1 /* Everything about breakpoints, for GDB.
3 Copyright (C) 1986-2021 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "arch-utils.h"
26 #include "breakpoint.h"
27 #include "tracepoint.h"
29 #include "expression.h"
36 #include "gdbthread.h"
39 #include "gdb-demangle.h"
40 #include "filenames.h"
46 #include "completer.h"
48 #include "cli/cli-script.h"
52 #include "observable.h"
58 #include "parser-defs.h"
59 #include "gdb_regex.h"
61 #include "cli/cli-utils.h"
64 #include "dummy-frame.h"
66 #include "gdbsupport/format.h"
67 #include "thread-fsm.h"
68 #include "tid-parse.h"
69 #include "cli/cli-style.h"
71 /* readline include files */
72 #include "readline/tilde.h"
74 /* readline defines this. */
77 #include "mi/mi-common.h"
78 #include "extension.h"
80 #include "progspace-and-thread.h"
81 #include "gdbsupport/array-view.h"
82 #include "gdbsupport/gdb_optional.h"
84 /* Prototypes for local functions. */
86 static void map_breakpoint_numbers (const char *,
87 gdb::function_view
<void (breakpoint
*)>);
89 static void breakpoint_re_set_default (struct breakpoint
*);
92 create_sals_from_location_default (struct event_location
*location
,
93 struct linespec_result
*canonical
,
94 enum bptype type_wanted
);
96 static void create_breakpoints_sal_default (struct gdbarch
*,
97 struct linespec_result
*,
98 gdb::unique_xmalloc_ptr
<char>,
99 gdb::unique_xmalloc_ptr
<char>,
101 enum bpdisp
, int, int,
103 const struct breakpoint_ops
*,
104 int, int, int, unsigned);
106 static std::vector
<symtab_and_line
> decode_location_default
107 (struct breakpoint
*b
, struct event_location
*location
,
108 struct program_space
*search_pspace
);
110 static int can_use_hardware_watchpoint
111 (const std::vector
<value_ref_ptr
> &vals
);
113 static void mention (struct breakpoint
*);
115 static struct breakpoint
*set_raw_breakpoint_without_location (struct gdbarch
*,
117 const struct breakpoint_ops
*);
118 static struct bp_location
*add_location_to_breakpoint (struct breakpoint
*,
119 const struct symtab_and_line
*);
121 /* This function is used in gdbtk sources and thus can not be made
123 struct breakpoint
*set_raw_breakpoint (struct gdbarch
*gdbarch
,
124 struct symtab_and_line
,
126 const struct breakpoint_ops
*);
128 static struct breakpoint
*
129 momentary_breakpoint_from_master (struct breakpoint
*orig
,
131 const struct breakpoint_ops
*ops
,
134 static void breakpoint_adjustment_warning (CORE_ADDR
, CORE_ADDR
, int, int);
136 static CORE_ADDR
adjust_breakpoint_address (struct gdbarch
*gdbarch
,
140 static void describe_other_breakpoints (struct gdbarch
*,
141 struct program_space
*, CORE_ADDR
,
142 struct obj_section
*, int);
144 static int watchpoint_locations_match (struct bp_location
*loc1
,
145 struct bp_location
*loc2
);
147 static int breakpoint_locations_match (struct bp_location
*loc1
,
148 struct bp_location
*loc2
,
149 bool sw_hw_bps_match
= false);
151 static int breakpoint_location_address_match (struct bp_location
*bl
,
152 const struct address_space
*aspace
,
155 static int breakpoint_location_address_range_overlap (struct bp_location
*,
156 const address_space
*,
159 static int remove_breakpoint (struct bp_location
*);
160 static int remove_breakpoint_1 (struct bp_location
*, enum remove_bp_reason
);
162 static enum print_stop_action
print_bp_stop_message (bpstat bs
);
164 static int hw_breakpoint_used_count (void);
166 static int hw_watchpoint_use_count (struct breakpoint
*);
168 static int hw_watchpoint_used_count_others (struct breakpoint
*except
,
170 int *other_type_used
);
172 static void enable_breakpoint_disp (struct breakpoint
*, enum bpdisp
,
175 static void decref_bp_location (struct bp_location
**loc
);
177 static struct bp_location
*allocate_bp_location (struct breakpoint
*bpt
);
179 /* update_global_location_list's modes of operation wrt to whether to
180 insert locations now. */
181 enum ugll_insert_mode
183 /* Don't insert any breakpoint locations into the inferior, only
184 remove already-inserted locations that no longer should be
185 inserted. Functions that delete a breakpoint or breakpoints
186 should specify this mode, so that deleting a breakpoint doesn't
187 have the side effect of inserting the locations of other
188 breakpoints that are marked not-inserted, but should_be_inserted
189 returns true on them.
191 This behavior is useful is situations close to tear-down -- e.g.,
192 after an exec, while the target still has execution, but
193 breakpoint shadows of the previous executable image should *NOT*
194 be restored to the new image; or before detaching, where the
195 target still has execution and wants to delete breakpoints from
196 GDB's lists, and all breakpoints had already been removed from
200 /* May insert breakpoints iff breakpoints_should_be_inserted_now
201 claims breakpoints should be inserted now. */
204 /* Insert locations now, irrespective of
205 breakpoints_should_be_inserted_now. E.g., say all threads are
206 stopped right now, and the user did "continue". We need to
207 insert breakpoints _before_ resuming the target, but
208 UGLL_MAY_INSERT wouldn't insert them, because
209 breakpoints_should_be_inserted_now returns false at that point,
210 as no thread is running yet. */
214 static void update_global_location_list (enum ugll_insert_mode
);
216 static void update_global_location_list_nothrow (enum ugll_insert_mode
);
218 static void insert_breakpoint_locations (void);
220 static void trace_pass_command (const char *, int);
222 static void set_tracepoint_count (int num
);
224 static bool is_masked_watchpoint (const struct breakpoint
*b
);
226 static struct bp_location
**get_first_locp_gte_addr (CORE_ADDR address
);
228 /* Return 1 if B refers to a static tracepoint set by marker ("-m"), zero
231 static int strace_marker_p (struct breakpoint
*b
);
233 /* The breakpoint_ops structure to be inherited by all breakpoint_ops
234 that are implemented on top of software or hardware breakpoints
235 (user breakpoints, internal and momentary breakpoints, etc.). */
236 static struct breakpoint_ops bkpt_base_breakpoint_ops
;
238 /* Internal breakpoints class type. */
239 static struct breakpoint_ops internal_breakpoint_ops
;
241 /* Momentary breakpoints class type. */
242 static struct breakpoint_ops momentary_breakpoint_ops
;
244 /* The breakpoint_ops structure to be used in regular user created
246 struct breakpoint_ops bkpt_breakpoint_ops
;
248 /* Breakpoints set on probes. */
249 static struct breakpoint_ops bkpt_probe_breakpoint_ops
;
251 /* Tracepoints set on probes. */
252 static struct breakpoint_ops tracepoint_probe_breakpoint_ops
;
254 /* Dynamic printf class type. */
255 struct breakpoint_ops dprintf_breakpoint_ops
;
257 /* The style in which to perform a dynamic printf. This is a user
258 option because different output options have different tradeoffs;
259 if GDB does the printing, there is better error handling if there
260 is a problem with any of the arguments, but using an inferior
261 function lets you have special-purpose printers and sending of
262 output to the same place as compiled-in print functions. */
264 static const char dprintf_style_gdb
[] = "gdb";
265 static const char dprintf_style_call
[] = "call";
266 static const char dprintf_style_agent
[] = "agent";
267 static const char *const dprintf_style_enums
[] = {
273 static const char *dprintf_style
= dprintf_style_gdb
;
275 /* The function to use for dynamic printf if the preferred style is to
276 call into the inferior. The value is simply a string that is
277 copied into the command, so it can be anything that GDB can
278 evaluate to a callable address, not necessarily a function name. */
280 static char *dprintf_function
;
282 /* The channel to use for dynamic printf if the preferred style is to
283 call into the inferior; if a nonempty string, it will be passed to
284 the call as the first argument, with the format string as the
285 second. As with the dprintf function, this can be anything that
286 GDB knows how to evaluate, so in addition to common choices like
287 "stderr", this could be an app-specific expression like
288 "mystreams[curlogger]". */
290 static char *dprintf_channel
;
292 /* True if dprintf commands should continue to operate even if GDB
294 static bool disconnected_dprintf
= true;
296 struct command_line
*
297 breakpoint_commands (struct breakpoint
*b
)
299 return b
->commands
? b
->commands
.get () : NULL
;
302 /* Flag indicating that a command has proceeded the inferior past the
303 current breakpoint. */
305 static bool breakpoint_proceeded
;
308 bpdisp_text (enum bpdisp disp
)
310 /* NOTE: the following values are a part of MI protocol and
311 represent values of 'disp' field returned when inferior stops at
313 static const char * const bpdisps
[] = {"del", "dstp", "dis", "keep"};
315 return bpdisps
[(int) disp
];
318 /* Prototypes for exported functions. */
319 /* If FALSE, gdb will not use hardware support for watchpoints, even
320 if such is available. */
321 static int can_use_hw_watchpoints
;
324 show_can_use_hw_watchpoints (struct ui_file
*file
, int from_tty
,
325 struct cmd_list_element
*c
,
328 fprintf_filtered (file
,
329 _("Debugger's willingness to use "
330 "watchpoint hardware is %s.\n"),
334 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
335 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
336 for unrecognized breakpoint locations.
337 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
338 static enum auto_boolean pending_break_support
;
340 show_pending_break_support (struct ui_file
*file
, int from_tty
,
341 struct cmd_list_element
*c
,
344 fprintf_filtered (file
,
345 _("Debugger's behavior regarding "
346 "pending breakpoints is %s.\n"),
350 /* If true, gdb will automatically use hardware breakpoints for breakpoints
351 set with "break" but falling in read-only memory.
352 If false, gdb will warn about such breakpoints, but won't automatically
353 use hardware breakpoints. */
354 static bool automatic_hardware_breakpoints
;
356 show_automatic_hardware_breakpoints (struct ui_file
*file
, int from_tty
,
357 struct cmd_list_element
*c
,
360 fprintf_filtered (file
,
361 _("Automatic usage of hardware breakpoints is %s.\n"),
365 /* If on, GDB keeps breakpoints inserted even if the inferior is
366 stopped, and immediately inserts any new breakpoints as soon as
367 they're created. If off (default), GDB keeps breakpoints off of
368 the target as long as possible. That is, it delays inserting
369 breakpoints until the next resume, and removes them again when the
370 target fully stops. This is a bit safer in case GDB crashes while
371 processing user input. */
372 static bool always_inserted_mode
= false;
375 show_always_inserted_mode (struct ui_file
*file
, int from_tty
,
376 struct cmd_list_element
*c
, const char *value
)
378 fprintf_filtered (file
, _("Always inserted breakpoint mode is %s.\n"),
382 /* See breakpoint.h. */
385 breakpoints_should_be_inserted_now (void)
387 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
389 /* If breakpoints are global, they should be inserted even if no
390 thread under gdb's control is running, or even if there are
391 no threads under GDB's control yet. */
396 if (always_inserted_mode
)
398 /* The user wants breakpoints inserted even if all threads
403 for (inferior
*inf
: all_inferiors ())
404 if (inf
->has_execution ()
405 && threads_are_executing (inf
->process_target ()))
408 /* Don't remove breakpoints yet if, even though all threads are
409 stopped, we still have events to process. */
410 for (thread_info
*tp
: all_non_exited_threads ())
412 && tp
->suspend
.waitstatus_pending_p
)
418 static const char condition_evaluation_both
[] = "host or target";
420 /* Modes for breakpoint condition evaluation. */
421 static const char condition_evaluation_auto
[] = "auto";
422 static const char condition_evaluation_host
[] = "host";
423 static const char condition_evaluation_target
[] = "target";
424 static const char *const condition_evaluation_enums
[] = {
425 condition_evaluation_auto
,
426 condition_evaluation_host
,
427 condition_evaluation_target
,
431 /* Global that holds the current mode for breakpoint condition evaluation. */
432 static const char *condition_evaluation_mode_1
= condition_evaluation_auto
;
434 /* Global that we use to display information to the user (gets its value from
435 condition_evaluation_mode_1. */
436 static const char *condition_evaluation_mode
= condition_evaluation_auto
;
438 /* Translate a condition evaluation mode MODE into either "host"
439 or "target". This is used mostly to translate from "auto" to the
440 real setting that is being used. It returns the translated
444 translate_condition_evaluation_mode (const char *mode
)
446 if (mode
== condition_evaluation_auto
)
448 if (target_supports_evaluation_of_breakpoint_conditions ())
449 return condition_evaluation_target
;
451 return condition_evaluation_host
;
457 /* Discovers what condition_evaluation_auto translates to. */
460 breakpoint_condition_evaluation_mode (void)
462 return translate_condition_evaluation_mode (condition_evaluation_mode
);
465 /* Return true if GDB should evaluate breakpoint conditions or false
469 gdb_evaluates_breakpoint_condition_p (void)
471 const char *mode
= breakpoint_condition_evaluation_mode ();
473 return (mode
== condition_evaluation_host
);
476 /* Are we executing breakpoint commands? */
477 static int executing_breakpoint_commands
;
479 /* Are overlay event breakpoints enabled? */
480 static int overlay_events_enabled
;
482 /* See description in breakpoint.h. */
483 bool target_exact_watchpoints
= false;
485 /* Walk the following statement or block through all breakpoints.
486 ALL_BREAKPOINTS_SAFE does so even if the statement deletes the
487 current breakpoint. */
489 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
490 for (B = breakpoint_chain; \
491 B ? (TMP=B->next, 1): 0; \
494 /* Similar iterator for the low-level breakpoints. SAFE variant is
495 not provided so update_global_location_list must not be called
496 while executing the block of ALL_BP_LOCATIONS. */
498 #define ALL_BP_LOCATIONS(B,BP_TMP) \
499 for (BP_TMP = bp_locations.data (); \
500 BP_TMP < bp_locations.data () + bp_locations.size () && (B = *BP_TMP);\
503 /* Iterates through locations with address ADDRESS for the currently selected
504 program space. BP_LOCP_TMP points to each object. BP_LOCP_START points
505 to where the loop should start from.
506 If BP_LOCP_START is a NULL pointer, the macro automatically seeks the
507 appropriate location to start with. */
509 #define ALL_BP_LOCATIONS_AT_ADDR(BP_LOCP_TMP, BP_LOCP_START, ADDRESS) \
510 for (BP_LOCP_START = BP_LOCP_START == NULL ? get_first_locp_gte_addr (ADDRESS) : BP_LOCP_START, \
511 BP_LOCP_TMP = BP_LOCP_START; \
513 && (BP_LOCP_TMP < bp_locations.data () + bp_locations.size () \
514 && (*BP_LOCP_TMP)->address == ADDRESS); \
517 /* Chains of all breakpoints defined. */
519 static struct breakpoint
*breakpoint_chain
;
521 /* Breakpoint linked list range. */
523 using breakpoint_range
= next_adapter
<breakpoint
, breakpoint_iterator
>;
525 /* Return a range to iterate over all breakpoints. */
527 static breakpoint_range
530 return breakpoint_range (breakpoint_chain
);
533 /* Breakpoint linked list range, safe against deletion of the current
534 breakpoint while iterating. */
536 using breakpoint_safe_range
= basic_safe_range
<breakpoint_range
>;
538 /* Return a range to iterate over all breakpoints. This range is safe against
539 deletion of the current breakpoint while iterating. */
541 static breakpoint_safe_range
542 all_breakpoints_safe ()
544 return breakpoint_safe_range (all_breakpoints ());
547 /* See breakpoint.h. */
552 return tracepoint_range (breakpoint_chain
);
555 /* Array is sorted by bp_location_is_less_than - primarily by the ADDRESS. */
557 static std::vector
<bp_location
*> bp_locations
;
559 /* Maximum alignment offset between bp_target_info.PLACED_ADDRESS and
560 ADDRESS for the current elements of BP_LOCATIONS which get a valid
561 result from bp_location_has_shadow. You can use it for roughly
562 limiting the subrange of BP_LOCATIONS to scan for shadow bytes for
563 an address you need to read. */
565 static CORE_ADDR bp_locations_placed_address_before_address_max
;
567 /* Maximum offset plus alignment between bp_target_info.PLACED_ADDRESS
568 + bp_target_info.SHADOW_LEN and ADDRESS for the current elements of
569 BP_LOCATIONS which get a valid result from bp_location_has_shadow.
570 You can use it for roughly limiting the subrange of BP_LOCATIONS to
571 scan for shadow bytes for an address you need to read. */
573 static CORE_ADDR bp_locations_shadow_len_after_address_max
;
575 /* The locations that no longer correspond to any breakpoint, unlinked
576 from the bp_locations array, but for which a hit may still be
577 reported by a target. */
578 static std::vector
<bp_location
*> moribund_locations
;
580 /* Number of last breakpoint made. */
582 static int breakpoint_count
;
584 /* The value of `breakpoint_count' before the last command that
585 created breakpoints. If the last (break-like) command created more
586 than one breakpoint, then the difference between BREAKPOINT_COUNT
587 and PREV_BREAKPOINT_COUNT is more than one. */
588 static int prev_breakpoint_count
;
590 /* Number of last tracepoint made. */
592 static int tracepoint_count
;
594 static struct cmd_list_element
*breakpoint_set_cmdlist
;
595 static struct cmd_list_element
*breakpoint_show_cmdlist
;
596 struct cmd_list_element
*save_cmdlist
;
598 /* See declaration at breakpoint.h. */
601 breakpoint_find_if (int (*func
) (struct breakpoint
*b
, void *d
),
604 for (breakpoint
*b
: all_breakpoints ())
605 if (func (b
, user_data
) != 0)
611 /* Return whether a breakpoint is an active enabled breakpoint. */
613 breakpoint_enabled (struct breakpoint
*b
)
615 return (b
->enable_state
== bp_enabled
);
618 /* Set breakpoint count to NUM. */
621 set_breakpoint_count (int num
)
623 prev_breakpoint_count
= breakpoint_count
;
624 breakpoint_count
= num
;
625 set_internalvar_integer (lookup_internalvar ("bpnum"), num
);
628 /* Used by `start_rbreak_breakpoints' below, to record the current
629 breakpoint count before "rbreak" creates any breakpoint. */
630 static int rbreak_start_breakpoint_count
;
632 /* Called at the start an "rbreak" command to record the first
635 scoped_rbreak_breakpoints::scoped_rbreak_breakpoints ()
637 rbreak_start_breakpoint_count
= breakpoint_count
;
640 /* Called at the end of an "rbreak" command to record the last
643 scoped_rbreak_breakpoints::~scoped_rbreak_breakpoints ()
645 prev_breakpoint_count
= rbreak_start_breakpoint_count
;
648 /* Used in run_command to zero the hit count when a new run starts. */
651 clear_breakpoint_hit_counts (void)
653 for (breakpoint
*b
: all_breakpoints ())
658 /* Return the breakpoint with the specified number, or NULL
659 if the number does not refer to an existing breakpoint. */
662 get_breakpoint (int num
)
664 for (breakpoint
*b
: all_breakpoints ())
665 if (b
->number
== num
)
673 /* Mark locations as "conditions have changed" in case the target supports
674 evaluating conditions on its side. */
677 mark_breakpoint_modified (struct breakpoint
*b
)
679 /* This is only meaningful if the target is
680 evaluating conditions and if the user has
681 opted for condition evaluation on the target's
683 if (gdb_evaluates_breakpoint_condition_p ()
684 || !target_supports_evaluation_of_breakpoint_conditions ())
687 if (!is_breakpoint (b
))
690 for (bp_location
*loc
: b
->locations ())
691 loc
->condition_changed
= condition_modified
;
694 /* Mark location as "conditions have changed" in case the target supports
695 evaluating conditions on its side. */
698 mark_breakpoint_location_modified (struct bp_location
*loc
)
700 /* This is only meaningful if the target is
701 evaluating conditions and if the user has
702 opted for condition evaluation on the target's
704 if (gdb_evaluates_breakpoint_condition_p ()
705 || !target_supports_evaluation_of_breakpoint_conditions ())
709 if (!is_breakpoint (loc
->owner
))
712 loc
->condition_changed
= condition_modified
;
715 /* Sets the condition-evaluation mode using the static global
716 condition_evaluation_mode. */
719 set_condition_evaluation_mode (const char *args
, int from_tty
,
720 struct cmd_list_element
*c
)
722 const char *old_mode
, *new_mode
;
724 if ((condition_evaluation_mode_1
== condition_evaluation_target
)
725 && !target_supports_evaluation_of_breakpoint_conditions ())
727 condition_evaluation_mode_1
= condition_evaluation_mode
;
728 warning (_("Target does not support breakpoint condition evaluation.\n"
729 "Using host evaluation mode instead."));
733 new_mode
= translate_condition_evaluation_mode (condition_evaluation_mode_1
);
734 old_mode
= translate_condition_evaluation_mode (condition_evaluation_mode
);
736 /* Flip the switch. Flip it even if OLD_MODE == NEW_MODE as one of the
737 settings was "auto". */
738 condition_evaluation_mode
= condition_evaluation_mode_1
;
740 /* Only update the mode if the user picked a different one. */
741 if (new_mode
!= old_mode
)
743 struct bp_location
*loc
, **loc_tmp
;
744 /* If the user switched to a different evaluation mode, we
745 need to synch the changes with the target as follows:
747 "host" -> "target": Send all (valid) conditions to the target.
748 "target" -> "host": Remove all the conditions from the target.
751 if (new_mode
== condition_evaluation_target
)
753 /* Mark everything modified and synch conditions with the
755 ALL_BP_LOCATIONS (loc
, loc_tmp
)
756 mark_breakpoint_location_modified (loc
);
760 /* Manually mark non-duplicate locations to synch conditions
761 with the target. We do this to remove all the conditions the
762 target knows about. */
763 ALL_BP_LOCATIONS (loc
, loc_tmp
)
764 if (is_breakpoint (loc
->owner
) && loc
->inserted
)
765 loc
->needs_update
= 1;
769 update_global_location_list (UGLL_MAY_INSERT
);
775 /* Shows the current mode of breakpoint condition evaluation. Explicitly shows
776 what "auto" is translating to. */
779 show_condition_evaluation_mode (struct ui_file
*file
, int from_tty
,
780 struct cmd_list_element
*c
, const char *value
)
782 if (condition_evaluation_mode
== condition_evaluation_auto
)
783 fprintf_filtered (file
,
784 _("Breakpoint condition evaluation "
785 "mode is %s (currently %s).\n"),
787 breakpoint_condition_evaluation_mode ());
789 fprintf_filtered (file
, _("Breakpoint condition evaluation mode is %s.\n"),
793 /* A comparison function for bp_location AP and BP that is used by
794 bsearch. This comparison function only cares about addresses, unlike
795 the more general bp_location_is_less_than function. */
798 bp_locations_compare_addrs (const void *ap
, const void *bp
)
800 const struct bp_location
*a
= *(const struct bp_location
**) ap
;
801 const struct bp_location
*b
= *(const struct bp_location
**) bp
;
803 if (a
->address
== b
->address
)
806 return ((a
->address
> b
->address
) - (a
->address
< b
->address
));
809 /* Helper function to skip all bp_locations with addresses
810 less than ADDRESS. It returns the first bp_location that
811 is greater than or equal to ADDRESS. If none is found, just
814 static struct bp_location
**
815 get_first_locp_gte_addr (CORE_ADDR address
)
817 struct bp_location dummy_loc
;
818 struct bp_location
*dummy_locp
= &dummy_loc
;
819 struct bp_location
**locp_found
= NULL
;
821 /* Initialize the dummy location's address field. */
822 dummy_loc
.address
= address
;
824 /* Find a close match to the first location at ADDRESS. */
825 locp_found
= ((struct bp_location
**)
826 bsearch (&dummy_locp
, bp_locations
.data (), bp_locations
.size (),
827 sizeof (struct bp_location
**),
828 bp_locations_compare_addrs
));
830 /* Nothing was found, nothing left to do. */
831 if (locp_found
== NULL
)
834 /* We may have found a location that is at ADDRESS but is not the first in the
835 location's list. Go backwards (if possible) and locate the first one. */
836 while ((locp_found
- 1) >= bp_locations
.data ()
837 && (*(locp_found
- 1))->address
== address
)
843 /* Parse COND_STRING in the context of LOC and set as the condition
844 expression of LOC. BP_NUM is the number of LOC's owner, LOC_NUM is
845 the number of LOC within its owner. In case of parsing error, mark
846 LOC as DISABLED_BY_COND. In case of success, unset DISABLED_BY_COND. */
849 set_breakpoint_location_condition (const char *cond_string
, bp_location
*loc
,
850 int bp_num
, int loc_num
)
852 bool has_junk
= false;
855 expression_up new_exp
= parse_exp_1 (&cond_string
, loc
->address
,
856 block_for_pc (loc
->address
), 0);
857 if (*cond_string
!= 0)
861 loc
->cond
= std::move (new_exp
);
862 if (loc
->disabled_by_cond
&& loc
->enabled
)
863 printf_filtered (_("Breakpoint %d's condition is now valid at "
864 "location %d, enabling.\n"),
867 loc
->disabled_by_cond
= false;
870 catch (const gdb_exception_error
&e
)
874 /* Warn if a user-enabled location is now becoming disabled-by-cond.
875 BP_NUM is 0 if the breakpoint is being defined for the first
876 time using the "break ... if ..." command, and non-zero if
879 warning (_("failed to validate condition at location %d.%d, "
880 "disabling:\n %s"), bp_num
, loc_num
, e
.what ());
882 warning (_("failed to validate condition at location %d, "
883 "disabling:\n %s"), loc_num
, e
.what ());
886 loc
->disabled_by_cond
= true;
890 error (_("Garbage '%s' follows condition"), cond_string
);
894 set_breakpoint_condition (struct breakpoint
*b
, const char *exp
,
895 int from_tty
, bool force
)
899 xfree (b
->cond_string
);
900 b
->cond_string
= nullptr;
902 if (is_watchpoint (b
))
903 static_cast<watchpoint
*> (b
)->cond_exp
.reset ();
907 for (bp_location
*loc
: b
->locations ())
910 if (loc
->disabled_by_cond
&& loc
->enabled
)
911 printf_filtered (_("Breakpoint %d's condition is now valid at "
912 "location %d, enabling.\n"),
914 loc
->disabled_by_cond
= false;
917 /* No need to free the condition agent expression
918 bytecode (if we have one). We will handle this
919 when we go through update_global_location_list. */
924 printf_filtered (_("Breakpoint %d now unconditional.\n"), b
->number
);
928 if (is_watchpoint (b
))
930 innermost_block_tracker tracker
;
931 const char *arg
= exp
;
932 expression_up new_exp
= parse_exp_1 (&arg
, 0, 0, 0, &tracker
);
934 error (_("Junk at end of expression"));
935 watchpoint
*w
= static_cast<watchpoint
*> (b
);
936 w
->cond_exp
= std::move (new_exp
);
937 w
->cond_exp_valid_block
= tracker
.block ();
941 /* Parse and set condition expressions. We make two passes.
942 In the first, we parse the condition string to see if it
943 is valid in at least one location. If so, the condition
944 would be accepted. So we go ahead and set the locations'
945 conditions. In case no valid case is found, we throw
946 the error and the condition string will be rejected.
947 This two-pass approach is taken to avoid setting the
948 state of locations in case of a reject. */
949 for (bp_location
*loc
: b
->locations ())
953 const char *arg
= exp
;
954 parse_exp_1 (&arg
, loc
->address
,
955 block_for_pc (loc
->address
), 0);
957 error (_("Junk at end of expression"));
960 catch (const gdb_exception_error
&e
)
962 /* Condition string is invalid. If this happens to
963 be the last loc, abandon (if not forced) or continue
965 if (loc
->next
== nullptr && !force
)
970 /* If we reach here, the condition is valid at some locations. */
972 for (bp_location
*loc
: b
->locations ())
974 set_breakpoint_location_condition (exp
, loc
, b
->number
, loc_num
);
979 /* We know that the new condition parsed successfully. The
980 condition string of the breakpoint can be safely updated. */
981 xfree (b
->cond_string
);
982 b
->cond_string
= xstrdup (exp
);
983 b
->condition_not_parsed
= 0;
985 mark_breakpoint_modified (b
);
987 gdb::observers::breakpoint_modified
.notify (b
);
990 /* See breakpoint.h. */
993 set_breakpoint_condition (int bpnum
, const char *exp
, int from_tty
,
996 for (breakpoint
*b
: all_breakpoints ())
997 if (b
->number
== bpnum
)
999 /* Check if this breakpoint has a "stop" method implemented in an
1000 extension language. This method and conditions entered into GDB
1001 from the CLI are mutually exclusive. */
1002 const struct extension_language_defn
*extlang
1003 = get_breakpoint_cond_ext_lang (b
, EXT_LANG_NONE
);
1005 if (extlang
!= NULL
)
1007 error (_("Only one stop condition allowed. There is currently"
1008 " a %s stop condition defined for this breakpoint."),
1009 ext_lang_capitalized_name (extlang
));
1011 set_breakpoint_condition (b
, exp
, from_tty
, force
);
1013 if (is_breakpoint (b
))
1014 update_global_location_list (UGLL_MAY_INSERT
);
1019 error (_("No breakpoint number %d."), bpnum
);
1022 /* The options for the "condition" command. */
1024 struct condition_command_opts
1027 bool force_condition
= false;
1030 static const gdb::option::option_def condition_command_option_defs
[] = {
1032 gdb::option::flag_option_def
<condition_command_opts
> {
1034 [] (condition_command_opts
*opts
) { return &opts
->force_condition
; },
1035 N_("Set the condition even if it is invalid for all current locations."),
1040 /* Create an option_def_group for the "condition" options, with
1041 CC_OPTS as context. */
1043 static inline gdb::option::option_def_group
1044 make_condition_command_options_def_group (condition_command_opts
*cc_opts
)
1046 return {{condition_command_option_defs
}, cc_opts
};
1049 /* Completion for the "condition" command. */
1052 condition_completer (struct cmd_list_element
*cmd
,
1053 completion_tracker
&tracker
,
1054 const char *text
, const char * /*word*/)
1056 bool has_no_arguments
= (*text
== '\0');
1057 condition_command_opts cc_opts
;
1058 const auto group
= make_condition_command_options_def_group (&cc_opts
);
1059 if (gdb::option::complete_options
1060 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR
, group
))
1063 text
= skip_spaces (text
);
1064 const char *space
= skip_to_space (text
);
1071 tracker
.advance_custom_word_point_by (1);
1072 /* We don't support completion of history indices. */
1073 if (!isdigit (text
[1]))
1074 complete_internalvar (tracker
, &text
[1]);
1078 /* Suggest the "-force" flag if no arguments are given. If
1079 arguments were passed, they either already include the flag,
1080 or we are beyond the point of suggesting it because it's
1081 positionally the first argument. */
1082 if (has_no_arguments
)
1083 gdb::option::complete_on_all_options (tracker
, group
);
1085 /* We're completing the breakpoint number. */
1086 len
= strlen (text
);
1088 for (breakpoint
*b
: all_breakpoints ())
1092 xsnprintf (number
, sizeof (number
), "%d", b
->number
);
1094 if (strncmp (number
, text
, len
) == 0)
1095 tracker
.add_completion (make_unique_xstrdup (number
));
1101 /* We're completing the expression part. Skip the breakpoint num. */
1102 const char *exp_start
= skip_spaces (space
);
1103 tracker
.advance_custom_word_point_by (exp_start
- text
);
1105 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
1106 expression_completer (cmd
, tracker
, text
, word
);
1109 /* condition N EXP -- set break condition of breakpoint N to EXP. */
1112 condition_command (const char *arg
, int from_tty
)
1118 error_no_arg (_("breakpoint number"));
1122 /* Check if the "-force" flag was passed. */
1123 condition_command_opts cc_opts
;
1124 const auto group
= make_condition_command_options_def_group (&cc_opts
);
1125 gdb::option::process_options
1126 (&p
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR
, group
);
1128 bnum
= get_number (&p
);
1130 error (_("Bad breakpoint argument: '%s'"), arg
);
1132 set_breakpoint_condition (bnum
, p
, from_tty
, cc_opts
.force_condition
);
1135 /* Check that COMMAND do not contain commands that are suitable
1136 only for tracepoints and not suitable for ordinary breakpoints.
1137 Throw if any such commands is found. */
1140 check_no_tracepoint_commands (struct command_line
*commands
)
1142 struct command_line
*c
;
1144 for (c
= commands
; c
; c
= c
->next
)
1146 if (c
->control_type
== while_stepping_control
)
1147 error (_("The 'while-stepping' command can "
1148 "only be used for tracepoints"));
1150 check_no_tracepoint_commands (c
->body_list_0
.get ());
1151 check_no_tracepoint_commands (c
->body_list_1
.get ());
1153 /* Not that command parsing removes leading whitespace and comment
1154 lines and also empty lines. So, we only need to check for
1155 command directly. */
1156 if (strstr (c
->line
, "collect ") == c
->line
)
1157 error (_("The 'collect' command can only be used for tracepoints"));
1159 if (strstr (c
->line
, "teval ") == c
->line
)
1160 error (_("The 'teval' command can only be used for tracepoints"));
1164 struct longjmp_breakpoint
: public breakpoint
1166 ~longjmp_breakpoint () override
;
1169 /* Encapsulate tests for different types of tracepoints. */
1172 is_tracepoint_type (bptype type
)
1174 return (type
== bp_tracepoint
1175 || type
== bp_fast_tracepoint
1176 || type
== bp_static_tracepoint
);
1180 is_longjmp_type (bptype type
)
1182 return type
== bp_longjmp
|| type
== bp_exception
;
1185 /* See breakpoint.h. */
1188 is_tracepoint (const struct breakpoint
*b
)
1190 return is_tracepoint_type (b
->type
);
1193 /* Factory function to create an appropriate instance of breakpoint given
1196 static std::unique_ptr
<breakpoint
>
1197 new_breakpoint_from_type (bptype type
)
1201 if (is_tracepoint_type (type
))
1202 b
= new tracepoint ();
1203 else if (is_longjmp_type (type
))
1204 b
= new longjmp_breakpoint ();
1206 b
= new breakpoint ();
1208 return std::unique_ptr
<breakpoint
> (b
);
1211 /* A helper function that validates that COMMANDS are valid for a
1212 breakpoint. This function will throw an exception if a problem is
1216 validate_commands_for_breakpoint (struct breakpoint
*b
,
1217 struct command_line
*commands
)
1219 if (is_tracepoint (b
))
1221 struct tracepoint
*t
= (struct tracepoint
*) b
;
1222 struct command_line
*c
;
1223 struct command_line
*while_stepping
= 0;
1225 /* Reset the while-stepping step count. The previous commands
1226 might have included a while-stepping action, while the new
1230 /* We need to verify that each top-level element of commands is
1231 valid for tracepoints, that there's at most one
1232 while-stepping element, and that the while-stepping's body
1233 has valid tracing commands excluding nested while-stepping.
1234 We also need to validate the tracepoint action line in the
1235 context of the tracepoint --- validate_actionline actually
1236 has side effects, like setting the tracepoint's
1237 while-stepping STEP_COUNT, in addition to checking if the
1238 collect/teval actions parse and make sense in the
1239 tracepoint's context. */
1240 for (c
= commands
; c
; c
= c
->next
)
1242 if (c
->control_type
== while_stepping_control
)
1244 if (b
->type
== bp_fast_tracepoint
)
1245 error (_("The 'while-stepping' command "
1246 "cannot be used for fast tracepoint"));
1247 else if (b
->type
== bp_static_tracepoint
)
1248 error (_("The 'while-stepping' command "
1249 "cannot be used for static tracepoint"));
1252 error (_("The 'while-stepping' command "
1253 "can be used only once"));
1258 validate_actionline (c
->line
, b
);
1262 struct command_line
*c2
;
1264 gdb_assert (while_stepping
->body_list_1
== nullptr);
1265 c2
= while_stepping
->body_list_0
.get ();
1266 for (; c2
; c2
= c2
->next
)
1268 if (c2
->control_type
== while_stepping_control
)
1269 error (_("The 'while-stepping' command cannot be nested"));
1275 check_no_tracepoint_commands (commands
);
1279 /* Return a vector of all the static tracepoints set at ADDR. The
1280 caller is responsible for releasing the vector. */
1282 std::vector
<breakpoint
*>
1283 static_tracepoints_here (CORE_ADDR addr
)
1285 std::vector
<breakpoint
*> found
;
1287 for (breakpoint
*b
: all_breakpoints ())
1288 if (b
->type
== bp_static_tracepoint
)
1290 for (bp_location
*loc
: b
->locations ())
1291 if (loc
->address
== addr
)
1292 found
.push_back (b
);
1298 /* Set the command list of B to COMMANDS. If breakpoint is tracepoint,
1299 validate that only allowed commands are included. */
1302 breakpoint_set_commands (struct breakpoint
*b
,
1303 counted_command_line
&&commands
)
1305 validate_commands_for_breakpoint (b
, commands
.get ());
1307 b
->commands
= std::move (commands
);
1308 gdb::observers::breakpoint_modified
.notify (b
);
1311 /* Set the internal `silent' flag on the breakpoint. Note that this
1312 is not the same as the "silent" that may appear in the breakpoint's
1316 breakpoint_set_silent (struct breakpoint
*b
, int silent
)
1318 int old_silent
= b
->silent
;
1321 if (old_silent
!= silent
)
1322 gdb::observers::breakpoint_modified
.notify (b
);
1325 /* Set the thread for this breakpoint. If THREAD is -1, make the
1326 breakpoint work for any thread. */
1329 breakpoint_set_thread (struct breakpoint
*b
, int thread
)
1331 int old_thread
= b
->thread
;
1334 if (old_thread
!= thread
)
1335 gdb::observers::breakpoint_modified
.notify (b
);
1338 /* Set the task for this breakpoint. If TASK is 0, make the
1339 breakpoint work for any task. */
1342 breakpoint_set_task (struct breakpoint
*b
, int task
)
1344 int old_task
= b
->task
;
1347 if (old_task
!= task
)
1348 gdb::observers::breakpoint_modified
.notify (b
);
1352 commands_command_1 (const char *arg
, int from_tty
,
1353 struct command_line
*control
)
1355 counted_command_line cmd
;
1356 /* cmd_read will be true once we have read cmd. Note that cmd might still be
1357 NULL after the call to read_command_lines if the user provides an empty
1358 list of command by just typing "end". */
1359 bool cmd_read
= false;
1361 std::string new_arg
;
1363 if (arg
== NULL
|| !*arg
)
1365 /* Argument not explicitly given. Synthesize it. */
1366 if (breakpoint_count
- prev_breakpoint_count
> 1)
1367 new_arg
= string_printf ("%d-%d", prev_breakpoint_count
+ 1,
1369 else if (breakpoint_count
> 0)
1370 new_arg
= string_printf ("%d", breakpoint_count
);
1374 /* Create a copy of ARG. This is needed because the "commands"
1375 command may be coming from a script. In that case, the read
1376 line buffer is going to be overwritten in the lambda of
1377 'map_breakpoint_numbers' below when reading the next line
1378 before we are are done parsing the breakpoint numbers. */
1381 arg
= new_arg
.c_str ();
1383 map_breakpoint_numbers
1384 (arg
, [&] (breakpoint
*b
)
1388 gdb_assert (cmd
== NULL
);
1389 if (control
!= NULL
)
1390 cmd
= control
->body_list_0
;
1394 = string_printf (_("Type commands for breakpoint(s) "
1395 "%s, one per line."),
1398 auto do_validate
= [=] (const char *line
)
1400 validate_actionline (line
, b
);
1402 gdb::function_view
<void (const char *)> validator
;
1403 if (is_tracepoint (b
))
1404 validator
= do_validate
;
1406 cmd
= read_command_lines (str
.c_str (), from_tty
, 1, validator
);
1411 /* If a breakpoint was on the list more than once, we don't need to
1413 if (b
->commands
!= cmd
)
1415 validate_commands_for_breakpoint (b
, cmd
.get ());
1417 gdb::observers::breakpoint_modified
.notify (b
);
1423 commands_command (const char *arg
, int from_tty
)
1425 commands_command_1 (arg
, from_tty
, NULL
);
1428 /* Like commands_command, but instead of reading the commands from
1429 input stream, takes them from an already parsed command structure.
1431 This is used by cli-script.c to DTRT with breakpoint commands
1432 that are part of if and while bodies. */
1433 enum command_control_type
1434 commands_from_control_command (const char *arg
, struct command_line
*cmd
)
1436 commands_command_1 (arg
, 0, cmd
);
1437 return simple_control
;
1440 /* Return non-zero if BL->TARGET_INFO contains valid information. */
1443 bp_location_has_shadow (struct bp_location
*bl
)
1445 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
1449 if (bl
->target_info
.shadow_len
== 0)
1450 /* BL isn't valid, or doesn't shadow memory. */
1455 /* Update BUF, which is LEN bytes read from the target address
1456 MEMADDR, by replacing a memory breakpoint with its shadowed
1459 If READBUF is not NULL, this buffer must not overlap with the of
1460 the breakpoint location's shadow_contents buffer. Otherwise, a
1461 failed assertion internal error will be raised. */
1464 one_breakpoint_xfer_memory (gdb_byte
*readbuf
, gdb_byte
*writebuf
,
1465 const gdb_byte
*writebuf_org
,
1466 ULONGEST memaddr
, LONGEST len
,
1467 struct bp_target_info
*target_info
,
1468 struct gdbarch
*gdbarch
)
1470 /* Now do full processing of the found relevant range of elements. */
1471 CORE_ADDR bp_addr
= 0;
1475 if (!breakpoint_address_match (target_info
->placed_address_space
, 0,
1476 current_program_space
->aspace
, 0))
1478 /* The breakpoint is inserted in a different address space. */
1482 /* Addresses and length of the part of the breakpoint that
1484 bp_addr
= target_info
->placed_address
;
1485 bp_size
= target_info
->shadow_len
;
1487 if (bp_addr
+ bp_size
<= memaddr
)
1489 /* The breakpoint is entirely before the chunk of memory we are
1494 if (bp_addr
>= memaddr
+ len
)
1496 /* The breakpoint is entirely after the chunk of memory we are
1501 /* Offset within shadow_contents. */
1502 if (bp_addr
< memaddr
)
1504 /* Only copy the second part of the breakpoint. */
1505 bp_size
-= memaddr
- bp_addr
;
1506 bptoffset
= memaddr
- bp_addr
;
1510 if (bp_addr
+ bp_size
> memaddr
+ len
)
1512 /* Only copy the first part of the breakpoint. */
1513 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
1516 if (readbuf
!= NULL
)
1518 /* Verify that the readbuf buffer does not overlap with the
1519 shadow_contents buffer. */
1520 gdb_assert (target_info
->shadow_contents
>= readbuf
+ len
1521 || readbuf
>= (target_info
->shadow_contents
1522 + target_info
->shadow_len
));
1524 /* Update the read buffer with this inserted breakpoint's
1526 memcpy (readbuf
+ bp_addr
- memaddr
,
1527 target_info
->shadow_contents
+ bptoffset
, bp_size
);
1531 const unsigned char *bp
;
1532 CORE_ADDR addr
= target_info
->reqstd_address
;
1535 /* Update the shadow with what we want to write to memory. */
1536 memcpy (target_info
->shadow_contents
+ bptoffset
,
1537 writebuf_org
+ bp_addr
- memaddr
, bp_size
);
1539 /* Determine appropriate breakpoint contents and size for this
1541 bp
= gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &placed_size
);
1543 /* Update the final write buffer with this inserted
1544 breakpoint's INSN. */
1545 memcpy (writebuf
+ bp_addr
- memaddr
, bp
+ bptoffset
, bp_size
);
1549 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
1550 by replacing any memory breakpoints with their shadowed contents.
1552 If READBUF is not NULL, this buffer must not overlap with any of
1553 the breakpoint location's shadow_contents buffers. Otherwise,
1554 a failed assertion internal error will be raised.
1556 The range of shadowed area by each bp_location is:
1557 bl->address - bp_locations_placed_address_before_address_max
1558 up to bl->address + bp_locations_shadow_len_after_address_max
1559 The range we were requested to resolve shadows for is:
1560 memaddr ... memaddr + len
1561 Thus the safe cutoff boundaries for performance optimization are
1562 memaddr + len <= (bl->address
1563 - bp_locations_placed_address_before_address_max)
1565 bl->address + bp_locations_shadow_len_after_address_max <= memaddr */
1568 breakpoint_xfer_memory (gdb_byte
*readbuf
, gdb_byte
*writebuf
,
1569 const gdb_byte
*writebuf_org
,
1570 ULONGEST memaddr
, LONGEST len
)
1572 /* Left boundary, right boundary and median element of our binary
1574 unsigned bc_l
, bc_r
, bc
;
1576 /* Find BC_L which is a leftmost element which may affect BUF
1577 content. It is safe to report lower value but a failure to
1578 report higher one. */
1581 bc_r
= bp_locations
.size ();
1582 while (bc_l
+ 1 < bc_r
)
1584 struct bp_location
*bl
;
1586 bc
= (bc_l
+ bc_r
) / 2;
1587 bl
= bp_locations
[bc
];
1589 /* Check first BL->ADDRESS will not overflow due to the added
1590 constant. Then advance the left boundary only if we are sure
1591 the BC element can in no way affect the BUF content (MEMADDR
1592 to MEMADDR + LEN range).
1594 Use the BP_LOCATIONS_SHADOW_LEN_AFTER_ADDRESS_MAX safety
1595 offset so that we cannot miss a breakpoint with its shadow
1596 range tail still reaching MEMADDR. */
1598 if ((bl
->address
+ bp_locations_shadow_len_after_address_max
1600 && (bl
->address
+ bp_locations_shadow_len_after_address_max
1607 /* Due to the binary search above, we need to make sure we pick the
1608 first location that's at BC_L's address. E.g., if there are
1609 multiple locations at the same address, BC_L may end up pointing
1610 at a duplicate location, and miss the "master"/"inserted"
1611 location. Say, given locations L1, L2 and L3 at addresses A and
1614 L1@A, L2@A, L3@B, ...
1616 BC_L could end up pointing at location L2, while the "master"
1617 location could be L1. Since the `loc->inserted' flag is only set
1618 on "master" locations, we'd forget to restore the shadow of L1
1621 && bp_locations
[bc_l
]->address
== bp_locations
[bc_l
- 1]->address
)
1624 /* Now do full processing of the found relevant range of elements. */
1626 for (bc
= bc_l
; bc
< bp_locations
.size (); bc
++)
1628 struct bp_location
*bl
= bp_locations
[bc
];
1630 /* bp_location array has BL->OWNER always non-NULL. */
1631 if (bl
->owner
->type
== bp_none
)
1632 warning (_("reading through apparently deleted breakpoint #%d?"),
1635 /* Performance optimization: any further element can no longer affect BUF
1638 if (bl
->address
>= bp_locations_placed_address_before_address_max
1639 && memaddr
+ len
<= (bl
->address
1640 - bp_locations_placed_address_before_address_max
))
1643 if (!bp_location_has_shadow (bl
))
1646 one_breakpoint_xfer_memory (readbuf
, writebuf
, writebuf_org
,
1647 memaddr
, len
, &bl
->target_info
, bl
->gdbarch
);
1651 /* See breakpoint.h. */
1654 is_breakpoint (const struct breakpoint
*bpt
)
1656 return (bpt
->type
== bp_breakpoint
1657 || bpt
->type
== bp_hardware_breakpoint
1658 || bpt
->type
== bp_dprintf
);
1661 /* Return true if BPT is of any hardware watchpoint kind. */
1664 is_hardware_watchpoint (const struct breakpoint
*bpt
)
1666 return (bpt
->type
== bp_hardware_watchpoint
1667 || bpt
->type
== bp_read_watchpoint
1668 || bpt
->type
== bp_access_watchpoint
);
1671 /* See breakpoint.h. */
1674 is_watchpoint (const struct breakpoint
*bpt
)
1676 return (is_hardware_watchpoint (bpt
)
1677 || bpt
->type
== bp_watchpoint
);
1680 /* Returns true if the current thread and its running state are safe
1681 to evaluate or update watchpoint B. Watchpoints on local
1682 expressions need to be evaluated in the context of the thread that
1683 was current when the watchpoint was created, and, that thread needs
1684 to be stopped to be able to select the correct frame context.
1685 Watchpoints on global expressions can be evaluated on any thread,
1686 and in any state. It is presently left to the target allowing
1687 memory accesses when threads are running. */
1690 watchpoint_in_thread_scope (struct watchpoint
*b
)
1692 return (b
->pspace
== current_program_space
1693 && (b
->watchpoint_thread
== null_ptid
1694 || (inferior_ptid
== b
->watchpoint_thread
1695 && !inferior_thread ()->executing
)));
1698 /* Set watchpoint B to disp_del_at_next_stop, even including its possible
1699 associated bp_watchpoint_scope breakpoint. */
1702 watchpoint_del_at_next_stop (struct watchpoint
*w
)
1704 if (w
->related_breakpoint
!= w
)
1706 gdb_assert (w
->related_breakpoint
->type
== bp_watchpoint_scope
);
1707 gdb_assert (w
->related_breakpoint
->related_breakpoint
== w
);
1708 w
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
1709 w
->related_breakpoint
->related_breakpoint
= w
->related_breakpoint
;
1710 w
->related_breakpoint
= w
;
1712 w
->disposition
= disp_del_at_next_stop
;
1715 /* Extract a bitfield value from value VAL using the bit parameters contained in
1718 static struct value
*
1719 extract_bitfield_from_watchpoint_value (struct watchpoint
*w
, struct value
*val
)
1721 struct value
*bit_val
;
1726 bit_val
= allocate_value (value_type (val
));
1728 unpack_value_bitfield (bit_val
,
1731 value_contents_for_printing (val
),
1738 /* Allocate a dummy location and add it to B, which must be a software
1739 watchpoint. This is required because even if a software watchpoint
1740 is not watching any memory, bpstat_stop_status requires a location
1741 to be able to report stops. */
1744 software_watchpoint_add_no_memory_location (struct breakpoint
*b
,
1745 struct program_space
*pspace
)
1747 gdb_assert (b
->type
== bp_watchpoint
&& b
->loc
== NULL
);
1749 b
->loc
= allocate_bp_location (b
);
1750 b
->loc
->pspace
= pspace
;
1751 b
->loc
->address
= -1;
1752 b
->loc
->length
= -1;
1755 /* Returns true if B is a software watchpoint that is not watching any
1756 memory (e.g., "watch $pc"). */
1759 is_no_memory_software_watchpoint (struct breakpoint
*b
)
1761 return (b
->type
== bp_watchpoint
1763 && b
->loc
->next
== NULL
1764 && b
->loc
->address
== -1
1765 && b
->loc
->length
== -1);
1768 /* Assuming that B is a watchpoint:
1769 - Reparse watchpoint expression, if REPARSE is non-zero
1770 - Evaluate expression and store the result in B->val
1771 - Evaluate the condition if there is one, and store the result
1773 - Update the list of values that must be watched in B->loc.
1775 If the watchpoint disposition is disp_del_at_next_stop, then do
1776 nothing. If this is local watchpoint that is out of scope, delete
1779 Even with `set breakpoint always-inserted on' the watchpoints are
1780 removed + inserted on each stop here. Normal breakpoints must
1781 never be removed because they might be missed by a running thread
1782 when debugging in non-stop mode. On the other hand, hardware
1783 watchpoints (is_hardware_watchpoint; processed here) are specific
1784 to each LWP since they are stored in each LWP's hardware debug
1785 registers. Therefore, such LWP must be stopped first in order to
1786 be able to modify its hardware watchpoints.
1788 Hardware watchpoints must be reset exactly once after being
1789 presented to the user. It cannot be done sooner, because it would
1790 reset the data used to present the watchpoint hit to the user. And
1791 it must not be done later because it could display the same single
1792 watchpoint hit during multiple GDB stops. Note that the latter is
1793 relevant only to the hardware watchpoint types bp_read_watchpoint
1794 and bp_access_watchpoint. False hit by bp_hardware_watchpoint is
1795 not user-visible - its hit is suppressed if the memory content has
1798 The following constraints influence the location where we can reset
1799 hardware watchpoints:
1801 * target_stopped_by_watchpoint and target_stopped_data_address are
1802 called several times when GDB stops.
1805 * Multiple hardware watchpoints can be hit at the same time,
1806 causing GDB to stop. GDB only presents one hardware watchpoint
1807 hit at a time as the reason for stopping, and all the other hits
1808 are presented later, one after the other, each time the user
1809 requests the execution to be resumed. Execution is not resumed
1810 for the threads still having pending hit event stored in
1811 LWP_INFO->STATUS. While the watchpoint is already removed from
1812 the inferior on the first stop the thread hit event is kept being
1813 reported from its cached value by linux_nat_stopped_data_address
1814 until the real thread resume happens after the watchpoint gets
1815 presented and thus its LWP_INFO->STATUS gets reset.
1817 Therefore the hardware watchpoint hit can get safely reset on the
1818 watchpoint removal from inferior. */
1821 update_watchpoint (struct watchpoint
*b
, int reparse
)
1823 int within_current_scope
;
1824 struct frame_id saved_frame_id
;
1827 /* If this is a local watchpoint, we only want to check if the
1828 watchpoint frame is in scope if the current thread is the thread
1829 that was used to create the watchpoint. */
1830 if (!watchpoint_in_thread_scope (b
))
1833 if (b
->disposition
== disp_del_at_next_stop
)
1838 /* Determine if the watchpoint is within scope. */
1839 if (b
->exp_valid_block
== NULL
)
1840 within_current_scope
= 1;
1843 struct frame_info
*fi
= get_current_frame ();
1844 struct gdbarch
*frame_arch
= get_frame_arch (fi
);
1845 CORE_ADDR frame_pc
= get_frame_pc (fi
);
1847 /* If we're at a point where the stack has been destroyed
1848 (e.g. in a function epilogue), unwinding may not work
1849 properly. Do not attempt to recreate locations at this
1850 point. See similar comments in watchpoint_check. */
1851 if (gdbarch_stack_frame_destroyed_p (frame_arch
, frame_pc
))
1854 /* Save the current frame's ID so we can restore it after
1855 evaluating the watchpoint expression on its own frame. */
1856 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
1857 took a frame parameter, so that we didn't have to change the
1860 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
1862 fi
= frame_find_by_id (b
->watchpoint_frame
);
1863 within_current_scope
= (fi
!= NULL
);
1864 if (within_current_scope
)
1868 /* We don't free locations. They are stored in the bp_location array
1869 and update_global_location_list will eventually delete them and
1870 remove breakpoints if needed. */
1873 if (within_current_scope
&& reparse
)
1878 s
= b
->exp_string_reparse
? b
->exp_string_reparse
: b
->exp_string
;
1879 b
->exp
= parse_exp_1 (&s
, 0, b
->exp_valid_block
, 0);
1880 /* If the meaning of expression itself changed, the old value is
1881 no longer relevant. We don't want to report a watchpoint hit
1882 to the user when the old value and the new value may actually
1883 be completely different objects. */
1885 b
->val_valid
= false;
1887 /* Note that unlike with breakpoints, the watchpoint's condition
1888 expression is stored in the breakpoint object, not in the
1889 locations (re)created below. */
1890 if (b
->cond_string
!= NULL
)
1892 b
->cond_exp
.reset ();
1895 b
->cond_exp
= parse_exp_1 (&s
, 0, b
->cond_exp_valid_block
, 0);
1899 /* If we failed to parse the expression, for example because
1900 it refers to a global variable in a not-yet-loaded shared library,
1901 don't try to insert watchpoint. We don't automatically delete
1902 such watchpoint, though, since failure to parse expression
1903 is different from out-of-scope watchpoint. */
1904 if (!target_has_execution ())
1906 /* Without execution, memory can't change. No use to try and
1907 set watchpoint locations. The watchpoint will be reset when
1908 the target gains execution, through breakpoint_re_set. */
1909 if (!can_use_hw_watchpoints
)
1911 if (b
->ops
->works_in_software_mode (b
))
1912 b
->type
= bp_watchpoint
;
1914 error (_("Can't set read/access watchpoint when "
1915 "hardware watchpoints are disabled."));
1918 else if (within_current_scope
&& b
->exp
)
1920 std::vector
<value_ref_ptr
> val_chain
;
1921 struct value
*v
, *result
;
1922 struct program_space
*frame_pspace
;
1924 fetch_subexp_value (b
->exp
.get (), b
->exp
->op
.get (), &v
, &result
,
1927 /* Avoid setting b->val if it's already set. The meaning of
1928 b->val is 'the last value' user saw, and we should update
1929 it only if we reported that last value to user. As it
1930 happens, the code that reports it updates b->val directly.
1931 We don't keep track of the memory value for masked
1933 if (!b
->val_valid
&& !is_masked_watchpoint (b
))
1935 if (b
->val_bitsize
!= 0)
1936 v
= extract_bitfield_from_watchpoint_value (b
, v
);
1937 b
->val
= release_value (v
);
1938 b
->val_valid
= true;
1941 frame_pspace
= get_frame_program_space (get_selected_frame (NULL
));
1943 /* Look at each value on the value chain. */
1944 gdb_assert (!val_chain
.empty ());
1945 for (const value_ref_ptr
&iter
: val_chain
)
1949 /* If it's a memory location, and GDB actually needed
1950 its contents to evaluate the expression, then we
1951 must watch it. If the first value returned is
1952 still lazy, that means an error occurred reading it;
1953 watch it anyway in case it becomes readable. */
1954 if (VALUE_LVAL (v
) == lval_memory
1955 && (v
== val_chain
[0] || ! value_lazy (v
)))
1957 struct type
*vtype
= check_typedef (value_type (v
));
1959 /* We only watch structs and arrays if user asked
1960 for it explicitly, never if they just happen to
1961 appear in the middle of some value chain. */
1963 || (vtype
->code () != TYPE_CODE_STRUCT
1964 && vtype
->code () != TYPE_CODE_ARRAY
))
1967 enum target_hw_bp_type type
;
1968 struct bp_location
*loc
, **tmp
;
1969 int bitpos
= 0, bitsize
= 0;
1971 if (value_bitsize (v
) != 0)
1973 /* Extract the bit parameters out from the bitfield
1975 bitpos
= value_bitpos (v
);
1976 bitsize
= value_bitsize (v
);
1978 else if (v
== result
&& b
->val_bitsize
!= 0)
1980 /* If VAL_BITSIZE != 0 then RESULT is actually a bitfield
1981 lvalue whose bit parameters are saved in the fields
1982 VAL_BITPOS and VAL_BITSIZE. */
1983 bitpos
= b
->val_bitpos
;
1984 bitsize
= b
->val_bitsize
;
1987 addr
= value_address (v
);
1990 /* Skip the bytes that don't contain the bitfield. */
1995 if (b
->type
== bp_read_watchpoint
)
1997 else if (b
->type
== bp_access_watchpoint
)
2000 loc
= allocate_bp_location (b
);
2001 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
2004 loc
->gdbarch
= value_type (v
)->arch ();
2006 loc
->pspace
= frame_pspace
;
2007 loc
->address
= address_significant (loc
->gdbarch
, addr
);
2011 /* Just cover the bytes that make up the bitfield. */
2012 loc
->length
= ((bitpos
% 8) + bitsize
+ 7) / 8;
2015 loc
->length
= TYPE_LENGTH (value_type (v
));
2017 loc
->watchpoint_type
= type
;
2022 /* Change the type of breakpoint between hardware assisted or
2023 an ordinary watchpoint depending on the hardware support
2024 and free hardware slots. REPARSE is set when the inferior
2029 enum bp_loc_type loc_type
;
2031 reg_cnt
= can_use_hardware_watchpoint (val_chain
);
2035 int i
, target_resources_ok
, other_type_used
;
2038 /* Use an exact watchpoint when there's only one memory region to be
2039 watched, and only one debug register is needed to watch it. */
2040 b
->exact
= target_exact_watchpoints
&& reg_cnt
== 1;
2042 /* We need to determine how many resources are already
2043 used for all other hardware watchpoints plus this one
2044 to see if we still have enough resources to also fit
2045 this watchpoint in as well. */
2047 /* If this is a software watchpoint, we try to turn it
2048 to a hardware one -- count resources as if B was of
2049 hardware watchpoint type. */
2051 if (type
== bp_watchpoint
)
2052 type
= bp_hardware_watchpoint
;
2054 /* This watchpoint may or may not have been placed on
2055 the list yet at this point (it won't be in the list
2056 if we're trying to create it for the first time,
2057 through watch_command), so always account for it
2060 /* Count resources used by all watchpoints except B. */
2061 i
= hw_watchpoint_used_count_others (b
, type
, &other_type_used
);
2063 /* Add in the resources needed for B. */
2064 i
+= hw_watchpoint_use_count (b
);
2067 = target_can_use_hardware_watchpoint (type
, i
, other_type_used
);
2068 if (target_resources_ok
<= 0)
2070 int sw_mode
= b
->ops
->works_in_software_mode (b
);
2072 if (target_resources_ok
== 0 && !sw_mode
)
2073 error (_("Target does not support this type of "
2074 "hardware watchpoint."));
2075 else if (target_resources_ok
< 0 && !sw_mode
)
2076 error (_("There are not enough available hardware "
2077 "resources for this watchpoint."));
2079 /* Downgrade to software watchpoint. */
2080 b
->type
= bp_watchpoint
;
2084 /* If this was a software watchpoint, we've just
2085 found we have enough resources to turn it to a
2086 hardware watchpoint. Otherwise, this is a
2091 else if (!b
->ops
->works_in_software_mode (b
))
2093 if (!can_use_hw_watchpoints
)
2094 error (_("Can't set read/access watchpoint when "
2095 "hardware watchpoints are disabled."));
2097 error (_("Expression cannot be implemented with "
2098 "read/access watchpoint."));
2101 b
->type
= bp_watchpoint
;
2103 loc_type
= (b
->type
== bp_watchpoint
? bp_loc_other
2104 : bp_loc_hardware_watchpoint
);
2105 for (bp_location
*bl
: b
->locations ())
2106 bl
->loc_type
= loc_type
;
2109 /* If a software watchpoint is not watching any memory, then the
2110 above left it without any location set up. But,
2111 bpstat_stop_status requires a location to be able to report
2112 stops, so make sure there's at least a dummy one. */
2113 if (b
->type
== bp_watchpoint
&& b
->loc
== NULL
)
2114 software_watchpoint_add_no_memory_location (b
, frame_pspace
);
2116 else if (!within_current_scope
)
2118 printf_filtered (_("\
2119 Watchpoint %d deleted because the program has left the block\n\
2120 in which its expression is valid.\n"),
2122 watchpoint_del_at_next_stop (b
);
2125 /* Restore the selected frame. */
2127 select_frame (frame_find_by_id (saved_frame_id
));
2131 /* Returns 1 iff breakpoint location should be
2132 inserted in the inferior. We don't differentiate the type of BL's owner
2133 (breakpoint vs. tracepoint), although insert_location in tracepoint's
2134 breakpoint_ops is not defined, because in insert_bp_location,
2135 tracepoint's insert_location will not be called. */
2137 should_be_inserted (struct bp_location
*bl
)
2139 if (bl
->owner
== NULL
|| !breakpoint_enabled (bl
->owner
))
2142 if (bl
->owner
->disposition
== disp_del_at_next_stop
)
2145 if (!bl
->enabled
|| bl
->disabled_by_cond
2146 || bl
->shlib_disabled
|| bl
->duplicate
)
2149 if (user_breakpoint_p (bl
->owner
) && bl
->pspace
->executing_startup
)
2152 /* This is set for example, when we're attached to the parent of a
2153 vfork, and have detached from the child. The child is running
2154 free, and we expect it to do an exec or exit, at which point the
2155 OS makes the parent schedulable again (and the target reports
2156 that the vfork is done). Until the child is done with the shared
2157 memory region, do not insert breakpoints in the parent, otherwise
2158 the child could still trip on the parent's breakpoints. Since
2159 the parent is blocked anyway, it won't miss any breakpoint. */
2160 if (bl
->pspace
->breakpoints_not_allowed
)
2163 /* Don't insert a breakpoint if we're trying to step past its
2164 location, except if the breakpoint is a single-step breakpoint,
2165 and the breakpoint's thread is the thread which is stepping past
2167 if ((bl
->loc_type
== bp_loc_software_breakpoint
2168 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
2169 && stepping_past_instruction_at (bl
->pspace
->aspace
,
2171 /* The single-step breakpoint may be inserted at the location
2172 we're trying to step if the instruction branches to itself.
2173 However, the instruction won't be executed at all and it may
2174 break the semantics of the instruction, for example, the
2175 instruction is a conditional branch or updates some flags.
2176 We can't fix it unless GDB is able to emulate the instruction
2177 or switch to displaced stepping. */
2178 && !(bl
->owner
->type
== bp_single_step
2179 && thread_is_stepping_over_breakpoint (bl
->owner
->thread
)))
2181 infrun_debug_printf ("skipping breakpoint: stepping past insn at: %s",
2182 paddress (bl
->gdbarch
, bl
->address
));
2186 /* Don't insert watchpoints if we're trying to step past the
2187 instruction that triggered one. */
2188 if ((bl
->loc_type
== bp_loc_hardware_watchpoint
)
2189 && stepping_past_nonsteppable_watchpoint ())
2191 infrun_debug_printf ("stepping past non-steppable watchpoint. "
2192 "skipping watchpoint at %s:%d",
2193 paddress (bl
->gdbarch
, bl
->address
), bl
->length
);
2200 /* Same as should_be_inserted but does the check assuming
2201 that the location is not duplicated. */
2204 unduplicated_should_be_inserted (struct bp_location
*bl
)
2207 const int save_duplicate
= bl
->duplicate
;
2210 result
= should_be_inserted (bl
);
2211 bl
->duplicate
= save_duplicate
;
2215 /* Parses a conditional described by an expression COND into an
2216 agent expression bytecode suitable for evaluation
2217 by the bytecode interpreter. Return NULL if there was
2218 any error during parsing. */
2220 static agent_expr_up
2221 parse_cond_to_aexpr (CORE_ADDR scope
, struct expression
*cond
)
2226 agent_expr_up aexpr
;
2228 /* We don't want to stop processing, so catch any errors
2229 that may show up. */
2232 aexpr
= gen_eval_for_expr (scope
, cond
);
2235 catch (const gdb_exception_error
&ex
)
2237 /* If we got here, it means the condition could not be parsed to a valid
2238 bytecode expression and thus can't be evaluated on the target's side.
2239 It's no use iterating through the conditions. */
2242 /* We have a valid agent expression. */
2246 /* Based on location BL, create a list of breakpoint conditions to be
2247 passed on to the target. If we have duplicated locations with different
2248 conditions, we will add such conditions to the list. The idea is that the
2249 target will evaluate the list of conditions and will only notify GDB when
2250 one of them is true. */
2253 build_target_condition_list (struct bp_location
*bl
)
2255 struct bp_location
**locp
= NULL
, **loc2p
;
2256 int null_condition_or_parse_error
= 0;
2257 int modified
= bl
->needs_update
;
2258 struct bp_location
*loc
;
2260 /* Release conditions left over from a previous insert. */
2261 bl
->target_info
.conditions
.clear ();
2263 /* This is only meaningful if the target is
2264 evaluating conditions and if the user has
2265 opted for condition evaluation on the target's
2267 if (gdb_evaluates_breakpoint_condition_p ()
2268 || !target_supports_evaluation_of_breakpoint_conditions ())
2271 /* Do a first pass to check for locations with no assigned
2272 conditions or conditions that fail to parse to a valid agent
2273 expression bytecode. If any of these happen, then it's no use to
2274 send conditions to the target since this location will always
2275 trigger and generate a response back to GDB. Note we consider
2276 all locations at the same address irrespective of type, i.e.,
2277 even if the locations aren't considered duplicates (e.g.,
2278 software breakpoint and hardware breakpoint at the same
2280 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2283 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2287 /* Re-parse the conditions since something changed. In that
2288 case we already freed the condition bytecodes (see
2289 force_breakpoint_reinsertion). We just
2290 need to parse the condition to bytecodes again. */
2291 loc
->cond_bytecode
= parse_cond_to_aexpr (bl
->address
,
2295 /* If we have a NULL bytecode expression, it means something
2296 went wrong or we have a null condition expression. */
2297 if (!loc
->cond_bytecode
)
2299 null_condition_or_parse_error
= 1;
2305 /* If any of these happened, it means we will have to evaluate the conditions
2306 for the location's address on gdb's side. It is no use keeping bytecodes
2307 for all the other duplicate locations, thus we free all of them here.
2309 This is so we have a finer control over which locations' conditions are
2310 being evaluated by GDB or the remote stub. */
2311 if (null_condition_or_parse_error
)
2313 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2316 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2318 /* Only go as far as the first NULL bytecode is
2320 if (!loc
->cond_bytecode
)
2323 loc
->cond_bytecode
.reset ();
2328 /* No NULL conditions or failed bytecode generation. Build a
2329 condition list for this location's address. If we have software
2330 and hardware locations at the same address, they aren't
2331 considered duplicates, but we still marge all the conditions
2332 anyway, as it's simpler, and doesn't really make a practical
2334 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2338 && is_breakpoint (loc
->owner
)
2339 && loc
->pspace
->num
== bl
->pspace
->num
2340 && loc
->owner
->enable_state
== bp_enabled
2342 && !loc
->disabled_by_cond
)
2344 /* Add the condition to the vector. This will be used later
2345 to send the conditions to the target. */
2346 bl
->target_info
.conditions
.push_back (loc
->cond_bytecode
.get ());
2353 /* Parses a command described by string CMD into an agent expression
2354 bytecode suitable for evaluation by the bytecode interpreter.
2355 Return NULL if there was any error during parsing. */
2357 static agent_expr_up
2358 parse_cmd_to_aexpr (CORE_ADDR scope
, char *cmd
)
2360 const char *cmdrest
;
2361 const char *format_start
, *format_end
;
2362 struct gdbarch
*gdbarch
= get_current_arch ();
2369 if (*cmdrest
== ',')
2371 cmdrest
= skip_spaces (cmdrest
);
2373 if (*cmdrest
++ != '"')
2374 error (_("No format string following the location"));
2376 format_start
= cmdrest
;
2378 format_pieces
fpieces (&cmdrest
);
2380 format_end
= cmdrest
;
2382 if (*cmdrest
++ != '"')
2383 error (_("Bad format string, non-terminated '\"'."));
2385 cmdrest
= skip_spaces (cmdrest
);
2387 if (!(*cmdrest
== ',' || *cmdrest
== '\0'))
2388 error (_("Invalid argument syntax"));
2390 if (*cmdrest
== ',')
2392 cmdrest
= skip_spaces (cmdrest
);
2394 /* For each argument, make an expression. */
2396 std::vector
<struct expression
*> argvec
;
2397 while (*cmdrest
!= '\0')
2402 expression_up expr
= parse_exp_1 (&cmd1
, scope
, block_for_pc (scope
), 1);
2403 argvec
.push_back (expr
.release ());
2405 if (*cmdrest
== ',')
2409 agent_expr_up aexpr
;
2411 /* We don't want to stop processing, so catch any errors
2412 that may show up. */
2415 aexpr
= gen_printf (scope
, gdbarch
, 0, 0,
2416 format_start
, format_end
- format_start
,
2417 argvec
.size (), argvec
.data ());
2419 catch (const gdb_exception_error
&ex
)
2421 /* If we got here, it means the command could not be parsed to a valid
2422 bytecode expression and thus can't be evaluated on the target's side.
2423 It's no use iterating through the other commands. */
2426 /* We have a valid agent expression, return it. */
2430 /* Based on location BL, create a list of breakpoint commands to be
2431 passed on to the target. If we have duplicated locations with
2432 different commands, we will add any such to the list. */
2435 build_target_command_list (struct bp_location
*bl
)
2437 struct bp_location
**locp
= NULL
, **loc2p
;
2438 int null_command_or_parse_error
= 0;
2439 int modified
= bl
->needs_update
;
2440 struct bp_location
*loc
;
2442 /* Clear commands left over from a previous insert. */
2443 bl
->target_info
.tcommands
.clear ();
2445 if (!target_can_run_breakpoint_commands ())
2448 /* For now, limit to agent-style dprintf breakpoints. */
2449 if (dprintf_style
!= dprintf_style_agent
)
2452 /* For now, if we have any location at the same address that isn't a
2453 dprintf, don't install the target-side commands, as that would
2454 make the breakpoint not be reported to the core, and we'd lose
2456 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2459 if (is_breakpoint (loc
->owner
)
2460 && loc
->pspace
->num
== bl
->pspace
->num
2461 && loc
->owner
->type
!= bp_dprintf
)
2465 /* Do a first pass to check for locations with no assigned
2466 conditions or conditions that fail to parse to a valid agent expression
2467 bytecode. If any of these happen, then it's no use to send conditions
2468 to the target since this location will always trigger and generate a
2469 response back to GDB. */
2470 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2473 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2477 /* Re-parse the commands since something changed. In that
2478 case we already freed the command bytecodes (see
2479 force_breakpoint_reinsertion). We just
2480 need to parse the command to bytecodes again. */
2482 = parse_cmd_to_aexpr (bl
->address
,
2483 loc
->owner
->extra_string
);
2486 /* If we have a NULL bytecode expression, it means something
2487 went wrong or we have a null command expression. */
2488 if (!loc
->cmd_bytecode
)
2490 null_command_or_parse_error
= 1;
2496 /* If anything failed, then we're not doing target-side commands,
2498 if (null_command_or_parse_error
)
2500 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2503 if (is_breakpoint (loc
->owner
)
2504 && loc
->pspace
->num
== bl
->pspace
->num
)
2506 /* Only go as far as the first NULL bytecode is
2508 if (loc
->cmd_bytecode
== NULL
)
2511 loc
->cmd_bytecode
.reset ();
2516 /* No NULL commands or failed bytecode generation. Build a command
2517 list for all duplicate locations at this location's address.
2518 Note that here we must care for whether the breakpoint location
2519 types are considered duplicates, otherwise, say, if we have a
2520 software and hardware location at the same address, the target
2521 could end up running the commands twice. For the moment, we only
2522 support targets-side commands with dprintf, but it doesn't hurt
2523 to be pedantically correct in case that changes. */
2524 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2527 if (breakpoint_locations_match (bl
, loc
)
2528 && loc
->owner
->extra_string
2529 && is_breakpoint (loc
->owner
)
2530 && loc
->pspace
->num
== bl
->pspace
->num
2531 && loc
->owner
->enable_state
== bp_enabled
2533 && !loc
->disabled_by_cond
)
2535 /* Add the command to the vector. This will be used later
2536 to send the commands to the target. */
2537 bl
->target_info
.tcommands
.push_back (loc
->cmd_bytecode
.get ());
2541 bl
->target_info
.persist
= 0;
2542 /* Maybe flag this location as persistent. */
2543 if (bl
->owner
->type
== bp_dprintf
&& disconnected_dprintf
)
2544 bl
->target_info
.persist
= 1;
2547 /* Return the kind of breakpoint on address *ADDR. Get the kind
2548 of breakpoint according to ADDR except single-step breakpoint.
2549 Get the kind of single-step breakpoint according to the current
2553 breakpoint_kind (struct bp_location
*bl
, CORE_ADDR
*addr
)
2555 if (bl
->owner
->type
== bp_single_step
)
2557 struct thread_info
*thr
= find_thread_global_id (bl
->owner
->thread
);
2558 struct regcache
*regcache
;
2560 regcache
= get_thread_regcache (thr
);
2562 return gdbarch_breakpoint_kind_from_current_state (bl
->gdbarch
,
2566 return gdbarch_breakpoint_kind_from_pc (bl
->gdbarch
, addr
);
2569 /* Insert a low-level "breakpoint" of some type. BL is the breakpoint
2570 location. Any error messages are printed to TMP_ERROR_STREAM; and
2571 DISABLED_BREAKS, and HW_BREAKPOINT_ERROR are used to report problems.
2572 Returns 0 for success, 1 if the bp_location type is not supported or
2575 NOTE drow/2003-09-09: This routine could be broken down to an
2576 object-style method for each breakpoint or catchpoint type. */
2578 insert_bp_location (struct bp_location
*bl
,
2579 struct ui_file
*tmp_error_stream
,
2580 int *disabled_breaks
,
2581 int *hw_breakpoint_error
,
2582 int *hw_bp_error_explained_already
)
2584 gdb_exception bp_excpt
;
2586 if (!should_be_inserted (bl
) || (bl
->inserted
&& !bl
->needs_update
))
2589 /* Note we don't initialize bl->target_info, as that wipes out
2590 the breakpoint location's shadow_contents if the breakpoint
2591 is still inserted at that location. This in turn breaks
2592 target_read_memory which depends on these buffers when
2593 a memory read is requested at the breakpoint location:
2594 Once the target_info has been wiped, we fail to see that
2595 we have a breakpoint inserted at that address and thus
2596 read the breakpoint instead of returning the data saved in
2597 the breakpoint location's shadow contents. */
2598 bl
->target_info
.reqstd_address
= bl
->address
;
2599 bl
->target_info
.placed_address_space
= bl
->pspace
->aspace
;
2600 bl
->target_info
.length
= bl
->length
;
2602 /* When working with target-side conditions, we must pass all the conditions
2603 for the same breakpoint address down to the target since GDB will not
2604 insert those locations. With a list of breakpoint conditions, the target
2605 can decide when to stop and notify GDB. */
2607 if (is_breakpoint (bl
->owner
))
2609 build_target_condition_list (bl
);
2610 build_target_command_list (bl
);
2611 /* Reset the modification marker. */
2612 bl
->needs_update
= 0;
2615 /* If "set breakpoint auto-hw" is "on" and a software breakpoint was
2616 set at a read-only address, then a breakpoint location will have
2617 been changed to hardware breakpoint before we get here. If it is
2618 "off" however, error out before actually trying to insert the
2619 breakpoint, with a nicer error message. */
2620 if (bl
->loc_type
== bp_loc_software_breakpoint
2621 && !automatic_hardware_breakpoints
)
2623 mem_region
*mr
= lookup_mem_region (bl
->address
);
2625 if (mr
!= nullptr && mr
->attrib
.mode
!= MEM_RW
)
2627 fprintf_unfiltered (tmp_error_stream
,
2628 _("Cannot insert breakpoint %d.\n"
2629 "Cannot set software breakpoint "
2630 "at read-only address %s\n"),
2632 paddress (bl
->gdbarch
, bl
->address
));
2637 if (bl
->loc_type
== bp_loc_software_breakpoint
2638 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
2640 /* First check to see if we have to handle an overlay. */
2641 if (overlay_debugging
== ovly_off
2642 || bl
->section
== NULL
2643 || !(section_is_overlay (bl
->section
)))
2645 /* No overlay handling: just set the breakpoint. */
2650 val
= bl
->owner
->ops
->insert_location (bl
);
2652 bp_excpt
= gdb_exception
{RETURN_ERROR
, GENERIC_ERROR
};
2654 catch (gdb_exception
&e
)
2656 bp_excpt
= std::move (e
);
2661 /* This breakpoint is in an overlay section.
2662 Shall we set a breakpoint at the LMA? */
2663 if (!overlay_events_enabled
)
2665 /* Yes -- overlay event support is not active,
2666 so we must try to set a breakpoint at the LMA.
2667 This will not work for a hardware breakpoint. */
2668 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
2669 warning (_("hardware breakpoint %d not supported in overlay!"),
2673 CORE_ADDR addr
= overlay_unmapped_address (bl
->address
,
2675 /* Set a software (trap) breakpoint at the LMA. */
2676 bl
->overlay_target_info
= bl
->target_info
;
2677 bl
->overlay_target_info
.reqstd_address
= addr
;
2679 /* No overlay handling: just set the breakpoint. */
2684 bl
->overlay_target_info
.kind
2685 = breakpoint_kind (bl
, &addr
);
2686 bl
->overlay_target_info
.placed_address
= addr
;
2687 val
= target_insert_breakpoint (bl
->gdbarch
,
2688 &bl
->overlay_target_info
);
2691 = gdb_exception
{RETURN_ERROR
, GENERIC_ERROR
};
2693 catch (gdb_exception
&e
)
2695 bp_excpt
= std::move (e
);
2698 if (bp_excpt
.reason
!= 0)
2699 fprintf_unfiltered (tmp_error_stream
,
2700 "Overlay breakpoint %d "
2701 "failed: in ROM?\n",
2705 /* Shall we set a breakpoint at the VMA? */
2706 if (section_is_mapped (bl
->section
))
2708 /* Yes. This overlay section is mapped into memory. */
2713 val
= bl
->owner
->ops
->insert_location (bl
);
2715 bp_excpt
= gdb_exception
{RETURN_ERROR
, GENERIC_ERROR
};
2717 catch (gdb_exception
&e
)
2719 bp_excpt
= std::move (e
);
2724 /* No. This breakpoint will not be inserted.
2725 No error, but do not mark the bp as 'inserted'. */
2730 if (bp_excpt
.reason
!= 0)
2732 /* Can't set the breakpoint. */
2734 /* In some cases, we might not be able to insert a
2735 breakpoint in a shared library that has already been
2736 removed, but we have not yet processed the shlib unload
2737 event. Unfortunately, some targets that implement
2738 breakpoint insertion themselves can't tell why the
2739 breakpoint insertion failed (e.g., the remote target
2740 doesn't define error codes), so we must treat generic
2741 errors as memory errors. */
2742 if (bp_excpt
.reason
== RETURN_ERROR
2743 && (bp_excpt
.error
== GENERIC_ERROR
2744 || bp_excpt
.error
== MEMORY_ERROR
)
2745 && bl
->loc_type
== bp_loc_software_breakpoint
2746 && (solib_name_from_address (bl
->pspace
, bl
->address
)
2747 || shared_objfile_contains_address_p (bl
->pspace
,
2750 /* See also: disable_breakpoints_in_shlibs. */
2751 bl
->shlib_disabled
= 1;
2752 gdb::observers::breakpoint_modified
.notify (bl
->owner
);
2753 if (!*disabled_breaks
)
2755 fprintf_unfiltered (tmp_error_stream
,
2756 "Cannot insert breakpoint %d.\n",
2758 fprintf_unfiltered (tmp_error_stream
,
2759 "Temporarily disabling shared "
2760 "library breakpoints:\n");
2762 *disabled_breaks
= 1;
2763 fprintf_unfiltered (tmp_error_stream
,
2764 "breakpoint #%d\n", bl
->owner
->number
);
2769 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
2771 *hw_breakpoint_error
= 1;
2772 *hw_bp_error_explained_already
= bp_excpt
.message
!= NULL
;
2773 fprintf_unfiltered (tmp_error_stream
,
2774 "Cannot insert hardware breakpoint %d%s",
2776 bp_excpt
.message
? ":" : ".\n");
2777 if (bp_excpt
.message
!= NULL
)
2778 fprintf_unfiltered (tmp_error_stream
, "%s.\n",
2783 if (bp_excpt
.message
== NULL
)
2786 = memory_error_message (TARGET_XFER_E_IO
,
2787 bl
->gdbarch
, bl
->address
);
2789 fprintf_unfiltered (tmp_error_stream
,
2790 "Cannot insert breakpoint %d.\n"
2792 bl
->owner
->number
, message
.c_str ());
2796 fprintf_unfiltered (tmp_error_stream
,
2797 "Cannot insert breakpoint %d: %s\n",
2812 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
2813 /* NOTE drow/2003-09-08: This state only exists for removing
2814 watchpoints. It's not clear that it's necessary... */
2815 && bl
->owner
->disposition
!= disp_del_at_next_stop
)
2819 gdb_assert (bl
->owner
->ops
!= NULL
2820 && bl
->owner
->ops
->insert_location
!= NULL
);
2822 val
= bl
->owner
->ops
->insert_location (bl
);
2824 /* If trying to set a read-watchpoint, and it turns out it's not
2825 supported, try emulating one with an access watchpoint. */
2826 if (val
== 1 && bl
->watchpoint_type
== hw_read
)
2828 struct bp_location
*loc
, **loc_temp
;
2830 /* But don't try to insert it, if there's already another
2831 hw_access location that would be considered a duplicate
2833 ALL_BP_LOCATIONS (loc
, loc_temp
)
2835 && loc
->watchpoint_type
== hw_access
2836 && watchpoint_locations_match (bl
, loc
))
2840 bl
->target_info
= loc
->target_info
;
2841 bl
->watchpoint_type
= hw_access
;
2848 bl
->watchpoint_type
= hw_access
;
2849 val
= bl
->owner
->ops
->insert_location (bl
);
2852 /* Back to the original value. */
2853 bl
->watchpoint_type
= hw_read
;
2857 bl
->inserted
= (val
== 0);
2860 else if (bl
->owner
->type
== bp_catchpoint
)
2864 gdb_assert (bl
->owner
->ops
!= NULL
2865 && bl
->owner
->ops
->insert_location
!= NULL
);
2867 val
= bl
->owner
->ops
->insert_location (bl
);
2870 bl
->owner
->enable_state
= bp_disabled
;
2874 Error inserting catchpoint %d: Your system does not support this type\n\
2875 of catchpoint."), bl
->owner
->number
);
2877 warning (_("Error inserting catchpoint %d."), bl
->owner
->number
);
2880 bl
->inserted
= (val
== 0);
2882 /* We've already printed an error message if there was a problem
2883 inserting this catchpoint, and we've disabled the catchpoint,
2884 so just return success. */
2891 /* This function is called when program space PSPACE is about to be
2892 deleted. It takes care of updating breakpoints to not reference
2896 breakpoint_program_space_exit (struct program_space
*pspace
)
2898 struct bp_location
*loc
, **loc_temp
;
2900 /* Remove any breakpoint that was set through this program space. */
2901 for (breakpoint
*b
: all_breakpoints_safe ())
2902 if (b
->pspace
== pspace
)
2903 delete_breakpoint (b
);
2905 /* Breakpoints set through other program spaces could have locations
2906 bound to PSPACE as well. Remove those. */
2907 ALL_BP_LOCATIONS (loc
, loc_temp
)
2909 struct bp_location
*tmp
;
2911 if (loc
->pspace
== pspace
)
2913 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
2914 if (loc
->owner
->loc
== loc
)
2915 loc
->owner
->loc
= loc
->next
;
2917 for (tmp
= loc
->owner
->loc
; tmp
->next
!= NULL
; tmp
= tmp
->next
)
2918 if (tmp
->next
== loc
)
2920 tmp
->next
= loc
->next
;
2926 /* Now update the global location list to permanently delete the
2927 removed locations above. */
2928 update_global_location_list (UGLL_DONT_INSERT
);
2931 /* Make sure all breakpoints are inserted in inferior.
2932 Throws exception on any error.
2933 A breakpoint that is already inserted won't be inserted
2934 again, so calling this function twice is safe. */
2936 insert_breakpoints (void)
2938 for (breakpoint
*bpt
: all_breakpoints ())
2939 if (is_hardware_watchpoint (bpt
))
2941 struct watchpoint
*w
= (struct watchpoint
*) bpt
;
2943 update_watchpoint (w
, 0 /* don't reparse. */);
2946 /* Updating watchpoints creates new locations, so update the global
2947 location list. Explicitly tell ugll to insert locations and
2948 ignore breakpoints_always_inserted_mode. Also,
2949 update_global_location_list tries to "upgrade" software
2950 breakpoints to hardware breakpoints to handle "set breakpoint
2951 auto-hw", so we need to call it even if we don't have new
2953 update_global_location_list (UGLL_INSERT
);
2956 /* Invoke CALLBACK for each of bp_location. */
2959 iterate_over_bp_locations (gdb::function_view
<void (bp_location
*)> callback
)
2961 struct bp_location
*loc
, **loc_tmp
;
2963 ALL_BP_LOCATIONS (loc
, loc_tmp
)
2969 /* This is used when we need to synch breakpoint conditions between GDB and the
2970 target. It is the case with deleting and disabling of breakpoints when using
2971 always-inserted mode. */
2974 update_inserted_breakpoint_locations (void)
2976 struct bp_location
*bl
, **blp_tmp
;
2979 int disabled_breaks
= 0;
2980 int hw_breakpoint_error
= 0;
2981 int hw_bp_details_reported
= 0;
2983 string_file tmp_error_stream
;
2985 /* Explicitly mark the warning -- this will only be printed if
2986 there was an error. */
2987 tmp_error_stream
.puts ("Warning:\n");
2989 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
2991 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2993 /* We only want to update software breakpoints and hardware
2995 if (!is_breakpoint (bl
->owner
))
2998 /* We only want to update locations that are already inserted
2999 and need updating. This is to avoid unwanted insertion during
3000 deletion of breakpoints. */
3001 if (!bl
->inserted
|| !bl
->needs_update
)
3004 switch_to_program_space_and_thread (bl
->pspace
);
3006 /* For targets that support global breakpoints, there's no need
3007 to select an inferior to insert breakpoint to. In fact, even
3008 if we aren't attached to any process yet, we should still
3009 insert breakpoints. */
3010 if (!gdbarch_has_global_breakpoints (target_gdbarch ())
3011 && (inferior_ptid
== null_ptid
|| !target_has_execution ()))
3014 val
= insert_bp_location (bl
, &tmp_error_stream
, &disabled_breaks
,
3015 &hw_breakpoint_error
, &hw_bp_details_reported
);
3022 target_terminal::ours_for_output ();
3023 error_stream (tmp_error_stream
);
3027 /* Used when starting or continuing the program. */
3030 insert_breakpoint_locations (void)
3032 struct bp_location
*bl
, **blp_tmp
;
3035 int disabled_breaks
= 0;
3036 int hw_breakpoint_error
= 0;
3037 int hw_bp_error_explained_already
= 0;
3039 string_file tmp_error_stream
;
3041 /* Explicitly mark the warning -- this will only be printed if
3042 there was an error. */
3043 tmp_error_stream
.puts ("Warning:\n");
3045 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
3047 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3049 if (!should_be_inserted (bl
) || (bl
->inserted
&& !bl
->needs_update
))
3052 /* There is no point inserting thread-specific breakpoints if
3053 the thread no longer exists. ALL_BP_LOCATIONS bp_location
3054 has BL->OWNER always non-NULL. */
3055 if (bl
->owner
->thread
!= -1
3056 && !valid_global_thread_id (bl
->owner
->thread
))
3059 switch_to_program_space_and_thread (bl
->pspace
);
3061 /* For targets that support global breakpoints, there's no need
3062 to select an inferior to insert breakpoint to. In fact, even
3063 if we aren't attached to any process yet, we should still
3064 insert breakpoints. */
3065 if (!gdbarch_has_global_breakpoints (target_gdbarch ())
3066 && (inferior_ptid
== null_ptid
|| !target_has_execution ()))
3069 val
= insert_bp_location (bl
, &tmp_error_stream
, &disabled_breaks
,
3070 &hw_breakpoint_error
, &hw_bp_error_explained_already
);
3075 /* If we failed to insert all locations of a watchpoint, remove
3076 them, as half-inserted watchpoint is of limited use. */
3077 for (breakpoint
*bpt
: all_breakpoints ())
3079 int some_failed
= 0;
3081 if (!is_hardware_watchpoint (bpt
))
3084 if (!breakpoint_enabled (bpt
))
3087 if (bpt
->disposition
== disp_del_at_next_stop
)
3090 for (bp_location
*loc
: bpt
->locations ())
3091 if (!loc
->inserted
&& should_be_inserted (loc
))
3099 for (bp_location
*loc
: bpt
->locations ())
3101 remove_breakpoint (loc
);
3103 hw_breakpoint_error
= 1;
3104 tmp_error_stream
.printf ("Could not insert "
3105 "hardware watchpoint %d.\n",
3113 /* If a hardware breakpoint or watchpoint was inserted, add a
3114 message about possibly exhausted resources. */
3115 if (hw_breakpoint_error
&& !hw_bp_error_explained_already
)
3117 tmp_error_stream
.printf ("Could not insert hardware breakpoints:\n\
3118 You may have requested too many hardware breakpoints/watchpoints.\n");
3120 target_terminal::ours_for_output ();
3121 error_stream (tmp_error_stream
);
3125 /* Used when the program stops.
3126 Returns zero if successful, or non-zero if there was a problem
3127 removing a breakpoint location. */
3130 remove_breakpoints (void)
3132 struct bp_location
*bl
, **blp_tmp
;
3135 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3137 if (bl
->inserted
&& !is_tracepoint (bl
->owner
))
3138 val
|= remove_breakpoint (bl
);
3143 /* When a thread exits, remove breakpoints that are related to
3147 remove_threaded_breakpoints (struct thread_info
*tp
, int silent
)
3149 for (breakpoint
*b
: all_breakpoints_safe ())
3151 if (b
->thread
== tp
->global_num
&& user_breakpoint_p (b
))
3153 b
->disposition
= disp_del_at_next_stop
;
3155 printf_filtered (_("\
3156 Thread-specific breakpoint %d deleted - thread %s no longer in the thread list.\n"),
3157 b
->number
, print_thread_id (tp
));
3159 /* Hide it from the user. */
3165 /* See breakpoint.h. */
3168 remove_breakpoints_inf (inferior
*inf
)
3170 struct bp_location
*bl
, **blp_tmp
;
3173 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3175 if (bl
->pspace
!= inf
->pspace
)
3178 if (bl
->inserted
&& !bl
->target_info
.persist
)
3180 val
= remove_breakpoint (bl
);
3187 static int internal_breakpoint_number
= -1;
3189 /* Set the breakpoint number of B, depending on the value of INTERNAL.
3190 If INTERNAL is non-zero, the breakpoint number will be populated
3191 from internal_breakpoint_number and that variable decremented.
3192 Otherwise the breakpoint number will be populated from
3193 breakpoint_count and that value incremented. Internal breakpoints
3194 do not set the internal var bpnum. */
3196 set_breakpoint_number (int internal
, struct breakpoint
*b
)
3199 b
->number
= internal_breakpoint_number
--;
3202 set_breakpoint_count (breakpoint_count
+ 1);
3203 b
->number
= breakpoint_count
;
3207 static struct breakpoint
*
3208 create_internal_breakpoint (struct gdbarch
*gdbarch
,
3209 CORE_ADDR address
, enum bptype type
,
3210 const struct breakpoint_ops
*ops
)
3212 symtab_and_line sal
;
3214 sal
.section
= find_pc_overlay (sal
.pc
);
3215 sal
.pspace
= current_program_space
;
3217 breakpoint
*b
= set_raw_breakpoint (gdbarch
, sal
, type
, ops
);
3218 b
->number
= internal_breakpoint_number
--;
3219 b
->disposition
= disp_donttouch
;
3224 static const char *const longjmp_names
[] =
3226 "longjmp", "_longjmp", "siglongjmp", "_siglongjmp"
3228 #define NUM_LONGJMP_NAMES ARRAY_SIZE(longjmp_names)
3230 /* Per-objfile data private to breakpoint.c. */
3231 struct breakpoint_objfile_data
3233 /* Minimal symbol for "_ovly_debug_event" (if any). */
3234 struct bound_minimal_symbol overlay_msym
{};
3236 /* Minimal symbol(s) for "longjmp", "siglongjmp", etc. (if any). */
3237 struct bound_minimal_symbol longjmp_msym
[NUM_LONGJMP_NAMES
] {};
3239 /* True if we have looked for longjmp probes. */
3240 int longjmp_searched
= 0;
3242 /* SystemTap probe points for longjmp (if any). These are non-owning
3244 std::vector
<probe
*> longjmp_probes
;
3246 /* Minimal symbol for "std::terminate()" (if any). */
3247 struct bound_minimal_symbol terminate_msym
{};
3249 /* Minimal symbol for "_Unwind_DebugHook" (if any). */
3250 struct bound_minimal_symbol exception_msym
{};
3252 /* True if we have looked for exception probes. */
3253 int exception_searched
= 0;
3255 /* SystemTap probe points for unwinding (if any). These are non-owning
3257 std::vector
<probe
*> exception_probes
;
3260 static const struct objfile_key
<breakpoint_objfile_data
>
3261 breakpoint_objfile_key
;
3263 /* Minimal symbol not found sentinel. */
3264 static struct minimal_symbol msym_not_found
;
3266 /* Returns TRUE if MSYM point to the "not found" sentinel. */
3269 msym_not_found_p (const struct minimal_symbol
*msym
)
3271 return msym
== &msym_not_found
;
3274 /* Return per-objfile data needed by breakpoint.c.
3275 Allocate the data if necessary. */
3277 static struct breakpoint_objfile_data
*
3278 get_breakpoint_objfile_data (struct objfile
*objfile
)
3280 struct breakpoint_objfile_data
*bp_objfile_data
;
3282 bp_objfile_data
= breakpoint_objfile_key
.get (objfile
);
3283 if (bp_objfile_data
== NULL
)
3284 bp_objfile_data
= breakpoint_objfile_key
.emplace (objfile
);
3285 return bp_objfile_data
;
3289 create_overlay_event_breakpoint (void)
3291 const char *const func_name
= "_ovly_debug_event";
3293 for (objfile
*objfile
: current_program_space
->objfiles ())
3295 struct breakpoint
*b
;
3296 struct breakpoint_objfile_data
*bp_objfile_data
;
3298 struct explicit_location explicit_loc
;
3300 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3302 if (msym_not_found_p (bp_objfile_data
->overlay_msym
.minsym
))
3305 if (bp_objfile_data
->overlay_msym
.minsym
== NULL
)
3307 struct bound_minimal_symbol m
;
3309 m
= lookup_minimal_symbol_text (func_name
, objfile
);
3310 if (m
.minsym
== NULL
)
3312 /* Avoid future lookups in this objfile. */
3313 bp_objfile_data
->overlay_msym
.minsym
= &msym_not_found
;
3316 bp_objfile_data
->overlay_msym
= m
;
3319 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->overlay_msym
);
3320 b
= create_internal_breakpoint (objfile
->arch (), addr
,
3322 &internal_breakpoint_ops
);
3323 initialize_explicit_location (&explicit_loc
);
3324 explicit_loc
.function_name
= ASTRDUP (func_name
);
3325 b
->location
= new_explicit_location (&explicit_loc
);
3327 if (overlay_debugging
== ovly_auto
)
3329 b
->enable_state
= bp_enabled
;
3330 overlay_events_enabled
= 1;
3334 b
->enable_state
= bp_disabled
;
3335 overlay_events_enabled
= 0;
3340 /* Install a master longjmp breakpoint for OBJFILE using a probe. Return
3341 true if a breakpoint was installed. */
3344 create_longjmp_master_breakpoint_probe (objfile
*objfile
)
3346 struct gdbarch
*gdbarch
= objfile
->arch ();
3347 struct breakpoint_objfile_data
*bp_objfile_data
3348 = get_breakpoint_objfile_data (objfile
);
3350 if (!bp_objfile_data
->longjmp_searched
)
3352 std::vector
<probe
*> ret
3353 = find_probes_in_objfile (objfile
, "libc", "longjmp");
3357 /* We are only interested in checking one element. */
3360 if (!p
->can_evaluate_arguments ())
3362 /* We cannot use the probe interface here,
3363 because it does not know how to evaluate
3368 bp_objfile_data
->longjmp_probes
= ret
;
3369 bp_objfile_data
->longjmp_searched
= 1;
3372 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 /* Install master longjmp breakpoints for OBJFILE using longjmp_names.
3391 Return true if at least one breakpoint was installed. */
3394 create_longjmp_master_breakpoint_names (objfile
*objfile
)
3396 struct gdbarch
*gdbarch
= objfile
->arch ();
3397 if (!gdbarch_get_longjmp_target_p (gdbarch
))
3400 struct breakpoint_objfile_data
*bp_objfile_data
3401 = get_breakpoint_objfile_data (objfile
);
3402 unsigned int installed_bp
= 0;
3404 for (int i
= 0; i
< NUM_LONGJMP_NAMES
; i
++)
3406 struct breakpoint
*b
;
3407 const char *func_name
;
3409 struct explicit_location explicit_loc
;
3411 if (msym_not_found_p (bp_objfile_data
->longjmp_msym
[i
].minsym
))
3414 func_name
= longjmp_names
[i
];
3415 if (bp_objfile_data
->longjmp_msym
[i
].minsym
== NULL
)
3417 struct bound_minimal_symbol m
;
3419 m
= lookup_minimal_symbol_text (func_name
, objfile
);
3420 if (m
.minsym
== NULL
)
3422 /* Prevent future lookups in this objfile. */
3423 bp_objfile_data
->longjmp_msym
[i
].minsym
= &msym_not_found
;
3426 bp_objfile_data
->longjmp_msym
[i
] = m
;
3429 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->longjmp_msym
[i
]);
3430 b
= create_internal_breakpoint (gdbarch
, addr
, bp_longjmp_master
,
3431 &internal_breakpoint_ops
);
3432 initialize_explicit_location (&explicit_loc
);
3433 explicit_loc
.function_name
= ASTRDUP (func_name
);
3434 b
->location
= new_explicit_location (&explicit_loc
);
3435 b
->enable_state
= bp_disabled
;
3439 return installed_bp
> 0;
3442 /* Create a master longjmp breakpoint. */
3445 create_longjmp_master_breakpoint (void)
3447 scoped_restore_current_program_space restore_pspace
;
3449 for (struct program_space
*pspace
: program_spaces
)
3451 set_current_program_space (pspace
);
3453 for (objfile
*obj
: current_program_space
->objfiles ())
3455 /* Skip separate debug object, it's handled in the loop below. */
3456 if (obj
->separate_debug_objfile_backlink
!= nullptr)
3459 /* Try a probe kind breakpoint on main objfile. */
3460 if (create_longjmp_master_breakpoint_probe (obj
))
3463 /* Try longjmp_names kind breakpoints on main and separate_debug
3465 for (objfile
*debug_objfile
: obj
->separate_debug_objfiles ())
3466 if (create_longjmp_master_breakpoint_names (debug_objfile
))
3472 /* Create a master std::terminate breakpoint. */
3474 create_std_terminate_master_breakpoint (void)
3476 const char *const func_name
= "std::terminate()";
3478 scoped_restore_current_program_space restore_pspace
;
3480 for (struct program_space
*pspace
: program_spaces
)
3484 set_current_program_space (pspace
);
3486 for (objfile
*objfile
: current_program_space
->objfiles ())
3488 struct breakpoint
*b
;
3489 struct breakpoint_objfile_data
*bp_objfile_data
;
3490 struct explicit_location explicit_loc
;
3492 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3494 if (msym_not_found_p (bp_objfile_data
->terminate_msym
.minsym
))
3497 if (bp_objfile_data
->terminate_msym
.minsym
== NULL
)
3499 struct bound_minimal_symbol m
;
3501 m
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
3502 if (m
.minsym
== NULL
|| (MSYMBOL_TYPE (m
.minsym
) != mst_text
3503 && MSYMBOL_TYPE (m
.minsym
) != mst_file_text
))
3505 /* Prevent future lookups in this objfile. */
3506 bp_objfile_data
->terminate_msym
.minsym
= &msym_not_found
;
3509 bp_objfile_data
->terminate_msym
= m
;
3512 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->terminate_msym
);
3513 b
= create_internal_breakpoint (objfile
->arch (), addr
,
3514 bp_std_terminate_master
,
3515 &internal_breakpoint_ops
);
3516 initialize_explicit_location (&explicit_loc
);
3517 explicit_loc
.function_name
= ASTRDUP (func_name
);
3518 b
->location
= new_explicit_location (&explicit_loc
);
3519 b
->enable_state
= bp_disabled
;
3524 /* Install a master breakpoint on the unwinder's debug hook for OBJFILE using a
3525 probe. Return true if a breakpoint was installed. */
3528 create_exception_master_breakpoint_probe (objfile
*objfile
)
3530 struct breakpoint
*b
;
3531 struct gdbarch
*gdbarch
;
3532 struct breakpoint_objfile_data
*bp_objfile_data
;
3534 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3536 /* We prefer the SystemTap probe point if it exists. */
3537 if (!bp_objfile_data
->exception_searched
)
3539 std::vector
<probe
*> ret
3540 = find_probes_in_objfile (objfile
, "libgcc", "unwind");
3544 /* We are only interested in checking one element. */
3547 if (!p
->can_evaluate_arguments ())
3549 /* We cannot use the probe interface here, because it does
3550 not know how to evaluate arguments. */
3554 bp_objfile_data
->exception_probes
= ret
;
3555 bp_objfile_data
->exception_searched
= 1;
3558 if (bp_objfile_data
->exception_probes
.empty ())
3561 gdbarch
= objfile
->arch ();
3563 for (probe
*p
: bp_objfile_data
->exception_probes
)
3565 b
= create_internal_breakpoint (gdbarch
,
3566 p
->get_relocated_address (objfile
),
3567 bp_exception_master
,
3568 &internal_breakpoint_ops
);
3569 b
->location
= new_probe_location ("-probe-stap libgcc:unwind");
3570 b
->enable_state
= bp_disabled
;
3576 /* Install a master breakpoint on the unwinder's debug hook for OBJFILE using
3577 _Unwind_DebugHook. Return true if a breakpoint was installed. */
3580 create_exception_master_breakpoint_hook (objfile
*objfile
)
3582 const char *const func_name
= "_Unwind_DebugHook";
3583 struct breakpoint
*b
;
3584 struct gdbarch
*gdbarch
;
3585 struct breakpoint_objfile_data
*bp_objfile_data
;
3587 struct explicit_location explicit_loc
;
3589 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3591 if (msym_not_found_p (bp_objfile_data
->exception_msym
.minsym
))
3594 gdbarch
= objfile
->arch ();
3596 if (bp_objfile_data
->exception_msym
.minsym
== NULL
)
3598 struct bound_minimal_symbol debug_hook
;
3600 debug_hook
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
3601 if (debug_hook
.minsym
== NULL
)
3603 bp_objfile_data
->exception_msym
.minsym
= &msym_not_found
;
3607 bp_objfile_data
->exception_msym
= debug_hook
;
3610 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->exception_msym
);
3611 addr
= gdbarch_convert_from_func_ptr_addr
3612 (gdbarch
, addr
, current_inferior ()->top_target ());
3613 b
= create_internal_breakpoint (gdbarch
, addr
, bp_exception_master
,
3614 &internal_breakpoint_ops
);
3615 initialize_explicit_location (&explicit_loc
);
3616 explicit_loc
.function_name
= ASTRDUP (func_name
);
3617 b
->location
= new_explicit_location (&explicit_loc
);
3618 b
->enable_state
= bp_disabled
;
3623 /* Install a master breakpoint on the unwinder's debug hook. */
3626 create_exception_master_breakpoint (void)
3628 for (objfile
*obj
: current_program_space
->objfiles ())
3630 /* Skip separate debug object. */
3631 if (obj
->separate_debug_objfile_backlink
)
3634 /* Try a probe kind breakpoint. */
3635 if (create_exception_master_breakpoint_probe (obj
))
3638 /* Iterate over main and separate debug objects and try an
3639 _Unwind_DebugHook kind breakpoint. */
3640 for (objfile
*debug_objfile
: obj
->separate_debug_objfiles ())
3641 if (create_exception_master_breakpoint_hook (debug_objfile
))
3646 /* Does B have a location spec? */
3649 breakpoint_event_location_empty_p (const struct breakpoint
*b
)
3651 return b
->location
!= NULL
&& event_location_empty_p (b
->location
.get ());
3655 update_breakpoints_after_exec (void)
3657 struct bp_location
*bploc
, **bplocp_tmp
;
3659 /* We're about to delete breakpoints from GDB's lists. If the
3660 INSERTED flag is true, GDB will try to lift the breakpoints by
3661 writing the breakpoints' "shadow contents" back into memory. The
3662 "shadow contents" are NOT valid after an exec, so GDB should not
3663 do that. Instead, the target is responsible from marking
3664 breakpoints out as soon as it detects an exec. We don't do that
3665 here instead, because there may be other attempts to delete
3666 breakpoints after detecting an exec and before reaching here. */
3667 ALL_BP_LOCATIONS (bploc
, bplocp_tmp
)
3668 if (bploc
->pspace
== current_program_space
)
3669 gdb_assert (!bploc
->inserted
);
3671 for (breakpoint
*b
: all_breakpoints_safe ())
3673 if (b
->pspace
!= current_program_space
)
3676 /* Solib breakpoints must be explicitly reset after an exec(). */
3677 if (b
->type
== bp_shlib_event
)
3679 delete_breakpoint (b
);
3683 /* JIT breakpoints must be explicitly reset after an exec(). */
3684 if (b
->type
== bp_jit_event
)
3686 delete_breakpoint (b
);
3690 /* Thread event breakpoints must be set anew after an exec(),
3691 as must overlay event and longjmp master breakpoints. */
3692 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
3693 || b
->type
== bp_longjmp_master
|| b
->type
== bp_std_terminate_master
3694 || b
->type
== bp_exception_master
)
3696 delete_breakpoint (b
);
3700 /* Step-resume breakpoints are meaningless after an exec(). */
3701 if (b
->type
== bp_step_resume
|| b
->type
== bp_hp_step_resume
)
3703 delete_breakpoint (b
);
3707 /* Just like single-step breakpoints. */
3708 if (b
->type
== bp_single_step
)
3710 delete_breakpoint (b
);
3714 /* Longjmp and longjmp-resume breakpoints are also meaningless
3716 if (b
->type
== bp_longjmp
|| b
->type
== bp_longjmp_resume
3717 || b
->type
== bp_longjmp_call_dummy
3718 || b
->type
== bp_exception
|| b
->type
== bp_exception_resume
)
3720 delete_breakpoint (b
);
3724 if (b
->type
== bp_catchpoint
)
3726 /* For now, none of the bp_catchpoint breakpoints need to
3727 do anything at this point. In the future, if some of
3728 the catchpoints need to something, we will need to add
3729 a new method, and call this method from here. */
3733 /* bp_finish is a special case. The only way we ought to be able
3734 to see one of these when an exec() has happened, is if the user
3735 caught a vfork, and then said "finish". Ordinarily a finish just
3736 carries them to the call-site of the current callee, by setting
3737 a temporary bp there and resuming. But in this case, the finish
3738 will carry them entirely through the vfork & exec.
3740 We don't want to allow a bp_finish to remain inserted now. But
3741 we can't safely delete it, 'cause finish_command has a handle to
3742 the bp on a bpstat, and will later want to delete it. There's a
3743 chance (and I've seen it happen) that if we delete the bp_finish
3744 here, that its storage will get reused by the time finish_command
3745 gets 'round to deleting the "use to be a bp_finish" breakpoint.
3746 We really must allow finish_command to delete a bp_finish.
3748 In the absence of a general solution for the "how do we know
3749 it's safe to delete something others may have handles to?"
3750 problem, what we'll do here is just uninsert the bp_finish, and
3751 let finish_command delete it.
3753 (We know the bp_finish is "doomed" in the sense that it's
3754 momentary, and will be deleted as soon as finish_command sees
3755 the inferior stopped. So it doesn't matter that the bp's
3756 address is probably bogus in the new a.out, unlike e.g., the
3757 solib breakpoints.) */
3759 if (b
->type
== bp_finish
)
3764 /* Without a symbolic address, we have little hope of the
3765 pre-exec() address meaning the same thing in the post-exec()
3767 if (breakpoint_event_location_empty_p (b
))
3769 delete_breakpoint (b
);
3776 detach_breakpoints (ptid_t ptid
)
3778 struct bp_location
*bl
, **blp_tmp
;
3780 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
3781 struct inferior
*inf
= current_inferior ();
3783 if (ptid
.pid () == inferior_ptid
.pid ())
3784 error (_("Cannot detach breakpoints of inferior_ptid"));
3786 /* Set inferior_ptid; remove_breakpoint_1 uses this global. */
3787 inferior_ptid
= ptid
;
3788 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3790 if (bl
->pspace
!= inf
->pspace
)
3793 /* This function must physically remove breakpoints locations
3794 from the specified ptid, without modifying the breakpoint
3795 package's state. Locations of type bp_loc_other are only
3796 maintained at GDB side. So, there is no need to remove
3797 these bp_loc_other locations. Moreover, removing these
3798 would modify the breakpoint package's state. */
3799 if (bl
->loc_type
== bp_loc_other
)
3803 val
|= remove_breakpoint_1 (bl
, DETACH_BREAKPOINT
);
3809 /* Remove the breakpoint location BL from the current address space.
3810 Note that this is used to detach breakpoints from a child fork.
3811 When we get here, the child isn't in the inferior list, and neither
3812 do we have objects to represent its address space --- we should
3813 *not* look at bl->pspace->aspace here. */
3816 remove_breakpoint_1 (struct bp_location
*bl
, enum remove_bp_reason reason
)
3820 /* BL is never in moribund_locations by our callers. */
3821 gdb_assert (bl
->owner
!= NULL
);
3823 /* The type of none suggests that owner is actually deleted.
3824 This should not ever happen. */
3825 gdb_assert (bl
->owner
->type
!= bp_none
);
3827 if (bl
->loc_type
== bp_loc_software_breakpoint
3828 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
3830 /* "Normal" instruction breakpoint: either the standard
3831 trap-instruction bp (bp_breakpoint), or a
3832 bp_hardware_breakpoint. */
3834 /* First check to see if we have to handle an overlay. */
3835 if (overlay_debugging
== ovly_off
3836 || bl
->section
== NULL
3837 || !(section_is_overlay (bl
->section
)))
3839 /* No overlay handling: just remove the breakpoint. */
3841 /* If we're trying to uninsert a memory breakpoint that we
3842 know is set in a dynamic object that is marked
3843 shlib_disabled, then either the dynamic object was
3844 removed with "remove-symbol-file" or with
3845 "nosharedlibrary". In the former case, we don't know
3846 whether another dynamic object might have loaded over the
3847 breakpoint's address -- the user might well let us know
3848 about it next with add-symbol-file (the whole point of
3849 add-symbol-file is letting the user manually maintain a
3850 list of dynamically loaded objects). If we have the
3851 breakpoint's shadow memory, that is, this is a software
3852 breakpoint managed by GDB, check whether the breakpoint
3853 is still inserted in memory, to avoid overwriting wrong
3854 code with stale saved shadow contents. Note that HW
3855 breakpoints don't have shadow memory, as they're
3856 implemented using a mechanism that is not dependent on
3857 being able to modify the target's memory, and as such
3858 they should always be removed. */
3859 if (bl
->shlib_disabled
3860 && bl
->target_info
.shadow_len
!= 0
3861 && !memory_validate_breakpoint (bl
->gdbarch
, &bl
->target_info
))
3864 val
= bl
->owner
->ops
->remove_location (bl
, reason
);
3868 /* This breakpoint is in an overlay section.
3869 Did we set a breakpoint at the LMA? */
3870 if (!overlay_events_enabled
)
3872 /* Yes -- overlay event support is not active, so we
3873 should have set a breakpoint at the LMA. Remove it.
3875 /* Ignore any failures: if the LMA is in ROM, we will
3876 have already warned when we failed to insert it. */
3877 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
3878 target_remove_hw_breakpoint (bl
->gdbarch
,
3879 &bl
->overlay_target_info
);
3881 target_remove_breakpoint (bl
->gdbarch
,
3882 &bl
->overlay_target_info
,
3885 /* Did we set a breakpoint at the VMA?
3886 If so, we will have marked the breakpoint 'inserted'. */
3889 /* Yes -- remove it. Previously we did not bother to
3890 remove the breakpoint if the section had been
3891 unmapped, but let's not rely on that being safe. We
3892 don't know what the overlay manager might do. */
3894 /* However, we should remove *software* breakpoints only
3895 if the section is still mapped, or else we overwrite
3896 wrong code with the saved shadow contents. */
3897 if (bl
->loc_type
== bp_loc_hardware_breakpoint
3898 || section_is_mapped (bl
->section
))
3899 val
= bl
->owner
->ops
->remove_location (bl
, reason
);
3905 /* No -- not inserted, so no need to remove. No error. */
3910 /* In some cases, we might not be able to remove a breakpoint in
3911 a shared library that has already been removed, but we have
3912 not yet processed the shlib unload event. Similarly for an
3913 unloaded add-symbol-file object - the user might not yet have
3914 had the chance to remove-symbol-file it. shlib_disabled will
3915 be set if the library/object has already been removed, but
3916 the breakpoint hasn't been uninserted yet, e.g., after
3917 "nosharedlibrary" or "remove-symbol-file" with breakpoints
3918 always-inserted mode. */
3920 && (bl
->loc_type
== bp_loc_software_breakpoint
3921 && (bl
->shlib_disabled
3922 || solib_name_from_address (bl
->pspace
, bl
->address
)
3923 || shared_objfile_contains_address_p (bl
->pspace
,
3929 bl
->inserted
= (reason
== DETACH_BREAKPOINT
);
3931 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
)
3933 gdb_assert (bl
->owner
->ops
!= NULL
3934 && bl
->owner
->ops
->remove_location
!= NULL
);
3936 bl
->inserted
= (reason
== DETACH_BREAKPOINT
);
3937 bl
->owner
->ops
->remove_location (bl
, reason
);
3939 /* Failure to remove any of the hardware watchpoints comes here. */
3940 if (reason
== REMOVE_BREAKPOINT
&& bl
->inserted
)
3941 warning (_("Could not remove hardware watchpoint %d."),
3944 else if (bl
->owner
->type
== bp_catchpoint
3945 && breakpoint_enabled (bl
->owner
)
3948 gdb_assert (bl
->owner
->ops
!= NULL
3949 && bl
->owner
->ops
->remove_location
!= NULL
);
3951 val
= bl
->owner
->ops
->remove_location (bl
, reason
);
3955 bl
->inserted
= (reason
== DETACH_BREAKPOINT
);
3962 remove_breakpoint (struct bp_location
*bl
)
3964 /* BL is never in moribund_locations by our callers. */
3965 gdb_assert (bl
->owner
!= NULL
);
3967 /* The type of none suggests that owner is actually deleted.
3968 This should not ever happen. */
3969 gdb_assert (bl
->owner
->type
!= bp_none
);
3971 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
3973 switch_to_program_space_and_thread (bl
->pspace
);
3975 return remove_breakpoint_1 (bl
, REMOVE_BREAKPOINT
);
3978 /* Clear the "inserted" flag in all breakpoints. */
3981 mark_breakpoints_out (void)
3983 struct bp_location
*bl
, **blp_tmp
;
3985 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3986 if (bl
->pspace
== current_program_space
)
3990 /* Clear the "inserted" flag in all breakpoints and delete any
3991 breakpoints which should go away between runs of the program.
3993 Plus other such housekeeping that has to be done for breakpoints
3996 Note: this function gets called at the end of a run (by
3997 generic_mourn_inferior) and when a run begins (by
3998 init_wait_for_inferior). */
4003 breakpoint_init_inferior (enum inf_context context
)
4005 struct program_space
*pspace
= current_program_space
;
4007 /* If breakpoint locations are shared across processes, then there's
4009 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
4012 mark_breakpoints_out ();
4014 for (breakpoint
*b
: all_breakpoints_safe ())
4016 if (b
->loc
&& b
->loc
->pspace
!= pspace
)
4022 case bp_longjmp_call_dummy
:
4024 /* If the call dummy breakpoint is at the entry point it will
4025 cause problems when the inferior is rerun, so we better get
4028 case bp_watchpoint_scope
:
4030 /* Also get rid of scope breakpoints. */
4032 case bp_shlib_event
:
4034 /* Also remove solib event breakpoints. Their addresses may
4035 have changed since the last time we ran the program.
4036 Actually we may now be debugging against different target;
4037 and so the solib backend that installed this breakpoint may
4038 not be used in by the target. E.g.,
4040 (gdb) file prog-linux
4041 (gdb) run # native linux target
4044 (gdb) file prog-win.exe
4045 (gdb) tar rem :9999 # remote Windows gdbserver.
4048 case bp_step_resume
:
4050 /* Also remove step-resume breakpoints. */
4052 case bp_single_step
:
4054 /* Also remove single-step breakpoints. */
4056 delete_breakpoint (b
);
4060 case bp_hardware_watchpoint
:
4061 case bp_read_watchpoint
:
4062 case bp_access_watchpoint
:
4064 struct watchpoint
*w
= (struct watchpoint
*) b
;
4066 /* Likewise for watchpoints on local expressions. */
4067 if (w
->exp_valid_block
!= NULL
)
4068 delete_breakpoint (b
);
4071 /* Get rid of existing locations, which are no longer
4072 valid. New ones will be created in
4073 update_watchpoint, when the inferior is restarted.
4074 The next update_global_location_list call will
4075 garbage collect them. */
4078 if (context
== inf_starting
)
4080 /* Reset val field to force reread of starting value in
4081 insert_breakpoints. */
4082 w
->val
.reset (nullptr);
4083 w
->val_valid
= false;
4093 /* Get rid of the moribund locations. */
4094 for (bp_location
*bl
: moribund_locations
)
4095 decref_bp_location (&bl
);
4096 moribund_locations
.clear ();
4099 /* These functions concern about actual breakpoints inserted in the
4100 target --- to e.g. check if we need to do decr_pc adjustment or if
4101 we need to hop over the bkpt --- so we check for address space
4102 match, not program space. */
4104 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
4105 exists at PC. It returns ordinary_breakpoint_here if it's an
4106 ordinary breakpoint, or permanent_breakpoint_here if it's a
4107 permanent breakpoint.
4108 - When continuing from a location with an ordinary breakpoint, we
4109 actually single step once before calling insert_breakpoints.
4110 - When continuing from a location with a permanent breakpoint, we
4111 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
4112 the target, to advance the PC past the breakpoint. */
4114 enum breakpoint_here
4115 breakpoint_here_p (const address_space
*aspace
, CORE_ADDR pc
)
4117 struct bp_location
*bl
, **blp_tmp
;
4118 int any_breakpoint_here
= 0;
4120 ALL_BP_LOCATIONS (bl
, blp_tmp
)
4122 if (bl
->loc_type
!= bp_loc_software_breakpoint
4123 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4126 /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
4127 if ((breakpoint_enabled (bl
->owner
)
4129 && breakpoint_location_address_match (bl
, aspace
, pc
))
4131 if (overlay_debugging
4132 && section_is_overlay (bl
->section
)
4133 && !section_is_mapped (bl
->section
))
4134 continue; /* unmapped overlay -- can't be a match */
4135 else if (bl
->permanent
)
4136 return permanent_breakpoint_here
;
4138 any_breakpoint_here
= 1;
4142 return any_breakpoint_here
? ordinary_breakpoint_here
: no_breakpoint_here
;
4145 /* See breakpoint.h. */
4148 breakpoint_in_range_p (const address_space
*aspace
,
4149 CORE_ADDR addr
, ULONGEST len
)
4151 struct bp_location
*bl
, **blp_tmp
;
4153 ALL_BP_LOCATIONS (bl
, blp_tmp
)
4155 if (bl
->loc_type
!= bp_loc_software_breakpoint
4156 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4159 if ((breakpoint_enabled (bl
->owner
)
4161 && breakpoint_location_address_range_overlap (bl
, aspace
,
4164 if (overlay_debugging
4165 && section_is_overlay (bl
->section
)
4166 && !section_is_mapped (bl
->section
))
4168 /* Unmapped overlay -- can't be a match. */
4179 /* Return true if there's a moribund breakpoint at PC. */
4182 moribund_breakpoint_here_p (const address_space
*aspace
, CORE_ADDR pc
)
4184 for (bp_location
*loc
: moribund_locations
)
4185 if (breakpoint_location_address_match (loc
, aspace
, pc
))
4191 /* Returns non-zero iff BL is inserted at PC, in address space
4195 bp_location_inserted_here_p (struct bp_location
*bl
,
4196 const address_space
*aspace
, CORE_ADDR pc
)
4199 && breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
4202 if (overlay_debugging
4203 && section_is_overlay (bl
->section
)
4204 && !section_is_mapped (bl
->section
))
4205 return 0; /* unmapped overlay -- can't be a match */
4212 /* Returns non-zero iff there's a breakpoint inserted at PC. */
4215 breakpoint_inserted_here_p (const address_space
*aspace
, CORE_ADDR pc
)
4217 struct bp_location
**blp
, **blp_tmp
= NULL
;
4219 ALL_BP_LOCATIONS_AT_ADDR (blp
, blp_tmp
, pc
)
4221 struct bp_location
*bl
= *blp
;
4223 if (bl
->loc_type
!= bp_loc_software_breakpoint
4224 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4227 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4233 /* This function returns non-zero iff there is a software breakpoint
4237 software_breakpoint_inserted_here_p (const address_space
*aspace
,
4240 struct bp_location
**blp
, **blp_tmp
= NULL
;
4242 ALL_BP_LOCATIONS_AT_ADDR (blp
, blp_tmp
, pc
)
4244 struct bp_location
*bl
= *blp
;
4246 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
4249 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4256 /* See breakpoint.h. */
4259 hardware_breakpoint_inserted_here_p (const address_space
*aspace
,
4262 struct bp_location
**blp
, **blp_tmp
= NULL
;
4264 ALL_BP_LOCATIONS_AT_ADDR (blp
, blp_tmp
, pc
)
4266 struct bp_location
*bl
= *blp
;
4268 if (bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4271 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4279 hardware_watchpoint_inserted_in_range (const address_space
*aspace
,
4280 CORE_ADDR addr
, ULONGEST len
)
4282 for (breakpoint
*bpt
: all_breakpoints ())
4284 if (bpt
->type
!= bp_hardware_watchpoint
4285 && bpt
->type
!= bp_access_watchpoint
)
4288 if (!breakpoint_enabled (bpt
))
4291 for (bp_location
*loc
: bpt
->locations ())
4292 if (loc
->pspace
->aspace
== aspace
&& loc
->inserted
)
4296 /* Check for intersection. */
4297 l
= std::max
<CORE_ADDR
> (loc
->address
, addr
);
4298 h
= std::min
<CORE_ADDR
> (loc
->address
+ loc
->length
, addr
+ len
);
4306 /* See breakpoint.h. */
4309 is_catchpoint (struct breakpoint
*b
)
4311 return (b
->type
== bp_catchpoint
);
4314 /* Clear a bpstat so that it says we are not at any breakpoint.
4315 Also free any storage that is part of a bpstat. */
4318 bpstat_clear (bpstat
*bsp
)
4335 bpstats::bpstats (const bpstats
&other
)
4337 bp_location_at (other
.bp_location_at
),
4338 breakpoint_at (other
.breakpoint_at
),
4339 commands (other
.commands
),
4340 print (other
.print
),
4342 print_it (other
.print_it
)
4344 if (other
.old_val
!= NULL
)
4345 old_val
= release_value (value_copy (other
.old_val
.get ()));
4348 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
4349 is part of the bpstat is copied as well. */
4352 bpstat_copy (bpstat bs
)
4356 bpstat retval
= NULL
;
4361 for (; bs
!= NULL
; bs
= bs
->next
)
4363 tmp
= new bpstats (*bs
);
4366 /* This is the first thing in the chain. */
4376 /* Find the bpstat associated with this breakpoint. */
4379 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
4384 for (; bsp
!= NULL
; bsp
= bsp
->next
)
4386 if (bsp
->breakpoint_at
== breakpoint
)
4392 /* See breakpoint.h. */
4395 bpstat_explains_signal (bpstat bsp
, enum gdb_signal sig
)
4397 for (; bsp
!= NULL
; bsp
= bsp
->next
)
4399 if (bsp
->breakpoint_at
== NULL
)
4401 /* A moribund location can never explain a signal other than
4403 if (sig
== GDB_SIGNAL_TRAP
)
4408 if (bsp
->breakpoint_at
->ops
->explains_signal (bsp
->breakpoint_at
,
4417 /* Put in *NUM the breakpoint number of the first breakpoint we are
4418 stopped at. *BSP upon return is a bpstat which points to the
4419 remaining breakpoints stopped at (but which is not guaranteed to be
4420 good for anything but further calls to bpstat_num).
4422 Return 0 if passed a bpstat which does not indicate any breakpoints.
4423 Return -1 if stopped at a breakpoint that has been deleted since
4425 Return 1 otherwise. */
4428 bpstat_num (bpstat
*bsp
, int *num
)
4430 struct breakpoint
*b
;
4433 return 0; /* No more breakpoint values */
4435 /* We assume we'll never have several bpstats that correspond to a
4436 single breakpoint -- otherwise, this function might return the
4437 same number more than once and this will look ugly. */
4438 b
= (*bsp
)->breakpoint_at
;
4439 *bsp
= (*bsp
)->next
;
4441 return -1; /* breakpoint that's been deleted since */
4443 *num
= b
->number
; /* We have its number */
4447 /* See breakpoint.h. */
4450 bpstat_clear_actions (void)
4454 if (inferior_ptid
== null_ptid
)
4457 thread_info
*tp
= inferior_thread ();
4458 for (bs
= tp
->control
.stop_bpstat
; bs
!= NULL
; bs
= bs
->next
)
4460 bs
->commands
= NULL
;
4461 bs
->old_val
.reset (nullptr);
4465 /* Called when a command is about to proceed the inferior. */
4468 breakpoint_about_to_proceed (void)
4470 if (inferior_ptid
!= null_ptid
)
4472 struct thread_info
*tp
= inferior_thread ();
4474 /* Allow inferior function calls in breakpoint commands to not
4475 interrupt the command list. When the call finishes
4476 successfully, the inferior will be standing at the same
4477 breakpoint as if nothing happened. */
4478 if (tp
->control
.in_infcall
)
4482 breakpoint_proceeded
= 1;
4485 /* Return non-zero iff CMD as the first line of a command sequence is `silent'
4486 or its equivalent. */
4489 command_line_is_silent (struct command_line
*cmd
)
4491 return cmd
&& (strcmp ("silent", cmd
->line
) == 0);
4494 /* Execute all the commands associated with all the breakpoints at
4495 this location. Any of these commands could cause the process to
4496 proceed beyond this point, etc. We look out for such changes by
4497 checking the global "breakpoint_proceeded" after each command.
4499 Returns true if a breakpoint command resumed the inferior. In that
4500 case, it is the caller's responsibility to recall it again with the
4501 bpstat of the current thread. */
4504 bpstat_do_actions_1 (bpstat
*bsp
)
4509 /* Avoid endless recursion if a `source' command is contained
4511 if (executing_breakpoint_commands
)
4514 scoped_restore save_executing
4515 = make_scoped_restore (&executing_breakpoint_commands
, 1);
4517 scoped_restore preventer
= prevent_dont_repeat ();
4519 /* This pointer will iterate over the list of bpstat's. */
4522 breakpoint_proceeded
= 0;
4523 for (; bs
!= NULL
; bs
= bs
->next
)
4525 struct command_line
*cmd
= NULL
;
4527 /* Take ownership of the BSP's command tree, if it has one.
4529 The command tree could legitimately contain commands like
4530 'step' and 'next', which call clear_proceed_status, which
4531 frees stop_bpstat's command tree. To make sure this doesn't
4532 free the tree we're executing out from under us, we need to
4533 take ownership of the tree ourselves. Since a given bpstat's
4534 commands are only executed once, we don't need to copy it; we
4535 can clear the pointer in the bpstat, and make sure we free
4536 the tree when we're done. */
4537 counted_command_line ccmd
= bs
->commands
;
4538 bs
->commands
= NULL
;
4541 if (command_line_is_silent (cmd
))
4543 /* The action has been already done by bpstat_stop_status. */
4549 execute_control_command (cmd
);
4551 if (breakpoint_proceeded
)
4557 if (breakpoint_proceeded
)
4559 if (current_ui
->async
)
4560 /* If we are in async mode, then the target might be still
4561 running, not stopped at any breakpoint, so nothing for
4562 us to do here -- just return to the event loop. */
4565 /* In sync mode, when execute_control_command returns
4566 we're already standing on the next breakpoint.
4567 Breakpoint commands for that stop were not run, since
4568 execute_command does not run breakpoint commands --
4569 only command_line_handler does, but that one is not
4570 involved in execution of breakpoint commands. So, we
4571 can now execute breakpoint commands. It should be
4572 noted that making execute_command do bpstat actions is
4573 not an option -- in this case we'll have recursive
4574 invocation of bpstat for each breakpoint with a
4575 command, and can easily blow up GDB stack. Instead, we
4576 return true, which will trigger the caller to recall us
4577 with the new stop_bpstat. */
4585 /* Helper for bpstat_do_actions. Get the current thread, if there's
4586 one, is alive and has execution. Return NULL otherwise. */
4588 static thread_info
*
4589 get_bpstat_thread ()
4591 if (inferior_ptid
== null_ptid
|| !target_has_execution ())
4594 thread_info
*tp
= inferior_thread ();
4595 if (tp
->state
== THREAD_EXITED
|| tp
->executing
)
4601 bpstat_do_actions (void)
4603 auto cleanup_if_error
= make_scope_exit (bpstat_clear_actions
);
4606 /* Do any commands attached to breakpoint we are stopped at. */
4607 while ((tp
= get_bpstat_thread ()) != NULL
)
4609 /* Since in sync mode, bpstat_do_actions may resume the
4610 inferior, and only return when it is stopped at the next
4611 breakpoint, we keep doing breakpoint actions until it returns
4612 false to indicate the inferior was not resumed. */
4613 if (!bpstat_do_actions_1 (&tp
->control
.stop_bpstat
))
4617 cleanup_if_error
.release ();
4620 /* Print out the (old or new) value associated with a watchpoint. */
4623 watchpoint_value_print (struct value
*val
, struct ui_file
*stream
)
4626 fprintf_styled (stream
, metadata_style
.style (), _("<unreadable>"));
4629 struct value_print_options opts
;
4630 get_user_print_options (&opts
);
4631 value_print (val
, stream
, &opts
);
4635 /* Print the "Thread ID hit" part of "Thread ID hit Breakpoint N" if
4636 debugging multiple threads. */
4639 maybe_print_thread_hit_breakpoint (struct ui_out
*uiout
)
4641 if (uiout
->is_mi_like_p ())
4646 if (show_thread_that_caused_stop ())
4649 struct thread_info
*thr
= inferior_thread ();
4651 uiout
->text ("Thread ");
4652 uiout
->field_string ("thread-id", print_thread_id (thr
));
4654 name
= thr
->name
!= NULL
? thr
->name
: target_thread_name (thr
);
4657 uiout
->text (" \"");
4658 uiout
->field_string ("name", name
);
4662 uiout
->text (" hit ");
4666 /* Generic routine for printing messages indicating why we
4667 stopped. The behavior of this function depends on the value
4668 'print_it' in the bpstat structure. Under some circumstances we
4669 may decide not to print anything here and delegate the task to
4672 static enum print_stop_action
4673 print_bp_stop_message (bpstat bs
)
4675 switch (bs
->print_it
)
4678 /* Nothing should be printed for this bpstat entry. */
4679 return PRINT_UNKNOWN
;
4683 /* We still want to print the frame, but we already printed the
4684 relevant messages. */
4685 return PRINT_SRC_AND_LOC
;
4688 case print_it_normal
:
4690 struct breakpoint
*b
= bs
->breakpoint_at
;
4692 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
4693 which has since been deleted. */
4695 return PRINT_UNKNOWN
;
4697 /* Normal case. Call the breakpoint's print_it method. */
4698 return b
->ops
->print_it (bs
);
4703 internal_error (__FILE__
, __LINE__
,
4704 _("print_bp_stop_message: unrecognized enum value"));
4709 /* A helper function that prints a shared library stopped event. */
4712 print_solib_event (int is_catchpoint
)
4714 bool any_deleted
= !current_program_space
->deleted_solibs
.empty ();
4715 bool any_added
= !current_program_space
->added_solibs
.empty ();
4719 if (any_added
|| any_deleted
)
4720 current_uiout
->text (_("Stopped due to shared library event:\n"));
4722 current_uiout
->text (_("Stopped due to shared library event (no "
4723 "libraries added or removed)\n"));
4726 if (current_uiout
->is_mi_like_p ())
4727 current_uiout
->field_string ("reason",
4728 async_reason_lookup (EXEC_ASYNC_SOLIB_EVENT
));
4732 current_uiout
->text (_(" Inferior unloaded "));
4733 ui_out_emit_list
list_emitter (current_uiout
, "removed");
4734 for (int ix
= 0; ix
< current_program_space
->deleted_solibs
.size (); ix
++)
4736 const std::string
&name
= current_program_space
->deleted_solibs
[ix
];
4739 current_uiout
->text (" ");
4740 current_uiout
->field_string ("library", name
);
4741 current_uiout
->text ("\n");
4747 current_uiout
->text (_(" Inferior loaded "));
4748 ui_out_emit_list
list_emitter (current_uiout
, "added");
4750 for (so_list
*iter
: current_program_space
->added_solibs
)
4753 current_uiout
->text (" ");
4755 current_uiout
->field_string ("library", iter
->so_name
);
4756 current_uiout
->text ("\n");
4761 /* Print a message indicating what happened. This is called from
4762 normal_stop(). The input to this routine is the head of the bpstat
4763 list - a list of the eventpoints that caused this stop. KIND is
4764 the target_waitkind for the stopping event. This
4765 routine calls the generic print routine for printing a message
4766 about reasons for stopping. This will print (for example) the
4767 "Breakpoint n," part of the output. The return value of this
4770 PRINT_UNKNOWN: Means we printed nothing.
4771 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
4772 code to print the location. An example is
4773 "Breakpoint 1, " which should be followed by
4775 PRINT_SRC_ONLY: Means we printed something, but there is no need
4776 to also print the location part of the message.
4777 An example is the catch/throw messages, which
4778 don't require a location appended to the end.
4779 PRINT_NOTHING: We have done some printing and we don't need any
4780 further info to be printed. */
4782 enum print_stop_action
4783 bpstat_print (bpstat bs
, int kind
)
4785 enum print_stop_action val
;
4787 /* Maybe another breakpoint in the chain caused us to stop.
4788 (Currently all watchpoints go on the bpstat whether hit or not.
4789 That probably could (should) be changed, provided care is taken
4790 with respect to bpstat_explains_signal). */
4791 for (; bs
; bs
= bs
->next
)
4793 val
= print_bp_stop_message (bs
);
4794 if (val
== PRINT_SRC_ONLY
4795 || val
== PRINT_SRC_AND_LOC
4796 || val
== PRINT_NOTHING
)
4800 /* If we had hit a shared library event breakpoint,
4801 print_bp_stop_message would print out this message. If we hit an
4802 OS-level shared library event, do the same thing. */
4803 if (kind
== TARGET_WAITKIND_LOADED
)
4805 print_solib_event (0);
4806 return PRINT_NOTHING
;
4809 /* We reached the end of the chain, or we got a null BS to start
4810 with and nothing was printed. */
4811 return PRINT_UNKNOWN
;
4814 /* Evaluate the boolean expression EXP and return the result. */
4817 breakpoint_cond_eval (expression
*exp
)
4819 struct value
*mark
= value_mark ();
4820 bool res
= value_true (evaluate_expression (exp
));
4822 value_free_to_mark (mark
);
4826 /* Allocate a new bpstat. Link it to the FIFO list by BS_LINK_POINTER. */
4828 bpstats::bpstats (struct bp_location
*bl
, bpstat
**bs_link_pointer
)
4830 bp_location_at (bp_location_ref_ptr::new_reference (bl
)),
4831 breakpoint_at (bl
->owner
),
4835 print_it (print_it_normal
)
4837 **bs_link_pointer
= this;
4838 *bs_link_pointer
= &next
;
4843 breakpoint_at (NULL
),
4847 print_it (print_it_normal
)
4851 /* The target has stopped with waitstatus WS. Check if any hardware
4852 watchpoints have triggered, according to the target. */
4855 watchpoints_triggered (struct target_waitstatus
*ws
)
4857 bool stopped_by_watchpoint
= target_stopped_by_watchpoint ();
4860 if (!stopped_by_watchpoint
)
4862 /* We were not stopped by a watchpoint. Mark all watchpoints
4863 as not triggered. */
4864 for (breakpoint
*b
: all_breakpoints ())
4865 if (is_hardware_watchpoint (b
))
4867 struct watchpoint
*w
= (struct watchpoint
*) b
;
4869 w
->watchpoint_triggered
= watch_triggered_no
;
4875 if (!target_stopped_data_address (current_inferior ()->top_target (), &addr
))
4877 /* We were stopped by a watchpoint, but we don't know where.
4878 Mark all watchpoints as unknown. */
4879 for (breakpoint
*b
: all_breakpoints ())
4880 if (is_hardware_watchpoint (b
))
4882 struct watchpoint
*w
= (struct watchpoint
*) b
;
4884 w
->watchpoint_triggered
= watch_triggered_unknown
;
4890 /* The target could report the data address. Mark watchpoints
4891 affected by this data address as triggered, and all others as not
4894 for (breakpoint
*b
: all_breakpoints ())
4895 if (is_hardware_watchpoint (b
))
4897 struct watchpoint
*w
= (struct watchpoint
*) b
;
4899 w
->watchpoint_triggered
= watch_triggered_no
;
4900 for (bp_location
*loc
: b
->locations ())
4902 if (is_masked_watchpoint (b
))
4904 CORE_ADDR newaddr
= addr
& w
->hw_wp_mask
;
4905 CORE_ADDR start
= loc
->address
& w
->hw_wp_mask
;
4907 if (newaddr
== start
)
4909 w
->watchpoint_triggered
= watch_triggered_yes
;
4913 /* Exact match not required. Within range is sufficient. */
4914 else if (target_watchpoint_addr_within_range
4915 (current_inferior ()->top_target (), addr
, loc
->address
,
4918 w
->watchpoint_triggered
= watch_triggered_yes
;
4927 /* Possible return values for watchpoint_check. */
4928 enum wp_check_result
4930 /* The watchpoint has been deleted. */
4933 /* The value has changed. */
4934 WP_VALUE_CHANGED
= 2,
4936 /* The value has not changed. */
4937 WP_VALUE_NOT_CHANGED
= 3,
4939 /* Ignore this watchpoint, no matter if the value changed or not. */
4943 #define BP_TEMPFLAG 1
4944 #define BP_HARDWAREFLAG 2
4946 /* Evaluate watchpoint condition expression and check if its value
4949 static wp_check_result
4950 watchpoint_check (bpstat bs
)
4952 struct watchpoint
*b
;
4953 struct frame_info
*fr
;
4954 int within_current_scope
;
4956 /* BS is built from an existing struct breakpoint. */
4957 gdb_assert (bs
->breakpoint_at
!= NULL
);
4958 b
= (struct watchpoint
*) bs
->breakpoint_at
;
4960 /* If this is a local watchpoint, we only want to check if the
4961 watchpoint frame is in scope if the current thread is the thread
4962 that was used to create the watchpoint. */
4963 if (!watchpoint_in_thread_scope (b
))
4966 if (b
->exp_valid_block
== NULL
)
4967 within_current_scope
= 1;
4970 struct frame_info
*frame
= get_current_frame ();
4971 struct gdbarch
*frame_arch
= get_frame_arch (frame
);
4972 CORE_ADDR frame_pc
= get_frame_pc (frame
);
4974 /* stack_frame_destroyed_p() returns a non-zero value if we're
4975 still in the function but the stack frame has already been
4976 invalidated. Since we can't rely on the values of local
4977 variables after the stack has been destroyed, we are treating
4978 the watchpoint in that state as `not changed' without further
4979 checking. Don't mark watchpoints as changed if the current
4980 frame is in an epilogue - even if they are in some other
4981 frame, our view of the stack is likely to be wrong and
4982 frame_find_by_id could error out. */
4983 if (gdbarch_stack_frame_destroyed_p (frame_arch
, frame_pc
))
4986 fr
= frame_find_by_id (b
->watchpoint_frame
);
4987 within_current_scope
= (fr
!= NULL
);
4989 /* If we've gotten confused in the unwinder, we might have
4990 returned a frame that can't describe this variable. */
4991 if (within_current_scope
)
4993 struct symbol
*function
;
4995 function
= get_frame_function (fr
);
4996 if (function
== NULL
4997 || !contained_in (b
->exp_valid_block
,
4998 SYMBOL_BLOCK_VALUE (function
)))
4999 within_current_scope
= 0;
5002 if (within_current_scope
)
5003 /* If we end up stopping, the current frame will get selected
5004 in normal_stop. So this call to select_frame won't affect
5009 if (within_current_scope
)
5011 /* We use value_{,free_to_}mark because it could be a *long*
5012 time before we return to the command level and call
5013 free_all_values. We can't call free_all_values because we
5014 might be in the middle of evaluating a function call. */
5017 struct value
*new_val
;
5019 if (is_masked_watchpoint (b
))
5020 /* Since we don't know the exact trigger address (from
5021 stopped_data_address), just tell the user we've triggered
5022 a mask watchpoint. */
5023 return WP_VALUE_CHANGED
;
5025 mark
= value_mark ();
5026 fetch_subexp_value (b
->exp
.get (), b
->exp
->op
.get (), &new_val
,
5029 if (b
->val_bitsize
!= 0)
5030 new_val
= extract_bitfield_from_watchpoint_value (b
, new_val
);
5032 /* We use value_equal_contents instead of value_equal because
5033 the latter coerces an array to a pointer, thus comparing just
5034 the address of the array instead of its contents. This is
5035 not what we want. */
5036 if ((b
->val
!= NULL
) != (new_val
!= NULL
)
5037 || (b
->val
!= NULL
&& !value_equal_contents (b
->val
.get (),
5040 bs
->old_val
= b
->val
;
5041 b
->val
= release_value (new_val
);
5042 b
->val_valid
= true;
5043 if (new_val
!= NULL
)
5044 value_free_to_mark (mark
);
5045 return WP_VALUE_CHANGED
;
5049 /* Nothing changed. */
5050 value_free_to_mark (mark
);
5051 return WP_VALUE_NOT_CHANGED
;
5056 /* This seems like the only logical thing to do because
5057 if we temporarily ignored the watchpoint, then when
5058 we reenter the block in which it is valid it contains
5059 garbage (in the case of a function, it may have two
5060 garbage values, one before and one after the prologue).
5061 So we can't even detect the first assignment to it and
5062 watch after that (since the garbage may or may not equal
5063 the first value assigned). */
5064 /* We print all the stop information in
5065 breakpoint_ops->print_it, but in this case, by the time we
5066 call breakpoint_ops->print_it this bp will be deleted
5067 already. So we have no choice but print the information
5070 SWITCH_THRU_ALL_UIS ()
5072 struct ui_out
*uiout
= current_uiout
;
5074 if (uiout
->is_mi_like_p ())
5076 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
5077 uiout
->message ("\nWatchpoint %pF deleted because the program has "
5078 "left the block in\n"
5079 "which its expression is valid.\n",
5080 signed_field ("wpnum", b
->number
));
5083 /* Make sure the watchpoint's commands aren't executed. */
5085 watchpoint_del_at_next_stop (b
);
5091 /* Return true if it looks like target has stopped due to hitting
5092 breakpoint location BL. This function does not check if we should
5093 stop, only if BL explains the stop. */
5096 bpstat_check_location (const struct bp_location
*bl
,
5097 const address_space
*aspace
, CORE_ADDR bp_addr
,
5098 const struct target_waitstatus
*ws
)
5100 struct breakpoint
*b
= bl
->owner
;
5102 /* BL is from an existing breakpoint. */
5103 gdb_assert (b
!= NULL
);
5105 return b
->ops
->breakpoint_hit (bl
, aspace
, bp_addr
, ws
);
5108 /* Determine if the watched values have actually changed, and we
5109 should stop. If not, set BS->stop to 0. */
5112 bpstat_check_watchpoint (bpstat bs
)
5114 const struct bp_location
*bl
;
5115 struct watchpoint
*b
;
5117 /* BS is built for existing struct breakpoint. */
5118 bl
= bs
->bp_location_at
.get ();
5119 gdb_assert (bl
!= NULL
);
5120 b
= (struct watchpoint
*) bs
->breakpoint_at
;
5121 gdb_assert (b
!= NULL
);
5124 int must_check_value
= 0;
5126 if (b
->type
== bp_watchpoint
)
5127 /* For a software watchpoint, we must always check the
5129 must_check_value
= 1;
5130 else if (b
->watchpoint_triggered
== watch_triggered_yes
)
5131 /* We have a hardware watchpoint (read, write, or access)
5132 and the target earlier reported an address watched by
5134 must_check_value
= 1;
5135 else if (b
->watchpoint_triggered
== watch_triggered_unknown
5136 && b
->type
== bp_hardware_watchpoint
)
5137 /* We were stopped by a hardware watchpoint, but the target could
5138 not report the data address. We must check the watchpoint's
5139 value. Access and read watchpoints are out of luck; without
5140 a data address, we can't figure it out. */
5141 must_check_value
= 1;
5143 if (must_check_value
)
5149 e
= watchpoint_check (bs
);
5151 catch (const gdb_exception
&ex
)
5153 exception_fprintf (gdb_stderr
, ex
,
5154 "Error evaluating expression "
5155 "for watchpoint %d\n",
5158 SWITCH_THRU_ALL_UIS ()
5160 printf_filtered (_("Watchpoint %d deleted.\n"),
5163 watchpoint_del_at_next_stop (b
);
5170 /* We've already printed what needs to be printed. */
5171 bs
->print_it
= print_it_done
;
5175 bs
->print_it
= print_it_noop
;
5178 case WP_VALUE_CHANGED
:
5179 if (b
->type
== bp_read_watchpoint
)
5181 /* There are two cases to consider here:
5183 1. We're watching the triggered memory for reads.
5184 In that case, trust the target, and always report
5185 the watchpoint hit to the user. Even though
5186 reads don't cause value changes, the value may
5187 have changed since the last time it was read, and
5188 since we're not trapping writes, we will not see
5189 those, and as such we should ignore our notion of
5192 2. We're watching the triggered memory for both
5193 reads and writes. There are two ways this may
5196 2.1. This is a target that can't break on data
5197 reads only, but can break on accesses (reads or
5198 writes), such as e.g., x86. We detect this case
5199 at the time we try to insert read watchpoints.
5201 2.2. Otherwise, the target supports read
5202 watchpoints, but, the user set an access or write
5203 watchpoint watching the same memory as this read
5206 If we're watching memory writes as well as reads,
5207 ignore watchpoint hits when we find that the
5208 value hasn't changed, as reads don't cause
5209 changes. This still gives false positives when
5210 the program writes the same value to memory as
5211 what there was already in memory (we will confuse
5212 it for a read), but it's much better than
5215 int other_write_watchpoint
= 0;
5217 if (bl
->watchpoint_type
== hw_read
)
5219 for (breakpoint
*other_b
: all_breakpoints ())
5220 if (other_b
->type
== bp_hardware_watchpoint
5221 || other_b
->type
== bp_access_watchpoint
)
5223 struct watchpoint
*other_w
=
5224 (struct watchpoint
*) other_b
;
5226 if (other_w
->watchpoint_triggered
5227 == watch_triggered_yes
)
5229 other_write_watchpoint
= 1;
5235 if (other_write_watchpoint
5236 || bl
->watchpoint_type
== hw_access
)
5238 /* We're watching the same memory for writes,
5239 and the value changed since the last time we
5240 updated it, so this trap must be for a write.
5242 bs
->print_it
= print_it_noop
;
5247 case WP_VALUE_NOT_CHANGED
:
5248 if (b
->type
== bp_hardware_watchpoint
5249 || b
->type
== bp_watchpoint
)
5251 /* Don't stop: write watchpoints shouldn't fire if
5252 the value hasn't changed. */
5253 bs
->print_it
= print_it_noop
;
5263 else /* must_check_value == 0 */
5265 /* This is a case where some watchpoint(s) triggered, but
5266 not at the address of this watchpoint, or else no
5267 watchpoint triggered after all. So don't print
5268 anything for this watchpoint. */
5269 bs
->print_it
= print_it_noop
;
5275 /* For breakpoints that are currently marked as telling gdb to stop,
5276 check conditions (condition proper, frame, thread and ignore count)
5277 of breakpoint referred to by BS. If we should not stop for this
5278 breakpoint, set BS->stop to 0. */
5281 bpstat_check_breakpoint_conditions (bpstat bs
, thread_info
*thread
)
5283 const struct bp_location
*bl
;
5284 struct breakpoint
*b
;
5286 bool condition_result
= true;
5287 struct expression
*cond
;
5289 gdb_assert (bs
->stop
);
5291 /* BS is built for existing struct breakpoint. */
5292 bl
= bs
->bp_location_at
.get ();
5293 gdb_assert (bl
!= NULL
);
5294 b
= bs
->breakpoint_at
;
5295 gdb_assert (b
!= NULL
);
5297 /* Even if the target evaluated the condition on its end and notified GDB, we
5298 need to do so again since GDB does not know if we stopped due to a
5299 breakpoint or a single step breakpoint. */
5301 if (frame_id_p (b
->frame_id
)
5302 && !frame_id_eq (b
->frame_id
, get_stack_frame_id (get_current_frame ())))
5308 /* If this is a thread/task-specific breakpoint, don't waste cpu
5309 evaluating the condition if this isn't the specified
5311 if ((b
->thread
!= -1 && b
->thread
!= thread
->global_num
)
5312 || (b
->task
!= 0 && b
->task
!= ada_get_task_number (thread
)))
5318 /* Evaluate extension language breakpoints that have a "stop" method
5320 bs
->stop
= breakpoint_ext_lang_cond_says_stop (b
);
5322 if (is_watchpoint (b
))
5324 struct watchpoint
*w
= (struct watchpoint
*) b
;
5326 cond
= w
->cond_exp
.get ();
5329 cond
= bl
->cond
.get ();
5331 if (cond
&& b
->disposition
!= disp_del_at_next_stop
)
5333 int within_current_scope
= 1;
5334 struct watchpoint
* w
;
5336 /* We use value_mark and value_free_to_mark because it could
5337 be a long time before we return to the command level and
5338 call free_all_values. We can't call free_all_values
5339 because we might be in the middle of evaluating a
5341 struct value
*mark
= value_mark ();
5343 if (is_watchpoint (b
))
5344 w
= (struct watchpoint
*) b
;
5348 /* Need to select the frame, with all that implies so that
5349 the conditions will have the right context. Because we
5350 use the frame, we will not see an inlined function's
5351 variables when we arrive at a breakpoint at the start
5352 of the inlined function; the current frame will be the
5354 if (w
== NULL
|| w
->cond_exp_valid_block
== NULL
)
5355 select_frame (get_current_frame ());
5358 struct frame_info
*frame
;
5360 /* For local watchpoint expressions, which particular
5361 instance of a local is being watched matters, so we
5362 keep track of the frame to evaluate the expression
5363 in. To evaluate the condition however, it doesn't
5364 really matter which instantiation of the function
5365 where the condition makes sense triggers the
5366 watchpoint. This allows an expression like "watch
5367 global if q > 10" set in `func', catch writes to
5368 global on all threads that call `func', or catch
5369 writes on all recursive calls of `func' by a single
5370 thread. We simply always evaluate the condition in
5371 the innermost frame that's executing where it makes
5372 sense to evaluate the condition. It seems
5374 frame
= block_innermost_frame (w
->cond_exp_valid_block
);
5376 select_frame (frame
);
5378 within_current_scope
= 0;
5380 if (within_current_scope
)
5384 condition_result
= breakpoint_cond_eval (cond
);
5386 catch (const gdb_exception
&ex
)
5388 exception_fprintf (gdb_stderr
, ex
,
5389 "Error in testing breakpoint condition:\n");
5394 warning (_("Watchpoint condition cannot be tested "
5395 "in the current scope"));
5396 /* If we failed to set the right context for this
5397 watchpoint, unconditionally report it. */
5399 /* FIXME-someday, should give breakpoint #. */
5400 value_free_to_mark (mark
);
5403 if (cond
&& !condition_result
)
5407 else if (b
->ignore_count
> 0)
5411 /* Increase the hit count even though we don't stop. */
5413 gdb::observers::breakpoint_modified
.notify (b
);
5417 /* Returns true if we need to track moribund locations of LOC's type
5418 on the current target. */
5421 need_moribund_for_location_type (struct bp_location
*loc
)
5423 return ((loc
->loc_type
== bp_loc_software_breakpoint
5424 && !target_supports_stopped_by_sw_breakpoint ())
5425 || (loc
->loc_type
== bp_loc_hardware_breakpoint
5426 && !target_supports_stopped_by_hw_breakpoint ()));
5429 /* See breakpoint.h. */
5432 build_bpstat_chain (const address_space
*aspace
, CORE_ADDR bp_addr
,
5433 const struct target_waitstatus
*ws
)
5435 bpstat bs_head
= NULL
, *bs_link
= &bs_head
;
5437 for (breakpoint
*b
: all_breakpoints ())
5439 if (!breakpoint_enabled (b
))
5442 for (bp_location
*bl
: b
->locations ())
5444 /* For hardware watchpoints, we look only at the first
5445 location. The watchpoint_check function will work on the
5446 entire expression, not the individual locations. For
5447 read watchpoints, the watchpoints_triggered function has
5448 checked all locations already. */
5449 if (b
->type
== bp_hardware_watchpoint
&& bl
!= b
->loc
)
5452 if (!bl
->enabled
|| bl
->disabled_by_cond
|| bl
->shlib_disabled
)
5455 if (!bpstat_check_location (bl
, aspace
, bp_addr
, ws
))
5458 /* Come here if it's a watchpoint, or if the break address
5461 bpstat bs
= new bpstats (bl
, &bs_link
); /* Alloc a bpstat to
5464 /* Assume we stop. Should we find a watchpoint that is not
5465 actually triggered, or if the condition of the breakpoint
5466 evaluates as false, we'll reset 'stop' to 0. */
5470 /* If this is a scope breakpoint, mark the associated
5471 watchpoint as triggered so that we will handle the
5472 out-of-scope event. We'll get to the watchpoint next
5474 if (b
->type
== bp_watchpoint_scope
&& b
->related_breakpoint
!= b
)
5476 struct watchpoint
*w
= (struct watchpoint
*) b
->related_breakpoint
;
5478 w
->watchpoint_triggered
= watch_triggered_yes
;
5483 /* Check if a moribund breakpoint explains the stop. */
5484 if (!target_supports_stopped_by_sw_breakpoint ()
5485 || !target_supports_stopped_by_hw_breakpoint ())
5487 for (bp_location
*loc
: moribund_locations
)
5489 if (breakpoint_location_address_match (loc
, aspace
, bp_addr
)
5490 && need_moribund_for_location_type (loc
))
5492 bpstat bs
= new bpstats (loc
, &bs_link
);
5493 /* For hits of moribund locations, we should just proceed. */
5496 bs
->print_it
= print_it_noop
;
5504 /* See breakpoint.h. */
5507 bpstat_stop_status (const address_space
*aspace
,
5508 CORE_ADDR bp_addr
, thread_info
*thread
,
5509 const struct target_waitstatus
*ws
,
5512 struct breakpoint
*b
= NULL
;
5513 /* First item of allocated bpstat's. */
5514 bpstat bs_head
= stop_chain
;
5516 int need_remove_insert
;
5519 /* First, build the bpstat chain with locations that explain a
5520 target stop, while being careful to not set the target running,
5521 as that may invalidate locations (in particular watchpoint
5522 locations are recreated). Resuming will happen here with
5523 breakpoint conditions or watchpoint expressions that include
5524 inferior function calls. */
5525 if (bs_head
== NULL
)
5526 bs_head
= build_bpstat_chain (aspace
, bp_addr
, ws
);
5528 /* A bit of special processing for shlib breakpoints. We need to
5529 process solib loading here, so that the lists of loaded and
5530 unloaded libraries are correct before we handle "catch load" and
5532 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5534 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->type
== bp_shlib_event
)
5536 handle_solib_event ();
5541 /* Now go through the locations that caused the target to stop, and
5542 check whether we're interested in reporting this stop to higher
5543 layers, or whether we should resume the target transparently. */
5547 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5552 b
= bs
->breakpoint_at
;
5553 b
->ops
->check_status (bs
);
5556 bpstat_check_breakpoint_conditions (bs
, thread
);
5561 gdb::observers::breakpoint_modified
.notify (b
);
5563 /* We will stop here. */
5564 if (b
->disposition
== disp_disable
)
5566 --(b
->enable_count
);
5567 if (b
->enable_count
<= 0)
5568 b
->enable_state
= bp_disabled
;
5573 bs
->commands
= b
->commands
;
5574 if (command_line_is_silent (bs
->commands
5575 ? bs
->commands
.get () : NULL
))
5578 b
->ops
->after_condition_true (bs
);
5583 /* Print nothing for this entry if we don't stop or don't
5585 if (!bs
->stop
|| !bs
->print
)
5586 bs
->print_it
= print_it_noop
;
5589 /* If we aren't stopping, the value of some hardware watchpoint may
5590 not have changed, but the intermediate memory locations we are
5591 watching may have. Don't bother if we're stopping; this will get
5593 need_remove_insert
= 0;
5594 if (! bpstat_causes_stop (bs_head
))
5595 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5597 && bs
->breakpoint_at
5598 && is_hardware_watchpoint (bs
->breakpoint_at
))
5600 struct watchpoint
*w
= (struct watchpoint
*) bs
->breakpoint_at
;
5602 update_watchpoint (w
, 0 /* don't reparse. */);
5603 need_remove_insert
= 1;
5606 if (need_remove_insert
)
5607 update_global_location_list (UGLL_MAY_INSERT
);
5608 else if (removed_any
)
5609 update_global_location_list (UGLL_DONT_INSERT
);
5615 handle_jit_event (CORE_ADDR address
)
5617 struct gdbarch
*gdbarch
;
5619 infrun_debug_printf ("handling bp_jit_event");
5621 /* Switch terminal for any messages produced by
5622 breakpoint_re_set. */
5623 target_terminal::ours_for_output ();
5625 gdbarch
= get_frame_arch (get_current_frame ());
5626 /* This event is caused by a breakpoint set in `jit_breakpoint_re_set`,
5627 thus it is expected that its objectfile can be found through
5628 minimal symbol lookup. If it doesn't work (and assert fails), it
5629 most likely means that `jit_breakpoint_re_set` was changes and this
5630 function needs to be updated too. */
5631 bound_minimal_symbol jit_bp_sym
= lookup_minimal_symbol_by_pc (address
);
5632 gdb_assert (jit_bp_sym
.objfile
!= nullptr);
5633 jit_event_handler (gdbarch
, jit_bp_sym
.objfile
);
5635 target_terminal::inferior ();
5638 /* Prepare WHAT final decision for infrun. */
5640 /* Decide what infrun needs to do with this bpstat. */
5643 bpstat_what (bpstat bs_head
)
5645 struct bpstat_what retval
;
5648 retval
.main_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5649 retval
.call_dummy
= STOP_NONE
;
5650 retval
.is_longjmp
= false;
5652 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5654 /* Extract this BS's action. After processing each BS, we check
5655 if its action overrides all we've seem so far. */
5656 enum bpstat_what_main_action this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5659 if (bs
->breakpoint_at
== NULL
)
5661 /* I suspect this can happen if it was a momentary
5662 breakpoint which has since been deleted. */
5666 bptype
= bs
->breakpoint_at
->type
;
5673 case bp_hardware_breakpoint
:
5674 case bp_single_step
:
5677 case bp_shlib_event
:
5681 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5683 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5686 this_action
= BPSTAT_WHAT_SINGLE
;
5689 case bp_hardware_watchpoint
:
5690 case bp_read_watchpoint
:
5691 case bp_access_watchpoint
:
5695 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5697 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5701 /* There was a watchpoint, but we're not stopping.
5702 This requires no further action. */
5706 case bp_longjmp_call_dummy
:
5710 this_action
= BPSTAT_WHAT_SET_LONGJMP_RESUME
;
5711 retval
.is_longjmp
= bptype
!= bp_exception
;
5714 this_action
= BPSTAT_WHAT_SINGLE
;
5716 case bp_longjmp_resume
:
5717 case bp_exception_resume
:
5720 this_action
= BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
;
5721 retval
.is_longjmp
= bptype
== bp_longjmp_resume
;
5724 this_action
= BPSTAT_WHAT_SINGLE
;
5726 case bp_step_resume
:
5728 this_action
= BPSTAT_WHAT_STEP_RESUME
;
5731 /* It is for the wrong frame. */
5732 this_action
= BPSTAT_WHAT_SINGLE
;
5735 case bp_hp_step_resume
:
5737 this_action
= BPSTAT_WHAT_HP_STEP_RESUME
;
5740 /* It is for the wrong frame. */
5741 this_action
= BPSTAT_WHAT_SINGLE
;
5744 case bp_watchpoint_scope
:
5745 case bp_thread_event
:
5746 case bp_overlay_event
:
5747 case bp_longjmp_master
:
5748 case bp_std_terminate_master
:
5749 case bp_exception_master
:
5750 this_action
= BPSTAT_WHAT_SINGLE
;
5756 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5758 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5762 /* Some catchpoints are implemented with breakpoints.
5763 For those, we need to step over the breakpoint. */
5764 if (bs
->bp_location_at
->loc_type
!= bp_loc_other
)
5765 this_action
= BPSTAT_WHAT_SINGLE
;
5769 this_action
= BPSTAT_WHAT_SINGLE
;
5772 /* Make sure the action is stop (silent or noisy),
5773 so infrun.c pops the dummy frame. */
5774 retval
.call_dummy
= STOP_STACK_DUMMY
;
5775 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5777 case bp_std_terminate
:
5778 /* Make sure the action is stop (silent or noisy),
5779 so infrun.c pops the dummy frame. */
5780 retval
.call_dummy
= STOP_STD_TERMINATE
;
5781 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5784 case bp_fast_tracepoint
:
5785 case bp_static_tracepoint
:
5786 /* Tracepoint hits should not be reported back to GDB, and
5787 if one got through somehow, it should have been filtered
5789 internal_error (__FILE__
, __LINE__
,
5790 _("bpstat_what: tracepoint encountered"));
5792 case bp_gnu_ifunc_resolver
:
5793 /* Step over it (and insert bp_gnu_ifunc_resolver_return). */
5794 this_action
= BPSTAT_WHAT_SINGLE
;
5796 case bp_gnu_ifunc_resolver_return
:
5797 /* The breakpoint will be removed, execution will restart from the
5798 PC of the former breakpoint. */
5799 this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5804 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5806 this_action
= BPSTAT_WHAT_SINGLE
;
5810 internal_error (__FILE__
, __LINE__
,
5811 _("bpstat_what: unhandled bptype %d"), (int) bptype
);
5814 retval
.main_action
= std::max (retval
.main_action
, this_action
);
5821 bpstat_run_callbacks (bpstat bs_head
)
5825 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5827 struct breakpoint
*b
= bs
->breakpoint_at
;
5834 handle_jit_event (bs
->bp_location_at
->address
);
5836 case bp_gnu_ifunc_resolver
:
5837 gnu_ifunc_resolver_stop (b
);
5839 case bp_gnu_ifunc_resolver_return
:
5840 gnu_ifunc_resolver_return_stop (b
);
5846 /* See breakpoint.h. */
5849 bpstat_should_step ()
5851 for (breakpoint
*b
: all_breakpoints ())
5852 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
&& b
->loc
!= NULL
)
5858 /* See breakpoint.h. */
5861 bpstat_causes_stop (bpstat bs
)
5863 for (; bs
!= NULL
; bs
= bs
->next
)
5872 /* Compute a string of spaces suitable to indent the next line
5873 so it starts at the position corresponding to the table column
5874 named COL_NAME in the currently active table of UIOUT. */
5877 wrap_indent_at_field (struct ui_out
*uiout
, const char *col_name
)
5879 static char wrap_indent
[80];
5880 int i
, total_width
, width
, align
;
5884 for (i
= 1; uiout
->query_table_field (i
, &width
, &align
, &text
); i
++)
5886 if (strcmp (text
, col_name
) == 0)
5888 gdb_assert (total_width
< sizeof wrap_indent
);
5889 memset (wrap_indent
, ' ', total_width
);
5890 wrap_indent
[total_width
] = 0;
5895 total_width
+= width
+ 1;
5901 /* Determine if the locations of this breakpoint will have their conditions
5902 evaluated by the target, host or a mix of both. Returns the following:
5904 "host": Host evals condition.
5905 "host or target": Host or Target evals condition.
5906 "target": Target evals condition.
5910 bp_condition_evaluator (struct breakpoint
*b
)
5912 char host_evals
= 0;
5913 char target_evals
= 0;
5918 if (!is_breakpoint (b
))
5921 if (gdb_evaluates_breakpoint_condition_p ()
5922 || !target_supports_evaluation_of_breakpoint_conditions ())
5923 return condition_evaluation_host
;
5925 for (bp_location
*bl
: b
->locations ())
5927 if (bl
->cond_bytecode
)
5933 if (host_evals
&& target_evals
)
5934 return condition_evaluation_both
;
5935 else if (target_evals
)
5936 return condition_evaluation_target
;
5938 return condition_evaluation_host
;
5941 /* Determine the breakpoint location's condition evaluator. This is
5942 similar to bp_condition_evaluator, but for locations. */
5945 bp_location_condition_evaluator (struct bp_location
*bl
)
5947 if (bl
&& !is_breakpoint (bl
->owner
))
5950 if (gdb_evaluates_breakpoint_condition_p ()
5951 || !target_supports_evaluation_of_breakpoint_conditions ())
5952 return condition_evaluation_host
;
5954 if (bl
&& bl
->cond_bytecode
)
5955 return condition_evaluation_target
;
5957 return condition_evaluation_host
;
5960 /* Print the LOC location out of the list of B->LOC locations. */
5963 print_breakpoint_location (struct breakpoint
*b
,
5964 struct bp_location
*loc
)
5966 struct ui_out
*uiout
= current_uiout
;
5968 scoped_restore_current_program_space restore_pspace
;
5970 if (loc
!= NULL
&& loc
->shlib_disabled
)
5974 set_current_program_space (loc
->pspace
);
5976 if (b
->display_canonical
)
5977 uiout
->field_string ("what", event_location_to_string (b
->location
.get ()));
5978 else if (loc
&& loc
->symtab
)
5980 const struct symbol
*sym
= loc
->symbol
;
5984 uiout
->text ("in ");
5985 uiout
->field_string ("func", sym
->print_name (),
5986 function_name_style
.style ());
5988 uiout
->wrap_hint (wrap_indent_at_field (uiout
, "what"));
5989 uiout
->text ("at ");
5991 uiout
->field_string ("file",
5992 symtab_to_filename_for_display (loc
->symtab
),
5993 file_name_style
.style ());
5996 if (uiout
->is_mi_like_p ())
5997 uiout
->field_string ("fullname", symtab_to_fullname (loc
->symtab
));
5999 uiout
->field_signed ("line", loc
->line_number
);
6005 print_address_symbolic (loc
->gdbarch
, loc
->address
, &stb
,
6007 uiout
->field_stream ("at", stb
);
6011 uiout
->field_string ("pending",
6012 event_location_to_string (b
->location
.get ()));
6013 /* If extra_string is available, it could be holding a condition
6014 or dprintf arguments. In either case, make sure it is printed,
6015 too, but only for non-MI streams. */
6016 if (!uiout
->is_mi_like_p () && b
->extra_string
!= NULL
)
6018 if (b
->type
== bp_dprintf
)
6022 uiout
->text (b
->extra_string
);
6026 if (loc
&& is_breakpoint (b
)
6027 && breakpoint_condition_evaluation_mode () == condition_evaluation_target
6028 && bp_condition_evaluator (b
) == condition_evaluation_both
)
6031 uiout
->field_string ("evaluated-by",
6032 bp_location_condition_evaluator (loc
));
6038 bptype_string (enum bptype type
)
6040 struct ep_type_description
6043 const char *description
;
6045 static struct ep_type_description bptypes
[] =
6047 {bp_none
, "?deleted?"},
6048 {bp_breakpoint
, "breakpoint"},
6049 {bp_hardware_breakpoint
, "hw breakpoint"},
6050 {bp_single_step
, "sw single-step"},
6051 {bp_until
, "until"},
6052 {bp_finish
, "finish"},
6053 {bp_watchpoint
, "watchpoint"},
6054 {bp_hardware_watchpoint
, "hw watchpoint"},
6055 {bp_read_watchpoint
, "read watchpoint"},
6056 {bp_access_watchpoint
, "acc watchpoint"},
6057 {bp_longjmp
, "longjmp"},
6058 {bp_longjmp_resume
, "longjmp resume"},
6059 {bp_longjmp_call_dummy
, "longjmp for call dummy"},
6060 {bp_exception
, "exception"},
6061 {bp_exception_resume
, "exception resume"},
6062 {bp_step_resume
, "step resume"},
6063 {bp_hp_step_resume
, "high-priority step resume"},
6064 {bp_watchpoint_scope
, "watchpoint scope"},
6065 {bp_call_dummy
, "call dummy"},
6066 {bp_std_terminate
, "std::terminate"},
6067 {bp_shlib_event
, "shlib events"},
6068 {bp_thread_event
, "thread events"},
6069 {bp_overlay_event
, "overlay events"},
6070 {bp_longjmp_master
, "longjmp master"},
6071 {bp_std_terminate_master
, "std::terminate master"},
6072 {bp_exception_master
, "exception master"},
6073 {bp_catchpoint
, "catchpoint"},
6074 {bp_tracepoint
, "tracepoint"},
6075 {bp_fast_tracepoint
, "fast tracepoint"},
6076 {bp_static_tracepoint
, "static tracepoint"},
6077 {bp_dprintf
, "dprintf"},
6078 {bp_jit_event
, "jit events"},
6079 {bp_gnu_ifunc_resolver
, "STT_GNU_IFUNC resolver"},
6080 {bp_gnu_ifunc_resolver_return
, "STT_GNU_IFUNC resolver return"},
6083 if (((int) type
>= (sizeof (bptypes
) / sizeof (bptypes
[0])))
6084 || ((int) type
!= bptypes
[(int) type
].type
))
6085 internal_error (__FILE__
, __LINE__
,
6086 _("bptypes table does not describe type #%d."),
6089 return bptypes
[(int) type
].description
;
6092 /* For MI, output a field named 'thread-groups' with a list as the value.
6093 For CLI, prefix the list with the string 'inf'. */
6096 output_thread_groups (struct ui_out
*uiout
,
6097 const char *field_name
,
6098 const std::vector
<int> &inf_nums
,
6101 int is_mi
= uiout
->is_mi_like_p ();
6103 /* For backward compatibility, don't display inferiors in CLI unless
6104 there are several. Always display them for MI. */
6105 if (!is_mi
&& mi_only
)
6108 ui_out_emit_list
list_emitter (uiout
, field_name
);
6110 for (size_t i
= 0; i
< inf_nums
.size (); i
++)
6116 xsnprintf (mi_group
, sizeof (mi_group
), "i%d", inf_nums
[i
]);
6117 uiout
->field_string (NULL
, mi_group
);
6122 uiout
->text (" inf ");
6126 uiout
->text (plongest (inf_nums
[i
]));
6131 /* Print B to gdb_stdout. If RAW_LOC, print raw breakpoint locations
6132 instead of going via breakpoint_ops::print_one. This makes "maint
6133 info breakpoints" show the software breakpoint locations of
6134 catchpoints, which are considered internal implementation
6138 print_one_breakpoint_location (struct breakpoint
*b
,
6139 struct bp_location
*loc
,
6141 struct bp_location
**last_loc
,
6142 int allflag
, bool raw_loc
)
6144 struct command_line
*l
;
6145 static char bpenables
[] = "nynny";
6147 struct ui_out
*uiout
= current_uiout
;
6148 int header_of_multiple
= 0;
6149 int part_of_multiple
= (loc
!= NULL
);
6150 struct value_print_options opts
;
6152 get_user_print_options (&opts
);
6154 gdb_assert (!loc
|| loc_number
!= 0);
6155 /* See comment in print_one_breakpoint concerning treatment of
6156 breakpoints with single disabled location. */
6159 && (b
->loc
->next
!= NULL
6160 || !b
->loc
->enabled
|| b
->loc
->disabled_by_cond
)))
6161 header_of_multiple
= 1;
6169 if (part_of_multiple
)
6170 uiout
->field_fmt ("number", "%d.%d", b
->number
, loc_number
);
6172 uiout
->field_signed ("number", b
->number
);
6176 if (part_of_multiple
)
6177 uiout
->field_skip ("type");
6179 uiout
->field_string ("type", bptype_string (b
->type
));
6183 if (part_of_multiple
)
6184 uiout
->field_skip ("disp");
6186 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
6190 /* For locations that are disabled because of an invalid condition,
6191 display "N*" on CLI, where "*" refers to a footnote below the
6192 table. For MI, simply display a "N" without a footnote. */
6193 const char *N
= (uiout
->is_mi_like_p ()) ? "N" : "N*";
6194 if (part_of_multiple
)
6195 uiout
->field_string ("enabled", (loc
->disabled_by_cond
? N
6196 : (loc
->enabled
? "y" : "n")));
6198 uiout
->field_fmt ("enabled", "%c", bpenables
[(int) b
->enable_state
]);
6201 if (!raw_loc
&& b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
6202 b
->ops
->print_one (b
, last_loc
);
6205 if (is_watchpoint (b
))
6207 struct watchpoint
*w
= (struct watchpoint
*) b
;
6209 /* Field 4, the address, is omitted (which makes the columns
6210 not line up too nicely with the headers, but the effect
6211 is relatively readable). */
6212 if (opts
.addressprint
)
6213 uiout
->field_skip ("addr");
6215 uiout
->field_string ("what", w
->exp_string
);
6217 else if (!is_catchpoint (b
) || is_exception_catchpoint (b
)
6218 || is_ada_exception_catchpoint (b
))
6220 if (opts
.addressprint
)
6223 if (header_of_multiple
)
6224 uiout
->field_string ("addr", "<MULTIPLE>",
6225 metadata_style
.style ());
6226 else if (b
->loc
== NULL
|| loc
->shlib_disabled
)
6227 uiout
->field_string ("addr", "<PENDING>",
6228 metadata_style
.style ());
6230 uiout
->field_core_addr ("addr",
6231 loc
->gdbarch
, loc
->address
);
6234 if (!header_of_multiple
)
6235 print_breakpoint_location (b
, loc
);
6241 if (loc
!= NULL
&& !header_of_multiple
)
6243 std::vector
<int> inf_nums
;
6246 for (inferior
*inf
: all_inferiors ())
6248 if (inf
->pspace
== loc
->pspace
)
6249 inf_nums
.push_back (inf
->num
);
6252 /* For backward compatibility, don't display inferiors in CLI unless
6253 there are several. Always display for MI. */
6255 || (!gdbarch_has_global_breakpoints (target_gdbarch ())
6256 && (program_spaces
.size () > 1
6257 || number_of_inferiors () > 1)
6258 /* LOC is for existing B, it cannot be in
6259 moribund_locations and thus having NULL OWNER. */
6260 && loc
->owner
->type
!= bp_catchpoint
))
6262 output_thread_groups (uiout
, "thread-groups", inf_nums
, mi_only
);
6265 if (!part_of_multiple
)
6267 if (b
->thread
!= -1)
6269 /* FIXME: This seems to be redundant and lost here; see the
6270 "stop only in" line a little further down. */
6271 uiout
->text (" thread ");
6272 uiout
->field_signed ("thread", b
->thread
);
6274 else if (b
->task
!= 0)
6276 uiout
->text (" task ");
6277 uiout
->field_signed ("task", b
->task
);
6283 if (!part_of_multiple
)
6284 b
->ops
->print_one_detail (b
, uiout
);
6286 if (part_of_multiple
&& frame_id_p (b
->frame_id
))
6289 uiout
->text ("\tstop only in stack frame at ");
6290 /* FIXME: cagney/2002-12-01: Shouldn't be poking around inside
6292 uiout
->field_core_addr ("frame",
6293 b
->gdbarch
, b
->frame_id
.stack_addr
);
6297 if (!part_of_multiple
&& b
->cond_string
)
6300 if (is_tracepoint (b
))
6301 uiout
->text ("\ttrace only if ");
6303 uiout
->text ("\tstop only if ");
6304 uiout
->field_string ("cond", b
->cond_string
);
6306 /* Print whether the target is doing the breakpoint's condition
6307 evaluation. If GDB is doing the evaluation, don't print anything. */
6308 if (is_breakpoint (b
)
6309 && breakpoint_condition_evaluation_mode ()
6310 == condition_evaluation_target
)
6312 uiout
->message (" (%pF evals)",
6313 string_field ("evaluated-by",
6314 bp_condition_evaluator (b
)));
6319 if (!part_of_multiple
&& b
->thread
!= -1)
6321 /* FIXME should make an annotation for this. */
6322 uiout
->text ("\tstop only in thread ");
6323 if (uiout
->is_mi_like_p ())
6324 uiout
->field_signed ("thread", b
->thread
);
6327 struct thread_info
*thr
= find_thread_global_id (b
->thread
);
6329 uiout
->field_string ("thread", print_thread_id (thr
));
6334 if (!part_of_multiple
)
6338 /* FIXME should make an annotation for this. */
6339 if (is_catchpoint (b
))
6340 uiout
->text ("\tcatchpoint");
6341 else if (is_tracepoint (b
))
6342 uiout
->text ("\ttracepoint");
6344 uiout
->text ("\tbreakpoint");
6345 uiout
->text (" already hit ");
6346 uiout
->field_signed ("times", b
->hit_count
);
6347 if (b
->hit_count
== 1)
6348 uiout
->text (" time\n");
6350 uiout
->text (" times\n");
6354 /* Output the count also if it is zero, but only if this is mi. */
6355 if (uiout
->is_mi_like_p ())
6356 uiout
->field_signed ("times", b
->hit_count
);
6360 if (!part_of_multiple
&& b
->ignore_count
)
6363 uiout
->message ("\tignore next %pF hits\n",
6364 signed_field ("ignore", b
->ignore_count
));
6367 /* Note that an enable count of 1 corresponds to "enable once"
6368 behavior, which is reported by the combination of enablement and
6369 disposition, so we don't need to mention it here. */
6370 if (!part_of_multiple
&& b
->enable_count
> 1)
6373 uiout
->text ("\tdisable after ");
6374 /* Tweak the wording to clarify that ignore and enable counts
6375 are distinct, and have additive effect. */
6376 if (b
->ignore_count
)
6377 uiout
->text ("additional ");
6379 uiout
->text ("next ");
6380 uiout
->field_signed ("enable", b
->enable_count
);
6381 uiout
->text (" hits\n");
6384 if (!part_of_multiple
&& is_tracepoint (b
))
6386 struct tracepoint
*tp
= (struct tracepoint
*) b
;
6388 if (tp
->traceframe_usage
)
6390 uiout
->text ("\ttrace buffer usage ");
6391 uiout
->field_signed ("traceframe-usage", tp
->traceframe_usage
);
6392 uiout
->text (" bytes\n");
6396 l
= b
->commands
? b
->commands
.get () : NULL
;
6397 if (!part_of_multiple
&& l
)
6400 ui_out_emit_tuple
tuple_emitter (uiout
, "script");
6401 print_command_lines (uiout
, l
, 4);
6404 if (is_tracepoint (b
))
6406 struct tracepoint
*t
= (struct tracepoint
*) b
;
6408 if (!part_of_multiple
&& t
->pass_count
)
6410 annotate_field (10);
6411 uiout
->text ("\tpass count ");
6412 uiout
->field_signed ("pass", t
->pass_count
);
6413 uiout
->text (" \n");
6416 /* Don't display it when tracepoint or tracepoint location is
6418 if (!header_of_multiple
&& loc
!= NULL
&& !loc
->shlib_disabled
)
6420 annotate_field (11);
6422 if (uiout
->is_mi_like_p ())
6423 uiout
->field_string ("installed",
6424 loc
->inserted
? "y" : "n");
6430 uiout
->text ("\tnot ");
6431 uiout
->text ("installed on target\n");
6436 if (uiout
->is_mi_like_p () && !part_of_multiple
)
6438 if (is_watchpoint (b
))
6440 struct watchpoint
*w
= (struct watchpoint
*) b
;
6442 uiout
->field_string ("original-location", w
->exp_string
);
6444 else if (b
->location
!= NULL
6445 && event_location_to_string (b
->location
.get ()) != NULL
)
6446 uiout
->field_string ("original-location",
6447 event_location_to_string (b
->location
.get ()));
6451 /* See breakpoint.h. */
6453 bool fix_multi_location_breakpoint_output_globally
= false;
6456 print_one_breakpoint (struct breakpoint
*b
,
6457 struct bp_location
**last_loc
,
6460 struct ui_out
*uiout
= current_uiout
;
6461 bool use_fixed_output
6462 = (uiout
->test_flags (fix_multi_location_breakpoint_output
)
6463 || fix_multi_location_breakpoint_output_globally
);
6465 gdb::optional
<ui_out_emit_tuple
> bkpt_tuple_emitter (gdb::in_place
, uiout
, "bkpt");
6466 print_one_breakpoint_location (b
, NULL
, 0, last_loc
, allflag
, false);
6468 /* The mi2 broken format: the main breakpoint tuple ends here, the locations
6470 if (!use_fixed_output
)
6471 bkpt_tuple_emitter
.reset ();
6473 /* If this breakpoint has custom print function,
6474 it's already printed. Otherwise, print individual
6475 locations, if any. */
6477 || b
->ops
->print_one
== NULL
6480 /* If breakpoint has a single location that is disabled, we
6481 print it as if it had several locations, since otherwise it's
6482 hard to represent "breakpoint enabled, location disabled"
6485 Note that while hardware watchpoints have several locations
6486 internally, that's not a property exposed to users.
6488 Likewise, while catchpoints may be implemented with
6489 breakpoints (e.g., catch throw), that's not a property
6490 exposed to users. We do however display the internal
6491 breakpoint locations with "maint info breakpoints". */
6492 if (!is_hardware_watchpoint (b
)
6493 && (!is_catchpoint (b
) || is_exception_catchpoint (b
)
6494 || is_ada_exception_catchpoint (b
))
6496 || (b
->loc
&& (b
->loc
->next
6498 || b
->loc
->disabled_by_cond
))))
6500 gdb::optional
<ui_out_emit_list
> locations_list
;
6502 /* For MI version <= 2, keep the behavior where GDB outputs an invalid
6503 MI record. For later versions, place breakpoint locations in a
6505 if (uiout
->is_mi_like_p () && use_fixed_output
)
6506 locations_list
.emplace (uiout
, "locations");
6509 for (bp_location
*loc
: b
->locations ())
6511 ui_out_emit_tuple
loc_tuple_emitter (uiout
, NULL
);
6512 print_one_breakpoint_location (b
, loc
, n
, last_loc
,
6521 breakpoint_address_bits (struct breakpoint
*b
)
6523 int print_address_bits
= 0;
6525 /* Software watchpoints that aren't watching memory don't have an
6526 address to print. */
6527 if (is_no_memory_software_watchpoint (b
))
6530 for (bp_location
*loc
: b
->locations ())
6534 addr_bit
= gdbarch_addr_bit (loc
->gdbarch
);
6535 if (addr_bit
> print_address_bits
)
6536 print_address_bits
= addr_bit
;
6539 return print_address_bits
;
6542 /* See breakpoint.h. */
6545 print_breakpoint (breakpoint
*b
)
6547 struct bp_location
*dummy_loc
= NULL
;
6548 print_one_breakpoint (b
, &dummy_loc
, 0);
6551 /* Return true if this breakpoint was set by the user, false if it is
6552 internal or momentary. */
6555 user_breakpoint_p (struct breakpoint
*b
)
6557 return b
->number
> 0;
6560 /* See breakpoint.h. */
6563 pending_breakpoint_p (struct breakpoint
*b
)
6565 return b
->loc
== NULL
;
6568 /* Print information on breakpoints (including watchpoints and tracepoints).
6570 If non-NULL, BP_NUM_LIST is a list of numbers and number ranges as
6571 understood by number_or_range_parser. Only breakpoints included in this
6572 list are then printed.
6574 If SHOW_INTERNAL is true, print internal breakpoints.
6576 If FILTER is non-NULL, call it on each breakpoint and only include the
6577 ones for which it returns true.
6579 Return the total number of breakpoints listed. */
6582 breakpoint_1 (const char *bp_num_list
, bool show_internal
,
6583 bool (*filter
) (const struct breakpoint
*))
6585 struct bp_location
*last_loc
= NULL
;
6586 int nr_printable_breakpoints
;
6587 struct value_print_options opts
;
6588 int print_address_bits
= 0;
6589 int print_type_col_width
= 14;
6590 struct ui_out
*uiout
= current_uiout
;
6591 bool has_disabled_by_cond_location
= false;
6593 get_user_print_options (&opts
);
6595 /* Compute the number of rows in the table, as well as the size
6596 required for address fields. */
6597 nr_printable_breakpoints
= 0;
6598 for (breakpoint
*b
: all_breakpoints ())
6600 /* If we have a filter, only list the breakpoints it accepts. */
6601 if (filter
&& !filter (b
))
6604 /* If we have a BP_NUM_LIST string, it is a list of breakpoints to
6605 accept. Skip the others. */
6606 if (bp_num_list
!= NULL
&& *bp_num_list
!= '\0')
6608 if (show_internal
&& parse_and_eval_long (bp_num_list
) != b
->number
)
6610 if (!show_internal
&& !number_is_in_list (bp_num_list
, b
->number
))
6614 if (show_internal
|| user_breakpoint_p (b
))
6616 int addr_bit
, type_len
;
6618 addr_bit
= breakpoint_address_bits (b
);
6619 if (addr_bit
> print_address_bits
)
6620 print_address_bits
= addr_bit
;
6622 type_len
= strlen (bptype_string (b
->type
));
6623 if (type_len
> print_type_col_width
)
6624 print_type_col_width
= type_len
;
6626 nr_printable_breakpoints
++;
6631 ui_out_emit_table
table_emitter (uiout
,
6632 opts
.addressprint
? 6 : 5,
6633 nr_printable_breakpoints
,
6636 if (nr_printable_breakpoints
> 0)
6637 annotate_breakpoints_headers ();
6638 if (nr_printable_breakpoints
> 0)
6640 uiout
->table_header (7, ui_left
, "number", "Num"); /* 1 */
6641 if (nr_printable_breakpoints
> 0)
6643 uiout
->table_header (print_type_col_width
, ui_left
, "type", "Type"); /* 2 */
6644 if (nr_printable_breakpoints
> 0)
6646 uiout
->table_header (4, ui_left
, "disp", "Disp"); /* 3 */
6647 if (nr_printable_breakpoints
> 0)
6649 uiout
->table_header (3, ui_left
, "enabled", "Enb"); /* 4 */
6650 if (opts
.addressprint
)
6652 if (nr_printable_breakpoints
> 0)
6654 if (print_address_bits
<= 32)
6655 uiout
->table_header (10, ui_left
, "addr", "Address"); /* 5 */
6657 uiout
->table_header (18, ui_left
, "addr", "Address"); /* 5 */
6659 if (nr_printable_breakpoints
> 0)
6661 uiout
->table_header (40, ui_noalign
, "what", "What"); /* 6 */
6662 uiout
->table_body ();
6663 if (nr_printable_breakpoints
> 0)
6664 annotate_breakpoints_table ();
6666 for (breakpoint
*b
: all_breakpoints ())
6669 /* If we have a filter, only list the breakpoints it accepts. */
6670 if (filter
&& !filter (b
))
6673 /* If we have a BP_NUM_LIST string, it is a list of breakpoints to
6674 accept. Skip the others. */
6676 if (bp_num_list
!= NULL
&& *bp_num_list
!= '\0')
6678 if (show_internal
) /* maintenance info breakpoint */
6680 if (parse_and_eval_long (bp_num_list
) != b
->number
)
6683 else /* all others */
6685 if (!number_is_in_list (bp_num_list
, b
->number
))
6689 /* We only print out user settable breakpoints unless the
6690 show_internal is set. */
6691 if (show_internal
|| user_breakpoint_p (b
))
6693 print_one_breakpoint (b
, &last_loc
, show_internal
);
6694 for (bp_location
*loc
: b
->locations ())
6695 if (loc
->disabled_by_cond
)
6696 has_disabled_by_cond_location
= true;
6701 if (nr_printable_breakpoints
== 0)
6703 /* If there's a filter, let the caller decide how to report
6707 if (bp_num_list
== NULL
|| *bp_num_list
== '\0')
6708 uiout
->message ("No breakpoints or watchpoints.\n");
6710 uiout
->message ("No breakpoint or watchpoint matching '%s'.\n",
6716 if (last_loc
&& !server_command
)
6717 set_next_address (last_loc
->gdbarch
, last_loc
->address
);
6719 if (has_disabled_by_cond_location
&& !uiout
->is_mi_like_p ())
6720 uiout
->message (_("(*): Breakpoint condition is invalid at this "
6724 /* FIXME? Should this be moved up so that it is only called when
6725 there have been breakpoints? */
6726 annotate_breakpoints_table_end ();
6728 return nr_printable_breakpoints
;
6731 /* Display the value of default-collect in a way that is generally
6732 compatible with the breakpoint list. */
6735 default_collect_info (void)
6737 struct ui_out
*uiout
= current_uiout
;
6739 /* If it has no value (which is frequently the case), say nothing; a
6740 message like "No default-collect." gets in user's face when it's
6742 if (!*default_collect
)
6745 /* The following phrase lines up nicely with per-tracepoint collect
6747 uiout
->text ("default collect ");
6748 uiout
->field_string ("default-collect", default_collect
);
6749 uiout
->text (" \n");
6753 info_breakpoints_command (const char *args
, int from_tty
)
6755 breakpoint_1 (args
, false, NULL
);
6757 default_collect_info ();
6761 info_watchpoints_command (const char *args
, int from_tty
)
6763 int num_printed
= breakpoint_1 (args
, false, is_watchpoint
);
6764 struct ui_out
*uiout
= current_uiout
;
6766 if (num_printed
== 0)
6768 if (args
== NULL
|| *args
== '\0')
6769 uiout
->message ("No watchpoints.\n");
6771 uiout
->message ("No watchpoint matching '%s'.\n", args
);
6776 maintenance_info_breakpoints (const char *args
, int from_tty
)
6778 breakpoint_1 (args
, true, NULL
);
6780 default_collect_info ();
6784 breakpoint_has_pc (struct breakpoint
*b
,
6785 struct program_space
*pspace
,
6786 CORE_ADDR pc
, struct obj_section
*section
)
6788 for (bp_location
*bl
: b
->locations ())
6790 if (bl
->pspace
== pspace
6791 && bl
->address
== pc
6792 && (!overlay_debugging
|| bl
->section
== section
))
6798 /* Print a message describing any user-breakpoints set at PC. This
6799 concerns with logical breakpoints, so we match program spaces, not
6803 describe_other_breakpoints (struct gdbarch
*gdbarch
,
6804 struct program_space
*pspace
, CORE_ADDR pc
,
6805 struct obj_section
*section
, int thread
)
6809 for (breakpoint
*b
: all_breakpoints ())
6810 others
+= (user_breakpoint_p (b
)
6811 && breakpoint_has_pc (b
, pspace
, pc
, section
));
6816 printf_filtered (_("Note: breakpoint "));
6817 else /* if (others == ???) */
6818 printf_filtered (_("Note: breakpoints "));
6819 for (breakpoint
*b
: all_breakpoints ())
6820 if (user_breakpoint_p (b
) && breakpoint_has_pc (b
, pspace
, pc
, section
))
6823 printf_filtered ("%d", b
->number
);
6824 if (b
->thread
== -1 && thread
!= -1)
6825 printf_filtered (" (all threads)");
6826 else if (b
->thread
!= -1)
6827 printf_filtered (" (thread %d)", b
->thread
);
6828 printf_filtered ("%s%s ",
6829 ((b
->enable_state
== bp_disabled
6830 || b
->enable_state
== bp_call_disabled
)
6834 : ((others
== 1) ? " and" : ""));
6836 current_uiout
->message (_("also set at pc %ps.\n"),
6837 styled_string (address_style
.style (),
6838 paddress (gdbarch
, pc
)));
6843 /* Return true iff it is meaningful to use the address member of LOC.
6844 For some breakpoint types, the locations' address members are
6845 irrelevant and it makes no sense to attempt to compare them to
6846 other addresses (or use them for any other purpose either).
6848 More specifically, software watchpoints and catchpoints that are
6849 not backed by breakpoints always have a zero valued location
6850 address and we don't want to mark breakpoints of any of these types
6851 to be a duplicate of an actual breakpoint location at address
6855 bl_address_is_meaningful (bp_location
*loc
)
6857 return loc
->loc_type
!= bp_loc_other
;
6860 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
6861 true if LOC1 and LOC2 represent the same watchpoint location. */
6864 watchpoint_locations_match (struct bp_location
*loc1
,
6865 struct bp_location
*loc2
)
6867 struct watchpoint
*w1
= (struct watchpoint
*) loc1
->owner
;
6868 struct watchpoint
*w2
= (struct watchpoint
*) loc2
->owner
;
6870 /* Both of them must exist. */
6871 gdb_assert (w1
!= NULL
);
6872 gdb_assert (w2
!= NULL
);
6874 /* If the target can evaluate the condition expression in hardware,
6875 then we we need to insert both watchpoints even if they are at
6876 the same place. Otherwise the watchpoint will only trigger when
6877 the condition of whichever watchpoint was inserted evaluates to
6878 true, not giving a chance for GDB to check the condition of the
6879 other watchpoint. */
6881 && target_can_accel_watchpoint_condition (loc1
->address
,
6883 loc1
->watchpoint_type
,
6884 w1
->cond_exp
.get ()))
6886 && target_can_accel_watchpoint_condition (loc2
->address
,
6888 loc2
->watchpoint_type
,
6889 w2
->cond_exp
.get ())))
6892 /* Note that this checks the owner's type, not the location's. In
6893 case the target does not support read watchpoints, but does
6894 support access watchpoints, we'll have bp_read_watchpoint
6895 watchpoints with hw_access locations. Those should be considered
6896 duplicates of hw_read locations. The hw_read locations will
6897 become hw_access locations later. */
6898 return (loc1
->owner
->type
== loc2
->owner
->type
6899 && loc1
->pspace
->aspace
== loc2
->pspace
->aspace
6900 && loc1
->address
== loc2
->address
6901 && loc1
->length
== loc2
->length
);
6904 /* See breakpoint.h. */
6907 breakpoint_address_match (const address_space
*aspace1
, CORE_ADDR addr1
,
6908 const address_space
*aspace2
, CORE_ADDR addr2
)
6910 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
6911 || aspace1
== aspace2
)
6915 /* Returns true if {ASPACE2,ADDR2} falls within the range determined by
6916 {ASPACE1,ADDR1,LEN1}. In most targets, this can only be true if ASPACE1
6917 matches ASPACE2. On targets that have global breakpoints, the address
6918 space doesn't really matter. */
6921 breakpoint_address_match_range (const address_space
*aspace1
,
6923 int len1
, const address_space
*aspace2
,
6926 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
6927 || aspace1
== aspace2
)
6928 && addr2
>= addr1
&& addr2
< addr1
+ len1
);
6931 /* Returns true if {ASPACE,ADDR} matches the breakpoint BL. BL may be
6932 a ranged breakpoint. In most targets, a match happens only if ASPACE
6933 matches the breakpoint's address space. On targets that have global
6934 breakpoints, the address space doesn't really matter. */
6937 breakpoint_location_address_match (struct bp_location
*bl
,
6938 const address_space
*aspace
,
6941 return (breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
6944 && breakpoint_address_match_range (bl
->pspace
->aspace
,
6945 bl
->address
, bl
->length
,
6949 /* Returns true if the [ADDR,ADDR+LEN) range in ASPACE overlaps
6950 breakpoint BL. BL may be a ranged breakpoint. In most targets, a
6951 match happens only if ASPACE matches the breakpoint's address
6952 space. On targets that have global breakpoints, the address space
6953 doesn't really matter. */
6956 breakpoint_location_address_range_overlap (struct bp_location
*bl
,
6957 const address_space
*aspace
,
6958 CORE_ADDR addr
, int len
)
6960 if (gdbarch_has_global_breakpoints (target_gdbarch ())
6961 || bl
->pspace
->aspace
== aspace
)
6963 int bl_len
= bl
->length
!= 0 ? bl
->length
: 1;
6965 if (mem_ranges_overlap (addr
, len
, bl
->address
, bl_len
))
6971 /* If LOC1 and LOC2's owners are not tracepoints, returns false directly.
6972 Then, if LOC1 and LOC2 represent the same tracepoint location, returns
6973 true, otherwise returns false. */
6976 tracepoint_locations_match (struct bp_location
*loc1
,
6977 struct bp_location
*loc2
)
6979 if (is_tracepoint (loc1
->owner
) && is_tracepoint (loc2
->owner
))
6980 /* Since tracepoint locations are never duplicated with others', tracepoint
6981 locations at the same address of different tracepoints are regarded as
6982 different locations. */
6983 return (loc1
->address
== loc2
->address
&& loc1
->owner
== loc2
->owner
);
6988 /* Assuming LOC1 and LOC2's types' have meaningful target addresses
6989 (bl_address_is_meaningful), returns true if LOC1 and LOC2 represent
6990 the same location. If SW_HW_BPS_MATCH is true, then software
6991 breakpoint locations and hardware breakpoint locations match,
6992 otherwise they don't. */
6995 breakpoint_locations_match (struct bp_location
*loc1
,
6996 struct bp_location
*loc2
,
6997 bool sw_hw_bps_match
)
6999 int hw_point1
, hw_point2
;
7001 /* Both of them must not be in moribund_locations. */
7002 gdb_assert (loc1
->owner
!= NULL
);
7003 gdb_assert (loc2
->owner
!= NULL
);
7005 hw_point1
= is_hardware_watchpoint (loc1
->owner
);
7006 hw_point2
= is_hardware_watchpoint (loc2
->owner
);
7008 if (hw_point1
!= hw_point2
)
7011 return watchpoint_locations_match (loc1
, loc2
);
7012 else if (is_tracepoint (loc1
->owner
) || is_tracepoint (loc2
->owner
))
7013 return tracepoint_locations_match (loc1
, loc2
);
7015 /* We compare bp_location.length in order to cover ranged
7016 breakpoints. Keep this in sync with
7017 bp_location_is_less_than. */
7018 return (breakpoint_address_match (loc1
->pspace
->aspace
, loc1
->address
,
7019 loc2
->pspace
->aspace
, loc2
->address
)
7020 && (loc1
->loc_type
== loc2
->loc_type
|| sw_hw_bps_match
)
7021 && loc1
->length
== loc2
->length
);
7025 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
7026 int bnum
, int have_bnum
)
7028 /* The longest string possibly returned by hex_string_custom
7029 is 50 chars. These must be at least that big for safety. */
7033 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
7034 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
7036 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
7037 bnum
, astr1
, astr2
);
7039 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
7042 /* Adjust a breakpoint's address to account for architectural
7043 constraints on breakpoint placement. Return the adjusted address.
7044 Note: Very few targets require this kind of adjustment. For most
7045 targets, this function is simply the identity function. */
7048 adjust_breakpoint_address (struct gdbarch
*gdbarch
,
7049 CORE_ADDR bpaddr
, enum bptype bptype
)
7051 if (bptype
== bp_watchpoint
7052 || bptype
== bp_hardware_watchpoint
7053 || bptype
== bp_read_watchpoint
7054 || bptype
== bp_access_watchpoint
7055 || bptype
== bp_catchpoint
)
7057 /* Watchpoints and the various bp_catch_* eventpoints should not
7058 have their addresses modified. */
7061 else if (bptype
== bp_single_step
)
7063 /* Single-step breakpoints should not have their addresses
7064 modified. If there's any architectural constrain that
7065 applies to this address, then it should have already been
7066 taken into account when the breakpoint was created in the
7067 first place. If we didn't do this, stepping through e.g.,
7068 Thumb-2 IT blocks would break. */
7073 CORE_ADDR adjusted_bpaddr
= bpaddr
;
7075 if (gdbarch_adjust_breakpoint_address_p (gdbarch
))
7077 /* Some targets have architectural constraints on the placement
7078 of breakpoint instructions. Obtain the adjusted address. */
7079 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (gdbarch
, bpaddr
);
7082 adjusted_bpaddr
= address_significant (gdbarch
, adjusted_bpaddr
);
7084 /* An adjusted breakpoint address can significantly alter
7085 a user's expectations. Print a warning if an adjustment
7087 if (adjusted_bpaddr
!= bpaddr
)
7088 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
7090 return adjusted_bpaddr
;
7095 bp_location_from_bp_type (bptype type
)
7100 case bp_single_step
:
7104 case bp_longjmp_resume
:
7105 case bp_longjmp_call_dummy
:
7107 case bp_exception_resume
:
7108 case bp_step_resume
:
7109 case bp_hp_step_resume
:
7110 case bp_watchpoint_scope
:
7112 case bp_std_terminate
:
7113 case bp_shlib_event
:
7114 case bp_thread_event
:
7115 case bp_overlay_event
:
7117 case bp_longjmp_master
:
7118 case bp_std_terminate_master
:
7119 case bp_exception_master
:
7120 case bp_gnu_ifunc_resolver
:
7121 case bp_gnu_ifunc_resolver_return
:
7123 return bp_loc_software_breakpoint
;
7124 case bp_hardware_breakpoint
:
7125 return bp_loc_hardware_breakpoint
;
7126 case bp_hardware_watchpoint
:
7127 case bp_read_watchpoint
:
7128 case bp_access_watchpoint
:
7129 return bp_loc_hardware_watchpoint
;
7133 case bp_fast_tracepoint
:
7134 case bp_static_tracepoint
:
7135 return bp_loc_other
;
7137 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
7141 bp_location::bp_location (breakpoint
*owner
, bp_loc_type type
)
7143 this->owner
= owner
;
7144 this->cond_bytecode
= NULL
;
7145 this->shlib_disabled
= 0;
7147 this->disabled_by_cond
= false;
7149 this->loc_type
= type
;
7151 if (this->loc_type
== bp_loc_software_breakpoint
7152 || this->loc_type
== bp_loc_hardware_breakpoint
)
7153 mark_breakpoint_location_modified (this);
7158 bp_location::bp_location (breakpoint
*owner
)
7159 : bp_location::bp_location (owner
,
7160 bp_location_from_bp_type (owner
->type
))
7164 /* Allocate a struct bp_location. */
7166 static struct bp_location
*
7167 allocate_bp_location (struct breakpoint
*bpt
)
7169 return bpt
->ops
->allocate_location (bpt
);
7172 /* Decrement reference count. If the reference count reaches 0,
7173 destroy the bp_location. Sets *BLP to NULL. */
7176 decref_bp_location (struct bp_location
**blp
)
7178 bp_location_ref_policy::decref (*blp
);
7182 /* Add breakpoint B at the end of the global breakpoint chain. */
7185 add_to_breakpoint_chain (std::unique_ptr
<breakpoint
> &&b
)
7187 struct breakpoint
*b1
;
7188 struct breakpoint
*result
= b
.get ();
7190 /* Add this breakpoint to the end of the chain so that a list of
7191 breakpoints will come out in order of increasing numbers. */
7193 b1
= breakpoint_chain
;
7195 breakpoint_chain
= b
.release ();
7200 b1
->next
= b
.release ();
7206 /* Initializes breakpoint B with type BPTYPE and no locations yet. */
7209 init_raw_breakpoint_without_location (struct breakpoint
*b
,
7210 struct gdbarch
*gdbarch
,
7212 const struct breakpoint_ops
*ops
)
7214 gdb_assert (ops
!= NULL
);
7218 b
->gdbarch
= gdbarch
;
7219 b
->language
= current_language
->la_language
;
7220 b
->input_radix
= input_radix
;
7221 b
->related_breakpoint
= b
;
7224 /* Helper to set_raw_breakpoint below. Creates a breakpoint
7225 that has type BPTYPE and has no locations as yet. */
7227 static struct breakpoint
*
7228 set_raw_breakpoint_without_location (struct gdbarch
*gdbarch
,
7230 const struct breakpoint_ops
*ops
)
7232 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (bptype
);
7234 init_raw_breakpoint_without_location (b
.get (), gdbarch
, bptype
, ops
);
7235 return add_to_breakpoint_chain (std::move (b
));
7238 /* Initialize loc->function_name. */
7241 set_breakpoint_location_function (struct bp_location
*loc
)
7243 gdb_assert (loc
->owner
!= NULL
);
7245 if (loc
->owner
->type
== bp_breakpoint
7246 || loc
->owner
->type
== bp_hardware_breakpoint
7247 || is_tracepoint (loc
->owner
))
7249 const char *function_name
;
7251 if (loc
->msymbol
!= NULL
7252 && (MSYMBOL_TYPE (loc
->msymbol
) == mst_text_gnu_ifunc
7253 || MSYMBOL_TYPE (loc
->msymbol
) == mst_data_gnu_ifunc
))
7255 struct breakpoint
*b
= loc
->owner
;
7257 function_name
= loc
->msymbol
->linkage_name ();
7259 if (b
->type
== bp_breakpoint
&& b
->loc
== loc
7260 && loc
->next
== NULL
&& b
->related_breakpoint
== b
)
7262 /* Create only the whole new breakpoint of this type but do not
7263 mess more complicated breakpoints with multiple locations. */
7264 b
->type
= bp_gnu_ifunc_resolver
;
7265 /* Remember the resolver's address for use by the return
7267 loc
->related_address
= loc
->address
;
7271 find_pc_partial_function (loc
->address
, &function_name
, NULL
, NULL
);
7274 loc
->function_name
= xstrdup (function_name
);
7278 /* Attempt to determine architecture of location identified by SAL. */
7280 get_sal_arch (struct symtab_and_line sal
)
7283 return sal
.section
->objfile
->arch ();
7285 return SYMTAB_OBJFILE (sal
.symtab
)->arch ();
7290 /* Low level routine for partially initializing a breakpoint of type
7291 BPTYPE. The newly created breakpoint's address, section, source
7292 file name, and line number are provided by SAL.
7294 It is expected that the caller will complete the initialization of
7295 the newly created breakpoint struct as well as output any status
7296 information regarding the creation of a new breakpoint. */
7299 init_raw_breakpoint (struct breakpoint
*b
, struct gdbarch
*gdbarch
,
7300 struct symtab_and_line sal
, enum bptype bptype
,
7301 const struct breakpoint_ops
*ops
)
7303 init_raw_breakpoint_without_location (b
, gdbarch
, bptype
, ops
);
7305 add_location_to_breakpoint (b
, &sal
);
7307 if (bptype
!= bp_catchpoint
)
7308 gdb_assert (sal
.pspace
!= NULL
);
7310 /* Store the program space that was used to set the breakpoint,
7311 except for ordinary breakpoints, which are independent of the
7313 if (bptype
!= bp_breakpoint
&& bptype
!= bp_hardware_breakpoint
)
7314 b
->pspace
= sal
.pspace
;
7317 /* set_raw_breakpoint is a low level routine for allocating and
7318 partially initializing a breakpoint of type BPTYPE. The newly
7319 created breakpoint's address, section, source file name, and line
7320 number are provided by SAL. The newly created and partially
7321 initialized breakpoint is added to the breakpoint chain and
7322 is also returned as the value of this function.
7324 It is expected that the caller will complete the initialization of
7325 the newly created breakpoint struct as well as output any status
7326 information regarding the creation of a new breakpoint. In
7327 particular, set_raw_breakpoint does NOT set the breakpoint
7328 number! Care should be taken to not allow an error to occur
7329 prior to completing the initialization of the breakpoint. If this
7330 should happen, a bogus breakpoint will be left on the chain. */
7333 set_raw_breakpoint (struct gdbarch
*gdbarch
,
7334 struct symtab_and_line sal
, enum bptype bptype
,
7335 const struct breakpoint_ops
*ops
)
7337 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (bptype
);
7339 init_raw_breakpoint (b
.get (), gdbarch
, sal
, bptype
, ops
);
7340 return add_to_breakpoint_chain (std::move (b
));
7343 /* Call this routine when stepping and nexting to enable a breakpoint
7344 if we do a longjmp() or 'throw' in TP. FRAME is the frame which
7345 initiated the operation. */
7348 set_longjmp_breakpoint (struct thread_info
*tp
, struct frame_id frame
)
7350 int thread
= tp
->global_num
;
7352 /* To avoid having to rescan all objfile symbols at every step,
7353 we maintain a list of continually-inserted but always disabled
7354 longjmp "master" breakpoints. Here, we simply create momentary
7355 clones of those and enable them for the requested thread. */
7356 for (breakpoint
*b
: all_breakpoints_safe ())
7357 if (b
->pspace
== current_program_space
7358 && (b
->type
== bp_longjmp_master
7359 || b
->type
== bp_exception_master
))
7361 enum bptype type
= b
->type
== bp_longjmp_master
? bp_longjmp
: bp_exception
;
7362 struct breakpoint
*clone
;
7364 /* longjmp_breakpoint_ops ensures INITIATING_FRAME is cleared again
7365 after their removal. */
7366 clone
= momentary_breakpoint_from_master (b
, type
,
7367 &momentary_breakpoint_ops
, 1);
7368 clone
->thread
= thread
;
7371 tp
->initiating_frame
= frame
;
7374 /* Delete all longjmp breakpoints from THREAD. */
7376 delete_longjmp_breakpoint (int thread
)
7378 for (breakpoint
*b
: all_breakpoints_safe ())
7379 if (b
->type
== bp_longjmp
|| b
->type
== bp_exception
)
7381 if (b
->thread
== thread
)
7382 delete_breakpoint (b
);
7387 delete_longjmp_breakpoint_at_next_stop (int thread
)
7389 for (breakpoint
*b
: all_breakpoints_safe ())
7390 if (b
->type
== bp_longjmp
|| b
->type
== bp_exception
)
7392 if (b
->thread
== thread
)
7393 b
->disposition
= disp_del_at_next_stop
;
7397 /* Place breakpoints of type bp_longjmp_call_dummy to catch longjmp for
7398 INFERIOR_PTID thread. Chain them all by RELATED_BREAKPOINT and return
7399 pointer to any of them. Return NULL if this system cannot place longjmp
7403 set_longjmp_breakpoint_for_call_dummy (void)
7405 breakpoint
*retval
= nullptr;
7407 for (breakpoint
*b
: all_breakpoints ())
7408 if (b
->pspace
== current_program_space
&& b
->type
== bp_longjmp_master
)
7410 struct breakpoint
*new_b
;
7412 new_b
= momentary_breakpoint_from_master (b
, bp_longjmp_call_dummy
,
7413 &momentary_breakpoint_ops
,
7415 new_b
->thread
= inferior_thread ()->global_num
;
7417 /* Link NEW_B into the chain of RETVAL breakpoints. */
7419 gdb_assert (new_b
->related_breakpoint
== new_b
);
7422 new_b
->related_breakpoint
= retval
;
7423 while (retval
->related_breakpoint
!= new_b
->related_breakpoint
)
7424 retval
= retval
->related_breakpoint
;
7425 retval
->related_breakpoint
= new_b
;
7431 /* Verify all existing dummy frames and their associated breakpoints for
7432 TP. Remove those which can no longer be found in the current frame
7435 You should call this function only at places where it is safe to currently
7436 unwind the whole stack. Failed stack unwind would discard live dummy
7440 check_longjmp_breakpoint_for_call_dummy (struct thread_info
*tp
)
7442 struct breakpoint
*b
, *b_tmp
;
7444 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7445 if (b
->type
== bp_longjmp_call_dummy
&& b
->thread
== tp
->global_num
)
7447 struct breakpoint
*dummy_b
= b
->related_breakpoint
;
7449 while (dummy_b
!= b
&& dummy_b
->type
!= bp_call_dummy
)
7450 dummy_b
= dummy_b
->related_breakpoint
;
7451 if (dummy_b
->type
!= bp_call_dummy
7452 || frame_find_by_id (dummy_b
->frame_id
) != NULL
)
7455 dummy_frame_discard (dummy_b
->frame_id
, tp
);
7457 while (b
->related_breakpoint
!= b
)
7459 if (b_tmp
== b
->related_breakpoint
)
7460 b_tmp
= b
->related_breakpoint
->next
;
7461 delete_breakpoint (b
->related_breakpoint
);
7463 delete_breakpoint (b
);
7468 enable_overlay_breakpoints (void)
7470 for (breakpoint
*b
: all_breakpoints ())
7471 if (b
->type
== bp_overlay_event
)
7473 b
->enable_state
= bp_enabled
;
7474 update_global_location_list (UGLL_MAY_INSERT
);
7475 overlay_events_enabled
= 1;
7480 disable_overlay_breakpoints (void)
7482 for (breakpoint
*b
: all_breakpoints ())
7483 if (b
->type
== bp_overlay_event
)
7485 b
->enable_state
= bp_disabled
;
7486 update_global_location_list (UGLL_DONT_INSERT
);
7487 overlay_events_enabled
= 0;
7491 /* Set an active std::terminate breakpoint for each std::terminate
7492 master breakpoint. */
7494 set_std_terminate_breakpoint (void)
7496 for (breakpoint
*b
: all_breakpoints_safe ())
7497 if (b
->pspace
== current_program_space
7498 && b
->type
== bp_std_terminate_master
)
7500 momentary_breakpoint_from_master (b
, bp_std_terminate
,
7501 &momentary_breakpoint_ops
, 1);
7505 /* Delete all the std::terminate breakpoints. */
7507 delete_std_terminate_breakpoint (void)
7509 for (breakpoint
*b
: all_breakpoints_safe ())
7510 if (b
->type
== bp_std_terminate
)
7511 delete_breakpoint (b
);
7515 create_thread_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7517 struct breakpoint
*b
;
7519 b
= create_internal_breakpoint (gdbarch
, address
, bp_thread_event
,
7520 &internal_breakpoint_ops
);
7522 b
->enable_state
= bp_enabled
;
7523 /* location has to be used or breakpoint_re_set will delete me. */
7524 b
->location
= new_address_location (b
->loc
->address
, NULL
, 0);
7526 update_global_location_list_nothrow (UGLL_MAY_INSERT
);
7531 struct lang_and_radix
7537 /* Create a breakpoint for JIT code registration and unregistration. */
7540 create_jit_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7542 return create_internal_breakpoint (gdbarch
, address
, bp_jit_event
,
7543 &internal_breakpoint_ops
);
7546 /* Remove JIT code registration and unregistration breakpoint(s). */
7549 remove_jit_event_breakpoints (void)
7551 for (breakpoint
*b
: all_breakpoints_safe ())
7552 if (b
->type
== bp_jit_event
7553 && b
->loc
->pspace
== current_program_space
)
7554 delete_breakpoint (b
);
7558 remove_solib_event_breakpoints (void)
7560 for (breakpoint
*b
: all_breakpoints_safe ())
7561 if (b
->type
== bp_shlib_event
7562 && b
->loc
->pspace
== current_program_space
)
7563 delete_breakpoint (b
);
7566 /* See breakpoint.h. */
7569 remove_solib_event_breakpoints_at_next_stop (void)
7571 for (breakpoint
*b
: all_breakpoints_safe ())
7572 if (b
->type
== bp_shlib_event
7573 && b
->loc
->pspace
== current_program_space
)
7574 b
->disposition
= disp_del_at_next_stop
;
7577 /* Helper for create_solib_event_breakpoint /
7578 create_and_insert_solib_event_breakpoint. Allows specifying which
7579 INSERT_MODE to pass through to update_global_location_list. */
7581 static struct breakpoint
*
7582 create_solib_event_breakpoint_1 (struct gdbarch
*gdbarch
, CORE_ADDR address
,
7583 enum ugll_insert_mode insert_mode
)
7585 struct breakpoint
*b
;
7587 b
= create_internal_breakpoint (gdbarch
, address
, bp_shlib_event
,
7588 &internal_breakpoint_ops
);
7589 update_global_location_list_nothrow (insert_mode
);
7594 create_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7596 return create_solib_event_breakpoint_1 (gdbarch
, address
, UGLL_MAY_INSERT
);
7599 /* See breakpoint.h. */
7602 create_and_insert_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7604 struct breakpoint
*b
;
7606 /* Explicitly tell update_global_location_list to insert
7608 b
= create_solib_event_breakpoint_1 (gdbarch
, address
, UGLL_INSERT
);
7609 if (!b
->loc
->inserted
)
7611 delete_breakpoint (b
);
7617 /* Disable any breakpoints that are on code in shared libraries. Only
7618 apply to enabled breakpoints, disabled ones can just stay disabled. */
7621 disable_breakpoints_in_shlibs (void)
7623 struct bp_location
*loc
, **locp_tmp
;
7625 ALL_BP_LOCATIONS (loc
, locp_tmp
)
7627 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7628 struct breakpoint
*b
= loc
->owner
;
7630 /* We apply the check to all breakpoints, including disabled for
7631 those with loc->duplicate set. This is so that when breakpoint
7632 becomes enabled, or the duplicate is removed, gdb will try to
7633 insert all breakpoints. If we don't set shlib_disabled here,
7634 we'll try to insert those breakpoints and fail. */
7635 if (((b
->type
== bp_breakpoint
)
7636 || (b
->type
== bp_jit_event
)
7637 || (b
->type
== bp_hardware_breakpoint
)
7638 || (is_tracepoint (b
)))
7639 && loc
->pspace
== current_program_space
7640 && !loc
->shlib_disabled
7641 && solib_name_from_address (loc
->pspace
, loc
->address
)
7644 loc
->shlib_disabled
= 1;
7649 /* Disable any breakpoints and tracepoints that are in SOLIB upon
7650 notification of unloaded_shlib. Only apply to enabled breakpoints,
7651 disabled ones can just stay disabled. */
7654 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
7656 struct bp_location
*loc
, **locp_tmp
;
7657 int disabled_shlib_breaks
= 0;
7659 ALL_BP_LOCATIONS (loc
, locp_tmp
)
7661 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7662 struct breakpoint
*b
= loc
->owner
;
7664 if (solib
->pspace
== loc
->pspace
7665 && !loc
->shlib_disabled
7666 && (((b
->type
== bp_breakpoint
7667 || b
->type
== bp_jit_event
7668 || b
->type
== bp_hardware_breakpoint
)
7669 && (loc
->loc_type
== bp_loc_hardware_breakpoint
7670 || loc
->loc_type
== bp_loc_software_breakpoint
))
7671 || is_tracepoint (b
))
7672 && solib_contains_address_p (solib
, loc
->address
))
7674 loc
->shlib_disabled
= 1;
7675 /* At this point, we cannot rely on remove_breakpoint
7676 succeeding so we must mark the breakpoint as not inserted
7677 to prevent future errors occurring in remove_breakpoints. */
7680 /* This may cause duplicate notifications for the same breakpoint. */
7681 gdb::observers::breakpoint_modified
.notify (b
);
7683 if (!disabled_shlib_breaks
)
7685 target_terminal::ours_for_output ();
7686 warning (_("Temporarily disabling breakpoints "
7687 "for unloaded shared library \"%s\""),
7690 disabled_shlib_breaks
= 1;
7695 /* Disable any breakpoints and tracepoints in OBJFILE upon
7696 notification of free_objfile. Only apply to enabled breakpoints,
7697 disabled ones can just stay disabled. */
7700 disable_breakpoints_in_freed_objfile (struct objfile
*objfile
)
7702 if (objfile
== NULL
)
7705 /* OBJF_SHARED|OBJF_USERLOADED objfiles are dynamic modules manually
7706 managed by the user with add-symbol-file/remove-symbol-file.
7707 Similarly to how breakpoints in shared libraries are handled in
7708 response to "nosharedlibrary", mark breakpoints in such modules
7709 shlib_disabled so they end up uninserted on the next global
7710 location list update. Shared libraries not loaded by the user
7711 aren't handled here -- they're already handled in
7712 disable_breakpoints_in_unloaded_shlib, called by solib.c's
7713 solib_unloaded observer. We skip objfiles that are not
7714 OBJF_SHARED as those aren't considered dynamic objects (e.g. the
7716 if ((objfile
->flags
& OBJF_SHARED
) == 0
7717 || (objfile
->flags
& OBJF_USERLOADED
) == 0)
7720 for (breakpoint
*b
: all_breakpoints ())
7722 int bp_modified
= 0;
7724 if (!is_breakpoint (b
) && !is_tracepoint (b
))
7727 for (bp_location
*loc
: b
->locations ())
7729 CORE_ADDR loc_addr
= loc
->address
;
7731 if (loc
->loc_type
!= bp_loc_hardware_breakpoint
7732 && loc
->loc_type
!= bp_loc_software_breakpoint
)
7735 if (loc
->shlib_disabled
!= 0)
7738 if (objfile
->pspace
!= loc
->pspace
)
7741 if (loc
->loc_type
!= bp_loc_hardware_breakpoint
7742 && loc
->loc_type
!= bp_loc_software_breakpoint
)
7745 if (is_addr_in_objfile (loc_addr
, objfile
))
7747 loc
->shlib_disabled
= 1;
7748 /* At this point, we don't know whether the object was
7749 unmapped from the inferior or not, so leave the
7750 inserted flag alone. We'll handle failure to
7751 uninsert quietly, in case the object was indeed
7754 mark_breakpoint_location_modified (loc
);
7761 gdb::observers::breakpoint_modified
.notify (b
);
7765 /* FORK & VFORK catchpoints. */
7767 /* An instance of this type is used to represent a fork or vfork
7768 catchpoint. A breakpoint is really of this type iff its ops pointer points
7769 to CATCH_FORK_BREAKPOINT_OPS. */
7771 struct fork_catchpoint
: public breakpoint
7773 /* Process id of a child process whose forking triggered this
7774 catchpoint. This field is only valid immediately after this
7775 catchpoint has triggered. */
7776 ptid_t forked_inferior_pid
;
7779 /* Implement the "insert" breakpoint_ops method for fork
7783 insert_catch_fork (struct bp_location
*bl
)
7785 return target_insert_fork_catchpoint (inferior_ptid
.pid ());
7788 /* Implement the "remove" breakpoint_ops method for fork
7792 remove_catch_fork (struct bp_location
*bl
, enum remove_bp_reason reason
)
7794 return target_remove_fork_catchpoint (inferior_ptid
.pid ());
7797 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
7801 breakpoint_hit_catch_fork (const struct bp_location
*bl
,
7802 const address_space
*aspace
, CORE_ADDR bp_addr
,
7803 const struct target_waitstatus
*ws
)
7805 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bl
->owner
;
7807 if (ws
->kind
!= TARGET_WAITKIND_FORKED
)
7810 c
->forked_inferior_pid
= ws
->value
.related_pid
;
7814 /* Implement the "print_it" breakpoint_ops method for fork
7817 static enum print_stop_action
7818 print_it_catch_fork (bpstat bs
)
7820 struct ui_out
*uiout
= current_uiout
;
7821 struct breakpoint
*b
= bs
->breakpoint_at
;
7822 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bs
->breakpoint_at
;
7824 annotate_catchpoint (b
->number
);
7825 maybe_print_thread_hit_breakpoint (uiout
);
7826 if (b
->disposition
== disp_del
)
7827 uiout
->text ("Temporary catchpoint ");
7829 uiout
->text ("Catchpoint ");
7830 if (uiout
->is_mi_like_p ())
7832 uiout
->field_string ("reason", async_reason_lookup (EXEC_ASYNC_FORK
));
7833 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
7835 uiout
->field_signed ("bkptno", b
->number
);
7836 uiout
->text (" (forked process ");
7837 uiout
->field_signed ("newpid", c
->forked_inferior_pid
.pid ());
7838 uiout
->text ("), ");
7839 return PRINT_SRC_AND_LOC
;
7842 /* Implement the "print_one" breakpoint_ops method for fork
7846 print_one_catch_fork (struct breakpoint
*b
, struct bp_location
**last_loc
)
7848 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
7849 struct value_print_options opts
;
7850 struct ui_out
*uiout
= current_uiout
;
7852 get_user_print_options (&opts
);
7854 /* Field 4, the address, is omitted (which makes the columns not
7855 line up too nicely with the headers, but the effect is relatively
7857 if (opts
.addressprint
)
7858 uiout
->field_skip ("addr");
7860 uiout
->text ("fork");
7861 if (c
->forked_inferior_pid
!= null_ptid
)
7863 uiout
->text (", process ");
7864 uiout
->field_signed ("what", c
->forked_inferior_pid
.pid ());
7868 if (uiout
->is_mi_like_p ())
7869 uiout
->field_string ("catch-type", "fork");
7872 /* Implement the "print_mention" breakpoint_ops method for fork
7876 print_mention_catch_fork (struct breakpoint
*b
)
7878 printf_filtered (_("Catchpoint %d (fork)"), b
->number
);
7881 /* Implement the "print_recreate" breakpoint_ops method for fork
7885 print_recreate_catch_fork (struct breakpoint
*b
, struct ui_file
*fp
)
7887 fprintf_unfiltered (fp
, "catch fork");
7888 print_recreate_thread (b
, fp
);
7891 /* The breakpoint_ops structure to be used in fork catchpoints. */
7893 static struct breakpoint_ops catch_fork_breakpoint_ops
;
7895 /* Implement the "insert" breakpoint_ops method for vfork
7899 insert_catch_vfork (struct bp_location
*bl
)
7901 return target_insert_vfork_catchpoint (inferior_ptid
.pid ());
7904 /* Implement the "remove" breakpoint_ops method for vfork
7908 remove_catch_vfork (struct bp_location
*bl
, enum remove_bp_reason reason
)
7910 return target_remove_vfork_catchpoint (inferior_ptid
.pid ());
7913 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
7917 breakpoint_hit_catch_vfork (const struct bp_location
*bl
,
7918 const address_space
*aspace
, CORE_ADDR bp_addr
,
7919 const struct target_waitstatus
*ws
)
7921 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bl
->owner
;
7923 if (ws
->kind
!= TARGET_WAITKIND_VFORKED
)
7926 c
->forked_inferior_pid
= ws
->value
.related_pid
;
7930 /* Implement the "print_it" breakpoint_ops method for vfork
7933 static enum print_stop_action
7934 print_it_catch_vfork (bpstat bs
)
7936 struct ui_out
*uiout
= current_uiout
;
7937 struct breakpoint
*b
= bs
->breakpoint_at
;
7938 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
7940 annotate_catchpoint (b
->number
);
7941 maybe_print_thread_hit_breakpoint (uiout
);
7942 if (b
->disposition
== disp_del
)
7943 uiout
->text ("Temporary catchpoint ");
7945 uiout
->text ("Catchpoint ");
7946 if (uiout
->is_mi_like_p ())
7948 uiout
->field_string ("reason", async_reason_lookup (EXEC_ASYNC_VFORK
));
7949 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
7951 uiout
->field_signed ("bkptno", b
->number
);
7952 uiout
->text (" (vforked process ");
7953 uiout
->field_signed ("newpid", c
->forked_inferior_pid
.pid ());
7954 uiout
->text ("), ");
7955 return PRINT_SRC_AND_LOC
;
7958 /* Implement the "print_one" breakpoint_ops method for vfork
7962 print_one_catch_vfork (struct breakpoint
*b
, struct bp_location
**last_loc
)
7964 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
7965 struct value_print_options opts
;
7966 struct ui_out
*uiout
= current_uiout
;
7968 get_user_print_options (&opts
);
7969 /* Field 4, the address, is omitted (which makes the columns not
7970 line up too nicely with the headers, but the effect is relatively
7972 if (opts
.addressprint
)
7973 uiout
->field_skip ("addr");
7975 uiout
->text ("vfork");
7976 if (c
->forked_inferior_pid
!= null_ptid
)
7978 uiout
->text (", process ");
7979 uiout
->field_signed ("what", c
->forked_inferior_pid
.pid ());
7983 if (uiout
->is_mi_like_p ())
7984 uiout
->field_string ("catch-type", "vfork");
7987 /* Implement the "print_mention" breakpoint_ops method for vfork
7991 print_mention_catch_vfork (struct breakpoint
*b
)
7993 printf_filtered (_("Catchpoint %d (vfork)"), b
->number
);
7996 /* Implement the "print_recreate" breakpoint_ops method for vfork
8000 print_recreate_catch_vfork (struct breakpoint
*b
, struct ui_file
*fp
)
8002 fprintf_unfiltered (fp
, "catch vfork");
8003 print_recreate_thread (b
, fp
);
8006 /* The breakpoint_ops structure to be used in vfork catchpoints. */
8008 static struct breakpoint_ops catch_vfork_breakpoint_ops
;
8010 /* An instance of this type is used to represent an solib catchpoint.
8011 A breakpoint is really of this type iff its ops pointer points to
8012 CATCH_SOLIB_BREAKPOINT_OPS. */
8014 struct solib_catchpoint
: public breakpoint
8016 ~solib_catchpoint () override
;
8018 /* True for "catch load", false for "catch unload". */
8021 /* Regular expression to match, if any. COMPILED is only valid when
8022 REGEX is non-NULL. */
8024 std::unique_ptr
<compiled_regex
> compiled
;
8027 solib_catchpoint::~solib_catchpoint ()
8029 xfree (this->regex
);
8033 insert_catch_solib (struct bp_location
*ignore
)
8039 remove_catch_solib (struct bp_location
*ignore
, enum remove_bp_reason reason
)
8045 breakpoint_hit_catch_solib (const struct bp_location
*bl
,
8046 const address_space
*aspace
,
8048 const struct target_waitstatus
*ws
)
8050 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) bl
->owner
;
8052 if (ws
->kind
== TARGET_WAITKIND_LOADED
)
8055 for (breakpoint
*other
: all_breakpoints ())
8057 if (other
== bl
->owner
)
8060 if (other
->type
!= bp_shlib_event
)
8063 if (self
->pspace
!= NULL
&& other
->pspace
!= self
->pspace
)
8066 for (bp_location
*other_bl
: other
->locations ())
8068 if (other
->ops
->breakpoint_hit (other_bl
, aspace
, bp_addr
, ws
))
8077 check_status_catch_solib (struct bpstats
*bs
)
8079 struct solib_catchpoint
*self
8080 = (struct solib_catchpoint
*) bs
->breakpoint_at
;
8084 for (so_list
*iter
: current_program_space
->added_solibs
)
8087 || self
->compiled
->exec (iter
->so_name
, 0, NULL
, 0) == 0)
8093 for (const std::string
&iter
: current_program_space
->deleted_solibs
)
8096 || self
->compiled
->exec (iter
.c_str (), 0, NULL
, 0) == 0)
8102 bs
->print_it
= print_it_noop
;
8105 static enum print_stop_action
8106 print_it_catch_solib (bpstat bs
)
8108 struct breakpoint
*b
= bs
->breakpoint_at
;
8109 struct ui_out
*uiout
= current_uiout
;
8111 annotate_catchpoint (b
->number
);
8112 maybe_print_thread_hit_breakpoint (uiout
);
8113 if (b
->disposition
== disp_del
)
8114 uiout
->text ("Temporary catchpoint ");
8116 uiout
->text ("Catchpoint ");
8117 uiout
->field_signed ("bkptno", b
->number
);
8119 if (uiout
->is_mi_like_p ())
8120 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
8121 print_solib_event (1);
8122 return PRINT_SRC_AND_LOC
;
8126 print_one_catch_solib (struct breakpoint
*b
, struct bp_location
**locs
)
8128 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8129 struct value_print_options opts
;
8130 struct ui_out
*uiout
= current_uiout
;
8132 get_user_print_options (&opts
);
8133 /* Field 4, the address, is omitted (which makes the columns not
8134 line up too nicely with the headers, but the effect is relatively
8136 if (opts
.addressprint
)
8139 uiout
->field_skip ("addr");
8147 msg
= string_printf (_("load of library matching %s"), self
->regex
);
8149 msg
= _("load of library");
8154 msg
= string_printf (_("unload of library matching %s"), self
->regex
);
8156 msg
= _("unload of library");
8158 uiout
->field_string ("what", msg
);
8160 if (uiout
->is_mi_like_p ())
8161 uiout
->field_string ("catch-type", self
->is_load
? "load" : "unload");
8165 print_mention_catch_solib (struct breakpoint
*b
)
8167 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8169 printf_filtered (_("Catchpoint %d (%s)"), b
->number
,
8170 self
->is_load
? "load" : "unload");
8174 print_recreate_catch_solib (struct breakpoint
*b
, struct ui_file
*fp
)
8176 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8178 fprintf_unfiltered (fp
, "%s %s",
8179 b
->disposition
== disp_del
? "tcatch" : "catch",
8180 self
->is_load
? "load" : "unload");
8182 fprintf_unfiltered (fp
, " %s", self
->regex
);
8183 fprintf_unfiltered (fp
, "\n");
8186 static struct breakpoint_ops catch_solib_breakpoint_ops
;
8188 /* See breakpoint.h. */
8191 add_solib_catchpoint (const char *arg
, bool is_load
, bool is_temp
, bool enabled
)
8193 struct gdbarch
*gdbarch
= get_current_arch ();
8197 arg
= skip_spaces (arg
);
8199 std::unique_ptr
<solib_catchpoint
> c (new solib_catchpoint ());
8203 c
->compiled
.reset (new compiled_regex (arg
, REG_NOSUB
,
8204 _("Invalid regexp")));
8205 c
->regex
= xstrdup (arg
);
8208 c
->is_load
= is_load
;
8209 init_catchpoint (c
.get (), gdbarch
, is_temp
, NULL
,
8210 &catch_solib_breakpoint_ops
);
8212 c
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
8214 install_breakpoint (0, std::move (c
), 1);
8217 /* A helper function that does all the work for "catch load" and
8221 catch_load_or_unload (const char *arg
, int from_tty
, int is_load
,
8222 struct cmd_list_element
*command
)
8224 const int enabled
= 1;
8225 bool temp
= get_cmd_context (command
) == CATCH_TEMPORARY
;
8227 add_solib_catchpoint (arg
, is_load
, temp
, enabled
);
8231 catch_load_command_1 (const char *arg
, int from_tty
,
8232 struct cmd_list_element
*command
)
8234 catch_load_or_unload (arg
, from_tty
, 1, command
);
8238 catch_unload_command_1 (const char *arg
, int from_tty
,
8239 struct cmd_list_element
*command
)
8241 catch_load_or_unload (arg
, from_tty
, 0, command
);
8244 /* See breakpoint.h. */
8247 init_catchpoint (struct breakpoint
*b
,
8248 struct gdbarch
*gdbarch
, bool temp
,
8249 const char *cond_string
,
8250 const struct breakpoint_ops
*ops
)
8252 symtab_and_line sal
;
8253 sal
.pspace
= current_program_space
;
8255 init_raw_breakpoint (b
, gdbarch
, sal
, bp_catchpoint
, ops
);
8257 b
->cond_string
= (cond_string
== NULL
) ? NULL
: xstrdup (cond_string
);
8258 b
->disposition
= temp
? disp_del
: disp_donttouch
;
8262 install_breakpoint (int internal
, std::unique_ptr
<breakpoint
> &&arg
, int update_gll
)
8264 breakpoint
*b
= add_to_breakpoint_chain (std::move (arg
));
8265 set_breakpoint_number (internal
, b
);
8266 if (is_tracepoint (b
))
8267 set_tracepoint_count (breakpoint_count
);
8270 gdb::observers::breakpoint_created
.notify (b
);
8273 update_global_location_list (UGLL_MAY_INSERT
);
8277 create_fork_vfork_event_catchpoint (struct gdbarch
*gdbarch
,
8278 bool temp
, const char *cond_string
,
8279 const struct breakpoint_ops
*ops
)
8281 std::unique_ptr
<fork_catchpoint
> c (new fork_catchpoint ());
8283 init_catchpoint (c
.get (), gdbarch
, temp
, cond_string
, ops
);
8285 c
->forked_inferior_pid
= null_ptid
;
8287 install_breakpoint (0, std::move (c
), 1);
8290 /* Exec catchpoints. */
8292 /* An instance of this type is used to represent an exec catchpoint.
8293 A breakpoint is really of this type iff its ops pointer points to
8294 CATCH_EXEC_BREAKPOINT_OPS. */
8296 struct exec_catchpoint
: public breakpoint
8298 ~exec_catchpoint () override
;
8300 /* Filename of a program whose exec triggered this catchpoint.
8301 This field is only valid immediately after this catchpoint has
8303 char *exec_pathname
;
8306 /* Exec catchpoint destructor. */
8308 exec_catchpoint::~exec_catchpoint ()
8310 xfree (this->exec_pathname
);
8314 insert_catch_exec (struct bp_location
*bl
)
8316 return target_insert_exec_catchpoint (inferior_ptid
.pid ());
8320 remove_catch_exec (struct bp_location
*bl
, enum remove_bp_reason reason
)
8322 return target_remove_exec_catchpoint (inferior_ptid
.pid ());
8326 breakpoint_hit_catch_exec (const struct bp_location
*bl
,
8327 const address_space
*aspace
, CORE_ADDR bp_addr
,
8328 const struct target_waitstatus
*ws
)
8330 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) bl
->owner
;
8332 if (ws
->kind
!= TARGET_WAITKIND_EXECD
)
8335 c
->exec_pathname
= xstrdup (ws
->value
.execd_pathname
);
8339 static enum print_stop_action
8340 print_it_catch_exec (bpstat bs
)
8342 struct ui_out
*uiout
= current_uiout
;
8343 struct breakpoint
*b
= bs
->breakpoint_at
;
8344 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
8346 annotate_catchpoint (b
->number
);
8347 maybe_print_thread_hit_breakpoint (uiout
);
8348 if (b
->disposition
== disp_del
)
8349 uiout
->text ("Temporary catchpoint ");
8351 uiout
->text ("Catchpoint ");
8352 if (uiout
->is_mi_like_p ())
8354 uiout
->field_string ("reason", async_reason_lookup (EXEC_ASYNC_EXEC
));
8355 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
8357 uiout
->field_signed ("bkptno", b
->number
);
8358 uiout
->text (" (exec'd ");
8359 uiout
->field_string ("new-exec", c
->exec_pathname
);
8360 uiout
->text ("), ");
8362 return PRINT_SRC_AND_LOC
;
8366 print_one_catch_exec (struct breakpoint
*b
, struct bp_location
**last_loc
)
8368 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
8369 struct value_print_options opts
;
8370 struct ui_out
*uiout
= current_uiout
;
8372 get_user_print_options (&opts
);
8374 /* Field 4, the address, is omitted (which makes the columns
8375 not line up too nicely with the headers, but the effect
8376 is relatively readable). */
8377 if (opts
.addressprint
)
8378 uiout
->field_skip ("addr");
8380 uiout
->text ("exec");
8381 if (c
->exec_pathname
!= NULL
)
8383 uiout
->text (", program \"");
8384 uiout
->field_string ("what", c
->exec_pathname
);
8385 uiout
->text ("\" ");
8388 if (uiout
->is_mi_like_p ())
8389 uiout
->field_string ("catch-type", "exec");
8393 print_mention_catch_exec (struct breakpoint
*b
)
8395 printf_filtered (_("Catchpoint %d (exec)"), b
->number
);
8398 /* Implement the "print_recreate" breakpoint_ops method for exec
8402 print_recreate_catch_exec (struct breakpoint
*b
, struct ui_file
*fp
)
8404 fprintf_unfiltered (fp
, "catch exec");
8405 print_recreate_thread (b
, fp
);
8408 static struct breakpoint_ops catch_exec_breakpoint_ops
;
8411 hw_breakpoint_used_count (void)
8415 for (breakpoint
*b
: all_breakpoints ())
8416 if (b
->type
== bp_hardware_breakpoint
&& breakpoint_enabled (b
))
8417 for (bp_location
*bl
: b
->locations ())
8419 /* Special types of hardware breakpoints may use more than
8421 i
+= b
->ops
->resources_needed (bl
);
8427 /* Returns the resources B would use if it were a hardware
8431 hw_watchpoint_use_count (struct breakpoint
*b
)
8435 if (!breakpoint_enabled (b
))
8438 for (bp_location
*bl
: b
->locations ())
8440 /* Special types of hardware watchpoints may use more than
8442 i
+= b
->ops
->resources_needed (bl
);
8448 /* Returns the sum the used resources of all hardware watchpoints of
8449 type TYPE in the breakpoints list. Also returns in OTHER_TYPE_USED
8450 the sum of the used resources of all hardware watchpoints of other
8451 types _not_ TYPE. */
8454 hw_watchpoint_used_count_others (struct breakpoint
*except
,
8455 enum bptype type
, int *other_type_used
)
8459 *other_type_used
= 0;
8460 for (breakpoint
*b
: all_breakpoints ())
8464 if (!breakpoint_enabled (b
))
8467 if (b
->type
== type
)
8468 i
+= hw_watchpoint_use_count (b
);
8469 else if (is_hardware_watchpoint (b
))
8470 *other_type_used
= 1;
8477 disable_watchpoints_before_interactive_call_start (void)
8479 for (breakpoint
*b
: all_breakpoints ())
8480 if (is_watchpoint (b
) && breakpoint_enabled (b
))
8482 b
->enable_state
= bp_call_disabled
;
8483 update_global_location_list (UGLL_DONT_INSERT
);
8488 enable_watchpoints_after_interactive_call_stop (void)
8490 for (breakpoint
*b
: all_breakpoints ())
8491 if (is_watchpoint (b
) && b
->enable_state
== bp_call_disabled
)
8493 b
->enable_state
= bp_enabled
;
8494 update_global_location_list (UGLL_MAY_INSERT
);
8499 disable_breakpoints_before_startup (void)
8501 current_program_space
->executing_startup
= 1;
8502 update_global_location_list (UGLL_DONT_INSERT
);
8506 enable_breakpoints_after_startup (void)
8508 current_program_space
->executing_startup
= 0;
8509 breakpoint_re_set ();
8512 /* Create a new single-step breakpoint for thread THREAD, with no
8515 static struct breakpoint
*
8516 new_single_step_breakpoint (int thread
, struct gdbarch
*gdbarch
)
8518 std::unique_ptr
<breakpoint
> b (new breakpoint ());
8520 init_raw_breakpoint_without_location (b
.get (), gdbarch
, bp_single_step
,
8521 &momentary_breakpoint_ops
);
8523 b
->disposition
= disp_donttouch
;
8524 b
->frame_id
= null_frame_id
;
8527 gdb_assert (b
->thread
!= 0);
8529 return add_to_breakpoint_chain (std::move (b
));
8532 /* Set a momentary breakpoint of type TYPE at address specified by
8533 SAL. If FRAME_ID is valid, the breakpoint is restricted to that
8537 set_momentary_breakpoint (struct gdbarch
*gdbarch
, struct symtab_and_line sal
,
8538 struct frame_id frame_id
, enum bptype type
)
8540 struct breakpoint
*b
;
8542 /* If FRAME_ID is valid, it should be a real frame, not an inlined or
8544 gdb_assert (!frame_id_artificial_p (frame_id
));
8546 b
= set_raw_breakpoint (gdbarch
, sal
, type
, &momentary_breakpoint_ops
);
8547 b
->enable_state
= bp_enabled
;
8548 b
->disposition
= disp_donttouch
;
8549 b
->frame_id
= frame_id
;
8551 b
->thread
= inferior_thread ()->global_num
;
8553 update_global_location_list_nothrow (UGLL_MAY_INSERT
);
8555 return breakpoint_up (b
);
8558 /* Make a momentary breakpoint based on the master breakpoint ORIG.
8559 The new breakpoint will have type TYPE, use OPS as its
8560 breakpoint_ops, and will set enabled to LOC_ENABLED. */
8562 static struct breakpoint
*
8563 momentary_breakpoint_from_master (struct breakpoint
*orig
,
8565 const struct breakpoint_ops
*ops
,
8568 struct breakpoint
*copy
;
8570 copy
= set_raw_breakpoint_without_location (orig
->gdbarch
, type
, ops
);
8571 copy
->loc
= allocate_bp_location (copy
);
8572 set_breakpoint_location_function (copy
->loc
);
8574 copy
->loc
->gdbarch
= orig
->loc
->gdbarch
;
8575 copy
->loc
->requested_address
= orig
->loc
->requested_address
;
8576 copy
->loc
->address
= orig
->loc
->address
;
8577 copy
->loc
->section
= orig
->loc
->section
;
8578 copy
->loc
->pspace
= orig
->loc
->pspace
;
8579 copy
->loc
->probe
= orig
->loc
->probe
;
8580 copy
->loc
->line_number
= orig
->loc
->line_number
;
8581 copy
->loc
->symtab
= orig
->loc
->symtab
;
8582 copy
->loc
->enabled
= loc_enabled
;
8583 copy
->frame_id
= orig
->frame_id
;
8584 copy
->thread
= orig
->thread
;
8585 copy
->pspace
= orig
->pspace
;
8587 copy
->enable_state
= bp_enabled
;
8588 copy
->disposition
= disp_donttouch
;
8589 copy
->number
= internal_breakpoint_number
--;
8591 update_global_location_list_nothrow (UGLL_DONT_INSERT
);
8595 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
8599 clone_momentary_breakpoint (struct breakpoint
*orig
)
8601 /* If there's nothing to clone, then return nothing. */
8605 return momentary_breakpoint_from_master (orig
, orig
->type
, orig
->ops
, 0);
8609 set_momentary_breakpoint_at_pc (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
8612 struct symtab_and_line sal
;
8614 sal
= find_pc_line (pc
, 0);
8616 sal
.section
= find_pc_overlay (pc
);
8617 sal
.explicit_pc
= 1;
8619 return set_momentary_breakpoint (gdbarch
, sal
, null_frame_id
, type
);
8623 /* Tell the user we have just set a breakpoint B. */
8626 mention (struct breakpoint
*b
)
8628 b
->ops
->print_mention (b
);
8629 current_uiout
->text ("\n");
8633 static bool bp_loc_is_permanent (struct bp_location
*loc
);
8635 /* Handle "set breakpoint auto-hw on".
8637 If the explicitly specified breakpoint type is not hardware
8638 breakpoint, check the memory map to see whether the breakpoint
8639 address is in read-only memory.
8641 - location type is not hardware breakpoint, memory is read-only.
8642 We change the type of the location to hardware breakpoint.
8644 - location type is hardware breakpoint, memory is read-write. This
8645 means we've previously made the location hardware one, but then the
8646 memory map changed, so we undo.
8650 handle_automatic_hardware_breakpoints (bp_location
*bl
)
8652 if (automatic_hardware_breakpoints
8653 && bl
->owner
->type
!= bp_hardware_breakpoint
8654 && (bl
->loc_type
== bp_loc_software_breakpoint
8655 || bl
->loc_type
== bp_loc_hardware_breakpoint
))
8657 /* When breakpoints are removed, remove_breakpoints will use
8658 location types we've just set here, the only possible problem
8659 is that memory map has changed during running program, but
8660 it's not going to work anyway with current gdb. */
8661 mem_region
*mr
= lookup_mem_region (bl
->address
);
8665 enum bp_loc_type new_type
;
8667 if (mr
->attrib
.mode
!= MEM_RW
)
8668 new_type
= bp_loc_hardware_breakpoint
;
8670 new_type
= bp_loc_software_breakpoint
;
8672 if (new_type
!= bl
->loc_type
)
8674 static bool said
= false;
8676 bl
->loc_type
= new_type
;
8679 fprintf_filtered (gdb_stdout
,
8680 _("Note: automatically using "
8681 "hardware breakpoints for "
8682 "read-only addresses.\n"));
8690 static struct bp_location
*
8691 add_location_to_breakpoint (struct breakpoint
*b
,
8692 const struct symtab_and_line
*sal
)
8694 struct bp_location
*loc
, **tmp
;
8695 CORE_ADDR adjusted_address
;
8696 struct gdbarch
*loc_gdbarch
= get_sal_arch (*sal
);
8698 if (loc_gdbarch
== NULL
)
8699 loc_gdbarch
= b
->gdbarch
;
8701 /* Adjust the breakpoint's address prior to allocating a location.
8702 Once we call allocate_bp_location(), that mostly uninitialized
8703 location will be placed on the location chain. Adjustment of the
8704 breakpoint may cause target_read_memory() to be called and we do
8705 not want its scan of the location chain to find a breakpoint and
8706 location that's only been partially initialized. */
8707 adjusted_address
= adjust_breakpoint_address (loc_gdbarch
,
8710 /* Sort the locations by their ADDRESS. */
8711 loc
= allocate_bp_location (b
);
8712 for (tmp
= &(b
->loc
); *tmp
!= NULL
&& (*tmp
)->address
<= adjusted_address
;
8713 tmp
= &((*tmp
)->next
))
8718 loc
->requested_address
= sal
->pc
;
8719 loc
->address
= adjusted_address
;
8720 loc
->pspace
= sal
->pspace
;
8721 loc
->probe
.prob
= sal
->prob
;
8722 loc
->probe
.objfile
= sal
->objfile
;
8723 gdb_assert (loc
->pspace
!= NULL
);
8724 loc
->section
= sal
->section
;
8725 loc
->gdbarch
= loc_gdbarch
;
8726 loc
->line_number
= sal
->line
;
8727 loc
->symtab
= sal
->symtab
;
8728 loc
->symbol
= sal
->symbol
;
8729 loc
->msymbol
= sal
->msymbol
;
8730 loc
->objfile
= sal
->objfile
;
8732 set_breakpoint_location_function (loc
);
8734 /* While by definition, permanent breakpoints are already present in the
8735 code, we don't mark the location as inserted. Normally one would expect
8736 that GDB could rely on that breakpoint instruction to stop the program,
8737 thus removing the need to insert its own breakpoint, except that executing
8738 the breakpoint instruction can kill the target instead of reporting a
8739 SIGTRAP. E.g., on SPARC, when interrupts are disabled, executing the
8740 instruction resets the CPU, so QEMU 2.0.0 for SPARC correspondingly dies
8741 with "Trap 0x02 while interrupts disabled, Error state". Letting the
8742 breakpoint be inserted normally results in QEMU knowing about the GDB
8743 breakpoint, and thus trap before the breakpoint instruction is executed.
8744 (If GDB later needs to continue execution past the permanent breakpoint,
8745 it manually increments the PC, thus avoiding executing the breakpoint
8747 if (bp_loc_is_permanent (loc
))
8754 /* Return true if LOC is pointing to a permanent breakpoint,
8755 return false otherwise. */
8758 bp_loc_is_permanent (struct bp_location
*loc
)
8760 gdb_assert (loc
!= NULL
);
8762 /* If we have a non-breakpoint-backed catchpoint or a software
8763 watchpoint, just return 0. We should not attempt to read from
8764 the addresses the locations of these breakpoint types point to.
8765 gdbarch_program_breakpoint_here_p, below, will attempt to read
8767 if (!bl_address_is_meaningful (loc
))
8770 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
8771 switch_to_program_space_and_thread (loc
->pspace
);
8772 return gdbarch_program_breakpoint_here_p (loc
->gdbarch
, loc
->address
);
8775 /* Build a command list for the dprintf corresponding to the current
8776 settings of the dprintf style options. */
8779 update_dprintf_command_list (struct breakpoint
*b
)
8781 char *dprintf_args
= b
->extra_string
;
8782 char *printf_line
= NULL
;
8787 dprintf_args
= skip_spaces (dprintf_args
);
8789 /* Allow a comma, as it may have terminated a location, but don't
8791 if (*dprintf_args
== ',')
8793 dprintf_args
= skip_spaces (dprintf_args
);
8795 if (*dprintf_args
!= '"')
8796 error (_("Bad format string, missing '\"'."));
8798 if (strcmp (dprintf_style
, dprintf_style_gdb
) == 0)
8799 printf_line
= xstrprintf ("printf %s", dprintf_args
);
8800 else if (strcmp (dprintf_style
, dprintf_style_call
) == 0)
8802 if (!dprintf_function
)
8803 error (_("No function supplied for dprintf call"));
8805 if (dprintf_channel
&& strlen (dprintf_channel
) > 0)
8806 printf_line
= xstrprintf ("call (void) %s (%s,%s)",
8811 printf_line
= xstrprintf ("call (void) %s (%s)",
8815 else if (strcmp (dprintf_style
, dprintf_style_agent
) == 0)
8817 if (target_can_run_breakpoint_commands ())
8818 printf_line
= xstrprintf ("agent-printf %s", dprintf_args
);
8821 warning (_("Target cannot run dprintf commands, falling back to GDB printf"));
8822 printf_line
= xstrprintf ("printf %s", dprintf_args
);
8826 internal_error (__FILE__
, __LINE__
,
8827 _("Invalid dprintf style."));
8829 gdb_assert (printf_line
!= NULL
);
8831 /* Manufacture a printf sequence. */
8832 struct command_line
*printf_cmd_line
8833 = new struct command_line (simple_control
, printf_line
);
8834 breakpoint_set_commands (b
, counted_command_line (printf_cmd_line
,
8835 command_lines_deleter ()));
8838 /* Update all dprintf commands, making their command lists reflect
8839 current style settings. */
8842 update_dprintf_commands (const char *args
, int from_tty
,
8843 struct cmd_list_element
*c
)
8845 for (breakpoint
*b
: all_breakpoints ())
8846 if (b
->type
== bp_dprintf
)
8847 update_dprintf_command_list (b
);
8850 /* Create a breakpoint with SAL as location. Use LOCATION
8851 as a description of the location, and COND_STRING
8852 as condition expression. If LOCATION is NULL then create an
8853 "address location" from the address in the SAL. */
8856 init_breakpoint_sal (struct breakpoint
*b
, struct gdbarch
*gdbarch
,
8857 gdb::array_view
<const symtab_and_line
> sals
,
8858 event_location_up
&&location
,
8859 gdb::unique_xmalloc_ptr
<char> filter
,
8860 gdb::unique_xmalloc_ptr
<char> cond_string
,
8861 gdb::unique_xmalloc_ptr
<char> extra_string
,
8862 enum bptype type
, enum bpdisp disposition
,
8863 int thread
, int task
, int ignore_count
,
8864 const struct breakpoint_ops
*ops
, int from_tty
,
8865 int enabled
, int internal
, unsigned flags
,
8866 int display_canonical
)
8870 if (type
== bp_hardware_breakpoint
)
8872 int target_resources_ok
;
8874 i
= hw_breakpoint_used_count ();
8875 target_resources_ok
=
8876 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
8878 if (target_resources_ok
== 0)
8879 error (_("No hardware breakpoint support in the target."));
8880 else if (target_resources_ok
< 0)
8881 error (_("Hardware breakpoints used exceeds limit."));
8884 gdb_assert (!sals
.empty ());
8886 for (const auto &sal
: sals
)
8888 struct bp_location
*loc
;
8892 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
8894 loc_gdbarch
= gdbarch
;
8896 describe_other_breakpoints (loc_gdbarch
,
8897 sal
.pspace
, sal
.pc
, sal
.section
, thread
);
8900 if (&sal
== &sals
[0])
8902 init_raw_breakpoint (b
, gdbarch
, sal
, type
, ops
);
8906 b
->cond_string
= cond_string
.release ();
8907 b
->extra_string
= extra_string
.release ();
8908 b
->ignore_count
= ignore_count
;
8909 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
8910 b
->disposition
= disposition
;
8912 if ((flags
& CREATE_BREAKPOINT_FLAGS_INSERTED
) != 0)
8913 b
->loc
->inserted
= 1;
8915 if (type
== bp_static_tracepoint
)
8917 struct tracepoint
*t
= (struct tracepoint
*) b
;
8918 struct static_tracepoint_marker marker
;
8920 if (strace_marker_p (b
))
8922 /* We already know the marker exists, otherwise, we
8923 wouldn't see a sal for it. */
8925 = &event_location_to_string (b
->location
.get ())[3];
8928 p
= skip_spaces (p
);
8930 endp
= skip_to_space (p
);
8932 t
->static_trace_marker_id
.assign (p
, endp
- p
);
8934 printf_filtered (_("Probed static tracepoint "
8936 t
->static_trace_marker_id
.c_str ());
8938 else if (target_static_tracepoint_marker_at (sal
.pc
, &marker
))
8940 t
->static_trace_marker_id
= std::move (marker
.str_id
);
8942 printf_filtered (_("Probed static tracepoint "
8944 t
->static_trace_marker_id
.c_str ());
8947 warning (_("Couldn't determine the static "
8948 "tracepoint marker to probe"));
8955 loc
= add_location_to_breakpoint (b
, &sal
);
8956 if ((flags
& CREATE_BREAKPOINT_FLAGS_INSERTED
) != 0)
8960 /* Do not set breakpoint locations conditions yet. As locations
8961 are inserted, they get sorted based on their addresses. Let
8962 the list stabilize to have reliable location numbers. */
8964 /* Dynamic printf requires and uses additional arguments on the
8965 command line, otherwise it's an error. */
8966 if (type
== bp_dprintf
)
8968 if (b
->extra_string
)
8969 update_dprintf_command_list (b
);
8971 error (_("Format string required"));
8973 else if (b
->extra_string
)
8974 error (_("Garbage '%s' at end of command"), b
->extra_string
);
8978 /* The order of the locations is now stable. Set the location
8979 condition using the location's number. */
8981 for (bp_location
*loc
: b
->locations ())
8983 if (b
->cond_string
!= nullptr)
8984 set_breakpoint_location_condition (b
->cond_string
, loc
, b
->number
,
8990 b
->display_canonical
= display_canonical
;
8991 if (location
!= NULL
)
8992 b
->location
= std::move (location
);
8994 b
->location
= new_address_location (b
->loc
->address
, NULL
, 0);
8995 b
->filter
= std::move (filter
);
8999 create_breakpoint_sal (struct gdbarch
*gdbarch
,
9000 gdb::array_view
<const symtab_and_line
> sals
,
9001 event_location_up
&&location
,
9002 gdb::unique_xmalloc_ptr
<char> filter
,
9003 gdb::unique_xmalloc_ptr
<char> cond_string
,
9004 gdb::unique_xmalloc_ptr
<char> extra_string
,
9005 enum bptype type
, enum bpdisp disposition
,
9006 int thread
, int task
, int ignore_count
,
9007 const struct breakpoint_ops
*ops
, int from_tty
,
9008 int enabled
, int internal
, unsigned flags
,
9009 int display_canonical
)
9011 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (type
);
9013 init_breakpoint_sal (b
.get (), gdbarch
,
9014 sals
, std::move (location
),
9016 std::move (cond_string
),
9017 std::move (extra_string
),
9019 thread
, task
, ignore_count
,
9021 enabled
, internal
, flags
,
9024 install_breakpoint (internal
, std::move (b
), 0);
9027 /* Add SALS.nelts breakpoints to the breakpoint table. For each
9028 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
9029 value. COND_STRING, if not NULL, specified the condition to be
9030 used for all breakpoints. Essentially the only case where
9031 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
9032 function. In that case, it's still not possible to specify
9033 separate conditions for different overloaded functions, so
9034 we take just a single condition string.
9036 NOTE: If the function succeeds, the caller is expected to cleanup
9037 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
9038 array contents). If the function fails (error() is called), the
9039 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
9040 COND and SALS arrays and each of those arrays contents. */
9043 create_breakpoints_sal (struct gdbarch
*gdbarch
,
9044 struct linespec_result
*canonical
,
9045 gdb::unique_xmalloc_ptr
<char> cond_string
,
9046 gdb::unique_xmalloc_ptr
<char> extra_string
,
9047 enum bptype type
, enum bpdisp disposition
,
9048 int thread
, int task
, int ignore_count
,
9049 const struct breakpoint_ops
*ops
, int from_tty
,
9050 int enabled
, int internal
, unsigned flags
)
9052 if (canonical
->pre_expanded
)
9053 gdb_assert (canonical
->lsals
.size () == 1);
9055 for (const auto &lsal
: canonical
->lsals
)
9057 /* Note that 'location' can be NULL in the case of a plain
9058 'break', without arguments. */
9059 event_location_up location
9060 = (canonical
->location
!= NULL
9061 ? copy_event_location (canonical
->location
.get ()) : NULL
);
9062 gdb::unique_xmalloc_ptr
<char> filter_string
9063 (lsal
.canonical
!= NULL
? xstrdup (lsal
.canonical
) : NULL
);
9065 create_breakpoint_sal (gdbarch
, lsal
.sals
,
9066 std::move (location
),
9067 std::move (filter_string
),
9068 std::move (cond_string
),
9069 std::move (extra_string
),
9071 thread
, task
, ignore_count
, ops
,
9072 from_tty
, enabled
, internal
, flags
,
9073 canonical
->special_display
);
9077 /* Parse LOCATION which is assumed to be a SAL specification possibly
9078 followed by conditionals. On return, SALS contains an array of SAL
9079 addresses found. LOCATION points to the end of the SAL (for
9080 linespec locations).
9082 The array and the line spec strings are allocated on the heap, it is
9083 the caller's responsibility to free them. */
9086 parse_breakpoint_sals (struct event_location
*location
,
9087 struct linespec_result
*canonical
)
9089 struct symtab_and_line cursal
;
9091 if (event_location_type (location
) == LINESPEC_LOCATION
)
9093 const char *spec
= get_linespec_location (location
)->spec_string
;
9097 /* The last displayed codepoint, if it's valid, is our default
9098 breakpoint address. */
9099 if (last_displayed_sal_is_valid ())
9101 /* Set sal's pspace, pc, symtab, and line to the values
9102 corresponding to the last call to print_frame_info.
9103 Be sure to reinitialize LINE with NOTCURRENT == 0
9104 as the breakpoint line number is inappropriate otherwise.
9105 find_pc_line would adjust PC, re-set it back. */
9106 symtab_and_line sal
= get_last_displayed_sal ();
9107 CORE_ADDR pc
= sal
.pc
;
9109 sal
= find_pc_line (pc
, 0);
9111 /* "break" without arguments is equivalent to "break *PC"
9112 where PC is the last displayed codepoint's address. So
9113 make sure to set sal.explicit_pc to prevent GDB from
9114 trying to expand the list of sals to include all other
9115 instances with the same symtab and line. */
9117 sal
.explicit_pc
= 1;
9119 struct linespec_sals lsal
;
9121 lsal
.canonical
= NULL
;
9123 canonical
->lsals
.push_back (std::move (lsal
));
9127 error (_("No default breakpoint address now."));
9131 /* Force almost all breakpoints to be in terms of the
9132 current_source_symtab (which is decode_line_1's default).
9133 This should produce the results we want almost all of the
9134 time while leaving default_breakpoint_* alone.
9136 ObjC: However, don't match an Objective-C method name which
9137 may have a '+' or '-' succeeded by a '['. */
9138 cursal
= get_current_source_symtab_and_line ();
9139 if (last_displayed_sal_is_valid ())
9141 const char *spec
= NULL
;
9143 if (event_location_type (location
) == LINESPEC_LOCATION
)
9144 spec
= get_linespec_location (location
)->spec_string
;
9148 && strchr ("+-", spec
[0]) != NULL
9151 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, NULL
,
9152 get_last_displayed_symtab (),
9153 get_last_displayed_line (),
9154 canonical
, NULL
, NULL
);
9159 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, NULL
,
9160 cursal
.symtab
, cursal
.line
, canonical
, NULL
, NULL
);
9164 /* Convert each SAL into a real PC. Verify that the PC can be
9165 inserted as a breakpoint. If it can't throw an error. */
9168 breakpoint_sals_to_pc (std::vector
<symtab_and_line
> &sals
)
9170 for (auto &sal
: sals
)
9171 resolve_sal_pc (&sal
);
9174 /* Fast tracepoints may have restrictions on valid locations. For
9175 instance, a fast tracepoint using a jump instead of a trap will
9176 likely have to overwrite more bytes than a trap would, and so can
9177 only be placed where the instruction is longer than the jump, or a
9178 multi-instruction sequence does not have a jump into the middle of
9182 check_fast_tracepoint_sals (struct gdbarch
*gdbarch
,
9183 gdb::array_view
<const symtab_and_line
> sals
)
9185 for (const auto &sal
: sals
)
9187 struct gdbarch
*sarch
;
9189 sarch
= get_sal_arch (sal
);
9190 /* We fall back to GDBARCH if there is no architecture
9191 associated with SAL. */
9195 if (!gdbarch_fast_tracepoint_valid_at (sarch
, sal
.pc
, &msg
))
9196 error (_("May not have a fast tracepoint at %s%s"),
9197 paddress (sarch
, sal
.pc
), msg
.c_str ());
9201 /* Given TOK, a string specification of condition and thread, as
9202 accepted by the 'break' command, extract the condition
9203 string and thread number and set *COND_STRING and *THREAD.
9204 PC identifies the context at which the condition should be parsed.
9205 If no condition is found, *COND_STRING is set to NULL.
9206 If no thread is found, *THREAD is set to -1. */
9209 find_condition_and_thread (const char *tok
, CORE_ADDR pc
,
9210 char **cond_string
, int *thread
, int *task
,
9213 *cond_string
= NULL
;
9221 const char *end_tok
;
9223 const char *cond_start
= NULL
;
9224 const char *cond_end
= NULL
;
9226 tok
= skip_spaces (tok
);
9228 if ((*tok
== '"' || *tok
== ',') && rest
)
9230 *rest
= savestring (tok
, strlen (tok
));
9234 end_tok
= skip_to_space (tok
);
9236 toklen
= end_tok
- tok
;
9238 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
9240 tok
= cond_start
= end_tok
+ 1;
9243 parse_exp_1 (&tok
, pc
, block_for_pc (pc
), 0);
9245 catch (const gdb_exception_error
&)
9250 tok
= tok
+ strlen (tok
);
9253 *cond_string
= savestring (cond_start
, cond_end
- cond_start
);
9255 else if (toklen
>= 1 && strncmp (tok
, "-force-condition", toklen
) == 0)
9260 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
9263 struct thread_info
*thr
;
9266 thr
= parse_thread_id (tok
, &tmptok
);
9268 error (_("Junk after thread keyword."));
9269 *thread
= thr
->global_num
;
9272 else if (toklen
>= 1 && strncmp (tok
, "task", toklen
) == 0)
9277 *task
= strtol (tok
, &tmptok
, 0);
9279 error (_("Junk after task keyword."));
9280 if (!valid_task_id (*task
))
9281 error (_("Unknown task %d."), *task
);
9286 *rest
= savestring (tok
, strlen (tok
));
9290 error (_("Junk at end of arguments."));
9294 /* Call 'find_condition_and_thread' for each sal in SALS until a parse
9295 succeeds. The parsed values are written to COND_STRING, THREAD,
9296 TASK, and REST. See the comment of 'find_condition_and_thread'
9297 for the description of these parameters and INPUT. */
9300 find_condition_and_thread_for_sals (const std::vector
<symtab_and_line
> &sals
,
9301 const char *input
, char **cond_string
,
9302 int *thread
, int *task
, char **rest
)
9304 int num_failures
= 0;
9305 for (auto &sal
: sals
)
9307 char *cond
= nullptr;
9310 char *remaining
= nullptr;
9312 /* Here we want to parse 'arg' to separate condition from thread
9313 number. But because parsing happens in a context and the
9314 contexts of sals might be different, try each until there is
9315 success. Finding one successful parse is sufficient for our
9316 goal. When setting the breakpoint we'll re-parse the
9317 condition in the context of each sal. */
9320 find_condition_and_thread (input
, sal
.pc
, &cond
, &thread_id
,
9321 &task_id
, &remaining
);
9322 *cond_string
= cond
;
9323 *thread
= thread_id
;
9328 catch (const gdb_exception_error
&e
)
9331 /* If no sal remains, do not continue. */
9332 if (num_failures
== sals
.size ())
9338 /* Decode a static tracepoint marker spec. */
9340 static std::vector
<symtab_and_line
>
9341 decode_static_tracepoint_spec (const char **arg_p
)
9343 const char *p
= &(*arg_p
)[3];
9346 p
= skip_spaces (p
);
9348 endp
= skip_to_space (p
);
9350 std::string
marker_str (p
, endp
- p
);
9352 std::vector
<static_tracepoint_marker
> markers
9353 = target_static_tracepoint_markers_by_strid (marker_str
.c_str ());
9354 if (markers
.empty ())
9355 error (_("No known static tracepoint marker named %s"),
9356 marker_str
.c_str ());
9358 std::vector
<symtab_and_line
> sals
;
9359 sals
.reserve (markers
.size ());
9361 for (const static_tracepoint_marker
&marker
: markers
)
9363 symtab_and_line sal
= find_pc_line (marker
.address
, 0);
9364 sal
.pc
= marker
.address
;
9365 sals
.push_back (sal
);
9372 /* Returns the breakpoint ops appropriate for use with with LOCATION_TYPE and
9373 according to IS_TRACEPOINT. */
9375 static const struct breakpoint_ops
*
9376 breakpoint_ops_for_event_location_type (enum event_location_type location_type
,
9381 if (location_type
== PROBE_LOCATION
)
9382 return &tracepoint_probe_breakpoint_ops
;
9384 return &tracepoint_breakpoint_ops
;
9388 if (location_type
== PROBE_LOCATION
)
9389 return &bkpt_probe_breakpoint_ops
;
9391 return &bkpt_breakpoint_ops
;
9395 /* See breakpoint.h. */
9397 const struct breakpoint_ops
*
9398 breakpoint_ops_for_event_location (const struct event_location
*location
,
9401 if (location
!= nullptr)
9402 return breakpoint_ops_for_event_location_type
9403 (event_location_type (location
), is_tracepoint
);
9404 return is_tracepoint
? &tracepoint_breakpoint_ops
: &bkpt_breakpoint_ops
;
9407 /* See breakpoint.h. */
9410 create_breakpoint (struct gdbarch
*gdbarch
,
9411 struct event_location
*location
,
9412 const char *cond_string
,
9413 int thread
, const char *extra_string
,
9414 bool force_condition
, int parse_extra
,
9415 int tempflag
, enum bptype type_wanted
,
9417 enum auto_boolean pending_break_support
,
9418 const struct breakpoint_ops
*ops
,
9419 int from_tty
, int enabled
, int internal
,
9422 struct linespec_result canonical
;
9425 int prev_bkpt_count
= breakpoint_count
;
9427 gdb_assert (ops
!= NULL
);
9429 /* If extra_string isn't useful, set it to NULL. */
9430 if (extra_string
!= NULL
&& *extra_string
== '\0')
9431 extra_string
= NULL
;
9435 ops
->create_sals_from_location (location
, &canonical
, type_wanted
);
9437 catch (const gdb_exception_error
&e
)
9439 /* If caller is interested in rc value from parse, set
9441 if (e
.error
== NOT_FOUND_ERROR
)
9443 /* If pending breakpoint support is turned off, throw
9446 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
9449 exception_print (gdb_stderr
, e
);
9451 /* If pending breakpoint support is auto query and the user
9452 selects no, then simply return the error code. */
9453 if (pending_break_support
== AUTO_BOOLEAN_AUTO
9454 && !nquery (_("Make %s pending on future shared library load? "),
9455 bptype_string (type_wanted
)))
9458 /* At this point, either the user was queried about setting
9459 a pending breakpoint and selected yes, or pending
9460 breakpoint behavior is on and thus a pending breakpoint
9461 is defaulted on behalf of the user. */
9468 if (!pending
&& canonical
.lsals
.empty ())
9471 /* Resolve all line numbers to PC's and verify that the addresses
9472 are ok for the target. */
9475 for (auto &lsal
: canonical
.lsals
)
9476 breakpoint_sals_to_pc (lsal
.sals
);
9479 /* Fast tracepoints may have additional restrictions on location. */
9480 if (!pending
&& type_wanted
== bp_fast_tracepoint
)
9482 for (const auto &lsal
: canonical
.lsals
)
9483 check_fast_tracepoint_sals (gdbarch
, lsal
.sals
);
9486 /* Verify that condition can be parsed, before setting any
9487 breakpoints. Allocate a separate condition expression for each
9491 gdb::unique_xmalloc_ptr
<char> cond_string_copy
;
9492 gdb::unique_xmalloc_ptr
<char> extra_string_copy
;
9499 const linespec_sals
&lsal
= canonical
.lsals
[0];
9501 find_condition_and_thread_for_sals (lsal
.sals
, extra_string
,
9502 &cond
, &thread
, &task
, &rest
);
9503 cond_string_copy
.reset (cond
);
9504 extra_string_copy
.reset (rest
);
9508 if (type_wanted
!= bp_dprintf
9509 && extra_string
!= NULL
&& *extra_string
!= '\0')
9510 error (_("Garbage '%s' at end of location"), extra_string
);
9512 /* Check the validity of the condition. We should error out
9513 if the condition is invalid at all of the locations and
9514 if it is not forced. In the PARSE_EXTRA case above, this
9515 check is done when parsing the EXTRA_STRING. */
9516 if (cond_string
!= nullptr && !force_condition
)
9518 int num_failures
= 0;
9519 const linespec_sals
&lsal
= canonical
.lsals
[0];
9520 for (const auto &sal
: lsal
.sals
)
9522 const char *cond
= cond_string
;
9525 parse_exp_1 (&cond
, sal
.pc
, block_for_pc (sal
.pc
), 0);
9526 /* One success is sufficient to keep going. */
9529 catch (const gdb_exception_error
&)
9532 /* If this is the last sal, error out. */
9533 if (num_failures
== lsal
.sals
.size ())
9539 /* Create a private copy of condition string. */
9541 cond_string_copy
.reset (xstrdup (cond_string
));
9542 /* Create a private copy of any extra string. */
9544 extra_string_copy
.reset (xstrdup (extra_string
));
9547 ops
->create_breakpoints_sal (gdbarch
, &canonical
,
9548 std::move (cond_string_copy
),
9549 std::move (extra_string_copy
),
9551 tempflag
? disp_del
: disp_donttouch
,
9552 thread
, task
, ignore_count
, ops
,
9553 from_tty
, enabled
, internal
, flags
);
9557 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (type_wanted
);
9559 init_raw_breakpoint_without_location (b
.get (), gdbarch
, type_wanted
, ops
);
9560 b
->location
= copy_event_location (location
);
9563 b
->cond_string
= NULL
;
9566 /* Create a private copy of condition string. */
9567 b
->cond_string
= cond_string
!= NULL
? xstrdup (cond_string
) : NULL
;
9571 /* Create a private copy of any extra string. */
9572 b
->extra_string
= extra_string
!= NULL
? xstrdup (extra_string
) : NULL
;
9573 b
->ignore_count
= ignore_count
;
9574 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
9575 b
->condition_not_parsed
= 1;
9576 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
9577 if ((type_wanted
!= bp_breakpoint
9578 && type_wanted
!= bp_hardware_breakpoint
) || thread
!= -1)
9579 b
->pspace
= current_program_space
;
9581 install_breakpoint (internal
, std::move (b
), 0);
9584 if (canonical
.lsals
.size () > 1)
9586 warning (_("Multiple breakpoints were set.\nUse the "
9587 "\"delete\" command to delete unwanted breakpoints."));
9588 prev_breakpoint_count
= prev_bkpt_count
;
9591 update_global_location_list (UGLL_MAY_INSERT
);
9596 /* Set a breakpoint.
9597 ARG is a string describing breakpoint address,
9598 condition, and thread.
9599 FLAG specifies if a breakpoint is hardware on,
9600 and if breakpoint is temporary, using BP_HARDWARE_FLAG
9604 break_command_1 (const char *arg
, int flag
, int from_tty
)
9606 int tempflag
= flag
& BP_TEMPFLAG
;
9607 enum bptype type_wanted
= (flag
& BP_HARDWAREFLAG
9608 ? bp_hardware_breakpoint
9611 event_location_up location
= string_to_event_location (&arg
, current_language
);
9612 const struct breakpoint_ops
*ops
= breakpoint_ops_for_event_location
9613 (location
.get (), false /* is_tracepoint */);
9615 create_breakpoint (get_current_arch (),
9617 NULL
, 0, arg
, false, 1 /* parse arg */,
9618 tempflag
, type_wanted
,
9619 0 /* Ignore count */,
9620 pending_break_support
,
9628 /* Helper function for break_command_1 and disassemble_command. */
9631 resolve_sal_pc (struct symtab_and_line
*sal
)
9635 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
9637 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
9638 error (_("No line %d in file \"%s\"."),
9639 sal
->line
, symtab_to_filename_for_display (sal
->symtab
));
9642 /* If this SAL corresponds to a breakpoint inserted using a line
9643 number, then skip the function prologue if necessary. */
9644 if (sal
->explicit_line
)
9645 skip_prologue_sal (sal
);
9648 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
9650 const struct blockvector
*bv
;
9651 const struct block
*b
;
9654 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
,
9655 SYMTAB_COMPUNIT (sal
->symtab
));
9658 sym
= block_linkage_function (b
);
9661 fixup_symbol_section (sym
, SYMTAB_OBJFILE (sal
->symtab
));
9662 sal
->section
= sym
->obj_section (SYMTAB_OBJFILE (sal
->symtab
));
9666 /* It really is worthwhile to have the section, so we'll
9667 just have to look harder. This case can be executed
9668 if we have line numbers but no functions (as can
9669 happen in assembly source). */
9671 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
9672 switch_to_program_space_and_thread (sal
->pspace
);
9674 bound_minimal_symbol msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
9676 sal
->section
= msym
.obj_section ();
9683 break_command (const char *arg
, int from_tty
)
9685 break_command_1 (arg
, 0, from_tty
);
9689 tbreak_command (const char *arg
, int from_tty
)
9691 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
9695 hbreak_command (const char *arg
, int from_tty
)
9697 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
9701 thbreak_command (const char *arg
, int from_tty
)
9703 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
9707 stop_command (const char *arg
, int from_tty
)
9709 printf_filtered (_("Specify the type of breakpoint to set.\n\
9710 Usage: stop in <function | address>\n\
9711 stop at <line>\n"));
9715 stopin_command (const char *arg
, int from_tty
)
9721 else if (*arg
!= '*')
9723 const char *argptr
= arg
;
9726 /* Look for a ':'. If this is a line number specification, then
9727 say it is bad, otherwise, it should be an address or
9728 function/method name. */
9729 while (*argptr
&& !hasColon
)
9731 hasColon
= (*argptr
== ':');
9736 badInput
= (*argptr
!= ':'); /* Not a class::method */
9738 badInput
= isdigit (*arg
); /* a simple line number */
9742 printf_filtered (_("Usage: stop in <function | address>\n"));
9744 break_command_1 (arg
, 0, from_tty
);
9748 stopat_command (const char *arg
, int from_tty
)
9752 if (arg
== NULL
|| *arg
== '*') /* no line number */
9756 const char *argptr
= arg
;
9759 /* Look for a ':'. If there is a '::' then get out, otherwise
9760 it is probably a line number. */
9761 while (*argptr
&& !hasColon
)
9763 hasColon
= (*argptr
== ':');
9768 badInput
= (*argptr
== ':'); /* we have class::method */
9770 badInput
= !isdigit (*arg
); /* not a line number */
9774 printf_filtered (_("Usage: stop at LINE\n"));
9776 break_command_1 (arg
, 0, from_tty
);
9779 /* The dynamic printf command is mostly like a regular breakpoint, but
9780 with a prewired command list consisting of a single output command,
9781 built from extra arguments supplied on the dprintf command
9785 dprintf_command (const char *arg
, int from_tty
)
9787 event_location_up location
= string_to_event_location (&arg
, current_language
);
9789 /* If non-NULL, ARG should have been advanced past the location;
9790 the next character must be ','. */
9793 if (arg
[0] != ',' || arg
[1] == '\0')
9794 error (_("Format string required"));
9797 /* Skip the comma. */
9802 create_breakpoint (get_current_arch (),
9804 NULL
, 0, arg
, false, 1 /* parse arg */,
9806 0 /* Ignore count */,
9807 pending_break_support
,
9808 &dprintf_breakpoint_ops
,
9816 agent_printf_command (const char *arg
, int from_tty
)
9818 error (_("May only run agent-printf on the target"));
9821 /* Implement the "breakpoint_hit" breakpoint_ops method for
9822 ranged breakpoints. */
9825 breakpoint_hit_ranged_breakpoint (const struct bp_location
*bl
,
9826 const address_space
*aspace
,
9828 const struct target_waitstatus
*ws
)
9830 if (ws
->kind
!= TARGET_WAITKIND_STOPPED
9831 || ws
->value
.sig
!= GDB_SIGNAL_TRAP
)
9834 return breakpoint_address_match_range (bl
->pspace
->aspace
, bl
->address
,
9835 bl
->length
, aspace
, bp_addr
);
9838 /* Implement the "resources_needed" breakpoint_ops method for
9839 ranged breakpoints. */
9842 resources_needed_ranged_breakpoint (const struct bp_location
*bl
)
9844 return target_ranged_break_num_registers ();
9847 /* Implement the "print_it" breakpoint_ops method for
9848 ranged breakpoints. */
9850 static enum print_stop_action
9851 print_it_ranged_breakpoint (bpstat bs
)
9853 struct breakpoint
*b
= bs
->breakpoint_at
;
9854 struct bp_location
*bl
= b
->loc
;
9855 struct ui_out
*uiout
= current_uiout
;
9857 gdb_assert (b
->type
== bp_hardware_breakpoint
);
9859 /* Ranged breakpoints have only one location. */
9860 gdb_assert (bl
&& bl
->next
== NULL
);
9862 annotate_breakpoint (b
->number
);
9864 maybe_print_thread_hit_breakpoint (uiout
);
9866 if (b
->disposition
== disp_del
)
9867 uiout
->text ("Temporary ranged breakpoint ");
9869 uiout
->text ("Ranged breakpoint ");
9870 if (uiout
->is_mi_like_p ())
9872 uiout
->field_string ("reason",
9873 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
9874 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
9876 uiout
->field_signed ("bkptno", b
->number
);
9879 return PRINT_SRC_AND_LOC
;
9882 /* Implement the "print_one" breakpoint_ops method for
9883 ranged breakpoints. */
9886 print_one_ranged_breakpoint (struct breakpoint
*b
,
9887 struct bp_location
**last_loc
)
9889 struct bp_location
*bl
= b
->loc
;
9890 struct value_print_options opts
;
9891 struct ui_out
*uiout
= current_uiout
;
9893 /* Ranged breakpoints have only one location. */
9894 gdb_assert (bl
&& bl
->next
== NULL
);
9896 get_user_print_options (&opts
);
9898 if (opts
.addressprint
)
9899 /* We don't print the address range here, it will be printed later
9900 by print_one_detail_ranged_breakpoint. */
9901 uiout
->field_skip ("addr");
9903 print_breakpoint_location (b
, bl
);
9907 /* Implement the "print_one_detail" breakpoint_ops method for
9908 ranged breakpoints. */
9911 print_one_detail_ranged_breakpoint (const struct breakpoint
*b
,
9912 struct ui_out
*uiout
)
9914 CORE_ADDR address_start
, address_end
;
9915 struct bp_location
*bl
= b
->loc
;
9920 address_start
= bl
->address
;
9921 address_end
= address_start
+ bl
->length
- 1;
9923 uiout
->text ("\taddress range: ");
9924 stb
.printf ("[%s, %s]",
9925 print_core_address (bl
->gdbarch
, address_start
),
9926 print_core_address (bl
->gdbarch
, address_end
));
9927 uiout
->field_stream ("addr", stb
);
9931 /* Implement the "print_mention" breakpoint_ops method for
9932 ranged breakpoints. */
9935 print_mention_ranged_breakpoint (struct breakpoint
*b
)
9937 struct bp_location
*bl
= b
->loc
;
9938 struct ui_out
*uiout
= current_uiout
;
9941 gdb_assert (b
->type
== bp_hardware_breakpoint
);
9943 uiout
->message (_("Hardware assisted ranged breakpoint %d from %s to %s."),
9944 b
->number
, paddress (bl
->gdbarch
, bl
->address
),
9945 paddress (bl
->gdbarch
, bl
->address
+ bl
->length
- 1));
9948 /* Implement the "print_recreate" breakpoint_ops method for
9949 ranged breakpoints. */
9952 print_recreate_ranged_breakpoint (struct breakpoint
*b
, struct ui_file
*fp
)
9954 fprintf_unfiltered (fp
, "break-range %s, %s",
9955 event_location_to_string (b
->location
.get ()),
9956 event_location_to_string (b
->location_range_end
.get ()));
9957 print_recreate_thread (b
, fp
);
9960 /* The breakpoint_ops structure to be used in ranged breakpoints. */
9962 static struct breakpoint_ops ranged_breakpoint_ops
;
9964 /* Find the address where the end of the breakpoint range should be
9965 placed, given the SAL of the end of the range. This is so that if
9966 the user provides a line number, the end of the range is set to the
9967 last instruction of the given line. */
9970 find_breakpoint_range_end (struct symtab_and_line sal
)
9974 /* If the user provided a PC value, use it. Otherwise,
9975 find the address of the end of the given location. */
9976 if (sal
.explicit_pc
)
9983 ret
= find_line_pc_range (sal
, &start
, &end
);
9985 error (_("Could not find location of the end of the range."));
9987 /* find_line_pc_range returns the start of the next line. */
9994 /* Implement the "break-range" CLI command. */
9997 break_range_command (const char *arg
, int from_tty
)
9999 const char *arg_start
;
10000 struct linespec_result canonical_start
, canonical_end
;
10001 int bp_count
, can_use_bp
, length
;
10003 struct breakpoint
*b
;
10005 /* We don't support software ranged breakpoints. */
10006 if (target_ranged_break_num_registers () < 0)
10007 error (_("This target does not support hardware ranged breakpoints."));
10009 bp_count
= hw_breakpoint_used_count ();
10010 bp_count
+= target_ranged_break_num_registers ();
10011 can_use_bp
= target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
10013 if (can_use_bp
< 0)
10014 error (_("Hardware breakpoints used exceeds limit."));
10016 arg
= skip_spaces (arg
);
10017 if (arg
== NULL
|| arg
[0] == '\0')
10018 error(_("No address range specified."));
10021 event_location_up start_location
= string_to_event_location (&arg
,
10023 parse_breakpoint_sals (start_location
.get (), &canonical_start
);
10026 error (_("Too few arguments."));
10027 else if (canonical_start
.lsals
.empty ())
10028 error (_("Could not find location of the beginning of the range."));
10030 const linespec_sals
&lsal_start
= canonical_start
.lsals
[0];
10032 if (canonical_start
.lsals
.size () > 1
10033 || lsal_start
.sals
.size () != 1)
10034 error (_("Cannot create a ranged breakpoint with multiple locations."));
10036 const symtab_and_line
&sal_start
= lsal_start
.sals
[0];
10037 std::string
addr_string_start (arg_start
, arg
- arg_start
);
10039 arg
++; /* Skip the comma. */
10040 arg
= skip_spaces (arg
);
10042 /* Parse the end location. */
10046 /* We call decode_line_full directly here instead of using
10047 parse_breakpoint_sals because we need to specify the start location's
10048 symtab and line as the default symtab and line for the end of the
10049 range. This makes it possible to have ranges like "foo.c:27, +14",
10050 where +14 means 14 lines from the start location. */
10051 event_location_up end_location
= string_to_event_location (&arg
,
10053 decode_line_full (end_location
.get (), DECODE_LINE_FUNFIRSTLINE
, NULL
,
10054 sal_start
.symtab
, sal_start
.line
,
10055 &canonical_end
, NULL
, NULL
);
10057 if (canonical_end
.lsals
.empty ())
10058 error (_("Could not find location of the end of the range."));
10060 const linespec_sals
&lsal_end
= canonical_end
.lsals
[0];
10061 if (canonical_end
.lsals
.size () > 1
10062 || lsal_end
.sals
.size () != 1)
10063 error (_("Cannot create a ranged breakpoint with multiple locations."));
10065 const symtab_and_line
&sal_end
= lsal_end
.sals
[0];
10067 end
= find_breakpoint_range_end (sal_end
);
10068 if (sal_start
.pc
> end
)
10069 error (_("Invalid address range, end precedes start."));
10071 length
= end
- sal_start
.pc
+ 1;
10073 /* Length overflowed. */
10074 error (_("Address range too large."));
10075 else if (length
== 1)
10077 /* This range is simple enough to be handled by
10078 the `hbreak' command. */
10079 hbreak_command (&addr_string_start
[0], 1);
10084 /* Now set up the breakpoint. */
10085 b
= set_raw_breakpoint (get_current_arch (), sal_start
,
10086 bp_hardware_breakpoint
, &ranged_breakpoint_ops
);
10087 set_breakpoint_count (breakpoint_count
+ 1);
10088 b
->number
= breakpoint_count
;
10089 b
->disposition
= disp_donttouch
;
10090 b
->location
= std::move (start_location
);
10091 b
->location_range_end
= std::move (end_location
);
10092 b
->loc
->length
= length
;
10095 gdb::observers::breakpoint_created
.notify (b
);
10096 update_global_location_list (UGLL_MAY_INSERT
);
10099 /* Return non-zero if EXP is verified as constant. Returned zero
10100 means EXP is variable. Also the constant detection may fail for
10101 some constant expressions and in such case still falsely return
10105 watchpoint_exp_is_const (const struct expression
*exp
)
10107 return exp
->op
->constant_p ();
10110 /* Watchpoint destructor. */
10112 watchpoint::~watchpoint ()
10114 xfree (this->exp_string
);
10115 xfree (this->exp_string_reparse
);
10118 /* Implement the "re_set" breakpoint_ops method for watchpoints. */
10121 re_set_watchpoint (struct breakpoint
*b
)
10123 struct watchpoint
*w
= (struct watchpoint
*) b
;
10125 /* Watchpoint can be either on expression using entirely global
10126 variables, or it can be on local variables.
10128 Watchpoints of the first kind are never auto-deleted, and even
10129 persist across program restarts. Since they can use variables
10130 from shared libraries, we need to reparse expression as libraries
10131 are loaded and unloaded.
10133 Watchpoints on local variables can also change meaning as result
10134 of solib event. For example, if a watchpoint uses both a local
10135 and a global variables in expression, it's a local watchpoint,
10136 but unloading of a shared library will make the expression
10137 invalid. This is not a very common use case, but we still
10138 re-evaluate expression, to avoid surprises to the user.
10140 Note that for local watchpoints, we re-evaluate it only if
10141 watchpoints frame id is still valid. If it's not, it means the
10142 watchpoint is out of scope and will be deleted soon. In fact,
10143 I'm not sure we'll ever be called in this case.
10145 If a local watchpoint's frame id is still valid, then
10146 w->exp_valid_block is likewise valid, and we can safely use it.
10148 Don't do anything about disabled watchpoints, since they will be
10149 reevaluated again when enabled. */
10150 update_watchpoint (w
, 1 /* reparse */);
10153 /* Implement the "insert" breakpoint_ops method for hardware watchpoints. */
10156 insert_watchpoint (struct bp_location
*bl
)
10158 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10159 int length
= w
->exact
? 1 : bl
->length
;
10161 return target_insert_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
10162 w
->cond_exp
.get ());
10165 /* Implement the "remove" breakpoint_ops method for hardware watchpoints. */
10168 remove_watchpoint (struct bp_location
*bl
, enum remove_bp_reason reason
)
10170 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10171 int length
= w
->exact
? 1 : bl
->length
;
10173 return target_remove_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
10174 w
->cond_exp
.get ());
10178 breakpoint_hit_watchpoint (const struct bp_location
*bl
,
10179 const address_space
*aspace
, CORE_ADDR bp_addr
,
10180 const struct target_waitstatus
*ws
)
10182 struct breakpoint
*b
= bl
->owner
;
10183 struct watchpoint
*w
= (struct watchpoint
*) b
;
10185 /* Continuable hardware watchpoints are treated as non-existent if the
10186 reason we stopped wasn't a hardware watchpoint (we didn't stop on
10187 some data address). Otherwise gdb won't stop on a break instruction
10188 in the code (not from a breakpoint) when a hardware watchpoint has
10189 been defined. Also skip watchpoints which we know did not trigger
10190 (did not match the data address). */
10191 if (is_hardware_watchpoint (b
)
10192 && w
->watchpoint_triggered
== watch_triggered_no
)
10199 check_status_watchpoint (bpstat bs
)
10201 gdb_assert (is_watchpoint (bs
->breakpoint_at
));
10203 bpstat_check_watchpoint (bs
);
10206 /* Implement the "resources_needed" breakpoint_ops method for
10207 hardware watchpoints. */
10210 resources_needed_watchpoint (const struct bp_location
*bl
)
10212 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10213 int length
= w
->exact
? 1 : bl
->length
;
10215 return target_region_ok_for_hw_watchpoint (bl
->address
, length
);
10218 /* Implement the "works_in_software_mode" breakpoint_ops method for
10219 hardware watchpoints. */
10222 works_in_software_mode_watchpoint (const struct breakpoint
*b
)
10224 /* Read and access watchpoints only work with hardware support. */
10225 return b
->type
== bp_watchpoint
|| b
->type
== bp_hardware_watchpoint
;
10228 static enum print_stop_action
10229 print_it_watchpoint (bpstat bs
)
10231 struct breakpoint
*b
;
10232 enum print_stop_action result
;
10233 struct watchpoint
*w
;
10234 struct ui_out
*uiout
= current_uiout
;
10236 gdb_assert (bs
->bp_location_at
!= NULL
);
10238 b
= bs
->breakpoint_at
;
10239 w
= (struct watchpoint
*) b
;
10241 annotate_watchpoint (b
->number
);
10242 maybe_print_thread_hit_breakpoint (uiout
);
10246 gdb::optional
<ui_out_emit_tuple
> tuple_emitter
;
10249 case bp_watchpoint
:
10250 case bp_hardware_watchpoint
:
10251 if (uiout
->is_mi_like_p ())
10252 uiout
->field_string
10253 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
10255 tuple_emitter
.emplace (uiout
, "value");
10256 uiout
->text ("\nOld value = ");
10257 watchpoint_value_print (bs
->old_val
.get (), &stb
);
10258 uiout
->field_stream ("old", stb
);
10259 uiout
->text ("\nNew value = ");
10260 watchpoint_value_print (w
->val
.get (), &stb
);
10261 uiout
->field_stream ("new", stb
);
10262 uiout
->text ("\n");
10263 /* More than one watchpoint may have been triggered. */
10264 result
= PRINT_UNKNOWN
;
10267 case bp_read_watchpoint
:
10268 if (uiout
->is_mi_like_p ())
10269 uiout
->field_string
10270 ("reason", async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
10272 tuple_emitter
.emplace (uiout
, "value");
10273 uiout
->text ("\nValue = ");
10274 watchpoint_value_print (w
->val
.get (), &stb
);
10275 uiout
->field_stream ("value", stb
);
10276 uiout
->text ("\n");
10277 result
= PRINT_UNKNOWN
;
10280 case bp_access_watchpoint
:
10281 if (bs
->old_val
!= NULL
)
10283 if (uiout
->is_mi_like_p ())
10284 uiout
->field_string
10286 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
10288 tuple_emitter
.emplace (uiout
, "value");
10289 uiout
->text ("\nOld value = ");
10290 watchpoint_value_print (bs
->old_val
.get (), &stb
);
10291 uiout
->field_stream ("old", stb
);
10292 uiout
->text ("\nNew value = ");
10297 if (uiout
->is_mi_like_p ())
10298 uiout
->field_string
10300 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
10301 tuple_emitter
.emplace (uiout
, "value");
10302 uiout
->text ("\nValue = ");
10304 watchpoint_value_print (w
->val
.get (), &stb
);
10305 uiout
->field_stream ("new", stb
);
10306 uiout
->text ("\n");
10307 result
= PRINT_UNKNOWN
;
10310 result
= PRINT_UNKNOWN
;
10316 /* Implement the "print_mention" breakpoint_ops method for hardware
10320 print_mention_watchpoint (struct breakpoint
*b
)
10322 struct watchpoint
*w
= (struct watchpoint
*) b
;
10323 struct ui_out
*uiout
= current_uiout
;
10324 const char *tuple_name
;
10328 case bp_watchpoint
:
10329 uiout
->text ("Watchpoint ");
10330 tuple_name
= "wpt";
10332 case bp_hardware_watchpoint
:
10333 uiout
->text ("Hardware watchpoint ");
10334 tuple_name
= "wpt";
10336 case bp_read_watchpoint
:
10337 uiout
->text ("Hardware read watchpoint ");
10338 tuple_name
= "hw-rwpt";
10340 case bp_access_watchpoint
:
10341 uiout
->text ("Hardware access (read/write) watchpoint ");
10342 tuple_name
= "hw-awpt";
10345 internal_error (__FILE__
, __LINE__
,
10346 _("Invalid hardware watchpoint type."));
10349 ui_out_emit_tuple
tuple_emitter (uiout
, tuple_name
);
10350 uiout
->field_signed ("number", b
->number
);
10351 uiout
->text (": ");
10352 uiout
->field_string ("exp", w
->exp_string
);
10355 /* Implement the "print_recreate" breakpoint_ops method for
10359 print_recreate_watchpoint (struct breakpoint
*b
, struct ui_file
*fp
)
10361 struct watchpoint
*w
= (struct watchpoint
*) b
;
10365 case bp_watchpoint
:
10366 case bp_hardware_watchpoint
:
10367 fprintf_unfiltered (fp
, "watch");
10369 case bp_read_watchpoint
:
10370 fprintf_unfiltered (fp
, "rwatch");
10372 case bp_access_watchpoint
:
10373 fprintf_unfiltered (fp
, "awatch");
10376 internal_error (__FILE__
, __LINE__
,
10377 _("Invalid watchpoint type."));
10380 fprintf_unfiltered (fp
, " %s", w
->exp_string
);
10381 print_recreate_thread (b
, fp
);
10384 /* Implement the "explains_signal" breakpoint_ops method for
10388 explains_signal_watchpoint (struct breakpoint
*b
, enum gdb_signal sig
)
10390 /* A software watchpoint cannot cause a signal other than
10391 GDB_SIGNAL_TRAP. */
10392 if (b
->type
== bp_watchpoint
&& sig
!= GDB_SIGNAL_TRAP
)
10398 /* The breakpoint_ops structure to be used in hardware watchpoints. */
10400 static struct breakpoint_ops watchpoint_breakpoint_ops
;
10402 /* Implement the "insert" breakpoint_ops method for
10403 masked hardware watchpoints. */
10406 insert_masked_watchpoint (struct bp_location
*bl
)
10408 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10410 return target_insert_mask_watchpoint (bl
->address
, w
->hw_wp_mask
,
10411 bl
->watchpoint_type
);
10414 /* Implement the "remove" breakpoint_ops method for
10415 masked hardware watchpoints. */
10418 remove_masked_watchpoint (struct bp_location
*bl
, enum remove_bp_reason reason
)
10420 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10422 return target_remove_mask_watchpoint (bl
->address
, w
->hw_wp_mask
,
10423 bl
->watchpoint_type
);
10426 /* Implement the "resources_needed" breakpoint_ops method for
10427 masked hardware watchpoints. */
10430 resources_needed_masked_watchpoint (const struct bp_location
*bl
)
10432 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10434 return target_masked_watch_num_registers (bl
->address
, w
->hw_wp_mask
);
10437 /* Implement the "works_in_software_mode" breakpoint_ops method for
10438 masked hardware watchpoints. */
10441 works_in_software_mode_masked_watchpoint (const struct breakpoint
*b
)
10446 /* Implement the "print_it" breakpoint_ops method for
10447 masked hardware watchpoints. */
10449 static enum print_stop_action
10450 print_it_masked_watchpoint (bpstat bs
)
10452 struct breakpoint
*b
= bs
->breakpoint_at
;
10453 struct ui_out
*uiout
= current_uiout
;
10455 /* Masked watchpoints have only one location. */
10456 gdb_assert (b
->loc
&& b
->loc
->next
== NULL
);
10458 annotate_watchpoint (b
->number
);
10459 maybe_print_thread_hit_breakpoint (uiout
);
10463 case bp_hardware_watchpoint
:
10464 if (uiout
->is_mi_like_p ())
10465 uiout
->field_string
10466 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
10469 case bp_read_watchpoint
:
10470 if (uiout
->is_mi_like_p ())
10471 uiout
->field_string
10472 ("reason", async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
10475 case bp_access_watchpoint
:
10476 if (uiout
->is_mi_like_p ())
10477 uiout
->field_string
10479 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
10482 internal_error (__FILE__
, __LINE__
,
10483 _("Invalid hardware watchpoint type."));
10487 uiout
->text (_("\n\
10488 Check the underlying instruction at PC for the memory\n\
10489 address and value which triggered this watchpoint.\n"));
10490 uiout
->text ("\n");
10492 /* More than one watchpoint may have been triggered. */
10493 return PRINT_UNKNOWN
;
10496 /* Implement the "print_one_detail" breakpoint_ops method for
10497 masked hardware watchpoints. */
10500 print_one_detail_masked_watchpoint (const struct breakpoint
*b
,
10501 struct ui_out
*uiout
)
10503 struct watchpoint
*w
= (struct watchpoint
*) b
;
10505 /* Masked watchpoints have only one location. */
10506 gdb_assert (b
->loc
&& b
->loc
->next
== NULL
);
10508 uiout
->text ("\tmask ");
10509 uiout
->field_core_addr ("mask", b
->loc
->gdbarch
, w
->hw_wp_mask
);
10510 uiout
->text ("\n");
10513 /* Implement the "print_mention" breakpoint_ops method for
10514 masked hardware watchpoints. */
10517 print_mention_masked_watchpoint (struct breakpoint
*b
)
10519 struct watchpoint
*w
= (struct watchpoint
*) b
;
10520 struct ui_out
*uiout
= current_uiout
;
10521 const char *tuple_name
;
10525 case bp_hardware_watchpoint
:
10526 uiout
->text ("Masked hardware watchpoint ");
10527 tuple_name
= "wpt";
10529 case bp_read_watchpoint
:
10530 uiout
->text ("Masked hardware read watchpoint ");
10531 tuple_name
= "hw-rwpt";
10533 case bp_access_watchpoint
:
10534 uiout
->text ("Masked hardware access (read/write) watchpoint ");
10535 tuple_name
= "hw-awpt";
10538 internal_error (__FILE__
, __LINE__
,
10539 _("Invalid hardware watchpoint type."));
10542 ui_out_emit_tuple
tuple_emitter (uiout
, tuple_name
);
10543 uiout
->field_signed ("number", b
->number
);
10544 uiout
->text (": ");
10545 uiout
->field_string ("exp", w
->exp_string
);
10548 /* Implement the "print_recreate" breakpoint_ops method for
10549 masked hardware watchpoints. */
10552 print_recreate_masked_watchpoint (struct breakpoint
*b
, struct ui_file
*fp
)
10554 struct watchpoint
*w
= (struct watchpoint
*) b
;
10558 case bp_hardware_watchpoint
:
10559 fprintf_unfiltered (fp
, "watch");
10561 case bp_read_watchpoint
:
10562 fprintf_unfiltered (fp
, "rwatch");
10564 case bp_access_watchpoint
:
10565 fprintf_unfiltered (fp
, "awatch");
10568 internal_error (__FILE__
, __LINE__
,
10569 _("Invalid hardware watchpoint type."));
10572 fprintf_unfiltered (fp
, " %s mask 0x%s", w
->exp_string
,
10573 phex (w
->hw_wp_mask
, sizeof (CORE_ADDR
)));
10574 print_recreate_thread (b
, fp
);
10577 /* The breakpoint_ops structure to be used in masked hardware watchpoints. */
10579 static struct breakpoint_ops masked_watchpoint_breakpoint_ops
;
10581 /* Tell whether the given watchpoint is a masked hardware watchpoint. */
10584 is_masked_watchpoint (const struct breakpoint
*b
)
10586 return b
->ops
== &masked_watchpoint_breakpoint_ops
;
10589 /* accessflag: hw_write: watch write,
10590 hw_read: watch read,
10591 hw_access: watch access (read or write) */
10593 watch_command_1 (const char *arg
, int accessflag
, int from_tty
,
10594 bool just_location
, bool internal
)
10596 struct breakpoint
*scope_breakpoint
= NULL
;
10597 const struct block
*exp_valid_block
= NULL
, *cond_exp_valid_block
= NULL
;
10598 struct value
*result
;
10599 int saved_bitpos
= 0, saved_bitsize
= 0;
10600 const char *exp_start
= NULL
;
10601 const char *exp_end
= NULL
;
10602 const char *tok
, *end_tok
;
10604 const char *cond_start
= NULL
;
10605 const char *cond_end
= NULL
;
10606 enum bptype bp_type
;
10608 /* Flag to indicate whether we are going to use masks for
10609 the hardware watchpoint. */
10610 bool use_mask
= false;
10611 CORE_ADDR mask
= 0;
10613 /* Make sure that we actually have parameters to parse. */
10614 if (arg
!= NULL
&& arg
[0] != '\0')
10616 const char *value_start
;
10618 exp_end
= arg
+ strlen (arg
);
10620 /* Look for "parameter value" pairs at the end
10621 of the arguments string. */
10622 for (tok
= exp_end
- 1; tok
> arg
; tok
--)
10624 /* Skip whitespace at the end of the argument list. */
10625 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
10628 /* Find the beginning of the last token.
10629 This is the value of the parameter. */
10630 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
10632 value_start
= tok
+ 1;
10634 /* Skip whitespace. */
10635 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
10640 /* Find the beginning of the second to last token.
10641 This is the parameter itself. */
10642 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
10645 toklen
= end_tok
- tok
+ 1;
10647 if (toklen
== 6 && startswith (tok
, "thread"))
10649 struct thread_info
*thr
;
10650 /* At this point we've found a "thread" token, which means
10651 the user is trying to set a watchpoint that triggers
10652 only in a specific thread. */
10656 error(_("You can specify only one thread."));
10658 /* Extract the thread ID from the next token. */
10659 thr
= parse_thread_id (value_start
, &endp
);
10661 /* Check if the user provided a valid thread ID. */
10662 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
10663 invalid_thread_id_error (value_start
);
10665 thread
= thr
->global_num
;
10667 else if (toklen
== 4 && startswith (tok
, "mask"))
10669 /* We've found a "mask" token, which means the user wants to
10670 create a hardware watchpoint that is going to have the mask
10672 struct value
*mask_value
, *mark
;
10675 error(_("You can specify only one mask."));
10677 use_mask
= just_location
= true;
10679 mark
= value_mark ();
10680 mask_value
= parse_to_comma_and_eval (&value_start
);
10681 mask
= value_as_address (mask_value
);
10682 value_free_to_mark (mark
);
10685 /* We didn't recognize what we found. We should stop here. */
10688 /* Truncate the string and get rid of the "parameter value" pair before
10689 the arguments string is parsed by the parse_exp_1 function. */
10696 /* Parse the rest of the arguments. From here on out, everything
10697 is in terms of a newly allocated string instead of the original
10699 std::string
expression (arg
, exp_end
- arg
);
10700 exp_start
= arg
= expression
.c_str ();
10701 innermost_block_tracker tracker
;
10702 expression_up exp
= parse_exp_1 (&arg
, 0, 0, 0, &tracker
);
10704 /* Remove trailing whitespace from the expression before saving it.
10705 This makes the eventual display of the expression string a bit
10707 while (exp_end
> exp_start
&& (exp_end
[-1] == ' ' || exp_end
[-1] == '\t'))
10710 /* Checking if the expression is not constant. */
10711 if (watchpoint_exp_is_const (exp
.get ()))
10715 len
= exp_end
- exp_start
;
10716 while (len
> 0 && isspace (exp_start
[len
- 1]))
10718 error (_("Cannot watch constant value `%.*s'."), len
, exp_start
);
10721 exp_valid_block
= tracker
.block ();
10722 struct value
*mark
= value_mark ();
10723 struct value
*val_as_value
= nullptr;
10724 fetch_subexp_value (exp
.get (), exp
->op
.get (), &val_as_value
, &result
, NULL
,
10727 if (val_as_value
!= NULL
&& just_location
)
10729 saved_bitpos
= value_bitpos (val_as_value
);
10730 saved_bitsize
= value_bitsize (val_as_value
);
10738 exp_valid_block
= NULL
;
10739 val
= release_value (value_addr (result
));
10740 value_free_to_mark (mark
);
10744 ret
= target_masked_watch_num_registers (value_as_address (val
.get ()),
10747 error (_("This target does not support masked watchpoints."));
10748 else if (ret
== -2)
10749 error (_("Invalid mask or memory region."));
10752 else if (val_as_value
!= NULL
)
10753 val
= release_value (val_as_value
);
10755 tok
= skip_spaces (arg
);
10756 end_tok
= skip_to_space (tok
);
10758 toklen
= end_tok
- tok
;
10759 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
10761 tok
= cond_start
= end_tok
+ 1;
10762 innermost_block_tracker if_tracker
;
10763 parse_exp_1 (&tok
, 0, 0, 0, &if_tracker
);
10765 /* The watchpoint expression may not be local, but the condition
10766 may still be. E.g.: `watch global if local > 0'. */
10767 cond_exp_valid_block
= if_tracker
.block ();
10772 error (_("Junk at end of command."));
10774 frame_info
*wp_frame
= block_innermost_frame (exp_valid_block
);
10776 /* Save this because create_internal_breakpoint below invalidates
10778 frame_id watchpoint_frame
= get_frame_id (wp_frame
);
10780 /* If the expression is "local", then set up a "watchpoint scope"
10781 breakpoint at the point where we've left the scope of the watchpoint
10782 expression. Create the scope breakpoint before the watchpoint, so
10783 that we will encounter it first in bpstat_stop_status. */
10784 if (exp_valid_block
!= NULL
&& wp_frame
!= NULL
)
10786 frame_id caller_frame_id
= frame_unwind_caller_id (wp_frame
);
10788 if (frame_id_p (caller_frame_id
))
10790 gdbarch
*caller_arch
= frame_unwind_caller_arch (wp_frame
);
10791 CORE_ADDR caller_pc
= frame_unwind_caller_pc (wp_frame
);
10794 = create_internal_breakpoint (caller_arch
, caller_pc
,
10795 bp_watchpoint_scope
,
10796 &momentary_breakpoint_ops
);
10798 /* create_internal_breakpoint could invalidate WP_FRAME. */
10801 scope_breakpoint
->enable_state
= bp_enabled
;
10803 /* Automatically delete the breakpoint when it hits. */
10804 scope_breakpoint
->disposition
= disp_del
;
10806 /* Only break in the proper frame (help with recursion). */
10807 scope_breakpoint
->frame_id
= caller_frame_id
;
10809 /* Set the address at which we will stop. */
10810 scope_breakpoint
->loc
->gdbarch
= caller_arch
;
10811 scope_breakpoint
->loc
->requested_address
= caller_pc
;
10812 scope_breakpoint
->loc
->address
10813 = adjust_breakpoint_address (scope_breakpoint
->loc
->gdbarch
,
10814 scope_breakpoint
->loc
->requested_address
,
10815 scope_breakpoint
->type
);
10819 /* Now set up the breakpoint. We create all watchpoints as hardware
10820 watchpoints here even if hardware watchpoints are turned off, a call
10821 to update_watchpoint later in this function will cause the type to
10822 drop back to bp_watchpoint (software watchpoint) if required. */
10824 if (accessflag
== hw_read
)
10825 bp_type
= bp_read_watchpoint
;
10826 else if (accessflag
== hw_access
)
10827 bp_type
= bp_access_watchpoint
;
10829 bp_type
= bp_hardware_watchpoint
;
10831 std::unique_ptr
<watchpoint
> w (new watchpoint ());
10834 init_raw_breakpoint_without_location (w
.get (), NULL
, bp_type
,
10835 &masked_watchpoint_breakpoint_ops
);
10837 init_raw_breakpoint_without_location (w
.get (), NULL
, bp_type
,
10838 &watchpoint_breakpoint_ops
);
10839 w
->thread
= thread
;
10840 w
->disposition
= disp_donttouch
;
10841 w
->pspace
= current_program_space
;
10842 w
->exp
= std::move (exp
);
10843 w
->exp_valid_block
= exp_valid_block
;
10844 w
->cond_exp_valid_block
= cond_exp_valid_block
;
10847 struct type
*t
= value_type (val
.get ());
10848 CORE_ADDR addr
= value_as_address (val
.get ());
10850 w
->exp_string_reparse
10851 = current_language
->watch_location_expression (t
, addr
).release ();
10853 w
->exp_string
= xstrprintf ("-location %.*s",
10854 (int) (exp_end
- exp_start
), exp_start
);
10857 w
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
10861 w
->hw_wp_mask
= mask
;
10866 w
->val_bitpos
= saved_bitpos
;
10867 w
->val_bitsize
= saved_bitsize
;
10868 w
->val_valid
= true;
10872 w
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
10874 w
->cond_string
= 0;
10876 if (frame_id_p (watchpoint_frame
))
10878 w
->watchpoint_frame
= watchpoint_frame
;
10879 w
->watchpoint_thread
= inferior_ptid
;
10883 w
->watchpoint_frame
= null_frame_id
;
10884 w
->watchpoint_thread
= null_ptid
;
10887 if (scope_breakpoint
!= NULL
)
10889 /* The scope breakpoint is related to the watchpoint. We will
10890 need to act on them together. */
10891 w
->related_breakpoint
= scope_breakpoint
;
10892 scope_breakpoint
->related_breakpoint
= w
.get ();
10895 if (!just_location
)
10896 value_free_to_mark (mark
);
10898 /* Finally update the new watchpoint. This creates the locations
10899 that should be inserted. */
10900 update_watchpoint (w
.get (), 1);
10902 install_breakpoint (internal
, std::move (w
), 1);
10905 /* Return count of debug registers needed to watch the given expression.
10906 If the watchpoint cannot be handled in hardware return zero. */
10909 can_use_hardware_watchpoint (const std::vector
<value_ref_ptr
> &vals
)
10911 int found_memory_cnt
= 0;
10913 /* Did the user specifically forbid us to use hardware watchpoints? */
10914 if (!can_use_hw_watchpoints
)
10917 gdb_assert (!vals
.empty ());
10918 struct value
*head
= vals
[0].get ();
10920 /* Make sure that the value of the expression depends only upon
10921 memory contents, and values computed from them within GDB. If we
10922 find any register references or function calls, we can't use a
10923 hardware watchpoint.
10925 The idea here is that evaluating an expression generates a series
10926 of values, one holding the value of every subexpression. (The
10927 expression a*b+c has five subexpressions: a, b, a*b, c, and
10928 a*b+c.) GDB's values hold almost enough information to establish
10929 the criteria given above --- they identify memory lvalues,
10930 register lvalues, computed values, etcetera. So we can evaluate
10931 the expression, and then scan the chain of values that leaves
10932 behind to decide whether we can detect any possible change to the
10933 expression's final value using only hardware watchpoints.
10935 However, I don't think that the values returned by inferior
10936 function calls are special in any way. So this function may not
10937 notice that an expression involving an inferior function call
10938 can't be watched with hardware watchpoints. FIXME. */
10939 for (const value_ref_ptr
&iter
: vals
)
10941 struct value
*v
= iter
.get ();
10943 if (VALUE_LVAL (v
) == lval_memory
)
10945 if (v
!= head
&& value_lazy (v
))
10946 /* A lazy memory lvalue in the chain is one that GDB never
10947 needed to fetch; we either just used its address (e.g.,
10948 `a' in `a.b') or we never needed it at all (e.g., `a'
10949 in `a,b'). This doesn't apply to HEAD; if that is
10950 lazy then it was not readable, but watch it anyway. */
10954 /* Ahh, memory we actually used! Check if we can cover
10955 it with hardware watchpoints. */
10956 struct type
*vtype
= check_typedef (value_type (v
));
10958 /* We only watch structs and arrays if user asked for it
10959 explicitly, never if they just happen to appear in a
10960 middle of some value chain. */
10962 || (vtype
->code () != TYPE_CODE_STRUCT
10963 && vtype
->code () != TYPE_CODE_ARRAY
))
10965 CORE_ADDR vaddr
= value_address (v
);
10969 len
= (target_exact_watchpoints
10970 && is_scalar_type_recursive (vtype
))?
10971 1 : TYPE_LENGTH (value_type (v
));
10973 num_regs
= target_region_ok_for_hw_watchpoint (vaddr
, len
);
10977 found_memory_cnt
+= num_regs
;
10981 else if (VALUE_LVAL (v
) != not_lval
10982 && deprecated_value_modifiable (v
) == 0)
10983 return 0; /* These are values from the history (e.g., $1). */
10984 else if (VALUE_LVAL (v
) == lval_register
)
10985 return 0; /* Cannot watch a register with a HW watchpoint. */
10988 /* The expression itself looks suitable for using a hardware
10989 watchpoint, but give the target machine a chance to reject it. */
10990 return found_memory_cnt
;
10994 watch_command_wrapper (const char *arg
, int from_tty
, bool internal
)
10996 watch_command_1 (arg
, hw_write
, from_tty
, 0, internal
);
10999 /* Options for the watch, awatch, and rwatch commands. */
11001 struct watch_options
11003 /* For -location. */
11004 bool location
= false;
11007 /* Definitions of options for the "watch", "awatch", and "rwatch" commands.
11009 Historically GDB always accepted both '-location' and '-l' flags for
11010 these commands (both flags being synonyms). When converting to the
11011 newer option scheme only '-location' is added here. That's fine (for
11012 backward compatibility) as any non-ambiguous prefix of a flag will be
11013 accepted, so '-l', '-loc', are now all accepted.
11015 What this means is that, if in the future, we add any new flag here
11016 that starts with '-l' then this will break backward compatibility, so
11017 please, don't do that! */
11019 static const gdb::option::option_def watch_option_defs
[] = {
11020 gdb::option::flag_option_def
<watch_options
> {
11022 [] (watch_options
*opt
) { return &opt
->location
; },
11024 This evaluates EXPRESSION and watches the memory to which is refers.\n\
11025 -l can be used as a short form of -location."),
11029 /* Returns the option group used by 'watch', 'awatch', and 'rwatch'
11032 static gdb::option::option_def_group
11033 make_watch_options_def_group (watch_options
*opts
)
11035 return {{watch_option_defs
}, opts
};
11038 /* A helper function that looks for the "-location" argument and then
11039 calls watch_command_1. */
11042 watch_maybe_just_location (const char *arg
, int accessflag
, int from_tty
)
11044 watch_options opts
;
11045 auto grp
= make_watch_options_def_group (&opts
);
11046 gdb::option::process_options
11047 (&arg
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
11048 if (arg
!= nullptr && *arg
== '\0')
11051 watch_command_1 (arg
, accessflag
, from_tty
, opts
.location
, false);
11054 /* Command completion for 'watch', 'awatch', and 'rwatch' commands. */
11056 watch_command_completer (struct cmd_list_element
*ignore
,
11057 completion_tracker
&tracker
,
11058 const char *text
, const char * /*word*/)
11060 const auto group
= make_watch_options_def_group (nullptr);
11061 if (gdb::option::complete_options
11062 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
11065 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
11066 expression_completer (ignore
, tracker
, text
, word
);
11070 watch_command (const char *arg
, int from_tty
)
11072 watch_maybe_just_location (arg
, hw_write
, from_tty
);
11076 rwatch_command_wrapper (const char *arg
, int from_tty
, bool internal
)
11078 watch_command_1 (arg
, hw_read
, from_tty
, 0, internal
);
11082 rwatch_command (const char *arg
, int from_tty
)
11084 watch_maybe_just_location (arg
, hw_read
, from_tty
);
11088 awatch_command_wrapper (const char *arg
, int from_tty
, bool internal
)
11090 watch_command_1 (arg
, hw_access
, from_tty
, 0, internal
);
11094 awatch_command (const char *arg
, int from_tty
)
11096 watch_maybe_just_location (arg
, hw_access
, from_tty
);
11100 /* Data for the FSM that manages the until(location)/advance commands
11101 in infcmd.c. Here because it uses the mechanisms of
11104 struct until_break_fsm
: public thread_fsm
11106 /* The thread that was current when the command was executed. */
11109 /* The breakpoint set at the return address in the caller frame,
11110 plus breakpoints at all the destination locations. */
11111 std::vector
<breakpoint_up
> breakpoints
;
11113 until_break_fsm (struct interp
*cmd_interp
, int thread
,
11114 std::vector
<breakpoint_up
> &&breakpoints
)
11115 : thread_fsm (cmd_interp
),
11117 breakpoints (std::move (breakpoints
))
11121 void clean_up (struct thread_info
*thread
) override
;
11122 bool should_stop (struct thread_info
*thread
) override
;
11123 enum async_reply_reason
do_async_reply_reason () override
;
11126 /* Implementation of the 'should_stop' FSM method for the
11127 until(location)/advance commands. */
11130 until_break_fsm::should_stop (struct thread_info
*tp
)
11132 for (const breakpoint_up
&bp
: breakpoints
)
11133 if (bpstat_find_breakpoint (tp
->control
.stop_bpstat
,
11134 bp
.get ()) != NULL
)
11143 /* Implementation of the 'clean_up' FSM method for the
11144 until(location)/advance commands. */
11147 until_break_fsm::clean_up (struct thread_info
*)
11149 /* Clean up our temporary breakpoints. */
11150 breakpoints
.clear ();
11151 delete_longjmp_breakpoint (thread
);
11154 /* Implementation of the 'async_reply_reason' FSM method for the
11155 until(location)/advance commands. */
11157 enum async_reply_reason
11158 until_break_fsm::do_async_reply_reason ()
11160 return EXEC_ASYNC_LOCATION_REACHED
;
11164 until_break_command (const char *arg
, int from_tty
, int anywhere
)
11166 struct frame_info
*frame
;
11167 struct gdbarch
*frame_gdbarch
;
11168 struct frame_id stack_frame_id
;
11169 struct frame_id caller_frame_id
;
11171 struct thread_info
*tp
;
11173 clear_proceed_status (0);
11175 /* Set a breakpoint where the user wants it and at return from
11178 event_location_up location
= string_to_event_location (&arg
, current_language
);
11180 std::vector
<symtab_and_line
> sals
11181 = (last_displayed_sal_is_valid ()
11182 ? decode_line_1 (location
.get (), DECODE_LINE_FUNFIRSTLINE
, NULL
,
11183 get_last_displayed_symtab (),
11184 get_last_displayed_line ())
11185 : decode_line_1 (location
.get (), DECODE_LINE_FUNFIRSTLINE
,
11189 error (_("Couldn't get information on specified line."));
11192 error (_("Junk at end of arguments."));
11194 tp
= inferior_thread ();
11195 thread
= tp
->global_num
;
11197 /* Note linespec handling above invalidates the frame chain.
11198 Installing a breakpoint also invalidates the frame chain (as it
11199 may need to switch threads), so do any frame handling before
11202 frame
= get_selected_frame (NULL
);
11203 frame_gdbarch
= get_frame_arch (frame
);
11204 stack_frame_id
= get_stack_frame_id (frame
);
11205 caller_frame_id
= frame_unwind_caller_id (frame
);
11207 /* Keep within the current frame, or in frames called by the current
11210 std::vector
<breakpoint_up
> breakpoints
;
11212 gdb::optional
<delete_longjmp_breakpoint_cleanup
> lj_deleter
;
11214 if (frame_id_p (caller_frame_id
))
11216 struct symtab_and_line sal2
;
11217 struct gdbarch
*caller_gdbarch
;
11219 sal2
= find_pc_line (frame_unwind_caller_pc (frame
), 0);
11220 sal2
.pc
= frame_unwind_caller_pc (frame
);
11221 caller_gdbarch
= frame_unwind_caller_arch (frame
);
11223 breakpoint_up caller_breakpoint
11224 = set_momentary_breakpoint (caller_gdbarch
, sal2
,
11225 caller_frame_id
, bp_until
);
11226 breakpoints
.emplace_back (std::move (caller_breakpoint
));
11228 set_longjmp_breakpoint (tp
, caller_frame_id
);
11229 lj_deleter
.emplace (thread
);
11232 /* set_momentary_breakpoint could invalidate FRAME. */
11235 /* If the user told us to continue until a specified location, we
11236 don't specify a frame at which we need to stop. Otherwise,
11237 specify the selected frame, because we want to stop only at the
11238 very same frame. */
11239 frame_id stop_frame_id
= anywhere
? null_frame_id
: stack_frame_id
;
11241 for (symtab_and_line
&sal
: sals
)
11243 resolve_sal_pc (&sal
);
11245 breakpoint_up location_breakpoint
11246 = set_momentary_breakpoint (frame_gdbarch
, sal
,
11247 stop_frame_id
, bp_until
);
11248 breakpoints
.emplace_back (std::move (location_breakpoint
));
11251 tp
->thread_fsm
= new until_break_fsm (command_interp (), tp
->global_num
,
11252 std::move (breakpoints
));
11255 lj_deleter
->release ();
11257 proceed (-1, GDB_SIGNAL_DEFAULT
);
11260 /* This function attempts to parse an optional "if <cond>" clause
11261 from the arg string. If one is not found, it returns NULL.
11263 Else, it returns a pointer to the condition string. (It does not
11264 attempt to evaluate the string against a particular block.) And,
11265 it updates arg to point to the first character following the parsed
11266 if clause in the arg string. */
11269 ep_parse_optional_if_clause (const char **arg
)
11271 const char *cond_string
;
11273 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
11276 /* Skip the "if" keyword. */
11279 /* Skip any extra leading whitespace, and record the start of the
11280 condition string. */
11281 *arg
= skip_spaces (*arg
);
11282 cond_string
= *arg
;
11284 /* Assume that the condition occupies the remainder of the arg
11286 (*arg
) += strlen (cond_string
);
11288 return cond_string
;
11291 /* Commands to deal with catching events, such as signals, exceptions,
11292 process start/exit, etc. */
11296 catch_fork_temporary
, catch_vfork_temporary
,
11297 catch_fork_permanent
, catch_vfork_permanent
11302 catch_fork_command_1 (const char *arg
, int from_tty
,
11303 struct cmd_list_element
*command
)
11305 struct gdbarch
*gdbarch
= get_current_arch ();
11306 const char *cond_string
= NULL
;
11307 catch_fork_kind fork_kind
;
11309 fork_kind
= (catch_fork_kind
) (uintptr_t) get_cmd_context (command
);
11310 bool temp
= (fork_kind
== catch_fork_temporary
11311 || fork_kind
== catch_vfork_temporary
);
11315 arg
= skip_spaces (arg
);
11317 /* The allowed syntax is:
11319 catch [v]fork if <cond>
11321 First, check if there's an if clause. */
11322 cond_string
= ep_parse_optional_if_clause (&arg
);
11324 if ((*arg
!= '\0') && !isspace (*arg
))
11325 error (_("Junk at end of arguments."));
11327 /* If this target supports it, create a fork or vfork catchpoint
11328 and enable reporting of such events. */
11331 case catch_fork_temporary
:
11332 case catch_fork_permanent
:
11333 create_fork_vfork_event_catchpoint (gdbarch
, temp
, cond_string
,
11334 &catch_fork_breakpoint_ops
);
11336 case catch_vfork_temporary
:
11337 case catch_vfork_permanent
:
11338 create_fork_vfork_event_catchpoint (gdbarch
, temp
, cond_string
,
11339 &catch_vfork_breakpoint_ops
);
11342 error (_("unsupported or unknown fork kind; cannot catch it"));
11348 catch_exec_command_1 (const char *arg
, int from_tty
,
11349 struct cmd_list_element
*command
)
11351 struct gdbarch
*gdbarch
= get_current_arch ();
11352 const char *cond_string
= NULL
;
11353 bool temp
= get_cmd_context (command
) == CATCH_TEMPORARY
;
11357 arg
= skip_spaces (arg
);
11359 /* The allowed syntax is:
11361 catch exec if <cond>
11363 First, check if there's an if clause. */
11364 cond_string
= ep_parse_optional_if_clause (&arg
);
11366 if ((*arg
!= '\0') && !isspace (*arg
))
11367 error (_("Junk at end of arguments."));
11369 std::unique_ptr
<exec_catchpoint
> c (new exec_catchpoint ());
11370 init_catchpoint (c
.get (), gdbarch
, temp
, cond_string
,
11371 &catch_exec_breakpoint_ops
);
11372 c
->exec_pathname
= NULL
;
11374 install_breakpoint (0, std::move (c
), 1);
11378 init_ada_exception_breakpoint (struct breakpoint
*b
,
11379 struct gdbarch
*gdbarch
,
11380 struct symtab_and_line sal
,
11381 const char *addr_string
,
11382 const struct breakpoint_ops
*ops
,
11389 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
11391 loc_gdbarch
= gdbarch
;
11393 describe_other_breakpoints (loc_gdbarch
,
11394 sal
.pspace
, sal
.pc
, sal
.section
, -1);
11395 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
11396 version for exception catchpoints, because two catchpoints
11397 used for different exception names will use the same address.
11398 In this case, a "breakpoint ... also set at..." warning is
11399 unproductive. Besides, the warning phrasing is also a bit
11400 inappropriate, we should use the word catchpoint, and tell
11401 the user what type of catchpoint it is. The above is good
11402 enough for now, though. */
11405 init_raw_breakpoint (b
, gdbarch
, sal
, bp_catchpoint
, ops
);
11407 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
11408 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
11409 b
->location
= string_to_event_location (&addr_string
,
11410 language_def (language_ada
));
11411 b
->language
= language_ada
;
11416 /* Compare two breakpoints and return a strcmp-like result. */
11419 compare_breakpoints (const breakpoint
*a
, const breakpoint
*b
)
11421 uintptr_t ua
= (uintptr_t) a
;
11422 uintptr_t ub
= (uintptr_t) b
;
11424 if (a
->number
< b
->number
)
11426 else if (a
->number
> b
->number
)
11429 /* Now sort by address, in case we see, e..g, two breakpoints with
11433 return ua
> ub
? 1 : 0;
11436 /* Delete breakpoints by address or line. */
11439 clear_command (const char *arg
, int from_tty
)
11443 std::vector
<symtab_and_line
> decoded_sals
;
11444 symtab_and_line last_sal
;
11445 gdb::array_view
<symtab_and_line
> sals
;
11449 = decode_line_with_current_source (arg
,
11450 (DECODE_LINE_FUNFIRSTLINE
11451 | DECODE_LINE_LIST_MODE
));
11453 sals
= decoded_sals
;
11457 /* Set sal's line, symtab, pc, and pspace to the values
11458 corresponding to the last call to print_frame_info. If the
11459 codepoint is not valid, this will set all the fields to 0. */
11460 last_sal
= get_last_displayed_sal ();
11461 if (last_sal
.symtab
== 0)
11462 error (_("No source file specified."));
11468 /* We don't call resolve_sal_pc here. That's not as bad as it
11469 seems, because all existing breakpoints typically have both
11470 file/line and pc set. So, if clear is given file/line, we can
11471 match this to existing breakpoint without obtaining pc at all.
11473 We only support clearing given the address explicitly
11474 present in breakpoint table. Say, we've set breakpoint
11475 at file:line. There were several PC values for that file:line,
11476 due to optimization, all in one block.
11478 We've picked one PC value. If "clear" is issued with another
11479 PC corresponding to the same file:line, the breakpoint won't
11480 be cleared. We probably can still clear the breakpoint, but
11481 since the other PC value is never presented to user, user
11482 can only find it by guessing, and it does not seem important
11483 to support that. */
11485 /* For each line spec given, delete bps which correspond to it. Do
11486 it in two passes, solely to preserve the current behavior that
11487 from_tty is forced true if we delete more than one
11490 std::vector
<struct breakpoint
*> found
;
11491 for (const auto &sal
: sals
)
11493 const char *sal_fullname
;
11495 /* If exact pc given, clear bpts at that pc.
11496 If line given (pc == 0), clear all bpts on specified line.
11497 If defaulting, clear all bpts on default line
11500 defaulting sal.pc != 0 tests to do
11505 1 0 <can't happen> */
11507 sal_fullname
= (sal
.symtab
== NULL
11508 ? NULL
: symtab_to_fullname (sal
.symtab
));
11510 /* Find all matching breakpoints and add them to 'found'. */
11511 for (breakpoint
*b
: all_breakpoints ())
11514 /* Are we going to delete b? */
11515 if (b
->type
!= bp_none
&& !is_watchpoint (b
))
11517 for (bp_location
*loc
: b
->locations ())
11519 /* If the user specified file:line, don't allow a PC
11520 match. This matches historical gdb behavior. */
11521 int pc_match
= (!sal
.explicit_line
11523 && (loc
->pspace
== sal
.pspace
)
11524 && (loc
->address
== sal
.pc
)
11525 && (!section_is_overlay (loc
->section
)
11526 || loc
->section
== sal
.section
));
11527 int line_match
= 0;
11529 if ((default_match
|| sal
.explicit_line
)
11530 && loc
->symtab
!= NULL
11531 && sal_fullname
!= NULL
11532 && sal
.pspace
== loc
->pspace
11533 && loc
->line_number
== sal
.line
11534 && filename_cmp (symtab_to_fullname (loc
->symtab
),
11535 sal_fullname
) == 0)
11538 if (pc_match
|| line_match
)
11547 found
.push_back (b
);
11551 /* Now go thru the 'found' chain and delete them. */
11552 if (found
.empty ())
11555 error (_("No breakpoint at %s."), arg
);
11557 error (_("No breakpoint at this line."));
11560 /* Remove duplicates from the vec. */
11561 std::sort (found
.begin (), found
.end (),
11562 [] (const breakpoint
*bp_a
, const breakpoint
*bp_b
)
11564 return compare_breakpoints (bp_a
, bp_b
) < 0;
11566 found
.erase (std::unique (found
.begin (), found
.end (),
11567 [] (const breakpoint
*bp_a
, const breakpoint
*bp_b
)
11569 return compare_breakpoints (bp_a
, bp_b
) == 0;
11573 if (found
.size () > 1)
11574 from_tty
= 1; /* Always report if deleted more than one. */
11577 if (found
.size () == 1)
11578 printf_unfiltered (_("Deleted breakpoint "));
11580 printf_unfiltered (_("Deleted breakpoints "));
11583 for (breakpoint
*iter
: found
)
11586 printf_unfiltered ("%d ", iter
->number
);
11587 delete_breakpoint (iter
);
11590 putchar_unfiltered ('\n');
11593 /* Delete breakpoint in BS if they are `delete' breakpoints and
11594 all breakpoints that are marked for deletion, whether hit or not.
11595 This is called after any breakpoint is hit, or after errors. */
11598 breakpoint_auto_delete (bpstat bs
)
11600 for (; bs
; bs
= bs
->next
)
11601 if (bs
->breakpoint_at
11602 && bs
->breakpoint_at
->disposition
== disp_del
11604 delete_breakpoint (bs
->breakpoint_at
);
11606 for (breakpoint
*b
: all_breakpoints_safe ())
11607 if (b
->disposition
== disp_del_at_next_stop
)
11608 delete_breakpoint (b
);
11611 /* A comparison function for bp_location AP and BP being interfaced to
11612 std::sort. Sort elements primarily by their ADDRESS (no matter what
11613 bl_address_is_meaningful says), secondarily by ordering first
11614 permanent elements and terciarily just ensuring the array is sorted
11615 stable way despite std::sort being an unstable algorithm. */
11618 bp_location_is_less_than (const bp_location
*a
, const bp_location
*b
)
11620 if (a
->address
!= b
->address
)
11621 return a
->address
< b
->address
;
11623 /* Sort locations at the same address by their pspace number, keeping
11624 locations of the same inferior (in a multi-inferior environment)
11627 if (a
->pspace
->num
!= b
->pspace
->num
)
11628 return a
->pspace
->num
< b
->pspace
->num
;
11630 /* Sort permanent breakpoints first. */
11631 if (a
->permanent
!= b
->permanent
)
11632 return a
->permanent
> b
->permanent
;
11634 /* Sort by type in order to make duplicate determination easier.
11635 See update_global_location_list. This is kept in sync with
11636 breakpoint_locations_match. */
11637 if (a
->loc_type
< b
->loc_type
)
11640 /* Likewise, for range-breakpoints, sort by length. */
11641 if (a
->loc_type
== bp_loc_hardware_breakpoint
11642 && b
->loc_type
== bp_loc_hardware_breakpoint
11643 && a
->length
< b
->length
)
11646 /* Make the internal GDB representation stable across GDB runs
11647 where A and B memory inside GDB can differ. Breakpoint locations of
11648 the same type at the same address can be sorted in arbitrary order. */
11650 if (a
->owner
->number
!= b
->owner
->number
)
11651 return a
->owner
->number
< b
->owner
->number
;
11656 /* Set bp_locations_placed_address_before_address_max and
11657 bp_locations_shadow_len_after_address_max according to the current
11658 content of the bp_locations array. */
11661 bp_locations_target_extensions_update (void)
11663 struct bp_location
*bl
, **blp_tmp
;
11665 bp_locations_placed_address_before_address_max
= 0;
11666 bp_locations_shadow_len_after_address_max
= 0;
11668 ALL_BP_LOCATIONS (bl
, blp_tmp
)
11670 CORE_ADDR start
, end
, addr
;
11672 if (!bp_location_has_shadow (bl
))
11675 start
= bl
->target_info
.placed_address
;
11676 end
= start
+ bl
->target_info
.shadow_len
;
11678 gdb_assert (bl
->address
>= start
);
11679 addr
= bl
->address
- start
;
11680 if (addr
> bp_locations_placed_address_before_address_max
)
11681 bp_locations_placed_address_before_address_max
= addr
;
11683 /* Zero SHADOW_LEN would not pass bp_location_has_shadow. */
11685 gdb_assert (bl
->address
< end
);
11686 addr
= end
- bl
->address
;
11687 if (addr
> bp_locations_shadow_len_after_address_max
)
11688 bp_locations_shadow_len_after_address_max
= addr
;
11692 /* Download tracepoint locations if they haven't been. */
11695 download_tracepoint_locations (void)
11697 enum tribool can_download_tracepoint
= TRIBOOL_UNKNOWN
;
11699 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
11701 for (breakpoint
*b
: all_tracepoints ())
11703 struct tracepoint
*t
;
11704 int bp_location_downloaded
= 0;
11706 if ((b
->type
== bp_fast_tracepoint
11707 ? !may_insert_fast_tracepoints
11708 : !may_insert_tracepoints
))
11711 if (can_download_tracepoint
== TRIBOOL_UNKNOWN
)
11713 if (target_can_download_tracepoint ())
11714 can_download_tracepoint
= TRIBOOL_TRUE
;
11716 can_download_tracepoint
= TRIBOOL_FALSE
;
11719 if (can_download_tracepoint
== TRIBOOL_FALSE
)
11722 for (bp_location
*bl
: b
->locations ())
11724 /* In tracepoint, locations are _never_ duplicated, so
11725 should_be_inserted is equivalent to
11726 unduplicated_should_be_inserted. */
11727 if (!should_be_inserted (bl
) || bl
->inserted
)
11730 switch_to_program_space_and_thread (bl
->pspace
);
11732 target_download_tracepoint (bl
);
11735 bp_location_downloaded
= 1;
11737 t
= (struct tracepoint
*) b
;
11738 t
->number_on_target
= b
->number
;
11739 if (bp_location_downloaded
)
11740 gdb::observers::breakpoint_modified
.notify (b
);
11744 /* Swap the insertion/duplication state between two locations. */
11747 swap_insertion (struct bp_location
*left
, struct bp_location
*right
)
11749 const int left_inserted
= left
->inserted
;
11750 const int left_duplicate
= left
->duplicate
;
11751 const int left_needs_update
= left
->needs_update
;
11752 const struct bp_target_info left_target_info
= left
->target_info
;
11754 /* Locations of tracepoints can never be duplicated. */
11755 if (is_tracepoint (left
->owner
))
11756 gdb_assert (!left
->duplicate
);
11757 if (is_tracepoint (right
->owner
))
11758 gdb_assert (!right
->duplicate
);
11760 left
->inserted
= right
->inserted
;
11761 left
->duplicate
= right
->duplicate
;
11762 left
->needs_update
= right
->needs_update
;
11763 left
->target_info
= right
->target_info
;
11764 right
->inserted
= left_inserted
;
11765 right
->duplicate
= left_duplicate
;
11766 right
->needs_update
= left_needs_update
;
11767 right
->target_info
= left_target_info
;
11770 /* Force the re-insertion of the locations at ADDRESS. This is called
11771 once a new/deleted/modified duplicate location is found and we are evaluating
11772 conditions on the target's side. Such conditions need to be updated on
11776 force_breakpoint_reinsertion (struct bp_location
*bl
)
11778 struct bp_location
**locp
= NULL
, **loc2p
;
11779 struct bp_location
*loc
;
11780 CORE_ADDR address
= 0;
11783 address
= bl
->address
;
11784 pspace_num
= bl
->pspace
->num
;
11786 /* This is only meaningful if the target is
11787 evaluating conditions and if the user has
11788 opted for condition evaluation on the target's
11790 if (gdb_evaluates_breakpoint_condition_p ()
11791 || !target_supports_evaluation_of_breakpoint_conditions ())
11794 /* Flag all breakpoint locations with this address and
11795 the same program space as the location
11796 as "its condition has changed". We need to
11797 update the conditions on the target's side. */
11798 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, address
)
11802 if (!is_breakpoint (loc
->owner
)
11803 || pspace_num
!= loc
->pspace
->num
)
11806 /* Flag the location appropriately. We use a different state to
11807 let everyone know that we already updated the set of locations
11808 with addr bl->address and program space bl->pspace. This is so
11809 we don't have to keep calling these functions just to mark locations
11810 that have already been marked. */
11811 loc
->condition_changed
= condition_updated
;
11813 /* Free the agent expression bytecode as well. We will compute
11815 loc
->cond_bytecode
.reset ();
11819 /* Called whether new breakpoints are created, or existing breakpoints
11820 deleted, to update the global location list and recompute which
11821 locations are duplicate of which.
11823 The INSERT_MODE flag determines whether locations may not, may, or
11824 shall be inserted now. See 'enum ugll_insert_mode' for more
11828 update_global_location_list (enum ugll_insert_mode insert_mode
)
11830 /* Last breakpoint location address that was marked for update. */
11831 CORE_ADDR last_addr
= 0;
11832 /* Last breakpoint location program space that was marked for update. */
11833 int last_pspace_num
= -1;
11835 /* Used in the duplicates detection below. When iterating over all
11836 bp_locations, points to the first bp_location of a given address.
11837 Breakpoints and watchpoints of different types are never
11838 duplicates of each other. Keep one pointer for each type of
11839 breakpoint/watchpoint, so we only need to loop over all locations
11841 struct bp_location
*bp_loc_first
; /* breakpoint */
11842 struct bp_location
*wp_loc_first
; /* hardware watchpoint */
11843 struct bp_location
*awp_loc_first
; /* access watchpoint */
11844 struct bp_location
*rwp_loc_first
; /* read watchpoint */
11846 /* Saved former bp_locations array which we compare against the newly
11847 built bp_locations from the current state of ALL_BREAKPOINTS. */
11848 std::vector
<bp_location
*> old_locations
= std::move (bp_locations
);
11849 bp_locations
.clear ();
11851 for (breakpoint
*b
: all_breakpoints ())
11852 for (bp_location
*loc
: b
->locations ())
11853 bp_locations
.push_back (loc
);
11855 /* See if we need to "upgrade" a software breakpoint to a hardware
11856 breakpoint. Do this before deciding whether locations are
11857 duplicates. Also do this before sorting because sorting order
11858 depends on location type. */
11859 for (bp_location
*loc
: bp_locations
)
11860 if (!loc
->inserted
&& should_be_inserted (loc
))
11861 handle_automatic_hardware_breakpoints (loc
);
11863 std::sort (bp_locations
.begin (), bp_locations
.end (),
11864 bp_location_is_less_than
);
11866 bp_locations_target_extensions_update ();
11868 /* Identify bp_location instances that are no longer present in the
11869 new list, and therefore should be freed. Note that it's not
11870 necessary that those locations should be removed from inferior --
11871 if there's another location at the same address (previously
11872 marked as duplicate), we don't need to remove/insert the
11875 LOCP is kept in sync with OLD_LOCP, each pointing to the current
11876 and former bp_location array state respectively. */
11879 for (bp_location
*old_loc
: old_locations
)
11881 /* Tells if 'old_loc' is found among the new locations. If
11882 not, we have to free it. */
11883 int found_object
= 0;
11884 /* Tells if the location should remain inserted in the target. */
11885 int keep_in_target
= 0;
11888 /* Skip LOCP entries which will definitely never be needed.
11889 Stop either at or being the one matching OLD_LOC. */
11890 while (loc_i
< bp_locations
.size ()
11891 && bp_locations
[loc_i
]->address
< old_loc
->address
)
11894 for (size_t loc2_i
= loc_i
;
11895 (loc2_i
< bp_locations
.size ()
11896 && bp_locations
[loc2_i
]->address
== old_loc
->address
);
11899 /* Check if this is a new/duplicated location or a duplicated
11900 location that had its condition modified. If so, we want to send
11901 its condition to the target if evaluation of conditions is taking
11903 if (bp_locations
[loc2_i
]->condition_changed
== condition_modified
11904 && (last_addr
!= old_loc
->address
11905 || last_pspace_num
!= old_loc
->pspace
->num
))
11907 force_breakpoint_reinsertion (bp_locations
[loc2_i
]);
11908 last_pspace_num
= old_loc
->pspace
->num
;
11911 if (bp_locations
[loc2_i
] == old_loc
)
11915 /* We have already handled this address, update it so that we don't
11916 have to go through updates again. */
11917 last_addr
= old_loc
->address
;
11919 /* Target-side condition evaluation: Handle deleted locations. */
11921 force_breakpoint_reinsertion (old_loc
);
11923 /* If this location is no longer present, and inserted, look if
11924 there's maybe a new location at the same address. If so,
11925 mark that one inserted, and don't remove this one. This is
11926 needed so that we don't have a time window where a breakpoint
11927 at certain location is not inserted. */
11929 if (old_loc
->inserted
)
11931 /* If the location is inserted now, we might have to remove
11934 if (found_object
&& should_be_inserted (old_loc
))
11936 /* The location is still present in the location list,
11937 and still should be inserted. Don't do anything. */
11938 keep_in_target
= 1;
11942 /* This location still exists, but it won't be kept in the
11943 target since it may have been disabled. We proceed to
11944 remove its target-side condition. */
11946 /* The location is either no longer present, or got
11947 disabled. See if there's another location at the
11948 same address, in which case we don't need to remove
11949 this one from the target. */
11951 /* OLD_LOC comes from existing struct breakpoint. */
11952 if (bl_address_is_meaningful (old_loc
))
11954 for (size_t loc2_i
= loc_i
;
11955 (loc2_i
< bp_locations
.size ()
11956 && bp_locations
[loc2_i
]->address
== old_loc
->address
);
11959 bp_location
*loc2
= bp_locations
[loc2_i
];
11961 if (loc2
== old_loc
)
11964 if (breakpoint_locations_match (loc2
, old_loc
))
11966 /* Read watchpoint locations are switched to
11967 access watchpoints, if the former are not
11968 supported, but the latter are. */
11969 if (is_hardware_watchpoint (old_loc
->owner
))
11971 gdb_assert (is_hardware_watchpoint (loc2
->owner
));
11972 loc2
->watchpoint_type
= old_loc
->watchpoint_type
;
11975 /* loc2 is a duplicated location. We need to check
11976 if it should be inserted in case it will be
11978 if (unduplicated_should_be_inserted (loc2
))
11980 swap_insertion (old_loc
, loc2
);
11981 keep_in_target
= 1;
11989 if (!keep_in_target
)
11991 if (remove_breakpoint (old_loc
))
11993 /* This is just about all we can do. We could keep
11994 this location on the global list, and try to
11995 remove it next time, but there's no particular
11996 reason why we will succeed next time.
11998 Note that at this point, old_loc->owner is still
11999 valid, as delete_breakpoint frees the breakpoint
12000 only after calling us. */
12001 printf_filtered (_("warning: Error removing "
12002 "breakpoint %d\n"),
12003 old_loc
->owner
->number
);
12011 if (removed
&& target_is_non_stop_p ()
12012 && need_moribund_for_location_type (old_loc
))
12014 /* This location was removed from the target. In
12015 non-stop mode, a race condition is possible where
12016 we've removed a breakpoint, but stop events for that
12017 breakpoint are already queued and will arrive later.
12018 We apply an heuristic to be able to distinguish such
12019 SIGTRAPs from other random SIGTRAPs: we keep this
12020 breakpoint location for a bit, and will retire it
12021 after we see some number of events. The theory here
12022 is that reporting of events should, "on the average",
12023 be fair, so after a while we'll see events from all
12024 threads that have anything of interest, and no longer
12025 need to keep this breakpoint location around. We
12026 don't hold locations forever so to reduce chances of
12027 mistaking a non-breakpoint SIGTRAP for a breakpoint
12030 The heuristic failing can be disastrous on
12031 decr_pc_after_break targets.
12033 On decr_pc_after_break targets, like e.g., x86-linux,
12034 if we fail to recognize a late breakpoint SIGTRAP,
12035 because events_till_retirement has reached 0 too
12036 soon, we'll fail to do the PC adjustment, and report
12037 a random SIGTRAP to the user. When the user resumes
12038 the inferior, it will most likely immediately crash
12039 with SIGILL/SIGBUS/SIGSEGV, or worse, get silently
12040 corrupted, because of being resumed e.g., in the
12041 middle of a multi-byte instruction, or skipped a
12042 one-byte instruction. This was actually seen happen
12043 on native x86-linux, and should be less rare on
12044 targets that do not support new thread events, like
12045 remote, due to the heuristic depending on
12048 Mistaking a random SIGTRAP for a breakpoint trap
12049 causes similar symptoms (PC adjustment applied when
12050 it shouldn't), but then again, playing with SIGTRAPs
12051 behind the debugger's back is asking for trouble.
12053 Since hardware watchpoint traps are always
12054 distinguishable from other traps, so we don't need to
12055 apply keep hardware watchpoint moribund locations
12056 around. We simply always ignore hardware watchpoint
12057 traps we can no longer explain. */
12059 process_stratum_target
*proc_target
= nullptr;
12060 for (inferior
*inf
: all_inferiors ())
12061 if (inf
->pspace
== old_loc
->pspace
)
12063 proc_target
= inf
->process_target ();
12066 if (proc_target
!= nullptr)
12067 old_loc
->events_till_retirement
12068 = 3 * (thread_count (proc_target
) + 1);
12070 old_loc
->events_till_retirement
= 1;
12071 old_loc
->owner
= NULL
;
12073 moribund_locations
.push_back (old_loc
);
12077 old_loc
->owner
= NULL
;
12078 decref_bp_location (&old_loc
);
12083 /* Rescan breakpoints at the same address and section, marking the
12084 first one as "first" and any others as "duplicates". This is so
12085 that the bpt instruction is only inserted once. If we have a
12086 permanent breakpoint at the same place as BPT, make that one the
12087 official one, and the rest as duplicates. Permanent breakpoints
12088 are sorted first for the same address.
12090 Do the same for hardware watchpoints, but also considering the
12091 watchpoint's type (regular/access/read) and length. */
12093 bp_loc_first
= NULL
;
12094 wp_loc_first
= NULL
;
12095 awp_loc_first
= NULL
;
12096 rwp_loc_first
= NULL
;
12098 bp_location
*loc
, **locp
;
12099 ALL_BP_LOCATIONS (loc
, locp
)
12101 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always
12103 struct bp_location
**loc_first_p
;
12104 breakpoint
*b
= loc
->owner
;
12106 if (!unduplicated_should_be_inserted (loc
)
12107 || !bl_address_is_meaningful (loc
)
12108 /* Don't detect duplicate for tracepoint locations because they are
12109 never duplicated. See the comments in field `duplicate' of
12110 `struct bp_location'. */
12111 || is_tracepoint (b
))
12113 /* Clear the condition modification flag. */
12114 loc
->condition_changed
= condition_unchanged
;
12118 if (b
->type
== bp_hardware_watchpoint
)
12119 loc_first_p
= &wp_loc_first
;
12120 else if (b
->type
== bp_read_watchpoint
)
12121 loc_first_p
= &rwp_loc_first
;
12122 else if (b
->type
== bp_access_watchpoint
)
12123 loc_first_p
= &awp_loc_first
;
12125 loc_first_p
= &bp_loc_first
;
12127 if (*loc_first_p
== NULL
12128 || (overlay_debugging
&& loc
->section
!= (*loc_first_p
)->section
)
12129 || !breakpoint_locations_match (loc
, *loc_first_p
))
12131 *loc_first_p
= loc
;
12132 loc
->duplicate
= 0;
12134 if (is_breakpoint (loc
->owner
) && loc
->condition_changed
)
12136 loc
->needs_update
= 1;
12137 /* Clear the condition modification flag. */
12138 loc
->condition_changed
= condition_unchanged
;
12144 /* This and the above ensure the invariant that the first location
12145 is not duplicated, and is the inserted one.
12146 All following are marked as duplicated, and are not inserted. */
12148 swap_insertion (loc
, *loc_first_p
);
12149 loc
->duplicate
= 1;
12151 /* Clear the condition modification flag. */
12152 loc
->condition_changed
= condition_unchanged
;
12155 if (insert_mode
== UGLL_INSERT
|| breakpoints_should_be_inserted_now ())
12157 if (insert_mode
!= UGLL_DONT_INSERT
)
12158 insert_breakpoint_locations ();
12161 /* Even though the caller told us to not insert new
12162 locations, we may still need to update conditions on the
12163 target's side of breakpoints that were already inserted
12164 if the target is evaluating breakpoint conditions. We
12165 only update conditions for locations that are marked
12167 update_inserted_breakpoint_locations ();
12171 if (insert_mode
!= UGLL_DONT_INSERT
)
12172 download_tracepoint_locations ();
12176 breakpoint_retire_moribund (void)
12178 for (int ix
= 0; ix
< moribund_locations
.size (); ++ix
)
12180 struct bp_location
*loc
= moribund_locations
[ix
];
12181 if (--(loc
->events_till_retirement
) == 0)
12183 decref_bp_location (&loc
);
12184 unordered_remove (moribund_locations
, ix
);
12191 update_global_location_list_nothrow (enum ugll_insert_mode insert_mode
)
12196 update_global_location_list (insert_mode
);
12198 catch (const gdb_exception_error
&e
)
12203 /* Clear BKP from a BPS. */
12206 bpstat_remove_bp_location (bpstat bps
, struct breakpoint
*bpt
)
12210 for (bs
= bps
; bs
; bs
= bs
->next
)
12211 if (bs
->breakpoint_at
== bpt
)
12213 bs
->breakpoint_at
= NULL
;
12214 bs
->old_val
= NULL
;
12215 /* bs->commands will be freed later. */
12219 /* Callback for iterate_over_threads. */
12221 bpstat_remove_breakpoint_callback (struct thread_info
*th
, void *data
)
12223 struct breakpoint
*bpt
= (struct breakpoint
*) data
;
12225 bpstat_remove_bp_location (th
->control
.stop_bpstat
, bpt
);
12229 /* Helper for breakpoint and tracepoint breakpoint_ops->mention
12233 say_where (struct breakpoint
*b
)
12235 struct value_print_options opts
;
12237 get_user_print_options (&opts
);
12239 /* i18n: cagney/2005-02-11: Below needs to be merged into a
12241 if (b
->loc
== NULL
)
12243 /* For pending locations, the output differs slightly based
12244 on b->extra_string. If this is non-NULL, it contains either
12245 a condition or dprintf arguments. */
12246 if (b
->extra_string
== NULL
)
12248 printf_filtered (_(" (%s) pending."),
12249 event_location_to_string (b
->location
.get ()));
12251 else if (b
->type
== bp_dprintf
)
12253 printf_filtered (_(" (%s,%s) pending."),
12254 event_location_to_string (b
->location
.get ()),
12259 printf_filtered (_(" (%s %s) pending."),
12260 event_location_to_string (b
->location
.get ()),
12266 if (opts
.addressprint
|| b
->loc
->symtab
== NULL
)
12267 printf_filtered (" at %ps",
12268 styled_string (address_style
.style (),
12269 paddress (b
->loc
->gdbarch
,
12270 b
->loc
->address
)));
12271 if (b
->loc
->symtab
!= NULL
)
12273 /* If there is a single location, we can print the location
12275 if (b
->loc
->next
== NULL
)
12277 const char *filename
12278 = symtab_to_filename_for_display (b
->loc
->symtab
);
12279 printf_filtered (": file %ps, line %d.",
12280 styled_string (file_name_style
.style (),
12282 b
->loc
->line_number
);
12285 /* This is not ideal, but each location may have a
12286 different file name, and this at least reflects the
12287 real situation somewhat. */
12288 printf_filtered (": %s.",
12289 event_location_to_string (b
->location
.get ()));
12294 struct bp_location
*loc
= b
->loc
;
12296 for (; loc
; loc
= loc
->next
)
12298 printf_filtered (" (%d locations)", n
);
12303 bp_location::~bp_location ()
12305 xfree (function_name
);
12308 /* Destructor for the breakpoint base class. */
12310 breakpoint::~breakpoint ()
12312 xfree (this->cond_string
);
12313 xfree (this->extra_string
);
12316 /* See breakpoint.h. */
12318 bp_locations_range
breakpoint::locations ()
12320 return bp_locations_range (this->loc
);
12323 static struct bp_location
*
12324 base_breakpoint_allocate_location (struct breakpoint
*self
)
12326 return new bp_location (self
);
12330 base_breakpoint_re_set (struct breakpoint
*b
)
12332 /* Nothing to re-set. */
12335 #define internal_error_pure_virtual_called() \
12336 gdb_assert_not_reached ("pure virtual function called")
12339 base_breakpoint_insert_location (struct bp_location
*bl
)
12341 internal_error_pure_virtual_called ();
12345 base_breakpoint_remove_location (struct bp_location
*bl
,
12346 enum remove_bp_reason reason
)
12348 internal_error_pure_virtual_called ();
12352 base_breakpoint_breakpoint_hit (const struct bp_location
*bl
,
12353 const address_space
*aspace
,
12355 const struct target_waitstatus
*ws
)
12357 internal_error_pure_virtual_called ();
12361 base_breakpoint_check_status (bpstat bs
)
12366 /* A "works_in_software_mode" breakpoint_ops method that just internal
12370 base_breakpoint_works_in_software_mode (const struct breakpoint
*b
)
12372 internal_error_pure_virtual_called ();
12375 /* A "resources_needed" breakpoint_ops method that just internal
12379 base_breakpoint_resources_needed (const struct bp_location
*bl
)
12381 internal_error_pure_virtual_called ();
12384 static enum print_stop_action
12385 base_breakpoint_print_it (bpstat bs
)
12387 internal_error_pure_virtual_called ();
12391 base_breakpoint_print_one_detail (const struct breakpoint
*self
,
12392 struct ui_out
*uiout
)
12398 base_breakpoint_print_mention (struct breakpoint
*b
)
12400 internal_error_pure_virtual_called ();
12404 base_breakpoint_print_recreate (struct breakpoint
*b
, struct ui_file
*fp
)
12406 internal_error_pure_virtual_called ();
12410 base_breakpoint_create_sals_from_location
12411 (struct event_location
*location
,
12412 struct linespec_result
*canonical
,
12413 enum bptype type_wanted
)
12415 internal_error_pure_virtual_called ();
12419 base_breakpoint_create_breakpoints_sal (struct gdbarch
*gdbarch
,
12420 struct linespec_result
*c
,
12421 gdb::unique_xmalloc_ptr
<char> cond_string
,
12422 gdb::unique_xmalloc_ptr
<char> extra_string
,
12423 enum bptype type_wanted
,
12424 enum bpdisp disposition
,
12426 int task
, int ignore_count
,
12427 const struct breakpoint_ops
*o
,
12428 int from_tty
, int enabled
,
12429 int internal
, unsigned flags
)
12431 internal_error_pure_virtual_called ();
12434 static std::vector
<symtab_and_line
>
12435 base_breakpoint_decode_location (struct breakpoint
*b
,
12436 struct event_location
*location
,
12437 struct program_space
*search_pspace
)
12439 internal_error_pure_virtual_called ();
12442 /* The default 'explains_signal' method. */
12445 base_breakpoint_explains_signal (struct breakpoint
*b
, enum gdb_signal sig
)
12450 /* The default "after_condition_true" method. */
12453 base_breakpoint_after_condition_true (struct bpstats
*bs
)
12455 /* Nothing to do. */
12458 struct breakpoint_ops base_breakpoint_ops
=
12460 base_breakpoint_allocate_location
,
12461 base_breakpoint_re_set
,
12462 base_breakpoint_insert_location
,
12463 base_breakpoint_remove_location
,
12464 base_breakpoint_breakpoint_hit
,
12465 base_breakpoint_check_status
,
12466 base_breakpoint_resources_needed
,
12467 base_breakpoint_works_in_software_mode
,
12468 base_breakpoint_print_it
,
12470 base_breakpoint_print_one_detail
,
12471 base_breakpoint_print_mention
,
12472 base_breakpoint_print_recreate
,
12473 base_breakpoint_create_sals_from_location
,
12474 base_breakpoint_create_breakpoints_sal
,
12475 base_breakpoint_decode_location
,
12476 base_breakpoint_explains_signal
,
12477 base_breakpoint_after_condition_true
,
12480 /* Default breakpoint_ops methods. */
12483 bkpt_re_set (struct breakpoint
*b
)
12485 /* FIXME: is this still reachable? */
12486 if (breakpoint_event_location_empty_p (b
))
12488 /* Anything without a location can't be re-set. */
12489 delete_breakpoint (b
);
12493 breakpoint_re_set_default (b
);
12497 bkpt_insert_location (struct bp_location
*bl
)
12499 CORE_ADDR addr
= bl
->target_info
.reqstd_address
;
12501 bl
->target_info
.kind
= breakpoint_kind (bl
, &addr
);
12502 bl
->target_info
.placed_address
= addr
;
12504 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
12505 return target_insert_hw_breakpoint (bl
->gdbarch
, &bl
->target_info
);
12507 return target_insert_breakpoint (bl
->gdbarch
, &bl
->target_info
);
12511 bkpt_remove_location (struct bp_location
*bl
, enum remove_bp_reason reason
)
12513 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
12514 return target_remove_hw_breakpoint (bl
->gdbarch
, &bl
->target_info
);
12516 return target_remove_breakpoint (bl
->gdbarch
, &bl
->target_info
, reason
);
12520 bkpt_breakpoint_hit (const struct bp_location
*bl
,
12521 const address_space
*aspace
, CORE_ADDR bp_addr
,
12522 const struct target_waitstatus
*ws
)
12524 if (ws
->kind
!= TARGET_WAITKIND_STOPPED
12525 || ws
->value
.sig
!= GDB_SIGNAL_TRAP
)
12528 if (!breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
12532 if (overlay_debugging
/* unmapped overlay section */
12533 && section_is_overlay (bl
->section
)
12534 && !section_is_mapped (bl
->section
))
12541 dprintf_breakpoint_hit (const struct bp_location
*bl
,
12542 const address_space
*aspace
, CORE_ADDR bp_addr
,
12543 const struct target_waitstatus
*ws
)
12545 if (dprintf_style
== dprintf_style_agent
12546 && target_can_run_breakpoint_commands ())
12548 /* An agent-style dprintf never causes a stop. If we see a trap
12549 for this address it must be for a breakpoint that happens to
12550 be set at the same address. */
12554 return bkpt_breakpoint_hit (bl
, aspace
, bp_addr
, ws
);
12558 bkpt_resources_needed (const struct bp_location
*bl
)
12560 gdb_assert (bl
->owner
->type
== bp_hardware_breakpoint
);
12565 static enum print_stop_action
12566 bkpt_print_it (bpstat bs
)
12568 struct breakpoint
*b
;
12569 const struct bp_location
*bl
;
12571 struct ui_out
*uiout
= current_uiout
;
12573 gdb_assert (bs
->bp_location_at
!= NULL
);
12575 bl
= bs
->bp_location_at
.get ();
12576 b
= bs
->breakpoint_at
;
12578 bp_temp
= b
->disposition
== disp_del
;
12579 if (bl
->address
!= bl
->requested_address
)
12580 breakpoint_adjustment_warning (bl
->requested_address
,
12583 annotate_breakpoint (b
->number
);
12584 maybe_print_thread_hit_breakpoint (uiout
);
12586 if (uiout
->is_mi_like_p ())
12588 uiout
->field_string ("reason",
12589 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
12590 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
12593 uiout
->message ("Temporary breakpoint %pF, ",
12594 signed_field ("bkptno", b
->number
));
12596 uiout
->message ("Breakpoint %pF, ",
12597 signed_field ("bkptno", b
->number
));
12599 return PRINT_SRC_AND_LOC
;
12603 bkpt_print_mention (struct breakpoint
*b
)
12605 if (current_uiout
->is_mi_like_p ())
12610 case bp_breakpoint
:
12611 case bp_gnu_ifunc_resolver
:
12612 if (b
->disposition
== disp_del
)
12613 printf_filtered (_("Temporary breakpoint"));
12615 printf_filtered (_("Breakpoint"));
12616 printf_filtered (_(" %d"), b
->number
);
12617 if (b
->type
== bp_gnu_ifunc_resolver
)
12618 printf_filtered (_(" at gnu-indirect-function resolver"));
12620 case bp_hardware_breakpoint
:
12621 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
12624 printf_filtered (_("Dprintf %d"), b
->number
);
12632 bkpt_print_recreate (struct breakpoint
*tp
, struct ui_file
*fp
)
12634 if (tp
->type
== bp_breakpoint
&& tp
->disposition
== disp_del
)
12635 fprintf_unfiltered (fp
, "tbreak");
12636 else if (tp
->type
== bp_breakpoint
)
12637 fprintf_unfiltered (fp
, "break");
12638 else if (tp
->type
== bp_hardware_breakpoint
12639 && tp
->disposition
== disp_del
)
12640 fprintf_unfiltered (fp
, "thbreak");
12641 else if (tp
->type
== bp_hardware_breakpoint
)
12642 fprintf_unfiltered (fp
, "hbreak");
12644 internal_error (__FILE__
, __LINE__
,
12645 _("unhandled breakpoint type %d"), (int) tp
->type
);
12647 fprintf_unfiltered (fp
, " %s",
12648 event_location_to_string (tp
->location
.get ()));
12650 /* Print out extra_string if this breakpoint is pending. It might
12651 contain, for example, conditions that were set by the user. */
12652 if (tp
->loc
== NULL
&& tp
->extra_string
!= NULL
)
12653 fprintf_unfiltered (fp
, " %s", tp
->extra_string
);
12655 print_recreate_thread (tp
, fp
);
12659 bkpt_create_sals_from_location (struct event_location
*location
,
12660 struct linespec_result
*canonical
,
12661 enum bptype type_wanted
)
12663 create_sals_from_location_default (location
, canonical
, type_wanted
);
12667 bkpt_create_breakpoints_sal (struct gdbarch
*gdbarch
,
12668 struct linespec_result
*canonical
,
12669 gdb::unique_xmalloc_ptr
<char> cond_string
,
12670 gdb::unique_xmalloc_ptr
<char> extra_string
,
12671 enum bptype type_wanted
,
12672 enum bpdisp disposition
,
12674 int task
, int ignore_count
,
12675 const struct breakpoint_ops
*ops
,
12676 int from_tty
, int enabled
,
12677 int internal
, unsigned flags
)
12679 create_breakpoints_sal_default (gdbarch
, canonical
,
12680 std::move (cond_string
),
12681 std::move (extra_string
),
12683 disposition
, thread
, task
,
12684 ignore_count
, ops
, from_tty
,
12685 enabled
, internal
, flags
);
12688 static std::vector
<symtab_and_line
>
12689 bkpt_decode_location (struct breakpoint
*b
,
12690 struct event_location
*location
,
12691 struct program_space
*search_pspace
)
12693 return decode_location_default (b
, location
, search_pspace
);
12696 /* Virtual table for internal breakpoints. */
12699 internal_bkpt_re_set (struct breakpoint
*b
)
12703 /* Delete overlay event and longjmp master breakpoints; they
12704 will be reset later by breakpoint_re_set. */
12705 case bp_overlay_event
:
12706 case bp_longjmp_master
:
12707 case bp_std_terminate_master
:
12708 case bp_exception_master
:
12709 delete_breakpoint (b
);
12712 /* This breakpoint is special, it's set up when the inferior
12713 starts and we really don't want to touch it. */
12714 case bp_shlib_event
:
12716 /* Like bp_shlib_event, this breakpoint type is special. Once
12717 it is set up, we do not want to touch it. */
12718 case bp_thread_event
:
12724 internal_bkpt_check_status (bpstat bs
)
12726 if (bs
->breakpoint_at
->type
== bp_shlib_event
)
12728 /* If requested, stop when the dynamic linker notifies GDB of
12729 events. This allows the user to get control and place
12730 breakpoints in initializer routines for dynamically loaded
12731 objects (among other things). */
12732 bs
->stop
= stop_on_solib_events
;
12733 bs
->print
= stop_on_solib_events
;
12739 static enum print_stop_action
12740 internal_bkpt_print_it (bpstat bs
)
12742 struct breakpoint
*b
;
12744 b
= bs
->breakpoint_at
;
12748 case bp_shlib_event
:
12749 /* Did we stop because the user set the stop_on_solib_events
12750 variable? (If so, we report this as a generic, "Stopped due
12751 to shlib event" message.) */
12752 print_solib_event (0);
12755 case bp_thread_event
:
12756 /* Not sure how we will get here.
12757 GDB should not stop for these breakpoints. */
12758 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
12761 case bp_overlay_event
:
12762 /* By analogy with the thread event, GDB should not stop for these. */
12763 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
12766 case bp_longjmp_master
:
12767 /* These should never be enabled. */
12768 printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
12771 case bp_std_terminate_master
:
12772 /* These should never be enabled. */
12773 printf_filtered (_("std::terminate Master Breakpoint: "
12774 "gdb should not stop!\n"));
12777 case bp_exception_master
:
12778 /* These should never be enabled. */
12779 printf_filtered (_("Exception Master Breakpoint: "
12780 "gdb should not stop!\n"));
12784 return PRINT_NOTHING
;
12788 internal_bkpt_print_mention (struct breakpoint
*b
)
12790 /* Nothing to mention. These breakpoints are internal. */
12793 /* Virtual table for momentary breakpoints */
12796 momentary_bkpt_re_set (struct breakpoint
*b
)
12798 /* Keep temporary breakpoints, which can be encountered when we step
12799 over a dlopen call and solib_add is resetting the breakpoints.
12800 Otherwise these should have been blown away via the cleanup chain
12801 or by breakpoint_init_inferior when we rerun the executable. */
12805 momentary_bkpt_check_status (bpstat bs
)
12807 /* Nothing. The point of these breakpoints is causing a stop. */
12810 static enum print_stop_action
12811 momentary_bkpt_print_it (bpstat bs
)
12813 return PRINT_UNKNOWN
;
12817 momentary_bkpt_print_mention (struct breakpoint
*b
)
12819 /* Nothing to mention. These breakpoints are internal. */
12822 /* Ensure INITIATING_FRAME is cleared when no such breakpoint exists.
12824 It gets cleared already on the removal of the first one of such placed
12825 breakpoints. This is OK as they get all removed altogether. */
12827 longjmp_breakpoint::~longjmp_breakpoint ()
12829 thread_info
*tp
= find_thread_global_id (this->thread
);
12832 tp
->initiating_frame
= null_frame_id
;
12835 /* Specific methods for probe breakpoints. */
12838 bkpt_probe_insert_location (struct bp_location
*bl
)
12840 int v
= bkpt_insert_location (bl
);
12844 /* The insertion was successful, now let's set the probe's semaphore
12846 bl
->probe
.prob
->set_semaphore (bl
->probe
.objfile
, bl
->gdbarch
);
12853 bkpt_probe_remove_location (struct bp_location
*bl
,
12854 enum remove_bp_reason reason
)
12856 /* Let's clear the semaphore before removing the location. */
12857 bl
->probe
.prob
->clear_semaphore (bl
->probe
.objfile
, bl
->gdbarch
);
12859 return bkpt_remove_location (bl
, reason
);
12863 bkpt_probe_create_sals_from_location (struct event_location
*location
,
12864 struct linespec_result
*canonical
,
12865 enum bptype type_wanted
)
12867 struct linespec_sals lsal
;
12869 lsal
.sals
= parse_probes (location
, NULL
, canonical
);
12871 = xstrdup (event_location_to_string (canonical
->location
.get ()));
12872 canonical
->lsals
.push_back (std::move (lsal
));
12875 static std::vector
<symtab_and_line
>
12876 bkpt_probe_decode_location (struct breakpoint
*b
,
12877 struct event_location
*location
,
12878 struct program_space
*search_pspace
)
12880 std::vector
<symtab_and_line
> sals
= parse_probes (location
, search_pspace
, NULL
);
12882 error (_("probe not found"));
12886 /* The breakpoint_ops structure to be used in tracepoints. */
12889 tracepoint_re_set (struct breakpoint
*b
)
12891 breakpoint_re_set_default (b
);
12895 tracepoint_breakpoint_hit (const struct bp_location
*bl
,
12896 const address_space
*aspace
, CORE_ADDR bp_addr
,
12897 const struct target_waitstatus
*ws
)
12899 /* By definition, the inferior does not report stops at
12905 tracepoint_print_one_detail (const struct breakpoint
*self
,
12906 struct ui_out
*uiout
)
12908 struct tracepoint
*tp
= (struct tracepoint
*) self
;
12909 if (!tp
->static_trace_marker_id
.empty ())
12911 gdb_assert (self
->type
== bp_static_tracepoint
);
12913 uiout
->message ("\tmarker id is %pF\n",
12914 string_field ("static-tracepoint-marker-string-id",
12915 tp
->static_trace_marker_id
.c_str ()));
12920 tracepoint_print_mention (struct breakpoint
*b
)
12922 if (current_uiout
->is_mi_like_p ())
12927 case bp_tracepoint
:
12928 printf_filtered (_("Tracepoint"));
12929 printf_filtered (_(" %d"), b
->number
);
12931 case bp_fast_tracepoint
:
12932 printf_filtered (_("Fast tracepoint"));
12933 printf_filtered (_(" %d"), b
->number
);
12935 case bp_static_tracepoint
:
12936 printf_filtered (_("Static tracepoint"));
12937 printf_filtered (_(" %d"), b
->number
);
12940 internal_error (__FILE__
, __LINE__
,
12941 _("unhandled tracepoint type %d"), (int) b
->type
);
12948 tracepoint_print_recreate (struct breakpoint
*self
, struct ui_file
*fp
)
12950 struct tracepoint
*tp
= (struct tracepoint
*) self
;
12952 if (self
->type
== bp_fast_tracepoint
)
12953 fprintf_unfiltered (fp
, "ftrace");
12954 else if (self
->type
== bp_static_tracepoint
)
12955 fprintf_unfiltered (fp
, "strace");
12956 else if (self
->type
== bp_tracepoint
)
12957 fprintf_unfiltered (fp
, "trace");
12959 internal_error (__FILE__
, __LINE__
,
12960 _("unhandled tracepoint type %d"), (int) self
->type
);
12962 fprintf_unfiltered (fp
, " %s",
12963 event_location_to_string (self
->location
.get ()));
12964 print_recreate_thread (self
, fp
);
12966 if (tp
->pass_count
)
12967 fprintf_unfiltered (fp
, " passcount %d\n", tp
->pass_count
);
12971 tracepoint_create_sals_from_location (struct event_location
*location
,
12972 struct linespec_result
*canonical
,
12973 enum bptype type_wanted
)
12975 create_sals_from_location_default (location
, canonical
, type_wanted
);
12979 tracepoint_create_breakpoints_sal (struct gdbarch
*gdbarch
,
12980 struct linespec_result
*canonical
,
12981 gdb::unique_xmalloc_ptr
<char> cond_string
,
12982 gdb::unique_xmalloc_ptr
<char> extra_string
,
12983 enum bptype type_wanted
,
12984 enum bpdisp disposition
,
12986 int task
, int ignore_count
,
12987 const struct breakpoint_ops
*ops
,
12988 int from_tty
, int enabled
,
12989 int internal
, unsigned flags
)
12991 create_breakpoints_sal_default (gdbarch
, canonical
,
12992 std::move (cond_string
),
12993 std::move (extra_string
),
12995 disposition
, thread
, task
,
12996 ignore_count
, ops
, from_tty
,
12997 enabled
, internal
, flags
);
13000 static std::vector
<symtab_and_line
>
13001 tracepoint_decode_location (struct breakpoint
*b
,
13002 struct event_location
*location
,
13003 struct program_space
*search_pspace
)
13005 return decode_location_default (b
, location
, search_pspace
);
13008 struct breakpoint_ops tracepoint_breakpoint_ops
;
13010 /* Virtual table for tracepoints on static probes. */
13013 tracepoint_probe_create_sals_from_location
13014 (struct event_location
*location
,
13015 struct linespec_result
*canonical
,
13016 enum bptype type_wanted
)
13018 /* We use the same method for breakpoint on probes. */
13019 bkpt_probe_create_sals_from_location (location
, canonical
, type_wanted
);
13022 static std::vector
<symtab_and_line
>
13023 tracepoint_probe_decode_location (struct breakpoint
*b
,
13024 struct event_location
*location
,
13025 struct program_space
*search_pspace
)
13027 /* We use the same method for breakpoint on probes. */
13028 return bkpt_probe_decode_location (b
, location
, search_pspace
);
13031 /* Dprintf breakpoint_ops methods. */
13034 dprintf_re_set (struct breakpoint
*b
)
13036 breakpoint_re_set_default (b
);
13038 /* extra_string should never be non-NULL for dprintf. */
13039 gdb_assert (b
->extra_string
!= NULL
);
13041 /* 1 - connect to target 1, that can run breakpoint commands.
13042 2 - create a dprintf, which resolves fine.
13043 3 - disconnect from target 1
13044 4 - connect to target 2, that can NOT run breakpoint commands.
13046 After steps #3/#4, you'll want the dprintf command list to
13047 be updated, because target 1 and 2 may well return different
13048 answers for target_can_run_breakpoint_commands().
13049 Given absence of finer grained resetting, we get to do
13050 it all the time. */
13051 if (b
->extra_string
!= NULL
)
13052 update_dprintf_command_list (b
);
13055 /* Implement the "print_recreate" breakpoint_ops method for dprintf. */
13058 dprintf_print_recreate (struct breakpoint
*tp
, struct ui_file
*fp
)
13060 fprintf_unfiltered (fp
, "dprintf %s,%s",
13061 event_location_to_string (tp
->location
.get ()),
13063 print_recreate_thread (tp
, fp
);
13066 /* Implement the "after_condition_true" breakpoint_ops method for
13069 dprintf's are implemented with regular commands in their command
13070 list, but we run the commands here instead of before presenting the
13071 stop to the user, as dprintf's don't actually cause a stop. This
13072 also makes it so that the commands of multiple dprintfs at the same
13073 address are all handled. */
13076 dprintf_after_condition_true (struct bpstats
*bs
)
13078 struct bpstats tmp_bs
;
13079 struct bpstats
*tmp_bs_p
= &tmp_bs
;
13081 /* dprintf's never cause a stop. This wasn't set in the
13082 check_status hook instead because that would make the dprintf's
13083 condition not be evaluated. */
13086 /* Run the command list here. Take ownership of it instead of
13087 copying. We never want these commands to run later in
13088 bpstat_do_actions, if a breakpoint that causes a stop happens to
13089 be set at same address as this dprintf, or even if running the
13090 commands here throws. */
13091 tmp_bs
.commands
= bs
->commands
;
13092 bs
->commands
= NULL
;
13094 bpstat_do_actions_1 (&tmp_bs_p
);
13096 /* 'tmp_bs.commands' will usually be NULL by now, but
13097 bpstat_do_actions_1 may return early without processing the whole
13101 /* The breakpoint_ops structure to be used on static tracepoints with
13105 strace_marker_create_sals_from_location (struct event_location
*location
,
13106 struct linespec_result
*canonical
,
13107 enum bptype type_wanted
)
13109 struct linespec_sals lsal
;
13110 const char *arg_start
, *arg
;
13112 arg
= arg_start
= get_linespec_location (location
)->spec_string
;
13113 lsal
.sals
= decode_static_tracepoint_spec (&arg
);
13115 std::string
str (arg_start
, arg
- arg_start
);
13116 const char *ptr
= str
.c_str ();
13117 canonical
->location
13118 = new_linespec_location (&ptr
, symbol_name_match_type::FULL
);
13121 = xstrdup (event_location_to_string (canonical
->location
.get ()));
13122 canonical
->lsals
.push_back (std::move (lsal
));
13126 strace_marker_create_breakpoints_sal (struct gdbarch
*gdbarch
,
13127 struct linespec_result
*canonical
,
13128 gdb::unique_xmalloc_ptr
<char> cond_string
,
13129 gdb::unique_xmalloc_ptr
<char> extra_string
,
13130 enum bptype type_wanted
,
13131 enum bpdisp disposition
,
13133 int task
, int ignore_count
,
13134 const struct breakpoint_ops
*ops
,
13135 int from_tty
, int enabled
,
13136 int internal
, unsigned flags
)
13138 const linespec_sals
&lsal
= canonical
->lsals
[0];
13140 /* If the user is creating a static tracepoint by marker id
13141 (strace -m MARKER_ID), then store the sals index, so that
13142 breakpoint_re_set can try to match up which of the newly
13143 found markers corresponds to this one, and, don't try to
13144 expand multiple locations for each sal, given than SALS
13145 already should contain all sals for MARKER_ID. */
13147 for (size_t i
= 0; i
< lsal
.sals
.size (); i
++)
13149 event_location_up location
13150 = copy_event_location (canonical
->location
.get ());
13152 std::unique_ptr
<tracepoint
> tp (new tracepoint ());
13153 init_breakpoint_sal (tp
.get (), gdbarch
, lsal
.sals
[i
],
13154 std::move (location
), NULL
,
13155 std::move (cond_string
),
13156 std::move (extra_string
),
13157 type_wanted
, disposition
,
13158 thread
, task
, ignore_count
, ops
,
13159 from_tty
, enabled
, internal
, flags
,
13160 canonical
->special_display
);
13161 /* Given that its possible to have multiple markers with
13162 the same string id, if the user is creating a static
13163 tracepoint by marker id ("strace -m MARKER_ID"), then
13164 store the sals index, so that breakpoint_re_set can
13165 try to match up which of the newly found markers
13166 corresponds to this one */
13167 tp
->static_trace_marker_id_idx
= i
;
13169 install_breakpoint (internal
, std::move (tp
), 0);
13173 static std::vector
<symtab_and_line
>
13174 strace_marker_decode_location (struct breakpoint
*b
,
13175 struct event_location
*location
,
13176 struct program_space
*search_pspace
)
13178 struct tracepoint
*tp
= (struct tracepoint
*) b
;
13179 const char *s
= get_linespec_location (location
)->spec_string
;
13181 std::vector
<symtab_and_line
> sals
= decode_static_tracepoint_spec (&s
);
13182 if (sals
.size () > tp
->static_trace_marker_id_idx
)
13184 sals
[0] = sals
[tp
->static_trace_marker_id_idx
];
13189 error (_("marker %s not found"), tp
->static_trace_marker_id
.c_str ());
13192 static struct breakpoint_ops strace_marker_breakpoint_ops
;
13195 strace_marker_p (struct breakpoint
*b
)
13197 return b
->ops
== &strace_marker_breakpoint_ops
;
13200 /* Delete a breakpoint and clean up all traces of it in the data
13204 delete_breakpoint (struct breakpoint
*bpt
)
13206 gdb_assert (bpt
!= NULL
);
13208 /* Has this bp already been deleted? This can happen because
13209 multiple lists can hold pointers to bp's. bpstat lists are
13212 One example of this happening is a watchpoint's scope bp. When
13213 the scope bp triggers, we notice that the watchpoint is out of
13214 scope, and delete it. We also delete its scope bp. But the
13215 scope bp is marked "auto-deleting", and is already on a bpstat.
13216 That bpstat is then checked for auto-deleting bp's, which are
13219 A real solution to this problem might involve reference counts in
13220 bp's, and/or giving them pointers back to their referencing
13221 bpstat's, and teaching delete_breakpoint to only free a bp's
13222 storage when no more references were extent. A cheaper bandaid
13224 if (bpt
->type
== bp_none
)
13227 /* At least avoid this stale reference until the reference counting
13228 of breakpoints gets resolved. */
13229 if (bpt
->related_breakpoint
!= bpt
)
13231 struct breakpoint
*related
;
13232 struct watchpoint
*w
;
13234 if (bpt
->type
== bp_watchpoint_scope
)
13235 w
= (struct watchpoint
*) bpt
->related_breakpoint
;
13236 else if (bpt
->related_breakpoint
->type
== bp_watchpoint_scope
)
13237 w
= (struct watchpoint
*) bpt
;
13241 watchpoint_del_at_next_stop (w
);
13243 /* Unlink bpt from the bpt->related_breakpoint ring. */
13244 for (related
= bpt
; related
->related_breakpoint
!= bpt
;
13245 related
= related
->related_breakpoint
);
13246 related
->related_breakpoint
= bpt
->related_breakpoint
;
13247 bpt
->related_breakpoint
= bpt
;
13250 /* watch_command_1 creates a watchpoint but only sets its number if
13251 update_watchpoint succeeds in creating its bp_locations. If there's
13252 a problem in that process, we'll be asked to delete the half-created
13253 watchpoint. In that case, don't announce the deletion. */
13255 gdb::observers::breakpoint_deleted
.notify (bpt
);
13257 if (breakpoint_chain
== bpt
)
13258 breakpoint_chain
= bpt
->next
;
13260 for (breakpoint
*b
: all_breakpoints ())
13261 if (b
->next
== bpt
)
13263 b
->next
= bpt
->next
;
13267 /* Be sure no bpstat's are pointing at the breakpoint after it's
13269 /* FIXME, how can we find all bpstat's? We just check stop_bpstat
13270 in all threads for now. Note that we cannot just remove bpstats
13271 pointing at bpt from the stop_bpstat list entirely, as breakpoint
13272 commands are associated with the bpstat; if we remove it here,
13273 then the later call to bpstat_do_actions (&stop_bpstat); in
13274 event-top.c won't do anything, and temporary breakpoints with
13275 commands won't work. */
13277 iterate_over_threads (bpstat_remove_breakpoint_callback
, bpt
);
13279 /* Now that breakpoint is removed from breakpoint list, update the
13280 global location list. This will remove locations that used to
13281 belong to this breakpoint. Do this before freeing the breakpoint
13282 itself, since remove_breakpoint looks at location's owner. It
13283 might be better design to have location completely
13284 self-contained, but it's not the case now. */
13285 update_global_location_list (UGLL_DONT_INSERT
);
13287 /* On the chance that someone will soon try again to delete this
13288 same bp, we mark it as deleted before freeing its storage. */
13289 bpt
->type
= bp_none
;
13293 /* Iterator function to call a user-provided callback function once
13294 for each of B and its related breakpoints. */
13297 iterate_over_related_breakpoints (struct breakpoint
*b
,
13298 gdb::function_view
<void (breakpoint
*)> function
)
13300 struct breakpoint
*related
;
13305 struct breakpoint
*next
;
13307 /* FUNCTION may delete RELATED. */
13308 next
= related
->related_breakpoint
;
13310 if (next
== related
)
13312 /* RELATED is the last ring entry. */
13313 function (related
);
13315 /* FUNCTION may have deleted it, so we'd never reach back to
13316 B. There's nothing left to do anyway, so just break
13321 function (related
);
13325 while (related
!= b
);
13329 delete_command (const char *arg
, int from_tty
)
13335 int breaks_to_delete
= 0;
13337 /* Delete all breakpoints if no argument. Do not delete
13338 internal breakpoints, these have to be deleted with an
13339 explicit breakpoint number argument. */
13340 for (breakpoint
*b
: all_breakpoints ())
13341 if (user_breakpoint_p (b
))
13343 breaks_to_delete
= 1;
13347 /* Ask user only if there are some breakpoints to delete. */
13349 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
13350 for (breakpoint
*b
: all_breakpoints_safe ())
13351 if (user_breakpoint_p (b
))
13352 delete_breakpoint (b
);
13355 map_breakpoint_numbers
13356 (arg
, [&] (breakpoint
*br
)
13358 iterate_over_related_breakpoints (br
, delete_breakpoint
);
13362 /* Return true if all locations of B bound to PSPACE are pending. If
13363 PSPACE is NULL, all locations of all program spaces are
13367 all_locations_are_pending (struct breakpoint
*b
, struct program_space
*pspace
)
13369 for (bp_location
*loc
: b
->locations ())
13370 if ((pspace
== NULL
13371 || loc
->pspace
== pspace
)
13372 && !loc
->shlib_disabled
13373 && !loc
->pspace
->executing_startup
)
13378 /* Subroutine of update_breakpoint_locations to simplify it.
13379 Return non-zero if multiple fns in list LOC have the same name.
13380 Null names are ignored. */
13383 ambiguous_names_p (struct bp_location
*loc
)
13385 struct bp_location
*l
;
13386 htab_up
htab (htab_create_alloc (13, htab_hash_string
, htab_eq_string
, NULL
,
13389 for (l
= loc
; l
!= NULL
; l
= l
->next
)
13392 const char *name
= l
->function_name
;
13394 /* Allow for some names to be NULL, ignore them. */
13398 slot
= (const char **) htab_find_slot (htab
.get (), (const void *) name
,
13400 /* NOTE: We can assume slot != NULL here because xcalloc never
13410 /* When symbols change, it probably means the sources changed as well,
13411 and it might mean the static tracepoint markers are no longer at
13412 the same address or line numbers they used to be at last we
13413 checked. Losing your static tracepoints whenever you rebuild is
13414 undesirable. This function tries to resync/rematch gdb static
13415 tracepoints with the markers on the target, for static tracepoints
13416 that have not been set by marker id. Static tracepoint that have
13417 been set by marker id are reset by marker id in breakpoint_re_set.
13420 1) For a tracepoint set at a specific address, look for a marker at
13421 the old PC. If one is found there, assume to be the same marker.
13422 If the name / string id of the marker found is different from the
13423 previous known name, assume that means the user renamed the marker
13424 in the sources, and output a warning.
13426 2) For a tracepoint set at a given line number, look for a marker
13427 at the new address of the old line number. If one is found there,
13428 assume to be the same marker. If the name / string id of the
13429 marker found is different from the previous known name, assume that
13430 means the user renamed the marker in the sources, and output a
13433 3) If a marker is no longer found at the same address or line, it
13434 may mean the marker no longer exists. But it may also just mean
13435 the code changed a bit. Maybe the user added a few lines of code
13436 that made the marker move up or down (in line number terms). Ask
13437 the target for info about the marker with the string id as we knew
13438 it. If found, update line number and address in the matching
13439 static tracepoint. This will get confused if there's more than one
13440 marker with the same ID (possible in UST, although unadvised
13441 precisely because it confuses tools). */
13443 static struct symtab_and_line
13444 update_static_tracepoint (struct breakpoint
*b
, struct symtab_and_line sal
)
13446 struct tracepoint
*tp
= (struct tracepoint
*) b
;
13447 struct static_tracepoint_marker marker
;
13452 find_line_pc (sal
.symtab
, sal
.line
, &pc
);
13454 if (target_static_tracepoint_marker_at (pc
, &marker
))
13456 if (tp
->static_trace_marker_id
!= marker
.str_id
)
13457 warning (_("static tracepoint %d changed probed marker from %s to %s"),
13458 b
->number
, tp
->static_trace_marker_id
.c_str (),
13459 marker
.str_id
.c_str ());
13461 tp
->static_trace_marker_id
= std::move (marker
.str_id
);
13466 /* Old marker wasn't found on target at lineno. Try looking it up
13468 if (!sal
.explicit_pc
13470 && sal
.symtab
!= NULL
13471 && !tp
->static_trace_marker_id
.empty ())
13473 std::vector
<static_tracepoint_marker
> markers
13474 = target_static_tracepoint_markers_by_strid
13475 (tp
->static_trace_marker_id
.c_str ());
13477 if (!markers
.empty ())
13479 struct symbol
*sym
;
13480 struct static_tracepoint_marker
*tpmarker
;
13481 struct ui_out
*uiout
= current_uiout
;
13482 struct explicit_location explicit_loc
;
13484 tpmarker
= &markers
[0];
13486 tp
->static_trace_marker_id
= std::move (tpmarker
->str_id
);
13488 warning (_("marker for static tracepoint %d (%s) not "
13489 "found at previous line number"),
13490 b
->number
, tp
->static_trace_marker_id
.c_str ());
13492 symtab_and_line sal2
= find_pc_line (tpmarker
->address
, 0);
13493 sym
= find_pc_sect_function (tpmarker
->address
, NULL
);
13494 uiout
->text ("Now in ");
13497 uiout
->field_string ("func", sym
->print_name (),
13498 function_name_style
.style ());
13499 uiout
->text (" at ");
13501 uiout
->field_string ("file",
13502 symtab_to_filename_for_display (sal2
.symtab
),
13503 file_name_style
.style ());
13506 if (uiout
->is_mi_like_p ())
13508 const char *fullname
= symtab_to_fullname (sal2
.symtab
);
13510 uiout
->field_string ("fullname", fullname
);
13513 uiout
->field_signed ("line", sal2
.line
);
13514 uiout
->text ("\n");
13516 b
->loc
->line_number
= sal2
.line
;
13517 b
->loc
->symtab
= sym
!= NULL
? sal2
.symtab
: NULL
;
13519 b
->location
.reset (NULL
);
13520 initialize_explicit_location (&explicit_loc
);
13521 explicit_loc
.source_filename
13522 = ASTRDUP (symtab_to_filename_for_display (sal2
.symtab
));
13523 explicit_loc
.line_offset
.offset
= b
->loc
->line_number
;
13524 explicit_loc
.line_offset
.sign
= LINE_OFFSET_NONE
;
13525 b
->location
= new_explicit_location (&explicit_loc
);
13527 /* Might be nice to check if function changed, and warn if
13534 /* Returns 1 iff locations A and B are sufficiently same that
13535 we don't need to report breakpoint as changed. */
13538 locations_are_equal (struct bp_location
*a
, struct bp_location
*b
)
13542 if (a
->address
!= b
->address
)
13545 if (a
->shlib_disabled
!= b
->shlib_disabled
)
13548 if (a
->enabled
!= b
->enabled
)
13551 if (a
->disabled_by_cond
!= b
->disabled_by_cond
)
13558 if ((a
== NULL
) != (b
== NULL
))
13564 /* Split all locations of B that are bound to PSPACE out of B's
13565 location list to a separate list and return that list's head. If
13566 PSPACE is NULL, hoist out all locations of B. */
13568 static struct bp_location
*
13569 hoist_existing_locations (struct breakpoint
*b
, struct program_space
*pspace
)
13571 struct bp_location head
;
13572 struct bp_location
*i
= b
->loc
;
13573 struct bp_location
**i_link
= &b
->loc
;
13574 struct bp_location
*hoisted
= &head
;
13576 if (pspace
== NULL
)
13587 if (i
->pspace
== pspace
)
13602 /* Create new breakpoint locations for B (a hardware or software
13603 breakpoint) based on SALS and SALS_END. If SALS_END.NELTS is not
13604 zero, then B is a ranged breakpoint. Only recreates locations for
13605 FILTER_PSPACE. Locations of other program spaces are left
13609 update_breakpoint_locations (struct breakpoint
*b
,
13610 struct program_space
*filter_pspace
,
13611 gdb::array_view
<const symtab_and_line
> sals
,
13612 gdb::array_view
<const symtab_and_line
> sals_end
)
13614 struct bp_location
*existing_locations
;
13616 if (!sals_end
.empty () && (sals
.size () != 1 || sals_end
.size () != 1))
13618 /* Ranged breakpoints have only one start location and one end
13620 b
->enable_state
= bp_disabled
;
13621 printf_unfiltered (_("Could not reset ranged breakpoint %d: "
13622 "multiple locations found\n"),
13627 /* If there's no new locations, and all existing locations are
13628 pending, don't do anything. This optimizes the common case where
13629 all locations are in the same shared library, that was unloaded.
13630 We'd like to retain the location, so that when the library is
13631 loaded again, we don't loose the enabled/disabled status of the
13632 individual locations. */
13633 if (all_locations_are_pending (b
, filter_pspace
) && sals
.empty ())
13636 existing_locations
= hoist_existing_locations (b
, filter_pspace
);
13638 for (const auto &sal
: sals
)
13640 struct bp_location
*new_loc
;
13642 switch_to_program_space_and_thread (sal
.pspace
);
13644 new_loc
= add_location_to_breakpoint (b
, &sal
);
13646 /* Reparse conditions, they might contain references to the
13648 if (b
->cond_string
!= NULL
)
13652 s
= b
->cond_string
;
13655 new_loc
->cond
= parse_exp_1 (&s
, sal
.pc
,
13656 block_for_pc (sal
.pc
),
13659 catch (const gdb_exception_error
&e
)
13661 new_loc
->disabled_by_cond
= true;
13665 if (!sals_end
.empty ())
13667 CORE_ADDR end
= find_breakpoint_range_end (sals_end
[0]);
13669 new_loc
->length
= end
- sals
[0].pc
+ 1;
13673 /* If possible, carry over 'disable' status from existing
13676 struct bp_location
*e
= existing_locations
;
13677 /* If there are multiple breakpoints with the same function name,
13678 e.g. for inline functions, comparing function names won't work.
13679 Instead compare pc addresses; this is just a heuristic as things
13680 may have moved, but in practice it gives the correct answer
13681 often enough until a better solution is found. */
13682 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
13684 for (; e
; e
= e
->next
)
13686 if ((!e
->enabled
|| e
->disabled_by_cond
) && e
->function_name
)
13688 if (have_ambiguous_names
)
13690 for (bp_location
*l
: b
->locations ())
13692 /* Ignore software vs hardware location type at
13693 this point, because with "set breakpoint
13694 auto-hw", after a re-set, locations that were
13695 hardware can end up as software, or vice versa.
13696 As mentioned above, this is an heuristic and in
13697 practice should give the correct answer often
13699 if (breakpoint_locations_match (e
, l
, true))
13701 l
->enabled
= e
->enabled
;
13702 l
->disabled_by_cond
= e
->disabled_by_cond
;
13709 for (bp_location
*l
: b
->locations ())
13710 if (l
->function_name
13711 && strcmp (e
->function_name
, l
->function_name
) == 0)
13713 l
->enabled
= e
->enabled
;
13714 l
->disabled_by_cond
= e
->disabled_by_cond
;
13722 if (!locations_are_equal (existing_locations
, b
->loc
))
13723 gdb::observers::breakpoint_modified
.notify (b
);
13726 /* Find the SaL locations corresponding to the given LOCATION.
13727 On return, FOUND will be 1 if any SaL was found, zero otherwise. */
13729 static std::vector
<symtab_and_line
>
13730 location_to_sals (struct breakpoint
*b
, struct event_location
*location
,
13731 struct program_space
*search_pspace
, int *found
)
13733 struct gdb_exception exception
;
13735 gdb_assert (b
->ops
!= NULL
);
13737 std::vector
<symtab_and_line
> sals
;
13741 sals
= b
->ops
->decode_location (b
, location
, search_pspace
);
13743 catch (gdb_exception_error
&e
)
13745 int not_found_and_ok
= 0;
13747 /* For pending breakpoints, it's expected that parsing will
13748 fail until the right shared library is loaded. User has
13749 already told to create pending breakpoints and don't need
13750 extra messages. If breakpoint is in bp_shlib_disabled
13751 state, then user already saw the message about that
13752 breakpoint being disabled, and don't want to see more
13754 if (e
.error
== NOT_FOUND_ERROR
13755 && (b
->condition_not_parsed
13757 && search_pspace
!= NULL
13758 && b
->loc
->pspace
!= search_pspace
)
13759 || (b
->loc
&& b
->loc
->shlib_disabled
)
13760 || (b
->loc
&& b
->loc
->pspace
->executing_startup
)
13761 || b
->enable_state
== bp_disabled
))
13762 not_found_and_ok
= 1;
13764 if (!not_found_and_ok
)
13766 /* We surely don't want to warn about the same breakpoint
13767 10 times. One solution, implemented here, is disable
13768 the breakpoint on error. Another solution would be to
13769 have separate 'warning emitted' flag. Since this
13770 happens only when a binary has changed, I don't know
13771 which approach is better. */
13772 b
->enable_state
= bp_disabled
;
13776 exception
= std::move (e
);
13779 if (exception
.reason
== 0 || exception
.error
!= NOT_FOUND_ERROR
)
13781 for (auto &sal
: sals
)
13782 resolve_sal_pc (&sal
);
13783 if (b
->condition_not_parsed
&& b
->extra_string
!= NULL
)
13785 char *cond_string
, *extra_string
;
13788 find_condition_and_thread_for_sals (sals
, b
->extra_string
,
13789 &cond_string
, &thread
,
13790 &task
, &extra_string
);
13791 gdb_assert (b
->cond_string
== NULL
);
13793 b
->cond_string
= cond_string
;
13794 b
->thread
= thread
;
13798 xfree (b
->extra_string
);
13799 b
->extra_string
= extra_string
;
13801 b
->condition_not_parsed
= 0;
13804 if (b
->type
== bp_static_tracepoint
&& !strace_marker_p (b
))
13805 sals
[0] = update_static_tracepoint (b
, sals
[0]);
13815 /* The default re_set method, for typical hardware or software
13816 breakpoints. Reevaluate the breakpoint and recreate its
13820 breakpoint_re_set_default (struct breakpoint
*b
)
13822 struct program_space
*filter_pspace
= current_program_space
;
13823 std::vector
<symtab_and_line
> expanded
, expanded_end
;
13826 std::vector
<symtab_and_line
> sals
= location_to_sals (b
, b
->location
.get (),
13827 filter_pspace
, &found
);
13829 expanded
= std::move (sals
);
13831 if (b
->location_range_end
!= NULL
)
13833 std::vector
<symtab_and_line
> sals_end
13834 = location_to_sals (b
, b
->location_range_end
.get (),
13835 filter_pspace
, &found
);
13837 expanded_end
= std::move (sals_end
);
13840 update_breakpoint_locations (b
, filter_pspace
, expanded
, expanded_end
);
13843 /* Default method for creating SALs from an address string. It basically
13844 calls parse_breakpoint_sals. Return 1 for success, zero for failure. */
13847 create_sals_from_location_default (struct event_location
*location
,
13848 struct linespec_result
*canonical
,
13849 enum bptype type_wanted
)
13851 parse_breakpoint_sals (location
, canonical
);
13854 /* Call create_breakpoints_sal for the given arguments. This is the default
13855 function for the `create_breakpoints_sal' method of
13859 create_breakpoints_sal_default (struct gdbarch
*gdbarch
,
13860 struct linespec_result
*canonical
,
13861 gdb::unique_xmalloc_ptr
<char> cond_string
,
13862 gdb::unique_xmalloc_ptr
<char> extra_string
,
13863 enum bptype type_wanted
,
13864 enum bpdisp disposition
,
13866 int task
, int ignore_count
,
13867 const struct breakpoint_ops
*ops
,
13868 int from_tty
, int enabled
,
13869 int internal
, unsigned flags
)
13871 create_breakpoints_sal (gdbarch
, canonical
,
13872 std::move (cond_string
),
13873 std::move (extra_string
),
13874 type_wanted
, disposition
,
13875 thread
, task
, ignore_count
, ops
, from_tty
,
13876 enabled
, internal
, flags
);
13879 /* Decode the line represented by S by calling decode_line_full. This is the
13880 default function for the `decode_location' method of breakpoint_ops. */
13882 static std::vector
<symtab_and_line
>
13883 decode_location_default (struct breakpoint
*b
,
13884 struct event_location
*location
,
13885 struct program_space
*search_pspace
)
13887 struct linespec_result canonical
;
13889 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, search_pspace
,
13890 NULL
, 0, &canonical
, multiple_symbols_all
,
13893 /* We should get 0 or 1 resulting SALs. */
13894 gdb_assert (canonical
.lsals
.size () < 2);
13896 if (!canonical
.lsals
.empty ())
13898 const linespec_sals
&lsal
= canonical
.lsals
[0];
13899 return std::move (lsal
.sals
);
13904 /* Reset a breakpoint. */
13907 breakpoint_re_set_one (breakpoint
*b
)
13909 input_radix
= b
->input_radix
;
13910 set_language (b
->language
);
13912 b
->ops
->re_set (b
);
13915 /* Re-set breakpoint locations for the current program space.
13916 Locations bound to other program spaces are left untouched. */
13919 breakpoint_re_set (void)
13922 scoped_restore_current_language save_language
;
13923 scoped_restore save_input_radix
= make_scoped_restore (&input_radix
);
13924 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
13926 /* breakpoint_re_set_one sets the current_language to the language
13927 of the breakpoint it is resetting (see prepare_re_set_context)
13928 before re-evaluating the breakpoint's location. This change can
13929 unfortunately get undone by accident if the language_mode is set
13930 to auto, and we either switch frames, or more likely in this context,
13931 we select the current frame.
13933 We prevent this by temporarily turning the language_mode to
13934 language_mode_manual. We restore it once all breakpoints
13935 have been reset. */
13936 scoped_restore save_language_mode
= make_scoped_restore (&language_mode
);
13937 language_mode
= language_mode_manual
;
13939 /* Note: we must not try to insert locations until after all
13940 breakpoints have been re-set. Otherwise, e.g., when re-setting
13941 breakpoint 1, we'd insert the locations of breakpoint 2, which
13942 hadn't been re-set yet, and thus may have stale locations. */
13944 for (breakpoint
*b
: all_breakpoints_safe ())
13948 breakpoint_re_set_one (b
);
13950 catch (const gdb_exception
&ex
)
13952 exception_fprintf (gdb_stderr
, ex
,
13953 "Error in re-setting breakpoint %d: ",
13958 jit_breakpoint_re_set ();
13961 create_overlay_event_breakpoint ();
13962 create_longjmp_master_breakpoint ();
13963 create_std_terminate_master_breakpoint ();
13964 create_exception_master_breakpoint ();
13966 /* Now we can insert. */
13967 update_global_location_list (UGLL_MAY_INSERT
);
13970 /* Reset the thread number of this breakpoint:
13972 - If the breakpoint is for all threads, leave it as-is.
13973 - Else, reset it to the current thread for inferior_ptid. */
13975 breakpoint_re_set_thread (struct breakpoint
*b
)
13977 if (b
->thread
!= -1)
13979 b
->thread
= inferior_thread ()->global_num
;
13981 /* We're being called after following a fork. The new fork is
13982 selected as current, and unless this was a vfork will have a
13983 different program space from the original thread. Reset that
13985 b
->loc
->pspace
= current_program_space
;
13989 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
13990 If from_tty is nonzero, it prints a message to that effect,
13991 which ends with a period (no newline). */
13994 set_ignore_count (int bptnum
, int count
, int from_tty
)
13999 for (breakpoint
*b
: all_breakpoints ())
14000 if (b
->number
== bptnum
)
14002 if (is_tracepoint (b
))
14004 if (from_tty
&& count
!= 0)
14005 printf_filtered (_("Ignore count ignored for tracepoint %d."),
14010 b
->ignore_count
= count
;
14014 printf_filtered (_("Will stop next time "
14015 "breakpoint %d is reached."),
14017 else if (count
== 1)
14018 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
14021 printf_filtered (_("Will ignore next %d "
14022 "crossings of breakpoint %d."),
14025 gdb::observers::breakpoint_modified
.notify (b
);
14029 error (_("No breakpoint number %d."), bptnum
);
14032 /* Command to set ignore-count of breakpoint N to COUNT. */
14035 ignore_command (const char *args
, int from_tty
)
14037 const char *p
= args
;
14041 error_no_arg (_("a breakpoint number"));
14043 num
= get_number (&p
);
14045 error (_("bad breakpoint number: '%s'"), args
);
14047 error (_("Second argument (specified ignore-count) is missing."));
14049 set_ignore_count (num
,
14050 longest_to_int (value_as_long (parse_and_eval (p
))),
14053 printf_filtered ("\n");
14057 /* Call FUNCTION on each of the breakpoints with numbers in the range
14058 defined by BP_NUM_RANGE (an inclusive range). */
14061 map_breakpoint_number_range (std::pair
<int, int> bp_num_range
,
14062 gdb::function_view
<void (breakpoint
*)> function
)
14064 if (bp_num_range
.first
== 0)
14066 warning (_("bad breakpoint number at or near '%d'"),
14067 bp_num_range
.first
);
14071 for (int i
= bp_num_range
.first
; i
<= bp_num_range
.second
; i
++)
14073 bool match
= false;
14075 for (breakpoint
*b
: all_breakpoints_safe ())
14076 if (b
->number
== i
)
14083 printf_unfiltered (_("No breakpoint number %d.\n"), i
);
14088 /* Call FUNCTION on each of the breakpoints whose numbers are given in
14092 map_breakpoint_numbers (const char *args
,
14093 gdb::function_view
<void (breakpoint
*)> function
)
14095 if (args
== NULL
|| *args
== '\0')
14096 error_no_arg (_("one or more breakpoint numbers"));
14098 number_or_range_parser
parser (args
);
14100 while (!parser
.finished ())
14102 int num
= parser
.get_number ();
14103 map_breakpoint_number_range (std::make_pair (num
, num
), function
);
14107 /* Return the breakpoint location structure corresponding to the
14108 BP_NUM and LOC_NUM values. */
14110 static struct bp_location
*
14111 find_location_by_number (int bp_num
, int loc_num
)
14113 breakpoint
*b
= get_breakpoint (bp_num
);
14115 if (!b
|| b
->number
!= bp_num
)
14116 error (_("Bad breakpoint number '%d'"), bp_num
);
14119 error (_("Bad breakpoint location number '%d'"), loc_num
);
14122 for (bp_location
*loc
: b
->locations ())
14123 if (++n
== loc_num
)
14126 error (_("Bad breakpoint location number '%d'"), loc_num
);
14129 /* Modes of operation for extract_bp_num. */
14130 enum class extract_bp_kind
14132 /* Extracting a breakpoint number. */
14135 /* Extracting a location number. */
14139 /* Extract a breakpoint or location number (as determined by KIND)
14140 from the string starting at START. TRAILER is a character which
14141 can be found after the number. If you don't want a trailer, use
14142 '\0'. If END_OUT is not NULL, it is set to point after the parsed
14143 string. This always returns a positive integer. */
14146 extract_bp_num (extract_bp_kind kind
, const char *start
,
14147 int trailer
, const char **end_out
= NULL
)
14149 const char *end
= start
;
14150 int num
= get_number_trailer (&end
, trailer
);
14152 error (kind
== extract_bp_kind::bp
14153 ? _("Negative breakpoint number '%.*s'")
14154 : _("Negative breakpoint location number '%.*s'"),
14155 int (end
- start
), start
);
14157 error (kind
== extract_bp_kind::bp
14158 ? _("Bad breakpoint number '%.*s'")
14159 : _("Bad breakpoint location number '%.*s'"),
14160 int (end
- start
), start
);
14162 if (end_out
!= NULL
)
14167 /* Extract a breakpoint or location range (as determined by KIND) in
14168 the form NUM1-NUM2 stored at &ARG[arg_offset]. Returns a std::pair
14169 representing the (inclusive) range. The returned pair's elements
14170 are always positive integers. */
14172 static std::pair
<int, int>
14173 extract_bp_or_bp_range (extract_bp_kind kind
,
14174 const std::string
&arg
,
14175 std::string::size_type arg_offset
)
14177 std::pair
<int, int> range
;
14178 const char *bp_loc
= &arg
[arg_offset
];
14179 std::string::size_type dash
= arg
.find ('-', arg_offset
);
14180 if (dash
!= std::string::npos
)
14182 /* bp_loc is a range (x-z). */
14183 if (arg
.length () == dash
+ 1)
14184 error (kind
== extract_bp_kind::bp
14185 ? _("Bad breakpoint number at or near: '%s'")
14186 : _("Bad breakpoint location number at or near: '%s'"),
14190 const char *start_first
= bp_loc
;
14191 const char *start_second
= &arg
[dash
+ 1];
14192 range
.first
= extract_bp_num (kind
, start_first
, '-');
14193 range
.second
= extract_bp_num (kind
, start_second
, '\0', &end
);
14195 if (range
.first
> range
.second
)
14196 error (kind
== extract_bp_kind::bp
14197 ? _("Inverted breakpoint range at '%.*s'")
14198 : _("Inverted breakpoint location range at '%.*s'"),
14199 int (end
- start_first
), start_first
);
14203 /* bp_loc is a single value. */
14204 range
.first
= extract_bp_num (kind
, bp_loc
, '\0');
14205 range
.second
= range
.first
;
14210 /* Extract the breakpoint/location range specified by ARG. Returns
14211 the breakpoint range in BP_NUM_RANGE, and the location range in
14214 ARG may be in any of the following forms:
14216 x where 'x' is a breakpoint number.
14217 x-y where 'x' and 'y' specify a breakpoint numbers range.
14218 x.y where 'x' is a breakpoint number and 'y' a location number.
14219 x.y-z where 'x' is a breakpoint number and 'y' and 'z' specify a
14220 location number range.
14224 extract_bp_number_and_location (const std::string
&arg
,
14225 std::pair
<int, int> &bp_num_range
,
14226 std::pair
<int, int> &bp_loc_range
)
14228 std::string::size_type dot
= arg
.find ('.');
14230 if (dot
!= std::string::npos
)
14232 /* Handle 'x.y' and 'x.y-z' cases. */
14234 if (arg
.length () == dot
+ 1 || dot
== 0)
14235 error (_("Bad breakpoint number at or near: '%s'"), arg
.c_str ());
14238 = extract_bp_num (extract_bp_kind::bp
, arg
.c_str (), '.');
14239 bp_num_range
.second
= bp_num_range
.first
;
14241 bp_loc_range
= extract_bp_or_bp_range (extract_bp_kind::loc
,
14246 /* Handle x and x-y cases. */
14248 bp_num_range
= extract_bp_or_bp_range (extract_bp_kind::bp
, arg
, 0);
14249 bp_loc_range
.first
= 0;
14250 bp_loc_range
.second
= 0;
14254 /* Enable or disable a breakpoint location BP_NUM.LOC_NUM. ENABLE
14255 specifies whether to enable or disable. */
14258 enable_disable_bp_num_loc (int bp_num
, int loc_num
, bool enable
)
14260 struct bp_location
*loc
= find_location_by_number (bp_num
, loc_num
);
14263 if (loc
->disabled_by_cond
&& enable
)
14264 error (_("Breakpoint %d's condition is invalid at location %d, "
14265 "cannot enable."), bp_num
, loc_num
);
14267 if (loc
->enabled
!= enable
)
14269 loc
->enabled
= enable
;
14270 mark_breakpoint_location_modified (loc
);
14272 if (target_supports_enable_disable_tracepoint ()
14273 && current_trace_status ()->running
&& loc
->owner
14274 && is_tracepoint (loc
->owner
))
14275 target_disable_tracepoint (loc
);
14277 update_global_location_list (UGLL_DONT_INSERT
);
14279 gdb::observers::breakpoint_modified
.notify (loc
->owner
);
14282 /* Enable or disable a range of breakpoint locations. BP_NUM is the
14283 number of the breakpoint, and BP_LOC_RANGE specifies the
14284 (inclusive) range of location numbers of that breakpoint to
14285 enable/disable. ENABLE specifies whether to enable or disable the
14289 enable_disable_breakpoint_location_range (int bp_num
,
14290 std::pair
<int, int> &bp_loc_range
,
14293 for (int i
= bp_loc_range
.first
; i
<= bp_loc_range
.second
; i
++)
14294 enable_disable_bp_num_loc (bp_num
, i
, enable
);
14297 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14298 If from_tty is nonzero, it prints a message to that effect,
14299 which ends with a period (no newline). */
14302 disable_breakpoint (struct breakpoint
*bpt
)
14304 /* Never disable a watchpoint scope breakpoint; we want to
14305 hit them when we leave scope so we can delete both the
14306 watchpoint and its scope breakpoint at that time. */
14307 if (bpt
->type
== bp_watchpoint_scope
)
14310 bpt
->enable_state
= bp_disabled
;
14312 /* Mark breakpoint locations modified. */
14313 mark_breakpoint_modified (bpt
);
14315 if (target_supports_enable_disable_tracepoint ()
14316 && current_trace_status ()->running
&& is_tracepoint (bpt
))
14318 for (bp_location
*location
: bpt
->locations ())
14319 target_disable_tracepoint (location
);
14322 update_global_location_list (UGLL_DONT_INSERT
);
14324 gdb::observers::breakpoint_modified
.notify (bpt
);
14327 /* Enable or disable the breakpoint(s) or breakpoint location(s)
14328 specified in ARGS. ARGS may be in any of the formats handled by
14329 extract_bp_number_and_location. ENABLE specifies whether to enable
14330 or disable the breakpoints/locations. */
14333 enable_disable_command (const char *args
, int from_tty
, bool enable
)
14337 for (breakpoint
*bpt
: all_breakpoints ())
14338 if (user_breakpoint_p (bpt
))
14341 enable_breakpoint (bpt
);
14343 disable_breakpoint (bpt
);
14348 std::string num
= extract_arg (&args
);
14350 while (!num
.empty ())
14352 std::pair
<int, int> bp_num_range
, bp_loc_range
;
14354 extract_bp_number_and_location (num
, bp_num_range
, bp_loc_range
);
14356 if (bp_loc_range
.first
== bp_loc_range
.second
14357 && bp_loc_range
.first
== 0)
14359 /* Handle breakpoint ids with formats 'x' or 'x-z'. */
14360 map_breakpoint_number_range (bp_num_range
,
14362 ? enable_breakpoint
14363 : disable_breakpoint
);
14367 /* Handle breakpoint ids with formats 'x.y' or
14369 enable_disable_breakpoint_location_range
14370 (bp_num_range
.first
, bp_loc_range
, enable
);
14372 num
= extract_arg (&args
);
14377 /* The disable command disables the specified breakpoints/locations
14378 (or all defined breakpoints) so they're no longer effective in
14379 stopping the inferior. ARGS may be in any of the forms defined in
14380 extract_bp_number_and_location. */
14383 disable_command (const char *args
, int from_tty
)
14385 enable_disable_command (args
, from_tty
, false);
14389 enable_breakpoint_disp (struct breakpoint
*bpt
, enum bpdisp disposition
,
14392 int target_resources_ok
;
14394 if (bpt
->type
== bp_hardware_breakpoint
)
14397 i
= hw_breakpoint_used_count ();
14398 target_resources_ok
=
14399 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
14401 if (target_resources_ok
== 0)
14402 error (_("No hardware breakpoint support in the target."));
14403 else if (target_resources_ok
< 0)
14404 error (_("Hardware breakpoints used exceeds limit."));
14407 if (is_watchpoint (bpt
))
14409 /* Initialize it just to avoid a GCC false warning. */
14410 enum enable_state orig_enable_state
= bp_disabled
;
14414 struct watchpoint
*w
= (struct watchpoint
*) bpt
;
14416 orig_enable_state
= bpt
->enable_state
;
14417 bpt
->enable_state
= bp_enabled
;
14418 update_watchpoint (w
, 1 /* reparse */);
14420 catch (const gdb_exception
&e
)
14422 bpt
->enable_state
= orig_enable_state
;
14423 exception_fprintf (gdb_stderr
, e
, _("Cannot enable watchpoint %d: "),
14429 bpt
->enable_state
= bp_enabled
;
14431 /* Mark breakpoint locations modified. */
14432 mark_breakpoint_modified (bpt
);
14434 if (target_supports_enable_disable_tracepoint ()
14435 && current_trace_status ()->running
&& is_tracepoint (bpt
))
14437 for (bp_location
*location
: bpt
->locations ())
14438 target_enable_tracepoint (location
);
14441 bpt
->disposition
= disposition
;
14442 bpt
->enable_count
= count
;
14443 update_global_location_list (UGLL_MAY_INSERT
);
14445 gdb::observers::breakpoint_modified
.notify (bpt
);
14450 enable_breakpoint (struct breakpoint
*bpt
)
14452 enable_breakpoint_disp (bpt
, bpt
->disposition
, 0);
14455 /* The enable command enables the specified breakpoints/locations (or
14456 all defined breakpoints) so they once again become (or continue to
14457 be) effective in stopping the inferior. ARGS may be in any of the
14458 forms defined in extract_bp_number_and_location. */
14461 enable_command (const char *args
, int from_tty
)
14463 enable_disable_command (args
, from_tty
, true);
14467 enable_once_command (const char *args
, int from_tty
)
14469 map_breakpoint_numbers
14470 (args
, [&] (breakpoint
*b
)
14472 iterate_over_related_breakpoints
14473 (b
, [&] (breakpoint
*bpt
)
14475 enable_breakpoint_disp (bpt
, disp_disable
, 1);
14481 enable_count_command (const char *args
, int from_tty
)
14486 error_no_arg (_("hit count"));
14488 count
= get_number (&args
);
14490 map_breakpoint_numbers
14491 (args
, [&] (breakpoint
*b
)
14493 iterate_over_related_breakpoints
14494 (b
, [&] (breakpoint
*bpt
)
14496 enable_breakpoint_disp (bpt
, disp_disable
, count
);
14502 enable_delete_command (const char *args
, int from_tty
)
14504 map_breakpoint_numbers
14505 (args
, [&] (breakpoint
*b
)
14507 iterate_over_related_breakpoints
14508 (b
, [&] (breakpoint
*bpt
)
14510 enable_breakpoint_disp (bpt
, disp_del
, 1);
14515 /* Invalidate last known value of any hardware watchpoint if
14516 the memory which that value represents has been written to by
14520 invalidate_bp_value_on_memory_change (struct inferior
*inferior
,
14521 CORE_ADDR addr
, ssize_t len
,
14522 const bfd_byte
*data
)
14524 for (breakpoint
*bp
: all_breakpoints ())
14525 if (bp
->enable_state
== bp_enabled
14526 && bp
->type
== bp_hardware_watchpoint
)
14528 struct watchpoint
*wp
= (struct watchpoint
*) bp
;
14530 if (wp
->val_valid
&& wp
->val
!= nullptr)
14532 for (bp_location
*loc
: bp
->locations ())
14533 if (loc
->loc_type
== bp_loc_hardware_watchpoint
14534 && loc
->address
+ loc
->length
> addr
14535 && addr
+ len
> loc
->address
)
14538 wp
->val_valid
= false;
14544 /* Create and insert a breakpoint for software single step. */
14547 insert_single_step_breakpoint (struct gdbarch
*gdbarch
,
14548 const address_space
*aspace
,
14551 struct thread_info
*tp
= inferior_thread ();
14552 struct symtab_and_line sal
;
14553 CORE_ADDR pc
= next_pc
;
14555 if (tp
->control
.single_step_breakpoints
== NULL
)
14557 tp
->control
.single_step_breakpoints
14558 = new_single_step_breakpoint (tp
->global_num
, gdbarch
);
14561 sal
= find_pc_line (pc
, 0);
14563 sal
.section
= find_pc_overlay (pc
);
14564 sal
.explicit_pc
= 1;
14565 add_location_to_breakpoint (tp
->control
.single_step_breakpoints
, &sal
);
14567 update_global_location_list (UGLL_INSERT
);
14570 /* Insert single step breakpoints according to the current state. */
14573 insert_single_step_breakpoints (struct gdbarch
*gdbarch
)
14575 struct regcache
*regcache
= get_current_regcache ();
14576 std::vector
<CORE_ADDR
> next_pcs
;
14578 next_pcs
= gdbarch_software_single_step (gdbarch
, regcache
);
14580 if (!next_pcs
.empty ())
14582 struct frame_info
*frame
= get_current_frame ();
14583 const address_space
*aspace
= get_frame_address_space (frame
);
14585 for (CORE_ADDR pc
: next_pcs
)
14586 insert_single_step_breakpoint (gdbarch
, aspace
, pc
);
14594 /* See breakpoint.h. */
14597 breakpoint_has_location_inserted_here (struct breakpoint
*bp
,
14598 const address_space
*aspace
,
14601 for (bp_location
*loc
: bp
->locations ())
14603 && breakpoint_location_address_match (loc
, aspace
, pc
))
14609 /* Check whether a software single-step breakpoint is inserted at
14613 single_step_breakpoint_inserted_here_p (const address_space
*aspace
,
14616 for (breakpoint
*bpt
: all_breakpoints ())
14618 if (bpt
->type
== bp_single_step
14619 && breakpoint_has_location_inserted_here (bpt
, aspace
, pc
))
14625 /* Tracepoint-specific operations. */
14627 /* Set tracepoint count to NUM. */
14629 set_tracepoint_count (int num
)
14631 tracepoint_count
= num
;
14632 set_internalvar_integer (lookup_internalvar ("tpnum"), num
);
14636 trace_command (const char *arg
, int from_tty
)
14638 event_location_up location
= string_to_event_location (&arg
,
14640 const struct breakpoint_ops
*ops
= breakpoint_ops_for_event_location
14641 (location
.get (), true /* is_tracepoint */);
14643 create_breakpoint (get_current_arch (),
14645 NULL
, 0, arg
, false, 1 /* parse arg */,
14647 bp_tracepoint
/* type_wanted */,
14648 0 /* Ignore count */,
14649 pending_break_support
,
14653 0 /* internal */, 0);
14657 ftrace_command (const char *arg
, int from_tty
)
14659 event_location_up location
= string_to_event_location (&arg
,
14661 create_breakpoint (get_current_arch (),
14663 NULL
, 0, arg
, false, 1 /* parse arg */,
14665 bp_fast_tracepoint
/* type_wanted */,
14666 0 /* Ignore count */,
14667 pending_break_support
,
14668 &tracepoint_breakpoint_ops
,
14671 0 /* internal */, 0);
14674 /* strace command implementation. Creates a static tracepoint. */
14677 strace_command (const char *arg
, int from_tty
)
14679 struct breakpoint_ops
*ops
;
14680 event_location_up location
;
14682 /* Decide if we are dealing with a static tracepoint marker (`-m'),
14683 or with a normal static tracepoint. */
14684 if (arg
&& startswith (arg
, "-m") && isspace (arg
[2]))
14686 ops
= &strace_marker_breakpoint_ops
;
14687 location
= new_linespec_location (&arg
, symbol_name_match_type::FULL
);
14691 ops
= &tracepoint_breakpoint_ops
;
14692 location
= string_to_event_location (&arg
, current_language
);
14695 create_breakpoint (get_current_arch (),
14697 NULL
, 0, arg
, false, 1 /* parse arg */,
14699 bp_static_tracepoint
/* type_wanted */,
14700 0 /* Ignore count */,
14701 pending_break_support
,
14705 0 /* internal */, 0);
14708 /* Set up a fake reader function that gets command lines from a linked
14709 list that was acquired during tracepoint uploading. */
14711 static struct uploaded_tp
*this_utp
;
14712 static int next_cmd
;
14715 read_uploaded_action (void)
14717 char *rslt
= nullptr;
14719 if (next_cmd
< this_utp
->cmd_strings
.size ())
14721 rslt
= this_utp
->cmd_strings
[next_cmd
].get ();
14728 /* Given information about a tracepoint as recorded on a target (which
14729 can be either a live system or a trace file), attempt to create an
14730 equivalent GDB tracepoint. This is not a reliable process, since
14731 the target does not necessarily have all the information used when
14732 the tracepoint was originally defined. */
14734 struct tracepoint
*
14735 create_tracepoint_from_upload (struct uploaded_tp
*utp
)
14737 const char *addr_str
;
14738 char small_buf
[100];
14739 struct tracepoint
*tp
;
14741 if (utp
->at_string
)
14742 addr_str
= utp
->at_string
.get ();
14745 /* In the absence of a source location, fall back to raw
14746 address. Since there is no way to confirm that the address
14747 means the same thing as when the trace was started, warn the
14749 warning (_("Uploaded tracepoint %d has no "
14750 "source location, using raw address"),
14752 xsnprintf (small_buf
, sizeof (small_buf
), "*%s", hex_string (utp
->addr
));
14753 addr_str
= small_buf
;
14756 /* There's not much we can do with a sequence of bytecodes. */
14757 if (utp
->cond
&& !utp
->cond_string
)
14758 warning (_("Uploaded tracepoint %d condition "
14759 "has no source form, ignoring it"),
14762 event_location_up location
= string_to_event_location (&addr_str
,
14764 if (!create_breakpoint (get_current_arch (),
14766 utp
->cond_string
.get (), -1, addr_str
,
14767 false /* force_condition */,
14768 0 /* parse cond/thread */,
14770 utp
->type
/* type_wanted */,
14771 0 /* Ignore count */,
14772 pending_break_support
,
14773 &tracepoint_breakpoint_ops
,
14775 utp
->enabled
/* enabled */,
14777 CREATE_BREAKPOINT_FLAGS_INSERTED
))
14780 /* Get the tracepoint we just created. */
14781 tp
= get_tracepoint (tracepoint_count
);
14782 gdb_assert (tp
!= NULL
);
14786 xsnprintf (small_buf
, sizeof (small_buf
), "%d %d", utp
->pass
,
14789 trace_pass_command (small_buf
, 0);
14792 /* If we have uploaded versions of the original commands, set up a
14793 special-purpose "reader" function and call the usual command line
14794 reader, then pass the result to the breakpoint command-setting
14796 if (!utp
->cmd_strings
.empty ())
14798 counted_command_line cmd_list
;
14803 cmd_list
= read_command_lines_1 (read_uploaded_action
, 1, NULL
);
14805 breakpoint_set_commands (tp
, std::move (cmd_list
));
14807 else if (!utp
->actions
.empty ()
14808 || !utp
->step_actions
.empty ())
14809 warning (_("Uploaded tracepoint %d actions "
14810 "have no source form, ignoring them"),
14813 /* Copy any status information that might be available. */
14814 tp
->hit_count
= utp
->hit_count
;
14815 tp
->traceframe_usage
= utp
->traceframe_usage
;
14820 /* Print information on tracepoint number TPNUM_EXP, or all if
14824 info_tracepoints_command (const char *args
, int from_tty
)
14826 struct ui_out
*uiout
= current_uiout
;
14829 num_printed
= breakpoint_1 (args
, false, is_tracepoint
);
14831 if (num_printed
== 0)
14833 if (args
== NULL
|| *args
== '\0')
14834 uiout
->message ("No tracepoints.\n");
14836 uiout
->message ("No tracepoint matching '%s'.\n", args
);
14839 default_collect_info ();
14842 /* The 'enable trace' command enables tracepoints.
14843 Not supported by all targets. */
14845 enable_trace_command (const char *args
, int from_tty
)
14847 enable_command (args
, from_tty
);
14850 /* The 'disable trace' command disables tracepoints.
14851 Not supported by all targets. */
14853 disable_trace_command (const char *args
, int from_tty
)
14855 disable_command (args
, from_tty
);
14858 /* Remove a tracepoint (or all if no argument). */
14860 delete_trace_command (const char *arg
, int from_tty
)
14866 int breaks_to_delete
= 0;
14868 /* Delete all breakpoints if no argument.
14869 Do not delete internal or call-dummy breakpoints, these
14870 have to be deleted with an explicit breakpoint number
14872 for (breakpoint
*tp
: all_tracepoints ())
14873 if (is_tracepoint (tp
) && user_breakpoint_p (tp
))
14875 breaks_to_delete
= 1;
14879 /* Ask user only if there are some breakpoints to delete. */
14881 || (breaks_to_delete
&& query (_("Delete all tracepoints? "))))
14883 for (breakpoint
*b
: all_breakpoints_safe ())
14884 if (is_tracepoint (b
) && user_breakpoint_p (b
))
14885 delete_breakpoint (b
);
14889 map_breakpoint_numbers
14890 (arg
, [&] (breakpoint
*br
)
14892 iterate_over_related_breakpoints (br
, delete_breakpoint
);
14896 /* Helper function for trace_pass_command. */
14899 trace_pass_set_count (struct tracepoint
*tp
, int count
, int from_tty
)
14901 tp
->pass_count
= count
;
14902 gdb::observers::breakpoint_modified
.notify (tp
);
14904 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
14905 tp
->number
, count
);
14908 /* Set passcount for tracepoint.
14910 First command argument is passcount, second is tracepoint number.
14911 If tracepoint number omitted, apply to most recently defined.
14912 Also accepts special argument "all". */
14915 trace_pass_command (const char *args
, int from_tty
)
14917 struct tracepoint
*t1
;
14920 if (args
== 0 || *args
== 0)
14921 error (_("passcount command requires an "
14922 "argument (count + optional TP num)"));
14924 count
= strtoulst (args
, &args
, 10); /* Count comes first, then TP num. */
14926 args
= skip_spaces (args
);
14927 if (*args
&& strncasecmp (args
, "all", 3) == 0)
14929 args
+= 3; /* Skip special argument "all". */
14931 error (_("Junk at end of arguments."));
14933 for (breakpoint
*b
: all_tracepoints ())
14935 t1
= (struct tracepoint
*) b
;
14936 trace_pass_set_count (t1
, count
, from_tty
);
14939 else if (*args
== '\0')
14941 t1
= get_tracepoint_by_number (&args
, NULL
);
14943 trace_pass_set_count (t1
, count
, from_tty
);
14947 number_or_range_parser
parser (args
);
14948 while (!parser
.finished ())
14950 t1
= get_tracepoint_by_number (&args
, &parser
);
14952 trace_pass_set_count (t1
, count
, from_tty
);
14957 struct tracepoint
*
14958 get_tracepoint (int num
)
14960 for (breakpoint
*t
: all_tracepoints ())
14961 if (t
->number
== num
)
14962 return (struct tracepoint
*) t
;
14967 /* Find the tracepoint with the given target-side number (which may be
14968 different from the tracepoint number after disconnecting and
14971 struct tracepoint
*
14972 get_tracepoint_by_number_on_target (int num
)
14974 for (breakpoint
*b
: all_tracepoints ())
14976 struct tracepoint
*t
= (struct tracepoint
*) b
;
14978 if (t
->number_on_target
== num
)
14985 /* Utility: parse a tracepoint number and look it up in the list.
14986 If STATE is not NULL, use, get_number_or_range_state and ignore ARG.
14987 If the argument is missing, the most recent tracepoint
14988 (tracepoint_count) is returned. */
14990 struct tracepoint
*
14991 get_tracepoint_by_number (const char **arg
,
14992 number_or_range_parser
*parser
)
14995 const char *instring
= arg
== NULL
? NULL
: *arg
;
14997 if (parser
!= NULL
)
14999 gdb_assert (!parser
->finished ());
15000 tpnum
= parser
->get_number ();
15002 else if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
15003 tpnum
= tracepoint_count
;
15005 tpnum
= get_number (arg
);
15009 if (instring
&& *instring
)
15010 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
15013 printf_filtered (_("No previous tracepoint\n"));
15017 for (breakpoint
*t
: all_tracepoints ())
15018 if (t
->number
== tpnum
)
15020 return (struct tracepoint
*) t
;
15023 printf_unfiltered ("No tracepoint number %d.\n", tpnum
);
15028 print_recreate_thread (struct breakpoint
*b
, struct ui_file
*fp
)
15030 if (b
->thread
!= -1)
15031 fprintf_unfiltered (fp
, " thread %d", b
->thread
);
15034 fprintf_unfiltered (fp
, " task %d", b
->task
);
15036 fprintf_unfiltered (fp
, "\n");
15039 /* Save information on user settable breakpoints (watchpoints, etc) to
15040 a new script file named FILENAME. If FILTER is non-NULL, call it
15041 on each breakpoint and only include the ones for which it returns
15045 save_breakpoints (const char *filename
, int from_tty
,
15046 bool (*filter
) (const struct breakpoint
*))
15049 int extra_trace_bits
= 0;
15051 if (filename
== 0 || *filename
== 0)
15052 error (_("Argument required (file name in which to save)"));
15054 /* See if we have anything to save. */
15055 for (breakpoint
*tp
: all_breakpoints ())
15057 /* Skip internal and momentary breakpoints. */
15058 if (!user_breakpoint_p (tp
))
15061 /* If we have a filter, only save the breakpoints it accepts. */
15062 if (filter
&& !filter (tp
))
15067 if (is_tracepoint (tp
))
15069 extra_trace_bits
= 1;
15071 /* We can stop searching. */
15078 warning (_("Nothing to save."));
15082 gdb::unique_xmalloc_ptr
<char> expanded_filename (tilde_expand (filename
));
15086 if (!fp
.open (expanded_filename
.get (), "w"))
15087 error (_("Unable to open file '%s' for saving (%s)"),
15088 expanded_filename
.get (), safe_strerror (errno
));
15090 if (extra_trace_bits
)
15091 save_trace_state_variables (&fp
);
15093 for (breakpoint
*tp
: all_breakpoints ())
15095 /* Skip internal and momentary breakpoints. */
15096 if (!user_breakpoint_p (tp
))
15099 /* If we have a filter, only save the breakpoints it accepts. */
15100 if (filter
&& !filter (tp
))
15103 tp
->ops
->print_recreate (tp
, &fp
);
15105 /* Note, we can't rely on tp->number for anything, as we can't
15106 assume the recreated breakpoint numbers will match. Use $bpnum
15109 if (tp
->cond_string
)
15110 fp
.printf (" condition $bpnum %s\n", tp
->cond_string
);
15112 if (tp
->ignore_count
)
15113 fp
.printf (" ignore $bpnum %d\n", tp
->ignore_count
);
15115 if (tp
->type
!= bp_dprintf
&& tp
->commands
)
15117 fp
.puts (" commands\n");
15119 current_uiout
->redirect (&fp
);
15122 print_command_lines (current_uiout
, tp
->commands
.get (), 2);
15124 catch (const gdb_exception
&ex
)
15126 current_uiout
->redirect (NULL
);
15130 current_uiout
->redirect (NULL
);
15131 fp
.puts (" end\n");
15134 if (tp
->enable_state
== bp_disabled
)
15135 fp
.puts ("disable $bpnum\n");
15137 /* If this is a multi-location breakpoint, check if the locations
15138 should be individually disabled. Watchpoint locations are
15139 special, and not user visible. */
15140 if (!is_watchpoint (tp
) && tp
->loc
&& tp
->loc
->next
)
15144 for (bp_location
*loc
: tp
->locations ())
15147 fp
.printf ("disable $bpnum.%d\n", n
);
15154 if (extra_trace_bits
&& *default_collect
)
15155 fp
.printf ("set default-collect %s\n", default_collect
);
15158 printf_filtered (_("Saved to file '%s'.\n"), expanded_filename
.get ());
15161 /* The `save breakpoints' command. */
15164 save_breakpoints_command (const char *args
, int from_tty
)
15166 save_breakpoints (args
, from_tty
, NULL
);
15169 /* The `save tracepoints' command. */
15172 save_tracepoints_command (const char *args
, int from_tty
)
15174 save_breakpoints (args
, from_tty
, is_tracepoint
);
15178 /* This help string is used to consolidate all the help string for specifying
15179 locations used by several commands. */
15181 #define LOCATION_HELP_STRING \
15182 "Linespecs are colon-separated lists of location parameters, such as\n\
15183 source filename, function name, label name, and line number.\n\
15184 Example: To specify the start of a label named \"the_top\" in the\n\
15185 function \"fact\" in the file \"factorial.c\", use\n\
15186 \"factorial.c:fact:the_top\".\n\
15188 Address locations begin with \"*\" and specify an exact address in the\n\
15189 program. Example: To specify the fourth byte past the start function\n\
15190 \"main\", use \"*main + 4\".\n\
15192 Explicit locations are similar to linespecs but use an option/argument\n\
15193 syntax to specify location parameters.\n\
15194 Example: To specify the start of the label named \"the_top\" in the\n\
15195 function \"fact\" in the file \"factorial.c\", use \"-source factorial.c\n\
15196 -function fact -label the_top\".\n\
15198 By default, a specified function is matched against the program's\n\
15199 functions in all scopes. For C++, this means in all namespaces and\n\
15200 classes. For Ada, this means in all packages. E.g., in C++,\n\
15201 \"func()\" matches \"A::func()\", \"A::B::func()\", etc. The\n\
15202 \"-qualified\" flag overrides this behavior, making GDB interpret the\n\
15203 specified name as a complete fully-qualified name instead."
15205 /* This help string is used for the break, hbreak, tbreak and thbreak
15206 commands. It is defined as a macro to prevent duplication.
15207 COMMAND should be a string constant containing the name of the
15210 #define BREAK_ARGS_HELP(command) \
15211 command" [PROBE_MODIFIER] [LOCATION] [thread THREADNUM]\n\
15212 \t[-force-condition] [if CONDITION]\n\
15213 PROBE_MODIFIER shall be present if the command is to be placed in a\n\
15214 probe point. Accepted values are `-probe' (for a generic, automatically\n\
15215 guessed probe type), `-probe-stap' (for a SystemTap probe) or \n\
15216 `-probe-dtrace' (for a DTrace probe).\n\
15217 LOCATION may be a linespec, address, or explicit location as described\n\
15220 With no LOCATION, uses current execution address of the selected\n\
15221 stack frame. This is useful for breaking on return to a stack frame.\n\
15223 THREADNUM is the number from \"info threads\".\n\
15224 CONDITION is a boolean expression.\n\
15226 With the \"-force-condition\" flag, the condition is defined even when\n\
15227 it is invalid for all current locations.\n\
15228 \n" LOCATION_HELP_STRING "\n\n\
15229 Multiple breakpoints at one place are permitted, and useful if their\n\
15230 conditions are different.\n\
15232 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
15234 /* List of subcommands for "catch". */
15235 static struct cmd_list_element
*catch_cmdlist
;
15237 /* List of subcommands for "tcatch". */
15238 static struct cmd_list_element
*tcatch_cmdlist
;
15241 add_catch_command (const char *name
, const char *docstring
,
15242 cmd_const_sfunc_ftype
*sfunc
,
15243 completer_ftype
*completer
,
15244 void *user_data_catch
,
15245 void *user_data_tcatch
)
15247 struct cmd_list_element
*command
;
15249 command
= add_cmd (name
, class_breakpoint
, docstring
,
15251 set_cmd_sfunc (command
, sfunc
);
15252 set_cmd_context (command
, user_data_catch
);
15253 set_cmd_completer (command
, completer
);
15255 command
= add_cmd (name
, class_breakpoint
, docstring
,
15257 set_cmd_sfunc (command
, sfunc
);
15258 set_cmd_context (command
, user_data_tcatch
);
15259 set_cmd_completer (command
, completer
);
15262 struct breakpoint
*
15263 iterate_over_breakpoints (gdb::function_view
<bool (breakpoint
*)> callback
)
15265 for (breakpoint
*b
: all_breakpoints_safe ())
15272 /* Zero if any of the breakpoint's locations could be a location where
15273 functions have been inlined, nonzero otherwise. */
15276 is_non_inline_function (struct breakpoint
*b
)
15278 /* The shared library event breakpoint is set on the address of a
15279 non-inline function. */
15280 if (b
->type
== bp_shlib_event
)
15286 /* Nonzero if the specified PC cannot be a location where functions
15287 have been inlined. */
15290 pc_at_non_inline_function (const address_space
*aspace
, CORE_ADDR pc
,
15291 const struct target_waitstatus
*ws
)
15293 for (breakpoint
*b
: all_breakpoints ())
15295 if (!is_non_inline_function (b
))
15298 for (bp_location
*bl
: b
->locations ())
15300 if (!bl
->shlib_disabled
15301 && bpstat_check_location (bl
, aspace
, pc
, ws
))
15309 /* Remove any references to OBJFILE which is going to be freed. */
15312 breakpoint_free_objfile (struct objfile
*objfile
)
15314 struct bp_location
**locp
, *loc
;
15316 ALL_BP_LOCATIONS (loc
, locp
)
15317 if (loc
->symtab
!= NULL
&& SYMTAB_OBJFILE (loc
->symtab
) == objfile
)
15318 loc
->symtab
= NULL
;
15322 initialize_breakpoint_ops (void)
15324 static int initialized
= 0;
15326 struct breakpoint_ops
*ops
;
15332 /* The breakpoint_ops structure to be inherit by all kinds of
15333 breakpoints (real breakpoints, i.e., user "break" breakpoints,
15334 internal and momentary breakpoints, etc.). */
15335 ops
= &bkpt_base_breakpoint_ops
;
15336 *ops
= base_breakpoint_ops
;
15337 ops
->re_set
= bkpt_re_set
;
15338 ops
->insert_location
= bkpt_insert_location
;
15339 ops
->remove_location
= bkpt_remove_location
;
15340 ops
->breakpoint_hit
= bkpt_breakpoint_hit
;
15341 ops
->create_sals_from_location
= bkpt_create_sals_from_location
;
15342 ops
->create_breakpoints_sal
= bkpt_create_breakpoints_sal
;
15343 ops
->decode_location
= bkpt_decode_location
;
15345 /* The breakpoint_ops structure to be used in regular breakpoints. */
15346 ops
= &bkpt_breakpoint_ops
;
15347 *ops
= bkpt_base_breakpoint_ops
;
15348 ops
->re_set
= bkpt_re_set
;
15349 ops
->resources_needed
= bkpt_resources_needed
;
15350 ops
->print_it
= bkpt_print_it
;
15351 ops
->print_mention
= bkpt_print_mention
;
15352 ops
->print_recreate
= bkpt_print_recreate
;
15354 /* Ranged breakpoints. */
15355 ops
= &ranged_breakpoint_ops
;
15356 *ops
= bkpt_breakpoint_ops
;
15357 ops
->breakpoint_hit
= breakpoint_hit_ranged_breakpoint
;
15358 ops
->resources_needed
= resources_needed_ranged_breakpoint
;
15359 ops
->print_it
= print_it_ranged_breakpoint
;
15360 ops
->print_one
= print_one_ranged_breakpoint
;
15361 ops
->print_one_detail
= print_one_detail_ranged_breakpoint
;
15362 ops
->print_mention
= print_mention_ranged_breakpoint
;
15363 ops
->print_recreate
= print_recreate_ranged_breakpoint
;
15365 /* Internal breakpoints. */
15366 ops
= &internal_breakpoint_ops
;
15367 *ops
= bkpt_base_breakpoint_ops
;
15368 ops
->re_set
= internal_bkpt_re_set
;
15369 ops
->check_status
= internal_bkpt_check_status
;
15370 ops
->print_it
= internal_bkpt_print_it
;
15371 ops
->print_mention
= internal_bkpt_print_mention
;
15373 /* Momentary breakpoints. */
15374 ops
= &momentary_breakpoint_ops
;
15375 *ops
= bkpt_base_breakpoint_ops
;
15376 ops
->re_set
= momentary_bkpt_re_set
;
15377 ops
->check_status
= momentary_bkpt_check_status
;
15378 ops
->print_it
= momentary_bkpt_print_it
;
15379 ops
->print_mention
= momentary_bkpt_print_mention
;
15381 /* Probe breakpoints. */
15382 ops
= &bkpt_probe_breakpoint_ops
;
15383 *ops
= bkpt_breakpoint_ops
;
15384 ops
->insert_location
= bkpt_probe_insert_location
;
15385 ops
->remove_location
= bkpt_probe_remove_location
;
15386 ops
->create_sals_from_location
= bkpt_probe_create_sals_from_location
;
15387 ops
->decode_location
= bkpt_probe_decode_location
;
15390 ops
= &watchpoint_breakpoint_ops
;
15391 *ops
= base_breakpoint_ops
;
15392 ops
->re_set
= re_set_watchpoint
;
15393 ops
->insert_location
= insert_watchpoint
;
15394 ops
->remove_location
= remove_watchpoint
;
15395 ops
->breakpoint_hit
= breakpoint_hit_watchpoint
;
15396 ops
->check_status
= check_status_watchpoint
;
15397 ops
->resources_needed
= resources_needed_watchpoint
;
15398 ops
->works_in_software_mode
= works_in_software_mode_watchpoint
;
15399 ops
->print_it
= print_it_watchpoint
;
15400 ops
->print_mention
= print_mention_watchpoint
;
15401 ops
->print_recreate
= print_recreate_watchpoint
;
15402 ops
->explains_signal
= explains_signal_watchpoint
;
15404 /* Masked watchpoints. */
15405 ops
= &masked_watchpoint_breakpoint_ops
;
15406 *ops
= watchpoint_breakpoint_ops
;
15407 ops
->insert_location
= insert_masked_watchpoint
;
15408 ops
->remove_location
= remove_masked_watchpoint
;
15409 ops
->resources_needed
= resources_needed_masked_watchpoint
;
15410 ops
->works_in_software_mode
= works_in_software_mode_masked_watchpoint
;
15411 ops
->print_it
= print_it_masked_watchpoint
;
15412 ops
->print_one_detail
= print_one_detail_masked_watchpoint
;
15413 ops
->print_mention
= print_mention_masked_watchpoint
;
15414 ops
->print_recreate
= print_recreate_masked_watchpoint
;
15417 ops
= &tracepoint_breakpoint_ops
;
15418 *ops
= base_breakpoint_ops
;
15419 ops
->re_set
= tracepoint_re_set
;
15420 ops
->breakpoint_hit
= tracepoint_breakpoint_hit
;
15421 ops
->print_one_detail
= tracepoint_print_one_detail
;
15422 ops
->print_mention
= tracepoint_print_mention
;
15423 ops
->print_recreate
= tracepoint_print_recreate
;
15424 ops
->create_sals_from_location
= tracepoint_create_sals_from_location
;
15425 ops
->create_breakpoints_sal
= tracepoint_create_breakpoints_sal
;
15426 ops
->decode_location
= tracepoint_decode_location
;
15428 /* Probe tracepoints. */
15429 ops
= &tracepoint_probe_breakpoint_ops
;
15430 *ops
= tracepoint_breakpoint_ops
;
15431 ops
->create_sals_from_location
= tracepoint_probe_create_sals_from_location
;
15432 ops
->decode_location
= tracepoint_probe_decode_location
;
15434 /* Static tracepoints with marker (`-m'). */
15435 ops
= &strace_marker_breakpoint_ops
;
15436 *ops
= tracepoint_breakpoint_ops
;
15437 ops
->create_sals_from_location
= strace_marker_create_sals_from_location
;
15438 ops
->create_breakpoints_sal
= strace_marker_create_breakpoints_sal
;
15439 ops
->decode_location
= strace_marker_decode_location
;
15441 /* Fork catchpoints. */
15442 ops
= &catch_fork_breakpoint_ops
;
15443 *ops
= base_breakpoint_ops
;
15444 ops
->insert_location
= insert_catch_fork
;
15445 ops
->remove_location
= remove_catch_fork
;
15446 ops
->breakpoint_hit
= breakpoint_hit_catch_fork
;
15447 ops
->print_it
= print_it_catch_fork
;
15448 ops
->print_one
= print_one_catch_fork
;
15449 ops
->print_mention
= print_mention_catch_fork
;
15450 ops
->print_recreate
= print_recreate_catch_fork
;
15452 /* Vfork catchpoints. */
15453 ops
= &catch_vfork_breakpoint_ops
;
15454 *ops
= base_breakpoint_ops
;
15455 ops
->insert_location
= insert_catch_vfork
;
15456 ops
->remove_location
= remove_catch_vfork
;
15457 ops
->breakpoint_hit
= breakpoint_hit_catch_vfork
;
15458 ops
->print_it
= print_it_catch_vfork
;
15459 ops
->print_one
= print_one_catch_vfork
;
15460 ops
->print_mention
= print_mention_catch_vfork
;
15461 ops
->print_recreate
= print_recreate_catch_vfork
;
15463 /* Exec catchpoints. */
15464 ops
= &catch_exec_breakpoint_ops
;
15465 *ops
= base_breakpoint_ops
;
15466 ops
->insert_location
= insert_catch_exec
;
15467 ops
->remove_location
= remove_catch_exec
;
15468 ops
->breakpoint_hit
= breakpoint_hit_catch_exec
;
15469 ops
->print_it
= print_it_catch_exec
;
15470 ops
->print_one
= print_one_catch_exec
;
15471 ops
->print_mention
= print_mention_catch_exec
;
15472 ops
->print_recreate
= print_recreate_catch_exec
;
15474 /* Solib-related catchpoints. */
15475 ops
= &catch_solib_breakpoint_ops
;
15476 *ops
= base_breakpoint_ops
;
15477 ops
->insert_location
= insert_catch_solib
;
15478 ops
->remove_location
= remove_catch_solib
;
15479 ops
->breakpoint_hit
= breakpoint_hit_catch_solib
;
15480 ops
->check_status
= check_status_catch_solib
;
15481 ops
->print_it
= print_it_catch_solib
;
15482 ops
->print_one
= print_one_catch_solib
;
15483 ops
->print_mention
= print_mention_catch_solib
;
15484 ops
->print_recreate
= print_recreate_catch_solib
;
15486 ops
= &dprintf_breakpoint_ops
;
15487 *ops
= bkpt_base_breakpoint_ops
;
15488 ops
->re_set
= dprintf_re_set
;
15489 ops
->resources_needed
= bkpt_resources_needed
;
15490 ops
->print_it
= bkpt_print_it
;
15491 ops
->print_mention
= bkpt_print_mention
;
15492 ops
->print_recreate
= dprintf_print_recreate
;
15493 ops
->after_condition_true
= dprintf_after_condition_true
;
15494 ops
->breakpoint_hit
= dprintf_breakpoint_hit
;
15497 /* Chain containing all defined "enable breakpoint" subcommands. */
15499 static struct cmd_list_element
*enablebreaklist
= NULL
;
15501 /* See breakpoint.h. */
15503 cmd_list_element
*commands_cmd_element
= nullptr;
15505 void _initialize_breakpoint ();
15507 _initialize_breakpoint ()
15509 struct cmd_list_element
*c
;
15511 initialize_breakpoint_ops ();
15513 gdb::observers::solib_unloaded
.attach (disable_breakpoints_in_unloaded_shlib
,
15515 gdb::observers::free_objfile
.attach (disable_breakpoints_in_freed_objfile
,
15517 gdb::observers::memory_changed
.attach (invalidate_bp_value_on_memory_change
,
15520 breakpoint_chain
= 0;
15521 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
15522 before a breakpoint is set. */
15523 breakpoint_count
= 0;
15525 tracepoint_count
= 0;
15527 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
15528 Set ignore-count of breakpoint number N to COUNT.\n\
15529 Usage is `ignore N COUNT'."));
15531 commands_cmd_element
= add_com ("commands", class_breakpoint
,
15532 commands_command
, _("\
15533 Set commands to be executed when the given breakpoints are hit.\n\
15534 Give a space-separated breakpoint list as argument after \"commands\".\n\
15535 A list element can be a breakpoint number (e.g. `5') or a range of numbers\n\
15537 With no argument, the targeted breakpoint is the last one set.\n\
15538 The commands themselves follow starting on the next line.\n\
15539 Type a line containing \"end\" to indicate the end of them.\n\
15540 Give \"silent\" as the first line to make the breakpoint silent;\n\
15541 then no output is printed when it is hit, except what the commands print."));
15543 const auto cc_opts
= make_condition_command_options_def_group (nullptr);
15544 static std::string condition_command_help
15545 = gdb::option::build_help (_("\
15546 Specify breakpoint number N to break only if COND is true.\n\
15547 Usage is `condition [OPTION] N COND', where N is an integer and COND\n\
15548 is an expression to be evaluated whenever breakpoint N is reached.\n\
15551 %OPTIONS%"), cc_opts
);
15553 c
= add_com ("condition", class_breakpoint
, condition_command
,
15554 condition_command_help
.c_str ());
15555 set_cmd_completer_handle_brkchars (c
, condition_completer
);
15557 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
15558 Set a temporary breakpoint.\n\
15559 Like \"break\" except the breakpoint is only temporary,\n\
15560 so it will be deleted when hit. Equivalent to \"break\" followed\n\
15561 by using \"enable delete\" on the breakpoint number.\n\
15563 BREAK_ARGS_HELP ("tbreak")));
15564 set_cmd_completer (c
, location_completer
);
15566 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
15567 Set a hardware assisted breakpoint.\n\
15568 Like \"break\" except the breakpoint requires hardware support,\n\
15569 some target hardware may not have this support.\n\
15571 BREAK_ARGS_HELP ("hbreak")));
15572 set_cmd_completer (c
, location_completer
);
15574 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
15575 Set a temporary hardware assisted breakpoint.\n\
15576 Like \"hbreak\" except the breakpoint is only temporary,\n\
15577 so it will be deleted when hit.\n\
15579 BREAK_ARGS_HELP ("thbreak")));
15580 set_cmd_completer (c
, location_completer
);
15582 cmd_list_element
*enable_cmd
15583 = add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
15584 Enable all or some breakpoints.\n\
15585 Usage: enable [BREAKPOINTNUM]...\n\
15586 Give breakpoint numbers (separated by spaces) as arguments.\n\
15587 With no subcommand, breakpoints are enabled until you command otherwise.\n\
15588 This is used to cancel the effect of the \"disable\" command.\n\
15589 With a subcommand you can enable temporarily."),
15590 &enablelist
, 1, &cmdlist
);
15592 add_com_alias ("en", enable_cmd
, class_breakpoint
, 1);
15594 add_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
15595 Enable all or some breakpoints.\n\
15596 Usage: enable breakpoints [BREAKPOINTNUM]...\n\
15597 Give breakpoint numbers (separated by spaces) as arguments.\n\
15598 This is used to cancel the effect of the \"disable\" command.\n\
15599 May be abbreviated to simply \"enable\"."),
15600 &enablebreaklist
, 1, &enablelist
);
15602 add_cmd ("once", no_class
, enable_once_command
, _("\
15603 Enable some breakpoints for one hit.\n\
15604 Usage: enable breakpoints once BREAKPOINTNUM...\n\
15605 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
15608 add_cmd ("delete", no_class
, enable_delete_command
, _("\
15609 Enable some breakpoints and delete when hit.\n\
15610 Usage: enable breakpoints delete BREAKPOINTNUM...\n\
15611 If a breakpoint is hit while enabled in this fashion, it is deleted."),
15614 add_cmd ("count", no_class
, enable_count_command
, _("\
15615 Enable some breakpoints for COUNT hits.\n\
15616 Usage: enable breakpoints count COUNT BREAKPOINTNUM...\n\
15617 If a breakpoint is hit while enabled in this fashion,\n\
15618 the count is decremented; when it reaches zero, the breakpoint is disabled."),
15621 add_cmd ("delete", no_class
, enable_delete_command
, _("\
15622 Enable some breakpoints and delete when hit.\n\
15623 Usage: enable delete BREAKPOINTNUM...\n\
15624 If a breakpoint is hit while enabled in this fashion, it is deleted."),
15627 add_cmd ("once", no_class
, enable_once_command
, _("\
15628 Enable some breakpoints for one hit.\n\
15629 Usage: enable once BREAKPOINTNUM...\n\
15630 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
15633 add_cmd ("count", no_class
, enable_count_command
, _("\
15634 Enable some breakpoints for COUNT hits.\n\
15635 Usage: enable count COUNT BREAKPOINTNUM...\n\
15636 If a breakpoint is hit while enabled in this fashion,\n\
15637 the count is decremented; when it reaches zero, the breakpoint is disabled."),
15640 cmd_list_element
*disable_cmd
15641 = add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
15642 Disable all or some breakpoints.\n\
15643 Usage: disable [BREAKPOINTNUM]...\n\
15644 Arguments are breakpoint numbers with spaces in between.\n\
15645 To disable all breakpoints, give no argument.\n\
15646 A disabled breakpoint is not forgotten, but has no effect until re-enabled."),
15647 &disablelist
, 1, &cmdlist
);
15648 add_com_alias ("dis", disable_cmd
, class_breakpoint
, 1);
15649 add_com_alias ("disa", disable_cmd
, class_breakpoint
, 1);
15651 add_cmd ("breakpoints", class_breakpoint
, disable_command
, _("\
15652 Disable all or some breakpoints.\n\
15653 Usage: disable breakpoints [BREAKPOINTNUM]...\n\
15654 Arguments are breakpoint numbers with spaces in between.\n\
15655 To disable all breakpoints, give no argument.\n\
15656 A disabled breakpoint is not forgotten, but has no effect until re-enabled.\n\
15657 This command may be abbreviated \"disable\"."),
15660 cmd_list_element
*delete_cmd
15661 = add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
15662 Delete all or some breakpoints.\n\
15663 Usage: delete [BREAKPOINTNUM]...\n\
15664 Arguments are breakpoint numbers with spaces in between.\n\
15665 To delete all breakpoints, give no argument.\n\
15667 Also a prefix command for deletion of other GDB objects."),
15668 &deletelist
, 1, &cmdlist
);
15669 add_com_alias ("d", delete_cmd
, class_breakpoint
, 1);
15670 add_com_alias ("del", delete_cmd
, class_breakpoint
, 1);
15672 add_cmd ("breakpoints", class_breakpoint
, delete_command
, _("\
15673 Delete all or some breakpoints or auto-display expressions.\n\
15674 Usage: delete breakpoints [BREAKPOINTNUM]...\n\
15675 Arguments are breakpoint numbers with spaces in between.\n\
15676 To delete all breakpoints, give no argument.\n\
15677 This command may be abbreviated \"delete\"."),
15680 cmd_list_element
*clear_cmd
15681 = add_com ("clear", class_breakpoint
, clear_command
, _("\
15682 Clear breakpoint at specified location.\n\
15683 Argument may be a linespec, explicit, or address location as described below.\n\
15685 With no argument, clears all breakpoints in the line that the selected frame\n\
15686 is executing in.\n"
15687 "\n" LOCATION_HELP_STRING
"\n\n\
15688 See also the \"delete\" command which clears breakpoints by number."));
15689 add_com_alias ("cl", clear_cmd
, class_breakpoint
, 1);
15691 cmd_list_element
*break_cmd
15692 = add_com ("break", class_breakpoint
, break_command
, _("\
15693 Set breakpoint at specified location.\n"
15694 BREAK_ARGS_HELP ("break")));
15695 set_cmd_completer (break_cmd
, location_completer
);
15697 add_com_alias ("b", break_cmd
, class_run
, 1);
15698 add_com_alias ("br", break_cmd
, class_run
, 1);
15699 add_com_alias ("bre", break_cmd
, class_run
, 1);
15700 add_com_alias ("brea", break_cmd
, class_run
, 1);
15704 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
15705 Break in function/address or break at a line in the current file."),
15706 &stoplist
, 1, &cmdlist
);
15707 add_cmd ("in", class_breakpoint
, stopin_command
,
15708 _("Break in function or address."), &stoplist
);
15709 add_cmd ("at", class_breakpoint
, stopat_command
,
15710 _("Break at a line in the current file."), &stoplist
);
15711 add_com ("status", class_info
, info_breakpoints_command
, _("\
15712 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
15713 The \"Type\" column indicates one of:\n\
15714 \tbreakpoint - normal breakpoint\n\
15715 \twatchpoint - watchpoint\n\
15716 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15717 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
15718 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
15719 address and file/line number respectively.\n\
15721 Convenience variable \"$_\" and default examine address for \"x\"\n\
15722 are set to the address of the last breakpoint listed unless the command\n\
15723 is prefixed with \"server \".\n\n\
15724 Convenience variable \"$bpnum\" contains the number of the last\n\
15725 breakpoint set."));
15728 cmd_list_element
*info_breakpoints_cmd
15729 = add_info ("breakpoints", info_breakpoints_command
, _("\
15730 Status of specified breakpoints (all user-settable breakpoints if no argument).\n\
15731 The \"Type\" column indicates one of:\n\
15732 \tbreakpoint - normal breakpoint\n\
15733 \twatchpoint - watchpoint\n\
15734 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15735 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
15736 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
15737 address and file/line number respectively.\n\
15739 Convenience variable \"$_\" and default examine address for \"x\"\n\
15740 are set to the address of the last breakpoint listed unless the command\n\
15741 is prefixed with \"server \".\n\n\
15742 Convenience variable \"$bpnum\" contains the number of the last\n\
15743 breakpoint set."));
15745 add_info_alias ("b", info_breakpoints_cmd
, 1);
15747 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
15748 Status of all breakpoints, or breakpoint number NUMBER.\n\
15749 The \"Type\" column indicates one of:\n\
15750 \tbreakpoint - normal breakpoint\n\
15751 \twatchpoint - watchpoint\n\
15752 \tlongjmp - internal breakpoint used to step through longjmp()\n\
15753 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
15754 \tuntil - internal breakpoint used by the \"until\" command\n\
15755 \tfinish - internal breakpoint used by the \"finish\" command\n\
15756 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15757 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
15758 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
15759 address and file/line number respectively.\n\
15761 Convenience variable \"$_\" and default examine address for \"x\"\n\
15762 are set to the address of the last breakpoint listed unless the command\n\
15763 is prefixed with \"server \".\n\n\
15764 Convenience variable \"$bpnum\" contains the number of the last\n\
15766 &maintenanceinfolist
);
15768 add_basic_prefix_cmd ("catch", class_breakpoint
, _("\
15769 Set catchpoints to catch events."),
15771 0/*allow-unknown*/, &cmdlist
);
15773 add_basic_prefix_cmd ("tcatch", class_breakpoint
, _("\
15774 Set temporary catchpoints to catch events."),
15776 0/*allow-unknown*/, &cmdlist
);
15778 add_catch_command ("fork", _("Catch calls to fork."),
15779 catch_fork_command_1
,
15781 (void *) (uintptr_t) catch_fork_permanent
,
15782 (void *) (uintptr_t) catch_fork_temporary
);
15783 add_catch_command ("vfork", _("Catch calls to vfork."),
15784 catch_fork_command_1
,
15786 (void *) (uintptr_t) catch_vfork_permanent
,
15787 (void *) (uintptr_t) catch_vfork_temporary
);
15788 add_catch_command ("exec", _("Catch calls to exec."),
15789 catch_exec_command_1
,
15793 add_catch_command ("load", _("Catch loads of shared libraries.\n\
15794 Usage: catch load [REGEX]\n\
15795 If REGEX is given, only stop for libraries matching the regular expression."),
15796 catch_load_command_1
,
15800 add_catch_command ("unload", _("Catch unloads of shared libraries.\n\
15801 Usage: catch unload [REGEX]\n\
15802 If REGEX is given, only stop for libraries matching the regular expression."),
15803 catch_unload_command_1
,
15808 const auto opts
= make_watch_options_def_group (nullptr);
15810 static const std::string watch_help
= gdb::option::build_help (_("\
15811 Set a watchpoint for EXPRESSION.\n\
15812 Usage: watch [-location] EXPRESSION\n\
15817 A watchpoint stops execution of your program whenever the value of\n\
15818 an expression changes."), opts
);
15819 c
= add_com ("watch", class_breakpoint
, watch_command
,
15820 watch_help
.c_str ());
15821 set_cmd_completer_handle_brkchars (c
, watch_command_completer
);
15823 static const std::string rwatch_help
= gdb::option::build_help (_("\
15824 Set a read watchpoint for EXPRESSION.\n\
15825 Usage: rwatch [-location] EXPRESSION\n\
15830 A read watchpoint stops execution of your program whenever the value of\n\
15831 an expression is read."), opts
);
15832 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
,
15833 rwatch_help
.c_str ());
15834 set_cmd_completer_handle_brkchars (c
, watch_command_completer
);
15836 static const std::string awatch_help
= gdb::option::build_help (_("\
15837 Set an access watchpoint for EXPRESSION.\n\
15838 Usage: awatch [-location] EXPRESSION\n\
15843 An access watchpoint stops execution of your program whenever the value\n\
15844 of an expression is either read or written."), opts
);
15845 c
= add_com ("awatch", class_breakpoint
, awatch_command
,
15846 awatch_help
.c_str ());
15847 set_cmd_completer_handle_brkchars (c
, watch_command_completer
);
15849 add_info ("watchpoints", info_watchpoints_command
, _("\
15850 Status of specified watchpoints (all watchpoints if no argument)."));
15852 /* XXX: cagney/2005-02-23: This should be a boolean, and should
15853 respond to changes - contrary to the description. */
15854 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
15855 &can_use_hw_watchpoints
, _("\
15856 Set debugger's willingness to use watchpoint hardware."), _("\
15857 Show debugger's willingness to use watchpoint hardware."), _("\
15858 If zero, gdb will not use hardware for new watchpoints, even if\n\
15859 such is available. (However, any hardware watchpoints that were\n\
15860 created before setting this to nonzero, will continue to use watchpoint\n\
15863 show_can_use_hw_watchpoints
,
15864 &setlist
, &showlist
);
15866 can_use_hw_watchpoints
= 1;
15868 /* Tracepoint manipulation commands. */
15870 cmd_list_element
*trace_cmd
15871 = add_com ("trace", class_breakpoint
, trace_command
, _("\
15872 Set a tracepoint at specified location.\n\
15874 BREAK_ARGS_HELP ("trace") "\n\
15875 Do \"help tracepoints\" for info on other tracepoint commands."));
15876 set_cmd_completer (trace_cmd
, location_completer
);
15878 add_com_alias ("tp", trace_cmd
, class_breakpoint
, 0);
15879 add_com_alias ("tr", trace_cmd
, class_breakpoint
, 1);
15880 add_com_alias ("tra", trace_cmd
, class_breakpoint
, 1);
15881 add_com_alias ("trac", trace_cmd
, class_breakpoint
, 1);
15883 c
= add_com ("ftrace", class_breakpoint
, ftrace_command
, _("\
15884 Set a fast tracepoint at specified location.\n\
15886 BREAK_ARGS_HELP ("ftrace") "\n\
15887 Do \"help tracepoints\" for info on other tracepoint commands."));
15888 set_cmd_completer (c
, location_completer
);
15890 c
= add_com ("strace", class_breakpoint
, strace_command
, _("\
15891 Set a static tracepoint at location or marker.\n\
15893 strace [LOCATION] [if CONDITION]\n\
15894 LOCATION may be a linespec, explicit, or address location (described below) \n\
15895 or -m MARKER_ID.\n\n\
15896 If a marker id is specified, probe the marker with that name. With\n\
15897 no LOCATION, uses current execution address of the selected stack frame.\n\
15898 Static tracepoints accept an extra collect action -- ``collect $_sdata''.\n\
15899 This collects arbitrary user data passed in the probe point call to the\n\
15900 tracing library. You can inspect it when analyzing the trace buffer,\n\
15901 by printing the $_sdata variable like any other convenience variable.\n\
15903 CONDITION is a boolean expression.\n\
15904 \n" LOCATION_HELP_STRING
"\n\n\
15905 Multiple tracepoints at one place are permitted, and useful if their\n\
15906 conditions are different.\n\
15908 Do \"help breakpoints\" for info on other commands dealing with breakpoints.\n\
15909 Do \"help tracepoints\" for info on other tracepoint commands."));
15910 set_cmd_completer (c
, location_completer
);
15912 cmd_list_element
*info_tracepoints_cmd
15913 = add_info ("tracepoints", info_tracepoints_command
, _("\
15914 Status of specified tracepoints (all tracepoints if no argument).\n\
15915 Convenience variable \"$tpnum\" contains the number of the\n\
15916 last tracepoint set."));
15918 add_info_alias ("tp", info_tracepoints_cmd
, 1);
15920 cmd_list_element
*delete_tracepoints_cmd
15921 = add_cmd ("tracepoints", class_trace
, delete_trace_command
, _("\
15922 Delete specified tracepoints.\n\
15923 Arguments are tracepoint numbers, separated by spaces.\n\
15924 No argument means delete all tracepoints."),
15926 add_alias_cmd ("tr", delete_tracepoints_cmd
, class_trace
, 1, &deletelist
);
15928 c
= add_cmd ("tracepoints", class_trace
, disable_trace_command
, _("\
15929 Disable specified tracepoints.\n\
15930 Arguments are tracepoint numbers, separated by spaces.\n\
15931 No argument means disable all tracepoints."),
15933 deprecate_cmd (c
, "disable");
15935 c
= add_cmd ("tracepoints", class_trace
, enable_trace_command
, _("\
15936 Enable specified tracepoints.\n\
15937 Arguments are tracepoint numbers, separated by spaces.\n\
15938 No argument means enable all tracepoints."),
15940 deprecate_cmd (c
, "enable");
15942 add_com ("passcount", class_trace
, trace_pass_command
, _("\
15943 Set the passcount for a tracepoint.\n\
15944 The trace will end when the tracepoint has been passed 'count' times.\n\
15945 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
15946 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
15948 add_basic_prefix_cmd ("save", class_breakpoint
,
15949 _("Save breakpoint definitions as a script."),
15951 0/*allow-unknown*/, &cmdlist
);
15953 c
= add_cmd ("breakpoints", class_breakpoint
, save_breakpoints_command
, _("\
15954 Save current breakpoint definitions as a script.\n\
15955 This includes all types of breakpoints (breakpoints, watchpoints,\n\
15956 catchpoints, tracepoints). Use the 'source' command in another debug\n\
15957 session to restore them."),
15959 set_cmd_completer (c
, filename_completer
);
15961 cmd_list_element
*save_tracepoints_cmd
15962 = add_cmd ("tracepoints", class_trace
, save_tracepoints_command
, _("\
15963 Save current tracepoint definitions as a script.\n\
15964 Use the 'source' command in another debug session to restore them."),
15966 set_cmd_completer (save_tracepoints_cmd
, filename_completer
);
15968 c
= add_com_alias ("save-tracepoints", save_tracepoints_cmd
, class_trace
, 0);
15969 deprecate_cmd (c
, "save tracepoints");
15971 add_basic_prefix_cmd ("breakpoint", class_maintenance
, _("\
15972 Breakpoint specific settings.\n\
15973 Configure various breakpoint-specific variables such as\n\
15974 pending breakpoint behavior."),
15975 &breakpoint_set_cmdlist
,
15976 0/*allow-unknown*/, &setlist
);
15977 add_show_prefix_cmd ("breakpoint", class_maintenance
, _("\
15978 Breakpoint specific settings.\n\
15979 Configure various breakpoint-specific variables such as\n\
15980 pending breakpoint behavior."),
15981 &breakpoint_show_cmdlist
,
15982 0/*allow-unknown*/, &showlist
);
15984 add_setshow_auto_boolean_cmd ("pending", no_class
,
15985 &pending_break_support
, _("\
15986 Set debugger's behavior regarding pending breakpoints."), _("\
15987 Show debugger's behavior regarding pending breakpoints."), _("\
15988 If on, an unrecognized breakpoint location will cause gdb to create a\n\
15989 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
15990 an error. If auto, an unrecognized breakpoint location results in a\n\
15991 user-query to see if a pending breakpoint should be created."),
15993 show_pending_break_support
,
15994 &breakpoint_set_cmdlist
,
15995 &breakpoint_show_cmdlist
);
15997 pending_break_support
= AUTO_BOOLEAN_AUTO
;
15999 add_setshow_boolean_cmd ("auto-hw", no_class
,
16000 &automatic_hardware_breakpoints
, _("\
16001 Set automatic usage of hardware breakpoints."), _("\
16002 Show automatic usage of hardware breakpoints."), _("\
16003 If set, the debugger will automatically use hardware breakpoints for\n\
16004 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
16005 a warning will be emitted for such breakpoints."),
16007 show_automatic_hardware_breakpoints
,
16008 &breakpoint_set_cmdlist
,
16009 &breakpoint_show_cmdlist
);
16011 add_setshow_boolean_cmd ("always-inserted", class_support
,
16012 &always_inserted_mode
, _("\
16013 Set mode for inserting breakpoints."), _("\
16014 Show mode for inserting breakpoints."), _("\
16015 When this mode is on, breakpoints are inserted immediately as soon as\n\
16016 they're created, kept inserted even when execution stops, and removed\n\
16017 only when the user deletes them. When this mode is off (the default),\n\
16018 breakpoints are inserted only when execution continues, and removed\n\
16019 when execution stops."),
16021 &show_always_inserted_mode
,
16022 &breakpoint_set_cmdlist
,
16023 &breakpoint_show_cmdlist
);
16025 add_setshow_enum_cmd ("condition-evaluation", class_breakpoint
,
16026 condition_evaluation_enums
,
16027 &condition_evaluation_mode_1
, _("\
16028 Set mode of breakpoint condition evaluation."), _("\
16029 Show mode of breakpoint condition evaluation."), _("\
16030 When this is set to \"host\", breakpoint conditions will be\n\
16031 evaluated on the host's side by GDB. When it is set to \"target\",\n\
16032 breakpoint conditions will be downloaded to the target (if the target\n\
16033 supports such feature) and conditions will be evaluated on the target's side.\n\
16034 If this is set to \"auto\" (default), this will be automatically set to\n\
16035 \"target\" if it supports condition evaluation, otherwise it will\n\
16036 be set to \"host\"."),
16037 &set_condition_evaluation_mode
,
16038 &show_condition_evaluation_mode
,
16039 &breakpoint_set_cmdlist
,
16040 &breakpoint_show_cmdlist
);
16042 add_com ("break-range", class_breakpoint
, break_range_command
, _("\
16043 Set a breakpoint for an address range.\n\
16044 break-range START-LOCATION, END-LOCATION\n\
16045 where START-LOCATION and END-LOCATION can be one of the following:\n\
16046 LINENUM, for that line in the current file,\n\
16047 FILE:LINENUM, for that line in that file,\n\
16048 +OFFSET, for that number of lines after the current line\n\
16049 or the start of the range\n\
16050 FUNCTION, for the first line in that function,\n\
16051 FILE:FUNCTION, to distinguish among like-named static functions.\n\
16052 *ADDRESS, for the instruction at that address.\n\
16054 The breakpoint will stop execution of the inferior whenever it executes\n\
16055 an instruction at any address within the [START-LOCATION, END-LOCATION]\n\
16056 range (including START-LOCATION and END-LOCATION)."));
16058 c
= add_com ("dprintf", class_breakpoint
, dprintf_command
, _("\
16059 Set a dynamic printf at specified location.\n\
16060 dprintf location,format string,arg1,arg2,...\n\
16061 location may be a linespec, explicit, or address location.\n"
16062 "\n" LOCATION_HELP_STRING
));
16063 set_cmd_completer (c
, location_completer
);
16065 add_setshow_enum_cmd ("dprintf-style", class_support
,
16066 dprintf_style_enums
, &dprintf_style
, _("\
16067 Set the style of usage for dynamic printf."), _("\
16068 Show the style of usage for dynamic printf."), _("\
16069 This setting chooses how GDB will do a dynamic printf.\n\
16070 If the value is \"gdb\", then the printing is done by GDB to its own\n\
16071 console, as with the \"printf\" command.\n\
16072 If the value is \"call\", the print is done by calling a function in your\n\
16073 program; by default printf(), but you can choose a different function or\n\
16074 output stream by setting dprintf-function and dprintf-channel."),
16075 update_dprintf_commands
, NULL
,
16076 &setlist
, &showlist
);
16078 dprintf_function
= xstrdup ("printf");
16079 add_setshow_string_cmd ("dprintf-function", class_support
,
16080 &dprintf_function
, _("\
16081 Set the function to use for dynamic printf."), _("\
16082 Show the function to use for dynamic printf."), NULL
,
16083 update_dprintf_commands
, NULL
,
16084 &setlist
, &showlist
);
16086 dprintf_channel
= xstrdup ("");
16087 add_setshow_string_cmd ("dprintf-channel", class_support
,
16088 &dprintf_channel
, _("\
16089 Set the channel to use for dynamic printf."), _("\
16090 Show the channel to use for dynamic printf."), NULL
,
16091 update_dprintf_commands
, NULL
,
16092 &setlist
, &showlist
);
16094 add_setshow_boolean_cmd ("disconnected-dprintf", no_class
,
16095 &disconnected_dprintf
, _("\
16096 Set whether dprintf continues after GDB disconnects."), _("\
16097 Show whether dprintf continues after GDB disconnects."), _("\
16098 Use this to let dprintf commands continue to hit and produce output\n\
16099 even if GDB disconnects or detaches from the target."),
16102 &setlist
, &showlist
);
16104 add_com ("agent-printf", class_vars
, agent_printf_command
, _("\
16105 Target agent only formatted printing, like the C \"printf\" function.\n\
16106 Usage: agent-printf \"format string\", ARG1, ARG2, ARG3, ..., ARGN\n\
16107 This supports most C printf format specifications, like %s, %d, etc.\n\
16108 This is useful for formatted output in user-defined commands."));
16110 automatic_hardware_breakpoints
= true;
16112 gdb::observers::about_to_proceed
.attach (breakpoint_about_to_proceed
,
16114 gdb::observers::thread_exit
.attach (remove_threaded_breakpoints
,