1 /* Everything about breakpoints, for GDB.
3 Copyright (C) 1986-2017 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"
58 #include "parser-defs.h"
59 #include "gdb_regex.h"
61 #include "cli/cli-utils.h"
62 #include "continuations.h"
66 #include "dummy-frame.h"
69 #include "thread-fsm.h"
70 #include "tid-parse.h"
72 /* readline include files */
73 #include "readline/readline.h"
74 #include "readline/history.h"
76 /* readline defines this. */
79 #include "mi/mi-common.h"
80 #include "extension.h"
82 #include "progspace-and-thread.h"
83 #include "common/array-view.h"
84 #include "common/gdb_optional.h"
86 /* Enums for exception-handling support. */
87 enum exception_event_kind
94 /* Prototypes for local functions. */
96 static void map_breakpoint_numbers (const char *,
97 gdb::function_view<void (breakpoint *)>);
99 static void ignore_command (char *, int);
101 static void breakpoint_re_set_default (struct breakpoint *);
104 create_sals_from_location_default (const struct event_location *location,
105 struct linespec_result *canonical,
106 enum bptype type_wanted);
108 static void create_breakpoints_sal_default (struct gdbarch *,
109 struct linespec_result *,
110 gdb::unique_xmalloc_ptr<char>,
111 gdb::unique_xmalloc_ptr<char>,
113 enum bpdisp, int, int,
115 const struct breakpoint_ops *,
116 int, int, int, unsigned);
118 static std::vector<symtab_and_line> decode_location_default
119 (struct breakpoint *b, const struct event_location *location,
120 struct program_space *search_pspace);
122 static void clear_command (char *, int);
124 static int can_use_hardware_watchpoint (struct value *);
126 static void mention (struct breakpoint *);
128 static struct breakpoint *set_raw_breakpoint_without_location (struct gdbarch *,
130 const struct breakpoint_ops *);
131 static struct bp_location *add_location_to_breakpoint (struct breakpoint *,
132 const struct symtab_and_line *);
134 /* This function is used in gdbtk sources and thus can not be made
136 struct breakpoint *set_raw_breakpoint (struct gdbarch *gdbarch,
137 struct symtab_and_line,
139 const struct breakpoint_ops *);
141 static struct breakpoint *
142 momentary_breakpoint_from_master (struct breakpoint *orig,
144 const struct breakpoint_ops *ops,
147 static void breakpoint_adjustment_warning (CORE_ADDR, CORE_ADDR, int, int);
149 static CORE_ADDR adjust_breakpoint_address (struct gdbarch *gdbarch,
153 static void describe_other_breakpoints (struct gdbarch *,
154 struct program_space *, CORE_ADDR,
155 struct obj_section *, int);
157 static int watchpoint_locations_match (struct bp_location *loc1,
158 struct bp_location *loc2);
160 static int breakpoint_location_address_match (struct bp_location *bl,
161 const struct address_space *aspace,
164 static int breakpoint_location_address_range_overlap (struct bp_location *,
165 const address_space *,
168 static void info_breakpoints_command (char *, int);
170 static void info_watchpoints_command (char *, int);
172 static void commands_command (char *, int);
174 static void condition_command (char *, int);
176 static int remove_breakpoint (struct bp_location *);
177 static int remove_breakpoint_1 (struct bp_location *, enum remove_bp_reason);
179 static enum print_stop_action print_bp_stop_message (bpstat bs);
181 static int hw_breakpoint_used_count (void);
183 static int hw_watchpoint_use_count (struct breakpoint *);
185 static int hw_watchpoint_used_count_others (struct breakpoint *except,
187 int *other_type_used);
189 static void hbreak_command (char *, int);
191 static void thbreak_command (char *, int);
193 static void enable_breakpoint_disp (struct breakpoint *, enum bpdisp,
196 static void stop_command (char *arg, int from_tty);
198 static void free_bp_location (struct bp_location *loc);
199 static void incref_bp_location (struct bp_location *loc);
200 static void decref_bp_location (struct bp_location **loc);
202 static struct bp_location *allocate_bp_location (struct breakpoint *bpt);
204 /* update_global_location_list's modes of operation wrt to whether to
205 insert locations now. */
206 enum ugll_insert_mode
208 /* Don't insert any breakpoint locations into the inferior, only
209 remove already-inserted locations that no longer should be
210 inserted. Functions that delete a breakpoint or breakpoints
211 should specify this mode, so that deleting a breakpoint doesn't
212 have the side effect of inserting the locations of other
213 breakpoints that are marked not-inserted, but should_be_inserted
214 returns true on them.
216 This behavior is useful is situations close to tear-down -- e.g.,
217 after an exec, while the target still has execution, but
218 breakpoint shadows of the previous executable image should *NOT*
219 be restored to the new image; or before detaching, where the
220 target still has execution and wants to delete breakpoints from
221 GDB's lists, and all breakpoints had already been removed from
225 /* May insert breakpoints iff breakpoints_should_be_inserted_now
226 claims breakpoints should be inserted now. */
229 /* Insert locations now, irrespective of
230 breakpoints_should_be_inserted_now. E.g., say all threads are
231 stopped right now, and the user did "continue". We need to
232 insert breakpoints _before_ resuming the target, but
233 UGLL_MAY_INSERT wouldn't insert them, because
234 breakpoints_should_be_inserted_now returns false at that point,
235 as no thread is running yet. */
239 static void update_global_location_list (enum ugll_insert_mode);
241 static void update_global_location_list_nothrow (enum ugll_insert_mode);
243 static int is_hardware_watchpoint (const struct breakpoint *bpt);
245 static void insert_breakpoint_locations (void);
247 static void info_tracepoints_command (char *, int);
249 static void enable_trace_command (char *, int);
251 static void disable_trace_command (char *, int);
253 static void trace_pass_command (char *, int);
255 static void set_tracepoint_count (int num);
257 static int is_masked_watchpoint (const struct breakpoint *b);
259 static struct bp_location **get_first_locp_gte_addr (CORE_ADDR address);
261 /* Return 1 if B refers to a static tracepoint set by marker ("-m"), zero
264 static int strace_marker_p (struct breakpoint *b);
266 /* The breakpoint_ops structure to be inherited by all breakpoint_ops
267 that are implemented on top of software or hardware breakpoints
268 (user breakpoints, internal and momentary breakpoints, etc.). */
269 static struct breakpoint_ops bkpt_base_breakpoint_ops;
271 /* Internal breakpoints class type. */
272 static struct breakpoint_ops internal_breakpoint_ops;
274 /* Momentary breakpoints class type. */
275 static struct breakpoint_ops momentary_breakpoint_ops;
277 /* The breakpoint_ops structure to be used in regular user created
279 struct breakpoint_ops bkpt_breakpoint_ops;
281 /* Breakpoints set on probes. */
282 static struct breakpoint_ops bkpt_probe_breakpoint_ops;
284 /* Dynamic printf class type. */
285 struct breakpoint_ops dprintf_breakpoint_ops;
287 /* The style in which to perform a dynamic printf. This is a user
288 option because different output options have different tradeoffs;
289 if GDB does the printing, there is better error handling if there
290 is a problem with any of the arguments, but using an inferior
291 function lets you have special-purpose printers and sending of
292 output to the same place as compiled-in print functions. */
294 static const char dprintf_style_gdb[] = "gdb";
295 static const char dprintf_style_call[] = "call";
296 static const char dprintf_style_agent[] = "agent";
297 static const char *const dprintf_style_enums[] = {
303 static const char *dprintf_style = dprintf_style_gdb;
305 /* The function to use for dynamic printf if the preferred style is to
306 call into the inferior. The value is simply a string that is
307 copied into the command, so it can be anything that GDB can
308 evaluate to a callable address, not necessarily a function name. */
310 static char *dprintf_function;
312 /* The channel to use for dynamic printf if the preferred style is to
313 call into the inferior; if a nonempty string, it will be passed to
314 the call as the first argument, with the format string as the
315 second. As with the dprintf function, this can be anything that
316 GDB knows how to evaluate, so in addition to common choices like
317 "stderr", this could be an app-specific expression like
318 "mystreams[curlogger]". */
320 static char *dprintf_channel;
322 /* True if dprintf commands should continue to operate even if GDB
324 static int disconnected_dprintf = 1;
326 struct command_line *
327 breakpoint_commands (struct breakpoint *b)
329 return b->commands ? b->commands.get () : NULL;
332 /* Flag indicating that a command has proceeded the inferior past the
333 current breakpoint. */
335 static int breakpoint_proceeded;
338 bpdisp_text (enum bpdisp disp)
340 /* NOTE: the following values are a part of MI protocol and
341 represent values of 'disp' field returned when inferior stops at
343 static const char * const bpdisps[] = {"del", "dstp", "dis", "keep"};
345 return bpdisps[(int) disp];
348 /* Prototypes for exported functions. */
349 /* If FALSE, gdb will not use hardware support for watchpoints, even
350 if such is available. */
351 static int can_use_hw_watchpoints;
354 show_can_use_hw_watchpoints (struct ui_file *file, int from_tty,
355 struct cmd_list_element *c,
358 fprintf_filtered (file,
359 _("Debugger's willingness to use "
360 "watchpoint hardware is %s.\n"),
364 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
365 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
366 for unrecognized breakpoint locations.
367 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
368 static enum auto_boolean pending_break_support;
370 show_pending_break_support (struct ui_file *file, int from_tty,
371 struct cmd_list_element *c,
374 fprintf_filtered (file,
375 _("Debugger's behavior regarding "
376 "pending breakpoints is %s.\n"),
380 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
381 set with "break" but falling in read-only memory.
382 If 0, gdb will warn about such breakpoints, but won't automatically
383 use hardware breakpoints. */
384 static int automatic_hardware_breakpoints;
386 show_automatic_hardware_breakpoints (struct ui_file *file, int from_tty,
387 struct cmd_list_element *c,
390 fprintf_filtered (file,
391 _("Automatic usage of hardware breakpoints is %s.\n"),
395 /* If on, GDB keeps breakpoints inserted even if the inferior is
396 stopped, and immediately inserts any new breakpoints as soon as
397 they're created. If off (default), GDB keeps breakpoints off of
398 the target as long as possible. That is, it delays inserting
399 breakpoints until the next resume, and removes them again when the
400 target fully stops. This is a bit safer in case GDB crashes while
401 processing user input. */
402 static int always_inserted_mode = 0;
405 show_always_inserted_mode (struct ui_file *file, int from_tty,
406 struct cmd_list_element *c, const char *value)
408 fprintf_filtered (file, _("Always inserted breakpoint mode is %s.\n"),
412 /* See breakpoint.h. */
415 breakpoints_should_be_inserted_now (void)
417 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
419 /* If breakpoints are global, they should be inserted even if no
420 thread under gdb's control is running, or even if there are
421 no threads under GDB's control yet. */
424 else if (target_has_execution)
426 struct thread_info *tp;
428 if (always_inserted_mode)
430 /* The user wants breakpoints inserted even if all threads
435 if (threads_are_executing ())
438 /* Don't remove breakpoints yet if, even though all threads are
439 stopped, we still have events to process. */
440 ALL_NON_EXITED_THREADS (tp)
442 && tp->suspend.waitstatus_pending_p)
448 static const char condition_evaluation_both[] = "host or target";
450 /* Modes for breakpoint condition evaluation. */
451 static const char condition_evaluation_auto[] = "auto";
452 static const char condition_evaluation_host[] = "host";
453 static const char condition_evaluation_target[] = "target";
454 static const char *const condition_evaluation_enums[] = {
455 condition_evaluation_auto,
456 condition_evaluation_host,
457 condition_evaluation_target,
461 /* Global that holds the current mode for breakpoint condition evaluation. */
462 static const char *condition_evaluation_mode_1 = condition_evaluation_auto;
464 /* Global that we use to display information to the user (gets its value from
465 condition_evaluation_mode_1. */
466 static const char *condition_evaluation_mode = condition_evaluation_auto;
468 /* Translate a condition evaluation mode MODE into either "host"
469 or "target". This is used mostly to translate from "auto" to the
470 real setting that is being used. It returns the translated
474 translate_condition_evaluation_mode (const char *mode)
476 if (mode == condition_evaluation_auto)
478 if (target_supports_evaluation_of_breakpoint_conditions ())
479 return condition_evaluation_target;
481 return condition_evaluation_host;
487 /* Discovers what condition_evaluation_auto translates to. */
490 breakpoint_condition_evaluation_mode (void)
492 return translate_condition_evaluation_mode (condition_evaluation_mode);
495 /* Return true if GDB should evaluate breakpoint conditions or false
499 gdb_evaluates_breakpoint_condition_p (void)
501 const char *mode = breakpoint_condition_evaluation_mode ();
503 return (mode == condition_evaluation_host);
506 /* Are we executing breakpoint commands? */
507 static int executing_breakpoint_commands;
509 /* Are overlay event breakpoints enabled? */
510 static int overlay_events_enabled;
512 /* See description in breakpoint.h. */
513 int target_exact_watchpoints = 0;
515 /* Walk the following statement or block through all breakpoints.
516 ALL_BREAKPOINTS_SAFE does so even if the statement deletes the
517 current breakpoint. */
519 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
521 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
522 for (B = breakpoint_chain; \
523 B ? (TMP=B->next, 1): 0; \
526 /* Similar iterator for the low-level breakpoints. SAFE variant is
527 not provided so update_global_location_list must not be called
528 while executing the block of ALL_BP_LOCATIONS. */
530 #define ALL_BP_LOCATIONS(B,BP_TMP) \
531 for (BP_TMP = bp_locations; \
532 BP_TMP < bp_locations + bp_locations_count && (B = *BP_TMP);\
535 /* Iterates through locations with address ADDRESS for the currently selected
536 program space. BP_LOCP_TMP points to each object. BP_LOCP_START points
537 to where the loop should start from.
538 If BP_LOCP_START is a NULL pointer, the macro automatically seeks the
539 appropriate location to start with. */
541 #define ALL_BP_LOCATIONS_AT_ADDR(BP_LOCP_TMP, BP_LOCP_START, ADDRESS) \
542 for (BP_LOCP_START = BP_LOCP_START == NULL ? get_first_locp_gte_addr (ADDRESS) : BP_LOCP_START, \
543 BP_LOCP_TMP = BP_LOCP_START; \
545 && (BP_LOCP_TMP < bp_locations + bp_locations_count \
546 && (*BP_LOCP_TMP)->address == ADDRESS); \
549 /* Iterator for tracepoints only. */
551 #define ALL_TRACEPOINTS(B) \
552 for (B = breakpoint_chain; B; B = B->next) \
553 if (is_tracepoint (B))
555 /* Chains of all breakpoints defined. */
557 struct breakpoint *breakpoint_chain;
559 /* Array is sorted by bp_locations_compare - primarily by the ADDRESS. */
561 static struct bp_location **bp_locations;
563 /* Number of elements of BP_LOCATIONS. */
565 static unsigned bp_locations_count;
567 /* Maximum alignment offset between bp_target_info.PLACED_ADDRESS and
568 ADDRESS for the current elements of BP_LOCATIONS which get a valid
569 result from bp_location_has_shadow. You can use it for roughly
570 limiting the subrange of BP_LOCATIONS to scan for shadow bytes for
571 an address you need to read. */
573 static CORE_ADDR bp_locations_placed_address_before_address_max;
575 /* Maximum offset plus alignment between bp_target_info.PLACED_ADDRESS
576 + bp_target_info.SHADOW_LEN and ADDRESS for the current elements of
577 BP_LOCATIONS which get a valid result from bp_location_has_shadow.
578 You can use it for roughly limiting the subrange of BP_LOCATIONS to
579 scan for shadow bytes for an address you need to read. */
581 static CORE_ADDR bp_locations_shadow_len_after_address_max;
583 /* The locations that no longer correspond to any breakpoint, unlinked
584 from the bp_locations array, but for which a hit may still be
585 reported by a target. */
586 VEC(bp_location_p) *moribund_locations = NULL;
588 /* Number of last breakpoint made. */
590 static int breakpoint_count;
592 /* The value of `breakpoint_count' before the last command that
593 created breakpoints. If the last (break-like) command created more
594 than one breakpoint, then the difference between BREAKPOINT_COUNT
595 and PREV_BREAKPOINT_COUNT is more than one. */
596 static int prev_breakpoint_count;
598 /* Number of last tracepoint made. */
600 static int tracepoint_count;
602 static struct cmd_list_element *breakpoint_set_cmdlist;
603 static struct cmd_list_element *breakpoint_show_cmdlist;
604 struct cmd_list_element *save_cmdlist;
606 /* See declaration at breakpoint.h. */
609 breakpoint_find_if (int (*func) (struct breakpoint *b, void *d),
612 struct breakpoint *b = NULL;
616 if (func (b, user_data) != 0)
623 /* Return whether a breakpoint is an active enabled breakpoint. */
625 breakpoint_enabled (struct breakpoint *b)
627 return (b->enable_state == bp_enabled);
630 /* Set breakpoint count to NUM. */
633 set_breakpoint_count (int num)
635 prev_breakpoint_count = breakpoint_count;
636 breakpoint_count = num;
637 set_internalvar_integer (lookup_internalvar ("bpnum"), num);
640 /* Used by `start_rbreak_breakpoints' below, to record the current
641 breakpoint count before "rbreak" creates any breakpoint. */
642 static int rbreak_start_breakpoint_count;
644 /* Called at the start an "rbreak" command to record the first
648 start_rbreak_breakpoints (void)
650 rbreak_start_breakpoint_count = breakpoint_count;
653 /* Called at the end of an "rbreak" command to record the last
657 end_rbreak_breakpoints (void)
659 prev_breakpoint_count = rbreak_start_breakpoint_count;
662 /* Used in run_command to zero the hit count when a new run starts. */
665 clear_breakpoint_hit_counts (void)
667 struct breakpoint *b;
674 /* Return the breakpoint with the specified number, or NULL
675 if the number does not refer to an existing breakpoint. */
678 get_breakpoint (int num)
680 struct breakpoint *b;
683 if (b->number == num)
691 /* Mark locations as "conditions have changed" in case the target supports
692 evaluating conditions on its side. */
695 mark_breakpoint_modified (struct breakpoint *b)
697 struct bp_location *loc;
699 /* This is only meaningful if the target is
700 evaluating conditions and if the user has
701 opted for condition evaluation on the target's
703 if (gdb_evaluates_breakpoint_condition_p ()
704 || !target_supports_evaluation_of_breakpoint_conditions ())
707 if (!is_breakpoint (b))
710 for (loc = b->loc; loc; loc = loc->next)
711 loc->condition_changed = condition_modified;
714 /* Mark location as "conditions have changed" in case the target supports
715 evaluating conditions on its side. */
718 mark_breakpoint_location_modified (struct bp_location *loc)
720 /* This is only meaningful if the target is
721 evaluating conditions and if the user has
722 opted for condition evaluation on the target's
724 if (gdb_evaluates_breakpoint_condition_p ()
725 || !target_supports_evaluation_of_breakpoint_conditions ())
729 if (!is_breakpoint (loc->owner))
732 loc->condition_changed = condition_modified;
735 /* Sets the condition-evaluation mode using the static global
736 condition_evaluation_mode. */
739 set_condition_evaluation_mode (char *args, int from_tty,
740 struct cmd_list_element *c)
742 const char *old_mode, *new_mode;
744 if ((condition_evaluation_mode_1 == condition_evaluation_target)
745 && !target_supports_evaluation_of_breakpoint_conditions ())
747 condition_evaluation_mode_1 = condition_evaluation_mode;
748 warning (_("Target does not support breakpoint condition evaluation.\n"
749 "Using host evaluation mode instead."));
753 new_mode = translate_condition_evaluation_mode (condition_evaluation_mode_1);
754 old_mode = translate_condition_evaluation_mode (condition_evaluation_mode);
756 /* Flip the switch. Flip it even if OLD_MODE == NEW_MODE as one of the
757 settings was "auto". */
758 condition_evaluation_mode = condition_evaluation_mode_1;
760 /* Only update the mode if the user picked a different one. */
761 if (new_mode != old_mode)
763 struct bp_location *loc, **loc_tmp;
764 /* If the user switched to a different evaluation mode, we
765 need to synch the changes with the target as follows:
767 "host" -> "target": Send all (valid) conditions to the target.
768 "target" -> "host": Remove all the conditions from the target.
771 if (new_mode == condition_evaluation_target)
773 /* Mark everything modified and synch conditions with the
775 ALL_BP_LOCATIONS (loc, loc_tmp)
776 mark_breakpoint_location_modified (loc);
780 /* Manually mark non-duplicate locations to synch conditions
781 with the target. We do this to remove all the conditions the
782 target knows about. */
783 ALL_BP_LOCATIONS (loc, loc_tmp)
784 if (is_breakpoint (loc->owner) && loc->inserted)
785 loc->needs_update = 1;
789 update_global_location_list (UGLL_MAY_INSERT);
795 /* Shows the current mode of breakpoint condition evaluation. Explicitly shows
796 what "auto" is translating to. */
799 show_condition_evaluation_mode (struct ui_file *file, int from_tty,
800 struct cmd_list_element *c, const char *value)
802 if (condition_evaluation_mode == condition_evaluation_auto)
803 fprintf_filtered (file,
804 _("Breakpoint condition evaluation "
805 "mode is %s (currently %s).\n"),
807 breakpoint_condition_evaluation_mode ());
809 fprintf_filtered (file, _("Breakpoint condition evaluation mode is %s.\n"),
813 /* A comparison function for bp_location AP and BP that is used by
814 bsearch. This comparison function only cares about addresses, unlike
815 the more general bp_locations_compare function. */
818 bp_locations_compare_addrs (const void *ap, const void *bp)
820 const struct bp_location *a = *(const struct bp_location **) ap;
821 const struct bp_location *b = *(const struct bp_location **) bp;
823 if (a->address == b->address)
826 return ((a->address > b->address) - (a->address < b->address));
829 /* Helper function to skip all bp_locations with addresses
830 less than ADDRESS. It returns the first bp_location that
831 is greater than or equal to ADDRESS. If none is found, just
834 static struct bp_location **
835 get_first_locp_gte_addr (CORE_ADDR address)
837 struct bp_location dummy_loc;
838 struct bp_location *dummy_locp = &dummy_loc;
839 struct bp_location **locp_found = NULL;
841 /* Initialize the dummy location's address field. */
842 dummy_loc.address = address;
844 /* Find a close match to the first location at ADDRESS. */
845 locp_found = ((struct bp_location **)
846 bsearch (&dummy_locp, bp_locations, bp_locations_count,
847 sizeof (struct bp_location **),
848 bp_locations_compare_addrs));
850 /* Nothing was found, nothing left to do. */
851 if (locp_found == NULL)
854 /* We may have found a location that is at ADDRESS but is not the first in the
855 location's list. Go backwards (if possible) and locate the first one. */
856 while ((locp_found - 1) >= bp_locations
857 && (*(locp_found - 1))->address == address)
864 set_breakpoint_condition (struct breakpoint *b, const char *exp,
867 xfree (b->cond_string);
868 b->cond_string = NULL;
870 if (is_watchpoint (b))
872 struct watchpoint *w = (struct watchpoint *) b;
874 w->cond_exp.reset ();
878 struct bp_location *loc;
880 for (loc = b->loc; loc; loc = loc->next)
884 /* No need to free the condition agent expression
885 bytecode (if we have one). We will handle this
886 when we go through update_global_location_list. */
893 printf_filtered (_("Breakpoint %d now unconditional.\n"), b->number);
897 const char *arg = exp;
899 /* I don't know if it matters whether this is the string the user
900 typed in or the decompiled expression. */
901 b->cond_string = xstrdup (arg);
902 b->condition_not_parsed = 0;
904 if (is_watchpoint (b))
906 struct watchpoint *w = (struct watchpoint *) b;
908 innermost_block = NULL;
910 w->cond_exp = parse_exp_1 (&arg, 0, 0, 0);
912 error (_("Junk at end of expression"));
913 w->cond_exp_valid_block = innermost_block;
917 struct bp_location *loc;
919 for (loc = b->loc; loc; loc = loc->next)
923 parse_exp_1 (&arg, loc->address,
924 block_for_pc (loc->address), 0);
926 error (_("Junk at end of expression"));
930 mark_breakpoint_modified (b);
932 observer_notify_breakpoint_modified (b);
935 /* Completion for the "condition" command. */
938 condition_completer (struct cmd_list_element *cmd,
939 completion_tracker &tracker,
940 const char *text, const char *word)
944 text = skip_spaces (text);
945 space = skip_to_space (text);
949 struct breakpoint *b;
950 VEC (char_ptr) *result = NULL;
954 /* We don't support completion of history indices. */
955 if (!isdigit (text[1]))
956 complete_internalvar (tracker, &text[1]);
960 /* We're completing the breakpoint number. */
967 xsnprintf (number, sizeof (number), "%d", b->number);
969 if (strncmp (number, text, len) == 0)
971 gdb::unique_xmalloc_ptr<char> copy (xstrdup (number));
972 tracker.add_completion (std::move (copy));
979 /* We're completing the expression part. */
980 text = skip_spaces (space);
981 expression_completer (cmd, tracker, text, word);
984 /* condition N EXP -- set break condition of breakpoint N to EXP. */
987 condition_command (char *arg, int from_tty)
989 struct breakpoint *b;
994 error_no_arg (_("breakpoint number"));
997 bnum = get_number (&p);
999 error (_("Bad breakpoint argument: '%s'"), arg);
1002 if (b->number == bnum)
1004 /* Check if this breakpoint has a "stop" method implemented in an
1005 extension language. This method and conditions entered into GDB
1006 from the CLI are mutually exclusive. */
1007 const struct extension_language_defn *extlang
1008 = get_breakpoint_cond_ext_lang (b, EXT_LANG_NONE);
1010 if (extlang != NULL)
1012 error (_("Only one stop condition allowed. There is currently"
1013 " a %s stop condition defined for this breakpoint."),
1014 ext_lang_capitalized_name (extlang));
1016 set_breakpoint_condition (b, p, from_tty);
1018 if (is_breakpoint (b))
1019 update_global_location_list (UGLL_MAY_INSERT);
1024 error (_("No breakpoint number %d."), bnum);
1027 /* Check that COMMAND do not contain commands that are suitable
1028 only for tracepoints and not suitable for ordinary breakpoints.
1029 Throw if any such commands is found. */
1032 check_no_tracepoint_commands (struct command_line *commands)
1034 struct command_line *c;
1036 for (c = commands; c; c = c->next)
1040 if (c->control_type == while_stepping_control)
1041 error (_("The 'while-stepping' command can "
1042 "only be used for tracepoints"));
1044 for (i = 0; i < c->body_count; ++i)
1045 check_no_tracepoint_commands ((c->body_list)[i]);
1047 /* Not that command parsing removes leading whitespace and comment
1048 lines and also empty lines. So, we only need to check for
1049 command directly. */
1050 if (strstr (c->line, "collect ") == c->line)
1051 error (_("The 'collect' command can only be used for tracepoints"));
1053 if (strstr (c->line, "teval ") == c->line)
1054 error (_("The 'teval' command can only be used for tracepoints"));
1058 struct longjmp_breakpoint : public breakpoint
1060 ~longjmp_breakpoint () override;
1063 /* Encapsulate tests for different types of tracepoints. */
1066 is_tracepoint_type (bptype type)
1068 return (type == bp_tracepoint
1069 || type == bp_fast_tracepoint
1070 || type == bp_static_tracepoint);
1074 is_longjmp_type (bptype type)
1076 return type == bp_longjmp || type == bp_exception;
1080 is_tracepoint (const struct breakpoint *b)
1082 return is_tracepoint_type (b->type);
1085 /* Factory function to create an appropriate instance of breakpoint given
1088 static std::unique_ptr<breakpoint>
1089 new_breakpoint_from_type (bptype type)
1093 if (is_tracepoint_type (type))
1094 b = new tracepoint ();
1095 else if (is_longjmp_type (type))
1096 b = new longjmp_breakpoint ();
1098 b = new breakpoint ();
1100 return std::unique_ptr<breakpoint> (b);
1103 /* A helper function that validates that COMMANDS are valid for a
1104 breakpoint. This function will throw an exception if a problem is
1108 validate_commands_for_breakpoint (struct breakpoint *b,
1109 struct command_line *commands)
1111 if (is_tracepoint (b))
1113 struct tracepoint *t = (struct tracepoint *) b;
1114 struct command_line *c;
1115 struct command_line *while_stepping = 0;
1117 /* Reset the while-stepping step count. The previous commands
1118 might have included a while-stepping action, while the new
1122 /* We need to verify that each top-level element of commands is
1123 valid for tracepoints, that there's at most one
1124 while-stepping element, and that the while-stepping's body
1125 has valid tracing commands excluding nested while-stepping.
1126 We also need to validate the tracepoint action line in the
1127 context of the tracepoint --- validate_actionline actually
1128 has side effects, like setting the tracepoint's
1129 while-stepping STEP_COUNT, in addition to checking if the
1130 collect/teval actions parse and make sense in the
1131 tracepoint's context. */
1132 for (c = commands; c; c = c->next)
1134 if (c->control_type == while_stepping_control)
1136 if (b->type == bp_fast_tracepoint)
1137 error (_("The 'while-stepping' command "
1138 "cannot be used for fast tracepoint"));
1139 else if (b->type == bp_static_tracepoint)
1140 error (_("The 'while-stepping' command "
1141 "cannot be used for static tracepoint"));
1144 error (_("The 'while-stepping' command "
1145 "can be used only once"));
1150 validate_actionline (c->line, b);
1154 struct command_line *c2;
1156 gdb_assert (while_stepping->body_count == 1);
1157 c2 = while_stepping->body_list[0];
1158 for (; c2; c2 = c2->next)
1160 if (c2->control_type == while_stepping_control)
1161 error (_("The 'while-stepping' command cannot be nested"));
1167 check_no_tracepoint_commands (commands);
1171 /* Return a vector of all the static tracepoints set at ADDR. The
1172 caller is responsible for releasing the vector. */
1175 static_tracepoints_here (CORE_ADDR addr)
1177 struct breakpoint *b;
1178 VEC(breakpoint_p) *found = 0;
1179 struct bp_location *loc;
1182 if (b->type == bp_static_tracepoint)
1184 for (loc = b->loc; loc; loc = loc->next)
1185 if (loc->address == addr)
1186 VEC_safe_push(breakpoint_p, found, b);
1192 /* Set the command list of B to COMMANDS. If breakpoint is tracepoint,
1193 validate that only allowed commands are included. */
1196 breakpoint_set_commands (struct breakpoint *b,
1197 command_line_up &&commands)
1199 validate_commands_for_breakpoint (b, commands.get ());
1201 b->commands = std::move (commands);
1202 observer_notify_breakpoint_modified (b);
1205 /* Set the internal `silent' flag on the breakpoint. Note that this
1206 is not the same as the "silent" that may appear in the breakpoint's
1210 breakpoint_set_silent (struct breakpoint *b, int silent)
1212 int old_silent = b->silent;
1215 if (old_silent != silent)
1216 observer_notify_breakpoint_modified (b);
1219 /* Set the thread for this breakpoint. If THREAD is -1, make the
1220 breakpoint work for any thread. */
1223 breakpoint_set_thread (struct breakpoint *b, int thread)
1225 int old_thread = b->thread;
1228 if (old_thread != thread)
1229 observer_notify_breakpoint_modified (b);
1232 /* Set the task for this breakpoint. If TASK is 0, make the
1233 breakpoint work for any task. */
1236 breakpoint_set_task (struct breakpoint *b, int task)
1238 int old_task = b->task;
1241 if (old_task != task)
1242 observer_notify_breakpoint_modified (b);
1246 check_tracepoint_command (char *line, void *closure)
1248 struct breakpoint *b = (struct breakpoint *) closure;
1250 validate_actionline (line, b);
1254 commands_command_1 (const char *arg, int from_tty,
1255 struct command_line *control)
1257 counted_command_line cmd;
1259 std::string new_arg;
1261 if (arg == NULL || !*arg)
1263 if (breakpoint_count - prev_breakpoint_count > 1)
1264 new_arg = string_printf ("%d-%d", prev_breakpoint_count + 1,
1266 else if (breakpoint_count > 0)
1267 new_arg = string_printf ("%d", breakpoint_count);
1268 arg = new_arg.c_str ();
1271 map_breakpoint_numbers
1272 (arg, [&] (breakpoint *b)
1276 if (control != NULL)
1277 cmd = copy_command_lines (control->body_list[0]);
1281 = string_printf (_("Type commands for breakpoint(s) "
1282 "%s, one per line."),
1285 cmd = read_command_lines (&str[0],
1288 ? check_tracepoint_command : 0),
1293 /* If a breakpoint was on the list more than once, we don't need to
1295 if (b->commands != cmd)
1297 validate_commands_for_breakpoint (b, cmd.get ());
1299 observer_notify_breakpoint_modified (b);
1304 error (_("No breakpoints specified."));
1308 commands_command (char *arg, int from_tty)
1310 commands_command_1 (arg, from_tty, NULL);
1313 /* Like commands_command, but instead of reading the commands from
1314 input stream, takes them from an already parsed command structure.
1316 This is used by cli-script.c to DTRT with breakpoint commands
1317 that are part of if and while bodies. */
1318 enum command_control_type
1319 commands_from_control_command (const char *arg, struct command_line *cmd)
1321 commands_command_1 (arg, 0, cmd);
1322 return simple_control;
1325 /* Return non-zero if BL->TARGET_INFO contains valid information. */
1328 bp_location_has_shadow (struct bp_location *bl)
1330 if (bl->loc_type != bp_loc_software_breakpoint)
1334 if (bl->target_info.shadow_len == 0)
1335 /* BL isn't valid, or doesn't shadow memory. */
1340 /* Update BUF, which is LEN bytes read from the target address
1341 MEMADDR, by replacing a memory breakpoint with its shadowed
1344 If READBUF is not NULL, this buffer must not overlap with the of
1345 the breakpoint location's shadow_contents buffer. Otherwise, a
1346 failed assertion internal error will be raised. */
1349 one_breakpoint_xfer_memory (gdb_byte *readbuf, gdb_byte *writebuf,
1350 const gdb_byte *writebuf_org,
1351 ULONGEST memaddr, LONGEST len,
1352 struct bp_target_info *target_info,
1353 struct gdbarch *gdbarch)
1355 /* Now do full processing of the found relevant range of elements. */
1356 CORE_ADDR bp_addr = 0;
1360 if (!breakpoint_address_match (target_info->placed_address_space, 0,
1361 current_program_space->aspace, 0))
1363 /* The breakpoint is inserted in a different address space. */
1367 /* Addresses and length of the part of the breakpoint that
1369 bp_addr = target_info->placed_address;
1370 bp_size = target_info->shadow_len;
1372 if (bp_addr + bp_size <= memaddr)
1374 /* The breakpoint is entirely before the chunk of memory we are
1379 if (bp_addr >= memaddr + len)
1381 /* The breakpoint is entirely after the chunk of memory we are
1386 /* Offset within shadow_contents. */
1387 if (bp_addr < memaddr)
1389 /* Only copy the second part of the breakpoint. */
1390 bp_size -= memaddr - bp_addr;
1391 bptoffset = memaddr - bp_addr;
1395 if (bp_addr + bp_size > memaddr + len)
1397 /* Only copy the first part of the breakpoint. */
1398 bp_size -= (bp_addr + bp_size) - (memaddr + len);
1401 if (readbuf != NULL)
1403 /* Verify that the readbuf buffer does not overlap with the
1404 shadow_contents buffer. */
1405 gdb_assert (target_info->shadow_contents >= readbuf + len
1406 || readbuf >= (target_info->shadow_contents
1407 + target_info->shadow_len));
1409 /* Update the read buffer with this inserted breakpoint's
1411 memcpy (readbuf + bp_addr - memaddr,
1412 target_info->shadow_contents + bptoffset, bp_size);
1416 const unsigned char *bp;
1417 CORE_ADDR addr = target_info->reqstd_address;
1420 /* Update the shadow with what we want to write to memory. */
1421 memcpy (target_info->shadow_contents + bptoffset,
1422 writebuf_org + bp_addr - memaddr, bp_size);
1424 /* Determine appropriate breakpoint contents and size for this
1426 bp = gdbarch_breakpoint_from_pc (gdbarch, &addr, &placed_size);
1428 /* Update the final write buffer with this inserted
1429 breakpoint's INSN. */
1430 memcpy (writebuf + bp_addr - memaddr, bp + bptoffset, bp_size);
1434 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
1435 by replacing any memory breakpoints with their shadowed contents.
1437 If READBUF is not NULL, this buffer must not overlap with any of
1438 the breakpoint location's shadow_contents buffers. Otherwise,
1439 a failed assertion internal error will be raised.
1441 The range of shadowed area by each bp_location is:
1442 bl->address - bp_locations_placed_address_before_address_max
1443 up to bl->address + bp_locations_shadow_len_after_address_max
1444 The range we were requested to resolve shadows for is:
1445 memaddr ... memaddr + len
1446 Thus the safe cutoff boundaries for performance optimization are
1447 memaddr + len <= (bl->address
1448 - bp_locations_placed_address_before_address_max)
1450 bl->address + bp_locations_shadow_len_after_address_max <= memaddr */
1453 breakpoint_xfer_memory (gdb_byte *readbuf, gdb_byte *writebuf,
1454 const gdb_byte *writebuf_org,
1455 ULONGEST memaddr, LONGEST len)
1457 /* Left boundary, right boundary and median element of our binary
1459 unsigned bc_l, bc_r, bc;
1461 /* Find BC_L which is a leftmost element which may affect BUF
1462 content. It is safe to report lower value but a failure to
1463 report higher one. */
1466 bc_r = bp_locations_count;
1467 while (bc_l + 1 < bc_r)
1469 struct bp_location *bl;
1471 bc = (bc_l + bc_r) / 2;
1472 bl = bp_locations[bc];
1474 /* Check first BL->ADDRESS will not overflow due to the added
1475 constant. Then advance the left boundary only if we are sure
1476 the BC element can in no way affect the BUF content (MEMADDR
1477 to MEMADDR + LEN range).
1479 Use the BP_LOCATIONS_SHADOW_LEN_AFTER_ADDRESS_MAX safety
1480 offset so that we cannot miss a breakpoint with its shadow
1481 range tail still reaching MEMADDR. */
1483 if ((bl->address + bp_locations_shadow_len_after_address_max
1485 && (bl->address + bp_locations_shadow_len_after_address_max
1492 /* Due to the binary search above, we need to make sure we pick the
1493 first location that's at BC_L's address. E.g., if there are
1494 multiple locations at the same address, BC_L may end up pointing
1495 at a duplicate location, and miss the "master"/"inserted"
1496 location. Say, given locations L1, L2 and L3 at addresses A and
1499 L1@A, L2@A, L3@B, ...
1501 BC_L could end up pointing at location L2, while the "master"
1502 location could be L1. Since the `loc->inserted' flag is only set
1503 on "master" locations, we'd forget to restore the shadow of L1
1506 && bp_locations[bc_l]->address == bp_locations[bc_l - 1]->address)
1509 /* Now do full processing of the found relevant range of elements. */
1511 for (bc = bc_l; bc < bp_locations_count; bc++)
1513 struct bp_location *bl = bp_locations[bc];
1515 /* bp_location array has BL->OWNER always non-NULL. */
1516 if (bl->owner->type == bp_none)
1517 warning (_("reading through apparently deleted breakpoint #%d?"),
1520 /* Performance optimization: any further element can no longer affect BUF
1523 if (bl->address >= bp_locations_placed_address_before_address_max
1524 && memaddr + len <= (bl->address
1525 - bp_locations_placed_address_before_address_max))
1528 if (!bp_location_has_shadow (bl))
1531 one_breakpoint_xfer_memory (readbuf, writebuf, writebuf_org,
1532 memaddr, len, &bl->target_info, bl->gdbarch);
1538 /* Return true if BPT is either a software breakpoint or a hardware
1542 is_breakpoint (const struct breakpoint *bpt)
1544 return (bpt->type == bp_breakpoint
1545 || bpt->type == bp_hardware_breakpoint
1546 || bpt->type == bp_dprintf);
1549 /* Return true if BPT is of any hardware watchpoint kind. */
1552 is_hardware_watchpoint (const struct breakpoint *bpt)
1554 return (bpt->type == bp_hardware_watchpoint
1555 || bpt->type == bp_read_watchpoint
1556 || bpt->type == bp_access_watchpoint);
1559 /* Return true if BPT is of any watchpoint kind, hardware or
1563 is_watchpoint (const struct breakpoint *bpt)
1565 return (is_hardware_watchpoint (bpt)
1566 || bpt->type == bp_watchpoint);
1569 /* Returns true if the current thread and its running state are safe
1570 to evaluate or update watchpoint B. Watchpoints on local
1571 expressions need to be evaluated in the context of the thread that
1572 was current when the watchpoint was created, and, that thread needs
1573 to be stopped to be able to select the correct frame context.
1574 Watchpoints on global expressions can be evaluated on any thread,
1575 and in any state. It is presently left to the target allowing
1576 memory accesses when threads are running. */
1579 watchpoint_in_thread_scope (struct watchpoint *b)
1581 return (b->pspace == current_program_space
1582 && (ptid_equal (b->watchpoint_thread, null_ptid)
1583 || (ptid_equal (inferior_ptid, b->watchpoint_thread)
1584 && !is_executing (inferior_ptid))));
1587 /* Set watchpoint B to disp_del_at_next_stop, even including its possible
1588 associated bp_watchpoint_scope breakpoint. */
1591 watchpoint_del_at_next_stop (struct watchpoint *w)
1593 if (w->related_breakpoint != w)
1595 gdb_assert (w->related_breakpoint->type == bp_watchpoint_scope);
1596 gdb_assert (w->related_breakpoint->related_breakpoint == w);
1597 w->related_breakpoint->disposition = disp_del_at_next_stop;
1598 w->related_breakpoint->related_breakpoint = w->related_breakpoint;
1599 w->related_breakpoint = w;
1601 w->disposition = disp_del_at_next_stop;
1604 /* Extract a bitfield value from value VAL using the bit parameters contained in
1607 static struct value *
1608 extract_bitfield_from_watchpoint_value (struct watchpoint *w, struct value *val)
1610 struct value *bit_val;
1615 bit_val = allocate_value (value_type (val));
1617 unpack_value_bitfield (bit_val,
1620 value_contents_for_printing (val),
1627 /* Allocate a dummy location and add it to B, which must be a software
1628 watchpoint. This is required because even if a software watchpoint
1629 is not watching any memory, bpstat_stop_status requires a location
1630 to be able to report stops. */
1633 software_watchpoint_add_no_memory_location (struct breakpoint *b,
1634 struct program_space *pspace)
1636 gdb_assert (b->type == bp_watchpoint && b->loc == NULL);
1638 b->loc = allocate_bp_location (b);
1639 b->loc->pspace = pspace;
1640 b->loc->address = -1;
1641 b->loc->length = -1;
1644 /* Returns true if B is a software watchpoint that is not watching any
1645 memory (e.g., "watch $pc"). */
1648 is_no_memory_software_watchpoint (struct breakpoint *b)
1650 return (b->type == bp_watchpoint
1652 && b->loc->next == NULL
1653 && b->loc->address == -1
1654 && b->loc->length == -1);
1657 /* Assuming that B is a watchpoint:
1658 - Reparse watchpoint expression, if REPARSE is non-zero
1659 - Evaluate expression and store the result in B->val
1660 - Evaluate the condition if there is one, and store the result
1662 - Update the list of values that must be watched in B->loc.
1664 If the watchpoint disposition is disp_del_at_next_stop, then do
1665 nothing. If this is local watchpoint that is out of scope, delete
1668 Even with `set breakpoint always-inserted on' the watchpoints are
1669 removed + inserted on each stop here. Normal breakpoints must
1670 never be removed because they might be missed by a running thread
1671 when debugging in non-stop mode. On the other hand, hardware
1672 watchpoints (is_hardware_watchpoint; processed here) are specific
1673 to each LWP since they are stored in each LWP's hardware debug
1674 registers. Therefore, such LWP must be stopped first in order to
1675 be able to modify its hardware watchpoints.
1677 Hardware watchpoints must be reset exactly once after being
1678 presented to the user. It cannot be done sooner, because it would
1679 reset the data used to present the watchpoint hit to the user. And
1680 it must not be done later because it could display the same single
1681 watchpoint hit during multiple GDB stops. Note that the latter is
1682 relevant only to the hardware watchpoint types bp_read_watchpoint
1683 and bp_access_watchpoint. False hit by bp_hardware_watchpoint is
1684 not user-visible - its hit is suppressed if the memory content has
1687 The following constraints influence the location where we can reset
1688 hardware watchpoints:
1690 * target_stopped_by_watchpoint and target_stopped_data_address are
1691 called several times when GDB stops.
1694 * Multiple hardware watchpoints can be hit at the same time,
1695 causing GDB to stop. GDB only presents one hardware watchpoint
1696 hit at a time as the reason for stopping, and all the other hits
1697 are presented later, one after the other, each time the user
1698 requests the execution to be resumed. Execution is not resumed
1699 for the threads still having pending hit event stored in
1700 LWP_INFO->STATUS. While the watchpoint is already removed from
1701 the inferior on the first stop the thread hit event is kept being
1702 reported from its cached value by linux_nat_stopped_data_address
1703 until the real thread resume happens after the watchpoint gets
1704 presented and thus its LWP_INFO->STATUS gets reset.
1706 Therefore the hardware watchpoint hit can get safely reset on the
1707 watchpoint removal from inferior. */
1710 update_watchpoint (struct watchpoint *b, int reparse)
1712 int within_current_scope;
1713 struct frame_id saved_frame_id;
1716 /* If this is a local watchpoint, we only want to check if the
1717 watchpoint frame is in scope if the current thread is the thread
1718 that was used to create the watchpoint. */
1719 if (!watchpoint_in_thread_scope (b))
1722 if (b->disposition == disp_del_at_next_stop)
1727 /* Determine if the watchpoint is within scope. */
1728 if (b->exp_valid_block == NULL)
1729 within_current_scope = 1;
1732 struct frame_info *fi = get_current_frame ();
1733 struct gdbarch *frame_arch = get_frame_arch (fi);
1734 CORE_ADDR frame_pc = get_frame_pc (fi);
1736 /* If we're at a point where the stack has been destroyed
1737 (e.g. in a function epilogue), unwinding may not work
1738 properly. Do not attempt to recreate locations at this
1739 point. See similar comments in watchpoint_check. */
1740 if (gdbarch_stack_frame_destroyed_p (frame_arch, frame_pc))
1743 /* Save the current frame's ID so we can restore it after
1744 evaluating the watchpoint expression on its own frame. */
1745 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
1746 took a frame parameter, so that we didn't have to change the
1749 saved_frame_id = get_frame_id (get_selected_frame (NULL));
1751 fi = frame_find_by_id (b->watchpoint_frame);
1752 within_current_scope = (fi != NULL);
1753 if (within_current_scope)
1757 /* We don't free locations. They are stored in the bp_location array
1758 and update_global_location_list will eventually delete them and
1759 remove breakpoints if needed. */
1762 if (within_current_scope && reparse)
1767 s = b->exp_string_reparse ? b->exp_string_reparse : b->exp_string;
1768 b->exp = parse_exp_1 (&s, 0, b->exp_valid_block, 0);
1769 /* If the meaning of expression itself changed, the old value is
1770 no longer relevant. We don't want to report a watchpoint hit
1771 to the user when the old value and the new value may actually
1772 be completely different objects. */
1773 value_free (b->val);
1777 /* Note that unlike with breakpoints, the watchpoint's condition
1778 expression is stored in the breakpoint object, not in the
1779 locations (re)created below. */
1780 if (b->cond_string != NULL)
1782 b->cond_exp.reset ();
1785 b->cond_exp = parse_exp_1 (&s, 0, b->cond_exp_valid_block, 0);
1789 /* If we failed to parse the expression, for example because
1790 it refers to a global variable in a not-yet-loaded shared library,
1791 don't try to insert watchpoint. We don't automatically delete
1792 such watchpoint, though, since failure to parse expression
1793 is different from out-of-scope watchpoint. */
1794 if (!target_has_execution)
1796 /* Without execution, memory can't change. No use to try and
1797 set watchpoint locations. The watchpoint will be reset when
1798 the target gains execution, through breakpoint_re_set. */
1799 if (!can_use_hw_watchpoints)
1801 if (b->ops->works_in_software_mode (b))
1802 b->type = bp_watchpoint;
1804 error (_("Can't set read/access watchpoint when "
1805 "hardware watchpoints are disabled."));
1808 else if (within_current_scope && b->exp)
1811 struct value *val_chain, *v, *result, *next;
1812 struct program_space *frame_pspace;
1814 fetch_subexp_value (b->exp.get (), &pc, &v, &result, &val_chain, 0);
1816 /* Avoid setting b->val if it's already set. The meaning of
1817 b->val is 'the last value' user saw, and we should update
1818 it only if we reported that last value to user. As it
1819 happens, the code that reports it updates b->val directly.
1820 We don't keep track of the memory value for masked
1822 if (!b->val_valid && !is_masked_watchpoint (b))
1824 if (b->val_bitsize != 0)
1826 v = extract_bitfield_from_watchpoint_value (b, v);
1834 frame_pspace = get_frame_program_space (get_selected_frame (NULL));
1836 /* Look at each value on the value chain. */
1837 for (v = val_chain; v; v = value_next (v))
1839 /* If it's a memory location, and GDB actually needed
1840 its contents to evaluate the expression, then we
1841 must watch it. If the first value returned is
1842 still lazy, that means an error occurred reading it;
1843 watch it anyway in case it becomes readable. */
1844 if (VALUE_LVAL (v) == lval_memory
1845 && (v == val_chain || ! value_lazy (v)))
1847 struct type *vtype = check_typedef (value_type (v));
1849 /* We only watch structs and arrays if user asked
1850 for it explicitly, never if they just happen to
1851 appear in the middle of some value chain. */
1853 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
1854 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
1857 enum target_hw_bp_type type;
1858 struct bp_location *loc, **tmp;
1859 int bitpos = 0, bitsize = 0;
1861 if (value_bitsize (v) != 0)
1863 /* Extract the bit parameters out from the bitfield
1865 bitpos = value_bitpos (v);
1866 bitsize = value_bitsize (v);
1868 else if (v == result && b->val_bitsize != 0)
1870 /* If VAL_BITSIZE != 0 then RESULT is actually a bitfield
1871 lvalue whose bit parameters are saved in the fields
1872 VAL_BITPOS and VAL_BITSIZE. */
1873 bitpos = b->val_bitpos;
1874 bitsize = b->val_bitsize;
1877 addr = value_address (v);
1880 /* Skip the bytes that don't contain the bitfield. */
1885 if (b->type == bp_read_watchpoint)
1887 else if (b->type == bp_access_watchpoint)
1890 loc = allocate_bp_location (b);
1891 for (tmp = &(b->loc); *tmp != NULL; tmp = &((*tmp)->next))
1894 loc->gdbarch = get_type_arch (value_type (v));
1896 loc->pspace = frame_pspace;
1897 loc->address = addr;
1901 /* Just cover the bytes that make up the bitfield. */
1902 loc->length = ((bitpos % 8) + bitsize + 7) / 8;
1905 loc->length = TYPE_LENGTH (value_type (v));
1907 loc->watchpoint_type = type;
1912 /* Change the type of breakpoint between hardware assisted or
1913 an ordinary watchpoint depending on the hardware support
1914 and free hardware slots. REPARSE is set when the inferior
1919 enum bp_loc_type loc_type;
1920 struct bp_location *bl;
1922 reg_cnt = can_use_hardware_watchpoint (val_chain);
1926 int i, target_resources_ok, other_type_used;
1929 /* Use an exact watchpoint when there's only one memory region to be
1930 watched, and only one debug register is needed to watch it. */
1931 b->exact = target_exact_watchpoints && reg_cnt == 1;
1933 /* We need to determine how many resources are already
1934 used for all other hardware watchpoints plus this one
1935 to see if we still have enough resources to also fit
1936 this watchpoint in as well. */
1938 /* If this is a software watchpoint, we try to turn it
1939 to a hardware one -- count resources as if B was of
1940 hardware watchpoint type. */
1942 if (type == bp_watchpoint)
1943 type = bp_hardware_watchpoint;
1945 /* This watchpoint may or may not have been placed on
1946 the list yet at this point (it won't be in the list
1947 if we're trying to create it for the first time,
1948 through watch_command), so always account for it
1951 /* Count resources used by all watchpoints except B. */
1952 i = hw_watchpoint_used_count_others (b, type, &other_type_used);
1954 /* Add in the resources needed for B. */
1955 i += hw_watchpoint_use_count (b);
1958 = target_can_use_hardware_watchpoint (type, i, other_type_used);
1959 if (target_resources_ok <= 0)
1961 int sw_mode = b->ops->works_in_software_mode (b);
1963 if (target_resources_ok == 0 && !sw_mode)
1964 error (_("Target does not support this type of "
1965 "hardware watchpoint."));
1966 else if (target_resources_ok < 0 && !sw_mode)
1967 error (_("There are not enough available hardware "
1968 "resources for this watchpoint."));
1970 /* Downgrade to software watchpoint. */
1971 b->type = bp_watchpoint;
1975 /* If this was a software watchpoint, we've just
1976 found we have enough resources to turn it to a
1977 hardware watchpoint. Otherwise, this is a
1982 else if (!b->ops->works_in_software_mode (b))
1984 if (!can_use_hw_watchpoints)
1985 error (_("Can't set read/access watchpoint when "
1986 "hardware watchpoints are disabled."));
1988 error (_("Expression cannot be implemented with "
1989 "read/access watchpoint."));
1992 b->type = bp_watchpoint;
1994 loc_type = (b->type == bp_watchpoint? bp_loc_other
1995 : bp_loc_hardware_watchpoint);
1996 for (bl = b->loc; bl; bl = bl->next)
1997 bl->loc_type = loc_type;
2000 for (v = val_chain; v; v = next)
2002 next = value_next (v);
2007 /* If a software watchpoint is not watching any memory, then the
2008 above left it without any location set up. But,
2009 bpstat_stop_status requires a location to be able to report
2010 stops, so make sure there's at least a dummy one. */
2011 if (b->type == bp_watchpoint && b->loc == NULL)
2012 software_watchpoint_add_no_memory_location (b, frame_pspace);
2014 else if (!within_current_scope)
2016 printf_filtered (_("\
2017 Watchpoint %d deleted because the program has left the block\n\
2018 in which its expression is valid.\n"),
2020 watchpoint_del_at_next_stop (b);
2023 /* Restore the selected frame. */
2025 select_frame (frame_find_by_id (saved_frame_id));
2029 /* Returns 1 iff breakpoint location should be
2030 inserted in the inferior. We don't differentiate the type of BL's owner
2031 (breakpoint vs. tracepoint), although insert_location in tracepoint's
2032 breakpoint_ops is not defined, because in insert_bp_location,
2033 tracepoint's insert_location will not be called. */
2035 should_be_inserted (struct bp_location *bl)
2037 if (bl->owner == NULL || !breakpoint_enabled (bl->owner))
2040 if (bl->owner->disposition == disp_del_at_next_stop)
2043 if (!bl->enabled || bl->shlib_disabled || bl->duplicate)
2046 if (user_breakpoint_p (bl->owner) && bl->pspace->executing_startup)
2049 /* This is set for example, when we're attached to the parent of a
2050 vfork, and have detached from the child. The child is running
2051 free, and we expect it to do an exec or exit, at which point the
2052 OS makes the parent schedulable again (and the target reports
2053 that the vfork is done). Until the child is done with the shared
2054 memory region, do not insert breakpoints in the parent, otherwise
2055 the child could still trip on the parent's breakpoints. Since
2056 the parent is blocked anyway, it won't miss any breakpoint. */
2057 if (bl->pspace->breakpoints_not_allowed)
2060 /* Don't insert a breakpoint if we're trying to step past its
2061 location, except if the breakpoint is a single-step breakpoint,
2062 and the breakpoint's thread is the thread which is stepping past
2064 if ((bl->loc_type == bp_loc_software_breakpoint
2065 || bl->loc_type == bp_loc_hardware_breakpoint)
2066 && stepping_past_instruction_at (bl->pspace->aspace,
2068 /* The single-step breakpoint may be inserted at the location
2069 we're trying to step if the instruction branches to itself.
2070 However, the instruction won't be executed at all and it may
2071 break the semantics of the instruction, for example, the
2072 instruction is a conditional branch or updates some flags.
2073 We can't fix it unless GDB is able to emulate the instruction
2074 or switch to displaced stepping. */
2075 && !(bl->owner->type == bp_single_step
2076 && thread_is_stepping_over_breakpoint (bl->owner->thread)))
2080 fprintf_unfiltered (gdb_stdlog,
2081 "infrun: skipping breakpoint: "
2082 "stepping past insn at: %s\n",
2083 paddress (bl->gdbarch, bl->address));
2088 /* Don't insert watchpoints if we're trying to step past the
2089 instruction that triggered one. */
2090 if ((bl->loc_type == bp_loc_hardware_watchpoint)
2091 && stepping_past_nonsteppable_watchpoint ())
2095 fprintf_unfiltered (gdb_stdlog,
2096 "infrun: stepping past non-steppable watchpoint. "
2097 "skipping watchpoint at %s:%d\n",
2098 paddress (bl->gdbarch, bl->address),
2107 /* Same as should_be_inserted but does the check assuming
2108 that the location is not duplicated. */
2111 unduplicated_should_be_inserted (struct bp_location *bl)
2114 const int save_duplicate = bl->duplicate;
2117 result = should_be_inserted (bl);
2118 bl->duplicate = save_duplicate;
2122 /* Parses a conditional described by an expression COND into an
2123 agent expression bytecode suitable for evaluation
2124 by the bytecode interpreter. Return NULL if there was
2125 any error during parsing. */
2127 static agent_expr_up
2128 parse_cond_to_aexpr (CORE_ADDR scope, struct expression *cond)
2133 agent_expr_up aexpr;
2135 /* We don't want to stop processing, so catch any errors
2136 that may show up. */
2139 aexpr = gen_eval_for_expr (scope, cond);
2142 CATCH (ex, RETURN_MASK_ERROR)
2144 /* If we got here, it means the condition could not be parsed to a valid
2145 bytecode expression and thus can't be evaluated on the target's side.
2146 It's no use iterating through the conditions. */
2150 /* We have a valid agent expression. */
2154 /* Based on location BL, create a list of breakpoint conditions to be
2155 passed on to the target. If we have duplicated locations with different
2156 conditions, we will add such conditions to the list. The idea is that the
2157 target will evaluate the list of conditions and will only notify GDB when
2158 one of them is true. */
2161 build_target_condition_list (struct bp_location *bl)
2163 struct bp_location **locp = NULL, **loc2p;
2164 int null_condition_or_parse_error = 0;
2165 int modified = bl->needs_update;
2166 struct bp_location *loc;
2168 /* Release conditions left over from a previous insert. */
2169 bl->target_info.conditions.clear ();
2171 /* This is only meaningful if the target is
2172 evaluating conditions and if the user has
2173 opted for condition evaluation on the target's
2175 if (gdb_evaluates_breakpoint_condition_p ()
2176 || !target_supports_evaluation_of_breakpoint_conditions ())
2179 /* Do a first pass to check for locations with no assigned
2180 conditions or conditions that fail to parse to a valid agent expression
2181 bytecode. If any of these happen, then it's no use to send conditions
2182 to the target since this location will always trigger and generate a
2183 response back to GDB. */
2184 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2187 if (is_breakpoint (loc->owner) && loc->pspace->num == bl->pspace->num)
2191 /* Re-parse the conditions since something changed. In that
2192 case we already freed the condition bytecodes (see
2193 force_breakpoint_reinsertion). We just
2194 need to parse the condition to bytecodes again. */
2195 loc->cond_bytecode = parse_cond_to_aexpr (bl->address,
2199 /* If we have a NULL bytecode expression, it means something
2200 went wrong or we have a null condition expression. */
2201 if (!loc->cond_bytecode)
2203 null_condition_or_parse_error = 1;
2209 /* If any of these happened, it means we will have to evaluate the conditions
2210 for the location's address on gdb's side. It is no use keeping bytecodes
2211 for all the other duplicate locations, thus we free all of them here.
2213 This is so we have a finer control over which locations' conditions are
2214 being evaluated by GDB or the remote stub. */
2215 if (null_condition_or_parse_error)
2217 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2220 if (is_breakpoint (loc->owner) && loc->pspace->num == bl->pspace->num)
2222 /* Only go as far as the first NULL bytecode is
2224 if (!loc->cond_bytecode)
2227 loc->cond_bytecode.reset ();
2232 /* No NULL conditions or failed bytecode generation. Build a condition list
2233 for this location's address. */
2234 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2238 && is_breakpoint (loc->owner)
2239 && loc->pspace->num == bl->pspace->num
2240 && loc->owner->enable_state == bp_enabled
2243 /* Add the condition to the vector. This will be used later
2244 to send the conditions to the target. */
2245 bl->target_info.conditions.push_back (loc->cond_bytecode.get ());
2252 /* Parses a command described by string CMD into an agent expression
2253 bytecode suitable for evaluation by the bytecode interpreter.
2254 Return NULL if there was any error during parsing. */
2256 static agent_expr_up
2257 parse_cmd_to_aexpr (CORE_ADDR scope, char *cmd)
2259 struct cleanup *old_cleanups = 0;
2260 struct expression **argvec;
2261 const char *cmdrest;
2262 const char *format_start, *format_end;
2263 struct format_piece *fpieces;
2265 struct gdbarch *gdbarch = get_current_arch ();
2272 if (*cmdrest == ',')
2274 cmdrest = skip_spaces (cmdrest);
2276 if (*cmdrest++ != '"')
2277 error (_("No format string following the location"));
2279 format_start = cmdrest;
2281 fpieces = parse_format_string (&cmdrest);
2283 old_cleanups = make_cleanup (free_format_pieces_cleanup, &fpieces);
2285 format_end = cmdrest;
2287 if (*cmdrest++ != '"')
2288 error (_("Bad format string, non-terminated '\"'."));
2290 cmdrest = skip_spaces (cmdrest);
2292 if (!(*cmdrest == ',' || *cmdrest == '\0'))
2293 error (_("Invalid argument syntax"));
2295 if (*cmdrest == ',')
2297 cmdrest = skip_spaces (cmdrest);
2299 /* For each argument, make an expression. */
2301 argvec = (struct expression **) alloca (strlen (cmd)
2302 * sizeof (struct expression *));
2305 while (*cmdrest != '\0')
2310 expression_up expr = parse_exp_1 (&cmd1, scope, block_for_pc (scope), 1);
2311 argvec[nargs++] = expr.release ();
2313 if (*cmdrest == ',')
2317 agent_expr_up aexpr;
2319 /* We don't want to stop processing, so catch any errors
2320 that may show up. */
2323 aexpr = gen_printf (scope, gdbarch, 0, 0,
2324 format_start, format_end - format_start,
2325 fpieces, nargs, argvec);
2327 CATCH (ex, RETURN_MASK_ERROR)
2329 /* If we got here, it means the command could not be parsed to a valid
2330 bytecode expression and thus can't be evaluated on the target's side.
2331 It's no use iterating through the other commands. */
2335 do_cleanups (old_cleanups);
2337 /* We have a valid agent expression, return it. */
2341 /* Based on location BL, create a list of breakpoint commands to be
2342 passed on to the target. If we have duplicated locations with
2343 different commands, we will add any such to the list. */
2346 build_target_command_list (struct bp_location *bl)
2348 struct bp_location **locp = NULL, **loc2p;
2349 int null_command_or_parse_error = 0;
2350 int modified = bl->needs_update;
2351 struct bp_location *loc;
2353 /* Clear commands left over from a previous insert. */
2354 bl->target_info.tcommands.clear ();
2356 if (!target_can_run_breakpoint_commands ())
2359 /* For now, limit to agent-style dprintf breakpoints. */
2360 if (dprintf_style != dprintf_style_agent)
2363 /* For now, if we have any duplicate location that isn't a dprintf,
2364 don't install the target-side commands, as that would make the
2365 breakpoint not be reported to the core, and we'd lose
2367 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2370 if (is_breakpoint (loc->owner)
2371 && loc->pspace->num == bl->pspace->num
2372 && loc->owner->type != bp_dprintf)
2376 /* Do a first pass to check for locations with no assigned
2377 conditions or conditions that fail to parse to a valid agent expression
2378 bytecode. If any of these happen, then it's no use to send conditions
2379 to the target since this location will always trigger and generate a
2380 response back to GDB. */
2381 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2384 if (is_breakpoint (loc->owner) && loc->pspace->num == bl->pspace->num)
2388 /* Re-parse the commands since something changed. In that
2389 case we already freed the command bytecodes (see
2390 force_breakpoint_reinsertion). We just
2391 need to parse the command to bytecodes again. */
2393 = parse_cmd_to_aexpr (bl->address,
2394 loc->owner->extra_string);
2397 /* If we have a NULL bytecode expression, it means something
2398 went wrong or we have a null command expression. */
2399 if (!loc->cmd_bytecode)
2401 null_command_or_parse_error = 1;
2407 /* If anything failed, then we're not doing target-side commands,
2409 if (null_command_or_parse_error)
2411 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2414 if (is_breakpoint (loc->owner)
2415 && loc->pspace->num == bl->pspace->num)
2417 /* Only go as far as the first NULL bytecode is
2419 if (loc->cmd_bytecode == NULL)
2422 loc->cmd_bytecode.reset ();
2427 /* No NULL commands or failed bytecode generation. Build a command list
2428 for this location's address. */
2429 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2432 if (loc->owner->extra_string
2433 && is_breakpoint (loc->owner)
2434 && loc->pspace->num == bl->pspace->num
2435 && loc->owner->enable_state == bp_enabled
2438 /* Add the command to the vector. This will be used later
2439 to send the commands to the target. */
2440 bl->target_info.tcommands.push_back (loc->cmd_bytecode.get ());
2444 bl->target_info.persist = 0;
2445 /* Maybe flag this location as persistent. */
2446 if (bl->owner->type == bp_dprintf && disconnected_dprintf)
2447 bl->target_info.persist = 1;
2450 /* Return the kind of breakpoint on address *ADDR. Get the kind
2451 of breakpoint according to ADDR except single-step breakpoint.
2452 Get the kind of single-step breakpoint according to the current
2456 breakpoint_kind (struct bp_location *bl, CORE_ADDR *addr)
2458 if (bl->owner->type == bp_single_step)
2460 struct thread_info *thr = find_thread_global_id (bl->owner->thread);
2461 struct regcache *regcache;
2463 regcache = get_thread_regcache (thr->ptid);
2465 return gdbarch_breakpoint_kind_from_current_state (bl->gdbarch,
2469 return gdbarch_breakpoint_kind_from_pc (bl->gdbarch, addr);
2472 /* Insert a low-level "breakpoint" of some type. BL is the breakpoint
2473 location. Any error messages are printed to TMP_ERROR_STREAM; and
2474 DISABLED_BREAKS, and HW_BREAKPOINT_ERROR are used to report problems.
2475 Returns 0 for success, 1 if the bp_location type is not supported or
2478 NOTE drow/2003-09-09: This routine could be broken down to an
2479 object-style method for each breakpoint or catchpoint type. */
2481 insert_bp_location (struct bp_location *bl,
2482 struct ui_file *tmp_error_stream,
2483 int *disabled_breaks,
2484 int *hw_breakpoint_error,
2485 int *hw_bp_error_explained_already)
2487 enum errors bp_err = GDB_NO_ERROR;
2488 const char *bp_err_message = NULL;
2490 if (!should_be_inserted (bl) || (bl->inserted && !bl->needs_update))
2493 /* Note we don't initialize bl->target_info, as that wipes out
2494 the breakpoint location's shadow_contents if the breakpoint
2495 is still inserted at that location. This in turn breaks
2496 target_read_memory which depends on these buffers when
2497 a memory read is requested at the breakpoint location:
2498 Once the target_info has been wiped, we fail to see that
2499 we have a breakpoint inserted at that address and thus
2500 read the breakpoint instead of returning the data saved in
2501 the breakpoint location's shadow contents. */
2502 bl->target_info.reqstd_address = bl->address;
2503 bl->target_info.placed_address_space = bl->pspace->aspace;
2504 bl->target_info.length = bl->length;
2506 /* When working with target-side conditions, we must pass all the conditions
2507 for the same breakpoint address down to the target since GDB will not
2508 insert those locations. With a list of breakpoint conditions, the target
2509 can decide when to stop and notify GDB. */
2511 if (is_breakpoint (bl->owner))
2513 build_target_condition_list (bl);
2514 build_target_command_list (bl);
2515 /* Reset the modification marker. */
2516 bl->needs_update = 0;
2519 if (bl->loc_type == bp_loc_software_breakpoint
2520 || bl->loc_type == bp_loc_hardware_breakpoint)
2522 if (bl->owner->type != bp_hardware_breakpoint)
2524 /* If the explicitly specified breakpoint type
2525 is not hardware breakpoint, check the memory map to see
2526 if the breakpoint address is in read only memory or not.
2528 Two important cases are:
2529 - location type is not hardware breakpoint, memory
2530 is readonly. We change the type of the location to
2531 hardware breakpoint.
2532 - location type is hardware breakpoint, memory is
2533 read-write. This means we've previously made the
2534 location hardware one, but then the memory map changed,
2537 When breakpoints are removed, remove_breakpoints will use
2538 location types we've just set here, the only possible
2539 problem is that memory map has changed during running
2540 program, but it's not going to work anyway with current
2542 struct mem_region *mr
2543 = lookup_mem_region (bl->target_info.reqstd_address);
2547 if (automatic_hardware_breakpoints)
2549 enum bp_loc_type new_type;
2551 if (mr->attrib.mode != MEM_RW)
2552 new_type = bp_loc_hardware_breakpoint;
2554 new_type = bp_loc_software_breakpoint;
2556 if (new_type != bl->loc_type)
2558 static int said = 0;
2560 bl->loc_type = new_type;
2563 fprintf_filtered (gdb_stdout,
2564 _("Note: automatically using "
2565 "hardware breakpoints for "
2566 "read-only addresses.\n"));
2571 else if (bl->loc_type == bp_loc_software_breakpoint
2572 && mr->attrib.mode != MEM_RW)
2574 fprintf_unfiltered (tmp_error_stream,
2575 _("Cannot insert breakpoint %d.\n"
2576 "Cannot set software breakpoint "
2577 "at read-only address %s\n"),
2579 paddress (bl->gdbarch, bl->address));
2585 /* First check to see if we have to handle an overlay. */
2586 if (overlay_debugging == ovly_off
2587 || bl->section == NULL
2588 || !(section_is_overlay (bl->section)))
2590 /* No overlay handling: just set the breakpoint. */
2595 val = bl->owner->ops->insert_location (bl);
2597 bp_err = GENERIC_ERROR;
2599 CATCH (e, RETURN_MASK_ALL)
2602 bp_err_message = e.message;
2608 /* This breakpoint is in an overlay section.
2609 Shall we set a breakpoint at the LMA? */
2610 if (!overlay_events_enabled)
2612 /* Yes -- overlay event support is not active,
2613 so we must try to set a breakpoint at the LMA.
2614 This will not work for a hardware breakpoint. */
2615 if (bl->loc_type == bp_loc_hardware_breakpoint)
2616 warning (_("hardware breakpoint %d not supported in overlay!"),
2620 CORE_ADDR addr = overlay_unmapped_address (bl->address,
2622 /* Set a software (trap) breakpoint at the LMA. */
2623 bl->overlay_target_info = bl->target_info;
2624 bl->overlay_target_info.reqstd_address = addr;
2626 /* No overlay handling: just set the breakpoint. */
2631 bl->overlay_target_info.kind
2632 = breakpoint_kind (bl, &addr);
2633 bl->overlay_target_info.placed_address = addr;
2634 val = target_insert_breakpoint (bl->gdbarch,
2635 &bl->overlay_target_info);
2637 bp_err = GENERIC_ERROR;
2639 CATCH (e, RETURN_MASK_ALL)
2642 bp_err_message = e.message;
2646 if (bp_err != GDB_NO_ERROR)
2647 fprintf_unfiltered (tmp_error_stream,
2648 "Overlay breakpoint %d "
2649 "failed: in ROM?\n",
2653 /* Shall we set a breakpoint at the VMA? */
2654 if (section_is_mapped (bl->section))
2656 /* Yes. This overlay section is mapped into memory. */
2661 val = bl->owner->ops->insert_location (bl);
2663 bp_err = GENERIC_ERROR;
2665 CATCH (e, RETURN_MASK_ALL)
2668 bp_err_message = e.message;
2674 /* No. This breakpoint will not be inserted.
2675 No error, but do not mark the bp as 'inserted'. */
2680 if (bp_err != GDB_NO_ERROR)
2682 /* Can't set the breakpoint. */
2684 /* In some cases, we might not be able to insert a
2685 breakpoint in a shared library that has already been
2686 removed, but we have not yet processed the shlib unload
2687 event. Unfortunately, some targets that implement
2688 breakpoint insertion themselves can't tell why the
2689 breakpoint insertion failed (e.g., the remote target
2690 doesn't define error codes), so we must treat generic
2691 errors as memory errors. */
2692 if ((bp_err == GENERIC_ERROR || bp_err == MEMORY_ERROR)
2693 && bl->loc_type == bp_loc_software_breakpoint
2694 && (solib_name_from_address (bl->pspace, bl->address)
2695 || shared_objfile_contains_address_p (bl->pspace,
2698 /* See also: disable_breakpoints_in_shlibs. */
2699 bl->shlib_disabled = 1;
2700 observer_notify_breakpoint_modified (bl->owner);
2701 if (!*disabled_breaks)
2703 fprintf_unfiltered (tmp_error_stream,
2704 "Cannot insert breakpoint %d.\n",
2706 fprintf_unfiltered (tmp_error_stream,
2707 "Temporarily disabling shared "
2708 "library breakpoints:\n");
2710 *disabled_breaks = 1;
2711 fprintf_unfiltered (tmp_error_stream,
2712 "breakpoint #%d\n", bl->owner->number);
2717 if (bl->loc_type == bp_loc_hardware_breakpoint)
2719 *hw_breakpoint_error = 1;
2720 *hw_bp_error_explained_already = bp_err_message != NULL;
2721 fprintf_unfiltered (tmp_error_stream,
2722 "Cannot insert hardware breakpoint %d%s",
2723 bl->owner->number, bp_err_message ? ":" : ".\n");
2724 if (bp_err_message != NULL)
2725 fprintf_unfiltered (tmp_error_stream, "%s.\n", bp_err_message);
2729 if (bp_err_message == NULL)
2732 = memory_error_message (TARGET_XFER_E_IO,
2733 bl->gdbarch, bl->address);
2735 fprintf_unfiltered (tmp_error_stream,
2736 "Cannot insert breakpoint %d.\n"
2738 bl->owner->number, message.c_str ());
2742 fprintf_unfiltered (tmp_error_stream,
2743 "Cannot insert breakpoint %d: %s\n",
2758 else if (bl->loc_type == bp_loc_hardware_watchpoint
2759 /* NOTE drow/2003-09-08: This state only exists for removing
2760 watchpoints. It's not clear that it's necessary... */
2761 && bl->owner->disposition != disp_del_at_next_stop)
2765 gdb_assert (bl->owner->ops != NULL
2766 && bl->owner->ops->insert_location != NULL);
2768 val = bl->owner->ops->insert_location (bl);
2770 /* If trying to set a read-watchpoint, and it turns out it's not
2771 supported, try emulating one with an access watchpoint. */
2772 if (val == 1 && bl->watchpoint_type == hw_read)
2774 struct bp_location *loc, **loc_temp;
2776 /* But don't try to insert it, if there's already another
2777 hw_access location that would be considered a duplicate
2779 ALL_BP_LOCATIONS (loc, loc_temp)
2781 && loc->watchpoint_type == hw_access
2782 && watchpoint_locations_match (bl, loc))
2786 bl->target_info = loc->target_info;
2787 bl->watchpoint_type = hw_access;
2794 bl->watchpoint_type = hw_access;
2795 val = bl->owner->ops->insert_location (bl);
2798 /* Back to the original value. */
2799 bl->watchpoint_type = hw_read;
2803 bl->inserted = (val == 0);
2806 else if (bl->owner->type == bp_catchpoint)
2810 gdb_assert (bl->owner->ops != NULL
2811 && bl->owner->ops->insert_location != NULL);
2813 val = bl->owner->ops->insert_location (bl);
2816 bl->owner->enable_state = bp_disabled;
2820 Error inserting catchpoint %d: Your system does not support this type\n\
2821 of catchpoint."), bl->owner->number);
2823 warning (_("Error inserting catchpoint %d."), bl->owner->number);
2826 bl->inserted = (val == 0);
2828 /* We've already printed an error message if there was a problem
2829 inserting this catchpoint, and we've disabled the catchpoint,
2830 so just return success. */
2837 /* This function is called when program space PSPACE is about to be
2838 deleted. It takes care of updating breakpoints to not reference
2842 breakpoint_program_space_exit (struct program_space *pspace)
2844 struct breakpoint *b, *b_temp;
2845 struct bp_location *loc, **loc_temp;
2847 /* Remove any breakpoint that was set through this program space. */
2848 ALL_BREAKPOINTS_SAFE (b, b_temp)
2850 if (b->pspace == pspace)
2851 delete_breakpoint (b);
2854 /* Breakpoints set through other program spaces could have locations
2855 bound to PSPACE as well. Remove those. */
2856 ALL_BP_LOCATIONS (loc, loc_temp)
2858 struct bp_location *tmp;
2860 if (loc->pspace == pspace)
2862 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
2863 if (loc->owner->loc == loc)
2864 loc->owner->loc = loc->next;
2866 for (tmp = loc->owner->loc; tmp->next != NULL; tmp = tmp->next)
2867 if (tmp->next == loc)
2869 tmp->next = loc->next;
2875 /* Now update the global location list to permanently delete the
2876 removed locations above. */
2877 update_global_location_list (UGLL_DONT_INSERT);
2880 /* Make sure all breakpoints are inserted in inferior.
2881 Throws exception on any error.
2882 A breakpoint that is already inserted won't be inserted
2883 again, so calling this function twice is safe. */
2885 insert_breakpoints (void)
2887 struct breakpoint *bpt;
2889 ALL_BREAKPOINTS (bpt)
2890 if (is_hardware_watchpoint (bpt))
2892 struct watchpoint *w = (struct watchpoint *) bpt;
2894 update_watchpoint (w, 0 /* don't reparse. */);
2897 /* Updating watchpoints creates new locations, so update the global
2898 location list. Explicitly tell ugll to insert locations and
2899 ignore breakpoints_always_inserted_mode. */
2900 update_global_location_list (UGLL_INSERT);
2903 /* Invoke CALLBACK for each of bp_location. */
2906 iterate_over_bp_locations (walk_bp_location_callback callback)
2908 struct bp_location *loc, **loc_tmp;
2910 ALL_BP_LOCATIONS (loc, loc_tmp)
2912 callback (loc, NULL);
2916 /* This is used when we need to synch breakpoint conditions between GDB and the
2917 target. It is the case with deleting and disabling of breakpoints when using
2918 always-inserted mode. */
2921 update_inserted_breakpoint_locations (void)
2923 struct bp_location *bl, **blp_tmp;
2926 int disabled_breaks = 0;
2927 int hw_breakpoint_error = 0;
2928 int hw_bp_details_reported = 0;
2930 string_file tmp_error_stream;
2932 /* Explicitly mark the warning -- this will only be printed if
2933 there was an error. */
2934 tmp_error_stream.puts ("Warning:\n");
2936 scoped_restore_current_pspace_and_thread restore_pspace_thread;
2938 ALL_BP_LOCATIONS (bl, blp_tmp)
2940 /* We only want to update software breakpoints and hardware
2942 if (!is_breakpoint (bl->owner))
2945 /* We only want to update locations that are already inserted
2946 and need updating. This is to avoid unwanted insertion during
2947 deletion of breakpoints. */
2948 if (!bl->inserted || (bl->inserted && !bl->needs_update))
2951 switch_to_program_space_and_thread (bl->pspace);
2953 /* For targets that support global breakpoints, there's no need
2954 to select an inferior to insert breakpoint to. In fact, even
2955 if we aren't attached to any process yet, we should still
2956 insert breakpoints. */
2957 if (!gdbarch_has_global_breakpoints (target_gdbarch ())
2958 && ptid_equal (inferior_ptid, null_ptid))
2961 val = insert_bp_location (bl, &tmp_error_stream, &disabled_breaks,
2962 &hw_breakpoint_error, &hw_bp_details_reported);
2969 target_terminal::ours_for_output ();
2970 error_stream (tmp_error_stream);
2974 /* Used when starting or continuing the program. */
2977 insert_breakpoint_locations (void)
2979 struct breakpoint *bpt;
2980 struct bp_location *bl, **blp_tmp;
2983 int disabled_breaks = 0;
2984 int hw_breakpoint_error = 0;
2985 int hw_bp_error_explained_already = 0;
2987 string_file tmp_error_stream;
2989 /* Explicitly mark the warning -- this will only be printed if
2990 there was an error. */
2991 tmp_error_stream.puts ("Warning:\n");
2993 scoped_restore_current_pspace_and_thread restore_pspace_thread;
2995 ALL_BP_LOCATIONS (bl, blp_tmp)
2997 if (!should_be_inserted (bl) || (bl->inserted && !bl->needs_update))
3000 /* There is no point inserting thread-specific breakpoints if
3001 the thread no longer exists. ALL_BP_LOCATIONS bp_location
3002 has BL->OWNER always non-NULL. */
3003 if (bl->owner->thread != -1
3004 && !valid_global_thread_id (bl->owner->thread))
3007 switch_to_program_space_and_thread (bl->pspace);
3009 /* For targets that support global breakpoints, there's no need
3010 to select an inferior to insert breakpoint to. In fact, even
3011 if we aren't attached to any process yet, we should still
3012 insert breakpoints. */
3013 if (!gdbarch_has_global_breakpoints (target_gdbarch ())
3014 && ptid_equal (inferior_ptid, null_ptid))
3017 val = insert_bp_location (bl, &tmp_error_stream, &disabled_breaks,
3018 &hw_breakpoint_error, &hw_bp_error_explained_already);
3023 /* If we failed to insert all locations of a watchpoint, remove
3024 them, as half-inserted watchpoint is of limited use. */
3025 ALL_BREAKPOINTS (bpt)
3027 int some_failed = 0;
3028 struct bp_location *loc;
3030 if (!is_hardware_watchpoint (bpt))
3033 if (!breakpoint_enabled (bpt))
3036 if (bpt->disposition == disp_del_at_next_stop)
3039 for (loc = bpt->loc; loc; loc = loc->next)
3040 if (!loc->inserted && should_be_inserted (loc))
3047 for (loc = bpt->loc; loc; loc = loc->next)
3049 remove_breakpoint (loc);
3051 hw_breakpoint_error = 1;
3052 tmp_error_stream.printf ("Could not insert "
3053 "hardware watchpoint %d.\n",
3061 /* If a hardware breakpoint or watchpoint was inserted, add a
3062 message about possibly exhausted resources. */
3063 if (hw_breakpoint_error && !hw_bp_error_explained_already)
3065 tmp_error_stream.printf ("Could not insert hardware breakpoints:\n\
3066 You may have requested too many hardware breakpoints/watchpoints.\n");
3068 target_terminal::ours_for_output ();
3069 error_stream (tmp_error_stream);
3073 /* Used when the program stops.
3074 Returns zero if successful, or non-zero if there was a problem
3075 removing a breakpoint location. */
3078 remove_breakpoints (void)
3080 struct bp_location *bl, **blp_tmp;
3083 ALL_BP_LOCATIONS (bl, blp_tmp)
3085 if (bl->inserted && !is_tracepoint (bl->owner))
3086 val |= remove_breakpoint (bl);
3091 /* When a thread exits, remove breakpoints that are related to
3095 remove_threaded_breakpoints (struct thread_info *tp, int silent)
3097 struct breakpoint *b, *b_tmp;
3099 ALL_BREAKPOINTS_SAFE (b, b_tmp)
3101 if (b->thread == tp->global_num && user_breakpoint_p (b))
3103 b->disposition = disp_del_at_next_stop;
3105 printf_filtered (_("\
3106 Thread-specific breakpoint %d deleted - thread %s no longer in the thread list.\n"),
3107 b->number, print_thread_id (tp));
3109 /* Hide it from the user. */
3115 /* Remove breakpoints of process PID. */
3118 remove_breakpoints_pid (int pid)
3120 struct bp_location *bl, **blp_tmp;
3122 struct inferior *inf = find_inferior_pid (pid);
3124 ALL_BP_LOCATIONS (bl, blp_tmp)
3126 if (bl->pspace != inf->pspace)
3129 if (bl->inserted && !bl->target_info.persist)
3131 val = remove_breakpoint (bl);
3139 static int internal_breakpoint_number = -1;
3141 /* Set the breakpoint number of B, depending on the value of INTERNAL.
3142 If INTERNAL is non-zero, the breakpoint number will be populated
3143 from internal_breakpoint_number and that variable decremented.
3144 Otherwise the breakpoint number will be populated from
3145 breakpoint_count and that value incremented. Internal breakpoints
3146 do not set the internal var bpnum. */
3148 set_breakpoint_number (int internal, struct breakpoint *b)
3151 b->number = internal_breakpoint_number--;
3154 set_breakpoint_count (breakpoint_count + 1);
3155 b->number = breakpoint_count;
3159 static struct breakpoint *
3160 create_internal_breakpoint (struct gdbarch *gdbarch,
3161 CORE_ADDR address, enum bptype type,
3162 const struct breakpoint_ops *ops)
3164 symtab_and_line sal;
3166 sal.section = find_pc_overlay (sal.pc);
3167 sal.pspace = current_program_space;
3169 breakpoint *b = set_raw_breakpoint (gdbarch, sal, type, ops);
3170 b->number = internal_breakpoint_number--;
3171 b->disposition = disp_donttouch;
3176 static const char *const longjmp_names[] =
3178 "longjmp", "_longjmp", "siglongjmp", "_siglongjmp"
3180 #define NUM_LONGJMP_NAMES ARRAY_SIZE(longjmp_names)
3182 /* Per-objfile data private to breakpoint.c. */
3183 struct breakpoint_objfile_data
3185 /* Minimal symbol for "_ovly_debug_event" (if any). */
3186 struct bound_minimal_symbol overlay_msym {};
3188 /* Minimal symbol(s) for "longjmp", "siglongjmp", etc. (if any). */
3189 struct bound_minimal_symbol longjmp_msym[NUM_LONGJMP_NAMES] {};
3191 /* True if we have looked for longjmp probes. */
3192 int longjmp_searched = 0;
3194 /* SystemTap probe points for longjmp (if any). These are non-owning
3196 std::vector<probe *> longjmp_probes;
3198 /* Minimal symbol for "std::terminate()" (if any). */
3199 struct bound_minimal_symbol terminate_msym {};
3201 /* Minimal symbol for "_Unwind_DebugHook" (if any). */
3202 struct bound_minimal_symbol exception_msym {};
3204 /* True if we have looked for exception probes. */
3205 int exception_searched = 0;
3207 /* SystemTap probe points for unwinding (if any). These are non-owning
3209 std::vector<probe *> exception_probes;
3212 static const struct objfile_data *breakpoint_objfile_key;
3214 /* Minimal symbol not found sentinel. */
3215 static struct minimal_symbol msym_not_found;
3217 /* Returns TRUE if MSYM point to the "not found" sentinel. */
3220 msym_not_found_p (const struct minimal_symbol *msym)
3222 return msym == &msym_not_found;
3225 /* Return per-objfile data needed by breakpoint.c.
3226 Allocate the data if necessary. */
3228 static struct breakpoint_objfile_data *
3229 get_breakpoint_objfile_data (struct objfile *objfile)
3231 struct breakpoint_objfile_data *bp_objfile_data;
3233 bp_objfile_data = ((struct breakpoint_objfile_data *)
3234 objfile_data (objfile, breakpoint_objfile_key));
3235 if (bp_objfile_data == NULL)
3237 bp_objfile_data = new breakpoint_objfile_data ();
3238 set_objfile_data (objfile, breakpoint_objfile_key, bp_objfile_data);
3240 return bp_objfile_data;
3244 free_breakpoint_objfile_data (struct objfile *obj, void *data)
3246 struct breakpoint_objfile_data *bp_objfile_data
3247 = (struct breakpoint_objfile_data *) data;
3249 delete bp_objfile_data;
3253 create_overlay_event_breakpoint (void)
3255 struct objfile *objfile;
3256 const char *const func_name = "_ovly_debug_event";
3258 ALL_OBJFILES (objfile)
3260 struct breakpoint *b;
3261 struct breakpoint_objfile_data *bp_objfile_data;
3263 struct explicit_location explicit_loc;
3265 bp_objfile_data = get_breakpoint_objfile_data (objfile);
3267 if (msym_not_found_p (bp_objfile_data->overlay_msym.minsym))
3270 if (bp_objfile_data->overlay_msym.minsym == NULL)
3272 struct bound_minimal_symbol m;
3274 m = lookup_minimal_symbol_text (func_name, objfile);
3275 if (m.minsym == NULL)
3277 /* Avoid future lookups in this objfile. */
3278 bp_objfile_data->overlay_msym.minsym = &msym_not_found;
3281 bp_objfile_data->overlay_msym = m;
3284 addr = BMSYMBOL_VALUE_ADDRESS (bp_objfile_data->overlay_msym);
3285 b = create_internal_breakpoint (get_objfile_arch (objfile), addr,
3287 &internal_breakpoint_ops);
3288 initialize_explicit_location (&explicit_loc);
3289 explicit_loc.function_name = ASTRDUP (func_name);
3290 b->location = new_explicit_location (&explicit_loc);
3292 if (overlay_debugging == ovly_auto)
3294 b->enable_state = bp_enabled;
3295 overlay_events_enabled = 1;
3299 b->enable_state = bp_disabled;
3300 overlay_events_enabled = 0;
3306 create_longjmp_master_breakpoint (void)
3308 struct program_space *pspace;
3310 scoped_restore_current_program_space restore_pspace;
3312 ALL_PSPACES (pspace)
3314 struct objfile *objfile;
3316 set_current_program_space (pspace);
3318 ALL_OBJFILES (objfile)
3321 struct gdbarch *gdbarch;
3322 struct breakpoint_objfile_data *bp_objfile_data;
3324 gdbarch = get_objfile_arch (objfile);
3326 bp_objfile_data = get_breakpoint_objfile_data (objfile);
3328 if (!bp_objfile_data->longjmp_searched)
3330 std::vector<probe *> ret
3331 = find_probes_in_objfile (objfile, "libc", "longjmp");
3335 /* We are only interested in checking one element. */
3338 if (!can_evaluate_probe_arguments (p))
3340 /* We cannot use the probe interface here, because it does
3341 not know how to evaluate arguments. */
3345 bp_objfile_data->longjmp_probes = ret;
3346 bp_objfile_data->longjmp_searched = 1;
3349 if (!bp_objfile_data->longjmp_probes.empty ())
3351 struct gdbarch *gdbarch = get_objfile_arch (objfile);
3353 for (probe *p : bp_objfile_data->longjmp_probes)
3355 struct breakpoint *b;
3357 b = create_internal_breakpoint (gdbarch,
3358 get_probe_address (p, objfile),
3360 &internal_breakpoint_ops);
3361 b->location = new_probe_location ("-probe-stap libc:longjmp");
3362 b->enable_state = bp_disabled;
3368 if (!gdbarch_get_longjmp_target_p (gdbarch))
3371 for (i = 0; i < NUM_LONGJMP_NAMES; i++)
3373 struct breakpoint *b;
3374 const char *func_name;
3376 struct explicit_location explicit_loc;
3378 if (msym_not_found_p (bp_objfile_data->longjmp_msym[i].minsym))
3381 func_name = longjmp_names[i];
3382 if (bp_objfile_data->longjmp_msym[i].minsym == NULL)
3384 struct bound_minimal_symbol m;
3386 m = lookup_minimal_symbol_text (func_name, objfile);
3387 if (m.minsym == NULL)
3389 /* Prevent future lookups in this objfile. */
3390 bp_objfile_data->longjmp_msym[i].minsym = &msym_not_found;
3393 bp_objfile_data->longjmp_msym[i] = m;
3396 addr = BMSYMBOL_VALUE_ADDRESS (bp_objfile_data->longjmp_msym[i]);
3397 b = create_internal_breakpoint (gdbarch, addr, bp_longjmp_master,
3398 &internal_breakpoint_ops);
3399 initialize_explicit_location (&explicit_loc);
3400 explicit_loc.function_name = ASTRDUP (func_name);
3401 b->location = new_explicit_location (&explicit_loc);
3402 b->enable_state = bp_disabled;
3408 /* Create a master std::terminate breakpoint. */
3410 create_std_terminate_master_breakpoint (void)
3412 struct program_space *pspace;
3413 const char *const func_name = "std::terminate()";
3415 scoped_restore_current_program_space restore_pspace;
3417 ALL_PSPACES (pspace)
3419 struct objfile *objfile;
3422 set_current_program_space (pspace);
3424 ALL_OBJFILES (objfile)
3426 struct breakpoint *b;
3427 struct breakpoint_objfile_data *bp_objfile_data;
3428 struct explicit_location explicit_loc;
3430 bp_objfile_data = get_breakpoint_objfile_data (objfile);
3432 if (msym_not_found_p (bp_objfile_data->terminate_msym.minsym))
3435 if (bp_objfile_data->terminate_msym.minsym == NULL)
3437 struct bound_minimal_symbol m;
3439 m = lookup_minimal_symbol (func_name, NULL, objfile);
3440 if (m.minsym == NULL || (MSYMBOL_TYPE (m.minsym) != mst_text
3441 && MSYMBOL_TYPE (m.minsym) != mst_file_text))
3443 /* Prevent future lookups in this objfile. */
3444 bp_objfile_data->terminate_msym.minsym = &msym_not_found;
3447 bp_objfile_data->terminate_msym = m;
3450 addr = BMSYMBOL_VALUE_ADDRESS (bp_objfile_data->terminate_msym);
3451 b = create_internal_breakpoint (get_objfile_arch (objfile), addr,
3452 bp_std_terminate_master,
3453 &internal_breakpoint_ops);
3454 initialize_explicit_location (&explicit_loc);
3455 explicit_loc.function_name = ASTRDUP (func_name);
3456 b->location = new_explicit_location (&explicit_loc);
3457 b->enable_state = bp_disabled;
3462 /* Install a master breakpoint on the unwinder's debug hook. */
3465 create_exception_master_breakpoint (void)
3467 struct objfile *objfile;
3468 const char *const func_name = "_Unwind_DebugHook";
3470 ALL_OBJFILES (objfile)
3472 struct breakpoint *b;
3473 struct gdbarch *gdbarch;
3474 struct breakpoint_objfile_data *bp_objfile_data;
3476 struct explicit_location explicit_loc;
3478 bp_objfile_data = get_breakpoint_objfile_data (objfile);
3480 /* We prefer the SystemTap probe point if it exists. */
3481 if (!bp_objfile_data->exception_searched)
3483 std::vector<probe *> ret
3484 = find_probes_in_objfile (objfile, "libgcc", "unwind");
3488 /* We are only interested in checking one element. */
3491 if (!can_evaluate_probe_arguments (p))
3493 /* We cannot use the probe interface here, because it does
3494 not know how to evaluate arguments. */
3498 bp_objfile_data->exception_probes = ret;
3499 bp_objfile_data->exception_searched = 1;
3502 if (!bp_objfile_data->exception_probes.empty ())
3504 struct gdbarch *gdbarch = get_objfile_arch (objfile);
3506 for (probe *p : bp_objfile_data->exception_probes)
3508 struct breakpoint *b;
3510 b = create_internal_breakpoint (gdbarch,
3511 get_probe_address (p, objfile),
3512 bp_exception_master,
3513 &internal_breakpoint_ops);
3514 b->location = new_probe_location ("-probe-stap libgcc:unwind");
3515 b->enable_state = bp_disabled;
3521 /* Otherwise, try the hook function. */
3523 if (msym_not_found_p (bp_objfile_data->exception_msym.minsym))
3526 gdbarch = get_objfile_arch (objfile);
3528 if (bp_objfile_data->exception_msym.minsym == NULL)
3530 struct bound_minimal_symbol debug_hook;
3532 debug_hook = lookup_minimal_symbol (func_name, NULL, objfile);
3533 if (debug_hook.minsym == NULL)
3535 bp_objfile_data->exception_msym.minsym = &msym_not_found;
3539 bp_objfile_data->exception_msym = debug_hook;
3542 addr = BMSYMBOL_VALUE_ADDRESS (bp_objfile_data->exception_msym);
3543 addr = gdbarch_convert_from_func_ptr_addr (gdbarch, addr,
3545 b = create_internal_breakpoint (gdbarch, addr, bp_exception_master,
3546 &internal_breakpoint_ops);
3547 initialize_explicit_location (&explicit_loc);
3548 explicit_loc.function_name = ASTRDUP (func_name);
3549 b->location = new_explicit_location (&explicit_loc);
3550 b->enable_state = bp_disabled;
3554 /* Does B have a location spec? */
3557 breakpoint_event_location_empty_p (const struct breakpoint *b)
3559 return b->location != NULL && event_location_empty_p (b->location.get ());
3563 update_breakpoints_after_exec (void)
3565 struct breakpoint *b, *b_tmp;
3566 struct bp_location *bploc, **bplocp_tmp;
3568 /* We're about to delete breakpoints from GDB's lists. If the
3569 INSERTED flag is true, GDB will try to lift the breakpoints by
3570 writing the breakpoints' "shadow contents" back into memory. The
3571 "shadow contents" are NOT valid after an exec, so GDB should not
3572 do that. Instead, the target is responsible from marking
3573 breakpoints out as soon as it detects an exec. We don't do that
3574 here instead, because there may be other attempts to delete
3575 breakpoints after detecting an exec and before reaching here. */
3576 ALL_BP_LOCATIONS (bploc, bplocp_tmp)
3577 if (bploc->pspace == current_program_space)
3578 gdb_assert (!bploc->inserted);
3580 ALL_BREAKPOINTS_SAFE (b, b_tmp)
3582 if (b->pspace != current_program_space)
3585 /* Solib breakpoints must be explicitly reset after an exec(). */
3586 if (b->type == bp_shlib_event)
3588 delete_breakpoint (b);
3592 /* JIT breakpoints must be explicitly reset after an exec(). */
3593 if (b->type == bp_jit_event)
3595 delete_breakpoint (b);
3599 /* Thread event breakpoints must be set anew after an exec(),
3600 as must overlay event and longjmp master breakpoints. */
3601 if (b->type == bp_thread_event || b->type == bp_overlay_event
3602 || b->type == bp_longjmp_master || b->type == bp_std_terminate_master
3603 || b->type == bp_exception_master)
3605 delete_breakpoint (b);
3609 /* Step-resume breakpoints are meaningless after an exec(). */
3610 if (b->type == bp_step_resume || b->type == bp_hp_step_resume)
3612 delete_breakpoint (b);
3616 /* Just like single-step breakpoints. */
3617 if (b->type == bp_single_step)
3619 delete_breakpoint (b);
3623 /* Longjmp and longjmp-resume breakpoints are also meaningless
3625 if (b->type == bp_longjmp || b->type == bp_longjmp_resume
3626 || b->type == bp_longjmp_call_dummy
3627 || b->type == bp_exception || b->type == bp_exception_resume)
3629 delete_breakpoint (b);
3633 if (b->type == bp_catchpoint)
3635 /* For now, none of the bp_catchpoint breakpoints need to
3636 do anything at this point. In the future, if some of
3637 the catchpoints need to something, we will need to add
3638 a new method, and call this method from here. */
3642 /* bp_finish is a special case. The only way we ought to be able
3643 to see one of these when an exec() has happened, is if the user
3644 caught a vfork, and then said "finish". Ordinarily a finish just
3645 carries them to the call-site of the current callee, by setting
3646 a temporary bp there and resuming. But in this case, the finish
3647 will carry them entirely through the vfork & exec.
3649 We don't want to allow a bp_finish to remain inserted now. But
3650 we can't safely delete it, 'cause finish_command has a handle to
3651 the bp on a bpstat, and will later want to delete it. There's a
3652 chance (and I've seen it happen) that if we delete the bp_finish
3653 here, that its storage will get reused by the time finish_command
3654 gets 'round to deleting the "use to be a bp_finish" breakpoint.
3655 We really must allow finish_command to delete a bp_finish.
3657 In the absence of a general solution for the "how do we know
3658 it's safe to delete something others may have handles to?"
3659 problem, what we'll do here is just uninsert the bp_finish, and
3660 let finish_command delete it.
3662 (We know the bp_finish is "doomed" in the sense that it's
3663 momentary, and will be deleted as soon as finish_command sees
3664 the inferior stopped. So it doesn't matter that the bp's
3665 address is probably bogus in the new a.out, unlike e.g., the
3666 solib breakpoints.) */
3668 if (b->type == bp_finish)
3673 /* Without a symbolic address, we have little hope of the
3674 pre-exec() address meaning the same thing in the post-exec()
3676 if (breakpoint_event_location_empty_p (b))
3678 delete_breakpoint (b);
3685 detach_breakpoints (ptid_t ptid)
3687 struct bp_location *bl, **blp_tmp;
3689 scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
3690 struct inferior *inf = current_inferior ();
3692 if (ptid_get_pid (ptid) == ptid_get_pid (inferior_ptid))
3693 error (_("Cannot detach breakpoints of inferior_ptid"));
3695 /* Set inferior_ptid; remove_breakpoint_1 uses this global. */
3696 inferior_ptid = ptid;
3697 ALL_BP_LOCATIONS (bl, blp_tmp)
3699 if (bl->pspace != inf->pspace)
3702 /* This function must physically remove breakpoints locations
3703 from the specified ptid, without modifying the breakpoint
3704 package's state. Locations of type bp_loc_other are only
3705 maintained at GDB side. So, there is no need to remove
3706 these bp_loc_other locations. Moreover, removing these
3707 would modify the breakpoint package's state. */
3708 if (bl->loc_type == bp_loc_other)
3712 val |= remove_breakpoint_1 (bl, DETACH_BREAKPOINT);
3718 /* Remove the breakpoint location BL from the current address space.
3719 Note that this is used to detach breakpoints from a child fork.
3720 When we get here, the child isn't in the inferior list, and neither
3721 do we have objects to represent its address space --- we should
3722 *not* look at bl->pspace->aspace here. */
3725 remove_breakpoint_1 (struct bp_location *bl, enum remove_bp_reason reason)
3729 /* BL is never in moribund_locations by our callers. */
3730 gdb_assert (bl->owner != NULL);
3732 /* The type of none suggests that owner is actually deleted.
3733 This should not ever happen. */
3734 gdb_assert (bl->owner->type != bp_none);
3736 if (bl->loc_type == bp_loc_software_breakpoint
3737 || bl->loc_type == bp_loc_hardware_breakpoint)
3739 /* "Normal" instruction breakpoint: either the standard
3740 trap-instruction bp (bp_breakpoint), or a
3741 bp_hardware_breakpoint. */
3743 /* First check to see if we have to handle an overlay. */
3744 if (overlay_debugging == ovly_off
3745 || bl->section == NULL
3746 || !(section_is_overlay (bl->section)))
3748 /* No overlay handling: just remove the breakpoint. */
3750 /* If we're trying to uninsert a memory breakpoint that we
3751 know is set in a dynamic object that is marked
3752 shlib_disabled, then either the dynamic object was
3753 removed with "remove-symbol-file" or with
3754 "nosharedlibrary". In the former case, we don't know
3755 whether another dynamic object might have loaded over the
3756 breakpoint's address -- the user might well let us know
3757 about it next with add-symbol-file (the whole point of
3758 add-symbol-file is letting the user manually maintain a
3759 list of dynamically loaded objects). If we have the
3760 breakpoint's shadow memory, that is, this is a software
3761 breakpoint managed by GDB, check whether the breakpoint
3762 is still inserted in memory, to avoid overwriting wrong
3763 code with stale saved shadow contents. Note that HW
3764 breakpoints don't have shadow memory, as they're
3765 implemented using a mechanism that is not dependent on
3766 being able to modify the target's memory, and as such
3767 they should always be removed. */
3768 if (bl->shlib_disabled
3769 && bl->target_info.shadow_len != 0
3770 && !memory_validate_breakpoint (bl->gdbarch, &bl->target_info))
3773 val = bl->owner->ops->remove_location (bl, reason);
3777 /* This breakpoint is in an overlay section.
3778 Did we set a breakpoint at the LMA? */
3779 if (!overlay_events_enabled)
3781 /* Yes -- overlay event support is not active, so we
3782 should have set a breakpoint at the LMA. Remove it.
3784 /* Ignore any failures: if the LMA is in ROM, we will
3785 have already warned when we failed to insert it. */
3786 if (bl->loc_type == bp_loc_hardware_breakpoint)
3787 target_remove_hw_breakpoint (bl->gdbarch,
3788 &bl->overlay_target_info);
3790 target_remove_breakpoint (bl->gdbarch,
3791 &bl->overlay_target_info,
3794 /* Did we set a breakpoint at the VMA?
3795 If so, we will have marked the breakpoint 'inserted'. */
3798 /* Yes -- remove it. Previously we did not bother to
3799 remove the breakpoint if the section had been
3800 unmapped, but let's not rely on that being safe. We
3801 don't know what the overlay manager might do. */
3803 /* However, we should remove *software* breakpoints only
3804 if the section is still mapped, or else we overwrite
3805 wrong code with the saved shadow contents. */
3806 if (bl->loc_type == bp_loc_hardware_breakpoint
3807 || section_is_mapped (bl->section))
3808 val = bl->owner->ops->remove_location (bl, reason);
3814 /* No -- not inserted, so no need to remove. No error. */
3819 /* In some cases, we might not be able to remove a breakpoint in
3820 a shared library that has already been removed, but we have
3821 not yet processed the shlib unload event. Similarly for an
3822 unloaded add-symbol-file object - the user might not yet have
3823 had the chance to remove-symbol-file it. shlib_disabled will
3824 be set if the library/object has already been removed, but
3825 the breakpoint hasn't been uninserted yet, e.g., after
3826 "nosharedlibrary" or "remove-symbol-file" with breakpoints
3827 always-inserted mode. */
3829 && (bl->loc_type == bp_loc_software_breakpoint
3830 && (bl->shlib_disabled
3831 || solib_name_from_address (bl->pspace, bl->address)
3832 || shared_objfile_contains_address_p (bl->pspace,
3838 bl->inserted = (reason == DETACH_BREAKPOINT);
3840 else if (bl->loc_type == bp_loc_hardware_watchpoint)
3842 gdb_assert (bl->owner->ops != NULL
3843 && bl->owner->ops->remove_location != NULL);
3845 bl->inserted = (reason == DETACH_BREAKPOINT);
3846 bl->owner->ops->remove_location (bl, reason);
3848 /* Failure to remove any of the hardware watchpoints comes here. */
3849 if (reason == REMOVE_BREAKPOINT && bl->inserted)
3850 warning (_("Could not remove hardware watchpoint %d."),
3853 else if (bl->owner->type == bp_catchpoint
3854 && breakpoint_enabled (bl->owner)
3857 gdb_assert (bl->owner->ops != NULL
3858 && bl->owner->ops->remove_location != NULL);
3860 val = bl->owner->ops->remove_location (bl, reason);
3864 bl->inserted = (reason == DETACH_BREAKPOINT);
3871 remove_breakpoint (struct bp_location *bl)
3873 /* BL is never in moribund_locations by our callers. */
3874 gdb_assert (bl->owner != NULL);
3876 /* The type of none suggests that owner is actually deleted.
3877 This should not ever happen. */
3878 gdb_assert (bl->owner->type != bp_none);
3880 scoped_restore_current_pspace_and_thread restore_pspace_thread;
3882 switch_to_program_space_and_thread (bl->pspace);
3884 return remove_breakpoint_1 (bl, REMOVE_BREAKPOINT);
3887 /* Clear the "inserted" flag in all breakpoints. */
3890 mark_breakpoints_out (void)
3892 struct bp_location *bl, **blp_tmp;
3894 ALL_BP_LOCATIONS (bl, blp_tmp)
3895 if (bl->pspace == current_program_space)
3899 /* Clear the "inserted" flag in all breakpoints and delete any
3900 breakpoints which should go away between runs of the program.
3902 Plus other such housekeeping that has to be done for breakpoints
3905 Note: this function gets called at the end of a run (by
3906 generic_mourn_inferior) and when a run begins (by
3907 init_wait_for_inferior). */
3912 breakpoint_init_inferior (enum inf_context context)
3914 struct breakpoint *b, *b_tmp;
3915 struct bp_location *bl;
3917 struct program_space *pspace = current_program_space;
3919 /* If breakpoint locations are shared across processes, then there's
3921 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
3924 mark_breakpoints_out ();
3926 ALL_BREAKPOINTS_SAFE (b, b_tmp)
3928 if (b->loc && b->loc->pspace != pspace)
3934 case bp_longjmp_call_dummy:
3936 /* If the call dummy breakpoint is at the entry point it will
3937 cause problems when the inferior is rerun, so we better get
3940 case bp_watchpoint_scope:
3942 /* Also get rid of scope breakpoints. */
3944 case bp_shlib_event:
3946 /* Also remove solib event breakpoints. Their addresses may
3947 have changed since the last time we ran the program.
3948 Actually we may now be debugging against different target;
3949 and so the solib backend that installed this breakpoint may
3950 not be used in by the target. E.g.,
3952 (gdb) file prog-linux
3953 (gdb) run # native linux target
3956 (gdb) file prog-win.exe
3957 (gdb) tar rem :9999 # remote Windows gdbserver.
3960 case bp_step_resume:
3962 /* Also remove step-resume breakpoints. */
3964 case bp_single_step:
3966 /* Also remove single-step breakpoints. */
3968 delete_breakpoint (b);
3972 case bp_hardware_watchpoint:
3973 case bp_read_watchpoint:
3974 case bp_access_watchpoint:
3976 struct watchpoint *w = (struct watchpoint *) b;
3978 /* Likewise for watchpoints on local expressions. */
3979 if (w->exp_valid_block != NULL)
3980 delete_breakpoint (b);
3983 /* Get rid of existing locations, which are no longer
3984 valid. New ones will be created in
3985 update_watchpoint, when the inferior is restarted.
3986 The next update_global_location_list call will
3987 garbage collect them. */
3990 if (context == inf_starting)
3992 /* Reset val field to force reread of starting value in
3993 insert_breakpoints. */
3995 value_free (w->val);
4007 /* Get rid of the moribund locations. */
4008 for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, bl); ++ix)
4009 decref_bp_location (&bl);
4010 VEC_free (bp_location_p, moribund_locations);
4013 /* These functions concern about actual breakpoints inserted in the
4014 target --- to e.g. check if we need to do decr_pc adjustment or if
4015 we need to hop over the bkpt --- so we check for address space
4016 match, not program space. */
4018 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
4019 exists at PC. It returns ordinary_breakpoint_here if it's an
4020 ordinary breakpoint, or permanent_breakpoint_here if it's a
4021 permanent breakpoint.
4022 - When continuing from a location with an ordinary breakpoint, we
4023 actually single step once before calling insert_breakpoints.
4024 - When continuing from a location with a permanent breakpoint, we
4025 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
4026 the target, to advance the PC past the breakpoint. */
4028 enum breakpoint_here
4029 breakpoint_here_p (const address_space *aspace, CORE_ADDR pc)
4031 struct bp_location *bl, **blp_tmp;
4032 int any_breakpoint_here = 0;
4034 ALL_BP_LOCATIONS (bl, blp_tmp)
4036 if (bl->loc_type != bp_loc_software_breakpoint
4037 && bl->loc_type != bp_loc_hardware_breakpoint)
4040 /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
4041 if ((breakpoint_enabled (bl->owner)
4043 && breakpoint_location_address_match (bl, aspace, pc))
4045 if (overlay_debugging
4046 && section_is_overlay (bl->section)
4047 && !section_is_mapped (bl->section))
4048 continue; /* unmapped overlay -- can't be a match */
4049 else if (bl->permanent)
4050 return permanent_breakpoint_here;
4052 any_breakpoint_here = 1;
4056 return any_breakpoint_here ? ordinary_breakpoint_here : no_breakpoint_here;
4059 /* See breakpoint.h. */
4062 breakpoint_in_range_p (const address_space *aspace,
4063 CORE_ADDR addr, ULONGEST len)
4065 struct bp_location *bl, **blp_tmp;
4067 ALL_BP_LOCATIONS (bl, blp_tmp)
4069 if (bl->loc_type != bp_loc_software_breakpoint
4070 && bl->loc_type != bp_loc_hardware_breakpoint)
4073 if ((breakpoint_enabled (bl->owner)
4075 && breakpoint_location_address_range_overlap (bl, aspace,
4078 if (overlay_debugging
4079 && section_is_overlay (bl->section)
4080 && !section_is_mapped (bl->section))
4082 /* Unmapped overlay -- can't be a match. */
4093 /* Return true if there's a moribund breakpoint at PC. */
4096 moribund_breakpoint_here_p (const address_space *aspace, CORE_ADDR pc)
4098 struct bp_location *loc;
4101 for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
4102 if (breakpoint_location_address_match (loc, aspace, pc))
4108 /* Returns non-zero iff BL is inserted at PC, in address space
4112 bp_location_inserted_here_p (struct bp_location *bl,
4113 const address_space *aspace, CORE_ADDR pc)
4116 && breakpoint_address_match (bl->pspace->aspace, bl->address,
4119 if (overlay_debugging
4120 && section_is_overlay (bl->section)
4121 && !section_is_mapped (bl->section))
4122 return 0; /* unmapped overlay -- can't be a match */
4129 /* Returns non-zero iff there's a breakpoint inserted at PC. */
4132 breakpoint_inserted_here_p (const address_space *aspace, CORE_ADDR pc)
4134 struct bp_location **blp, **blp_tmp = NULL;
4136 ALL_BP_LOCATIONS_AT_ADDR (blp, blp_tmp, pc)
4138 struct bp_location *bl = *blp;
4140 if (bl->loc_type != bp_loc_software_breakpoint
4141 && bl->loc_type != bp_loc_hardware_breakpoint)
4144 if (bp_location_inserted_here_p (bl, aspace, pc))
4150 /* This function returns non-zero iff there is a software breakpoint
4154 software_breakpoint_inserted_here_p (const address_space *aspace,
4157 struct bp_location **blp, **blp_tmp = NULL;
4159 ALL_BP_LOCATIONS_AT_ADDR (blp, blp_tmp, pc)
4161 struct bp_location *bl = *blp;
4163 if (bl->loc_type != bp_loc_software_breakpoint)
4166 if (bp_location_inserted_here_p (bl, aspace, pc))
4173 /* See breakpoint.h. */
4176 hardware_breakpoint_inserted_here_p (const address_space *aspace,
4179 struct bp_location **blp, **blp_tmp = NULL;
4181 ALL_BP_LOCATIONS_AT_ADDR (blp, blp_tmp, pc)
4183 struct bp_location *bl = *blp;
4185 if (bl->loc_type != bp_loc_hardware_breakpoint)
4188 if (bp_location_inserted_here_p (bl, aspace, pc))
4196 hardware_watchpoint_inserted_in_range (const address_space *aspace,
4197 CORE_ADDR addr, ULONGEST len)
4199 struct breakpoint *bpt;
4201 ALL_BREAKPOINTS (bpt)
4203 struct bp_location *loc;
4205 if (bpt->type != bp_hardware_watchpoint
4206 && bpt->type != bp_access_watchpoint)
4209 if (!breakpoint_enabled (bpt))
4212 for (loc = bpt->loc; loc; loc = loc->next)
4213 if (loc->pspace->aspace == aspace && loc->inserted)
4217 /* Check for intersection. */
4218 l = std::max<CORE_ADDR> (loc->address, addr);
4219 h = std::min<CORE_ADDR> (loc->address + loc->length, addr + len);
4228 /* bpstat stuff. External routines' interfaces are documented
4232 is_catchpoint (struct breakpoint *ep)
4234 return (ep->type == bp_catchpoint);
4237 /* Frees any storage that is part of a bpstat. Does not walk the
4240 bpstats::~bpstats ()
4242 if (old_val != NULL)
4243 value_free (old_val);
4244 if (bp_location_at != NULL)
4245 decref_bp_location (&bp_location_at);
4248 /* Clear a bpstat so that it says we are not at any breakpoint.
4249 Also free any storage that is part of a bpstat. */
4252 bpstat_clear (bpstat *bsp)
4269 bpstats::bpstats (const bpstats &other)
4271 bp_location_at (other.bp_location_at),
4272 breakpoint_at (other.breakpoint_at),
4273 commands (other.commands),
4274 old_val (other.old_val),
4275 print (other.print),
4277 print_it (other.print_it)
4279 if (old_val != NULL)
4281 old_val = value_copy (old_val);
4282 release_value (old_val);
4284 incref_bp_location (bp_location_at);
4287 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
4288 is part of the bpstat is copied as well. */
4291 bpstat_copy (bpstat bs)
4295 bpstat retval = NULL;
4300 for (; bs != NULL; bs = bs->next)
4302 tmp = new bpstats (*bs);
4305 /* This is the first thing in the chain. */
4315 /* Find the bpstat associated with this breakpoint. */
4318 bpstat_find_breakpoint (bpstat bsp, struct breakpoint *breakpoint)
4323 for (; bsp != NULL; bsp = bsp->next)
4325 if (bsp->breakpoint_at == breakpoint)
4331 /* See breakpoint.h. */
4334 bpstat_explains_signal (bpstat bsp, enum gdb_signal sig)
4336 for (; bsp != NULL; bsp = bsp->next)
4338 if (bsp->breakpoint_at == NULL)
4340 /* A moribund location can never explain a signal other than
4342 if (sig == GDB_SIGNAL_TRAP)
4347 if (bsp->breakpoint_at->ops->explains_signal (bsp->breakpoint_at,
4356 /* Put in *NUM the breakpoint number of the first breakpoint we are
4357 stopped at. *BSP upon return is a bpstat which points to the
4358 remaining breakpoints stopped at (but which is not guaranteed to be
4359 good for anything but further calls to bpstat_num).
4361 Return 0 if passed a bpstat which does not indicate any breakpoints.
4362 Return -1 if stopped at a breakpoint that has been deleted since
4364 Return 1 otherwise. */
4367 bpstat_num (bpstat *bsp, int *num)
4369 struct breakpoint *b;
4372 return 0; /* No more breakpoint values */
4374 /* We assume we'll never have several bpstats that correspond to a
4375 single breakpoint -- otherwise, this function might return the
4376 same number more than once and this will look ugly. */
4377 b = (*bsp)->breakpoint_at;
4378 *bsp = (*bsp)->next;
4380 return -1; /* breakpoint that's been deleted since */
4382 *num = b->number; /* We have its number */
4386 /* See breakpoint.h. */
4389 bpstat_clear_actions (void)
4391 struct thread_info *tp;
4394 if (ptid_equal (inferior_ptid, null_ptid))
4397 tp = find_thread_ptid (inferior_ptid);
4401 for (bs = tp->control.stop_bpstat; bs != NULL; bs = bs->next)
4403 bs->commands = NULL;
4405 if (bs->old_val != NULL)
4407 value_free (bs->old_val);
4413 /* Called when a command is about to proceed the inferior. */
4416 breakpoint_about_to_proceed (void)
4418 if (!ptid_equal (inferior_ptid, null_ptid))
4420 struct thread_info *tp = inferior_thread ();
4422 /* Allow inferior function calls in breakpoint commands to not
4423 interrupt the command list. When the call finishes
4424 successfully, the inferior will be standing at the same
4425 breakpoint as if nothing happened. */
4426 if (tp->control.in_infcall)
4430 breakpoint_proceeded = 1;
4433 /* Return non-zero iff CMD as the first line of a command sequence is `silent'
4434 or its equivalent. */
4437 command_line_is_silent (struct command_line *cmd)
4439 return cmd && (strcmp ("silent", cmd->line) == 0);
4442 /* Execute all the commands associated with all the breakpoints at
4443 this location. Any of these commands could cause the process to
4444 proceed beyond this point, etc. We look out for such changes by
4445 checking the global "breakpoint_proceeded" after each command.
4447 Returns true if a breakpoint command resumed the inferior. In that
4448 case, it is the caller's responsibility to recall it again with the
4449 bpstat of the current thread. */
4452 bpstat_do_actions_1 (bpstat *bsp)
4457 /* Avoid endless recursion if a `source' command is contained
4459 if (executing_breakpoint_commands)
4462 scoped_restore save_executing
4463 = make_scoped_restore (&executing_breakpoint_commands, 1);
4465 scoped_restore preventer = prevent_dont_repeat ();
4467 /* This pointer will iterate over the list of bpstat's. */
4470 breakpoint_proceeded = 0;
4471 for (; bs != NULL; bs = bs->next)
4473 struct command_line *cmd = NULL;
4475 /* Take ownership of the BSP's command tree, if it has one.
4477 The command tree could legitimately contain commands like
4478 'step' and 'next', which call clear_proceed_status, which
4479 frees stop_bpstat's command tree. To make sure this doesn't
4480 free the tree we're executing out from under us, we need to
4481 take ownership of the tree ourselves. Since a given bpstat's
4482 commands are only executed once, we don't need to copy it; we
4483 can clear the pointer in the bpstat, and make sure we free
4484 the tree when we're done. */
4485 counted_command_line ccmd = bs->commands;
4486 bs->commands = NULL;
4489 if (command_line_is_silent (cmd))
4491 /* The action has been already done by bpstat_stop_status. */
4497 execute_control_command (cmd);
4499 if (breakpoint_proceeded)
4505 if (breakpoint_proceeded)
4507 if (current_ui->async)
4508 /* If we are in async mode, then the target might be still
4509 running, not stopped at any breakpoint, so nothing for
4510 us to do here -- just return to the event loop. */
4513 /* In sync mode, when execute_control_command returns
4514 we're already standing on the next breakpoint.
4515 Breakpoint commands for that stop were not run, since
4516 execute_command does not run breakpoint commands --
4517 only command_line_handler does, but that one is not
4518 involved in execution of breakpoint commands. So, we
4519 can now execute breakpoint commands. It should be
4520 noted that making execute_command do bpstat actions is
4521 not an option -- in this case we'll have recursive
4522 invocation of bpstat for each breakpoint with a
4523 command, and can easily blow up GDB stack. Instead, we
4524 return true, which will trigger the caller to recall us
4525 with the new stop_bpstat. */
4534 bpstat_do_actions (void)
4536 struct cleanup *cleanup_if_error = make_bpstat_clear_actions_cleanup ();
4538 /* Do any commands attached to breakpoint we are stopped at. */
4539 while (!ptid_equal (inferior_ptid, null_ptid)
4540 && target_has_execution
4541 && !is_exited (inferior_ptid)
4542 && !is_executing (inferior_ptid))
4543 /* Since in sync mode, bpstat_do_actions may resume the inferior,
4544 and only return when it is stopped at the next breakpoint, we
4545 keep doing breakpoint actions until it returns false to
4546 indicate the inferior was not resumed. */
4547 if (!bpstat_do_actions_1 (&inferior_thread ()->control.stop_bpstat))
4550 discard_cleanups (cleanup_if_error);
4553 /* Print out the (old or new) value associated with a watchpoint. */
4556 watchpoint_value_print (struct value *val, struct ui_file *stream)
4559 fprintf_unfiltered (stream, _("<unreadable>"));
4562 struct value_print_options opts;
4563 get_user_print_options (&opts);
4564 value_print (val, stream, &opts);
4568 /* Print the "Thread ID hit" part of "Thread ID hit Breakpoint N" if
4569 debugging multiple threads. */
4572 maybe_print_thread_hit_breakpoint (struct ui_out *uiout)
4574 if (uiout->is_mi_like_p ())
4579 if (show_thread_that_caused_stop ())
4582 struct thread_info *thr = inferior_thread ();
4584 uiout->text ("Thread ");
4585 uiout->field_fmt ("thread-id", "%s", print_thread_id (thr));
4587 name = thr->name != NULL ? thr->name : target_thread_name (thr);
4590 uiout->text (" \"");
4591 uiout->field_fmt ("name", "%s", name);
4595 uiout->text (" hit ");
4599 /* Generic routine for printing messages indicating why we
4600 stopped. The behavior of this function depends on the value
4601 'print_it' in the bpstat structure. Under some circumstances we
4602 may decide not to print anything here and delegate the task to
4605 static enum print_stop_action
4606 print_bp_stop_message (bpstat bs)
4608 switch (bs->print_it)
4611 /* Nothing should be printed for this bpstat entry. */
4612 return PRINT_UNKNOWN;
4616 /* We still want to print the frame, but we already printed the
4617 relevant messages. */
4618 return PRINT_SRC_AND_LOC;
4621 case print_it_normal:
4623 struct breakpoint *b = bs->breakpoint_at;
4625 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
4626 which has since been deleted. */
4628 return PRINT_UNKNOWN;
4630 /* Normal case. Call the breakpoint's print_it method. */
4631 return b->ops->print_it (bs);
4636 internal_error (__FILE__, __LINE__,
4637 _("print_bp_stop_message: unrecognized enum value"));
4642 /* A helper function that prints a shared library stopped event. */
4645 print_solib_event (int is_catchpoint)
4648 = !VEC_empty (char_ptr, current_program_space->deleted_solibs);
4650 = !VEC_empty (so_list_ptr, current_program_space->added_solibs);
4654 if (any_added || any_deleted)
4655 current_uiout->text (_("Stopped due to shared library event:\n"));
4657 current_uiout->text (_("Stopped due to shared library event (no "
4658 "libraries added or removed)\n"));
4661 if (current_uiout->is_mi_like_p ())
4662 current_uiout->field_string ("reason",
4663 async_reason_lookup (EXEC_ASYNC_SOLIB_EVENT));
4670 current_uiout->text (_(" Inferior unloaded "));
4671 ui_out_emit_list list_emitter (current_uiout, "removed");
4673 VEC_iterate (char_ptr, current_program_space->deleted_solibs,
4678 current_uiout->text (" ");
4679 current_uiout->field_string ("library", name);
4680 current_uiout->text ("\n");
4686 struct so_list *iter;
4689 current_uiout->text (_(" Inferior loaded "));
4690 ui_out_emit_list list_emitter (current_uiout, "added");
4692 VEC_iterate (so_list_ptr, current_program_space->added_solibs,
4697 current_uiout->text (" ");
4698 current_uiout->field_string ("library", iter->so_name);
4699 current_uiout->text ("\n");
4704 /* Print a message indicating what happened. This is called from
4705 normal_stop(). The input to this routine is the head of the bpstat
4706 list - a list of the eventpoints that caused this stop. KIND is
4707 the target_waitkind for the stopping event. This
4708 routine calls the generic print routine for printing a message
4709 about reasons for stopping. This will print (for example) the
4710 "Breakpoint n," part of the output. The return value of this
4713 PRINT_UNKNOWN: Means we printed nothing.
4714 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
4715 code to print the location. An example is
4716 "Breakpoint 1, " which should be followed by
4718 PRINT_SRC_ONLY: Means we printed something, but there is no need
4719 to also print the location part of the message.
4720 An example is the catch/throw messages, which
4721 don't require a location appended to the end.
4722 PRINT_NOTHING: We have done some printing and we don't need any
4723 further info to be printed. */
4725 enum print_stop_action
4726 bpstat_print (bpstat bs, int kind)
4728 enum print_stop_action val;
4730 /* Maybe another breakpoint in the chain caused us to stop.
4731 (Currently all watchpoints go on the bpstat whether hit or not.
4732 That probably could (should) be changed, provided care is taken
4733 with respect to bpstat_explains_signal). */
4734 for (; bs; bs = bs->next)
4736 val = print_bp_stop_message (bs);
4737 if (val == PRINT_SRC_ONLY
4738 || val == PRINT_SRC_AND_LOC
4739 || val == PRINT_NOTHING)
4743 /* If we had hit a shared library event breakpoint,
4744 print_bp_stop_message would print out this message. If we hit an
4745 OS-level shared library event, do the same thing. */
4746 if (kind == TARGET_WAITKIND_LOADED)
4748 print_solib_event (0);
4749 return PRINT_NOTHING;
4752 /* We reached the end of the chain, or we got a null BS to start
4753 with and nothing was printed. */
4754 return PRINT_UNKNOWN;
4757 /* Evaluate the boolean expression EXP and return the result. */
4760 breakpoint_cond_eval (expression *exp)
4762 struct value *mark = value_mark ();
4763 bool res = value_true (evaluate_expression (exp));
4765 value_free_to_mark (mark);
4769 /* Allocate a new bpstat. Link it to the FIFO list by BS_LINK_POINTER. */
4771 bpstats::bpstats (struct bp_location *bl, bpstat **bs_link_pointer)
4773 bp_location_at (bl),
4774 breakpoint_at (bl->owner),
4779 print_it (print_it_normal)
4781 incref_bp_location (bl);
4782 **bs_link_pointer = this;
4783 *bs_link_pointer = &next;
4788 bp_location_at (NULL),
4789 breakpoint_at (NULL),
4794 print_it (print_it_normal)
4798 /* The target has stopped with waitstatus WS. Check if any hardware
4799 watchpoints have triggered, according to the target. */
4802 watchpoints_triggered (struct target_waitstatus *ws)
4804 int stopped_by_watchpoint = target_stopped_by_watchpoint ();
4806 struct breakpoint *b;
4808 if (!stopped_by_watchpoint)
4810 /* We were not stopped by a watchpoint. Mark all watchpoints
4811 as not triggered. */
4813 if (is_hardware_watchpoint (b))
4815 struct watchpoint *w = (struct watchpoint *) b;
4817 w->watchpoint_triggered = watch_triggered_no;
4823 if (!target_stopped_data_address (¤t_target, &addr))
4825 /* We were stopped by a watchpoint, but we don't know where.
4826 Mark all watchpoints as unknown. */
4828 if (is_hardware_watchpoint (b))
4830 struct watchpoint *w = (struct watchpoint *) b;
4832 w->watchpoint_triggered = watch_triggered_unknown;
4838 /* The target could report the data address. Mark watchpoints
4839 affected by this data address as triggered, and all others as not
4843 if (is_hardware_watchpoint (b))
4845 struct watchpoint *w = (struct watchpoint *) b;
4846 struct bp_location *loc;
4848 w->watchpoint_triggered = watch_triggered_no;
4849 for (loc = b->loc; loc; loc = loc->next)
4851 if (is_masked_watchpoint (b))
4853 CORE_ADDR newaddr = addr & w->hw_wp_mask;
4854 CORE_ADDR start = loc->address & w->hw_wp_mask;
4856 if (newaddr == start)
4858 w->watchpoint_triggered = watch_triggered_yes;
4862 /* Exact match not required. Within range is sufficient. */
4863 else if (target_watchpoint_addr_within_range (¤t_target,
4867 w->watchpoint_triggered = watch_triggered_yes;
4876 /* Possible return values for watchpoint_check. */
4877 enum wp_check_result
4879 /* The watchpoint has been deleted. */
4882 /* The value has changed. */
4883 WP_VALUE_CHANGED = 2,
4885 /* The value has not changed. */
4886 WP_VALUE_NOT_CHANGED = 3,
4888 /* Ignore this watchpoint, no matter if the value changed or not. */
4892 #define BP_TEMPFLAG 1
4893 #define BP_HARDWAREFLAG 2
4895 /* Evaluate watchpoint condition expression and check if its value
4898 static wp_check_result
4899 watchpoint_check (bpstat bs)
4901 struct watchpoint *b;
4902 struct frame_info *fr;
4903 int within_current_scope;
4905 /* BS is built from an existing struct breakpoint. */
4906 gdb_assert (bs->breakpoint_at != NULL);
4907 b = (struct watchpoint *) bs->breakpoint_at;
4909 /* If this is a local watchpoint, we only want to check if the
4910 watchpoint frame is in scope if the current thread is the thread
4911 that was used to create the watchpoint. */
4912 if (!watchpoint_in_thread_scope (b))
4915 if (b->exp_valid_block == NULL)
4916 within_current_scope = 1;
4919 struct frame_info *frame = get_current_frame ();
4920 struct gdbarch *frame_arch = get_frame_arch (frame);
4921 CORE_ADDR frame_pc = get_frame_pc (frame);
4923 /* stack_frame_destroyed_p() returns a non-zero value if we're
4924 still in the function but the stack frame has already been
4925 invalidated. Since we can't rely on the values of local
4926 variables after the stack has been destroyed, we are treating
4927 the watchpoint in that state as `not changed' without further
4928 checking. Don't mark watchpoints as changed if the current
4929 frame is in an epilogue - even if they are in some other
4930 frame, our view of the stack is likely to be wrong and
4931 frame_find_by_id could error out. */
4932 if (gdbarch_stack_frame_destroyed_p (frame_arch, frame_pc))
4935 fr = frame_find_by_id (b->watchpoint_frame);
4936 within_current_scope = (fr != NULL);
4938 /* If we've gotten confused in the unwinder, we might have
4939 returned a frame that can't describe this variable. */
4940 if (within_current_scope)
4942 struct symbol *function;
4944 function = get_frame_function (fr);
4945 if (function == NULL
4946 || !contained_in (b->exp_valid_block,
4947 SYMBOL_BLOCK_VALUE (function)))
4948 within_current_scope = 0;
4951 if (within_current_scope)
4952 /* If we end up stopping, the current frame will get selected
4953 in normal_stop. So this call to select_frame won't affect
4958 if (within_current_scope)
4960 /* We use value_{,free_to_}mark because it could be a *long*
4961 time before we return to the command level and call
4962 free_all_values. We can't call free_all_values because we
4963 might be in the middle of evaluating a function call. */
4967 struct value *new_val;
4969 if (is_masked_watchpoint (b))
4970 /* Since we don't know the exact trigger address (from
4971 stopped_data_address), just tell the user we've triggered
4972 a mask watchpoint. */
4973 return WP_VALUE_CHANGED;
4975 mark = value_mark ();
4976 fetch_subexp_value (b->exp.get (), &pc, &new_val, NULL, NULL, 0);
4978 if (b->val_bitsize != 0)
4979 new_val = extract_bitfield_from_watchpoint_value (b, new_val);
4981 /* We use value_equal_contents instead of value_equal because
4982 the latter coerces an array to a pointer, thus comparing just
4983 the address of the array instead of its contents. This is
4984 not what we want. */
4985 if ((b->val != NULL) != (new_val != NULL)
4986 || (b->val != NULL && !value_equal_contents (b->val, new_val)))
4988 if (new_val != NULL)
4990 release_value (new_val);
4991 value_free_to_mark (mark);
4993 bs->old_val = b->val;
4996 return WP_VALUE_CHANGED;
5000 /* Nothing changed. */
5001 value_free_to_mark (mark);
5002 return WP_VALUE_NOT_CHANGED;
5007 /* This seems like the only logical thing to do because
5008 if we temporarily ignored the watchpoint, then when
5009 we reenter the block in which it is valid it contains
5010 garbage (in the case of a function, it may have two
5011 garbage values, one before and one after the prologue).
5012 So we can't even detect the first assignment to it and
5013 watch after that (since the garbage may or may not equal
5014 the first value assigned). */
5015 /* We print all the stop information in
5016 breakpoint_ops->print_it, but in this case, by the time we
5017 call breakpoint_ops->print_it this bp will be deleted
5018 already. So we have no choice but print the information
5021 SWITCH_THRU_ALL_UIS ()
5023 struct ui_out *uiout = current_uiout;
5025 if (uiout->is_mi_like_p ())
5027 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE));
5028 uiout->text ("\nWatchpoint ");
5029 uiout->field_int ("wpnum", b->number);
5030 uiout->text (" deleted because the program has left the block in\n"
5031 "which its expression is valid.\n");
5034 /* Make sure the watchpoint's commands aren't executed. */
5036 watchpoint_del_at_next_stop (b);
5042 /* Return true if it looks like target has stopped due to hitting
5043 breakpoint location BL. This function does not check if we should
5044 stop, only if BL explains the stop. */
5047 bpstat_check_location (const struct bp_location *bl,
5048 const address_space *aspace, CORE_ADDR bp_addr,
5049 const struct target_waitstatus *ws)
5051 struct breakpoint *b = bl->owner;
5053 /* BL is from an existing breakpoint. */
5054 gdb_assert (b != NULL);
5056 return b->ops->breakpoint_hit (bl, aspace, bp_addr, ws);
5059 /* Determine if the watched values have actually changed, and we
5060 should stop. If not, set BS->stop to 0. */
5063 bpstat_check_watchpoint (bpstat bs)
5065 const struct bp_location *bl;
5066 struct watchpoint *b;
5068 /* BS is built for existing struct breakpoint. */
5069 bl = bs->bp_location_at;
5070 gdb_assert (bl != NULL);
5071 b = (struct watchpoint *) bs->breakpoint_at;
5072 gdb_assert (b != NULL);
5075 int must_check_value = 0;
5077 if (b->type == bp_watchpoint)
5078 /* For a software watchpoint, we must always check the
5080 must_check_value = 1;
5081 else if (b->watchpoint_triggered == watch_triggered_yes)
5082 /* We have a hardware watchpoint (read, write, or access)
5083 and the target earlier reported an address watched by
5085 must_check_value = 1;
5086 else if (b->watchpoint_triggered == watch_triggered_unknown
5087 && b->type == bp_hardware_watchpoint)
5088 /* We were stopped by a hardware watchpoint, but the target could
5089 not report the data address. We must check the watchpoint's
5090 value. Access and read watchpoints are out of luck; without
5091 a data address, we can't figure it out. */
5092 must_check_value = 1;
5094 if (must_check_value)
5100 e = watchpoint_check (bs);
5102 CATCH (ex, RETURN_MASK_ALL)
5104 exception_fprintf (gdb_stderr, ex,
5105 "Error evaluating expression "
5106 "for watchpoint %d\n",
5109 SWITCH_THRU_ALL_UIS ()
5111 printf_filtered (_("Watchpoint %d deleted.\n"),
5114 watchpoint_del_at_next_stop (b);
5122 /* We've already printed what needs to be printed. */
5123 bs->print_it = print_it_done;
5127 bs->print_it = print_it_noop;
5130 case WP_VALUE_CHANGED:
5131 if (b->type == bp_read_watchpoint)
5133 /* There are two cases to consider here:
5135 1. We're watching the triggered memory for reads.
5136 In that case, trust the target, and always report
5137 the watchpoint hit to the user. Even though
5138 reads don't cause value changes, the value may
5139 have changed since the last time it was read, and
5140 since we're not trapping writes, we will not see
5141 those, and as such we should ignore our notion of
5144 2. We're watching the triggered memory for both
5145 reads and writes. There are two ways this may
5148 2.1. This is a target that can't break on data
5149 reads only, but can break on accesses (reads or
5150 writes), such as e.g., x86. We detect this case
5151 at the time we try to insert read watchpoints.
5153 2.2. Otherwise, the target supports read
5154 watchpoints, but, the user set an access or write
5155 watchpoint watching the same memory as this read
5158 If we're watching memory writes as well as reads,
5159 ignore watchpoint hits when we find that the
5160 value hasn't changed, as reads don't cause
5161 changes. This still gives false positives when
5162 the program writes the same value to memory as
5163 what there was already in memory (we will confuse
5164 it for a read), but it's much better than
5167 int other_write_watchpoint = 0;
5169 if (bl->watchpoint_type == hw_read)
5171 struct breakpoint *other_b;
5173 ALL_BREAKPOINTS (other_b)
5174 if (other_b->type == bp_hardware_watchpoint
5175 || other_b->type == bp_access_watchpoint)
5177 struct watchpoint *other_w =
5178 (struct watchpoint *) other_b;
5180 if (other_w->watchpoint_triggered
5181 == watch_triggered_yes)
5183 other_write_watchpoint = 1;
5189 if (other_write_watchpoint
5190 || bl->watchpoint_type == hw_access)
5192 /* We're watching the same memory for writes,
5193 and the value changed since the last time we
5194 updated it, so this trap must be for a write.
5196 bs->print_it = print_it_noop;
5201 case WP_VALUE_NOT_CHANGED:
5202 if (b->type == bp_hardware_watchpoint
5203 || b->type == bp_watchpoint)
5205 /* Don't stop: write watchpoints shouldn't fire if
5206 the value hasn't changed. */
5207 bs->print_it = print_it_noop;
5217 else /* must_check_value == 0 */
5219 /* This is a case where some watchpoint(s) triggered, but
5220 not at the address of this watchpoint, or else no
5221 watchpoint triggered after all. So don't print
5222 anything for this watchpoint. */
5223 bs->print_it = print_it_noop;
5229 /* For breakpoints that are currently marked as telling gdb to stop,
5230 check conditions (condition proper, frame, thread and ignore count)
5231 of breakpoint referred to by BS. If we should not stop for this
5232 breakpoint, set BS->stop to 0. */
5235 bpstat_check_breakpoint_conditions (bpstat bs, ptid_t ptid)
5237 const struct bp_location *bl;
5238 struct breakpoint *b;
5240 bool condition_result = true;
5241 struct expression *cond;
5243 gdb_assert (bs->stop);
5245 /* BS is built for existing struct breakpoint. */
5246 bl = bs->bp_location_at;
5247 gdb_assert (bl != NULL);
5248 b = bs->breakpoint_at;
5249 gdb_assert (b != NULL);
5251 /* Even if the target evaluated the condition on its end and notified GDB, we
5252 need to do so again since GDB does not know if we stopped due to a
5253 breakpoint or a single step breakpoint. */
5255 if (frame_id_p (b->frame_id)
5256 && !frame_id_eq (b->frame_id, get_stack_frame_id (get_current_frame ())))
5262 /* If this is a thread/task-specific breakpoint, don't waste cpu
5263 evaluating the condition if this isn't the specified
5265 if ((b->thread != -1 && b->thread != ptid_to_global_thread_id (ptid))
5266 || (b->task != 0 && b->task != ada_get_task_number (ptid)))
5273 /* Evaluate extension language breakpoints that have a "stop" method
5275 bs->stop = breakpoint_ext_lang_cond_says_stop (b);
5277 if (is_watchpoint (b))
5279 struct watchpoint *w = (struct watchpoint *) b;
5281 cond = w->cond_exp.get ();
5284 cond = bl->cond.get ();
5286 if (cond && b->disposition != disp_del_at_next_stop)
5288 int within_current_scope = 1;
5289 struct watchpoint * w;
5291 /* We use value_mark and value_free_to_mark because it could
5292 be a long time before we return to the command level and
5293 call free_all_values. We can't call free_all_values
5294 because we might be in the middle of evaluating a
5296 struct value *mark = value_mark ();
5298 if (is_watchpoint (b))
5299 w = (struct watchpoint *) b;
5303 /* Need to select the frame, with all that implies so that
5304 the conditions will have the right context. Because we
5305 use the frame, we will not see an inlined function's
5306 variables when we arrive at a breakpoint at the start
5307 of the inlined function; the current frame will be the
5309 if (w == NULL || w->cond_exp_valid_block == NULL)
5310 select_frame (get_current_frame ());
5313 struct frame_info *frame;
5315 /* For local watchpoint expressions, which particular
5316 instance of a local is being watched matters, so we
5317 keep track of the frame to evaluate the expression
5318 in. To evaluate the condition however, it doesn't
5319 really matter which instantiation of the function
5320 where the condition makes sense triggers the
5321 watchpoint. This allows an expression like "watch
5322 global if q > 10" set in `func', catch writes to
5323 global on all threads that call `func', or catch
5324 writes on all recursive calls of `func' by a single
5325 thread. We simply always evaluate the condition in
5326 the innermost frame that's executing where it makes
5327 sense to evaluate the condition. It seems
5329 frame = block_innermost_frame (w->cond_exp_valid_block);
5331 select_frame (frame);
5333 within_current_scope = 0;
5335 if (within_current_scope)
5339 condition_result = breakpoint_cond_eval (cond);
5341 CATCH (ex, RETURN_MASK_ALL)
5343 exception_fprintf (gdb_stderr, ex,
5344 "Error in testing breakpoint condition:\n");
5350 warning (_("Watchpoint condition cannot be tested "
5351 "in the current scope"));
5352 /* If we failed to set the right context for this
5353 watchpoint, unconditionally report it. */
5355 /* FIXME-someday, should give breakpoint #. */
5356 value_free_to_mark (mark);
5359 if (cond && !condition_result)
5363 else if (b->ignore_count > 0)
5367 /* Increase the hit count even though we don't stop. */
5369 observer_notify_breakpoint_modified (b);
5373 /* Returns true if we need to track moribund locations of LOC's type
5374 on the current target. */
5377 need_moribund_for_location_type (struct bp_location *loc)
5379 return ((loc->loc_type == bp_loc_software_breakpoint
5380 && !target_supports_stopped_by_sw_breakpoint ())
5381 || (loc->loc_type == bp_loc_hardware_breakpoint
5382 && !target_supports_stopped_by_hw_breakpoint ()));
5386 /* Get a bpstat associated with having just stopped at address
5387 BP_ADDR in thread PTID.
5389 Determine whether we stopped at a breakpoint, etc, or whether we
5390 don't understand this stop. Result is a chain of bpstat's such
5393 if we don't understand the stop, the result is a null pointer.
5395 if we understand why we stopped, the result is not null.
5397 Each element of the chain refers to a particular breakpoint or
5398 watchpoint at which we have stopped. (We may have stopped for
5399 several reasons concurrently.)
5401 Each element of the chain has valid next, breakpoint_at,
5402 commands, FIXME??? fields. */
5405 bpstat_stop_status (const address_space *aspace,
5406 CORE_ADDR bp_addr, ptid_t ptid,
5407 const struct target_waitstatus *ws)
5409 struct breakpoint *b = NULL;
5410 struct bp_location *bl;
5411 struct bp_location *loc;
5412 /* First item of allocated bpstat's. */
5413 bpstat bs_head = NULL, *bs_link = &bs_head;
5414 /* Pointer to the last thing in the chain currently. */
5417 int need_remove_insert;
5420 /* First, build the bpstat chain with locations that explain a
5421 target stop, while being careful to not set the target running,
5422 as that may invalidate locations (in particular watchpoint
5423 locations are recreated). Resuming will happen here with
5424 breakpoint conditions or watchpoint expressions that include
5425 inferior function calls. */
5429 if (!breakpoint_enabled (b))
5432 for (bl = b->loc; bl != NULL; bl = bl->next)
5434 /* For hardware watchpoints, we look only at the first
5435 location. The watchpoint_check function will work on the
5436 entire expression, not the individual locations. For
5437 read watchpoints, the watchpoints_triggered function has
5438 checked all locations already. */
5439 if (b->type == bp_hardware_watchpoint && bl != b->loc)
5442 if (!bl->enabled || bl->shlib_disabled)
5445 if (!bpstat_check_location (bl, aspace, bp_addr, ws))
5448 /* Come here if it's a watchpoint, or if the break address
5451 bs = new bpstats (bl, &bs_link); /* Alloc a bpstat to
5454 /* Assume we stop. Should we find a watchpoint that is not
5455 actually triggered, or if the condition of the breakpoint
5456 evaluates as false, we'll reset 'stop' to 0. */
5460 /* If this is a scope breakpoint, mark the associated
5461 watchpoint as triggered so that we will handle the
5462 out-of-scope event. We'll get to the watchpoint next
5464 if (b->type == bp_watchpoint_scope && b->related_breakpoint != b)
5466 struct watchpoint *w = (struct watchpoint *) b->related_breakpoint;
5468 w->watchpoint_triggered = watch_triggered_yes;
5473 /* Check if a moribund breakpoint explains the stop. */
5474 if (!target_supports_stopped_by_sw_breakpoint ()
5475 || !target_supports_stopped_by_hw_breakpoint ())
5477 for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
5479 if (breakpoint_location_address_match (loc, aspace, bp_addr)
5480 && need_moribund_for_location_type (loc))
5482 bs = new bpstats (loc, &bs_link);
5483 /* For hits of moribund locations, we should just proceed. */
5486 bs->print_it = print_it_noop;
5491 /* A bit of special processing for shlib breakpoints. We need to
5492 process solib loading here, so that the lists of loaded and
5493 unloaded libraries are correct before we handle "catch load" and
5495 for (bs = bs_head; bs != NULL; bs = bs->next)
5497 if (bs->breakpoint_at && bs->breakpoint_at->type == bp_shlib_event)
5499 handle_solib_event ();
5504 /* Now go through the locations that caused the target to stop, and
5505 check whether we're interested in reporting this stop to higher
5506 layers, or whether we should resume the target transparently. */
5510 for (bs = bs_head; bs != NULL; bs = bs->next)
5515 b = bs->breakpoint_at;
5516 b->ops->check_status (bs);
5519 bpstat_check_breakpoint_conditions (bs, ptid);
5524 observer_notify_breakpoint_modified (b);
5526 /* We will stop here. */
5527 if (b->disposition == disp_disable)
5529 --(b->enable_count);
5530 if (b->enable_count <= 0)
5531 b->enable_state = bp_disabled;
5536 bs->commands = b->commands;
5537 if (command_line_is_silent (bs->commands
5538 ? bs->commands.get () : NULL))
5541 b->ops->after_condition_true (bs);
5546 /* Print nothing for this entry if we don't stop or don't
5548 if (!bs->stop || !bs->print)
5549 bs->print_it = print_it_noop;
5552 /* If we aren't stopping, the value of some hardware watchpoint may
5553 not have changed, but the intermediate memory locations we are
5554 watching may have. Don't bother if we're stopping; this will get
5556 need_remove_insert = 0;
5557 if (! bpstat_causes_stop (bs_head))
5558 for (bs = bs_head; bs != NULL; bs = bs->next)
5560 && bs->breakpoint_at
5561 && is_hardware_watchpoint (bs->breakpoint_at))
5563 struct watchpoint *w = (struct watchpoint *) bs->breakpoint_at;
5565 update_watchpoint (w, 0 /* don't reparse. */);
5566 need_remove_insert = 1;
5569 if (need_remove_insert)
5570 update_global_location_list (UGLL_MAY_INSERT);
5571 else if (removed_any)
5572 update_global_location_list (UGLL_DONT_INSERT);
5578 handle_jit_event (void)
5580 struct frame_info *frame;
5581 struct gdbarch *gdbarch;
5584 fprintf_unfiltered (gdb_stdlog, "handling bp_jit_event\n");
5586 /* Switch terminal for any messages produced by
5587 breakpoint_re_set. */
5588 target_terminal::ours_for_output ();
5590 frame = get_current_frame ();
5591 gdbarch = get_frame_arch (frame);
5593 jit_event_handler (gdbarch);
5595 target_terminal::inferior ();
5598 /* Prepare WHAT final decision for infrun. */
5600 /* Decide what infrun needs to do with this bpstat. */
5603 bpstat_what (bpstat bs_head)
5605 struct bpstat_what retval;
5608 retval.main_action = BPSTAT_WHAT_KEEP_CHECKING;
5609 retval.call_dummy = STOP_NONE;
5610 retval.is_longjmp = 0;
5612 for (bs = bs_head; bs != NULL; bs = bs->next)
5614 /* Extract this BS's action. After processing each BS, we check
5615 if its action overrides all we've seem so far. */
5616 enum bpstat_what_main_action this_action = BPSTAT_WHAT_KEEP_CHECKING;
5619 if (bs->breakpoint_at == NULL)
5621 /* I suspect this can happen if it was a momentary
5622 breakpoint which has since been deleted. */
5626 bptype = bs->breakpoint_at->type;
5633 case bp_hardware_breakpoint:
5634 case bp_single_step:
5637 case bp_shlib_event:
5641 this_action = BPSTAT_WHAT_STOP_NOISY;
5643 this_action = BPSTAT_WHAT_STOP_SILENT;
5646 this_action = BPSTAT_WHAT_SINGLE;
5649 case bp_hardware_watchpoint:
5650 case bp_read_watchpoint:
5651 case bp_access_watchpoint:
5655 this_action = BPSTAT_WHAT_STOP_NOISY;
5657 this_action = BPSTAT_WHAT_STOP_SILENT;
5661 /* There was a watchpoint, but we're not stopping.
5662 This requires no further action. */
5666 case bp_longjmp_call_dummy:
5670 this_action = BPSTAT_WHAT_SET_LONGJMP_RESUME;
5671 retval.is_longjmp = bptype != bp_exception;
5674 this_action = BPSTAT_WHAT_SINGLE;
5676 case bp_longjmp_resume:
5677 case bp_exception_resume:
5680 this_action = BPSTAT_WHAT_CLEAR_LONGJMP_RESUME;
5681 retval.is_longjmp = bptype == bp_longjmp_resume;
5684 this_action = BPSTAT_WHAT_SINGLE;
5686 case bp_step_resume:
5688 this_action = BPSTAT_WHAT_STEP_RESUME;
5691 /* It is for the wrong frame. */
5692 this_action = BPSTAT_WHAT_SINGLE;
5695 case bp_hp_step_resume:
5697 this_action = BPSTAT_WHAT_HP_STEP_RESUME;
5700 /* It is for the wrong frame. */
5701 this_action = BPSTAT_WHAT_SINGLE;
5704 case bp_watchpoint_scope:
5705 case bp_thread_event:
5706 case bp_overlay_event:
5707 case bp_longjmp_master:
5708 case bp_std_terminate_master:
5709 case bp_exception_master:
5710 this_action = BPSTAT_WHAT_SINGLE;
5716 this_action = BPSTAT_WHAT_STOP_NOISY;
5718 this_action = BPSTAT_WHAT_STOP_SILENT;
5722 /* There was a catchpoint, but we're not stopping.
5723 This requires no further action. */
5727 this_action = BPSTAT_WHAT_SINGLE;
5730 /* Make sure the action is stop (silent or noisy),
5731 so infrun.c pops the dummy frame. */
5732 retval.call_dummy = STOP_STACK_DUMMY;
5733 this_action = BPSTAT_WHAT_STOP_SILENT;
5735 case bp_std_terminate:
5736 /* Make sure the action is stop (silent or noisy),
5737 so infrun.c pops the dummy frame. */
5738 retval.call_dummy = STOP_STD_TERMINATE;
5739 this_action = BPSTAT_WHAT_STOP_SILENT;
5742 case bp_fast_tracepoint:
5743 case bp_static_tracepoint:
5744 /* Tracepoint hits should not be reported back to GDB, and
5745 if one got through somehow, it should have been filtered
5747 internal_error (__FILE__, __LINE__,
5748 _("bpstat_what: tracepoint encountered"));
5750 case bp_gnu_ifunc_resolver:
5751 /* Step over it (and insert bp_gnu_ifunc_resolver_return). */
5752 this_action = BPSTAT_WHAT_SINGLE;
5754 case bp_gnu_ifunc_resolver_return:
5755 /* The breakpoint will be removed, execution will restart from the
5756 PC of the former breakpoint. */
5757 this_action = BPSTAT_WHAT_KEEP_CHECKING;
5762 this_action = BPSTAT_WHAT_STOP_SILENT;
5764 this_action = BPSTAT_WHAT_SINGLE;
5768 internal_error (__FILE__, __LINE__,
5769 _("bpstat_what: unhandled bptype %d"), (int) bptype);
5772 retval.main_action = std::max (retval.main_action, this_action);
5779 bpstat_run_callbacks (bpstat bs_head)
5783 for (bs = bs_head; bs != NULL; bs = bs->next)
5785 struct breakpoint *b = bs->breakpoint_at;
5792 handle_jit_event ();
5794 case bp_gnu_ifunc_resolver:
5795 gnu_ifunc_resolver_stop (b);
5797 case bp_gnu_ifunc_resolver_return:
5798 gnu_ifunc_resolver_return_stop (b);
5804 /* Nonzero if we should step constantly (e.g. watchpoints on machines
5805 without hardware support). This isn't related to a specific bpstat,
5806 just to things like whether watchpoints are set. */
5809 bpstat_should_step (void)
5811 struct breakpoint *b;
5814 if (breakpoint_enabled (b) && b->type == bp_watchpoint && b->loc != NULL)
5820 bpstat_causes_stop (bpstat bs)
5822 for (; bs != NULL; bs = bs->next)
5831 /* Compute a string of spaces suitable to indent the next line
5832 so it starts at the position corresponding to the table column
5833 named COL_NAME in the currently active table of UIOUT. */
5836 wrap_indent_at_field (struct ui_out *uiout, const char *col_name)
5838 static char wrap_indent[80];
5839 int i, total_width, width, align;
5843 for (i = 1; uiout->query_table_field (i, &width, &align, &text); i++)
5845 if (strcmp (text, col_name) == 0)
5847 gdb_assert (total_width < sizeof wrap_indent);
5848 memset (wrap_indent, ' ', total_width);
5849 wrap_indent[total_width] = 0;
5854 total_width += width + 1;
5860 /* Determine if the locations of this breakpoint will have their conditions
5861 evaluated by the target, host or a mix of both. Returns the following:
5863 "host": Host evals condition.
5864 "host or target": Host or Target evals condition.
5865 "target": Target evals condition.
5869 bp_condition_evaluator (struct breakpoint *b)
5871 struct bp_location *bl;
5872 char host_evals = 0;
5873 char target_evals = 0;
5878 if (!is_breakpoint (b))
5881 if (gdb_evaluates_breakpoint_condition_p ()
5882 || !target_supports_evaluation_of_breakpoint_conditions ())
5883 return condition_evaluation_host;
5885 for (bl = b->loc; bl; bl = bl->next)
5887 if (bl->cond_bytecode)
5893 if (host_evals && target_evals)
5894 return condition_evaluation_both;
5895 else if (target_evals)
5896 return condition_evaluation_target;
5898 return condition_evaluation_host;
5901 /* Determine the breakpoint location's condition evaluator. This is
5902 similar to bp_condition_evaluator, but for locations. */
5905 bp_location_condition_evaluator (struct bp_location *bl)
5907 if (bl && !is_breakpoint (bl->owner))
5910 if (gdb_evaluates_breakpoint_condition_p ()
5911 || !target_supports_evaluation_of_breakpoint_conditions ())
5912 return condition_evaluation_host;
5914 if (bl && bl->cond_bytecode)
5915 return condition_evaluation_target;
5917 return condition_evaluation_host;
5920 /* Print the LOC location out of the list of B->LOC locations. */
5923 print_breakpoint_location (struct breakpoint *b,
5924 struct bp_location *loc)
5926 struct ui_out *uiout = current_uiout;
5928 scoped_restore_current_program_space restore_pspace;
5930 if (loc != NULL && loc->shlib_disabled)
5934 set_current_program_space (loc->pspace);
5936 if (b->display_canonical)
5937 uiout->field_string ("what", event_location_to_string (b->location.get ()));
5938 else if (loc && loc->symtab)
5940 const struct symbol *sym = loc->symbol;
5943 sym = find_pc_sect_function (loc->address, loc->section);
5947 uiout->text ("in ");
5948 uiout->field_string ("func", SYMBOL_PRINT_NAME (sym));
5950 uiout->wrap_hint (wrap_indent_at_field (uiout, "what"));
5951 uiout->text ("at ");
5953 uiout->field_string ("file",
5954 symtab_to_filename_for_display (loc->symtab));
5957 if (uiout->is_mi_like_p ())
5958 uiout->field_string ("fullname", symtab_to_fullname (loc->symtab));
5960 uiout->field_int ("line", loc->line_number);
5966 print_address_symbolic (loc->gdbarch, loc->address, &stb,
5968 uiout->field_stream ("at", stb);
5972 uiout->field_string ("pending",
5973 event_location_to_string (b->location.get ()));
5974 /* If extra_string is available, it could be holding a condition
5975 or dprintf arguments. In either case, make sure it is printed,
5976 too, but only for non-MI streams. */
5977 if (!uiout->is_mi_like_p () && b->extra_string != NULL)
5979 if (b->type == bp_dprintf)
5983 uiout->text (b->extra_string);
5987 if (loc && is_breakpoint (b)
5988 && breakpoint_condition_evaluation_mode () == condition_evaluation_target
5989 && bp_condition_evaluator (b) == condition_evaluation_both)
5992 uiout->field_string ("evaluated-by",
5993 bp_location_condition_evaluator (loc));
5999 bptype_string (enum bptype type)
6001 struct ep_type_description
6004 const char *description;
6006 static struct ep_type_description bptypes[] =
6008 {bp_none, "?deleted?"},
6009 {bp_breakpoint, "breakpoint"},
6010 {bp_hardware_breakpoint, "hw breakpoint"},
6011 {bp_single_step, "sw single-step"},
6012 {bp_until, "until"},
6013 {bp_finish, "finish"},
6014 {bp_watchpoint, "watchpoint"},
6015 {bp_hardware_watchpoint, "hw watchpoint"},
6016 {bp_read_watchpoint, "read watchpoint"},
6017 {bp_access_watchpoint, "acc watchpoint"},
6018 {bp_longjmp, "longjmp"},
6019 {bp_longjmp_resume, "longjmp resume"},
6020 {bp_longjmp_call_dummy, "longjmp for call dummy"},
6021 {bp_exception, "exception"},
6022 {bp_exception_resume, "exception resume"},
6023 {bp_step_resume, "step resume"},
6024 {bp_hp_step_resume, "high-priority step resume"},
6025 {bp_watchpoint_scope, "watchpoint scope"},
6026 {bp_call_dummy, "call dummy"},
6027 {bp_std_terminate, "std::terminate"},
6028 {bp_shlib_event, "shlib events"},
6029 {bp_thread_event, "thread events"},
6030 {bp_overlay_event, "overlay events"},
6031 {bp_longjmp_master, "longjmp master"},
6032 {bp_std_terminate_master, "std::terminate master"},
6033 {bp_exception_master, "exception master"},
6034 {bp_catchpoint, "catchpoint"},
6035 {bp_tracepoint, "tracepoint"},
6036 {bp_fast_tracepoint, "fast tracepoint"},
6037 {bp_static_tracepoint, "static tracepoint"},
6038 {bp_dprintf, "dprintf"},
6039 {bp_jit_event, "jit events"},
6040 {bp_gnu_ifunc_resolver, "STT_GNU_IFUNC resolver"},
6041 {bp_gnu_ifunc_resolver_return, "STT_GNU_IFUNC resolver return"},
6044 if (((int) type >= (sizeof (bptypes) / sizeof (bptypes[0])))
6045 || ((int) type != bptypes[(int) type].type))
6046 internal_error (__FILE__, __LINE__,
6047 _("bptypes table does not describe type #%d."),
6050 return bptypes[(int) type].description;
6053 /* For MI, output a field named 'thread-groups' with a list as the value.
6054 For CLI, prefix the list with the string 'inf'. */
6057 output_thread_groups (struct ui_out *uiout,
6058 const char *field_name,
6062 int is_mi = uiout->is_mi_like_p ();
6066 /* For backward compatibility, don't display inferiors in CLI unless
6067 there are several. Always display them for MI. */
6068 if (!is_mi && mi_only)
6071 ui_out_emit_list list_emitter (uiout, field_name);
6073 for (i = 0; VEC_iterate (int, inf_num, i, inf); ++i)
6079 xsnprintf (mi_group, sizeof (mi_group), "i%d", inf);
6080 uiout->field_string (NULL, mi_group);
6085 uiout->text (" inf ");
6089 uiout->text (plongest (inf));
6094 /* Print B to gdb_stdout. */
6097 print_one_breakpoint_location (struct breakpoint *b,
6098 struct bp_location *loc,
6100 struct bp_location **last_loc,
6103 struct command_line *l;
6104 static char bpenables[] = "nynny";
6106 struct ui_out *uiout = current_uiout;
6107 int header_of_multiple = 0;
6108 int part_of_multiple = (loc != NULL);
6109 struct value_print_options opts;
6111 get_user_print_options (&opts);
6113 gdb_assert (!loc || loc_number != 0);
6114 /* See comment in print_one_breakpoint concerning treatment of
6115 breakpoints with single disabled location. */
6118 && (b->loc->next != NULL || !b->loc->enabled)))
6119 header_of_multiple = 1;
6127 if (part_of_multiple)
6130 formatted = xstrprintf ("%d.%d", b->number, loc_number);
6131 uiout->field_string ("number", formatted);
6136 uiout->field_int ("number", b->number);
6141 if (part_of_multiple)
6142 uiout->field_skip ("type");
6144 uiout->field_string ("type", bptype_string (b->type));
6148 if (part_of_multiple)
6149 uiout->field_skip ("disp");
6151 uiout->field_string ("disp", bpdisp_text (b->disposition));
6156 if (part_of_multiple)
6157 uiout->field_string ("enabled", loc->enabled ? "y" : "n");
6159 uiout->field_fmt ("enabled", "%c", bpenables[(int) b->enable_state]);
6164 if (b->ops != NULL && b->ops->print_one != NULL)
6166 /* Although the print_one can possibly print all locations,
6167 calling it here is not likely to get any nice result. So,
6168 make sure there's just one location. */
6169 gdb_assert (b->loc == NULL || b->loc->next == NULL);
6170 b->ops->print_one (b, last_loc);
6176 internal_error (__FILE__, __LINE__,
6177 _("print_one_breakpoint: bp_none encountered\n"));
6181 case bp_hardware_watchpoint:
6182 case bp_read_watchpoint:
6183 case bp_access_watchpoint:
6185 struct watchpoint *w = (struct watchpoint *) b;
6187 /* Field 4, the address, is omitted (which makes the columns
6188 not line up too nicely with the headers, but the effect
6189 is relatively readable). */
6190 if (opts.addressprint)
6191 uiout->field_skip ("addr");
6193 uiout->field_string ("what", w->exp_string);
6198 case bp_hardware_breakpoint:
6199 case bp_single_step:
6203 case bp_longjmp_resume:
6204 case bp_longjmp_call_dummy:
6206 case bp_exception_resume:
6207 case bp_step_resume:
6208 case bp_hp_step_resume:
6209 case bp_watchpoint_scope:
6211 case bp_std_terminate:
6212 case bp_shlib_event:
6213 case bp_thread_event:
6214 case bp_overlay_event:
6215 case bp_longjmp_master:
6216 case bp_std_terminate_master:
6217 case bp_exception_master:
6219 case bp_fast_tracepoint:
6220 case bp_static_tracepoint:
6223 case bp_gnu_ifunc_resolver:
6224 case bp_gnu_ifunc_resolver_return:
6225 if (opts.addressprint)
6228 if (header_of_multiple)
6229 uiout->field_string ("addr", "<MULTIPLE>");
6230 else if (b->loc == NULL || loc->shlib_disabled)
6231 uiout->field_string ("addr", "<PENDING>");
6233 uiout->field_core_addr ("addr",
6234 loc->gdbarch, loc->address);
6237 if (!header_of_multiple)
6238 print_breakpoint_location (b, loc);
6245 if (loc != NULL && !header_of_multiple)
6247 struct inferior *inf;
6248 VEC(int) *inf_num = NULL;
6253 if (inf->pspace == loc->pspace)
6254 VEC_safe_push (int, inf_num, inf->num);
6257 /* For backward compatibility, don't display inferiors in CLI unless
6258 there are several. Always display for MI. */
6260 || (!gdbarch_has_global_breakpoints (target_gdbarch ())
6261 && (number_of_program_spaces () > 1
6262 || number_of_inferiors () > 1)
6263 /* LOC is for existing B, it cannot be in
6264 moribund_locations and thus having NULL OWNER. */
6265 && loc->owner->type != bp_catchpoint))
6267 output_thread_groups (uiout, "thread-groups", inf_num, mi_only);
6268 VEC_free (int, inf_num);
6271 if (!part_of_multiple)
6273 if (b->thread != -1)
6275 /* FIXME: This seems to be redundant and lost here; see the
6276 "stop only in" line a little further down. */
6277 uiout->text (" thread ");
6278 uiout->field_int ("thread", b->thread);
6280 else if (b->task != 0)
6282 uiout->text (" task ");
6283 uiout->field_int ("task", b->task);
6289 if (!part_of_multiple)
6290 b->ops->print_one_detail (b, uiout);
6292 if (part_of_multiple && frame_id_p (b->frame_id))
6295 uiout->text ("\tstop only in stack frame at ");
6296 /* FIXME: cagney/2002-12-01: Shouldn't be poking around inside
6298 uiout->field_core_addr ("frame",
6299 b->gdbarch, b->frame_id.stack_addr);
6303 if (!part_of_multiple && b->cond_string)
6306 if (is_tracepoint (b))
6307 uiout->text ("\ttrace only if ");
6309 uiout->text ("\tstop only if ");
6310 uiout->field_string ("cond", b->cond_string);
6312 /* Print whether the target is doing the breakpoint's condition
6313 evaluation. If GDB is doing the evaluation, don't print anything. */
6314 if (is_breakpoint (b)
6315 && breakpoint_condition_evaluation_mode ()
6316 == condition_evaluation_target)
6319 uiout->field_string ("evaluated-by",
6320 bp_condition_evaluator (b));
6321 uiout->text (" evals)");
6326 if (!part_of_multiple && b->thread != -1)
6328 /* FIXME should make an annotation for this. */
6329 uiout->text ("\tstop only in thread ");
6330 if (uiout->is_mi_like_p ())
6331 uiout->field_int ("thread", b->thread);
6334 struct thread_info *thr = find_thread_global_id (b->thread);
6336 uiout->field_string ("thread", print_thread_id (thr));
6341 if (!part_of_multiple)
6345 /* FIXME should make an annotation for this. */
6346 if (is_catchpoint (b))
6347 uiout->text ("\tcatchpoint");
6348 else if (is_tracepoint (b))
6349 uiout->text ("\ttracepoint");
6351 uiout->text ("\tbreakpoint");
6352 uiout->text (" already hit ");
6353 uiout->field_int ("times", b->hit_count);
6354 if (b->hit_count == 1)
6355 uiout->text (" time\n");
6357 uiout->text (" times\n");
6361 /* Output the count also if it is zero, but only if this is mi. */
6362 if (uiout->is_mi_like_p ())
6363 uiout->field_int ("times", b->hit_count);
6367 if (!part_of_multiple && b->ignore_count)
6370 uiout->text ("\tignore next ");
6371 uiout->field_int ("ignore", b->ignore_count);
6372 uiout->text (" hits\n");
6375 /* Note that an enable count of 1 corresponds to "enable once"
6376 behavior, which is reported by the combination of enablement and
6377 disposition, so we don't need to mention it here. */
6378 if (!part_of_multiple && b->enable_count > 1)
6381 uiout->text ("\tdisable after ");
6382 /* Tweak the wording to clarify that ignore and enable counts
6383 are distinct, and have additive effect. */
6384 if (b->ignore_count)
6385 uiout->text ("additional ");
6387 uiout->text ("next ");
6388 uiout->field_int ("enable", b->enable_count);
6389 uiout->text (" hits\n");
6392 if (!part_of_multiple && is_tracepoint (b))
6394 struct tracepoint *tp = (struct tracepoint *) b;
6396 if (tp->traceframe_usage)
6398 uiout->text ("\ttrace buffer usage ");
6399 uiout->field_int ("traceframe-usage", tp->traceframe_usage);
6400 uiout->text (" bytes\n");
6404 l = b->commands ? b->commands.get () : NULL;
6405 if (!part_of_multiple && l)
6408 ui_out_emit_tuple tuple_emitter (uiout, "script");
6409 print_command_lines (uiout, l, 4);
6412 if (is_tracepoint (b))
6414 struct tracepoint *t = (struct tracepoint *) b;
6416 if (!part_of_multiple && t->pass_count)
6418 annotate_field (10);
6419 uiout->text ("\tpass count ");
6420 uiout->field_int ("pass", t->pass_count);
6421 uiout->text (" \n");
6424 /* Don't display it when tracepoint or tracepoint location is
6426 if (!header_of_multiple && loc != NULL && !loc->shlib_disabled)
6428 annotate_field (11);
6430 if (uiout->is_mi_like_p ())
6431 uiout->field_string ("installed",
6432 loc->inserted ? "y" : "n");
6438 uiout->text ("\tnot ");
6439 uiout->text ("installed on target\n");
6444 if (uiout->is_mi_like_p () && !part_of_multiple)
6446 if (is_watchpoint (b))
6448 struct watchpoint *w = (struct watchpoint *) b;
6450 uiout->field_string ("original-location", w->exp_string);
6452 else if (b->location != NULL
6453 && event_location_to_string (b->location.get ()) != NULL)
6454 uiout->field_string ("original-location",
6455 event_location_to_string (b->location.get ()));
6460 print_one_breakpoint (struct breakpoint *b,
6461 struct bp_location **last_loc,
6464 struct ui_out *uiout = current_uiout;
6467 ui_out_emit_tuple tuple_emitter (uiout, "bkpt");
6469 print_one_breakpoint_location (b, NULL, 0, last_loc, allflag);
6472 /* If this breakpoint has custom print function,
6473 it's already printed. Otherwise, print individual
6474 locations, if any. */
6475 if (b->ops == NULL || b->ops->print_one == NULL)
6477 /* If breakpoint has a single location that is disabled, we
6478 print it as if it had several locations, since otherwise it's
6479 hard to represent "breakpoint enabled, location disabled"
6482 Note that while hardware watchpoints have several locations
6483 internally, that's not a property exposed to user. */
6485 && !is_hardware_watchpoint (b)
6486 && (b->loc->next || !b->loc->enabled))
6488 struct bp_location *loc;
6491 for (loc = b->loc; loc; loc = loc->next, ++n)
6493 ui_out_emit_tuple tuple_emitter (uiout, NULL);
6494 print_one_breakpoint_location (b, loc, n, last_loc, allflag);
6501 breakpoint_address_bits (struct breakpoint *b)
6503 int print_address_bits = 0;
6504 struct bp_location *loc;
6506 /* Software watchpoints that aren't watching memory don't have an
6507 address to print. */
6508 if (is_no_memory_software_watchpoint (b))
6511 for (loc = b->loc; loc; loc = loc->next)
6515 addr_bit = gdbarch_addr_bit (loc->gdbarch);
6516 if (addr_bit > print_address_bits)
6517 print_address_bits = addr_bit;
6520 return print_address_bits;
6523 /* See breakpoint.h. */
6526 print_breakpoint (breakpoint *b)
6528 struct bp_location *dummy_loc = NULL;
6529 print_one_breakpoint (b, &dummy_loc, 0);
6532 /* Return true if this breakpoint was set by the user, false if it is
6533 internal or momentary. */
6536 user_breakpoint_p (struct breakpoint *b)
6538 return b->number > 0;
6541 /* See breakpoint.h. */
6544 pending_breakpoint_p (struct breakpoint *b)
6546 return b->loc == NULL;
6549 /* Print information on user settable breakpoint (watchpoint, etc)
6550 number BNUM. If BNUM is -1 print all user-settable breakpoints.
6551 If ALLFLAG is non-zero, include non-user-settable breakpoints. If
6552 FILTER is non-NULL, call it on each breakpoint and only include the
6553 ones for which it returns non-zero. Return the total number of
6554 breakpoints listed. */
6557 breakpoint_1 (const char *args, int allflag,
6558 int (*filter) (const struct breakpoint *))
6560 struct breakpoint *b;
6561 struct bp_location *last_loc = NULL;
6562 int nr_printable_breakpoints;
6563 struct value_print_options opts;
6564 int print_address_bits = 0;
6565 int print_type_col_width = 14;
6566 struct ui_out *uiout = current_uiout;
6568 get_user_print_options (&opts);
6570 /* Compute the number of rows in the table, as well as the size
6571 required for address fields. */
6572 nr_printable_breakpoints = 0;
6575 /* If we have a filter, only list the breakpoints it accepts. */
6576 if (filter && !filter (b))
6579 /* If we have an "args" string, it is a list of breakpoints to
6580 accept. Skip the others. */
6581 if (args != NULL && *args != '\0')
6583 if (allflag && parse_and_eval_long (args) != b->number)
6585 if (!allflag && !number_is_in_list (args, b->number))
6589 if (allflag || user_breakpoint_p (b))
6591 int addr_bit, type_len;
6593 addr_bit = breakpoint_address_bits (b);
6594 if (addr_bit > print_address_bits)
6595 print_address_bits = addr_bit;
6597 type_len = strlen (bptype_string (b->type));
6598 if (type_len > print_type_col_width)
6599 print_type_col_width = type_len;
6601 nr_printable_breakpoints++;
6606 ui_out_emit_table table_emitter (uiout,
6607 opts.addressprint ? 6 : 5,
6608 nr_printable_breakpoints,
6611 if (nr_printable_breakpoints > 0)
6612 annotate_breakpoints_headers ();
6613 if (nr_printable_breakpoints > 0)
6615 uiout->table_header (7, ui_left, "number", "Num"); /* 1 */
6616 if (nr_printable_breakpoints > 0)
6618 uiout->table_header (print_type_col_width, ui_left, "type", "Type"); /* 2 */
6619 if (nr_printable_breakpoints > 0)
6621 uiout->table_header (4, ui_left, "disp", "Disp"); /* 3 */
6622 if (nr_printable_breakpoints > 0)
6624 uiout->table_header (3, ui_left, "enabled", "Enb"); /* 4 */
6625 if (opts.addressprint)
6627 if (nr_printable_breakpoints > 0)
6629 if (print_address_bits <= 32)
6630 uiout->table_header (10, ui_left, "addr", "Address"); /* 5 */
6632 uiout->table_header (18, ui_left, "addr", "Address"); /* 5 */
6634 if (nr_printable_breakpoints > 0)
6636 uiout->table_header (40, ui_noalign, "what", "What"); /* 6 */
6637 uiout->table_body ();
6638 if (nr_printable_breakpoints > 0)
6639 annotate_breakpoints_table ();
6644 /* If we have a filter, only list the breakpoints it accepts. */
6645 if (filter && !filter (b))
6648 /* If we have an "args" string, it is a list of breakpoints to
6649 accept. Skip the others. */
6651 if (args != NULL && *args != '\0')
6653 if (allflag) /* maintenance info breakpoint */
6655 if (parse_and_eval_long (args) != b->number)
6658 else /* all others */
6660 if (!number_is_in_list (args, b->number))
6664 /* We only print out user settable breakpoints unless the
6666 if (allflag || user_breakpoint_p (b))
6667 print_one_breakpoint (b, &last_loc, allflag);
6671 if (nr_printable_breakpoints == 0)
6673 /* If there's a filter, let the caller decide how to report
6677 if (args == NULL || *args == '\0')
6678 uiout->message ("No breakpoints or watchpoints.\n");
6680 uiout->message ("No breakpoint or watchpoint matching '%s'.\n",
6686 if (last_loc && !server_command)
6687 set_next_address (last_loc->gdbarch, last_loc->address);
6690 /* FIXME? Should this be moved up so that it is only called when
6691 there have been breakpoints? */
6692 annotate_breakpoints_table_end ();
6694 return nr_printable_breakpoints;
6697 /* Display the value of default-collect in a way that is generally
6698 compatible with the breakpoint list. */
6701 default_collect_info (void)
6703 struct ui_out *uiout = current_uiout;
6705 /* If it has no value (which is frequently the case), say nothing; a
6706 message like "No default-collect." gets in user's face when it's
6708 if (!*default_collect)
6711 /* The following phrase lines up nicely with per-tracepoint collect
6713 uiout->text ("default collect ");
6714 uiout->field_string ("default-collect", default_collect);
6715 uiout->text (" \n");
6719 info_breakpoints_command (char *args, int from_tty)
6721 breakpoint_1 (args, 0, NULL);
6723 default_collect_info ();
6727 info_watchpoints_command (char *args, int from_tty)
6729 int num_printed = breakpoint_1 (args, 0, is_watchpoint);
6730 struct ui_out *uiout = current_uiout;
6732 if (num_printed == 0)
6734 if (args == NULL || *args == '\0')
6735 uiout->message ("No watchpoints.\n");
6737 uiout->message ("No watchpoint matching '%s'.\n", args);
6742 maintenance_info_breakpoints (const char *args, int from_tty)
6744 breakpoint_1 (args, 1, NULL);
6746 default_collect_info ();
6750 breakpoint_has_pc (struct breakpoint *b,
6751 struct program_space *pspace,
6752 CORE_ADDR pc, struct obj_section *section)
6754 struct bp_location *bl = b->loc;
6756 for (; bl; bl = bl->next)
6758 if (bl->pspace == pspace
6759 && bl->address == pc
6760 && (!overlay_debugging || bl->section == section))
6766 /* Print a message describing any user-breakpoints set at PC. This
6767 concerns with logical breakpoints, so we match program spaces, not
6771 describe_other_breakpoints (struct gdbarch *gdbarch,
6772 struct program_space *pspace, CORE_ADDR pc,
6773 struct obj_section *section, int thread)
6776 struct breakpoint *b;
6779 others += (user_breakpoint_p (b)
6780 && breakpoint_has_pc (b, pspace, pc, section));
6784 printf_filtered (_("Note: breakpoint "));
6785 else /* if (others == ???) */
6786 printf_filtered (_("Note: breakpoints "));
6788 if (user_breakpoint_p (b) && breakpoint_has_pc (b, pspace, pc, section))
6791 printf_filtered ("%d", b->number);
6792 if (b->thread == -1 && thread != -1)
6793 printf_filtered (" (all threads)");
6794 else if (b->thread != -1)
6795 printf_filtered (" (thread %d)", b->thread);
6796 printf_filtered ("%s%s ",
6797 ((b->enable_state == bp_disabled
6798 || b->enable_state == bp_call_disabled)
6802 : ((others == 1) ? " and" : ""));
6804 printf_filtered (_("also set at pc "));
6805 fputs_filtered (paddress (gdbarch, pc), gdb_stdout);
6806 printf_filtered (".\n");
6811 /* Return true iff it is meaningful to use the address member of
6812 BPT locations. For some breakpoint types, the locations' address members
6813 are irrelevant and it makes no sense to attempt to compare them to other
6814 addresses (or use them for any other purpose either).
6816 More specifically, each of the following breakpoint types will
6817 always have a zero valued location address and we don't want to mark
6818 breakpoints of any of these types to be a duplicate of an actual
6819 breakpoint location at address zero:
6827 breakpoint_address_is_meaningful (struct breakpoint *bpt)
6829 enum bptype type = bpt->type;
6831 return (type != bp_watchpoint && type != bp_catchpoint);
6834 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
6835 true if LOC1 and LOC2 represent the same watchpoint location. */
6838 watchpoint_locations_match (struct bp_location *loc1,
6839 struct bp_location *loc2)
6841 struct watchpoint *w1 = (struct watchpoint *) loc1->owner;
6842 struct watchpoint *w2 = (struct watchpoint *) loc2->owner;
6844 /* Both of them must exist. */
6845 gdb_assert (w1 != NULL);
6846 gdb_assert (w2 != NULL);
6848 /* If the target can evaluate the condition expression in hardware,
6849 then we we need to insert both watchpoints even if they are at
6850 the same place. Otherwise the watchpoint will only trigger when
6851 the condition of whichever watchpoint was inserted evaluates to
6852 true, not giving a chance for GDB to check the condition of the
6853 other watchpoint. */
6855 && target_can_accel_watchpoint_condition (loc1->address,
6857 loc1->watchpoint_type,
6858 w1->cond_exp.get ()))
6860 && target_can_accel_watchpoint_condition (loc2->address,
6862 loc2->watchpoint_type,
6863 w2->cond_exp.get ())))
6866 /* Note that this checks the owner's type, not the location's. In
6867 case the target does not support read watchpoints, but does
6868 support access watchpoints, we'll have bp_read_watchpoint
6869 watchpoints with hw_access locations. Those should be considered
6870 duplicates of hw_read locations. The hw_read locations will
6871 become hw_access locations later. */
6872 return (loc1->owner->type == loc2->owner->type
6873 && loc1->pspace->aspace == loc2->pspace->aspace
6874 && loc1->address == loc2->address
6875 && loc1->length == loc2->length);
6878 /* See breakpoint.h. */
6881 breakpoint_address_match (const address_space *aspace1, CORE_ADDR addr1,
6882 const address_space *aspace2, CORE_ADDR addr2)
6884 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
6885 || aspace1 == aspace2)
6889 /* Returns true if {ASPACE2,ADDR2} falls within the range determined by
6890 {ASPACE1,ADDR1,LEN1}. In most targets, this can only be true if ASPACE1
6891 matches ASPACE2. On targets that have global breakpoints, the address
6892 space doesn't really matter. */
6895 breakpoint_address_match_range (const address_space *aspace1,
6897 int len1, const address_space *aspace2,
6900 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
6901 || aspace1 == aspace2)
6902 && addr2 >= addr1 && addr2 < addr1 + len1);
6905 /* Returns true if {ASPACE,ADDR} matches the breakpoint BL. BL may be
6906 a ranged breakpoint. In most targets, a match happens only if ASPACE
6907 matches the breakpoint's address space. On targets that have global
6908 breakpoints, the address space doesn't really matter. */
6911 breakpoint_location_address_match (struct bp_location *bl,
6912 const address_space *aspace,
6915 return (breakpoint_address_match (bl->pspace->aspace, bl->address,
6918 && breakpoint_address_match_range (bl->pspace->aspace,
6919 bl->address, bl->length,
6923 /* Returns true if the [ADDR,ADDR+LEN) range in ASPACE overlaps
6924 breakpoint BL. BL may be a ranged breakpoint. In most targets, a
6925 match happens only if ASPACE matches the breakpoint's address
6926 space. On targets that have global breakpoints, the address space
6927 doesn't really matter. */
6930 breakpoint_location_address_range_overlap (struct bp_location *bl,
6931 const address_space *aspace,
6932 CORE_ADDR addr, int len)
6934 if (gdbarch_has_global_breakpoints (target_gdbarch ())
6935 || bl->pspace->aspace == aspace)
6937 int bl_len = bl->length != 0 ? bl->length : 1;
6939 if (mem_ranges_overlap (addr, len, bl->address, bl_len))
6945 /* If LOC1 and LOC2's owners are not tracepoints, returns false directly.
6946 Then, if LOC1 and LOC2 represent the same tracepoint location, returns
6947 true, otherwise returns false. */
6950 tracepoint_locations_match (struct bp_location *loc1,
6951 struct bp_location *loc2)
6953 if (is_tracepoint (loc1->owner) && is_tracepoint (loc2->owner))
6954 /* Since tracepoint locations are never duplicated with others', tracepoint
6955 locations at the same address of different tracepoints are regarded as
6956 different locations. */
6957 return (loc1->address == loc2->address && loc1->owner == loc2->owner);
6962 /* Assuming LOC1 and LOC2's types' have meaningful target addresses
6963 (breakpoint_address_is_meaningful), returns true if LOC1 and LOC2
6964 represent the same location. */
6967 breakpoint_locations_match (struct bp_location *loc1,
6968 struct bp_location *loc2)
6970 int hw_point1, hw_point2;
6972 /* Both of them must not be in moribund_locations. */
6973 gdb_assert (loc1->owner != NULL);
6974 gdb_assert (loc2->owner != NULL);
6976 hw_point1 = is_hardware_watchpoint (loc1->owner);
6977 hw_point2 = is_hardware_watchpoint (loc2->owner);
6979 if (hw_point1 != hw_point2)
6982 return watchpoint_locations_match (loc1, loc2);
6983 else if (is_tracepoint (loc1->owner) || is_tracepoint (loc2->owner))
6984 return tracepoint_locations_match (loc1, loc2);
6986 /* We compare bp_location.length in order to cover ranged breakpoints. */
6987 return (breakpoint_address_match (loc1->pspace->aspace, loc1->address,
6988 loc2->pspace->aspace, loc2->address)
6989 && loc1->length == loc2->length);
6993 breakpoint_adjustment_warning (CORE_ADDR from_addr, CORE_ADDR to_addr,
6994 int bnum, int have_bnum)
6996 /* The longest string possibly returned by hex_string_custom
6997 is 50 chars. These must be at least that big for safety. */
7001 strcpy (astr1, hex_string_custom ((unsigned long) from_addr, 8));
7002 strcpy (astr2, hex_string_custom ((unsigned long) to_addr, 8));
7004 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
7005 bnum, astr1, astr2);
7007 warning (_("Breakpoint address adjusted from %s to %s."), astr1, astr2);
7010 /* Adjust a breakpoint's address to account for architectural
7011 constraints on breakpoint placement. Return the adjusted address.
7012 Note: Very few targets require this kind of adjustment. For most
7013 targets, this function is simply the identity function. */
7016 adjust_breakpoint_address (struct gdbarch *gdbarch,
7017 CORE_ADDR bpaddr, enum bptype bptype)
7019 if (!gdbarch_adjust_breakpoint_address_p (gdbarch))
7021 /* Very few targets need any kind of breakpoint adjustment. */
7024 else if (bptype == bp_watchpoint
7025 || bptype == bp_hardware_watchpoint
7026 || bptype == bp_read_watchpoint
7027 || bptype == bp_access_watchpoint
7028 || bptype == bp_catchpoint)
7030 /* Watchpoints and the various bp_catch_* eventpoints should not
7031 have their addresses modified. */
7034 else if (bptype == bp_single_step)
7036 /* Single-step breakpoints should not have their addresses
7037 modified. If there's any architectural constrain that
7038 applies to this address, then it should have already been
7039 taken into account when the breakpoint was created in the
7040 first place. If we didn't do this, stepping through e.g.,
7041 Thumb-2 IT blocks would break. */
7046 CORE_ADDR adjusted_bpaddr;
7048 /* Some targets have architectural constraints on the placement
7049 of breakpoint instructions. Obtain the adjusted address. */
7050 adjusted_bpaddr = gdbarch_adjust_breakpoint_address (gdbarch, bpaddr);
7052 /* An adjusted breakpoint address can significantly alter
7053 a user's expectations. Print a warning if an adjustment
7055 if (adjusted_bpaddr != bpaddr)
7056 breakpoint_adjustment_warning (bpaddr, adjusted_bpaddr, 0, 0);
7058 return adjusted_bpaddr;
7062 bp_location::bp_location (const bp_location_ops *ops, breakpoint *owner)
7064 bp_location *loc = this;
7066 gdb_assert (ops != NULL);
7070 loc->cond_bytecode = NULL;
7071 loc->shlib_disabled = 0;
7074 switch (owner->type)
7077 case bp_single_step:
7081 case bp_longjmp_resume:
7082 case bp_longjmp_call_dummy:
7084 case bp_exception_resume:
7085 case bp_step_resume:
7086 case bp_hp_step_resume:
7087 case bp_watchpoint_scope:
7089 case bp_std_terminate:
7090 case bp_shlib_event:
7091 case bp_thread_event:
7092 case bp_overlay_event:
7094 case bp_longjmp_master:
7095 case bp_std_terminate_master:
7096 case bp_exception_master:
7097 case bp_gnu_ifunc_resolver:
7098 case bp_gnu_ifunc_resolver_return:
7100 loc->loc_type = bp_loc_software_breakpoint;
7101 mark_breakpoint_location_modified (loc);
7103 case bp_hardware_breakpoint:
7104 loc->loc_type = bp_loc_hardware_breakpoint;
7105 mark_breakpoint_location_modified (loc);
7107 case bp_hardware_watchpoint:
7108 case bp_read_watchpoint:
7109 case bp_access_watchpoint:
7110 loc->loc_type = bp_loc_hardware_watchpoint;
7115 case bp_fast_tracepoint:
7116 case bp_static_tracepoint:
7117 loc->loc_type = bp_loc_other;
7120 internal_error (__FILE__, __LINE__, _("unknown breakpoint type"));
7126 /* Allocate a struct bp_location. */
7128 static struct bp_location *
7129 allocate_bp_location (struct breakpoint *bpt)
7131 return bpt->ops->allocate_location (bpt);
7135 free_bp_location (struct bp_location *loc)
7137 loc->ops->dtor (loc);
7141 /* Increment reference count. */
7144 incref_bp_location (struct bp_location *bl)
7149 /* Decrement reference count. If the reference count reaches 0,
7150 destroy the bp_location. Sets *BLP to NULL. */
7153 decref_bp_location (struct bp_location **blp)
7155 gdb_assert ((*blp)->refc > 0);
7157 if (--(*blp)->refc == 0)
7158 free_bp_location (*blp);
7162 /* Add breakpoint B at the end of the global breakpoint chain. */
7165 add_to_breakpoint_chain (std::unique_ptr<breakpoint> &&b)
7167 struct breakpoint *b1;
7168 struct breakpoint *result = b.get ();
7170 /* Add this breakpoint to the end of the chain so that a list of
7171 breakpoints will come out in order of increasing numbers. */
7173 b1 = breakpoint_chain;
7175 breakpoint_chain = b.release ();
7180 b1->next = b.release ();
7186 /* Initializes breakpoint B with type BPTYPE and no locations yet. */
7189 init_raw_breakpoint_without_location (struct breakpoint *b,
7190 struct gdbarch *gdbarch,
7192 const struct breakpoint_ops *ops)
7194 gdb_assert (ops != NULL);
7198 b->gdbarch = gdbarch;
7199 b->language = current_language->la_language;
7200 b->input_radix = input_radix;
7201 b->related_breakpoint = b;
7204 /* Helper to set_raw_breakpoint below. Creates a breakpoint
7205 that has type BPTYPE and has no locations as yet. */
7207 static struct breakpoint *
7208 set_raw_breakpoint_without_location (struct gdbarch *gdbarch,
7210 const struct breakpoint_ops *ops)
7212 std::unique_ptr<breakpoint> b = new_breakpoint_from_type (bptype);
7214 init_raw_breakpoint_without_location (b.get (), gdbarch, bptype, ops);
7215 return add_to_breakpoint_chain (std::move (b));
7218 /* Initialize loc->function_name. EXPLICIT_LOC says no indirect function
7219 resolutions should be made as the user specified the location explicitly
7223 set_breakpoint_location_function (struct bp_location *loc, int explicit_loc)
7225 gdb_assert (loc->owner != NULL);
7227 if (loc->owner->type == bp_breakpoint
7228 || loc->owner->type == bp_hardware_breakpoint
7229 || is_tracepoint (loc->owner))
7232 const char *function_name;
7233 CORE_ADDR func_addr;
7235 find_pc_partial_function_gnu_ifunc (loc->address, &function_name,
7236 &func_addr, NULL, &is_gnu_ifunc);
7238 if (is_gnu_ifunc && !explicit_loc)
7240 struct breakpoint *b = loc->owner;
7242 gdb_assert (loc->pspace == current_program_space);
7243 if (gnu_ifunc_resolve_name (function_name,
7244 &loc->requested_address))
7246 /* Recalculate ADDRESS based on new REQUESTED_ADDRESS. */
7247 loc->address = adjust_breakpoint_address (loc->gdbarch,
7248 loc->requested_address,
7251 else if (b->type == bp_breakpoint && b->loc == loc
7252 && loc->next == NULL && b->related_breakpoint == b)
7254 /* Create only the whole new breakpoint of this type but do not
7255 mess more complicated breakpoints with multiple locations. */
7256 b->type = bp_gnu_ifunc_resolver;
7257 /* Remember the resolver's address for use by the return
7259 loc->related_address = func_addr;
7264 loc->function_name = xstrdup (function_name);
7268 /* Attempt to determine architecture of location identified by SAL. */
7270 get_sal_arch (struct symtab_and_line sal)
7273 return get_objfile_arch (sal.section->objfile);
7275 return get_objfile_arch (SYMTAB_OBJFILE (sal.symtab));
7280 /* Low level routine for partially initializing a breakpoint of type
7281 BPTYPE. The newly created breakpoint's address, section, source
7282 file name, and line number are provided by SAL.
7284 It is expected that the caller will complete the initialization of
7285 the newly created breakpoint struct as well as output any status
7286 information regarding the creation of a new breakpoint. */
7289 init_raw_breakpoint (struct breakpoint *b, struct gdbarch *gdbarch,
7290 struct symtab_and_line sal, enum bptype bptype,
7291 const struct breakpoint_ops *ops)
7293 init_raw_breakpoint_without_location (b, gdbarch, bptype, ops);
7295 add_location_to_breakpoint (b, &sal);
7297 if (bptype != bp_catchpoint)
7298 gdb_assert (sal.pspace != NULL);
7300 /* Store the program space that was used to set the breakpoint,
7301 except for ordinary breakpoints, which are independent of the
7303 if (bptype != bp_breakpoint && bptype != bp_hardware_breakpoint)
7304 b->pspace = sal.pspace;
7307 /* set_raw_breakpoint is a low level routine for allocating and
7308 partially initializing a breakpoint of type BPTYPE. The newly
7309 created breakpoint's address, section, source file name, and line
7310 number are provided by SAL. The newly created and partially
7311 initialized breakpoint is added to the breakpoint chain and
7312 is also returned as the value of this function.
7314 It is expected that the caller will complete the initialization of
7315 the newly created breakpoint struct as well as output any status
7316 information regarding the creation of a new breakpoint. In
7317 particular, set_raw_breakpoint does NOT set the breakpoint
7318 number! Care should be taken to not allow an error to occur
7319 prior to completing the initialization of the breakpoint. If this
7320 should happen, a bogus breakpoint will be left on the chain. */
7323 set_raw_breakpoint (struct gdbarch *gdbarch,
7324 struct symtab_and_line sal, enum bptype bptype,
7325 const struct breakpoint_ops *ops)
7327 std::unique_ptr<breakpoint> b = new_breakpoint_from_type (bptype);
7329 init_raw_breakpoint (b.get (), gdbarch, sal, bptype, ops);
7330 return add_to_breakpoint_chain (std::move (b));
7333 /* Call this routine when stepping and nexting to enable a breakpoint
7334 if we do a longjmp() or 'throw' in TP. FRAME is the frame which
7335 initiated the operation. */
7338 set_longjmp_breakpoint (struct thread_info *tp, struct frame_id frame)
7340 struct breakpoint *b, *b_tmp;
7341 int thread = tp->global_num;
7343 /* To avoid having to rescan all objfile symbols at every step,
7344 we maintain a list of continually-inserted but always disabled
7345 longjmp "master" breakpoints. Here, we simply create momentary
7346 clones of those and enable them for the requested thread. */
7347 ALL_BREAKPOINTS_SAFE (b, b_tmp)
7348 if (b->pspace == current_program_space
7349 && (b->type == bp_longjmp_master
7350 || b->type == bp_exception_master))
7352 enum bptype type = b->type == bp_longjmp_master ? bp_longjmp : bp_exception;
7353 struct breakpoint *clone;
7355 /* longjmp_breakpoint_ops ensures INITIATING_FRAME is cleared again
7356 after their removal. */
7357 clone = momentary_breakpoint_from_master (b, type,
7358 &momentary_breakpoint_ops, 1);
7359 clone->thread = thread;
7362 tp->initiating_frame = frame;
7365 /* Delete all longjmp breakpoints from THREAD. */
7367 delete_longjmp_breakpoint (int thread)
7369 struct breakpoint *b, *b_tmp;
7371 ALL_BREAKPOINTS_SAFE (b, b_tmp)
7372 if (b->type == bp_longjmp || b->type == bp_exception)
7374 if (b->thread == thread)
7375 delete_breakpoint (b);
7380 delete_longjmp_breakpoint_at_next_stop (int thread)
7382 struct breakpoint *b, *b_tmp;
7384 ALL_BREAKPOINTS_SAFE (b, b_tmp)
7385 if (b->type == bp_longjmp || b->type == bp_exception)
7387 if (b->thread == thread)
7388 b->disposition = disp_del_at_next_stop;
7392 /* Place breakpoints of type bp_longjmp_call_dummy to catch longjmp for
7393 INFERIOR_PTID thread. Chain them all by RELATED_BREAKPOINT and return
7394 pointer to any of them. Return NULL if this system cannot place longjmp
7398 set_longjmp_breakpoint_for_call_dummy (void)
7400 struct breakpoint *b, *retval = NULL;
7403 if (b->pspace == current_program_space && b->type == bp_longjmp_master)
7405 struct breakpoint *new_b;
7407 new_b = momentary_breakpoint_from_master (b, bp_longjmp_call_dummy,
7408 &momentary_breakpoint_ops,
7410 new_b->thread = ptid_to_global_thread_id (inferior_ptid);
7412 /* Link NEW_B into the chain of RETVAL breakpoints. */
7414 gdb_assert (new_b->related_breakpoint == new_b);
7417 new_b->related_breakpoint = retval;
7418 while (retval->related_breakpoint != new_b->related_breakpoint)
7419 retval = retval->related_breakpoint;
7420 retval->related_breakpoint = new_b;
7426 /* Verify all existing dummy frames and their associated breakpoints for
7427 TP. Remove those which can no longer be found in the current frame
7430 You should call this function only at places where it is safe to currently
7431 unwind the whole stack. Failed stack unwind would discard live dummy
7435 check_longjmp_breakpoint_for_call_dummy (struct thread_info *tp)
7437 struct breakpoint *b, *b_tmp;
7439 ALL_BREAKPOINTS_SAFE (b, b_tmp)
7440 if (b->type == bp_longjmp_call_dummy && b->thread == tp->global_num)
7442 struct breakpoint *dummy_b = b->related_breakpoint;
7444 while (dummy_b != b && dummy_b->type != bp_call_dummy)
7445 dummy_b = dummy_b->related_breakpoint;
7446 if (dummy_b->type != bp_call_dummy
7447 || frame_find_by_id (dummy_b->frame_id) != NULL)
7450 dummy_frame_discard (dummy_b->frame_id, tp->ptid);
7452 while (b->related_breakpoint != b)
7454 if (b_tmp == b->related_breakpoint)
7455 b_tmp = b->related_breakpoint->next;
7456 delete_breakpoint (b->related_breakpoint);
7458 delete_breakpoint (b);
7463 enable_overlay_breakpoints (void)
7465 struct breakpoint *b;
7468 if (b->type == bp_overlay_event)
7470 b->enable_state = bp_enabled;
7471 update_global_location_list (UGLL_MAY_INSERT);
7472 overlay_events_enabled = 1;
7477 disable_overlay_breakpoints (void)
7479 struct breakpoint *b;
7482 if (b->type == bp_overlay_event)
7484 b->enable_state = bp_disabled;
7485 update_global_location_list (UGLL_DONT_INSERT);
7486 overlay_events_enabled = 0;
7490 /* Set an active std::terminate breakpoint for each std::terminate
7491 master breakpoint. */
7493 set_std_terminate_breakpoint (void)
7495 struct breakpoint *b, *b_tmp;
7497 ALL_BREAKPOINTS_SAFE (b, b_tmp)
7498 if (b->pspace == current_program_space
7499 && b->type == bp_std_terminate_master)
7501 momentary_breakpoint_from_master (b, bp_std_terminate,
7502 &momentary_breakpoint_ops, 1);
7506 /* Delete all the std::terminate breakpoints. */
7508 delete_std_terminate_breakpoint (void)
7510 struct breakpoint *b, *b_tmp;
7512 ALL_BREAKPOINTS_SAFE (b, b_tmp)
7513 if (b->type == bp_std_terminate)
7514 delete_breakpoint (b);
7518 create_thread_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
7520 struct breakpoint *b;
7522 b = create_internal_breakpoint (gdbarch, address, bp_thread_event,
7523 &internal_breakpoint_ops);
7525 b->enable_state = bp_enabled;
7526 /* location has to be used or breakpoint_re_set will delete me. */
7527 b->location = new_address_location (b->loc->address, NULL, 0);
7529 update_global_location_list_nothrow (UGLL_MAY_INSERT);
7534 struct lang_and_radix
7540 /* Create a breakpoint for JIT code registration and unregistration. */
7543 create_jit_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
7545 return create_internal_breakpoint (gdbarch, address, bp_jit_event,
7546 &internal_breakpoint_ops);
7549 /* Remove JIT code registration and unregistration breakpoint(s). */
7552 remove_jit_event_breakpoints (void)
7554 struct breakpoint *b, *b_tmp;
7556 ALL_BREAKPOINTS_SAFE (b, b_tmp)
7557 if (b->type == bp_jit_event
7558 && b->loc->pspace == current_program_space)
7559 delete_breakpoint (b);
7563 remove_solib_event_breakpoints (void)
7565 struct breakpoint *b, *b_tmp;
7567 ALL_BREAKPOINTS_SAFE (b, b_tmp)
7568 if (b->type == bp_shlib_event
7569 && b->loc->pspace == current_program_space)
7570 delete_breakpoint (b);
7573 /* See breakpoint.h. */
7576 remove_solib_event_breakpoints_at_next_stop (void)
7578 struct breakpoint *b, *b_tmp;
7580 ALL_BREAKPOINTS_SAFE (b, b_tmp)
7581 if (b->type == bp_shlib_event
7582 && b->loc->pspace == current_program_space)
7583 b->disposition = disp_del_at_next_stop;
7586 /* Helper for create_solib_event_breakpoint /
7587 create_and_insert_solib_event_breakpoint. Allows specifying which
7588 INSERT_MODE to pass through to update_global_location_list. */
7590 static struct breakpoint *
7591 create_solib_event_breakpoint_1 (struct gdbarch *gdbarch, CORE_ADDR address,
7592 enum ugll_insert_mode insert_mode)
7594 struct breakpoint *b;
7596 b = create_internal_breakpoint (gdbarch, address, bp_shlib_event,
7597 &internal_breakpoint_ops);
7598 update_global_location_list_nothrow (insert_mode);
7603 create_solib_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
7605 return create_solib_event_breakpoint_1 (gdbarch, address, UGLL_MAY_INSERT);
7608 /* See breakpoint.h. */
7611 create_and_insert_solib_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
7613 struct breakpoint *b;
7615 /* Explicitly tell update_global_location_list to insert
7617 b = create_solib_event_breakpoint_1 (gdbarch, address, UGLL_INSERT);
7618 if (!b->loc->inserted)
7620 delete_breakpoint (b);
7626 /* Disable any breakpoints that are on code in shared libraries. Only
7627 apply to enabled breakpoints, disabled ones can just stay disabled. */
7630 disable_breakpoints_in_shlibs (void)
7632 struct bp_location *loc, **locp_tmp;
7634 ALL_BP_LOCATIONS (loc, locp_tmp)
7636 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7637 struct breakpoint *b = loc->owner;
7639 /* We apply the check to all breakpoints, including disabled for
7640 those with loc->duplicate set. This is so that when breakpoint
7641 becomes enabled, or the duplicate is removed, gdb will try to
7642 insert all breakpoints. If we don't set shlib_disabled here,
7643 we'll try to insert those breakpoints and fail. */
7644 if (((b->type == bp_breakpoint)
7645 || (b->type == bp_jit_event)
7646 || (b->type == bp_hardware_breakpoint)
7647 || (is_tracepoint (b)))
7648 && loc->pspace == current_program_space
7649 && !loc->shlib_disabled
7650 && solib_name_from_address (loc->pspace, loc->address)
7653 loc->shlib_disabled = 1;
7658 /* Disable any breakpoints and tracepoints that are in SOLIB upon
7659 notification of unloaded_shlib. Only apply to enabled breakpoints,
7660 disabled ones can just stay disabled. */
7663 disable_breakpoints_in_unloaded_shlib (struct so_list *solib)
7665 struct bp_location *loc, **locp_tmp;
7666 int disabled_shlib_breaks = 0;
7668 ALL_BP_LOCATIONS (loc, locp_tmp)
7670 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7671 struct breakpoint *b = loc->owner;
7673 if (solib->pspace == loc->pspace
7674 && !loc->shlib_disabled
7675 && (((b->type == bp_breakpoint
7676 || b->type == bp_jit_event
7677 || b->type == bp_hardware_breakpoint)
7678 && (loc->loc_type == bp_loc_hardware_breakpoint
7679 || loc->loc_type == bp_loc_software_breakpoint))
7680 || is_tracepoint (b))
7681 && solib_contains_address_p (solib, loc->address))
7683 loc->shlib_disabled = 1;
7684 /* At this point, we cannot rely on remove_breakpoint
7685 succeeding so we must mark the breakpoint as not inserted
7686 to prevent future errors occurring in remove_breakpoints. */
7689 /* This may cause duplicate notifications for the same breakpoint. */
7690 observer_notify_breakpoint_modified (b);
7692 if (!disabled_shlib_breaks)
7694 target_terminal::ours_for_output ();
7695 warning (_("Temporarily disabling breakpoints "
7696 "for unloaded shared library \"%s\""),
7699 disabled_shlib_breaks = 1;
7704 /* Disable any breakpoints and tracepoints in OBJFILE upon
7705 notification of free_objfile. Only apply to enabled breakpoints,
7706 disabled ones can just stay disabled. */
7709 disable_breakpoints_in_freed_objfile (struct objfile *objfile)
7711 struct breakpoint *b;
7713 if (objfile == NULL)
7716 /* OBJF_SHARED|OBJF_USERLOADED objfiles are dynamic modules manually
7717 managed by the user with add-symbol-file/remove-symbol-file.
7718 Similarly to how breakpoints in shared libraries are handled in
7719 response to "nosharedlibrary", mark breakpoints in such modules
7720 shlib_disabled so they end up uninserted on the next global
7721 location list update. Shared libraries not loaded by the user
7722 aren't handled here -- they're already handled in
7723 disable_breakpoints_in_unloaded_shlib, called by solib.c's
7724 solib_unloaded observer. We skip objfiles that are not
7725 OBJF_SHARED as those aren't considered dynamic objects (e.g. the
7727 if ((objfile->flags & OBJF_SHARED) == 0
7728 || (objfile->flags & OBJF_USERLOADED) == 0)
7733 struct bp_location *loc;
7734 int bp_modified = 0;
7736 if (!is_breakpoint (b) && !is_tracepoint (b))
7739 for (loc = b->loc; loc != NULL; loc = loc->next)
7741 CORE_ADDR loc_addr = loc->address;
7743 if (loc->loc_type != bp_loc_hardware_breakpoint
7744 && loc->loc_type != bp_loc_software_breakpoint)
7747 if (loc->shlib_disabled != 0)
7750 if (objfile->pspace != loc->pspace)
7753 if (loc->loc_type != bp_loc_hardware_breakpoint
7754 && loc->loc_type != bp_loc_software_breakpoint)
7757 if (is_addr_in_objfile (loc_addr, objfile))
7759 loc->shlib_disabled = 1;
7760 /* At this point, we don't know whether the object was
7761 unmapped from the inferior or not, so leave the
7762 inserted flag alone. We'll handle failure to
7763 uninsert quietly, in case the object was indeed
7766 mark_breakpoint_location_modified (loc);
7773 observer_notify_breakpoint_modified (b);
7777 /* FORK & VFORK catchpoints. */
7779 /* An instance of this type is used to represent a fork or vfork
7780 catchpoint. A breakpoint is really of this type iff its ops pointer points
7781 to CATCH_FORK_BREAKPOINT_OPS. */
7783 struct fork_catchpoint : public breakpoint
7785 /* Process id of a child process whose forking triggered this
7786 catchpoint. This field is only valid immediately after this
7787 catchpoint has triggered. */
7788 ptid_t forked_inferior_pid;
7791 /* Implement the "insert" breakpoint_ops method for fork
7795 insert_catch_fork (struct bp_location *bl)
7797 return target_insert_fork_catchpoint (ptid_get_pid (inferior_ptid));
7800 /* Implement the "remove" breakpoint_ops method for fork
7804 remove_catch_fork (struct bp_location *bl, enum remove_bp_reason reason)
7806 return target_remove_fork_catchpoint (ptid_get_pid (inferior_ptid));
7809 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
7813 breakpoint_hit_catch_fork (const struct bp_location *bl,
7814 const address_space *aspace, CORE_ADDR bp_addr,
7815 const struct target_waitstatus *ws)
7817 struct fork_catchpoint *c = (struct fork_catchpoint *) bl->owner;
7819 if (ws->kind != TARGET_WAITKIND_FORKED)
7822 c->forked_inferior_pid = ws->value.related_pid;
7826 /* Implement the "print_it" breakpoint_ops method for fork
7829 static enum print_stop_action
7830 print_it_catch_fork (bpstat bs)
7832 struct ui_out *uiout = current_uiout;
7833 struct breakpoint *b = bs->breakpoint_at;
7834 struct fork_catchpoint *c = (struct fork_catchpoint *) bs->breakpoint_at;
7836 annotate_catchpoint (b->number);
7837 maybe_print_thread_hit_breakpoint (uiout);
7838 if (b->disposition == disp_del)
7839 uiout->text ("Temporary catchpoint ");
7841 uiout->text ("Catchpoint ");
7842 if (uiout->is_mi_like_p ())
7844 uiout->field_string ("reason", async_reason_lookup (EXEC_ASYNC_FORK));
7845 uiout->field_string ("disp", bpdisp_text (b->disposition));
7847 uiout->field_int ("bkptno", b->number);
7848 uiout->text (" (forked process ");
7849 uiout->field_int ("newpid", ptid_get_pid (c->forked_inferior_pid));
7850 uiout->text ("), ");
7851 return PRINT_SRC_AND_LOC;
7854 /* Implement the "print_one" breakpoint_ops method for fork
7858 print_one_catch_fork (struct breakpoint *b, struct bp_location **last_loc)
7860 struct fork_catchpoint *c = (struct fork_catchpoint *) b;
7861 struct value_print_options opts;
7862 struct ui_out *uiout = current_uiout;
7864 get_user_print_options (&opts);
7866 /* Field 4, the address, is omitted (which makes the columns not
7867 line up too nicely with the headers, but the effect is relatively
7869 if (opts.addressprint)
7870 uiout->field_skip ("addr");
7872 uiout->text ("fork");
7873 if (!ptid_equal (c->forked_inferior_pid, null_ptid))
7875 uiout->text (", process ");
7876 uiout->field_int ("what", ptid_get_pid (c->forked_inferior_pid));
7880 if (uiout->is_mi_like_p ())
7881 uiout->field_string ("catch-type", "fork");
7884 /* Implement the "print_mention" breakpoint_ops method for fork
7888 print_mention_catch_fork (struct breakpoint *b)
7890 printf_filtered (_("Catchpoint %d (fork)"), b->number);
7893 /* Implement the "print_recreate" breakpoint_ops method for fork
7897 print_recreate_catch_fork (struct breakpoint *b, struct ui_file *fp)
7899 fprintf_unfiltered (fp, "catch fork");
7900 print_recreate_thread (b, fp);
7903 /* The breakpoint_ops structure to be used in fork catchpoints. */
7905 static struct breakpoint_ops catch_fork_breakpoint_ops;
7907 /* Implement the "insert" breakpoint_ops method for vfork
7911 insert_catch_vfork (struct bp_location *bl)
7913 return target_insert_vfork_catchpoint (ptid_get_pid (inferior_ptid));
7916 /* Implement the "remove" breakpoint_ops method for vfork
7920 remove_catch_vfork (struct bp_location *bl, enum remove_bp_reason reason)
7922 return target_remove_vfork_catchpoint (ptid_get_pid (inferior_ptid));
7925 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
7929 breakpoint_hit_catch_vfork (const struct bp_location *bl,
7930 const address_space *aspace, CORE_ADDR bp_addr,
7931 const struct target_waitstatus *ws)
7933 struct fork_catchpoint *c = (struct fork_catchpoint *) bl->owner;
7935 if (ws->kind != TARGET_WAITKIND_VFORKED)
7938 c->forked_inferior_pid = ws->value.related_pid;
7942 /* Implement the "print_it" breakpoint_ops method for vfork
7945 static enum print_stop_action
7946 print_it_catch_vfork (bpstat bs)
7948 struct ui_out *uiout = current_uiout;
7949 struct breakpoint *b = bs->breakpoint_at;
7950 struct fork_catchpoint *c = (struct fork_catchpoint *) b;
7952 annotate_catchpoint (b->number);
7953 maybe_print_thread_hit_breakpoint (uiout);
7954 if (b->disposition == disp_del)
7955 uiout->text ("Temporary catchpoint ");
7957 uiout->text ("Catchpoint ");
7958 if (uiout->is_mi_like_p ())
7960 uiout->field_string ("reason", async_reason_lookup (EXEC_ASYNC_VFORK));
7961 uiout->field_string ("disp", bpdisp_text (b->disposition));
7963 uiout->field_int ("bkptno", b->number);
7964 uiout->text (" (vforked process ");
7965 uiout->field_int ("newpid", ptid_get_pid (c->forked_inferior_pid));
7966 uiout->text ("), ");
7967 return PRINT_SRC_AND_LOC;
7970 /* Implement the "print_one" breakpoint_ops method for vfork
7974 print_one_catch_vfork (struct breakpoint *b, struct bp_location **last_loc)
7976 struct fork_catchpoint *c = (struct fork_catchpoint *) b;
7977 struct value_print_options opts;
7978 struct ui_out *uiout = current_uiout;
7980 get_user_print_options (&opts);
7981 /* Field 4, the address, is omitted (which makes the columns not
7982 line up too nicely with the headers, but the effect is relatively
7984 if (opts.addressprint)
7985 uiout->field_skip ("addr");
7987 uiout->text ("vfork");
7988 if (!ptid_equal (c->forked_inferior_pid, null_ptid))
7990 uiout->text (", process ");
7991 uiout->field_int ("what", ptid_get_pid (c->forked_inferior_pid));
7995 if (uiout->is_mi_like_p ())
7996 uiout->field_string ("catch-type", "vfork");
7999 /* Implement the "print_mention" breakpoint_ops method for vfork
8003 print_mention_catch_vfork (struct breakpoint *b)
8005 printf_filtered (_("Catchpoint %d (vfork)"), b->number);
8008 /* Implement the "print_recreate" breakpoint_ops method for vfork
8012 print_recreate_catch_vfork (struct breakpoint *b, struct ui_file *fp)
8014 fprintf_unfiltered (fp, "catch vfork");
8015 print_recreate_thread (b, fp);
8018 /* The breakpoint_ops structure to be used in vfork catchpoints. */
8020 static struct breakpoint_ops catch_vfork_breakpoint_ops;
8022 /* An instance of this type is used to represent an solib catchpoint.
8023 A breakpoint is really of this type iff its ops pointer points to
8024 CATCH_SOLIB_BREAKPOINT_OPS. */
8026 struct solib_catchpoint : public breakpoint
8028 ~solib_catchpoint () override;
8030 /* True for "catch load", false for "catch unload". */
8031 unsigned char is_load;
8033 /* Regular expression to match, if any. COMPILED is only valid when
8034 REGEX is non-NULL. */
8036 std::unique_ptr<compiled_regex> compiled;
8039 solib_catchpoint::~solib_catchpoint ()
8041 xfree (this->regex);
8045 insert_catch_solib (struct bp_location *ignore)
8051 remove_catch_solib (struct bp_location *ignore, enum remove_bp_reason reason)
8057 breakpoint_hit_catch_solib (const struct bp_location *bl,
8058 const address_space *aspace,
8060 const struct target_waitstatus *ws)
8062 struct solib_catchpoint *self = (struct solib_catchpoint *) bl->owner;
8063 struct breakpoint *other;
8065 if (ws->kind == TARGET_WAITKIND_LOADED)
8068 ALL_BREAKPOINTS (other)
8070 struct bp_location *other_bl;
8072 if (other == bl->owner)
8075 if (other->type != bp_shlib_event)
8078 if (self->pspace != NULL && other->pspace != self->pspace)
8081 for (other_bl = other->loc; other_bl != NULL; other_bl = other_bl->next)
8083 if (other->ops->breakpoint_hit (other_bl, aspace, bp_addr, ws))
8092 check_status_catch_solib (struct bpstats *bs)
8094 struct solib_catchpoint *self
8095 = (struct solib_catchpoint *) bs->breakpoint_at;
8100 struct so_list *iter;
8103 VEC_iterate (so_list_ptr, current_program_space->added_solibs,
8108 || self->compiled->exec (iter->so_name, 0, NULL, 0) == 0)
8117 VEC_iterate (char_ptr, current_program_space->deleted_solibs,
8122 || self->compiled->exec (iter, 0, NULL, 0) == 0)
8128 bs->print_it = print_it_noop;
8131 static enum print_stop_action
8132 print_it_catch_solib (bpstat bs)
8134 struct breakpoint *b = bs->breakpoint_at;
8135 struct ui_out *uiout = current_uiout;
8137 annotate_catchpoint (b->number);
8138 maybe_print_thread_hit_breakpoint (uiout);
8139 if (b->disposition == disp_del)
8140 uiout->text ("Temporary catchpoint ");
8142 uiout->text ("Catchpoint ");
8143 uiout->field_int ("bkptno", b->number);
8145 if (uiout->is_mi_like_p ())
8146 uiout->field_string ("disp", bpdisp_text (b->disposition));
8147 print_solib_event (1);
8148 return PRINT_SRC_AND_LOC;
8152 print_one_catch_solib (struct breakpoint *b, struct bp_location **locs)
8154 struct solib_catchpoint *self = (struct solib_catchpoint *) b;
8155 struct value_print_options opts;
8156 struct ui_out *uiout = current_uiout;
8159 get_user_print_options (&opts);
8160 /* Field 4, the address, is omitted (which makes the columns not
8161 line up too nicely with the headers, but the effect is relatively
8163 if (opts.addressprint)
8166 uiout->field_skip ("addr");
8173 msg = xstrprintf (_("load of library matching %s"), self->regex);
8175 msg = xstrdup (_("load of library"));
8180 msg = xstrprintf (_("unload of library matching %s"), self->regex);
8182 msg = xstrdup (_("unload of library"));
8184 uiout->field_string ("what", msg);
8187 if (uiout->is_mi_like_p ())
8188 uiout->field_string ("catch-type", self->is_load ? "load" : "unload");
8192 print_mention_catch_solib (struct breakpoint *b)
8194 struct solib_catchpoint *self = (struct solib_catchpoint *) b;
8196 printf_filtered (_("Catchpoint %d (%s)"), b->number,
8197 self->is_load ? "load" : "unload");
8201 print_recreate_catch_solib (struct breakpoint *b, struct ui_file *fp)
8203 struct solib_catchpoint *self = (struct solib_catchpoint *) b;
8205 fprintf_unfiltered (fp, "%s %s",
8206 b->disposition == disp_del ? "tcatch" : "catch",
8207 self->is_load ? "load" : "unload");
8209 fprintf_unfiltered (fp, " %s", self->regex);
8210 fprintf_unfiltered (fp, "\n");
8213 static struct breakpoint_ops catch_solib_breakpoint_ops;
8215 /* Shared helper function (MI and CLI) for creating and installing
8216 a shared object event catchpoint. If IS_LOAD is non-zero then
8217 the events to be caught are load events, otherwise they are
8218 unload events. If IS_TEMP is non-zero the catchpoint is a
8219 temporary one. If ENABLED is non-zero the catchpoint is
8220 created in an enabled state. */
8223 add_solib_catchpoint (const char *arg, int is_load, int is_temp, int enabled)
8225 struct gdbarch *gdbarch = get_current_arch ();
8229 arg = skip_spaces (arg);
8231 std::unique_ptr<solib_catchpoint> c (new solib_catchpoint ());
8235 c->compiled.reset (new compiled_regex (arg, REG_NOSUB,
8236 _("Invalid regexp")));
8237 c->regex = xstrdup (arg);
8240 c->is_load = is_load;
8241 init_catchpoint (c.get (), gdbarch, is_temp, NULL,
8242 &catch_solib_breakpoint_ops);
8244 c->enable_state = enabled ? bp_enabled : bp_disabled;
8246 install_breakpoint (0, std::move (c), 1);
8249 /* A helper function that does all the work for "catch load" and
8253 catch_load_or_unload (char *arg, int from_tty, int is_load,
8254 struct cmd_list_element *command)
8257 const int enabled = 1;
8259 tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
8261 add_solib_catchpoint (arg, is_load, tempflag, enabled);
8265 catch_load_command_1 (char *arg, int from_tty,
8266 struct cmd_list_element *command)
8268 catch_load_or_unload (arg, from_tty, 1, command);
8272 catch_unload_command_1 (char *arg, int from_tty,
8273 struct cmd_list_element *command)
8275 catch_load_or_unload (arg, from_tty, 0, command);
8278 /* Initialize a new breakpoint of the bp_catchpoint kind. If TEMPFLAG
8279 is non-zero, then make the breakpoint temporary. If COND_STRING is
8280 not NULL, then store it in the breakpoint. OPS, if not NULL, is
8281 the breakpoint_ops structure associated to the catchpoint. */
8284 init_catchpoint (struct breakpoint *b,
8285 struct gdbarch *gdbarch, int tempflag,
8286 const char *cond_string,
8287 const struct breakpoint_ops *ops)
8289 symtab_and_line sal;
8290 sal.pspace = current_program_space;
8292 init_raw_breakpoint (b, gdbarch, sal, bp_catchpoint, ops);
8294 b->cond_string = (cond_string == NULL) ? NULL : xstrdup (cond_string);
8295 b->disposition = tempflag ? disp_del : disp_donttouch;
8299 install_breakpoint (int internal, std::unique_ptr<breakpoint> &&arg, int update_gll)
8301 breakpoint *b = add_to_breakpoint_chain (std::move (arg));
8302 set_breakpoint_number (internal, b);
8303 if (is_tracepoint (b))
8304 set_tracepoint_count (breakpoint_count);
8307 observer_notify_breakpoint_created (b);
8310 update_global_location_list (UGLL_MAY_INSERT);
8314 create_fork_vfork_event_catchpoint (struct gdbarch *gdbarch,
8315 int tempflag, const char *cond_string,
8316 const struct breakpoint_ops *ops)
8318 std::unique_ptr<fork_catchpoint> c (new fork_catchpoint ());
8320 init_catchpoint (c.get (), gdbarch, tempflag, cond_string, ops);
8322 c->forked_inferior_pid = null_ptid;
8324 install_breakpoint (0, std::move (c), 1);
8327 /* Exec catchpoints. */
8329 /* An instance of this type is used to represent an exec catchpoint.
8330 A breakpoint is really of this type iff its ops pointer points to
8331 CATCH_EXEC_BREAKPOINT_OPS. */
8333 struct exec_catchpoint : public breakpoint
8335 ~exec_catchpoint () override;
8337 /* Filename of a program whose exec triggered this catchpoint.
8338 This field is only valid immediately after this catchpoint has
8340 char *exec_pathname;
8343 /* Exec catchpoint destructor. */
8345 exec_catchpoint::~exec_catchpoint ()
8347 xfree (this->exec_pathname);
8351 insert_catch_exec (struct bp_location *bl)
8353 return target_insert_exec_catchpoint (ptid_get_pid (inferior_ptid));
8357 remove_catch_exec (struct bp_location *bl, enum remove_bp_reason reason)
8359 return target_remove_exec_catchpoint (ptid_get_pid (inferior_ptid));
8363 breakpoint_hit_catch_exec (const struct bp_location *bl,
8364 const address_space *aspace, CORE_ADDR bp_addr,
8365 const struct target_waitstatus *ws)
8367 struct exec_catchpoint *c = (struct exec_catchpoint *) bl->owner;
8369 if (ws->kind != TARGET_WAITKIND_EXECD)
8372 c->exec_pathname = xstrdup (ws->value.execd_pathname);
8376 static enum print_stop_action
8377 print_it_catch_exec (bpstat bs)
8379 struct ui_out *uiout = current_uiout;
8380 struct breakpoint *b = bs->breakpoint_at;
8381 struct exec_catchpoint *c = (struct exec_catchpoint *) b;
8383 annotate_catchpoint (b->number);
8384 maybe_print_thread_hit_breakpoint (uiout);
8385 if (b->disposition == disp_del)
8386 uiout->text ("Temporary catchpoint ");
8388 uiout->text ("Catchpoint ");
8389 if (uiout->is_mi_like_p ())
8391 uiout->field_string ("reason", async_reason_lookup (EXEC_ASYNC_EXEC));
8392 uiout->field_string ("disp", bpdisp_text (b->disposition));
8394 uiout->field_int ("bkptno", b->number);
8395 uiout->text (" (exec'd ");
8396 uiout->field_string ("new-exec", c->exec_pathname);
8397 uiout->text ("), ");
8399 return PRINT_SRC_AND_LOC;
8403 print_one_catch_exec (struct breakpoint *b, struct bp_location **last_loc)
8405 struct exec_catchpoint *c = (struct exec_catchpoint *) b;
8406 struct value_print_options opts;
8407 struct ui_out *uiout = current_uiout;
8409 get_user_print_options (&opts);
8411 /* Field 4, the address, is omitted (which makes the columns
8412 not line up too nicely with the headers, but the effect
8413 is relatively readable). */
8414 if (opts.addressprint)
8415 uiout->field_skip ("addr");
8417 uiout->text ("exec");
8418 if (c->exec_pathname != NULL)
8420 uiout->text (", program \"");
8421 uiout->field_string ("what", c->exec_pathname);
8422 uiout->text ("\" ");
8425 if (uiout->is_mi_like_p ())
8426 uiout->field_string ("catch-type", "exec");
8430 print_mention_catch_exec (struct breakpoint *b)
8432 printf_filtered (_("Catchpoint %d (exec)"), b->number);
8435 /* Implement the "print_recreate" breakpoint_ops method for exec
8439 print_recreate_catch_exec (struct breakpoint *b, struct ui_file *fp)
8441 fprintf_unfiltered (fp, "catch exec");
8442 print_recreate_thread (b, fp);
8445 static struct breakpoint_ops catch_exec_breakpoint_ops;
8448 hw_breakpoint_used_count (void)
8451 struct breakpoint *b;
8452 struct bp_location *bl;
8456 if (b->type == bp_hardware_breakpoint && breakpoint_enabled (b))
8457 for (bl = b->loc; bl; bl = bl->next)
8459 /* Special types of hardware breakpoints may use more than
8461 i += b->ops->resources_needed (bl);
8468 /* Returns the resources B would use if it were a hardware
8472 hw_watchpoint_use_count (struct breakpoint *b)
8475 struct bp_location *bl;
8477 if (!breakpoint_enabled (b))
8480 for (bl = b->loc; bl; bl = bl->next)
8482 /* Special types of hardware watchpoints may use more than
8484 i += b->ops->resources_needed (bl);
8490 /* Returns the sum the used resources of all hardware watchpoints of
8491 type TYPE in the breakpoints list. Also returns in OTHER_TYPE_USED
8492 the sum of the used resources of all hardware watchpoints of other
8493 types _not_ TYPE. */
8496 hw_watchpoint_used_count_others (struct breakpoint *except,
8497 enum bptype type, int *other_type_used)
8500 struct breakpoint *b;
8502 *other_type_used = 0;
8507 if (!breakpoint_enabled (b))
8510 if (b->type == type)
8511 i += hw_watchpoint_use_count (b);
8512 else if (is_hardware_watchpoint (b))
8513 *other_type_used = 1;
8520 disable_watchpoints_before_interactive_call_start (void)
8522 struct breakpoint *b;
8526 if (is_watchpoint (b) && breakpoint_enabled (b))
8528 b->enable_state = bp_call_disabled;
8529 update_global_location_list (UGLL_DONT_INSERT);
8535 enable_watchpoints_after_interactive_call_stop (void)
8537 struct breakpoint *b;
8541 if (is_watchpoint (b) && b->enable_state == bp_call_disabled)
8543 b->enable_state = bp_enabled;
8544 update_global_location_list (UGLL_MAY_INSERT);
8550 disable_breakpoints_before_startup (void)
8552 current_program_space->executing_startup = 1;
8553 update_global_location_list (UGLL_DONT_INSERT);
8557 enable_breakpoints_after_startup (void)
8559 current_program_space->executing_startup = 0;
8560 breakpoint_re_set ();
8563 /* Create a new single-step breakpoint for thread THREAD, with no
8566 static struct breakpoint *
8567 new_single_step_breakpoint (int thread, struct gdbarch *gdbarch)
8569 std::unique_ptr<breakpoint> b (new breakpoint ());
8571 init_raw_breakpoint_without_location (b.get (), gdbarch, bp_single_step,
8572 &momentary_breakpoint_ops);
8574 b->disposition = disp_donttouch;
8575 b->frame_id = null_frame_id;
8578 gdb_assert (b->thread != 0);
8580 return add_to_breakpoint_chain (std::move (b));
8583 /* Set a momentary breakpoint of type TYPE at address specified by
8584 SAL. If FRAME_ID is valid, the breakpoint is restricted to that
8588 set_momentary_breakpoint (struct gdbarch *gdbarch, struct symtab_and_line sal,
8589 struct frame_id frame_id, enum bptype type)
8591 struct breakpoint *b;
8593 /* If FRAME_ID is valid, it should be a real frame, not an inlined or
8595 gdb_assert (!frame_id_artificial_p (frame_id));
8597 b = set_raw_breakpoint (gdbarch, sal, type, &momentary_breakpoint_ops);
8598 b->enable_state = bp_enabled;
8599 b->disposition = disp_donttouch;
8600 b->frame_id = frame_id;
8602 /* If we're debugging a multi-threaded program, then we want
8603 momentary breakpoints to be active in only a single thread of
8605 if (in_thread_list (inferior_ptid))
8606 b->thread = ptid_to_global_thread_id (inferior_ptid);
8608 update_global_location_list_nothrow (UGLL_MAY_INSERT);
8613 /* Make a momentary breakpoint based on the master breakpoint ORIG.
8614 The new breakpoint will have type TYPE, use OPS as its
8615 breakpoint_ops, and will set enabled to LOC_ENABLED. */
8617 static struct breakpoint *
8618 momentary_breakpoint_from_master (struct breakpoint *orig,
8620 const struct breakpoint_ops *ops,
8623 struct breakpoint *copy;
8625 copy = set_raw_breakpoint_without_location (orig->gdbarch, type, ops);
8626 copy->loc = allocate_bp_location (copy);
8627 set_breakpoint_location_function (copy->loc, 1);
8629 copy->loc->gdbarch = orig->loc->gdbarch;
8630 copy->loc->requested_address = orig->loc->requested_address;
8631 copy->loc->address = orig->loc->address;
8632 copy->loc->section = orig->loc->section;
8633 copy->loc->pspace = orig->loc->pspace;
8634 copy->loc->probe = orig->loc->probe;
8635 copy->loc->line_number = orig->loc->line_number;
8636 copy->loc->symtab = orig->loc->symtab;
8637 copy->loc->enabled = loc_enabled;
8638 copy->frame_id = orig->frame_id;
8639 copy->thread = orig->thread;
8640 copy->pspace = orig->pspace;
8642 copy->enable_state = bp_enabled;
8643 copy->disposition = disp_donttouch;
8644 copy->number = internal_breakpoint_number--;
8646 update_global_location_list_nothrow (UGLL_DONT_INSERT);
8650 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
8654 clone_momentary_breakpoint (struct breakpoint *orig)
8656 /* If there's nothing to clone, then return nothing. */
8660 return momentary_breakpoint_from_master (orig, orig->type, orig->ops, 0);
8664 set_momentary_breakpoint_at_pc (struct gdbarch *gdbarch, CORE_ADDR pc,
8667 struct symtab_and_line sal;
8669 sal = find_pc_line (pc, 0);
8671 sal.section = find_pc_overlay (pc);
8672 sal.explicit_pc = 1;
8674 return set_momentary_breakpoint (gdbarch, sal, null_frame_id, type);
8678 /* Tell the user we have just set a breakpoint B. */
8681 mention (struct breakpoint *b)
8683 b->ops->print_mention (b);
8684 if (current_uiout->is_mi_like_p ())
8686 printf_filtered ("\n");
8690 static int bp_loc_is_permanent (struct bp_location *loc);
8692 static struct bp_location *
8693 add_location_to_breakpoint (struct breakpoint *b,
8694 const struct symtab_and_line *sal)
8696 struct bp_location *loc, **tmp;
8697 CORE_ADDR adjusted_address;
8698 struct gdbarch *loc_gdbarch = get_sal_arch (*sal);
8700 if (loc_gdbarch == NULL)
8701 loc_gdbarch = b->gdbarch;
8703 /* Adjust the breakpoint's address prior to allocating a location.
8704 Once we call allocate_bp_location(), that mostly uninitialized
8705 location will be placed on the location chain. Adjustment of the
8706 breakpoint may cause target_read_memory() to be called and we do
8707 not want its scan of the location chain to find a breakpoint and
8708 location that's only been partially initialized. */
8709 adjusted_address = adjust_breakpoint_address (loc_gdbarch,
8712 /* Sort the locations by their ADDRESS. */
8713 loc = allocate_bp_location (b);
8714 for (tmp = &(b->loc); *tmp != NULL && (*tmp)->address <= adjusted_address;
8715 tmp = &((*tmp)->next))
8720 loc->requested_address = sal->pc;
8721 loc->address = adjusted_address;
8722 loc->pspace = sal->pspace;
8723 loc->probe.probe = sal->probe;
8724 loc->probe.objfile = sal->objfile;
8725 gdb_assert (loc->pspace != NULL);
8726 loc->section = sal->section;
8727 loc->gdbarch = loc_gdbarch;
8728 loc->line_number = sal->line;
8729 loc->symtab = sal->symtab;
8730 loc->symbol = sal->symbol;
8732 set_breakpoint_location_function (loc,
8733 sal->explicit_pc || sal->explicit_line);
8735 /* While by definition, permanent breakpoints are already present in the
8736 code, we don't mark the location as inserted. Normally one would expect
8737 that GDB could rely on that breakpoint instruction to stop the program,
8738 thus removing the need to insert its own breakpoint, except that executing
8739 the breakpoint instruction can kill the target instead of reporting a
8740 SIGTRAP. E.g., on SPARC, when interrupts are disabled, executing the
8741 instruction resets the CPU, so QEMU 2.0.0 for SPARC correspondingly dies
8742 with "Trap 0x02 while interrupts disabled, Error state". Letting the
8743 breakpoint be inserted normally results in QEMU knowing about the GDB
8744 breakpoint, and thus trap before the breakpoint instruction is executed.
8745 (If GDB later needs to continue execution past the permanent breakpoint,
8746 it manually increments the PC, thus avoiding executing the breakpoint
8748 if (bp_loc_is_permanent (loc))
8755 /* See breakpoint.h. */
8758 program_breakpoint_here_p (struct gdbarch *gdbarch, CORE_ADDR address)
8762 const gdb_byte *bpoint;
8763 gdb_byte *target_mem;
8766 bpoint = gdbarch_breakpoint_from_pc (gdbarch, &addr, &len);
8768 /* Software breakpoints unsupported? */
8772 target_mem = (gdb_byte *) alloca (len);
8774 /* Enable the automatic memory restoration from breakpoints while
8775 we read the memory. Otherwise we could say about our temporary
8776 breakpoints they are permanent. */
8777 scoped_restore restore_memory
8778 = make_scoped_restore_show_memory_breakpoints (0);
8780 if (target_read_memory (address, target_mem, len) == 0
8781 && memcmp (target_mem, bpoint, len) == 0)
8787 /* Return 1 if LOC is pointing to a permanent breakpoint,
8788 return 0 otherwise. */
8791 bp_loc_is_permanent (struct bp_location *loc)
8793 gdb_assert (loc != NULL);
8795 /* If we have a catchpoint or a watchpoint, just return 0. We should not
8796 attempt to read from the addresses the locations of these breakpoint types
8797 point to. program_breakpoint_here_p, below, will attempt to read
8799 if (!breakpoint_address_is_meaningful (loc->owner))
8802 scoped_restore_current_pspace_and_thread restore_pspace_thread;
8803 switch_to_program_space_and_thread (loc->pspace);
8804 return program_breakpoint_here_p (loc->gdbarch, loc->address);
8807 /* Build a command list for the dprintf corresponding to the current
8808 settings of the dprintf style options. */
8811 update_dprintf_command_list (struct breakpoint *b)
8813 char *dprintf_args = b->extra_string;
8814 char *printf_line = NULL;
8819 dprintf_args = skip_spaces (dprintf_args);
8821 /* Allow a comma, as it may have terminated a location, but don't
8823 if (*dprintf_args == ',')
8825 dprintf_args = skip_spaces (dprintf_args);
8827 if (*dprintf_args != '"')
8828 error (_("Bad format string, missing '\"'."));
8830 if (strcmp (dprintf_style, dprintf_style_gdb) == 0)
8831 printf_line = xstrprintf ("printf %s", dprintf_args);
8832 else if (strcmp (dprintf_style, dprintf_style_call) == 0)
8834 if (!dprintf_function)
8835 error (_("No function supplied for dprintf call"));
8837 if (dprintf_channel && strlen (dprintf_channel) > 0)
8838 printf_line = xstrprintf ("call (void) %s (%s,%s)",
8843 printf_line = xstrprintf ("call (void) %s (%s)",
8847 else if (strcmp (dprintf_style, dprintf_style_agent) == 0)
8849 if (target_can_run_breakpoint_commands ())
8850 printf_line = xstrprintf ("agent-printf %s", dprintf_args);
8853 warning (_("Target cannot run dprintf commands, falling back to GDB printf"));
8854 printf_line = xstrprintf ("printf %s", dprintf_args);
8858 internal_error (__FILE__, __LINE__,
8859 _("Invalid dprintf style."));
8861 gdb_assert (printf_line != NULL);
8862 /* Manufacture a printf sequence. */
8864 struct command_line *printf_cmd_line = XNEW (struct command_line);
8866 printf_cmd_line->control_type = simple_control;
8867 printf_cmd_line->body_count = 0;
8868 printf_cmd_line->body_list = NULL;
8869 printf_cmd_line->next = NULL;
8870 printf_cmd_line->line = printf_line;
8872 breakpoint_set_commands (b, command_line_up (printf_cmd_line));
8876 /* Update all dprintf commands, making their command lists reflect
8877 current style settings. */
8880 update_dprintf_commands (char *args, int from_tty,
8881 struct cmd_list_element *c)
8883 struct breakpoint *b;
8887 if (b->type == bp_dprintf)
8888 update_dprintf_command_list (b);
8892 /* Create a breakpoint with SAL as location. Use LOCATION
8893 as a description of the location, and COND_STRING
8894 as condition expression. If LOCATION is NULL then create an
8895 "address location" from the address in the SAL. */
8898 init_breakpoint_sal (struct breakpoint *b, struct gdbarch *gdbarch,
8899 gdb::array_view<const symtab_and_line> sals,
8900 event_location_up &&location,
8901 gdb::unique_xmalloc_ptr<char> filter,
8902 gdb::unique_xmalloc_ptr<char> cond_string,
8903 gdb::unique_xmalloc_ptr<char> extra_string,
8904 enum bptype type, enum bpdisp disposition,
8905 int thread, int task, int ignore_count,
8906 const struct breakpoint_ops *ops, int from_tty,
8907 int enabled, int internal, unsigned flags,
8908 int display_canonical)
8912 if (type == bp_hardware_breakpoint)
8914 int target_resources_ok;
8916 i = hw_breakpoint_used_count ();
8917 target_resources_ok =
8918 target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
8920 if (target_resources_ok == 0)
8921 error (_("No hardware breakpoint support in the target."));
8922 else if (target_resources_ok < 0)
8923 error (_("Hardware breakpoints used exceeds limit."));
8926 gdb_assert (!sals.empty ());
8928 for (const auto &sal : sals)
8930 struct bp_location *loc;
8934 struct gdbarch *loc_gdbarch = get_sal_arch (sal);
8936 loc_gdbarch = gdbarch;
8938 describe_other_breakpoints (loc_gdbarch,
8939 sal.pspace, sal.pc, sal.section, thread);
8942 if (&sal == &sals[0])
8944 init_raw_breakpoint (b, gdbarch, sal, type, ops);
8948 b->cond_string = cond_string.release ();
8949 b->extra_string = extra_string.release ();
8950 b->ignore_count = ignore_count;
8951 b->enable_state = enabled ? bp_enabled : bp_disabled;
8952 b->disposition = disposition;
8954 if ((flags & CREATE_BREAKPOINT_FLAGS_INSERTED) != 0)
8955 b->loc->inserted = 1;
8957 if (type == bp_static_tracepoint)
8959 struct tracepoint *t = (struct tracepoint *) b;
8960 struct static_tracepoint_marker marker;
8962 if (strace_marker_p (b))
8964 /* We already know the marker exists, otherwise, we
8965 wouldn't see a sal for it. */
8967 = &event_location_to_string (b->location.get ())[3];
8971 p = skip_spaces (p);
8973 endp = skip_to_space (p);
8975 marker_str = savestring (p, endp - p);
8976 t->static_trace_marker_id = marker_str;
8978 printf_filtered (_("Probed static tracepoint "
8980 t->static_trace_marker_id);
8982 else if (target_static_tracepoint_marker_at (sal.pc, &marker))
8984 t->static_trace_marker_id = xstrdup (marker.str_id);
8985 release_static_tracepoint_marker (&marker);
8987 printf_filtered (_("Probed static tracepoint "
8989 t->static_trace_marker_id);
8992 warning (_("Couldn't determine the static "
8993 "tracepoint marker to probe"));
9000 loc = add_location_to_breakpoint (b, &sal);
9001 if ((flags & CREATE_BREAKPOINT_FLAGS_INSERTED) != 0)
9007 const char *arg = b->cond_string;
9009 loc->cond = parse_exp_1 (&arg, loc->address,
9010 block_for_pc (loc->address), 0);
9012 error (_("Garbage '%s' follows condition"), arg);
9015 /* Dynamic printf requires and uses additional arguments on the
9016 command line, otherwise it's an error. */
9017 if (type == bp_dprintf)
9019 if (b->extra_string)
9020 update_dprintf_command_list (b);
9022 error (_("Format string required"));
9024 else if (b->extra_string)
9025 error (_("Garbage '%s' at end of command"), b->extra_string);
9028 b->display_canonical = display_canonical;
9029 if (location != NULL)
9030 b->location = std::move (location);
9032 b->location = new_address_location (b->loc->address, NULL, 0);
9033 b->filter = filter.release ();
9037 create_breakpoint_sal (struct gdbarch *gdbarch,
9038 gdb::array_view<const symtab_and_line> sals,
9039 event_location_up &&location,
9040 gdb::unique_xmalloc_ptr<char> filter,
9041 gdb::unique_xmalloc_ptr<char> cond_string,
9042 gdb::unique_xmalloc_ptr<char> extra_string,
9043 enum bptype type, enum bpdisp disposition,
9044 int thread, int task, int ignore_count,
9045 const struct breakpoint_ops *ops, int from_tty,
9046 int enabled, int internal, unsigned flags,
9047 int display_canonical)
9049 std::unique_ptr<breakpoint> b = new_breakpoint_from_type (type);
9051 init_breakpoint_sal (b.get (), gdbarch,
9052 sals, std::move (location),
9054 std::move (cond_string),
9055 std::move (extra_string),
9057 thread, task, ignore_count,
9059 enabled, internal, flags,
9062 install_breakpoint (internal, std::move (b), 0);
9065 /* Add SALS.nelts breakpoints to the breakpoint table. For each
9066 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
9067 value. COND_STRING, if not NULL, specified the condition to be
9068 used for all breakpoints. Essentially the only case where
9069 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
9070 function. In that case, it's still not possible to specify
9071 separate conditions for different overloaded functions, so
9072 we take just a single condition string.
9074 NOTE: If the function succeeds, the caller is expected to cleanup
9075 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
9076 array contents). If the function fails (error() is called), the
9077 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
9078 COND and SALS arrays and each of those arrays contents. */
9081 create_breakpoints_sal (struct gdbarch *gdbarch,
9082 struct linespec_result *canonical,
9083 gdb::unique_xmalloc_ptr<char> cond_string,
9084 gdb::unique_xmalloc_ptr<char> extra_string,
9085 enum bptype type, enum bpdisp disposition,
9086 int thread, int task, int ignore_count,
9087 const struct breakpoint_ops *ops, int from_tty,
9088 int enabled, int internal, unsigned flags)
9090 if (canonical->pre_expanded)
9091 gdb_assert (canonical->lsals.size () == 1);
9093 for (const auto &lsal : canonical->lsals)
9095 /* Note that 'location' can be NULL in the case of a plain
9096 'break', without arguments. */
9097 event_location_up location
9098 = (canonical->location != NULL
9099 ? copy_event_location (canonical->location.get ()) : NULL);
9100 gdb::unique_xmalloc_ptr<char> filter_string
9101 (lsal.canonical != NULL ? xstrdup (lsal.canonical) : NULL);
9103 create_breakpoint_sal (gdbarch, lsal.sals,
9104 std::move (location),
9105 std::move (filter_string),
9106 std::move (cond_string),
9107 std::move (extra_string),
9109 thread, task, ignore_count, ops,
9110 from_tty, enabled, internal, flags,
9111 canonical->special_display);
9115 /* Parse LOCATION which is assumed to be a SAL specification possibly
9116 followed by conditionals. On return, SALS contains an array of SAL
9117 addresses found. LOCATION points to the end of the SAL (for
9118 linespec locations).
9120 The array and the line spec strings are allocated on the heap, it is
9121 the caller's responsibility to free them. */
9124 parse_breakpoint_sals (const struct event_location *location,
9125 struct linespec_result *canonical)
9127 struct symtab_and_line cursal;
9129 if (event_location_type (location) == LINESPEC_LOCATION)
9131 const char *address = get_linespec_location (location);
9133 if (address == NULL)
9135 /* The last displayed codepoint, if it's valid, is our default
9136 breakpoint address. */
9137 if (last_displayed_sal_is_valid ())
9139 /* Set sal's pspace, pc, symtab, and line to the values
9140 corresponding to the last call to print_frame_info.
9141 Be sure to reinitialize LINE with NOTCURRENT == 0
9142 as the breakpoint line number is inappropriate otherwise.
9143 find_pc_line would adjust PC, re-set it back. */
9144 symtab_and_line sal = get_last_displayed_sal ();
9145 CORE_ADDR pc = sal.pc;
9147 sal = find_pc_line (pc, 0);
9149 /* "break" without arguments is equivalent to "break *PC"
9150 where PC is the last displayed codepoint's address. So
9151 make sure to set sal.explicit_pc to prevent GDB from
9152 trying to expand the list of sals to include all other
9153 instances with the same symtab and line. */
9155 sal.explicit_pc = 1;
9157 struct linespec_sals lsal;
9159 lsal.canonical = NULL;
9161 canonical->lsals.push_back (std::move (lsal));
9165 error (_("No default breakpoint address now."));
9169 /* Force almost all breakpoints to be in terms of the
9170 current_source_symtab (which is decode_line_1's default).
9171 This should produce the results we want almost all of the
9172 time while leaving default_breakpoint_* alone.
9174 ObjC: However, don't match an Objective-C method name which
9175 may have a '+' or '-' succeeded by a '['. */
9176 cursal = get_current_source_symtab_and_line ();
9177 if (last_displayed_sal_is_valid ())
9179 const char *address = NULL;
9181 if (event_location_type (location) == LINESPEC_LOCATION)
9182 address = get_linespec_location (location);
9186 && strchr ("+-", address[0]) != NULL
9187 && address[1] != '['))
9189 decode_line_full (location, DECODE_LINE_FUNFIRSTLINE, NULL,
9190 get_last_displayed_symtab (),
9191 get_last_displayed_line (),
9192 canonical, NULL, NULL);
9197 decode_line_full (location, DECODE_LINE_FUNFIRSTLINE, NULL,
9198 cursal.symtab, cursal.line, canonical, NULL, NULL);
9202 /* Convert each SAL into a real PC. Verify that the PC can be
9203 inserted as a breakpoint. If it can't throw an error. */
9206 breakpoint_sals_to_pc (std::vector<symtab_and_line> &sals)
9208 for (auto &sal : sals)
9209 resolve_sal_pc (&sal);
9212 /* Fast tracepoints may have restrictions on valid locations. For
9213 instance, a fast tracepoint using a jump instead of a trap will
9214 likely have to overwrite more bytes than a trap would, and so can
9215 only be placed where the instruction is longer than the jump, or a
9216 multi-instruction sequence does not have a jump into the middle of
9220 check_fast_tracepoint_sals (struct gdbarch *gdbarch,
9221 gdb::array_view<const symtab_and_line> sals)
9225 struct cleanup *old_chain;
9227 for (const auto &sal : sals)
9229 struct gdbarch *sarch;
9231 sarch = get_sal_arch (sal);
9232 /* We fall back to GDBARCH if there is no architecture
9233 associated with SAL. */
9236 rslt = gdbarch_fast_tracepoint_valid_at (sarch, sal.pc, &msg);
9237 old_chain = make_cleanup (xfree, msg);
9240 error (_("May not have a fast tracepoint at %s%s"),
9241 paddress (sarch, sal.pc), (msg ? msg : ""));
9243 do_cleanups (old_chain);
9247 /* Given TOK, a string specification of condition and thread, as
9248 accepted by the 'break' command, extract the condition
9249 string and thread number and set *COND_STRING and *THREAD.
9250 PC identifies the context at which the condition should be parsed.
9251 If no condition is found, *COND_STRING is set to NULL.
9252 If no thread is found, *THREAD is set to -1. */
9255 find_condition_and_thread (const char *tok, CORE_ADDR pc,
9256 char **cond_string, int *thread, int *task,
9259 *cond_string = NULL;
9266 const char *end_tok;
9268 const char *cond_start = NULL;
9269 const char *cond_end = NULL;
9271 tok = skip_spaces (tok);
9273 if ((*tok == '"' || *tok == ',') && rest)
9275 *rest = savestring (tok, strlen (tok));
9279 end_tok = skip_to_space (tok);
9281 toklen = end_tok - tok;
9283 if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
9285 tok = cond_start = end_tok + 1;
9286 parse_exp_1 (&tok, pc, block_for_pc (pc), 0);
9288 *cond_string = savestring (cond_start, cond_end - cond_start);
9290 else if (toklen >= 1 && strncmp (tok, "thread", toklen) == 0)
9293 struct thread_info *thr;
9296 thr = parse_thread_id (tok, &tmptok);
9298 error (_("Junk after thread keyword."));
9299 *thread = thr->global_num;
9302 else if (toklen >= 1 && strncmp (tok, "task", toklen) == 0)
9307 *task = strtol (tok, &tmptok, 0);
9309 error (_("Junk after task keyword."));
9310 if (!valid_task_id (*task))
9311 error (_("Unknown task %d."), *task);
9316 *rest = savestring (tok, strlen (tok));
9320 error (_("Junk at end of arguments."));
9324 /* Decode a static tracepoint marker spec. */
9326 static std::vector<symtab_and_line>
9327 decode_static_tracepoint_spec (const char **arg_p)
9329 VEC(static_tracepoint_marker_p) *markers = NULL;
9330 const char *p = &(*arg_p)[3];
9334 p = skip_spaces (p);
9336 endp = skip_to_space (p);
9338 std::string marker_str (p, endp - p);
9340 markers = target_static_tracepoint_markers_by_strid (marker_str.c_str ());
9341 if (VEC_empty(static_tracepoint_marker_p, markers))
9342 error (_("No known static tracepoint marker named %s"),
9343 marker_str.c_str ());
9345 std::vector<symtab_and_line> sals;
9346 sals.reserve (VEC_length(static_tracepoint_marker_p, markers));
9348 for (i = 0; i < VEC_length(static_tracepoint_marker_p, markers); i++)
9350 struct static_tracepoint_marker *marker;
9352 marker = VEC_index (static_tracepoint_marker_p, markers, i);
9354 symtab_and_line sal = find_pc_line (marker->address, 0);
9355 sal.pc = marker->address;
9356 sals.push_back (sal);
9358 release_static_tracepoint_marker (marker);
9365 /* See breakpoint.h. */
9368 create_breakpoint (struct gdbarch *gdbarch,
9369 const struct event_location *location,
9370 const char *cond_string,
9371 int thread, const char *extra_string,
9373 int tempflag, enum bptype type_wanted,
9375 enum auto_boolean pending_break_support,
9376 const struct breakpoint_ops *ops,
9377 int from_tty, int enabled, int internal,
9380 struct linespec_result canonical;
9381 struct cleanup *bkpt_chain = NULL;
9384 int prev_bkpt_count = breakpoint_count;
9386 gdb_assert (ops != NULL);
9388 /* If extra_string isn't useful, set it to NULL. */
9389 if (extra_string != NULL && *extra_string == '\0')
9390 extra_string = NULL;
9394 ops->create_sals_from_location (location, &canonical, type_wanted);
9396 CATCH (e, RETURN_MASK_ERROR)
9398 /* If caller is interested in rc value from parse, set
9400 if (e.error == NOT_FOUND_ERROR)
9402 /* If pending breakpoint support is turned off, throw
9405 if (pending_break_support == AUTO_BOOLEAN_FALSE)
9406 throw_exception (e);
9408 exception_print (gdb_stderr, e);
9410 /* If pending breakpoint support is auto query and the user
9411 selects no, then simply return the error code. */
9412 if (pending_break_support == AUTO_BOOLEAN_AUTO
9413 && !nquery (_("Make %s pending on future shared library load? "),
9414 bptype_string (type_wanted)))
9417 /* At this point, either the user was queried about setting
9418 a pending breakpoint and selected yes, or pending
9419 breakpoint behavior is on and thus a pending breakpoint
9420 is defaulted on behalf of the user. */
9424 throw_exception (e);
9428 if (!pending && canonical.lsals.empty ())
9431 /* ----------------------------- SNIP -----------------------------
9432 Anything added to the cleanup chain beyond this point is assumed
9433 to be part of a breakpoint. If the breakpoint create succeeds
9434 then the memory is not reclaimed. */
9435 bkpt_chain = make_cleanup (null_cleanup, 0);
9437 /* Resolve all line numbers to PC's and verify that the addresses
9438 are ok for the target. */
9441 for (auto &lsal : canonical.lsals)
9442 breakpoint_sals_to_pc (lsal.sals);
9445 /* Fast tracepoints may have additional restrictions on location. */
9446 if (!pending && type_wanted == bp_fast_tracepoint)
9448 for (const auto &lsal : canonical.lsals)
9449 check_fast_tracepoint_sals (gdbarch, lsal.sals);
9452 /* Verify that condition can be parsed, before setting any
9453 breakpoints. Allocate a separate condition expression for each
9457 gdb::unique_xmalloc_ptr<char> cond_string_copy;
9458 gdb::unique_xmalloc_ptr<char> extra_string_copy;
9465 const linespec_sals &lsal = canonical.lsals[0];
9467 /* Here we only parse 'arg' to separate condition
9468 from thread number, so parsing in context of first
9469 sal is OK. When setting the breakpoint we'll
9470 re-parse it in context of each sal. */
9472 find_condition_and_thread (extra_string, lsal.sals[0].pc,
9473 &cond, &thread, &task, &rest);
9474 cond_string_copy.reset (cond);
9475 extra_string_copy.reset (rest);
9479 if (type_wanted != bp_dprintf
9480 && extra_string != NULL && *extra_string != '\0')
9481 error (_("Garbage '%s' at end of location"), extra_string);
9483 /* Create a private copy of condition string. */
9485 cond_string_copy.reset (xstrdup (cond_string));
9486 /* Create a private copy of any extra string. */
9488 extra_string_copy.reset (xstrdup (extra_string));
9491 ops->create_breakpoints_sal (gdbarch, &canonical,
9492 std::move (cond_string_copy),
9493 std::move (extra_string_copy),
9495 tempflag ? disp_del : disp_donttouch,
9496 thread, task, ignore_count, ops,
9497 from_tty, enabled, internal, flags);
9501 std::unique_ptr <breakpoint> b = new_breakpoint_from_type (type_wanted);
9503 init_raw_breakpoint_without_location (b.get (), gdbarch, type_wanted, ops);
9504 b->location = copy_event_location (location);
9507 b->cond_string = NULL;
9510 /* Create a private copy of condition string. */
9511 b->cond_string = cond_string != NULL ? xstrdup (cond_string) : NULL;
9515 /* Create a private copy of any extra string. */
9516 b->extra_string = extra_string != NULL ? xstrdup (extra_string) : NULL;
9517 b->ignore_count = ignore_count;
9518 b->disposition = tempflag ? disp_del : disp_donttouch;
9519 b->condition_not_parsed = 1;
9520 b->enable_state = enabled ? bp_enabled : bp_disabled;
9521 if ((type_wanted != bp_breakpoint
9522 && type_wanted != bp_hardware_breakpoint) || thread != -1)
9523 b->pspace = current_program_space;
9525 install_breakpoint (internal, std::move (b), 0);
9528 if (canonical.lsals.size () > 1)
9530 warning (_("Multiple breakpoints were set.\nUse the "
9531 "\"delete\" command to delete unwanted breakpoints."));
9532 prev_breakpoint_count = prev_bkpt_count;
9535 /* That's it. Discard the cleanups for data inserted into the
9537 discard_cleanups (bkpt_chain);
9539 /* error call may happen here - have BKPT_CHAIN already discarded. */
9540 update_global_location_list (UGLL_MAY_INSERT);
9545 /* Set a breakpoint.
9546 ARG is a string describing breakpoint address,
9547 condition, and thread.
9548 FLAG specifies if a breakpoint is hardware on,
9549 and if breakpoint is temporary, using BP_HARDWARE_FLAG
9553 break_command_1 (const char *arg, int flag, int from_tty)
9555 int tempflag = flag & BP_TEMPFLAG;
9556 enum bptype type_wanted = (flag & BP_HARDWAREFLAG
9557 ? bp_hardware_breakpoint
9559 struct breakpoint_ops *ops;
9561 event_location_up location = string_to_event_location (&arg, current_language);
9563 /* Matching breakpoints on probes. */
9564 if (location != NULL
9565 && event_location_type (location.get ()) == PROBE_LOCATION)
9566 ops = &bkpt_probe_breakpoint_ops;
9568 ops = &bkpt_breakpoint_ops;
9570 create_breakpoint (get_current_arch (),
9572 NULL, 0, arg, 1 /* parse arg */,
9573 tempflag, type_wanted,
9574 0 /* Ignore count */,
9575 pending_break_support,
9583 /* Helper function for break_command_1 and disassemble_command. */
9586 resolve_sal_pc (struct symtab_and_line *sal)
9590 if (sal->pc == 0 && sal->symtab != NULL)
9592 if (!find_line_pc (sal->symtab, sal->line, &pc))
9593 error (_("No line %d in file \"%s\"."),
9594 sal->line, symtab_to_filename_for_display (sal->symtab));
9597 /* If this SAL corresponds to a breakpoint inserted using a line
9598 number, then skip the function prologue if necessary. */
9599 if (sal->explicit_line)
9600 skip_prologue_sal (sal);
9603 if (sal->section == 0 && sal->symtab != NULL)
9605 const struct blockvector *bv;
9606 const struct block *b;
9609 bv = blockvector_for_pc_sect (sal->pc, 0, &b,
9610 SYMTAB_COMPUNIT (sal->symtab));
9613 sym = block_linkage_function (b);
9616 fixup_symbol_section (sym, SYMTAB_OBJFILE (sal->symtab));
9617 sal->section = SYMBOL_OBJ_SECTION (SYMTAB_OBJFILE (sal->symtab),
9622 /* It really is worthwhile to have the section, so we'll
9623 just have to look harder. This case can be executed
9624 if we have line numbers but no functions (as can
9625 happen in assembly source). */
9627 scoped_restore_current_pspace_and_thread restore_pspace_thread;
9628 switch_to_program_space_and_thread (sal->pspace);
9630 bound_minimal_symbol msym = lookup_minimal_symbol_by_pc (sal->pc);
9632 sal->section = MSYMBOL_OBJ_SECTION (msym.objfile, msym.minsym);
9639 break_command (char *arg, int from_tty)
9641 break_command_1 (arg, 0, from_tty);
9645 tbreak_command (char *arg, int from_tty)
9647 break_command_1 (arg, BP_TEMPFLAG, from_tty);
9651 hbreak_command (char *arg, int from_tty)
9653 break_command_1 (arg, BP_HARDWAREFLAG, from_tty);
9657 thbreak_command (char *arg, int from_tty)
9659 break_command_1 (arg, (BP_TEMPFLAG | BP_HARDWAREFLAG), from_tty);
9663 stop_command (char *arg, int from_tty)
9665 printf_filtered (_("Specify the type of breakpoint to set.\n\
9666 Usage: stop in <function | address>\n\
9667 stop at <line>\n"));
9671 stopin_command (const char *arg, int from_tty)
9675 if (arg == (char *) NULL)
9677 else if (*arg != '*')
9679 const char *argptr = arg;
9682 /* Look for a ':'. If this is a line number specification, then
9683 say it is bad, otherwise, it should be an address or
9684 function/method name. */
9685 while (*argptr && !hasColon)
9687 hasColon = (*argptr == ':');
9692 badInput = (*argptr != ':'); /* Not a class::method */
9694 badInput = isdigit (*arg); /* a simple line number */
9698 printf_filtered (_("Usage: stop in <function | address>\n"));
9700 break_command_1 (arg, 0, from_tty);
9704 stopat_command (const char *arg, int from_tty)
9708 if (arg == (char *) NULL || *arg == '*') /* no line number */
9712 const char *argptr = arg;
9715 /* Look for a ':'. If there is a '::' then get out, otherwise
9716 it is probably a line number. */
9717 while (*argptr && !hasColon)
9719 hasColon = (*argptr == ':');
9724 badInput = (*argptr == ':'); /* we have class::method */
9726 badInput = !isdigit (*arg); /* not a line number */
9730 printf_filtered (_("Usage: stop at <line>\n"));
9732 break_command_1 (arg, 0, from_tty);
9735 /* The dynamic printf command is mostly like a regular breakpoint, but
9736 with a prewired command list consisting of a single output command,
9737 built from extra arguments supplied on the dprintf command
9741 dprintf_command (char *arg_in, int from_tty)
9743 const char *arg = arg_in;
9744 event_location_up location = string_to_event_location (&arg, current_language);
9746 /* If non-NULL, ARG should have been advanced past the location;
9747 the next character must be ','. */
9750 if (arg[0] != ',' || arg[1] == '\0')
9751 error (_("Format string required"));
9754 /* Skip the comma. */
9759 create_breakpoint (get_current_arch (),
9761 NULL, 0, arg, 1 /* parse arg */,
9763 0 /* Ignore count */,
9764 pending_break_support,
9765 &dprintf_breakpoint_ops,
9773 agent_printf_command (char *arg, int from_tty)
9775 error (_("May only run agent-printf on the target"));
9778 /* Implement the "breakpoint_hit" breakpoint_ops method for
9779 ranged breakpoints. */
9782 breakpoint_hit_ranged_breakpoint (const struct bp_location *bl,
9783 const address_space *aspace,
9785 const struct target_waitstatus *ws)
9787 if (ws->kind != TARGET_WAITKIND_STOPPED
9788 || ws->value.sig != GDB_SIGNAL_TRAP)
9791 return breakpoint_address_match_range (bl->pspace->aspace, bl->address,
9792 bl->length, aspace, bp_addr);
9795 /* Implement the "resources_needed" breakpoint_ops method for
9796 ranged breakpoints. */
9799 resources_needed_ranged_breakpoint (const struct bp_location *bl)
9801 return target_ranged_break_num_registers ();
9804 /* Implement the "print_it" breakpoint_ops method for
9805 ranged breakpoints. */
9807 static enum print_stop_action
9808 print_it_ranged_breakpoint (bpstat bs)
9810 struct breakpoint *b = bs->breakpoint_at;
9811 struct bp_location *bl = b->loc;
9812 struct ui_out *uiout = current_uiout;
9814 gdb_assert (b->type == bp_hardware_breakpoint);
9816 /* Ranged breakpoints have only one location. */
9817 gdb_assert (bl && bl->next == NULL);
9819 annotate_breakpoint (b->number);
9821 maybe_print_thread_hit_breakpoint (uiout);
9823 if (b->disposition == disp_del)
9824 uiout->text ("Temporary ranged breakpoint ");
9826 uiout->text ("Ranged breakpoint ");
9827 if (uiout->is_mi_like_p ())
9829 uiout->field_string ("reason",
9830 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
9831 uiout->field_string ("disp", bpdisp_text (b->disposition));
9833 uiout->field_int ("bkptno", b->number);
9836 return PRINT_SRC_AND_LOC;
9839 /* Implement the "print_one" breakpoint_ops method for
9840 ranged breakpoints. */
9843 print_one_ranged_breakpoint (struct breakpoint *b,
9844 struct bp_location **last_loc)
9846 struct bp_location *bl = b->loc;
9847 struct value_print_options opts;
9848 struct ui_out *uiout = current_uiout;
9850 /* Ranged breakpoints have only one location. */
9851 gdb_assert (bl && bl->next == NULL);
9853 get_user_print_options (&opts);
9855 if (opts.addressprint)
9856 /* We don't print the address range here, it will be printed later
9857 by print_one_detail_ranged_breakpoint. */
9858 uiout->field_skip ("addr");
9860 print_breakpoint_location (b, bl);
9864 /* Implement the "print_one_detail" breakpoint_ops method for
9865 ranged breakpoints. */
9868 print_one_detail_ranged_breakpoint (const struct breakpoint *b,
9869 struct ui_out *uiout)
9871 CORE_ADDR address_start, address_end;
9872 struct bp_location *bl = b->loc;
9877 address_start = bl->address;
9878 address_end = address_start + bl->length - 1;
9880 uiout->text ("\taddress range: ");
9881 stb.printf ("[%s, %s]",
9882 print_core_address (bl->gdbarch, address_start),
9883 print_core_address (bl->gdbarch, address_end));
9884 uiout->field_stream ("addr", stb);
9888 /* Implement the "print_mention" breakpoint_ops method for
9889 ranged breakpoints. */
9892 print_mention_ranged_breakpoint (struct breakpoint *b)
9894 struct bp_location *bl = b->loc;
9895 struct ui_out *uiout = current_uiout;
9898 gdb_assert (b->type == bp_hardware_breakpoint);
9900 if (uiout->is_mi_like_p ())
9903 printf_filtered (_("Hardware assisted ranged breakpoint %d from %s to %s."),
9904 b->number, paddress (bl->gdbarch, bl->address),
9905 paddress (bl->gdbarch, bl->address + bl->length - 1));
9908 /* Implement the "print_recreate" breakpoint_ops method for
9909 ranged breakpoints. */
9912 print_recreate_ranged_breakpoint (struct breakpoint *b, struct ui_file *fp)
9914 fprintf_unfiltered (fp, "break-range %s, %s",
9915 event_location_to_string (b->location.get ()),
9916 event_location_to_string (b->location_range_end.get ()));
9917 print_recreate_thread (b, fp);
9920 /* The breakpoint_ops structure to be used in ranged breakpoints. */
9922 static struct breakpoint_ops ranged_breakpoint_ops;
9924 /* Find the address where the end of the breakpoint range should be
9925 placed, given the SAL of the end of the range. This is so that if
9926 the user provides a line number, the end of the range is set to the
9927 last instruction of the given line. */
9930 find_breakpoint_range_end (struct symtab_and_line sal)
9934 /* If the user provided a PC value, use it. Otherwise,
9935 find the address of the end of the given location. */
9936 if (sal.explicit_pc)
9943 ret = find_line_pc_range (sal, &start, &end);
9945 error (_("Could not find location of the end of the range."));
9947 /* find_line_pc_range returns the start of the next line. */
9954 /* Implement the "break-range" CLI command. */
9957 break_range_command (char *arg_in, int from_tty)
9959 const char *arg = arg_in;
9960 const char *arg_start;
9961 struct linespec_result canonical_start, canonical_end;
9962 int bp_count, can_use_bp, length;
9964 struct breakpoint *b;
9966 /* We don't support software ranged breakpoints. */
9967 if (target_ranged_break_num_registers () < 0)
9968 error (_("This target does not support hardware ranged breakpoints."));
9970 bp_count = hw_breakpoint_used_count ();
9971 bp_count += target_ranged_break_num_registers ();
9972 can_use_bp = target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
9975 error (_("Hardware breakpoints used exceeds limit."));
9977 arg = skip_spaces (arg);
9978 if (arg == NULL || arg[0] == '\0')
9979 error(_("No address range specified."));
9982 event_location_up start_location = string_to_event_location (&arg,
9984 parse_breakpoint_sals (start_location.get (), &canonical_start);
9987 error (_("Too few arguments."));
9988 else if (canonical_start.lsals.empty ())
9989 error (_("Could not find location of the beginning of the range."));
9991 const linespec_sals &lsal_start = canonical_start.lsals[0];
9993 if (canonical_start.lsals.size () > 1
9994 || lsal_start.sals.size () != 1)
9995 error (_("Cannot create a ranged breakpoint with multiple locations."));
9997 const symtab_and_line &sal_start = lsal_start.sals[0];
9998 std::string addr_string_start (arg_start, arg - arg_start);
10000 arg++; /* Skip the comma. */
10001 arg = skip_spaces (arg);
10003 /* Parse the end location. */
10007 /* We call decode_line_full directly here instead of using
10008 parse_breakpoint_sals because we need to specify the start location's
10009 symtab and line as the default symtab and line for the end of the
10010 range. This makes it possible to have ranges like "foo.c:27, +14",
10011 where +14 means 14 lines from the start location. */
10012 event_location_up end_location = string_to_event_location (&arg,
10014 decode_line_full (end_location.get (), DECODE_LINE_FUNFIRSTLINE, NULL,
10015 sal_start.symtab, sal_start.line,
10016 &canonical_end, NULL, NULL);
10018 if (canonical_end.lsals.empty ())
10019 error (_("Could not find location of the end of the range."));
10021 const linespec_sals &lsal_end = canonical_end.lsals[0];
10022 if (canonical_end.lsals.size () > 1
10023 || lsal_end.sals.size () != 1)
10024 error (_("Cannot create a ranged breakpoint with multiple locations."));
10026 const symtab_and_line &sal_end = lsal_end.sals[0];
10028 end = find_breakpoint_range_end (sal_end);
10029 if (sal_start.pc > end)
10030 error (_("Invalid address range, end precedes start."));
10032 length = end - sal_start.pc + 1;
10034 /* Length overflowed. */
10035 error (_("Address range too large."));
10036 else if (length == 1)
10038 /* This range is simple enough to be handled by
10039 the `hbreak' command. */
10040 hbreak_command (&addr_string_start[0], 1);
10045 /* Now set up the breakpoint. */
10046 b = set_raw_breakpoint (get_current_arch (), sal_start,
10047 bp_hardware_breakpoint, &ranged_breakpoint_ops);
10048 set_breakpoint_count (breakpoint_count + 1);
10049 b->number = breakpoint_count;
10050 b->disposition = disp_donttouch;
10051 b->location = std::move (start_location);
10052 b->location_range_end = std::move (end_location);
10053 b->loc->length = length;
10056 observer_notify_breakpoint_created (b);
10057 update_global_location_list (UGLL_MAY_INSERT);
10060 /* Return non-zero if EXP is verified as constant. Returned zero
10061 means EXP is variable. Also the constant detection may fail for
10062 some constant expressions and in such case still falsely return
10066 watchpoint_exp_is_const (const struct expression *exp)
10068 int i = exp->nelts;
10074 /* We are only interested in the descriptor of each element. */
10075 operator_length (exp, i, &oplenp, &argsp);
10078 switch (exp->elts[i].opcode)
10088 case BINOP_LOGICAL_AND:
10089 case BINOP_LOGICAL_OR:
10090 case BINOP_BITWISE_AND:
10091 case BINOP_BITWISE_IOR:
10092 case BINOP_BITWISE_XOR:
10094 case BINOP_NOTEQUAL:
10120 case OP_OBJC_NSSTRING:
10123 case UNOP_LOGICAL_NOT:
10124 case UNOP_COMPLEMENT:
10129 case UNOP_CAST_TYPE:
10130 case UNOP_REINTERPRET_CAST:
10131 case UNOP_DYNAMIC_CAST:
10132 /* Unary, binary and ternary operators: We have to check
10133 their operands. If they are constant, then so is the
10134 result of that operation. For instance, if A and B are
10135 determined to be constants, then so is "A + B".
10137 UNOP_IND is one exception to the rule above, because the
10138 value of *ADDR is not necessarily a constant, even when
10143 /* Check whether the associated symbol is a constant.
10145 We use SYMBOL_CLASS rather than TYPE_CONST because it's
10146 possible that a buggy compiler could mark a variable as
10147 constant even when it is not, and TYPE_CONST would return
10148 true in this case, while SYMBOL_CLASS wouldn't.
10150 We also have to check for function symbols because they
10151 are always constant. */
10153 struct symbol *s = exp->elts[i + 2].symbol;
10155 if (SYMBOL_CLASS (s) != LOC_BLOCK
10156 && SYMBOL_CLASS (s) != LOC_CONST
10157 && SYMBOL_CLASS (s) != LOC_CONST_BYTES)
10162 /* The default action is to return 0 because we are using
10163 the optimistic approach here: If we don't know something,
10164 then it is not a constant. */
10173 /* Watchpoint destructor. */
10175 watchpoint::~watchpoint ()
10177 xfree (this->exp_string);
10178 xfree (this->exp_string_reparse);
10179 value_free (this->val);
10182 /* Implement the "re_set" breakpoint_ops method for watchpoints. */
10185 re_set_watchpoint (struct breakpoint *b)
10187 struct watchpoint *w = (struct watchpoint *) b;
10189 /* Watchpoint can be either on expression using entirely global
10190 variables, or it can be on local variables.
10192 Watchpoints of the first kind are never auto-deleted, and even
10193 persist across program restarts. Since they can use variables
10194 from shared libraries, we need to reparse expression as libraries
10195 are loaded and unloaded.
10197 Watchpoints on local variables can also change meaning as result
10198 of solib event. For example, if a watchpoint uses both a local
10199 and a global variables in expression, it's a local watchpoint,
10200 but unloading of a shared library will make the expression
10201 invalid. This is not a very common use case, but we still
10202 re-evaluate expression, to avoid surprises to the user.
10204 Note that for local watchpoints, we re-evaluate it only if
10205 watchpoints frame id is still valid. If it's not, it means the
10206 watchpoint is out of scope and will be deleted soon. In fact,
10207 I'm not sure we'll ever be called in this case.
10209 If a local watchpoint's frame id is still valid, then
10210 w->exp_valid_block is likewise valid, and we can safely use it.
10212 Don't do anything about disabled watchpoints, since they will be
10213 reevaluated again when enabled. */
10214 update_watchpoint (w, 1 /* reparse */);
10217 /* Implement the "insert" breakpoint_ops method for hardware watchpoints. */
10220 insert_watchpoint (struct bp_location *bl)
10222 struct watchpoint *w = (struct watchpoint *) bl->owner;
10223 int length = w->exact ? 1 : bl->length;
10225 return target_insert_watchpoint (bl->address, length, bl->watchpoint_type,
10226 w->cond_exp.get ());
10229 /* Implement the "remove" breakpoint_ops method for hardware watchpoints. */
10232 remove_watchpoint (struct bp_location *bl, enum remove_bp_reason reason)
10234 struct watchpoint *w = (struct watchpoint *) bl->owner;
10235 int length = w->exact ? 1 : bl->length;
10237 return target_remove_watchpoint (bl->address, length, bl->watchpoint_type,
10238 w->cond_exp.get ());
10242 breakpoint_hit_watchpoint (const struct bp_location *bl,
10243 const address_space *aspace, CORE_ADDR bp_addr,
10244 const struct target_waitstatus *ws)
10246 struct breakpoint *b = bl->owner;
10247 struct watchpoint *w = (struct watchpoint *) b;
10249 /* Continuable hardware watchpoints are treated as non-existent if the
10250 reason we stopped wasn't a hardware watchpoint (we didn't stop on
10251 some data address). Otherwise gdb won't stop on a break instruction
10252 in the code (not from a breakpoint) when a hardware watchpoint has
10253 been defined. Also skip watchpoints which we know did not trigger
10254 (did not match the data address). */
10255 if (is_hardware_watchpoint (b)
10256 && w->watchpoint_triggered == watch_triggered_no)
10263 check_status_watchpoint (bpstat bs)
10265 gdb_assert (is_watchpoint (bs->breakpoint_at));
10267 bpstat_check_watchpoint (bs);
10270 /* Implement the "resources_needed" breakpoint_ops method for
10271 hardware watchpoints. */
10274 resources_needed_watchpoint (const struct bp_location *bl)
10276 struct watchpoint *w = (struct watchpoint *) bl->owner;
10277 int length = w->exact? 1 : bl->length;
10279 return target_region_ok_for_hw_watchpoint (bl->address, length);
10282 /* Implement the "works_in_software_mode" breakpoint_ops method for
10283 hardware watchpoints. */
10286 works_in_software_mode_watchpoint (const struct breakpoint *b)
10288 /* Read and access watchpoints only work with hardware support. */
10289 return b->type == bp_watchpoint || b->type == bp_hardware_watchpoint;
10292 static enum print_stop_action
10293 print_it_watchpoint (bpstat bs)
10295 struct breakpoint *b;
10296 enum print_stop_action result;
10297 struct watchpoint *w;
10298 struct ui_out *uiout = current_uiout;
10300 gdb_assert (bs->bp_location_at != NULL);
10302 b = bs->breakpoint_at;
10303 w = (struct watchpoint *) b;
10305 annotate_watchpoint (b->number);
10306 maybe_print_thread_hit_breakpoint (uiout);
10310 gdb::optional<ui_out_emit_tuple> tuple_emitter;
10313 case bp_watchpoint:
10314 case bp_hardware_watchpoint:
10315 if (uiout->is_mi_like_p ())
10316 uiout->field_string
10317 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER));
10319 tuple_emitter.emplace (uiout, "value");
10320 uiout->text ("\nOld value = ");
10321 watchpoint_value_print (bs->old_val, &stb);
10322 uiout->field_stream ("old", stb);
10323 uiout->text ("\nNew value = ");
10324 watchpoint_value_print (w->val, &stb);
10325 uiout->field_stream ("new", stb);
10326 uiout->text ("\n");
10327 /* More than one watchpoint may have been triggered. */
10328 result = PRINT_UNKNOWN;
10331 case bp_read_watchpoint:
10332 if (uiout->is_mi_like_p ())
10333 uiout->field_string
10334 ("reason", async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER));
10336 tuple_emitter.emplace (uiout, "value");
10337 uiout->text ("\nValue = ");
10338 watchpoint_value_print (w->val, &stb);
10339 uiout->field_stream ("value", stb);
10340 uiout->text ("\n");
10341 result = PRINT_UNKNOWN;
10344 case bp_access_watchpoint:
10345 if (bs->old_val != NULL)
10347 if (uiout->is_mi_like_p ())
10348 uiout->field_string
10350 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
10352 tuple_emitter.emplace (uiout, "value");
10353 uiout->text ("\nOld value = ");
10354 watchpoint_value_print (bs->old_val, &stb);
10355 uiout->field_stream ("old", stb);
10356 uiout->text ("\nNew value = ");
10361 if (uiout->is_mi_like_p ())
10362 uiout->field_string
10364 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
10365 tuple_emitter.emplace (uiout, "value");
10366 uiout->text ("\nValue = ");
10368 watchpoint_value_print (w->val, &stb);
10369 uiout->field_stream ("new", stb);
10370 uiout->text ("\n");
10371 result = PRINT_UNKNOWN;
10374 result = PRINT_UNKNOWN;
10380 /* Implement the "print_mention" breakpoint_ops method for hardware
10384 print_mention_watchpoint (struct breakpoint *b)
10386 struct watchpoint *w = (struct watchpoint *) b;
10387 struct ui_out *uiout = current_uiout;
10388 const char *tuple_name;
10392 case bp_watchpoint:
10393 uiout->text ("Watchpoint ");
10394 tuple_name = "wpt";
10396 case bp_hardware_watchpoint:
10397 uiout->text ("Hardware watchpoint ");
10398 tuple_name = "wpt";
10400 case bp_read_watchpoint:
10401 uiout->text ("Hardware read watchpoint ");
10402 tuple_name = "hw-rwpt";
10404 case bp_access_watchpoint:
10405 uiout->text ("Hardware access (read/write) watchpoint ");
10406 tuple_name = "hw-awpt";
10409 internal_error (__FILE__, __LINE__,
10410 _("Invalid hardware watchpoint type."));
10413 ui_out_emit_tuple tuple_emitter (uiout, tuple_name);
10414 uiout->field_int ("number", b->number);
10415 uiout->text (": ");
10416 uiout->field_string ("exp", w->exp_string);
10419 /* Implement the "print_recreate" breakpoint_ops method for
10423 print_recreate_watchpoint (struct breakpoint *b, struct ui_file *fp)
10425 struct watchpoint *w = (struct watchpoint *) b;
10429 case bp_watchpoint:
10430 case bp_hardware_watchpoint:
10431 fprintf_unfiltered (fp, "watch");
10433 case bp_read_watchpoint:
10434 fprintf_unfiltered (fp, "rwatch");
10436 case bp_access_watchpoint:
10437 fprintf_unfiltered (fp, "awatch");
10440 internal_error (__FILE__, __LINE__,
10441 _("Invalid watchpoint type."));
10444 fprintf_unfiltered (fp, " %s", w->exp_string);
10445 print_recreate_thread (b, fp);
10448 /* Implement the "explains_signal" breakpoint_ops method for
10452 explains_signal_watchpoint (struct breakpoint *b, enum gdb_signal sig)
10454 /* A software watchpoint cannot cause a signal other than
10455 GDB_SIGNAL_TRAP. */
10456 if (b->type == bp_watchpoint && sig != GDB_SIGNAL_TRAP)
10462 /* The breakpoint_ops structure to be used in hardware watchpoints. */
10464 static struct breakpoint_ops watchpoint_breakpoint_ops;
10466 /* Implement the "insert" breakpoint_ops method for
10467 masked hardware watchpoints. */
10470 insert_masked_watchpoint (struct bp_location *bl)
10472 struct watchpoint *w = (struct watchpoint *) bl->owner;
10474 return target_insert_mask_watchpoint (bl->address, w->hw_wp_mask,
10475 bl->watchpoint_type);
10478 /* Implement the "remove" breakpoint_ops method for
10479 masked hardware watchpoints. */
10482 remove_masked_watchpoint (struct bp_location *bl, enum remove_bp_reason reason)
10484 struct watchpoint *w = (struct watchpoint *) bl->owner;
10486 return target_remove_mask_watchpoint (bl->address, w->hw_wp_mask,
10487 bl->watchpoint_type);
10490 /* Implement the "resources_needed" breakpoint_ops method for
10491 masked hardware watchpoints. */
10494 resources_needed_masked_watchpoint (const struct bp_location *bl)
10496 struct watchpoint *w = (struct watchpoint *) bl->owner;
10498 return target_masked_watch_num_registers (bl->address, w->hw_wp_mask);
10501 /* Implement the "works_in_software_mode" breakpoint_ops method for
10502 masked hardware watchpoints. */
10505 works_in_software_mode_masked_watchpoint (const struct breakpoint *b)
10510 /* Implement the "print_it" breakpoint_ops method for
10511 masked hardware watchpoints. */
10513 static enum print_stop_action
10514 print_it_masked_watchpoint (bpstat bs)
10516 struct breakpoint *b = bs->breakpoint_at;
10517 struct ui_out *uiout = current_uiout;
10519 /* Masked watchpoints have only one location. */
10520 gdb_assert (b->loc && b->loc->next == NULL);
10522 annotate_watchpoint (b->number);
10523 maybe_print_thread_hit_breakpoint (uiout);
10527 case bp_hardware_watchpoint:
10528 if (uiout->is_mi_like_p ())
10529 uiout->field_string
10530 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER));
10533 case bp_read_watchpoint:
10534 if (uiout->is_mi_like_p ())
10535 uiout->field_string
10536 ("reason", async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER));
10539 case bp_access_watchpoint:
10540 if (uiout->is_mi_like_p ())
10541 uiout->field_string
10543 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
10546 internal_error (__FILE__, __LINE__,
10547 _("Invalid hardware watchpoint type."));
10551 uiout->text (_("\n\
10552 Check the underlying instruction at PC for the memory\n\
10553 address and value which triggered this watchpoint.\n"));
10554 uiout->text ("\n");
10556 /* More than one watchpoint may have been triggered. */
10557 return PRINT_UNKNOWN;
10560 /* Implement the "print_one_detail" breakpoint_ops method for
10561 masked hardware watchpoints. */
10564 print_one_detail_masked_watchpoint (const struct breakpoint *b,
10565 struct ui_out *uiout)
10567 struct watchpoint *w = (struct watchpoint *) b;
10569 /* Masked watchpoints have only one location. */
10570 gdb_assert (b->loc && b->loc->next == NULL);
10572 uiout->text ("\tmask ");
10573 uiout->field_core_addr ("mask", b->loc->gdbarch, w->hw_wp_mask);
10574 uiout->text ("\n");
10577 /* Implement the "print_mention" breakpoint_ops method for
10578 masked hardware watchpoints. */
10581 print_mention_masked_watchpoint (struct breakpoint *b)
10583 struct watchpoint *w = (struct watchpoint *) b;
10584 struct ui_out *uiout = current_uiout;
10585 const char *tuple_name;
10589 case bp_hardware_watchpoint:
10590 uiout->text ("Masked hardware watchpoint ");
10591 tuple_name = "wpt";
10593 case bp_read_watchpoint:
10594 uiout->text ("Masked hardware read watchpoint ");
10595 tuple_name = "hw-rwpt";
10597 case bp_access_watchpoint:
10598 uiout->text ("Masked hardware access (read/write) watchpoint ");
10599 tuple_name = "hw-awpt";
10602 internal_error (__FILE__, __LINE__,
10603 _("Invalid hardware watchpoint type."));
10606 ui_out_emit_tuple tuple_emitter (uiout, tuple_name);
10607 uiout->field_int ("number", b->number);
10608 uiout->text (": ");
10609 uiout->field_string ("exp", w->exp_string);
10612 /* Implement the "print_recreate" breakpoint_ops method for
10613 masked hardware watchpoints. */
10616 print_recreate_masked_watchpoint (struct breakpoint *b, struct ui_file *fp)
10618 struct watchpoint *w = (struct watchpoint *) b;
10623 case bp_hardware_watchpoint:
10624 fprintf_unfiltered (fp, "watch");
10626 case bp_read_watchpoint:
10627 fprintf_unfiltered (fp, "rwatch");
10629 case bp_access_watchpoint:
10630 fprintf_unfiltered (fp, "awatch");
10633 internal_error (__FILE__, __LINE__,
10634 _("Invalid hardware watchpoint type."));
10637 sprintf_vma (tmp, w->hw_wp_mask);
10638 fprintf_unfiltered (fp, " %s mask 0x%s", w->exp_string, tmp);
10639 print_recreate_thread (b, fp);
10642 /* The breakpoint_ops structure to be used in masked hardware watchpoints. */
10644 static struct breakpoint_ops masked_watchpoint_breakpoint_ops;
10646 /* Tell whether the given watchpoint is a masked hardware watchpoint. */
10649 is_masked_watchpoint (const struct breakpoint *b)
10651 return b->ops == &masked_watchpoint_breakpoint_ops;
10654 /* accessflag: hw_write: watch write,
10655 hw_read: watch read,
10656 hw_access: watch access (read or write) */
10658 watch_command_1 (const char *arg, int accessflag, int from_tty,
10659 int just_location, int internal)
10661 struct breakpoint *scope_breakpoint = NULL;
10662 const struct block *exp_valid_block = NULL, *cond_exp_valid_block = NULL;
10663 struct value *val, *mark, *result;
10664 int saved_bitpos = 0, saved_bitsize = 0;
10665 const char *exp_start = NULL;
10666 const char *exp_end = NULL;
10667 const char *tok, *end_tok;
10669 const char *cond_start = NULL;
10670 const char *cond_end = NULL;
10671 enum bptype bp_type;
10674 /* Flag to indicate whether we are going to use masks for
10675 the hardware watchpoint. */
10677 CORE_ADDR mask = 0;
10679 /* Make sure that we actually have parameters to parse. */
10680 if (arg != NULL && arg[0] != '\0')
10682 const char *value_start;
10684 exp_end = arg + strlen (arg);
10686 /* Look for "parameter value" pairs at the end
10687 of the arguments string. */
10688 for (tok = exp_end - 1; tok > arg; tok--)
10690 /* Skip whitespace at the end of the argument list. */
10691 while (tok > arg && (*tok == ' ' || *tok == '\t'))
10694 /* Find the beginning of the last token.
10695 This is the value of the parameter. */
10696 while (tok > arg && (*tok != ' ' && *tok != '\t'))
10698 value_start = tok + 1;
10700 /* Skip whitespace. */
10701 while (tok > arg && (*tok == ' ' || *tok == '\t'))
10706 /* Find the beginning of the second to last token.
10707 This is the parameter itself. */
10708 while (tok > arg && (*tok != ' ' && *tok != '\t'))
10711 toklen = end_tok - tok + 1;
10713 if (toklen == 6 && startswith (tok, "thread"))
10715 struct thread_info *thr;
10716 /* At this point we've found a "thread" token, which means
10717 the user is trying to set a watchpoint that triggers
10718 only in a specific thread. */
10722 error(_("You can specify only one thread."));
10724 /* Extract the thread ID from the next token. */
10725 thr = parse_thread_id (value_start, &endp);
10727 /* Check if the user provided a valid thread ID. */
10728 if (*endp != ' ' && *endp != '\t' && *endp != '\0')
10729 invalid_thread_id_error (value_start);
10731 thread = thr->global_num;
10733 else if (toklen == 4 && startswith (tok, "mask"))
10735 /* We've found a "mask" token, which means the user wants to
10736 create a hardware watchpoint that is going to have the mask
10738 struct value *mask_value, *mark;
10741 error(_("You can specify only one mask."));
10743 use_mask = just_location = 1;
10745 mark = value_mark ();
10746 mask_value = parse_to_comma_and_eval (&value_start);
10747 mask = value_as_address (mask_value);
10748 value_free_to_mark (mark);
10751 /* We didn't recognize what we found. We should stop here. */
10754 /* Truncate the string and get rid of the "parameter value" pair before
10755 the arguments string is parsed by the parse_exp_1 function. */
10762 /* Parse the rest of the arguments. From here on out, everything
10763 is in terms of a newly allocated string instead of the original
10765 innermost_block = NULL;
10766 std::string expression (arg, exp_end - arg);
10767 exp_start = arg = expression.c_str ();
10768 expression_up exp = parse_exp_1 (&arg, 0, 0, 0);
10770 /* Remove trailing whitespace from the expression before saving it.
10771 This makes the eventual display of the expression string a bit
10773 while (exp_end > exp_start && (exp_end[-1] == ' ' || exp_end[-1] == '\t'))
10776 /* Checking if the expression is not constant. */
10777 if (watchpoint_exp_is_const (exp.get ()))
10781 len = exp_end - exp_start;
10782 while (len > 0 && isspace (exp_start[len - 1]))
10784 error (_("Cannot watch constant value `%.*s'."), len, exp_start);
10787 exp_valid_block = innermost_block;
10788 mark = value_mark ();
10789 fetch_subexp_value (exp.get (), &pc, &val, &result, NULL, just_location);
10791 if (val != NULL && just_location)
10793 saved_bitpos = value_bitpos (val);
10794 saved_bitsize = value_bitsize (val);
10801 exp_valid_block = NULL;
10802 val = value_addr (result);
10803 release_value (val);
10804 value_free_to_mark (mark);
10808 ret = target_masked_watch_num_registers (value_as_address (val),
10811 error (_("This target does not support masked watchpoints."));
10812 else if (ret == -2)
10813 error (_("Invalid mask or memory region."));
10816 else if (val != NULL)
10817 release_value (val);
10819 tok = skip_spaces (arg);
10820 end_tok = skip_to_space (tok);
10822 toklen = end_tok - tok;
10823 if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
10825 innermost_block = NULL;
10826 tok = cond_start = end_tok + 1;
10827 parse_exp_1 (&tok, 0, 0, 0);
10829 /* The watchpoint expression may not be local, but the condition
10830 may still be. E.g.: `watch global if local > 0'. */
10831 cond_exp_valid_block = innermost_block;
10836 error (_("Junk at end of command."));
10838 frame_info *wp_frame = block_innermost_frame (exp_valid_block);
10840 /* Save this because create_internal_breakpoint below invalidates
10842 frame_id watchpoint_frame = get_frame_id (wp_frame);
10844 /* If the expression is "local", then set up a "watchpoint scope"
10845 breakpoint at the point where we've left the scope of the watchpoint
10846 expression. Create the scope breakpoint before the watchpoint, so
10847 that we will encounter it first in bpstat_stop_status. */
10848 if (exp_valid_block != NULL && wp_frame != NULL)
10850 frame_id caller_frame_id = frame_unwind_caller_id (wp_frame);
10852 if (frame_id_p (caller_frame_id))
10854 gdbarch *caller_arch = frame_unwind_caller_arch (wp_frame);
10855 CORE_ADDR caller_pc = frame_unwind_caller_pc (wp_frame);
10858 = create_internal_breakpoint (caller_arch, caller_pc,
10859 bp_watchpoint_scope,
10860 &momentary_breakpoint_ops);
10862 /* create_internal_breakpoint could invalidate WP_FRAME. */
10865 scope_breakpoint->enable_state = bp_enabled;
10867 /* Automatically delete the breakpoint when it hits. */
10868 scope_breakpoint->disposition = disp_del;
10870 /* Only break in the proper frame (help with recursion). */
10871 scope_breakpoint->frame_id = caller_frame_id;
10873 /* Set the address at which we will stop. */
10874 scope_breakpoint->loc->gdbarch = caller_arch;
10875 scope_breakpoint->loc->requested_address = caller_pc;
10876 scope_breakpoint->loc->address
10877 = adjust_breakpoint_address (scope_breakpoint->loc->gdbarch,
10878 scope_breakpoint->loc->requested_address,
10879 scope_breakpoint->type);
10883 /* Now set up the breakpoint. We create all watchpoints as hardware
10884 watchpoints here even if hardware watchpoints are turned off, a call
10885 to update_watchpoint later in this function will cause the type to
10886 drop back to bp_watchpoint (software watchpoint) if required. */
10888 if (accessflag == hw_read)
10889 bp_type = bp_read_watchpoint;
10890 else if (accessflag == hw_access)
10891 bp_type = bp_access_watchpoint;
10893 bp_type = bp_hardware_watchpoint;
10895 std::unique_ptr<watchpoint> w (new watchpoint ());
10898 init_raw_breakpoint_without_location (w.get (), NULL, bp_type,
10899 &masked_watchpoint_breakpoint_ops);
10901 init_raw_breakpoint_without_location (w.get (), NULL, bp_type,
10902 &watchpoint_breakpoint_ops);
10903 w->thread = thread;
10904 w->disposition = disp_donttouch;
10905 w->pspace = current_program_space;
10906 w->exp = std::move (exp);
10907 w->exp_valid_block = exp_valid_block;
10908 w->cond_exp_valid_block = cond_exp_valid_block;
10911 struct type *t = value_type (val);
10912 CORE_ADDR addr = value_as_address (val);
10914 w->exp_string_reparse
10915 = current_language->la_watch_location_expression (t, addr).release ();
10917 w->exp_string = xstrprintf ("-location %.*s",
10918 (int) (exp_end - exp_start), exp_start);
10921 w->exp_string = savestring (exp_start, exp_end - exp_start);
10925 w->hw_wp_mask = mask;
10930 w->val_bitpos = saved_bitpos;
10931 w->val_bitsize = saved_bitsize;
10936 w->cond_string = savestring (cond_start, cond_end - cond_start);
10938 w->cond_string = 0;
10940 if (frame_id_p (watchpoint_frame))
10942 w->watchpoint_frame = watchpoint_frame;
10943 w->watchpoint_thread = inferior_ptid;
10947 w->watchpoint_frame = null_frame_id;
10948 w->watchpoint_thread = null_ptid;
10951 if (scope_breakpoint != NULL)
10953 /* The scope breakpoint is related to the watchpoint. We will
10954 need to act on them together. */
10955 w->related_breakpoint = scope_breakpoint;
10956 scope_breakpoint->related_breakpoint = w.get ();
10959 if (!just_location)
10960 value_free_to_mark (mark);
10962 /* Finally update the new watchpoint. This creates the locations
10963 that should be inserted. */
10964 update_watchpoint (w.get (), 1);
10966 install_breakpoint (internal, std::move (w), 1);
10969 /* Return count of debug registers needed to watch the given expression.
10970 If the watchpoint cannot be handled in hardware return zero. */
10973 can_use_hardware_watchpoint (struct value *v)
10975 int found_memory_cnt = 0;
10976 struct value *head = v;
10978 /* Did the user specifically forbid us to use hardware watchpoints? */
10979 if (!can_use_hw_watchpoints)
10982 /* Make sure that the value of the expression depends only upon
10983 memory contents, and values computed from them within GDB. If we
10984 find any register references or function calls, we can't use a
10985 hardware watchpoint.
10987 The idea here is that evaluating an expression generates a series
10988 of values, one holding the value of every subexpression. (The
10989 expression a*b+c has five subexpressions: a, b, a*b, c, and
10990 a*b+c.) GDB's values hold almost enough information to establish
10991 the criteria given above --- they identify memory lvalues,
10992 register lvalues, computed values, etcetera. So we can evaluate
10993 the expression, and then scan the chain of values that leaves
10994 behind to decide whether we can detect any possible change to the
10995 expression's final value using only hardware watchpoints.
10997 However, I don't think that the values returned by inferior
10998 function calls are special in any way. So this function may not
10999 notice that an expression involving an inferior function call
11000 can't be watched with hardware watchpoints. FIXME. */
11001 for (; v; v = value_next (v))
11003 if (VALUE_LVAL (v) == lval_memory)
11005 if (v != head && value_lazy (v))
11006 /* A lazy memory lvalue in the chain is one that GDB never
11007 needed to fetch; we either just used its address (e.g.,
11008 `a' in `a.b') or we never needed it at all (e.g., `a'
11009 in `a,b'). This doesn't apply to HEAD; if that is
11010 lazy then it was not readable, but watch it anyway. */
11014 /* Ahh, memory we actually used! Check if we can cover
11015 it with hardware watchpoints. */
11016 struct type *vtype = check_typedef (value_type (v));
11018 /* We only watch structs and arrays if user asked for it
11019 explicitly, never if they just happen to appear in a
11020 middle of some value chain. */
11022 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
11023 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
11025 CORE_ADDR vaddr = value_address (v);
11029 len = (target_exact_watchpoints
11030 && is_scalar_type_recursive (vtype))?
11031 1 : TYPE_LENGTH (value_type (v));
11033 num_regs = target_region_ok_for_hw_watchpoint (vaddr, len);
11037 found_memory_cnt += num_regs;
11041 else if (VALUE_LVAL (v) != not_lval
11042 && deprecated_value_modifiable (v) == 0)
11043 return 0; /* These are values from the history (e.g., $1). */
11044 else if (VALUE_LVAL (v) == lval_register)
11045 return 0; /* Cannot watch a register with a HW watchpoint. */
11048 /* The expression itself looks suitable for using a hardware
11049 watchpoint, but give the target machine a chance to reject it. */
11050 return found_memory_cnt;
11054 watch_command_wrapper (const char *arg, int from_tty, int internal)
11056 watch_command_1 (arg, hw_write, from_tty, 0, internal);
11059 /* A helper function that looks for the "-location" argument and then
11060 calls watch_command_1. */
11063 watch_maybe_just_location (char *arg, int accessflag, int from_tty)
11065 int just_location = 0;
11068 && (check_for_argument (&arg, "-location", sizeof ("-location") - 1)
11069 || check_for_argument (&arg, "-l", sizeof ("-l") - 1)))
11071 arg = skip_spaces (arg);
11075 watch_command_1 (arg, accessflag, from_tty, just_location, 0);
11079 watch_command (char *arg, int from_tty)
11081 watch_maybe_just_location (arg, hw_write, from_tty);
11085 rwatch_command_wrapper (const char *arg, int from_tty, int internal)
11087 watch_command_1 (arg, hw_read, from_tty, 0, internal);
11091 rwatch_command (char *arg, int from_tty)
11093 watch_maybe_just_location (arg, hw_read, from_tty);
11097 awatch_command_wrapper (const char *arg, int from_tty, int internal)
11099 watch_command_1 (arg, hw_access, from_tty, 0, internal);
11103 awatch_command (char *arg, int from_tty)
11105 watch_maybe_just_location (arg, hw_access, from_tty);
11109 /* Data for the FSM that manages the until(location)/advance commands
11110 in infcmd.c. Here because it uses the mechanisms of
11113 struct until_break_fsm
11115 /* The base class. */
11116 struct thread_fsm thread_fsm;
11118 /* The thread that as current when the command was executed. */
11121 /* The breakpoint set at the destination location. */
11122 struct breakpoint *location_breakpoint;
11124 /* Breakpoint set at the return address in the caller frame. May be
11126 struct breakpoint *caller_breakpoint;
11129 static void until_break_fsm_clean_up (struct thread_fsm *self,
11130 struct thread_info *thread);
11131 static int until_break_fsm_should_stop (struct thread_fsm *self,
11132 struct thread_info *thread);
11133 static enum async_reply_reason
11134 until_break_fsm_async_reply_reason (struct thread_fsm *self);
11136 /* until_break_fsm's vtable. */
11138 static struct thread_fsm_ops until_break_fsm_ops =
11141 until_break_fsm_clean_up,
11142 until_break_fsm_should_stop,
11143 NULL, /* return_value */
11144 until_break_fsm_async_reply_reason,
11147 /* Allocate a new until_break_command_fsm. */
11149 static struct until_break_fsm *
11150 new_until_break_fsm (struct interp *cmd_interp, int thread,
11151 struct breakpoint *location_breakpoint,
11152 struct breakpoint *caller_breakpoint)
11154 struct until_break_fsm *sm;
11156 sm = XCNEW (struct until_break_fsm);
11157 thread_fsm_ctor (&sm->thread_fsm, &until_break_fsm_ops, cmd_interp);
11159 sm->thread = thread;
11160 sm->location_breakpoint = location_breakpoint;
11161 sm->caller_breakpoint = caller_breakpoint;
11166 /* Implementation of the 'should_stop' FSM method for the
11167 until(location)/advance commands. */
11170 until_break_fsm_should_stop (struct thread_fsm *self,
11171 struct thread_info *tp)
11173 struct until_break_fsm *sm = (struct until_break_fsm *) self;
11175 if (bpstat_find_breakpoint (tp->control.stop_bpstat,
11176 sm->location_breakpoint) != NULL
11177 || (sm->caller_breakpoint != NULL
11178 && bpstat_find_breakpoint (tp->control.stop_bpstat,
11179 sm->caller_breakpoint) != NULL))
11180 thread_fsm_set_finished (self);
11185 /* Implementation of the 'clean_up' FSM method for the
11186 until(location)/advance commands. */
11189 until_break_fsm_clean_up (struct thread_fsm *self,
11190 struct thread_info *thread)
11192 struct until_break_fsm *sm = (struct until_break_fsm *) self;
11194 /* Clean up our temporary breakpoints. */
11195 if (sm->location_breakpoint != NULL)
11197 delete_breakpoint (sm->location_breakpoint);
11198 sm->location_breakpoint = NULL;
11200 if (sm->caller_breakpoint != NULL)
11202 delete_breakpoint (sm->caller_breakpoint);
11203 sm->caller_breakpoint = NULL;
11205 delete_longjmp_breakpoint (sm->thread);
11208 /* Implementation of the 'async_reply_reason' FSM method for the
11209 until(location)/advance commands. */
11211 static enum async_reply_reason
11212 until_break_fsm_async_reply_reason (struct thread_fsm *self)
11214 return EXEC_ASYNC_LOCATION_REACHED;
11218 until_break_command (const char *arg, int from_tty, int anywhere)
11220 struct frame_info *frame;
11221 struct gdbarch *frame_gdbarch;
11222 struct frame_id stack_frame_id;
11223 struct frame_id caller_frame_id;
11224 struct breakpoint *location_breakpoint;
11225 struct breakpoint *caller_breakpoint = NULL;
11226 struct cleanup *old_chain;
11228 struct thread_info *tp;
11229 struct until_break_fsm *sm;
11231 clear_proceed_status (0);
11233 /* Set a breakpoint where the user wants it and at return from
11236 event_location_up location = string_to_event_location (&arg, current_language);
11238 std::vector<symtab_and_line> sals
11239 = (last_displayed_sal_is_valid ()
11240 ? decode_line_1 (location.get (), DECODE_LINE_FUNFIRSTLINE, NULL,
11241 get_last_displayed_symtab (),
11242 get_last_displayed_line ())
11243 : decode_line_1 (location.get (), DECODE_LINE_FUNFIRSTLINE,
11244 NULL, (struct symtab *) NULL, 0));
11246 if (sals.size () != 1)
11247 error (_("Couldn't get information on specified line."));
11249 symtab_and_line &sal = sals[0];
11252 error (_("Junk at end of arguments."));
11254 resolve_sal_pc (&sal);
11256 tp = inferior_thread ();
11257 thread = tp->global_num;
11259 old_chain = make_cleanup (null_cleanup, NULL);
11261 /* Note linespec handling above invalidates the frame chain.
11262 Installing a breakpoint also invalidates the frame chain (as it
11263 may need to switch threads), so do any frame handling before
11266 frame = get_selected_frame (NULL);
11267 frame_gdbarch = get_frame_arch (frame);
11268 stack_frame_id = get_stack_frame_id (frame);
11269 caller_frame_id = frame_unwind_caller_id (frame);
11271 /* Keep within the current frame, or in frames called by the current
11274 if (frame_id_p (caller_frame_id))
11276 struct symtab_and_line sal2;
11277 struct gdbarch *caller_gdbarch;
11279 sal2 = find_pc_line (frame_unwind_caller_pc (frame), 0);
11280 sal2.pc = frame_unwind_caller_pc (frame);
11281 caller_gdbarch = frame_unwind_caller_arch (frame);
11282 caller_breakpoint = set_momentary_breakpoint (caller_gdbarch,
11286 make_cleanup_delete_breakpoint (caller_breakpoint);
11288 set_longjmp_breakpoint (tp, caller_frame_id);
11289 make_cleanup (delete_longjmp_breakpoint_cleanup, &thread);
11292 /* set_momentary_breakpoint could invalidate FRAME. */
11296 /* If the user told us to continue until a specified location,
11297 we don't specify a frame at which we need to stop. */
11298 location_breakpoint = set_momentary_breakpoint (frame_gdbarch, sal,
11299 null_frame_id, bp_until);
11301 /* Otherwise, specify the selected frame, because we want to stop
11302 only at the very same frame. */
11303 location_breakpoint = set_momentary_breakpoint (frame_gdbarch, sal,
11304 stack_frame_id, bp_until);
11305 make_cleanup_delete_breakpoint (location_breakpoint);
11307 sm = new_until_break_fsm (command_interp (), tp->global_num,
11308 location_breakpoint, caller_breakpoint);
11309 tp->thread_fsm = &sm->thread_fsm;
11311 discard_cleanups (old_chain);
11313 proceed (-1, GDB_SIGNAL_DEFAULT);
11316 /* This function attempts to parse an optional "if <cond>" clause
11317 from the arg string. If one is not found, it returns NULL.
11319 Else, it returns a pointer to the condition string. (It does not
11320 attempt to evaluate the string against a particular block.) And,
11321 it updates arg to point to the first character following the parsed
11322 if clause in the arg string. */
11325 ep_parse_optional_if_clause (const char **arg)
11327 const char *cond_string;
11329 if (((*arg)[0] != 'i') || ((*arg)[1] != 'f') || !isspace ((*arg)[2]))
11332 /* Skip the "if" keyword. */
11335 /* Skip any extra leading whitespace, and record the start of the
11336 condition string. */
11337 *arg = skip_spaces (*arg);
11338 cond_string = *arg;
11340 /* Assume that the condition occupies the remainder of the arg
11342 (*arg) += strlen (cond_string);
11344 return cond_string;
11347 /* Commands to deal with catching events, such as signals, exceptions,
11348 process start/exit, etc. */
11352 catch_fork_temporary, catch_vfork_temporary,
11353 catch_fork_permanent, catch_vfork_permanent
11358 catch_fork_command_1 (char *arg_entry, int from_tty,
11359 struct cmd_list_element *command)
11361 const char *arg = arg_entry;
11362 struct gdbarch *gdbarch = get_current_arch ();
11363 const char *cond_string = NULL;
11364 catch_fork_kind fork_kind;
11367 fork_kind = (catch_fork_kind) (uintptr_t) get_cmd_context (command);
11368 tempflag = (fork_kind == catch_fork_temporary
11369 || fork_kind == catch_vfork_temporary);
11373 arg = skip_spaces (arg);
11375 /* The allowed syntax is:
11377 catch [v]fork if <cond>
11379 First, check if there's an if clause. */
11380 cond_string = ep_parse_optional_if_clause (&arg);
11382 if ((*arg != '\0') && !isspace (*arg))
11383 error (_("Junk at end of arguments."));
11385 /* If this target supports it, create a fork or vfork catchpoint
11386 and enable reporting of such events. */
11389 case catch_fork_temporary:
11390 case catch_fork_permanent:
11391 create_fork_vfork_event_catchpoint (gdbarch, tempflag, cond_string,
11392 &catch_fork_breakpoint_ops);
11394 case catch_vfork_temporary:
11395 case catch_vfork_permanent:
11396 create_fork_vfork_event_catchpoint (gdbarch, tempflag, cond_string,
11397 &catch_vfork_breakpoint_ops);
11400 error (_("unsupported or unknown fork kind; cannot catch it"));
11406 catch_exec_command_1 (char *arg_entry, int from_tty,
11407 struct cmd_list_element *command)
11409 const char *arg = arg_entry;
11410 struct gdbarch *gdbarch = get_current_arch ();
11412 const char *cond_string = NULL;
11414 tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
11418 arg = skip_spaces (arg);
11420 /* The allowed syntax is:
11422 catch exec if <cond>
11424 First, check if there's an if clause. */
11425 cond_string = ep_parse_optional_if_clause (&arg);
11427 if ((*arg != '\0') && !isspace (*arg))
11428 error (_("Junk at end of arguments."));
11430 std::unique_ptr<exec_catchpoint> c (new exec_catchpoint ());
11431 init_catchpoint (c.get (), gdbarch, tempflag, cond_string,
11432 &catch_exec_breakpoint_ops);
11433 c->exec_pathname = NULL;
11435 install_breakpoint (0, std::move (c), 1);
11439 init_ada_exception_breakpoint (struct breakpoint *b,
11440 struct gdbarch *gdbarch,
11441 struct symtab_and_line sal,
11442 const char *addr_string,
11443 const struct breakpoint_ops *ops,
11450 struct gdbarch *loc_gdbarch = get_sal_arch (sal);
11452 loc_gdbarch = gdbarch;
11454 describe_other_breakpoints (loc_gdbarch,
11455 sal.pspace, sal.pc, sal.section, -1);
11456 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
11457 version for exception catchpoints, because two catchpoints
11458 used for different exception names will use the same address.
11459 In this case, a "breakpoint ... also set at..." warning is
11460 unproductive. Besides, the warning phrasing is also a bit
11461 inappropriate, we should use the word catchpoint, and tell
11462 the user what type of catchpoint it is. The above is good
11463 enough for now, though. */
11466 init_raw_breakpoint (b, gdbarch, sal, bp_breakpoint, ops);
11468 b->enable_state = enabled ? bp_enabled : bp_disabled;
11469 b->disposition = tempflag ? disp_del : disp_donttouch;
11470 b->location = string_to_event_location (&addr_string,
11471 language_def (language_ada));
11472 b->language = language_ada;
11476 catch_command (const char *arg, int from_tty)
11478 error (_("Catch requires an event name."));
11483 tcatch_command (const char *arg, int from_tty)
11485 error (_("Catch requires an event name."));
11488 /* Compare two breakpoints and return a strcmp-like result. */
11491 compare_breakpoints (const breakpoint *a, const breakpoint *b)
11493 uintptr_t ua = (uintptr_t) a;
11494 uintptr_t ub = (uintptr_t) b;
11496 if (a->number < b->number)
11498 else if (a->number > b->number)
11501 /* Now sort by address, in case we see, e..g, two breakpoints with
11505 return ua > ub ? 1 : 0;
11508 /* Delete breakpoints by address or line. */
11511 clear_command (char *arg, int from_tty)
11513 struct breakpoint *b;
11517 std::vector<symtab_and_line> decoded_sals;
11518 symtab_and_line last_sal;
11519 gdb::array_view<symtab_and_line> sals;
11523 = decode_line_with_current_source (arg,
11524 (DECODE_LINE_FUNFIRSTLINE
11525 | DECODE_LINE_LIST_MODE));
11527 sals = decoded_sals;
11531 /* Set sal's line, symtab, pc, and pspace to the values
11532 corresponding to the last call to print_frame_info. If the
11533 codepoint is not valid, this will set all the fields to 0. */
11534 last_sal = get_last_displayed_sal ();
11535 if (last_sal.symtab == 0)
11536 error (_("No source file specified."));
11542 /* We don't call resolve_sal_pc here. That's not as bad as it
11543 seems, because all existing breakpoints typically have both
11544 file/line and pc set. So, if clear is given file/line, we can
11545 match this to existing breakpoint without obtaining pc at all.
11547 We only support clearing given the address explicitly
11548 present in breakpoint table. Say, we've set breakpoint
11549 at file:line. There were several PC values for that file:line,
11550 due to optimization, all in one block.
11552 We've picked one PC value. If "clear" is issued with another
11553 PC corresponding to the same file:line, the breakpoint won't
11554 be cleared. We probably can still clear the breakpoint, but
11555 since the other PC value is never presented to user, user
11556 can only find it by guessing, and it does not seem important
11557 to support that. */
11559 /* For each line spec given, delete bps which correspond to it. Do
11560 it in two passes, solely to preserve the current behavior that
11561 from_tty is forced true if we delete more than one
11564 std::vector<struct breakpoint *> found;
11565 for (const auto &sal : sals)
11567 const char *sal_fullname;
11569 /* If exact pc given, clear bpts at that pc.
11570 If line given (pc == 0), clear all bpts on specified line.
11571 If defaulting, clear all bpts on default line
11574 defaulting sal.pc != 0 tests to do
11579 1 0 <can't happen> */
11581 sal_fullname = (sal.symtab == NULL
11582 ? NULL : symtab_to_fullname (sal.symtab));
11584 /* Find all matching breakpoints and add them to 'found'. */
11585 ALL_BREAKPOINTS (b)
11588 /* Are we going to delete b? */
11589 if (b->type != bp_none && !is_watchpoint (b))
11591 struct bp_location *loc = b->loc;
11592 for (; loc; loc = loc->next)
11594 /* If the user specified file:line, don't allow a PC
11595 match. This matches historical gdb behavior. */
11596 int pc_match = (!sal.explicit_line
11598 && (loc->pspace == sal.pspace)
11599 && (loc->address == sal.pc)
11600 && (!section_is_overlay (loc->section)
11601 || loc->section == sal.section));
11602 int line_match = 0;
11604 if ((default_match || sal.explicit_line)
11605 && loc->symtab != NULL
11606 && sal_fullname != NULL
11607 && sal.pspace == loc->pspace
11608 && loc->line_number == sal.line
11609 && filename_cmp (symtab_to_fullname (loc->symtab),
11610 sal_fullname) == 0)
11613 if (pc_match || line_match)
11622 found.push_back (b);
11626 /* Now go thru the 'found' chain and delete them. */
11627 if (found.empty ())
11630 error (_("No breakpoint at %s."), arg);
11632 error (_("No breakpoint at this line."));
11635 /* Remove duplicates from the vec. */
11636 std::sort (found.begin (), found.end (),
11637 [] (const breakpoint *a, const breakpoint *b)
11639 return compare_breakpoints (a, b) < 0;
11641 found.erase (std::unique (found.begin (), found.end (),
11642 [] (const breakpoint *a, const breakpoint *b)
11644 return compare_breakpoints (a, b) == 0;
11648 if (found.size () > 1)
11649 from_tty = 1; /* Always report if deleted more than one. */
11652 if (found.size () == 1)
11653 printf_unfiltered (_("Deleted breakpoint "));
11655 printf_unfiltered (_("Deleted breakpoints "));
11658 for (breakpoint *iter : found)
11661 printf_unfiltered ("%d ", iter->number);
11662 delete_breakpoint (iter);
11665 putchar_unfiltered ('\n');
11668 /* Delete breakpoint in BS if they are `delete' breakpoints and
11669 all breakpoints that are marked for deletion, whether hit or not.
11670 This is called after any breakpoint is hit, or after errors. */
11673 breakpoint_auto_delete (bpstat bs)
11675 struct breakpoint *b, *b_tmp;
11677 for (; bs; bs = bs->next)
11678 if (bs->breakpoint_at
11679 && bs->breakpoint_at->disposition == disp_del
11681 delete_breakpoint (bs->breakpoint_at);
11683 ALL_BREAKPOINTS_SAFE (b, b_tmp)
11685 if (b->disposition == disp_del_at_next_stop)
11686 delete_breakpoint (b);
11690 /* A comparison function for bp_location AP and BP being interfaced to
11691 qsort. Sort elements primarily by their ADDRESS (no matter what
11692 does breakpoint_address_is_meaningful say for its OWNER),
11693 secondarily by ordering first permanent elements and
11694 terciarily just ensuring the array is sorted stable way despite
11695 qsort being an unstable algorithm. */
11698 bp_locations_compare (const void *ap, const void *bp)
11700 const struct bp_location *a = *(const struct bp_location **) ap;
11701 const struct bp_location *b = *(const struct bp_location **) bp;
11703 if (a->address != b->address)
11704 return (a->address > b->address) - (a->address < b->address);
11706 /* Sort locations at the same address by their pspace number, keeping
11707 locations of the same inferior (in a multi-inferior environment)
11710 if (a->pspace->num != b->pspace->num)
11711 return ((a->pspace->num > b->pspace->num)
11712 - (a->pspace->num < b->pspace->num));
11714 /* Sort permanent breakpoints first. */
11715 if (a->permanent != b->permanent)
11716 return (a->permanent < b->permanent) - (a->permanent > b->permanent);
11718 /* Make the internal GDB representation stable across GDB runs
11719 where A and B memory inside GDB can differ. Breakpoint locations of
11720 the same type at the same address can be sorted in arbitrary order. */
11722 if (a->owner->number != b->owner->number)
11723 return ((a->owner->number > b->owner->number)
11724 - (a->owner->number < b->owner->number));
11726 return (a > b) - (a < b);
11729 /* Set bp_locations_placed_address_before_address_max and
11730 bp_locations_shadow_len_after_address_max according to the current
11731 content of the bp_locations array. */
11734 bp_locations_target_extensions_update (void)
11736 struct bp_location *bl, **blp_tmp;
11738 bp_locations_placed_address_before_address_max = 0;
11739 bp_locations_shadow_len_after_address_max = 0;
11741 ALL_BP_LOCATIONS (bl, blp_tmp)
11743 CORE_ADDR start, end, addr;
11745 if (!bp_location_has_shadow (bl))
11748 start = bl->target_info.placed_address;
11749 end = start + bl->target_info.shadow_len;
11751 gdb_assert (bl->address >= start);
11752 addr = bl->address - start;
11753 if (addr > bp_locations_placed_address_before_address_max)
11754 bp_locations_placed_address_before_address_max = addr;
11756 /* Zero SHADOW_LEN would not pass bp_location_has_shadow. */
11758 gdb_assert (bl->address < end);
11759 addr = end - bl->address;
11760 if (addr > bp_locations_shadow_len_after_address_max)
11761 bp_locations_shadow_len_after_address_max = addr;
11765 /* Download tracepoint locations if they haven't been. */
11768 download_tracepoint_locations (void)
11770 struct breakpoint *b;
11771 enum tribool can_download_tracepoint = TRIBOOL_UNKNOWN;
11773 scoped_restore_current_pspace_and_thread restore_pspace_thread;
11775 ALL_TRACEPOINTS (b)
11777 struct bp_location *bl;
11778 struct tracepoint *t;
11779 int bp_location_downloaded = 0;
11781 if ((b->type == bp_fast_tracepoint
11782 ? !may_insert_fast_tracepoints
11783 : !may_insert_tracepoints))
11786 if (can_download_tracepoint == TRIBOOL_UNKNOWN)
11788 if (target_can_download_tracepoint ())
11789 can_download_tracepoint = TRIBOOL_TRUE;
11791 can_download_tracepoint = TRIBOOL_FALSE;
11794 if (can_download_tracepoint == TRIBOOL_FALSE)
11797 for (bl = b->loc; bl; bl = bl->next)
11799 /* In tracepoint, locations are _never_ duplicated, so
11800 should_be_inserted is equivalent to
11801 unduplicated_should_be_inserted. */
11802 if (!should_be_inserted (bl) || bl->inserted)
11805 switch_to_program_space_and_thread (bl->pspace);
11807 target_download_tracepoint (bl);
11810 bp_location_downloaded = 1;
11812 t = (struct tracepoint *) b;
11813 t->number_on_target = b->number;
11814 if (bp_location_downloaded)
11815 observer_notify_breakpoint_modified (b);
11819 /* Swap the insertion/duplication state between two locations. */
11822 swap_insertion (struct bp_location *left, struct bp_location *right)
11824 const int left_inserted = left->inserted;
11825 const int left_duplicate = left->duplicate;
11826 const int left_needs_update = left->needs_update;
11827 const struct bp_target_info left_target_info = left->target_info;
11829 /* Locations of tracepoints can never be duplicated. */
11830 if (is_tracepoint (left->owner))
11831 gdb_assert (!left->duplicate);
11832 if (is_tracepoint (right->owner))
11833 gdb_assert (!right->duplicate);
11835 left->inserted = right->inserted;
11836 left->duplicate = right->duplicate;
11837 left->needs_update = right->needs_update;
11838 left->target_info = right->target_info;
11839 right->inserted = left_inserted;
11840 right->duplicate = left_duplicate;
11841 right->needs_update = left_needs_update;
11842 right->target_info = left_target_info;
11845 /* Force the re-insertion of the locations at ADDRESS. This is called
11846 once a new/deleted/modified duplicate location is found and we are evaluating
11847 conditions on the target's side. Such conditions need to be updated on
11851 force_breakpoint_reinsertion (struct bp_location *bl)
11853 struct bp_location **locp = NULL, **loc2p;
11854 struct bp_location *loc;
11855 CORE_ADDR address = 0;
11858 address = bl->address;
11859 pspace_num = bl->pspace->num;
11861 /* This is only meaningful if the target is
11862 evaluating conditions and if the user has
11863 opted for condition evaluation on the target's
11865 if (gdb_evaluates_breakpoint_condition_p ()
11866 || !target_supports_evaluation_of_breakpoint_conditions ())
11869 /* Flag all breakpoint locations with this address and
11870 the same program space as the location
11871 as "its condition has changed". We need to
11872 update the conditions on the target's side. */
11873 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, address)
11877 if (!is_breakpoint (loc->owner)
11878 || pspace_num != loc->pspace->num)
11881 /* Flag the location appropriately. We use a different state to
11882 let everyone know that we already updated the set of locations
11883 with addr bl->address and program space bl->pspace. This is so
11884 we don't have to keep calling these functions just to mark locations
11885 that have already been marked. */
11886 loc->condition_changed = condition_updated;
11888 /* Free the agent expression bytecode as well. We will compute
11890 loc->cond_bytecode.reset ();
11893 /* Called whether new breakpoints are created, or existing breakpoints
11894 deleted, to update the global location list and recompute which
11895 locations are duplicate of which.
11897 The INSERT_MODE flag determines whether locations may not, may, or
11898 shall be inserted now. See 'enum ugll_insert_mode' for more
11902 update_global_location_list (enum ugll_insert_mode insert_mode)
11904 struct breakpoint *b;
11905 struct bp_location **locp, *loc;
11906 /* Last breakpoint location address that was marked for update. */
11907 CORE_ADDR last_addr = 0;
11908 /* Last breakpoint location program space that was marked for update. */
11909 int last_pspace_num = -1;
11911 /* Used in the duplicates detection below. When iterating over all
11912 bp_locations, points to the first bp_location of a given address.
11913 Breakpoints and watchpoints of different types are never
11914 duplicates of each other. Keep one pointer for each type of
11915 breakpoint/watchpoint, so we only need to loop over all locations
11917 struct bp_location *bp_loc_first; /* breakpoint */
11918 struct bp_location *wp_loc_first; /* hardware watchpoint */
11919 struct bp_location *awp_loc_first; /* access watchpoint */
11920 struct bp_location *rwp_loc_first; /* read watchpoint */
11922 /* Saved former bp_locations array which we compare against the newly
11923 built bp_locations from the current state of ALL_BREAKPOINTS. */
11924 struct bp_location **old_locp;
11925 unsigned old_locations_count;
11926 gdb::unique_xmalloc_ptr<struct bp_location *> old_locations (bp_locations);
11928 old_locations_count = bp_locations_count;
11929 bp_locations = NULL;
11930 bp_locations_count = 0;
11932 ALL_BREAKPOINTS (b)
11933 for (loc = b->loc; loc; loc = loc->next)
11934 bp_locations_count++;
11936 bp_locations = XNEWVEC (struct bp_location *, bp_locations_count);
11937 locp = bp_locations;
11938 ALL_BREAKPOINTS (b)
11939 for (loc = b->loc; loc; loc = loc->next)
11941 qsort (bp_locations, bp_locations_count, sizeof (*bp_locations),
11942 bp_locations_compare);
11944 bp_locations_target_extensions_update ();
11946 /* Identify bp_location instances that are no longer present in the
11947 new list, and therefore should be freed. Note that it's not
11948 necessary that those locations should be removed from inferior --
11949 if there's another location at the same address (previously
11950 marked as duplicate), we don't need to remove/insert the
11953 LOCP is kept in sync with OLD_LOCP, each pointing to the current
11954 and former bp_location array state respectively. */
11956 locp = bp_locations;
11957 for (old_locp = old_locations.get ();
11958 old_locp < old_locations.get () + old_locations_count;
11961 struct bp_location *old_loc = *old_locp;
11962 struct bp_location **loc2p;
11964 /* Tells if 'old_loc' is found among the new locations. If
11965 not, we have to free it. */
11966 int found_object = 0;
11967 /* Tells if the location should remain inserted in the target. */
11968 int keep_in_target = 0;
11971 /* Skip LOCP entries which will definitely never be needed.
11972 Stop either at or being the one matching OLD_LOC. */
11973 while (locp < bp_locations + bp_locations_count
11974 && (*locp)->address < old_loc->address)
11978 (loc2p < bp_locations + bp_locations_count
11979 && (*loc2p)->address == old_loc->address);
11982 /* Check if this is a new/duplicated location or a duplicated
11983 location that had its condition modified. If so, we want to send
11984 its condition to the target if evaluation of conditions is taking
11986 if ((*loc2p)->condition_changed == condition_modified
11987 && (last_addr != old_loc->address
11988 || last_pspace_num != old_loc->pspace->num))
11990 force_breakpoint_reinsertion (*loc2p);
11991 last_pspace_num = old_loc->pspace->num;
11994 if (*loc2p == old_loc)
11998 /* We have already handled this address, update it so that we don't
11999 have to go through updates again. */
12000 last_addr = old_loc->address;
12002 /* Target-side condition evaluation: Handle deleted locations. */
12004 force_breakpoint_reinsertion (old_loc);
12006 /* If this location is no longer present, and inserted, look if
12007 there's maybe a new location at the same address. If so,
12008 mark that one inserted, and don't remove this one. This is
12009 needed so that we don't have a time window where a breakpoint
12010 at certain location is not inserted. */
12012 if (old_loc->inserted)
12014 /* If the location is inserted now, we might have to remove
12017 if (found_object && should_be_inserted (old_loc))
12019 /* The location is still present in the location list,
12020 and still should be inserted. Don't do anything. */
12021 keep_in_target = 1;
12025 /* This location still exists, but it won't be kept in the
12026 target since it may have been disabled. We proceed to
12027 remove its target-side condition. */
12029 /* The location is either no longer present, or got
12030 disabled. See if there's another location at the
12031 same address, in which case we don't need to remove
12032 this one from the target. */
12034 /* OLD_LOC comes from existing struct breakpoint. */
12035 if (breakpoint_address_is_meaningful (old_loc->owner))
12038 (loc2p < bp_locations + bp_locations_count
12039 && (*loc2p)->address == old_loc->address);
12042 struct bp_location *loc2 = *loc2p;
12044 if (breakpoint_locations_match (loc2, old_loc))
12046 /* Read watchpoint locations are switched to
12047 access watchpoints, if the former are not
12048 supported, but the latter are. */
12049 if (is_hardware_watchpoint (old_loc->owner))
12051 gdb_assert (is_hardware_watchpoint (loc2->owner));
12052 loc2->watchpoint_type = old_loc->watchpoint_type;
12055 /* loc2 is a duplicated location. We need to check
12056 if it should be inserted in case it will be
12058 if (loc2 != old_loc
12059 && unduplicated_should_be_inserted (loc2))
12061 swap_insertion (old_loc, loc2);
12062 keep_in_target = 1;
12070 if (!keep_in_target)
12072 if (remove_breakpoint (old_loc))
12074 /* This is just about all we can do. We could keep
12075 this location on the global list, and try to
12076 remove it next time, but there's no particular
12077 reason why we will succeed next time.
12079 Note that at this point, old_loc->owner is still
12080 valid, as delete_breakpoint frees the breakpoint
12081 only after calling us. */
12082 printf_filtered (_("warning: Error removing "
12083 "breakpoint %d\n"),
12084 old_loc->owner->number);
12092 if (removed && target_is_non_stop_p ()
12093 && need_moribund_for_location_type (old_loc))
12095 /* This location was removed from the target. In
12096 non-stop mode, a race condition is possible where
12097 we've removed a breakpoint, but stop events for that
12098 breakpoint are already queued and will arrive later.
12099 We apply an heuristic to be able to distinguish such
12100 SIGTRAPs from other random SIGTRAPs: we keep this
12101 breakpoint location for a bit, and will retire it
12102 after we see some number of events. The theory here
12103 is that reporting of events should, "on the average",
12104 be fair, so after a while we'll see events from all
12105 threads that have anything of interest, and no longer
12106 need to keep this breakpoint location around. We
12107 don't hold locations forever so to reduce chances of
12108 mistaking a non-breakpoint SIGTRAP for a breakpoint
12111 The heuristic failing can be disastrous on
12112 decr_pc_after_break targets.
12114 On decr_pc_after_break targets, like e.g., x86-linux,
12115 if we fail to recognize a late breakpoint SIGTRAP,
12116 because events_till_retirement has reached 0 too
12117 soon, we'll fail to do the PC adjustment, and report
12118 a random SIGTRAP to the user. When the user resumes
12119 the inferior, it will most likely immediately crash
12120 with SIGILL/SIGBUS/SIGSEGV, or worse, get silently
12121 corrupted, because of being resumed e.g., in the
12122 middle of a multi-byte instruction, or skipped a
12123 one-byte instruction. This was actually seen happen
12124 on native x86-linux, and should be less rare on
12125 targets that do not support new thread events, like
12126 remote, due to the heuristic depending on
12129 Mistaking a random SIGTRAP for a breakpoint trap
12130 causes similar symptoms (PC adjustment applied when
12131 it shouldn't), but then again, playing with SIGTRAPs
12132 behind the debugger's back is asking for trouble.
12134 Since hardware watchpoint traps are always
12135 distinguishable from other traps, so we don't need to
12136 apply keep hardware watchpoint moribund locations
12137 around. We simply always ignore hardware watchpoint
12138 traps we can no longer explain. */
12140 old_loc->events_till_retirement = 3 * (thread_count () + 1);
12141 old_loc->owner = NULL;
12143 VEC_safe_push (bp_location_p, moribund_locations, old_loc);
12147 old_loc->owner = NULL;
12148 decref_bp_location (&old_loc);
12153 /* Rescan breakpoints at the same address and section, marking the
12154 first one as "first" and any others as "duplicates". This is so
12155 that the bpt instruction is only inserted once. If we have a
12156 permanent breakpoint at the same place as BPT, make that one the
12157 official one, and the rest as duplicates. Permanent breakpoints
12158 are sorted first for the same address.
12160 Do the same for hardware watchpoints, but also considering the
12161 watchpoint's type (regular/access/read) and length. */
12163 bp_loc_first = NULL;
12164 wp_loc_first = NULL;
12165 awp_loc_first = NULL;
12166 rwp_loc_first = NULL;
12167 ALL_BP_LOCATIONS (loc, locp)
12169 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always
12171 struct bp_location **loc_first_p;
12174 if (!unduplicated_should_be_inserted (loc)
12175 || !breakpoint_address_is_meaningful (b)
12176 /* Don't detect duplicate for tracepoint locations because they are
12177 never duplicated. See the comments in field `duplicate' of
12178 `struct bp_location'. */
12179 || is_tracepoint (b))
12181 /* Clear the condition modification flag. */
12182 loc->condition_changed = condition_unchanged;
12186 if (b->type == bp_hardware_watchpoint)
12187 loc_first_p = &wp_loc_first;
12188 else if (b->type == bp_read_watchpoint)
12189 loc_first_p = &rwp_loc_first;
12190 else if (b->type == bp_access_watchpoint)
12191 loc_first_p = &awp_loc_first;
12193 loc_first_p = &bp_loc_first;
12195 if (*loc_first_p == NULL
12196 || (overlay_debugging && loc->section != (*loc_first_p)->section)
12197 || !breakpoint_locations_match (loc, *loc_first_p))
12199 *loc_first_p = loc;
12200 loc->duplicate = 0;
12202 if (is_breakpoint (loc->owner) && loc->condition_changed)
12204 loc->needs_update = 1;
12205 /* Clear the condition modification flag. */
12206 loc->condition_changed = condition_unchanged;
12212 /* This and the above ensure the invariant that the first location
12213 is not duplicated, and is the inserted one.
12214 All following are marked as duplicated, and are not inserted. */
12216 swap_insertion (loc, *loc_first_p);
12217 loc->duplicate = 1;
12219 /* Clear the condition modification flag. */
12220 loc->condition_changed = condition_unchanged;
12223 if (insert_mode == UGLL_INSERT || breakpoints_should_be_inserted_now ())
12225 if (insert_mode != UGLL_DONT_INSERT)
12226 insert_breakpoint_locations ();
12229 /* Even though the caller told us to not insert new
12230 locations, we may still need to update conditions on the
12231 target's side of breakpoints that were already inserted
12232 if the target is evaluating breakpoint conditions. We
12233 only update conditions for locations that are marked
12235 update_inserted_breakpoint_locations ();
12239 if (insert_mode != UGLL_DONT_INSERT)
12240 download_tracepoint_locations ();
12244 breakpoint_retire_moribund (void)
12246 struct bp_location *loc;
12249 for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
12250 if (--(loc->events_till_retirement) == 0)
12252 decref_bp_location (&loc);
12253 VEC_unordered_remove (bp_location_p, moribund_locations, ix);
12259 update_global_location_list_nothrow (enum ugll_insert_mode insert_mode)
12264 update_global_location_list (insert_mode);
12266 CATCH (e, RETURN_MASK_ERROR)
12272 /* Clear BKP from a BPS. */
12275 bpstat_remove_bp_location (bpstat bps, struct breakpoint *bpt)
12279 for (bs = bps; bs; bs = bs->next)
12280 if (bs->breakpoint_at == bpt)
12282 bs->breakpoint_at = NULL;
12283 bs->old_val = NULL;
12284 /* bs->commands will be freed later. */
12288 /* Callback for iterate_over_threads. */
12290 bpstat_remove_breakpoint_callback (struct thread_info *th, void *data)
12292 struct breakpoint *bpt = (struct breakpoint *) data;
12294 bpstat_remove_bp_location (th->control.stop_bpstat, bpt);
12298 /* Helper for breakpoint and tracepoint breakpoint_ops->mention
12302 say_where (struct breakpoint *b)
12304 struct value_print_options opts;
12306 get_user_print_options (&opts);
12308 /* i18n: cagney/2005-02-11: Below needs to be merged into a
12310 if (b->loc == NULL)
12312 /* For pending locations, the output differs slightly based
12313 on b->extra_string. If this is non-NULL, it contains either
12314 a condition or dprintf arguments. */
12315 if (b->extra_string == NULL)
12317 printf_filtered (_(" (%s) pending."),
12318 event_location_to_string (b->location.get ()));
12320 else if (b->type == bp_dprintf)
12322 printf_filtered (_(" (%s,%s) pending."),
12323 event_location_to_string (b->location.get ()),
12328 printf_filtered (_(" (%s %s) pending."),
12329 event_location_to_string (b->location.get ()),
12335 if (opts.addressprint || b->loc->symtab == NULL)
12337 printf_filtered (" at ");
12338 fputs_filtered (paddress (b->loc->gdbarch, b->loc->address),
12341 if (b->loc->symtab != NULL)
12343 /* If there is a single location, we can print the location
12345 if (b->loc->next == NULL)
12346 printf_filtered (": file %s, line %d.",
12347 symtab_to_filename_for_display (b->loc->symtab),
12348 b->loc->line_number);
12350 /* This is not ideal, but each location may have a
12351 different file name, and this at least reflects the
12352 real situation somewhat. */
12353 printf_filtered (": %s.",
12354 event_location_to_string (b->location.get ()));
12359 struct bp_location *loc = b->loc;
12361 for (; loc; loc = loc->next)
12363 printf_filtered (" (%d locations)", n);
12368 /* Default bp_location_ops methods. */
12371 bp_location_dtor (struct bp_location *self)
12373 xfree (self->function_name);
12376 static const struct bp_location_ops bp_location_ops =
12381 /* Destructor for the breakpoint base class. */
12383 breakpoint::~breakpoint ()
12385 xfree (this->cond_string);
12386 xfree (this->extra_string);
12387 xfree (this->filter);
12390 static struct bp_location *
12391 base_breakpoint_allocate_location (struct breakpoint *self)
12393 return new bp_location (&bp_location_ops, self);
12397 base_breakpoint_re_set (struct breakpoint *b)
12399 /* Nothing to re-set. */
12402 #define internal_error_pure_virtual_called() \
12403 gdb_assert_not_reached ("pure virtual function called")
12406 base_breakpoint_insert_location (struct bp_location *bl)
12408 internal_error_pure_virtual_called ();
12412 base_breakpoint_remove_location (struct bp_location *bl,
12413 enum remove_bp_reason reason)
12415 internal_error_pure_virtual_called ();
12419 base_breakpoint_breakpoint_hit (const struct bp_location *bl,
12420 const address_space *aspace,
12422 const struct target_waitstatus *ws)
12424 internal_error_pure_virtual_called ();
12428 base_breakpoint_check_status (bpstat bs)
12433 /* A "works_in_software_mode" breakpoint_ops method that just internal
12437 base_breakpoint_works_in_software_mode (const struct breakpoint *b)
12439 internal_error_pure_virtual_called ();
12442 /* A "resources_needed" breakpoint_ops method that just internal
12446 base_breakpoint_resources_needed (const struct bp_location *bl)
12448 internal_error_pure_virtual_called ();
12451 static enum print_stop_action
12452 base_breakpoint_print_it (bpstat bs)
12454 internal_error_pure_virtual_called ();
12458 base_breakpoint_print_one_detail (const struct breakpoint *self,
12459 struct ui_out *uiout)
12465 base_breakpoint_print_mention (struct breakpoint *b)
12467 internal_error_pure_virtual_called ();
12471 base_breakpoint_print_recreate (struct breakpoint *b, struct ui_file *fp)
12473 internal_error_pure_virtual_called ();
12477 base_breakpoint_create_sals_from_location
12478 (const struct event_location *location,
12479 struct linespec_result *canonical,
12480 enum bptype type_wanted)
12482 internal_error_pure_virtual_called ();
12486 base_breakpoint_create_breakpoints_sal (struct gdbarch *gdbarch,
12487 struct linespec_result *c,
12488 gdb::unique_xmalloc_ptr<char> cond_string,
12489 gdb::unique_xmalloc_ptr<char> extra_string,
12490 enum bptype type_wanted,
12491 enum bpdisp disposition,
12493 int task, int ignore_count,
12494 const struct breakpoint_ops *o,
12495 int from_tty, int enabled,
12496 int internal, unsigned flags)
12498 internal_error_pure_virtual_called ();
12501 static std::vector<symtab_and_line>
12502 base_breakpoint_decode_location (struct breakpoint *b,
12503 const struct event_location *location,
12504 struct program_space *search_pspace)
12506 internal_error_pure_virtual_called ();
12509 /* The default 'explains_signal' method. */
12512 base_breakpoint_explains_signal (struct breakpoint *b, enum gdb_signal sig)
12517 /* The default "after_condition_true" method. */
12520 base_breakpoint_after_condition_true (struct bpstats *bs)
12522 /* Nothing to do. */
12525 struct breakpoint_ops base_breakpoint_ops =
12527 base_breakpoint_allocate_location,
12528 base_breakpoint_re_set,
12529 base_breakpoint_insert_location,
12530 base_breakpoint_remove_location,
12531 base_breakpoint_breakpoint_hit,
12532 base_breakpoint_check_status,
12533 base_breakpoint_resources_needed,
12534 base_breakpoint_works_in_software_mode,
12535 base_breakpoint_print_it,
12537 base_breakpoint_print_one_detail,
12538 base_breakpoint_print_mention,
12539 base_breakpoint_print_recreate,
12540 base_breakpoint_create_sals_from_location,
12541 base_breakpoint_create_breakpoints_sal,
12542 base_breakpoint_decode_location,
12543 base_breakpoint_explains_signal,
12544 base_breakpoint_after_condition_true,
12547 /* Default breakpoint_ops methods. */
12550 bkpt_re_set (struct breakpoint *b)
12552 /* FIXME: is this still reachable? */
12553 if (breakpoint_event_location_empty_p (b))
12555 /* Anything without a location can't be re-set. */
12556 delete_breakpoint (b);
12560 breakpoint_re_set_default (b);
12564 bkpt_insert_location (struct bp_location *bl)
12566 CORE_ADDR addr = bl->target_info.reqstd_address;
12568 bl->target_info.kind = breakpoint_kind (bl, &addr);
12569 bl->target_info.placed_address = addr;
12571 if (bl->loc_type == bp_loc_hardware_breakpoint)
12572 return target_insert_hw_breakpoint (bl->gdbarch, &bl->target_info);
12574 return target_insert_breakpoint (bl->gdbarch, &bl->target_info);
12578 bkpt_remove_location (struct bp_location *bl, enum remove_bp_reason reason)
12580 if (bl->loc_type == bp_loc_hardware_breakpoint)
12581 return target_remove_hw_breakpoint (bl->gdbarch, &bl->target_info);
12583 return target_remove_breakpoint (bl->gdbarch, &bl->target_info, reason);
12587 bkpt_breakpoint_hit (const struct bp_location *bl,
12588 const address_space *aspace, CORE_ADDR bp_addr,
12589 const struct target_waitstatus *ws)
12591 if (ws->kind != TARGET_WAITKIND_STOPPED
12592 || ws->value.sig != GDB_SIGNAL_TRAP)
12595 if (!breakpoint_address_match (bl->pspace->aspace, bl->address,
12599 if (overlay_debugging /* unmapped overlay section */
12600 && section_is_overlay (bl->section)
12601 && !section_is_mapped (bl->section))
12608 dprintf_breakpoint_hit (const struct bp_location *bl,
12609 const address_space *aspace, CORE_ADDR bp_addr,
12610 const struct target_waitstatus *ws)
12612 if (dprintf_style == dprintf_style_agent
12613 && target_can_run_breakpoint_commands ())
12615 /* An agent-style dprintf never causes a stop. If we see a trap
12616 for this address it must be for a breakpoint that happens to
12617 be set at the same address. */
12621 return bkpt_breakpoint_hit (bl, aspace, bp_addr, ws);
12625 bkpt_resources_needed (const struct bp_location *bl)
12627 gdb_assert (bl->owner->type == bp_hardware_breakpoint);
12632 static enum print_stop_action
12633 bkpt_print_it (bpstat bs)
12635 struct breakpoint *b;
12636 const struct bp_location *bl;
12638 struct ui_out *uiout = current_uiout;
12640 gdb_assert (bs->bp_location_at != NULL);
12642 bl = bs->bp_location_at;
12643 b = bs->breakpoint_at;
12645 bp_temp = b->disposition == disp_del;
12646 if (bl->address != bl->requested_address)
12647 breakpoint_adjustment_warning (bl->requested_address,
12650 annotate_breakpoint (b->number);
12651 maybe_print_thread_hit_breakpoint (uiout);
12654 uiout->text ("Temporary breakpoint ");
12656 uiout->text ("Breakpoint ");
12657 if (uiout->is_mi_like_p ())
12659 uiout->field_string ("reason",
12660 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
12661 uiout->field_string ("disp", bpdisp_text (b->disposition));
12663 uiout->field_int ("bkptno", b->number);
12664 uiout->text (", ");
12666 return PRINT_SRC_AND_LOC;
12670 bkpt_print_mention (struct breakpoint *b)
12672 if (current_uiout->is_mi_like_p ())
12677 case bp_breakpoint:
12678 case bp_gnu_ifunc_resolver:
12679 if (b->disposition == disp_del)
12680 printf_filtered (_("Temporary breakpoint"));
12682 printf_filtered (_("Breakpoint"));
12683 printf_filtered (_(" %d"), b->number);
12684 if (b->type == bp_gnu_ifunc_resolver)
12685 printf_filtered (_(" at gnu-indirect-function resolver"));
12687 case bp_hardware_breakpoint:
12688 printf_filtered (_("Hardware assisted breakpoint %d"), b->number);
12691 printf_filtered (_("Dprintf %d"), b->number);
12699 bkpt_print_recreate (struct breakpoint *tp, struct ui_file *fp)
12701 if (tp->type == bp_breakpoint && tp->disposition == disp_del)
12702 fprintf_unfiltered (fp, "tbreak");
12703 else if (tp->type == bp_breakpoint)
12704 fprintf_unfiltered (fp, "break");
12705 else if (tp->type == bp_hardware_breakpoint
12706 && tp->disposition == disp_del)
12707 fprintf_unfiltered (fp, "thbreak");
12708 else if (tp->type == bp_hardware_breakpoint)
12709 fprintf_unfiltered (fp, "hbreak");
12711 internal_error (__FILE__, __LINE__,
12712 _("unhandled breakpoint type %d"), (int) tp->type);
12714 fprintf_unfiltered (fp, " %s",
12715 event_location_to_string (tp->location.get ()));
12717 /* Print out extra_string if this breakpoint is pending. It might
12718 contain, for example, conditions that were set by the user. */
12719 if (tp->loc == NULL && tp->extra_string != NULL)
12720 fprintf_unfiltered (fp, " %s", tp->extra_string);
12722 print_recreate_thread (tp, fp);
12726 bkpt_create_sals_from_location (const struct event_location *location,
12727 struct linespec_result *canonical,
12728 enum bptype type_wanted)
12730 create_sals_from_location_default (location, canonical, type_wanted);
12734 bkpt_create_breakpoints_sal (struct gdbarch *gdbarch,
12735 struct linespec_result *canonical,
12736 gdb::unique_xmalloc_ptr<char> cond_string,
12737 gdb::unique_xmalloc_ptr<char> extra_string,
12738 enum bptype type_wanted,
12739 enum bpdisp disposition,
12741 int task, int ignore_count,
12742 const struct breakpoint_ops *ops,
12743 int from_tty, int enabled,
12744 int internal, unsigned flags)
12746 create_breakpoints_sal_default (gdbarch, canonical,
12747 std::move (cond_string),
12748 std::move (extra_string),
12750 disposition, thread, task,
12751 ignore_count, ops, from_tty,
12752 enabled, internal, flags);
12755 static std::vector<symtab_and_line>
12756 bkpt_decode_location (struct breakpoint *b,
12757 const struct event_location *location,
12758 struct program_space *search_pspace)
12760 return decode_location_default (b, location, search_pspace);
12763 /* Virtual table for internal breakpoints. */
12766 internal_bkpt_re_set (struct breakpoint *b)
12770 /* Delete overlay event and longjmp master breakpoints; they
12771 will be reset later by breakpoint_re_set. */
12772 case bp_overlay_event:
12773 case bp_longjmp_master:
12774 case bp_std_terminate_master:
12775 case bp_exception_master:
12776 delete_breakpoint (b);
12779 /* This breakpoint is special, it's set up when the inferior
12780 starts and we really don't want to touch it. */
12781 case bp_shlib_event:
12783 /* Like bp_shlib_event, this breakpoint type is special. Once
12784 it is set up, we do not want to touch it. */
12785 case bp_thread_event:
12791 internal_bkpt_check_status (bpstat bs)
12793 if (bs->breakpoint_at->type == bp_shlib_event)
12795 /* If requested, stop when the dynamic linker notifies GDB of
12796 events. This allows the user to get control and place
12797 breakpoints in initializer routines for dynamically loaded
12798 objects (among other things). */
12799 bs->stop = stop_on_solib_events;
12800 bs->print = stop_on_solib_events;
12806 static enum print_stop_action
12807 internal_bkpt_print_it (bpstat bs)
12809 struct breakpoint *b;
12811 b = bs->breakpoint_at;
12815 case bp_shlib_event:
12816 /* Did we stop because the user set the stop_on_solib_events
12817 variable? (If so, we report this as a generic, "Stopped due
12818 to shlib event" message.) */
12819 print_solib_event (0);
12822 case bp_thread_event:
12823 /* Not sure how we will get here.
12824 GDB should not stop for these breakpoints. */
12825 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
12828 case bp_overlay_event:
12829 /* By analogy with the thread event, GDB should not stop for these. */
12830 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
12833 case bp_longjmp_master:
12834 /* These should never be enabled. */
12835 printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
12838 case bp_std_terminate_master:
12839 /* These should never be enabled. */
12840 printf_filtered (_("std::terminate Master Breakpoint: "
12841 "gdb should not stop!\n"));
12844 case bp_exception_master:
12845 /* These should never be enabled. */
12846 printf_filtered (_("Exception Master Breakpoint: "
12847 "gdb should not stop!\n"));
12851 return PRINT_NOTHING;
12855 internal_bkpt_print_mention (struct breakpoint *b)
12857 /* Nothing to mention. These breakpoints are internal. */
12860 /* Virtual table for momentary breakpoints */
12863 momentary_bkpt_re_set (struct breakpoint *b)
12865 /* Keep temporary breakpoints, which can be encountered when we step
12866 over a dlopen call and solib_add is resetting the breakpoints.
12867 Otherwise these should have been blown away via the cleanup chain
12868 or by breakpoint_init_inferior when we rerun the executable. */
12872 momentary_bkpt_check_status (bpstat bs)
12874 /* Nothing. The point of these breakpoints is causing a stop. */
12877 static enum print_stop_action
12878 momentary_bkpt_print_it (bpstat bs)
12880 return PRINT_UNKNOWN;
12884 momentary_bkpt_print_mention (struct breakpoint *b)
12886 /* Nothing to mention. These breakpoints are internal. */
12889 /* Ensure INITIATING_FRAME is cleared when no such breakpoint exists.
12891 It gets cleared already on the removal of the first one of such placed
12892 breakpoints. This is OK as they get all removed altogether. */
12894 longjmp_breakpoint::~longjmp_breakpoint ()
12896 thread_info *tp = find_thread_global_id (this->thread);
12899 tp->initiating_frame = null_frame_id;
12902 /* Specific methods for probe breakpoints. */
12905 bkpt_probe_insert_location (struct bp_location *bl)
12907 int v = bkpt_insert_location (bl);
12911 /* The insertion was successful, now let's set the probe's semaphore
12913 if (bl->probe.probe->pops->set_semaphore != NULL)
12914 bl->probe.probe->pops->set_semaphore (bl->probe.probe,
12923 bkpt_probe_remove_location (struct bp_location *bl,
12924 enum remove_bp_reason reason)
12926 /* Let's clear the semaphore before removing the location. */
12927 if (bl->probe.probe->pops->clear_semaphore != NULL)
12928 bl->probe.probe->pops->clear_semaphore (bl->probe.probe,
12932 return bkpt_remove_location (bl, reason);
12936 bkpt_probe_create_sals_from_location (const struct event_location *location,
12937 struct linespec_result *canonical,
12938 enum bptype type_wanted)
12940 struct linespec_sals lsal;
12942 lsal.sals = parse_probes (location, NULL, canonical);
12944 = xstrdup (event_location_to_string (canonical->location.get ()));
12945 canonical->lsals.push_back (std::move (lsal));
12948 static std::vector<symtab_and_line>
12949 bkpt_probe_decode_location (struct breakpoint *b,
12950 const struct event_location *location,
12951 struct program_space *search_pspace)
12953 std::vector<symtab_and_line> sals = parse_probes (location, search_pspace, NULL);
12955 error (_("probe not found"));
12959 /* The breakpoint_ops structure to be used in tracepoints. */
12962 tracepoint_re_set (struct breakpoint *b)
12964 breakpoint_re_set_default (b);
12968 tracepoint_breakpoint_hit (const struct bp_location *bl,
12969 const address_space *aspace, CORE_ADDR bp_addr,
12970 const struct target_waitstatus *ws)
12972 /* By definition, the inferior does not report stops at
12978 tracepoint_print_one_detail (const struct breakpoint *self,
12979 struct ui_out *uiout)
12981 struct tracepoint *tp = (struct tracepoint *) self;
12982 if (tp->static_trace_marker_id)
12984 gdb_assert (self->type == bp_static_tracepoint);
12986 uiout->text ("\tmarker id is ");
12987 uiout->field_string ("static-tracepoint-marker-string-id",
12988 tp->static_trace_marker_id);
12989 uiout->text ("\n");
12994 tracepoint_print_mention (struct breakpoint *b)
12996 if (current_uiout->is_mi_like_p ())
13001 case bp_tracepoint:
13002 printf_filtered (_("Tracepoint"));
13003 printf_filtered (_(" %d"), b->number);
13005 case bp_fast_tracepoint:
13006 printf_filtered (_("Fast tracepoint"));
13007 printf_filtered (_(" %d"), b->number);
13009 case bp_static_tracepoint:
13010 printf_filtered (_("Static tracepoint"));
13011 printf_filtered (_(" %d"), b->number);
13014 internal_error (__FILE__, __LINE__,
13015 _("unhandled tracepoint type %d"), (int) b->type);
13022 tracepoint_print_recreate (struct breakpoint *self, struct ui_file *fp)
13024 struct tracepoint *tp = (struct tracepoint *) self;
13026 if (self->type == bp_fast_tracepoint)
13027 fprintf_unfiltered (fp, "ftrace");
13028 else if (self->type == bp_static_tracepoint)
13029 fprintf_unfiltered (fp, "strace");
13030 else if (self->type == bp_tracepoint)
13031 fprintf_unfiltered (fp, "trace");
13033 internal_error (__FILE__, __LINE__,
13034 _("unhandled tracepoint type %d"), (int) self->type);
13036 fprintf_unfiltered (fp, " %s",
13037 event_location_to_string (self->location.get ()));
13038 print_recreate_thread (self, fp);
13040 if (tp->pass_count)
13041 fprintf_unfiltered (fp, " passcount %d\n", tp->pass_count);
13045 tracepoint_create_sals_from_location (const struct event_location *location,
13046 struct linespec_result *canonical,
13047 enum bptype type_wanted)
13049 create_sals_from_location_default (location, canonical, type_wanted);
13053 tracepoint_create_breakpoints_sal (struct gdbarch *gdbarch,
13054 struct linespec_result *canonical,
13055 gdb::unique_xmalloc_ptr<char> cond_string,
13056 gdb::unique_xmalloc_ptr<char> extra_string,
13057 enum bptype type_wanted,
13058 enum bpdisp disposition,
13060 int task, int ignore_count,
13061 const struct breakpoint_ops *ops,
13062 int from_tty, int enabled,
13063 int internal, unsigned flags)
13065 create_breakpoints_sal_default (gdbarch, canonical,
13066 std::move (cond_string),
13067 std::move (extra_string),
13069 disposition, thread, task,
13070 ignore_count, ops, from_tty,
13071 enabled, internal, flags);
13074 static std::vector<symtab_and_line>
13075 tracepoint_decode_location (struct breakpoint *b,
13076 const struct event_location *location,
13077 struct program_space *search_pspace)
13079 return decode_location_default (b, location, search_pspace);
13082 struct breakpoint_ops tracepoint_breakpoint_ops;
13084 /* The breakpoint_ops structure to be use on tracepoints placed in a
13088 tracepoint_probe_create_sals_from_location
13089 (const struct event_location *location,
13090 struct linespec_result *canonical,
13091 enum bptype type_wanted)
13093 /* We use the same method for breakpoint on probes. */
13094 bkpt_probe_create_sals_from_location (location, canonical, type_wanted);
13097 static std::vector<symtab_and_line>
13098 tracepoint_probe_decode_location (struct breakpoint *b,
13099 const struct event_location *location,
13100 struct program_space *search_pspace)
13102 /* We use the same method for breakpoint on probes. */
13103 return bkpt_probe_decode_location (b, location, search_pspace);
13106 static struct breakpoint_ops tracepoint_probe_breakpoint_ops;
13108 /* Dprintf breakpoint_ops methods. */
13111 dprintf_re_set (struct breakpoint *b)
13113 breakpoint_re_set_default (b);
13115 /* extra_string should never be non-NULL for dprintf. */
13116 gdb_assert (b->extra_string != NULL);
13118 /* 1 - connect to target 1, that can run breakpoint commands.
13119 2 - create a dprintf, which resolves fine.
13120 3 - disconnect from target 1
13121 4 - connect to target 2, that can NOT run breakpoint commands.
13123 After steps #3/#4, you'll want the dprintf command list to
13124 be updated, because target 1 and 2 may well return different
13125 answers for target_can_run_breakpoint_commands().
13126 Given absence of finer grained resetting, we get to do
13127 it all the time. */
13128 if (b->extra_string != NULL)
13129 update_dprintf_command_list (b);
13132 /* Implement the "print_recreate" breakpoint_ops method for dprintf. */
13135 dprintf_print_recreate (struct breakpoint *tp, struct ui_file *fp)
13137 fprintf_unfiltered (fp, "dprintf %s,%s",
13138 event_location_to_string (tp->location.get ()),
13140 print_recreate_thread (tp, fp);
13143 /* Implement the "after_condition_true" breakpoint_ops method for
13146 dprintf's are implemented with regular commands in their command
13147 list, but we run the commands here instead of before presenting the
13148 stop to the user, as dprintf's don't actually cause a stop. This
13149 also makes it so that the commands of multiple dprintfs at the same
13150 address are all handled. */
13153 dprintf_after_condition_true (struct bpstats *bs)
13155 struct bpstats tmp_bs;
13156 struct bpstats *tmp_bs_p = &tmp_bs;
13158 /* dprintf's never cause a stop. This wasn't set in the
13159 check_status hook instead because that would make the dprintf's
13160 condition not be evaluated. */
13163 /* Run the command list here. Take ownership of it instead of
13164 copying. We never want these commands to run later in
13165 bpstat_do_actions, if a breakpoint that causes a stop happens to
13166 be set at same address as this dprintf, or even if running the
13167 commands here throws. */
13168 tmp_bs.commands = bs->commands;
13169 bs->commands = NULL;
13171 bpstat_do_actions_1 (&tmp_bs_p);
13173 /* 'tmp_bs.commands' will usually be NULL by now, but
13174 bpstat_do_actions_1 may return early without processing the whole
13178 /* The breakpoint_ops structure to be used on static tracepoints with
13182 strace_marker_create_sals_from_location (const struct event_location *location,
13183 struct linespec_result *canonical,
13184 enum bptype type_wanted)
13186 struct linespec_sals lsal;
13187 const char *arg_start, *arg;
13189 arg = arg_start = get_linespec_location (location);
13190 lsal.sals = decode_static_tracepoint_spec (&arg);
13192 std::string str (arg_start, arg - arg_start);
13193 const char *ptr = str.c_str ();
13194 canonical->location = new_linespec_location (&ptr);
13197 = xstrdup (event_location_to_string (canonical->location.get ()));
13198 canonical->lsals.push_back (std::move (lsal));
13202 strace_marker_create_breakpoints_sal (struct gdbarch *gdbarch,
13203 struct linespec_result *canonical,
13204 gdb::unique_xmalloc_ptr<char> cond_string,
13205 gdb::unique_xmalloc_ptr<char> extra_string,
13206 enum bptype type_wanted,
13207 enum bpdisp disposition,
13209 int task, int ignore_count,
13210 const struct breakpoint_ops *ops,
13211 int from_tty, int enabled,
13212 int internal, unsigned flags)
13214 const linespec_sals &lsal = canonical->lsals[0];
13216 /* If the user is creating a static tracepoint by marker id
13217 (strace -m MARKER_ID), then store the sals index, so that
13218 breakpoint_re_set can try to match up which of the newly
13219 found markers corresponds to this one, and, don't try to
13220 expand multiple locations for each sal, given than SALS
13221 already should contain all sals for MARKER_ID. */
13223 for (size_t i = 0; i < lsal.sals.size (); i++)
13225 event_location_up location
13226 = copy_event_location (canonical->location.get ());
13228 std::unique_ptr<tracepoint> tp (new tracepoint ());
13229 init_breakpoint_sal (tp.get (), gdbarch, lsal.sals[i],
13230 std::move (location), NULL,
13231 std::move (cond_string),
13232 std::move (extra_string),
13233 type_wanted, disposition,
13234 thread, task, ignore_count, ops,
13235 from_tty, enabled, internal, flags,
13236 canonical->special_display);
13237 /* Given that its possible to have multiple markers with
13238 the same string id, if the user is creating a static
13239 tracepoint by marker id ("strace -m MARKER_ID"), then
13240 store the sals index, so that breakpoint_re_set can
13241 try to match up which of the newly found markers
13242 corresponds to this one */
13243 tp->static_trace_marker_id_idx = i;
13245 install_breakpoint (internal, std::move (tp), 0);
13249 static std::vector<symtab_and_line>
13250 strace_marker_decode_location (struct breakpoint *b,
13251 const struct event_location *location,
13252 struct program_space *search_pspace)
13254 struct tracepoint *tp = (struct tracepoint *) b;
13255 const char *s = get_linespec_location (location);
13257 std::vector<symtab_and_line> sals = decode_static_tracepoint_spec (&s);
13258 if (sals.size () > tp->static_trace_marker_id_idx)
13260 sals[0] = sals[tp->static_trace_marker_id_idx];
13265 error (_("marker %s not found"), tp->static_trace_marker_id);
13268 static struct breakpoint_ops strace_marker_breakpoint_ops;
13271 strace_marker_p (struct breakpoint *b)
13273 return b->ops == &strace_marker_breakpoint_ops;
13276 /* Delete a breakpoint and clean up all traces of it in the data
13280 delete_breakpoint (struct breakpoint *bpt)
13282 struct breakpoint *b;
13284 gdb_assert (bpt != NULL);
13286 /* Has this bp already been deleted? This can happen because
13287 multiple lists can hold pointers to bp's. bpstat lists are
13290 One example of this happening is a watchpoint's scope bp. When
13291 the scope bp triggers, we notice that the watchpoint is out of
13292 scope, and delete it. We also delete its scope bp. But the
13293 scope bp is marked "auto-deleting", and is already on a bpstat.
13294 That bpstat is then checked for auto-deleting bp's, which are
13297 A real solution to this problem might involve reference counts in
13298 bp's, and/or giving them pointers back to their referencing
13299 bpstat's, and teaching delete_breakpoint to only free a bp's
13300 storage when no more references were extent. A cheaper bandaid
13302 if (bpt->type == bp_none)
13305 /* At least avoid this stale reference until the reference counting
13306 of breakpoints gets resolved. */
13307 if (bpt->related_breakpoint != bpt)
13309 struct breakpoint *related;
13310 struct watchpoint *w;
13312 if (bpt->type == bp_watchpoint_scope)
13313 w = (struct watchpoint *) bpt->related_breakpoint;
13314 else if (bpt->related_breakpoint->type == bp_watchpoint_scope)
13315 w = (struct watchpoint *) bpt;
13319 watchpoint_del_at_next_stop (w);
13321 /* Unlink bpt from the bpt->related_breakpoint ring. */
13322 for (related = bpt; related->related_breakpoint != bpt;
13323 related = related->related_breakpoint);
13324 related->related_breakpoint = bpt->related_breakpoint;
13325 bpt->related_breakpoint = bpt;
13328 /* watch_command_1 creates a watchpoint but only sets its number if
13329 update_watchpoint succeeds in creating its bp_locations. If there's
13330 a problem in that process, we'll be asked to delete the half-created
13331 watchpoint. In that case, don't announce the deletion. */
13333 observer_notify_breakpoint_deleted (bpt);
13335 if (breakpoint_chain == bpt)
13336 breakpoint_chain = bpt->next;
13338 ALL_BREAKPOINTS (b)
13339 if (b->next == bpt)
13341 b->next = bpt->next;
13345 /* Be sure no bpstat's are pointing at the breakpoint after it's
13347 /* FIXME, how can we find all bpstat's? We just check stop_bpstat
13348 in all threads for now. Note that we cannot just remove bpstats
13349 pointing at bpt from the stop_bpstat list entirely, as breakpoint
13350 commands are associated with the bpstat; if we remove it here,
13351 then the later call to bpstat_do_actions (&stop_bpstat); in
13352 event-top.c won't do anything, and temporary breakpoints with
13353 commands won't work. */
13355 iterate_over_threads (bpstat_remove_breakpoint_callback, bpt);
13357 /* Now that breakpoint is removed from breakpoint list, update the
13358 global location list. This will remove locations that used to
13359 belong to this breakpoint. Do this before freeing the breakpoint
13360 itself, since remove_breakpoint looks at location's owner. It
13361 might be better design to have location completely
13362 self-contained, but it's not the case now. */
13363 update_global_location_list (UGLL_DONT_INSERT);
13365 /* On the chance that someone will soon try again to delete this
13366 same bp, we mark it as deleted before freeing its storage. */
13367 bpt->type = bp_none;
13372 do_delete_breakpoint_cleanup (void *b)
13374 delete_breakpoint ((struct breakpoint *) b);
13378 make_cleanup_delete_breakpoint (struct breakpoint *b)
13380 return make_cleanup (do_delete_breakpoint_cleanup, b);
13383 /* Iterator function to call a user-provided callback function once
13384 for each of B and its related breakpoints. */
13387 iterate_over_related_breakpoints (struct breakpoint *b,
13388 gdb::function_view<void (breakpoint *)> function)
13390 struct breakpoint *related;
13395 struct breakpoint *next;
13397 /* FUNCTION may delete RELATED. */
13398 next = related->related_breakpoint;
13400 if (next == related)
13402 /* RELATED is the last ring entry. */
13403 function (related);
13405 /* FUNCTION may have deleted it, so we'd never reach back to
13406 B. There's nothing left to do anyway, so just break
13411 function (related);
13415 while (related != b);
13419 delete_command (const char *arg, int from_tty)
13421 struct breakpoint *b, *b_tmp;
13427 int breaks_to_delete = 0;
13429 /* Delete all breakpoints if no argument. Do not delete
13430 internal breakpoints, these have to be deleted with an
13431 explicit breakpoint number argument. */
13432 ALL_BREAKPOINTS (b)
13433 if (user_breakpoint_p (b))
13435 breaks_to_delete = 1;
13439 /* Ask user only if there are some breakpoints to delete. */
13441 || (breaks_to_delete && query (_("Delete all breakpoints? "))))
13443 ALL_BREAKPOINTS_SAFE (b, b_tmp)
13444 if (user_breakpoint_p (b))
13445 delete_breakpoint (b);
13449 map_breakpoint_numbers
13450 (arg, [&] (breakpoint *b)
13452 iterate_over_related_breakpoints (b, delete_breakpoint);
13456 /* Return true if all locations of B bound to PSPACE are pending. If
13457 PSPACE is NULL, all locations of all program spaces are
13461 all_locations_are_pending (struct breakpoint *b, struct program_space *pspace)
13463 struct bp_location *loc;
13465 for (loc = b->loc; loc != NULL; loc = loc->next)
13466 if ((pspace == NULL
13467 || loc->pspace == pspace)
13468 && !loc->shlib_disabled
13469 && !loc->pspace->executing_startup)
13474 /* Subroutine of update_breakpoint_locations to simplify it.
13475 Return non-zero if multiple fns in list LOC have the same name.
13476 Null names are ignored. */
13479 ambiguous_names_p (struct bp_location *loc)
13481 struct bp_location *l;
13482 htab_t htab = htab_create_alloc (13, htab_hash_string,
13483 (int (*) (const void *,
13484 const void *)) streq,
13485 NULL, xcalloc, xfree);
13487 for (l = loc; l != NULL; l = l->next)
13490 const char *name = l->function_name;
13492 /* Allow for some names to be NULL, ignore them. */
13496 slot = (const char **) htab_find_slot (htab, (const void *) name,
13498 /* NOTE: We can assume slot != NULL here because xcalloc never
13502 htab_delete (htab);
13508 htab_delete (htab);
13512 /* When symbols change, it probably means the sources changed as well,
13513 and it might mean the static tracepoint markers are no longer at
13514 the same address or line numbers they used to be at last we
13515 checked. Losing your static tracepoints whenever you rebuild is
13516 undesirable. This function tries to resync/rematch gdb static
13517 tracepoints with the markers on the target, for static tracepoints
13518 that have not been set by marker id. Static tracepoint that have
13519 been set by marker id are reset by marker id in breakpoint_re_set.
13522 1) For a tracepoint set at a specific address, look for a marker at
13523 the old PC. If one is found there, assume to be the same marker.
13524 If the name / string id of the marker found is different from the
13525 previous known name, assume that means the user renamed the marker
13526 in the sources, and output a warning.
13528 2) For a tracepoint set at a given line number, look for a marker
13529 at the new address of the old line number. If one is found there,
13530 assume to be the same marker. If the name / string id of the
13531 marker found is different from the previous known name, assume that
13532 means the user renamed the marker in the sources, and output a
13535 3) If a marker is no longer found at the same address or line, it
13536 may mean the marker no longer exists. But it may also just mean
13537 the code changed a bit. Maybe the user added a few lines of code
13538 that made the marker move up or down (in line number terms). Ask
13539 the target for info about the marker with the string id as we knew
13540 it. If found, update line number and address in the matching
13541 static tracepoint. This will get confused if there's more than one
13542 marker with the same ID (possible in UST, although unadvised
13543 precisely because it confuses tools). */
13545 static struct symtab_and_line
13546 update_static_tracepoint (struct breakpoint *b, struct symtab_and_line sal)
13548 struct tracepoint *tp = (struct tracepoint *) b;
13549 struct static_tracepoint_marker marker;
13554 find_line_pc (sal.symtab, sal.line, &pc);
13556 if (target_static_tracepoint_marker_at (pc, &marker))
13558 if (strcmp (tp->static_trace_marker_id, marker.str_id) != 0)
13559 warning (_("static tracepoint %d changed probed marker from %s to %s"),
13561 tp->static_trace_marker_id, marker.str_id);
13563 xfree (tp->static_trace_marker_id);
13564 tp->static_trace_marker_id = xstrdup (marker.str_id);
13565 release_static_tracepoint_marker (&marker);
13570 /* Old marker wasn't found on target at lineno. Try looking it up
13572 if (!sal.explicit_pc
13574 && sal.symtab != NULL
13575 && tp->static_trace_marker_id != NULL)
13577 VEC(static_tracepoint_marker_p) *markers;
13580 = target_static_tracepoint_markers_by_strid (tp->static_trace_marker_id);
13582 if (!VEC_empty(static_tracepoint_marker_p, markers))
13584 struct symbol *sym;
13585 struct static_tracepoint_marker *tpmarker;
13586 struct ui_out *uiout = current_uiout;
13587 struct explicit_location explicit_loc;
13589 tpmarker = VEC_index (static_tracepoint_marker_p, markers, 0);
13591 xfree (tp->static_trace_marker_id);
13592 tp->static_trace_marker_id = xstrdup (tpmarker->str_id);
13594 warning (_("marker for static tracepoint %d (%s) not "
13595 "found at previous line number"),
13596 b->number, tp->static_trace_marker_id);
13598 symtab_and_line sal2 = find_pc_line (tpmarker->address, 0);
13599 sym = find_pc_sect_function (tpmarker->address, NULL);
13600 uiout->text ("Now in ");
13603 uiout->field_string ("func", SYMBOL_PRINT_NAME (sym));
13604 uiout->text (" at ");
13606 uiout->field_string ("file",
13607 symtab_to_filename_for_display (sal2.symtab));
13610 if (uiout->is_mi_like_p ())
13612 const char *fullname = symtab_to_fullname (sal2.symtab);
13614 uiout->field_string ("fullname", fullname);
13617 uiout->field_int ("line", sal2.line);
13618 uiout->text ("\n");
13620 b->loc->line_number = sal2.line;
13621 b->loc->symtab = sym != NULL ? sal2.symtab : NULL;
13623 b->location.reset (NULL);
13624 initialize_explicit_location (&explicit_loc);
13625 explicit_loc.source_filename
13626 = ASTRDUP (symtab_to_filename_for_display (sal2.symtab));
13627 explicit_loc.line_offset.offset = b->loc->line_number;
13628 explicit_loc.line_offset.sign = LINE_OFFSET_NONE;
13629 b->location = new_explicit_location (&explicit_loc);
13631 /* Might be nice to check if function changed, and warn if
13634 release_static_tracepoint_marker (tpmarker);
13640 /* Returns 1 iff locations A and B are sufficiently same that
13641 we don't need to report breakpoint as changed. */
13644 locations_are_equal (struct bp_location *a, struct bp_location *b)
13648 if (a->address != b->address)
13651 if (a->shlib_disabled != b->shlib_disabled)
13654 if (a->enabled != b->enabled)
13661 if ((a == NULL) != (b == NULL))
13667 /* Split all locations of B that are bound to PSPACE out of B's
13668 location list to a separate list and return that list's head. If
13669 PSPACE is NULL, hoist out all locations of B. */
13671 static struct bp_location *
13672 hoist_existing_locations (struct breakpoint *b, struct program_space *pspace)
13674 struct bp_location head;
13675 struct bp_location *i = b->loc;
13676 struct bp_location **i_link = &b->loc;
13677 struct bp_location *hoisted = &head;
13679 if (pspace == NULL)
13690 if (i->pspace == pspace)
13705 /* Create new breakpoint locations for B (a hardware or software
13706 breakpoint) based on SALS and SALS_END. If SALS_END.NELTS is not
13707 zero, then B is a ranged breakpoint. Only recreates locations for
13708 FILTER_PSPACE. Locations of other program spaces are left
13712 update_breakpoint_locations (struct breakpoint *b,
13713 struct program_space *filter_pspace,
13714 gdb::array_view<const symtab_and_line> sals,
13715 gdb::array_view<const symtab_and_line> sals_end)
13718 struct bp_location *existing_locations;
13720 if (!sals_end.empty () && (sals.size () != 1 || sals_end.size () != 1))
13722 /* Ranged breakpoints have only one start location and one end
13724 b->enable_state = bp_disabled;
13725 printf_unfiltered (_("Could not reset ranged breakpoint %d: "
13726 "multiple locations found\n"),
13731 /* If there's no new locations, and all existing locations are
13732 pending, don't do anything. This optimizes the common case where
13733 all locations are in the same shared library, that was unloaded.
13734 We'd like to retain the location, so that when the library is
13735 loaded again, we don't loose the enabled/disabled status of the
13736 individual locations. */
13737 if (all_locations_are_pending (b, filter_pspace) && sals.empty ())
13740 existing_locations = hoist_existing_locations (b, filter_pspace);
13742 for (const auto &sal : sals)
13744 struct bp_location *new_loc;
13746 switch_to_program_space_and_thread (sal.pspace);
13748 new_loc = add_location_to_breakpoint (b, &sal);
13750 /* Reparse conditions, they might contain references to the
13752 if (b->cond_string != NULL)
13756 s = b->cond_string;
13759 new_loc->cond = parse_exp_1 (&s, sal.pc,
13760 block_for_pc (sal.pc),
13763 CATCH (e, RETURN_MASK_ERROR)
13765 warning (_("failed to reevaluate condition "
13766 "for breakpoint %d: %s"),
13767 b->number, e.message);
13768 new_loc->enabled = 0;
13773 if (!sals_end.empty ())
13775 CORE_ADDR end = find_breakpoint_range_end (sals_end[0]);
13777 new_loc->length = end - sals[0].pc + 1;
13781 /* If possible, carry over 'disable' status from existing
13784 struct bp_location *e = existing_locations;
13785 /* If there are multiple breakpoints with the same function name,
13786 e.g. for inline functions, comparing function names won't work.
13787 Instead compare pc addresses; this is just a heuristic as things
13788 may have moved, but in practice it gives the correct answer
13789 often enough until a better solution is found. */
13790 int have_ambiguous_names = ambiguous_names_p (b->loc);
13792 for (; e; e = e->next)
13794 if (!e->enabled && e->function_name)
13796 struct bp_location *l = b->loc;
13797 if (have_ambiguous_names)
13799 for (; l; l = l->next)
13800 if (breakpoint_locations_match (e, l))
13808 for (; l; l = l->next)
13809 if (l->function_name
13810 && strcmp (e->function_name, l->function_name) == 0)
13820 if (!locations_are_equal (existing_locations, b->loc))
13821 observer_notify_breakpoint_modified (b);
13824 /* Find the SaL locations corresponding to the given LOCATION.
13825 On return, FOUND will be 1 if any SaL was found, zero otherwise. */
13827 static std::vector<symtab_and_line>
13828 location_to_sals (struct breakpoint *b, struct event_location *location,
13829 struct program_space *search_pspace, int *found)
13831 struct gdb_exception exception = exception_none;
13833 gdb_assert (b->ops != NULL);
13835 std::vector<symtab_and_line> sals;
13839 sals = b->ops->decode_location (b, location, search_pspace);
13841 CATCH (e, RETURN_MASK_ERROR)
13843 int not_found_and_ok = 0;
13847 /* For pending breakpoints, it's expected that parsing will
13848 fail until the right shared library is loaded. User has
13849 already told to create pending breakpoints and don't need
13850 extra messages. If breakpoint is in bp_shlib_disabled
13851 state, then user already saw the message about that
13852 breakpoint being disabled, and don't want to see more
13854 if (e.error == NOT_FOUND_ERROR
13855 && (b->condition_not_parsed
13857 && search_pspace != NULL
13858 && b->loc->pspace != search_pspace)
13859 || (b->loc && b->loc->shlib_disabled)
13860 || (b->loc && b->loc->pspace->executing_startup)
13861 || b->enable_state == bp_disabled))
13862 not_found_and_ok = 1;
13864 if (!not_found_and_ok)
13866 /* We surely don't want to warn about the same breakpoint
13867 10 times. One solution, implemented here, is disable
13868 the breakpoint on error. Another solution would be to
13869 have separate 'warning emitted' flag. Since this
13870 happens only when a binary has changed, I don't know
13871 which approach is better. */
13872 b->enable_state = bp_disabled;
13873 throw_exception (e);
13878 if (exception.reason == 0 || exception.error != NOT_FOUND_ERROR)
13880 for (auto &sal : sals)
13881 resolve_sal_pc (&sal);
13882 if (b->condition_not_parsed && b->extra_string != NULL)
13884 char *cond_string, *extra_string;
13887 find_condition_and_thread (b->extra_string, sals[0].pc,
13888 &cond_string, &thread, &task,
13890 gdb_assert (b->cond_string == NULL);
13892 b->cond_string = cond_string;
13893 b->thread = thread;
13897 xfree (b->extra_string);
13898 b->extra_string = extra_string;
13900 b->condition_not_parsed = 0;
13903 if (b->type == bp_static_tracepoint && !strace_marker_p (b))
13904 sals[0] = update_static_tracepoint (b, sals[0]);
13914 /* The default re_set method, for typical hardware or software
13915 breakpoints. Reevaluate the breakpoint and recreate its
13919 breakpoint_re_set_default (struct breakpoint *b)
13921 struct program_space *filter_pspace = current_program_space;
13922 std::vector<symtab_and_line> expanded, expanded_end;
13925 std::vector<symtab_and_line> sals = location_to_sals (b, b->location.get (),
13926 filter_pspace, &found);
13928 expanded = std::move (sals);
13930 if (b->location_range_end != NULL)
13932 std::vector<symtab_and_line> sals_end
13933 = location_to_sals (b, b->location_range_end.get (),
13934 filter_pspace, &found);
13936 expanded_end = std::move (sals_end);
13939 update_breakpoint_locations (b, filter_pspace, expanded, expanded_end);
13942 /* Default method for creating SALs from an address string. It basically
13943 calls parse_breakpoint_sals. Return 1 for success, zero for failure. */
13946 create_sals_from_location_default (const struct event_location *location,
13947 struct linespec_result *canonical,
13948 enum bptype type_wanted)
13950 parse_breakpoint_sals (location, canonical);
13953 /* Call create_breakpoints_sal for the given arguments. This is the default
13954 function for the `create_breakpoints_sal' method of
13958 create_breakpoints_sal_default (struct gdbarch *gdbarch,
13959 struct linespec_result *canonical,
13960 gdb::unique_xmalloc_ptr<char> cond_string,
13961 gdb::unique_xmalloc_ptr<char> extra_string,
13962 enum bptype type_wanted,
13963 enum bpdisp disposition,
13965 int task, int ignore_count,
13966 const struct breakpoint_ops *ops,
13967 int from_tty, int enabled,
13968 int internal, unsigned flags)
13970 create_breakpoints_sal (gdbarch, canonical,
13971 std::move (cond_string),
13972 std::move (extra_string),
13973 type_wanted, disposition,
13974 thread, task, ignore_count, ops, from_tty,
13975 enabled, internal, flags);
13978 /* Decode the line represented by S by calling decode_line_full. This is the
13979 default function for the `decode_location' method of breakpoint_ops. */
13981 static std::vector<symtab_and_line>
13982 decode_location_default (struct breakpoint *b,
13983 const struct event_location *location,
13984 struct program_space *search_pspace)
13986 struct linespec_result canonical;
13988 decode_line_full (location, DECODE_LINE_FUNFIRSTLINE, search_pspace,
13989 (struct symtab *) NULL, 0,
13990 &canonical, multiple_symbols_all,
13993 /* We should get 0 or 1 resulting SALs. */
13994 gdb_assert (canonical.lsals.size () < 2);
13996 if (!canonical.lsals.empty ())
13998 const linespec_sals &lsal = canonical.lsals[0];
13999 return std::move (lsal.sals);
14004 /* Reset a breakpoint. */
14007 breakpoint_re_set_one (breakpoint *b)
14009 input_radix = b->input_radix;
14010 set_language (b->language);
14012 b->ops->re_set (b);
14015 /* Re-set breakpoint locations for the current program space.
14016 Locations bound to other program spaces are left untouched. */
14019 breakpoint_re_set (void)
14021 struct breakpoint *b, *b_tmp;
14024 scoped_restore_current_language save_language;
14025 scoped_restore save_input_radix = make_scoped_restore (&input_radix);
14026 scoped_restore_current_pspace_and_thread restore_pspace_thread;
14028 /* Note: we must not try to insert locations until after all
14029 breakpoints have been re-set. Otherwise, e.g., when re-setting
14030 breakpoint 1, we'd insert the locations of breakpoint 2, which
14031 hadn't been re-set yet, and thus may have stale locations. */
14033 ALL_BREAKPOINTS_SAFE (b, b_tmp)
14037 breakpoint_re_set_one (b);
14039 CATCH (ex, RETURN_MASK_ALL)
14041 exception_fprintf (gdb_stderr, ex,
14042 "Error in re-setting breakpoint %d: ",
14048 jit_breakpoint_re_set ();
14051 create_overlay_event_breakpoint ();
14052 create_longjmp_master_breakpoint ();
14053 create_std_terminate_master_breakpoint ();
14054 create_exception_master_breakpoint ();
14056 /* Now we can insert. */
14057 update_global_location_list (UGLL_MAY_INSERT);
14060 /* Reset the thread number of this breakpoint:
14062 - If the breakpoint is for all threads, leave it as-is.
14063 - Else, reset it to the current thread for inferior_ptid. */
14065 breakpoint_re_set_thread (struct breakpoint *b)
14067 if (b->thread != -1)
14069 if (in_thread_list (inferior_ptid))
14070 b->thread = ptid_to_global_thread_id (inferior_ptid);
14072 /* We're being called after following a fork. The new fork is
14073 selected as current, and unless this was a vfork will have a
14074 different program space from the original thread. Reset that
14076 b->loc->pspace = current_program_space;
14080 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14081 If from_tty is nonzero, it prints a message to that effect,
14082 which ends with a period (no newline). */
14085 set_ignore_count (int bptnum, int count, int from_tty)
14087 struct breakpoint *b;
14092 ALL_BREAKPOINTS (b)
14093 if (b->number == bptnum)
14095 if (is_tracepoint (b))
14097 if (from_tty && count != 0)
14098 printf_filtered (_("Ignore count ignored for tracepoint %d."),
14103 b->ignore_count = count;
14107 printf_filtered (_("Will stop next time "
14108 "breakpoint %d is reached."),
14110 else if (count == 1)
14111 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
14114 printf_filtered (_("Will ignore next %d "
14115 "crossings of breakpoint %d."),
14118 observer_notify_breakpoint_modified (b);
14122 error (_("No breakpoint number %d."), bptnum);
14125 /* Command to set ignore-count of breakpoint N to COUNT. */
14128 ignore_command (char *args, int from_tty)
14134 error_no_arg (_("a breakpoint number"));
14136 num = get_number (&p);
14138 error (_("bad breakpoint number: '%s'"), args);
14140 error (_("Second argument (specified ignore-count) is missing."));
14142 set_ignore_count (num,
14143 longest_to_int (value_as_long (parse_and_eval (p))),
14146 printf_filtered ("\n");
14149 /* Call FUNCTION on each of the breakpoints
14150 whose numbers are given in ARGS. */
14153 map_breakpoint_numbers (const char *args,
14154 gdb::function_view<void (breakpoint *)> function)
14157 struct breakpoint *b, *tmp;
14159 if (args == 0 || *args == '\0')
14160 error_no_arg (_("one or more breakpoint numbers"));
14162 number_or_range_parser parser (args);
14164 while (!parser.finished ())
14166 const char *p = parser.cur_tok ();
14167 bool match = false;
14169 num = parser.get_number ();
14172 warning (_("bad breakpoint number at or near '%s'"), p);
14176 ALL_BREAKPOINTS_SAFE (b, tmp)
14177 if (b->number == num)
14184 printf_unfiltered (_("No breakpoint number %d.\n"), num);
14189 static struct bp_location *
14190 find_location_by_number (const char *number)
14195 struct breakpoint *b;
14196 struct bp_location *loc;
14199 bp_num = get_number_trailer (&p1, '.');
14200 if (bp_num == 0 || p1[0] != '.')
14201 error (_("Bad breakpoint number '%s'"), number);
14203 ALL_BREAKPOINTS (b)
14204 if (b->number == bp_num)
14209 if (!b || b->number != bp_num)
14210 error (_("Bad breakpoint number '%s'"), number);
14212 /* Skip the dot. */
14214 const char *save = p1;
14215 loc_num = get_number (&p1);
14217 error (_("Bad breakpoint location number '%s'"), number);
14221 for (;loc_num && loc; --loc_num, loc = loc->next)
14224 error (_("Bad breakpoint location number '%s'"), save);
14230 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14231 If from_tty is nonzero, it prints a message to that effect,
14232 which ends with a period (no newline). */
14235 disable_breakpoint (struct breakpoint *bpt)
14237 /* Never disable a watchpoint scope breakpoint; we want to
14238 hit them when we leave scope so we can delete both the
14239 watchpoint and its scope breakpoint at that time. */
14240 if (bpt->type == bp_watchpoint_scope)
14243 bpt->enable_state = bp_disabled;
14245 /* Mark breakpoint locations modified. */
14246 mark_breakpoint_modified (bpt);
14248 if (target_supports_enable_disable_tracepoint ()
14249 && current_trace_status ()->running && is_tracepoint (bpt))
14251 struct bp_location *location;
14253 for (location = bpt->loc; location; location = location->next)
14254 target_disable_tracepoint (location);
14257 update_global_location_list (UGLL_DONT_INSERT);
14259 observer_notify_breakpoint_modified (bpt);
14263 disable_command (const char *args, int from_tty)
14267 struct breakpoint *bpt;
14269 ALL_BREAKPOINTS (bpt)
14270 if (user_breakpoint_p (bpt))
14271 disable_breakpoint (bpt);
14275 std::string num = extract_arg (&args);
14277 while (!num.empty ())
14279 if (num.find ('.') != std::string::npos)
14281 struct bp_location *loc = find_location_by_number (num.c_str ());
14288 mark_breakpoint_location_modified (loc);
14290 if (target_supports_enable_disable_tracepoint ()
14291 && current_trace_status ()->running && loc->owner
14292 && is_tracepoint (loc->owner))
14293 target_disable_tracepoint (loc);
14295 update_global_location_list (UGLL_DONT_INSERT);
14298 map_breakpoint_numbers
14299 (num.c_str (), [&] (breakpoint *b)
14301 iterate_over_related_breakpoints (b, disable_breakpoint);
14303 num = extract_arg (&args);
14309 enable_breakpoint_disp (struct breakpoint *bpt, enum bpdisp disposition,
14312 int target_resources_ok;
14314 if (bpt->type == bp_hardware_breakpoint)
14317 i = hw_breakpoint_used_count ();
14318 target_resources_ok =
14319 target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
14321 if (target_resources_ok == 0)
14322 error (_("No hardware breakpoint support in the target."));
14323 else if (target_resources_ok < 0)
14324 error (_("Hardware breakpoints used exceeds limit."));
14327 if (is_watchpoint (bpt))
14329 /* Initialize it just to avoid a GCC false warning. */
14330 enum enable_state orig_enable_state = bp_disabled;
14334 struct watchpoint *w = (struct watchpoint *) bpt;
14336 orig_enable_state = bpt->enable_state;
14337 bpt->enable_state = bp_enabled;
14338 update_watchpoint (w, 1 /* reparse */);
14340 CATCH (e, RETURN_MASK_ALL)
14342 bpt->enable_state = orig_enable_state;
14343 exception_fprintf (gdb_stderr, e, _("Cannot enable watchpoint %d: "),
14350 bpt->enable_state = bp_enabled;
14352 /* Mark breakpoint locations modified. */
14353 mark_breakpoint_modified (bpt);
14355 if (target_supports_enable_disable_tracepoint ()
14356 && current_trace_status ()->running && is_tracepoint (bpt))
14358 struct bp_location *location;
14360 for (location = bpt->loc; location; location = location->next)
14361 target_enable_tracepoint (location);
14364 bpt->disposition = disposition;
14365 bpt->enable_count = count;
14366 update_global_location_list (UGLL_MAY_INSERT);
14368 observer_notify_breakpoint_modified (bpt);
14373 enable_breakpoint (struct breakpoint *bpt)
14375 enable_breakpoint_disp (bpt, bpt->disposition, 0);
14378 /* The enable command enables the specified breakpoints (or all defined
14379 breakpoints) so they once again become (or continue to be) effective
14380 in stopping the inferior. */
14383 enable_command (const char *args, int from_tty)
14387 struct breakpoint *bpt;
14389 ALL_BREAKPOINTS (bpt)
14390 if (user_breakpoint_p (bpt))
14391 enable_breakpoint (bpt);
14395 std::string num = extract_arg (&args);
14397 while (!num.empty ())
14399 if (num.find ('.') != std::string::npos)
14401 struct bp_location *loc = find_location_by_number (num.c_str ());
14408 mark_breakpoint_location_modified (loc);
14410 if (target_supports_enable_disable_tracepoint ()
14411 && current_trace_status ()->running && loc->owner
14412 && is_tracepoint (loc->owner))
14413 target_enable_tracepoint (loc);
14415 update_global_location_list (UGLL_MAY_INSERT);
14418 map_breakpoint_numbers
14419 (num.c_str (), [&] (breakpoint *b)
14421 iterate_over_related_breakpoints (b, enable_breakpoint);
14423 num = extract_arg (&args);
14429 enable_once_command (const char *args, int from_tty)
14431 map_breakpoint_numbers
14432 (args, [&] (breakpoint *b)
14434 iterate_over_related_breakpoints
14435 (b, [&] (breakpoint *bpt)
14437 enable_breakpoint_disp (bpt, disp_disable, 1);
14443 enable_count_command (const char *args, int from_tty)
14448 error_no_arg (_("hit count"));
14450 count = get_number (&args);
14452 map_breakpoint_numbers
14453 (args, [&] (breakpoint *b)
14455 iterate_over_related_breakpoints
14456 (b, [&] (breakpoint *bpt)
14458 enable_breakpoint_disp (bpt, disp_disable, count);
14464 enable_delete_command (const char *args, int from_tty)
14466 map_breakpoint_numbers
14467 (args, [&] (breakpoint *b)
14469 iterate_over_related_breakpoints
14470 (b, [&] (breakpoint *bpt)
14472 enable_breakpoint_disp (bpt, disp_del, 1);
14478 set_breakpoint_cmd (const char *args, int from_tty)
14483 show_breakpoint_cmd (const char *args, int from_tty)
14487 /* Invalidate last known value of any hardware watchpoint if
14488 the memory which that value represents has been written to by
14492 invalidate_bp_value_on_memory_change (struct inferior *inferior,
14493 CORE_ADDR addr, ssize_t len,
14494 const bfd_byte *data)
14496 struct breakpoint *bp;
14498 ALL_BREAKPOINTS (bp)
14499 if (bp->enable_state == bp_enabled
14500 && bp->type == bp_hardware_watchpoint)
14502 struct watchpoint *wp = (struct watchpoint *) bp;
14504 if (wp->val_valid && wp->val)
14506 struct bp_location *loc;
14508 for (loc = bp->loc; loc != NULL; loc = loc->next)
14509 if (loc->loc_type == bp_loc_hardware_watchpoint
14510 && loc->address + loc->length > addr
14511 && addr + len > loc->address)
14513 value_free (wp->val);
14521 /* Create and insert a breakpoint for software single step. */
14524 insert_single_step_breakpoint (struct gdbarch *gdbarch,
14525 const address_space *aspace,
14528 struct thread_info *tp = inferior_thread ();
14529 struct symtab_and_line sal;
14530 CORE_ADDR pc = next_pc;
14532 if (tp->control.single_step_breakpoints == NULL)
14534 tp->control.single_step_breakpoints
14535 = new_single_step_breakpoint (tp->global_num, gdbarch);
14538 sal = find_pc_line (pc, 0);
14540 sal.section = find_pc_overlay (pc);
14541 sal.explicit_pc = 1;
14542 add_location_to_breakpoint (tp->control.single_step_breakpoints, &sal);
14544 update_global_location_list (UGLL_INSERT);
14547 /* Insert single step breakpoints according to the current state. */
14550 insert_single_step_breakpoints (struct gdbarch *gdbarch)
14552 struct regcache *regcache = get_current_regcache ();
14553 std::vector<CORE_ADDR> next_pcs;
14555 next_pcs = gdbarch_software_single_step (gdbarch, regcache);
14557 if (!next_pcs.empty ())
14559 struct frame_info *frame = get_current_frame ();
14560 struct address_space *aspace = get_frame_address_space (frame);
14562 for (CORE_ADDR pc : next_pcs)
14563 insert_single_step_breakpoint (gdbarch, aspace, pc);
14571 /* See breakpoint.h. */
14574 breakpoint_has_location_inserted_here (struct breakpoint *bp,
14575 const address_space *aspace,
14578 struct bp_location *loc;
14580 for (loc = bp->loc; loc != NULL; loc = loc->next)
14582 && breakpoint_location_address_match (loc, aspace, pc))
14588 /* Check whether a software single-step breakpoint is inserted at
14592 single_step_breakpoint_inserted_here_p (const address_space *aspace,
14595 struct breakpoint *bpt;
14597 ALL_BREAKPOINTS (bpt)
14599 if (bpt->type == bp_single_step
14600 && breakpoint_has_location_inserted_here (bpt, aspace, pc))
14606 /* Tracepoint-specific operations. */
14608 /* Set tracepoint count to NUM. */
14610 set_tracepoint_count (int num)
14612 tracepoint_count = num;
14613 set_internalvar_integer (lookup_internalvar ("tpnum"), num);
14617 trace_command (char *arg_in, int from_tty)
14619 const char *arg = arg_in;
14620 struct breakpoint_ops *ops;
14622 event_location_up location = string_to_event_location (&arg,
14624 if (location != NULL
14625 && event_location_type (location.get ()) == PROBE_LOCATION)
14626 ops = &tracepoint_probe_breakpoint_ops;
14628 ops = &tracepoint_breakpoint_ops;
14630 create_breakpoint (get_current_arch (),
14632 NULL, 0, arg, 1 /* parse arg */,
14634 bp_tracepoint /* type_wanted */,
14635 0 /* Ignore count */,
14636 pending_break_support,
14640 0 /* internal */, 0);
14644 ftrace_command (char *arg_in, int from_tty)
14646 const char *arg = arg_in;
14647 event_location_up location = string_to_event_location (&arg,
14649 create_breakpoint (get_current_arch (),
14651 NULL, 0, arg, 1 /* parse arg */,
14653 bp_fast_tracepoint /* type_wanted */,
14654 0 /* Ignore count */,
14655 pending_break_support,
14656 &tracepoint_breakpoint_ops,
14659 0 /* internal */, 0);
14662 /* strace command implementation. Creates a static tracepoint. */
14665 strace_command (char *arg_in, int from_tty)
14667 const char *arg = arg_in;
14668 struct breakpoint_ops *ops;
14669 event_location_up location;
14671 /* Decide if we are dealing with a static tracepoint marker (`-m'),
14672 or with a normal static tracepoint. */
14673 if (arg && startswith (arg, "-m") && isspace (arg[2]))
14675 ops = &strace_marker_breakpoint_ops;
14676 location = new_linespec_location (&arg);
14680 ops = &tracepoint_breakpoint_ops;
14681 location = string_to_event_location (&arg, current_language);
14684 create_breakpoint (get_current_arch (),
14686 NULL, 0, arg, 1 /* parse arg */,
14688 bp_static_tracepoint /* type_wanted */,
14689 0 /* Ignore count */,
14690 pending_break_support,
14694 0 /* internal */, 0);
14697 /* Set up a fake reader function that gets command lines from a linked
14698 list that was acquired during tracepoint uploading. */
14700 static struct uploaded_tp *this_utp;
14701 static int next_cmd;
14704 read_uploaded_action (void)
14708 VEC_iterate (char_ptr, this_utp->cmd_strings, next_cmd, rslt);
14715 /* Given information about a tracepoint as recorded on a target (which
14716 can be either a live system or a trace file), attempt to create an
14717 equivalent GDB tracepoint. This is not a reliable process, since
14718 the target does not necessarily have all the information used when
14719 the tracepoint was originally defined. */
14721 struct tracepoint *
14722 create_tracepoint_from_upload (struct uploaded_tp *utp)
14724 const char *addr_str;
14725 char small_buf[100];
14726 struct tracepoint *tp;
14728 if (utp->at_string)
14729 addr_str = utp->at_string;
14732 /* In the absence of a source location, fall back to raw
14733 address. Since there is no way to confirm that the address
14734 means the same thing as when the trace was started, warn the
14736 warning (_("Uploaded tracepoint %d has no "
14737 "source location, using raw address"),
14739 xsnprintf (small_buf, sizeof (small_buf), "*%s", hex_string (utp->addr));
14740 addr_str = small_buf;
14743 /* There's not much we can do with a sequence of bytecodes. */
14744 if (utp->cond && !utp->cond_string)
14745 warning (_("Uploaded tracepoint %d condition "
14746 "has no source form, ignoring it"),
14749 event_location_up location = string_to_event_location (&addr_str,
14751 if (!create_breakpoint (get_current_arch (),
14753 utp->cond_string, -1, addr_str,
14754 0 /* parse cond/thread */,
14756 utp->type /* type_wanted */,
14757 0 /* Ignore count */,
14758 pending_break_support,
14759 &tracepoint_breakpoint_ops,
14761 utp->enabled /* enabled */,
14763 CREATE_BREAKPOINT_FLAGS_INSERTED))
14766 /* Get the tracepoint we just created. */
14767 tp = get_tracepoint (tracepoint_count);
14768 gdb_assert (tp != NULL);
14772 xsnprintf (small_buf, sizeof (small_buf), "%d %d", utp->pass,
14775 trace_pass_command (small_buf, 0);
14778 /* If we have uploaded versions of the original commands, set up a
14779 special-purpose "reader" function and call the usual command line
14780 reader, then pass the result to the breakpoint command-setting
14782 if (!VEC_empty (char_ptr, utp->cmd_strings))
14784 command_line_up cmd_list;
14789 cmd_list = read_command_lines_1 (read_uploaded_action, 1, NULL, NULL);
14791 breakpoint_set_commands (tp, std::move (cmd_list));
14793 else if (!VEC_empty (char_ptr, utp->actions)
14794 || !VEC_empty (char_ptr, utp->step_actions))
14795 warning (_("Uploaded tracepoint %d actions "
14796 "have no source form, ignoring them"),
14799 /* Copy any status information that might be available. */
14800 tp->hit_count = utp->hit_count;
14801 tp->traceframe_usage = utp->traceframe_usage;
14806 /* Print information on tracepoint number TPNUM_EXP, or all if
14810 info_tracepoints_command (char *args, int from_tty)
14812 struct ui_out *uiout = current_uiout;
14815 num_printed = breakpoint_1 (args, 0, is_tracepoint);
14817 if (num_printed == 0)
14819 if (args == NULL || *args == '\0')
14820 uiout->message ("No tracepoints.\n");
14822 uiout->message ("No tracepoint matching '%s'.\n", args);
14825 default_collect_info ();
14828 /* The 'enable trace' command enables tracepoints.
14829 Not supported by all targets. */
14831 enable_trace_command (char *args, int from_tty)
14833 enable_command (args, from_tty);
14836 /* The 'disable trace' command disables tracepoints.
14837 Not supported by all targets. */
14839 disable_trace_command (char *args, int from_tty)
14841 disable_command (args, from_tty);
14844 /* Remove a tracepoint (or all if no argument). */
14846 delete_trace_command (const char *arg, int from_tty)
14848 struct breakpoint *b, *b_tmp;
14854 int breaks_to_delete = 0;
14856 /* Delete all breakpoints if no argument.
14857 Do not delete internal or call-dummy breakpoints, these
14858 have to be deleted with an explicit breakpoint number
14860 ALL_TRACEPOINTS (b)
14861 if (is_tracepoint (b) && user_breakpoint_p (b))
14863 breaks_to_delete = 1;
14867 /* Ask user only if there are some breakpoints to delete. */
14869 || (breaks_to_delete && query (_("Delete all tracepoints? "))))
14871 ALL_BREAKPOINTS_SAFE (b, b_tmp)
14872 if (is_tracepoint (b) && user_breakpoint_p (b))
14873 delete_breakpoint (b);
14877 map_breakpoint_numbers
14878 (arg, [&] (breakpoint *b)
14880 iterate_over_related_breakpoints (b, delete_breakpoint);
14884 /* Helper function for trace_pass_command. */
14887 trace_pass_set_count (struct tracepoint *tp, int count, int from_tty)
14889 tp->pass_count = count;
14890 observer_notify_breakpoint_modified (tp);
14892 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
14893 tp->number, count);
14896 /* Set passcount for tracepoint.
14898 First command argument is passcount, second is tracepoint number.
14899 If tracepoint number omitted, apply to most recently defined.
14900 Also accepts special argument "all". */
14903 trace_pass_command (char *args, int from_tty)
14905 struct tracepoint *t1;
14906 unsigned int count;
14908 if (args == 0 || *args == 0)
14909 error (_("passcount command requires an "
14910 "argument (count + optional TP num)"));
14912 count = strtoul (args, &args, 10); /* Count comes first, then TP num. */
14914 args = skip_spaces (args);
14915 if (*args && strncasecmp (args, "all", 3) == 0)
14917 struct breakpoint *b;
14919 args += 3; /* Skip special argument "all". */
14921 error (_("Junk at end of arguments."));
14923 ALL_TRACEPOINTS (b)
14925 t1 = (struct tracepoint *) b;
14926 trace_pass_set_count (t1, count, from_tty);
14929 else if (*args == '\0')
14931 t1 = get_tracepoint_by_number (&args, NULL);
14933 trace_pass_set_count (t1, count, from_tty);
14937 number_or_range_parser parser (args);
14938 while (!parser.finished ())
14940 t1 = get_tracepoint_by_number (&args, &parser);
14942 trace_pass_set_count (t1, count, from_tty);
14947 struct tracepoint *
14948 get_tracepoint (int num)
14950 struct breakpoint *t;
14952 ALL_TRACEPOINTS (t)
14953 if (t->number == num)
14954 return (struct tracepoint *) t;
14959 /* Find the tracepoint with the given target-side number (which may be
14960 different from the tracepoint number after disconnecting and
14963 struct tracepoint *
14964 get_tracepoint_by_number_on_target (int num)
14966 struct breakpoint *b;
14968 ALL_TRACEPOINTS (b)
14970 struct tracepoint *t = (struct tracepoint *) b;
14972 if (t->number_on_target == num)
14979 /* Utility: parse a tracepoint number and look it up in the list.
14980 If STATE is not NULL, use, get_number_or_range_state and ignore ARG.
14981 If the argument is missing, the most recent tracepoint
14982 (tracepoint_count) is returned. */
14984 struct tracepoint *
14985 get_tracepoint_by_number (char **arg,
14986 number_or_range_parser *parser)
14988 struct breakpoint *t;
14990 char *instring = arg == NULL ? NULL : *arg;
14992 if (parser != NULL)
14994 gdb_assert (!parser->finished ());
14995 tpnum = parser->get_number ();
14997 else if (arg == NULL || *arg == NULL || ! **arg)
14998 tpnum = tracepoint_count;
15000 tpnum = get_number (arg);
15004 if (instring && *instring)
15005 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
15008 printf_filtered (_("No previous tracepoint\n"));
15012 ALL_TRACEPOINTS (t)
15013 if (t->number == tpnum)
15015 return (struct tracepoint *) t;
15018 printf_unfiltered ("No tracepoint number %d.\n", tpnum);
15023 print_recreate_thread (struct breakpoint *b, struct ui_file *fp)
15025 if (b->thread != -1)
15026 fprintf_unfiltered (fp, " thread %d", b->thread);
15029 fprintf_unfiltered (fp, " task %d", b->task);
15031 fprintf_unfiltered (fp, "\n");
15034 /* Save information on user settable breakpoints (watchpoints, etc) to
15035 a new script file named FILENAME. If FILTER is non-NULL, call it
15036 on each breakpoint and only include the ones for which it returns
15040 save_breakpoints (const char *filename, int from_tty,
15041 int (*filter) (const struct breakpoint *))
15043 struct breakpoint *tp;
15045 int extra_trace_bits = 0;
15047 if (filename == 0 || *filename == 0)
15048 error (_("Argument required (file name in which to save)"));
15050 /* See if we have anything to save. */
15051 ALL_BREAKPOINTS (tp)
15053 /* Skip internal and momentary breakpoints. */
15054 if (!user_breakpoint_p (tp))
15057 /* If we have a filter, only save the breakpoints it accepts. */
15058 if (filter && !filter (tp))
15063 if (is_tracepoint (tp))
15065 extra_trace_bits = 1;
15067 /* We can stop searching. */
15074 warning (_("Nothing to save."));
15078 gdb::unique_xmalloc_ptr<char> expanded_filename (tilde_expand (filename));
15082 if (!fp.open (expanded_filename.get (), "w"))
15083 error (_("Unable to open file '%s' for saving (%s)"),
15084 expanded_filename.get (), safe_strerror (errno));
15086 if (extra_trace_bits)
15087 save_trace_state_variables (&fp);
15089 ALL_BREAKPOINTS (tp)
15091 /* Skip internal and momentary breakpoints. */
15092 if (!user_breakpoint_p (tp))
15095 /* If we have a filter, only save the breakpoints it accepts. */
15096 if (filter && !filter (tp))
15099 tp->ops->print_recreate (tp, &fp);
15101 /* Note, we can't rely on tp->number for anything, as we can't
15102 assume the recreated breakpoint numbers will match. Use $bpnum
15105 if (tp->cond_string)
15106 fp.printf (" condition $bpnum %s\n", tp->cond_string);
15108 if (tp->ignore_count)
15109 fp.printf (" ignore $bpnum %d\n", tp->ignore_count);
15111 if (tp->type != bp_dprintf && tp->commands)
15113 fp.puts (" commands\n");
15115 current_uiout->redirect (&fp);
15118 print_command_lines (current_uiout, tp->commands.get (), 2);
15120 CATCH (ex, RETURN_MASK_ALL)
15122 current_uiout->redirect (NULL);
15123 throw_exception (ex);
15127 current_uiout->redirect (NULL);
15128 fp.puts (" end\n");
15131 if (tp->enable_state == bp_disabled)
15132 fp.puts ("disable $bpnum\n");
15134 /* If this is a multi-location breakpoint, check if the locations
15135 should be individually disabled. Watchpoint locations are
15136 special, and not user visible. */
15137 if (!is_watchpoint (tp) && tp->loc && tp->loc->next)
15139 struct bp_location *loc;
15142 for (loc = tp->loc; loc != NULL; loc = loc->next, n++)
15144 fp.printf ("disable $bpnum.%d\n", n);
15148 if (extra_trace_bits && *default_collect)
15149 fp.printf ("set default-collect %s\n", default_collect);
15152 printf_filtered (_("Saved to file '%s'.\n"), expanded_filename.get ());
15155 /* The `save breakpoints' command. */
15158 save_breakpoints_command (const char *args, int from_tty)
15160 save_breakpoints (args, from_tty, NULL);
15163 /* The `save tracepoints' command. */
15166 save_tracepoints_command (const char *args, int from_tty)
15168 save_breakpoints (args, from_tty, is_tracepoint);
15171 /* Create a vector of all tracepoints. */
15173 VEC(breakpoint_p) *
15174 all_tracepoints (void)
15176 VEC(breakpoint_p) *tp_vec = 0;
15177 struct breakpoint *tp;
15179 ALL_TRACEPOINTS (tp)
15181 VEC_safe_push (breakpoint_p, tp_vec, tp);
15188 /* This help string is used to consolidate all the help string for specifying
15189 locations used by several commands. */
15191 #define LOCATION_HELP_STRING \
15192 "Linespecs are colon-separated lists of location parameters, such as\n\
15193 source filename, function name, label name, and line number.\n\
15194 Example: To specify the start of a label named \"the_top\" in the\n\
15195 function \"fact\" in the file \"factorial.c\", use\n\
15196 \"factorial.c:fact:the_top\".\n\
15198 Address locations begin with \"*\" and specify an exact address in the\n\
15199 program. Example: To specify the fourth byte past the start function\n\
15200 \"main\", use \"*main + 4\".\n\
15202 Explicit locations are similar to linespecs but use an option/argument\n\
15203 syntax to specify location parameters.\n\
15204 Example: To specify the start of the label named \"the_top\" in the\n\
15205 function \"fact\" in the file \"factorial.c\", use \"-source factorial.c\n\
15206 -function fact -label the_top\".\n"
15208 /* This help string is used for the break, hbreak, tbreak and thbreak
15209 commands. It is defined as a macro to prevent duplication.
15210 COMMAND should be a string constant containing the name of the
15213 #define BREAK_ARGS_HELP(command) \
15214 command" [PROBE_MODIFIER] [LOCATION] [thread THREADNUM] [if CONDITION]\n\
15215 PROBE_MODIFIER shall be present if the command is to be placed in a\n\
15216 probe point. Accepted values are `-probe' (for a generic, automatically\n\
15217 guessed probe type), `-probe-stap' (for a SystemTap probe) or \n\
15218 `-probe-dtrace' (for a DTrace probe).\n\
15219 LOCATION may be a linespec, address, or explicit location as described\n\
15222 With no LOCATION, uses current execution address of the selected\n\
15223 stack frame. This is useful for breaking on return to a stack frame.\n\
15225 THREADNUM is the number from \"info threads\".\n\
15226 CONDITION is a boolean expression.\n\
15227 \n" LOCATION_HELP_STRING "\n\
15228 Multiple breakpoints at one place are permitted, and useful if their\n\
15229 conditions are different.\n\
15231 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
15233 /* List of subcommands for "catch". */
15234 static struct cmd_list_element *catch_cmdlist;
15236 /* List of subcommands for "tcatch". */
15237 static struct cmd_list_element *tcatch_cmdlist;
15240 add_catch_command (const char *name, const char *docstring,
15241 cmd_sfunc_ftype *sfunc,
15242 completer_ftype *completer,
15243 void *user_data_catch,
15244 void *user_data_tcatch)
15246 struct cmd_list_element *command;
15248 command = add_cmd (name, class_breakpoint, docstring,
15250 set_cmd_sfunc (command, sfunc);
15251 set_cmd_context (command, user_data_catch);
15252 set_cmd_completer (command, completer);
15254 command = add_cmd (name, class_breakpoint, docstring,
15256 set_cmd_sfunc (command, sfunc);
15257 set_cmd_context (command, user_data_tcatch);
15258 set_cmd_completer (command, completer);
15262 save_command (const char *arg, int from_tty)
15264 printf_unfiltered (_("\"save\" must be followed by "
15265 "the name of a save subcommand.\n"));
15266 help_list (save_cmdlist, "save ", all_commands, gdb_stdout);
15269 struct breakpoint *
15270 iterate_over_breakpoints (int (*callback) (struct breakpoint *, void *),
15273 struct breakpoint *b, *b_tmp;
15275 ALL_BREAKPOINTS_SAFE (b, b_tmp)
15277 if ((*callback) (b, data))
15284 /* Zero if any of the breakpoint's locations could be a location where
15285 functions have been inlined, nonzero otherwise. */
15288 is_non_inline_function (struct breakpoint *b)
15290 /* The shared library event breakpoint is set on the address of a
15291 non-inline function. */
15292 if (b->type == bp_shlib_event)
15298 /* Nonzero if the specified PC cannot be a location where functions
15299 have been inlined. */
15302 pc_at_non_inline_function (const address_space *aspace, CORE_ADDR pc,
15303 const struct target_waitstatus *ws)
15305 struct breakpoint *b;
15306 struct bp_location *bl;
15308 ALL_BREAKPOINTS (b)
15310 if (!is_non_inline_function (b))
15313 for (bl = b->loc; bl != NULL; bl = bl->next)
15315 if (!bl->shlib_disabled
15316 && bpstat_check_location (bl, aspace, pc, ws))
15324 /* Remove any references to OBJFILE which is going to be freed. */
15327 breakpoint_free_objfile (struct objfile *objfile)
15329 struct bp_location **locp, *loc;
15331 ALL_BP_LOCATIONS (loc, locp)
15332 if (loc->symtab != NULL && SYMTAB_OBJFILE (loc->symtab) == objfile)
15333 loc->symtab = NULL;
15337 initialize_breakpoint_ops (void)
15339 static int initialized = 0;
15341 struct breakpoint_ops *ops;
15347 /* The breakpoint_ops structure to be inherit by all kinds of
15348 breakpoints (real breakpoints, i.e., user "break" breakpoints,
15349 internal and momentary breakpoints, etc.). */
15350 ops = &bkpt_base_breakpoint_ops;
15351 *ops = base_breakpoint_ops;
15352 ops->re_set = bkpt_re_set;
15353 ops->insert_location = bkpt_insert_location;
15354 ops->remove_location = bkpt_remove_location;
15355 ops->breakpoint_hit = bkpt_breakpoint_hit;
15356 ops->create_sals_from_location = bkpt_create_sals_from_location;
15357 ops->create_breakpoints_sal = bkpt_create_breakpoints_sal;
15358 ops->decode_location = bkpt_decode_location;
15360 /* The breakpoint_ops structure to be used in regular breakpoints. */
15361 ops = &bkpt_breakpoint_ops;
15362 *ops = bkpt_base_breakpoint_ops;
15363 ops->re_set = bkpt_re_set;
15364 ops->resources_needed = bkpt_resources_needed;
15365 ops->print_it = bkpt_print_it;
15366 ops->print_mention = bkpt_print_mention;
15367 ops->print_recreate = bkpt_print_recreate;
15369 /* Ranged breakpoints. */
15370 ops = &ranged_breakpoint_ops;
15371 *ops = bkpt_breakpoint_ops;
15372 ops->breakpoint_hit = breakpoint_hit_ranged_breakpoint;
15373 ops->resources_needed = resources_needed_ranged_breakpoint;
15374 ops->print_it = print_it_ranged_breakpoint;
15375 ops->print_one = print_one_ranged_breakpoint;
15376 ops->print_one_detail = print_one_detail_ranged_breakpoint;
15377 ops->print_mention = print_mention_ranged_breakpoint;
15378 ops->print_recreate = print_recreate_ranged_breakpoint;
15380 /* Internal breakpoints. */
15381 ops = &internal_breakpoint_ops;
15382 *ops = bkpt_base_breakpoint_ops;
15383 ops->re_set = internal_bkpt_re_set;
15384 ops->check_status = internal_bkpt_check_status;
15385 ops->print_it = internal_bkpt_print_it;
15386 ops->print_mention = internal_bkpt_print_mention;
15388 /* Momentary breakpoints. */
15389 ops = &momentary_breakpoint_ops;
15390 *ops = bkpt_base_breakpoint_ops;
15391 ops->re_set = momentary_bkpt_re_set;
15392 ops->check_status = momentary_bkpt_check_status;
15393 ops->print_it = momentary_bkpt_print_it;
15394 ops->print_mention = momentary_bkpt_print_mention;
15396 /* Probe breakpoints. */
15397 ops = &bkpt_probe_breakpoint_ops;
15398 *ops = bkpt_breakpoint_ops;
15399 ops->insert_location = bkpt_probe_insert_location;
15400 ops->remove_location = bkpt_probe_remove_location;
15401 ops->create_sals_from_location = bkpt_probe_create_sals_from_location;
15402 ops->decode_location = bkpt_probe_decode_location;
15405 ops = &watchpoint_breakpoint_ops;
15406 *ops = base_breakpoint_ops;
15407 ops->re_set = re_set_watchpoint;
15408 ops->insert_location = insert_watchpoint;
15409 ops->remove_location = remove_watchpoint;
15410 ops->breakpoint_hit = breakpoint_hit_watchpoint;
15411 ops->check_status = check_status_watchpoint;
15412 ops->resources_needed = resources_needed_watchpoint;
15413 ops->works_in_software_mode = works_in_software_mode_watchpoint;
15414 ops->print_it = print_it_watchpoint;
15415 ops->print_mention = print_mention_watchpoint;
15416 ops->print_recreate = print_recreate_watchpoint;
15417 ops->explains_signal = explains_signal_watchpoint;
15419 /* Masked watchpoints. */
15420 ops = &masked_watchpoint_breakpoint_ops;
15421 *ops = watchpoint_breakpoint_ops;
15422 ops->insert_location = insert_masked_watchpoint;
15423 ops->remove_location = remove_masked_watchpoint;
15424 ops->resources_needed = resources_needed_masked_watchpoint;
15425 ops->works_in_software_mode = works_in_software_mode_masked_watchpoint;
15426 ops->print_it = print_it_masked_watchpoint;
15427 ops->print_one_detail = print_one_detail_masked_watchpoint;
15428 ops->print_mention = print_mention_masked_watchpoint;
15429 ops->print_recreate = print_recreate_masked_watchpoint;
15432 ops = &tracepoint_breakpoint_ops;
15433 *ops = base_breakpoint_ops;
15434 ops->re_set = tracepoint_re_set;
15435 ops->breakpoint_hit = tracepoint_breakpoint_hit;
15436 ops->print_one_detail = tracepoint_print_one_detail;
15437 ops->print_mention = tracepoint_print_mention;
15438 ops->print_recreate = tracepoint_print_recreate;
15439 ops->create_sals_from_location = tracepoint_create_sals_from_location;
15440 ops->create_breakpoints_sal = tracepoint_create_breakpoints_sal;
15441 ops->decode_location = tracepoint_decode_location;
15443 /* Probe tracepoints. */
15444 ops = &tracepoint_probe_breakpoint_ops;
15445 *ops = tracepoint_breakpoint_ops;
15446 ops->create_sals_from_location = tracepoint_probe_create_sals_from_location;
15447 ops->decode_location = tracepoint_probe_decode_location;
15449 /* Static tracepoints with marker (`-m'). */
15450 ops = &strace_marker_breakpoint_ops;
15451 *ops = tracepoint_breakpoint_ops;
15452 ops->create_sals_from_location = strace_marker_create_sals_from_location;
15453 ops->create_breakpoints_sal = strace_marker_create_breakpoints_sal;
15454 ops->decode_location = strace_marker_decode_location;
15456 /* Fork catchpoints. */
15457 ops = &catch_fork_breakpoint_ops;
15458 *ops = base_breakpoint_ops;
15459 ops->insert_location = insert_catch_fork;
15460 ops->remove_location = remove_catch_fork;
15461 ops->breakpoint_hit = breakpoint_hit_catch_fork;
15462 ops->print_it = print_it_catch_fork;
15463 ops->print_one = print_one_catch_fork;
15464 ops->print_mention = print_mention_catch_fork;
15465 ops->print_recreate = print_recreate_catch_fork;
15467 /* Vfork catchpoints. */
15468 ops = &catch_vfork_breakpoint_ops;
15469 *ops = base_breakpoint_ops;
15470 ops->insert_location = insert_catch_vfork;
15471 ops->remove_location = remove_catch_vfork;
15472 ops->breakpoint_hit = breakpoint_hit_catch_vfork;
15473 ops->print_it = print_it_catch_vfork;
15474 ops->print_one = print_one_catch_vfork;
15475 ops->print_mention = print_mention_catch_vfork;
15476 ops->print_recreate = print_recreate_catch_vfork;
15478 /* Exec catchpoints. */
15479 ops = &catch_exec_breakpoint_ops;
15480 *ops = base_breakpoint_ops;
15481 ops->insert_location = insert_catch_exec;
15482 ops->remove_location = remove_catch_exec;
15483 ops->breakpoint_hit = breakpoint_hit_catch_exec;
15484 ops->print_it = print_it_catch_exec;
15485 ops->print_one = print_one_catch_exec;
15486 ops->print_mention = print_mention_catch_exec;
15487 ops->print_recreate = print_recreate_catch_exec;
15489 /* Solib-related catchpoints. */
15490 ops = &catch_solib_breakpoint_ops;
15491 *ops = base_breakpoint_ops;
15492 ops->insert_location = insert_catch_solib;
15493 ops->remove_location = remove_catch_solib;
15494 ops->breakpoint_hit = breakpoint_hit_catch_solib;
15495 ops->check_status = check_status_catch_solib;
15496 ops->print_it = print_it_catch_solib;
15497 ops->print_one = print_one_catch_solib;
15498 ops->print_mention = print_mention_catch_solib;
15499 ops->print_recreate = print_recreate_catch_solib;
15501 ops = &dprintf_breakpoint_ops;
15502 *ops = bkpt_base_breakpoint_ops;
15503 ops->re_set = dprintf_re_set;
15504 ops->resources_needed = bkpt_resources_needed;
15505 ops->print_it = bkpt_print_it;
15506 ops->print_mention = bkpt_print_mention;
15507 ops->print_recreate = dprintf_print_recreate;
15508 ops->after_condition_true = dprintf_after_condition_true;
15509 ops->breakpoint_hit = dprintf_breakpoint_hit;
15512 /* Chain containing all defined "enable breakpoint" subcommands. */
15514 static struct cmd_list_element *enablebreaklist = NULL;
15517 _initialize_breakpoint (void)
15519 struct cmd_list_element *c;
15521 initialize_breakpoint_ops ();
15523 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib);
15524 observer_attach_free_objfile (disable_breakpoints_in_freed_objfile);
15525 observer_attach_memory_changed (invalidate_bp_value_on_memory_change);
15527 breakpoint_objfile_key
15528 = register_objfile_data_with_cleanup (NULL, free_breakpoint_objfile_data);
15530 breakpoint_chain = 0;
15531 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
15532 before a breakpoint is set. */
15533 breakpoint_count = 0;
15535 tracepoint_count = 0;
15537 add_com ("ignore", class_breakpoint, ignore_command, _("\
15538 Set ignore-count of breakpoint number N to COUNT.\n\
15539 Usage is `ignore N COUNT'."));
15541 add_com ("commands", class_breakpoint, commands_command, _("\
15542 Set commands to be executed when the given breakpoints are hit.\n\
15543 Give a space-separated breakpoint list as argument after \"commands\".\n\
15544 A list element can be a breakpoint number (e.g. `5') or a range of numbers\n\
15546 With no argument, the targeted breakpoint is the last one set.\n\
15547 The commands themselves follow starting on the next line.\n\
15548 Type a line containing \"end\" to indicate the end of them.\n\
15549 Give \"silent\" as the first line to make the breakpoint silent;\n\
15550 then no output is printed when it is hit, except what the commands print."));
15552 c = add_com ("condition", class_breakpoint, condition_command, _("\
15553 Specify breakpoint number N to break only if COND is true.\n\
15554 Usage is `condition N COND', where N is an integer and COND is an\n\
15555 expression to be evaluated whenever breakpoint N is reached."));
15556 set_cmd_completer (c, condition_completer);
15558 c = add_com ("tbreak", class_breakpoint, tbreak_command, _("\
15559 Set a temporary breakpoint.\n\
15560 Like \"break\" except the breakpoint is only temporary,\n\
15561 so it will be deleted when hit. Equivalent to \"break\" followed\n\
15562 by using \"enable delete\" on the breakpoint number.\n\
15564 BREAK_ARGS_HELP ("tbreak")));
15565 set_cmd_completer (c, location_completer);
15567 c = add_com ("hbreak", class_breakpoint, hbreak_command, _("\
15568 Set a hardware assisted breakpoint.\n\
15569 Like \"break\" except the breakpoint requires hardware support,\n\
15570 some target hardware may not have this support.\n\
15572 BREAK_ARGS_HELP ("hbreak")));
15573 set_cmd_completer (c, location_completer);
15575 c = add_com ("thbreak", class_breakpoint, thbreak_command, _("\
15576 Set a temporary hardware assisted breakpoint.\n\
15577 Like \"hbreak\" except the breakpoint is only temporary,\n\
15578 so it will be deleted when hit.\n\
15580 BREAK_ARGS_HELP ("thbreak")));
15581 set_cmd_completer (c, location_completer);
15583 add_prefix_cmd ("enable", class_breakpoint, enable_command, _("\
15584 Enable some breakpoints.\n\
15585 Give breakpoint numbers (separated by spaces) as arguments.\n\
15586 With no subcommand, breakpoints are enabled until you command otherwise.\n\
15587 This is used to cancel the effect of the \"disable\" command.\n\
15588 With a subcommand you can enable temporarily."),
15589 &enablelist, "enable ", 1, &cmdlist);
15591 add_com_alias ("en", "enable", class_breakpoint, 1);
15593 add_prefix_cmd ("breakpoints", class_breakpoint, enable_command, _("\
15594 Enable some breakpoints.\n\
15595 Give breakpoint numbers (separated by spaces) as arguments.\n\
15596 This is used to cancel the effect of the \"disable\" command.\n\
15597 May be abbreviated to simply \"enable\".\n"),
15598 &enablebreaklist, "enable breakpoints ", 1, &enablelist);
15600 add_cmd ("once", no_class, enable_once_command, _("\
15601 Enable breakpoints for one hit. Give breakpoint numbers.\n\
15602 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
15605 add_cmd ("delete", no_class, enable_delete_command, _("\
15606 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
15607 If a breakpoint is hit while enabled in this fashion, it is deleted."),
15610 add_cmd ("count", no_class, enable_count_command, _("\
15611 Enable breakpoints for COUNT hits. Give count and then breakpoint numbers.\n\
15612 If a breakpoint is hit while enabled in this fashion,\n\
15613 the count is decremented; when it reaches zero, the breakpoint is disabled."),
15616 add_cmd ("delete", no_class, enable_delete_command, _("\
15617 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
15618 If a breakpoint is hit while enabled in this fashion, it is deleted."),
15621 add_cmd ("once", no_class, enable_once_command, _("\
15622 Enable breakpoints for one hit. Give breakpoint numbers.\n\
15623 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
15626 add_cmd ("count", no_class, enable_count_command, _("\
15627 Enable breakpoints for COUNT hits. Give count and then breakpoint numbers.\n\
15628 If a breakpoint is hit while enabled in this fashion,\n\
15629 the count is decremented; when it reaches zero, the breakpoint is disabled."),
15632 add_prefix_cmd ("disable", class_breakpoint, disable_command, _("\
15633 Disable some breakpoints.\n\
15634 Arguments are breakpoint numbers with spaces in between.\n\
15635 To disable all breakpoints, give no argument.\n\
15636 A disabled breakpoint is not forgotten, but has no effect until re-enabled."),
15637 &disablelist, "disable ", 1, &cmdlist);
15638 add_com_alias ("dis", "disable", class_breakpoint, 1);
15639 add_com_alias ("disa", "disable", class_breakpoint, 1);
15641 add_cmd ("breakpoints", class_alias, disable_command, _("\
15642 Disable some breakpoints.\n\
15643 Arguments are breakpoint numbers with spaces in between.\n\
15644 To disable all breakpoints, give no argument.\n\
15645 A disabled breakpoint is not forgotten, but has no effect until re-enabled.\n\
15646 This command may be abbreviated \"disable\"."),
15649 add_prefix_cmd ("delete", class_breakpoint, delete_command, _("\
15650 Delete some breakpoints or auto-display expressions.\n\
15651 Arguments are breakpoint numbers with spaces in between.\n\
15652 To delete all breakpoints, give no argument.\n\
15654 Also a prefix command for deletion of other GDB objects.\n\
15655 The \"unset\" command is also an alias for \"delete\"."),
15656 &deletelist, "delete ", 1, &cmdlist);
15657 add_com_alias ("d", "delete", class_breakpoint, 1);
15658 add_com_alias ("del", "delete", class_breakpoint, 1);
15660 add_cmd ("breakpoints", class_alias, delete_command, _("\
15661 Delete some breakpoints or auto-display expressions.\n\
15662 Arguments are breakpoint numbers with spaces in between.\n\
15663 To delete all breakpoints, give no argument.\n\
15664 This command may be abbreviated \"delete\"."),
15667 add_com ("clear", class_breakpoint, clear_command, _("\
15668 Clear breakpoint at specified location.\n\
15669 Argument may be a linespec, explicit, or address location as described below.\n\
15671 With no argument, clears all breakpoints in the line that the selected frame\n\
15672 is executing in.\n"
15673 "\n" LOCATION_HELP_STRING "\n\
15674 See also the \"delete\" command which clears breakpoints by number."));
15675 add_com_alias ("cl", "clear", class_breakpoint, 1);
15677 c = add_com ("break", class_breakpoint, break_command, _("\
15678 Set breakpoint at specified location.\n"
15679 BREAK_ARGS_HELP ("break")));
15680 set_cmd_completer (c, location_completer);
15682 add_com_alias ("b", "break", class_run, 1);
15683 add_com_alias ("br", "break", class_run, 1);
15684 add_com_alias ("bre", "break", class_run, 1);
15685 add_com_alias ("brea", "break", class_run, 1);
15689 add_abbrev_prefix_cmd ("stop", class_breakpoint, stop_command, _("\
15690 Break in function/address or break at a line in the current file."),
15691 &stoplist, "stop ", 1, &cmdlist);
15692 add_cmd ("in", class_breakpoint, stopin_command,
15693 _("Break in function or address."), &stoplist);
15694 add_cmd ("at", class_breakpoint, stopat_command,
15695 _("Break at a line in the current file."), &stoplist);
15696 add_com ("status", class_info, info_breakpoints_command, _("\
15697 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
15698 The \"Type\" column indicates one of:\n\
15699 \tbreakpoint - normal breakpoint\n\
15700 \twatchpoint - watchpoint\n\
15701 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15702 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
15703 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
15704 address and file/line number respectively.\n\
15706 Convenience variable \"$_\" and default examine address for \"x\"\n\
15707 are set to the address of the last breakpoint listed unless the command\n\
15708 is prefixed with \"server \".\n\n\
15709 Convenience variable \"$bpnum\" contains the number of the last\n\
15710 breakpoint set."));
15713 add_info ("breakpoints", info_breakpoints_command, _("\
15714 Status of specified breakpoints (all user-settable breakpoints if no argument).\n\
15715 The \"Type\" column indicates one of:\n\
15716 \tbreakpoint - normal breakpoint\n\
15717 \twatchpoint - watchpoint\n\
15718 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15719 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
15720 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
15721 address and file/line number respectively.\n\
15723 Convenience variable \"$_\" and default examine address for \"x\"\n\
15724 are set to the address of the last breakpoint listed unless the command\n\
15725 is prefixed with \"server \".\n\n\
15726 Convenience variable \"$bpnum\" contains the number of the last\n\
15727 breakpoint set."));
15729 add_info_alias ("b", "breakpoints", 1);
15731 add_cmd ("breakpoints", class_maintenance, maintenance_info_breakpoints, _("\
15732 Status of all breakpoints, or breakpoint number NUMBER.\n\
15733 The \"Type\" column indicates one of:\n\
15734 \tbreakpoint - normal breakpoint\n\
15735 \twatchpoint - watchpoint\n\
15736 \tlongjmp - internal breakpoint used to step through longjmp()\n\
15737 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
15738 \tuntil - internal breakpoint used by the \"until\" command\n\
15739 \tfinish - internal breakpoint used by the \"finish\" command\n\
15740 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15741 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
15742 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
15743 address and file/line number respectively.\n\
15745 Convenience variable \"$_\" and default examine address for \"x\"\n\
15746 are set to the address of the last breakpoint listed unless the command\n\
15747 is prefixed with \"server \".\n\n\
15748 Convenience variable \"$bpnum\" contains the number of the last\n\
15750 &maintenanceinfolist);
15752 add_prefix_cmd ("catch", class_breakpoint, catch_command, _("\
15753 Set catchpoints to catch events."),
15754 &catch_cmdlist, "catch ",
15755 0/*allow-unknown*/, &cmdlist);
15757 add_prefix_cmd ("tcatch", class_breakpoint, tcatch_command, _("\
15758 Set temporary catchpoints to catch events."),
15759 &tcatch_cmdlist, "tcatch ",
15760 0/*allow-unknown*/, &cmdlist);
15762 add_catch_command ("fork", _("Catch calls to fork."),
15763 catch_fork_command_1,
15765 (void *) (uintptr_t) catch_fork_permanent,
15766 (void *) (uintptr_t) catch_fork_temporary);
15767 add_catch_command ("vfork", _("Catch calls to vfork."),
15768 catch_fork_command_1,
15770 (void *) (uintptr_t) catch_vfork_permanent,
15771 (void *) (uintptr_t) catch_vfork_temporary);
15772 add_catch_command ("exec", _("Catch calls to exec."),
15773 catch_exec_command_1,
15777 add_catch_command ("load", _("Catch loads of shared libraries.\n\
15778 Usage: catch load [REGEX]\n\
15779 If REGEX is given, only stop for libraries matching the regular expression."),
15780 catch_load_command_1,
15784 add_catch_command ("unload", _("Catch unloads of shared libraries.\n\
15785 Usage: catch unload [REGEX]\n\
15786 If REGEX is given, only stop for libraries matching the regular expression."),
15787 catch_unload_command_1,
15792 c = add_com ("watch", class_breakpoint, watch_command, _("\
15793 Set a watchpoint for an expression.\n\
15794 Usage: watch [-l|-location] EXPRESSION\n\
15795 A watchpoint stops execution of your program whenever the value of\n\
15796 an expression changes.\n\
15797 If -l or -location is given, this evaluates EXPRESSION and watches\n\
15798 the memory to which it refers."));
15799 set_cmd_completer (c, expression_completer);
15801 c = add_com ("rwatch", class_breakpoint, rwatch_command, _("\
15802 Set a read watchpoint for an expression.\n\
15803 Usage: rwatch [-l|-location] EXPRESSION\n\
15804 A watchpoint stops execution of your program whenever the value of\n\
15805 an expression is read.\n\
15806 If -l or -location is given, this evaluates EXPRESSION and watches\n\
15807 the memory to which it refers."));
15808 set_cmd_completer (c, expression_completer);
15810 c = add_com ("awatch", class_breakpoint, awatch_command, _("\
15811 Set a watchpoint for an expression.\n\
15812 Usage: awatch [-l|-location] EXPRESSION\n\
15813 A watchpoint stops execution of your program whenever the value of\n\
15814 an expression is either read or written.\n\
15815 If -l or -location is given, this evaluates EXPRESSION and watches\n\
15816 the memory to which it refers."));
15817 set_cmd_completer (c, expression_completer);
15819 add_info ("watchpoints", info_watchpoints_command, _("\
15820 Status of specified watchpoints (all watchpoints if no argument)."));
15822 /* XXX: cagney/2005-02-23: This should be a boolean, and should
15823 respond to changes - contrary to the description. */
15824 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support,
15825 &can_use_hw_watchpoints, _("\
15826 Set debugger's willingness to use watchpoint hardware."), _("\
15827 Show debugger's willingness to use watchpoint hardware."), _("\
15828 If zero, gdb will not use hardware for new watchpoints, even if\n\
15829 such is available. (However, any hardware watchpoints that were\n\
15830 created before setting this to nonzero, will continue to use watchpoint\n\
15833 show_can_use_hw_watchpoints,
15834 &setlist, &showlist);
15836 can_use_hw_watchpoints = 1;
15838 /* Tracepoint manipulation commands. */
15840 c = add_com ("trace", class_breakpoint, trace_command, _("\
15841 Set a tracepoint at specified location.\n\
15843 BREAK_ARGS_HELP ("trace") "\n\
15844 Do \"help tracepoints\" for info on other tracepoint commands."));
15845 set_cmd_completer (c, location_completer);
15847 add_com_alias ("tp", "trace", class_alias, 0);
15848 add_com_alias ("tr", "trace", class_alias, 1);
15849 add_com_alias ("tra", "trace", class_alias, 1);
15850 add_com_alias ("trac", "trace", class_alias, 1);
15852 c = add_com ("ftrace", class_breakpoint, ftrace_command, _("\
15853 Set a fast tracepoint at specified location.\n\
15855 BREAK_ARGS_HELP ("ftrace") "\n\
15856 Do \"help tracepoints\" for info on other tracepoint commands."));
15857 set_cmd_completer (c, location_completer);
15859 c = add_com ("strace", class_breakpoint, strace_command, _("\
15860 Set a static tracepoint at location or marker.\n\
15862 strace [LOCATION] [if CONDITION]\n\
15863 LOCATION may be a linespec, explicit, or address location (described below) \n\
15864 or -m MARKER_ID.\n\n\
15865 If a marker id is specified, probe the marker with that name. With\n\
15866 no LOCATION, uses current execution address of the selected stack frame.\n\
15867 Static tracepoints accept an extra collect action -- ``collect $_sdata''.\n\
15868 This collects arbitrary user data passed in the probe point call to the\n\
15869 tracing library. You can inspect it when analyzing the trace buffer,\n\
15870 by printing the $_sdata variable like any other convenience variable.\n\
15872 CONDITION is a boolean expression.\n\
15873 \n" LOCATION_HELP_STRING "\n\
15874 Multiple tracepoints at one place are permitted, and useful if their\n\
15875 conditions are different.\n\
15877 Do \"help breakpoints\" for info on other commands dealing with breakpoints.\n\
15878 Do \"help tracepoints\" for info on other tracepoint commands."));
15879 set_cmd_completer (c, location_completer);
15881 add_info ("tracepoints", info_tracepoints_command, _("\
15882 Status of specified tracepoints (all tracepoints if no argument).\n\
15883 Convenience variable \"$tpnum\" contains the number of the\n\
15884 last tracepoint set."));
15886 add_info_alias ("tp", "tracepoints", 1);
15888 add_cmd ("tracepoints", class_trace, delete_trace_command, _("\
15889 Delete specified tracepoints.\n\
15890 Arguments are tracepoint numbers, separated by spaces.\n\
15891 No argument means delete all tracepoints."),
15893 add_alias_cmd ("tr", "tracepoints", class_trace, 1, &deletelist);
15895 c = add_cmd ("tracepoints", class_trace, disable_trace_command, _("\
15896 Disable specified tracepoints.\n\
15897 Arguments are tracepoint numbers, separated by spaces.\n\
15898 No argument means disable all tracepoints."),
15900 deprecate_cmd (c, "disable");
15902 c = add_cmd ("tracepoints", class_trace, enable_trace_command, _("\
15903 Enable specified tracepoints.\n\
15904 Arguments are tracepoint numbers, separated by spaces.\n\
15905 No argument means enable all tracepoints."),
15907 deprecate_cmd (c, "enable");
15909 add_com ("passcount", class_trace, trace_pass_command, _("\
15910 Set the passcount for a tracepoint.\n\
15911 The trace will end when the tracepoint has been passed 'count' times.\n\
15912 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
15913 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
15915 add_prefix_cmd ("save", class_breakpoint, save_command,
15916 _("Save breakpoint definitions as a script."),
15917 &save_cmdlist, "save ",
15918 0/*allow-unknown*/, &cmdlist);
15920 c = add_cmd ("breakpoints", class_breakpoint, save_breakpoints_command, _("\
15921 Save current breakpoint definitions as a script.\n\
15922 This includes all types of breakpoints (breakpoints, watchpoints,\n\
15923 catchpoints, tracepoints). Use the 'source' command in another debug\n\
15924 session to restore them."),
15926 set_cmd_completer (c, filename_completer);
15928 c = add_cmd ("tracepoints", class_trace, save_tracepoints_command, _("\
15929 Save current tracepoint definitions as a script.\n\
15930 Use the 'source' command in another debug session to restore them."),
15932 set_cmd_completer (c, filename_completer);
15934 c = add_com_alias ("save-tracepoints", "save tracepoints", class_trace, 0);
15935 deprecate_cmd (c, "save tracepoints");
15937 add_prefix_cmd ("breakpoint", class_maintenance, set_breakpoint_cmd, _("\
15938 Breakpoint specific settings\n\
15939 Configure various breakpoint-specific variables such as\n\
15940 pending breakpoint behavior"),
15941 &breakpoint_set_cmdlist, "set breakpoint ",
15942 0/*allow-unknown*/, &setlist);
15943 add_prefix_cmd ("breakpoint", class_maintenance, show_breakpoint_cmd, _("\
15944 Breakpoint specific settings\n\
15945 Configure various breakpoint-specific variables such as\n\
15946 pending breakpoint behavior"),
15947 &breakpoint_show_cmdlist, "show breakpoint ",
15948 0/*allow-unknown*/, &showlist);
15950 add_setshow_auto_boolean_cmd ("pending", no_class,
15951 &pending_break_support, _("\
15952 Set debugger's behavior regarding pending breakpoints."), _("\
15953 Show debugger's behavior regarding pending breakpoints."), _("\
15954 If on, an unrecognized breakpoint location will cause gdb to create a\n\
15955 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
15956 an error. If auto, an unrecognized breakpoint location results in a\n\
15957 user-query to see if a pending breakpoint should be created."),
15959 show_pending_break_support,
15960 &breakpoint_set_cmdlist,
15961 &breakpoint_show_cmdlist);
15963 pending_break_support = AUTO_BOOLEAN_AUTO;
15965 add_setshow_boolean_cmd ("auto-hw", no_class,
15966 &automatic_hardware_breakpoints, _("\
15967 Set automatic usage of hardware breakpoints."), _("\
15968 Show automatic usage of hardware breakpoints."), _("\
15969 If set, the debugger will automatically use hardware breakpoints for\n\
15970 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
15971 a warning will be emitted for such breakpoints."),
15973 show_automatic_hardware_breakpoints,
15974 &breakpoint_set_cmdlist,
15975 &breakpoint_show_cmdlist);
15977 add_setshow_boolean_cmd ("always-inserted", class_support,
15978 &always_inserted_mode, _("\
15979 Set mode for inserting breakpoints."), _("\
15980 Show mode for inserting breakpoints."), _("\
15981 When this mode is on, breakpoints are inserted immediately as soon as\n\
15982 they're created, kept inserted even when execution stops, and removed\n\
15983 only when the user deletes them. When this mode is off (the default),\n\
15984 breakpoints are inserted only when execution continues, and removed\n\
15985 when execution stops."),
15987 &show_always_inserted_mode,
15988 &breakpoint_set_cmdlist,
15989 &breakpoint_show_cmdlist);
15991 add_setshow_enum_cmd ("condition-evaluation", class_breakpoint,
15992 condition_evaluation_enums,
15993 &condition_evaluation_mode_1, _("\
15994 Set mode of breakpoint condition evaluation."), _("\
15995 Show mode of breakpoint condition evaluation."), _("\
15996 When this is set to \"host\", breakpoint conditions will be\n\
15997 evaluated on the host's side by GDB. When it is set to \"target\",\n\
15998 breakpoint conditions will be downloaded to the target (if the target\n\
15999 supports such feature) and conditions will be evaluated on the target's side.\n\
16000 If this is set to \"auto\" (default), this will be automatically set to\n\
16001 \"target\" if it supports condition evaluation, otherwise it will\n\
16002 be set to \"gdb\""),
16003 &set_condition_evaluation_mode,
16004 &show_condition_evaluation_mode,
16005 &breakpoint_set_cmdlist,
16006 &breakpoint_show_cmdlist);
16008 add_com ("break-range", class_breakpoint, break_range_command, _("\
16009 Set a breakpoint for an address range.\n\
16010 break-range START-LOCATION, END-LOCATION\n\
16011 where START-LOCATION and END-LOCATION can be one of the following:\n\
16012 LINENUM, for that line in the current file,\n\
16013 FILE:LINENUM, for that line in that file,\n\
16014 +OFFSET, for that number of lines after the current line\n\
16015 or the start of the range\n\
16016 FUNCTION, for the first line in that function,\n\
16017 FILE:FUNCTION, to distinguish among like-named static functions.\n\
16018 *ADDRESS, for the instruction at that address.\n\
16020 The breakpoint will stop execution of the inferior whenever it executes\n\
16021 an instruction at any address within the [START-LOCATION, END-LOCATION]\n\
16022 range (including START-LOCATION and END-LOCATION)."));
16024 c = add_com ("dprintf", class_breakpoint, dprintf_command, _("\
16025 Set a dynamic printf at specified location.\n\
16026 dprintf location,format string,arg1,arg2,...\n\
16027 location may be a linespec, explicit, or address location.\n"
16028 "\n" LOCATION_HELP_STRING));
16029 set_cmd_completer (c, location_completer);
16031 add_setshow_enum_cmd ("dprintf-style", class_support,
16032 dprintf_style_enums, &dprintf_style, _("\
16033 Set the style of usage for dynamic printf."), _("\
16034 Show the style of usage for dynamic printf."), _("\
16035 This setting chooses how GDB will do a dynamic printf.\n\
16036 If the value is \"gdb\", then the printing is done by GDB to its own\n\
16037 console, as with the \"printf\" command.\n\
16038 If the value is \"call\", the print is done by calling a function in your\n\
16039 program; by default printf(), but you can choose a different function or\n\
16040 output stream by setting dprintf-function and dprintf-channel."),
16041 update_dprintf_commands, NULL,
16042 &setlist, &showlist);
16044 dprintf_function = xstrdup ("printf");
16045 add_setshow_string_cmd ("dprintf-function", class_support,
16046 &dprintf_function, _("\
16047 Set the function to use for dynamic printf"), _("\
16048 Show the function to use for dynamic printf"), NULL,
16049 update_dprintf_commands, NULL,
16050 &setlist, &showlist);
16052 dprintf_channel = xstrdup ("");
16053 add_setshow_string_cmd ("dprintf-channel", class_support,
16054 &dprintf_channel, _("\
16055 Set the channel to use for dynamic printf"), _("\
16056 Show the channel to use for dynamic printf"), NULL,
16057 update_dprintf_commands, NULL,
16058 &setlist, &showlist);
16060 add_setshow_boolean_cmd ("disconnected-dprintf", no_class,
16061 &disconnected_dprintf, _("\
16062 Set whether dprintf continues after GDB disconnects."), _("\
16063 Show whether dprintf continues after GDB disconnects."), _("\
16064 Use this to let dprintf commands continue to hit and produce output\n\
16065 even if GDB disconnects or detaches from the target."),
16068 &setlist, &showlist);
16070 add_com ("agent-printf", class_vars, agent_printf_command, _("\
16071 agent-printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
16072 (target agent only) This is useful for formatted output in user-defined commands."));
16074 automatic_hardware_breakpoints = 1;
16076 observer_attach_about_to_proceed (breakpoint_about_to_proceed);
16077 observer_attach_thread_exit (remove_threaded_breakpoints);