1 /* Everything about breakpoints, for GDB.
3 Copyright (C) 1986-2020 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "arch-utils.h"
26 #include "breakpoint.h"
27 #include "tracepoint.h"
29 #include "expression.h"
36 #include "gdbthread.h"
39 #include "gdb-demangle.h"
40 #include "filenames.h"
46 #include "completer.h"
48 #include "cli/cli-script.h"
52 #include "observable.h"
58 #include "parser-defs.h"
59 #include "gdb_regex.h"
61 #include "cli/cli-utils.h"
64 #include "dummy-frame.h"
66 #include "gdbsupport/format.h"
67 #include "thread-fsm.h"
68 #include "tid-parse.h"
69 #include "cli/cli-style.h"
71 /* readline include files */
72 #include "readline/tilde.h"
74 /* readline defines this. */
77 #include "mi/mi-common.h"
78 #include "extension.h"
80 #include "progspace-and-thread.h"
81 #include "gdbsupport/array-view.h"
82 #include "gdbsupport/gdb_optional.h"
84 /* Prototypes for local functions. */
86 static void map_breakpoint_numbers (const char *,
87 gdb::function_view
<void (breakpoint
*)>);
89 static void breakpoint_re_set_default (struct breakpoint
*);
92 create_sals_from_location_default (const struct event_location
*location
,
93 struct linespec_result
*canonical
,
94 enum bptype type_wanted
);
96 static void create_breakpoints_sal_default (struct gdbarch
*,
97 struct linespec_result
*,
98 gdb::unique_xmalloc_ptr
<char>,
99 gdb::unique_xmalloc_ptr
<char>,
101 enum bpdisp
, int, int,
103 const struct breakpoint_ops
*,
104 int, int, int, unsigned);
106 static std::vector
<symtab_and_line
> decode_location_default
107 (struct breakpoint
*b
, const struct event_location
*location
,
108 struct program_space
*search_pspace
);
110 static int can_use_hardware_watchpoint
111 (const std::vector
<value_ref_ptr
> &vals
);
113 static void mention (struct breakpoint
*);
115 static struct breakpoint
*set_raw_breakpoint_without_location (struct gdbarch
*,
117 const struct breakpoint_ops
*);
118 static struct bp_location
*add_location_to_breakpoint (struct breakpoint
*,
119 const struct symtab_and_line
*);
121 /* This function is used in gdbtk sources and thus can not be made
123 struct breakpoint
*set_raw_breakpoint (struct gdbarch
*gdbarch
,
124 struct symtab_and_line
,
126 const struct breakpoint_ops
*);
128 static struct breakpoint
*
129 momentary_breakpoint_from_master (struct breakpoint
*orig
,
131 const struct breakpoint_ops
*ops
,
134 static void breakpoint_adjustment_warning (CORE_ADDR
, CORE_ADDR
, int, int);
136 static CORE_ADDR
adjust_breakpoint_address (struct gdbarch
*gdbarch
,
140 static void describe_other_breakpoints (struct gdbarch
*,
141 struct program_space
*, CORE_ADDR
,
142 struct obj_section
*, int);
144 static int watchpoint_locations_match (struct bp_location
*loc1
,
145 struct bp_location
*loc2
);
147 static int breakpoint_location_address_match (struct bp_location
*bl
,
148 const struct address_space
*aspace
,
151 static int breakpoint_location_address_range_overlap (struct bp_location
*,
152 const address_space
*,
155 static int remove_breakpoint (struct bp_location
*);
156 static int remove_breakpoint_1 (struct bp_location
*, enum remove_bp_reason
);
158 static enum print_stop_action
print_bp_stop_message (bpstat bs
);
160 static int hw_breakpoint_used_count (void);
162 static int hw_watchpoint_use_count (struct breakpoint
*);
164 static int hw_watchpoint_used_count_others (struct breakpoint
*except
,
166 int *other_type_used
);
168 static void enable_breakpoint_disp (struct breakpoint
*, enum bpdisp
,
171 static void free_bp_location (struct bp_location
*loc
);
172 static void incref_bp_location (struct bp_location
*loc
);
173 static void decref_bp_location (struct bp_location
**loc
);
175 static struct bp_location
*allocate_bp_location (struct breakpoint
*bpt
);
177 /* update_global_location_list's modes of operation wrt to whether to
178 insert locations now. */
179 enum ugll_insert_mode
181 /* Don't insert any breakpoint locations into the inferior, only
182 remove already-inserted locations that no longer should be
183 inserted. Functions that delete a breakpoint or breakpoints
184 should specify this mode, so that deleting a breakpoint doesn't
185 have the side effect of inserting the locations of other
186 breakpoints that are marked not-inserted, but should_be_inserted
187 returns true on them.
189 This behavior is useful is situations close to tear-down -- e.g.,
190 after an exec, while the target still has execution, but
191 breakpoint shadows of the previous executable image should *NOT*
192 be restored to the new image; or before detaching, where the
193 target still has execution and wants to delete breakpoints from
194 GDB's lists, and all breakpoints had already been removed from
198 /* May insert breakpoints iff breakpoints_should_be_inserted_now
199 claims breakpoints should be inserted now. */
202 /* Insert locations now, irrespective of
203 breakpoints_should_be_inserted_now. E.g., say all threads are
204 stopped right now, and the user did "continue". We need to
205 insert breakpoints _before_ resuming the target, but
206 UGLL_MAY_INSERT wouldn't insert them, because
207 breakpoints_should_be_inserted_now returns false at that point,
208 as no thread is running yet. */
212 static void update_global_location_list (enum ugll_insert_mode
);
214 static void update_global_location_list_nothrow (enum ugll_insert_mode
);
216 static void insert_breakpoint_locations (void);
218 static void trace_pass_command (const char *, int);
220 static void set_tracepoint_count (int num
);
222 static bool is_masked_watchpoint (const struct breakpoint
*b
);
224 static struct bp_location
**get_first_locp_gte_addr (CORE_ADDR address
);
226 /* Return 1 if B refers to a static tracepoint set by marker ("-m"), zero
229 static int strace_marker_p (struct breakpoint
*b
);
231 /* The breakpoint_ops structure to be inherited by all breakpoint_ops
232 that are implemented on top of software or hardware breakpoints
233 (user breakpoints, internal and momentary breakpoints, etc.). */
234 static struct breakpoint_ops bkpt_base_breakpoint_ops
;
236 /* Internal breakpoints class type. */
237 static struct breakpoint_ops internal_breakpoint_ops
;
239 /* Momentary breakpoints class type. */
240 static struct breakpoint_ops momentary_breakpoint_ops
;
242 /* The breakpoint_ops structure to be used in regular user created
244 struct breakpoint_ops bkpt_breakpoint_ops
;
246 /* Breakpoints set on probes. */
247 static struct breakpoint_ops bkpt_probe_breakpoint_ops
;
249 /* Tracepoints set on probes. */
250 static struct breakpoint_ops tracepoint_probe_breakpoint_ops
;
252 /* Dynamic printf class type. */
253 struct breakpoint_ops dprintf_breakpoint_ops
;
255 /* The style in which to perform a dynamic printf. This is a user
256 option because different output options have different tradeoffs;
257 if GDB does the printing, there is better error handling if there
258 is a problem with any of the arguments, but using an inferior
259 function lets you have special-purpose printers and sending of
260 output to the same place as compiled-in print functions. */
262 static const char dprintf_style_gdb
[] = "gdb";
263 static const char dprintf_style_call
[] = "call";
264 static const char dprintf_style_agent
[] = "agent";
265 static const char *const dprintf_style_enums
[] = {
271 static const char *dprintf_style
= dprintf_style_gdb
;
273 /* The function to use for dynamic printf if the preferred style is to
274 call into the inferior. The value is simply a string that is
275 copied into the command, so it can be anything that GDB can
276 evaluate to a callable address, not necessarily a function name. */
278 static char *dprintf_function
;
280 /* The channel to use for dynamic printf if the preferred style is to
281 call into the inferior; if a nonempty string, it will be passed to
282 the call as the first argument, with the format string as the
283 second. As with the dprintf function, this can be anything that
284 GDB knows how to evaluate, so in addition to common choices like
285 "stderr", this could be an app-specific expression like
286 "mystreams[curlogger]". */
288 static char *dprintf_channel
;
290 /* True if dprintf commands should continue to operate even if GDB
292 static bool disconnected_dprintf
= true;
294 struct command_line
*
295 breakpoint_commands (struct breakpoint
*b
)
297 return b
->commands
? b
->commands
.get () : NULL
;
300 /* Flag indicating that a command has proceeded the inferior past the
301 current breakpoint. */
303 static bool breakpoint_proceeded
;
306 bpdisp_text (enum bpdisp disp
)
308 /* NOTE: the following values are a part of MI protocol and
309 represent values of 'disp' field returned when inferior stops at
311 static const char * const bpdisps
[] = {"del", "dstp", "dis", "keep"};
313 return bpdisps
[(int) disp
];
316 /* Prototypes for exported functions. */
317 /* If FALSE, gdb will not use hardware support for watchpoints, even
318 if such is available. */
319 static int can_use_hw_watchpoints
;
322 show_can_use_hw_watchpoints (struct ui_file
*file
, int from_tty
,
323 struct cmd_list_element
*c
,
326 fprintf_filtered (file
,
327 _("Debugger's willingness to use "
328 "watchpoint hardware is %s.\n"),
332 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
333 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
334 for unrecognized breakpoint locations.
335 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
336 static enum auto_boolean pending_break_support
;
338 show_pending_break_support (struct ui_file
*file
, int from_tty
,
339 struct cmd_list_element
*c
,
342 fprintf_filtered (file
,
343 _("Debugger's behavior regarding "
344 "pending breakpoints is %s.\n"),
348 /* If true, gdb will automatically use hardware breakpoints for breakpoints
349 set with "break" but falling in read-only memory.
350 If false, gdb will warn about such breakpoints, but won't automatically
351 use hardware breakpoints. */
352 static bool automatic_hardware_breakpoints
;
354 show_automatic_hardware_breakpoints (struct ui_file
*file
, int from_tty
,
355 struct cmd_list_element
*c
,
358 fprintf_filtered (file
,
359 _("Automatic usage of hardware breakpoints is %s.\n"),
363 /* If on, GDB keeps breakpoints inserted even if the inferior is
364 stopped, and immediately inserts any new breakpoints as soon as
365 they're created. If off (default), GDB keeps breakpoints off of
366 the target as long as possible. That is, it delays inserting
367 breakpoints until the next resume, and removes them again when the
368 target fully stops. This is a bit safer in case GDB crashes while
369 processing user input. */
370 static bool always_inserted_mode
= false;
373 show_always_inserted_mode (struct ui_file
*file
, int from_tty
,
374 struct cmd_list_element
*c
, const char *value
)
376 fprintf_filtered (file
, _("Always inserted breakpoint mode is %s.\n"),
380 /* See breakpoint.h. */
383 breakpoints_should_be_inserted_now (void)
385 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
387 /* If breakpoints are global, they should be inserted even if no
388 thread under gdb's control is running, or even if there are
389 no threads under GDB's control yet. */
394 if (always_inserted_mode
)
396 /* The user wants breakpoints inserted even if all threads
401 for (inferior
*inf
: all_inferiors ())
402 if (inf
->has_execution ()
403 && threads_are_executing (inf
->process_target ()))
406 /* Don't remove breakpoints yet if, even though all threads are
407 stopped, we still have events to process. */
408 for (thread_info
*tp
: all_non_exited_threads ())
410 && tp
->suspend
.waitstatus_pending_p
)
416 static const char condition_evaluation_both
[] = "host or target";
418 /* Modes for breakpoint condition evaluation. */
419 static const char condition_evaluation_auto
[] = "auto";
420 static const char condition_evaluation_host
[] = "host";
421 static const char condition_evaluation_target
[] = "target";
422 static const char *const condition_evaluation_enums
[] = {
423 condition_evaluation_auto
,
424 condition_evaluation_host
,
425 condition_evaluation_target
,
429 /* Global that holds the current mode for breakpoint condition evaluation. */
430 static const char *condition_evaluation_mode_1
= condition_evaluation_auto
;
432 /* Global that we use to display information to the user (gets its value from
433 condition_evaluation_mode_1. */
434 static const char *condition_evaluation_mode
= condition_evaluation_auto
;
436 /* Translate a condition evaluation mode MODE into either "host"
437 or "target". This is used mostly to translate from "auto" to the
438 real setting that is being used. It returns the translated
442 translate_condition_evaluation_mode (const char *mode
)
444 if (mode
== condition_evaluation_auto
)
446 if (target_supports_evaluation_of_breakpoint_conditions ())
447 return condition_evaluation_target
;
449 return condition_evaluation_host
;
455 /* Discovers what condition_evaluation_auto translates to. */
458 breakpoint_condition_evaluation_mode (void)
460 return translate_condition_evaluation_mode (condition_evaluation_mode
);
463 /* Return true if GDB should evaluate breakpoint conditions or false
467 gdb_evaluates_breakpoint_condition_p (void)
469 const char *mode
= breakpoint_condition_evaluation_mode ();
471 return (mode
== condition_evaluation_host
);
474 /* Are we executing breakpoint commands? */
475 static int executing_breakpoint_commands
;
477 /* Are overlay event breakpoints enabled? */
478 static int overlay_events_enabled
;
480 /* See description in breakpoint.h. */
481 bool target_exact_watchpoints
= false;
483 /* Walk the following statement or block through all breakpoints.
484 ALL_BREAKPOINTS_SAFE does so even if the statement deletes the
485 current breakpoint. */
487 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
489 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
490 for (B = breakpoint_chain; \
491 B ? (TMP=B->next, 1): 0; \
494 /* Similar iterator for the low-level breakpoints. SAFE variant is
495 not provided so update_global_location_list must not be called
496 while executing the block of ALL_BP_LOCATIONS. */
498 #define ALL_BP_LOCATIONS(B,BP_TMP) \
499 for (BP_TMP = bp_locations; \
500 BP_TMP < bp_locations + bp_locations_count && (B = *BP_TMP);\
503 /* Iterates through locations with address ADDRESS for the currently selected
504 program space. BP_LOCP_TMP points to each object. BP_LOCP_START points
505 to where the loop should start from.
506 If BP_LOCP_START is a NULL pointer, the macro automatically seeks the
507 appropriate location to start with. */
509 #define ALL_BP_LOCATIONS_AT_ADDR(BP_LOCP_TMP, BP_LOCP_START, ADDRESS) \
510 for (BP_LOCP_START = BP_LOCP_START == NULL ? get_first_locp_gte_addr (ADDRESS) : BP_LOCP_START, \
511 BP_LOCP_TMP = BP_LOCP_START; \
513 && (BP_LOCP_TMP < bp_locations + bp_locations_count \
514 && (*BP_LOCP_TMP)->address == ADDRESS); \
517 /* Iterator for tracepoints only. */
519 #define ALL_TRACEPOINTS(B) \
520 for (B = breakpoint_chain; B; B = B->next) \
521 if (is_tracepoint (B))
523 /* Chains of all breakpoints defined. */
525 static struct breakpoint
*breakpoint_chain
;
527 /* Array is sorted by bp_location_is_less_than - primarily by the ADDRESS. */
529 static struct bp_location
**bp_locations
;
531 /* Number of elements of BP_LOCATIONS. */
533 static unsigned bp_locations_count
;
535 /* Maximum alignment offset between bp_target_info.PLACED_ADDRESS and
536 ADDRESS for the current elements of BP_LOCATIONS which get a valid
537 result from bp_location_has_shadow. You can use it for roughly
538 limiting the subrange of BP_LOCATIONS to scan for shadow bytes for
539 an address you need to read. */
541 static CORE_ADDR bp_locations_placed_address_before_address_max
;
543 /* Maximum offset plus alignment between bp_target_info.PLACED_ADDRESS
544 + bp_target_info.SHADOW_LEN and ADDRESS for the current elements of
545 BP_LOCATIONS which get a valid result from bp_location_has_shadow.
546 You can use it for roughly limiting the subrange of BP_LOCATIONS to
547 scan for shadow bytes for an address you need to read. */
549 static CORE_ADDR bp_locations_shadow_len_after_address_max
;
551 /* The locations that no longer correspond to any breakpoint, unlinked
552 from the bp_locations array, but for which a hit may still be
553 reported by a target. */
554 static std::vector
<bp_location
*> moribund_locations
;
556 /* Number of last breakpoint made. */
558 static int breakpoint_count
;
560 /* The value of `breakpoint_count' before the last command that
561 created breakpoints. If the last (break-like) command created more
562 than one breakpoint, then the difference between BREAKPOINT_COUNT
563 and PREV_BREAKPOINT_COUNT is more than one. */
564 static int prev_breakpoint_count
;
566 /* Number of last tracepoint made. */
568 static int tracepoint_count
;
570 static struct cmd_list_element
*breakpoint_set_cmdlist
;
571 static struct cmd_list_element
*breakpoint_show_cmdlist
;
572 struct cmd_list_element
*save_cmdlist
;
574 /* See declaration at breakpoint.h. */
577 breakpoint_find_if (int (*func
) (struct breakpoint
*b
, void *d
),
580 struct breakpoint
*b
= NULL
;
584 if (func (b
, user_data
) != 0)
591 /* Return whether a breakpoint is an active enabled breakpoint. */
593 breakpoint_enabled (struct breakpoint
*b
)
595 return (b
->enable_state
== bp_enabled
);
598 /* Set breakpoint count to NUM. */
601 set_breakpoint_count (int num
)
603 prev_breakpoint_count
= breakpoint_count
;
604 breakpoint_count
= num
;
605 set_internalvar_integer (lookup_internalvar ("bpnum"), num
);
608 /* Used by `start_rbreak_breakpoints' below, to record the current
609 breakpoint count before "rbreak" creates any breakpoint. */
610 static int rbreak_start_breakpoint_count
;
612 /* Called at the start an "rbreak" command to record the first
615 scoped_rbreak_breakpoints::scoped_rbreak_breakpoints ()
617 rbreak_start_breakpoint_count
= breakpoint_count
;
620 /* Called at the end of an "rbreak" command to record the last
623 scoped_rbreak_breakpoints::~scoped_rbreak_breakpoints ()
625 prev_breakpoint_count
= rbreak_start_breakpoint_count
;
628 /* Used in run_command to zero the hit count when a new run starts. */
631 clear_breakpoint_hit_counts (void)
633 struct breakpoint
*b
;
640 /* Return the breakpoint with the specified number, or NULL
641 if the number does not refer to an existing breakpoint. */
644 get_breakpoint (int num
)
646 struct breakpoint
*b
;
649 if (b
->number
== num
)
657 /* Mark locations as "conditions have changed" in case the target supports
658 evaluating conditions on its side. */
661 mark_breakpoint_modified (struct breakpoint
*b
)
663 struct bp_location
*loc
;
665 /* This is only meaningful if the target is
666 evaluating conditions and if the user has
667 opted for condition evaluation on the target's
669 if (gdb_evaluates_breakpoint_condition_p ()
670 || !target_supports_evaluation_of_breakpoint_conditions ())
673 if (!is_breakpoint (b
))
676 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
677 loc
->condition_changed
= condition_modified
;
680 /* Mark location as "conditions have changed" in case the target supports
681 evaluating conditions on its side. */
684 mark_breakpoint_location_modified (struct bp_location
*loc
)
686 /* This is only meaningful if the target is
687 evaluating conditions and if the user has
688 opted for condition evaluation on the target's
690 if (gdb_evaluates_breakpoint_condition_p ()
691 || !target_supports_evaluation_of_breakpoint_conditions ())
695 if (!is_breakpoint (loc
->owner
))
698 loc
->condition_changed
= condition_modified
;
701 /* Sets the condition-evaluation mode using the static global
702 condition_evaluation_mode. */
705 set_condition_evaluation_mode (const char *args
, int from_tty
,
706 struct cmd_list_element
*c
)
708 const char *old_mode
, *new_mode
;
710 if ((condition_evaluation_mode_1
== condition_evaluation_target
)
711 && !target_supports_evaluation_of_breakpoint_conditions ())
713 condition_evaluation_mode_1
= condition_evaluation_mode
;
714 warning (_("Target does not support breakpoint condition evaluation.\n"
715 "Using host evaluation mode instead."));
719 new_mode
= translate_condition_evaluation_mode (condition_evaluation_mode_1
);
720 old_mode
= translate_condition_evaluation_mode (condition_evaluation_mode
);
722 /* Flip the switch. Flip it even if OLD_MODE == NEW_MODE as one of the
723 settings was "auto". */
724 condition_evaluation_mode
= condition_evaluation_mode_1
;
726 /* Only update the mode if the user picked a different one. */
727 if (new_mode
!= old_mode
)
729 struct bp_location
*loc
, **loc_tmp
;
730 /* If the user switched to a different evaluation mode, we
731 need to synch the changes with the target as follows:
733 "host" -> "target": Send all (valid) conditions to the target.
734 "target" -> "host": Remove all the conditions from the target.
737 if (new_mode
== condition_evaluation_target
)
739 /* Mark everything modified and synch conditions with the
741 ALL_BP_LOCATIONS (loc
, loc_tmp
)
742 mark_breakpoint_location_modified (loc
);
746 /* Manually mark non-duplicate locations to synch conditions
747 with the target. We do this to remove all the conditions the
748 target knows about. */
749 ALL_BP_LOCATIONS (loc
, loc_tmp
)
750 if (is_breakpoint (loc
->owner
) && loc
->inserted
)
751 loc
->needs_update
= 1;
755 update_global_location_list (UGLL_MAY_INSERT
);
761 /* Shows the current mode of breakpoint condition evaluation. Explicitly shows
762 what "auto" is translating to. */
765 show_condition_evaluation_mode (struct ui_file
*file
, int from_tty
,
766 struct cmd_list_element
*c
, const char *value
)
768 if (condition_evaluation_mode
== condition_evaluation_auto
)
769 fprintf_filtered (file
,
770 _("Breakpoint condition evaluation "
771 "mode is %s (currently %s).\n"),
773 breakpoint_condition_evaluation_mode ());
775 fprintf_filtered (file
, _("Breakpoint condition evaluation mode is %s.\n"),
779 /* A comparison function for bp_location AP and BP that is used by
780 bsearch. This comparison function only cares about addresses, unlike
781 the more general bp_location_is_less_than function. */
784 bp_locations_compare_addrs (const void *ap
, const void *bp
)
786 const struct bp_location
*a
= *(const struct bp_location
**) ap
;
787 const struct bp_location
*b
= *(const struct bp_location
**) bp
;
789 if (a
->address
== b
->address
)
792 return ((a
->address
> b
->address
) - (a
->address
< b
->address
));
795 /* Helper function to skip all bp_locations with addresses
796 less than ADDRESS. It returns the first bp_location that
797 is greater than or equal to ADDRESS. If none is found, just
800 static struct bp_location
**
801 get_first_locp_gte_addr (CORE_ADDR address
)
803 struct bp_location dummy_loc
;
804 struct bp_location
*dummy_locp
= &dummy_loc
;
805 struct bp_location
**locp_found
= NULL
;
807 /* Initialize the dummy location's address field. */
808 dummy_loc
.address
= address
;
810 /* Find a close match to the first location at ADDRESS. */
811 locp_found
= ((struct bp_location
**)
812 bsearch (&dummy_locp
, bp_locations
, bp_locations_count
,
813 sizeof (struct bp_location
**),
814 bp_locations_compare_addrs
));
816 /* Nothing was found, nothing left to do. */
817 if (locp_found
== NULL
)
820 /* We may have found a location that is at ADDRESS but is not the first in the
821 location's list. Go backwards (if possible) and locate the first one. */
822 while ((locp_found
- 1) >= bp_locations
823 && (*(locp_found
- 1))->address
== address
)
830 set_breakpoint_condition (struct breakpoint
*b
, const char *exp
,
833 xfree (b
->cond_string
);
834 b
->cond_string
= NULL
;
836 if (is_watchpoint (b
))
838 struct watchpoint
*w
= (struct watchpoint
*) b
;
840 w
->cond_exp
.reset ();
844 struct bp_location
*loc
;
846 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
850 /* No need to free the condition agent expression
851 bytecode (if we have one). We will handle this
852 when we go through update_global_location_list. */
859 printf_filtered (_("Breakpoint %d now unconditional.\n"), b
->number
);
863 const char *arg
= exp
;
865 /* I don't know if it matters whether this is the string the user
866 typed in or the decompiled expression. */
867 b
->cond_string
= xstrdup (arg
);
868 b
->condition_not_parsed
= 0;
870 if (is_watchpoint (b
))
872 struct watchpoint
*w
= (struct watchpoint
*) b
;
874 innermost_block_tracker tracker
;
876 w
->cond_exp
= parse_exp_1 (&arg
, 0, 0, 0, &tracker
);
878 error (_("Junk at end of expression"));
879 w
->cond_exp_valid_block
= tracker
.block ();
883 struct bp_location
*loc
;
885 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
889 parse_exp_1 (&arg
, loc
->address
,
890 block_for_pc (loc
->address
), 0);
892 error (_("Junk at end of expression"));
896 mark_breakpoint_modified (b
);
898 gdb::observers::breakpoint_modified
.notify (b
);
901 /* Completion for the "condition" command. */
904 condition_completer (struct cmd_list_element
*cmd
,
905 completion_tracker
&tracker
,
906 const char *text
, const char *word
)
910 text
= skip_spaces (text
);
911 space
= skip_to_space (text
);
915 struct breakpoint
*b
;
919 /* We don't support completion of history indices. */
920 if (!isdigit (text
[1]))
921 complete_internalvar (tracker
, &text
[1]);
925 /* We're completing the breakpoint number. */
932 xsnprintf (number
, sizeof (number
), "%d", b
->number
);
934 if (strncmp (number
, text
, len
) == 0)
935 tracker
.add_completion (make_unique_xstrdup (number
));
941 /* We're completing the expression part. */
942 text
= skip_spaces (space
);
943 expression_completer (cmd
, tracker
, text
, word
);
946 /* condition N EXP -- set break condition of breakpoint N to EXP. */
949 condition_command (const char *arg
, int from_tty
)
951 struct breakpoint
*b
;
956 error_no_arg (_("breakpoint number"));
959 bnum
= get_number (&p
);
961 error (_("Bad breakpoint argument: '%s'"), arg
);
964 if (b
->number
== bnum
)
966 /* Check if this breakpoint has a "stop" method implemented in an
967 extension language. This method and conditions entered into GDB
968 from the CLI are mutually exclusive. */
969 const struct extension_language_defn
*extlang
970 = get_breakpoint_cond_ext_lang (b
, EXT_LANG_NONE
);
974 error (_("Only one stop condition allowed. There is currently"
975 " a %s stop condition defined for this breakpoint."),
976 ext_lang_capitalized_name (extlang
));
978 set_breakpoint_condition (b
, p
, from_tty
);
980 if (is_breakpoint (b
))
981 update_global_location_list (UGLL_MAY_INSERT
);
986 error (_("No breakpoint number %d."), bnum
);
989 /* Check that COMMAND do not contain commands that are suitable
990 only for tracepoints and not suitable for ordinary breakpoints.
991 Throw if any such commands is found. */
994 check_no_tracepoint_commands (struct command_line
*commands
)
996 struct command_line
*c
;
998 for (c
= commands
; c
; c
= c
->next
)
1000 if (c
->control_type
== while_stepping_control
)
1001 error (_("The 'while-stepping' command can "
1002 "only be used for tracepoints"));
1004 check_no_tracepoint_commands (c
->body_list_0
.get ());
1005 check_no_tracepoint_commands (c
->body_list_1
.get ());
1007 /* Not that command parsing removes leading whitespace and comment
1008 lines and also empty lines. So, we only need to check for
1009 command directly. */
1010 if (strstr (c
->line
, "collect ") == c
->line
)
1011 error (_("The 'collect' command can only be used for tracepoints"));
1013 if (strstr (c
->line
, "teval ") == c
->line
)
1014 error (_("The 'teval' command can only be used for tracepoints"));
1018 struct longjmp_breakpoint
: public breakpoint
1020 ~longjmp_breakpoint () override
;
1023 /* Encapsulate tests for different types of tracepoints. */
1026 is_tracepoint_type (bptype type
)
1028 return (type
== bp_tracepoint
1029 || type
== bp_fast_tracepoint
1030 || type
== bp_static_tracepoint
);
1034 is_longjmp_type (bptype type
)
1036 return type
== bp_longjmp
|| type
== bp_exception
;
1039 /* See breakpoint.h. */
1042 is_tracepoint (const struct breakpoint
*b
)
1044 return is_tracepoint_type (b
->type
);
1047 /* Factory function to create an appropriate instance of breakpoint given
1050 static std::unique_ptr
<breakpoint
>
1051 new_breakpoint_from_type (bptype type
)
1055 if (is_tracepoint_type (type
))
1056 b
= new tracepoint ();
1057 else if (is_longjmp_type (type
))
1058 b
= new longjmp_breakpoint ();
1060 b
= new breakpoint ();
1062 return std::unique_ptr
<breakpoint
> (b
);
1065 /* A helper function that validates that COMMANDS are valid for a
1066 breakpoint. This function will throw an exception if a problem is
1070 validate_commands_for_breakpoint (struct breakpoint
*b
,
1071 struct command_line
*commands
)
1073 if (is_tracepoint (b
))
1075 struct tracepoint
*t
= (struct tracepoint
*) b
;
1076 struct command_line
*c
;
1077 struct command_line
*while_stepping
= 0;
1079 /* Reset the while-stepping step count. The previous commands
1080 might have included a while-stepping action, while the new
1084 /* We need to verify that each top-level element of commands is
1085 valid for tracepoints, that there's at most one
1086 while-stepping element, and that the while-stepping's body
1087 has valid tracing commands excluding nested while-stepping.
1088 We also need to validate the tracepoint action line in the
1089 context of the tracepoint --- validate_actionline actually
1090 has side effects, like setting the tracepoint's
1091 while-stepping STEP_COUNT, in addition to checking if the
1092 collect/teval actions parse and make sense in the
1093 tracepoint's context. */
1094 for (c
= commands
; c
; c
= c
->next
)
1096 if (c
->control_type
== while_stepping_control
)
1098 if (b
->type
== bp_fast_tracepoint
)
1099 error (_("The 'while-stepping' command "
1100 "cannot be used for fast tracepoint"));
1101 else if (b
->type
== bp_static_tracepoint
)
1102 error (_("The 'while-stepping' command "
1103 "cannot be used for static tracepoint"));
1106 error (_("The 'while-stepping' command "
1107 "can be used only once"));
1112 validate_actionline (c
->line
, b
);
1116 struct command_line
*c2
;
1118 gdb_assert (while_stepping
->body_list_1
== nullptr);
1119 c2
= while_stepping
->body_list_0
.get ();
1120 for (; c2
; c2
= c2
->next
)
1122 if (c2
->control_type
== while_stepping_control
)
1123 error (_("The 'while-stepping' command cannot be nested"));
1129 check_no_tracepoint_commands (commands
);
1133 /* Return a vector of all the static tracepoints set at ADDR. The
1134 caller is responsible for releasing the vector. */
1136 std::vector
<breakpoint
*>
1137 static_tracepoints_here (CORE_ADDR addr
)
1139 struct breakpoint
*b
;
1140 std::vector
<breakpoint
*> found
;
1141 struct bp_location
*loc
;
1144 if (b
->type
== bp_static_tracepoint
)
1146 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1147 if (loc
->address
== addr
)
1148 found
.push_back (b
);
1154 /* Set the command list of B to COMMANDS. If breakpoint is tracepoint,
1155 validate that only allowed commands are included. */
1158 breakpoint_set_commands (struct breakpoint
*b
,
1159 counted_command_line
&&commands
)
1161 validate_commands_for_breakpoint (b
, commands
.get ());
1163 b
->commands
= std::move (commands
);
1164 gdb::observers::breakpoint_modified
.notify (b
);
1167 /* Set the internal `silent' flag on the breakpoint. Note that this
1168 is not the same as the "silent" that may appear in the breakpoint's
1172 breakpoint_set_silent (struct breakpoint
*b
, int silent
)
1174 int old_silent
= b
->silent
;
1177 if (old_silent
!= silent
)
1178 gdb::observers::breakpoint_modified
.notify (b
);
1181 /* Set the thread for this breakpoint. If THREAD is -1, make the
1182 breakpoint work for any thread. */
1185 breakpoint_set_thread (struct breakpoint
*b
, int thread
)
1187 int old_thread
= b
->thread
;
1190 if (old_thread
!= thread
)
1191 gdb::observers::breakpoint_modified
.notify (b
);
1194 /* Set the task for this breakpoint. If TASK is 0, make the
1195 breakpoint work for any task. */
1198 breakpoint_set_task (struct breakpoint
*b
, int task
)
1200 int old_task
= b
->task
;
1203 if (old_task
!= task
)
1204 gdb::observers::breakpoint_modified
.notify (b
);
1208 commands_command_1 (const char *arg
, int from_tty
,
1209 struct command_line
*control
)
1211 counted_command_line cmd
;
1212 /* cmd_read will be true once we have read cmd. Note that cmd might still be
1213 NULL after the call to read_command_lines if the user provides an empty
1214 list of command by just typing "end". */
1215 bool cmd_read
= false;
1217 std::string new_arg
;
1219 if (arg
== NULL
|| !*arg
)
1221 if (breakpoint_count
- prev_breakpoint_count
> 1)
1222 new_arg
= string_printf ("%d-%d", prev_breakpoint_count
+ 1,
1224 else if (breakpoint_count
> 0)
1225 new_arg
= string_printf ("%d", breakpoint_count
);
1226 arg
= new_arg
.c_str ();
1229 map_breakpoint_numbers
1230 (arg
, [&] (breakpoint
*b
)
1234 gdb_assert (cmd
== NULL
);
1235 if (control
!= NULL
)
1236 cmd
= control
->body_list_0
;
1240 = string_printf (_("Type commands for breakpoint(s) "
1241 "%s, one per line."),
1244 auto do_validate
= [=] (const char *line
)
1246 validate_actionline (line
, b
);
1248 gdb::function_view
<void (const char *)> validator
;
1249 if (is_tracepoint (b
))
1250 validator
= do_validate
;
1252 cmd
= read_command_lines (str
.c_str (), from_tty
, 1, validator
);
1257 /* If a breakpoint was on the list more than once, we don't need to
1259 if (b
->commands
!= cmd
)
1261 validate_commands_for_breakpoint (b
, cmd
.get ());
1263 gdb::observers::breakpoint_modified
.notify (b
);
1269 commands_command (const char *arg
, int from_tty
)
1271 commands_command_1 (arg
, from_tty
, NULL
);
1274 /* Like commands_command, but instead of reading the commands from
1275 input stream, takes them from an already parsed command structure.
1277 This is used by cli-script.c to DTRT with breakpoint commands
1278 that are part of if and while bodies. */
1279 enum command_control_type
1280 commands_from_control_command (const char *arg
, struct command_line
*cmd
)
1282 commands_command_1 (arg
, 0, cmd
);
1283 return simple_control
;
1286 /* Return non-zero if BL->TARGET_INFO contains valid information. */
1289 bp_location_has_shadow (struct bp_location
*bl
)
1291 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
1295 if (bl
->target_info
.shadow_len
== 0)
1296 /* BL isn't valid, or doesn't shadow memory. */
1301 /* Update BUF, which is LEN bytes read from the target address
1302 MEMADDR, by replacing a memory breakpoint with its shadowed
1305 If READBUF is not NULL, this buffer must not overlap with the of
1306 the breakpoint location's shadow_contents buffer. Otherwise, a
1307 failed assertion internal error will be raised. */
1310 one_breakpoint_xfer_memory (gdb_byte
*readbuf
, gdb_byte
*writebuf
,
1311 const gdb_byte
*writebuf_org
,
1312 ULONGEST memaddr
, LONGEST len
,
1313 struct bp_target_info
*target_info
,
1314 struct gdbarch
*gdbarch
)
1316 /* Now do full processing of the found relevant range of elements. */
1317 CORE_ADDR bp_addr
= 0;
1321 if (!breakpoint_address_match (target_info
->placed_address_space
, 0,
1322 current_program_space
->aspace
, 0))
1324 /* The breakpoint is inserted in a different address space. */
1328 /* Addresses and length of the part of the breakpoint that
1330 bp_addr
= target_info
->placed_address
;
1331 bp_size
= target_info
->shadow_len
;
1333 if (bp_addr
+ bp_size
<= memaddr
)
1335 /* The breakpoint is entirely before the chunk of memory we are
1340 if (bp_addr
>= memaddr
+ len
)
1342 /* The breakpoint is entirely after the chunk of memory we are
1347 /* Offset within shadow_contents. */
1348 if (bp_addr
< memaddr
)
1350 /* Only copy the second part of the breakpoint. */
1351 bp_size
-= memaddr
- bp_addr
;
1352 bptoffset
= memaddr
- bp_addr
;
1356 if (bp_addr
+ bp_size
> memaddr
+ len
)
1358 /* Only copy the first part of the breakpoint. */
1359 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
1362 if (readbuf
!= NULL
)
1364 /* Verify that the readbuf buffer does not overlap with the
1365 shadow_contents buffer. */
1366 gdb_assert (target_info
->shadow_contents
>= readbuf
+ len
1367 || readbuf
>= (target_info
->shadow_contents
1368 + target_info
->shadow_len
));
1370 /* Update the read buffer with this inserted breakpoint's
1372 memcpy (readbuf
+ bp_addr
- memaddr
,
1373 target_info
->shadow_contents
+ bptoffset
, bp_size
);
1377 const unsigned char *bp
;
1378 CORE_ADDR addr
= target_info
->reqstd_address
;
1381 /* Update the shadow with what we want to write to memory. */
1382 memcpy (target_info
->shadow_contents
+ bptoffset
,
1383 writebuf_org
+ bp_addr
- memaddr
, bp_size
);
1385 /* Determine appropriate breakpoint contents and size for this
1387 bp
= gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &placed_size
);
1389 /* Update the final write buffer with this inserted
1390 breakpoint's INSN. */
1391 memcpy (writebuf
+ bp_addr
- memaddr
, bp
+ bptoffset
, bp_size
);
1395 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
1396 by replacing any memory breakpoints with their shadowed contents.
1398 If READBUF is not NULL, this buffer must not overlap with any of
1399 the breakpoint location's shadow_contents buffers. Otherwise,
1400 a failed assertion internal error will be raised.
1402 The range of shadowed area by each bp_location is:
1403 bl->address - bp_locations_placed_address_before_address_max
1404 up to bl->address + bp_locations_shadow_len_after_address_max
1405 The range we were requested to resolve shadows for is:
1406 memaddr ... memaddr + len
1407 Thus the safe cutoff boundaries for performance optimization are
1408 memaddr + len <= (bl->address
1409 - bp_locations_placed_address_before_address_max)
1411 bl->address + bp_locations_shadow_len_after_address_max <= memaddr */
1414 breakpoint_xfer_memory (gdb_byte
*readbuf
, gdb_byte
*writebuf
,
1415 const gdb_byte
*writebuf_org
,
1416 ULONGEST memaddr
, LONGEST len
)
1418 /* Left boundary, right boundary and median element of our binary
1420 unsigned bc_l
, bc_r
, bc
;
1422 /* Find BC_L which is a leftmost element which may affect BUF
1423 content. It is safe to report lower value but a failure to
1424 report higher one. */
1427 bc_r
= bp_locations_count
;
1428 while (bc_l
+ 1 < bc_r
)
1430 struct bp_location
*bl
;
1432 bc
= (bc_l
+ bc_r
) / 2;
1433 bl
= bp_locations
[bc
];
1435 /* Check first BL->ADDRESS will not overflow due to the added
1436 constant. Then advance the left boundary only if we are sure
1437 the BC element can in no way affect the BUF content (MEMADDR
1438 to MEMADDR + LEN range).
1440 Use the BP_LOCATIONS_SHADOW_LEN_AFTER_ADDRESS_MAX safety
1441 offset so that we cannot miss a breakpoint with its shadow
1442 range tail still reaching MEMADDR. */
1444 if ((bl
->address
+ bp_locations_shadow_len_after_address_max
1446 && (bl
->address
+ bp_locations_shadow_len_after_address_max
1453 /* Due to the binary search above, we need to make sure we pick the
1454 first location that's at BC_L's address. E.g., if there are
1455 multiple locations at the same address, BC_L may end up pointing
1456 at a duplicate location, and miss the "master"/"inserted"
1457 location. Say, given locations L1, L2 and L3 at addresses A and
1460 L1@A, L2@A, L3@B, ...
1462 BC_L could end up pointing at location L2, while the "master"
1463 location could be L1. Since the `loc->inserted' flag is only set
1464 on "master" locations, we'd forget to restore the shadow of L1
1467 && bp_locations
[bc_l
]->address
== bp_locations
[bc_l
- 1]->address
)
1470 /* Now do full processing of the found relevant range of elements. */
1472 for (bc
= bc_l
; bc
< bp_locations_count
; bc
++)
1474 struct bp_location
*bl
= bp_locations
[bc
];
1476 /* bp_location array has BL->OWNER always non-NULL. */
1477 if (bl
->owner
->type
== bp_none
)
1478 warning (_("reading through apparently deleted breakpoint #%d?"),
1481 /* Performance optimization: any further element can no longer affect BUF
1484 if (bl
->address
>= bp_locations_placed_address_before_address_max
1485 && memaddr
+ len
<= (bl
->address
1486 - bp_locations_placed_address_before_address_max
))
1489 if (!bp_location_has_shadow (bl
))
1492 one_breakpoint_xfer_memory (readbuf
, writebuf
, writebuf_org
,
1493 memaddr
, len
, &bl
->target_info
, bl
->gdbarch
);
1497 /* See breakpoint.h. */
1500 is_breakpoint (const struct breakpoint
*bpt
)
1502 return (bpt
->type
== bp_breakpoint
1503 || bpt
->type
== bp_hardware_breakpoint
1504 || bpt
->type
== bp_dprintf
);
1507 /* Return true if BPT is of any hardware watchpoint kind. */
1510 is_hardware_watchpoint (const struct breakpoint
*bpt
)
1512 return (bpt
->type
== bp_hardware_watchpoint
1513 || bpt
->type
== bp_read_watchpoint
1514 || bpt
->type
== bp_access_watchpoint
);
1517 /* See breakpoint.h. */
1520 is_watchpoint (const struct breakpoint
*bpt
)
1522 return (is_hardware_watchpoint (bpt
)
1523 || bpt
->type
== bp_watchpoint
);
1526 /* Returns true if the current thread and its running state are safe
1527 to evaluate or update watchpoint B. Watchpoints on local
1528 expressions need to be evaluated in the context of the thread that
1529 was current when the watchpoint was created, and, that thread needs
1530 to be stopped to be able to select the correct frame context.
1531 Watchpoints on global expressions can be evaluated on any thread,
1532 and in any state. It is presently left to the target allowing
1533 memory accesses when threads are running. */
1536 watchpoint_in_thread_scope (struct watchpoint
*b
)
1538 return (b
->pspace
== current_program_space
1539 && (b
->watchpoint_thread
== null_ptid
1540 || (inferior_ptid
== b
->watchpoint_thread
1541 && !inferior_thread ()->executing
)));
1544 /* Set watchpoint B to disp_del_at_next_stop, even including its possible
1545 associated bp_watchpoint_scope breakpoint. */
1548 watchpoint_del_at_next_stop (struct watchpoint
*w
)
1550 if (w
->related_breakpoint
!= w
)
1552 gdb_assert (w
->related_breakpoint
->type
== bp_watchpoint_scope
);
1553 gdb_assert (w
->related_breakpoint
->related_breakpoint
== w
);
1554 w
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
1555 w
->related_breakpoint
->related_breakpoint
= w
->related_breakpoint
;
1556 w
->related_breakpoint
= w
;
1558 w
->disposition
= disp_del_at_next_stop
;
1561 /* Extract a bitfield value from value VAL using the bit parameters contained in
1564 static struct value
*
1565 extract_bitfield_from_watchpoint_value (struct watchpoint
*w
, struct value
*val
)
1567 struct value
*bit_val
;
1572 bit_val
= allocate_value (value_type (val
));
1574 unpack_value_bitfield (bit_val
,
1577 value_contents_for_printing (val
),
1584 /* Allocate a dummy location and add it to B, which must be a software
1585 watchpoint. This is required because even if a software watchpoint
1586 is not watching any memory, bpstat_stop_status requires a location
1587 to be able to report stops. */
1590 software_watchpoint_add_no_memory_location (struct breakpoint
*b
,
1591 struct program_space
*pspace
)
1593 gdb_assert (b
->type
== bp_watchpoint
&& b
->loc
== NULL
);
1595 b
->loc
= allocate_bp_location (b
);
1596 b
->loc
->pspace
= pspace
;
1597 b
->loc
->address
= -1;
1598 b
->loc
->length
= -1;
1601 /* Returns true if B is a software watchpoint that is not watching any
1602 memory (e.g., "watch $pc"). */
1605 is_no_memory_software_watchpoint (struct breakpoint
*b
)
1607 return (b
->type
== bp_watchpoint
1609 && b
->loc
->next
== NULL
1610 && b
->loc
->address
== -1
1611 && b
->loc
->length
== -1);
1614 /* Assuming that B is a watchpoint:
1615 - Reparse watchpoint expression, if REPARSE is non-zero
1616 - Evaluate expression and store the result in B->val
1617 - Evaluate the condition if there is one, and store the result
1619 - Update the list of values that must be watched in B->loc.
1621 If the watchpoint disposition is disp_del_at_next_stop, then do
1622 nothing. If this is local watchpoint that is out of scope, delete
1625 Even with `set breakpoint always-inserted on' the watchpoints are
1626 removed + inserted on each stop here. Normal breakpoints must
1627 never be removed because they might be missed by a running thread
1628 when debugging in non-stop mode. On the other hand, hardware
1629 watchpoints (is_hardware_watchpoint; processed here) are specific
1630 to each LWP since they are stored in each LWP's hardware debug
1631 registers. Therefore, such LWP must be stopped first in order to
1632 be able to modify its hardware watchpoints.
1634 Hardware watchpoints must be reset exactly once after being
1635 presented to the user. It cannot be done sooner, because it would
1636 reset the data used to present the watchpoint hit to the user. And
1637 it must not be done later because it could display the same single
1638 watchpoint hit during multiple GDB stops. Note that the latter is
1639 relevant only to the hardware watchpoint types bp_read_watchpoint
1640 and bp_access_watchpoint. False hit by bp_hardware_watchpoint is
1641 not user-visible - its hit is suppressed if the memory content has
1644 The following constraints influence the location where we can reset
1645 hardware watchpoints:
1647 * target_stopped_by_watchpoint and target_stopped_data_address are
1648 called several times when GDB stops.
1651 * Multiple hardware watchpoints can be hit at the same time,
1652 causing GDB to stop. GDB only presents one hardware watchpoint
1653 hit at a time as the reason for stopping, and all the other hits
1654 are presented later, one after the other, each time the user
1655 requests the execution to be resumed. Execution is not resumed
1656 for the threads still having pending hit event stored in
1657 LWP_INFO->STATUS. While the watchpoint is already removed from
1658 the inferior on the first stop the thread hit event is kept being
1659 reported from its cached value by linux_nat_stopped_data_address
1660 until the real thread resume happens after the watchpoint gets
1661 presented and thus its LWP_INFO->STATUS gets reset.
1663 Therefore the hardware watchpoint hit can get safely reset on the
1664 watchpoint removal from inferior. */
1667 update_watchpoint (struct watchpoint
*b
, int reparse
)
1669 int within_current_scope
;
1670 struct frame_id saved_frame_id
;
1673 /* If this is a local watchpoint, we only want to check if the
1674 watchpoint frame is in scope if the current thread is the thread
1675 that was used to create the watchpoint. */
1676 if (!watchpoint_in_thread_scope (b
))
1679 if (b
->disposition
== disp_del_at_next_stop
)
1684 /* Determine if the watchpoint is within scope. */
1685 if (b
->exp_valid_block
== NULL
)
1686 within_current_scope
= 1;
1689 struct frame_info
*fi
= get_current_frame ();
1690 struct gdbarch
*frame_arch
= get_frame_arch (fi
);
1691 CORE_ADDR frame_pc
= get_frame_pc (fi
);
1693 /* If we're at a point where the stack has been destroyed
1694 (e.g. in a function epilogue), unwinding may not work
1695 properly. Do not attempt to recreate locations at this
1696 point. See similar comments in watchpoint_check. */
1697 if (gdbarch_stack_frame_destroyed_p (frame_arch
, frame_pc
))
1700 /* Save the current frame's ID so we can restore it after
1701 evaluating the watchpoint expression on its own frame. */
1702 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
1703 took a frame parameter, so that we didn't have to change the
1706 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
1708 fi
= frame_find_by_id (b
->watchpoint_frame
);
1709 within_current_scope
= (fi
!= NULL
);
1710 if (within_current_scope
)
1714 /* We don't free locations. They are stored in the bp_location array
1715 and update_global_location_list will eventually delete them and
1716 remove breakpoints if needed. */
1719 if (within_current_scope
&& reparse
)
1724 s
= b
->exp_string_reparse
? b
->exp_string_reparse
: b
->exp_string
;
1725 b
->exp
= parse_exp_1 (&s
, 0, b
->exp_valid_block
, 0);
1726 /* If the meaning of expression itself changed, the old value is
1727 no longer relevant. We don't want to report a watchpoint hit
1728 to the user when the old value and the new value may actually
1729 be completely different objects. */
1731 b
->val_valid
= false;
1733 /* Note that unlike with breakpoints, the watchpoint's condition
1734 expression is stored in the breakpoint object, not in the
1735 locations (re)created below. */
1736 if (b
->cond_string
!= NULL
)
1738 b
->cond_exp
.reset ();
1741 b
->cond_exp
= parse_exp_1 (&s
, 0, b
->cond_exp_valid_block
, 0);
1745 /* If we failed to parse the expression, for example because
1746 it refers to a global variable in a not-yet-loaded shared library,
1747 don't try to insert watchpoint. We don't automatically delete
1748 such watchpoint, though, since failure to parse expression
1749 is different from out-of-scope watchpoint. */
1750 if (!target_has_execution
)
1752 /* Without execution, memory can't change. No use to try and
1753 set watchpoint locations. The watchpoint will be reset when
1754 the target gains execution, through breakpoint_re_set. */
1755 if (!can_use_hw_watchpoints
)
1757 if (b
->ops
->works_in_software_mode (b
))
1758 b
->type
= bp_watchpoint
;
1760 error (_("Can't set read/access watchpoint when "
1761 "hardware watchpoints are disabled."));
1764 else if (within_current_scope
&& b
->exp
)
1767 std::vector
<value_ref_ptr
> val_chain
;
1768 struct value
*v
, *result
;
1769 struct program_space
*frame_pspace
;
1771 fetch_subexp_value (b
->exp
.get (), &pc
, &v
, &result
, &val_chain
, 0);
1773 /* Avoid setting b->val if it's already set. The meaning of
1774 b->val is 'the last value' user saw, and we should update
1775 it only if we reported that last value to user. As it
1776 happens, the code that reports it updates b->val directly.
1777 We don't keep track of the memory value for masked
1779 if (!b
->val_valid
&& !is_masked_watchpoint (b
))
1781 if (b
->val_bitsize
!= 0)
1782 v
= extract_bitfield_from_watchpoint_value (b
, v
);
1783 b
->val
= release_value (v
);
1784 b
->val_valid
= true;
1787 frame_pspace
= get_frame_program_space (get_selected_frame (NULL
));
1789 /* Look at each value on the value chain. */
1790 gdb_assert (!val_chain
.empty ());
1791 for (const value_ref_ptr
&iter
: val_chain
)
1795 /* If it's a memory location, and GDB actually needed
1796 its contents to evaluate the expression, then we
1797 must watch it. If the first value returned is
1798 still lazy, that means an error occurred reading it;
1799 watch it anyway in case it becomes readable. */
1800 if (VALUE_LVAL (v
) == lval_memory
1801 && (v
== val_chain
[0] || ! value_lazy (v
)))
1803 struct type
*vtype
= check_typedef (value_type (v
));
1805 /* We only watch structs and arrays if user asked
1806 for it explicitly, never if they just happen to
1807 appear in the middle of some value chain. */
1809 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
1810 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
1813 enum target_hw_bp_type type
;
1814 struct bp_location
*loc
, **tmp
;
1815 int bitpos
= 0, bitsize
= 0;
1817 if (value_bitsize (v
) != 0)
1819 /* Extract the bit parameters out from the bitfield
1821 bitpos
= value_bitpos (v
);
1822 bitsize
= value_bitsize (v
);
1824 else if (v
== result
&& b
->val_bitsize
!= 0)
1826 /* If VAL_BITSIZE != 0 then RESULT is actually a bitfield
1827 lvalue whose bit parameters are saved in the fields
1828 VAL_BITPOS and VAL_BITSIZE. */
1829 bitpos
= b
->val_bitpos
;
1830 bitsize
= b
->val_bitsize
;
1833 addr
= value_address (v
);
1836 /* Skip the bytes that don't contain the bitfield. */
1841 if (b
->type
== bp_read_watchpoint
)
1843 else if (b
->type
== bp_access_watchpoint
)
1846 loc
= allocate_bp_location (b
);
1847 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
1850 loc
->gdbarch
= get_type_arch (value_type (v
));
1852 loc
->pspace
= frame_pspace
;
1853 loc
->address
= address_significant (loc
->gdbarch
, addr
);
1857 /* Just cover the bytes that make up the bitfield. */
1858 loc
->length
= ((bitpos
% 8) + bitsize
+ 7) / 8;
1861 loc
->length
= TYPE_LENGTH (value_type (v
));
1863 loc
->watchpoint_type
= type
;
1868 /* Change the type of breakpoint between hardware assisted or
1869 an ordinary watchpoint depending on the hardware support
1870 and free hardware slots. REPARSE is set when the inferior
1875 enum bp_loc_type loc_type
;
1876 struct bp_location
*bl
;
1878 reg_cnt
= can_use_hardware_watchpoint (val_chain
);
1882 int i
, target_resources_ok
, other_type_used
;
1885 /* Use an exact watchpoint when there's only one memory region to be
1886 watched, and only one debug register is needed to watch it. */
1887 b
->exact
= target_exact_watchpoints
&& reg_cnt
== 1;
1889 /* We need to determine how many resources are already
1890 used for all other hardware watchpoints plus this one
1891 to see if we still have enough resources to also fit
1892 this watchpoint in as well. */
1894 /* If this is a software watchpoint, we try to turn it
1895 to a hardware one -- count resources as if B was of
1896 hardware watchpoint type. */
1898 if (type
== bp_watchpoint
)
1899 type
= bp_hardware_watchpoint
;
1901 /* This watchpoint may or may not have been placed on
1902 the list yet at this point (it won't be in the list
1903 if we're trying to create it for the first time,
1904 through watch_command), so always account for it
1907 /* Count resources used by all watchpoints except B. */
1908 i
= hw_watchpoint_used_count_others (b
, type
, &other_type_used
);
1910 /* Add in the resources needed for B. */
1911 i
+= hw_watchpoint_use_count (b
);
1914 = target_can_use_hardware_watchpoint (type
, i
, other_type_used
);
1915 if (target_resources_ok
<= 0)
1917 int sw_mode
= b
->ops
->works_in_software_mode (b
);
1919 if (target_resources_ok
== 0 && !sw_mode
)
1920 error (_("Target does not support this type of "
1921 "hardware watchpoint."));
1922 else if (target_resources_ok
< 0 && !sw_mode
)
1923 error (_("There are not enough available hardware "
1924 "resources for this watchpoint."));
1926 /* Downgrade to software watchpoint. */
1927 b
->type
= bp_watchpoint
;
1931 /* If this was a software watchpoint, we've just
1932 found we have enough resources to turn it to a
1933 hardware watchpoint. Otherwise, this is a
1938 else if (!b
->ops
->works_in_software_mode (b
))
1940 if (!can_use_hw_watchpoints
)
1941 error (_("Can't set read/access watchpoint when "
1942 "hardware watchpoints are disabled."));
1944 error (_("Expression cannot be implemented with "
1945 "read/access watchpoint."));
1948 b
->type
= bp_watchpoint
;
1950 loc_type
= (b
->type
== bp_watchpoint
? bp_loc_other
1951 : bp_loc_hardware_watchpoint
);
1952 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
1953 bl
->loc_type
= loc_type
;
1956 /* If a software watchpoint is not watching any memory, then the
1957 above left it without any location set up. But,
1958 bpstat_stop_status requires a location to be able to report
1959 stops, so make sure there's at least a dummy one. */
1960 if (b
->type
== bp_watchpoint
&& b
->loc
== NULL
)
1961 software_watchpoint_add_no_memory_location (b
, frame_pspace
);
1963 else if (!within_current_scope
)
1965 printf_filtered (_("\
1966 Watchpoint %d deleted because the program has left the block\n\
1967 in which its expression is valid.\n"),
1969 watchpoint_del_at_next_stop (b
);
1972 /* Restore the selected frame. */
1974 select_frame (frame_find_by_id (saved_frame_id
));
1978 /* Returns 1 iff breakpoint location should be
1979 inserted in the inferior. We don't differentiate the type of BL's owner
1980 (breakpoint vs. tracepoint), although insert_location in tracepoint's
1981 breakpoint_ops is not defined, because in insert_bp_location,
1982 tracepoint's insert_location will not be called. */
1984 should_be_inserted (struct bp_location
*bl
)
1986 if (bl
->owner
== NULL
|| !breakpoint_enabled (bl
->owner
))
1989 if (bl
->owner
->disposition
== disp_del_at_next_stop
)
1992 if (!bl
->enabled
|| bl
->shlib_disabled
|| bl
->duplicate
)
1995 if (user_breakpoint_p (bl
->owner
) && bl
->pspace
->executing_startup
)
1998 /* This is set for example, when we're attached to the parent of a
1999 vfork, and have detached from the child. The child is running
2000 free, and we expect it to do an exec or exit, at which point the
2001 OS makes the parent schedulable again (and the target reports
2002 that the vfork is done). Until the child is done with the shared
2003 memory region, do not insert breakpoints in the parent, otherwise
2004 the child could still trip on the parent's breakpoints. Since
2005 the parent is blocked anyway, it won't miss any breakpoint. */
2006 if (bl
->pspace
->breakpoints_not_allowed
)
2009 /* Don't insert a breakpoint if we're trying to step past its
2010 location, except if the breakpoint is a single-step breakpoint,
2011 and the breakpoint's thread is the thread which is stepping past
2013 if ((bl
->loc_type
== bp_loc_software_breakpoint
2014 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
2015 && stepping_past_instruction_at (bl
->pspace
->aspace
,
2017 /* The single-step breakpoint may be inserted at the location
2018 we're trying to step if the instruction branches to itself.
2019 However, the instruction won't be executed at all and it may
2020 break the semantics of the instruction, for example, the
2021 instruction is a conditional branch or updates some flags.
2022 We can't fix it unless GDB is able to emulate the instruction
2023 or switch to displaced stepping. */
2024 && !(bl
->owner
->type
== bp_single_step
2025 && thread_is_stepping_over_breakpoint (bl
->owner
->thread
)))
2029 fprintf_unfiltered (gdb_stdlog
,
2030 "infrun: skipping breakpoint: "
2031 "stepping past insn at: %s\n",
2032 paddress (bl
->gdbarch
, bl
->address
));
2037 /* Don't insert watchpoints if we're trying to step past the
2038 instruction that triggered one. */
2039 if ((bl
->loc_type
== bp_loc_hardware_watchpoint
)
2040 && stepping_past_nonsteppable_watchpoint ())
2044 fprintf_unfiltered (gdb_stdlog
,
2045 "infrun: stepping past non-steppable watchpoint. "
2046 "skipping watchpoint at %s:%d\n",
2047 paddress (bl
->gdbarch
, bl
->address
),
2056 /* Same as should_be_inserted but does the check assuming
2057 that the location is not duplicated. */
2060 unduplicated_should_be_inserted (struct bp_location
*bl
)
2063 const int save_duplicate
= bl
->duplicate
;
2066 result
= should_be_inserted (bl
);
2067 bl
->duplicate
= save_duplicate
;
2071 /* Parses a conditional described by an expression COND into an
2072 agent expression bytecode suitable for evaluation
2073 by the bytecode interpreter. Return NULL if there was
2074 any error during parsing. */
2076 static agent_expr_up
2077 parse_cond_to_aexpr (CORE_ADDR scope
, struct expression
*cond
)
2082 agent_expr_up aexpr
;
2084 /* We don't want to stop processing, so catch any errors
2085 that may show up. */
2088 aexpr
= gen_eval_for_expr (scope
, cond
);
2091 catch (const gdb_exception_error
&ex
)
2093 /* If we got here, it means the condition could not be parsed to a valid
2094 bytecode expression and thus can't be evaluated on the target's side.
2095 It's no use iterating through the conditions. */
2098 /* We have a valid agent expression. */
2102 /* Based on location BL, create a list of breakpoint conditions to be
2103 passed on to the target. If we have duplicated locations with different
2104 conditions, we will add such conditions to the list. The idea is that the
2105 target will evaluate the list of conditions and will only notify GDB when
2106 one of them is true. */
2109 build_target_condition_list (struct bp_location
*bl
)
2111 struct bp_location
**locp
= NULL
, **loc2p
;
2112 int null_condition_or_parse_error
= 0;
2113 int modified
= bl
->needs_update
;
2114 struct bp_location
*loc
;
2116 /* Release conditions left over from a previous insert. */
2117 bl
->target_info
.conditions
.clear ();
2119 /* This is only meaningful if the target is
2120 evaluating conditions and if the user has
2121 opted for condition evaluation on the target's
2123 if (gdb_evaluates_breakpoint_condition_p ()
2124 || !target_supports_evaluation_of_breakpoint_conditions ())
2127 /* Do a first pass to check for locations with no assigned
2128 conditions or conditions that fail to parse to a valid agent expression
2129 bytecode. If any of these happen, then it's no use to send conditions
2130 to the target since this location will always trigger and generate a
2131 response back to GDB. */
2132 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2135 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2139 /* Re-parse the conditions since something changed. In that
2140 case we already freed the condition bytecodes (see
2141 force_breakpoint_reinsertion). We just
2142 need to parse the condition to bytecodes again. */
2143 loc
->cond_bytecode
= parse_cond_to_aexpr (bl
->address
,
2147 /* If we have a NULL bytecode expression, it means something
2148 went wrong or we have a null condition expression. */
2149 if (!loc
->cond_bytecode
)
2151 null_condition_or_parse_error
= 1;
2157 /* If any of these happened, it means we will have to evaluate the conditions
2158 for the location's address on gdb's side. It is no use keeping bytecodes
2159 for all the other duplicate locations, thus we free all of them here.
2161 This is so we have a finer control over which locations' conditions are
2162 being evaluated by GDB or the remote stub. */
2163 if (null_condition_or_parse_error
)
2165 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2168 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2170 /* Only go as far as the first NULL bytecode is
2172 if (!loc
->cond_bytecode
)
2175 loc
->cond_bytecode
.reset ();
2180 /* No NULL conditions or failed bytecode generation. Build a condition list
2181 for this location's address. */
2182 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2186 && is_breakpoint (loc
->owner
)
2187 && loc
->pspace
->num
== bl
->pspace
->num
2188 && loc
->owner
->enable_state
== bp_enabled
2191 /* Add the condition to the vector. This will be used later
2192 to send the conditions to the target. */
2193 bl
->target_info
.conditions
.push_back (loc
->cond_bytecode
.get ());
2200 /* Parses a command described by string CMD into an agent expression
2201 bytecode suitable for evaluation by the bytecode interpreter.
2202 Return NULL if there was any error during parsing. */
2204 static agent_expr_up
2205 parse_cmd_to_aexpr (CORE_ADDR scope
, char *cmd
)
2207 const char *cmdrest
;
2208 const char *format_start
, *format_end
;
2209 struct gdbarch
*gdbarch
= get_current_arch ();
2216 if (*cmdrest
== ',')
2218 cmdrest
= skip_spaces (cmdrest
);
2220 if (*cmdrest
++ != '"')
2221 error (_("No format string following the location"));
2223 format_start
= cmdrest
;
2225 format_pieces
fpieces (&cmdrest
);
2227 format_end
= cmdrest
;
2229 if (*cmdrest
++ != '"')
2230 error (_("Bad format string, non-terminated '\"'."));
2232 cmdrest
= skip_spaces (cmdrest
);
2234 if (!(*cmdrest
== ',' || *cmdrest
== '\0'))
2235 error (_("Invalid argument syntax"));
2237 if (*cmdrest
== ',')
2239 cmdrest
= skip_spaces (cmdrest
);
2241 /* For each argument, make an expression. */
2243 std::vector
<struct expression
*> argvec
;
2244 while (*cmdrest
!= '\0')
2249 expression_up expr
= parse_exp_1 (&cmd1
, scope
, block_for_pc (scope
), 1);
2250 argvec
.push_back (expr
.release ());
2252 if (*cmdrest
== ',')
2256 agent_expr_up aexpr
;
2258 /* We don't want to stop processing, so catch any errors
2259 that may show up. */
2262 aexpr
= gen_printf (scope
, gdbarch
, 0, 0,
2263 format_start
, format_end
- format_start
,
2264 argvec
.size (), argvec
.data ());
2266 catch (const gdb_exception_error
&ex
)
2268 /* If we got here, it means the command could not be parsed to a valid
2269 bytecode expression and thus can't be evaluated on the target's side.
2270 It's no use iterating through the other commands. */
2273 /* We have a valid agent expression, return it. */
2277 /* Based on location BL, create a list of breakpoint commands to be
2278 passed on to the target. If we have duplicated locations with
2279 different commands, we will add any such to the list. */
2282 build_target_command_list (struct bp_location
*bl
)
2284 struct bp_location
**locp
= NULL
, **loc2p
;
2285 int null_command_or_parse_error
= 0;
2286 int modified
= bl
->needs_update
;
2287 struct bp_location
*loc
;
2289 /* Clear commands left over from a previous insert. */
2290 bl
->target_info
.tcommands
.clear ();
2292 if (!target_can_run_breakpoint_commands ())
2295 /* For now, limit to agent-style dprintf breakpoints. */
2296 if (dprintf_style
!= dprintf_style_agent
)
2299 /* For now, if we have any duplicate location that isn't a dprintf,
2300 don't install the target-side commands, as that would make the
2301 breakpoint not be reported to the core, and we'd lose
2303 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2306 if (is_breakpoint (loc
->owner
)
2307 && loc
->pspace
->num
== bl
->pspace
->num
2308 && loc
->owner
->type
!= bp_dprintf
)
2312 /* Do a first pass to check for locations with no assigned
2313 conditions or conditions that fail to parse to a valid agent expression
2314 bytecode. If any of these happen, then it's no use to send conditions
2315 to the target since this location will always trigger and generate a
2316 response back to GDB. */
2317 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2320 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2324 /* Re-parse the commands since something changed. In that
2325 case we already freed the command bytecodes (see
2326 force_breakpoint_reinsertion). We just
2327 need to parse the command to bytecodes again. */
2329 = parse_cmd_to_aexpr (bl
->address
,
2330 loc
->owner
->extra_string
);
2333 /* If we have a NULL bytecode expression, it means something
2334 went wrong or we have a null command expression. */
2335 if (!loc
->cmd_bytecode
)
2337 null_command_or_parse_error
= 1;
2343 /* If anything failed, then we're not doing target-side commands,
2345 if (null_command_or_parse_error
)
2347 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2350 if (is_breakpoint (loc
->owner
)
2351 && loc
->pspace
->num
== bl
->pspace
->num
)
2353 /* Only go as far as the first NULL bytecode is
2355 if (loc
->cmd_bytecode
== NULL
)
2358 loc
->cmd_bytecode
.reset ();
2363 /* No NULL commands or failed bytecode generation. Build a command list
2364 for this location's address. */
2365 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2368 if (loc
->owner
->extra_string
2369 && is_breakpoint (loc
->owner
)
2370 && loc
->pspace
->num
== bl
->pspace
->num
2371 && loc
->owner
->enable_state
== bp_enabled
2374 /* Add the command to the vector. This will be used later
2375 to send the commands to the target. */
2376 bl
->target_info
.tcommands
.push_back (loc
->cmd_bytecode
.get ());
2380 bl
->target_info
.persist
= 0;
2381 /* Maybe flag this location as persistent. */
2382 if (bl
->owner
->type
== bp_dprintf
&& disconnected_dprintf
)
2383 bl
->target_info
.persist
= 1;
2386 /* Return the kind of breakpoint on address *ADDR. Get the kind
2387 of breakpoint according to ADDR except single-step breakpoint.
2388 Get the kind of single-step breakpoint according to the current
2392 breakpoint_kind (struct bp_location
*bl
, CORE_ADDR
*addr
)
2394 if (bl
->owner
->type
== bp_single_step
)
2396 struct thread_info
*thr
= find_thread_global_id (bl
->owner
->thread
);
2397 struct regcache
*regcache
;
2399 regcache
= get_thread_regcache (thr
);
2401 return gdbarch_breakpoint_kind_from_current_state (bl
->gdbarch
,
2405 return gdbarch_breakpoint_kind_from_pc (bl
->gdbarch
, addr
);
2408 /* Insert a low-level "breakpoint" of some type. BL is the breakpoint
2409 location. Any error messages are printed to TMP_ERROR_STREAM; and
2410 DISABLED_BREAKS, and HW_BREAKPOINT_ERROR are used to report problems.
2411 Returns 0 for success, 1 if the bp_location type is not supported or
2414 NOTE drow/2003-09-09: This routine could be broken down to an
2415 object-style method for each breakpoint or catchpoint type. */
2417 insert_bp_location (struct bp_location
*bl
,
2418 struct ui_file
*tmp_error_stream
,
2419 int *disabled_breaks
,
2420 int *hw_breakpoint_error
,
2421 int *hw_bp_error_explained_already
)
2423 gdb_exception bp_excpt
;
2425 if (!should_be_inserted (bl
) || (bl
->inserted
&& !bl
->needs_update
))
2428 /* Note we don't initialize bl->target_info, as that wipes out
2429 the breakpoint location's shadow_contents if the breakpoint
2430 is still inserted at that location. This in turn breaks
2431 target_read_memory which depends on these buffers when
2432 a memory read is requested at the breakpoint location:
2433 Once the target_info has been wiped, we fail to see that
2434 we have a breakpoint inserted at that address and thus
2435 read the breakpoint instead of returning the data saved in
2436 the breakpoint location's shadow contents. */
2437 bl
->target_info
.reqstd_address
= bl
->address
;
2438 bl
->target_info
.placed_address_space
= bl
->pspace
->aspace
;
2439 bl
->target_info
.length
= bl
->length
;
2441 /* When working with target-side conditions, we must pass all the conditions
2442 for the same breakpoint address down to the target since GDB will not
2443 insert those locations. With a list of breakpoint conditions, the target
2444 can decide when to stop and notify GDB. */
2446 if (is_breakpoint (bl
->owner
))
2448 build_target_condition_list (bl
);
2449 build_target_command_list (bl
);
2450 /* Reset the modification marker. */
2451 bl
->needs_update
= 0;
2454 if (bl
->loc_type
== bp_loc_software_breakpoint
2455 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
2457 if (bl
->owner
->type
!= bp_hardware_breakpoint
)
2459 /* If the explicitly specified breakpoint type
2460 is not hardware breakpoint, check the memory map to see
2461 if the breakpoint address is in read only memory or not.
2463 Two important cases are:
2464 - location type is not hardware breakpoint, memory
2465 is readonly. We change the type of the location to
2466 hardware breakpoint.
2467 - location type is hardware breakpoint, memory is
2468 read-write. This means we've previously made the
2469 location hardware one, but then the memory map changed,
2472 When breakpoints are removed, remove_breakpoints will use
2473 location types we've just set here, the only possible
2474 problem is that memory map has changed during running
2475 program, but it's not going to work anyway with current
2477 struct mem_region
*mr
2478 = lookup_mem_region (bl
->target_info
.reqstd_address
);
2482 if (automatic_hardware_breakpoints
)
2484 enum bp_loc_type new_type
;
2486 if (mr
->attrib
.mode
!= MEM_RW
)
2487 new_type
= bp_loc_hardware_breakpoint
;
2489 new_type
= bp_loc_software_breakpoint
;
2491 if (new_type
!= bl
->loc_type
)
2493 static int said
= 0;
2495 bl
->loc_type
= new_type
;
2498 fprintf_filtered (gdb_stdout
,
2499 _("Note: automatically using "
2500 "hardware breakpoints for "
2501 "read-only addresses.\n"));
2506 else if (bl
->loc_type
== bp_loc_software_breakpoint
2507 && mr
->attrib
.mode
!= MEM_RW
)
2509 fprintf_unfiltered (tmp_error_stream
,
2510 _("Cannot insert breakpoint %d.\n"
2511 "Cannot set software breakpoint "
2512 "at read-only address %s\n"),
2514 paddress (bl
->gdbarch
, bl
->address
));
2520 /* First check to see if we have to handle an overlay. */
2521 if (overlay_debugging
== ovly_off
2522 || bl
->section
== NULL
2523 || !(section_is_overlay (bl
->section
)))
2525 /* No overlay handling: just set the breakpoint. */
2530 val
= bl
->owner
->ops
->insert_location (bl
);
2532 bp_excpt
= gdb_exception
{RETURN_ERROR
, GENERIC_ERROR
};
2534 catch (gdb_exception
&e
)
2536 bp_excpt
= std::move (e
);
2541 /* This breakpoint is in an overlay section.
2542 Shall we set a breakpoint at the LMA? */
2543 if (!overlay_events_enabled
)
2545 /* Yes -- overlay event support is not active,
2546 so we must try to set a breakpoint at the LMA.
2547 This will not work for a hardware breakpoint. */
2548 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
2549 warning (_("hardware breakpoint %d not supported in overlay!"),
2553 CORE_ADDR addr
= overlay_unmapped_address (bl
->address
,
2555 /* Set a software (trap) breakpoint at the LMA. */
2556 bl
->overlay_target_info
= bl
->target_info
;
2557 bl
->overlay_target_info
.reqstd_address
= addr
;
2559 /* No overlay handling: just set the breakpoint. */
2564 bl
->overlay_target_info
.kind
2565 = breakpoint_kind (bl
, &addr
);
2566 bl
->overlay_target_info
.placed_address
= addr
;
2567 val
= target_insert_breakpoint (bl
->gdbarch
,
2568 &bl
->overlay_target_info
);
2571 = gdb_exception
{RETURN_ERROR
, GENERIC_ERROR
};
2573 catch (gdb_exception
&e
)
2575 bp_excpt
= std::move (e
);
2578 if (bp_excpt
.reason
!= 0)
2579 fprintf_unfiltered (tmp_error_stream
,
2580 "Overlay breakpoint %d "
2581 "failed: in ROM?\n",
2585 /* Shall we set a breakpoint at the VMA? */
2586 if (section_is_mapped (bl
->section
))
2588 /* Yes. This overlay section is mapped into memory. */
2593 val
= bl
->owner
->ops
->insert_location (bl
);
2595 bp_excpt
= gdb_exception
{RETURN_ERROR
, GENERIC_ERROR
};
2597 catch (gdb_exception
&e
)
2599 bp_excpt
= std::move (e
);
2604 /* No. This breakpoint will not be inserted.
2605 No error, but do not mark the bp as 'inserted'. */
2610 if (bp_excpt
.reason
!= 0)
2612 /* Can't set the breakpoint. */
2614 /* In some cases, we might not be able to insert a
2615 breakpoint in a shared library that has already been
2616 removed, but we have not yet processed the shlib unload
2617 event. Unfortunately, some targets that implement
2618 breakpoint insertion themselves can't tell why the
2619 breakpoint insertion failed (e.g., the remote target
2620 doesn't define error codes), so we must treat generic
2621 errors as memory errors. */
2622 if (bp_excpt
.reason
== RETURN_ERROR
2623 && (bp_excpt
.error
== GENERIC_ERROR
2624 || bp_excpt
.error
== MEMORY_ERROR
)
2625 && bl
->loc_type
== bp_loc_software_breakpoint
2626 && (solib_name_from_address (bl
->pspace
, bl
->address
)
2627 || shared_objfile_contains_address_p (bl
->pspace
,
2630 /* See also: disable_breakpoints_in_shlibs. */
2631 bl
->shlib_disabled
= 1;
2632 gdb::observers::breakpoint_modified
.notify (bl
->owner
);
2633 if (!*disabled_breaks
)
2635 fprintf_unfiltered (tmp_error_stream
,
2636 "Cannot insert breakpoint %d.\n",
2638 fprintf_unfiltered (tmp_error_stream
,
2639 "Temporarily disabling shared "
2640 "library breakpoints:\n");
2642 *disabled_breaks
= 1;
2643 fprintf_unfiltered (tmp_error_stream
,
2644 "breakpoint #%d\n", bl
->owner
->number
);
2649 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
2651 *hw_breakpoint_error
= 1;
2652 *hw_bp_error_explained_already
= bp_excpt
.message
!= NULL
;
2653 fprintf_unfiltered (tmp_error_stream
,
2654 "Cannot insert hardware breakpoint %d%s",
2656 bp_excpt
.message
? ":" : ".\n");
2657 if (bp_excpt
.message
!= NULL
)
2658 fprintf_unfiltered (tmp_error_stream
, "%s.\n",
2663 if (bp_excpt
.message
== NULL
)
2666 = memory_error_message (TARGET_XFER_E_IO
,
2667 bl
->gdbarch
, bl
->address
);
2669 fprintf_unfiltered (tmp_error_stream
,
2670 "Cannot insert breakpoint %d.\n"
2672 bl
->owner
->number
, message
.c_str ());
2676 fprintf_unfiltered (tmp_error_stream
,
2677 "Cannot insert breakpoint %d: %s\n",
2692 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
2693 /* NOTE drow/2003-09-08: This state only exists for removing
2694 watchpoints. It's not clear that it's necessary... */
2695 && bl
->owner
->disposition
!= disp_del_at_next_stop
)
2699 gdb_assert (bl
->owner
->ops
!= NULL
2700 && bl
->owner
->ops
->insert_location
!= NULL
);
2702 val
= bl
->owner
->ops
->insert_location (bl
);
2704 /* If trying to set a read-watchpoint, and it turns out it's not
2705 supported, try emulating one with an access watchpoint. */
2706 if (val
== 1 && bl
->watchpoint_type
== hw_read
)
2708 struct bp_location
*loc
, **loc_temp
;
2710 /* But don't try to insert it, if there's already another
2711 hw_access location that would be considered a duplicate
2713 ALL_BP_LOCATIONS (loc
, loc_temp
)
2715 && loc
->watchpoint_type
== hw_access
2716 && watchpoint_locations_match (bl
, loc
))
2720 bl
->target_info
= loc
->target_info
;
2721 bl
->watchpoint_type
= hw_access
;
2728 bl
->watchpoint_type
= hw_access
;
2729 val
= bl
->owner
->ops
->insert_location (bl
);
2732 /* Back to the original value. */
2733 bl
->watchpoint_type
= hw_read
;
2737 bl
->inserted
= (val
== 0);
2740 else if (bl
->owner
->type
== bp_catchpoint
)
2744 gdb_assert (bl
->owner
->ops
!= NULL
2745 && bl
->owner
->ops
->insert_location
!= NULL
);
2747 val
= bl
->owner
->ops
->insert_location (bl
);
2750 bl
->owner
->enable_state
= bp_disabled
;
2754 Error inserting catchpoint %d: Your system does not support this type\n\
2755 of catchpoint."), bl
->owner
->number
);
2757 warning (_("Error inserting catchpoint %d."), bl
->owner
->number
);
2760 bl
->inserted
= (val
== 0);
2762 /* We've already printed an error message if there was a problem
2763 inserting this catchpoint, and we've disabled the catchpoint,
2764 so just return success. */
2771 /* This function is called when program space PSPACE is about to be
2772 deleted. It takes care of updating breakpoints to not reference
2776 breakpoint_program_space_exit (struct program_space
*pspace
)
2778 struct breakpoint
*b
, *b_temp
;
2779 struct bp_location
*loc
, **loc_temp
;
2781 /* Remove any breakpoint that was set through this program space. */
2782 ALL_BREAKPOINTS_SAFE (b
, b_temp
)
2784 if (b
->pspace
== pspace
)
2785 delete_breakpoint (b
);
2788 /* Breakpoints set through other program spaces could have locations
2789 bound to PSPACE as well. Remove those. */
2790 ALL_BP_LOCATIONS (loc
, loc_temp
)
2792 struct bp_location
*tmp
;
2794 if (loc
->pspace
== pspace
)
2796 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
2797 if (loc
->owner
->loc
== loc
)
2798 loc
->owner
->loc
= loc
->next
;
2800 for (tmp
= loc
->owner
->loc
; tmp
->next
!= NULL
; tmp
= tmp
->next
)
2801 if (tmp
->next
== loc
)
2803 tmp
->next
= loc
->next
;
2809 /* Now update the global location list to permanently delete the
2810 removed locations above. */
2811 update_global_location_list (UGLL_DONT_INSERT
);
2814 /* Make sure all breakpoints are inserted in inferior.
2815 Throws exception on any error.
2816 A breakpoint that is already inserted won't be inserted
2817 again, so calling this function twice is safe. */
2819 insert_breakpoints (void)
2821 struct breakpoint
*bpt
;
2823 ALL_BREAKPOINTS (bpt
)
2824 if (is_hardware_watchpoint (bpt
))
2826 struct watchpoint
*w
= (struct watchpoint
*) bpt
;
2828 update_watchpoint (w
, 0 /* don't reparse. */);
2831 /* Updating watchpoints creates new locations, so update the global
2832 location list. Explicitly tell ugll to insert locations and
2833 ignore breakpoints_always_inserted_mode. */
2834 update_global_location_list (UGLL_INSERT
);
2837 /* Invoke CALLBACK for each of bp_location. */
2840 iterate_over_bp_locations (walk_bp_location_callback callback
)
2842 struct bp_location
*loc
, **loc_tmp
;
2844 ALL_BP_LOCATIONS (loc
, loc_tmp
)
2846 callback (loc
, NULL
);
2850 /* This is used when we need to synch breakpoint conditions between GDB and the
2851 target. It is the case with deleting and disabling of breakpoints when using
2852 always-inserted mode. */
2855 update_inserted_breakpoint_locations (void)
2857 struct bp_location
*bl
, **blp_tmp
;
2860 int disabled_breaks
= 0;
2861 int hw_breakpoint_error
= 0;
2862 int hw_bp_details_reported
= 0;
2864 string_file tmp_error_stream
;
2866 /* Explicitly mark the warning -- this will only be printed if
2867 there was an error. */
2868 tmp_error_stream
.puts ("Warning:\n");
2870 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
2872 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2874 /* We only want to update software breakpoints and hardware
2876 if (!is_breakpoint (bl
->owner
))
2879 /* We only want to update locations that are already inserted
2880 and need updating. This is to avoid unwanted insertion during
2881 deletion of breakpoints. */
2882 if (!bl
->inserted
|| !bl
->needs_update
)
2885 switch_to_program_space_and_thread (bl
->pspace
);
2887 /* For targets that support global breakpoints, there's no need
2888 to select an inferior to insert breakpoint to. In fact, even
2889 if we aren't attached to any process yet, we should still
2890 insert breakpoints. */
2891 if (!gdbarch_has_global_breakpoints (target_gdbarch ())
2892 && (inferior_ptid
== null_ptid
|| !target_has_execution
))
2895 val
= insert_bp_location (bl
, &tmp_error_stream
, &disabled_breaks
,
2896 &hw_breakpoint_error
, &hw_bp_details_reported
);
2903 target_terminal::ours_for_output ();
2904 error_stream (tmp_error_stream
);
2908 /* Used when starting or continuing the program. */
2911 insert_breakpoint_locations (void)
2913 struct breakpoint
*bpt
;
2914 struct bp_location
*bl
, **blp_tmp
;
2917 int disabled_breaks
= 0;
2918 int hw_breakpoint_error
= 0;
2919 int hw_bp_error_explained_already
= 0;
2921 string_file tmp_error_stream
;
2923 /* Explicitly mark the warning -- this will only be printed if
2924 there was an error. */
2925 tmp_error_stream
.puts ("Warning:\n");
2927 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
2929 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2931 if (!should_be_inserted (bl
) || (bl
->inserted
&& !bl
->needs_update
))
2934 /* There is no point inserting thread-specific breakpoints if
2935 the thread no longer exists. ALL_BP_LOCATIONS bp_location
2936 has BL->OWNER always non-NULL. */
2937 if (bl
->owner
->thread
!= -1
2938 && !valid_global_thread_id (bl
->owner
->thread
))
2941 switch_to_program_space_and_thread (bl
->pspace
);
2943 /* For targets that support global breakpoints, there's no need
2944 to select an inferior to insert breakpoint to. In fact, even
2945 if we aren't attached to any process yet, we should still
2946 insert breakpoints. */
2947 if (!gdbarch_has_global_breakpoints (target_gdbarch ())
2948 && (inferior_ptid
== null_ptid
|| !target_has_execution
))
2951 val
= insert_bp_location (bl
, &tmp_error_stream
, &disabled_breaks
,
2952 &hw_breakpoint_error
, &hw_bp_error_explained_already
);
2957 /* If we failed to insert all locations of a watchpoint, remove
2958 them, as half-inserted watchpoint is of limited use. */
2959 ALL_BREAKPOINTS (bpt
)
2961 int some_failed
= 0;
2962 struct bp_location
*loc
;
2964 if (!is_hardware_watchpoint (bpt
))
2967 if (!breakpoint_enabled (bpt
))
2970 if (bpt
->disposition
== disp_del_at_next_stop
)
2973 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
2974 if (!loc
->inserted
&& should_be_inserted (loc
))
2981 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
2983 remove_breakpoint (loc
);
2985 hw_breakpoint_error
= 1;
2986 tmp_error_stream
.printf ("Could not insert "
2987 "hardware watchpoint %d.\n",
2995 /* If a hardware breakpoint or watchpoint was inserted, add a
2996 message about possibly exhausted resources. */
2997 if (hw_breakpoint_error
&& !hw_bp_error_explained_already
)
2999 tmp_error_stream
.printf ("Could not insert hardware breakpoints:\n\
3000 You may have requested too many hardware breakpoints/watchpoints.\n");
3002 target_terminal::ours_for_output ();
3003 error_stream (tmp_error_stream
);
3007 /* Used when the program stops.
3008 Returns zero if successful, or non-zero if there was a problem
3009 removing a breakpoint location. */
3012 remove_breakpoints (void)
3014 struct bp_location
*bl
, **blp_tmp
;
3017 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3019 if (bl
->inserted
&& !is_tracepoint (bl
->owner
))
3020 val
|= remove_breakpoint (bl
);
3025 /* When a thread exits, remove breakpoints that are related to
3029 remove_threaded_breakpoints (struct thread_info
*tp
, int silent
)
3031 struct breakpoint
*b
, *b_tmp
;
3033 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
3035 if (b
->thread
== tp
->global_num
&& user_breakpoint_p (b
))
3037 b
->disposition
= disp_del_at_next_stop
;
3039 printf_filtered (_("\
3040 Thread-specific breakpoint %d deleted - thread %s no longer in the thread list.\n"),
3041 b
->number
, print_thread_id (tp
));
3043 /* Hide it from the user. */
3049 /* See breakpoint.h. */
3052 remove_breakpoints_inf (inferior
*inf
)
3054 struct bp_location
*bl
, **blp_tmp
;
3057 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3059 if (bl
->pspace
!= inf
->pspace
)
3062 if (bl
->inserted
&& !bl
->target_info
.persist
)
3064 val
= remove_breakpoint (bl
);
3071 static int internal_breakpoint_number
= -1;
3073 /* Set the breakpoint number of B, depending on the value of INTERNAL.
3074 If INTERNAL is non-zero, the breakpoint number will be populated
3075 from internal_breakpoint_number and that variable decremented.
3076 Otherwise the breakpoint number will be populated from
3077 breakpoint_count and that value incremented. Internal breakpoints
3078 do not set the internal var bpnum. */
3080 set_breakpoint_number (int internal
, struct breakpoint
*b
)
3083 b
->number
= internal_breakpoint_number
--;
3086 set_breakpoint_count (breakpoint_count
+ 1);
3087 b
->number
= breakpoint_count
;
3091 static struct breakpoint
*
3092 create_internal_breakpoint (struct gdbarch
*gdbarch
,
3093 CORE_ADDR address
, enum bptype type
,
3094 const struct breakpoint_ops
*ops
)
3096 symtab_and_line sal
;
3098 sal
.section
= find_pc_overlay (sal
.pc
);
3099 sal
.pspace
= current_program_space
;
3101 breakpoint
*b
= set_raw_breakpoint (gdbarch
, sal
, type
, ops
);
3102 b
->number
= internal_breakpoint_number
--;
3103 b
->disposition
= disp_donttouch
;
3108 static const char *const longjmp_names
[] =
3110 "longjmp", "_longjmp", "siglongjmp", "_siglongjmp"
3112 #define NUM_LONGJMP_NAMES ARRAY_SIZE(longjmp_names)
3114 /* Per-objfile data private to breakpoint.c. */
3115 struct breakpoint_objfile_data
3117 /* Minimal symbol for "_ovly_debug_event" (if any). */
3118 struct bound_minimal_symbol overlay_msym
{};
3120 /* Minimal symbol(s) for "longjmp", "siglongjmp", etc. (if any). */
3121 struct bound_minimal_symbol longjmp_msym
[NUM_LONGJMP_NAMES
] {};
3123 /* True if we have looked for longjmp probes. */
3124 int longjmp_searched
= 0;
3126 /* SystemTap probe points for longjmp (if any). These are non-owning
3128 std::vector
<probe
*> longjmp_probes
;
3130 /* Minimal symbol for "std::terminate()" (if any). */
3131 struct bound_minimal_symbol terminate_msym
{};
3133 /* Minimal symbol for "_Unwind_DebugHook" (if any). */
3134 struct bound_minimal_symbol exception_msym
{};
3136 /* True if we have looked for exception probes. */
3137 int exception_searched
= 0;
3139 /* SystemTap probe points for unwinding (if any). These are non-owning
3141 std::vector
<probe
*> exception_probes
;
3144 static const struct objfile_key
<breakpoint_objfile_data
>
3145 breakpoint_objfile_key
;
3147 /* Minimal symbol not found sentinel. */
3148 static struct minimal_symbol msym_not_found
;
3150 /* Returns TRUE if MSYM point to the "not found" sentinel. */
3153 msym_not_found_p (const struct minimal_symbol
*msym
)
3155 return msym
== &msym_not_found
;
3158 /* Return per-objfile data needed by breakpoint.c.
3159 Allocate the data if necessary. */
3161 static struct breakpoint_objfile_data
*
3162 get_breakpoint_objfile_data (struct objfile
*objfile
)
3164 struct breakpoint_objfile_data
*bp_objfile_data
;
3166 bp_objfile_data
= breakpoint_objfile_key
.get (objfile
);
3167 if (bp_objfile_data
== NULL
)
3168 bp_objfile_data
= breakpoint_objfile_key
.emplace (objfile
);
3169 return bp_objfile_data
;
3173 create_overlay_event_breakpoint (void)
3175 const char *const func_name
= "_ovly_debug_event";
3177 for (objfile
*objfile
: current_program_space
->objfiles ())
3179 struct breakpoint
*b
;
3180 struct breakpoint_objfile_data
*bp_objfile_data
;
3182 struct explicit_location explicit_loc
;
3184 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3186 if (msym_not_found_p (bp_objfile_data
->overlay_msym
.minsym
))
3189 if (bp_objfile_data
->overlay_msym
.minsym
== NULL
)
3191 struct bound_minimal_symbol m
;
3193 m
= lookup_minimal_symbol_text (func_name
, objfile
);
3194 if (m
.minsym
== NULL
)
3196 /* Avoid future lookups in this objfile. */
3197 bp_objfile_data
->overlay_msym
.minsym
= &msym_not_found
;
3200 bp_objfile_data
->overlay_msym
= m
;
3203 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->overlay_msym
);
3204 b
= create_internal_breakpoint (objfile
->arch (), addr
,
3206 &internal_breakpoint_ops
);
3207 initialize_explicit_location (&explicit_loc
);
3208 explicit_loc
.function_name
= ASTRDUP (func_name
);
3209 b
->location
= new_explicit_location (&explicit_loc
);
3211 if (overlay_debugging
== ovly_auto
)
3213 b
->enable_state
= bp_enabled
;
3214 overlay_events_enabled
= 1;
3218 b
->enable_state
= bp_disabled
;
3219 overlay_events_enabled
= 0;
3225 create_longjmp_master_breakpoint (void)
3227 struct program_space
*pspace
;
3229 scoped_restore_current_program_space restore_pspace
;
3231 ALL_PSPACES (pspace
)
3233 set_current_program_space (pspace
);
3235 for (objfile
*objfile
: current_program_space
->objfiles ())
3238 struct gdbarch
*gdbarch
;
3239 struct breakpoint_objfile_data
*bp_objfile_data
;
3241 gdbarch
= objfile
->arch ();
3243 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3245 if (!bp_objfile_data
->longjmp_searched
)
3247 std::vector
<probe
*> ret
3248 = find_probes_in_objfile (objfile
, "libc", "longjmp");
3252 /* We are only interested in checking one element. */
3255 if (!p
->can_evaluate_arguments ())
3257 /* We cannot use the probe interface here, because it does
3258 not know how to evaluate arguments. */
3262 bp_objfile_data
->longjmp_probes
= ret
;
3263 bp_objfile_data
->longjmp_searched
= 1;
3266 if (!bp_objfile_data
->longjmp_probes
.empty ())
3268 for (probe
*p
: bp_objfile_data
->longjmp_probes
)
3270 struct breakpoint
*b
;
3272 b
= create_internal_breakpoint (gdbarch
,
3273 p
->get_relocated_address (objfile
),
3275 &internal_breakpoint_ops
);
3276 b
->location
= new_probe_location ("-probe-stap libc:longjmp");
3277 b
->enable_state
= bp_disabled
;
3283 if (!gdbarch_get_longjmp_target_p (gdbarch
))
3286 for (i
= 0; i
< NUM_LONGJMP_NAMES
; i
++)
3288 struct breakpoint
*b
;
3289 const char *func_name
;
3291 struct explicit_location explicit_loc
;
3293 if (msym_not_found_p (bp_objfile_data
->longjmp_msym
[i
].minsym
))
3296 func_name
= longjmp_names
[i
];
3297 if (bp_objfile_data
->longjmp_msym
[i
].minsym
== NULL
)
3299 struct bound_minimal_symbol m
;
3301 m
= lookup_minimal_symbol_text (func_name
, objfile
);
3302 if (m
.minsym
== NULL
)
3304 /* Prevent future lookups in this objfile. */
3305 bp_objfile_data
->longjmp_msym
[i
].minsym
= &msym_not_found
;
3308 bp_objfile_data
->longjmp_msym
[i
] = m
;
3311 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->longjmp_msym
[i
]);
3312 b
= create_internal_breakpoint (gdbarch
, addr
, bp_longjmp_master
,
3313 &internal_breakpoint_ops
);
3314 initialize_explicit_location (&explicit_loc
);
3315 explicit_loc
.function_name
= ASTRDUP (func_name
);
3316 b
->location
= new_explicit_location (&explicit_loc
);
3317 b
->enable_state
= bp_disabled
;
3323 /* Create a master std::terminate breakpoint. */
3325 create_std_terminate_master_breakpoint (void)
3327 struct program_space
*pspace
;
3328 const char *const func_name
= "std::terminate()";
3330 scoped_restore_current_program_space restore_pspace
;
3332 ALL_PSPACES (pspace
)
3336 set_current_program_space (pspace
);
3338 for (objfile
*objfile
: current_program_space
->objfiles ())
3340 struct breakpoint
*b
;
3341 struct breakpoint_objfile_data
*bp_objfile_data
;
3342 struct explicit_location explicit_loc
;
3344 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3346 if (msym_not_found_p (bp_objfile_data
->terminate_msym
.minsym
))
3349 if (bp_objfile_data
->terminate_msym
.minsym
== NULL
)
3351 struct bound_minimal_symbol m
;
3353 m
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
3354 if (m
.minsym
== NULL
|| (MSYMBOL_TYPE (m
.minsym
) != mst_text
3355 && MSYMBOL_TYPE (m
.minsym
) != mst_file_text
))
3357 /* Prevent future lookups in this objfile. */
3358 bp_objfile_data
->terminate_msym
.minsym
= &msym_not_found
;
3361 bp_objfile_data
->terminate_msym
= m
;
3364 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->terminate_msym
);
3365 b
= create_internal_breakpoint (objfile
->arch (), addr
,
3366 bp_std_terminate_master
,
3367 &internal_breakpoint_ops
);
3368 initialize_explicit_location (&explicit_loc
);
3369 explicit_loc
.function_name
= ASTRDUP (func_name
);
3370 b
->location
= new_explicit_location (&explicit_loc
);
3371 b
->enable_state
= bp_disabled
;
3376 /* Install a master breakpoint on the unwinder's debug hook. */
3379 create_exception_master_breakpoint (void)
3381 const char *const func_name
= "_Unwind_DebugHook";
3383 for (objfile
*objfile
: current_program_space
->objfiles ())
3385 struct breakpoint
*b
;
3386 struct gdbarch
*gdbarch
;
3387 struct breakpoint_objfile_data
*bp_objfile_data
;
3389 struct explicit_location explicit_loc
;
3391 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3393 /* We prefer the SystemTap probe point if it exists. */
3394 if (!bp_objfile_data
->exception_searched
)
3396 std::vector
<probe
*> ret
3397 = find_probes_in_objfile (objfile
, "libgcc", "unwind");
3401 /* We are only interested in checking one element. */
3404 if (!p
->can_evaluate_arguments ())
3406 /* We cannot use the probe interface here, because it does
3407 not know how to evaluate arguments. */
3411 bp_objfile_data
->exception_probes
= ret
;
3412 bp_objfile_data
->exception_searched
= 1;
3415 if (!bp_objfile_data
->exception_probes
.empty ())
3417 gdbarch
= objfile
->arch ();
3419 for (probe
*p
: bp_objfile_data
->exception_probes
)
3421 b
= create_internal_breakpoint (gdbarch
,
3422 p
->get_relocated_address (objfile
),
3423 bp_exception_master
,
3424 &internal_breakpoint_ops
);
3425 b
->location
= new_probe_location ("-probe-stap libgcc:unwind");
3426 b
->enable_state
= bp_disabled
;
3432 /* Otherwise, try the hook function. */
3434 if (msym_not_found_p (bp_objfile_data
->exception_msym
.minsym
))
3437 gdbarch
= objfile
->arch ();
3439 if (bp_objfile_data
->exception_msym
.minsym
== NULL
)
3441 struct bound_minimal_symbol debug_hook
;
3443 debug_hook
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
3444 if (debug_hook
.minsym
== NULL
)
3446 bp_objfile_data
->exception_msym
.minsym
= &msym_not_found
;
3450 bp_objfile_data
->exception_msym
= debug_hook
;
3453 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->exception_msym
);
3454 addr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, addr
,
3455 current_top_target ());
3456 b
= create_internal_breakpoint (gdbarch
, addr
, bp_exception_master
,
3457 &internal_breakpoint_ops
);
3458 initialize_explicit_location (&explicit_loc
);
3459 explicit_loc
.function_name
= ASTRDUP (func_name
);
3460 b
->location
= new_explicit_location (&explicit_loc
);
3461 b
->enable_state
= bp_disabled
;
3465 /* Does B have a location spec? */
3468 breakpoint_event_location_empty_p (const struct breakpoint
*b
)
3470 return b
->location
!= NULL
&& event_location_empty_p (b
->location
.get ());
3474 update_breakpoints_after_exec (void)
3476 struct breakpoint
*b
, *b_tmp
;
3477 struct bp_location
*bploc
, **bplocp_tmp
;
3479 /* We're about to delete breakpoints from GDB's lists. If the
3480 INSERTED flag is true, GDB will try to lift the breakpoints by
3481 writing the breakpoints' "shadow contents" back into memory. The
3482 "shadow contents" are NOT valid after an exec, so GDB should not
3483 do that. Instead, the target is responsible from marking
3484 breakpoints out as soon as it detects an exec. We don't do that
3485 here instead, because there may be other attempts to delete
3486 breakpoints after detecting an exec and before reaching here. */
3487 ALL_BP_LOCATIONS (bploc
, bplocp_tmp
)
3488 if (bploc
->pspace
== current_program_space
)
3489 gdb_assert (!bploc
->inserted
);
3491 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
3493 if (b
->pspace
!= current_program_space
)
3496 /* Solib breakpoints must be explicitly reset after an exec(). */
3497 if (b
->type
== bp_shlib_event
)
3499 delete_breakpoint (b
);
3503 /* JIT breakpoints must be explicitly reset after an exec(). */
3504 if (b
->type
== bp_jit_event
)
3506 delete_breakpoint (b
);
3510 /* Thread event breakpoints must be set anew after an exec(),
3511 as must overlay event and longjmp master breakpoints. */
3512 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
3513 || b
->type
== bp_longjmp_master
|| b
->type
== bp_std_terminate_master
3514 || b
->type
== bp_exception_master
)
3516 delete_breakpoint (b
);
3520 /* Step-resume breakpoints are meaningless after an exec(). */
3521 if (b
->type
== bp_step_resume
|| b
->type
== bp_hp_step_resume
)
3523 delete_breakpoint (b
);
3527 /* Just like single-step breakpoints. */
3528 if (b
->type
== bp_single_step
)
3530 delete_breakpoint (b
);
3534 /* Longjmp and longjmp-resume breakpoints are also meaningless
3536 if (b
->type
== bp_longjmp
|| b
->type
== bp_longjmp_resume
3537 || b
->type
== bp_longjmp_call_dummy
3538 || b
->type
== bp_exception
|| b
->type
== bp_exception_resume
)
3540 delete_breakpoint (b
);
3544 if (b
->type
== bp_catchpoint
)
3546 /* For now, none of the bp_catchpoint breakpoints need to
3547 do anything at this point. In the future, if some of
3548 the catchpoints need to something, we will need to add
3549 a new method, and call this method from here. */
3553 /* bp_finish is a special case. The only way we ought to be able
3554 to see one of these when an exec() has happened, is if the user
3555 caught a vfork, and then said "finish". Ordinarily a finish just
3556 carries them to the call-site of the current callee, by setting
3557 a temporary bp there and resuming. But in this case, the finish
3558 will carry them entirely through the vfork & exec.
3560 We don't want to allow a bp_finish to remain inserted now. But
3561 we can't safely delete it, 'cause finish_command has a handle to
3562 the bp on a bpstat, and will later want to delete it. There's a
3563 chance (and I've seen it happen) that if we delete the bp_finish
3564 here, that its storage will get reused by the time finish_command
3565 gets 'round to deleting the "use to be a bp_finish" breakpoint.
3566 We really must allow finish_command to delete a bp_finish.
3568 In the absence of a general solution for the "how do we know
3569 it's safe to delete something others may have handles to?"
3570 problem, what we'll do here is just uninsert the bp_finish, and
3571 let finish_command delete it.
3573 (We know the bp_finish is "doomed" in the sense that it's
3574 momentary, and will be deleted as soon as finish_command sees
3575 the inferior stopped. So it doesn't matter that the bp's
3576 address is probably bogus in the new a.out, unlike e.g., the
3577 solib breakpoints.) */
3579 if (b
->type
== bp_finish
)
3584 /* Without a symbolic address, we have little hope of the
3585 pre-exec() address meaning the same thing in the post-exec()
3587 if (breakpoint_event_location_empty_p (b
))
3589 delete_breakpoint (b
);
3596 detach_breakpoints (ptid_t ptid
)
3598 struct bp_location
*bl
, **blp_tmp
;
3600 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
3601 struct inferior
*inf
= current_inferior ();
3603 if (ptid
.pid () == inferior_ptid
.pid ())
3604 error (_("Cannot detach breakpoints of inferior_ptid"));
3606 /* Set inferior_ptid; remove_breakpoint_1 uses this global. */
3607 inferior_ptid
= ptid
;
3608 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3610 if (bl
->pspace
!= inf
->pspace
)
3613 /* This function must physically remove breakpoints locations
3614 from the specified ptid, without modifying the breakpoint
3615 package's state. Locations of type bp_loc_other are only
3616 maintained at GDB side. So, there is no need to remove
3617 these bp_loc_other locations. Moreover, removing these
3618 would modify the breakpoint package's state. */
3619 if (bl
->loc_type
== bp_loc_other
)
3623 val
|= remove_breakpoint_1 (bl
, DETACH_BREAKPOINT
);
3629 /* Remove the breakpoint location BL from the current address space.
3630 Note that this is used to detach breakpoints from a child fork.
3631 When we get here, the child isn't in the inferior list, and neither
3632 do we have objects to represent its address space --- we should
3633 *not* look at bl->pspace->aspace here. */
3636 remove_breakpoint_1 (struct bp_location
*bl
, enum remove_bp_reason reason
)
3640 /* BL is never in moribund_locations by our callers. */
3641 gdb_assert (bl
->owner
!= NULL
);
3643 /* The type of none suggests that owner is actually deleted.
3644 This should not ever happen. */
3645 gdb_assert (bl
->owner
->type
!= bp_none
);
3647 if (bl
->loc_type
== bp_loc_software_breakpoint
3648 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
3650 /* "Normal" instruction breakpoint: either the standard
3651 trap-instruction bp (bp_breakpoint), or a
3652 bp_hardware_breakpoint. */
3654 /* First check to see if we have to handle an overlay. */
3655 if (overlay_debugging
== ovly_off
3656 || bl
->section
== NULL
3657 || !(section_is_overlay (bl
->section
)))
3659 /* No overlay handling: just remove the breakpoint. */
3661 /* If we're trying to uninsert a memory breakpoint that we
3662 know is set in a dynamic object that is marked
3663 shlib_disabled, then either the dynamic object was
3664 removed with "remove-symbol-file" or with
3665 "nosharedlibrary". In the former case, we don't know
3666 whether another dynamic object might have loaded over the
3667 breakpoint's address -- the user might well let us know
3668 about it next with add-symbol-file (the whole point of
3669 add-symbol-file is letting the user manually maintain a
3670 list of dynamically loaded objects). If we have the
3671 breakpoint's shadow memory, that is, this is a software
3672 breakpoint managed by GDB, check whether the breakpoint
3673 is still inserted in memory, to avoid overwriting wrong
3674 code with stale saved shadow contents. Note that HW
3675 breakpoints don't have shadow memory, as they're
3676 implemented using a mechanism that is not dependent on
3677 being able to modify the target's memory, and as such
3678 they should always be removed. */
3679 if (bl
->shlib_disabled
3680 && bl
->target_info
.shadow_len
!= 0
3681 && !memory_validate_breakpoint (bl
->gdbarch
, &bl
->target_info
))
3684 val
= bl
->owner
->ops
->remove_location (bl
, reason
);
3688 /* This breakpoint is in an overlay section.
3689 Did we set a breakpoint at the LMA? */
3690 if (!overlay_events_enabled
)
3692 /* Yes -- overlay event support is not active, so we
3693 should have set a breakpoint at the LMA. Remove it.
3695 /* Ignore any failures: if the LMA is in ROM, we will
3696 have already warned when we failed to insert it. */
3697 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
3698 target_remove_hw_breakpoint (bl
->gdbarch
,
3699 &bl
->overlay_target_info
);
3701 target_remove_breakpoint (bl
->gdbarch
,
3702 &bl
->overlay_target_info
,
3705 /* Did we set a breakpoint at the VMA?
3706 If so, we will have marked the breakpoint 'inserted'. */
3709 /* Yes -- remove it. Previously we did not bother to
3710 remove the breakpoint if the section had been
3711 unmapped, but let's not rely on that being safe. We
3712 don't know what the overlay manager might do. */
3714 /* However, we should remove *software* breakpoints only
3715 if the section is still mapped, or else we overwrite
3716 wrong code with the saved shadow contents. */
3717 if (bl
->loc_type
== bp_loc_hardware_breakpoint
3718 || section_is_mapped (bl
->section
))
3719 val
= bl
->owner
->ops
->remove_location (bl
, reason
);
3725 /* No -- not inserted, so no need to remove. No error. */
3730 /* In some cases, we might not be able to remove a breakpoint in
3731 a shared library that has already been removed, but we have
3732 not yet processed the shlib unload event. Similarly for an
3733 unloaded add-symbol-file object - the user might not yet have
3734 had the chance to remove-symbol-file it. shlib_disabled will
3735 be set if the library/object has already been removed, but
3736 the breakpoint hasn't been uninserted yet, e.g., after
3737 "nosharedlibrary" or "remove-symbol-file" with breakpoints
3738 always-inserted mode. */
3740 && (bl
->loc_type
== bp_loc_software_breakpoint
3741 && (bl
->shlib_disabled
3742 || solib_name_from_address (bl
->pspace
, bl
->address
)
3743 || shared_objfile_contains_address_p (bl
->pspace
,
3749 bl
->inserted
= (reason
== DETACH_BREAKPOINT
);
3751 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
)
3753 gdb_assert (bl
->owner
->ops
!= NULL
3754 && bl
->owner
->ops
->remove_location
!= NULL
);
3756 bl
->inserted
= (reason
== DETACH_BREAKPOINT
);
3757 bl
->owner
->ops
->remove_location (bl
, reason
);
3759 /* Failure to remove any of the hardware watchpoints comes here. */
3760 if (reason
== REMOVE_BREAKPOINT
&& bl
->inserted
)
3761 warning (_("Could not remove hardware watchpoint %d."),
3764 else if (bl
->owner
->type
== bp_catchpoint
3765 && breakpoint_enabled (bl
->owner
)
3768 gdb_assert (bl
->owner
->ops
!= NULL
3769 && bl
->owner
->ops
->remove_location
!= NULL
);
3771 val
= bl
->owner
->ops
->remove_location (bl
, reason
);
3775 bl
->inserted
= (reason
== DETACH_BREAKPOINT
);
3782 remove_breakpoint (struct bp_location
*bl
)
3784 /* BL is never in moribund_locations by our callers. */
3785 gdb_assert (bl
->owner
!= NULL
);
3787 /* The type of none suggests that owner is actually deleted.
3788 This should not ever happen. */
3789 gdb_assert (bl
->owner
->type
!= bp_none
);
3791 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
3793 switch_to_program_space_and_thread (bl
->pspace
);
3795 return remove_breakpoint_1 (bl
, REMOVE_BREAKPOINT
);
3798 /* Clear the "inserted" flag in all breakpoints. */
3801 mark_breakpoints_out (void)
3803 struct bp_location
*bl
, **blp_tmp
;
3805 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3806 if (bl
->pspace
== current_program_space
)
3810 /* Clear the "inserted" flag in all breakpoints and delete any
3811 breakpoints which should go away between runs of the program.
3813 Plus other such housekeeping that has to be done for breakpoints
3816 Note: this function gets called at the end of a run (by
3817 generic_mourn_inferior) and when a run begins (by
3818 init_wait_for_inferior). */
3823 breakpoint_init_inferior (enum inf_context context
)
3825 struct breakpoint
*b
, *b_tmp
;
3826 struct program_space
*pspace
= current_program_space
;
3828 /* If breakpoint locations are shared across processes, then there's
3830 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
3833 mark_breakpoints_out ();
3835 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
3837 if (b
->loc
&& b
->loc
->pspace
!= pspace
)
3843 case bp_longjmp_call_dummy
:
3845 /* If the call dummy breakpoint is at the entry point it will
3846 cause problems when the inferior is rerun, so we better get
3849 case bp_watchpoint_scope
:
3851 /* Also get rid of scope breakpoints. */
3853 case bp_shlib_event
:
3855 /* Also remove solib event breakpoints. Their addresses may
3856 have changed since the last time we ran the program.
3857 Actually we may now be debugging against different target;
3858 and so the solib backend that installed this breakpoint may
3859 not be used in by the target. E.g.,
3861 (gdb) file prog-linux
3862 (gdb) run # native linux target
3865 (gdb) file prog-win.exe
3866 (gdb) tar rem :9999 # remote Windows gdbserver.
3869 case bp_step_resume
:
3871 /* Also remove step-resume breakpoints. */
3873 case bp_single_step
:
3875 /* Also remove single-step breakpoints. */
3877 delete_breakpoint (b
);
3881 case bp_hardware_watchpoint
:
3882 case bp_read_watchpoint
:
3883 case bp_access_watchpoint
:
3885 struct watchpoint
*w
= (struct watchpoint
*) b
;
3887 /* Likewise for watchpoints on local expressions. */
3888 if (w
->exp_valid_block
!= NULL
)
3889 delete_breakpoint (b
);
3892 /* Get rid of existing locations, which are no longer
3893 valid. New ones will be created in
3894 update_watchpoint, when the inferior is restarted.
3895 The next update_global_location_list call will
3896 garbage collect them. */
3899 if (context
== inf_starting
)
3901 /* Reset val field to force reread of starting value in
3902 insert_breakpoints. */
3903 w
->val
.reset (nullptr);
3904 w
->val_valid
= false;
3914 /* Get rid of the moribund locations. */
3915 for (bp_location
*bl
: moribund_locations
)
3916 decref_bp_location (&bl
);
3917 moribund_locations
.clear ();
3920 /* These functions concern about actual breakpoints inserted in the
3921 target --- to e.g. check if we need to do decr_pc adjustment or if
3922 we need to hop over the bkpt --- so we check for address space
3923 match, not program space. */
3925 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
3926 exists at PC. It returns ordinary_breakpoint_here if it's an
3927 ordinary breakpoint, or permanent_breakpoint_here if it's a
3928 permanent breakpoint.
3929 - When continuing from a location with an ordinary breakpoint, we
3930 actually single step once before calling insert_breakpoints.
3931 - When continuing from a location with a permanent breakpoint, we
3932 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
3933 the target, to advance the PC past the breakpoint. */
3935 enum breakpoint_here
3936 breakpoint_here_p (const address_space
*aspace
, CORE_ADDR pc
)
3938 struct bp_location
*bl
, **blp_tmp
;
3939 int any_breakpoint_here
= 0;
3941 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3943 if (bl
->loc_type
!= bp_loc_software_breakpoint
3944 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
3947 /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
3948 if ((breakpoint_enabled (bl
->owner
)
3950 && breakpoint_location_address_match (bl
, aspace
, pc
))
3952 if (overlay_debugging
3953 && section_is_overlay (bl
->section
)
3954 && !section_is_mapped (bl
->section
))
3955 continue; /* unmapped overlay -- can't be a match */
3956 else if (bl
->permanent
)
3957 return permanent_breakpoint_here
;
3959 any_breakpoint_here
= 1;
3963 return any_breakpoint_here
? ordinary_breakpoint_here
: no_breakpoint_here
;
3966 /* See breakpoint.h. */
3969 breakpoint_in_range_p (const address_space
*aspace
,
3970 CORE_ADDR addr
, ULONGEST len
)
3972 struct bp_location
*bl
, **blp_tmp
;
3974 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3976 if (bl
->loc_type
!= bp_loc_software_breakpoint
3977 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
3980 if ((breakpoint_enabled (bl
->owner
)
3982 && breakpoint_location_address_range_overlap (bl
, aspace
,
3985 if (overlay_debugging
3986 && section_is_overlay (bl
->section
)
3987 && !section_is_mapped (bl
->section
))
3989 /* Unmapped overlay -- can't be a match. */
4000 /* Return true if there's a moribund breakpoint at PC. */
4003 moribund_breakpoint_here_p (const address_space
*aspace
, CORE_ADDR pc
)
4005 for (bp_location
*loc
: moribund_locations
)
4006 if (breakpoint_location_address_match (loc
, aspace
, pc
))
4012 /* Returns non-zero iff BL is inserted at PC, in address space
4016 bp_location_inserted_here_p (struct bp_location
*bl
,
4017 const address_space
*aspace
, CORE_ADDR pc
)
4020 && breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
4023 if (overlay_debugging
4024 && section_is_overlay (bl
->section
)
4025 && !section_is_mapped (bl
->section
))
4026 return 0; /* unmapped overlay -- can't be a match */
4033 /* Returns non-zero iff there's a breakpoint inserted at PC. */
4036 breakpoint_inserted_here_p (const address_space
*aspace
, CORE_ADDR pc
)
4038 struct bp_location
**blp
, **blp_tmp
= NULL
;
4040 ALL_BP_LOCATIONS_AT_ADDR (blp
, blp_tmp
, pc
)
4042 struct bp_location
*bl
= *blp
;
4044 if (bl
->loc_type
!= bp_loc_software_breakpoint
4045 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4048 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4054 /* This function returns non-zero iff there is a software breakpoint
4058 software_breakpoint_inserted_here_p (const address_space
*aspace
,
4061 struct bp_location
**blp
, **blp_tmp
= NULL
;
4063 ALL_BP_LOCATIONS_AT_ADDR (blp
, blp_tmp
, pc
)
4065 struct bp_location
*bl
= *blp
;
4067 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
4070 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4077 /* See breakpoint.h. */
4080 hardware_breakpoint_inserted_here_p (const address_space
*aspace
,
4083 struct bp_location
**blp
, **blp_tmp
= NULL
;
4085 ALL_BP_LOCATIONS_AT_ADDR (blp
, blp_tmp
, pc
)
4087 struct bp_location
*bl
= *blp
;
4089 if (bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4092 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4100 hardware_watchpoint_inserted_in_range (const address_space
*aspace
,
4101 CORE_ADDR addr
, ULONGEST len
)
4103 struct breakpoint
*bpt
;
4105 ALL_BREAKPOINTS (bpt
)
4107 struct bp_location
*loc
;
4109 if (bpt
->type
!= bp_hardware_watchpoint
4110 && bpt
->type
!= bp_access_watchpoint
)
4113 if (!breakpoint_enabled (bpt
))
4116 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
4117 if (loc
->pspace
->aspace
== aspace
&& loc
->inserted
)
4121 /* Check for intersection. */
4122 l
= std::max
<CORE_ADDR
> (loc
->address
, addr
);
4123 h
= std::min
<CORE_ADDR
> (loc
->address
+ loc
->length
, addr
+ len
);
4131 /* See breakpoint.h. */
4134 is_catchpoint (struct breakpoint
*b
)
4136 return (b
->type
== bp_catchpoint
);
4139 /* Frees any storage that is part of a bpstat. Does not walk the
4142 bpstats::~bpstats ()
4144 if (bp_location_at
!= NULL
)
4145 decref_bp_location (&bp_location_at
);
4148 /* Clear a bpstat so that it says we are not at any breakpoint.
4149 Also free any storage that is part of a bpstat. */
4152 bpstat_clear (bpstat
*bsp
)
4169 bpstats::bpstats (const bpstats
&other
)
4171 bp_location_at (other
.bp_location_at
),
4172 breakpoint_at (other
.breakpoint_at
),
4173 commands (other
.commands
),
4174 print (other
.print
),
4176 print_it (other
.print_it
)
4178 if (other
.old_val
!= NULL
)
4179 old_val
= release_value (value_copy (other
.old_val
.get ()));
4180 incref_bp_location (bp_location_at
);
4183 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
4184 is part of the bpstat is copied as well. */
4187 bpstat_copy (bpstat bs
)
4191 bpstat retval
= NULL
;
4196 for (; bs
!= NULL
; bs
= bs
->next
)
4198 tmp
= new bpstats (*bs
);
4201 /* This is the first thing in the chain. */
4211 /* Find the bpstat associated with this breakpoint. */
4214 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
4219 for (; bsp
!= NULL
; bsp
= bsp
->next
)
4221 if (bsp
->breakpoint_at
== breakpoint
)
4227 /* See breakpoint.h. */
4230 bpstat_explains_signal (bpstat bsp
, enum gdb_signal sig
)
4232 for (; bsp
!= NULL
; bsp
= bsp
->next
)
4234 if (bsp
->breakpoint_at
== NULL
)
4236 /* A moribund location can never explain a signal other than
4238 if (sig
== GDB_SIGNAL_TRAP
)
4243 if (bsp
->breakpoint_at
->ops
->explains_signal (bsp
->breakpoint_at
,
4252 /* Put in *NUM the breakpoint number of the first breakpoint we are
4253 stopped at. *BSP upon return is a bpstat which points to the
4254 remaining breakpoints stopped at (but which is not guaranteed to be
4255 good for anything but further calls to bpstat_num).
4257 Return 0 if passed a bpstat which does not indicate any breakpoints.
4258 Return -1 if stopped at a breakpoint that has been deleted since
4260 Return 1 otherwise. */
4263 bpstat_num (bpstat
*bsp
, int *num
)
4265 struct breakpoint
*b
;
4268 return 0; /* No more breakpoint values */
4270 /* We assume we'll never have several bpstats that correspond to a
4271 single breakpoint -- otherwise, this function might return the
4272 same number more than once and this will look ugly. */
4273 b
= (*bsp
)->breakpoint_at
;
4274 *bsp
= (*bsp
)->next
;
4276 return -1; /* breakpoint that's been deleted since */
4278 *num
= b
->number
; /* We have its number */
4282 /* See breakpoint.h. */
4285 bpstat_clear_actions (void)
4289 if (inferior_ptid
== null_ptid
)
4292 thread_info
*tp
= inferior_thread ();
4293 for (bs
= tp
->control
.stop_bpstat
; bs
!= NULL
; bs
= bs
->next
)
4295 bs
->commands
= NULL
;
4296 bs
->old_val
.reset (nullptr);
4300 /* Called when a command is about to proceed the inferior. */
4303 breakpoint_about_to_proceed (void)
4305 if (inferior_ptid
!= null_ptid
)
4307 struct thread_info
*tp
= inferior_thread ();
4309 /* Allow inferior function calls in breakpoint commands to not
4310 interrupt the command list. When the call finishes
4311 successfully, the inferior will be standing at the same
4312 breakpoint as if nothing happened. */
4313 if (tp
->control
.in_infcall
)
4317 breakpoint_proceeded
= 1;
4320 /* Return non-zero iff CMD as the first line of a command sequence is `silent'
4321 or its equivalent. */
4324 command_line_is_silent (struct command_line
*cmd
)
4326 return cmd
&& (strcmp ("silent", cmd
->line
) == 0);
4329 /* Execute all the commands associated with all the breakpoints at
4330 this location. Any of these commands could cause the process to
4331 proceed beyond this point, etc. We look out for such changes by
4332 checking the global "breakpoint_proceeded" after each command.
4334 Returns true if a breakpoint command resumed the inferior. In that
4335 case, it is the caller's responsibility to recall it again with the
4336 bpstat of the current thread. */
4339 bpstat_do_actions_1 (bpstat
*bsp
)
4344 /* Avoid endless recursion if a `source' command is contained
4346 if (executing_breakpoint_commands
)
4349 scoped_restore save_executing
4350 = make_scoped_restore (&executing_breakpoint_commands
, 1);
4352 scoped_restore preventer
= prevent_dont_repeat ();
4354 /* This pointer will iterate over the list of bpstat's. */
4357 breakpoint_proceeded
= 0;
4358 for (; bs
!= NULL
; bs
= bs
->next
)
4360 struct command_line
*cmd
= NULL
;
4362 /* Take ownership of the BSP's command tree, if it has one.
4364 The command tree could legitimately contain commands like
4365 'step' and 'next', which call clear_proceed_status, which
4366 frees stop_bpstat's command tree. To make sure this doesn't
4367 free the tree we're executing out from under us, we need to
4368 take ownership of the tree ourselves. Since a given bpstat's
4369 commands are only executed once, we don't need to copy it; we
4370 can clear the pointer in the bpstat, and make sure we free
4371 the tree when we're done. */
4372 counted_command_line ccmd
= bs
->commands
;
4373 bs
->commands
= NULL
;
4376 if (command_line_is_silent (cmd
))
4378 /* The action has been already done by bpstat_stop_status. */
4384 execute_control_command (cmd
);
4386 if (breakpoint_proceeded
)
4392 if (breakpoint_proceeded
)
4394 if (current_ui
->async
)
4395 /* If we are in async mode, then the target might be still
4396 running, not stopped at any breakpoint, so nothing for
4397 us to do here -- just return to the event loop. */
4400 /* In sync mode, when execute_control_command returns
4401 we're already standing on the next breakpoint.
4402 Breakpoint commands for that stop were not run, since
4403 execute_command does not run breakpoint commands --
4404 only command_line_handler does, but that one is not
4405 involved in execution of breakpoint commands. So, we
4406 can now execute breakpoint commands. It should be
4407 noted that making execute_command do bpstat actions is
4408 not an option -- in this case we'll have recursive
4409 invocation of bpstat for each breakpoint with a
4410 command, and can easily blow up GDB stack. Instead, we
4411 return true, which will trigger the caller to recall us
4412 with the new stop_bpstat. */
4420 /* Helper for bpstat_do_actions. Get the current thread, if there's
4421 one, is alive and has execution. Return NULL otherwise. */
4423 static thread_info
*
4424 get_bpstat_thread ()
4426 if (inferior_ptid
== null_ptid
|| !target_has_execution
)
4429 thread_info
*tp
= inferior_thread ();
4430 if (tp
->state
== THREAD_EXITED
|| tp
->executing
)
4436 bpstat_do_actions (void)
4438 auto cleanup_if_error
= make_scope_exit (bpstat_clear_actions
);
4441 /* Do any commands attached to breakpoint we are stopped at. */
4442 while ((tp
= get_bpstat_thread ()) != NULL
)
4444 /* Since in sync mode, bpstat_do_actions may resume the
4445 inferior, and only return when it is stopped at the next
4446 breakpoint, we keep doing breakpoint actions until it returns
4447 false to indicate the inferior was not resumed. */
4448 if (!bpstat_do_actions_1 (&tp
->control
.stop_bpstat
))
4452 cleanup_if_error
.release ();
4455 /* Print out the (old or new) value associated with a watchpoint. */
4458 watchpoint_value_print (struct value
*val
, struct ui_file
*stream
)
4461 fprintf_styled (stream
, metadata_style
.style (), _("<unreadable>"));
4464 struct value_print_options opts
;
4465 get_user_print_options (&opts
);
4466 value_print (val
, stream
, &opts
);
4470 /* Print the "Thread ID hit" part of "Thread ID hit Breakpoint N" if
4471 debugging multiple threads. */
4474 maybe_print_thread_hit_breakpoint (struct ui_out
*uiout
)
4476 if (uiout
->is_mi_like_p ())
4481 if (show_thread_that_caused_stop ())
4484 struct thread_info
*thr
= inferior_thread ();
4486 uiout
->text ("Thread ");
4487 uiout
->field_string ("thread-id", print_thread_id (thr
));
4489 name
= thr
->name
!= NULL
? thr
->name
: target_thread_name (thr
);
4492 uiout
->text (" \"");
4493 uiout
->field_string ("name", name
);
4497 uiout
->text (" hit ");
4501 /* Generic routine for printing messages indicating why we
4502 stopped. The behavior of this function depends on the value
4503 'print_it' in the bpstat structure. Under some circumstances we
4504 may decide not to print anything here and delegate the task to
4507 static enum print_stop_action
4508 print_bp_stop_message (bpstat bs
)
4510 switch (bs
->print_it
)
4513 /* Nothing should be printed for this bpstat entry. */
4514 return PRINT_UNKNOWN
;
4518 /* We still want to print the frame, but we already printed the
4519 relevant messages. */
4520 return PRINT_SRC_AND_LOC
;
4523 case print_it_normal
:
4525 struct breakpoint
*b
= bs
->breakpoint_at
;
4527 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
4528 which has since been deleted. */
4530 return PRINT_UNKNOWN
;
4532 /* Normal case. Call the breakpoint's print_it method. */
4533 return b
->ops
->print_it (bs
);
4538 internal_error (__FILE__
, __LINE__
,
4539 _("print_bp_stop_message: unrecognized enum value"));
4544 /* A helper function that prints a shared library stopped event. */
4547 print_solib_event (int is_catchpoint
)
4549 bool any_deleted
= !current_program_space
->deleted_solibs
.empty ();
4550 bool any_added
= !current_program_space
->added_solibs
.empty ();
4554 if (any_added
|| any_deleted
)
4555 current_uiout
->text (_("Stopped due to shared library event:\n"));
4557 current_uiout
->text (_("Stopped due to shared library event (no "
4558 "libraries added or removed)\n"));
4561 if (current_uiout
->is_mi_like_p ())
4562 current_uiout
->field_string ("reason",
4563 async_reason_lookup (EXEC_ASYNC_SOLIB_EVENT
));
4567 current_uiout
->text (_(" Inferior unloaded "));
4568 ui_out_emit_list
list_emitter (current_uiout
, "removed");
4569 for (int ix
= 0; ix
< current_program_space
->deleted_solibs
.size (); ix
++)
4571 const std::string
&name
= current_program_space
->deleted_solibs
[ix
];
4574 current_uiout
->text (" ");
4575 current_uiout
->field_string ("library", name
);
4576 current_uiout
->text ("\n");
4582 current_uiout
->text (_(" Inferior loaded "));
4583 ui_out_emit_list
list_emitter (current_uiout
, "added");
4585 for (so_list
*iter
: current_program_space
->added_solibs
)
4588 current_uiout
->text (" ");
4590 current_uiout
->field_string ("library", iter
->so_name
);
4591 current_uiout
->text ("\n");
4596 /* Print a message indicating what happened. This is called from
4597 normal_stop(). The input to this routine is the head of the bpstat
4598 list - a list of the eventpoints that caused this stop. KIND is
4599 the target_waitkind for the stopping event. This
4600 routine calls the generic print routine for printing a message
4601 about reasons for stopping. This will print (for example) the
4602 "Breakpoint n," part of the output. The return value of this
4605 PRINT_UNKNOWN: Means we printed nothing.
4606 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
4607 code to print the location. An example is
4608 "Breakpoint 1, " which should be followed by
4610 PRINT_SRC_ONLY: Means we printed something, but there is no need
4611 to also print the location part of the message.
4612 An example is the catch/throw messages, which
4613 don't require a location appended to the end.
4614 PRINT_NOTHING: We have done some printing and we don't need any
4615 further info to be printed. */
4617 enum print_stop_action
4618 bpstat_print (bpstat bs
, int kind
)
4620 enum print_stop_action val
;
4622 /* Maybe another breakpoint in the chain caused us to stop.
4623 (Currently all watchpoints go on the bpstat whether hit or not.
4624 That probably could (should) be changed, provided care is taken
4625 with respect to bpstat_explains_signal). */
4626 for (; bs
; bs
= bs
->next
)
4628 val
= print_bp_stop_message (bs
);
4629 if (val
== PRINT_SRC_ONLY
4630 || val
== PRINT_SRC_AND_LOC
4631 || val
== PRINT_NOTHING
)
4635 /* If we had hit a shared library event breakpoint,
4636 print_bp_stop_message would print out this message. If we hit an
4637 OS-level shared library event, do the same thing. */
4638 if (kind
== TARGET_WAITKIND_LOADED
)
4640 print_solib_event (0);
4641 return PRINT_NOTHING
;
4644 /* We reached the end of the chain, or we got a null BS to start
4645 with and nothing was printed. */
4646 return PRINT_UNKNOWN
;
4649 /* Evaluate the boolean expression EXP and return the result. */
4652 breakpoint_cond_eval (expression
*exp
)
4654 struct value
*mark
= value_mark ();
4655 bool res
= value_true (evaluate_expression (exp
));
4657 value_free_to_mark (mark
);
4661 /* Allocate a new bpstat. Link it to the FIFO list by BS_LINK_POINTER. */
4663 bpstats::bpstats (struct bp_location
*bl
, bpstat
**bs_link_pointer
)
4665 bp_location_at (bl
),
4666 breakpoint_at (bl
->owner
),
4670 print_it (print_it_normal
)
4672 incref_bp_location (bl
);
4673 **bs_link_pointer
= this;
4674 *bs_link_pointer
= &next
;
4679 bp_location_at (NULL
),
4680 breakpoint_at (NULL
),
4684 print_it (print_it_normal
)
4688 /* The target has stopped with waitstatus WS. Check if any hardware
4689 watchpoints have triggered, according to the target. */
4692 watchpoints_triggered (struct target_waitstatus
*ws
)
4694 bool stopped_by_watchpoint
= target_stopped_by_watchpoint ();
4696 struct breakpoint
*b
;
4698 if (!stopped_by_watchpoint
)
4700 /* We were not stopped by a watchpoint. Mark all watchpoints
4701 as not triggered. */
4703 if (is_hardware_watchpoint (b
))
4705 struct watchpoint
*w
= (struct watchpoint
*) b
;
4707 w
->watchpoint_triggered
= watch_triggered_no
;
4713 if (!target_stopped_data_address (current_top_target (), &addr
))
4715 /* We were stopped by a watchpoint, but we don't know where.
4716 Mark all watchpoints as unknown. */
4718 if (is_hardware_watchpoint (b
))
4720 struct watchpoint
*w
= (struct watchpoint
*) b
;
4722 w
->watchpoint_triggered
= watch_triggered_unknown
;
4728 /* The target could report the data address. Mark watchpoints
4729 affected by this data address as triggered, and all others as not
4733 if (is_hardware_watchpoint (b
))
4735 struct watchpoint
*w
= (struct watchpoint
*) b
;
4736 struct bp_location
*loc
;
4738 w
->watchpoint_triggered
= watch_triggered_no
;
4739 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
4741 if (is_masked_watchpoint (b
))
4743 CORE_ADDR newaddr
= addr
& w
->hw_wp_mask
;
4744 CORE_ADDR start
= loc
->address
& w
->hw_wp_mask
;
4746 if (newaddr
== start
)
4748 w
->watchpoint_triggered
= watch_triggered_yes
;
4752 /* Exact match not required. Within range is sufficient. */
4753 else if (target_watchpoint_addr_within_range (current_top_target (),
4757 w
->watchpoint_triggered
= watch_triggered_yes
;
4766 /* Possible return values for watchpoint_check. */
4767 enum wp_check_result
4769 /* The watchpoint has been deleted. */
4772 /* The value has changed. */
4773 WP_VALUE_CHANGED
= 2,
4775 /* The value has not changed. */
4776 WP_VALUE_NOT_CHANGED
= 3,
4778 /* Ignore this watchpoint, no matter if the value changed or not. */
4782 #define BP_TEMPFLAG 1
4783 #define BP_HARDWAREFLAG 2
4785 /* Evaluate watchpoint condition expression and check if its value
4788 static wp_check_result
4789 watchpoint_check (bpstat bs
)
4791 struct watchpoint
*b
;
4792 struct frame_info
*fr
;
4793 int within_current_scope
;
4795 /* BS is built from an existing struct breakpoint. */
4796 gdb_assert (bs
->breakpoint_at
!= NULL
);
4797 b
= (struct watchpoint
*) bs
->breakpoint_at
;
4799 /* If this is a local watchpoint, we only want to check if the
4800 watchpoint frame is in scope if the current thread is the thread
4801 that was used to create the watchpoint. */
4802 if (!watchpoint_in_thread_scope (b
))
4805 if (b
->exp_valid_block
== NULL
)
4806 within_current_scope
= 1;
4809 struct frame_info
*frame
= get_current_frame ();
4810 struct gdbarch
*frame_arch
= get_frame_arch (frame
);
4811 CORE_ADDR frame_pc
= get_frame_pc (frame
);
4813 /* stack_frame_destroyed_p() returns a non-zero value if we're
4814 still in the function but the stack frame has already been
4815 invalidated. Since we can't rely on the values of local
4816 variables after the stack has been destroyed, we are treating
4817 the watchpoint in that state as `not changed' without further
4818 checking. Don't mark watchpoints as changed if the current
4819 frame is in an epilogue - even if they are in some other
4820 frame, our view of the stack is likely to be wrong and
4821 frame_find_by_id could error out. */
4822 if (gdbarch_stack_frame_destroyed_p (frame_arch
, frame_pc
))
4825 fr
= frame_find_by_id (b
->watchpoint_frame
);
4826 within_current_scope
= (fr
!= NULL
);
4828 /* If we've gotten confused in the unwinder, we might have
4829 returned a frame that can't describe this variable. */
4830 if (within_current_scope
)
4832 struct symbol
*function
;
4834 function
= get_frame_function (fr
);
4835 if (function
== NULL
4836 || !contained_in (b
->exp_valid_block
,
4837 SYMBOL_BLOCK_VALUE (function
)))
4838 within_current_scope
= 0;
4841 if (within_current_scope
)
4842 /* If we end up stopping, the current frame will get selected
4843 in normal_stop. So this call to select_frame won't affect
4848 if (within_current_scope
)
4850 /* We use value_{,free_to_}mark because it could be a *long*
4851 time before we return to the command level and call
4852 free_all_values. We can't call free_all_values because we
4853 might be in the middle of evaluating a function call. */
4857 struct value
*new_val
;
4859 if (is_masked_watchpoint (b
))
4860 /* Since we don't know the exact trigger address (from
4861 stopped_data_address), just tell the user we've triggered
4862 a mask watchpoint. */
4863 return WP_VALUE_CHANGED
;
4865 mark
= value_mark ();
4866 fetch_subexp_value (b
->exp
.get (), &pc
, &new_val
, NULL
, NULL
, 0);
4868 if (b
->val_bitsize
!= 0)
4869 new_val
= extract_bitfield_from_watchpoint_value (b
, new_val
);
4871 /* We use value_equal_contents instead of value_equal because
4872 the latter coerces an array to a pointer, thus comparing just
4873 the address of the array instead of its contents. This is
4874 not what we want. */
4875 if ((b
->val
!= NULL
) != (new_val
!= NULL
)
4876 || (b
->val
!= NULL
&& !value_equal_contents (b
->val
.get (),
4879 bs
->old_val
= b
->val
;
4880 b
->val
= release_value (new_val
);
4881 b
->val_valid
= true;
4882 if (new_val
!= NULL
)
4883 value_free_to_mark (mark
);
4884 return WP_VALUE_CHANGED
;
4888 /* Nothing changed. */
4889 value_free_to_mark (mark
);
4890 return WP_VALUE_NOT_CHANGED
;
4895 /* This seems like the only logical thing to do because
4896 if we temporarily ignored the watchpoint, then when
4897 we reenter the block in which it is valid it contains
4898 garbage (in the case of a function, it may have two
4899 garbage values, one before and one after the prologue).
4900 So we can't even detect the first assignment to it and
4901 watch after that (since the garbage may or may not equal
4902 the first value assigned). */
4903 /* We print all the stop information in
4904 breakpoint_ops->print_it, but in this case, by the time we
4905 call breakpoint_ops->print_it this bp will be deleted
4906 already. So we have no choice but print the information
4909 SWITCH_THRU_ALL_UIS ()
4911 struct ui_out
*uiout
= current_uiout
;
4913 if (uiout
->is_mi_like_p ())
4915 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
4916 uiout
->message ("\nWatchpoint %pF deleted because the program has "
4917 "left the block in\n"
4918 "which its expression is valid.\n",
4919 signed_field ("wpnum", b
->number
));
4922 /* Make sure the watchpoint's commands aren't executed. */
4924 watchpoint_del_at_next_stop (b
);
4930 /* Return true if it looks like target has stopped due to hitting
4931 breakpoint location BL. This function does not check if we should
4932 stop, only if BL explains the stop. */
4935 bpstat_check_location (const struct bp_location
*bl
,
4936 const address_space
*aspace
, CORE_ADDR bp_addr
,
4937 const struct target_waitstatus
*ws
)
4939 struct breakpoint
*b
= bl
->owner
;
4941 /* BL is from an existing breakpoint. */
4942 gdb_assert (b
!= NULL
);
4944 return b
->ops
->breakpoint_hit (bl
, aspace
, bp_addr
, ws
);
4947 /* Determine if the watched values have actually changed, and we
4948 should stop. If not, set BS->stop to 0. */
4951 bpstat_check_watchpoint (bpstat bs
)
4953 const struct bp_location
*bl
;
4954 struct watchpoint
*b
;
4956 /* BS is built for existing struct breakpoint. */
4957 bl
= bs
->bp_location_at
;
4958 gdb_assert (bl
!= NULL
);
4959 b
= (struct watchpoint
*) bs
->breakpoint_at
;
4960 gdb_assert (b
!= NULL
);
4963 int must_check_value
= 0;
4965 if (b
->type
== bp_watchpoint
)
4966 /* For a software watchpoint, we must always check the
4968 must_check_value
= 1;
4969 else if (b
->watchpoint_triggered
== watch_triggered_yes
)
4970 /* We have a hardware watchpoint (read, write, or access)
4971 and the target earlier reported an address watched by
4973 must_check_value
= 1;
4974 else if (b
->watchpoint_triggered
== watch_triggered_unknown
4975 && b
->type
== bp_hardware_watchpoint
)
4976 /* We were stopped by a hardware watchpoint, but the target could
4977 not report the data address. We must check the watchpoint's
4978 value. Access and read watchpoints are out of luck; without
4979 a data address, we can't figure it out. */
4980 must_check_value
= 1;
4982 if (must_check_value
)
4988 e
= watchpoint_check (bs
);
4990 catch (const gdb_exception
&ex
)
4992 exception_fprintf (gdb_stderr
, ex
,
4993 "Error evaluating expression "
4994 "for watchpoint %d\n",
4997 SWITCH_THRU_ALL_UIS ()
4999 printf_filtered (_("Watchpoint %d deleted.\n"),
5002 watchpoint_del_at_next_stop (b
);
5009 /* We've already printed what needs to be printed. */
5010 bs
->print_it
= print_it_done
;
5014 bs
->print_it
= print_it_noop
;
5017 case WP_VALUE_CHANGED
:
5018 if (b
->type
== bp_read_watchpoint
)
5020 /* There are two cases to consider here:
5022 1. We're watching the triggered memory for reads.
5023 In that case, trust the target, and always report
5024 the watchpoint hit to the user. Even though
5025 reads don't cause value changes, the value may
5026 have changed since the last time it was read, and
5027 since we're not trapping writes, we will not see
5028 those, and as such we should ignore our notion of
5031 2. We're watching the triggered memory for both
5032 reads and writes. There are two ways this may
5035 2.1. This is a target that can't break on data
5036 reads only, but can break on accesses (reads or
5037 writes), such as e.g., x86. We detect this case
5038 at the time we try to insert read watchpoints.
5040 2.2. Otherwise, the target supports read
5041 watchpoints, but, the user set an access or write
5042 watchpoint watching the same memory as this read
5045 If we're watching memory writes as well as reads,
5046 ignore watchpoint hits when we find that the
5047 value hasn't changed, as reads don't cause
5048 changes. This still gives false positives when
5049 the program writes the same value to memory as
5050 what there was already in memory (we will confuse
5051 it for a read), but it's much better than
5054 int other_write_watchpoint
= 0;
5056 if (bl
->watchpoint_type
== hw_read
)
5058 struct breakpoint
*other_b
;
5060 ALL_BREAKPOINTS (other_b
)
5061 if (other_b
->type
== bp_hardware_watchpoint
5062 || other_b
->type
== bp_access_watchpoint
)
5064 struct watchpoint
*other_w
=
5065 (struct watchpoint
*) other_b
;
5067 if (other_w
->watchpoint_triggered
5068 == watch_triggered_yes
)
5070 other_write_watchpoint
= 1;
5076 if (other_write_watchpoint
5077 || bl
->watchpoint_type
== hw_access
)
5079 /* We're watching the same memory for writes,
5080 and the value changed since the last time we
5081 updated it, so this trap must be for a write.
5083 bs
->print_it
= print_it_noop
;
5088 case WP_VALUE_NOT_CHANGED
:
5089 if (b
->type
== bp_hardware_watchpoint
5090 || b
->type
== bp_watchpoint
)
5092 /* Don't stop: write watchpoints shouldn't fire if
5093 the value hasn't changed. */
5094 bs
->print_it
= print_it_noop
;
5104 else /* must_check_value == 0 */
5106 /* This is a case where some watchpoint(s) triggered, but
5107 not at the address of this watchpoint, or else no
5108 watchpoint triggered after all. So don't print
5109 anything for this watchpoint. */
5110 bs
->print_it
= print_it_noop
;
5116 /* For breakpoints that are currently marked as telling gdb to stop,
5117 check conditions (condition proper, frame, thread and ignore count)
5118 of breakpoint referred to by BS. If we should not stop for this
5119 breakpoint, set BS->stop to 0. */
5122 bpstat_check_breakpoint_conditions (bpstat bs
, thread_info
*thread
)
5124 const struct bp_location
*bl
;
5125 struct breakpoint
*b
;
5127 bool condition_result
= true;
5128 struct expression
*cond
;
5130 gdb_assert (bs
->stop
);
5132 /* BS is built for existing struct breakpoint. */
5133 bl
= bs
->bp_location_at
;
5134 gdb_assert (bl
!= NULL
);
5135 b
= bs
->breakpoint_at
;
5136 gdb_assert (b
!= NULL
);
5138 /* Even if the target evaluated the condition on its end and notified GDB, we
5139 need to do so again since GDB does not know if we stopped due to a
5140 breakpoint or a single step breakpoint. */
5142 if (frame_id_p (b
->frame_id
)
5143 && !frame_id_eq (b
->frame_id
, get_stack_frame_id (get_current_frame ())))
5149 /* If this is a thread/task-specific breakpoint, don't waste cpu
5150 evaluating the condition if this isn't the specified
5152 if ((b
->thread
!= -1 && b
->thread
!= thread
->global_num
)
5153 || (b
->task
!= 0 && b
->task
!= ada_get_task_number (thread
)))
5159 /* Evaluate extension language breakpoints that have a "stop" method
5161 bs
->stop
= breakpoint_ext_lang_cond_says_stop (b
);
5163 if (is_watchpoint (b
))
5165 struct watchpoint
*w
= (struct watchpoint
*) b
;
5167 cond
= w
->cond_exp
.get ();
5170 cond
= bl
->cond
.get ();
5172 if (cond
&& b
->disposition
!= disp_del_at_next_stop
)
5174 int within_current_scope
= 1;
5175 struct watchpoint
* w
;
5177 /* We use value_mark and value_free_to_mark because it could
5178 be a long time before we return to the command level and
5179 call free_all_values. We can't call free_all_values
5180 because we might be in the middle of evaluating a
5182 struct value
*mark
= value_mark ();
5184 if (is_watchpoint (b
))
5185 w
= (struct watchpoint
*) b
;
5189 /* Need to select the frame, with all that implies so that
5190 the conditions will have the right context. Because we
5191 use the frame, we will not see an inlined function's
5192 variables when we arrive at a breakpoint at the start
5193 of the inlined function; the current frame will be the
5195 if (w
== NULL
|| w
->cond_exp_valid_block
== NULL
)
5196 select_frame (get_current_frame ());
5199 struct frame_info
*frame
;
5201 /* For local watchpoint expressions, which particular
5202 instance of a local is being watched matters, so we
5203 keep track of the frame to evaluate the expression
5204 in. To evaluate the condition however, it doesn't
5205 really matter which instantiation of the function
5206 where the condition makes sense triggers the
5207 watchpoint. This allows an expression like "watch
5208 global if q > 10" set in `func', catch writes to
5209 global on all threads that call `func', or catch
5210 writes on all recursive calls of `func' by a single
5211 thread. We simply always evaluate the condition in
5212 the innermost frame that's executing where it makes
5213 sense to evaluate the condition. It seems
5215 frame
= block_innermost_frame (w
->cond_exp_valid_block
);
5217 select_frame (frame
);
5219 within_current_scope
= 0;
5221 if (within_current_scope
)
5225 condition_result
= breakpoint_cond_eval (cond
);
5227 catch (const gdb_exception
&ex
)
5229 exception_fprintf (gdb_stderr
, ex
,
5230 "Error in testing breakpoint condition:\n");
5235 warning (_("Watchpoint condition cannot be tested "
5236 "in the current scope"));
5237 /* If we failed to set the right context for this
5238 watchpoint, unconditionally report it. */
5240 /* FIXME-someday, should give breakpoint #. */
5241 value_free_to_mark (mark
);
5244 if (cond
&& !condition_result
)
5248 else if (b
->ignore_count
> 0)
5252 /* Increase the hit count even though we don't stop. */
5254 gdb::observers::breakpoint_modified
.notify (b
);
5258 /* Returns true if we need to track moribund locations of LOC's type
5259 on the current target. */
5262 need_moribund_for_location_type (struct bp_location
*loc
)
5264 return ((loc
->loc_type
== bp_loc_software_breakpoint
5265 && !target_supports_stopped_by_sw_breakpoint ())
5266 || (loc
->loc_type
== bp_loc_hardware_breakpoint
5267 && !target_supports_stopped_by_hw_breakpoint ()));
5270 /* See breakpoint.h. */
5273 build_bpstat_chain (const address_space
*aspace
, CORE_ADDR bp_addr
,
5274 const struct target_waitstatus
*ws
)
5276 struct breakpoint
*b
;
5277 bpstat bs_head
= NULL
, *bs_link
= &bs_head
;
5281 if (!breakpoint_enabled (b
))
5284 for (bp_location
*bl
= b
->loc
; bl
!= NULL
; bl
= bl
->next
)
5286 /* For hardware watchpoints, we look only at the first
5287 location. The watchpoint_check function will work on the
5288 entire expression, not the individual locations. For
5289 read watchpoints, the watchpoints_triggered function has
5290 checked all locations already. */
5291 if (b
->type
== bp_hardware_watchpoint
&& bl
!= b
->loc
)
5294 if (!bl
->enabled
|| bl
->shlib_disabled
)
5297 if (!bpstat_check_location (bl
, aspace
, bp_addr
, ws
))
5300 /* Come here if it's a watchpoint, or if the break address
5303 bpstat bs
= new bpstats (bl
, &bs_link
); /* Alloc a bpstat to
5306 /* Assume we stop. Should we find a watchpoint that is not
5307 actually triggered, or if the condition of the breakpoint
5308 evaluates as false, we'll reset 'stop' to 0. */
5312 /* If this is a scope breakpoint, mark the associated
5313 watchpoint as triggered so that we will handle the
5314 out-of-scope event. We'll get to the watchpoint next
5316 if (b
->type
== bp_watchpoint_scope
&& b
->related_breakpoint
!= b
)
5318 struct watchpoint
*w
= (struct watchpoint
*) b
->related_breakpoint
;
5320 w
->watchpoint_triggered
= watch_triggered_yes
;
5325 /* Check if a moribund breakpoint explains the stop. */
5326 if (!target_supports_stopped_by_sw_breakpoint ()
5327 || !target_supports_stopped_by_hw_breakpoint ())
5329 for (bp_location
*loc
: moribund_locations
)
5331 if (breakpoint_location_address_match (loc
, aspace
, bp_addr
)
5332 && need_moribund_for_location_type (loc
))
5334 bpstat bs
= new bpstats (loc
, &bs_link
);
5335 /* For hits of moribund locations, we should just proceed. */
5338 bs
->print_it
= print_it_noop
;
5346 /* See breakpoint.h. */
5349 bpstat_stop_status (const address_space
*aspace
,
5350 CORE_ADDR bp_addr
, thread_info
*thread
,
5351 const struct target_waitstatus
*ws
,
5354 struct breakpoint
*b
= NULL
;
5355 /* First item of allocated bpstat's. */
5356 bpstat bs_head
= stop_chain
;
5358 int need_remove_insert
;
5361 /* First, build the bpstat chain with locations that explain a
5362 target stop, while being careful to not set the target running,
5363 as that may invalidate locations (in particular watchpoint
5364 locations are recreated). Resuming will happen here with
5365 breakpoint conditions or watchpoint expressions that include
5366 inferior function calls. */
5367 if (bs_head
== NULL
)
5368 bs_head
= build_bpstat_chain (aspace
, bp_addr
, ws
);
5370 /* A bit of special processing for shlib breakpoints. We need to
5371 process solib loading here, so that the lists of loaded and
5372 unloaded libraries are correct before we handle "catch load" and
5374 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5376 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->type
== bp_shlib_event
)
5378 handle_solib_event ();
5383 /* Now go through the locations that caused the target to stop, and
5384 check whether we're interested in reporting this stop to higher
5385 layers, or whether we should resume the target transparently. */
5389 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5394 b
= bs
->breakpoint_at
;
5395 b
->ops
->check_status (bs
);
5398 bpstat_check_breakpoint_conditions (bs
, thread
);
5403 gdb::observers::breakpoint_modified
.notify (b
);
5405 /* We will stop here. */
5406 if (b
->disposition
== disp_disable
)
5408 --(b
->enable_count
);
5409 if (b
->enable_count
<= 0)
5410 b
->enable_state
= bp_disabled
;
5415 bs
->commands
= b
->commands
;
5416 if (command_line_is_silent (bs
->commands
5417 ? bs
->commands
.get () : NULL
))
5420 b
->ops
->after_condition_true (bs
);
5425 /* Print nothing for this entry if we don't stop or don't
5427 if (!bs
->stop
|| !bs
->print
)
5428 bs
->print_it
= print_it_noop
;
5431 /* If we aren't stopping, the value of some hardware watchpoint may
5432 not have changed, but the intermediate memory locations we are
5433 watching may have. Don't bother if we're stopping; this will get
5435 need_remove_insert
= 0;
5436 if (! bpstat_causes_stop (bs_head
))
5437 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5439 && bs
->breakpoint_at
5440 && is_hardware_watchpoint (bs
->breakpoint_at
))
5442 struct watchpoint
*w
= (struct watchpoint
*) bs
->breakpoint_at
;
5444 update_watchpoint (w
, 0 /* don't reparse. */);
5445 need_remove_insert
= 1;
5448 if (need_remove_insert
)
5449 update_global_location_list (UGLL_MAY_INSERT
);
5450 else if (removed_any
)
5451 update_global_location_list (UGLL_DONT_INSERT
);
5457 handle_jit_event (void)
5459 struct frame_info
*frame
;
5460 struct gdbarch
*gdbarch
;
5463 fprintf_unfiltered (gdb_stdlog
, "handling bp_jit_event\n");
5465 /* Switch terminal for any messages produced by
5466 breakpoint_re_set. */
5467 target_terminal::ours_for_output ();
5469 frame
= get_current_frame ();
5470 gdbarch
= get_frame_arch (frame
);
5472 jit_event_handler (gdbarch
);
5474 target_terminal::inferior ();
5477 /* Prepare WHAT final decision for infrun. */
5479 /* Decide what infrun needs to do with this bpstat. */
5482 bpstat_what (bpstat bs_head
)
5484 struct bpstat_what retval
;
5487 retval
.main_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5488 retval
.call_dummy
= STOP_NONE
;
5489 retval
.is_longjmp
= false;
5491 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5493 /* Extract this BS's action. After processing each BS, we check
5494 if its action overrides all we've seem so far. */
5495 enum bpstat_what_main_action this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5498 if (bs
->breakpoint_at
== NULL
)
5500 /* I suspect this can happen if it was a momentary
5501 breakpoint which has since been deleted. */
5505 bptype
= bs
->breakpoint_at
->type
;
5512 case bp_hardware_breakpoint
:
5513 case bp_single_step
:
5516 case bp_shlib_event
:
5520 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5522 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5525 this_action
= BPSTAT_WHAT_SINGLE
;
5528 case bp_hardware_watchpoint
:
5529 case bp_read_watchpoint
:
5530 case bp_access_watchpoint
:
5534 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5536 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5540 /* There was a watchpoint, but we're not stopping.
5541 This requires no further action. */
5545 case bp_longjmp_call_dummy
:
5549 this_action
= BPSTAT_WHAT_SET_LONGJMP_RESUME
;
5550 retval
.is_longjmp
= bptype
!= bp_exception
;
5553 this_action
= BPSTAT_WHAT_SINGLE
;
5555 case bp_longjmp_resume
:
5556 case bp_exception_resume
:
5559 this_action
= BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
;
5560 retval
.is_longjmp
= bptype
== bp_longjmp_resume
;
5563 this_action
= BPSTAT_WHAT_SINGLE
;
5565 case bp_step_resume
:
5567 this_action
= BPSTAT_WHAT_STEP_RESUME
;
5570 /* It is for the wrong frame. */
5571 this_action
= BPSTAT_WHAT_SINGLE
;
5574 case bp_hp_step_resume
:
5576 this_action
= BPSTAT_WHAT_HP_STEP_RESUME
;
5579 /* It is for the wrong frame. */
5580 this_action
= BPSTAT_WHAT_SINGLE
;
5583 case bp_watchpoint_scope
:
5584 case bp_thread_event
:
5585 case bp_overlay_event
:
5586 case bp_longjmp_master
:
5587 case bp_std_terminate_master
:
5588 case bp_exception_master
:
5589 this_action
= BPSTAT_WHAT_SINGLE
;
5595 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5597 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5601 /* Some catchpoints are implemented with breakpoints.
5602 For those, we need to step over the breakpoint. */
5603 if (bs
->bp_location_at
->loc_type
!= bp_loc_other
)
5604 this_action
= BPSTAT_WHAT_SINGLE
;
5608 this_action
= BPSTAT_WHAT_SINGLE
;
5611 /* Make sure the action is stop (silent or noisy),
5612 so infrun.c pops the dummy frame. */
5613 retval
.call_dummy
= STOP_STACK_DUMMY
;
5614 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5616 case bp_std_terminate
:
5617 /* Make sure the action is stop (silent or noisy),
5618 so infrun.c pops the dummy frame. */
5619 retval
.call_dummy
= STOP_STD_TERMINATE
;
5620 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5623 case bp_fast_tracepoint
:
5624 case bp_static_tracepoint
:
5625 /* Tracepoint hits should not be reported back to GDB, and
5626 if one got through somehow, it should have been filtered
5628 internal_error (__FILE__
, __LINE__
,
5629 _("bpstat_what: tracepoint encountered"));
5631 case bp_gnu_ifunc_resolver
:
5632 /* Step over it (and insert bp_gnu_ifunc_resolver_return). */
5633 this_action
= BPSTAT_WHAT_SINGLE
;
5635 case bp_gnu_ifunc_resolver_return
:
5636 /* The breakpoint will be removed, execution will restart from the
5637 PC of the former breakpoint. */
5638 this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5643 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5645 this_action
= BPSTAT_WHAT_SINGLE
;
5649 internal_error (__FILE__
, __LINE__
,
5650 _("bpstat_what: unhandled bptype %d"), (int) bptype
);
5653 retval
.main_action
= std::max (retval
.main_action
, this_action
);
5660 bpstat_run_callbacks (bpstat bs_head
)
5664 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5666 struct breakpoint
*b
= bs
->breakpoint_at
;
5673 handle_jit_event ();
5675 case bp_gnu_ifunc_resolver
:
5676 gnu_ifunc_resolver_stop (b
);
5678 case bp_gnu_ifunc_resolver_return
:
5679 gnu_ifunc_resolver_return_stop (b
);
5685 /* See breakpoint.h. */
5688 bpstat_should_step ()
5690 struct breakpoint
*b
;
5693 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
&& b
->loc
!= NULL
)
5698 /* See breakpoint.h. */
5701 bpstat_causes_stop (bpstat bs
)
5703 for (; bs
!= NULL
; bs
= bs
->next
)
5712 /* Compute a string of spaces suitable to indent the next line
5713 so it starts at the position corresponding to the table column
5714 named COL_NAME in the currently active table of UIOUT. */
5717 wrap_indent_at_field (struct ui_out
*uiout
, const char *col_name
)
5719 static char wrap_indent
[80];
5720 int i
, total_width
, width
, align
;
5724 for (i
= 1; uiout
->query_table_field (i
, &width
, &align
, &text
); i
++)
5726 if (strcmp (text
, col_name
) == 0)
5728 gdb_assert (total_width
< sizeof wrap_indent
);
5729 memset (wrap_indent
, ' ', total_width
);
5730 wrap_indent
[total_width
] = 0;
5735 total_width
+= width
+ 1;
5741 /* Determine if the locations of this breakpoint will have their conditions
5742 evaluated by the target, host or a mix of both. Returns the following:
5744 "host": Host evals condition.
5745 "host or target": Host or Target evals condition.
5746 "target": Target evals condition.
5750 bp_condition_evaluator (struct breakpoint
*b
)
5752 struct bp_location
*bl
;
5753 char host_evals
= 0;
5754 char target_evals
= 0;
5759 if (!is_breakpoint (b
))
5762 if (gdb_evaluates_breakpoint_condition_p ()
5763 || !target_supports_evaluation_of_breakpoint_conditions ())
5764 return condition_evaluation_host
;
5766 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
5768 if (bl
->cond_bytecode
)
5774 if (host_evals
&& target_evals
)
5775 return condition_evaluation_both
;
5776 else if (target_evals
)
5777 return condition_evaluation_target
;
5779 return condition_evaluation_host
;
5782 /* Determine the breakpoint location's condition evaluator. This is
5783 similar to bp_condition_evaluator, but for locations. */
5786 bp_location_condition_evaluator (struct bp_location
*bl
)
5788 if (bl
&& !is_breakpoint (bl
->owner
))
5791 if (gdb_evaluates_breakpoint_condition_p ()
5792 || !target_supports_evaluation_of_breakpoint_conditions ())
5793 return condition_evaluation_host
;
5795 if (bl
&& bl
->cond_bytecode
)
5796 return condition_evaluation_target
;
5798 return condition_evaluation_host
;
5801 /* Print the LOC location out of the list of B->LOC locations. */
5804 print_breakpoint_location (struct breakpoint
*b
,
5805 struct bp_location
*loc
)
5807 struct ui_out
*uiout
= current_uiout
;
5809 scoped_restore_current_program_space restore_pspace
;
5811 if (loc
!= NULL
&& loc
->shlib_disabled
)
5815 set_current_program_space (loc
->pspace
);
5817 if (b
->display_canonical
)
5818 uiout
->field_string ("what", event_location_to_string (b
->location
.get ()));
5819 else if (loc
&& loc
->symtab
)
5821 const struct symbol
*sym
= loc
->symbol
;
5825 uiout
->text ("in ");
5826 uiout
->field_string ("func", sym
->print_name (),
5827 function_name_style
.style ());
5829 uiout
->wrap_hint (wrap_indent_at_field (uiout
, "what"));
5830 uiout
->text ("at ");
5832 uiout
->field_string ("file",
5833 symtab_to_filename_for_display (loc
->symtab
),
5834 file_name_style
.style ());
5837 if (uiout
->is_mi_like_p ())
5838 uiout
->field_string ("fullname", symtab_to_fullname (loc
->symtab
));
5840 uiout
->field_signed ("line", loc
->line_number
);
5846 print_address_symbolic (loc
->gdbarch
, loc
->address
, &stb
,
5848 uiout
->field_stream ("at", stb
);
5852 uiout
->field_string ("pending",
5853 event_location_to_string (b
->location
.get ()));
5854 /* If extra_string is available, it could be holding a condition
5855 or dprintf arguments. In either case, make sure it is printed,
5856 too, but only for non-MI streams. */
5857 if (!uiout
->is_mi_like_p () && b
->extra_string
!= NULL
)
5859 if (b
->type
== bp_dprintf
)
5863 uiout
->text (b
->extra_string
);
5867 if (loc
&& is_breakpoint (b
)
5868 && breakpoint_condition_evaluation_mode () == condition_evaluation_target
5869 && bp_condition_evaluator (b
) == condition_evaluation_both
)
5872 uiout
->field_string ("evaluated-by",
5873 bp_location_condition_evaluator (loc
));
5879 bptype_string (enum bptype type
)
5881 struct ep_type_description
5884 const char *description
;
5886 static struct ep_type_description bptypes
[] =
5888 {bp_none
, "?deleted?"},
5889 {bp_breakpoint
, "breakpoint"},
5890 {bp_hardware_breakpoint
, "hw breakpoint"},
5891 {bp_single_step
, "sw single-step"},
5892 {bp_until
, "until"},
5893 {bp_finish
, "finish"},
5894 {bp_watchpoint
, "watchpoint"},
5895 {bp_hardware_watchpoint
, "hw watchpoint"},
5896 {bp_read_watchpoint
, "read watchpoint"},
5897 {bp_access_watchpoint
, "acc watchpoint"},
5898 {bp_longjmp
, "longjmp"},
5899 {bp_longjmp_resume
, "longjmp resume"},
5900 {bp_longjmp_call_dummy
, "longjmp for call dummy"},
5901 {bp_exception
, "exception"},
5902 {bp_exception_resume
, "exception resume"},
5903 {bp_step_resume
, "step resume"},
5904 {bp_hp_step_resume
, "high-priority step resume"},
5905 {bp_watchpoint_scope
, "watchpoint scope"},
5906 {bp_call_dummy
, "call dummy"},
5907 {bp_std_terminate
, "std::terminate"},
5908 {bp_shlib_event
, "shlib events"},
5909 {bp_thread_event
, "thread events"},
5910 {bp_overlay_event
, "overlay events"},
5911 {bp_longjmp_master
, "longjmp master"},
5912 {bp_std_terminate_master
, "std::terminate master"},
5913 {bp_exception_master
, "exception master"},
5914 {bp_catchpoint
, "catchpoint"},
5915 {bp_tracepoint
, "tracepoint"},
5916 {bp_fast_tracepoint
, "fast tracepoint"},
5917 {bp_static_tracepoint
, "static tracepoint"},
5918 {bp_dprintf
, "dprintf"},
5919 {bp_jit_event
, "jit events"},
5920 {bp_gnu_ifunc_resolver
, "STT_GNU_IFUNC resolver"},
5921 {bp_gnu_ifunc_resolver_return
, "STT_GNU_IFUNC resolver return"},
5924 if (((int) type
>= (sizeof (bptypes
) / sizeof (bptypes
[0])))
5925 || ((int) type
!= bptypes
[(int) type
].type
))
5926 internal_error (__FILE__
, __LINE__
,
5927 _("bptypes table does not describe type #%d."),
5930 return bptypes
[(int) type
].description
;
5933 /* For MI, output a field named 'thread-groups' with a list as the value.
5934 For CLI, prefix the list with the string 'inf'. */
5937 output_thread_groups (struct ui_out
*uiout
,
5938 const char *field_name
,
5939 const std::vector
<int> &inf_nums
,
5942 int is_mi
= uiout
->is_mi_like_p ();
5944 /* For backward compatibility, don't display inferiors in CLI unless
5945 there are several. Always display them for MI. */
5946 if (!is_mi
&& mi_only
)
5949 ui_out_emit_list
list_emitter (uiout
, field_name
);
5951 for (size_t i
= 0; i
< inf_nums
.size (); i
++)
5957 xsnprintf (mi_group
, sizeof (mi_group
), "i%d", inf_nums
[i
]);
5958 uiout
->field_string (NULL
, mi_group
);
5963 uiout
->text (" inf ");
5967 uiout
->text (plongest (inf_nums
[i
]));
5972 /* Print B to gdb_stdout. If RAW_LOC, print raw breakpoint locations
5973 instead of going via breakpoint_ops::print_one. This makes "maint
5974 info breakpoints" show the software breakpoint locations of
5975 catchpoints, which are considered internal implementation
5979 print_one_breakpoint_location (struct breakpoint
*b
,
5980 struct bp_location
*loc
,
5982 struct bp_location
**last_loc
,
5983 int allflag
, bool raw_loc
)
5985 struct command_line
*l
;
5986 static char bpenables
[] = "nynny";
5988 struct ui_out
*uiout
= current_uiout
;
5989 int header_of_multiple
= 0;
5990 int part_of_multiple
= (loc
!= NULL
);
5991 struct value_print_options opts
;
5993 get_user_print_options (&opts
);
5995 gdb_assert (!loc
|| loc_number
!= 0);
5996 /* See comment in print_one_breakpoint concerning treatment of
5997 breakpoints with single disabled location. */
6000 && (b
->loc
->next
!= NULL
|| !b
->loc
->enabled
)))
6001 header_of_multiple
= 1;
6009 if (part_of_multiple
)
6010 uiout
->field_fmt ("number", "%d.%d", b
->number
, loc_number
);
6012 uiout
->field_signed ("number", b
->number
);
6016 if (part_of_multiple
)
6017 uiout
->field_skip ("type");
6019 uiout
->field_string ("type", bptype_string (b
->type
));
6023 if (part_of_multiple
)
6024 uiout
->field_skip ("disp");
6026 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
6030 if (part_of_multiple
)
6031 uiout
->field_string ("enabled", loc
->enabled
? "y" : "n");
6033 uiout
->field_fmt ("enabled", "%c", bpenables
[(int) b
->enable_state
]);
6036 if (!raw_loc
&& b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
6037 b
->ops
->print_one (b
, last_loc
);
6040 if (is_watchpoint (b
))
6042 struct watchpoint
*w
= (struct watchpoint
*) b
;
6044 /* Field 4, the address, is omitted (which makes the columns
6045 not line up too nicely with the headers, but the effect
6046 is relatively readable). */
6047 if (opts
.addressprint
)
6048 uiout
->field_skip ("addr");
6050 uiout
->field_string ("what", w
->exp_string
);
6052 else if (!is_catchpoint (b
) || is_exception_catchpoint (b
)
6053 || is_ada_exception_catchpoint (b
))
6055 if (opts
.addressprint
)
6058 if (header_of_multiple
)
6059 uiout
->field_string ("addr", "<MULTIPLE>",
6060 metadata_style
.style ());
6061 else if (b
->loc
== NULL
|| loc
->shlib_disabled
)
6062 uiout
->field_string ("addr", "<PENDING>",
6063 metadata_style
.style ());
6065 uiout
->field_core_addr ("addr",
6066 loc
->gdbarch
, loc
->address
);
6069 if (!header_of_multiple
)
6070 print_breakpoint_location (b
, loc
);
6076 if (loc
!= NULL
&& !header_of_multiple
)
6078 std::vector
<int> inf_nums
;
6081 for (inferior
*inf
: all_inferiors ())
6083 if (inf
->pspace
== loc
->pspace
)
6084 inf_nums
.push_back (inf
->num
);
6087 /* For backward compatibility, don't display inferiors in CLI unless
6088 there are several. Always display for MI. */
6090 || (!gdbarch_has_global_breakpoints (target_gdbarch ())
6091 && (number_of_program_spaces () > 1
6092 || number_of_inferiors () > 1)
6093 /* LOC is for existing B, it cannot be in
6094 moribund_locations and thus having NULL OWNER. */
6095 && loc
->owner
->type
!= bp_catchpoint
))
6097 output_thread_groups (uiout
, "thread-groups", inf_nums
, mi_only
);
6100 if (!part_of_multiple
)
6102 if (b
->thread
!= -1)
6104 /* FIXME: This seems to be redundant and lost here; see the
6105 "stop only in" line a little further down. */
6106 uiout
->text (" thread ");
6107 uiout
->field_signed ("thread", b
->thread
);
6109 else if (b
->task
!= 0)
6111 uiout
->text (" task ");
6112 uiout
->field_signed ("task", b
->task
);
6118 if (!part_of_multiple
)
6119 b
->ops
->print_one_detail (b
, uiout
);
6121 if (part_of_multiple
&& frame_id_p (b
->frame_id
))
6124 uiout
->text ("\tstop only in stack frame at ");
6125 /* FIXME: cagney/2002-12-01: Shouldn't be poking around inside
6127 uiout
->field_core_addr ("frame",
6128 b
->gdbarch
, b
->frame_id
.stack_addr
);
6132 if (!part_of_multiple
&& b
->cond_string
)
6135 if (is_tracepoint (b
))
6136 uiout
->text ("\ttrace only if ");
6138 uiout
->text ("\tstop only if ");
6139 uiout
->field_string ("cond", b
->cond_string
);
6141 /* Print whether the target is doing the breakpoint's condition
6142 evaluation. If GDB is doing the evaluation, don't print anything. */
6143 if (is_breakpoint (b
)
6144 && breakpoint_condition_evaluation_mode ()
6145 == condition_evaluation_target
)
6147 uiout
->message (" (%pF evals)",
6148 string_field ("evaluated-by",
6149 bp_condition_evaluator (b
)));
6154 if (!part_of_multiple
&& b
->thread
!= -1)
6156 /* FIXME should make an annotation for this. */
6157 uiout
->text ("\tstop only in thread ");
6158 if (uiout
->is_mi_like_p ())
6159 uiout
->field_signed ("thread", b
->thread
);
6162 struct thread_info
*thr
= find_thread_global_id (b
->thread
);
6164 uiout
->field_string ("thread", print_thread_id (thr
));
6169 if (!part_of_multiple
)
6173 /* FIXME should make an annotation for this. */
6174 if (is_catchpoint (b
))
6175 uiout
->text ("\tcatchpoint");
6176 else if (is_tracepoint (b
))
6177 uiout
->text ("\ttracepoint");
6179 uiout
->text ("\tbreakpoint");
6180 uiout
->text (" already hit ");
6181 uiout
->field_signed ("times", b
->hit_count
);
6182 if (b
->hit_count
== 1)
6183 uiout
->text (" time\n");
6185 uiout
->text (" times\n");
6189 /* Output the count also if it is zero, but only if this is mi. */
6190 if (uiout
->is_mi_like_p ())
6191 uiout
->field_signed ("times", b
->hit_count
);
6195 if (!part_of_multiple
&& b
->ignore_count
)
6198 uiout
->message ("\tignore next %pF hits\n",
6199 signed_field ("ignore", b
->ignore_count
));
6202 /* Note that an enable count of 1 corresponds to "enable once"
6203 behavior, which is reported by the combination of enablement and
6204 disposition, so we don't need to mention it here. */
6205 if (!part_of_multiple
&& b
->enable_count
> 1)
6208 uiout
->text ("\tdisable after ");
6209 /* Tweak the wording to clarify that ignore and enable counts
6210 are distinct, and have additive effect. */
6211 if (b
->ignore_count
)
6212 uiout
->text ("additional ");
6214 uiout
->text ("next ");
6215 uiout
->field_signed ("enable", b
->enable_count
);
6216 uiout
->text (" hits\n");
6219 if (!part_of_multiple
&& is_tracepoint (b
))
6221 struct tracepoint
*tp
= (struct tracepoint
*) b
;
6223 if (tp
->traceframe_usage
)
6225 uiout
->text ("\ttrace buffer usage ");
6226 uiout
->field_signed ("traceframe-usage", tp
->traceframe_usage
);
6227 uiout
->text (" bytes\n");
6231 l
= b
->commands
? b
->commands
.get () : NULL
;
6232 if (!part_of_multiple
&& l
)
6235 ui_out_emit_tuple
tuple_emitter (uiout
, "script");
6236 print_command_lines (uiout
, l
, 4);
6239 if (is_tracepoint (b
))
6241 struct tracepoint
*t
= (struct tracepoint
*) b
;
6243 if (!part_of_multiple
&& t
->pass_count
)
6245 annotate_field (10);
6246 uiout
->text ("\tpass count ");
6247 uiout
->field_signed ("pass", t
->pass_count
);
6248 uiout
->text (" \n");
6251 /* Don't display it when tracepoint or tracepoint location is
6253 if (!header_of_multiple
&& loc
!= NULL
&& !loc
->shlib_disabled
)
6255 annotate_field (11);
6257 if (uiout
->is_mi_like_p ())
6258 uiout
->field_string ("installed",
6259 loc
->inserted
? "y" : "n");
6265 uiout
->text ("\tnot ");
6266 uiout
->text ("installed on target\n");
6271 if (uiout
->is_mi_like_p () && !part_of_multiple
)
6273 if (is_watchpoint (b
))
6275 struct watchpoint
*w
= (struct watchpoint
*) b
;
6277 uiout
->field_string ("original-location", w
->exp_string
);
6279 else if (b
->location
!= NULL
6280 && event_location_to_string (b
->location
.get ()) != NULL
)
6281 uiout
->field_string ("original-location",
6282 event_location_to_string (b
->location
.get ()));
6286 /* See breakpoint.h. */
6288 bool fix_multi_location_breakpoint_output_globally
= false;
6291 print_one_breakpoint (struct breakpoint
*b
,
6292 struct bp_location
**last_loc
,
6295 struct ui_out
*uiout
= current_uiout
;
6296 bool use_fixed_output
6297 = (uiout
->test_flags (fix_multi_location_breakpoint_output
)
6298 || fix_multi_location_breakpoint_output_globally
);
6300 gdb::optional
<ui_out_emit_tuple
> bkpt_tuple_emitter (gdb::in_place
, uiout
, "bkpt");
6301 print_one_breakpoint_location (b
, NULL
, 0, last_loc
, allflag
, false);
6303 /* The mi2 broken format: the main breakpoint tuple ends here, the locations
6305 if (!use_fixed_output
)
6306 bkpt_tuple_emitter
.reset ();
6308 /* If this breakpoint has custom print function,
6309 it's already printed. Otherwise, print individual
6310 locations, if any. */
6312 || b
->ops
->print_one
== NULL
6315 /* If breakpoint has a single location that is disabled, we
6316 print it as if it had several locations, since otherwise it's
6317 hard to represent "breakpoint enabled, location disabled"
6320 Note that while hardware watchpoints have several locations
6321 internally, that's not a property exposed to users.
6323 Likewise, while catchpoints may be implemented with
6324 breakpoints (e.g., catch throw), that's not a property
6325 exposed to users. We do however display the internal
6326 breakpoint locations with "maint info breakpoints". */
6327 if (!is_hardware_watchpoint (b
)
6328 && (!is_catchpoint (b
) || is_exception_catchpoint (b
)
6329 || is_ada_exception_catchpoint (b
))
6331 || (b
->loc
&& (b
->loc
->next
|| !b
->loc
->enabled
))))
6333 gdb::optional
<ui_out_emit_list
> locations_list
;
6335 /* For MI version <= 2, keep the behavior where GDB outputs an invalid
6336 MI record. For later versions, place breakpoint locations in a
6338 if (uiout
->is_mi_like_p () && use_fixed_output
)
6339 locations_list
.emplace (uiout
, "locations");
6342 for (bp_location
*loc
= b
->loc
; loc
!= NULL
; loc
= loc
->next
, ++n
)
6344 ui_out_emit_tuple
loc_tuple_emitter (uiout
, NULL
);
6345 print_one_breakpoint_location (b
, loc
, n
, last_loc
,
6353 breakpoint_address_bits (struct breakpoint
*b
)
6355 int print_address_bits
= 0;
6356 struct bp_location
*loc
;
6358 /* Software watchpoints that aren't watching memory don't have an
6359 address to print. */
6360 if (is_no_memory_software_watchpoint (b
))
6363 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
6367 addr_bit
= gdbarch_addr_bit (loc
->gdbarch
);
6368 if (addr_bit
> print_address_bits
)
6369 print_address_bits
= addr_bit
;
6372 return print_address_bits
;
6375 /* See breakpoint.h. */
6378 print_breakpoint (breakpoint
*b
)
6380 struct bp_location
*dummy_loc
= NULL
;
6381 print_one_breakpoint (b
, &dummy_loc
, 0);
6384 /* Return true if this breakpoint was set by the user, false if it is
6385 internal or momentary. */
6388 user_breakpoint_p (struct breakpoint
*b
)
6390 return b
->number
> 0;
6393 /* See breakpoint.h. */
6396 pending_breakpoint_p (struct breakpoint
*b
)
6398 return b
->loc
== NULL
;
6401 /* Print information on breakpoints (including watchpoints and tracepoints).
6403 If non-NULL, BP_NUM_LIST is a list of numbers and number ranges as
6404 understood by number_or_range_parser. Only breakpoints included in this
6405 list are then printed.
6407 If SHOW_INTERNAL is true, print internal breakpoints.
6409 If FILTER is non-NULL, call it on each breakpoint and only include the
6410 ones for which it returns true.
6412 Return the total number of breakpoints listed. */
6415 breakpoint_1 (const char *bp_num_list
, bool show_internal
,
6416 bool (*filter
) (const struct breakpoint
*))
6418 struct breakpoint
*b
;
6419 struct bp_location
*last_loc
= NULL
;
6420 int nr_printable_breakpoints
;
6421 struct value_print_options opts
;
6422 int print_address_bits
= 0;
6423 int print_type_col_width
= 14;
6424 struct ui_out
*uiout
= current_uiout
;
6426 get_user_print_options (&opts
);
6428 /* Compute the number of rows in the table, as well as the size
6429 required for address fields. */
6430 nr_printable_breakpoints
= 0;
6433 /* If we have a filter, only list the breakpoints it accepts. */
6434 if (filter
&& !filter (b
))
6437 /* If we have a BP_NUM_LIST string, it is a list of breakpoints to
6438 accept. Skip the others. */
6439 if (bp_num_list
!= NULL
&& *bp_num_list
!= '\0')
6441 if (show_internal
&& parse_and_eval_long (bp_num_list
) != b
->number
)
6443 if (!show_internal
&& !number_is_in_list (bp_num_list
, b
->number
))
6447 if (show_internal
|| user_breakpoint_p (b
))
6449 int addr_bit
, type_len
;
6451 addr_bit
= breakpoint_address_bits (b
);
6452 if (addr_bit
> print_address_bits
)
6453 print_address_bits
= addr_bit
;
6455 type_len
= strlen (bptype_string (b
->type
));
6456 if (type_len
> print_type_col_width
)
6457 print_type_col_width
= type_len
;
6459 nr_printable_breakpoints
++;
6464 ui_out_emit_table
table_emitter (uiout
,
6465 opts
.addressprint
? 6 : 5,
6466 nr_printable_breakpoints
,
6469 if (nr_printable_breakpoints
> 0)
6470 annotate_breakpoints_headers ();
6471 if (nr_printable_breakpoints
> 0)
6473 uiout
->table_header (7, ui_left
, "number", "Num"); /* 1 */
6474 if (nr_printable_breakpoints
> 0)
6476 uiout
->table_header (print_type_col_width
, ui_left
, "type", "Type"); /* 2 */
6477 if (nr_printable_breakpoints
> 0)
6479 uiout
->table_header (4, ui_left
, "disp", "Disp"); /* 3 */
6480 if (nr_printable_breakpoints
> 0)
6482 uiout
->table_header (3, ui_left
, "enabled", "Enb"); /* 4 */
6483 if (opts
.addressprint
)
6485 if (nr_printable_breakpoints
> 0)
6487 if (print_address_bits
<= 32)
6488 uiout
->table_header (10, ui_left
, "addr", "Address"); /* 5 */
6490 uiout
->table_header (18, ui_left
, "addr", "Address"); /* 5 */
6492 if (nr_printable_breakpoints
> 0)
6494 uiout
->table_header (40, ui_noalign
, "what", "What"); /* 6 */
6495 uiout
->table_body ();
6496 if (nr_printable_breakpoints
> 0)
6497 annotate_breakpoints_table ();
6502 /* If we have a filter, only list the breakpoints it accepts. */
6503 if (filter
&& !filter (b
))
6506 /* If we have a BP_NUM_LIST string, it is a list of breakpoints to
6507 accept. Skip the others. */
6509 if (bp_num_list
!= NULL
&& *bp_num_list
!= '\0')
6511 if (show_internal
) /* maintenance info breakpoint */
6513 if (parse_and_eval_long (bp_num_list
) != b
->number
)
6516 else /* all others */
6518 if (!number_is_in_list (bp_num_list
, b
->number
))
6522 /* We only print out user settable breakpoints unless the
6523 show_internal is set. */
6524 if (show_internal
|| user_breakpoint_p (b
))
6525 print_one_breakpoint (b
, &last_loc
, show_internal
);
6529 if (nr_printable_breakpoints
== 0)
6531 /* If there's a filter, let the caller decide how to report
6535 if (bp_num_list
== NULL
|| *bp_num_list
== '\0')
6536 uiout
->message ("No breakpoints or watchpoints.\n");
6538 uiout
->message ("No breakpoint or watchpoint matching '%s'.\n",
6544 if (last_loc
&& !server_command
)
6545 set_next_address (last_loc
->gdbarch
, last_loc
->address
);
6548 /* FIXME? Should this be moved up so that it is only called when
6549 there have been breakpoints? */
6550 annotate_breakpoints_table_end ();
6552 return nr_printable_breakpoints
;
6555 /* Display the value of default-collect in a way that is generally
6556 compatible with the breakpoint list. */
6559 default_collect_info (void)
6561 struct ui_out
*uiout
= current_uiout
;
6563 /* If it has no value (which is frequently the case), say nothing; a
6564 message like "No default-collect." gets in user's face when it's
6566 if (!*default_collect
)
6569 /* The following phrase lines up nicely with per-tracepoint collect
6571 uiout
->text ("default collect ");
6572 uiout
->field_string ("default-collect", default_collect
);
6573 uiout
->text (" \n");
6577 info_breakpoints_command (const char *args
, int from_tty
)
6579 breakpoint_1 (args
, false, NULL
);
6581 default_collect_info ();
6585 info_watchpoints_command (const char *args
, int from_tty
)
6587 int num_printed
= breakpoint_1 (args
, false, is_watchpoint
);
6588 struct ui_out
*uiout
= current_uiout
;
6590 if (num_printed
== 0)
6592 if (args
== NULL
|| *args
== '\0')
6593 uiout
->message ("No watchpoints.\n");
6595 uiout
->message ("No watchpoint matching '%s'.\n", args
);
6600 maintenance_info_breakpoints (const char *args
, int from_tty
)
6602 breakpoint_1 (args
, true, NULL
);
6604 default_collect_info ();
6608 breakpoint_has_pc (struct breakpoint
*b
,
6609 struct program_space
*pspace
,
6610 CORE_ADDR pc
, struct obj_section
*section
)
6612 struct bp_location
*bl
= b
->loc
;
6614 for (; bl
; bl
= bl
->next
)
6616 if (bl
->pspace
== pspace
6617 && bl
->address
== pc
6618 && (!overlay_debugging
|| bl
->section
== section
))
6624 /* Print a message describing any user-breakpoints set at PC. This
6625 concerns with logical breakpoints, so we match program spaces, not
6629 describe_other_breakpoints (struct gdbarch
*gdbarch
,
6630 struct program_space
*pspace
, CORE_ADDR pc
,
6631 struct obj_section
*section
, int thread
)
6634 struct breakpoint
*b
;
6637 others
+= (user_breakpoint_p (b
)
6638 && breakpoint_has_pc (b
, pspace
, pc
, section
));
6642 printf_filtered (_("Note: breakpoint "));
6643 else /* if (others == ???) */
6644 printf_filtered (_("Note: breakpoints "));
6646 if (user_breakpoint_p (b
) && breakpoint_has_pc (b
, pspace
, pc
, section
))
6649 printf_filtered ("%d", b
->number
);
6650 if (b
->thread
== -1 && thread
!= -1)
6651 printf_filtered (" (all threads)");
6652 else if (b
->thread
!= -1)
6653 printf_filtered (" (thread %d)", b
->thread
);
6654 printf_filtered ("%s%s ",
6655 ((b
->enable_state
== bp_disabled
6656 || b
->enable_state
== bp_call_disabled
)
6660 : ((others
== 1) ? " and" : ""));
6662 current_uiout
->message (_("also set at pc %ps.\n"),
6663 styled_string (address_style
.style (),
6664 paddress (gdbarch
, pc
)));
6669 /* Return true iff it is meaningful to use the address member of LOC.
6670 For some breakpoint types, the locations' address members are
6671 irrelevant and it makes no sense to attempt to compare them to
6672 other addresses (or use them for any other purpose either).
6674 More specifically, software watchpoints and catchpoints that are
6675 not backed by breakpoints always have a zero valued location
6676 address and we don't want to mark breakpoints of any of these types
6677 to be a duplicate of an actual breakpoint location at address
6681 bl_address_is_meaningful (bp_location
*loc
)
6683 return loc
->loc_type
!= bp_loc_other
;
6686 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
6687 true if LOC1 and LOC2 represent the same watchpoint location. */
6690 watchpoint_locations_match (struct bp_location
*loc1
,
6691 struct bp_location
*loc2
)
6693 struct watchpoint
*w1
= (struct watchpoint
*) loc1
->owner
;
6694 struct watchpoint
*w2
= (struct watchpoint
*) loc2
->owner
;
6696 /* Both of them must exist. */
6697 gdb_assert (w1
!= NULL
);
6698 gdb_assert (w2
!= NULL
);
6700 /* If the target can evaluate the condition expression in hardware,
6701 then we we need to insert both watchpoints even if they are at
6702 the same place. Otherwise the watchpoint will only trigger when
6703 the condition of whichever watchpoint was inserted evaluates to
6704 true, not giving a chance for GDB to check the condition of the
6705 other watchpoint. */
6707 && target_can_accel_watchpoint_condition (loc1
->address
,
6709 loc1
->watchpoint_type
,
6710 w1
->cond_exp
.get ()))
6712 && target_can_accel_watchpoint_condition (loc2
->address
,
6714 loc2
->watchpoint_type
,
6715 w2
->cond_exp
.get ())))
6718 /* Note that this checks the owner's type, not the location's. In
6719 case the target does not support read watchpoints, but does
6720 support access watchpoints, we'll have bp_read_watchpoint
6721 watchpoints with hw_access locations. Those should be considered
6722 duplicates of hw_read locations. The hw_read locations will
6723 become hw_access locations later. */
6724 return (loc1
->owner
->type
== loc2
->owner
->type
6725 && loc1
->pspace
->aspace
== loc2
->pspace
->aspace
6726 && loc1
->address
== loc2
->address
6727 && loc1
->length
== loc2
->length
);
6730 /* See breakpoint.h. */
6733 breakpoint_address_match (const address_space
*aspace1
, CORE_ADDR addr1
,
6734 const address_space
*aspace2
, CORE_ADDR addr2
)
6736 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
6737 || aspace1
== aspace2
)
6741 /* Returns true if {ASPACE2,ADDR2} falls within the range determined by
6742 {ASPACE1,ADDR1,LEN1}. In most targets, this can only be true if ASPACE1
6743 matches ASPACE2. On targets that have global breakpoints, the address
6744 space doesn't really matter. */
6747 breakpoint_address_match_range (const address_space
*aspace1
,
6749 int len1
, const address_space
*aspace2
,
6752 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
6753 || aspace1
== aspace2
)
6754 && addr2
>= addr1
&& addr2
< addr1
+ len1
);
6757 /* Returns true if {ASPACE,ADDR} matches the breakpoint BL. BL may be
6758 a ranged breakpoint. In most targets, a match happens only if ASPACE
6759 matches the breakpoint's address space. On targets that have global
6760 breakpoints, the address space doesn't really matter. */
6763 breakpoint_location_address_match (struct bp_location
*bl
,
6764 const address_space
*aspace
,
6767 return (breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
6770 && breakpoint_address_match_range (bl
->pspace
->aspace
,
6771 bl
->address
, bl
->length
,
6775 /* Returns true if the [ADDR,ADDR+LEN) range in ASPACE overlaps
6776 breakpoint BL. BL may be a ranged breakpoint. In most targets, a
6777 match happens only if ASPACE matches the breakpoint's address
6778 space. On targets that have global breakpoints, the address space
6779 doesn't really matter. */
6782 breakpoint_location_address_range_overlap (struct bp_location
*bl
,
6783 const address_space
*aspace
,
6784 CORE_ADDR addr
, int len
)
6786 if (gdbarch_has_global_breakpoints (target_gdbarch ())
6787 || bl
->pspace
->aspace
== aspace
)
6789 int bl_len
= bl
->length
!= 0 ? bl
->length
: 1;
6791 if (mem_ranges_overlap (addr
, len
, bl
->address
, bl_len
))
6797 /* If LOC1 and LOC2's owners are not tracepoints, returns false directly.
6798 Then, if LOC1 and LOC2 represent the same tracepoint location, returns
6799 true, otherwise returns false. */
6802 tracepoint_locations_match (struct bp_location
*loc1
,
6803 struct bp_location
*loc2
)
6805 if (is_tracepoint (loc1
->owner
) && is_tracepoint (loc2
->owner
))
6806 /* Since tracepoint locations are never duplicated with others', tracepoint
6807 locations at the same address of different tracepoints are regarded as
6808 different locations. */
6809 return (loc1
->address
== loc2
->address
&& loc1
->owner
== loc2
->owner
);
6814 /* Assuming LOC1 and LOC2's types' have meaningful target addresses
6815 (bl_address_is_meaningful), returns true if LOC1 and LOC2 represent
6816 the same location. */
6819 breakpoint_locations_match (struct bp_location
*loc1
,
6820 struct bp_location
*loc2
)
6822 int hw_point1
, hw_point2
;
6824 /* Both of them must not be in moribund_locations. */
6825 gdb_assert (loc1
->owner
!= NULL
);
6826 gdb_assert (loc2
->owner
!= NULL
);
6828 hw_point1
= is_hardware_watchpoint (loc1
->owner
);
6829 hw_point2
= is_hardware_watchpoint (loc2
->owner
);
6831 if (hw_point1
!= hw_point2
)
6834 return watchpoint_locations_match (loc1
, loc2
);
6835 else if (is_tracepoint (loc1
->owner
) || is_tracepoint (loc2
->owner
))
6836 return tracepoint_locations_match (loc1
, loc2
);
6838 /* We compare bp_location.length in order to cover ranged breakpoints. */
6839 return (breakpoint_address_match (loc1
->pspace
->aspace
, loc1
->address
,
6840 loc2
->pspace
->aspace
, loc2
->address
)
6841 && loc1
->length
== loc2
->length
);
6845 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
6846 int bnum
, int have_bnum
)
6848 /* The longest string possibly returned by hex_string_custom
6849 is 50 chars. These must be at least that big for safety. */
6853 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
6854 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
6856 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
6857 bnum
, astr1
, astr2
);
6859 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
6862 /* Adjust a breakpoint's address to account for architectural
6863 constraints on breakpoint placement. Return the adjusted address.
6864 Note: Very few targets require this kind of adjustment. For most
6865 targets, this function is simply the identity function. */
6868 adjust_breakpoint_address (struct gdbarch
*gdbarch
,
6869 CORE_ADDR bpaddr
, enum bptype bptype
)
6871 if (bptype
== bp_watchpoint
6872 || bptype
== bp_hardware_watchpoint
6873 || bptype
== bp_read_watchpoint
6874 || bptype
== bp_access_watchpoint
6875 || bptype
== bp_catchpoint
)
6877 /* Watchpoints and the various bp_catch_* eventpoints should not
6878 have their addresses modified. */
6881 else if (bptype
== bp_single_step
)
6883 /* Single-step breakpoints should not have their addresses
6884 modified. If there's any architectural constrain that
6885 applies to this address, then it should have already been
6886 taken into account when the breakpoint was created in the
6887 first place. If we didn't do this, stepping through e.g.,
6888 Thumb-2 IT blocks would break. */
6893 CORE_ADDR adjusted_bpaddr
= bpaddr
;
6895 if (gdbarch_adjust_breakpoint_address_p (gdbarch
))
6897 /* Some targets have architectural constraints on the placement
6898 of breakpoint instructions. Obtain the adjusted address. */
6899 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (gdbarch
, bpaddr
);
6902 adjusted_bpaddr
= address_significant (gdbarch
, adjusted_bpaddr
);
6904 /* An adjusted breakpoint address can significantly alter
6905 a user's expectations. Print a warning if an adjustment
6907 if (adjusted_bpaddr
!= bpaddr
)
6908 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
6910 return adjusted_bpaddr
;
6915 bp_location_from_bp_type (bptype type
)
6920 case bp_single_step
:
6924 case bp_longjmp_resume
:
6925 case bp_longjmp_call_dummy
:
6927 case bp_exception_resume
:
6928 case bp_step_resume
:
6929 case bp_hp_step_resume
:
6930 case bp_watchpoint_scope
:
6932 case bp_std_terminate
:
6933 case bp_shlib_event
:
6934 case bp_thread_event
:
6935 case bp_overlay_event
:
6937 case bp_longjmp_master
:
6938 case bp_std_terminate_master
:
6939 case bp_exception_master
:
6940 case bp_gnu_ifunc_resolver
:
6941 case bp_gnu_ifunc_resolver_return
:
6943 return bp_loc_software_breakpoint
;
6944 case bp_hardware_breakpoint
:
6945 return bp_loc_hardware_breakpoint
;
6946 case bp_hardware_watchpoint
:
6947 case bp_read_watchpoint
:
6948 case bp_access_watchpoint
:
6949 return bp_loc_hardware_watchpoint
;
6953 case bp_fast_tracepoint
:
6954 case bp_static_tracepoint
:
6955 return bp_loc_other
;
6957 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
6961 bp_location::bp_location (breakpoint
*owner
, bp_loc_type type
)
6963 this->owner
= owner
;
6964 this->cond_bytecode
= NULL
;
6965 this->shlib_disabled
= 0;
6968 this->loc_type
= type
;
6970 if (this->loc_type
== bp_loc_software_breakpoint
6971 || this->loc_type
== bp_loc_hardware_breakpoint
)
6972 mark_breakpoint_location_modified (this);
6977 bp_location::bp_location (breakpoint
*owner
)
6978 : bp_location::bp_location (owner
,
6979 bp_location_from_bp_type (owner
->type
))
6983 /* Allocate a struct bp_location. */
6985 static struct bp_location
*
6986 allocate_bp_location (struct breakpoint
*bpt
)
6988 return bpt
->ops
->allocate_location (bpt
);
6992 free_bp_location (struct bp_location
*loc
)
6997 /* Increment reference count. */
7000 incref_bp_location (struct bp_location
*bl
)
7005 /* Decrement reference count. If the reference count reaches 0,
7006 destroy the bp_location. Sets *BLP to NULL. */
7009 decref_bp_location (struct bp_location
**blp
)
7011 gdb_assert ((*blp
)->refc
> 0);
7013 if (--(*blp
)->refc
== 0)
7014 free_bp_location (*blp
);
7018 /* Add breakpoint B at the end of the global breakpoint chain. */
7021 add_to_breakpoint_chain (std::unique_ptr
<breakpoint
> &&b
)
7023 struct breakpoint
*b1
;
7024 struct breakpoint
*result
= b
.get ();
7026 /* Add this breakpoint to the end of the chain so that a list of
7027 breakpoints will come out in order of increasing numbers. */
7029 b1
= breakpoint_chain
;
7031 breakpoint_chain
= b
.release ();
7036 b1
->next
= b
.release ();
7042 /* Initializes breakpoint B with type BPTYPE and no locations yet. */
7045 init_raw_breakpoint_without_location (struct breakpoint
*b
,
7046 struct gdbarch
*gdbarch
,
7048 const struct breakpoint_ops
*ops
)
7050 gdb_assert (ops
!= NULL
);
7054 b
->gdbarch
= gdbarch
;
7055 b
->language
= current_language
->la_language
;
7056 b
->input_radix
= input_radix
;
7057 b
->related_breakpoint
= b
;
7060 /* Helper to set_raw_breakpoint below. Creates a breakpoint
7061 that has type BPTYPE and has no locations as yet. */
7063 static struct breakpoint
*
7064 set_raw_breakpoint_without_location (struct gdbarch
*gdbarch
,
7066 const struct breakpoint_ops
*ops
)
7068 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (bptype
);
7070 init_raw_breakpoint_without_location (b
.get (), gdbarch
, bptype
, ops
);
7071 return add_to_breakpoint_chain (std::move (b
));
7074 /* Initialize loc->function_name. */
7077 set_breakpoint_location_function (struct bp_location
*loc
)
7079 gdb_assert (loc
->owner
!= NULL
);
7081 if (loc
->owner
->type
== bp_breakpoint
7082 || loc
->owner
->type
== bp_hardware_breakpoint
7083 || is_tracepoint (loc
->owner
))
7085 const char *function_name
;
7087 if (loc
->msymbol
!= NULL
7088 && (MSYMBOL_TYPE (loc
->msymbol
) == mst_text_gnu_ifunc
7089 || MSYMBOL_TYPE (loc
->msymbol
) == mst_data_gnu_ifunc
))
7091 struct breakpoint
*b
= loc
->owner
;
7093 function_name
= loc
->msymbol
->linkage_name ();
7095 if (b
->type
== bp_breakpoint
&& b
->loc
== loc
7096 && loc
->next
== NULL
&& b
->related_breakpoint
== b
)
7098 /* Create only the whole new breakpoint of this type but do not
7099 mess more complicated breakpoints with multiple locations. */
7100 b
->type
= bp_gnu_ifunc_resolver
;
7101 /* Remember the resolver's address for use by the return
7103 loc
->related_address
= loc
->address
;
7107 find_pc_partial_function (loc
->address
, &function_name
, NULL
, NULL
);
7110 loc
->function_name
= xstrdup (function_name
);
7114 /* Attempt to determine architecture of location identified by SAL. */
7116 get_sal_arch (struct symtab_and_line sal
)
7119 return sal
.section
->objfile
->arch ();
7121 return SYMTAB_OBJFILE (sal
.symtab
)->arch ();
7126 /* Low level routine for partially initializing a breakpoint of type
7127 BPTYPE. The newly created breakpoint's address, section, source
7128 file name, and line number are provided by SAL.
7130 It is expected that the caller will complete the initialization of
7131 the newly created breakpoint struct as well as output any status
7132 information regarding the creation of a new breakpoint. */
7135 init_raw_breakpoint (struct breakpoint
*b
, struct gdbarch
*gdbarch
,
7136 struct symtab_and_line sal
, enum bptype bptype
,
7137 const struct breakpoint_ops
*ops
)
7139 init_raw_breakpoint_without_location (b
, gdbarch
, bptype
, ops
);
7141 add_location_to_breakpoint (b
, &sal
);
7143 if (bptype
!= bp_catchpoint
)
7144 gdb_assert (sal
.pspace
!= NULL
);
7146 /* Store the program space that was used to set the breakpoint,
7147 except for ordinary breakpoints, which are independent of the
7149 if (bptype
!= bp_breakpoint
&& bptype
!= bp_hardware_breakpoint
)
7150 b
->pspace
= sal
.pspace
;
7153 /* set_raw_breakpoint is a low level routine for allocating and
7154 partially initializing a breakpoint of type BPTYPE. The newly
7155 created breakpoint's address, section, source file name, and line
7156 number are provided by SAL. The newly created and partially
7157 initialized breakpoint is added to the breakpoint chain and
7158 is also returned as the value of this function.
7160 It is expected that the caller will complete the initialization of
7161 the newly created breakpoint struct as well as output any status
7162 information regarding the creation of a new breakpoint. In
7163 particular, set_raw_breakpoint does NOT set the breakpoint
7164 number! Care should be taken to not allow an error to occur
7165 prior to completing the initialization of the breakpoint. If this
7166 should happen, a bogus breakpoint will be left on the chain. */
7169 set_raw_breakpoint (struct gdbarch
*gdbarch
,
7170 struct symtab_and_line sal
, enum bptype bptype
,
7171 const struct breakpoint_ops
*ops
)
7173 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (bptype
);
7175 init_raw_breakpoint (b
.get (), gdbarch
, sal
, bptype
, ops
);
7176 return add_to_breakpoint_chain (std::move (b
));
7179 /* Call this routine when stepping and nexting to enable a breakpoint
7180 if we do a longjmp() or 'throw' in TP. FRAME is the frame which
7181 initiated the operation. */
7184 set_longjmp_breakpoint (struct thread_info
*tp
, struct frame_id frame
)
7186 struct breakpoint
*b
, *b_tmp
;
7187 int thread
= tp
->global_num
;
7189 /* To avoid having to rescan all objfile symbols at every step,
7190 we maintain a list of continually-inserted but always disabled
7191 longjmp "master" breakpoints. Here, we simply create momentary
7192 clones of those and enable them for the requested thread. */
7193 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7194 if (b
->pspace
== current_program_space
7195 && (b
->type
== bp_longjmp_master
7196 || b
->type
== bp_exception_master
))
7198 enum bptype type
= b
->type
== bp_longjmp_master
? bp_longjmp
: bp_exception
;
7199 struct breakpoint
*clone
;
7201 /* longjmp_breakpoint_ops ensures INITIATING_FRAME is cleared again
7202 after their removal. */
7203 clone
= momentary_breakpoint_from_master (b
, type
,
7204 &momentary_breakpoint_ops
, 1);
7205 clone
->thread
= thread
;
7208 tp
->initiating_frame
= frame
;
7211 /* Delete all longjmp breakpoints from THREAD. */
7213 delete_longjmp_breakpoint (int thread
)
7215 struct breakpoint
*b
, *b_tmp
;
7217 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7218 if (b
->type
== bp_longjmp
|| b
->type
== bp_exception
)
7220 if (b
->thread
== thread
)
7221 delete_breakpoint (b
);
7226 delete_longjmp_breakpoint_at_next_stop (int thread
)
7228 struct breakpoint
*b
, *b_tmp
;
7230 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7231 if (b
->type
== bp_longjmp
|| b
->type
== bp_exception
)
7233 if (b
->thread
== thread
)
7234 b
->disposition
= disp_del_at_next_stop
;
7238 /* Place breakpoints of type bp_longjmp_call_dummy to catch longjmp for
7239 INFERIOR_PTID thread. Chain them all by RELATED_BREAKPOINT and return
7240 pointer to any of them. Return NULL if this system cannot place longjmp
7244 set_longjmp_breakpoint_for_call_dummy (void)
7246 struct breakpoint
*b
, *retval
= NULL
;
7249 if (b
->pspace
== current_program_space
&& b
->type
== bp_longjmp_master
)
7251 struct breakpoint
*new_b
;
7253 new_b
= momentary_breakpoint_from_master (b
, bp_longjmp_call_dummy
,
7254 &momentary_breakpoint_ops
,
7256 new_b
->thread
= inferior_thread ()->global_num
;
7258 /* Link NEW_B into the chain of RETVAL breakpoints. */
7260 gdb_assert (new_b
->related_breakpoint
== new_b
);
7263 new_b
->related_breakpoint
= retval
;
7264 while (retval
->related_breakpoint
!= new_b
->related_breakpoint
)
7265 retval
= retval
->related_breakpoint
;
7266 retval
->related_breakpoint
= new_b
;
7272 /* Verify all existing dummy frames and their associated breakpoints for
7273 TP. Remove those which can no longer be found in the current frame
7276 You should call this function only at places where it is safe to currently
7277 unwind the whole stack. Failed stack unwind would discard live dummy
7281 check_longjmp_breakpoint_for_call_dummy (struct thread_info
*tp
)
7283 struct breakpoint
*b
, *b_tmp
;
7285 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7286 if (b
->type
== bp_longjmp_call_dummy
&& b
->thread
== tp
->global_num
)
7288 struct breakpoint
*dummy_b
= b
->related_breakpoint
;
7290 while (dummy_b
!= b
&& dummy_b
->type
!= bp_call_dummy
)
7291 dummy_b
= dummy_b
->related_breakpoint
;
7292 if (dummy_b
->type
!= bp_call_dummy
7293 || frame_find_by_id (dummy_b
->frame_id
) != NULL
)
7296 dummy_frame_discard (dummy_b
->frame_id
, tp
);
7298 while (b
->related_breakpoint
!= b
)
7300 if (b_tmp
== b
->related_breakpoint
)
7301 b_tmp
= b
->related_breakpoint
->next
;
7302 delete_breakpoint (b
->related_breakpoint
);
7304 delete_breakpoint (b
);
7309 enable_overlay_breakpoints (void)
7311 struct breakpoint
*b
;
7314 if (b
->type
== bp_overlay_event
)
7316 b
->enable_state
= bp_enabled
;
7317 update_global_location_list (UGLL_MAY_INSERT
);
7318 overlay_events_enabled
= 1;
7323 disable_overlay_breakpoints (void)
7325 struct breakpoint
*b
;
7328 if (b
->type
== bp_overlay_event
)
7330 b
->enable_state
= bp_disabled
;
7331 update_global_location_list (UGLL_DONT_INSERT
);
7332 overlay_events_enabled
= 0;
7336 /* Set an active std::terminate breakpoint for each std::terminate
7337 master breakpoint. */
7339 set_std_terminate_breakpoint (void)
7341 struct breakpoint
*b
, *b_tmp
;
7343 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7344 if (b
->pspace
== current_program_space
7345 && b
->type
== bp_std_terminate_master
)
7347 momentary_breakpoint_from_master (b
, bp_std_terminate
,
7348 &momentary_breakpoint_ops
, 1);
7352 /* Delete all the std::terminate breakpoints. */
7354 delete_std_terminate_breakpoint (void)
7356 struct breakpoint
*b
, *b_tmp
;
7358 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7359 if (b
->type
== bp_std_terminate
)
7360 delete_breakpoint (b
);
7364 create_thread_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7366 struct breakpoint
*b
;
7368 b
= create_internal_breakpoint (gdbarch
, address
, bp_thread_event
,
7369 &internal_breakpoint_ops
);
7371 b
->enable_state
= bp_enabled
;
7372 /* location has to be used or breakpoint_re_set will delete me. */
7373 b
->location
= new_address_location (b
->loc
->address
, NULL
, 0);
7375 update_global_location_list_nothrow (UGLL_MAY_INSERT
);
7380 struct lang_and_radix
7386 /* Create a breakpoint for JIT code registration and unregistration. */
7389 create_jit_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7391 return create_internal_breakpoint (gdbarch
, address
, bp_jit_event
,
7392 &internal_breakpoint_ops
);
7395 /* Remove JIT code registration and unregistration breakpoint(s). */
7398 remove_jit_event_breakpoints (void)
7400 struct breakpoint
*b
, *b_tmp
;
7402 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7403 if (b
->type
== bp_jit_event
7404 && b
->loc
->pspace
== current_program_space
)
7405 delete_breakpoint (b
);
7409 remove_solib_event_breakpoints (void)
7411 struct breakpoint
*b
, *b_tmp
;
7413 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7414 if (b
->type
== bp_shlib_event
7415 && b
->loc
->pspace
== current_program_space
)
7416 delete_breakpoint (b
);
7419 /* See breakpoint.h. */
7422 remove_solib_event_breakpoints_at_next_stop (void)
7424 struct breakpoint
*b
, *b_tmp
;
7426 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7427 if (b
->type
== bp_shlib_event
7428 && b
->loc
->pspace
== current_program_space
)
7429 b
->disposition
= disp_del_at_next_stop
;
7432 /* Helper for create_solib_event_breakpoint /
7433 create_and_insert_solib_event_breakpoint. Allows specifying which
7434 INSERT_MODE to pass through to update_global_location_list. */
7436 static struct breakpoint
*
7437 create_solib_event_breakpoint_1 (struct gdbarch
*gdbarch
, CORE_ADDR address
,
7438 enum ugll_insert_mode insert_mode
)
7440 struct breakpoint
*b
;
7442 b
= create_internal_breakpoint (gdbarch
, address
, bp_shlib_event
,
7443 &internal_breakpoint_ops
);
7444 update_global_location_list_nothrow (insert_mode
);
7449 create_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7451 return create_solib_event_breakpoint_1 (gdbarch
, address
, UGLL_MAY_INSERT
);
7454 /* See breakpoint.h. */
7457 create_and_insert_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7459 struct breakpoint
*b
;
7461 /* Explicitly tell update_global_location_list to insert
7463 b
= create_solib_event_breakpoint_1 (gdbarch
, address
, UGLL_INSERT
);
7464 if (!b
->loc
->inserted
)
7466 delete_breakpoint (b
);
7472 /* Disable any breakpoints that are on code in shared libraries. Only
7473 apply to enabled breakpoints, disabled ones can just stay disabled. */
7476 disable_breakpoints_in_shlibs (void)
7478 struct bp_location
*loc
, **locp_tmp
;
7480 ALL_BP_LOCATIONS (loc
, locp_tmp
)
7482 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7483 struct breakpoint
*b
= loc
->owner
;
7485 /* We apply the check to all breakpoints, including disabled for
7486 those with loc->duplicate set. This is so that when breakpoint
7487 becomes enabled, or the duplicate is removed, gdb will try to
7488 insert all breakpoints. If we don't set shlib_disabled here,
7489 we'll try to insert those breakpoints and fail. */
7490 if (((b
->type
== bp_breakpoint
)
7491 || (b
->type
== bp_jit_event
)
7492 || (b
->type
== bp_hardware_breakpoint
)
7493 || (is_tracepoint (b
)))
7494 && loc
->pspace
== current_program_space
7495 && !loc
->shlib_disabled
7496 && solib_name_from_address (loc
->pspace
, loc
->address
)
7499 loc
->shlib_disabled
= 1;
7504 /* Disable any breakpoints and tracepoints that are in SOLIB upon
7505 notification of unloaded_shlib. Only apply to enabled breakpoints,
7506 disabled ones can just stay disabled. */
7509 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
7511 struct bp_location
*loc
, **locp_tmp
;
7512 int disabled_shlib_breaks
= 0;
7514 ALL_BP_LOCATIONS (loc
, locp_tmp
)
7516 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7517 struct breakpoint
*b
= loc
->owner
;
7519 if (solib
->pspace
== loc
->pspace
7520 && !loc
->shlib_disabled
7521 && (((b
->type
== bp_breakpoint
7522 || b
->type
== bp_jit_event
7523 || b
->type
== bp_hardware_breakpoint
)
7524 && (loc
->loc_type
== bp_loc_hardware_breakpoint
7525 || loc
->loc_type
== bp_loc_software_breakpoint
))
7526 || is_tracepoint (b
))
7527 && solib_contains_address_p (solib
, loc
->address
))
7529 loc
->shlib_disabled
= 1;
7530 /* At this point, we cannot rely on remove_breakpoint
7531 succeeding so we must mark the breakpoint as not inserted
7532 to prevent future errors occurring in remove_breakpoints. */
7535 /* This may cause duplicate notifications for the same breakpoint. */
7536 gdb::observers::breakpoint_modified
.notify (b
);
7538 if (!disabled_shlib_breaks
)
7540 target_terminal::ours_for_output ();
7541 warning (_("Temporarily disabling breakpoints "
7542 "for unloaded shared library \"%s\""),
7545 disabled_shlib_breaks
= 1;
7550 /* Disable any breakpoints and tracepoints in OBJFILE upon
7551 notification of free_objfile. Only apply to enabled breakpoints,
7552 disabled ones can just stay disabled. */
7555 disable_breakpoints_in_freed_objfile (struct objfile
*objfile
)
7557 struct breakpoint
*b
;
7559 if (objfile
== NULL
)
7562 /* OBJF_SHARED|OBJF_USERLOADED objfiles are dynamic modules manually
7563 managed by the user with add-symbol-file/remove-symbol-file.
7564 Similarly to how breakpoints in shared libraries are handled in
7565 response to "nosharedlibrary", mark breakpoints in such modules
7566 shlib_disabled so they end up uninserted on the next global
7567 location list update. Shared libraries not loaded by the user
7568 aren't handled here -- they're already handled in
7569 disable_breakpoints_in_unloaded_shlib, called by solib.c's
7570 solib_unloaded observer. We skip objfiles that are not
7571 OBJF_SHARED as those aren't considered dynamic objects (e.g. the
7573 if ((objfile
->flags
& OBJF_SHARED
) == 0
7574 || (objfile
->flags
& OBJF_USERLOADED
) == 0)
7579 struct bp_location
*loc
;
7580 int bp_modified
= 0;
7582 if (!is_breakpoint (b
) && !is_tracepoint (b
))
7585 for (loc
= b
->loc
; loc
!= NULL
; loc
= loc
->next
)
7587 CORE_ADDR loc_addr
= loc
->address
;
7589 if (loc
->loc_type
!= bp_loc_hardware_breakpoint
7590 && loc
->loc_type
!= bp_loc_software_breakpoint
)
7593 if (loc
->shlib_disabled
!= 0)
7596 if (objfile
->pspace
!= loc
->pspace
)
7599 if (loc
->loc_type
!= bp_loc_hardware_breakpoint
7600 && loc
->loc_type
!= bp_loc_software_breakpoint
)
7603 if (is_addr_in_objfile (loc_addr
, objfile
))
7605 loc
->shlib_disabled
= 1;
7606 /* At this point, we don't know whether the object was
7607 unmapped from the inferior or not, so leave the
7608 inserted flag alone. We'll handle failure to
7609 uninsert quietly, in case the object was indeed
7612 mark_breakpoint_location_modified (loc
);
7619 gdb::observers::breakpoint_modified
.notify (b
);
7623 /* FORK & VFORK catchpoints. */
7625 /* An instance of this type is used to represent a fork or vfork
7626 catchpoint. A breakpoint is really of this type iff its ops pointer points
7627 to CATCH_FORK_BREAKPOINT_OPS. */
7629 struct fork_catchpoint
: public breakpoint
7631 /* Process id of a child process whose forking triggered this
7632 catchpoint. This field is only valid immediately after this
7633 catchpoint has triggered. */
7634 ptid_t forked_inferior_pid
;
7637 /* Implement the "insert" breakpoint_ops method for fork
7641 insert_catch_fork (struct bp_location
*bl
)
7643 return target_insert_fork_catchpoint (inferior_ptid
.pid ());
7646 /* Implement the "remove" breakpoint_ops method for fork
7650 remove_catch_fork (struct bp_location
*bl
, enum remove_bp_reason reason
)
7652 return target_remove_fork_catchpoint (inferior_ptid
.pid ());
7655 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
7659 breakpoint_hit_catch_fork (const struct bp_location
*bl
,
7660 const address_space
*aspace
, CORE_ADDR bp_addr
,
7661 const struct target_waitstatus
*ws
)
7663 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bl
->owner
;
7665 if (ws
->kind
!= TARGET_WAITKIND_FORKED
)
7668 c
->forked_inferior_pid
= ws
->value
.related_pid
;
7672 /* Implement the "print_it" breakpoint_ops method for fork
7675 static enum print_stop_action
7676 print_it_catch_fork (bpstat bs
)
7678 struct ui_out
*uiout
= current_uiout
;
7679 struct breakpoint
*b
= bs
->breakpoint_at
;
7680 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bs
->breakpoint_at
;
7682 annotate_catchpoint (b
->number
);
7683 maybe_print_thread_hit_breakpoint (uiout
);
7684 if (b
->disposition
== disp_del
)
7685 uiout
->text ("Temporary catchpoint ");
7687 uiout
->text ("Catchpoint ");
7688 if (uiout
->is_mi_like_p ())
7690 uiout
->field_string ("reason", async_reason_lookup (EXEC_ASYNC_FORK
));
7691 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
7693 uiout
->field_signed ("bkptno", b
->number
);
7694 uiout
->text (" (forked process ");
7695 uiout
->field_signed ("newpid", c
->forked_inferior_pid
.pid ());
7696 uiout
->text ("), ");
7697 return PRINT_SRC_AND_LOC
;
7700 /* Implement the "print_one" breakpoint_ops method for fork
7704 print_one_catch_fork (struct breakpoint
*b
, struct bp_location
**last_loc
)
7706 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
7707 struct value_print_options opts
;
7708 struct ui_out
*uiout
= current_uiout
;
7710 get_user_print_options (&opts
);
7712 /* Field 4, the address, is omitted (which makes the columns not
7713 line up too nicely with the headers, but the effect is relatively
7715 if (opts
.addressprint
)
7716 uiout
->field_skip ("addr");
7718 uiout
->text ("fork");
7719 if (c
->forked_inferior_pid
!= null_ptid
)
7721 uiout
->text (", process ");
7722 uiout
->field_signed ("what", c
->forked_inferior_pid
.pid ());
7726 if (uiout
->is_mi_like_p ())
7727 uiout
->field_string ("catch-type", "fork");
7730 /* Implement the "print_mention" breakpoint_ops method for fork
7734 print_mention_catch_fork (struct breakpoint
*b
)
7736 printf_filtered (_("Catchpoint %d (fork)"), b
->number
);
7739 /* Implement the "print_recreate" breakpoint_ops method for fork
7743 print_recreate_catch_fork (struct breakpoint
*b
, struct ui_file
*fp
)
7745 fprintf_unfiltered (fp
, "catch fork");
7746 print_recreate_thread (b
, fp
);
7749 /* The breakpoint_ops structure to be used in fork catchpoints. */
7751 static struct breakpoint_ops catch_fork_breakpoint_ops
;
7753 /* Implement the "insert" breakpoint_ops method for vfork
7757 insert_catch_vfork (struct bp_location
*bl
)
7759 return target_insert_vfork_catchpoint (inferior_ptid
.pid ());
7762 /* Implement the "remove" breakpoint_ops method for vfork
7766 remove_catch_vfork (struct bp_location
*bl
, enum remove_bp_reason reason
)
7768 return target_remove_vfork_catchpoint (inferior_ptid
.pid ());
7771 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
7775 breakpoint_hit_catch_vfork (const struct bp_location
*bl
,
7776 const address_space
*aspace
, CORE_ADDR bp_addr
,
7777 const struct target_waitstatus
*ws
)
7779 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bl
->owner
;
7781 if (ws
->kind
!= TARGET_WAITKIND_VFORKED
)
7784 c
->forked_inferior_pid
= ws
->value
.related_pid
;
7788 /* Implement the "print_it" breakpoint_ops method for vfork
7791 static enum print_stop_action
7792 print_it_catch_vfork (bpstat bs
)
7794 struct ui_out
*uiout
= current_uiout
;
7795 struct breakpoint
*b
= bs
->breakpoint_at
;
7796 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
7798 annotate_catchpoint (b
->number
);
7799 maybe_print_thread_hit_breakpoint (uiout
);
7800 if (b
->disposition
== disp_del
)
7801 uiout
->text ("Temporary catchpoint ");
7803 uiout
->text ("Catchpoint ");
7804 if (uiout
->is_mi_like_p ())
7806 uiout
->field_string ("reason", async_reason_lookup (EXEC_ASYNC_VFORK
));
7807 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
7809 uiout
->field_signed ("bkptno", b
->number
);
7810 uiout
->text (" (vforked process ");
7811 uiout
->field_signed ("newpid", c
->forked_inferior_pid
.pid ());
7812 uiout
->text ("), ");
7813 return PRINT_SRC_AND_LOC
;
7816 /* Implement the "print_one" breakpoint_ops method for vfork
7820 print_one_catch_vfork (struct breakpoint
*b
, struct bp_location
**last_loc
)
7822 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
7823 struct value_print_options opts
;
7824 struct ui_out
*uiout
= current_uiout
;
7826 get_user_print_options (&opts
);
7827 /* Field 4, the address, is omitted (which makes the columns not
7828 line up too nicely with the headers, but the effect is relatively
7830 if (opts
.addressprint
)
7831 uiout
->field_skip ("addr");
7833 uiout
->text ("vfork");
7834 if (c
->forked_inferior_pid
!= null_ptid
)
7836 uiout
->text (", process ");
7837 uiout
->field_signed ("what", c
->forked_inferior_pid
.pid ());
7841 if (uiout
->is_mi_like_p ())
7842 uiout
->field_string ("catch-type", "vfork");
7845 /* Implement the "print_mention" breakpoint_ops method for vfork
7849 print_mention_catch_vfork (struct breakpoint
*b
)
7851 printf_filtered (_("Catchpoint %d (vfork)"), b
->number
);
7854 /* Implement the "print_recreate" breakpoint_ops method for vfork
7858 print_recreate_catch_vfork (struct breakpoint
*b
, struct ui_file
*fp
)
7860 fprintf_unfiltered (fp
, "catch vfork");
7861 print_recreate_thread (b
, fp
);
7864 /* The breakpoint_ops structure to be used in vfork catchpoints. */
7866 static struct breakpoint_ops catch_vfork_breakpoint_ops
;
7868 /* An instance of this type is used to represent an solib catchpoint.
7869 A breakpoint is really of this type iff its ops pointer points to
7870 CATCH_SOLIB_BREAKPOINT_OPS. */
7872 struct solib_catchpoint
: public breakpoint
7874 ~solib_catchpoint () override
;
7876 /* True for "catch load", false for "catch unload". */
7877 unsigned char is_load
;
7879 /* Regular expression to match, if any. COMPILED is only valid when
7880 REGEX is non-NULL. */
7882 std::unique_ptr
<compiled_regex
> compiled
;
7885 solib_catchpoint::~solib_catchpoint ()
7887 xfree (this->regex
);
7891 insert_catch_solib (struct bp_location
*ignore
)
7897 remove_catch_solib (struct bp_location
*ignore
, enum remove_bp_reason reason
)
7903 breakpoint_hit_catch_solib (const struct bp_location
*bl
,
7904 const address_space
*aspace
,
7906 const struct target_waitstatus
*ws
)
7908 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) bl
->owner
;
7909 struct breakpoint
*other
;
7911 if (ws
->kind
== TARGET_WAITKIND_LOADED
)
7914 ALL_BREAKPOINTS (other
)
7916 struct bp_location
*other_bl
;
7918 if (other
== bl
->owner
)
7921 if (other
->type
!= bp_shlib_event
)
7924 if (self
->pspace
!= NULL
&& other
->pspace
!= self
->pspace
)
7927 for (other_bl
= other
->loc
; other_bl
!= NULL
; other_bl
= other_bl
->next
)
7929 if (other
->ops
->breakpoint_hit (other_bl
, aspace
, bp_addr
, ws
))
7938 check_status_catch_solib (struct bpstats
*bs
)
7940 struct solib_catchpoint
*self
7941 = (struct solib_catchpoint
*) bs
->breakpoint_at
;
7945 for (so_list
*iter
: current_program_space
->added_solibs
)
7948 || self
->compiled
->exec (iter
->so_name
, 0, NULL
, 0) == 0)
7954 for (const std::string
&iter
: current_program_space
->deleted_solibs
)
7957 || self
->compiled
->exec (iter
.c_str (), 0, NULL
, 0) == 0)
7963 bs
->print_it
= print_it_noop
;
7966 static enum print_stop_action
7967 print_it_catch_solib (bpstat bs
)
7969 struct breakpoint
*b
= bs
->breakpoint_at
;
7970 struct ui_out
*uiout
= current_uiout
;
7972 annotate_catchpoint (b
->number
);
7973 maybe_print_thread_hit_breakpoint (uiout
);
7974 if (b
->disposition
== disp_del
)
7975 uiout
->text ("Temporary catchpoint ");
7977 uiout
->text ("Catchpoint ");
7978 uiout
->field_signed ("bkptno", b
->number
);
7980 if (uiout
->is_mi_like_p ())
7981 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
7982 print_solib_event (1);
7983 return PRINT_SRC_AND_LOC
;
7987 print_one_catch_solib (struct breakpoint
*b
, struct bp_location
**locs
)
7989 struct solib_catchpoint
*self
= (struct solib_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
)
8000 uiout
->field_skip ("addr");
8008 msg
= string_printf (_("load of library matching %s"), self
->regex
);
8010 msg
= _("load of library");
8015 msg
= string_printf (_("unload of library matching %s"), self
->regex
);
8017 msg
= _("unload of library");
8019 uiout
->field_string ("what", msg
);
8021 if (uiout
->is_mi_like_p ())
8022 uiout
->field_string ("catch-type", self
->is_load
? "load" : "unload");
8026 print_mention_catch_solib (struct breakpoint
*b
)
8028 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8030 printf_filtered (_("Catchpoint %d (%s)"), b
->number
,
8031 self
->is_load
? "load" : "unload");
8035 print_recreate_catch_solib (struct breakpoint
*b
, struct ui_file
*fp
)
8037 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8039 fprintf_unfiltered (fp
, "%s %s",
8040 b
->disposition
== disp_del
? "tcatch" : "catch",
8041 self
->is_load
? "load" : "unload");
8043 fprintf_unfiltered (fp
, " %s", self
->regex
);
8044 fprintf_unfiltered (fp
, "\n");
8047 static struct breakpoint_ops catch_solib_breakpoint_ops
;
8049 /* Shared helper function (MI and CLI) for creating and installing
8050 a shared object event catchpoint. If IS_LOAD is non-zero then
8051 the events to be caught are load events, otherwise they are
8052 unload events. If IS_TEMP is non-zero the catchpoint is a
8053 temporary one. If ENABLED is non-zero the catchpoint is
8054 created in an enabled state. */
8057 add_solib_catchpoint (const char *arg
, int is_load
, int is_temp
, int enabled
)
8059 struct gdbarch
*gdbarch
= get_current_arch ();
8063 arg
= skip_spaces (arg
);
8065 std::unique_ptr
<solib_catchpoint
> c (new solib_catchpoint ());
8069 c
->compiled
.reset (new compiled_regex (arg
, REG_NOSUB
,
8070 _("Invalid regexp")));
8071 c
->regex
= xstrdup (arg
);
8074 c
->is_load
= is_load
;
8075 init_catchpoint (c
.get (), gdbarch
, is_temp
, NULL
,
8076 &catch_solib_breakpoint_ops
);
8078 c
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
8080 install_breakpoint (0, std::move (c
), 1);
8083 /* A helper function that does all the work for "catch load" and
8087 catch_load_or_unload (const char *arg
, int from_tty
, int is_load
,
8088 struct cmd_list_element
*command
)
8091 const int enabled
= 1;
8093 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
8095 add_solib_catchpoint (arg
, is_load
, tempflag
, enabled
);
8099 catch_load_command_1 (const char *arg
, int from_tty
,
8100 struct cmd_list_element
*command
)
8102 catch_load_or_unload (arg
, from_tty
, 1, command
);
8106 catch_unload_command_1 (const char *arg
, int from_tty
,
8107 struct cmd_list_element
*command
)
8109 catch_load_or_unload (arg
, from_tty
, 0, command
);
8112 /* Initialize a new breakpoint of the bp_catchpoint kind. If TEMPFLAG
8113 is non-zero, then make the breakpoint temporary. If COND_STRING is
8114 not NULL, then store it in the breakpoint. OPS, if not NULL, is
8115 the breakpoint_ops structure associated to the catchpoint. */
8118 init_catchpoint (struct breakpoint
*b
,
8119 struct gdbarch
*gdbarch
, int tempflag
,
8120 const char *cond_string
,
8121 const struct breakpoint_ops
*ops
)
8123 symtab_and_line sal
;
8124 sal
.pspace
= current_program_space
;
8126 init_raw_breakpoint (b
, gdbarch
, sal
, bp_catchpoint
, ops
);
8128 b
->cond_string
= (cond_string
== NULL
) ? NULL
: xstrdup (cond_string
);
8129 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
8133 install_breakpoint (int internal
, std::unique_ptr
<breakpoint
> &&arg
, int update_gll
)
8135 breakpoint
*b
= add_to_breakpoint_chain (std::move (arg
));
8136 set_breakpoint_number (internal
, b
);
8137 if (is_tracepoint (b
))
8138 set_tracepoint_count (breakpoint_count
);
8141 gdb::observers::breakpoint_created
.notify (b
);
8144 update_global_location_list (UGLL_MAY_INSERT
);
8148 create_fork_vfork_event_catchpoint (struct gdbarch
*gdbarch
,
8149 int tempflag
, const char *cond_string
,
8150 const struct breakpoint_ops
*ops
)
8152 std::unique_ptr
<fork_catchpoint
> c (new fork_catchpoint ());
8154 init_catchpoint (c
.get (), gdbarch
, tempflag
, cond_string
, ops
);
8156 c
->forked_inferior_pid
= null_ptid
;
8158 install_breakpoint (0, std::move (c
), 1);
8161 /* Exec catchpoints. */
8163 /* An instance of this type is used to represent an exec catchpoint.
8164 A breakpoint is really of this type iff its ops pointer points to
8165 CATCH_EXEC_BREAKPOINT_OPS. */
8167 struct exec_catchpoint
: public breakpoint
8169 ~exec_catchpoint () override
;
8171 /* Filename of a program whose exec triggered this catchpoint.
8172 This field is only valid immediately after this catchpoint has
8174 char *exec_pathname
;
8177 /* Exec catchpoint destructor. */
8179 exec_catchpoint::~exec_catchpoint ()
8181 xfree (this->exec_pathname
);
8185 insert_catch_exec (struct bp_location
*bl
)
8187 return target_insert_exec_catchpoint (inferior_ptid
.pid ());
8191 remove_catch_exec (struct bp_location
*bl
, enum remove_bp_reason reason
)
8193 return target_remove_exec_catchpoint (inferior_ptid
.pid ());
8197 breakpoint_hit_catch_exec (const struct bp_location
*bl
,
8198 const address_space
*aspace
, CORE_ADDR bp_addr
,
8199 const struct target_waitstatus
*ws
)
8201 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) bl
->owner
;
8203 if (ws
->kind
!= TARGET_WAITKIND_EXECD
)
8206 c
->exec_pathname
= xstrdup (ws
->value
.execd_pathname
);
8210 static enum print_stop_action
8211 print_it_catch_exec (bpstat bs
)
8213 struct ui_out
*uiout
= current_uiout
;
8214 struct breakpoint
*b
= bs
->breakpoint_at
;
8215 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
8217 annotate_catchpoint (b
->number
);
8218 maybe_print_thread_hit_breakpoint (uiout
);
8219 if (b
->disposition
== disp_del
)
8220 uiout
->text ("Temporary catchpoint ");
8222 uiout
->text ("Catchpoint ");
8223 if (uiout
->is_mi_like_p ())
8225 uiout
->field_string ("reason", async_reason_lookup (EXEC_ASYNC_EXEC
));
8226 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
8228 uiout
->field_signed ("bkptno", b
->number
);
8229 uiout
->text (" (exec'd ");
8230 uiout
->field_string ("new-exec", c
->exec_pathname
);
8231 uiout
->text ("), ");
8233 return PRINT_SRC_AND_LOC
;
8237 print_one_catch_exec (struct breakpoint
*b
, struct bp_location
**last_loc
)
8239 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
8240 struct value_print_options opts
;
8241 struct ui_out
*uiout
= current_uiout
;
8243 get_user_print_options (&opts
);
8245 /* Field 4, the address, is omitted (which makes the columns
8246 not line up too nicely with the headers, but the effect
8247 is relatively readable). */
8248 if (opts
.addressprint
)
8249 uiout
->field_skip ("addr");
8251 uiout
->text ("exec");
8252 if (c
->exec_pathname
!= NULL
)
8254 uiout
->text (", program \"");
8255 uiout
->field_string ("what", c
->exec_pathname
);
8256 uiout
->text ("\" ");
8259 if (uiout
->is_mi_like_p ())
8260 uiout
->field_string ("catch-type", "exec");
8264 print_mention_catch_exec (struct breakpoint
*b
)
8266 printf_filtered (_("Catchpoint %d (exec)"), b
->number
);
8269 /* Implement the "print_recreate" breakpoint_ops method for exec
8273 print_recreate_catch_exec (struct breakpoint
*b
, struct ui_file
*fp
)
8275 fprintf_unfiltered (fp
, "catch exec");
8276 print_recreate_thread (b
, fp
);
8279 static struct breakpoint_ops catch_exec_breakpoint_ops
;
8282 hw_breakpoint_used_count (void)
8285 struct breakpoint
*b
;
8286 struct bp_location
*bl
;
8290 if (b
->type
== bp_hardware_breakpoint
&& breakpoint_enabled (b
))
8291 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
8293 /* Special types of hardware breakpoints may use more than
8295 i
+= b
->ops
->resources_needed (bl
);
8302 /* Returns the resources B would use if it were a hardware
8306 hw_watchpoint_use_count (struct breakpoint
*b
)
8309 struct bp_location
*bl
;
8311 if (!breakpoint_enabled (b
))
8314 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
8316 /* Special types of hardware watchpoints may use more than
8318 i
+= b
->ops
->resources_needed (bl
);
8324 /* Returns the sum the used resources of all hardware watchpoints of
8325 type TYPE in the breakpoints list. Also returns in OTHER_TYPE_USED
8326 the sum of the used resources of all hardware watchpoints of other
8327 types _not_ TYPE. */
8330 hw_watchpoint_used_count_others (struct breakpoint
*except
,
8331 enum bptype type
, int *other_type_used
)
8334 struct breakpoint
*b
;
8336 *other_type_used
= 0;
8341 if (!breakpoint_enabled (b
))
8344 if (b
->type
== type
)
8345 i
+= hw_watchpoint_use_count (b
);
8346 else if (is_hardware_watchpoint (b
))
8347 *other_type_used
= 1;
8354 disable_watchpoints_before_interactive_call_start (void)
8356 struct breakpoint
*b
;
8360 if (is_watchpoint (b
) && breakpoint_enabled (b
))
8362 b
->enable_state
= bp_call_disabled
;
8363 update_global_location_list (UGLL_DONT_INSERT
);
8369 enable_watchpoints_after_interactive_call_stop (void)
8371 struct breakpoint
*b
;
8375 if (is_watchpoint (b
) && b
->enable_state
== bp_call_disabled
)
8377 b
->enable_state
= bp_enabled
;
8378 update_global_location_list (UGLL_MAY_INSERT
);
8384 disable_breakpoints_before_startup (void)
8386 current_program_space
->executing_startup
= 1;
8387 update_global_location_list (UGLL_DONT_INSERT
);
8391 enable_breakpoints_after_startup (void)
8393 current_program_space
->executing_startup
= 0;
8394 breakpoint_re_set ();
8397 /* Create a new single-step breakpoint for thread THREAD, with no
8400 static struct breakpoint
*
8401 new_single_step_breakpoint (int thread
, struct gdbarch
*gdbarch
)
8403 std::unique_ptr
<breakpoint
> b (new breakpoint ());
8405 init_raw_breakpoint_without_location (b
.get (), gdbarch
, bp_single_step
,
8406 &momentary_breakpoint_ops
);
8408 b
->disposition
= disp_donttouch
;
8409 b
->frame_id
= null_frame_id
;
8412 gdb_assert (b
->thread
!= 0);
8414 return add_to_breakpoint_chain (std::move (b
));
8417 /* Set a momentary breakpoint of type TYPE at address specified by
8418 SAL. If FRAME_ID is valid, the breakpoint is restricted to that
8422 set_momentary_breakpoint (struct gdbarch
*gdbarch
, struct symtab_and_line sal
,
8423 struct frame_id frame_id
, enum bptype type
)
8425 struct breakpoint
*b
;
8427 /* If FRAME_ID is valid, it should be a real frame, not an inlined or
8429 gdb_assert (!frame_id_artificial_p (frame_id
));
8431 b
= set_raw_breakpoint (gdbarch
, sal
, type
, &momentary_breakpoint_ops
);
8432 b
->enable_state
= bp_enabled
;
8433 b
->disposition
= disp_donttouch
;
8434 b
->frame_id
= frame_id
;
8436 b
->thread
= inferior_thread ()->global_num
;
8438 update_global_location_list_nothrow (UGLL_MAY_INSERT
);
8440 return breakpoint_up (b
);
8443 /* Make a momentary breakpoint based on the master breakpoint ORIG.
8444 The new breakpoint will have type TYPE, use OPS as its
8445 breakpoint_ops, and will set enabled to LOC_ENABLED. */
8447 static struct breakpoint
*
8448 momentary_breakpoint_from_master (struct breakpoint
*orig
,
8450 const struct breakpoint_ops
*ops
,
8453 struct breakpoint
*copy
;
8455 copy
= set_raw_breakpoint_without_location (orig
->gdbarch
, type
, ops
);
8456 copy
->loc
= allocate_bp_location (copy
);
8457 set_breakpoint_location_function (copy
->loc
);
8459 copy
->loc
->gdbarch
= orig
->loc
->gdbarch
;
8460 copy
->loc
->requested_address
= orig
->loc
->requested_address
;
8461 copy
->loc
->address
= orig
->loc
->address
;
8462 copy
->loc
->section
= orig
->loc
->section
;
8463 copy
->loc
->pspace
= orig
->loc
->pspace
;
8464 copy
->loc
->probe
= orig
->loc
->probe
;
8465 copy
->loc
->line_number
= orig
->loc
->line_number
;
8466 copy
->loc
->symtab
= orig
->loc
->symtab
;
8467 copy
->loc
->enabled
= loc_enabled
;
8468 copy
->frame_id
= orig
->frame_id
;
8469 copy
->thread
= orig
->thread
;
8470 copy
->pspace
= orig
->pspace
;
8472 copy
->enable_state
= bp_enabled
;
8473 copy
->disposition
= disp_donttouch
;
8474 copy
->number
= internal_breakpoint_number
--;
8476 update_global_location_list_nothrow (UGLL_DONT_INSERT
);
8480 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
8484 clone_momentary_breakpoint (struct breakpoint
*orig
)
8486 /* If there's nothing to clone, then return nothing. */
8490 return momentary_breakpoint_from_master (orig
, orig
->type
, orig
->ops
, 0);
8494 set_momentary_breakpoint_at_pc (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
8497 struct symtab_and_line sal
;
8499 sal
= find_pc_line (pc
, 0);
8501 sal
.section
= find_pc_overlay (pc
);
8502 sal
.explicit_pc
= 1;
8504 return set_momentary_breakpoint (gdbarch
, sal
, null_frame_id
, type
);
8508 /* Tell the user we have just set a breakpoint B. */
8511 mention (struct breakpoint
*b
)
8513 b
->ops
->print_mention (b
);
8514 current_uiout
->text ("\n");
8518 static bool bp_loc_is_permanent (struct bp_location
*loc
);
8520 static struct bp_location
*
8521 add_location_to_breakpoint (struct breakpoint
*b
,
8522 const struct symtab_and_line
*sal
)
8524 struct bp_location
*loc
, **tmp
;
8525 CORE_ADDR adjusted_address
;
8526 struct gdbarch
*loc_gdbarch
= get_sal_arch (*sal
);
8528 if (loc_gdbarch
== NULL
)
8529 loc_gdbarch
= b
->gdbarch
;
8531 /* Adjust the breakpoint's address prior to allocating a location.
8532 Once we call allocate_bp_location(), that mostly uninitialized
8533 location will be placed on the location chain. Adjustment of the
8534 breakpoint may cause target_read_memory() to be called and we do
8535 not want its scan of the location chain to find a breakpoint and
8536 location that's only been partially initialized. */
8537 adjusted_address
= adjust_breakpoint_address (loc_gdbarch
,
8540 /* Sort the locations by their ADDRESS. */
8541 loc
= allocate_bp_location (b
);
8542 for (tmp
= &(b
->loc
); *tmp
!= NULL
&& (*tmp
)->address
<= adjusted_address
;
8543 tmp
= &((*tmp
)->next
))
8548 loc
->requested_address
= sal
->pc
;
8549 loc
->address
= adjusted_address
;
8550 loc
->pspace
= sal
->pspace
;
8551 loc
->probe
.prob
= sal
->prob
;
8552 loc
->probe
.objfile
= sal
->objfile
;
8553 gdb_assert (loc
->pspace
!= NULL
);
8554 loc
->section
= sal
->section
;
8555 loc
->gdbarch
= loc_gdbarch
;
8556 loc
->line_number
= sal
->line
;
8557 loc
->symtab
= sal
->symtab
;
8558 loc
->symbol
= sal
->symbol
;
8559 loc
->msymbol
= sal
->msymbol
;
8560 loc
->objfile
= sal
->objfile
;
8562 set_breakpoint_location_function (loc
);
8564 /* While by definition, permanent breakpoints are already present in the
8565 code, we don't mark the location as inserted. Normally one would expect
8566 that GDB could rely on that breakpoint instruction to stop the program,
8567 thus removing the need to insert its own breakpoint, except that executing
8568 the breakpoint instruction can kill the target instead of reporting a
8569 SIGTRAP. E.g., on SPARC, when interrupts are disabled, executing the
8570 instruction resets the CPU, so QEMU 2.0.0 for SPARC correspondingly dies
8571 with "Trap 0x02 while interrupts disabled, Error state". Letting the
8572 breakpoint be inserted normally results in QEMU knowing about the GDB
8573 breakpoint, and thus trap before the breakpoint instruction is executed.
8574 (If GDB later needs to continue execution past the permanent breakpoint,
8575 it manually increments the PC, thus avoiding executing the breakpoint
8577 if (bp_loc_is_permanent (loc
))
8584 /* Return true if LOC is pointing to a permanent breakpoint,
8585 return false otherwise. */
8588 bp_loc_is_permanent (struct bp_location
*loc
)
8590 gdb_assert (loc
!= NULL
);
8592 /* If we have a non-breakpoint-backed catchpoint or a software
8593 watchpoint, just return 0. We should not attempt to read from
8594 the addresses the locations of these breakpoint types point to.
8595 gdbarch_program_breakpoint_here_p, below, will attempt to read
8597 if (!bl_address_is_meaningful (loc
))
8600 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
8601 switch_to_program_space_and_thread (loc
->pspace
);
8602 return gdbarch_program_breakpoint_here_p (loc
->gdbarch
, loc
->address
);
8605 /* Build a command list for the dprintf corresponding to the current
8606 settings of the dprintf style options. */
8609 update_dprintf_command_list (struct breakpoint
*b
)
8611 char *dprintf_args
= b
->extra_string
;
8612 char *printf_line
= NULL
;
8617 dprintf_args
= skip_spaces (dprintf_args
);
8619 /* Allow a comma, as it may have terminated a location, but don't
8621 if (*dprintf_args
== ',')
8623 dprintf_args
= skip_spaces (dprintf_args
);
8625 if (*dprintf_args
!= '"')
8626 error (_("Bad format string, missing '\"'."));
8628 if (strcmp (dprintf_style
, dprintf_style_gdb
) == 0)
8629 printf_line
= xstrprintf ("printf %s", dprintf_args
);
8630 else if (strcmp (dprintf_style
, dprintf_style_call
) == 0)
8632 if (!dprintf_function
)
8633 error (_("No function supplied for dprintf call"));
8635 if (dprintf_channel
&& strlen (dprintf_channel
) > 0)
8636 printf_line
= xstrprintf ("call (void) %s (%s,%s)",
8641 printf_line
= xstrprintf ("call (void) %s (%s)",
8645 else if (strcmp (dprintf_style
, dprintf_style_agent
) == 0)
8647 if (target_can_run_breakpoint_commands ())
8648 printf_line
= xstrprintf ("agent-printf %s", dprintf_args
);
8651 warning (_("Target cannot run dprintf commands, falling back to GDB printf"));
8652 printf_line
= xstrprintf ("printf %s", dprintf_args
);
8656 internal_error (__FILE__
, __LINE__
,
8657 _("Invalid dprintf style."));
8659 gdb_assert (printf_line
!= NULL
);
8661 /* Manufacture a printf sequence. */
8662 struct command_line
*printf_cmd_line
8663 = new struct command_line (simple_control
, printf_line
);
8664 breakpoint_set_commands (b
, counted_command_line (printf_cmd_line
,
8665 command_lines_deleter ()));
8668 /* Update all dprintf commands, making their command lists reflect
8669 current style settings. */
8672 update_dprintf_commands (const char *args
, int from_tty
,
8673 struct cmd_list_element
*c
)
8675 struct breakpoint
*b
;
8679 if (b
->type
== bp_dprintf
)
8680 update_dprintf_command_list (b
);
8684 /* Create a breakpoint with SAL as location. Use LOCATION
8685 as a description of the location, and COND_STRING
8686 as condition expression. If LOCATION is NULL then create an
8687 "address location" from the address in the SAL. */
8690 init_breakpoint_sal (struct breakpoint
*b
, struct gdbarch
*gdbarch
,
8691 gdb::array_view
<const symtab_and_line
> sals
,
8692 event_location_up
&&location
,
8693 gdb::unique_xmalloc_ptr
<char> filter
,
8694 gdb::unique_xmalloc_ptr
<char> cond_string
,
8695 gdb::unique_xmalloc_ptr
<char> extra_string
,
8696 enum bptype type
, enum bpdisp disposition
,
8697 int thread
, int task
, int ignore_count
,
8698 const struct breakpoint_ops
*ops
, int from_tty
,
8699 int enabled
, int internal
, unsigned flags
,
8700 int display_canonical
)
8704 if (type
== bp_hardware_breakpoint
)
8706 int target_resources_ok
;
8708 i
= hw_breakpoint_used_count ();
8709 target_resources_ok
=
8710 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
8712 if (target_resources_ok
== 0)
8713 error (_("No hardware breakpoint support in the target."));
8714 else if (target_resources_ok
< 0)
8715 error (_("Hardware breakpoints used exceeds limit."));
8718 gdb_assert (!sals
.empty ());
8720 for (const auto &sal
: sals
)
8722 struct bp_location
*loc
;
8726 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
8728 loc_gdbarch
= gdbarch
;
8730 describe_other_breakpoints (loc_gdbarch
,
8731 sal
.pspace
, sal
.pc
, sal
.section
, thread
);
8734 if (&sal
== &sals
[0])
8736 init_raw_breakpoint (b
, gdbarch
, sal
, type
, ops
);
8740 b
->cond_string
= cond_string
.release ();
8741 b
->extra_string
= extra_string
.release ();
8742 b
->ignore_count
= ignore_count
;
8743 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
8744 b
->disposition
= disposition
;
8746 if ((flags
& CREATE_BREAKPOINT_FLAGS_INSERTED
) != 0)
8747 b
->loc
->inserted
= 1;
8749 if (type
== bp_static_tracepoint
)
8751 struct tracepoint
*t
= (struct tracepoint
*) b
;
8752 struct static_tracepoint_marker marker
;
8754 if (strace_marker_p (b
))
8756 /* We already know the marker exists, otherwise, we
8757 wouldn't see a sal for it. */
8759 = &event_location_to_string (b
->location
.get ())[3];
8762 p
= skip_spaces (p
);
8764 endp
= skip_to_space (p
);
8766 t
->static_trace_marker_id
.assign (p
, endp
- p
);
8768 printf_filtered (_("Probed static tracepoint "
8770 t
->static_trace_marker_id
.c_str ());
8772 else if (target_static_tracepoint_marker_at (sal
.pc
, &marker
))
8774 t
->static_trace_marker_id
= std::move (marker
.str_id
);
8776 printf_filtered (_("Probed static tracepoint "
8778 t
->static_trace_marker_id
.c_str ());
8781 warning (_("Couldn't determine the static "
8782 "tracepoint marker to probe"));
8789 loc
= add_location_to_breakpoint (b
, &sal
);
8790 if ((flags
& CREATE_BREAKPOINT_FLAGS_INSERTED
) != 0)
8796 const char *arg
= b
->cond_string
;
8798 loc
->cond
= parse_exp_1 (&arg
, loc
->address
,
8799 block_for_pc (loc
->address
), 0);
8801 error (_("Garbage '%s' follows condition"), arg
);
8804 /* Dynamic printf requires and uses additional arguments on the
8805 command line, otherwise it's an error. */
8806 if (type
== bp_dprintf
)
8808 if (b
->extra_string
)
8809 update_dprintf_command_list (b
);
8811 error (_("Format string required"));
8813 else if (b
->extra_string
)
8814 error (_("Garbage '%s' at end of command"), b
->extra_string
);
8817 b
->display_canonical
= display_canonical
;
8818 if (location
!= NULL
)
8819 b
->location
= std::move (location
);
8821 b
->location
= new_address_location (b
->loc
->address
, NULL
, 0);
8822 b
->filter
= std::move (filter
);
8826 create_breakpoint_sal (struct gdbarch
*gdbarch
,
8827 gdb::array_view
<const symtab_and_line
> sals
,
8828 event_location_up
&&location
,
8829 gdb::unique_xmalloc_ptr
<char> filter
,
8830 gdb::unique_xmalloc_ptr
<char> cond_string
,
8831 gdb::unique_xmalloc_ptr
<char> extra_string
,
8832 enum bptype type
, enum bpdisp disposition
,
8833 int thread
, int task
, int ignore_count
,
8834 const struct breakpoint_ops
*ops
, int from_tty
,
8835 int enabled
, int internal
, unsigned flags
,
8836 int display_canonical
)
8838 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (type
);
8840 init_breakpoint_sal (b
.get (), gdbarch
,
8841 sals
, std::move (location
),
8843 std::move (cond_string
),
8844 std::move (extra_string
),
8846 thread
, task
, ignore_count
,
8848 enabled
, internal
, flags
,
8851 install_breakpoint (internal
, std::move (b
), 0);
8854 /* Add SALS.nelts breakpoints to the breakpoint table. For each
8855 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
8856 value. COND_STRING, if not NULL, specified the condition to be
8857 used for all breakpoints. Essentially the only case where
8858 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
8859 function. In that case, it's still not possible to specify
8860 separate conditions for different overloaded functions, so
8861 we take just a single condition string.
8863 NOTE: If the function succeeds, the caller is expected to cleanup
8864 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
8865 array contents). If the function fails (error() is called), the
8866 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
8867 COND and SALS arrays and each of those arrays contents. */
8870 create_breakpoints_sal (struct gdbarch
*gdbarch
,
8871 struct linespec_result
*canonical
,
8872 gdb::unique_xmalloc_ptr
<char> cond_string
,
8873 gdb::unique_xmalloc_ptr
<char> extra_string
,
8874 enum bptype type
, enum bpdisp disposition
,
8875 int thread
, int task
, int ignore_count
,
8876 const struct breakpoint_ops
*ops
, int from_tty
,
8877 int enabled
, int internal
, unsigned flags
)
8879 if (canonical
->pre_expanded
)
8880 gdb_assert (canonical
->lsals
.size () == 1);
8882 for (const auto &lsal
: canonical
->lsals
)
8884 /* Note that 'location' can be NULL in the case of a plain
8885 'break', without arguments. */
8886 event_location_up location
8887 = (canonical
->location
!= NULL
8888 ? copy_event_location (canonical
->location
.get ()) : NULL
);
8889 gdb::unique_xmalloc_ptr
<char> filter_string
8890 (lsal
.canonical
!= NULL
? xstrdup (lsal
.canonical
) : NULL
);
8892 create_breakpoint_sal (gdbarch
, lsal
.sals
,
8893 std::move (location
),
8894 std::move (filter_string
),
8895 std::move (cond_string
),
8896 std::move (extra_string
),
8898 thread
, task
, ignore_count
, ops
,
8899 from_tty
, enabled
, internal
, flags
,
8900 canonical
->special_display
);
8904 /* Parse LOCATION which is assumed to be a SAL specification possibly
8905 followed by conditionals. On return, SALS contains an array of SAL
8906 addresses found. LOCATION points to the end of the SAL (for
8907 linespec locations).
8909 The array and the line spec strings are allocated on the heap, it is
8910 the caller's responsibility to free them. */
8913 parse_breakpoint_sals (const struct event_location
*location
,
8914 struct linespec_result
*canonical
)
8916 struct symtab_and_line cursal
;
8918 if (event_location_type (location
) == LINESPEC_LOCATION
)
8920 const char *spec
= get_linespec_location (location
)->spec_string
;
8924 /* The last displayed codepoint, if it's valid, is our default
8925 breakpoint address. */
8926 if (last_displayed_sal_is_valid ())
8928 /* Set sal's pspace, pc, symtab, and line to the values
8929 corresponding to the last call to print_frame_info.
8930 Be sure to reinitialize LINE with NOTCURRENT == 0
8931 as the breakpoint line number is inappropriate otherwise.
8932 find_pc_line would adjust PC, re-set it back. */
8933 symtab_and_line sal
= get_last_displayed_sal ();
8934 CORE_ADDR pc
= sal
.pc
;
8936 sal
= find_pc_line (pc
, 0);
8938 /* "break" without arguments is equivalent to "break *PC"
8939 where PC is the last displayed codepoint's address. So
8940 make sure to set sal.explicit_pc to prevent GDB from
8941 trying to expand the list of sals to include all other
8942 instances with the same symtab and line. */
8944 sal
.explicit_pc
= 1;
8946 struct linespec_sals lsal
;
8948 lsal
.canonical
= NULL
;
8950 canonical
->lsals
.push_back (std::move (lsal
));
8954 error (_("No default breakpoint address now."));
8958 /* Force almost all breakpoints to be in terms of the
8959 current_source_symtab (which is decode_line_1's default).
8960 This should produce the results we want almost all of the
8961 time while leaving default_breakpoint_* alone.
8963 ObjC: However, don't match an Objective-C method name which
8964 may have a '+' or '-' succeeded by a '['. */
8965 cursal
= get_current_source_symtab_and_line ();
8966 if (last_displayed_sal_is_valid ())
8968 const char *spec
= NULL
;
8970 if (event_location_type (location
) == LINESPEC_LOCATION
)
8971 spec
= get_linespec_location (location
)->spec_string
;
8975 && strchr ("+-", spec
[0]) != NULL
8978 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, NULL
,
8979 get_last_displayed_symtab (),
8980 get_last_displayed_line (),
8981 canonical
, NULL
, NULL
);
8986 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, NULL
,
8987 cursal
.symtab
, cursal
.line
, canonical
, NULL
, NULL
);
8991 /* Convert each SAL into a real PC. Verify that the PC can be
8992 inserted as a breakpoint. If it can't throw an error. */
8995 breakpoint_sals_to_pc (std::vector
<symtab_and_line
> &sals
)
8997 for (auto &sal
: sals
)
8998 resolve_sal_pc (&sal
);
9001 /* Fast tracepoints may have restrictions on valid locations. For
9002 instance, a fast tracepoint using a jump instead of a trap will
9003 likely have to overwrite more bytes than a trap would, and so can
9004 only be placed where the instruction is longer than the jump, or a
9005 multi-instruction sequence does not have a jump into the middle of
9009 check_fast_tracepoint_sals (struct gdbarch
*gdbarch
,
9010 gdb::array_view
<const symtab_and_line
> sals
)
9012 for (const auto &sal
: sals
)
9014 struct gdbarch
*sarch
;
9016 sarch
= get_sal_arch (sal
);
9017 /* We fall back to GDBARCH if there is no architecture
9018 associated with SAL. */
9022 if (!gdbarch_fast_tracepoint_valid_at (sarch
, sal
.pc
, &msg
))
9023 error (_("May not have a fast tracepoint at %s%s"),
9024 paddress (sarch
, sal
.pc
), msg
.c_str ());
9028 /* Given TOK, a string specification of condition and thread, as
9029 accepted by the 'break' command, extract the condition
9030 string and thread number and set *COND_STRING and *THREAD.
9031 PC identifies the context at which the condition should be parsed.
9032 If no condition is found, *COND_STRING is set to NULL.
9033 If no thread is found, *THREAD is set to -1. */
9036 find_condition_and_thread (const char *tok
, CORE_ADDR pc
,
9037 char **cond_string
, int *thread
, int *task
,
9040 *cond_string
= NULL
;
9047 const char *end_tok
;
9049 const char *cond_start
= NULL
;
9050 const char *cond_end
= NULL
;
9052 tok
= skip_spaces (tok
);
9054 if ((*tok
== '"' || *tok
== ',') && rest
)
9056 *rest
= savestring (tok
, strlen (tok
));
9060 end_tok
= skip_to_space (tok
);
9062 toklen
= end_tok
- tok
;
9064 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
9066 tok
= cond_start
= end_tok
+ 1;
9067 parse_exp_1 (&tok
, pc
, block_for_pc (pc
), 0);
9069 *cond_string
= savestring (cond_start
, cond_end
- cond_start
);
9071 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
9074 struct thread_info
*thr
;
9077 thr
= parse_thread_id (tok
, &tmptok
);
9079 error (_("Junk after thread keyword."));
9080 *thread
= thr
->global_num
;
9083 else if (toklen
>= 1 && strncmp (tok
, "task", toklen
) == 0)
9088 *task
= strtol (tok
, &tmptok
, 0);
9090 error (_("Junk after task keyword."));
9091 if (!valid_task_id (*task
))
9092 error (_("Unknown task %d."), *task
);
9097 *rest
= savestring (tok
, strlen (tok
));
9101 error (_("Junk at end of arguments."));
9105 /* Decode a static tracepoint marker spec. */
9107 static std::vector
<symtab_and_line
>
9108 decode_static_tracepoint_spec (const char **arg_p
)
9110 const char *p
= &(*arg_p
)[3];
9113 p
= skip_spaces (p
);
9115 endp
= skip_to_space (p
);
9117 std::string
marker_str (p
, endp
- p
);
9119 std::vector
<static_tracepoint_marker
> markers
9120 = target_static_tracepoint_markers_by_strid (marker_str
.c_str ());
9121 if (markers
.empty ())
9122 error (_("No known static tracepoint marker named %s"),
9123 marker_str
.c_str ());
9125 std::vector
<symtab_and_line
> sals
;
9126 sals
.reserve (markers
.size ());
9128 for (const static_tracepoint_marker
&marker
: markers
)
9130 symtab_and_line sal
= find_pc_line (marker
.address
, 0);
9131 sal
.pc
= marker
.address
;
9132 sals
.push_back (sal
);
9139 /* Returns the breakpoint ops appropriate for use with with LOCATION_TYPE and
9140 according to IS_TRACEPOINT. */
9142 static const struct breakpoint_ops
*
9143 breakpoint_ops_for_event_location_type (enum event_location_type location_type
,
9148 if (location_type
== PROBE_LOCATION
)
9149 return &tracepoint_probe_breakpoint_ops
;
9151 return &tracepoint_breakpoint_ops
;
9155 if (location_type
== PROBE_LOCATION
)
9156 return &bkpt_probe_breakpoint_ops
;
9158 return &bkpt_breakpoint_ops
;
9162 /* See breakpoint.h. */
9164 const struct breakpoint_ops
*
9165 breakpoint_ops_for_event_location (const struct event_location
*location
,
9168 if (location
!= nullptr)
9169 return breakpoint_ops_for_event_location_type
9170 (event_location_type (location
), is_tracepoint
);
9171 return is_tracepoint
? &tracepoint_breakpoint_ops
: &bkpt_breakpoint_ops
;
9174 /* See breakpoint.h. */
9177 create_breakpoint (struct gdbarch
*gdbarch
,
9178 const struct event_location
*location
,
9179 const char *cond_string
,
9180 int thread
, const char *extra_string
,
9182 int tempflag
, enum bptype type_wanted
,
9184 enum auto_boolean pending_break_support
,
9185 const struct breakpoint_ops
*ops
,
9186 int from_tty
, int enabled
, int internal
,
9189 struct linespec_result canonical
;
9192 int prev_bkpt_count
= breakpoint_count
;
9194 gdb_assert (ops
!= NULL
);
9196 /* If extra_string isn't useful, set it to NULL. */
9197 if (extra_string
!= NULL
&& *extra_string
== '\0')
9198 extra_string
= NULL
;
9202 ops
->create_sals_from_location (location
, &canonical
, type_wanted
);
9204 catch (const gdb_exception_error
&e
)
9206 /* If caller is interested in rc value from parse, set
9208 if (e
.error
== NOT_FOUND_ERROR
)
9210 /* If pending breakpoint support is turned off, throw
9213 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
9216 exception_print (gdb_stderr
, e
);
9218 /* If pending breakpoint support is auto query and the user
9219 selects no, then simply return the error code. */
9220 if (pending_break_support
== AUTO_BOOLEAN_AUTO
9221 && !nquery (_("Make %s pending on future shared library load? "),
9222 bptype_string (type_wanted
)))
9225 /* At this point, either the user was queried about setting
9226 a pending breakpoint and selected yes, or pending
9227 breakpoint behavior is on and thus a pending breakpoint
9228 is defaulted on behalf of the user. */
9235 if (!pending
&& canonical
.lsals
.empty ())
9238 /* Resolve all line numbers to PC's and verify that the addresses
9239 are ok for the target. */
9242 for (auto &lsal
: canonical
.lsals
)
9243 breakpoint_sals_to_pc (lsal
.sals
);
9246 /* Fast tracepoints may have additional restrictions on location. */
9247 if (!pending
&& type_wanted
== bp_fast_tracepoint
)
9249 for (const auto &lsal
: canonical
.lsals
)
9250 check_fast_tracepoint_sals (gdbarch
, lsal
.sals
);
9253 /* Verify that condition can be parsed, before setting any
9254 breakpoints. Allocate a separate condition expression for each
9258 gdb::unique_xmalloc_ptr
<char> cond_string_copy
;
9259 gdb::unique_xmalloc_ptr
<char> extra_string_copy
;
9266 const linespec_sals
&lsal
= canonical
.lsals
[0];
9268 /* Here we only parse 'arg' to separate condition
9269 from thread number, so parsing in context of first
9270 sal is OK. When setting the breakpoint we'll
9271 re-parse it in context of each sal. */
9273 find_condition_and_thread (extra_string
, lsal
.sals
[0].pc
,
9274 &cond
, &thread
, &task
, &rest
);
9275 cond_string_copy
.reset (cond
);
9276 extra_string_copy
.reset (rest
);
9280 if (type_wanted
!= bp_dprintf
9281 && extra_string
!= NULL
&& *extra_string
!= '\0')
9282 error (_("Garbage '%s' at end of location"), extra_string
);
9284 /* Create a private copy of condition string. */
9286 cond_string_copy
.reset (xstrdup (cond_string
));
9287 /* Create a private copy of any extra string. */
9289 extra_string_copy
.reset (xstrdup (extra_string
));
9292 ops
->create_breakpoints_sal (gdbarch
, &canonical
,
9293 std::move (cond_string_copy
),
9294 std::move (extra_string_copy
),
9296 tempflag
? disp_del
: disp_donttouch
,
9297 thread
, task
, ignore_count
, ops
,
9298 from_tty
, enabled
, internal
, flags
);
9302 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (type_wanted
);
9304 init_raw_breakpoint_without_location (b
.get (), gdbarch
, type_wanted
, ops
);
9305 b
->location
= copy_event_location (location
);
9308 b
->cond_string
= NULL
;
9311 /* Create a private copy of condition string. */
9312 b
->cond_string
= cond_string
!= NULL
? xstrdup (cond_string
) : NULL
;
9316 /* Create a private copy of any extra string. */
9317 b
->extra_string
= extra_string
!= NULL
? xstrdup (extra_string
) : NULL
;
9318 b
->ignore_count
= ignore_count
;
9319 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
9320 b
->condition_not_parsed
= 1;
9321 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
9322 if ((type_wanted
!= bp_breakpoint
9323 && type_wanted
!= bp_hardware_breakpoint
) || thread
!= -1)
9324 b
->pspace
= current_program_space
;
9326 install_breakpoint (internal
, std::move (b
), 0);
9329 if (canonical
.lsals
.size () > 1)
9331 warning (_("Multiple breakpoints were set.\nUse the "
9332 "\"delete\" command to delete unwanted breakpoints."));
9333 prev_breakpoint_count
= prev_bkpt_count
;
9336 update_global_location_list (UGLL_MAY_INSERT
);
9341 /* Set a breakpoint.
9342 ARG is a string describing breakpoint address,
9343 condition, and thread.
9344 FLAG specifies if a breakpoint is hardware on,
9345 and if breakpoint is temporary, using BP_HARDWARE_FLAG
9349 break_command_1 (const char *arg
, int flag
, int from_tty
)
9351 int tempflag
= flag
& BP_TEMPFLAG
;
9352 enum bptype type_wanted
= (flag
& BP_HARDWAREFLAG
9353 ? bp_hardware_breakpoint
9356 event_location_up location
= string_to_event_location (&arg
, current_language
);
9357 const struct breakpoint_ops
*ops
= breakpoint_ops_for_event_location
9358 (location
.get (), false /* is_tracepoint */);
9360 create_breakpoint (get_current_arch (),
9362 NULL
, 0, arg
, 1 /* parse arg */,
9363 tempflag
, type_wanted
,
9364 0 /* Ignore count */,
9365 pending_break_support
,
9373 /* Helper function for break_command_1 and disassemble_command. */
9376 resolve_sal_pc (struct symtab_and_line
*sal
)
9380 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
9382 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
9383 error (_("No line %d in file \"%s\"."),
9384 sal
->line
, symtab_to_filename_for_display (sal
->symtab
));
9387 /* If this SAL corresponds to a breakpoint inserted using a line
9388 number, then skip the function prologue if necessary. */
9389 if (sal
->explicit_line
)
9390 skip_prologue_sal (sal
);
9393 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
9395 const struct blockvector
*bv
;
9396 const struct block
*b
;
9399 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
,
9400 SYMTAB_COMPUNIT (sal
->symtab
));
9403 sym
= block_linkage_function (b
);
9406 fixup_symbol_section (sym
, SYMTAB_OBJFILE (sal
->symtab
));
9407 sal
->section
= SYMBOL_OBJ_SECTION (SYMTAB_OBJFILE (sal
->symtab
),
9412 /* It really is worthwhile to have the section, so we'll
9413 just have to look harder. This case can be executed
9414 if we have line numbers but no functions (as can
9415 happen in assembly source). */
9417 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
9418 switch_to_program_space_and_thread (sal
->pspace
);
9420 bound_minimal_symbol msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
9422 sal
->section
= MSYMBOL_OBJ_SECTION (msym
.objfile
, msym
.minsym
);
9429 break_command (const char *arg
, int from_tty
)
9431 break_command_1 (arg
, 0, from_tty
);
9435 tbreak_command (const char *arg
, int from_tty
)
9437 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
9441 hbreak_command (const char *arg
, int from_tty
)
9443 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
9447 thbreak_command (const char *arg
, int from_tty
)
9449 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
9453 stop_command (const char *arg
, int from_tty
)
9455 printf_filtered (_("Specify the type of breakpoint to set.\n\
9456 Usage: stop in <function | address>\n\
9457 stop at <line>\n"));
9461 stopin_command (const char *arg
, int from_tty
)
9467 else if (*arg
!= '*')
9469 const char *argptr
= arg
;
9472 /* Look for a ':'. If this is a line number specification, then
9473 say it is bad, otherwise, it should be an address or
9474 function/method name. */
9475 while (*argptr
&& !hasColon
)
9477 hasColon
= (*argptr
== ':');
9482 badInput
= (*argptr
!= ':'); /* Not a class::method */
9484 badInput
= isdigit (*arg
); /* a simple line number */
9488 printf_filtered (_("Usage: stop in <function | address>\n"));
9490 break_command_1 (arg
, 0, from_tty
);
9494 stopat_command (const char *arg
, int from_tty
)
9498 if (arg
== NULL
|| *arg
== '*') /* no line number */
9502 const char *argptr
= arg
;
9505 /* Look for a ':'. If there is a '::' then get out, otherwise
9506 it is probably a line number. */
9507 while (*argptr
&& !hasColon
)
9509 hasColon
= (*argptr
== ':');
9514 badInput
= (*argptr
== ':'); /* we have class::method */
9516 badInput
= !isdigit (*arg
); /* not a line number */
9520 printf_filtered (_("Usage: stop at LINE\n"));
9522 break_command_1 (arg
, 0, from_tty
);
9525 /* The dynamic printf command is mostly like a regular breakpoint, but
9526 with a prewired command list consisting of a single output command,
9527 built from extra arguments supplied on the dprintf command
9531 dprintf_command (const char *arg
, int from_tty
)
9533 event_location_up location
= string_to_event_location (&arg
, current_language
);
9535 /* If non-NULL, ARG should have been advanced past the location;
9536 the next character must be ','. */
9539 if (arg
[0] != ',' || arg
[1] == '\0')
9540 error (_("Format string required"));
9543 /* Skip the comma. */
9548 create_breakpoint (get_current_arch (),
9550 NULL
, 0, arg
, 1 /* parse arg */,
9552 0 /* Ignore count */,
9553 pending_break_support
,
9554 &dprintf_breakpoint_ops
,
9562 agent_printf_command (const char *arg
, int from_tty
)
9564 error (_("May only run agent-printf on the target"));
9567 /* Implement the "breakpoint_hit" breakpoint_ops method for
9568 ranged breakpoints. */
9571 breakpoint_hit_ranged_breakpoint (const struct bp_location
*bl
,
9572 const address_space
*aspace
,
9574 const struct target_waitstatus
*ws
)
9576 if (ws
->kind
!= TARGET_WAITKIND_STOPPED
9577 || ws
->value
.sig
!= GDB_SIGNAL_TRAP
)
9580 return breakpoint_address_match_range (bl
->pspace
->aspace
, bl
->address
,
9581 bl
->length
, aspace
, bp_addr
);
9584 /* Implement the "resources_needed" breakpoint_ops method for
9585 ranged breakpoints. */
9588 resources_needed_ranged_breakpoint (const struct bp_location
*bl
)
9590 return target_ranged_break_num_registers ();
9593 /* Implement the "print_it" breakpoint_ops method for
9594 ranged breakpoints. */
9596 static enum print_stop_action
9597 print_it_ranged_breakpoint (bpstat bs
)
9599 struct breakpoint
*b
= bs
->breakpoint_at
;
9600 struct bp_location
*bl
= b
->loc
;
9601 struct ui_out
*uiout
= current_uiout
;
9603 gdb_assert (b
->type
== bp_hardware_breakpoint
);
9605 /* Ranged breakpoints have only one location. */
9606 gdb_assert (bl
&& bl
->next
== NULL
);
9608 annotate_breakpoint (b
->number
);
9610 maybe_print_thread_hit_breakpoint (uiout
);
9612 if (b
->disposition
== disp_del
)
9613 uiout
->text ("Temporary ranged breakpoint ");
9615 uiout
->text ("Ranged breakpoint ");
9616 if (uiout
->is_mi_like_p ())
9618 uiout
->field_string ("reason",
9619 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
9620 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
9622 uiout
->field_signed ("bkptno", b
->number
);
9625 return PRINT_SRC_AND_LOC
;
9628 /* Implement the "print_one" breakpoint_ops method for
9629 ranged breakpoints. */
9632 print_one_ranged_breakpoint (struct breakpoint
*b
,
9633 struct bp_location
**last_loc
)
9635 struct bp_location
*bl
= b
->loc
;
9636 struct value_print_options opts
;
9637 struct ui_out
*uiout
= current_uiout
;
9639 /* Ranged breakpoints have only one location. */
9640 gdb_assert (bl
&& bl
->next
== NULL
);
9642 get_user_print_options (&opts
);
9644 if (opts
.addressprint
)
9645 /* We don't print the address range here, it will be printed later
9646 by print_one_detail_ranged_breakpoint. */
9647 uiout
->field_skip ("addr");
9649 print_breakpoint_location (b
, bl
);
9653 /* Implement the "print_one_detail" breakpoint_ops method for
9654 ranged breakpoints. */
9657 print_one_detail_ranged_breakpoint (const struct breakpoint
*b
,
9658 struct ui_out
*uiout
)
9660 CORE_ADDR address_start
, address_end
;
9661 struct bp_location
*bl
= b
->loc
;
9666 address_start
= bl
->address
;
9667 address_end
= address_start
+ bl
->length
- 1;
9669 uiout
->text ("\taddress range: ");
9670 stb
.printf ("[%s, %s]",
9671 print_core_address (bl
->gdbarch
, address_start
),
9672 print_core_address (bl
->gdbarch
, address_end
));
9673 uiout
->field_stream ("addr", stb
);
9677 /* Implement the "print_mention" breakpoint_ops method for
9678 ranged breakpoints. */
9681 print_mention_ranged_breakpoint (struct breakpoint
*b
)
9683 struct bp_location
*bl
= b
->loc
;
9684 struct ui_out
*uiout
= current_uiout
;
9687 gdb_assert (b
->type
== bp_hardware_breakpoint
);
9689 uiout
->message (_("Hardware assisted ranged breakpoint %d from %s to %s."),
9690 b
->number
, paddress (bl
->gdbarch
, bl
->address
),
9691 paddress (bl
->gdbarch
, bl
->address
+ bl
->length
- 1));
9694 /* Implement the "print_recreate" breakpoint_ops method for
9695 ranged breakpoints. */
9698 print_recreate_ranged_breakpoint (struct breakpoint
*b
, struct ui_file
*fp
)
9700 fprintf_unfiltered (fp
, "break-range %s, %s",
9701 event_location_to_string (b
->location
.get ()),
9702 event_location_to_string (b
->location_range_end
.get ()));
9703 print_recreate_thread (b
, fp
);
9706 /* The breakpoint_ops structure to be used in ranged breakpoints. */
9708 static struct breakpoint_ops ranged_breakpoint_ops
;
9710 /* Find the address where the end of the breakpoint range should be
9711 placed, given the SAL of the end of the range. This is so that if
9712 the user provides a line number, the end of the range is set to the
9713 last instruction of the given line. */
9716 find_breakpoint_range_end (struct symtab_and_line sal
)
9720 /* If the user provided a PC value, use it. Otherwise,
9721 find the address of the end of the given location. */
9722 if (sal
.explicit_pc
)
9729 ret
= find_line_pc_range (sal
, &start
, &end
);
9731 error (_("Could not find location of the end of the range."));
9733 /* find_line_pc_range returns the start of the next line. */
9740 /* Implement the "break-range" CLI command. */
9743 break_range_command (const char *arg
, int from_tty
)
9745 const char *arg_start
;
9746 struct linespec_result canonical_start
, canonical_end
;
9747 int bp_count
, can_use_bp
, length
;
9749 struct breakpoint
*b
;
9751 /* We don't support software ranged breakpoints. */
9752 if (target_ranged_break_num_registers () < 0)
9753 error (_("This target does not support hardware ranged breakpoints."));
9755 bp_count
= hw_breakpoint_used_count ();
9756 bp_count
+= target_ranged_break_num_registers ();
9757 can_use_bp
= target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
9760 error (_("Hardware breakpoints used exceeds limit."));
9762 arg
= skip_spaces (arg
);
9763 if (arg
== NULL
|| arg
[0] == '\0')
9764 error(_("No address range specified."));
9767 event_location_up start_location
= string_to_event_location (&arg
,
9769 parse_breakpoint_sals (start_location
.get (), &canonical_start
);
9772 error (_("Too few arguments."));
9773 else if (canonical_start
.lsals
.empty ())
9774 error (_("Could not find location of the beginning of the range."));
9776 const linespec_sals
&lsal_start
= canonical_start
.lsals
[0];
9778 if (canonical_start
.lsals
.size () > 1
9779 || lsal_start
.sals
.size () != 1)
9780 error (_("Cannot create a ranged breakpoint with multiple locations."));
9782 const symtab_and_line
&sal_start
= lsal_start
.sals
[0];
9783 std::string
addr_string_start (arg_start
, arg
- arg_start
);
9785 arg
++; /* Skip the comma. */
9786 arg
= skip_spaces (arg
);
9788 /* Parse the end location. */
9792 /* We call decode_line_full directly here instead of using
9793 parse_breakpoint_sals because we need to specify the start location's
9794 symtab and line as the default symtab and line for the end of the
9795 range. This makes it possible to have ranges like "foo.c:27, +14",
9796 where +14 means 14 lines from the start location. */
9797 event_location_up end_location
= string_to_event_location (&arg
,
9799 decode_line_full (end_location
.get (), DECODE_LINE_FUNFIRSTLINE
, NULL
,
9800 sal_start
.symtab
, sal_start
.line
,
9801 &canonical_end
, NULL
, NULL
);
9803 if (canonical_end
.lsals
.empty ())
9804 error (_("Could not find location of the end of the range."));
9806 const linespec_sals
&lsal_end
= canonical_end
.lsals
[0];
9807 if (canonical_end
.lsals
.size () > 1
9808 || lsal_end
.sals
.size () != 1)
9809 error (_("Cannot create a ranged breakpoint with multiple locations."));
9811 const symtab_and_line
&sal_end
= lsal_end
.sals
[0];
9813 end
= find_breakpoint_range_end (sal_end
);
9814 if (sal_start
.pc
> end
)
9815 error (_("Invalid address range, end precedes start."));
9817 length
= end
- sal_start
.pc
+ 1;
9819 /* Length overflowed. */
9820 error (_("Address range too large."));
9821 else if (length
== 1)
9823 /* This range is simple enough to be handled by
9824 the `hbreak' command. */
9825 hbreak_command (&addr_string_start
[0], 1);
9830 /* Now set up the breakpoint. */
9831 b
= set_raw_breakpoint (get_current_arch (), sal_start
,
9832 bp_hardware_breakpoint
, &ranged_breakpoint_ops
);
9833 set_breakpoint_count (breakpoint_count
+ 1);
9834 b
->number
= breakpoint_count
;
9835 b
->disposition
= disp_donttouch
;
9836 b
->location
= std::move (start_location
);
9837 b
->location_range_end
= std::move (end_location
);
9838 b
->loc
->length
= length
;
9841 gdb::observers::breakpoint_created
.notify (b
);
9842 update_global_location_list (UGLL_MAY_INSERT
);
9845 /* Return non-zero if EXP is verified as constant. Returned zero
9846 means EXP is variable. Also the constant detection may fail for
9847 some constant expressions and in such case still falsely return
9851 watchpoint_exp_is_const (const struct expression
*exp
)
9859 /* We are only interested in the descriptor of each element. */
9860 operator_length (exp
, i
, &oplenp
, &argsp
);
9863 switch (exp
->elts
[i
].opcode
)
9873 case BINOP_LOGICAL_AND
:
9874 case BINOP_LOGICAL_OR
:
9875 case BINOP_BITWISE_AND
:
9876 case BINOP_BITWISE_IOR
:
9877 case BINOP_BITWISE_XOR
:
9879 case BINOP_NOTEQUAL
:
9905 case OP_OBJC_NSSTRING
:
9908 case UNOP_LOGICAL_NOT
:
9909 case UNOP_COMPLEMENT
:
9914 case UNOP_CAST_TYPE
:
9915 case UNOP_REINTERPRET_CAST
:
9916 case UNOP_DYNAMIC_CAST
:
9917 /* Unary, binary and ternary operators: We have to check
9918 their operands. If they are constant, then so is the
9919 result of that operation. For instance, if A and B are
9920 determined to be constants, then so is "A + B".
9922 UNOP_IND is one exception to the rule above, because the
9923 value of *ADDR is not necessarily a constant, even when
9928 /* Check whether the associated symbol is a constant.
9930 We use SYMBOL_CLASS rather than TYPE_CONST because it's
9931 possible that a buggy compiler could mark a variable as
9932 constant even when it is not, and TYPE_CONST would return
9933 true in this case, while SYMBOL_CLASS wouldn't.
9935 We also have to check for function symbols because they
9936 are always constant. */
9938 struct symbol
*s
= exp
->elts
[i
+ 2].symbol
;
9940 if (SYMBOL_CLASS (s
) != LOC_BLOCK
9941 && SYMBOL_CLASS (s
) != LOC_CONST
9942 && SYMBOL_CLASS (s
) != LOC_CONST_BYTES
)
9947 /* The default action is to return 0 because we are using
9948 the optimistic approach here: If we don't know something,
9949 then it is not a constant. */
9958 /* Watchpoint destructor. */
9960 watchpoint::~watchpoint ()
9962 xfree (this->exp_string
);
9963 xfree (this->exp_string_reparse
);
9966 /* Implement the "re_set" breakpoint_ops method for watchpoints. */
9969 re_set_watchpoint (struct breakpoint
*b
)
9971 struct watchpoint
*w
= (struct watchpoint
*) b
;
9973 /* Watchpoint can be either on expression using entirely global
9974 variables, or it can be on local variables.
9976 Watchpoints of the first kind are never auto-deleted, and even
9977 persist across program restarts. Since they can use variables
9978 from shared libraries, we need to reparse expression as libraries
9979 are loaded and unloaded.
9981 Watchpoints on local variables can also change meaning as result
9982 of solib event. For example, if a watchpoint uses both a local
9983 and a global variables in expression, it's a local watchpoint,
9984 but unloading of a shared library will make the expression
9985 invalid. This is not a very common use case, but we still
9986 re-evaluate expression, to avoid surprises to the user.
9988 Note that for local watchpoints, we re-evaluate it only if
9989 watchpoints frame id is still valid. If it's not, it means the
9990 watchpoint is out of scope and will be deleted soon. In fact,
9991 I'm not sure we'll ever be called in this case.
9993 If a local watchpoint's frame id is still valid, then
9994 w->exp_valid_block is likewise valid, and we can safely use it.
9996 Don't do anything about disabled watchpoints, since they will be
9997 reevaluated again when enabled. */
9998 update_watchpoint (w
, 1 /* reparse */);
10001 /* Implement the "insert" breakpoint_ops method for hardware watchpoints. */
10004 insert_watchpoint (struct bp_location
*bl
)
10006 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10007 int length
= w
->exact
? 1 : bl
->length
;
10009 return target_insert_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
10010 w
->cond_exp
.get ());
10013 /* Implement the "remove" breakpoint_ops method for hardware watchpoints. */
10016 remove_watchpoint (struct bp_location
*bl
, enum remove_bp_reason reason
)
10018 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10019 int length
= w
->exact
? 1 : bl
->length
;
10021 return target_remove_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
10022 w
->cond_exp
.get ());
10026 breakpoint_hit_watchpoint (const struct bp_location
*bl
,
10027 const address_space
*aspace
, CORE_ADDR bp_addr
,
10028 const struct target_waitstatus
*ws
)
10030 struct breakpoint
*b
= bl
->owner
;
10031 struct watchpoint
*w
= (struct watchpoint
*) b
;
10033 /* Continuable hardware watchpoints are treated as non-existent if the
10034 reason we stopped wasn't a hardware watchpoint (we didn't stop on
10035 some data address). Otherwise gdb won't stop on a break instruction
10036 in the code (not from a breakpoint) when a hardware watchpoint has
10037 been defined. Also skip watchpoints which we know did not trigger
10038 (did not match the data address). */
10039 if (is_hardware_watchpoint (b
)
10040 && w
->watchpoint_triggered
== watch_triggered_no
)
10047 check_status_watchpoint (bpstat bs
)
10049 gdb_assert (is_watchpoint (bs
->breakpoint_at
));
10051 bpstat_check_watchpoint (bs
);
10054 /* Implement the "resources_needed" breakpoint_ops method for
10055 hardware watchpoints. */
10058 resources_needed_watchpoint (const struct bp_location
*bl
)
10060 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10061 int length
= w
->exact
? 1 : bl
->length
;
10063 return target_region_ok_for_hw_watchpoint (bl
->address
, length
);
10066 /* Implement the "works_in_software_mode" breakpoint_ops method for
10067 hardware watchpoints. */
10070 works_in_software_mode_watchpoint (const struct breakpoint
*b
)
10072 /* Read and access watchpoints only work with hardware support. */
10073 return b
->type
== bp_watchpoint
|| b
->type
== bp_hardware_watchpoint
;
10076 static enum print_stop_action
10077 print_it_watchpoint (bpstat bs
)
10079 struct breakpoint
*b
;
10080 enum print_stop_action result
;
10081 struct watchpoint
*w
;
10082 struct ui_out
*uiout
= current_uiout
;
10084 gdb_assert (bs
->bp_location_at
!= NULL
);
10086 b
= bs
->breakpoint_at
;
10087 w
= (struct watchpoint
*) b
;
10089 annotate_watchpoint (b
->number
);
10090 maybe_print_thread_hit_breakpoint (uiout
);
10094 gdb::optional
<ui_out_emit_tuple
> tuple_emitter
;
10097 case bp_watchpoint
:
10098 case bp_hardware_watchpoint
:
10099 if (uiout
->is_mi_like_p ())
10100 uiout
->field_string
10101 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
10103 tuple_emitter
.emplace (uiout
, "value");
10104 uiout
->text ("\nOld value = ");
10105 watchpoint_value_print (bs
->old_val
.get (), &stb
);
10106 uiout
->field_stream ("old", stb
);
10107 uiout
->text ("\nNew value = ");
10108 watchpoint_value_print (w
->val
.get (), &stb
);
10109 uiout
->field_stream ("new", stb
);
10110 uiout
->text ("\n");
10111 /* More than one watchpoint may have been triggered. */
10112 result
= PRINT_UNKNOWN
;
10115 case bp_read_watchpoint
:
10116 if (uiout
->is_mi_like_p ())
10117 uiout
->field_string
10118 ("reason", async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
10120 tuple_emitter
.emplace (uiout
, "value");
10121 uiout
->text ("\nValue = ");
10122 watchpoint_value_print (w
->val
.get (), &stb
);
10123 uiout
->field_stream ("value", stb
);
10124 uiout
->text ("\n");
10125 result
= PRINT_UNKNOWN
;
10128 case bp_access_watchpoint
:
10129 if (bs
->old_val
!= NULL
)
10131 if (uiout
->is_mi_like_p ())
10132 uiout
->field_string
10134 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
10136 tuple_emitter
.emplace (uiout
, "value");
10137 uiout
->text ("\nOld value = ");
10138 watchpoint_value_print (bs
->old_val
.get (), &stb
);
10139 uiout
->field_stream ("old", stb
);
10140 uiout
->text ("\nNew value = ");
10145 if (uiout
->is_mi_like_p ())
10146 uiout
->field_string
10148 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
10149 tuple_emitter
.emplace (uiout
, "value");
10150 uiout
->text ("\nValue = ");
10152 watchpoint_value_print (w
->val
.get (), &stb
);
10153 uiout
->field_stream ("new", stb
);
10154 uiout
->text ("\n");
10155 result
= PRINT_UNKNOWN
;
10158 result
= PRINT_UNKNOWN
;
10164 /* Implement the "print_mention" breakpoint_ops method for hardware
10168 print_mention_watchpoint (struct breakpoint
*b
)
10170 struct watchpoint
*w
= (struct watchpoint
*) b
;
10171 struct ui_out
*uiout
= current_uiout
;
10172 const char *tuple_name
;
10176 case bp_watchpoint
:
10177 uiout
->text ("Watchpoint ");
10178 tuple_name
= "wpt";
10180 case bp_hardware_watchpoint
:
10181 uiout
->text ("Hardware watchpoint ");
10182 tuple_name
= "wpt";
10184 case bp_read_watchpoint
:
10185 uiout
->text ("Hardware read watchpoint ");
10186 tuple_name
= "hw-rwpt";
10188 case bp_access_watchpoint
:
10189 uiout
->text ("Hardware access (read/write) watchpoint ");
10190 tuple_name
= "hw-awpt";
10193 internal_error (__FILE__
, __LINE__
,
10194 _("Invalid hardware watchpoint type."));
10197 ui_out_emit_tuple
tuple_emitter (uiout
, tuple_name
);
10198 uiout
->field_signed ("number", b
->number
);
10199 uiout
->text (": ");
10200 uiout
->field_string ("exp", w
->exp_string
);
10203 /* Implement the "print_recreate" breakpoint_ops method for
10207 print_recreate_watchpoint (struct breakpoint
*b
, struct ui_file
*fp
)
10209 struct watchpoint
*w
= (struct watchpoint
*) b
;
10213 case bp_watchpoint
:
10214 case bp_hardware_watchpoint
:
10215 fprintf_unfiltered (fp
, "watch");
10217 case bp_read_watchpoint
:
10218 fprintf_unfiltered (fp
, "rwatch");
10220 case bp_access_watchpoint
:
10221 fprintf_unfiltered (fp
, "awatch");
10224 internal_error (__FILE__
, __LINE__
,
10225 _("Invalid watchpoint type."));
10228 fprintf_unfiltered (fp
, " %s", w
->exp_string
);
10229 print_recreate_thread (b
, fp
);
10232 /* Implement the "explains_signal" breakpoint_ops method for
10236 explains_signal_watchpoint (struct breakpoint
*b
, enum gdb_signal sig
)
10238 /* A software watchpoint cannot cause a signal other than
10239 GDB_SIGNAL_TRAP. */
10240 if (b
->type
== bp_watchpoint
&& sig
!= GDB_SIGNAL_TRAP
)
10246 /* The breakpoint_ops structure to be used in hardware watchpoints. */
10248 static struct breakpoint_ops watchpoint_breakpoint_ops
;
10250 /* Implement the "insert" breakpoint_ops method for
10251 masked hardware watchpoints. */
10254 insert_masked_watchpoint (struct bp_location
*bl
)
10256 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10258 return target_insert_mask_watchpoint (bl
->address
, w
->hw_wp_mask
,
10259 bl
->watchpoint_type
);
10262 /* Implement the "remove" breakpoint_ops method for
10263 masked hardware watchpoints. */
10266 remove_masked_watchpoint (struct bp_location
*bl
, enum remove_bp_reason reason
)
10268 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10270 return target_remove_mask_watchpoint (bl
->address
, w
->hw_wp_mask
,
10271 bl
->watchpoint_type
);
10274 /* Implement the "resources_needed" breakpoint_ops method for
10275 masked hardware watchpoints. */
10278 resources_needed_masked_watchpoint (const struct bp_location
*bl
)
10280 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10282 return target_masked_watch_num_registers (bl
->address
, w
->hw_wp_mask
);
10285 /* Implement the "works_in_software_mode" breakpoint_ops method for
10286 masked hardware watchpoints. */
10289 works_in_software_mode_masked_watchpoint (const struct breakpoint
*b
)
10294 /* Implement the "print_it" breakpoint_ops method for
10295 masked hardware watchpoints. */
10297 static enum print_stop_action
10298 print_it_masked_watchpoint (bpstat bs
)
10300 struct breakpoint
*b
= bs
->breakpoint_at
;
10301 struct ui_out
*uiout
= current_uiout
;
10303 /* Masked watchpoints have only one location. */
10304 gdb_assert (b
->loc
&& b
->loc
->next
== NULL
);
10306 annotate_watchpoint (b
->number
);
10307 maybe_print_thread_hit_breakpoint (uiout
);
10311 case bp_hardware_watchpoint
:
10312 if (uiout
->is_mi_like_p ())
10313 uiout
->field_string
10314 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
10317 case bp_read_watchpoint
:
10318 if (uiout
->is_mi_like_p ())
10319 uiout
->field_string
10320 ("reason", async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
10323 case bp_access_watchpoint
:
10324 if (uiout
->is_mi_like_p ())
10325 uiout
->field_string
10327 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
10330 internal_error (__FILE__
, __LINE__
,
10331 _("Invalid hardware watchpoint type."));
10335 uiout
->text (_("\n\
10336 Check the underlying instruction at PC for the memory\n\
10337 address and value which triggered this watchpoint.\n"));
10338 uiout
->text ("\n");
10340 /* More than one watchpoint may have been triggered. */
10341 return PRINT_UNKNOWN
;
10344 /* Implement the "print_one_detail" breakpoint_ops method for
10345 masked hardware watchpoints. */
10348 print_one_detail_masked_watchpoint (const struct breakpoint
*b
,
10349 struct ui_out
*uiout
)
10351 struct watchpoint
*w
= (struct watchpoint
*) b
;
10353 /* Masked watchpoints have only one location. */
10354 gdb_assert (b
->loc
&& b
->loc
->next
== NULL
);
10356 uiout
->text ("\tmask ");
10357 uiout
->field_core_addr ("mask", b
->loc
->gdbarch
, w
->hw_wp_mask
);
10358 uiout
->text ("\n");
10361 /* Implement the "print_mention" breakpoint_ops method for
10362 masked hardware watchpoints. */
10365 print_mention_masked_watchpoint (struct breakpoint
*b
)
10367 struct watchpoint
*w
= (struct watchpoint
*) b
;
10368 struct ui_out
*uiout
= current_uiout
;
10369 const char *tuple_name
;
10373 case bp_hardware_watchpoint
:
10374 uiout
->text ("Masked hardware watchpoint ");
10375 tuple_name
= "wpt";
10377 case bp_read_watchpoint
:
10378 uiout
->text ("Masked hardware read watchpoint ");
10379 tuple_name
= "hw-rwpt";
10381 case bp_access_watchpoint
:
10382 uiout
->text ("Masked hardware access (read/write) watchpoint ");
10383 tuple_name
= "hw-awpt";
10386 internal_error (__FILE__
, __LINE__
,
10387 _("Invalid hardware watchpoint type."));
10390 ui_out_emit_tuple
tuple_emitter (uiout
, tuple_name
);
10391 uiout
->field_signed ("number", b
->number
);
10392 uiout
->text (": ");
10393 uiout
->field_string ("exp", w
->exp_string
);
10396 /* Implement the "print_recreate" breakpoint_ops method for
10397 masked hardware watchpoints. */
10400 print_recreate_masked_watchpoint (struct breakpoint
*b
, struct ui_file
*fp
)
10402 struct watchpoint
*w
= (struct watchpoint
*) b
;
10406 case bp_hardware_watchpoint
:
10407 fprintf_unfiltered (fp
, "watch");
10409 case bp_read_watchpoint
:
10410 fprintf_unfiltered (fp
, "rwatch");
10412 case bp_access_watchpoint
:
10413 fprintf_unfiltered (fp
, "awatch");
10416 internal_error (__FILE__
, __LINE__
,
10417 _("Invalid hardware watchpoint type."));
10420 fprintf_unfiltered (fp
, " %s mask 0x%s", w
->exp_string
,
10421 phex (w
->hw_wp_mask
, sizeof (CORE_ADDR
)));
10422 print_recreate_thread (b
, fp
);
10425 /* The breakpoint_ops structure to be used in masked hardware watchpoints. */
10427 static struct breakpoint_ops masked_watchpoint_breakpoint_ops
;
10429 /* Tell whether the given watchpoint is a masked hardware watchpoint. */
10432 is_masked_watchpoint (const struct breakpoint
*b
)
10434 return b
->ops
== &masked_watchpoint_breakpoint_ops
;
10437 /* accessflag: hw_write: watch write,
10438 hw_read: watch read,
10439 hw_access: watch access (read or write) */
10441 watch_command_1 (const char *arg
, int accessflag
, int from_tty
,
10442 int just_location
, int internal
)
10444 struct breakpoint
*scope_breakpoint
= NULL
;
10445 const struct block
*exp_valid_block
= NULL
, *cond_exp_valid_block
= NULL
;
10446 struct value
*result
;
10447 int saved_bitpos
= 0, saved_bitsize
= 0;
10448 const char *exp_start
= NULL
;
10449 const char *exp_end
= NULL
;
10450 const char *tok
, *end_tok
;
10452 const char *cond_start
= NULL
;
10453 const char *cond_end
= NULL
;
10454 enum bptype bp_type
;
10457 /* Flag to indicate whether we are going to use masks for
10458 the hardware watchpoint. */
10460 CORE_ADDR mask
= 0;
10462 /* Make sure that we actually have parameters to parse. */
10463 if (arg
!= NULL
&& arg
[0] != '\0')
10465 const char *value_start
;
10467 exp_end
= arg
+ strlen (arg
);
10469 /* Look for "parameter value" pairs at the end
10470 of the arguments string. */
10471 for (tok
= exp_end
- 1; tok
> arg
; tok
--)
10473 /* Skip whitespace at the end of the argument list. */
10474 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
10477 /* Find the beginning of the last token.
10478 This is the value of the parameter. */
10479 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
10481 value_start
= tok
+ 1;
10483 /* Skip whitespace. */
10484 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
10489 /* Find the beginning of the second to last token.
10490 This is the parameter itself. */
10491 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
10494 toklen
= end_tok
- tok
+ 1;
10496 if (toklen
== 6 && startswith (tok
, "thread"))
10498 struct thread_info
*thr
;
10499 /* At this point we've found a "thread" token, which means
10500 the user is trying to set a watchpoint that triggers
10501 only in a specific thread. */
10505 error(_("You can specify only one thread."));
10507 /* Extract the thread ID from the next token. */
10508 thr
= parse_thread_id (value_start
, &endp
);
10510 /* Check if the user provided a valid thread ID. */
10511 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
10512 invalid_thread_id_error (value_start
);
10514 thread
= thr
->global_num
;
10516 else if (toklen
== 4 && startswith (tok
, "mask"))
10518 /* We've found a "mask" token, which means the user wants to
10519 create a hardware watchpoint that is going to have the mask
10521 struct value
*mask_value
, *mark
;
10524 error(_("You can specify only one mask."));
10526 use_mask
= just_location
= 1;
10528 mark
= value_mark ();
10529 mask_value
= parse_to_comma_and_eval (&value_start
);
10530 mask
= value_as_address (mask_value
);
10531 value_free_to_mark (mark
);
10534 /* We didn't recognize what we found. We should stop here. */
10537 /* Truncate the string and get rid of the "parameter value" pair before
10538 the arguments string is parsed by the parse_exp_1 function. */
10545 /* Parse the rest of the arguments. From here on out, everything
10546 is in terms of a newly allocated string instead of the original
10548 std::string
expression (arg
, exp_end
- arg
);
10549 exp_start
= arg
= expression
.c_str ();
10550 innermost_block_tracker tracker
;
10551 expression_up exp
= parse_exp_1 (&arg
, 0, 0, 0, &tracker
);
10553 /* Remove trailing whitespace from the expression before saving it.
10554 This makes the eventual display of the expression string a bit
10556 while (exp_end
> exp_start
&& (exp_end
[-1] == ' ' || exp_end
[-1] == '\t'))
10559 /* Checking if the expression is not constant. */
10560 if (watchpoint_exp_is_const (exp
.get ()))
10564 len
= exp_end
- exp_start
;
10565 while (len
> 0 && isspace (exp_start
[len
- 1]))
10567 error (_("Cannot watch constant value `%.*s'."), len
, exp_start
);
10570 exp_valid_block
= tracker
.block ();
10571 struct value
*mark
= value_mark ();
10572 struct value
*val_as_value
= nullptr;
10573 fetch_subexp_value (exp
.get (), &pc
, &val_as_value
, &result
, NULL
,
10576 if (val_as_value
!= NULL
&& just_location
)
10578 saved_bitpos
= value_bitpos (val_as_value
);
10579 saved_bitsize
= value_bitsize (val_as_value
);
10587 exp_valid_block
= NULL
;
10588 val
= release_value (value_addr (result
));
10589 value_free_to_mark (mark
);
10593 ret
= target_masked_watch_num_registers (value_as_address (val
.get ()),
10596 error (_("This target does not support masked watchpoints."));
10597 else if (ret
== -2)
10598 error (_("Invalid mask or memory region."));
10601 else if (val_as_value
!= NULL
)
10602 val
= release_value (val_as_value
);
10604 tok
= skip_spaces (arg
);
10605 end_tok
= skip_to_space (tok
);
10607 toklen
= end_tok
- tok
;
10608 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
10610 tok
= cond_start
= end_tok
+ 1;
10611 innermost_block_tracker if_tracker
;
10612 parse_exp_1 (&tok
, 0, 0, 0, &if_tracker
);
10614 /* The watchpoint expression may not be local, but the condition
10615 may still be. E.g.: `watch global if local > 0'. */
10616 cond_exp_valid_block
= if_tracker
.block ();
10621 error (_("Junk at end of command."));
10623 frame_info
*wp_frame
= block_innermost_frame (exp_valid_block
);
10625 /* Save this because create_internal_breakpoint below invalidates
10627 frame_id watchpoint_frame
= get_frame_id (wp_frame
);
10629 /* If the expression is "local", then set up a "watchpoint scope"
10630 breakpoint at the point where we've left the scope of the watchpoint
10631 expression. Create the scope breakpoint before the watchpoint, so
10632 that we will encounter it first in bpstat_stop_status. */
10633 if (exp_valid_block
!= NULL
&& wp_frame
!= NULL
)
10635 frame_id caller_frame_id
= frame_unwind_caller_id (wp_frame
);
10637 if (frame_id_p (caller_frame_id
))
10639 gdbarch
*caller_arch
= frame_unwind_caller_arch (wp_frame
);
10640 CORE_ADDR caller_pc
= frame_unwind_caller_pc (wp_frame
);
10643 = create_internal_breakpoint (caller_arch
, caller_pc
,
10644 bp_watchpoint_scope
,
10645 &momentary_breakpoint_ops
);
10647 /* create_internal_breakpoint could invalidate WP_FRAME. */
10650 scope_breakpoint
->enable_state
= bp_enabled
;
10652 /* Automatically delete the breakpoint when it hits. */
10653 scope_breakpoint
->disposition
= disp_del
;
10655 /* Only break in the proper frame (help with recursion). */
10656 scope_breakpoint
->frame_id
= caller_frame_id
;
10658 /* Set the address at which we will stop. */
10659 scope_breakpoint
->loc
->gdbarch
= caller_arch
;
10660 scope_breakpoint
->loc
->requested_address
= caller_pc
;
10661 scope_breakpoint
->loc
->address
10662 = adjust_breakpoint_address (scope_breakpoint
->loc
->gdbarch
,
10663 scope_breakpoint
->loc
->requested_address
,
10664 scope_breakpoint
->type
);
10668 /* Now set up the breakpoint. We create all watchpoints as hardware
10669 watchpoints here even if hardware watchpoints are turned off, a call
10670 to update_watchpoint later in this function will cause the type to
10671 drop back to bp_watchpoint (software watchpoint) if required. */
10673 if (accessflag
== hw_read
)
10674 bp_type
= bp_read_watchpoint
;
10675 else if (accessflag
== hw_access
)
10676 bp_type
= bp_access_watchpoint
;
10678 bp_type
= bp_hardware_watchpoint
;
10680 std::unique_ptr
<watchpoint
> w (new watchpoint ());
10683 init_raw_breakpoint_without_location (w
.get (), NULL
, bp_type
,
10684 &masked_watchpoint_breakpoint_ops
);
10686 init_raw_breakpoint_without_location (w
.get (), NULL
, bp_type
,
10687 &watchpoint_breakpoint_ops
);
10688 w
->thread
= thread
;
10689 w
->disposition
= disp_donttouch
;
10690 w
->pspace
= current_program_space
;
10691 w
->exp
= std::move (exp
);
10692 w
->exp_valid_block
= exp_valid_block
;
10693 w
->cond_exp_valid_block
= cond_exp_valid_block
;
10696 struct type
*t
= value_type (val
.get ());
10697 CORE_ADDR addr
= value_as_address (val
.get ());
10699 w
->exp_string_reparse
10700 = current_language
->la_watch_location_expression (t
, addr
).release ();
10702 w
->exp_string
= xstrprintf ("-location %.*s",
10703 (int) (exp_end
- exp_start
), exp_start
);
10706 w
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
10710 w
->hw_wp_mask
= mask
;
10715 w
->val_bitpos
= saved_bitpos
;
10716 w
->val_bitsize
= saved_bitsize
;
10717 w
->val_valid
= true;
10721 w
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
10723 w
->cond_string
= 0;
10725 if (frame_id_p (watchpoint_frame
))
10727 w
->watchpoint_frame
= watchpoint_frame
;
10728 w
->watchpoint_thread
= inferior_ptid
;
10732 w
->watchpoint_frame
= null_frame_id
;
10733 w
->watchpoint_thread
= null_ptid
;
10736 if (scope_breakpoint
!= NULL
)
10738 /* The scope breakpoint is related to the watchpoint. We will
10739 need to act on them together. */
10740 w
->related_breakpoint
= scope_breakpoint
;
10741 scope_breakpoint
->related_breakpoint
= w
.get ();
10744 if (!just_location
)
10745 value_free_to_mark (mark
);
10747 /* Finally update the new watchpoint. This creates the locations
10748 that should be inserted. */
10749 update_watchpoint (w
.get (), 1);
10751 install_breakpoint (internal
, std::move (w
), 1);
10754 /* Return count of debug registers needed to watch the given expression.
10755 If the watchpoint cannot be handled in hardware return zero. */
10758 can_use_hardware_watchpoint (const std::vector
<value_ref_ptr
> &vals
)
10760 int found_memory_cnt
= 0;
10762 /* Did the user specifically forbid us to use hardware watchpoints? */
10763 if (!can_use_hw_watchpoints
)
10766 gdb_assert (!vals
.empty ());
10767 struct value
*head
= vals
[0].get ();
10769 /* Make sure that the value of the expression depends only upon
10770 memory contents, and values computed from them within GDB. If we
10771 find any register references or function calls, we can't use a
10772 hardware watchpoint.
10774 The idea here is that evaluating an expression generates a series
10775 of values, one holding the value of every subexpression. (The
10776 expression a*b+c has five subexpressions: a, b, a*b, c, and
10777 a*b+c.) GDB's values hold almost enough information to establish
10778 the criteria given above --- they identify memory lvalues,
10779 register lvalues, computed values, etcetera. So we can evaluate
10780 the expression, and then scan the chain of values that leaves
10781 behind to decide whether we can detect any possible change to the
10782 expression's final value using only hardware watchpoints.
10784 However, I don't think that the values returned by inferior
10785 function calls are special in any way. So this function may not
10786 notice that an expression involving an inferior function call
10787 can't be watched with hardware watchpoints. FIXME. */
10788 for (const value_ref_ptr
&iter
: vals
)
10790 struct value
*v
= iter
.get ();
10792 if (VALUE_LVAL (v
) == lval_memory
)
10794 if (v
!= head
&& value_lazy (v
))
10795 /* A lazy memory lvalue in the chain is one that GDB never
10796 needed to fetch; we either just used its address (e.g.,
10797 `a' in `a.b') or we never needed it at all (e.g., `a'
10798 in `a,b'). This doesn't apply to HEAD; if that is
10799 lazy then it was not readable, but watch it anyway. */
10803 /* Ahh, memory we actually used! Check if we can cover
10804 it with hardware watchpoints. */
10805 struct type
*vtype
= check_typedef (value_type (v
));
10807 /* We only watch structs and arrays if user asked for it
10808 explicitly, never if they just happen to appear in a
10809 middle of some value chain. */
10811 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
10812 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
10814 CORE_ADDR vaddr
= value_address (v
);
10818 len
= (target_exact_watchpoints
10819 && is_scalar_type_recursive (vtype
))?
10820 1 : TYPE_LENGTH (value_type (v
));
10822 num_regs
= target_region_ok_for_hw_watchpoint (vaddr
, len
);
10826 found_memory_cnt
+= num_regs
;
10830 else if (VALUE_LVAL (v
) != not_lval
10831 && deprecated_value_modifiable (v
) == 0)
10832 return 0; /* These are values from the history (e.g., $1). */
10833 else if (VALUE_LVAL (v
) == lval_register
)
10834 return 0; /* Cannot watch a register with a HW watchpoint. */
10837 /* The expression itself looks suitable for using a hardware
10838 watchpoint, but give the target machine a chance to reject it. */
10839 return found_memory_cnt
;
10843 watch_command_wrapper (const char *arg
, int from_tty
, int internal
)
10845 watch_command_1 (arg
, hw_write
, from_tty
, 0, internal
);
10848 /* A helper function that looks for the "-location" argument and then
10849 calls watch_command_1. */
10852 watch_maybe_just_location (const char *arg
, int accessflag
, int from_tty
)
10854 int just_location
= 0;
10857 && (check_for_argument (&arg
, "-location", sizeof ("-location") - 1)
10858 || check_for_argument (&arg
, "-l", sizeof ("-l") - 1)))
10861 watch_command_1 (arg
, accessflag
, from_tty
, just_location
, 0);
10865 watch_command (const char *arg
, int from_tty
)
10867 watch_maybe_just_location (arg
, hw_write
, from_tty
);
10871 rwatch_command_wrapper (const char *arg
, int from_tty
, int internal
)
10873 watch_command_1 (arg
, hw_read
, from_tty
, 0, internal
);
10877 rwatch_command (const char *arg
, int from_tty
)
10879 watch_maybe_just_location (arg
, hw_read
, from_tty
);
10883 awatch_command_wrapper (const char *arg
, int from_tty
, int internal
)
10885 watch_command_1 (arg
, hw_access
, from_tty
, 0, internal
);
10889 awatch_command (const char *arg
, int from_tty
)
10891 watch_maybe_just_location (arg
, hw_access
, from_tty
);
10895 /* Data for the FSM that manages the until(location)/advance commands
10896 in infcmd.c. Here because it uses the mechanisms of
10899 struct until_break_fsm
: public thread_fsm
10901 /* The thread that was current when the command was executed. */
10904 /* The breakpoint set at the destination location. */
10905 breakpoint_up location_breakpoint
;
10907 /* Breakpoint set at the return address in the caller frame. May be
10909 breakpoint_up caller_breakpoint
;
10911 until_break_fsm (struct interp
*cmd_interp
, int thread
,
10912 breakpoint_up
&&location_breakpoint
,
10913 breakpoint_up
&&caller_breakpoint
)
10914 : thread_fsm (cmd_interp
),
10916 location_breakpoint (std::move (location_breakpoint
)),
10917 caller_breakpoint (std::move (caller_breakpoint
))
10921 void clean_up (struct thread_info
*thread
) override
;
10922 bool should_stop (struct thread_info
*thread
) override
;
10923 enum async_reply_reason
do_async_reply_reason () override
;
10926 /* Implementation of the 'should_stop' FSM method for the
10927 until(location)/advance commands. */
10930 until_break_fsm::should_stop (struct thread_info
*tp
)
10932 if (bpstat_find_breakpoint (tp
->control
.stop_bpstat
,
10933 location_breakpoint
.get ()) != NULL
10934 || (caller_breakpoint
!= NULL
10935 && bpstat_find_breakpoint (tp
->control
.stop_bpstat
,
10936 caller_breakpoint
.get ()) != NULL
))
10942 /* Implementation of the 'clean_up' FSM method for the
10943 until(location)/advance commands. */
10946 until_break_fsm::clean_up (struct thread_info
*)
10948 /* Clean up our temporary breakpoints. */
10949 location_breakpoint
.reset ();
10950 caller_breakpoint
.reset ();
10951 delete_longjmp_breakpoint (thread
);
10954 /* Implementation of the 'async_reply_reason' FSM method for the
10955 until(location)/advance commands. */
10957 enum async_reply_reason
10958 until_break_fsm::do_async_reply_reason ()
10960 return EXEC_ASYNC_LOCATION_REACHED
;
10964 until_break_command (const char *arg
, int from_tty
, int anywhere
)
10966 struct frame_info
*frame
;
10967 struct gdbarch
*frame_gdbarch
;
10968 struct frame_id stack_frame_id
;
10969 struct frame_id caller_frame_id
;
10971 struct thread_info
*tp
;
10973 clear_proceed_status (0);
10975 /* Set a breakpoint where the user wants it and at return from
10978 event_location_up location
= string_to_event_location (&arg
, current_language
);
10980 std::vector
<symtab_and_line
> sals
10981 = (last_displayed_sal_is_valid ()
10982 ? decode_line_1 (location
.get (), DECODE_LINE_FUNFIRSTLINE
, NULL
,
10983 get_last_displayed_symtab (),
10984 get_last_displayed_line ())
10985 : decode_line_1 (location
.get (), DECODE_LINE_FUNFIRSTLINE
,
10988 if (sals
.size () != 1)
10989 error (_("Couldn't get information on specified line."));
10991 symtab_and_line
&sal
= sals
[0];
10994 error (_("Junk at end of arguments."));
10996 resolve_sal_pc (&sal
);
10998 tp
= inferior_thread ();
10999 thread
= tp
->global_num
;
11001 /* Note linespec handling above invalidates the frame chain.
11002 Installing a breakpoint also invalidates the frame chain (as it
11003 may need to switch threads), so do any frame handling before
11006 frame
= get_selected_frame (NULL
);
11007 frame_gdbarch
= get_frame_arch (frame
);
11008 stack_frame_id
= get_stack_frame_id (frame
);
11009 caller_frame_id
= frame_unwind_caller_id (frame
);
11011 /* Keep within the current frame, or in frames called by the current
11014 breakpoint_up caller_breakpoint
;
11016 gdb::optional
<delete_longjmp_breakpoint_cleanup
> lj_deleter
;
11018 if (frame_id_p (caller_frame_id
))
11020 struct symtab_and_line sal2
;
11021 struct gdbarch
*caller_gdbarch
;
11023 sal2
= find_pc_line (frame_unwind_caller_pc (frame
), 0);
11024 sal2
.pc
= frame_unwind_caller_pc (frame
);
11025 caller_gdbarch
= frame_unwind_caller_arch (frame
);
11026 caller_breakpoint
= set_momentary_breakpoint (caller_gdbarch
,
11031 set_longjmp_breakpoint (tp
, caller_frame_id
);
11032 lj_deleter
.emplace (thread
);
11035 /* set_momentary_breakpoint could invalidate FRAME. */
11038 breakpoint_up location_breakpoint
;
11040 /* If the user told us to continue until a specified location,
11041 we don't specify a frame at which we need to stop. */
11042 location_breakpoint
= set_momentary_breakpoint (frame_gdbarch
, sal
,
11043 null_frame_id
, bp_until
);
11045 /* Otherwise, specify the selected frame, because we want to stop
11046 only at the very same frame. */
11047 location_breakpoint
= set_momentary_breakpoint (frame_gdbarch
, sal
,
11048 stack_frame_id
, bp_until
);
11050 tp
->thread_fsm
= new until_break_fsm (command_interp (), tp
->global_num
,
11051 std::move (location_breakpoint
),
11052 std::move (caller_breakpoint
));
11055 lj_deleter
->release ();
11057 proceed (-1, GDB_SIGNAL_DEFAULT
);
11060 /* This function attempts to parse an optional "if <cond>" clause
11061 from the arg string. If one is not found, it returns NULL.
11063 Else, it returns a pointer to the condition string. (It does not
11064 attempt to evaluate the string against a particular block.) And,
11065 it updates arg to point to the first character following the parsed
11066 if clause in the arg string. */
11069 ep_parse_optional_if_clause (const char **arg
)
11071 const char *cond_string
;
11073 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
11076 /* Skip the "if" keyword. */
11079 /* Skip any extra leading whitespace, and record the start of the
11080 condition string. */
11081 *arg
= skip_spaces (*arg
);
11082 cond_string
= *arg
;
11084 /* Assume that the condition occupies the remainder of the arg
11086 (*arg
) += strlen (cond_string
);
11088 return cond_string
;
11091 /* Commands to deal with catching events, such as signals, exceptions,
11092 process start/exit, etc. */
11096 catch_fork_temporary
, catch_vfork_temporary
,
11097 catch_fork_permanent
, catch_vfork_permanent
11102 catch_fork_command_1 (const char *arg
, int from_tty
,
11103 struct cmd_list_element
*command
)
11105 struct gdbarch
*gdbarch
= get_current_arch ();
11106 const char *cond_string
= NULL
;
11107 catch_fork_kind fork_kind
;
11110 fork_kind
= (catch_fork_kind
) (uintptr_t) get_cmd_context (command
);
11111 tempflag
= (fork_kind
== catch_fork_temporary
11112 || fork_kind
== catch_vfork_temporary
);
11116 arg
= skip_spaces (arg
);
11118 /* The allowed syntax is:
11120 catch [v]fork if <cond>
11122 First, check if there's an if clause. */
11123 cond_string
= ep_parse_optional_if_clause (&arg
);
11125 if ((*arg
!= '\0') && !isspace (*arg
))
11126 error (_("Junk at end of arguments."));
11128 /* If this target supports it, create a fork or vfork catchpoint
11129 and enable reporting of such events. */
11132 case catch_fork_temporary
:
11133 case catch_fork_permanent
:
11134 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
11135 &catch_fork_breakpoint_ops
);
11137 case catch_vfork_temporary
:
11138 case catch_vfork_permanent
:
11139 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
11140 &catch_vfork_breakpoint_ops
);
11143 error (_("unsupported or unknown fork kind; cannot catch it"));
11149 catch_exec_command_1 (const char *arg
, int from_tty
,
11150 struct cmd_list_element
*command
)
11152 struct gdbarch
*gdbarch
= get_current_arch ();
11154 const char *cond_string
= NULL
;
11156 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
11160 arg
= skip_spaces (arg
);
11162 /* The allowed syntax is:
11164 catch exec if <cond>
11166 First, check if there's an if clause. */
11167 cond_string
= ep_parse_optional_if_clause (&arg
);
11169 if ((*arg
!= '\0') && !isspace (*arg
))
11170 error (_("Junk at end of arguments."));
11172 std::unique_ptr
<exec_catchpoint
> c (new exec_catchpoint ());
11173 init_catchpoint (c
.get (), gdbarch
, tempflag
, cond_string
,
11174 &catch_exec_breakpoint_ops
);
11175 c
->exec_pathname
= NULL
;
11177 install_breakpoint (0, std::move (c
), 1);
11181 init_ada_exception_breakpoint (struct breakpoint
*b
,
11182 struct gdbarch
*gdbarch
,
11183 struct symtab_and_line sal
,
11184 const char *addr_string
,
11185 const struct breakpoint_ops
*ops
,
11192 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
11194 loc_gdbarch
= gdbarch
;
11196 describe_other_breakpoints (loc_gdbarch
,
11197 sal
.pspace
, sal
.pc
, sal
.section
, -1);
11198 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
11199 version for exception catchpoints, because two catchpoints
11200 used for different exception names will use the same address.
11201 In this case, a "breakpoint ... also set at..." warning is
11202 unproductive. Besides, the warning phrasing is also a bit
11203 inappropriate, we should use the word catchpoint, and tell
11204 the user what type of catchpoint it is. The above is good
11205 enough for now, though. */
11208 init_raw_breakpoint (b
, gdbarch
, sal
, bp_catchpoint
, ops
);
11210 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
11211 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
11212 b
->location
= string_to_event_location (&addr_string
,
11213 language_def (language_ada
));
11214 b
->language
= language_ada
;
11219 /* Compare two breakpoints and return a strcmp-like result. */
11222 compare_breakpoints (const breakpoint
*a
, const breakpoint
*b
)
11224 uintptr_t ua
= (uintptr_t) a
;
11225 uintptr_t ub
= (uintptr_t) b
;
11227 if (a
->number
< b
->number
)
11229 else if (a
->number
> b
->number
)
11232 /* Now sort by address, in case we see, e..g, two breakpoints with
11236 return ua
> ub
? 1 : 0;
11239 /* Delete breakpoints by address or line. */
11242 clear_command (const char *arg
, int from_tty
)
11244 struct breakpoint
*b
;
11247 std::vector
<symtab_and_line
> decoded_sals
;
11248 symtab_and_line last_sal
;
11249 gdb::array_view
<symtab_and_line
> sals
;
11253 = decode_line_with_current_source (arg
,
11254 (DECODE_LINE_FUNFIRSTLINE
11255 | DECODE_LINE_LIST_MODE
));
11257 sals
= decoded_sals
;
11261 /* Set sal's line, symtab, pc, and pspace to the values
11262 corresponding to the last call to print_frame_info. If the
11263 codepoint is not valid, this will set all the fields to 0. */
11264 last_sal
= get_last_displayed_sal ();
11265 if (last_sal
.symtab
== 0)
11266 error (_("No source file specified."));
11272 /* We don't call resolve_sal_pc here. That's not as bad as it
11273 seems, because all existing breakpoints typically have both
11274 file/line and pc set. So, if clear is given file/line, we can
11275 match this to existing breakpoint without obtaining pc at all.
11277 We only support clearing given the address explicitly
11278 present in breakpoint table. Say, we've set breakpoint
11279 at file:line. There were several PC values for that file:line,
11280 due to optimization, all in one block.
11282 We've picked one PC value. If "clear" is issued with another
11283 PC corresponding to the same file:line, the breakpoint won't
11284 be cleared. We probably can still clear the breakpoint, but
11285 since the other PC value is never presented to user, user
11286 can only find it by guessing, and it does not seem important
11287 to support that. */
11289 /* For each line spec given, delete bps which correspond to it. Do
11290 it in two passes, solely to preserve the current behavior that
11291 from_tty is forced true if we delete more than one
11294 std::vector
<struct breakpoint
*> found
;
11295 for (const auto &sal
: sals
)
11297 const char *sal_fullname
;
11299 /* If exact pc given, clear bpts at that pc.
11300 If line given (pc == 0), clear all bpts on specified line.
11301 If defaulting, clear all bpts on default line
11304 defaulting sal.pc != 0 tests to do
11309 1 0 <can't happen> */
11311 sal_fullname
= (sal
.symtab
== NULL
11312 ? NULL
: symtab_to_fullname (sal
.symtab
));
11314 /* Find all matching breakpoints and add them to 'found'. */
11315 ALL_BREAKPOINTS (b
)
11318 /* Are we going to delete b? */
11319 if (b
->type
!= bp_none
&& !is_watchpoint (b
))
11321 struct bp_location
*loc
= b
->loc
;
11322 for (; loc
; loc
= loc
->next
)
11324 /* If the user specified file:line, don't allow a PC
11325 match. This matches historical gdb behavior. */
11326 int pc_match
= (!sal
.explicit_line
11328 && (loc
->pspace
== sal
.pspace
)
11329 && (loc
->address
== sal
.pc
)
11330 && (!section_is_overlay (loc
->section
)
11331 || loc
->section
== sal
.section
));
11332 int line_match
= 0;
11334 if ((default_match
|| sal
.explicit_line
)
11335 && loc
->symtab
!= NULL
11336 && sal_fullname
!= NULL
11337 && sal
.pspace
== loc
->pspace
11338 && loc
->line_number
== sal
.line
11339 && filename_cmp (symtab_to_fullname (loc
->symtab
),
11340 sal_fullname
) == 0)
11343 if (pc_match
|| line_match
)
11352 found
.push_back (b
);
11356 /* Now go thru the 'found' chain and delete them. */
11357 if (found
.empty ())
11360 error (_("No breakpoint at %s."), arg
);
11362 error (_("No breakpoint at this line."));
11365 /* Remove duplicates from the vec. */
11366 std::sort (found
.begin (), found
.end (),
11367 [] (const breakpoint
*bp_a
, const breakpoint
*bp_b
)
11369 return compare_breakpoints (bp_a
, bp_b
) < 0;
11371 found
.erase (std::unique (found
.begin (), found
.end (),
11372 [] (const breakpoint
*bp_a
, const breakpoint
*bp_b
)
11374 return compare_breakpoints (bp_a
, bp_b
) == 0;
11378 if (found
.size () > 1)
11379 from_tty
= 1; /* Always report if deleted more than one. */
11382 if (found
.size () == 1)
11383 printf_unfiltered (_("Deleted breakpoint "));
11385 printf_unfiltered (_("Deleted breakpoints "));
11388 for (breakpoint
*iter
: found
)
11391 printf_unfiltered ("%d ", iter
->number
);
11392 delete_breakpoint (iter
);
11395 putchar_unfiltered ('\n');
11398 /* Delete breakpoint in BS if they are `delete' breakpoints and
11399 all breakpoints that are marked for deletion, whether hit or not.
11400 This is called after any breakpoint is hit, or after errors. */
11403 breakpoint_auto_delete (bpstat bs
)
11405 struct breakpoint
*b
, *b_tmp
;
11407 for (; bs
; bs
= bs
->next
)
11408 if (bs
->breakpoint_at
11409 && bs
->breakpoint_at
->disposition
== disp_del
11411 delete_breakpoint (bs
->breakpoint_at
);
11413 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
11415 if (b
->disposition
== disp_del_at_next_stop
)
11416 delete_breakpoint (b
);
11420 /* A comparison function for bp_location AP and BP being interfaced to
11421 std::sort. Sort elements primarily by their ADDRESS (no matter what
11422 bl_address_is_meaningful says), secondarily by ordering first
11423 permanent elements and terciarily just ensuring the array is sorted
11424 stable way despite std::sort being an unstable algorithm. */
11427 bp_location_is_less_than (const bp_location
*a
, const bp_location
*b
)
11429 if (a
->address
!= b
->address
)
11430 return a
->address
< b
->address
;
11432 /* Sort locations at the same address by their pspace number, keeping
11433 locations of the same inferior (in a multi-inferior environment)
11436 if (a
->pspace
->num
!= b
->pspace
->num
)
11437 return a
->pspace
->num
< b
->pspace
->num
;
11439 /* Sort permanent breakpoints first. */
11440 if (a
->permanent
!= b
->permanent
)
11441 return a
->permanent
> b
->permanent
;
11443 /* Make the internal GDB representation stable across GDB runs
11444 where A and B memory inside GDB can differ. Breakpoint locations of
11445 the same type at the same address can be sorted in arbitrary order. */
11447 if (a
->owner
->number
!= b
->owner
->number
)
11448 return a
->owner
->number
< b
->owner
->number
;
11453 /* Set bp_locations_placed_address_before_address_max and
11454 bp_locations_shadow_len_after_address_max according to the current
11455 content of the bp_locations array. */
11458 bp_locations_target_extensions_update (void)
11460 struct bp_location
*bl
, **blp_tmp
;
11462 bp_locations_placed_address_before_address_max
= 0;
11463 bp_locations_shadow_len_after_address_max
= 0;
11465 ALL_BP_LOCATIONS (bl
, blp_tmp
)
11467 CORE_ADDR start
, end
, addr
;
11469 if (!bp_location_has_shadow (bl
))
11472 start
= bl
->target_info
.placed_address
;
11473 end
= start
+ bl
->target_info
.shadow_len
;
11475 gdb_assert (bl
->address
>= start
);
11476 addr
= bl
->address
- start
;
11477 if (addr
> bp_locations_placed_address_before_address_max
)
11478 bp_locations_placed_address_before_address_max
= addr
;
11480 /* Zero SHADOW_LEN would not pass bp_location_has_shadow. */
11482 gdb_assert (bl
->address
< end
);
11483 addr
= end
- bl
->address
;
11484 if (addr
> bp_locations_shadow_len_after_address_max
)
11485 bp_locations_shadow_len_after_address_max
= addr
;
11489 /* Download tracepoint locations if they haven't been. */
11492 download_tracepoint_locations (void)
11494 struct breakpoint
*b
;
11495 enum tribool can_download_tracepoint
= TRIBOOL_UNKNOWN
;
11497 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
11499 ALL_TRACEPOINTS (b
)
11501 struct bp_location
*bl
;
11502 struct tracepoint
*t
;
11503 int bp_location_downloaded
= 0;
11505 if ((b
->type
== bp_fast_tracepoint
11506 ? !may_insert_fast_tracepoints
11507 : !may_insert_tracepoints
))
11510 if (can_download_tracepoint
== TRIBOOL_UNKNOWN
)
11512 if (target_can_download_tracepoint ())
11513 can_download_tracepoint
= TRIBOOL_TRUE
;
11515 can_download_tracepoint
= TRIBOOL_FALSE
;
11518 if (can_download_tracepoint
== TRIBOOL_FALSE
)
11521 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
11523 /* In tracepoint, locations are _never_ duplicated, so
11524 should_be_inserted is equivalent to
11525 unduplicated_should_be_inserted. */
11526 if (!should_be_inserted (bl
) || bl
->inserted
)
11529 switch_to_program_space_and_thread (bl
->pspace
);
11531 target_download_tracepoint (bl
);
11534 bp_location_downloaded
= 1;
11536 t
= (struct tracepoint
*) b
;
11537 t
->number_on_target
= b
->number
;
11538 if (bp_location_downloaded
)
11539 gdb::observers::breakpoint_modified
.notify (b
);
11543 /* Swap the insertion/duplication state between two locations. */
11546 swap_insertion (struct bp_location
*left
, struct bp_location
*right
)
11548 const int left_inserted
= left
->inserted
;
11549 const int left_duplicate
= left
->duplicate
;
11550 const int left_needs_update
= left
->needs_update
;
11551 const struct bp_target_info left_target_info
= left
->target_info
;
11553 /* Locations of tracepoints can never be duplicated. */
11554 if (is_tracepoint (left
->owner
))
11555 gdb_assert (!left
->duplicate
);
11556 if (is_tracepoint (right
->owner
))
11557 gdb_assert (!right
->duplicate
);
11559 left
->inserted
= right
->inserted
;
11560 left
->duplicate
= right
->duplicate
;
11561 left
->needs_update
= right
->needs_update
;
11562 left
->target_info
= right
->target_info
;
11563 right
->inserted
= left_inserted
;
11564 right
->duplicate
= left_duplicate
;
11565 right
->needs_update
= left_needs_update
;
11566 right
->target_info
= left_target_info
;
11569 /* Force the re-insertion of the locations at ADDRESS. This is called
11570 once a new/deleted/modified duplicate location is found and we are evaluating
11571 conditions on the target's side. Such conditions need to be updated on
11575 force_breakpoint_reinsertion (struct bp_location
*bl
)
11577 struct bp_location
**locp
= NULL
, **loc2p
;
11578 struct bp_location
*loc
;
11579 CORE_ADDR address
= 0;
11582 address
= bl
->address
;
11583 pspace_num
= bl
->pspace
->num
;
11585 /* This is only meaningful if the target is
11586 evaluating conditions and if the user has
11587 opted for condition evaluation on the target's
11589 if (gdb_evaluates_breakpoint_condition_p ()
11590 || !target_supports_evaluation_of_breakpoint_conditions ())
11593 /* Flag all breakpoint locations with this address and
11594 the same program space as the location
11595 as "its condition has changed". We need to
11596 update the conditions on the target's side. */
11597 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, address
)
11601 if (!is_breakpoint (loc
->owner
)
11602 || pspace_num
!= loc
->pspace
->num
)
11605 /* Flag the location appropriately. We use a different state to
11606 let everyone know that we already updated the set of locations
11607 with addr bl->address and program space bl->pspace. This is so
11608 we don't have to keep calling these functions just to mark locations
11609 that have already been marked. */
11610 loc
->condition_changed
= condition_updated
;
11612 /* Free the agent expression bytecode as well. We will compute
11614 loc
->cond_bytecode
.reset ();
11617 /* Called whether new breakpoints are created, or existing breakpoints
11618 deleted, to update the global location list and recompute which
11619 locations are duplicate of which.
11621 The INSERT_MODE flag determines whether locations may not, may, or
11622 shall be inserted now. See 'enum ugll_insert_mode' for more
11626 update_global_location_list (enum ugll_insert_mode insert_mode
)
11628 struct breakpoint
*b
;
11629 struct bp_location
**locp
, *loc
;
11630 /* Last breakpoint location address that was marked for update. */
11631 CORE_ADDR last_addr
= 0;
11632 /* Last breakpoint location program space that was marked for update. */
11633 int last_pspace_num
= -1;
11635 /* Used in the duplicates detection below. When iterating over all
11636 bp_locations, points to the first bp_location of a given address.
11637 Breakpoints and watchpoints of different types are never
11638 duplicates of each other. Keep one pointer for each type of
11639 breakpoint/watchpoint, so we only need to loop over all locations
11641 struct bp_location
*bp_loc_first
; /* breakpoint */
11642 struct bp_location
*wp_loc_first
; /* hardware watchpoint */
11643 struct bp_location
*awp_loc_first
; /* access watchpoint */
11644 struct bp_location
*rwp_loc_first
; /* read watchpoint */
11646 /* Saved former bp_locations array which we compare against the newly
11647 built bp_locations from the current state of ALL_BREAKPOINTS. */
11648 struct bp_location
**old_locp
;
11649 unsigned old_locations_count
;
11650 gdb::unique_xmalloc_ptr
<struct bp_location
*> old_locations (bp_locations
);
11652 old_locations_count
= bp_locations_count
;
11653 bp_locations
= NULL
;
11654 bp_locations_count
= 0;
11656 ALL_BREAKPOINTS (b
)
11657 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
11658 bp_locations_count
++;
11660 bp_locations
= XNEWVEC (struct bp_location
*, bp_locations_count
);
11661 locp
= bp_locations
;
11662 ALL_BREAKPOINTS (b
)
11663 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
11665 std::sort (bp_locations
, bp_locations
+ bp_locations_count
,
11666 bp_location_is_less_than
);
11668 bp_locations_target_extensions_update ();
11670 /* Identify bp_location instances that are no longer present in the
11671 new list, and therefore should be freed. Note that it's not
11672 necessary that those locations should be removed from inferior --
11673 if there's another location at the same address (previously
11674 marked as duplicate), we don't need to remove/insert the
11677 LOCP is kept in sync with OLD_LOCP, each pointing to the current
11678 and former bp_location array state respectively. */
11680 locp
= bp_locations
;
11681 for (old_locp
= old_locations
.get ();
11682 old_locp
< old_locations
.get () + old_locations_count
;
11685 struct bp_location
*old_loc
= *old_locp
;
11686 struct bp_location
**loc2p
;
11688 /* Tells if 'old_loc' is found among the new locations. If
11689 not, we have to free it. */
11690 int found_object
= 0;
11691 /* Tells if the location should remain inserted in the target. */
11692 int keep_in_target
= 0;
11695 /* Skip LOCP entries which will definitely never be needed.
11696 Stop either at or being the one matching OLD_LOC. */
11697 while (locp
< bp_locations
+ bp_locations_count
11698 && (*locp
)->address
< old_loc
->address
)
11702 (loc2p
< bp_locations
+ bp_locations_count
11703 && (*loc2p
)->address
== old_loc
->address
);
11706 /* Check if this is a new/duplicated location or a duplicated
11707 location that had its condition modified. If so, we want to send
11708 its condition to the target if evaluation of conditions is taking
11710 if ((*loc2p
)->condition_changed
== condition_modified
11711 && (last_addr
!= old_loc
->address
11712 || last_pspace_num
!= old_loc
->pspace
->num
))
11714 force_breakpoint_reinsertion (*loc2p
);
11715 last_pspace_num
= old_loc
->pspace
->num
;
11718 if (*loc2p
== old_loc
)
11722 /* We have already handled this address, update it so that we don't
11723 have to go through updates again. */
11724 last_addr
= old_loc
->address
;
11726 /* Target-side condition evaluation: Handle deleted locations. */
11728 force_breakpoint_reinsertion (old_loc
);
11730 /* If this location is no longer present, and inserted, look if
11731 there's maybe a new location at the same address. If so,
11732 mark that one inserted, and don't remove this one. This is
11733 needed so that we don't have a time window where a breakpoint
11734 at certain location is not inserted. */
11736 if (old_loc
->inserted
)
11738 /* If the location is inserted now, we might have to remove
11741 if (found_object
&& should_be_inserted (old_loc
))
11743 /* The location is still present in the location list,
11744 and still should be inserted. Don't do anything. */
11745 keep_in_target
= 1;
11749 /* This location still exists, but it won't be kept in the
11750 target since it may have been disabled. We proceed to
11751 remove its target-side condition. */
11753 /* The location is either no longer present, or got
11754 disabled. See if there's another location at the
11755 same address, in which case we don't need to remove
11756 this one from the target. */
11758 /* OLD_LOC comes from existing struct breakpoint. */
11759 if (bl_address_is_meaningful (old_loc
))
11762 (loc2p
< bp_locations
+ bp_locations_count
11763 && (*loc2p
)->address
== old_loc
->address
);
11766 struct bp_location
*loc2
= *loc2p
;
11768 if (breakpoint_locations_match (loc2
, old_loc
))
11770 /* Read watchpoint locations are switched to
11771 access watchpoints, if the former are not
11772 supported, but the latter are. */
11773 if (is_hardware_watchpoint (old_loc
->owner
))
11775 gdb_assert (is_hardware_watchpoint (loc2
->owner
));
11776 loc2
->watchpoint_type
= old_loc
->watchpoint_type
;
11779 /* loc2 is a duplicated location. We need to check
11780 if it should be inserted in case it will be
11782 if (loc2
!= old_loc
11783 && unduplicated_should_be_inserted (loc2
))
11785 swap_insertion (old_loc
, loc2
);
11786 keep_in_target
= 1;
11794 if (!keep_in_target
)
11796 if (remove_breakpoint (old_loc
))
11798 /* This is just about all we can do. We could keep
11799 this location on the global list, and try to
11800 remove it next time, but there's no particular
11801 reason why we will succeed next time.
11803 Note that at this point, old_loc->owner is still
11804 valid, as delete_breakpoint frees the breakpoint
11805 only after calling us. */
11806 printf_filtered (_("warning: Error removing "
11807 "breakpoint %d\n"),
11808 old_loc
->owner
->number
);
11816 if (removed
&& target_is_non_stop_p ()
11817 && need_moribund_for_location_type (old_loc
))
11819 /* This location was removed from the target. In
11820 non-stop mode, a race condition is possible where
11821 we've removed a breakpoint, but stop events for that
11822 breakpoint are already queued and will arrive later.
11823 We apply an heuristic to be able to distinguish such
11824 SIGTRAPs from other random SIGTRAPs: we keep this
11825 breakpoint location for a bit, and will retire it
11826 after we see some number of events. The theory here
11827 is that reporting of events should, "on the average",
11828 be fair, so after a while we'll see events from all
11829 threads that have anything of interest, and no longer
11830 need to keep this breakpoint location around. We
11831 don't hold locations forever so to reduce chances of
11832 mistaking a non-breakpoint SIGTRAP for a breakpoint
11835 The heuristic failing can be disastrous on
11836 decr_pc_after_break targets.
11838 On decr_pc_after_break targets, like e.g., x86-linux,
11839 if we fail to recognize a late breakpoint SIGTRAP,
11840 because events_till_retirement has reached 0 too
11841 soon, we'll fail to do the PC adjustment, and report
11842 a random SIGTRAP to the user. When the user resumes
11843 the inferior, it will most likely immediately crash
11844 with SIGILL/SIGBUS/SIGSEGV, or worse, get silently
11845 corrupted, because of being resumed e.g., in the
11846 middle of a multi-byte instruction, or skipped a
11847 one-byte instruction. This was actually seen happen
11848 on native x86-linux, and should be less rare on
11849 targets that do not support new thread events, like
11850 remote, due to the heuristic depending on
11853 Mistaking a random SIGTRAP for a breakpoint trap
11854 causes similar symptoms (PC adjustment applied when
11855 it shouldn't), but then again, playing with SIGTRAPs
11856 behind the debugger's back is asking for trouble.
11858 Since hardware watchpoint traps are always
11859 distinguishable from other traps, so we don't need to
11860 apply keep hardware watchpoint moribund locations
11861 around. We simply always ignore hardware watchpoint
11862 traps we can no longer explain. */
11864 process_stratum_target
*proc_target
= nullptr;
11865 for (inferior
*inf
: all_inferiors ())
11866 if (inf
->pspace
== old_loc
->pspace
)
11868 proc_target
= inf
->process_target ();
11871 if (proc_target
!= nullptr)
11872 old_loc
->events_till_retirement
11873 = 3 * (thread_count (proc_target
) + 1);
11875 old_loc
->events_till_retirement
= 1;
11876 old_loc
->owner
= NULL
;
11878 moribund_locations
.push_back (old_loc
);
11882 old_loc
->owner
= NULL
;
11883 decref_bp_location (&old_loc
);
11888 /* Rescan breakpoints at the same address and section, marking the
11889 first one as "first" and any others as "duplicates". This is so
11890 that the bpt instruction is only inserted once. If we have a
11891 permanent breakpoint at the same place as BPT, make that one the
11892 official one, and the rest as duplicates. Permanent breakpoints
11893 are sorted first for the same address.
11895 Do the same for hardware watchpoints, but also considering the
11896 watchpoint's type (regular/access/read) and length. */
11898 bp_loc_first
= NULL
;
11899 wp_loc_first
= NULL
;
11900 awp_loc_first
= NULL
;
11901 rwp_loc_first
= NULL
;
11902 ALL_BP_LOCATIONS (loc
, locp
)
11904 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always
11906 struct bp_location
**loc_first_p
;
11909 if (!unduplicated_should_be_inserted (loc
)
11910 || !bl_address_is_meaningful (loc
)
11911 /* Don't detect duplicate for tracepoint locations because they are
11912 never duplicated. See the comments in field `duplicate' of
11913 `struct bp_location'. */
11914 || is_tracepoint (b
))
11916 /* Clear the condition modification flag. */
11917 loc
->condition_changed
= condition_unchanged
;
11921 if (b
->type
== bp_hardware_watchpoint
)
11922 loc_first_p
= &wp_loc_first
;
11923 else if (b
->type
== bp_read_watchpoint
)
11924 loc_first_p
= &rwp_loc_first
;
11925 else if (b
->type
== bp_access_watchpoint
)
11926 loc_first_p
= &awp_loc_first
;
11928 loc_first_p
= &bp_loc_first
;
11930 if (*loc_first_p
== NULL
11931 || (overlay_debugging
&& loc
->section
!= (*loc_first_p
)->section
)
11932 || !breakpoint_locations_match (loc
, *loc_first_p
))
11934 *loc_first_p
= loc
;
11935 loc
->duplicate
= 0;
11937 if (is_breakpoint (loc
->owner
) && loc
->condition_changed
)
11939 loc
->needs_update
= 1;
11940 /* Clear the condition modification flag. */
11941 loc
->condition_changed
= condition_unchanged
;
11947 /* This and the above ensure the invariant that the first location
11948 is not duplicated, and is the inserted one.
11949 All following are marked as duplicated, and are not inserted. */
11951 swap_insertion (loc
, *loc_first_p
);
11952 loc
->duplicate
= 1;
11954 /* Clear the condition modification flag. */
11955 loc
->condition_changed
= condition_unchanged
;
11958 if (insert_mode
== UGLL_INSERT
|| breakpoints_should_be_inserted_now ())
11960 if (insert_mode
!= UGLL_DONT_INSERT
)
11961 insert_breakpoint_locations ();
11964 /* Even though the caller told us to not insert new
11965 locations, we may still need to update conditions on the
11966 target's side of breakpoints that were already inserted
11967 if the target is evaluating breakpoint conditions. We
11968 only update conditions for locations that are marked
11970 update_inserted_breakpoint_locations ();
11974 if (insert_mode
!= UGLL_DONT_INSERT
)
11975 download_tracepoint_locations ();
11979 breakpoint_retire_moribund (void)
11981 for (int ix
= 0; ix
< moribund_locations
.size (); ++ix
)
11983 struct bp_location
*loc
= moribund_locations
[ix
];
11984 if (--(loc
->events_till_retirement
) == 0)
11986 decref_bp_location (&loc
);
11987 unordered_remove (moribund_locations
, ix
);
11994 update_global_location_list_nothrow (enum ugll_insert_mode insert_mode
)
11999 update_global_location_list (insert_mode
);
12001 catch (const gdb_exception_error
&e
)
12006 /* Clear BKP from a BPS. */
12009 bpstat_remove_bp_location (bpstat bps
, struct breakpoint
*bpt
)
12013 for (bs
= bps
; bs
; bs
= bs
->next
)
12014 if (bs
->breakpoint_at
== bpt
)
12016 bs
->breakpoint_at
= NULL
;
12017 bs
->old_val
= NULL
;
12018 /* bs->commands will be freed later. */
12022 /* Callback for iterate_over_threads. */
12024 bpstat_remove_breakpoint_callback (struct thread_info
*th
, void *data
)
12026 struct breakpoint
*bpt
= (struct breakpoint
*) data
;
12028 bpstat_remove_bp_location (th
->control
.stop_bpstat
, bpt
);
12032 /* Helper for breakpoint and tracepoint breakpoint_ops->mention
12036 say_where (struct breakpoint
*b
)
12038 struct value_print_options opts
;
12040 get_user_print_options (&opts
);
12042 /* i18n: cagney/2005-02-11: Below needs to be merged into a
12044 if (b
->loc
== NULL
)
12046 /* For pending locations, the output differs slightly based
12047 on b->extra_string. If this is non-NULL, it contains either
12048 a condition or dprintf arguments. */
12049 if (b
->extra_string
== NULL
)
12051 printf_filtered (_(" (%s) pending."),
12052 event_location_to_string (b
->location
.get ()));
12054 else if (b
->type
== bp_dprintf
)
12056 printf_filtered (_(" (%s,%s) pending."),
12057 event_location_to_string (b
->location
.get ()),
12062 printf_filtered (_(" (%s %s) pending."),
12063 event_location_to_string (b
->location
.get ()),
12069 if (opts
.addressprint
|| b
->loc
->symtab
== NULL
)
12070 printf_filtered (" at %ps",
12071 styled_string (address_style
.style (),
12072 paddress (b
->loc
->gdbarch
,
12073 b
->loc
->address
)));
12074 if (b
->loc
->symtab
!= NULL
)
12076 /* If there is a single location, we can print the location
12078 if (b
->loc
->next
== NULL
)
12080 const char *filename
12081 = symtab_to_filename_for_display (b
->loc
->symtab
);
12082 printf_filtered (": file %ps, line %d.",
12083 styled_string (file_name_style
.style (),
12085 b
->loc
->line_number
);
12088 /* This is not ideal, but each location may have a
12089 different file name, and this at least reflects the
12090 real situation somewhat. */
12091 printf_filtered (": %s.",
12092 event_location_to_string (b
->location
.get ()));
12097 struct bp_location
*loc
= b
->loc
;
12099 for (; loc
; loc
= loc
->next
)
12101 printf_filtered (" (%d locations)", n
);
12106 bp_location::~bp_location ()
12108 xfree (function_name
);
12111 /* Destructor for the breakpoint base class. */
12113 breakpoint::~breakpoint ()
12115 xfree (this->cond_string
);
12116 xfree (this->extra_string
);
12119 static struct bp_location
*
12120 base_breakpoint_allocate_location (struct breakpoint
*self
)
12122 return new bp_location (self
);
12126 base_breakpoint_re_set (struct breakpoint
*b
)
12128 /* Nothing to re-set. */
12131 #define internal_error_pure_virtual_called() \
12132 gdb_assert_not_reached ("pure virtual function called")
12135 base_breakpoint_insert_location (struct bp_location
*bl
)
12137 internal_error_pure_virtual_called ();
12141 base_breakpoint_remove_location (struct bp_location
*bl
,
12142 enum remove_bp_reason reason
)
12144 internal_error_pure_virtual_called ();
12148 base_breakpoint_breakpoint_hit (const struct bp_location
*bl
,
12149 const address_space
*aspace
,
12151 const struct target_waitstatus
*ws
)
12153 internal_error_pure_virtual_called ();
12157 base_breakpoint_check_status (bpstat bs
)
12162 /* A "works_in_software_mode" breakpoint_ops method that just internal
12166 base_breakpoint_works_in_software_mode (const struct breakpoint
*b
)
12168 internal_error_pure_virtual_called ();
12171 /* A "resources_needed" breakpoint_ops method that just internal
12175 base_breakpoint_resources_needed (const struct bp_location
*bl
)
12177 internal_error_pure_virtual_called ();
12180 static enum print_stop_action
12181 base_breakpoint_print_it (bpstat bs
)
12183 internal_error_pure_virtual_called ();
12187 base_breakpoint_print_one_detail (const struct breakpoint
*self
,
12188 struct ui_out
*uiout
)
12194 base_breakpoint_print_mention (struct breakpoint
*b
)
12196 internal_error_pure_virtual_called ();
12200 base_breakpoint_print_recreate (struct breakpoint
*b
, struct ui_file
*fp
)
12202 internal_error_pure_virtual_called ();
12206 base_breakpoint_create_sals_from_location
12207 (const struct event_location
*location
,
12208 struct linespec_result
*canonical
,
12209 enum bptype type_wanted
)
12211 internal_error_pure_virtual_called ();
12215 base_breakpoint_create_breakpoints_sal (struct gdbarch
*gdbarch
,
12216 struct linespec_result
*c
,
12217 gdb::unique_xmalloc_ptr
<char> cond_string
,
12218 gdb::unique_xmalloc_ptr
<char> extra_string
,
12219 enum bptype type_wanted
,
12220 enum bpdisp disposition
,
12222 int task
, int ignore_count
,
12223 const struct breakpoint_ops
*o
,
12224 int from_tty
, int enabled
,
12225 int internal
, unsigned flags
)
12227 internal_error_pure_virtual_called ();
12230 static std::vector
<symtab_and_line
>
12231 base_breakpoint_decode_location (struct breakpoint
*b
,
12232 const struct event_location
*location
,
12233 struct program_space
*search_pspace
)
12235 internal_error_pure_virtual_called ();
12238 /* The default 'explains_signal' method. */
12241 base_breakpoint_explains_signal (struct breakpoint
*b
, enum gdb_signal sig
)
12246 /* The default "after_condition_true" method. */
12249 base_breakpoint_after_condition_true (struct bpstats
*bs
)
12251 /* Nothing to do. */
12254 struct breakpoint_ops base_breakpoint_ops
=
12256 base_breakpoint_allocate_location
,
12257 base_breakpoint_re_set
,
12258 base_breakpoint_insert_location
,
12259 base_breakpoint_remove_location
,
12260 base_breakpoint_breakpoint_hit
,
12261 base_breakpoint_check_status
,
12262 base_breakpoint_resources_needed
,
12263 base_breakpoint_works_in_software_mode
,
12264 base_breakpoint_print_it
,
12266 base_breakpoint_print_one_detail
,
12267 base_breakpoint_print_mention
,
12268 base_breakpoint_print_recreate
,
12269 base_breakpoint_create_sals_from_location
,
12270 base_breakpoint_create_breakpoints_sal
,
12271 base_breakpoint_decode_location
,
12272 base_breakpoint_explains_signal
,
12273 base_breakpoint_after_condition_true
,
12276 /* Default breakpoint_ops methods. */
12279 bkpt_re_set (struct breakpoint
*b
)
12281 /* FIXME: is this still reachable? */
12282 if (breakpoint_event_location_empty_p (b
))
12284 /* Anything without a location can't be re-set. */
12285 delete_breakpoint (b
);
12289 breakpoint_re_set_default (b
);
12293 bkpt_insert_location (struct bp_location
*bl
)
12295 CORE_ADDR addr
= bl
->target_info
.reqstd_address
;
12297 bl
->target_info
.kind
= breakpoint_kind (bl
, &addr
);
12298 bl
->target_info
.placed_address
= addr
;
12300 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
12301 return target_insert_hw_breakpoint (bl
->gdbarch
, &bl
->target_info
);
12303 return target_insert_breakpoint (bl
->gdbarch
, &bl
->target_info
);
12307 bkpt_remove_location (struct bp_location
*bl
, enum remove_bp_reason reason
)
12309 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
12310 return target_remove_hw_breakpoint (bl
->gdbarch
, &bl
->target_info
);
12312 return target_remove_breakpoint (bl
->gdbarch
, &bl
->target_info
, reason
);
12316 bkpt_breakpoint_hit (const struct bp_location
*bl
,
12317 const address_space
*aspace
, CORE_ADDR bp_addr
,
12318 const struct target_waitstatus
*ws
)
12320 if (ws
->kind
!= TARGET_WAITKIND_STOPPED
12321 || ws
->value
.sig
!= GDB_SIGNAL_TRAP
)
12324 if (!breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
12328 if (overlay_debugging
/* unmapped overlay section */
12329 && section_is_overlay (bl
->section
)
12330 && !section_is_mapped (bl
->section
))
12337 dprintf_breakpoint_hit (const struct bp_location
*bl
,
12338 const address_space
*aspace
, CORE_ADDR bp_addr
,
12339 const struct target_waitstatus
*ws
)
12341 if (dprintf_style
== dprintf_style_agent
12342 && target_can_run_breakpoint_commands ())
12344 /* An agent-style dprintf never causes a stop. If we see a trap
12345 for this address it must be for a breakpoint that happens to
12346 be set at the same address. */
12350 return bkpt_breakpoint_hit (bl
, aspace
, bp_addr
, ws
);
12354 bkpt_resources_needed (const struct bp_location
*bl
)
12356 gdb_assert (bl
->owner
->type
== bp_hardware_breakpoint
);
12361 static enum print_stop_action
12362 bkpt_print_it (bpstat bs
)
12364 struct breakpoint
*b
;
12365 const struct bp_location
*bl
;
12367 struct ui_out
*uiout
= current_uiout
;
12369 gdb_assert (bs
->bp_location_at
!= NULL
);
12371 bl
= bs
->bp_location_at
;
12372 b
= bs
->breakpoint_at
;
12374 bp_temp
= b
->disposition
== disp_del
;
12375 if (bl
->address
!= bl
->requested_address
)
12376 breakpoint_adjustment_warning (bl
->requested_address
,
12379 annotate_breakpoint (b
->number
);
12380 maybe_print_thread_hit_breakpoint (uiout
);
12382 if (uiout
->is_mi_like_p ())
12384 uiout
->field_string ("reason",
12385 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
12386 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
12389 uiout
->message ("Temporary breakpoint %pF, ",
12390 signed_field ("bkptno", b
->number
));
12392 uiout
->message ("Breakpoint %pF, ",
12393 signed_field ("bkptno", b
->number
));
12395 return PRINT_SRC_AND_LOC
;
12399 bkpt_print_mention (struct breakpoint
*b
)
12401 if (current_uiout
->is_mi_like_p ())
12406 case bp_breakpoint
:
12407 case bp_gnu_ifunc_resolver
:
12408 if (b
->disposition
== disp_del
)
12409 printf_filtered (_("Temporary breakpoint"));
12411 printf_filtered (_("Breakpoint"));
12412 printf_filtered (_(" %d"), b
->number
);
12413 if (b
->type
== bp_gnu_ifunc_resolver
)
12414 printf_filtered (_(" at gnu-indirect-function resolver"));
12416 case bp_hardware_breakpoint
:
12417 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
12420 printf_filtered (_("Dprintf %d"), b
->number
);
12428 bkpt_print_recreate (struct breakpoint
*tp
, struct ui_file
*fp
)
12430 if (tp
->type
== bp_breakpoint
&& tp
->disposition
== disp_del
)
12431 fprintf_unfiltered (fp
, "tbreak");
12432 else if (tp
->type
== bp_breakpoint
)
12433 fprintf_unfiltered (fp
, "break");
12434 else if (tp
->type
== bp_hardware_breakpoint
12435 && tp
->disposition
== disp_del
)
12436 fprintf_unfiltered (fp
, "thbreak");
12437 else if (tp
->type
== bp_hardware_breakpoint
)
12438 fprintf_unfiltered (fp
, "hbreak");
12440 internal_error (__FILE__
, __LINE__
,
12441 _("unhandled breakpoint type %d"), (int) tp
->type
);
12443 fprintf_unfiltered (fp
, " %s",
12444 event_location_to_string (tp
->location
.get ()));
12446 /* Print out extra_string if this breakpoint is pending. It might
12447 contain, for example, conditions that were set by the user. */
12448 if (tp
->loc
== NULL
&& tp
->extra_string
!= NULL
)
12449 fprintf_unfiltered (fp
, " %s", tp
->extra_string
);
12451 print_recreate_thread (tp
, fp
);
12455 bkpt_create_sals_from_location (const struct event_location
*location
,
12456 struct linespec_result
*canonical
,
12457 enum bptype type_wanted
)
12459 create_sals_from_location_default (location
, canonical
, type_wanted
);
12463 bkpt_create_breakpoints_sal (struct gdbarch
*gdbarch
,
12464 struct linespec_result
*canonical
,
12465 gdb::unique_xmalloc_ptr
<char> cond_string
,
12466 gdb::unique_xmalloc_ptr
<char> extra_string
,
12467 enum bptype type_wanted
,
12468 enum bpdisp disposition
,
12470 int task
, int ignore_count
,
12471 const struct breakpoint_ops
*ops
,
12472 int from_tty
, int enabled
,
12473 int internal
, unsigned flags
)
12475 create_breakpoints_sal_default (gdbarch
, canonical
,
12476 std::move (cond_string
),
12477 std::move (extra_string
),
12479 disposition
, thread
, task
,
12480 ignore_count
, ops
, from_tty
,
12481 enabled
, internal
, flags
);
12484 static std::vector
<symtab_and_line
>
12485 bkpt_decode_location (struct breakpoint
*b
,
12486 const struct event_location
*location
,
12487 struct program_space
*search_pspace
)
12489 return decode_location_default (b
, location
, search_pspace
);
12492 /* Virtual table for internal breakpoints. */
12495 internal_bkpt_re_set (struct breakpoint
*b
)
12499 /* Delete overlay event and longjmp master breakpoints; they
12500 will be reset later by breakpoint_re_set. */
12501 case bp_overlay_event
:
12502 case bp_longjmp_master
:
12503 case bp_std_terminate_master
:
12504 case bp_exception_master
:
12505 delete_breakpoint (b
);
12508 /* This breakpoint is special, it's set up when the inferior
12509 starts and we really don't want to touch it. */
12510 case bp_shlib_event
:
12512 /* Like bp_shlib_event, this breakpoint type is special. Once
12513 it is set up, we do not want to touch it. */
12514 case bp_thread_event
:
12520 internal_bkpt_check_status (bpstat bs
)
12522 if (bs
->breakpoint_at
->type
== bp_shlib_event
)
12524 /* If requested, stop when the dynamic linker notifies GDB of
12525 events. This allows the user to get control and place
12526 breakpoints in initializer routines for dynamically loaded
12527 objects (among other things). */
12528 bs
->stop
= stop_on_solib_events
;
12529 bs
->print
= stop_on_solib_events
;
12535 static enum print_stop_action
12536 internal_bkpt_print_it (bpstat bs
)
12538 struct breakpoint
*b
;
12540 b
= bs
->breakpoint_at
;
12544 case bp_shlib_event
:
12545 /* Did we stop because the user set the stop_on_solib_events
12546 variable? (If so, we report this as a generic, "Stopped due
12547 to shlib event" message.) */
12548 print_solib_event (0);
12551 case bp_thread_event
:
12552 /* Not sure how we will get here.
12553 GDB should not stop for these breakpoints. */
12554 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
12557 case bp_overlay_event
:
12558 /* By analogy with the thread event, GDB should not stop for these. */
12559 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
12562 case bp_longjmp_master
:
12563 /* These should never be enabled. */
12564 printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
12567 case bp_std_terminate_master
:
12568 /* These should never be enabled. */
12569 printf_filtered (_("std::terminate Master Breakpoint: "
12570 "gdb should not stop!\n"));
12573 case bp_exception_master
:
12574 /* These should never be enabled. */
12575 printf_filtered (_("Exception Master Breakpoint: "
12576 "gdb should not stop!\n"));
12580 return PRINT_NOTHING
;
12584 internal_bkpt_print_mention (struct breakpoint
*b
)
12586 /* Nothing to mention. These breakpoints are internal. */
12589 /* Virtual table for momentary breakpoints */
12592 momentary_bkpt_re_set (struct breakpoint
*b
)
12594 /* Keep temporary breakpoints, which can be encountered when we step
12595 over a dlopen call and solib_add is resetting the breakpoints.
12596 Otherwise these should have been blown away via the cleanup chain
12597 or by breakpoint_init_inferior when we rerun the executable. */
12601 momentary_bkpt_check_status (bpstat bs
)
12603 /* Nothing. The point of these breakpoints is causing a stop. */
12606 static enum print_stop_action
12607 momentary_bkpt_print_it (bpstat bs
)
12609 return PRINT_UNKNOWN
;
12613 momentary_bkpt_print_mention (struct breakpoint
*b
)
12615 /* Nothing to mention. These breakpoints are internal. */
12618 /* Ensure INITIATING_FRAME is cleared when no such breakpoint exists.
12620 It gets cleared already on the removal of the first one of such placed
12621 breakpoints. This is OK as they get all removed altogether. */
12623 longjmp_breakpoint::~longjmp_breakpoint ()
12625 thread_info
*tp
= find_thread_global_id (this->thread
);
12628 tp
->initiating_frame
= null_frame_id
;
12631 /* Specific methods for probe breakpoints. */
12634 bkpt_probe_insert_location (struct bp_location
*bl
)
12636 int v
= bkpt_insert_location (bl
);
12640 /* The insertion was successful, now let's set the probe's semaphore
12642 bl
->probe
.prob
->set_semaphore (bl
->probe
.objfile
, bl
->gdbarch
);
12649 bkpt_probe_remove_location (struct bp_location
*bl
,
12650 enum remove_bp_reason reason
)
12652 /* Let's clear the semaphore before removing the location. */
12653 bl
->probe
.prob
->clear_semaphore (bl
->probe
.objfile
, bl
->gdbarch
);
12655 return bkpt_remove_location (bl
, reason
);
12659 bkpt_probe_create_sals_from_location (const struct event_location
*location
,
12660 struct linespec_result
*canonical
,
12661 enum bptype type_wanted
)
12663 struct linespec_sals lsal
;
12665 lsal
.sals
= parse_probes (location
, NULL
, canonical
);
12667 = xstrdup (event_location_to_string (canonical
->location
.get ()));
12668 canonical
->lsals
.push_back (std::move (lsal
));
12671 static std::vector
<symtab_and_line
>
12672 bkpt_probe_decode_location (struct breakpoint
*b
,
12673 const struct event_location
*location
,
12674 struct program_space
*search_pspace
)
12676 std::vector
<symtab_and_line
> sals
= parse_probes (location
, search_pspace
, NULL
);
12678 error (_("probe not found"));
12682 /* The breakpoint_ops structure to be used in tracepoints. */
12685 tracepoint_re_set (struct breakpoint
*b
)
12687 breakpoint_re_set_default (b
);
12691 tracepoint_breakpoint_hit (const struct bp_location
*bl
,
12692 const address_space
*aspace
, CORE_ADDR bp_addr
,
12693 const struct target_waitstatus
*ws
)
12695 /* By definition, the inferior does not report stops at
12701 tracepoint_print_one_detail (const struct breakpoint
*self
,
12702 struct ui_out
*uiout
)
12704 struct tracepoint
*tp
= (struct tracepoint
*) self
;
12705 if (!tp
->static_trace_marker_id
.empty ())
12707 gdb_assert (self
->type
== bp_static_tracepoint
);
12709 uiout
->message ("\tmarker id is %pF\n",
12710 string_field ("static-tracepoint-marker-string-id",
12711 tp
->static_trace_marker_id
.c_str ()));
12716 tracepoint_print_mention (struct breakpoint
*b
)
12718 if (current_uiout
->is_mi_like_p ())
12723 case bp_tracepoint
:
12724 printf_filtered (_("Tracepoint"));
12725 printf_filtered (_(" %d"), b
->number
);
12727 case bp_fast_tracepoint
:
12728 printf_filtered (_("Fast tracepoint"));
12729 printf_filtered (_(" %d"), b
->number
);
12731 case bp_static_tracepoint
:
12732 printf_filtered (_("Static tracepoint"));
12733 printf_filtered (_(" %d"), b
->number
);
12736 internal_error (__FILE__
, __LINE__
,
12737 _("unhandled tracepoint type %d"), (int) b
->type
);
12744 tracepoint_print_recreate (struct breakpoint
*self
, struct ui_file
*fp
)
12746 struct tracepoint
*tp
= (struct tracepoint
*) self
;
12748 if (self
->type
== bp_fast_tracepoint
)
12749 fprintf_unfiltered (fp
, "ftrace");
12750 else if (self
->type
== bp_static_tracepoint
)
12751 fprintf_unfiltered (fp
, "strace");
12752 else if (self
->type
== bp_tracepoint
)
12753 fprintf_unfiltered (fp
, "trace");
12755 internal_error (__FILE__
, __LINE__
,
12756 _("unhandled tracepoint type %d"), (int) self
->type
);
12758 fprintf_unfiltered (fp
, " %s",
12759 event_location_to_string (self
->location
.get ()));
12760 print_recreate_thread (self
, fp
);
12762 if (tp
->pass_count
)
12763 fprintf_unfiltered (fp
, " passcount %d\n", tp
->pass_count
);
12767 tracepoint_create_sals_from_location (const struct event_location
*location
,
12768 struct linespec_result
*canonical
,
12769 enum bptype type_wanted
)
12771 create_sals_from_location_default (location
, canonical
, type_wanted
);
12775 tracepoint_create_breakpoints_sal (struct gdbarch
*gdbarch
,
12776 struct linespec_result
*canonical
,
12777 gdb::unique_xmalloc_ptr
<char> cond_string
,
12778 gdb::unique_xmalloc_ptr
<char> extra_string
,
12779 enum bptype type_wanted
,
12780 enum bpdisp disposition
,
12782 int task
, int ignore_count
,
12783 const struct breakpoint_ops
*ops
,
12784 int from_tty
, int enabled
,
12785 int internal
, unsigned flags
)
12787 create_breakpoints_sal_default (gdbarch
, canonical
,
12788 std::move (cond_string
),
12789 std::move (extra_string
),
12791 disposition
, thread
, task
,
12792 ignore_count
, ops
, from_tty
,
12793 enabled
, internal
, flags
);
12796 static std::vector
<symtab_and_line
>
12797 tracepoint_decode_location (struct breakpoint
*b
,
12798 const struct event_location
*location
,
12799 struct program_space
*search_pspace
)
12801 return decode_location_default (b
, location
, search_pspace
);
12804 struct breakpoint_ops tracepoint_breakpoint_ops
;
12806 /* Virtual table for tracepoints on static probes. */
12809 tracepoint_probe_create_sals_from_location
12810 (const struct event_location
*location
,
12811 struct linespec_result
*canonical
,
12812 enum bptype type_wanted
)
12814 /* We use the same method for breakpoint on probes. */
12815 bkpt_probe_create_sals_from_location (location
, canonical
, type_wanted
);
12818 static std::vector
<symtab_and_line
>
12819 tracepoint_probe_decode_location (struct breakpoint
*b
,
12820 const struct event_location
*location
,
12821 struct program_space
*search_pspace
)
12823 /* We use the same method for breakpoint on probes. */
12824 return bkpt_probe_decode_location (b
, location
, search_pspace
);
12827 /* Dprintf breakpoint_ops methods. */
12830 dprintf_re_set (struct breakpoint
*b
)
12832 breakpoint_re_set_default (b
);
12834 /* extra_string should never be non-NULL for dprintf. */
12835 gdb_assert (b
->extra_string
!= NULL
);
12837 /* 1 - connect to target 1, that can run breakpoint commands.
12838 2 - create a dprintf, which resolves fine.
12839 3 - disconnect from target 1
12840 4 - connect to target 2, that can NOT run breakpoint commands.
12842 After steps #3/#4, you'll want the dprintf command list to
12843 be updated, because target 1 and 2 may well return different
12844 answers for target_can_run_breakpoint_commands().
12845 Given absence of finer grained resetting, we get to do
12846 it all the time. */
12847 if (b
->extra_string
!= NULL
)
12848 update_dprintf_command_list (b
);
12851 /* Implement the "print_recreate" breakpoint_ops method for dprintf. */
12854 dprintf_print_recreate (struct breakpoint
*tp
, struct ui_file
*fp
)
12856 fprintf_unfiltered (fp
, "dprintf %s,%s",
12857 event_location_to_string (tp
->location
.get ()),
12859 print_recreate_thread (tp
, fp
);
12862 /* Implement the "after_condition_true" breakpoint_ops method for
12865 dprintf's are implemented with regular commands in their command
12866 list, but we run the commands here instead of before presenting the
12867 stop to the user, as dprintf's don't actually cause a stop. This
12868 also makes it so that the commands of multiple dprintfs at the same
12869 address are all handled. */
12872 dprintf_after_condition_true (struct bpstats
*bs
)
12874 struct bpstats tmp_bs
;
12875 struct bpstats
*tmp_bs_p
= &tmp_bs
;
12877 /* dprintf's never cause a stop. This wasn't set in the
12878 check_status hook instead because that would make the dprintf's
12879 condition not be evaluated. */
12882 /* Run the command list here. Take ownership of it instead of
12883 copying. We never want these commands to run later in
12884 bpstat_do_actions, if a breakpoint that causes a stop happens to
12885 be set at same address as this dprintf, or even if running the
12886 commands here throws. */
12887 tmp_bs
.commands
= bs
->commands
;
12888 bs
->commands
= NULL
;
12890 bpstat_do_actions_1 (&tmp_bs_p
);
12892 /* 'tmp_bs.commands' will usually be NULL by now, but
12893 bpstat_do_actions_1 may return early without processing the whole
12897 /* The breakpoint_ops structure to be used on static tracepoints with
12901 strace_marker_create_sals_from_location (const struct event_location
*location
,
12902 struct linespec_result
*canonical
,
12903 enum bptype type_wanted
)
12905 struct linespec_sals lsal
;
12906 const char *arg_start
, *arg
;
12908 arg
= arg_start
= get_linespec_location (location
)->spec_string
;
12909 lsal
.sals
= decode_static_tracepoint_spec (&arg
);
12911 std::string
str (arg_start
, arg
- arg_start
);
12912 const char *ptr
= str
.c_str ();
12913 canonical
->location
12914 = new_linespec_location (&ptr
, symbol_name_match_type::FULL
);
12917 = xstrdup (event_location_to_string (canonical
->location
.get ()));
12918 canonical
->lsals
.push_back (std::move (lsal
));
12922 strace_marker_create_breakpoints_sal (struct gdbarch
*gdbarch
,
12923 struct linespec_result
*canonical
,
12924 gdb::unique_xmalloc_ptr
<char> cond_string
,
12925 gdb::unique_xmalloc_ptr
<char> extra_string
,
12926 enum bptype type_wanted
,
12927 enum bpdisp disposition
,
12929 int task
, int ignore_count
,
12930 const struct breakpoint_ops
*ops
,
12931 int from_tty
, int enabled
,
12932 int internal
, unsigned flags
)
12934 const linespec_sals
&lsal
= canonical
->lsals
[0];
12936 /* If the user is creating a static tracepoint by marker id
12937 (strace -m MARKER_ID), then store the sals index, so that
12938 breakpoint_re_set can try to match up which of the newly
12939 found markers corresponds to this one, and, don't try to
12940 expand multiple locations for each sal, given than SALS
12941 already should contain all sals for MARKER_ID. */
12943 for (size_t i
= 0; i
< lsal
.sals
.size (); i
++)
12945 event_location_up location
12946 = copy_event_location (canonical
->location
.get ());
12948 std::unique_ptr
<tracepoint
> tp (new tracepoint ());
12949 init_breakpoint_sal (tp
.get (), gdbarch
, lsal
.sals
[i
],
12950 std::move (location
), NULL
,
12951 std::move (cond_string
),
12952 std::move (extra_string
),
12953 type_wanted
, disposition
,
12954 thread
, task
, ignore_count
, ops
,
12955 from_tty
, enabled
, internal
, flags
,
12956 canonical
->special_display
);
12957 /* Given that its possible to have multiple markers with
12958 the same string id, if the user is creating a static
12959 tracepoint by marker id ("strace -m MARKER_ID"), then
12960 store the sals index, so that breakpoint_re_set can
12961 try to match up which of the newly found markers
12962 corresponds to this one */
12963 tp
->static_trace_marker_id_idx
= i
;
12965 install_breakpoint (internal
, std::move (tp
), 0);
12969 static std::vector
<symtab_and_line
>
12970 strace_marker_decode_location (struct breakpoint
*b
,
12971 const struct event_location
*location
,
12972 struct program_space
*search_pspace
)
12974 struct tracepoint
*tp
= (struct tracepoint
*) b
;
12975 const char *s
= get_linespec_location (location
)->spec_string
;
12977 std::vector
<symtab_and_line
> sals
= decode_static_tracepoint_spec (&s
);
12978 if (sals
.size () > tp
->static_trace_marker_id_idx
)
12980 sals
[0] = sals
[tp
->static_trace_marker_id_idx
];
12985 error (_("marker %s not found"), tp
->static_trace_marker_id
.c_str ());
12988 static struct breakpoint_ops strace_marker_breakpoint_ops
;
12991 strace_marker_p (struct breakpoint
*b
)
12993 return b
->ops
== &strace_marker_breakpoint_ops
;
12996 /* Delete a breakpoint and clean up all traces of it in the data
13000 delete_breakpoint (struct breakpoint
*bpt
)
13002 struct breakpoint
*b
;
13004 gdb_assert (bpt
!= NULL
);
13006 /* Has this bp already been deleted? This can happen because
13007 multiple lists can hold pointers to bp's. bpstat lists are
13010 One example of this happening is a watchpoint's scope bp. When
13011 the scope bp triggers, we notice that the watchpoint is out of
13012 scope, and delete it. We also delete its scope bp. But the
13013 scope bp is marked "auto-deleting", and is already on a bpstat.
13014 That bpstat is then checked for auto-deleting bp's, which are
13017 A real solution to this problem might involve reference counts in
13018 bp's, and/or giving them pointers back to their referencing
13019 bpstat's, and teaching delete_breakpoint to only free a bp's
13020 storage when no more references were extent. A cheaper bandaid
13022 if (bpt
->type
== bp_none
)
13025 /* At least avoid this stale reference until the reference counting
13026 of breakpoints gets resolved. */
13027 if (bpt
->related_breakpoint
!= bpt
)
13029 struct breakpoint
*related
;
13030 struct watchpoint
*w
;
13032 if (bpt
->type
== bp_watchpoint_scope
)
13033 w
= (struct watchpoint
*) bpt
->related_breakpoint
;
13034 else if (bpt
->related_breakpoint
->type
== bp_watchpoint_scope
)
13035 w
= (struct watchpoint
*) bpt
;
13039 watchpoint_del_at_next_stop (w
);
13041 /* Unlink bpt from the bpt->related_breakpoint ring. */
13042 for (related
= bpt
; related
->related_breakpoint
!= bpt
;
13043 related
= related
->related_breakpoint
);
13044 related
->related_breakpoint
= bpt
->related_breakpoint
;
13045 bpt
->related_breakpoint
= bpt
;
13048 /* watch_command_1 creates a watchpoint but only sets its number if
13049 update_watchpoint succeeds in creating its bp_locations. If there's
13050 a problem in that process, we'll be asked to delete the half-created
13051 watchpoint. In that case, don't announce the deletion. */
13053 gdb::observers::breakpoint_deleted
.notify (bpt
);
13055 if (breakpoint_chain
== bpt
)
13056 breakpoint_chain
= bpt
->next
;
13058 ALL_BREAKPOINTS (b
)
13059 if (b
->next
== bpt
)
13061 b
->next
= bpt
->next
;
13065 /* Be sure no bpstat's are pointing at the breakpoint after it's
13067 /* FIXME, how can we find all bpstat's? We just check stop_bpstat
13068 in all threads for now. Note that we cannot just remove bpstats
13069 pointing at bpt from the stop_bpstat list entirely, as breakpoint
13070 commands are associated with the bpstat; if we remove it here,
13071 then the later call to bpstat_do_actions (&stop_bpstat); in
13072 event-top.c won't do anything, and temporary breakpoints with
13073 commands won't work. */
13075 iterate_over_threads (bpstat_remove_breakpoint_callback
, bpt
);
13077 /* Now that breakpoint is removed from breakpoint list, update the
13078 global location list. This will remove locations that used to
13079 belong to this breakpoint. Do this before freeing the breakpoint
13080 itself, since remove_breakpoint looks at location's owner. It
13081 might be better design to have location completely
13082 self-contained, but it's not the case now. */
13083 update_global_location_list (UGLL_DONT_INSERT
);
13085 /* On the chance that someone will soon try again to delete this
13086 same bp, we mark it as deleted before freeing its storage. */
13087 bpt
->type
= bp_none
;
13091 /* Iterator function to call a user-provided callback function once
13092 for each of B and its related breakpoints. */
13095 iterate_over_related_breakpoints (struct breakpoint
*b
,
13096 gdb::function_view
<void (breakpoint
*)> function
)
13098 struct breakpoint
*related
;
13103 struct breakpoint
*next
;
13105 /* FUNCTION may delete RELATED. */
13106 next
= related
->related_breakpoint
;
13108 if (next
== related
)
13110 /* RELATED is the last ring entry. */
13111 function (related
);
13113 /* FUNCTION may have deleted it, so we'd never reach back to
13114 B. There's nothing left to do anyway, so just break
13119 function (related
);
13123 while (related
!= b
);
13127 delete_command (const char *arg
, int from_tty
)
13129 struct breakpoint
*b
, *b_tmp
;
13135 int breaks_to_delete
= 0;
13137 /* Delete all breakpoints if no argument. Do not delete
13138 internal breakpoints, these have to be deleted with an
13139 explicit breakpoint number argument. */
13140 ALL_BREAKPOINTS (b
)
13141 if (user_breakpoint_p (b
))
13143 breaks_to_delete
= 1;
13147 /* Ask user only if there are some breakpoints to delete. */
13149 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
13151 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
13152 if (user_breakpoint_p (b
))
13153 delete_breakpoint (b
);
13157 map_breakpoint_numbers
13158 (arg
, [&] (breakpoint
*br
)
13160 iterate_over_related_breakpoints (br
, delete_breakpoint
);
13164 /* Return true if all locations of B bound to PSPACE are pending. If
13165 PSPACE is NULL, all locations of all program spaces are
13169 all_locations_are_pending (struct breakpoint
*b
, struct program_space
*pspace
)
13171 struct bp_location
*loc
;
13173 for (loc
= b
->loc
; loc
!= NULL
; loc
= loc
->next
)
13174 if ((pspace
== NULL
13175 || loc
->pspace
== pspace
)
13176 && !loc
->shlib_disabled
13177 && !loc
->pspace
->executing_startup
)
13182 /* Subroutine of update_breakpoint_locations to simplify it.
13183 Return non-zero if multiple fns in list LOC have the same name.
13184 Null names are ignored. */
13187 ambiguous_names_p (struct bp_location
*loc
)
13189 struct bp_location
*l
;
13190 htab_t htab
= htab_create_alloc (13, htab_hash_string
, streq_hash
, NULL
,
13193 for (l
= loc
; l
!= NULL
; l
= l
->next
)
13196 const char *name
= l
->function_name
;
13198 /* Allow for some names to be NULL, ignore them. */
13202 slot
= (const char **) htab_find_slot (htab
, (const void *) name
,
13204 /* NOTE: We can assume slot != NULL here because xcalloc never
13208 htab_delete (htab
);
13214 htab_delete (htab
);
13218 /* When symbols change, it probably means the sources changed as well,
13219 and it might mean the static tracepoint markers are no longer at
13220 the same address or line numbers they used to be at last we
13221 checked. Losing your static tracepoints whenever you rebuild is
13222 undesirable. This function tries to resync/rematch gdb static
13223 tracepoints with the markers on the target, for static tracepoints
13224 that have not been set by marker id. Static tracepoint that have
13225 been set by marker id are reset by marker id in breakpoint_re_set.
13228 1) For a tracepoint set at a specific address, look for a marker at
13229 the old PC. If one is found there, assume to be the same marker.
13230 If the name / string id of the marker found is different from the
13231 previous known name, assume that means the user renamed the marker
13232 in the sources, and output a warning.
13234 2) For a tracepoint set at a given line number, look for a marker
13235 at the new address of the old line number. If one is found there,
13236 assume to be the same marker. If the name / string id of the
13237 marker found is different from the previous known name, assume that
13238 means the user renamed the marker in the sources, and output a
13241 3) If a marker is no longer found at the same address or line, it
13242 may mean the marker no longer exists. But it may also just mean
13243 the code changed a bit. Maybe the user added a few lines of code
13244 that made the marker move up or down (in line number terms). Ask
13245 the target for info about the marker with the string id as we knew
13246 it. If found, update line number and address in the matching
13247 static tracepoint. This will get confused if there's more than one
13248 marker with the same ID (possible in UST, although unadvised
13249 precisely because it confuses tools). */
13251 static struct symtab_and_line
13252 update_static_tracepoint (struct breakpoint
*b
, struct symtab_and_line sal
)
13254 struct tracepoint
*tp
= (struct tracepoint
*) b
;
13255 struct static_tracepoint_marker marker
;
13260 find_line_pc (sal
.symtab
, sal
.line
, &pc
);
13262 if (target_static_tracepoint_marker_at (pc
, &marker
))
13264 if (tp
->static_trace_marker_id
!= marker
.str_id
)
13265 warning (_("static tracepoint %d changed probed marker from %s to %s"),
13266 b
->number
, tp
->static_trace_marker_id
.c_str (),
13267 marker
.str_id
.c_str ());
13269 tp
->static_trace_marker_id
= std::move (marker
.str_id
);
13274 /* Old marker wasn't found on target at lineno. Try looking it up
13276 if (!sal
.explicit_pc
13278 && sal
.symtab
!= NULL
13279 && !tp
->static_trace_marker_id
.empty ())
13281 std::vector
<static_tracepoint_marker
> markers
13282 = target_static_tracepoint_markers_by_strid
13283 (tp
->static_trace_marker_id
.c_str ());
13285 if (!markers
.empty ())
13287 struct symbol
*sym
;
13288 struct static_tracepoint_marker
*tpmarker
;
13289 struct ui_out
*uiout
= current_uiout
;
13290 struct explicit_location explicit_loc
;
13292 tpmarker
= &markers
[0];
13294 tp
->static_trace_marker_id
= std::move (tpmarker
->str_id
);
13296 warning (_("marker for static tracepoint %d (%s) not "
13297 "found at previous line number"),
13298 b
->number
, tp
->static_trace_marker_id
.c_str ());
13300 symtab_and_line sal2
= find_pc_line (tpmarker
->address
, 0);
13301 sym
= find_pc_sect_function (tpmarker
->address
, NULL
);
13302 uiout
->text ("Now in ");
13305 uiout
->field_string ("func", sym
->print_name (),
13306 function_name_style
.style ());
13307 uiout
->text (" at ");
13309 uiout
->field_string ("file",
13310 symtab_to_filename_for_display (sal2
.symtab
),
13311 file_name_style
.style ());
13314 if (uiout
->is_mi_like_p ())
13316 const char *fullname
= symtab_to_fullname (sal2
.symtab
);
13318 uiout
->field_string ("fullname", fullname
);
13321 uiout
->field_signed ("line", sal2
.line
);
13322 uiout
->text ("\n");
13324 b
->loc
->line_number
= sal2
.line
;
13325 b
->loc
->symtab
= sym
!= NULL
? sal2
.symtab
: NULL
;
13327 b
->location
.reset (NULL
);
13328 initialize_explicit_location (&explicit_loc
);
13329 explicit_loc
.source_filename
13330 = ASTRDUP (symtab_to_filename_for_display (sal2
.symtab
));
13331 explicit_loc
.line_offset
.offset
= b
->loc
->line_number
;
13332 explicit_loc
.line_offset
.sign
= LINE_OFFSET_NONE
;
13333 b
->location
= new_explicit_location (&explicit_loc
);
13335 /* Might be nice to check if function changed, and warn if
13342 /* Returns 1 iff locations A and B are sufficiently same that
13343 we don't need to report breakpoint as changed. */
13346 locations_are_equal (struct bp_location
*a
, struct bp_location
*b
)
13350 if (a
->address
!= b
->address
)
13353 if (a
->shlib_disabled
!= b
->shlib_disabled
)
13356 if (a
->enabled
!= b
->enabled
)
13363 if ((a
== NULL
) != (b
== NULL
))
13369 /* Split all locations of B that are bound to PSPACE out of B's
13370 location list to a separate list and return that list's head. If
13371 PSPACE is NULL, hoist out all locations of B. */
13373 static struct bp_location
*
13374 hoist_existing_locations (struct breakpoint
*b
, struct program_space
*pspace
)
13376 struct bp_location head
;
13377 struct bp_location
*i
= b
->loc
;
13378 struct bp_location
**i_link
= &b
->loc
;
13379 struct bp_location
*hoisted
= &head
;
13381 if (pspace
== NULL
)
13392 if (i
->pspace
== pspace
)
13407 /* Create new breakpoint locations for B (a hardware or software
13408 breakpoint) based on SALS and SALS_END. If SALS_END.NELTS is not
13409 zero, then B is a ranged breakpoint. Only recreates locations for
13410 FILTER_PSPACE. Locations of other program spaces are left
13414 update_breakpoint_locations (struct breakpoint
*b
,
13415 struct program_space
*filter_pspace
,
13416 gdb::array_view
<const symtab_and_line
> sals
,
13417 gdb::array_view
<const symtab_and_line
> sals_end
)
13419 struct bp_location
*existing_locations
;
13421 if (!sals_end
.empty () && (sals
.size () != 1 || sals_end
.size () != 1))
13423 /* Ranged breakpoints have only one start location and one end
13425 b
->enable_state
= bp_disabled
;
13426 printf_unfiltered (_("Could not reset ranged breakpoint %d: "
13427 "multiple locations found\n"),
13432 /* If there's no new locations, and all existing locations are
13433 pending, don't do anything. This optimizes the common case where
13434 all locations are in the same shared library, that was unloaded.
13435 We'd like to retain the location, so that when the library is
13436 loaded again, we don't loose the enabled/disabled status of the
13437 individual locations. */
13438 if (all_locations_are_pending (b
, filter_pspace
) && sals
.empty ())
13441 existing_locations
= hoist_existing_locations (b
, filter_pspace
);
13443 for (const auto &sal
: sals
)
13445 struct bp_location
*new_loc
;
13447 switch_to_program_space_and_thread (sal
.pspace
);
13449 new_loc
= add_location_to_breakpoint (b
, &sal
);
13451 /* Reparse conditions, they might contain references to the
13453 if (b
->cond_string
!= NULL
)
13457 s
= b
->cond_string
;
13460 new_loc
->cond
= parse_exp_1 (&s
, sal
.pc
,
13461 block_for_pc (sal
.pc
),
13464 catch (const gdb_exception_error
&e
)
13466 warning (_("failed to reevaluate condition "
13467 "for breakpoint %d: %s"),
13468 b
->number
, e
.what ());
13469 new_loc
->enabled
= 0;
13473 if (!sals_end
.empty ())
13475 CORE_ADDR end
= find_breakpoint_range_end (sals_end
[0]);
13477 new_loc
->length
= end
- sals
[0].pc
+ 1;
13481 /* If possible, carry over 'disable' status from existing
13484 struct bp_location
*e
= existing_locations
;
13485 /* If there are multiple breakpoints with the same function name,
13486 e.g. for inline functions, comparing function names won't work.
13487 Instead compare pc addresses; this is just a heuristic as things
13488 may have moved, but in practice it gives the correct answer
13489 often enough until a better solution is found. */
13490 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
13492 for (; e
; e
= e
->next
)
13494 if (!e
->enabled
&& e
->function_name
)
13496 struct bp_location
*l
= b
->loc
;
13497 if (have_ambiguous_names
)
13499 for (; l
; l
= l
->next
)
13500 if (breakpoint_locations_match (e
, l
))
13508 for (; l
; l
= l
->next
)
13509 if (l
->function_name
13510 && strcmp (e
->function_name
, l
->function_name
) == 0)
13520 if (!locations_are_equal (existing_locations
, b
->loc
))
13521 gdb::observers::breakpoint_modified
.notify (b
);
13524 /* Find the SaL locations corresponding to the given LOCATION.
13525 On return, FOUND will be 1 if any SaL was found, zero otherwise. */
13527 static std::vector
<symtab_and_line
>
13528 location_to_sals (struct breakpoint
*b
, struct event_location
*location
,
13529 struct program_space
*search_pspace
, int *found
)
13531 struct gdb_exception exception
;
13533 gdb_assert (b
->ops
!= NULL
);
13535 std::vector
<symtab_and_line
> sals
;
13539 sals
= b
->ops
->decode_location (b
, location
, search_pspace
);
13541 catch (gdb_exception_error
&e
)
13543 int not_found_and_ok
= 0;
13545 /* For pending breakpoints, it's expected that parsing will
13546 fail until the right shared library is loaded. User has
13547 already told to create pending breakpoints and don't need
13548 extra messages. If breakpoint is in bp_shlib_disabled
13549 state, then user already saw the message about that
13550 breakpoint being disabled, and don't want to see more
13552 if (e
.error
== NOT_FOUND_ERROR
13553 && (b
->condition_not_parsed
13555 && search_pspace
!= NULL
13556 && b
->loc
->pspace
!= search_pspace
)
13557 || (b
->loc
&& b
->loc
->shlib_disabled
)
13558 || (b
->loc
&& b
->loc
->pspace
->executing_startup
)
13559 || b
->enable_state
== bp_disabled
))
13560 not_found_and_ok
= 1;
13562 if (!not_found_and_ok
)
13564 /* We surely don't want to warn about the same breakpoint
13565 10 times. One solution, implemented here, is disable
13566 the breakpoint on error. Another solution would be to
13567 have separate 'warning emitted' flag. Since this
13568 happens only when a binary has changed, I don't know
13569 which approach is better. */
13570 b
->enable_state
= bp_disabled
;
13574 exception
= std::move (e
);
13577 if (exception
.reason
== 0 || exception
.error
!= NOT_FOUND_ERROR
)
13579 for (auto &sal
: sals
)
13580 resolve_sal_pc (&sal
);
13581 if (b
->condition_not_parsed
&& b
->extra_string
!= NULL
)
13583 char *cond_string
, *extra_string
;
13586 find_condition_and_thread (b
->extra_string
, sals
[0].pc
,
13587 &cond_string
, &thread
, &task
,
13589 gdb_assert (b
->cond_string
== NULL
);
13591 b
->cond_string
= cond_string
;
13592 b
->thread
= thread
;
13596 xfree (b
->extra_string
);
13597 b
->extra_string
= extra_string
;
13599 b
->condition_not_parsed
= 0;
13602 if (b
->type
== bp_static_tracepoint
&& !strace_marker_p (b
))
13603 sals
[0] = update_static_tracepoint (b
, sals
[0]);
13613 /* The default re_set method, for typical hardware or software
13614 breakpoints. Reevaluate the breakpoint and recreate its
13618 breakpoint_re_set_default (struct breakpoint
*b
)
13620 struct program_space
*filter_pspace
= current_program_space
;
13621 std::vector
<symtab_and_line
> expanded
, expanded_end
;
13624 std::vector
<symtab_and_line
> sals
= location_to_sals (b
, b
->location
.get (),
13625 filter_pspace
, &found
);
13627 expanded
= std::move (sals
);
13629 if (b
->location_range_end
!= NULL
)
13631 std::vector
<symtab_and_line
> sals_end
13632 = location_to_sals (b
, b
->location_range_end
.get (),
13633 filter_pspace
, &found
);
13635 expanded_end
= std::move (sals_end
);
13638 update_breakpoint_locations (b
, filter_pspace
, expanded
, expanded_end
);
13641 /* Default method for creating SALs from an address string. It basically
13642 calls parse_breakpoint_sals. Return 1 for success, zero for failure. */
13645 create_sals_from_location_default (const struct event_location
*location
,
13646 struct linespec_result
*canonical
,
13647 enum bptype type_wanted
)
13649 parse_breakpoint_sals (location
, canonical
);
13652 /* Call create_breakpoints_sal for the given arguments. This is the default
13653 function for the `create_breakpoints_sal' method of
13657 create_breakpoints_sal_default (struct gdbarch
*gdbarch
,
13658 struct linespec_result
*canonical
,
13659 gdb::unique_xmalloc_ptr
<char> cond_string
,
13660 gdb::unique_xmalloc_ptr
<char> extra_string
,
13661 enum bptype type_wanted
,
13662 enum bpdisp disposition
,
13664 int task
, int ignore_count
,
13665 const struct breakpoint_ops
*ops
,
13666 int from_tty
, int enabled
,
13667 int internal
, unsigned flags
)
13669 create_breakpoints_sal (gdbarch
, canonical
,
13670 std::move (cond_string
),
13671 std::move (extra_string
),
13672 type_wanted
, disposition
,
13673 thread
, task
, ignore_count
, ops
, from_tty
,
13674 enabled
, internal
, flags
);
13677 /* Decode the line represented by S by calling decode_line_full. This is the
13678 default function for the `decode_location' method of breakpoint_ops. */
13680 static std::vector
<symtab_and_line
>
13681 decode_location_default (struct breakpoint
*b
,
13682 const struct event_location
*location
,
13683 struct program_space
*search_pspace
)
13685 struct linespec_result canonical
;
13687 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, search_pspace
,
13688 NULL
, 0, &canonical
, multiple_symbols_all
,
13691 /* We should get 0 or 1 resulting SALs. */
13692 gdb_assert (canonical
.lsals
.size () < 2);
13694 if (!canonical
.lsals
.empty ())
13696 const linespec_sals
&lsal
= canonical
.lsals
[0];
13697 return std::move (lsal
.sals
);
13702 /* Reset a breakpoint. */
13705 breakpoint_re_set_one (breakpoint
*b
)
13707 input_radix
= b
->input_radix
;
13708 set_language (b
->language
);
13710 b
->ops
->re_set (b
);
13713 /* Re-set breakpoint locations for the current program space.
13714 Locations bound to other program spaces are left untouched. */
13717 breakpoint_re_set (void)
13719 struct breakpoint
*b
, *b_tmp
;
13722 scoped_restore_current_language save_language
;
13723 scoped_restore save_input_radix
= make_scoped_restore (&input_radix
);
13724 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
13726 /* breakpoint_re_set_one sets the current_language to the language
13727 of the breakpoint it is resetting (see prepare_re_set_context)
13728 before re-evaluating the breakpoint's location. This change can
13729 unfortunately get undone by accident if the language_mode is set
13730 to auto, and we either switch frames, or more likely in this context,
13731 we select the current frame.
13733 We prevent this by temporarily turning the language_mode to
13734 language_mode_manual. We restore it once all breakpoints
13735 have been reset. */
13736 scoped_restore save_language_mode
= make_scoped_restore (&language_mode
);
13737 language_mode
= language_mode_manual
;
13739 /* Note: we must not try to insert locations until after all
13740 breakpoints have been re-set. Otherwise, e.g., when re-setting
13741 breakpoint 1, we'd insert the locations of breakpoint 2, which
13742 hadn't been re-set yet, and thus may have stale locations. */
13744 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
13748 breakpoint_re_set_one (b
);
13750 catch (const gdb_exception
&ex
)
13752 exception_fprintf (gdb_stderr
, ex
,
13753 "Error in re-setting breakpoint %d: ",
13758 jit_breakpoint_re_set ();
13761 create_overlay_event_breakpoint ();
13762 create_longjmp_master_breakpoint ();
13763 create_std_terminate_master_breakpoint ();
13764 create_exception_master_breakpoint ();
13766 /* Now we can insert. */
13767 update_global_location_list (UGLL_MAY_INSERT
);
13770 /* Reset the thread number of this breakpoint:
13772 - If the breakpoint is for all threads, leave it as-is.
13773 - Else, reset it to the current thread for inferior_ptid. */
13775 breakpoint_re_set_thread (struct breakpoint
*b
)
13777 if (b
->thread
!= -1)
13779 b
->thread
= inferior_thread ()->global_num
;
13781 /* We're being called after following a fork. The new fork is
13782 selected as current, and unless this was a vfork will have a
13783 different program space from the original thread. Reset that
13785 b
->loc
->pspace
= current_program_space
;
13789 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
13790 If from_tty is nonzero, it prints a message to that effect,
13791 which ends with a period (no newline). */
13794 set_ignore_count (int bptnum
, int count
, int from_tty
)
13796 struct breakpoint
*b
;
13801 ALL_BREAKPOINTS (b
)
13802 if (b
->number
== bptnum
)
13804 if (is_tracepoint (b
))
13806 if (from_tty
&& count
!= 0)
13807 printf_filtered (_("Ignore count ignored for tracepoint %d."),
13812 b
->ignore_count
= count
;
13816 printf_filtered (_("Will stop next time "
13817 "breakpoint %d is reached."),
13819 else if (count
== 1)
13820 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
13823 printf_filtered (_("Will ignore next %d "
13824 "crossings of breakpoint %d."),
13827 gdb::observers::breakpoint_modified
.notify (b
);
13831 error (_("No breakpoint number %d."), bptnum
);
13834 /* Command to set ignore-count of breakpoint N to COUNT. */
13837 ignore_command (const char *args
, int from_tty
)
13839 const char *p
= args
;
13843 error_no_arg (_("a breakpoint number"));
13845 num
= get_number (&p
);
13847 error (_("bad breakpoint number: '%s'"), args
);
13849 error (_("Second argument (specified ignore-count) is missing."));
13851 set_ignore_count (num
,
13852 longest_to_int (value_as_long (parse_and_eval (p
))),
13855 printf_filtered ("\n");
13859 /* Call FUNCTION on each of the breakpoints with numbers in the range
13860 defined by BP_NUM_RANGE (an inclusive range). */
13863 map_breakpoint_number_range (std::pair
<int, int> bp_num_range
,
13864 gdb::function_view
<void (breakpoint
*)> function
)
13866 if (bp_num_range
.first
== 0)
13868 warning (_("bad breakpoint number at or near '%d'"),
13869 bp_num_range
.first
);
13873 struct breakpoint
*b
, *tmp
;
13875 for (int i
= bp_num_range
.first
; i
<= bp_num_range
.second
; i
++)
13877 bool match
= false;
13879 ALL_BREAKPOINTS_SAFE (b
, tmp
)
13880 if (b
->number
== i
)
13887 printf_unfiltered (_("No breakpoint number %d.\n"), i
);
13892 /* Call FUNCTION on each of the breakpoints whose numbers are given in
13896 map_breakpoint_numbers (const char *args
,
13897 gdb::function_view
<void (breakpoint
*)> function
)
13899 if (args
== NULL
|| *args
== '\0')
13900 error_no_arg (_("one or more breakpoint numbers"));
13902 number_or_range_parser
parser (args
);
13904 while (!parser
.finished ())
13906 int num
= parser
.get_number ();
13907 map_breakpoint_number_range (std::make_pair (num
, num
), function
);
13911 /* Return the breakpoint location structure corresponding to the
13912 BP_NUM and LOC_NUM values. */
13914 static struct bp_location
*
13915 find_location_by_number (int bp_num
, int loc_num
)
13917 struct breakpoint
*b
;
13919 ALL_BREAKPOINTS (b
)
13920 if (b
->number
== bp_num
)
13925 if (!b
|| b
->number
!= bp_num
)
13926 error (_("Bad breakpoint number '%d'"), bp_num
);
13929 error (_("Bad breakpoint location number '%d'"), loc_num
);
13932 for (bp_location
*loc
= b
->loc
; loc
!= NULL
; loc
= loc
->next
)
13933 if (++n
== loc_num
)
13936 error (_("Bad breakpoint location number '%d'"), loc_num
);
13939 /* Modes of operation for extract_bp_num. */
13940 enum class extract_bp_kind
13942 /* Extracting a breakpoint number. */
13945 /* Extracting a location number. */
13949 /* Extract a breakpoint or location number (as determined by KIND)
13950 from the string starting at START. TRAILER is a character which
13951 can be found after the number. If you don't want a trailer, use
13952 '\0'. If END_OUT is not NULL, it is set to point after the parsed
13953 string. This always returns a positive integer. */
13956 extract_bp_num (extract_bp_kind kind
, const char *start
,
13957 int trailer
, const char **end_out
= NULL
)
13959 const char *end
= start
;
13960 int num
= get_number_trailer (&end
, trailer
);
13962 error (kind
== extract_bp_kind::bp
13963 ? _("Negative breakpoint number '%.*s'")
13964 : _("Negative breakpoint location number '%.*s'"),
13965 int (end
- start
), start
);
13967 error (kind
== extract_bp_kind::bp
13968 ? _("Bad breakpoint number '%.*s'")
13969 : _("Bad breakpoint location number '%.*s'"),
13970 int (end
- start
), start
);
13972 if (end_out
!= NULL
)
13977 /* Extract a breakpoint or location range (as determined by KIND) in
13978 the form NUM1-NUM2 stored at &ARG[arg_offset]. Returns a std::pair
13979 representing the (inclusive) range. The returned pair's elements
13980 are always positive integers. */
13982 static std::pair
<int, int>
13983 extract_bp_or_bp_range (extract_bp_kind kind
,
13984 const std::string
&arg
,
13985 std::string::size_type arg_offset
)
13987 std::pair
<int, int> range
;
13988 const char *bp_loc
= &arg
[arg_offset
];
13989 std::string::size_type dash
= arg
.find ('-', arg_offset
);
13990 if (dash
!= std::string::npos
)
13992 /* bp_loc is a range (x-z). */
13993 if (arg
.length () == dash
+ 1)
13994 error (kind
== extract_bp_kind::bp
13995 ? _("Bad breakpoint number at or near: '%s'")
13996 : _("Bad breakpoint location number at or near: '%s'"),
14000 const char *start_first
= bp_loc
;
14001 const char *start_second
= &arg
[dash
+ 1];
14002 range
.first
= extract_bp_num (kind
, start_first
, '-');
14003 range
.second
= extract_bp_num (kind
, start_second
, '\0', &end
);
14005 if (range
.first
> range
.second
)
14006 error (kind
== extract_bp_kind::bp
14007 ? _("Inverted breakpoint range at '%.*s'")
14008 : _("Inverted breakpoint location range at '%.*s'"),
14009 int (end
- start_first
), start_first
);
14013 /* bp_loc is a single value. */
14014 range
.first
= extract_bp_num (kind
, bp_loc
, '\0');
14015 range
.second
= range
.first
;
14020 /* Extract the breakpoint/location range specified by ARG. Returns
14021 the breakpoint range in BP_NUM_RANGE, and the location range in
14024 ARG may be in any of the following forms:
14026 x where 'x' is a breakpoint number.
14027 x-y where 'x' and 'y' specify a breakpoint numbers range.
14028 x.y where 'x' is a breakpoint number and 'y' a location number.
14029 x.y-z where 'x' is a breakpoint number and 'y' and 'z' specify a
14030 location number range.
14034 extract_bp_number_and_location (const std::string
&arg
,
14035 std::pair
<int, int> &bp_num_range
,
14036 std::pair
<int, int> &bp_loc_range
)
14038 std::string::size_type dot
= arg
.find ('.');
14040 if (dot
!= std::string::npos
)
14042 /* Handle 'x.y' and 'x.y-z' cases. */
14044 if (arg
.length () == dot
+ 1 || dot
== 0)
14045 error (_("Bad breakpoint number at or near: '%s'"), arg
.c_str ());
14048 = extract_bp_num (extract_bp_kind::bp
, arg
.c_str (), '.');
14049 bp_num_range
.second
= bp_num_range
.first
;
14051 bp_loc_range
= extract_bp_or_bp_range (extract_bp_kind::loc
,
14056 /* Handle x and x-y cases. */
14058 bp_num_range
= extract_bp_or_bp_range (extract_bp_kind::bp
, arg
, 0);
14059 bp_loc_range
.first
= 0;
14060 bp_loc_range
.second
= 0;
14064 /* Enable or disable a breakpoint location BP_NUM.LOC_NUM. ENABLE
14065 specifies whether to enable or disable. */
14068 enable_disable_bp_num_loc (int bp_num
, int loc_num
, bool enable
)
14070 struct bp_location
*loc
= find_location_by_number (bp_num
, loc_num
);
14073 if (loc
->enabled
!= enable
)
14075 loc
->enabled
= enable
;
14076 mark_breakpoint_location_modified (loc
);
14078 if (target_supports_enable_disable_tracepoint ()
14079 && current_trace_status ()->running
&& loc
->owner
14080 && is_tracepoint (loc
->owner
))
14081 target_disable_tracepoint (loc
);
14083 update_global_location_list (UGLL_DONT_INSERT
);
14085 gdb::observers::breakpoint_modified
.notify (loc
->owner
);
14088 /* Enable or disable a range of breakpoint locations. BP_NUM is the
14089 number of the breakpoint, and BP_LOC_RANGE specifies the
14090 (inclusive) range of location numbers of that breakpoint to
14091 enable/disable. ENABLE specifies whether to enable or disable the
14095 enable_disable_breakpoint_location_range (int bp_num
,
14096 std::pair
<int, int> &bp_loc_range
,
14099 for (int i
= bp_loc_range
.first
; i
<= bp_loc_range
.second
; i
++)
14100 enable_disable_bp_num_loc (bp_num
, i
, enable
);
14103 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14104 If from_tty is nonzero, it prints a message to that effect,
14105 which ends with a period (no newline). */
14108 disable_breakpoint (struct breakpoint
*bpt
)
14110 /* Never disable a watchpoint scope breakpoint; we want to
14111 hit them when we leave scope so we can delete both the
14112 watchpoint and its scope breakpoint at that time. */
14113 if (bpt
->type
== bp_watchpoint_scope
)
14116 bpt
->enable_state
= bp_disabled
;
14118 /* Mark breakpoint locations modified. */
14119 mark_breakpoint_modified (bpt
);
14121 if (target_supports_enable_disable_tracepoint ()
14122 && current_trace_status ()->running
&& is_tracepoint (bpt
))
14124 struct bp_location
*location
;
14126 for (location
= bpt
->loc
; location
; location
= location
->next
)
14127 target_disable_tracepoint (location
);
14130 update_global_location_list (UGLL_DONT_INSERT
);
14132 gdb::observers::breakpoint_modified
.notify (bpt
);
14135 /* Enable or disable the breakpoint(s) or breakpoint location(s)
14136 specified in ARGS. ARGS may be in any of the formats handled by
14137 extract_bp_number_and_location. ENABLE specifies whether to enable
14138 or disable the breakpoints/locations. */
14141 enable_disable_command (const char *args
, int from_tty
, bool enable
)
14145 struct breakpoint
*bpt
;
14147 ALL_BREAKPOINTS (bpt
)
14148 if (user_breakpoint_p (bpt
))
14151 enable_breakpoint (bpt
);
14153 disable_breakpoint (bpt
);
14158 std::string num
= extract_arg (&args
);
14160 while (!num
.empty ())
14162 std::pair
<int, int> bp_num_range
, bp_loc_range
;
14164 extract_bp_number_and_location (num
, bp_num_range
, bp_loc_range
);
14166 if (bp_loc_range
.first
== bp_loc_range
.second
14167 && bp_loc_range
.first
== 0)
14169 /* Handle breakpoint ids with formats 'x' or 'x-z'. */
14170 map_breakpoint_number_range (bp_num_range
,
14172 ? enable_breakpoint
14173 : disable_breakpoint
);
14177 /* Handle breakpoint ids with formats 'x.y' or
14179 enable_disable_breakpoint_location_range
14180 (bp_num_range
.first
, bp_loc_range
, enable
);
14182 num
= extract_arg (&args
);
14187 /* The disable command disables the specified breakpoints/locations
14188 (or all defined breakpoints) so they're no longer effective in
14189 stopping the inferior. ARGS may be in any of the forms defined in
14190 extract_bp_number_and_location. */
14193 disable_command (const char *args
, int from_tty
)
14195 enable_disable_command (args
, from_tty
, false);
14199 enable_breakpoint_disp (struct breakpoint
*bpt
, enum bpdisp disposition
,
14202 int target_resources_ok
;
14204 if (bpt
->type
== bp_hardware_breakpoint
)
14207 i
= hw_breakpoint_used_count ();
14208 target_resources_ok
=
14209 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
14211 if (target_resources_ok
== 0)
14212 error (_("No hardware breakpoint support in the target."));
14213 else if (target_resources_ok
< 0)
14214 error (_("Hardware breakpoints used exceeds limit."));
14217 if (is_watchpoint (bpt
))
14219 /* Initialize it just to avoid a GCC false warning. */
14220 enum enable_state orig_enable_state
= bp_disabled
;
14224 struct watchpoint
*w
= (struct watchpoint
*) bpt
;
14226 orig_enable_state
= bpt
->enable_state
;
14227 bpt
->enable_state
= bp_enabled
;
14228 update_watchpoint (w
, 1 /* reparse */);
14230 catch (const gdb_exception
&e
)
14232 bpt
->enable_state
= orig_enable_state
;
14233 exception_fprintf (gdb_stderr
, e
, _("Cannot enable watchpoint %d: "),
14239 bpt
->enable_state
= bp_enabled
;
14241 /* Mark breakpoint locations modified. */
14242 mark_breakpoint_modified (bpt
);
14244 if (target_supports_enable_disable_tracepoint ()
14245 && current_trace_status ()->running
&& is_tracepoint (bpt
))
14247 struct bp_location
*location
;
14249 for (location
= bpt
->loc
; location
; location
= location
->next
)
14250 target_enable_tracepoint (location
);
14253 bpt
->disposition
= disposition
;
14254 bpt
->enable_count
= count
;
14255 update_global_location_list (UGLL_MAY_INSERT
);
14257 gdb::observers::breakpoint_modified
.notify (bpt
);
14262 enable_breakpoint (struct breakpoint
*bpt
)
14264 enable_breakpoint_disp (bpt
, bpt
->disposition
, 0);
14267 /* The enable command enables the specified breakpoints/locations (or
14268 all defined breakpoints) so they once again become (or continue to
14269 be) effective in stopping the inferior. ARGS may be in any of the
14270 forms defined in extract_bp_number_and_location. */
14273 enable_command (const char *args
, int from_tty
)
14275 enable_disable_command (args
, from_tty
, true);
14279 enable_once_command (const char *args
, int from_tty
)
14281 map_breakpoint_numbers
14282 (args
, [&] (breakpoint
*b
)
14284 iterate_over_related_breakpoints
14285 (b
, [&] (breakpoint
*bpt
)
14287 enable_breakpoint_disp (bpt
, disp_disable
, 1);
14293 enable_count_command (const char *args
, int from_tty
)
14298 error_no_arg (_("hit count"));
14300 count
= get_number (&args
);
14302 map_breakpoint_numbers
14303 (args
, [&] (breakpoint
*b
)
14305 iterate_over_related_breakpoints
14306 (b
, [&] (breakpoint
*bpt
)
14308 enable_breakpoint_disp (bpt
, disp_disable
, count
);
14314 enable_delete_command (const char *args
, int from_tty
)
14316 map_breakpoint_numbers
14317 (args
, [&] (breakpoint
*b
)
14319 iterate_over_related_breakpoints
14320 (b
, [&] (breakpoint
*bpt
)
14322 enable_breakpoint_disp (bpt
, disp_del
, 1);
14327 /* Invalidate last known value of any hardware watchpoint if
14328 the memory which that value represents has been written to by
14332 invalidate_bp_value_on_memory_change (struct inferior
*inferior
,
14333 CORE_ADDR addr
, ssize_t len
,
14334 const bfd_byte
*data
)
14336 struct breakpoint
*bp
;
14338 ALL_BREAKPOINTS (bp
)
14339 if (bp
->enable_state
== bp_enabled
14340 && bp
->type
== bp_hardware_watchpoint
)
14342 struct watchpoint
*wp
= (struct watchpoint
*) bp
;
14344 if (wp
->val_valid
&& wp
->val
!= nullptr)
14346 struct bp_location
*loc
;
14348 for (loc
= bp
->loc
; loc
!= NULL
; loc
= loc
->next
)
14349 if (loc
->loc_type
== bp_loc_hardware_watchpoint
14350 && loc
->address
+ loc
->length
> addr
14351 && addr
+ len
> loc
->address
)
14354 wp
->val_valid
= false;
14360 /* Create and insert a breakpoint for software single step. */
14363 insert_single_step_breakpoint (struct gdbarch
*gdbarch
,
14364 const address_space
*aspace
,
14367 struct thread_info
*tp
= inferior_thread ();
14368 struct symtab_and_line sal
;
14369 CORE_ADDR pc
= next_pc
;
14371 if (tp
->control
.single_step_breakpoints
== NULL
)
14373 tp
->control
.single_step_breakpoints
14374 = new_single_step_breakpoint (tp
->global_num
, gdbarch
);
14377 sal
= find_pc_line (pc
, 0);
14379 sal
.section
= find_pc_overlay (pc
);
14380 sal
.explicit_pc
= 1;
14381 add_location_to_breakpoint (tp
->control
.single_step_breakpoints
, &sal
);
14383 update_global_location_list (UGLL_INSERT
);
14386 /* Insert single step breakpoints according to the current state. */
14389 insert_single_step_breakpoints (struct gdbarch
*gdbarch
)
14391 struct regcache
*regcache
= get_current_regcache ();
14392 std::vector
<CORE_ADDR
> next_pcs
;
14394 next_pcs
= gdbarch_software_single_step (gdbarch
, regcache
);
14396 if (!next_pcs
.empty ())
14398 struct frame_info
*frame
= get_current_frame ();
14399 const address_space
*aspace
= get_frame_address_space (frame
);
14401 for (CORE_ADDR pc
: next_pcs
)
14402 insert_single_step_breakpoint (gdbarch
, aspace
, pc
);
14410 /* See breakpoint.h. */
14413 breakpoint_has_location_inserted_here (struct breakpoint
*bp
,
14414 const address_space
*aspace
,
14417 struct bp_location
*loc
;
14419 for (loc
= bp
->loc
; loc
!= NULL
; loc
= loc
->next
)
14421 && breakpoint_location_address_match (loc
, aspace
, pc
))
14427 /* Check whether a software single-step breakpoint is inserted at
14431 single_step_breakpoint_inserted_here_p (const address_space
*aspace
,
14434 struct breakpoint
*bpt
;
14436 ALL_BREAKPOINTS (bpt
)
14438 if (bpt
->type
== bp_single_step
14439 && breakpoint_has_location_inserted_here (bpt
, aspace
, pc
))
14445 /* Tracepoint-specific operations. */
14447 /* Set tracepoint count to NUM. */
14449 set_tracepoint_count (int num
)
14451 tracepoint_count
= num
;
14452 set_internalvar_integer (lookup_internalvar ("tpnum"), num
);
14456 trace_command (const char *arg
, int from_tty
)
14458 event_location_up location
= string_to_event_location (&arg
,
14460 const struct breakpoint_ops
*ops
= breakpoint_ops_for_event_location
14461 (location
.get (), true /* is_tracepoint */);
14463 create_breakpoint (get_current_arch (),
14465 NULL
, 0, arg
, 1 /* parse arg */,
14467 bp_tracepoint
/* type_wanted */,
14468 0 /* Ignore count */,
14469 pending_break_support
,
14473 0 /* internal */, 0);
14477 ftrace_command (const char *arg
, int from_tty
)
14479 event_location_up location
= string_to_event_location (&arg
,
14481 create_breakpoint (get_current_arch (),
14483 NULL
, 0, arg
, 1 /* parse arg */,
14485 bp_fast_tracepoint
/* type_wanted */,
14486 0 /* Ignore count */,
14487 pending_break_support
,
14488 &tracepoint_breakpoint_ops
,
14491 0 /* internal */, 0);
14494 /* strace command implementation. Creates a static tracepoint. */
14497 strace_command (const char *arg
, int from_tty
)
14499 struct breakpoint_ops
*ops
;
14500 event_location_up location
;
14502 /* Decide if we are dealing with a static tracepoint marker (`-m'),
14503 or with a normal static tracepoint. */
14504 if (arg
&& startswith (arg
, "-m") && isspace (arg
[2]))
14506 ops
= &strace_marker_breakpoint_ops
;
14507 location
= new_linespec_location (&arg
, symbol_name_match_type::FULL
);
14511 ops
= &tracepoint_breakpoint_ops
;
14512 location
= string_to_event_location (&arg
, current_language
);
14515 create_breakpoint (get_current_arch (),
14517 NULL
, 0, arg
, 1 /* parse arg */,
14519 bp_static_tracepoint
/* type_wanted */,
14520 0 /* Ignore count */,
14521 pending_break_support
,
14525 0 /* internal */, 0);
14528 /* Set up a fake reader function that gets command lines from a linked
14529 list that was acquired during tracepoint uploading. */
14531 static struct uploaded_tp
*this_utp
;
14532 static int next_cmd
;
14535 read_uploaded_action (void)
14537 char *rslt
= nullptr;
14539 if (next_cmd
< this_utp
->cmd_strings
.size ())
14541 rslt
= this_utp
->cmd_strings
[next_cmd
].get ();
14548 /* Given information about a tracepoint as recorded on a target (which
14549 can be either a live system or a trace file), attempt to create an
14550 equivalent GDB tracepoint. This is not a reliable process, since
14551 the target does not necessarily have all the information used when
14552 the tracepoint was originally defined. */
14554 struct tracepoint
*
14555 create_tracepoint_from_upload (struct uploaded_tp
*utp
)
14557 const char *addr_str
;
14558 char small_buf
[100];
14559 struct tracepoint
*tp
;
14561 if (utp
->at_string
)
14562 addr_str
= utp
->at_string
.get ();
14565 /* In the absence of a source location, fall back to raw
14566 address. Since there is no way to confirm that the address
14567 means the same thing as when the trace was started, warn the
14569 warning (_("Uploaded tracepoint %d has no "
14570 "source location, using raw address"),
14572 xsnprintf (small_buf
, sizeof (small_buf
), "*%s", hex_string (utp
->addr
));
14573 addr_str
= small_buf
;
14576 /* There's not much we can do with a sequence of bytecodes. */
14577 if (utp
->cond
&& !utp
->cond_string
)
14578 warning (_("Uploaded tracepoint %d condition "
14579 "has no source form, ignoring it"),
14582 event_location_up location
= string_to_event_location (&addr_str
,
14584 if (!create_breakpoint (get_current_arch (),
14586 utp
->cond_string
.get (), -1, addr_str
,
14587 0 /* parse cond/thread */,
14589 utp
->type
/* type_wanted */,
14590 0 /* Ignore count */,
14591 pending_break_support
,
14592 &tracepoint_breakpoint_ops
,
14594 utp
->enabled
/* enabled */,
14596 CREATE_BREAKPOINT_FLAGS_INSERTED
))
14599 /* Get the tracepoint we just created. */
14600 tp
= get_tracepoint (tracepoint_count
);
14601 gdb_assert (tp
!= NULL
);
14605 xsnprintf (small_buf
, sizeof (small_buf
), "%d %d", utp
->pass
,
14608 trace_pass_command (small_buf
, 0);
14611 /* If we have uploaded versions of the original commands, set up a
14612 special-purpose "reader" function and call the usual command line
14613 reader, then pass the result to the breakpoint command-setting
14615 if (!utp
->cmd_strings
.empty ())
14617 counted_command_line cmd_list
;
14622 cmd_list
= read_command_lines_1 (read_uploaded_action
, 1, NULL
);
14624 breakpoint_set_commands (tp
, std::move (cmd_list
));
14626 else if (!utp
->actions
.empty ()
14627 || !utp
->step_actions
.empty ())
14628 warning (_("Uploaded tracepoint %d actions "
14629 "have no source form, ignoring them"),
14632 /* Copy any status information that might be available. */
14633 tp
->hit_count
= utp
->hit_count
;
14634 tp
->traceframe_usage
= utp
->traceframe_usage
;
14639 /* Print information on tracepoint number TPNUM_EXP, or all if
14643 info_tracepoints_command (const char *args
, int from_tty
)
14645 struct ui_out
*uiout
= current_uiout
;
14648 num_printed
= breakpoint_1 (args
, false, is_tracepoint
);
14650 if (num_printed
== 0)
14652 if (args
== NULL
|| *args
== '\0')
14653 uiout
->message ("No tracepoints.\n");
14655 uiout
->message ("No tracepoint matching '%s'.\n", args
);
14658 default_collect_info ();
14661 /* The 'enable trace' command enables tracepoints.
14662 Not supported by all targets. */
14664 enable_trace_command (const char *args
, int from_tty
)
14666 enable_command (args
, from_tty
);
14669 /* The 'disable trace' command disables tracepoints.
14670 Not supported by all targets. */
14672 disable_trace_command (const char *args
, int from_tty
)
14674 disable_command (args
, from_tty
);
14677 /* Remove a tracepoint (or all if no argument). */
14679 delete_trace_command (const char *arg
, int from_tty
)
14681 struct breakpoint
*b
, *b_tmp
;
14687 int breaks_to_delete
= 0;
14689 /* Delete all breakpoints if no argument.
14690 Do not delete internal or call-dummy breakpoints, these
14691 have to be deleted with an explicit breakpoint number
14693 ALL_TRACEPOINTS (b
)
14694 if (is_tracepoint (b
) && user_breakpoint_p (b
))
14696 breaks_to_delete
= 1;
14700 /* Ask user only if there are some breakpoints to delete. */
14702 || (breaks_to_delete
&& query (_("Delete all tracepoints? "))))
14704 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
14705 if (is_tracepoint (b
) && user_breakpoint_p (b
))
14706 delete_breakpoint (b
);
14710 map_breakpoint_numbers
14711 (arg
, [&] (breakpoint
*br
)
14713 iterate_over_related_breakpoints (br
, delete_breakpoint
);
14717 /* Helper function for trace_pass_command. */
14720 trace_pass_set_count (struct tracepoint
*tp
, int count
, int from_tty
)
14722 tp
->pass_count
= count
;
14723 gdb::observers::breakpoint_modified
.notify (tp
);
14725 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
14726 tp
->number
, count
);
14729 /* Set passcount for tracepoint.
14731 First command argument is passcount, second is tracepoint number.
14732 If tracepoint number omitted, apply to most recently defined.
14733 Also accepts special argument "all". */
14736 trace_pass_command (const char *args
, int from_tty
)
14738 struct tracepoint
*t1
;
14741 if (args
== 0 || *args
== 0)
14742 error (_("passcount command requires an "
14743 "argument (count + optional TP num)"));
14745 count
= strtoulst (args
, &args
, 10); /* Count comes first, then TP num. */
14747 args
= skip_spaces (args
);
14748 if (*args
&& strncasecmp (args
, "all", 3) == 0)
14750 struct breakpoint
*b
;
14752 args
+= 3; /* Skip special argument "all". */
14754 error (_("Junk at end of arguments."));
14756 ALL_TRACEPOINTS (b
)
14758 t1
= (struct tracepoint
*) b
;
14759 trace_pass_set_count (t1
, count
, from_tty
);
14762 else if (*args
== '\0')
14764 t1
= get_tracepoint_by_number (&args
, NULL
);
14766 trace_pass_set_count (t1
, count
, from_tty
);
14770 number_or_range_parser
parser (args
);
14771 while (!parser
.finished ())
14773 t1
= get_tracepoint_by_number (&args
, &parser
);
14775 trace_pass_set_count (t1
, count
, from_tty
);
14780 struct tracepoint
*
14781 get_tracepoint (int num
)
14783 struct breakpoint
*t
;
14785 ALL_TRACEPOINTS (t
)
14786 if (t
->number
== num
)
14787 return (struct tracepoint
*) t
;
14792 /* Find the tracepoint with the given target-side number (which may be
14793 different from the tracepoint number after disconnecting and
14796 struct tracepoint
*
14797 get_tracepoint_by_number_on_target (int num
)
14799 struct breakpoint
*b
;
14801 ALL_TRACEPOINTS (b
)
14803 struct tracepoint
*t
= (struct tracepoint
*) b
;
14805 if (t
->number_on_target
== num
)
14812 /* Utility: parse a tracepoint number and look it up in the list.
14813 If STATE is not NULL, use, get_number_or_range_state and ignore ARG.
14814 If the argument is missing, the most recent tracepoint
14815 (tracepoint_count) is returned. */
14817 struct tracepoint
*
14818 get_tracepoint_by_number (const char **arg
,
14819 number_or_range_parser
*parser
)
14821 struct breakpoint
*t
;
14823 const char *instring
= arg
== NULL
? NULL
: *arg
;
14825 if (parser
!= NULL
)
14827 gdb_assert (!parser
->finished ());
14828 tpnum
= parser
->get_number ();
14830 else if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
14831 tpnum
= tracepoint_count
;
14833 tpnum
= get_number (arg
);
14837 if (instring
&& *instring
)
14838 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
14841 printf_filtered (_("No previous tracepoint\n"));
14845 ALL_TRACEPOINTS (t
)
14846 if (t
->number
== tpnum
)
14848 return (struct tracepoint
*) t
;
14851 printf_unfiltered ("No tracepoint number %d.\n", tpnum
);
14856 print_recreate_thread (struct breakpoint
*b
, struct ui_file
*fp
)
14858 if (b
->thread
!= -1)
14859 fprintf_unfiltered (fp
, " thread %d", b
->thread
);
14862 fprintf_unfiltered (fp
, " task %d", b
->task
);
14864 fprintf_unfiltered (fp
, "\n");
14867 /* Save information on user settable breakpoints (watchpoints, etc) to
14868 a new script file named FILENAME. If FILTER is non-NULL, call it
14869 on each breakpoint and only include the ones for which it returns
14873 save_breakpoints (const char *filename
, int from_tty
,
14874 bool (*filter
) (const struct breakpoint
*))
14876 struct breakpoint
*tp
;
14878 int extra_trace_bits
= 0;
14880 if (filename
== 0 || *filename
== 0)
14881 error (_("Argument required (file name in which to save)"));
14883 /* See if we have anything to save. */
14884 ALL_BREAKPOINTS (tp
)
14886 /* Skip internal and momentary breakpoints. */
14887 if (!user_breakpoint_p (tp
))
14890 /* If we have a filter, only save the breakpoints it accepts. */
14891 if (filter
&& !filter (tp
))
14896 if (is_tracepoint (tp
))
14898 extra_trace_bits
= 1;
14900 /* We can stop searching. */
14907 warning (_("Nothing to save."));
14911 gdb::unique_xmalloc_ptr
<char> expanded_filename (tilde_expand (filename
));
14915 if (!fp
.open (expanded_filename
.get (), "w"))
14916 error (_("Unable to open file '%s' for saving (%s)"),
14917 expanded_filename
.get (), safe_strerror (errno
));
14919 if (extra_trace_bits
)
14920 save_trace_state_variables (&fp
);
14922 ALL_BREAKPOINTS (tp
)
14924 /* Skip internal and momentary breakpoints. */
14925 if (!user_breakpoint_p (tp
))
14928 /* If we have a filter, only save the breakpoints it accepts. */
14929 if (filter
&& !filter (tp
))
14932 tp
->ops
->print_recreate (tp
, &fp
);
14934 /* Note, we can't rely on tp->number for anything, as we can't
14935 assume the recreated breakpoint numbers will match. Use $bpnum
14938 if (tp
->cond_string
)
14939 fp
.printf (" condition $bpnum %s\n", tp
->cond_string
);
14941 if (tp
->ignore_count
)
14942 fp
.printf (" ignore $bpnum %d\n", tp
->ignore_count
);
14944 if (tp
->type
!= bp_dprintf
&& tp
->commands
)
14946 fp
.puts (" commands\n");
14948 current_uiout
->redirect (&fp
);
14951 print_command_lines (current_uiout
, tp
->commands
.get (), 2);
14953 catch (const gdb_exception
&ex
)
14955 current_uiout
->redirect (NULL
);
14959 current_uiout
->redirect (NULL
);
14960 fp
.puts (" end\n");
14963 if (tp
->enable_state
== bp_disabled
)
14964 fp
.puts ("disable $bpnum\n");
14966 /* If this is a multi-location breakpoint, check if the locations
14967 should be individually disabled. Watchpoint locations are
14968 special, and not user visible. */
14969 if (!is_watchpoint (tp
) && tp
->loc
&& tp
->loc
->next
)
14971 struct bp_location
*loc
;
14974 for (loc
= tp
->loc
; loc
!= NULL
; loc
= loc
->next
, n
++)
14976 fp
.printf ("disable $bpnum.%d\n", n
);
14980 if (extra_trace_bits
&& *default_collect
)
14981 fp
.printf ("set default-collect %s\n", default_collect
);
14984 printf_filtered (_("Saved to file '%s'.\n"), expanded_filename
.get ());
14987 /* The `save breakpoints' command. */
14990 save_breakpoints_command (const char *args
, int from_tty
)
14992 save_breakpoints (args
, from_tty
, NULL
);
14995 /* The `save tracepoints' command. */
14998 save_tracepoints_command (const char *args
, int from_tty
)
15000 save_breakpoints (args
, from_tty
, is_tracepoint
);
15003 /* Create a vector of all tracepoints. */
15005 std::vector
<breakpoint
*>
15006 all_tracepoints (void)
15008 std::vector
<breakpoint
*> tp_vec
;
15009 struct breakpoint
*tp
;
15011 ALL_TRACEPOINTS (tp
)
15013 tp_vec
.push_back (tp
);
15020 /* This help string is used to consolidate all the help string for specifying
15021 locations used by several commands. */
15023 #define LOCATION_HELP_STRING \
15024 "Linespecs are colon-separated lists of location parameters, such as\n\
15025 source filename, function name, label name, and line number.\n\
15026 Example: To specify the start of a label named \"the_top\" in the\n\
15027 function \"fact\" in the file \"factorial.c\", use\n\
15028 \"factorial.c:fact:the_top\".\n\
15030 Address locations begin with \"*\" and specify an exact address in the\n\
15031 program. Example: To specify the fourth byte past the start function\n\
15032 \"main\", use \"*main + 4\".\n\
15034 Explicit locations are similar to linespecs but use an option/argument\n\
15035 syntax to specify location parameters.\n\
15036 Example: To specify the start of the label named \"the_top\" in the\n\
15037 function \"fact\" in the file \"factorial.c\", use \"-source factorial.c\n\
15038 -function fact -label the_top\".\n\
15040 By default, a specified function is matched against the program's\n\
15041 functions in all scopes. For C++, this means in all namespaces and\n\
15042 classes. For Ada, this means in all packages. E.g., in C++,\n\
15043 \"func()\" matches \"A::func()\", \"A::B::func()\", etc. The\n\
15044 \"-qualified\" flag overrides this behavior, making GDB interpret the\n\
15045 specified name as a complete fully-qualified name instead."
15047 /* This help string is used for the break, hbreak, tbreak and thbreak
15048 commands. It is defined as a macro to prevent duplication.
15049 COMMAND should be a string constant containing the name of the
15052 #define BREAK_ARGS_HELP(command) \
15053 command" [PROBE_MODIFIER] [LOCATION] [thread THREADNUM] [if CONDITION]\n\
15054 PROBE_MODIFIER shall be present if the command is to be placed in a\n\
15055 probe point. Accepted values are `-probe' (for a generic, automatically\n\
15056 guessed probe type), `-probe-stap' (for a SystemTap probe) or \n\
15057 `-probe-dtrace' (for a DTrace probe).\n\
15058 LOCATION may be a linespec, address, or explicit location as described\n\
15061 With no LOCATION, uses current execution address of the selected\n\
15062 stack frame. This is useful for breaking on return to a stack frame.\n\
15064 THREADNUM is the number from \"info threads\".\n\
15065 CONDITION is a boolean expression.\n\
15066 \n" LOCATION_HELP_STRING "\n\n\
15067 Multiple breakpoints at one place are permitted, and useful if their\n\
15068 conditions are different.\n\
15070 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
15072 /* List of subcommands for "catch". */
15073 static struct cmd_list_element
*catch_cmdlist
;
15075 /* List of subcommands for "tcatch". */
15076 static struct cmd_list_element
*tcatch_cmdlist
;
15079 add_catch_command (const char *name
, const char *docstring
,
15080 cmd_const_sfunc_ftype
*sfunc
,
15081 completer_ftype
*completer
,
15082 void *user_data_catch
,
15083 void *user_data_tcatch
)
15085 struct cmd_list_element
*command
;
15087 command
= add_cmd (name
, class_breakpoint
, docstring
,
15089 set_cmd_sfunc (command
, sfunc
);
15090 set_cmd_context (command
, user_data_catch
);
15091 set_cmd_completer (command
, completer
);
15093 command
= add_cmd (name
, class_breakpoint
, docstring
,
15095 set_cmd_sfunc (command
, sfunc
);
15096 set_cmd_context (command
, user_data_tcatch
);
15097 set_cmd_completer (command
, completer
);
15100 struct breakpoint
*
15101 iterate_over_breakpoints (gdb::function_view
<bool (breakpoint
*)> callback
)
15103 struct breakpoint
*b
, *b_tmp
;
15105 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
15114 /* Zero if any of the breakpoint's locations could be a location where
15115 functions have been inlined, nonzero otherwise. */
15118 is_non_inline_function (struct breakpoint
*b
)
15120 /* The shared library event breakpoint is set on the address of a
15121 non-inline function. */
15122 if (b
->type
== bp_shlib_event
)
15128 /* Nonzero if the specified PC cannot be a location where functions
15129 have been inlined. */
15132 pc_at_non_inline_function (const address_space
*aspace
, CORE_ADDR pc
,
15133 const struct target_waitstatus
*ws
)
15135 struct breakpoint
*b
;
15136 struct bp_location
*bl
;
15138 ALL_BREAKPOINTS (b
)
15140 if (!is_non_inline_function (b
))
15143 for (bl
= b
->loc
; bl
!= NULL
; bl
= bl
->next
)
15145 if (!bl
->shlib_disabled
15146 && bpstat_check_location (bl
, aspace
, pc
, ws
))
15154 /* Remove any references to OBJFILE which is going to be freed. */
15157 breakpoint_free_objfile (struct objfile
*objfile
)
15159 struct bp_location
**locp
, *loc
;
15161 ALL_BP_LOCATIONS (loc
, locp
)
15162 if (loc
->symtab
!= NULL
&& SYMTAB_OBJFILE (loc
->symtab
) == objfile
)
15163 loc
->symtab
= NULL
;
15167 initialize_breakpoint_ops (void)
15169 static int initialized
= 0;
15171 struct breakpoint_ops
*ops
;
15177 /* The breakpoint_ops structure to be inherit by all kinds of
15178 breakpoints (real breakpoints, i.e., user "break" breakpoints,
15179 internal and momentary breakpoints, etc.). */
15180 ops
= &bkpt_base_breakpoint_ops
;
15181 *ops
= base_breakpoint_ops
;
15182 ops
->re_set
= bkpt_re_set
;
15183 ops
->insert_location
= bkpt_insert_location
;
15184 ops
->remove_location
= bkpt_remove_location
;
15185 ops
->breakpoint_hit
= bkpt_breakpoint_hit
;
15186 ops
->create_sals_from_location
= bkpt_create_sals_from_location
;
15187 ops
->create_breakpoints_sal
= bkpt_create_breakpoints_sal
;
15188 ops
->decode_location
= bkpt_decode_location
;
15190 /* The breakpoint_ops structure to be used in regular breakpoints. */
15191 ops
= &bkpt_breakpoint_ops
;
15192 *ops
= bkpt_base_breakpoint_ops
;
15193 ops
->re_set
= bkpt_re_set
;
15194 ops
->resources_needed
= bkpt_resources_needed
;
15195 ops
->print_it
= bkpt_print_it
;
15196 ops
->print_mention
= bkpt_print_mention
;
15197 ops
->print_recreate
= bkpt_print_recreate
;
15199 /* Ranged breakpoints. */
15200 ops
= &ranged_breakpoint_ops
;
15201 *ops
= bkpt_breakpoint_ops
;
15202 ops
->breakpoint_hit
= breakpoint_hit_ranged_breakpoint
;
15203 ops
->resources_needed
= resources_needed_ranged_breakpoint
;
15204 ops
->print_it
= print_it_ranged_breakpoint
;
15205 ops
->print_one
= print_one_ranged_breakpoint
;
15206 ops
->print_one_detail
= print_one_detail_ranged_breakpoint
;
15207 ops
->print_mention
= print_mention_ranged_breakpoint
;
15208 ops
->print_recreate
= print_recreate_ranged_breakpoint
;
15210 /* Internal breakpoints. */
15211 ops
= &internal_breakpoint_ops
;
15212 *ops
= bkpt_base_breakpoint_ops
;
15213 ops
->re_set
= internal_bkpt_re_set
;
15214 ops
->check_status
= internal_bkpt_check_status
;
15215 ops
->print_it
= internal_bkpt_print_it
;
15216 ops
->print_mention
= internal_bkpt_print_mention
;
15218 /* Momentary breakpoints. */
15219 ops
= &momentary_breakpoint_ops
;
15220 *ops
= bkpt_base_breakpoint_ops
;
15221 ops
->re_set
= momentary_bkpt_re_set
;
15222 ops
->check_status
= momentary_bkpt_check_status
;
15223 ops
->print_it
= momentary_bkpt_print_it
;
15224 ops
->print_mention
= momentary_bkpt_print_mention
;
15226 /* Probe breakpoints. */
15227 ops
= &bkpt_probe_breakpoint_ops
;
15228 *ops
= bkpt_breakpoint_ops
;
15229 ops
->insert_location
= bkpt_probe_insert_location
;
15230 ops
->remove_location
= bkpt_probe_remove_location
;
15231 ops
->create_sals_from_location
= bkpt_probe_create_sals_from_location
;
15232 ops
->decode_location
= bkpt_probe_decode_location
;
15235 ops
= &watchpoint_breakpoint_ops
;
15236 *ops
= base_breakpoint_ops
;
15237 ops
->re_set
= re_set_watchpoint
;
15238 ops
->insert_location
= insert_watchpoint
;
15239 ops
->remove_location
= remove_watchpoint
;
15240 ops
->breakpoint_hit
= breakpoint_hit_watchpoint
;
15241 ops
->check_status
= check_status_watchpoint
;
15242 ops
->resources_needed
= resources_needed_watchpoint
;
15243 ops
->works_in_software_mode
= works_in_software_mode_watchpoint
;
15244 ops
->print_it
= print_it_watchpoint
;
15245 ops
->print_mention
= print_mention_watchpoint
;
15246 ops
->print_recreate
= print_recreate_watchpoint
;
15247 ops
->explains_signal
= explains_signal_watchpoint
;
15249 /* Masked watchpoints. */
15250 ops
= &masked_watchpoint_breakpoint_ops
;
15251 *ops
= watchpoint_breakpoint_ops
;
15252 ops
->insert_location
= insert_masked_watchpoint
;
15253 ops
->remove_location
= remove_masked_watchpoint
;
15254 ops
->resources_needed
= resources_needed_masked_watchpoint
;
15255 ops
->works_in_software_mode
= works_in_software_mode_masked_watchpoint
;
15256 ops
->print_it
= print_it_masked_watchpoint
;
15257 ops
->print_one_detail
= print_one_detail_masked_watchpoint
;
15258 ops
->print_mention
= print_mention_masked_watchpoint
;
15259 ops
->print_recreate
= print_recreate_masked_watchpoint
;
15262 ops
= &tracepoint_breakpoint_ops
;
15263 *ops
= base_breakpoint_ops
;
15264 ops
->re_set
= tracepoint_re_set
;
15265 ops
->breakpoint_hit
= tracepoint_breakpoint_hit
;
15266 ops
->print_one_detail
= tracepoint_print_one_detail
;
15267 ops
->print_mention
= tracepoint_print_mention
;
15268 ops
->print_recreate
= tracepoint_print_recreate
;
15269 ops
->create_sals_from_location
= tracepoint_create_sals_from_location
;
15270 ops
->create_breakpoints_sal
= tracepoint_create_breakpoints_sal
;
15271 ops
->decode_location
= tracepoint_decode_location
;
15273 /* Probe tracepoints. */
15274 ops
= &tracepoint_probe_breakpoint_ops
;
15275 *ops
= tracepoint_breakpoint_ops
;
15276 ops
->create_sals_from_location
= tracepoint_probe_create_sals_from_location
;
15277 ops
->decode_location
= tracepoint_probe_decode_location
;
15279 /* Static tracepoints with marker (`-m'). */
15280 ops
= &strace_marker_breakpoint_ops
;
15281 *ops
= tracepoint_breakpoint_ops
;
15282 ops
->create_sals_from_location
= strace_marker_create_sals_from_location
;
15283 ops
->create_breakpoints_sal
= strace_marker_create_breakpoints_sal
;
15284 ops
->decode_location
= strace_marker_decode_location
;
15286 /* Fork catchpoints. */
15287 ops
= &catch_fork_breakpoint_ops
;
15288 *ops
= base_breakpoint_ops
;
15289 ops
->insert_location
= insert_catch_fork
;
15290 ops
->remove_location
= remove_catch_fork
;
15291 ops
->breakpoint_hit
= breakpoint_hit_catch_fork
;
15292 ops
->print_it
= print_it_catch_fork
;
15293 ops
->print_one
= print_one_catch_fork
;
15294 ops
->print_mention
= print_mention_catch_fork
;
15295 ops
->print_recreate
= print_recreate_catch_fork
;
15297 /* Vfork catchpoints. */
15298 ops
= &catch_vfork_breakpoint_ops
;
15299 *ops
= base_breakpoint_ops
;
15300 ops
->insert_location
= insert_catch_vfork
;
15301 ops
->remove_location
= remove_catch_vfork
;
15302 ops
->breakpoint_hit
= breakpoint_hit_catch_vfork
;
15303 ops
->print_it
= print_it_catch_vfork
;
15304 ops
->print_one
= print_one_catch_vfork
;
15305 ops
->print_mention
= print_mention_catch_vfork
;
15306 ops
->print_recreate
= print_recreate_catch_vfork
;
15308 /* Exec catchpoints. */
15309 ops
= &catch_exec_breakpoint_ops
;
15310 *ops
= base_breakpoint_ops
;
15311 ops
->insert_location
= insert_catch_exec
;
15312 ops
->remove_location
= remove_catch_exec
;
15313 ops
->breakpoint_hit
= breakpoint_hit_catch_exec
;
15314 ops
->print_it
= print_it_catch_exec
;
15315 ops
->print_one
= print_one_catch_exec
;
15316 ops
->print_mention
= print_mention_catch_exec
;
15317 ops
->print_recreate
= print_recreate_catch_exec
;
15319 /* Solib-related catchpoints. */
15320 ops
= &catch_solib_breakpoint_ops
;
15321 *ops
= base_breakpoint_ops
;
15322 ops
->insert_location
= insert_catch_solib
;
15323 ops
->remove_location
= remove_catch_solib
;
15324 ops
->breakpoint_hit
= breakpoint_hit_catch_solib
;
15325 ops
->check_status
= check_status_catch_solib
;
15326 ops
->print_it
= print_it_catch_solib
;
15327 ops
->print_one
= print_one_catch_solib
;
15328 ops
->print_mention
= print_mention_catch_solib
;
15329 ops
->print_recreate
= print_recreate_catch_solib
;
15331 ops
= &dprintf_breakpoint_ops
;
15332 *ops
= bkpt_base_breakpoint_ops
;
15333 ops
->re_set
= dprintf_re_set
;
15334 ops
->resources_needed
= bkpt_resources_needed
;
15335 ops
->print_it
= bkpt_print_it
;
15336 ops
->print_mention
= bkpt_print_mention
;
15337 ops
->print_recreate
= dprintf_print_recreate
;
15338 ops
->after_condition_true
= dprintf_after_condition_true
;
15339 ops
->breakpoint_hit
= dprintf_breakpoint_hit
;
15342 /* Chain containing all defined "enable breakpoint" subcommands. */
15344 static struct cmd_list_element
*enablebreaklist
= NULL
;
15346 /* See breakpoint.h. */
15348 cmd_list_element
*commands_cmd_element
= nullptr;
15350 void _initialize_breakpoint ();
15352 _initialize_breakpoint ()
15354 struct cmd_list_element
*c
;
15356 initialize_breakpoint_ops ();
15358 gdb::observers::solib_unloaded
.attach (disable_breakpoints_in_unloaded_shlib
);
15359 gdb::observers::free_objfile
.attach (disable_breakpoints_in_freed_objfile
);
15360 gdb::observers::memory_changed
.attach (invalidate_bp_value_on_memory_change
);
15362 breakpoint_chain
= 0;
15363 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
15364 before a breakpoint is set. */
15365 breakpoint_count
= 0;
15367 tracepoint_count
= 0;
15369 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
15370 Set ignore-count of breakpoint number N to COUNT.\n\
15371 Usage is `ignore N COUNT'."));
15373 commands_cmd_element
= add_com ("commands", class_breakpoint
,
15374 commands_command
, _("\
15375 Set commands to be executed when the given breakpoints are hit.\n\
15376 Give a space-separated breakpoint list as argument after \"commands\".\n\
15377 A list element can be a breakpoint number (e.g. `5') or a range of numbers\n\
15379 With no argument, the targeted breakpoint is the last one set.\n\
15380 The commands themselves follow starting on the next line.\n\
15381 Type a line containing \"end\" to indicate the end of them.\n\
15382 Give \"silent\" as the first line to make the breakpoint silent;\n\
15383 then no output is printed when it is hit, except what the commands print."));
15385 c
= add_com ("condition", class_breakpoint
, condition_command
, _("\
15386 Specify breakpoint number N to break only if COND is true.\n\
15387 Usage is `condition N COND', where N is an integer and COND is an\n\
15388 expression to be evaluated whenever breakpoint N is reached."));
15389 set_cmd_completer (c
, condition_completer
);
15391 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
15392 Set a temporary breakpoint.\n\
15393 Like \"break\" except the breakpoint is only temporary,\n\
15394 so it will be deleted when hit. Equivalent to \"break\" followed\n\
15395 by using \"enable delete\" on the breakpoint number.\n\
15397 BREAK_ARGS_HELP ("tbreak")));
15398 set_cmd_completer (c
, location_completer
);
15400 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
15401 Set a hardware assisted breakpoint.\n\
15402 Like \"break\" except the breakpoint requires hardware support,\n\
15403 some target hardware may not have this support.\n\
15405 BREAK_ARGS_HELP ("hbreak")));
15406 set_cmd_completer (c
, location_completer
);
15408 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
15409 Set a temporary hardware assisted breakpoint.\n\
15410 Like \"hbreak\" except the breakpoint is only temporary,\n\
15411 so it will be deleted when hit.\n\
15413 BREAK_ARGS_HELP ("thbreak")));
15414 set_cmd_completer (c
, location_completer
);
15416 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
15417 Enable all or some breakpoints.\n\
15418 Usage: enable [BREAKPOINTNUM]...\n\
15419 Give breakpoint numbers (separated by spaces) as arguments.\n\
15420 With no subcommand, breakpoints are enabled until you command otherwise.\n\
15421 This is used to cancel the effect of the \"disable\" command.\n\
15422 With a subcommand you can enable temporarily."),
15423 &enablelist
, "enable ", 1, &cmdlist
);
15425 add_com_alias ("en", "enable", class_breakpoint
, 1);
15427 add_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
15428 Enable all or some breakpoints.\n\
15429 Usage: enable breakpoints [BREAKPOINTNUM]...\n\
15430 Give breakpoint numbers (separated by spaces) as arguments.\n\
15431 This is used to cancel the effect of the \"disable\" command.\n\
15432 May be abbreviated to simply \"enable\"."),
15433 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
15435 add_cmd ("once", no_class
, enable_once_command
, _("\
15436 Enable some breakpoints for one hit.\n\
15437 Usage: enable breakpoints once BREAKPOINTNUM...\n\
15438 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
15441 add_cmd ("delete", no_class
, enable_delete_command
, _("\
15442 Enable some breakpoints and delete when hit.\n\
15443 Usage: enable breakpoints delete BREAKPOINTNUM...\n\
15444 If a breakpoint is hit while enabled in this fashion, it is deleted."),
15447 add_cmd ("count", no_class
, enable_count_command
, _("\
15448 Enable some breakpoints for COUNT hits.\n\
15449 Usage: enable breakpoints count COUNT BREAKPOINTNUM...\n\
15450 If a breakpoint is hit while enabled in this fashion,\n\
15451 the count is decremented; when it reaches zero, the breakpoint is disabled."),
15454 add_cmd ("delete", no_class
, enable_delete_command
, _("\
15455 Enable some breakpoints and delete when hit.\n\
15456 Usage: enable delete BREAKPOINTNUM...\n\
15457 If a breakpoint is hit while enabled in this fashion, it is deleted."),
15460 add_cmd ("once", no_class
, enable_once_command
, _("\
15461 Enable some breakpoints for one hit.\n\
15462 Usage: enable once BREAKPOINTNUM...\n\
15463 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
15466 add_cmd ("count", no_class
, enable_count_command
, _("\
15467 Enable some breakpoints for COUNT hits.\n\
15468 Usage: enable count COUNT BREAKPOINTNUM...\n\
15469 If a breakpoint is hit while enabled in this fashion,\n\
15470 the count is decremented; when it reaches zero, the breakpoint is disabled."),
15473 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
15474 Disable all or some breakpoints.\n\
15475 Usage: disable [BREAKPOINTNUM]...\n\
15476 Arguments are breakpoint numbers with spaces in between.\n\
15477 To disable all breakpoints, give no argument.\n\
15478 A disabled breakpoint is not forgotten, but has no effect until re-enabled."),
15479 &disablelist
, "disable ", 1, &cmdlist
);
15480 add_com_alias ("dis", "disable", class_breakpoint
, 1);
15481 add_com_alias ("disa", "disable", class_breakpoint
, 1);
15483 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
15484 Disable all or some breakpoints.\n\
15485 Usage: disable breakpoints [BREAKPOINTNUM]...\n\
15486 Arguments are breakpoint numbers with spaces in between.\n\
15487 To disable all breakpoints, give no argument.\n\
15488 A disabled breakpoint is not forgotten, but has no effect until re-enabled.\n\
15489 This command may be abbreviated \"disable\"."),
15492 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
15493 Delete all or some breakpoints.\n\
15494 Usage: delete [BREAKPOINTNUM]...\n\
15495 Arguments are breakpoint numbers with spaces in between.\n\
15496 To delete all breakpoints, give no argument.\n\
15498 Also a prefix command for deletion of other GDB objects."),
15499 &deletelist
, "delete ", 1, &cmdlist
);
15500 add_com_alias ("d", "delete", class_breakpoint
, 1);
15501 add_com_alias ("del", "delete", class_breakpoint
, 1);
15503 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
15504 Delete all or some breakpoints or auto-display expressions.\n\
15505 Usage: delete breakpoints [BREAKPOINTNUM]...\n\
15506 Arguments are breakpoint numbers with spaces in between.\n\
15507 To delete all breakpoints, give no argument.\n\
15508 This command may be abbreviated \"delete\"."),
15511 add_com ("clear", class_breakpoint
, clear_command
, _("\
15512 Clear breakpoint at specified location.\n\
15513 Argument may be a linespec, explicit, or address location as described below.\n\
15515 With no argument, clears all breakpoints in the line that the selected frame\n\
15516 is executing in.\n"
15517 "\n" LOCATION_HELP_STRING
"\n\n\
15518 See also the \"delete\" command which clears breakpoints by number."));
15519 add_com_alias ("cl", "clear", class_breakpoint
, 1);
15521 c
= add_com ("break", class_breakpoint
, break_command
, _("\
15522 Set breakpoint at specified location.\n"
15523 BREAK_ARGS_HELP ("break")));
15524 set_cmd_completer (c
, location_completer
);
15526 add_com_alias ("b", "break", class_run
, 1);
15527 add_com_alias ("br", "break", class_run
, 1);
15528 add_com_alias ("bre", "break", class_run
, 1);
15529 add_com_alias ("brea", "break", class_run
, 1);
15533 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
15534 Break in function/address or break at a line in the current file."),
15535 &stoplist
, "stop ", 1, &cmdlist
);
15536 add_cmd ("in", class_breakpoint
, stopin_command
,
15537 _("Break in function or address."), &stoplist
);
15538 add_cmd ("at", class_breakpoint
, stopat_command
,
15539 _("Break at a line in the current file."), &stoplist
);
15540 add_com ("status", class_info
, info_breakpoints_command
, _("\
15541 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
15542 The \"Type\" column indicates one of:\n\
15543 \tbreakpoint - normal breakpoint\n\
15544 \twatchpoint - watchpoint\n\
15545 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15546 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
15547 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
15548 address and file/line number respectively.\n\
15550 Convenience variable \"$_\" and default examine address for \"x\"\n\
15551 are set to the address of the last breakpoint listed unless the command\n\
15552 is prefixed with \"server \".\n\n\
15553 Convenience variable \"$bpnum\" contains the number of the last\n\
15554 breakpoint set."));
15557 add_info ("breakpoints", info_breakpoints_command
, _("\
15558 Status of specified breakpoints (all user-settable breakpoints if no argument).\n\
15559 The \"Type\" column indicates one of:\n\
15560 \tbreakpoint - normal breakpoint\n\
15561 \twatchpoint - watchpoint\n\
15562 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15563 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
15564 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
15565 address and file/line number respectively.\n\
15567 Convenience variable \"$_\" and default examine address for \"x\"\n\
15568 are set to the address of the last breakpoint listed unless the command\n\
15569 is prefixed with \"server \".\n\n\
15570 Convenience variable \"$bpnum\" contains the number of the last\n\
15571 breakpoint set."));
15573 add_info_alias ("b", "breakpoints", 1);
15575 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
15576 Status of all breakpoints, or breakpoint number NUMBER.\n\
15577 The \"Type\" column indicates one of:\n\
15578 \tbreakpoint - normal breakpoint\n\
15579 \twatchpoint - watchpoint\n\
15580 \tlongjmp - internal breakpoint used to step through longjmp()\n\
15581 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
15582 \tuntil - internal breakpoint used by the \"until\" command\n\
15583 \tfinish - internal breakpoint used by the \"finish\" command\n\
15584 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15585 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
15586 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
15587 address and file/line number respectively.\n\
15589 Convenience variable \"$_\" and default examine address for \"x\"\n\
15590 are set to the address of the last breakpoint listed unless the command\n\
15591 is prefixed with \"server \".\n\n\
15592 Convenience variable \"$bpnum\" contains the number of the last\n\
15594 &maintenanceinfolist
);
15596 add_basic_prefix_cmd ("catch", class_breakpoint
, _("\
15597 Set catchpoints to catch events."),
15598 &catch_cmdlist
, "catch ",
15599 0/*allow-unknown*/, &cmdlist
);
15601 add_basic_prefix_cmd ("tcatch", class_breakpoint
, _("\
15602 Set temporary catchpoints to catch events."),
15603 &tcatch_cmdlist
, "tcatch ",
15604 0/*allow-unknown*/, &cmdlist
);
15606 add_catch_command ("fork", _("Catch calls to fork."),
15607 catch_fork_command_1
,
15609 (void *) (uintptr_t) catch_fork_permanent
,
15610 (void *) (uintptr_t) catch_fork_temporary
);
15611 add_catch_command ("vfork", _("Catch calls to vfork."),
15612 catch_fork_command_1
,
15614 (void *) (uintptr_t) catch_vfork_permanent
,
15615 (void *) (uintptr_t) catch_vfork_temporary
);
15616 add_catch_command ("exec", _("Catch calls to exec."),
15617 catch_exec_command_1
,
15621 add_catch_command ("load", _("Catch loads of shared libraries.\n\
15622 Usage: catch load [REGEX]\n\
15623 If REGEX is given, only stop for libraries matching the regular expression."),
15624 catch_load_command_1
,
15628 add_catch_command ("unload", _("Catch unloads of shared libraries.\n\
15629 Usage: catch unload [REGEX]\n\
15630 If REGEX is given, only stop for libraries matching the regular expression."),
15631 catch_unload_command_1
,
15636 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
15637 Set a watchpoint for an expression.\n\
15638 Usage: watch [-l|-location] EXPRESSION\n\
15639 A watchpoint stops execution of your program whenever the value of\n\
15640 an expression changes.\n\
15641 If -l or -location is given, this evaluates EXPRESSION and watches\n\
15642 the memory to which it refers."));
15643 set_cmd_completer (c
, expression_completer
);
15645 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
15646 Set a read watchpoint for an expression.\n\
15647 Usage: rwatch [-l|-location] EXPRESSION\n\
15648 A watchpoint stops execution of your program whenever the value of\n\
15649 an expression is read.\n\
15650 If -l or -location is given, this evaluates EXPRESSION and watches\n\
15651 the memory to which it refers."));
15652 set_cmd_completer (c
, expression_completer
);
15654 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
15655 Set a watchpoint for an expression.\n\
15656 Usage: awatch [-l|-location] EXPRESSION\n\
15657 A watchpoint stops execution of your program whenever the value of\n\
15658 an expression is either read or written.\n\
15659 If -l or -location is given, this evaluates EXPRESSION and watches\n\
15660 the memory to which it refers."));
15661 set_cmd_completer (c
, expression_completer
);
15663 add_info ("watchpoints", info_watchpoints_command
, _("\
15664 Status of specified watchpoints (all watchpoints if no argument)."));
15666 /* XXX: cagney/2005-02-23: This should be a boolean, and should
15667 respond to changes - contrary to the description. */
15668 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
15669 &can_use_hw_watchpoints
, _("\
15670 Set debugger's willingness to use watchpoint hardware."), _("\
15671 Show debugger's willingness to use watchpoint hardware."), _("\
15672 If zero, gdb will not use hardware for new watchpoints, even if\n\
15673 such is available. (However, any hardware watchpoints that were\n\
15674 created before setting this to nonzero, will continue to use watchpoint\n\
15677 show_can_use_hw_watchpoints
,
15678 &setlist
, &showlist
);
15680 can_use_hw_watchpoints
= 1;
15682 /* Tracepoint manipulation commands. */
15684 c
= add_com ("trace", class_breakpoint
, trace_command
, _("\
15685 Set a tracepoint at specified location.\n\
15687 BREAK_ARGS_HELP ("trace") "\n\
15688 Do \"help tracepoints\" for info on other tracepoint commands."));
15689 set_cmd_completer (c
, location_completer
);
15691 add_com_alias ("tp", "trace", class_alias
, 0);
15692 add_com_alias ("tr", "trace", class_alias
, 1);
15693 add_com_alias ("tra", "trace", class_alias
, 1);
15694 add_com_alias ("trac", "trace", class_alias
, 1);
15696 c
= add_com ("ftrace", class_breakpoint
, ftrace_command
, _("\
15697 Set a fast tracepoint at specified location.\n\
15699 BREAK_ARGS_HELP ("ftrace") "\n\
15700 Do \"help tracepoints\" for info on other tracepoint commands."));
15701 set_cmd_completer (c
, location_completer
);
15703 c
= add_com ("strace", class_breakpoint
, strace_command
, _("\
15704 Set a static tracepoint at location or marker.\n\
15706 strace [LOCATION] [if CONDITION]\n\
15707 LOCATION may be a linespec, explicit, or address location (described below) \n\
15708 or -m MARKER_ID.\n\n\
15709 If a marker id is specified, probe the marker with that name. With\n\
15710 no LOCATION, uses current execution address of the selected stack frame.\n\
15711 Static tracepoints accept an extra collect action -- ``collect $_sdata''.\n\
15712 This collects arbitrary user data passed in the probe point call to the\n\
15713 tracing library. You can inspect it when analyzing the trace buffer,\n\
15714 by printing the $_sdata variable like any other convenience variable.\n\
15716 CONDITION is a boolean expression.\n\
15717 \n" LOCATION_HELP_STRING
"\n\n\
15718 Multiple tracepoints at one place are permitted, and useful if their\n\
15719 conditions are different.\n\
15721 Do \"help breakpoints\" for info on other commands dealing with breakpoints.\n\
15722 Do \"help tracepoints\" for info on other tracepoint commands."));
15723 set_cmd_completer (c
, location_completer
);
15725 add_info ("tracepoints", info_tracepoints_command
, _("\
15726 Status of specified tracepoints (all tracepoints if no argument).\n\
15727 Convenience variable \"$tpnum\" contains the number of the\n\
15728 last tracepoint set."));
15730 add_info_alias ("tp", "tracepoints", 1);
15732 add_cmd ("tracepoints", class_trace
, delete_trace_command
, _("\
15733 Delete specified tracepoints.\n\
15734 Arguments are tracepoint numbers, separated by spaces.\n\
15735 No argument means delete all tracepoints."),
15737 add_alias_cmd ("tr", "tracepoints", class_trace
, 1, &deletelist
);
15739 c
= add_cmd ("tracepoints", class_trace
, disable_trace_command
, _("\
15740 Disable specified tracepoints.\n\
15741 Arguments are tracepoint numbers, separated by spaces.\n\
15742 No argument means disable all tracepoints."),
15744 deprecate_cmd (c
, "disable");
15746 c
= add_cmd ("tracepoints", class_trace
, enable_trace_command
, _("\
15747 Enable specified tracepoints.\n\
15748 Arguments are tracepoint numbers, separated by spaces.\n\
15749 No argument means enable all tracepoints."),
15751 deprecate_cmd (c
, "enable");
15753 add_com ("passcount", class_trace
, trace_pass_command
, _("\
15754 Set the passcount for a tracepoint.\n\
15755 The trace will end when the tracepoint has been passed 'count' times.\n\
15756 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
15757 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
15759 add_basic_prefix_cmd ("save", class_breakpoint
,
15760 _("Save breakpoint definitions as a script."),
15761 &save_cmdlist
, "save ",
15762 0/*allow-unknown*/, &cmdlist
);
15764 c
= add_cmd ("breakpoints", class_breakpoint
, save_breakpoints_command
, _("\
15765 Save current breakpoint definitions as a script.\n\
15766 This includes all types of breakpoints (breakpoints, watchpoints,\n\
15767 catchpoints, tracepoints). Use the 'source' command in another debug\n\
15768 session to restore them."),
15770 set_cmd_completer (c
, filename_completer
);
15772 c
= add_cmd ("tracepoints", class_trace
, save_tracepoints_command
, _("\
15773 Save current tracepoint definitions as a script.\n\
15774 Use the 'source' command in another debug session to restore them."),
15776 set_cmd_completer (c
, filename_completer
);
15778 c
= add_com_alias ("save-tracepoints", "save tracepoints", class_trace
, 0);
15779 deprecate_cmd (c
, "save tracepoints");
15781 add_basic_prefix_cmd ("breakpoint", class_maintenance
, _("\
15782 Breakpoint specific settings.\n\
15783 Configure various breakpoint-specific variables such as\n\
15784 pending breakpoint behavior."),
15785 &breakpoint_set_cmdlist
, "set breakpoint ",
15786 0/*allow-unknown*/, &setlist
);
15787 add_show_prefix_cmd ("breakpoint", class_maintenance
, _("\
15788 Breakpoint specific settings.\n\
15789 Configure various breakpoint-specific variables such as\n\
15790 pending breakpoint behavior."),
15791 &breakpoint_show_cmdlist
, "show breakpoint ",
15792 0/*allow-unknown*/, &showlist
);
15794 add_setshow_auto_boolean_cmd ("pending", no_class
,
15795 &pending_break_support
, _("\
15796 Set debugger's behavior regarding pending breakpoints."), _("\
15797 Show debugger's behavior regarding pending breakpoints."), _("\
15798 If on, an unrecognized breakpoint location will cause gdb to create a\n\
15799 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
15800 an error. If auto, an unrecognized breakpoint location results in a\n\
15801 user-query to see if a pending breakpoint should be created."),
15803 show_pending_break_support
,
15804 &breakpoint_set_cmdlist
,
15805 &breakpoint_show_cmdlist
);
15807 pending_break_support
= AUTO_BOOLEAN_AUTO
;
15809 add_setshow_boolean_cmd ("auto-hw", no_class
,
15810 &automatic_hardware_breakpoints
, _("\
15811 Set automatic usage of hardware breakpoints."), _("\
15812 Show automatic usage of hardware breakpoints."), _("\
15813 If set, the debugger will automatically use hardware breakpoints for\n\
15814 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
15815 a warning will be emitted for such breakpoints."),
15817 show_automatic_hardware_breakpoints
,
15818 &breakpoint_set_cmdlist
,
15819 &breakpoint_show_cmdlist
);
15821 add_setshow_boolean_cmd ("always-inserted", class_support
,
15822 &always_inserted_mode
, _("\
15823 Set mode for inserting breakpoints."), _("\
15824 Show mode for inserting breakpoints."), _("\
15825 When this mode is on, breakpoints are inserted immediately as soon as\n\
15826 they're created, kept inserted even when execution stops, and removed\n\
15827 only when the user deletes them. When this mode is off (the default),\n\
15828 breakpoints are inserted only when execution continues, and removed\n\
15829 when execution stops."),
15831 &show_always_inserted_mode
,
15832 &breakpoint_set_cmdlist
,
15833 &breakpoint_show_cmdlist
);
15835 add_setshow_enum_cmd ("condition-evaluation", class_breakpoint
,
15836 condition_evaluation_enums
,
15837 &condition_evaluation_mode_1
, _("\
15838 Set mode of breakpoint condition evaluation."), _("\
15839 Show mode of breakpoint condition evaluation."), _("\
15840 When this is set to \"host\", breakpoint conditions will be\n\
15841 evaluated on the host's side by GDB. When it is set to \"target\",\n\
15842 breakpoint conditions will be downloaded to the target (if the target\n\
15843 supports such feature) and conditions will be evaluated on the target's side.\n\
15844 If this is set to \"auto\" (default), this will be automatically set to\n\
15845 \"target\" if it supports condition evaluation, otherwise it will\n\
15846 be set to \"gdb\""),
15847 &set_condition_evaluation_mode
,
15848 &show_condition_evaluation_mode
,
15849 &breakpoint_set_cmdlist
,
15850 &breakpoint_show_cmdlist
);
15852 add_com ("break-range", class_breakpoint
, break_range_command
, _("\
15853 Set a breakpoint for an address range.\n\
15854 break-range START-LOCATION, END-LOCATION\n\
15855 where START-LOCATION and END-LOCATION can be one of the following:\n\
15856 LINENUM, for that line in the current file,\n\
15857 FILE:LINENUM, for that line in that file,\n\
15858 +OFFSET, for that number of lines after the current line\n\
15859 or the start of the range\n\
15860 FUNCTION, for the first line in that function,\n\
15861 FILE:FUNCTION, to distinguish among like-named static functions.\n\
15862 *ADDRESS, for the instruction at that address.\n\
15864 The breakpoint will stop execution of the inferior whenever it executes\n\
15865 an instruction at any address within the [START-LOCATION, END-LOCATION]\n\
15866 range (including START-LOCATION and END-LOCATION)."));
15868 c
= add_com ("dprintf", class_breakpoint
, dprintf_command
, _("\
15869 Set a dynamic printf at specified location.\n\
15870 dprintf location,format string,arg1,arg2,...\n\
15871 location may be a linespec, explicit, or address location.\n"
15872 "\n" LOCATION_HELP_STRING
));
15873 set_cmd_completer (c
, location_completer
);
15875 add_setshow_enum_cmd ("dprintf-style", class_support
,
15876 dprintf_style_enums
, &dprintf_style
, _("\
15877 Set the style of usage for dynamic printf."), _("\
15878 Show the style of usage for dynamic printf."), _("\
15879 This setting chooses how GDB will do a dynamic printf.\n\
15880 If the value is \"gdb\", then the printing is done by GDB to its own\n\
15881 console, as with the \"printf\" command.\n\
15882 If the value is \"call\", the print is done by calling a function in your\n\
15883 program; by default printf(), but you can choose a different function or\n\
15884 output stream by setting dprintf-function and dprintf-channel."),
15885 update_dprintf_commands
, NULL
,
15886 &setlist
, &showlist
);
15888 dprintf_function
= xstrdup ("printf");
15889 add_setshow_string_cmd ("dprintf-function", class_support
,
15890 &dprintf_function
, _("\
15891 Set the function to use for dynamic printf."), _("\
15892 Show the function to use for dynamic printf."), NULL
,
15893 update_dprintf_commands
, NULL
,
15894 &setlist
, &showlist
);
15896 dprintf_channel
= xstrdup ("");
15897 add_setshow_string_cmd ("dprintf-channel", class_support
,
15898 &dprintf_channel
, _("\
15899 Set the channel to use for dynamic printf."), _("\
15900 Show the channel to use for dynamic printf."), NULL
,
15901 update_dprintf_commands
, NULL
,
15902 &setlist
, &showlist
);
15904 add_setshow_boolean_cmd ("disconnected-dprintf", no_class
,
15905 &disconnected_dprintf
, _("\
15906 Set whether dprintf continues after GDB disconnects."), _("\
15907 Show whether dprintf continues after GDB disconnects."), _("\
15908 Use this to let dprintf commands continue to hit and produce output\n\
15909 even if GDB disconnects or detaches from the target."),
15912 &setlist
, &showlist
);
15914 add_com ("agent-printf", class_vars
, agent_printf_command
, _("\
15915 Target agent only formatted printing, like the C \"printf\" function.\n\
15916 Usage: agent-printf \"format string\", ARG1, ARG2, ARG3, ..., ARGN\n\
15917 This supports most C printf format specifications, like %s, %d, etc.\n\
15918 This is useful for formatted output in user-defined commands."));
15920 automatic_hardware_breakpoints
= true;
15922 gdb::observers::about_to_proceed
.attach (breakpoint_about_to_proceed
);
15923 gdb::observers::thread_exit
.attach (remove_threaded_breakpoints
);