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(B) for (B = breakpoint_chain; B; B = B->next)
491 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
492 for (B = breakpoint_chain; \
493 B ? (TMP=B->next, 1): 0; \
496 /* Similar iterator for the low-level breakpoints. SAFE variant is
497 not provided so update_global_location_list must not be called
498 while executing the block of ALL_BP_LOCATIONS. */
500 #define ALL_BP_LOCATIONS(B,BP_TMP) \
501 for (BP_TMP = bp_locations; \
502 BP_TMP < bp_locations + bp_locations_count && (B = *BP_TMP);\
505 /* Iterates through locations with address ADDRESS for the currently selected
506 program space. BP_LOCP_TMP points to each object. BP_LOCP_START points
507 to where the loop should start from.
508 If BP_LOCP_START is a NULL pointer, the macro automatically seeks the
509 appropriate location to start with. */
511 #define ALL_BP_LOCATIONS_AT_ADDR(BP_LOCP_TMP, BP_LOCP_START, ADDRESS) \
512 for (BP_LOCP_START = BP_LOCP_START == NULL ? get_first_locp_gte_addr (ADDRESS) : BP_LOCP_START, \
513 BP_LOCP_TMP = BP_LOCP_START; \
515 && (BP_LOCP_TMP < bp_locations + bp_locations_count \
516 && (*BP_LOCP_TMP)->address == ADDRESS); \
519 /* Iterator for tracepoints only. */
521 #define ALL_TRACEPOINTS(B) \
522 for (B = breakpoint_chain; B; B = B->next) \
523 if (is_tracepoint (B))
525 /* Chains of all breakpoints defined. */
527 static struct breakpoint
*breakpoint_chain
;
529 /* Array is sorted by bp_location_is_less_than - primarily by the ADDRESS. */
531 static struct bp_location
**bp_locations
;
533 /* Number of elements of BP_LOCATIONS. */
535 static unsigned bp_locations_count
;
537 /* Maximum alignment offset between bp_target_info.PLACED_ADDRESS and
538 ADDRESS for the current elements of BP_LOCATIONS which get a valid
539 result from bp_location_has_shadow. You can use it for roughly
540 limiting the subrange of BP_LOCATIONS to scan for shadow bytes for
541 an address you need to read. */
543 static CORE_ADDR bp_locations_placed_address_before_address_max
;
545 /* Maximum offset plus alignment between bp_target_info.PLACED_ADDRESS
546 + bp_target_info.SHADOW_LEN and ADDRESS for the current elements of
547 BP_LOCATIONS which get a valid result from bp_location_has_shadow.
548 You can use it for roughly limiting the subrange of BP_LOCATIONS to
549 scan for shadow bytes for an address you need to read. */
551 static CORE_ADDR bp_locations_shadow_len_after_address_max
;
553 /* The locations that no longer correspond to any breakpoint, unlinked
554 from the bp_locations array, but for which a hit may still be
555 reported by a target. */
556 static std::vector
<bp_location
*> moribund_locations
;
558 /* Number of last breakpoint made. */
560 static int breakpoint_count
;
562 /* The value of `breakpoint_count' before the last command that
563 created breakpoints. If the last (break-like) command created more
564 than one breakpoint, then the difference between BREAKPOINT_COUNT
565 and PREV_BREAKPOINT_COUNT is more than one. */
566 static int prev_breakpoint_count
;
568 /* Number of last tracepoint made. */
570 static int tracepoint_count
;
572 static struct cmd_list_element
*breakpoint_set_cmdlist
;
573 static struct cmd_list_element
*breakpoint_show_cmdlist
;
574 struct cmd_list_element
*save_cmdlist
;
576 /* See declaration at breakpoint.h. */
579 breakpoint_find_if (int (*func
) (struct breakpoint
*b
, void *d
),
582 struct breakpoint
*b
= NULL
;
586 if (func (b
, user_data
) != 0)
593 /* Return whether a breakpoint is an active enabled breakpoint. */
595 breakpoint_enabled (struct breakpoint
*b
)
597 return (b
->enable_state
== bp_enabled
);
600 /* Set breakpoint count to NUM. */
603 set_breakpoint_count (int num
)
605 prev_breakpoint_count
= breakpoint_count
;
606 breakpoint_count
= num
;
607 set_internalvar_integer (lookup_internalvar ("bpnum"), num
);
610 /* Used by `start_rbreak_breakpoints' below, to record the current
611 breakpoint count before "rbreak" creates any breakpoint. */
612 static int rbreak_start_breakpoint_count
;
614 /* Called at the start an "rbreak" command to record the first
617 scoped_rbreak_breakpoints::scoped_rbreak_breakpoints ()
619 rbreak_start_breakpoint_count
= breakpoint_count
;
622 /* Called at the end of an "rbreak" command to record the last
625 scoped_rbreak_breakpoints::~scoped_rbreak_breakpoints ()
627 prev_breakpoint_count
= rbreak_start_breakpoint_count
;
630 /* Used in run_command to zero the hit count when a new run starts. */
633 clear_breakpoint_hit_counts (void)
635 struct breakpoint
*b
;
642 /* Return the breakpoint with the specified number, or NULL
643 if the number does not refer to an existing breakpoint. */
646 get_breakpoint (int num
)
648 struct breakpoint
*b
;
651 if (b
->number
== num
)
659 /* Mark locations as "conditions have changed" in case the target supports
660 evaluating conditions on its side. */
663 mark_breakpoint_modified (struct breakpoint
*b
)
665 struct bp_location
*loc
;
667 /* This is only meaningful if the target is
668 evaluating conditions and if the user has
669 opted for condition evaluation on the target's
671 if (gdb_evaluates_breakpoint_condition_p ()
672 || !target_supports_evaluation_of_breakpoint_conditions ())
675 if (!is_breakpoint (b
))
678 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
679 loc
->condition_changed
= condition_modified
;
682 /* Mark location as "conditions have changed" in case the target supports
683 evaluating conditions on its side. */
686 mark_breakpoint_location_modified (struct bp_location
*loc
)
688 /* This is only meaningful if the target is
689 evaluating conditions and if the user has
690 opted for condition evaluation on the target's
692 if (gdb_evaluates_breakpoint_condition_p ()
693 || !target_supports_evaluation_of_breakpoint_conditions ())
697 if (!is_breakpoint (loc
->owner
))
700 loc
->condition_changed
= condition_modified
;
703 /* Sets the condition-evaluation mode using the static global
704 condition_evaluation_mode. */
707 set_condition_evaluation_mode (const char *args
, int from_tty
,
708 struct cmd_list_element
*c
)
710 const char *old_mode
, *new_mode
;
712 if ((condition_evaluation_mode_1
== condition_evaluation_target
)
713 && !target_supports_evaluation_of_breakpoint_conditions ())
715 condition_evaluation_mode_1
= condition_evaluation_mode
;
716 warning (_("Target does not support breakpoint condition evaluation.\n"
717 "Using host evaluation mode instead."));
721 new_mode
= translate_condition_evaluation_mode (condition_evaluation_mode_1
);
722 old_mode
= translate_condition_evaluation_mode (condition_evaluation_mode
);
724 /* Flip the switch. Flip it even if OLD_MODE == NEW_MODE as one of the
725 settings was "auto". */
726 condition_evaluation_mode
= condition_evaluation_mode_1
;
728 /* Only update the mode if the user picked a different one. */
729 if (new_mode
!= old_mode
)
731 struct bp_location
*loc
, **loc_tmp
;
732 /* If the user switched to a different evaluation mode, we
733 need to synch the changes with the target as follows:
735 "host" -> "target": Send all (valid) conditions to the target.
736 "target" -> "host": Remove all the conditions from the target.
739 if (new_mode
== condition_evaluation_target
)
741 /* Mark everything modified and synch conditions with the
743 ALL_BP_LOCATIONS (loc
, loc_tmp
)
744 mark_breakpoint_location_modified (loc
);
748 /* Manually mark non-duplicate locations to synch conditions
749 with the target. We do this to remove all the conditions the
750 target knows about. */
751 ALL_BP_LOCATIONS (loc
, loc_tmp
)
752 if (is_breakpoint (loc
->owner
) && loc
->inserted
)
753 loc
->needs_update
= 1;
757 update_global_location_list (UGLL_MAY_INSERT
);
763 /* Shows the current mode of breakpoint condition evaluation. Explicitly shows
764 what "auto" is translating to. */
767 show_condition_evaluation_mode (struct ui_file
*file
, int from_tty
,
768 struct cmd_list_element
*c
, const char *value
)
770 if (condition_evaluation_mode
== condition_evaluation_auto
)
771 fprintf_filtered (file
,
772 _("Breakpoint condition evaluation "
773 "mode is %s (currently %s).\n"),
775 breakpoint_condition_evaluation_mode ());
777 fprintf_filtered (file
, _("Breakpoint condition evaluation mode is %s.\n"),
781 /* A comparison function for bp_location AP and BP that is used by
782 bsearch. This comparison function only cares about addresses, unlike
783 the more general bp_location_is_less_than function. */
786 bp_locations_compare_addrs (const void *ap
, const void *bp
)
788 const struct bp_location
*a
= *(const struct bp_location
**) ap
;
789 const struct bp_location
*b
= *(const struct bp_location
**) bp
;
791 if (a
->address
== b
->address
)
794 return ((a
->address
> b
->address
) - (a
->address
< b
->address
));
797 /* Helper function to skip all bp_locations with addresses
798 less than ADDRESS. It returns the first bp_location that
799 is greater than or equal to ADDRESS. If none is found, just
802 static struct bp_location
**
803 get_first_locp_gte_addr (CORE_ADDR address
)
805 struct bp_location dummy_loc
;
806 struct bp_location
*dummy_locp
= &dummy_loc
;
807 struct bp_location
**locp_found
= NULL
;
809 /* Initialize the dummy location's address field. */
810 dummy_loc
.address
= address
;
812 /* Find a close match to the first location at ADDRESS. */
813 locp_found
= ((struct bp_location
**)
814 bsearch (&dummy_locp
, bp_locations
, bp_locations_count
,
815 sizeof (struct bp_location
**),
816 bp_locations_compare_addrs
));
818 /* Nothing was found, nothing left to do. */
819 if (locp_found
== NULL
)
822 /* We may have found a location that is at ADDRESS but is not the first in the
823 location's list. Go backwards (if possible) and locate the first one. */
824 while ((locp_found
- 1) >= bp_locations
825 && (*(locp_found
- 1))->address
== address
)
831 /* Parse COND_STRING in the context of LOC and set as the condition
832 expression of LOC. BP_NUM is the number of LOC's owner, LOC_NUM is
833 the number of LOC within its owner. In case of parsing error, mark
834 LOC as DISABLED_BY_COND. In case of success, unset DISABLED_BY_COND. */
837 set_breakpoint_location_condition (const char *cond_string
, bp_location
*loc
,
838 int bp_num
, int loc_num
)
840 bool has_junk
= false;
843 expression_up new_exp
= parse_exp_1 (&cond_string
, loc
->address
,
844 block_for_pc (loc
->address
), 0);
845 if (*cond_string
!= 0)
849 loc
->cond
= std::move (new_exp
);
850 if (loc
->disabled_by_cond
&& loc
->enabled
)
851 printf_filtered (_("Breakpoint %d's condition is now valid at "
852 "location %d, enabling.\n"),
855 loc
->disabled_by_cond
= false;
858 catch (const gdb_exception_error
&e
)
862 /* Warn if a user-enabled location is now becoming disabled-by-cond.
863 BP_NUM is 0 if the breakpoint is being defined for the first
864 time using the "break ... if ..." command, and non-zero if
867 warning (_("failed to validate condition at location %d.%d, "
868 "disabling:\n %s"), bp_num
, loc_num
, e
.what ());
870 warning (_("failed to validate condition at location %d, "
871 "disabling:\n %s"), loc_num
, e
.what ());
874 loc
->disabled_by_cond
= true;
878 error (_("Garbage '%s' follows condition"), cond_string
);
882 set_breakpoint_condition (struct breakpoint
*b
, const char *exp
,
883 int from_tty
, bool force
)
887 xfree (b
->cond_string
);
888 b
->cond_string
= nullptr;
890 if (is_watchpoint (b
))
891 static_cast<watchpoint
*> (b
)->cond_exp
.reset ();
895 for (bp_location
*loc
= b
->loc
; loc
!= nullptr; loc
= loc
->next
)
898 if (loc
->disabled_by_cond
&& loc
->enabled
)
899 printf_filtered (_("Breakpoint %d's condition is now valid at "
900 "location %d, enabling.\n"),
902 loc
->disabled_by_cond
= false;
905 /* No need to free the condition agent expression
906 bytecode (if we have one). We will handle this
907 when we go through update_global_location_list. */
912 printf_filtered (_("Breakpoint %d now unconditional.\n"), b
->number
);
916 if (is_watchpoint (b
))
918 innermost_block_tracker tracker
;
919 const char *arg
= exp
;
920 expression_up new_exp
= parse_exp_1 (&arg
, 0, 0, 0, &tracker
);
922 error (_("Junk at end of expression"));
923 watchpoint
*w
= static_cast<watchpoint
*> (b
);
924 w
->cond_exp
= std::move (new_exp
);
925 w
->cond_exp_valid_block
= tracker
.block ();
929 /* Parse and set condition expressions. We make two passes.
930 In the first, we parse the condition string to see if it
931 is valid in at least one location. If so, the condition
932 would be accepted. So we go ahead and set the locations'
933 conditions. In case no valid case is found, we throw
934 the error and the condition string will be rejected.
935 This two-pass approach is taken to avoid setting the
936 state of locations in case of a reject. */
937 for (bp_location
*loc
= b
->loc
; loc
!= nullptr; loc
= loc
->next
)
941 const char *arg
= exp
;
942 parse_exp_1 (&arg
, loc
->address
,
943 block_for_pc (loc
->address
), 0);
945 error (_("Junk at end of expression"));
948 catch (const gdb_exception_error
&e
)
950 /* Condition string is invalid. If this happens to
951 be the last loc, abandon (if not forced) or continue
953 if (loc
->next
== nullptr && !force
)
958 /* If we reach here, the condition is valid at some locations. */
960 for (bp_location
*loc
= b
->loc
; loc
!= nullptr;
961 loc
= loc
->next
, loc_num
++)
962 set_breakpoint_location_condition (exp
, loc
, b
->number
, loc_num
);
965 /* We know that the new condition parsed successfully. The
966 condition string of the breakpoint can be safely updated. */
967 xfree (b
->cond_string
);
968 b
->cond_string
= xstrdup (exp
);
969 b
->condition_not_parsed
= 0;
971 mark_breakpoint_modified (b
);
973 gdb::observers::breakpoint_modified
.notify (b
);
976 /* The options for the "condition" command. */
978 struct condition_command_opts
981 bool force_condition
= false;
984 static const gdb::option::option_def condition_command_option_defs
[] = {
986 gdb::option::flag_option_def
<condition_command_opts
> {
988 [] (condition_command_opts
*opts
) { return &opts
->force_condition
; },
989 N_("Set the condition even if it is invalid for all current locations."),
994 /* Create an option_def_group for the "condition" options, with
995 CC_OPTS as context. */
997 static inline gdb::option::option_def_group
998 make_condition_command_options_def_group (condition_command_opts
*cc_opts
)
1000 return {{condition_command_option_defs
}, cc_opts
};
1003 /* Completion for the "condition" command. */
1006 condition_completer (struct cmd_list_element
*cmd
,
1007 completion_tracker
&tracker
,
1008 const char *text
, const char * /*word*/)
1010 bool has_no_arguments
= (*text
== '\0');
1011 condition_command_opts cc_opts
;
1012 const auto group
= make_condition_command_options_def_group (&cc_opts
);
1013 if (gdb::option::complete_options
1014 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR
, group
))
1017 text
= skip_spaces (text
);
1018 const char *space
= skip_to_space (text
);
1022 struct breakpoint
*b
;
1026 tracker
.advance_custom_word_point_by (1);
1027 /* We don't support completion of history indices. */
1028 if (!isdigit (text
[1]))
1029 complete_internalvar (tracker
, &text
[1]);
1033 /* Suggest the "-force" flag if no arguments are given. If
1034 arguments were passed, they either already include the flag,
1035 or we are beyond the point of suggesting it because it's
1036 positionally the first argument. */
1037 if (has_no_arguments
)
1038 gdb::option::complete_on_all_options (tracker
, group
);
1040 /* We're completing the breakpoint number. */
1041 len
= strlen (text
);
1047 xsnprintf (number
, sizeof (number
), "%d", b
->number
);
1049 if (strncmp (number
, text
, len
) == 0)
1050 tracker
.add_completion (make_unique_xstrdup (number
));
1056 /* We're completing the expression part. Skip the breakpoint num. */
1057 const char *exp_start
= skip_spaces (space
);
1058 tracker
.advance_custom_word_point_by (exp_start
- text
);
1060 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
1061 expression_completer (cmd
, tracker
, text
, word
);
1064 /* condition N EXP -- set break condition of breakpoint N to EXP. */
1067 condition_command (const char *arg
, int from_tty
)
1069 struct breakpoint
*b
;
1074 error_no_arg (_("breakpoint number"));
1078 /* Check if the "-force" flag was passed. */
1079 condition_command_opts cc_opts
;
1080 const auto group
= make_condition_command_options_def_group (&cc_opts
);
1081 gdb::option::process_options
1082 (&p
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR
, group
);
1084 bnum
= get_number (&p
);
1086 error (_("Bad breakpoint argument: '%s'"), arg
);
1089 if (b
->number
== bnum
)
1091 /* Check if this breakpoint has a "stop" method implemented in an
1092 extension language. This method and conditions entered into GDB
1093 from the CLI are mutually exclusive. */
1094 const struct extension_language_defn
*extlang
1095 = get_breakpoint_cond_ext_lang (b
, EXT_LANG_NONE
);
1097 if (extlang
!= NULL
)
1099 error (_("Only one stop condition allowed. There is currently"
1100 " a %s stop condition defined for this breakpoint."),
1101 ext_lang_capitalized_name (extlang
));
1103 set_breakpoint_condition (b
, p
, from_tty
, cc_opts
.force_condition
);
1105 if (is_breakpoint (b
))
1106 update_global_location_list (UGLL_MAY_INSERT
);
1111 error (_("No breakpoint number %d."), bnum
);
1114 /* Check that COMMAND do not contain commands that are suitable
1115 only for tracepoints and not suitable for ordinary breakpoints.
1116 Throw if any such commands is found. */
1119 check_no_tracepoint_commands (struct command_line
*commands
)
1121 struct command_line
*c
;
1123 for (c
= commands
; c
; c
= c
->next
)
1125 if (c
->control_type
== while_stepping_control
)
1126 error (_("The 'while-stepping' command can "
1127 "only be used for tracepoints"));
1129 check_no_tracepoint_commands (c
->body_list_0
.get ());
1130 check_no_tracepoint_commands (c
->body_list_1
.get ());
1132 /* Not that command parsing removes leading whitespace and comment
1133 lines and also empty lines. So, we only need to check for
1134 command directly. */
1135 if (strstr (c
->line
, "collect ") == c
->line
)
1136 error (_("The 'collect' command can only be used for tracepoints"));
1138 if (strstr (c
->line
, "teval ") == c
->line
)
1139 error (_("The 'teval' command can only be used for tracepoints"));
1143 struct longjmp_breakpoint
: public breakpoint
1145 ~longjmp_breakpoint () override
;
1148 /* Encapsulate tests for different types of tracepoints. */
1151 is_tracepoint_type (bptype type
)
1153 return (type
== bp_tracepoint
1154 || type
== bp_fast_tracepoint
1155 || type
== bp_static_tracepoint
);
1159 is_longjmp_type (bptype type
)
1161 return type
== bp_longjmp
|| type
== bp_exception
;
1164 /* See breakpoint.h. */
1167 is_tracepoint (const struct breakpoint
*b
)
1169 return is_tracepoint_type (b
->type
);
1172 /* Factory function to create an appropriate instance of breakpoint given
1175 static std::unique_ptr
<breakpoint
>
1176 new_breakpoint_from_type (bptype type
)
1180 if (is_tracepoint_type (type
))
1181 b
= new tracepoint ();
1182 else if (is_longjmp_type (type
))
1183 b
= new longjmp_breakpoint ();
1185 b
= new breakpoint ();
1187 return std::unique_ptr
<breakpoint
> (b
);
1190 /* A helper function that validates that COMMANDS are valid for a
1191 breakpoint. This function will throw an exception if a problem is
1195 validate_commands_for_breakpoint (struct breakpoint
*b
,
1196 struct command_line
*commands
)
1198 if (is_tracepoint (b
))
1200 struct tracepoint
*t
= (struct tracepoint
*) b
;
1201 struct command_line
*c
;
1202 struct command_line
*while_stepping
= 0;
1204 /* Reset the while-stepping step count. The previous commands
1205 might have included a while-stepping action, while the new
1209 /* We need to verify that each top-level element of commands is
1210 valid for tracepoints, that there's at most one
1211 while-stepping element, and that the while-stepping's body
1212 has valid tracing commands excluding nested while-stepping.
1213 We also need to validate the tracepoint action line in the
1214 context of the tracepoint --- validate_actionline actually
1215 has side effects, like setting the tracepoint's
1216 while-stepping STEP_COUNT, in addition to checking if the
1217 collect/teval actions parse and make sense in the
1218 tracepoint's context. */
1219 for (c
= commands
; c
; c
= c
->next
)
1221 if (c
->control_type
== while_stepping_control
)
1223 if (b
->type
== bp_fast_tracepoint
)
1224 error (_("The 'while-stepping' command "
1225 "cannot be used for fast tracepoint"));
1226 else if (b
->type
== bp_static_tracepoint
)
1227 error (_("The 'while-stepping' command "
1228 "cannot be used for static tracepoint"));
1231 error (_("The 'while-stepping' command "
1232 "can be used only once"));
1237 validate_actionline (c
->line
, b
);
1241 struct command_line
*c2
;
1243 gdb_assert (while_stepping
->body_list_1
== nullptr);
1244 c2
= while_stepping
->body_list_0
.get ();
1245 for (; c2
; c2
= c2
->next
)
1247 if (c2
->control_type
== while_stepping_control
)
1248 error (_("The 'while-stepping' command cannot be nested"));
1254 check_no_tracepoint_commands (commands
);
1258 /* Return a vector of all the static tracepoints set at ADDR. The
1259 caller is responsible for releasing the vector. */
1261 std::vector
<breakpoint
*>
1262 static_tracepoints_here (CORE_ADDR addr
)
1264 struct breakpoint
*b
;
1265 std::vector
<breakpoint
*> found
;
1266 struct bp_location
*loc
;
1269 if (b
->type
== bp_static_tracepoint
)
1271 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1272 if (loc
->address
== addr
)
1273 found
.push_back (b
);
1279 /* Set the command list of B to COMMANDS. If breakpoint is tracepoint,
1280 validate that only allowed commands are included. */
1283 breakpoint_set_commands (struct breakpoint
*b
,
1284 counted_command_line
&&commands
)
1286 validate_commands_for_breakpoint (b
, commands
.get ());
1288 b
->commands
= std::move (commands
);
1289 gdb::observers::breakpoint_modified
.notify (b
);
1292 /* Set the internal `silent' flag on the breakpoint. Note that this
1293 is not the same as the "silent" that may appear in the breakpoint's
1297 breakpoint_set_silent (struct breakpoint
*b
, int silent
)
1299 int old_silent
= b
->silent
;
1302 if (old_silent
!= silent
)
1303 gdb::observers::breakpoint_modified
.notify (b
);
1306 /* Set the thread for this breakpoint. If THREAD is -1, make the
1307 breakpoint work for any thread. */
1310 breakpoint_set_thread (struct breakpoint
*b
, int thread
)
1312 int old_thread
= b
->thread
;
1315 if (old_thread
!= thread
)
1316 gdb::observers::breakpoint_modified
.notify (b
);
1319 /* Set the task for this breakpoint. If TASK is 0, make the
1320 breakpoint work for any task. */
1323 breakpoint_set_task (struct breakpoint
*b
, int task
)
1325 int old_task
= b
->task
;
1328 if (old_task
!= task
)
1329 gdb::observers::breakpoint_modified
.notify (b
);
1333 commands_command_1 (const char *arg
, int from_tty
,
1334 struct command_line
*control
)
1336 counted_command_line cmd
;
1337 /* cmd_read will be true once we have read cmd. Note that cmd might still be
1338 NULL after the call to read_command_lines if the user provides an empty
1339 list of command by just typing "end". */
1340 bool cmd_read
= false;
1342 std::string new_arg
;
1344 if (arg
== NULL
|| !*arg
)
1346 /* Argument not explicitly given. Synthesize it. */
1347 if (breakpoint_count
- prev_breakpoint_count
> 1)
1348 new_arg
= string_printf ("%d-%d", prev_breakpoint_count
+ 1,
1350 else if (breakpoint_count
> 0)
1351 new_arg
= string_printf ("%d", breakpoint_count
);
1355 /* Create a copy of ARG. This is needed because the "commands"
1356 command may be coming from a script. In that case, the read
1357 line buffer is going to be overwritten in the lambda of
1358 'map_breakpoint_numbers' below when reading the next line
1359 before we are are done parsing the breakpoint numbers. */
1362 arg
= new_arg
.c_str ();
1364 map_breakpoint_numbers
1365 (arg
, [&] (breakpoint
*b
)
1369 gdb_assert (cmd
== NULL
);
1370 if (control
!= NULL
)
1371 cmd
= control
->body_list_0
;
1375 = string_printf (_("Type commands for breakpoint(s) "
1376 "%s, one per line."),
1379 auto do_validate
= [=] (const char *line
)
1381 validate_actionline (line
, b
);
1383 gdb::function_view
<void (const char *)> validator
;
1384 if (is_tracepoint (b
))
1385 validator
= do_validate
;
1387 cmd
= read_command_lines (str
.c_str (), from_tty
, 1, validator
);
1392 /* If a breakpoint was on the list more than once, we don't need to
1394 if (b
->commands
!= cmd
)
1396 validate_commands_for_breakpoint (b
, cmd
.get ());
1398 gdb::observers::breakpoint_modified
.notify (b
);
1404 commands_command (const char *arg
, int from_tty
)
1406 commands_command_1 (arg
, from_tty
, NULL
);
1409 /* Like commands_command, but instead of reading the commands from
1410 input stream, takes them from an already parsed command structure.
1412 This is used by cli-script.c to DTRT with breakpoint commands
1413 that are part of if and while bodies. */
1414 enum command_control_type
1415 commands_from_control_command (const char *arg
, struct command_line
*cmd
)
1417 commands_command_1 (arg
, 0, cmd
);
1418 return simple_control
;
1421 /* Return non-zero if BL->TARGET_INFO contains valid information. */
1424 bp_location_has_shadow (struct bp_location
*bl
)
1426 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
1430 if (bl
->target_info
.shadow_len
== 0)
1431 /* BL isn't valid, or doesn't shadow memory. */
1436 /* Update BUF, which is LEN bytes read from the target address
1437 MEMADDR, by replacing a memory breakpoint with its shadowed
1440 If READBUF is not NULL, this buffer must not overlap with the of
1441 the breakpoint location's shadow_contents buffer. Otherwise, a
1442 failed assertion internal error will be raised. */
1445 one_breakpoint_xfer_memory (gdb_byte
*readbuf
, gdb_byte
*writebuf
,
1446 const gdb_byte
*writebuf_org
,
1447 ULONGEST memaddr
, LONGEST len
,
1448 struct bp_target_info
*target_info
,
1449 struct gdbarch
*gdbarch
)
1451 /* Now do full processing of the found relevant range of elements. */
1452 CORE_ADDR bp_addr
= 0;
1456 if (!breakpoint_address_match (target_info
->placed_address_space
, 0,
1457 current_program_space
->aspace
, 0))
1459 /* The breakpoint is inserted in a different address space. */
1463 /* Addresses and length of the part of the breakpoint that
1465 bp_addr
= target_info
->placed_address
;
1466 bp_size
= target_info
->shadow_len
;
1468 if (bp_addr
+ bp_size
<= memaddr
)
1470 /* The breakpoint is entirely before the chunk of memory we are
1475 if (bp_addr
>= memaddr
+ len
)
1477 /* The breakpoint is entirely after the chunk of memory we are
1482 /* Offset within shadow_contents. */
1483 if (bp_addr
< memaddr
)
1485 /* Only copy the second part of the breakpoint. */
1486 bp_size
-= memaddr
- bp_addr
;
1487 bptoffset
= memaddr
- bp_addr
;
1491 if (bp_addr
+ bp_size
> memaddr
+ len
)
1493 /* Only copy the first part of the breakpoint. */
1494 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
1497 if (readbuf
!= NULL
)
1499 /* Verify that the readbuf buffer does not overlap with the
1500 shadow_contents buffer. */
1501 gdb_assert (target_info
->shadow_contents
>= readbuf
+ len
1502 || readbuf
>= (target_info
->shadow_contents
1503 + target_info
->shadow_len
));
1505 /* Update the read buffer with this inserted breakpoint's
1507 memcpy (readbuf
+ bp_addr
- memaddr
,
1508 target_info
->shadow_contents
+ bptoffset
, bp_size
);
1512 const unsigned char *bp
;
1513 CORE_ADDR addr
= target_info
->reqstd_address
;
1516 /* Update the shadow with what we want to write to memory. */
1517 memcpy (target_info
->shadow_contents
+ bptoffset
,
1518 writebuf_org
+ bp_addr
- memaddr
, bp_size
);
1520 /* Determine appropriate breakpoint contents and size for this
1522 bp
= gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &placed_size
);
1524 /* Update the final write buffer with this inserted
1525 breakpoint's INSN. */
1526 memcpy (writebuf
+ bp_addr
- memaddr
, bp
+ bptoffset
, bp_size
);
1530 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
1531 by replacing any memory breakpoints with their shadowed contents.
1533 If READBUF is not NULL, this buffer must not overlap with any of
1534 the breakpoint location's shadow_contents buffers. Otherwise,
1535 a failed assertion internal error will be raised.
1537 The range of shadowed area by each bp_location is:
1538 bl->address - bp_locations_placed_address_before_address_max
1539 up to bl->address + bp_locations_shadow_len_after_address_max
1540 The range we were requested to resolve shadows for is:
1541 memaddr ... memaddr + len
1542 Thus the safe cutoff boundaries for performance optimization are
1543 memaddr + len <= (bl->address
1544 - bp_locations_placed_address_before_address_max)
1546 bl->address + bp_locations_shadow_len_after_address_max <= memaddr */
1549 breakpoint_xfer_memory (gdb_byte
*readbuf
, gdb_byte
*writebuf
,
1550 const gdb_byte
*writebuf_org
,
1551 ULONGEST memaddr
, LONGEST len
)
1553 /* Left boundary, right boundary and median element of our binary
1555 unsigned bc_l
, bc_r
, bc
;
1557 /* Find BC_L which is a leftmost element which may affect BUF
1558 content. It is safe to report lower value but a failure to
1559 report higher one. */
1562 bc_r
= bp_locations_count
;
1563 while (bc_l
+ 1 < bc_r
)
1565 struct bp_location
*bl
;
1567 bc
= (bc_l
+ bc_r
) / 2;
1568 bl
= bp_locations
[bc
];
1570 /* Check first BL->ADDRESS will not overflow due to the added
1571 constant. Then advance the left boundary only if we are sure
1572 the BC element can in no way affect the BUF content (MEMADDR
1573 to MEMADDR + LEN range).
1575 Use the BP_LOCATIONS_SHADOW_LEN_AFTER_ADDRESS_MAX safety
1576 offset so that we cannot miss a breakpoint with its shadow
1577 range tail still reaching MEMADDR. */
1579 if ((bl
->address
+ bp_locations_shadow_len_after_address_max
1581 && (bl
->address
+ bp_locations_shadow_len_after_address_max
1588 /* Due to the binary search above, we need to make sure we pick the
1589 first location that's at BC_L's address. E.g., if there are
1590 multiple locations at the same address, BC_L may end up pointing
1591 at a duplicate location, and miss the "master"/"inserted"
1592 location. Say, given locations L1, L2 and L3 at addresses A and
1595 L1@A, L2@A, L3@B, ...
1597 BC_L could end up pointing at location L2, while the "master"
1598 location could be L1. Since the `loc->inserted' flag is only set
1599 on "master" locations, we'd forget to restore the shadow of L1
1602 && bp_locations
[bc_l
]->address
== bp_locations
[bc_l
- 1]->address
)
1605 /* Now do full processing of the found relevant range of elements. */
1607 for (bc
= bc_l
; bc
< bp_locations_count
; bc
++)
1609 struct bp_location
*bl
= bp_locations
[bc
];
1611 /* bp_location array has BL->OWNER always non-NULL. */
1612 if (bl
->owner
->type
== bp_none
)
1613 warning (_("reading through apparently deleted breakpoint #%d?"),
1616 /* Performance optimization: any further element can no longer affect BUF
1619 if (bl
->address
>= bp_locations_placed_address_before_address_max
1620 && memaddr
+ len
<= (bl
->address
1621 - bp_locations_placed_address_before_address_max
))
1624 if (!bp_location_has_shadow (bl
))
1627 one_breakpoint_xfer_memory (readbuf
, writebuf
, writebuf_org
,
1628 memaddr
, len
, &bl
->target_info
, bl
->gdbarch
);
1632 /* See breakpoint.h. */
1635 is_breakpoint (const struct breakpoint
*bpt
)
1637 return (bpt
->type
== bp_breakpoint
1638 || bpt
->type
== bp_hardware_breakpoint
1639 || bpt
->type
== bp_dprintf
);
1642 /* Return true if BPT is of any hardware watchpoint kind. */
1645 is_hardware_watchpoint (const struct breakpoint
*bpt
)
1647 return (bpt
->type
== bp_hardware_watchpoint
1648 || bpt
->type
== bp_read_watchpoint
1649 || bpt
->type
== bp_access_watchpoint
);
1652 /* See breakpoint.h. */
1655 is_watchpoint (const struct breakpoint
*bpt
)
1657 return (is_hardware_watchpoint (bpt
)
1658 || bpt
->type
== bp_watchpoint
);
1661 /* Returns true if the current thread and its running state are safe
1662 to evaluate or update watchpoint B. Watchpoints on local
1663 expressions need to be evaluated in the context of the thread that
1664 was current when the watchpoint was created, and, that thread needs
1665 to be stopped to be able to select the correct frame context.
1666 Watchpoints on global expressions can be evaluated on any thread,
1667 and in any state. It is presently left to the target allowing
1668 memory accesses when threads are running. */
1671 watchpoint_in_thread_scope (struct watchpoint
*b
)
1673 return (b
->pspace
== current_program_space
1674 && (b
->watchpoint_thread
== null_ptid
1675 || (inferior_ptid
== b
->watchpoint_thread
1676 && !inferior_thread ()->executing
)));
1679 /* Set watchpoint B to disp_del_at_next_stop, even including its possible
1680 associated bp_watchpoint_scope breakpoint. */
1683 watchpoint_del_at_next_stop (struct watchpoint
*w
)
1685 if (w
->related_breakpoint
!= w
)
1687 gdb_assert (w
->related_breakpoint
->type
== bp_watchpoint_scope
);
1688 gdb_assert (w
->related_breakpoint
->related_breakpoint
== w
);
1689 w
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
1690 w
->related_breakpoint
->related_breakpoint
= w
->related_breakpoint
;
1691 w
->related_breakpoint
= w
;
1693 w
->disposition
= disp_del_at_next_stop
;
1696 /* Extract a bitfield value from value VAL using the bit parameters contained in
1699 static struct value
*
1700 extract_bitfield_from_watchpoint_value (struct watchpoint
*w
, struct value
*val
)
1702 struct value
*bit_val
;
1707 bit_val
= allocate_value (value_type (val
));
1709 unpack_value_bitfield (bit_val
,
1712 value_contents_for_printing (val
),
1719 /* Allocate a dummy location and add it to B, which must be a software
1720 watchpoint. This is required because even if a software watchpoint
1721 is not watching any memory, bpstat_stop_status requires a location
1722 to be able to report stops. */
1725 software_watchpoint_add_no_memory_location (struct breakpoint
*b
,
1726 struct program_space
*pspace
)
1728 gdb_assert (b
->type
== bp_watchpoint
&& b
->loc
== NULL
);
1730 b
->loc
= allocate_bp_location (b
);
1731 b
->loc
->pspace
= pspace
;
1732 b
->loc
->address
= -1;
1733 b
->loc
->length
= -1;
1736 /* Returns true if B is a software watchpoint that is not watching any
1737 memory (e.g., "watch $pc"). */
1740 is_no_memory_software_watchpoint (struct breakpoint
*b
)
1742 return (b
->type
== bp_watchpoint
1744 && b
->loc
->next
== NULL
1745 && b
->loc
->address
== -1
1746 && b
->loc
->length
== -1);
1749 /* Assuming that B is a watchpoint:
1750 - Reparse watchpoint expression, if REPARSE is non-zero
1751 - Evaluate expression and store the result in B->val
1752 - Evaluate the condition if there is one, and store the result
1754 - Update the list of values that must be watched in B->loc.
1756 If the watchpoint disposition is disp_del_at_next_stop, then do
1757 nothing. If this is local watchpoint that is out of scope, delete
1760 Even with `set breakpoint always-inserted on' the watchpoints are
1761 removed + inserted on each stop here. Normal breakpoints must
1762 never be removed because they might be missed by a running thread
1763 when debugging in non-stop mode. On the other hand, hardware
1764 watchpoints (is_hardware_watchpoint; processed here) are specific
1765 to each LWP since they are stored in each LWP's hardware debug
1766 registers. Therefore, such LWP must be stopped first in order to
1767 be able to modify its hardware watchpoints.
1769 Hardware watchpoints must be reset exactly once after being
1770 presented to the user. It cannot be done sooner, because it would
1771 reset the data used to present the watchpoint hit to the user. And
1772 it must not be done later because it could display the same single
1773 watchpoint hit during multiple GDB stops. Note that the latter is
1774 relevant only to the hardware watchpoint types bp_read_watchpoint
1775 and bp_access_watchpoint. False hit by bp_hardware_watchpoint is
1776 not user-visible - its hit is suppressed if the memory content has
1779 The following constraints influence the location where we can reset
1780 hardware watchpoints:
1782 * target_stopped_by_watchpoint and target_stopped_data_address are
1783 called several times when GDB stops.
1786 * Multiple hardware watchpoints can be hit at the same time,
1787 causing GDB to stop. GDB only presents one hardware watchpoint
1788 hit at a time as the reason for stopping, and all the other hits
1789 are presented later, one after the other, each time the user
1790 requests the execution to be resumed. Execution is not resumed
1791 for the threads still having pending hit event stored in
1792 LWP_INFO->STATUS. While the watchpoint is already removed from
1793 the inferior on the first stop the thread hit event is kept being
1794 reported from its cached value by linux_nat_stopped_data_address
1795 until the real thread resume happens after the watchpoint gets
1796 presented and thus its LWP_INFO->STATUS gets reset.
1798 Therefore the hardware watchpoint hit can get safely reset on the
1799 watchpoint removal from inferior. */
1802 update_watchpoint (struct watchpoint
*b
, int reparse
)
1804 int within_current_scope
;
1805 struct frame_id saved_frame_id
;
1808 /* If this is a local watchpoint, we only want to check if the
1809 watchpoint frame is in scope if the current thread is the thread
1810 that was used to create the watchpoint. */
1811 if (!watchpoint_in_thread_scope (b
))
1814 if (b
->disposition
== disp_del_at_next_stop
)
1819 /* Determine if the watchpoint is within scope. */
1820 if (b
->exp_valid_block
== NULL
)
1821 within_current_scope
= 1;
1824 struct frame_info
*fi
= get_current_frame ();
1825 struct gdbarch
*frame_arch
= get_frame_arch (fi
);
1826 CORE_ADDR frame_pc
= get_frame_pc (fi
);
1828 /* If we're at a point where the stack has been destroyed
1829 (e.g. in a function epilogue), unwinding may not work
1830 properly. Do not attempt to recreate locations at this
1831 point. See similar comments in watchpoint_check. */
1832 if (gdbarch_stack_frame_destroyed_p (frame_arch
, frame_pc
))
1835 /* Save the current frame's ID so we can restore it after
1836 evaluating the watchpoint expression on its own frame. */
1837 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
1838 took a frame parameter, so that we didn't have to change the
1841 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
1843 fi
= frame_find_by_id (b
->watchpoint_frame
);
1844 within_current_scope
= (fi
!= NULL
);
1845 if (within_current_scope
)
1849 /* We don't free locations. They are stored in the bp_location array
1850 and update_global_location_list will eventually delete them and
1851 remove breakpoints if needed. */
1854 if (within_current_scope
&& reparse
)
1859 s
= b
->exp_string_reparse
? b
->exp_string_reparse
: b
->exp_string
;
1860 b
->exp
= parse_exp_1 (&s
, 0, b
->exp_valid_block
, 0);
1861 /* If the meaning of expression itself changed, the old value is
1862 no longer relevant. We don't want to report a watchpoint hit
1863 to the user when the old value and the new value may actually
1864 be completely different objects. */
1866 b
->val_valid
= false;
1868 /* Note that unlike with breakpoints, the watchpoint's condition
1869 expression is stored in the breakpoint object, not in the
1870 locations (re)created below. */
1871 if (b
->cond_string
!= NULL
)
1873 b
->cond_exp
.reset ();
1876 b
->cond_exp
= parse_exp_1 (&s
, 0, b
->cond_exp_valid_block
, 0);
1880 /* If we failed to parse the expression, for example because
1881 it refers to a global variable in a not-yet-loaded shared library,
1882 don't try to insert watchpoint. We don't automatically delete
1883 such watchpoint, though, since failure to parse expression
1884 is different from out-of-scope watchpoint. */
1885 if (!target_has_execution ())
1887 /* Without execution, memory can't change. No use to try and
1888 set watchpoint locations. The watchpoint will be reset when
1889 the target gains execution, through breakpoint_re_set. */
1890 if (!can_use_hw_watchpoints
)
1892 if (b
->ops
->works_in_software_mode (b
))
1893 b
->type
= bp_watchpoint
;
1895 error (_("Can't set read/access watchpoint when "
1896 "hardware watchpoints are disabled."));
1899 else if (within_current_scope
&& b
->exp
)
1902 std::vector
<value_ref_ptr
> val_chain
;
1903 struct value
*v
, *result
;
1904 struct program_space
*frame_pspace
;
1906 fetch_subexp_value (b
->exp
.get (), &pc
, &v
, &result
, &val_chain
, false);
1908 /* Avoid setting b->val if it's already set. The meaning of
1909 b->val is 'the last value' user saw, and we should update
1910 it only if we reported that last value to user. As it
1911 happens, the code that reports it updates b->val directly.
1912 We don't keep track of the memory value for masked
1914 if (!b
->val_valid
&& !is_masked_watchpoint (b
))
1916 if (b
->val_bitsize
!= 0)
1917 v
= extract_bitfield_from_watchpoint_value (b
, v
);
1918 b
->val
= release_value (v
);
1919 b
->val_valid
= true;
1922 frame_pspace
= get_frame_program_space (get_selected_frame (NULL
));
1924 /* Look at each value on the value chain. */
1925 gdb_assert (!val_chain
.empty ());
1926 for (const value_ref_ptr
&iter
: val_chain
)
1930 /* If it's a memory location, and GDB actually needed
1931 its contents to evaluate the expression, then we
1932 must watch it. If the first value returned is
1933 still lazy, that means an error occurred reading it;
1934 watch it anyway in case it becomes readable. */
1935 if (VALUE_LVAL (v
) == lval_memory
1936 && (v
== val_chain
[0] || ! value_lazy (v
)))
1938 struct type
*vtype
= check_typedef (value_type (v
));
1940 /* We only watch structs and arrays if user asked
1941 for it explicitly, never if they just happen to
1942 appear in the middle of some value chain. */
1944 || (vtype
->code () != TYPE_CODE_STRUCT
1945 && vtype
->code () != TYPE_CODE_ARRAY
))
1948 enum target_hw_bp_type type
;
1949 struct bp_location
*loc
, **tmp
;
1950 int bitpos
= 0, bitsize
= 0;
1952 if (value_bitsize (v
) != 0)
1954 /* Extract the bit parameters out from the bitfield
1956 bitpos
= value_bitpos (v
);
1957 bitsize
= value_bitsize (v
);
1959 else if (v
== result
&& b
->val_bitsize
!= 0)
1961 /* If VAL_BITSIZE != 0 then RESULT is actually a bitfield
1962 lvalue whose bit parameters are saved in the fields
1963 VAL_BITPOS and VAL_BITSIZE. */
1964 bitpos
= b
->val_bitpos
;
1965 bitsize
= b
->val_bitsize
;
1968 addr
= value_address (v
);
1971 /* Skip the bytes that don't contain the bitfield. */
1976 if (b
->type
== bp_read_watchpoint
)
1978 else if (b
->type
== bp_access_watchpoint
)
1981 loc
= allocate_bp_location (b
);
1982 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
1985 loc
->gdbarch
= value_type (v
)->arch ();
1987 loc
->pspace
= frame_pspace
;
1988 loc
->address
= address_significant (loc
->gdbarch
, addr
);
1992 /* Just cover the bytes that make up the bitfield. */
1993 loc
->length
= ((bitpos
% 8) + bitsize
+ 7) / 8;
1996 loc
->length
= TYPE_LENGTH (value_type (v
));
1998 loc
->watchpoint_type
= type
;
2003 /* Change the type of breakpoint between hardware assisted or
2004 an ordinary watchpoint depending on the hardware support
2005 and free hardware slots. REPARSE is set when the inferior
2010 enum bp_loc_type loc_type
;
2011 struct bp_location
*bl
;
2013 reg_cnt
= can_use_hardware_watchpoint (val_chain
);
2017 int i
, target_resources_ok
, other_type_used
;
2020 /* Use an exact watchpoint when there's only one memory region to be
2021 watched, and only one debug register is needed to watch it. */
2022 b
->exact
= target_exact_watchpoints
&& reg_cnt
== 1;
2024 /* We need to determine how many resources are already
2025 used for all other hardware watchpoints plus this one
2026 to see if we still have enough resources to also fit
2027 this watchpoint in as well. */
2029 /* If this is a software watchpoint, we try to turn it
2030 to a hardware one -- count resources as if B was of
2031 hardware watchpoint type. */
2033 if (type
== bp_watchpoint
)
2034 type
= bp_hardware_watchpoint
;
2036 /* This watchpoint may or may not have been placed on
2037 the list yet at this point (it won't be in the list
2038 if we're trying to create it for the first time,
2039 through watch_command), so always account for it
2042 /* Count resources used by all watchpoints except B. */
2043 i
= hw_watchpoint_used_count_others (b
, type
, &other_type_used
);
2045 /* Add in the resources needed for B. */
2046 i
+= hw_watchpoint_use_count (b
);
2049 = target_can_use_hardware_watchpoint (type
, i
, other_type_used
);
2050 if (target_resources_ok
<= 0)
2052 int sw_mode
= b
->ops
->works_in_software_mode (b
);
2054 if (target_resources_ok
== 0 && !sw_mode
)
2055 error (_("Target does not support this type of "
2056 "hardware watchpoint."));
2057 else if (target_resources_ok
< 0 && !sw_mode
)
2058 error (_("There are not enough available hardware "
2059 "resources for this watchpoint."));
2061 /* Downgrade to software watchpoint. */
2062 b
->type
= bp_watchpoint
;
2066 /* If this was a software watchpoint, we've just
2067 found we have enough resources to turn it to a
2068 hardware watchpoint. Otherwise, this is a
2073 else if (!b
->ops
->works_in_software_mode (b
))
2075 if (!can_use_hw_watchpoints
)
2076 error (_("Can't set read/access watchpoint when "
2077 "hardware watchpoints are disabled."));
2079 error (_("Expression cannot be implemented with "
2080 "read/access watchpoint."));
2083 b
->type
= bp_watchpoint
;
2085 loc_type
= (b
->type
== bp_watchpoint
? bp_loc_other
2086 : bp_loc_hardware_watchpoint
);
2087 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
2088 bl
->loc_type
= loc_type
;
2091 /* If a software watchpoint is not watching any memory, then the
2092 above left it without any location set up. But,
2093 bpstat_stop_status requires a location to be able to report
2094 stops, so make sure there's at least a dummy one. */
2095 if (b
->type
== bp_watchpoint
&& b
->loc
== NULL
)
2096 software_watchpoint_add_no_memory_location (b
, frame_pspace
);
2098 else if (!within_current_scope
)
2100 printf_filtered (_("\
2101 Watchpoint %d deleted because the program has left the block\n\
2102 in which its expression is valid.\n"),
2104 watchpoint_del_at_next_stop (b
);
2107 /* Restore the selected frame. */
2109 select_frame (frame_find_by_id (saved_frame_id
));
2113 /* Returns 1 iff breakpoint location should be
2114 inserted in the inferior. We don't differentiate the type of BL's owner
2115 (breakpoint vs. tracepoint), although insert_location in tracepoint's
2116 breakpoint_ops is not defined, because in insert_bp_location,
2117 tracepoint's insert_location will not be called. */
2119 should_be_inserted (struct bp_location
*bl
)
2121 if (bl
->owner
== NULL
|| !breakpoint_enabled (bl
->owner
))
2124 if (bl
->owner
->disposition
== disp_del_at_next_stop
)
2127 if (!bl
->enabled
|| bl
->disabled_by_cond
2128 || bl
->shlib_disabled
|| bl
->duplicate
)
2131 if (user_breakpoint_p (bl
->owner
) && bl
->pspace
->executing_startup
)
2134 /* This is set for example, when we're attached to the parent of a
2135 vfork, and have detached from the child. The child is running
2136 free, and we expect it to do an exec or exit, at which point the
2137 OS makes the parent schedulable again (and the target reports
2138 that the vfork is done). Until the child is done with the shared
2139 memory region, do not insert breakpoints in the parent, otherwise
2140 the child could still trip on the parent's breakpoints. Since
2141 the parent is blocked anyway, it won't miss any breakpoint. */
2142 if (bl
->pspace
->breakpoints_not_allowed
)
2145 /* Don't insert a breakpoint if we're trying to step past its
2146 location, except if the breakpoint is a single-step breakpoint,
2147 and the breakpoint's thread is the thread which is stepping past
2149 if ((bl
->loc_type
== bp_loc_software_breakpoint
2150 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
2151 && stepping_past_instruction_at (bl
->pspace
->aspace
,
2153 /* The single-step breakpoint may be inserted at the location
2154 we're trying to step if the instruction branches to itself.
2155 However, the instruction won't be executed at all and it may
2156 break the semantics of the instruction, for example, the
2157 instruction is a conditional branch or updates some flags.
2158 We can't fix it unless GDB is able to emulate the instruction
2159 or switch to displaced stepping. */
2160 && !(bl
->owner
->type
== bp_single_step
2161 && thread_is_stepping_over_breakpoint (bl
->owner
->thread
)))
2163 infrun_debug_printf ("skipping breakpoint: stepping past insn at: %s",
2164 paddress (bl
->gdbarch
, bl
->address
));
2168 /* Don't insert watchpoints if we're trying to step past the
2169 instruction that triggered one. */
2170 if ((bl
->loc_type
== bp_loc_hardware_watchpoint
)
2171 && stepping_past_nonsteppable_watchpoint ())
2173 infrun_debug_printf ("stepping past non-steppable watchpoint. "
2174 "skipping watchpoint at %s:%d",
2175 paddress (bl
->gdbarch
, bl
->address
), bl
->length
);
2182 /* Same as should_be_inserted but does the check assuming
2183 that the location is not duplicated. */
2186 unduplicated_should_be_inserted (struct bp_location
*bl
)
2189 const int save_duplicate
= bl
->duplicate
;
2192 result
= should_be_inserted (bl
);
2193 bl
->duplicate
= save_duplicate
;
2197 /* Parses a conditional described by an expression COND into an
2198 agent expression bytecode suitable for evaluation
2199 by the bytecode interpreter. Return NULL if there was
2200 any error during parsing. */
2202 static agent_expr_up
2203 parse_cond_to_aexpr (CORE_ADDR scope
, struct expression
*cond
)
2208 agent_expr_up aexpr
;
2210 /* We don't want to stop processing, so catch any errors
2211 that may show up. */
2214 aexpr
= gen_eval_for_expr (scope
, cond
);
2217 catch (const gdb_exception_error
&ex
)
2219 /* If we got here, it means the condition could not be parsed to a valid
2220 bytecode expression and thus can't be evaluated on the target's side.
2221 It's no use iterating through the conditions. */
2224 /* We have a valid agent expression. */
2228 /* Based on location BL, create a list of breakpoint conditions to be
2229 passed on to the target. If we have duplicated locations with different
2230 conditions, we will add such conditions to the list. The idea is that the
2231 target will evaluate the list of conditions and will only notify GDB when
2232 one of them is true. */
2235 build_target_condition_list (struct bp_location
*bl
)
2237 struct bp_location
**locp
= NULL
, **loc2p
;
2238 int null_condition_or_parse_error
= 0;
2239 int modified
= bl
->needs_update
;
2240 struct bp_location
*loc
;
2242 /* Release conditions left over from a previous insert. */
2243 bl
->target_info
.conditions
.clear ();
2245 /* This is only meaningful if the target is
2246 evaluating conditions and if the user has
2247 opted for condition evaluation on the target's
2249 if (gdb_evaluates_breakpoint_condition_p ()
2250 || !target_supports_evaluation_of_breakpoint_conditions ())
2253 /* Do a first pass to check for locations with no assigned
2254 conditions or conditions that fail to parse to a valid agent
2255 expression bytecode. If any of these happen, then it's no use to
2256 send conditions to the target since this location will always
2257 trigger and generate a response back to GDB. Note we consider
2258 all locations at the same address irrespective of type, i.e.,
2259 even if the locations aren't considered duplicates (e.g.,
2260 software breakpoint and hardware breakpoint at the same
2262 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2265 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2269 /* Re-parse the conditions since something changed. In that
2270 case we already freed the condition bytecodes (see
2271 force_breakpoint_reinsertion). We just
2272 need to parse the condition to bytecodes again. */
2273 loc
->cond_bytecode
= parse_cond_to_aexpr (bl
->address
,
2277 /* If we have a NULL bytecode expression, it means something
2278 went wrong or we have a null condition expression. */
2279 if (!loc
->cond_bytecode
)
2281 null_condition_or_parse_error
= 1;
2287 /* If any of these happened, it means we will have to evaluate the conditions
2288 for the location's address on gdb's side. It is no use keeping bytecodes
2289 for all the other duplicate locations, thus we free all of them here.
2291 This is so we have a finer control over which locations' conditions are
2292 being evaluated by GDB or the remote stub. */
2293 if (null_condition_or_parse_error
)
2295 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2298 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2300 /* Only go as far as the first NULL bytecode is
2302 if (!loc
->cond_bytecode
)
2305 loc
->cond_bytecode
.reset ();
2310 /* No NULL conditions or failed bytecode generation. Build a
2311 condition list for this location's address. If we have software
2312 and hardware locations at the same address, they aren't
2313 considered duplicates, but we still marge all the conditions
2314 anyway, as it's simpler, and doesn't really make a practical
2316 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2320 && is_breakpoint (loc
->owner
)
2321 && loc
->pspace
->num
== bl
->pspace
->num
2322 && loc
->owner
->enable_state
== bp_enabled
2324 && !loc
->disabled_by_cond
)
2326 /* Add the condition to the vector. This will be used later
2327 to send the conditions to the target. */
2328 bl
->target_info
.conditions
.push_back (loc
->cond_bytecode
.get ());
2335 /* Parses a command described by string CMD into an agent expression
2336 bytecode suitable for evaluation by the bytecode interpreter.
2337 Return NULL if there was any error during parsing. */
2339 static agent_expr_up
2340 parse_cmd_to_aexpr (CORE_ADDR scope
, char *cmd
)
2342 const char *cmdrest
;
2343 const char *format_start
, *format_end
;
2344 struct gdbarch
*gdbarch
= get_current_arch ();
2351 if (*cmdrest
== ',')
2353 cmdrest
= skip_spaces (cmdrest
);
2355 if (*cmdrest
++ != '"')
2356 error (_("No format string following the location"));
2358 format_start
= cmdrest
;
2360 format_pieces
fpieces (&cmdrest
);
2362 format_end
= cmdrest
;
2364 if (*cmdrest
++ != '"')
2365 error (_("Bad format string, non-terminated '\"'."));
2367 cmdrest
= skip_spaces (cmdrest
);
2369 if (!(*cmdrest
== ',' || *cmdrest
== '\0'))
2370 error (_("Invalid argument syntax"));
2372 if (*cmdrest
== ',')
2374 cmdrest
= skip_spaces (cmdrest
);
2376 /* For each argument, make an expression. */
2378 std::vector
<struct expression
*> argvec
;
2379 while (*cmdrest
!= '\0')
2384 expression_up expr
= parse_exp_1 (&cmd1
, scope
, block_for_pc (scope
), 1);
2385 argvec
.push_back (expr
.release ());
2387 if (*cmdrest
== ',')
2391 agent_expr_up aexpr
;
2393 /* We don't want to stop processing, so catch any errors
2394 that may show up. */
2397 aexpr
= gen_printf (scope
, gdbarch
, 0, 0,
2398 format_start
, format_end
- format_start
,
2399 argvec
.size (), argvec
.data ());
2401 catch (const gdb_exception_error
&ex
)
2403 /* If we got here, it means the command could not be parsed to a valid
2404 bytecode expression and thus can't be evaluated on the target's side.
2405 It's no use iterating through the other commands. */
2408 /* We have a valid agent expression, return it. */
2412 /* Based on location BL, create a list of breakpoint commands to be
2413 passed on to the target. If we have duplicated locations with
2414 different commands, we will add any such to the list. */
2417 build_target_command_list (struct bp_location
*bl
)
2419 struct bp_location
**locp
= NULL
, **loc2p
;
2420 int null_command_or_parse_error
= 0;
2421 int modified
= bl
->needs_update
;
2422 struct bp_location
*loc
;
2424 /* Clear commands left over from a previous insert. */
2425 bl
->target_info
.tcommands
.clear ();
2427 if (!target_can_run_breakpoint_commands ())
2430 /* For now, limit to agent-style dprintf breakpoints. */
2431 if (dprintf_style
!= dprintf_style_agent
)
2434 /* For now, if we have any location at the same address that isn't a
2435 dprintf, don't install the target-side commands, as that would
2436 make the breakpoint not be reported to the core, and we'd lose
2438 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2441 if (is_breakpoint (loc
->owner
)
2442 && loc
->pspace
->num
== bl
->pspace
->num
2443 && loc
->owner
->type
!= bp_dprintf
)
2447 /* Do a first pass to check for locations with no assigned
2448 conditions or conditions that fail to parse to a valid agent expression
2449 bytecode. If any of these happen, then it's no use to send conditions
2450 to the target since this location will always trigger and generate a
2451 response back to GDB. */
2452 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2455 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2459 /* Re-parse the commands since something changed. In that
2460 case we already freed the command bytecodes (see
2461 force_breakpoint_reinsertion). We just
2462 need to parse the command to bytecodes again. */
2464 = parse_cmd_to_aexpr (bl
->address
,
2465 loc
->owner
->extra_string
);
2468 /* If we have a NULL bytecode expression, it means something
2469 went wrong or we have a null command expression. */
2470 if (!loc
->cmd_bytecode
)
2472 null_command_or_parse_error
= 1;
2478 /* If anything failed, then we're not doing target-side commands,
2480 if (null_command_or_parse_error
)
2482 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2485 if (is_breakpoint (loc
->owner
)
2486 && loc
->pspace
->num
== bl
->pspace
->num
)
2488 /* Only go as far as the first NULL bytecode is
2490 if (loc
->cmd_bytecode
== NULL
)
2493 loc
->cmd_bytecode
.reset ();
2498 /* No NULL commands or failed bytecode generation. Build a command
2499 list for all duplicate locations at this location's address.
2500 Note that here we must care for whether the breakpoint location
2501 types are considered duplicates, otherwise, say, if we have a
2502 software and hardware location at the same address, the target
2503 could end up running the commands twice. For the moment, we only
2504 support targets-side commands with dprintf, but it doesn't hurt
2505 to be pedantically correct in case that changes. */
2506 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2509 if (breakpoint_locations_match (bl
, loc
)
2510 && loc
->owner
->extra_string
2511 && is_breakpoint (loc
->owner
)
2512 && loc
->pspace
->num
== bl
->pspace
->num
2513 && loc
->owner
->enable_state
== bp_enabled
2515 && !loc
->disabled_by_cond
)
2517 /* Add the command to the vector. This will be used later
2518 to send the commands to the target. */
2519 bl
->target_info
.tcommands
.push_back (loc
->cmd_bytecode
.get ());
2523 bl
->target_info
.persist
= 0;
2524 /* Maybe flag this location as persistent. */
2525 if (bl
->owner
->type
== bp_dprintf
&& disconnected_dprintf
)
2526 bl
->target_info
.persist
= 1;
2529 /* Return the kind of breakpoint on address *ADDR. Get the kind
2530 of breakpoint according to ADDR except single-step breakpoint.
2531 Get the kind of single-step breakpoint according to the current
2535 breakpoint_kind (struct bp_location
*bl
, CORE_ADDR
*addr
)
2537 if (bl
->owner
->type
== bp_single_step
)
2539 struct thread_info
*thr
= find_thread_global_id (bl
->owner
->thread
);
2540 struct regcache
*regcache
;
2542 regcache
= get_thread_regcache (thr
);
2544 return gdbarch_breakpoint_kind_from_current_state (bl
->gdbarch
,
2548 return gdbarch_breakpoint_kind_from_pc (bl
->gdbarch
, addr
);
2551 /* Insert a low-level "breakpoint" of some type. BL is the breakpoint
2552 location. Any error messages are printed to TMP_ERROR_STREAM; and
2553 DISABLED_BREAKS, and HW_BREAKPOINT_ERROR are used to report problems.
2554 Returns 0 for success, 1 if the bp_location type is not supported or
2557 NOTE drow/2003-09-09: This routine could be broken down to an
2558 object-style method for each breakpoint or catchpoint type. */
2560 insert_bp_location (struct bp_location
*bl
,
2561 struct ui_file
*tmp_error_stream
,
2562 int *disabled_breaks
,
2563 int *hw_breakpoint_error
,
2564 int *hw_bp_error_explained_already
)
2566 gdb_exception bp_excpt
;
2568 if (!should_be_inserted (bl
) || (bl
->inserted
&& !bl
->needs_update
))
2571 /* Note we don't initialize bl->target_info, as that wipes out
2572 the breakpoint location's shadow_contents if the breakpoint
2573 is still inserted at that location. This in turn breaks
2574 target_read_memory which depends on these buffers when
2575 a memory read is requested at the breakpoint location:
2576 Once the target_info has been wiped, we fail to see that
2577 we have a breakpoint inserted at that address and thus
2578 read the breakpoint instead of returning the data saved in
2579 the breakpoint location's shadow contents. */
2580 bl
->target_info
.reqstd_address
= bl
->address
;
2581 bl
->target_info
.placed_address_space
= bl
->pspace
->aspace
;
2582 bl
->target_info
.length
= bl
->length
;
2584 /* When working with target-side conditions, we must pass all the conditions
2585 for the same breakpoint address down to the target since GDB will not
2586 insert those locations. With a list of breakpoint conditions, the target
2587 can decide when to stop and notify GDB. */
2589 if (is_breakpoint (bl
->owner
))
2591 build_target_condition_list (bl
);
2592 build_target_command_list (bl
);
2593 /* Reset the modification marker. */
2594 bl
->needs_update
= 0;
2597 /* If "set breakpoint auto-hw" is "on" and a software breakpoint was
2598 set at a read-only address, then a breakpoint location will have
2599 been changed to hardware breakpoint before we get here. If it is
2600 "off" however, error out before actually trying to insert the
2601 breakpoint, with a nicer error message. */
2602 if (bl
->loc_type
== bp_loc_software_breakpoint
2603 && !automatic_hardware_breakpoints
)
2605 mem_region
*mr
= lookup_mem_region (bl
->address
);
2607 if (mr
!= nullptr && mr
->attrib
.mode
!= MEM_RW
)
2609 fprintf_unfiltered (tmp_error_stream
,
2610 _("Cannot insert breakpoint %d.\n"
2611 "Cannot set software breakpoint "
2612 "at read-only address %s\n"),
2614 paddress (bl
->gdbarch
, bl
->address
));
2619 if (bl
->loc_type
== bp_loc_software_breakpoint
2620 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
2622 /* First check to see if we have to handle an overlay. */
2623 if (overlay_debugging
== ovly_off
2624 || bl
->section
== NULL
2625 || !(section_is_overlay (bl
->section
)))
2627 /* No overlay handling: just set the breakpoint. */
2632 val
= bl
->owner
->ops
->insert_location (bl
);
2634 bp_excpt
= gdb_exception
{RETURN_ERROR
, GENERIC_ERROR
};
2636 catch (gdb_exception
&e
)
2638 bp_excpt
= std::move (e
);
2643 /* This breakpoint is in an overlay section.
2644 Shall we set a breakpoint at the LMA? */
2645 if (!overlay_events_enabled
)
2647 /* Yes -- overlay event support is not active,
2648 so we must try to set a breakpoint at the LMA.
2649 This will not work for a hardware breakpoint. */
2650 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
2651 warning (_("hardware breakpoint %d not supported in overlay!"),
2655 CORE_ADDR addr
= overlay_unmapped_address (bl
->address
,
2657 /* Set a software (trap) breakpoint at the LMA. */
2658 bl
->overlay_target_info
= bl
->target_info
;
2659 bl
->overlay_target_info
.reqstd_address
= addr
;
2661 /* No overlay handling: just set the breakpoint. */
2666 bl
->overlay_target_info
.kind
2667 = breakpoint_kind (bl
, &addr
);
2668 bl
->overlay_target_info
.placed_address
= addr
;
2669 val
= target_insert_breakpoint (bl
->gdbarch
,
2670 &bl
->overlay_target_info
);
2673 = gdb_exception
{RETURN_ERROR
, GENERIC_ERROR
};
2675 catch (gdb_exception
&e
)
2677 bp_excpt
= std::move (e
);
2680 if (bp_excpt
.reason
!= 0)
2681 fprintf_unfiltered (tmp_error_stream
,
2682 "Overlay breakpoint %d "
2683 "failed: in ROM?\n",
2687 /* Shall we set a breakpoint at the VMA? */
2688 if (section_is_mapped (bl
->section
))
2690 /* Yes. This overlay section is mapped into memory. */
2695 val
= bl
->owner
->ops
->insert_location (bl
);
2697 bp_excpt
= gdb_exception
{RETURN_ERROR
, GENERIC_ERROR
};
2699 catch (gdb_exception
&e
)
2701 bp_excpt
= std::move (e
);
2706 /* No. This breakpoint will not be inserted.
2707 No error, but do not mark the bp as 'inserted'. */
2712 if (bp_excpt
.reason
!= 0)
2714 /* Can't set the breakpoint. */
2716 /* In some cases, we might not be able to insert a
2717 breakpoint in a shared library that has already been
2718 removed, but we have not yet processed the shlib unload
2719 event. Unfortunately, some targets that implement
2720 breakpoint insertion themselves can't tell why the
2721 breakpoint insertion failed (e.g., the remote target
2722 doesn't define error codes), so we must treat generic
2723 errors as memory errors. */
2724 if (bp_excpt
.reason
== RETURN_ERROR
2725 && (bp_excpt
.error
== GENERIC_ERROR
2726 || bp_excpt
.error
== MEMORY_ERROR
)
2727 && bl
->loc_type
== bp_loc_software_breakpoint
2728 && (solib_name_from_address (bl
->pspace
, bl
->address
)
2729 || shared_objfile_contains_address_p (bl
->pspace
,
2732 /* See also: disable_breakpoints_in_shlibs. */
2733 bl
->shlib_disabled
= 1;
2734 gdb::observers::breakpoint_modified
.notify (bl
->owner
);
2735 if (!*disabled_breaks
)
2737 fprintf_unfiltered (tmp_error_stream
,
2738 "Cannot insert breakpoint %d.\n",
2740 fprintf_unfiltered (tmp_error_stream
,
2741 "Temporarily disabling shared "
2742 "library breakpoints:\n");
2744 *disabled_breaks
= 1;
2745 fprintf_unfiltered (tmp_error_stream
,
2746 "breakpoint #%d\n", bl
->owner
->number
);
2751 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
2753 *hw_breakpoint_error
= 1;
2754 *hw_bp_error_explained_already
= bp_excpt
.message
!= NULL
;
2755 fprintf_unfiltered (tmp_error_stream
,
2756 "Cannot insert hardware breakpoint %d%s",
2758 bp_excpt
.message
? ":" : ".\n");
2759 if (bp_excpt
.message
!= NULL
)
2760 fprintf_unfiltered (tmp_error_stream
, "%s.\n",
2765 if (bp_excpt
.message
== NULL
)
2768 = memory_error_message (TARGET_XFER_E_IO
,
2769 bl
->gdbarch
, bl
->address
);
2771 fprintf_unfiltered (tmp_error_stream
,
2772 "Cannot insert breakpoint %d.\n"
2774 bl
->owner
->number
, message
.c_str ());
2778 fprintf_unfiltered (tmp_error_stream
,
2779 "Cannot insert breakpoint %d: %s\n",
2794 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
2795 /* NOTE drow/2003-09-08: This state only exists for removing
2796 watchpoints. It's not clear that it's necessary... */
2797 && bl
->owner
->disposition
!= disp_del_at_next_stop
)
2801 gdb_assert (bl
->owner
->ops
!= NULL
2802 && bl
->owner
->ops
->insert_location
!= NULL
);
2804 val
= bl
->owner
->ops
->insert_location (bl
);
2806 /* If trying to set a read-watchpoint, and it turns out it's not
2807 supported, try emulating one with an access watchpoint. */
2808 if (val
== 1 && bl
->watchpoint_type
== hw_read
)
2810 struct bp_location
*loc
, **loc_temp
;
2812 /* But don't try to insert it, if there's already another
2813 hw_access location that would be considered a duplicate
2815 ALL_BP_LOCATIONS (loc
, loc_temp
)
2817 && loc
->watchpoint_type
== hw_access
2818 && watchpoint_locations_match (bl
, loc
))
2822 bl
->target_info
= loc
->target_info
;
2823 bl
->watchpoint_type
= hw_access
;
2830 bl
->watchpoint_type
= hw_access
;
2831 val
= bl
->owner
->ops
->insert_location (bl
);
2834 /* Back to the original value. */
2835 bl
->watchpoint_type
= hw_read
;
2839 bl
->inserted
= (val
== 0);
2842 else if (bl
->owner
->type
== bp_catchpoint
)
2846 gdb_assert (bl
->owner
->ops
!= NULL
2847 && bl
->owner
->ops
->insert_location
!= NULL
);
2849 val
= bl
->owner
->ops
->insert_location (bl
);
2852 bl
->owner
->enable_state
= bp_disabled
;
2856 Error inserting catchpoint %d: Your system does not support this type\n\
2857 of catchpoint."), bl
->owner
->number
);
2859 warning (_("Error inserting catchpoint %d."), bl
->owner
->number
);
2862 bl
->inserted
= (val
== 0);
2864 /* We've already printed an error message if there was a problem
2865 inserting this catchpoint, and we've disabled the catchpoint,
2866 so just return success. */
2873 /* This function is called when program space PSPACE is about to be
2874 deleted. It takes care of updating breakpoints to not reference
2878 breakpoint_program_space_exit (struct program_space
*pspace
)
2880 struct breakpoint
*b
, *b_temp
;
2881 struct bp_location
*loc
, **loc_temp
;
2883 /* Remove any breakpoint that was set through this program space. */
2884 ALL_BREAKPOINTS_SAFE (b
, b_temp
)
2886 if (b
->pspace
== pspace
)
2887 delete_breakpoint (b
);
2890 /* Breakpoints set through other program spaces could have locations
2891 bound to PSPACE as well. Remove those. */
2892 ALL_BP_LOCATIONS (loc
, loc_temp
)
2894 struct bp_location
*tmp
;
2896 if (loc
->pspace
== pspace
)
2898 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
2899 if (loc
->owner
->loc
== loc
)
2900 loc
->owner
->loc
= loc
->next
;
2902 for (tmp
= loc
->owner
->loc
; tmp
->next
!= NULL
; tmp
= tmp
->next
)
2903 if (tmp
->next
== loc
)
2905 tmp
->next
= loc
->next
;
2911 /* Now update the global location list to permanently delete the
2912 removed locations above. */
2913 update_global_location_list (UGLL_DONT_INSERT
);
2916 /* Make sure all breakpoints are inserted in inferior.
2917 Throws exception on any error.
2918 A breakpoint that is already inserted won't be inserted
2919 again, so calling this function twice is safe. */
2921 insert_breakpoints (void)
2923 struct breakpoint
*bpt
;
2925 ALL_BREAKPOINTS (bpt
)
2926 if (is_hardware_watchpoint (bpt
))
2928 struct watchpoint
*w
= (struct watchpoint
*) bpt
;
2930 update_watchpoint (w
, 0 /* don't reparse. */);
2933 /* Updating watchpoints creates new locations, so update the global
2934 location list. Explicitly tell ugll to insert locations and
2935 ignore breakpoints_always_inserted_mode. Also,
2936 update_global_location_list tries to "upgrade" software
2937 breakpoints to hardware breakpoints to handle "set breakpoint
2938 auto-hw", so we need to call it even if we don't have new
2940 update_global_location_list (UGLL_INSERT
);
2943 /* Invoke CALLBACK for each of bp_location. */
2946 iterate_over_bp_locations (walk_bp_location_callback callback
)
2948 struct bp_location
*loc
, **loc_tmp
;
2950 ALL_BP_LOCATIONS (loc
, loc_tmp
)
2952 callback (loc
, NULL
);
2956 /* This is used when we need to synch breakpoint conditions between GDB and the
2957 target. It is the case with deleting and disabling of breakpoints when using
2958 always-inserted mode. */
2961 update_inserted_breakpoint_locations (void)
2963 struct bp_location
*bl
, **blp_tmp
;
2966 int disabled_breaks
= 0;
2967 int hw_breakpoint_error
= 0;
2968 int hw_bp_details_reported
= 0;
2970 string_file tmp_error_stream
;
2972 /* Explicitly mark the warning -- this will only be printed if
2973 there was an error. */
2974 tmp_error_stream
.puts ("Warning:\n");
2976 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
2978 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2980 /* We only want to update software breakpoints and hardware
2982 if (!is_breakpoint (bl
->owner
))
2985 /* We only want to update locations that are already inserted
2986 and need updating. This is to avoid unwanted insertion during
2987 deletion of breakpoints. */
2988 if (!bl
->inserted
|| !bl
->needs_update
)
2991 switch_to_program_space_and_thread (bl
->pspace
);
2993 /* For targets that support global breakpoints, there's no need
2994 to select an inferior to insert breakpoint to. In fact, even
2995 if we aren't attached to any process yet, we should still
2996 insert breakpoints. */
2997 if (!gdbarch_has_global_breakpoints (target_gdbarch ())
2998 && (inferior_ptid
== null_ptid
|| !target_has_execution ()))
3001 val
= insert_bp_location (bl
, &tmp_error_stream
, &disabled_breaks
,
3002 &hw_breakpoint_error
, &hw_bp_details_reported
);
3009 target_terminal::ours_for_output ();
3010 error_stream (tmp_error_stream
);
3014 /* Used when starting or continuing the program. */
3017 insert_breakpoint_locations (void)
3019 struct breakpoint
*bpt
;
3020 struct bp_location
*bl
, **blp_tmp
;
3023 int disabled_breaks
= 0;
3024 int hw_breakpoint_error
= 0;
3025 int hw_bp_error_explained_already
= 0;
3027 string_file tmp_error_stream
;
3029 /* Explicitly mark the warning -- this will only be printed if
3030 there was an error. */
3031 tmp_error_stream
.puts ("Warning:\n");
3033 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
3035 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3037 if (!should_be_inserted (bl
) || (bl
->inserted
&& !bl
->needs_update
))
3040 /* There is no point inserting thread-specific breakpoints if
3041 the thread no longer exists. ALL_BP_LOCATIONS bp_location
3042 has BL->OWNER always non-NULL. */
3043 if (bl
->owner
->thread
!= -1
3044 && !valid_global_thread_id (bl
->owner
->thread
))
3047 switch_to_program_space_and_thread (bl
->pspace
);
3049 /* For targets that support global breakpoints, there's no need
3050 to select an inferior to insert breakpoint to. In fact, even
3051 if we aren't attached to any process yet, we should still
3052 insert breakpoints. */
3053 if (!gdbarch_has_global_breakpoints (target_gdbarch ())
3054 && (inferior_ptid
== null_ptid
|| !target_has_execution ()))
3057 val
= insert_bp_location (bl
, &tmp_error_stream
, &disabled_breaks
,
3058 &hw_breakpoint_error
, &hw_bp_error_explained_already
);
3063 /* If we failed to insert all locations of a watchpoint, remove
3064 them, as half-inserted watchpoint is of limited use. */
3065 ALL_BREAKPOINTS (bpt
)
3067 int some_failed
= 0;
3068 struct bp_location
*loc
;
3070 if (!is_hardware_watchpoint (bpt
))
3073 if (!breakpoint_enabled (bpt
))
3076 if (bpt
->disposition
== disp_del_at_next_stop
)
3079 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
3080 if (!loc
->inserted
&& should_be_inserted (loc
))
3087 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
3089 remove_breakpoint (loc
);
3091 hw_breakpoint_error
= 1;
3092 tmp_error_stream
.printf ("Could not insert "
3093 "hardware watchpoint %d.\n",
3101 /* If a hardware breakpoint or watchpoint was inserted, add a
3102 message about possibly exhausted resources. */
3103 if (hw_breakpoint_error
&& !hw_bp_error_explained_already
)
3105 tmp_error_stream
.printf ("Could not insert hardware breakpoints:\n\
3106 You may have requested too many hardware breakpoints/watchpoints.\n");
3108 target_terminal::ours_for_output ();
3109 error_stream (tmp_error_stream
);
3113 /* Used when the program stops.
3114 Returns zero if successful, or non-zero if there was a problem
3115 removing a breakpoint location. */
3118 remove_breakpoints (void)
3120 struct bp_location
*bl
, **blp_tmp
;
3123 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3125 if (bl
->inserted
&& !is_tracepoint (bl
->owner
))
3126 val
|= remove_breakpoint (bl
);
3131 /* When a thread exits, remove breakpoints that are related to
3135 remove_threaded_breakpoints (struct thread_info
*tp
, int silent
)
3137 struct breakpoint
*b
, *b_tmp
;
3139 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
3141 if (b
->thread
== tp
->global_num
&& user_breakpoint_p (b
))
3143 b
->disposition
= disp_del_at_next_stop
;
3145 printf_filtered (_("\
3146 Thread-specific breakpoint %d deleted - thread %s no longer in the thread list.\n"),
3147 b
->number
, print_thread_id (tp
));
3149 /* Hide it from the user. */
3155 /* See breakpoint.h. */
3158 remove_breakpoints_inf (inferior
*inf
)
3160 struct bp_location
*bl
, **blp_tmp
;
3163 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3165 if (bl
->pspace
!= inf
->pspace
)
3168 if (bl
->inserted
&& !bl
->target_info
.persist
)
3170 val
= remove_breakpoint (bl
);
3177 static int internal_breakpoint_number
= -1;
3179 /* Set the breakpoint number of B, depending on the value of INTERNAL.
3180 If INTERNAL is non-zero, the breakpoint number will be populated
3181 from internal_breakpoint_number and that variable decremented.
3182 Otherwise the breakpoint number will be populated from
3183 breakpoint_count and that value incremented. Internal breakpoints
3184 do not set the internal var bpnum. */
3186 set_breakpoint_number (int internal
, struct breakpoint
*b
)
3189 b
->number
= internal_breakpoint_number
--;
3192 set_breakpoint_count (breakpoint_count
+ 1);
3193 b
->number
= breakpoint_count
;
3197 static struct breakpoint
*
3198 create_internal_breakpoint (struct gdbarch
*gdbarch
,
3199 CORE_ADDR address
, enum bptype type
,
3200 const struct breakpoint_ops
*ops
)
3202 symtab_and_line sal
;
3204 sal
.section
= find_pc_overlay (sal
.pc
);
3205 sal
.pspace
= current_program_space
;
3207 breakpoint
*b
= set_raw_breakpoint (gdbarch
, sal
, type
, ops
);
3208 b
->number
= internal_breakpoint_number
--;
3209 b
->disposition
= disp_donttouch
;
3214 static const char *const longjmp_names
[] =
3216 "longjmp", "_longjmp", "siglongjmp", "_siglongjmp"
3218 #define NUM_LONGJMP_NAMES ARRAY_SIZE(longjmp_names)
3220 /* Per-objfile data private to breakpoint.c. */
3221 struct breakpoint_objfile_data
3223 /* Minimal symbol for "_ovly_debug_event" (if any). */
3224 struct bound_minimal_symbol overlay_msym
{};
3226 /* Minimal symbol(s) for "longjmp", "siglongjmp", etc. (if any). */
3227 struct bound_minimal_symbol longjmp_msym
[NUM_LONGJMP_NAMES
] {};
3229 /* True if we have looked for longjmp probes. */
3230 int longjmp_searched
= 0;
3232 /* SystemTap probe points for longjmp (if any). These are non-owning
3234 std::vector
<probe
*> longjmp_probes
;
3236 /* Minimal symbol for "std::terminate()" (if any). */
3237 struct bound_minimal_symbol terminate_msym
{};
3239 /* Minimal symbol for "_Unwind_DebugHook" (if any). */
3240 struct bound_minimal_symbol exception_msym
{};
3242 /* True if we have looked for exception probes. */
3243 int exception_searched
= 0;
3245 /* SystemTap probe points for unwinding (if any). These are non-owning
3247 std::vector
<probe
*> exception_probes
;
3250 static const struct objfile_key
<breakpoint_objfile_data
>
3251 breakpoint_objfile_key
;
3253 /* Minimal symbol not found sentinel. */
3254 static struct minimal_symbol msym_not_found
;
3256 /* Returns TRUE if MSYM point to the "not found" sentinel. */
3259 msym_not_found_p (const struct minimal_symbol
*msym
)
3261 return msym
== &msym_not_found
;
3264 /* Return per-objfile data needed by breakpoint.c.
3265 Allocate the data if necessary. */
3267 static struct breakpoint_objfile_data
*
3268 get_breakpoint_objfile_data (struct objfile
*objfile
)
3270 struct breakpoint_objfile_data
*bp_objfile_data
;
3272 bp_objfile_data
= breakpoint_objfile_key
.get (objfile
);
3273 if (bp_objfile_data
== NULL
)
3274 bp_objfile_data
= breakpoint_objfile_key
.emplace (objfile
);
3275 return bp_objfile_data
;
3279 create_overlay_event_breakpoint (void)
3281 const char *const func_name
= "_ovly_debug_event";
3283 for (objfile
*objfile
: current_program_space
->objfiles ())
3285 struct breakpoint
*b
;
3286 struct breakpoint_objfile_data
*bp_objfile_data
;
3288 struct explicit_location explicit_loc
;
3290 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3292 if (msym_not_found_p (bp_objfile_data
->overlay_msym
.minsym
))
3295 if (bp_objfile_data
->overlay_msym
.minsym
== NULL
)
3297 struct bound_minimal_symbol m
;
3299 m
= lookup_minimal_symbol_text (func_name
, objfile
);
3300 if (m
.minsym
== NULL
)
3302 /* Avoid future lookups in this objfile. */
3303 bp_objfile_data
->overlay_msym
.minsym
= &msym_not_found
;
3306 bp_objfile_data
->overlay_msym
= m
;
3309 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->overlay_msym
);
3310 b
= create_internal_breakpoint (objfile
->arch (), addr
,
3312 &internal_breakpoint_ops
);
3313 initialize_explicit_location (&explicit_loc
);
3314 explicit_loc
.function_name
= ASTRDUP (func_name
);
3315 b
->location
= new_explicit_location (&explicit_loc
);
3317 if (overlay_debugging
== ovly_auto
)
3319 b
->enable_state
= bp_enabled
;
3320 overlay_events_enabled
= 1;
3324 b
->enable_state
= bp_disabled
;
3325 overlay_events_enabled
= 0;
3330 /* Install a master longjmp breakpoint for OBJFILE using a probe. Return
3331 true if a breakpoint was installed. */
3334 create_longjmp_master_breakpoint_probe (objfile
*objfile
)
3336 struct gdbarch
*gdbarch
= objfile
->arch ();
3337 struct breakpoint_objfile_data
*bp_objfile_data
3338 = get_breakpoint_objfile_data (objfile
);
3340 if (!bp_objfile_data
->longjmp_searched
)
3342 std::vector
<probe
*> ret
3343 = find_probes_in_objfile (objfile
, "libc", "longjmp");
3347 /* We are only interested in checking one element. */
3350 if (!p
->can_evaluate_arguments ())
3352 /* We cannot use the probe interface here,
3353 because it does not know how to evaluate
3358 bp_objfile_data
->longjmp_probes
= ret
;
3359 bp_objfile_data
->longjmp_searched
= 1;
3362 if (bp_objfile_data
->longjmp_probes
.empty ())
3365 for (probe
*p
: bp_objfile_data
->longjmp_probes
)
3367 struct breakpoint
*b
;
3369 b
= create_internal_breakpoint (gdbarch
,
3370 p
->get_relocated_address (objfile
),
3372 &internal_breakpoint_ops
);
3373 b
->location
= new_probe_location ("-probe-stap libc:longjmp");
3374 b
->enable_state
= bp_disabled
;
3380 /* Install master longjmp breakpoints for OBJFILE using longjmp_names.
3381 Return true if at least one breakpoint was installed. */
3384 create_longjmp_master_breakpoint_names (objfile
*objfile
)
3386 struct gdbarch
*gdbarch
= objfile
->arch ();
3387 if (!gdbarch_get_longjmp_target_p (gdbarch
))
3390 struct breakpoint_objfile_data
*bp_objfile_data
3391 = get_breakpoint_objfile_data (objfile
);
3392 unsigned int installed_bp
= 0;
3394 for (int i
= 0; i
< NUM_LONGJMP_NAMES
; i
++)
3396 struct breakpoint
*b
;
3397 const char *func_name
;
3399 struct explicit_location explicit_loc
;
3401 if (msym_not_found_p (bp_objfile_data
->longjmp_msym
[i
].minsym
))
3404 func_name
= longjmp_names
[i
];
3405 if (bp_objfile_data
->longjmp_msym
[i
].minsym
== NULL
)
3407 struct bound_minimal_symbol m
;
3409 m
= lookup_minimal_symbol_text (func_name
, objfile
);
3410 if (m
.minsym
== NULL
)
3412 /* Prevent future lookups in this objfile. */
3413 bp_objfile_data
->longjmp_msym
[i
].minsym
= &msym_not_found
;
3416 bp_objfile_data
->longjmp_msym
[i
] = m
;
3419 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->longjmp_msym
[i
]);
3420 b
= create_internal_breakpoint (gdbarch
, addr
, bp_longjmp_master
,
3421 &internal_breakpoint_ops
);
3422 initialize_explicit_location (&explicit_loc
);
3423 explicit_loc
.function_name
= ASTRDUP (func_name
);
3424 b
->location
= new_explicit_location (&explicit_loc
);
3425 b
->enable_state
= bp_disabled
;
3429 return installed_bp
> 0;
3432 /* Create a master longjmp breakpoint. */
3435 create_longjmp_master_breakpoint (void)
3437 scoped_restore_current_program_space restore_pspace
;
3439 for (struct program_space
*pspace
: program_spaces
)
3441 set_current_program_space (pspace
);
3443 for (objfile
*obj
: current_program_space
->objfiles ())
3445 /* Skip separate debug object, it's handled in the loop below. */
3446 if (obj
->separate_debug_objfile_backlink
!= nullptr)
3449 /* Try a probe kind breakpoint on main objfile. */
3450 if (create_longjmp_master_breakpoint_probe (obj
))
3453 /* Try longjmp_names kind breakpoints on main and separate_debug
3455 for (objfile
*debug_objfile
: obj
->separate_debug_objfiles ())
3456 if (create_longjmp_master_breakpoint_names (debug_objfile
))
3462 /* Create a master std::terminate breakpoint. */
3464 create_std_terminate_master_breakpoint (void)
3466 const char *const func_name
= "std::terminate()";
3468 scoped_restore_current_program_space restore_pspace
;
3470 for (struct program_space
*pspace
: program_spaces
)
3474 set_current_program_space (pspace
);
3476 for (objfile
*objfile
: current_program_space
->objfiles ())
3478 struct breakpoint
*b
;
3479 struct breakpoint_objfile_data
*bp_objfile_data
;
3480 struct explicit_location explicit_loc
;
3482 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3484 if (msym_not_found_p (bp_objfile_data
->terminate_msym
.minsym
))
3487 if (bp_objfile_data
->terminate_msym
.minsym
== NULL
)
3489 struct bound_minimal_symbol m
;
3491 m
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
3492 if (m
.minsym
== NULL
|| (MSYMBOL_TYPE (m
.minsym
) != mst_text
3493 && MSYMBOL_TYPE (m
.minsym
) != mst_file_text
))
3495 /* Prevent future lookups in this objfile. */
3496 bp_objfile_data
->terminate_msym
.minsym
= &msym_not_found
;
3499 bp_objfile_data
->terminate_msym
= m
;
3502 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->terminate_msym
);
3503 b
= create_internal_breakpoint (objfile
->arch (), addr
,
3504 bp_std_terminate_master
,
3505 &internal_breakpoint_ops
);
3506 initialize_explicit_location (&explicit_loc
);
3507 explicit_loc
.function_name
= ASTRDUP (func_name
);
3508 b
->location
= new_explicit_location (&explicit_loc
);
3509 b
->enable_state
= bp_disabled
;
3514 /* Install a master breakpoint on the unwinder's debug hook for OBJFILE using a
3515 probe. Return true if a breakpoint was installed. */
3518 create_exception_master_breakpoint_probe (objfile
*objfile
)
3520 struct breakpoint
*b
;
3521 struct gdbarch
*gdbarch
;
3522 struct breakpoint_objfile_data
*bp_objfile_data
;
3524 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3526 /* We prefer the SystemTap probe point if it exists. */
3527 if (!bp_objfile_data
->exception_searched
)
3529 std::vector
<probe
*> ret
3530 = find_probes_in_objfile (objfile
, "libgcc", "unwind");
3534 /* We are only interested in checking one element. */
3537 if (!p
->can_evaluate_arguments ())
3539 /* We cannot use the probe interface here, because it does
3540 not know how to evaluate arguments. */
3544 bp_objfile_data
->exception_probes
= ret
;
3545 bp_objfile_data
->exception_searched
= 1;
3548 if (bp_objfile_data
->exception_probes
.empty ())
3551 gdbarch
= objfile
->arch ();
3553 for (probe
*p
: bp_objfile_data
->exception_probes
)
3555 b
= create_internal_breakpoint (gdbarch
,
3556 p
->get_relocated_address (objfile
),
3557 bp_exception_master
,
3558 &internal_breakpoint_ops
);
3559 b
->location
= new_probe_location ("-probe-stap libgcc:unwind");
3560 b
->enable_state
= bp_disabled
;
3566 /* Install a master breakpoint on the unwinder's debug hook for OBJFILE using
3567 _Unwind_DebugHook. Return true if a breakpoint was installed. */
3570 create_exception_master_breakpoint_hook (objfile
*objfile
)
3572 const char *const func_name
= "_Unwind_DebugHook";
3573 struct breakpoint
*b
;
3574 struct gdbarch
*gdbarch
;
3575 struct breakpoint_objfile_data
*bp_objfile_data
;
3577 struct explicit_location explicit_loc
;
3579 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3581 if (msym_not_found_p (bp_objfile_data
->exception_msym
.minsym
))
3584 gdbarch
= objfile
->arch ();
3586 if (bp_objfile_data
->exception_msym
.minsym
== NULL
)
3588 struct bound_minimal_symbol debug_hook
;
3590 debug_hook
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
3591 if (debug_hook
.minsym
== NULL
)
3593 bp_objfile_data
->exception_msym
.minsym
= &msym_not_found
;
3597 bp_objfile_data
->exception_msym
= debug_hook
;
3600 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->exception_msym
);
3601 addr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, addr
,
3602 current_top_target ());
3603 b
= create_internal_breakpoint (gdbarch
, addr
, bp_exception_master
,
3604 &internal_breakpoint_ops
);
3605 initialize_explicit_location (&explicit_loc
);
3606 explicit_loc
.function_name
= ASTRDUP (func_name
);
3607 b
->location
= new_explicit_location (&explicit_loc
);
3608 b
->enable_state
= bp_disabled
;
3613 /* Install a master breakpoint on the unwinder's debug hook. */
3616 create_exception_master_breakpoint (void)
3618 for (objfile
*obj
: current_program_space
->objfiles ())
3620 /* Skip separate debug object. */
3621 if (obj
->separate_debug_objfile_backlink
)
3624 /* Try a probe kind breakpoint. */
3625 if (create_exception_master_breakpoint_probe (obj
))
3628 /* Iterate over separate debug objects and try an _Unwind_DebugHook
3630 for (objfile
*sepdebug
= obj
->separate_debug_objfile
;
3631 sepdebug
!= nullptr; sepdebug
= sepdebug
->separate_debug_objfile
)
3632 if (create_exception_master_breakpoint_hook (sepdebug
))
3637 /* Does B have a location spec? */
3640 breakpoint_event_location_empty_p (const struct breakpoint
*b
)
3642 return b
->location
!= NULL
&& event_location_empty_p (b
->location
.get ());
3646 update_breakpoints_after_exec (void)
3648 struct breakpoint
*b
, *b_tmp
;
3649 struct bp_location
*bploc
, **bplocp_tmp
;
3651 /* We're about to delete breakpoints from GDB's lists. If the
3652 INSERTED flag is true, GDB will try to lift the breakpoints by
3653 writing the breakpoints' "shadow contents" back into memory. The
3654 "shadow contents" are NOT valid after an exec, so GDB should not
3655 do that. Instead, the target is responsible from marking
3656 breakpoints out as soon as it detects an exec. We don't do that
3657 here instead, because there may be other attempts to delete
3658 breakpoints after detecting an exec and before reaching here. */
3659 ALL_BP_LOCATIONS (bploc
, bplocp_tmp
)
3660 if (bploc
->pspace
== current_program_space
)
3661 gdb_assert (!bploc
->inserted
);
3663 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
3665 if (b
->pspace
!= current_program_space
)
3668 /* Solib breakpoints must be explicitly reset after an exec(). */
3669 if (b
->type
== bp_shlib_event
)
3671 delete_breakpoint (b
);
3675 /* JIT breakpoints must be explicitly reset after an exec(). */
3676 if (b
->type
== bp_jit_event
)
3678 delete_breakpoint (b
);
3682 /* Thread event breakpoints must be set anew after an exec(),
3683 as must overlay event and longjmp master breakpoints. */
3684 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
3685 || b
->type
== bp_longjmp_master
|| b
->type
== bp_std_terminate_master
3686 || b
->type
== bp_exception_master
)
3688 delete_breakpoint (b
);
3692 /* Step-resume breakpoints are meaningless after an exec(). */
3693 if (b
->type
== bp_step_resume
|| b
->type
== bp_hp_step_resume
)
3695 delete_breakpoint (b
);
3699 /* Just like single-step breakpoints. */
3700 if (b
->type
== bp_single_step
)
3702 delete_breakpoint (b
);
3706 /* Longjmp and longjmp-resume breakpoints are also meaningless
3708 if (b
->type
== bp_longjmp
|| b
->type
== bp_longjmp_resume
3709 || b
->type
== bp_longjmp_call_dummy
3710 || b
->type
== bp_exception
|| b
->type
== bp_exception_resume
)
3712 delete_breakpoint (b
);
3716 if (b
->type
== bp_catchpoint
)
3718 /* For now, none of the bp_catchpoint breakpoints need to
3719 do anything at this point. In the future, if some of
3720 the catchpoints need to something, we will need to add
3721 a new method, and call this method from here. */
3725 /* bp_finish is a special case. The only way we ought to be able
3726 to see one of these when an exec() has happened, is if the user
3727 caught a vfork, and then said "finish". Ordinarily a finish just
3728 carries them to the call-site of the current callee, by setting
3729 a temporary bp there and resuming. But in this case, the finish
3730 will carry them entirely through the vfork & exec.
3732 We don't want to allow a bp_finish to remain inserted now. But
3733 we can't safely delete it, 'cause finish_command has a handle to
3734 the bp on a bpstat, and will later want to delete it. There's a
3735 chance (and I've seen it happen) that if we delete the bp_finish
3736 here, that its storage will get reused by the time finish_command
3737 gets 'round to deleting the "use to be a bp_finish" breakpoint.
3738 We really must allow finish_command to delete a bp_finish.
3740 In the absence of a general solution for the "how do we know
3741 it's safe to delete something others may have handles to?"
3742 problem, what we'll do here is just uninsert the bp_finish, and
3743 let finish_command delete it.
3745 (We know the bp_finish is "doomed" in the sense that it's
3746 momentary, and will be deleted as soon as finish_command sees
3747 the inferior stopped. So it doesn't matter that the bp's
3748 address is probably bogus in the new a.out, unlike e.g., the
3749 solib breakpoints.) */
3751 if (b
->type
== bp_finish
)
3756 /* Without a symbolic address, we have little hope of the
3757 pre-exec() address meaning the same thing in the post-exec()
3759 if (breakpoint_event_location_empty_p (b
))
3761 delete_breakpoint (b
);
3768 detach_breakpoints (ptid_t ptid
)
3770 struct bp_location
*bl
, **blp_tmp
;
3772 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
3773 struct inferior
*inf
= current_inferior ();
3775 if (ptid
.pid () == inferior_ptid
.pid ())
3776 error (_("Cannot detach breakpoints of inferior_ptid"));
3778 /* Set inferior_ptid; remove_breakpoint_1 uses this global. */
3779 inferior_ptid
= ptid
;
3780 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3782 if (bl
->pspace
!= inf
->pspace
)
3785 /* This function must physically remove breakpoints locations
3786 from the specified ptid, without modifying the breakpoint
3787 package's state. Locations of type bp_loc_other are only
3788 maintained at GDB side. So, there is no need to remove
3789 these bp_loc_other locations. Moreover, removing these
3790 would modify the breakpoint package's state. */
3791 if (bl
->loc_type
== bp_loc_other
)
3795 val
|= remove_breakpoint_1 (bl
, DETACH_BREAKPOINT
);
3801 /* Remove the breakpoint location BL from the current address space.
3802 Note that this is used to detach breakpoints from a child fork.
3803 When we get here, the child isn't in the inferior list, and neither
3804 do we have objects to represent its address space --- we should
3805 *not* look at bl->pspace->aspace here. */
3808 remove_breakpoint_1 (struct bp_location
*bl
, enum remove_bp_reason reason
)
3812 /* BL is never in moribund_locations by our callers. */
3813 gdb_assert (bl
->owner
!= NULL
);
3815 /* The type of none suggests that owner is actually deleted.
3816 This should not ever happen. */
3817 gdb_assert (bl
->owner
->type
!= bp_none
);
3819 if (bl
->loc_type
== bp_loc_software_breakpoint
3820 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
3822 /* "Normal" instruction breakpoint: either the standard
3823 trap-instruction bp (bp_breakpoint), or a
3824 bp_hardware_breakpoint. */
3826 /* First check to see if we have to handle an overlay. */
3827 if (overlay_debugging
== ovly_off
3828 || bl
->section
== NULL
3829 || !(section_is_overlay (bl
->section
)))
3831 /* No overlay handling: just remove the breakpoint. */
3833 /* If we're trying to uninsert a memory breakpoint that we
3834 know is set in a dynamic object that is marked
3835 shlib_disabled, then either the dynamic object was
3836 removed with "remove-symbol-file" or with
3837 "nosharedlibrary". In the former case, we don't know
3838 whether another dynamic object might have loaded over the
3839 breakpoint's address -- the user might well let us know
3840 about it next with add-symbol-file (the whole point of
3841 add-symbol-file is letting the user manually maintain a
3842 list of dynamically loaded objects). If we have the
3843 breakpoint's shadow memory, that is, this is a software
3844 breakpoint managed by GDB, check whether the breakpoint
3845 is still inserted in memory, to avoid overwriting wrong
3846 code with stale saved shadow contents. Note that HW
3847 breakpoints don't have shadow memory, as they're
3848 implemented using a mechanism that is not dependent on
3849 being able to modify the target's memory, and as such
3850 they should always be removed. */
3851 if (bl
->shlib_disabled
3852 && bl
->target_info
.shadow_len
!= 0
3853 && !memory_validate_breakpoint (bl
->gdbarch
, &bl
->target_info
))
3856 val
= bl
->owner
->ops
->remove_location (bl
, reason
);
3860 /* This breakpoint is in an overlay section.
3861 Did we set a breakpoint at the LMA? */
3862 if (!overlay_events_enabled
)
3864 /* Yes -- overlay event support is not active, so we
3865 should have set a breakpoint at the LMA. Remove it.
3867 /* Ignore any failures: if the LMA is in ROM, we will
3868 have already warned when we failed to insert it. */
3869 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
3870 target_remove_hw_breakpoint (bl
->gdbarch
,
3871 &bl
->overlay_target_info
);
3873 target_remove_breakpoint (bl
->gdbarch
,
3874 &bl
->overlay_target_info
,
3877 /* Did we set a breakpoint at the VMA?
3878 If so, we will have marked the breakpoint 'inserted'. */
3881 /* Yes -- remove it. Previously we did not bother to
3882 remove the breakpoint if the section had been
3883 unmapped, but let's not rely on that being safe. We
3884 don't know what the overlay manager might do. */
3886 /* However, we should remove *software* breakpoints only
3887 if the section is still mapped, or else we overwrite
3888 wrong code with the saved shadow contents. */
3889 if (bl
->loc_type
== bp_loc_hardware_breakpoint
3890 || section_is_mapped (bl
->section
))
3891 val
= bl
->owner
->ops
->remove_location (bl
, reason
);
3897 /* No -- not inserted, so no need to remove. No error. */
3902 /* In some cases, we might not be able to remove a breakpoint in
3903 a shared library that has already been removed, but we have
3904 not yet processed the shlib unload event. Similarly for an
3905 unloaded add-symbol-file object - the user might not yet have
3906 had the chance to remove-symbol-file it. shlib_disabled will
3907 be set if the library/object has already been removed, but
3908 the breakpoint hasn't been uninserted yet, e.g., after
3909 "nosharedlibrary" or "remove-symbol-file" with breakpoints
3910 always-inserted mode. */
3912 && (bl
->loc_type
== bp_loc_software_breakpoint
3913 && (bl
->shlib_disabled
3914 || solib_name_from_address (bl
->pspace
, bl
->address
)
3915 || shared_objfile_contains_address_p (bl
->pspace
,
3921 bl
->inserted
= (reason
== DETACH_BREAKPOINT
);
3923 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
)
3925 gdb_assert (bl
->owner
->ops
!= NULL
3926 && bl
->owner
->ops
->remove_location
!= NULL
);
3928 bl
->inserted
= (reason
== DETACH_BREAKPOINT
);
3929 bl
->owner
->ops
->remove_location (bl
, reason
);
3931 /* Failure to remove any of the hardware watchpoints comes here. */
3932 if (reason
== REMOVE_BREAKPOINT
&& bl
->inserted
)
3933 warning (_("Could not remove hardware watchpoint %d."),
3936 else if (bl
->owner
->type
== bp_catchpoint
3937 && breakpoint_enabled (bl
->owner
)
3940 gdb_assert (bl
->owner
->ops
!= NULL
3941 && bl
->owner
->ops
->remove_location
!= NULL
);
3943 val
= bl
->owner
->ops
->remove_location (bl
, reason
);
3947 bl
->inserted
= (reason
== DETACH_BREAKPOINT
);
3954 remove_breakpoint (struct bp_location
*bl
)
3956 /* BL is never in moribund_locations by our callers. */
3957 gdb_assert (bl
->owner
!= NULL
);
3959 /* The type of none suggests that owner is actually deleted.
3960 This should not ever happen. */
3961 gdb_assert (bl
->owner
->type
!= bp_none
);
3963 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
3965 switch_to_program_space_and_thread (bl
->pspace
);
3967 return remove_breakpoint_1 (bl
, REMOVE_BREAKPOINT
);
3970 /* Clear the "inserted" flag in all breakpoints. */
3973 mark_breakpoints_out (void)
3975 struct bp_location
*bl
, **blp_tmp
;
3977 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3978 if (bl
->pspace
== current_program_space
)
3982 /* Clear the "inserted" flag in all breakpoints and delete any
3983 breakpoints which should go away between runs of the program.
3985 Plus other such housekeeping that has to be done for breakpoints
3988 Note: this function gets called at the end of a run (by
3989 generic_mourn_inferior) and when a run begins (by
3990 init_wait_for_inferior). */
3995 breakpoint_init_inferior (enum inf_context context
)
3997 struct breakpoint
*b
, *b_tmp
;
3998 struct program_space
*pspace
= current_program_space
;
4000 /* If breakpoint locations are shared across processes, then there's
4002 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
4005 mark_breakpoints_out ();
4007 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
4009 if (b
->loc
&& b
->loc
->pspace
!= pspace
)
4015 case bp_longjmp_call_dummy
:
4017 /* If the call dummy breakpoint is at the entry point it will
4018 cause problems when the inferior is rerun, so we better get
4021 case bp_watchpoint_scope
:
4023 /* Also get rid of scope breakpoints. */
4025 case bp_shlib_event
:
4027 /* Also remove solib event breakpoints. Their addresses may
4028 have changed since the last time we ran the program.
4029 Actually we may now be debugging against different target;
4030 and so the solib backend that installed this breakpoint may
4031 not be used in by the target. E.g.,
4033 (gdb) file prog-linux
4034 (gdb) run # native linux target
4037 (gdb) file prog-win.exe
4038 (gdb) tar rem :9999 # remote Windows gdbserver.
4041 case bp_step_resume
:
4043 /* Also remove step-resume breakpoints. */
4045 case bp_single_step
:
4047 /* Also remove single-step breakpoints. */
4049 delete_breakpoint (b
);
4053 case bp_hardware_watchpoint
:
4054 case bp_read_watchpoint
:
4055 case bp_access_watchpoint
:
4057 struct watchpoint
*w
= (struct watchpoint
*) b
;
4059 /* Likewise for watchpoints on local expressions. */
4060 if (w
->exp_valid_block
!= NULL
)
4061 delete_breakpoint (b
);
4064 /* Get rid of existing locations, which are no longer
4065 valid. New ones will be created in
4066 update_watchpoint, when the inferior is restarted.
4067 The next update_global_location_list call will
4068 garbage collect them. */
4071 if (context
== inf_starting
)
4073 /* Reset val field to force reread of starting value in
4074 insert_breakpoints. */
4075 w
->val
.reset (nullptr);
4076 w
->val_valid
= false;
4086 /* Get rid of the moribund locations. */
4087 for (bp_location
*bl
: moribund_locations
)
4088 decref_bp_location (&bl
);
4089 moribund_locations
.clear ();
4092 /* These functions concern about actual breakpoints inserted in the
4093 target --- to e.g. check if we need to do decr_pc adjustment or if
4094 we need to hop over the bkpt --- so we check for address space
4095 match, not program space. */
4097 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
4098 exists at PC. It returns ordinary_breakpoint_here if it's an
4099 ordinary breakpoint, or permanent_breakpoint_here if it's a
4100 permanent breakpoint.
4101 - When continuing from a location with an ordinary breakpoint, we
4102 actually single step once before calling insert_breakpoints.
4103 - When continuing from a location with a permanent breakpoint, we
4104 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
4105 the target, to advance the PC past the breakpoint. */
4107 enum breakpoint_here
4108 breakpoint_here_p (const address_space
*aspace
, CORE_ADDR pc
)
4110 struct bp_location
*bl
, **blp_tmp
;
4111 int any_breakpoint_here
= 0;
4113 ALL_BP_LOCATIONS (bl
, blp_tmp
)
4115 if (bl
->loc_type
!= bp_loc_software_breakpoint
4116 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4119 /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
4120 if ((breakpoint_enabled (bl
->owner
)
4122 && breakpoint_location_address_match (bl
, aspace
, pc
))
4124 if (overlay_debugging
4125 && section_is_overlay (bl
->section
)
4126 && !section_is_mapped (bl
->section
))
4127 continue; /* unmapped overlay -- can't be a match */
4128 else if (bl
->permanent
)
4129 return permanent_breakpoint_here
;
4131 any_breakpoint_here
= 1;
4135 return any_breakpoint_here
? ordinary_breakpoint_here
: no_breakpoint_here
;
4138 /* See breakpoint.h. */
4141 breakpoint_in_range_p (const address_space
*aspace
,
4142 CORE_ADDR addr
, ULONGEST len
)
4144 struct bp_location
*bl
, **blp_tmp
;
4146 ALL_BP_LOCATIONS (bl
, blp_tmp
)
4148 if (bl
->loc_type
!= bp_loc_software_breakpoint
4149 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4152 if ((breakpoint_enabled (bl
->owner
)
4154 && breakpoint_location_address_range_overlap (bl
, aspace
,
4157 if (overlay_debugging
4158 && section_is_overlay (bl
->section
)
4159 && !section_is_mapped (bl
->section
))
4161 /* Unmapped overlay -- can't be a match. */
4172 /* Return true if there's a moribund breakpoint at PC. */
4175 moribund_breakpoint_here_p (const address_space
*aspace
, CORE_ADDR pc
)
4177 for (bp_location
*loc
: moribund_locations
)
4178 if (breakpoint_location_address_match (loc
, aspace
, pc
))
4184 /* Returns non-zero iff BL is inserted at PC, in address space
4188 bp_location_inserted_here_p (struct bp_location
*bl
,
4189 const address_space
*aspace
, CORE_ADDR pc
)
4192 && breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
4195 if (overlay_debugging
4196 && section_is_overlay (bl
->section
)
4197 && !section_is_mapped (bl
->section
))
4198 return 0; /* unmapped overlay -- can't be a match */
4205 /* Returns non-zero iff there's a breakpoint inserted at PC. */
4208 breakpoint_inserted_here_p (const address_space
*aspace
, CORE_ADDR pc
)
4210 struct bp_location
**blp
, **blp_tmp
= NULL
;
4212 ALL_BP_LOCATIONS_AT_ADDR (blp
, blp_tmp
, pc
)
4214 struct bp_location
*bl
= *blp
;
4216 if (bl
->loc_type
!= bp_loc_software_breakpoint
4217 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4220 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4226 /* This function returns non-zero iff there is a software breakpoint
4230 software_breakpoint_inserted_here_p (const address_space
*aspace
,
4233 struct bp_location
**blp
, **blp_tmp
= NULL
;
4235 ALL_BP_LOCATIONS_AT_ADDR (blp
, blp_tmp
, pc
)
4237 struct bp_location
*bl
= *blp
;
4239 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
4242 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4249 /* See breakpoint.h. */
4252 hardware_breakpoint_inserted_here_p (const address_space
*aspace
,
4255 struct bp_location
**blp
, **blp_tmp
= NULL
;
4257 ALL_BP_LOCATIONS_AT_ADDR (blp
, blp_tmp
, pc
)
4259 struct bp_location
*bl
= *blp
;
4261 if (bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4264 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4272 hardware_watchpoint_inserted_in_range (const address_space
*aspace
,
4273 CORE_ADDR addr
, ULONGEST len
)
4275 struct breakpoint
*bpt
;
4277 ALL_BREAKPOINTS (bpt
)
4279 struct bp_location
*loc
;
4281 if (bpt
->type
!= bp_hardware_watchpoint
4282 && bpt
->type
!= bp_access_watchpoint
)
4285 if (!breakpoint_enabled (bpt
))
4288 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
4289 if (loc
->pspace
->aspace
== aspace
&& loc
->inserted
)
4293 /* Check for intersection. */
4294 l
= std::max
<CORE_ADDR
> (loc
->address
, addr
);
4295 h
= std::min
<CORE_ADDR
> (loc
->address
+ loc
->length
, addr
+ len
);
4303 /* See breakpoint.h. */
4306 is_catchpoint (struct breakpoint
*b
)
4308 return (b
->type
== bp_catchpoint
);
4311 /* Clear a bpstat so that it says we are not at any breakpoint.
4312 Also free any storage that is part of a bpstat. */
4315 bpstat_clear (bpstat
*bsp
)
4332 bpstats::bpstats (const bpstats
&other
)
4334 bp_location_at (other
.bp_location_at
),
4335 breakpoint_at (other
.breakpoint_at
),
4336 commands (other
.commands
),
4337 print (other
.print
),
4339 print_it (other
.print_it
)
4341 if (other
.old_val
!= NULL
)
4342 old_val
= release_value (value_copy (other
.old_val
.get ()));
4345 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
4346 is part of the bpstat is copied as well. */
4349 bpstat_copy (bpstat bs
)
4353 bpstat retval
= NULL
;
4358 for (; bs
!= NULL
; bs
= bs
->next
)
4360 tmp
= new bpstats (*bs
);
4363 /* This is the first thing in the chain. */
4373 /* Find the bpstat associated with this breakpoint. */
4376 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
4381 for (; bsp
!= NULL
; bsp
= bsp
->next
)
4383 if (bsp
->breakpoint_at
== breakpoint
)
4389 /* See breakpoint.h. */
4392 bpstat_explains_signal (bpstat bsp
, enum gdb_signal sig
)
4394 for (; bsp
!= NULL
; bsp
= bsp
->next
)
4396 if (bsp
->breakpoint_at
== NULL
)
4398 /* A moribund location can never explain a signal other than
4400 if (sig
== GDB_SIGNAL_TRAP
)
4405 if (bsp
->breakpoint_at
->ops
->explains_signal (bsp
->breakpoint_at
,
4414 /* Put in *NUM the breakpoint number of the first breakpoint we are
4415 stopped at. *BSP upon return is a bpstat which points to the
4416 remaining breakpoints stopped at (but which is not guaranteed to be
4417 good for anything but further calls to bpstat_num).
4419 Return 0 if passed a bpstat which does not indicate any breakpoints.
4420 Return -1 if stopped at a breakpoint that has been deleted since
4422 Return 1 otherwise. */
4425 bpstat_num (bpstat
*bsp
, int *num
)
4427 struct breakpoint
*b
;
4430 return 0; /* No more breakpoint values */
4432 /* We assume we'll never have several bpstats that correspond to a
4433 single breakpoint -- otherwise, this function might return the
4434 same number more than once and this will look ugly. */
4435 b
= (*bsp
)->breakpoint_at
;
4436 *bsp
= (*bsp
)->next
;
4438 return -1; /* breakpoint that's been deleted since */
4440 *num
= b
->number
; /* We have its number */
4444 /* See breakpoint.h. */
4447 bpstat_clear_actions (void)
4451 if (inferior_ptid
== null_ptid
)
4454 thread_info
*tp
= inferior_thread ();
4455 for (bs
= tp
->control
.stop_bpstat
; bs
!= NULL
; bs
= bs
->next
)
4457 bs
->commands
= NULL
;
4458 bs
->old_val
.reset (nullptr);
4462 /* Called when a command is about to proceed the inferior. */
4465 breakpoint_about_to_proceed (void)
4467 if (inferior_ptid
!= null_ptid
)
4469 struct thread_info
*tp
= inferior_thread ();
4471 /* Allow inferior function calls in breakpoint commands to not
4472 interrupt the command list. When the call finishes
4473 successfully, the inferior will be standing at the same
4474 breakpoint as if nothing happened. */
4475 if (tp
->control
.in_infcall
)
4479 breakpoint_proceeded
= 1;
4482 /* Return non-zero iff CMD as the first line of a command sequence is `silent'
4483 or its equivalent. */
4486 command_line_is_silent (struct command_line
*cmd
)
4488 return cmd
&& (strcmp ("silent", cmd
->line
) == 0);
4491 /* Execute all the commands associated with all the breakpoints at
4492 this location. Any of these commands could cause the process to
4493 proceed beyond this point, etc. We look out for such changes by
4494 checking the global "breakpoint_proceeded" after each command.
4496 Returns true if a breakpoint command resumed the inferior. In that
4497 case, it is the caller's responsibility to recall it again with the
4498 bpstat of the current thread. */
4501 bpstat_do_actions_1 (bpstat
*bsp
)
4506 /* Avoid endless recursion if a `source' command is contained
4508 if (executing_breakpoint_commands
)
4511 scoped_restore save_executing
4512 = make_scoped_restore (&executing_breakpoint_commands
, 1);
4514 scoped_restore preventer
= prevent_dont_repeat ();
4516 /* This pointer will iterate over the list of bpstat's. */
4519 breakpoint_proceeded
= 0;
4520 for (; bs
!= NULL
; bs
= bs
->next
)
4522 struct command_line
*cmd
= NULL
;
4524 /* Take ownership of the BSP's command tree, if it has one.
4526 The command tree could legitimately contain commands like
4527 'step' and 'next', which call clear_proceed_status, which
4528 frees stop_bpstat's command tree. To make sure this doesn't
4529 free the tree we're executing out from under us, we need to
4530 take ownership of the tree ourselves. Since a given bpstat's
4531 commands are only executed once, we don't need to copy it; we
4532 can clear the pointer in the bpstat, and make sure we free
4533 the tree when we're done. */
4534 counted_command_line ccmd
= bs
->commands
;
4535 bs
->commands
= NULL
;
4538 if (command_line_is_silent (cmd
))
4540 /* The action has been already done by bpstat_stop_status. */
4546 execute_control_command (cmd
);
4548 if (breakpoint_proceeded
)
4554 if (breakpoint_proceeded
)
4556 if (current_ui
->async
)
4557 /* If we are in async mode, then the target might be still
4558 running, not stopped at any breakpoint, so nothing for
4559 us to do here -- just return to the event loop. */
4562 /* In sync mode, when execute_control_command returns
4563 we're already standing on the next breakpoint.
4564 Breakpoint commands for that stop were not run, since
4565 execute_command does not run breakpoint commands --
4566 only command_line_handler does, but that one is not
4567 involved in execution of breakpoint commands. So, we
4568 can now execute breakpoint commands. It should be
4569 noted that making execute_command do bpstat actions is
4570 not an option -- in this case we'll have recursive
4571 invocation of bpstat for each breakpoint with a
4572 command, and can easily blow up GDB stack. Instead, we
4573 return true, which will trigger the caller to recall us
4574 with the new stop_bpstat. */
4582 /* Helper for bpstat_do_actions. Get the current thread, if there's
4583 one, is alive and has execution. Return NULL otherwise. */
4585 static thread_info
*
4586 get_bpstat_thread ()
4588 if (inferior_ptid
== null_ptid
|| !target_has_execution ())
4591 thread_info
*tp
= inferior_thread ();
4592 if (tp
->state
== THREAD_EXITED
|| tp
->executing
)
4598 bpstat_do_actions (void)
4600 auto cleanup_if_error
= make_scope_exit (bpstat_clear_actions
);
4603 /* Do any commands attached to breakpoint we are stopped at. */
4604 while ((tp
= get_bpstat_thread ()) != NULL
)
4606 /* Since in sync mode, bpstat_do_actions may resume the
4607 inferior, and only return when it is stopped at the next
4608 breakpoint, we keep doing breakpoint actions until it returns
4609 false to indicate the inferior was not resumed. */
4610 if (!bpstat_do_actions_1 (&tp
->control
.stop_bpstat
))
4614 cleanup_if_error
.release ();
4617 /* Print out the (old or new) value associated with a watchpoint. */
4620 watchpoint_value_print (struct value
*val
, struct ui_file
*stream
)
4623 fprintf_styled (stream
, metadata_style
.style (), _("<unreadable>"));
4626 struct value_print_options opts
;
4627 get_user_print_options (&opts
);
4628 value_print (val
, stream
, &opts
);
4632 /* Print the "Thread ID hit" part of "Thread ID hit Breakpoint N" if
4633 debugging multiple threads. */
4636 maybe_print_thread_hit_breakpoint (struct ui_out
*uiout
)
4638 if (uiout
->is_mi_like_p ())
4643 if (show_thread_that_caused_stop ())
4646 struct thread_info
*thr
= inferior_thread ();
4648 uiout
->text ("Thread ");
4649 uiout
->field_string ("thread-id", print_thread_id (thr
));
4651 name
= thr
->name
!= NULL
? thr
->name
: target_thread_name (thr
);
4654 uiout
->text (" \"");
4655 uiout
->field_string ("name", name
);
4659 uiout
->text (" hit ");
4663 /* Generic routine for printing messages indicating why we
4664 stopped. The behavior of this function depends on the value
4665 'print_it' in the bpstat structure. Under some circumstances we
4666 may decide not to print anything here and delegate the task to
4669 static enum print_stop_action
4670 print_bp_stop_message (bpstat bs
)
4672 switch (bs
->print_it
)
4675 /* Nothing should be printed for this bpstat entry. */
4676 return PRINT_UNKNOWN
;
4680 /* We still want to print the frame, but we already printed the
4681 relevant messages. */
4682 return PRINT_SRC_AND_LOC
;
4685 case print_it_normal
:
4687 struct breakpoint
*b
= bs
->breakpoint_at
;
4689 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
4690 which has since been deleted. */
4692 return PRINT_UNKNOWN
;
4694 /* Normal case. Call the breakpoint's print_it method. */
4695 return b
->ops
->print_it (bs
);
4700 internal_error (__FILE__
, __LINE__
,
4701 _("print_bp_stop_message: unrecognized enum value"));
4706 /* A helper function that prints a shared library stopped event. */
4709 print_solib_event (int is_catchpoint
)
4711 bool any_deleted
= !current_program_space
->deleted_solibs
.empty ();
4712 bool any_added
= !current_program_space
->added_solibs
.empty ();
4716 if (any_added
|| any_deleted
)
4717 current_uiout
->text (_("Stopped due to shared library event:\n"));
4719 current_uiout
->text (_("Stopped due to shared library event (no "
4720 "libraries added or removed)\n"));
4723 if (current_uiout
->is_mi_like_p ())
4724 current_uiout
->field_string ("reason",
4725 async_reason_lookup (EXEC_ASYNC_SOLIB_EVENT
));
4729 current_uiout
->text (_(" Inferior unloaded "));
4730 ui_out_emit_list
list_emitter (current_uiout
, "removed");
4731 for (int ix
= 0; ix
< current_program_space
->deleted_solibs
.size (); ix
++)
4733 const std::string
&name
= current_program_space
->deleted_solibs
[ix
];
4736 current_uiout
->text (" ");
4737 current_uiout
->field_string ("library", name
);
4738 current_uiout
->text ("\n");
4744 current_uiout
->text (_(" Inferior loaded "));
4745 ui_out_emit_list
list_emitter (current_uiout
, "added");
4747 for (so_list
*iter
: current_program_space
->added_solibs
)
4750 current_uiout
->text (" ");
4752 current_uiout
->field_string ("library", iter
->so_name
);
4753 current_uiout
->text ("\n");
4758 /* Print a message indicating what happened. This is called from
4759 normal_stop(). The input to this routine is the head of the bpstat
4760 list - a list of the eventpoints that caused this stop. KIND is
4761 the target_waitkind for the stopping event. This
4762 routine calls the generic print routine for printing a message
4763 about reasons for stopping. This will print (for example) the
4764 "Breakpoint n," part of the output. The return value of this
4767 PRINT_UNKNOWN: Means we printed nothing.
4768 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
4769 code to print the location. An example is
4770 "Breakpoint 1, " which should be followed by
4772 PRINT_SRC_ONLY: Means we printed something, but there is no need
4773 to also print the location part of the message.
4774 An example is the catch/throw messages, which
4775 don't require a location appended to the end.
4776 PRINT_NOTHING: We have done some printing and we don't need any
4777 further info to be printed. */
4779 enum print_stop_action
4780 bpstat_print (bpstat bs
, int kind
)
4782 enum print_stop_action val
;
4784 /* Maybe another breakpoint in the chain caused us to stop.
4785 (Currently all watchpoints go on the bpstat whether hit or not.
4786 That probably could (should) be changed, provided care is taken
4787 with respect to bpstat_explains_signal). */
4788 for (; bs
; bs
= bs
->next
)
4790 val
= print_bp_stop_message (bs
);
4791 if (val
== PRINT_SRC_ONLY
4792 || val
== PRINT_SRC_AND_LOC
4793 || val
== PRINT_NOTHING
)
4797 /* If we had hit a shared library event breakpoint,
4798 print_bp_stop_message would print out this message. If we hit an
4799 OS-level shared library event, do the same thing. */
4800 if (kind
== TARGET_WAITKIND_LOADED
)
4802 print_solib_event (0);
4803 return PRINT_NOTHING
;
4806 /* We reached the end of the chain, or we got a null BS to start
4807 with and nothing was printed. */
4808 return PRINT_UNKNOWN
;
4811 /* Evaluate the boolean expression EXP and return the result. */
4814 breakpoint_cond_eval (expression
*exp
)
4816 struct value
*mark
= value_mark ();
4817 bool res
= value_true (evaluate_expression (exp
));
4819 value_free_to_mark (mark
);
4823 /* Allocate a new bpstat. Link it to the FIFO list by BS_LINK_POINTER. */
4825 bpstats::bpstats (struct bp_location
*bl
, bpstat
**bs_link_pointer
)
4827 bp_location_at (bp_location_ref_ptr::new_reference (bl
)),
4828 breakpoint_at (bl
->owner
),
4832 print_it (print_it_normal
)
4834 **bs_link_pointer
= this;
4835 *bs_link_pointer
= &next
;
4840 breakpoint_at (NULL
),
4844 print_it (print_it_normal
)
4848 /* The target has stopped with waitstatus WS. Check if any hardware
4849 watchpoints have triggered, according to the target. */
4852 watchpoints_triggered (struct target_waitstatus
*ws
)
4854 bool stopped_by_watchpoint
= target_stopped_by_watchpoint ();
4856 struct breakpoint
*b
;
4858 if (!stopped_by_watchpoint
)
4860 /* We were not stopped by a watchpoint. Mark all watchpoints
4861 as not triggered. */
4863 if (is_hardware_watchpoint (b
))
4865 struct watchpoint
*w
= (struct watchpoint
*) b
;
4867 w
->watchpoint_triggered
= watch_triggered_no
;
4873 if (!target_stopped_data_address (current_top_target (), &addr
))
4875 /* We were stopped by a watchpoint, but we don't know where.
4876 Mark all watchpoints as unknown. */
4878 if (is_hardware_watchpoint (b
))
4880 struct watchpoint
*w
= (struct watchpoint
*) b
;
4882 w
->watchpoint_triggered
= watch_triggered_unknown
;
4888 /* The target could report the data address. Mark watchpoints
4889 affected by this data address as triggered, and all others as not
4893 if (is_hardware_watchpoint (b
))
4895 struct watchpoint
*w
= (struct watchpoint
*) b
;
4896 struct bp_location
*loc
;
4898 w
->watchpoint_triggered
= watch_triggered_no
;
4899 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
4901 if (is_masked_watchpoint (b
))
4903 CORE_ADDR newaddr
= addr
& w
->hw_wp_mask
;
4904 CORE_ADDR start
= loc
->address
& w
->hw_wp_mask
;
4906 if (newaddr
== start
)
4908 w
->watchpoint_triggered
= watch_triggered_yes
;
4912 /* Exact match not required. Within range is sufficient. */
4913 else if (target_watchpoint_addr_within_range (current_top_target (),
4917 w
->watchpoint_triggered
= watch_triggered_yes
;
4926 /* Possible return values for watchpoint_check. */
4927 enum wp_check_result
4929 /* The watchpoint has been deleted. */
4932 /* The value has changed. */
4933 WP_VALUE_CHANGED
= 2,
4935 /* The value has not changed. */
4936 WP_VALUE_NOT_CHANGED
= 3,
4938 /* Ignore this watchpoint, no matter if the value changed or not. */
4942 #define BP_TEMPFLAG 1
4943 #define BP_HARDWAREFLAG 2
4945 /* Evaluate watchpoint condition expression and check if its value
4948 static wp_check_result
4949 watchpoint_check (bpstat bs
)
4951 struct watchpoint
*b
;
4952 struct frame_info
*fr
;
4953 int within_current_scope
;
4955 /* BS is built from an existing struct breakpoint. */
4956 gdb_assert (bs
->breakpoint_at
!= NULL
);
4957 b
= (struct watchpoint
*) bs
->breakpoint_at
;
4959 /* If this is a local watchpoint, we only want to check if the
4960 watchpoint frame is in scope if the current thread is the thread
4961 that was used to create the watchpoint. */
4962 if (!watchpoint_in_thread_scope (b
))
4965 if (b
->exp_valid_block
== NULL
)
4966 within_current_scope
= 1;
4969 struct frame_info
*frame
= get_current_frame ();
4970 struct gdbarch
*frame_arch
= get_frame_arch (frame
);
4971 CORE_ADDR frame_pc
= get_frame_pc (frame
);
4973 /* stack_frame_destroyed_p() returns a non-zero value if we're
4974 still in the function but the stack frame has already been
4975 invalidated. Since we can't rely on the values of local
4976 variables after the stack has been destroyed, we are treating
4977 the watchpoint in that state as `not changed' without further
4978 checking. Don't mark watchpoints as changed if the current
4979 frame is in an epilogue - even if they are in some other
4980 frame, our view of the stack is likely to be wrong and
4981 frame_find_by_id could error out. */
4982 if (gdbarch_stack_frame_destroyed_p (frame_arch
, frame_pc
))
4985 fr
= frame_find_by_id (b
->watchpoint_frame
);
4986 within_current_scope
= (fr
!= NULL
);
4988 /* If we've gotten confused in the unwinder, we might have
4989 returned a frame that can't describe this variable. */
4990 if (within_current_scope
)
4992 struct symbol
*function
;
4994 function
= get_frame_function (fr
);
4995 if (function
== NULL
4996 || !contained_in (b
->exp_valid_block
,
4997 SYMBOL_BLOCK_VALUE (function
)))
4998 within_current_scope
= 0;
5001 if (within_current_scope
)
5002 /* If we end up stopping, the current frame will get selected
5003 in normal_stop. So this call to select_frame won't affect
5008 if (within_current_scope
)
5010 /* We use value_{,free_to_}mark because it could be a *long*
5011 time before we return to the command level and call
5012 free_all_values. We can't call free_all_values because we
5013 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 (), &pc
, &new_val
, NULL
, NULL
, false);
5028 if (b
->val_bitsize
!= 0)
5029 new_val
= extract_bitfield_from_watchpoint_value (b
, new_val
);
5031 /* We use value_equal_contents instead of value_equal because
5032 the latter coerces an array to a pointer, thus comparing just
5033 the address of the array instead of its contents. This is
5034 not what we want. */
5035 if ((b
->val
!= NULL
) != (new_val
!= NULL
)
5036 || (b
->val
!= NULL
&& !value_equal_contents (b
->val
.get (),
5039 bs
->old_val
= b
->val
;
5040 b
->val
= release_value (new_val
);
5041 b
->val_valid
= true;
5042 if (new_val
!= NULL
)
5043 value_free_to_mark (mark
);
5044 return WP_VALUE_CHANGED
;
5048 /* Nothing changed. */
5049 value_free_to_mark (mark
);
5050 return WP_VALUE_NOT_CHANGED
;
5055 /* This seems like the only logical thing to do because
5056 if we temporarily ignored the watchpoint, then when
5057 we reenter the block in which it is valid it contains
5058 garbage (in the case of a function, it may have two
5059 garbage values, one before and one after the prologue).
5060 So we can't even detect the first assignment to it and
5061 watch after that (since the garbage may or may not equal
5062 the first value assigned). */
5063 /* We print all the stop information in
5064 breakpoint_ops->print_it, but in this case, by the time we
5065 call breakpoint_ops->print_it this bp will be deleted
5066 already. So we have no choice but print the information
5069 SWITCH_THRU_ALL_UIS ()
5071 struct ui_out
*uiout
= current_uiout
;
5073 if (uiout
->is_mi_like_p ())
5075 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
5076 uiout
->message ("\nWatchpoint %pF deleted because the program has "
5077 "left the block in\n"
5078 "which its expression is valid.\n",
5079 signed_field ("wpnum", b
->number
));
5082 /* Make sure the watchpoint's commands aren't executed. */
5084 watchpoint_del_at_next_stop (b
);
5090 /* Return true if it looks like target has stopped due to hitting
5091 breakpoint location BL. This function does not check if we should
5092 stop, only if BL explains the stop. */
5095 bpstat_check_location (const struct bp_location
*bl
,
5096 const address_space
*aspace
, CORE_ADDR bp_addr
,
5097 const struct target_waitstatus
*ws
)
5099 struct breakpoint
*b
= bl
->owner
;
5101 /* BL is from an existing breakpoint. */
5102 gdb_assert (b
!= NULL
);
5104 return b
->ops
->breakpoint_hit (bl
, aspace
, bp_addr
, ws
);
5107 /* Determine if the watched values have actually changed, and we
5108 should stop. If not, set BS->stop to 0. */
5111 bpstat_check_watchpoint (bpstat bs
)
5113 const struct bp_location
*bl
;
5114 struct watchpoint
*b
;
5116 /* BS is built for existing struct breakpoint. */
5117 bl
= bs
->bp_location_at
.get ();
5118 gdb_assert (bl
!= NULL
);
5119 b
= (struct watchpoint
*) bs
->breakpoint_at
;
5120 gdb_assert (b
!= NULL
);
5123 int must_check_value
= 0;
5125 if (b
->type
== bp_watchpoint
)
5126 /* For a software watchpoint, we must always check the
5128 must_check_value
= 1;
5129 else if (b
->watchpoint_triggered
== watch_triggered_yes
)
5130 /* We have a hardware watchpoint (read, write, or access)
5131 and the target earlier reported an address watched by
5133 must_check_value
= 1;
5134 else if (b
->watchpoint_triggered
== watch_triggered_unknown
5135 && b
->type
== bp_hardware_watchpoint
)
5136 /* We were stopped by a hardware watchpoint, but the target could
5137 not report the data address. We must check the watchpoint's
5138 value. Access and read watchpoints are out of luck; without
5139 a data address, we can't figure it out. */
5140 must_check_value
= 1;
5142 if (must_check_value
)
5148 e
= watchpoint_check (bs
);
5150 catch (const gdb_exception
&ex
)
5152 exception_fprintf (gdb_stderr
, ex
,
5153 "Error evaluating expression "
5154 "for watchpoint %d\n",
5157 SWITCH_THRU_ALL_UIS ()
5159 printf_filtered (_("Watchpoint %d deleted.\n"),
5162 watchpoint_del_at_next_stop (b
);
5169 /* We've already printed what needs to be printed. */
5170 bs
->print_it
= print_it_done
;
5174 bs
->print_it
= print_it_noop
;
5177 case WP_VALUE_CHANGED
:
5178 if (b
->type
== bp_read_watchpoint
)
5180 /* There are two cases to consider here:
5182 1. We're watching the triggered memory for reads.
5183 In that case, trust the target, and always report
5184 the watchpoint hit to the user. Even though
5185 reads don't cause value changes, the value may
5186 have changed since the last time it was read, and
5187 since we're not trapping writes, we will not see
5188 those, and as such we should ignore our notion of
5191 2. We're watching the triggered memory for both
5192 reads and writes. There are two ways this may
5195 2.1. This is a target that can't break on data
5196 reads only, but can break on accesses (reads or
5197 writes), such as e.g., x86. We detect this case
5198 at the time we try to insert read watchpoints.
5200 2.2. Otherwise, the target supports read
5201 watchpoints, but, the user set an access or write
5202 watchpoint watching the same memory as this read
5205 If we're watching memory writes as well as reads,
5206 ignore watchpoint hits when we find that the
5207 value hasn't changed, as reads don't cause
5208 changes. This still gives false positives when
5209 the program writes the same value to memory as
5210 what there was already in memory (we will confuse
5211 it for a read), but it's much better than
5214 int other_write_watchpoint
= 0;
5216 if (bl
->watchpoint_type
== hw_read
)
5218 struct breakpoint
*other_b
;
5220 ALL_BREAKPOINTS (other_b
)
5221 if (other_b
->type
== bp_hardware_watchpoint
5222 || other_b
->type
== bp_access_watchpoint
)
5224 struct watchpoint
*other_w
=
5225 (struct watchpoint
*) other_b
;
5227 if (other_w
->watchpoint_triggered
5228 == watch_triggered_yes
)
5230 other_write_watchpoint
= 1;
5236 if (other_write_watchpoint
5237 || bl
->watchpoint_type
== hw_access
)
5239 /* We're watching the same memory for writes,
5240 and the value changed since the last time we
5241 updated it, so this trap must be for a write.
5243 bs
->print_it
= print_it_noop
;
5248 case WP_VALUE_NOT_CHANGED
:
5249 if (b
->type
== bp_hardware_watchpoint
5250 || b
->type
== bp_watchpoint
)
5252 /* Don't stop: write watchpoints shouldn't fire if
5253 the value hasn't changed. */
5254 bs
->print_it
= print_it_noop
;
5264 else /* must_check_value == 0 */
5266 /* This is a case where some watchpoint(s) triggered, but
5267 not at the address of this watchpoint, or else no
5268 watchpoint triggered after all. So don't print
5269 anything for this watchpoint. */
5270 bs
->print_it
= print_it_noop
;
5276 /* For breakpoints that are currently marked as telling gdb to stop,
5277 check conditions (condition proper, frame, thread and ignore count)
5278 of breakpoint referred to by BS. If we should not stop for this
5279 breakpoint, set BS->stop to 0. */
5282 bpstat_check_breakpoint_conditions (bpstat bs
, thread_info
*thread
)
5284 const struct bp_location
*bl
;
5285 struct breakpoint
*b
;
5287 bool condition_result
= true;
5288 struct expression
*cond
;
5290 gdb_assert (bs
->stop
);
5292 /* BS is built for existing struct breakpoint. */
5293 bl
= bs
->bp_location_at
.get ();
5294 gdb_assert (bl
!= NULL
);
5295 b
= bs
->breakpoint_at
;
5296 gdb_assert (b
!= NULL
);
5298 /* Even if the target evaluated the condition on its end and notified GDB, we
5299 need to do so again since GDB does not know if we stopped due to a
5300 breakpoint or a single step breakpoint. */
5302 if (frame_id_p (b
->frame_id
)
5303 && !frame_id_eq (b
->frame_id
, get_stack_frame_id (get_current_frame ())))
5309 /* If this is a thread/task-specific breakpoint, don't waste cpu
5310 evaluating the condition if this isn't the specified
5312 if ((b
->thread
!= -1 && b
->thread
!= thread
->global_num
)
5313 || (b
->task
!= 0 && b
->task
!= ada_get_task_number (thread
)))
5319 /* Evaluate extension language breakpoints that have a "stop" method
5321 bs
->stop
= breakpoint_ext_lang_cond_says_stop (b
);
5323 if (is_watchpoint (b
))
5325 struct watchpoint
*w
= (struct watchpoint
*) b
;
5327 cond
= w
->cond_exp
.get ();
5330 cond
= bl
->cond
.get ();
5332 if (cond
&& b
->disposition
!= disp_del_at_next_stop
)
5334 int within_current_scope
= 1;
5335 struct watchpoint
* w
;
5337 /* We use value_mark and value_free_to_mark because it could
5338 be a long time before we return to the command level and
5339 call free_all_values. We can't call free_all_values
5340 because we might be in the middle of evaluating a
5342 struct value
*mark
= value_mark ();
5344 if (is_watchpoint (b
))
5345 w
= (struct watchpoint
*) b
;
5349 /* Need to select the frame, with all that implies so that
5350 the conditions will have the right context. Because we
5351 use the frame, we will not see an inlined function's
5352 variables when we arrive at a breakpoint at the start
5353 of the inlined function; the current frame will be the
5355 if (w
== NULL
|| w
->cond_exp_valid_block
== NULL
)
5356 select_frame (get_current_frame ());
5359 struct frame_info
*frame
;
5361 /* For local watchpoint expressions, which particular
5362 instance of a local is being watched matters, so we
5363 keep track of the frame to evaluate the expression
5364 in. To evaluate the condition however, it doesn't
5365 really matter which instantiation of the function
5366 where the condition makes sense triggers the
5367 watchpoint. This allows an expression like "watch
5368 global if q > 10" set in `func', catch writes to
5369 global on all threads that call `func', or catch
5370 writes on all recursive calls of `func' by a single
5371 thread. We simply always evaluate the condition in
5372 the innermost frame that's executing where it makes
5373 sense to evaluate the condition. It seems
5375 frame
= block_innermost_frame (w
->cond_exp_valid_block
);
5377 select_frame (frame
);
5379 within_current_scope
= 0;
5381 if (within_current_scope
)
5385 condition_result
= breakpoint_cond_eval (cond
);
5387 catch (const gdb_exception
&ex
)
5389 exception_fprintf (gdb_stderr
, ex
,
5390 "Error in testing breakpoint condition:\n");
5395 warning (_("Watchpoint condition cannot be tested "
5396 "in the current scope"));
5397 /* If we failed to set the right context for this
5398 watchpoint, unconditionally report it. */
5400 /* FIXME-someday, should give breakpoint #. */
5401 value_free_to_mark (mark
);
5404 if (cond
&& !condition_result
)
5408 else if (b
->ignore_count
> 0)
5412 /* Increase the hit count even though we don't stop. */
5414 gdb::observers::breakpoint_modified
.notify (b
);
5418 /* Returns true if we need to track moribund locations of LOC's type
5419 on the current target. */
5422 need_moribund_for_location_type (struct bp_location
*loc
)
5424 return ((loc
->loc_type
== bp_loc_software_breakpoint
5425 && !target_supports_stopped_by_sw_breakpoint ())
5426 || (loc
->loc_type
== bp_loc_hardware_breakpoint
5427 && !target_supports_stopped_by_hw_breakpoint ()));
5430 /* See breakpoint.h. */
5433 build_bpstat_chain (const address_space
*aspace
, CORE_ADDR bp_addr
,
5434 const struct target_waitstatus
*ws
)
5436 struct breakpoint
*b
;
5437 bpstat bs_head
= NULL
, *bs_link
= &bs_head
;
5441 if (!breakpoint_enabled (b
))
5444 for (bp_location
*bl
= b
->loc
; bl
!= NULL
; bl
= bl
->next
)
5446 /* For hardware watchpoints, we look only at the first
5447 location. The watchpoint_check function will work on the
5448 entire expression, not the individual locations. For
5449 read watchpoints, the watchpoints_triggered function has
5450 checked all locations already. */
5451 if (b
->type
== bp_hardware_watchpoint
&& bl
!= b
->loc
)
5454 if (!bl
->enabled
|| bl
->disabled_by_cond
|| bl
->shlib_disabled
)
5457 if (!bpstat_check_location (bl
, aspace
, bp_addr
, ws
))
5460 /* Come here if it's a watchpoint, or if the break address
5463 bpstat bs
= new bpstats (bl
, &bs_link
); /* Alloc a bpstat to
5466 /* Assume we stop. Should we find a watchpoint that is not
5467 actually triggered, or if the condition of the breakpoint
5468 evaluates as false, we'll reset 'stop' to 0. */
5472 /* If this is a scope breakpoint, mark the associated
5473 watchpoint as triggered so that we will handle the
5474 out-of-scope event. We'll get to the watchpoint next
5476 if (b
->type
== bp_watchpoint_scope
&& b
->related_breakpoint
!= b
)
5478 struct watchpoint
*w
= (struct watchpoint
*) b
->related_breakpoint
;
5480 w
->watchpoint_triggered
= watch_triggered_yes
;
5485 /* Check if a moribund breakpoint explains the stop. */
5486 if (!target_supports_stopped_by_sw_breakpoint ()
5487 || !target_supports_stopped_by_hw_breakpoint ())
5489 for (bp_location
*loc
: moribund_locations
)
5491 if (breakpoint_location_address_match (loc
, aspace
, bp_addr
)
5492 && need_moribund_for_location_type (loc
))
5494 bpstat bs
= new bpstats (loc
, &bs_link
);
5495 /* For hits of moribund locations, we should just proceed. */
5498 bs
->print_it
= print_it_noop
;
5506 /* See breakpoint.h. */
5509 bpstat_stop_status (const address_space
*aspace
,
5510 CORE_ADDR bp_addr
, thread_info
*thread
,
5511 const struct target_waitstatus
*ws
,
5514 struct breakpoint
*b
= NULL
;
5515 /* First item of allocated bpstat's. */
5516 bpstat bs_head
= stop_chain
;
5518 int need_remove_insert
;
5521 /* First, build the bpstat chain with locations that explain a
5522 target stop, while being careful to not set the target running,
5523 as that may invalidate locations (in particular watchpoint
5524 locations are recreated). Resuming will happen here with
5525 breakpoint conditions or watchpoint expressions that include
5526 inferior function calls. */
5527 if (bs_head
== NULL
)
5528 bs_head
= build_bpstat_chain (aspace
, bp_addr
, ws
);
5530 /* A bit of special processing for shlib breakpoints. We need to
5531 process solib loading here, so that the lists of loaded and
5532 unloaded libraries are correct before we handle "catch load" and
5534 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5536 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->type
== bp_shlib_event
)
5538 handle_solib_event ();
5543 /* Now go through the locations that caused the target to stop, and
5544 check whether we're interested in reporting this stop to higher
5545 layers, or whether we should resume the target transparently. */
5549 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5554 b
= bs
->breakpoint_at
;
5555 b
->ops
->check_status (bs
);
5558 bpstat_check_breakpoint_conditions (bs
, thread
);
5563 gdb::observers::breakpoint_modified
.notify (b
);
5565 /* We will stop here. */
5566 if (b
->disposition
== disp_disable
)
5568 --(b
->enable_count
);
5569 if (b
->enable_count
<= 0)
5570 b
->enable_state
= bp_disabled
;
5575 bs
->commands
= b
->commands
;
5576 if (command_line_is_silent (bs
->commands
5577 ? bs
->commands
.get () : NULL
))
5580 b
->ops
->after_condition_true (bs
);
5585 /* Print nothing for this entry if we don't stop or don't
5587 if (!bs
->stop
|| !bs
->print
)
5588 bs
->print_it
= print_it_noop
;
5591 /* If we aren't stopping, the value of some hardware watchpoint may
5592 not have changed, but the intermediate memory locations we are
5593 watching may have. Don't bother if we're stopping; this will get
5595 need_remove_insert
= 0;
5596 if (! bpstat_causes_stop (bs_head
))
5597 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5599 && bs
->breakpoint_at
5600 && is_hardware_watchpoint (bs
->breakpoint_at
))
5602 struct watchpoint
*w
= (struct watchpoint
*) bs
->breakpoint_at
;
5604 update_watchpoint (w
, 0 /* don't reparse. */);
5605 need_remove_insert
= 1;
5608 if (need_remove_insert
)
5609 update_global_location_list (UGLL_MAY_INSERT
);
5610 else if (removed_any
)
5611 update_global_location_list (UGLL_DONT_INSERT
);
5617 handle_jit_event (CORE_ADDR address
)
5619 struct gdbarch
*gdbarch
;
5621 infrun_debug_printf ("handling bp_jit_event");
5623 /* Switch terminal for any messages produced by
5624 breakpoint_re_set. */
5625 target_terminal::ours_for_output ();
5627 gdbarch
= get_frame_arch (get_current_frame ());
5628 /* This event is caused by a breakpoint set in `jit_breakpoint_re_set`,
5629 thus it is expected that its objectfile can be found through
5630 minimal symbol lookup. If it doesn't work (and assert fails), it
5631 most likely means that `jit_breakpoint_re_set` was changes and this
5632 function needs to be updated too. */
5633 bound_minimal_symbol jit_bp_sym
= lookup_minimal_symbol_by_pc (address
);
5634 gdb_assert (jit_bp_sym
.objfile
!= nullptr);
5635 jit_event_handler (gdbarch
, jit_bp_sym
.objfile
);
5637 target_terminal::inferior ();
5640 /* Prepare WHAT final decision for infrun. */
5642 /* Decide what infrun needs to do with this bpstat. */
5645 bpstat_what (bpstat bs_head
)
5647 struct bpstat_what retval
;
5650 retval
.main_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5651 retval
.call_dummy
= STOP_NONE
;
5652 retval
.is_longjmp
= false;
5654 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5656 /* Extract this BS's action. After processing each BS, we check
5657 if its action overrides all we've seem so far. */
5658 enum bpstat_what_main_action this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5661 if (bs
->breakpoint_at
== NULL
)
5663 /* I suspect this can happen if it was a momentary
5664 breakpoint which has since been deleted. */
5668 bptype
= bs
->breakpoint_at
->type
;
5675 case bp_hardware_breakpoint
:
5676 case bp_single_step
:
5679 case bp_shlib_event
:
5683 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5685 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5688 this_action
= BPSTAT_WHAT_SINGLE
;
5691 case bp_hardware_watchpoint
:
5692 case bp_read_watchpoint
:
5693 case bp_access_watchpoint
:
5697 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5699 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5703 /* There was a watchpoint, but we're not stopping.
5704 This requires no further action. */
5708 case bp_longjmp_call_dummy
:
5712 this_action
= BPSTAT_WHAT_SET_LONGJMP_RESUME
;
5713 retval
.is_longjmp
= bptype
!= bp_exception
;
5716 this_action
= BPSTAT_WHAT_SINGLE
;
5718 case bp_longjmp_resume
:
5719 case bp_exception_resume
:
5722 this_action
= BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
;
5723 retval
.is_longjmp
= bptype
== bp_longjmp_resume
;
5726 this_action
= BPSTAT_WHAT_SINGLE
;
5728 case bp_step_resume
:
5730 this_action
= BPSTAT_WHAT_STEP_RESUME
;
5733 /* It is for the wrong frame. */
5734 this_action
= BPSTAT_WHAT_SINGLE
;
5737 case bp_hp_step_resume
:
5739 this_action
= BPSTAT_WHAT_HP_STEP_RESUME
;
5742 /* It is for the wrong frame. */
5743 this_action
= BPSTAT_WHAT_SINGLE
;
5746 case bp_watchpoint_scope
:
5747 case bp_thread_event
:
5748 case bp_overlay_event
:
5749 case bp_longjmp_master
:
5750 case bp_std_terminate_master
:
5751 case bp_exception_master
:
5752 this_action
= BPSTAT_WHAT_SINGLE
;
5758 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5760 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5764 /* Some catchpoints are implemented with breakpoints.
5765 For those, we need to step over the breakpoint. */
5766 if (bs
->bp_location_at
->loc_type
!= bp_loc_other
)
5767 this_action
= BPSTAT_WHAT_SINGLE
;
5771 this_action
= BPSTAT_WHAT_SINGLE
;
5774 /* Make sure the action is stop (silent or noisy),
5775 so infrun.c pops the dummy frame. */
5776 retval
.call_dummy
= STOP_STACK_DUMMY
;
5777 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5779 case bp_std_terminate
:
5780 /* Make sure the action is stop (silent or noisy),
5781 so infrun.c pops the dummy frame. */
5782 retval
.call_dummy
= STOP_STD_TERMINATE
;
5783 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5786 case bp_fast_tracepoint
:
5787 case bp_static_tracepoint
:
5788 /* Tracepoint hits should not be reported back to GDB, and
5789 if one got through somehow, it should have been filtered
5791 internal_error (__FILE__
, __LINE__
,
5792 _("bpstat_what: tracepoint encountered"));
5794 case bp_gnu_ifunc_resolver
:
5795 /* Step over it (and insert bp_gnu_ifunc_resolver_return). */
5796 this_action
= BPSTAT_WHAT_SINGLE
;
5798 case bp_gnu_ifunc_resolver_return
:
5799 /* The breakpoint will be removed, execution will restart from the
5800 PC of the former breakpoint. */
5801 this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5806 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5808 this_action
= BPSTAT_WHAT_SINGLE
;
5812 internal_error (__FILE__
, __LINE__
,
5813 _("bpstat_what: unhandled bptype %d"), (int) bptype
);
5816 retval
.main_action
= std::max (retval
.main_action
, this_action
);
5823 bpstat_run_callbacks (bpstat bs_head
)
5827 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5829 struct breakpoint
*b
= bs
->breakpoint_at
;
5836 handle_jit_event (bs
->bp_location_at
->address
);
5838 case bp_gnu_ifunc_resolver
:
5839 gnu_ifunc_resolver_stop (b
);
5841 case bp_gnu_ifunc_resolver_return
:
5842 gnu_ifunc_resolver_return_stop (b
);
5848 /* See breakpoint.h. */
5851 bpstat_should_step ()
5853 struct breakpoint
*b
;
5856 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
&& b
->loc
!= NULL
)
5861 /* See breakpoint.h. */
5864 bpstat_causes_stop (bpstat bs
)
5866 for (; bs
!= NULL
; bs
= bs
->next
)
5875 /* Compute a string of spaces suitable to indent the next line
5876 so it starts at the position corresponding to the table column
5877 named COL_NAME in the currently active table of UIOUT. */
5880 wrap_indent_at_field (struct ui_out
*uiout
, const char *col_name
)
5882 static char wrap_indent
[80];
5883 int i
, total_width
, width
, align
;
5887 for (i
= 1; uiout
->query_table_field (i
, &width
, &align
, &text
); i
++)
5889 if (strcmp (text
, col_name
) == 0)
5891 gdb_assert (total_width
< sizeof wrap_indent
);
5892 memset (wrap_indent
, ' ', total_width
);
5893 wrap_indent
[total_width
] = 0;
5898 total_width
+= width
+ 1;
5904 /* Determine if the locations of this breakpoint will have their conditions
5905 evaluated by the target, host or a mix of both. Returns the following:
5907 "host": Host evals condition.
5908 "host or target": Host or Target evals condition.
5909 "target": Target evals condition.
5913 bp_condition_evaluator (struct breakpoint
*b
)
5915 struct bp_location
*bl
;
5916 char host_evals
= 0;
5917 char target_evals
= 0;
5922 if (!is_breakpoint (b
))
5925 if (gdb_evaluates_breakpoint_condition_p ()
5926 || !target_supports_evaluation_of_breakpoint_conditions ())
5927 return condition_evaluation_host
;
5929 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
5931 if (bl
->cond_bytecode
)
5937 if (host_evals
&& target_evals
)
5938 return condition_evaluation_both
;
5939 else if (target_evals
)
5940 return condition_evaluation_target
;
5942 return condition_evaluation_host
;
5945 /* Determine the breakpoint location's condition evaluator. This is
5946 similar to bp_condition_evaluator, but for locations. */
5949 bp_location_condition_evaluator (struct bp_location
*bl
)
5951 if (bl
&& !is_breakpoint (bl
->owner
))
5954 if (gdb_evaluates_breakpoint_condition_p ()
5955 || !target_supports_evaluation_of_breakpoint_conditions ())
5956 return condition_evaluation_host
;
5958 if (bl
&& bl
->cond_bytecode
)
5959 return condition_evaluation_target
;
5961 return condition_evaluation_host
;
5964 /* Print the LOC location out of the list of B->LOC locations. */
5967 print_breakpoint_location (struct breakpoint
*b
,
5968 struct bp_location
*loc
)
5970 struct ui_out
*uiout
= current_uiout
;
5972 scoped_restore_current_program_space restore_pspace
;
5974 if (loc
!= NULL
&& loc
->shlib_disabled
)
5978 set_current_program_space (loc
->pspace
);
5980 if (b
->display_canonical
)
5981 uiout
->field_string ("what", event_location_to_string (b
->location
.get ()));
5982 else if (loc
&& loc
->symtab
)
5984 const struct symbol
*sym
= loc
->symbol
;
5988 uiout
->text ("in ");
5989 uiout
->field_string ("func", sym
->print_name (),
5990 function_name_style
.style ());
5992 uiout
->wrap_hint (wrap_indent_at_field (uiout
, "what"));
5993 uiout
->text ("at ");
5995 uiout
->field_string ("file",
5996 symtab_to_filename_for_display (loc
->symtab
),
5997 file_name_style
.style ());
6000 if (uiout
->is_mi_like_p ())
6001 uiout
->field_string ("fullname", symtab_to_fullname (loc
->symtab
));
6003 uiout
->field_signed ("line", loc
->line_number
);
6009 print_address_symbolic (loc
->gdbarch
, loc
->address
, &stb
,
6011 uiout
->field_stream ("at", stb
);
6015 uiout
->field_string ("pending",
6016 event_location_to_string (b
->location
.get ()));
6017 /* If extra_string is available, it could be holding a condition
6018 or dprintf arguments. In either case, make sure it is printed,
6019 too, but only for non-MI streams. */
6020 if (!uiout
->is_mi_like_p () && b
->extra_string
!= NULL
)
6022 if (b
->type
== bp_dprintf
)
6026 uiout
->text (b
->extra_string
);
6030 if (loc
&& is_breakpoint (b
)
6031 && breakpoint_condition_evaluation_mode () == condition_evaluation_target
6032 && bp_condition_evaluator (b
) == condition_evaluation_both
)
6035 uiout
->field_string ("evaluated-by",
6036 bp_location_condition_evaluator (loc
));
6042 bptype_string (enum bptype type
)
6044 struct ep_type_description
6047 const char *description
;
6049 static struct ep_type_description bptypes
[] =
6051 {bp_none
, "?deleted?"},
6052 {bp_breakpoint
, "breakpoint"},
6053 {bp_hardware_breakpoint
, "hw breakpoint"},
6054 {bp_single_step
, "sw single-step"},
6055 {bp_until
, "until"},
6056 {bp_finish
, "finish"},
6057 {bp_watchpoint
, "watchpoint"},
6058 {bp_hardware_watchpoint
, "hw watchpoint"},
6059 {bp_read_watchpoint
, "read watchpoint"},
6060 {bp_access_watchpoint
, "acc watchpoint"},
6061 {bp_longjmp
, "longjmp"},
6062 {bp_longjmp_resume
, "longjmp resume"},
6063 {bp_longjmp_call_dummy
, "longjmp for call dummy"},
6064 {bp_exception
, "exception"},
6065 {bp_exception_resume
, "exception resume"},
6066 {bp_step_resume
, "step resume"},
6067 {bp_hp_step_resume
, "high-priority step resume"},
6068 {bp_watchpoint_scope
, "watchpoint scope"},
6069 {bp_call_dummy
, "call dummy"},
6070 {bp_std_terminate
, "std::terminate"},
6071 {bp_shlib_event
, "shlib events"},
6072 {bp_thread_event
, "thread events"},
6073 {bp_overlay_event
, "overlay events"},
6074 {bp_longjmp_master
, "longjmp master"},
6075 {bp_std_terminate_master
, "std::terminate master"},
6076 {bp_exception_master
, "exception master"},
6077 {bp_catchpoint
, "catchpoint"},
6078 {bp_tracepoint
, "tracepoint"},
6079 {bp_fast_tracepoint
, "fast tracepoint"},
6080 {bp_static_tracepoint
, "static tracepoint"},
6081 {bp_dprintf
, "dprintf"},
6082 {bp_jit_event
, "jit events"},
6083 {bp_gnu_ifunc_resolver
, "STT_GNU_IFUNC resolver"},
6084 {bp_gnu_ifunc_resolver_return
, "STT_GNU_IFUNC resolver return"},
6087 if (((int) type
>= (sizeof (bptypes
) / sizeof (bptypes
[0])))
6088 || ((int) type
!= bptypes
[(int) type
].type
))
6089 internal_error (__FILE__
, __LINE__
,
6090 _("bptypes table does not describe type #%d."),
6093 return bptypes
[(int) type
].description
;
6096 /* For MI, output a field named 'thread-groups' with a list as the value.
6097 For CLI, prefix the list with the string 'inf'. */
6100 output_thread_groups (struct ui_out
*uiout
,
6101 const char *field_name
,
6102 const std::vector
<int> &inf_nums
,
6105 int is_mi
= uiout
->is_mi_like_p ();
6107 /* For backward compatibility, don't display inferiors in CLI unless
6108 there are several. Always display them for MI. */
6109 if (!is_mi
&& mi_only
)
6112 ui_out_emit_list
list_emitter (uiout
, field_name
);
6114 for (size_t i
= 0; i
< inf_nums
.size (); i
++)
6120 xsnprintf (mi_group
, sizeof (mi_group
), "i%d", inf_nums
[i
]);
6121 uiout
->field_string (NULL
, mi_group
);
6126 uiout
->text (" inf ");
6130 uiout
->text (plongest (inf_nums
[i
]));
6135 /* Print B to gdb_stdout. If RAW_LOC, print raw breakpoint locations
6136 instead of going via breakpoint_ops::print_one. This makes "maint
6137 info breakpoints" show the software breakpoint locations of
6138 catchpoints, which are considered internal implementation
6142 print_one_breakpoint_location (struct breakpoint
*b
,
6143 struct bp_location
*loc
,
6145 struct bp_location
**last_loc
,
6146 int allflag
, bool raw_loc
)
6148 struct command_line
*l
;
6149 static char bpenables
[] = "nynny";
6151 struct ui_out
*uiout
= current_uiout
;
6152 int header_of_multiple
= 0;
6153 int part_of_multiple
= (loc
!= NULL
);
6154 struct value_print_options opts
;
6156 get_user_print_options (&opts
);
6158 gdb_assert (!loc
|| loc_number
!= 0);
6159 /* See comment in print_one_breakpoint concerning treatment of
6160 breakpoints with single disabled location. */
6163 && (b
->loc
->next
!= NULL
6164 || !b
->loc
->enabled
|| b
->loc
->disabled_by_cond
)))
6165 header_of_multiple
= 1;
6173 if (part_of_multiple
)
6174 uiout
->field_fmt ("number", "%d.%d", b
->number
, loc_number
);
6176 uiout
->field_signed ("number", b
->number
);
6180 if (part_of_multiple
)
6181 uiout
->field_skip ("type");
6183 uiout
->field_string ("type", bptype_string (b
->type
));
6187 if (part_of_multiple
)
6188 uiout
->field_skip ("disp");
6190 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
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
->loc
; loc
!= NULL
; loc
= loc
->next
, ++n
)
6511 ui_out_emit_tuple
loc_tuple_emitter (uiout
, NULL
);
6512 print_one_breakpoint_location (b
, loc
, n
, last_loc
,
6520 breakpoint_address_bits (struct breakpoint
*b
)
6522 int print_address_bits
= 0;
6523 struct bp_location
*loc
;
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 (loc
= b
->loc
; loc
; loc
= loc
->next
)
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 breakpoint
*b
;
6586 struct bp_location
*last_loc
= NULL
;
6587 int nr_printable_breakpoints
;
6588 struct value_print_options opts
;
6589 int print_address_bits
= 0;
6590 int print_type_col_width
= 14;
6591 struct ui_out
*uiout
= current_uiout
;
6592 bool has_disabled_by_cond_location
= false;
6594 get_user_print_options (&opts
);
6596 /* Compute the number of rows in the table, as well as the size
6597 required for address fields. */
6598 nr_printable_breakpoints
= 0;
6601 /* If we have a filter, only list the breakpoints it accepts. */
6602 if (filter
&& !filter (b
))
6605 /* If we have a BP_NUM_LIST string, it is a list of breakpoints to
6606 accept. Skip the others. */
6607 if (bp_num_list
!= NULL
&& *bp_num_list
!= '\0')
6609 if (show_internal
&& parse_and_eval_long (bp_num_list
) != b
->number
)
6611 if (!show_internal
&& !number_is_in_list (bp_num_list
, b
->number
))
6615 if (show_internal
|| user_breakpoint_p (b
))
6617 int addr_bit
, type_len
;
6619 addr_bit
= breakpoint_address_bits (b
);
6620 if (addr_bit
> print_address_bits
)
6621 print_address_bits
= addr_bit
;
6623 type_len
= strlen (bptype_string (b
->type
));
6624 if (type_len
> print_type_col_width
)
6625 print_type_col_width
= type_len
;
6627 nr_printable_breakpoints
++;
6632 ui_out_emit_table
table_emitter (uiout
,
6633 opts
.addressprint
? 6 : 5,
6634 nr_printable_breakpoints
,
6637 if (nr_printable_breakpoints
> 0)
6638 annotate_breakpoints_headers ();
6639 if (nr_printable_breakpoints
> 0)
6641 uiout
->table_header (7, ui_left
, "number", "Num"); /* 1 */
6642 if (nr_printable_breakpoints
> 0)
6644 uiout
->table_header (print_type_col_width
, ui_left
, "type", "Type"); /* 2 */
6645 if (nr_printable_breakpoints
> 0)
6647 uiout
->table_header (4, ui_left
, "disp", "Disp"); /* 3 */
6648 if (nr_printable_breakpoints
> 0)
6650 uiout
->table_header (3, ui_left
, "enabled", "Enb"); /* 4 */
6651 if (opts
.addressprint
)
6653 if (nr_printable_breakpoints
> 0)
6655 if (print_address_bits
<= 32)
6656 uiout
->table_header (10, ui_left
, "addr", "Address"); /* 5 */
6658 uiout
->table_header (18, ui_left
, "addr", "Address"); /* 5 */
6660 if (nr_printable_breakpoints
> 0)
6662 uiout
->table_header (40, ui_noalign
, "what", "What"); /* 6 */
6663 uiout
->table_body ();
6664 if (nr_printable_breakpoints
> 0)
6665 annotate_breakpoints_table ();
6670 /* If we have a filter, only list the breakpoints it accepts. */
6671 if (filter
&& !filter (b
))
6674 /* If we have a BP_NUM_LIST string, it is a list of breakpoints to
6675 accept. Skip the others. */
6677 if (bp_num_list
!= NULL
&& *bp_num_list
!= '\0')
6679 if (show_internal
) /* maintenance info breakpoint */
6681 if (parse_and_eval_long (bp_num_list
) != b
->number
)
6684 else /* all others */
6686 if (!number_is_in_list (bp_num_list
, b
->number
))
6690 /* We only print out user settable breakpoints unless the
6691 show_internal is set. */
6692 if (show_internal
|| user_breakpoint_p (b
))
6694 print_one_breakpoint (b
, &last_loc
, show_internal
);
6695 for (bp_location
*loc
= b
->loc
; loc
!= NULL
; loc
= loc
->next
)
6696 if (loc
->disabled_by_cond
)
6697 has_disabled_by_cond_location
= true;
6702 if (nr_printable_breakpoints
== 0)
6704 /* If there's a filter, let the caller decide how to report
6708 if (bp_num_list
== NULL
|| *bp_num_list
== '\0')
6709 uiout
->message ("No breakpoints or watchpoints.\n");
6711 uiout
->message ("No breakpoint or watchpoint matching '%s'.\n",
6717 if (last_loc
&& !server_command
)
6718 set_next_address (last_loc
->gdbarch
, last_loc
->address
);
6720 if (has_disabled_by_cond_location
)
6721 uiout
->message (_("(*): Breakpoint condition is invalid at this "
6725 /* FIXME? Should this be moved up so that it is only called when
6726 there have been breakpoints? */
6727 annotate_breakpoints_table_end ();
6729 return nr_printable_breakpoints
;
6732 /* Display the value of default-collect in a way that is generally
6733 compatible with the breakpoint list. */
6736 default_collect_info (void)
6738 struct ui_out
*uiout
= current_uiout
;
6740 /* If it has no value (which is frequently the case), say nothing; a
6741 message like "No default-collect." gets in user's face when it's
6743 if (!*default_collect
)
6746 /* The following phrase lines up nicely with per-tracepoint collect
6748 uiout
->text ("default collect ");
6749 uiout
->field_string ("default-collect", default_collect
);
6750 uiout
->text (" \n");
6754 info_breakpoints_command (const char *args
, int from_tty
)
6756 breakpoint_1 (args
, false, NULL
);
6758 default_collect_info ();
6762 info_watchpoints_command (const char *args
, int from_tty
)
6764 int num_printed
= breakpoint_1 (args
, false, is_watchpoint
);
6765 struct ui_out
*uiout
= current_uiout
;
6767 if (num_printed
== 0)
6769 if (args
== NULL
|| *args
== '\0')
6770 uiout
->message ("No watchpoints.\n");
6772 uiout
->message ("No watchpoint matching '%s'.\n", args
);
6777 maintenance_info_breakpoints (const char *args
, int from_tty
)
6779 breakpoint_1 (args
, true, NULL
);
6781 default_collect_info ();
6785 breakpoint_has_pc (struct breakpoint
*b
,
6786 struct program_space
*pspace
,
6787 CORE_ADDR pc
, struct obj_section
*section
)
6789 struct bp_location
*bl
= b
->loc
;
6791 for (; bl
; bl
= bl
->next
)
6793 if (bl
->pspace
== pspace
6794 && bl
->address
== pc
6795 && (!overlay_debugging
|| bl
->section
== section
))
6801 /* Print a message describing any user-breakpoints set at PC. This
6802 concerns with logical breakpoints, so we match program spaces, not
6806 describe_other_breakpoints (struct gdbarch
*gdbarch
,
6807 struct program_space
*pspace
, CORE_ADDR pc
,
6808 struct obj_section
*section
, int thread
)
6811 struct breakpoint
*b
;
6814 others
+= (user_breakpoint_p (b
)
6815 && breakpoint_has_pc (b
, pspace
, pc
, section
));
6819 printf_filtered (_("Note: breakpoint "));
6820 else /* if (others == ???) */
6821 printf_filtered (_("Note: breakpoints "));
6823 if (user_breakpoint_p (b
) && breakpoint_has_pc (b
, pspace
, pc
, section
))
6826 printf_filtered ("%d", b
->number
);
6827 if (b
->thread
== -1 && thread
!= -1)
6828 printf_filtered (" (all threads)");
6829 else if (b
->thread
!= -1)
6830 printf_filtered (" (thread %d)", b
->thread
);
6831 printf_filtered ("%s%s ",
6832 ((b
->enable_state
== bp_disabled
6833 || b
->enable_state
== bp_call_disabled
)
6837 : ((others
== 1) ? " and" : ""));
6839 current_uiout
->message (_("also set at pc %ps.\n"),
6840 styled_string (address_style
.style (),
6841 paddress (gdbarch
, pc
)));
6846 /* Return true iff it is meaningful to use the address member of LOC.
6847 For some breakpoint types, the locations' address members are
6848 irrelevant and it makes no sense to attempt to compare them to
6849 other addresses (or use them for any other purpose either).
6851 More specifically, software watchpoints and catchpoints that are
6852 not backed by breakpoints always have a zero valued location
6853 address and we don't want to mark breakpoints of any of these types
6854 to be a duplicate of an actual breakpoint location at address
6858 bl_address_is_meaningful (bp_location
*loc
)
6860 return loc
->loc_type
!= bp_loc_other
;
6863 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
6864 true if LOC1 and LOC2 represent the same watchpoint location. */
6867 watchpoint_locations_match (struct bp_location
*loc1
,
6868 struct bp_location
*loc2
)
6870 struct watchpoint
*w1
= (struct watchpoint
*) loc1
->owner
;
6871 struct watchpoint
*w2
= (struct watchpoint
*) loc2
->owner
;
6873 /* Both of them must exist. */
6874 gdb_assert (w1
!= NULL
);
6875 gdb_assert (w2
!= NULL
);
6877 /* If the target can evaluate the condition expression in hardware,
6878 then we we need to insert both watchpoints even if they are at
6879 the same place. Otherwise the watchpoint will only trigger when
6880 the condition of whichever watchpoint was inserted evaluates to
6881 true, not giving a chance for GDB to check the condition of the
6882 other watchpoint. */
6884 && target_can_accel_watchpoint_condition (loc1
->address
,
6886 loc1
->watchpoint_type
,
6887 w1
->cond_exp
.get ()))
6889 && target_can_accel_watchpoint_condition (loc2
->address
,
6891 loc2
->watchpoint_type
,
6892 w2
->cond_exp
.get ())))
6895 /* Note that this checks the owner's type, not the location's. In
6896 case the target does not support read watchpoints, but does
6897 support access watchpoints, we'll have bp_read_watchpoint
6898 watchpoints with hw_access locations. Those should be considered
6899 duplicates of hw_read locations. The hw_read locations will
6900 become hw_access locations later. */
6901 return (loc1
->owner
->type
== loc2
->owner
->type
6902 && loc1
->pspace
->aspace
== loc2
->pspace
->aspace
6903 && loc1
->address
== loc2
->address
6904 && loc1
->length
== loc2
->length
);
6907 /* See breakpoint.h. */
6910 breakpoint_address_match (const address_space
*aspace1
, CORE_ADDR addr1
,
6911 const address_space
*aspace2
, CORE_ADDR addr2
)
6913 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
6914 || aspace1
== aspace2
)
6918 /* Returns true if {ASPACE2,ADDR2} falls within the range determined by
6919 {ASPACE1,ADDR1,LEN1}. In most targets, this can only be true if ASPACE1
6920 matches ASPACE2. On targets that have global breakpoints, the address
6921 space doesn't really matter. */
6924 breakpoint_address_match_range (const address_space
*aspace1
,
6926 int len1
, const address_space
*aspace2
,
6929 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
6930 || aspace1
== aspace2
)
6931 && addr2
>= addr1
&& addr2
< addr1
+ len1
);
6934 /* Returns true if {ASPACE,ADDR} matches the breakpoint BL. BL may be
6935 a ranged breakpoint. In most targets, a match happens only if ASPACE
6936 matches the breakpoint's address space. On targets that have global
6937 breakpoints, the address space doesn't really matter. */
6940 breakpoint_location_address_match (struct bp_location
*bl
,
6941 const address_space
*aspace
,
6944 return (breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
6947 && breakpoint_address_match_range (bl
->pspace
->aspace
,
6948 bl
->address
, bl
->length
,
6952 /* Returns true if the [ADDR,ADDR+LEN) range in ASPACE overlaps
6953 breakpoint BL. BL may be a ranged breakpoint. In most targets, a
6954 match happens only if ASPACE matches the breakpoint's address
6955 space. On targets that have global breakpoints, the address space
6956 doesn't really matter. */
6959 breakpoint_location_address_range_overlap (struct bp_location
*bl
,
6960 const address_space
*aspace
,
6961 CORE_ADDR addr
, int len
)
6963 if (gdbarch_has_global_breakpoints (target_gdbarch ())
6964 || bl
->pspace
->aspace
== aspace
)
6966 int bl_len
= bl
->length
!= 0 ? bl
->length
: 1;
6968 if (mem_ranges_overlap (addr
, len
, bl
->address
, bl_len
))
6974 /* If LOC1 and LOC2's owners are not tracepoints, returns false directly.
6975 Then, if LOC1 and LOC2 represent the same tracepoint location, returns
6976 true, otherwise returns false. */
6979 tracepoint_locations_match (struct bp_location
*loc1
,
6980 struct bp_location
*loc2
)
6982 if (is_tracepoint (loc1
->owner
) && is_tracepoint (loc2
->owner
))
6983 /* Since tracepoint locations are never duplicated with others', tracepoint
6984 locations at the same address of different tracepoints are regarded as
6985 different locations. */
6986 return (loc1
->address
== loc2
->address
&& loc1
->owner
== loc2
->owner
);
6991 /* Assuming LOC1 and LOC2's types' have meaningful target addresses
6992 (bl_address_is_meaningful), returns true if LOC1 and LOC2 represent
6993 the same location. If SW_HW_BPS_MATCH is true, then software
6994 breakpoint locations and hardware breakpoint locations match,
6995 otherwise they don't. */
6998 breakpoint_locations_match (struct bp_location
*loc1
,
6999 struct bp_location
*loc2
,
7000 bool sw_hw_bps_match
)
7002 int hw_point1
, hw_point2
;
7004 /* Both of them must not be in moribund_locations. */
7005 gdb_assert (loc1
->owner
!= NULL
);
7006 gdb_assert (loc2
->owner
!= NULL
);
7008 hw_point1
= is_hardware_watchpoint (loc1
->owner
);
7009 hw_point2
= is_hardware_watchpoint (loc2
->owner
);
7011 if (hw_point1
!= hw_point2
)
7014 return watchpoint_locations_match (loc1
, loc2
);
7015 else if (is_tracepoint (loc1
->owner
) || is_tracepoint (loc2
->owner
))
7016 return tracepoint_locations_match (loc1
, loc2
);
7018 /* We compare bp_location.length in order to cover ranged
7019 breakpoints. Keep this in sync with
7020 bp_location_is_less_than. */
7021 return (breakpoint_address_match (loc1
->pspace
->aspace
, loc1
->address
,
7022 loc2
->pspace
->aspace
, loc2
->address
)
7023 && (loc1
->loc_type
== loc2
->loc_type
|| sw_hw_bps_match
)
7024 && loc1
->length
== loc2
->length
);
7028 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
7029 int bnum
, int have_bnum
)
7031 /* The longest string possibly returned by hex_string_custom
7032 is 50 chars. These must be at least that big for safety. */
7036 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
7037 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
7039 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
7040 bnum
, astr1
, astr2
);
7042 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
7045 /* Adjust a breakpoint's address to account for architectural
7046 constraints on breakpoint placement. Return the adjusted address.
7047 Note: Very few targets require this kind of adjustment. For most
7048 targets, this function is simply the identity function. */
7051 adjust_breakpoint_address (struct gdbarch
*gdbarch
,
7052 CORE_ADDR bpaddr
, enum bptype bptype
)
7054 if (bptype
== bp_watchpoint
7055 || bptype
== bp_hardware_watchpoint
7056 || bptype
== bp_read_watchpoint
7057 || bptype
== bp_access_watchpoint
7058 || bptype
== bp_catchpoint
)
7060 /* Watchpoints and the various bp_catch_* eventpoints should not
7061 have their addresses modified. */
7064 else if (bptype
== bp_single_step
)
7066 /* Single-step breakpoints should not have their addresses
7067 modified. If there's any architectural constrain that
7068 applies to this address, then it should have already been
7069 taken into account when the breakpoint was created in the
7070 first place. If we didn't do this, stepping through e.g.,
7071 Thumb-2 IT blocks would break. */
7076 CORE_ADDR adjusted_bpaddr
= bpaddr
;
7078 if (gdbarch_adjust_breakpoint_address_p (gdbarch
))
7080 /* Some targets have architectural constraints on the placement
7081 of breakpoint instructions. Obtain the adjusted address. */
7082 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (gdbarch
, bpaddr
);
7085 adjusted_bpaddr
= address_significant (gdbarch
, adjusted_bpaddr
);
7087 /* An adjusted breakpoint address can significantly alter
7088 a user's expectations. Print a warning if an adjustment
7090 if (adjusted_bpaddr
!= bpaddr
)
7091 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
7093 return adjusted_bpaddr
;
7098 bp_location_from_bp_type (bptype type
)
7103 case bp_single_step
:
7107 case bp_longjmp_resume
:
7108 case bp_longjmp_call_dummy
:
7110 case bp_exception_resume
:
7111 case bp_step_resume
:
7112 case bp_hp_step_resume
:
7113 case bp_watchpoint_scope
:
7115 case bp_std_terminate
:
7116 case bp_shlib_event
:
7117 case bp_thread_event
:
7118 case bp_overlay_event
:
7120 case bp_longjmp_master
:
7121 case bp_std_terminate_master
:
7122 case bp_exception_master
:
7123 case bp_gnu_ifunc_resolver
:
7124 case bp_gnu_ifunc_resolver_return
:
7126 return bp_loc_software_breakpoint
;
7127 case bp_hardware_breakpoint
:
7128 return bp_loc_hardware_breakpoint
;
7129 case bp_hardware_watchpoint
:
7130 case bp_read_watchpoint
:
7131 case bp_access_watchpoint
:
7132 return bp_loc_hardware_watchpoint
;
7136 case bp_fast_tracepoint
:
7137 case bp_static_tracepoint
:
7138 return bp_loc_other
;
7140 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
7144 bp_location::bp_location (breakpoint
*owner
, bp_loc_type type
)
7146 this->owner
= owner
;
7147 this->cond_bytecode
= NULL
;
7148 this->shlib_disabled
= 0;
7150 this->disabled_by_cond
= false;
7152 this->loc_type
= type
;
7154 if (this->loc_type
== bp_loc_software_breakpoint
7155 || this->loc_type
== bp_loc_hardware_breakpoint
)
7156 mark_breakpoint_location_modified (this);
7161 bp_location::bp_location (breakpoint
*owner
)
7162 : bp_location::bp_location (owner
,
7163 bp_location_from_bp_type (owner
->type
))
7167 /* Allocate a struct bp_location. */
7169 static struct bp_location
*
7170 allocate_bp_location (struct breakpoint
*bpt
)
7172 return bpt
->ops
->allocate_location (bpt
);
7175 /* Decrement reference count. If the reference count reaches 0,
7176 destroy the bp_location. Sets *BLP to NULL. */
7179 decref_bp_location (struct bp_location
**blp
)
7181 bp_location_ref_policy::decref (*blp
);
7185 /* Add breakpoint B at the end of the global breakpoint chain. */
7188 add_to_breakpoint_chain (std::unique_ptr
<breakpoint
> &&b
)
7190 struct breakpoint
*b1
;
7191 struct breakpoint
*result
= b
.get ();
7193 /* Add this breakpoint to the end of the chain so that a list of
7194 breakpoints will come out in order of increasing numbers. */
7196 b1
= breakpoint_chain
;
7198 breakpoint_chain
= b
.release ();
7203 b1
->next
= b
.release ();
7209 /* Initializes breakpoint B with type BPTYPE and no locations yet. */
7212 init_raw_breakpoint_without_location (struct breakpoint
*b
,
7213 struct gdbarch
*gdbarch
,
7215 const struct breakpoint_ops
*ops
)
7217 gdb_assert (ops
!= NULL
);
7221 b
->gdbarch
= gdbarch
;
7222 b
->language
= current_language
->la_language
;
7223 b
->input_radix
= input_radix
;
7224 b
->related_breakpoint
= b
;
7227 /* Helper to set_raw_breakpoint below. Creates a breakpoint
7228 that has type BPTYPE and has no locations as yet. */
7230 static struct breakpoint
*
7231 set_raw_breakpoint_without_location (struct gdbarch
*gdbarch
,
7233 const struct breakpoint_ops
*ops
)
7235 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (bptype
);
7237 init_raw_breakpoint_without_location (b
.get (), gdbarch
, bptype
, ops
);
7238 return add_to_breakpoint_chain (std::move (b
));
7241 /* Initialize loc->function_name. */
7244 set_breakpoint_location_function (struct bp_location
*loc
)
7246 gdb_assert (loc
->owner
!= NULL
);
7248 if (loc
->owner
->type
== bp_breakpoint
7249 || loc
->owner
->type
== bp_hardware_breakpoint
7250 || is_tracepoint (loc
->owner
))
7252 const char *function_name
;
7254 if (loc
->msymbol
!= NULL
7255 && (MSYMBOL_TYPE (loc
->msymbol
) == mst_text_gnu_ifunc
7256 || MSYMBOL_TYPE (loc
->msymbol
) == mst_data_gnu_ifunc
))
7258 struct breakpoint
*b
= loc
->owner
;
7260 function_name
= loc
->msymbol
->linkage_name ();
7262 if (b
->type
== bp_breakpoint
&& b
->loc
== loc
7263 && loc
->next
== NULL
&& b
->related_breakpoint
== b
)
7265 /* Create only the whole new breakpoint of this type but do not
7266 mess more complicated breakpoints with multiple locations. */
7267 b
->type
= bp_gnu_ifunc_resolver
;
7268 /* Remember the resolver's address for use by the return
7270 loc
->related_address
= loc
->address
;
7274 find_pc_partial_function (loc
->address
, &function_name
, NULL
, NULL
);
7277 loc
->function_name
= xstrdup (function_name
);
7281 /* Attempt to determine architecture of location identified by SAL. */
7283 get_sal_arch (struct symtab_and_line sal
)
7286 return sal
.section
->objfile
->arch ();
7288 return SYMTAB_OBJFILE (sal
.symtab
)->arch ();
7293 /* Low level routine for partially initializing a breakpoint of type
7294 BPTYPE. The newly created breakpoint's address, section, source
7295 file name, and line number are provided by SAL.
7297 It is expected that the caller will complete the initialization of
7298 the newly created breakpoint struct as well as output any status
7299 information regarding the creation of a new breakpoint. */
7302 init_raw_breakpoint (struct breakpoint
*b
, struct gdbarch
*gdbarch
,
7303 struct symtab_and_line sal
, enum bptype bptype
,
7304 const struct breakpoint_ops
*ops
)
7306 init_raw_breakpoint_without_location (b
, gdbarch
, bptype
, ops
);
7308 add_location_to_breakpoint (b
, &sal
);
7310 if (bptype
!= bp_catchpoint
)
7311 gdb_assert (sal
.pspace
!= NULL
);
7313 /* Store the program space that was used to set the breakpoint,
7314 except for ordinary breakpoints, which are independent of the
7316 if (bptype
!= bp_breakpoint
&& bptype
!= bp_hardware_breakpoint
)
7317 b
->pspace
= sal
.pspace
;
7320 /* set_raw_breakpoint is a low level routine for allocating and
7321 partially initializing a breakpoint of type BPTYPE. The newly
7322 created breakpoint's address, section, source file name, and line
7323 number are provided by SAL. The newly created and partially
7324 initialized breakpoint is added to the breakpoint chain and
7325 is also returned as the value of this function.
7327 It is expected that the caller will complete the initialization of
7328 the newly created breakpoint struct as well as output any status
7329 information regarding the creation of a new breakpoint. In
7330 particular, set_raw_breakpoint does NOT set the breakpoint
7331 number! Care should be taken to not allow an error to occur
7332 prior to completing the initialization of the breakpoint. If this
7333 should happen, a bogus breakpoint will be left on the chain. */
7336 set_raw_breakpoint (struct gdbarch
*gdbarch
,
7337 struct symtab_and_line sal
, enum bptype bptype
,
7338 const struct breakpoint_ops
*ops
)
7340 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (bptype
);
7342 init_raw_breakpoint (b
.get (), gdbarch
, sal
, bptype
, ops
);
7343 return add_to_breakpoint_chain (std::move (b
));
7346 /* Call this routine when stepping and nexting to enable a breakpoint
7347 if we do a longjmp() or 'throw' in TP. FRAME is the frame which
7348 initiated the operation. */
7351 set_longjmp_breakpoint (struct thread_info
*tp
, struct frame_id frame
)
7353 struct breakpoint
*b
, *b_tmp
;
7354 int thread
= tp
->global_num
;
7356 /* To avoid having to rescan all objfile symbols at every step,
7357 we maintain a list of continually-inserted but always disabled
7358 longjmp "master" breakpoints. Here, we simply create momentary
7359 clones of those and enable them for the requested thread. */
7360 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7361 if (b
->pspace
== current_program_space
7362 && (b
->type
== bp_longjmp_master
7363 || b
->type
== bp_exception_master
))
7365 enum bptype type
= b
->type
== bp_longjmp_master
? bp_longjmp
: bp_exception
;
7366 struct breakpoint
*clone
;
7368 /* longjmp_breakpoint_ops ensures INITIATING_FRAME is cleared again
7369 after their removal. */
7370 clone
= momentary_breakpoint_from_master (b
, type
,
7371 &momentary_breakpoint_ops
, 1);
7372 clone
->thread
= thread
;
7375 tp
->initiating_frame
= frame
;
7378 /* Delete all longjmp breakpoints from THREAD. */
7380 delete_longjmp_breakpoint (int thread
)
7382 struct breakpoint
*b
, *b_tmp
;
7384 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7385 if (b
->type
== bp_longjmp
|| b
->type
== bp_exception
)
7387 if (b
->thread
== thread
)
7388 delete_breakpoint (b
);
7393 delete_longjmp_breakpoint_at_next_stop (int thread
)
7395 struct breakpoint
*b
, *b_tmp
;
7397 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7398 if (b
->type
== bp_longjmp
|| b
->type
== bp_exception
)
7400 if (b
->thread
== thread
)
7401 b
->disposition
= disp_del_at_next_stop
;
7405 /* Place breakpoints of type bp_longjmp_call_dummy to catch longjmp for
7406 INFERIOR_PTID thread. Chain them all by RELATED_BREAKPOINT and return
7407 pointer to any of them. Return NULL if this system cannot place longjmp
7411 set_longjmp_breakpoint_for_call_dummy (void)
7413 struct breakpoint
*b
, *retval
= NULL
;
7416 if (b
->pspace
== current_program_space
&& b
->type
== bp_longjmp_master
)
7418 struct breakpoint
*new_b
;
7420 new_b
= momentary_breakpoint_from_master (b
, bp_longjmp_call_dummy
,
7421 &momentary_breakpoint_ops
,
7423 new_b
->thread
= inferior_thread ()->global_num
;
7425 /* Link NEW_B into the chain of RETVAL breakpoints. */
7427 gdb_assert (new_b
->related_breakpoint
== new_b
);
7430 new_b
->related_breakpoint
= retval
;
7431 while (retval
->related_breakpoint
!= new_b
->related_breakpoint
)
7432 retval
= retval
->related_breakpoint
;
7433 retval
->related_breakpoint
= new_b
;
7439 /* Verify all existing dummy frames and their associated breakpoints for
7440 TP. Remove those which can no longer be found in the current frame
7443 You should call this function only at places where it is safe to currently
7444 unwind the whole stack. Failed stack unwind would discard live dummy
7448 check_longjmp_breakpoint_for_call_dummy (struct thread_info
*tp
)
7450 struct breakpoint
*b
, *b_tmp
;
7452 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7453 if (b
->type
== bp_longjmp_call_dummy
&& b
->thread
== tp
->global_num
)
7455 struct breakpoint
*dummy_b
= b
->related_breakpoint
;
7457 while (dummy_b
!= b
&& dummy_b
->type
!= bp_call_dummy
)
7458 dummy_b
= dummy_b
->related_breakpoint
;
7459 if (dummy_b
->type
!= bp_call_dummy
7460 || frame_find_by_id (dummy_b
->frame_id
) != NULL
)
7463 dummy_frame_discard (dummy_b
->frame_id
, tp
);
7465 while (b
->related_breakpoint
!= b
)
7467 if (b_tmp
== b
->related_breakpoint
)
7468 b_tmp
= b
->related_breakpoint
->next
;
7469 delete_breakpoint (b
->related_breakpoint
);
7471 delete_breakpoint (b
);
7476 enable_overlay_breakpoints (void)
7478 struct breakpoint
*b
;
7481 if (b
->type
== bp_overlay_event
)
7483 b
->enable_state
= bp_enabled
;
7484 update_global_location_list (UGLL_MAY_INSERT
);
7485 overlay_events_enabled
= 1;
7490 disable_overlay_breakpoints (void)
7492 struct breakpoint
*b
;
7495 if (b
->type
== bp_overlay_event
)
7497 b
->enable_state
= bp_disabled
;
7498 update_global_location_list (UGLL_DONT_INSERT
);
7499 overlay_events_enabled
= 0;
7503 /* Set an active std::terminate breakpoint for each std::terminate
7504 master breakpoint. */
7506 set_std_terminate_breakpoint (void)
7508 struct breakpoint
*b
, *b_tmp
;
7510 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7511 if (b
->pspace
== current_program_space
7512 && b
->type
== bp_std_terminate_master
)
7514 momentary_breakpoint_from_master (b
, bp_std_terminate
,
7515 &momentary_breakpoint_ops
, 1);
7519 /* Delete all the std::terminate breakpoints. */
7521 delete_std_terminate_breakpoint (void)
7523 struct breakpoint
*b
, *b_tmp
;
7525 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7526 if (b
->type
== bp_std_terminate
)
7527 delete_breakpoint (b
);
7531 create_thread_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7533 struct breakpoint
*b
;
7535 b
= create_internal_breakpoint (gdbarch
, address
, bp_thread_event
,
7536 &internal_breakpoint_ops
);
7538 b
->enable_state
= bp_enabled
;
7539 /* location has to be used or breakpoint_re_set will delete me. */
7540 b
->location
= new_address_location (b
->loc
->address
, NULL
, 0);
7542 update_global_location_list_nothrow (UGLL_MAY_INSERT
);
7547 struct lang_and_radix
7553 /* Create a breakpoint for JIT code registration and unregistration. */
7556 create_jit_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7558 return create_internal_breakpoint (gdbarch
, address
, bp_jit_event
,
7559 &internal_breakpoint_ops
);
7562 /* Remove JIT code registration and unregistration breakpoint(s). */
7565 remove_jit_event_breakpoints (void)
7567 struct breakpoint
*b
, *b_tmp
;
7569 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7570 if (b
->type
== bp_jit_event
7571 && b
->loc
->pspace
== current_program_space
)
7572 delete_breakpoint (b
);
7576 remove_solib_event_breakpoints (void)
7578 struct breakpoint
*b
, *b_tmp
;
7580 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7581 if (b
->type
== bp_shlib_event
7582 && b
->loc
->pspace
== current_program_space
)
7583 delete_breakpoint (b
);
7586 /* See breakpoint.h. */
7589 remove_solib_event_breakpoints_at_next_stop (void)
7591 struct breakpoint
*b
, *b_tmp
;
7593 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7594 if (b
->type
== bp_shlib_event
7595 && b
->loc
->pspace
== current_program_space
)
7596 b
->disposition
= disp_del_at_next_stop
;
7599 /* Helper for create_solib_event_breakpoint /
7600 create_and_insert_solib_event_breakpoint. Allows specifying which
7601 INSERT_MODE to pass through to update_global_location_list. */
7603 static struct breakpoint
*
7604 create_solib_event_breakpoint_1 (struct gdbarch
*gdbarch
, CORE_ADDR address
,
7605 enum ugll_insert_mode insert_mode
)
7607 struct breakpoint
*b
;
7609 b
= create_internal_breakpoint (gdbarch
, address
, bp_shlib_event
,
7610 &internal_breakpoint_ops
);
7611 update_global_location_list_nothrow (insert_mode
);
7616 create_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7618 return create_solib_event_breakpoint_1 (gdbarch
, address
, UGLL_MAY_INSERT
);
7621 /* See breakpoint.h. */
7624 create_and_insert_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7626 struct breakpoint
*b
;
7628 /* Explicitly tell update_global_location_list to insert
7630 b
= create_solib_event_breakpoint_1 (gdbarch
, address
, UGLL_INSERT
);
7631 if (!b
->loc
->inserted
)
7633 delete_breakpoint (b
);
7639 /* Disable any breakpoints that are on code in shared libraries. Only
7640 apply to enabled breakpoints, disabled ones can just stay disabled. */
7643 disable_breakpoints_in_shlibs (void)
7645 struct bp_location
*loc
, **locp_tmp
;
7647 ALL_BP_LOCATIONS (loc
, locp_tmp
)
7649 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7650 struct breakpoint
*b
= loc
->owner
;
7652 /* We apply the check to all breakpoints, including disabled for
7653 those with loc->duplicate set. This is so that when breakpoint
7654 becomes enabled, or the duplicate is removed, gdb will try to
7655 insert all breakpoints. If we don't set shlib_disabled here,
7656 we'll try to insert those breakpoints and fail. */
7657 if (((b
->type
== bp_breakpoint
)
7658 || (b
->type
== bp_jit_event
)
7659 || (b
->type
== bp_hardware_breakpoint
)
7660 || (is_tracepoint (b
)))
7661 && loc
->pspace
== current_program_space
7662 && !loc
->shlib_disabled
7663 && solib_name_from_address (loc
->pspace
, loc
->address
)
7666 loc
->shlib_disabled
= 1;
7671 /* Disable any breakpoints and tracepoints that are in SOLIB upon
7672 notification of unloaded_shlib. Only apply to enabled breakpoints,
7673 disabled ones can just stay disabled. */
7676 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
7678 struct bp_location
*loc
, **locp_tmp
;
7679 int disabled_shlib_breaks
= 0;
7681 ALL_BP_LOCATIONS (loc
, locp_tmp
)
7683 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7684 struct breakpoint
*b
= loc
->owner
;
7686 if (solib
->pspace
== loc
->pspace
7687 && !loc
->shlib_disabled
7688 && (((b
->type
== bp_breakpoint
7689 || b
->type
== bp_jit_event
7690 || b
->type
== bp_hardware_breakpoint
)
7691 && (loc
->loc_type
== bp_loc_hardware_breakpoint
7692 || loc
->loc_type
== bp_loc_software_breakpoint
))
7693 || is_tracepoint (b
))
7694 && solib_contains_address_p (solib
, loc
->address
))
7696 loc
->shlib_disabled
= 1;
7697 /* At this point, we cannot rely on remove_breakpoint
7698 succeeding so we must mark the breakpoint as not inserted
7699 to prevent future errors occurring in remove_breakpoints. */
7702 /* This may cause duplicate notifications for the same breakpoint. */
7703 gdb::observers::breakpoint_modified
.notify (b
);
7705 if (!disabled_shlib_breaks
)
7707 target_terminal::ours_for_output ();
7708 warning (_("Temporarily disabling breakpoints "
7709 "for unloaded shared library \"%s\""),
7712 disabled_shlib_breaks
= 1;
7717 /* Disable any breakpoints and tracepoints in OBJFILE upon
7718 notification of free_objfile. Only apply to enabled breakpoints,
7719 disabled ones can just stay disabled. */
7722 disable_breakpoints_in_freed_objfile (struct objfile
*objfile
)
7724 struct breakpoint
*b
;
7726 if (objfile
== NULL
)
7729 /* OBJF_SHARED|OBJF_USERLOADED objfiles are dynamic modules manually
7730 managed by the user with add-symbol-file/remove-symbol-file.
7731 Similarly to how breakpoints in shared libraries are handled in
7732 response to "nosharedlibrary", mark breakpoints in such modules
7733 shlib_disabled so they end up uninserted on the next global
7734 location list update. Shared libraries not loaded by the user
7735 aren't handled here -- they're already handled in
7736 disable_breakpoints_in_unloaded_shlib, called by solib.c's
7737 solib_unloaded observer. We skip objfiles that are not
7738 OBJF_SHARED as those aren't considered dynamic objects (e.g. the
7740 if ((objfile
->flags
& OBJF_SHARED
) == 0
7741 || (objfile
->flags
& OBJF_USERLOADED
) == 0)
7746 struct bp_location
*loc
;
7747 int bp_modified
= 0;
7749 if (!is_breakpoint (b
) && !is_tracepoint (b
))
7752 for (loc
= b
->loc
; loc
!= NULL
; loc
= loc
->next
)
7754 CORE_ADDR loc_addr
= loc
->address
;
7756 if (loc
->loc_type
!= bp_loc_hardware_breakpoint
7757 && loc
->loc_type
!= bp_loc_software_breakpoint
)
7760 if (loc
->shlib_disabled
!= 0)
7763 if (objfile
->pspace
!= loc
->pspace
)
7766 if (loc
->loc_type
!= bp_loc_hardware_breakpoint
7767 && loc
->loc_type
!= bp_loc_software_breakpoint
)
7770 if (is_addr_in_objfile (loc_addr
, objfile
))
7772 loc
->shlib_disabled
= 1;
7773 /* At this point, we don't know whether the object was
7774 unmapped from the inferior or not, so leave the
7775 inserted flag alone. We'll handle failure to
7776 uninsert quietly, in case the object was indeed
7779 mark_breakpoint_location_modified (loc
);
7786 gdb::observers::breakpoint_modified
.notify (b
);
7790 /* FORK & VFORK catchpoints. */
7792 /* An instance of this type is used to represent a fork or vfork
7793 catchpoint. A breakpoint is really of this type iff its ops pointer points
7794 to CATCH_FORK_BREAKPOINT_OPS. */
7796 struct fork_catchpoint
: public breakpoint
7798 /* Process id of a child process whose forking triggered this
7799 catchpoint. This field is only valid immediately after this
7800 catchpoint has triggered. */
7801 ptid_t forked_inferior_pid
;
7804 /* Implement the "insert" breakpoint_ops method for fork
7808 insert_catch_fork (struct bp_location
*bl
)
7810 return target_insert_fork_catchpoint (inferior_ptid
.pid ());
7813 /* Implement the "remove" breakpoint_ops method for fork
7817 remove_catch_fork (struct bp_location
*bl
, enum remove_bp_reason reason
)
7819 return target_remove_fork_catchpoint (inferior_ptid
.pid ());
7822 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
7826 breakpoint_hit_catch_fork (const struct bp_location
*bl
,
7827 const address_space
*aspace
, CORE_ADDR bp_addr
,
7828 const struct target_waitstatus
*ws
)
7830 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bl
->owner
;
7832 if (ws
->kind
!= TARGET_WAITKIND_FORKED
)
7835 c
->forked_inferior_pid
= ws
->value
.related_pid
;
7839 /* Implement the "print_it" breakpoint_ops method for fork
7842 static enum print_stop_action
7843 print_it_catch_fork (bpstat bs
)
7845 struct ui_out
*uiout
= current_uiout
;
7846 struct breakpoint
*b
= bs
->breakpoint_at
;
7847 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bs
->breakpoint_at
;
7849 annotate_catchpoint (b
->number
);
7850 maybe_print_thread_hit_breakpoint (uiout
);
7851 if (b
->disposition
== disp_del
)
7852 uiout
->text ("Temporary catchpoint ");
7854 uiout
->text ("Catchpoint ");
7855 if (uiout
->is_mi_like_p ())
7857 uiout
->field_string ("reason", async_reason_lookup (EXEC_ASYNC_FORK
));
7858 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
7860 uiout
->field_signed ("bkptno", b
->number
);
7861 uiout
->text (" (forked process ");
7862 uiout
->field_signed ("newpid", c
->forked_inferior_pid
.pid ());
7863 uiout
->text ("), ");
7864 return PRINT_SRC_AND_LOC
;
7867 /* Implement the "print_one" breakpoint_ops method for fork
7871 print_one_catch_fork (struct breakpoint
*b
, struct bp_location
**last_loc
)
7873 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
7874 struct value_print_options opts
;
7875 struct ui_out
*uiout
= current_uiout
;
7877 get_user_print_options (&opts
);
7879 /* Field 4, the address, is omitted (which makes the columns not
7880 line up too nicely with the headers, but the effect is relatively
7882 if (opts
.addressprint
)
7883 uiout
->field_skip ("addr");
7885 uiout
->text ("fork");
7886 if (c
->forked_inferior_pid
!= null_ptid
)
7888 uiout
->text (", process ");
7889 uiout
->field_signed ("what", c
->forked_inferior_pid
.pid ());
7893 if (uiout
->is_mi_like_p ())
7894 uiout
->field_string ("catch-type", "fork");
7897 /* Implement the "print_mention" breakpoint_ops method for fork
7901 print_mention_catch_fork (struct breakpoint
*b
)
7903 printf_filtered (_("Catchpoint %d (fork)"), b
->number
);
7906 /* Implement the "print_recreate" breakpoint_ops method for fork
7910 print_recreate_catch_fork (struct breakpoint
*b
, struct ui_file
*fp
)
7912 fprintf_unfiltered (fp
, "catch fork");
7913 print_recreate_thread (b
, fp
);
7916 /* The breakpoint_ops structure to be used in fork catchpoints. */
7918 static struct breakpoint_ops catch_fork_breakpoint_ops
;
7920 /* Implement the "insert" breakpoint_ops method for vfork
7924 insert_catch_vfork (struct bp_location
*bl
)
7926 return target_insert_vfork_catchpoint (inferior_ptid
.pid ());
7929 /* Implement the "remove" breakpoint_ops method for vfork
7933 remove_catch_vfork (struct bp_location
*bl
, enum remove_bp_reason reason
)
7935 return target_remove_vfork_catchpoint (inferior_ptid
.pid ());
7938 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
7942 breakpoint_hit_catch_vfork (const struct bp_location
*bl
,
7943 const address_space
*aspace
, CORE_ADDR bp_addr
,
7944 const struct target_waitstatus
*ws
)
7946 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bl
->owner
;
7948 if (ws
->kind
!= TARGET_WAITKIND_VFORKED
)
7951 c
->forked_inferior_pid
= ws
->value
.related_pid
;
7955 /* Implement the "print_it" breakpoint_ops method for vfork
7958 static enum print_stop_action
7959 print_it_catch_vfork (bpstat bs
)
7961 struct ui_out
*uiout
= current_uiout
;
7962 struct breakpoint
*b
= bs
->breakpoint_at
;
7963 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
7965 annotate_catchpoint (b
->number
);
7966 maybe_print_thread_hit_breakpoint (uiout
);
7967 if (b
->disposition
== disp_del
)
7968 uiout
->text ("Temporary catchpoint ");
7970 uiout
->text ("Catchpoint ");
7971 if (uiout
->is_mi_like_p ())
7973 uiout
->field_string ("reason", async_reason_lookup (EXEC_ASYNC_VFORK
));
7974 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
7976 uiout
->field_signed ("bkptno", b
->number
);
7977 uiout
->text (" (vforked process ");
7978 uiout
->field_signed ("newpid", c
->forked_inferior_pid
.pid ());
7979 uiout
->text ("), ");
7980 return PRINT_SRC_AND_LOC
;
7983 /* Implement the "print_one" breakpoint_ops method for vfork
7987 print_one_catch_vfork (struct breakpoint
*b
, struct bp_location
**last_loc
)
7989 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
7990 struct value_print_options opts
;
7991 struct ui_out
*uiout
= current_uiout
;
7993 get_user_print_options (&opts
);
7994 /* Field 4, the address, is omitted (which makes the columns not
7995 line up too nicely with the headers, but the effect is relatively
7997 if (opts
.addressprint
)
7998 uiout
->field_skip ("addr");
8000 uiout
->text ("vfork");
8001 if (c
->forked_inferior_pid
!= null_ptid
)
8003 uiout
->text (", process ");
8004 uiout
->field_signed ("what", c
->forked_inferior_pid
.pid ());
8008 if (uiout
->is_mi_like_p ())
8009 uiout
->field_string ("catch-type", "vfork");
8012 /* Implement the "print_mention" breakpoint_ops method for vfork
8016 print_mention_catch_vfork (struct breakpoint
*b
)
8018 printf_filtered (_("Catchpoint %d (vfork)"), b
->number
);
8021 /* Implement the "print_recreate" breakpoint_ops method for vfork
8025 print_recreate_catch_vfork (struct breakpoint
*b
, struct ui_file
*fp
)
8027 fprintf_unfiltered (fp
, "catch vfork");
8028 print_recreate_thread (b
, fp
);
8031 /* The breakpoint_ops structure to be used in vfork catchpoints. */
8033 static struct breakpoint_ops catch_vfork_breakpoint_ops
;
8035 /* An instance of this type is used to represent an solib catchpoint.
8036 A breakpoint is really of this type iff its ops pointer points to
8037 CATCH_SOLIB_BREAKPOINT_OPS. */
8039 struct solib_catchpoint
: public breakpoint
8041 ~solib_catchpoint () override
;
8043 /* True for "catch load", false for "catch unload". */
8046 /* Regular expression to match, if any. COMPILED is only valid when
8047 REGEX is non-NULL. */
8049 std::unique_ptr
<compiled_regex
> compiled
;
8052 solib_catchpoint::~solib_catchpoint ()
8054 xfree (this->regex
);
8058 insert_catch_solib (struct bp_location
*ignore
)
8064 remove_catch_solib (struct bp_location
*ignore
, enum remove_bp_reason reason
)
8070 breakpoint_hit_catch_solib (const struct bp_location
*bl
,
8071 const address_space
*aspace
,
8073 const struct target_waitstatus
*ws
)
8075 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) bl
->owner
;
8076 struct breakpoint
*other
;
8078 if (ws
->kind
== TARGET_WAITKIND_LOADED
)
8081 ALL_BREAKPOINTS (other
)
8083 struct bp_location
*other_bl
;
8085 if (other
== bl
->owner
)
8088 if (other
->type
!= bp_shlib_event
)
8091 if (self
->pspace
!= NULL
&& other
->pspace
!= self
->pspace
)
8094 for (other_bl
= other
->loc
; other_bl
!= NULL
; other_bl
= other_bl
->next
)
8096 if (other
->ops
->breakpoint_hit (other_bl
, aspace
, bp_addr
, ws
))
8105 check_status_catch_solib (struct bpstats
*bs
)
8107 struct solib_catchpoint
*self
8108 = (struct solib_catchpoint
*) bs
->breakpoint_at
;
8112 for (so_list
*iter
: current_program_space
->added_solibs
)
8115 || self
->compiled
->exec (iter
->so_name
, 0, NULL
, 0) == 0)
8121 for (const std::string
&iter
: current_program_space
->deleted_solibs
)
8124 || self
->compiled
->exec (iter
.c_str (), 0, NULL
, 0) == 0)
8130 bs
->print_it
= print_it_noop
;
8133 static enum print_stop_action
8134 print_it_catch_solib (bpstat bs
)
8136 struct breakpoint
*b
= bs
->breakpoint_at
;
8137 struct ui_out
*uiout
= current_uiout
;
8139 annotate_catchpoint (b
->number
);
8140 maybe_print_thread_hit_breakpoint (uiout
);
8141 if (b
->disposition
== disp_del
)
8142 uiout
->text ("Temporary catchpoint ");
8144 uiout
->text ("Catchpoint ");
8145 uiout
->field_signed ("bkptno", b
->number
);
8147 if (uiout
->is_mi_like_p ())
8148 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
8149 print_solib_event (1);
8150 return PRINT_SRC_AND_LOC
;
8154 print_one_catch_solib (struct breakpoint
*b
, struct bp_location
**locs
)
8156 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8157 struct value_print_options opts
;
8158 struct ui_out
*uiout
= current_uiout
;
8160 get_user_print_options (&opts
);
8161 /* Field 4, the address, is omitted (which makes the columns not
8162 line up too nicely with the headers, but the effect is relatively
8164 if (opts
.addressprint
)
8167 uiout
->field_skip ("addr");
8175 msg
= string_printf (_("load of library matching %s"), self
->regex
);
8177 msg
= _("load of library");
8182 msg
= string_printf (_("unload of library matching %s"), self
->regex
);
8184 msg
= _("unload of library");
8186 uiout
->field_string ("what", msg
);
8188 if (uiout
->is_mi_like_p ())
8189 uiout
->field_string ("catch-type", self
->is_load
? "load" : "unload");
8193 print_mention_catch_solib (struct breakpoint
*b
)
8195 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8197 printf_filtered (_("Catchpoint %d (%s)"), b
->number
,
8198 self
->is_load
? "load" : "unload");
8202 print_recreate_catch_solib (struct breakpoint
*b
, struct ui_file
*fp
)
8204 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8206 fprintf_unfiltered (fp
, "%s %s",
8207 b
->disposition
== disp_del
? "tcatch" : "catch",
8208 self
->is_load
? "load" : "unload");
8210 fprintf_unfiltered (fp
, " %s", self
->regex
);
8211 fprintf_unfiltered (fp
, "\n");
8214 static struct breakpoint_ops catch_solib_breakpoint_ops
;
8216 /* See breakpoint.h. */
8219 add_solib_catchpoint (const char *arg
, bool is_load
, bool is_temp
, bool enabled
)
8221 struct gdbarch
*gdbarch
= get_current_arch ();
8225 arg
= skip_spaces (arg
);
8227 std::unique_ptr
<solib_catchpoint
> c (new solib_catchpoint ());
8231 c
->compiled
.reset (new compiled_regex (arg
, REG_NOSUB
,
8232 _("Invalid regexp")));
8233 c
->regex
= xstrdup (arg
);
8236 c
->is_load
= is_load
;
8237 init_catchpoint (c
.get (), gdbarch
, is_temp
, NULL
,
8238 &catch_solib_breakpoint_ops
);
8240 c
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
8242 install_breakpoint (0, std::move (c
), 1);
8245 /* A helper function that does all the work for "catch load" and
8249 catch_load_or_unload (const char *arg
, int from_tty
, int is_load
,
8250 struct cmd_list_element
*command
)
8252 const int enabled
= 1;
8253 bool temp
= get_cmd_context (command
) == CATCH_TEMPORARY
;
8255 add_solib_catchpoint (arg
, is_load
, temp
, enabled
);
8259 catch_load_command_1 (const char *arg
, int from_tty
,
8260 struct cmd_list_element
*command
)
8262 catch_load_or_unload (arg
, from_tty
, 1, command
);
8266 catch_unload_command_1 (const char *arg
, int from_tty
,
8267 struct cmd_list_element
*command
)
8269 catch_load_or_unload (arg
, from_tty
, 0, command
);
8272 /* See breakpoint.h. */
8275 init_catchpoint (struct breakpoint
*b
,
8276 struct gdbarch
*gdbarch
, bool temp
,
8277 const char *cond_string
,
8278 const struct breakpoint_ops
*ops
)
8280 symtab_and_line sal
;
8281 sal
.pspace
= current_program_space
;
8283 init_raw_breakpoint (b
, gdbarch
, sal
, bp_catchpoint
, ops
);
8285 b
->cond_string
= (cond_string
== NULL
) ? NULL
: xstrdup (cond_string
);
8286 b
->disposition
= temp
? disp_del
: disp_donttouch
;
8290 install_breakpoint (int internal
, std::unique_ptr
<breakpoint
> &&arg
, int update_gll
)
8292 breakpoint
*b
= add_to_breakpoint_chain (std::move (arg
));
8293 set_breakpoint_number (internal
, b
);
8294 if (is_tracepoint (b
))
8295 set_tracepoint_count (breakpoint_count
);
8298 gdb::observers::breakpoint_created
.notify (b
);
8301 update_global_location_list (UGLL_MAY_INSERT
);
8305 create_fork_vfork_event_catchpoint (struct gdbarch
*gdbarch
,
8306 bool temp
, const char *cond_string
,
8307 const struct breakpoint_ops
*ops
)
8309 std::unique_ptr
<fork_catchpoint
> c (new fork_catchpoint ());
8311 init_catchpoint (c
.get (), gdbarch
, temp
, cond_string
, ops
);
8313 c
->forked_inferior_pid
= null_ptid
;
8315 install_breakpoint (0, std::move (c
), 1);
8318 /* Exec catchpoints. */
8320 /* An instance of this type is used to represent an exec catchpoint.
8321 A breakpoint is really of this type iff its ops pointer points to
8322 CATCH_EXEC_BREAKPOINT_OPS. */
8324 struct exec_catchpoint
: public breakpoint
8326 ~exec_catchpoint () override
;
8328 /* Filename of a program whose exec triggered this catchpoint.
8329 This field is only valid immediately after this catchpoint has
8331 char *exec_pathname
;
8334 /* Exec catchpoint destructor. */
8336 exec_catchpoint::~exec_catchpoint ()
8338 xfree (this->exec_pathname
);
8342 insert_catch_exec (struct bp_location
*bl
)
8344 return target_insert_exec_catchpoint (inferior_ptid
.pid ());
8348 remove_catch_exec (struct bp_location
*bl
, enum remove_bp_reason reason
)
8350 return target_remove_exec_catchpoint (inferior_ptid
.pid ());
8354 breakpoint_hit_catch_exec (const struct bp_location
*bl
,
8355 const address_space
*aspace
, CORE_ADDR bp_addr
,
8356 const struct target_waitstatus
*ws
)
8358 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) bl
->owner
;
8360 if (ws
->kind
!= TARGET_WAITKIND_EXECD
)
8363 c
->exec_pathname
= xstrdup (ws
->value
.execd_pathname
);
8367 static enum print_stop_action
8368 print_it_catch_exec (bpstat bs
)
8370 struct ui_out
*uiout
= current_uiout
;
8371 struct breakpoint
*b
= bs
->breakpoint_at
;
8372 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
8374 annotate_catchpoint (b
->number
);
8375 maybe_print_thread_hit_breakpoint (uiout
);
8376 if (b
->disposition
== disp_del
)
8377 uiout
->text ("Temporary catchpoint ");
8379 uiout
->text ("Catchpoint ");
8380 if (uiout
->is_mi_like_p ())
8382 uiout
->field_string ("reason", async_reason_lookup (EXEC_ASYNC_EXEC
));
8383 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
8385 uiout
->field_signed ("bkptno", b
->number
);
8386 uiout
->text (" (exec'd ");
8387 uiout
->field_string ("new-exec", c
->exec_pathname
);
8388 uiout
->text ("), ");
8390 return PRINT_SRC_AND_LOC
;
8394 print_one_catch_exec (struct breakpoint
*b
, struct bp_location
**last_loc
)
8396 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
8397 struct value_print_options opts
;
8398 struct ui_out
*uiout
= current_uiout
;
8400 get_user_print_options (&opts
);
8402 /* Field 4, the address, is omitted (which makes the columns
8403 not line up too nicely with the headers, but the effect
8404 is relatively readable). */
8405 if (opts
.addressprint
)
8406 uiout
->field_skip ("addr");
8408 uiout
->text ("exec");
8409 if (c
->exec_pathname
!= NULL
)
8411 uiout
->text (", program \"");
8412 uiout
->field_string ("what", c
->exec_pathname
);
8413 uiout
->text ("\" ");
8416 if (uiout
->is_mi_like_p ())
8417 uiout
->field_string ("catch-type", "exec");
8421 print_mention_catch_exec (struct breakpoint
*b
)
8423 printf_filtered (_("Catchpoint %d (exec)"), b
->number
);
8426 /* Implement the "print_recreate" breakpoint_ops method for exec
8430 print_recreate_catch_exec (struct breakpoint
*b
, struct ui_file
*fp
)
8432 fprintf_unfiltered (fp
, "catch exec");
8433 print_recreate_thread (b
, fp
);
8436 static struct breakpoint_ops catch_exec_breakpoint_ops
;
8439 hw_breakpoint_used_count (void)
8442 struct breakpoint
*b
;
8443 struct bp_location
*bl
;
8447 if (b
->type
== bp_hardware_breakpoint
&& breakpoint_enabled (b
))
8448 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
8450 /* Special types of hardware breakpoints may use more than
8452 i
+= b
->ops
->resources_needed (bl
);
8459 /* Returns the resources B would use if it were a hardware
8463 hw_watchpoint_use_count (struct breakpoint
*b
)
8466 struct bp_location
*bl
;
8468 if (!breakpoint_enabled (b
))
8471 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
8473 /* Special types of hardware watchpoints may use more than
8475 i
+= b
->ops
->resources_needed (bl
);
8481 /* Returns the sum the used resources of all hardware watchpoints of
8482 type TYPE in the breakpoints list. Also returns in OTHER_TYPE_USED
8483 the sum of the used resources of all hardware watchpoints of other
8484 types _not_ TYPE. */
8487 hw_watchpoint_used_count_others (struct breakpoint
*except
,
8488 enum bptype type
, int *other_type_used
)
8491 struct breakpoint
*b
;
8493 *other_type_used
= 0;
8498 if (!breakpoint_enabled (b
))
8501 if (b
->type
== type
)
8502 i
+= hw_watchpoint_use_count (b
);
8503 else if (is_hardware_watchpoint (b
))
8504 *other_type_used
= 1;
8511 disable_watchpoints_before_interactive_call_start (void)
8513 struct breakpoint
*b
;
8517 if (is_watchpoint (b
) && breakpoint_enabled (b
))
8519 b
->enable_state
= bp_call_disabled
;
8520 update_global_location_list (UGLL_DONT_INSERT
);
8526 enable_watchpoints_after_interactive_call_stop (void)
8528 struct breakpoint
*b
;
8532 if (is_watchpoint (b
) && b
->enable_state
== bp_call_disabled
)
8534 b
->enable_state
= bp_enabled
;
8535 update_global_location_list (UGLL_MAY_INSERT
);
8541 disable_breakpoints_before_startup (void)
8543 current_program_space
->executing_startup
= 1;
8544 update_global_location_list (UGLL_DONT_INSERT
);
8548 enable_breakpoints_after_startup (void)
8550 current_program_space
->executing_startup
= 0;
8551 breakpoint_re_set ();
8554 /* Create a new single-step breakpoint for thread THREAD, with no
8557 static struct breakpoint
*
8558 new_single_step_breakpoint (int thread
, struct gdbarch
*gdbarch
)
8560 std::unique_ptr
<breakpoint
> b (new breakpoint ());
8562 init_raw_breakpoint_without_location (b
.get (), gdbarch
, bp_single_step
,
8563 &momentary_breakpoint_ops
);
8565 b
->disposition
= disp_donttouch
;
8566 b
->frame_id
= null_frame_id
;
8569 gdb_assert (b
->thread
!= 0);
8571 return add_to_breakpoint_chain (std::move (b
));
8574 /* Set a momentary breakpoint of type TYPE at address specified by
8575 SAL. If FRAME_ID is valid, the breakpoint is restricted to that
8579 set_momentary_breakpoint (struct gdbarch
*gdbarch
, struct symtab_and_line sal
,
8580 struct frame_id frame_id
, enum bptype type
)
8582 struct breakpoint
*b
;
8584 /* If FRAME_ID is valid, it should be a real frame, not an inlined or
8586 gdb_assert (!frame_id_artificial_p (frame_id
));
8588 b
= set_raw_breakpoint (gdbarch
, sal
, type
, &momentary_breakpoint_ops
);
8589 b
->enable_state
= bp_enabled
;
8590 b
->disposition
= disp_donttouch
;
8591 b
->frame_id
= frame_id
;
8593 b
->thread
= inferior_thread ()->global_num
;
8595 update_global_location_list_nothrow (UGLL_MAY_INSERT
);
8597 return breakpoint_up (b
);
8600 /* Make a momentary breakpoint based on the master breakpoint ORIG.
8601 The new breakpoint will have type TYPE, use OPS as its
8602 breakpoint_ops, and will set enabled to LOC_ENABLED. */
8604 static struct breakpoint
*
8605 momentary_breakpoint_from_master (struct breakpoint
*orig
,
8607 const struct breakpoint_ops
*ops
,
8610 struct breakpoint
*copy
;
8612 copy
= set_raw_breakpoint_without_location (orig
->gdbarch
, type
, ops
);
8613 copy
->loc
= allocate_bp_location (copy
);
8614 set_breakpoint_location_function (copy
->loc
);
8616 copy
->loc
->gdbarch
= orig
->loc
->gdbarch
;
8617 copy
->loc
->requested_address
= orig
->loc
->requested_address
;
8618 copy
->loc
->address
= orig
->loc
->address
;
8619 copy
->loc
->section
= orig
->loc
->section
;
8620 copy
->loc
->pspace
= orig
->loc
->pspace
;
8621 copy
->loc
->probe
= orig
->loc
->probe
;
8622 copy
->loc
->line_number
= orig
->loc
->line_number
;
8623 copy
->loc
->symtab
= orig
->loc
->symtab
;
8624 copy
->loc
->enabled
= loc_enabled
;
8625 copy
->frame_id
= orig
->frame_id
;
8626 copy
->thread
= orig
->thread
;
8627 copy
->pspace
= orig
->pspace
;
8629 copy
->enable_state
= bp_enabled
;
8630 copy
->disposition
= disp_donttouch
;
8631 copy
->number
= internal_breakpoint_number
--;
8633 update_global_location_list_nothrow (UGLL_DONT_INSERT
);
8637 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
8641 clone_momentary_breakpoint (struct breakpoint
*orig
)
8643 /* If there's nothing to clone, then return nothing. */
8647 return momentary_breakpoint_from_master (orig
, orig
->type
, orig
->ops
, 0);
8651 set_momentary_breakpoint_at_pc (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
8654 struct symtab_and_line sal
;
8656 sal
= find_pc_line (pc
, 0);
8658 sal
.section
= find_pc_overlay (pc
);
8659 sal
.explicit_pc
= 1;
8661 return set_momentary_breakpoint (gdbarch
, sal
, null_frame_id
, type
);
8665 /* Tell the user we have just set a breakpoint B. */
8668 mention (struct breakpoint
*b
)
8670 b
->ops
->print_mention (b
);
8671 current_uiout
->text ("\n");
8675 static bool bp_loc_is_permanent (struct bp_location
*loc
);
8677 /* Handle "set breakpoint auto-hw on".
8679 If the explicitly specified breakpoint type is not hardware
8680 breakpoint, check the memory map to see whether the breakpoint
8681 address is in read-only memory.
8683 - location type is not hardware breakpoint, memory is read-only.
8684 We change the type of the location to hardware breakpoint.
8686 - location type is hardware breakpoint, memory is read-write. This
8687 means we've previously made the location hardware one, but then the
8688 memory map changed, so we undo.
8692 handle_automatic_hardware_breakpoints (bp_location
*bl
)
8694 if (automatic_hardware_breakpoints
8695 && bl
->owner
->type
!= bp_hardware_breakpoint
8696 && (bl
->loc_type
== bp_loc_software_breakpoint
8697 || bl
->loc_type
== bp_loc_hardware_breakpoint
))
8699 /* When breakpoints are removed, remove_breakpoints will use
8700 location types we've just set here, the only possible problem
8701 is that memory map has changed during running program, but
8702 it's not going to work anyway with current gdb. */
8703 mem_region
*mr
= lookup_mem_region (bl
->address
);
8707 enum bp_loc_type new_type
;
8709 if (mr
->attrib
.mode
!= MEM_RW
)
8710 new_type
= bp_loc_hardware_breakpoint
;
8712 new_type
= bp_loc_software_breakpoint
;
8714 if (new_type
!= bl
->loc_type
)
8716 static bool said
= false;
8718 bl
->loc_type
= new_type
;
8721 fprintf_filtered (gdb_stdout
,
8722 _("Note: automatically using "
8723 "hardware breakpoints for "
8724 "read-only addresses.\n"));
8732 static struct bp_location
*
8733 add_location_to_breakpoint (struct breakpoint
*b
,
8734 const struct symtab_and_line
*sal
)
8736 struct bp_location
*loc
, **tmp
;
8737 CORE_ADDR adjusted_address
;
8738 struct gdbarch
*loc_gdbarch
= get_sal_arch (*sal
);
8740 if (loc_gdbarch
== NULL
)
8741 loc_gdbarch
= b
->gdbarch
;
8743 /* Adjust the breakpoint's address prior to allocating a location.
8744 Once we call allocate_bp_location(), that mostly uninitialized
8745 location will be placed on the location chain. Adjustment of the
8746 breakpoint may cause target_read_memory() to be called and we do
8747 not want its scan of the location chain to find a breakpoint and
8748 location that's only been partially initialized. */
8749 adjusted_address
= adjust_breakpoint_address (loc_gdbarch
,
8752 /* Sort the locations by their ADDRESS. */
8753 loc
= allocate_bp_location (b
);
8754 for (tmp
= &(b
->loc
); *tmp
!= NULL
&& (*tmp
)->address
<= adjusted_address
;
8755 tmp
= &((*tmp
)->next
))
8760 loc
->requested_address
= sal
->pc
;
8761 loc
->address
= adjusted_address
;
8762 loc
->pspace
= sal
->pspace
;
8763 loc
->probe
.prob
= sal
->prob
;
8764 loc
->probe
.objfile
= sal
->objfile
;
8765 gdb_assert (loc
->pspace
!= NULL
);
8766 loc
->section
= sal
->section
;
8767 loc
->gdbarch
= loc_gdbarch
;
8768 loc
->line_number
= sal
->line
;
8769 loc
->symtab
= sal
->symtab
;
8770 loc
->symbol
= sal
->symbol
;
8771 loc
->msymbol
= sal
->msymbol
;
8772 loc
->objfile
= sal
->objfile
;
8774 set_breakpoint_location_function (loc
);
8776 /* While by definition, permanent breakpoints are already present in the
8777 code, we don't mark the location as inserted. Normally one would expect
8778 that GDB could rely on that breakpoint instruction to stop the program,
8779 thus removing the need to insert its own breakpoint, except that executing
8780 the breakpoint instruction can kill the target instead of reporting a
8781 SIGTRAP. E.g., on SPARC, when interrupts are disabled, executing the
8782 instruction resets the CPU, so QEMU 2.0.0 for SPARC correspondingly dies
8783 with "Trap 0x02 while interrupts disabled, Error state". Letting the
8784 breakpoint be inserted normally results in QEMU knowing about the GDB
8785 breakpoint, and thus trap before the breakpoint instruction is executed.
8786 (If GDB later needs to continue execution past the permanent breakpoint,
8787 it manually increments the PC, thus avoiding executing the breakpoint
8789 if (bp_loc_is_permanent (loc
))
8796 /* Return true if LOC is pointing to a permanent breakpoint,
8797 return false otherwise. */
8800 bp_loc_is_permanent (struct bp_location
*loc
)
8802 gdb_assert (loc
!= NULL
);
8804 /* If we have a non-breakpoint-backed catchpoint or a software
8805 watchpoint, just return 0. We should not attempt to read from
8806 the addresses the locations of these breakpoint types point to.
8807 gdbarch_program_breakpoint_here_p, below, will attempt to read
8809 if (!bl_address_is_meaningful (loc
))
8812 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
8813 switch_to_program_space_and_thread (loc
->pspace
);
8814 return gdbarch_program_breakpoint_here_p (loc
->gdbarch
, loc
->address
);
8817 /* Build a command list for the dprintf corresponding to the current
8818 settings of the dprintf style options. */
8821 update_dprintf_command_list (struct breakpoint
*b
)
8823 char *dprintf_args
= b
->extra_string
;
8824 char *printf_line
= NULL
;
8829 dprintf_args
= skip_spaces (dprintf_args
);
8831 /* Allow a comma, as it may have terminated a location, but don't
8833 if (*dprintf_args
== ',')
8835 dprintf_args
= skip_spaces (dprintf_args
);
8837 if (*dprintf_args
!= '"')
8838 error (_("Bad format string, missing '\"'."));
8840 if (strcmp (dprintf_style
, dprintf_style_gdb
) == 0)
8841 printf_line
= xstrprintf ("printf %s", dprintf_args
);
8842 else if (strcmp (dprintf_style
, dprintf_style_call
) == 0)
8844 if (!dprintf_function
)
8845 error (_("No function supplied for dprintf call"));
8847 if (dprintf_channel
&& strlen (dprintf_channel
) > 0)
8848 printf_line
= xstrprintf ("call (void) %s (%s,%s)",
8853 printf_line
= xstrprintf ("call (void) %s (%s)",
8857 else if (strcmp (dprintf_style
, dprintf_style_agent
) == 0)
8859 if (target_can_run_breakpoint_commands ())
8860 printf_line
= xstrprintf ("agent-printf %s", dprintf_args
);
8863 warning (_("Target cannot run dprintf commands, falling back to GDB printf"));
8864 printf_line
= xstrprintf ("printf %s", dprintf_args
);
8868 internal_error (__FILE__
, __LINE__
,
8869 _("Invalid dprintf style."));
8871 gdb_assert (printf_line
!= NULL
);
8873 /* Manufacture a printf sequence. */
8874 struct command_line
*printf_cmd_line
8875 = new struct command_line (simple_control
, printf_line
);
8876 breakpoint_set_commands (b
, counted_command_line (printf_cmd_line
,
8877 command_lines_deleter ()));
8880 /* Update all dprintf commands, making their command lists reflect
8881 current style settings. */
8884 update_dprintf_commands (const char *args
, int from_tty
,
8885 struct cmd_list_element
*c
)
8887 struct breakpoint
*b
;
8891 if (b
->type
== bp_dprintf
)
8892 update_dprintf_command_list (b
);
8896 /* Create a breakpoint with SAL as location. Use LOCATION
8897 as a description of the location, and COND_STRING
8898 as condition expression. If LOCATION is NULL then create an
8899 "address location" from the address in the SAL. */
8902 init_breakpoint_sal (struct breakpoint
*b
, struct gdbarch
*gdbarch
,
8903 gdb::array_view
<const symtab_and_line
> sals
,
8904 event_location_up
&&location
,
8905 gdb::unique_xmalloc_ptr
<char> filter
,
8906 gdb::unique_xmalloc_ptr
<char> cond_string
,
8907 gdb::unique_xmalloc_ptr
<char> extra_string
,
8908 enum bptype type
, enum bpdisp disposition
,
8909 int thread
, int task
, int ignore_count
,
8910 const struct breakpoint_ops
*ops
, int from_tty
,
8911 int enabled
, int internal
, unsigned flags
,
8912 int display_canonical
)
8916 if (type
== bp_hardware_breakpoint
)
8918 int target_resources_ok
;
8920 i
= hw_breakpoint_used_count ();
8921 target_resources_ok
=
8922 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
8924 if (target_resources_ok
== 0)
8925 error (_("No hardware breakpoint support in the target."));
8926 else if (target_resources_ok
< 0)
8927 error (_("Hardware breakpoints used exceeds limit."));
8930 gdb_assert (!sals
.empty ());
8932 for (const auto &sal
: sals
)
8934 struct bp_location
*loc
;
8938 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
8940 loc_gdbarch
= gdbarch
;
8942 describe_other_breakpoints (loc_gdbarch
,
8943 sal
.pspace
, sal
.pc
, sal
.section
, thread
);
8946 if (&sal
== &sals
[0])
8948 init_raw_breakpoint (b
, gdbarch
, sal
, type
, ops
);
8952 b
->cond_string
= cond_string
.release ();
8953 b
->extra_string
= extra_string
.release ();
8954 b
->ignore_count
= ignore_count
;
8955 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
8956 b
->disposition
= disposition
;
8958 if ((flags
& CREATE_BREAKPOINT_FLAGS_INSERTED
) != 0)
8959 b
->loc
->inserted
= 1;
8961 if (type
== bp_static_tracepoint
)
8963 struct tracepoint
*t
= (struct tracepoint
*) b
;
8964 struct static_tracepoint_marker marker
;
8966 if (strace_marker_p (b
))
8968 /* We already know the marker exists, otherwise, we
8969 wouldn't see a sal for it. */
8971 = &event_location_to_string (b
->location
.get ())[3];
8974 p
= skip_spaces (p
);
8976 endp
= skip_to_space (p
);
8978 t
->static_trace_marker_id
.assign (p
, endp
- p
);
8980 printf_filtered (_("Probed static tracepoint "
8982 t
->static_trace_marker_id
.c_str ());
8984 else if (target_static_tracepoint_marker_at (sal
.pc
, &marker
))
8986 t
->static_trace_marker_id
= std::move (marker
.str_id
);
8988 printf_filtered (_("Probed static tracepoint "
8990 t
->static_trace_marker_id
.c_str ());
8993 warning (_("Couldn't determine the static "
8994 "tracepoint marker to probe"));
9001 loc
= add_location_to_breakpoint (b
, &sal
);
9002 if ((flags
& CREATE_BREAKPOINT_FLAGS_INSERTED
) != 0)
9006 /* Do not set breakpoint locations conditions yet. As locations
9007 are inserted, they get sorted based on their addresses. Let
9008 the list stabilize to have reliable location numbers. */
9010 /* Dynamic printf requires and uses additional arguments on the
9011 command line, otherwise it's an error. */
9012 if (type
== bp_dprintf
)
9014 if (b
->extra_string
)
9015 update_dprintf_command_list (b
);
9017 error (_("Format string required"));
9019 else if (b
->extra_string
)
9020 error (_("Garbage '%s' at end of command"), b
->extra_string
);
9024 /* The order of the locations is now stable. Set the location
9025 condition using the location's number. */
9027 for (bp_location
*loc
= b
->loc
; loc
!= nullptr; loc
= loc
->next
)
9029 if (b
->cond_string
!= nullptr)
9030 set_breakpoint_location_condition (b
->cond_string
, loc
, b
->number
,
9036 b
->display_canonical
= display_canonical
;
9037 if (location
!= NULL
)
9038 b
->location
= std::move (location
);
9040 b
->location
= new_address_location (b
->loc
->address
, NULL
, 0);
9041 b
->filter
= std::move (filter
);
9045 create_breakpoint_sal (struct gdbarch
*gdbarch
,
9046 gdb::array_view
<const symtab_and_line
> sals
,
9047 event_location_up
&&location
,
9048 gdb::unique_xmalloc_ptr
<char> filter
,
9049 gdb::unique_xmalloc_ptr
<char> cond_string
,
9050 gdb::unique_xmalloc_ptr
<char> extra_string
,
9051 enum bptype type
, enum bpdisp disposition
,
9052 int thread
, int task
, int ignore_count
,
9053 const struct breakpoint_ops
*ops
, int from_tty
,
9054 int enabled
, int internal
, unsigned flags
,
9055 int display_canonical
)
9057 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (type
);
9059 init_breakpoint_sal (b
.get (), gdbarch
,
9060 sals
, std::move (location
),
9062 std::move (cond_string
),
9063 std::move (extra_string
),
9065 thread
, task
, ignore_count
,
9067 enabled
, internal
, flags
,
9070 install_breakpoint (internal
, std::move (b
), 0);
9073 /* Add SALS.nelts breakpoints to the breakpoint table. For each
9074 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
9075 value. COND_STRING, if not NULL, specified the condition to be
9076 used for all breakpoints. Essentially the only case where
9077 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
9078 function. In that case, it's still not possible to specify
9079 separate conditions for different overloaded functions, so
9080 we take just a single condition string.
9082 NOTE: If the function succeeds, the caller is expected to cleanup
9083 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
9084 array contents). If the function fails (error() is called), the
9085 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
9086 COND and SALS arrays and each of those arrays contents. */
9089 create_breakpoints_sal (struct gdbarch
*gdbarch
,
9090 struct linespec_result
*canonical
,
9091 gdb::unique_xmalloc_ptr
<char> cond_string
,
9092 gdb::unique_xmalloc_ptr
<char> extra_string
,
9093 enum bptype type
, enum bpdisp disposition
,
9094 int thread
, int task
, int ignore_count
,
9095 const struct breakpoint_ops
*ops
, int from_tty
,
9096 int enabled
, int internal
, unsigned flags
)
9098 if (canonical
->pre_expanded
)
9099 gdb_assert (canonical
->lsals
.size () == 1);
9101 for (const auto &lsal
: canonical
->lsals
)
9103 /* Note that 'location' can be NULL in the case of a plain
9104 'break', without arguments. */
9105 event_location_up location
9106 = (canonical
->location
!= NULL
9107 ? copy_event_location (canonical
->location
.get ()) : NULL
);
9108 gdb::unique_xmalloc_ptr
<char> filter_string
9109 (lsal
.canonical
!= NULL
? xstrdup (lsal
.canonical
) : NULL
);
9111 create_breakpoint_sal (gdbarch
, lsal
.sals
,
9112 std::move (location
),
9113 std::move (filter_string
),
9114 std::move (cond_string
),
9115 std::move (extra_string
),
9117 thread
, task
, ignore_count
, ops
,
9118 from_tty
, enabled
, internal
, flags
,
9119 canonical
->special_display
);
9123 /* Parse LOCATION which is assumed to be a SAL specification possibly
9124 followed by conditionals. On return, SALS contains an array of SAL
9125 addresses found. LOCATION points to the end of the SAL (for
9126 linespec locations).
9128 The array and the line spec strings are allocated on the heap, it is
9129 the caller's responsibility to free them. */
9132 parse_breakpoint_sals (struct event_location
*location
,
9133 struct linespec_result
*canonical
)
9135 struct symtab_and_line cursal
;
9137 if (event_location_type (location
) == LINESPEC_LOCATION
)
9139 const char *spec
= get_linespec_location (location
)->spec_string
;
9143 /* The last displayed codepoint, if it's valid, is our default
9144 breakpoint address. */
9145 if (last_displayed_sal_is_valid ())
9147 /* Set sal's pspace, pc, symtab, and line to the values
9148 corresponding to the last call to print_frame_info.
9149 Be sure to reinitialize LINE with NOTCURRENT == 0
9150 as the breakpoint line number is inappropriate otherwise.
9151 find_pc_line would adjust PC, re-set it back. */
9152 symtab_and_line sal
= get_last_displayed_sal ();
9153 CORE_ADDR pc
= sal
.pc
;
9155 sal
= find_pc_line (pc
, 0);
9157 /* "break" without arguments is equivalent to "break *PC"
9158 where PC is the last displayed codepoint's address. So
9159 make sure to set sal.explicit_pc to prevent GDB from
9160 trying to expand the list of sals to include all other
9161 instances with the same symtab and line. */
9163 sal
.explicit_pc
= 1;
9165 struct linespec_sals lsal
;
9167 lsal
.canonical
= NULL
;
9169 canonical
->lsals
.push_back (std::move (lsal
));
9173 error (_("No default breakpoint address now."));
9177 /* Force almost all breakpoints to be in terms of the
9178 current_source_symtab (which is decode_line_1's default).
9179 This should produce the results we want almost all of the
9180 time while leaving default_breakpoint_* alone.
9182 ObjC: However, don't match an Objective-C method name which
9183 may have a '+' or '-' succeeded by a '['. */
9184 cursal
= get_current_source_symtab_and_line ();
9185 if (last_displayed_sal_is_valid ())
9187 const char *spec
= NULL
;
9189 if (event_location_type (location
) == LINESPEC_LOCATION
)
9190 spec
= get_linespec_location (location
)->spec_string
;
9194 && strchr ("+-", spec
[0]) != NULL
9197 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, NULL
,
9198 get_last_displayed_symtab (),
9199 get_last_displayed_line (),
9200 canonical
, NULL
, NULL
);
9205 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, NULL
,
9206 cursal
.symtab
, cursal
.line
, canonical
, NULL
, NULL
);
9210 /* Convert each SAL into a real PC. Verify that the PC can be
9211 inserted as a breakpoint. If it can't throw an error. */
9214 breakpoint_sals_to_pc (std::vector
<symtab_and_line
> &sals
)
9216 for (auto &sal
: sals
)
9217 resolve_sal_pc (&sal
);
9220 /* Fast tracepoints may have restrictions on valid locations. For
9221 instance, a fast tracepoint using a jump instead of a trap will
9222 likely have to overwrite more bytes than a trap would, and so can
9223 only be placed where the instruction is longer than the jump, or a
9224 multi-instruction sequence does not have a jump into the middle of
9228 check_fast_tracepoint_sals (struct gdbarch
*gdbarch
,
9229 gdb::array_view
<const symtab_and_line
> sals
)
9231 for (const auto &sal
: sals
)
9233 struct gdbarch
*sarch
;
9235 sarch
= get_sal_arch (sal
);
9236 /* We fall back to GDBARCH if there is no architecture
9237 associated with SAL. */
9241 if (!gdbarch_fast_tracepoint_valid_at (sarch
, sal
.pc
, &msg
))
9242 error (_("May not have a fast tracepoint at %s%s"),
9243 paddress (sarch
, sal
.pc
), msg
.c_str ());
9247 /* Given TOK, a string specification of condition and thread, as
9248 accepted by the 'break' command, extract the condition
9249 string and thread number and set *COND_STRING and *THREAD.
9250 PC identifies the context at which the condition should be parsed.
9251 If no condition is found, *COND_STRING is set to NULL.
9252 If no thread is found, *THREAD is set to -1. */
9255 find_condition_and_thread (const char *tok
, CORE_ADDR pc
,
9256 char **cond_string
, int *thread
, int *task
,
9259 *cond_string
= NULL
;
9267 const char *end_tok
;
9269 const char *cond_start
= NULL
;
9270 const char *cond_end
= NULL
;
9272 tok
= skip_spaces (tok
);
9274 if ((*tok
== '"' || *tok
== ',') && rest
)
9276 *rest
= savestring (tok
, strlen (tok
));
9280 end_tok
= skip_to_space (tok
);
9282 toklen
= end_tok
- tok
;
9284 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
9286 tok
= cond_start
= end_tok
+ 1;
9289 parse_exp_1 (&tok
, pc
, block_for_pc (pc
), 0);
9291 catch (const gdb_exception_error
&)
9296 tok
= tok
+ strlen (tok
);
9299 *cond_string
= savestring (cond_start
, cond_end
- cond_start
);
9301 else if (toklen
>= 1 && strncmp (tok
, "-force-condition", toklen
) == 0)
9306 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
9309 struct thread_info
*thr
;
9312 thr
= parse_thread_id (tok
, &tmptok
);
9314 error (_("Junk after thread keyword."));
9315 *thread
= thr
->global_num
;
9318 else if (toklen
>= 1 && strncmp (tok
, "task", toklen
) == 0)
9323 *task
= strtol (tok
, &tmptok
, 0);
9325 error (_("Junk after task keyword."));
9326 if (!valid_task_id (*task
))
9327 error (_("Unknown task %d."), *task
);
9332 *rest
= savestring (tok
, strlen (tok
));
9336 error (_("Junk at end of arguments."));
9340 /* Call 'find_condition_and_thread' for each sal in SALS until a parse
9341 succeeds. The parsed values are written to COND_STRING, THREAD,
9342 TASK, and REST. See the comment of 'find_condition_and_thread'
9343 for the description of these parameters and INPUT. */
9346 find_condition_and_thread_for_sals (const std::vector
<symtab_and_line
> &sals
,
9347 const char *input
, char **cond_string
,
9348 int *thread
, int *task
, char **rest
)
9350 int num_failures
= 0;
9351 for (auto &sal
: sals
)
9353 char *cond
= nullptr;
9356 char *remaining
= nullptr;
9358 /* Here we want to parse 'arg' to separate condition from thread
9359 number. But because parsing happens in a context and the
9360 contexts of sals might be different, try each until there is
9361 success. Finding one successful parse is sufficient for our
9362 goal. When setting the breakpoint we'll re-parse the
9363 condition in the context of each sal. */
9366 find_condition_and_thread (input
, sal
.pc
, &cond
, &thread_id
,
9367 &task_id
, &remaining
);
9368 *cond_string
= cond
;
9369 *thread
= thread_id
;
9374 catch (const gdb_exception_error
&e
)
9377 /* If no sal remains, do not continue. */
9378 if (num_failures
== sals
.size ())
9384 /* Decode a static tracepoint marker spec. */
9386 static std::vector
<symtab_and_line
>
9387 decode_static_tracepoint_spec (const char **arg_p
)
9389 const char *p
= &(*arg_p
)[3];
9392 p
= skip_spaces (p
);
9394 endp
= skip_to_space (p
);
9396 std::string
marker_str (p
, endp
- p
);
9398 std::vector
<static_tracepoint_marker
> markers
9399 = target_static_tracepoint_markers_by_strid (marker_str
.c_str ());
9400 if (markers
.empty ())
9401 error (_("No known static tracepoint marker named %s"),
9402 marker_str
.c_str ());
9404 std::vector
<symtab_and_line
> sals
;
9405 sals
.reserve (markers
.size ());
9407 for (const static_tracepoint_marker
&marker
: markers
)
9409 symtab_and_line sal
= find_pc_line (marker
.address
, 0);
9410 sal
.pc
= marker
.address
;
9411 sals
.push_back (sal
);
9418 /* Returns the breakpoint ops appropriate for use with with LOCATION_TYPE and
9419 according to IS_TRACEPOINT. */
9421 static const struct breakpoint_ops
*
9422 breakpoint_ops_for_event_location_type (enum event_location_type location_type
,
9427 if (location_type
== PROBE_LOCATION
)
9428 return &tracepoint_probe_breakpoint_ops
;
9430 return &tracepoint_breakpoint_ops
;
9434 if (location_type
== PROBE_LOCATION
)
9435 return &bkpt_probe_breakpoint_ops
;
9437 return &bkpt_breakpoint_ops
;
9441 /* See breakpoint.h. */
9443 const struct breakpoint_ops
*
9444 breakpoint_ops_for_event_location (const struct event_location
*location
,
9447 if (location
!= nullptr)
9448 return breakpoint_ops_for_event_location_type
9449 (event_location_type (location
), is_tracepoint
);
9450 return is_tracepoint
? &tracepoint_breakpoint_ops
: &bkpt_breakpoint_ops
;
9453 /* See breakpoint.h. */
9456 create_breakpoint (struct gdbarch
*gdbarch
,
9457 struct event_location
*location
,
9458 const char *cond_string
,
9459 int thread
, const char *extra_string
,
9461 int tempflag
, enum bptype type_wanted
,
9463 enum auto_boolean pending_break_support
,
9464 const struct breakpoint_ops
*ops
,
9465 int from_tty
, int enabled
, int internal
,
9468 struct linespec_result canonical
;
9471 int prev_bkpt_count
= breakpoint_count
;
9473 gdb_assert (ops
!= NULL
);
9475 /* If extra_string isn't useful, set it to NULL. */
9476 if (extra_string
!= NULL
&& *extra_string
== '\0')
9477 extra_string
= NULL
;
9481 ops
->create_sals_from_location (location
, &canonical
, type_wanted
);
9483 catch (const gdb_exception_error
&e
)
9485 /* If caller is interested in rc value from parse, set
9487 if (e
.error
== NOT_FOUND_ERROR
)
9489 /* If pending breakpoint support is turned off, throw
9492 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
9495 exception_print (gdb_stderr
, e
);
9497 /* If pending breakpoint support is auto query and the user
9498 selects no, then simply return the error code. */
9499 if (pending_break_support
== AUTO_BOOLEAN_AUTO
9500 && !nquery (_("Make %s pending on future shared library load? "),
9501 bptype_string (type_wanted
)))
9504 /* At this point, either the user was queried about setting
9505 a pending breakpoint and selected yes, or pending
9506 breakpoint behavior is on and thus a pending breakpoint
9507 is defaulted on behalf of the user. */
9514 if (!pending
&& canonical
.lsals
.empty ())
9517 /* Resolve all line numbers to PC's and verify that the addresses
9518 are ok for the target. */
9521 for (auto &lsal
: canonical
.lsals
)
9522 breakpoint_sals_to_pc (lsal
.sals
);
9525 /* Fast tracepoints may have additional restrictions on location. */
9526 if (!pending
&& type_wanted
== bp_fast_tracepoint
)
9528 for (const auto &lsal
: canonical
.lsals
)
9529 check_fast_tracepoint_sals (gdbarch
, lsal
.sals
);
9532 /* Verify that condition can be parsed, before setting any
9533 breakpoints. Allocate a separate condition expression for each
9537 gdb::unique_xmalloc_ptr
<char> cond_string_copy
;
9538 gdb::unique_xmalloc_ptr
<char> extra_string_copy
;
9545 const linespec_sals
&lsal
= canonical
.lsals
[0];
9547 find_condition_and_thread_for_sals (lsal
.sals
, extra_string
,
9548 &cond
, &thread
, &task
, &rest
);
9549 cond_string_copy
.reset (cond
);
9550 extra_string_copy
.reset (rest
);
9554 if (type_wanted
!= bp_dprintf
9555 && extra_string
!= NULL
&& *extra_string
!= '\0')
9556 error (_("Garbage '%s' at end of location"), extra_string
);
9558 /* Create a private copy of condition string. */
9560 cond_string_copy
.reset (xstrdup (cond_string
));
9561 /* Create a private copy of any extra string. */
9563 extra_string_copy
.reset (xstrdup (extra_string
));
9566 ops
->create_breakpoints_sal (gdbarch
, &canonical
,
9567 std::move (cond_string_copy
),
9568 std::move (extra_string_copy
),
9570 tempflag
? disp_del
: disp_donttouch
,
9571 thread
, task
, ignore_count
, ops
,
9572 from_tty
, enabled
, internal
, flags
);
9576 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (type_wanted
);
9578 init_raw_breakpoint_without_location (b
.get (), gdbarch
, type_wanted
, ops
);
9579 b
->location
= copy_event_location (location
);
9582 b
->cond_string
= NULL
;
9585 /* Create a private copy of condition string. */
9586 b
->cond_string
= cond_string
!= NULL
? xstrdup (cond_string
) : NULL
;
9590 /* Create a private copy of any extra string. */
9591 b
->extra_string
= extra_string
!= NULL
? xstrdup (extra_string
) : NULL
;
9592 b
->ignore_count
= ignore_count
;
9593 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
9594 b
->condition_not_parsed
= 1;
9595 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
9596 if ((type_wanted
!= bp_breakpoint
9597 && type_wanted
!= bp_hardware_breakpoint
) || thread
!= -1)
9598 b
->pspace
= current_program_space
;
9600 install_breakpoint (internal
, std::move (b
), 0);
9603 if (canonical
.lsals
.size () > 1)
9605 warning (_("Multiple breakpoints were set.\nUse the "
9606 "\"delete\" command to delete unwanted breakpoints."));
9607 prev_breakpoint_count
= prev_bkpt_count
;
9610 update_global_location_list (UGLL_MAY_INSERT
);
9615 /* Set a breakpoint.
9616 ARG is a string describing breakpoint address,
9617 condition, and thread.
9618 FLAG specifies if a breakpoint is hardware on,
9619 and if breakpoint is temporary, using BP_HARDWARE_FLAG
9623 break_command_1 (const char *arg
, int flag
, int from_tty
)
9625 int tempflag
= flag
& BP_TEMPFLAG
;
9626 enum bptype type_wanted
= (flag
& BP_HARDWAREFLAG
9627 ? bp_hardware_breakpoint
9630 event_location_up location
= string_to_event_location (&arg
, current_language
);
9631 const struct breakpoint_ops
*ops
= breakpoint_ops_for_event_location
9632 (location
.get (), false /* is_tracepoint */);
9634 create_breakpoint (get_current_arch (),
9636 NULL
, 0, arg
, 1 /* parse arg */,
9637 tempflag
, type_wanted
,
9638 0 /* Ignore count */,
9639 pending_break_support
,
9647 /* Helper function for break_command_1 and disassemble_command. */
9650 resolve_sal_pc (struct symtab_and_line
*sal
)
9654 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
9656 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
9657 error (_("No line %d in file \"%s\"."),
9658 sal
->line
, symtab_to_filename_for_display (sal
->symtab
));
9661 /* If this SAL corresponds to a breakpoint inserted using a line
9662 number, then skip the function prologue if necessary. */
9663 if (sal
->explicit_line
)
9664 skip_prologue_sal (sal
);
9667 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
9669 const struct blockvector
*bv
;
9670 const struct block
*b
;
9673 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
,
9674 SYMTAB_COMPUNIT (sal
->symtab
));
9677 sym
= block_linkage_function (b
);
9680 fixup_symbol_section (sym
, SYMTAB_OBJFILE (sal
->symtab
));
9681 sal
->section
= SYMBOL_OBJ_SECTION (SYMTAB_OBJFILE (sal
->symtab
),
9686 /* It really is worthwhile to have the section, so we'll
9687 just have to look harder. This case can be executed
9688 if we have line numbers but no functions (as can
9689 happen in assembly source). */
9691 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
9692 switch_to_program_space_and_thread (sal
->pspace
);
9694 bound_minimal_symbol msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
9696 sal
->section
= MSYMBOL_OBJ_SECTION (msym
.objfile
, msym
.minsym
);
9703 break_command (const char *arg
, int from_tty
)
9705 break_command_1 (arg
, 0, from_tty
);
9709 tbreak_command (const char *arg
, int from_tty
)
9711 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
9715 hbreak_command (const char *arg
, int from_tty
)
9717 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
9721 thbreak_command (const char *arg
, int from_tty
)
9723 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
9727 stop_command (const char *arg
, int from_tty
)
9729 printf_filtered (_("Specify the type of breakpoint to set.\n\
9730 Usage: stop in <function | address>\n\
9731 stop at <line>\n"));
9735 stopin_command (const char *arg
, int from_tty
)
9741 else if (*arg
!= '*')
9743 const char *argptr
= arg
;
9746 /* Look for a ':'. If this is a line number specification, then
9747 say it is bad, otherwise, it should be an address or
9748 function/method name. */
9749 while (*argptr
&& !hasColon
)
9751 hasColon
= (*argptr
== ':');
9756 badInput
= (*argptr
!= ':'); /* Not a class::method */
9758 badInput
= isdigit (*arg
); /* a simple line number */
9762 printf_filtered (_("Usage: stop in <function | address>\n"));
9764 break_command_1 (arg
, 0, from_tty
);
9768 stopat_command (const char *arg
, int from_tty
)
9772 if (arg
== NULL
|| *arg
== '*') /* no line number */
9776 const char *argptr
= arg
;
9779 /* Look for a ':'. If there is a '::' then get out, otherwise
9780 it is probably a line number. */
9781 while (*argptr
&& !hasColon
)
9783 hasColon
= (*argptr
== ':');
9788 badInput
= (*argptr
== ':'); /* we have class::method */
9790 badInput
= !isdigit (*arg
); /* not a line number */
9794 printf_filtered (_("Usage: stop at LINE\n"));
9796 break_command_1 (arg
, 0, from_tty
);
9799 /* The dynamic printf command is mostly like a regular breakpoint, but
9800 with a prewired command list consisting of a single output command,
9801 built from extra arguments supplied on the dprintf command
9805 dprintf_command (const char *arg
, int from_tty
)
9807 event_location_up location
= string_to_event_location (&arg
, current_language
);
9809 /* If non-NULL, ARG should have been advanced past the location;
9810 the next character must be ','. */
9813 if (arg
[0] != ',' || arg
[1] == '\0')
9814 error (_("Format string required"));
9817 /* Skip the comma. */
9822 create_breakpoint (get_current_arch (),
9824 NULL
, 0, arg
, 1 /* parse arg */,
9826 0 /* Ignore count */,
9827 pending_break_support
,
9828 &dprintf_breakpoint_ops
,
9836 agent_printf_command (const char *arg
, int from_tty
)
9838 error (_("May only run agent-printf on the target"));
9841 /* Implement the "breakpoint_hit" breakpoint_ops method for
9842 ranged breakpoints. */
9845 breakpoint_hit_ranged_breakpoint (const struct bp_location
*bl
,
9846 const address_space
*aspace
,
9848 const struct target_waitstatus
*ws
)
9850 if (ws
->kind
!= TARGET_WAITKIND_STOPPED
9851 || ws
->value
.sig
!= GDB_SIGNAL_TRAP
)
9854 return breakpoint_address_match_range (bl
->pspace
->aspace
, bl
->address
,
9855 bl
->length
, aspace
, bp_addr
);
9858 /* Implement the "resources_needed" breakpoint_ops method for
9859 ranged breakpoints. */
9862 resources_needed_ranged_breakpoint (const struct bp_location
*bl
)
9864 return target_ranged_break_num_registers ();
9867 /* Implement the "print_it" breakpoint_ops method for
9868 ranged breakpoints. */
9870 static enum print_stop_action
9871 print_it_ranged_breakpoint (bpstat bs
)
9873 struct breakpoint
*b
= bs
->breakpoint_at
;
9874 struct bp_location
*bl
= b
->loc
;
9875 struct ui_out
*uiout
= current_uiout
;
9877 gdb_assert (b
->type
== bp_hardware_breakpoint
);
9879 /* Ranged breakpoints have only one location. */
9880 gdb_assert (bl
&& bl
->next
== NULL
);
9882 annotate_breakpoint (b
->number
);
9884 maybe_print_thread_hit_breakpoint (uiout
);
9886 if (b
->disposition
== disp_del
)
9887 uiout
->text ("Temporary ranged breakpoint ");
9889 uiout
->text ("Ranged breakpoint ");
9890 if (uiout
->is_mi_like_p ())
9892 uiout
->field_string ("reason",
9893 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
9894 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
9896 uiout
->field_signed ("bkptno", b
->number
);
9899 return PRINT_SRC_AND_LOC
;
9902 /* Implement the "print_one" breakpoint_ops method for
9903 ranged breakpoints. */
9906 print_one_ranged_breakpoint (struct breakpoint
*b
,
9907 struct bp_location
**last_loc
)
9909 struct bp_location
*bl
= b
->loc
;
9910 struct value_print_options opts
;
9911 struct ui_out
*uiout
= current_uiout
;
9913 /* Ranged breakpoints have only one location. */
9914 gdb_assert (bl
&& bl
->next
== NULL
);
9916 get_user_print_options (&opts
);
9918 if (opts
.addressprint
)
9919 /* We don't print the address range here, it will be printed later
9920 by print_one_detail_ranged_breakpoint. */
9921 uiout
->field_skip ("addr");
9923 print_breakpoint_location (b
, bl
);
9927 /* Implement the "print_one_detail" breakpoint_ops method for
9928 ranged breakpoints. */
9931 print_one_detail_ranged_breakpoint (const struct breakpoint
*b
,
9932 struct ui_out
*uiout
)
9934 CORE_ADDR address_start
, address_end
;
9935 struct bp_location
*bl
= b
->loc
;
9940 address_start
= bl
->address
;
9941 address_end
= address_start
+ bl
->length
- 1;
9943 uiout
->text ("\taddress range: ");
9944 stb
.printf ("[%s, %s]",
9945 print_core_address (bl
->gdbarch
, address_start
),
9946 print_core_address (bl
->gdbarch
, address_end
));
9947 uiout
->field_stream ("addr", stb
);
9951 /* Implement the "print_mention" breakpoint_ops method for
9952 ranged breakpoints. */
9955 print_mention_ranged_breakpoint (struct breakpoint
*b
)
9957 struct bp_location
*bl
= b
->loc
;
9958 struct ui_out
*uiout
= current_uiout
;
9961 gdb_assert (b
->type
== bp_hardware_breakpoint
);
9963 uiout
->message (_("Hardware assisted ranged breakpoint %d from %s to %s."),
9964 b
->number
, paddress (bl
->gdbarch
, bl
->address
),
9965 paddress (bl
->gdbarch
, bl
->address
+ bl
->length
- 1));
9968 /* Implement the "print_recreate" breakpoint_ops method for
9969 ranged breakpoints. */
9972 print_recreate_ranged_breakpoint (struct breakpoint
*b
, struct ui_file
*fp
)
9974 fprintf_unfiltered (fp
, "break-range %s, %s",
9975 event_location_to_string (b
->location
.get ()),
9976 event_location_to_string (b
->location_range_end
.get ()));
9977 print_recreate_thread (b
, fp
);
9980 /* The breakpoint_ops structure to be used in ranged breakpoints. */
9982 static struct breakpoint_ops ranged_breakpoint_ops
;
9984 /* Find the address where the end of the breakpoint range should be
9985 placed, given the SAL of the end of the range. This is so that if
9986 the user provides a line number, the end of the range is set to the
9987 last instruction of the given line. */
9990 find_breakpoint_range_end (struct symtab_and_line sal
)
9994 /* If the user provided a PC value, use it. Otherwise,
9995 find the address of the end of the given location. */
9996 if (sal
.explicit_pc
)
10003 ret
= find_line_pc_range (sal
, &start
, &end
);
10005 error (_("Could not find location of the end of the range."));
10007 /* find_line_pc_range returns the start of the next line. */
10014 /* Implement the "break-range" CLI command. */
10017 break_range_command (const char *arg
, int from_tty
)
10019 const char *arg_start
;
10020 struct linespec_result canonical_start
, canonical_end
;
10021 int bp_count
, can_use_bp
, length
;
10023 struct breakpoint
*b
;
10025 /* We don't support software ranged breakpoints. */
10026 if (target_ranged_break_num_registers () < 0)
10027 error (_("This target does not support hardware ranged breakpoints."));
10029 bp_count
= hw_breakpoint_used_count ();
10030 bp_count
+= target_ranged_break_num_registers ();
10031 can_use_bp
= target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
10033 if (can_use_bp
< 0)
10034 error (_("Hardware breakpoints used exceeds limit."));
10036 arg
= skip_spaces (arg
);
10037 if (arg
== NULL
|| arg
[0] == '\0')
10038 error(_("No address range specified."));
10041 event_location_up start_location
= string_to_event_location (&arg
,
10043 parse_breakpoint_sals (start_location
.get (), &canonical_start
);
10046 error (_("Too few arguments."));
10047 else if (canonical_start
.lsals
.empty ())
10048 error (_("Could not find location of the beginning of the range."));
10050 const linespec_sals
&lsal_start
= canonical_start
.lsals
[0];
10052 if (canonical_start
.lsals
.size () > 1
10053 || lsal_start
.sals
.size () != 1)
10054 error (_("Cannot create a ranged breakpoint with multiple locations."));
10056 const symtab_and_line
&sal_start
= lsal_start
.sals
[0];
10057 std::string
addr_string_start (arg_start
, arg
- arg_start
);
10059 arg
++; /* Skip the comma. */
10060 arg
= skip_spaces (arg
);
10062 /* Parse the end location. */
10066 /* We call decode_line_full directly here instead of using
10067 parse_breakpoint_sals because we need to specify the start location's
10068 symtab and line as the default symtab and line for the end of the
10069 range. This makes it possible to have ranges like "foo.c:27, +14",
10070 where +14 means 14 lines from the start location. */
10071 event_location_up end_location
= string_to_event_location (&arg
,
10073 decode_line_full (end_location
.get (), DECODE_LINE_FUNFIRSTLINE
, NULL
,
10074 sal_start
.symtab
, sal_start
.line
,
10075 &canonical_end
, NULL
, NULL
);
10077 if (canonical_end
.lsals
.empty ())
10078 error (_("Could not find location of the end of the range."));
10080 const linespec_sals
&lsal_end
= canonical_end
.lsals
[0];
10081 if (canonical_end
.lsals
.size () > 1
10082 || lsal_end
.sals
.size () != 1)
10083 error (_("Cannot create a ranged breakpoint with multiple locations."));
10085 const symtab_and_line
&sal_end
= lsal_end
.sals
[0];
10087 end
= find_breakpoint_range_end (sal_end
);
10088 if (sal_start
.pc
> end
)
10089 error (_("Invalid address range, end precedes start."));
10091 length
= end
- sal_start
.pc
+ 1;
10093 /* Length overflowed. */
10094 error (_("Address range too large."));
10095 else if (length
== 1)
10097 /* This range is simple enough to be handled by
10098 the `hbreak' command. */
10099 hbreak_command (&addr_string_start
[0], 1);
10104 /* Now set up the breakpoint. */
10105 b
= set_raw_breakpoint (get_current_arch (), sal_start
,
10106 bp_hardware_breakpoint
, &ranged_breakpoint_ops
);
10107 set_breakpoint_count (breakpoint_count
+ 1);
10108 b
->number
= breakpoint_count
;
10109 b
->disposition
= disp_donttouch
;
10110 b
->location
= std::move (start_location
);
10111 b
->location_range_end
= std::move (end_location
);
10112 b
->loc
->length
= length
;
10115 gdb::observers::breakpoint_created
.notify (b
);
10116 update_global_location_list (UGLL_MAY_INSERT
);
10119 /* Return non-zero if EXP is verified as constant. Returned zero
10120 means EXP is variable. Also the constant detection may fail for
10121 some constant expressions and in such case still falsely return
10125 watchpoint_exp_is_const (const struct expression
*exp
)
10127 int i
= exp
->nelts
;
10133 /* We are only interested in the descriptor of each element. */
10134 operator_length (exp
, i
, &oplenp
, &argsp
);
10137 switch (exp
->elts
[i
].opcode
)
10147 case BINOP_LOGICAL_AND
:
10148 case BINOP_LOGICAL_OR
:
10149 case BINOP_BITWISE_AND
:
10150 case BINOP_BITWISE_IOR
:
10151 case BINOP_BITWISE_XOR
:
10153 case BINOP_NOTEQUAL
:
10179 case OP_OBJC_NSSTRING
:
10182 case UNOP_LOGICAL_NOT
:
10183 case UNOP_COMPLEMENT
:
10188 case UNOP_CAST_TYPE
:
10189 case UNOP_REINTERPRET_CAST
:
10190 case UNOP_DYNAMIC_CAST
:
10191 /* Unary, binary and ternary operators: We have to check
10192 their operands. If they are constant, then so is the
10193 result of that operation. For instance, if A and B are
10194 determined to be constants, then so is "A + B".
10196 UNOP_IND is one exception to the rule above, because the
10197 value of *ADDR is not necessarily a constant, even when
10202 /* Check whether the associated symbol is a constant.
10204 We use SYMBOL_CLASS rather than TYPE_CONST because it's
10205 possible that a buggy compiler could mark a variable as
10206 constant even when it is not, and TYPE_CONST would return
10207 true in this case, while SYMBOL_CLASS wouldn't.
10209 We also have to check for function symbols because they
10210 are always constant. */
10212 struct symbol
*s
= exp
->elts
[i
+ 2].symbol
;
10214 if (SYMBOL_CLASS (s
) != LOC_BLOCK
10215 && SYMBOL_CLASS (s
) != LOC_CONST
10216 && SYMBOL_CLASS (s
) != LOC_CONST_BYTES
)
10221 /* The default action is to return 0 because we are using
10222 the optimistic approach here: If we don't know something,
10223 then it is not a constant. */
10232 /* Watchpoint destructor. */
10234 watchpoint::~watchpoint ()
10236 xfree (this->exp_string
);
10237 xfree (this->exp_string_reparse
);
10240 /* Implement the "re_set" breakpoint_ops method for watchpoints. */
10243 re_set_watchpoint (struct breakpoint
*b
)
10245 struct watchpoint
*w
= (struct watchpoint
*) b
;
10247 /* Watchpoint can be either on expression using entirely global
10248 variables, or it can be on local variables.
10250 Watchpoints of the first kind are never auto-deleted, and even
10251 persist across program restarts. Since they can use variables
10252 from shared libraries, we need to reparse expression as libraries
10253 are loaded and unloaded.
10255 Watchpoints on local variables can also change meaning as result
10256 of solib event. For example, if a watchpoint uses both a local
10257 and a global variables in expression, it's a local watchpoint,
10258 but unloading of a shared library will make the expression
10259 invalid. This is not a very common use case, but we still
10260 re-evaluate expression, to avoid surprises to the user.
10262 Note that for local watchpoints, we re-evaluate it only if
10263 watchpoints frame id is still valid. If it's not, it means the
10264 watchpoint is out of scope and will be deleted soon. In fact,
10265 I'm not sure we'll ever be called in this case.
10267 If a local watchpoint's frame id is still valid, then
10268 w->exp_valid_block is likewise valid, and we can safely use it.
10270 Don't do anything about disabled watchpoints, since they will be
10271 reevaluated again when enabled. */
10272 update_watchpoint (w
, 1 /* reparse */);
10275 /* Implement the "insert" breakpoint_ops method for hardware watchpoints. */
10278 insert_watchpoint (struct bp_location
*bl
)
10280 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10281 int length
= w
->exact
? 1 : bl
->length
;
10283 return target_insert_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
10284 w
->cond_exp
.get ());
10287 /* Implement the "remove" breakpoint_ops method for hardware watchpoints. */
10290 remove_watchpoint (struct bp_location
*bl
, enum remove_bp_reason reason
)
10292 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10293 int length
= w
->exact
? 1 : bl
->length
;
10295 return target_remove_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
10296 w
->cond_exp
.get ());
10300 breakpoint_hit_watchpoint (const struct bp_location
*bl
,
10301 const address_space
*aspace
, CORE_ADDR bp_addr
,
10302 const struct target_waitstatus
*ws
)
10304 struct breakpoint
*b
= bl
->owner
;
10305 struct watchpoint
*w
= (struct watchpoint
*) b
;
10307 /* Continuable hardware watchpoints are treated as non-existent if the
10308 reason we stopped wasn't a hardware watchpoint (we didn't stop on
10309 some data address). Otherwise gdb won't stop on a break instruction
10310 in the code (not from a breakpoint) when a hardware watchpoint has
10311 been defined. Also skip watchpoints which we know did not trigger
10312 (did not match the data address). */
10313 if (is_hardware_watchpoint (b
)
10314 && w
->watchpoint_triggered
== watch_triggered_no
)
10321 check_status_watchpoint (bpstat bs
)
10323 gdb_assert (is_watchpoint (bs
->breakpoint_at
));
10325 bpstat_check_watchpoint (bs
);
10328 /* Implement the "resources_needed" breakpoint_ops method for
10329 hardware watchpoints. */
10332 resources_needed_watchpoint (const struct bp_location
*bl
)
10334 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10335 int length
= w
->exact
? 1 : bl
->length
;
10337 return target_region_ok_for_hw_watchpoint (bl
->address
, length
);
10340 /* Implement the "works_in_software_mode" breakpoint_ops method for
10341 hardware watchpoints. */
10344 works_in_software_mode_watchpoint (const struct breakpoint
*b
)
10346 /* Read and access watchpoints only work with hardware support. */
10347 return b
->type
== bp_watchpoint
|| b
->type
== bp_hardware_watchpoint
;
10350 static enum print_stop_action
10351 print_it_watchpoint (bpstat bs
)
10353 struct breakpoint
*b
;
10354 enum print_stop_action result
;
10355 struct watchpoint
*w
;
10356 struct ui_out
*uiout
= current_uiout
;
10358 gdb_assert (bs
->bp_location_at
!= NULL
);
10360 b
= bs
->breakpoint_at
;
10361 w
= (struct watchpoint
*) b
;
10363 annotate_watchpoint (b
->number
);
10364 maybe_print_thread_hit_breakpoint (uiout
);
10368 gdb::optional
<ui_out_emit_tuple
> tuple_emitter
;
10371 case bp_watchpoint
:
10372 case bp_hardware_watchpoint
:
10373 if (uiout
->is_mi_like_p ())
10374 uiout
->field_string
10375 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
10377 tuple_emitter
.emplace (uiout
, "value");
10378 uiout
->text ("\nOld value = ");
10379 watchpoint_value_print (bs
->old_val
.get (), &stb
);
10380 uiout
->field_stream ("old", stb
);
10381 uiout
->text ("\nNew value = ");
10382 watchpoint_value_print (w
->val
.get (), &stb
);
10383 uiout
->field_stream ("new", stb
);
10384 uiout
->text ("\n");
10385 /* More than one watchpoint may have been triggered. */
10386 result
= PRINT_UNKNOWN
;
10389 case bp_read_watchpoint
:
10390 if (uiout
->is_mi_like_p ())
10391 uiout
->field_string
10392 ("reason", async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
10394 tuple_emitter
.emplace (uiout
, "value");
10395 uiout
->text ("\nValue = ");
10396 watchpoint_value_print (w
->val
.get (), &stb
);
10397 uiout
->field_stream ("value", stb
);
10398 uiout
->text ("\n");
10399 result
= PRINT_UNKNOWN
;
10402 case bp_access_watchpoint
:
10403 if (bs
->old_val
!= NULL
)
10405 if (uiout
->is_mi_like_p ())
10406 uiout
->field_string
10408 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
10410 tuple_emitter
.emplace (uiout
, "value");
10411 uiout
->text ("\nOld value = ");
10412 watchpoint_value_print (bs
->old_val
.get (), &stb
);
10413 uiout
->field_stream ("old", stb
);
10414 uiout
->text ("\nNew value = ");
10419 if (uiout
->is_mi_like_p ())
10420 uiout
->field_string
10422 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
10423 tuple_emitter
.emplace (uiout
, "value");
10424 uiout
->text ("\nValue = ");
10426 watchpoint_value_print (w
->val
.get (), &stb
);
10427 uiout
->field_stream ("new", stb
);
10428 uiout
->text ("\n");
10429 result
= PRINT_UNKNOWN
;
10432 result
= PRINT_UNKNOWN
;
10438 /* Implement the "print_mention" breakpoint_ops method for hardware
10442 print_mention_watchpoint (struct breakpoint
*b
)
10444 struct watchpoint
*w
= (struct watchpoint
*) b
;
10445 struct ui_out
*uiout
= current_uiout
;
10446 const char *tuple_name
;
10450 case bp_watchpoint
:
10451 uiout
->text ("Watchpoint ");
10452 tuple_name
= "wpt";
10454 case bp_hardware_watchpoint
:
10455 uiout
->text ("Hardware watchpoint ");
10456 tuple_name
= "wpt";
10458 case bp_read_watchpoint
:
10459 uiout
->text ("Hardware read watchpoint ");
10460 tuple_name
= "hw-rwpt";
10462 case bp_access_watchpoint
:
10463 uiout
->text ("Hardware access (read/write) watchpoint ");
10464 tuple_name
= "hw-awpt";
10467 internal_error (__FILE__
, __LINE__
,
10468 _("Invalid hardware watchpoint type."));
10471 ui_out_emit_tuple
tuple_emitter (uiout
, tuple_name
);
10472 uiout
->field_signed ("number", b
->number
);
10473 uiout
->text (": ");
10474 uiout
->field_string ("exp", w
->exp_string
);
10477 /* Implement the "print_recreate" breakpoint_ops method for
10481 print_recreate_watchpoint (struct breakpoint
*b
, struct ui_file
*fp
)
10483 struct watchpoint
*w
= (struct watchpoint
*) b
;
10487 case bp_watchpoint
:
10488 case bp_hardware_watchpoint
:
10489 fprintf_unfiltered (fp
, "watch");
10491 case bp_read_watchpoint
:
10492 fprintf_unfiltered (fp
, "rwatch");
10494 case bp_access_watchpoint
:
10495 fprintf_unfiltered (fp
, "awatch");
10498 internal_error (__FILE__
, __LINE__
,
10499 _("Invalid watchpoint type."));
10502 fprintf_unfiltered (fp
, " %s", w
->exp_string
);
10503 print_recreate_thread (b
, fp
);
10506 /* Implement the "explains_signal" breakpoint_ops method for
10510 explains_signal_watchpoint (struct breakpoint
*b
, enum gdb_signal sig
)
10512 /* A software watchpoint cannot cause a signal other than
10513 GDB_SIGNAL_TRAP. */
10514 if (b
->type
== bp_watchpoint
&& sig
!= GDB_SIGNAL_TRAP
)
10520 /* The breakpoint_ops structure to be used in hardware watchpoints. */
10522 static struct breakpoint_ops watchpoint_breakpoint_ops
;
10524 /* Implement the "insert" breakpoint_ops method for
10525 masked hardware watchpoints. */
10528 insert_masked_watchpoint (struct bp_location
*bl
)
10530 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10532 return target_insert_mask_watchpoint (bl
->address
, w
->hw_wp_mask
,
10533 bl
->watchpoint_type
);
10536 /* Implement the "remove" breakpoint_ops method for
10537 masked hardware watchpoints. */
10540 remove_masked_watchpoint (struct bp_location
*bl
, enum remove_bp_reason reason
)
10542 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10544 return target_remove_mask_watchpoint (bl
->address
, w
->hw_wp_mask
,
10545 bl
->watchpoint_type
);
10548 /* Implement the "resources_needed" breakpoint_ops method for
10549 masked hardware watchpoints. */
10552 resources_needed_masked_watchpoint (const struct bp_location
*bl
)
10554 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10556 return target_masked_watch_num_registers (bl
->address
, w
->hw_wp_mask
);
10559 /* Implement the "works_in_software_mode" breakpoint_ops method for
10560 masked hardware watchpoints. */
10563 works_in_software_mode_masked_watchpoint (const struct breakpoint
*b
)
10568 /* Implement the "print_it" breakpoint_ops method for
10569 masked hardware watchpoints. */
10571 static enum print_stop_action
10572 print_it_masked_watchpoint (bpstat bs
)
10574 struct breakpoint
*b
= bs
->breakpoint_at
;
10575 struct ui_out
*uiout
= current_uiout
;
10577 /* Masked watchpoints have only one location. */
10578 gdb_assert (b
->loc
&& b
->loc
->next
== NULL
);
10580 annotate_watchpoint (b
->number
);
10581 maybe_print_thread_hit_breakpoint (uiout
);
10585 case bp_hardware_watchpoint
:
10586 if (uiout
->is_mi_like_p ())
10587 uiout
->field_string
10588 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
10591 case bp_read_watchpoint
:
10592 if (uiout
->is_mi_like_p ())
10593 uiout
->field_string
10594 ("reason", async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
10597 case bp_access_watchpoint
:
10598 if (uiout
->is_mi_like_p ())
10599 uiout
->field_string
10601 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
10604 internal_error (__FILE__
, __LINE__
,
10605 _("Invalid hardware watchpoint type."));
10609 uiout
->text (_("\n\
10610 Check the underlying instruction at PC for the memory\n\
10611 address and value which triggered this watchpoint.\n"));
10612 uiout
->text ("\n");
10614 /* More than one watchpoint may have been triggered. */
10615 return PRINT_UNKNOWN
;
10618 /* Implement the "print_one_detail" breakpoint_ops method for
10619 masked hardware watchpoints. */
10622 print_one_detail_masked_watchpoint (const struct breakpoint
*b
,
10623 struct ui_out
*uiout
)
10625 struct watchpoint
*w
= (struct watchpoint
*) b
;
10627 /* Masked watchpoints have only one location. */
10628 gdb_assert (b
->loc
&& b
->loc
->next
== NULL
);
10630 uiout
->text ("\tmask ");
10631 uiout
->field_core_addr ("mask", b
->loc
->gdbarch
, w
->hw_wp_mask
);
10632 uiout
->text ("\n");
10635 /* Implement the "print_mention" breakpoint_ops method for
10636 masked hardware watchpoints. */
10639 print_mention_masked_watchpoint (struct breakpoint
*b
)
10641 struct watchpoint
*w
= (struct watchpoint
*) b
;
10642 struct ui_out
*uiout
= current_uiout
;
10643 const char *tuple_name
;
10647 case bp_hardware_watchpoint
:
10648 uiout
->text ("Masked hardware watchpoint ");
10649 tuple_name
= "wpt";
10651 case bp_read_watchpoint
:
10652 uiout
->text ("Masked hardware read watchpoint ");
10653 tuple_name
= "hw-rwpt";
10655 case bp_access_watchpoint
:
10656 uiout
->text ("Masked hardware access (read/write) watchpoint ");
10657 tuple_name
= "hw-awpt";
10660 internal_error (__FILE__
, __LINE__
,
10661 _("Invalid hardware watchpoint type."));
10664 ui_out_emit_tuple
tuple_emitter (uiout
, tuple_name
);
10665 uiout
->field_signed ("number", b
->number
);
10666 uiout
->text (": ");
10667 uiout
->field_string ("exp", w
->exp_string
);
10670 /* Implement the "print_recreate" breakpoint_ops method for
10671 masked hardware watchpoints. */
10674 print_recreate_masked_watchpoint (struct breakpoint
*b
, struct ui_file
*fp
)
10676 struct watchpoint
*w
= (struct watchpoint
*) b
;
10680 case bp_hardware_watchpoint
:
10681 fprintf_unfiltered (fp
, "watch");
10683 case bp_read_watchpoint
:
10684 fprintf_unfiltered (fp
, "rwatch");
10686 case bp_access_watchpoint
:
10687 fprintf_unfiltered (fp
, "awatch");
10690 internal_error (__FILE__
, __LINE__
,
10691 _("Invalid hardware watchpoint type."));
10694 fprintf_unfiltered (fp
, " %s mask 0x%s", w
->exp_string
,
10695 phex (w
->hw_wp_mask
, sizeof (CORE_ADDR
)));
10696 print_recreate_thread (b
, fp
);
10699 /* The breakpoint_ops structure to be used in masked hardware watchpoints. */
10701 static struct breakpoint_ops masked_watchpoint_breakpoint_ops
;
10703 /* Tell whether the given watchpoint is a masked hardware watchpoint. */
10706 is_masked_watchpoint (const struct breakpoint
*b
)
10708 return b
->ops
== &masked_watchpoint_breakpoint_ops
;
10711 /* accessflag: hw_write: watch write,
10712 hw_read: watch read,
10713 hw_access: watch access (read or write) */
10715 watch_command_1 (const char *arg
, int accessflag
, int from_tty
,
10716 bool just_location
, bool internal
)
10718 struct breakpoint
*scope_breakpoint
= NULL
;
10719 const struct block
*exp_valid_block
= NULL
, *cond_exp_valid_block
= NULL
;
10720 struct value
*result
;
10721 int saved_bitpos
= 0, saved_bitsize
= 0;
10722 const char *exp_start
= NULL
;
10723 const char *exp_end
= NULL
;
10724 const char *tok
, *end_tok
;
10726 const char *cond_start
= NULL
;
10727 const char *cond_end
= NULL
;
10728 enum bptype bp_type
;
10731 /* Flag to indicate whether we are going to use masks for
10732 the hardware watchpoint. */
10733 bool use_mask
= false;
10734 CORE_ADDR mask
= 0;
10736 /* Make sure that we actually have parameters to parse. */
10737 if (arg
!= NULL
&& arg
[0] != '\0')
10739 const char *value_start
;
10741 exp_end
= arg
+ strlen (arg
);
10743 /* Look for "parameter value" pairs at the end
10744 of the arguments string. */
10745 for (tok
= exp_end
- 1; tok
> arg
; tok
--)
10747 /* Skip whitespace at the end of the argument list. */
10748 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
10751 /* Find the beginning of the last token.
10752 This is the value of the parameter. */
10753 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
10755 value_start
= tok
+ 1;
10757 /* Skip whitespace. */
10758 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
10763 /* Find the beginning of the second to last token.
10764 This is the parameter itself. */
10765 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
10768 toklen
= end_tok
- tok
+ 1;
10770 if (toklen
== 6 && startswith (tok
, "thread"))
10772 struct thread_info
*thr
;
10773 /* At this point we've found a "thread" token, which means
10774 the user is trying to set a watchpoint that triggers
10775 only in a specific thread. */
10779 error(_("You can specify only one thread."));
10781 /* Extract the thread ID from the next token. */
10782 thr
= parse_thread_id (value_start
, &endp
);
10784 /* Check if the user provided a valid thread ID. */
10785 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
10786 invalid_thread_id_error (value_start
);
10788 thread
= thr
->global_num
;
10790 else if (toklen
== 4 && startswith (tok
, "mask"))
10792 /* We've found a "mask" token, which means the user wants to
10793 create a hardware watchpoint that is going to have the mask
10795 struct value
*mask_value
, *mark
;
10798 error(_("You can specify only one mask."));
10800 use_mask
= just_location
= true;
10802 mark
= value_mark ();
10803 mask_value
= parse_to_comma_and_eval (&value_start
);
10804 mask
= value_as_address (mask_value
);
10805 value_free_to_mark (mark
);
10808 /* We didn't recognize what we found. We should stop here. */
10811 /* Truncate the string and get rid of the "parameter value" pair before
10812 the arguments string is parsed by the parse_exp_1 function. */
10819 /* Parse the rest of the arguments. From here on out, everything
10820 is in terms of a newly allocated string instead of the original
10822 std::string
expression (arg
, exp_end
- arg
);
10823 exp_start
= arg
= expression
.c_str ();
10824 innermost_block_tracker tracker
;
10825 expression_up exp
= parse_exp_1 (&arg
, 0, 0, 0, &tracker
);
10827 /* Remove trailing whitespace from the expression before saving it.
10828 This makes the eventual display of the expression string a bit
10830 while (exp_end
> exp_start
&& (exp_end
[-1] == ' ' || exp_end
[-1] == '\t'))
10833 /* Checking if the expression is not constant. */
10834 if (watchpoint_exp_is_const (exp
.get ()))
10838 len
= exp_end
- exp_start
;
10839 while (len
> 0 && isspace (exp_start
[len
- 1]))
10841 error (_("Cannot watch constant value `%.*s'."), len
, exp_start
);
10844 exp_valid_block
= tracker
.block ();
10845 struct value
*mark
= value_mark ();
10846 struct value
*val_as_value
= nullptr;
10847 fetch_subexp_value (exp
.get (), &pc
, &val_as_value
, &result
, NULL
,
10850 if (val_as_value
!= NULL
&& just_location
)
10852 saved_bitpos
= value_bitpos (val_as_value
);
10853 saved_bitsize
= value_bitsize (val_as_value
);
10861 exp_valid_block
= NULL
;
10862 val
= release_value (value_addr (result
));
10863 value_free_to_mark (mark
);
10867 ret
= target_masked_watch_num_registers (value_as_address (val
.get ()),
10870 error (_("This target does not support masked watchpoints."));
10871 else if (ret
== -2)
10872 error (_("Invalid mask or memory region."));
10875 else if (val_as_value
!= NULL
)
10876 val
= release_value (val_as_value
);
10878 tok
= skip_spaces (arg
);
10879 end_tok
= skip_to_space (tok
);
10881 toklen
= end_tok
- tok
;
10882 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
10884 tok
= cond_start
= end_tok
+ 1;
10885 innermost_block_tracker if_tracker
;
10886 parse_exp_1 (&tok
, 0, 0, 0, &if_tracker
);
10888 /* The watchpoint expression may not be local, but the condition
10889 may still be. E.g.: `watch global if local > 0'. */
10890 cond_exp_valid_block
= if_tracker
.block ();
10895 error (_("Junk at end of command."));
10897 frame_info
*wp_frame
= block_innermost_frame (exp_valid_block
);
10899 /* Save this because create_internal_breakpoint below invalidates
10901 frame_id watchpoint_frame
= get_frame_id (wp_frame
);
10903 /* If the expression is "local", then set up a "watchpoint scope"
10904 breakpoint at the point where we've left the scope of the watchpoint
10905 expression. Create the scope breakpoint before the watchpoint, so
10906 that we will encounter it first in bpstat_stop_status. */
10907 if (exp_valid_block
!= NULL
&& wp_frame
!= NULL
)
10909 frame_id caller_frame_id
= frame_unwind_caller_id (wp_frame
);
10911 if (frame_id_p (caller_frame_id
))
10913 gdbarch
*caller_arch
= frame_unwind_caller_arch (wp_frame
);
10914 CORE_ADDR caller_pc
= frame_unwind_caller_pc (wp_frame
);
10917 = create_internal_breakpoint (caller_arch
, caller_pc
,
10918 bp_watchpoint_scope
,
10919 &momentary_breakpoint_ops
);
10921 /* create_internal_breakpoint could invalidate WP_FRAME. */
10924 scope_breakpoint
->enable_state
= bp_enabled
;
10926 /* Automatically delete the breakpoint when it hits. */
10927 scope_breakpoint
->disposition
= disp_del
;
10929 /* Only break in the proper frame (help with recursion). */
10930 scope_breakpoint
->frame_id
= caller_frame_id
;
10932 /* Set the address at which we will stop. */
10933 scope_breakpoint
->loc
->gdbarch
= caller_arch
;
10934 scope_breakpoint
->loc
->requested_address
= caller_pc
;
10935 scope_breakpoint
->loc
->address
10936 = adjust_breakpoint_address (scope_breakpoint
->loc
->gdbarch
,
10937 scope_breakpoint
->loc
->requested_address
,
10938 scope_breakpoint
->type
);
10942 /* Now set up the breakpoint. We create all watchpoints as hardware
10943 watchpoints here even if hardware watchpoints are turned off, a call
10944 to update_watchpoint later in this function will cause the type to
10945 drop back to bp_watchpoint (software watchpoint) if required. */
10947 if (accessflag
== hw_read
)
10948 bp_type
= bp_read_watchpoint
;
10949 else if (accessflag
== hw_access
)
10950 bp_type
= bp_access_watchpoint
;
10952 bp_type
= bp_hardware_watchpoint
;
10954 std::unique_ptr
<watchpoint
> w (new watchpoint ());
10957 init_raw_breakpoint_without_location (w
.get (), NULL
, bp_type
,
10958 &masked_watchpoint_breakpoint_ops
);
10960 init_raw_breakpoint_without_location (w
.get (), NULL
, bp_type
,
10961 &watchpoint_breakpoint_ops
);
10962 w
->thread
= thread
;
10963 w
->disposition
= disp_donttouch
;
10964 w
->pspace
= current_program_space
;
10965 w
->exp
= std::move (exp
);
10966 w
->exp_valid_block
= exp_valid_block
;
10967 w
->cond_exp_valid_block
= cond_exp_valid_block
;
10970 struct type
*t
= value_type (val
.get ());
10971 CORE_ADDR addr
= value_as_address (val
.get ());
10973 w
->exp_string_reparse
10974 = current_language
->watch_location_expression (t
, addr
).release ();
10976 w
->exp_string
= xstrprintf ("-location %.*s",
10977 (int) (exp_end
- exp_start
), exp_start
);
10980 w
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
10984 w
->hw_wp_mask
= mask
;
10989 w
->val_bitpos
= saved_bitpos
;
10990 w
->val_bitsize
= saved_bitsize
;
10991 w
->val_valid
= true;
10995 w
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
10997 w
->cond_string
= 0;
10999 if (frame_id_p (watchpoint_frame
))
11001 w
->watchpoint_frame
= watchpoint_frame
;
11002 w
->watchpoint_thread
= inferior_ptid
;
11006 w
->watchpoint_frame
= null_frame_id
;
11007 w
->watchpoint_thread
= null_ptid
;
11010 if (scope_breakpoint
!= NULL
)
11012 /* The scope breakpoint is related to the watchpoint. We will
11013 need to act on them together. */
11014 w
->related_breakpoint
= scope_breakpoint
;
11015 scope_breakpoint
->related_breakpoint
= w
.get ();
11018 if (!just_location
)
11019 value_free_to_mark (mark
);
11021 /* Finally update the new watchpoint. This creates the locations
11022 that should be inserted. */
11023 update_watchpoint (w
.get (), 1);
11025 install_breakpoint (internal
, std::move (w
), 1);
11028 /* Return count of debug registers needed to watch the given expression.
11029 If the watchpoint cannot be handled in hardware return zero. */
11032 can_use_hardware_watchpoint (const std::vector
<value_ref_ptr
> &vals
)
11034 int found_memory_cnt
= 0;
11036 /* Did the user specifically forbid us to use hardware watchpoints? */
11037 if (!can_use_hw_watchpoints
)
11040 gdb_assert (!vals
.empty ());
11041 struct value
*head
= vals
[0].get ();
11043 /* Make sure that the value of the expression depends only upon
11044 memory contents, and values computed from them within GDB. If we
11045 find any register references or function calls, we can't use a
11046 hardware watchpoint.
11048 The idea here is that evaluating an expression generates a series
11049 of values, one holding the value of every subexpression. (The
11050 expression a*b+c has five subexpressions: a, b, a*b, c, and
11051 a*b+c.) GDB's values hold almost enough information to establish
11052 the criteria given above --- they identify memory lvalues,
11053 register lvalues, computed values, etcetera. So we can evaluate
11054 the expression, and then scan the chain of values that leaves
11055 behind to decide whether we can detect any possible change to the
11056 expression's final value using only hardware watchpoints.
11058 However, I don't think that the values returned by inferior
11059 function calls are special in any way. So this function may not
11060 notice that an expression involving an inferior function call
11061 can't be watched with hardware watchpoints. FIXME. */
11062 for (const value_ref_ptr
&iter
: vals
)
11064 struct value
*v
= iter
.get ();
11066 if (VALUE_LVAL (v
) == lval_memory
)
11068 if (v
!= head
&& value_lazy (v
))
11069 /* A lazy memory lvalue in the chain is one that GDB never
11070 needed to fetch; we either just used its address (e.g.,
11071 `a' in `a.b') or we never needed it at all (e.g., `a'
11072 in `a,b'). This doesn't apply to HEAD; if that is
11073 lazy then it was not readable, but watch it anyway. */
11077 /* Ahh, memory we actually used! Check if we can cover
11078 it with hardware watchpoints. */
11079 struct type
*vtype
= check_typedef (value_type (v
));
11081 /* We only watch structs and arrays if user asked for it
11082 explicitly, never if they just happen to appear in a
11083 middle of some value chain. */
11085 || (vtype
->code () != TYPE_CODE_STRUCT
11086 && vtype
->code () != TYPE_CODE_ARRAY
))
11088 CORE_ADDR vaddr
= value_address (v
);
11092 len
= (target_exact_watchpoints
11093 && is_scalar_type_recursive (vtype
))?
11094 1 : TYPE_LENGTH (value_type (v
));
11096 num_regs
= target_region_ok_for_hw_watchpoint (vaddr
, len
);
11100 found_memory_cnt
+= num_regs
;
11104 else if (VALUE_LVAL (v
) != not_lval
11105 && deprecated_value_modifiable (v
) == 0)
11106 return 0; /* These are values from the history (e.g., $1). */
11107 else if (VALUE_LVAL (v
) == lval_register
)
11108 return 0; /* Cannot watch a register with a HW watchpoint. */
11111 /* The expression itself looks suitable for using a hardware
11112 watchpoint, but give the target machine a chance to reject it. */
11113 return found_memory_cnt
;
11117 watch_command_wrapper (const char *arg
, int from_tty
, bool internal
)
11119 watch_command_1 (arg
, hw_write
, from_tty
, 0, internal
);
11122 /* Options for the watch, awatch, and rwatch commands. */
11124 struct watch_options
11126 /* For -location. */
11127 bool location
= false;
11130 /* Definitions of options for the "watch", "awatch", and "rwatch" commands.
11132 Historically GDB always accepted both '-location' and '-l' flags for
11133 these commands (both flags being synonyms). When converting to the
11134 newer option scheme only '-location' is added here. That's fine (for
11135 backward compatibility) as any non-ambiguous prefix of a flag will be
11136 accepted, so '-l', '-loc', are now all accepted.
11138 What this means is that, if in the future, we add any new flag here
11139 that starts with '-l' then this will break backward compatibility, so
11140 please, don't do that! */
11142 static const gdb::option::option_def watch_option_defs
[] = {
11143 gdb::option::flag_option_def
<watch_options
> {
11145 [] (watch_options
*opt
) { return &opt
->location
; },
11147 This evaluates EXPRESSION and watches the memory to which is refers.\n\
11148 -l can be used as a short form of -location."),
11152 /* Returns the option group used by 'watch', 'awatch', and 'rwatch'
11155 static gdb::option::option_def_group
11156 make_watch_options_def_group (watch_options
*opts
)
11158 return {{watch_option_defs
}, opts
};
11161 /* A helper function that looks for the "-location" argument and then
11162 calls watch_command_1. */
11165 watch_maybe_just_location (const char *arg
, int accessflag
, int from_tty
)
11167 watch_options opts
;
11168 auto grp
= make_watch_options_def_group (&opts
);
11169 gdb::option::process_options
11170 (&arg
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
11171 if (arg
!= nullptr && *arg
== '\0')
11174 watch_command_1 (arg
, accessflag
, from_tty
, opts
.location
, false);
11177 /* Command completion for 'watch', 'awatch', and 'rwatch' commands. */
11179 watch_command_completer (struct cmd_list_element
*ignore
,
11180 completion_tracker
&tracker
,
11181 const char *text
, const char * /*word*/)
11183 const auto group
= make_watch_options_def_group (nullptr);
11184 if (gdb::option::complete_options
11185 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
11188 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
11189 expression_completer (ignore
, tracker
, text
, word
);
11193 watch_command (const char *arg
, int from_tty
)
11195 watch_maybe_just_location (arg
, hw_write
, from_tty
);
11199 rwatch_command_wrapper (const char *arg
, int from_tty
, bool internal
)
11201 watch_command_1 (arg
, hw_read
, from_tty
, 0, internal
);
11205 rwatch_command (const char *arg
, int from_tty
)
11207 watch_maybe_just_location (arg
, hw_read
, from_tty
);
11211 awatch_command_wrapper (const char *arg
, int from_tty
, bool internal
)
11213 watch_command_1 (arg
, hw_access
, from_tty
, 0, internal
);
11217 awatch_command (const char *arg
, int from_tty
)
11219 watch_maybe_just_location (arg
, hw_access
, from_tty
);
11223 /* Data for the FSM that manages the until(location)/advance commands
11224 in infcmd.c. Here because it uses the mechanisms of
11227 struct until_break_fsm
: public thread_fsm
11229 /* The thread that was current when the command was executed. */
11232 /* The breakpoint set at the return address in the caller frame,
11233 plus breakpoints at all the destination locations. */
11234 std::vector
<breakpoint_up
> breakpoints
;
11236 until_break_fsm (struct interp
*cmd_interp
, int thread
,
11237 std::vector
<breakpoint_up
> &&breakpoints
)
11238 : thread_fsm (cmd_interp
),
11240 breakpoints (std::move (breakpoints
))
11244 void clean_up (struct thread_info
*thread
) override
;
11245 bool should_stop (struct thread_info
*thread
) override
;
11246 enum async_reply_reason
do_async_reply_reason () override
;
11249 /* Implementation of the 'should_stop' FSM method for the
11250 until(location)/advance commands. */
11253 until_break_fsm::should_stop (struct thread_info
*tp
)
11255 for (const breakpoint_up
&bp
: breakpoints
)
11256 if (bpstat_find_breakpoint (tp
->control
.stop_bpstat
,
11257 bp
.get ()) != NULL
)
11266 /* Implementation of the 'clean_up' FSM method for the
11267 until(location)/advance commands. */
11270 until_break_fsm::clean_up (struct thread_info
*)
11272 /* Clean up our temporary breakpoints. */
11273 breakpoints
.clear ();
11274 delete_longjmp_breakpoint (thread
);
11277 /* Implementation of the 'async_reply_reason' FSM method for the
11278 until(location)/advance commands. */
11280 enum async_reply_reason
11281 until_break_fsm::do_async_reply_reason ()
11283 return EXEC_ASYNC_LOCATION_REACHED
;
11287 until_break_command (const char *arg
, int from_tty
, int anywhere
)
11289 struct frame_info
*frame
;
11290 struct gdbarch
*frame_gdbarch
;
11291 struct frame_id stack_frame_id
;
11292 struct frame_id caller_frame_id
;
11294 struct thread_info
*tp
;
11296 clear_proceed_status (0);
11298 /* Set a breakpoint where the user wants it and at return from
11301 event_location_up location
= string_to_event_location (&arg
, current_language
);
11303 std::vector
<symtab_and_line
> sals
11304 = (last_displayed_sal_is_valid ()
11305 ? decode_line_1 (location
.get (), DECODE_LINE_FUNFIRSTLINE
, NULL
,
11306 get_last_displayed_symtab (),
11307 get_last_displayed_line ())
11308 : decode_line_1 (location
.get (), DECODE_LINE_FUNFIRSTLINE
,
11312 error (_("Couldn't get information on specified line."));
11315 error (_("Junk at end of arguments."));
11317 tp
= inferior_thread ();
11318 thread
= tp
->global_num
;
11320 /* Note linespec handling above invalidates the frame chain.
11321 Installing a breakpoint also invalidates the frame chain (as it
11322 may need to switch threads), so do any frame handling before
11325 frame
= get_selected_frame (NULL
);
11326 frame_gdbarch
= get_frame_arch (frame
);
11327 stack_frame_id
= get_stack_frame_id (frame
);
11328 caller_frame_id
= frame_unwind_caller_id (frame
);
11330 /* Keep within the current frame, or in frames called by the current
11333 std::vector
<breakpoint_up
> breakpoints
;
11335 gdb::optional
<delete_longjmp_breakpoint_cleanup
> lj_deleter
;
11337 if (frame_id_p (caller_frame_id
))
11339 struct symtab_and_line sal2
;
11340 struct gdbarch
*caller_gdbarch
;
11342 sal2
= find_pc_line (frame_unwind_caller_pc (frame
), 0);
11343 sal2
.pc
= frame_unwind_caller_pc (frame
);
11344 caller_gdbarch
= frame_unwind_caller_arch (frame
);
11346 breakpoint_up caller_breakpoint
11347 = set_momentary_breakpoint (caller_gdbarch
, sal2
,
11348 caller_frame_id
, bp_until
);
11349 breakpoints
.emplace_back (std::move (caller_breakpoint
));
11351 set_longjmp_breakpoint (tp
, caller_frame_id
);
11352 lj_deleter
.emplace (thread
);
11355 /* set_momentary_breakpoint could invalidate FRAME. */
11358 /* If the user told us to continue until a specified location, we
11359 don't specify a frame at which we need to stop. Otherwise,
11360 specify the selected frame, because we want to stop only at the
11361 very same frame. */
11362 frame_id stop_frame_id
= anywhere
? null_frame_id
: stack_frame_id
;
11364 for (symtab_and_line
&sal
: sals
)
11366 resolve_sal_pc (&sal
);
11368 breakpoint_up location_breakpoint
11369 = set_momentary_breakpoint (frame_gdbarch
, sal
,
11370 stop_frame_id
, bp_until
);
11371 breakpoints
.emplace_back (std::move (location_breakpoint
));
11374 tp
->thread_fsm
= new until_break_fsm (command_interp (), tp
->global_num
,
11375 std::move (breakpoints
));
11378 lj_deleter
->release ();
11380 proceed (-1, GDB_SIGNAL_DEFAULT
);
11383 /* This function attempts to parse an optional "if <cond>" clause
11384 from the arg string. If one is not found, it returns NULL.
11386 Else, it returns a pointer to the condition string. (It does not
11387 attempt to evaluate the string against a particular block.) And,
11388 it updates arg to point to the first character following the parsed
11389 if clause in the arg string. */
11392 ep_parse_optional_if_clause (const char **arg
)
11394 const char *cond_string
;
11396 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
11399 /* Skip the "if" keyword. */
11402 /* Skip any extra leading whitespace, and record the start of the
11403 condition string. */
11404 *arg
= skip_spaces (*arg
);
11405 cond_string
= *arg
;
11407 /* Assume that the condition occupies the remainder of the arg
11409 (*arg
) += strlen (cond_string
);
11411 return cond_string
;
11414 /* Commands to deal with catching events, such as signals, exceptions,
11415 process start/exit, etc. */
11419 catch_fork_temporary
, catch_vfork_temporary
,
11420 catch_fork_permanent
, catch_vfork_permanent
11425 catch_fork_command_1 (const char *arg
, int from_tty
,
11426 struct cmd_list_element
*command
)
11428 struct gdbarch
*gdbarch
= get_current_arch ();
11429 const char *cond_string
= NULL
;
11430 catch_fork_kind fork_kind
;
11432 fork_kind
= (catch_fork_kind
) (uintptr_t) get_cmd_context (command
);
11433 bool temp
= (fork_kind
== catch_fork_temporary
11434 || fork_kind
== catch_vfork_temporary
);
11438 arg
= skip_spaces (arg
);
11440 /* The allowed syntax is:
11442 catch [v]fork if <cond>
11444 First, check if there's an if clause. */
11445 cond_string
= ep_parse_optional_if_clause (&arg
);
11447 if ((*arg
!= '\0') && !isspace (*arg
))
11448 error (_("Junk at end of arguments."));
11450 /* If this target supports it, create a fork or vfork catchpoint
11451 and enable reporting of such events. */
11454 case catch_fork_temporary
:
11455 case catch_fork_permanent
:
11456 create_fork_vfork_event_catchpoint (gdbarch
, temp
, cond_string
,
11457 &catch_fork_breakpoint_ops
);
11459 case catch_vfork_temporary
:
11460 case catch_vfork_permanent
:
11461 create_fork_vfork_event_catchpoint (gdbarch
, temp
, cond_string
,
11462 &catch_vfork_breakpoint_ops
);
11465 error (_("unsupported or unknown fork kind; cannot catch it"));
11471 catch_exec_command_1 (const char *arg
, int from_tty
,
11472 struct cmd_list_element
*command
)
11474 struct gdbarch
*gdbarch
= get_current_arch ();
11475 const char *cond_string
= NULL
;
11476 bool temp
= get_cmd_context (command
) == CATCH_TEMPORARY
;
11480 arg
= skip_spaces (arg
);
11482 /* The allowed syntax is:
11484 catch exec if <cond>
11486 First, check if there's an if clause. */
11487 cond_string
= ep_parse_optional_if_clause (&arg
);
11489 if ((*arg
!= '\0') && !isspace (*arg
))
11490 error (_("Junk at end of arguments."));
11492 std::unique_ptr
<exec_catchpoint
> c (new exec_catchpoint ());
11493 init_catchpoint (c
.get (), gdbarch
, temp
, cond_string
,
11494 &catch_exec_breakpoint_ops
);
11495 c
->exec_pathname
= NULL
;
11497 install_breakpoint (0, std::move (c
), 1);
11501 init_ada_exception_breakpoint (struct breakpoint
*b
,
11502 struct gdbarch
*gdbarch
,
11503 struct symtab_and_line sal
,
11504 const char *addr_string
,
11505 const struct breakpoint_ops
*ops
,
11512 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
11514 loc_gdbarch
= gdbarch
;
11516 describe_other_breakpoints (loc_gdbarch
,
11517 sal
.pspace
, sal
.pc
, sal
.section
, -1);
11518 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
11519 version for exception catchpoints, because two catchpoints
11520 used for different exception names will use the same address.
11521 In this case, a "breakpoint ... also set at..." warning is
11522 unproductive. Besides, the warning phrasing is also a bit
11523 inappropriate, we should use the word catchpoint, and tell
11524 the user what type of catchpoint it is. The above is good
11525 enough for now, though. */
11528 init_raw_breakpoint (b
, gdbarch
, sal
, bp_catchpoint
, ops
);
11530 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
11531 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
11532 b
->location
= string_to_event_location (&addr_string
,
11533 language_def (language_ada
));
11534 b
->language
= language_ada
;
11539 /* Compare two breakpoints and return a strcmp-like result. */
11542 compare_breakpoints (const breakpoint
*a
, const breakpoint
*b
)
11544 uintptr_t ua
= (uintptr_t) a
;
11545 uintptr_t ub
= (uintptr_t) b
;
11547 if (a
->number
< b
->number
)
11549 else if (a
->number
> b
->number
)
11552 /* Now sort by address, in case we see, e..g, two breakpoints with
11556 return ua
> ub
? 1 : 0;
11559 /* Delete breakpoints by address or line. */
11562 clear_command (const char *arg
, int from_tty
)
11564 struct breakpoint
*b
;
11567 std::vector
<symtab_and_line
> decoded_sals
;
11568 symtab_and_line last_sal
;
11569 gdb::array_view
<symtab_and_line
> sals
;
11573 = decode_line_with_current_source (arg
,
11574 (DECODE_LINE_FUNFIRSTLINE
11575 | DECODE_LINE_LIST_MODE
));
11577 sals
= decoded_sals
;
11581 /* Set sal's line, symtab, pc, and pspace to the values
11582 corresponding to the last call to print_frame_info. If the
11583 codepoint is not valid, this will set all the fields to 0. */
11584 last_sal
= get_last_displayed_sal ();
11585 if (last_sal
.symtab
== 0)
11586 error (_("No source file specified."));
11592 /* We don't call resolve_sal_pc here. That's not as bad as it
11593 seems, because all existing breakpoints typically have both
11594 file/line and pc set. So, if clear is given file/line, we can
11595 match this to existing breakpoint without obtaining pc at all.
11597 We only support clearing given the address explicitly
11598 present in breakpoint table. Say, we've set breakpoint
11599 at file:line. There were several PC values for that file:line,
11600 due to optimization, all in one block.
11602 We've picked one PC value. If "clear" is issued with another
11603 PC corresponding to the same file:line, the breakpoint won't
11604 be cleared. We probably can still clear the breakpoint, but
11605 since the other PC value is never presented to user, user
11606 can only find it by guessing, and it does not seem important
11607 to support that. */
11609 /* For each line spec given, delete bps which correspond to it. Do
11610 it in two passes, solely to preserve the current behavior that
11611 from_tty is forced true if we delete more than one
11614 std::vector
<struct breakpoint
*> found
;
11615 for (const auto &sal
: sals
)
11617 const char *sal_fullname
;
11619 /* If exact pc given, clear bpts at that pc.
11620 If line given (pc == 0), clear all bpts on specified line.
11621 If defaulting, clear all bpts on default line
11624 defaulting sal.pc != 0 tests to do
11629 1 0 <can't happen> */
11631 sal_fullname
= (sal
.symtab
== NULL
11632 ? NULL
: symtab_to_fullname (sal
.symtab
));
11634 /* Find all matching breakpoints and add them to 'found'. */
11635 ALL_BREAKPOINTS (b
)
11638 /* Are we going to delete b? */
11639 if (b
->type
!= bp_none
&& !is_watchpoint (b
))
11641 struct bp_location
*loc
= b
->loc
;
11642 for (; loc
; loc
= loc
->next
)
11644 /* If the user specified file:line, don't allow a PC
11645 match. This matches historical gdb behavior. */
11646 int pc_match
= (!sal
.explicit_line
11648 && (loc
->pspace
== sal
.pspace
)
11649 && (loc
->address
== sal
.pc
)
11650 && (!section_is_overlay (loc
->section
)
11651 || loc
->section
== sal
.section
));
11652 int line_match
= 0;
11654 if ((default_match
|| sal
.explicit_line
)
11655 && loc
->symtab
!= NULL
11656 && sal_fullname
!= NULL
11657 && sal
.pspace
== loc
->pspace
11658 && loc
->line_number
== sal
.line
11659 && filename_cmp (symtab_to_fullname (loc
->symtab
),
11660 sal_fullname
) == 0)
11663 if (pc_match
|| line_match
)
11672 found
.push_back (b
);
11676 /* Now go thru the 'found' chain and delete them. */
11677 if (found
.empty ())
11680 error (_("No breakpoint at %s."), arg
);
11682 error (_("No breakpoint at this line."));
11685 /* Remove duplicates from the vec. */
11686 std::sort (found
.begin (), found
.end (),
11687 [] (const breakpoint
*bp_a
, const breakpoint
*bp_b
)
11689 return compare_breakpoints (bp_a
, bp_b
) < 0;
11691 found
.erase (std::unique (found
.begin (), found
.end (),
11692 [] (const breakpoint
*bp_a
, const breakpoint
*bp_b
)
11694 return compare_breakpoints (bp_a
, bp_b
) == 0;
11698 if (found
.size () > 1)
11699 from_tty
= 1; /* Always report if deleted more than one. */
11702 if (found
.size () == 1)
11703 printf_unfiltered (_("Deleted breakpoint "));
11705 printf_unfiltered (_("Deleted breakpoints "));
11708 for (breakpoint
*iter
: found
)
11711 printf_unfiltered ("%d ", iter
->number
);
11712 delete_breakpoint (iter
);
11715 putchar_unfiltered ('\n');
11718 /* Delete breakpoint in BS if they are `delete' breakpoints and
11719 all breakpoints that are marked for deletion, whether hit or not.
11720 This is called after any breakpoint is hit, or after errors. */
11723 breakpoint_auto_delete (bpstat bs
)
11725 struct breakpoint
*b
, *b_tmp
;
11727 for (; bs
; bs
= bs
->next
)
11728 if (bs
->breakpoint_at
11729 && bs
->breakpoint_at
->disposition
== disp_del
11731 delete_breakpoint (bs
->breakpoint_at
);
11733 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
11735 if (b
->disposition
== disp_del_at_next_stop
)
11736 delete_breakpoint (b
);
11740 /* A comparison function for bp_location AP and BP being interfaced to
11741 std::sort. Sort elements primarily by their ADDRESS (no matter what
11742 bl_address_is_meaningful says), secondarily by ordering first
11743 permanent elements and terciarily just ensuring the array is sorted
11744 stable way despite std::sort being an unstable algorithm. */
11747 bp_location_is_less_than (const bp_location
*a
, const bp_location
*b
)
11749 if (a
->address
!= b
->address
)
11750 return a
->address
< b
->address
;
11752 /* Sort locations at the same address by their pspace number, keeping
11753 locations of the same inferior (in a multi-inferior environment)
11756 if (a
->pspace
->num
!= b
->pspace
->num
)
11757 return a
->pspace
->num
< b
->pspace
->num
;
11759 /* Sort permanent breakpoints first. */
11760 if (a
->permanent
!= b
->permanent
)
11761 return a
->permanent
> b
->permanent
;
11763 /* Sort by type in order to make duplicate determination easier.
11764 See update_global_location_list. This is kept in sync with
11765 breakpoint_locations_match. */
11766 if (a
->loc_type
< b
->loc_type
)
11769 /* Likewise, for range-breakpoints, sort by length. */
11770 if (a
->loc_type
== bp_loc_hardware_breakpoint
11771 && b
->loc_type
== bp_loc_hardware_breakpoint
11772 && a
->length
< b
->length
)
11775 /* Make the internal GDB representation stable across GDB runs
11776 where A and B memory inside GDB can differ. Breakpoint locations of
11777 the same type at the same address can be sorted in arbitrary order. */
11779 if (a
->owner
->number
!= b
->owner
->number
)
11780 return a
->owner
->number
< b
->owner
->number
;
11785 /* Set bp_locations_placed_address_before_address_max and
11786 bp_locations_shadow_len_after_address_max according to the current
11787 content of the bp_locations array. */
11790 bp_locations_target_extensions_update (void)
11792 struct bp_location
*bl
, **blp_tmp
;
11794 bp_locations_placed_address_before_address_max
= 0;
11795 bp_locations_shadow_len_after_address_max
= 0;
11797 ALL_BP_LOCATIONS (bl
, blp_tmp
)
11799 CORE_ADDR start
, end
, addr
;
11801 if (!bp_location_has_shadow (bl
))
11804 start
= bl
->target_info
.placed_address
;
11805 end
= start
+ bl
->target_info
.shadow_len
;
11807 gdb_assert (bl
->address
>= start
);
11808 addr
= bl
->address
- start
;
11809 if (addr
> bp_locations_placed_address_before_address_max
)
11810 bp_locations_placed_address_before_address_max
= addr
;
11812 /* Zero SHADOW_LEN would not pass bp_location_has_shadow. */
11814 gdb_assert (bl
->address
< end
);
11815 addr
= end
- bl
->address
;
11816 if (addr
> bp_locations_shadow_len_after_address_max
)
11817 bp_locations_shadow_len_after_address_max
= addr
;
11821 /* Download tracepoint locations if they haven't been. */
11824 download_tracepoint_locations (void)
11826 struct breakpoint
*b
;
11827 enum tribool can_download_tracepoint
= TRIBOOL_UNKNOWN
;
11829 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
11831 ALL_TRACEPOINTS (b
)
11833 struct bp_location
*bl
;
11834 struct tracepoint
*t
;
11835 int bp_location_downloaded
= 0;
11837 if ((b
->type
== bp_fast_tracepoint
11838 ? !may_insert_fast_tracepoints
11839 : !may_insert_tracepoints
))
11842 if (can_download_tracepoint
== TRIBOOL_UNKNOWN
)
11844 if (target_can_download_tracepoint ())
11845 can_download_tracepoint
= TRIBOOL_TRUE
;
11847 can_download_tracepoint
= TRIBOOL_FALSE
;
11850 if (can_download_tracepoint
== TRIBOOL_FALSE
)
11853 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
11855 /* In tracepoint, locations are _never_ duplicated, so
11856 should_be_inserted is equivalent to
11857 unduplicated_should_be_inserted. */
11858 if (!should_be_inserted (bl
) || bl
->inserted
)
11861 switch_to_program_space_and_thread (bl
->pspace
);
11863 target_download_tracepoint (bl
);
11866 bp_location_downloaded
= 1;
11868 t
= (struct tracepoint
*) b
;
11869 t
->number_on_target
= b
->number
;
11870 if (bp_location_downloaded
)
11871 gdb::observers::breakpoint_modified
.notify (b
);
11875 /* Swap the insertion/duplication state between two locations. */
11878 swap_insertion (struct bp_location
*left
, struct bp_location
*right
)
11880 const int left_inserted
= left
->inserted
;
11881 const int left_duplicate
= left
->duplicate
;
11882 const int left_needs_update
= left
->needs_update
;
11883 const struct bp_target_info left_target_info
= left
->target_info
;
11885 /* Locations of tracepoints can never be duplicated. */
11886 if (is_tracepoint (left
->owner
))
11887 gdb_assert (!left
->duplicate
);
11888 if (is_tracepoint (right
->owner
))
11889 gdb_assert (!right
->duplicate
);
11891 left
->inserted
= right
->inserted
;
11892 left
->duplicate
= right
->duplicate
;
11893 left
->needs_update
= right
->needs_update
;
11894 left
->target_info
= right
->target_info
;
11895 right
->inserted
= left_inserted
;
11896 right
->duplicate
= left_duplicate
;
11897 right
->needs_update
= left_needs_update
;
11898 right
->target_info
= left_target_info
;
11901 /* Force the re-insertion of the locations at ADDRESS. This is called
11902 once a new/deleted/modified duplicate location is found and we are evaluating
11903 conditions on the target's side. Such conditions need to be updated on
11907 force_breakpoint_reinsertion (struct bp_location
*bl
)
11909 struct bp_location
**locp
= NULL
, **loc2p
;
11910 struct bp_location
*loc
;
11911 CORE_ADDR address
= 0;
11914 address
= bl
->address
;
11915 pspace_num
= bl
->pspace
->num
;
11917 /* This is only meaningful if the target is
11918 evaluating conditions and if the user has
11919 opted for condition evaluation on the target's
11921 if (gdb_evaluates_breakpoint_condition_p ()
11922 || !target_supports_evaluation_of_breakpoint_conditions ())
11925 /* Flag all breakpoint locations with this address and
11926 the same program space as the location
11927 as "its condition has changed". We need to
11928 update the conditions on the target's side. */
11929 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, address
)
11933 if (!is_breakpoint (loc
->owner
)
11934 || pspace_num
!= loc
->pspace
->num
)
11937 /* Flag the location appropriately. We use a different state to
11938 let everyone know that we already updated the set of locations
11939 with addr bl->address and program space bl->pspace. This is so
11940 we don't have to keep calling these functions just to mark locations
11941 that have already been marked. */
11942 loc
->condition_changed
= condition_updated
;
11944 /* Free the agent expression bytecode as well. We will compute
11946 loc
->cond_bytecode
.reset ();
11950 /* Called whether new breakpoints are created, or existing breakpoints
11951 deleted, to update the global location list and recompute which
11952 locations are duplicate of which.
11954 The INSERT_MODE flag determines whether locations may not, may, or
11955 shall be inserted now. See 'enum ugll_insert_mode' for more
11959 update_global_location_list (enum ugll_insert_mode insert_mode
)
11961 struct breakpoint
*b
;
11962 struct bp_location
**locp
, *loc
;
11963 /* Last breakpoint location address that was marked for update. */
11964 CORE_ADDR last_addr
= 0;
11965 /* Last breakpoint location program space that was marked for update. */
11966 int last_pspace_num
= -1;
11968 /* Used in the duplicates detection below. When iterating over all
11969 bp_locations, points to the first bp_location of a given address.
11970 Breakpoints and watchpoints of different types are never
11971 duplicates of each other. Keep one pointer for each type of
11972 breakpoint/watchpoint, so we only need to loop over all locations
11974 struct bp_location
*bp_loc_first
; /* breakpoint */
11975 struct bp_location
*wp_loc_first
; /* hardware watchpoint */
11976 struct bp_location
*awp_loc_first
; /* access watchpoint */
11977 struct bp_location
*rwp_loc_first
; /* read watchpoint */
11979 /* Saved former bp_locations array which we compare against the newly
11980 built bp_locations from the current state of ALL_BREAKPOINTS. */
11981 struct bp_location
**old_locp
;
11982 unsigned old_locations_count
;
11983 gdb::unique_xmalloc_ptr
<struct bp_location
*> old_locations (bp_locations
);
11985 old_locations_count
= bp_locations_count
;
11986 bp_locations
= NULL
;
11987 bp_locations_count
= 0;
11989 ALL_BREAKPOINTS (b
)
11990 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
11991 bp_locations_count
++;
11993 bp_locations
= XNEWVEC (struct bp_location
*, bp_locations_count
);
11994 locp
= bp_locations
;
11995 ALL_BREAKPOINTS (b
)
11996 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
11999 /* See if we need to "upgrade" a software breakpoint to a hardware
12000 breakpoint. Do this before deciding whether locations are
12001 duplicates. Also do this before sorting because sorting order
12002 depends on location type. */
12003 for (locp
= bp_locations
;
12004 locp
< bp_locations
+ bp_locations_count
;
12008 if (!loc
->inserted
&& should_be_inserted (loc
))
12009 handle_automatic_hardware_breakpoints (loc
);
12012 std::sort (bp_locations
, bp_locations
+ bp_locations_count
,
12013 bp_location_is_less_than
);
12015 bp_locations_target_extensions_update ();
12017 /* Identify bp_location instances that are no longer present in the
12018 new list, and therefore should be freed. Note that it's not
12019 necessary that those locations should be removed from inferior --
12020 if there's another location at the same address (previously
12021 marked as duplicate), we don't need to remove/insert the
12024 LOCP is kept in sync with OLD_LOCP, each pointing to the current
12025 and former bp_location array state respectively. */
12027 locp
= bp_locations
;
12028 for (old_locp
= old_locations
.get ();
12029 old_locp
< old_locations
.get () + old_locations_count
;
12032 struct bp_location
*old_loc
= *old_locp
;
12033 struct bp_location
**loc2p
;
12035 /* Tells if 'old_loc' is found among the new locations. If
12036 not, we have to free it. */
12037 int found_object
= 0;
12038 /* Tells if the location should remain inserted in the target. */
12039 int keep_in_target
= 0;
12042 /* Skip LOCP entries which will definitely never be needed.
12043 Stop either at or being the one matching OLD_LOC. */
12044 while (locp
< bp_locations
+ bp_locations_count
12045 && (*locp
)->address
< old_loc
->address
)
12049 (loc2p
< bp_locations
+ bp_locations_count
12050 && (*loc2p
)->address
== old_loc
->address
);
12053 /* Check if this is a new/duplicated location or a duplicated
12054 location that had its condition modified. If so, we want to send
12055 its condition to the target if evaluation of conditions is taking
12057 if ((*loc2p
)->condition_changed
== condition_modified
12058 && (last_addr
!= old_loc
->address
12059 || last_pspace_num
!= old_loc
->pspace
->num
))
12061 force_breakpoint_reinsertion (*loc2p
);
12062 last_pspace_num
= old_loc
->pspace
->num
;
12065 if (*loc2p
== old_loc
)
12069 /* We have already handled this address, update it so that we don't
12070 have to go through updates again. */
12071 last_addr
= old_loc
->address
;
12073 /* Target-side condition evaluation: Handle deleted locations. */
12075 force_breakpoint_reinsertion (old_loc
);
12077 /* If this location is no longer present, and inserted, look if
12078 there's maybe a new location at the same address. If so,
12079 mark that one inserted, and don't remove this one. This is
12080 needed so that we don't have a time window where a breakpoint
12081 at certain location is not inserted. */
12083 if (old_loc
->inserted
)
12085 /* If the location is inserted now, we might have to remove
12088 if (found_object
&& should_be_inserted (old_loc
))
12090 /* The location is still present in the location list,
12091 and still should be inserted. Don't do anything. */
12092 keep_in_target
= 1;
12096 /* This location still exists, but it won't be kept in the
12097 target since it may have been disabled. We proceed to
12098 remove its target-side condition. */
12100 /* The location is either no longer present, or got
12101 disabled. See if there's another location at the
12102 same address, in which case we don't need to remove
12103 this one from the target. */
12105 /* OLD_LOC comes from existing struct breakpoint. */
12106 if (bl_address_is_meaningful (old_loc
))
12109 (loc2p
< bp_locations
+ bp_locations_count
12110 && (*loc2p
)->address
== old_loc
->address
);
12113 struct bp_location
*loc2
= *loc2p
;
12115 if (loc2
== old_loc
)
12118 if (breakpoint_locations_match (loc2
, old_loc
))
12120 /* Read watchpoint locations are switched to
12121 access watchpoints, if the former are not
12122 supported, but the latter are. */
12123 if (is_hardware_watchpoint (old_loc
->owner
))
12125 gdb_assert (is_hardware_watchpoint (loc2
->owner
));
12126 loc2
->watchpoint_type
= old_loc
->watchpoint_type
;
12129 /* loc2 is a duplicated location. We need to check
12130 if it should be inserted in case it will be
12132 if (unduplicated_should_be_inserted (loc2
))
12134 swap_insertion (old_loc
, loc2
);
12135 keep_in_target
= 1;
12143 if (!keep_in_target
)
12145 if (remove_breakpoint (old_loc
))
12147 /* This is just about all we can do. We could keep
12148 this location on the global list, and try to
12149 remove it next time, but there's no particular
12150 reason why we will succeed next time.
12152 Note that at this point, old_loc->owner is still
12153 valid, as delete_breakpoint frees the breakpoint
12154 only after calling us. */
12155 printf_filtered (_("warning: Error removing "
12156 "breakpoint %d\n"),
12157 old_loc
->owner
->number
);
12165 if (removed
&& target_is_non_stop_p ()
12166 && need_moribund_for_location_type (old_loc
))
12168 /* This location was removed from the target. In
12169 non-stop mode, a race condition is possible where
12170 we've removed a breakpoint, but stop events for that
12171 breakpoint are already queued and will arrive later.
12172 We apply an heuristic to be able to distinguish such
12173 SIGTRAPs from other random SIGTRAPs: we keep this
12174 breakpoint location for a bit, and will retire it
12175 after we see some number of events. The theory here
12176 is that reporting of events should, "on the average",
12177 be fair, so after a while we'll see events from all
12178 threads that have anything of interest, and no longer
12179 need to keep this breakpoint location around. We
12180 don't hold locations forever so to reduce chances of
12181 mistaking a non-breakpoint SIGTRAP for a breakpoint
12184 The heuristic failing can be disastrous on
12185 decr_pc_after_break targets.
12187 On decr_pc_after_break targets, like e.g., x86-linux,
12188 if we fail to recognize a late breakpoint SIGTRAP,
12189 because events_till_retirement has reached 0 too
12190 soon, we'll fail to do the PC adjustment, and report
12191 a random SIGTRAP to the user. When the user resumes
12192 the inferior, it will most likely immediately crash
12193 with SIGILL/SIGBUS/SIGSEGV, or worse, get silently
12194 corrupted, because of being resumed e.g., in the
12195 middle of a multi-byte instruction, or skipped a
12196 one-byte instruction. This was actually seen happen
12197 on native x86-linux, and should be less rare on
12198 targets that do not support new thread events, like
12199 remote, due to the heuristic depending on
12202 Mistaking a random SIGTRAP for a breakpoint trap
12203 causes similar symptoms (PC adjustment applied when
12204 it shouldn't), but then again, playing with SIGTRAPs
12205 behind the debugger's back is asking for trouble.
12207 Since hardware watchpoint traps are always
12208 distinguishable from other traps, so we don't need to
12209 apply keep hardware watchpoint moribund locations
12210 around. We simply always ignore hardware watchpoint
12211 traps we can no longer explain. */
12213 process_stratum_target
*proc_target
= nullptr;
12214 for (inferior
*inf
: all_inferiors ())
12215 if (inf
->pspace
== old_loc
->pspace
)
12217 proc_target
= inf
->process_target ();
12220 if (proc_target
!= nullptr)
12221 old_loc
->events_till_retirement
12222 = 3 * (thread_count (proc_target
) + 1);
12224 old_loc
->events_till_retirement
= 1;
12225 old_loc
->owner
= NULL
;
12227 moribund_locations
.push_back (old_loc
);
12231 old_loc
->owner
= NULL
;
12232 decref_bp_location (&old_loc
);
12237 /* Rescan breakpoints at the same address and section, marking the
12238 first one as "first" and any others as "duplicates". This is so
12239 that the bpt instruction is only inserted once. If we have a
12240 permanent breakpoint at the same place as BPT, make that one the
12241 official one, and the rest as duplicates. Permanent breakpoints
12242 are sorted first for the same address.
12244 Do the same for hardware watchpoints, but also considering the
12245 watchpoint's type (regular/access/read) and length. */
12247 bp_loc_first
= NULL
;
12248 wp_loc_first
= NULL
;
12249 awp_loc_first
= NULL
;
12250 rwp_loc_first
= NULL
;
12251 ALL_BP_LOCATIONS (loc
, locp
)
12253 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always
12255 struct bp_location
**loc_first_p
;
12258 if (!unduplicated_should_be_inserted (loc
)
12259 || !bl_address_is_meaningful (loc
)
12260 /* Don't detect duplicate for tracepoint locations because they are
12261 never duplicated. See the comments in field `duplicate' of
12262 `struct bp_location'. */
12263 || is_tracepoint (b
))
12265 /* Clear the condition modification flag. */
12266 loc
->condition_changed
= condition_unchanged
;
12270 if (b
->type
== bp_hardware_watchpoint
)
12271 loc_first_p
= &wp_loc_first
;
12272 else if (b
->type
== bp_read_watchpoint
)
12273 loc_first_p
= &rwp_loc_first
;
12274 else if (b
->type
== bp_access_watchpoint
)
12275 loc_first_p
= &awp_loc_first
;
12277 loc_first_p
= &bp_loc_first
;
12279 if (*loc_first_p
== NULL
12280 || (overlay_debugging
&& loc
->section
!= (*loc_first_p
)->section
)
12281 || !breakpoint_locations_match (loc
, *loc_first_p
))
12283 *loc_first_p
= loc
;
12284 loc
->duplicate
= 0;
12286 if (is_breakpoint (loc
->owner
) && loc
->condition_changed
)
12288 loc
->needs_update
= 1;
12289 /* Clear the condition modification flag. */
12290 loc
->condition_changed
= condition_unchanged
;
12296 /* This and the above ensure the invariant that the first location
12297 is not duplicated, and is the inserted one.
12298 All following are marked as duplicated, and are not inserted. */
12300 swap_insertion (loc
, *loc_first_p
);
12301 loc
->duplicate
= 1;
12303 /* Clear the condition modification flag. */
12304 loc
->condition_changed
= condition_unchanged
;
12307 if (insert_mode
== UGLL_INSERT
|| breakpoints_should_be_inserted_now ())
12309 if (insert_mode
!= UGLL_DONT_INSERT
)
12310 insert_breakpoint_locations ();
12313 /* Even though the caller told us to not insert new
12314 locations, we may still need to update conditions on the
12315 target's side of breakpoints that were already inserted
12316 if the target is evaluating breakpoint conditions. We
12317 only update conditions for locations that are marked
12319 update_inserted_breakpoint_locations ();
12323 if (insert_mode
!= UGLL_DONT_INSERT
)
12324 download_tracepoint_locations ();
12328 breakpoint_retire_moribund (void)
12330 for (int ix
= 0; ix
< moribund_locations
.size (); ++ix
)
12332 struct bp_location
*loc
= moribund_locations
[ix
];
12333 if (--(loc
->events_till_retirement
) == 0)
12335 decref_bp_location (&loc
);
12336 unordered_remove (moribund_locations
, ix
);
12343 update_global_location_list_nothrow (enum ugll_insert_mode insert_mode
)
12348 update_global_location_list (insert_mode
);
12350 catch (const gdb_exception_error
&e
)
12355 /* Clear BKP from a BPS. */
12358 bpstat_remove_bp_location (bpstat bps
, struct breakpoint
*bpt
)
12362 for (bs
= bps
; bs
; bs
= bs
->next
)
12363 if (bs
->breakpoint_at
== bpt
)
12365 bs
->breakpoint_at
= NULL
;
12366 bs
->old_val
= NULL
;
12367 /* bs->commands will be freed later. */
12371 /* Callback for iterate_over_threads. */
12373 bpstat_remove_breakpoint_callback (struct thread_info
*th
, void *data
)
12375 struct breakpoint
*bpt
= (struct breakpoint
*) data
;
12377 bpstat_remove_bp_location (th
->control
.stop_bpstat
, bpt
);
12381 /* Helper for breakpoint and tracepoint breakpoint_ops->mention
12385 say_where (struct breakpoint
*b
)
12387 struct value_print_options opts
;
12389 get_user_print_options (&opts
);
12391 /* i18n: cagney/2005-02-11: Below needs to be merged into a
12393 if (b
->loc
== NULL
)
12395 /* For pending locations, the output differs slightly based
12396 on b->extra_string. If this is non-NULL, it contains either
12397 a condition or dprintf arguments. */
12398 if (b
->extra_string
== NULL
)
12400 printf_filtered (_(" (%s) pending."),
12401 event_location_to_string (b
->location
.get ()));
12403 else if (b
->type
== bp_dprintf
)
12405 printf_filtered (_(" (%s,%s) pending."),
12406 event_location_to_string (b
->location
.get ()),
12411 printf_filtered (_(" (%s %s) pending."),
12412 event_location_to_string (b
->location
.get ()),
12418 if (opts
.addressprint
|| b
->loc
->symtab
== NULL
)
12419 printf_filtered (" at %ps",
12420 styled_string (address_style
.style (),
12421 paddress (b
->loc
->gdbarch
,
12422 b
->loc
->address
)));
12423 if (b
->loc
->symtab
!= NULL
)
12425 /* If there is a single location, we can print the location
12427 if (b
->loc
->next
== NULL
)
12429 const char *filename
12430 = symtab_to_filename_for_display (b
->loc
->symtab
);
12431 printf_filtered (": file %ps, line %d.",
12432 styled_string (file_name_style
.style (),
12434 b
->loc
->line_number
);
12437 /* This is not ideal, but each location may have a
12438 different file name, and this at least reflects the
12439 real situation somewhat. */
12440 printf_filtered (": %s.",
12441 event_location_to_string (b
->location
.get ()));
12446 struct bp_location
*loc
= b
->loc
;
12448 for (; loc
; loc
= loc
->next
)
12450 printf_filtered (" (%d locations)", n
);
12455 bp_location::~bp_location ()
12457 xfree (function_name
);
12460 /* Destructor for the breakpoint base class. */
12462 breakpoint::~breakpoint ()
12464 xfree (this->cond_string
);
12465 xfree (this->extra_string
);
12468 static struct bp_location
*
12469 base_breakpoint_allocate_location (struct breakpoint
*self
)
12471 return new bp_location (self
);
12475 base_breakpoint_re_set (struct breakpoint
*b
)
12477 /* Nothing to re-set. */
12480 #define internal_error_pure_virtual_called() \
12481 gdb_assert_not_reached ("pure virtual function called")
12484 base_breakpoint_insert_location (struct bp_location
*bl
)
12486 internal_error_pure_virtual_called ();
12490 base_breakpoint_remove_location (struct bp_location
*bl
,
12491 enum remove_bp_reason reason
)
12493 internal_error_pure_virtual_called ();
12497 base_breakpoint_breakpoint_hit (const struct bp_location
*bl
,
12498 const address_space
*aspace
,
12500 const struct target_waitstatus
*ws
)
12502 internal_error_pure_virtual_called ();
12506 base_breakpoint_check_status (bpstat bs
)
12511 /* A "works_in_software_mode" breakpoint_ops method that just internal
12515 base_breakpoint_works_in_software_mode (const struct breakpoint
*b
)
12517 internal_error_pure_virtual_called ();
12520 /* A "resources_needed" breakpoint_ops method that just internal
12524 base_breakpoint_resources_needed (const struct bp_location
*bl
)
12526 internal_error_pure_virtual_called ();
12529 static enum print_stop_action
12530 base_breakpoint_print_it (bpstat bs
)
12532 internal_error_pure_virtual_called ();
12536 base_breakpoint_print_one_detail (const struct breakpoint
*self
,
12537 struct ui_out
*uiout
)
12543 base_breakpoint_print_mention (struct breakpoint
*b
)
12545 internal_error_pure_virtual_called ();
12549 base_breakpoint_print_recreate (struct breakpoint
*b
, struct ui_file
*fp
)
12551 internal_error_pure_virtual_called ();
12555 base_breakpoint_create_sals_from_location
12556 (struct event_location
*location
,
12557 struct linespec_result
*canonical
,
12558 enum bptype type_wanted
)
12560 internal_error_pure_virtual_called ();
12564 base_breakpoint_create_breakpoints_sal (struct gdbarch
*gdbarch
,
12565 struct linespec_result
*c
,
12566 gdb::unique_xmalloc_ptr
<char> cond_string
,
12567 gdb::unique_xmalloc_ptr
<char> extra_string
,
12568 enum bptype type_wanted
,
12569 enum bpdisp disposition
,
12571 int task
, int ignore_count
,
12572 const struct breakpoint_ops
*o
,
12573 int from_tty
, int enabled
,
12574 int internal
, unsigned flags
)
12576 internal_error_pure_virtual_called ();
12579 static std::vector
<symtab_and_line
>
12580 base_breakpoint_decode_location (struct breakpoint
*b
,
12581 struct event_location
*location
,
12582 struct program_space
*search_pspace
)
12584 internal_error_pure_virtual_called ();
12587 /* The default 'explains_signal' method. */
12590 base_breakpoint_explains_signal (struct breakpoint
*b
, enum gdb_signal sig
)
12595 /* The default "after_condition_true" method. */
12598 base_breakpoint_after_condition_true (struct bpstats
*bs
)
12600 /* Nothing to do. */
12603 struct breakpoint_ops base_breakpoint_ops
=
12605 base_breakpoint_allocate_location
,
12606 base_breakpoint_re_set
,
12607 base_breakpoint_insert_location
,
12608 base_breakpoint_remove_location
,
12609 base_breakpoint_breakpoint_hit
,
12610 base_breakpoint_check_status
,
12611 base_breakpoint_resources_needed
,
12612 base_breakpoint_works_in_software_mode
,
12613 base_breakpoint_print_it
,
12615 base_breakpoint_print_one_detail
,
12616 base_breakpoint_print_mention
,
12617 base_breakpoint_print_recreate
,
12618 base_breakpoint_create_sals_from_location
,
12619 base_breakpoint_create_breakpoints_sal
,
12620 base_breakpoint_decode_location
,
12621 base_breakpoint_explains_signal
,
12622 base_breakpoint_after_condition_true
,
12625 /* Default breakpoint_ops methods. */
12628 bkpt_re_set (struct breakpoint
*b
)
12630 /* FIXME: is this still reachable? */
12631 if (breakpoint_event_location_empty_p (b
))
12633 /* Anything without a location can't be re-set. */
12634 delete_breakpoint (b
);
12638 breakpoint_re_set_default (b
);
12642 bkpt_insert_location (struct bp_location
*bl
)
12644 CORE_ADDR addr
= bl
->target_info
.reqstd_address
;
12646 bl
->target_info
.kind
= breakpoint_kind (bl
, &addr
);
12647 bl
->target_info
.placed_address
= addr
;
12649 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
12650 return target_insert_hw_breakpoint (bl
->gdbarch
, &bl
->target_info
);
12652 return target_insert_breakpoint (bl
->gdbarch
, &bl
->target_info
);
12656 bkpt_remove_location (struct bp_location
*bl
, enum remove_bp_reason reason
)
12658 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
12659 return target_remove_hw_breakpoint (bl
->gdbarch
, &bl
->target_info
);
12661 return target_remove_breakpoint (bl
->gdbarch
, &bl
->target_info
, reason
);
12665 bkpt_breakpoint_hit (const struct bp_location
*bl
,
12666 const address_space
*aspace
, CORE_ADDR bp_addr
,
12667 const struct target_waitstatus
*ws
)
12669 if (ws
->kind
!= TARGET_WAITKIND_STOPPED
12670 || ws
->value
.sig
!= GDB_SIGNAL_TRAP
)
12673 if (!breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
12677 if (overlay_debugging
/* unmapped overlay section */
12678 && section_is_overlay (bl
->section
)
12679 && !section_is_mapped (bl
->section
))
12686 dprintf_breakpoint_hit (const struct bp_location
*bl
,
12687 const address_space
*aspace
, CORE_ADDR bp_addr
,
12688 const struct target_waitstatus
*ws
)
12690 if (dprintf_style
== dprintf_style_agent
12691 && target_can_run_breakpoint_commands ())
12693 /* An agent-style dprintf never causes a stop. If we see a trap
12694 for this address it must be for a breakpoint that happens to
12695 be set at the same address. */
12699 return bkpt_breakpoint_hit (bl
, aspace
, bp_addr
, ws
);
12703 bkpt_resources_needed (const struct bp_location
*bl
)
12705 gdb_assert (bl
->owner
->type
== bp_hardware_breakpoint
);
12710 static enum print_stop_action
12711 bkpt_print_it (bpstat bs
)
12713 struct breakpoint
*b
;
12714 const struct bp_location
*bl
;
12716 struct ui_out
*uiout
= current_uiout
;
12718 gdb_assert (bs
->bp_location_at
!= NULL
);
12720 bl
= bs
->bp_location_at
.get ();
12721 b
= bs
->breakpoint_at
;
12723 bp_temp
= b
->disposition
== disp_del
;
12724 if (bl
->address
!= bl
->requested_address
)
12725 breakpoint_adjustment_warning (bl
->requested_address
,
12728 annotate_breakpoint (b
->number
);
12729 maybe_print_thread_hit_breakpoint (uiout
);
12731 if (uiout
->is_mi_like_p ())
12733 uiout
->field_string ("reason",
12734 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
12735 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
12738 uiout
->message ("Temporary breakpoint %pF, ",
12739 signed_field ("bkptno", b
->number
));
12741 uiout
->message ("Breakpoint %pF, ",
12742 signed_field ("bkptno", b
->number
));
12744 return PRINT_SRC_AND_LOC
;
12748 bkpt_print_mention (struct breakpoint
*b
)
12750 if (current_uiout
->is_mi_like_p ())
12755 case bp_breakpoint
:
12756 case bp_gnu_ifunc_resolver
:
12757 if (b
->disposition
== disp_del
)
12758 printf_filtered (_("Temporary breakpoint"));
12760 printf_filtered (_("Breakpoint"));
12761 printf_filtered (_(" %d"), b
->number
);
12762 if (b
->type
== bp_gnu_ifunc_resolver
)
12763 printf_filtered (_(" at gnu-indirect-function resolver"));
12765 case bp_hardware_breakpoint
:
12766 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
12769 printf_filtered (_("Dprintf %d"), b
->number
);
12777 bkpt_print_recreate (struct breakpoint
*tp
, struct ui_file
*fp
)
12779 if (tp
->type
== bp_breakpoint
&& tp
->disposition
== disp_del
)
12780 fprintf_unfiltered (fp
, "tbreak");
12781 else if (tp
->type
== bp_breakpoint
)
12782 fprintf_unfiltered (fp
, "break");
12783 else if (tp
->type
== bp_hardware_breakpoint
12784 && tp
->disposition
== disp_del
)
12785 fprintf_unfiltered (fp
, "thbreak");
12786 else if (tp
->type
== bp_hardware_breakpoint
)
12787 fprintf_unfiltered (fp
, "hbreak");
12789 internal_error (__FILE__
, __LINE__
,
12790 _("unhandled breakpoint type %d"), (int) tp
->type
);
12792 fprintf_unfiltered (fp
, " %s",
12793 event_location_to_string (tp
->location
.get ()));
12795 /* Print out extra_string if this breakpoint is pending. It might
12796 contain, for example, conditions that were set by the user. */
12797 if (tp
->loc
== NULL
&& tp
->extra_string
!= NULL
)
12798 fprintf_unfiltered (fp
, " %s", tp
->extra_string
);
12800 print_recreate_thread (tp
, fp
);
12804 bkpt_create_sals_from_location (struct event_location
*location
,
12805 struct linespec_result
*canonical
,
12806 enum bptype type_wanted
)
12808 create_sals_from_location_default (location
, canonical
, type_wanted
);
12812 bkpt_create_breakpoints_sal (struct gdbarch
*gdbarch
,
12813 struct linespec_result
*canonical
,
12814 gdb::unique_xmalloc_ptr
<char> cond_string
,
12815 gdb::unique_xmalloc_ptr
<char> extra_string
,
12816 enum bptype type_wanted
,
12817 enum bpdisp disposition
,
12819 int task
, int ignore_count
,
12820 const struct breakpoint_ops
*ops
,
12821 int from_tty
, int enabled
,
12822 int internal
, unsigned flags
)
12824 create_breakpoints_sal_default (gdbarch
, canonical
,
12825 std::move (cond_string
),
12826 std::move (extra_string
),
12828 disposition
, thread
, task
,
12829 ignore_count
, ops
, from_tty
,
12830 enabled
, internal
, flags
);
12833 static std::vector
<symtab_and_line
>
12834 bkpt_decode_location (struct breakpoint
*b
,
12835 struct event_location
*location
,
12836 struct program_space
*search_pspace
)
12838 return decode_location_default (b
, location
, search_pspace
);
12841 /* Virtual table for internal breakpoints. */
12844 internal_bkpt_re_set (struct breakpoint
*b
)
12848 /* Delete overlay event and longjmp master breakpoints; they
12849 will be reset later by breakpoint_re_set. */
12850 case bp_overlay_event
:
12851 case bp_longjmp_master
:
12852 case bp_std_terminate_master
:
12853 case bp_exception_master
:
12854 delete_breakpoint (b
);
12857 /* This breakpoint is special, it's set up when the inferior
12858 starts and we really don't want to touch it. */
12859 case bp_shlib_event
:
12861 /* Like bp_shlib_event, this breakpoint type is special. Once
12862 it is set up, we do not want to touch it. */
12863 case bp_thread_event
:
12869 internal_bkpt_check_status (bpstat bs
)
12871 if (bs
->breakpoint_at
->type
== bp_shlib_event
)
12873 /* If requested, stop when the dynamic linker notifies GDB of
12874 events. This allows the user to get control and place
12875 breakpoints in initializer routines for dynamically loaded
12876 objects (among other things). */
12877 bs
->stop
= stop_on_solib_events
;
12878 bs
->print
= stop_on_solib_events
;
12884 static enum print_stop_action
12885 internal_bkpt_print_it (bpstat bs
)
12887 struct breakpoint
*b
;
12889 b
= bs
->breakpoint_at
;
12893 case bp_shlib_event
:
12894 /* Did we stop because the user set the stop_on_solib_events
12895 variable? (If so, we report this as a generic, "Stopped due
12896 to shlib event" message.) */
12897 print_solib_event (0);
12900 case bp_thread_event
:
12901 /* Not sure how we will get here.
12902 GDB should not stop for these breakpoints. */
12903 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
12906 case bp_overlay_event
:
12907 /* By analogy with the thread event, GDB should not stop for these. */
12908 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
12911 case bp_longjmp_master
:
12912 /* These should never be enabled. */
12913 printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
12916 case bp_std_terminate_master
:
12917 /* These should never be enabled. */
12918 printf_filtered (_("std::terminate Master Breakpoint: "
12919 "gdb should not stop!\n"));
12922 case bp_exception_master
:
12923 /* These should never be enabled. */
12924 printf_filtered (_("Exception Master Breakpoint: "
12925 "gdb should not stop!\n"));
12929 return PRINT_NOTHING
;
12933 internal_bkpt_print_mention (struct breakpoint
*b
)
12935 /* Nothing to mention. These breakpoints are internal. */
12938 /* Virtual table for momentary breakpoints */
12941 momentary_bkpt_re_set (struct breakpoint
*b
)
12943 /* Keep temporary breakpoints, which can be encountered when we step
12944 over a dlopen call and solib_add is resetting the breakpoints.
12945 Otherwise these should have been blown away via the cleanup chain
12946 or by breakpoint_init_inferior when we rerun the executable. */
12950 momentary_bkpt_check_status (bpstat bs
)
12952 /* Nothing. The point of these breakpoints is causing a stop. */
12955 static enum print_stop_action
12956 momentary_bkpt_print_it (bpstat bs
)
12958 return PRINT_UNKNOWN
;
12962 momentary_bkpt_print_mention (struct breakpoint
*b
)
12964 /* Nothing to mention. These breakpoints are internal. */
12967 /* Ensure INITIATING_FRAME is cleared when no such breakpoint exists.
12969 It gets cleared already on the removal of the first one of such placed
12970 breakpoints. This is OK as they get all removed altogether. */
12972 longjmp_breakpoint::~longjmp_breakpoint ()
12974 thread_info
*tp
= find_thread_global_id (this->thread
);
12977 tp
->initiating_frame
= null_frame_id
;
12980 /* Specific methods for probe breakpoints. */
12983 bkpt_probe_insert_location (struct bp_location
*bl
)
12985 int v
= bkpt_insert_location (bl
);
12989 /* The insertion was successful, now let's set the probe's semaphore
12991 bl
->probe
.prob
->set_semaphore (bl
->probe
.objfile
, bl
->gdbarch
);
12998 bkpt_probe_remove_location (struct bp_location
*bl
,
12999 enum remove_bp_reason reason
)
13001 /* Let's clear the semaphore before removing the location. */
13002 bl
->probe
.prob
->clear_semaphore (bl
->probe
.objfile
, bl
->gdbarch
);
13004 return bkpt_remove_location (bl
, reason
);
13008 bkpt_probe_create_sals_from_location (struct event_location
*location
,
13009 struct linespec_result
*canonical
,
13010 enum bptype type_wanted
)
13012 struct linespec_sals lsal
;
13014 lsal
.sals
= parse_probes (location
, NULL
, canonical
);
13016 = xstrdup (event_location_to_string (canonical
->location
.get ()));
13017 canonical
->lsals
.push_back (std::move (lsal
));
13020 static std::vector
<symtab_and_line
>
13021 bkpt_probe_decode_location (struct breakpoint
*b
,
13022 struct event_location
*location
,
13023 struct program_space
*search_pspace
)
13025 std::vector
<symtab_and_line
> sals
= parse_probes (location
, search_pspace
, NULL
);
13027 error (_("probe not found"));
13031 /* The breakpoint_ops structure to be used in tracepoints. */
13034 tracepoint_re_set (struct breakpoint
*b
)
13036 breakpoint_re_set_default (b
);
13040 tracepoint_breakpoint_hit (const struct bp_location
*bl
,
13041 const address_space
*aspace
, CORE_ADDR bp_addr
,
13042 const struct target_waitstatus
*ws
)
13044 /* By definition, the inferior does not report stops at
13050 tracepoint_print_one_detail (const struct breakpoint
*self
,
13051 struct ui_out
*uiout
)
13053 struct tracepoint
*tp
= (struct tracepoint
*) self
;
13054 if (!tp
->static_trace_marker_id
.empty ())
13056 gdb_assert (self
->type
== bp_static_tracepoint
);
13058 uiout
->message ("\tmarker id is %pF\n",
13059 string_field ("static-tracepoint-marker-string-id",
13060 tp
->static_trace_marker_id
.c_str ()));
13065 tracepoint_print_mention (struct breakpoint
*b
)
13067 if (current_uiout
->is_mi_like_p ())
13072 case bp_tracepoint
:
13073 printf_filtered (_("Tracepoint"));
13074 printf_filtered (_(" %d"), b
->number
);
13076 case bp_fast_tracepoint
:
13077 printf_filtered (_("Fast tracepoint"));
13078 printf_filtered (_(" %d"), b
->number
);
13080 case bp_static_tracepoint
:
13081 printf_filtered (_("Static tracepoint"));
13082 printf_filtered (_(" %d"), b
->number
);
13085 internal_error (__FILE__
, __LINE__
,
13086 _("unhandled tracepoint type %d"), (int) b
->type
);
13093 tracepoint_print_recreate (struct breakpoint
*self
, struct ui_file
*fp
)
13095 struct tracepoint
*tp
= (struct tracepoint
*) self
;
13097 if (self
->type
== bp_fast_tracepoint
)
13098 fprintf_unfiltered (fp
, "ftrace");
13099 else if (self
->type
== bp_static_tracepoint
)
13100 fprintf_unfiltered (fp
, "strace");
13101 else if (self
->type
== bp_tracepoint
)
13102 fprintf_unfiltered (fp
, "trace");
13104 internal_error (__FILE__
, __LINE__
,
13105 _("unhandled tracepoint type %d"), (int) self
->type
);
13107 fprintf_unfiltered (fp
, " %s",
13108 event_location_to_string (self
->location
.get ()));
13109 print_recreate_thread (self
, fp
);
13111 if (tp
->pass_count
)
13112 fprintf_unfiltered (fp
, " passcount %d\n", tp
->pass_count
);
13116 tracepoint_create_sals_from_location (struct event_location
*location
,
13117 struct linespec_result
*canonical
,
13118 enum bptype type_wanted
)
13120 create_sals_from_location_default (location
, canonical
, type_wanted
);
13124 tracepoint_create_breakpoints_sal (struct gdbarch
*gdbarch
,
13125 struct linespec_result
*canonical
,
13126 gdb::unique_xmalloc_ptr
<char> cond_string
,
13127 gdb::unique_xmalloc_ptr
<char> extra_string
,
13128 enum bptype type_wanted
,
13129 enum bpdisp disposition
,
13131 int task
, int ignore_count
,
13132 const struct breakpoint_ops
*ops
,
13133 int from_tty
, int enabled
,
13134 int internal
, unsigned flags
)
13136 create_breakpoints_sal_default (gdbarch
, canonical
,
13137 std::move (cond_string
),
13138 std::move (extra_string
),
13140 disposition
, thread
, task
,
13141 ignore_count
, ops
, from_tty
,
13142 enabled
, internal
, flags
);
13145 static std::vector
<symtab_and_line
>
13146 tracepoint_decode_location (struct breakpoint
*b
,
13147 struct event_location
*location
,
13148 struct program_space
*search_pspace
)
13150 return decode_location_default (b
, location
, search_pspace
);
13153 struct breakpoint_ops tracepoint_breakpoint_ops
;
13155 /* Virtual table for tracepoints on static probes. */
13158 tracepoint_probe_create_sals_from_location
13159 (struct event_location
*location
,
13160 struct linespec_result
*canonical
,
13161 enum bptype type_wanted
)
13163 /* We use the same method for breakpoint on probes. */
13164 bkpt_probe_create_sals_from_location (location
, canonical
, type_wanted
);
13167 static std::vector
<symtab_and_line
>
13168 tracepoint_probe_decode_location (struct breakpoint
*b
,
13169 struct event_location
*location
,
13170 struct program_space
*search_pspace
)
13172 /* We use the same method for breakpoint on probes. */
13173 return bkpt_probe_decode_location (b
, location
, search_pspace
);
13176 /* Dprintf breakpoint_ops methods. */
13179 dprintf_re_set (struct breakpoint
*b
)
13181 breakpoint_re_set_default (b
);
13183 /* extra_string should never be non-NULL for dprintf. */
13184 gdb_assert (b
->extra_string
!= NULL
);
13186 /* 1 - connect to target 1, that can run breakpoint commands.
13187 2 - create a dprintf, which resolves fine.
13188 3 - disconnect from target 1
13189 4 - connect to target 2, that can NOT run breakpoint commands.
13191 After steps #3/#4, you'll want the dprintf command list to
13192 be updated, because target 1 and 2 may well return different
13193 answers for target_can_run_breakpoint_commands().
13194 Given absence of finer grained resetting, we get to do
13195 it all the time. */
13196 if (b
->extra_string
!= NULL
)
13197 update_dprintf_command_list (b
);
13200 /* Implement the "print_recreate" breakpoint_ops method for dprintf. */
13203 dprintf_print_recreate (struct breakpoint
*tp
, struct ui_file
*fp
)
13205 fprintf_unfiltered (fp
, "dprintf %s,%s",
13206 event_location_to_string (tp
->location
.get ()),
13208 print_recreate_thread (tp
, fp
);
13211 /* Implement the "after_condition_true" breakpoint_ops method for
13214 dprintf's are implemented with regular commands in their command
13215 list, but we run the commands here instead of before presenting the
13216 stop to the user, as dprintf's don't actually cause a stop. This
13217 also makes it so that the commands of multiple dprintfs at the same
13218 address are all handled. */
13221 dprintf_after_condition_true (struct bpstats
*bs
)
13223 struct bpstats tmp_bs
;
13224 struct bpstats
*tmp_bs_p
= &tmp_bs
;
13226 /* dprintf's never cause a stop. This wasn't set in the
13227 check_status hook instead because that would make the dprintf's
13228 condition not be evaluated. */
13231 /* Run the command list here. Take ownership of it instead of
13232 copying. We never want these commands to run later in
13233 bpstat_do_actions, if a breakpoint that causes a stop happens to
13234 be set at same address as this dprintf, or even if running the
13235 commands here throws. */
13236 tmp_bs
.commands
= bs
->commands
;
13237 bs
->commands
= NULL
;
13239 bpstat_do_actions_1 (&tmp_bs_p
);
13241 /* 'tmp_bs.commands' will usually be NULL by now, but
13242 bpstat_do_actions_1 may return early without processing the whole
13246 /* The breakpoint_ops structure to be used on static tracepoints with
13250 strace_marker_create_sals_from_location (struct event_location
*location
,
13251 struct linespec_result
*canonical
,
13252 enum bptype type_wanted
)
13254 struct linespec_sals lsal
;
13255 const char *arg_start
, *arg
;
13257 arg
= arg_start
= get_linespec_location (location
)->spec_string
;
13258 lsal
.sals
= decode_static_tracepoint_spec (&arg
);
13260 std::string
str (arg_start
, arg
- arg_start
);
13261 const char *ptr
= str
.c_str ();
13262 canonical
->location
13263 = new_linespec_location (&ptr
, symbol_name_match_type::FULL
);
13266 = xstrdup (event_location_to_string (canonical
->location
.get ()));
13267 canonical
->lsals
.push_back (std::move (lsal
));
13271 strace_marker_create_breakpoints_sal (struct gdbarch
*gdbarch
,
13272 struct linespec_result
*canonical
,
13273 gdb::unique_xmalloc_ptr
<char> cond_string
,
13274 gdb::unique_xmalloc_ptr
<char> extra_string
,
13275 enum bptype type_wanted
,
13276 enum bpdisp disposition
,
13278 int task
, int ignore_count
,
13279 const struct breakpoint_ops
*ops
,
13280 int from_tty
, int enabled
,
13281 int internal
, unsigned flags
)
13283 const linespec_sals
&lsal
= canonical
->lsals
[0];
13285 /* If the user is creating a static tracepoint by marker id
13286 (strace -m MARKER_ID), then store the sals index, so that
13287 breakpoint_re_set can try to match up which of the newly
13288 found markers corresponds to this one, and, don't try to
13289 expand multiple locations for each sal, given than SALS
13290 already should contain all sals for MARKER_ID. */
13292 for (size_t i
= 0; i
< lsal
.sals
.size (); i
++)
13294 event_location_up location
13295 = copy_event_location (canonical
->location
.get ());
13297 std::unique_ptr
<tracepoint
> tp (new tracepoint ());
13298 init_breakpoint_sal (tp
.get (), gdbarch
, lsal
.sals
[i
],
13299 std::move (location
), NULL
,
13300 std::move (cond_string
),
13301 std::move (extra_string
),
13302 type_wanted
, disposition
,
13303 thread
, task
, ignore_count
, ops
,
13304 from_tty
, enabled
, internal
, flags
,
13305 canonical
->special_display
);
13306 /* Given that its possible to have multiple markers with
13307 the same string id, if the user is creating a static
13308 tracepoint by marker id ("strace -m MARKER_ID"), then
13309 store the sals index, so that breakpoint_re_set can
13310 try to match up which of the newly found markers
13311 corresponds to this one */
13312 tp
->static_trace_marker_id_idx
= i
;
13314 install_breakpoint (internal
, std::move (tp
), 0);
13318 static std::vector
<symtab_and_line
>
13319 strace_marker_decode_location (struct breakpoint
*b
,
13320 struct event_location
*location
,
13321 struct program_space
*search_pspace
)
13323 struct tracepoint
*tp
= (struct tracepoint
*) b
;
13324 const char *s
= get_linespec_location (location
)->spec_string
;
13326 std::vector
<symtab_and_line
> sals
= decode_static_tracepoint_spec (&s
);
13327 if (sals
.size () > tp
->static_trace_marker_id_idx
)
13329 sals
[0] = sals
[tp
->static_trace_marker_id_idx
];
13334 error (_("marker %s not found"), tp
->static_trace_marker_id
.c_str ());
13337 static struct breakpoint_ops strace_marker_breakpoint_ops
;
13340 strace_marker_p (struct breakpoint
*b
)
13342 return b
->ops
== &strace_marker_breakpoint_ops
;
13345 /* Delete a breakpoint and clean up all traces of it in the data
13349 delete_breakpoint (struct breakpoint
*bpt
)
13351 struct breakpoint
*b
;
13353 gdb_assert (bpt
!= NULL
);
13355 /* Has this bp already been deleted? This can happen because
13356 multiple lists can hold pointers to bp's. bpstat lists are
13359 One example of this happening is a watchpoint's scope bp. When
13360 the scope bp triggers, we notice that the watchpoint is out of
13361 scope, and delete it. We also delete its scope bp. But the
13362 scope bp is marked "auto-deleting", and is already on a bpstat.
13363 That bpstat is then checked for auto-deleting bp's, which are
13366 A real solution to this problem might involve reference counts in
13367 bp's, and/or giving them pointers back to their referencing
13368 bpstat's, and teaching delete_breakpoint to only free a bp's
13369 storage when no more references were extent. A cheaper bandaid
13371 if (bpt
->type
== bp_none
)
13374 /* At least avoid this stale reference until the reference counting
13375 of breakpoints gets resolved. */
13376 if (bpt
->related_breakpoint
!= bpt
)
13378 struct breakpoint
*related
;
13379 struct watchpoint
*w
;
13381 if (bpt
->type
== bp_watchpoint_scope
)
13382 w
= (struct watchpoint
*) bpt
->related_breakpoint
;
13383 else if (bpt
->related_breakpoint
->type
== bp_watchpoint_scope
)
13384 w
= (struct watchpoint
*) bpt
;
13388 watchpoint_del_at_next_stop (w
);
13390 /* Unlink bpt from the bpt->related_breakpoint ring. */
13391 for (related
= bpt
; related
->related_breakpoint
!= bpt
;
13392 related
= related
->related_breakpoint
);
13393 related
->related_breakpoint
= bpt
->related_breakpoint
;
13394 bpt
->related_breakpoint
= bpt
;
13397 /* watch_command_1 creates a watchpoint but only sets its number if
13398 update_watchpoint succeeds in creating its bp_locations. If there's
13399 a problem in that process, we'll be asked to delete the half-created
13400 watchpoint. In that case, don't announce the deletion. */
13402 gdb::observers::breakpoint_deleted
.notify (bpt
);
13404 if (breakpoint_chain
== bpt
)
13405 breakpoint_chain
= bpt
->next
;
13407 ALL_BREAKPOINTS (b
)
13408 if (b
->next
== bpt
)
13410 b
->next
= bpt
->next
;
13414 /* Be sure no bpstat's are pointing at the breakpoint after it's
13416 /* FIXME, how can we find all bpstat's? We just check stop_bpstat
13417 in all threads for now. Note that we cannot just remove bpstats
13418 pointing at bpt from the stop_bpstat list entirely, as breakpoint
13419 commands are associated with the bpstat; if we remove it here,
13420 then the later call to bpstat_do_actions (&stop_bpstat); in
13421 event-top.c won't do anything, and temporary breakpoints with
13422 commands won't work. */
13424 iterate_over_threads (bpstat_remove_breakpoint_callback
, bpt
);
13426 /* Now that breakpoint is removed from breakpoint list, update the
13427 global location list. This will remove locations that used to
13428 belong to this breakpoint. Do this before freeing the breakpoint
13429 itself, since remove_breakpoint looks at location's owner. It
13430 might be better design to have location completely
13431 self-contained, but it's not the case now. */
13432 update_global_location_list (UGLL_DONT_INSERT
);
13434 /* On the chance that someone will soon try again to delete this
13435 same bp, we mark it as deleted before freeing its storage. */
13436 bpt
->type
= bp_none
;
13440 /* Iterator function to call a user-provided callback function once
13441 for each of B and its related breakpoints. */
13444 iterate_over_related_breakpoints (struct breakpoint
*b
,
13445 gdb::function_view
<void (breakpoint
*)> function
)
13447 struct breakpoint
*related
;
13452 struct breakpoint
*next
;
13454 /* FUNCTION may delete RELATED. */
13455 next
= related
->related_breakpoint
;
13457 if (next
== related
)
13459 /* RELATED is the last ring entry. */
13460 function (related
);
13462 /* FUNCTION may have deleted it, so we'd never reach back to
13463 B. There's nothing left to do anyway, so just break
13468 function (related
);
13472 while (related
!= b
);
13476 delete_command (const char *arg
, int from_tty
)
13478 struct breakpoint
*b
, *b_tmp
;
13484 int breaks_to_delete
= 0;
13486 /* Delete all breakpoints if no argument. Do not delete
13487 internal breakpoints, these have to be deleted with an
13488 explicit breakpoint number argument. */
13489 ALL_BREAKPOINTS (b
)
13490 if (user_breakpoint_p (b
))
13492 breaks_to_delete
= 1;
13496 /* Ask user only if there are some breakpoints to delete. */
13498 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
13500 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
13501 if (user_breakpoint_p (b
))
13502 delete_breakpoint (b
);
13506 map_breakpoint_numbers
13507 (arg
, [&] (breakpoint
*br
)
13509 iterate_over_related_breakpoints (br
, delete_breakpoint
);
13513 /* Return true if all locations of B bound to PSPACE are pending. If
13514 PSPACE is NULL, all locations of all program spaces are
13518 all_locations_are_pending (struct breakpoint
*b
, struct program_space
*pspace
)
13520 struct bp_location
*loc
;
13522 for (loc
= b
->loc
; loc
!= NULL
; loc
= loc
->next
)
13523 if ((pspace
== NULL
13524 || loc
->pspace
== pspace
)
13525 && !loc
->shlib_disabled
13526 && !loc
->pspace
->executing_startup
)
13531 /* Subroutine of update_breakpoint_locations to simplify it.
13532 Return non-zero if multiple fns in list LOC have the same name.
13533 Null names are ignored. */
13536 ambiguous_names_p (struct bp_location
*loc
)
13538 struct bp_location
*l
;
13539 htab_up
htab (htab_create_alloc (13, htab_hash_string
, streq_hash
, NULL
,
13542 for (l
= loc
; l
!= NULL
; l
= l
->next
)
13545 const char *name
= l
->function_name
;
13547 /* Allow for some names to be NULL, ignore them. */
13551 slot
= (const char **) htab_find_slot (htab
.get (), (const void *) name
,
13553 /* NOTE: We can assume slot != NULL here because xcalloc never
13563 /* When symbols change, it probably means the sources changed as well,
13564 and it might mean the static tracepoint markers are no longer at
13565 the same address or line numbers they used to be at last we
13566 checked. Losing your static tracepoints whenever you rebuild is
13567 undesirable. This function tries to resync/rematch gdb static
13568 tracepoints with the markers on the target, for static tracepoints
13569 that have not been set by marker id. Static tracepoint that have
13570 been set by marker id are reset by marker id in breakpoint_re_set.
13573 1) For a tracepoint set at a specific address, look for a marker at
13574 the old PC. If one is found there, assume to be the same marker.
13575 If the name / string id of the marker found is different from the
13576 previous known name, assume that means the user renamed the marker
13577 in the sources, and output a warning.
13579 2) For a tracepoint set at a given line number, look for a marker
13580 at the new address of the old line number. If one is found there,
13581 assume to be the same marker. If the name / string id of the
13582 marker found is different from the previous known name, assume that
13583 means the user renamed the marker in the sources, and output a
13586 3) If a marker is no longer found at the same address or line, it
13587 may mean the marker no longer exists. But it may also just mean
13588 the code changed a bit. Maybe the user added a few lines of code
13589 that made the marker move up or down (in line number terms). Ask
13590 the target for info about the marker with the string id as we knew
13591 it. If found, update line number and address in the matching
13592 static tracepoint. This will get confused if there's more than one
13593 marker with the same ID (possible in UST, although unadvised
13594 precisely because it confuses tools). */
13596 static struct symtab_and_line
13597 update_static_tracepoint (struct breakpoint
*b
, struct symtab_and_line sal
)
13599 struct tracepoint
*tp
= (struct tracepoint
*) b
;
13600 struct static_tracepoint_marker marker
;
13605 find_line_pc (sal
.symtab
, sal
.line
, &pc
);
13607 if (target_static_tracepoint_marker_at (pc
, &marker
))
13609 if (tp
->static_trace_marker_id
!= marker
.str_id
)
13610 warning (_("static tracepoint %d changed probed marker from %s to %s"),
13611 b
->number
, tp
->static_trace_marker_id
.c_str (),
13612 marker
.str_id
.c_str ());
13614 tp
->static_trace_marker_id
= std::move (marker
.str_id
);
13619 /* Old marker wasn't found on target at lineno. Try looking it up
13621 if (!sal
.explicit_pc
13623 && sal
.symtab
!= NULL
13624 && !tp
->static_trace_marker_id
.empty ())
13626 std::vector
<static_tracepoint_marker
> markers
13627 = target_static_tracepoint_markers_by_strid
13628 (tp
->static_trace_marker_id
.c_str ());
13630 if (!markers
.empty ())
13632 struct symbol
*sym
;
13633 struct static_tracepoint_marker
*tpmarker
;
13634 struct ui_out
*uiout
= current_uiout
;
13635 struct explicit_location explicit_loc
;
13637 tpmarker
= &markers
[0];
13639 tp
->static_trace_marker_id
= std::move (tpmarker
->str_id
);
13641 warning (_("marker for static tracepoint %d (%s) not "
13642 "found at previous line number"),
13643 b
->number
, tp
->static_trace_marker_id
.c_str ());
13645 symtab_and_line sal2
= find_pc_line (tpmarker
->address
, 0);
13646 sym
= find_pc_sect_function (tpmarker
->address
, NULL
);
13647 uiout
->text ("Now in ");
13650 uiout
->field_string ("func", sym
->print_name (),
13651 function_name_style
.style ());
13652 uiout
->text (" at ");
13654 uiout
->field_string ("file",
13655 symtab_to_filename_for_display (sal2
.symtab
),
13656 file_name_style
.style ());
13659 if (uiout
->is_mi_like_p ())
13661 const char *fullname
= symtab_to_fullname (sal2
.symtab
);
13663 uiout
->field_string ("fullname", fullname
);
13666 uiout
->field_signed ("line", sal2
.line
);
13667 uiout
->text ("\n");
13669 b
->loc
->line_number
= sal2
.line
;
13670 b
->loc
->symtab
= sym
!= NULL
? sal2
.symtab
: NULL
;
13672 b
->location
.reset (NULL
);
13673 initialize_explicit_location (&explicit_loc
);
13674 explicit_loc
.source_filename
13675 = ASTRDUP (symtab_to_filename_for_display (sal2
.symtab
));
13676 explicit_loc
.line_offset
.offset
= b
->loc
->line_number
;
13677 explicit_loc
.line_offset
.sign
= LINE_OFFSET_NONE
;
13678 b
->location
= new_explicit_location (&explicit_loc
);
13680 /* Might be nice to check if function changed, and warn if
13687 /* Returns 1 iff locations A and B are sufficiently same that
13688 we don't need to report breakpoint as changed. */
13691 locations_are_equal (struct bp_location
*a
, struct bp_location
*b
)
13695 if (a
->address
!= b
->address
)
13698 if (a
->shlib_disabled
!= b
->shlib_disabled
)
13701 if (a
->enabled
!= b
->enabled
)
13704 if (a
->disabled_by_cond
!= b
->disabled_by_cond
)
13711 if ((a
== NULL
) != (b
== NULL
))
13717 /* Split all locations of B that are bound to PSPACE out of B's
13718 location list to a separate list and return that list's head. If
13719 PSPACE is NULL, hoist out all locations of B. */
13721 static struct bp_location
*
13722 hoist_existing_locations (struct breakpoint
*b
, struct program_space
*pspace
)
13724 struct bp_location head
;
13725 struct bp_location
*i
= b
->loc
;
13726 struct bp_location
**i_link
= &b
->loc
;
13727 struct bp_location
*hoisted
= &head
;
13729 if (pspace
== NULL
)
13740 if (i
->pspace
== pspace
)
13755 /* Create new breakpoint locations for B (a hardware or software
13756 breakpoint) based on SALS and SALS_END. If SALS_END.NELTS is not
13757 zero, then B is a ranged breakpoint. Only recreates locations for
13758 FILTER_PSPACE. Locations of other program spaces are left
13762 update_breakpoint_locations (struct breakpoint
*b
,
13763 struct program_space
*filter_pspace
,
13764 gdb::array_view
<const symtab_and_line
> sals
,
13765 gdb::array_view
<const symtab_and_line
> sals_end
)
13767 struct bp_location
*existing_locations
;
13769 if (!sals_end
.empty () && (sals
.size () != 1 || sals_end
.size () != 1))
13771 /* Ranged breakpoints have only one start location and one end
13773 b
->enable_state
= bp_disabled
;
13774 printf_unfiltered (_("Could not reset ranged breakpoint %d: "
13775 "multiple locations found\n"),
13780 /* If there's no new locations, and all existing locations are
13781 pending, don't do anything. This optimizes the common case where
13782 all locations are in the same shared library, that was unloaded.
13783 We'd like to retain the location, so that when the library is
13784 loaded again, we don't loose the enabled/disabled status of the
13785 individual locations. */
13786 if (all_locations_are_pending (b
, filter_pspace
) && sals
.empty ())
13789 existing_locations
= hoist_existing_locations (b
, filter_pspace
);
13791 for (const auto &sal
: sals
)
13793 struct bp_location
*new_loc
;
13795 switch_to_program_space_and_thread (sal
.pspace
);
13797 new_loc
= add_location_to_breakpoint (b
, &sal
);
13799 /* Reparse conditions, they might contain references to the
13801 if (b
->cond_string
!= NULL
)
13805 s
= b
->cond_string
;
13808 new_loc
->cond
= parse_exp_1 (&s
, sal
.pc
,
13809 block_for_pc (sal
.pc
),
13812 catch (const gdb_exception_error
&e
)
13814 new_loc
->disabled_by_cond
= true;
13818 if (!sals_end
.empty ())
13820 CORE_ADDR end
= find_breakpoint_range_end (sals_end
[0]);
13822 new_loc
->length
= end
- sals
[0].pc
+ 1;
13826 /* If possible, carry over 'disable' status from existing
13829 struct bp_location
*e
= existing_locations
;
13830 /* If there are multiple breakpoints with the same function name,
13831 e.g. for inline functions, comparing function names won't work.
13832 Instead compare pc addresses; this is just a heuristic as things
13833 may have moved, but in practice it gives the correct answer
13834 often enough until a better solution is found. */
13835 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
13837 for (; e
; e
= e
->next
)
13839 if ((!e
->enabled
|| e
->disabled_by_cond
) && e
->function_name
)
13841 struct bp_location
*l
= b
->loc
;
13842 if (have_ambiguous_names
)
13844 for (; l
; l
= l
->next
)
13846 /* Ignore software vs hardware location type at
13847 this point, because with "set breakpoint
13848 auto-hw", after a re-set, locations that were
13849 hardware can end up as software, or vice versa.
13850 As mentioned above, this is an heuristic and in
13851 practice should give the correct answer often
13853 if (breakpoint_locations_match (e
, l
, true))
13855 l
->enabled
= e
->enabled
;
13856 l
->disabled_by_cond
= e
->disabled_by_cond
;
13863 for (; l
; l
= l
->next
)
13864 if (l
->function_name
13865 && strcmp (e
->function_name
, l
->function_name
) == 0)
13867 l
->enabled
= e
->enabled
;
13868 l
->disabled_by_cond
= e
->disabled_by_cond
;
13876 if (!locations_are_equal (existing_locations
, b
->loc
))
13877 gdb::observers::breakpoint_modified
.notify (b
);
13880 /* Find the SaL locations corresponding to the given LOCATION.
13881 On return, FOUND will be 1 if any SaL was found, zero otherwise. */
13883 static std::vector
<symtab_and_line
>
13884 location_to_sals (struct breakpoint
*b
, struct event_location
*location
,
13885 struct program_space
*search_pspace
, int *found
)
13887 struct gdb_exception exception
;
13889 gdb_assert (b
->ops
!= NULL
);
13891 std::vector
<symtab_and_line
> sals
;
13895 sals
= b
->ops
->decode_location (b
, location
, search_pspace
);
13897 catch (gdb_exception_error
&e
)
13899 int not_found_and_ok
= 0;
13901 /* For pending breakpoints, it's expected that parsing will
13902 fail until the right shared library is loaded. User has
13903 already told to create pending breakpoints and don't need
13904 extra messages. If breakpoint is in bp_shlib_disabled
13905 state, then user already saw the message about that
13906 breakpoint being disabled, and don't want to see more
13908 if (e
.error
== NOT_FOUND_ERROR
13909 && (b
->condition_not_parsed
13911 && search_pspace
!= NULL
13912 && b
->loc
->pspace
!= search_pspace
)
13913 || (b
->loc
&& b
->loc
->shlib_disabled
)
13914 || (b
->loc
&& b
->loc
->pspace
->executing_startup
)
13915 || b
->enable_state
== bp_disabled
))
13916 not_found_and_ok
= 1;
13918 if (!not_found_and_ok
)
13920 /* We surely don't want to warn about the same breakpoint
13921 10 times. One solution, implemented here, is disable
13922 the breakpoint on error. Another solution would be to
13923 have separate 'warning emitted' flag. Since this
13924 happens only when a binary has changed, I don't know
13925 which approach is better. */
13926 b
->enable_state
= bp_disabled
;
13930 exception
= std::move (e
);
13933 if (exception
.reason
== 0 || exception
.error
!= NOT_FOUND_ERROR
)
13935 for (auto &sal
: sals
)
13936 resolve_sal_pc (&sal
);
13937 if (b
->condition_not_parsed
&& b
->extra_string
!= NULL
)
13939 char *cond_string
, *extra_string
;
13942 find_condition_and_thread_for_sals (sals
, b
->extra_string
,
13943 &cond_string
, &thread
,
13944 &task
, &extra_string
);
13945 gdb_assert (b
->cond_string
== NULL
);
13947 b
->cond_string
= cond_string
;
13948 b
->thread
= thread
;
13952 xfree (b
->extra_string
);
13953 b
->extra_string
= extra_string
;
13955 b
->condition_not_parsed
= 0;
13958 if (b
->type
== bp_static_tracepoint
&& !strace_marker_p (b
))
13959 sals
[0] = update_static_tracepoint (b
, sals
[0]);
13969 /* The default re_set method, for typical hardware or software
13970 breakpoints. Reevaluate the breakpoint and recreate its
13974 breakpoint_re_set_default (struct breakpoint
*b
)
13976 struct program_space
*filter_pspace
= current_program_space
;
13977 std::vector
<symtab_and_line
> expanded
, expanded_end
;
13980 std::vector
<symtab_and_line
> sals
= location_to_sals (b
, b
->location
.get (),
13981 filter_pspace
, &found
);
13983 expanded
= std::move (sals
);
13985 if (b
->location_range_end
!= NULL
)
13987 std::vector
<symtab_and_line
> sals_end
13988 = location_to_sals (b
, b
->location_range_end
.get (),
13989 filter_pspace
, &found
);
13991 expanded_end
= std::move (sals_end
);
13994 update_breakpoint_locations (b
, filter_pspace
, expanded
, expanded_end
);
13997 /* Default method for creating SALs from an address string. It basically
13998 calls parse_breakpoint_sals. Return 1 for success, zero for failure. */
14001 create_sals_from_location_default (struct event_location
*location
,
14002 struct linespec_result
*canonical
,
14003 enum bptype type_wanted
)
14005 parse_breakpoint_sals (location
, canonical
);
14008 /* Call create_breakpoints_sal for the given arguments. This is the default
14009 function for the `create_breakpoints_sal' method of
14013 create_breakpoints_sal_default (struct gdbarch
*gdbarch
,
14014 struct linespec_result
*canonical
,
14015 gdb::unique_xmalloc_ptr
<char> cond_string
,
14016 gdb::unique_xmalloc_ptr
<char> extra_string
,
14017 enum bptype type_wanted
,
14018 enum bpdisp disposition
,
14020 int task
, int ignore_count
,
14021 const struct breakpoint_ops
*ops
,
14022 int from_tty
, int enabled
,
14023 int internal
, unsigned flags
)
14025 create_breakpoints_sal (gdbarch
, canonical
,
14026 std::move (cond_string
),
14027 std::move (extra_string
),
14028 type_wanted
, disposition
,
14029 thread
, task
, ignore_count
, ops
, from_tty
,
14030 enabled
, internal
, flags
);
14033 /* Decode the line represented by S by calling decode_line_full. This is the
14034 default function for the `decode_location' method of breakpoint_ops. */
14036 static std::vector
<symtab_and_line
>
14037 decode_location_default (struct breakpoint
*b
,
14038 struct event_location
*location
,
14039 struct program_space
*search_pspace
)
14041 struct linespec_result canonical
;
14043 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, search_pspace
,
14044 NULL
, 0, &canonical
, multiple_symbols_all
,
14047 /* We should get 0 or 1 resulting SALs. */
14048 gdb_assert (canonical
.lsals
.size () < 2);
14050 if (!canonical
.lsals
.empty ())
14052 const linespec_sals
&lsal
= canonical
.lsals
[0];
14053 return std::move (lsal
.sals
);
14058 /* Reset a breakpoint. */
14061 breakpoint_re_set_one (breakpoint
*b
)
14063 input_radix
= b
->input_radix
;
14064 set_language (b
->language
);
14066 b
->ops
->re_set (b
);
14069 /* Re-set breakpoint locations for the current program space.
14070 Locations bound to other program spaces are left untouched. */
14073 breakpoint_re_set (void)
14075 struct breakpoint
*b
, *b_tmp
;
14078 scoped_restore_current_language save_language
;
14079 scoped_restore save_input_radix
= make_scoped_restore (&input_radix
);
14080 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
14082 /* breakpoint_re_set_one sets the current_language to the language
14083 of the breakpoint it is resetting (see prepare_re_set_context)
14084 before re-evaluating the breakpoint's location. This change can
14085 unfortunately get undone by accident if the language_mode is set
14086 to auto, and we either switch frames, or more likely in this context,
14087 we select the current frame.
14089 We prevent this by temporarily turning the language_mode to
14090 language_mode_manual. We restore it once all breakpoints
14091 have been reset. */
14092 scoped_restore save_language_mode
= make_scoped_restore (&language_mode
);
14093 language_mode
= language_mode_manual
;
14095 /* Note: we must not try to insert locations until after all
14096 breakpoints have been re-set. Otherwise, e.g., when re-setting
14097 breakpoint 1, we'd insert the locations of breakpoint 2, which
14098 hadn't been re-set yet, and thus may have stale locations. */
14100 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
14104 breakpoint_re_set_one (b
);
14106 catch (const gdb_exception
&ex
)
14108 exception_fprintf (gdb_stderr
, ex
,
14109 "Error in re-setting breakpoint %d: ",
14114 jit_breakpoint_re_set ();
14117 create_overlay_event_breakpoint ();
14118 create_longjmp_master_breakpoint ();
14119 create_std_terminate_master_breakpoint ();
14120 create_exception_master_breakpoint ();
14122 /* Now we can insert. */
14123 update_global_location_list (UGLL_MAY_INSERT
);
14126 /* Reset the thread number of this breakpoint:
14128 - If the breakpoint is for all threads, leave it as-is.
14129 - Else, reset it to the current thread for inferior_ptid. */
14131 breakpoint_re_set_thread (struct breakpoint
*b
)
14133 if (b
->thread
!= -1)
14135 b
->thread
= inferior_thread ()->global_num
;
14137 /* We're being called after following a fork. The new fork is
14138 selected as current, and unless this was a vfork will have a
14139 different program space from the original thread. Reset that
14141 b
->loc
->pspace
= current_program_space
;
14145 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14146 If from_tty is nonzero, it prints a message to that effect,
14147 which ends with a period (no newline). */
14150 set_ignore_count (int bptnum
, int count
, int from_tty
)
14152 struct breakpoint
*b
;
14157 ALL_BREAKPOINTS (b
)
14158 if (b
->number
== bptnum
)
14160 if (is_tracepoint (b
))
14162 if (from_tty
&& count
!= 0)
14163 printf_filtered (_("Ignore count ignored for tracepoint %d."),
14168 b
->ignore_count
= count
;
14172 printf_filtered (_("Will stop next time "
14173 "breakpoint %d is reached."),
14175 else if (count
== 1)
14176 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
14179 printf_filtered (_("Will ignore next %d "
14180 "crossings of breakpoint %d."),
14183 gdb::observers::breakpoint_modified
.notify (b
);
14187 error (_("No breakpoint number %d."), bptnum
);
14190 /* Command to set ignore-count of breakpoint N to COUNT. */
14193 ignore_command (const char *args
, int from_tty
)
14195 const char *p
= args
;
14199 error_no_arg (_("a breakpoint number"));
14201 num
= get_number (&p
);
14203 error (_("bad breakpoint number: '%s'"), args
);
14205 error (_("Second argument (specified ignore-count) is missing."));
14207 set_ignore_count (num
,
14208 longest_to_int (value_as_long (parse_and_eval (p
))),
14211 printf_filtered ("\n");
14215 /* Call FUNCTION on each of the breakpoints with numbers in the range
14216 defined by BP_NUM_RANGE (an inclusive range). */
14219 map_breakpoint_number_range (std::pair
<int, int> bp_num_range
,
14220 gdb::function_view
<void (breakpoint
*)> function
)
14222 if (bp_num_range
.first
== 0)
14224 warning (_("bad breakpoint number at or near '%d'"),
14225 bp_num_range
.first
);
14229 struct breakpoint
*b
, *tmp
;
14231 for (int i
= bp_num_range
.first
; i
<= bp_num_range
.second
; i
++)
14233 bool match
= false;
14235 ALL_BREAKPOINTS_SAFE (b
, tmp
)
14236 if (b
->number
== i
)
14243 printf_unfiltered (_("No breakpoint number %d.\n"), i
);
14248 /* Call FUNCTION on each of the breakpoints whose numbers are given in
14252 map_breakpoint_numbers (const char *args
,
14253 gdb::function_view
<void (breakpoint
*)> function
)
14255 if (args
== NULL
|| *args
== '\0')
14256 error_no_arg (_("one or more breakpoint numbers"));
14258 number_or_range_parser
parser (args
);
14260 while (!parser
.finished ())
14262 int num
= parser
.get_number ();
14263 map_breakpoint_number_range (std::make_pair (num
, num
), function
);
14267 /* Return the breakpoint location structure corresponding to the
14268 BP_NUM and LOC_NUM values. */
14270 static struct bp_location
*
14271 find_location_by_number (int bp_num
, int loc_num
)
14273 struct breakpoint
*b
;
14275 ALL_BREAKPOINTS (b
)
14276 if (b
->number
== bp_num
)
14281 if (!b
|| b
->number
!= bp_num
)
14282 error (_("Bad breakpoint number '%d'"), bp_num
);
14285 error (_("Bad breakpoint location number '%d'"), loc_num
);
14288 for (bp_location
*loc
= b
->loc
; loc
!= NULL
; loc
= loc
->next
)
14289 if (++n
== loc_num
)
14292 error (_("Bad breakpoint location number '%d'"), loc_num
);
14295 /* Modes of operation for extract_bp_num. */
14296 enum class extract_bp_kind
14298 /* Extracting a breakpoint number. */
14301 /* Extracting a location number. */
14305 /* Extract a breakpoint or location number (as determined by KIND)
14306 from the string starting at START. TRAILER is a character which
14307 can be found after the number. If you don't want a trailer, use
14308 '\0'. If END_OUT is not NULL, it is set to point after the parsed
14309 string. This always returns a positive integer. */
14312 extract_bp_num (extract_bp_kind kind
, const char *start
,
14313 int trailer
, const char **end_out
= NULL
)
14315 const char *end
= start
;
14316 int num
= get_number_trailer (&end
, trailer
);
14318 error (kind
== extract_bp_kind::bp
14319 ? _("Negative breakpoint number '%.*s'")
14320 : _("Negative breakpoint location number '%.*s'"),
14321 int (end
- start
), start
);
14323 error (kind
== extract_bp_kind::bp
14324 ? _("Bad breakpoint number '%.*s'")
14325 : _("Bad breakpoint location number '%.*s'"),
14326 int (end
- start
), start
);
14328 if (end_out
!= NULL
)
14333 /* Extract a breakpoint or location range (as determined by KIND) in
14334 the form NUM1-NUM2 stored at &ARG[arg_offset]. Returns a std::pair
14335 representing the (inclusive) range. The returned pair's elements
14336 are always positive integers. */
14338 static std::pair
<int, int>
14339 extract_bp_or_bp_range (extract_bp_kind kind
,
14340 const std::string
&arg
,
14341 std::string::size_type arg_offset
)
14343 std::pair
<int, int> range
;
14344 const char *bp_loc
= &arg
[arg_offset
];
14345 std::string::size_type dash
= arg
.find ('-', arg_offset
);
14346 if (dash
!= std::string::npos
)
14348 /* bp_loc is a range (x-z). */
14349 if (arg
.length () == dash
+ 1)
14350 error (kind
== extract_bp_kind::bp
14351 ? _("Bad breakpoint number at or near: '%s'")
14352 : _("Bad breakpoint location number at or near: '%s'"),
14356 const char *start_first
= bp_loc
;
14357 const char *start_second
= &arg
[dash
+ 1];
14358 range
.first
= extract_bp_num (kind
, start_first
, '-');
14359 range
.second
= extract_bp_num (kind
, start_second
, '\0', &end
);
14361 if (range
.first
> range
.second
)
14362 error (kind
== extract_bp_kind::bp
14363 ? _("Inverted breakpoint range at '%.*s'")
14364 : _("Inverted breakpoint location range at '%.*s'"),
14365 int (end
- start_first
), start_first
);
14369 /* bp_loc is a single value. */
14370 range
.first
= extract_bp_num (kind
, bp_loc
, '\0');
14371 range
.second
= range
.first
;
14376 /* Extract the breakpoint/location range specified by ARG. Returns
14377 the breakpoint range in BP_NUM_RANGE, and the location range in
14380 ARG may be in any of the following forms:
14382 x where 'x' is a breakpoint number.
14383 x-y where 'x' and 'y' specify a breakpoint numbers range.
14384 x.y where 'x' is a breakpoint number and 'y' a location number.
14385 x.y-z where 'x' is a breakpoint number and 'y' and 'z' specify a
14386 location number range.
14390 extract_bp_number_and_location (const std::string
&arg
,
14391 std::pair
<int, int> &bp_num_range
,
14392 std::pair
<int, int> &bp_loc_range
)
14394 std::string::size_type dot
= arg
.find ('.');
14396 if (dot
!= std::string::npos
)
14398 /* Handle 'x.y' and 'x.y-z' cases. */
14400 if (arg
.length () == dot
+ 1 || dot
== 0)
14401 error (_("Bad breakpoint number at or near: '%s'"), arg
.c_str ());
14404 = extract_bp_num (extract_bp_kind::bp
, arg
.c_str (), '.');
14405 bp_num_range
.second
= bp_num_range
.first
;
14407 bp_loc_range
= extract_bp_or_bp_range (extract_bp_kind::loc
,
14412 /* Handle x and x-y cases. */
14414 bp_num_range
= extract_bp_or_bp_range (extract_bp_kind::bp
, arg
, 0);
14415 bp_loc_range
.first
= 0;
14416 bp_loc_range
.second
= 0;
14420 /* Enable or disable a breakpoint location BP_NUM.LOC_NUM. ENABLE
14421 specifies whether to enable or disable. */
14424 enable_disable_bp_num_loc (int bp_num
, int loc_num
, bool enable
)
14426 struct bp_location
*loc
= find_location_by_number (bp_num
, loc_num
);
14429 if (loc
->disabled_by_cond
&& enable
)
14430 error (_("Breakpoint %d's condition is invalid at location %d, "
14431 "cannot enable."), bp_num
, loc_num
);
14433 if (loc
->enabled
!= enable
)
14435 loc
->enabled
= enable
;
14436 mark_breakpoint_location_modified (loc
);
14438 if (target_supports_enable_disable_tracepoint ()
14439 && current_trace_status ()->running
&& loc
->owner
14440 && is_tracepoint (loc
->owner
))
14441 target_disable_tracepoint (loc
);
14443 update_global_location_list (UGLL_DONT_INSERT
);
14445 gdb::observers::breakpoint_modified
.notify (loc
->owner
);
14448 /* Enable or disable a range of breakpoint locations. BP_NUM is the
14449 number of the breakpoint, and BP_LOC_RANGE specifies the
14450 (inclusive) range of location numbers of that breakpoint to
14451 enable/disable. ENABLE specifies whether to enable or disable the
14455 enable_disable_breakpoint_location_range (int bp_num
,
14456 std::pair
<int, int> &bp_loc_range
,
14459 for (int i
= bp_loc_range
.first
; i
<= bp_loc_range
.second
; i
++)
14460 enable_disable_bp_num_loc (bp_num
, i
, enable
);
14463 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14464 If from_tty is nonzero, it prints a message to that effect,
14465 which ends with a period (no newline). */
14468 disable_breakpoint (struct breakpoint
*bpt
)
14470 /* Never disable a watchpoint scope breakpoint; we want to
14471 hit them when we leave scope so we can delete both the
14472 watchpoint and its scope breakpoint at that time. */
14473 if (bpt
->type
== bp_watchpoint_scope
)
14476 bpt
->enable_state
= bp_disabled
;
14478 /* Mark breakpoint locations modified. */
14479 mark_breakpoint_modified (bpt
);
14481 if (target_supports_enable_disable_tracepoint ()
14482 && current_trace_status ()->running
&& is_tracepoint (bpt
))
14484 struct bp_location
*location
;
14486 for (location
= bpt
->loc
; location
; location
= location
->next
)
14487 target_disable_tracepoint (location
);
14490 update_global_location_list (UGLL_DONT_INSERT
);
14492 gdb::observers::breakpoint_modified
.notify (bpt
);
14495 /* Enable or disable the breakpoint(s) or breakpoint location(s)
14496 specified in ARGS. ARGS may be in any of the formats handled by
14497 extract_bp_number_and_location. ENABLE specifies whether to enable
14498 or disable the breakpoints/locations. */
14501 enable_disable_command (const char *args
, int from_tty
, bool enable
)
14505 struct breakpoint
*bpt
;
14507 ALL_BREAKPOINTS (bpt
)
14508 if (user_breakpoint_p (bpt
))
14511 enable_breakpoint (bpt
);
14513 disable_breakpoint (bpt
);
14518 std::string num
= extract_arg (&args
);
14520 while (!num
.empty ())
14522 std::pair
<int, int> bp_num_range
, bp_loc_range
;
14524 extract_bp_number_and_location (num
, bp_num_range
, bp_loc_range
);
14526 if (bp_loc_range
.first
== bp_loc_range
.second
14527 && bp_loc_range
.first
== 0)
14529 /* Handle breakpoint ids with formats 'x' or 'x-z'. */
14530 map_breakpoint_number_range (bp_num_range
,
14532 ? enable_breakpoint
14533 : disable_breakpoint
);
14537 /* Handle breakpoint ids with formats 'x.y' or
14539 enable_disable_breakpoint_location_range
14540 (bp_num_range
.first
, bp_loc_range
, enable
);
14542 num
= extract_arg (&args
);
14547 /* The disable command disables the specified breakpoints/locations
14548 (or all defined breakpoints) so they're no longer effective in
14549 stopping the inferior. ARGS may be in any of the forms defined in
14550 extract_bp_number_and_location. */
14553 disable_command (const char *args
, int from_tty
)
14555 enable_disable_command (args
, from_tty
, false);
14559 enable_breakpoint_disp (struct breakpoint
*bpt
, enum bpdisp disposition
,
14562 int target_resources_ok
;
14564 if (bpt
->type
== bp_hardware_breakpoint
)
14567 i
= hw_breakpoint_used_count ();
14568 target_resources_ok
=
14569 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
14571 if (target_resources_ok
== 0)
14572 error (_("No hardware breakpoint support in the target."));
14573 else if (target_resources_ok
< 0)
14574 error (_("Hardware breakpoints used exceeds limit."));
14577 if (is_watchpoint (bpt
))
14579 /* Initialize it just to avoid a GCC false warning. */
14580 enum enable_state orig_enable_state
= bp_disabled
;
14584 struct watchpoint
*w
= (struct watchpoint
*) bpt
;
14586 orig_enable_state
= bpt
->enable_state
;
14587 bpt
->enable_state
= bp_enabled
;
14588 update_watchpoint (w
, 1 /* reparse */);
14590 catch (const gdb_exception
&e
)
14592 bpt
->enable_state
= orig_enable_state
;
14593 exception_fprintf (gdb_stderr
, e
, _("Cannot enable watchpoint %d: "),
14599 bpt
->enable_state
= bp_enabled
;
14601 /* Mark breakpoint locations modified. */
14602 mark_breakpoint_modified (bpt
);
14604 if (target_supports_enable_disable_tracepoint ()
14605 && current_trace_status ()->running
&& is_tracepoint (bpt
))
14607 struct bp_location
*location
;
14609 for (location
= bpt
->loc
; location
; location
= location
->next
)
14610 target_enable_tracepoint (location
);
14613 bpt
->disposition
= disposition
;
14614 bpt
->enable_count
= count
;
14615 update_global_location_list (UGLL_MAY_INSERT
);
14617 gdb::observers::breakpoint_modified
.notify (bpt
);
14622 enable_breakpoint (struct breakpoint
*bpt
)
14624 enable_breakpoint_disp (bpt
, bpt
->disposition
, 0);
14627 /* The enable command enables the specified breakpoints/locations (or
14628 all defined breakpoints) so they once again become (or continue to
14629 be) effective in stopping the inferior. ARGS may be in any of the
14630 forms defined in extract_bp_number_and_location. */
14633 enable_command (const char *args
, int from_tty
)
14635 enable_disable_command (args
, from_tty
, true);
14639 enable_once_command (const char *args
, int from_tty
)
14641 map_breakpoint_numbers
14642 (args
, [&] (breakpoint
*b
)
14644 iterate_over_related_breakpoints
14645 (b
, [&] (breakpoint
*bpt
)
14647 enable_breakpoint_disp (bpt
, disp_disable
, 1);
14653 enable_count_command (const char *args
, int from_tty
)
14658 error_no_arg (_("hit count"));
14660 count
= get_number (&args
);
14662 map_breakpoint_numbers
14663 (args
, [&] (breakpoint
*b
)
14665 iterate_over_related_breakpoints
14666 (b
, [&] (breakpoint
*bpt
)
14668 enable_breakpoint_disp (bpt
, disp_disable
, count
);
14674 enable_delete_command (const char *args
, int from_tty
)
14676 map_breakpoint_numbers
14677 (args
, [&] (breakpoint
*b
)
14679 iterate_over_related_breakpoints
14680 (b
, [&] (breakpoint
*bpt
)
14682 enable_breakpoint_disp (bpt
, disp_del
, 1);
14687 /* Invalidate last known value of any hardware watchpoint if
14688 the memory which that value represents has been written to by
14692 invalidate_bp_value_on_memory_change (struct inferior
*inferior
,
14693 CORE_ADDR addr
, ssize_t len
,
14694 const bfd_byte
*data
)
14696 struct breakpoint
*bp
;
14698 ALL_BREAKPOINTS (bp
)
14699 if (bp
->enable_state
== bp_enabled
14700 && bp
->type
== bp_hardware_watchpoint
)
14702 struct watchpoint
*wp
= (struct watchpoint
*) bp
;
14704 if (wp
->val_valid
&& wp
->val
!= nullptr)
14706 struct bp_location
*loc
;
14708 for (loc
= bp
->loc
; loc
!= NULL
; loc
= loc
->next
)
14709 if (loc
->loc_type
== bp_loc_hardware_watchpoint
14710 && loc
->address
+ loc
->length
> addr
14711 && addr
+ len
> loc
->address
)
14714 wp
->val_valid
= false;
14720 /* Create and insert a breakpoint for software single step. */
14723 insert_single_step_breakpoint (struct gdbarch
*gdbarch
,
14724 const address_space
*aspace
,
14727 struct thread_info
*tp
= inferior_thread ();
14728 struct symtab_and_line sal
;
14729 CORE_ADDR pc
= next_pc
;
14731 if (tp
->control
.single_step_breakpoints
== NULL
)
14733 tp
->control
.single_step_breakpoints
14734 = new_single_step_breakpoint (tp
->global_num
, gdbarch
);
14737 sal
= find_pc_line (pc
, 0);
14739 sal
.section
= find_pc_overlay (pc
);
14740 sal
.explicit_pc
= 1;
14741 add_location_to_breakpoint (tp
->control
.single_step_breakpoints
, &sal
);
14743 update_global_location_list (UGLL_INSERT
);
14746 /* Insert single step breakpoints according to the current state. */
14749 insert_single_step_breakpoints (struct gdbarch
*gdbarch
)
14751 struct regcache
*regcache
= get_current_regcache ();
14752 std::vector
<CORE_ADDR
> next_pcs
;
14754 next_pcs
= gdbarch_software_single_step (gdbarch
, regcache
);
14756 if (!next_pcs
.empty ())
14758 struct frame_info
*frame
= get_current_frame ();
14759 const address_space
*aspace
= get_frame_address_space (frame
);
14761 for (CORE_ADDR pc
: next_pcs
)
14762 insert_single_step_breakpoint (gdbarch
, aspace
, pc
);
14770 /* See breakpoint.h. */
14773 breakpoint_has_location_inserted_here (struct breakpoint
*bp
,
14774 const address_space
*aspace
,
14777 struct bp_location
*loc
;
14779 for (loc
= bp
->loc
; loc
!= NULL
; loc
= loc
->next
)
14781 && breakpoint_location_address_match (loc
, aspace
, pc
))
14787 /* Check whether a software single-step breakpoint is inserted at
14791 single_step_breakpoint_inserted_here_p (const address_space
*aspace
,
14794 struct breakpoint
*bpt
;
14796 ALL_BREAKPOINTS (bpt
)
14798 if (bpt
->type
== bp_single_step
14799 && breakpoint_has_location_inserted_here (bpt
, aspace
, pc
))
14805 /* Tracepoint-specific operations. */
14807 /* Set tracepoint count to NUM. */
14809 set_tracepoint_count (int num
)
14811 tracepoint_count
= num
;
14812 set_internalvar_integer (lookup_internalvar ("tpnum"), num
);
14816 trace_command (const char *arg
, int from_tty
)
14818 event_location_up location
= string_to_event_location (&arg
,
14820 const struct breakpoint_ops
*ops
= breakpoint_ops_for_event_location
14821 (location
.get (), true /* is_tracepoint */);
14823 create_breakpoint (get_current_arch (),
14825 NULL
, 0, arg
, 1 /* parse arg */,
14827 bp_tracepoint
/* type_wanted */,
14828 0 /* Ignore count */,
14829 pending_break_support
,
14833 0 /* internal */, 0);
14837 ftrace_command (const char *arg
, int from_tty
)
14839 event_location_up location
= string_to_event_location (&arg
,
14841 create_breakpoint (get_current_arch (),
14843 NULL
, 0, arg
, 1 /* parse arg */,
14845 bp_fast_tracepoint
/* type_wanted */,
14846 0 /* Ignore count */,
14847 pending_break_support
,
14848 &tracepoint_breakpoint_ops
,
14851 0 /* internal */, 0);
14854 /* strace command implementation. Creates a static tracepoint. */
14857 strace_command (const char *arg
, int from_tty
)
14859 struct breakpoint_ops
*ops
;
14860 event_location_up location
;
14862 /* Decide if we are dealing with a static tracepoint marker (`-m'),
14863 or with a normal static tracepoint. */
14864 if (arg
&& startswith (arg
, "-m") && isspace (arg
[2]))
14866 ops
= &strace_marker_breakpoint_ops
;
14867 location
= new_linespec_location (&arg
, symbol_name_match_type::FULL
);
14871 ops
= &tracepoint_breakpoint_ops
;
14872 location
= string_to_event_location (&arg
, current_language
);
14875 create_breakpoint (get_current_arch (),
14877 NULL
, 0, arg
, 1 /* parse arg */,
14879 bp_static_tracepoint
/* type_wanted */,
14880 0 /* Ignore count */,
14881 pending_break_support
,
14885 0 /* internal */, 0);
14888 /* Set up a fake reader function that gets command lines from a linked
14889 list that was acquired during tracepoint uploading. */
14891 static struct uploaded_tp
*this_utp
;
14892 static int next_cmd
;
14895 read_uploaded_action (void)
14897 char *rslt
= nullptr;
14899 if (next_cmd
< this_utp
->cmd_strings
.size ())
14901 rslt
= this_utp
->cmd_strings
[next_cmd
].get ();
14908 /* Given information about a tracepoint as recorded on a target (which
14909 can be either a live system or a trace file), attempt to create an
14910 equivalent GDB tracepoint. This is not a reliable process, since
14911 the target does not necessarily have all the information used when
14912 the tracepoint was originally defined. */
14914 struct tracepoint
*
14915 create_tracepoint_from_upload (struct uploaded_tp
*utp
)
14917 const char *addr_str
;
14918 char small_buf
[100];
14919 struct tracepoint
*tp
;
14921 if (utp
->at_string
)
14922 addr_str
= utp
->at_string
.get ();
14925 /* In the absence of a source location, fall back to raw
14926 address. Since there is no way to confirm that the address
14927 means the same thing as when the trace was started, warn the
14929 warning (_("Uploaded tracepoint %d has no "
14930 "source location, using raw address"),
14932 xsnprintf (small_buf
, sizeof (small_buf
), "*%s", hex_string (utp
->addr
));
14933 addr_str
= small_buf
;
14936 /* There's not much we can do with a sequence of bytecodes. */
14937 if (utp
->cond
&& !utp
->cond_string
)
14938 warning (_("Uploaded tracepoint %d condition "
14939 "has no source form, ignoring it"),
14942 event_location_up location
= string_to_event_location (&addr_str
,
14944 if (!create_breakpoint (get_current_arch (),
14946 utp
->cond_string
.get (), -1, addr_str
,
14947 0 /* parse cond/thread */,
14949 utp
->type
/* type_wanted */,
14950 0 /* Ignore count */,
14951 pending_break_support
,
14952 &tracepoint_breakpoint_ops
,
14954 utp
->enabled
/* enabled */,
14956 CREATE_BREAKPOINT_FLAGS_INSERTED
))
14959 /* Get the tracepoint we just created. */
14960 tp
= get_tracepoint (tracepoint_count
);
14961 gdb_assert (tp
!= NULL
);
14965 xsnprintf (small_buf
, sizeof (small_buf
), "%d %d", utp
->pass
,
14968 trace_pass_command (small_buf
, 0);
14971 /* If we have uploaded versions of the original commands, set up a
14972 special-purpose "reader" function and call the usual command line
14973 reader, then pass the result to the breakpoint command-setting
14975 if (!utp
->cmd_strings
.empty ())
14977 counted_command_line cmd_list
;
14982 cmd_list
= read_command_lines_1 (read_uploaded_action
, 1, NULL
);
14984 breakpoint_set_commands (tp
, std::move (cmd_list
));
14986 else if (!utp
->actions
.empty ()
14987 || !utp
->step_actions
.empty ())
14988 warning (_("Uploaded tracepoint %d actions "
14989 "have no source form, ignoring them"),
14992 /* Copy any status information that might be available. */
14993 tp
->hit_count
= utp
->hit_count
;
14994 tp
->traceframe_usage
= utp
->traceframe_usage
;
14999 /* Print information on tracepoint number TPNUM_EXP, or all if
15003 info_tracepoints_command (const char *args
, int from_tty
)
15005 struct ui_out
*uiout
= current_uiout
;
15008 num_printed
= breakpoint_1 (args
, false, is_tracepoint
);
15010 if (num_printed
== 0)
15012 if (args
== NULL
|| *args
== '\0')
15013 uiout
->message ("No tracepoints.\n");
15015 uiout
->message ("No tracepoint matching '%s'.\n", args
);
15018 default_collect_info ();
15021 /* The 'enable trace' command enables tracepoints.
15022 Not supported by all targets. */
15024 enable_trace_command (const char *args
, int from_tty
)
15026 enable_command (args
, from_tty
);
15029 /* The 'disable trace' command disables tracepoints.
15030 Not supported by all targets. */
15032 disable_trace_command (const char *args
, int from_tty
)
15034 disable_command (args
, from_tty
);
15037 /* Remove a tracepoint (or all if no argument). */
15039 delete_trace_command (const char *arg
, int from_tty
)
15041 struct breakpoint
*b
, *b_tmp
;
15047 int breaks_to_delete
= 0;
15049 /* Delete all breakpoints if no argument.
15050 Do not delete internal or call-dummy breakpoints, these
15051 have to be deleted with an explicit breakpoint number
15053 ALL_TRACEPOINTS (b
)
15054 if (is_tracepoint (b
) && user_breakpoint_p (b
))
15056 breaks_to_delete
= 1;
15060 /* Ask user only if there are some breakpoints to delete. */
15062 || (breaks_to_delete
&& query (_("Delete all tracepoints? "))))
15064 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
15065 if (is_tracepoint (b
) && user_breakpoint_p (b
))
15066 delete_breakpoint (b
);
15070 map_breakpoint_numbers
15071 (arg
, [&] (breakpoint
*br
)
15073 iterate_over_related_breakpoints (br
, delete_breakpoint
);
15077 /* Helper function for trace_pass_command. */
15080 trace_pass_set_count (struct tracepoint
*tp
, int count
, int from_tty
)
15082 tp
->pass_count
= count
;
15083 gdb::observers::breakpoint_modified
.notify (tp
);
15085 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
15086 tp
->number
, count
);
15089 /* Set passcount for tracepoint.
15091 First command argument is passcount, second is tracepoint number.
15092 If tracepoint number omitted, apply to most recently defined.
15093 Also accepts special argument "all". */
15096 trace_pass_command (const char *args
, int from_tty
)
15098 struct tracepoint
*t1
;
15101 if (args
== 0 || *args
== 0)
15102 error (_("passcount command requires an "
15103 "argument (count + optional TP num)"));
15105 count
= strtoulst (args
, &args
, 10); /* Count comes first, then TP num. */
15107 args
= skip_spaces (args
);
15108 if (*args
&& strncasecmp (args
, "all", 3) == 0)
15110 struct breakpoint
*b
;
15112 args
+= 3; /* Skip special argument "all". */
15114 error (_("Junk at end of arguments."));
15116 ALL_TRACEPOINTS (b
)
15118 t1
= (struct tracepoint
*) b
;
15119 trace_pass_set_count (t1
, count
, from_tty
);
15122 else if (*args
== '\0')
15124 t1
= get_tracepoint_by_number (&args
, NULL
);
15126 trace_pass_set_count (t1
, count
, from_tty
);
15130 number_or_range_parser
parser (args
);
15131 while (!parser
.finished ())
15133 t1
= get_tracepoint_by_number (&args
, &parser
);
15135 trace_pass_set_count (t1
, count
, from_tty
);
15140 struct tracepoint
*
15141 get_tracepoint (int num
)
15143 struct breakpoint
*t
;
15145 ALL_TRACEPOINTS (t
)
15146 if (t
->number
== num
)
15147 return (struct tracepoint
*) t
;
15152 /* Find the tracepoint with the given target-side number (which may be
15153 different from the tracepoint number after disconnecting and
15156 struct tracepoint
*
15157 get_tracepoint_by_number_on_target (int num
)
15159 struct breakpoint
*b
;
15161 ALL_TRACEPOINTS (b
)
15163 struct tracepoint
*t
= (struct tracepoint
*) b
;
15165 if (t
->number_on_target
== num
)
15172 /* Utility: parse a tracepoint number and look it up in the list.
15173 If STATE is not NULL, use, get_number_or_range_state and ignore ARG.
15174 If the argument is missing, the most recent tracepoint
15175 (tracepoint_count) is returned. */
15177 struct tracepoint
*
15178 get_tracepoint_by_number (const char **arg
,
15179 number_or_range_parser
*parser
)
15181 struct breakpoint
*t
;
15183 const char *instring
= arg
== NULL
? NULL
: *arg
;
15185 if (parser
!= NULL
)
15187 gdb_assert (!parser
->finished ());
15188 tpnum
= parser
->get_number ();
15190 else if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
15191 tpnum
= tracepoint_count
;
15193 tpnum
= get_number (arg
);
15197 if (instring
&& *instring
)
15198 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
15201 printf_filtered (_("No previous tracepoint\n"));
15205 ALL_TRACEPOINTS (t
)
15206 if (t
->number
== tpnum
)
15208 return (struct tracepoint
*) t
;
15211 printf_unfiltered ("No tracepoint number %d.\n", tpnum
);
15216 print_recreate_thread (struct breakpoint
*b
, struct ui_file
*fp
)
15218 if (b
->thread
!= -1)
15219 fprintf_unfiltered (fp
, " thread %d", b
->thread
);
15222 fprintf_unfiltered (fp
, " task %d", b
->task
);
15224 fprintf_unfiltered (fp
, "\n");
15227 /* Save information on user settable breakpoints (watchpoints, etc) to
15228 a new script file named FILENAME. If FILTER is non-NULL, call it
15229 on each breakpoint and only include the ones for which it returns
15233 save_breakpoints (const char *filename
, int from_tty
,
15234 bool (*filter
) (const struct breakpoint
*))
15236 struct breakpoint
*tp
;
15238 int extra_trace_bits
= 0;
15240 if (filename
== 0 || *filename
== 0)
15241 error (_("Argument required (file name in which to save)"));
15243 /* See if we have anything to save. */
15244 ALL_BREAKPOINTS (tp
)
15246 /* Skip internal and momentary breakpoints. */
15247 if (!user_breakpoint_p (tp
))
15250 /* If we have a filter, only save the breakpoints it accepts. */
15251 if (filter
&& !filter (tp
))
15256 if (is_tracepoint (tp
))
15258 extra_trace_bits
= 1;
15260 /* We can stop searching. */
15267 warning (_("Nothing to save."));
15271 gdb::unique_xmalloc_ptr
<char> expanded_filename (tilde_expand (filename
));
15275 if (!fp
.open (expanded_filename
.get (), "w"))
15276 error (_("Unable to open file '%s' for saving (%s)"),
15277 expanded_filename
.get (), safe_strerror (errno
));
15279 if (extra_trace_bits
)
15280 save_trace_state_variables (&fp
);
15282 ALL_BREAKPOINTS (tp
)
15284 /* Skip internal and momentary breakpoints. */
15285 if (!user_breakpoint_p (tp
))
15288 /* If we have a filter, only save the breakpoints it accepts. */
15289 if (filter
&& !filter (tp
))
15292 tp
->ops
->print_recreate (tp
, &fp
);
15294 /* Note, we can't rely on tp->number for anything, as we can't
15295 assume the recreated breakpoint numbers will match. Use $bpnum
15298 if (tp
->cond_string
)
15299 fp
.printf (" condition $bpnum %s\n", tp
->cond_string
);
15301 if (tp
->ignore_count
)
15302 fp
.printf (" ignore $bpnum %d\n", tp
->ignore_count
);
15304 if (tp
->type
!= bp_dprintf
&& tp
->commands
)
15306 fp
.puts (" commands\n");
15308 current_uiout
->redirect (&fp
);
15311 print_command_lines (current_uiout
, tp
->commands
.get (), 2);
15313 catch (const gdb_exception
&ex
)
15315 current_uiout
->redirect (NULL
);
15319 current_uiout
->redirect (NULL
);
15320 fp
.puts (" end\n");
15323 if (tp
->enable_state
== bp_disabled
)
15324 fp
.puts ("disable $bpnum\n");
15326 /* If this is a multi-location breakpoint, check if the locations
15327 should be individually disabled. Watchpoint locations are
15328 special, and not user visible. */
15329 if (!is_watchpoint (tp
) && tp
->loc
&& tp
->loc
->next
)
15331 struct bp_location
*loc
;
15334 for (loc
= tp
->loc
; loc
!= NULL
; loc
= loc
->next
, n
++)
15336 fp
.printf ("disable $bpnum.%d\n", n
);
15340 if (extra_trace_bits
&& *default_collect
)
15341 fp
.printf ("set default-collect %s\n", default_collect
);
15344 printf_filtered (_("Saved to file '%s'.\n"), expanded_filename
.get ());
15347 /* The `save breakpoints' command. */
15350 save_breakpoints_command (const char *args
, int from_tty
)
15352 save_breakpoints (args
, from_tty
, NULL
);
15355 /* The `save tracepoints' command. */
15358 save_tracepoints_command (const char *args
, int from_tty
)
15360 save_breakpoints (args
, from_tty
, is_tracepoint
);
15363 /* Create a vector of all tracepoints. */
15365 std::vector
<breakpoint
*>
15366 all_tracepoints (void)
15368 std::vector
<breakpoint
*> tp_vec
;
15369 struct breakpoint
*tp
;
15371 ALL_TRACEPOINTS (tp
)
15373 tp_vec
.push_back (tp
);
15380 /* This help string is used to consolidate all the help string for specifying
15381 locations used by several commands. */
15383 #define LOCATION_HELP_STRING \
15384 "Linespecs are colon-separated lists of location parameters, such as\n\
15385 source filename, function name, label name, and line number.\n\
15386 Example: To specify the start of a label named \"the_top\" in the\n\
15387 function \"fact\" in the file \"factorial.c\", use\n\
15388 \"factorial.c:fact:the_top\".\n\
15390 Address locations begin with \"*\" and specify an exact address in the\n\
15391 program. Example: To specify the fourth byte past the start function\n\
15392 \"main\", use \"*main + 4\".\n\
15394 Explicit locations are similar to linespecs but use an option/argument\n\
15395 syntax to specify location parameters.\n\
15396 Example: To specify the start of the label named \"the_top\" in the\n\
15397 function \"fact\" in the file \"factorial.c\", use \"-source factorial.c\n\
15398 -function fact -label the_top\".\n\
15400 By default, a specified function is matched against the program's\n\
15401 functions in all scopes. For C++, this means in all namespaces and\n\
15402 classes. For Ada, this means in all packages. E.g., in C++,\n\
15403 \"func()\" matches \"A::func()\", \"A::B::func()\", etc. The\n\
15404 \"-qualified\" flag overrides this behavior, making GDB interpret the\n\
15405 specified name as a complete fully-qualified name instead."
15407 /* This help string is used for the break, hbreak, tbreak and thbreak
15408 commands. It is defined as a macro to prevent duplication.
15409 COMMAND should be a string constant containing the name of the
15412 #define BREAK_ARGS_HELP(command) \
15413 command" [PROBE_MODIFIER] [LOCATION] [thread THREADNUM]\n\
15414 \t[-force-condition] [if CONDITION]\n\
15415 PROBE_MODIFIER shall be present if the command is to be placed in a\n\
15416 probe point. Accepted values are `-probe' (for a generic, automatically\n\
15417 guessed probe type), `-probe-stap' (for a SystemTap probe) or \n\
15418 `-probe-dtrace' (for a DTrace probe).\n\
15419 LOCATION may be a linespec, address, or explicit location as described\n\
15422 With no LOCATION, uses current execution address of the selected\n\
15423 stack frame. This is useful for breaking on return to a stack frame.\n\
15425 THREADNUM is the number from \"info threads\".\n\
15426 CONDITION is a boolean expression.\n\
15428 With the \"-force-condition\" flag, the condition is defined even when\n\
15429 it is invalid for all current locations.\n\
15430 \n" LOCATION_HELP_STRING "\n\n\
15431 Multiple breakpoints at one place are permitted, and useful if their\n\
15432 conditions are different.\n\
15434 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
15436 /* List of subcommands for "catch". */
15437 static struct cmd_list_element
*catch_cmdlist
;
15439 /* List of subcommands for "tcatch". */
15440 static struct cmd_list_element
*tcatch_cmdlist
;
15443 add_catch_command (const char *name
, const char *docstring
,
15444 cmd_const_sfunc_ftype
*sfunc
,
15445 completer_ftype
*completer
,
15446 void *user_data_catch
,
15447 void *user_data_tcatch
)
15449 struct cmd_list_element
*command
;
15451 command
= add_cmd (name
, class_breakpoint
, docstring
,
15453 set_cmd_sfunc (command
, sfunc
);
15454 set_cmd_context (command
, user_data_catch
);
15455 set_cmd_completer (command
, completer
);
15457 command
= add_cmd (name
, class_breakpoint
, docstring
,
15459 set_cmd_sfunc (command
, sfunc
);
15460 set_cmd_context (command
, user_data_tcatch
);
15461 set_cmd_completer (command
, completer
);
15464 struct breakpoint
*
15465 iterate_over_breakpoints (gdb::function_view
<bool (breakpoint
*)> callback
)
15467 struct breakpoint
*b
, *b_tmp
;
15469 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
15478 /* Zero if any of the breakpoint's locations could be a location where
15479 functions have been inlined, nonzero otherwise. */
15482 is_non_inline_function (struct breakpoint
*b
)
15484 /* The shared library event breakpoint is set on the address of a
15485 non-inline function. */
15486 if (b
->type
== bp_shlib_event
)
15492 /* Nonzero if the specified PC cannot be a location where functions
15493 have been inlined. */
15496 pc_at_non_inline_function (const address_space
*aspace
, CORE_ADDR pc
,
15497 const struct target_waitstatus
*ws
)
15499 struct breakpoint
*b
;
15500 struct bp_location
*bl
;
15502 ALL_BREAKPOINTS (b
)
15504 if (!is_non_inline_function (b
))
15507 for (bl
= b
->loc
; bl
!= NULL
; bl
= bl
->next
)
15509 if (!bl
->shlib_disabled
15510 && bpstat_check_location (bl
, aspace
, pc
, ws
))
15518 /* Remove any references to OBJFILE which is going to be freed. */
15521 breakpoint_free_objfile (struct objfile
*objfile
)
15523 struct bp_location
**locp
, *loc
;
15525 ALL_BP_LOCATIONS (loc
, locp
)
15526 if (loc
->symtab
!= NULL
&& SYMTAB_OBJFILE (loc
->symtab
) == objfile
)
15527 loc
->symtab
= NULL
;
15531 initialize_breakpoint_ops (void)
15533 static int initialized
= 0;
15535 struct breakpoint_ops
*ops
;
15541 /* The breakpoint_ops structure to be inherit by all kinds of
15542 breakpoints (real breakpoints, i.e., user "break" breakpoints,
15543 internal and momentary breakpoints, etc.). */
15544 ops
= &bkpt_base_breakpoint_ops
;
15545 *ops
= base_breakpoint_ops
;
15546 ops
->re_set
= bkpt_re_set
;
15547 ops
->insert_location
= bkpt_insert_location
;
15548 ops
->remove_location
= bkpt_remove_location
;
15549 ops
->breakpoint_hit
= bkpt_breakpoint_hit
;
15550 ops
->create_sals_from_location
= bkpt_create_sals_from_location
;
15551 ops
->create_breakpoints_sal
= bkpt_create_breakpoints_sal
;
15552 ops
->decode_location
= bkpt_decode_location
;
15554 /* The breakpoint_ops structure to be used in regular breakpoints. */
15555 ops
= &bkpt_breakpoint_ops
;
15556 *ops
= bkpt_base_breakpoint_ops
;
15557 ops
->re_set
= bkpt_re_set
;
15558 ops
->resources_needed
= bkpt_resources_needed
;
15559 ops
->print_it
= bkpt_print_it
;
15560 ops
->print_mention
= bkpt_print_mention
;
15561 ops
->print_recreate
= bkpt_print_recreate
;
15563 /* Ranged breakpoints. */
15564 ops
= &ranged_breakpoint_ops
;
15565 *ops
= bkpt_breakpoint_ops
;
15566 ops
->breakpoint_hit
= breakpoint_hit_ranged_breakpoint
;
15567 ops
->resources_needed
= resources_needed_ranged_breakpoint
;
15568 ops
->print_it
= print_it_ranged_breakpoint
;
15569 ops
->print_one
= print_one_ranged_breakpoint
;
15570 ops
->print_one_detail
= print_one_detail_ranged_breakpoint
;
15571 ops
->print_mention
= print_mention_ranged_breakpoint
;
15572 ops
->print_recreate
= print_recreate_ranged_breakpoint
;
15574 /* Internal breakpoints. */
15575 ops
= &internal_breakpoint_ops
;
15576 *ops
= bkpt_base_breakpoint_ops
;
15577 ops
->re_set
= internal_bkpt_re_set
;
15578 ops
->check_status
= internal_bkpt_check_status
;
15579 ops
->print_it
= internal_bkpt_print_it
;
15580 ops
->print_mention
= internal_bkpt_print_mention
;
15582 /* Momentary breakpoints. */
15583 ops
= &momentary_breakpoint_ops
;
15584 *ops
= bkpt_base_breakpoint_ops
;
15585 ops
->re_set
= momentary_bkpt_re_set
;
15586 ops
->check_status
= momentary_bkpt_check_status
;
15587 ops
->print_it
= momentary_bkpt_print_it
;
15588 ops
->print_mention
= momentary_bkpt_print_mention
;
15590 /* Probe breakpoints. */
15591 ops
= &bkpt_probe_breakpoint_ops
;
15592 *ops
= bkpt_breakpoint_ops
;
15593 ops
->insert_location
= bkpt_probe_insert_location
;
15594 ops
->remove_location
= bkpt_probe_remove_location
;
15595 ops
->create_sals_from_location
= bkpt_probe_create_sals_from_location
;
15596 ops
->decode_location
= bkpt_probe_decode_location
;
15599 ops
= &watchpoint_breakpoint_ops
;
15600 *ops
= base_breakpoint_ops
;
15601 ops
->re_set
= re_set_watchpoint
;
15602 ops
->insert_location
= insert_watchpoint
;
15603 ops
->remove_location
= remove_watchpoint
;
15604 ops
->breakpoint_hit
= breakpoint_hit_watchpoint
;
15605 ops
->check_status
= check_status_watchpoint
;
15606 ops
->resources_needed
= resources_needed_watchpoint
;
15607 ops
->works_in_software_mode
= works_in_software_mode_watchpoint
;
15608 ops
->print_it
= print_it_watchpoint
;
15609 ops
->print_mention
= print_mention_watchpoint
;
15610 ops
->print_recreate
= print_recreate_watchpoint
;
15611 ops
->explains_signal
= explains_signal_watchpoint
;
15613 /* Masked watchpoints. */
15614 ops
= &masked_watchpoint_breakpoint_ops
;
15615 *ops
= watchpoint_breakpoint_ops
;
15616 ops
->insert_location
= insert_masked_watchpoint
;
15617 ops
->remove_location
= remove_masked_watchpoint
;
15618 ops
->resources_needed
= resources_needed_masked_watchpoint
;
15619 ops
->works_in_software_mode
= works_in_software_mode_masked_watchpoint
;
15620 ops
->print_it
= print_it_masked_watchpoint
;
15621 ops
->print_one_detail
= print_one_detail_masked_watchpoint
;
15622 ops
->print_mention
= print_mention_masked_watchpoint
;
15623 ops
->print_recreate
= print_recreate_masked_watchpoint
;
15626 ops
= &tracepoint_breakpoint_ops
;
15627 *ops
= base_breakpoint_ops
;
15628 ops
->re_set
= tracepoint_re_set
;
15629 ops
->breakpoint_hit
= tracepoint_breakpoint_hit
;
15630 ops
->print_one_detail
= tracepoint_print_one_detail
;
15631 ops
->print_mention
= tracepoint_print_mention
;
15632 ops
->print_recreate
= tracepoint_print_recreate
;
15633 ops
->create_sals_from_location
= tracepoint_create_sals_from_location
;
15634 ops
->create_breakpoints_sal
= tracepoint_create_breakpoints_sal
;
15635 ops
->decode_location
= tracepoint_decode_location
;
15637 /* Probe tracepoints. */
15638 ops
= &tracepoint_probe_breakpoint_ops
;
15639 *ops
= tracepoint_breakpoint_ops
;
15640 ops
->create_sals_from_location
= tracepoint_probe_create_sals_from_location
;
15641 ops
->decode_location
= tracepoint_probe_decode_location
;
15643 /* Static tracepoints with marker (`-m'). */
15644 ops
= &strace_marker_breakpoint_ops
;
15645 *ops
= tracepoint_breakpoint_ops
;
15646 ops
->create_sals_from_location
= strace_marker_create_sals_from_location
;
15647 ops
->create_breakpoints_sal
= strace_marker_create_breakpoints_sal
;
15648 ops
->decode_location
= strace_marker_decode_location
;
15650 /* Fork catchpoints. */
15651 ops
= &catch_fork_breakpoint_ops
;
15652 *ops
= base_breakpoint_ops
;
15653 ops
->insert_location
= insert_catch_fork
;
15654 ops
->remove_location
= remove_catch_fork
;
15655 ops
->breakpoint_hit
= breakpoint_hit_catch_fork
;
15656 ops
->print_it
= print_it_catch_fork
;
15657 ops
->print_one
= print_one_catch_fork
;
15658 ops
->print_mention
= print_mention_catch_fork
;
15659 ops
->print_recreate
= print_recreate_catch_fork
;
15661 /* Vfork catchpoints. */
15662 ops
= &catch_vfork_breakpoint_ops
;
15663 *ops
= base_breakpoint_ops
;
15664 ops
->insert_location
= insert_catch_vfork
;
15665 ops
->remove_location
= remove_catch_vfork
;
15666 ops
->breakpoint_hit
= breakpoint_hit_catch_vfork
;
15667 ops
->print_it
= print_it_catch_vfork
;
15668 ops
->print_one
= print_one_catch_vfork
;
15669 ops
->print_mention
= print_mention_catch_vfork
;
15670 ops
->print_recreate
= print_recreate_catch_vfork
;
15672 /* Exec catchpoints. */
15673 ops
= &catch_exec_breakpoint_ops
;
15674 *ops
= base_breakpoint_ops
;
15675 ops
->insert_location
= insert_catch_exec
;
15676 ops
->remove_location
= remove_catch_exec
;
15677 ops
->breakpoint_hit
= breakpoint_hit_catch_exec
;
15678 ops
->print_it
= print_it_catch_exec
;
15679 ops
->print_one
= print_one_catch_exec
;
15680 ops
->print_mention
= print_mention_catch_exec
;
15681 ops
->print_recreate
= print_recreate_catch_exec
;
15683 /* Solib-related catchpoints. */
15684 ops
= &catch_solib_breakpoint_ops
;
15685 *ops
= base_breakpoint_ops
;
15686 ops
->insert_location
= insert_catch_solib
;
15687 ops
->remove_location
= remove_catch_solib
;
15688 ops
->breakpoint_hit
= breakpoint_hit_catch_solib
;
15689 ops
->check_status
= check_status_catch_solib
;
15690 ops
->print_it
= print_it_catch_solib
;
15691 ops
->print_one
= print_one_catch_solib
;
15692 ops
->print_mention
= print_mention_catch_solib
;
15693 ops
->print_recreate
= print_recreate_catch_solib
;
15695 ops
= &dprintf_breakpoint_ops
;
15696 *ops
= bkpt_base_breakpoint_ops
;
15697 ops
->re_set
= dprintf_re_set
;
15698 ops
->resources_needed
= bkpt_resources_needed
;
15699 ops
->print_it
= bkpt_print_it
;
15700 ops
->print_mention
= bkpt_print_mention
;
15701 ops
->print_recreate
= dprintf_print_recreate
;
15702 ops
->after_condition_true
= dprintf_after_condition_true
;
15703 ops
->breakpoint_hit
= dprintf_breakpoint_hit
;
15706 /* Chain containing all defined "enable breakpoint" subcommands. */
15708 static struct cmd_list_element
*enablebreaklist
= NULL
;
15710 /* See breakpoint.h. */
15712 cmd_list_element
*commands_cmd_element
= nullptr;
15714 void _initialize_breakpoint ();
15716 _initialize_breakpoint ()
15718 struct cmd_list_element
*c
;
15720 initialize_breakpoint_ops ();
15722 gdb::observers::solib_unloaded
.attach (disable_breakpoints_in_unloaded_shlib
);
15723 gdb::observers::free_objfile
.attach (disable_breakpoints_in_freed_objfile
);
15724 gdb::observers::memory_changed
.attach (invalidate_bp_value_on_memory_change
);
15726 breakpoint_chain
= 0;
15727 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
15728 before a breakpoint is set. */
15729 breakpoint_count
= 0;
15731 tracepoint_count
= 0;
15733 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
15734 Set ignore-count of breakpoint number N to COUNT.\n\
15735 Usage is `ignore N COUNT'."));
15737 commands_cmd_element
= add_com ("commands", class_breakpoint
,
15738 commands_command
, _("\
15739 Set commands to be executed when the given breakpoints are hit.\n\
15740 Give a space-separated breakpoint list as argument after \"commands\".\n\
15741 A list element can be a breakpoint number (e.g. `5') or a range of numbers\n\
15743 With no argument, the targeted breakpoint is the last one set.\n\
15744 The commands themselves follow starting on the next line.\n\
15745 Type a line containing \"end\" to indicate the end of them.\n\
15746 Give \"silent\" as the first line to make the breakpoint silent;\n\
15747 then no output is printed when it is hit, except what the commands print."));
15749 const auto cc_opts
= make_condition_command_options_def_group (nullptr);
15750 static std::string condition_command_help
15751 = gdb::option::build_help (_("\
15752 Specify breakpoint number N to break only if COND is true.\n\
15753 Usage is `condition [OPTION] N COND', where N is an integer and COND\n\
15754 is an expression to be evaluated whenever breakpoint N is reached.\n\
15757 %OPTIONS%"), cc_opts
);
15759 c
= add_com ("condition", class_breakpoint
, condition_command
,
15760 condition_command_help
.c_str ());
15761 set_cmd_completer_handle_brkchars (c
, condition_completer
);
15763 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
15764 Set a temporary breakpoint.\n\
15765 Like \"break\" except the breakpoint is only temporary,\n\
15766 so it will be deleted when hit. Equivalent to \"break\" followed\n\
15767 by using \"enable delete\" on the breakpoint number.\n\
15769 BREAK_ARGS_HELP ("tbreak")));
15770 set_cmd_completer (c
, location_completer
);
15772 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
15773 Set a hardware assisted breakpoint.\n\
15774 Like \"break\" except the breakpoint requires hardware support,\n\
15775 some target hardware may not have this support.\n\
15777 BREAK_ARGS_HELP ("hbreak")));
15778 set_cmd_completer (c
, location_completer
);
15780 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
15781 Set a temporary hardware assisted breakpoint.\n\
15782 Like \"hbreak\" except the breakpoint is only temporary,\n\
15783 so it will be deleted when hit.\n\
15785 BREAK_ARGS_HELP ("thbreak")));
15786 set_cmd_completer (c
, location_completer
);
15788 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
15789 Enable all or some breakpoints.\n\
15790 Usage: enable [BREAKPOINTNUM]...\n\
15791 Give breakpoint numbers (separated by spaces) as arguments.\n\
15792 With no subcommand, breakpoints are enabled until you command otherwise.\n\
15793 This is used to cancel the effect of the \"disable\" command.\n\
15794 With a subcommand you can enable temporarily."),
15795 &enablelist
, "enable ", 1, &cmdlist
);
15797 add_com_alias ("en", "enable", class_breakpoint
, 1);
15799 add_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
15800 Enable all or some breakpoints.\n\
15801 Usage: enable breakpoints [BREAKPOINTNUM]...\n\
15802 Give breakpoint numbers (separated by spaces) as arguments.\n\
15803 This is used to cancel the effect of the \"disable\" command.\n\
15804 May be abbreviated to simply \"enable\"."),
15805 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
15807 add_cmd ("once", no_class
, enable_once_command
, _("\
15808 Enable some breakpoints for one hit.\n\
15809 Usage: enable breakpoints once BREAKPOINTNUM...\n\
15810 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
15813 add_cmd ("delete", no_class
, enable_delete_command
, _("\
15814 Enable some breakpoints and delete when hit.\n\
15815 Usage: enable breakpoints delete BREAKPOINTNUM...\n\
15816 If a breakpoint is hit while enabled in this fashion, it is deleted."),
15819 add_cmd ("count", no_class
, enable_count_command
, _("\
15820 Enable some breakpoints for COUNT hits.\n\
15821 Usage: enable breakpoints count COUNT BREAKPOINTNUM...\n\
15822 If a breakpoint is hit while enabled in this fashion,\n\
15823 the count is decremented; when it reaches zero, the breakpoint is disabled."),
15826 add_cmd ("delete", no_class
, enable_delete_command
, _("\
15827 Enable some breakpoints and delete when hit.\n\
15828 Usage: enable delete BREAKPOINTNUM...\n\
15829 If a breakpoint is hit while enabled in this fashion, it is deleted."),
15832 add_cmd ("once", no_class
, enable_once_command
, _("\
15833 Enable some breakpoints for one hit.\n\
15834 Usage: enable once BREAKPOINTNUM...\n\
15835 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
15838 add_cmd ("count", no_class
, enable_count_command
, _("\
15839 Enable some breakpoints for COUNT hits.\n\
15840 Usage: enable count COUNT BREAKPOINTNUM...\n\
15841 If a breakpoint is hit while enabled in this fashion,\n\
15842 the count is decremented; when it reaches zero, the breakpoint is disabled."),
15845 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
15846 Disable all or some breakpoints.\n\
15847 Usage: disable [BREAKPOINTNUM]...\n\
15848 Arguments are breakpoint numbers with spaces in between.\n\
15849 To disable all breakpoints, give no argument.\n\
15850 A disabled breakpoint is not forgotten, but has no effect until re-enabled."),
15851 &disablelist
, "disable ", 1, &cmdlist
);
15852 add_com_alias ("dis", "disable", class_breakpoint
, 1);
15853 add_com_alias ("disa", "disable", class_breakpoint
, 1);
15855 add_cmd ("breakpoints", class_breakpoint
, disable_command
, _("\
15856 Disable all or some breakpoints.\n\
15857 Usage: disable breakpoints [BREAKPOINTNUM]...\n\
15858 Arguments are breakpoint numbers with spaces in between.\n\
15859 To disable all breakpoints, give no argument.\n\
15860 A disabled breakpoint is not forgotten, but has no effect until re-enabled.\n\
15861 This command may be abbreviated \"disable\"."),
15864 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
15865 Delete all or some breakpoints.\n\
15866 Usage: delete [BREAKPOINTNUM]...\n\
15867 Arguments are breakpoint numbers with spaces in between.\n\
15868 To delete all breakpoints, give no argument.\n\
15870 Also a prefix command for deletion of other GDB objects."),
15871 &deletelist
, "delete ", 1, &cmdlist
);
15872 add_com_alias ("d", "delete", class_breakpoint
, 1);
15873 add_com_alias ("del", "delete", class_breakpoint
, 1);
15875 add_cmd ("breakpoints", class_breakpoint
, delete_command
, _("\
15876 Delete all or some breakpoints or auto-display expressions.\n\
15877 Usage: delete breakpoints [BREAKPOINTNUM]...\n\
15878 Arguments are breakpoint numbers with spaces in between.\n\
15879 To delete all breakpoints, give no argument.\n\
15880 This command may be abbreviated \"delete\"."),
15883 add_com ("clear", class_breakpoint
, clear_command
, _("\
15884 Clear breakpoint at specified location.\n\
15885 Argument may be a linespec, explicit, or address location as described below.\n\
15887 With no argument, clears all breakpoints in the line that the selected frame\n\
15888 is executing in.\n"
15889 "\n" LOCATION_HELP_STRING
"\n\n\
15890 See also the \"delete\" command which clears breakpoints by number."));
15891 add_com_alias ("cl", "clear", class_breakpoint
, 1);
15893 c
= add_com ("break", class_breakpoint
, break_command
, _("\
15894 Set breakpoint at specified location.\n"
15895 BREAK_ARGS_HELP ("break")));
15896 set_cmd_completer (c
, location_completer
);
15898 add_com_alias ("b", "break", class_run
, 1);
15899 add_com_alias ("br", "break", class_run
, 1);
15900 add_com_alias ("bre", "break", class_run
, 1);
15901 add_com_alias ("brea", "break", class_run
, 1);
15905 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
15906 Break in function/address or break at a line in the current file."),
15907 &stoplist
, "stop ", 1, &cmdlist
);
15908 add_cmd ("in", class_breakpoint
, stopin_command
,
15909 _("Break in function or address."), &stoplist
);
15910 add_cmd ("at", class_breakpoint
, stopat_command
,
15911 _("Break at a line in the current file."), &stoplist
);
15912 add_com ("status", class_info
, info_breakpoints_command
, _("\
15913 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
15914 The \"Type\" column indicates one of:\n\
15915 \tbreakpoint - normal breakpoint\n\
15916 \twatchpoint - watchpoint\n\
15917 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15918 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
15919 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
15920 address and file/line number respectively.\n\
15922 Convenience variable \"$_\" and default examine address for \"x\"\n\
15923 are set to the address of the last breakpoint listed unless the command\n\
15924 is prefixed with \"server \".\n\n\
15925 Convenience variable \"$bpnum\" contains the number of the last\n\
15926 breakpoint set."));
15929 add_info ("breakpoints", info_breakpoints_command
, _("\
15930 Status of specified breakpoints (all user-settable breakpoints if no argument).\n\
15931 The \"Type\" column indicates one of:\n\
15932 \tbreakpoint - normal breakpoint\n\
15933 \twatchpoint - watchpoint\n\
15934 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15935 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
15936 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
15937 address and file/line number respectively.\n\
15939 Convenience variable \"$_\" and default examine address for \"x\"\n\
15940 are set to the address of the last breakpoint listed unless the command\n\
15941 is prefixed with \"server \".\n\n\
15942 Convenience variable \"$bpnum\" contains the number of the last\n\
15943 breakpoint set."));
15945 add_info_alias ("b", "breakpoints", 1);
15947 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
15948 Status of all breakpoints, or breakpoint number NUMBER.\n\
15949 The \"Type\" column indicates one of:\n\
15950 \tbreakpoint - normal breakpoint\n\
15951 \twatchpoint - watchpoint\n\
15952 \tlongjmp - internal breakpoint used to step through longjmp()\n\
15953 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
15954 \tuntil - internal breakpoint used by the \"until\" command\n\
15955 \tfinish - internal breakpoint used by the \"finish\" command\n\
15956 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15957 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
15958 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
15959 address and file/line number respectively.\n\
15961 Convenience variable \"$_\" and default examine address for \"x\"\n\
15962 are set to the address of the last breakpoint listed unless the command\n\
15963 is prefixed with \"server \".\n\n\
15964 Convenience variable \"$bpnum\" contains the number of the last\n\
15966 &maintenanceinfolist
);
15968 add_basic_prefix_cmd ("catch", class_breakpoint
, _("\
15969 Set catchpoints to catch events."),
15970 &catch_cmdlist
, "catch ",
15971 0/*allow-unknown*/, &cmdlist
);
15973 add_basic_prefix_cmd ("tcatch", class_breakpoint
, _("\
15974 Set temporary catchpoints to catch events."),
15975 &tcatch_cmdlist
, "tcatch ",
15976 0/*allow-unknown*/, &cmdlist
);
15978 add_catch_command ("fork", _("Catch calls to fork."),
15979 catch_fork_command_1
,
15981 (void *) (uintptr_t) catch_fork_permanent
,
15982 (void *) (uintptr_t) catch_fork_temporary
);
15983 add_catch_command ("vfork", _("Catch calls to vfork."),
15984 catch_fork_command_1
,
15986 (void *) (uintptr_t) catch_vfork_permanent
,
15987 (void *) (uintptr_t) catch_vfork_temporary
);
15988 add_catch_command ("exec", _("Catch calls to exec."),
15989 catch_exec_command_1
,
15993 add_catch_command ("load", _("Catch loads of shared libraries.\n\
15994 Usage: catch load [REGEX]\n\
15995 If REGEX is given, only stop for libraries matching the regular expression."),
15996 catch_load_command_1
,
16000 add_catch_command ("unload", _("Catch unloads of shared libraries.\n\
16001 Usage: catch unload [REGEX]\n\
16002 If REGEX is given, only stop for libraries matching the regular expression."),
16003 catch_unload_command_1
,
16008 const auto opts
= make_watch_options_def_group (nullptr);
16010 static const std::string watch_help
= gdb::option::build_help (_("\
16011 Set a watchpoint for EXPRESSION.\n\
16012 Usage: watch [-location] EXPRESSION\n\
16017 A watchpoint stops execution of your program whenever the value of\n\
16018 an expression changes."), opts
);
16019 c
= add_com ("watch", class_breakpoint
, watch_command
,
16020 watch_help
.c_str ());
16021 set_cmd_completer_handle_brkchars (c
, watch_command_completer
);
16023 static const std::string rwatch_help
= gdb::option::build_help (_("\
16024 Set a read watchpoint for EXPRESSION.\n\
16025 Usage: rwatch [-location] EXPRESSION\n\
16030 A read watchpoint stops execution of your program whenever the value of\n\
16031 an expression is read."), opts
);
16032 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
,
16033 rwatch_help
.c_str ());
16034 set_cmd_completer_handle_brkchars (c
, watch_command_completer
);
16036 static const std::string awatch_help
= gdb::option::build_help (_("\
16037 Set an access watchpoint for EXPRESSION.\n\
16038 Usage: awatch [-location] EXPRESSION\n\
16043 An access watchpoint stops execution of your program whenever the value\n\
16044 of an expression is either read or written."), opts
);
16045 c
= add_com ("awatch", class_breakpoint
, awatch_command
,
16046 awatch_help
.c_str ());
16047 set_cmd_completer_handle_brkchars (c
, watch_command_completer
);
16049 add_info ("watchpoints", info_watchpoints_command
, _("\
16050 Status of specified watchpoints (all watchpoints if no argument)."));
16052 /* XXX: cagney/2005-02-23: This should be a boolean, and should
16053 respond to changes - contrary to the description. */
16054 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
16055 &can_use_hw_watchpoints
, _("\
16056 Set debugger's willingness to use watchpoint hardware."), _("\
16057 Show debugger's willingness to use watchpoint hardware."), _("\
16058 If zero, gdb will not use hardware for new watchpoints, even if\n\
16059 such is available. (However, any hardware watchpoints that were\n\
16060 created before setting this to nonzero, will continue to use watchpoint\n\
16063 show_can_use_hw_watchpoints
,
16064 &setlist
, &showlist
);
16066 can_use_hw_watchpoints
= 1;
16068 /* Tracepoint manipulation commands. */
16070 c
= add_com ("trace", class_breakpoint
, trace_command
, _("\
16071 Set a tracepoint at specified location.\n\
16073 BREAK_ARGS_HELP ("trace") "\n\
16074 Do \"help tracepoints\" for info on other tracepoint commands."));
16075 set_cmd_completer (c
, location_completer
);
16077 add_com_alias ("tp", "trace", class_breakpoint
, 0);
16078 add_com_alias ("tr", "trace", class_breakpoint
, 1);
16079 add_com_alias ("tra", "trace", class_breakpoint
, 1);
16080 add_com_alias ("trac", "trace", class_breakpoint
, 1);
16082 c
= add_com ("ftrace", class_breakpoint
, ftrace_command
, _("\
16083 Set a fast tracepoint at specified location.\n\
16085 BREAK_ARGS_HELP ("ftrace") "\n\
16086 Do \"help tracepoints\" for info on other tracepoint commands."));
16087 set_cmd_completer (c
, location_completer
);
16089 c
= add_com ("strace", class_breakpoint
, strace_command
, _("\
16090 Set a static tracepoint at location or marker.\n\
16092 strace [LOCATION] [if CONDITION]\n\
16093 LOCATION may be a linespec, explicit, or address location (described below) \n\
16094 or -m MARKER_ID.\n\n\
16095 If a marker id is specified, probe the marker with that name. With\n\
16096 no LOCATION, uses current execution address of the selected stack frame.\n\
16097 Static tracepoints accept an extra collect action -- ``collect $_sdata''.\n\
16098 This collects arbitrary user data passed in the probe point call to the\n\
16099 tracing library. You can inspect it when analyzing the trace buffer,\n\
16100 by printing the $_sdata variable like any other convenience variable.\n\
16102 CONDITION is a boolean expression.\n\
16103 \n" LOCATION_HELP_STRING
"\n\n\
16104 Multiple tracepoints at one place are permitted, and useful if their\n\
16105 conditions are different.\n\
16107 Do \"help breakpoints\" for info on other commands dealing with breakpoints.\n\
16108 Do \"help tracepoints\" for info on other tracepoint commands."));
16109 set_cmd_completer (c
, location_completer
);
16111 add_info ("tracepoints", info_tracepoints_command
, _("\
16112 Status of specified tracepoints (all tracepoints if no argument).\n\
16113 Convenience variable \"$tpnum\" contains the number of the\n\
16114 last tracepoint set."));
16116 add_info_alias ("tp", "tracepoints", 1);
16118 add_cmd ("tracepoints", class_trace
, delete_trace_command
, _("\
16119 Delete specified tracepoints.\n\
16120 Arguments are tracepoint numbers, separated by spaces.\n\
16121 No argument means delete all tracepoints."),
16123 add_alias_cmd ("tr", "tracepoints", class_trace
, 1, &deletelist
);
16125 c
= add_cmd ("tracepoints", class_trace
, disable_trace_command
, _("\
16126 Disable specified tracepoints.\n\
16127 Arguments are tracepoint numbers, separated by spaces.\n\
16128 No argument means disable all tracepoints."),
16130 deprecate_cmd (c
, "disable");
16132 c
= add_cmd ("tracepoints", class_trace
, enable_trace_command
, _("\
16133 Enable specified tracepoints.\n\
16134 Arguments are tracepoint numbers, separated by spaces.\n\
16135 No argument means enable all tracepoints."),
16137 deprecate_cmd (c
, "enable");
16139 add_com ("passcount", class_trace
, trace_pass_command
, _("\
16140 Set the passcount for a tracepoint.\n\
16141 The trace will end when the tracepoint has been passed 'count' times.\n\
16142 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
16143 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
16145 add_basic_prefix_cmd ("save", class_breakpoint
,
16146 _("Save breakpoint definitions as a script."),
16147 &save_cmdlist
, "save ",
16148 0/*allow-unknown*/, &cmdlist
);
16150 c
= add_cmd ("breakpoints", class_breakpoint
, save_breakpoints_command
, _("\
16151 Save current breakpoint definitions as a script.\n\
16152 This includes all types of breakpoints (breakpoints, watchpoints,\n\
16153 catchpoints, tracepoints). Use the 'source' command in another debug\n\
16154 session to restore them."),
16156 set_cmd_completer (c
, filename_completer
);
16158 c
= add_cmd ("tracepoints", class_trace
, save_tracepoints_command
, _("\
16159 Save current tracepoint definitions as a script.\n\
16160 Use the 'source' command in another debug session to restore them."),
16162 set_cmd_completer (c
, filename_completer
);
16164 c
= add_com_alias ("save-tracepoints", "save tracepoints", class_trace
, 0);
16165 deprecate_cmd (c
, "save tracepoints");
16167 add_basic_prefix_cmd ("breakpoint", class_maintenance
, _("\
16168 Breakpoint specific settings.\n\
16169 Configure various breakpoint-specific variables such as\n\
16170 pending breakpoint behavior."),
16171 &breakpoint_set_cmdlist
, "set breakpoint ",
16172 0/*allow-unknown*/, &setlist
);
16173 add_show_prefix_cmd ("breakpoint", class_maintenance
, _("\
16174 Breakpoint specific settings.\n\
16175 Configure various breakpoint-specific variables such as\n\
16176 pending breakpoint behavior."),
16177 &breakpoint_show_cmdlist
, "show breakpoint ",
16178 0/*allow-unknown*/, &showlist
);
16180 add_setshow_auto_boolean_cmd ("pending", no_class
,
16181 &pending_break_support
, _("\
16182 Set debugger's behavior regarding pending breakpoints."), _("\
16183 Show debugger's behavior regarding pending breakpoints."), _("\
16184 If on, an unrecognized breakpoint location will cause gdb to create a\n\
16185 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
16186 an error. If auto, an unrecognized breakpoint location results in a\n\
16187 user-query to see if a pending breakpoint should be created."),
16189 show_pending_break_support
,
16190 &breakpoint_set_cmdlist
,
16191 &breakpoint_show_cmdlist
);
16193 pending_break_support
= AUTO_BOOLEAN_AUTO
;
16195 add_setshow_boolean_cmd ("auto-hw", no_class
,
16196 &automatic_hardware_breakpoints
, _("\
16197 Set automatic usage of hardware breakpoints."), _("\
16198 Show automatic usage of hardware breakpoints."), _("\
16199 If set, the debugger will automatically use hardware breakpoints for\n\
16200 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
16201 a warning will be emitted for such breakpoints."),
16203 show_automatic_hardware_breakpoints
,
16204 &breakpoint_set_cmdlist
,
16205 &breakpoint_show_cmdlist
);
16207 add_setshow_boolean_cmd ("always-inserted", class_support
,
16208 &always_inserted_mode
, _("\
16209 Set mode for inserting breakpoints."), _("\
16210 Show mode for inserting breakpoints."), _("\
16211 When this mode is on, breakpoints are inserted immediately as soon as\n\
16212 they're created, kept inserted even when execution stops, and removed\n\
16213 only when the user deletes them. When this mode is off (the default),\n\
16214 breakpoints are inserted only when execution continues, and removed\n\
16215 when execution stops."),
16217 &show_always_inserted_mode
,
16218 &breakpoint_set_cmdlist
,
16219 &breakpoint_show_cmdlist
);
16221 add_setshow_enum_cmd ("condition-evaluation", class_breakpoint
,
16222 condition_evaluation_enums
,
16223 &condition_evaluation_mode_1
, _("\
16224 Set mode of breakpoint condition evaluation."), _("\
16225 Show mode of breakpoint condition evaluation."), _("\
16226 When this is set to \"host\", breakpoint conditions will be\n\
16227 evaluated on the host's side by GDB. When it is set to \"target\",\n\
16228 breakpoint conditions will be downloaded to the target (if the target\n\
16229 supports such feature) and conditions will be evaluated on the target's side.\n\
16230 If this is set to \"auto\" (default), this will be automatically set to\n\
16231 \"target\" if it supports condition evaluation, otherwise it will\n\
16232 be set to \"host\"."),
16233 &set_condition_evaluation_mode
,
16234 &show_condition_evaluation_mode
,
16235 &breakpoint_set_cmdlist
,
16236 &breakpoint_show_cmdlist
);
16238 add_com ("break-range", class_breakpoint
, break_range_command
, _("\
16239 Set a breakpoint for an address range.\n\
16240 break-range START-LOCATION, END-LOCATION\n\
16241 where START-LOCATION and END-LOCATION can be one of the following:\n\
16242 LINENUM, for that line in the current file,\n\
16243 FILE:LINENUM, for that line in that file,\n\
16244 +OFFSET, for that number of lines after the current line\n\
16245 or the start of the range\n\
16246 FUNCTION, for the first line in that function,\n\
16247 FILE:FUNCTION, to distinguish among like-named static functions.\n\
16248 *ADDRESS, for the instruction at that address.\n\
16250 The breakpoint will stop execution of the inferior whenever it executes\n\
16251 an instruction at any address within the [START-LOCATION, END-LOCATION]\n\
16252 range (including START-LOCATION and END-LOCATION)."));
16254 c
= add_com ("dprintf", class_breakpoint
, dprintf_command
, _("\
16255 Set a dynamic printf at specified location.\n\
16256 dprintf location,format string,arg1,arg2,...\n\
16257 location may be a linespec, explicit, or address location.\n"
16258 "\n" LOCATION_HELP_STRING
));
16259 set_cmd_completer (c
, location_completer
);
16261 add_setshow_enum_cmd ("dprintf-style", class_support
,
16262 dprintf_style_enums
, &dprintf_style
, _("\
16263 Set the style of usage for dynamic printf."), _("\
16264 Show the style of usage for dynamic printf."), _("\
16265 This setting chooses how GDB will do a dynamic printf.\n\
16266 If the value is \"gdb\", then the printing is done by GDB to its own\n\
16267 console, as with the \"printf\" command.\n\
16268 If the value is \"call\", the print is done by calling a function in your\n\
16269 program; by default printf(), but you can choose a different function or\n\
16270 output stream by setting dprintf-function and dprintf-channel."),
16271 update_dprintf_commands
, NULL
,
16272 &setlist
, &showlist
);
16274 dprintf_function
= xstrdup ("printf");
16275 add_setshow_string_cmd ("dprintf-function", class_support
,
16276 &dprintf_function
, _("\
16277 Set the function to use for dynamic printf."), _("\
16278 Show the function to use for dynamic printf."), NULL
,
16279 update_dprintf_commands
, NULL
,
16280 &setlist
, &showlist
);
16282 dprintf_channel
= xstrdup ("");
16283 add_setshow_string_cmd ("dprintf-channel", class_support
,
16284 &dprintf_channel
, _("\
16285 Set the channel to use for dynamic printf."), _("\
16286 Show the channel to use for dynamic printf."), NULL
,
16287 update_dprintf_commands
, NULL
,
16288 &setlist
, &showlist
);
16290 add_setshow_boolean_cmd ("disconnected-dprintf", no_class
,
16291 &disconnected_dprintf
, _("\
16292 Set whether dprintf continues after GDB disconnects."), _("\
16293 Show whether dprintf continues after GDB disconnects."), _("\
16294 Use this to let dprintf commands continue to hit and produce output\n\
16295 even if GDB disconnects or detaches from the target."),
16298 &setlist
, &showlist
);
16300 add_com ("agent-printf", class_vars
, agent_printf_command
, _("\
16301 Target agent only formatted printing, like the C \"printf\" function.\n\
16302 Usage: agent-printf \"format string\", ARG1, ARG2, ARG3, ..., ARGN\n\
16303 This supports most C printf format specifications, like %s, %d, etc.\n\
16304 This is useful for formatted output in user-defined commands."));
16306 automatic_hardware_breakpoints
= true;
16308 gdb::observers::about_to_proceed
.attach (breakpoint_about_to_proceed
);
16309 gdb::observers::thread_exit
.attach (remove_threaded_breakpoints
);