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 (struct event_location
*location
,
93 struct linespec_result
*canonical
,
94 enum bptype type_wanted
);
96 static void create_breakpoints_sal_default (struct gdbarch
*,
97 struct linespec_result
*,
98 gdb::unique_xmalloc_ptr
<char>,
99 gdb::unique_xmalloc_ptr
<char>,
101 enum bpdisp
, int, int,
103 const struct breakpoint_ops
*,
104 int, int, int, unsigned);
106 static std::vector
<symtab_and_line
> decode_location_default
107 (struct breakpoint
*b
, struct event_location
*location
,
108 struct program_space
*search_pspace
);
110 static int can_use_hardware_watchpoint
111 (const std::vector
<value_ref_ptr
> &vals
);
113 static void mention (struct breakpoint
*);
115 static struct breakpoint
*set_raw_breakpoint_without_location (struct gdbarch
*,
117 const struct breakpoint_ops
*);
118 static struct bp_location
*add_location_to_breakpoint (struct breakpoint
*,
119 const struct symtab_and_line
*);
121 /* This function is used in gdbtk sources and thus can not be made
123 struct breakpoint
*set_raw_breakpoint (struct gdbarch
*gdbarch
,
124 struct symtab_and_line
,
126 const struct breakpoint_ops
*);
128 static struct breakpoint
*
129 momentary_breakpoint_from_master (struct breakpoint
*orig
,
131 const struct breakpoint_ops
*ops
,
134 static void breakpoint_adjustment_warning (CORE_ADDR
, CORE_ADDR
, int, int);
136 static CORE_ADDR
adjust_breakpoint_address (struct gdbarch
*gdbarch
,
140 static void describe_other_breakpoints (struct gdbarch
*,
141 struct program_space
*, CORE_ADDR
,
142 struct obj_section
*, int);
144 static int watchpoint_locations_match (struct bp_location
*loc1
,
145 struct bp_location
*loc2
);
147 static int breakpoint_locations_match (struct bp_location
*loc1
,
148 struct bp_location
*loc2
,
149 bool sw_hw_bps_match
= false);
151 static int breakpoint_location_address_match (struct bp_location
*bl
,
152 const struct address_space
*aspace
,
155 static int breakpoint_location_address_range_overlap (struct bp_location
*,
156 const address_space
*,
159 static int remove_breakpoint (struct bp_location
*);
160 static int remove_breakpoint_1 (struct bp_location
*, enum remove_bp_reason
);
162 static enum print_stop_action
print_bp_stop_message (bpstat bs
);
164 static int hw_breakpoint_used_count (void);
166 static int hw_watchpoint_use_count (struct breakpoint
*);
168 static int hw_watchpoint_used_count_others (struct breakpoint
*except
,
170 int *other_type_used
);
172 static void enable_breakpoint_disp (struct breakpoint
*, enum bpdisp
,
175 static void 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
)
833 /* Parse COND_STRING in the context of LOC and set as the condition
834 expression of LOC. BP_NUM is the number of LOC's owner, LOC_NUM is
835 the number of LOC within its owner. In case of parsing error, mark
836 LOC as DISABLED_BY_COND. In case of success, unset DISABLED_BY_COND. */
839 set_breakpoint_location_condition (const char *cond_string
, bp_location
*loc
,
840 int bp_num
, int loc_num
)
842 bool has_junk
= false;
845 expression_up new_exp
= parse_exp_1 (&cond_string
, loc
->address
,
846 block_for_pc (loc
->address
), 0);
847 if (*cond_string
!= 0)
851 loc
->cond
= std::move (new_exp
);
852 if (loc
->disabled_by_cond
&& loc
->enabled
)
853 printf_filtered (_("Breakpoint %d's condition is now valid at "
854 "location %d, enabling.\n"),
857 loc
->disabled_by_cond
= false;
860 catch (const gdb_exception_error
&e
)
864 /* Warn if a user-enabled location is now becoming disabled-by-cond.
865 BP_NUM is 0 if the breakpoint is being defined for the first
866 time using the "break ... if ..." command, and non-zero if
869 warning (_("failed to validate condition at location %d.%d, "
870 "disabling:\n %s"), bp_num
, loc_num
, e
.what ());
872 warning (_("failed to validate condition at location %d, "
873 "disabling:\n %s"), loc_num
, e
.what ());
876 loc
->disabled_by_cond
= true;
880 error (_("Garbage '%s' follows condition"), cond_string
);
884 set_breakpoint_condition (struct breakpoint
*b
, const char *exp
,
885 int from_tty
, bool force
)
889 xfree (b
->cond_string
);
890 b
->cond_string
= nullptr;
892 if (is_watchpoint (b
))
893 static_cast<watchpoint
*> (b
)->cond_exp
.reset ();
897 for (bp_location
*loc
= b
->loc
; loc
!= nullptr; loc
= loc
->next
)
900 if (loc
->disabled_by_cond
&& loc
->enabled
)
901 printf_filtered (_("Breakpoint %d's condition is now valid at "
902 "location %d, enabling.\n"),
904 loc
->disabled_by_cond
= false;
907 /* No need to free the condition agent expression
908 bytecode (if we have one). We will handle this
909 when we go through update_global_location_list. */
914 printf_filtered (_("Breakpoint %d now unconditional.\n"), b
->number
);
918 if (is_watchpoint (b
))
920 innermost_block_tracker tracker
;
921 const char *arg
= exp
;
922 expression_up new_exp
= parse_exp_1 (&arg
, 0, 0, 0, &tracker
);
924 error (_("Junk at end of expression"));
925 watchpoint
*w
= static_cast<watchpoint
*> (b
);
926 w
->cond_exp
= std::move (new_exp
);
927 w
->cond_exp_valid_block
= tracker
.block ();
931 /* Parse and set condition expressions. We make two passes.
932 In the first, we parse the condition string to see if it
933 is valid in at least one location. If so, the condition
934 would be accepted. So we go ahead and set the locations'
935 conditions. In case no valid case is found, we throw
936 the error and the condition string will be rejected.
937 This two-pass approach is taken to avoid setting the
938 state of locations in case of a reject. */
939 for (bp_location
*loc
= b
->loc
; loc
!= nullptr; loc
= loc
->next
)
943 const char *arg
= exp
;
944 parse_exp_1 (&arg
, loc
->address
,
945 block_for_pc (loc
->address
), 0);
947 error (_("Junk at end of expression"));
950 catch (const gdb_exception_error
&e
)
952 /* Condition string is invalid. If this happens to
953 be the last loc, abandon (if not forced) or continue
955 if (loc
->next
== nullptr && !force
)
960 /* If we reach here, the condition is valid at some locations. */
962 for (bp_location
*loc
= b
->loc
; loc
!= nullptr;
963 loc
= loc
->next
, loc_num
++)
964 set_breakpoint_location_condition (exp
, loc
, b
->number
, loc_num
);
967 /* We know that the new condition parsed successfully. The
968 condition string of the breakpoint can be safely updated. */
969 xfree (b
->cond_string
);
970 b
->cond_string
= xstrdup (exp
);
971 b
->condition_not_parsed
= 0;
973 mark_breakpoint_modified (b
);
975 gdb::observers::breakpoint_modified
.notify (b
);
978 /* The options for the "condition" command. */
980 struct condition_command_opts
983 bool force_condition
= false;
986 static const gdb::option::option_def condition_command_option_defs
[] = {
988 gdb::option::flag_option_def
<condition_command_opts
> {
990 [] (condition_command_opts
*opts
) { return &opts
->force_condition
; },
991 N_("Set the condition even if it is invalid for all current locations."),
996 /* Create an option_def_group for the "condition" options, with
997 CC_OPTS as context. */
999 static inline gdb::option::option_def_group
1000 make_condition_command_options_def_group (condition_command_opts
*cc_opts
)
1002 return {{condition_command_option_defs
}, cc_opts
};
1005 /* Completion for the "condition" command. */
1008 condition_completer (struct cmd_list_element
*cmd
,
1009 completion_tracker
&tracker
,
1010 const char *text
, const char * /*word*/)
1012 bool has_no_arguments
= (*text
== '\0');
1013 condition_command_opts cc_opts
;
1014 const auto group
= make_condition_command_options_def_group (&cc_opts
);
1015 if (gdb::option::complete_options
1016 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR
, group
))
1019 text
= skip_spaces (text
);
1020 const char *space
= skip_to_space (text
);
1024 struct breakpoint
*b
;
1028 tracker
.advance_custom_word_point_by (1);
1029 /* We don't support completion of history indices. */
1030 if (!isdigit (text
[1]))
1031 complete_internalvar (tracker
, &text
[1]);
1035 /* Suggest the "-force" flag if no arguments are given. If
1036 arguments were passed, they either already include the flag,
1037 or we are beyond the point of suggesting it because it's
1038 positionally the first argument. */
1039 if (has_no_arguments
)
1040 gdb::option::complete_on_all_options (tracker
, group
);
1042 /* We're completing the breakpoint number. */
1043 len
= strlen (text
);
1049 xsnprintf (number
, sizeof (number
), "%d", b
->number
);
1051 if (strncmp (number
, text
, len
) == 0)
1052 tracker
.add_completion (make_unique_xstrdup (number
));
1058 /* We're completing the expression part. Skip the breakpoint num. */
1059 const char *exp_start
= skip_spaces (space
);
1060 tracker
.advance_custom_word_point_by (exp_start
- text
);
1062 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
1063 expression_completer (cmd
, tracker
, text
, word
);
1066 /* condition N EXP -- set break condition of breakpoint N to EXP. */
1069 condition_command (const char *arg
, int from_tty
)
1071 struct breakpoint
*b
;
1076 error_no_arg (_("breakpoint number"));
1080 /* Check if the "-force" flag was passed. */
1081 condition_command_opts cc_opts
;
1082 const auto group
= make_condition_command_options_def_group (&cc_opts
);
1083 gdb::option::process_options
1084 (&p
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR
, group
);
1086 bnum
= get_number (&p
);
1088 error (_("Bad breakpoint argument: '%s'"), arg
);
1091 if (b
->number
== bnum
)
1093 /* Check if this breakpoint has a "stop" method implemented in an
1094 extension language. This method and conditions entered into GDB
1095 from the CLI are mutually exclusive. */
1096 const struct extension_language_defn
*extlang
1097 = get_breakpoint_cond_ext_lang (b
, EXT_LANG_NONE
);
1099 if (extlang
!= NULL
)
1101 error (_("Only one stop condition allowed. There is currently"
1102 " a %s stop condition defined for this breakpoint."),
1103 ext_lang_capitalized_name (extlang
));
1105 set_breakpoint_condition (b
, p
, from_tty
, cc_opts
.force_condition
);
1107 if (is_breakpoint (b
))
1108 update_global_location_list (UGLL_MAY_INSERT
);
1113 error (_("No breakpoint number %d."), bnum
);
1116 /* Check that COMMAND do not contain commands that are suitable
1117 only for tracepoints and not suitable for ordinary breakpoints.
1118 Throw if any such commands is found. */
1121 check_no_tracepoint_commands (struct command_line
*commands
)
1123 struct command_line
*c
;
1125 for (c
= commands
; c
; c
= c
->next
)
1127 if (c
->control_type
== while_stepping_control
)
1128 error (_("The 'while-stepping' command can "
1129 "only be used for tracepoints"));
1131 check_no_tracepoint_commands (c
->body_list_0
.get ());
1132 check_no_tracepoint_commands (c
->body_list_1
.get ());
1134 /* Not that command parsing removes leading whitespace and comment
1135 lines and also empty lines. So, we only need to check for
1136 command directly. */
1137 if (strstr (c
->line
, "collect ") == c
->line
)
1138 error (_("The 'collect' command can only be used for tracepoints"));
1140 if (strstr (c
->line
, "teval ") == c
->line
)
1141 error (_("The 'teval' command can only be used for tracepoints"));
1145 struct longjmp_breakpoint
: public breakpoint
1147 ~longjmp_breakpoint () override
;
1150 /* Encapsulate tests for different types of tracepoints. */
1153 is_tracepoint_type (bptype type
)
1155 return (type
== bp_tracepoint
1156 || type
== bp_fast_tracepoint
1157 || type
== bp_static_tracepoint
);
1161 is_longjmp_type (bptype type
)
1163 return type
== bp_longjmp
|| type
== bp_exception
;
1166 /* See breakpoint.h. */
1169 is_tracepoint (const struct breakpoint
*b
)
1171 return is_tracepoint_type (b
->type
);
1174 /* Factory function to create an appropriate instance of breakpoint given
1177 static std::unique_ptr
<breakpoint
>
1178 new_breakpoint_from_type (bptype type
)
1182 if (is_tracepoint_type (type
))
1183 b
= new tracepoint ();
1184 else if (is_longjmp_type (type
))
1185 b
= new longjmp_breakpoint ();
1187 b
= new breakpoint ();
1189 return std::unique_ptr
<breakpoint
> (b
);
1192 /* A helper function that validates that COMMANDS are valid for a
1193 breakpoint. This function will throw an exception if a problem is
1197 validate_commands_for_breakpoint (struct breakpoint
*b
,
1198 struct command_line
*commands
)
1200 if (is_tracepoint (b
))
1202 struct tracepoint
*t
= (struct tracepoint
*) b
;
1203 struct command_line
*c
;
1204 struct command_line
*while_stepping
= 0;
1206 /* Reset the while-stepping step count. The previous commands
1207 might have included a while-stepping action, while the new
1211 /* We need to verify that each top-level element of commands is
1212 valid for tracepoints, that there's at most one
1213 while-stepping element, and that the while-stepping's body
1214 has valid tracing commands excluding nested while-stepping.
1215 We also need to validate the tracepoint action line in the
1216 context of the tracepoint --- validate_actionline actually
1217 has side effects, like setting the tracepoint's
1218 while-stepping STEP_COUNT, in addition to checking if the
1219 collect/teval actions parse and make sense in the
1220 tracepoint's context. */
1221 for (c
= commands
; c
; c
= c
->next
)
1223 if (c
->control_type
== while_stepping_control
)
1225 if (b
->type
== bp_fast_tracepoint
)
1226 error (_("The 'while-stepping' command "
1227 "cannot be used for fast tracepoint"));
1228 else if (b
->type
== bp_static_tracepoint
)
1229 error (_("The 'while-stepping' command "
1230 "cannot be used for static tracepoint"));
1233 error (_("The 'while-stepping' command "
1234 "can be used only once"));
1239 validate_actionline (c
->line
, b
);
1243 struct command_line
*c2
;
1245 gdb_assert (while_stepping
->body_list_1
== nullptr);
1246 c2
= while_stepping
->body_list_0
.get ();
1247 for (; c2
; c2
= c2
->next
)
1249 if (c2
->control_type
== while_stepping_control
)
1250 error (_("The 'while-stepping' command cannot be nested"));
1256 check_no_tracepoint_commands (commands
);
1260 /* Return a vector of all the static tracepoints set at ADDR. The
1261 caller is responsible for releasing the vector. */
1263 std::vector
<breakpoint
*>
1264 static_tracepoints_here (CORE_ADDR addr
)
1266 struct breakpoint
*b
;
1267 std::vector
<breakpoint
*> found
;
1268 struct bp_location
*loc
;
1271 if (b
->type
== bp_static_tracepoint
)
1273 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1274 if (loc
->address
== addr
)
1275 found
.push_back (b
);
1281 /* Set the command list of B to COMMANDS. If breakpoint is tracepoint,
1282 validate that only allowed commands are included. */
1285 breakpoint_set_commands (struct breakpoint
*b
,
1286 counted_command_line
&&commands
)
1288 validate_commands_for_breakpoint (b
, commands
.get ());
1290 b
->commands
= std::move (commands
);
1291 gdb::observers::breakpoint_modified
.notify (b
);
1294 /* Set the internal `silent' flag on the breakpoint. Note that this
1295 is not the same as the "silent" that may appear in the breakpoint's
1299 breakpoint_set_silent (struct breakpoint
*b
, int silent
)
1301 int old_silent
= b
->silent
;
1304 if (old_silent
!= silent
)
1305 gdb::observers::breakpoint_modified
.notify (b
);
1308 /* Set the thread for this breakpoint. If THREAD is -1, make the
1309 breakpoint work for any thread. */
1312 breakpoint_set_thread (struct breakpoint
*b
, int thread
)
1314 int old_thread
= b
->thread
;
1317 if (old_thread
!= thread
)
1318 gdb::observers::breakpoint_modified
.notify (b
);
1321 /* Set the task for this breakpoint. If TASK is 0, make the
1322 breakpoint work for any task. */
1325 breakpoint_set_task (struct breakpoint
*b
, int task
)
1327 int old_task
= b
->task
;
1330 if (old_task
!= task
)
1331 gdb::observers::breakpoint_modified
.notify (b
);
1335 commands_command_1 (const char *arg
, int from_tty
,
1336 struct command_line
*control
)
1338 counted_command_line cmd
;
1339 /* cmd_read will be true once we have read cmd. Note that cmd might still be
1340 NULL after the call to read_command_lines if the user provides an empty
1341 list of command by just typing "end". */
1342 bool cmd_read
= false;
1344 std::string new_arg
;
1346 if (arg
== NULL
|| !*arg
)
1348 /* Argument not explicitly given. Synthesize it. */
1349 if (breakpoint_count
- prev_breakpoint_count
> 1)
1350 new_arg
= string_printf ("%d-%d", prev_breakpoint_count
+ 1,
1352 else if (breakpoint_count
> 0)
1353 new_arg
= string_printf ("%d", breakpoint_count
);
1357 /* Create a copy of ARG. This is needed because the "commands"
1358 command may be coming from a script. In that case, the read
1359 line buffer is going to be overwritten in the lambda of
1360 'map_breakpoint_numbers' below when reading the next line
1361 before we are are done parsing the breakpoint numbers. */
1364 arg
= new_arg
.c_str ();
1366 map_breakpoint_numbers
1367 (arg
, [&] (breakpoint
*b
)
1371 gdb_assert (cmd
== NULL
);
1372 if (control
!= NULL
)
1373 cmd
= control
->body_list_0
;
1377 = string_printf (_("Type commands for breakpoint(s) "
1378 "%s, one per line."),
1381 auto do_validate
= [=] (const char *line
)
1383 validate_actionline (line
, b
);
1385 gdb::function_view
<void (const char *)> validator
;
1386 if (is_tracepoint (b
))
1387 validator
= do_validate
;
1389 cmd
= read_command_lines (str
.c_str (), from_tty
, 1, validator
);
1394 /* If a breakpoint was on the list more than once, we don't need to
1396 if (b
->commands
!= cmd
)
1398 validate_commands_for_breakpoint (b
, cmd
.get ());
1400 gdb::observers::breakpoint_modified
.notify (b
);
1406 commands_command (const char *arg
, int from_tty
)
1408 commands_command_1 (arg
, from_tty
, NULL
);
1411 /* Like commands_command, but instead of reading the commands from
1412 input stream, takes them from an already parsed command structure.
1414 This is used by cli-script.c to DTRT with breakpoint commands
1415 that are part of if and while bodies. */
1416 enum command_control_type
1417 commands_from_control_command (const char *arg
, struct command_line
*cmd
)
1419 commands_command_1 (arg
, 0, cmd
);
1420 return simple_control
;
1423 /* Return non-zero if BL->TARGET_INFO contains valid information. */
1426 bp_location_has_shadow (struct bp_location
*bl
)
1428 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
1432 if (bl
->target_info
.shadow_len
== 0)
1433 /* BL isn't valid, or doesn't shadow memory. */
1438 /* Update BUF, which is LEN bytes read from the target address
1439 MEMADDR, by replacing a memory breakpoint with its shadowed
1442 If READBUF is not NULL, this buffer must not overlap with the of
1443 the breakpoint location's shadow_contents buffer. Otherwise, a
1444 failed assertion internal error will be raised. */
1447 one_breakpoint_xfer_memory (gdb_byte
*readbuf
, gdb_byte
*writebuf
,
1448 const gdb_byte
*writebuf_org
,
1449 ULONGEST memaddr
, LONGEST len
,
1450 struct bp_target_info
*target_info
,
1451 struct gdbarch
*gdbarch
)
1453 /* Now do full processing of the found relevant range of elements. */
1454 CORE_ADDR bp_addr
= 0;
1458 if (!breakpoint_address_match (target_info
->placed_address_space
, 0,
1459 current_program_space
->aspace
, 0))
1461 /* The breakpoint is inserted in a different address space. */
1465 /* Addresses and length of the part of the breakpoint that
1467 bp_addr
= target_info
->placed_address
;
1468 bp_size
= target_info
->shadow_len
;
1470 if (bp_addr
+ bp_size
<= memaddr
)
1472 /* The breakpoint is entirely before the chunk of memory we are
1477 if (bp_addr
>= memaddr
+ len
)
1479 /* The breakpoint is entirely after the chunk of memory we are
1484 /* Offset within shadow_contents. */
1485 if (bp_addr
< memaddr
)
1487 /* Only copy the second part of the breakpoint. */
1488 bp_size
-= memaddr
- bp_addr
;
1489 bptoffset
= memaddr
- bp_addr
;
1493 if (bp_addr
+ bp_size
> memaddr
+ len
)
1495 /* Only copy the first part of the breakpoint. */
1496 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
1499 if (readbuf
!= NULL
)
1501 /* Verify that the readbuf buffer does not overlap with the
1502 shadow_contents buffer. */
1503 gdb_assert (target_info
->shadow_contents
>= readbuf
+ len
1504 || readbuf
>= (target_info
->shadow_contents
1505 + target_info
->shadow_len
));
1507 /* Update the read buffer with this inserted breakpoint's
1509 memcpy (readbuf
+ bp_addr
- memaddr
,
1510 target_info
->shadow_contents
+ bptoffset
, bp_size
);
1514 const unsigned char *bp
;
1515 CORE_ADDR addr
= target_info
->reqstd_address
;
1518 /* Update the shadow with what we want to write to memory. */
1519 memcpy (target_info
->shadow_contents
+ bptoffset
,
1520 writebuf_org
+ bp_addr
- memaddr
, bp_size
);
1522 /* Determine appropriate breakpoint contents and size for this
1524 bp
= gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &placed_size
);
1526 /* Update the final write buffer with this inserted
1527 breakpoint's INSN. */
1528 memcpy (writebuf
+ bp_addr
- memaddr
, bp
+ bptoffset
, bp_size
);
1532 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
1533 by replacing any memory breakpoints with their shadowed contents.
1535 If READBUF is not NULL, this buffer must not overlap with any of
1536 the breakpoint location's shadow_contents buffers. Otherwise,
1537 a failed assertion internal error will be raised.
1539 The range of shadowed area by each bp_location is:
1540 bl->address - bp_locations_placed_address_before_address_max
1541 up to bl->address + bp_locations_shadow_len_after_address_max
1542 The range we were requested to resolve shadows for is:
1543 memaddr ... memaddr + len
1544 Thus the safe cutoff boundaries for performance optimization are
1545 memaddr + len <= (bl->address
1546 - bp_locations_placed_address_before_address_max)
1548 bl->address + bp_locations_shadow_len_after_address_max <= memaddr */
1551 breakpoint_xfer_memory (gdb_byte
*readbuf
, gdb_byte
*writebuf
,
1552 const gdb_byte
*writebuf_org
,
1553 ULONGEST memaddr
, LONGEST len
)
1555 /* Left boundary, right boundary and median element of our binary
1557 unsigned bc_l
, bc_r
, bc
;
1559 /* Find BC_L which is a leftmost element which may affect BUF
1560 content. It is safe to report lower value but a failure to
1561 report higher one. */
1564 bc_r
= bp_locations_count
;
1565 while (bc_l
+ 1 < bc_r
)
1567 struct bp_location
*bl
;
1569 bc
= (bc_l
+ bc_r
) / 2;
1570 bl
= bp_locations
[bc
];
1572 /* Check first BL->ADDRESS will not overflow due to the added
1573 constant. Then advance the left boundary only if we are sure
1574 the BC element can in no way affect the BUF content (MEMADDR
1575 to MEMADDR + LEN range).
1577 Use the BP_LOCATIONS_SHADOW_LEN_AFTER_ADDRESS_MAX safety
1578 offset so that we cannot miss a breakpoint with its shadow
1579 range tail still reaching MEMADDR. */
1581 if ((bl
->address
+ bp_locations_shadow_len_after_address_max
1583 && (bl
->address
+ bp_locations_shadow_len_after_address_max
1590 /* Due to the binary search above, we need to make sure we pick the
1591 first location that's at BC_L's address. E.g., if there are
1592 multiple locations at the same address, BC_L may end up pointing
1593 at a duplicate location, and miss the "master"/"inserted"
1594 location. Say, given locations L1, L2 and L3 at addresses A and
1597 L1@A, L2@A, L3@B, ...
1599 BC_L could end up pointing at location L2, while the "master"
1600 location could be L1. Since the `loc->inserted' flag is only set
1601 on "master" locations, we'd forget to restore the shadow of L1
1604 && bp_locations
[bc_l
]->address
== bp_locations
[bc_l
- 1]->address
)
1607 /* Now do full processing of the found relevant range of elements. */
1609 for (bc
= bc_l
; bc
< bp_locations_count
; bc
++)
1611 struct bp_location
*bl
= bp_locations
[bc
];
1613 /* bp_location array has BL->OWNER always non-NULL. */
1614 if (bl
->owner
->type
== bp_none
)
1615 warning (_("reading through apparently deleted breakpoint #%d?"),
1618 /* Performance optimization: any further element can no longer affect BUF
1621 if (bl
->address
>= bp_locations_placed_address_before_address_max
1622 && memaddr
+ len
<= (bl
->address
1623 - bp_locations_placed_address_before_address_max
))
1626 if (!bp_location_has_shadow (bl
))
1629 one_breakpoint_xfer_memory (readbuf
, writebuf
, writebuf_org
,
1630 memaddr
, len
, &bl
->target_info
, bl
->gdbarch
);
1634 /* See breakpoint.h. */
1637 is_breakpoint (const struct breakpoint
*bpt
)
1639 return (bpt
->type
== bp_breakpoint
1640 || bpt
->type
== bp_hardware_breakpoint
1641 || bpt
->type
== bp_dprintf
);
1644 /* Return true if BPT is of any hardware watchpoint kind. */
1647 is_hardware_watchpoint (const struct breakpoint
*bpt
)
1649 return (bpt
->type
== bp_hardware_watchpoint
1650 || bpt
->type
== bp_read_watchpoint
1651 || bpt
->type
== bp_access_watchpoint
);
1654 /* See breakpoint.h. */
1657 is_watchpoint (const struct breakpoint
*bpt
)
1659 return (is_hardware_watchpoint (bpt
)
1660 || bpt
->type
== bp_watchpoint
);
1663 /* Returns true if the current thread and its running state are safe
1664 to evaluate or update watchpoint B. Watchpoints on local
1665 expressions need to be evaluated in the context of the thread that
1666 was current when the watchpoint was created, and, that thread needs
1667 to be stopped to be able to select the correct frame context.
1668 Watchpoints on global expressions can be evaluated on any thread,
1669 and in any state. It is presently left to the target allowing
1670 memory accesses when threads are running. */
1673 watchpoint_in_thread_scope (struct watchpoint
*b
)
1675 return (b
->pspace
== current_program_space
1676 && (b
->watchpoint_thread
== null_ptid
1677 || (inferior_ptid
== b
->watchpoint_thread
1678 && !inferior_thread ()->executing
)));
1681 /* Set watchpoint B to disp_del_at_next_stop, even including its possible
1682 associated bp_watchpoint_scope breakpoint. */
1685 watchpoint_del_at_next_stop (struct watchpoint
*w
)
1687 if (w
->related_breakpoint
!= w
)
1689 gdb_assert (w
->related_breakpoint
->type
== bp_watchpoint_scope
);
1690 gdb_assert (w
->related_breakpoint
->related_breakpoint
== w
);
1691 w
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
1692 w
->related_breakpoint
->related_breakpoint
= w
->related_breakpoint
;
1693 w
->related_breakpoint
= w
;
1695 w
->disposition
= disp_del_at_next_stop
;
1698 /* Extract a bitfield value from value VAL using the bit parameters contained in
1701 static struct value
*
1702 extract_bitfield_from_watchpoint_value (struct watchpoint
*w
, struct value
*val
)
1704 struct value
*bit_val
;
1709 bit_val
= allocate_value (value_type (val
));
1711 unpack_value_bitfield (bit_val
,
1714 value_contents_for_printing (val
),
1721 /* Allocate a dummy location and add it to B, which must be a software
1722 watchpoint. This is required because even if a software watchpoint
1723 is not watching any memory, bpstat_stop_status requires a location
1724 to be able to report stops. */
1727 software_watchpoint_add_no_memory_location (struct breakpoint
*b
,
1728 struct program_space
*pspace
)
1730 gdb_assert (b
->type
== bp_watchpoint
&& b
->loc
== NULL
);
1732 b
->loc
= allocate_bp_location (b
);
1733 b
->loc
->pspace
= pspace
;
1734 b
->loc
->address
= -1;
1735 b
->loc
->length
= -1;
1738 /* Returns true if B is a software watchpoint that is not watching any
1739 memory (e.g., "watch $pc"). */
1742 is_no_memory_software_watchpoint (struct breakpoint
*b
)
1744 return (b
->type
== bp_watchpoint
1746 && b
->loc
->next
== NULL
1747 && b
->loc
->address
== -1
1748 && b
->loc
->length
== -1);
1751 /* Assuming that B is a watchpoint:
1752 - Reparse watchpoint expression, if REPARSE is non-zero
1753 - Evaluate expression and store the result in B->val
1754 - Evaluate the condition if there is one, and store the result
1756 - Update the list of values that must be watched in B->loc.
1758 If the watchpoint disposition is disp_del_at_next_stop, then do
1759 nothing. If this is local watchpoint that is out of scope, delete
1762 Even with `set breakpoint always-inserted on' the watchpoints are
1763 removed + inserted on each stop here. Normal breakpoints must
1764 never be removed because they might be missed by a running thread
1765 when debugging in non-stop mode. On the other hand, hardware
1766 watchpoints (is_hardware_watchpoint; processed here) are specific
1767 to each LWP since they are stored in each LWP's hardware debug
1768 registers. Therefore, such LWP must be stopped first in order to
1769 be able to modify its hardware watchpoints.
1771 Hardware watchpoints must be reset exactly once after being
1772 presented to the user. It cannot be done sooner, because it would
1773 reset the data used to present the watchpoint hit to the user. And
1774 it must not be done later because it could display the same single
1775 watchpoint hit during multiple GDB stops. Note that the latter is
1776 relevant only to the hardware watchpoint types bp_read_watchpoint
1777 and bp_access_watchpoint. False hit by bp_hardware_watchpoint is
1778 not user-visible - its hit is suppressed if the memory content has
1781 The following constraints influence the location where we can reset
1782 hardware watchpoints:
1784 * target_stopped_by_watchpoint and target_stopped_data_address are
1785 called several times when GDB stops.
1788 * Multiple hardware watchpoints can be hit at the same time,
1789 causing GDB to stop. GDB only presents one hardware watchpoint
1790 hit at a time as the reason for stopping, and all the other hits
1791 are presented later, one after the other, each time the user
1792 requests the execution to be resumed. Execution is not resumed
1793 for the threads still having pending hit event stored in
1794 LWP_INFO->STATUS. While the watchpoint is already removed from
1795 the inferior on the first stop the thread hit event is kept being
1796 reported from its cached value by linux_nat_stopped_data_address
1797 until the real thread resume happens after the watchpoint gets
1798 presented and thus its LWP_INFO->STATUS gets reset.
1800 Therefore the hardware watchpoint hit can get safely reset on the
1801 watchpoint removal from inferior. */
1804 update_watchpoint (struct watchpoint
*b
, int reparse
)
1806 int within_current_scope
;
1807 struct frame_id saved_frame_id
;
1810 /* If this is a local watchpoint, we only want to check if the
1811 watchpoint frame is in scope if the current thread is the thread
1812 that was used to create the watchpoint. */
1813 if (!watchpoint_in_thread_scope (b
))
1816 if (b
->disposition
== disp_del_at_next_stop
)
1821 /* Determine if the watchpoint is within scope. */
1822 if (b
->exp_valid_block
== NULL
)
1823 within_current_scope
= 1;
1826 struct frame_info
*fi
= get_current_frame ();
1827 struct gdbarch
*frame_arch
= get_frame_arch (fi
);
1828 CORE_ADDR frame_pc
= get_frame_pc (fi
);
1830 /* If we're at a point where the stack has been destroyed
1831 (e.g. in a function epilogue), unwinding may not work
1832 properly. Do not attempt to recreate locations at this
1833 point. See similar comments in watchpoint_check. */
1834 if (gdbarch_stack_frame_destroyed_p (frame_arch
, frame_pc
))
1837 /* Save the current frame's ID so we can restore it after
1838 evaluating the watchpoint expression on its own frame. */
1839 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
1840 took a frame parameter, so that we didn't have to change the
1843 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
1845 fi
= frame_find_by_id (b
->watchpoint_frame
);
1846 within_current_scope
= (fi
!= NULL
);
1847 if (within_current_scope
)
1851 /* We don't free locations. They are stored in the bp_location array
1852 and update_global_location_list will eventually delete them and
1853 remove breakpoints if needed. */
1856 if (within_current_scope
&& reparse
)
1861 s
= b
->exp_string_reparse
? b
->exp_string_reparse
: b
->exp_string
;
1862 b
->exp
= parse_exp_1 (&s
, 0, b
->exp_valid_block
, 0);
1863 /* If the meaning of expression itself changed, the old value is
1864 no longer relevant. We don't want to report a watchpoint hit
1865 to the user when the old value and the new value may actually
1866 be completely different objects. */
1868 b
->val_valid
= false;
1870 /* Note that unlike with breakpoints, the watchpoint's condition
1871 expression is stored in the breakpoint object, not in the
1872 locations (re)created below. */
1873 if (b
->cond_string
!= NULL
)
1875 b
->cond_exp
.reset ();
1878 b
->cond_exp
= parse_exp_1 (&s
, 0, b
->cond_exp_valid_block
, 0);
1882 /* If we failed to parse the expression, for example because
1883 it refers to a global variable in a not-yet-loaded shared library,
1884 don't try to insert watchpoint. We don't automatically delete
1885 such watchpoint, though, since failure to parse expression
1886 is different from out-of-scope watchpoint. */
1887 if (!target_has_execution ())
1889 /* Without execution, memory can't change. No use to try and
1890 set watchpoint locations. The watchpoint will be reset when
1891 the target gains execution, through breakpoint_re_set. */
1892 if (!can_use_hw_watchpoints
)
1894 if (b
->ops
->works_in_software_mode (b
))
1895 b
->type
= bp_watchpoint
;
1897 error (_("Can't set read/access watchpoint when "
1898 "hardware watchpoints are disabled."));
1901 else if (within_current_scope
&& b
->exp
)
1904 std::vector
<value_ref_ptr
> val_chain
;
1905 struct value
*v
, *result
;
1906 struct program_space
*frame_pspace
;
1908 fetch_subexp_value (b
->exp
.get (), &pc
, &v
, &result
, &val_chain
, 0);
1910 /* Avoid setting b->val if it's already set. The meaning of
1911 b->val is 'the last value' user saw, and we should update
1912 it only if we reported that last value to user. As it
1913 happens, the code that reports it updates b->val directly.
1914 We don't keep track of the memory value for masked
1916 if (!b
->val_valid
&& !is_masked_watchpoint (b
))
1918 if (b
->val_bitsize
!= 0)
1919 v
= extract_bitfield_from_watchpoint_value (b
, v
);
1920 b
->val
= release_value (v
);
1921 b
->val_valid
= true;
1924 frame_pspace
= get_frame_program_space (get_selected_frame (NULL
));
1926 /* Look at each value on the value chain. */
1927 gdb_assert (!val_chain
.empty ());
1928 for (const value_ref_ptr
&iter
: val_chain
)
1932 /* If it's a memory location, and GDB actually needed
1933 its contents to evaluate the expression, then we
1934 must watch it. If the first value returned is
1935 still lazy, that means an error occurred reading it;
1936 watch it anyway in case it becomes readable. */
1937 if (VALUE_LVAL (v
) == lval_memory
1938 && (v
== val_chain
[0] || ! value_lazy (v
)))
1940 struct type
*vtype
= check_typedef (value_type (v
));
1942 /* We only watch structs and arrays if user asked
1943 for it explicitly, never if they just happen to
1944 appear in the middle of some value chain. */
1946 || (vtype
->code () != TYPE_CODE_STRUCT
1947 && vtype
->code () != TYPE_CODE_ARRAY
))
1950 enum target_hw_bp_type type
;
1951 struct bp_location
*loc
, **tmp
;
1952 int bitpos
= 0, bitsize
= 0;
1954 if (value_bitsize (v
) != 0)
1956 /* Extract the bit parameters out from the bitfield
1958 bitpos
= value_bitpos (v
);
1959 bitsize
= value_bitsize (v
);
1961 else if (v
== result
&& b
->val_bitsize
!= 0)
1963 /* If VAL_BITSIZE != 0 then RESULT is actually a bitfield
1964 lvalue whose bit parameters are saved in the fields
1965 VAL_BITPOS and VAL_BITSIZE. */
1966 bitpos
= b
->val_bitpos
;
1967 bitsize
= b
->val_bitsize
;
1970 addr
= value_address (v
);
1973 /* Skip the bytes that don't contain the bitfield. */
1978 if (b
->type
== bp_read_watchpoint
)
1980 else if (b
->type
== bp_access_watchpoint
)
1983 loc
= allocate_bp_location (b
);
1984 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
1987 loc
->gdbarch
= get_type_arch (value_type (v
));
1989 loc
->pspace
= frame_pspace
;
1990 loc
->address
= address_significant (loc
->gdbarch
, addr
);
1994 /* Just cover the bytes that make up the bitfield. */
1995 loc
->length
= ((bitpos
% 8) + bitsize
+ 7) / 8;
1998 loc
->length
= TYPE_LENGTH (value_type (v
));
2000 loc
->watchpoint_type
= type
;
2005 /* Change the type of breakpoint between hardware assisted or
2006 an ordinary watchpoint depending on the hardware support
2007 and free hardware slots. REPARSE is set when the inferior
2012 enum bp_loc_type loc_type
;
2013 struct bp_location
*bl
;
2015 reg_cnt
= can_use_hardware_watchpoint (val_chain
);
2019 int i
, target_resources_ok
, other_type_used
;
2022 /* Use an exact watchpoint when there's only one memory region to be
2023 watched, and only one debug register is needed to watch it. */
2024 b
->exact
= target_exact_watchpoints
&& reg_cnt
== 1;
2026 /* We need to determine how many resources are already
2027 used for all other hardware watchpoints plus this one
2028 to see if we still have enough resources to also fit
2029 this watchpoint in as well. */
2031 /* If this is a software watchpoint, we try to turn it
2032 to a hardware one -- count resources as if B was of
2033 hardware watchpoint type. */
2035 if (type
== bp_watchpoint
)
2036 type
= bp_hardware_watchpoint
;
2038 /* This watchpoint may or may not have been placed on
2039 the list yet at this point (it won't be in the list
2040 if we're trying to create it for the first time,
2041 through watch_command), so always account for it
2044 /* Count resources used by all watchpoints except B. */
2045 i
= hw_watchpoint_used_count_others (b
, type
, &other_type_used
);
2047 /* Add in the resources needed for B. */
2048 i
+= hw_watchpoint_use_count (b
);
2051 = target_can_use_hardware_watchpoint (type
, i
, other_type_used
);
2052 if (target_resources_ok
<= 0)
2054 int sw_mode
= b
->ops
->works_in_software_mode (b
);
2056 if (target_resources_ok
== 0 && !sw_mode
)
2057 error (_("Target does not support this type of "
2058 "hardware watchpoint."));
2059 else if (target_resources_ok
< 0 && !sw_mode
)
2060 error (_("There are not enough available hardware "
2061 "resources for this watchpoint."));
2063 /* Downgrade to software watchpoint. */
2064 b
->type
= bp_watchpoint
;
2068 /* If this was a software watchpoint, we've just
2069 found we have enough resources to turn it to a
2070 hardware watchpoint. Otherwise, this is a
2075 else if (!b
->ops
->works_in_software_mode (b
))
2077 if (!can_use_hw_watchpoints
)
2078 error (_("Can't set read/access watchpoint when "
2079 "hardware watchpoints are disabled."));
2081 error (_("Expression cannot be implemented with "
2082 "read/access watchpoint."));
2085 b
->type
= bp_watchpoint
;
2087 loc_type
= (b
->type
== bp_watchpoint
? bp_loc_other
2088 : bp_loc_hardware_watchpoint
);
2089 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
2090 bl
->loc_type
= loc_type
;
2093 /* If a software watchpoint is not watching any memory, then the
2094 above left it without any location set up. But,
2095 bpstat_stop_status requires a location to be able to report
2096 stops, so make sure there's at least a dummy one. */
2097 if (b
->type
== bp_watchpoint
&& b
->loc
== NULL
)
2098 software_watchpoint_add_no_memory_location (b
, frame_pspace
);
2100 else if (!within_current_scope
)
2102 printf_filtered (_("\
2103 Watchpoint %d deleted because the program has left the block\n\
2104 in which its expression is valid.\n"),
2106 watchpoint_del_at_next_stop (b
);
2109 /* Restore the selected frame. */
2111 select_frame (frame_find_by_id (saved_frame_id
));
2115 /* Returns 1 iff breakpoint location should be
2116 inserted in the inferior. We don't differentiate the type of BL's owner
2117 (breakpoint vs. tracepoint), although insert_location in tracepoint's
2118 breakpoint_ops is not defined, because in insert_bp_location,
2119 tracepoint's insert_location will not be called. */
2121 should_be_inserted (struct bp_location
*bl
)
2123 if (bl
->owner
== NULL
|| !breakpoint_enabled (bl
->owner
))
2126 if (bl
->owner
->disposition
== disp_del_at_next_stop
)
2129 if (!bl
->enabled
|| bl
->disabled_by_cond
2130 || bl
->shlib_disabled
|| bl
->duplicate
)
2133 if (user_breakpoint_p (bl
->owner
) && bl
->pspace
->executing_startup
)
2136 /* This is set for example, when we're attached to the parent of a
2137 vfork, and have detached from the child. The child is running
2138 free, and we expect it to do an exec or exit, at which point the
2139 OS makes the parent schedulable again (and the target reports
2140 that the vfork is done). Until the child is done with the shared
2141 memory region, do not insert breakpoints in the parent, otherwise
2142 the child could still trip on the parent's breakpoints. Since
2143 the parent is blocked anyway, it won't miss any breakpoint. */
2144 if (bl
->pspace
->breakpoints_not_allowed
)
2147 /* Don't insert a breakpoint if we're trying to step past its
2148 location, except if the breakpoint is a single-step breakpoint,
2149 and the breakpoint's thread is the thread which is stepping past
2151 if ((bl
->loc_type
== bp_loc_software_breakpoint
2152 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
2153 && stepping_past_instruction_at (bl
->pspace
->aspace
,
2155 /* The single-step breakpoint may be inserted at the location
2156 we're trying to step if the instruction branches to itself.
2157 However, the instruction won't be executed at all and it may
2158 break the semantics of the instruction, for example, the
2159 instruction is a conditional branch or updates some flags.
2160 We can't fix it unless GDB is able to emulate the instruction
2161 or switch to displaced stepping. */
2162 && !(bl
->owner
->type
== bp_single_step
2163 && thread_is_stepping_over_breakpoint (bl
->owner
->thread
)))
2165 infrun_debug_printf ("skipping breakpoint: stepping past insn at: %s",
2166 paddress (bl
->gdbarch
, bl
->address
));
2170 /* Don't insert watchpoints if we're trying to step past the
2171 instruction that triggered one. */
2172 if ((bl
->loc_type
== bp_loc_hardware_watchpoint
)
2173 && stepping_past_nonsteppable_watchpoint ())
2175 infrun_debug_printf ("stepping past non-steppable watchpoint. "
2176 "skipping watchpoint at %s:%d\n",
2177 paddress (bl
->gdbarch
, bl
->address
), bl
->length
);
2184 /* Same as should_be_inserted but does the check assuming
2185 that the location is not duplicated. */
2188 unduplicated_should_be_inserted (struct bp_location
*bl
)
2191 const int save_duplicate
= bl
->duplicate
;
2194 result
= should_be_inserted (bl
);
2195 bl
->duplicate
= save_duplicate
;
2199 /* Parses a conditional described by an expression COND into an
2200 agent expression bytecode suitable for evaluation
2201 by the bytecode interpreter. Return NULL if there was
2202 any error during parsing. */
2204 static agent_expr_up
2205 parse_cond_to_aexpr (CORE_ADDR scope
, struct expression
*cond
)
2210 agent_expr_up aexpr
;
2212 /* We don't want to stop processing, so catch any errors
2213 that may show up. */
2216 aexpr
= gen_eval_for_expr (scope
, cond
);
2219 catch (const gdb_exception_error
&ex
)
2221 /* If we got here, it means the condition could not be parsed to a valid
2222 bytecode expression and thus can't be evaluated on the target's side.
2223 It's no use iterating through the conditions. */
2226 /* We have a valid agent expression. */
2230 /* Based on location BL, create a list of breakpoint conditions to be
2231 passed on to the target. If we have duplicated locations with different
2232 conditions, we will add such conditions to the list. The idea is that the
2233 target will evaluate the list of conditions and will only notify GDB when
2234 one of them is true. */
2237 build_target_condition_list (struct bp_location
*bl
)
2239 struct bp_location
**locp
= NULL
, **loc2p
;
2240 int null_condition_or_parse_error
= 0;
2241 int modified
= bl
->needs_update
;
2242 struct bp_location
*loc
;
2244 /* Release conditions left over from a previous insert. */
2245 bl
->target_info
.conditions
.clear ();
2247 /* This is only meaningful if the target is
2248 evaluating conditions and if the user has
2249 opted for condition evaluation on the target's
2251 if (gdb_evaluates_breakpoint_condition_p ()
2252 || !target_supports_evaluation_of_breakpoint_conditions ())
2255 /* Do a first pass to check for locations with no assigned
2256 conditions or conditions that fail to parse to a valid agent
2257 expression bytecode. If any of these happen, then it's no use to
2258 send conditions to the target since this location will always
2259 trigger and generate a response back to GDB. Note we consider
2260 all locations at the same address irrespective of type, i.e.,
2261 even if the locations aren't considered duplicates (e.g.,
2262 software breakpoint and hardware breakpoint at the same
2264 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2267 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2271 /* Re-parse the conditions since something changed. In that
2272 case we already freed the condition bytecodes (see
2273 force_breakpoint_reinsertion). We just
2274 need to parse the condition to bytecodes again. */
2275 loc
->cond_bytecode
= parse_cond_to_aexpr (bl
->address
,
2279 /* If we have a NULL bytecode expression, it means something
2280 went wrong or we have a null condition expression. */
2281 if (!loc
->cond_bytecode
)
2283 null_condition_or_parse_error
= 1;
2289 /* If any of these happened, it means we will have to evaluate the conditions
2290 for the location's address on gdb's side. It is no use keeping bytecodes
2291 for all the other duplicate locations, thus we free all of them here.
2293 This is so we have a finer control over which locations' conditions are
2294 being evaluated by GDB or the remote stub. */
2295 if (null_condition_or_parse_error
)
2297 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2300 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2302 /* Only go as far as the first NULL bytecode is
2304 if (!loc
->cond_bytecode
)
2307 loc
->cond_bytecode
.reset ();
2312 /* No NULL conditions or failed bytecode generation. Build a
2313 condition list for this location's address. If we have software
2314 and hardware locations at the same address, they aren't
2315 considered duplicates, but we still marge all the conditions
2316 anyway, as it's simpler, and doesn't really make a practical
2318 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2322 && is_breakpoint (loc
->owner
)
2323 && loc
->pspace
->num
== bl
->pspace
->num
2324 && loc
->owner
->enable_state
== bp_enabled
2326 && !loc
->disabled_by_cond
)
2328 /* Add the condition to the vector. This will be used later
2329 to send the conditions to the target. */
2330 bl
->target_info
.conditions
.push_back (loc
->cond_bytecode
.get ());
2337 /* Parses a command described by string CMD into an agent expression
2338 bytecode suitable for evaluation by the bytecode interpreter.
2339 Return NULL if there was any error during parsing. */
2341 static agent_expr_up
2342 parse_cmd_to_aexpr (CORE_ADDR scope
, char *cmd
)
2344 const char *cmdrest
;
2345 const char *format_start
, *format_end
;
2346 struct gdbarch
*gdbarch
= get_current_arch ();
2353 if (*cmdrest
== ',')
2355 cmdrest
= skip_spaces (cmdrest
);
2357 if (*cmdrest
++ != '"')
2358 error (_("No format string following the location"));
2360 format_start
= cmdrest
;
2362 format_pieces
fpieces (&cmdrest
);
2364 format_end
= cmdrest
;
2366 if (*cmdrest
++ != '"')
2367 error (_("Bad format string, non-terminated '\"'."));
2369 cmdrest
= skip_spaces (cmdrest
);
2371 if (!(*cmdrest
== ',' || *cmdrest
== '\0'))
2372 error (_("Invalid argument syntax"));
2374 if (*cmdrest
== ',')
2376 cmdrest
= skip_spaces (cmdrest
);
2378 /* For each argument, make an expression. */
2380 std::vector
<struct expression
*> argvec
;
2381 while (*cmdrest
!= '\0')
2386 expression_up expr
= parse_exp_1 (&cmd1
, scope
, block_for_pc (scope
), 1);
2387 argvec
.push_back (expr
.release ());
2389 if (*cmdrest
== ',')
2393 agent_expr_up aexpr
;
2395 /* We don't want to stop processing, so catch any errors
2396 that may show up. */
2399 aexpr
= gen_printf (scope
, gdbarch
, 0, 0,
2400 format_start
, format_end
- format_start
,
2401 argvec
.size (), argvec
.data ());
2403 catch (const gdb_exception_error
&ex
)
2405 /* If we got here, it means the command could not be parsed to a valid
2406 bytecode expression and thus can't be evaluated on the target's side.
2407 It's no use iterating through the other commands. */
2410 /* We have a valid agent expression, return it. */
2414 /* Based on location BL, create a list of breakpoint commands to be
2415 passed on to the target. If we have duplicated locations with
2416 different commands, we will add any such to the list. */
2419 build_target_command_list (struct bp_location
*bl
)
2421 struct bp_location
**locp
= NULL
, **loc2p
;
2422 int null_command_or_parse_error
= 0;
2423 int modified
= bl
->needs_update
;
2424 struct bp_location
*loc
;
2426 /* Clear commands left over from a previous insert. */
2427 bl
->target_info
.tcommands
.clear ();
2429 if (!target_can_run_breakpoint_commands ())
2432 /* For now, limit to agent-style dprintf breakpoints. */
2433 if (dprintf_style
!= dprintf_style_agent
)
2436 /* For now, if we have any location at the same address that isn't a
2437 dprintf, don't install the target-side commands, as that would
2438 make the breakpoint not be reported to the core, and we'd lose
2440 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2443 if (is_breakpoint (loc
->owner
)
2444 && loc
->pspace
->num
== bl
->pspace
->num
2445 && loc
->owner
->type
!= bp_dprintf
)
2449 /* Do a first pass to check for locations with no assigned
2450 conditions or conditions that fail to parse to a valid agent expression
2451 bytecode. If any of these happen, then it's no use to send conditions
2452 to the target since this location will always trigger and generate a
2453 response back to GDB. */
2454 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2457 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2461 /* Re-parse the commands since something changed. In that
2462 case we already freed the command bytecodes (see
2463 force_breakpoint_reinsertion). We just
2464 need to parse the command to bytecodes again. */
2466 = parse_cmd_to_aexpr (bl
->address
,
2467 loc
->owner
->extra_string
);
2470 /* If we have a NULL bytecode expression, it means something
2471 went wrong or we have a null command expression. */
2472 if (!loc
->cmd_bytecode
)
2474 null_command_or_parse_error
= 1;
2480 /* If anything failed, then we're not doing target-side commands,
2482 if (null_command_or_parse_error
)
2484 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2487 if (is_breakpoint (loc
->owner
)
2488 && loc
->pspace
->num
== bl
->pspace
->num
)
2490 /* Only go as far as the first NULL bytecode is
2492 if (loc
->cmd_bytecode
== NULL
)
2495 loc
->cmd_bytecode
.reset ();
2500 /* No NULL commands or failed bytecode generation. Build a command
2501 list for all duplicate locations at this location's address.
2502 Note that here we must care for whether the breakpoint location
2503 types are considered duplicates, otherwise, say, if we have a
2504 software and hardware location at the same address, the target
2505 could end up running the commands twice. For the moment, we only
2506 support targets-side commands with dprintf, but it doesn't hurt
2507 to be pedantically correct in case that changes. */
2508 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2511 if (breakpoint_locations_match (bl
, loc
)
2512 && loc
->owner
->extra_string
2513 && is_breakpoint (loc
->owner
)
2514 && loc
->pspace
->num
== bl
->pspace
->num
2515 && loc
->owner
->enable_state
== bp_enabled
2517 && !loc
->disabled_by_cond
)
2519 /* Add the command to the vector. This will be used later
2520 to send the commands to the target. */
2521 bl
->target_info
.tcommands
.push_back (loc
->cmd_bytecode
.get ());
2525 bl
->target_info
.persist
= 0;
2526 /* Maybe flag this location as persistent. */
2527 if (bl
->owner
->type
== bp_dprintf
&& disconnected_dprintf
)
2528 bl
->target_info
.persist
= 1;
2531 /* Return the kind of breakpoint on address *ADDR. Get the kind
2532 of breakpoint according to ADDR except single-step breakpoint.
2533 Get the kind of single-step breakpoint according to the current
2537 breakpoint_kind (struct bp_location
*bl
, CORE_ADDR
*addr
)
2539 if (bl
->owner
->type
== bp_single_step
)
2541 struct thread_info
*thr
= find_thread_global_id (bl
->owner
->thread
);
2542 struct regcache
*regcache
;
2544 regcache
= get_thread_regcache (thr
);
2546 return gdbarch_breakpoint_kind_from_current_state (bl
->gdbarch
,
2550 return gdbarch_breakpoint_kind_from_pc (bl
->gdbarch
, addr
);
2553 /* Insert a low-level "breakpoint" of some type. BL is the breakpoint
2554 location. Any error messages are printed to TMP_ERROR_STREAM; and
2555 DISABLED_BREAKS, and HW_BREAKPOINT_ERROR are used to report problems.
2556 Returns 0 for success, 1 if the bp_location type is not supported or
2559 NOTE drow/2003-09-09: This routine could be broken down to an
2560 object-style method for each breakpoint or catchpoint type. */
2562 insert_bp_location (struct bp_location
*bl
,
2563 struct ui_file
*tmp_error_stream
,
2564 int *disabled_breaks
,
2565 int *hw_breakpoint_error
,
2566 int *hw_bp_error_explained_already
)
2568 gdb_exception bp_excpt
;
2570 if (!should_be_inserted (bl
) || (bl
->inserted
&& !bl
->needs_update
))
2573 /* Note we don't initialize bl->target_info, as that wipes out
2574 the breakpoint location's shadow_contents if the breakpoint
2575 is still inserted at that location. This in turn breaks
2576 target_read_memory which depends on these buffers when
2577 a memory read is requested at the breakpoint location:
2578 Once the target_info has been wiped, we fail to see that
2579 we have a breakpoint inserted at that address and thus
2580 read the breakpoint instead of returning the data saved in
2581 the breakpoint location's shadow contents. */
2582 bl
->target_info
.reqstd_address
= bl
->address
;
2583 bl
->target_info
.placed_address_space
= bl
->pspace
->aspace
;
2584 bl
->target_info
.length
= bl
->length
;
2586 /* When working with target-side conditions, we must pass all the conditions
2587 for the same breakpoint address down to the target since GDB will not
2588 insert those locations. With a list of breakpoint conditions, the target
2589 can decide when to stop and notify GDB. */
2591 if (is_breakpoint (bl
->owner
))
2593 build_target_condition_list (bl
);
2594 build_target_command_list (bl
);
2595 /* Reset the modification marker. */
2596 bl
->needs_update
= 0;
2599 /* If "set breakpoint auto-hw" is "on" and a software breakpoint was
2600 set at a read-only address, then a breakpoint location will have
2601 been changed to hardware breakpoint before we get here. If it is
2602 "off" however, error out before actually trying to insert the
2603 breakpoint, with a nicer error message. */
2604 if (bl
->loc_type
== bp_loc_software_breakpoint
2605 && !automatic_hardware_breakpoints
)
2607 mem_region
*mr
= lookup_mem_region (bl
->address
);
2609 if (mr
!= nullptr && mr
->attrib
.mode
!= MEM_RW
)
2611 fprintf_unfiltered (tmp_error_stream
,
2612 _("Cannot insert breakpoint %d.\n"
2613 "Cannot set software breakpoint "
2614 "at read-only address %s\n"),
2616 paddress (bl
->gdbarch
, bl
->address
));
2621 if (bl
->loc_type
== bp_loc_software_breakpoint
2622 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
2624 /* First check to see if we have to handle an overlay. */
2625 if (overlay_debugging
== ovly_off
2626 || bl
->section
== NULL
2627 || !(section_is_overlay (bl
->section
)))
2629 /* No overlay handling: just set the breakpoint. */
2634 val
= bl
->owner
->ops
->insert_location (bl
);
2636 bp_excpt
= gdb_exception
{RETURN_ERROR
, GENERIC_ERROR
};
2638 catch (gdb_exception
&e
)
2640 bp_excpt
= std::move (e
);
2645 /* This breakpoint is in an overlay section.
2646 Shall we set a breakpoint at the LMA? */
2647 if (!overlay_events_enabled
)
2649 /* Yes -- overlay event support is not active,
2650 so we must try to set a breakpoint at the LMA.
2651 This will not work for a hardware breakpoint. */
2652 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
2653 warning (_("hardware breakpoint %d not supported in overlay!"),
2657 CORE_ADDR addr
= overlay_unmapped_address (bl
->address
,
2659 /* Set a software (trap) breakpoint at the LMA. */
2660 bl
->overlay_target_info
= bl
->target_info
;
2661 bl
->overlay_target_info
.reqstd_address
= addr
;
2663 /* No overlay handling: just set the breakpoint. */
2668 bl
->overlay_target_info
.kind
2669 = breakpoint_kind (bl
, &addr
);
2670 bl
->overlay_target_info
.placed_address
= addr
;
2671 val
= target_insert_breakpoint (bl
->gdbarch
,
2672 &bl
->overlay_target_info
);
2675 = gdb_exception
{RETURN_ERROR
, GENERIC_ERROR
};
2677 catch (gdb_exception
&e
)
2679 bp_excpt
= std::move (e
);
2682 if (bp_excpt
.reason
!= 0)
2683 fprintf_unfiltered (tmp_error_stream
,
2684 "Overlay breakpoint %d "
2685 "failed: in ROM?\n",
2689 /* Shall we set a breakpoint at the VMA? */
2690 if (section_is_mapped (bl
->section
))
2692 /* Yes. This overlay section is mapped into memory. */
2697 val
= bl
->owner
->ops
->insert_location (bl
);
2699 bp_excpt
= gdb_exception
{RETURN_ERROR
, GENERIC_ERROR
};
2701 catch (gdb_exception
&e
)
2703 bp_excpt
= std::move (e
);
2708 /* No. This breakpoint will not be inserted.
2709 No error, but do not mark the bp as 'inserted'. */
2714 if (bp_excpt
.reason
!= 0)
2716 /* Can't set the breakpoint. */
2718 /* In some cases, we might not be able to insert a
2719 breakpoint in a shared library that has already been
2720 removed, but we have not yet processed the shlib unload
2721 event. Unfortunately, some targets that implement
2722 breakpoint insertion themselves can't tell why the
2723 breakpoint insertion failed (e.g., the remote target
2724 doesn't define error codes), so we must treat generic
2725 errors as memory errors. */
2726 if (bp_excpt
.reason
== RETURN_ERROR
2727 && (bp_excpt
.error
== GENERIC_ERROR
2728 || bp_excpt
.error
== MEMORY_ERROR
)
2729 && bl
->loc_type
== bp_loc_software_breakpoint
2730 && (solib_name_from_address (bl
->pspace
, bl
->address
)
2731 || shared_objfile_contains_address_p (bl
->pspace
,
2734 /* See also: disable_breakpoints_in_shlibs. */
2735 bl
->shlib_disabled
= 1;
2736 gdb::observers::breakpoint_modified
.notify (bl
->owner
);
2737 if (!*disabled_breaks
)
2739 fprintf_unfiltered (tmp_error_stream
,
2740 "Cannot insert breakpoint %d.\n",
2742 fprintf_unfiltered (tmp_error_stream
,
2743 "Temporarily disabling shared "
2744 "library breakpoints:\n");
2746 *disabled_breaks
= 1;
2747 fprintf_unfiltered (tmp_error_stream
,
2748 "breakpoint #%d\n", bl
->owner
->number
);
2753 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
2755 *hw_breakpoint_error
= 1;
2756 *hw_bp_error_explained_already
= bp_excpt
.message
!= NULL
;
2757 fprintf_unfiltered (tmp_error_stream
,
2758 "Cannot insert hardware breakpoint %d%s",
2760 bp_excpt
.message
? ":" : ".\n");
2761 if (bp_excpt
.message
!= NULL
)
2762 fprintf_unfiltered (tmp_error_stream
, "%s.\n",
2767 if (bp_excpt
.message
== NULL
)
2770 = memory_error_message (TARGET_XFER_E_IO
,
2771 bl
->gdbarch
, bl
->address
);
2773 fprintf_unfiltered (tmp_error_stream
,
2774 "Cannot insert breakpoint %d.\n"
2776 bl
->owner
->number
, message
.c_str ());
2780 fprintf_unfiltered (tmp_error_stream
,
2781 "Cannot insert breakpoint %d: %s\n",
2796 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
2797 /* NOTE drow/2003-09-08: This state only exists for removing
2798 watchpoints. It's not clear that it's necessary... */
2799 && bl
->owner
->disposition
!= disp_del_at_next_stop
)
2803 gdb_assert (bl
->owner
->ops
!= NULL
2804 && bl
->owner
->ops
->insert_location
!= NULL
);
2806 val
= bl
->owner
->ops
->insert_location (bl
);
2808 /* If trying to set a read-watchpoint, and it turns out it's not
2809 supported, try emulating one with an access watchpoint. */
2810 if (val
== 1 && bl
->watchpoint_type
== hw_read
)
2812 struct bp_location
*loc
, **loc_temp
;
2814 /* But don't try to insert it, if there's already another
2815 hw_access location that would be considered a duplicate
2817 ALL_BP_LOCATIONS (loc
, loc_temp
)
2819 && loc
->watchpoint_type
== hw_access
2820 && watchpoint_locations_match (bl
, loc
))
2824 bl
->target_info
= loc
->target_info
;
2825 bl
->watchpoint_type
= hw_access
;
2832 bl
->watchpoint_type
= hw_access
;
2833 val
= bl
->owner
->ops
->insert_location (bl
);
2836 /* Back to the original value. */
2837 bl
->watchpoint_type
= hw_read
;
2841 bl
->inserted
= (val
== 0);
2844 else if (bl
->owner
->type
== bp_catchpoint
)
2848 gdb_assert (bl
->owner
->ops
!= NULL
2849 && bl
->owner
->ops
->insert_location
!= NULL
);
2851 val
= bl
->owner
->ops
->insert_location (bl
);
2854 bl
->owner
->enable_state
= bp_disabled
;
2858 Error inserting catchpoint %d: Your system does not support this type\n\
2859 of catchpoint."), bl
->owner
->number
);
2861 warning (_("Error inserting catchpoint %d."), bl
->owner
->number
);
2864 bl
->inserted
= (val
== 0);
2866 /* We've already printed an error message if there was a problem
2867 inserting this catchpoint, and we've disabled the catchpoint,
2868 so just return success. */
2875 /* This function is called when program space PSPACE is about to be
2876 deleted. It takes care of updating breakpoints to not reference
2880 breakpoint_program_space_exit (struct program_space
*pspace
)
2882 struct breakpoint
*b
, *b_temp
;
2883 struct bp_location
*loc
, **loc_temp
;
2885 /* Remove any breakpoint that was set through this program space. */
2886 ALL_BREAKPOINTS_SAFE (b
, b_temp
)
2888 if (b
->pspace
== pspace
)
2889 delete_breakpoint (b
);
2892 /* Breakpoints set through other program spaces could have locations
2893 bound to PSPACE as well. Remove those. */
2894 ALL_BP_LOCATIONS (loc
, loc_temp
)
2896 struct bp_location
*tmp
;
2898 if (loc
->pspace
== pspace
)
2900 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
2901 if (loc
->owner
->loc
== loc
)
2902 loc
->owner
->loc
= loc
->next
;
2904 for (tmp
= loc
->owner
->loc
; tmp
->next
!= NULL
; tmp
= tmp
->next
)
2905 if (tmp
->next
== loc
)
2907 tmp
->next
= loc
->next
;
2913 /* Now update the global location list to permanently delete the
2914 removed locations above. */
2915 update_global_location_list (UGLL_DONT_INSERT
);
2918 /* Make sure all breakpoints are inserted in inferior.
2919 Throws exception on any error.
2920 A breakpoint that is already inserted won't be inserted
2921 again, so calling this function twice is safe. */
2923 insert_breakpoints (void)
2925 struct breakpoint
*bpt
;
2927 ALL_BREAKPOINTS (bpt
)
2928 if (is_hardware_watchpoint (bpt
))
2930 struct watchpoint
*w
= (struct watchpoint
*) bpt
;
2932 update_watchpoint (w
, 0 /* don't reparse. */);
2935 /* Updating watchpoints creates new locations, so update the global
2936 location list. Explicitly tell ugll to insert locations and
2937 ignore breakpoints_always_inserted_mode. Also,
2938 update_global_location_list tries to "upgrade" software
2939 breakpoints to hardware breakpoints to handle "set breakpoint
2940 auto-hw", so we need to call it even if we don't have new
2942 update_global_location_list (UGLL_INSERT
);
2945 /* Invoke CALLBACK for each of bp_location. */
2948 iterate_over_bp_locations (walk_bp_location_callback callback
)
2950 struct bp_location
*loc
, **loc_tmp
;
2952 ALL_BP_LOCATIONS (loc
, loc_tmp
)
2954 callback (loc
, NULL
);
2958 /* This is used when we need to synch breakpoint conditions between GDB and the
2959 target. It is the case with deleting and disabling of breakpoints when using
2960 always-inserted mode. */
2963 update_inserted_breakpoint_locations (void)
2965 struct bp_location
*bl
, **blp_tmp
;
2968 int disabled_breaks
= 0;
2969 int hw_breakpoint_error
= 0;
2970 int hw_bp_details_reported
= 0;
2972 string_file tmp_error_stream
;
2974 /* Explicitly mark the warning -- this will only be printed if
2975 there was an error. */
2976 tmp_error_stream
.puts ("Warning:\n");
2978 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
2980 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2982 /* We only want to update software breakpoints and hardware
2984 if (!is_breakpoint (bl
->owner
))
2987 /* We only want to update locations that are already inserted
2988 and need updating. This is to avoid unwanted insertion during
2989 deletion of breakpoints. */
2990 if (!bl
->inserted
|| !bl
->needs_update
)
2993 switch_to_program_space_and_thread (bl
->pspace
);
2995 /* For targets that support global breakpoints, there's no need
2996 to select an inferior to insert breakpoint to. In fact, even
2997 if we aren't attached to any process yet, we should still
2998 insert breakpoints. */
2999 if (!gdbarch_has_global_breakpoints (target_gdbarch ())
3000 && (inferior_ptid
== null_ptid
|| !target_has_execution ()))
3003 val
= insert_bp_location (bl
, &tmp_error_stream
, &disabled_breaks
,
3004 &hw_breakpoint_error
, &hw_bp_details_reported
);
3011 target_terminal::ours_for_output ();
3012 error_stream (tmp_error_stream
);
3016 /* Used when starting or continuing the program. */
3019 insert_breakpoint_locations (void)
3021 struct breakpoint
*bpt
;
3022 struct bp_location
*bl
, **blp_tmp
;
3025 int disabled_breaks
= 0;
3026 int hw_breakpoint_error
= 0;
3027 int hw_bp_error_explained_already
= 0;
3029 string_file tmp_error_stream
;
3031 /* Explicitly mark the warning -- this will only be printed if
3032 there was an error. */
3033 tmp_error_stream
.puts ("Warning:\n");
3035 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
3037 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3039 if (!should_be_inserted (bl
) || (bl
->inserted
&& !bl
->needs_update
))
3042 /* There is no point inserting thread-specific breakpoints if
3043 the thread no longer exists. ALL_BP_LOCATIONS bp_location
3044 has BL->OWNER always non-NULL. */
3045 if (bl
->owner
->thread
!= -1
3046 && !valid_global_thread_id (bl
->owner
->thread
))
3049 switch_to_program_space_and_thread (bl
->pspace
);
3051 /* For targets that support global breakpoints, there's no need
3052 to select an inferior to insert breakpoint to. In fact, even
3053 if we aren't attached to any process yet, we should still
3054 insert breakpoints. */
3055 if (!gdbarch_has_global_breakpoints (target_gdbarch ())
3056 && (inferior_ptid
== null_ptid
|| !target_has_execution ()))
3059 val
= insert_bp_location (bl
, &tmp_error_stream
, &disabled_breaks
,
3060 &hw_breakpoint_error
, &hw_bp_error_explained_already
);
3065 /* If we failed to insert all locations of a watchpoint, remove
3066 them, as half-inserted watchpoint is of limited use. */
3067 ALL_BREAKPOINTS (bpt
)
3069 int some_failed
= 0;
3070 struct bp_location
*loc
;
3072 if (!is_hardware_watchpoint (bpt
))
3075 if (!breakpoint_enabled (bpt
))
3078 if (bpt
->disposition
== disp_del_at_next_stop
)
3081 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
3082 if (!loc
->inserted
&& should_be_inserted (loc
))
3089 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
3091 remove_breakpoint (loc
);
3093 hw_breakpoint_error
= 1;
3094 tmp_error_stream
.printf ("Could not insert "
3095 "hardware watchpoint %d.\n",
3103 /* If a hardware breakpoint or watchpoint was inserted, add a
3104 message about possibly exhausted resources. */
3105 if (hw_breakpoint_error
&& !hw_bp_error_explained_already
)
3107 tmp_error_stream
.printf ("Could not insert hardware breakpoints:\n\
3108 You may have requested too many hardware breakpoints/watchpoints.\n");
3110 target_terminal::ours_for_output ();
3111 error_stream (tmp_error_stream
);
3115 /* Used when the program stops.
3116 Returns zero if successful, or non-zero if there was a problem
3117 removing a breakpoint location. */
3120 remove_breakpoints (void)
3122 struct bp_location
*bl
, **blp_tmp
;
3125 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3127 if (bl
->inserted
&& !is_tracepoint (bl
->owner
))
3128 val
|= remove_breakpoint (bl
);
3133 /* When a thread exits, remove breakpoints that are related to
3137 remove_threaded_breakpoints (struct thread_info
*tp
, int silent
)
3139 struct breakpoint
*b
, *b_tmp
;
3141 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
3143 if (b
->thread
== tp
->global_num
&& user_breakpoint_p (b
))
3145 b
->disposition
= disp_del_at_next_stop
;
3147 printf_filtered (_("\
3148 Thread-specific breakpoint %d deleted - thread %s no longer in the thread list.\n"),
3149 b
->number
, print_thread_id (tp
));
3151 /* Hide it from the user. */
3157 /* See breakpoint.h. */
3160 remove_breakpoints_inf (inferior
*inf
)
3162 struct bp_location
*bl
, **blp_tmp
;
3165 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3167 if (bl
->pspace
!= inf
->pspace
)
3170 if (bl
->inserted
&& !bl
->target_info
.persist
)
3172 val
= remove_breakpoint (bl
);
3179 static int internal_breakpoint_number
= -1;
3181 /* Set the breakpoint number of B, depending on the value of INTERNAL.
3182 If INTERNAL is non-zero, the breakpoint number will be populated
3183 from internal_breakpoint_number and that variable decremented.
3184 Otherwise the breakpoint number will be populated from
3185 breakpoint_count and that value incremented. Internal breakpoints
3186 do not set the internal var bpnum. */
3188 set_breakpoint_number (int internal
, struct breakpoint
*b
)
3191 b
->number
= internal_breakpoint_number
--;
3194 set_breakpoint_count (breakpoint_count
+ 1);
3195 b
->number
= breakpoint_count
;
3199 static struct breakpoint
*
3200 create_internal_breakpoint (struct gdbarch
*gdbarch
,
3201 CORE_ADDR address
, enum bptype type
,
3202 const struct breakpoint_ops
*ops
)
3204 symtab_and_line sal
;
3206 sal
.section
= find_pc_overlay (sal
.pc
);
3207 sal
.pspace
= current_program_space
;
3209 breakpoint
*b
= set_raw_breakpoint (gdbarch
, sal
, type
, ops
);
3210 b
->number
= internal_breakpoint_number
--;
3211 b
->disposition
= disp_donttouch
;
3216 static const char *const longjmp_names
[] =
3218 "longjmp", "_longjmp", "siglongjmp", "_siglongjmp"
3220 #define NUM_LONGJMP_NAMES ARRAY_SIZE(longjmp_names)
3222 /* Per-objfile data private to breakpoint.c. */
3223 struct breakpoint_objfile_data
3225 /* Minimal symbol for "_ovly_debug_event" (if any). */
3226 struct bound_minimal_symbol overlay_msym
{};
3228 /* Minimal symbol(s) for "longjmp", "siglongjmp", etc. (if any). */
3229 struct bound_minimal_symbol longjmp_msym
[NUM_LONGJMP_NAMES
] {};
3231 /* True if we have looked for longjmp probes. */
3232 int longjmp_searched
= 0;
3234 /* SystemTap probe points for longjmp (if any). These are non-owning
3236 std::vector
<probe
*> longjmp_probes
;
3238 /* Minimal symbol for "std::terminate()" (if any). */
3239 struct bound_minimal_symbol terminate_msym
{};
3241 /* Minimal symbol for "_Unwind_DebugHook" (if any). */
3242 struct bound_minimal_symbol exception_msym
{};
3244 /* True if we have looked for exception probes. */
3245 int exception_searched
= 0;
3247 /* SystemTap probe points for unwinding (if any). These are non-owning
3249 std::vector
<probe
*> exception_probes
;
3252 static const struct objfile_key
<breakpoint_objfile_data
>
3253 breakpoint_objfile_key
;
3255 /* Minimal symbol not found sentinel. */
3256 static struct minimal_symbol msym_not_found
;
3258 /* Returns TRUE if MSYM point to the "not found" sentinel. */
3261 msym_not_found_p (const struct minimal_symbol
*msym
)
3263 return msym
== &msym_not_found
;
3266 /* Return per-objfile data needed by breakpoint.c.
3267 Allocate the data if necessary. */
3269 static struct breakpoint_objfile_data
*
3270 get_breakpoint_objfile_data (struct objfile
*objfile
)
3272 struct breakpoint_objfile_data
*bp_objfile_data
;
3274 bp_objfile_data
= breakpoint_objfile_key
.get (objfile
);
3275 if (bp_objfile_data
== NULL
)
3276 bp_objfile_data
= breakpoint_objfile_key
.emplace (objfile
);
3277 return bp_objfile_data
;
3281 create_overlay_event_breakpoint (void)
3283 const char *const func_name
= "_ovly_debug_event";
3285 for (objfile
*objfile
: current_program_space
->objfiles ())
3287 struct breakpoint
*b
;
3288 struct breakpoint_objfile_data
*bp_objfile_data
;
3290 struct explicit_location explicit_loc
;
3292 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3294 if (msym_not_found_p (bp_objfile_data
->overlay_msym
.minsym
))
3297 if (bp_objfile_data
->overlay_msym
.minsym
== NULL
)
3299 struct bound_minimal_symbol m
;
3301 m
= lookup_minimal_symbol_text (func_name
, objfile
);
3302 if (m
.minsym
== NULL
)
3304 /* Avoid future lookups in this objfile. */
3305 bp_objfile_data
->overlay_msym
.minsym
= &msym_not_found
;
3308 bp_objfile_data
->overlay_msym
= m
;
3311 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->overlay_msym
);
3312 b
= create_internal_breakpoint (objfile
->arch (), addr
,
3314 &internal_breakpoint_ops
);
3315 initialize_explicit_location (&explicit_loc
);
3316 explicit_loc
.function_name
= ASTRDUP (func_name
);
3317 b
->location
= new_explicit_location (&explicit_loc
);
3319 if (overlay_debugging
== ovly_auto
)
3321 b
->enable_state
= bp_enabled
;
3322 overlay_events_enabled
= 1;
3326 b
->enable_state
= bp_disabled
;
3327 overlay_events_enabled
= 0;
3333 create_longjmp_master_breakpoint (void)
3335 scoped_restore_current_program_space restore_pspace
;
3337 for (struct program_space
*pspace
: program_spaces
)
3339 set_current_program_space (pspace
);
3341 for (objfile
*objfile
: current_program_space
->objfiles ())
3344 struct gdbarch
*gdbarch
;
3345 struct breakpoint_objfile_data
*bp_objfile_data
;
3347 gdbarch
= objfile
->arch ();
3349 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3351 if (!bp_objfile_data
->longjmp_searched
)
3353 std::vector
<probe
*> ret
3354 = find_probes_in_objfile (objfile
, "libc", "longjmp");
3358 /* We are only interested in checking one element. */
3361 if (!p
->can_evaluate_arguments ())
3363 /* We cannot use the probe interface here,
3364 because it does not know how to evaluate
3369 bp_objfile_data
->longjmp_probes
= ret
;
3370 bp_objfile_data
->longjmp_searched
= 1;
3373 if (!bp_objfile_data
->longjmp_probes
.empty ())
3375 for (probe
*p
: bp_objfile_data
->longjmp_probes
)
3377 struct breakpoint
*b
;
3379 b
= create_internal_breakpoint (gdbarch
,
3380 p
->get_relocated_address (objfile
),
3382 &internal_breakpoint_ops
);
3383 b
->location
= new_probe_location ("-probe-stap libc:longjmp");
3384 b
->enable_state
= bp_disabled
;
3390 if (!gdbarch_get_longjmp_target_p (gdbarch
))
3393 for (i
= 0; i
< NUM_LONGJMP_NAMES
; i
++)
3395 struct breakpoint
*b
;
3396 const char *func_name
;
3398 struct explicit_location explicit_loc
;
3400 if (msym_not_found_p (bp_objfile_data
->longjmp_msym
[i
].minsym
))
3403 func_name
= longjmp_names
[i
];
3404 if (bp_objfile_data
->longjmp_msym
[i
].minsym
== NULL
)
3406 struct bound_minimal_symbol m
;
3408 m
= lookup_minimal_symbol_text (func_name
, objfile
);
3409 if (m
.minsym
== NULL
)
3411 /* Prevent future lookups in this objfile. */
3412 bp_objfile_data
->longjmp_msym
[i
].minsym
= &msym_not_found
;
3415 bp_objfile_data
->longjmp_msym
[i
] = m
;
3418 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->longjmp_msym
[i
]);
3419 b
= create_internal_breakpoint (gdbarch
, addr
, bp_longjmp_master
,
3420 &internal_breakpoint_ops
);
3421 initialize_explicit_location (&explicit_loc
);
3422 explicit_loc
.function_name
= ASTRDUP (func_name
);
3423 b
->location
= new_explicit_location (&explicit_loc
);
3424 b
->enable_state
= bp_disabled
;
3430 /* Create a master std::terminate breakpoint. */
3432 create_std_terminate_master_breakpoint (void)
3434 const char *const func_name
= "std::terminate()";
3436 scoped_restore_current_program_space restore_pspace
;
3438 for (struct program_space
*pspace
: program_spaces
)
3442 set_current_program_space (pspace
);
3444 for (objfile
*objfile
: current_program_space
->objfiles ())
3446 struct breakpoint
*b
;
3447 struct breakpoint_objfile_data
*bp_objfile_data
;
3448 struct explicit_location explicit_loc
;
3450 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3452 if (msym_not_found_p (bp_objfile_data
->terminate_msym
.minsym
))
3455 if (bp_objfile_data
->terminate_msym
.minsym
== NULL
)
3457 struct bound_minimal_symbol m
;
3459 m
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
3460 if (m
.minsym
== NULL
|| (MSYMBOL_TYPE (m
.minsym
) != mst_text
3461 && MSYMBOL_TYPE (m
.minsym
) != mst_file_text
))
3463 /* Prevent future lookups in this objfile. */
3464 bp_objfile_data
->terminate_msym
.minsym
= &msym_not_found
;
3467 bp_objfile_data
->terminate_msym
= m
;
3470 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->terminate_msym
);
3471 b
= create_internal_breakpoint (objfile
->arch (), addr
,
3472 bp_std_terminate_master
,
3473 &internal_breakpoint_ops
);
3474 initialize_explicit_location (&explicit_loc
);
3475 explicit_loc
.function_name
= ASTRDUP (func_name
);
3476 b
->location
= new_explicit_location (&explicit_loc
);
3477 b
->enable_state
= bp_disabled
;
3482 /* Install a master breakpoint on the unwinder's debug hook. */
3485 create_exception_master_breakpoint (void)
3487 const char *const func_name
= "_Unwind_DebugHook";
3489 for (objfile
*objfile
: current_program_space
->objfiles ())
3491 struct breakpoint
*b
;
3492 struct gdbarch
*gdbarch
;
3493 struct breakpoint_objfile_data
*bp_objfile_data
;
3495 struct explicit_location explicit_loc
;
3497 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3499 /* We prefer the SystemTap probe point if it exists. */
3500 if (!bp_objfile_data
->exception_searched
)
3502 std::vector
<probe
*> ret
3503 = find_probes_in_objfile (objfile
, "libgcc", "unwind");
3507 /* We are only interested in checking one element. */
3510 if (!p
->can_evaluate_arguments ())
3512 /* We cannot use the probe interface here, because it does
3513 not know how to evaluate arguments. */
3517 bp_objfile_data
->exception_probes
= ret
;
3518 bp_objfile_data
->exception_searched
= 1;
3521 if (!bp_objfile_data
->exception_probes
.empty ())
3523 gdbarch
= objfile
->arch ();
3525 for (probe
*p
: bp_objfile_data
->exception_probes
)
3527 b
= create_internal_breakpoint (gdbarch
,
3528 p
->get_relocated_address (objfile
),
3529 bp_exception_master
,
3530 &internal_breakpoint_ops
);
3531 b
->location
= new_probe_location ("-probe-stap libgcc:unwind");
3532 b
->enable_state
= bp_disabled
;
3538 /* Otherwise, try the hook function. */
3540 if (msym_not_found_p (bp_objfile_data
->exception_msym
.minsym
))
3543 gdbarch
= objfile
->arch ();
3545 if (bp_objfile_data
->exception_msym
.minsym
== NULL
)
3547 struct bound_minimal_symbol debug_hook
;
3549 debug_hook
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
3550 if (debug_hook
.minsym
== NULL
)
3552 bp_objfile_data
->exception_msym
.minsym
= &msym_not_found
;
3556 bp_objfile_data
->exception_msym
= debug_hook
;
3559 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->exception_msym
);
3560 addr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, addr
,
3561 current_top_target ());
3562 b
= create_internal_breakpoint (gdbarch
, addr
, bp_exception_master
,
3563 &internal_breakpoint_ops
);
3564 initialize_explicit_location (&explicit_loc
);
3565 explicit_loc
.function_name
= ASTRDUP (func_name
);
3566 b
->location
= new_explicit_location (&explicit_loc
);
3567 b
->enable_state
= bp_disabled
;
3571 /* Does B have a location spec? */
3574 breakpoint_event_location_empty_p (const struct breakpoint
*b
)
3576 return b
->location
!= NULL
&& event_location_empty_p (b
->location
.get ());
3580 update_breakpoints_after_exec (void)
3582 struct breakpoint
*b
, *b_tmp
;
3583 struct bp_location
*bploc
, **bplocp_tmp
;
3585 /* We're about to delete breakpoints from GDB's lists. If the
3586 INSERTED flag is true, GDB will try to lift the breakpoints by
3587 writing the breakpoints' "shadow contents" back into memory. The
3588 "shadow contents" are NOT valid after an exec, so GDB should not
3589 do that. Instead, the target is responsible from marking
3590 breakpoints out as soon as it detects an exec. We don't do that
3591 here instead, because there may be other attempts to delete
3592 breakpoints after detecting an exec and before reaching here. */
3593 ALL_BP_LOCATIONS (bploc
, bplocp_tmp
)
3594 if (bploc
->pspace
== current_program_space
)
3595 gdb_assert (!bploc
->inserted
);
3597 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
3599 if (b
->pspace
!= current_program_space
)
3602 /* Solib breakpoints must be explicitly reset after an exec(). */
3603 if (b
->type
== bp_shlib_event
)
3605 delete_breakpoint (b
);
3609 /* JIT breakpoints must be explicitly reset after an exec(). */
3610 if (b
->type
== bp_jit_event
)
3612 delete_breakpoint (b
);
3616 /* Thread event breakpoints must be set anew after an exec(),
3617 as must overlay event and longjmp master breakpoints. */
3618 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
3619 || b
->type
== bp_longjmp_master
|| b
->type
== bp_std_terminate_master
3620 || b
->type
== bp_exception_master
)
3622 delete_breakpoint (b
);
3626 /* Step-resume breakpoints are meaningless after an exec(). */
3627 if (b
->type
== bp_step_resume
|| b
->type
== bp_hp_step_resume
)
3629 delete_breakpoint (b
);
3633 /* Just like single-step breakpoints. */
3634 if (b
->type
== bp_single_step
)
3636 delete_breakpoint (b
);
3640 /* Longjmp and longjmp-resume breakpoints are also meaningless
3642 if (b
->type
== bp_longjmp
|| b
->type
== bp_longjmp_resume
3643 || b
->type
== bp_longjmp_call_dummy
3644 || b
->type
== bp_exception
|| b
->type
== bp_exception_resume
)
3646 delete_breakpoint (b
);
3650 if (b
->type
== bp_catchpoint
)
3652 /* For now, none of the bp_catchpoint breakpoints need to
3653 do anything at this point. In the future, if some of
3654 the catchpoints need to something, we will need to add
3655 a new method, and call this method from here. */
3659 /* bp_finish is a special case. The only way we ought to be able
3660 to see one of these when an exec() has happened, is if the user
3661 caught a vfork, and then said "finish". Ordinarily a finish just
3662 carries them to the call-site of the current callee, by setting
3663 a temporary bp there and resuming. But in this case, the finish
3664 will carry them entirely through the vfork & exec.
3666 We don't want to allow a bp_finish to remain inserted now. But
3667 we can't safely delete it, 'cause finish_command has a handle to
3668 the bp on a bpstat, and will later want to delete it. There's a
3669 chance (and I've seen it happen) that if we delete the bp_finish
3670 here, that its storage will get reused by the time finish_command
3671 gets 'round to deleting the "use to be a bp_finish" breakpoint.
3672 We really must allow finish_command to delete a bp_finish.
3674 In the absence of a general solution for the "how do we know
3675 it's safe to delete something others may have handles to?"
3676 problem, what we'll do here is just uninsert the bp_finish, and
3677 let finish_command delete it.
3679 (We know the bp_finish is "doomed" in the sense that it's
3680 momentary, and will be deleted as soon as finish_command sees
3681 the inferior stopped. So it doesn't matter that the bp's
3682 address is probably bogus in the new a.out, unlike e.g., the
3683 solib breakpoints.) */
3685 if (b
->type
== bp_finish
)
3690 /* Without a symbolic address, we have little hope of the
3691 pre-exec() address meaning the same thing in the post-exec()
3693 if (breakpoint_event_location_empty_p (b
))
3695 delete_breakpoint (b
);
3702 detach_breakpoints (ptid_t ptid
)
3704 struct bp_location
*bl
, **blp_tmp
;
3706 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
3707 struct inferior
*inf
= current_inferior ();
3709 if (ptid
.pid () == inferior_ptid
.pid ())
3710 error (_("Cannot detach breakpoints of inferior_ptid"));
3712 /* Set inferior_ptid; remove_breakpoint_1 uses this global. */
3713 inferior_ptid
= ptid
;
3714 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3716 if (bl
->pspace
!= inf
->pspace
)
3719 /* This function must physically remove breakpoints locations
3720 from the specified ptid, without modifying the breakpoint
3721 package's state. Locations of type bp_loc_other are only
3722 maintained at GDB side. So, there is no need to remove
3723 these bp_loc_other locations. Moreover, removing these
3724 would modify the breakpoint package's state. */
3725 if (bl
->loc_type
== bp_loc_other
)
3729 val
|= remove_breakpoint_1 (bl
, DETACH_BREAKPOINT
);
3735 /* Remove the breakpoint location BL from the current address space.
3736 Note that this is used to detach breakpoints from a child fork.
3737 When we get here, the child isn't in the inferior list, and neither
3738 do we have objects to represent its address space --- we should
3739 *not* look at bl->pspace->aspace here. */
3742 remove_breakpoint_1 (struct bp_location
*bl
, enum remove_bp_reason reason
)
3746 /* BL is never in moribund_locations by our callers. */
3747 gdb_assert (bl
->owner
!= NULL
);
3749 /* The type of none suggests that owner is actually deleted.
3750 This should not ever happen. */
3751 gdb_assert (bl
->owner
->type
!= bp_none
);
3753 if (bl
->loc_type
== bp_loc_software_breakpoint
3754 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
3756 /* "Normal" instruction breakpoint: either the standard
3757 trap-instruction bp (bp_breakpoint), or a
3758 bp_hardware_breakpoint. */
3760 /* First check to see if we have to handle an overlay. */
3761 if (overlay_debugging
== ovly_off
3762 || bl
->section
== NULL
3763 || !(section_is_overlay (bl
->section
)))
3765 /* No overlay handling: just remove the breakpoint. */
3767 /* If we're trying to uninsert a memory breakpoint that we
3768 know is set in a dynamic object that is marked
3769 shlib_disabled, then either the dynamic object was
3770 removed with "remove-symbol-file" or with
3771 "nosharedlibrary". In the former case, we don't know
3772 whether another dynamic object might have loaded over the
3773 breakpoint's address -- the user might well let us know
3774 about it next with add-symbol-file (the whole point of
3775 add-symbol-file is letting the user manually maintain a
3776 list of dynamically loaded objects). If we have the
3777 breakpoint's shadow memory, that is, this is a software
3778 breakpoint managed by GDB, check whether the breakpoint
3779 is still inserted in memory, to avoid overwriting wrong
3780 code with stale saved shadow contents. Note that HW
3781 breakpoints don't have shadow memory, as they're
3782 implemented using a mechanism that is not dependent on
3783 being able to modify the target's memory, and as such
3784 they should always be removed. */
3785 if (bl
->shlib_disabled
3786 && bl
->target_info
.shadow_len
!= 0
3787 && !memory_validate_breakpoint (bl
->gdbarch
, &bl
->target_info
))
3790 val
= bl
->owner
->ops
->remove_location (bl
, reason
);
3794 /* This breakpoint is in an overlay section.
3795 Did we set a breakpoint at the LMA? */
3796 if (!overlay_events_enabled
)
3798 /* Yes -- overlay event support is not active, so we
3799 should have set a breakpoint at the LMA. Remove it.
3801 /* Ignore any failures: if the LMA is in ROM, we will
3802 have already warned when we failed to insert it. */
3803 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
3804 target_remove_hw_breakpoint (bl
->gdbarch
,
3805 &bl
->overlay_target_info
);
3807 target_remove_breakpoint (bl
->gdbarch
,
3808 &bl
->overlay_target_info
,
3811 /* Did we set a breakpoint at the VMA?
3812 If so, we will have marked the breakpoint 'inserted'. */
3815 /* Yes -- remove it. Previously we did not bother to
3816 remove the breakpoint if the section had been
3817 unmapped, but let's not rely on that being safe. We
3818 don't know what the overlay manager might do. */
3820 /* However, we should remove *software* breakpoints only
3821 if the section is still mapped, or else we overwrite
3822 wrong code with the saved shadow contents. */
3823 if (bl
->loc_type
== bp_loc_hardware_breakpoint
3824 || section_is_mapped (bl
->section
))
3825 val
= bl
->owner
->ops
->remove_location (bl
, reason
);
3831 /* No -- not inserted, so no need to remove. No error. */
3836 /* In some cases, we might not be able to remove a breakpoint in
3837 a shared library that has already been removed, but we have
3838 not yet processed the shlib unload event. Similarly for an
3839 unloaded add-symbol-file object - the user might not yet have
3840 had the chance to remove-symbol-file it. shlib_disabled will
3841 be set if the library/object has already been removed, but
3842 the breakpoint hasn't been uninserted yet, e.g., after
3843 "nosharedlibrary" or "remove-symbol-file" with breakpoints
3844 always-inserted mode. */
3846 && (bl
->loc_type
== bp_loc_software_breakpoint
3847 && (bl
->shlib_disabled
3848 || solib_name_from_address (bl
->pspace
, bl
->address
)
3849 || shared_objfile_contains_address_p (bl
->pspace
,
3855 bl
->inserted
= (reason
== DETACH_BREAKPOINT
);
3857 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
)
3859 gdb_assert (bl
->owner
->ops
!= NULL
3860 && bl
->owner
->ops
->remove_location
!= NULL
);
3862 bl
->inserted
= (reason
== DETACH_BREAKPOINT
);
3863 bl
->owner
->ops
->remove_location (bl
, reason
);
3865 /* Failure to remove any of the hardware watchpoints comes here. */
3866 if (reason
== REMOVE_BREAKPOINT
&& bl
->inserted
)
3867 warning (_("Could not remove hardware watchpoint %d."),
3870 else if (bl
->owner
->type
== bp_catchpoint
3871 && breakpoint_enabled (bl
->owner
)
3874 gdb_assert (bl
->owner
->ops
!= NULL
3875 && bl
->owner
->ops
->remove_location
!= NULL
);
3877 val
= bl
->owner
->ops
->remove_location (bl
, reason
);
3881 bl
->inserted
= (reason
== DETACH_BREAKPOINT
);
3888 remove_breakpoint (struct bp_location
*bl
)
3890 /* BL is never in moribund_locations by our callers. */
3891 gdb_assert (bl
->owner
!= NULL
);
3893 /* The type of none suggests that owner is actually deleted.
3894 This should not ever happen. */
3895 gdb_assert (bl
->owner
->type
!= bp_none
);
3897 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
3899 switch_to_program_space_and_thread (bl
->pspace
);
3901 return remove_breakpoint_1 (bl
, REMOVE_BREAKPOINT
);
3904 /* Clear the "inserted" flag in all breakpoints. */
3907 mark_breakpoints_out (void)
3909 struct bp_location
*bl
, **blp_tmp
;
3911 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3912 if (bl
->pspace
== current_program_space
)
3916 /* Clear the "inserted" flag in all breakpoints and delete any
3917 breakpoints which should go away between runs of the program.
3919 Plus other such housekeeping that has to be done for breakpoints
3922 Note: this function gets called at the end of a run (by
3923 generic_mourn_inferior) and when a run begins (by
3924 init_wait_for_inferior). */
3929 breakpoint_init_inferior (enum inf_context context
)
3931 struct breakpoint
*b
, *b_tmp
;
3932 struct program_space
*pspace
= current_program_space
;
3934 /* If breakpoint locations are shared across processes, then there's
3936 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
3939 mark_breakpoints_out ();
3941 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
3943 if (b
->loc
&& b
->loc
->pspace
!= pspace
)
3949 case bp_longjmp_call_dummy
:
3951 /* If the call dummy breakpoint is at the entry point it will
3952 cause problems when the inferior is rerun, so we better get
3955 case bp_watchpoint_scope
:
3957 /* Also get rid of scope breakpoints. */
3959 case bp_shlib_event
:
3961 /* Also remove solib event breakpoints. Their addresses may
3962 have changed since the last time we ran the program.
3963 Actually we may now be debugging against different target;
3964 and so the solib backend that installed this breakpoint may
3965 not be used in by the target. E.g.,
3967 (gdb) file prog-linux
3968 (gdb) run # native linux target
3971 (gdb) file prog-win.exe
3972 (gdb) tar rem :9999 # remote Windows gdbserver.
3975 case bp_step_resume
:
3977 /* Also remove step-resume breakpoints. */
3979 case bp_single_step
:
3981 /* Also remove single-step breakpoints. */
3983 delete_breakpoint (b
);
3987 case bp_hardware_watchpoint
:
3988 case bp_read_watchpoint
:
3989 case bp_access_watchpoint
:
3991 struct watchpoint
*w
= (struct watchpoint
*) b
;
3993 /* Likewise for watchpoints on local expressions. */
3994 if (w
->exp_valid_block
!= NULL
)
3995 delete_breakpoint (b
);
3998 /* Get rid of existing locations, which are no longer
3999 valid. New ones will be created in
4000 update_watchpoint, when the inferior is restarted.
4001 The next update_global_location_list call will
4002 garbage collect them. */
4005 if (context
== inf_starting
)
4007 /* Reset val field to force reread of starting value in
4008 insert_breakpoints. */
4009 w
->val
.reset (nullptr);
4010 w
->val_valid
= false;
4020 /* Get rid of the moribund locations. */
4021 for (bp_location
*bl
: moribund_locations
)
4022 decref_bp_location (&bl
);
4023 moribund_locations
.clear ();
4026 /* These functions concern about actual breakpoints inserted in the
4027 target --- to e.g. check if we need to do decr_pc adjustment or if
4028 we need to hop over the bkpt --- so we check for address space
4029 match, not program space. */
4031 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
4032 exists at PC. It returns ordinary_breakpoint_here if it's an
4033 ordinary breakpoint, or permanent_breakpoint_here if it's a
4034 permanent breakpoint.
4035 - When continuing from a location with an ordinary breakpoint, we
4036 actually single step once before calling insert_breakpoints.
4037 - When continuing from a location with a permanent breakpoint, we
4038 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
4039 the target, to advance the PC past the breakpoint. */
4041 enum breakpoint_here
4042 breakpoint_here_p (const address_space
*aspace
, CORE_ADDR pc
)
4044 struct bp_location
*bl
, **blp_tmp
;
4045 int any_breakpoint_here
= 0;
4047 ALL_BP_LOCATIONS (bl
, blp_tmp
)
4049 if (bl
->loc_type
!= bp_loc_software_breakpoint
4050 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4053 /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
4054 if ((breakpoint_enabled (bl
->owner
)
4056 && breakpoint_location_address_match (bl
, aspace
, pc
))
4058 if (overlay_debugging
4059 && section_is_overlay (bl
->section
)
4060 && !section_is_mapped (bl
->section
))
4061 continue; /* unmapped overlay -- can't be a match */
4062 else if (bl
->permanent
)
4063 return permanent_breakpoint_here
;
4065 any_breakpoint_here
= 1;
4069 return any_breakpoint_here
? ordinary_breakpoint_here
: no_breakpoint_here
;
4072 /* See breakpoint.h. */
4075 breakpoint_in_range_p (const address_space
*aspace
,
4076 CORE_ADDR addr
, ULONGEST len
)
4078 struct bp_location
*bl
, **blp_tmp
;
4080 ALL_BP_LOCATIONS (bl
, blp_tmp
)
4082 if (bl
->loc_type
!= bp_loc_software_breakpoint
4083 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4086 if ((breakpoint_enabled (bl
->owner
)
4088 && breakpoint_location_address_range_overlap (bl
, aspace
,
4091 if (overlay_debugging
4092 && section_is_overlay (bl
->section
)
4093 && !section_is_mapped (bl
->section
))
4095 /* Unmapped overlay -- can't be a match. */
4106 /* Return true if there's a moribund breakpoint at PC. */
4109 moribund_breakpoint_here_p (const address_space
*aspace
, CORE_ADDR pc
)
4111 for (bp_location
*loc
: moribund_locations
)
4112 if (breakpoint_location_address_match (loc
, aspace
, pc
))
4118 /* Returns non-zero iff BL is inserted at PC, in address space
4122 bp_location_inserted_here_p (struct bp_location
*bl
,
4123 const address_space
*aspace
, CORE_ADDR pc
)
4126 && breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
4129 if (overlay_debugging
4130 && section_is_overlay (bl
->section
)
4131 && !section_is_mapped (bl
->section
))
4132 return 0; /* unmapped overlay -- can't be a match */
4139 /* Returns non-zero iff there's a breakpoint inserted at PC. */
4142 breakpoint_inserted_here_p (const address_space
*aspace
, CORE_ADDR pc
)
4144 struct bp_location
**blp
, **blp_tmp
= NULL
;
4146 ALL_BP_LOCATIONS_AT_ADDR (blp
, blp_tmp
, pc
)
4148 struct bp_location
*bl
= *blp
;
4150 if (bl
->loc_type
!= bp_loc_software_breakpoint
4151 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4154 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4160 /* This function returns non-zero iff there is a software breakpoint
4164 software_breakpoint_inserted_here_p (const address_space
*aspace
,
4167 struct bp_location
**blp
, **blp_tmp
= NULL
;
4169 ALL_BP_LOCATIONS_AT_ADDR (blp
, blp_tmp
, pc
)
4171 struct bp_location
*bl
= *blp
;
4173 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
4176 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4183 /* See breakpoint.h. */
4186 hardware_breakpoint_inserted_here_p (const address_space
*aspace
,
4189 struct bp_location
**blp
, **blp_tmp
= NULL
;
4191 ALL_BP_LOCATIONS_AT_ADDR (blp
, blp_tmp
, pc
)
4193 struct bp_location
*bl
= *blp
;
4195 if (bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4198 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4206 hardware_watchpoint_inserted_in_range (const address_space
*aspace
,
4207 CORE_ADDR addr
, ULONGEST len
)
4209 struct breakpoint
*bpt
;
4211 ALL_BREAKPOINTS (bpt
)
4213 struct bp_location
*loc
;
4215 if (bpt
->type
!= bp_hardware_watchpoint
4216 && bpt
->type
!= bp_access_watchpoint
)
4219 if (!breakpoint_enabled (bpt
))
4222 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
4223 if (loc
->pspace
->aspace
== aspace
&& loc
->inserted
)
4227 /* Check for intersection. */
4228 l
= std::max
<CORE_ADDR
> (loc
->address
, addr
);
4229 h
= std::min
<CORE_ADDR
> (loc
->address
+ loc
->length
, addr
+ len
);
4237 /* See breakpoint.h. */
4240 is_catchpoint (struct breakpoint
*b
)
4242 return (b
->type
== bp_catchpoint
);
4245 /* Frees any storage that is part of a bpstat. Does not walk the
4248 bpstats::~bpstats ()
4250 if (bp_location_at
!= NULL
)
4251 decref_bp_location (&bp_location_at
);
4254 /* Clear a bpstat so that it says we are not at any breakpoint.
4255 Also free any storage that is part of a bpstat. */
4258 bpstat_clear (bpstat
*bsp
)
4275 bpstats::bpstats (const bpstats
&other
)
4277 bp_location_at (other
.bp_location_at
),
4278 breakpoint_at (other
.breakpoint_at
),
4279 commands (other
.commands
),
4280 print (other
.print
),
4282 print_it (other
.print_it
)
4284 if (other
.old_val
!= NULL
)
4285 old_val
= release_value (value_copy (other
.old_val
.get ()));
4286 incref_bp_location (bp_location_at
);
4289 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
4290 is part of the bpstat is copied as well. */
4293 bpstat_copy (bpstat bs
)
4297 bpstat retval
= NULL
;
4302 for (; bs
!= NULL
; bs
= bs
->next
)
4304 tmp
= new bpstats (*bs
);
4307 /* This is the first thing in the chain. */
4317 /* Find the bpstat associated with this breakpoint. */
4320 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
4325 for (; bsp
!= NULL
; bsp
= bsp
->next
)
4327 if (bsp
->breakpoint_at
== breakpoint
)
4333 /* See breakpoint.h. */
4336 bpstat_explains_signal (bpstat bsp
, enum gdb_signal sig
)
4338 for (; bsp
!= NULL
; bsp
= bsp
->next
)
4340 if (bsp
->breakpoint_at
== NULL
)
4342 /* A moribund location can never explain a signal other than
4344 if (sig
== GDB_SIGNAL_TRAP
)
4349 if (bsp
->breakpoint_at
->ops
->explains_signal (bsp
->breakpoint_at
,
4358 /* Put in *NUM the breakpoint number of the first breakpoint we are
4359 stopped at. *BSP upon return is a bpstat which points to the
4360 remaining breakpoints stopped at (but which is not guaranteed to be
4361 good for anything but further calls to bpstat_num).
4363 Return 0 if passed a bpstat which does not indicate any breakpoints.
4364 Return -1 if stopped at a breakpoint that has been deleted since
4366 Return 1 otherwise. */
4369 bpstat_num (bpstat
*bsp
, int *num
)
4371 struct breakpoint
*b
;
4374 return 0; /* No more breakpoint values */
4376 /* We assume we'll never have several bpstats that correspond to a
4377 single breakpoint -- otherwise, this function might return the
4378 same number more than once and this will look ugly. */
4379 b
= (*bsp
)->breakpoint_at
;
4380 *bsp
= (*bsp
)->next
;
4382 return -1; /* breakpoint that's been deleted since */
4384 *num
= b
->number
; /* We have its number */
4388 /* See breakpoint.h. */
4391 bpstat_clear_actions (void)
4395 if (inferior_ptid
== null_ptid
)
4398 thread_info
*tp
= inferior_thread ();
4399 for (bs
= tp
->control
.stop_bpstat
; bs
!= NULL
; bs
= bs
->next
)
4401 bs
->commands
= NULL
;
4402 bs
->old_val
.reset (nullptr);
4406 /* Called when a command is about to proceed the inferior. */
4409 breakpoint_about_to_proceed (void)
4411 if (inferior_ptid
!= null_ptid
)
4413 struct thread_info
*tp
= inferior_thread ();
4415 /* Allow inferior function calls in breakpoint commands to not
4416 interrupt the command list. When the call finishes
4417 successfully, the inferior will be standing at the same
4418 breakpoint as if nothing happened. */
4419 if (tp
->control
.in_infcall
)
4423 breakpoint_proceeded
= 1;
4426 /* Return non-zero iff CMD as the first line of a command sequence is `silent'
4427 or its equivalent. */
4430 command_line_is_silent (struct command_line
*cmd
)
4432 return cmd
&& (strcmp ("silent", cmd
->line
) == 0);
4435 /* Execute all the commands associated with all the breakpoints at
4436 this location. Any of these commands could cause the process to
4437 proceed beyond this point, etc. We look out for such changes by
4438 checking the global "breakpoint_proceeded" after each command.
4440 Returns true if a breakpoint command resumed the inferior. In that
4441 case, it is the caller's responsibility to recall it again with the
4442 bpstat of the current thread. */
4445 bpstat_do_actions_1 (bpstat
*bsp
)
4450 /* Avoid endless recursion if a `source' command is contained
4452 if (executing_breakpoint_commands
)
4455 scoped_restore save_executing
4456 = make_scoped_restore (&executing_breakpoint_commands
, 1);
4458 scoped_restore preventer
= prevent_dont_repeat ();
4460 /* This pointer will iterate over the list of bpstat's. */
4463 breakpoint_proceeded
= 0;
4464 for (; bs
!= NULL
; bs
= bs
->next
)
4466 struct command_line
*cmd
= NULL
;
4468 /* Take ownership of the BSP's command tree, if it has one.
4470 The command tree could legitimately contain commands like
4471 'step' and 'next', which call clear_proceed_status, which
4472 frees stop_bpstat's command tree. To make sure this doesn't
4473 free the tree we're executing out from under us, we need to
4474 take ownership of the tree ourselves. Since a given bpstat's
4475 commands are only executed once, we don't need to copy it; we
4476 can clear the pointer in the bpstat, and make sure we free
4477 the tree when we're done. */
4478 counted_command_line ccmd
= bs
->commands
;
4479 bs
->commands
= NULL
;
4482 if (command_line_is_silent (cmd
))
4484 /* The action has been already done by bpstat_stop_status. */
4490 execute_control_command (cmd
);
4492 if (breakpoint_proceeded
)
4498 if (breakpoint_proceeded
)
4500 if (current_ui
->async
)
4501 /* If we are in async mode, then the target might be still
4502 running, not stopped at any breakpoint, so nothing for
4503 us to do here -- just return to the event loop. */
4506 /* In sync mode, when execute_control_command returns
4507 we're already standing on the next breakpoint.
4508 Breakpoint commands for that stop were not run, since
4509 execute_command does not run breakpoint commands --
4510 only command_line_handler does, but that one is not
4511 involved in execution of breakpoint commands. So, we
4512 can now execute breakpoint commands. It should be
4513 noted that making execute_command do bpstat actions is
4514 not an option -- in this case we'll have recursive
4515 invocation of bpstat for each breakpoint with a
4516 command, and can easily blow up GDB stack. Instead, we
4517 return true, which will trigger the caller to recall us
4518 with the new stop_bpstat. */
4526 /* Helper for bpstat_do_actions. Get the current thread, if there's
4527 one, is alive and has execution. Return NULL otherwise. */
4529 static thread_info
*
4530 get_bpstat_thread ()
4532 if (inferior_ptid
== null_ptid
|| !target_has_execution ())
4535 thread_info
*tp
= inferior_thread ();
4536 if (tp
->state
== THREAD_EXITED
|| tp
->executing
)
4542 bpstat_do_actions (void)
4544 auto cleanup_if_error
= make_scope_exit (bpstat_clear_actions
);
4547 /* Do any commands attached to breakpoint we are stopped at. */
4548 while ((tp
= get_bpstat_thread ()) != NULL
)
4550 /* Since in sync mode, bpstat_do_actions may resume the
4551 inferior, and only return when it is stopped at the next
4552 breakpoint, we keep doing breakpoint actions until it returns
4553 false to indicate the inferior was not resumed. */
4554 if (!bpstat_do_actions_1 (&tp
->control
.stop_bpstat
))
4558 cleanup_if_error
.release ();
4561 /* Print out the (old or new) value associated with a watchpoint. */
4564 watchpoint_value_print (struct value
*val
, struct ui_file
*stream
)
4567 fprintf_styled (stream
, metadata_style
.style (), _("<unreadable>"));
4570 struct value_print_options opts
;
4571 get_user_print_options (&opts
);
4572 value_print (val
, stream
, &opts
);
4576 /* Print the "Thread ID hit" part of "Thread ID hit Breakpoint N" if
4577 debugging multiple threads. */
4580 maybe_print_thread_hit_breakpoint (struct ui_out
*uiout
)
4582 if (uiout
->is_mi_like_p ())
4587 if (show_thread_that_caused_stop ())
4590 struct thread_info
*thr
= inferior_thread ();
4592 uiout
->text ("Thread ");
4593 uiout
->field_string ("thread-id", print_thread_id (thr
));
4595 name
= thr
->name
!= NULL
? thr
->name
: target_thread_name (thr
);
4598 uiout
->text (" \"");
4599 uiout
->field_string ("name", name
);
4603 uiout
->text (" hit ");
4607 /* Generic routine for printing messages indicating why we
4608 stopped. The behavior of this function depends on the value
4609 'print_it' in the bpstat structure. Under some circumstances we
4610 may decide not to print anything here and delegate the task to
4613 static enum print_stop_action
4614 print_bp_stop_message (bpstat bs
)
4616 switch (bs
->print_it
)
4619 /* Nothing should be printed for this bpstat entry. */
4620 return PRINT_UNKNOWN
;
4624 /* We still want to print the frame, but we already printed the
4625 relevant messages. */
4626 return PRINT_SRC_AND_LOC
;
4629 case print_it_normal
:
4631 struct breakpoint
*b
= bs
->breakpoint_at
;
4633 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
4634 which has since been deleted. */
4636 return PRINT_UNKNOWN
;
4638 /* Normal case. Call the breakpoint's print_it method. */
4639 return b
->ops
->print_it (bs
);
4644 internal_error (__FILE__
, __LINE__
,
4645 _("print_bp_stop_message: unrecognized enum value"));
4650 /* A helper function that prints a shared library stopped event. */
4653 print_solib_event (int is_catchpoint
)
4655 bool any_deleted
= !current_program_space
->deleted_solibs
.empty ();
4656 bool any_added
= !current_program_space
->added_solibs
.empty ();
4660 if (any_added
|| any_deleted
)
4661 current_uiout
->text (_("Stopped due to shared library event:\n"));
4663 current_uiout
->text (_("Stopped due to shared library event (no "
4664 "libraries added or removed)\n"));
4667 if (current_uiout
->is_mi_like_p ())
4668 current_uiout
->field_string ("reason",
4669 async_reason_lookup (EXEC_ASYNC_SOLIB_EVENT
));
4673 current_uiout
->text (_(" Inferior unloaded "));
4674 ui_out_emit_list
list_emitter (current_uiout
, "removed");
4675 for (int ix
= 0; ix
< current_program_space
->deleted_solibs
.size (); ix
++)
4677 const std::string
&name
= current_program_space
->deleted_solibs
[ix
];
4680 current_uiout
->text (" ");
4681 current_uiout
->field_string ("library", name
);
4682 current_uiout
->text ("\n");
4688 current_uiout
->text (_(" Inferior loaded "));
4689 ui_out_emit_list
list_emitter (current_uiout
, "added");
4691 for (so_list
*iter
: current_program_space
->added_solibs
)
4694 current_uiout
->text (" ");
4696 current_uiout
->field_string ("library", iter
->so_name
);
4697 current_uiout
->text ("\n");
4702 /* Print a message indicating what happened. This is called from
4703 normal_stop(). The input to this routine is the head of the bpstat
4704 list - a list of the eventpoints that caused this stop. KIND is
4705 the target_waitkind for the stopping event. This
4706 routine calls the generic print routine for printing a message
4707 about reasons for stopping. This will print (for example) the
4708 "Breakpoint n," part of the output. The return value of this
4711 PRINT_UNKNOWN: Means we printed nothing.
4712 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
4713 code to print the location. An example is
4714 "Breakpoint 1, " which should be followed by
4716 PRINT_SRC_ONLY: Means we printed something, but there is no need
4717 to also print the location part of the message.
4718 An example is the catch/throw messages, which
4719 don't require a location appended to the end.
4720 PRINT_NOTHING: We have done some printing and we don't need any
4721 further info to be printed. */
4723 enum print_stop_action
4724 bpstat_print (bpstat bs
, int kind
)
4726 enum print_stop_action val
;
4728 /* Maybe another breakpoint in the chain caused us to stop.
4729 (Currently all watchpoints go on the bpstat whether hit or not.
4730 That probably could (should) be changed, provided care is taken
4731 with respect to bpstat_explains_signal). */
4732 for (; bs
; bs
= bs
->next
)
4734 val
= print_bp_stop_message (bs
);
4735 if (val
== PRINT_SRC_ONLY
4736 || val
== PRINT_SRC_AND_LOC
4737 || val
== PRINT_NOTHING
)
4741 /* If we had hit a shared library event breakpoint,
4742 print_bp_stop_message would print out this message. If we hit an
4743 OS-level shared library event, do the same thing. */
4744 if (kind
== TARGET_WAITKIND_LOADED
)
4746 print_solib_event (0);
4747 return PRINT_NOTHING
;
4750 /* We reached the end of the chain, or we got a null BS to start
4751 with and nothing was printed. */
4752 return PRINT_UNKNOWN
;
4755 /* Evaluate the boolean expression EXP and return the result. */
4758 breakpoint_cond_eval (expression
*exp
)
4760 struct value
*mark
= value_mark ();
4761 bool res
= value_true (evaluate_expression (exp
));
4763 value_free_to_mark (mark
);
4767 /* Allocate a new bpstat. Link it to the FIFO list by BS_LINK_POINTER. */
4769 bpstats::bpstats (struct bp_location
*bl
, bpstat
**bs_link_pointer
)
4771 bp_location_at (bl
),
4772 breakpoint_at (bl
->owner
),
4776 print_it (print_it_normal
)
4778 incref_bp_location (bl
);
4779 **bs_link_pointer
= this;
4780 *bs_link_pointer
= &next
;
4785 bp_location_at (NULL
),
4786 breakpoint_at (NULL
),
4790 print_it (print_it_normal
)
4794 /* The target has stopped with waitstatus WS. Check if any hardware
4795 watchpoints have triggered, according to the target. */
4798 watchpoints_triggered (struct target_waitstatus
*ws
)
4800 bool stopped_by_watchpoint
= target_stopped_by_watchpoint ();
4802 struct breakpoint
*b
;
4804 if (!stopped_by_watchpoint
)
4806 /* We were not stopped by a watchpoint. Mark all watchpoints
4807 as not triggered. */
4809 if (is_hardware_watchpoint (b
))
4811 struct watchpoint
*w
= (struct watchpoint
*) b
;
4813 w
->watchpoint_triggered
= watch_triggered_no
;
4819 if (!target_stopped_data_address (current_top_target (), &addr
))
4821 /* We were stopped by a watchpoint, but we don't know where.
4822 Mark all watchpoints as unknown. */
4824 if (is_hardware_watchpoint (b
))
4826 struct watchpoint
*w
= (struct watchpoint
*) b
;
4828 w
->watchpoint_triggered
= watch_triggered_unknown
;
4834 /* The target could report the data address. Mark watchpoints
4835 affected by this data address as triggered, and all others as not
4839 if (is_hardware_watchpoint (b
))
4841 struct watchpoint
*w
= (struct watchpoint
*) b
;
4842 struct bp_location
*loc
;
4844 w
->watchpoint_triggered
= watch_triggered_no
;
4845 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
4847 if (is_masked_watchpoint (b
))
4849 CORE_ADDR newaddr
= addr
& w
->hw_wp_mask
;
4850 CORE_ADDR start
= loc
->address
& w
->hw_wp_mask
;
4852 if (newaddr
== start
)
4854 w
->watchpoint_triggered
= watch_triggered_yes
;
4858 /* Exact match not required. Within range is sufficient. */
4859 else if (target_watchpoint_addr_within_range (current_top_target (),
4863 w
->watchpoint_triggered
= watch_triggered_yes
;
4872 /* Possible return values for watchpoint_check. */
4873 enum wp_check_result
4875 /* The watchpoint has been deleted. */
4878 /* The value has changed. */
4879 WP_VALUE_CHANGED
= 2,
4881 /* The value has not changed. */
4882 WP_VALUE_NOT_CHANGED
= 3,
4884 /* Ignore this watchpoint, no matter if the value changed or not. */
4888 #define BP_TEMPFLAG 1
4889 #define BP_HARDWAREFLAG 2
4891 /* Evaluate watchpoint condition expression and check if its value
4894 static wp_check_result
4895 watchpoint_check (bpstat bs
)
4897 struct watchpoint
*b
;
4898 struct frame_info
*fr
;
4899 int within_current_scope
;
4901 /* BS is built from an existing struct breakpoint. */
4902 gdb_assert (bs
->breakpoint_at
!= NULL
);
4903 b
= (struct watchpoint
*) bs
->breakpoint_at
;
4905 /* If this is a local watchpoint, we only want to check if the
4906 watchpoint frame is in scope if the current thread is the thread
4907 that was used to create the watchpoint. */
4908 if (!watchpoint_in_thread_scope (b
))
4911 if (b
->exp_valid_block
== NULL
)
4912 within_current_scope
= 1;
4915 struct frame_info
*frame
= get_current_frame ();
4916 struct gdbarch
*frame_arch
= get_frame_arch (frame
);
4917 CORE_ADDR frame_pc
= get_frame_pc (frame
);
4919 /* stack_frame_destroyed_p() returns a non-zero value if we're
4920 still in the function but the stack frame has already been
4921 invalidated. Since we can't rely on the values of local
4922 variables after the stack has been destroyed, we are treating
4923 the watchpoint in that state as `not changed' without further
4924 checking. Don't mark watchpoints as changed if the current
4925 frame is in an epilogue - even if they are in some other
4926 frame, our view of the stack is likely to be wrong and
4927 frame_find_by_id could error out. */
4928 if (gdbarch_stack_frame_destroyed_p (frame_arch
, frame_pc
))
4931 fr
= frame_find_by_id (b
->watchpoint_frame
);
4932 within_current_scope
= (fr
!= NULL
);
4934 /* If we've gotten confused in the unwinder, we might have
4935 returned a frame that can't describe this variable. */
4936 if (within_current_scope
)
4938 struct symbol
*function
;
4940 function
= get_frame_function (fr
);
4941 if (function
== NULL
4942 || !contained_in (b
->exp_valid_block
,
4943 SYMBOL_BLOCK_VALUE (function
)))
4944 within_current_scope
= 0;
4947 if (within_current_scope
)
4948 /* If we end up stopping, the current frame will get selected
4949 in normal_stop. So this call to select_frame won't affect
4954 if (within_current_scope
)
4956 /* We use value_{,free_to_}mark because it could be a *long*
4957 time before we return to the command level and call
4958 free_all_values. We can't call free_all_values because we
4959 might be in the middle of evaluating a function call. */
4963 struct value
*new_val
;
4965 if (is_masked_watchpoint (b
))
4966 /* Since we don't know the exact trigger address (from
4967 stopped_data_address), just tell the user we've triggered
4968 a mask watchpoint. */
4969 return WP_VALUE_CHANGED
;
4971 mark
= value_mark ();
4972 fetch_subexp_value (b
->exp
.get (), &pc
, &new_val
, NULL
, NULL
, 0);
4974 if (b
->val_bitsize
!= 0)
4975 new_val
= extract_bitfield_from_watchpoint_value (b
, new_val
);
4977 /* We use value_equal_contents instead of value_equal because
4978 the latter coerces an array to a pointer, thus comparing just
4979 the address of the array instead of its contents. This is
4980 not what we want. */
4981 if ((b
->val
!= NULL
) != (new_val
!= NULL
)
4982 || (b
->val
!= NULL
&& !value_equal_contents (b
->val
.get (),
4985 bs
->old_val
= b
->val
;
4986 b
->val
= release_value (new_val
);
4987 b
->val_valid
= true;
4988 if (new_val
!= NULL
)
4989 value_free_to_mark (mark
);
4990 return WP_VALUE_CHANGED
;
4994 /* Nothing changed. */
4995 value_free_to_mark (mark
);
4996 return WP_VALUE_NOT_CHANGED
;
5001 /* This seems like the only logical thing to do because
5002 if we temporarily ignored the watchpoint, then when
5003 we reenter the block in which it is valid it contains
5004 garbage (in the case of a function, it may have two
5005 garbage values, one before and one after the prologue).
5006 So we can't even detect the first assignment to it and
5007 watch after that (since the garbage may or may not equal
5008 the first value assigned). */
5009 /* We print all the stop information in
5010 breakpoint_ops->print_it, but in this case, by the time we
5011 call breakpoint_ops->print_it this bp will be deleted
5012 already. So we have no choice but print the information
5015 SWITCH_THRU_ALL_UIS ()
5017 struct ui_out
*uiout
= current_uiout
;
5019 if (uiout
->is_mi_like_p ())
5021 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
5022 uiout
->message ("\nWatchpoint %pF deleted because the program has "
5023 "left the block in\n"
5024 "which its expression is valid.\n",
5025 signed_field ("wpnum", b
->number
));
5028 /* Make sure the watchpoint's commands aren't executed. */
5030 watchpoint_del_at_next_stop (b
);
5036 /* Return true if it looks like target has stopped due to hitting
5037 breakpoint location BL. This function does not check if we should
5038 stop, only if BL explains the stop. */
5041 bpstat_check_location (const struct bp_location
*bl
,
5042 const address_space
*aspace
, CORE_ADDR bp_addr
,
5043 const struct target_waitstatus
*ws
)
5045 struct breakpoint
*b
= bl
->owner
;
5047 /* BL is from an existing breakpoint. */
5048 gdb_assert (b
!= NULL
);
5050 return b
->ops
->breakpoint_hit (bl
, aspace
, bp_addr
, ws
);
5053 /* Determine if the watched values have actually changed, and we
5054 should stop. If not, set BS->stop to 0. */
5057 bpstat_check_watchpoint (bpstat bs
)
5059 const struct bp_location
*bl
;
5060 struct watchpoint
*b
;
5062 /* BS is built for existing struct breakpoint. */
5063 bl
= bs
->bp_location_at
;
5064 gdb_assert (bl
!= NULL
);
5065 b
= (struct watchpoint
*) bs
->breakpoint_at
;
5066 gdb_assert (b
!= NULL
);
5069 int must_check_value
= 0;
5071 if (b
->type
== bp_watchpoint
)
5072 /* For a software watchpoint, we must always check the
5074 must_check_value
= 1;
5075 else if (b
->watchpoint_triggered
== watch_triggered_yes
)
5076 /* We have a hardware watchpoint (read, write, or access)
5077 and the target earlier reported an address watched by
5079 must_check_value
= 1;
5080 else if (b
->watchpoint_triggered
== watch_triggered_unknown
5081 && b
->type
== bp_hardware_watchpoint
)
5082 /* We were stopped by a hardware watchpoint, but the target could
5083 not report the data address. We must check the watchpoint's
5084 value. Access and read watchpoints are out of luck; without
5085 a data address, we can't figure it out. */
5086 must_check_value
= 1;
5088 if (must_check_value
)
5094 e
= watchpoint_check (bs
);
5096 catch (const gdb_exception
&ex
)
5098 exception_fprintf (gdb_stderr
, ex
,
5099 "Error evaluating expression "
5100 "for watchpoint %d\n",
5103 SWITCH_THRU_ALL_UIS ()
5105 printf_filtered (_("Watchpoint %d deleted.\n"),
5108 watchpoint_del_at_next_stop (b
);
5115 /* We've already printed what needs to be printed. */
5116 bs
->print_it
= print_it_done
;
5120 bs
->print_it
= print_it_noop
;
5123 case WP_VALUE_CHANGED
:
5124 if (b
->type
== bp_read_watchpoint
)
5126 /* There are two cases to consider here:
5128 1. We're watching the triggered memory for reads.
5129 In that case, trust the target, and always report
5130 the watchpoint hit to the user. Even though
5131 reads don't cause value changes, the value may
5132 have changed since the last time it was read, and
5133 since we're not trapping writes, we will not see
5134 those, and as such we should ignore our notion of
5137 2. We're watching the triggered memory for both
5138 reads and writes. There are two ways this may
5141 2.1. This is a target that can't break on data
5142 reads only, but can break on accesses (reads or
5143 writes), such as e.g., x86. We detect this case
5144 at the time we try to insert read watchpoints.
5146 2.2. Otherwise, the target supports read
5147 watchpoints, but, the user set an access or write
5148 watchpoint watching the same memory as this read
5151 If we're watching memory writes as well as reads,
5152 ignore watchpoint hits when we find that the
5153 value hasn't changed, as reads don't cause
5154 changes. This still gives false positives when
5155 the program writes the same value to memory as
5156 what there was already in memory (we will confuse
5157 it for a read), but it's much better than
5160 int other_write_watchpoint
= 0;
5162 if (bl
->watchpoint_type
== hw_read
)
5164 struct breakpoint
*other_b
;
5166 ALL_BREAKPOINTS (other_b
)
5167 if (other_b
->type
== bp_hardware_watchpoint
5168 || other_b
->type
== bp_access_watchpoint
)
5170 struct watchpoint
*other_w
=
5171 (struct watchpoint
*) other_b
;
5173 if (other_w
->watchpoint_triggered
5174 == watch_triggered_yes
)
5176 other_write_watchpoint
= 1;
5182 if (other_write_watchpoint
5183 || bl
->watchpoint_type
== hw_access
)
5185 /* We're watching the same memory for writes,
5186 and the value changed since the last time we
5187 updated it, so this trap must be for a write.
5189 bs
->print_it
= print_it_noop
;
5194 case WP_VALUE_NOT_CHANGED
:
5195 if (b
->type
== bp_hardware_watchpoint
5196 || b
->type
== bp_watchpoint
)
5198 /* Don't stop: write watchpoints shouldn't fire if
5199 the value hasn't changed. */
5200 bs
->print_it
= print_it_noop
;
5210 else /* must_check_value == 0 */
5212 /* This is a case where some watchpoint(s) triggered, but
5213 not at the address of this watchpoint, or else no
5214 watchpoint triggered after all. So don't print
5215 anything for this watchpoint. */
5216 bs
->print_it
= print_it_noop
;
5222 /* For breakpoints that are currently marked as telling gdb to stop,
5223 check conditions (condition proper, frame, thread and ignore count)
5224 of breakpoint referred to by BS. If we should not stop for this
5225 breakpoint, set BS->stop to 0. */
5228 bpstat_check_breakpoint_conditions (bpstat bs
, thread_info
*thread
)
5230 const struct bp_location
*bl
;
5231 struct breakpoint
*b
;
5233 bool condition_result
= true;
5234 struct expression
*cond
;
5236 gdb_assert (bs
->stop
);
5238 /* BS is built for existing struct breakpoint. */
5239 bl
= bs
->bp_location_at
;
5240 gdb_assert (bl
!= NULL
);
5241 b
= bs
->breakpoint_at
;
5242 gdb_assert (b
!= NULL
);
5244 /* Even if the target evaluated the condition on its end and notified GDB, we
5245 need to do so again since GDB does not know if we stopped due to a
5246 breakpoint or a single step breakpoint. */
5248 if (frame_id_p (b
->frame_id
)
5249 && !frame_id_eq (b
->frame_id
, get_stack_frame_id (get_current_frame ())))
5255 /* If this is a thread/task-specific breakpoint, don't waste cpu
5256 evaluating the condition if this isn't the specified
5258 if ((b
->thread
!= -1 && b
->thread
!= thread
->global_num
)
5259 || (b
->task
!= 0 && b
->task
!= ada_get_task_number (thread
)))
5265 /* Evaluate extension language breakpoints that have a "stop" method
5267 bs
->stop
= breakpoint_ext_lang_cond_says_stop (b
);
5269 if (is_watchpoint (b
))
5271 struct watchpoint
*w
= (struct watchpoint
*) b
;
5273 cond
= w
->cond_exp
.get ();
5276 cond
= bl
->cond
.get ();
5278 if (cond
&& b
->disposition
!= disp_del_at_next_stop
)
5280 int within_current_scope
= 1;
5281 struct watchpoint
* w
;
5283 /* We use value_mark and value_free_to_mark because it could
5284 be a long time before we return to the command level and
5285 call free_all_values. We can't call free_all_values
5286 because we might be in the middle of evaluating a
5288 struct value
*mark
= value_mark ();
5290 if (is_watchpoint (b
))
5291 w
= (struct watchpoint
*) b
;
5295 /* Need to select the frame, with all that implies so that
5296 the conditions will have the right context. Because we
5297 use the frame, we will not see an inlined function's
5298 variables when we arrive at a breakpoint at the start
5299 of the inlined function; the current frame will be the
5301 if (w
== NULL
|| w
->cond_exp_valid_block
== NULL
)
5302 select_frame (get_current_frame ());
5305 struct frame_info
*frame
;
5307 /* For local watchpoint expressions, which particular
5308 instance of a local is being watched matters, so we
5309 keep track of the frame to evaluate the expression
5310 in. To evaluate the condition however, it doesn't
5311 really matter which instantiation of the function
5312 where the condition makes sense triggers the
5313 watchpoint. This allows an expression like "watch
5314 global if q > 10" set in `func', catch writes to
5315 global on all threads that call `func', or catch
5316 writes on all recursive calls of `func' by a single
5317 thread. We simply always evaluate the condition in
5318 the innermost frame that's executing where it makes
5319 sense to evaluate the condition. It seems
5321 frame
= block_innermost_frame (w
->cond_exp_valid_block
);
5323 select_frame (frame
);
5325 within_current_scope
= 0;
5327 if (within_current_scope
)
5331 condition_result
= breakpoint_cond_eval (cond
);
5333 catch (const gdb_exception
&ex
)
5335 exception_fprintf (gdb_stderr
, ex
,
5336 "Error in testing breakpoint condition:\n");
5341 warning (_("Watchpoint condition cannot be tested "
5342 "in the current scope"));
5343 /* If we failed to set the right context for this
5344 watchpoint, unconditionally report it. */
5346 /* FIXME-someday, should give breakpoint #. */
5347 value_free_to_mark (mark
);
5350 if (cond
&& !condition_result
)
5354 else if (b
->ignore_count
> 0)
5358 /* Increase the hit count even though we don't stop. */
5360 gdb::observers::breakpoint_modified
.notify (b
);
5364 /* Returns true if we need to track moribund locations of LOC's type
5365 on the current target. */
5368 need_moribund_for_location_type (struct bp_location
*loc
)
5370 return ((loc
->loc_type
== bp_loc_software_breakpoint
5371 && !target_supports_stopped_by_sw_breakpoint ())
5372 || (loc
->loc_type
== bp_loc_hardware_breakpoint
5373 && !target_supports_stopped_by_hw_breakpoint ()));
5376 /* See breakpoint.h. */
5379 build_bpstat_chain (const address_space
*aspace
, CORE_ADDR bp_addr
,
5380 const struct target_waitstatus
*ws
)
5382 struct breakpoint
*b
;
5383 bpstat bs_head
= NULL
, *bs_link
= &bs_head
;
5387 if (!breakpoint_enabled (b
))
5390 for (bp_location
*bl
= b
->loc
; bl
!= NULL
; bl
= bl
->next
)
5392 /* For hardware watchpoints, we look only at the first
5393 location. The watchpoint_check function will work on the
5394 entire expression, not the individual locations. For
5395 read watchpoints, the watchpoints_triggered function has
5396 checked all locations already. */
5397 if (b
->type
== bp_hardware_watchpoint
&& bl
!= b
->loc
)
5400 if (!bl
->enabled
|| bl
->disabled_by_cond
|| bl
->shlib_disabled
)
5403 if (!bpstat_check_location (bl
, aspace
, bp_addr
, ws
))
5406 /* Come here if it's a watchpoint, or if the break address
5409 bpstat bs
= new bpstats (bl
, &bs_link
); /* Alloc a bpstat to
5412 /* Assume we stop. Should we find a watchpoint that is not
5413 actually triggered, or if the condition of the breakpoint
5414 evaluates as false, we'll reset 'stop' to 0. */
5418 /* If this is a scope breakpoint, mark the associated
5419 watchpoint as triggered so that we will handle the
5420 out-of-scope event. We'll get to the watchpoint next
5422 if (b
->type
== bp_watchpoint_scope
&& b
->related_breakpoint
!= b
)
5424 struct watchpoint
*w
= (struct watchpoint
*) b
->related_breakpoint
;
5426 w
->watchpoint_triggered
= watch_triggered_yes
;
5431 /* Check if a moribund breakpoint explains the stop. */
5432 if (!target_supports_stopped_by_sw_breakpoint ()
5433 || !target_supports_stopped_by_hw_breakpoint ())
5435 for (bp_location
*loc
: moribund_locations
)
5437 if (breakpoint_location_address_match (loc
, aspace
, bp_addr
)
5438 && need_moribund_for_location_type (loc
))
5440 bpstat bs
= new bpstats (loc
, &bs_link
);
5441 /* For hits of moribund locations, we should just proceed. */
5444 bs
->print_it
= print_it_noop
;
5452 /* See breakpoint.h. */
5455 bpstat_stop_status (const address_space
*aspace
,
5456 CORE_ADDR bp_addr
, thread_info
*thread
,
5457 const struct target_waitstatus
*ws
,
5460 struct breakpoint
*b
= NULL
;
5461 /* First item of allocated bpstat's. */
5462 bpstat bs_head
= stop_chain
;
5464 int need_remove_insert
;
5467 /* First, build the bpstat chain with locations that explain a
5468 target stop, while being careful to not set the target running,
5469 as that may invalidate locations (in particular watchpoint
5470 locations are recreated). Resuming will happen here with
5471 breakpoint conditions or watchpoint expressions that include
5472 inferior function calls. */
5473 if (bs_head
== NULL
)
5474 bs_head
= build_bpstat_chain (aspace
, bp_addr
, ws
);
5476 /* A bit of special processing for shlib breakpoints. We need to
5477 process solib loading here, so that the lists of loaded and
5478 unloaded libraries are correct before we handle "catch load" and
5480 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5482 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->type
== bp_shlib_event
)
5484 handle_solib_event ();
5489 /* Now go through the locations that caused the target to stop, and
5490 check whether we're interested in reporting this stop to higher
5491 layers, or whether we should resume the target transparently. */
5495 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5500 b
= bs
->breakpoint_at
;
5501 b
->ops
->check_status (bs
);
5504 bpstat_check_breakpoint_conditions (bs
, thread
);
5509 gdb::observers::breakpoint_modified
.notify (b
);
5511 /* We will stop here. */
5512 if (b
->disposition
== disp_disable
)
5514 --(b
->enable_count
);
5515 if (b
->enable_count
<= 0)
5516 b
->enable_state
= bp_disabled
;
5521 bs
->commands
= b
->commands
;
5522 if (command_line_is_silent (bs
->commands
5523 ? bs
->commands
.get () : NULL
))
5526 b
->ops
->after_condition_true (bs
);
5531 /* Print nothing for this entry if we don't stop or don't
5533 if (!bs
->stop
|| !bs
->print
)
5534 bs
->print_it
= print_it_noop
;
5537 /* If we aren't stopping, the value of some hardware watchpoint may
5538 not have changed, but the intermediate memory locations we are
5539 watching may have. Don't bother if we're stopping; this will get
5541 need_remove_insert
= 0;
5542 if (! bpstat_causes_stop (bs_head
))
5543 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5545 && bs
->breakpoint_at
5546 && is_hardware_watchpoint (bs
->breakpoint_at
))
5548 struct watchpoint
*w
= (struct watchpoint
*) bs
->breakpoint_at
;
5550 update_watchpoint (w
, 0 /* don't reparse. */);
5551 need_remove_insert
= 1;
5554 if (need_remove_insert
)
5555 update_global_location_list (UGLL_MAY_INSERT
);
5556 else if (removed_any
)
5557 update_global_location_list (UGLL_DONT_INSERT
);
5563 handle_jit_event (CORE_ADDR address
)
5565 struct gdbarch
*gdbarch
;
5567 infrun_debug_printf ("handling bp_jit_event");
5569 /* Switch terminal for any messages produced by
5570 breakpoint_re_set. */
5571 target_terminal::ours_for_output ();
5573 gdbarch
= get_frame_arch (get_current_frame ());
5574 /* This event is caused by a breakpoint set in `jit_breakpoint_re_set`,
5575 thus it is expected that its objectfile can be found through
5576 minimal symbol lookup. If it doesn't work (and assert fails), it
5577 most likely means that `jit_breakpoint_re_set` was changes and this
5578 function needs to be updated too. */
5579 bound_minimal_symbol jit_bp_sym
= lookup_minimal_symbol_by_pc (address
);
5580 gdb_assert (jit_bp_sym
.objfile
!= nullptr);
5581 jit_event_handler (gdbarch
, jit_bp_sym
.objfile
);
5583 target_terminal::inferior ();
5586 /* Prepare WHAT final decision for infrun. */
5588 /* Decide what infrun needs to do with this bpstat. */
5591 bpstat_what (bpstat bs_head
)
5593 struct bpstat_what retval
;
5596 retval
.main_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5597 retval
.call_dummy
= STOP_NONE
;
5598 retval
.is_longjmp
= false;
5600 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5602 /* Extract this BS's action. After processing each BS, we check
5603 if its action overrides all we've seem so far. */
5604 enum bpstat_what_main_action this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5607 if (bs
->breakpoint_at
== NULL
)
5609 /* I suspect this can happen if it was a momentary
5610 breakpoint which has since been deleted. */
5614 bptype
= bs
->breakpoint_at
->type
;
5621 case bp_hardware_breakpoint
:
5622 case bp_single_step
:
5625 case bp_shlib_event
:
5629 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5631 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5634 this_action
= BPSTAT_WHAT_SINGLE
;
5637 case bp_hardware_watchpoint
:
5638 case bp_read_watchpoint
:
5639 case bp_access_watchpoint
:
5643 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5645 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5649 /* There was a watchpoint, but we're not stopping.
5650 This requires no further action. */
5654 case bp_longjmp_call_dummy
:
5658 this_action
= BPSTAT_WHAT_SET_LONGJMP_RESUME
;
5659 retval
.is_longjmp
= bptype
!= bp_exception
;
5662 this_action
= BPSTAT_WHAT_SINGLE
;
5664 case bp_longjmp_resume
:
5665 case bp_exception_resume
:
5668 this_action
= BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
;
5669 retval
.is_longjmp
= bptype
== bp_longjmp_resume
;
5672 this_action
= BPSTAT_WHAT_SINGLE
;
5674 case bp_step_resume
:
5676 this_action
= BPSTAT_WHAT_STEP_RESUME
;
5679 /* It is for the wrong frame. */
5680 this_action
= BPSTAT_WHAT_SINGLE
;
5683 case bp_hp_step_resume
:
5685 this_action
= BPSTAT_WHAT_HP_STEP_RESUME
;
5688 /* It is for the wrong frame. */
5689 this_action
= BPSTAT_WHAT_SINGLE
;
5692 case bp_watchpoint_scope
:
5693 case bp_thread_event
:
5694 case bp_overlay_event
:
5695 case bp_longjmp_master
:
5696 case bp_std_terminate_master
:
5697 case bp_exception_master
:
5698 this_action
= BPSTAT_WHAT_SINGLE
;
5704 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5706 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5710 /* Some catchpoints are implemented with breakpoints.
5711 For those, we need to step over the breakpoint. */
5712 if (bs
->bp_location_at
->loc_type
!= bp_loc_other
)
5713 this_action
= BPSTAT_WHAT_SINGLE
;
5717 this_action
= BPSTAT_WHAT_SINGLE
;
5720 /* Make sure the action is stop (silent or noisy),
5721 so infrun.c pops the dummy frame. */
5722 retval
.call_dummy
= STOP_STACK_DUMMY
;
5723 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5725 case bp_std_terminate
:
5726 /* Make sure the action is stop (silent or noisy),
5727 so infrun.c pops the dummy frame. */
5728 retval
.call_dummy
= STOP_STD_TERMINATE
;
5729 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5732 case bp_fast_tracepoint
:
5733 case bp_static_tracepoint
:
5734 /* Tracepoint hits should not be reported back to GDB, and
5735 if one got through somehow, it should have been filtered
5737 internal_error (__FILE__
, __LINE__
,
5738 _("bpstat_what: tracepoint encountered"));
5740 case bp_gnu_ifunc_resolver
:
5741 /* Step over it (and insert bp_gnu_ifunc_resolver_return). */
5742 this_action
= BPSTAT_WHAT_SINGLE
;
5744 case bp_gnu_ifunc_resolver_return
:
5745 /* The breakpoint will be removed, execution will restart from the
5746 PC of the former breakpoint. */
5747 this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5752 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5754 this_action
= BPSTAT_WHAT_SINGLE
;
5758 internal_error (__FILE__
, __LINE__
,
5759 _("bpstat_what: unhandled bptype %d"), (int) bptype
);
5762 retval
.main_action
= std::max (retval
.main_action
, this_action
);
5769 bpstat_run_callbacks (bpstat bs_head
)
5773 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5775 struct breakpoint
*b
= bs
->breakpoint_at
;
5782 handle_jit_event (bs
->bp_location_at
->address
);
5784 case bp_gnu_ifunc_resolver
:
5785 gnu_ifunc_resolver_stop (b
);
5787 case bp_gnu_ifunc_resolver_return
:
5788 gnu_ifunc_resolver_return_stop (b
);
5794 /* See breakpoint.h. */
5797 bpstat_should_step ()
5799 struct breakpoint
*b
;
5802 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
&& b
->loc
!= NULL
)
5807 /* See breakpoint.h. */
5810 bpstat_causes_stop (bpstat bs
)
5812 for (; bs
!= NULL
; bs
= bs
->next
)
5821 /* Compute a string of spaces suitable to indent the next line
5822 so it starts at the position corresponding to the table column
5823 named COL_NAME in the currently active table of UIOUT. */
5826 wrap_indent_at_field (struct ui_out
*uiout
, const char *col_name
)
5828 static char wrap_indent
[80];
5829 int i
, total_width
, width
, align
;
5833 for (i
= 1; uiout
->query_table_field (i
, &width
, &align
, &text
); i
++)
5835 if (strcmp (text
, col_name
) == 0)
5837 gdb_assert (total_width
< sizeof wrap_indent
);
5838 memset (wrap_indent
, ' ', total_width
);
5839 wrap_indent
[total_width
] = 0;
5844 total_width
+= width
+ 1;
5850 /* Determine if the locations of this breakpoint will have their conditions
5851 evaluated by the target, host or a mix of both. Returns the following:
5853 "host": Host evals condition.
5854 "host or target": Host or Target evals condition.
5855 "target": Target evals condition.
5859 bp_condition_evaluator (struct breakpoint
*b
)
5861 struct bp_location
*bl
;
5862 char host_evals
= 0;
5863 char target_evals
= 0;
5868 if (!is_breakpoint (b
))
5871 if (gdb_evaluates_breakpoint_condition_p ()
5872 || !target_supports_evaluation_of_breakpoint_conditions ())
5873 return condition_evaluation_host
;
5875 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
5877 if (bl
->cond_bytecode
)
5883 if (host_evals
&& target_evals
)
5884 return condition_evaluation_both
;
5885 else if (target_evals
)
5886 return condition_evaluation_target
;
5888 return condition_evaluation_host
;
5891 /* Determine the breakpoint location's condition evaluator. This is
5892 similar to bp_condition_evaluator, but for locations. */
5895 bp_location_condition_evaluator (struct bp_location
*bl
)
5897 if (bl
&& !is_breakpoint (bl
->owner
))
5900 if (gdb_evaluates_breakpoint_condition_p ()
5901 || !target_supports_evaluation_of_breakpoint_conditions ())
5902 return condition_evaluation_host
;
5904 if (bl
&& bl
->cond_bytecode
)
5905 return condition_evaluation_target
;
5907 return condition_evaluation_host
;
5910 /* Print the LOC location out of the list of B->LOC locations. */
5913 print_breakpoint_location (struct breakpoint
*b
,
5914 struct bp_location
*loc
)
5916 struct ui_out
*uiout
= current_uiout
;
5918 scoped_restore_current_program_space restore_pspace
;
5920 if (loc
!= NULL
&& loc
->shlib_disabled
)
5924 set_current_program_space (loc
->pspace
);
5926 if (b
->display_canonical
)
5927 uiout
->field_string ("what", event_location_to_string (b
->location
.get ()));
5928 else if (loc
&& loc
->symtab
)
5930 const struct symbol
*sym
= loc
->symbol
;
5934 uiout
->text ("in ");
5935 uiout
->field_string ("func", sym
->print_name (),
5936 function_name_style
.style ());
5938 uiout
->wrap_hint (wrap_indent_at_field (uiout
, "what"));
5939 uiout
->text ("at ");
5941 uiout
->field_string ("file",
5942 symtab_to_filename_for_display (loc
->symtab
),
5943 file_name_style
.style ());
5946 if (uiout
->is_mi_like_p ())
5947 uiout
->field_string ("fullname", symtab_to_fullname (loc
->symtab
));
5949 uiout
->field_signed ("line", loc
->line_number
);
5955 print_address_symbolic (loc
->gdbarch
, loc
->address
, &stb
,
5957 uiout
->field_stream ("at", stb
);
5961 uiout
->field_string ("pending",
5962 event_location_to_string (b
->location
.get ()));
5963 /* If extra_string is available, it could be holding a condition
5964 or dprintf arguments. In either case, make sure it is printed,
5965 too, but only for non-MI streams. */
5966 if (!uiout
->is_mi_like_p () && b
->extra_string
!= NULL
)
5968 if (b
->type
== bp_dprintf
)
5972 uiout
->text (b
->extra_string
);
5976 if (loc
&& is_breakpoint (b
)
5977 && breakpoint_condition_evaluation_mode () == condition_evaluation_target
5978 && bp_condition_evaluator (b
) == condition_evaluation_both
)
5981 uiout
->field_string ("evaluated-by",
5982 bp_location_condition_evaluator (loc
));
5988 bptype_string (enum bptype type
)
5990 struct ep_type_description
5993 const char *description
;
5995 static struct ep_type_description bptypes
[] =
5997 {bp_none
, "?deleted?"},
5998 {bp_breakpoint
, "breakpoint"},
5999 {bp_hardware_breakpoint
, "hw breakpoint"},
6000 {bp_single_step
, "sw single-step"},
6001 {bp_until
, "until"},
6002 {bp_finish
, "finish"},
6003 {bp_watchpoint
, "watchpoint"},
6004 {bp_hardware_watchpoint
, "hw watchpoint"},
6005 {bp_read_watchpoint
, "read watchpoint"},
6006 {bp_access_watchpoint
, "acc watchpoint"},
6007 {bp_longjmp
, "longjmp"},
6008 {bp_longjmp_resume
, "longjmp resume"},
6009 {bp_longjmp_call_dummy
, "longjmp for call dummy"},
6010 {bp_exception
, "exception"},
6011 {bp_exception_resume
, "exception resume"},
6012 {bp_step_resume
, "step resume"},
6013 {bp_hp_step_resume
, "high-priority step resume"},
6014 {bp_watchpoint_scope
, "watchpoint scope"},
6015 {bp_call_dummy
, "call dummy"},
6016 {bp_std_terminate
, "std::terminate"},
6017 {bp_shlib_event
, "shlib events"},
6018 {bp_thread_event
, "thread events"},
6019 {bp_overlay_event
, "overlay events"},
6020 {bp_longjmp_master
, "longjmp master"},
6021 {bp_std_terminate_master
, "std::terminate master"},
6022 {bp_exception_master
, "exception master"},
6023 {bp_catchpoint
, "catchpoint"},
6024 {bp_tracepoint
, "tracepoint"},
6025 {bp_fast_tracepoint
, "fast tracepoint"},
6026 {bp_static_tracepoint
, "static tracepoint"},
6027 {bp_dprintf
, "dprintf"},
6028 {bp_jit_event
, "jit events"},
6029 {bp_gnu_ifunc_resolver
, "STT_GNU_IFUNC resolver"},
6030 {bp_gnu_ifunc_resolver_return
, "STT_GNU_IFUNC resolver return"},
6033 if (((int) type
>= (sizeof (bptypes
) / sizeof (bptypes
[0])))
6034 || ((int) type
!= bptypes
[(int) type
].type
))
6035 internal_error (__FILE__
, __LINE__
,
6036 _("bptypes table does not describe type #%d."),
6039 return bptypes
[(int) type
].description
;
6042 /* For MI, output a field named 'thread-groups' with a list as the value.
6043 For CLI, prefix the list with the string 'inf'. */
6046 output_thread_groups (struct ui_out
*uiout
,
6047 const char *field_name
,
6048 const std::vector
<int> &inf_nums
,
6051 int is_mi
= uiout
->is_mi_like_p ();
6053 /* For backward compatibility, don't display inferiors in CLI unless
6054 there are several. Always display them for MI. */
6055 if (!is_mi
&& mi_only
)
6058 ui_out_emit_list
list_emitter (uiout
, field_name
);
6060 for (size_t i
= 0; i
< inf_nums
.size (); i
++)
6066 xsnprintf (mi_group
, sizeof (mi_group
), "i%d", inf_nums
[i
]);
6067 uiout
->field_string (NULL
, mi_group
);
6072 uiout
->text (" inf ");
6076 uiout
->text (plongest (inf_nums
[i
]));
6081 /* Print B to gdb_stdout. If RAW_LOC, print raw breakpoint locations
6082 instead of going via breakpoint_ops::print_one. This makes "maint
6083 info breakpoints" show the software breakpoint locations of
6084 catchpoints, which are considered internal implementation
6088 print_one_breakpoint_location (struct breakpoint
*b
,
6089 struct bp_location
*loc
,
6091 struct bp_location
**last_loc
,
6092 int allflag
, bool raw_loc
)
6094 struct command_line
*l
;
6095 static char bpenables
[] = "nynny";
6097 struct ui_out
*uiout
= current_uiout
;
6098 int header_of_multiple
= 0;
6099 int part_of_multiple
= (loc
!= NULL
);
6100 struct value_print_options opts
;
6102 get_user_print_options (&opts
);
6104 gdb_assert (!loc
|| loc_number
!= 0);
6105 /* See comment in print_one_breakpoint concerning treatment of
6106 breakpoints with single disabled location. */
6109 && (b
->loc
->next
!= NULL
6110 || !b
->loc
->enabled
|| b
->loc
->disabled_by_cond
)))
6111 header_of_multiple
= 1;
6119 if (part_of_multiple
)
6120 uiout
->field_fmt ("number", "%d.%d", b
->number
, loc_number
);
6122 uiout
->field_signed ("number", b
->number
);
6126 if (part_of_multiple
)
6127 uiout
->field_skip ("type");
6129 uiout
->field_string ("type", bptype_string (b
->type
));
6133 if (part_of_multiple
)
6134 uiout
->field_skip ("disp");
6136 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
6140 if (part_of_multiple
)
6141 uiout
->field_string ("enabled", (loc
->disabled_by_cond
? "N*"
6142 : (loc
->enabled
? "y" : "n")));
6144 uiout
->field_fmt ("enabled", "%c", bpenables
[(int) b
->enable_state
]);
6147 if (!raw_loc
&& b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
6148 b
->ops
->print_one (b
, last_loc
);
6151 if (is_watchpoint (b
))
6153 struct watchpoint
*w
= (struct watchpoint
*) b
;
6155 /* Field 4, the address, is omitted (which makes the columns
6156 not line up too nicely with the headers, but the effect
6157 is relatively readable). */
6158 if (opts
.addressprint
)
6159 uiout
->field_skip ("addr");
6161 uiout
->field_string ("what", w
->exp_string
);
6163 else if (!is_catchpoint (b
) || is_exception_catchpoint (b
)
6164 || is_ada_exception_catchpoint (b
))
6166 if (opts
.addressprint
)
6169 if (header_of_multiple
)
6170 uiout
->field_string ("addr", "<MULTIPLE>",
6171 metadata_style
.style ());
6172 else if (b
->loc
== NULL
|| loc
->shlib_disabled
)
6173 uiout
->field_string ("addr", "<PENDING>",
6174 metadata_style
.style ());
6176 uiout
->field_core_addr ("addr",
6177 loc
->gdbarch
, loc
->address
);
6180 if (!header_of_multiple
)
6181 print_breakpoint_location (b
, loc
);
6187 if (loc
!= NULL
&& !header_of_multiple
)
6189 std::vector
<int> inf_nums
;
6192 for (inferior
*inf
: all_inferiors ())
6194 if (inf
->pspace
== loc
->pspace
)
6195 inf_nums
.push_back (inf
->num
);
6198 /* For backward compatibility, don't display inferiors in CLI unless
6199 there are several. Always display for MI. */
6201 || (!gdbarch_has_global_breakpoints (target_gdbarch ())
6202 && (program_spaces
.size () > 1
6203 || number_of_inferiors () > 1)
6204 /* LOC is for existing B, it cannot be in
6205 moribund_locations and thus having NULL OWNER. */
6206 && loc
->owner
->type
!= bp_catchpoint
))
6208 output_thread_groups (uiout
, "thread-groups", inf_nums
, mi_only
);
6211 if (!part_of_multiple
)
6213 if (b
->thread
!= -1)
6215 /* FIXME: This seems to be redundant and lost here; see the
6216 "stop only in" line a little further down. */
6217 uiout
->text (" thread ");
6218 uiout
->field_signed ("thread", b
->thread
);
6220 else if (b
->task
!= 0)
6222 uiout
->text (" task ");
6223 uiout
->field_signed ("task", b
->task
);
6229 if (!part_of_multiple
)
6230 b
->ops
->print_one_detail (b
, uiout
);
6232 if (part_of_multiple
&& frame_id_p (b
->frame_id
))
6235 uiout
->text ("\tstop only in stack frame at ");
6236 /* FIXME: cagney/2002-12-01: Shouldn't be poking around inside
6238 uiout
->field_core_addr ("frame",
6239 b
->gdbarch
, b
->frame_id
.stack_addr
);
6243 if (!part_of_multiple
&& b
->cond_string
)
6246 if (is_tracepoint (b
))
6247 uiout
->text ("\ttrace only if ");
6249 uiout
->text ("\tstop only if ");
6250 uiout
->field_string ("cond", b
->cond_string
);
6252 /* Print whether the target is doing the breakpoint's condition
6253 evaluation. If GDB is doing the evaluation, don't print anything. */
6254 if (is_breakpoint (b
)
6255 && breakpoint_condition_evaluation_mode ()
6256 == condition_evaluation_target
)
6258 uiout
->message (" (%pF evals)",
6259 string_field ("evaluated-by",
6260 bp_condition_evaluator (b
)));
6265 if (!part_of_multiple
&& b
->thread
!= -1)
6267 /* FIXME should make an annotation for this. */
6268 uiout
->text ("\tstop only in thread ");
6269 if (uiout
->is_mi_like_p ())
6270 uiout
->field_signed ("thread", b
->thread
);
6273 struct thread_info
*thr
= find_thread_global_id (b
->thread
);
6275 uiout
->field_string ("thread", print_thread_id (thr
));
6280 if (!part_of_multiple
)
6284 /* FIXME should make an annotation for this. */
6285 if (is_catchpoint (b
))
6286 uiout
->text ("\tcatchpoint");
6287 else if (is_tracepoint (b
))
6288 uiout
->text ("\ttracepoint");
6290 uiout
->text ("\tbreakpoint");
6291 uiout
->text (" already hit ");
6292 uiout
->field_signed ("times", b
->hit_count
);
6293 if (b
->hit_count
== 1)
6294 uiout
->text (" time\n");
6296 uiout
->text (" times\n");
6300 /* Output the count also if it is zero, but only if this is mi. */
6301 if (uiout
->is_mi_like_p ())
6302 uiout
->field_signed ("times", b
->hit_count
);
6306 if (!part_of_multiple
&& b
->ignore_count
)
6309 uiout
->message ("\tignore next %pF hits\n",
6310 signed_field ("ignore", b
->ignore_count
));
6313 /* Note that an enable count of 1 corresponds to "enable once"
6314 behavior, which is reported by the combination of enablement and
6315 disposition, so we don't need to mention it here. */
6316 if (!part_of_multiple
&& b
->enable_count
> 1)
6319 uiout
->text ("\tdisable after ");
6320 /* Tweak the wording to clarify that ignore and enable counts
6321 are distinct, and have additive effect. */
6322 if (b
->ignore_count
)
6323 uiout
->text ("additional ");
6325 uiout
->text ("next ");
6326 uiout
->field_signed ("enable", b
->enable_count
);
6327 uiout
->text (" hits\n");
6330 if (!part_of_multiple
&& is_tracepoint (b
))
6332 struct tracepoint
*tp
= (struct tracepoint
*) b
;
6334 if (tp
->traceframe_usage
)
6336 uiout
->text ("\ttrace buffer usage ");
6337 uiout
->field_signed ("traceframe-usage", tp
->traceframe_usage
);
6338 uiout
->text (" bytes\n");
6342 l
= b
->commands
? b
->commands
.get () : NULL
;
6343 if (!part_of_multiple
&& l
)
6346 ui_out_emit_tuple
tuple_emitter (uiout
, "script");
6347 print_command_lines (uiout
, l
, 4);
6350 if (is_tracepoint (b
))
6352 struct tracepoint
*t
= (struct tracepoint
*) b
;
6354 if (!part_of_multiple
&& t
->pass_count
)
6356 annotate_field (10);
6357 uiout
->text ("\tpass count ");
6358 uiout
->field_signed ("pass", t
->pass_count
);
6359 uiout
->text (" \n");
6362 /* Don't display it when tracepoint or tracepoint location is
6364 if (!header_of_multiple
&& loc
!= NULL
&& !loc
->shlib_disabled
)
6366 annotate_field (11);
6368 if (uiout
->is_mi_like_p ())
6369 uiout
->field_string ("installed",
6370 loc
->inserted
? "y" : "n");
6376 uiout
->text ("\tnot ");
6377 uiout
->text ("installed on target\n");
6382 if (uiout
->is_mi_like_p () && !part_of_multiple
)
6384 if (is_watchpoint (b
))
6386 struct watchpoint
*w
= (struct watchpoint
*) b
;
6388 uiout
->field_string ("original-location", w
->exp_string
);
6390 else if (b
->location
!= NULL
6391 && event_location_to_string (b
->location
.get ()) != NULL
)
6392 uiout
->field_string ("original-location",
6393 event_location_to_string (b
->location
.get ()));
6397 /* See breakpoint.h. */
6399 bool fix_multi_location_breakpoint_output_globally
= false;
6402 print_one_breakpoint (struct breakpoint
*b
,
6403 struct bp_location
**last_loc
,
6406 struct ui_out
*uiout
= current_uiout
;
6407 bool use_fixed_output
6408 = (uiout
->test_flags (fix_multi_location_breakpoint_output
)
6409 || fix_multi_location_breakpoint_output_globally
);
6411 gdb::optional
<ui_out_emit_tuple
> bkpt_tuple_emitter (gdb::in_place
, uiout
, "bkpt");
6412 print_one_breakpoint_location (b
, NULL
, 0, last_loc
, allflag
, false);
6414 /* The mi2 broken format: the main breakpoint tuple ends here, the locations
6416 if (!use_fixed_output
)
6417 bkpt_tuple_emitter
.reset ();
6419 /* If this breakpoint has custom print function,
6420 it's already printed. Otherwise, print individual
6421 locations, if any. */
6423 || b
->ops
->print_one
== NULL
6426 /* If breakpoint has a single location that is disabled, we
6427 print it as if it had several locations, since otherwise it's
6428 hard to represent "breakpoint enabled, location disabled"
6431 Note that while hardware watchpoints have several locations
6432 internally, that's not a property exposed to users.
6434 Likewise, while catchpoints may be implemented with
6435 breakpoints (e.g., catch throw), that's not a property
6436 exposed to users. We do however display the internal
6437 breakpoint locations with "maint info breakpoints". */
6438 if (!is_hardware_watchpoint (b
)
6439 && (!is_catchpoint (b
) || is_exception_catchpoint (b
)
6440 || is_ada_exception_catchpoint (b
))
6442 || (b
->loc
&& (b
->loc
->next
6444 || b
->loc
->disabled_by_cond
))))
6446 gdb::optional
<ui_out_emit_list
> locations_list
;
6448 /* For MI version <= 2, keep the behavior where GDB outputs an invalid
6449 MI record. For later versions, place breakpoint locations in a
6451 if (uiout
->is_mi_like_p () && use_fixed_output
)
6452 locations_list
.emplace (uiout
, "locations");
6455 for (bp_location
*loc
= b
->loc
; loc
!= NULL
; loc
= loc
->next
, ++n
)
6457 ui_out_emit_tuple
loc_tuple_emitter (uiout
, NULL
);
6458 print_one_breakpoint_location (b
, loc
, n
, last_loc
,
6466 breakpoint_address_bits (struct breakpoint
*b
)
6468 int print_address_bits
= 0;
6469 struct bp_location
*loc
;
6471 /* Software watchpoints that aren't watching memory don't have an
6472 address to print. */
6473 if (is_no_memory_software_watchpoint (b
))
6476 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
6480 addr_bit
= gdbarch_addr_bit (loc
->gdbarch
);
6481 if (addr_bit
> print_address_bits
)
6482 print_address_bits
= addr_bit
;
6485 return print_address_bits
;
6488 /* See breakpoint.h. */
6491 print_breakpoint (breakpoint
*b
)
6493 struct bp_location
*dummy_loc
= NULL
;
6494 print_one_breakpoint (b
, &dummy_loc
, 0);
6497 /* Return true if this breakpoint was set by the user, false if it is
6498 internal or momentary. */
6501 user_breakpoint_p (struct breakpoint
*b
)
6503 return b
->number
> 0;
6506 /* See breakpoint.h. */
6509 pending_breakpoint_p (struct breakpoint
*b
)
6511 return b
->loc
== NULL
;
6514 /* Print information on breakpoints (including watchpoints and tracepoints).
6516 If non-NULL, BP_NUM_LIST is a list of numbers and number ranges as
6517 understood by number_or_range_parser. Only breakpoints included in this
6518 list are then printed.
6520 If SHOW_INTERNAL is true, print internal breakpoints.
6522 If FILTER is non-NULL, call it on each breakpoint and only include the
6523 ones for which it returns true.
6525 Return the total number of breakpoints listed. */
6528 breakpoint_1 (const char *bp_num_list
, bool show_internal
,
6529 bool (*filter
) (const struct breakpoint
*))
6531 struct breakpoint
*b
;
6532 struct bp_location
*last_loc
= NULL
;
6533 int nr_printable_breakpoints
;
6534 struct value_print_options opts
;
6535 int print_address_bits
= 0;
6536 int print_type_col_width
= 14;
6537 struct ui_out
*uiout
= current_uiout
;
6538 bool has_disabled_by_cond_location
= false;
6540 get_user_print_options (&opts
);
6542 /* Compute the number of rows in the table, as well as the size
6543 required for address fields. */
6544 nr_printable_breakpoints
= 0;
6547 /* If we have a filter, only list the breakpoints it accepts. */
6548 if (filter
&& !filter (b
))
6551 /* If we have a BP_NUM_LIST string, it is a list of breakpoints to
6552 accept. Skip the others. */
6553 if (bp_num_list
!= NULL
&& *bp_num_list
!= '\0')
6555 if (show_internal
&& parse_and_eval_long (bp_num_list
) != b
->number
)
6557 if (!show_internal
&& !number_is_in_list (bp_num_list
, b
->number
))
6561 if (show_internal
|| user_breakpoint_p (b
))
6563 int addr_bit
, type_len
;
6565 addr_bit
= breakpoint_address_bits (b
);
6566 if (addr_bit
> print_address_bits
)
6567 print_address_bits
= addr_bit
;
6569 type_len
= strlen (bptype_string (b
->type
));
6570 if (type_len
> print_type_col_width
)
6571 print_type_col_width
= type_len
;
6573 nr_printable_breakpoints
++;
6578 ui_out_emit_table
table_emitter (uiout
,
6579 opts
.addressprint
? 6 : 5,
6580 nr_printable_breakpoints
,
6583 if (nr_printable_breakpoints
> 0)
6584 annotate_breakpoints_headers ();
6585 if (nr_printable_breakpoints
> 0)
6587 uiout
->table_header (7, ui_left
, "number", "Num"); /* 1 */
6588 if (nr_printable_breakpoints
> 0)
6590 uiout
->table_header (print_type_col_width
, ui_left
, "type", "Type"); /* 2 */
6591 if (nr_printable_breakpoints
> 0)
6593 uiout
->table_header (4, ui_left
, "disp", "Disp"); /* 3 */
6594 if (nr_printable_breakpoints
> 0)
6596 uiout
->table_header (3, ui_left
, "enabled", "Enb"); /* 4 */
6597 if (opts
.addressprint
)
6599 if (nr_printable_breakpoints
> 0)
6601 if (print_address_bits
<= 32)
6602 uiout
->table_header (10, ui_left
, "addr", "Address"); /* 5 */
6604 uiout
->table_header (18, ui_left
, "addr", "Address"); /* 5 */
6606 if (nr_printable_breakpoints
> 0)
6608 uiout
->table_header (40, ui_noalign
, "what", "What"); /* 6 */
6609 uiout
->table_body ();
6610 if (nr_printable_breakpoints
> 0)
6611 annotate_breakpoints_table ();
6616 /* If we have a filter, only list the breakpoints it accepts. */
6617 if (filter
&& !filter (b
))
6620 /* If we have a BP_NUM_LIST string, it is a list of breakpoints to
6621 accept. Skip the others. */
6623 if (bp_num_list
!= NULL
&& *bp_num_list
!= '\0')
6625 if (show_internal
) /* maintenance info breakpoint */
6627 if (parse_and_eval_long (bp_num_list
) != b
->number
)
6630 else /* all others */
6632 if (!number_is_in_list (bp_num_list
, b
->number
))
6636 /* We only print out user settable breakpoints unless the
6637 show_internal is set. */
6638 if (show_internal
|| user_breakpoint_p (b
))
6640 print_one_breakpoint (b
, &last_loc
, show_internal
);
6641 for (bp_location
*loc
= b
->loc
; loc
!= NULL
; loc
= loc
->next
)
6642 if (loc
->disabled_by_cond
)
6643 has_disabled_by_cond_location
= true;
6648 if (nr_printable_breakpoints
== 0)
6650 /* If there's a filter, let the caller decide how to report
6654 if (bp_num_list
== NULL
|| *bp_num_list
== '\0')
6655 uiout
->message ("No breakpoints or watchpoints.\n");
6657 uiout
->message ("No breakpoint or watchpoint matching '%s'.\n",
6663 if (last_loc
&& !server_command
)
6664 set_next_address (last_loc
->gdbarch
, last_loc
->address
);
6666 if (has_disabled_by_cond_location
)
6667 uiout
->message (_("(*): Breakpoint condition is invalid at this "
6671 /* FIXME? Should this be moved up so that it is only called when
6672 there have been breakpoints? */
6673 annotate_breakpoints_table_end ();
6675 return nr_printable_breakpoints
;
6678 /* Display the value of default-collect in a way that is generally
6679 compatible with the breakpoint list. */
6682 default_collect_info (void)
6684 struct ui_out
*uiout
= current_uiout
;
6686 /* If it has no value (which is frequently the case), say nothing; a
6687 message like "No default-collect." gets in user's face when it's
6689 if (!*default_collect
)
6692 /* The following phrase lines up nicely with per-tracepoint collect
6694 uiout
->text ("default collect ");
6695 uiout
->field_string ("default-collect", default_collect
);
6696 uiout
->text (" \n");
6700 info_breakpoints_command (const char *args
, int from_tty
)
6702 breakpoint_1 (args
, false, NULL
);
6704 default_collect_info ();
6708 info_watchpoints_command (const char *args
, int from_tty
)
6710 int num_printed
= breakpoint_1 (args
, false, is_watchpoint
);
6711 struct ui_out
*uiout
= current_uiout
;
6713 if (num_printed
== 0)
6715 if (args
== NULL
|| *args
== '\0')
6716 uiout
->message ("No watchpoints.\n");
6718 uiout
->message ("No watchpoint matching '%s'.\n", args
);
6723 maintenance_info_breakpoints (const char *args
, int from_tty
)
6725 breakpoint_1 (args
, true, NULL
);
6727 default_collect_info ();
6731 breakpoint_has_pc (struct breakpoint
*b
,
6732 struct program_space
*pspace
,
6733 CORE_ADDR pc
, struct obj_section
*section
)
6735 struct bp_location
*bl
= b
->loc
;
6737 for (; bl
; bl
= bl
->next
)
6739 if (bl
->pspace
== pspace
6740 && bl
->address
== pc
6741 && (!overlay_debugging
|| bl
->section
== section
))
6747 /* Print a message describing any user-breakpoints set at PC. This
6748 concerns with logical breakpoints, so we match program spaces, not
6752 describe_other_breakpoints (struct gdbarch
*gdbarch
,
6753 struct program_space
*pspace
, CORE_ADDR pc
,
6754 struct obj_section
*section
, int thread
)
6757 struct breakpoint
*b
;
6760 others
+= (user_breakpoint_p (b
)
6761 && breakpoint_has_pc (b
, pspace
, pc
, section
));
6765 printf_filtered (_("Note: breakpoint "));
6766 else /* if (others == ???) */
6767 printf_filtered (_("Note: breakpoints "));
6769 if (user_breakpoint_p (b
) && breakpoint_has_pc (b
, pspace
, pc
, section
))
6772 printf_filtered ("%d", b
->number
);
6773 if (b
->thread
== -1 && thread
!= -1)
6774 printf_filtered (" (all threads)");
6775 else if (b
->thread
!= -1)
6776 printf_filtered (" (thread %d)", b
->thread
);
6777 printf_filtered ("%s%s ",
6778 ((b
->enable_state
== bp_disabled
6779 || b
->enable_state
== bp_call_disabled
)
6783 : ((others
== 1) ? " and" : ""));
6785 current_uiout
->message (_("also set at pc %ps.\n"),
6786 styled_string (address_style
.style (),
6787 paddress (gdbarch
, pc
)));
6792 /* Return true iff it is meaningful to use the address member of LOC.
6793 For some breakpoint types, the locations' address members are
6794 irrelevant and it makes no sense to attempt to compare them to
6795 other addresses (or use them for any other purpose either).
6797 More specifically, software watchpoints and catchpoints that are
6798 not backed by breakpoints always have a zero valued location
6799 address and we don't want to mark breakpoints of any of these types
6800 to be a duplicate of an actual breakpoint location at address
6804 bl_address_is_meaningful (bp_location
*loc
)
6806 return loc
->loc_type
!= bp_loc_other
;
6809 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
6810 true if LOC1 and LOC2 represent the same watchpoint location. */
6813 watchpoint_locations_match (struct bp_location
*loc1
,
6814 struct bp_location
*loc2
)
6816 struct watchpoint
*w1
= (struct watchpoint
*) loc1
->owner
;
6817 struct watchpoint
*w2
= (struct watchpoint
*) loc2
->owner
;
6819 /* Both of them must exist. */
6820 gdb_assert (w1
!= NULL
);
6821 gdb_assert (w2
!= NULL
);
6823 /* If the target can evaluate the condition expression in hardware,
6824 then we we need to insert both watchpoints even if they are at
6825 the same place. Otherwise the watchpoint will only trigger when
6826 the condition of whichever watchpoint was inserted evaluates to
6827 true, not giving a chance for GDB to check the condition of the
6828 other watchpoint. */
6830 && target_can_accel_watchpoint_condition (loc1
->address
,
6832 loc1
->watchpoint_type
,
6833 w1
->cond_exp
.get ()))
6835 && target_can_accel_watchpoint_condition (loc2
->address
,
6837 loc2
->watchpoint_type
,
6838 w2
->cond_exp
.get ())))
6841 /* Note that this checks the owner's type, not the location's. In
6842 case the target does not support read watchpoints, but does
6843 support access watchpoints, we'll have bp_read_watchpoint
6844 watchpoints with hw_access locations. Those should be considered
6845 duplicates of hw_read locations. The hw_read locations will
6846 become hw_access locations later. */
6847 return (loc1
->owner
->type
== loc2
->owner
->type
6848 && loc1
->pspace
->aspace
== loc2
->pspace
->aspace
6849 && loc1
->address
== loc2
->address
6850 && loc1
->length
== loc2
->length
);
6853 /* See breakpoint.h. */
6856 breakpoint_address_match (const address_space
*aspace1
, CORE_ADDR addr1
,
6857 const address_space
*aspace2
, CORE_ADDR addr2
)
6859 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
6860 || aspace1
== aspace2
)
6864 /* Returns true if {ASPACE2,ADDR2} falls within the range determined by
6865 {ASPACE1,ADDR1,LEN1}. In most targets, this can only be true if ASPACE1
6866 matches ASPACE2. On targets that have global breakpoints, the address
6867 space doesn't really matter. */
6870 breakpoint_address_match_range (const address_space
*aspace1
,
6872 int len1
, const address_space
*aspace2
,
6875 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
6876 || aspace1
== aspace2
)
6877 && addr2
>= addr1
&& addr2
< addr1
+ len1
);
6880 /* Returns true if {ASPACE,ADDR} matches the breakpoint BL. BL may be
6881 a ranged breakpoint. In most targets, a match happens only if ASPACE
6882 matches the breakpoint's address space. On targets that have global
6883 breakpoints, the address space doesn't really matter. */
6886 breakpoint_location_address_match (struct bp_location
*bl
,
6887 const address_space
*aspace
,
6890 return (breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
6893 && breakpoint_address_match_range (bl
->pspace
->aspace
,
6894 bl
->address
, bl
->length
,
6898 /* Returns true if the [ADDR,ADDR+LEN) range in ASPACE overlaps
6899 breakpoint BL. BL may be a ranged breakpoint. In most targets, a
6900 match happens only if ASPACE matches the breakpoint's address
6901 space. On targets that have global breakpoints, the address space
6902 doesn't really matter. */
6905 breakpoint_location_address_range_overlap (struct bp_location
*bl
,
6906 const address_space
*aspace
,
6907 CORE_ADDR addr
, int len
)
6909 if (gdbarch_has_global_breakpoints (target_gdbarch ())
6910 || bl
->pspace
->aspace
== aspace
)
6912 int bl_len
= bl
->length
!= 0 ? bl
->length
: 1;
6914 if (mem_ranges_overlap (addr
, len
, bl
->address
, bl_len
))
6920 /* If LOC1 and LOC2's owners are not tracepoints, returns false directly.
6921 Then, if LOC1 and LOC2 represent the same tracepoint location, returns
6922 true, otherwise returns false. */
6925 tracepoint_locations_match (struct bp_location
*loc1
,
6926 struct bp_location
*loc2
)
6928 if (is_tracepoint (loc1
->owner
) && is_tracepoint (loc2
->owner
))
6929 /* Since tracepoint locations are never duplicated with others', tracepoint
6930 locations at the same address of different tracepoints are regarded as
6931 different locations. */
6932 return (loc1
->address
== loc2
->address
&& loc1
->owner
== loc2
->owner
);
6937 /* Assuming LOC1 and LOC2's types' have meaningful target addresses
6938 (bl_address_is_meaningful), returns true if LOC1 and LOC2 represent
6939 the same location. If SW_HW_BPS_MATCH is true, then software
6940 breakpoint locations and hardware breakpoint locations match,
6941 otherwise they don't. */
6944 breakpoint_locations_match (struct bp_location
*loc1
,
6945 struct bp_location
*loc2
,
6946 bool sw_hw_bps_match
)
6948 int hw_point1
, hw_point2
;
6950 /* Both of them must not be in moribund_locations. */
6951 gdb_assert (loc1
->owner
!= NULL
);
6952 gdb_assert (loc2
->owner
!= NULL
);
6954 hw_point1
= is_hardware_watchpoint (loc1
->owner
);
6955 hw_point2
= is_hardware_watchpoint (loc2
->owner
);
6957 if (hw_point1
!= hw_point2
)
6960 return watchpoint_locations_match (loc1
, loc2
);
6961 else if (is_tracepoint (loc1
->owner
) || is_tracepoint (loc2
->owner
))
6962 return tracepoint_locations_match (loc1
, loc2
);
6964 /* We compare bp_location.length in order to cover ranged
6965 breakpoints. Keep this in sync with
6966 bp_location_is_less_than. */
6967 return (breakpoint_address_match (loc1
->pspace
->aspace
, loc1
->address
,
6968 loc2
->pspace
->aspace
, loc2
->address
)
6969 && (loc1
->loc_type
== loc2
->loc_type
|| sw_hw_bps_match
)
6970 && loc1
->length
== loc2
->length
);
6974 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
6975 int bnum
, int have_bnum
)
6977 /* The longest string possibly returned by hex_string_custom
6978 is 50 chars. These must be at least that big for safety. */
6982 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
6983 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
6985 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
6986 bnum
, astr1
, astr2
);
6988 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
6991 /* Adjust a breakpoint's address to account for architectural
6992 constraints on breakpoint placement. Return the adjusted address.
6993 Note: Very few targets require this kind of adjustment. For most
6994 targets, this function is simply the identity function. */
6997 adjust_breakpoint_address (struct gdbarch
*gdbarch
,
6998 CORE_ADDR bpaddr
, enum bptype bptype
)
7000 if (bptype
== bp_watchpoint
7001 || bptype
== bp_hardware_watchpoint
7002 || bptype
== bp_read_watchpoint
7003 || bptype
== bp_access_watchpoint
7004 || bptype
== bp_catchpoint
)
7006 /* Watchpoints and the various bp_catch_* eventpoints should not
7007 have their addresses modified. */
7010 else if (bptype
== bp_single_step
)
7012 /* Single-step breakpoints should not have their addresses
7013 modified. If there's any architectural constrain that
7014 applies to this address, then it should have already been
7015 taken into account when the breakpoint was created in the
7016 first place. If we didn't do this, stepping through e.g.,
7017 Thumb-2 IT blocks would break. */
7022 CORE_ADDR adjusted_bpaddr
= bpaddr
;
7024 if (gdbarch_adjust_breakpoint_address_p (gdbarch
))
7026 /* Some targets have architectural constraints on the placement
7027 of breakpoint instructions. Obtain the adjusted address. */
7028 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (gdbarch
, bpaddr
);
7031 adjusted_bpaddr
= address_significant (gdbarch
, adjusted_bpaddr
);
7033 /* An adjusted breakpoint address can significantly alter
7034 a user's expectations. Print a warning if an adjustment
7036 if (adjusted_bpaddr
!= bpaddr
)
7037 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
7039 return adjusted_bpaddr
;
7044 bp_location_from_bp_type (bptype type
)
7049 case bp_single_step
:
7053 case bp_longjmp_resume
:
7054 case bp_longjmp_call_dummy
:
7056 case bp_exception_resume
:
7057 case bp_step_resume
:
7058 case bp_hp_step_resume
:
7059 case bp_watchpoint_scope
:
7061 case bp_std_terminate
:
7062 case bp_shlib_event
:
7063 case bp_thread_event
:
7064 case bp_overlay_event
:
7066 case bp_longjmp_master
:
7067 case bp_std_terminate_master
:
7068 case bp_exception_master
:
7069 case bp_gnu_ifunc_resolver
:
7070 case bp_gnu_ifunc_resolver_return
:
7072 return bp_loc_software_breakpoint
;
7073 case bp_hardware_breakpoint
:
7074 return bp_loc_hardware_breakpoint
;
7075 case bp_hardware_watchpoint
:
7076 case bp_read_watchpoint
:
7077 case bp_access_watchpoint
:
7078 return bp_loc_hardware_watchpoint
;
7082 case bp_fast_tracepoint
:
7083 case bp_static_tracepoint
:
7084 return bp_loc_other
;
7086 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
7090 bp_location::bp_location (breakpoint
*owner
, bp_loc_type type
)
7092 this->owner
= owner
;
7093 this->cond_bytecode
= NULL
;
7094 this->shlib_disabled
= 0;
7096 this->disabled_by_cond
= false;
7098 this->loc_type
= type
;
7100 if (this->loc_type
== bp_loc_software_breakpoint
7101 || this->loc_type
== bp_loc_hardware_breakpoint
)
7102 mark_breakpoint_location_modified (this);
7107 bp_location::bp_location (breakpoint
*owner
)
7108 : bp_location::bp_location (owner
,
7109 bp_location_from_bp_type (owner
->type
))
7113 /* Allocate a struct bp_location. */
7115 static struct bp_location
*
7116 allocate_bp_location (struct breakpoint
*bpt
)
7118 return bpt
->ops
->allocate_location (bpt
);
7122 free_bp_location (struct bp_location
*loc
)
7127 /* Increment reference count. */
7130 incref_bp_location (struct bp_location
*bl
)
7135 /* Decrement reference count. If the reference count reaches 0,
7136 destroy the bp_location. Sets *BLP to NULL. */
7139 decref_bp_location (struct bp_location
**blp
)
7141 gdb_assert ((*blp
)->refc
> 0);
7143 if (--(*blp
)->refc
== 0)
7144 free_bp_location (*blp
);
7148 /* Add breakpoint B at the end of the global breakpoint chain. */
7151 add_to_breakpoint_chain (std::unique_ptr
<breakpoint
> &&b
)
7153 struct breakpoint
*b1
;
7154 struct breakpoint
*result
= b
.get ();
7156 /* Add this breakpoint to the end of the chain so that a list of
7157 breakpoints will come out in order of increasing numbers. */
7159 b1
= breakpoint_chain
;
7161 breakpoint_chain
= b
.release ();
7166 b1
->next
= b
.release ();
7172 /* Initializes breakpoint B with type BPTYPE and no locations yet. */
7175 init_raw_breakpoint_without_location (struct breakpoint
*b
,
7176 struct gdbarch
*gdbarch
,
7178 const struct breakpoint_ops
*ops
)
7180 gdb_assert (ops
!= NULL
);
7184 b
->gdbarch
= gdbarch
;
7185 b
->language
= current_language
->la_language
;
7186 b
->input_radix
= input_radix
;
7187 b
->related_breakpoint
= b
;
7190 /* Helper to set_raw_breakpoint below. Creates a breakpoint
7191 that has type BPTYPE and has no locations as yet. */
7193 static struct breakpoint
*
7194 set_raw_breakpoint_without_location (struct gdbarch
*gdbarch
,
7196 const struct breakpoint_ops
*ops
)
7198 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (bptype
);
7200 init_raw_breakpoint_without_location (b
.get (), gdbarch
, bptype
, ops
);
7201 return add_to_breakpoint_chain (std::move (b
));
7204 /* Initialize loc->function_name. */
7207 set_breakpoint_location_function (struct bp_location
*loc
)
7209 gdb_assert (loc
->owner
!= NULL
);
7211 if (loc
->owner
->type
== bp_breakpoint
7212 || loc
->owner
->type
== bp_hardware_breakpoint
7213 || is_tracepoint (loc
->owner
))
7215 const char *function_name
;
7217 if (loc
->msymbol
!= NULL
7218 && (MSYMBOL_TYPE (loc
->msymbol
) == mst_text_gnu_ifunc
7219 || MSYMBOL_TYPE (loc
->msymbol
) == mst_data_gnu_ifunc
))
7221 struct breakpoint
*b
= loc
->owner
;
7223 function_name
= loc
->msymbol
->linkage_name ();
7225 if (b
->type
== bp_breakpoint
&& b
->loc
== loc
7226 && loc
->next
== NULL
&& b
->related_breakpoint
== b
)
7228 /* Create only the whole new breakpoint of this type but do not
7229 mess more complicated breakpoints with multiple locations. */
7230 b
->type
= bp_gnu_ifunc_resolver
;
7231 /* Remember the resolver's address for use by the return
7233 loc
->related_address
= loc
->address
;
7237 find_pc_partial_function (loc
->address
, &function_name
, NULL
, NULL
);
7240 loc
->function_name
= xstrdup (function_name
);
7244 /* Attempt to determine architecture of location identified by SAL. */
7246 get_sal_arch (struct symtab_and_line sal
)
7249 return sal
.section
->objfile
->arch ();
7251 return SYMTAB_OBJFILE (sal
.symtab
)->arch ();
7256 /* Low level routine for partially initializing a breakpoint of type
7257 BPTYPE. The newly created breakpoint's address, section, source
7258 file name, and line number are provided by SAL.
7260 It is expected that the caller will complete the initialization of
7261 the newly created breakpoint struct as well as output any status
7262 information regarding the creation of a new breakpoint. */
7265 init_raw_breakpoint (struct breakpoint
*b
, struct gdbarch
*gdbarch
,
7266 struct symtab_and_line sal
, enum bptype bptype
,
7267 const struct breakpoint_ops
*ops
)
7269 init_raw_breakpoint_without_location (b
, gdbarch
, bptype
, ops
);
7271 add_location_to_breakpoint (b
, &sal
);
7273 if (bptype
!= bp_catchpoint
)
7274 gdb_assert (sal
.pspace
!= NULL
);
7276 /* Store the program space that was used to set the breakpoint,
7277 except for ordinary breakpoints, which are independent of the
7279 if (bptype
!= bp_breakpoint
&& bptype
!= bp_hardware_breakpoint
)
7280 b
->pspace
= sal
.pspace
;
7283 /* set_raw_breakpoint is a low level routine for allocating and
7284 partially initializing a breakpoint of type BPTYPE. The newly
7285 created breakpoint's address, section, source file name, and line
7286 number are provided by SAL. The newly created and partially
7287 initialized breakpoint is added to the breakpoint chain and
7288 is also returned as the value of this function.
7290 It is expected that the caller will complete the initialization of
7291 the newly created breakpoint struct as well as output any status
7292 information regarding the creation of a new breakpoint. In
7293 particular, set_raw_breakpoint does NOT set the breakpoint
7294 number! Care should be taken to not allow an error to occur
7295 prior to completing the initialization of the breakpoint. If this
7296 should happen, a bogus breakpoint will be left on the chain. */
7299 set_raw_breakpoint (struct gdbarch
*gdbarch
,
7300 struct symtab_and_line sal
, enum bptype bptype
,
7301 const struct breakpoint_ops
*ops
)
7303 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (bptype
);
7305 init_raw_breakpoint (b
.get (), gdbarch
, sal
, bptype
, ops
);
7306 return add_to_breakpoint_chain (std::move (b
));
7309 /* Call this routine when stepping and nexting to enable a breakpoint
7310 if we do a longjmp() or 'throw' in TP. FRAME is the frame which
7311 initiated the operation. */
7314 set_longjmp_breakpoint (struct thread_info
*tp
, struct frame_id frame
)
7316 struct breakpoint
*b
, *b_tmp
;
7317 int thread
= tp
->global_num
;
7319 /* To avoid having to rescan all objfile symbols at every step,
7320 we maintain a list of continually-inserted but always disabled
7321 longjmp "master" breakpoints. Here, we simply create momentary
7322 clones of those and enable them for the requested thread. */
7323 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7324 if (b
->pspace
== current_program_space
7325 && (b
->type
== bp_longjmp_master
7326 || b
->type
== bp_exception_master
))
7328 enum bptype type
= b
->type
== bp_longjmp_master
? bp_longjmp
: bp_exception
;
7329 struct breakpoint
*clone
;
7331 /* longjmp_breakpoint_ops ensures INITIATING_FRAME is cleared again
7332 after their removal. */
7333 clone
= momentary_breakpoint_from_master (b
, type
,
7334 &momentary_breakpoint_ops
, 1);
7335 clone
->thread
= thread
;
7338 tp
->initiating_frame
= frame
;
7341 /* Delete all longjmp breakpoints from THREAD. */
7343 delete_longjmp_breakpoint (int thread
)
7345 struct breakpoint
*b
, *b_tmp
;
7347 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7348 if (b
->type
== bp_longjmp
|| b
->type
== bp_exception
)
7350 if (b
->thread
== thread
)
7351 delete_breakpoint (b
);
7356 delete_longjmp_breakpoint_at_next_stop (int thread
)
7358 struct breakpoint
*b
, *b_tmp
;
7360 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7361 if (b
->type
== bp_longjmp
|| b
->type
== bp_exception
)
7363 if (b
->thread
== thread
)
7364 b
->disposition
= disp_del_at_next_stop
;
7368 /* Place breakpoints of type bp_longjmp_call_dummy to catch longjmp for
7369 INFERIOR_PTID thread. Chain them all by RELATED_BREAKPOINT and return
7370 pointer to any of them. Return NULL if this system cannot place longjmp
7374 set_longjmp_breakpoint_for_call_dummy (void)
7376 struct breakpoint
*b
, *retval
= NULL
;
7379 if (b
->pspace
== current_program_space
&& b
->type
== bp_longjmp_master
)
7381 struct breakpoint
*new_b
;
7383 new_b
= momentary_breakpoint_from_master (b
, bp_longjmp_call_dummy
,
7384 &momentary_breakpoint_ops
,
7386 new_b
->thread
= inferior_thread ()->global_num
;
7388 /* Link NEW_B into the chain of RETVAL breakpoints. */
7390 gdb_assert (new_b
->related_breakpoint
== new_b
);
7393 new_b
->related_breakpoint
= retval
;
7394 while (retval
->related_breakpoint
!= new_b
->related_breakpoint
)
7395 retval
= retval
->related_breakpoint
;
7396 retval
->related_breakpoint
= new_b
;
7402 /* Verify all existing dummy frames and their associated breakpoints for
7403 TP. Remove those which can no longer be found in the current frame
7406 You should call this function only at places where it is safe to currently
7407 unwind the whole stack. Failed stack unwind would discard live dummy
7411 check_longjmp_breakpoint_for_call_dummy (struct thread_info
*tp
)
7413 struct breakpoint
*b
, *b_tmp
;
7415 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7416 if (b
->type
== bp_longjmp_call_dummy
&& b
->thread
== tp
->global_num
)
7418 struct breakpoint
*dummy_b
= b
->related_breakpoint
;
7420 while (dummy_b
!= b
&& dummy_b
->type
!= bp_call_dummy
)
7421 dummy_b
= dummy_b
->related_breakpoint
;
7422 if (dummy_b
->type
!= bp_call_dummy
7423 || frame_find_by_id (dummy_b
->frame_id
) != NULL
)
7426 dummy_frame_discard (dummy_b
->frame_id
, tp
);
7428 while (b
->related_breakpoint
!= b
)
7430 if (b_tmp
== b
->related_breakpoint
)
7431 b_tmp
= b
->related_breakpoint
->next
;
7432 delete_breakpoint (b
->related_breakpoint
);
7434 delete_breakpoint (b
);
7439 enable_overlay_breakpoints (void)
7441 struct breakpoint
*b
;
7444 if (b
->type
== bp_overlay_event
)
7446 b
->enable_state
= bp_enabled
;
7447 update_global_location_list (UGLL_MAY_INSERT
);
7448 overlay_events_enabled
= 1;
7453 disable_overlay_breakpoints (void)
7455 struct breakpoint
*b
;
7458 if (b
->type
== bp_overlay_event
)
7460 b
->enable_state
= bp_disabled
;
7461 update_global_location_list (UGLL_DONT_INSERT
);
7462 overlay_events_enabled
= 0;
7466 /* Set an active std::terminate breakpoint for each std::terminate
7467 master breakpoint. */
7469 set_std_terminate_breakpoint (void)
7471 struct breakpoint
*b
, *b_tmp
;
7473 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7474 if (b
->pspace
== current_program_space
7475 && b
->type
== bp_std_terminate_master
)
7477 momentary_breakpoint_from_master (b
, bp_std_terminate
,
7478 &momentary_breakpoint_ops
, 1);
7482 /* Delete all the std::terminate breakpoints. */
7484 delete_std_terminate_breakpoint (void)
7486 struct breakpoint
*b
, *b_tmp
;
7488 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7489 if (b
->type
== bp_std_terminate
)
7490 delete_breakpoint (b
);
7494 create_thread_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7496 struct breakpoint
*b
;
7498 b
= create_internal_breakpoint (gdbarch
, address
, bp_thread_event
,
7499 &internal_breakpoint_ops
);
7501 b
->enable_state
= bp_enabled
;
7502 /* location has to be used or breakpoint_re_set will delete me. */
7503 b
->location
= new_address_location (b
->loc
->address
, NULL
, 0);
7505 update_global_location_list_nothrow (UGLL_MAY_INSERT
);
7510 struct lang_and_radix
7516 /* Create a breakpoint for JIT code registration and unregistration. */
7519 create_jit_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7521 return create_internal_breakpoint (gdbarch
, address
, bp_jit_event
,
7522 &internal_breakpoint_ops
);
7525 /* Remove JIT code registration and unregistration breakpoint(s). */
7528 remove_jit_event_breakpoints (void)
7530 struct breakpoint
*b
, *b_tmp
;
7532 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7533 if (b
->type
== bp_jit_event
7534 && b
->loc
->pspace
== current_program_space
)
7535 delete_breakpoint (b
);
7539 remove_solib_event_breakpoints (void)
7541 struct breakpoint
*b
, *b_tmp
;
7543 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7544 if (b
->type
== bp_shlib_event
7545 && b
->loc
->pspace
== current_program_space
)
7546 delete_breakpoint (b
);
7549 /* See breakpoint.h. */
7552 remove_solib_event_breakpoints_at_next_stop (void)
7554 struct breakpoint
*b
, *b_tmp
;
7556 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7557 if (b
->type
== bp_shlib_event
7558 && b
->loc
->pspace
== current_program_space
)
7559 b
->disposition
= disp_del_at_next_stop
;
7562 /* Helper for create_solib_event_breakpoint /
7563 create_and_insert_solib_event_breakpoint. Allows specifying which
7564 INSERT_MODE to pass through to update_global_location_list. */
7566 static struct breakpoint
*
7567 create_solib_event_breakpoint_1 (struct gdbarch
*gdbarch
, CORE_ADDR address
,
7568 enum ugll_insert_mode insert_mode
)
7570 struct breakpoint
*b
;
7572 b
= create_internal_breakpoint (gdbarch
, address
, bp_shlib_event
,
7573 &internal_breakpoint_ops
);
7574 update_global_location_list_nothrow (insert_mode
);
7579 create_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7581 return create_solib_event_breakpoint_1 (gdbarch
, address
, UGLL_MAY_INSERT
);
7584 /* See breakpoint.h. */
7587 create_and_insert_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7589 struct breakpoint
*b
;
7591 /* Explicitly tell update_global_location_list to insert
7593 b
= create_solib_event_breakpoint_1 (gdbarch
, address
, UGLL_INSERT
);
7594 if (!b
->loc
->inserted
)
7596 delete_breakpoint (b
);
7602 /* Disable any breakpoints that are on code in shared libraries. Only
7603 apply to enabled breakpoints, disabled ones can just stay disabled. */
7606 disable_breakpoints_in_shlibs (void)
7608 struct bp_location
*loc
, **locp_tmp
;
7610 ALL_BP_LOCATIONS (loc
, locp_tmp
)
7612 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7613 struct breakpoint
*b
= loc
->owner
;
7615 /* We apply the check to all breakpoints, including disabled for
7616 those with loc->duplicate set. This is so that when breakpoint
7617 becomes enabled, or the duplicate is removed, gdb will try to
7618 insert all breakpoints. If we don't set shlib_disabled here,
7619 we'll try to insert those breakpoints and fail. */
7620 if (((b
->type
== bp_breakpoint
)
7621 || (b
->type
== bp_jit_event
)
7622 || (b
->type
== bp_hardware_breakpoint
)
7623 || (is_tracepoint (b
)))
7624 && loc
->pspace
== current_program_space
7625 && !loc
->shlib_disabled
7626 && solib_name_from_address (loc
->pspace
, loc
->address
)
7629 loc
->shlib_disabled
= 1;
7634 /* Disable any breakpoints and tracepoints that are in SOLIB upon
7635 notification of unloaded_shlib. Only apply to enabled breakpoints,
7636 disabled ones can just stay disabled. */
7639 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
7641 struct bp_location
*loc
, **locp_tmp
;
7642 int disabled_shlib_breaks
= 0;
7644 ALL_BP_LOCATIONS (loc
, locp_tmp
)
7646 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7647 struct breakpoint
*b
= loc
->owner
;
7649 if (solib
->pspace
== loc
->pspace
7650 && !loc
->shlib_disabled
7651 && (((b
->type
== bp_breakpoint
7652 || b
->type
== bp_jit_event
7653 || b
->type
== bp_hardware_breakpoint
)
7654 && (loc
->loc_type
== bp_loc_hardware_breakpoint
7655 || loc
->loc_type
== bp_loc_software_breakpoint
))
7656 || is_tracepoint (b
))
7657 && solib_contains_address_p (solib
, loc
->address
))
7659 loc
->shlib_disabled
= 1;
7660 /* At this point, we cannot rely on remove_breakpoint
7661 succeeding so we must mark the breakpoint as not inserted
7662 to prevent future errors occurring in remove_breakpoints. */
7665 /* This may cause duplicate notifications for the same breakpoint. */
7666 gdb::observers::breakpoint_modified
.notify (b
);
7668 if (!disabled_shlib_breaks
)
7670 target_terminal::ours_for_output ();
7671 warning (_("Temporarily disabling breakpoints "
7672 "for unloaded shared library \"%s\""),
7675 disabled_shlib_breaks
= 1;
7680 /* Disable any breakpoints and tracepoints in OBJFILE upon
7681 notification of free_objfile. Only apply to enabled breakpoints,
7682 disabled ones can just stay disabled. */
7685 disable_breakpoints_in_freed_objfile (struct objfile
*objfile
)
7687 struct breakpoint
*b
;
7689 if (objfile
== NULL
)
7692 /* OBJF_SHARED|OBJF_USERLOADED objfiles are dynamic modules manually
7693 managed by the user with add-symbol-file/remove-symbol-file.
7694 Similarly to how breakpoints in shared libraries are handled in
7695 response to "nosharedlibrary", mark breakpoints in such modules
7696 shlib_disabled so they end up uninserted on the next global
7697 location list update. Shared libraries not loaded by the user
7698 aren't handled here -- they're already handled in
7699 disable_breakpoints_in_unloaded_shlib, called by solib.c's
7700 solib_unloaded observer. We skip objfiles that are not
7701 OBJF_SHARED as those aren't considered dynamic objects (e.g. the
7703 if ((objfile
->flags
& OBJF_SHARED
) == 0
7704 || (objfile
->flags
& OBJF_USERLOADED
) == 0)
7709 struct bp_location
*loc
;
7710 int bp_modified
= 0;
7712 if (!is_breakpoint (b
) && !is_tracepoint (b
))
7715 for (loc
= b
->loc
; loc
!= NULL
; loc
= loc
->next
)
7717 CORE_ADDR loc_addr
= loc
->address
;
7719 if (loc
->loc_type
!= bp_loc_hardware_breakpoint
7720 && loc
->loc_type
!= bp_loc_software_breakpoint
)
7723 if (loc
->shlib_disabled
!= 0)
7726 if (objfile
->pspace
!= loc
->pspace
)
7729 if (loc
->loc_type
!= bp_loc_hardware_breakpoint
7730 && loc
->loc_type
!= bp_loc_software_breakpoint
)
7733 if (is_addr_in_objfile (loc_addr
, objfile
))
7735 loc
->shlib_disabled
= 1;
7736 /* At this point, we don't know whether the object was
7737 unmapped from the inferior or not, so leave the
7738 inserted flag alone. We'll handle failure to
7739 uninsert quietly, in case the object was indeed
7742 mark_breakpoint_location_modified (loc
);
7749 gdb::observers::breakpoint_modified
.notify (b
);
7753 /* FORK & VFORK catchpoints. */
7755 /* An instance of this type is used to represent a fork or vfork
7756 catchpoint. A breakpoint is really of this type iff its ops pointer points
7757 to CATCH_FORK_BREAKPOINT_OPS. */
7759 struct fork_catchpoint
: public breakpoint
7761 /* Process id of a child process whose forking triggered this
7762 catchpoint. This field is only valid immediately after this
7763 catchpoint has triggered. */
7764 ptid_t forked_inferior_pid
;
7767 /* Implement the "insert" breakpoint_ops method for fork
7771 insert_catch_fork (struct bp_location
*bl
)
7773 return target_insert_fork_catchpoint (inferior_ptid
.pid ());
7776 /* Implement the "remove" breakpoint_ops method for fork
7780 remove_catch_fork (struct bp_location
*bl
, enum remove_bp_reason reason
)
7782 return target_remove_fork_catchpoint (inferior_ptid
.pid ());
7785 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
7789 breakpoint_hit_catch_fork (const struct bp_location
*bl
,
7790 const address_space
*aspace
, CORE_ADDR bp_addr
,
7791 const struct target_waitstatus
*ws
)
7793 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bl
->owner
;
7795 if (ws
->kind
!= TARGET_WAITKIND_FORKED
)
7798 c
->forked_inferior_pid
= ws
->value
.related_pid
;
7802 /* Implement the "print_it" breakpoint_ops method for fork
7805 static enum print_stop_action
7806 print_it_catch_fork (bpstat bs
)
7808 struct ui_out
*uiout
= current_uiout
;
7809 struct breakpoint
*b
= bs
->breakpoint_at
;
7810 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bs
->breakpoint_at
;
7812 annotate_catchpoint (b
->number
);
7813 maybe_print_thread_hit_breakpoint (uiout
);
7814 if (b
->disposition
== disp_del
)
7815 uiout
->text ("Temporary catchpoint ");
7817 uiout
->text ("Catchpoint ");
7818 if (uiout
->is_mi_like_p ())
7820 uiout
->field_string ("reason", async_reason_lookup (EXEC_ASYNC_FORK
));
7821 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
7823 uiout
->field_signed ("bkptno", b
->number
);
7824 uiout
->text (" (forked process ");
7825 uiout
->field_signed ("newpid", c
->forked_inferior_pid
.pid ());
7826 uiout
->text ("), ");
7827 return PRINT_SRC_AND_LOC
;
7830 /* Implement the "print_one" breakpoint_ops method for fork
7834 print_one_catch_fork (struct breakpoint
*b
, struct bp_location
**last_loc
)
7836 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
7837 struct value_print_options opts
;
7838 struct ui_out
*uiout
= current_uiout
;
7840 get_user_print_options (&opts
);
7842 /* Field 4, the address, is omitted (which makes the columns not
7843 line up too nicely with the headers, but the effect is relatively
7845 if (opts
.addressprint
)
7846 uiout
->field_skip ("addr");
7848 uiout
->text ("fork");
7849 if (c
->forked_inferior_pid
!= null_ptid
)
7851 uiout
->text (", process ");
7852 uiout
->field_signed ("what", c
->forked_inferior_pid
.pid ());
7856 if (uiout
->is_mi_like_p ())
7857 uiout
->field_string ("catch-type", "fork");
7860 /* Implement the "print_mention" breakpoint_ops method for fork
7864 print_mention_catch_fork (struct breakpoint
*b
)
7866 printf_filtered (_("Catchpoint %d (fork)"), b
->number
);
7869 /* Implement the "print_recreate" breakpoint_ops method for fork
7873 print_recreate_catch_fork (struct breakpoint
*b
, struct ui_file
*fp
)
7875 fprintf_unfiltered (fp
, "catch fork");
7876 print_recreate_thread (b
, fp
);
7879 /* The breakpoint_ops structure to be used in fork catchpoints. */
7881 static struct breakpoint_ops catch_fork_breakpoint_ops
;
7883 /* Implement the "insert" breakpoint_ops method for vfork
7887 insert_catch_vfork (struct bp_location
*bl
)
7889 return target_insert_vfork_catchpoint (inferior_ptid
.pid ());
7892 /* Implement the "remove" breakpoint_ops method for vfork
7896 remove_catch_vfork (struct bp_location
*bl
, enum remove_bp_reason reason
)
7898 return target_remove_vfork_catchpoint (inferior_ptid
.pid ());
7901 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
7905 breakpoint_hit_catch_vfork (const struct bp_location
*bl
,
7906 const address_space
*aspace
, CORE_ADDR bp_addr
,
7907 const struct target_waitstatus
*ws
)
7909 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bl
->owner
;
7911 if (ws
->kind
!= TARGET_WAITKIND_VFORKED
)
7914 c
->forked_inferior_pid
= ws
->value
.related_pid
;
7918 /* Implement the "print_it" breakpoint_ops method for vfork
7921 static enum print_stop_action
7922 print_it_catch_vfork (bpstat bs
)
7924 struct ui_out
*uiout
= current_uiout
;
7925 struct breakpoint
*b
= bs
->breakpoint_at
;
7926 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
7928 annotate_catchpoint (b
->number
);
7929 maybe_print_thread_hit_breakpoint (uiout
);
7930 if (b
->disposition
== disp_del
)
7931 uiout
->text ("Temporary catchpoint ");
7933 uiout
->text ("Catchpoint ");
7934 if (uiout
->is_mi_like_p ())
7936 uiout
->field_string ("reason", async_reason_lookup (EXEC_ASYNC_VFORK
));
7937 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
7939 uiout
->field_signed ("bkptno", b
->number
);
7940 uiout
->text (" (vforked process ");
7941 uiout
->field_signed ("newpid", c
->forked_inferior_pid
.pid ());
7942 uiout
->text ("), ");
7943 return PRINT_SRC_AND_LOC
;
7946 /* Implement the "print_one" breakpoint_ops method for vfork
7950 print_one_catch_vfork (struct breakpoint
*b
, struct bp_location
**last_loc
)
7952 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
7953 struct value_print_options opts
;
7954 struct ui_out
*uiout
= current_uiout
;
7956 get_user_print_options (&opts
);
7957 /* Field 4, the address, is omitted (which makes the columns not
7958 line up too nicely with the headers, but the effect is relatively
7960 if (opts
.addressprint
)
7961 uiout
->field_skip ("addr");
7963 uiout
->text ("vfork");
7964 if (c
->forked_inferior_pid
!= null_ptid
)
7966 uiout
->text (", process ");
7967 uiout
->field_signed ("what", c
->forked_inferior_pid
.pid ());
7971 if (uiout
->is_mi_like_p ())
7972 uiout
->field_string ("catch-type", "vfork");
7975 /* Implement the "print_mention" breakpoint_ops method for vfork
7979 print_mention_catch_vfork (struct breakpoint
*b
)
7981 printf_filtered (_("Catchpoint %d (vfork)"), b
->number
);
7984 /* Implement the "print_recreate" breakpoint_ops method for vfork
7988 print_recreate_catch_vfork (struct breakpoint
*b
, struct ui_file
*fp
)
7990 fprintf_unfiltered (fp
, "catch vfork");
7991 print_recreate_thread (b
, fp
);
7994 /* The breakpoint_ops structure to be used in vfork catchpoints. */
7996 static struct breakpoint_ops catch_vfork_breakpoint_ops
;
7998 /* An instance of this type is used to represent an solib catchpoint.
7999 A breakpoint is really of this type iff its ops pointer points to
8000 CATCH_SOLIB_BREAKPOINT_OPS. */
8002 struct solib_catchpoint
: public breakpoint
8004 ~solib_catchpoint () override
;
8006 /* True for "catch load", false for "catch unload". */
8009 /* Regular expression to match, if any. COMPILED is only valid when
8010 REGEX is non-NULL. */
8012 std::unique_ptr
<compiled_regex
> compiled
;
8015 solib_catchpoint::~solib_catchpoint ()
8017 xfree (this->regex
);
8021 insert_catch_solib (struct bp_location
*ignore
)
8027 remove_catch_solib (struct bp_location
*ignore
, enum remove_bp_reason reason
)
8033 breakpoint_hit_catch_solib (const struct bp_location
*bl
,
8034 const address_space
*aspace
,
8036 const struct target_waitstatus
*ws
)
8038 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) bl
->owner
;
8039 struct breakpoint
*other
;
8041 if (ws
->kind
== TARGET_WAITKIND_LOADED
)
8044 ALL_BREAKPOINTS (other
)
8046 struct bp_location
*other_bl
;
8048 if (other
== bl
->owner
)
8051 if (other
->type
!= bp_shlib_event
)
8054 if (self
->pspace
!= NULL
&& other
->pspace
!= self
->pspace
)
8057 for (other_bl
= other
->loc
; other_bl
!= NULL
; other_bl
= other_bl
->next
)
8059 if (other
->ops
->breakpoint_hit (other_bl
, aspace
, bp_addr
, ws
))
8068 check_status_catch_solib (struct bpstats
*bs
)
8070 struct solib_catchpoint
*self
8071 = (struct solib_catchpoint
*) bs
->breakpoint_at
;
8075 for (so_list
*iter
: current_program_space
->added_solibs
)
8078 || self
->compiled
->exec (iter
->so_name
, 0, NULL
, 0) == 0)
8084 for (const std::string
&iter
: current_program_space
->deleted_solibs
)
8087 || self
->compiled
->exec (iter
.c_str (), 0, NULL
, 0) == 0)
8093 bs
->print_it
= print_it_noop
;
8096 static enum print_stop_action
8097 print_it_catch_solib (bpstat bs
)
8099 struct breakpoint
*b
= bs
->breakpoint_at
;
8100 struct ui_out
*uiout
= current_uiout
;
8102 annotate_catchpoint (b
->number
);
8103 maybe_print_thread_hit_breakpoint (uiout
);
8104 if (b
->disposition
== disp_del
)
8105 uiout
->text ("Temporary catchpoint ");
8107 uiout
->text ("Catchpoint ");
8108 uiout
->field_signed ("bkptno", b
->number
);
8110 if (uiout
->is_mi_like_p ())
8111 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
8112 print_solib_event (1);
8113 return PRINT_SRC_AND_LOC
;
8117 print_one_catch_solib (struct breakpoint
*b
, struct bp_location
**locs
)
8119 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8120 struct value_print_options opts
;
8121 struct ui_out
*uiout
= current_uiout
;
8123 get_user_print_options (&opts
);
8124 /* Field 4, the address, is omitted (which makes the columns not
8125 line up too nicely with the headers, but the effect is relatively
8127 if (opts
.addressprint
)
8130 uiout
->field_skip ("addr");
8138 msg
= string_printf (_("load of library matching %s"), self
->regex
);
8140 msg
= _("load of library");
8145 msg
= string_printf (_("unload of library matching %s"), self
->regex
);
8147 msg
= _("unload of library");
8149 uiout
->field_string ("what", msg
);
8151 if (uiout
->is_mi_like_p ())
8152 uiout
->field_string ("catch-type", self
->is_load
? "load" : "unload");
8156 print_mention_catch_solib (struct breakpoint
*b
)
8158 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8160 printf_filtered (_("Catchpoint %d (%s)"), b
->number
,
8161 self
->is_load
? "load" : "unload");
8165 print_recreate_catch_solib (struct breakpoint
*b
, struct ui_file
*fp
)
8167 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8169 fprintf_unfiltered (fp
, "%s %s",
8170 b
->disposition
== disp_del
? "tcatch" : "catch",
8171 self
->is_load
? "load" : "unload");
8173 fprintf_unfiltered (fp
, " %s", self
->regex
);
8174 fprintf_unfiltered (fp
, "\n");
8177 static struct breakpoint_ops catch_solib_breakpoint_ops
;
8179 /* See breakpoint.h. */
8182 add_solib_catchpoint (const char *arg
, bool is_load
, bool is_temp
, bool enabled
)
8184 struct gdbarch
*gdbarch
= get_current_arch ();
8188 arg
= skip_spaces (arg
);
8190 std::unique_ptr
<solib_catchpoint
> c (new solib_catchpoint ());
8194 c
->compiled
.reset (new compiled_regex (arg
, REG_NOSUB
,
8195 _("Invalid regexp")));
8196 c
->regex
= xstrdup (arg
);
8199 c
->is_load
= is_load
;
8200 init_catchpoint (c
.get (), gdbarch
, is_temp
, NULL
,
8201 &catch_solib_breakpoint_ops
);
8203 c
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
8205 install_breakpoint (0, std::move (c
), 1);
8208 /* A helper function that does all the work for "catch load" and
8212 catch_load_or_unload (const char *arg
, int from_tty
, int is_load
,
8213 struct cmd_list_element
*command
)
8215 const int enabled
= 1;
8216 bool temp
= get_cmd_context (command
) == CATCH_TEMPORARY
;
8218 add_solib_catchpoint (arg
, is_load
, temp
, enabled
);
8222 catch_load_command_1 (const char *arg
, int from_tty
,
8223 struct cmd_list_element
*command
)
8225 catch_load_or_unload (arg
, from_tty
, 1, command
);
8229 catch_unload_command_1 (const char *arg
, int from_tty
,
8230 struct cmd_list_element
*command
)
8232 catch_load_or_unload (arg
, from_tty
, 0, command
);
8235 /* See breakpoint.h. */
8238 init_catchpoint (struct breakpoint
*b
,
8239 struct gdbarch
*gdbarch
, bool temp
,
8240 const char *cond_string
,
8241 const struct breakpoint_ops
*ops
)
8243 symtab_and_line sal
;
8244 sal
.pspace
= current_program_space
;
8246 init_raw_breakpoint (b
, gdbarch
, sal
, bp_catchpoint
, ops
);
8248 b
->cond_string
= (cond_string
== NULL
) ? NULL
: xstrdup (cond_string
);
8249 b
->disposition
= temp
? disp_del
: disp_donttouch
;
8253 install_breakpoint (int internal
, std::unique_ptr
<breakpoint
> &&arg
, int update_gll
)
8255 breakpoint
*b
= add_to_breakpoint_chain (std::move (arg
));
8256 set_breakpoint_number (internal
, b
);
8257 if (is_tracepoint (b
))
8258 set_tracepoint_count (breakpoint_count
);
8261 gdb::observers::breakpoint_created
.notify (b
);
8264 update_global_location_list (UGLL_MAY_INSERT
);
8268 create_fork_vfork_event_catchpoint (struct gdbarch
*gdbarch
,
8269 bool temp
, const char *cond_string
,
8270 const struct breakpoint_ops
*ops
)
8272 std::unique_ptr
<fork_catchpoint
> c (new fork_catchpoint ());
8274 init_catchpoint (c
.get (), gdbarch
, temp
, cond_string
, ops
);
8276 c
->forked_inferior_pid
= null_ptid
;
8278 install_breakpoint (0, std::move (c
), 1);
8281 /* Exec catchpoints. */
8283 /* An instance of this type is used to represent an exec catchpoint.
8284 A breakpoint is really of this type iff its ops pointer points to
8285 CATCH_EXEC_BREAKPOINT_OPS. */
8287 struct exec_catchpoint
: public breakpoint
8289 ~exec_catchpoint () override
;
8291 /* Filename of a program whose exec triggered this catchpoint.
8292 This field is only valid immediately after this catchpoint has
8294 char *exec_pathname
;
8297 /* Exec catchpoint destructor. */
8299 exec_catchpoint::~exec_catchpoint ()
8301 xfree (this->exec_pathname
);
8305 insert_catch_exec (struct bp_location
*bl
)
8307 return target_insert_exec_catchpoint (inferior_ptid
.pid ());
8311 remove_catch_exec (struct bp_location
*bl
, enum remove_bp_reason reason
)
8313 return target_remove_exec_catchpoint (inferior_ptid
.pid ());
8317 breakpoint_hit_catch_exec (const struct bp_location
*bl
,
8318 const address_space
*aspace
, CORE_ADDR bp_addr
,
8319 const struct target_waitstatus
*ws
)
8321 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) bl
->owner
;
8323 if (ws
->kind
!= TARGET_WAITKIND_EXECD
)
8326 c
->exec_pathname
= xstrdup (ws
->value
.execd_pathname
);
8330 static enum print_stop_action
8331 print_it_catch_exec (bpstat bs
)
8333 struct ui_out
*uiout
= current_uiout
;
8334 struct breakpoint
*b
= bs
->breakpoint_at
;
8335 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
8337 annotate_catchpoint (b
->number
);
8338 maybe_print_thread_hit_breakpoint (uiout
);
8339 if (b
->disposition
== disp_del
)
8340 uiout
->text ("Temporary catchpoint ");
8342 uiout
->text ("Catchpoint ");
8343 if (uiout
->is_mi_like_p ())
8345 uiout
->field_string ("reason", async_reason_lookup (EXEC_ASYNC_EXEC
));
8346 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
8348 uiout
->field_signed ("bkptno", b
->number
);
8349 uiout
->text (" (exec'd ");
8350 uiout
->field_string ("new-exec", c
->exec_pathname
);
8351 uiout
->text ("), ");
8353 return PRINT_SRC_AND_LOC
;
8357 print_one_catch_exec (struct breakpoint
*b
, struct bp_location
**last_loc
)
8359 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
8360 struct value_print_options opts
;
8361 struct ui_out
*uiout
= current_uiout
;
8363 get_user_print_options (&opts
);
8365 /* Field 4, the address, is omitted (which makes the columns
8366 not line up too nicely with the headers, but the effect
8367 is relatively readable). */
8368 if (opts
.addressprint
)
8369 uiout
->field_skip ("addr");
8371 uiout
->text ("exec");
8372 if (c
->exec_pathname
!= NULL
)
8374 uiout
->text (", program \"");
8375 uiout
->field_string ("what", c
->exec_pathname
);
8376 uiout
->text ("\" ");
8379 if (uiout
->is_mi_like_p ())
8380 uiout
->field_string ("catch-type", "exec");
8384 print_mention_catch_exec (struct breakpoint
*b
)
8386 printf_filtered (_("Catchpoint %d (exec)"), b
->number
);
8389 /* Implement the "print_recreate" breakpoint_ops method for exec
8393 print_recreate_catch_exec (struct breakpoint
*b
, struct ui_file
*fp
)
8395 fprintf_unfiltered (fp
, "catch exec");
8396 print_recreate_thread (b
, fp
);
8399 static struct breakpoint_ops catch_exec_breakpoint_ops
;
8402 hw_breakpoint_used_count (void)
8405 struct breakpoint
*b
;
8406 struct bp_location
*bl
;
8410 if (b
->type
== bp_hardware_breakpoint
&& breakpoint_enabled (b
))
8411 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
8413 /* Special types of hardware breakpoints may use more than
8415 i
+= b
->ops
->resources_needed (bl
);
8422 /* Returns the resources B would use if it were a hardware
8426 hw_watchpoint_use_count (struct breakpoint
*b
)
8429 struct bp_location
*bl
;
8431 if (!breakpoint_enabled (b
))
8434 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
8436 /* Special types of hardware watchpoints may use more than
8438 i
+= b
->ops
->resources_needed (bl
);
8444 /* Returns the sum the used resources of all hardware watchpoints of
8445 type TYPE in the breakpoints list. Also returns in OTHER_TYPE_USED
8446 the sum of the used resources of all hardware watchpoints of other
8447 types _not_ TYPE. */
8450 hw_watchpoint_used_count_others (struct breakpoint
*except
,
8451 enum bptype type
, int *other_type_used
)
8454 struct breakpoint
*b
;
8456 *other_type_used
= 0;
8461 if (!breakpoint_enabled (b
))
8464 if (b
->type
== type
)
8465 i
+= hw_watchpoint_use_count (b
);
8466 else if (is_hardware_watchpoint (b
))
8467 *other_type_used
= 1;
8474 disable_watchpoints_before_interactive_call_start (void)
8476 struct breakpoint
*b
;
8480 if (is_watchpoint (b
) && breakpoint_enabled (b
))
8482 b
->enable_state
= bp_call_disabled
;
8483 update_global_location_list (UGLL_DONT_INSERT
);
8489 enable_watchpoints_after_interactive_call_stop (void)
8491 struct breakpoint
*b
;
8495 if (is_watchpoint (b
) && b
->enable_state
== bp_call_disabled
)
8497 b
->enable_state
= bp_enabled
;
8498 update_global_location_list (UGLL_MAY_INSERT
);
8504 disable_breakpoints_before_startup (void)
8506 current_program_space
->executing_startup
= 1;
8507 update_global_location_list (UGLL_DONT_INSERT
);
8511 enable_breakpoints_after_startup (void)
8513 current_program_space
->executing_startup
= 0;
8514 breakpoint_re_set ();
8517 /* Create a new single-step breakpoint for thread THREAD, with no
8520 static struct breakpoint
*
8521 new_single_step_breakpoint (int thread
, struct gdbarch
*gdbarch
)
8523 std::unique_ptr
<breakpoint
> b (new breakpoint ());
8525 init_raw_breakpoint_without_location (b
.get (), gdbarch
, bp_single_step
,
8526 &momentary_breakpoint_ops
);
8528 b
->disposition
= disp_donttouch
;
8529 b
->frame_id
= null_frame_id
;
8532 gdb_assert (b
->thread
!= 0);
8534 return add_to_breakpoint_chain (std::move (b
));
8537 /* Set a momentary breakpoint of type TYPE at address specified by
8538 SAL. If FRAME_ID is valid, the breakpoint is restricted to that
8542 set_momentary_breakpoint (struct gdbarch
*gdbarch
, struct symtab_and_line sal
,
8543 struct frame_id frame_id
, enum bptype type
)
8545 struct breakpoint
*b
;
8547 /* If FRAME_ID is valid, it should be a real frame, not an inlined or
8549 gdb_assert (!frame_id_artificial_p (frame_id
));
8551 b
= set_raw_breakpoint (gdbarch
, sal
, type
, &momentary_breakpoint_ops
);
8552 b
->enable_state
= bp_enabled
;
8553 b
->disposition
= disp_donttouch
;
8554 b
->frame_id
= frame_id
;
8556 b
->thread
= inferior_thread ()->global_num
;
8558 update_global_location_list_nothrow (UGLL_MAY_INSERT
);
8560 return breakpoint_up (b
);
8563 /* Make a momentary breakpoint based on the master breakpoint ORIG.
8564 The new breakpoint will have type TYPE, use OPS as its
8565 breakpoint_ops, and will set enabled to LOC_ENABLED. */
8567 static struct breakpoint
*
8568 momentary_breakpoint_from_master (struct breakpoint
*orig
,
8570 const struct breakpoint_ops
*ops
,
8573 struct breakpoint
*copy
;
8575 copy
= set_raw_breakpoint_without_location (orig
->gdbarch
, type
, ops
);
8576 copy
->loc
= allocate_bp_location (copy
);
8577 set_breakpoint_location_function (copy
->loc
);
8579 copy
->loc
->gdbarch
= orig
->loc
->gdbarch
;
8580 copy
->loc
->requested_address
= orig
->loc
->requested_address
;
8581 copy
->loc
->address
= orig
->loc
->address
;
8582 copy
->loc
->section
= orig
->loc
->section
;
8583 copy
->loc
->pspace
= orig
->loc
->pspace
;
8584 copy
->loc
->probe
= orig
->loc
->probe
;
8585 copy
->loc
->line_number
= orig
->loc
->line_number
;
8586 copy
->loc
->symtab
= orig
->loc
->symtab
;
8587 copy
->loc
->enabled
= loc_enabled
;
8588 copy
->frame_id
= orig
->frame_id
;
8589 copy
->thread
= orig
->thread
;
8590 copy
->pspace
= orig
->pspace
;
8592 copy
->enable_state
= bp_enabled
;
8593 copy
->disposition
= disp_donttouch
;
8594 copy
->number
= internal_breakpoint_number
--;
8596 update_global_location_list_nothrow (UGLL_DONT_INSERT
);
8600 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
8604 clone_momentary_breakpoint (struct breakpoint
*orig
)
8606 /* If there's nothing to clone, then return nothing. */
8610 return momentary_breakpoint_from_master (orig
, orig
->type
, orig
->ops
, 0);
8614 set_momentary_breakpoint_at_pc (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
8617 struct symtab_and_line sal
;
8619 sal
= find_pc_line (pc
, 0);
8621 sal
.section
= find_pc_overlay (pc
);
8622 sal
.explicit_pc
= 1;
8624 return set_momentary_breakpoint (gdbarch
, sal
, null_frame_id
, type
);
8628 /* Tell the user we have just set a breakpoint B. */
8631 mention (struct breakpoint
*b
)
8633 b
->ops
->print_mention (b
);
8634 current_uiout
->text ("\n");
8638 static bool bp_loc_is_permanent (struct bp_location
*loc
);
8640 /* Handle "set breakpoint auto-hw on".
8642 If the explicitly specified breakpoint type is not hardware
8643 breakpoint, check the memory map to see whether the breakpoint
8644 address is in read-only memory.
8646 - location type is not hardware breakpoint, memory is read-only.
8647 We change the type of the location to hardware breakpoint.
8649 - location type is hardware breakpoint, memory is read-write. This
8650 means we've previously made the location hardware one, but then the
8651 memory map changed, so we undo.
8655 handle_automatic_hardware_breakpoints (bp_location
*bl
)
8657 if (automatic_hardware_breakpoints
8658 && bl
->owner
->type
!= bp_hardware_breakpoint
8659 && (bl
->loc_type
== bp_loc_software_breakpoint
8660 || bl
->loc_type
== bp_loc_hardware_breakpoint
))
8662 /* When breakpoints are removed, remove_breakpoints will use
8663 location types we've just set here, the only possible problem
8664 is that memory map has changed during running program, but
8665 it's not going to work anyway with current gdb. */
8666 mem_region
*mr
= lookup_mem_region (bl
->address
);
8670 enum bp_loc_type new_type
;
8672 if (mr
->attrib
.mode
!= MEM_RW
)
8673 new_type
= bp_loc_hardware_breakpoint
;
8675 new_type
= bp_loc_software_breakpoint
;
8677 if (new_type
!= bl
->loc_type
)
8679 static bool said
= false;
8681 bl
->loc_type
= new_type
;
8684 fprintf_filtered (gdb_stdout
,
8685 _("Note: automatically using "
8686 "hardware breakpoints for "
8687 "read-only addresses.\n"));
8695 static struct bp_location
*
8696 add_location_to_breakpoint (struct breakpoint
*b
,
8697 const struct symtab_and_line
*sal
)
8699 struct bp_location
*loc
, **tmp
;
8700 CORE_ADDR adjusted_address
;
8701 struct gdbarch
*loc_gdbarch
= get_sal_arch (*sal
);
8703 if (loc_gdbarch
== NULL
)
8704 loc_gdbarch
= b
->gdbarch
;
8706 /* Adjust the breakpoint's address prior to allocating a location.
8707 Once we call allocate_bp_location(), that mostly uninitialized
8708 location will be placed on the location chain. Adjustment of the
8709 breakpoint may cause target_read_memory() to be called and we do
8710 not want its scan of the location chain to find a breakpoint and
8711 location that's only been partially initialized. */
8712 adjusted_address
= adjust_breakpoint_address (loc_gdbarch
,
8715 /* Sort the locations by their ADDRESS. */
8716 loc
= allocate_bp_location (b
);
8717 for (tmp
= &(b
->loc
); *tmp
!= NULL
&& (*tmp
)->address
<= adjusted_address
;
8718 tmp
= &((*tmp
)->next
))
8723 loc
->requested_address
= sal
->pc
;
8724 loc
->address
= adjusted_address
;
8725 loc
->pspace
= sal
->pspace
;
8726 loc
->probe
.prob
= sal
->prob
;
8727 loc
->probe
.objfile
= sal
->objfile
;
8728 gdb_assert (loc
->pspace
!= NULL
);
8729 loc
->section
= sal
->section
;
8730 loc
->gdbarch
= loc_gdbarch
;
8731 loc
->line_number
= sal
->line
;
8732 loc
->symtab
= sal
->symtab
;
8733 loc
->symbol
= sal
->symbol
;
8734 loc
->msymbol
= sal
->msymbol
;
8735 loc
->objfile
= sal
->objfile
;
8737 set_breakpoint_location_function (loc
);
8739 /* While by definition, permanent breakpoints are already present in the
8740 code, we don't mark the location as inserted. Normally one would expect
8741 that GDB could rely on that breakpoint instruction to stop the program,
8742 thus removing the need to insert its own breakpoint, except that executing
8743 the breakpoint instruction can kill the target instead of reporting a
8744 SIGTRAP. E.g., on SPARC, when interrupts are disabled, executing the
8745 instruction resets the CPU, so QEMU 2.0.0 for SPARC correspondingly dies
8746 with "Trap 0x02 while interrupts disabled, Error state". Letting the
8747 breakpoint be inserted normally results in QEMU knowing about the GDB
8748 breakpoint, and thus trap before the breakpoint instruction is executed.
8749 (If GDB later needs to continue execution past the permanent breakpoint,
8750 it manually increments the PC, thus avoiding executing the breakpoint
8752 if (bp_loc_is_permanent (loc
))
8759 /* Return true if LOC is pointing to a permanent breakpoint,
8760 return false otherwise. */
8763 bp_loc_is_permanent (struct bp_location
*loc
)
8765 gdb_assert (loc
!= NULL
);
8767 /* If we have a non-breakpoint-backed catchpoint or a software
8768 watchpoint, just return 0. We should not attempt to read from
8769 the addresses the locations of these breakpoint types point to.
8770 gdbarch_program_breakpoint_here_p, below, will attempt to read
8772 if (!bl_address_is_meaningful (loc
))
8775 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
8776 switch_to_program_space_and_thread (loc
->pspace
);
8777 return gdbarch_program_breakpoint_here_p (loc
->gdbarch
, loc
->address
);
8780 /* Build a command list for the dprintf corresponding to the current
8781 settings of the dprintf style options. */
8784 update_dprintf_command_list (struct breakpoint
*b
)
8786 char *dprintf_args
= b
->extra_string
;
8787 char *printf_line
= NULL
;
8792 dprintf_args
= skip_spaces (dprintf_args
);
8794 /* Allow a comma, as it may have terminated a location, but don't
8796 if (*dprintf_args
== ',')
8798 dprintf_args
= skip_spaces (dprintf_args
);
8800 if (*dprintf_args
!= '"')
8801 error (_("Bad format string, missing '\"'."));
8803 if (strcmp (dprintf_style
, dprintf_style_gdb
) == 0)
8804 printf_line
= xstrprintf ("printf %s", dprintf_args
);
8805 else if (strcmp (dprintf_style
, dprintf_style_call
) == 0)
8807 if (!dprintf_function
)
8808 error (_("No function supplied for dprintf call"));
8810 if (dprintf_channel
&& strlen (dprintf_channel
) > 0)
8811 printf_line
= xstrprintf ("call (void) %s (%s,%s)",
8816 printf_line
= xstrprintf ("call (void) %s (%s)",
8820 else if (strcmp (dprintf_style
, dprintf_style_agent
) == 0)
8822 if (target_can_run_breakpoint_commands ())
8823 printf_line
= xstrprintf ("agent-printf %s", dprintf_args
);
8826 warning (_("Target cannot run dprintf commands, falling back to GDB printf"));
8827 printf_line
= xstrprintf ("printf %s", dprintf_args
);
8831 internal_error (__FILE__
, __LINE__
,
8832 _("Invalid dprintf style."));
8834 gdb_assert (printf_line
!= NULL
);
8836 /* Manufacture a printf sequence. */
8837 struct command_line
*printf_cmd_line
8838 = new struct command_line (simple_control
, printf_line
);
8839 breakpoint_set_commands (b
, counted_command_line (printf_cmd_line
,
8840 command_lines_deleter ()));
8843 /* Update all dprintf commands, making their command lists reflect
8844 current style settings. */
8847 update_dprintf_commands (const char *args
, int from_tty
,
8848 struct cmd_list_element
*c
)
8850 struct breakpoint
*b
;
8854 if (b
->type
== bp_dprintf
)
8855 update_dprintf_command_list (b
);
8859 /* Create a breakpoint with SAL as location. Use LOCATION
8860 as a description of the location, and COND_STRING
8861 as condition expression. If LOCATION is NULL then create an
8862 "address location" from the address in the SAL. */
8865 init_breakpoint_sal (struct breakpoint
*b
, struct gdbarch
*gdbarch
,
8866 gdb::array_view
<const symtab_and_line
> sals
,
8867 event_location_up
&&location
,
8868 gdb::unique_xmalloc_ptr
<char> filter
,
8869 gdb::unique_xmalloc_ptr
<char> cond_string
,
8870 gdb::unique_xmalloc_ptr
<char> extra_string
,
8871 enum bptype type
, enum bpdisp disposition
,
8872 int thread
, int task
, int ignore_count
,
8873 const struct breakpoint_ops
*ops
, int from_tty
,
8874 int enabled
, int internal
, unsigned flags
,
8875 int display_canonical
)
8879 if (type
== bp_hardware_breakpoint
)
8881 int target_resources_ok
;
8883 i
= hw_breakpoint_used_count ();
8884 target_resources_ok
=
8885 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
8887 if (target_resources_ok
== 0)
8888 error (_("No hardware breakpoint support in the target."));
8889 else if (target_resources_ok
< 0)
8890 error (_("Hardware breakpoints used exceeds limit."));
8893 gdb_assert (!sals
.empty ());
8895 for (const auto &sal
: sals
)
8897 struct bp_location
*loc
;
8901 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
8903 loc_gdbarch
= gdbarch
;
8905 describe_other_breakpoints (loc_gdbarch
,
8906 sal
.pspace
, sal
.pc
, sal
.section
, thread
);
8909 if (&sal
== &sals
[0])
8911 init_raw_breakpoint (b
, gdbarch
, sal
, type
, ops
);
8915 b
->cond_string
= cond_string
.release ();
8916 b
->extra_string
= extra_string
.release ();
8917 b
->ignore_count
= ignore_count
;
8918 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
8919 b
->disposition
= disposition
;
8921 if ((flags
& CREATE_BREAKPOINT_FLAGS_INSERTED
) != 0)
8922 b
->loc
->inserted
= 1;
8924 if (type
== bp_static_tracepoint
)
8926 struct tracepoint
*t
= (struct tracepoint
*) b
;
8927 struct static_tracepoint_marker marker
;
8929 if (strace_marker_p (b
))
8931 /* We already know the marker exists, otherwise, we
8932 wouldn't see a sal for it. */
8934 = &event_location_to_string (b
->location
.get ())[3];
8937 p
= skip_spaces (p
);
8939 endp
= skip_to_space (p
);
8941 t
->static_trace_marker_id
.assign (p
, endp
- p
);
8943 printf_filtered (_("Probed static tracepoint "
8945 t
->static_trace_marker_id
.c_str ());
8947 else if (target_static_tracepoint_marker_at (sal
.pc
, &marker
))
8949 t
->static_trace_marker_id
= std::move (marker
.str_id
);
8951 printf_filtered (_("Probed static tracepoint "
8953 t
->static_trace_marker_id
.c_str ());
8956 warning (_("Couldn't determine the static "
8957 "tracepoint marker to probe"));
8964 loc
= add_location_to_breakpoint (b
, &sal
);
8965 if ((flags
& CREATE_BREAKPOINT_FLAGS_INSERTED
) != 0)
8969 /* Do not set breakpoint locations conditions yet. As locations
8970 are inserted, they get sorted based on their addresses. Let
8971 the list stabilize to have reliable location numbers. */
8973 /* Dynamic printf requires and uses additional arguments on the
8974 command line, otherwise it's an error. */
8975 if (type
== bp_dprintf
)
8977 if (b
->extra_string
)
8978 update_dprintf_command_list (b
);
8980 error (_("Format string required"));
8982 else if (b
->extra_string
)
8983 error (_("Garbage '%s' at end of command"), b
->extra_string
);
8987 /* The order of the locations is now stable. Set the location
8988 condition using the location's number. */
8990 for (bp_location
*loc
= b
->loc
; loc
!= nullptr; loc
= loc
->next
)
8992 if (b
->cond_string
!= nullptr)
8993 set_breakpoint_location_condition (b
->cond_string
, loc
, b
->number
,
8999 b
->display_canonical
= display_canonical
;
9000 if (location
!= NULL
)
9001 b
->location
= std::move (location
);
9003 b
->location
= new_address_location (b
->loc
->address
, NULL
, 0);
9004 b
->filter
= std::move (filter
);
9008 create_breakpoint_sal (struct gdbarch
*gdbarch
,
9009 gdb::array_view
<const symtab_and_line
> sals
,
9010 event_location_up
&&location
,
9011 gdb::unique_xmalloc_ptr
<char> filter
,
9012 gdb::unique_xmalloc_ptr
<char> cond_string
,
9013 gdb::unique_xmalloc_ptr
<char> extra_string
,
9014 enum bptype type
, enum bpdisp disposition
,
9015 int thread
, int task
, int ignore_count
,
9016 const struct breakpoint_ops
*ops
, int from_tty
,
9017 int enabled
, int internal
, unsigned flags
,
9018 int display_canonical
)
9020 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (type
);
9022 init_breakpoint_sal (b
.get (), gdbarch
,
9023 sals
, std::move (location
),
9025 std::move (cond_string
),
9026 std::move (extra_string
),
9028 thread
, task
, ignore_count
,
9030 enabled
, internal
, flags
,
9033 install_breakpoint (internal
, std::move (b
), 0);
9036 /* Add SALS.nelts breakpoints to the breakpoint table. For each
9037 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
9038 value. COND_STRING, if not NULL, specified the condition to be
9039 used for all breakpoints. Essentially the only case where
9040 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
9041 function. In that case, it's still not possible to specify
9042 separate conditions for different overloaded functions, so
9043 we take just a single condition string.
9045 NOTE: If the function succeeds, the caller is expected to cleanup
9046 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
9047 array contents). If the function fails (error() is called), the
9048 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
9049 COND and SALS arrays and each of those arrays contents. */
9052 create_breakpoints_sal (struct gdbarch
*gdbarch
,
9053 struct linespec_result
*canonical
,
9054 gdb::unique_xmalloc_ptr
<char> cond_string
,
9055 gdb::unique_xmalloc_ptr
<char> extra_string
,
9056 enum bptype type
, enum bpdisp disposition
,
9057 int thread
, int task
, int ignore_count
,
9058 const struct breakpoint_ops
*ops
, int from_tty
,
9059 int enabled
, int internal
, unsigned flags
)
9061 if (canonical
->pre_expanded
)
9062 gdb_assert (canonical
->lsals
.size () == 1);
9064 for (const auto &lsal
: canonical
->lsals
)
9066 /* Note that 'location' can be NULL in the case of a plain
9067 'break', without arguments. */
9068 event_location_up location
9069 = (canonical
->location
!= NULL
9070 ? copy_event_location (canonical
->location
.get ()) : NULL
);
9071 gdb::unique_xmalloc_ptr
<char> filter_string
9072 (lsal
.canonical
!= NULL
? xstrdup (lsal
.canonical
) : NULL
);
9074 create_breakpoint_sal (gdbarch
, lsal
.sals
,
9075 std::move (location
),
9076 std::move (filter_string
),
9077 std::move (cond_string
),
9078 std::move (extra_string
),
9080 thread
, task
, ignore_count
, ops
,
9081 from_tty
, enabled
, internal
, flags
,
9082 canonical
->special_display
);
9086 /* Parse LOCATION which is assumed to be a SAL specification possibly
9087 followed by conditionals. On return, SALS contains an array of SAL
9088 addresses found. LOCATION points to the end of the SAL (for
9089 linespec locations).
9091 The array and the line spec strings are allocated on the heap, it is
9092 the caller's responsibility to free them. */
9095 parse_breakpoint_sals (struct event_location
*location
,
9096 struct linespec_result
*canonical
)
9098 struct symtab_and_line cursal
;
9100 if (event_location_type (location
) == LINESPEC_LOCATION
)
9102 const char *spec
= get_linespec_location (location
)->spec_string
;
9106 /* The last displayed codepoint, if it's valid, is our default
9107 breakpoint address. */
9108 if (last_displayed_sal_is_valid ())
9110 /* Set sal's pspace, pc, symtab, and line to the values
9111 corresponding to the last call to print_frame_info.
9112 Be sure to reinitialize LINE with NOTCURRENT == 0
9113 as the breakpoint line number is inappropriate otherwise.
9114 find_pc_line would adjust PC, re-set it back. */
9115 symtab_and_line sal
= get_last_displayed_sal ();
9116 CORE_ADDR pc
= sal
.pc
;
9118 sal
= find_pc_line (pc
, 0);
9120 /* "break" without arguments is equivalent to "break *PC"
9121 where PC is the last displayed codepoint's address. So
9122 make sure to set sal.explicit_pc to prevent GDB from
9123 trying to expand the list of sals to include all other
9124 instances with the same symtab and line. */
9126 sal
.explicit_pc
= 1;
9128 struct linespec_sals lsal
;
9130 lsal
.canonical
= NULL
;
9132 canonical
->lsals
.push_back (std::move (lsal
));
9136 error (_("No default breakpoint address now."));
9140 /* Force almost all breakpoints to be in terms of the
9141 current_source_symtab (which is decode_line_1's default).
9142 This should produce the results we want almost all of the
9143 time while leaving default_breakpoint_* alone.
9145 ObjC: However, don't match an Objective-C method name which
9146 may have a '+' or '-' succeeded by a '['. */
9147 cursal
= get_current_source_symtab_and_line ();
9148 if (last_displayed_sal_is_valid ())
9150 const char *spec
= NULL
;
9152 if (event_location_type (location
) == LINESPEC_LOCATION
)
9153 spec
= get_linespec_location (location
)->spec_string
;
9157 && strchr ("+-", spec
[0]) != NULL
9160 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, NULL
,
9161 get_last_displayed_symtab (),
9162 get_last_displayed_line (),
9163 canonical
, NULL
, NULL
);
9168 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, NULL
,
9169 cursal
.symtab
, cursal
.line
, canonical
, NULL
, NULL
);
9173 /* Convert each SAL into a real PC. Verify that the PC can be
9174 inserted as a breakpoint. If it can't throw an error. */
9177 breakpoint_sals_to_pc (std::vector
<symtab_and_line
> &sals
)
9179 for (auto &sal
: sals
)
9180 resolve_sal_pc (&sal
);
9183 /* Fast tracepoints may have restrictions on valid locations. For
9184 instance, a fast tracepoint using a jump instead of a trap will
9185 likely have to overwrite more bytes than a trap would, and so can
9186 only be placed where the instruction is longer than the jump, or a
9187 multi-instruction sequence does not have a jump into the middle of
9191 check_fast_tracepoint_sals (struct gdbarch
*gdbarch
,
9192 gdb::array_view
<const symtab_and_line
> sals
)
9194 for (const auto &sal
: sals
)
9196 struct gdbarch
*sarch
;
9198 sarch
= get_sal_arch (sal
);
9199 /* We fall back to GDBARCH if there is no architecture
9200 associated with SAL. */
9204 if (!gdbarch_fast_tracepoint_valid_at (sarch
, sal
.pc
, &msg
))
9205 error (_("May not have a fast tracepoint at %s%s"),
9206 paddress (sarch
, sal
.pc
), msg
.c_str ());
9210 /* Given TOK, a string specification of condition and thread, as
9211 accepted by the 'break' command, extract the condition
9212 string and thread number and set *COND_STRING and *THREAD.
9213 PC identifies the context at which the condition should be parsed.
9214 If no condition is found, *COND_STRING is set to NULL.
9215 If no thread is found, *THREAD is set to -1. */
9218 find_condition_and_thread (const char *tok
, CORE_ADDR pc
,
9219 char **cond_string
, int *thread
, int *task
,
9222 *cond_string
= NULL
;
9230 const char *end_tok
;
9232 const char *cond_start
= NULL
;
9233 const char *cond_end
= NULL
;
9235 tok
= skip_spaces (tok
);
9237 if ((*tok
== '"' || *tok
== ',') && rest
)
9239 *rest
= savestring (tok
, strlen (tok
));
9243 end_tok
= skip_to_space (tok
);
9245 toklen
= end_tok
- tok
;
9247 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
9249 tok
= cond_start
= end_tok
+ 1;
9252 parse_exp_1 (&tok
, pc
, block_for_pc (pc
), 0);
9254 catch (const gdb_exception_error
&)
9259 tok
= tok
+ strlen (tok
);
9262 *cond_string
= savestring (cond_start
, cond_end
- cond_start
);
9264 else if (toklen
>= 1 && strncmp (tok
, "-force-condition", toklen
) == 0)
9266 tok
= cond_start
= end_tok
+ 1;
9269 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
9272 struct thread_info
*thr
;
9275 thr
= parse_thread_id (tok
, &tmptok
);
9277 error (_("Junk after thread keyword."));
9278 *thread
= thr
->global_num
;
9281 else if (toklen
>= 1 && strncmp (tok
, "task", toklen
) == 0)
9286 *task
= strtol (tok
, &tmptok
, 0);
9288 error (_("Junk after task keyword."));
9289 if (!valid_task_id (*task
))
9290 error (_("Unknown task %d."), *task
);
9295 *rest
= savestring (tok
, strlen (tok
));
9299 error (_("Junk at end of arguments."));
9303 /* Call 'find_condition_and_thread' for each sal in SALS until a parse
9304 succeeds. The parsed values are written to COND_STRING, THREAD,
9305 TASK, and REST. See the comment of 'find_condition_and_thread'
9306 for the description of these parameters and INPUT. */
9309 find_condition_and_thread_for_sals (const std::vector
<symtab_and_line
> &sals
,
9310 const char *input
, char **cond_string
,
9311 int *thread
, int *task
, char **rest
)
9313 int num_failures
= 0;
9314 for (auto &sal
: sals
)
9316 char *cond
= nullptr;
9319 char *remaining
= nullptr;
9321 /* Here we want to parse 'arg' to separate condition from thread
9322 number. But because parsing happens in a context and the
9323 contexts of sals might be different, try each until there is
9324 success. Finding one successful parse is sufficient for our
9325 goal. When setting the breakpoint we'll re-parse the
9326 condition in the context of each sal. */
9329 find_condition_and_thread (input
, sal
.pc
, &cond
, &thread_id
,
9330 &task_id
, &remaining
);
9331 *cond_string
= cond
;
9332 *thread
= thread_id
;
9337 catch (const gdb_exception_error
&e
)
9340 /* If no sal remains, do not continue. */
9341 if (num_failures
== sals
.size ())
9347 /* Decode a static tracepoint marker spec. */
9349 static std::vector
<symtab_and_line
>
9350 decode_static_tracepoint_spec (const char **arg_p
)
9352 const char *p
= &(*arg_p
)[3];
9355 p
= skip_spaces (p
);
9357 endp
= skip_to_space (p
);
9359 std::string
marker_str (p
, endp
- p
);
9361 std::vector
<static_tracepoint_marker
> markers
9362 = target_static_tracepoint_markers_by_strid (marker_str
.c_str ());
9363 if (markers
.empty ())
9364 error (_("No known static tracepoint marker named %s"),
9365 marker_str
.c_str ());
9367 std::vector
<symtab_and_line
> sals
;
9368 sals
.reserve (markers
.size ());
9370 for (const static_tracepoint_marker
&marker
: markers
)
9372 symtab_and_line sal
= find_pc_line (marker
.address
, 0);
9373 sal
.pc
= marker
.address
;
9374 sals
.push_back (sal
);
9381 /* Returns the breakpoint ops appropriate for use with with LOCATION_TYPE and
9382 according to IS_TRACEPOINT. */
9384 static const struct breakpoint_ops
*
9385 breakpoint_ops_for_event_location_type (enum event_location_type location_type
,
9390 if (location_type
== PROBE_LOCATION
)
9391 return &tracepoint_probe_breakpoint_ops
;
9393 return &tracepoint_breakpoint_ops
;
9397 if (location_type
== PROBE_LOCATION
)
9398 return &bkpt_probe_breakpoint_ops
;
9400 return &bkpt_breakpoint_ops
;
9404 /* See breakpoint.h. */
9406 const struct breakpoint_ops
*
9407 breakpoint_ops_for_event_location (const struct event_location
*location
,
9410 if (location
!= nullptr)
9411 return breakpoint_ops_for_event_location_type
9412 (event_location_type (location
), is_tracepoint
);
9413 return is_tracepoint
? &tracepoint_breakpoint_ops
: &bkpt_breakpoint_ops
;
9416 /* See breakpoint.h. */
9419 create_breakpoint (struct gdbarch
*gdbarch
,
9420 struct event_location
*location
,
9421 const char *cond_string
,
9422 int thread
, const char *extra_string
,
9424 int tempflag
, enum bptype type_wanted
,
9426 enum auto_boolean pending_break_support
,
9427 const struct breakpoint_ops
*ops
,
9428 int from_tty
, int enabled
, int internal
,
9431 struct linespec_result canonical
;
9434 int prev_bkpt_count
= breakpoint_count
;
9436 gdb_assert (ops
!= NULL
);
9438 /* If extra_string isn't useful, set it to NULL. */
9439 if (extra_string
!= NULL
&& *extra_string
== '\0')
9440 extra_string
= NULL
;
9444 ops
->create_sals_from_location (location
, &canonical
, type_wanted
);
9446 catch (const gdb_exception_error
&e
)
9448 /* If caller is interested in rc value from parse, set
9450 if (e
.error
== NOT_FOUND_ERROR
)
9452 /* If pending breakpoint support is turned off, throw
9455 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
9458 exception_print (gdb_stderr
, e
);
9460 /* If pending breakpoint support is auto query and the user
9461 selects no, then simply return the error code. */
9462 if (pending_break_support
== AUTO_BOOLEAN_AUTO
9463 && !nquery (_("Make %s pending on future shared library load? "),
9464 bptype_string (type_wanted
)))
9467 /* At this point, either the user was queried about setting
9468 a pending breakpoint and selected yes, or pending
9469 breakpoint behavior is on and thus a pending breakpoint
9470 is defaulted on behalf of the user. */
9477 if (!pending
&& canonical
.lsals
.empty ())
9480 /* Resolve all line numbers to PC's and verify that the addresses
9481 are ok for the target. */
9484 for (auto &lsal
: canonical
.lsals
)
9485 breakpoint_sals_to_pc (lsal
.sals
);
9488 /* Fast tracepoints may have additional restrictions on location. */
9489 if (!pending
&& type_wanted
== bp_fast_tracepoint
)
9491 for (const auto &lsal
: canonical
.lsals
)
9492 check_fast_tracepoint_sals (gdbarch
, lsal
.sals
);
9495 /* Verify that condition can be parsed, before setting any
9496 breakpoints. Allocate a separate condition expression for each
9500 gdb::unique_xmalloc_ptr
<char> cond_string_copy
;
9501 gdb::unique_xmalloc_ptr
<char> extra_string_copy
;
9508 const linespec_sals
&lsal
= canonical
.lsals
[0];
9510 find_condition_and_thread_for_sals (lsal
.sals
, extra_string
,
9511 &cond
, &thread
, &task
, &rest
);
9512 cond_string_copy
.reset (cond
);
9513 extra_string_copy
.reset (rest
);
9517 if (type_wanted
!= bp_dprintf
9518 && extra_string
!= NULL
&& *extra_string
!= '\0')
9519 error (_("Garbage '%s' at end of location"), extra_string
);
9521 /* Create a private copy of condition string. */
9523 cond_string_copy
.reset (xstrdup (cond_string
));
9524 /* Create a private copy of any extra string. */
9526 extra_string_copy
.reset (xstrdup (extra_string
));
9529 ops
->create_breakpoints_sal (gdbarch
, &canonical
,
9530 std::move (cond_string_copy
),
9531 std::move (extra_string_copy
),
9533 tempflag
? disp_del
: disp_donttouch
,
9534 thread
, task
, ignore_count
, ops
,
9535 from_tty
, enabled
, internal
, flags
);
9539 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (type_wanted
);
9541 init_raw_breakpoint_without_location (b
.get (), gdbarch
, type_wanted
, ops
);
9542 b
->location
= copy_event_location (location
);
9545 b
->cond_string
= NULL
;
9548 /* Create a private copy of condition string. */
9549 b
->cond_string
= cond_string
!= NULL
? xstrdup (cond_string
) : NULL
;
9553 /* Create a private copy of any extra string. */
9554 b
->extra_string
= extra_string
!= NULL
? xstrdup (extra_string
) : NULL
;
9555 b
->ignore_count
= ignore_count
;
9556 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
9557 b
->condition_not_parsed
= 1;
9558 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
9559 if ((type_wanted
!= bp_breakpoint
9560 && type_wanted
!= bp_hardware_breakpoint
) || thread
!= -1)
9561 b
->pspace
= current_program_space
;
9563 install_breakpoint (internal
, std::move (b
), 0);
9566 if (canonical
.lsals
.size () > 1)
9568 warning (_("Multiple breakpoints were set.\nUse the "
9569 "\"delete\" command to delete unwanted breakpoints."));
9570 prev_breakpoint_count
= prev_bkpt_count
;
9573 update_global_location_list (UGLL_MAY_INSERT
);
9578 /* Set a breakpoint.
9579 ARG is a string describing breakpoint address,
9580 condition, and thread.
9581 FLAG specifies if a breakpoint is hardware on,
9582 and if breakpoint is temporary, using BP_HARDWARE_FLAG
9586 break_command_1 (const char *arg
, int flag
, int from_tty
)
9588 int tempflag
= flag
& BP_TEMPFLAG
;
9589 enum bptype type_wanted
= (flag
& BP_HARDWAREFLAG
9590 ? bp_hardware_breakpoint
9593 event_location_up location
= string_to_event_location (&arg
, current_language
);
9594 const struct breakpoint_ops
*ops
= breakpoint_ops_for_event_location
9595 (location
.get (), false /* is_tracepoint */);
9597 create_breakpoint (get_current_arch (),
9599 NULL
, 0, arg
, 1 /* parse arg */,
9600 tempflag
, type_wanted
,
9601 0 /* Ignore count */,
9602 pending_break_support
,
9610 /* Helper function for break_command_1 and disassemble_command. */
9613 resolve_sal_pc (struct symtab_and_line
*sal
)
9617 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
9619 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
9620 error (_("No line %d in file \"%s\"."),
9621 sal
->line
, symtab_to_filename_for_display (sal
->symtab
));
9624 /* If this SAL corresponds to a breakpoint inserted using a line
9625 number, then skip the function prologue if necessary. */
9626 if (sal
->explicit_line
)
9627 skip_prologue_sal (sal
);
9630 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
9632 const struct blockvector
*bv
;
9633 const struct block
*b
;
9636 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
,
9637 SYMTAB_COMPUNIT (sal
->symtab
));
9640 sym
= block_linkage_function (b
);
9643 fixup_symbol_section (sym
, SYMTAB_OBJFILE (sal
->symtab
));
9644 sal
->section
= SYMBOL_OBJ_SECTION (SYMTAB_OBJFILE (sal
->symtab
),
9649 /* It really is worthwhile to have the section, so we'll
9650 just have to look harder. This case can be executed
9651 if we have line numbers but no functions (as can
9652 happen in assembly source). */
9654 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
9655 switch_to_program_space_and_thread (sal
->pspace
);
9657 bound_minimal_symbol msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
9659 sal
->section
= MSYMBOL_OBJ_SECTION (msym
.objfile
, msym
.minsym
);
9666 break_command (const char *arg
, int from_tty
)
9668 break_command_1 (arg
, 0, from_tty
);
9672 tbreak_command (const char *arg
, int from_tty
)
9674 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
9678 hbreak_command (const char *arg
, int from_tty
)
9680 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
9684 thbreak_command (const char *arg
, int from_tty
)
9686 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
9690 stop_command (const char *arg
, int from_tty
)
9692 printf_filtered (_("Specify the type of breakpoint to set.\n\
9693 Usage: stop in <function | address>\n\
9694 stop at <line>\n"));
9698 stopin_command (const char *arg
, int from_tty
)
9704 else if (*arg
!= '*')
9706 const char *argptr
= arg
;
9709 /* Look for a ':'. If this is a line number specification, then
9710 say it is bad, otherwise, it should be an address or
9711 function/method name. */
9712 while (*argptr
&& !hasColon
)
9714 hasColon
= (*argptr
== ':');
9719 badInput
= (*argptr
!= ':'); /* Not a class::method */
9721 badInput
= isdigit (*arg
); /* a simple line number */
9725 printf_filtered (_("Usage: stop in <function | address>\n"));
9727 break_command_1 (arg
, 0, from_tty
);
9731 stopat_command (const char *arg
, int from_tty
)
9735 if (arg
== NULL
|| *arg
== '*') /* no line number */
9739 const char *argptr
= arg
;
9742 /* Look for a ':'. If there is a '::' then get out, otherwise
9743 it is probably a line number. */
9744 while (*argptr
&& !hasColon
)
9746 hasColon
= (*argptr
== ':');
9751 badInput
= (*argptr
== ':'); /* we have class::method */
9753 badInput
= !isdigit (*arg
); /* not a line number */
9757 printf_filtered (_("Usage: stop at LINE\n"));
9759 break_command_1 (arg
, 0, from_tty
);
9762 /* The dynamic printf command is mostly like a regular breakpoint, but
9763 with a prewired command list consisting of a single output command,
9764 built from extra arguments supplied on the dprintf command
9768 dprintf_command (const char *arg
, int from_tty
)
9770 event_location_up location
= string_to_event_location (&arg
, current_language
);
9772 /* If non-NULL, ARG should have been advanced past the location;
9773 the next character must be ','. */
9776 if (arg
[0] != ',' || arg
[1] == '\0')
9777 error (_("Format string required"));
9780 /* Skip the comma. */
9785 create_breakpoint (get_current_arch (),
9787 NULL
, 0, arg
, 1 /* parse arg */,
9789 0 /* Ignore count */,
9790 pending_break_support
,
9791 &dprintf_breakpoint_ops
,
9799 agent_printf_command (const char *arg
, int from_tty
)
9801 error (_("May only run agent-printf on the target"));
9804 /* Implement the "breakpoint_hit" breakpoint_ops method for
9805 ranged breakpoints. */
9808 breakpoint_hit_ranged_breakpoint (const struct bp_location
*bl
,
9809 const address_space
*aspace
,
9811 const struct target_waitstatus
*ws
)
9813 if (ws
->kind
!= TARGET_WAITKIND_STOPPED
9814 || ws
->value
.sig
!= GDB_SIGNAL_TRAP
)
9817 return breakpoint_address_match_range (bl
->pspace
->aspace
, bl
->address
,
9818 bl
->length
, aspace
, bp_addr
);
9821 /* Implement the "resources_needed" breakpoint_ops method for
9822 ranged breakpoints. */
9825 resources_needed_ranged_breakpoint (const struct bp_location
*bl
)
9827 return target_ranged_break_num_registers ();
9830 /* Implement the "print_it" breakpoint_ops method for
9831 ranged breakpoints. */
9833 static enum print_stop_action
9834 print_it_ranged_breakpoint (bpstat bs
)
9836 struct breakpoint
*b
= bs
->breakpoint_at
;
9837 struct bp_location
*bl
= b
->loc
;
9838 struct ui_out
*uiout
= current_uiout
;
9840 gdb_assert (b
->type
== bp_hardware_breakpoint
);
9842 /* Ranged breakpoints have only one location. */
9843 gdb_assert (bl
&& bl
->next
== NULL
);
9845 annotate_breakpoint (b
->number
);
9847 maybe_print_thread_hit_breakpoint (uiout
);
9849 if (b
->disposition
== disp_del
)
9850 uiout
->text ("Temporary ranged breakpoint ");
9852 uiout
->text ("Ranged breakpoint ");
9853 if (uiout
->is_mi_like_p ())
9855 uiout
->field_string ("reason",
9856 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
9857 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
9859 uiout
->field_signed ("bkptno", b
->number
);
9862 return PRINT_SRC_AND_LOC
;
9865 /* Implement the "print_one" breakpoint_ops method for
9866 ranged breakpoints. */
9869 print_one_ranged_breakpoint (struct breakpoint
*b
,
9870 struct bp_location
**last_loc
)
9872 struct bp_location
*bl
= b
->loc
;
9873 struct value_print_options opts
;
9874 struct ui_out
*uiout
= current_uiout
;
9876 /* Ranged breakpoints have only one location. */
9877 gdb_assert (bl
&& bl
->next
== NULL
);
9879 get_user_print_options (&opts
);
9881 if (opts
.addressprint
)
9882 /* We don't print the address range here, it will be printed later
9883 by print_one_detail_ranged_breakpoint. */
9884 uiout
->field_skip ("addr");
9886 print_breakpoint_location (b
, bl
);
9890 /* Implement the "print_one_detail" breakpoint_ops method for
9891 ranged breakpoints. */
9894 print_one_detail_ranged_breakpoint (const struct breakpoint
*b
,
9895 struct ui_out
*uiout
)
9897 CORE_ADDR address_start
, address_end
;
9898 struct bp_location
*bl
= b
->loc
;
9903 address_start
= bl
->address
;
9904 address_end
= address_start
+ bl
->length
- 1;
9906 uiout
->text ("\taddress range: ");
9907 stb
.printf ("[%s, %s]",
9908 print_core_address (bl
->gdbarch
, address_start
),
9909 print_core_address (bl
->gdbarch
, address_end
));
9910 uiout
->field_stream ("addr", stb
);
9914 /* Implement the "print_mention" breakpoint_ops method for
9915 ranged breakpoints. */
9918 print_mention_ranged_breakpoint (struct breakpoint
*b
)
9920 struct bp_location
*bl
= b
->loc
;
9921 struct ui_out
*uiout
= current_uiout
;
9924 gdb_assert (b
->type
== bp_hardware_breakpoint
);
9926 uiout
->message (_("Hardware assisted ranged breakpoint %d from %s to %s."),
9927 b
->number
, paddress (bl
->gdbarch
, bl
->address
),
9928 paddress (bl
->gdbarch
, bl
->address
+ bl
->length
- 1));
9931 /* Implement the "print_recreate" breakpoint_ops method for
9932 ranged breakpoints. */
9935 print_recreate_ranged_breakpoint (struct breakpoint
*b
, struct ui_file
*fp
)
9937 fprintf_unfiltered (fp
, "break-range %s, %s",
9938 event_location_to_string (b
->location
.get ()),
9939 event_location_to_string (b
->location_range_end
.get ()));
9940 print_recreate_thread (b
, fp
);
9943 /* The breakpoint_ops structure to be used in ranged breakpoints. */
9945 static struct breakpoint_ops ranged_breakpoint_ops
;
9947 /* Find the address where the end of the breakpoint range should be
9948 placed, given the SAL of the end of the range. This is so that if
9949 the user provides a line number, the end of the range is set to the
9950 last instruction of the given line. */
9953 find_breakpoint_range_end (struct symtab_and_line sal
)
9957 /* If the user provided a PC value, use it. Otherwise,
9958 find the address of the end of the given location. */
9959 if (sal
.explicit_pc
)
9966 ret
= find_line_pc_range (sal
, &start
, &end
);
9968 error (_("Could not find location of the end of the range."));
9970 /* find_line_pc_range returns the start of the next line. */
9977 /* Implement the "break-range" CLI command. */
9980 break_range_command (const char *arg
, int from_tty
)
9982 const char *arg_start
;
9983 struct linespec_result canonical_start
, canonical_end
;
9984 int bp_count
, can_use_bp
, length
;
9986 struct breakpoint
*b
;
9988 /* We don't support software ranged breakpoints. */
9989 if (target_ranged_break_num_registers () < 0)
9990 error (_("This target does not support hardware ranged breakpoints."));
9992 bp_count
= hw_breakpoint_used_count ();
9993 bp_count
+= target_ranged_break_num_registers ();
9994 can_use_bp
= target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
9997 error (_("Hardware breakpoints used exceeds limit."));
9999 arg
= skip_spaces (arg
);
10000 if (arg
== NULL
|| arg
[0] == '\0')
10001 error(_("No address range specified."));
10004 event_location_up start_location
= string_to_event_location (&arg
,
10006 parse_breakpoint_sals (start_location
.get (), &canonical_start
);
10009 error (_("Too few arguments."));
10010 else if (canonical_start
.lsals
.empty ())
10011 error (_("Could not find location of the beginning of the range."));
10013 const linespec_sals
&lsal_start
= canonical_start
.lsals
[0];
10015 if (canonical_start
.lsals
.size () > 1
10016 || lsal_start
.sals
.size () != 1)
10017 error (_("Cannot create a ranged breakpoint with multiple locations."));
10019 const symtab_and_line
&sal_start
= lsal_start
.sals
[0];
10020 std::string
addr_string_start (arg_start
, arg
- arg_start
);
10022 arg
++; /* Skip the comma. */
10023 arg
= skip_spaces (arg
);
10025 /* Parse the end location. */
10029 /* We call decode_line_full directly here instead of using
10030 parse_breakpoint_sals because we need to specify the start location's
10031 symtab and line as the default symtab and line for the end of the
10032 range. This makes it possible to have ranges like "foo.c:27, +14",
10033 where +14 means 14 lines from the start location. */
10034 event_location_up end_location
= string_to_event_location (&arg
,
10036 decode_line_full (end_location
.get (), DECODE_LINE_FUNFIRSTLINE
, NULL
,
10037 sal_start
.symtab
, sal_start
.line
,
10038 &canonical_end
, NULL
, NULL
);
10040 if (canonical_end
.lsals
.empty ())
10041 error (_("Could not find location of the end of the range."));
10043 const linespec_sals
&lsal_end
= canonical_end
.lsals
[0];
10044 if (canonical_end
.lsals
.size () > 1
10045 || lsal_end
.sals
.size () != 1)
10046 error (_("Cannot create a ranged breakpoint with multiple locations."));
10048 const symtab_and_line
&sal_end
= lsal_end
.sals
[0];
10050 end
= find_breakpoint_range_end (sal_end
);
10051 if (sal_start
.pc
> end
)
10052 error (_("Invalid address range, end precedes start."));
10054 length
= end
- sal_start
.pc
+ 1;
10056 /* Length overflowed. */
10057 error (_("Address range too large."));
10058 else if (length
== 1)
10060 /* This range is simple enough to be handled by
10061 the `hbreak' command. */
10062 hbreak_command (&addr_string_start
[0], 1);
10067 /* Now set up the breakpoint. */
10068 b
= set_raw_breakpoint (get_current_arch (), sal_start
,
10069 bp_hardware_breakpoint
, &ranged_breakpoint_ops
);
10070 set_breakpoint_count (breakpoint_count
+ 1);
10071 b
->number
= breakpoint_count
;
10072 b
->disposition
= disp_donttouch
;
10073 b
->location
= std::move (start_location
);
10074 b
->location_range_end
= std::move (end_location
);
10075 b
->loc
->length
= length
;
10078 gdb::observers::breakpoint_created
.notify (b
);
10079 update_global_location_list (UGLL_MAY_INSERT
);
10082 /* Return non-zero if EXP is verified as constant. Returned zero
10083 means EXP is variable. Also the constant detection may fail for
10084 some constant expressions and in such case still falsely return
10088 watchpoint_exp_is_const (const struct expression
*exp
)
10090 int i
= exp
->nelts
;
10096 /* We are only interested in the descriptor of each element. */
10097 operator_length (exp
, i
, &oplenp
, &argsp
);
10100 switch (exp
->elts
[i
].opcode
)
10110 case BINOP_LOGICAL_AND
:
10111 case BINOP_LOGICAL_OR
:
10112 case BINOP_BITWISE_AND
:
10113 case BINOP_BITWISE_IOR
:
10114 case BINOP_BITWISE_XOR
:
10116 case BINOP_NOTEQUAL
:
10142 case OP_OBJC_NSSTRING
:
10145 case UNOP_LOGICAL_NOT
:
10146 case UNOP_COMPLEMENT
:
10151 case UNOP_CAST_TYPE
:
10152 case UNOP_REINTERPRET_CAST
:
10153 case UNOP_DYNAMIC_CAST
:
10154 /* Unary, binary and ternary operators: We have to check
10155 their operands. If they are constant, then so is the
10156 result of that operation. For instance, if A and B are
10157 determined to be constants, then so is "A + B".
10159 UNOP_IND is one exception to the rule above, because the
10160 value of *ADDR is not necessarily a constant, even when
10165 /* Check whether the associated symbol is a constant.
10167 We use SYMBOL_CLASS rather than TYPE_CONST because it's
10168 possible that a buggy compiler could mark a variable as
10169 constant even when it is not, and TYPE_CONST would return
10170 true in this case, while SYMBOL_CLASS wouldn't.
10172 We also have to check for function symbols because they
10173 are always constant. */
10175 struct symbol
*s
= exp
->elts
[i
+ 2].symbol
;
10177 if (SYMBOL_CLASS (s
) != LOC_BLOCK
10178 && SYMBOL_CLASS (s
) != LOC_CONST
10179 && SYMBOL_CLASS (s
) != LOC_CONST_BYTES
)
10184 /* The default action is to return 0 because we are using
10185 the optimistic approach here: If we don't know something,
10186 then it is not a constant. */
10195 /* Watchpoint destructor. */
10197 watchpoint::~watchpoint ()
10199 xfree (this->exp_string
);
10200 xfree (this->exp_string_reparse
);
10203 /* Implement the "re_set" breakpoint_ops method for watchpoints. */
10206 re_set_watchpoint (struct breakpoint
*b
)
10208 struct watchpoint
*w
= (struct watchpoint
*) b
;
10210 /* Watchpoint can be either on expression using entirely global
10211 variables, or it can be on local variables.
10213 Watchpoints of the first kind are never auto-deleted, and even
10214 persist across program restarts. Since they can use variables
10215 from shared libraries, we need to reparse expression as libraries
10216 are loaded and unloaded.
10218 Watchpoints on local variables can also change meaning as result
10219 of solib event. For example, if a watchpoint uses both a local
10220 and a global variables in expression, it's a local watchpoint,
10221 but unloading of a shared library will make the expression
10222 invalid. This is not a very common use case, but we still
10223 re-evaluate expression, to avoid surprises to the user.
10225 Note that for local watchpoints, we re-evaluate it only if
10226 watchpoints frame id is still valid. If it's not, it means the
10227 watchpoint is out of scope and will be deleted soon. In fact,
10228 I'm not sure we'll ever be called in this case.
10230 If a local watchpoint's frame id is still valid, then
10231 w->exp_valid_block is likewise valid, and we can safely use it.
10233 Don't do anything about disabled watchpoints, since they will be
10234 reevaluated again when enabled. */
10235 update_watchpoint (w
, 1 /* reparse */);
10238 /* Implement the "insert" breakpoint_ops method for hardware watchpoints. */
10241 insert_watchpoint (struct bp_location
*bl
)
10243 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10244 int length
= w
->exact
? 1 : bl
->length
;
10246 return target_insert_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
10247 w
->cond_exp
.get ());
10250 /* Implement the "remove" breakpoint_ops method for hardware watchpoints. */
10253 remove_watchpoint (struct bp_location
*bl
, enum remove_bp_reason reason
)
10255 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10256 int length
= w
->exact
? 1 : bl
->length
;
10258 return target_remove_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
10259 w
->cond_exp
.get ());
10263 breakpoint_hit_watchpoint (const struct bp_location
*bl
,
10264 const address_space
*aspace
, CORE_ADDR bp_addr
,
10265 const struct target_waitstatus
*ws
)
10267 struct breakpoint
*b
= bl
->owner
;
10268 struct watchpoint
*w
= (struct watchpoint
*) b
;
10270 /* Continuable hardware watchpoints are treated as non-existent if the
10271 reason we stopped wasn't a hardware watchpoint (we didn't stop on
10272 some data address). Otherwise gdb won't stop on a break instruction
10273 in the code (not from a breakpoint) when a hardware watchpoint has
10274 been defined. Also skip watchpoints which we know did not trigger
10275 (did not match the data address). */
10276 if (is_hardware_watchpoint (b
)
10277 && w
->watchpoint_triggered
== watch_triggered_no
)
10284 check_status_watchpoint (bpstat bs
)
10286 gdb_assert (is_watchpoint (bs
->breakpoint_at
));
10288 bpstat_check_watchpoint (bs
);
10291 /* Implement the "resources_needed" breakpoint_ops method for
10292 hardware watchpoints. */
10295 resources_needed_watchpoint (const struct bp_location
*bl
)
10297 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10298 int length
= w
->exact
? 1 : bl
->length
;
10300 return target_region_ok_for_hw_watchpoint (bl
->address
, length
);
10303 /* Implement the "works_in_software_mode" breakpoint_ops method for
10304 hardware watchpoints. */
10307 works_in_software_mode_watchpoint (const struct breakpoint
*b
)
10309 /* Read and access watchpoints only work with hardware support. */
10310 return b
->type
== bp_watchpoint
|| b
->type
== bp_hardware_watchpoint
;
10313 static enum print_stop_action
10314 print_it_watchpoint (bpstat bs
)
10316 struct breakpoint
*b
;
10317 enum print_stop_action result
;
10318 struct watchpoint
*w
;
10319 struct ui_out
*uiout
= current_uiout
;
10321 gdb_assert (bs
->bp_location_at
!= NULL
);
10323 b
= bs
->breakpoint_at
;
10324 w
= (struct watchpoint
*) b
;
10326 annotate_watchpoint (b
->number
);
10327 maybe_print_thread_hit_breakpoint (uiout
);
10331 gdb::optional
<ui_out_emit_tuple
> tuple_emitter
;
10334 case bp_watchpoint
:
10335 case bp_hardware_watchpoint
:
10336 if (uiout
->is_mi_like_p ())
10337 uiout
->field_string
10338 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
10340 tuple_emitter
.emplace (uiout
, "value");
10341 uiout
->text ("\nOld value = ");
10342 watchpoint_value_print (bs
->old_val
.get (), &stb
);
10343 uiout
->field_stream ("old", stb
);
10344 uiout
->text ("\nNew value = ");
10345 watchpoint_value_print (w
->val
.get (), &stb
);
10346 uiout
->field_stream ("new", stb
);
10347 uiout
->text ("\n");
10348 /* More than one watchpoint may have been triggered. */
10349 result
= PRINT_UNKNOWN
;
10352 case bp_read_watchpoint
:
10353 if (uiout
->is_mi_like_p ())
10354 uiout
->field_string
10355 ("reason", async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
10357 tuple_emitter
.emplace (uiout
, "value");
10358 uiout
->text ("\nValue = ");
10359 watchpoint_value_print (w
->val
.get (), &stb
);
10360 uiout
->field_stream ("value", stb
);
10361 uiout
->text ("\n");
10362 result
= PRINT_UNKNOWN
;
10365 case bp_access_watchpoint
:
10366 if (bs
->old_val
!= NULL
)
10368 if (uiout
->is_mi_like_p ())
10369 uiout
->field_string
10371 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
10373 tuple_emitter
.emplace (uiout
, "value");
10374 uiout
->text ("\nOld value = ");
10375 watchpoint_value_print (bs
->old_val
.get (), &stb
);
10376 uiout
->field_stream ("old", stb
);
10377 uiout
->text ("\nNew value = ");
10382 if (uiout
->is_mi_like_p ())
10383 uiout
->field_string
10385 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
10386 tuple_emitter
.emplace (uiout
, "value");
10387 uiout
->text ("\nValue = ");
10389 watchpoint_value_print (w
->val
.get (), &stb
);
10390 uiout
->field_stream ("new", stb
);
10391 uiout
->text ("\n");
10392 result
= PRINT_UNKNOWN
;
10395 result
= PRINT_UNKNOWN
;
10401 /* Implement the "print_mention" breakpoint_ops method for hardware
10405 print_mention_watchpoint (struct breakpoint
*b
)
10407 struct watchpoint
*w
= (struct watchpoint
*) b
;
10408 struct ui_out
*uiout
= current_uiout
;
10409 const char *tuple_name
;
10413 case bp_watchpoint
:
10414 uiout
->text ("Watchpoint ");
10415 tuple_name
= "wpt";
10417 case bp_hardware_watchpoint
:
10418 uiout
->text ("Hardware watchpoint ");
10419 tuple_name
= "wpt";
10421 case bp_read_watchpoint
:
10422 uiout
->text ("Hardware read watchpoint ");
10423 tuple_name
= "hw-rwpt";
10425 case bp_access_watchpoint
:
10426 uiout
->text ("Hardware access (read/write) watchpoint ");
10427 tuple_name
= "hw-awpt";
10430 internal_error (__FILE__
, __LINE__
,
10431 _("Invalid hardware watchpoint type."));
10434 ui_out_emit_tuple
tuple_emitter (uiout
, tuple_name
);
10435 uiout
->field_signed ("number", b
->number
);
10436 uiout
->text (": ");
10437 uiout
->field_string ("exp", w
->exp_string
);
10440 /* Implement the "print_recreate" breakpoint_ops method for
10444 print_recreate_watchpoint (struct breakpoint
*b
, struct ui_file
*fp
)
10446 struct watchpoint
*w
= (struct watchpoint
*) b
;
10450 case bp_watchpoint
:
10451 case bp_hardware_watchpoint
:
10452 fprintf_unfiltered (fp
, "watch");
10454 case bp_read_watchpoint
:
10455 fprintf_unfiltered (fp
, "rwatch");
10457 case bp_access_watchpoint
:
10458 fprintf_unfiltered (fp
, "awatch");
10461 internal_error (__FILE__
, __LINE__
,
10462 _("Invalid watchpoint type."));
10465 fprintf_unfiltered (fp
, " %s", w
->exp_string
);
10466 print_recreate_thread (b
, fp
);
10469 /* Implement the "explains_signal" breakpoint_ops method for
10473 explains_signal_watchpoint (struct breakpoint
*b
, enum gdb_signal sig
)
10475 /* A software watchpoint cannot cause a signal other than
10476 GDB_SIGNAL_TRAP. */
10477 if (b
->type
== bp_watchpoint
&& sig
!= GDB_SIGNAL_TRAP
)
10483 /* The breakpoint_ops structure to be used in hardware watchpoints. */
10485 static struct breakpoint_ops watchpoint_breakpoint_ops
;
10487 /* Implement the "insert" breakpoint_ops method for
10488 masked hardware watchpoints. */
10491 insert_masked_watchpoint (struct bp_location
*bl
)
10493 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10495 return target_insert_mask_watchpoint (bl
->address
, w
->hw_wp_mask
,
10496 bl
->watchpoint_type
);
10499 /* Implement the "remove" breakpoint_ops method for
10500 masked hardware watchpoints. */
10503 remove_masked_watchpoint (struct bp_location
*bl
, enum remove_bp_reason reason
)
10505 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10507 return target_remove_mask_watchpoint (bl
->address
, w
->hw_wp_mask
,
10508 bl
->watchpoint_type
);
10511 /* Implement the "resources_needed" breakpoint_ops method for
10512 masked hardware watchpoints. */
10515 resources_needed_masked_watchpoint (const struct bp_location
*bl
)
10517 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10519 return target_masked_watch_num_registers (bl
->address
, w
->hw_wp_mask
);
10522 /* Implement the "works_in_software_mode" breakpoint_ops method for
10523 masked hardware watchpoints. */
10526 works_in_software_mode_masked_watchpoint (const struct breakpoint
*b
)
10531 /* Implement the "print_it" breakpoint_ops method for
10532 masked hardware watchpoints. */
10534 static enum print_stop_action
10535 print_it_masked_watchpoint (bpstat bs
)
10537 struct breakpoint
*b
= bs
->breakpoint_at
;
10538 struct ui_out
*uiout
= current_uiout
;
10540 /* Masked watchpoints have only one location. */
10541 gdb_assert (b
->loc
&& b
->loc
->next
== NULL
);
10543 annotate_watchpoint (b
->number
);
10544 maybe_print_thread_hit_breakpoint (uiout
);
10548 case bp_hardware_watchpoint
:
10549 if (uiout
->is_mi_like_p ())
10550 uiout
->field_string
10551 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
10554 case bp_read_watchpoint
:
10555 if (uiout
->is_mi_like_p ())
10556 uiout
->field_string
10557 ("reason", async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
10560 case bp_access_watchpoint
:
10561 if (uiout
->is_mi_like_p ())
10562 uiout
->field_string
10564 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
10567 internal_error (__FILE__
, __LINE__
,
10568 _("Invalid hardware watchpoint type."));
10572 uiout
->text (_("\n\
10573 Check the underlying instruction at PC for the memory\n\
10574 address and value which triggered this watchpoint.\n"));
10575 uiout
->text ("\n");
10577 /* More than one watchpoint may have been triggered. */
10578 return PRINT_UNKNOWN
;
10581 /* Implement the "print_one_detail" breakpoint_ops method for
10582 masked hardware watchpoints. */
10585 print_one_detail_masked_watchpoint (const struct breakpoint
*b
,
10586 struct ui_out
*uiout
)
10588 struct watchpoint
*w
= (struct watchpoint
*) b
;
10590 /* Masked watchpoints have only one location. */
10591 gdb_assert (b
->loc
&& b
->loc
->next
== NULL
);
10593 uiout
->text ("\tmask ");
10594 uiout
->field_core_addr ("mask", b
->loc
->gdbarch
, w
->hw_wp_mask
);
10595 uiout
->text ("\n");
10598 /* Implement the "print_mention" breakpoint_ops method for
10599 masked hardware watchpoints. */
10602 print_mention_masked_watchpoint (struct breakpoint
*b
)
10604 struct watchpoint
*w
= (struct watchpoint
*) b
;
10605 struct ui_out
*uiout
= current_uiout
;
10606 const char *tuple_name
;
10610 case bp_hardware_watchpoint
:
10611 uiout
->text ("Masked hardware watchpoint ");
10612 tuple_name
= "wpt";
10614 case bp_read_watchpoint
:
10615 uiout
->text ("Masked hardware read watchpoint ");
10616 tuple_name
= "hw-rwpt";
10618 case bp_access_watchpoint
:
10619 uiout
->text ("Masked hardware access (read/write) watchpoint ");
10620 tuple_name
= "hw-awpt";
10623 internal_error (__FILE__
, __LINE__
,
10624 _("Invalid hardware watchpoint type."));
10627 ui_out_emit_tuple
tuple_emitter (uiout
, tuple_name
);
10628 uiout
->field_signed ("number", b
->number
);
10629 uiout
->text (": ");
10630 uiout
->field_string ("exp", w
->exp_string
);
10633 /* Implement the "print_recreate" breakpoint_ops method for
10634 masked hardware watchpoints. */
10637 print_recreate_masked_watchpoint (struct breakpoint
*b
, struct ui_file
*fp
)
10639 struct watchpoint
*w
= (struct watchpoint
*) b
;
10643 case bp_hardware_watchpoint
:
10644 fprintf_unfiltered (fp
, "watch");
10646 case bp_read_watchpoint
:
10647 fprintf_unfiltered (fp
, "rwatch");
10649 case bp_access_watchpoint
:
10650 fprintf_unfiltered (fp
, "awatch");
10653 internal_error (__FILE__
, __LINE__
,
10654 _("Invalid hardware watchpoint type."));
10657 fprintf_unfiltered (fp
, " %s mask 0x%s", w
->exp_string
,
10658 phex (w
->hw_wp_mask
, sizeof (CORE_ADDR
)));
10659 print_recreate_thread (b
, fp
);
10662 /* The breakpoint_ops structure to be used in masked hardware watchpoints. */
10664 static struct breakpoint_ops masked_watchpoint_breakpoint_ops
;
10666 /* Tell whether the given watchpoint is a masked hardware watchpoint. */
10669 is_masked_watchpoint (const struct breakpoint
*b
)
10671 return b
->ops
== &masked_watchpoint_breakpoint_ops
;
10674 /* accessflag: hw_write: watch write,
10675 hw_read: watch read,
10676 hw_access: watch access (read or write) */
10678 watch_command_1 (const char *arg
, int accessflag
, int from_tty
,
10679 int just_location
, int internal
)
10681 struct breakpoint
*scope_breakpoint
= NULL
;
10682 const struct block
*exp_valid_block
= NULL
, *cond_exp_valid_block
= NULL
;
10683 struct value
*result
;
10684 int saved_bitpos
= 0, saved_bitsize
= 0;
10685 const char *exp_start
= NULL
;
10686 const char *exp_end
= NULL
;
10687 const char *tok
, *end_tok
;
10689 const char *cond_start
= NULL
;
10690 const char *cond_end
= NULL
;
10691 enum bptype bp_type
;
10694 /* Flag to indicate whether we are going to use masks for
10695 the hardware watchpoint. */
10697 CORE_ADDR mask
= 0;
10699 /* Make sure that we actually have parameters to parse. */
10700 if (arg
!= NULL
&& arg
[0] != '\0')
10702 const char *value_start
;
10704 exp_end
= arg
+ strlen (arg
);
10706 /* Look for "parameter value" pairs at the end
10707 of the arguments string. */
10708 for (tok
= exp_end
- 1; tok
> arg
; tok
--)
10710 /* Skip whitespace at the end of the argument list. */
10711 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
10714 /* Find the beginning of the last token.
10715 This is the value of the parameter. */
10716 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
10718 value_start
= tok
+ 1;
10720 /* Skip whitespace. */
10721 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
10726 /* Find the beginning of the second to last token.
10727 This is the parameter itself. */
10728 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
10731 toklen
= end_tok
- tok
+ 1;
10733 if (toklen
== 6 && startswith (tok
, "thread"))
10735 struct thread_info
*thr
;
10736 /* At this point we've found a "thread" token, which means
10737 the user is trying to set a watchpoint that triggers
10738 only in a specific thread. */
10742 error(_("You can specify only one thread."));
10744 /* Extract the thread ID from the next token. */
10745 thr
= parse_thread_id (value_start
, &endp
);
10747 /* Check if the user provided a valid thread ID. */
10748 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
10749 invalid_thread_id_error (value_start
);
10751 thread
= thr
->global_num
;
10753 else if (toklen
== 4 && startswith (tok
, "mask"))
10755 /* We've found a "mask" token, which means the user wants to
10756 create a hardware watchpoint that is going to have the mask
10758 struct value
*mask_value
, *mark
;
10761 error(_("You can specify only one mask."));
10763 use_mask
= just_location
= 1;
10765 mark
= value_mark ();
10766 mask_value
= parse_to_comma_and_eval (&value_start
);
10767 mask
= value_as_address (mask_value
);
10768 value_free_to_mark (mark
);
10771 /* We didn't recognize what we found. We should stop here. */
10774 /* Truncate the string and get rid of the "parameter value" pair before
10775 the arguments string is parsed by the parse_exp_1 function. */
10782 /* Parse the rest of the arguments. From here on out, everything
10783 is in terms of a newly allocated string instead of the original
10785 std::string
expression (arg
, exp_end
- arg
);
10786 exp_start
= arg
= expression
.c_str ();
10787 innermost_block_tracker tracker
;
10788 expression_up exp
= parse_exp_1 (&arg
, 0, 0, 0, &tracker
);
10790 /* Remove trailing whitespace from the expression before saving it.
10791 This makes the eventual display of the expression string a bit
10793 while (exp_end
> exp_start
&& (exp_end
[-1] == ' ' || exp_end
[-1] == '\t'))
10796 /* Checking if the expression is not constant. */
10797 if (watchpoint_exp_is_const (exp
.get ()))
10801 len
= exp_end
- exp_start
;
10802 while (len
> 0 && isspace (exp_start
[len
- 1]))
10804 error (_("Cannot watch constant value `%.*s'."), len
, exp_start
);
10807 exp_valid_block
= tracker
.block ();
10808 struct value
*mark
= value_mark ();
10809 struct value
*val_as_value
= nullptr;
10810 fetch_subexp_value (exp
.get (), &pc
, &val_as_value
, &result
, NULL
,
10813 if (val_as_value
!= NULL
&& just_location
)
10815 saved_bitpos
= value_bitpos (val_as_value
);
10816 saved_bitsize
= value_bitsize (val_as_value
);
10824 exp_valid_block
= NULL
;
10825 val
= release_value (value_addr (result
));
10826 value_free_to_mark (mark
);
10830 ret
= target_masked_watch_num_registers (value_as_address (val
.get ()),
10833 error (_("This target does not support masked watchpoints."));
10834 else if (ret
== -2)
10835 error (_("Invalid mask or memory region."));
10838 else if (val_as_value
!= NULL
)
10839 val
= release_value (val_as_value
);
10841 tok
= skip_spaces (arg
);
10842 end_tok
= skip_to_space (tok
);
10844 toklen
= end_tok
- tok
;
10845 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
10847 tok
= cond_start
= end_tok
+ 1;
10848 innermost_block_tracker if_tracker
;
10849 parse_exp_1 (&tok
, 0, 0, 0, &if_tracker
);
10851 /* The watchpoint expression may not be local, but the condition
10852 may still be. E.g.: `watch global if local > 0'. */
10853 cond_exp_valid_block
= if_tracker
.block ();
10858 error (_("Junk at end of command."));
10860 frame_info
*wp_frame
= block_innermost_frame (exp_valid_block
);
10862 /* Save this because create_internal_breakpoint below invalidates
10864 frame_id watchpoint_frame
= get_frame_id (wp_frame
);
10866 /* If the expression is "local", then set up a "watchpoint scope"
10867 breakpoint at the point where we've left the scope of the watchpoint
10868 expression. Create the scope breakpoint before the watchpoint, so
10869 that we will encounter it first in bpstat_stop_status. */
10870 if (exp_valid_block
!= NULL
&& wp_frame
!= NULL
)
10872 frame_id caller_frame_id
= frame_unwind_caller_id (wp_frame
);
10874 if (frame_id_p (caller_frame_id
))
10876 gdbarch
*caller_arch
= frame_unwind_caller_arch (wp_frame
);
10877 CORE_ADDR caller_pc
= frame_unwind_caller_pc (wp_frame
);
10880 = create_internal_breakpoint (caller_arch
, caller_pc
,
10881 bp_watchpoint_scope
,
10882 &momentary_breakpoint_ops
);
10884 /* create_internal_breakpoint could invalidate WP_FRAME. */
10887 scope_breakpoint
->enable_state
= bp_enabled
;
10889 /* Automatically delete the breakpoint when it hits. */
10890 scope_breakpoint
->disposition
= disp_del
;
10892 /* Only break in the proper frame (help with recursion). */
10893 scope_breakpoint
->frame_id
= caller_frame_id
;
10895 /* Set the address at which we will stop. */
10896 scope_breakpoint
->loc
->gdbarch
= caller_arch
;
10897 scope_breakpoint
->loc
->requested_address
= caller_pc
;
10898 scope_breakpoint
->loc
->address
10899 = adjust_breakpoint_address (scope_breakpoint
->loc
->gdbarch
,
10900 scope_breakpoint
->loc
->requested_address
,
10901 scope_breakpoint
->type
);
10905 /* Now set up the breakpoint. We create all watchpoints as hardware
10906 watchpoints here even if hardware watchpoints are turned off, a call
10907 to update_watchpoint later in this function will cause the type to
10908 drop back to bp_watchpoint (software watchpoint) if required. */
10910 if (accessflag
== hw_read
)
10911 bp_type
= bp_read_watchpoint
;
10912 else if (accessflag
== hw_access
)
10913 bp_type
= bp_access_watchpoint
;
10915 bp_type
= bp_hardware_watchpoint
;
10917 std::unique_ptr
<watchpoint
> w (new watchpoint ());
10920 init_raw_breakpoint_without_location (w
.get (), NULL
, bp_type
,
10921 &masked_watchpoint_breakpoint_ops
);
10923 init_raw_breakpoint_without_location (w
.get (), NULL
, bp_type
,
10924 &watchpoint_breakpoint_ops
);
10925 w
->thread
= thread
;
10926 w
->disposition
= disp_donttouch
;
10927 w
->pspace
= current_program_space
;
10928 w
->exp
= std::move (exp
);
10929 w
->exp_valid_block
= exp_valid_block
;
10930 w
->cond_exp_valid_block
= cond_exp_valid_block
;
10933 struct type
*t
= value_type (val
.get ());
10934 CORE_ADDR addr
= value_as_address (val
.get ());
10936 w
->exp_string_reparse
10937 = current_language
->watch_location_expression (t
, addr
).release ();
10939 w
->exp_string
= xstrprintf ("-location %.*s",
10940 (int) (exp_end
- exp_start
), exp_start
);
10943 w
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
10947 w
->hw_wp_mask
= mask
;
10952 w
->val_bitpos
= saved_bitpos
;
10953 w
->val_bitsize
= saved_bitsize
;
10954 w
->val_valid
= true;
10958 w
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
10960 w
->cond_string
= 0;
10962 if (frame_id_p (watchpoint_frame
))
10964 w
->watchpoint_frame
= watchpoint_frame
;
10965 w
->watchpoint_thread
= inferior_ptid
;
10969 w
->watchpoint_frame
= null_frame_id
;
10970 w
->watchpoint_thread
= null_ptid
;
10973 if (scope_breakpoint
!= NULL
)
10975 /* The scope breakpoint is related to the watchpoint. We will
10976 need to act on them together. */
10977 w
->related_breakpoint
= scope_breakpoint
;
10978 scope_breakpoint
->related_breakpoint
= w
.get ();
10981 if (!just_location
)
10982 value_free_to_mark (mark
);
10984 /* Finally update the new watchpoint. This creates the locations
10985 that should be inserted. */
10986 update_watchpoint (w
.get (), 1);
10988 install_breakpoint (internal
, std::move (w
), 1);
10991 /* Return count of debug registers needed to watch the given expression.
10992 If the watchpoint cannot be handled in hardware return zero. */
10995 can_use_hardware_watchpoint (const std::vector
<value_ref_ptr
> &vals
)
10997 int found_memory_cnt
= 0;
10999 /* Did the user specifically forbid us to use hardware watchpoints? */
11000 if (!can_use_hw_watchpoints
)
11003 gdb_assert (!vals
.empty ());
11004 struct value
*head
= vals
[0].get ();
11006 /* Make sure that the value of the expression depends only upon
11007 memory contents, and values computed from them within GDB. If we
11008 find any register references or function calls, we can't use a
11009 hardware watchpoint.
11011 The idea here is that evaluating an expression generates a series
11012 of values, one holding the value of every subexpression. (The
11013 expression a*b+c has five subexpressions: a, b, a*b, c, and
11014 a*b+c.) GDB's values hold almost enough information to establish
11015 the criteria given above --- they identify memory lvalues,
11016 register lvalues, computed values, etcetera. So we can evaluate
11017 the expression, and then scan the chain of values that leaves
11018 behind to decide whether we can detect any possible change to the
11019 expression's final value using only hardware watchpoints.
11021 However, I don't think that the values returned by inferior
11022 function calls are special in any way. So this function may not
11023 notice that an expression involving an inferior function call
11024 can't be watched with hardware watchpoints. FIXME. */
11025 for (const value_ref_ptr
&iter
: vals
)
11027 struct value
*v
= iter
.get ();
11029 if (VALUE_LVAL (v
) == lval_memory
)
11031 if (v
!= head
&& value_lazy (v
))
11032 /* A lazy memory lvalue in the chain is one that GDB never
11033 needed to fetch; we either just used its address (e.g.,
11034 `a' in `a.b') or we never needed it at all (e.g., `a'
11035 in `a,b'). This doesn't apply to HEAD; if that is
11036 lazy then it was not readable, but watch it anyway. */
11040 /* Ahh, memory we actually used! Check if we can cover
11041 it with hardware watchpoints. */
11042 struct type
*vtype
= check_typedef (value_type (v
));
11044 /* We only watch structs and arrays if user asked for it
11045 explicitly, never if they just happen to appear in a
11046 middle of some value chain. */
11048 || (vtype
->code () != TYPE_CODE_STRUCT
11049 && vtype
->code () != TYPE_CODE_ARRAY
))
11051 CORE_ADDR vaddr
= value_address (v
);
11055 len
= (target_exact_watchpoints
11056 && is_scalar_type_recursive (vtype
))?
11057 1 : TYPE_LENGTH (value_type (v
));
11059 num_regs
= target_region_ok_for_hw_watchpoint (vaddr
, len
);
11063 found_memory_cnt
+= num_regs
;
11067 else if (VALUE_LVAL (v
) != not_lval
11068 && deprecated_value_modifiable (v
) == 0)
11069 return 0; /* These are values from the history (e.g., $1). */
11070 else if (VALUE_LVAL (v
) == lval_register
)
11071 return 0; /* Cannot watch a register with a HW watchpoint. */
11074 /* The expression itself looks suitable for using a hardware
11075 watchpoint, but give the target machine a chance to reject it. */
11076 return found_memory_cnt
;
11080 watch_command_wrapper (const char *arg
, int from_tty
, int internal
)
11082 watch_command_1 (arg
, hw_write
, from_tty
, 0, internal
);
11085 /* A helper function that looks for the "-location" argument and then
11086 calls watch_command_1. */
11089 watch_maybe_just_location (const char *arg
, int accessflag
, int from_tty
)
11091 int just_location
= 0;
11094 && (check_for_argument (&arg
, "-location", sizeof ("-location") - 1)
11095 || check_for_argument (&arg
, "-l", sizeof ("-l") - 1)))
11098 watch_command_1 (arg
, accessflag
, from_tty
, just_location
, 0);
11102 watch_command (const char *arg
, int from_tty
)
11104 watch_maybe_just_location (arg
, hw_write
, from_tty
);
11108 rwatch_command_wrapper (const char *arg
, int from_tty
, int internal
)
11110 watch_command_1 (arg
, hw_read
, from_tty
, 0, internal
);
11114 rwatch_command (const char *arg
, int from_tty
)
11116 watch_maybe_just_location (arg
, hw_read
, from_tty
);
11120 awatch_command_wrapper (const char *arg
, int from_tty
, int internal
)
11122 watch_command_1 (arg
, hw_access
, from_tty
, 0, internal
);
11126 awatch_command (const char *arg
, int from_tty
)
11128 watch_maybe_just_location (arg
, hw_access
, from_tty
);
11132 /* Data for the FSM that manages the until(location)/advance commands
11133 in infcmd.c. Here because it uses the mechanisms of
11136 struct until_break_fsm
: public thread_fsm
11138 /* The thread that was current when the command was executed. */
11141 /* The breakpoint set at the return address in the caller frame,
11142 plus breakpoints at all the destination locations. */
11143 std::vector
<breakpoint_up
> breakpoints
;
11145 until_break_fsm (struct interp
*cmd_interp
, int thread
,
11146 std::vector
<breakpoint_up
> &&breakpoints
)
11147 : thread_fsm (cmd_interp
),
11149 breakpoints (std::move (breakpoints
))
11153 void clean_up (struct thread_info
*thread
) override
;
11154 bool should_stop (struct thread_info
*thread
) override
;
11155 enum async_reply_reason
do_async_reply_reason () override
;
11158 /* Implementation of the 'should_stop' FSM method for the
11159 until(location)/advance commands. */
11162 until_break_fsm::should_stop (struct thread_info
*tp
)
11164 for (const breakpoint_up
&bp
: breakpoints
)
11165 if (bpstat_find_breakpoint (tp
->control
.stop_bpstat
,
11166 bp
.get ()) != NULL
)
11175 /* Implementation of the 'clean_up' FSM method for the
11176 until(location)/advance commands. */
11179 until_break_fsm::clean_up (struct thread_info
*)
11181 /* Clean up our temporary breakpoints. */
11182 breakpoints
.clear ();
11183 delete_longjmp_breakpoint (thread
);
11186 /* Implementation of the 'async_reply_reason' FSM method for the
11187 until(location)/advance commands. */
11189 enum async_reply_reason
11190 until_break_fsm::do_async_reply_reason ()
11192 return EXEC_ASYNC_LOCATION_REACHED
;
11196 until_break_command (const char *arg
, int from_tty
, int anywhere
)
11198 struct frame_info
*frame
;
11199 struct gdbarch
*frame_gdbarch
;
11200 struct frame_id stack_frame_id
;
11201 struct frame_id caller_frame_id
;
11203 struct thread_info
*tp
;
11205 clear_proceed_status (0);
11207 /* Set a breakpoint where the user wants it and at return from
11210 event_location_up location
= string_to_event_location (&arg
, current_language
);
11212 std::vector
<symtab_and_line
> sals
11213 = (last_displayed_sal_is_valid ()
11214 ? decode_line_1 (location
.get (), DECODE_LINE_FUNFIRSTLINE
, NULL
,
11215 get_last_displayed_symtab (),
11216 get_last_displayed_line ())
11217 : decode_line_1 (location
.get (), DECODE_LINE_FUNFIRSTLINE
,
11221 error (_("Couldn't get information on specified line."));
11224 error (_("Junk at end of arguments."));
11226 tp
= inferior_thread ();
11227 thread
= tp
->global_num
;
11229 /* Note linespec handling above invalidates the frame chain.
11230 Installing a breakpoint also invalidates the frame chain (as it
11231 may need to switch threads), so do any frame handling before
11234 frame
= get_selected_frame (NULL
);
11235 frame_gdbarch
= get_frame_arch (frame
);
11236 stack_frame_id
= get_stack_frame_id (frame
);
11237 caller_frame_id
= frame_unwind_caller_id (frame
);
11239 /* Keep within the current frame, or in frames called by the current
11242 std::vector
<breakpoint_up
> breakpoints
;
11244 gdb::optional
<delete_longjmp_breakpoint_cleanup
> lj_deleter
;
11246 if (frame_id_p (caller_frame_id
))
11248 struct symtab_and_line sal2
;
11249 struct gdbarch
*caller_gdbarch
;
11251 sal2
= find_pc_line (frame_unwind_caller_pc (frame
), 0);
11252 sal2
.pc
= frame_unwind_caller_pc (frame
);
11253 caller_gdbarch
= frame_unwind_caller_arch (frame
);
11255 breakpoint_up caller_breakpoint
11256 = set_momentary_breakpoint (caller_gdbarch
, sal2
,
11257 caller_frame_id
, bp_until
);
11258 breakpoints
.emplace_back (std::move (caller_breakpoint
));
11260 set_longjmp_breakpoint (tp
, caller_frame_id
);
11261 lj_deleter
.emplace (thread
);
11264 /* set_momentary_breakpoint could invalidate FRAME. */
11267 /* If the user told us to continue until a specified location, we
11268 don't specify a frame at which we need to stop. Otherwise,
11269 specify the selected frame, because we want to stop only at the
11270 very same frame. */
11271 frame_id stop_frame_id
= anywhere
? null_frame_id
: stack_frame_id
;
11273 for (symtab_and_line
&sal
: sals
)
11275 resolve_sal_pc (&sal
);
11277 breakpoint_up location_breakpoint
11278 = set_momentary_breakpoint (frame_gdbarch
, sal
,
11279 stop_frame_id
, bp_until
);
11280 breakpoints
.emplace_back (std::move (location_breakpoint
));
11283 tp
->thread_fsm
= new until_break_fsm (command_interp (), tp
->global_num
,
11284 std::move (breakpoints
));
11287 lj_deleter
->release ();
11289 proceed (-1, GDB_SIGNAL_DEFAULT
);
11292 /* This function attempts to parse an optional "if <cond>" clause
11293 from the arg string. If one is not found, it returns NULL.
11295 Else, it returns a pointer to the condition string. (It does not
11296 attempt to evaluate the string against a particular block.) And,
11297 it updates arg to point to the first character following the parsed
11298 if clause in the arg string. */
11301 ep_parse_optional_if_clause (const char **arg
)
11303 const char *cond_string
;
11305 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
11308 /* Skip the "if" keyword. */
11311 /* Skip any extra leading whitespace, and record the start of the
11312 condition string. */
11313 *arg
= skip_spaces (*arg
);
11314 cond_string
= *arg
;
11316 /* Assume that the condition occupies the remainder of the arg
11318 (*arg
) += strlen (cond_string
);
11320 return cond_string
;
11323 /* Commands to deal with catching events, such as signals, exceptions,
11324 process start/exit, etc. */
11328 catch_fork_temporary
, catch_vfork_temporary
,
11329 catch_fork_permanent
, catch_vfork_permanent
11334 catch_fork_command_1 (const char *arg
, int from_tty
,
11335 struct cmd_list_element
*command
)
11337 struct gdbarch
*gdbarch
= get_current_arch ();
11338 const char *cond_string
= NULL
;
11339 catch_fork_kind fork_kind
;
11341 fork_kind
= (catch_fork_kind
) (uintptr_t) get_cmd_context (command
);
11342 bool temp
= (fork_kind
== catch_fork_temporary
11343 || fork_kind
== catch_vfork_temporary
);
11347 arg
= skip_spaces (arg
);
11349 /* The allowed syntax is:
11351 catch [v]fork if <cond>
11353 First, check if there's an if clause. */
11354 cond_string
= ep_parse_optional_if_clause (&arg
);
11356 if ((*arg
!= '\0') && !isspace (*arg
))
11357 error (_("Junk at end of arguments."));
11359 /* If this target supports it, create a fork or vfork catchpoint
11360 and enable reporting of such events. */
11363 case catch_fork_temporary
:
11364 case catch_fork_permanent
:
11365 create_fork_vfork_event_catchpoint (gdbarch
, temp
, cond_string
,
11366 &catch_fork_breakpoint_ops
);
11368 case catch_vfork_temporary
:
11369 case catch_vfork_permanent
:
11370 create_fork_vfork_event_catchpoint (gdbarch
, temp
, cond_string
,
11371 &catch_vfork_breakpoint_ops
);
11374 error (_("unsupported or unknown fork kind; cannot catch it"));
11380 catch_exec_command_1 (const char *arg
, int from_tty
,
11381 struct cmd_list_element
*command
)
11383 struct gdbarch
*gdbarch
= get_current_arch ();
11384 const char *cond_string
= NULL
;
11385 bool temp
= get_cmd_context (command
) == CATCH_TEMPORARY
;
11389 arg
= skip_spaces (arg
);
11391 /* The allowed syntax is:
11393 catch exec if <cond>
11395 First, check if there's an if clause. */
11396 cond_string
= ep_parse_optional_if_clause (&arg
);
11398 if ((*arg
!= '\0') && !isspace (*arg
))
11399 error (_("Junk at end of arguments."));
11401 std::unique_ptr
<exec_catchpoint
> c (new exec_catchpoint ());
11402 init_catchpoint (c
.get (), gdbarch
, temp
, cond_string
,
11403 &catch_exec_breakpoint_ops
);
11404 c
->exec_pathname
= NULL
;
11406 install_breakpoint (0, std::move (c
), 1);
11410 init_ada_exception_breakpoint (struct breakpoint
*b
,
11411 struct gdbarch
*gdbarch
,
11412 struct symtab_and_line sal
,
11413 const char *addr_string
,
11414 const struct breakpoint_ops
*ops
,
11421 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
11423 loc_gdbarch
= gdbarch
;
11425 describe_other_breakpoints (loc_gdbarch
,
11426 sal
.pspace
, sal
.pc
, sal
.section
, -1);
11427 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
11428 version for exception catchpoints, because two catchpoints
11429 used for different exception names will use the same address.
11430 In this case, a "breakpoint ... also set at..." warning is
11431 unproductive. Besides, the warning phrasing is also a bit
11432 inappropriate, we should use the word catchpoint, and tell
11433 the user what type of catchpoint it is. The above is good
11434 enough for now, though. */
11437 init_raw_breakpoint (b
, gdbarch
, sal
, bp_catchpoint
, ops
);
11439 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
11440 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
11441 b
->location
= string_to_event_location (&addr_string
,
11442 language_def (language_ada
));
11443 b
->language
= language_ada
;
11448 /* Compare two breakpoints and return a strcmp-like result. */
11451 compare_breakpoints (const breakpoint
*a
, const breakpoint
*b
)
11453 uintptr_t ua
= (uintptr_t) a
;
11454 uintptr_t ub
= (uintptr_t) b
;
11456 if (a
->number
< b
->number
)
11458 else if (a
->number
> b
->number
)
11461 /* Now sort by address, in case we see, e..g, two breakpoints with
11465 return ua
> ub
? 1 : 0;
11468 /* Delete breakpoints by address or line. */
11471 clear_command (const char *arg
, int from_tty
)
11473 struct breakpoint
*b
;
11476 std::vector
<symtab_and_line
> decoded_sals
;
11477 symtab_and_line last_sal
;
11478 gdb::array_view
<symtab_and_line
> sals
;
11482 = decode_line_with_current_source (arg
,
11483 (DECODE_LINE_FUNFIRSTLINE
11484 | DECODE_LINE_LIST_MODE
));
11486 sals
= decoded_sals
;
11490 /* Set sal's line, symtab, pc, and pspace to the values
11491 corresponding to the last call to print_frame_info. If the
11492 codepoint is not valid, this will set all the fields to 0. */
11493 last_sal
= get_last_displayed_sal ();
11494 if (last_sal
.symtab
== 0)
11495 error (_("No source file specified."));
11501 /* We don't call resolve_sal_pc here. That's not as bad as it
11502 seems, because all existing breakpoints typically have both
11503 file/line and pc set. So, if clear is given file/line, we can
11504 match this to existing breakpoint without obtaining pc at all.
11506 We only support clearing given the address explicitly
11507 present in breakpoint table. Say, we've set breakpoint
11508 at file:line. There were several PC values for that file:line,
11509 due to optimization, all in one block.
11511 We've picked one PC value. If "clear" is issued with another
11512 PC corresponding to the same file:line, the breakpoint won't
11513 be cleared. We probably can still clear the breakpoint, but
11514 since the other PC value is never presented to user, user
11515 can only find it by guessing, and it does not seem important
11516 to support that. */
11518 /* For each line spec given, delete bps which correspond to it. Do
11519 it in two passes, solely to preserve the current behavior that
11520 from_tty is forced true if we delete more than one
11523 std::vector
<struct breakpoint
*> found
;
11524 for (const auto &sal
: sals
)
11526 const char *sal_fullname
;
11528 /* If exact pc given, clear bpts at that pc.
11529 If line given (pc == 0), clear all bpts on specified line.
11530 If defaulting, clear all bpts on default line
11533 defaulting sal.pc != 0 tests to do
11538 1 0 <can't happen> */
11540 sal_fullname
= (sal
.symtab
== NULL
11541 ? NULL
: symtab_to_fullname (sal
.symtab
));
11543 /* Find all matching breakpoints and add them to 'found'. */
11544 ALL_BREAKPOINTS (b
)
11547 /* Are we going to delete b? */
11548 if (b
->type
!= bp_none
&& !is_watchpoint (b
))
11550 struct bp_location
*loc
= b
->loc
;
11551 for (; loc
; loc
= loc
->next
)
11553 /* If the user specified file:line, don't allow a PC
11554 match. This matches historical gdb behavior. */
11555 int pc_match
= (!sal
.explicit_line
11557 && (loc
->pspace
== sal
.pspace
)
11558 && (loc
->address
== sal
.pc
)
11559 && (!section_is_overlay (loc
->section
)
11560 || loc
->section
== sal
.section
));
11561 int line_match
= 0;
11563 if ((default_match
|| sal
.explicit_line
)
11564 && loc
->symtab
!= NULL
11565 && sal_fullname
!= NULL
11566 && sal
.pspace
== loc
->pspace
11567 && loc
->line_number
== sal
.line
11568 && filename_cmp (symtab_to_fullname (loc
->symtab
),
11569 sal_fullname
) == 0)
11572 if (pc_match
|| line_match
)
11581 found
.push_back (b
);
11585 /* Now go thru the 'found' chain and delete them. */
11586 if (found
.empty ())
11589 error (_("No breakpoint at %s."), arg
);
11591 error (_("No breakpoint at this line."));
11594 /* Remove duplicates from the vec. */
11595 std::sort (found
.begin (), found
.end (),
11596 [] (const breakpoint
*bp_a
, const breakpoint
*bp_b
)
11598 return compare_breakpoints (bp_a
, bp_b
) < 0;
11600 found
.erase (std::unique (found
.begin (), found
.end (),
11601 [] (const breakpoint
*bp_a
, const breakpoint
*bp_b
)
11603 return compare_breakpoints (bp_a
, bp_b
) == 0;
11607 if (found
.size () > 1)
11608 from_tty
= 1; /* Always report if deleted more than one. */
11611 if (found
.size () == 1)
11612 printf_unfiltered (_("Deleted breakpoint "));
11614 printf_unfiltered (_("Deleted breakpoints "));
11617 for (breakpoint
*iter
: found
)
11620 printf_unfiltered ("%d ", iter
->number
);
11621 delete_breakpoint (iter
);
11624 putchar_unfiltered ('\n');
11627 /* Delete breakpoint in BS if they are `delete' breakpoints and
11628 all breakpoints that are marked for deletion, whether hit or not.
11629 This is called after any breakpoint is hit, or after errors. */
11632 breakpoint_auto_delete (bpstat bs
)
11634 struct breakpoint
*b
, *b_tmp
;
11636 for (; bs
; bs
= bs
->next
)
11637 if (bs
->breakpoint_at
11638 && bs
->breakpoint_at
->disposition
== disp_del
11640 delete_breakpoint (bs
->breakpoint_at
);
11642 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
11644 if (b
->disposition
== disp_del_at_next_stop
)
11645 delete_breakpoint (b
);
11649 /* A comparison function for bp_location AP and BP being interfaced to
11650 std::sort. Sort elements primarily by their ADDRESS (no matter what
11651 bl_address_is_meaningful says), secondarily by ordering first
11652 permanent elements and terciarily just ensuring the array is sorted
11653 stable way despite std::sort being an unstable algorithm. */
11656 bp_location_is_less_than (const bp_location
*a
, const bp_location
*b
)
11658 if (a
->address
!= b
->address
)
11659 return a
->address
< b
->address
;
11661 /* Sort locations at the same address by their pspace number, keeping
11662 locations of the same inferior (in a multi-inferior environment)
11665 if (a
->pspace
->num
!= b
->pspace
->num
)
11666 return a
->pspace
->num
< b
->pspace
->num
;
11668 /* Sort permanent breakpoints first. */
11669 if (a
->permanent
!= b
->permanent
)
11670 return a
->permanent
> b
->permanent
;
11672 /* Sort by type in order to make duplicate determination easier.
11673 See update_global_location_list. This is kept in sync with
11674 breakpoint_locations_match. */
11675 if (a
->loc_type
< b
->loc_type
)
11678 /* Likewise, for range-breakpoints, sort by length. */
11679 if (a
->loc_type
== bp_loc_hardware_breakpoint
11680 && b
->loc_type
== bp_loc_hardware_breakpoint
11681 && a
->length
< b
->length
)
11684 /* Make the internal GDB representation stable across GDB runs
11685 where A and B memory inside GDB can differ. Breakpoint locations of
11686 the same type at the same address can be sorted in arbitrary order. */
11688 if (a
->owner
->number
!= b
->owner
->number
)
11689 return a
->owner
->number
< b
->owner
->number
;
11694 /* Set bp_locations_placed_address_before_address_max and
11695 bp_locations_shadow_len_after_address_max according to the current
11696 content of the bp_locations array. */
11699 bp_locations_target_extensions_update (void)
11701 struct bp_location
*bl
, **blp_tmp
;
11703 bp_locations_placed_address_before_address_max
= 0;
11704 bp_locations_shadow_len_after_address_max
= 0;
11706 ALL_BP_LOCATIONS (bl
, blp_tmp
)
11708 CORE_ADDR start
, end
, addr
;
11710 if (!bp_location_has_shadow (bl
))
11713 start
= bl
->target_info
.placed_address
;
11714 end
= start
+ bl
->target_info
.shadow_len
;
11716 gdb_assert (bl
->address
>= start
);
11717 addr
= bl
->address
- start
;
11718 if (addr
> bp_locations_placed_address_before_address_max
)
11719 bp_locations_placed_address_before_address_max
= addr
;
11721 /* Zero SHADOW_LEN would not pass bp_location_has_shadow. */
11723 gdb_assert (bl
->address
< end
);
11724 addr
= end
- bl
->address
;
11725 if (addr
> bp_locations_shadow_len_after_address_max
)
11726 bp_locations_shadow_len_after_address_max
= addr
;
11730 /* Download tracepoint locations if they haven't been. */
11733 download_tracepoint_locations (void)
11735 struct breakpoint
*b
;
11736 enum tribool can_download_tracepoint
= TRIBOOL_UNKNOWN
;
11738 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
11740 ALL_TRACEPOINTS (b
)
11742 struct bp_location
*bl
;
11743 struct tracepoint
*t
;
11744 int bp_location_downloaded
= 0;
11746 if ((b
->type
== bp_fast_tracepoint
11747 ? !may_insert_fast_tracepoints
11748 : !may_insert_tracepoints
))
11751 if (can_download_tracepoint
== TRIBOOL_UNKNOWN
)
11753 if (target_can_download_tracepoint ())
11754 can_download_tracepoint
= TRIBOOL_TRUE
;
11756 can_download_tracepoint
= TRIBOOL_FALSE
;
11759 if (can_download_tracepoint
== TRIBOOL_FALSE
)
11762 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
11764 /* In tracepoint, locations are _never_ duplicated, so
11765 should_be_inserted is equivalent to
11766 unduplicated_should_be_inserted. */
11767 if (!should_be_inserted (bl
) || bl
->inserted
)
11770 switch_to_program_space_and_thread (bl
->pspace
);
11772 target_download_tracepoint (bl
);
11775 bp_location_downloaded
= 1;
11777 t
= (struct tracepoint
*) b
;
11778 t
->number_on_target
= b
->number
;
11779 if (bp_location_downloaded
)
11780 gdb::observers::breakpoint_modified
.notify (b
);
11784 /* Swap the insertion/duplication state between two locations. */
11787 swap_insertion (struct bp_location
*left
, struct bp_location
*right
)
11789 const int left_inserted
= left
->inserted
;
11790 const int left_duplicate
= left
->duplicate
;
11791 const int left_needs_update
= left
->needs_update
;
11792 const struct bp_target_info left_target_info
= left
->target_info
;
11794 /* Locations of tracepoints can never be duplicated. */
11795 if (is_tracepoint (left
->owner
))
11796 gdb_assert (!left
->duplicate
);
11797 if (is_tracepoint (right
->owner
))
11798 gdb_assert (!right
->duplicate
);
11800 left
->inserted
= right
->inserted
;
11801 left
->duplicate
= right
->duplicate
;
11802 left
->needs_update
= right
->needs_update
;
11803 left
->target_info
= right
->target_info
;
11804 right
->inserted
= left_inserted
;
11805 right
->duplicate
= left_duplicate
;
11806 right
->needs_update
= left_needs_update
;
11807 right
->target_info
= left_target_info
;
11810 /* Force the re-insertion of the locations at ADDRESS. This is called
11811 once a new/deleted/modified duplicate location is found and we are evaluating
11812 conditions on the target's side. Such conditions need to be updated on
11816 force_breakpoint_reinsertion (struct bp_location
*bl
)
11818 struct bp_location
**locp
= NULL
, **loc2p
;
11819 struct bp_location
*loc
;
11820 CORE_ADDR address
= 0;
11823 address
= bl
->address
;
11824 pspace_num
= bl
->pspace
->num
;
11826 /* This is only meaningful if the target is
11827 evaluating conditions and if the user has
11828 opted for condition evaluation on the target's
11830 if (gdb_evaluates_breakpoint_condition_p ()
11831 || !target_supports_evaluation_of_breakpoint_conditions ())
11834 /* Flag all breakpoint locations with this address and
11835 the same program space as the location
11836 as "its condition has changed". We need to
11837 update the conditions on the target's side. */
11838 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, address
)
11842 if (!is_breakpoint (loc
->owner
)
11843 || pspace_num
!= loc
->pspace
->num
)
11846 /* Flag the location appropriately. We use a different state to
11847 let everyone know that we already updated the set of locations
11848 with addr bl->address and program space bl->pspace. This is so
11849 we don't have to keep calling these functions just to mark locations
11850 that have already been marked. */
11851 loc
->condition_changed
= condition_updated
;
11853 /* Free the agent expression bytecode as well. We will compute
11855 loc
->cond_bytecode
.reset ();
11859 /* Called whether new breakpoints are created, or existing breakpoints
11860 deleted, to update the global location list and recompute which
11861 locations are duplicate of which.
11863 The INSERT_MODE flag determines whether locations may not, may, or
11864 shall be inserted now. See 'enum ugll_insert_mode' for more
11868 update_global_location_list (enum ugll_insert_mode insert_mode
)
11870 struct breakpoint
*b
;
11871 struct bp_location
**locp
, *loc
;
11872 /* Last breakpoint location address that was marked for update. */
11873 CORE_ADDR last_addr
= 0;
11874 /* Last breakpoint location program space that was marked for update. */
11875 int last_pspace_num
= -1;
11877 /* Used in the duplicates detection below. When iterating over all
11878 bp_locations, points to the first bp_location of a given address.
11879 Breakpoints and watchpoints of different types are never
11880 duplicates of each other. Keep one pointer for each type of
11881 breakpoint/watchpoint, so we only need to loop over all locations
11883 struct bp_location
*bp_loc_first
; /* breakpoint */
11884 struct bp_location
*wp_loc_first
; /* hardware watchpoint */
11885 struct bp_location
*awp_loc_first
; /* access watchpoint */
11886 struct bp_location
*rwp_loc_first
; /* read watchpoint */
11888 /* Saved former bp_locations array which we compare against the newly
11889 built bp_locations from the current state of ALL_BREAKPOINTS. */
11890 struct bp_location
**old_locp
;
11891 unsigned old_locations_count
;
11892 gdb::unique_xmalloc_ptr
<struct bp_location
*> old_locations (bp_locations
);
11894 old_locations_count
= bp_locations_count
;
11895 bp_locations
= NULL
;
11896 bp_locations_count
= 0;
11898 ALL_BREAKPOINTS (b
)
11899 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
11900 bp_locations_count
++;
11902 bp_locations
= XNEWVEC (struct bp_location
*, bp_locations_count
);
11903 locp
= bp_locations
;
11904 ALL_BREAKPOINTS (b
)
11905 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
11908 /* See if we need to "upgrade" a software breakpoint to a hardware
11909 breakpoint. Do this before deciding whether locations are
11910 duplicates. Also do this before sorting because sorting order
11911 depends on location type. */
11912 for (locp
= bp_locations
;
11913 locp
< bp_locations
+ bp_locations_count
;
11917 if (!loc
->inserted
&& should_be_inserted (loc
))
11918 handle_automatic_hardware_breakpoints (loc
);
11921 std::sort (bp_locations
, bp_locations
+ bp_locations_count
,
11922 bp_location_is_less_than
);
11924 bp_locations_target_extensions_update ();
11926 /* Identify bp_location instances that are no longer present in the
11927 new list, and therefore should be freed. Note that it's not
11928 necessary that those locations should be removed from inferior --
11929 if there's another location at the same address (previously
11930 marked as duplicate), we don't need to remove/insert the
11933 LOCP is kept in sync with OLD_LOCP, each pointing to the current
11934 and former bp_location array state respectively. */
11936 locp
= bp_locations
;
11937 for (old_locp
= old_locations
.get ();
11938 old_locp
< old_locations
.get () + old_locations_count
;
11941 struct bp_location
*old_loc
= *old_locp
;
11942 struct bp_location
**loc2p
;
11944 /* Tells if 'old_loc' is found among the new locations. If
11945 not, we have to free it. */
11946 int found_object
= 0;
11947 /* Tells if the location should remain inserted in the target. */
11948 int keep_in_target
= 0;
11951 /* Skip LOCP entries which will definitely never be needed.
11952 Stop either at or being the one matching OLD_LOC. */
11953 while (locp
< bp_locations
+ bp_locations_count
11954 && (*locp
)->address
< old_loc
->address
)
11958 (loc2p
< bp_locations
+ bp_locations_count
11959 && (*loc2p
)->address
== old_loc
->address
);
11962 /* Check if this is a new/duplicated location or a duplicated
11963 location that had its condition modified. If so, we want to send
11964 its condition to the target if evaluation of conditions is taking
11966 if ((*loc2p
)->condition_changed
== condition_modified
11967 && (last_addr
!= old_loc
->address
11968 || last_pspace_num
!= old_loc
->pspace
->num
))
11970 force_breakpoint_reinsertion (*loc2p
);
11971 last_pspace_num
= old_loc
->pspace
->num
;
11974 if (*loc2p
== old_loc
)
11978 /* We have already handled this address, update it so that we don't
11979 have to go through updates again. */
11980 last_addr
= old_loc
->address
;
11982 /* Target-side condition evaluation: Handle deleted locations. */
11984 force_breakpoint_reinsertion (old_loc
);
11986 /* If this location is no longer present, and inserted, look if
11987 there's maybe a new location at the same address. If so,
11988 mark that one inserted, and don't remove this one. This is
11989 needed so that we don't have a time window where a breakpoint
11990 at certain location is not inserted. */
11992 if (old_loc
->inserted
)
11994 /* If the location is inserted now, we might have to remove
11997 if (found_object
&& should_be_inserted (old_loc
))
11999 /* The location is still present in the location list,
12000 and still should be inserted. Don't do anything. */
12001 keep_in_target
= 1;
12005 /* This location still exists, but it won't be kept in the
12006 target since it may have been disabled. We proceed to
12007 remove its target-side condition. */
12009 /* The location is either no longer present, or got
12010 disabled. See if there's another location at the
12011 same address, in which case we don't need to remove
12012 this one from the target. */
12014 /* OLD_LOC comes from existing struct breakpoint. */
12015 if (bl_address_is_meaningful (old_loc
))
12018 (loc2p
< bp_locations
+ bp_locations_count
12019 && (*loc2p
)->address
== old_loc
->address
);
12022 struct bp_location
*loc2
= *loc2p
;
12024 if (loc2
== old_loc
)
12027 if (breakpoint_locations_match (loc2
, old_loc
))
12029 /* Read watchpoint locations are switched to
12030 access watchpoints, if the former are not
12031 supported, but the latter are. */
12032 if (is_hardware_watchpoint (old_loc
->owner
))
12034 gdb_assert (is_hardware_watchpoint (loc2
->owner
));
12035 loc2
->watchpoint_type
= old_loc
->watchpoint_type
;
12038 /* loc2 is a duplicated location. We need to check
12039 if it should be inserted in case it will be
12041 if (unduplicated_should_be_inserted (loc2
))
12043 swap_insertion (old_loc
, loc2
);
12044 keep_in_target
= 1;
12052 if (!keep_in_target
)
12054 if (remove_breakpoint (old_loc
))
12056 /* This is just about all we can do. We could keep
12057 this location on the global list, and try to
12058 remove it next time, but there's no particular
12059 reason why we will succeed next time.
12061 Note that at this point, old_loc->owner is still
12062 valid, as delete_breakpoint frees the breakpoint
12063 only after calling us. */
12064 printf_filtered (_("warning: Error removing "
12065 "breakpoint %d\n"),
12066 old_loc
->owner
->number
);
12074 if (removed
&& target_is_non_stop_p ()
12075 && need_moribund_for_location_type (old_loc
))
12077 /* This location was removed from the target. In
12078 non-stop mode, a race condition is possible where
12079 we've removed a breakpoint, but stop events for that
12080 breakpoint are already queued and will arrive later.
12081 We apply an heuristic to be able to distinguish such
12082 SIGTRAPs from other random SIGTRAPs: we keep this
12083 breakpoint location for a bit, and will retire it
12084 after we see some number of events. The theory here
12085 is that reporting of events should, "on the average",
12086 be fair, so after a while we'll see events from all
12087 threads that have anything of interest, and no longer
12088 need to keep this breakpoint location around. We
12089 don't hold locations forever so to reduce chances of
12090 mistaking a non-breakpoint SIGTRAP for a breakpoint
12093 The heuristic failing can be disastrous on
12094 decr_pc_after_break targets.
12096 On decr_pc_after_break targets, like e.g., x86-linux,
12097 if we fail to recognize a late breakpoint SIGTRAP,
12098 because events_till_retirement has reached 0 too
12099 soon, we'll fail to do the PC adjustment, and report
12100 a random SIGTRAP to the user. When the user resumes
12101 the inferior, it will most likely immediately crash
12102 with SIGILL/SIGBUS/SIGSEGV, or worse, get silently
12103 corrupted, because of being resumed e.g., in the
12104 middle of a multi-byte instruction, or skipped a
12105 one-byte instruction. This was actually seen happen
12106 on native x86-linux, and should be less rare on
12107 targets that do not support new thread events, like
12108 remote, due to the heuristic depending on
12111 Mistaking a random SIGTRAP for a breakpoint trap
12112 causes similar symptoms (PC adjustment applied when
12113 it shouldn't), but then again, playing with SIGTRAPs
12114 behind the debugger's back is asking for trouble.
12116 Since hardware watchpoint traps are always
12117 distinguishable from other traps, so we don't need to
12118 apply keep hardware watchpoint moribund locations
12119 around. We simply always ignore hardware watchpoint
12120 traps we can no longer explain. */
12122 process_stratum_target
*proc_target
= nullptr;
12123 for (inferior
*inf
: all_inferiors ())
12124 if (inf
->pspace
== old_loc
->pspace
)
12126 proc_target
= inf
->process_target ();
12129 if (proc_target
!= nullptr)
12130 old_loc
->events_till_retirement
12131 = 3 * (thread_count (proc_target
) + 1);
12133 old_loc
->events_till_retirement
= 1;
12134 old_loc
->owner
= NULL
;
12136 moribund_locations
.push_back (old_loc
);
12140 old_loc
->owner
= NULL
;
12141 decref_bp_location (&old_loc
);
12146 /* Rescan breakpoints at the same address and section, marking the
12147 first one as "first" and any others as "duplicates". This is so
12148 that the bpt instruction is only inserted once. If we have a
12149 permanent breakpoint at the same place as BPT, make that one the
12150 official one, and the rest as duplicates. Permanent breakpoints
12151 are sorted first for the same address.
12153 Do the same for hardware watchpoints, but also considering the
12154 watchpoint's type (regular/access/read) and length. */
12156 bp_loc_first
= NULL
;
12157 wp_loc_first
= NULL
;
12158 awp_loc_first
= NULL
;
12159 rwp_loc_first
= NULL
;
12160 ALL_BP_LOCATIONS (loc
, locp
)
12162 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always
12164 struct bp_location
**loc_first_p
;
12167 if (!unduplicated_should_be_inserted (loc
)
12168 || !bl_address_is_meaningful (loc
)
12169 /* Don't detect duplicate for tracepoint locations because they are
12170 never duplicated. See the comments in field `duplicate' of
12171 `struct bp_location'. */
12172 || is_tracepoint (b
))
12174 /* Clear the condition modification flag. */
12175 loc
->condition_changed
= condition_unchanged
;
12179 if (b
->type
== bp_hardware_watchpoint
)
12180 loc_first_p
= &wp_loc_first
;
12181 else if (b
->type
== bp_read_watchpoint
)
12182 loc_first_p
= &rwp_loc_first
;
12183 else if (b
->type
== bp_access_watchpoint
)
12184 loc_first_p
= &awp_loc_first
;
12186 loc_first_p
= &bp_loc_first
;
12188 if (*loc_first_p
== NULL
12189 || (overlay_debugging
&& loc
->section
!= (*loc_first_p
)->section
)
12190 || !breakpoint_locations_match (loc
, *loc_first_p
))
12192 *loc_first_p
= loc
;
12193 loc
->duplicate
= 0;
12195 if (is_breakpoint (loc
->owner
) && loc
->condition_changed
)
12197 loc
->needs_update
= 1;
12198 /* Clear the condition modification flag. */
12199 loc
->condition_changed
= condition_unchanged
;
12205 /* This and the above ensure the invariant that the first location
12206 is not duplicated, and is the inserted one.
12207 All following are marked as duplicated, and are not inserted. */
12209 swap_insertion (loc
, *loc_first_p
);
12210 loc
->duplicate
= 1;
12212 /* Clear the condition modification flag. */
12213 loc
->condition_changed
= condition_unchanged
;
12216 if (insert_mode
== UGLL_INSERT
|| breakpoints_should_be_inserted_now ())
12218 if (insert_mode
!= UGLL_DONT_INSERT
)
12219 insert_breakpoint_locations ();
12222 /* Even though the caller told us to not insert new
12223 locations, we may still need to update conditions on the
12224 target's side of breakpoints that were already inserted
12225 if the target is evaluating breakpoint conditions. We
12226 only update conditions for locations that are marked
12228 update_inserted_breakpoint_locations ();
12232 if (insert_mode
!= UGLL_DONT_INSERT
)
12233 download_tracepoint_locations ();
12237 breakpoint_retire_moribund (void)
12239 for (int ix
= 0; ix
< moribund_locations
.size (); ++ix
)
12241 struct bp_location
*loc
= moribund_locations
[ix
];
12242 if (--(loc
->events_till_retirement
) == 0)
12244 decref_bp_location (&loc
);
12245 unordered_remove (moribund_locations
, ix
);
12252 update_global_location_list_nothrow (enum ugll_insert_mode insert_mode
)
12257 update_global_location_list (insert_mode
);
12259 catch (const gdb_exception_error
&e
)
12264 /* Clear BKP from a BPS. */
12267 bpstat_remove_bp_location (bpstat bps
, struct breakpoint
*bpt
)
12271 for (bs
= bps
; bs
; bs
= bs
->next
)
12272 if (bs
->breakpoint_at
== bpt
)
12274 bs
->breakpoint_at
= NULL
;
12275 bs
->old_val
= NULL
;
12276 /* bs->commands will be freed later. */
12280 /* Callback for iterate_over_threads. */
12282 bpstat_remove_breakpoint_callback (struct thread_info
*th
, void *data
)
12284 struct breakpoint
*bpt
= (struct breakpoint
*) data
;
12286 bpstat_remove_bp_location (th
->control
.stop_bpstat
, bpt
);
12290 /* Helper for breakpoint and tracepoint breakpoint_ops->mention
12294 say_where (struct breakpoint
*b
)
12296 struct value_print_options opts
;
12298 get_user_print_options (&opts
);
12300 /* i18n: cagney/2005-02-11: Below needs to be merged into a
12302 if (b
->loc
== NULL
)
12304 /* For pending locations, the output differs slightly based
12305 on b->extra_string. If this is non-NULL, it contains either
12306 a condition or dprintf arguments. */
12307 if (b
->extra_string
== NULL
)
12309 printf_filtered (_(" (%s) pending."),
12310 event_location_to_string (b
->location
.get ()));
12312 else if (b
->type
== bp_dprintf
)
12314 printf_filtered (_(" (%s,%s) pending."),
12315 event_location_to_string (b
->location
.get ()),
12320 printf_filtered (_(" (%s %s) pending."),
12321 event_location_to_string (b
->location
.get ()),
12327 if (opts
.addressprint
|| b
->loc
->symtab
== NULL
)
12328 printf_filtered (" at %ps",
12329 styled_string (address_style
.style (),
12330 paddress (b
->loc
->gdbarch
,
12331 b
->loc
->address
)));
12332 if (b
->loc
->symtab
!= NULL
)
12334 /* If there is a single location, we can print the location
12336 if (b
->loc
->next
== NULL
)
12338 const char *filename
12339 = symtab_to_filename_for_display (b
->loc
->symtab
);
12340 printf_filtered (": file %ps, line %d.",
12341 styled_string (file_name_style
.style (),
12343 b
->loc
->line_number
);
12346 /* This is not ideal, but each location may have a
12347 different file name, and this at least reflects the
12348 real situation somewhat. */
12349 printf_filtered (": %s.",
12350 event_location_to_string (b
->location
.get ()));
12355 struct bp_location
*loc
= b
->loc
;
12357 for (; loc
; loc
= loc
->next
)
12359 printf_filtered (" (%d locations)", n
);
12364 bp_location::~bp_location ()
12366 xfree (function_name
);
12369 /* Destructor for the breakpoint base class. */
12371 breakpoint::~breakpoint ()
12373 xfree (this->cond_string
);
12374 xfree (this->extra_string
);
12377 static struct bp_location
*
12378 base_breakpoint_allocate_location (struct breakpoint
*self
)
12380 return new bp_location (self
);
12384 base_breakpoint_re_set (struct breakpoint
*b
)
12386 /* Nothing to re-set. */
12389 #define internal_error_pure_virtual_called() \
12390 gdb_assert_not_reached ("pure virtual function called")
12393 base_breakpoint_insert_location (struct bp_location
*bl
)
12395 internal_error_pure_virtual_called ();
12399 base_breakpoint_remove_location (struct bp_location
*bl
,
12400 enum remove_bp_reason reason
)
12402 internal_error_pure_virtual_called ();
12406 base_breakpoint_breakpoint_hit (const struct bp_location
*bl
,
12407 const address_space
*aspace
,
12409 const struct target_waitstatus
*ws
)
12411 internal_error_pure_virtual_called ();
12415 base_breakpoint_check_status (bpstat bs
)
12420 /* A "works_in_software_mode" breakpoint_ops method that just internal
12424 base_breakpoint_works_in_software_mode (const struct breakpoint
*b
)
12426 internal_error_pure_virtual_called ();
12429 /* A "resources_needed" breakpoint_ops method that just internal
12433 base_breakpoint_resources_needed (const struct bp_location
*bl
)
12435 internal_error_pure_virtual_called ();
12438 static enum print_stop_action
12439 base_breakpoint_print_it (bpstat bs
)
12441 internal_error_pure_virtual_called ();
12445 base_breakpoint_print_one_detail (const struct breakpoint
*self
,
12446 struct ui_out
*uiout
)
12452 base_breakpoint_print_mention (struct breakpoint
*b
)
12454 internal_error_pure_virtual_called ();
12458 base_breakpoint_print_recreate (struct breakpoint
*b
, struct ui_file
*fp
)
12460 internal_error_pure_virtual_called ();
12464 base_breakpoint_create_sals_from_location
12465 (struct event_location
*location
,
12466 struct linespec_result
*canonical
,
12467 enum bptype type_wanted
)
12469 internal_error_pure_virtual_called ();
12473 base_breakpoint_create_breakpoints_sal (struct gdbarch
*gdbarch
,
12474 struct linespec_result
*c
,
12475 gdb::unique_xmalloc_ptr
<char> cond_string
,
12476 gdb::unique_xmalloc_ptr
<char> extra_string
,
12477 enum bptype type_wanted
,
12478 enum bpdisp disposition
,
12480 int task
, int ignore_count
,
12481 const struct breakpoint_ops
*o
,
12482 int from_tty
, int enabled
,
12483 int internal
, unsigned flags
)
12485 internal_error_pure_virtual_called ();
12488 static std::vector
<symtab_and_line
>
12489 base_breakpoint_decode_location (struct breakpoint
*b
,
12490 struct event_location
*location
,
12491 struct program_space
*search_pspace
)
12493 internal_error_pure_virtual_called ();
12496 /* The default 'explains_signal' method. */
12499 base_breakpoint_explains_signal (struct breakpoint
*b
, enum gdb_signal sig
)
12504 /* The default "after_condition_true" method. */
12507 base_breakpoint_after_condition_true (struct bpstats
*bs
)
12509 /* Nothing to do. */
12512 struct breakpoint_ops base_breakpoint_ops
=
12514 base_breakpoint_allocate_location
,
12515 base_breakpoint_re_set
,
12516 base_breakpoint_insert_location
,
12517 base_breakpoint_remove_location
,
12518 base_breakpoint_breakpoint_hit
,
12519 base_breakpoint_check_status
,
12520 base_breakpoint_resources_needed
,
12521 base_breakpoint_works_in_software_mode
,
12522 base_breakpoint_print_it
,
12524 base_breakpoint_print_one_detail
,
12525 base_breakpoint_print_mention
,
12526 base_breakpoint_print_recreate
,
12527 base_breakpoint_create_sals_from_location
,
12528 base_breakpoint_create_breakpoints_sal
,
12529 base_breakpoint_decode_location
,
12530 base_breakpoint_explains_signal
,
12531 base_breakpoint_after_condition_true
,
12534 /* Default breakpoint_ops methods. */
12537 bkpt_re_set (struct breakpoint
*b
)
12539 /* FIXME: is this still reachable? */
12540 if (breakpoint_event_location_empty_p (b
))
12542 /* Anything without a location can't be re-set. */
12543 delete_breakpoint (b
);
12547 breakpoint_re_set_default (b
);
12551 bkpt_insert_location (struct bp_location
*bl
)
12553 CORE_ADDR addr
= bl
->target_info
.reqstd_address
;
12555 bl
->target_info
.kind
= breakpoint_kind (bl
, &addr
);
12556 bl
->target_info
.placed_address
= addr
;
12558 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
12559 return target_insert_hw_breakpoint (bl
->gdbarch
, &bl
->target_info
);
12561 return target_insert_breakpoint (bl
->gdbarch
, &bl
->target_info
);
12565 bkpt_remove_location (struct bp_location
*bl
, enum remove_bp_reason reason
)
12567 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
12568 return target_remove_hw_breakpoint (bl
->gdbarch
, &bl
->target_info
);
12570 return target_remove_breakpoint (bl
->gdbarch
, &bl
->target_info
, reason
);
12574 bkpt_breakpoint_hit (const struct bp_location
*bl
,
12575 const address_space
*aspace
, CORE_ADDR bp_addr
,
12576 const struct target_waitstatus
*ws
)
12578 if (ws
->kind
!= TARGET_WAITKIND_STOPPED
12579 || ws
->value
.sig
!= GDB_SIGNAL_TRAP
)
12582 if (!breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
12586 if (overlay_debugging
/* unmapped overlay section */
12587 && section_is_overlay (bl
->section
)
12588 && !section_is_mapped (bl
->section
))
12595 dprintf_breakpoint_hit (const struct bp_location
*bl
,
12596 const address_space
*aspace
, CORE_ADDR bp_addr
,
12597 const struct target_waitstatus
*ws
)
12599 if (dprintf_style
== dprintf_style_agent
12600 && target_can_run_breakpoint_commands ())
12602 /* An agent-style dprintf never causes a stop. If we see a trap
12603 for this address it must be for a breakpoint that happens to
12604 be set at the same address. */
12608 return bkpt_breakpoint_hit (bl
, aspace
, bp_addr
, ws
);
12612 bkpt_resources_needed (const struct bp_location
*bl
)
12614 gdb_assert (bl
->owner
->type
== bp_hardware_breakpoint
);
12619 static enum print_stop_action
12620 bkpt_print_it (bpstat bs
)
12622 struct breakpoint
*b
;
12623 const struct bp_location
*bl
;
12625 struct ui_out
*uiout
= current_uiout
;
12627 gdb_assert (bs
->bp_location_at
!= NULL
);
12629 bl
= bs
->bp_location_at
;
12630 b
= bs
->breakpoint_at
;
12632 bp_temp
= b
->disposition
== disp_del
;
12633 if (bl
->address
!= bl
->requested_address
)
12634 breakpoint_adjustment_warning (bl
->requested_address
,
12637 annotate_breakpoint (b
->number
);
12638 maybe_print_thread_hit_breakpoint (uiout
);
12640 if (uiout
->is_mi_like_p ())
12642 uiout
->field_string ("reason",
12643 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
12644 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
12647 uiout
->message ("Temporary breakpoint %pF, ",
12648 signed_field ("bkptno", b
->number
));
12650 uiout
->message ("Breakpoint %pF, ",
12651 signed_field ("bkptno", b
->number
));
12653 return PRINT_SRC_AND_LOC
;
12657 bkpt_print_mention (struct breakpoint
*b
)
12659 if (current_uiout
->is_mi_like_p ())
12664 case bp_breakpoint
:
12665 case bp_gnu_ifunc_resolver
:
12666 if (b
->disposition
== disp_del
)
12667 printf_filtered (_("Temporary breakpoint"));
12669 printf_filtered (_("Breakpoint"));
12670 printf_filtered (_(" %d"), b
->number
);
12671 if (b
->type
== bp_gnu_ifunc_resolver
)
12672 printf_filtered (_(" at gnu-indirect-function resolver"));
12674 case bp_hardware_breakpoint
:
12675 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
12678 printf_filtered (_("Dprintf %d"), b
->number
);
12686 bkpt_print_recreate (struct breakpoint
*tp
, struct ui_file
*fp
)
12688 if (tp
->type
== bp_breakpoint
&& tp
->disposition
== disp_del
)
12689 fprintf_unfiltered (fp
, "tbreak");
12690 else if (tp
->type
== bp_breakpoint
)
12691 fprintf_unfiltered (fp
, "break");
12692 else if (tp
->type
== bp_hardware_breakpoint
12693 && tp
->disposition
== disp_del
)
12694 fprintf_unfiltered (fp
, "thbreak");
12695 else if (tp
->type
== bp_hardware_breakpoint
)
12696 fprintf_unfiltered (fp
, "hbreak");
12698 internal_error (__FILE__
, __LINE__
,
12699 _("unhandled breakpoint type %d"), (int) tp
->type
);
12701 fprintf_unfiltered (fp
, " %s",
12702 event_location_to_string (tp
->location
.get ()));
12704 /* Print out extra_string if this breakpoint is pending. It might
12705 contain, for example, conditions that were set by the user. */
12706 if (tp
->loc
== NULL
&& tp
->extra_string
!= NULL
)
12707 fprintf_unfiltered (fp
, " %s", tp
->extra_string
);
12709 print_recreate_thread (tp
, fp
);
12713 bkpt_create_sals_from_location (struct event_location
*location
,
12714 struct linespec_result
*canonical
,
12715 enum bptype type_wanted
)
12717 create_sals_from_location_default (location
, canonical
, type_wanted
);
12721 bkpt_create_breakpoints_sal (struct gdbarch
*gdbarch
,
12722 struct linespec_result
*canonical
,
12723 gdb::unique_xmalloc_ptr
<char> cond_string
,
12724 gdb::unique_xmalloc_ptr
<char> extra_string
,
12725 enum bptype type_wanted
,
12726 enum bpdisp disposition
,
12728 int task
, int ignore_count
,
12729 const struct breakpoint_ops
*ops
,
12730 int from_tty
, int enabled
,
12731 int internal
, unsigned flags
)
12733 create_breakpoints_sal_default (gdbarch
, canonical
,
12734 std::move (cond_string
),
12735 std::move (extra_string
),
12737 disposition
, thread
, task
,
12738 ignore_count
, ops
, from_tty
,
12739 enabled
, internal
, flags
);
12742 static std::vector
<symtab_and_line
>
12743 bkpt_decode_location (struct breakpoint
*b
,
12744 struct event_location
*location
,
12745 struct program_space
*search_pspace
)
12747 return decode_location_default (b
, location
, search_pspace
);
12750 /* Virtual table for internal breakpoints. */
12753 internal_bkpt_re_set (struct breakpoint
*b
)
12757 /* Delete overlay event and longjmp master breakpoints; they
12758 will be reset later by breakpoint_re_set. */
12759 case bp_overlay_event
:
12760 case bp_longjmp_master
:
12761 case bp_std_terminate_master
:
12762 case bp_exception_master
:
12763 delete_breakpoint (b
);
12766 /* This breakpoint is special, it's set up when the inferior
12767 starts and we really don't want to touch it. */
12768 case bp_shlib_event
:
12770 /* Like bp_shlib_event, this breakpoint type is special. Once
12771 it is set up, we do not want to touch it. */
12772 case bp_thread_event
:
12778 internal_bkpt_check_status (bpstat bs
)
12780 if (bs
->breakpoint_at
->type
== bp_shlib_event
)
12782 /* If requested, stop when the dynamic linker notifies GDB of
12783 events. This allows the user to get control and place
12784 breakpoints in initializer routines for dynamically loaded
12785 objects (among other things). */
12786 bs
->stop
= stop_on_solib_events
;
12787 bs
->print
= stop_on_solib_events
;
12793 static enum print_stop_action
12794 internal_bkpt_print_it (bpstat bs
)
12796 struct breakpoint
*b
;
12798 b
= bs
->breakpoint_at
;
12802 case bp_shlib_event
:
12803 /* Did we stop because the user set the stop_on_solib_events
12804 variable? (If so, we report this as a generic, "Stopped due
12805 to shlib event" message.) */
12806 print_solib_event (0);
12809 case bp_thread_event
:
12810 /* Not sure how we will get here.
12811 GDB should not stop for these breakpoints. */
12812 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
12815 case bp_overlay_event
:
12816 /* By analogy with the thread event, GDB should not stop for these. */
12817 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
12820 case bp_longjmp_master
:
12821 /* These should never be enabled. */
12822 printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
12825 case bp_std_terminate_master
:
12826 /* These should never be enabled. */
12827 printf_filtered (_("std::terminate Master Breakpoint: "
12828 "gdb should not stop!\n"));
12831 case bp_exception_master
:
12832 /* These should never be enabled. */
12833 printf_filtered (_("Exception Master Breakpoint: "
12834 "gdb should not stop!\n"));
12838 return PRINT_NOTHING
;
12842 internal_bkpt_print_mention (struct breakpoint
*b
)
12844 /* Nothing to mention. These breakpoints are internal. */
12847 /* Virtual table for momentary breakpoints */
12850 momentary_bkpt_re_set (struct breakpoint
*b
)
12852 /* Keep temporary breakpoints, which can be encountered when we step
12853 over a dlopen call and solib_add is resetting the breakpoints.
12854 Otherwise these should have been blown away via the cleanup chain
12855 or by breakpoint_init_inferior when we rerun the executable. */
12859 momentary_bkpt_check_status (bpstat bs
)
12861 /* Nothing. The point of these breakpoints is causing a stop. */
12864 static enum print_stop_action
12865 momentary_bkpt_print_it (bpstat bs
)
12867 return PRINT_UNKNOWN
;
12871 momentary_bkpt_print_mention (struct breakpoint
*b
)
12873 /* Nothing to mention. These breakpoints are internal. */
12876 /* Ensure INITIATING_FRAME is cleared when no such breakpoint exists.
12878 It gets cleared already on the removal of the first one of such placed
12879 breakpoints. This is OK as they get all removed altogether. */
12881 longjmp_breakpoint::~longjmp_breakpoint ()
12883 thread_info
*tp
= find_thread_global_id (this->thread
);
12886 tp
->initiating_frame
= null_frame_id
;
12889 /* Specific methods for probe breakpoints. */
12892 bkpt_probe_insert_location (struct bp_location
*bl
)
12894 int v
= bkpt_insert_location (bl
);
12898 /* The insertion was successful, now let's set the probe's semaphore
12900 bl
->probe
.prob
->set_semaphore (bl
->probe
.objfile
, bl
->gdbarch
);
12907 bkpt_probe_remove_location (struct bp_location
*bl
,
12908 enum remove_bp_reason reason
)
12910 /* Let's clear the semaphore before removing the location. */
12911 bl
->probe
.prob
->clear_semaphore (bl
->probe
.objfile
, bl
->gdbarch
);
12913 return bkpt_remove_location (bl
, reason
);
12917 bkpt_probe_create_sals_from_location (struct event_location
*location
,
12918 struct linespec_result
*canonical
,
12919 enum bptype type_wanted
)
12921 struct linespec_sals lsal
;
12923 lsal
.sals
= parse_probes (location
, NULL
, canonical
);
12925 = xstrdup (event_location_to_string (canonical
->location
.get ()));
12926 canonical
->lsals
.push_back (std::move (lsal
));
12929 static std::vector
<symtab_and_line
>
12930 bkpt_probe_decode_location (struct breakpoint
*b
,
12931 struct event_location
*location
,
12932 struct program_space
*search_pspace
)
12934 std::vector
<symtab_and_line
> sals
= parse_probes (location
, search_pspace
, NULL
);
12936 error (_("probe not found"));
12940 /* The breakpoint_ops structure to be used in tracepoints. */
12943 tracepoint_re_set (struct breakpoint
*b
)
12945 breakpoint_re_set_default (b
);
12949 tracepoint_breakpoint_hit (const struct bp_location
*bl
,
12950 const address_space
*aspace
, CORE_ADDR bp_addr
,
12951 const struct target_waitstatus
*ws
)
12953 /* By definition, the inferior does not report stops at
12959 tracepoint_print_one_detail (const struct breakpoint
*self
,
12960 struct ui_out
*uiout
)
12962 struct tracepoint
*tp
= (struct tracepoint
*) self
;
12963 if (!tp
->static_trace_marker_id
.empty ())
12965 gdb_assert (self
->type
== bp_static_tracepoint
);
12967 uiout
->message ("\tmarker id is %pF\n",
12968 string_field ("static-tracepoint-marker-string-id",
12969 tp
->static_trace_marker_id
.c_str ()));
12974 tracepoint_print_mention (struct breakpoint
*b
)
12976 if (current_uiout
->is_mi_like_p ())
12981 case bp_tracepoint
:
12982 printf_filtered (_("Tracepoint"));
12983 printf_filtered (_(" %d"), b
->number
);
12985 case bp_fast_tracepoint
:
12986 printf_filtered (_("Fast tracepoint"));
12987 printf_filtered (_(" %d"), b
->number
);
12989 case bp_static_tracepoint
:
12990 printf_filtered (_("Static tracepoint"));
12991 printf_filtered (_(" %d"), b
->number
);
12994 internal_error (__FILE__
, __LINE__
,
12995 _("unhandled tracepoint type %d"), (int) b
->type
);
13002 tracepoint_print_recreate (struct breakpoint
*self
, struct ui_file
*fp
)
13004 struct tracepoint
*tp
= (struct tracepoint
*) self
;
13006 if (self
->type
== bp_fast_tracepoint
)
13007 fprintf_unfiltered (fp
, "ftrace");
13008 else if (self
->type
== bp_static_tracepoint
)
13009 fprintf_unfiltered (fp
, "strace");
13010 else if (self
->type
== bp_tracepoint
)
13011 fprintf_unfiltered (fp
, "trace");
13013 internal_error (__FILE__
, __LINE__
,
13014 _("unhandled tracepoint type %d"), (int) self
->type
);
13016 fprintf_unfiltered (fp
, " %s",
13017 event_location_to_string (self
->location
.get ()));
13018 print_recreate_thread (self
, fp
);
13020 if (tp
->pass_count
)
13021 fprintf_unfiltered (fp
, " passcount %d\n", tp
->pass_count
);
13025 tracepoint_create_sals_from_location (struct event_location
*location
,
13026 struct linespec_result
*canonical
,
13027 enum bptype type_wanted
)
13029 create_sals_from_location_default (location
, canonical
, type_wanted
);
13033 tracepoint_create_breakpoints_sal (struct gdbarch
*gdbarch
,
13034 struct linespec_result
*canonical
,
13035 gdb::unique_xmalloc_ptr
<char> cond_string
,
13036 gdb::unique_xmalloc_ptr
<char> extra_string
,
13037 enum bptype type_wanted
,
13038 enum bpdisp disposition
,
13040 int task
, int ignore_count
,
13041 const struct breakpoint_ops
*ops
,
13042 int from_tty
, int enabled
,
13043 int internal
, unsigned flags
)
13045 create_breakpoints_sal_default (gdbarch
, canonical
,
13046 std::move (cond_string
),
13047 std::move (extra_string
),
13049 disposition
, thread
, task
,
13050 ignore_count
, ops
, from_tty
,
13051 enabled
, internal
, flags
);
13054 static std::vector
<symtab_and_line
>
13055 tracepoint_decode_location (struct breakpoint
*b
,
13056 struct event_location
*location
,
13057 struct program_space
*search_pspace
)
13059 return decode_location_default (b
, location
, search_pspace
);
13062 struct breakpoint_ops tracepoint_breakpoint_ops
;
13064 /* Virtual table for tracepoints on static probes. */
13067 tracepoint_probe_create_sals_from_location
13068 (struct event_location
*location
,
13069 struct linespec_result
*canonical
,
13070 enum bptype type_wanted
)
13072 /* We use the same method for breakpoint on probes. */
13073 bkpt_probe_create_sals_from_location (location
, canonical
, type_wanted
);
13076 static std::vector
<symtab_and_line
>
13077 tracepoint_probe_decode_location (struct breakpoint
*b
,
13078 struct event_location
*location
,
13079 struct program_space
*search_pspace
)
13081 /* We use the same method for breakpoint on probes. */
13082 return bkpt_probe_decode_location (b
, location
, search_pspace
);
13085 /* Dprintf breakpoint_ops methods. */
13088 dprintf_re_set (struct breakpoint
*b
)
13090 breakpoint_re_set_default (b
);
13092 /* extra_string should never be non-NULL for dprintf. */
13093 gdb_assert (b
->extra_string
!= NULL
);
13095 /* 1 - connect to target 1, that can run breakpoint commands.
13096 2 - create a dprintf, which resolves fine.
13097 3 - disconnect from target 1
13098 4 - connect to target 2, that can NOT run breakpoint commands.
13100 After steps #3/#4, you'll want the dprintf command list to
13101 be updated, because target 1 and 2 may well return different
13102 answers for target_can_run_breakpoint_commands().
13103 Given absence of finer grained resetting, we get to do
13104 it all the time. */
13105 if (b
->extra_string
!= NULL
)
13106 update_dprintf_command_list (b
);
13109 /* Implement the "print_recreate" breakpoint_ops method for dprintf. */
13112 dprintf_print_recreate (struct breakpoint
*tp
, struct ui_file
*fp
)
13114 fprintf_unfiltered (fp
, "dprintf %s,%s",
13115 event_location_to_string (tp
->location
.get ()),
13117 print_recreate_thread (tp
, fp
);
13120 /* Implement the "after_condition_true" breakpoint_ops method for
13123 dprintf's are implemented with regular commands in their command
13124 list, but we run the commands here instead of before presenting the
13125 stop to the user, as dprintf's don't actually cause a stop. This
13126 also makes it so that the commands of multiple dprintfs at the same
13127 address are all handled. */
13130 dprintf_after_condition_true (struct bpstats
*bs
)
13132 struct bpstats tmp_bs
;
13133 struct bpstats
*tmp_bs_p
= &tmp_bs
;
13135 /* dprintf's never cause a stop. This wasn't set in the
13136 check_status hook instead because that would make the dprintf's
13137 condition not be evaluated. */
13140 /* Run the command list here. Take ownership of it instead of
13141 copying. We never want these commands to run later in
13142 bpstat_do_actions, if a breakpoint that causes a stop happens to
13143 be set at same address as this dprintf, or even if running the
13144 commands here throws. */
13145 tmp_bs
.commands
= bs
->commands
;
13146 bs
->commands
= NULL
;
13148 bpstat_do_actions_1 (&tmp_bs_p
);
13150 /* 'tmp_bs.commands' will usually be NULL by now, but
13151 bpstat_do_actions_1 may return early without processing the whole
13155 /* The breakpoint_ops structure to be used on static tracepoints with
13159 strace_marker_create_sals_from_location (struct event_location
*location
,
13160 struct linespec_result
*canonical
,
13161 enum bptype type_wanted
)
13163 struct linespec_sals lsal
;
13164 const char *arg_start
, *arg
;
13166 arg
= arg_start
= get_linespec_location (location
)->spec_string
;
13167 lsal
.sals
= decode_static_tracepoint_spec (&arg
);
13169 std::string
str (arg_start
, arg
- arg_start
);
13170 const char *ptr
= str
.c_str ();
13171 canonical
->location
13172 = new_linespec_location (&ptr
, symbol_name_match_type::FULL
);
13175 = xstrdup (event_location_to_string (canonical
->location
.get ()));
13176 canonical
->lsals
.push_back (std::move (lsal
));
13180 strace_marker_create_breakpoints_sal (struct gdbarch
*gdbarch
,
13181 struct linespec_result
*canonical
,
13182 gdb::unique_xmalloc_ptr
<char> cond_string
,
13183 gdb::unique_xmalloc_ptr
<char> extra_string
,
13184 enum bptype type_wanted
,
13185 enum bpdisp disposition
,
13187 int task
, int ignore_count
,
13188 const struct breakpoint_ops
*ops
,
13189 int from_tty
, int enabled
,
13190 int internal
, unsigned flags
)
13192 const linespec_sals
&lsal
= canonical
->lsals
[0];
13194 /* If the user is creating a static tracepoint by marker id
13195 (strace -m MARKER_ID), then store the sals index, so that
13196 breakpoint_re_set can try to match up which of the newly
13197 found markers corresponds to this one, and, don't try to
13198 expand multiple locations for each sal, given than SALS
13199 already should contain all sals for MARKER_ID. */
13201 for (size_t i
= 0; i
< lsal
.sals
.size (); i
++)
13203 event_location_up location
13204 = copy_event_location (canonical
->location
.get ());
13206 std::unique_ptr
<tracepoint
> tp (new tracepoint ());
13207 init_breakpoint_sal (tp
.get (), gdbarch
, lsal
.sals
[i
],
13208 std::move (location
), NULL
,
13209 std::move (cond_string
),
13210 std::move (extra_string
),
13211 type_wanted
, disposition
,
13212 thread
, task
, ignore_count
, ops
,
13213 from_tty
, enabled
, internal
, flags
,
13214 canonical
->special_display
);
13215 /* Given that its possible to have multiple markers with
13216 the same string id, if the user is creating a static
13217 tracepoint by marker id ("strace -m MARKER_ID"), then
13218 store the sals index, so that breakpoint_re_set can
13219 try to match up which of the newly found markers
13220 corresponds to this one */
13221 tp
->static_trace_marker_id_idx
= i
;
13223 install_breakpoint (internal
, std::move (tp
), 0);
13227 static std::vector
<symtab_and_line
>
13228 strace_marker_decode_location (struct breakpoint
*b
,
13229 struct event_location
*location
,
13230 struct program_space
*search_pspace
)
13232 struct tracepoint
*tp
= (struct tracepoint
*) b
;
13233 const char *s
= get_linespec_location (location
)->spec_string
;
13235 std::vector
<symtab_and_line
> sals
= decode_static_tracepoint_spec (&s
);
13236 if (sals
.size () > tp
->static_trace_marker_id_idx
)
13238 sals
[0] = sals
[tp
->static_trace_marker_id_idx
];
13243 error (_("marker %s not found"), tp
->static_trace_marker_id
.c_str ());
13246 static struct breakpoint_ops strace_marker_breakpoint_ops
;
13249 strace_marker_p (struct breakpoint
*b
)
13251 return b
->ops
== &strace_marker_breakpoint_ops
;
13254 /* Delete a breakpoint and clean up all traces of it in the data
13258 delete_breakpoint (struct breakpoint
*bpt
)
13260 struct breakpoint
*b
;
13262 gdb_assert (bpt
!= NULL
);
13264 /* Has this bp already been deleted? This can happen because
13265 multiple lists can hold pointers to bp's. bpstat lists are
13268 One example of this happening is a watchpoint's scope bp. When
13269 the scope bp triggers, we notice that the watchpoint is out of
13270 scope, and delete it. We also delete its scope bp. But the
13271 scope bp is marked "auto-deleting", and is already on a bpstat.
13272 That bpstat is then checked for auto-deleting bp's, which are
13275 A real solution to this problem might involve reference counts in
13276 bp's, and/or giving them pointers back to their referencing
13277 bpstat's, and teaching delete_breakpoint to only free a bp's
13278 storage when no more references were extent. A cheaper bandaid
13280 if (bpt
->type
== bp_none
)
13283 /* At least avoid this stale reference until the reference counting
13284 of breakpoints gets resolved. */
13285 if (bpt
->related_breakpoint
!= bpt
)
13287 struct breakpoint
*related
;
13288 struct watchpoint
*w
;
13290 if (bpt
->type
== bp_watchpoint_scope
)
13291 w
= (struct watchpoint
*) bpt
->related_breakpoint
;
13292 else if (bpt
->related_breakpoint
->type
== bp_watchpoint_scope
)
13293 w
= (struct watchpoint
*) bpt
;
13297 watchpoint_del_at_next_stop (w
);
13299 /* Unlink bpt from the bpt->related_breakpoint ring. */
13300 for (related
= bpt
; related
->related_breakpoint
!= bpt
;
13301 related
= related
->related_breakpoint
);
13302 related
->related_breakpoint
= bpt
->related_breakpoint
;
13303 bpt
->related_breakpoint
= bpt
;
13306 /* watch_command_1 creates a watchpoint but only sets its number if
13307 update_watchpoint succeeds in creating its bp_locations. If there's
13308 a problem in that process, we'll be asked to delete the half-created
13309 watchpoint. In that case, don't announce the deletion. */
13311 gdb::observers::breakpoint_deleted
.notify (bpt
);
13313 if (breakpoint_chain
== bpt
)
13314 breakpoint_chain
= bpt
->next
;
13316 ALL_BREAKPOINTS (b
)
13317 if (b
->next
== bpt
)
13319 b
->next
= bpt
->next
;
13323 /* Be sure no bpstat's are pointing at the breakpoint after it's
13325 /* FIXME, how can we find all bpstat's? We just check stop_bpstat
13326 in all threads for now. Note that we cannot just remove bpstats
13327 pointing at bpt from the stop_bpstat list entirely, as breakpoint
13328 commands are associated with the bpstat; if we remove it here,
13329 then the later call to bpstat_do_actions (&stop_bpstat); in
13330 event-top.c won't do anything, and temporary breakpoints with
13331 commands won't work. */
13333 iterate_over_threads (bpstat_remove_breakpoint_callback
, bpt
);
13335 /* Now that breakpoint is removed from breakpoint list, update the
13336 global location list. This will remove locations that used to
13337 belong to this breakpoint. Do this before freeing the breakpoint
13338 itself, since remove_breakpoint looks at location's owner. It
13339 might be better design to have location completely
13340 self-contained, but it's not the case now. */
13341 update_global_location_list (UGLL_DONT_INSERT
);
13343 /* On the chance that someone will soon try again to delete this
13344 same bp, we mark it as deleted before freeing its storage. */
13345 bpt
->type
= bp_none
;
13349 /* Iterator function to call a user-provided callback function once
13350 for each of B and its related breakpoints. */
13353 iterate_over_related_breakpoints (struct breakpoint
*b
,
13354 gdb::function_view
<void (breakpoint
*)> function
)
13356 struct breakpoint
*related
;
13361 struct breakpoint
*next
;
13363 /* FUNCTION may delete RELATED. */
13364 next
= related
->related_breakpoint
;
13366 if (next
== related
)
13368 /* RELATED is the last ring entry. */
13369 function (related
);
13371 /* FUNCTION may have deleted it, so we'd never reach back to
13372 B. There's nothing left to do anyway, so just break
13377 function (related
);
13381 while (related
!= b
);
13385 delete_command (const char *arg
, int from_tty
)
13387 struct breakpoint
*b
, *b_tmp
;
13393 int breaks_to_delete
= 0;
13395 /* Delete all breakpoints if no argument. Do not delete
13396 internal breakpoints, these have to be deleted with an
13397 explicit breakpoint number argument. */
13398 ALL_BREAKPOINTS (b
)
13399 if (user_breakpoint_p (b
))
13401 breaks_to_delete
= 1;
13405 /* Ask user only if there are some breakpoints to delete. */
13407 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
13409 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
13410 if (user_breakpoint_p (b
))
13411 delete_breakpoint (b
);
13415 map_breakpoint_numbers
13416 (arg
, [&] (breakpoint
*br
)
13418 iterate_over_related_breakpoints (br
, delete_breakpoint
);
13422 /* Return true if all locations of B bound to PSPACE are pending. If
13423 PSPACE is NULL, all locations of all program spaces are
13427 all_locations_are_pending (struct breakpoint
*b
, struct program_space
*pspace
)
13429 struct bp_location
*loc
;
13431 for (loc
= b
->loc
; loc
!= NULL
; loc
= loc
->next
)
13432 if ((pspace
== NULL
13433 || loc
->pspace
== pspace
)
13434 && !loc
->shlib_disabled
13435 && !loc
->pspace
->executing_startup
)
13440 /* Subroutine of update_breakpoint_locations to simplify it.
13441 Return non-zero if multiple fns in list LOC have the same name.
13442 Null names are ignored. */
13445 ambiguous_names_p (struct bp_location
*loc
)
13447 struct bp_location
*l
;
13448 htab_up
htab (htab_create_alloc (13, htab_hash_string
, streq_hash
, NULL
,
13451 for (l
= loc
; l
!= NULL
; l
= l
->next
)
13454 const char *name
= l
->function_name
;
13456 /* Allow for some names to be NULL, ignore them. */
13460 slot
= (const char **) htab_find_slot (htab
.get (), (const void *) name
,
13462 /* NOTE: We can assume slot != NULL here because xcalloc never
13472 /* When symbols change, it probably means the sources changed as well,
13473 and it might mean the static tracepoint markers are no longer at
13474 the same address or line numbers they used to be at last we
13475 checked. Losing your static tracepoints whenever you rebuild is
13476 undesirable. This function tries to resync/rematch gdb static
13477 tracepoints with the markers on the target, for static tracepoints
13478 that have not been set by marker id. Static tracepoint that have
13479 been set by marker id are reset by marker id in breakpoint_re_set.
13482 1) For a tracepoint set at a specific address, look for a marker at
13483 the old PC. If one is found there, assume to be the same marker.
13484 If the name / string id of the marker found is different from the
13485 previous known name, assume that means the user renamed the marker
13486 in the sources, and output a warning.
13488 2) For a tracepoint set at a given line number, look for a marker
13489 at the new address of the old line number. If one is found there,
13490 assume to be the same marker. If the name / string id of the
13491 marker found is different from the previous known name, assume that
13492 means the user renamed the marker in the sources, and output a
13495 3) If a marker is no longer found at the same address or line, it
13496 may mean the marker no longer exists. But it may also just mean
13497 the code changed a bit. Maybe the user added a few lines of code
13498 that made the marker move up or down (in line number terms). Ask
13499 the target for info about the marker with the string id as we knew
13500 it. If found, update line number and address in the matching
13501 static tracepoint. This will get confused if there's more than one
13502 marker with the same ID (possible in UST, although unadvised
13503 precisely because it confuses tools). */
13505 static struct symtab_and_line
13506 update_static_tracepoint (struct breakpoint
*b
, struct symtab_and_line sal
)
13508 struct tracepoint
*tp
= (struct tracepoint
*) b
;
13509 struct static_tracepoint_marker marker
;
13514 find_line_pc (sal
.symtab
, sal
.line
, &pc
);
13516 if (target_static_tracepoint_marker_at (pc
, &marker
))
13518 if (tp
->static_trace_marker_id
!= marker
.str_id
)
13519 warning (_("static tracepoint %d changed probed marker from %s to %s"),
13520 b
->number
, tp
->static_trace_marker_id
.c_str (),
13521 marker
.str_id
.c_str ());
13523 tp
->static_trace_marker_id
= std::move (marker
.str_id
);
13528 /* Old marker wasn't found on target at lineno. Try looking it up
13530 if (!sal
.explicit_pc
13532 && sal
.symtab
!= NULL
13533 && !tp
->static_trace_marker_id
.empty ())
13535 std::vector
<static_tracepoint_marker
> markers
13536 = target_static_tracepoint_markers_by_strid
13537 (tp
->static_trace_marker_id
.c_str ());
13539 if (!markers
.empty ())
13541 struct symbol
*sym
;
13542 struct static_tracepoint_marker
*tpmarker
;
13543 struct ui_out
*uiout
= current_uiout
;
13544 struct explicit_location explicit_loc
;
13546 tpmarker
= &markers
[0];
13548 tp
->static_trace_marker_id
= std::move (tpmarker
->str_id
);
13550 warning (_("marker for static tracepoint %d (%s) not "
13551 "found at previous line number"),
13552 b
->number
, tp
->static_trace_marker_id
.c_str ());
13554 symtab_and_line sal2
= find_pc_line (tpmarker
->address
, 0);
13555 sym
= find_pc_sect_function (tpmarker
->address
, NULL
);
13556 uiout
->text ("Now in ");
13559 uiout
->field_string ("func", sym
->print_name (),
13560 function_name_style
.style ());
13561 uiout
->text (" at ");
13563 uiout
->field_string ("file",
13564 symtab_to_filename_for_display (sal2
.symtab
),
13565 file_name_style
.style ());
13568 if (uiout
->is_mi_like_p ())
13570 const char *fullname
= symtab_to_fullname (sal2
.symtab
);
13572 uiout
->field_string ("fullname", fullname
);
13575 uiout
->field_signed ("line", sal2
.line
);
13576 uiout
->text ("\n");
13578 b
->loc
->line_number
= sal2
.line
;
13579 b
->loc
->symtab
= sym
!= NULL
? sal2
.symtab
: NULL
;
13581 b
->location
.reset (NULL
);
13582 initialize_explicit_location (&explicit_loc
);
13583 explicit_loc
.source_filename
13584 = ASTRDUP (symtab_to_filename_for_display (sal2
.symtab
));
13585 explicit_loc
.line_offset
.offset
= b
->loc
->line_number
;
13586 explicit_loc
.line_offset
.sign
= LINE_OFFSET_NONE
;
13587 b
->location
= new_explicit_location (&explicit_loc
);
13589 /* Might be nice to check if function changed, and warn if
13596 /* Returns 1 iff locations A and B are sufficiently same that
13597 we don't need to report breakpoint as changed. */
13600 locations_are_equal (struct bp_location
*a
, struct bp_location
*b
)
13604 if (a
->address
!= b
->address
)
13607 if (a
->shlib_disabled
!= b
->shlib_disabled
)
13610 if (a
->enabled
!= b
->enabled
)
13613 if (a
->disabled_by_cond
!= b
->disabled_by_cond
)
13620 if ((a
== NULL
) != (b
== NULL
))
13626 /* Split all locations of B that are bound to PSPACE out of B's
13627 location list to a separate list and return that list's head. If
13628 PSPACE is NULL, hoist out all locations of B. */
13630 static struct bp_location
*
13631 hoist_existing_locations (struct breakpoint
*b
, struct program_space
*pspace
)
13633 struct bp_location head
;
13634 struct bp_location
*i
= b
->loc
;
13635 struct bp_location
**i_link
= &b
->loc
;
13636 struct bp_location
*hoisted
= &head
;
13638 if (pspace
== NULL
)
13649 if (i
->pspace
== pspace
)
13664 /* Create new breakpoint locations for B (a hardware or software
13665 breakpoint) based on SALS and SALS_END. If SALS_END.NELTS is not
13666 zero, then B is a ranged breakpoint. Only recreates locations for
13667 FILTER_PSPACE. Locations of other program spaces are left
13671 update_breakpoint_locations (struct breakpoint
*b
,
13672 struct program_space
*filter_pspace
,
13673 gdb::array_view
<const symtab_and_line
> sals
,
13674 gdb::array_view
<const symtab_and_line
> sals_end
)
13676 struct bp_location
*existing_locations
;
13678 if (!sals_end
.empty () && (sals
.size () != 1 || sals_end
.size () != 1))
13680 /* Ranged breakpoints have only one start location and one end
13682 b
->enable_state
= bp_disabled
;
13683 printf_unfiltered (_("Could not reset ranged breakpoint %d: "
13684 "multiple locations found\n"),
13689 /* If there's no new locations, and all existing locations are
13690 pending, don't do anything. This optimizes the common case where
13691 all locations are in the same shared library, that was unloaded.
13692 We'd like to retain the location, so that when the library is
13693 loaded again, we don't loose the enabled/disabled status of the
13694 individual locations. */
13695 if (all_locations_are_pending (b
, filter_pspace
) && sals
.empty ())
13698 existing_locations
= hoist_existing_locations (b
, filter_pspace
);
13700 for (const auto &sal
: sals
)
13702 struct bp_location
*new_loc
;
13704 switch_to_program_space_and_thread (sal
.pspace
);
13706 new_loc
= add_location_to_breakpoint (b
, &sal
);
13708 /* Reparse conditions, they might contain references to the
13710 if (b
->cond_string
!= NULL
)
13714 s
= b
->cond_string
;
13717 new_loc
->cond
= parse_exp_1 (&s
, sal
.pc
,
13718 block_for_pc (sal
.pc
),
13721 catch (const gdb_exception_error
&e
)
13723 new_loc
->disabled_by_cond
= true;
13727 if (!sals_end
.empty ())
13729 CORE_ADDR end
= find_breakpoint_range_end (sals_end
[0]);
13731 new_loc
->length
= end
- sals
[0].pc
+ 1;
13735 /* If possible, carry over 'disable' status from existing
13738 struct bp_location
*e
= existing_locations
;
13739 /* If there are multiple breakpoints with the same function name,
13740 e.g. for inline functions, comparing function names won't work.
13741 Instead compare pc addresses; this is just a heuristic as things
13742 may have moved, but in practice it gives the correct answer
13743 often enough until a better solution is found. */
13744 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
13746 for (; e
; e
= e
->next
)
13748 if ((!e
->enabled
|| e
->disabled_by_cond
) && e
->function_name
)
13750 struct bp_location
*l
= b
->loc
;
13751 if (have_ambiguous_names
)
13753 for (; l
; l
= l
->next
)
13755 /* Ignore software vs hardware location type at
13756 this point, because with "set breakpoint
13757 auto-hw", after a re-set, locations that were
13758 hardware can end up as software, or vice versa.
13759 As mentioned above, this is an heuristic and in
13760 practice should give the correct answer often
13762 if (breakpoint_locations_match (e
, l
, true))
13764 l
->enabled
= e
->enabled
;
13765 l
->disabled_by_cond
= e
->disabled_by_cond
;
13772 for (; l
; l
= l
->next
)
13773 if (l
->function_name
13774 && strcmp (e
->function_name
, l
->function_name
) == 0)
13776 l
->enabled
= e
->enabled
;
13777 l
->disabled_by_cond
= e
->disabled_by_cond
;
13785 if (!locations_are_equal (existing_locations
, b
->loc
))
13786 gdb::observers::breakpoint_modified
.notify (b
);
13789 /* Find the SaL locations corresponding to the given LOCATION.
13790 On return, FOUND will be 1 if any SaL was found, zero otherwise. */
13792 static std::vector
<symtab_and_line
>
13793 location_to_sals (struct breakpoint
*b
, struct event_location
*location
,
13794 struct program_space
*search_pspace
, int *found
)
13796 struct gdb_exception exception
;
13798 gdb_assert (b
->ops
!= NULL
);
13800 std::vector
<symtab_and_line
> sals
;
13804 sals
= b
->ops
->decode_location (b
, location
, search_pspace
);
13806 catch (gdb_exception_error
&e
)
13808 int not_found_and_ok
= 0;
13810 /* For pending breakpoints, it's expected that parsing will
13811 fail until the right shared library is loaded. User has
13812 already told to create pending breakpoints and don't need
13813 extra messages. If breakpoint is in bp_shlib_disabled
13814 state, then user already saw the message about that
13815 breakpoint being disabled, and don't want to see more
13817 if (e
.error
== NOT_FOUND_ERROR
13818 && (b
->condition_not_parsed
13820 && search_pspace
!= NULL
13821 && b
->loc
->pspace
!= search_pspace
)
13822 || (b
->loc
&& b
->loc
->shlib_disabled
)
13823 || (b
->loc
&& b
->loc
->pspace
->executing_startup
)
13824 || b
->enable_state
== bp_disabled
))
13825 not_found_and_ok
= 1;
13827 if (!not_found_and_ok
)
13829 /* We surely don't want to warn about the same breakpoint
13830 10 times. One solution, implemented here, is disable
13831 the breakpoint on error. Another solution would be to
13832 have separate 'warning emitted' flag. Since this
13833 happens only when a binary has changed, I don't know
13834 which approach is better. */
13835 b
->enable_state
= bp_disabled
;
13839 exception
= std::move (e
);
13842 if (exception
.reason
== 0 || exception
.error
!= NOT_FOUND_ERROR
)
13844 for (auto &sal
: sals
)
13845 resolve_sal_pc (&sal
);
13846 if (b
->condition_not_parsed
&& b
->extra_string
!= NULL
)
13848 char *cond_string
, *extra_string
;
13851 find_condition_and_thread_for_sals (sals
, b
->extra_string
,
13852 &cond_string
, &thread
,
13853 &task
, &extra_string
);
13854 gdb_assert (b
->cond_string
== NULL
);
13856 b
->cond_string
= cond_string
;
13857 b
->thread
= thread
;
13861 xfree (b
->extra_string
);
13862 b
->extra_string
= extra_string
;
13864 b
->condition_not_parsed
= 0;
13867 if (b
->type
== bp_static_tracepoint
&& !strace_marker_p (b
))
13868 sals
[0] = update_static_tracepoint (b
, sals
[0]);
13878 /* The default re_set method, for typical hardware or software
13879 breakpoints. Reevaluate the breakpoint and recreate its
13883 breakpoint_re_set_default (struct breakpoint
*b
)
13885 struct program_space
*filter_pspace
= current_program_space
;
13886 std::vector
<symtab_and_line
> expanded
, expanded_end
;
13889 std::vector
<symtab_and_line
> sals
= location_to_sals (b
, b
->location
.get (),
13890 filter_pspace
, &found
);
13892 expanded
= std::move (sals
);
13894 if (b
->location_range_end
!= NULL
)
13896 std::vector
<symtab_and_line
> sals_end
13897 = location_to_sals (b
, b
->location_range_end
.get (),
13898 filter_pspace
, &found
);
13900 expanded_end
= std::move (sals_end
);
13903 update_breakpoint_locations (b
, filter_pspace
, expanded
, expanded_end
);
13906 /* Default method for creating SALs from an address string. It basically
13907 calls parse_breakpoint_sals. Return 1 for success, zero for failure. */
13910 create_sals_from_location_default (struct event_location
*location
,
13911 struct linespec_result
*canonical
,
13912 enum bptype type_wanted
)
13914 parse_breakpoint_sals (location
, canonical
);
13917 /* Call create_breakpoints_sal for the given arguments. This is the default
13918 function for the `create_breakpoints_sal' method of
13922 create_breakpoints_sal_default (struct gdbarch
*gdbarch
,
13923 struct linespec_result
*canonical
,
13924 gdb::unique_xmalloc_ptr
<char> cond_string
,
13925 gdb::unique_xmalloc_ptr
<char> extra_string
,
13926 enum bptype type_wanted
,
13927 enum bpdisp disposition
,
13929 int task
, int ignore_count
,
13930 const struct breakpoint_ops
*ops
,
13931 int from_tty
, int enabled
,
13932 int internal
, unsigned flags
)
13934 create_breakpoints_sal (gdbarch
, canonical
,
13935 std::move (cond_string
),
13936 std::move (extra_string
),
13937 type_wanted
, disposition
,
13938 thread
, task
, ignore_count
, ops
, from_tty
,
13939 enabled
, internal
, flags
);
13942 /* Decode the line represented by S by calling decode_line_full. This is the
13943 default function for the `decode_location' method of breakpoint_ops. */
13945 static std::vector
<symtab_and_line
>
13946 decode_location_default (struct breakpoint
*b
,
13947 struct event_location
*location
,
13948 struct program_space
*search_pspace
)
13950 struct linespec_result canonical
;
13952 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, search_pspace
,
13953 NULL
, 0, &canonical
, multiple_symbols_all
,
13956 /* We should get 0 or 1 resulting SALs. */
13957 gdb_assert (canonical
.lsals
.size () < 2);
13959 if (!canonical
.lsals
.empty ())
13961 const linespec_sals
&lsal
= canonical
.lsals
[0];
13962 return std::move (lsal
.sals
);
13967 /* Reset a breakpoint. */
13970 breakpoint_re_set_one (breakpoint
*b
)
13972 input_radix
= b
->input_radix
;
13973 set_language (b
->language
);
13975 b
->ops
->re_set (b
);
13978 /* Re-set breakpoint locations for the current program space.
13979 Locations bound to other program spaces are left untouched. */
13982 breakpoint_re_set (void)
13984 struct breakpoint
*b
, *b_tmp
;
13987 scoped_restore_current_language save_language
;
13988 scoped_restore save_input_radix
= make_scoped_restore (&input_radix
);
13989 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
13991 /* breakpoint_re_set_one sets the current_language to the language
13992 of the breakpoint it is resetting (see prepare_re_set_context)
13993 before re-evaluating the breakpoint's location. This change can
13994 unfortunately get undone by accident if the language_mode is set
13995 to auto, and we either switch frames, or more likely in this context,
13996 we select the current frame.
13998 We prevent this by temporarily turning the language_mode to
13999 language_mode_manual. We restore it once all breakpoints
14000 have been reset. */
14001 scoped_restore save_language_mode
= make_scoped_restore (&language_mode
);
14002 language_mode
= language_mode_manual
;
14004 /* Note: we must not try to insert locations until after all
14005 breakpoints have been re-set. Otherwise, e.g., when re-setting
14006 breakpoint 1, we'd insert the locations of breakpoint 2, which
14007 hadn't been re-set yet, and thus may have stale locations. */
14009 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
14013 breakpoint_re_set_one (b
);
14015 catch (const gdb_exception
&ex
)
14017 exception_fprintf (gdb_stderr
, ex
,
14018 "Error in re-setting breakpoint %d: ",
14023 jit_breakpoint_re_set ();
14026 create_overlay_event_breakpoint ();
14027 create_longjmp_master_breakpoint ();
14028 create_std_terminate_master_breakpoint ();
14029 create_exception_master_breakpoint ();
14031 /* Now we can insert. */
14032 update_global_location_list (UGLL_MAY_INSERT
);
14035 /* Reset the thread number of this breakpoint:
14037 - If the breakpoint is for all threads, leave it as-is.
14038 - Else, reset it to the current thread for inferior_ptid. */
14040 breakpoint_re_set_thread (struct breakpoint
*b
)
14042 if (b
->thread
!= -1)
14044 b
->thread
= inferior_thread ()->global_num
;
14046 /* We're being called after following a fork. The new fork is
14047 selected as current, and unless this was a vfork will have a
14048 different program space from the original thread. Reset that
14050 b
->loc
->pspace
= current_program_space
;
14054 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14055 If from_tty is nonzero, it prints a message to that effect,
14056 which ends with a period (no newline). */
14059 set_ignore_count (int bptnum
, int count
, int from_tty
)
14061 struct breakpoint
*b
;
14066 ALL_BREAKPOINTS (b
)
14067 if (b
->number
== bptnum
)
14069 if (is_tracepoint (b
))
14071 if (from_tty
&& count
!= 0)
14072 printf_filtered (_("Ignore count ignored for tracepoint %d."),
14077 b
->ignore_count
= count
;
14081 printf_filtered (_("Will stop next time "
14082 "breakpoint %d is reached."),
14084 else if (count
== 1)
14085 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
14088 printf_filtered (_("Will ignore next %d "
14089 "crossings of breakpoint %d."),
14092 gdb::observers::breakpoint_modified
.notify (b
);
14096 error (_("No breakpoint number %d."), bptnum
);
14099 /* Command to set ignore-count of breakpoint N to COUNT. */
14102 ignore_command (const char *args
, int from_tty
)
14104 const char *p
= args
;
14108 error_no_arg (_("a breakpoint number"));
14110 num
= get_number (&p
);
14112 error (_("bad breakpoint number: '%s'"), args
);
14114 error (_("Second argument (specified ignore-count) is missing."));
14116 set_ignore_count (num
,
14117 longest_to_int (value_as_long (parse_and_eval (p
))),
14120 printf_filtered ("\n");
14124 /* Call FUNCTION on each of the breakpoints with numbers in the range
14125 defined by BP_NUM_RANGE (an inclusive range). */
14128 map_breakpoint_number_range (std::pair
<int, int> bp_num_range
,
14129 gdb::function_view
<void (breakpoint
*)> function
)
14131 if (bp_num_range
.first
== 0)
14133 warning (_("bad breakpoint number at or near '%d'"),
14134 bp_num_range
.first
);
14138 struct breakpoint
*b
, *tmp
;
14140 for (int i
= bp_num_range
.first
; i
<= bp_num_range
.second
; i
++)
14142 bool match
= false;
14144 ALL_BREAKPOINTS_SAFE (b
, tmp
)
14145 if (b
->number
== i
)
14152 printf_unfiltered (_("No breakpoint number %d.\n"), i
);
14157 /* Call FUNCTION on each of the breakpoints whose numbers are given in
14161 map_breakpoint_numbers (const char *args
,
14162 gdb::function_view
<void (breakpoint
*)> function
)
14164 if (args
== NULL
|| *args
== '\0')
14165 error_no_arg (_("one or more breakpoint numbers"));
14167 number_or_range_parser
parser (args
);
14169 while (!parser
.finished ())
14171 int num
= parser
.get_number ();
14172 map_breakpoint_number_range (std::make_pair (num
, num
), function
);
14176 /* Return the breakpoint location structure corresponding to the
14177 BP_NUM and LOC_NUM values. */
14179 static struct bp_location
*
14180 find_location_by_number (int bp_num
, int loc_num
)
14182 struct breakpoint
*b
;
14184 ALL_BREAKPOINTS (b
)
14185 if (b
->number
== bp_num
)
14190 if (!b
|| b
->number
!= bp_num
)
14191 error (_("Bad breakpoint number '%d'"), bp_num
);
14194 error (_("Bad breakpoint location number '%d'"), loc_num
);
14197 for (bp_location
*loc
= b
->loc
; loc
!= NULL
; loc
= loc
->next
)
14198 if (++n
== loc_num
)
14201 error (_("Bad breakpoint location number '%d'"), loc_num
);
14204 /* Modes of operation for extract_bp_num. */
14205 enum class extract_bp_kind
14207 /* Extracting a breakpoint number. */
14210 /* Extracting a location number. */
14214 /* Extract a breakpoint or location number (as determined by KIND)
14215 from the string starting at START. TRAILER is a character which
14216 can be found after the number. If you don't want a trailer, use
14217 '\0'. If END_OUT is not NULL, it is set to point after the parsed
14218 string. This always returns a positive integer. */
14221 extract_bp_num (extract_bp_kind kind
, const char *start
,
14222 int trailer
, const char **end_out
= NULL
)
14224 const char *end
= start
;
14225 int num
= get_number_trailer (&end
, trailer
);
14227 error (kind
== extract_bp_kind::bp
14228 ? _("Negative breakpoint number '%.*s'")
14229 : _("Negative breakpoint location number '%.*s'"),
14230 int (end
- start
), start
);
14232 error (kind
== extract_bp_kind::bp
14233 ? _("Bad breakpoint number '%.*s'")
14234 : _("Bad breakpoint location number '%.*s'"),
14235 int (end
- start
), start
);
14237 if (end_out
!= NULL
)
14242 /* Extract a breakpoint or location range (as determined by KIND) in
14243 the form NUM1-NUM2 stored at &ARG[arg_offset]. Returns a std::pair
14244 representing the (inclusive) range. The returned pair's elements
14245 are always positive integers. */
14247 static std::pair
<int, int>
14248 extract_bp_or_bp_range (extract_bp_kind kind
,
14249 const std::string
&arg
,
14250 std::string::size_type arg_offset
)
14252 std::pair
<int, int> range
;
14253 const char *bp_loc
= &arg
[arg_offset
];
14254 std::string::size_type dash
= arg
.find ('-', arg_offset
);
14255 if (dash
!= std::string::npos
)
14257 /* bp_loc is a range (x-z). */
14258 if (arg
.length () == dash
+ 1)
14259 error (kind
== extract_bp_kind::bp
14260 ? _("Bad breakpoint number at or near: '%s'")
14261 : _("Bad breakpoint location number at or near: '%s'"),
14265 const char *start_first
= bp_loc
;
14266 const char *start_second
= &arg
[dash
+ 1];
14267 range
.first
= extract_bp_num (kind
, start_first
, '-');
14268 range
.second
= extract_bp_num (kind
, start_second
, '\0', &end
);
14270 if (range
.first
> range
.second
)
14271 error (kind
== extract_bp_kind::bp
14272 ? _("Inverted breakpoint range at '%.*s'")
14273 : _("Inverted breakpoint location range at '%.*s'"),
14274 int (end
- start_first
), start_first
);
14278 /* bp_loc is a single value. */
14279 range
.first
= extract_bp_num (kind
, bp_loc
, '\0');
14280 range
.second
= range
.first
;
14285 /* Extract the breakpoint/location range specified by ARG. Returns
14286 the breakpoint range in BP_NUM_RANGE, and the location range in
14289 ARG may be in any of the following forms:
14291 x where 'x' is a breakpoint number.
14292 x-y where 'x' and 'y' specify a breakpoint numbers range.
14293 x.y where 'x' is a breakpoint number and 'y' a location number.
14294 x.y-z where 'x' is a breakpoint number and 'y' and 'z' specify a
14295 location number range.
14299 extract_bp_number_and_location (const std::string
&arg
,
14300 std::pair
<int, int> &bp_num_range
,
14301 std::pair
<int, int> &bp_loc_range
)
14303 std::string::size_type dot
= arg
.find ('.');
14305 if (dot
!= std::string::npos
)
14307 /* Handle 'x.y' and 'x.y-z' cases. */
14309 if (arg
.length () == dot
+ 1 || dot
== 0)
14310 error (_("Bad breakpoint number at or near: '%s'"), arg
.c_str ());
14313 = extract_bp_num (extract_bp_kind::bp
, arg
.c_str (), '.');
14314 bp_num_range
.second
= bp_num_range
.first
;
14316 bp_loc_range
= extract_bp_or_bp_range (extract_bp_kind::loc
,
14321 /* Handle x and x-y cases. */
14323 bp_num_range
= extract_bp_or_bp_range (extract_bp_kind::bp
, arg
, 0);
14324 bp_loc_range
.first
= 0;
14325 bp_loc_range
.second
= 0;
14329 /* Enable or disable a breakpoint location BP_NUM.LOC_NUM. ENABLE
14330 specifies whether to enable or disable. */
14333 enable_disable_bp_num_loc (int bp_num
, int loc_num
, bool enable
)
14335 struct bp_location
*loc
= find_location_by_number (bp_num
, loc_num
);
14338 if (loc
->disabled_by_cond
&& enable
)
14339 error (_("Breakpoint %d's condition is invalid at location %d, "
14340 "cannot enable."), bp_num
, loc_num
);
14342 if (loc
->enabled
!= enable
)
14344 loc
->enabled
= enable
;
14345 mark_breakpoint_location_modified (loc
);
14347 if (target_supports_enable_disable_tracepoint ()
14348 && current_trace_status ()->running
&& loc
->owner
14349 && is_tracepoint (loc
->owner
))
14350 target_disable_tracepoint (loc
);
14352 update_global_location_list (UGLL_DONT_INSERT
);
14354 gdb::observers::breakpoint_modified
.notify (loc
->owner
);
14357 /* Enable or disable a range of breakpoint locations. BP_NUM is the
14358 number of the breakpoint, and BP_LOC_RANGE specifies the
14359 (inclusive) range of location numbers of that breakpoint to
14360 enable/disable. ENABLE specifies whether to enable or disable the
14364 enable_disable_breakpoint_location_range (int bp_num
,
14365 std::pair
<int, int> &bp_loc_range
,
14368 for (int i
= bp_loc_range
.first
; i
<= bp_loc_range
.second
; i
++)
14369 enable_disable_bp_num_loc (bp_num
, i
, enable
);
14372 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14373 If from_tty is nonzero, it prints a message to that effect,
14374 which ends with a period (no newline). */
14377 disable_breakpoint (struct breakpoint
*bpt
)
14379 /* Never disable a watchpoint scope breakpoint; we want to
14380 hit them when we leave scope so we can delete both the
14381 watchpoint and its scope breakpoint at that time. */
14382 if (bpt
->type
== bp_watchpoint_scope
)
14385 bpt
->enable_state
= bp_disabled
;
14387 /* Mark breakpoint locations modified. */
14388 mark_breakpoint_modified (bpt
);
14390 if (target_supports_enable_disable_tracepoint ()
14391 && current_trace_status ()->running
&& is_tracepoint (bpt
))
14393 struct bp_location
*location
;
14395 for (location
= bpt
->loc
; location
; location
= location
->next
)
14396 target_disable_tracepoint (location
);
14399 update_global_location_list (UGLL_DONT_INSERT
);
14401 gdb::observers::breakpoint_modified
.notify (bpt
);
14404 /* Enable or disable the breakpoint(s) or breakpoint location(s)
14405 specified in ARGS. ARGS may be in any of the formats handled by
14406 extract_bp_number_and_location. ENABLE specifies whether to enable
14407 or disable the breakpoints/locations. */
14410 enable_disable_command (const char *args
, int from_tty
, bool enable
)
14414 struct breakpoint
*bpt
;
14416 ALL_BREAKPOINTS (bpt
)
14417 if (user_breakpoint_p (bpt
))
14420 enable_breakpoint (bpt
);
14422 disable_breakpoint (bpt
);
14427 std::string num
= extract_arg (&args
);
14429 while (!num
.empty ())
14431 std::pair
<int, int> bp_num_range
, bp_loc_range
;
14433 extract_bp_number_and_location (num
, bp_num_range
, bp_loc_range
);
14435 if (bp_loc_range
.first
== bp_loc_range
.second
14436 && bp_loc_range
.first
== 0)
14438 /* Handle breakpoint ids with formats 'x' or 'x-z'. */
14439 map_breakpoint_number_range (bp_num_range
,
14441 ? enable_breakpoint
14442 : disable_breakpoint
);
14446 /* Handle breakpoint ids with formats 'x.y' or
14448 enable_disable_breakpoint_location_range
14449 (bp_num_range
.first
, bp_loc_range
, enable
);
14451 num
= extract_arg (&args
);
14456 /* The disable command disables the specified breakpoints/locations
14457 (or all defined breakpoints) so they're no longer effective in
14458 stopping the inferior. ARGS may be in any of the forms defined in
14459 extract_bp_number_and_location. */
14462 disable_command (const char *args
, int from_tty
)
14464 enable_disable_command (args
, from_tty
, false);
14468 enable_breakpoint_disp (struct breakpoint
*bpt
, enum bpdisp disposition
,
14471 int target_resources_ok
;
14473 if (bpt
->type
== bp_hardware_breakpoint
)
14476 i
= hw_breakpoint_used_count ();
14477 target_resources_ok
=
14478 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
14480 if (target_resources_ok
== 0)
14481 error (_("No hardware breakpoint support in the target."));
14482 else if (target_resources_ok
< 0)
14483 error (_("Hardware breakpoints used exceeds limit."));
14486 if (is_watchpoint (bpt
))
14488 /* Initialize it just to avoid a GCC false warning. */
14489 enum enable_state orig_enable_state
= bp_disabled
;
14493 struct watchpoint
*w
= (struct watchpoint
*) bpt
;
14495 orig_enable_state
= bpt
->enable_state
;
14496 bpt
->enable_state
= bp_enabled
;
14497 update_watchpoint (w
, 1 /* reparse */);
14499 catch (const gdb_exception
&e
)
14501 bpt
->enable_state
= orig_enable_state
;
14502 exception_fprintf (gdb_stderr
, e
, _("Cannot enable watchpoint %d: "),
14508 bpt
->enable_state
= bp_enabled
;
14510 /* Mark breakpoint locations modified. */
14511 mark_breakpoint_modified (bpt
);
14513 if (target_supports_enable_disable_tracepoint ()
14514 && current_trace_status ()->running
&& is_tracepoint (bpt
))
14516 struct bp_location
*location
;
14518 for (location
= bpt
->loc
; location
; location
= location
->next
)
14519 target_enable_tracepoint (location
);
14522 bpt
->disposition
= disposition
;
14523 bpt
->enable_count
= count
;
14524 update_global_location_list (UGLL_MAY_INSERT
);
14526 gdb::observers::breakpoint_modified
.notify (bpt
);
14531 enable_breakpoint (struct breakpoint
*bpt
)
14533 enable_breakpoint_disp (bpt
, bpt
->disposition
, 0);
14536 /* The enable command enables the specified breakpoints/locations (or
14537 all defined breakpoints) so they once again become (or continue to
14538 be) effective in stopping the inferior. ARGS may be in any of the
14539 forms defined in extract_bp_number_and_location. */
14542 enable_command (const char *args
, int from_tty
)
14544 enable_disable_command (args
, from_tty
, true);
14548 enable_once_command (const char *args
, int from_tty
)
14550 map_breakpoint_numbers
14551 (args
, [&] (breakpoint
*b
)
14553 iterate_over_related_breakpoints
14554 (b
, [&] (breakpoint
*bpt
)
14556 enable_breakpoint_disp (bpt
, disp_disable
, 1);
14562 enable_count_command (const char *args
, int from_tty
)
14567 error_no_arg (_("hit count"));
14569 count
= get_number (&args
);
14571 map_breakpoint_numbers
14572 (args
, [&] (breakpoint
*b
)
14574 iterate_over_related_breakpoints
14575 (b
, [&] (breakpoint
*bpt
)
14577 enable_breakpoint_disp (bpt
, disp_disable
, count
);
14583 enable_delete_command (const char *args
, int from_tty
)
14585 map_breakpoint_numbers
14586 (args
, [&] (breakpoint
*b
)
14588 iterate_over_related_breakpoints
14589 (b
, [&] (breakpoint
*bpt
)
14591 enable_breakpoint_disp (bpt
, disp_del
, 1);
14596 /* Invalidate last known value of any hardware watchpoint if
14597 the memory which that value represents has been written to by
14601 invalidate_bp_value_on_memory_change (struct inferior
*inferior
,
14602 CORE_ADDR addr
, ssize_t len
,
14603 const bfd_byte
*data
)
14605 struct breakpoint
*bp
;
14607 ALL_BREAKPOINTS (bp
)
14608 if (bp
->enable_state
== bp_enabled
14609 && bp
->type
== bp_hardware_watchpoint
)
14611 struct watchpoint
*wp
= (struct watchpoint
*) bp
;
14613 if (wp
->val_valid
&& wp
->val
!= nullptr)
14615 struct bp_location
*loc
;
14617 for (loc
= bp
->loc
; loc
!= NULL
; loc
= loc
->next
)
14618 if (loc
->loc_type
== bp_loc_hardware_watchpoint
14619 && loc
->address
+ loc
->length
> addr
14620 && addr
+ len
> loc
->address
)
14623 wp
->val_valid
= false;
14629 /* Create and insert a breakpoint for software single step. */
14632 insert_single_step_breakpoint (struct gdbarch
*gdbarch
,
14633 const address_space
*aspace
,
14636 struct thread_info
*tp
= inferior_thread ();
14637 struct symtab_and_line sal
;
14638 CORE_ADDR pc
= next_pc
;
14640 if (tp
->control
.single_step_breakpoints
== NULL
)
14642 tp
->control
.single_step_breakpoints
14643 = new_single_step_breakpoint (tp
->global_num
, gdbarch
);
14646 sal
= find_pc_line (pc
, 0);
14648 sal
.section
= find_pc_overlay (pc
);
14649 sal
.explicit_pc
= 1;
14650 add_location_to_breakpoint (tp
->control
.single_step_breakpoints
, &sal
);
14652 update_global_location_list (UGLL_INSERT
);
14655 /* Insert single step breakpoints according to the current state. */
14658 insert_single_step_breakpoints (struct gdbarch
*gdbarch
)
14660 struct regcache
*regcache
= get_current_regcache ();
14661 std::vector
<CORE_ADDR
> next_pcs
;
14663 next_pcs
= gdbarch_software_single_step (gdbarch
, regcache
);
14665 if (!next_pcs
.empty ())
14667 struct frame_info
*frame
= get_current_frame ();
14668 const address_space
*aspace
= get_frame_address_space (frame
);
14670 for (CORE_ADDR pc
: next_pcs
)
14671 insert_single_step_breakpoint (gdbarch
, aspace
, pc
);
14679 /* See breakpoint.h. */
14682 breakpoint_has_location_inserted_here (struct breakpoint
*bp
,
14683 const address_space
*aspace
,
14686 struct bp_location
*loc
;
14688 for (loc
= bp
->loc
; loc
!= NULL
; loc
= loc
->next
)
14690 && breakpoint_location_address_match (loc
, aspace
, pc
))
14696 /* Check whether a software single-step breakpoint is inserted at
14700 single_step_breakpoint_inserted_here_p (const address_space
*aspace
,
14703 struct breakpoint
*bpt
;
14705 ALL_BREAKPOINTS (bpt
)
14707 if (bpt
->type
== bp_single_step
14708 && breakpoint_has_location_inserted_here (bpt
, aspace
, pc
))
14714 /* Tracepoint-specific operations. */
14716 /* Set tracepoint count to NUM. */
14718 set_tracepoint_count (int num
)
14720 tracepoint_count
= num
;
14721 set_internalvar_integer (lookup_internalvar ("tpnum"), num
);
14725 trace_command (const char *arg
, int from_tty
)
14727 event_location_up location
= string_to_event_location (&arg
,
14729 const struct breakpoint_ops
*ops
= breakpoint_ops_for_event_location
14730 (location
.get (), true /* is_tracepoint */);
14732 create_breakpoint (get_current_arch (),
14734 NULL
, 0, arg
, 1 /* parse arg */,
14736 bp_tracepoint
/* type_wanted */,
14737 0 /* Ignore count */,
14738 pending_break_support
,
14742 0 /* internal */, 0);
14746 ftrace_command (const char *arg
, int from_tty
)
14748 event_location_up location
= string_to_event_location (&arg
,
14750 create_breakpoint (get_current_arch (),
14752 NULL
, 0, arg
, 1 /* parse arg */,
14754 bp_fast_tracepoint
/* type_wanted */,
14755 0 /* Ignore count */,
14756 pending_break_support
,
14757 &tracepoint_breakpoint_ops
,
14760 0 /* internal */, 0);
14763 /* strace command implementation. Creates a static tracepoint. */
14766 strace_command (const char *arg
, int from_tty
)
14768 struct breakpoint_ops
*ops
;
14769 event_location_up location
;
14771 /* Decide if we are dealing with a static tracepoint marker (`-m'),
14772 or with a normal static tracepoint. */
14773 if (arg
&& startswith (arg
, "-m") && isspace (arg
[2]))
14775 ops
= &strace_marker_breakpoint_ops
;
14776 location
= new_linespec_location (&arg
, symbol_name_match_type::FULL
);
14780 ops
= &tracepoint_breakpoint_ops
;
14781 location
= string_to_event_location (&arg
, current_language
);
14784 create_breakpoint (get_current_arch (),
14786 NULL
, 0, arg
, 1 /* parse arg */,
14788 bp_static_tracepoint
/* type_wanted */,
14789 0 /* Ignore count */,
14790 pending_break_support
,
14794 0 /* internal */, 0);
14797 /* Set up a fake reader function that gets command lines from a linked
14798 list that was acquired during tracepoint uploading. */
14800 static struct uploaded_tp
*this_utp
;
14801 static int next_cmd
;
14804 read_uploaded_action (void)
14806 char *rslt
= nullptr;
14808 if (next_cmd
< this_utp
->cmd_strings
.size ())
14810 rslt
= this_utp
->cmd_strings
[next_cmd
].get ();
14817 /* Given information about a tracepoint as recorded on a target (which
14818 can be either a live system or a trace file), attempt to create an
14819 equivalent GDB tracepoint. This is not a reliable process, since
14820 the target does not necessarily have all the information used when
14821 the tracepoint was originally defined. */
14823 struct tracepoint
*
14824 create_tracepoint_from_upload (struct uploaded_tp
*utp
)
14826 const char *addr_str
;
14827 char small_buf
[100];
14828 struct tracepoint
*tp
;
14830 if (utp
->at_string
)
14831 addr_str
= utp
->at_string
.get ();
14834 /* In the absence of a source location, fall back to raw
14835 address. Since there is no way to confirm that the address
14836 means the same thing as when the trace was started, warn the
14838 warning (_("Uploaded tracepoint %d has no "
14839 "source location, using raw address"),
14841 xsnprintf (small_buf
, sizeof (small_buf
), "*%s", hex_string (utp
->addr
));
14842 addr_str
= small_buf
;
14845 /* There's not much we can do with a sequence of bytecodes. */
14846 if (utp
->cond
&& !utp
->cond_string
)
14847 warning (_("Uploaded tracepoint %d condition "
14848 "has no source form, ignoring it"),
14851 event_location_up location
= string_to_event_location (&addr_str
,
14853 if (!create_breakpoint (get_current_arch (),
14855 utp
->cond_string
.get (), -1, addr_str
,
14856 0 /* parse cond/thread */,
14858 utp
->type
/* type_wanted */,
14859 0 /* Ignore count */,
14860 pending_break_support
,
14861 &tracepoint_breakpoint_ops
,
14863 utp
->enabled
/* enabled */,
14865 CREATE_BREAKPOINT_FLAGS_INSERTED
))
14868 /* Get the tracepoint we just created. */
14869 tp
= get_tracepoint (tracepoint_count
);
14870 gdb_assert (tp
!= NULL
);
14874 xsnprintf (small_buf
, sizeof (small_buf
), "%d %d", utp
->pass
,
14877 trace_pass_command (small_buf
, 0);
14880 /* If we have uploaded versions of the original commands, set up a
14881 special-purpose "reader" function and call the usual command line
14882 reader, then pass the result to the breakpoint command-setting
14884 if (!utp
->cmd_strings
.empty ())
14886 counted_command_line cmd_list
;
14891 cmd_list
= read_command_lines_1 (read_uploaded_action
, 1, NULL
);
14893 breakpoint_set_commands (tp
, std::move (cmd_list
));
14895 else if (!utp
->actions
.empty ()
14896 || !utp
->step_actions
.empty ())
14897 warning (_("Uploaded tracepoint %d actions "
14898 "have no source form, ignoring them"),
14901 /* Copy any status information that might be available. */
14902 tp
->hit_count
= utp
->hit_count
;
14903 tp
->traceframe_usage
= utp
->traceframe_usage
;
14908 /* Print information on tracepoint number TPNUM_EXP, or all if
14912 info_tracepoints_command (const char *args
, int from_tty
)
14914 struct ui_out
*uiout
= current_uiout
;
14917 num_printed
= breakpoint_1 (args
, false, is_tracepoint
);
14919 if (num_printed
== 0)
14921 if (args
== NULL
|| *args
== '\0')
14922 uiout
->message ("No tracepoints.\n");
14924 uiout
->message ("No tracepoint matching '%s'.\n", args
);
14927 default_collect_info ();
14930 /* The 'enable trace' command enables tracepoints.
14931 Not supported by all targets. */
14933 enable_trace_command (const char *args
, int from_tty
)
14935 enable_command (args
, from_tty
);
14938 /* The 'disable trace' command disables tracepoints.
14939 Not supported by all targets. */
14941 disable_trace_command (const char *args
, int from_tty
)
14943 disable_command (args
, from_tty
);
14946 /* Remove a tracepoint (or all if no argument). */
14948 delete_trace_command (const char *arg
, int from_tty
)
14950 struct breakpoint
*b
, *b_tmp
;
14956 int breaks_to_delete
= 0;
14958 /* Delete all breakpoints if no argument.
14959 Do not delete internal or call-dummy breakpoints, these
14960 have to be deleted with an explicit breakpoint number
14962 ALL_TRACEPOINTS (b
)
14963 if (is_tracepoint (b
) && user_breakpoint_p (b
))
14965 breaks_to_delete
= 1;
14969 /* Ask user only if there are some breakpoints to delete. */
14971 || (breaks_to_delete
&& query (_("Delete all tracepoints? "))))
14973 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
14974 if (is_tracepoint (b
) && user_breakpoint_p (b
))
14975 delete_breakpoint (b
);
14979 map_breakpoint_numbers
14980 (arg
, [&] (breakpoint
*br
)
14982 iterate_over_related_breakpoints (br
, delete_breakpoint
);
14986 /* Helper function for trace_pass_command. */
14989 trace_pass_set_count (struct tracepoint
*tp
, int count
, int from_tty
)
14991 tp
->pass_count
= count
;
14992 gdb::observers::breakpoint_modified
.notify (tp
);
14994 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
14995 tp
->number
, count
);
14998 /* Set passcount for tracepoint.
15000 First command argument is passcount, second is tracepoint number.
15001 If tracepoint number omitted, apply to most recently defined.
15002 Also accepts special argument "all". */
15005 trace_pass_command (const char *args
, int from_tty
)
15007 struct tracepoint
*t1
;
15010 if (args
== 0 || *args
== 0)
15011 error (_("passcount command requires an "
15012 "argument (count + optional TP num)"));
15014 count
= strtoulst (args
, &args
, 10); /* Count comes first, then TP num. */
15016 args
= skip_spaces (args
);
15017 if (*args
&& strncasecmp (args
, "all", 3) == 0)
15019 struct breakpoint
*b
;
15021 args
+= 3; /* Skip special argument "all". */
15023 error (_("Junk at end of arguments."));
15025 ALL_TRACEPOINTS (b
)
15027 t1
= (struct tracepoint
*) b
;
15028 trace_pass_set_count (t1
, count
, from_tty
);
15031 else if (*args
== '\0')
15033 t1
= get_tracepoint_by_number (&args
, NULL
);
15035 trace_pass_set_count (t1
, count
, from_tty
);
15039 number_or_range_parser
parser (args
);
15040 while (!parser
.finished ())
15042 t1
= get_tracepoint_by_number (&args
, &parser
);
15044 trace_pass_set_count (t1
, count
, from_tty
);
15049 struct tracepoint
*
15050 get_tracepoint (int num
)
15052 struct breakpoint
*t
;
15054 ALL_TRACEPOINTS (t
)
15055 if (t
->number
== num
)
15056 return (struct tracepoint
*) t
;
15061 /* Find the tracepoint with the given target-side number (which may be
15062 different from the tracepoint number after disconnecting and
15065 struct tracepoint
*
15066 get_tracepoint_by_number_on_target (int num
)
15068 struct breakpoint
*b
;
15070 ALL_TRACEPOINTS (b
)
15072 struct tracepoint
*t
= (struct tracepoint
*) b
;
15074 if (t
->number_on_target
== num
)
15081 /* Utility: parse a tracepoint number and look it up in the list.
15082 If STATE is not NULL, use, get_number_or_range_state and ignore ARG.
15083 If the argument is missing, the most recent tracepoint
15084 (tracepoint_count) is returned. */
15086 struct tracepoint
*
15087 get_tracepoint_by_number (const char **arg
,
15088 number_or_range_parser
*parser
)
15090 struct breakpoint
*t
;
15092 const char *instring
= arg
== NULL
? NULL
: *arg
;
15094 if (parser
!= NULL
)
15096 gdb_assert (!parser
->finished ());
15097 tpnum
= parser
->get_number ();
15099 else if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
15100 tpnum
= tracepoint_count
;
15102 tpnum
= get_number (arg
);
15106 if (instring
&& *instring
)
15107 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
15110 printf_filtered (_("No previous tracepoint\n"));
15114 ALL_TRACEPOINTS (t
)
15115 if (t
->number
== tpnum
)
15117 return (struct tracepoint
*) t
;
15120 printf_unfiltered ("No tracepoint number %d.\n", tpnum
);
15125 print_recreate_thread (struct breakpoint
*b
, struct ui_file
*fp
)
15127 if (b
->thread
!= -1)
15128 fprintf_unfiltered (fp
, " thread %d", b
->thread
);
15131 fprintf_unfiltered (fp
, " task %d", b
->task
);
15133 fprintf_unfiltered (fp
, "\n");
15136 /* Save information on user settable breakpoints (watchpoints, etc) to
15137 a new script file named FILENAME. If FILTER is non-NULL, call it
15138 on each breakpoint and only include the ones for which it returns
15142 save_breakpoints (const char *filename
, int from_tty
,
15143 bool (*filter
) (const struct breakpoint
*))
15145 struct breakpoint
*tp
;
15147 int extra_trace_bits
= 0;
15149 if (filename
== 0 || *filename
== 0)
15150 error (_("Argument required (file name in which to save)"));
15152 /* See if we have anything to save. */
15153 ALL_BREAKPOINTS (tp
)
15155 /* Skip internal and momentary breakpoints. */
15156 if (!user_breakpoint_p (tp
))
15159 /* If we have a filter, only save the breakpoints it accepts. */
15160 if (filter
&& !filter (tp
))
15165 if (is_tracepoint (tp
))
15167 extra_trace_bits
= 1;
15169 /* We can stop searching. */
15176 warning (_("Nothing to save."));
15180 gdb::unique_xmalloc_ptr
<char> expanded_filename (tilde_expand (filename
));
15184 if (!fp
.open (expanded_filename
.get (), "w"))
15185 error (_("Unable to open file '%s' for saving (%s)"),
15186 expanded_filename
.get (), safe_strerror (errno
));
15188 if (extra_trace_bits
)
15189 save_trace_state_variables (&fp
);
15191 ALL_BREAKPOINTS (tp
)
15193 /* Skip internal and momentary breakpoints. */
15194 if (!user_breakpoint_p (tp
))
15197 /* If we have a filter, only save the breakpoints it accepts. */
15198 if (filter
&& !filter (tp
))
15201 tp
->ops
->print_recreate (tp
, &fp
);
15203 /* Note, we can't rely on tp->number for anything, as we can't
15204 assume the recreated breakpoint numbers will match. Use $bpnum
15207 if (tp
->cond_string
)
15208 fp
.printf (" condition $bpnum %s\n", tp
->cond_string
);
15210 if (tp
->ignore_count
)
15211 fp
.printf (" ignore $bpnum %d\n", tp
->ignore_count
);
15213 if (tp
->type
!= bp_dprintf
&& tp
->commands
)
15215 fp
.puts (" commands\n");
15217 current_uiout
->redirect (&fp
);
15220 print_command_lines (current_uiout
, tp
->commands
.get (), 2);
15222 catch (const gdb_exception
&ex
)
15224 current_uiout
->redirect (NULL
);
15228 current_uiout
->redirect (NULL
);
15229 fp
.puts (" end\n");
15232 if (tp
->enable_state
== bp_disabled
)
15233 fp
.puts ("disable $bpnum\n");
15235 /* If this is a multi-location breakpoint, check if the locations
15236 should be individually disabled. Watchpoint locations are
15237 special, and not user visible. */
15238 if (!is_watchpoint (tp
) && tp
->loc
&& tp
->loc
->next
)
15240 struct bp_location
*loc
;
15243 for (loc
= tp
->loc
; loc
!= NULL
; loc
= loc
->next
, n
++)
15245 fp
.printf ("disable $bpnum.%d\n", n
);
15249 if (extra_trace_bits
&& *default_collect
)
15250 fp
.printf ("set default-collect %s\n", default_collect
);
15253 printf_filtered (_("Saved to file '%s'.\n"), expanded_filename
.get ());
15256 /* The `save breakpoints' command. */
15259 save_breakpoints_command (const char *args
, int from_tty
)
15261 save_breakpoints (args
, from_tty
, NULL
);
15264 /* The `save tracepoints' command. */
15267 save_tracepoints_command (const char *args
, int from_tty
)
15269 save_breakpoints (args
, from_tty
, is_tracepoint
);
15272 /* Create a vector of all tracepoints. */
15274 std::vector
<breakpoint
*>
15275 all_tracepoints (void)
15277 std::vector
<breakpoint
*> tp_vec
;
15278 struct breakpoint
*tp
;
15280 ALL_TRACEPOINTS (tp
)
15282 tp_vec
.push_back (tp
);
15289 /* This help string is used to consolidate all the help string for specifying
15290 locations used by several commands. */
15292 #define LOCATION_HELP_STRING \
15293 "Linespecs are colon-separated lists of location parameters, such as\n\
15294 source filename, function name, label name, and line number.\n\
15295 Example: To specify the start of a label named \"the_top\" in the\n\
15296 function \"fact\" in the file \"factorial.c\", use\n\
15297 \"factorial.c:fact:the_top\".\n\
15299 Address locations begin with \"*\" and specify an exact address in the\n\
15300 program. Example: To specify the fourth byte past the start function\n\
15301 \"main\", use \"*main + 4\".\n\
15303 Explicit locations are similar to linespecs but use an option/argument\n\
15304 syntax to specify location parameters.\n\
15305 Example: To specify the start of the label named \"the_top\" in the\n\
15306 function \"fact\" in the file \"factorial.c\", use \"-source factorial.c\n\
15307 -function fact -label the_top\".\n\
15309 By default, a specified function is matched against the program's\n\
15310 functions in all scopes. For C++, this means in all namespaces and\n\
15311 classes. For Ada, this means in all packages. E.g., in C++,\n\
15312 \"func()\" matches \"A::func()\", \"A::B::func()\", etc. The\n\
15313 \"-qualified\" flag overrides this behavior, making GDB interpret the\n\
15314 specified name as a complete fully-qualified name instead."
15316 /* This help string is used for the break, hbreak, tbreak and thbreak
15317 commands. It is defined as a macro to prevent duplication.
15318 COMMAND should be a string constant containing the name of the
15321 #define BREAK_ARGS_HELP(command) \
15322 command" [PROBE_MODIFIER] [LOCATION] [thread THREADNUM]\n\
15323 \t[-force-condition] [if CONDITION]\n\
15324 PROBE_MODIFIER shall be present if the command is to be placed in a\n\
15325 probe point. Accepted values are `-probe' (for a generic, automatically\n\
15326 guessed probe type), `-probe-stap' (for a SystemTap probe) or \n\
15327 `-probe-dtrace' (for a DTrace probe).\n\
15328 LOCATION may be a linespec, address, or explicit location as described\n\
15331 With no LOCATION, uses current execution address of the selected\n\
15332 stack frame. This is useful for breaking on return to a stack frame.\n\
15334 THREADNUM is the number from \"info threads\".\n\
15335 CONDITION is a boolean expression.\n\
15337 With the \"-force-condition\" flag, the condition is defined even when\n\
15338 it is invalid for all current locations.\n\
15339 \n" LOCATION_HELP_STRING "\n\n\
15340 Multiple breakpoints at one place are permitted, and useful if their\n\
15341 conditions are different.\n\
15343 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
15345 /* List of subcommands for "catch". */
15346 static struct cmd_list_element
*catch_cmdlist
;
15348 /* List of subcommands for "tcatch". */
15349 static struct cmd_list_element
*tcatch_cmdlist
;
15352 add_catch_command (const char *name
, const char *docstring
,
15353 cmd_const_sfunc_ftype
*sfunc
,
15354 completer_ftype
*completer
,
15355 void *user_data_catch
,
15356 void *user_data_tcatch
)
15358 struct cmd_list_element
*command
;
15360 command
= add_cmd (name
, class_breakpoint
, docstring
,
15362 set_cmd_sfunc (command
, sfunc
);
15363 set_cmd_context (command
, user_data_catch
);
15364 set_cmd_completer (command
, completer
);
15366 command
= add_cmd (name
, class_breakpoint
, docstring
,
15368 set_cmd_sfunc (command
, sfunc
);
15369 set_cmd_context (command
, user_data_tcatch
);
15370 set_cmd_completer (command
, completer
);
15373 struct breakpoint
*
15374 iterate_over_breakpoints (gdb::function_view
<bool (breakpoint
*)> callback
)
15376 struct breakpoint
*b
, *b_tmp
;
15378 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
15387 /* Zero if any of the breakpoint's locations could be a location where
15388 functions have been inlined, nonzero otherwise. */
15391 is_non_inline_function (struct breakpoint
*b
)
15393 /* The shared library event breakpoint is set on the address of a
15394 non-inline function. */
15395 if (b
->type
== bp_shlib_event
)
15401 /* Nonzero if the specified PC cannot be a location where functions
15402 have been inlined. */
15405 pc_at_non_inline_function (const address_space
*aspace
, CORE_ADDR pc
,
15406 const struct target_waitstatus
*ws
)
15408 struct breakpoint
*b
;
15409 struct bp_location
*bl
;
15411 ALL_BREAKPOINTS (b
)
15413 if (!is_non_inline_function (b
))
15416 for (bl
= b
->loc
; bl
!= NULL
; bl
= bl
->next
)
15418 if (!bl
->shlib_disabled
15419 && bpstat_check_location (bl
, aspace
, pc
, ws
))
15427 /* Remove any references to OBJFILE which is going to be freed. */
15430 breakpoint_free_objfile (struct objfile
*objfile
)
15432 struct bp_location
**locp
, *loc
;
15434 ALL_BP_LOCATIONS (loc
, locp
)
15435 if (loc
->symtab
!= NULL
&& SYMTAB_OBJFILE (loc
->symtab
) == objfile
)
15436 loc
->symtab
= NULL
;
15440 initialize_breakpoint_ops (void)
15442 static int initialized
= 0;
15444 struct breakpoint_ops
*ops
;
15450 /* The breakpoint_ops structure to be inherit by all kinds of
15451 breakpoints (real breakpoints, i.e., user "break" breakpoints,
15452 internal and momentary breakpoints, etc.). */
15453 ops
= &bkpt_base_breakpoint_ops
;
15454 *ops
= base_breakpoint_ops
;
15455 ops
->re_set
= bkpt_re_set
;
15456 ops
->insert_location
= bkpt_insert_location
;
15457 ops
->remove_location
= bkpt_remove_location
;
15458 ops
->breakpoint_hit
= bkpt_breakpoint_hit
;
15459 ops
->create_sals_from_location
= bkpt_create_sals_from_location
;
15460 ops
->create_breakpoints_sal
= bkpt_create_breakpoints_sal
;
15461 ops
->decode_location
= bkpt_decode_location
;
15463 /* The breakpoint_ops structure to be used in regular breakpoints. */
15464 ops
= &bkpt_breakpoint_ops
;
15465 *ops
= bkpt_base_breakpoint_ops
;
15466 ops
->re_set
= bkpt_re_set
;
15467 ops
->resources_needed
= bkpt_resources_needed
;
15468 ops
->print_it
= bkpt_print_it
;
15469 ops
->print_mention
= bkpt_print_mention
;
15470 ops
->print_recreate
= bkpt_print_recreate
;
15472 /* Ranged breakpoints. */
15473 ops
= &ranged_breakpoint_ops
;
15474 *ops
= bkpt_breakpoint_ops
;
15475 ops
->breakpoint_hit
= breakpoint_hit_ranged_breakpoint
;
15476 ops
->resources_needed
= resources_needed_ranged_breakpoint
;
15477 ops
->print_it
= print_it_ranged_breakpoint
;
15478 ops
->print_one
= print_one_ranged_breakpoint
;
15479 ops
->print_one_detail
= print_one_detail_ranged_breakpoint
;
15480 ops
->print_mention
= print_mention_ranged_breakpoint
;
15481 ops
->print_recreate
= print_recreate_ranged_breakpoint
;
15483 /* Internal breakpoints. */
15484 ops
= &internal_breakpoint_ops
;
15485 *ops
= bkpt_base_breakpoint_ops
;
15486 ops
->re_set
= internal_bkpt_re_set
;
15487 ops
->check_status
= internal_bkpt_check_status
;
15488 ops
->print_it
= internal_bkpt_print_it
;
15489 ops
->print_mention
= internal_bkpt_print_mention
;
15491 /* Momentary breakpoints. */
15492 ops
= &momentary_breakpoint_ops
;
15493 *ops
= bkpt_base_breakpoint_ops
;
15494 ops
->re_set
= momentary_bkpt_re_set
;
15495 ops
->check_status
= momentary_bkpt_check_status
;
15496 ops
->print_it
= momentary_bkpt_print_it
;
15497 ops
->print_mention
= momentary_bkpt_print_mention
;
15499 /* Probe breakpoints. */
15500 ops
= &bkpt_probe_breakpoint_ops
;
15501 *ops
= bkpt_breakpoint_ops
;
15502 ops
->insert_location
= bkpt_probe_insert_location
;
15503 ops
->remove_location
= bkpt_probe_remove_location
;
15504 ops
->create_sals_from_location
= bkpt_probe_create_sals_from_location
;
15505 ops
->decode_location
= bkpt_probe_decode_location
;
15508 ops
= &watchpoint_breakpoint_ops
;
15509 *ops
= base_breakpoint_ops
;
15510 ops
->re_set
= re_set_watchpoint
;
15511 ops
->insert_location
= insert_watchpoint
;
15512 ops
->remove_location
= remove_watchpoint
;
15513 ops
->breakpoint_hit
= breakpoint_hit_watchpoint
;
15514 ops
->check_status
= check_status_watchpoint
;
15515 ops
->resources_needed
= resources_needed_watchpoint
;
15516 ops
->works_in_software_mode
= works_in_software_mode_watchpoint
;
15517 ops
->print_it
= print_it_watchpoint
;
15518 ops
->print_mention
= print_mention_watchpoint
;
15519 ops
->print_recreate
= print_recreate_watchpoint
;
15520 ops
->explains_signal
= explains_signal_watchpoint
;
15522 /* Masked watchpoints. */
15523 ops
= &masked_watchpoint_breakpoint_ops
;
15524 *ops
= watchpoint_breakpoint_ops
;
15525 ops
->insert_location
= insert_masked_watchpoint
;
15526 ops
->remove_location
= remove_masked_watchpoint
;
15527 ops
->resources_needed
= resources_needed_masked_watchpoint
;
15528 ops
->works_in_software_mode
= works_in_software_mode_masked_watchpoint
;
15529 ops
->print_it
= print_it_masked_watchpoint
;
15530 ops
->print_one_detail
= print_one_detail_masked_watchpoint
;
15531 ops
->print_mention
= print_mention_masked_watchpoint
;
15532 ops
->print_recreate
= print_recreate_masked_watchpoint
;
15535 ops
= &tracepoint_breakpoint_ops
;
15536 *ops
= base_breakpoint_ops
;
15537 ops
->re_set
= tracepoint_re_set
;
15538 ops
->breakpoint_hit
= tracepoint_breakpoint_hit
;
15539 ops
->print_one_detail
= tracepoint_print_one_detail
;
15540 ops
->print_mention
= tracepoint_print_mention
;
15541 ops
->print_recreate
= tracepoint_print_recreate
;
15542 ops
->create_sals_from_location
= tracepoint_create_sals_from_location
;
15543 ops
->create_breakpoints_sal
= tracepoint_create_breakpoints_sal
;
15544 ops
->decode_location
= tracepoint_decode_location
;
15546 /* Probe tracepoints. */
15547 ops
= &tracepoint_probe_breakpoint_ops
;
15548 *ops
= tracepoint_breakpoint_ops
;
15549 ops
->create_sals_from_location
= tracepoint_probe_create_sals_from_location
;
15550 ops
->decode_location
= tracepoint_probe_decode_location
;
15552 /* Static tracepoints with marker (`-m'). */
15553 ops
= &strace_marker_breakpoint_ops
;
15554 *ops
= tracepoint_breakpoint_ops
;
15555 ops
->create_sals_from_location
= strace_marker_create_sals_from_location
;
15556 ops
->create_breakpoints_sal
= strace_marker_create_breakpoints_sal
;
15557 ops
->decode_location
= strace_marker_decode_location
;
15559 /* Fork catchpoints. */
15560 ops
= &catch_fork_breakpoint_ops
;
15561 *ops
= base_breakpoint_ops
;
15562 ops
->insert_location
= insert_catch_fork
;
15563 ops
->remove_location
= remove_catch_fork
;
15564 ops
->breakpoint_hit
= breakpoint_hit_catch_fork
;
15565 ops
->print_it
= print_it_catch_fork
;
15566 ops
->print_one
= print_one_catch_fork
;
15567 ops
->print_mention
= print_mention_catch_fork
;
15568 ops
->print_recreate
= print_recreate_catch_fork
;
15570 /* Vfork catchpoints. */
15571 ops
= &catch_vfork_breakpoint_ops
;
15572 *ops
= base_breakpoint_ops
;
15573 ops
->insert_location
= insert_catch_vfork
;
15574 ops
->remove_location
= remove_catch_vfork
;
15575 ops
->breakpoint_hit
= breakpoint_hit_catch_vfork
;
15576 ops
->print_it
= print_it_catch_vfork
;
15577 ops
->print_one
= print_one_catch_vfork
;
15578 ops
->print_mention
= print_mention_catch_vfork
;
15579 ops
->print_recreate
= print_recreate_catch_vfork
;
15581 /* Exec catchpoints. */
15582 ops
= &catch_exec_breakpoint_ops
;
15583 *ops
= base_breakpoint_ops
;
15584 ops
->insert_location
= insert_catch_exec
;
15585 ops
->remove_location
= remove_catch_exec
;
15586 ops
->breakpoint_hit
= breakpoint_hit_catch_exec
;
15587 ops
->print_it
= print_it_catch_exec
;
15588 ops
->print_one
= print_one_catch_exec
;
15589 ops
->print_mention
= print_mention_catch_exec
;
15590 ops
->print_recreate
= print_recreate_catch_exec
;
15592 /* Solib-related catchpoints. */
15593 ops
= &catch_solib_breakpoint_ops
;
15594 *ops
= base_breakpoint_ops
;
15595 ops
->insert_location
= insert_catch_solib
;
15596 ops
->remove_location
= remove_catch_solib
;
15597 ops
->breakpoint_hit
= breakpoint_hit_catch_solib
;
15598 ops
->check_status
= check_status_catch_solib
;
15599 ops
->print_it
= print_it_catch_solib
;
15600 ops
->print_one
= print_one_catch_solib
;
15601 ops
->print_mention
= print_mention_catch_solib
;
15602 ops
->print_recreate
= print_recreate_catch_solib
;
15604 ops
= &dprintf_breakpoint_ops
;
15605 *ops
= bkpt_base_breakpoint_ops
;
15606 ops
->re_set
= dprintf_re_set
;
15607 ops
->resources_needed
= bkpt_resources_needed
;
15608 ops
->print_it
= bkpt_print_it
;
15609 ops
->print_mention
= bkpt_print_mention
;
15610 ops
->print_recreate
= dprintf_print_recreate
;
15611 ops
->after_condition_true
= dprintf_after_condition_true
;
15612 ops
->breakpoint_hit
= dprintf_breakpoint_hit
;
15615 /* Chain containing all defined "enable breakpoint" subcommands. */
15617 static struct cmd_list_element
*enablebreaklist
= NULL
;
15619 /* See breakpoint.h. */
15621 cmd_list_element
*commands_cmd_element
= nullptr;
15623 void _initialize_breakpoint ();
15625 _initialize_breakpoint ()
15627 struct cmd_list_element
*c
;
15629 initialize_breakpoint_ops ();
15631 gdb::observers::solib_unloaded
.attach (disable_breakpoints_in_unloaded_shlib
);
15632 gdb::observers::free_objfile
.attach (disable_breakpoints_in_freed_objfile
);
15633 gdb::observers::memory_changed
.attach (invalidate_bp_value_on_memory_change
);
15635 breakpoint_chain
= 0;
15636 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
15637 before a breakpoint is set. */
15638 breakpoint_count
= 0;
15640 tracepoint_count
= 0;
15642 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
15643 Set ignore-count of breakpoint number N to COUNT.\n\
15644 Usage is `ignore N COUNT'."));
15646 commands_cmd_element
= add_com ("commands", class_breakpoint
,
15647 commands_command
, _("\
15648 Set commands to be executed when the given breakpoints are hit.\n\
15649 Give a space-separated breakpoint list as argument after \"commands\".\n\
15650 A list element can be a breakpoint number (e.g. `5') or a range of numbers\n\
15652 With no argument, the targeted breakpoint is the last one set.\n\
15653 The commands themselves follow starting on the next line.\n\
15654 Type a line containing \"end\" to indicate the end of them.\n\
15655 Give \"silent\" as the first line to make the breakpoint silent;\n\
15656 then no output is printed when it is hit, except what the commands print."));
15658 const auto cc_opts
= make_condition_command_options_def_group (nullptr);
15659 static std::string condition_command_help
15660 = gdb::option::build_help (_("\
15661 Specify breakpoint number N to break only if COND is true.\n\
15662 Usage is `condition [OPTION] N COND', where N is an integer and COND\n\
15663 is an expression to be evaluated whenever breakpoint N is reached.\n\
15666 %OPTIONS%"), cc_opts
);
15668 c
= add_com ("condition", class_breakpoint
, condition_command
,
15669 condition_command_help
.c_str ());
15670 set_cmd_completer_handle_brkchars (c
, condition_completer
);
15672 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
15673 Set a temporary breakpoint.\n\
15674 Like \"break\" except the breakpoint is only temporary,\n\
15675 so it will be deleted when hit. Equivalent to \"break\" followed\n\
15676 by using \"enable delete\" on the breakpoint number.\n\
15678 BREAK_ARGS_HELP ("tbreak")));
15679 set_cmd_completer (c
, location_completer
);
15681 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
15682 Set a hardware assisted breakpoint.\n\
15683 Like \"break\" except the breakpoint requires hardware support,\n\
15684 some target hardware may not have this support.\n\
15686 BREAK_ARGS_HELP ("hbreak")));
15687 set_cmd_completer (c
, location_completer
);
15689 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
15690 Set a temporary hardware assisted breakpoint.\n\
15691 Like \"hbreak\" except the breakpoint is only temporary,\n\
15692 so it will be deleted when hit.\n\
15694 BREAK_ARGS_HELP ("thbreak")));
15695 set_cmd_completer (c
, location_completer
);
15697 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
15698 Enable all or some breakpoints.\n\
15699 Usage: enable [BREAKPOINTNUM]...\n\
15700 Give breakpoint numbers (separated by spaces) as arguments.\n\
15701 With no subcommand, breakpoints are enabled until you command otherwise.\n\
15702 This is used to cancel the effect of the \"disable\" command.\n\
15703 With a subcommand you can enable temporarily."),
15704 &enablelist
, "enable ", 1, &cmdlist
);
15706 add_com_alias ("en", "enable", class_breakpoint
, 1);
15708 add_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
15709 Enable all or some breakpoints.\n\
15710 Usage: enable breakpoints [BREAKPOINTNUM]...\n\
15711 Give breakpoint numbers (separated by spaces) as arguments.\n\
15712 This is used to cancel the effect of the \"disable\" command.\n\
15713 May be abbreviated to simply \"enable\"."),
15714 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
15716 add_cmd ("once", no_class
, enable_once_command
, _("\
15717 Enable some breakpoints for one hit.\n\
15718 Usage: enable breakpoints once BREAKPOINTNUM...\n\
15719 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
15722 add_cmd ("delete", no_class
, enable_delete_command
, _("\
15723 Enable some breakpoints and delete when hit.\n\
15724 Usage: enable breakpoints delete BREAKPOINTNUM...\n\
15725 If a breakpoint is hit while enabled in this fashion, it is deleted."),
15728 add_cmd ("count", no_class
, enable_count_command
, _("\
15729 Enable some breakpoints for COUNT hits.\n\
15730 Usage: enable breakpoints count COUNT BREAKPOINTNUM...\n\
15731 If a breakpoint is hit while enabled in this fashion,\n\
15732 the count is decremented; when it reaches zero, the breakpoint is disabled."),
15735 add_cmd ("delete", no_class
, enable_delete_command
, _("\
15736 Enable some breakpoints and delete when hit.\n\
15737 Usage: enable delete BREAKPOINTNUM...\n\
15738 If a breakpoint is hit while enabled in this fashion, it is deleted."),
15741 add_cmd ("once", no_class
, enable_once_command
, _("\
15742 Enable some breakpoints for one hit.\n\
15743 Usage: enable once BREAKPOINTNUM...\n\
15744 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
15747 add_cmd ("count", no_class
, enable_count_command
, _("\
15748 Enable some breakpoints for COUNT hits.\n\
15749 Usage: enable count COUNT BREAKPOINTNUM...\n\
15750 If a breakpoint is hit while enabled in this fashion,\n\
15751 the count is decremented; when it reaches zero, the breakpoint is disabled."),
15754 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
15755 Disable all or some breakpoints.\n\
15756 Usage: disable [BREAKPOINTNUM]...\n\
15757 Arguments are breakpoint numbers with spaces in between.\n\
15758 To disable all breakpoints, give no argument.\n\
15759 A disabled breakpoint is not forgotten, but has no effect until re-enabled."),
15760 &disablelist
, "disable ", 1, &cmdlist
);
15761 add_com_alias ("dis", "disable", class_breakpoint
, 1);
15762 add_com_alias ("disa", "disable", class_breakpoint
, 1);
15764 add_cmd ("breakpoints", class_breakpoint
, disable_command
, _("\
15765 Disable all or some breakpoints.\n\
15766 Usage: disable breakpoints [BREAKPOINTNUM]...\n\
15767 Arguments are breakpoint numbers with spaces in between.\n\
15768 To disable all breakpoints, give no argument.\n\
15769 A disabled breakpoint is not forgotten, but has no effect until re-enabled.\n\
15770 This command may be abbreviated \"disable\"."),
15773 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
15774 Delete all or some breakpoints.\n\
15775 Usage: delete [BREAKPOINTNUM]...\n\
15776 Arguments are breakpoint numbers with spaces in between.\n\
15777 To delete all breakpoints, give no argument.\n\
15779 Also a prefix command for deletion of other GDB objects."),
15780 &deletelist
, "delete ", 1, &cmdlist
);
15781 add_com_alias ("d", "delete", class_breakpoint
, 1);
15782 add_com_alias ("del", "delete", class_breakpoint
, 1);
15784 add_cmd ("breakpoints", class_breakpoint
, delete_command
, _("\
15785 Delete all or some breakpoints or auto-display expressions.\n\
15786 Usage: delete breakpoints [BREAKPOINTNUM]...\n\
15787 Arguments are breakpoint numbers with spaces in between.\n\
15788 To delete all breakpoints, give no argument.\n\
15789 This command may be abbreviated \"delete\"."),
15792 add_com ("clear", class_breakpoint
, clear_command
, _("\
15793 Clear breakpoint at specified location.\n\
15794 Argument may be a linespec, explicit, or address location as described below.\n\
15796 With no argument, clears all breakpoints in the line that the selected frame\n\
15797 is executing in.\n"
15798 "\n" LOCATION_HELP_STRING
"\n\n\
15799 See also the \"delete\" command which clears breakpoints by number."));
15800 add_com_alias ("cl", "clear", class_breakpoint
, 1);
15802 c
= add_com ("break", class_breakpoint
, break_command
, _("\
15803 Set breakpoint at specified location.\n"
15804 BREAK_ARGS_HELP ("break")));
15805 set_cmd_completer (c
, location_completer
);
15807 add_com_alias ("b", "break", class_run
, 1);
15808 add_com_alias ("br", "break", class_run
, 1);
15809 add_com_alias ("bre", "break", class_run
, 1);
15810 add_com_alias ("brea", "break", class_run
, 1);
15814 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
15815 Break in function/address or break at a line in the current file."),
15816 &stoplist
, "stop ", 1, &cmdlist
);
15817 add_cmd ("in", class_breakpoint
, stopin_command
,
15818 _("Break in function or address."), &stoplist
);
15819 add_cmd ("at", class_breakpoint
, stopat_command
,
15820 _("Break at a line in the current file."), &stoplist
);
15821 add_com ("status", class_info
, info_breakpoints_command
, _("\
15822 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
15823 The \"Type\" column indicates one of:\n\
15824 \tbreakpoint - normal breakpoint\n\
15825 \twatchpoint - watchpoint\n\
15826 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15827 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
15828 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
15829 address and file/line number respectively.\n\
15831 Convenience variable \"$_\" and default examine address for \"x\"\n\
15832 are set to the address of the last breakpoint listed unless the command\n\
15833 is prefixed with \"server \".\n\n\
15834 Convenience variable \"$bpnum\" contains the number of the last\n\
15835 breakpoint set."));
15838 add_info ("breakpoints", info_breakpoints_command
, _("\
15839 Status of specified breakpoints (all user-settable breakpoints if no argument).\n\
15840 The \"Type\" column indicates one of:\n\
15841 \tbreakpoint - normal breakpoint\n\
15842 \twatchpoint - watchpoint\n\
15843 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15844 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
15845 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
15846 address and file/line number respectively.\n\
15848 Convenience variable \"$_\" and default examine address for \"x\"\n\
15849 are set to the address of the last breakpoint listed unless the command\n\
15850 is prefixed with \"server \".\n\n\
15851 Convenience variable \"$bpnum\" contains the number of the last\n\
15852 breakpoint set."));
15854 add_info_alias ("b", "breakpoints", 1);
15856 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
15857 Status of all breakpoints, or breakpoint number NUMBER.\n\
15858 The \"Type\" column indicates one of:\n\
15859 \tbreakpoint - normal breakpoint\n\
15860 \twatchpoint - watchpoint\n\
15861 \tlongjmp - internal breakpoint used to step through longjmp()\n\
15862 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
15863 \tuntil - internal breakpoint used by the \"until\" command\n\
15864 \tfinish - internal breakpoint used by the \"finish\" command\n\
15865 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15866 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
15867 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
15868 address and file/line number respectively.\n\
15870 Convenience variable \"$_\" and default examine address for \"x\"\n\
15871 are set to the address of the last breakpoint listed unless the command\n\
15872 is prefixed with \"server \".\n\n\
15873 Convenience variable \"$bpnum\" contains the number of the last\n\
15875 &maintenanceinfolist
);
15877 add_basic_prefix_cmd ("catch", class_breakpoint
, _("\
15878 Set catchpoints to catch events."),
15879 &catch_cmdlist
, "catch ",
15880 0/*allow-unknown*/, &cmdlist
);
15882 add_basic_prefix_cmd ("tcatch", class_breakpoint
, _("\
15883 Set temporary catchpoints to catch events."),
15884 &tcatch_cmdlist
, "tcatch ",
15885 0/*allow-unknown*/, &cmdlist
);
15887 add_catch_command ("fork", _("Catch calls to fork."),
15888 catch_fork_command_1
,
15890 (void *) (uintptr_t) catch_fork_permanent
,
15891 (void *) (uintptr_t) catch_fork_temporary
);
15892 add_catch_command ("vfork", _("Catch calls to vfork."),
15893 catch_fork_command_1
,
15895 (void *) (uintptr_t) catch_vfork_permanent
,
15896 (void *) (uintptr_t) catch_vfork_temporary
);
15897 add_catch_command ("exec", _("Catch calls to exec."),
15898 catch_exec_command_1
,
15902 add_catch_command ("load", _("Catch loads of shared libraries.\n\
15903 Usage: catch load [REGEX]\n\
15904 If REGEX is given, only stop for libraries matching the regular expression."),
15905 catch_load_command_1
,
15909 add_catch_command ("unload", _("Catch unloads of shared libraries.\n\
15910 Usage: catch unload [REGEX]\n\
15911 If REGEX is given, only stop for libraries matching the regular expression."),
15912 catch_unload_command_1
,
15917 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
15918 Set a watchpoint for an expression.\n\
15919 Usage: watch [-l|-location] EXPRESSION\n\
15920 A watchpoint stops execution of your program whenever the value of\n\
15921 an expression changes.\n\
15922 If -l or -location is given, this evaluates EXPRESSION and watches\n\
15923 the memory to which it refers."));
15924 set_cmd_completer (c
, expression_completer
);
15926 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
15927 Set a read watchpoint for an expression.\n\
15928 Usage: rwatch [-l|-location] EXPRESSION\n\
15929 A watchpoint stops execution of your program whenever the value of\n\
15930 an expression is read.\n\
15931 If -l or -location is given, this evaluates EXPRESSION and watches\n\
15932 the memory to which it refers."));
15933 set_cmd_completer (c
, expression_completer
);
15935 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
15936 Set a watchpoint for an expression.\n\
15937 Usage: awatch [-l|-location] EXPRESSION\n\
15938 A watchpoint stops execution of your program whenever the value of\n\
15939 an expression is either read or written.\n\
15940 If -l or -location is given, this evaluates EXPRESSION and watches\n\
15941 the memory to which it refers."));
15942 set_cmd_completer (c
, expression_completer
);
15944 add_info ("watchpoints", info_watchpoints_command
, _("\
15945 Status of specified watchpoints (all watchpoints if no argument)."));
15947 /* XXX: cagney/2005-02-23: This should be a boolean, and should
15948 respond to changes - contrary to the description. */
15949 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
15950 &can_use_hw_watchpoints
, _("\
15951 Set debugger's willingness to use watchpoint hardware."), _("\
15952 Show debugger's willingness to use watchpoint hardware."), _("\
15953 If zero, gdb will not use hardware for new watchpoints, even if\n\
15954 such is available. (However, any hardware watchpoints that were\n\
15955 created before setting this to nonzero, will continue to use watchpoint\n\
15958 show_can_use_hw_watchpoints
,
15959 &setlist
, &showlist
);
15961 can_use_hw_watchpoints
= 1;
15963 /* Tracepoint manipulation commands. */
15965 c
= add_com ("trace", class_breakpoint
, trace_command
, _("\
15966 Set a tracepoint at specified location.\n\
15968 BREAK_ARGS_HELP ("trace") "\n\
15969 Do \"help tracepoints\" for info on other tracepoint commands."));
15970 set_cmd_completer (c
, location_completer
);
15972 add_com_alias ("tp", "trace", class_breakpoint
, 0);
15973 add_com_alias ("tr", "trace", class_breakpoint
, 1);
15974 add_com_alias ("tra", "trace", class_breakpoint
, 1);
15975 add_com_alias ("trac", "trace", class_breakpoint
, 1);
15977 c
= add_com ("ftrace", class_breakpoint
, ftrace_command
, _("\
15978 Set a fast tracepoint at specified location.\n\
15980 BREAK_ARGS_HELP ("ftrace") "\n\
15981 Do \"help tracepoints\" for info on other tracepoint commands."));
15982 set_cmd_completer (c
, location_completer
);
15984 c
= add_com ("strace", class_breakpoint
, strace_command
, _("\
15985 Set a static tracepoint at location or marker.\n\
15987 strace [LOCATION] [if CONDITION]\n\
15988 LOCATION may be a linespec, explicit, or address location (described below) \n\
15989 or -m MARKER_ID.\n\n\
15990 If a marker id is specified, probe the marker with that name. With\n\
15991 no LOCATION, uses current execution address of the selected stack frame.\n\
15992 Static tracepoints accept an extra collect action -- ``collect $_sdata''.\n\
15993 This collects arbitrary user data passed in the probe point call to the\n\
15994 tracing library. You can inspect it when analyzing the trace buffer,\n\
15995 by printing the $_sdata variable like any other convenience variable.\n\
15997 CONDITION is a boolean expression.\n\
15998 \n" LOCATION_HELP_STRING
"\n\n\
15999 Multiple tracepoints at one place are permitted, and useful if their\n\
16000 conditions are different.\n\
16002 Do \"help breakpoints\" for info on other commands dealing with breakpoints.\n\
16003 Do \"help tracepoints\" for info on other tracepoint commands."));
16004 set_cmd_completer (c
, location_completer
);
16006 add_info ("tracepoints", info_tracepoints_command
, _("\
16007 Status of specified tracepoints (all tracepoints if no argument).\n\
16008 Convenience variable \"$tpnum\" contains the number of the\n\
16009 last tracepoint set."));
16011 add_info_alias ("tp", "tracepoints", 1);
16013 add_cmd ("tracepoints", class_trace
, delete_trace_command
, _("\
16014 Delete specified tracepoints.\n\
16015 Arguments are tracepoint numbers, separated by spaces.\n\
16016 No argument means delete all tracepoints."),
16018 add_alias_cmd ("tr", "tracepoints", class_trace
, 1, &deletelist
);
16020 c
= add_cmd ("tracepoints", class_trace
, disable_trace_command
, _("\
16021 Disable specified tracepoints.\n\
16022 Arguments are tracepoint numbers, separated by spaces.\n\
16023 No argument means disable all tracepoints."),
16025 deprecate_cmd (c
, "disable");
16027 c
= add_cmd ("tracepoints", class_trace
, enable_trace_command
, _("\
16028 Enable specified tracepoints.\n\
16029 Arguments are tracepoint numbers, separated by spaces.\n\
16030 No argument means enable all tracepoints."),
16032 deprecate_cmd (c
, "enable");
16034 add_com ("passcount", class_trace
, trace_pass_command
, _("\
16035 Set the passcount for a tracepoint.\n\
16036 The trace will end when the tracepoint has been passed 'count' times.\n\
16037 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
16038 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
16040 add_basic_prefix_cmd ("save", class_breakpoint
,
16041 _("Save breakpoint definitions as a script."),
16042 &save_cmdlist
, "save ",
16043 0/*allow-unknown*/, &cmdlist
);
16045 c
= add_cmd ("breakpoints", class_breakpoint
, save_breakpoints_command
, _("\
16046 Save current breakpoint definitions as a script.\n\
16047 This includes all types of breakpoints (breakpoints, watchpoints,\n\
16048 catchpoints, tracepoints). Use the 'source' command in another debug\n\
16049 session to restore them."),
16051 set_cmd_completer (c
, filename_completer
);
16053 c
= add_cmd ("tracepoints", class_trace
, save_tracepoints_command
, _("\
16054 Save current tracepoint definitions as a script.\n\
16055 Use the 'source' command in another debug session to restore them."),
16057 set_cmd_completer (c
, filename_completer
);
16059 c
= add_com_alias ("save-tracepoints", "save tracepoints", class_trace
, 0);
16060 deprecate_cmd (c
, "save tracepoints");
16062 add_basic_prefix_cmd ("breakpoint", class_maintenance
, _("\
16063 Breakpoint specific settings.\n\
16064 Configure various breakpoint-specific variables such as\n\
16065 pending breakpoint behavior."),
16066 &breakpoint_set_cmdlist
, "set breakpoint ",
16067 0/*allow-unknown*/, &setlist
);
16068 add_show_prefix_cmd ("breakpoint", class_maintenance
, _("\
16069 Breakpoint specific settings.\n\
16070 Configure various breakpoint-specific variables such as\n\
16071 pending breakpoint behavior."),
16072 &breakpoint_show_cmdlist
, "show breakpoint ",
16073 0/*allow-unknown*/, &showlist
);
16075 add_setshow_auto_boolean_cmd ("pending", no_class
,
16076 &pending_break_support
, _("\
16077 Set debugger's behavior regarding pending breakpoints."), _("\
16078 Show debugger's behavior regarding pending breakpoints."), _("\
16079 If on, an unrecognized breakpoint location will cause gdb to create a\n\
16080 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
16081 an error. If auto, an unrecognized breakpoint location results in a\n\
16082 user-query to see if a pending breakpoint should be created."),
16084 show_pending_break_support
,
16085 &breakpoint_set_cmdlist
,
16086 &breakpoint_show_cmdlist
);
16088 pending_break_support
= AUTO_BOOLEAN_AUTO
;
16090 add_setshow_boolean_cmd ("auto-hw", no_class
,
16091 &automatic_hardware_breakpoints
, _("\
16092 Set automatic usage of hardware breakpoints."), _("\
16093 Show automatic usage of hardware breakpoints."), _("\
16094 If set, the debugger will automatically use hardware breakpoints for\n\
16095 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
16096 a warning will be emitted for such breakpoints."),
16098 show_automatic_hardware_breakpoints
,
16099 &breakpoint_set_cmdlist
,
16100 &breakpoint_show_cmdlist
);
16102 add_setshow_boolean_cmd ("always-inserted", class_support
,
16103 &always_inserted_mode
, _("\
16104 Set mode for inserting breakpoints."), _("\
16105 Show mode for inserting breakpoints."), _("\
16106 When this mode is on, breakpoints are inserted immediately as soon as\n\
16107 they're created, kept inserted even when execution stops, and removed\n\
16108 only when the user deletes them. When this mode is off (the default),\n\
16109 breakpoints are inserted only when execution continues, and removed\n\
16110 when execution stops."),
16112 &show_always_inserted_mode
,
16113 &breakpoint_set_cmdlist
,
16114 &breakpoint_show_cmdlist
);
16116 add_setshow_enum_cmd ("condition-evaluation", class_breakpoint
,
16117 condition_evaluation_enums
,
16118 &condition_evaluation_mode_1
, _("\
16119 Set mode of breakpoint condition evaluation."), _("\
16120 Show mode of breakpoint condition evaluation."), _("\
16121 When this is set to \"host\", breakpoint conditions will be\n\
16122 evaluated on the host's side by GDB. When it is set to \"target\",\n\
16123 breakpoint conditions will be downloaded to the target (if the target\n\
16124 supports such feature) and conditions will be evaluated on the target's side.\n\
16125 If this is set to \"auto\" (default), this will be automatically set to\n\
16126 \"target\" if it supports condition evaluation, otherwise it will\n\
16127 be set to \"host\"."),
16128 &set_condition_evaluation_mode
,
16129 &show_condition_evaluation_mode
,
16130 &breakpoint_set_cmdlist
,
16131 &breakpoint_show_cmdlist
);
16133 add_com ("break-range", class_breakpoint
, break_range_command
, _("\
16134 Set a breakpoint for an address range.\n\
16135 break-range START-LOCATION, END-LOCATION\n\
16136 where START-LOCATION and END-LOCATION can be one of the following:\n\
16137 LINENUM, for that line in the current file,\n\
16138 FILE:LINENUM, for that line in that file,\n\
16139 +OFFSET, for that number of lines after the current line\n\
16140 or the start of the range\n\
16141 FUNCTION, for the first line in that function,\n\
16142 FILE:FUNCTION, to distinguish among like-named static functions.\n\
16143 *ADDRESS, for the instruction at that address.\n\
16145 The breakpoint will stop execution of the inferior whenever it executes\n\
16146 an instruction at any address within the [START-LOCATION, END-LOCATION]\n\
16147 range (including START-LOCATION and END-LOCATION)."));
16149 c
= add_com ("dprintf", class_breakpoint
, dprintf_command
, _("\
16150 Set a dynamic printf at specified location.\n\
16151 dprintf location,format string,arg1,arg2,...\n\
16152 location may be a linespec, explicit, or address location.\n"
16153 "\n" LOCATION_HELP_STRING
));
16154 set_cmd_completer (c
, location_completer
);
16156 add_setshow_enum_cmd ("dprintf-style", class_support
,
16157 dprintf_style_enums
, &dprintf_style
, _("\
16158 Set the style of usage for dynamic printf."), _("\
16159 Show the style of usage for dynamic printf."), _("\
16160 This setting chooses how GDB will do a dynamic printf.\n\
16161 If the value is \"gdb\", then the printing is done by GDB to its own\n\
16162 console, as with the \"printf\" command.\n\
16163 If the value is \"call\", the print is done by calling a function in your\n\
16164 program; by default printf(), but you can choose a different function or\n\
16165 output stream by setting dprintf-function and dprintf-channel."),
16166 update_dprintf_commands
, NULL
,
16167 &setlist
, &showlist
);
16169 dprintf_function
= xstrdup ("printf");
16170 add_setshow_string_cmd ("dprintf-function", class_support
,
16171 &dprintf_function
, _("\
16172 Set the function to use for dynamic printf."), _("\
16173 Show the function to use for dynamic printf."), NULL
,
16174 update_dprintf_commands
, NULL
,
16175 &setlist
, &showlist
);
16177 dprintf_channel
= xstrdup ("");
16178 add_setshow_string_cmd ("dprintf-channel", class_support
,
16179 &dprintf_channel
, _("\
16180 Set the channel to use for dynamic printf."), _("\
16181 Show the channel to use for dynamic printf."), NULL
,
16182 update_dprintf_commands
, NULL
,
16183 &setlist
, &showlist
);
16185 add_setshow_boolean_cmd ("disconnected-dprintf", no_class
,
16186 &disconnected_dprintf
, _("\
16187 Set whether dprintf continues after GDB disconnects."), _("\
16188 Show whether dprintf continues after GDB disconnects."), _("\
16189 Use this to let dprintf commands continue to hit and produce output\n\
16190 even if GDB disconnects or detaches from the target."),
16193 &setlist
, &showlist
);
16195 add_com ("agent-printf", class_vars
, agent_printf_command
, _("\
16196 Target agent only formatted printing, like the C \"printf\" function.\n\
16197 Usage: agent-printf \"format string\", ARG1, ARG2, ARG3, ..., ARGN\n\
16198 This supports most C printf format specifications, like %s, %d, etc.\n\
16199 This is useful for formatted output in user-defined commands."));
16201 automatic_hardware_breakpoints
= true;
16203 gdb::observers::about_to_proceed
.attach (breakpoint_about_to_proceed
);
16204 gdb::observers::thread_exit
.attach (remove_threaded_breakpoints
);