1 /* Everything about breakpoints, for GDB.
3 Copyright (C) 1986-2020 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 (const 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
, const 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 free_bp_location (struct bp_location
*loc
);
176 static void incref_bp_location (struct bp_location
*loc
);
177 static void decref_bp_location (struct bp_location
**loc
);
179 static struct bp_location
*allocate_bp_location (struct breakpoint
*bpt
);
181 /* update_global_location_list's modes of operation wrt to whether to
182 insert locations now. */
183 enum ugll_insert_mode
185 /* Don't insert any breakpoint locations into the inferior, only
186 remove already-inserted locations that no longer should be
187 inserted. Functions that delete a breakpoint or breakpoints
188 should specify this mode, so that deleting a breakpoint doesn't
189 have the side effect of inserting the locations of other
190 breakpoints that are marked not-inserted, but should_be_inserted
191 returns true on them.
193 This behavior is useful is situations close to tear-down -- e.g.,
194 after an exec, while the target still has execution, but
195 breakpoint shadows of the previous executable image should *NOT*
196 be restored to the new image; or before detaching, where the
197 target still has execution and wants to delete breakpoints from
198 GDB's lists, and all breakpoints had already been removed from
202 /* May insert breakpoints iff breakpoints_should_be_inserted_now
203 claims breakpoints should be inserted now. */
206 /* Insert locations now, irrespective of
207 breakpoints_should_be_inserted_now. E.g., say all threads are
208 stopped right now, and the user did "continue". We need to
209 insert breakpoints _before_ resuming the target, but
210 UGLL_MAY_INSERT wouldn't insert them, because
211 breakpoints_should_be_inserted_now returns false at that point,
212 as no thread is running yet. */
216 static void update_global_location_list (enum ugll_insert_mode
);
218 static void update_global_location_list_nothrow (enum ugll_insert_mode
);
220 static void insert_breakpoint_locations (void);
222 static void trace_pass_command (const char *, int);
224 static void set_tracepoint_count (int num
);
226 static bool is_masked_watchpoint (const struct breakpoint
*b
);
228 static struct bp_location
**get_first_locp_gte_addr (CORE_ADDR address
);
230 /* Return 1 if B refers to a static tracepoint set by marker ("-m"), zero
233 static int strace_marker_p (struct breakpoint
*b
);
235 /* The breakpoint_ops structure to be inherited by all breakpoint_ops
236 that are implemented on top of software or hardware breakpoints
237 (user breakpoints, internal and momentary breakpoints, etc.). */
238 static struct breakpoint_ops bkpt_base_breakpoint_ops
;
240 /* Internal breakpoints class type. */
241 static struct breakpoint_ops internal_breakpoint_ops
;
243 /* Momentary breakpoints class type. */
244 static struct breakpoint_ops momentary_breakpoint_ops
;
246 /* The breakpoint_ops structure to be used in regular user created
248 struct breakpoint_ops bkpt_breakpoint_ops
;
250 /* Breakpoints set on probes. */
251 static struct breakpoint_ops bkpt_probe_breakpoint_ops
;
253 /* Tracepoints set on probes. */
254 static struct breakpoint_ops tracepoint_probe_breakpoint_ops
;
256 /* Dynamic printf class type. */
257 struct breakpoint_ops dprintf_breakpoint_ops
;
259 /* The style in which to perform a dynamic printf. This is a user
260 option because different output options have different tradeoffs;
261 if GDB does the printing, there is better error handling if there
262 is a problem with any of the arguments, but using an inferior
263 function lets you have special-purpose printers and sending of
264 output to the same place as compiled-in print functions. */
266 static const char dprintf_style_gdb
[] = "gdb";
267 static const char dprintf_style_call
[] = "call";
268 static const char dprintf_style_agent
[] = "agent";
269 static const char *const dprintf_style_enums
[] = {
275 static const char *dprintf_style
= dprintf_style_gdb
;
277 /* The function to use for dynamic printf if the preferred style is to
278 call into the inferior. The value is simply a string that is
279 copied into the command, so it can be anything that GDB can
280 evaluate to a callable address, not necessarily a function name. */
282 static char *dprintf_function
;
284 /* The channel to use for dynamic printf if the preferred style is to
285 call into the inferior; if a nonempty string, it will be passed to
286 the call as the first argument, with the format string as the
287 second. As with the dprintf function, this can be anything that
288 GDB knows how to evaluate, so in addition to common choices like
289 "stderr", this could be an app-specific expression like
290 "mystreams[curlogger]". */
292 static char *dprintf_channel
;
294 /* True if dprintf commands should continue to operate even if GDB
296 static bool disconnected_dprintf
= true;
298 struct command_line
*
299 breakpoint_commands (struct breakpoint
*b
)
301 return b
->commands
? b
->commands
.get () : NULL
;
304 /* Flag indicating that a command has proceeded the inferior past the
305 current breakpoint. */
307 static bool breakpoint_proceeded
;
310 bpdisp_text (enum bpdisp disp
)
312 /* NOTE: the following values are a part of MI protocol and
313 represent values of 'disp' field returned when inferior stops at
315 static const char * const bpdisps
[] = {"del", "dstp", "dis", "keep"};
317 return bpdisps
[(int) disp
];
320 /* Prototypes for exported functions. */
321 /* If FALSE, gdb will not use hardware support for watchpoints, even
322 if such is available. */
323 static int can_use_hw_watchpoints
;
326 show_can_use_hw_watchpoints (struct ui_file
*file
, int from_tty
,
327 struct cmd_list_element
*c
,
330 fprintf_filtered (file
,
331 _("Debugger's willingness to use "
332 "watchpoint hardware is %s.\n"),
336 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
337 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
338 for unrecognized breakpoint locations.
339 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
340 static enum auto_boolean pending_break_support
;
342 show_pending_break_support (struct ui_file
*file
, int from_tty
,
343 struct cmd_list_element
*c
,
346 fprintf_filtered (file
,
347 _("Debugger's behavior regarding "
348 "pending breakpoints is %s.\n"),
352 /* If true, gdb will automatically use hardware breakpoints for breakpoints
353 set with "break" but falling in read-only memory.
354 If false, gdb will warn about such breakpoints, but won't automatically
355 use hardware breakpoints. */
356 static bool automatic_hardware_breakpoints
;
358 show_automatic_hardware_breakpoints (struct ui_file
*file
, int from_tty
,
359 struct cmd_list_element
*c
,
362 fprintf_filtered (file
,
363 _("Automatic usage of hardware breakpoints is %s.\n"),
367 /* If on, GDB keeps breakpoints inserted even if the inferior is
368 stopped, and immediately inserts any new breakpoints as soon as
369 they're created. If off (default), GDB keeps breakpoints off of
370 the target as long as possible. That is, it delays inserting
371 breakpoints until the next resume, and removes them again when the
372 target fully stops. This is a bit safer in case GDB crashes while
373 processing user input. */
374 static bool always_inserted_mode
= false;
377 show_always_inserted_mode (struct ui_file
*file
, int from_tty
,
378 struct cmd_list_element
*c
, const char *value
)
380 fprintf_filtered (file
, _("Always inserted breakpoint mode is %s.\n"),
384 /* See breakpoint.h. */
387 breakpoints_should_be_inserted_now (void)
389 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
391 /* If breakpoints are global, they should be inserted even if no
392 thread under gdb's control is running, or even if there are
393 no threads under GDB's control yet. */
398 if (always_inserted_mode
)
400 /* The user wants breakpoints inserted even if all threads
405 for (inferior
*inf
: all_inferiors ())
406 if (inf
->has_execution ()
407 && threads_are_executing (inf
->process_target ()))
410 /* Don't remove breakpoints yet if, even though all threads are
411 stopped, we still have events to process. */
412 for (thread_info
*tp
: all_non_exited_threads ())
414 && tp
->suspend
.waitstatus_pending_p
)
420 static const char condition_evaluation_both
[] = "host or target";
422 /* Modes for breakpoint condition evaluation. */
423 static const char condition_evaluation_auto
[] = "auto";
424 static const char condition_evaluation_host
[] = "host";
425 static const char condition_evaluation_target
[] = "target";
426 static const char *const condition_evaluation_enums
[] = {
427 condition_evaluation_auto
,
428 condition_evaluation_host
,
429 condition_evaluation_target
,
433 /* Global that holds the current mode for breakpoint condition evaluation. */
434 static const char *condition_evaluation_mode_1
= condition_evaluation_auto
;
436 /* Global that we use to display information to the user (gets its value from
437 condition_evaluation_mode_1. */
438 static const char *condition_evaluation_mode
= condition_evaluation_auto
;
440 /* Translate a condition evaluation mode MODE into either "host"
441 or "target". This is used mostly to translate from "auto" to the
442 real setting that is being used. It returns the translated
446 translate_condition_evaluation_mode (const char *mode
)
448 if (mode
== condition_evaluation_auto
)
450 if (target_supports_evaluation_of_breakpoint_conditions ())
451 return condition_evaluation_target
;
453 return condition_evaluation_host
;
459 /* Discovers what condition_evaluation_auto translates to. */
462 breakpoint_condition_evaluation_mode (void)
464 return translate_condition_evaluation_mode (condition_evaluation_mode
);
467 /* Return true if GDB should evaluate breakpoint conditions or false
471 gdb_evaluates_breakpoint_condition_p (void)
473 const char *mode
= breakpoint_condition_evaluation_mode ();
475 return (mode
== condition_evaluation_host
);
478 /* Are we executing breakpoint commands? */
479 static int executing_breakpoint_commands
;
481 /* Are overlay event breakpoints enabled? */
482 static int overlay_events_enabled
;
484 /* See description in breakpoint.h. */
485 bool target_exact_watchpoints
= false;
487 /* Walk the following statement or block through all breakpoints.
488 ALL_BREAKPOINTS_SAFE does so even if the statement deletes the
489 current breakpoint. */
491 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
493 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
494 for (B = breakpoint_chain; \
495 B ? (TMP=B->next, 1): 0; \
498 /* Similar iterator for the low-level breakpoints. SAFE variant is
499 not provided so update_global_location_list must not be called
500 while executing the block of ALL_BP_LOCATIONS. */
502 #define ALL_BP_LOCATIONS(B,BP_TMP) \
503 for (BP_TMP = bp_locations; \
504 BP_TMP < bp_locations + bp_locations_count && (B = *BP_TMP);\
507 /* Iterates through locations with address ADDRESS for the currently selected
508 program space. BP_LOCP_TMP points to each object. BP_LOCP_START points
509 to where the loop should start from.
510 If BP_LOCP_START is a NULL pointer, the macro automatically seeks the
511 appropriate location to start with. */
513 #define ALL_BP_LOCATIONS_AT_ADDR(BP_LOCP_TMP, BP_LOCP_START, ADDRESS) \
514 for (BP_LOCP_START = BP_LOCP_START == NULL ? get_first_locp_gte_addr (ADDRESS) : BP_LOCP_START, \
515 BP_LOCP_TMP = BP_LOCP_START; \
517 && (BP_LOCP_TMP < bp_locations + bp_locations_count \
518 && (*BP_LOCP_TMP)->address == ADDRESS); \
521 /* Iterator for tracepoints only. */
523 #define ALL_TRACEPOINTS(B) \
524 for (B = breakpoint_chain; B; B = B->next) \
525 if (is_tracepoint (B))
527 /* Chains of all breakpoints defined. */
529 static struct breakpoint
*breakpoint_chain
;
531 /* Array is sorted by bp_location_is_less_than - primarily by the ADDRESS. */
533 static struct bp_location
**bp_locations
;
535 /* Number of elements of BP_LOCATIONS. */
537 static unsigned bp_locations_count
;
539 /* Maximum alignment offset between bp_target_info.PLACED_ADDRESS and
540 ADDRESS for the current elements of BP_LOCATIONS which get a valid
541 result from bp_location_has_shadow. You can use it for roughly
542 limiting the subrange of BP_LOCATIONS to scan for shadow bytes for
543 an address you need to read. */
545 static CORE_ADDR bp_locations_placed_address_before_address_max
;
547 /* Maximum offset plus alignment between bp_target_info.PLACED_ADDRESS
548 + bp_target_info.SHADOW_LEN and ADDRESS for the current elements of
549 BP_LOCATIONS which get a valid result from bp_location_has_shadow.
550 You can use it for roughly limiting the subrange of BP_LOCATIONS to
551 scan for shadow bytes for an address you need to read. */
553 static CORE_ADDR bp_locations_shadow_len_after_address_max
;
555 /* The locations that no longer correspond to any breakpoint, unlinked
556 from the bp_locations array, but for which a hit may still be
557 reported by a target. */
558 static std::vector
<bp_location
*> moribund_locations
;
560 /* Number of last breakpoint made. */
562 static int breakpoint_count
;
564 /* The value of `breakpoint_count' before the last command that
565 created breakpoints. If the last (break-like) command created more
566 than one breakpoint, then the difference between BREAKPOINT_COUNT
567 and PREV_BREAKPOINT_COUNT is more than one. */
568 static int prev_breakpoint_count
;
570 /* Number of last tracepoint made. */
572 static int tracepoint_count
;
574 static struct cmd_list_element
*breakpoint_set_cmdlist
;
575 static struct cmd_list_element
*breakpoint_show_cmdlist
;
576 struct cmd_list_element
*save_cmdlist
;
578 /* See declaration at breakpoint.h. */
581 breakpoint_find_if (int (*func
) (struct breakpoint
*b
, void *d
),
584 struct breakpoint
*b
= NULL
;
588 if (func (b
, user_data
) != 0)
595 /* Return whether a breakpoint is an active enabled breakpoint. */
597 breakpoint_enabled (struct breakpoint
*b
)
599 return (b
->enable_state
== bp_enabled
);
602 /* Set breakpoint count to NUM. */
605 set_breakpoint_count (int num
)
607 prev_breakpoint_count
= breakpoint_count
;
608 breakpoint_count
= num
;
609 set_internalvar_integer (lookup_internalvar ("bpnum"), num
);
612 /* Used by `start_rbreak_breakpoints' below, to record the current
613 breakpoint count before "rbreak" creates any breakpoint. */
614 static int rbreak_start_breakpoint_count
;
616 /* Called at the start an "rbreak" command to record the first
619 scoped_rbreak_breakpoints::scoped_rbreak_breakpoints ()
621 rbreak_start_breakpoint_count
= breakpoint_count
;
624 /* Called at the end of an "rbreak" command to record the last
627 scoped_rbreak_breakpoints::~scoped_rbreak_breakpoints ()
629 prev_breakpoint_count
= rbreak_start_breakpoint_count
;
632 /* Used in run_command to zero the hit count when a new run starts. */
635 clear_breakpoint_hit_counts (void)
637 struct breakpoint
*b
;
644 /* Return the breakpoint with the specified number, or NULL
645 if the number does not refer to an existing breakpoint. */
648 get_breakpoint (int num
)
650 struct breakpoint
*b
;
653 if (b
->number
== num
)
661 /* Mark locations as "conditions have changed" in case the target supports
662 evaluating conditions on its side. */
665 mark_breakpoint_modified (struct breakpoint
*b
)
667 struct bp_location
*loc
;
669 /* This is only meaningful if the target is
670 evaluating conditions and if the user has
671 opted for condition evaluation on the target's
673 if (gdb_evaluates_breakpoint_condition_p ()
674 || !target_supports_evaluation_of_breakpoint_conditions ())
677 if (!is_breakpoint (b
))
680 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
681 loc
->condition_changed
= condition_modified
;
684 /* Mark location as "conditions have changed" in case the target supports
685 evaluating conditions on its side. */
688 mark_breakpoint_location_modified (struct bp_location
*loc
)
690 /* This is only meaningful if the target is
691 evaluating conditions and if the user has
692 opted for condition evaluation on the target's
694 if (gdb_evaluates_breakpoint_condition_p ()
695 || !target_supports_evaluation_of_breakpoint_conditions ())
699 if (!is_breakpoint (loc
->owner
))
702 loc
->condition_changed
= condition_modified
;
705 /* Sets the condition-evaluation mode using the static global
706 condition_evaluation_mode. */
709 set_condition_evaluation_mode (const char *args
, int from_tty
,
710 struct cmd_list_element
*c
)
712 const char *old_mode
, *new_mode
;
714 if ((condition_evaluation_mode_1
== condition_evaluation_target
)
715 && !target_supports_evaluation_of_breakpoint_conditions ())
717 condition_evaluation_mode_1
= condition_evaluation_mode
;
718 warning (_("Target does not support breakpoint condition evaluation.\n"
719 "Using host evaluation mode instead."));
723 new_mode
= translate_condition_evaluation_mode (condition_evaluation_mode_1
);
724 old_mode
= translate_condition_evaluation_mode (condition_evaluation_mode
);
726 /* Flip the switch. Flip it even if OLD_MODE == NEW_MODE as one of the
727 settings was "auto". */
728 condition_evaluation_mode
= condition_evaluation_mode_1
;
730 /* Only update the mode if the user picked a different one. */
731 if (new_mode
!= old_mode
)
733 struct bp_location
*loc
, **loc_tmp
;
734 /* If the user switched to a different evaluation mode, we
735 need to synch the changes with the target as follows:
737 "host" -> "target": Send all (valid) conditions to the target.
738 "target" -> "host": Remove all the conditions from the target.
741 if (new_mode
== condition_evaluation_target
)
743 /* Mark everything modified and synch conditions with the
745 ALL_BP_LOCATIONS (loc
, loc_tmp
)
746 mark_breakpoint_location_modified (loc
);
750 /* Manually mark non-duplicate locations to synch conditions
751 with the target. We do this to remove all the conditions the
752 target knows about. */
753 ALL_BP_LOCATIONS (loc
, loc_tmp
)
754 if (is_breakpoint (loc
->owner
) && loc
->inserted
)
755 loc
->needs_update
= 1;
759 update_global_location_list (UGLL_MAY_INSERT
);
765 /* Shows the current mode of breakpoint condition evaluation. Explicitly shows
766 what "auto" is translating to. */
769 show_condition_evaluation_mode (struct ui_file
*file
, int from_tty
,
770 struct cmd_list_element
*c
, const char *value
)
772 if (condition_evaluation_mode
== condition_evaluation_auto
)
773 fprintf_filtered (file
,
774 _("Breakpoint condition evaluation "
775 "mode is %s (currently %s).\n"),
777 breakpoint_condition_evaluation_mode ());
779 fprintf_filtered (file
, _("Breakpoint condition evaluation mode is %s.\n"),
783 /* A comparison function for bp_location AP and BP that is used by
784 bsearch. This comparison function only cares about addresses, unlike
785 the more general bp_location_is_less_than function. */
788 bp_locations_compare_addrs (const void *ap
, const void *bp
)
790 const struct bp_location
*a
= *(const struct bp_location
**) ap
;
791 const struct bp_location
*b
= *(const struct bp_location
**) bp
;
793 if (a
->address
== b
->address
)
796 return ((a
->address
> b
->address
) - (a
->address
< b
->address
));
799 /* Helper function to skip all bp_locations with addresses
800 less than ADDRESS. It returns the first bp_location that
801 is greater than or equal to ADDRESS. If none is found, just
804 static struct bp_location
**
805 get_first_locp_gte_addr (CORE_ADDR address
)
807 struct bp_location dummy_loc
;
808 struct bp_location
*dummy_locp
= &dummy_loc
;
809 struct bp_location
**locp_found
= NULL
;
811 /* Initialize the dummy location's address field. */
812 dummy_loc
.address
= address
;
814 /* Find a close match to the first location at ADDRESS. */
815 locp_found
= ((struct bp_location
**)
816 bsearch (&dummy_locp
, bp_locations
, bp_locations_count
,
817 sizeof (struct bp_location
**),
818 bp_locations_compare_addrs
));
820 /* Nothing was found, nothing left to do. */
821 if (locp_found
== NULL
)
824 /* We may have found a location that is at ADDRESS but is not the first in the
825 location's list. Go backwards (if possible) and locate the first one. */
826 while ((locp_found
- 1) >= bp_locations
827 && (*(locp_found
- 1))->address
== address
)
834 set_breakpoint_condition (struct breakpoint
*b
, const char *exp
,
837 xfree (b
->cond_string
);
838 b
->cond_string
= NULL
;
840 if (is_watchpoint (b
))
842 struct watchpoint
*w
= (struct watchpoint
*) b
;
844 w
->cond_exp
.reset ();
848 struct bp_location
*loc
;
850 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
854 /* No need to free the condition agent expression
855 bytecode (if we have one). We will handle this
856 when we go through update_global_location_list. */
863 printf_filtered (_("Breakpoint %d now unconditional.\n"), b
->number
);
867 const char *arg
= exp
;
869 /* I don't know if it matters whether this is the string the user
870 typed in or the decompiled expression. */
871 b
->cond_string
= xstrdup (arg
);
872 b
->condition_not_parsed
= 0;
874 if (is_watchpoint (b
))
876 struct watchpoint
*w
= (struct watchpoint
*) b
;
878 innermost_block_tracker tracker
;
880 w
->cond_exp
= parse_exp_1 (&arg
, 0, 0, 0, &tracker
);
882 error (_("Junk at end of expression"));
883 w
->cond_exp_valid_block
= tracker
.block ();
887 struct bp_location
*loc
;
889 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
893 parse_exp_1 (&arg
, loc
->address
,
894 block_for_pc (loc
->address
), 0);
896 error (_("Junk at end of expression"));
900 mark_breakpoint_modified (b
);
902 gdb::observers::breakpoint_modified
.notify (b
);
905 /* Completion for the "condition" command. */
908 condition_completer (struct cmd_list_element
*cmd
,
909 completion_tracker
&tracker
,
910 const char *text
, const char *word
)
914 text
= skip_spaces (text
);
915 space
= skip_to_space (text
);
919 struct breakpoint
*b
;
923 /* We don't support completion of history indices. */
924 if (!isdigit (text
[1]))
925 complete_internalvar (tracker
, &text
[1]);
929 /* We're completing the breakpoint number. */
936 xsnprintf (number
, sizeof (number
), "%d", b
->number
);
938 if (strncmp (number
, text
, len
) == 0)
939 tracker
.add_completion (make_unique_xstrdup (number
));
945 /* We're completing the expression part. */
946 text
= skip_spaces (space
);
947 expression_completer (cmd
, tracker
, text
, word
);
950 /* condition N EXP -- set break condition of breakpoint N to EXP. */
953 condition_command (const char *arg
, int from_tty
)
955 struct breakpoint
*b
;
960 error_no_arg (_("breakpoint number"));
963 bnum
= get_number (&p
);
965 error (_("Bad breakpoint argument: '%s'"), arg
);
968 if (b
->number
== bnum
)
970 /* Check if this breakpoint has a "stop" method implemented in an
971 extension language. This method and conditions entered into GDB
972 from the CLI are mutually exclusive. */
973 const struct extension_language_defn
*extlang
974 = get_breakpoint_cond_ext_lang (b
, EXT_LANG_NONE
);
978 error (_("Only one stop condition allowed. There is currently"
979 " a %s stop condition defined for this breakpoint."),
980 ext_lang_capitalized_name (extlang
));
982 set_breakpoint_condition (b
, p
, from_tty
);
984 if (is_breakpoint (b
))
985 update_global_location_list (UGLL_MAY_INSERT
);
990 error (_("No breakpoint number %d."), bnum
);
993 /* Check that COMMAND do not contain commands that are suitable
994 only for tracepoints and not suitable for ordinary breakpoints.
995 Throw if any such commands is found. */
998 check_no_tracepoint_commands (struct command_line
*commands
)
1000 struct command_line
*c
;
1002 for (c
= commands
; c
; c
= c
->next
)
1004 if (c
->control_type
== while_stepping_control
)
1005 error (_("The 'while-stepping' command can "
1006 "only be used for tracepoints"));
1008 check_no_tracepoint_commands (c
->body_list_0
.get ());
1009 check_no_tracepoint_commands (c
->body_list_1
.get ());
1011 /* Not that command parsing removes leading whitespace and comment
1012 lines and also empty lines. So, we only need to check for
1013 command directly. */
1014 if (strstr (c
->line
, "collect ") == c
->line
)
1015 error (_("The 'collect' command can only be used for tracepoints"));
1017 if (strstr (c
->line
, "teval ") == c
->line
)
1018 error (_("The 'teval' command can only be used for tracepoints"));
1022 struct longjmp_breakpoint
: public breakpoint
1024 ~longjmp_breakpoint () override
;
1027 /* Encapsulate tests for different types of tracepoints. */
1030 is_tracepoint_type (bptype type
)
1032 return (type
== bp_tracepoint
1033 || type
== bp_fast_tracepoint
1034 || type
== bp_static_tracepoint
);
1038 is_longjmp_type (bptype type
)
1040 return type
== bp_longjmp
|| type
== bp_exception
;
1043 /* See breakpoint.h. */
1046 is_tracepoint (const struct breakpoint
*b
)
1048 return is_tracepoint_type (b
->type
);
1051 /* Factory function to create an appropriate instance of breakpoint given
1054 static std::unique_ptr
<breakpoint
>
1055 new_breakpoint_from_type (bptype type
)
1059 if (is_tracepoint_type (type
))
1060 b
= new tracepoint ();
1061 else if (is_longjmp_type (type
))
1062 b
= new longjmp_breakpoint ();
1064 b
= new breakpoint ();
1066 return std::unique_ptr
<breakpoint
> (b
);
1069 /* A helper function that validates that COMMANDS are valid for a
1070 breakpoint. This function will throw an exception if a problem is
1074 validate_commands_for_breakpoint (struct breakpoint
*b
,
1075 struct command_line
*commands
)
1077 if (is_tracepoint (b
))
1079 struct tracepoint
*t
= (struct tracepoint
*) b
;
1080 struct command_line
*c
;
1081 struct command_line
*while_stepping
= 0;
1083 /* Reset the while-stepping step count. The previous commands
1084 might have included a while-stepping action, while the new
1088 /* We need to verify that each top-level element of commands is
1089 valid for tracepoints, that there's at most one
1090 while-stepping element, and that the while-stepping's body
1091 has valid tracing commands excluding nested while-stepping.
1092 We also need to validate the tracepoint action line in the
1093 context of the tracepoint --- validate_actionline actually
1094 has side effects, like setting the tracepoint's
1095 while-stepping STEP_COUNT, in addition to checking if the
1096 collect/teval actions parse and make sense in the
1097 tracepoint's context. */
1098 for (c
= commands
; c
; c
= c
->next
)
1100 if (c
->control_type
== while_stepping_control
)
1102 if (b
->type
== bp_fast_tracepoint
)
1103 error (_("The 'while-stepping' command "
1104 "cannot be used for fast tracepoint"));
1105 else if (b
->type
== bp_static_tracepoint
)
1106 error (_("The 'while-stepping' command "
1107 "cannot be used for static tracepoint"));
1110 error (_("The 'while-stepping' command "
1111 "can be used only once"));
1116 validate_actionline (c
->line
, b
);
1120 struct command_line
*c2
;
1122 gdb_assert (while_stepping
->body_list_1
== nullptr);
1123 c2
= while_stepping
->body_list_0
.get ();
1124 for (; c2
; c2
= c2
->next
)
1126 if (c2
->control_type
== while_stepping_control
)
1127 error (_("The 'while-stepping' command cannot be nested"));
1133 check_no_tracepoint_commands (commands
);
1137 /* Return a vector of all the static tracepoints set at ADDR. The
1138 caller is responsible for releasing the vector. */
1140 std::vector
<breakpoint
*>
1141 static_tracepoints_here (CORE_ADDR addr
)
1143 struct breakpoint
*b
;
1144 std::vector
<breakpoint
*> found
;
1145 struct bp_location
*loc
;
1148 if (b
->type
== bp_static_tracepoint
)
1150 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1151 if (loc
->address
== addr
)
1152 found
.push_back (b
);
1158 /* Set the command list of B to COMMANDS. If breakpoint is tracepoint,
1159 validate that only allowed commands are included. */
1162 breakpoint_set_commands (struct breakpoint
*b
,
1163 counted_command_line
&&commands
)
1165 validate_commands_for_breakpoint (b
, commands
.get ());
1167 b
->commands
= std::move (commands
);
1168 gdb::observers::breakpoint_modified
.notify (b
);
1171 /* Set the internal `silent' flag on the breakpoint. Note that this
1172 is not the same as the "silent" that may appear in the breakpoint's
1176 breakpoint_set_silent (struct breakpoint
*b
, int silent
)
1178 int old_silent
= b
->silent
;
1181 if (old_silent
!= silent
)
1182 gdb::observers::breakpoint_modified
.notify (b
);
1185 /* Set the thread for this breakpoint. If THREAD is -1, make the
1186 breakpoint work for any thread. */
1189 breakpoint_set_thread (struct breakpoint
*b
, int thread
)
1191 int old_thread
= b
->thread
;
1194 if (old_thread
!= thread
)
1195 gdb::observers::breakpoint_modified
.notify (b
);
1198 /* Set the task for this breakpoint. If TASK is 0, make the
1199 breakpoint work for any task. */
1202 breakpoint_set_task (struct breakpoint
*b
, int task
)
1204 int old_task
= b
->task
;
1207 if (old_task
!= task
)
1208 gdb::observers::breakpoint_modified
.notify (b
);
1212 commands_command_1 (const char *arg
, int from_tty
,
1213 struct command_line
*control
)
1215 counted_command_line cmd
;
1216 /* cmd_read will be true once we have read cmd. Note that cmd might still be
1217 NULL after the call to read_command_lines if the user provides an empty
1218 list of command by just typing "end". */
1219 bool cmd_read
= false;
1221 std::string new_arg
;
1223 if (arg
== NULL
|| !*arg
)
1225 if (breakpoint_count
- prev_breakpoint_count
> 1)
1226 new_arg
= string_printf ("%d-%d", prev_breakpoint_count
+ 1,
1228 else if (breakpoint_count
> 0)
1229 new_arg
= string_printf ("%d", breakpoint_count
);
1230 arg
= new_arg
.c_str ();
1233 map_breakpoint_numbers
1234 (arg
, [&] (breakpoint
*b
)
1238 gdb_assert (cmd
== NULL
);
1239 if (control
!= NULL
)
1240 cmd
= control
->body_list_0
;
1244 = string_printf (_("Type commands for breakpoint(s) "
1245 "%s, one per line."),
1248 auto do_validate
= [=] (const char *line
)
1250 validate_actionline (line
, b
);
1252 gdb::function_view
<void (const char *)> validator
;
1253 if (is_tracepoint (b
))
1254 validator
= do_validate
;
1256 cmd
= read_command_lines (str
.c_str (), from_tty
, 1, validator
);
1261 /* If a breakpoint was on the list more than once, we don't need to
1263 if (b
->commands
!= cmd
)
1265 validate_commands_for_breakpoint (b
, cmd
.get ());
1267 gdb::observers::breakpoint_modified
.notify (b
);
1273 commands_command (const char *arg
, int from_tty
)
1275 commands_command_1 (arg
, from_tty
, NULL
);
1278 /* Like commands_command, but instead of reading the commands from
1279 input stream, takes them from an already parsed command structure.
1281 This is used by cli-script.c to DTRT with breakpoint commands
1282 that are part of if and while bodies. */
1283 enum command_control_type
1284 commands_from_control_command (const char *arg
, struct command_line
*cmd
)
1286 commands_command_1 (arg
, 0, cmd
);
1287 return simple_control
;
1290 /* Return non-zero if BL->TARGET_INFO contains valid information. */
1293 bp_location_has_shadow (struct bp_location
*bl
)
1295 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
1299 if (bl
->target_info
.shadow_len
== 0)
1300 /* BL isn't valid, or doesn't shadow memory. */
1305 /* Update BUF, which is LEN bytes read from the target address
1306 MEMADDR, by replacing a memory breakpoint with its shadowed
1309 If READBUF is not NULL, this buffer must not overlap with the of
1310 the breakpoint location's shadow_contents buffer. Otherwise, a
1311 failed assertion internal error will be raised. */
1314 one_breakpoint_xfer_memory (gdb_byte
*readbuf
, gdb_byte
*writebuf
,
1315 const gdb_byte
*writebuf_org
,
1316 ULONGEST memaddr
, LONGEST len
,
1317 struct bp_target_info
*target_info
,
1318 struct gdbarch
*gdbarch
)
1320 /* Now do full processing of the found relevant range of elements. */
1321 CORE_ADDR bp_addr
= 0;
1325 if (!breakpoint_address_match (target_info
->placed_address_space
, 0,
1326 current_program_space
->aspace
, 0))
1328 /* The breakpoint is inserted in a different address space. */
1332 /* Addresses and length of the part of the breakpoint that
1334 bp_addr
= target_info
->placed_address
;
1335 bp_size
= target_info
->shadow_len
;
1337 if (bp_addr
+ bp_size
<= memaddr
)
1339 /* The breakpoint is entirely before the chunk of memory we are
1344 if (bp_addr
>= memaddr
+ len
)
1346 /* The breakpoint is entirely after the chunk of memory we are
1351 /* Offset within shadow_contents. */
1352 if (bp_addr
< memaddr
)
1354 /* Only copy the second part of the breakpoint. */
1355 bp_size
-= memaddr
- bp_addr
;
1356 bptoffset
= memaddr
- bp_addr
;
1360 if (bp_addr
+ bp_size
> memaddr
+ len
)
1362 /* Only copy the first part of the breakpoint. */
1363 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
1366 if (readbuf
!= NULL
)
1368 /* Verify that the readbuf buffer does not overlap with the
1369 shadow_contents buffer. */
1370 gdb_assert (target_info
->shadow_contents
>= readbuf
+ len
1371 || readbuf
>= (target_info
->shadow_contents
1372 + target_info
->shadow_len
));
1374 /* Update the read buffer with this inserted breakpoint's
1376 memcpy (readbuf
+ bp_addr
- memaddr
,
1377 target_info
->shadow_contents
+ bptoffset
, bp_size
);
1381 const unsigned char *bp
;
1382 CORE_ADDR addr
= target_info
->reqstd_address
;
1385 /* Update the shadow with what we want to write to memory. */
1386 memcpy (target_info
->shadow_contents
+ bptoffset
,
1387 writebuf_org
+ bp_addr
- memaddr
, bp_size
);
1389 /* Determine appropriate breakpoint contents and size for this
1391 bp
= gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &placed_size
);
1393 /* Update the final write buffer with this inserted
1394 breakpoint's INSN. */
1395 memcpy (writebuf
+ bp_addr
- memaddr
, bp
+ bptoffset
, bp_size
);
1399 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
1400 by replacing any memory breakpoints with their shadowed contents.
1402 If READBUF is not NULL, this buffer must not overlap with any of
1403 the breakpoint location's shadow_contents buffers. Otherwise,
1404 a failed assertion internal error will be raised.
1406 The range of shadowed area by each bp_location is:
1407 bl->address - bp_locations_placed_address_before_address_max
1408 up to bl->address + bp_locations_shadow_len_after_address_max
1409 The range we were requested to resolve shadows for is:
1410 memaddr ... memaddr + len
1411 Thus the safe cutoff boundaries for performance optimization are
1412 memaddr + len <= (bl->address
1413 - bp_locations_placed_address_before_address_max)
1415 bl->address + bp_locations_shadow_len_after_address_max <= memaddr */
1418 breakpoint_xfer_memory (gdb_byte
*readbuf
, gdb_byte
*writebuf
,
1419 const gdb_byte
*writebuf_org
,
1420 ULONGEST memaddr
, LONGEST len
)
1422 /* Left boundary, right boundary and median element of our binary
1424 unsigned bc_l
, bc_r
, bc
;
1426 /* Find BC_L which is a leftmost element which may affect BUF
1427 content. It is safe to report lower value but a failure to
1428 report higher one. */
1431 bc_r
= bp_locations_count
;
1432 while (bc_l
+ 1 < bc_r
)
1434 struct bp_location
*bl
;
1436 bc
= (bc_l
+ bc_r
) / 2;
1437 bl
= bp_locations
[bc
];
1439 /* Check first BL->ADDRESS will not overflow due to the added
1440 constant. Then advance the left boundary only if we are sure
1441 the BC element can in no way affect the BUF content (MEMADDR
1442 to MEMADDR + LEN range).
1444 Use the BP_LOCATIONS_SHADOW_LEN_AFTER_ADDRESS_MAX safety
1445 offset so that we cannot miss a breakpoint with its shadow
1446 range tail still reaching MEMADDR. */
1448 if ((bl
->address
+ bp_locations_shadow_len_after_address_max
1450 && (bl
->address
+ bp_locations_shadow_len_after_address_max
1457 /* Due to the binary search above, we need to make sure we pick the
1458 first location that's at BC_L's address. E.g., if there are
1459 multiple locations at the same address, BC_L may end up pointing
1460 at a duplicate location, and miss the "master"/"inserted"
1461 location. Say, given locations L1, L2 and L3 at addresses A and
1464 L1@A, L2@A, L3@B, ...
1466 BC_L could end up pointing at location L2, while the "master"
1467 location could be L1. Since the `loc->inserted' flag is only set
1468 on "master" locations, we'd forget to restore the shadow of L1
1471 && bp_locations
[bc_l
]->address
== bp_locations
[bc_l
- 1]->address
)
1474 /* Now do full processing of the found relevant range of elements. */
1476 for (bc
= bc_l
; bc
< bp_locations_count
; bc
++)
1478 struct bp_location
*bl
= bp_locations
[bc
];
1480 /* bp_location array has BL->OWNER always non-NULL. */
1481 if (bl
->owner
->type
== bp_none
)
1482 warning (_("reading through apparently deleted breakpoint #%d?"),
1485 /* Performance optimization: any further element can no longer affect BUF
1488 if (bl
->address
>= bp_locations_placed_address_before_address_max
1489 && memaddr
+ len
<= (bl
->address
1490 - bp_locations_placed_address_before_address_max
))
1493 if (!bp_location_has_shadow (bl
))
1496 one_breakpoint_xfer_memory (readbuf
, writebuf
, writebuf_org
,
1497 memaddr
, len
, &bl
->target_info
, bl
->gdbarch
);
1501 /* See breakpoint.h. */
1504 is_breakpoint (const struct breakpoint
*bpt
)
1506 return (bpt
->type
== bp_breakpoint
1507 || bpt
->type
== bp_hardware_breakpoint
1508 || bpt
->type
== bp_dprintf
);
1511 /* Return true if BPT is of any hardware watchpoint kind. */
1514 is_hardware_watchpoint (const struct breakpoint
*bpt
)
1516 return (bpt
->type
== bp_hardware_watchpoint
1517 || bpt
->type
== bp_read_watchpoint
1518 || bpt
->type
== bp_access_watchpoint
);
1521 /* See breakpoint.h. */
1524 is_watchpoint (const struct breakpoint
*bpt
)
1526 return (is_hardware_watchpoint (bpt
)
1527 || bpt
->type
== bp_watchpoint
);
1530 /* Returns true if the current thread and its running state are safe
1531 to evaluate or update watchpoint B. Watchpoints on local
1532 expressions need to be evaluated in the context of the thread that
1533 was current when the watchpoint was created, and, that thread needs
1534 to be stopped to be able to select the correct frame context.
1535 Watchpoints on global expressions can be evaluated on any thread,
1536 and in any state. It is presently left to the target allowing
1537 memory accesses when threads are running. */
1540 watchpoint_in_thread_scope (struct watchpoint
*b
)
1542 return (b
->pspace
== current_program_space
1543 && (b
->watchpoint_thread
== null_ptid
1544 || (inferior_ptid
== b
->watchpoint_thread
1545 && !inferior_thread ()->executing
)));
1548 /* Set watchpoint B to disp_del_at_next_stop, even including its possible
1549 associated bp_watchpoint_scope breakpoint. */
1552 watchpoint_del_at_next_stop (struct watchpoint
*w
)
1554 if (w
->related_breakpoint
!= w
)
1556 gdb_assert (w
->related_breakpoint
->type
== bp_watchpoint_scope
);
1557 gdb_assert (w
->related_breakpoint
->related_breakpoint
== w
);
1558 w
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
1559 w
->related_breakpoint
->related_breakpoint
= w
->related_breakpoint
;
1560 w
->related_breakpoint
= w
;
1562 w
->disposition
= disp_del_at_next_stop
;
1565 /* Extract a bitfield value from value VAL using the bit parameters contained in
1568 static struct value
*
1569 extract_bitfield_from_watchpoint_value (struct watchpoint
*w
, struct value
*val
)
1571 struct value
*bit_val
;
1576 bit_val
= allocate_value (value_type (val
));
1578 unpack_value_bitfield (bit_val
,
1581 value_contents_for_printing (val
),
1588 /* Allocate a dummy location and add it to B, which must be a software
1589 watchpoint. This is required because even if a software watchpoint
1590 is not watching any memory, bpstat_stop_status requires a location
1591 to be able to report stops. */
1594 software_watchpoint_add_no_memory_location (struct breakpoint
*b
,
1595 struct program_space
*pspace
)
1597 gdb_assert (b
->type
== bp_watchpoint
&& b
->loc
== NULL
);
1599 b
->loc
= allocate_bp_location (b
);
1600 b
->loc
->pspace
= pspace
;
1601 b
->loc
->address
= -1;
1602 b
->loc
->length
= -1;
1605 /* Returns true if B is a software watchpoint that is not watching any
1606 memory (e.g., "watch $pc"). */
1609 is_no_memory_software_watchpoint (struct breakpoint
*b
)
1611 return (b
->type
== bp_watchpoint
1613 && b
->loc
->next
== NULL
1614 && b
->loc
->address
== -1
1615 && b
->loc
->length
== -1);
1618 /* Assuming that B is a watchpoint:
1619 - Reparse watchpoint expression, if REPARSE is non-zero
1620 - Evaluate expression and store the result in B->val
1621 - Evaluate the condition if there is one, and store the result
1623 - Update the list of values that must be watched in B->loc.
1625 If the watchpoint disposition is disp_del_at_next_stop, then do
1626 nothing. If this is local watchpoint that is out of scope, delete
1629 Even with `set breakpoint always-inserted on' the watchpoints are
1630 removed + inserted on each stop here. Normal breakpoints must
1631 never be removed because they might be missed by a running thread
1632 when debugging in non-stop mode. On the other hand, hardware
1633 watchpoints (is_hardware_watchpoint; processed here) are specific
1634 to each LWP since they are stored in each LWP's hardware debug
1635 registers. Therefore, such LWP must be stopped first in order to
1636 be able to modify its hardware watchpoints.
1638 Hardware watchpoints must be reset exactly once after being
1639 presented to the user. It cannot be done sooner, because it would
1640 reset the data used to present the watchpoint hit to the user. And
1641 it must not be done later because it could display the same single
1642 watchpoint hit during multiple GDB stops. Note that the latter is
1643 relevant only to the hardware watchpoint types bp_read_watchpoint
1644 and bp_access_watchpoint. False hit by bp_hardware_watchpoint is
1645 not user-visible - its hit is suppressed if the memory content has
1648 The following constraints influence the location where we can reset
1649 hardware watchpoints:
1651 * target_stopped_by_watchpoint and target_stopped_data_address are
1652 called several times when GDB stops.
1655 * Multiple hardware watchpoints can be hit at the same time,
1656 causing GDB to stop. GDB only presents one hardware watchpoint
1657 hit at a time as the reason for stopping, and all the other hits
1658 are presented later, one after the other, each time the user
1659 requests the execution to be resumed. Execution is not resumed
1660 for the threads still having pending hit event stored in
1661 LWP_INFO->STATUS. While the watchpoint is already removed from
1662 the inferior on the first stop the thread hit event is kept being
1663 reported from its cached value by linux_nat_stopped_data_address
1664 until the real thread resume happens after the watchpoint gets
1665 presented and thus its LWP_INFO->STATUS gets reset.
1667 Therefore the hardware watchpoint hit can get safely reset on the
1668 watchpoint removal from inferior. */
1671 update_watchpoint (struct watchpoint
*b
, int reparse
)
1673 int within_current_scope
;
1674 struct frame_id saved_frame_id
;
1677 /* If this is a local watchpoint, we only want to check if the
1678 watchpoint frame is in scope if the current thread is the thread
1679 that was used to create the watchpoint. */
1680 if (!watchpoint_in_thread_scope (b
))
1683 if (b
->disposition
== disp_del_at_next_stop
)
1688 /* Determine if the watchpoint is within scope. */
1689 if (b
->exp_valid_block
== NULL
)
1690 within_current_scope
= 1;
1693 struct frame_info
*fi
= get_current_frame ();
1694 struct gdbarch
*frame_arch
= get_frame_arch (fi
);
1695 CORE_ADDR frame_pc
= get_frame_pc (fi
);
1697 /* If we're at a point where the stack has been destroyed
1698 (e.g. in a function epilogue), unwinding may not work
1699 properly. Do not attempt to recreate locations at this
1700 point. See similar comments in watchpoint_check. */
1701 if (gdbarch_stack_frame_destroyed_p (frame_arch
, frame_pc
))
1704 /* Save the current frame's ID so we can restore it after
1705 evaluating the watchpoint expression on its own frame. */
1706 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
1707 took a frame parameter, so that we didn't have to change the
1710 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
1712 fi
= frame_find_by_id (b
->watchpoint_frame
);
1713 within_current_scope
= (fi
!= NULL
);
1714 if (within_current_scope
)
1718 /* We don't free locations. They are stored in the bp_location array
1719 and update_global_location_list will eventually delete them and
1720 remove breakpoints if needed. */
1723 if (within_current_scope
&& reparse
)
1728 s
= b
->exp_string_reparse
? b
->exp_string_reparse
: b
->exp_string
;
1729 b
->exp
= parse_exp_1 (&s
, 0, b
->exp_valid_block
, 0);
1730 /* If the meaning of expression itself changed, the old value is
1731 no longer relevant. We don't want to report a watchpoint hit
1732 to the user when the old value and the new value may actually
1733 be completely different objects. */
1735 b
->val_valid
= false;
1737 /* Note that unlike with breakpoints, the watchpoint's condition
1738 expression is stored in the breakpoint object, not in the
1739 locations (re)created below. */
1740 if (b
->cond_string
!= NULL
)
1742 b
->cond_exp
.reset ();
1745 b
->cond_exp
= parse_exp_1 (&s
, 0, b
->cond_exp_valid_block
, 0);
1749 /* If we failed to parse the expression, for example because
1750 it refers to a global variable in a not-yet-loaded shared library,
1751 don't try to insert watchpoint. We don't automatically delete
1752 such watchpoint, though, since failure to parse expression
1753 is different from out-of-scope watchpoint. */
1754 if (!target_has_execution
)
1756 /* Without execution, memory can't change. No use to try and
1757 set watchpoint locations. The watchpoint will be reset when
1758 the target gains execution, through breakpoint_re_set. */
1759 if (!can_use_hw_watchpoints
)
1761 if (b
->ops
->works_in_software_mode (b
))
1762 b
->type
= bp_watchpoint
;
1764 error (_("Can't set read/access watchpoint when "
1765 "hardware watchpoints are disabled."));
1768 else if (within_current_scope
&& b
->exp
)
1771 std::vector
<value_ref_ptr
> val_chain
;
1772 struct value
*v
, *result
;
1773 struct program_space
*frame_pspace
;
1775 fetch_subexp_value (b
->exp
.get (), &pc
, &v
, &result
, &val_chain
, 0);
1777 /* Avoid setting b->val if it's already set. The meaning of
1778 b->val is 'the last value' user saw, and we should update
1779 it only if we reported that last value to user. As it
1780 happens, the code that reports it updates b->val directly.
1781 We don't keep track of the memory value for masked
1783 if (!b
->val_valid
&& !is_masked_watchpoint (b
))
1785 if (b
->val_bitsize
!= 0)
1786 v
= extract_bitfield_from_watchpoint_value (b
, v
);
1787 b
->val
= release_value (v
);
1788 b
->val_valid
= true;
1791 frame_pspace
= get_frame_program_space (get_selected_frame (NULL
));
1793 /* Look at each value on the value chain. */
1794 gdb_assert (!val_chain
.empty ());
1795 for (const value_ref_ptr
&iter
: val_chain
)
1799 /* If it's a memory location, and GDB actually needed
1800 its contents to evaluate the expression, then we
1801 must watch it. If the first value returned is
1802 still lazy, that means an error occurred reading it;
1803 watch it anyway in case it becomes readable. */
1804 if (VALUE_LVAL (v
) == lval_memory
1805 && (v
== val_chain
[0] || ! value_lazy (v
)))
1807 struct type
*vtype
= check_typedef (value_type (v
));
1809 /* We only watch structs and arrays if user asked
1810 for it explicitly, never if they just happen to
1811 appear in the middle of some value chain. */
1813 || (vtype
->code () != TYPE_CODE_STRUCT
1814 && vtype
->code () != TYPE_CODE_ARRAY
))
1817 enum target_hw_bp_type type
;
1818 struct bp_location
*loc
, **tmp
;
1819 int bitpos
= 0, bitsize
= 0;
1821 if (value_bitsize (v
) != 0)
1823 /* Extract the bit parameters out from the bitfield
1825 bitpos
= value_bitpos (v
);
1826 bitsize
= value_bitsize (v
);
1828 else if (v
== result
&& b
->val_bitsize
!= 0)
1830 /* If VAL_BITSIZE != 0 then RESULT is actually a bitfield
1831 lvalue whose bit parameters are saved in the fields
1832 VAL_BITPOS and VAL_BITSIZE. */
1833 bitpos
= b
->val_bitpos
;
1834 bitsize
= b
->val_bitsize
;
1837 addr
= value_address (v
);
1840 /* Skip the bytes that don't contain the bitfield. */
1845 if (b
->type
== bp_read_watchpoint
)
1847 else if (b
->type
== bp_access_watchpoint
)
1850 loc
= allocate_bp_location (b
);
1851 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
1854 loc
->gdbarch
= get_type_arch (value_type (v
));
1856 loc
->pspace
= frame_pspace
;
1857 loc
->address
= address_significant (loc
->gdbarch
, addr
);
1861 /* Just cover the bytes that make up the bitfield. */
1862 loc
->length
= ((bitpos
% 8) + bitsize
+ 7) / 8;
1865 loc
->length
= TYPE_LENGTH (value_type (v
));
1867 loc
->watchpoint_type
= type
;
1872 /* Change the type of breakpoint between hardware assisted or
1873 an ordinary watchpoint depending on the hardware support
1874 and free hardware slots. REPARSE is set when the inferior
1879 enum bp_loc_type loc_type
;
1880 struct bp_location
*bl
;
1882 reg_cnt
= can_use_hardware_watchpoint (val_chain
);
1886 int i
, target_resources_ok
, other_type_used
;
1889 /* Use an exact watchpoint when there's only one memory region to be
1890 watched, and only one debug register is needed to watch it. */
1891 b
->exact
= target_exact_watchpoints
&& reg_cnt
== 1;
1893 /* We need to determine how many resources are already
1894 used for all other hardware watchpoints plus this one
1895 to see if we still have enough resources to also fit
1896 this watchpoint in as well. */
1898 /* If this is a software watchpoint, we try to turn it
1899 to a hardware one -- count resources as if B was of
1900 hardware watchpoint type. */
1902 if (type
== bp_watchpoint
)
1903 type
= bp_hardware_watchpoint
;
1905 /* This watchpoint may or may not have been placed on
1906 the list yet at this point (it won't be in the list
1907 if we're trying to create it for the first time,
1908 through watch_command), so always account for it
1911 /* Count resources used by all watchpoints except B. */
1912 i
= hw_watchpoint_used_count_others (b
, type
, &other_type_used
);
1914 /* Add in the resources needed for B. */
1915 i
+= hw_watchpoint_use_count (b
);
1918 = target_can_use_hardware_watchpoint (type
, i
, other_type_used
);
1919 if (target_resources_ok
<= 0)
1921 int sw_mode
= b
->ops
->works_in_software_mode (b
);
1923 if (target_resources_ok
== 0 && !sw_mode
)
1924 error (_("Target does not support this type of "
1925 "hardware watchpoint."));
1926 else if (target_resources_ok
< 0 && !sw_mode
)
1927 error (_("There are not enough available hardware "
1928 "resources for this watchpoint."));
1930 /* Downgrade to software watchpoint. */
1931 b
->type
= bp_watchpoint
;
1935 /* If this was a software watchpoint, we've just
1936 found we have enough resources to turn it to a
1937 hardware watchpoint. Otherwise, this is a
1942 else if (!b
->ops
->works_in_software_mode (b
))
1944 if (!can_use_hw_watchpoints
)
1945 error (_("Can't set read/access watchpoint when "
1946 "hardware watchpoints are disabled."));
1948 error (_("Expression cannot be implemented with "
1949 "read/access watchpoint."));
1952 b
->type
= bp_watchpoint
;
1954 loc_type
= (b
->type
== bp_watchpoint
? bp_loc_other
1955 : bp_loc_hardware_watchpoint
);
1956 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
1957 bl
->loc_type
= loc_type
;
1960 /* If a software watchpoint is not watching any memory, then the
1961 above left it without any location set up. But,
1962 bpstat_stop_status requires a location to be able to report
1963 stops, so make sure there's at least a dummy one. */
1964 if (b
->type
== bp_watchpoint
&& b
->loc
== NULL
)
1965 software_watchpoint_add_no_memory_location (b
, frame_pspace
);
1967 else if (!within_current_scope
)
1969 printf_filtered (_("\
1970 Watchpoint %d deleted because the program has left the block\n\
1971 in which its expression is valid.\n"),
1973 watchpoint_del_at_next_stop (b
);
1976 /* Restore the selected frame. */
1978 select_frame (frame_find_by_id (saved_frame_id
));
1982 /* Returns 1 iff breakpoint location should be
1983 inserted in the inferior. We don't differentiate the type of BL's owner
1984 (breakpoint vs. tracepoint), although insert_location in tracepoint's
1985 breakpoint_ops is not defined, because in insert_bp_location,
1986 tracepoint's insert_location will not be called. */
1988 should_be_inserted (struct bp_location
*bl
)
1990 if (bl
->owner
== NULL
|| !breakpoint_enabled (bl
->owner
))
1993 if (bl
->owner
->disposition
== disp_del_at_next_stop
)
1996 if (!bl
->enabled
|| bl
->shlib_disabled
|| bl
->duplicate
)
1999 if (user_breakpoint_p (bl
->owner
) && bl
->pspace
->executing_startup
)
2002 /* This is set for example, when we're attached to the parent of a
2003 vfork, and have detached from the child. The child is running
2004 free, and we expect it to do an exec or exit, at which point the
2005 OS makes the parent schedulable again (and the target reports
2006 that the vfork is done). Until the child is done with the shared
2007 memory region, do not insert breakpoints in the parent, otherwise
2008 the child could still trip on the parent's breakpoints. Since
2009 the parent is blocked anyway, it won't miss any breakpoint. */
2010 if (bl
->pspace
->breakpoints_not_allowed
)
2013 /* Don't insert a breakpoint if we're trying to step past its
2014 location, except if the breakpoint is a single-step breakpoint,
2015 and the breakpoint's thread is the thread which is stepping past
2017 if ((bl
->loc_type
== bp_loc_software_breakpoint
2018 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
2019 && stepping_past_instruction_at (bl
->pspace
->aspace
,
2021 /* The single-step breakpoint may be inserted at the location
2022 we're trying to step if the instruction branches to itself.
2023 However, the instruction won't be executed at all and it may
2024 break the semantics of the instruction, for example, the
2025 instruction is a conditional branch or updates some flags.
2026 We can't fix it unless GDB is able to emulate the instruction
2027 or switch to displaced stepping. */
2028 && !(bl
->owner
->type
== bp_single_step
2029 && thread_is_stepping_over_breakpoint (bl
->owner
->thread
)))
2033 fprintf_unfiltered (gdb_stdlog
,
2034 "infrun: skipping breakpoint: "
2035 "stepping past insn at: %s\n",
2036 paddress (bl
->gdbarch
, bl
->address
));
2041 /* Don't insert watchpoints if we're trying to step past the
2042 instruction that triggered one. */
2043 if ((bl
->loc_type
== bp_loc_hardware_watchpoint
)
2044 && stepping_past_nonsteppable_watchpoint ())
2048 fprintf_unfiltered (gdb_stdlog
,
2049 "infrun: stepping past non-steppable watchpoint. "
2050 "skipping watchpoint at %s:%d\n",
2051 paddress (bl
->gdbarch
, bl
->address
),
2060 /* Same as should_be_inserted but does the check assuming
2061 that the location is not duplicated. */
2064 unduplicated_should_be_inserted (struct bp_location
*bl
)
2067 const int save_duplicate
= bl
->duplicate
;
2070 result
= should_be_inserted (bl
);
2071 bl
->duplicate
= save_duplicate
;
2075 /* Parses a conditional described by an expression COND into an
2076 agent expression bytecode suitable for evaluation
2077 by the bytecode interpreter. Return NULL if there was
2078 any error during parsing. */
2080 static agent_expr_up
2081 parse_cond_to_aexpr (CORE_ADDR scope
, struct expression
*cond
)
2086 agent_expr_up aexpr
;
2088 /* We don't want to stop processing, so catch any errors
2089 that may show up. */
2092 aexpr
= gen_eval_for_expr (scope
, cond
);
2095 catch (const gdb_exception_error
&ex
)
2097 /* If we got here, it means the condition could not be parsed to a valid
2098 bytecode expression and thus can't be evaluated on the target's side.
2099 It's no use iterating through the conditions. */
2102 /* We have a valid agent expression. */
2106 /* Based on location BL, create a list of breakpoint conditions to be
2107 passed on to the target. If we have duplicated locations with different
2108 conditions, we will add such conditions to the list. The idea is that the
2109 target will evaluate the list of conditions and will only notify GDB when
2110 one of them is true. */
2113 build_target_condition_list (struct bp_location
*bl
)
2115 struct bp_location
**locp
= NULL
, **loc2p
;
2116 int null_condition_or_parse_error
= 0;
2117 int modified
= bl
->needs_update
;
2118 struct bp_location
*loc
;
2120 /* Release conditions left over from a previous insert. */
2121 bl
->target_info
.conditions
.clear ();
2123 /* This is only meaningful if the target is
2124 evaluating conditions and if the user has
2125 opted for condition evaluation on the target's
2127 if (gdb_evaluates_breakpoint_condition_p ()
2128 || !target_supports_evaluation_of_breakpoint_conditions ())
2131 /* Do a first pass to check for locations with no assigned
2132 conditions or conditions that fail to parse to a valid agent
2133 expression bytecode. If any of these happen, then it's no use to
2134 send conditions to the target since this location will always
2135 trigger and generate a response back to GDB. Note we consider
2136 all locations at the same address irrespective of type, i.e.,
2137 even if the locations aren't considered duplicates (e.g.,
2138 software breakpoint and hardware breakpoint at the same
2140 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2143 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2147 /* Re-parse the conditions since something changed. In that
2148 case we already freed the condition bytecodes (see
2149 force_breakpoint_reinsertion). We just
2150 need to parse the condition to bytecodes again. */
2151 loc
->cond_bytecode
= parse_cond_to_aexpr (bl
->address
,
2155 /* If we have a NULL bytecode expression, it means something
2156 went wrong or we have a null condition expression. */
2157 if (!loc
->cond_bytecode
)
2159 null_condition_or_parse_error
= 1;
2165 /* If any of these happened, it means we will have to evaluate the conditions
2166 for the location's address on gdb's side. It is no use keeping bytecodes
2167 for all the other duplicate locations, thus we free all of them here.
2169 This is so we have a finer control over which locations' conditions are
2170 being evaluated by GDB or the remote stub. */
2171 if (null_condition_or_parse_error
)
2173 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2176 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2178 /* Only go as far as the first NULL bytecode is
2180 if (!loc
->cond_bytecode
)
2183 loc
->cond_bytecode
.reset ();
2188 /* No NULL conditions or failed bytecode generation. Build a
2189 condition list for this location's address. If we have software
2190 and hardware locations at the same address, they aren't
2191 considered duplicates, but we still marge all the conditions
2192 anyway, as it's simpler, and doesn't really make a practical
2194 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2198 && is_breakpoint (loc
->owner
)
2199 && loc
->pspace
->num
== bl
->pspace
->num
2200 && loc
->owner
->enable_state
== bp_enabled
2203 /* Add the condition to the vector. This will be used later
2204 to send the conditions to the target. */
2205 bl
->target_info
.conditions
.push_back (loc
->cond_bytecode
.get ());
2212 /* Parses a command described by string CMD into an agent expression
2213 bytecode suitable for evaluation by the bytecode interpreter.
2214 Return NULL if there was any error during parsing. */
2216 static agent_expr_up
2217 parse_cmd_to_aexpr (CORE_ADDR scope
, char *cmd
)
2219 const char *cmdrest
;
2220 const char *format_start
, *format_end
;
2221 struct gdbarch
*gdbarch
= get_current_arch ();
2228 if (*cmdrest
== ',')
2230 cmdrest
= skip_spaces (cmdrest
);
2232 if (*cmdrest
++ != '"')
2233 error (_("No format string following the location"));
2235 format_start
= cmdrest
;
2237 format_pieces
fpieces (&cmdrest
);
2239 format_end
= cmdrest
;
2241 if (*cmdrest
++ != '"')
2242 error (_("Bad format string, non-terminated '\"'."));
2244 cmdrest
= skip_spaces (cmdrest
);
2246 if (!(*cmdrest
== ',' || *cmdrest
== '\0'))
2247 error (_("Invalid argument syntax"));
2249 if (*cmdrest
== ',')
2251 cmdrest
= skip_spaces (cmdrest
);
2253 /* For each argument, make an expression. */
2255 std::vector
<struct expression
*> argvec
;
2256 while (*cmdrest
!= '\0')
2261 expression_up expr
= parse_exp_1 (&cmd1
, scope
, block_for_pc (scope
), 1);
2262 argvec
.push_back (expr
.release ());
2264 if (*cmdrest
== ',')
2268 agent_expr_up aexpr
;
2270 /* We don't want to stop processing, so catch any errors
2271 that may show up. */
2274 aexpr
= gen_printf (scope
, gdbarch
, 0, 0,
2275 format_start
, format_end
- format_start
,
2276 argvec
.size (), argvec
.data ());
2278 catch (const gdb_exception_error
&ex
)
2280 /* If we got here, it means the command could not be parsed to a valid
2281 bytecode expression and thus can't be evaluated on the target's side.
2282 It's no use iterating through the other commands. */
2285 /* We have a valid agent expression, return it. */
2289 /* Based on location BL, create a list of breakpoint commands to be
2290 passed on to the target. If we have duplicated locations with
2291 different commands, we will add any such to the list. */
2294 build_target_command_list (struct bp_location
*bl
)
2296 struct bp_location
**locp
= NULL
, **loc2p
;
2297 int null_command_or_parse_error
= 0;
2298 int modified
= bl
->needs_update
;
2299 struct bp_location
*loc
;
2301 /* Clear commands left over from a previous insert. */
2302 bl
->target_info
.tcommands
.clear ();
2304 if (!target_can_run_breakpoint_commands ())
2307 /* For now, limit to agent-style dprintf breakpoints. */
2308 if (dprintf_style
!= dprintf_style_agent
)
2311 /* For now, if we have any location at the same address that isn't a
2312 dprintf, don't install the target-side commands, as that would
2313 make the breakpoint not be reported to the core, and we'd lose
2315 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2318 if (is_breakpoint (loc
->owner
)
2319 && loc
->pspace
->num
== bl
->pspace
->num
2320 && loc
->owner
->type
!= bp_dprintf
)
2324 /* Do a first pass to check for locations with no assigned
2325 conditions or conditions that fail to parse to a valid agent expression
2326 bytecode. If any of these happen, then it's no use to send conditions
2327 to the target since this location will always trigger and generate a
2328 response back to GDB. */
2329 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2332 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2336 /* Re-parse the commands since something changed. In that
2337 case we already freed the command bytecodes (see
2338 force_breakpoint_reinsertion). We just
2339 need to parse the command to bytecodes again. */
2341 = parse_cmd_to_aexpr (bl
->address
,
2342 loc
->owner
->extra_string
);
2345 /* If we have a NULL bytecode expression, it means something
2346 went wrong or we have a null command expression. */
2347 if (!loc
->cmd_bytecode
)
2349 null_command_or_parse_error
= 1;
2355 /* If anything failed, then we're not doing target-side commands,
2357 if (null_command_or_parse_error
)
2359 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2362 if (is_breakpoint (loc
->owner
)
2363 && loc
->pspace
->num
== bl
->pspace
->num
)
2365 /* Only go as far as the first NULL bytecode is
2367 if (loc
->cmd_bytecode
== NULL
)
2370 loc
->cmd_bytecode
.reset ();
2375 /* No NULL commands or failed bytecode generation. Build a command
2376 list for all duplicate locations at this location's address.
2377 Note that here we must care for whether the breakpoint location
2378 types are considered duplicates, otherwise, say, if we have a
2379 software and hardware location at the same address, the target
2380 could end up running the commands twice. For the moment, we only
2381 support targets-side commands with dprintf, but it doesn't hurt
2382 to be pedantically correct in case that changes. */
2383 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2386 if (breakpoint_locations_match (bl
, loc
)
2387 && loc
->owner
->extra_string
2388 && is_breakpoint (loc
->owner
)
2389 && loc
->pspace
->num
== bl
->pspace
->num
2390 && loc
->owner
->enable_state
== bp_enabled
2393 /* Add the command to the vector. This will be used later
2394 to send the commands to the target. */
2395 bl
->target_info
.tcommands
.push_back (loc
->cmd_bytecode
.get ());
2399 bl
->target_info
.persist
= 0;
2400 /* Maybe flag this location as persistent. */
2401 if (bl
->owner
->type
== bp_dprintf
&& disconnected_dprintf
)
2402 bl
->target_info
.persist
= 1;
2405 /* Return the kind of breakpoint on address *ADDR. Get the kind
2406 of breakpoint according to ADDR except single-step breakpoint.
2407 Get the kind of single-step breakpoint according to the current
2411 breakpoint_kind (struct bp_location
*bl
, CORE_ADDR
*addr
)
2413 if (bl
->owner
->type
== bp_single_step
)
2415 struct thread_info
*thr
= find_thread_global_id (bl
->owner
->thread
);
2416 struct regcache
*regcache
;
2418 regcache
= get_thread_regcache (thr
);
2420 return gdbarch_breakpoint_kind_from_current_state (bl
->gdbarch
,
2424 return gdbarch_breakpoint_kind_from_pc (bl
->gdbarch
, addr
);
2427 /* Insert a low-level "breakpoint" of some type. BL is the breakpoint
2428 location. Any error messages are printed to TMP_ERROR_STREAM; and
2429 DISABLED_BREAKS, and HW_BREAKPOINT_ERROR are used to report problems.
2430 Returns 0 for success, 1 if the bp_location type is not supported or
2433 NOTE drow/2003-09-09: This routine could be broken down to an
2434 object-style method for each breakpoint or catchpoint type. */
2436 insert_bp_location (struct bp_location
*bl
,
2437 struct ui_file
*tmp_error_stream
,
2438 int *disabled_breaks
,
2439 int *hw_breakpoint_error
,
2440 int *hw_bp_error_explained_already
)
2442 gdb_exception bp_excpt
;
2444 if (!should_be_inserted (bl
) || (bl
->inserted
&& !bl
->needs_update
))
2447 /* Note we don't initialize bl->target_info, as that wipes out
2448 the breakpoint location's shadow_contents if the breakpoint
2449 is still inserted at that location. This in turn breaks
2450 target_read_memory which depends on these buffers when
2451 a memory read is requested at the breakpoint location:
2452 Once the target_info has been wiped, we fail to see that
2453 we have a breakpoint inserted at that address and thus
2454 read the breakpoint instead of returning the data saved in
2455 the breakpoint location's shadow contents. */
2456 bl
->target_info
.reqstd_address
= bl
->address
;
2457 bl
->target_info
.placed_address_space
= bl
->pspace
->aspace
;
2458 bl
->target_info
.length
= bl
->length
;
2460 /* When working with target-side conditions, we must pass all the conditions
2461 for the same breakpoint address down to the target since GDB will not
2462 insert those locations. With a list of breakpoint conditions, the target
2463 can decide when to stop and notify GDB. */
2465 if (is_breakpoint (bl
->owner
))
2467 build_target_condition_list (bl
);
2468 build_target_command_list (bl
);
2469 /* Reset the modification marker. */
2470 bl
->needs_update
= 0;
2473 /* If "set breakpoint auto-hw" is "on" and a software breakpoint was
2474 set at a read-only address, then a breakpoint location will have
2475 been changed to hardware breakpoint before we get here. If it is
2476 "off" however, error out before actually trying to insert the
2477 breakpoint, with a nicer error message. */
2478 if (bl
->loc_type
== bp_loc_software_breakpoint
2479 && !automatic_hardware_breakpoints
)
2481 mem_region
*mr
= lookup_mem_region (bl
->address
);
2483 if (mr
!= nullptr && mr
->attrib
.mode
!= MEM_RW
)
2485 fprintf_unfiltered (tmp_error_stream
,
2486 _("Cannot insert breakpoint %d.\n"
2487 "Cannot set software breakpoint "
2488 "at read-only address %s\n"),
2490 paddress (bl
->gdbarch
, bl
->address
));
2495 if (bl
->loc_type
== bp_loc_software_breakpoint
2496 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
2498 /* First check to see if we have to handle an overlay. */
2499 if (overlay_debugging
== ovly_off
2500 || bl
->section
== NULL
2501 || !(section_is_overlay (bl
->section
)))
2503 /* No overlay handling: just set the breakpoint. */
2508 val
= bl
->owner
->ops
->insert_location (bl
);
2510 bp_excpt
= gdb_exception
{RETURN_ERROR
, GENERIC_ERROR
};
2512 catch (gdb_exception
&e
)
2514 bp_excpt
= std::move (e
);
2519 /* This breakpoint is in an overlay section.
2520 Shall we set a breakpoint at the LMA? */
2521 if (!overlay_events_enabled
)
2523 /* Yes -- overlay event support is not active,
2524 so we must try to set a breakpoint at the LMA.
2525 This will not work for a hardware breakpoint. */
2526 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
2527 warning (_("hardware breakpoint %d not supported in overlay!"),
2531 CORE_ADDR addr
= overlay_unmapped_address (bl
->address
,
2533 /* Set a software (trap) breakpoint at the LMA. */
2534 bl
->overlay_target_info
= bl
->target_info
;
2535 bl
->overlay_target_info
.reqstd_address
= addr
;
2537 /* No overlay handling: just set the breakpoint. */
2542 bl
->overlay_target_info
.kind
2543 = breakpoint_kind (bl
, &addr
);
2544 bl
->overlay_target_info
.placed_address
= addr
;
2545 val
= target_insert_breakpoint (bl
->gdbarch
,
2546 &bl
->overlay_target_info
);
2549 = gdb_exception
{RETURN_ERROR
, GENERIC_ERROR
};
2551 catch (gdb_exception
&e
)
2553 bp_excpt
= std::move (e
);
2556 if (bp_excpt
.reason
!= 0)
2557 fprintf_unfiltered (tmp_error_stream
,
2558 "Overlay breakpoint %d "
2559 "failed: in ROM?\n",
2563 /* Shall we set a breakpoint at the VMA? */
2564 if (section_is_mapped (bl
->section
))
2566 /* Yes. This overlay section is mapped into memory. */
2571 val
= bl
->owner
->ops
->insert_location (bl
);
2573 bp_excpt
= gdb_exception
{RETURN_ERROR
, GENERIC_ERROR
};
2575 catch (gdb_exception
&e
)
2577 bp_excpt
= std::move (e
);
2582 /* No. This breakpoint will not be inserted.
2583 No error, but do not mark the bp as 'inserted'. */
2588 if (bp_excpt
.reason
!= 0)
2590 /* Can't set the breakpoint. */
2592 /* In some cases, we might not be able to insert a
2593 breakpoint in a shared library that has already been
2594 removed, but we have not yet processed the shlib unload
2595 event. Unfortunately, some targets that implement
2596 breakpoint insertion themselves can't tell why the
2597 breakpoint insertion failed (e.g., the remote target
2598 doesn't define error codes), so we must treat generic
2599 errors as memory errors. */
2600 if (bp_excpt
.reason
== RETURN_ERROR
2601 && (bp_excpt
.error
== GENERIC_ERROR
2602 || bp_excpt
.error
== MEMORY_ERROR
)
2603 && bl
->loc_type
== bp_loc_software_breakpoint
2604 && (solib_name_from_address (bl
->pspace
, bl
->address
)
2605 || shared_objfile_contains_address_p (bl
->pspace
,
2608 /* See also: disable_breakpoints_in_shlibs. */
2609 bl
->shlib_disabled
= 1;
2610 gdb::observers::breakpoint_modified
.notify (bl
->owner
);
2611 if (!*disabled_breaks
)
2613 fprintf_unfiltered (tmp_error_stream
,
2614 "Cannot insert breakpoint %d.\n",
2616 fprintf_unfiltered (tmp_error_stream
,
2617 "Temporarily disabling shared "
2618 "library breakpoints:\n");
2620 *disabled_breaks
= 1;
2621 fprintf_unfiltered (tmp_error_stream
,
2622 "breakpoint #%d\n", bl
->owner
->number
);
2627 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
2629 *hw_breakpoint_error
= 1;
2630 *hw_bp_error_explained_already
= bp_excpt
.message
!= NULL
;
2631 fprintf_unfiltered (tmp_error_stream
,
2632 "Cannot insert hardware breakpoint %d%s",
2634 bp_excpt
.message
? ":" : ".\n");
2635 if (bp_excpt
.message
!= NULL
)
2636 fprintf_unfiltered (tmp_error_stream
, "%s.\n",
2641 if (bp_excpt
.message
== NULL
)
2644 = memory_error_message (TARGET_XFER_E_IO
,
2645 bl
->gdbarch
, bl
->address
);
2647 fprintf_unfiltered (tmp_error_stream
,
2648 "Cannot insert breakpoint %d.\n"
2650 bl
->owner
->number
, message
.c_str ());
2654 fprintf_unfiltered (tmp_error_stream
,
2655 "Cannot insert breakpoint %d: %s\n",
2670 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
2671 /* NOTE drow/2003-09-08: This state only exists for removing
2672 watchpoints. It's not clear that it's necessary... */
2673 && bl
->owner
->disposition
!= disp_del_at_next_stop
)
2677 gdb_assert (bl
->owner
->ops
!= NULL
2678 && bl
->owner
->ops
->insert_location
!= NULL
);
2680 val
= bl
->owner
->ops
->insert_location (bl
);
2682 /* If trying to set a read-watchpoint, and it turns out it's not
2683 supported, try emulating one with an access watchpoint. */
2684 if (val
== 1 && bl
->watchpoint_type
== hw_read
)
2686 struct bp_location
*loc
, **loc_temp
;
2688 /* But don't try to insert it, if there's already another
2689 hw_access location that would be considered a duplicate
2691 ALL_BP_LOCATIONS (loc
, loc_temp
)
2693 && loc
->watchpoint_type
== hw_access
2694 && watchpoint_locations_match (bl
, loc
))
2698 bl
->target_info
= loc
->target_info
;
2699 bl
->watchpoint_type
= hw_access
;
2706 bl
->watchpoint_type
= hw_access
;
2707 val
= bl
->owner
->ops
->insert_location (bl
);
2710 /* Back to the original value. */
2711 bl
->watchpoint_type
= hw_read
;
2715 bl
->inserted
= (val
== 0);
2718 else if (bl
->owner
->type
== bp_catchpoint
)
2722 gdb_assert (bl
->owner
->ops
!= NULL
2723 && bl
->owner
->ops
->insert_location
!= NULL
);
2725 val
= bl
->owner
->ops
->insert_location (bl
);
2728 bl
->owner
->enable_state
= bp_disabled
;
2732 Error inserting catchpoint %d: Your system does not support this type\n\
2733 of catchpoint."), bl
->owner
->number
);
2735 warning (_("Error inserting catchpoint %d."), bl
->owner
->number
);
2738 bl
->inserted
= (val
== 0);
2740 /* We've already printed an error message if there was a problem
2741 inserting this catchpoint, and we've disabled the catchpoint,
2742 so just return success. */
2749 /* This function is called when program space PSPACE is about to be
2750 deleted. It takes care of updating breakpoints to not reference
2754 breakpoint_program_space_exit (struct program_space
*pspace
)
2756 struct breakpoint
*b
, *b_temp
;
2757 struct bp_location
*loc
, **loc_temp
;
2759 /* Remove any breakpoint that was set through this program space. */
2760 ALL_BREAKPOINTS_SAFE (b
, b_temp
)
2762 if (b
->pspace
== pspace
)
2763 delete_breakpoint (b
);
2766 /* Breakpoints set through other program spaces could have locations
2767 bound to PSPACE as well. Remove those. */
2768 ALL_BP_LOCATIONS (loc
, loc_temp
)
2770 struct bp_location
*tmp
;
2772 if (loc
->pspace
== pspace
)
2774 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
2775 if (loc
->owner
->loc
== loc
)
2776 loc
->owner
->loc
= loc
->next
;
2778 for (tmp
= loc
->owner
->loc
; tmp
->next
!= NULL
; tmp
= tmp
->next
)
2779 if (tmp
->next
== loc
)
2781 tmp
->next
= loc
->next
;
2787 /* Now update the global location list to permanently delete the
2788 removed locations above. */
2789 update_global_location_list (UGLL_DONT_INSERT
);
2792 /* Make sure all breakpoints are inserted in inferior.
2793 Throws exception on any error.
2794 A breakpoint that is already inserted won't be inserted
2795 again, so calling this function twice is safe. */
2797 insert_breakpoints (void)
2799 struct breakpoint
*bpt
;
2801 ALL_BREAKPOINTS (bpt
)
2802 if (is_hardware_watchpoint (bpt
))
2804 struct watchpoint
*w
= (struct watchpoint
*) bpt
;
2806 update_watchpoint (w
, 0 /* don't reparse. */);
2809 /* Updating watchpoints creates new locations, so update the global
2810 location list. Explicitly tell ugll to insert locations and
2811 ignore breakpoints_always_inserted_mode. Also,
2812 update_global_location_list tries to "upgrade" software
2813 breakpoints to hardware breakpoints to handle "set breakpoint
2814 auto-hw", so we need to call it even if we don't have new
2816 update_global_location_list (UGLL_INSERT
);
2819 /* Invoke CALLBACK for each of bp_location. */
2822 iterate_over_bp_locations (walk_bp_location_callback callback
)
2824 struct bp_location
*loc
, **loc_tmp
;
2826 ALL_BP_LOCATIONS (loc
, loc_tmp
)
2828 callback (loc
, NULL
);
2832 /* This is used when we need to synch breakpoint conditions between GDB and the
2833 target. It is the case with deleting and disabling of breakpoints when using
2834 always-inserted mode. */
2837 update_inserted_breakpoint_locations (void)
2839 struct bp_location
*bl
, **blp_tmp
;
2842 int disabled_breaks
= 0;
2843 int hw_breakpoint_error
= 0;
2844 int hw_bp_details_reported
= 0;
2846 string_file tmp_error_stream
;
2848 /* Explicitly mark the warning -- this will only be printed if
2849 there was an error. */
2850 tmp_error_stream
.puts ("Warning:\n");
2852 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
2854 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2856 /* We only want to update software breakpoints and hardware
2858 if (!is_breakpoint (bl
->owner
))
2861 /* We only want to update locations that are already inserted
2862 and need updating. This is to avoid unwanted insertion during
2863 deletion of breakpoints. */
2864 if (!bl
->inserted
|| !bl
->needs_update
)
2867 switch_to_program_space_and_thread (bl
->pspace
);
2869 /* For targets that support global breakpoints, there's no need
2870 to select an inferior to insert breakpoint to. In fact, even
2871 if we aren't attached to any process yet, we should still
2872 insert breakpoints. */
2873 if (!gdbarch_has_global_breakpoints (target_gdbarch ())
2874 && (inferior_ptid
== null_ptid
|| !target_has_execution
))
2877 val
= insert_bp_location (bl
, &tmp_error_stream
, &disabled_breaks
,
2878 &hw_breakpoint_error
, &hw_bp_details_reported
);
2885 target_terminal::ours_for_output ();
2886 error_stream (tmp_error_stream
);
2890 /* Used when starting or continuing the program. */
2893 insert_breakpoint_locations (void)
2895 struct breakpoint
*bpt
;
2896 struct bp_location
*bl
, **blp_tmp
;
2899 int disabled_breaks
= 0;
2900 int hw_breakpoint_error
= 0;
2901 int hw_bp_error_explained_already
= 0;
2903 string_file tmp_error_stream
;
2905 /* Explicitly mark the warning -- this will only be printed if
2906 there was an error. */
2907 tmp_error_stream
.puts ("Warning:\n");
2909 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
2911 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2913 if (!should_be_inserted (bl
) || (bl
->inserted
&& !bl
->needs_update
))
2916 /* There is no point inserting thread-specific breakpoints if
2917 the thread no longer exists. ALL_BP_LOCATIONS bp_location
2918 has BL->OWNER always non-NULL. */
2919 if (bl
->owner
->thread
!= -1
2920 && !valid_global_thread_id (bl
->owner
->thread
))
2923 switch_to_program_space_and_thread (bl
->pspace
);
2925 /* For targets that support global breakpoints, there's no need
2926 to select an inferior to insert breakpoint to. In fact, even
2927 if we aren't attached to any process yet, we should still
2928 insert breakpoints. */
2929 if (!gdbarch_has_global_breakpoints (target_gdbarch ())
2930 && (inferior_ptid
== null_ptid
|| !target_has_execution
))
2933 val
= insert_bp_location (bl
, &tmp_error_stream
, &disabled_breaks
,
2934 &hw_breakpoint_error
, &hw_bp_error_explained_already
);
2939 /* If we failed to insert all locations of a watchpoint, remove
2940 them, as half-inserted watchpoint is of limited use. */
2941 ALL_BREAKPOINTS (bpt
)
2943 int some_failed
= 0;
2944 struct bp_location
*loc
;
2946 if (!is_hardware_watchpoint (bpt
))
2949 if (!breakpoint_enabled (bpt
))
2952 if (bpt
->disposition
== disp_del_at_next_stop
)
2955 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
2956 if (!loc
->inserted
&& should_be_inserted (loc
))
2963 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
2965 remove_breakpoint (loc
);
2967 hw_breakpoint_error
= 1;
2968 tmp_error_stream
.printf ("Could not insert "
2969 "hardware watchpoint %d.\n",
2977 /* If a hardware breakpoint or watchpoint was inserted, add a
2978 message about possibly exhausted resources. */
2979 if (hw_breakpoint_error
&& !hw_bp_error_explained_already
)
2981 tmp_error_stream
.printf ("Could not insert hardware breakpoints:\n\
2982 You may have requested too many hardware breakpoints/watchpoints.\n");
2984 target_terminal::ours_for_output ();
2985 error_stream (tmp_error_stream
);
2989 /* Used when the program stops.
2990 Returns zero if successful, or non-zero if there was a problem
2991 removing a breakpoint location. */
2994 remove_breakpoints (void)
2996 struct bp_location
*bl
, **blp_tmp
;
2999 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3001 if (bl
->inserted
&& !is_tracepoint (bl
->owner
))
3002 val
|= remove_breakpoint (bl
);
3007 /* When a thread exits, remove breakpoints that are related to
3011 remove_threaded_breakpoints (struct thread_info
*tp
, int silent
)
3013 struct breakpoint
*b
, *b_tmp
;
3015 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
3017 if (b
->thread
== tp
->global_num
&& user_breakpoint_p (b
))
3019 b
->disposition
= disp_del_at_next_stop
;
3021 printf_filtered (_("\
3022 Thread-specific breakpoint %d deleted - thread %s no longer in the thread list.\n"),
3023 b
->number
, print_thread_id (tp
));
3025 /* Hide it from the user. */
3031 /* See breakpoint.h. */
3034 remove_breakpoints_inf (inferior
*inf
)
3036 struct bp_location
*bl
, **blp_tmp
;
3039 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3041 if (bl
->pspace
!= inf
->pspace
)
3044 if (bl
->inserted
&& !bl
->target_info
.persist
)
3046 val
= remove_breakpoint (bl
);
3053 static int internal_breakpoint_number
= -1;
3055 /* Set the breakpoint number of B, depending on the value of INTERNAL.
3056 If INTERNAL is non-zero, the breakpoint number will be populated
3057 from internal_breakpoint_number and that variable decremented.
3058 Otherwise the breakpoint number will be populated from
3059 breakpoint_count and that value incremented. Internal breakpoints
3060 do not set the internal var bpnum. */
3062 set_breakpoint_number (int internal
, struct breakpoint
*b
)
3065 b
->number
= internal_breakpoint_number
--;
3068 set_breakpoint_count (breakpoint_count
+ 1);
3069 b
->number
= breakpoint_count
;
3073 static struct breakpoint
*
3074 create_internal_breakpoint (struct gdbarch
*gdbarch
,
3075 CORE_ADDR address
, enum bptype type
,
3076 const struct breakpoint_ops
*ops
)
3078 symtab_and_line sal
;
3080 sal
.section
= find_pc_overlay (sal
.pc
);
3081 sal
.pspace
= current_program_space
;
3083 breakpoint
*b
= set_raw_breakpoint (gdbarch
, sal
, type
, ops
);
3084 b
->number
= internal_breakpoint_number
--;
3085 b
->disposition
= disp_donttouch
;
3090 static const char *const longjmp_names
[] =
3092 "longjmp", "_longjmp", "siglongjmp", "_siglongjmp"
3094 #define NUM_LONGJMP_NAMES ARRAY_SIZE(longjmp_names)
3096 /* Per-objfile data private to breakpoint.c. */
3097 struct breakpoint_objfile_data
3099 /* Minimal symbol for "_ovly_debug_event" (if any). */
3100 struct bound_minimal_symbol overlay_msym
{};
3102 /* Minimal symbol(s) for "longjmp", "siglongjmp", etc. (if any). */
3103 struct bound_minimal_symbol longjmp_msym
[NUM_LONGJMP_NAMES
] {};
3105 /* True if we have looked for longjmp probes. */
3106 int longjmp_searched
= 0;
3108 /* SystemTap probe points for longjmp (if any). These are non-owning
3110 std::vector
<probe
*> longjmp_probes
;
3112 /* Minimal symbol for "std::terminate()" (if any). */
3113 struct bound_minimal_symbol terminate_msym
{};
3115 /* Minimal symbol for "_Unwind_DebugHook" (if any). */
3116 struct bound_minimal_symbol exception_msym
{};
3118 /* True if we have looked for exception probes. */
3119 int exception_searched
= 0;
3121 /* SystemTap probe points for unwinding (if any). These are non-owning
3123 std::vector
<probe
*> exception_probes
;
3126 static const struct objfile_key
<breakpoint_objfile_data
>
3127 breakpoint_objfile_key
;
3129 /* Minimal symbol not found sentinel. */
3130 static struct minimal_symbol msym_not_found
;
3132 /* Returns TRUE if MSYM point to the "not found" sentinel. */
3135 msym_not_found_p (const struct minimal_symbol
*msym
)
3137 return msym
== &msym_not_found
;
3140 /* Return per-objfile data needed by breakpoint.c.
3141 Allocate the data if necessary. */
3143 static struct breakpoint_objfile_data
*
3144 get_breakpoint_objfile_data (struct objfile
*objfile
)
3146 struct breakpoint_objfile_data
*bp_objfile_data
;
3148 bp_objfile_data
= breakpoint_objfile_key
.get (objfile
);
3149 if (bp_objfile_data
== NULL
)
3150 bp_objfile_data
= breakpoint_objfile_key
.emplace (objfile
);
3151 return bp_objfile_data
;
3155 create_overlay_event_breakpoint (void)
3157 const char *const func_name
= "_ovly_debug_event";
3159 for (objfile
*objfile
: current_program_space
->objfiles ())
3161 struct breakpoint
*b
;
3162 struct breakpoint_objfile_data
*bp_objfile_data
;
3164 struct explicit_location explicit_loc
;
3166 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3168 if (msym_not_found_p (bp_objfile_data
->overlay_msym
.minsym
))
3171 if (bp_objfile_data
->overlay_msym
.minsym
== NULL
)
3173 struct bound_minimal_symbol m
;
3175 m
= lookup_minimal_symbol_text (func_name
, objfile
);
3176 if (m
.minsym
== NULL
)
3178 /* Avoid future lookups in this objfile. */
3179 bp_objfile_data
->overlay_msym
.minsym
= &msym_not_found
;
3182 bp_objfile_data
->overlay_msym
= m
;
3185 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->overlay_msym
);
3186 b
= create_internal_breakpoint (objfile
->arch (), addr
,
3188 &internal_breakpoint_ops
);
3189 initialize_explicit_location (&explicit_loc
);
3190 explicit_loc
.function_name
= ASTRDUP (func_name
);
3191 b
->location
= new_explicit_location (&explicit_loc
);
3193 if (overlay_debugging
== ovly_auto
)
3195 b
->enable_state
= bp_enabled
;
3196 overlay_events_enabled
= 1;
3200 b
->enable_state
= bp_disabled
;
3201 overlay_events_enabled
= 0;
3207 create_longjmp_master_breakpoint (void)
3209 scoped_restore_current_program_space restore_pspace
;
3211 for (struct program_space
*pspace
: program_spaces
)
3213 set_current_program_space (pspace
);
3215 for (objfile
*objfile
: current_program_space
->objfiles ())
3218 struct gdbarch
*gdbarch
;
3219 struct breakpoint_objfile_data
*bp_objfile_data
;
3221 gdbarch
= objfile
->arch ();
3223 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3225 if (!bp_objfile_data
->longjmp_searched
)
3227 std::vector
<probe
*> ret
3228 = find_probes_in_objfile (objfile
, "libc", "longjmp");
3232 /* We are only interested in checking one element. */
3235 if (!p
->can_evaluate_arguments ())
3237 /* We cannot use the probe interface here,
3238 because it does not know how to evaluate
3243 bp_objfile_data
->longjmp_probes
= ret
;
3244 bp_objfile_data
->longjmp_searched
= 1;
3247 if (!bp_objfile_data
->longjmp_probes
.empty ())
3249 for (probe
*p
: bp_objfile_data
->longjmp_probes
)
3251 struct breakpoint
*b
;
3253 b
= create_internal_breakpoint (gdbarch
,
3254 p
->get_relocated_address (objfile
),
3256 &internal_breakpoint_ops
);
3257 b
->location
= new_probe_location ("-probe-stap libc:longjmp");
3258 b
->enable_state
= bp_disabled
;
3264 if (!gdbarch_get_longjmp_target_p (gdbarch
))
3267 for (i
= 0; i
< NUM_LONGJMP_NAMES
; i
++)
3269 struct breakpoint
*b
;
3270 const char *func_name
;
3272 struct explicit_location explicit_loc
;
3274 if (msym_not_found_p (bp_objfile_data
->longjmp_msym
[i
].minsym
))
3277 func_name
= longjmp_names
[i
];
3278 if (bp_objfile_data
->longjmp_msym
[i
].minsym
== NULL
)
3280 struct bound_minimal_symbol m
;
3282 m
= lookup_minimal_symbol_text (func_name
, objfile
);
3283 if (m
.minsym
== NULL
)
3285 /* Prevent future lookups in this objfile. */
3286 bp_objfile_data
->longjmp_msym
[i
].minsym
= &msym_not_found
;
3289 bp_objfile_data
->longjmp_msym
[i
] = m
;
3292 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->longjmp_msym
[i
]);
3293 b
= create_internal_breakpoint (gdbarch
, addr
, bp_longjmp_master
,
3294 &internal_breakpoint_ops
);
3295 initialize_explicit_location (&explicit_loc
);
3296 explicit_loc
.function_name
= ASTRDUP (func_name
);
3297 b
->location
= new_explicit_location (&explicit_loc
);
3298 b
->enable_state
= bp_disabled
;
3304 /* Create a master std::terminate breakpoint. */
3306 create_std_terminate_master_breakpoint (void)
3308 const char *const func_name
= "std::terminate()";
3310 scoped_restore_current_program_space restore_pspace
;
3312 for (struct program_space
*pspace
: program_spaces
)
3316 set_current_program_space (pspace
);
3318 for (objfile
*objfile
: current_program_space
->objfiles ())
3320 struct breakpoint
*b
;
3321 struct breakpoint_objfile_data
*bp_objfile_data
;
3322 struct explicit_location explicit_loc
;
3324 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3326 if (msym_not_found_p (bp_objfile_data
->terminate_msym
.minsym
))
3329 if (bp_objfile_data
->terminate_msym
.minsym
== NULL
)
3331 struct bound_minimal_symbol m
;
3333 m
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
3334 if (m
.minsym
== NULL
|| (MSYMBOL_TYPE (m
.minsym
) != mst_text
3335 && MSYMBOL_TYPE (m
.minsym
) != mst_file_text
))
3337 /* Prevent future lookups in this objfile. */
3338 bp_objfile_data
->terminate_msym
.minsym
= &msym_not_found
;
3341 bp_objfile_data
->terminate_msym
= m
;
3344 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->terminate_msym
);
3345 b
= create_internal_breakpoint (objfile
->arch (), addr
,
3346 bp_std_terminate_master
,
3347 &internal_breakpoint_ops
);
3348 initialize_explicit_location (&explicit_loc
);
3349 explicit_loc
.function_name
= ASTRDUP (func_name
);
3350 b
->location
= new_explicit_location (&explicit_loc
);
3351 b
->enable_state
= bp_disabled
;
3356 /* Install a master breakpoint on the unwinder's debug hook. */
3359 create_exception_master_breakpoint (void)
3361 const char *const func_name
= "_Unwind_DebugHook";
3363 for (objfile
*objfile
: current_program_space
->objfiles ())
3365 struct breakpoint
*b
;
3366 struct gdbarch
*gdbarch
;
3367 struct breakpoint_objfile_data
*bp_objfile_data
;
3369 struct explicit_location explicit_loc
;
3371 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3373 /* We prefer the SystemTap probe point if it exists. */
3374 if (!bp_objfile_data
->exception_searched
)
3376 std::vector
<probe
*> ret
3377 = find_probes_in_objfile (objfile
, "libgcc", "unwind");
3381 /* We are only interested in checking one element. */
3384 if (!p
->can_evaluate_arguments ())
3386 /* We cannot use the probe interface here, because it does
3387 not know how to evaluate arguments. */
3391 bp_objfile_data
->exception_probes
= ret
;
3392 bp_objfile_data
->exception_searched
= 1;
3395 if (!bp_objfile_data
->exception_probes
.empty ())
3397 gdbarch
= objfile
->arch ();
3399 for (probe
*p
: bp_objfile_data
->exception_probes
)
3401 b
= create_internal_breakpoint (gdbarch
,
3402 p
->get_relocated_address (objfile
),
3403 bp_exception_master
,
3404 &internal_breakpoint_ops
);
3405 b
->location
= new_probe_location ("-probe-stap libgcc:unwind");
3406 b
->enable_state
= bp_disabled
;
3412 /* Otherwise, try the hook function. */
3414 if (msym_not_found_p (bp_objfile_data
->exception_msym
.minsym
))
3417 gdbarch
= objfile
->arch ();
3419 if (bp_objfile_data
->exception_msym
.minsym
== NULL
)
3421 struct bound_minimal_symbol debug_hook
;
3423 debug_hook
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
3424 if (debug_hook
.minsym
== NULL
)
3426 bp_objfile_data
->exception_msym
.minsym
= &msym_not_found
;
3430 bp_objfile_data
->exception_msym
= debug_hook
;
3433 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->exception_msym
);
3434 addr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, addr
,
3435 current_top_target ());
3436 b
= create_internal_breakpoint (gdbarch
, addr
, bp_exception_master
,
3437 &internal_breakpoint_ops
);
3438 initialize_explicit_location (&explicit_loc
);
3439 explicit_loc
.function_name
= ASTRDUP (func_name
);
3440 b
->location
= new_explicit_location (&explicit_loc
);
3441 b
->enable_state
= bp_disabled
;
3445 /* Does B have a location spec? */
3448 breakpoint_event_location_empty_p (const struct breakpoint
*b
)
3450 return b
->location
!= NULL
&& event_location_empty_p (b
->location
.get ());
3454 update_breakpoints_after_exec (void)
3456 struct breakpoint
*b
, *b_tmp
;
3457 struct bp_location
*bploc
, **bplocp_tmp
;
3459 /* We're about to delete breakpoints from GDB's lists. If the
3460 INSERTED flag is true, GDB will try to lift the breakpoints by
3461 writing the breakpoints' "shadow contents" back into memory. The
3462 "shadow contents" are NOT valid after an exec, so GDB should not
3463 do that. Instead, the target is responsible from marking
3464 breakpoints out as soon as it detects an exec. We don't do that
3465 here instead, because there may be other attempts to delete
3466 breakpoints after detecting an exec and before reaching here. */
3467 ALL_BP_LOCATIONS (bploc
, bplocp_tmp
)
3468 if (bploc
->pspace
== current_program_space
)
3469 gdb_assert (!bploc
->inserted
);
3471 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
3473 if (b
->pspace
!= current_program_space
)
3476 /* Solib breakpoints must be explicitly reset after an exec(). */
3477 if (b
->type
== bp_shlib_event
)
3479 delete_breakpoint (b
);
3483 /* JIT breakpoints must be explicitly reset after an exec(). */
3484 if (b
->type
== bp_jit_event
)
3486 delete_breakpoint (b
);
3490 /* Thread event breakpoints must be set anew after an exec(),
3491 as must overlay event and longjmp master breakpoints. */
3492 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
3493 || b
->type
== bp_longjmp_master
|| b
->type
== bp_std_terminate_master
3494 || b
->type
== bp_exception_master
)
3496 delete_breakpoint (b
);
3500 /* Step-resume breakpoints are meaningless after an exec(). */
3501 if (b
->type
== bp_step_resume
|| b
->type
== bp_hp_step_resume
)
3503 delete_breakpoint (b
);
3507 /* Just like single-step breakpoints. */
3508 if (b
->type
== bp_single_step
)
3510 delete_breakpoint (b
);
3514 /* Longjmp and longjmp-resume breakpoints are also meaningless
3516 if (b
->type
== bp_longjmp
|| b
->type
== bp_longjmp_resume
3517 || b
->type
== bp_longjmp_call_dummy
3518 || b
->type
== bp_exception
|| b
->type
== bp_exception_resume
)
3520 delete_breakpoint (b
);
3524 if (b
->type
== bp_catchpoint
)
3526 /* For now, none of the bp_catchpoint breakpoints need to
3527 do anything at this point. In the future, if some of
3528 the catchpoints need to something, we will need to add
3529 a new method, and call this method from here. */
3533 /* bp_finish is a special case. The only way we ought to be able
3534 to see one of these when an exec() has happened, is if the user
3535 caught a vfork, and then said "finish". Ordinarily a finish just
3536 carries them to the call-site of the current callee, by setting
3537 a temporary bp there and resuming. But in this case, the finish
3538 will carry them entirely through the vfork & exec.
3540 We don't want to allow a bp_finish to remain inserted now. But
3541 we can't safely delete it, 'cause finish_command has a handle to
3542 the bp on a bpstat, and will later want to delete it. There's a
3543 chance (and I've seen it happen) that if we delete the bp_finish
3544 here, that its storage will get reused by the time finish_command
3545 gets 'round to deleting the "use to be a bp_finish" breakpoint.
3546 We really must allow finish_command to delete a bp_finish.
3548 In the absence of a general solution for the "how do we know
3549 it's safe to delete something others may have handles to?"
3550 problem, what we'll do here is just uninsert the bp_finish, and
3551 let finish_command delete it.
3553 (We know the bp_finish is "doomed" in the sense that it's
3554 momentary, and will be deleted as soon as finish_command sees
3555 the inferior stopped. So it doesn't matter that the bp's
3556 address is probably bogus in the new a.out, unlike e.g., the
3557 solib breakpoints.) */
3559 if (b
->type
== bp_finish
)
3564 /* Without a symbolic address, we have little hope of the
3565 pre-exec() address meaning the same thing in the post-exec()
3567 if (breakpoint_event_location_empty_p (b
))
3569 delete_breakpoint (b
);
3576 detach_breakpoints (ptid_t ptid
)
3578 struct bp_location
*bl
, **blp_tmp
;
3580 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
3581 struct inferior
*inf
= current_inferior ();
3583 if (ptid
.pid () == inferior_ptid
.pid ())
3584 error (_("Cannot detach breakpoints of inferior_ptid"));
3586 /* Set inferior_ptid; remove_breakpoint_1 uses this global. */
3587 inferior_ptid
= ptid
;
3588 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3590 if (bl
->pspace
!= inf
->pspace
)
3593 /* This function must physically remove breakpoints locations
3594 from the specified ptid, without modifying the breakpoint
3595 package's state. Locations of type bp_loc_other are only
3596 maintained at GDB side. So, there is no need to remove
3597 these bp_loc_other locations. Moreover, removing these
3598 would modify the breakpoint package's state. */
3599 if (bl
->loc_type
== bp_loc_other
)
3603 val
|= remove_breakpoint_1 (bl
, DETACH_BREAKPOINT
);
3609 /* Remove the breakpoint location BL from the current address space.
3610 Note that this is used to detach breakpoints from a child fork.
3611 When we get here, the child isn't in the inferior list, and neither
3612 do we have objects to represent its address space --- we should
3613 *not* look at bl->pspace->aspace here. */
3616 remove_breakpoint_1 (struct bp_location
*bl
, enum remove_bp_reason reason
)
3620 /* BL is never in moribund_locations by our callers. */
3621 gdb_assert (bl
->owner
!= NULL
);
3623 /* The type of none suggests that owner is actually deleted.
3624 This should not ever happen. */
3625 gdb_assert (bl
->owner
->type
!= bp_none
);
3627 if (bl
->loc_type
== bp_loc_software_breakpoint
3628 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
3630 /* "Normal" instruction breakpoint: either the standard
3631 trap-instruction bp (bp_breakpoint), or a
3632 bp_hardware_breakpoint. */
3634 /* First check to see if we have to handle an overlay. */
3635 if (overlay_debugging
== ovly_off
3636 || bl
->section
== NULL
3637 || !(section_is_overlay (bl
->section
)))
3639 /* No overlay handling: just remove the breakpoint. */
3641 /* If we're trying to uninsert a memory breakpoint that we
3642 know is set in a dynamic object that is marked
3643 shlib_disabled, then either the dynamic object was
3644 removed with "remove-symbol-file" or with
3645 "nosharedlibrary". In the former case, we don't know
3646 whether another dynamic object might have loaded over the
3647 breakpoint's address -- the user might well let us know
3648 about it next with add-symbol-file (the whole point of
3649 add-symbol-file is letting the user manually maintain a
3650 list of dynamically loaded objects). If we have the
3651 breakpoint's shadow memory, that is, this is a software
3652 breakpoint managed by GDB, check whether the breakpoint
3653 is still inserted in memory, to avoid overwriting wrong
3654 code with stale saved shadow contents. Note that HW
3655 breakpoints don't have shadow memory, as they're
3656 implemented using a mechanism that is not dependent on
3657 being able to modify the target's memory, and as such
3658 they should always be removed. */
3659 if (bl
->shlib_disabled
3660 && bl
->target_info
.shadow_len
!= 0
3661 && !memory_validate_breakpoint (bl
->gdbarch
, &bl
->target_info
))
3664 val
= bl
->owner
->ops
->remove_location (bl
, reason
);
3668 /* This breakpoint is in an overlay section.
3669 Did we set a breakpoint at the LMA? */
3670 if (!overlay_events_enabled
)
3672 /* Yes -- overlay event support is not active, so we
3673 should have set a breakpoint at the LMA. Remove it.
3675 /* Ignore any failures: if the LMA is in ROM, we will
3676 have already warned when we failed to insert it. */
3677 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
3678 target_remove_hw_breakpoint (bl
->gdbarch
,
3679 &bl
->overlay_target_info
);
3681 target_remove_breakpoint (bl
->gdbarch
,
3682 &bl
->overlay_target_info
,
3685 /* Did we set a breakpoint at the VMA?
3686 If so, we will have marked the breakpoint 'inserted'. */
3689 /* Yes -- remove it. Previously we did not bother to
3690 remove the breakpoint if the section had been
3691 unmapped, but let's not rely on that being safe. We
3692 don't know what the overlay manager might do. */
3694 /* However, we should remove *software* breakpoints only
3695 if the section is still mapped, or else we overwrite
3696 wrong code with the saved shadow contents. */
3697 if (bl
->loc_type
== bp_loc_hardware_breakpoint
3698 || section_is_mapped (bl
->section
))
3699 val
= bl
->owner
->ops
->remove_location (bl
, reason
);
3705 /* No -- not inserted, so no need to remove. No error. */
3710 /* In some cases, we might not be able to remove a breakpoint in
3711 a shared library that has already been removed, but we have
3712 not yet processed the shlib unload event. Similarly for an
3713 unloaded add-symbol-file object - the user might not yet have
3714 had the chance to remove-symbol-file it. shlib_disabled will
3715 be set if the library/object has already been removed, but
3716 the breakpoint hasn't been uninserted yet, e.g., after
3717 "nosharedlibrary" or "remove-symbol-file" with breakpoints
3718 always-inserted mode. */
3720 && (bl
->loc_type
== bp_loc_software_breakpoint
3721 && (bl
->shlib_disabled
3722 || solib_name_from_address (bl
->pspace
, bl
->address
)
3723 || shared_objfile_contains_address_p (bl
->pspace
,
3729 bl
->inserted
= (reason
== DETACH_BREAKPOINT
);
3731 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
)
3733 gdb_assert (bl
->owner
->ops
!= NULL
3734 && bl
->owner
->ops
->remove_location
!= NULL
);
3736 bl
->inserted
= (reason
== DETACH_BREAKPOINT
);
3737 bl
->owner
->ops
->remove_location (bl
, reason
);
3739 /* Failure to remove any of the hardware watchpoints comes here. */
3740 if (reason
== REMOVE_BREAKPOINT
&& bl
->inserted
)
3741 warning (_("Could not remove hardware watchpoint %d."),
3744 else if (bl
->owner
->type
== bp_catchpoint
3745 && breakpoint_enabled (bl
->owner
)
3748 gdb_assert (bl
->owner
->ops
!= NULL
3749 && bl
->owner
->ops
->remove_location
!= NULL
);
3751 val
= bl
->owner
->ops
->remove_location (bl
, reason
);
3755 bl
->inserted
= (reason
== DETACH_BREAKPOINT
);
3762 remove_breakpoint (struct bp_location
*bl
)
3764 /* BL is never in moribund_locations by our callers. */
3765 gdb_assert (bl
->owner
!= NULL
);
3767 /* The type of none suggests that owner is actually deleted.
3768 This should not ever happen. */
3769 gdb_assert (bl
->owner
->type
!= bp_none
);
3771 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
3773 switch_to_program_space_and_thread (bl
->pspace
);
3775 return remove_breakpoint_1 (bl
, REMOVE_BREAKPOINT
);
3778 /* Clear the "inserted" flag in all breakpoints. */
3781 mark_breakpoints_out (void)
3783 struct bp_location
*bl
, **blp_tmp
;
3785 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3786 if (bl
->pspace
== current_program_space
)
3790 /* Clear the "inserted" flag in all breakpoints and delete any
3791 breakpoints which should go away between runs of the program.
3793 Plus other such housekeeping that has to be done for breakpoints
3796 Note: this function gets called at the end of a run (by
3797 generic_mourn_inferior) and when a run begins (by
3798 init_wait_for_inferior). */
3803 breakpoint_init_inferior (enum inf_context context
)
3805 struct breakpoint
*b
, *b_tmp
;
3806 struct program_space
*pspace
= current_program_space
;
3808 /* If breakpoint locations are shared across processes, then there's
3810 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
3813 mark_breakpoints_out ();
3815 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
3817 if (b
->loc
&& b
->loc
->pspace
!= pspace
)
3823 case bp_longjmp_call_dummy
:
3825 /* If the call dummy breakpoint is at the entry point it will
3826 cause problems when the inferior is rerun, so we better get
3829 case bp_watchpoint_scope
:
3831 /* Also get rid of scope breakpoints. */
3833 case bp_shlib_event
:
3835 /* Also remove solib event breakpoints. Their addresses may
3836 have changed since the last time we ran the program.
3837 Actually we may now be debugging against different target;
3838 and so the solib backend that installed this breakpoint may
3839 not be used in by the target. E.g.,
3841 (gdb) file prog-linux
3842 (gdb) run # native linux target
3845 (gdb) file prog-win.exe
3846 (gdb) tar rem :9999 # remote Windows gdbserver.
3849 case bp_step_resume
:
3851 /* Also remove step-resume breakpoints. */
3853 case bp_single_step
:
3855 /* Also remove single-step breakpoints. */
3857 delete_breakpoint (b
);
3861 case bp_hardware_watchpoint
:
3862 case bp_read_watchpoint
:
3863 case bp_access_watchpoint
:
3865 struct watchpoint
*w
= (struct watchpoint
*) b
;
3867 /* Likewise for watchpoints on local expressions. */
3868 if (w
->exp_valid_block
!= NULL
)
3869 delete_breakpoint (b
);
3872 /* Get rid of existing locations, which are no longer
3873 valid. New ones will be created in
3874 update_watchpoint, when the inferior is restarted.
3875 The next update_global_location_list call will
3876 garbage collect them. */
3879 if (context
== inf_starting
)
3881 /* Reset val field to force reread of starting value in
3882 insert_breakpoints. */
3883 w
->val
.reset (nullptr);
3884 w
->val_valid
= false;
3894 /* Get rid of the moribund locations. */
3895 for (bp_location
*bl
: moribund_locations
)
3896 decref_bp_location (&bl
);
3897 moribund_locations
.clear ();
3900 /* These functions concern about actual breakpoints inserted in the
3901 target --- to e.g. check if we need to do decr_pc adjustment or if
3902 we need to hop over the bkpt --- so we check for address space
3903 match, not program space. */
3905 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
3906 exists at PC. It returns ordinary_breakpoint_here if it's an
3907 ordinary breakpoint, or permanent_breakpoint_here if it's a
3908 permanent breakpoint.
3909 - When continuing from a location with an ordinary breakpoint, we
3910 actually single step once before calling insert_breakpoints.
3911 - When continuing from a location with a permanent breakpoint, we
3912 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
3913 the target, to advance the PC past the breakpoint. */
3915 enum breakpoint_here
3916 breakpoint_here_p (const address_space
*aspace
, CORE_ADDR pc
)
3918 struct bp_location
*bl
, **blp_tmp
;
3919 int any_breakpoint_here
= 0;
3921 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3923 if (bl
->loc_type
!= bp_loc_software_breakpoint
3924 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
3927 /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
3928 if ((breakpoint_enabled (bl
->owner
)
3930 && breakpoint_location_address_match (bl
, aspace
, pc
))
3932 if (overlay_debugging
3933 && section_is_overlay (bl
->section
)
3934 && !section_is_mapped (bl
->section
))
3935 continue; /* unmapped overlay -- can't be a match */
3936 else if (bl
->permanent
)
3937 return permanent_breakpoint_here
;
3939 any_breakpoint_here
= 1;
3943 return any_breakpoint_here
? ordinary_breakpoint_here
: no_breakpoint_here
;
3946 /* See breakpoint.h. */
3949 breakpoint_in_range_p (const address_space
*aspace
,
3950 CORE_ADDR addr
, ULONGEST len
)
3952 struct bp_location
*bl
, **blp_tmp
;
3954 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3956 if (bl
->loc_type
!= bp_loc_software_breakpoint
3957 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
3960 if ((breakpoint_enabled (bl
->owner
)
3962 && breakpoint_location_address_range_overlap (bl
, aspace
,
3965 if (overlay_debugging
3966 && section_is_overlay (bl
->section
)
3967 && !section_is_mapped (bl
->section
))
3969 /* Unmapped overlay -- can't be a match. */
3980 /* Return true if there's a moribund breakpoint at PC. */
3983 moribund_breakpoint_here_p (const address_space
*aspace
, CORE_ADDR pc
)
3985 for (bp_location
*loc
: moribund_locations
)
3986 if (breakpoint_location_address_match (loc
, aspace
, pc
))
3992 /* Returns non-zero iff BL is inserted at PC, in address space
3996 bp_location_inserted_here_p (struct bp_location
*bl
,
3997 const address_space
*aspace
, CORE_ADDR pc
)
4000 && breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
4003 if (overlay_debugging
4004 && section_is_overlay (bl
->section
)
4005 && !section_is_mapped (bl
->section
))
4006 return 0; /* unmapped overlay -- can't be a match */
4013 /* Returns non-zero iff there's a breakpoint inserted at PC. */
4016 breakpoint_inserted_here_p (const address_space
*aspace
, CORE_ADDR pc
)
4018 struct bp_location
**blp
, **blp_tmp
= NULL
;
4020 ALL_BP_LOCATIONS_AT_ADDR (blp
, blp_tmp
, pc
)
4022 struct bp_location
*bl
= *blp
;
4024 if (bl
->loc_type
!= bp_loc_software_breakpoint
4025 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4028 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4034 /* This function returns non-zero iff there is a software breakpoint
4038 software_breakpoint_inserted_here_p (const address_space
*aspace
,
4041 struct bp_location
**blp
, **blp_tmp
= NULL
;
4043 ALL_BP_LOCATIONS_AT_ADDR (blp
, blp_tmp
, pc
)
4045 struct bp_location
*bl
= *blp
;
4047 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
4050 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4057 /* See breakpoint.h. */
4060 hardware_breakpoint_inserted_here_p (const address_space
*aspace
,
4063 struct bp_location
**blp
, **blp_tmp
= NULL
;
4065 ALL_BP_LOCATIONS_AT_ADDR (blp
, blp_tmp
, pc
)
4067 struct bp_location
*bl
= *blp
;
4069 if (bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4072 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4080 hardware_watchpoint_inserted_in_range (const address_space
*aspace
,
4081 CORE_ADDR addr
, ULONGEST len
)
4083 struct breakpoint
*bpt
;
4085 ALL_BREAKPOINTS (bpt
)
4087 struct bp_location
*loc
;
4089 if (bpt
->type
!= bp_hardware_watchpoint
4090 && bpt
->type
!= bp_access_watchpoint
)
4093 if (!breakpoint_enabled (bpt
))
4096 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
4097 if (loc
->pspace
->aspace
== aspace
&& loc
->inserted
)
4101 /* Check for intersection. */
4102 l
= std::max
<CORE_ADDR
> (loc
->address
, addr
);
4103 h
= std::min
<CORE_ADDR
> (loc
->address
+ loc
->length
, addr
+ len
);
4111 /* See breakpoint.h. */
4114 is_catchpoint (struct breakpoint
*b
)
4116 return (b
->type
== bp_catchpoint
);
4119 /* Frees any storage that is part of a bpstat. Does not walk the
4122 bpstats::~bpstats ()
4124 if (bp_location_at
!= NULL
)
4125 decref_bp_location (&bp_location_at
);
4128 /* Clear a bpstat so that it says we are not at any breakpoint.
4129 Also free any storage that is part of a bpstat. */
4132 bpstat_clear (bpstat
*bsp
)
4149 bpstats::bpstats (const bpstats
&other
)
4151 bp_location_at (other
.bp_location_at
),
4152 breakpoint_at (other
.breakpoint_at
),
4153 commands (other
.commands
),
4154 print (other
.print
),
4156 print_it (other
.print_it
)
4158 if (other
.old_val
!= NULL
)
4159 old_val
= release_value (value_copy (other
.old_val
.get ()));
4160 incref_bp_location (bp_location_at
);
4163 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
4164 is part of the bpstat is copied as well. */
4167 bpstat_copy (bpstat bs
)
4171 bpstat retval
= NULL
;
4176 for (; bs
!= NULL
; bs
= bs
->next
)
4178 tmp
= new bpstats (*bs
);
4181 /* This is the first thing in the chain. */
4191 /* Find the bpstat associated with this breakpoint. */
4194 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
4199 for (; bsp
!= NULL
; bsp
= bsp
->next
)
4201 if (bsp
->breakpoint_at
== breakpoint
)
4207 /* See breakpoint.h. */
4210 bpstat_explains_signal (bpstat bsp
, enum gdb_signal sig
)
4212 for (; bsp
!= NULL
; bsp
= bsp
->next
)
4214 if (bsp
->breakpoint_at
== NULL
)
4216 /* A moribund location can never explain a signal other than
4218 if (sig
== GDB_SIGNAL_TRAP
)
4223 if (bsp
->breakpoint_at
->ops
->explains_signal (bsp
->breakpoint_at
,
4232 /* Put in *NUM the breakpoint number of the first breakpoint we are
4233 stopped at. *BSP upon return is a bpstat which points to the
4234 remaining breakpoints stopped at (but which is not guaranteed to be
4235 good for anything but further calls to bpstat_num).
4237 Return 0 if passed a bpstat which does not indicate any breakpoints.
4238 Return -1 if stopped at a breakpoint that has been deleted since
4240 Return 1 otherwise. */
4243 bpstat_num (bpstat
*bsp
, int *num
)
4245 struct breakpoint
*b
;
4248 return 0; /* No more breakpoint values */
4250 /* We assume we'll never have several bpstats that correspond to a
4251 single breakpoint -- otherwise, this function might return the
4252 same number more than once and this will look ugly. */
4253 b
= (*bsp
)->breakpoint_at
;
4254 *bsp
= (*bsp
)->next
;
4256 return -1; /* breakpoint that's been deleted since */
4258 *num
= b
->number
; /* We have its number */
4262 /* See breakpoint.h. */
4265 bpstat_clear_actions (void)
4269 if (inferior_ptid
== null_ptid
)
4272 thread_info
*tp
= inferior_thread ();
4273 for (bs
= tp
->control
.stop_bpstat
; bs
!= NULL
; bs
= bs
->next
)
4275 bs
->commands
= NULL
;
4276 bs
->old_val
.reset (nullptr);
4280 /* Called when a command is about to proceed the inferior. */
4283 breakpoint_about_to_proceed (void)
4285 if (inferior_ptid
!= null_ptid
)
4287 struct thread_info
*tp
= inferior_thread ();
4289 /* Allow inferior function calls in breakpoint commands to not
4290 interrupt the command list. When the call finishes
4291 successfully, the inferior will be standing at the same
4292 breakpoint as if nothing happened. */
4293 if (tp
->control
.in_infcall
)
4297 breakpoint_proceeded
= 1;
4300 /* Return non-zero iff CMD as the first line of a command sequence is `silent'
4301 or its equivalent. */
4304 command_line_is_silent (struct command_line
*cmd
)
4306 return cmd
&& (strcmp ("silent", cmd
->line
) == 0);
4309 /* Execute all the commands associated with all the breakpoints at
4310 this location. Any of these commands could cause the process to
4311 proceed beyond this point, etc. We look out for such changes by
4312 checking the global "breakpoint_proceeded" after each command.
4314 Returns true if a breakpoint command resumed the inferior. In that
4315 case, it is the caller's responsibility to recall it again with the
4316 bpstat of the current thread. */
4319 bpstat_do_actions_1 (bpstat
*bsp
)
4324 /* Avoid endless recursion if a `source' command is contained
4326 if (executing_breakpoint_commands
)
4329 scoped_restore save_executing
4330 = make_scoped_restore (&executing_breakpoint_commands
, 1);
4332 scoped_restore preventer
= prevent_dont_repeat ();
4334 /* This pointer will iterate over the list of bpstat's. */
4337 breakpoint_proceeded
= 0;
4338 for (; bs
!= NULL
; bs
= bs
->next
)
4340 struct command_line
*cmd
= NULL
;
4342 /* Take ownership of the BSP's command tree, if it has one.
4344 The command tree could legitimately contain commands like
4345 'step' and 'next', which call clear_proceed_status, which
4346 frees stop_bpstat's command tree. To make sure this doesn't
4347 free the tree we're executing out from under us, we need to
4348 take ownership of the tree ourselves. Since a given bpstat's
4349 commands are only executed once, we don't need to copy it; we
4350 can clear the pointer in the bpstat, and make sure we free
4351 the tree when we're done. */
4352 counted_command_line ccmd
= bs
->commands
;
4353 bs
->commands
= NULL
;
4356 if (command_line_is_silent (cmd
))
4358 /* The action has been already done by bpstat_stop_status. */
4364 execute_control_command (cmd
);
4366 if (breakpoint_proceeded
)
4372 if (breakpoint_proceeded
)
4374 if (current_ui
->async
)
4375 /* If we are in async mode, then the target might be still
4376 running, not stopped at any breakpoint, so nothing for
4377 us to do here -- just return to the event loop. */
4380 /* In sync mode, when execute_control_command returns
4381 we're already standing on the next breakpoint.
4382 Breakpoint commands for that stop were not run, since
4383 execute_command does not run breakpoint commands --
4384 only command_line_handler does, but that one is not
4385 involved in execution of breakpoint commands. So, we
4386 can now execute breakpoint commands. It should be
4387 noted that making execute_command do bpstat actions is
4388 not an option -- in this case we'll have recursive
4389 invocation of bpstat for each breakpoint with a
4390 command, and can easily blow up GDB stack. Instead, we
4391 return true, which will trigger the caller to recall us
4392 with the new stop_bpstat. */
4400 /* Helper for bpstat_do_actions. Get the current thread, if there's
4401 one, is alive and has execution. Return NULL otherwise. */
4403 static thread_info
*
4404 get_bpstat_thread ()
4406 if (inferior_ptid
== null_ptid
|| !target_has_execution
)
4409 thread_info
*tp
= inferior_thread ();
4410 if (tp
->state
== THREAD_EXITED
|| tp
->executing
)
4416 bpstat_do_actions (void)
4418 auto cleanup_if_error
= make_scope_exit (bpstat_clear_actions
);
4421 /* Do any commands attached to breakpoint we are stopped at. */
4422 while ((tp
= get_bpstat_thread ()) != NULL
)
4424 /* Since in sync mode, bpstat_do_actions may resume the
4425 inferior, and only return when it is stopped at the next
4426 breakpoint, we keep doing breakpoint actions until it returns
4427 false to indicate the inferior was not resumed. */
4428 if (!bpstat_do_actions_1 (&tp
->control
.stop_bpstat
))
4432 cleanup_if_error
.release ();
4435 /* Print out the (old or new) value associated with a watchpoint. */
4438 watchpoint_value_print (struct value
*val
, struct ui_file
*stream
)
4441 fprintf_styled (stream
, metadata_style
.style (), _("<unreadable>"));
4444 struct value_print_options opts
;
4445 get_user_print_options (&opts
);
4446 value_print (val
, stream
, &opts
);
4450 /* Print the "Thread ID hit" part of "Thread ID hit Breakpoint N" if
4451 debugging multiple threads. */
4454 maybe_print_thread_hit_breakpoint (struct ui_out
*uiout
)
4456 if (uiout
->is_mi_like_p ())
4461 if (show_thread_that_caused_stop ())
4464 struct thread_info
*thr
= inferior_thread ();
4466 uiout
->text ("Thread ");
4467 uiout
->field_string ("thread-id", print_thread_id (thr
));
4469 name
= thr
->name
!= NULL
? thr
->name
: target_thread_name (thr
);
4472 uiout
->text (" \"");
4473 uiout
->field_string ("name", name
);
4477 uiout
->text (" hit ");
4481 /* Generic routine for printing messages indicating why we
4482 stopped. The behavior of this function depends on the value
4483 'print_it' in the bpstat structure. Under some circumstances we
4484 may decide not to print anything here and delegate the task to
4487 static enum print_stop_action
4488 print_bp_stop_message (bpstat bs
)
4490 switch (bs
->print_it
)
4493 /* Nothing should be printed for this bpstat entry. */
4494 return PRINT_UNKNOWN
;
4498 /* We still want to print the frame, but we already printed the
4499 relevant messages. */
4500 return PRINT_SRC_AND_LOC
;
4503 case print_it_normal
:
4505 struct breakpoint
*b
= bs
->breakpoint_at
;
4507 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
4508 which has since been deleted. */
4510 return PRINT_UNKNOWN
;
4512 /* Normal case. Call the breakpoint's print_it method. */
4513 return b
->ops
->print_it (bs
);
4518 internal_error (__FILE__
, __LINE__
,
4519 _("print_bp_stop_message: unrecognized enum value"));
4524 /* A helper function that prints a shared library stopped event. */
4527 print_solib_event (int is_catchpoint
)
4529 bool any_deleted
= !current_program_space
->deleted_solibs
.empty ();
4530 bool any_added
= !current_program_space
->added_solibs
.empty ();
4534 if (any_added
|| any_deleted
)
4535 current_uiout
->text (_("Stopped due to shared library event:\n"));
4537 current_uiout
->text (_("Stopped due to shared library event (no "
4538 "libraries added or removed)\n"));
4541 if (current_uiout
->is_mi_like_p ())
4542 current_uiout
->field_string ("reason",
4543 async_reason_lookup (EXEC_ASYNC_SOLIB_EVENT
));
4547 current_uiout
->text (_(" Inferior unloaded "));
4548 ui_out_emit_list
list_emitter (current_uiout
, "removed");
4549 for (int ix
= 0; ix
< current_program_space
->deleted_solibs
.size (); ix
++)
4551 const std::string
&name
= current_program_space
->deleted_solibs
[ix
];
4554 current_uiout
->text (" ");
4555 current_uiout
->field_string ("library", name
);
4556 current_uiout
->text ("\n");
4562 current_uiout
->text (_(" Inferior loaded "));
4563 ui_out_emit_list
list_emitter (current_uiout
, "added");
4565 for (so_list
*iter
: current_program_space
->added_solibs
)
4568 current_uiout
->text (" ");
4570 current_uiout
->field_string ("library", iter
->so_name
);
4571 current_uiout
->text ("\n");
4576 /* Print a message indicating what happened. This is called from
4577 normal_stop(). The input to this routine is the head of the bpstat
4578 list - a list of the eventpoints that caused this stop. KIND is
4579 the target_waitkind for the stopping event. This
4580 routine calls the generic print routine for printing a message
4581 about reasons for stopping. This will print (for example) the
4582 "Breakpoint n," part of the output. The return value of this
4585 PRINT_UNKNOWN: Means we printed nothing.
4586 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
4587 code to print the location. An example is
4588 "Breakpoint 1, " which should be followed by
4590 PRINT_SRC_ONLY: Means we printed something, but there is no need
4591 to also print the location part of the message.
4592 An example is the catch/throw messages, which
4593 don't require a location appended to the end.
4594 PRINT_NOTHING: We have done some printing and we don't need any
4595 further info to be printed. */
4597 enum print_stop_action
4598 bpstat_print (bpstat bs
, int kind
)
4600 enum print_stop_action val
;
4602 /* Maybe another breakpoint in the chain caused us to stop.
4603 (Currently all watchpoints go on the bpstat whether hit or not.
4604 That probably could (should) be changed, provided care is taken
4605 with respect to bpstat_explains_signal). */
4606 for (; bs
; bs
= bs
->next
)
4608 val
= print_bp_stop_message (bs
);
4609 if (val
== PRINT_SRC_ONLY
4610 || val
== PRINT_SRC_AND_LOC
4611 || val
== PRINT_NOTHING
)
4615 /* If we had hit a shared library event breakpoint,
4616 print_bp_stop_message would print out this message. If we hit an
4617 OS-level shared library event, do the same thing. */
4618 if (kind
== TARGET_WAITKIND_LOADED
)
4620 print_solib_event (0);
4621 return PRINT_NOTHING
;
4624 /* We reached the end of the chain, or we got a null BS to start
4625 with and nothing was printed. */
4626 return PRINT_UNKNOWN
;
4629 /* Evaluate the boolean expression EXP and return the result. */
4632 breakpoint_cond_eval (expression
*exp
)
4634 struct value
*mark
= value_mark ();
4635 bool res
= value_true (evaluate_expression (exp
));
4637 value_free_to_mark (mark
);
4641 /* Allocate a new bpstat. Link it to the FIFO list by BS_LINK_POINTER. */
4643 bpstats::bpstats (struct bp_location
*bl
, bpstat
**bs_link_pointer
)
4645 bp_location_at (bl
),
4646 breakpoint_at (bl
->owner
),
4650 print_it (print_it_normal
)
4652 incref_bp_location (bl
);
4653 **bs_link_pointer
= this;
4654 *bs_link_pointer
= &next
;
4659 bp_location_at (NULL
),
4660 breakpoint_at (NULL
),
4664 print_it (print_it_normal
)
4668 /* The target has stopped with waitstatus WS. Check if any hardware
4669 watchpoints have triggered, according to the target. */
4672 watchpoints_triggered (struct target_waitstatus
*ws
)
4674 bool stopped_by_watchpoint
= target_stopped_by_watchpoint ();
4676 struct breakpoint
*b
;
4678 if (!stopped_by_watchpoint
)
4680 /* We were not stopped by a watchpoint. Mark all watchpoints
4681 as not triggered. */
4683 if (is_hardware_watchpoint (b
))
4685 struct watchpoint
*w
= (struct watchpoint
*) b
;
4687 w
->watchpoint_triggered
= watch_triggered_no
;
4693 if (!target_stopped_data_address (current_top_target (), &addr
))
4695 /* We were stopped by a watchpoint, but we don't know where.
4696 Mark all watchpoints as unknown. */
4698 if (is_hardware_watchpoint (b
))
4700 struct watchpoint
*w
= (struct watchpoint
*) b
;
4702 w
->watchpoint_triggered
= watch_triggered_unknown
;
4708 /* The target could report the data address. Mark watchpoints
4709 affected by this data address as triggered, and all others as not
4713 if (is_hardware_watchpoint (b
))
4715 struct watchpoint
*w
= (struct watchpoint
*) b
;
4716 struct bp_location
*loc
;
4718 w
->watchpoint_triggered
= watch_triggered_no
;
4719 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
4721 if (is_masked_watchpoint (b
))
4723 CORE_ADDR newaddr
= addr
& w
->hw_wp_mask
;
4724 CORE_ADDR start
= loc
->address
& w
->hw_wp_mask
;
4726 if (newaddr
== start
)
4728 w
->watchpoint_triggered
= watch_triggered_yes
;
4732 /* Exact match not required. Within range is sufficient. */
4733 else if (target_watchpoint_addr_within_range (current_top_target (),
4737 w
->watchpoint_triggered
= watch_triggered_yes
;
4746 /* Possible return values for watchpoint_check. */
4747 enum wp_check_result
4749 /* The watchpoint has been deleted. */
4752 /* The value has changed. */
4753 WP_VALUE_CHANGED
= 2,
4755 /* The value has not changed. */
4756 WP_VALUE_NOT_CHANGED
= 3,
4758 /* Ignore this watchpoint, no matter if the value changed or not. */
4762 #define BP_TEMPFLAG 1
4763 #define BP_HARDWAREFLAG 2
4765 /* Evaluate watchpoint condition expression and check if its value
4768 static wp_check_result
4769 watchpoint_check (bpstat bs
)
4771 struct watchpoint
*b
;
4772 struct frame_info
*fr
;
4773 int within_current_scope
;
4775 /* BS is built from an existing struct breakpoint. */
4776 gdb_assert (bs
->breakpoint_at
!= NULL
);
4777 b
= (struct watchpoint
*) bs
->breakpoint_at
;
4779 /* If this is a local watchpoint, we only want to check if the
4780 watchpoint frame is in scope if the current thread is the thread
4781 that was used to create the watchpoint. */
4782 if (!watchpoint_in_thread_scope (b
))
4785 if (b
->exp_valid_block
== NULL
)
4786 within_current_scope
= 1;
4789 struct frame_info
*frame
= get_current_frame ();
4790 struct gdbarch
*frame_arch
= get_frame_arch (frame
);
4791 CORE_ADDR frame_pc
= get_frame_pc (frame
);
4793 /* stack_frame_destroyed_p() returns a non-zero value if we're
4794 still in the function but the stack frame has already been
4795 invalidated. Since we can't rely on the values of local
4796 variables after the stack has been destroyed, we are treating
4797 the watchpoint in that state as `not changed' without further
4798 checking. Don't mark watchpoints as changed if the current
4799 frame is in an epilogue - even if they are in some other
4800 frame, our view of the stack is likely to be wrong and
4801 frame_find_by_id could error out. */
4802 if (gdbarch_stack_frame_destroyed_p (frame_arch
, frame_pc
))
4805 fr
= frame_find_by_id (b
->watchpoint_frame
);
4806 within_current_scope
= (fr
!= NULL
);
4808 /* If we've gotten confused in the unwinder, we might have
4809 returned a frame that can't describe this variable. */
4810 if (within_current_scope
)
4812 struct symbol
*function
;
4814 function
= get_frame_function (fr
);
4815 if (function
== NULL
4816 || !contained_in (b
->exp_valid_block
,
4817 SYMBOL_BLOCK_VALUE (function
)))
4818 within_current_scope
= 0;
4821 if (within_current_scope
)
4822 /* If we end up stopping, the current frame will get selected
4823 in normal_stop. So this call to select_frame won't affect
4828 if (within_current_scope
)
4830 /* We use value_{,free_to_}mark because it could be a *long*
4831 time before we return to the command level and call
4832 free_all_values. We can't call free_all_values because we
4833 might be in the middle of evaluating a function call. */
4837 struct value
*new_val
;
4839 if (is_masked_watchpoint (b
))
4840 /* Since we don't know the exact trigger address (from
4841 stopped_data_address), just tell the user we've triggered
4842 a mask watchpoint. */
4843 return WP_VALUE_CHANGED
;
4845 mark
= value_mark ();
4846 fetch_subexp_value (b
->exp
.get (), &pc
, &new_val
, NULL
, NULL
, 0);
4848 if (b
->val_bitsize
!= 0)
4849 new_val
= extract_bitfield_from_watchpoint_value (b
, new_val
);
4851 /* We use value_equal_contents instead of value_equal because
4852 the latter coerces an array to a pointer, thus comparing just
4853 the address of the array instead of its contents. This is
4854 not what we want. */
4855 if ((b
->val
!= NULL
) != (new_val
!= NULL
)
4856 || (b
->val
!= NULL
&& !value_equal_contents (b
->val
.get (),
4859 bs
->old_val
= b
->val
;
4860 b
->val
= release_value (new_val
);
4861 b
->val_valid
= true;
4862 if (new_val
!= NULL
)
4863 value_free_to_mark (mark
);
4864 return WP_VALUE_CHANGED
;
4868 /* Nothing changed. */
4869 value_free_to_mark (mark
);
4870 return WP_VALUE_NOT_CHANGED
;
4875 /* This seems like the only logical thing to do because
4876 if we temporarily ignored the watchpoint, then when
4877 we reenter the block in which it is valid it contains
4878 garbage (in the case of a function, it may have two
4879 garbage values, one before and one after the prologue).
4880 So we can't even detect the first assignment to it and
4881 watch after that (since the garbage may or may not equal
4882 the first value assigned). */
4883 /* We print all the stop information in
4884 breakpoint_ops->print_it, but in this case, by the time we
4885 call breakpoint_ops->print_it this bp will be deleted
4886 already. So we have no choice but print the information
4889 SWITCH_THRU_ALL_UIS ()
4891 struct ui_out
*uiout
= current_uiout
;
4893 if (uiout
->is_mi_like_p ())
4895 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
4896 uiout
->message ("\nWatchpoint %pF deleted because the program has "
4897 "left the block in\n"
4898 "which its expression is valid.\n",
4899 signed_field ("wpnum", b
->number
));
4902 /* Make sure the watchpoint's commands aren't executed. */
4904 watchpoint_del_at_next_stop (b
);
4910 /* Return true if it looks like target has stopped due to hitting
4911 breakpoint location BL. This function does not check if we should
4912 stop, only if BL explains the stop. */
4915 bpstat_check_location (const struct bp_location
*bl
,
4916 const address_space
*aspace
, CORE_ADDR bp_addr
,
4917 const struct target_waitstatus
*ws
)
4919 struct breakpoint
*b
= bl
->owner
;
4921 /* BL is from an existing breakpoint. */
4922 gdb_assert (b
!= NULL
);
4924 return b
->ops
->breakpoint_hit (bl
, aspace
, bp_addr
, ws
);
4927 /* Determine if the watched values have actually changed, and we
4928 should stop. If not, set BS->stop to 0. */
4931 bpstat_check_watchpoint (bpstat bs
)
4933 const struct bp_location
*bl
;
4934 struct watchpoint
*b
;
4936 /* BS is built for existing struct breakpoint. */
4937 bl
= bs
->bp_location_at
;
4938 gdb_assert (bl
!= NULL
);
4939 b
= (struct watchpoint
*) bs
->breakpoint_at
;
4940 gdb_assert (b
!= NULL
);
4943 int must_check_value
= 0;
4945 if (b
->type
== bp_watchpoint
)
4946 /* For a software watchpoint, we must always check the
4948 must_check_value
= 1;
4949 else if (b
->watchpoint_triggered
== watch_triggered_yes
)
4950 /* We have a hardware watchpoint (read, write, or access)
4951 and the target earlier reported an address watched by
4953 must_check_value
= 1;
4954 else if (b
->watchpoint_triggered
== watch_triggered_unknown
4955 && b
->type
== bp_hardware_watchpoint
)
4956 /* We were stopped by a hardware watchpoint, but the target could
4957 not report the data address. We must check the watchpoint's
4958 value. Access and read watchpoints are out of luck; without
4959 a data address, we can't figure it out. */
4960 must_check_value
= 1;
4962 if (must_check_value
)
4968 e
= watchpoint_check (bs
);
4970 catch (const gdb_exception
&ex
)
4972 exception_fprintf (gdb_stderr
, ex
,
4973 "Error evaluating expression "
4974 "for watchpoint %d\n",
4977 SWITCH_THRU_ALL_UIS ()
4979 printf_filtered (_("Watchpoint %d deleted.\n"),
4982 watchpoint_del_at_next_stop (b
);
4989 /* We've already printed what needs to be printed. */
4990 bs
->print_it
= print_it_done
;
4994 bs
->print_it
= print_it_noop
;
4997 case WP_VALUE_CHANGED
:
4998 if (b
->type
== bp_read_watchpoint
)
5000 /* There are two cases to consider here:
5002 1. We're watching the triggered memory for reads.
5003 In that case, trust the target, and always report
5004 the watchpoint hit to the user. Even though
5005 reads don't cause value changes, the value may
5006 have changed since the last time it was read, and
5007 since we're not trapping writes, we will not see
5008 those, and as such we should ignore our notion of
5011 2. We're watching the triggered memory for both
5012 reads and writes. There are two ways this may
5015 2.1. This is a target that can't break on data
5016 reads only, but can break on accesses (reads or
5017 writes), such as e.g., x86. We detect this case
5018 at the time we try to insert read watchpoints.
5020 2.2. Otherwise, the target supports read
5021 watchpoints, but, the user set an access or write
5022 watchpoint watching the same memory as this read
5025 If we're watching memory writes as well as reads,
5026 ignore watchpoint hits when we find that the
5027 value hasn't changed, as reads don't cause
5028 changes. This still gives false positives when
5029 the program writes the same value to memory as
5030 what there was already in memory (we will confuse
5031 it for a read), but it's much better than
5034 int other_write_watchpoint
= 0;
5036 if (bl
->watchpoint_type
== hw_read
)
5038 struct breakpoint
*other_b
;
5040 ALL_BREAKPOINTS (other_b
)
5041 if (other_b
->type
== bp_hardware_watchpoint
5042 || other_b
->type
== bp_access_watchpoint
)
5044 struct watchpoint
*other_w
=
5045 (struct watchpoint
*) other_b
;
5047 if (other_w
->watchpoint_triggered
5048 == watch_triggered_yes
)
5050 other_write_watchpoint
= 1;
5056 if (other_write_watchpoint
5057 || bl
->watchpoint_type
== hw_access
)
5059 /* We're watching the same memory for writes,
5060 and the value changed since the last time we
5061 updated it, so this trap must be for a write.
5063 bs
->print_it
= print_it_noop
;
5068 case WP_VALUE_NOT_CHANGED
:
5069 if (b
->type
== bp_hardware_watchpoint
5070 || b
->type
== bp_watchpoint
)
5072 /* Don't stop: write watchpoints shouldn't fire if
5073 the value hasn't changed. */
5074 bs
->print_it
= print_it_noop
;
5084 else /* must_check_value == 0 */
5086 /* This is a case where some watchpoint(s) triggered, but
5087 not at the address of this watchpoint, or else no
5088 watchpoint triggered after all. So don't print
5089 anything for this watchpoint. */
5090 bs
->print_it
= print_it_noop
;
5096 /* For breakpoints that are currently marked as telling gdb to stop,
5097 check conditions (condition proper, frame, thread and ignore count)
5098 of breakpoint referred to by BS. If we should not stop for this
5099 breakpoint, set BS->stop to 0. */
5102 bpstat_check_breakpoint_conditions (bpstat bs
, thread_info
*thread
)
5104 const struct bp_location
*bl
;
5105 struct breakpoint
*b
;
5107 bool condition_result
= true;
5108 struct expression
*cond
;
5110 gdb_assert (bs
->stop
);
5112 /* BS is built for existing struct breakpoint. */
5113 bl
= bs
->bp_location_at
;
5114 gdb_assert (bl
!= NULL
);
5115 b
= bs
->breakpoint_at
;
5116 gdb_assert (b
!= NULL
);
5118 /* Even if the target evaluated the condition on its end and notified GDB, we
5119 need to do so again since GDB does not know if we stopped due to a
5120 breakpoint or a single step breakpoint. */
5122 if (frame_id_p (b
->frame_id
)
5123 && !frame_id_eq (b
->frame_id
, get_stack_frame_id (get_current_frame ())))
5129 /* If this is a thread/task-specific breakpoint, don't waste cpu
5130 evaluating the condition if this isn't the specified
5132 if ((b
->thread
!= -1 && b
->thread
!= thread
->global_num
)
5133 || (b
->task
!= 0 && b
->task
!= ada_get_task_number (thread
)))
5139 /* Evaluate extension language breakpoints that have a "stop" method
5141 bs
->stop
= breakpoint_ext_lang_cond_says_stop (b
);
5143 if (is_watchpoint (b
))
5145 struct watchpoint
*w
= (struct watchpoint
*) b
;
5147 cond
= w
->cond_exp
.get ();
5150 cond
= bl
->cond
.get ();
5152 if (cond
&& b
->disposition
!= disp_del_at_next_stop
)
5154 int within_current_scope
= 1;
5155 struct watchpoint
* w
;
5157 /* We use value_mark and value_free_to_mark because it could
5158 be a long time before we return to the command level and
5159 call free_all_values. We can't call free_all_values
5160 because we might be in the middle of evaluating a
5162 struct value
*mark
= value_mark ();
5164 if (is_watchpoint (b
))
5165 w
= (struct watchpoint
*) b
;
5169 /* Need to select the frame, with all that implies so that
5170 the conditions will have the right context. Because we
5171 use the frame, we will not see an inlined function's
5172 variables when we arrive at a breakpoint at the start
5173 of the inlined function; the current frame will be the
5175 if (w
== NULL
|| w
->cond_exp_valid_block
== NULL
)
5176 select_frame (get_current_frame ());
5179 struct frame_info
*frame
;
5181 /* For local watchpoint expressions, which particular
5182 instance of a local is being watched matters, so we
5183 keep track of the frame to evaluate the expression
5184 in. To evaluate the condition however, it doesn't
5185 really matter which instantiation of the function
5186 where the condition makes sense triggers the
5187 watchpoint. This allows an expression like "watch
5188 global if q > 10" set in `func', catch writes to
5189 global on all threads that call `func', or catch
5190 writes on all recursive calls of `func' by a single
5191 thread. We simply always evaluate the condition in
5192 the innermost frame that's executing where it makes
5193 sense to evaluate the condition. It seems
5195 frame
= block_innermost_frame (w
->cond_exp_valid_block
);
5197 select_frame (frame
);
5199 within_current_scope
= 0;
5201 if (within_current_scope
)
5205 condition_result
= breakpoint_cond_eval (cond
);
5207 catch (const gdb_exception
&ex
)
5209 exception_fprintf (gdb_stderr
, ex
,
5210 "Error in testing breakpoint condition:\n");
5215 warning (_("Watchpoint condition cannot be tested "
5216 "in the current scope"));
5217 /* If we failed to set the right context for this
5218 watchpoint, unconditionally report it. */
5220 /* FIXME-someday, should give breakpoint #. */
5221 value_free_to_mark (mark
);
5224 if (cond
&& !condition_result
)
5228 else if (b
->ignore_count
> 0)
5232 /* Increase the hit count even though we don't stop. */
5234 gdb::observers::breakpoint_modified
.notify (b
);
5238 /* Returns true if we need to track moribund locations of LOC's type
5239 on the current target. */
5242 need_moribund_for_location_type (struct bp_location
*loc
)
5244 return ((loc
->loc_type
== bp_loc_software_breakpoint
5245 && !target_supports_stopped_by_sw_breakpoint ())
5246 || (loc
->loc_type
== bp_loc_hardware_breakpoint
5247 && !target_supports_stopped_by_hw_breakpoint ()));
5250 /* See breakpoint.h. */
5253 build_bpstat_chain (const address_space
*aspace
, CORE_ADDR bp_addr
,
5254 const struct target_waitstatus
*ws
)
5256 struct breakpoint
*b
;
5257 bpstat bs_head
= NULL
, *bs_link
= &bs_head
;
5261 if (!breakpoint_enabled (b
))
5264 for (bp_location
*bl
= b
->loc
; bl
!= NULL
; bl
= bl
->next
)
5266 /* For hardware watchpoints, we look only at the first
5267 location. The watchpoint_check function will work on the
5268 entire expression, not the individual locations. For
5269 read watchpoints, the watchpoints_triggered function has
5270 checked all locations already. */
5271 if (b
->type
== bp_hardware_watchpoint
&& bl
!= b
->loc
)
5274 if (!bl
->enabled
|| bl
->shlib_disabled
)
5277 if (!bpstat_check_location (bl
, aspace
, bp_addr
, ws
))
5280 /* Come here if it's a watchpoint, or if the break address
5283 bpstat bs
= new bpstats (bl
, &bs_link
); /* Alloc a bpstat to
5286 /* Assume we stop. Should we find a watchpoint that is not
5287 actually triggered, or if the condition of the breakpoint
5288 evaluates as false, we'll reset 'stop' to 0. */
5292 /* If this is a scope breakpoint, mark the associated
5293 watchpoint as triggered so that we will handle the
5294 out-of-scope event. We'll get to the watchpoint next
5296 if (b
->type
== bp_watchpoint_scope
&& b
->related_breakpoint
!= b
)
5298 struct watchpoint
*w
= (struct watchpoint
*) b
->related_breakpoint
;
5300 w
->watchpoint_triggered
= watch_triggered_yes
;
5305 /* Check if a moribund breakpoint explains the stop. */
5306 if (!target_supports_stopped_by_sw_breakpoint ()
5307 || !target_supports_stopped_by_hw_breakpoint ())
5309 for (bp_location
*loc
: moribund_locations
)
5311 if (breakpoint_location_address_match (loc
, aspace
, bp_addr
)
5312 && need_moribund_for_location_type (loc
))
5314 bpstat bs
= new bpstats (loc
, &bs_link
);
5315 /* For hits of moribund locations, we should just proceed. */
5318 bs
->print_it
= print_it_noop
;
5326 /* See breakpoint.h. */
5329 bpstat_stop_status (const address_space
*aspace
,
5330 CORE_ADDR bp_addr
, thread_info
*thread
,
5331 const struct target_waitstatus
*ws
,
5334 struct breakpoint
*b
= NULL
;
5335 /* First item of allocated bpstat's. */
5336 bpstat bs_head
= stop_chain
;
5338 int need_remove_insert
;
5341 /* First, build the bpstat chain with locations that explain a
5342 target stop, while being careful to not set the target running,
5343 as that may invalidate locations (in particular watchpoint
5344 locations are recreated). Resuming will happen here with
5345 breakpoint conditions or watchpoint expressions that include
5346 inferior function calls. */
5347 if (bs_head
== NULL
)
5348 bs_head
= build_bpstat_chain (aspace
, bp_addr
, ws
);
5350 /* A bit of special processing for shlib breakpoints. We need to
5351 process solib loading here, so that the lists of loaded and
5352 unloaded libraries are correct before we handle "catch load" and
5354 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5356 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->type
== bp_shlib_event
)
5358 handle_solib_event ();
5363 /* Now go through the locations that caused the target to stop, and
5364 check whether we're interested in reporting this stop to higher
5365 layers, or whether we should resume the target transparently. */
5369 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5374 b
= bs
->breakpoint_at
;
5375 b
->ops
->check_status (bs
);
5378 bpstat_check_breakpoint_conditions (bs
, thread
);
5383 gdb::observers::breakpoint_modified
.notify (b
);
5385 /* We will stop here. */
5386 if (b
->disposition
== disp_disable
)
5388 --(b
->enable_count
);
5389 if (b
->enable_count
<= 0)
5390 b
->enable_state
= bp_disabled
;
5395 bs
->commands
= b
->commands
;
5396 if (command_line_is_silent (bs
->commands
5397 ? bs
->commands
.get () : NULL
))
5400 b
->ops
->after_condition_true (bs
);
5405 /* Print nothing for this entry if we don't stop or don't
5407 if (!bs
->stop
|| !bs
->print
)
5408 bs
->print_it
= print_it_noop
;
5411 /* If we aren't stopping, the value of some hardware watchpoint may
5412 not have changed, but the intermediate memory locations we are
5413 watching may have. Don't bother if we're stopping; this will get
5415 need_remove_insert
= 0;
5416 if (! bpstat_causes_stop (bs_head
))
5417 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5419 && bs
->breakpoint_at
5420 && is_hardware_watchpoint (bs
->breakpoint_at
))
5422 struct watchpoint
*w
= (struct watchpoint
*) bs
->breakpoint_at
;
5424 update_watchpoint (w
, 0 /* don't reparse. */);
5425 need_remove_insert
= 1;
5428 if (need_remove_insert
)
5429 update_global_location_list (UGLL_MAY_INSERT
);
5430 else if (removed_any
)
5431 update_global_location_list (UGLL_DONT_INSERT
);
5437 handle_jit_event (void)
5439 struct frame_info
*frame
;
5440 struct gdbarch
*gdbarch
;
5443 fprintf_unfiltered (gdb_stdlog
, "handling bp_jit_event\n");
5445 /* Switch terminal for any messages produced by
5446 breakpoint_re_set. */
5447 target_terminal::ours_for_output ();
5449 frame
= get_current_frame ();
5450 gdbarch
= get_frame_arch (frame
);
5451 objfile
*jiter
= symbol_objfile (get_frame_function (frame
));
5453 jit_event_handler (gdbarch
, jiter
);
5455 target_terminal::inferior ();
5458 /* Prepare WHAT final decision for infrun. */
5460 /* Decide what infrun needs to do with this bpstat. */
5463 bpstat_what (bpstat bs_head
)
5465 struct bpstat_what retval
;
5468 retval
.main_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5469 retval
.call_dummy
= STOP_NONE
;
5470 retval
.is_longjmp
= false;
5472 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5474 /* Extract this BS's action. After processing each BS, we check
5475 if its action overrides all we've seem so far. */
5476 enum bpstat_what_main_action this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5479 if (bs
->breakpoint_at
== NULL
)
5481 /* I suspect this can happen if it was a momentary
5482 breakpoint which has since been deleted. */
5486 bptype
= bs
->breakpoint_at
->type
;
5493 case bp_hardware_breakpoint
:
5494 case bp_single_step
:
5497 case bp_shlib_event
:
5501 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5503 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5506 this_action
= BPSTAT_WHAT_SINGLE
;
5509 case bp_hardware_watchpoint
:
5510 case bp_read_watchpoint
:
5511 case bp_access_watchpoint
:
5515 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5517 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5521 /* There was a watchpoint, but we're not stopping.
5522 This requires no further action. */
5526 case bp_longjmp_call_dummy
:
5530 this_action
= BPSTAT_WHAT_SET_LONGJMP_RESUME
;
5531 retval
.is_longjmp
= bptype
!= bp_exception
;
5534 this_action
= BPSTAT_WHAT_SINGLE
;
5536 case bp_longjmp_resume
:
5537 case bp_exception_resume
:
5540 this_action
= BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
;
5541 retval
.is_longjmp
= bptype
== bp_longjmp_resume
;
5544 this_action
= BPSTAT_WHAT_SINGLE
;
5546 case bp_step_resume
:
5548 this_action
= BPSTAT_WHAT_STEP_RESUME
;
5551 /* It is for the wrong frame. */
5552 this_action
= BPSTAT_WHAT_SINGLE
;
5555 case bp_hp_step_resume
:
5557 this_action
= BPSTAT_WHAT_HP_STEP_RESUME
;
5560 /* It is for the wrong frame. */
5561 this_action
= BPSTAT_WHAT_SINGLE
;
5564 case bp_watchpoint_scope
:
5565 case bp_thread_event
:
5566 case bp_overlay_event
:
5567 case bp_longjmp_master
:
5568 case bp_std_terminate_master
:
5569 case bp_exception_master
:
5570 this_action
= BPSTAT_WHAT_SINGLE
;
5576 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5578 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5582 /* Some catchpoints are implemented with breakpoints.
5583 For those, we need to step over the breakpoint. */
5584 if (bs
->bp_location_at
->loc_type
!= bp_loc_other
)
5585 this_action
= BPSTAT_WHAT_SINGLE
;
5589 this_action
= BPSTAT_WHAT_SINGLE
;
5592 /* Make sure the action is stop (silent or noisy),
5593 so infrun.c pops the dummy frame. */
5594 retval
.call_dummy
= STOP_STACK_DUMMY
;
5595 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5597 case bp_std_terminate
:
5598 /* Make sure the action is stop (silent or noisy),
5599 so infrun.c pops the dummy frame. */
5600 retval
.call_dummy
= STOP_STD_TERMINATE
;
5601 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5604 case bp_fast_tracepoint
:
5605 case bp_static_tracepoint
:
5606 /* Tracepoint hits should not be reported back to GDB, and
5607 if one got through somehow, it should have been filtered
5609 internal_error (__FILE__
, __LINE__
,
5610 _("bpstat_what: tracepoint encountered"));
5612 case bp_gnu_ifunc_resolver
:
5613 /* Step over it (and insert bp_gnu_ifunc_resolver_return). */
5614 this_action
= BPSTAT_WHAT_SINGLE
;
5616 case bp_gnu_ifunc_resolver_return
:
5617 /* The breakpoint will be removed, execution will restart from the
5618 PC of the former breakpoint. */
5619 this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5624 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5626 this_action
= BPSTAT_WHAT_SINGLE
;
5630 internal_error (__FILE__
, __LINE__
,
5631 _("bpstat_what: unhandled bptype %d"), (int) bptype
);
5634 retval
.main_action
= std::max (retval
.main_action
, this_action
);
5641 bpstat_run_callbacks (bpstat bs_head
)
5645 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5647 struct breakpoint
*b
= bs
->breakpoint_at
;
5654 handle_jit_event ();
5656 case bp_gnu_ifunc_resolver
:
5657 gnu_ifunc_resolver_stop (b
);
5659 case bp_gnu_ifunc_resolver_return
:
5660 gnu_ifunc_resolver_return_stop (b
);
5666 /* See breakpoint.h. */
5669 bpstat_should_step ()
5671 struct breakpoint
*b
;
5674 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
&& b
->loc
!= NULL
)
5679 /* See breakpoint.h. */
5682 bpstat_causes_stop (bpstat bs
)
5684 for (; bs
!= NULL
; bs
= bs
->next
)
5693 /* Compute a string of spaces suitable to indent the next line
5694 so it starts at the position corresponding to the table column
5695 named COL_NAME in the currently active table of UIOUT. */
5698 wrap_indent_at_field (struct ui_out
*uiout
, const char *col_name
)
5700 static char wrap_indent
[80];
5701 int i
, total_width
, width
, align
;
5705 for (i
= 1; uiout
->query_table_field (i
, &width
, &align
, &text
); i
++)
5707 if (strcmp (text
, col_name
) == 0)
5709 gdb_assert (total_width
< sizeof wrap_indent
);
5710 memset (wrap_indent
, ' ', total_width
);
5711 wrap_indent
[total_width
] = 0;
5716 total_width
+= width
+ 1;
5722 /* Determine if the locations of this breakpoint will have their conditions
5723 evaluated by the target, host or a mix of both. Returns the following:
5725 "host": Host evals condition.
5726 "host or target": Host or Target evals condition.
5727 "target": Target evals condition.
5731 bp_condition_evaluator (struct breakpoint
*b
)
5733 struct bp_location
*bl
;
5734 char host_evals
= 0;
5735 char target_evals
= 0;
5740 if (!is_breakpoint (b
))
5743 if (gdb_evaluates_breakpoint_condition_p ()
5744 || !target_supports_evaluation_of_breakpoint_conditions ())
5745 return condition_evaluation_host
;
5747 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
5749 if (bl
->cond_bytecode
)
5755 if (host_evals
&& target_evals
)
5756 return condition_evaluation_both
;
5757 else if (target_evals
)
5758 return condition_evaluation_target
;
5760 return condition_evaluation_host
;
5763 /* Determine the breakpoint location's condition evaluator. This is
5764 similar to bp_condition_evaluator, but for locations. */
5767 bp_location_condition_evaluator (struct bp_location
*bl
)
5769 if (bl
&& !is_breakpoint (bl
->owner
))
5772 if (gdb_evaluates_breakpoint_condition_p ()
5773 || !target_supports_evaluation_of_breakpoint_conditions ())
5774 return condition_evaluation_host
;
5776 if (bl
&& bl
->cond_bytecode
)
5777 return condition_evaluation_target
;
5779 return condition_evaluation_host
;
5782 /* Print the LOC location out of the list of B->LOC locations. */
5785 print_breakpoint_location (struct breakpoint
*b
,
5786 struct bp_location
*loc
)
5788 struct ui_out
*uiout
= current_uiout
;
5790 scoped_restore_current_program_space restore_pspace
;
5792 if (loc
!= NULL
&& loc
->shlib_disabled
)
5796 set_current_program_space (loc
->pspace
);
5798 if (b
->display_canonical
)
5799 uiout
->field_string ("what", event_location_to_string (b
->location
.get ()));
5800 else if (loc
&& loc
->symtab
)
5802 const struct symbol
*sym
= loc
->symbol
;
5806 uiout
->text ("in ");
5807 uiout
->field_string ("func", sym
->print_name (),
5808 function_name_style
.style ());
5810 uiout
->wrap_hint (wrap_indent_at_field (uiout
, "what"));
5811 uiout
->text ("at ");
5813 uiout
->field_string ("file",
5814 symtab_to_filename_for_display (loc
->symtab
),
5815 file_name_style
.style ());
5818 if (uiout
->is_mi_like_p ())
5819 uiout
->field_string ("fullname", symtab_to_fullname (loc
->symtab
));
5821 uiout
->field_signed ("line", loc
->line_number
);
5827 print_address_symbolic (loc
->gdbarch
, loc
->address
, &stb
,
5829 uiout
->field_stream ("at", stb
);
5833 uiout
->field_string ("pending",
5834 event_location_to_string (b
->location
.get ()));
5835 /* If extra_string is available, it could be holding a condition
5836 or dprintf arguments. In either case, make sure it is printed,
5837 too, but only for non-MI streams. */
5838 if (!uiout
->is_mi_like_p () && b
->extra_string
!= NULL
)
5840 if (b
->type
== bp_dprintf
)
5844 uiout
->text (b
->extra_string
);
5848 if (loc
&& is_breakpoint (b
)
5849 && breakpoint_condition_evaluation_mode () == condition_evaluation_target
5850 && bp_condition_evaluator (b
) == condition_evaluation_both
)
5853 uiout
->field_string ("evaluated-by",
5854 bp_location_condition_evaluator (loc
));
5860 bptype_string (enum bptype type
)
5862 struct ep_type_description
5865 const char *description
;
5867 static struct ep_type_description bptypes
[] =
5869 {bp_none
, "?deleted?"},
5870 {bp_breakpoint
, "breakpoint"},
5871 {bp_hardware_breakpoint
, "hw breakpoint"},
5872 {bp_single_step
, "sw single-step"},
5873 {bp_until
, "until"},
5874 {bp_finish
, "finish"},
5875 {bp_watchpoint
, "watchpoint"},
5876 {bp_hardware_watchpoint
, "hw watchpoint"},
5877 {bp_read_watchpoint
, "read watchpoint"},
5878 {bp_access_watchpoint
, "acc watchpoint"},
5879 {bp_longjmp
, "longjmp"},
5880 {bp_longjmp_resume
, "longjmp resume"},
5881 {bp_longjmp_call_dummy
, "longjmp for call dummy"},
5882 {bp_exception
, "exception"},
5883 {bp_exception_resume
, "exception resume"},
5884 {bp_step_resume
, "step resume"},
5885 {bp_hp_step_resume
, "high-priority step resume"},
5886 {bp_watchpoint_scope
, "watchpoint scope"},
5887 {bp_call_dummy
, "call dummy"},
5888 {bp_std_terminate
, "std::terminate"},
5889 {bp_shlib_event
, "shlib events"},
5890 {bp_thread_event
, "thread events"},
5891 {bp_overlay_event
, "overlay events"},
5892 {bp_longjmp_master
, "longjmp master"},
5893 {bp_std_terminate_master
, "std::terminate master"},
5894 {bp_exception_master
, "exception master"},
5895 {bp_catchpoint
, "catchpoint"},
5896 {bp_tracepoint
, "tracepoint"},
5897 {bp_fast_tracepoint
, "fast tracepoint"},
5898 {bp_static_tracepoint
, "static tracepoint"},
5899 {bp_dprintf
, "dprintf"},
5900 {bp_jit_event
, "jit events"},
5901 {bp_gnu_ifunc_resolver
, "STT_GNU_IFUNC resolver"},
5902 {bp_gnu_ifunc_resolver_return
, "STT_GNU_IFUNC resolver return"},
5905 if (((int) type
>= (sizeof (bptypes
) / sizeof (bptypes
[0])))
5906 || ((int) type
!= bptypes
[(int) type
].type
))
5907 internal_error (__FILE__
, __LINE__
,
5908 _("bptypes table does not describe type #%d."),
5911 return bptypes
[(int) type
].description
;
5914 /* For MI, output a field named 'thread-groups' with a list as the value.
5915 For CLI, prefix the list with the string 'inf'. */
5918 output_thread_groups (struct ui_out
*uiout
,
5919 const char *field_name
,
5920 const std::vector
<int> &inf_nums
,
5923 int is_mi
= uiout
->is_mi_like_p ();
5925 /* For backward compatibility, don't display inferiors in CLI unless
5926 there are several. Always display them for MI. */
5927 if (!is_mi
&& mi_only
)
5930 ui_out_emit_list
list_emitter (uiout
, field_name
);
5932 for (size_t i
= 0; i
< inf_nums
.size (); i
++)
5938 xsnprintf (mi_group
, sizeof (mi_group
), "i%d", inf_nums
[i
]);
5939 uiout
->field_string (NULL
, mi_group
);
5944 uiout
->text (" inf ");
5948 uiout
->text (plongest (inf_nums
[i
]));
5953 /* Print B to gdb_stdout. If RAW_LOC, print raw breakpoint locations
5954 instead of going via breakpoint_ops::print_one. This makes "maint
5955 info breakpoints" show the software breakpoint locations of
5956 catchpoints, which are considered internal implementation
5960 print_one_breakpoint_location (struct breakpoint
*b
,
5961 struct bp_location
*loc
,
5963 struct bp_location
**last_loc
,
5964 int allflag
, bool raw_loc
)
5966 struct command_line
*l
;
5967 static char bpenables
[] = "nynny";
5969 struct ui_out
*uiout
= current_uiout
;
5970 int header_of_multiple
= 0;
5971 int part_of_multiple
= (loc
!= NULL
);
5972 struct value_print_options opts
;
5974 get_user_print_options (&opts
);
5976 gdb_assert (!loc
|| loc_number
!= 0);
5977 /* See comment in print_one_breakpoint concerning treatment of
5978 breakpoints with single disabled location. */
5981 && (b
->loc
->next
!= NULL
|| !b
->loc
->enabled
)))
5982 header_of_multiple
= 1;
5990 if (part_of_multiple
)
5991 uiout
->field_fmt ("number", "%d.%d", b
->number
, loc_number
);
5993 uiout
->field_signed ("number", b
->number
);
5997 if (part_of_multiple
)
5998 uiout
->field_skip ("type");
6000 uiout
->field_string ("type", bptype_string (b
->type
));
6004 if (part_of_multiple
)
6005 uiout
->field_skip ("disp");
6007 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
6011 if (part_of_multiple
)
6012 uiout
->field_string ("enabled", loc
->enabled
? "y" : "n");
6014 uiout
->field_fmt ("enabled", "%c", bpenables
[(int) b
->enable_state
]);
6017 if (!raw_loc
&& b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
6018 b
->ops
->print_one (b
, last_loc
);
6021 if (is_watchpoint (b
))
6023 struct watchpoint
*w
= (struct watchpoint
*) b
;
6025 /* Field 4, the address, is omitted (which makes the columns
6026 not line up too nicely with the headers, but the effect
6027 is relatively readable). */
6028 if (opts
.addressprint
)
6029 uiout
->field_skip ("addr");
6031 uiout
->field_string ("what", w
->exp_string
);
6033 else if (!is_catchpoint (b
) || is_exception_catchpoint (b
)
6034 || is_ada_exception_catchpoint (b
))
6036 if (opts
.addressprint
)
6039 if (header_of_multiple
)
6040 uiout
->field_string ("addr", "<MULTIPLE>",
6041 metadata_style
.style ());
6042 else if (b
->loc
== NULL
|| loc
->shlib_disabled
)
6043 uiout
->field_string ("addr", "<PENDING>",
6044 metadata_style
.style ());
6046 uiout
->field_core_addr ("addr",
6047 loc
->gdbarch
, loc
->address
);
6050 if (!header_of_multiple
)
6051 print_breakpoint_location (b
, loc
);
6057 if (loc
!= NULL
&& !header_of_multiple
)
6059 std::vector
<int> inf_nums
;
6062 for (inferior
*inf
: all_inferiors ())
6064 if (inf
->pspace
== loc
->pspace
)
6065 inf_nums
.push_back (inf
->num
);
6068 /* For backward compatibility, don't display inferiors in CLI unless
6069 there are several. Always display for MI. */
6071 || (!gdbarch_has_global_breakpoints (target_gdbarch ())
6072 && (program_spaces
.size () > 1
6073 || number_of_inferiors () > 1)
6074 /* LOC is for existing B, it cannot be in
6075 moribund_locations and thus having NULL OWNER. */
6076 && loc
->owner
->type
!= bp_catchpoint
))
6078 output_thread_groups (uiout
, "thread-groups", inf_nums
, mi_only
);
6081 if (!part_of_multiple
)
6083 if (b
->thread
!= -1)
6085 /* FIXME: This seems to be redundant and lost here; see the
6086 "stop only in" line a little further down. */
6087 uiout
->text (" thread ");
6088 uiout
->field_signed ("thread", b
->thread
);
6090 else if (b
->task
!= 0)
6092 uiout
->text (" task ");
6093 uiout
->field_signed ("task", b
->task
);
6099 if (!part_of_multiple
)
6100 b
->ops
->print_one_detail (b
, uiout
);
6102 if (part_of_multiple
&& frame_id_p (b
->frame_id
))
6105 uiout
->text ("\tstop only in stack frame at ");
6106 /* FIXME: cagney/2002-12-01: Shouldn't be poking around inside
6108 uiout
->field_core_addr ("frame",
6109 b
->gdbarch
, b
->frame_id
.stack_addr
);
6113 if (!part_of_multiple
&& b
->cond_string
)
6116 if (is_tracepoint (b
))
6117 uiout
->text ("\ttrace only if ");
6119 uiout
->text ("\tstop only if ");
6120 uiout
->field_string ("cond", b
->cond_string
);
6122 /* Print whether the target is doing the breakpoint's condition
6123 evaluation. If GDB is doing the evaluation, don't print anything. */
6124 if (is_breakpoint (b
)
6125 && breakpoint_condition_evaluation_mode ()
6126 == condition_evaluation_target
)
6128 uiout
->message (" (%pF evals)",
6129 string_field ("evaluated-by",
6130 bp_condition_evaluator (b
)));
6135 if (!part_of_multiple
&& b
->thread
!= -1)
6137 /* FIXME should make an annotation for this. */
6138 uiout
->text ("\tstop only in thread ");
6139 if (uiout
->is_mi_like_p ())
6140 uiout
->field_signed ("thread", b
->thread
);
6143 struct thread_info
*thr
= find_thread_global_id (b
->thread
);
6145 uiout
->field_string ("thread", print_thread_id (thr
));
6150 if (!part_of_multiple
)
6154 /* FIXME should make an annotation for this. */
6155 if (is_catchpoint (b
))
6156 uiout
->text ("\tcatchpoint");
6157 else if (is_tracepoint (b
))
6158 uiout
->text ("\ttracepoint");
6160 uiout
->text ("\tbreakpoint");
6161 uiout
->text (" already hit ");
6162 uiout
->field_signed ("times", b
->hit_count
);
6163 if (b
->hit_count
== 1)
6164 uiout
->text (" time\n");
6166 uiout
->text (" times\n");
6170 /* Output the count also if it is zero, but only if this is mi. */
6171 if (uiout
->is_mi_like_p ())
6172 uiout
->field_signed ("times", b
->hit_count
);
6176 if (!part_of_multiple
&& b
->ignore_count
)
6179 uiout
->message ("\tignore next %pF hits\n",
6180 signed_field ("ignore", b
->ignore_count
));
6183 /* Note that an enable count of 1 corresponds to "enable once"
6184 behavior, which is reported by the combination of enablement and
6185 disposition, so we don't need to mention it here. */
6186 if (!part_of_multiple
&& b
->enable_count
> 1)
6189 uiout
->text ("\tdisable after ");
6190 /* Tweak the wording to clarify that ignore and enable counts
6191 are distinct, and have additive effect. */
6192 if (b
->ignore_count
)
6193 uiout
->text ("additional ");
6195 uiout
->text ("next ");
6196 uiout
->field_signed ("enable", b
->enable_count
);
6197 uiout
->text (" hits\n");
6200 if (!part_of_multiple
&& is_tracepoint (b
))
6202 struct tracepoint
*tp
= (struct tracepoint
*) b
;
6204 if (tp
->traceframe_usage
)
6206 uiout
->text ("\ttrace buffer usage ");
6207 uiout
->field_signed ("traceframe-usage", tp
->traceframe_usage
);
6208 uiout
->text (" bytes\n");
6212 l
= b
->commands
? b
->commands
.get () : NULL
;
6213 if (!part_of_multiple
&& l
)
6216 ui_out_emit_tuple
tuple_emitter (uiout
, "script");
6217 print_command_lines (uiout
, l
, 4);
6220 if (is_tracepoint (b
))
6222 struct tracepoint
*t
= (struct tracepoint
*) b
;
6224 if (!part_of_multiple
&& t
->pass_count
)
6226 annotate_field (10);
6227 uiout
->text ("\tpass count ");
6228 uiout
->field_signed ("pass", t
->pass_count
);
6229 uiout
->text (" \n");
6232 /* Don't display it when tracepoint or tracepoint location is
6234 if (!header_of_multiple
&& loc
!= NULL
&& !loc
->shlib_disabled
)
6236 annotate_field (11);
6238 if (uiout
->is_mi_like_p ())
6239 uiout
->field_string ("installed",
6240 loc
->inserted
? "y" : "n");
6246 uiout
->text ("\tnot ");
6247 uiout
->text ("installed on target\n");
6252 if (uiout
->is_mi_like_p () && !part_of_multiple
)
6254 if (is_watchpoint (b
))
6256 struct watchpoint
*w
= (struct watchpoint
*) b
;
6258 uiout
->field_string ("original-location", w
->exp_string
);
6260 else if (b
->location
!= NULL
6261 && event_location_to_string (b
->location
.get ()) != NULL
)
6262 uiout
->field_string ("original-location",
6263 event_location_to_string (b
->location
.get ()));
6267 /* See breakpoint.h. */
6269 bool fix_multi_location_breakpoint_output_globally
= false;
6272 print_one_breakpoint (struct breakpoint
*b
,
6273 struct bp_location
**last_loc
,
6276 struct ui_out
*uiout
= current_uiout
;
6277 bool use_fixed_output
6278 = (uiout
->test_flags (fix_multi_location_breakpoint_output
)
6279 || fix_multi_location_breakpoint_output_globally
);
6281 gdb::optional
<ui_out_emit_tuple
> bkpt_tuple_emitter (gdb::in_place
, uiout
, "bkpt");
6282 print_one_breakpoint_location (b
, NULL
, 0, last_loc
, allflag
, false);
6284 /* The mi2 broken format: the main breakpoint tuple ends here, the locations
6286 if (!use_fixed_output
)
6287 bkpt_tuple_emitter
.reset ();
6289 /* If this breakpoint has custom print function,
6290 it's already printed. Otherwise, print individual
6291 locations, if any. */
6293 || b
->ops
->print_one
== NULL
6296 /* If breakpoint has a single location that is disabled, we
6297 print it as if it had several locations, since otherwise it's
6298 hard to represent "breakpoint enabled, location disabled"
6301 Note that while hardware watchpoints have several locations
6302 internally, that's not a property exposed to users.
6304 Likewise, while catchpoints may be implemented with
6305 breakpoints (e.g., catch throw), that's not a property
6306 exposed to users. We do however display the internal
6307 breakpoint locations with "maint info breakpoints". */
6308 if (!is_hardware_watchpoint (b
)
6309 && (!is_catchpoint (b
) || is_exception_catchpoint (b
)
6310 || is_ada_exception_catchpoint (b
))
6312 || (b
->loc
&& (b
->loc
->next
|| !b
->loc
->enabled
))))
6314 gdb::optional
<ui_out_emit_list
> locations_list
;
6316 /* For MI version <= 2, keep the behavior where GDB outputs an invalid
6317 MI record. For later versions, place breakpoint locations in a
6319 if (uiout
->is_mi_like_p () && use_fixed_output
)
6320 locations_list
.emplace (uiout
, "locations");
6323 for (bp_location
*loc
= b
->loc
; loc
!= NULL
; loc
= loc
->next
, ++n
)
6325 ui_out_emit_tuple
loc_tuple_emitter (uiout
, NULL
);
6326 print_one_breakpoint_location (b
, loc
, n
, last_loc
,
6334 breakpoint_address_bits (struct breakpoint
*b
)
6336 int print_address_bits
= 0;
6337 struct bp_location
*loc
;
6339 /* Software watchpoints that aren't watching memory don't have an
6340 address to print. */
6341 if (is_no_memory_software_watchpoint (b
))
6344 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
6348 addr_bit
= gdbarch_addr_bit (loc
->gdbarch
);
6349 if (addr_bit
> print_address_bits
)
6350 print_address_bits
= addr_bit
;
6353 return print_address_bits
;
6356 /* See breakpoint.h. */
6359 print_breakpoint (breakpoint
*b
)
6361 struct bp_location
*dummy_loc
= NULL
;
6362 print_one_breakpoint (b
, &dummy_loc
, 0);
6365 /* Return true if this breakpoint was set by the user, false if it is
6366 internal or momentary. */
6369 user_breakpoint_p (struct breakpoint
*b
)
6371 return b
->number
> 0;
6374 /* See breakpoint.h. */
6377 pending_breakpoint_p (struct breakpoint
*b
)
6379 return b
->loc
== NULL
;
6382 /* Print information on breakpoints (including watchpoints and tracepoints).
6384 If non-NULL, BP_NUM_LIST is a list of numbers and number ranges as
6385 understood by number_or_range_parser. Only breakpoints included in this
6386 list are then printed.
6388 If SHOW_INTERNAL is true, print internal breakpoints.
6390 If FILTER is non-NULL, call it on each breakpoint and only include the
6391 ones for which it returns true.
6393 Return the total number of breakpoints listed. */
6396 breakpoint_1 (const char *bp_num_list
, bool show_internal
,
6397 bool (*filter
) (const struct breakpoint
*))
6399 struct breakpoint
*b
;
6400 struct bp_location
*last_loc
= NULL
;
6401 int nr_printable_breakpoints
;
6402 struct value_print_options opts
;
6403 int print_address_bits
= 0;
6404 int print_type_col_width
= 14;
6405 struct ui_out
*uiout
= current_uiout
;
6407 get_user_print_options (&opts
);
6409 /* Compute the number of rows in the table, as well as the size
6410 required for address fields. */
6411 nr_printable_breakpoints
= 0;
6414 /* If we have a filter, only list the breakpoints it accepts. */
6415 if (filter
&& !filter (b
))
6418 /* If we have a BP_NUM_LIST string, it is a list of breakpoints to
6419 accept. Skip the others. */
6420 if (bp_num_list
!= NULL
&& *bp_num_list
!= '\0')
6422 if (show_internal
&& parse_and_eval_long (bp_num_list
) != b
->number
)
6424 if (!show_internal
&& !number_is_in_list (bp_num_list
, b
->number
))
6428 if (show_internal
|| user_breakpoint_p (b
))
6430 int addr_bit
, type_len
;
6432 addr_bit
= breakpoint_address_bits (b
);
6433 if (addr_bit
> print_address_bits
)
6434 print_address_bits
= addr_bit
;
6436 type_len
= strlen (bptype_string (b
->type
));
6437 if (type_len
> print_type_col_width
)
6438 print_type_col_width
= type_len
;
6440 nr_printable_breakpoints
++;
6445 ui_out_emit_table
table_emitter (uiout
,
6446 opts
.addressprint
? 6 : 5,
6447 nr_printable_breakpoints
,
6450 if (nr_printable_breakpoints
> 0)
6451 annotate_breakpoints_headers ();
6452 if (nr_printable_breakpoints
> 0)
6454 uiout
->table_header (7, ui_left
, "number", "Num"); /* 1 */
6455 if (nr_printable_breakpoints
> 0)
6457 uiout
->table_header (print_type_col_width
, ui_left
, "type", "Type"); /* 2 */
6458 if (nr_printable_breakpoints
> 0)
6460 uiout
->table_header (4, ui_left
, "disp", "Disp"); /* 3 */
6461 if (nr_printable_breakpoints
> 0)
6463 uiout
->table_header (3, ui_left
, "enabled", "Enb"); /* 4 */
6464 if (opts
.addressprint
)
6466 if (nr_printable_breakpoints
> 0)
6468 if (print_address_bits
<= 32)
6469 uiout
->table_header (10, ui_left
, "addr", "Address"); /* 5 */
6471 uiout
->table_header (18, ui_left
, "addr", "Address"); /* 5 */
6473 if (nr_printable_breakpoints
> 0)
6475 uiout
->table_header (40, ui_noalign
, "what", "What"); /* 6 */
6476 uiout
->table_body ();
6477 if (nr_printable_breakpoints
> 0)
6478 annotate_breakpoints_table ();
6483 /* If we have a filter, only list the breakpoints it accepts. */
6484 if (filter
&& !filter (b
))
6487 /* If we have a BP_NUM_LIST string, it is a list of breakpoints to
6488 accept. Skip the others. */
6490 if (bp_num_list
!= NULL
&& *bp_num_list
!= '\0')
6492 if (show_internal
) /* maintenance info breakpoint */
6494 if (parse_and_eval_long (bp_num_list
) != b
->number
)
6497 else /* all others */
6499 if (!number_is_in_list (bp_num_list
, b
->number
))
6503 /* We only print out user settable breakpoints unless the
6504 show_internal is set. */
6505 if (show_internal
|| user_breakpoint_p (b
))
6506 print_one_breakpoint (b
, &last_loc
, show_internal
);
6510 if (nr_printable_breakpoints
== 0)
6512 /* If there's a filter, let the caller decide how to report
6516 if (bp_num_list
== NULL
|| *bp_num_list
== '\0')
6517 uiout
->message ("No breakpoints or watchpoints.\n");
6519 uiout
->message ("No breakpoint or watchpoint matching '%s'.\n",
6525 if (last_loc
&& !server_command
)
6526 set_next_address (last_loc
->gdbarch
, last_loc
->address
);
6529 /* FIXME? Should this be moved up so that it is only called when
6530 there have been breakpoints? */
6531 annotate_breakpoints_table_end ();
6533 return nr_printable_breakpoints
;
6536 /* Display the value of default-collect in a way that is generally
6537 compatible with the breakpoint list. */
6540 default_collect_info (void)
6542 struct ui_out
*uiout
= current_uiout
;
6544 /* If it has no value (which is frequently the case), say nothing; a
6545 message like "No default-collect." gets in user's face when it's
6547 if (!*default_collect
)
6550 /* The following phrase lines up nicely with per-tracepoint collect
6552 uiout
->text ("default collect ");
6553 uiout
->field_string ("default-collect", default_collect
);
6554 uiout
->text (" \n");
6558 info_breakpoints_command (const char *args
, int from_tty
)
6560 breakpoint_1 (args
, false, NULL
);
6562 default_collect_info ();
6566 info_watchpoints_command (const char *args
, int from_tty
)
6568 int num_printed
= breakpoint_1 (args
, false, is_watchpoint
);
6569 struct ui_out
*uiout
= current_uiout
;
6571 if (num_printed
== 0)
6573 if (args
== NULL
|| *args
== '\0')
6574 uiout
->message ("No watchpoints.\n");
6576 uiout
->message ("No watchpoint matching '%s'.\n", args
);
6581 maintenance_info_breakpoints (const char *args
, int from_tty
)
6583 breakpoint_1 (args
, true, NULL
);
6585 default_collect_info ();
6589 breakpoint_has_pc (struct breakpoint
*b
,
6590 struct program_space
*pspace
,
6591 CORE_ADDR pc
, struct obj_section
*section
)
6593 struct bp_location
*bl
= b
->loc
;
6595 for (; bl
; bl
= bl
->next
)
6597 if (bl
->pspace
== pspace
6598 && bl
->address
== pc
6599 && (!overlay_debugging
|| bl
->section
== section
))
6605 /* Print a message describing any user-breakpoints set at PC. This
6606 concerns with logical breakpoints, so we match program spaces, not
6610 describe_other_breakpoints (struct gdbarch
*gdbarch
,
6611 struct program_space
*pspace
, CORE_ADDR pc
,
6612 struct obj_section
*section
, int thread
)
6615 struct breakpoint
*b
;
6618 others
+= (user_breakpoint_p (b
)
6619 && breakpoint_has_pc (b
, pspace
, pc
, section
));
6623 printf_filtered (_("Note: breakpoint "));
6624 else /* if (others == ???) */
6625 printf_filtered (_("Note: breakpoints "));
6627 if (user_breakpoint_p (b
) && breakpoint_has_pc (b
, pspace
, pc
, section
))
6630 printf_filtered ("%d", b
->number
);
6631 if (b
->thread
== -1 && thread
!= -1)
6632 printf_filtered (" (all threads)");
6633 else if (b
->thread
!= -1)
6634 printf_filtered (" (thread %d)", b
->thread
);
6635 printf_filtered ("%s%s ",
6636 ((b
->enable_state
== bp_disabled
6637 || b
->enable_state
== bp_call_disabled
)
6641 : ((others
== 1) ? " and" : ""));
6643 current_uiout
->message (_("also set at pc %ps.\n"),
6644 styled_string (address_style
.style (),
6645 paddress (gdbarch
, pc
)));
6650 /* Return true iff it is meaningful to use the address member of LOC.
6651 For some breakpoint types, the locations' address members are
6652 irrelevant and it makes no sense to attempt to compare them to
6653 other addresses (or use them for any other purpose either).
6655 More specifically, software watchpoints and catchpoints that are
6656 not backed by breakpoints always have a zero valued location
6657 address and we don't want to mark breakpoints of any of these types
6658 to be a duplicate of an actual breakpoint location at address
6662 bl_address_is_meaningful (bp_location
*loc
)
6664 return loc
->loc_type
!= bp_loc_other
;
6667 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
6668 true if LOC1 and LOC2 represent the same watchpoint location. */
6671 watchpoint_locations_match (struct bp_location
*loc1
,
6672 struct bp_location
*loc2
)
6674 struct watchpoint
*w1
= (struct watchpoint
*) loc1
->owner
;
6675 struct watchpoint
*w2
= (struct watchpoint
*) loc2
->owner
;
6677 /* Both of them must exist. */
6678 gdb_assert (w1
!= NULL
);
6679 gdb_assert (w2
!= NULL
);
6681 /* If the target can evaluate the condition expression in hardware,
6682 then we we need to insert both watchpoints even if they are at
6683 the same place. Otherwise the watchpoint will only trigger when
6684 the condition of whichever watchpoint was inserted evaluates to
6685 true, not giving a chance for GDB to check the condition of the
6686 other watchpoint. */
6688 && target_can_accel_watchpoint_condition (loc1
->address
,
6690 loc1
->watchpoint_type
,
6691 w1
->cond_exp
.get ()))
6693 && target_can_accel_watchpoint_condition (loc2
->address
,
6695 loc2
->watchpoint_type
,
6696 w2
->cond_exp
.get ())))
6699 /* Note that this checks the owner's type, not the location's. In
6700 case the target does not support read watchpoints, but does
6701 support access watchpoints, we'll have bp_read_watchpoint
6702 watchpoints with hw_access locations. Those should be considered
6703 duplicates of hw_read locations. The hw_read locations will
6704 become hw_access locations later. */
6705 return (loc1
->owner
->type
== loc2
->owner
->type
6706 && loc1
->pspace
->aspace
== loc2
->pspace
->aspace
6707 && loc1
->address
== loc2
->address
6708 && loc1
->length
== loc2
->length
);
6711 /* See breakpoint.h. */
6714 breakpoint_address_match (const address_space
*aspace1
, CORE_ADDR addr1
,
6715 const address_space
*aspace2
, CORE_ADDR addr2
)
6717 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
6718 || aspace1
== aspace2
)
6722 /* Returns true if {ASPACE2,ADDR2} falls within the range determined by
6723 {ASPACE1,ADDR1,LEN1}. In most targets, this can only be true if ASPACE1
6724 matches ASPACE2. On targets that have global breakpoints, the address
6725 space doesn't really matter. */
6728 breakpoint_address_match_range (const address_space
*aspace1
,
6730 int len1
, const address_space
*aspace2
,
6733 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
6734 || aspace1
== aspace2
)
6735 && addr2
>= addr1
&& addr2
< addr1
+ len1
);
6738 /* Returns true if {ASPACE,ADDR} matches the breakpoint BL. BL may be
6739 a ranged breakpoint. In most targets, a match happens only if ASPACE
6740 matches the breakpoint's address space. On targets that have global
6741 breakpoints, the address space doesn't really matter. */
6744 breakpoint_location_address_match (struct bp_location
*bl
,
6745 const address_space
*aspace
,
6748 return (breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
6751 && breakpoint_address_match_range (bl
->pspace
->aspace
,
6752 bl
->address
, bl
->length
,
6756 /* Returns true if the [ADDR,ADDR+LEN) range in ASPACE overlaps
6757 breakpoint BL. BL may be a ranged breakpoint. In most targets, a
6758 match happens only if ASPACE matches the breakpoint's address
6759 space. On targets that have global breakpoints, the address space
6760 doesn't really matter. */
6763 breakpoint_location_address_range_overlap (struct bp_location
*bl
,
6764 const address_space
*aspace
,
6765 CORE_ADDR addr
, int len
)
6767 if (gdbarch_has_global_breakpoints (target_gdbarch ())
6768 || bl
->pspace
->aspace
== aspace
)
6770 int bl_len
= bl
->length
!= 0 ? bl
->length
: 1;
6772 if (mem_ranges_overlap (addr
, len
, bl
->address
, bl_len
))
6778 /* If LOC1 and LOC2's owners are not tracepoints, returns false directly.
6779 Then, if LOC1 and LOC2 represent the same tracepoint location, returns
6780 true, otherwise returns false. */
6783 tracepoint_locations_match (struct bp_location
*loc1
,
6784 struct bp_location
*loc2
)
6786 if (is_tracepoint (loc1
->owner
) && is_tracepoint (loc2
->owner
))
6787 /* Since tracepoint locations are never duplicated with others', tracepoint
6788 locations at the same address of different tracepoints are regarded as
6789 different locations. */
6790 return (loc1
->address
== loc2
->address
&& loc1
->owner
== loc2
->owner
);
6795 /* Assuming LOC1 and LOC2's types' have meaningful target addresses
6796 (bl_address_is_meaningful), returns true if LOC1 and LOC2 represent
6797 the same location. If SW_HW_BPS_MATCH is true, then software
6798 breakpoint locations and hardware breakpoint locations match,
6799 otherwise they don't. */
6802 breakpoint_locations_match (struct bp_location
*loc1
,
6803 struct bp_location
*loc2
,
6804 bool sw_hw_bps_match
)
6806 int hw_point1
, hw_point2
;
6808 /* Both of them must not be in moribund_locations. */
6809 gdb_assert (loc1
->owner
!= NULL
);
6810 gdb_assert (loc2
->owner
!= NULL
);
6812 hw_point1
= is_hardware_watchpoint (loc1
->owner
);
6813 hw_point2
= is_hardware_watchpoint (loc2
->owner
);
6815 if (hw_point1
!= hw_point2
)
6818 return watchpoint_locations_match (loc1
, loc2
);
6819 else if (is_tracepoint (loc1
->owner
) || is_tracepoint (loc2
->owner
))
6820 return tracepoint_locations_match (loc1
, loc2
);
6822 /* We compare bp_location.length in order to cover ranged
6823 breakpoints. Keep this in sync with
6824 bp_location_is_less_than. */
6825 return (breakpoint_address_match (loc1
->pspace
->aspace
, loc1
->address
,
6826 loc2
->pspace
->aspace
, loc2
->address
)
6827 && (loc1
->loc_type
== loc2
->loc_type
|| sw_hw_bps_match
)
6828 && loc1
->length
== loc2
->length
);
6832 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
6833 int bnum
, int have_bnum
)
6835 /* The longest string possibly returned by hex_string_custom
6836 is 50 chars. These must be at least that big for safety. */
6840 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
6841 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
6843 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
6844 bnum
, astr1
, astr2
);
6846 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
6849 /* Adjust a breakpoint's address to account for architectural
6850 constraints on breakpoint placement. Return the adjusted address.
6851 Note: Very few targets require this kind of adjustment. For most
6852 targets, this function is simply the identity function. */
6855 adjust_breakpoint_address (struct gdbarch
*gdbarch
,
6856 CORE_ADDR bpaddr
, enum bptype bptype
)
6858 if (bptype
== bp_watchpoint
6859 || bptype
== bp_hardware_watchpoint
6860 || bptype
== bp_read_watchpoint
6861 || bptype
== bp_access_watchpoint
6862 || bptype
== bp_catchpoint
)
6864 /* Watchpoints and the various bp_catch_* eventpoints should not
6865 have their addresses modified. */
6868 else if (bptype
== bp_single_step
)
6870 /* Single-step breakpoints should not have their addresses
6871 modified. If there's any architectural constrain that
6872 applies to this address, then it should have already been
6873 taken into account when the breakpoint was created in the
6874 first place. If we didn't do this, stepping through e.g.,
6875 Thumb-2 IT blocks would break. */
6880 CORE_ADDR adjusted_bpaddr
= bpaddr
;
6882 if (gdbarch_adjust_breakpoint_address_p (gdbarch
))
6884 /* Some targets have architectural constraints on the placement
6885 of breakpoint instructions. Obtain the adjusted address. */
6886 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (gdbarch
, bpaddr
);
6889 adjusted_bpaddr
= address_significant (gdbarch
, adjusted_bpaddr
);
6891 /* An adjusted breakpoint address can significantly alter
6892 a user's expectations. Print a warning if an adjustment
6894 if (adjusted_bpaddr
!= bpaddr
)
6895 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
6897 return adjusted_bpaddr
;
6902 bp_location_from_bp_type (bptype type
)
6907 case bp_single_step
:
6911 case bp_longjmp_resume
:
6912 case bp_longjmp_call_dummy
:
6914 case bp_exception_resume
:
6915 case bp_step_resume
:
6916 case bp_hp_step_resume
:
6917 case bp_watchpoint_scope
:
6919 case bp_std_terminate
:
6920 case bp_shlib_event
:
6921 case bp_thread_event
:
6922 case bp_overlay_event
:
6924 case bp_longjmp_master
:
6925 case bp_std_terminate_master
:
6926 case bp_exception_master
:
6927 case bp_gnu_ifunc_resolver
:
6928 case bp_gnu_ifunc_resolver_return
:
6930 return bp_loc_software_breakpoint
;
6931 case bp_hardware_breakpoint
:
6932 return bp_loc_hardware_breakpoint
;
6933 case bp_hardware_watchpoint
:
6934 case bp_read_watchpoint
:
6935 case bp_access_watchpoint
:
6936 return bp_loc_hardware_watchpoint
;
6940 case bp_fast_tracepoint
:
6941 case bp_static_tracepoint
:
6942 return bp_loc_other
;
6944 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
6948 bp_location::bp_location (breakpoint
*owner
, bp_loc_type type
)
6950 this->owner
= owner
;
6951 this->cond_bytecode
= NULL
;
6952 this->shlib_disabled
= 0;
6955 this->loc_type
= type
;
6957 if (this->loc_type
== bp_loc_software_breakpoint
6958 || this->loc_type
== bp_loc_hardware_breakpoint
)
6959 mark_breakpoint_location_modified (this);
6964 bp_location::bp_location (breakpoint
*owner
)
6965 : bp_location::bp_location (owner
,
6966 bp_location_from_bp_type (owner
->type
))
6970 /* Allocate a struct bp_location. */
6972 static struct bp_location
*
6973 allocate_bp_location (struct breakpoint
*bpt
)
6975 return bpt
->ops
->allocate_location (bpt
);
6979 free_bp_location (struct bp_location
*loc
)
6984 /* Increment reference count. */
6987 incref_bp_location (struct bp_location
*bl
)
6992 /* Decrement reference count. If the reference count reaches 0,
6993 destroy the bp_location. Sets *BLP to NULL. */
6996 decref_bp_location (struct bp_location
**blp
)
6998 gdb_assert ((*blp
)->refc
> 0);
7000 if (--(*blp
)->refc
== 0)
7001 free_bp_location (*blp
);
7005 /* Add breakpoint B at the end of the global breakpoint chain. */
7008 add_to_breakpoint_chain (std::unique_ptr
<breakpoint
> &&b
)
7010 struct breakpoint
*b1
;
7011 struct breakpoint
*result
= b
.get ();
7013 /* Add this breakpoint to the end of the chain so that a list of
7014 breakpoints will come out in order of increasing numbers. */
7016 b1
= breakpoint_chain
;
7018 breakpoint_chain
= b
.release ();
7023 b1
->next
= b
.release ();
7029 /* Initializes breakpoint B with type BPTYPE and no locations yet. */
7032 init_raw_breakpoint_without_location (struct breakpoint
*b
,
7033 struct gdbarch
*gdbarch
,
7035 const struct breakpoint_ops
*ops
)
7037 gdb_assert (ops
!= NULL
);
7041 b
->gdbarch
= gdbarch
;
7042 b
->language
= current_language
->la_language
;
7043 b
->input_radix
= input_radix
;
7044 b
->related_breakpoint
= b
;
7047 /* Helper to set_raw_breakpoint below. Creates a breakpoint
7048 that has type BPTYPE and has no locations as yet. */
7050 static struct breakpoint
*
7051 set_raw_breakpoint_without_location (struct gdbarch
*gdbarch
,
7053 const struct breakpoint_ops
*ops
)
7055 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (bptype
);
7057 init_raw_breakpoint_without_location (b
.get (), gdbarch
, bptype
, ops
);
7058 return add_to_breakpoint_chain (std::move (b
));
7061 /* Initialize loc->function_name. */
7064 set_breakpoint_location_function (struct bp_location
*loc
)
7066 gdb_assert (loc
->owner
!= NULL
);
7068 if (loc
->owner
->type
== bp_breakpoint
7069 || loc
->owner
->type
== bp_hardware_breakpoint
7070 || is_tracepoint (loc
->owner
))
7072 const char *function_name
;
7074 if (loc
->msymbol
!= NULL
7075 && (MSYMBOL_TYPE (loc
->msymbol
) == mst_text_gnu_ifunc
7076 || MSYMBOL_TYPE (loc
->msymbol
) == mst_data_gnu_ifunc
))
7078 struct breakpoint
*b
= loc
->owner
;
7080 function_name
= loc
->msymbol
->linkage_name ();
7082 if (b
->type
== bp_breakpoint
&& b
->loc
== loc
7083 && loc
->next
== NULL
&& b
->related_breakpoint
== b
)
7085 /* Create only the whole new breakpoint of this type but do not
7086 mess more complicated breakpoints with multiple locations. */
7087 b
->type
= bp_gnu_ifunc_resolver
;
7088 /* Remember the resolver's address for use by the return
7090 loc
->related_address
= loc
->address
;
7094 find_pc_partial_function (loc
->address
, &function_name
, NULL
, NULL
);
7097 loc
->function_name
= xstrdup (function_name
);
7101 /* Attempt to determine architecture of location identified by SAL. */
7103 get_sal_arch (struct symtab_and_line sal
)
7106 return sal
.section
->objfile
->arch ();
7108 return SYMTAB_OBJFILE (sal
.symtab
)->arch ();
7113 /* Low level routine for partially initializing a breakpoint of type
7114 BPTYPE. The newly created breakpoint's address, section, source
7115 file name, and line number are provided by SAL.
7117 It is expected that the caller will complete the initialization of
7118 the newly created breakpoint struct as well as output any status
7119 information regarding the creation of a new breakpoint. */
7122 init_raw_breakpoint (struct breakpoint
*b
, struct gdbarch
*gdbarch
,
7123 struct symtab_and_line sal
, enum bptype bptype
,
7124 const struct breakpoint_ops
*ops
)
7126 init_raw_breakpoint_without_location (b
, gdbarch
, bptype
, ops
);
7128 add_location_to_breakpoint (b
, &sal
);
7130 if (bptype
!= bp_catchpoint
)
7131 gdb_assert (sal
.pspace
!= NULL
);
7133 /* Store the program space that was used to set the breakpoint,
7134 except for ordinary breakpoints, which are independent of the
7136 if (bptype
!= bp_breakpoint
&& bptype
!= bp_hardware_breakpoint
)
7137 b
->pspace
= sal
.pspace
;
7140 /* set_raw_breakpoint is a low level routine for allocating and
7141 partially initializing a breakpoint of type BPTYPE. The newly
7142 created breakpoint's address, section, source file name, and line
7143 number are provided by SAL. The newly created and partially
7144 initialized breakpoint is added to the breakpoint chain and
7145 is also returned as the value of this function.
7147 It is expected that the caller will complete the initialization of
7148 the newly created breakpoint struct as well as output any status
7149 information regarding the creation of a new breakpoint. In
7150 particular, set_raw_breakpoint does NOT set the breakpoint
7151 number! Care should be taken to not allow an error to occur
7152 prior to completing the initialization of the breakpoint. If this
7153 should happen, a bogus breakpoint will be left on the chain. */
7156 set_raw_breakpoint (struct gdbarch
*gdbarch
,
7157 struct symtab_and_line sal
, enum bptype bptype
,
7158 const struct breakpoint_ops
*ops
)
7160 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (bptype
);
7162 init_raw_breakpoint (b
.get (), gdbarch
, sal
, bptype
, ops
);
7163 return add_to_breakpoint_chain (std::move (b
));
7166 /* Call this routine when stepping and nexting to enable a breakpoint
7167 if we do a longjmp() or 'throw' in TP. FRAME is the frame which
7168 initiated the operation. */
7171 set_longjmp_breakpoint (struct thread_info
*tp
, struct frame_id frame
)
7173 struct breakpoint
*b
, *b_tmp
;
7174 int thread
= tp
->global_num
;
7176 /* To avoid having to rescan all objfile symbols at every step,
7177 we maintain a list of continually-inserted but always disabled
7178 longjmp "master" breakpoints. Here, we simply create momentary
7179 clones of those and enable them for the requested thread. */
7180 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7181 if (b
->pspace
== current_program_space
7182 && (b
->type
== bp_longjmp_master
7183 || b
->type
== bp_exception_master
))
7185 enum bptype type
= b
->type
== bp_longjmp_master
? bp_longjmp
: bp_exception
;
7186 struct breakpoint
*clone
;
7188 /* longjmp_breakpoint_ops ensures INITIATING_FRAME is cleared again
7189 after their removal. */
7190 clone
= momentary_breakpoint_from_master (b
, type
,
7191 &momentary_breakpoint_ops
, 1);
7192 clone
->thread
= thread
;
7195 tp
->initiating_frame
= frame
;
7198 /* Delete all longjmp breakpoints from THREAD. */
7200 delete_longjmp_breakpoint (int thread
)
7202 struct breakpoint
*b
, *b_tmp
;
7204 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7205 if (b
->type
== bp_longjmp
|| b
->type
== bp_exception
)
7207 if (b
->thread
== thread
)
7208 delete_breakpoint (b
);
7213 delete_longjmp_breakpoint_at_next_stop (int thread
)
7215 struct breakpoint
*b
, *b_tmp
;
7217 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7218 if (b
->type
== bp_longjmp
|| b
->type
== bp_exception
)
7220 if (b
->thread
== thread
)
7221 b
->disposition
= disp_del_at_next_stop
;
7225 /* Place breakpoints of type bp_longjmp_call_dummy to catch longjmp for
7226 INFERIOR_PTID thread. Chain them all by RELATED_BREAKPOINT and return
7227 pointer to any of them. Return NULL if this system cannot place longjmp
7231 set_longjmp_breakpoint_for_call_dummy (void)
7233 struct breakpoint
*b
, *retval
= NULL
;
7236 if (b
->pspace
== current_program_space
&& b
->type
== bp_longjmp_master
)
7238 struct breakpoint
*new_b
;
7240 new_b
= momentary_breakpoint_from_master (b
, bp_longjmp_call_dummy
,
7241 &momentary_breakpoint_ops
,
7243 new_b
->thread
= inferior_thread ()->global_num
;
7245 /* Link NEW_B into the chain of RETVAL breakpoints. */
7247 gdb_assert (new_b
->related_breakpoint
== new_b
);
7250 new_b
->related_breakpoint
= retval
;
7251 while (retval
->related_breakpoint
!= new_b
->related_breakpoint
)
7252 retval
= retval
->related_breakpoint
;
7253 retval
->related_breakpoint
= new_b
;
7259 /* Verify all existing dummy frames and their associated breakpoints for
7260 TP. Remove those which can no longer be found in the current frame
7263 You should call this function only at places where it is safe to currently
7264 unwind the whole stack. Failed stack unwind would discard live dummy
7268 check_longjmp_breakpoint_for_call_dummy (struct thread_info
*tp
)
7270 struct breakpoint
*b
, *b_tmp
;
7272 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7273 if (b
->type
== bp_longjmp_call_dummy
&& b
->thread
== tp
->global_num
)
7275 struct breakpoint
*dummy_b
= b
->related_breakpoint
;
7277 while (dummy_b
!= b
&& dummy_b
->type
!= bp_call_dummy
)
7278 dummy_b
= dummy_b
->related_breakpoint
;
7279 if (dummy_b
->type
!= bp_call_dummy
7280 || frame_find_by_id (dummy_b
->frame_id
) != NULL
)
7283 dummy_frame_discard (dummy_b
->frame_id
, tp
);
7285 while (b
->related_breakpoint
!= b
)
7287 if (b_tmp
== b
->related_breakpoint
)
7288 b_tmp
= b
->related_breakpoint
->next
;
7289 delete_breakpoint (b
->related_breakpoint
);
7291 delete_breakpoint (b
);
7296 enable_overlay_breakpoints (void)
7298 struct breakpoint
*b
;
7301 if (b
->type
== bp_overlay_event
)
7303 b
->enable_state
= bp_enabled
;
7304 update_global_location_list (UGLL_MAY_INSERT
);
7305 overlay_events_enabled
= 1;
7310 disable_overlay_breakpoints (void)
7312 struct breakpoint
*b
;
7315 if (b
->type
== bp_overlay_event
)
7317 b
->enable_state
= bp_disabled
;
7318 update_global_location_list (UGLL_DONT_INSERT
);
7319 overlay_events_enabled
= 0;
7323 /* Set an active std::terminate breakpoint for each std::terminate
7324 master breakpoint. */
7326 set_std_terminate_breakpoint (void)
7328 struct breakpoint
*b
, *b_tmp
;
7330 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7331 if (b
->pspace
== current_program_space
7332 && b
->type
== bp_std_terminate_master
)
7334 momentary_breakpoint_from_master (b
, bp_std_terminate
,
7335 &momentary_breakpoint_ops
, 1);
7339 /* Delete all the std::terminate breakpoints. */
7341 delete_std_terminate_breakpoint (void)
7343 struct breakpoint
*b
, *b_tmp
;
7345 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7346 if (b
->type
== bp_std_terminate
)
7347 delete_breakpoint (b
);
7351 create_thread_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7353 struct breakpoint
*b
;
7355 b
= create_internal_breakpoint (gdbarch
, address
, bp_thread_event
,
7356 &internal_breakpoint_ops
);
7358 b
->enable_state
= bp_enabled
;
7359 /* location has to be used or breakpoint_re_set will delete me. */
7360 b
->location
= new_address_location (b
->loc
->address
, NULL
, 0);
7362 update_global_location_list_nothrow (UGLL_MAY_INSERT
);
7367 struct lang_and_radix
7373 /* Create a breakpoint for JIT code registration and unregistration. */
7376 create_jit_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7378 return create_internal_breakpoint (gdbarch
, address
, bp_jit_event
,
7379 &internal_breakpoint_ops
);
7382 /* Remove JIT code registration and unregistration breakpoint(s). */
7385 remove_jit_event_breakpoints (void)
7387 struct breakpoint
*b
, *b_tmp
;
7389 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7390 if (b
->type
== bp_jit_event
7391 && b
->loc
->pspace
== current_program_space
)
7392 delete_breakpoint (b
);
7396 remove_solib_event_breakpoints (void)
7398 struct breakpoint
*b
, *b_tmp
;
7400 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7401 if (b
->type
== bp_shlib_event
7402 && b
->loc
->pspace
== current_program_space
)
7403 delete_breakpoint (b
);
7406 /* See breakpoint.h. */
7409 remove_solib_event_breakpoints_at_next_stop (void)
7411 struct breakpoint
*b
, *b_tmp
;
7413 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7414 if (b
->type
== bp_shlib_event
7415 && b
->loc
->pspace
== current_program_space
)
7416 b
->disposition
= disp_del_at_next_stop
;
7419 /* Helper for create_solib_event_breakpoint /
7420 create_and_insert_solib_event_breakpoint. Allows specifying which
7421 INSERT_MODE to pass through to update_global_location_list. */
7423 static struct breakpoint
*
7424 create_solib_event_breakpoint_1 (struct gdbarch
*gdbarch
, CORE_ADDR address
,
7425 enum ugll_insert_mode insert_mode
)
7427 struct breakpoint
*b
;
7429 b
= create_internal_breakpoint (gdbarch
, address
, bp_shlib_event
,
7430 &internal_breakpoint_ops
);
7431 update_global_location_list_nothrow (insert_mode
);
7436 create_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7438 return create_solib_event_breakpoint_1 (gdbarch
, address
, UGLL_MAY_INSERT
);
7441 /* See breakpoint.h. */
7444 create_and_insert_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7446 struct breakpoint
*b
;
7448 /* Explicitly tell update_global_location_list to insert
7450 b
= create_solib_event_breakpoint_1 (gdbarch
, address
, UGLL_INSERT
);
7451 if (!b
->loc
->inserted
)
7453 delete_breakpoint (b
);
7459 /* Disable any breakpoints that are on code in shared libraries. Only
7460 apply to enabled breakpoints, disabled ones can just stay disabled. */
7463 disable_breakpoints_in_shlibs (void)
7465 struct bp_location
*loc
, **locp_tmp
;
7467 ALL_BP_LOCATIONS (loc
, locp_tmp
)
7469 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7470 struct breakpoint
*b
= loc
->owner
;
7472 /* We apply the check to all breakpoints, including disabled for
7473 those with loc->duplicate set. This is so that when breakpoint
7474 becomes enabled, or the duplicate is removed, gdb will try to
7475 insert all breakpoints. If we don't set shlib_disabled here,
7476 we'll try to insert those breakpoints and fail. */
7477 if (((b
->type
== bp_breakpoint
)
7478 || (b
->type
== bp_jit_event
)
7479 || (b
->type
== bp_hardware_breakpoint
)
7480 || (is_tracepoint (b
)))
7481 && loc
->pspace
== current_program_space
7482 && !loc
->shlib_disabled
7483 && solib_name_from_address (loc
->pspace
, loc
->address
)
7486 loc
->shlib_disabled
= 1;
7491 /* Disable any breakpoints and tracepoints that are in SOLIB upon
7492 notification of unloaded_shlib. Only apply to enabled breakpoints,
7493 disabled ones can just stay disabled. */
7496 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
7498 struct bp_location
*loc
, **locp_tmp
;
7499 int disabled_shlib_breaks
= 0;
7501 ALL_BP_LOCATIONS (loc
, locp_tmp
)
7503 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7504 struct breakpoint
*b
= loc
->owner
;
7506 if (solib
->pspace
== loc
->pspace
7507 && !loc
->shlib_disabled
7508 && (((b
->type
== bp_breakpoint
7509 || b
->type
== bp_jit_event
7510 || b
->type
== bp_hardware_breakpoint
)
7511 && (loc
->loc_type
== bp_loc_hardware_breakpoint
7512 || loc
->loc_type
== bp_loc_software_breakpoint
))
7513 || is_tracepoint (b
))
7514 && solib_contains_address_p (solib
, loc
->address
))
7516 loc
->shlib_disabled
= 1;
7517 /* At this point, we cannot rely on remove_breakpoint
7518 succeeding so we must mark the breakpoint as not inserted
7519 to prevent future errors occurring in remove_breakpoints. */
7522 /* This may cause duplicate notifications for the same breakpoint. */
7523 gdb::observers::breakpoint_modified
.notify (b
);
7525 if (!disabled_shlib_breaks
)
7527 target_terminal::ours_for_output ();
7528 warning (_("Temporarily disabling breakpoints "
7529 "for unloaded shared library \"%s\""),
7532 disabled_shlib_breaks
= 1;
7537 /* Disable any breakpoints and tracepoints in OBJFILE upon
7538 notification of free_objfile. Only apply to enabled breakpoints,
7539 disabled ones can just stay disabled. */
7542 disable_breakpoints_in_freed_objfile (struct objfile
*objfile
)
7544 struct breakpoint
*b
;
7546 if (objfile
== NULL
)
7549 /* OBJF_SHARED|OBJF_USERLOADED objfiles are dynamic modules manually
7550 managed by the user with add-symbol-file/remove-symbol-file.
7551 Similarly to how breakpoints in shared libraries are handled in
7552 response to "nosharedlibrary", mark breakpoints in such modules
7553 shlib_disabled so they end up uninserted on the next global
7554 location list update. Shared libraries not loaded by the user
7555 aren't handled here -- they're already handled in
7556 disable_breakpoints_in_unloaded_shlib, called by solib.c's
7557 solib_unloaded observer. We skip objfiles that are not
7558 OBJF_SHARED as those aren't considered dynamic objects (e.g. the
7560 if ((objfile
->flags
& OBJF_SHARED
) == 0
7561 || (objfile
->flags
& OBJF_USERLOADED
) == 0)
7566 struct bp_location
*loc
;
7567 int bp_modified
= 0;
7569 if (!is_breakpoint (b
) && !is_tracepoint (b
))
7572 for (loc
= b
->loc
; loc
!= NULL
; loc
= loc
->next
)
7574 CORE_ADDR loc_addr
= loc
->address
;
7576 if (loc
->loc_type
!= bp_loc_hardware_breakpoint
7577 && loc
->loc_type
!= bp_loc_software_breakpoint
)
7580 if (loc
->shlib_disabled
!= 0)
7583 if (objfile
->pspace
!= loc
->pspace
)
7586 if (loc
->loc_type
!= bp_loc_hardware_breakpoint
7587 && loc
->loc_type
!= bp_loc_software_breakpoint
)
7590 if (is_addr_in_objfile (loc_addr
, objfile
))
7592 loc
->shlib_disabled
= 1;
7593 /* At this point, we don't know whether the object was
7594 unmapped from the inferior or not, so leave the
7595 inserted flag alone. We'll handle failure to
7596 uninsert quietly, in case the object was indeed
7599 mark_breakpoint_location_modified (loc
);
7606 gdb::observers::breakpoint_modified
.notify (b
);
7610 /* FORK & VFORK catchpoints. */
7612 /* An instance of this type is used to represent a fork or vfork
7613 catchpoint. A breakpoint is really of this type iff its ops pointer points
7614 to CATCH_FORK_BREAKPOINT_OPS. */
7616 struct fork_catchpoint
: public breakpoint
7618 /* Process id of a child process whose forking triggered this
7619 catchpoint. This field is only valid immediately after this
7620 catchpoint has triggered. */
7621 ptid_t forked_inferior_pid
;
7624 /* Implement the "insert" breakpoint_ops method for fork
7628 insert_catch_fork (struct bp_location
*bl
)
7630 return target_insert_fork_catchpoint (inferior_ptid
.pid ());
7633 /* Implement the "remove" breakpoint_ops method for fork
7637 remove_catch_fork (struct bp_location
*bl
, enum remove_bp_reason reason
)
7639 return target_remove_fork_catchpoint (inferior_ptid
.pid ());
7642 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
7646 breakpoint_hit_catch_fork (const struct bp_location
*bl
,
7647 const address_space
*aspace
, CORE_ADDR bp_addr
,
7648 const struct target_waitstatus
*ws
)
7650 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bl
->owner
;
7652 if (ws
->kind
!= TARGET_WAITKIND_FORKED
)
7655 c
->forked_inferior_pid
= ws
->value
.related_pid
;
7659 /* Implement the "print_it" breakpoint_ops method for fork
7662 static enum print_stop_action
7663 print_it_catch_fork (bpstat bs
)
7665 struct ui_out
*uiout
= current_uiout
;
7666 struct breakpoint
*b
= bs
->breakpoint_at
;
7667 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bs
->breakpoint_at
;
7669 annotate_catchpoint (b
->number
);
7670 maybe_print_thread_hit_breakpoint (uiout
);
7671 if (b
->disposition
== disp_del
)
7672 uiout
->text ("Temporary catchpoint ");
7674 uiout
->text ("Catchpoint ");
7675 if (uiout
->is_mi_like_p ())
7677 uiout
->field_string ("reason", async_reason_lookup (EXEC_ASYNC_FORK
));
7678 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
7680 uiout
->field_signed ("bkptno", b
->number
);
7681 uiout
->text (" (forked process ");
7682 uiout
->field_signed ("newpid", c
->forked_inferior_pid
.pid ());
7683 uiout
->text ("), ");
7684 return PRINT_SRC_AND_LOC
;
7687 /* Implement the "print_one" breakpoint_ops method for fork
7691 print_one_catch_fork (struct breakpoint
*b
, struct bp_location
**last_loc
)
7693 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
7694 struct value_print_options opts
;
7695 struct ui_out
*uiout
= current_uiout
;
7697 get_user_print_options (&opts
);
7699 /* Field 4, the address, is omitted (which makes the columns not
7700 line up too nicely with the headers, but the effect is relatively
7702 if (opts
.addressprint
)
7703 uiout
->field_skip ("addr");
7705 uiout
->text ("fork");
7706 if (c
->forked_inferior_pid
!= null_ptid
)
7708 uiout
->text (", process ");
7709 uiout
->field_signed ("what", c
->forked_inferior_pid
.pid ());
7713 if (uiout
->is_mi_like_p ())
7714 uiout
->field_string ("catch-type", "fork");
7717 /* Implement the "print_mention" breakpoint_ops method for fork
7721 print_mention_catch_fork (struct breakpoint
*b
)
7723 printf_filtered (_("Catchpoint %d (fork)"), b
->number
);
7726 /* Implement the "print_recreate" breakpoint_ops method for fork
7730 print_recreate_catch_fork (struct breakpoint
*b
, struct ui_file
*fp
)
7732 fprintf_unfiltered (fp
, "catch fork");
7733 print_recreate_thread (b
, fp
);
7736 /* The breakpoint_ops structure to be used in fork catchpoints. */
7738 static struct breakpoint_ops catch_fork_breakpoint_ops
;
7740 /* Implement the "insert" breakpoint_ops method for vfork
7744 insert_catch_vfork (struct bp_location
*bl
)
7746 return target_insert_vfork_catchpoint (inferior_ptid
.pid ());
7749 /* Implement the "remove" breakpoint_ops method for vfork
7753 remove_catch_vfork (struct bp_location
*bl
, enum remove_bp_reason reason
)
7755 return target_remove_vfork_catchpoint (inferior_ptid
.pid ());
7758 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
7762 breakpoint_hit_catch_vfork (const struct bp_location
*bl
,
7763 const address_space
*aspace
, CORE_ADDR bp_addr
,
7764 const struct target_waitstatus
*ws
)
7766 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bl
->owner
;
7768 if (ws
->kind
!= TARGET_WAITKIND_VFORKED
)
7771 c
->forked_inferior_pid
= ws
->value
.related_pid
;
7775 /* Implement the "print_it" breakpoint_ops method for vfork
7778 static enum print_stop_action
7779 print_it_catch_vfork (bpstat bs
)
7781 struct ui_out
*uiout
= current_uiout
;
7782 struct breakpoint
*b
= bs
->breakpoint_at
;
7783 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
7785 annotate_catchpoint (b
->number
);
7786 maybe_print_thread_hit_breakpoint (uiout
);
7787 if (b
->disposition
== disp_del
)
7788 uiout
->text ("Temporary catchpoint ");
7790 uiout
->text ("Catchpoint ");
7791 if (uiout
->is_mi_like_p ())
7793 uiout
->field_string ("reason", async_reason_lookup (EXEC_ASYNC_VFORK
));
7794 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
7796 uiout
->field_signed ("bkptno", b
->number
);
7797 uiout
->text (" (vforked process ");
7798 uiout
->field_signed ("newpid", c
->forked_inferior_pid
.pid ());
7799 uiout
->text ("), ");
7800 return PRINT_SRC_AND_LOC
;
7803 /* Implement the "print_one" breakpoint_ops method for vfork
7807 print_one_catch_vfork (struct breakpoint
*b
, struct bp_location
**last_loc
)
7809 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
7810 struct value_print_options opts
;
7811 struct ui_out
*uiout
= current_uiout
;
7813 get_user_print_options (&opts
);
7814 /* Field 4, the address, is omitted (which makes the columns not
7815 line up too nicely with the headers, but the effect is relatively
7817 if (opts
.addressprint
)
7818 uiout
->field_skip ("addr");
7820 uiout
->text ("vfork");
7821 if (c
->forked_inferior_pid
!= null_ptid
)
7823 uiout
->text (", process ");
7824 uiout
->field_signed ("what", c
->forked_inferior_pid
.pid ());
7828 if (uiout
->is_mi_like_p ())
7829 uiout
->field_string ("catch-type", "vfork");
7832 /* Implement the "print_mention" breakpoint_ops method for vfork
7836 print_mention_catch_vfork (struct breakpoint
*b
)
7838 printf_filtered (_("Catchpoint %d (vfork)"), b
->number
);
7841 /* Implement the "print_recreate" breakpoint_ops method for vfork
7845 print_recreate_catch_vfork (struct breakpoint
*b
, struct ui_file
*fp
)
7847 fprintf_unfiltered (fp
, "catch vfork");
7848 print_recreate_thread (b
, fp
);
7851 /* The breakpoint_ops structure to be used in vfork catchpoints. */
7853 static struct breakpoint_ops catch_vfork_breakpoint_ops
;
7855 /* An instance of this type is used to represent an solib catchpoint.
7856 A breakpoint is really of this type iff its ops pointer points to
7857 CATCH_SOLIB_BREAKPOINT_OPS. */
7859 struct solib_catchpoint
: public breakpoint
7861 ~solib_catchpoint () override
;
7863 /* True for "catch load", false for "catch unload". */
7864 unsigned char is_load
;
7866 /* Regular expression to match, if any. COMPILED is only valid when
7867 REGEX is non-NULL. */
7869 std::unique_ptr
<compiled_regex
> compiled
;
7872 solib_catchpoint::~solib_catchpoint ()
7874 xfree (this->regex
);
7878 insert_catch_solib (struct bp_location
*ignore
)
7884 remove_catch_solib (struct bp_location
*ignore
, enum remove_bp_reason reason
)
7890 breakpoint_hit_catch_solib (const struct bp_location
*bl
,
7891 const address_space
*aspace
,
7893 const struct target_waitstatus
*ws
)
7895 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) bl
->owner
;
7896 struct breakpoint
*other
;
7898 if (ws
->kind
== TARGET_WAITKIND_LOADED
)
7901 ALL_BREAKPOINTS (other
)
7903 struct bp_location
*other_bl
;
7905 if (other
== bl
->owner
)
7908 if (other
->type
!= bp_shlib_event
)
7911 if (self
->pspace
!= NULL
&& other
->pspace
!= self
->pspace
)
7914 for (other_bl
= other
->loc
; other_bl
!= NULL
; other_bl
= other_bl
->next
)
7916 if (other
->ops
->breakpoint_hit (other_bl
, aspace
, bp_addr
, ws
))
7925 check_status_catch_solib (struct bpstats
*bs
)
7927 struct solib_catchpoint
*self
7928 = (struct solib_catchpoint
*) bs
->breakpoint_at
;
7932 for (so_list
*iter
: current_program_space
->added_solibs
)
7935 || self
->compiled
->exec (iter
->so_name
, 0, NULL
, 0) == 0)
7941 for (const std::string
&iter
: current_program_space
->deleted_solibs
)
7944 || self
->compiled
->exec (iter
.c_str (), 0, NULL
, 0) == 0)
7950 bs
->print_it
= print_it_noop
;
7953 static enum print_stop_action
7954 print_it_catch_solib (bpstat bs
)
7956 struct breakpoint
*b
= bs
->breakpoint_at
;
7957 struct ui_out
*uiout
= current_uiout
;
7959 annotate_catchpoint (b
->number
);
7960 maybe_print_thread_hit_breakpoint (uiout
);
7961 if (b
->disposition
== disp_del
)
7962 uiout
->text ("Temporary catchpoint ");
7964 uiout
->text ("Catchpoint ");
7965 uiout
->field_signed ("bkptno", b
->number
);
7967 if (uiout
->is_mi_like_p ())
7968 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
7969 print_solib_event (1);
7970 return PRINT_SRC_AND_LOC
;
7974 print_one_catch_solib (struct breakpoint
*b
, struct bp_location
**locs
)
7976 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
7977 struct value_print_options opts
;
7978 struct ui_out
*uiout
= current_uiout
;
7980 get_user_print_options (&opts
);
7981 /* Field 4, the address, is omitted (which makes the columns not
7982 line up too nicely with the headers, but the effect is relatively
7984 if (opts
.addressprint
)
7987 uiout
->field_skip ("addr");
7995 msg
= string_printf (_("load of library matching %s"), self
->regex
);
7997 msg
= _("load of library");
8002 msg
= string_printf (_("unload of library matching %s"), self
->regex
);
8004 msg
= _("unload of library");
8006 uiout
->field_string ("what", msg
);
8008 if (uiout
->is_mi_like_p ())
8009 uiout
->field_string ("catch-type", self
->is_load
? "load" : "unload");
8013 print_mention_catch_solib (struct breakpoint
*b
)
8015 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8017 printf_filtered (_("Catchpoint %d (%s)"), b
->number
,
8018 self
->is_load
? "load" : "unload");
8022 print_recreate_catch_solib (struct breakpoint
*b
, struct ui_file
*fp
)
8024 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8026 fprintf_unfiltered (fp
, "%s %s",
8027 b
->disposition
== disp_del
? "tcatch" : "catch",
8028 self
->is_load
? "load" : "unload");
8030 fprintf_unfiltered (fp
, " %s", self
->regex
);
8031 fprintf_unfiltered (fp
, "\n");
8034 static struct breakpoint_ops catch_solib_breakpoint_ops
;
8036 /* Shared helper function (MI and CLI) for creating and installing
8037 a shared object event catchpoint. If IS_LOAD is non-zero then
8038 the events to be caught are load events, otherwise they are
8039 unload events. If IS_TEMP is non-zero the catchpoint is a
8040 temporary one. If ENABLED is non-zero the catchpoint is
8041 created in an enabled state. */
8044 add_solib_catchpoint (const char *arg
, int is_load
, int is_temp
, int enabled
)
8046 struct gdbarch
*gdbarch
= get_current_arch ();
8050 arg
= skip_spaces (arg
);
8052 std::unique_ptr
<solib_catchpoint
> c (new solib_catchpoint ());
8056 c
->compiled
.reset (new compiled_regex (arg
, REG_NOSUB
,
8057 _("Invalid regexp")));
8058 c
->regex
= xstrdup (arg
);
8061 c
->is_load
= is_load
;
8062 init_catchpoint (c
.get (), gdbarch
, is_temp
, NULL
,
8063 &catch_solib_breakpoint_ops
);
8065 c
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
8067 install_breakpoint (0, std::move (c
), 1);
8070 /* A helper function that does all the work for "catch load" and
8074 catch_load_or_unload (const char *arg
, int from_tty
, int is_load
,
8075 struct cmd_list_element
*command
)
8078 const int enabled
= 1;
8080 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
8082 add_solib_catchpoint (arg
, is_load
, tempflag
, enabled
);
8086 catch_load_command_1 (const char *arg
, int from_tty
,
8087 struct cmd_list_element
*command
)
8089 catch_load_or_unload (arg
, from_tty
, 1, command
);
8093 catch_unload_command_1 (const char *arg
, int from_tty
,
8094 struct cmd_list_element
*command
)
8096 catch_load_or_unload (arg
, from_tty
, 0, command
);
8099 /* Initialize a new breakpoint of the bp_catchpoint kind. If TEMPFLAG
8100 is non-zero, then make the breakpoint temporary. If COND_STRING is
8101 not NULL, then store it in the breakpoint. OPS, if not NULL, is
8102 the breakpoint_ops structure associated to the catchpoint. */
8105 init_catchpoint (struct breakpoint
*b
,
8106 struct gdbarch
*gdbarch
, int tempflag
,
8107 const char *cond_string
,
8108 const struct breakpoint_ops
*ops
)
8110 symtab_and_line sal
;
8111 sal
.pspace
= current_program_space
;
8113 init_raw_breakpoint (b
, gdbarch
, sal
, bp_catchpoint
, ops
);
8115 b
->cond_string
= (cond_string
== NULL
) ? NULL
: xstrdup (cond_string
);
8116 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
8120 install_breakpoint (int internal
, std::unique_ptr
<breakpoint
> &&arg
, int update_gll
)
8122 breakpoint
*b
= add_to_breakpoint_chain (std::move (arg
));
8123 set_breakpoint_number (internal
, b
);
8124 if (is_tracepoint (b
))
8125 set_tracepoint_count (breakpoint_count
);
8128 gdb::observers::breakpoint_created
.notify (b
);
8131 update_global_location_list (UGLL_MAY_INSERT
);
8135 create_fork_vfork_event_catchpoint (struct gdbarch
*gdbarch
,
8136 int tempflag
, const char *cond_string
,
8137 const struct breakpoint_ops
*ops
)
8139 std::unique_ptr
<fork_catchpoint
> c (new fork_catchpoint ());
8141 init_catchpoint (c
.get (), gdbarch
, tempflag
, cond_string
, ops
);
8143 c
->forked_inferior_pid
= null_ptid
;
8145 install_breakpoint (0, std::move (c
), 1);
8148 /* Exec catchpoints. */
8150 /* An instance of this type is used to represent an exec catchpoint.
8151 A breakpoint is really of this type iff its ops pointer points to
8152 CATCH_EXEC_BREAKPOINT_OPS. */
8154 struct exec_catchpoint
: public breakpoint
8156 ~exec_catchpoint () override
;
8158 /* Filename of a program whose exec triggered this catchpoint.
8159 This field is only valid immediately after this catchpoint has
8161 char *exec_pathname
;
8164 /* Exec catchpoint destructor. */
8166 exec_catchpoint::~exec_catchpoint ()
8168 xfree (this->exec_pathname
);
8172 insert_catch_exec (struct bp_location
*bl
)
8174 return target_insert_exec_catchpoint (inferior_ptid
.pid ());
8178 remove_catch_exec (struct bp_location
*bl
, enum remove_bp_reason reason
)
8180 return target_remove_exec_catchpoint (inferior_ptid
.pid ());
8184 breakpoint_hit_catch_exec (const struct bp_location
*bl
,
8185 const address_space
*aspace
, CORE_ADDR bp_addr
,
8186 const struct target_waitstatus
*ws
)
8188 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) bl
->owner
;
8190 if (ws
->kind
!= TARGET_WAITKIND_EXECD
)
8193 c
->exec_pathname
= xstrdup (ws
->value
.execd_pathname
);
8197 static enum print_stop_action
8198 print_it_catch_exec (bpstat bs
)
8200 struct ui_out
*uiout
= current_uiout
;
8201 struct breakpoint
*b
= bs
->breakpoint_at
;
8202 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
8204 annotate_catchpoint (b
->number
);
8205 maybe_print_thread_hit_breakpoint (uiout
);
8206 if (b
->disposition
== disp_del
)
8207 uiout
->text ("Temporary catchpoint ");
8209 uiout
->text ("Catchpoint ");
8210 if (uiout
->is_mi_like_p ())
8212 uiout
->field_string ("reason", async_reason_lookup (EXEC_ASYNC_EXEC
));
8213 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
8215 uiout
->field_signed ("bkptno", b
->number
);
8216 uiout
->text (" (exec'd ");
8217 uiout
->field_string ("new-exec", c
->exec_pathname
);
8218 uiout
->text ("), ");
8220 return PRINT_SRC_AND_LOC
;
8224 print_one_catch_exec (struct breakpoint
*b
, struct bp_location
**last_loc
)
8226 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
8227 struct value_print_options opts
;
8228 struct ui_out
*uiout
= current_uiout
;
8230 get_user_print_options (&opts
);
8232 /* Field 4, the address, is omitted (which makes the columns
8233 not line up too nicely with the headers, but the effect
8234 is relatively readable). */
8235 if (opts
.addressprint
)
8236 uiout
->field_skip ("addr");
8238 uiout
->text ("exec");
8239 if (c
->exec_pathname
!= NULL
)
8241 uiout
->text (", program \"");
8242 uiout
->field_string ("what", c
->exec_pathname
);
8243 uiout
->text ("\" ");
8246 if (uiout
->is_mi_like_p ())
8247 uiout
->field_string ("catch-type", "exec");
8251 print_mention_catch_exec (struct breakpoint
*b
)
8253 printf_filtered (_("Catchpoint %d (exec)"), b
->number
);
8256 /* Implement the "print_recreate" breakpoint_ops method for exec
8260 print_recreate_catch_exec (struct breakpoint
*b
, struct ui_file
*fp
)
8262 fprintf_unfiltered (fp
, "catch exec");
8263 print_recreate_thread (b
, fp
);
8266 static struct breakpoint_ops catch_exec_breakpoint_ops
;
8269 hw_breakpoint_used_count (void)
8272 struct breakpoint
*b
;
8273 struct bp_location
*bl
;
8277 if (b
->type
== bp_hardware_breakpoint
&& breakpoint_enabled (b
))
8278 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
8280 /* Special types of hardware breakpoints may use more than
8282 i
+= b
->ops
->resources_needed (bl
);
8289 /* Returns the resources B would use if it were a hardware
8293 hw_watchpoint_use_count (struct breakpoint
*b
)
8296 struct bp_location
*bl
;
8298 if (!breakpoint_enabled (b
))
8301 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
8303 /* Special types of hardware watchpoints may use more than
8305 i
+= b
->ops
->resources_needed (bl
);
8311 /* Returns the sum the used resources of all hardware watchpoints of
8312 type TYPE in the breakpoints list. Also returns in OTHER_TYPE_USED
8313 the sum of the used resources of all hardware watchpoints of other
8314 types _not_ TYPE. */
8317 hw_watchpoint_used_count_others (struct breakpoint
*except
,
8318 enum bptype type
, int *other_type_used
)
8321 struct breakpoint
*b
;
8323 *other_type_used
= 0;
8328 if (!breakpoint_enabled (b
))
8331 if (b
->type
== type
)
8332 i
+= hw_watchpoint_use_count (b
);
8333 else if (is_hardware_watchpoint (b
))
8334 *other_type_used
= 1;
8341 disable_watchpoints_before_interactive_call_start (void)
8343 struct breakpoint
*b
;
8347 if (is_watchpoint (b
) && breakpoint_enabled (b
))
8349 b
->enable_state
= bp_call_disabled
;
8350 update_global_location_list (UGLL_DONT_INSERT
);
8356 enable_watchpoints_after_interactive_call_stop (void)
8358 struct breakpoint
*b
;
8362 if (is_watchpoint (b
) && b
->enable_state
== bp_call_disabled
)
8364 b
->enable_state
= bp_enabled
;
8365 update_global_location_list (UGLL_MAY_INSERT
);
8371 disable_breakpoints_before_startup (void)
8373 current_program_space
->executing_startup
= 1;
8374 update_global_location_list (UGLL_DONT_INSERT
);
8378 enable_breakpoints_after_startup (void)
8380 current_program_space
->executing_startup
= 0;
8381 breakpoint_re_set ();
8384 /* Create a new single-step breakpoint for thread THREAD, with no
8387 static struct breakpoint
*
8388 new_single_step_breakpoint (int thread
, struct gdbarch
*gdbarch
)
8390 std::unique_ptr
<breakpoint
> b (new breakpoint ());
8392 init_raw_breakpoint_without_location (b
.get (), gdbarch
, bp_single_step
,
8393 &momentary_breakpoint_ops
);
8395 b
->disposition
= disp_donttouch
;
8396 b
->frame_id
= null_frame_id
;
8399 gdb_assert (b
->thread
!= 0);
8401 return add_to_breakpoint_chain (std::move (b
));
8404 /* Set a momentary breakpoint of type TYPE at address specified by
8405 SAL. If FRAME_ID is valid, the breakpoint is restricted to that
8409 set_momentary_breakpoint (struct gdbarch
*gdbarch
, struct symtab_and_line sal
,
8410 struct frame_id frame_id
, enum bptype type
)
8412 struct breakpoint
*b
;
8414 /* If FRAME_ID is valid, it should be a real frame, not an inlined or
8416 gdb_assert (!frame_id_artificial_p (frame_id
));
8418 b
= set_raw_breakpoint (gdbarch
, sal
, type
, &momentary_breakpoint_ops
);
8419 b
->enable_state
= bp_enabled
;
8420 b
->disposition
= disp_donttouch
;
8421 b
->frame_id
= frame_id
;
8423 b
->thread
= inferior_thread ()->global_num
;
8425 update_global_location_list_nothrow (UGLL_MAY_INSERT
);
8427 return breakpoint_up (b
);
8430 /* Make a momentary breakpoint based on the master breakpoint ORIG.
8431 The new breakpoint will have type TYPE, use OPS as its
8432 breakpoint_ops, and will set enabled to LOC_ENABLED. */
8434 static struct breakpoint
*
8435 momentary_breakpoint_from_master (struct breakpoint
*orig
,
8437 const struct breakpoint_ops
*ops
,
8440 struct breakpoint
*copy
;
8442 copy
= set_raw_breakpoint_without_location (orig
->gdbarch
, type
, ops
);
8443 copy
->loc
= allocate_bp_location (copy
);
8444 set_breakpoint_location_function (copy
->loc
);
8446 copy
->loc
->gdbarch
= orig
->loc
->gdbarch
;
8447 copy
->loc
->requested_address
= orig
->loc
->requested_address
;
8448 copy
->loc
->address
= orig
->loc
->address
;
8449 copy
->loc
->section
= orig
->loc
->section
;
8450 copy
->loc
->pspace
= orig
->loc
->pspace
;
8451 copy
->loc
->probe
= orig
->loc
->probe
;
8452 copy
->loc
->line_number
= orig
->loc
->line_number
;
8453 copy
->loc
->symtab
= orig
->loc
->symtab
;
8454 copy
->loc
->enabled
= loc_enabled
;
8455 copy
->frame_id
= orig
->frame_id
;
8456 copy
->thread
= orig
->thread
;
8457 copy
->pspace
= orig
->pspace
;
8459 copy
->enable_state
= bp_enabled
;
8460 copy
->disposition
= disp_donttouch
;
8461 copy
->number
= internal_breakpoint_number
--;
8463 update_global_location_list_nothrow (UGLL_DONT_INSERT
);
8467 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
8471 clone_momentary_breakpoint (struct breakpoint
*orig
)
8473 /* If there's nothing to clone, then return nothing. */
8477 return momentary_breakpoint_from_master (orig
, orig
->type
, orig
->ops
, 0);
8481 set_momentary_breakpoint_at_pc (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
8484 struct symtab_and_line sal
;
8486 sal
= find_pc_line (pc
, 0);
8488 sal
.section
= find_pc_overlay (pc
);
8489 sal
.explicit_pc
= 1;
8491 return set_momentary_breakpoint (gdbarch
, sal
, null_frame_id
, type
);
8495 /* Tell the user we have just set a breakpoint B. */
8498 mention (struct breakpoint
*b
)
8500 b
->ops
->print_mention (b
);
8501 current_uiout
->text ("\n");
8505 static bool bp_loc_is_permanent (struct bp_location
*loc
);
8507 /* Handle "set breakpoint auto-hw on".
8509 If the explicitly specified breakpoint type is not hardware
8510 breakpoint, check the memory map to see whether the breakpoint
8511 address is in read-only memory.
8513 - location type is not hardware breakpoint, memory is read-only.
8514 We change the type of the location to hardware breakpoint.
8516 - location type is hardware breakpoint, memory is read-write. This
8517 means we've previously made the location hardware one, but then the
8518 memory map changed, so we undo.
8522 handle_automatic_hardware_breakpoints (bp_location
*bl
)
8524 if (automatic_hardware_breakpoints
8525 && bl
->owner
->type
!= bp_hardware_breakpoint
8526 && (bl
->loc_type
== bp_loc_software_breakpoint
8527 || bl
->loc_type
== bp_loc_hardware_breakpoint
))
8529 /* When breakpoints are removed, remove_breakpoints will use
8530 location types we've just set here, the only possible problem
8531 is that memory map has changed during running program, but
8532 it's not going to work anyway with current gdb. */
8533 mem_region
*mr
= lookup_mem_region (bl
->address
);
8537 enum bp_loc_type new_type
;
8539 if (mr
->attrib
.mode
!= MEM_RW
)
8540 new_type
= bp_loc_hardware_breakpoint
;
8542 new_type
= bp_loc_software_breakpoint
;
8544 if (new_type
!= bl
->loc_type
)
8546 static bool said
= false;
8548 bl
->loc_type
= new_type
;
8551 fprintf_filtered (gdb_stdout
,
8552 _("Note: automatically using "
8553 "hardware breakpoints for "
8554 "read-only addresses.\n"));
8562 static struct bp_location
*
8563 add_location_to_breakpoint (struct breakpoint
*b
,
8564 const struct symtab_and_line
*sal
)
8566 struct bp_location
*loc
, **tmp
;
8567 CORE_ADDR adjusted_address
;
8568 struct gdbarch
*loc_gdbarch
= get_sal_arch (*sal
);
8570 if (loc_gdbarch
== NULL
)
8571 loc_gdbarch
= b
->gdbarch
;
8573 /* Adjust the breakpoint's address prior to allocating a location.
8574 Once we call allocate_bp_location(), that mostly uninitialized
8575 location will be placed on the location chain. Adjustment of the
8576 breakpoint may cause target_read_memory() to be called and we do
8577 not want its scan of the location chain to find a breakpoint and
8578 location that's only been partially initialized. */
8579 adjusted_address
= adjust_breakpoint_address (loc_gdbarch
,
8582 /* Sort the locations by their ADDRESS. */
8583 loc
= allocate_bp_location (b
);
8584 for (tmp
= &(b
->loc
); *tmp
!= NULL
&& (*tmp
)->address
<= adjusted_address
;
8585 tmp
= &((*tmp
)->next
))
8590 loc
->requested_address
= sal
->pc
;
8591 loc
->address
= adjusted_address
;
8592 loc
->pspace
= sal
->pspace
;
8593 loc
->probe
.prob
= sal
->prob
;
8594 loc
->probe
.objfile
= sal
->objfile
;
8595 gdb_assert (loc
->pspace
!= NULL
);
8596 loc
->section
= sal
->section
;
8597 loc
->gdbarch
= loc_gdbarch
;
8598 loc
->line_number
= sal
->line
;
8599 loc
->symtab
= sal
->symtab
;
8600 loc
->symbol
= sal
->symbol
;
8601 loc
->msymbol
= sal
->msymbol
;
8602 loc
->objfile
= sal
->objfile
;
8604 set_breakpoint_location_function (loc
);
8606 /* While by definition, permanent breakpoints are already present in the
8607 code, we don't mark the location as inserted. Normally one would expect
8608 that GDB could rely on that breakpoint instruction to stop the program,
8609 thus removing the need to insert its own breakpoint, except that executing
8610 the breakpoint instruction can kill the target instead of reporting a
8611 SIGTRAP. E.g., on SPARC, when interrupts are disabled, executing the
8612 instruction resets the CPU, so QEMU 2.0.0 for SPARC correspondingly dies
8613 with "Trap 0x02 while interrupts disabled, Error state". Letting the
8614 breakpoint be inserted normally results in QEMU knowing about the GDB
8615 breakpoint, and thus trap before the breakpoint instruction is executed.
8616 (If GDB later needs to continue execution past the permanent breakpoint,
8617 it manually increments the PC, thus avoiding executing the breakpoint
8619 if (bp_loc_is_permanent (loc
))
8626 /* Return true if LOC is pointing to a permanent breakpoint,
8627 return false otherwise. */
8630 bp_loc_is_permanent (struct bp_location
*loc
)
8632 gdb_assert (loc
!= NULL
);
8634 /* If we have a non-breakpoint-backed catchpoint or a software
8635 watchpoint, just return 0. We should not attempt to read from
8636 the addresses the locations of these breakpoint types point to.
8637 gdbarch_program_breakpoint_here_p, below, will attempt to read
8639 if (!bl_address_is_meaningful (loc
))
8642 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
8643 switch_to_program_space_and_thread (loc
->pspace
);
8644 return gdbarch_program_breakpoint_here_p (loc
->gdbarch
, loc
->address
);
8647 /* Build a command list for the dprintf corresponding to the current
8648 settings of the dprintf style options. */
8651 update_dprintf_command_list (struct breakpoint
*b
)
8653 char *dprintf_args
= b
->extra_string
;
8654 char *printf_line
= NULL
;
8659 dprintf_args
= skip_spaces (dprintf_args
);
8661 /* Allow a comma, as it may have terminated a location, but don't
8663 if (*dprintf_args
== ',')
8665 dprintf_args
= skip_spaces (dprintf_args
);
8667 if (*dprintf_args
!= '"')
8668 error (_("Bad format string, missing '\"'."));
8670 if (strcmp (dprintf_style
, dprintf_style_gdb
) == 0)
8671 printf_line
= xstrprintf ("printf %s", dprintf_args
);
8672 else if (strcmp (dprintf_style
, dprintf_style_call
) == 0)
8674 if (!dprintf_function
)
8675 error (_("No function supplied for dprintf call"));
8677 if (dprintf_channel
&& strlen (dprintf_channel
) > 0)
8678 printf_line
= xstrprintf ("call (void) %s (%s,%s)",
8683 printf_line
= xstrprintf ("call (void) %s (%s)",
8687 else if (strcmp (dprintf_style
, dprintf_style_agent
) == 0)
8689 if (target_can_run_breakpoint_commands ())
8690 printf_line
= xstrprintf ("agent-printf %s", dprintf_args
);
8693 warning (_("Target cannot run dprintf commands, falling back to GDB printf"));
8694 printf_line
= xstrprintf ("printf %s", dprintf_args
);
8698 internal_error (__FILE__
, __LINE__
,
8699 _("Invalid dprintf style."));
8701 gdb_assert (printf_line
!= NULL
);
8703 /* Manufacture a printf sequence. */
8704 struct command_line
*printf_cmd_line
8705 = new struct command_line (simple_control
, printf_line
);
8706 breakpoint_set_commands (b
, counted_command_line (printf_cmd_line
,
8707 command_lines_deleter ()));
8710 /* Update all dprintf commands, making their command lists reflect
8711 current style settings. */
8714 update_dprintf_commands (const char *args
, int from_tty
,
8715 struct cmd_list_element
*c
)
8717 struct breakpoint
*b
;
8721 if (b
->type
== bp_dprintf
)
8722 update_dprintf_command_list (b
);
8726 /* Create a breakpoint with SAL as location. Use LOCATION
8727 as a description of the location, and COND_STRING
8728 as condition expression. If LOCATION is NULL then create an
8729 "address location" from the address in the SAL. */
8732 init_breakpoint_sal (struct breakpoint
*b
, struct gdbarch
*gdbarch
,
8733 gdb::array_view
<const symtab_and_line
> sals
,
8734 event_location_up
&&location
,
8735 gdb::unique_xmalloc_ptr
<char> filter
,
8736 gdb::unique_xmalloc_ptr
<char> cond_string
,
8737 gdb::unique_xmalloc_ptr
<char> extra_string
,
8738 enum bptype type
, enum bpdisp disposition
,
8739 int thread
, int task
, int ignore_count
,
8740 const struct breakpoint_ops
*ops
, int from_tty
,
8741 int enabled
, int internal
, unsigned flags
,
8742 int display_canonical
)
8746 if (type
== bp_hardware_breakpoint
)
8748 int target_resources_ok
;
8750 i
= hw_breakpoint_used_count ();
8751 target_resources_ok
=
8752 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
8754 if (target_resources_ok
== 0)
8755 error (_("No hardware breakpoint support in the target."));
8756 else if (target_resources_ok
< 0)
8757 error (_("Hardware breakpoints used exceeds limit."));
8760 gdb_assert (!sals
.empty ());
8762 for (const auto &sal
: sals
)
8764 struct bp_location
*loc
;
8768 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
8770 loc_gdbarch
= gdbarch
;
8772 describe_other_breakpoints (loc_gdbarch
,
8773 sal
.pspace
, sal
.pc
, sal
.section
, thread
);
8776 if (&sal
== &sals
[0])
8778 init_raw_breakpoint (b
, gdbarch
, sal
, type
, ops
);
8782 b
->cond_string
= cond_string
.release ();
8783 b
->extra_string
= extra_string
.release ();
8784 b
->ignore_count
= ignore_count
;
8785 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
8786 b
->disposition
= disposition
;
8788 if ((flags
& CREATE_BREAKPOINT_FLAGS_INSERTED
) != 0)
8789 b
->loc
->inserted
= 1;
8791 if (type
== bp_static_tracepoint
)
8793 struct tracepoint
*t
= (struct tracepoint
*) b
;
8794 struct static_tracepoint_marker marker
;
8796 if (strace_marker_p (b
))
8798 /* We already know the marker exists, otherwise, we
8799 wouldn't see a sal for it. */
8801 = &event_location_to_string (b
->location
.get ())[3];
8804 p
= skip_spaces (p
);
8806 endp
= skip_to_space (p
);
8808 t
->static_trace_marker_id
.assign (p
, endp
- p
);
8810 printf_filtered (_("Probed static tracepoint "
8812 t
->static_trace_marker_id
.c_str ());
8814 else if (target_static_tracepoint_marker_at (sal
.pc
, &marker
))
8816 t
->static_trace_marker_id
= std::move (marker
.str_id
);
8818 printf_filtered (_("Probed static tracepoint "
8820 t
->static_trace_marker_id
.c_str ());
8823 warning (_("Couldn't determine the static "
8824 "tracepoint marker to probe"));
8831 loc
= add_location_to_breakpoint (b
, &sal
);
8832 if ((flags
& CREATE_BREAKPOINT_FLAGS_INSERTED
) != 0)
8838 const char *arg
= b
->cond_string
;
8840 loc
->cond
= parse_exp_1 (&arg
, loc
->address
,
8841 block_for_pc (loc
->address
), 0);
8843 error (_("Garbage '%s' follows condition"), arg
);
8846 /* Dynamic printf requires and uses additional arguments on the
8847 command line, otherwise it's an error. */
8848 if (type
== bp_dprintf
)
8850 if (b
->extra_string
)
8851 update_dprintf_command_list (b
);
8853 error (_("Format string required"));
8855 else if (b
->extra_string
)
8856 error (_("Garbage '%s' at end of command"), b
->extra_string
);
8859 b
->display_canonical
= display_canonical
;
8860 if (location
!= NULL
)
8861 b
->location
= std::move (location
);
8863 b
->location
= new_address_location (b
->loc
->address
, NULL
, 0);
8864 b
->filter
= std::move (filter
);
8868 create_breakpoint_sal (struct gdbarch
*gdbarch
,
8869 gdb::array_view
<const symtab_and_line
> sals
,
8870 event_location_up
&&location
,
8871 gdb::unique_xmalloc_ptr
<char> filter
,
8872 gdb::unique_xmalloc_ptr
<char> cond_string
,
8873 gdb::unique_xmalloc_ptr
<char> extra_string
,
8874 enum bptype type
, enum bpdisp disposition
,
8875 int thread
, int task
, int ignore_count
,
8876 const struct breakpoint_ops
*ops
, int from_tty
,
8877 int enabled
, int internal
, unsigned flags
,
8878 int display_canonical
)
8880 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (type
);
8882 init_breakpoint_sal (b
.get (), gdbarch
,
8883 sals
, std::move (location
),
8885 std::move (cond_string
),
8886 std::move (extra_string
),
8888 thread
, task
, ignore_count
,
8890 enabled
, internal
, flags
,
8893 install_breakpoint (internal
, std::move (b
), 0);
8896 /* Add SALS.nelts breakpoints to the breakpoint table. For each
8897 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
8898 value. COND_STRING, if not NULL, specified the condition to be
8899 used for all breakpoints. Essentially the only case where
8900 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
8901 function. In that case, it's still not possible to specify
8902 separate conditions for different overloaded functions, so
8903 we take just a single condition string.
8905 NOTE: If the function succeeds, the caller is expected to cleanup
8906 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
8907 array contents). If the function fails (error() is called), the
8908 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
8909 COND and SALS arrays and each of those arrays contents. */
8912 create_breakpoints_sal (struct gdbarch
*gdbarch
,
8913 struct linespec_result
*canonical
,
8914 gdb::unique_xmalloc_ptr
<char> cond_string
,
8915 gdb::unique_xmalloc_ptr
<char> extra_string
,
8916 enum bptype type
, enum bpdisp disposition
,
8917 int thread
, int task
, int ignore_count
,
8918 const struct breakpoint_ops
*ops
, int from_tty
,
8919 int enabled
, int internal
, unsigned flags
)
8921 if (canonical
->pre_expanded
)
8922 gdb_assert (canonical
->lsals
.size () == 1);
8924 for (const auto &lsal
: canonical
->lsals
)
8926 /* Note that 'location' can be NULL in the case of a plain
8927 'break', without arguments. */
8928 event_location_up location
8929 = (canonical
->location
!= NULL
8930 ? copy_event_location (canonical
->location
.get ()) : NULL
);
8931 gdb::unique_xmalloc_ptr
<char> filter_string
8932 (lsal
.canonical
!= NULL
? xstrdup (lsal
.canonical
) : NULL
);
8934 create_breakpoint_sal (gdbarch
, lsal
.sals
,
8935 std::move (location
),
8936 std::move (filter_string
),
8937 std::move (cond_string
),
8938 std::move (extra_string
),
8940 thread
, task
, ignore_count
, ops
,
8941 from_tty
, enabled
, internal
, flags
,
8942 canonical
->special_display
);
8946 /* Parse LOCATION which is assumed to be a SAL specification possibly
8947 followed by conditionals. On return, SALS contains an array of SAL
8948 addresses found. LOCATION points to the end of the SAL (for
8949 linespec locations).
8951 The array and the line spec strings are allocated on the heap, it is
8952 the caller's responsibility to free them. */
8955 parse_breakpoint_sals (const struct event_location
*location
,
8956 struct linespec_result
*canonical
)
8958 struct symtab_and_line cursal
;
8960 if (event_location_type (location
) == LINESPEC_LOCATION
)
8962 const char *spec
= get_linespec_location (location
)->spec_string
;
8966 /* The last displayed codepoint, if it's valid, is our default
8967 breakpoint address. */
8968 if (last_displayed_sal_is_valid ())
8970 /* Set sal's pspace, pc, symtab, and line to the values
8971 corresponding to the last call to print_frame_info.
8972 Be sure to reinitialize LINE with NOTCURRENT == 0
8973 as the breakpoint line number is inappropriate otherwise.
8974 find_pc_line would adjust PC, re-set it back. */
8975 symtab_and_line sal
= get_last_displayed_sal ();
8976 CORE_ADDR pc
= sal
.pc
;
8978 sal
= find_pc_line (pc
, 0);
8980 /* "break" without arguments is equivalent to "break *PC"
8981 where PC is the last displayed codepoint's address. So
8982 make sure to set sal.explicit_pc to prevent GDB from
8983 trying to expand the list of sals to include all other
8984 instances with the same symtab and line. */
8986 sal
.explicit_pc
= 1;
8988 struct linespec_sals lsal
;
8990 lsal
.canonical
= NULL
;
8992 canonical
->lsals
.push_back (std::move (lsal
));
8996 error (_("No default breakpoint address now."));
9000 /* Force almost all breakpoints to be in terms of the
9001 current_source_symtab (which is decode_line_1's default).
9002 This should produce the results we want almost all of the
9003 time while leaving default_breakpoint_* alone.
9005 ObjC: However, don't match an Objective-C method name which
9006 may have a '+' or '-' succeeded by a '['. */
9007 cursal
= get_current_source_symtab_and_line ();
9008 if (last_displayed_sal_is_valid ())
9010 const char *spec
= NULL
;
9012 if (event_location_type (location
) == LINESPEC_LOCATION
)
9013 spec
= get_linespec_location (location
)->spec_string
;
9017 && strchr ("+-", spec
[0]) != NULL
9020 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, NULL
,
9021 get_last_displayed_symtab (),
9022 get_last_displayed_line (),
9023 canonical
, NULL
, NULL
);
9028 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, NULL
,
9029 cursal
.symtab
, cursal
.line
, canonical
, NULL
, NULL
);
9033 /* Convert each SAL into a real PC. Verify that the PC can be
9034 inserted as a breakpoint. If it can't throw an error. */
9037 breakpoint_sals_to_pc (std::vector
<symtab_and_line
> &sals
)
9039 for (auto &sal
: sals
)
9040 resolve_sal_pc (&sal
);
9043 /* Fast tracepoints may have restrictions on valid locations. For
9044 instance, a fast tracepoint using a jump instead of a trap will
9045 likely have to overwrite more bytes than a trap would, and so can
9046 only be placed where the instruction is longer than the jump, or a
9047 multi-instruction sequence does not have a jump into the middle of
9051 check_fast_tracepoint_sals (struct gdbarch
*gdbarch
,
9052 gdb::array_view
<const symtab_and_line
> sals
)
9054 for (const auto &sal
: sals
)
9056 struct gdbarch
*sarch
;
9058 sarch
= get_sal_arch (sal
);
9059 /* We fall back to GDBARCH if there is no architecture
9060 associated with SAL. */
9064 if (!gdbarch_fast_tracepoint_valid_at (sarch
, sal
.pc
, &msg
))
9065 error (_("May not have a fast tracepoint at %s%s"),
9066 paddress (sarch
, sal
.pc
), msg
.c_str ());
9070 /* Given TOK, a string specification of condition and thread, as
9071 accepted by the 'break' command, extract the condition
9072 string and thread number and set *COND_STRING and *THREAD.
9073 PC identifies the context at which the condition should be parsed.
9074 If no condition is found, *COND_STRING is set to NULL.
9075 If no thread is found, *THREAD is set to -1. */
9078 find_condition_and_thread (const char *tok
, CORE_ADDR pc
,
9079 char **cond_string
, int *thread
, int *task
,
9082 *cond_string
= NULL
;
9089 const char *end_tok
;
9091 const char *cond_start
= NULL
;
9092 const char *cond_end
= NULL
;
9094 tok
= skip_spaces (tok
);
9096 if ((*tok
== '"' || *tok
== ',') && rest
)
9098 *rest
= savestring (tok
, strlen (tok
));
9102 end_tok
= skip_to_space (tok
);
9104 toklen
= end_tok
- tok
;
9106 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
9108 tok
= cond_start
= end_tok
+ 1;
9109 parse_exp_1 (&tok
, pc
, block_for_pc (pc
), 0);
9111 *cond_string
= savestring (cond_start
, cond_end
- cond_start
);
9113 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
9116 struct thread_info
*thr
;
9119 thr
= parse_thread_id (tok
, &tmptok
);
9121 error (_("Junk after thread keyword."));
9122 *thread
= thr
->global_num
;
9125 else if (toklen
>= 1 && strncmp (tok
, "task", toklen
) == 0)
9130 *task
= strtol (tok
, &tmptok
, 0);
9132 error (_("Junk after task keyword."));
9133 if (!valid_task_id (*task
))
9134 error (_("Unknown task %d."), *task
);
9139 *rest
= savestring (tok
, strlen (tok
));
9143 error (_("Junk at end of arguments."));
9147 /* Decode a static tracepoint marker spec. */
9149 static std::vector
<symtab_and_line
>
9150 decode_static_tracepoint_spec (const char **arg_p
)
9152 const char *p
= &(*arg_p
)[3];
9155 p
= skip_spaces (p
);
9157 endp
= skip_to_space (p
);
9159 std::string
marker_str (p
, endp
- p
);
9161 std::vector
<static_tracepoint_marker
> markers
9162 = target_static_tracepoint_markers_by_strid (marker_str
.c_str ());
9163 if (markers
.empty ())
9164 error (_("No known static tracepoint marker named %s"),
9165 marker_str
.c_str ());
9167 std::vector
<symtab_and_line
> sals
;
9168 sals
.reserve (markers
.size ());
9170 for (const static_tracepoint_marker
&marker
: markers
)
9172 symtab_and_line sal
= find_pc_line (marker
.address
, 0);
9173 sal
.pc
= marker
.address
;
9174 sals
.push_back (sal
);
9181 /* Returns the breakpoint ops appropriate for use with with LOCATION_TYPE and
9182 according to IS_TRACEPOINT. */
9184 static const struct breakpoint_ops
*
9185 breakpoint_ops_for_event_location_type (enum event_location_type location_type
,
9190 if (location_type
== PROBE_LOCATION
)
9191 return &tracepoint_probe_breakpoint_ops
;
9193 return &tracepoint_breakpoint_ops
;
9197 if (location_type
== PROBE_LOCATION
)
9198 return &bkpt_probe_breakpoint_ops
;
9200 return &bkpt_breakpoint_ops
;
9204 /* See breakpoint.h. */
9206 const struct breakpoint_ops
*
9207 breakpoint_ops_for_event_location (const struct event_location
*location
,
9210 if (location
!= nullptr)
9211 return breakpoint_ops_for_event_location_type
9212 (event_location_type (location
), is_tracepoint
);
9213 return is_tracepoint
? &tracepoint_breakpoint_ops
: &bkpt_breakpoint_ops
;
9216 /* See breakpoint.h. */
9219 create_breakpoint (struct gdbarch
*gdbarch
,
9220 const struct event_location
*location
,
9221 const char *cond_string
,
9222 int thread
, const char *extra_string
,
9224 int tempflag
, enum bptype type_wanted
,
9226 enum auto_boolean pending_break_support
,
9227 const struct breakpoint_ops
*ops
,
9228 int from_tty
, int enabled
, int internal
,
9231 struct linespec_result canonical
;
9234 int prev_bkpt_count
= breakpoint_count
;
9236 gdb_assert (ops
!= NULL
);
9238 /* If extra_string isn't useful, set it to NULL. */
9239 if (extra_string
!= NULL
&& *extra_string
== '\0')
9240 extra_string
= NULL
;
9244 ops
->create_sals_from_location (location
, &canonical
, type_wanted
);
9246 catch (const gdb_exception_error
&e
)
9248 /* If caller is interested in rc value from parse, set
9250 if (e
.error
== NOT_FOUND_ERROR
)
9252 /* If pending breakpoint support is turned off, throw
9255 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
9258 exception_print (gdb_stderr
, e
);
9260 /* If pending breakpoint support is auto query and the user
9261 selects no, then simply return the error code. */
9262 if (pending_break_support
== AUTO_BOOLEAN_AUTO
9263 && !nquery (_("Make %s pending on future shared library load? "),
9264 bptype_string (type_wanted
)))
9267 /* At this point, either the user was queried about setting
9268 a pending breakpoint and selected yes, or pending
9269 breakpoint behavior is on and thus a pending breakpoint
9270 is defaulted on behalf of the user. */
9277 if (!pending
&& canonical
.lsals
.empty ())
9280 /* Resolve all line numbers to PC's and verify that the addresses
9281 are ok for the target. */
9284 for (auto &lsal
: canonical
.lsals
)
9285 breakpoint_sals_to_pc (lsal
.sals
);
9288 /* Fast tracepoints may have additional restrictions on location. */
9289 if (!pending
&& type_wanted
== bp_fast_tracepoint
)
9291 for (const auto &lsal
: canonical
.lsals
)
9292 check_fast_tracepoint_sals (gdbarch
, lsal
.sals
);
9295 /* Verify that condition can be parsed, before setting any
9296 breakpoints. Allocate a separate condition expression for each
9300 gdb::unique_xmalloc_ptr
<char> cond_string_copy
;
9301 gdb::unique_xmalloc_ptr
<char> extra_string_copy
;
9308 const linespec_sals
&lsal
= canonical
.lsals
[0];
9310 /* Here we only parse 'arg' to separate condition
9311 from thread number, so parsing in context of first
9312 sal is OK. When setting the breakpoint we'll
9313 re-parse it in context of each sal. */
9315 find_condition_and_thread (extra_string
, lsal
.sals
[0].pc
,
9316 &cond
, &thread
, &task
, &rest
);
9317 cond_string_copy
.reset (cond
);
9318 extra_string_copy
.reset (rest
);
9322 if (type_wanted
!= bp_dprintf
9323 && extra_string
!= NULL
&& *extra_string
!= '\0')
9324 error (_("Garbage '%s' at end of location"), extra_string
);
9326 /* Create a private copy of condition string. */
9328 cond_string_copy
.reset (xstrdup (cond_string
));
9329 /* Create a private copy of any extra string. */
9331 extra_string_copy
.reset (xstrdup (extra_string
));
9334 ops
->create_breakpoints_sal (gdbarch
, &canonical
,
9335 std::move (cond_string_copy
),
9336 std::move (extra_string_copy
),
9338 tempflag
? disp_del
: disp_donttouch
,
9339 thread
, task
, ignore_count
, ops
,
9340 from_tty
, enabled
, internal
, flags
);
9344 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (type_wanted
);
9346 init_raw_breakpoint_without_location (b
.get (), gdbarch
, type_wanted
, ops
);
9347 b
->location
= copy_event_location (location
);
9350 b
->cond_string
= NULL
;
9353 /* Create a private copy of condition string. */
9354 b
->cond_string
= cond_string
!= NULL
? xstrdup (cond_string
) : NULL
;
9358 /* Create a private copy of any extra string. */
9359 b
->extra_string
= extra_string
!= NULL
? xstrdup (extra_string
) : NULL
;
9360 b
->ignore_count
= ignore_count
;
9361 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
9362 b
->condition_not_parsed
= 1;
9363 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
9364 if ((type_wanted
!= bp_breakpoint
9365 && type_wanted
!= bp_hardware_breakpoint
) || thread
!= -1)
9366 b
->pspace
= current_program_space
;
9368 install_breakpoint (internal
, std::move (b
), 0);
9371 if (canonical
.lsals
.size () > 1)
9373 warning (_("Multiple breakpoints were set.\nUse the "
9374 "\"delete\" command to delete unwanted breakpoints."));
9375 prev_breakpoint_count
= prev_bkpt_count
;
9378 update_global_location_list (UGLL_MAY_INSERT
);
9383 /* Set a breakpoint.
9384 ARG is a string describing breakpoint address,
9385 condition, and thread.
9386 FLAG specifies if a breakpoint is hardware on,
9387 and if breakpoint is temporary, using BP_HARDWARE_FLAG
9391 break_command_1 (const char *arg
, int flag
, int from_tty
)
9393 int tempflag
= flag
& BP_TEMPFLAG
;
9394 enum bptype type_wanted
= (flag
& BP_HARDWAREFLAG
9395 ? bp_hardware_breakpoint
9398 event_location_up location
= string_to_event_location (&arg
, current_language
);
9399 const struct breakpoint_ops
*ops
= breakpoint_ops_for_event_location
9400 (location
.get (), false /* is_tracepoint */);
9402 create_breakpoint (get_current_arch (),
9404 NULL
, 0, arg
, 1 /* parse arg */,
9405 tempflag
, type_wanted
,
9406 0 /* Ignore count */,
9407 pending_break_support
,
9415 /* Helper function for break_command_1 and disassemble_command. */
9418 resolve_sal_pc (struct symtab_and_line
*sal
)
9422 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
9424 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
9425 error (_("No line %d in file \"%s\"."),
9426 sal
->line
, symtab_to_filename_for_display (sal
->symtab
));
9429 /* If this SAL corresponds to a breakpoint inserted using a line
9430 number, then skip the function prologue if necessary. */
9431 if (sal
->explicit_line
)
9432 skip_prologue_sal (sal
);
9435 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
9437 const struct blockvector
*bv
;
9438 const struct block
*b
;
9441 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
,
9442 SYMTAB_COMPUNIT (sal
->symtab
));
9445 sym
= block_linkage_function (b
);
9448 fixup_symbol_section (sym
, SYMTAB_OBJFILE (sal
->symtab
));
9449 sal
->section
= SYMBOL_OBJ_SECTION (SYMTAB_OBJFILE (sal
->symtab
),
9454 /* It really is worthwhile to have the section, so we'll
9455 just have to look harder. This case can be executed
9456 if we have line numbers but no functions (as can
9457 happen in assembly source). */
9459 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
9460 switch_to_program_space_and_thread (sal
->pspace
);
9462 bound_minimal_symbol msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
9464 sal
->section
= MSYMBOL_OBJ_SECTION (msym
.objfile
, msym
.minsym
);
9471 break_command (const char *arg
, int from_tty
)
9473 break_command_1 (arg
, 0, from_tty
);
9477 tbreak_command (const char *arg
, int from_tty
)
9479 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
9483 hbreak_command (const char *arg
, int from_tty
)
9485 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
9489 thbreak_command (const char *arg
, int from_tty
)
9491 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
9495 stop_command (const char *arg
, int from_tty
)
9497 printf_filtered (_("Specify the type of breakpoint to set.\n\
9498 Usage: stop in <function | address>\n\
9499 stop at <line>\n"));
9503 stopin_command (const char *arg
, int from_tty
)
9509 else if (*arg
!= '*')
9511 const char *argptr
= arg
;
9514 /* Look for a ':'. If this is a line number specification, then
9515 say it is bad, otherwise, it should be an address or
9516 function/method name. */
9517 while (*argptr
&& !hasColon
)
9519 hasColon
= (*argptr
== ':');
9524 badInput
= (*argptr
!= ':'); /* Not a class::method */
9526 badInput
= isdigit (*arg
); /* a simple line number */
9530 printf_filtered (_("Usage: stop in <function | address>\n"));
9532 break_command_1 (arg
, 0, from_tty
);
9536 stopat_command (const char *arg
, int from_tty
)
9540 if (arg
== NULL
|| *arg
== '*') /* no line number */
9544 const char *argptr
= arg
;
9547 /* Look for a ':'. If there is a '::' then get out, otherwise
9548 it is probably a line number. */
9549 while (*argptr
&& !hasColon
)
9551 hasColon
= (*argptr
== ':');
9556 badInput
= (*argptr
== ':'); /* we have class::method */
9558 badInput
= !isdigit (*arg
); /* not a line number */
9562 printf_filtered (_("Usage: stop at LINE\n"));
9564 break_command_1 (arg
, 0, from_tty
);
9567 /* The dynamic printf command is mostly like a regular breakpoint, but
9568 with a prewired command list consisting of a single output command,
9569 built from extra arguments supplied on the dprintf command
9573 dprintf_command (const char *arg
, int from_tty
)
9575 event_location_up location
= string_to_event_location (&arg
, current_language
);
9577 /* If non-NULL, ARG should have been advanced past the location;
9578 the next character must be ','. */
9581 if (arg
[0] != ',' || arg
[1] == '\0')
9582 error (_("Format string required"));
9585 /* Skip the comma. */
9590 create_breakpoint (get_current_arch (),
9592 NULL
, 0, arg
, 1 /* parse arg */,
9594 0 /* Ignore count */,
9595 pending_break_support
,
9596 &dprintf_breakpoint_ops
,
9604 agent_printf_command (const char *arg
, int from_tty
)
9606 error (_("May only run agent-printf on the target"));
9609 /* Implement the "breakpoint_hit" breakpoint_ops method for
9610 ranged breakpoints. */
9613 breakpoint_hit_ranged_breakpoint (const struct bp_location
*bl
,
9614 const address_space
*aspace
,
9616 const struct target_waitstatus
*ws
)
9618 if (ws
->kind
!= TARGET_WAITKIND_STOPPED
9619 || ws
->value
.sig
!= GDB_SIGNAL_TRAP
)
9622 return breakpoint_address_match_range (bl
->pspace
->aspace
, bl
->address
,
9623 bl
->length
, aspace
, bp_addr
);
9626 /* Implement the "resources_needed" breakpoint_ops method for
9627 ranged breakpoints. */
9630 resources_needed_ranged_breakpoint (const struct bp_location
*bl
)
9632 return target_ranged_break_num_registers ();
9635 /* Implement the "print_it" breakpoint_ops method for
9636 ranged breakpoints. */
9638 static enum print_stop_action
9639 print_it_ranged_breakpoint (bpstat bs
)
9641 struct breakpoint
*b
= bs
->breakpoint_at
;
9642 struct bp_location
*bl
= b
->loc
;
9643 struct ui_out
*uiout
= current_uiout
;
9645 gdb_assert (b
->type
== bp_hardware_breakpoint
);
9647 /* Ranged breakpoints have only one location. */
9648 gdb_assert (bl
&& bl
->next
== NULL
);
9650 annotate_breakpoint (b
->number
);
9652 maybe_print_thread_hit_breakpoint (uiout
);
9654 if (b
->disposition
== disp_del
)
9655 uiout
->text ("Temporary ranged breakpoint ");
9657 uiout
->text ("Ranged breakpoint ");
9658 if (uiout
->is_mi_like_p ())
9660 uiout
->field_string ("reason",
9661 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
9662 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
9664 uiout
->field_signed ("bkptno", b
->number
);
9667 return PRINT_SRC_AND_LOC
;
9670 /* Implement the "print_one" breakpoint_ops method for
9671 ranged breakpoints. */
9674 print_one_ranged_breakpoint (struct breakpoint
*b
,
9675 struct bp_location
**last_loc
)
9677 struct bp_location
*bl
= b
->loc
;
9678 struct value_print_options opts
;
9679 struct ui_out
*uiout
= current_uiout
;
9681 /* Ranged breakpoints have only one location. */
9682 gdb_assert (bl
&& bl
->next
== NULL
);
9684 get_user_print_options (&opts
);
9686 if (opts
.addressprint
)
9687 /* We don't print the address range here, it will be printed later
9688 by print_one_detail_ranged_breakpoint. */
9689 uiout
->field_skip ("addr");
9691 print_breakpoint_location (b
, bl
);
9695 /* Implement the "print_one_detail" breakpoint_ops method for
9696 ranged breakpoints. */
9699 print_one_detail_ranged_breakpoint (const struct breakpoint
*b
,
9700 struct ui_out
*uiout
)
9702 CORE_ADDR address_start
, address_end
;
9703 struct bp_location
*bl
= b
->loc
;
9708 address_start
= bl
->address
;
9709 address_end
= address_start
+ bl
->length
- 1;
9711 uiout
->text ("\taddress range: ");
9712 stb
.printf ("[%s, %s]",
9713 print_core_address (bl
->gdbarch
, address_start
),
9714 print_core_address (bl
->gdbarch
, address_end
));
9715 uiout
->field_stream ("addr", stb
);
9719 /* Implement the "print_mention" breakpoint_ops method for
9720 ranged breakpoints. */
9723 print_mention_ranged_breakpoint (struct breakpoint
*b
)
9725 struct bp_location
*bl
= b
->loc
;
9726 struct ui_out
*uiout
= current_uiout
;
9729 gdb_assert (b
->type
== bp_hardware_breakpoint
);
9731 uiout
->message (_("Hardware assisted ranged breakpoint %d from %s to %s."),
9732 b
->number
, paddress (bl
->gdbarch
, bl
->address
),
9733 paddress (bl
->gdbarch
, bl
->address
+ bl
->length
- 1));
9736 /* Implement the "print_recreate" breakpoint_ops method for
9737 ranged breakpoints. */
9740 print_recreate_ranged_breakpoint (struct breakpoint
*b
, struct ui_file
*fp
)
9742 fprintf_unfiltered (fp
, "break-range %s, %s",
9743 event_location_to_string (b
->location
.get ()),
9744 event_location_to_string (b
->location_range_end
.get ()));
9745 print_recreate_thread (b
, fp
);
9748 /* The breakpoint_ops structure to be used in ranged breakpoints. */
9750 static struct breakpoint_ops ranged_breakpoint_ops
;
9752 /* Find the address where the end of the breakpoint range should be
9753 placed, given the SAL of the end of the range. This is so that if
9754 the user provides a line number, the end of the range is set to the
9755 last instruction of the given line. */
9758 find_breakpoint_range_end (struct symtab_and_line sal
)
9762 /* If the user provided a PC value, use it. Otherwise,
9763 find the address of the end of the given location. */
9764 if (sal
.explicit_pc
)
9771 ret
= find_line_pc_range (sal
, &start
, &end
);
9773 error (_("Could not find location of the end of the range."));
9775 /* find_line_pc_range returns the start of the next line. */
9782 /* Implement the "break-range" CLI command. */
9785 break_range_command (const char *arg
, int from_tty
)
9787 const char *arg_start
;
9788 struct linespec_result canonical_start
, canonical_end
;
9789 int bp_count
, can_use_bp
, length
;
9791 struct breakpoint
*b
;
9793 /* We don't support software ranged breakpoints. */
9794 if (target_ranged_break_num_registers () < 0)
9795 error (_("This target does not support hardware ranged breakpoints."));
9797 bp_count
= hw_breakpoint_used_count ();
9798 bp_count
+= target_ranged_break_num_registers ();
9799 can_use_bp
= target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
9802 error (_("Hardware breakpoints used exceeds limit."));
9804 arg
= skip_spaces (arg
);
9805 if (arg
== NULL
|| arg
[0] == '\0')
9806 error(_("No address range specified."));
9809 event_location_up start_location
= string_to_event_location (&arg
,
9811 parse_breakpoint_sals (start_location
.get (), &canonical_start
);
9814 error (_("Too few arguments."));
9815 else if (canonical_start
.lsals
.empty ())
9816 error (_("Could not find location of the beginning of the range."));
9818 const linespec_sals
&lsal_start
= canonical_start
.lsals
[0];
9820 if (canonical_start
.lsals
.size () > 1
9821 || lsal_start
.sals
.size () != 1)
9822 error (_("Cannot create a ranged breakpoint with multiple locations."));
9824 const symtab_and_line
&sal_start
= lsal_start
.sals
[0];
9825 std::string
addr_string_start (arg_start
, arg
- arg_start
);
9827 arg
++; /* Skip the comma. */
9828 arg
= skip_spaces (arg
);
9830 /* Parse the end location. */
9834 /* We call decode_line_full directly here instead of using
9835 parse_breakpoint_sals because we need to specify the start location's
9836 symtab and line as the default symtab and line for the end of the
9837 range. This makes it possible to have ranges like "foo.c:27, +14",
9838 where +14 means 14 lines from the start location. */
9839 event_location_up end_location
= string_to_event_location (&arg
,
9841 decode_line_full (end_location
.get (), DECODE_LINE_FUNFIRSTLINE
, NULL
,
9842 sal_start
.symtab
, sal_start
.line
,
9843 &canonical_end
, NULL
, NULL
);
9845 if (canonical_end
.lsals
.empty ())
9846 error (_("Could not find location of the end of the range."));
9848 const linespec_sals
&lsal_end
= canonical_end
.lsals
[0];
9849 if (canonical_end
.lsals
.size () > 1
9850 || lsal_end
.sals
.size () != 1)
9851 error (_("Cannot create a ranged breakpoint with multiple locations."));
9853 const symtab_and_line
&sal_end
= lsal_end
.sals
[0];
9855 end
= find_breakpoint_range_end (sal_end
);
9856 if (sal_start
.pc
> end
)
9857 error (_("Invalid address range, end precedes start."));
9859 length
= end
- sal_start
.pc
+ 1;
9861 /* Length overflowed. */
9862 error (_("Address range too large."));
9863 else if (length
== 1)
9865 /* This range is simple enough to be handled by
9866 the `hbreak' command. */
9867 hbreak_command (&addr_string_start
[0], 1);
9872 /* Now set up the breakpoint. */
9873 b
= set_raw_breakpoint (get_current_arch (), sal_start
,
9874 bp_hardware_breakpoint
, &ranged_breakpoint_ops
);
9875 set_breakpoint_count (breakpoint_count
+ 1);
9876 b
->number
= breakpoint_count
;
9877 b
->disposition
= disp_donttouch
;
9878 b
->location
= std::move (start_location
);
9879 b
->location_range_end
= std::move (end_location
);
9880 b
->loc
->length
= length
;
9883 gdb::observers::breakpoint_created
.notify (b
);
9884 update_global_location_list (UGLL_MAY_INSERT
);
9887 /* Return non-zero if EXP is verified as constant. Returned zero
9888 means EXP is variable. Also the constant detection may fail for
9889 some constant expressions and in such case still falsely return
9893 watchpoint_exp_is_const (const struct expression
*exp
)
9901 /* We are only interested in the descriptor of each element. */
9902 operator_length (exp
, i
, &oplenp
, &argsp
);
9905 switch (exp
->elts
[i
].opcode
)
9915 case BINOP_LOGICAL_AND
:
9916 case BINOP_LOGICAL_OR
:
9917 case BINOP_BITWISE_AND
:
9918 case BINOP_BITWISE_IOR
:
9919 case BINOP_BITWISE_XOR
:
9921 case BINOP_NOTEQUAL
:
9947 case OP_OBJC_NSSTRING
:
9950 case UNOP_LOGICAL_NOT
:
9951 case UNOP_COMPLEMENT
:
9956 case UNOP_CAST_TYPE
:
9957 case UNOP_REINTERPRET_CAST
:
9958 case UNOP_DYNAMIC_CAST
:
9959 /* Unary, binary and ternary operators: We have to check
9960 their operands. If they are constant, then so is the
9961 result of that operation. For instance, if A and B are
9962 determined to be constants, then so is "A + B".
9964 UNOP_IND is one exception to the rule above, because the
9965 value of *ADDR is not necessarily a constant, even when
9970 /* Check whether the associated symbol is a constant.
9972 We use SYMBOL_CLASS rather than TYPE_CONST because it's
9973 possible that a buggy compiler could mark a variable as
9974 constant even when it is not, and TYPE_CONST would return
9975 true in this case, while SYMBOL_CLASS wouldn't.
9977 We also have to check for function symbols because they
9978 are always constant. */
9980 struct symbol
*s
= exp
->elts
[i
+ 2].symbol
;
9982 if (SYMBOL_CLASS (s
) != LOC_BLOCK
9983 && SYMBOL_CLASS (s
) != LOC_CONST
9984 && SYMBOL_CLASS (s
) != LOC_CONST_BYTES
)
9989 /* The default action is to return 0 because we are using
9990 the optimistic approach here: If we don't know something,
9991 then it is not a constant. */
10000 /* Watchpoint destructor. */
10002 watchpoint::~watchpoint ()
10004 xfree (this->exp_string
);
10005 xfree (this->exp_string_reparse
);
10008 /* Implement the "re_set" breakpoint_ops method for watchpoints. */
10011 re_set_watchpoint (struct breakpoint
*b
)
10013 struct watchpoint
*w
= (struct watchpoint
*) b
;
10015 /* Watchpoint can be either on expression using entirely global
10016 variables, or it can be on local variables.
10018 Watchpoints of the first kind are never auto-deleted, and even
10019 persist across program restarts. Since they can use variables
10020 from shared libraries, we need to reparse expression as libraries
10021 are loaded and unloaded.
10023 Watchpoints on local variables can also change meaning as result
10024 of solib event. For example, if a watchpoint uses both a local
10025 and a global variables in expression, it's a local watchpoint,
10026 but unloading of a shared library will make the expression
10027 invalid. This is not a very common use case, but we still
10028 re-evaluate expression, to avoid surprises to the user.
10030 Note that for local watchpoints, we re-evaluate it only if
10031 watchpoints frame id is still valid. If it's not, it means the
10032 watchpoint is out of scope and will be deleted soon. In fact,
10033 I'm not sure we'll ever be called in this case.
10035 If a local watchpoint's frame id is still valid, then
10036 w->exp_valid_block is likewise valid, and we can safely use it.
10038 Don't do anything about disabled watchpoints, since they will be
10039 reevaluated again when enabled. */
10040 update_watchpoint (w
, 1 /* reparse */);
10043 /* Implement the "insert" breakpoint_ops method for hardware watchpoints. */
10046 insert_watchpoint (struct bp_location
*bl
)
10048 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10049 int length
= w
->exact
? 1 : bl
->length
;
10051 return target_insert_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
10052 w
->cond_exp
.get ());
10055 /* Implement the "remove" breakpoint_ops method for hardware watchpoints. */
10058 remove_watchpoint (struct bp_location
*bl
, enum remove_bp_reason reason
)
10060 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10061 int length
= w
->exact
? 1 : bl
->length
;
10063 return target_remove_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
10064 w
->cond_exp
.get ());
10068 breakpoint_hit_watchpoint (const struct bp_location
*bl
,
10069 const address_space
*aspace
, CORE_ADDR bp_addr
,
10070 const struct target_waitstatus
*ws
)
10072 struct breakpoint
*b
= bl
->owner
;
10073 struct watchpoint
*w
= (struct watchpoint
*) b
;
10075 /* Continuable hardware watchpoints are treated as non-existent if the
10076 reason we stopped wasn't a hardware watchpoint (we didn't stop on
10077 some data address). Otherwise gdb won't stop on a break instruction
10078 in the code (not from a breakpoint) when a hardware watchpoint has
10079 been defined. Also skip watchpoints which we know did not trigger
10080 (did not match the data address). */
10081 if (is_hardware_watchpoint (b
)
10082 && w
->watchpoint_triggered
== watch_triggered_no
)
10089 check_status_watchpoint (bpstat bs
)
10091 gdb_assert (is_watchpoint (bs
->breakpoint_at
));
10093 bpstat_check_watchpoint (bs
);
10096 /* Implement the "resources_needed" breakpoint_ops method for
10097 hardware watchpoints. */
10100 resources_needed_watchpoint (const struct bp_location
*bl
)
10102 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10103 int length
= w
->exact
? 1 : bl
->length
;
10105 return target_region_ok_for_hw_watchpoint (bl
->address
, length
);
10108 /* Implement the "works_in_software_mode" breakpoint_ops method for
10109 hardware watchpoints. */
10112 works_in_software_mode_watchpoint (const struct breakpoint
*b
)
10114 /* Read and access watchpoints only work with hardware support. */
10115 return b
->type
== bp_watchpoint
|| b
->type
== bp_hardware_watchpoint
;
10118 static enum print_stop_action
10119 print_it_watchpoint (bpstat bs
)
10121 struct breakpoint
*b
;
10122 enum print_stop_action result
;
10123 struct watchpoint
*w
;
10124 struct ui_out
*uiout
= current_uiout
;
10126 gdb_assert (bs
->bp_location_at
!= NULL
);
10128 b
= bs
->breakpoint_at
;
10129 w
= (struct watchpoint
*) b
;
10131 annotate_watchpoint (b
->number
);
10132 maybe_print_thread_hit_breakpoint (uiout
);
10136 gdb::optional
<ui_out_emit_tuple
> tuple_emitter
;
10139 case bp_watchpoint
:
10140 case bp_hardware_watchpoint
:
10141 if (uiout
->is_mi_like_p ())
10142 uiout
->field_string
10143 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
10145 tuple_emitter
.emplace (uiout
, "value");
10146 uiout
->text ("\nOld value = ");
10147 watchpoint_value_print (bs
->old_val
.get (), &stb
);
10148 uiout
->field_stream ("old", stb
);
10149 uiout
->text ("\nNew value = ");
10150 watchpoint_value_print (w
->val
.get (), &stb
);
10151 uiout
->field_stream ("new", stb
);
10152 uiout
->text ("\n");
10153 /* More than one watchpoint may have been triggered. */
10154 result
= PRINT_UNKNOWN
;
10157 case bp_read_watchpoint
:
10158 if (uiout
->is_mi_like_p ())
10159 uiout
->field_string
10160 ("reason", async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
10162 tuple_emitter
.emplace (uiout
, "value");
10163 uiout
->text ("\nValue = ");
10164 watchpoint_value_print (w
->val
.get (), &stb
);
10165 uiout
->field_stream ("value", stb
);
10166 uiout
->text ("\n");
10167 result
= PRINT_UNKNOWN
;
10170 case bp_access_watchpoint
:
10171 if (bs
->old_val
!= NULL
)
10173 if (uiout
->is_mi_like_p ())
10174 uiout
->field_string
10176 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
10178 tuple_emitter
.emplace (uiout
, "value");
10179 uiout
->text ("\nOld value = ");
10180 watchpoint_value_print (bs
->old_val
.get (), &stb
);
10181 uiout
->field_stream ("old", stb
);
10182 uiout
->text ("\nNew value = ");
10187 if (uiout
->is_mi_like_p ())
10188 uiout
->field_string
10190 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
10191 tuple_emitter
.emplace (uiout
, "value");
10192 uiout
->text ("\nValue = ");
10194 watchpoint_value_print (w
->val
.get (), &stb
);
10195 uiout
->field_stream ("new", stb
);
10196 uiout
->text ("\n");
10197 result
= PRINT_UNKNOWN
;
10200 result
= PRINT_UNKNOWN
;
10206 /* Implement the "print_mention" breakpoint_ops method for hardware
10210 print_mention_watchpoint (struct breakpoint
*b
)
10212 struct watchpoint
*w
= (struct watchpoint
*) b
;
10213 struct ui_out
*uiout
= current_uiout
;
10214 const char *tuple_name
;
10218 case bp_watchpoint
:
10219 uiout
->text ("Watchpoint ");
10220 tuple_name
= "wpt";
10222 case bp_hardware_watchpoint
:
10223 uiout
->text ("Hardware watchpoint ");
10224 tuple_name
= "wpt";
10226 case bp_read_watchpoint
:
10227 uiout
->text ("Hardware read watchpoint ");
10228 tuple_name
= "hw-rwpt";
10230 case bp_access_watchpoint
:
10231 uiout
->text ("Hardware access (read/write) watchpoint ");
10232 tuple_name
= "hw-awpt";
10235 internal_error (__FILE__
, __LINE__
,
10236 _("Invalid hardware watchpoint type."));
10239 ui_out_emit_tuple
tuple_emitter (uiout
, tuple_name
);
10240 uiout
->field_signed ("number", b
->number
);
10241 uiout
->text (": ");
10242 uiout
->field_string ("exp", w
->exp_string
);
10245 /* Implement the "print_recreate" breakpoint_ops method for
10249 print_recreate_watchpoint (struct breakpoint
*b
, struct ui_file
*fp
)
10251 struct watchpoint
*w
= (struct watchpoint
*) b
;
10255 case bp_watchpoint
:
10256 case bp_hardware_watchpoint
:
10257 fprintf_unfiltered (fp
, "watch");
10259 case bp_read_watchpoint
:
10260 fprintf_unfiltered (fp
, "rwatch");
10262 case bp_access_watchpoint
:
10263 fprintf_unfiltered (fp
, "awatch");
10266 internal_error (__FILE__
, __LINE__
,
10267 _("Invalid watchpoint type."));
10270 fprintf_unfiltered (fp
, " %s", w
->exp_string
);
10271 print_recreate_thread (b
, fp
);
10274 /* Implement the "explains_signal" breakpoint_ops method for
10278 explains_signal_watchpoint (struct breakpoint
*b
, enum gdb_signal sig
)
10280 /* A software watchpoint cannot cause a signal other than
10281 GDB_SIGNAL_TRAP. */
10282 if (b
->type
== bp_watchpoint
&& sig
!= GDB_SIGNAL_TRAP
)
10288 /* The breakpoint_ops structure to be used in hardware watchpoints. */
10290 static struct breakpoint_ops watchpoint_breakpoint_ops
;
10292 /* Implement the "insert" breakpoint_ops method for
10293 masked hardware watchpoints. */
10296 insert_masked_watchpoint (struct bp_location
*bl
)
10298 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10300 return target_insert_mask_watchpoint (bl
->address
, w
->hw_wp_mask
,
10301 bl
->watchpoint_type
);
10304 /* Implement the "remove" breakpoint_ops method for
10305 masked hardware watchpoints. */
10308 remove_masked_watchpoint (struct bp_location
*bl
, enum remove_bp_reason reason
)
10310 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10312 return target_remove_mask_watchpoint (bl
->address
, w
->hw_wp_mask
,
10313 bl
->watchpoint_type
);
10316 /* Implement the "resources_needed" breakpoint_ops method for
10317 masked hardware watchpoints. */
10320 resources_needed_masked_watchpoint (const struct bp_location
*bl
)
10322 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10324 return target_masked_watch_num_registers (bl
->address
, w
->hw_wp_mask
);
10327 /* Implement the "works_in_software_mode" breakpoint_ops method for
10328 masked hardware watchpoints. */
10331 works_in_software_mode_masked_watchpoint (const struct breakpoint
*b
)
10336 /* Implement the "print_it" breakpoint_ops method for
10337 masked hardware watchpoints. */
10339 static enum print_stop_action
10340 print_it_masked_watchpoint (bpstat bs
)
10342 struct breakpoint
*b
= bs
->breakpoint_at
;
10343 struct ui_out
*uiout
= current_uiout
;
10345 /* Masked watchpoints have only one location. */
10346 gdb_assert (b
->loc
&& b
->loc
->next
== NULL
);
10348 annotate_watchpoint (b
->number
);
10349 maybe_print_thread_hit_breakpoint (uiout
);
10353 case bp_hardware_watchpoint
:
10354 if (uiout
->is_mi_like_p ())
10355 uiout
->field_string
10356 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
10359 case bp_read_watchpoint
:
10360 if (uiout
->is_mi_like_p ())
10361 uiout
->field_string
10362 ("reason", async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
10365 case bp_access_watchpoint
:
10366 if (uiout
->is_mi_like_p ())
10367 uiout
->field_string
10369 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
10372 internal_error (__FILE__
, __LINE__
,
10373 _("Invalid hardware watchpoint type."));
10377 uiout
->text (_("\n\
10378 Check the underlying instruction at PC for the memory\n\
10379 address and value which triggered this watchpoint.\n"));
10380 uiout
->text ("\n");
10382 /* More than one watchpoint may have been triggered. */
10383 return PRINT_UNKNOWN
;
10386 /* Implement the "print_one_detail" breakpoint_ops method for
10387 masked hardware watchpoints. */
10390 print_one_detail_masked_watchpoint (const struct breakpoint
*b
,
10391 struct ui_out
*uiout
)
10393 struct watchpoint
*w
= (struct watchpoint
*) b
;
10395 /* Masked watchpoints have only one location. */
10396 gdb_assert (b
->loc
&& b
->loc
->next
== NULL
);
10398 uiout
->text ("\tmask ");
10399 uiout
->field_core_addr ("mask", b
->loc
->gdbarch
, w
->hw_wp_mask
);
10400 uiout
->text ("\n");
10403 /* Implement the "print_mention" breakpoint_ops method for
10404 masked hardware watchpoints. */
10407 print_mention_masked_watchpoint (struct breakpoint
*b
)
10409 struct watchpoint
*w
= (struct watchpoint
*) b
;
10410 struct ui_out
*uiout
= current_uiout
;
10411 const char *tuple_name
;
10415 case bp_hardware_watchpoint
:
10416 uiout
->text ("Masked hardware watchpoint ");
10417 tuple_name
= "wpt";
10419 case bp_read_watchpoint
:
10420 uiout
->text ("Masked hardware read watchpoint ");
10421 tuple_name
= "hw-rwpt";
10423 case bp_access_watchpoint
:
10424 uiout
->text ("Masked hardware access (read/write) watchpoint ");
10425 tuple_name
= "hw-awpt";
10428 internal_error (__FILE__
, __LINE__
,
10429 _("Invalid hardware watchpoint type."));
10432 ui_out_emit_tuple
tuple_emitter (uiout
, tuple_name
);
10433 uiout
->field_signed ("number", b
->number
);
10434 uiout
->text (": ");
10435 uiout
->field_string ("exp", w
->exp_string
);
10438 /* Implement the "print_recreate" breakpoint_ops method for
10439 masked hardware watchpoints. */
10442 print_recreate_masked_watchpoint (struct breakpoint
*b
, struct ui_file
*fp
)
10444 struct watchpoint
*w
= (struct watchpoint
*) b
;
10448 case bp_hardware_watchpoint
:
10449 fprintf_unfiltered (fp
, "watch");
10451 case bp_read_watchpoint
:
10452 fprintf_unfiltered (fp
, "rwatch");
10454 case bp_access_watchpoint
:
10455 fprintf_unfiltered (fp
, "awatch");
10458 internal_error (__FILE__
, __LINE__
,
10459 _("Invalid hardware watchpoint type."));
10462 fprintf_unfiltered (fp
, " %s mask 0x%s", w
->exp_string
,
10463 phex (w
->hw_wp_mask
, sizeof (CORE_ADDR
)));
10464 print_recreate_thread (b
, fp
);
10467 /* The breakpoint_ops structure to be used in masked hardware watchpoints. */
10469 static struct breakpoint_ops masked_watchpoint_breakpoint_ops
;
10471 /* Tell whether the given watchpoint is a masked hardware watchpoint. */
10474 is_masked_watchpoint (const struct breakpoint
*b
)
10476 return b
->ops
== &masked_watchpoint_breakpoint_ops
;
10479 /* accessflag: hw_write: watch write,
10480 hw_read: watch read,
10481 hw_access: watch access (read or write) */
10483 watch_command_1 (const char *arg
, int accessflag
, int from_tty
,
10484 int just_location
, int internal
)
10486 struct breakpoint
*scope_breakpoint
= NULL
;
10487 const struct block
*exp_valid_block
= NULL
, *cond_exp_valid_block
= NULL
;
10488 struct value
*result
;
10489 int saved_bitpos
= 0, saved_bitsize
= 0;
10490 const char *exp_start
= NULL
;
10491 const char *exp_end
= NULL
;
10492 const char *tok
, *end_tok
;
10494 const char *cond_start
= NULL
;
10495 const char *cond_end
= NULL
;
10496 enum bptype bp_type
;
10499 /* Flag to indicate whether we are going to use masks for
10500 the hardware watchpoint. */
10502 CORE_ADDR mask
= 0;
10504 /* Make sure that we actually have parameters to parse. */
10505 if (arg
!= NULL
&& arg
[0] != '\0')
10507 const char *value_start
;
10509 exp_end
= arg
+ strlen (arg
);
10511 /* Look for "parameter value" pairs at the end
10512 of the arguments string. */
10513 for (tok
= exp_end
- 1; tok
> arg
; tok
--)
10515 /* Skip whitespace at the end of the argument list. */
10516 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
10519 /* Find the beginning of the last token.
10520 This is the value of the parameter. */
10521 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
10523 value_start
= tok
+ 1;
10525 /* Skip whitespace. */
10526 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
10531 /* Find the beginning of the second to last token.
10532 This is the parameter itself. */
10533 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
10536 toklen
= end_tok
- tok
+ 1;
10538 if (toklen
== 6 && startswith (tok
, "thread"))
10540 struct thread_info
*thr
;
10541 /* At this point we've found a "thread" token, which means
10542 the user is trying to set a watchpoint that triggers
10543 only in a specific thread. */
10547 error(_("You can specify only one thread."));
10549 /* Extract the thread ID from the next token. */
10550 thr
= parse_thread_id (value_start
, &endp
);
10552 /* Check if the user provided a valid thread ID. */
10553 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
10554 invalid_thread_id_error (value_start
);
10556 thread
= thr
->global_num
;
10558 else if (toklen
== 4 && startswith (tok
, "mask"))
10560 /* We've found a "mask" token, which means the user wants to
10561 create a hardware watchpoint that is going to have the mask
10563 struct value
*mask_value
, *mark
;
10566 error(_("You can specify only one mask."));
10568 use_mask
= just_location
= 1;
10570 mark
= value_mark ();
10571 mask_value
= parse_to_comma_and_eval (&value_start
);
10572 mask
= value_as_address (mask_value
);
10573 value_free_to_mark (mark
);
10576 /* We didn't recognize what we found. We should stop here. */
10579 /* Truncate the string and get rid of the "parameter value" pair before
10580 the arguments string is parsed by the parse_exp_1 function. */
10587 /* Parse the rest of the arguments. From here on out, everything
10588 is in terms of a newly allocated string instead of the original
10590 std::string
expression (arg
, exp_end
- arg
);
10591 exp_start
= arg
= expression
.c_str ();
10592 innermost_block_tracker tracker
;
10593 expression_up exp
= parse_exp_1 (&arg
, 0, 0, 0, &tracker
);
10595 /* Remove trailing whitespace from the expression before saving it.
10596 This makes the eventual display of the expression string a bit
10598 while (exp_end
> exp_start
&& (exp_end
[-1] == ' ' || exp_end
[-1] == '\t'))
10601 /* Checking if the expression is not constant. */
10602 if (watchpoint_exp_is_const (exp
.get ()))
10606 len
= exp_end
- exp_start
;
10607 while (len
> 0 && isspace (exp_start
[len
- 1]))
10609 error (_("Cannot watch constant value `%.*s'."), len
, exp_start
);
10612 exp_valid_block
= tracker
.block ();
10613 struct value
*mark
= value_mark ();
10614 struct value
*val_as_value
= nullptr;
10615 fetch_subexp_value (exp
.get (), &pc
, &val_as_value
, &result
, NULL
,
10618 if (val_as_value
!= NULL
&& just_location
)
10620 saved_bitpos
= value_bitpos (val_as_value
);
10621 saved_bitsize
= value_bitsize (val_as_value
);
10629 exp_valid_block
= NULL
;
10630 val
= release_value (value_addr (result
));
10631 value_free_to_mark (mark
);
10635 ret
= target_masked_watch_num_registers (value_as_address (val
.get ()),
10638 error (_("This target does not support masked watchpoints."));
10639 else if (ret
== -2)
10640 error (_("Invalid mask or memory region."));
10643 else if (val_as_value
!= NULL
)
10644 val
= release_value (val_as_value
);
10646 tok
= skip_spaces (arg
);
10647 end_tok
= skip_to_space (tok
);
10649 toklen
= end_tok
- tok
;
10650 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
10652 tok
= cond_start
= end_tok
+ 1;
10653 innermost_block_tracker if_tracker
;
10654 parse_exp_1 (&tok
, 0, 0, 0, &if_tracker
);
10656 /* The watchpoint expression may not be local, but the condition
10657 may still be. E.g.: `watch global if local > 0'. */
10658 cond_exp_valid_block
= if_tracker
.block ();
10663 error (_("Junk at end of command."));
10665 frame_info
*wp_frame
= block_innermost_frame (exp_valid_block
);
10667 /* Save this because create_internal_breakpoint below invalidates
10669 frame_id watchpoint_frame
= get_frame_id (wp_frame
);
10671 /* If the expression is "local", then set up a "watchpoint scope"
10672 breakpoint at the point where we've left the scope of the watchpoint
10673 expression. Create the scope breakpoint before the watchpoint, so
10674 that we will encounter it first in bpstat_stop_status. */
10675 if (exp_valid_block
!= NULL
&& wp_frame
!= NULL
)
10677 frame_id caller_frame_id
= frame_unwind_caller_id (wp_frame
);
10679 if (frame_id_p (caller_frame_id
))
10681 gdbarch
*caller_arch
= frame_unwind_caller_arch (wp_frame
);
10682 CORE_ADDR caller_pc
= frame_unwind_caller_pc (wp_frame
);
10685 = create_internal_breakpoint (caller_arch
, caller_pc
,
10686 bp_watchpoint_scope
,
10687 &momentary_breakpoint_ops
);
10689 /* create_internal_breakpoint could invalidate WP_FRAME. */
10692 scope_breakpoint
->enable_state
= bp_enabled
;
10694 /* Automatically delete the breakpoint when it hits. */
10695 scope_breakpoint
->disposition
= disp_del
;
10697 /* Only break in the proper frame (help with recursion). */
10698 scope_breakpoint
->frame_id
= caller_frame_id
;
10700 /* Set the address at which we will stop. */
10701 scope_breakpoint
->loc
->gdbarch
= caller_arch
;
10702 scope_breakpoint
->loc
->requested_address
= caller_pc
;
10703 scope_breakpoint
->loc
->address
10704 = adjust_breakpoint_address (scope_breakpoint
->loc
->gdbarch
,
10705 scope_breakpoint
->loc
->requested_address
,
10706 scope_breakpoint
->type
);
10710 /* Now set up the breakpoint. We create all watchpoints as hardware
10711 watchpoints here even if hardware watchpoints are turned off, a call
10712 to update_watchpoint later in this function will cause the type to
10713 drop back to bp_watchpoint (software watchpoint) if required. */
10715 if (accessflag
== hw_read
)
10716 bp_type
= bp_read_watchpoint
;
10717 else if (accessflag
== hw_access
)
10718 bp_type
= bp_access_watchpoint
;
10720 bp_type
= bp_hardware_watchpoint
;
10722 std::unique_ptr
<watchpoint
> w (new watchpoint ());
10725 init_raw_breakpoint_without_location (w
.get (), NULL
, bp_type
,
10726 &masked_watchpoint_breakpoint_ops
);
10728 init_raw_breakpoint_without_location (w
.get (), NULL
, bp_type
,
10729 &watchpoint_breakpoint_ops
);
10730 w
->thread
= thread
;
10731 w
->disposition
= disp_donttouch
;
10732 w
->pspace
= current_program_space
;
10733 w
->exp
= std::move (exp
);
10734 w
->exp_valid_block
= exp_valid_block
;
10735 w
->cond_exp_valid_block
= cond_exp_valid_block
;
10738 struct type
*t
= value_type (val
.get ());
10739 CORE_ADDR addr
= value_as_address (val
.get ());
10741 w
->exp_string_reparse
10742 = current_language
->watch_location_expression (t
, addr
).release ();
10744 w
->exp_string
= xstrprintf ("-location %.*s",
10745 (int) (exp_end
- exp_start
), exp_start
);
10748 w
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
10752 w
->hw_wp_mask
= mask
;
10757 w
->val_bitpos
= saved_bitpos
;
10758 w
->val_bitsize
= saved_bitsize
;
10759 w
->val_valid
= true;
10763 w
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
10765 w
->cond_string
= 0;
10767 if (frame_id_p (watchpoint_frame
))
10769 w
->watchpoint_frame
= watchpoint_frame
;
10770 w
->watchpoint_thread
= inferior_ptid
;
10774 w
->watchpoint_frame
= null_frame_id
;
10775 w
->watchpoint_thread
= null_ptid
;
10778 if (scope_breakpoint
!= NULL
)
10780 /* The scope breakpoint is related to the watchpoint. We will
10781 need to act on them together. */
10782 w
->related_breakpoint
= scope_breakpoint
;
10783 scope_breakpoint
->related_breakpoint
= w
.get ();
10786 if (!just_location
)
10787 value_free_to_mark (mark
);
10789 /* Finally update the new watchpoint. This creates the locations
10790 that should be inserted. */
10791 update_watchpoint (w
.get (), 1);
10793 install_breakpoint (internal
, std::move (w
), 1);
10796 /* Return count of debug registers needed to watch the given expression.
10797 If the watchpoint cannot be handled in hardware return zero. */
10800 can_use_hardware_watchpoint (const std::vector
<value_ref_ptr
> &vals
)
10802 int found_memory_cnt
= 0;
10804 /* Did the user specifically forbid us to use hardware watchpoints? */
10805 if (!can_use_hw_watchpoints
)
10808 gdb_assert (!vals
.empty ());
10809 struct value
*head
= vals
[0].get ();
10811 /* Make sure that the value of the expression depends only upon
10812 memory contents, and values computed from them within GDB. If we
10813 find any register references or function calls, we can't use a
10814 hardware watchpoint.
10816 The idea here is that evaluating an expression generates a series
10817 of values, one holding the value of every subexpression. (The
10818 expression a*b+c has five subexpressions: a, b, a*b, c, and
10819 a*b+c.) GDB's values hold almost enough information to establish
10820 the criteria given above --- they identify memory lvalues,
10821 register lvalues, computed values, etcetera. So we can evaluate
10822 the expression, and then scan the chain of values that leaves
10823 behind to decide whether we can detect any possible change to the
10824 expression's final value using only hardware watchpoints.
10826 However, I don't think that the values returned by inferior
10827 function calls are special in any way. So this function may not
10828 notice that an expression involving an inferior function call
10829 can't be watched with hardware watchpoints. FIXME. */
10830 for (const value_ref_ptr
&iter
: vals
)
10832 struct value
*v
= iter
.get ();
10834 if (VALUE_LVAL (v
) == lval_memory
)
10836 if (v
!= head
&& value_lazy (v
))
10837 /* A lazy memory lvalue in the chain is one that GDB never
10838 needed to fetch; we either just used its address (e.g.,
10839 `a' in `a.b') or we never needed it at all (e.g., `a'
10840 in `a,b'). This doesn't apply to HEAD; if that is
10841 lazy then it was not readable, but watch it anyway. */
10845 /* Ahh, memory we actually used! Check if we can cover
10846 it with hardware watchpoints. */
10847 struct type
*vtype
= check_typedef (value_type (v
));
10849 /* We only watch structs and arrays if user asked for it
10850 explicitly, never if they just happen to appear in a
10851 middle of some value chain. */
10853 || (vtype
->code () != TYPE_CODE_STRUCT
10854 && vtype
->code () != TYPE_CODE_ARRAY
))
10856 CORE_ADDR vaddr
= value_address (v
);
10860 len
= (target_exact_watchpoints
10861 && is_scalar_type_recursive (vtype
))?
10862 1 : TYPE_LENGTH (value_type (v
));
10864 num_regs
= target_region_ok_for_hw_watchpoint (vaddr
, len
);
10868 found_memory_cnt
+= num_regs
;
10872 else if (VALUE_LVAL (v
) != not_lval
10873 && deprecated_value_modifiable (v
) == 0)
10874 return 0; /* These are values from the history (e.g., $1). */
10875 else if (VALUE_LVAL (v
) == lval_register
)
10876 return 0; /* Cannot watch a register with a HW watchpoint. */
10879 /* The expression itself looks suitable for using a hardware
10880 watchpoint, but give the target machine a chance to reject it. */
10881 return found_memory_cnt
;
10885 watch_command_wrapper (const char *arg
, int from_tty
, int internal
)
10887 watch_command_1 (arg
, hw_write
, from_tty
, 0, internal
);
10890 /* A helper function that looks for the "-location" argument and then
10891 calls watch_command_1. */
10894 watch_maybe_just_location (const char *arg
, int accessflag
, int from_tty
)
10896 int just_location
= 0;
10899 && (check_for_argument (&arg
, "-location", sizeof ("-location") - 1)
10900 || check_for_argument (&arg
, "-l", sizeof ("-l") - 1)))
10903 watch_command_1 (arg
, accessflag
, from_tty
, just_location
, 0);
10907 watch_command (const char *arg
, int from_tty
)
10909 watch_maybe_just_location (arg
, hw_write
, from_tty
);
10913 rwatch_command_wrapper (const char *arg
, int from_tty
, int internal
)
10915 watch_command_1 (arg
, hw_read
, from_tty
, 0, internal
);
10919 rwatch_command (const char *arg
, int from_tty
)
10921 watch_maybe_just_location (arg
, hw_read
, from_tty
);
10925 awatch_command_wrapper (const char *arg
, int from_tty
, int internal
)
10927 watch_command_1 (arg
, hw_access
, from_tty
, 0, internal
);
10931 awatch_command (const char *arg
, int from_tty
)
10933 watch_maybe_just_location (arg
, hw_access
, from_tty
);
10937 /* Data for the FSM that manages the until(location)/advance commands
10938 in infcmd.c. Here because it uses the mechanisms of
10941 struct until_break_fsm
: public thread_fsm
10943 /* The thread that was current when the command was executed. */
10946 /* The breakpoint set at the destination location. */
10947 breakpoint_up location_breakpoint
;
10949 /* Breakpoint set at the return address in the caller frame. May be
10951 breakpoint_up caller_breakpoint
;
10953 until_break_fsm (struct interp
*cmd_interp
, int thread
,
10954 breakpoint_up
&&location_breakpoint
,
10955 breakpoint_up
&&caller_breakpoint
)
10956 : thread_fsm (cmd_interp
),
10958 location_breakpoint (std::move (location_breakpoint
)),
10959 caller_breakpoint (std::move (caller_breakpoint
))
10963 void clean_up (struct thread_info
*thread
) override
;
10964 bool should_stop (struct thread_info
*thread
) override
;
10965 enum async_reply_reason
do_async_reply_reason () override
;
10968 /* Implementation of the 'should_stop' FSM method for the
10969 until(location)/advance commands. */
10972 until_break_fsm::should_stop (struct thread_info
*tp
)
10974 if (bpstat_find_breakpoint (tp
->control
.stop_bpstat
,
10975 location_breakpoint
.get ()) != NULL
10976 || (caller_breakpoint
!= NULL
10977 && bpstat_find_breakpoint (tp
->control
.stop_bpstat
,
10978 caller_breakpoint
.get ()) != NULL
))
10984 /* Implementation of the 'clean_up' FSM method for the
10985 until(location)/advance commands. */
10988 until_break_fsm::clean_up (struct thread_info
*)
10990 /* Clean up our temporary breakpoints. */
10991 location_breakpoint
.reset ();
10992 caller_breakpoint
.reset ();
10993 delete_longjmp_breakpoint (thread
);
10996 /* Implementation of the 'async_reply_reason' FSM method for the
10997 until(location)/advance commands. */
10999 enum async_reply_reason
11000 until_break_fsm::do_async_reply_reason ()
11002 return EXEC_ASYNC_LOCATION_REACHED
;
11006 until_break_command (const char *arg
, int from_tty
, int anywhere
)
11008 struct frame_info
*frame
;
11009 struct gdbarch
*frame_gdbarch
;
11010 struct frame_id stack_frame_id
;
11011 struct frame_id caller_frame_id
;
11013 struct thread_info
*tp
;
11015 clear_proceed_status (0);
11017 /* Set a breakpoint where the user wants it and at return from
11020 event_location_up location
= string_to_event_location (&arg
, current_language
);
11022 std::vector
<symtab_and_line
> sals
11023 = (last_displayed_sal_is_valid ()
11024 ? decode_line_1 (location
.get (), DECODE_LINE_FUNFIRSTLINE
, NULL
,
11025 get_last_displayed_symtab (),
11026 get_last_displayed_line ())
11027 : decode_line_1 (location
.get (), DECODE_LINE_FUNFIRSTLINE
,
11030 if (sals
.size () != 1)
11031 error (_("Couldn't get information on specified line."));
11033 symtab_and_line
&sal
= sals
[0];
11036 error (_("Junk at end of arguments."));
11038 resolve_sal_pc (&sal
);
11040 tp
= inferior_thread ();
11041 thread
= tp
->global_num
;
11043 /* Note linespec handling above invalidates the frame chain.
11044 Installing a breakpoint also invalidates the frame chain (as it
11045 may need to switch threads), so do any frame handling before
11048 frame
= get_selected_frame (NULL
);
11049 frame_gdbarch
= get_frame_arch (frame
);
11050 stack_frame_id
= get_stack_frame_id (frame
);
11051 caller_frame_id
= frame_unwind_caller_id (frame
);
11053 /* Keep within the current frame, or in frames called by the current
11056 breakpoint_up caller_breakpoint
;
11058 gdb::optional
<delete_longjmp_breakpoint_cleanup
> lj_deleter
;
11060 if (frame_id_p (caller_frame_id
))
11062 struct symtab_and_line sal2
;
11063 struct gdbarch
*caller_gdbarch
;
11065 sal2
= find_pc_line (frame_unwind_caller_pc (frame
), 0);
11066 sal2
.pc
= frame_unwind_caller_pc (frame
);
11067 caller_gdbarch
= frame_unwind_caller_arch (frame
);
11068 caller_breakpoint
= set_momentary_breakpoint (caller_gdbarch
,
11073 set_longjmp_breakpoint (tp
, caller_frame_id
);
11074 lj_deleter
.emplace (thread
);
11077 /* set_momentary_breakpoint could invalidate FRAME. */
11080 breakpoint_up location_breakpoint
;
11082 /* If the user told us to continue until a specified location,
11083 we don't specify a frame at which we need to stop. */
11084 location_breakpoint
= set_momentary_breakpoint (frame_gdbarch
, sal
,
11085 null_frame_id
, bp_until
);
11087 /* Otherwise, specify the selected frame, because we want to stop
11088 only at the very same frame. */
11089 location_breakpoint
= set_momentary_breakpoint (frame_gdbarch
, sal
,
11090 stack_frame_id
, bp_until
);
11092 tp
->thread_fsm
= new until_break_fsm (command_interp (), tp
->global_num
,
11093 std::move (location_breakpoint
),
11094 std::move (caller_breakpoint
));
11097 lj_deleter
->release ();
11099 proceed (-1, GDB_SIGNAL_DEFAULT
);
11102 /* This function attempts to parse an optional "if <cond>" clause
11103 from the arg string. If one is not found, it returns NULL.
11105 Else, it returns a pointer to the condition string. (It does not
11106 attempt to evaluate the string against a particular block.) And,
11107 it updates arg to point to the first character following the parsed
11108 if clause in the arg string. */
11111 ep_parse_optional_if_clause (const char **arg
)
11113 const char *cond_string
;
11115 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
11118 /* Skip the "if" keyword. */
11121 /* Skip any extra leading whitespace, and record the start of the
11122 condition string. */
11123 *arg
= skip_spaces (*arg
);
11124 cond_string
= *arg
;
11126 /* Assume that the condition occupies the remainder of the arg
11128 (*arg
) += strlen (cond_string
);
11130 return cond_string
;
11133 /* Commands to deal with catching events, such as signals, exceptions,
11134 process start/exit, etc. */
11138 catch_fork_temporary
, catch_vfork_temporary
,
11139 catch_fork_permanent
, catch_vfork_permanent
11144 catch_fork_command_1 (const char *arg
, int from_tty
,
11145 struct cmd_list_element
*command
)
11147 struct gdbarch
*gdbarch
= get_current_arch ();
11148 const char *cond_string
= NULL
;
11149 catch_fork_kind fork_kind
;
11152 fork_kind
= (catch_fork_kind
) (uintptr_t) get_cmd_context (command
);
11153 tempflag
= (fork_kind
== catch_fork_temporary
11154 || fork_kind
== catch_vfork_temporary
);
11158 arg
= skip_spaces (arg
);
11160 /* The allowed syntax is:
11162 catch [v]fork if <cond>
11164 First, check if there's an if clause. */
11165 cond_string
= ep_parse_optional_if_clause (&arg
);
11167 if ((*arg
!= '\0') && !isspace (*arg
))
11168 error (_("Junk at end of arguments."));
11170 /* If this target supports it, create a fork or vfork catchpoint
11171 and enable reporting of such events. */
11174 case catch_fork_temporary
:
11175 case catch_fork_permanent
:
11176 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
11177 &catch_fork_breakpoint_ops
);
11179 case catch_vfork_temporary
:
11180 case catch_vfork_permanent
:
11181 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
11182 &catch_vfork_breakpoint_ops
);
11185 error (_("unsupported or unknown fork kind; cannot catch it"));
11191 catch_exec_command_1 (const char *arg
, int from_tty
,
11192 struct cmd_list_element
*command
)
11194 struct gdbarch
*gdbarch
= get_current_arch ();
11196 const char *cond_string
= NULL
;
11198 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
11202 arg
= skip_spaces (arg
);
11204 /* The allowed syntax is:
11206 catch exec if <cond>
11208 First, check if there's an if clause. */
11209 cond_string
= ep_parse_optional_if_clause (&arg
);
11211 if ((*arg
!= '\0') && !isspace (*arg
))
11212 error (_("Junk at end of arguments."));
11214 std::unique_ptr
<exec_catchpoint
> c (new exec_catchpoint ());
11215 init_catchpoint (c
.get (), gdbarch
, tempflag
, cond_string
,
11216 &catch_exec_breakpoint_ops
);
11217 c
->exec_pathname
= NULL
;
11219 install_breakpoint (0, std::move (c
), 1);
11223 init_ada_exception_breakpoint (struct breakpoint
*b
,
11224 struct gdbarch
*gdbarch
,
11225 struct symtab_and_line sal
,
11226 const char *addr_string
,
11227 const struct breakpoint_ops
*ops
,
11234 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
11236 loc_gdbarch
= gdbarch
;
11238 describe_other_breakpoints (loc_gdbarch
,
11239 sal
.pspace
, sal
.pc
, sal
.section
, -1);
11240 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
11241 version for exception catchpoints, because two catchpoints
11242 used for different exception names will use the same address.
11243 In this case, a "breakpoint ... also set at..." warning is
11244 unproductive. Besides, the warning phrasing is also a bit
11245 inappropriate, we should use the word catchpoint, and tell
11246 the user what type of catchpoint it is. The above is good
11247 enough for now, though. */
11250 init_raw_breakpoint (b
, gdbarch
, sal
, bp_catchpoint
, ops
);
11252 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
11253 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
11254 b
->location
= string_to_event_location (&addr_string
,
11255 language_def (language_ada
));
11256 b
->language
= language_ada
;
11261 /* Compare two breakpoints and return a strcmp-like result. */
11264 compare_breakpoints (const breakpoint
*a
, const breakpoint
*b
)
11266 uintptr_t ua
= (uintptr_t) a
;
11267 uintptr_t ub
= (uintptr_t) b
;
11269 if (a
->number
< b
->number
)
11271 else if (a
->number
> b
->number
)
11274 /* Now sort by address, in case we see, e..g, two breakpoints with
11278 return ua
> ub
? 1 : 0;
11281 /* Delete breakpoints by address or line. */
11284 clear_command (const char *arg
, int from_tty
)
11286 struct breakpoint
*b
;
11289 std::vector
<symtab_and_line
> decoded_sals
;
11290 symtab_and_line last_sal
;
11291 gdb::array_view
<symtab_and_line
> sals
;
11295 = decode_line_with_current_source (arg
,
11296 (DECODE_LINE_FUNFIRSTLINE
11297 | DECODE_LINE_LIST_MODE
));
11299 sals
= decoded_sals
;
11303 /* Set sal's line, symtab, pc, and pspace to the values
11304 corresponding to the last call to print_frame_info. If the
11305 codepoint is not valid, this will set all the fields to 0. */
11306 last_sal
= get_last_displayed_sal ();
11307 if (last_sal
.symtab
== 0)
11308 error (_("No source file specified."));
11314 /* We don't call resolve_sal_pc here. That's not as bad as it
11315 seems, because all existing breakpoints typically have both
11316 file/line and pc set. So, if clear is given file/line, we can
11317 match this to existing breakpoint without obtaining pc at all.
11319 We only support clearing given the address explicitly
11320 present in breakpoint table. Say, we've set breakpoint
11321 at file:line. There were several PC values for that file:line,
11322 due to optimization, all in one block.
11324 We've picked one PC value. If "clear" is issued with another
11325 PC corresponding to the same file:line, the breakpoint won't
11326 be cleared. We probably can still clear the breakpoint, but
11327 since the other PC value is never presented to user, user
11328 can only find it by guessing, and it does not seem important
11329 to support that. */
11331 /* For each line spec given, delete bps which correspond to it. Do
11332 it in two passes, solely to preserve the current behavior that
11333 from_tty is forced true if we delete more than one
11336 std::vector
<struct breakpoint
*> found
;
11337 for (const auto &sal
: sals
)
11339 const char *sal_fullname
;
11341 /* If exact pc given, clear bpts at that pc.
11342 If line given (pc == 0), clear all bpts on specified line.
11343 If defaulting, clear all bpts on default line
11346 defaulting sal.pc != 0 tests to do
11351 1 0 <can't happen> */
11353 sal_fullname
= (sal
.symtab
== NULL
11354 ? NULL
: symtab_to_fullname (sal
.symtab
));
11356 /* Find all matching breakpoints and add them to 'found'. */
11357 ALL_BREAKPOINTS (b
)
11360 /* Are we going to delete b? */
11361 if (b
->type
!= bp_none
&& !is_watchpoint (b
))
11363 struct bp_location
*loc
= b
->loc
;
11364 for (; loc
; loc
= loc
->next
)
11366 /* If the user specified file:line, don't allow a PC
11367 match. This matches historical gdb behavior. */
11368 int pc_match
= (!sal
.explicit_line
11370 && (loc
->pspace
== sal
.pspace
)
11371 && (loc
->address
== sal
.pc
)
11372 && (!section_is_overlay (loc
->section
)
11373 || loc
->section
== sal
.section
));
11374 int line_match
= 0;
11376 if ((default_match
|| sal
.explicit_line
)
11377 && loc
->symtab
!= NULL
11378 && sal_fullname
!= NULL
11379 && sal
.pspace
== loc
->pspace
11380 && loc
->line_number
== sal
.line
11381 && filename_cmp (symtab_to_fullname (loc
->symtab
),
11382 sal_fullname
) == 0)
11385 if (pc_match
|| line_match
)
11394 found
.push_back (b
);
11398 /* Now go thru the 'found' chain and delete them. */
11399 if (found
.empty ())
11402 error (_("No breakpoint at %s."), arg
);
11404 error (_("No breakpoint at this line."));
11407 /* Remove duplicates from the vec. */
11408 std::sort (found
.begin (), found
.end (),
11409 [] (const breakpoint
*bp_a
, const breakpoint
*bp_b
)
11411 return compare_breakpoints (bp_a
, bp_b
) < 0;
11413 found
.erase (std::unique (found
.begin (), found
.end (),
11414 [] (const breakpoint
*bp_a
, const breakpoint
*bp_b
)
11416 return compare_breakpoints (bp_a
, bp_b
) == 0;
11420 if (found
.size () > 1)
11421 from_tty
= 1; /* Always report if deleted more than one. */
11424 if (found
.size () == 1)
11425 printf_unfiltered (_("Deleted breakpoint "));
11427 printf_unfiltered (_("Deleted breakpoints "));
11430 for (breakpoint
*iter
: found
)
11433 printf_unfiltered ("%d ", iter
->number
);
11434 delete_breakpoint (iter
);
11437 putchar_unfiltered ('\n');
11440 /* Delete breakpoint in BS if they are `delete' breakpoints and
11441 all breakpoints that are marked for deletion, whether hit or not.
11442 This is called after any breakpoint is hit, or after errors. */
11445 breakpoint_auto_delete (bpstat bs
)
11447 struct breakpoint
*b
, *b_tmp
;
11449 for (; bs
; bs
= bs
->next
)
11450 if (bs
->breakpoint_at
11451 && bs
->breakpoint_at
->disposition
== disp_del
11453 delete_breakpoint (bs
->breakpoint_at
);
11455 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
11457 if (b
->disposition
== disp_del_at_next_stop
)
11458 delete_breakpoint (b
);
11462 /* A comparison function for bp_location AP and BP being interfaced to
11463 std::sort. Sort elements primarily by their ADDRESS (no matter what
11464 bl_address_is_meaningful says), secondarily by ordering first
11465 permanent elements and terciarily just ensuring the array is sorted
11466 stable way despite std::sort being an unstable algorithm. */
11469 bp_location_is_less_than (const bp_location
*a
, const bp_location
*b
)
11471 if (a
->address
!= b
->address
)
11472 return a
->address
< b
->address
;
11474 /* Sort locations at the same address by their pspace number, keeping
11475 locations of the same inferior (in a multi-inferior environment)
11478 if (a
->pspace
->num
!= b
->pspace
->num
)
11479 return a
->pspace
->num
< b
->pspace
->num
;
11481 /* Sort permanent breakpoints first. */
11482 if (a
->permanent
!= b
->permanent
)
11483 return a
->permanent
> b
->permanent
;
11485 /* Sort by type in order to make duplicate determination easier.
11486 See update_global_location_list. This is kept in sync with
11487 breakpoint_locations_match. */
11488 if (a
->loc_type
< b
->loc_type
)
11491 /* Likewise, for range-breakpoints, sort by length. */
11492 if (a
->loc_type
== bp_loc_hardware_breakpoint
11493 && b
->loc_type
== bp_loc_hardware_breakpoint
11494 && a
->length
< b
->length
)
11497 /* Make the internal GDB representation stable across GDB runs
11498 where A and B memory inside GDB can differ. Breakpoint locations of
11499 the same type at the same address can be sorted in arbitrary order. */
11501 if (a
->owner
->number
!= b
->owner
->number
)
11502 return a
->owner
->number
< b
->owner
->number
;
11507 /* Set bp_locations_placed_address_before_address_max and
11508 bp_locations_shadow_len_after_address_max according to the current
11509 content of the bp_locations array. */
11512 bp_locations_target_extensions_update (void)
11514 struct bp_location
*bl
, **blp_tmp
;
11516 bp_locations_placed_address_before_address_max
= 0;
11517 bp_locations_shadow_len_after_address_max
= 0;
11519 ALL_BP_LOCATIONS (bl
, blp_tmp
)
11521 CORE_ADDR start
, end
, addr
;
11523 if (!bp_location_has_shadow (bl
))
11526 start
= bl
->target_info
.placed_address
;
11527 end
= start
+ bl
->target_info
.shadow_len
;
11529 gdb_assert (bl
->address
>= start
);
11530 addr
= bl
->address
- start
;
11531 if (addr
> bp_locations_placed_address_before_address_max
)
11532 bp_locations_placed_address_before_address_max
= addr
;
11534 /* Zero SHADOW_LEN would not pass bp_location_has_shadow. */
11536 gdb_assert (bl
->address
< end
);
11537 addr
= end
- bl
->address
;
11538 if (addr
> bp_locations_shadow_len_after_address_max
)
11539 bp_locations_shadow_len_after_address_max
= addr
;
11543 /* Download tracepoint locations if they haven't been. */
11546 download_tracepoint_locations (void)
11548 struct breakpoint
*b
;
11549 enum tribool can_download_tracepoint
= TRIBOOL_UNKNOWN
;
11551 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
11553 ALL_TRACEPOINTS (b
)
11555 struct bp_location
*bl
;
11556 struct tracepoint
*t
;
11557 int bp_location_downloaded
= 0;
11559 if ((b
->type
== bp_fast_tracepoint
11560 ? !may_insert_fast_tracepoints
11561 : !may_insert_tracepoints
))
11564 if (can_download_tracepoint
== TRIBOOL_UNKNOWN
)
11566 if (target_can_download_tracepoint ())
11567 can_download_tracepoint
= TRIBOOL_TRUE
;
11569 can_download_tracepoint
= TRIBOOL_FALSE
;
11572 if (can_download_tracepoint
== TRIBOOL_FALSE
)
11575 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
11577 /* In tracepoint, locations are _never_ duplicated, so
11578 should_be_inserted is equivalent to
11579 unduplicated_should_be_inserted. */
11580 if (!should_be_inserted (bl
) || bl
->inserted
)
11583 switch_to_program_space_and_thread (bl
->pspace
);
11585 target_download_tracepoint (bl
);
11588 bp_location_downloaded
= 1;
11590 t
= (struct tracepoint
*) b
;
11591 t
->number_on_target
= b
->number
;
11592 if (bp_location_downloaded
)
11593 gdb::observers::breakpoint_modified
.notify (b
);
11597 /* Swap the insertion/duplication state between two locations. */
11600 swap_insertion (struct bp_location
*left
, struct bp_location
*right
)
11602 const int left_inserted
= left
->inserted
;
11603 const int left_duplicate
= left
->duplicate
;
11604 const int left_needs_update
= left
->needs_update
;
11605 const struct bp_target_info left_target_info
= left
->target_info
;
11607 /* Locations of tracepoints can never be duplicated. */
11608 if (is_tracepoint (left
->owner
))
11609 gdb_assert (!left
->duplicate
);
11610 if (is_tracepoint (right
->owner
))
11611 gdb_assert (!right
->duplicate
);
11613 left
->inserted
= right
->inserted
;
11614 left
->duplicate
= right
->duplicate
;
11615 left
->needs_update
= right
->needs_update
;
11616 left
->target_info
= right
->target_info
;
11617 right
->inserted
= left_inserted
;
11618 right
->duplicate
= left_duplicate
;
11619 right
->needs_update
= left_needs_update
;
11620 right
->target_info
= left_target_info
;
11623 /* Force the re-insertion of the locations at ADDRESS. This is called
11624 once a new/deleted/modified duplicate location is found and we are evaluating
11625 conditions on the target's side. Such conditions need to be updated on
11629 force_breakpoint_reinsertion (struct bp_location
*bl
)
11631 struct bp_location
**locp
= NULL
, **loc2p
;
11632 struct bp_location
*loc
;
11633 CORE_ADDR address
= 0;
11636 address
= bl
->address
;
11637 pspace_num
= bl
->pspace
->num
;
11639 /* This is only meaningful if the target is
11640 evaluating conditions and if the user has
11641 opted for condition evaluation on the target's
11643 if (gdb_evaluates_breakpoint_condition_p ()
11644 || !target_supports_evaluation_of_breakpoint_conditions ())
11647 /* Flag all breakpoint locations with this address and
11648 the same program space as the location
11649 as "its condition has changed". We need to
11650 update the conditions on the target's side. */
11651 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, address
)
11655 if (!is_breakpoint (loc
->owner
)
11656 || pspace_num
!= loc
->pspace
->num
)
11659 /* Flag the location appropriately. We use a different state to
11660 let everyone know that we already updated the set of locations
11661 with addr bl->address and program space bl->pspace. This is so
11662 we don't have to keep calling these functions just to mark locations
11663 that have already been marked. */
11664 loc
->condition_changed
= condition_updated
;
11666 /* Free the agent expression bytecode as well. We will compute
11668 loc
->cond_bytecode
.reset ();
11672 /* Called whether new breakpoints are created, or existing breakpoints
11673 deleted, to update the global location list and recompute which
11674 locations are duplicate of which.
11676 The INSERT_MODE flag determines whether locations may not, may, or
11677 shall be inserted now. See 'enum ugll_insert_mode' for more
11681 update_global_location_list (enum ugll_insert_mode insert_mode
)
11683 struct breakpoint
*b
;
11684 struct bp_location
**locp
, *loc
;
11685 /* Last breakpoint location address that was marked for update. */
11686 CORE_ADDR last_addr
= 0;
11687 /* Last breakpoint location program space that was marked for update. */
11688 int last_pspace_num
= -1;
11690 /* Used in the duplicates detection below. When iterating over all
11691 bp_locations, points to the first bp_location of a given address.
11692 Breakpoints and watchpoints of different types are never
11693 duplicates of each other. Keep one pointer for each type of
11694 breakpoint/watchpoint, so we only need to loop over all locations
11696 struct bp_location
*bp_loc_first
; /* breakpoint */
11697 struct bp_location
*wp_loc_first
; /* hardware watchpoint */
11698 struct bp_location
*awp_loc_first
; /* access watchpoint */
11699 struct bp_location
*rwp_loc_first
; /* read watchpoint */
11701 /* Saved former bp_locations array which we compare against the newly
11702 built bp_locations from the current state of ALL_BREAKPOINTS. */
11703 struct bp_location
**old_locp
;
11704 unsigned old_locations_count
;
11705 gdb::unique_xmalloc_ptr
<struct bp_location
*> old_locations (bp_locations
);
11707 old_locations_count
= bp_locations_count
;
11708 bp_locations
= NULL
;
11709 bp_locations_count
= 0;
11711 ALL_BREAKPOINTS (b
)
11712 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
11713 bp_locations_count
++;
11715 bp_locations
= XNEWVEC (struct bp_location
*, bp_locations_count
);
11716 locp
= bp_locations
;
11717 ALL_BREAKPOINTS (b
)
11718 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
11721 /* See if we need to "upgrade" a software breakpoint to a hardware
11722 breakpoint. Do this before deciding whether locations are
11723 duplicates. Also do this before sorting because sorting order
11724 depends on location type. */
11725 for (locp
= bp_locations
;
11726 locp
< bp_locations
+ bp_locations_count
;
11730 if (!loc
->inserted
&& should_be_inserted (loc
))
11731 handle_automatic_hardware_breakpoints (loc
);
11734 std::sort (bp_locations
, bp_locations
+ bp_locations_count
,
11735 bp_location_is_less_than
);
11737 bp_locations_target_extensions_update ();
11739 /* Identify bp_location instances that are no longer present in the
11740 new list, and therefore should be freed. Note that it's not
11741 necessary that those locations should be removed from inferior --
11742 if there's another location at the same address (previously
11743 marked as duplicate), we don't need to remove/insert the
11746 LOCP is kept in sync with OLD_LOCP, each pointing to the current
11747 and former bp_location array state respectively. */
11749 locp
= bp_locations
;
11750 for (old_locp
= old_locations
.get ();
11751 old_locp
< old_locations
.get () + old_locations_count
;
11754 struct bp_location
*old_loc
= *old_locp
;
11755 struct bp_location
**loc2p
;
11757 /* Tells if 'old_loc' is found among the new locations. If
11758 not, we have to free it. */
11759 int found_object
= 0;
11760 /* Tells if the location should remain inserted in the target. */
11761 int keep_in_target
= 0;
11764 /* Skip LOCP entries which will definitely never be needed.
11765 Stop either at or being the one matching OLD_LOC. */
11766 while (locp
< bp_locations
+ bp_locations_count
11767 && (*locp
)->address
< old_loc
->address
)
11771 (loc2p
< bp_locations
+ bp_locations_count
11772 && (*loc2p
)->address
== old_loc
->address
);
11775 /* Check if this is a new/duplicated location or a duplicated
11776 location that had its condition modified. If so, we want to send
11777 its condition to the target if evaluation of conditions is taking
11779 if ((*loc2p
)->condition_changed
== condition_modified
11780 && (last_addr
!= old_loc
->address
11781 || last_pspace_num
!= old_loc
->pspace
->num
))
11783 force_breakpoint_reinsertion (*loc2p
);
11784 last_pspace_num
= old_loc
->pspace
->num
;
11787 if (*loc2p
== old_loc
)
11791 /* We have already handled this address, update it so that we don't
11792 have to go through updates again. */
11793 last_addr
= old_loc
->address
;
11795 /* Target-side condition evaluation: Handle deleted locations. */
11797 force_breakpoint_reinsertion (old_loc
);
11799 /* If this location is no longer present, and inserted, look if
11800 there's maybe a new location at the same address. If so,
11801 mark that one inserted, and don't remove this one. This is
11802 needed so that we don't have a time window where a breakpoint
11803 at certain location is not inserted. */
11805 if (old_loc
->inserted
)
11807 /* If the location is inserted now, we might have to remove
11810 if (found_object
&& should_be_inserted (old_loc
))
11812 /* The location is still present in the location list,
11813 and still should be inserted. Don't do anything. */
11814 keep_in_target
= 1;
11818 /* This location still exists, but it won't be kept in the
11819 target since it may have been disabled. We proceed to
11820 remove its target-side condition. */
11822 /* The location is either no longer present, or got
11823 disabled. See if there's another location at the
11824 same address, in which case we don't need to remove
11825 this one from the target. */
11827 /* OLD_LOC comes from existing struct breakpoint. */
11828 if (bl_address_is_meaningful (old_loc
))
11831 (loc2p
< bp_locations
+ bp_locations_count
11832 && (*loc2p
)->address
== old_loc
->address
);
11835 struct bp_location
*loc2
= *loc2p
;
11837 if (loc2
== old_loc
)
11840 if (breakpoint_locations_match (loc2
, old_loc
))
11842 /* Read watchpoint locations are switched to
11843 access watchpoints, if the former are not
11844 supported, but the latter are. */
11845 if (is_hardware_watchpoint (old_loc
->owner
))
11847 gdb_assert (is_hardware_watchpoint (loc2
->owner
));
11848 loc2
->watchpoint_type
= old_loc
->watchpoint_type
;
11851 /* loc2 is a duplicated location. We need to check
11852 if it should be inserted in case it will be
11854 if (unduplicated_should_be_inserted (loc2
))
11856 swap_insertion (old_loc
, loc2
);
11857 keep_in_target
= 1;
11865 if (!keep_in_target
)
11867 if (remove_breakpoint (old_loc
))
11869 /* This is just about all we can do. We could keep
11870 this location on the global list, and try to
11871 remove it next time, but there's no particular
11872 reason why we will succeed next time.
11874 Note that at this point, old_loc->owner is still
11875 valid, as delete_breakpoint frees the breakpoint
11876 only after calling us. */
11877 printf_filtered (_("warning: Error removing "
11878 "breakpoint %d\n"),
11879 old_loc
->owner
->number
);
11887 if (removed
&& target_is_non_stop_p ()
11888 && need_moribund_for_location_type (old_loc
))
11890 /* This location was removed from the target. In
11891 non-stop mode, a race condition is possible where
11892 we've removed a breakpoint, but stop events for that
11893 breakpoint are already queued and will arrive later.
11894 We apply an heuristic to be able to distinguish such
11895 SIGTRAPs from other random SIGTRAPs: we keep this
11896 breakpoint location for a bit, and will retire it
11897 after we see some number of events. The theory here
11898 is that reporting of events should, "on the average",
11899 be fair, so after a while we'll see events from all
11900 threads that have anything of interest, and no longer
11901 need to keep this breakpoint location around. We
11902 don't hold locations forever so to reduce chances of
11903 mistaking a non-breakpoint SIGTRAP for a breakpoint
11906 The heuristic failing can be disastrous on
11907 decr_pc_after_break targets.
11909 On decr_pc_after_break targets, like e.g., x86-linux,
11910 if we fail to recognize a late breakpoint SIGTRAP,
11911 because events_till_retirement has reached 0 too
11912 soon, we'll fail to do the PC adjustment, and report
11913 a random SIGTRAP to the user. When the user resumes
11914 the inferior, it will most likely immediately crash
11915 with SIGILL/SIGBUS/SIGSEGV, or worse, get silently
11916 corrupted, because of being resumed e.g., in the
11917 middle of a multi-byte instruction, or skipped a
11918 one-byte instruction. This was actually seen happen
11919 on native x86-linux, and should be less rare on
11920 targets that do not support new thread events, like
11921 remote, due to the heuristic depending on
11924 Mistaking a random SIGTRAP for a breakpoint trap
11925 causes similar symptoms (PC adjustment applied when
11926 it shouldn't), but then again, playing with SIGTRAPs
11927 behind the debugger's back is asking for trouble.
11929 Since hardware watchpoint traps are always
11930 distinguishable from other traps, so we don't need to
11931 apply keep hardware watchpoint moribund locations
11932 around. We simply always ignore hardware watchpoint
11933 traps we can no longer explain. */
11935 process_stratum_target
*proc_target
= nullptr;
11936 for (inferior
*inf
: all_inferiors ())
11937 if (inf
->pspace
== old_loc
->pspace
)
11939 proc_target
= inf
->process_target ();
11942 if (proc_target
!= nullptr)
11943 old_loc
->events_till_retirement
11944 = 3 * (thread_count (proc_target
) + 1);
11946 old_loc
->events_till_retirement
= 1;
11947 old_loc
->owner
= NULL
;
11949 moribund_locations
.push_back (old_loc
);
11953 old_loc
->owner
= NULL
;
11954 decref_bp_location (&old_loc
);
11959 /* Rescan breakpoints at the same address and section, marking the
11960 first one as "first" and any others as "duplicates". This is so
11961 that the bpt instruction is only inserted once. If we have a
11962 permanent breakpoint at the same place as BPT, make that one the
11963 official one, and the rest as duplicates. Permanent breakpoints
11964 are sorted first for the same address.
11966 Do the same for hardware watchpoints, but also considering the
11967 watchpoint's type (regular/access/read) and length. */
11969 bp_loc_first
= NULL
;
11970 wp_loc_first
= NULL
;
11971 awp_loc_first
= NULL
;
11972 rwp_loc_first
= NULL
;
11973 ALL_BP_LOCATIONS (loc
, locp
)
11975 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always
11977 struct bp_location
**loc_first_p
;
11980 if (!unduplicated_should_be_inserted (loc
)
11981 || !bl_address_is_meaningful (loc
)
11982 /* Don't detect duplicate for tracepoint locations because they are
11983 never duplicated. See the comments in field `duplicate' of
11984 `struct bp_location'. */
11985 || is_tracepoint (b
))
11987 /* Clear the condition modification flag. */
11988 loc
->condition_changed
= condition_unchanged
;
11992 if (b
->type
== bp_hardware_watchpoint
)
11993 loc_first_p
= &wp_loc_first
;
11994 else if (b
->type
== bp_read_watchpoint
)
11995 loc_first_p
= &rwp_loc_first
;
11996 else if (b
->type
== bp_access_watchpoint
)
11997 loc_first_p
= &awp_loc_first
;
11999 loc_first_p
= &bp_loc_first
;
12001 if (*loc_first_p
== NULL
12002 || (overlay_debugging
&& loc
->section
!= (*loc_first_p
)->section
)
12003 || !breakpoint_locations_match (loc
, *loc_first_p
))
12005 *loc_first_p
= loc
;
12006 loc
->duplicate
= 0;
12008 if (is_breakpoint (loc
->owner
) && loc
->condition_changed
)
12010 loc
->needs_update
= 1;
12011 /* Clear the condition modification flag. */
12012 loc
->condition_changed
= condition_unchanged
;
12018 /* This and the above ensure the invariant that the first location
12019 is not duplicated, and is the inserted one.
12020 All following are marked as duplicated, and are not inserted. */
12022 swap_insertion (loc
, *loc_first_p
);
12023 loc
->duplicate
= 1;
12025 /* Clear the condition modification flag. */
12026 loc
->condition_changed
= condition_unchanged
;
12029 if (insert_mode
== UGLL_INSERT
|| breakpoints_should_be_inserted_now ())
12031 if (insert_mode
!= UGLL_DONT_INSERT
)
12032 insert_breakpoint_locations ();
12035 /* Even though the caller told us to not insert new
12036 locations, we may still need to update conditions on the
12037 target's side of breakpoints that were already inserted
12038 if the target is evaluating breakpoint conditions. We
12039 only update conditions for locations that are marked
12041 update_inserted_breakpoint_locations ();
12045 if (insert_mode
!= UGLL_DONT_INSERT
)
12046 download_tracepoint_locations ();
12050 breakpoint_retire_moribund (void)
12052 for (int ix
= 0; ix
< moribund_locations
.size (); ++ix
)
12054 struct bp_location
*loc
= moribund_locations
[ix
];
12055 if (--(loc
->events_till_retirement
) == 0)
12057 decref_bp_location (&loc
);
12058 unordered_remove (moribund_locations
, ix
);
12065 update_global_location_list_nothrow (enum ugll_insert_mode insert_mode
)
12070 update_global_location_list (insert_mode
);
12072 catch (const gdb_exception_error
&e
)
12077 /* Clear BKP from a BPS. */
12080 bpstat_remove_bp_location (bpstat bps
, struct breakpoint
*bpt
)
12084 for (bs
= bps
; bs
; bs
= bs
->next
)
12085 if (bs
->breakpoint_at
== bpt
)
12087 bs
->breakpoint_at
= NULL
;
12088 bs
->old_val
= NULL
;
12089 /* bs->commands will be freed later. */
12093 /* Callback for iterate_over_threads. */
12095 bpstat_remove_breakpoint_callback (struct thread_info
*th
, void *data
)
12097 struct breakpoint
*bpt
= (struct breakpoint
*) data
;
12099 bpstat_remove_bp_location (th
->control
.stop_bpstat
, bpt
);
12103 /* Helper for breakpoint and tracepoint breakpoint_ops->mention
12107 say_where (struct breakpoint
*b
)
12109 struct value_print_options opts
;
12111 get_user_print_options (&opts
);
12113 /* i18n: cagney/2005-02-11: Below needs to be merged into a
12115 if (b
->loc
== NULL
)
12117 /* For pending locations, the output differs slightly based
12118 on b->extra_string. If this is non-NULL, it contains either
12119 a condition or dprintf arguments. */
12120 if (b
->extra_string
== NULL
)
12122 printf_filtered (_(" (%s) pending."),
12123 event_location_to_string (b
->location
.get ()));
12125 else if (b
->type
== bp_dprintf
)
12127 printf_filtered (_(" (%s,%s) pending."),
12128 event_location_to_string (b
->location
.get ()),
12133 printf_filtered (_(" (%s %s) pending."),
12134 event_location_to_string (b
->location
.get ()),
12140 if (opts
.addressprint
|| b
->loc
->symtab
== NULL
)
12141 printf_filtered (" at %ps",
12142 styled_string (address_style
.style (),
12143 paddress (b
->loc
->gdbarch
,
12144 b
->loc
->address
)));
12145 if (b
->loc
->symtab
!= NULL
)
12147 /* If there is a single location, we can print the location
12149 if (b
->loc
->next
== NULL
)
12151 const char *filename
12152 = symtab_to_filename_for_display (b
->loc
->symtab
);
12153 printf_filtered (": file %ps, line %d.",
12154 styled_string (file_name_style
.style (),
12156 b
->loc
->line_number
);
12159 /* This is not ideal, but each location may have a
12160 different file name, and this at least reflects the
12161 real situation somewhat. */
12162 printf_filtered (": %s.",
12163 event_location_to_string (b
->location
.get ()));
12168 struct bp_location
*loc
= b
->loc
;
12170 for (; loc
; loc
= loc
->next
)
12172 printf_filtered (" (%d locations)", n
);
12177 bp_location::~bp_location ()
12179 xfree (function_name
);
12182 /* Destructor for the breakpoint base class. */
12184 breakpoint::~breakpoint ()
12186 xfree (this->cond_string
);
12187 xfree (this->extra_string
);
12190 static struct bp_location
*
12191 base_breakpoint_allocate_location (struct breakpoint
*self
)
12193 return new bp_location (self
);
12197 base_breakpoint_re_set (struct breakpoint
*b
)
12199 /* Nothing to re-set. */
12202 #define internal_error_pure_virtual_called() \
12203 gdb_assert_not_reached ("pure virtual function called")
12206 base_breakpoint_insert_location (struct bp_location
*bl
)
12208 internal_error_pure_virtual_called ();
12212 base_breakpoint_remove_location (struct bp_location
*bl
,
12213 enum remove_bp_reason reason
)
12215 internal_error_pure_virtual_called ();
12219 base_breakpoint_breakpoint_hit (const struct bp_location
*bl
,
12220 const address_space
*aspace
,
12222 const struct target_waitstatus
*ws
)
12224 internal_error_pure_virtual_called ();
12228 base_breakpoint_check_status (bpstat bs
)
12233 /* A "works_in_software_mode" breakpoint_ops method that just internal
12237 base_breakpoint_works_in_software_mode (const struct breakpoint
*b
)
12239 internal_error_pure_virtual_called ();
12242 /* A "resources_needed" breakpoint_ops method that just internal
12246 base_breakpoint_resources_needed (const struct bp_location
*bl
)
12248 internal_error_pure_virtual_called ();
12251 static enum print_stop_action
12252 base_breakpoint_print_it (bpstat bs
)
12254 internal_error_pure_virtual_called ();
12258 base_breakpoint_print_one_detail (const struct breakpoint
*self
,
12259 struct ui_out
*uiout
)
12265 base_breakpoint_print_mention (struct breakpoint
*b
)
12267 internal_error_pure_virtual_called ();
12271 base_breakpoint_print_recreate (struct breakpoint
*b
, struct ui_file
*fp
)
12273 internal_error_pure_virtual_called ();
12277 base_breakpoint_create_sals_from_location
12278 (const struct event_location
*location
,
12279 struct linespec_result
*canonical
,
12280 enum bptype type_wanted
)
12282 internal_error_pure_virtual_called ();
12286 base_breakpoint_create_breakpoints_sal (struct gdbarch
*gdbarch
,
12287 struct linespec_result
*c
,
12288 gdb::unique_xmalloc_ptr
<char> cond_string
,
12289 gdb::unique_xmalloc_ptr
<char> extra_string
,
12290 enum bptype type_wanted
,
12291 enum bpdisp disposition
,
12293 int task
, int ignore_count
,
12294 const struct breakpoint_ops
*o
,
12295 int from_tty
, int enabled
,
12296 int internal
, unsigned flags
)
12298 internal_error_pure_virtual_called ();
12301 static std::vector
<symtab_and_line
>
12302 base_breakpoint_decode_location (struct breakpoint
*b
,
12303 const struct event_location
*location
,
12304 struct program_space
*search_pspace
)
12306 internal_error_pure_virtual_called ();
12309 /* The default 'explains_signal' method. */
12312 base_breakpoint_explains_signal (struct breakpoint
*b
, enum gdb_signal sig
)
12317 /* The default "after_condition_true" method. */
12320 base_breakpoint_after_condition_true (struct bpstats
*bs
)
12322 /* Nothing to do. */
12325 struct breakpoint_ops base_breakpoint_ops
=
12327 base_breakpoint_allocate_location
,
12328 base_breakpoint_re_set
,
12329 base_breakpoint_insert_location
,
12330 base_breakpoint_remove_location
,
12331 base_breakpoint_breakpoint_hit
,
12332 base_breakpoint_check_status
,
12333 base_breakpoint_resources_needed
,
12334 base_breakpoint_works_in_software_mode
,
12335 base_breakpoint_print_it
,
12337 base_breakpoint_print_one_detail
,
12338 base_breakpoint_print_mention
,
12339 base_breakpoint_print_recreate
,
12340 base_breakpoint_create_sals_from_location
,
12341 base_breakpoint_create_breakpoints_sal
,
12342 base_breakpoint_decode_location
,
12343 base_breakpoint_explains_signal
,
12344 base_breakpoint_after_condition_true
,
12347 /* Default breakpoint_ops methods. */
12350 bkpt_re_set (struct breakpoint
*b
)
12352 /* FIXME: is this still reachable? */
12353 if (breakpoint_event_location_empty_p (b
))
12355 /* Anything without a location can't be re-set. */
12356 delete_breakpoint (b
);
12360 breakpoint_re_set_default (b
);
12364 bkpt_insert_location (struct bp_location
*bl
)
12366 CORE_ADDR addr
= bl
->target_info
.reqstd_address
;
12368 bl
->target_info
.kind
= breakpoint_kind (bl
, &addr
);
12369 bl
->target_info
.placed_address
= addr
;
12371 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
12372 return target_insert_hw_breakpoint (bl
->gdbarch
, &bl
->target_info
);
12374 return target_insert_breakpoint (bl
->gdbarch
, &bl
->target_info
);
12378 bkpt_remove_location (struct bp_location
*bl
, enum remove_bp_reason reason
)
12380 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
12381 return target_remove_hw_breakpoint (bl
->gdbarch
, &bl
->target_info
);
12383 return target_remove_breakpoint (bl
->gdbarch
, &bl
->target_info
, reason
);
12387 bkpt_breakpoint_hit (const struct bp_location
*bl
,
12388 const address_space
*aspace
, CORE_ADDR bp_addr
,
12389 const struct target_waitstatus
*ws
)
12391 if (ws
->kind
!= TARGET_WAITKIND_STOPPED
12392 || ws
->value
.sig
!= GDB_SIGNAL_TRAP
)
12395 if (!breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
12399 if (overlay_debugging
/* unmapped overlay section */
12400 && section_is_overlay (bl
->section
)
12401 && !section_is_mapped (bl
->section
))
12408 dprintf_breakpoint_hit (const struct bp_location
*bl
,
12409 const address_space
*aspace
, CORE_ADDR bp_addr
,
12410 const struct target_waitstatus
*ws
)
12412 if (dprintf_style
== dprintf_style_agent
12413 && target_can_run_breakpoint_commands ())
12415 /* An agent-style dprintf never causes a stop. If we see a trap
12416 for this address it must be for a breakpoint that happens to
12417 be set at the same address. */
12421 return bkpt_breakpoint_hit (bl
, aspace
, bp_addr
, ws
);
12425 bkpt_resources_needed (const struct bp_location
*bl
)
12427 gdb_assert (bl
->owner
->type
== bp_hardware_breakpoint
);
12432 static enum print_stop_action
12433 bkpt_print_it (bpstat bs
)
12435 struct breakpoint
*b
;
12436 const struct bp_location
*bl
;
12438 struct ui_out
*uiout
= current_uiout
;
12440 gdb_assert (bs
->bp_location_at
!= NULL
);
12442 bl
= bs
->bp_location_at
;
12443 b
= bs
->breakpoint_at
;
12445 bp_temp
= b
->disposition
== disp_del
;
12446 if (bl
->address
!= bl
->requested_address
)
12447 breakpoint_adjustment_warning (bl
->requested_address
,
12450 annotate_breakpoint (b
->number
);
12451 maybe_print_thread_hit_breakpoint (uiout
);
12453 if (uiout
->is_mi_like_p ())
12455 uiout
->field_string ("reason",
12456 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
12457 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
12460 uiout
->message ("Temporary breakpoint %pF, ",
12461 signed_field ("bkptno", b
->number
));
12463 uiout
->message ("Breakpoint %pF, ",
12464 signed_field ("bkptno", b
->number
));
12466 return PRINT_SRC_AND_LOC
;
12470 bkpt_print_mention (struct breakpoint
*b
)
12472 if (current_uiout
->is_mi_like_p ())
12477 case bp_breakpoint
:
12478 case bp_gnu_ifunc_resolver
:
12479 if (b
->disposition
== disp_del
)
12480 printf_filtered (_("Temporary breakpoint"));
12482 printf_filtered (_("Breakpoint"));
12483 printf_filtered (_(" %d"), b
->number
);
12484 if (b
->type
== bp_gnu_ifunc_resolver
)
12485 printf_filtered (_(" at gnu-indirect-function resolver"));
12487 case bp_hardware_breakpoint
:
12488 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
12491 printf_filtered (_("Dprintf %d"), b
->number
);
12499 bkpt_print_recreate (struct breakpoint
*tp
, struct ui_file
*fp
)
12501 if (tp
->type
== bp_breakpoint
&& tp
->disposition
== disp_del
)
12502 fprintf_unfiltered (fp
, "tbreak");
12503 else if (tp
->type
== bp_breakpoint
)
12504 fprintf_unfiltered (fp
, "break");
12505 else if (tp
->type
== bp_hardware_breakpoint
12506 && tp
->disposition
== disp_del
)
12507 fprintf_unfiltered (fp
, "thbreak");
12508 else if (tp
->type
== bp_hardware_breakpoint
)
12509 fprintf_unfiltered (fp
, "hbreak");
12511 internal_error (__FILE__
, __LINE__
,
12512 _("unhandled breakpoint type %d"), (int) tp
->type
);
12514 fprintf_unfiltered (fp
, " %s",
12515 event_location_to_string (tp
->location
.get ()));
12517 /* Print out extra_string if this breakpoint is pending. It might
12518 contain, for example, conditions that were set by the user. */
12519 if (tp
->loc
== NULL
&& tp
->extra_string
!= NULL
)
12520 fprintf_unfiltered (fp
, " %s", tp
->extra_string
);
12522 print_recreate_thread (tp
, fp
);
12526 bkpt_create_sals_from_location (const struct event_location
*location
,
12527 struct linespec_result
*canonical
,
12528 enum bptype type_wanted
)
12530 create_sals_from_location_default (location
, canonical
, type_wanted
);
12534 bkpt_create_breakpoints_sal (struct gdbarch
*gdbarch
,
12535 struct linespec_result
*canonical
,
12536 gdb::unique_xmalloc_ptr
<char> cond_string
,
12537 gdb::unique_xmalloc_ptr
<char> extra_string
,
12538 enum bptype type_wanted
,
12539 enum bpdisp disposition
,
12541 int task
, int ignore_count
,
12542 const struct breakpoint_ops
*ops
,
12543 int from_tty
, int enabled
,
12544 int internal
, unsigned flags
)
12546 create_breakpoints_sal_default (gdbarch
, canonical
,
12547 std::move (cond_string
),
12548 std::move (extra_string
),
12550 disposition
, thread
, task
,
12551 ignore_count
, ops
, from_tty
,
12552 enabled
, internal
, flags
);
12555 static std::vector
<symtab_and_line
>
12556 bkpt_decode_location (struct breakpoint
*b
,
12557 const struct event_location
*location
,
12558 struct program_space
*search_pspace
)
12560 return decode_location_default (b
, location
, search_pspace
);
12563 /* Virtual table for internal breakpoints. */
12566 internal_bkpt_re_set (struct breakpoint
*b
)
12570 /* Delete overlay event and longjmp master breakpoints; they
12571 will be reset later by breakpoint_re_set. */
12572 case bp_overlay_event
:
12573 case bp_longjmp_master
:
12574 case bp_std_terminate_master
:
12575 case bp_exception_master
:
12576 delete_breakpoint (b
);
12579 /* This breakpoint is special, it's set up when the inferior
12580 starts and we really don't want to touch it. */
12581 case bp_shlib_event
:
12583 /* Like bp_shlib_event, this breakpoint type is special. Once
12584 it is set up, we do not want to touch it. */
12585 case bp_thread_event
:
12591 internal_bkpt_check_status (bpstat bs
)
12593 if (bs
->breakpoint_at
->type
== bp_shlib_event
)
12595 /* If requested, stop when the dynamic linker notifies GDB of
12596 events. This allows the user to get control and place
12597 breakpoints in initializer routines for dynamically loaded
12598 objects (among other things). */
12599 bs
->stop
= stop_on_solib_events
;
12600 bs
->print
= stop_on_solib_events
;
12606 static enum print_stop_action
12607 internal_bkpt_print_it (bpstat bs
)
12609 struct breakpoint
*b
;
12611 b
= bs
->breakpoint_at
;
12615 case bp_shlib_event
:
12616 /* Did we stop because the user set the stop_on_solib_events
12617 variable? (If so, we report this as a generic, "Stopped due
12618 to shlib event" message.) */
12619 print_solib_event (0);
12622 case bp_thread_event
:
12623 /* Not sure how we will get here.
12624 GDB should not stop for these breakpoints. */
12625 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
12628 case bp_overlay_event
:
12629 /* By analogy with the thread event, GDB should not stop for these. */
12630 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
12633 case bp_longjmp_master
:
12634 /* These should never be enabled. */
12635 printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
12638 case bp_std_terminate_master
:
12639 /* These should never be enabled. */
12640 printf_filtered (_("std::terminate Master Breakpoint: "
12641 "gdb should not stop!\n"));
12644 case bp_exception_master
:
12645 /* These should never be enabled. */
12646 printf_filtered (_("Exception Master Breakpoint: "
12647 "gdb should not stop!\n"));
12651 return PRINT_NOTHING
;
12655 internal_bkpt_print_mention (struct breakpoint
*b
)
12657 /* Nothing to mention. These breakpoints are internal. */
12660 /* Virtual table for momentary breakpoints */
12663 momentary_bkpt_re_set (struct breakpoint
*b
)
12665 /* Keep temporary breakpoints, which can be encountered when we step
12666 over a dlopen call and solib_add is resetting the breakpoints.
12667 Otherwise these should have been blown away via the cleanup chain
12668 or by breakpoint_init_inferior when we rerun the executable. */
12672 momentary_bkpt_check_status (bpstat bs
)
12674 /* Nothing. The point of these breakpoints is causing a stop. */
12677 static enum print_stop_action
12678 momentary_bkpt_print_it (bpstat bs
)
12680 return PRINT_UNKNOWN
;
12684 momentary_bkpt_print_mention (struct breakpoint
*b
)
12686 /* Nothing to mention. These breakpoints are internal. */
12689 /* Ensure INITIATING_FRAME is cleared when no such breakpoint exists.
12691 It gets cleared already on the removal of the first one of such placed
12692 breakpoints. This is OK as they get all removed altogether. */
12694 longjmp_breakpoint::~longjmp_breakpoint ()
12696 thread_info
*tp
= find_thread_global_id (this->thread
);
12699 tp
->initiating_frame
= null_frame_id
;
12702 /* Specific methods for probe breakpoints. */
12705 bkpt_probe_insert_location (struct bp_location
*bl
)
12707 int v
= bkpt_insert_location (bl
);
12711 /* The insertion was successful, now let's set the probe's semaphore
12713 bl
->probe
.prob
->set_semaphore (bl
->probe
.objfile
, bl
->gdbarch
);
12720 bkpt_probe_remove_location (struct bp_location
*bl
,
12721 enum remove_bp_reason reason
)
12723 /* Let's clear the semaphore before removing the location. */
12724 bl
->probe
.prob
->clear_semaphore (bl
->probe
.objfile
, bl
->gdbarch
);
12726 return bkpt_remove_location (bl
, reason
);
12730 bkpt_probe_create_sals_from_location (const struct event_location
*location
,
12731 struct linespec_result
*canonical
,
12732 enum bptype type_wanted
)
12734 struct linespec_sals lsal
;
12736 lsal
.sals
= parse_probes (location
, NULL
, canonical
);
12738 = xstrdup (event_location_to_string (canonical
->location
.get ()));
12739 canonical
->lsals
.push_back (std::move (lsal
));
12742 static std::vector
<symtab_and_line
>
12743 bkpt_probe_decode_location (struct breakpoint
*b
,
12744 const struct event_location
*location
,
12745 struct program_space
*search_pspace
)
12747 std::vector
<symtab_and_line
> sals
= parse_probes (location
, search_pspace
, NULL
);
12749 error (_("probe not found"));
12753 /* The breakpoint_ops structure to be used in tracepoints. */
12756 tracepoint_re_set (struct breakpoint
*b
)
12758 breakpoint_re_set_default (b
);
12762 tracepoint_breakpoint_hit (const struct bp_location
*bl
,
12763 const address_space
*aspace
, CORE_ADDR bp_addr
,
12764 const struct target_waitstatus
*ws
)
12766 /* By definition, the inferior does not report stops at
12772 tracepoint_print_one_detail (const struct breakpoint
*self
,
12773 struct ui_out
*uiout
)
12775 struct tracepoint
*tp
= (struct tracepoint
*) self
;
12776 if (!tp
->static_trace_marker_id
.empty ())
12778 gdb_assert (self
->type
== bp_static_tracepoint
);
12780 uiout
->message ("\tmarker id is %pF\n",
12781 string_field ("static-tracepoint-marker-string-id",
12782 tp
->static_trace_marker_id
.c_str ()));
12787 tracepoint_print_mention (struct breakpoint
*b
)
12789 if (current_uiout
->is_mi_like_p ())
12794 case bp_tracepoint
:
12795 printf_filtered (_("Tracepoint"));
12796 printf_filtered (_(" %d"), b
->number
);
12798 case bp_fast_tracepoint
:
12799 printf_filtered (_("Fast tracepoint"));
12800 printf_filtered (_(" %d"), b
->number
);
12802 case bp_static_tracepoint
:
12803 printf_filtered (_("Static tracepoint"));
12804 printf_filtered (_(" %d"), b
->number
);
12807 internal_error (__FILE__
, __LINE__
,
12808 _("unhandled tracepoint type %d"), (int) b
->type
);
12815 tracepoint_print_recreate (struct breakpoint
*self
, struct ui_file
*fp
)
12817 struct tracepoint
*tp
= (struct tracepoint
*) self
;
12819 if (self
->type
== bp_fast_tracepoint
)
12820 fprintf_unfiltered (fp
, "ftrace");
12821 else if (self
->type
== bp_static_tracepoint
)
12822 fprintf_unfiltered (fp
, "strace");
12823 else if (self
->type
== bp_tracepoint
)
12824 fprintf_unfiltered (fp
, "trace");
12826 internal_error (__FILE__
, __LINE__
,
12827 _("unhandled tracepoint type %d"), (int) self
->type
);
12829 fprintf_unfiltered (fp
, " %s",
12830 event_location_to_string (self
->location
.get ()));
12831 print_recreate_thread (self
, fp
);
12833 if (tp
->pass_count
)
12834 fprintf_unfiltered (fp
, " passcount %d\n", tp
->pass_count
);
12838 tracepoint_create_sals_from_location (const struct event_location
*location
,
12839 struct linespec_result
*canonical
,
12840 enum bptype type_wanted
)
12842 create_sals_from_location_default (location
, canonical
, type_wanted
);
12846 tracepoint_create_breakpoints_sal (struct gdbarch
*gdbarch
,
12847 struct linespec_result
*canonical
,
12848 gdb::unique_xmalloc_ptr
<char> cond_string
,
12849 gdb::unique_xmalloc_ptr
<char> extra_string
,
12850 enum bptype type_wanted
,
12851 enum bpdisp disposition
,
12853 int task
, int ignore_count
,
12854 const struct breakpoint_ops
*ops
,
12855 int from_tty
, int enabled
,
12856 int internal
, unsigned flags
)
12858 create_breakpoints_sal_default (gdbarch
, canonical
,
12859 std::move (cond_string
),
12860 std::move (extra_string
),
12862 disposition
, thread
, task
,
12863 ignore_count
, ops
, from_tty
,
12864 enabled
, internal
, flags
);
12867 static std::vector
<symtab_and_line
>
12868 tracepoint_decode_location (struct breakpoint
*b
,
12869 const struct event_location
*location
,
12870 struct program_space
*search_pspace
)
12872 return decode_location_default (b
, location
, search_pspace
);
12875 struct breakpoint_ops tracepoint_breakpoint_ops
;
12877 /* Virtual table for tracepoints on static probes. */
12880 tracepoint_probe_create_sals_from_location
12881 (const struct event_location
*location
,
12882 struct linespec_result
*canonical
,
12883 enum bptype type_wanted
)
12885 /* We use the same method for breakpoint on probes. */
12886 bkpt_probe_create_sals_from_location (location
, canonical
, type_wanted
);
12889 static std::vector
<symtab_and_line
>
12890 tracepoint_probe_decode_location (struct breakpoint
*b
,
12891 const struct event_location
*location
,
12892 struct program_space
*search_pspace
)
12894 /* We use the same method for breakpoint on probes. */
12895 return bkpt_probe_decode_location (b
, location
, search_pspace
);
12898 /* Dprintf breakpoint_ops methods. */
12901 dprintf_re_set (struct breakpoint
*b
)
12903 breakpoint_re_set_default (b
);
12905 /* extra_string should never be non-NULL for dprintf. */
12906 gdb_assert (b
->extra_string
!= NULL
);
12908 /* 1 - connect to target 1, that can run breakpoint commands.
12909 2 - create a dprintf, which resolves fine.
12910 3 - disconnect from target 1
12911 4 - connect to target 2, that can NOT run breakpoint commands.
12913 After steps #3/#4, you'll want the dprintf command list to
12914 be updated, because target 1 and 2 may well return different
12915 answers for target_can_run_breakpoint_commands().
12916 Given absence of finer grained resetting, we get to do
12917 it all the time. */
12918 if (b
->extra_string
!= NULL
)
12919 update_dprintf_command_list (b
);
12922 /* Implement the "print_recreate" breakpoint_ops method for dprintf. */
12925 dprintf_print_recreate (struct breakpoint
*tp
, struct ui_file
*fp
)
12927 fprintf_unfiltered (fp
, "dprintf %s,%s",
12928 event_location_to_string (tp
->location
.get ()),
12930 print_recreate_thread (tp
, fp
);
12933 /* Implement the "after_condition_true" breakpoint_ops method for
12936 dprintf's are implemented with regular commands in their command
12937 list, but we run the commands here instead of before presenting the
12938 stop to the user, as dprintf's don't actually cause a stop. This
12939 also makes it so that the commands of multiple dprintfs at the same
12940 address are all handled. */
12943 dprintf_after_condition_true (struct bpstats
*bs
)
12945 struct bpstats tmp_bs
;
12946 struct bpstats
*tmp_bs_p
= &tmp_bs
;
12948 /* dprintf's never cause a stop. This wasn't set in the
12949 check_status hook instead because that would make the dprintf's
12950 condition not be evaluated. */
12953 /* Run the command list here. Take ownership of it instead of
12954 copying. We never want these commands to run later in
12955 bpstat_do_actions, if a breakpoint that causes a stop happens to
12956 be set at same address as this dprintf, or even if running the
12957 commands here throws. */
12958 tmp_bs
.commands
= bs
->commands
;
12959 bs
->commands
= NULL
;
12961 bpstat_do_actions_1 (&tmp_bs_p
);
12963 /* 'tmp_bs.commands' will usually be NULL by now, but
12964 bpstat_do_actions_1 may return early without processing the whole
12968 /* The breakpoint_ops structure to be used on static tracepoints with
12972 strace_marker_create_sals_from_location (const struct event_location
*location
,
12973 struct linespec_result
*canonical
,
12974 enum bptype type_wanted
)
12976 struct linespec_sals lsal
;
12977 const char *arg_start
, *arg
;
12979 arg
= arg_start
= get_linespec_location (location
)->spec_string
;
12980 lsal
.sals
= decode_static_tracepoint_spec (&arg
);
12982 std::string
str (arg_start
, arg
- arg_start
);
12983 const char *ptr
= str
.c_str ();
12984 canonical
->location
12985 = new_linespec_location (&ptr
, symbol_name_match_type::FULL
);
12988 = xstrdup (event_location_to_string (canonical
->location
.get ()));
12989 canonical
->lsals
.push_back (std::move (lsal
));
12993 strace_marker_create_breakpoints_sal (struct gdbarch
*gdbarch
,
12994 struct linespec_result
*canonical
,
12995 gdb::unique_xmalloc_ptr
<char> cond_string
,
12996 gdb::unique_xmalloc_ptr
<char> extra_string
,
12997 enum bptype type_wanted
,
12998 enum bpdisp disposition
,
13000 int task
, int ignore_count
,
13001 const struct breakpoint_ops
*ops
,
13002 int from_tty
, int enabled
,
13003 int internal
, unsigned flags
)
13005 const linespec_sals
&lsal
= canonical
->lsals
[0];
13007 /* If the user is creating a static tracepoint by marker id
13008 (strace -m MARKER_ID), then store the sals index, so that
13009 breakpoint_re_set can try to match up which of the newly
13010 found markers corresponds to this one, and, don't try to
13011 expand multiple locations for each sal, given than SALS
13012 already should contain all sals for MARKER_ID. */
13014 for (size_t i
= 0; i
< lsal
.sals
.size (); i
++)
13016 event_location_up location
13017 = copy_event_location (canonical
->location
.get ());
13019 std::unique_ptr
<tracepoint
> tp (new tracepoint ());
13020 init_breakpoint_sal (tp
.get (), gdbarch
, lsal
.sals
[i
],
13021 std::move (location
), NULL
,
13022 std::move (cond_string
),
13023 std::move (extra_string
),
13024 type_wanted
, disposition
,
13025 thread
, task
, ignore_count
, ops
,
13026 from_tty
, enabled
, internal
, flags
,
13027 canonical
->special_display
);
13028 /* Given that its possible to have multiple markers with
13029 the same string id, if the user is creating a static
13030 tracepoint by marker id ("strace -m MARKER_ID"), then
13031 store the sals index, so that breakpoint_re_set can
13032 try to match up which of the newly found markers
13033 corresponds to this one */
13034 tp
->static_trace_marker_id_idx
= i
;
13036 install_breakpoint (internal
, std::move (tp
), 0);
13040 static std::vector
<symtab_and_line
>
13041 strace_marker_decode_location (struct breakpoint
*b
,
13042 const struct event_location
*location
,
13043 struct program_space
*search_pspace
)
13045 struct tracepoint
*tp
= (struct tracepoint
*) b
;
13046 const char *s
= get_linespec_location (location
)->spec_string
;
13048 std::vector
<symtab_and_line
> sals
= decode_static_tracepoint_spec (&s
);
13049 if (sals
.size () > tp
->static_trace_marker_id_idx
)
13051 sals
[0] = sals
[tp
->static_trace_marker_id_idx
];
13056 error (_("marker %s not found"), tp
->static_trace_marker_id
.c_str ());
13059 static struct breakpoint_ops strace_marker_breakpoint_ops
;
13062 strace_marker_p (struct breakpoint
*b
)
13064 return b
->ops
== &strace_marker_breakpoint_ops
;
13067 /* Delete a breakpoint and clean up all traces of it in the data
13071 delete_breakpoint (struct breakpoint
*bpt
)
13073 struct breakpoint
*b
;
13075 gdb_assert (bpt
!= NULL
);
13077 /* Has this bp already been deleted? This can happen because
13078 multiple lists can hold pointers to bp's. bpstat lists are
13081 One example of this happening is a watchpoint's scope bp. When
13082 the scope bp triggers, we notice that the watchpoint is out of
13083 scope, and delete it. We also delete its scope bp. But the
13084 scope bp is marked "auto-deleting", and is already on a bpstat.
13085 That bpstat is then checked for auto-deleting bp's, which are
13088 A real solution to this problem might involve reference counts in
13089 bp's, and/or giving them pointers back to their referencing
13090 bpstat's, and teaching delete_breakpoint to only free a bp's
13091 storage when no more references were extent. A cheaper bandaid
13093 if (bpt
->type
== bp_none
)
13096 /* At least avoid this stale reference until the reference counting
13097 of breakpoints gets resolved. */
13098 if (bpt
->related_breakpoint
!= bpt
)
13100 struct breakpoint
*related
;
13101 struct watchpoint
*w
;
13103 if (bpt
->type
== bp_watchpoint_scope
)
13104 w
= (struct watchpoint
*) bpt
->related_breakpoint
;
13105 else if (bpt
->related_breakpoint
->type
== bp_watchpoint_scope
)
13106 w
= (struct watchpoint
*) bpt
;
13110 watchpoint_del_at_next_stop (w
);
13112 /* Unlink bpt from the bpt->related_breakpoint ring. */
13113 for (related
= bpt
; related
->related_breakpoint
!= bpt
;
13114 related
= related
->related_breakpoint
);
13115 related
->related_breakpoint
= bpt
->related_breakpoint
;
13116 bpt
->related_breakpoint
= bpt
;
13119 /* watch_command_1 creates a watchpoint but only sets its number if
13120 update_watchpoint succeeds in creating its bp_locations. If there's
13121 a problem in that process, we'll be asked to delete the half-created
13122 watchpoint. In that case, don't announce the deletion. */
13124 gdb::observers::breakpoint_deleted
.notify (bpt
);
13126 if (breakpoint_chain
== bpt
)
13127 breakpoint_chain
= bpt
->next
;
13129 ALL_BREAKPOINTS (b
)
13130 if (b
->next
== bpt
)
13132 b
->next
= bpt
->next
;
13136 /* Be sure no bpstat's are pointing at the breakpoint after it's
13138 /* FIXME, how can we find all bpstat's? We just check stop_bpstat
13139 in all threads for now. Note that we cannot just remove bpstats
13140 pointing at bpt from the stop_bpstat list entirely, as breakpoint
13141 commands are associated with the bpstat; if we remove it here,
13142 then the later call to bpstat_do_actions (&stop_bpstat); in
13143 event-top.c won't do anything, and temporary breakpoints with
13144 commands won't work. */
13146 iterate_over_threads (bpstat_remove_breakpoint_callback
, bpt
);
13148 /* Now that breakpoint is removed from breakpoint list, update the
13149 global location list. This will remove locations that used to
13150 belong to this breakpoint. Do this before freeing the breakpoint
13151 itself, since remove_breakpoint looks at location's owner. It
13152 might be better design to have location completely
13153 self-contained, but it's not the case now. */
13154 update_global_location_list (UGLL_DONT_INSERT
);
13156 /* On the chance that someone will soon try again to delete this
13157 same bp, we mark it as deleted before freeing its storage. */
13158 bpt
->type
= bp_none
;
13162 /* Iterator function to call a user-provided callback function once
13163 for each of B and its related breakpoints. */
13166 iterate_over_related_breakpoints (struct breakpoint
*b
,
13167 gdb::function_view
<void (breakpoint
*)> function
)
13169 struct breakpoint
*related
;
13174 struct breakpoint
*next
;
13176 /* FUNCTION may delete RELATED. */
13177 next
= related
->related_breakpoint
;
13179 if (next
== related
)
13181 /* RELATED is the last ring entry. */
13182 function (related
);
13184 /* FUNCTION may have deleted it, so we'd never reach back to
13185 B. There's nothing left to do anyway, so just break
13190 function (related
);
13194 while (related
!= b
);
13198 delete_command (const char *arg
, int from_tty
)
13200 struct breakpoint
*b
, *b_tmp
;
13206 int breaks_to_delete
= 0;
13208 /* Delete all breakpoints if no argument. Do not delete
13209 internal breakpoints, these have to be deleted with an
13210 explicit breakpoint number argument. */
13211 ALL_BREAKPOINTS (b
)
13212 if (user_breakpoint_p (b
))
13214 breaks_to_delete
= 1;
13218 /* Ask user only if there are some breakpoints to delete. */
13220 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
13222 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
13223 if (user_breakpoint_p (b
))
13224 delete_breakpoint (b
);
13228 map_breakpoint_numbers
13229 (arg
, [&] (breakpoint
*br
)
13231 iterate_over_related_breakpoints (br
, delete_breakpoint
);
13235 /* Return true if all locations of B bound to PSPACE are pending. If
13236 PSPACE is NULL, all locations of all program spaces are
13240 all_locations_are_pending (struct breakpoint
*b
, struct program_space
*pspace
)
13242 struct bp_location
*loc
;
13244 for (loc
= b
->loc
; loc
!= NULL
; loc
= loc
->next
)
13245 if ((pspace
== NULL
13246 || loc
->pspace
== pspace
)
13247 && !loc
->shlib_disabled
13248 && !loc
->pspace
->executing_startup
)
13253 /* Subroutine of update_breakpoint_locations to simplify it.
13254 Return non-zero if multiple fns in list LOC have the same name.
13255 Null names are ignored. */
13258 ambiguous_names_p (struct bp_location
*loc
)
13260 struct bp_location
*l
;
13261 htab_t htab
= htab_create_alloc (13, htab_hash_string
, streq_hash
, NULL
,
13264 for (l
= loc
; l
!= NULL
; l
= l
->next
)
13267 const char *name
= l
->function_name
;
13269 /* Allow for some names to be NULL, ignore them. */
13273 slot
= (const char **) htab_find_slot (htab
, (const void *) name
,
13275 /* NOTE: We can assume slot != NULL here because xcalloc never
13279 htab_delete (htab
);
13285 htab_delete (htab
);
13289 /* When symbols change, it probably means the sources changed as well,
13290 and it might mean the static tracepoint markers are no longer at
13291 the same address or line numbers they used to be at last we
13292 checked. Losing your static tracepoints whenever you rebuild is
13293 undesirable. This function tries to resync/rematch gdb static
13294 tracepoints with the markers on the target, for static tracepoints
13295 that have not been set by marker id. Static tracepoint that have
13296 been set by marker id are reset by marker id in breakpoint_re_set.
13299 1) For a tracepoint set at a specific address, look for a marker at
13300 the old PC. If one is found there, assume to be the same marker.
13301 If the name / string id of the marker found is different from the
13302 previous known name, assume that means the user renamed the marker
13303 in the sources, and output a warning.
13305 2) For a tracepoint set at a given line number, look for a marker
13306 at the new address of the old line number. If one is found there,
13307 assume to be the same marker. If the name / string id of the
13308 marker found is different from the previous known name, assume that
13309 means the user renamed the marker in the sources, and output a
13312 3) If a marker is no longer found at the same address or line, it
13313 may mean the marker no longer exists. But it may also just mean
13314 the code changed a bit. Maybe the user added a few lines of code
13315 that made the marker move up or down (in line number terms). Ask
13316 the target for info about the marker with the string id as we knew
13317 it. If found, update line number and address in the matching
13318 static tracepoint. This will get confused if there's more than one
13319 marker with the same ID (possible in UST, although unadvised
13320 precisely because it confuses tools). */
13322 static struct symtab_and_line
13323 update_static_tracepoint (struct breakpoint
*b
, struct symtab_and_line sal
)
13325 struct tracepoint
*tp
= (struct tracepoint
*) b
;
13326 struct static_tracepoint_marker marker
;
13331 find_line_pc (sal
.symtab
, sal
.line
, &pc
);
13333 if (target_static_tracepoint_marker_at (pc
, &marker
))
13335 if (tp
->static_trace_marker_id
!= marker
.str_id
)
13336 warning (_("static tracepoint %d changed probed marker from %s to %s"),
13337 b
->number
, tp
->static_trace_marker_id
.c_str (),
13338 marker
.str_id
.c_str ());
13340 tp
->static_trace_marker_id
= std::move (marker
.str_id
);
13345 /* Old marker wasn't found on target at lineno. Try looking it up
13347 if (!sal
.explicit_pc
13349 && sal
.symtab
!= NULL
13350 && !tp
->static_trace_marker_id
.empty ())
13352 std::vector
<static_tracepoint_marker
> markers
13353 = target_static_tracepoint_markers_by_strid
13354 (tp
->static_trace_marker_id
.c_str ());
13356 if (!markers
.empty ())
13358 struct symbol
*sym
;
13359 struct static_tracepoint_marker
*tpmarker
;
13360 struct ui_out
*uiout
= current_uiout
;
13361 struct explicit_location explicit_loc
;
13363 tpmarker
= &markers
[0];
13365 tp
->static_trace_marker_id
= std::move (tpmarker
->str_id
);
13367 warning (_("marker for static tracepoint %d (%s) not "
13368 "found at previous line number"),
13369 b
->number
, tp
->static_trace_marker_id
.c_str ());
13371 symtab_and_line sal2
= find_pc_line (tpmarker
->address
, 0);
13372 sym
= find_pc_sect_function (tpmarker
->address
, NULL
);
13373 uiout
->text ("Now in ");
13376 uiout
->field_string ("func", sym
->print_name (),
13377 function_name_style
.style ());
13378 uiout
->text (" at ");
13380 uiout
->field_string ("file",
13381 symtab_to_filename_for_display (sal2
.symtab
),
13382 file_name_style
.style ());
13385 if (uiout
->is_mi_like_p ())
13387 const char *fullname
= symtab_to_fullname (sal2
.symtab
);
13389 uiout
->field_string ("fullname", fullname
);
13392 uiout
->field_signed ("line", sal2
.line
);
13393 uiout
->text ("\n");
13395 b
->loc
->line_number
= sal2
.line
;
13396 b
->loc
->symtab
= sym
!= NULL
? sal2
.symtab
: NULL
;
13398 b
->location
.reset (NULL
);
13399 initialize_explicit_location (&explicit_loc
);
13400 explicit_loc
.source_filename
13401 = ASTRDUP (symtab_to_filename_for_display (sal2
.symtab
));
13402 explicit_loc
.line_offset
.offset
= b
->loc
->line_number
;
13403 explicit_loc
.line_offset
.sign
= LINE_OFFSET_NONE
;
13404 b
->location
= new_explicit_location (&explicit_loc
);
13406 /* Might be nice to check if function changed, and warn if
13413 /* Returns 1 iff locations A and B are sufficiently same that
13414 we don't need to report breakpoint as changed. */
13417 locations_are_equal (struct bp_location
*a
, struct bp_location
*b
)
13421 if (a
->address
!= b
->address
)
13424 if (a
->shlib_disabled
!= b
->shlib_disabled
)
13427 if (a
->enabled
!= b
->enabled
)
13434 if ((a
== NULL
) != (b
== NULL
))
13440 /* Split all locations of B that are bound to PSPACE out of B's
13441 location list to a separate list and return that list's head. If
13442 PSPACE is NULL, hoist out all locations of B. */
13444 static struct bp_location
*
13445 hoist_existing_locations (struct breakpoint
*b
, struct program_space
*pspace
)
13447 struct bp_location head
;
13448 struct bp_location
*i
= b
->loc
;
13449 struct bp_location
**i_link
= &b
->loc
;
13450 struct bp_location
*hoisted
= &head
;
13452 if (pspace
== NULL
)
13463 if (i
->pspace
== pspace
)
13478 /* Create new breakpoint locations for B (a hardware or software
13479 breakpoint) based on SALS and SALS_END. If SALS_END.NELTS is not
13480 zero, then B is a ranged breakpoint. Only recreates locations for
13481 FILTER_PSPACE. Locations of other program spaces are left
13485 update_breakpoint_locations (struct breakpoint
*b
,
13486 struct program_space
*filter_pspace
,
13487 gdb::array_view
<const symtab_and_line
> sals
,
13488 gdb::array_view
<const symtab_and_line
> sals_end
)
13490 struct bp_location
*existing_locations
;
13492 if (!sals_end
.empty () && (sals
.size () != 1 || sals_end
.size () != 1))
13494 /* Ranged breakpoints have only one start location and one end
13496 b
->enable_state
= bp_disabled
;
13497 printf_unfiltered (_("Could not reset ranged breakpoint %d: "
13498 "multiple locations found\n"),
13503 /* If there's no new locations, and all existing locations are
13504 pending, don't do anything. This optimizes the common case where
13505 all locations are in the same shared library, that was unloaded.
13506 We'd like to retain the location, so that when the library is
13507 loaded again, we don't loose the enabled/disabled status of the
13508 individual locations. */
13509 if (all_locations_are_pending (b
, filter_pspace
) && sals
.empty ())
13512 existing_locations
= hoist_existing_locations (b
, filter_pspace
);
13514 for (const auto &sal
: sals
)
13516 struct bp_location
*new_loc
;
13518 switch_to_program_space_and_thread (sal
.pspace
);
13520 new_loc
= add_location_to_breakpoint (b
, &sal
);
13522 /* Reparse conditions, they might contain references to the
13524 if (b
->cond_string
!= NULL
)
13528 s
= b
->cond_string
;
13531 new_loc
->cond
= parse_exp_1 (&s
, sal
.pc
,
13532 block_for_pc (sal
.pc
),
13535 catch (const gdb_exception_error
&e
)
13537 warning (_("failed to reevaluate condition "
13538 "for breakpoint %d: %s"),
13539 b
->number
, e
.what ());
13540 new_loc
->enabled
= 0;
13544 if (!sals_end
.empty ())
13546 CORE_ADDR end
= find_breakpoint_range_end (sals_end
[0]);
13548 new_loc
->length
= end
- sals
[0].pc
+ 1;
13552 /* If possible, carry over 'disable' status from existing
13555 struct bp_location
*e
= existing_locations
;
13556 /* If there are multiple breakpoints with the same function name,
13557 e.g. for inline functions, comparing function names won't work.
13558 Instead compare pc addresses; this is just a heuristic as things
13559 may have moved, but in practice it gives the correct answer
13560 often enough until a better solution is found. */
13561 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
13563 for (; e
; e
= e
->next
)
13565 if (!e
->enabled
&& e
->function_name
)
13567 struct bp_location
*l
= b
->loc
;
13568 if (have_ambiguous_names
)
13570 for (; l
; l
= l
->next
)
13572 /* Ignore software vs hardware location type at
13573 this point, because with "set breakpoint
13574 auto-hw", after a re-set, locations that were
13575 hardware can end up as software, or vice versa.
13576 As mentioned above, this is an heuristic and in
13577 practice should give the correct answer often
13579 if (breakpoint_locations_match (e
, l
, true))
13588 for (; l
; l
= l
->next
)
13589 if (l
->function_name
13590 && strcmp (e
->function_name
, l
->function_name
) == 0)
13600 if (!locations_are_equal (existing_locations
, b
->loc
))
13601 gdb::observers::breakpoint_modified
.notify (b
);
13604 /* Find the SaL locations corresponding to the given LOCATION.
13605 On return, FOUND will be 1 if any SaL was found, zero otherwise. */
13607 static std::vector
<symtab_and_line
>
13608 location_to_sals (struct breakpoint
*b
, struct event_location
*location
,
13609 struct program_space
*search_pspace
, int *found
)
13611 struct gdb_exception exception
;
13613 gdb_assert (b
->ops
!= NULL
);
13615 std::vector
<symtab_and_line
> sals
;
13619 sals
= b
->ops
->decode_location (b
, location
, search_pspace
);
13621 catch (gdb_exception_error
&e
)
13623 int not_found_and_ok
= 0;
13625 /* For pending breakpoints, it's expected that parsing will
13626 fail until the right shared library is loaded. User has
13627 already told to create pending breakpoints and don't need
13628 extra messages. If breakpoint is in bp_shlib_disabled
13629 state, then user already saw the message about that
13630 breakpoint being disabled, and don't want to see more
13632 if (e
.error
== NOT_FOUND_ERROR
13633 && (b
->condition_not_parsed
13635 && search_pspace
!= NULL
13636 && b
->loc
->pspace
!= search_pspace
)
13637 || (b
->loc
&& b
->loc
->shlib_disabled
)
13638 || (b
->loc
&& b
->loc
->pspace
->executing_startup
)
13639 || b
->enable_state
== bp_disabled
))
13640 not_found_and_ok
= 1;
13642 if (!not_found_and_ok
)
13644 /* We surely don't want to warn about the same breakpoint
13645 10 times. One solution, implemented here, is disable
13646 the breakpoint on error. Another solution would be to
13647 have separate 'warning emitted' flag. Since this
13648 happens only when a binary has changed, I don't know
13649 which approach is better. */
13650 b
->enable_state
= bp_disabled
;
13654 exception
= std::move (e
);
13657 if (exception
.reason
== 0 || exception
.error
!= NOT_FOUND_ERROR
)
13659 for (auto &sal
: sals
)
13660 resolve_sal_pc (&sal
);
13661 if (b
->condition_not_parsed
&& b
->extra_string
!= NULL
)
13663 char *cond_string
, *extra_string
;
13666 find_condition_and_thread (b
->extra_string
, sals
[0].pc
,
13667 &cond_string
, &thread
, &task
,
13669 gdb_assert (b
->cond_string
== NULL
);
13671 b
->cond_string
= cond_string
;
13672 b
->thread
= thread
;
13676 xfree (b
->extra_string
);
13677 b
->extra_string
= extra_string
;
13679 b
->condition_not_parsed
= 0;
13682 if (b
->type
== bp_static_tracepoint
&& !strace_marker_p (b
))
13683 sals
[0] = update_static_tracepoint (b
, sals
[0]);
13693 /* The default re_set method, for typical hardware or software
13694 breakpoints. Reevaluate the breakpoint and recreate its
13698 breakpoint_re_set_default (struct breakpoint
*b
)
13700 struct program_space
*filter_pspace
= current_program_space
;
13701 std::vector
<symtab_and_line
> expanded
, expanded_end
;
13704 std::vector
<symtab_and_line
> sals
= location_to_sals (b
, b
->location
.get (),
13705 filter_pspace
, &found
);
13707 expanded
= std::move (sals
);
13709 if (b
->location_range_end
!= NULL
)
13711 std::vector
<symtab_and_line
> sals_end
13712 = location_to_sals (b
, b
->location_range_end
.get (),
13713 filter_pspace
, &found
);
13715 expanded_end
= std::move (sals_end
);
13718 update_breakpoint_locations (b
, filter_pspace
, expanded
, expanded_end
);
13721 /* Default method for creating SALs from an address string. It basically
13722 calls parse_breakpoint_sals. Return 1 for success, zero for failure. */
13725 create_sals_from_location_default (const struct event_location
*location
,
13726 struct linespec_result
*canonical
,
13727 enum bptype type_wanted
)
13729 parse_breakpoint_sals (location
, canonical
);
13732 /* Call create_breakpoints_sal for the given arguments. This is the default
13733 function for the `create_breakpoints_sal' method of
13737 create_breakpoints_sal_default (struct gdbarch
*gdbarch
,
13738 struct linespec_result
*canonical
,
13739 gdb::unique_xmalloc_ptr
<char> cond_string
,
13740 gdb::unique_xmalloc_ptr
<char> extra_string
,
13741 enum bptype type_wanted
,
13742 enum bpdisp disposition
,
13744 int task
, int ignore_count
,
13745 const struct breakpoint_ops
*ops
,
13746 int from_tty
, int enabled
,
13747 int internal
, unsigned flags
)
13749 create_breakpoints_sal (gdbarch
, canonical
,
13750 std::move (cond_string
),
13751 std::move (extra_string
),
13752 type_wanted
, disposition
,
13753 thread
, task
, ignore_count
, ops
, from_tty
,
13754 enabled
, internal
, flags
);
13757 /* Decode the line represented by S by calling decode_line_full. This is the
13758 default function for the `decode_location' method of breakpoint_ops. */
13760 static std::vector
<symtab_and_line
>
13761 decode_location_default (struct breakpoint
*b
,
13762 const struct event_location
*location
,
13763 struct program_space
*search_pspace
)
13765 struct linespec_result canonical
;
13767 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, search_pspace
,
13768 NULL
, 0, &canonical
, multiple_symbols_all
,
13771 /* We should get 0 or 1 resulting SALs. */
13772 gdb_assert (canonical
.lsals
.size () < 2);
13774 if (!canonical
.lsals
.empty ())
13776 const linespec_sals
&lsal
= canonical
.lsals
[0];
13777 return std::move (lsal
.sals
);
13782 /* Reset a breakpoint. */
13785 breakpoint_re_set_one (breakpoint
*b
)
13787 input_radix
= b
->input_radix
;
13788 set_language (b
->language
);
13790 b
->ops
->re_set (b
);
13793 /* Re-set breakpoint locations for the current program space.
13794 Locations bound to other program spaces are left untouched. */
13797 breakpoint_re_set (void)
13799 struct breakpoint
*b
, *b_tmp
;
13802 scoped_restore_current_language save_language
;
13803 scoped_restore save_input_radix
= make_scoped_restore (&input_radix
);
13804 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
13806 /* breakpoint_re_set_one sets the current_language to the language
13807 of the breakpoint it is resetting (see prepare_re_set_context)
13808 before re-evaluating the breakpoint's location. This change can
13809 unfortunately get undone by accident if the language_mode is set
13810 to auto, and we either switch frames, or more likely in this context,
13811 we select the current frame.
13813 We prevent this by temporarily turning the language_mode to
13814 language_mode_manual. We restore it once all breakpoints
13815 have been reset. */
13816 scoped_restore save_language_mode
= make_scoped_restore (&language_mode
);
13817 language_mode
= language_mode_manual
;
13819 /* Note: we must not try to insert locations until after all
13820 breakpoints have been re-set. Otherwise, e.g., when re-setting
13821 breakpoint 1, we'd insert the locations of breakpoint 2, which
13822 hadn't been re-set yet, and thus may have stale locations. */
13824 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
13828 breakpoint_re_set_one (b
);
13830 catch (const gdb_exception
&ex
)
13832 exception_fprintf (gdb_stderr
, ex
,
13833 "Error in re-setting breakpoint %d: ",
13838 jit_breakpoint_re_set ();
13841 create_overlay_event_breakpoint ();
13842 create_longjmp_master_breakpoint ();
13843 create_std_terminate_master_breakpoint ();
13844 create_exception_master_breakpoint ();
13846 /* Now we can insert. */
13847 update_global_location_list (UGLL_MAY_INSERT
);
13850 /* Reset the thread number of this breakpoint:
13852 - If the breakpoint is for all threads, leave it as-is.
13853 - Else, reset it to the current thread for inferior_ptid. */
13855 breakpoint_re_set_thread (struct breakpoint
*b
)
13857 if (b
->thread
!= -1)
13859 b
->thread
= inferior_thread ()->global_num
;
13861 /* We're being called after following a fork. The new fork is
13862 selected as current, and unless this was a vfork will have a
13863 different program space from the original thread. Reset that
13865 b
->loc
->pspace
= current_program_space
;
13869 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
13870 If from_tty is nonzero, it prints a message to that effect,
13871 which ends with a period (no newline). */
13874 set_ignore_count (int bptnum
, int count
, int from_tty
)
13876 struct breakpoint
*b
;
13881 ALL_BREAKPOINTS (b
)
13882 if (b
->number
== bptnum
)
13884 if (is_tracepoint (b
))
13886 if (from_tty
&& count
!= 0)
13887 printf_filtered (_("Ignore count ignored for tracepoint %d."),
13892 b
->ignore_count
= count
;
13896 printf_filtered (_("Will stop next time "
13897 "breakpoint %d is reached."),
13899 else if (count
== 1)
13900 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
13903 printf_filtered (_("Will ignore next %d "
13904 "crossings of breakpoint %d."),
13907 gdb::observers::breakpoint_modified
.notify (b
);
13911 error (_("No breakpoint number %d."), bptnum
);
13914 /* Command to set ignore-count of breakpoint N to COUNT. */
13917 ignore_command (const char *args
, int from_tty
)
13919 const char *p
= args
;
13923 error_no_arg (_("a breakpoint number"));
13925 num
= get_number (&p
);
13927 error (_("bad breakpoint number: '%s'"), args
);
13929 error (_("Second argument (specified ignore-count) is missing."));
13931 set_ignore_count (num
,
13932 longest_to_int (value_as_long (parse_and_eval (p
))),
13935 printf_filtered ("\n");
13939 /* Call FUNCTION on each of the breakpoints with numbers in the range
13940 defined by BP_NUM_RANGE (an inclusive range). */
13943 map_breakpoint_number_range (std::pair
<int, int> bp_num_range
,
13944 gdb::function_view
<void (breakpoint
*)> function
)
13946 if (bp_num_range
.first
== 0)
13948 warning (_("bad breakpoint number at or near '%d'"),
13949 bp_num_range
.first
);
13953 struct breakpoint
*b
, *tmp
;
13955 for (int i
= bp_num_range
.first
; i
<= bp_num_range
.second
; i
++)
13957 bool match
= false;
13959 ALL_BREAKPOINTS_SAFE (b
, tmp
)
13960 if (b
->number
== i
)
13967 printf_unfiltered (_("No breakpoint number %d.\n"), i
);
13972 /* Call FUNCTION on each of the breakpoints whose numbers are given in
13976 map_breakpoint_numbers (const char *args
,
13977 gdb::function_view
<void (breakpoint
*)> function
)
13979 if (args
== NULL
|| *args
== '\0')
13980 error_no_arg (_("one or more breakpoint numbers"));
13982 number_or_range_parser
parser (args
);
13984 while (!parser
.finished ())
13986 int num
= parser
.get_number ();
13987 map_breakpoint_number_range (std::make_pair (num
, num
), function
);
13991 /* Return the breakpoint location structure corresponding to the
13992 BP_NUM and LOC_NUM values. */
13994 static struct bp_location
*
13995 find_location_by_number (int bp_num
, int loc_num
)
13997 struct breakpoint
*b
;
13999 ALL_BREAKPOINTS (b
)
14000 if (b
->number
== bp_num
)
14005 if (!b
|| b
->number
!= bp_num
)
14006 error (_("Bad breakpoint number '%d'"), bp_num
);
14009 error (_("Bad breakpoint location number '%d'"), loc_num
);
14012 for (bp_location
*loc
= b
->loc
; loc
!= NULL
; loc
= loc
->next
)
14013 if (++n
== loc_num
)
14016 error (_("Bad breakpoint location number '%d'"), loc_num
);
14019 /* Modes of operation for extract_bp_num. */
14020 enum class extract_bp_kind
14022 /* Extracting a breakpoint number. */
14025 /* Extracting a location number. */
14029 /* Extract a breakpoint or location number (as determined by KIND)
14030 from the string starting at START. TRAILER is a character which
14031 can be found after the number. If you don't want a trailer, use
14032 '\0'. If END_OUT is not NULL, it is set to point after the parsed
14033 string. This always returns a positive integer. */
14036 extract_bp_num (extract_bp_kind kind
, const char *start
,
14037 int trailer
, const char **end_out
= NULL
)
14039 const char *end
= start
;
14040 int num
= get_number_trailer (&end
, trailer
);
14042 error (kind
== extract_bp_kind::bp
14043 ? _("Negative breakpoint number '%.*s'")
14044 : _("Negative breakpoint location number '%.*s'"),
14045 int (end
- start
), start
);
14047 error (kind
== extract_bp_kind::bp
14048 ? _("Bad breakpoint number '%.*s'")
14049 : _("Bad breakpoint location number '%.*s'"),
14050 int (end
- start
), start
);
14052 if (end_out
!= NULL
)
14057 /* Extract a breakpoint or location range (as determined by KIND) in
14058 the form NUM1-NUM2 stored at &ARG[arg_offset]. Returns a std::pair
14059 representing the (inclusive) range. The returned pair's elements
14060 are always positive integers. */
14062 static std::pair
<int, int>
14063 extract_bp_or_bp_range (extract_bp_kind kind
,
14064 const std::string
&arg
,
14065 std::string::size_type arg_offset
)
14067 std::pair
<int, int> range
;
14068 const char *bp_loc
= &arg
[arg_offset
];
14069 std::string::size_type dash
= arg
.find ('-', arg_offset
);
14070 if (dash
!= std::string::npos
)
14072 /* bp_loc is a range (x-z). */
14073 if (arg
.length () == dash
+ 1)
14074 error (kind
== extract_bp_kind::bp
14075 ? _("Bad breakpoint number at or near: '%s'")
14076 : _("Bad breakpoint location number at or near: '%s'"),
14080 const char *start_first
= bp_loc
;
14081 const char *start_second
= &arg
[dash
+ 1];
14082 range
.first
= extract_bp_num (kind
, start_first
, '-');
14083 range
.second
= extract_bp_num (kind
, start_second
, '\0', &end
);
14085 if (range
.first
> range
.second
)
14086 error (kind
== extract_bp_kind::bp
14087 ? _("Inverted breakpoint range at '%.*s'")
14088 : _("Inverted breakpoint location range at '%.*s'"),
14089 int (end
- start_first
), start_first
);
14093 /* bp_loc is a single value. */
14094 range
.first
= extract_bp_num (kind
, bp_loc
, '\0');
14095 range
.second
= range
.first
;
14100 /* Extract the breakpoint/location range specified by ARG. Returns
14101 the breakpoint range in BP_NUM_RANGE, and the location range in
14104 ARG may be in any of the following forms:
14106 x where 'x' is a breakpoint number.
14107 x-y where 'x' and 'y' specify a breakpoint numbers range.
14108 x.y where 'x' is a breakpoint number and 'y' a location number.
14109 x.y-z where 'x' is a breakpoint number and 'y' and 'z' specify a
14110 location number range.
14114 extract_bp_number_and_location (const std::string
&arg
,
14115 std::pair
<int, int> &bp_num_range
,
14116 std::pair
<int, int> &bp_loc_range
)
14118 std::string::size_type dot
= arg
.find ('.');
14120 if (dot
!= std::string::npos
)
14122 /* Handle 'x.y' and 'x.y-z' cases. */
14124 if (arg
.length () == dot
+ 1 || dot
== 0)
14125 error (_("Bad breakpoint number at or near: '%s'"), arg
.c_str ());
14128 = extract_bp_num (extract_bp_kind::bp
, arg
.c_str (), '.');
14129 bp_num_range
.second
= bp_num_range
.first
;
14131 bp_loc_range
= extract_bp_or_bp_range (extract_bp_kind::loc
,
14136 /* Handle x and x-y cases. */
14138 bp_num_range
= extract_bp_or_bp_range (extract_bp_kind::bp
, arg
, 0);
14139 bp_loc_range
.first
= 0;
14140 bp_loc_range
.second
= 0;
14144 /* Enable or disable a breakpoint location BP_NUM.LOC_NUM. ENABLE
14145 specifies whether to enable or disable. */
14148 enable_disable_bp_num_loc (int bp_num
, int loc_num
, bool enable
)
14150 struct bp_location
*loc
= find_location_by_number (bp_num
, loc_num
);
14153 if (loc
->enabled
!= enable
)
14155 loc
->enabled
= enable
;
14156 mark_breakpoint_location_modified (loc
);
14158 if (target_supports_enable_disable_tracepoint ()
14159 && current_trace_status ()->running
&& loc
->owner
14160 && is_tracepoint (loc
->owner
))
14161 target_disable_tracepoint (loc
);
14163 update_global_location_list (UGLL_DONT_INSERT
);
14165 gdb::observers::breakpoint_modified
.notify (loc
->owner
);
14168 /* Enable or disable a range of breakpoint locations. BP_NUM is the
14169 number of the breakpoint, and BP_LOC_RANGE specifies the
14170 (inclusive) range of location numbers of that breakpoint to
14171 enable/disable. ENABLE specifies whether to enable or disable the
14175 enable_disable_breakpoint_location_range (int bp_num
,
14176 std::pair
<int, int> &bp_loc_range
,
14179 for (int i
= bp_loc_range
.first
; i
<= bp_loc_range
.second
; i
++)
14180 enable_disable_bp_num_loc (bp_num
, i
, enable
);
14183 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14184 If from_tty is nonzero, it prints a message to that effect,
14185 which ends with a period (no newline). */
14188 disable_breakpoint (struct breakpoint
*bpt
)
14190 /* Never disable a watchpoint scope breakpoint; we want to
14191 hit them when we leave scope so we can delete both the
14192 watchpoint and its scope breakpoint at that time. */
14193 if (bpt
->type
== bp_watchpoint_scope
)
14196 bpt
->enable_state
= bp_disabled
;
14198 /* Mark breakpoint locations modified. */
14199 mark_breakpoint_modified (bpt
);
14201 if (target_supports_enable_disable_tracepoint ()
14202 && current_trace_status ()->running
&& is_tracepoint (bpt
))
14204 struct bp_location
*location
;
14206 for (location
= bpt
->loc
; location
; location
= location
->next
)
14207 target_disable_tracepoint (location
);
14210 update_global_location_list (UGLL_DONT_INSERT
);
14212 gdb::observers::breakpoint_modified
.notify (bpt
);
14215 /* Enable or disable the breakpoint(s) or breakpoint location(s)
14216 specified in ARGS. ARGS may be in any of the formats handled by
14217 extract_bp_number_and_location. ENABLE specifies whether to enable
14218 or disable the breakpoints/locations. */
14221 enable_disable_command (const char *args
, int from_tty
, bool enable
)
14225 struct breakpoint
*bpt
;
14227 ALL_BREAKPOINTS (bpt
)
14228 if (user_breakpoint_p (bpt
))
14231 enable_breakpoint (bpt
);
14233 disable_breakpoint (bpt
);
14238 std::string num
= extract_arg (&args
);
14240 while (!num
.empty ())
14242 std::pair
<int, int> bp_num_range
, bp_loc_range
;
14244 extract_bp_number_and_location (num
, bp_num_range
, bp_loc_range
);
14246 if (bp_loc_range
.first
== bp_loc_range
.second
14247 && bp_loc_range
.first
== 0)
14249 /* Handle breakpoint ids with formats 'x' or 'x-z'. */
14250 map_breakpoint_number_range (bp_num_range
,
14252 ? enable_breakpoint
14253 : disable_breakpoint
);
14257 /* Handle breakpoint ids with formats 'x.y' or
14259 enable_disable_breakpoint_location_range
14260 (bp_num_range
.first
, bp_loc_range
, enable
);
14262 num
= extract_arg (&args
);
14267 /* The disable command disables the specified breakpoints/locations
14268 (or all defined breakpoints) so they're no longer effective in
14269 stopping the inferior. ARGS may be in any of the forms defined in
14270 extract_bp_number_and_location. */
14273 disable_command (const char *args
, int from_tty
)
14275 enable_disable_command (args
, from_tty
, false);
14279 enable_breakpoint_disp (struct breakpoint
*bpt
, enum bpdisp disposition
,
14282 int target_resources_ok
;
14284 if (bpt
->type
== bp_hardware_breakpoint
)
14287 i
= hw_breakpoint_used_count ();
14288 target_resources_ok
=
14289 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
14291 if (target_resources_ok
== 0)
14292 error (_("No hardware breakpoint support in the target."));
14293 else if (target_resources_ok
< 0)
14294 error (_("Hardware breakpoints used exceeds limit."));
14297 if (is_watchpoint (bpt
))
14299 /* Initialize it just to avoid a GCC false warning. */
14300 enum enable_state orig_enable_state
= bp_disabled
;
14304 struct watchpoint
*w
= (struct watchpoint
*) bpt
;
14306 orig_enable_state
= bpt
->enable_state
;
14307 bpt
->enable_state
= bp_enabled
;
14308 update_watchpoint (w
, 1 /* reparse */);
14310 catch (const gdb_exception
&e
)
14312 bpt
->enable_state
= orig_enable_state
;
14313 exception_fprintf (gdb_stderr
, e
, _("Cannot enable watchpoint %d: "),
14319 bpt
->enable_state
= bp_enabled
;
14321 /* Mark breakpoint locations modified. */
14322 mark_breakpoint_modified (bpt
);
14324 if (target_supports_enable_disable_tracepoint ()
14325 && current_trace_status ()->running
&& is_tracepoint (bpt
))
14327 struct bp_location
*location
;
14329 for (location
= bpt
->loc
; location
; location
= location
->next
)
14330 target_enable_tracepoint (location
);
14333 bpt
->disposition
= disposition
;
14334 bpt
->enable_count
= count
;
14335 update_global_location_list (UGLL_MAY_INSERT
);
14337 gdb::observers::breakpoint_modified
.notify (bpt
);
14342 enable_breakpoint (struct breakpoint
*bpt
)
14344 enable_breakpoint_disp (bpt
, bpt
->disposition
, 0);
14347 /* The enable command enables the specified breakpoints/locations (or
14348 all defined breakpoints) so they once again become (or continue to
14349 be) effective in stopping the inferior. ARGS may be in any of the
14350 forms defined in extract_bp_number_and_location. */
14353 enable_command (const char *args
, int from_tty
)
14355 enable_disable_command (args
, from_tty
, true);
14359 enable_once_command (const char *args
, int from_tty
)
14361 map_breakpoint_numbers
14362 (args
, [&] (breakpoint
*b
)
14364 iterate_over_related_breakpoints
14365 (b
, [&] (breakpoint
*bpt
)
14367 enable_breakpoint_disp (bpt
, disp_disable
, 1);
14373 enable_count_command (const char *args
, int from_tty
)
14378 error_no_arg (_("hit count"));
14380 count
= get_number (&args
);
14382 map_breakpoint_numbers
14383 (args
, [&] (breakpoint
*b
)
14385 iterate_over_related_breakpoints
14386 (b
, [&] (breakpoint
*bpt
)
14388 enable_breakpoint_disp (bpt
, disp_disable
, count
);
14394 enable_delete_command (const char *args
, int from_tty
)
14396 map_breakpoint_numbers
14397 (args
, [&] (breakpoint
*b
)
14399 iterate_over_related_breakpoints
14400 (b
, [&] (breakpoint
*bpt
)
14402 enable_breakpoint_disp (bpt
, disp_del
, 1);
14407 /* Invalidate last known value of any hardware watchpoint if
14408 the memory which that value represents has been written to by
14412 invalidate_bp_value_on_memory_change (struct inferior
*inferior
,
14413 CORE_ADDR addr
, ssize_t len
,
14414 const bfd_byte
*data
)
14416 struct breakpoint
*bp
;
14418 ALL_BREAKPOINTS (bp
)
14419 if (bp
->enable_state
== bp_enabled
14420 && bp
->type
== bp_hardware_watchpoint
)
14422 struct watchpoint
*wp
= (struct watchpoint
*) bp
;
14424 if (wp
->val_valid
&& wp
->val
!= nullptr)
14426 struct bp_location
*loc
;
14428 for (loc
= bp
->loc
; loc
!= NULL
; loc
= loc
->next
)
14429 if (loc
->loc_type
== bp_loc_hardware_watchpoint
14430 && loc
->address
+ loc
->length
> addr
14431 && addr
+ len
> loc
->address
)
14434 wp
->val_valid
= false;
14440 /* Create and insert a breakpoint for software single step. */
14443 insert_single_step_breakpoint (struct gdbarch
*gdbarch
,
14444 const address_space
*aspace
,
14447 struct thread_info
*tp
= inferior_thread ();
14448 struct symtab_and_line sal
;
14449 CORE_ADDR pc
= next_pc
;
14451 if (tp
->control
.single_step_breakpoints
== NULL
)
14453 tp
->control
.single_step_breakpoints
14454 = new_single_step_breakpoint (tp
->global_num
, gdbarch
);
14457 sal
= find_pc_line (pc
, 0);
14459 sal
.section
= find_pc_overlay (pc
);
14460 sal
.explicit_pc
= 1;
14461 add_location_to_breakpoint (tp
->control
.single_step_breakpoints
, &sal
);
14463 update_global_location_list (UGLL_INSERT
);
14466 /* Insert single step breakpoints according to the current state. */
14469 insert_single_step_breakpoints (struct gdbarch
*gdbarch
)
14471 struct regcache
*regcache
= get_current_regcache ();
14472 std::vector
<CORE_ADDR
> next_pcs
;
14474 next_pcs
= gdbarch_software_single_step (gdbarch
, regcache
);
14476 if (!next_pcs
.empty ())
14478 struct frame_info
*frame
= get_current_frame ();
14479 const address_space
*aspace
= get_frame_address_space (frame
);
14481 for (CORE_ADDR pc
: next_pcs
)
14482 insert_single_step_breakpoint (gdbarch
, aspace
, pc
);
14490 /* See breakpoint.h. */
14493 breakpoint_has_location_inserted_here (struct breakpoint
*bp
,
14494 const address_space
*aspace
,
14497 struct bp_location
*loc
;
14499 for (loc
= bp
->loc
; loc
!= NULL
; loc
= loc
->next
)
14501 && breakpoint_location_address_match (loc
, aspace
, pc
))
14507 /* Check whether a software single-step breakpoint is inserted at
14511 single_step_breakpoint_inserted_here_p (const address_space
*aspace
,
14514 struct breakpoint
*bpt
;
14516 ALL_BREAKPOINTS (bpt
)
14518 if (bpt
->type
== bp_single_step
14519 && breakpoint_has_location_inserted_here (bpt
, aspace
, pc
))
14525 /* Tracepoint-specific operations. */
14527 /* Set tracepoint count to NUM. */
14529 set_tracepoint_count (int num
)
14531 tracepoint_count
= num
;
14532 set_internalvar_integer (lookup_internalvar ("tpnum"), num
);
14536 trace_command (const char *arg
, int from_tty
)
14538 event_location_up location
= string_to_event_location (&arg
,
14540 const struct breakpoint_ops
*ops
= breakpoint_ops_for_event_location
14541 (location
.get (), true /* is_tracepoint */);
14543 create_breakpoint (get_current_arch (),
14545 NULL
, 0, arg
, 1 /* parse arg */,
14547 bp_tracepoint
/* type_wanted */,
14548 0 /* Ignore count */,
14549 pending_break_support
,
14553 0 /* internal */, 0);
14557 ftrace_command (const char *arg
, int from_tty
)
14559 event_location_up location
= string_to_event_location (&arg
,
14561 create_breakpoint (get_current_arch (),
14563 NULL
, 0, arg
, 1 /* parse arg */,
14565 bp_fast_tracepoint
/* type_wanted */,
14566 0 /* Ignore count */,
14567 pending_break_support
,
14568 &tracepoint_breakpoint_ops
,
14571 0 /* internal */, 0);
14574 /* strace command implementation. Creates a static tracepoint. */
14577 strace_command (const char *arg
, int from_tty
)
14579 struct breakpoint_ops
*ops
;
14580 event_location_up location
;
14582 /* Decide if we are dealing with a static tracepoint marker (`-m'),
14583 or with a normal static tracepoint. */
14584 if (arg
&& startswith (arg
, "-m") && isspace (arg
[2]))
14586 ops
= &strace_marker_breakpoint_ops
;
14587 location
= new_linespec_location (&arg
, symbol_name_match_type::FULL
);
14591 ops
= &tracepoint_breakpoint_ops
;
14592 location
= string_to_event_location (&arg
, current_language
);
14595 create_breakpoint (get_current_arch (),
14597 NULL
, 0, arg
, 1 /* parse arg */,
14599 bp_static_tracepoint
/* type_wanted */,
14600 0 /* Ignore count */,
14601 pending_break_support
,
14605 0 /* internal */, 0);
14608 /* Set up a fake reader function that gets command lines from a linked
14609 list that was acquired during tracepoint uploading. */
14611 static struct uploaded_tp
*this_utp
;
14612 static int next_cmd
;
14615 read_uploaded_action (void)
14617 char *rslt
= nullptr;
14619 if (next_cmd
< this_utp
->cmd_strings
.size ())
14621 rslt
= this_utp
->cmd_strings
[next_cmd
].get ();
14628 /* Given information about a tracepoint as recorded on a target (which
14629 can be either a live system or a trace file), attempt to create an
14630 equivalent GDB tracepoint. This is not a reliable process, since
14631 the target does not necessarily have all the information used when
14632 the tracepoint was originally defined. */
14634 struct tracepoint
*
14635 create_tracepoint_from_upload (struct uploaded_tp
*utp
)
14637 const char *addr_str
;
14638 char small_buf
[100];
14639 struct tracepoint
*tp
;
14641 if (utp
->at_string
)
14642 addr_str
= utp
->at_string
.get ();
14645 /* In the absence of a source location, fall back to raw
14646 address. Since there is no way to confirm that the address
14647 means the same thing as when the trace was started, warn the
14649 warning (_("Uploaded tracepoint %d has no "
14650 "source location, using raw address"),
14652 xsnprintf (small_buf
, sizeof (small_buf
), "*%s", hex_string (utp
->addr
));
14653 addr_str
= small_buf
;
14656 /* There's not much we can do with a sequence of bytecodes. */
14657 if (utp
->cond
&& !utp
->cond_string
)
14658 warning (_("Uploaded tracepoint %d condition "
14659 "has no source form, ignoring it"),
14662 event_location_up location
= string_to_event_location (&addr_str
,
14664 if (!create_breakpoint (get_current_arch (),
14666 utp
->cond_string
.get (), -1, addr_str
,
14667 0 /* parse cond/thread */,
14669 utp
->type
/* type_wanted */,
14670 0 /* Ignore count */,
14671 pending_break_support
,
14672 &tracepoint_breakpoint_ops
,
14674 utp
->enabled
/* enabled */,
14676 CREATE_BREAKPOINT_FLAGS_INSERTED
))
14679 /* Get the tracepoint we just created. */
14680 tp
= get_tracepoint (tracepoint_count
);
14681 gdb_assert (tp
!= NULL
);
14685 xsnprintf (small_buf
, sizeof (small_buf
), "%d %d", utp
->pass
,
14688 trace_pass_command (small_buf
, 0);
14691 /* If we have uploaded versions of the original commands, set up a
14692 special-purpose "reader" function and call the usual command line
14693 reader, then pass the result to the breakpoint command-setting
14695 if (!utp
->cmd_strings
.empty ())
14697 counted_command_line cmd_list
;
14702 cmd_list
= read_command_lines_1 (read_uploaded_action
, 1, NULL
);
14704 breakpoint_set_commands (tp
, std::move (cmd_list
));
14706 else if (!utp
->actions
.empty ()
14707 || !utp
->step_actions
.empty ())
14708 warning (_("Uploaded tracepoint %d actions "
14709 "have no source form, ignoring them"),
14712 /* Copy any status information that might be available. */
14713 tp
->hit_count
= utp
->hit_count
;
14714 tp
->traceframe_usage
= utp
->traceframe_usage
;
14719 /* Print information on tracepoint number TPNUM_EXP, or all if
14723 info_tracepoints_command (const char *args
, int from_tty
)
14725 struct ui_out
*uiout
= current_uiout
;
14728 num_printed
= breakpoint_1 (args
, false, is_tracepoint
);
14730 if (num_printed
== 0)
14732 if (args
== NULL
|| *args
== '\0')
14733 uiout
->message ("No tracepoints.\n");
14735 uiout
->message ("No tracepoint matching '%s'.\n", args
);
14738 default_collect_info ();
14741 /* The 'enable trace' command enables tracepoints.
14742 Not supported by all targets. */
14744 enable_trace_command (const char *args
, int from_tty
)
14746 enable_command (args
, from_tty
);
14749 /* The 'disable trace' command disables tracepoints.
14750 Not supported by all targets. */
14752 disable_trace_command (const char *args
, int from_tty
)
14754 disable_command (args
, from_tty
);
14757 /* Remove a tracepoint (or all if no argument). */
14759 delete_trace_command (const char *arg
, int from_tty
)
14761 struct breakpoint
*b
, *b_tmp
;
14767 int breaks_to_delete
= 0;
14769 /* Delete all breakpoints if no argument.
14770 Do not delete internal or call-dummy breakpoints, these
14771 have to be deleted with an explicit breakpoint number
14773 ALL_TRACEPOINTS (b
)
14774 if (is_tracepoint (b
) && user_breakpoint_p (b
))
14776 breaks_to_delete
= 1;
14780 /* Ask user only if there are some breakpoints to delete. */
14782 || (breaks_to_delete
&& query (_("Delete all tracepoints? "))))
14784 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
14785 if (is_tracepoint (b
) && user_breakpoint_p (b
))
14786 delete_breakpoint (b
);
14790 map_breakpoint_numbers
14791 (arg
, [&] (breakpoint
*br
)
14793 iterate_over_related_breakpoints (br
, delete_breakpoint
);
14797 /* Helper function for trace_pass_command. */
14800 trace_pass_set_count (struct tracepoint
*tp
, int count
, int from_tty
)
14802 tp
->pass_count
= count
;
14803 gdb::observers::breakpoint_modified
.notify (tp
);
14805 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
14806 tp
->number
, count
);
14809 /* Set passcount for tracepoint.
14811 First command argument is passcount, second is tracepoint number.
14812 If tracepoint number omitted, apply to most recently defined.
14813 Also accepts special argument "all". */
14816 trace_pass_command (const char *args
, int from_tty
)
14818 struct tracepoint
*t1
;
14821 if (args
== 0 || *args
== 0)
14822 error (_("passcount command requires an "
14823 "argument (count + optional TP num)"));
14825 count
= strtoulst (args
, &args
, 10); /* Count comes first, then TP num. */
14827 args
= skip_spaces (args
);
14828 if (*args
&& strncasecmp (args
, "all", 3) == 0)
14830 struct breakpoint
*b
;
14832 args
+= 3; /* Skip special argument "all". */
14834 error (_("Junk at end of arguments."));
14836 ALL_TRACEPOINTS (b
)
14838 t1
= (struct tracepoint
*) b
;
14839 trace_pass_set_count (t1
, count
, from_tty
);
14842 else if (*args
== '\0')
14844 t1
= get_tracepoint_by_number (&args
, NULL
);
14846 trace_pass_set_count (t1
, count
, from_tty
);
14850 number_or_range_parser
parser (args
);
14851 while (!parser
.finished ())
14853 t1
= get_tracepoint_by_number (&args
, &parser
);
14855 trace_pass_set_count (t1
, count
, from_tty
);
14860 struct tracepoint
*
14861 get_tracepoint (int num
)
14863 struct breakpoint
*t
;
14865 ALL_TRACEPOINTS (t
)
14866 if (t
->number
== num
)
14867 return (struct tracepoint
*) t
;
14872 /* Find the tracepoint with the given target-side number (which may be
14873 different from the tracepoint number after disconnecting and
14876 struct tracepoint
*
14877 get_tracepoint_by_number_on_target (int num
)
14879 struct breakpoint
*b
;
14881 ALL_TRACEPOINTS (b
)
14883 struct tracepoint
*t
= (struct tracepoint
*) b
;
14885 if (t
->number_on_target
== num
)
14892 /* Utility: parse a tracepoint number and look it up in the list.
14893 If STATE is not NULL, use, get_number_or_range_state and ignore ARG.
14894 If the argument is missing, the most recent tracepoint
14895 (tracepoint_count) is returned. */
14897 struct tracepoint
*
14898 get_tracepoint_by_number (const char **arg
,
14899 number_or_range_parser
*parser
)
14901 struct breakpoint
*t
;
14903 const char *instring
= arg
== NULL
? NULL
: *arg
;
14905 if (parser
!= NULL
)
14907 gdb_assert (!parser
->finished ());
14908 tpnum
= parser
->get_number ();
14910 else if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
14911 tpnum
= tracepoint_count
;
14913 tpnum
= get_number (arg
);
14917 if (instring
&& *instring
)
14918 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
14921 printf_filtered (_("No previous tracepoint\n"));
14925 ALL_TRACEPOINTS (t
)
14926 if (t
->number
== tpnum
)
14928 return (struct tracepoint
*) t
;
14931 printf_unfiltered ("No tracepoint number %d.\n", tpnum
);
14936 print_recreate_thread (struct breakpoint
*b
, struct ui_file
*fp
)
14938 if (b
->thread
!= -1)
14939 fprintf_unfiltered (fp
, " thread %d", b
->thread
);
14942 fprintf_unfiltered (fp
, " task %d", b
->task
);
14944 fprintf_unfiltered (fp
, "\n");
14947 /* Save information on user settable breakpoints (watchpoints, etc) to
14948 a new script file named FILENAME. If FILTER is non-NULL, call it
14949 on each breakpoint and only include the ones for which it returns
14953 save_breakpoints (const char *filename
, int from_tty
,
14954 bool (*filter
) (const struct breakpoint
*))
14956 struct breakpoint
*tp
;
14958 int extra_trace_bits
= 0;
14960 if (filename
== 0 || *filename
== 0)
14961 error (_("Argument required (file name in which to save)"));
14963 /* See if we have anything to save. */
14964 ALL_BREAKPOINTS (tp
)
14966 /* Skip internal and momentary breakpoints. */
14967 if (!user_breakpoint_p (tp
))
14970 /* If we have a filter, only save the breakpoints it accepts. */
14971 if (filter
&& !filter (tp
))
14976 if (is_tracepoint (tp
))
14978 extra_trace_bits
= 1;
14980 /* We can stop searching. */
14987 warning (_("Nothing to save."));
14991 gdb::unique_xmalloc_ptr
<char> expanded_filename (tilde_expand (filename
));
14995 if (!fp
.open (expanded_filename
.get (), "w"))
14996 error (_("Unable to open file '%s' for saving (%s)"),
14997 expanded_filename
.get (), safe_strerror (errno
));
14999 if (extra_trace_bits
)
15000 save_trace_state_variables (&fp
);
15002 ALL_BREAKPOINTS (tp
)
15004 /* Skip internal and momentary breakpoints. */
15005 if (!user_breakpoint_p (tp
))
15008 /* If we have a filter, only save the breakpoints it accepts. */
15009 if (filter
&& !filter (tp
))
15012 tp
->ops
->print_recreate (tp
, &fp
);
15014 /* Note, we can't rely on tp->number for anything, as we can't
15015 assume the recreated breakpoint numbers will match. Use $bpnum
15018 if (tp
->cond_string
)
15019 fp
.printf (" condition $bpnum %s\n", tp
->cond_string
);
15021 if (tp
->ignore_count
)
15022 fp
.printf (" ignore $bpnum %d\n", tp
->ignore_count
);
15024 if (tp
->type
!= bp_dprintf
&& tp
->commands
)
15026 fp
.puts (" commands\n");
15028 current_uiout
->redirect (&fp
);
15031 print_command_lines (current_uiout
, tp
->commands
.get (), 2);
15033 catch (const gdb_exception
&ex
)
15035 current_uiout
->redirect (NULL
);
15039 current_uiout
->redirect (NULL
);
15040 fp
.puts (" end\n");
15043 if (tp
->enable_state
== bp_disabled
)
15044 fp
.puts ("disable $bpnum\n");
15046 /* If this is a multi-location breakpoint, check if the locations
15047 should be individually disabled. Watchpoint locations are
15048 special, and not user visible. */
15049 if (!is_watchpoint (tp
) && tp
->loc
&& tp
->loc
->next
)
15051 struct bp_location
*loc
;
15054 for (loc
= tp
->loc
; loc
!= NULL
; loc
= loc
->next
, n
++)
15056 fp
.printf ("disable $bpnum.%d\n", n
);
15060 if (extra_trace_bits
&& *default_collect
)
15061 fp
.printf ("set default-collect %s\n", default_collect
);
15064 printf_filtered (_("Saved to file '%s'.\n"), expanded_filename
.get ());
15067 /* The `save breakpoints' command. */
15070 save_breakpoints_command (const char *args
, int from_tty
)
15072 save_breakpoints (args
, from_tty
, NULL
);
15075 /* The `save tracepoints' command. */
15078 save_tracepoints_command (const char *args
, int from_tty
)
15080 save_breakpoints (args
, from_tty
, is_tracepoint
);
15083 /* Create a vector of all tracepoints. */
15085 std::vector
<breakpoint
*>
15086 all_tracepoints (void)
15088 std::vector
<breakpoint
*> tp_vec
;
15089 struct breakpoint
*tp
;
15091 ALL_TRACEPOINTS (tp
)
15093 tp_vec
.push_back (tp
);
15100 /* This help string is used to consolidate all the help string for specifying
15101 locations used by several commands. */
15103 #define LOCATION_HELP_STRING \
15104 "Linespecs are colon-separated lists of location parameters, such as\n\
15105 source filename, function name, label name, and line number.\n\
15106 Example: To specify the start of a label named \"the_top\" in the\n\
15107 function \"fact\" in the file \"factorial.c\", use\n\
15108 \"factorial.c:fact:the_top\".\n\
15110 Address locations begin with \"*\" and specify an exact address in the\n\
15111 program. Example: To specify the fourth byte past the start function\n\
15112 \"main\", use \"*main + 4\".\n\
15114 Explicit locations are similar to linespecs but use an option/argument\n\
15115 syntax to specify location parameters.\n\
15116 Example: To specify the start of the label named \"the_top\" in the\n\
15117 function \"fact\" in the file \"factorial.c\", use \"-source factorial.c\n\
15118 -function fact -label the_top\".\n\
15120 By default, a specified function is matched against the program's\n\
15121 functions in all scopes. For C++, this means in all namespaces and\n\
15122 classes. For Ada, this means in all packages. E.g., in C++,\n\
15123 \"func()\" matches \"A::func()\", \"A::B::func()\", etc. The\n\
15124 \"-qualified\" flag overrides this behavior, making GDB interpret the\n\
15125 specified name as a complete fully-qualified name instead."
15127 /* This help string is used for the break, hbreak, tbreak and thbreak
15128 commands. It is defined as a macro to prevent duplication.
15129 COMMAND should be a string constant containing the name of the
15132 #define BREAK_ARGS_HELP(command) \
15133 command" [PROBE_MODIFIER] [LOCATION] [thread THREADNUM] [if CONDITION]\n\
15134 PROBE_MODIFIER shall be present if the command is to be placed in a\n\
15135 probe point. Accepted values are `-probe' (for a generic, automatically\n\
15136 guessed probe type), `-probe-stap' (for a SystemTap probe) or \n\
15137 `-probe-dtrace' (for a DTrace probe).\n\
15138 LOCATION may be a linespec, address, or explicit location as described\n\
15141 With no LOCATION, uses current execution address of the selected\n\
15142 stack frame. This is useful for breaking on return to a stack frame.\n\
15144 THREADNUM is the number from \"info threads\".\n\
15145 CONDITION is a boolean expression.\n\
15146 \n" LOCATION_HELP_STRING "\n\n\
15147 Multiple breakpoints at one place are permitted, and useful if their\n\
15148 conditions are different.\n\
15150 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
15152 /* List of subcommands for "catch". */
15153 static struct cmd_list_element
*catch_cmdlist
;
15155 /* List of subcommands for "tcatch". */
15156 static struct cmd_list_element
*tcatch_cmdlist
;
15159 add_catch_command (const char *name
, const char *docstring
,
15160 cmd_const_sfunc_ftype
*sfunc
,
15161 completer_ftype
*completer
,
15162 void *user_data_catch
,
15163 void *user_data_tcatch
)
15165 struct cmd_list_element
*command
;
15167 command
= add_cmd (name
, class_breakpoint
, docstring
,
15169 set_cmd_sfunc (command
, sfunc
);
15170 set_cmd_context (command
, user_data_catch
);
15171 set_cmd_completer (command
, completer
);
15173 command
= add_cmd (name
, class_breakpoint
, docstring
,
15175 set_cmd_sfunc (command
, sfunc
);
15176 set_cmd_context (command
, user_data_tcatch
);
15177 set_cmd_completer (command
, completer
);
15180 struct breakpoint
*
15181 iterate_over_breakpoints (gdb::function_view
<bool (breakpoint
*)> callback
)
15183 struct breakpoint
*b
, *b_tmp
;
15185 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
15194 /* Zero if any of the breakpoint's locations could be a location where
15195 functions have been inlined, nonzero otherwise. */
15198 is_non_inline_function (struct breakpoint
*b
)
15200 /* The shared library event breakpoint is set on the address of a
15201 non-inline function. */
15202 if (b
->type
== bp_shlib_event
)
15208 /* Nonzero if the specified PC cannot be a location where functions
15209 have been inlined. */
15212 pc_at_non_inline_function (const address_space
*aspace
, CORE_ADDR pc
,
15213 const struct target_waitstatus
*ws
)
15215 struct breakpoint
*b
;
15216 struct bp_location
*bl
;
15218 ALL_BREAKPOINTS (b
)
15220 if (!is_non_inline_function (b
))
15223 for (bl
= b
->loc
; bl
!= NULL
; bl
= bl
->next
)
15225 if (!bl
->shlib_disabled
15226 && bpstat_check_location (bl
, aspace
, pc
, ws
))
15234 /* Remove any references to OBJFILE which is going to be freed. */
15237 breakpoint_free_objfile (struct objfile
*objfile
)
15239 struct bp_location
**locp
, *loc
;
15241 ALL_BP_LOCATIONS (loc
, locp
)
15242 if (loc
->symtab
!= NULL
&& SYMTAB_OBJFILE (loc
->symtab
) == objfile
)
15243 loc
->symtab
= NULL
;
15247 initialize_breakpoint_ops (void)
15249 static int initialized
= 0;
15251 struct breakpoint_ops
*ops
;
15257 /* The breakpoint_ops structure to be inherit by all kinds of
15258 breakpoints (real breakpoints, i.e., user "break" breakpoints,
15259 internal and momentary breakpoints, etc.). */
15260 ops
= &bkpt_base_breakpoint_ops
;
15261 *ops
= base_breakpoint_ops
;
15262 ops
->re_set
= bkpt_re_set
;
15263 ops
->insert_location
= bkpt_insert_location
;
15264 ops
->remove_location
= bkpt_remove_location
;
15265 ops
->breakpoint_hit
= bkpt_breakpoint_hit
;
15266 ops
->create_sals_from_location
= bkpt_create_sals_from_location
;
15267 ops
->create_breakpoints_sal
= bkpt_create_breakpoints_sal
;
15268 ops
->decode_location
= bkpt_decode_location
;
15270 /* The breakpoint_ops structure to be used in regular breakpoints. */
15271 ops
= &bkpt_breakpoint_ops
;
15272 *ops
= bkpt_base_breakpoint_ops
;
15273 ops
->re_set
= bkpt_re_set
;
15274 ops
->resources_needed
= bkpt_resources_needed
;
15275 ops
->print_it
= bkpt_print_it
;
15276 ops
->print_mention
= bkpt_print_mention
;
15277 ops
->print_recreate
= bkpt_print_recreate
;
15279 /* Ranged breakpoints. */
15280 ops
= &ranged_breakpoint_ops
;
15281 *ops
= bkpt_breakpoint_ops
;
15282 ops
->breakpoint_hit
= breakpoint_hit_ranged_breakpoint
;
15283 ops
->resources_needed
= resources_needed_ranged_breakpoint
;
15284 ops
->print_it
= print_it_ranged_breakpoint
;
15285 ops
->print_one
= print_one_ranged_breakpoint
;
15286 ops
->print_one_detail
= print_one_detail_ranged_breakpoint
;
15287 ops
->print_mention
= print_mention_ranged_breakpoint
;
15288 ops
->print_recreate
= print_recreate_ranged_breakpoint
;
15290 /* Internal breakpoints. */
15291 ops
= &internal_breakpoint_ops
;
15292 *ops
= bkpt_base_breakpoint_ops
;
15293 ops
->re_set
= internal_bkpt_re_set
;
15294 ops
->check_status
= internal_bkpt_check_status
;
15295 ops
->print_it
= internal_bkpt_print_it
;
15296 ops
->print_mention
= internal_bkpt_print_mention
;
15298 /* Momentary breakpoints. */
15299 ops
= &momentary_breakpoint_ops
;
15300 *ops
= bkpt_base_breakpoint_ops
;
15301 ops
->re_set
= momentary_bkpt_re_set
;
15302 ops
->check_status
= momentary_bkpt_check_status
;
15303 ops
->print_it
= momentary_bkpt_print_it
;
15304 ops
->print_mention
= momentary_bkpt_print_mention
;
15306 /* Probe breakpoints. */
15307 ops
= &bkpt_probe_breakpoint_ops
;
15308 *ops
= bkpt_breakpoint_ops
;
15309 ops
->insert_location
= bkpt_probe_insert_location
;
15310 ops
->remove_location
= bkpt_probe_remove_location
;
15311 ops
->create_sals_from_location
= bkpt_probe_create_sals_from_location
;
15312 ops
->decode_location
= bkpt_probe_decode_location
;
15315 ops
= &watchpoint_breakpoint_ops
;
15316 *ops
= base_breakpoint_ops
;
15317 ops
->re_set
= re_set_watchpoint
;
15318 ops
->insert_location
= insert_watchpoint
;
15319 ops
->remove_location
= remove_watchpoint
;
15320 ops
->breakpoint_hit
= breakpoint_hit_watchpoint
;
15321 ops
->check_status
= check_status_watchpoint
;
15322 ops
->resources_needed
= resources_needed_watchpoint
;
15323 ops
->works_in_software_mode
= works_in_software_mode_watchpoint
;
15324 ops
->print_it
= print_it_watchpoint
;
15325 ops
->print_mention
= print_mention_watchpoint
;
15326 ops
->print_recreate
= print_recreate_watchpoint
;
15327 ops
->explains_signal
= explains_signal_watchpoint
;
15329 /* Masked watchpoints. */
15330 ops
= &masked_watchpoint_breakpoint_ops
;
15331 *ops
= watchpoint_breakpoint_ops
;
15332 ops
->insert_location
= insert_masked_watchpoint
;
15333 ops
->remove_location
= remove_masked_watchpoint
;
15334 ops
->resources_needed
= resources_needed_masked_watchpoint
;
15335 ops
->works_in_software_mode
= works_in_software_mode_masked_watchpoint
;
15336 ops
->print_it
= print_it_masked_watchpoint
;
15337 ops
->print_one_detail
= print_one_detail_masked_watchpoint
;
15338 ops
->print_mention
= print_mention_masked_watchpoint
;
15339 ops
->print_recreate
= print_recreate_masked_watchpoint
;
15342 ops
= &tracepoint_breakpoint_ops
;
15343 *ops
= base_breakpoint_ops
;
15344 ops
->re_set
= tracepoint_re_set
;
15345 ops
->breakpoint_hit
= tracepoint_breakpoint_hit
;
15346 ops
->print_one_detail
= tracepoint_print_one_detail
;
15347 ops
->print_mention
= tracepoint_print_mention
;
15348 ops
->print_recreate
= tracepoint_print_recreate
;
15349 ops
->create_sals_from_location
= tracepoint_create_sals_from_location
;
15350 ops
->create_breakpoints_sal
= tracepoint_create_breakpoints_sal
;
15351 ops
->decode_location
= tracepoint_decode_location
;
15353 /* Probe tracepoints. */
15354 ops
= &tracepoint_probe_breakpoint_ops
;
15355 *ops
= tracepoint_breakpoint_ops
;
15356 ops
->create_sals_from_location
= tracepoint_probe_create_sals_from_location
;
15357 ops
->decode_location
= tracepoint_probe_decode_location
;
15359 /* Static tracepoints with marker (`-m'). */
15360 ops
= &strace_marker_breakpoint_ops
;
15361 *ops
= tracepoint_breakpoint_ops
;
15362 ops
->create_sals_from_location
= strace_marker_create_sals_from_location
;
15363 ops
->create_breakpoints_sal
= strace_marker_create_breakpoints_sal
;
15364 ops
->decode_location
= strace_marker_decode_location
;
15366 /* Fork catchpoints. */
15367 ops
= &catch_fork_breakpoint_ops
;
15368 *ops
= base_breakpoint_ops
;
15369 ops
->insert_location
= insert_catch_fork
;
15370 ops
->remove_location
= remove_catch_fork
;
15371 ops
->breakpoint_hit
= breakpoint_hit_catch_fork
;
15372 ops
->print_it
= print_it_catch_fork
;
15373 ops
->print_one
= print_one_catch_fork
;
15374 ops
->print_mention
= print_mention_catch_fork
;
15375 ops
->print_recreate
= print_recreate_catch_fork
;
15377 /* Vfork catchpoints. */
15378 ops
= &catch_vfork_breakpoint_ops
;
15379 *ops
= base_breakpoint_ops
;
15380 ops
->insert_location
= insert_catch_vfork
;
15381 ops
->remove_location
= remove_catch_vfork
;
15382 ops
->breakpoint_hit
= breakpoint_hit_catch_vfork
;
15383 ops
->print_it
= print_it_catch_vfork
;
15384 ops
->print_one
= print_one_catch_vfork
;
15385 ops
->print_mention
= print_mention_catch_vfork
;
15386 ops
->print_recreate
= print_recreate_catch_vfork
;
15388 /* Exec catchpoints. */
15389 ops
= &catch_exec_breakpoint_ops
;
15390 *ops
= base_breakpoint_ops
;
15391 ops
->insert_location
= insert_catch_exec
;
15392 ops
->remove_location
= remove_catch_exec
;
15393 ops
->breakpoint_hit
= breakpoint_hit_catch_exec
;
15394 ops
->print_it
= print_it_catch_exec
;
15395 ops
->print_one
= print_one_catch_exec
;
15396 ops
->print_mention
= print_mention_catch_exec
;
15397 ops
->print_recreate
= print_recreate_catch_exec
;
15399 /* Solib-related catchpoints. */
15400 ops
= &catch_solib_breakpoint_ops
;
15401 *ops
= base_breakpoint_ops
;
15402 ops
->insert_location
= insert_catch_solib
;
15403 ops
->remove_location
= remove_catch_solib
;
15404 ops
->breakpoint_hit
= breakpoint_hit_catch_solib
;
15405 ops
->check_status
= check_status_catch_solib
;
15406 ops
->print_it
= print_it_catch_solib
;
15407 ops
->print_one
= print_one_catch_solib
;
15408 ops
->print_mention
= print_mention_catch_solib
;
15409 ops
->print_recreate
= print_recreate_catch_solib
;
15411 ops
= &dprintf_breakpoint_ops
;
15412 *ops
= bkpt_base_breakpoint_ops
;
15413 ops
->re_set
= dprintf_re_set
;
15414 ops
->resources_needed
= bkpt_resources_needed
;
15415 ops
->print_it
= bkpt_print_it
;
15416 ops
->print_mention
= bkpt_print_mention
;
15417 ops
->print_recreate
= dprintf_print_recreate
;
15418 ops
->after_condition_true
= dprintf_after_condition_true
;
15419 ops
->breakpoint_hit
= dprintf_breakpoint_hit
;
15422 /* Chain containing all defined "enable breakpoint" subcommands. */
15424 static struct cmd_list_element
*enablebreaklist
= NULL
;
15426 /* See breakpoint.h. */
15428 cmd_list_element
*commands_cmd_element
= nullptr;
15430 void _initialize_breakpoint ();
15432 _initialize_breakpoint ()
15434 struct cmd_list_element
*c
;
15436 initialize_breakpoint_ops ();
15438 gdb::observers::solib_unloaded
.attach (disable_breakpoints_in_unloaded_shlib
);
15439 gdb::observers::free_objfile
.attach (disable_breakpoints_in_freed_objfile
);
15440 gdb::observers::memory_changed
.attach (invalidate_bp_value_on_memory_change
);
15442 breakpoint_chain
= 0;
15443 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
15444 before a breakpoint is set. */
15445 breakpoint_count
= 0;
15447 tracepoint_count
= 0;
15449 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
15450 Set ignore-count of breakpoint number N to COUNT.\n\
15451 Usage is `ignore N COUNT'."));
15453 commands_cmd_element
= add_com ("commands", class_breakpoint
,
15454 commands_command
, _("\
15455 Set commands to be executed when the given breakpoints are hit.\n\
15456 Give a space-separated breakpoint list as argument after \"commands\".\n\
15457 A list element can be a breakpoint number (e.g. `5') or a range of numbers\n\
15459 With no argument, the targeted breakpoint is the last one set.\n\
15460 The commands themselves follow starting on the next line.\n\
15461 Type a line containing \"end\" to indicate the end of them.\n\
15462 Give \"silent\" as the first line to make the breakpoint silent;\n\
15463 then no output is printed when it is hit, except what the commands print."));
15465 c
= add_com ("condition", class_breakpoint
, condition_command
, _("\
15466 Specify breakpoint number N to break only if COND is true.\n\
15467 Usage is `condition N COND', where N is an integer and COND is an\n\
15468 expression to be evaluated whenever breakpoint N is reached."));
15469 set_cmd_completer (c
, condition_completer
);
15471 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
15472 Set a temporary breakpoint.\n\
15473 Like \"break\" except the breakpoint is only temporary,\n\
15474 so it will be deleted when hit. Equivalent to \"break\" followed\n\
15475 by using \"enable delete\" on the breakpoint number.\n\
15477 BREAK_ARGS_HELP ("tbreak")));
15478 set_cmd_completer (c
, location_completer
);
15480 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
15481 Set a hardware assisted breakpoint.\n\
15482 Like \"break\" except the breakpoint requires hardware support,\n\
15483 some target hardware may not have this support.\n\
15485 BREAK_ARGS_HELP ("hbreak")));
15486 set_cmd_completer (c
, location_completer
);
15488 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
15489 Set a temporary hardware assisted breakpoint.\n\
15490 Like \"hbreak\" except the breakpoint is only temporary,\n\
15491 so it will be deleted when hit.\n\
15493 BREAK_ARGS_HELP ("thbreak")));
15494 set_cmd_completer (c
, location_completer
);
15496 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
15497 Enable all or some breakpoints.\n\
15498 Usage: enable [BREAKPOINTNUM]...\n\
15499 Give breakpoint numbers (separated by spaces) as arguments.\n\
15500 With no subcommand, breakpoints are enabled until you command otherwise.\n\
15501 This is used to cancel the effect of the \"disable\" command.\n\
15502 With a subcommand you can enable temporarily."),
15503 &enablelist
, "enable ", 1, &cmdlist
);
15505 add_com_alias ("en", "enable", class_breakpoint
, 1);
15507 add_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
15508 Enable all or some breakpoints.\n\
15509 Usage: enable breakpoints [BREAKPOINTNUM]...\n\
15510 Give breakpoint numbers (separated by spaces) as arguments.\n\
15511 This is used to cancel the effect of the \"disable\" command.\n\
15512 May be abbreviated to simply \"enable\"."),
15513 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
15515 add_cmd ("once", no_class
, enable_once_command
, _("\
15516 Enable some breakpoints for one hit.\n\
15517 Usage: enable breakpoints once BREAKPOINTNUM...\n\
15518 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
15521 add_cmd ("delete", no_class
, enable_delete_command
, _("\
15522 Enable some breakpoints and delete when hit.\n\
15523 Usage: enable breakpoints delete BREAKPOINTNUM...\n\
15524 If a breakpoint is hit while enabled in this fashion, it is deleted."),
15527 add_cmd ("count", no_class
, enable_count_command
, _("\
15528 Enable some breakpoints for COUNT hits.\n\
15529 Usage: enable breakpoints count COUNT BREAKPOINTNUM...\n\
15530 If a breakpoint is hit while enabled in this fashion,\n\
15531 the count is decremented; when it reaches zero, the breakpoint is disabled."),
15534 add_cmd ("delete", no_class
, enable_delete_command
, _("\
15535 Enable some breakpoints and delete when hit.\n\
15536 Usage: enable delete BREAKPOINTNUM...\n\
15537 If a breakpoint is hit while enabled in this fashion, it is deleted."),
15540 add_cmd ("once", no_class
, enable_once_command
, _("\
15541 Enable some breakpoints for one hit.\n\
15542 Usage: enable once BREAKPOINTNUM...\n\
15543 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
15546 add_cmd ("count", no_class
, enable_count_command
, _("\
15547 Enable some breakpoints for COUNT hits.\n\
15548 Usage: enable count COUNT BREAKPOINTNUM...\n\
15549 If a breakpoint is hit while enabled in this fashion,\n\
15550 the count is decremented; when it reaches zero, the breakpoint is disabled."),
15553 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
15554 Disable all or some breakpoints.\n\
15555 Usage: disable [BREAKPOINTNUM]...\n\
15556 Arguments are breakpoint numbers with spaces in between.\n\
15557 To disable all breakpoints, give no argument.\n\
15558 A disabled breakpoint is not forgotten, but has no effect until re-enabled."),
15559 &disablelist
, "disable ", 1, &cmdlist
);
15560 add_com_alias ("dis", "disable", class_breakpoint
, 1);
15561 add_com_alias ("disa", "disable", class_breakpoint
, 1);
15563 add_cmd ("breakpoints", class_breakpoint
, disable_command
, _("\
15564 Disable all or some breakpoints.\n\
15565 Usage: disable breakpoints [BREAKPOINTNUM]...\n\
15566 Arguments are breakpoint numbers with spaces in between.\n\
15567 To disable all breakpoints, give no argument.\n\
15568 A disabled breakpoint is not forgotten, but has no effect until re-enabled.\n\
15569 This command may be abbreviated \"disable\"."),
15572 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
15573 Delete all or some breakpoints.\n\
15574 Usage: delete [BREAKPOINTNUM]...\n\
15575 Arguments are breakpoint numbers with spaces in between.\n\
15576 To delete all breakpoints, give no argument.\n\
15578 Also a prefix command for deletion of other GDB objects."),
15579 &deletelist
, "delete ", 1, &cmdlist
);
15580 add_com_alias ("d", "delete", class_breakpoint
, 1);
15581 add_com_alias ("del", "delete", class_breakpoint
, 1);
15583 add_cmd ("breakpoints", class_breakpoint
, delete_command
, _("\
15584 Delete all or some breakpoints or auto-display expressions.\n\
15585 Usage: delete breakpoints [BREAKPOINTNUM]...\n\
15586 Arguments are breakpoint numbers with spaces in between.\n\
15587 To delete all breakpoints, give no argument.\n\
15588 This command may be abbreviated \"delete\"."),
15591 add_com ("clear", class_breakpoint
, clear_command
, _("\
15592 Clear breakpoint at specified location.\n\
15593 Argument may be a linespec, explicit, or address location as described below.\n\
15595 With no argument, clears all breakpoints in the line that the selected frame\n\
15596 is executing in.\n"
15597 "\n" LOCATION_HELP_STRING
"\n\n\
15598 See also the \"delete\" command which clears breakpoints by number."));
15599 add_com_alias ("cl", "clear", class_breakpoint
, 1);
15601 c
= add_com ("break", class_breakpoint
, break_command
, _("\
15602 Set breakpoint at specified location.\n"
15603 BREAK_ARGS_HELP ("break")));
15604 set_cmd_completer (c
, location_completer
);
15606 add_com_alias ("b", "break", class_run
, 1);
15607 add_com_alias ("br", "break", class_run
, 1);
15608 add_com_alias ("bre", "break", class_run
, 1);
15609 add_com_alias ("brea", "break", class_run
, 1);
15613 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
15614 Break in function/address or break at a line in the current file."),
15615 &stoplist
, "stop ", 1, &cmdlist
);
15616 add_cmd ("in", class_breakpoint
, stopin_command
,
15617 _("Break in function or address."), &stoplist
);
15618 add_cmd ("at", class_breakpoint
, stopat_command
,
15619 _("Break at a line in the current file."), &stoplist
);
15620 add_com ("status", class_info
, info_breakpoints_command
, _("\
15621 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
15622 The \"Type\" column indicates one of:\n\
15623 \tbreakpoint - normal breakpoint\n\
15624 \twatchpoint - watchpoint\n\
15625 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15626 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
15627 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
15628 address and file/line number respectively.\n\
15630 Convenience variable \"$_\" and default examine address for \"x\"\n\
15631 are set to the address of the last breakpoint listed unless the command\n\
15632 is prefixed with \"server \".\n\n\
15633 Convenience variable \"$bpnum\" contains the number of the last\n\
15634 breakpoint set."));
15637 add_info ("breakpoints", info_breakpoints_command
, _("\
15638 Status of specified breakpoints (all user-settable breakpoints if no argument).\n\
15639 The \"Type\" column indicates one of:\n\
15640 \tbreakpoint - normal breakpoint\n\
15641 \twatchpoint - watchpoint\n\
15642 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15643 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
15644 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
15645 address and file/line number respectively.\n\
15647 Convenience variable \"$_\" and default examine address for \"x\"\n\
15648 are set to the address of the last breakpoint listed unless the command\n\
15649 is prefixed with \"server \".\n\n\
15650 Convenience variable \"$bpnum\" contains the number of the last\n\
15651 breakpoint set."));
15653 add_info_alias ("b", "breakpoints", 1);
15655 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
15656 Status of all breakpoints, or breakpoint number NUMBER.\n\
15657 The \"Type\" column indicates one of:\n\
15658 \tbreakpoint - normal breakpoint\n\
15659 \twatchpoint - watchpoint\n\
15660 \tlongjmp - internal breakpoint used to step through longjmp()\n\
15661 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
15662 \tuntil - internal breakpoint used by the \"until\" command\n\
15663 \tfinish - internal breakpoint used by the \"finish\" command\n\
15664 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15665 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
15666 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
15667 address and file/line number respectively.\n\
15669 Convenience variable \"$_\" and default examine address for \"x\"\n\
15670 are set to the address of the last breakpoint listed unless the command\n\
15671 is prefixed with \"server \".\n\n\
15672 Convenience variable \"$bpnum\" contains the number of the last\n\
15674 &maintenanceinfolist
);
15676 add_basic_prefix_cmd ("catch", class_breakpoint
, _("\
15677 Set catchpoints to catch events."),
15678 &catch_cmdlist
, "catch ",
15679 0/*allow-unknown*/, &cmdlist
);
15681 add_basic_prefix_cmd ("tcatch", class_breakpoint
, _("\
15682 Set temporary catchpoints to catch events."),
15683 &tcatch_cmdlist
, "tcatch ",
15684 0/*allow-unknown*/, &cmdlist
);
15686 add_catch_command ("fork", _("Catch calls to fork."),
15687 catch_fork_command_1
,
15689 (void *) (uintptr_t) catch_fork_permanent
,
15690 (void *) (uintptr_t) catch_fork_temporary
);
15691 add_catch_command ("vfork", _("Catch calls to vfork."),
15692 catch_fork_command_1
,
15694 (void *) (uintptr_t) catch_vfork_permanent
,
15695 (void *) (uintptr_t) catch_vfork_temporary
);
15696 add_catch_command ("exec", _("Catch calls to exec."),
15697 catch_exec_command_1
,
15701 add_catch_command ("load", _("Catch loads of shared libraries.\n\
15702 Usage: catch load [REGEX]\n\
15703 If REGEX is given, only stop for libraries matching the regular expression."),
15704 catch_load_command_1
,
15708 add_catch_command ("unload", _("Catch unloads of shared libraries.\n\
15709 Usage: catch unload [REGEX]\n\
15710 If REGEX is given, only stop for libraries matching the regular expression."),
15711 catch_unload_command_1
,
15716 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
15717 Set a watchpoint for an expression.\n\
15718 Usage: watch [-l|-location] EXPRESSION\n\
15719 A watchpoint stops execution of your program whenever the value of\n\
15720 an expression changes.\n\
15721 If -l or -location is given, this evaluates EXPRESSION and watches\n\
15722 the memory to which it refers."));
15723 set_cmd_completer (c
, expression_completer
);
15725 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
15726 Set a read watchpoint for an expression.\n\
15727 Usage: rwatch [-l|-location] EXPRESSION\n\
15728 A watchpoint stops execution of your program whenever the value of\n\
15729 an expression is read.\n\
15730 If -l or -location is given, this evaluates EXPRESSION and watches\n\
15731 the memory to which it refers."));
15732 set_cmd_completer (c
, expression_completer
);
15734 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
15735 Set a watchpoint for an expression.\n\
15736 Usage: awatch [-l|-location] EXPRESSION\n\
15737 A watchpoint stops execution of your program whenever the value of\n\
15738 an expression is either read or written.\n\
15739 If -l or -location is given, this evaluates EXPRESSION and watches\n\
15740 the memory to which it refers."));
15741 set_cmd_completer (c
, expression_completer
);
15743 add_info ("watchpoints", info_watchpoints_command
, _("\
15744 Status of specified watchpoints (all watchpoints if no argument)."));
15746 /* XXX: cagney/2005-02-23: This should be a boolean, and should
15747 respond to changes - contrary to the description. */
15748 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
15749 &can_use_hw_watchpoints
, _("\
15750 Set debugger's willingness to use watchpoint hardware."), _("\
15751 Show debugger's willingness to use watchpoint hardware."), _("\
15752 If zero, gdb will not use hardware for new watchpoints, even if\n\
15753 such is available. (However, any hardware watchpoints that were\n\
15754 created before setting this to nonzero, will continue to use watchpoint\n\
15757 show_can_use_hw_watchpoints
,
15758 &setlist
, &showlist
);
15760 can_use_hw_watchpoints
= 1;
15762 /* Tracepoint manipulation commands. */
15764 c
= add_com ("trace", class_breakpoint
, trace_command
, _("\
15765 Set a tracepoint at specified location.\n\
15767 BREAK_ARGS_HELP ("trace") "\n\
15768 Do \"help tracepoints\" for info on other tracepoint commands."));
15769 set_cmd_completer (c
, location_completer
);
15771 add_com_alias ("tp", "trace", class_breakpoint
, 0);
15772 add_com_alias ("tr", "trace", class_breakpoint
, 1);
15773 add_com_alias ("tra", "trace", class_breakpoint
, 1);
15774 add_com_alias ("trac", "trace", class_breakpoint
, 1);
15776 c
= add_com ("ftrace", class_breakpoint
, ftrace_command
, _("\
15777 Set a fast tracepoint at specified location.\n\
15779 BREAK_ARGS_HELP ("ftrace") "\n\
15780 Do \"help tracepoints\" for info on other tracepoint commands."));
15781 set_cmd_completer (c
, location_completer
);
15783 c
= add_com ("strace", class_breakpoint
, strace_command
, _("\
15784 Set a static tracepoint at location or marker.\n\
15786 strace [LOCATION] [if CONDITION]\n\
15787 LOCATION may be a linespec, explicit, or address location (described below) \n\
15788 or -m MARKER_ID.\n\n\
15789 If a marker id is specified, probe the marker with that name. With\n\
15790 no LOCATION, uses current execution address of the selected stack frame.\n\
15791 Static tracepoints accept an extra collect action -- ``collect $_sdata''.\n\
15792 This collects arbitrary user data passed in the probe point call to the\n\
15793 tracing library. You can inspect it when analyzing the trace buffer,\n\
15794 by printing the $_sdata variable like any other convenience variable.\n\
15796 CONDITION is a boolean expression.\n\
15797 \n" LOCATION_HELP_STRING
"\n\n\
15798 Multiple tracepoints at one place are permitted, and useful if their\n\
15799 conditions are different.\n\
15801 Do \"help breakpoints\" for info on other commands dealing with breakpoints.\n\
15802 Do \"help tracepoints\" for info on other tracepoint commands."));
15803 set_cmd_completer (c
, location_completer
);
15805 add_info ("tracepoints", info_tracepoints_command
, _("\
15806 Status of specified tracepoints (all tracepoints if no argument).\n\
15807 Convenience variable \"$tpnum\" contains the number of the\n\
15808 last tracepoint set."));
15810 add_info_alias ("tp", "tracepoints", 1);
15812 add_cmd ("tracepoints", class_trace
, delete_trace_command
, _("\
15813 Delete specified tracepoints.\n\
15814 Arguments are tracepoint numbers, separated by spaces.\n\
15815 No argument means delete all tracepoints."),
15817 add_alias_cmd ("tr", "tracepoints", class_trace
, 1, &deletelist
);
15819 c
= add_cmd ("tracepoints", class_trace
, disable_trace_command
, _("\
15820 Disable specified tracepoints.\n\
15821 Arguments are tracepoint numbers, separated by spaces.\n\
15822 No argument means disable all tracepoints."),
15824 deprecate_cmd (c
, "disable");
15826 c
= add_cmd ("tracepoints", class_trace
, enable_trace_command
, _("\
15827 Enable specified tracepoints.\n\
15828 Arguments are tracepoint numbers, separated by spaces.\n\
15829 No argument means enable all tracepoints."),
15831 deprecate_cmd (c
, "enable");
15833 add_com ("passcount", class_trace
, trace_pass_command
, _("\
15834 Set the passcount for a tracepoint.\n\
15835 The trace will end when the tracepoint has been passed 'count' times.\n\
15836 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
15837 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
15839 add_basic_prefix_cmd ("save", class_breakpoint
,
15840 _("Save breakpoint definitions as a script."),
15841 &save_cmdlist
, "save ",
15842 0/*allow-unknown*/, &cmdlist
);
15844 c
= add_cmd ("breakpoints", class_breakpoint
, save_breakpoints_command
, _("\
15845 Save current breakpoint definitions as a script.\n\
15846 This includes all types of breakpoints (breakpoints, watchpoints,\n\
15847 catchpoints, tracepoints). Use the 'source' command in another debug\n\
15848 session to restore them."),
15850 set_cmd_completer (c
, filename_completer
);
15852 c
= add_cmd ("tracepoints", class_trace
, save_tracepoints_command
, _("\
15853 Save current tracepoint definitions as a script.\n\
15854 Use the 'source' command in another debug session to restore them."),
15856 set_cmd_completer (c
, filename_completer
);
15858 c
= add_com_alias ("save-tracepoints", "save tracepoints", class_trace
, 0);
15859 deprecate_cmd (c
, "save tracepoints");
15861 add_basic_prefix_cmd ("breakpoint", class_maintenance
, _("\
15862 Breakpoint specific settings.\n\
15863 Configure various breakpoint-specific variables such as\n\
15864 pending breakpoint behavior."),
15865 &breakpoint_set_cmdlist
, "set breakpoint ",
15866 0/*allow-unknown*/, &setlist
);
15867 add_show_prefix_cmd ("breakpoint", class_maintenance
, _("\
15868 Breakpoint specific settings.\n\
15869 Configure various breakpoint-specific variables such as\n\
15870 pending breakpoint behavior."),
15871 &breakpoint_show_cmdlist
, "show breakpoint ",
15872 0/*allow-unknown*/, &showlist
);
15874 add_setshow_auto_boolean_cmd ("pending", no_class
,
15875 &pending_break_support
, _("\
15876 Set debugger's behavior regarding pending breakpoints."), _("\
15877 Show debugger's behavior regarding pending breakpoints."), _("\
15878 If on, an unrecognized breakpoint location will cause gdb to create a\n\
15879 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
15880 an error. If auto, an unrecognized breakpoint location results in a\n\
15881 user-query to see if a pending breakpoint should be created."),
15883 show_pending_break_support
,
15884 &breakpoint_set_cmdlist
,
15885 &breakpoint_show_cmdlist
);
15887 pending_break_support
= AUTO_BOOLEAN_AUTO
;
15889 add_setshow_boolean_cmd ("auto-hw", no_class
,
15890 &automatic_hardware_breakpoints
, _("\
15891 Set automatic usage of hardware breakpoints."), _("\
15892 Show automatic usage of hardware breakpoints."), _("\
15893 If set, the debugger will automatically use hardware breakpoints for\n\
15894 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
15895 a warning will be emitted for such breakpoints."),
15897 show_automatic_hardware_breakpoints
,
15898 &breakpoint_set_cmdlist
,
15899 &breakpoint_show_cmdlist
);
15901 add_setshow_boolean_cmd ("always-inserted", class_support
,
15902 &always_inserted_mode
, _("\
15903 Set mode for inserting breakpoints."), _("\
15904 Show mode for inserting breakpoints."), _("\
15905 When this mode is on, breakpoints are inserted immediately as soon as\n\
15906 they're created, kept inserted even when execution stops, and removed\n\
15907 only when the user deletes them. When this mode is off (the default),\n\
15908 breakpoints are inserted only when execution continues, and removed\n\
15909 when execution stops."),
15911 &show_always_inserted_mode
,
15912 &breakpoint_set_cmdlist
,
15913 &breakpoint_show_cmdlist
);
15915 add_setshow_enum_cmd ("condition-evaluation", class_breakpoint
,
15916 condition_evaluation_enums
,
15917 &condition_evaluation_mode_1
, _("\
15918 Set mode of breakpoint condition evaluation."), _("\
15919 Show mode of breakpoint condition evaluation."), _("\
15920 When this is set to \"host\", breakpoint conditions will be\n\
15921 evaluated on the host's side by GDB. When it is set to \"target\",\n\
15922 breakpoint conditions will be downloaded to the target (if the target\n\
15923 supports such feature) and conditions will be evaluated on the target's side.\n\
15924 If this is set to \"auto\" (default), this will be automatically set to\n\
15925 \"target\" if it supports condition evaluation, otherwise it will\n\
15926 be set to \"gdb\""),
15927 &set_condition_evaluation_mode
,
15928 &show_condition_evaluation_mode
,
15929 &breakpoint_set_cmdlist
,
15930 &breakpoint_show_cmdlist
);
15932 add_com ("break-range", class_breakpoint
, break_range_command
, _("\
15933 Set a breakpoint for an address range.\n\
15934 break-range START-LOCATION, END-LOCATION\n\
15935 where START-LOCATION and END-LOCATION can be one of the following:\n\
15936 LINENUM, for that line in the current file,\n\
15937 FILE:LINENUM, for that line in that file,\n\
15938 +OFFSET, for that number of lines after the current line\n\
15939 or the start of the range\n\
15940 FUNCTION, for the first line in that function,\n\
15941 FILE:FUNCTION, to distinguish among like-named static functions.\n\
15942 *ADDRESS, for the instruction at that address.\n\
15944 The breakpoint will stop execution of the inferior whenever it executes\n\
15945 an instruction at any address within the [START-LOCATION, END-LOCATION]\n\
15946 range (including START-LOCATION and END-LOCATION)."));
15948 c
= add_com ("dprintf", class_breakpoint
, dprintf_command
, _("\
15949 Set a dynamic printf at specified location.\n\
15950 dprintf location,format string,arg1,arg2,...\n\
15951 location may be a linespec, explicit, or address location.\n"
15952 "\n" LOCATION_HELP_STRING
));
15953 set_cmd_completer (c
, location_completer
);
15955 add_setshow_enum_cmd ("dprintf-style", class_support
,
15956 dprintf_style_enums
, &dprintf_style
, _("\
15957 Set the style of usage for dynamic printf."), _("\
15958 Show the style of usage for dynamic printf."), _("\
15959 This setting chooses how GDB will do a dynamic printf.\n\
15960 If the value is \"gdb\", then the printing is done by GDB to its own\n\
15961 console, as with the \"printf\" command.\n\
15962 If the value is \"call\", the print is done by calling a function in your\n\
15963 program; by default printf(), but you can choose a different function or\n\
15964 output stream by setting dprintf-function and dprintf-channel."),
15965 update_dprintf_commands
, NULL
,
15966 &setlist
, &showlist
);
15968 dprintf_function
= xstrdup ("printf");
15969 add_setshow_string_cmd ("dprintf-function", class_support
,
15970 &dprintf_function
, _("\
15971 Set the function to use for dynamic printf."), _("\
15972 Show the function to use for dynamic printf."), NULL
,
15973 update_dprintf_commands
, NULL
,
15974 &setlist
, &showlist
);
15976 dprintf_channel
= xstrdup ("");
15977 add_setshow_string_cmd ("dprintf-channel", class_support
,
15978 &dprintf_channel
, _("\
15979 Set the channel to use for dynamic printf."), _("\
15980 Show the channel to use for dynamic printf."), NULL
,
15981 update_dprintf_commands
, NULL
,
15982 &setlist
, &showlist
);
15984 add_setshow_boolean_cmd ("disconnected-dprintf", no_class
,
15985 &disconnected_dprintf
, _("\
15986 Set whether dprintf continues after GDB disconnects."), _("\
15987 Show whether dprintf continues after GDB disconnects."), _("\
15988 Use this to let dprintf commands continue to hit and produce output\n\
15989 even if GDB disconnects or detaches from the target."),
15992 &setlist
, &showlist
);
15994 add_com ("agent-printf", class_vars
, agent_printf_command
, _("\
15995 Target agent only formatted printing, like the C \"printf\" function.\n\
15996 Usage: agent-printf \"format string\", ARG1, ARG2, ARG3, ..., ARGN\n\
15997 This supports most C printf format specifications, like %s, %d, etc.\n\
15998 This is useful for formatted output in user-defined commands."));
16000 automatic_hardware_breakpoints
= true;
16002 gdb::observers::about_to_proceed
.attach (breakpoint_about_to_proceed
);
16003 gdb::observers::thread_exit
.attach (remove_threaded_breakpoints
);