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 struct address_space
*aspace
,
164 static int breakpoint_location_address_range_overlap (struct bp_location
*,
165 struct 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
;
3194 /* SystemTap probe points for longjmp (if any). */
3195 VEC (probe_p
) *longjmp_probes
;
3197 /* Minimal symbol for "std::terminate()" (if any). */
3198 struct bound_minimal_symbol terminate_msym
;
3200 /* Minimal symbol for "_Unwind_DebugHook" (if any). */
3201 struct bound_minimal_symbol exception_msym
;
3203 /* True if we have looked for exception probes. */
3204 int exception_searched
;
3206 /* SystemTap probe points for unwinding (if any). */
3207 VEC (probe_p
) *exception_probes
;
3210 static const struct objfile_data
*breakpoint_objfile_key
;
3212 /* Minimal symbol not found sentinel. */
3213 static struct minimal_symbol msym_not_found
;
3215 /* Returns TRUE if MSYM point to the "not found" sentinel. */
3218 msym_not_found_p (const struct minimal_symbol
*msym
)
3220 return msym
== &msym_not_found
;
3223 /* Return per-objfile data needed by breakpoint.c.
3224 Allocate the data if necessary. */
3226 static struct breakpoint_objfile_data
*
3227 get_breakpoint_objfile_data (struct objfile
*objfile
)
3229 struct breakpoint_objfile_data
*bp_objfile_data
;
3231 bp_objfile_data
= ((struct breakpoint_objfile_data
*)
3232 objfile_data (objfile
, breakpoint_objfile_key
));
3233 if (bp_objfile_data
== NULL
)
3236 XOBNEW (&objfile
->objfile_obstack
, struct breakpoint_objfile_data
);
3238 memset (bp_objfile_data
, 0, sizeof (*bp_objfile_data
));
3239 set_objfile_data (objfile
, breakpoint_objfile_key
, bp_objfile_data
);
3241 return bp_objfile_data
;
3245 free_breakpoint_probes (struct objfile
*obj
, void *data
)
3247 struct breakpoint_objfile_data
*bp_objfile_data
3248 = (struct breakpoint_objfile_data
*) data
;
3250 VEC_free (probe_p
, bp_objfile_data
->longjmp_probes
);
3251 VEC_free (probe_p
, bp_objfile_data
->exception_probes
);
3255 create_overlay_event_breakpoint (void)
3257 struct objfile
*objfile
;
3258 const char *const func_name
= "_ovly_debug_event";
3260 ALL_OBJFILES (objfile
)
3262 struct breakpoint
*b
;
3263 struct breakpoint_objfile_data
*bp_objfile_data
;
3265 struct explicit_location explicit_loc
;
3267 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3269 if (msym_not_found_p (bp_objfile_data
->overlay_msym
.minsym
))
3272 if (bp_objfile_data
->overlay_msym
.minsym
== NULL
)
3274 struct bound_minimal_symbol m
;
3276 m
= lookup_minimal_symbol_text (func_name
, objfile
);
3277 if (m
.minsym
== NULL
)
3279 /* Avoid future lookups in this objfile. */
3280 bp_objfile_data
->overlay_msym
.minsym
= &msym_not_found
;
3283 bp_objfile_data
->overlay_msym
= m
;
3286 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->overlay_msym
);
3287 b
= create_internal_breakpoint (get_objfile_arch (objfile
), addr
,
3289 &internal_breakpoint_ops
);
3290 initialize_explicit_location (&explicit_loc
);
3291 explicit_loc
.function_name
= ASTRDUP (func_name
);
3292 b
->location
= new_explicit_location (&explicit_loc
);
3294 if (overlay_debugging
== ovly_auto
)
3296 b
->enable_state
= bp_enabled
;
3297 overlay_events_enabled
= 1;
3301 b
->enable_state
= bp_disabled
;
3302 overlay_events_enabled
= 0;
3308 create_longjmp_master_breakpoint (void)
3310 struct program_space
*pspace
;
3312 scoped_restore_current_program_space restore_pspace
;
3314 ALL_PSPACES (pspace
)
3316 struct objfile
*objfile
;
3318 set_current_program_space (pspace
);
3320 ALL_OBJFILES (objfile
)
3323 struct gdbarch
*gdbarch
;
3324 struct breakpoint_objfile_data
*bp_objfile_data
;
3326 gdbarch
= get_objfile_arch (objfile
);
3328 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3330 if (!bp_objfile_data
->longjmp_searched
)
3334 ret
= find_probes_in_objfile (objfile
, "libc", "longjmp");
3337 /* We are only interested in checking one element. */
3338 struct probe
*p
= VEC_index (probe_p
, ret
, 0);
3340 if (!can_evaluate_probe_arguments (p
))
3342 /* We cannot use the probe interface here, because it does
3343 not know how to evaluate arguments. */
3344 VEC_free (probe_p
, ret
);
3348 bp_objfile_data
->longjmp_probes
= ret
;
3349 bp_objfile_data
->longjmp_searched
= 1;
3352 if (bp_objfile_data
->longjmp_probes
!= NULL
)
3355 struct probe
*probe
;
3356 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3359 VEC_iterate (probe_p
,
3360 bp_objfile_data
->longjmp_probes
,
3364 struct breakpoint
*b
;
3366 b
= create_internal_breakpoint (gdbarch
,
3367 get_probe_address (probe
,
3370 &internal_breakpoint_ops
);
3371 b
->location
= new_probe_location ("-probe-stap libc:longjmp");
3372 b
->enable_state
= bp_disabled
;
3378 if (!gdbarch_get_longjmp_target_p (gdbarch
))
3381 for (i
= 0; i
< NUM_LONGJMP_NAMES
; i
++)
3383 struct breakpoint
*b
;
3384 const char *func_name
;
3386 struct explicit_location explicit_loc
;
3388 if (msym_not_found_p (bp_objfile_data
->longjmp_msym
[i
].minsym
))
3391 func_name
= longjmp_names
[i
];
3392 if (bp_objfile_data
->longjmp_msym
[i
].minsym
== NULL
)
3394 struct bound_minimal_symbol m
;
3396 m
= lookup_minimal_symbol_text (func_name
, objfile
);
3397 if (m
.minsym
== NULL
)
3399 /* Prevent future lookups in this objfile. */
3400 bp_objfile_data
->longjmp_msym
[i
].minsym
= &msym_not_found
;
3403 bp_objfile_data
->longjmp_msym
[i
] = m
;
3406 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->longjmp_msym
[i
]);
3407 b
= create_internal_breakpoint (gdbarch
, addr
, bp_longjmp_master
,
3408 &internal_breakpoint_ops
);
3409 initialize_explicit_location (&explicit_loc
);
3410 explicit_loc
.function_name
= ASTRDUP (func_name
);
3411 b
->location
= new_explicit_location (&explicit_loc
);
3412 b
->enable_state
= bp_disabled
;
3418 /* Create a master std::terminate breakpoint. */
3420 create_std_terminate_master_breakpoint (void)
3422 struct program_space
*pspace
;
3423 const char *const func_name
= "std::terminate()";
3425 scoped_restore_current_program_space restore_pspace
;
3427 ALL_PSPACES (pspace
)
3429 struct objfile
*objfile
;
3432 set_current_program_space (pspace
);
3434 ALL_OBJFILES (objfile
)
3436 struct breakpoint
*b
;
3437 struct breakpoint_objfile_data
*bp_objfile_data
;
3438 struct explicit_location explicit_loc
;
3440 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3442 if (msym_not_found_p (bp_objfile_data
->terminate_msym
.minsym
))
3445 if (bp_objfile_data
->terminate_msym
.minsym
== NULL
)
3447 struct bound_minimal_symbol m
;
3449 m
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
3450 if (m
.minsym
== NULL
|| (MSYMBOL_TYPE (m
.minsym
) != mst_text
3451 && MSYMBOL_TYPE (m
.minsym
) != mst_file_text
))
3453 /* Prevent future lookups in this objfile. */
3454 bp_objfile_data
->terminate_msym
.minsym
= &msym_not_found
;
3457 bp_objfile_data
->terminate_msym
= m
;
3460 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->terminate_msym
);
3461 b
= create_internal_breakpoint (get_objfile_arch (objfile
), addr
,
3462 bp_std_terminate_master
,
3463 &internal_breakpoint_ops
);
3464 initialize_explicit_location (&explicit_loc
);
3465 explicit_loc
.function_name
= ASTRDUP (func_name
);
3466 b
->location
= new_explicit_location (&explicit_loc
);
3467 b
->enable_state
= bp_disabled
;
3472 /* Install a master breakpoint on the unwinder's debug hook. */
3475 create_exception_master_breakpoint (void)
3477 struct objfile
*objfile
;
3478 const char *const func_name
= "_Unwind_DebugHook";
3480 ALL_OBJFILES (objfile
)
3482 struct breakpoint
*b
;
3483 struct gdbarch
*gdbarch
;
3484 struct breakpoint_objfile_data
*bp_objfile_data
;
3486 struct explicit_location explicit_loc
;
3488 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3490 /* We prefer the SystemTap probe point if it exists. */
3491 if (!bp_objfile_data
->exception_searched
)
3495 ret
= find_probes_in_objfile (objfile
, "libgcc", "unwind");
3499 /* We are only interested in checking one element. */
3500 struct probe
*p
= VEC_index (probe_p
, ret
, 0);
3502 if (!can_evaluate_probe_arguments (p
))
3504 /* We cannot use the probe interface here, because it does
3505 not know how to evaluate arguments. */
3506 VEC_free (probe_p
, ret
);
3510 bp_objfile_data
->exception_probes
= ret
;
3511 bp_objfile_data
->exception_searched
= 1;
3514 if (bp_objfile_data
->exception_probes
!= NULL
)
3516 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3518 struct probe
*probe
;
3521 VEC_iterate (probe_p
,
3522 bp_objfile_data
->exception_probes
,
3526 struct breakpoint
*b
;
3528 b
= create_internal_breakpoint (gdbarch
,
3529 get_probe_address (probe
,
3531 bp_exception_master
,
3532 &internal_breakpoint_ops
);
3533 b
->location
= new_probe_location ("-probe-stap libgcc:unwind");
3534 b
->enable_state
= bp_disabled
;
3540 /* Otherwise, try the hook function. */
3542 if (msym_not_found_p (bp_objfile_data
->exception_msym
.minsym
))
3545 gdbarch
= get_objfile_arch (objfile
);
3547 if (bp_objfile_data
->exception_msym
.minsym
== NULL
)
3549 struct bound_minimal_symbol debug_hook
;
3551 debug_hook
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
3552 if (debug_hook
.minsym
== NULL
)
3554 bp_objfile_data
->exception_msym
.minsym
= &msym_not_found
;
3558 bp_objfile_data
->exception_msym
= debug_hook
;
3561 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->exception_msym
);
3562 addr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, addr
,
3564 b
= create_internal_breakpoint (gdbarch
, addr
, bp_exception_master
,
3565 &internal_breakpoint_ops
);
3566 initialize_explicit_location (&explicit_loc
);
3567 explicit_loc
.function_name
= ASTRDUP (func_name
);
3568 b
->location
= new_explicit_location (&explicit_loc
);
3569 b
->enable_state
= bp_disabled
;
3573 /* Does B have a location spec? */
3576 breakpoint_event_location_empty_p (const struct breakpoint
*b
)
3578 return b
->location
!= NULL
&& event_location_empty_p (b
->location
.get ());
3582 update_breakpoints_after_exec (void)
3584 struct breakpoint
*b
, *b_tmp
;
3585 struct bp_location
*bploc
, **bplocp_tmp
;
3587 /* We're about to delete breakpoints from GDB's lists. If the
3588 INSERTED flag is true, GDB will try to lift the breakpoints by
3589 writing the breakpoints' "shadow contents" back into memory. The
3590 "shadow contents" are NOT valid after an exec, so GDB should not
3591 do that. Instead, the target is responsible from marking
3592 breakpoints out as soon as it detects an exec. We don't do that
3593 here instead, because there may be other attempts to delete
3594 breakpoints after detecting an exec and before reaching here. */
3595 ALL_BP_LOCATIONS (bploc
, bplocp_tmp
)
3596 if (bploc
->pspace
== current_program_space
)
3597 gdb_assert (!bploc
->inserted
);
3599 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
3601 if (b
->pspace
!= current_program_space
)
3604 /* Solib breakpoints must be explicitly reset after an exec(). */
3605 if (b
->type
== bp_shlib_event
)
3607 delete_breakpoint (b
);
3611 /* JIT breakpoints must be explicitly reset after an exec(). */
3612 if (b
->type
== bp_jit_event
)
3614 delete_breakpoint (b
);
3618 /* Thread event breakpoints must be set anew after an exec(),
3619 as must overlay event and longjmp master breakpoints. */
3620 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
3621 || b
->type
== bp_longjmp_master
|| b
->type
== bp_std_terminate_master
3622 || b
->type
== bp_exception_master
)
3624 delete_breakpoint (b
);
3628 /* Step-resume breakpoints are meaningless after an exec(). */
3629 if (b
->type
== bp_step_resume
|| b
->type
== bp_hp_step_resume
)
3631 delete_breakpoint (b
);
3635 /* Just like single-step breakpoints. */
3636 if (b
->type
== bp_single_step
)
3638 delete_breakpoint (b
);
3642 /* Longjmp and longjmp-resume breakpoints are also meaningless
3644 if (b
->type
== bp_longjmp
|| b
->type
== bp_longjmp_resume
3645 || b
->type
== bp_longjmp_call_dummy
3646 || b
->type
== bp_exception
|| b
->type
== bp_exception_resume
)
3648 delete_breakpoint (b
);
3652 if (b
->type
== bp_catchpoint
)
3654 /* For now, none of the bp_catchpoint breakpoints need to
3655 do anything at this point. In the future, if some of
3656 the catchpoints need to something, we will need to add
3657 a new method, and call this method from here. */
3661 /* bp_finish is a special case. The only way we ought to be able
3662 to see one of these when an exec() has happened, is if the user
3663 caught a vfork, and then said "finish". Ordinarily a finish just
3664 carries them to the call-site of the current callee, by setting
3665 a temporary bp there and resuming. But in this case, the finish
3666 will carry them entirely through the vfork & exec.
3668 We don't want to allow a bp_finish to remain inserted now. But
3669 we can't safely delete it, 'cause finish_command has a handle to
3670 the bp on a bpstat, and will later want to delete it. There's a
3671 chance (and I've seen it happen) that if we delete the bp_finish
3672 here, that its storage will get reused by the time finish_command
3673 gets 'round to deleting the "use to be a bp_finish" breakpoint.
3674 We really must allow finish_command to delete a bp_finish.
3676 In the absence of a general solution for the "how do we know
3677 it's safe to delete something others may have handles to?"
3678 problem, what we'll do here is just uninsert the bp_finish, and
3679 let finish_command delete it.
3681 (We know the bp_finish is "doomed" in the sense that it's
3682 momentary, and will be deleted as soon as finish_command sees
3683 the inferior stopped. So it doesn't matter that the bp's
3684 address is probably bogus in the new a.out, unlike e.g., the
3685 solib breakpoints.) */
3687 if (b
->type
== bp_finish
)
3692 /* Without a symbolic address, we have little hope of the
3693 pre-exec() address meaning the same thing in the post-exec()
3695 if (breakpoint_event_location_empty_p (b
))
3697 delete_breakpoint (b
);
3704 detach_breakpoints (ptid_t ptid
)
3706 struct bp_location
*bl
, **blp_tmp
;
3708 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
3709 struct inferior
*inf
= current_inferior ();
3711 if (ptid_get_pid (ptid
) == ptid_get_pid (inferior_ptid
))
3712 error (_("Cannot detach breakpoints of inferior_ptid"));
3714 /* Set inferior_ptid; remove_breakpoint_1 uses this global. */
3715 inferior_ptid
= ptid
;
3716 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3718 if (bl
->pspace
!= inf
->pspace
)
3721 /* This function must physically remove breakpoints locations
3722 from the specified ptid, without modifying the breakpoint
3723 package's state. Locations of type bp_loc_other are only
3724 maintained at GDB side. So, there is no need to remove
3725 these bp_loc_other locations. Moreover, removing these
3726 would modify the breakpoint package's state. */
3727 if (bl
->loc_type
== bp_loc_other
)
3731 val
|= remove_breakpoint_1 (bl
, DETACH_BREAKPOINT
);
3737 /* Remove the breakpoint location BL from the current address space.
3738 Note that this is used to detach breakpoints from a child fork.
3739 When we get here, the child isn't in the inferior list, and neither
3740 do we have objects to represent its address space --- we should
3741 *not* look at bl->pspace->aspace here. */
3744 remove_breakpoint_1 (struct bp_location
*bl
, enum remove_bp_reason reason
)
3748 /* BL is never in moribund_locations by our callers. */
3749 gdb_assert (bl
->owner
!= NULL
);
3751 /* The type of none suggests that owner is actually deleted.
3752 This should not ever happen. */
3753 gdb_assert (bl
->owner
->type
!= bp_none
);
3755 if (bl
->loc_type
== bp_loc_software_breakpoint
3756 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
3758 /* "Normal" instruction breakpoint: either the standard
3759 trap-instruction bp (bp_breakpoint), or a
3760 bp_hardware_breakpoint. */
3762 /* First check to see if we have to handle an overlay. */
3763 if (overlay_debugging
== ovly_off
3764 || bl
->section
== NULL
3765 || !(section_is_overlay (bl
->section
)))
3767 /* No overlay handling: just remove the breakpoint. */
3769 /* If we're trying to uninsert a memory breakpoint that we
3770 know is set in a dynamic object that is marked
3771 shlib_disabled, then either the dynamic object was
3772 removed with "remove-symbol-file" or with
3773 "nosharedlibrary". In the former case, we don't know
3774 whether another dynamic object might have loaded over the
3775 breakpoint's address -- the user might well let us know
3776 about it next with add-symbol-file (the whole point of
3777 add-symbol-file is letting the user manually maintain a
3778 list of dynamically loaded objects). If we have the
3779 breakpoint's shadow memory, that is, this is a software
3780 breakpoint managed by GDB, check whether the breakpoint
3781 is still inserted in memory, to avoid overwriting wrong
3782 code with stale saved shadow contents. Note that HW
3783 breakpoints don't have shadow memory, as they're
3784 implemented using a mechanism that is not dependent on
3785 being able to modify the target's memory, and as such
3786 they should always be removed. */
3787 if (bl
->shlib_disabled
3788 && bl
->target_info
.shadow_len
!= 0
3789 && !memory_validate_breakpoint (bl
->gdbarch
, &bl
->target_info
))
3792 val
= bl
->owner
->ops
->remove_location (bl
, reason
);
3796 /* This breakpoint is in an overlay section.
3797 Did we set a breakpoint at the LMA? */
3798 if (!overlay_events_enabled
)
3800 /* Yes -- overlay event support is not active, so we
3801 should have set a breakpoint at the LMA. Remove it.
3803 /* Ignore any failures: if the LMA is in ROM, we will
3804 have already warned when we failed to insert it. */
3805 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
3806 target_remove_hw_breakpoint (bl
->gdbarch
,
3807 &bl
->overlay_target_info
);
3809 target_remove_breakpoint (bl
->gdbarch
,
3810 &bl
->overlay_target_info
,
3813 /* Did we set a breakpoint at the VMA?
3814 If so, we will have marked the breakpoint 'inserted'. */
3817 /* Yes -- remove it. Previously we did not bother to
3818 remove the breakpoint if the section had been
3819 unmapped, but let's not rely on that being safe. We
3820 don't know what the overlay manager might do. */
3822 /* However, we should remove *software* breakpoints only
3823 if the section is still mapped, or else we overwrite
3824 wrong code with the saved shadow contents. */
3825 if (bl
->loc_type
== bp_loc_hardware_breakpoint
3826 || section_is_mapped (bl
->section
))
3827 val
= bl
->owner
->ops
->remove_location (bl
, reason
);
3833 /* No -- not inserted, so no need to remove. No error. */
3838 /* In some cases, we might not be able to remove a breakpoint in
3839 a shared library that has already been removed, but we have
3840 not yet processed the shlib unload event. Similarly for an
3841 unloaded add-symbol-file object - the user might not yet have
3842 had the chance to remove-symbol-file it. shlib_disabled will
3843 be set if the library/object has already been removed, but
3844 the breakpoint hasn't been uninserted yet, e.g., after
3845 "nosharedlibrary" or "remove-symbol-file" with breakpoints
3846 always-inserted mode. */
3848 && (bl
->loc_type
== bp_loc_software_breakpoint
3849 && (bl
->shlib_disabled
3850 || solib_name_from_address (bl
->pspace
, bl
->address
)
3851 || shared_objfile_contains_address_p (bl
->pspace
,
3857 bl
->inserted
= (reason
== DETACH_BREAKPOINT
);
3859 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
)
3861 gdb_assert (bl
->owner
->ops
!= NULL
3862 && bl
->owner
->ops
->remove_location
!= NULL
);
3864 bl
->inserted
= (reason
== DETACH_BREAKPOINT
);
3865 bl
->owner
->ops
->remove_location (bl
, reason
);
3867 /* Failure to remove any of the hardware watchpoints comes here. */
3868 if (reason
== REMOVE_BREAKPOINT
&& bl
->inserted
)
3869 warning (_("Could not remove hardware watchpoint %d."),
3872 else if (bl
->owner
->type
== bp_catchpoint
3873 && breakpoint_enabled (bl
->owner
)
3876 gdb_assert (bl
->owner
->ops
!= NULL
3877 && bl
->owner
->ops
->remove_location
!= NULL
);
3879 val
= bl
->owner
->ops
->remove_location (bl
, reason
);
3883 bl
->inserted
= (reason
== DETACH_BREAKPOINT
);
3890 remove_breakpoint (struct bp_location
*bl
)
3892 /* BL is never in moribund_locations by our callers. */
3893 gdb_assert (bl
->owner
!= NULL
);
3895 /* The type of none suggests that owner is actually deleted.
3896 This should not ever happen. */
3897 gdb_assert (bl
->owner
->type
!= bp_none
);
3899 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
3901 switch_to_program_space_and_thread (bl
->pspace
);
3903 return remove_breakpoint_1 (bl
, REMOVE_BREAKPOINT
);
3906 /* Clear the "inserted" flag in all breakpoints. */
3909 mark_breakpoints_out (void)
3911 struct bp_location
*bl
, **blp_tmp
;
3913 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3914 if (bl
->pspace
== current_program_space
)
3918 /* Clear the "inserted" flag in all breakpoints and delete any
3919 breakpoints which should go away between runs of the program.
3921 Plus other such housekeeping that has to be done for breakpoints
3924 Note: this function gets called at the end of a run (by
3925 generic_mourn_inferior) and when a run begins (by
3926 init_wait_for_inferior). */
3931 breakpoint_init_inferior (enum inf_context context
)
3933 struct breakpoint
*b
, *b_tmp
;
3934 struct bp_location
*bl
;
3936 struct program_space
*pspace
= current_program_space
;
3938 /* If breakpoint locations are shared across processes, then there's
3940 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
3943 mark_breakpoints_out ();
3945 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
3947 if (b
->loc
&& b
->loc
->pspace
!= pspace
)
3953 case bp_longjmp_call_dummy
:
3955 /* If the call dummy breakpoint is at the entry point it will
3956 cause problems when the inferior is rerun, so we better get
3959 case bp_watchpoint_scope
:
3961 /* Also get rid of scope breakpoints. */
3963 case bp_shlib_event
:
3965 /* Also remove solib event breakpoints. Their addresses may
3966 have changed since the last time we ran the program.
3967 Actually we may now be debugging against different target;
3968 and so the solib backend that installed this breakpoint may
3969 not be used in by the target. E.g.,
3971 (gdb) file prog-linux
3972 (gdb) run # native linux target
3975 (gdb) file prog-win.exe
3976 (gdb) tar rem :9999 # remote Windows gdbserver.
3979 case bp_step_resume
:
3981 /* Also remove step-resume breakpoints. */
3983 case bp_single_step
:
3985 /* Also remove single-step breakpoints. */
3987 delete_breakpoint (b
);
3991 case bp_hardware_watchpoint
:
3992 case bp_read_watchpoint
:
3993 case bp_access_watchpoint
:
3995 struct watchpoint
*w
= (struct watchpoint
*) b
;
3997 /* Likewise for watchpoints on local expressions. */
3998 if (w
->exp_valid_block
!= NULL
)
3999 delete_breakpoint (b
);
4002 /* Get rid of existing locations, which are no longer
4003 valid. New ones will be created in
4004 update_watchpoint, when the inferior is restarted.
4005 The next update_global_location_list call will
4006 garbage collect them. */
4009 if (context
== inf_starting
)
4011 /* Reset val field to force reread of starting value in
4012 insert_breakpoints. */
4014 value_free (w
->val
);
4026 /* Get rid of the moribund locations. */
4027 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, bl
); ++ix
)
4028 decref_bp_location (&bl
);
4029 VEC_free (bp_location_p
, moribund_locations
);
4032 /* These functions concern about actual breakpoints inserted in the
4033 target --- to e.g. check if we need to do decr_pc adjustment or if
4034 we need to hop over the bkpt --- so we check for address space
4035 match, not program space. */
4037 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
4038 exists at PC. It returns ordinary_breakpoint_here if it's an
4039 ordinary breakpoint, or permanent_breakpoint_here if it's a
4040 permanent breakpoint.
4041 - When continuing from a location with an ordinary breakpoint, we
4042 actually single step once before calling insert_breakpoints.
4043 - When continuing from a location with a permanent breakpoint, we
4044 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
4045 the target, to advance the PC past the breakpoint. */
4047 enum breakpoint_here
4048 breakpoint_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
4050 struct bp_location
*bl
, **blp_tmp
;
4051 int any_breakpoint_here
= 0;
4053 ALL_BP_LOCATIONS (bl
, blp_tmp
)
4055 if (bl
->loc_type
!= bp_loc_software_breakpoint
4056 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4059 /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
4060 if ((breakpoint_enabled (bl
->owner
)
4062 && breakpoint_location_address_match (bl
, aspace
, pc
))
4064 if (overlay_debugging
4065 && section_is_overlay (bl
->section
)
4066 && !section_is_mapped (bl
->section
))
4067 continue; /* unmapped overlay -- can't be a match */
4068 else if (bl
->permanent
)
4069 return permanent_breakpoint_here
;
4071 any_breakpoint_here
= 1;
4075 return any_breakpoint_here
? ordinary_breakpoint_here
: no_breakpoint_here
;
4078 /* See breakpoint.h. */
4081 breakpoint_in_range_p (struct address_space
*aspace
,
4082 CORE_ADDR addr
, ULONGEST len
)
4084 struct bp_location
*bl
, **blp_tmp
;
4086 ALL_BP_LOCATIONS (bl
, blp_tmp
)
4088 if (bl
->loc_type
!= bp_loc_software_breakpoint
4089 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4092 if ((breakpoint_enabled (bl
->owner
)
4094 && breakpoint_location_address_range_overlap (bl
, aspace
,
4097 if (overlay_debugging
4098 && section_is_overlay (bl
->section
)
4099 && !section_is_mapped (bl
->section
))
4101 /* Unmapped overlay -- can't be a match. */
4112 /* Return true if there's a moribund breakpoint at PC. */
4115 moribund_breakpoint_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
4117 struct bp_location
*loc
;
4120 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
4121 if (breakpoint_location_address_match (loc
, aspace
, pc
))
4127 /* Returns non-zero iff BL is inserted at PC, in address space
4131 bp_location_inserted_here_p (struct bp_location
*bl
,
4132 struct address_space
*aspace
, CORE_ADDR pc
)
4135 && breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
4138 if (overlay_debugging
4139 && section_is_overlay (bl
->section
)
4140 && !section_is_mapped (bl
->section
))
4141 return 0; /* unmapped overlay -- can't be a match */
4148 /* Returns non-zero iff there's a breakpoint inserted at PC. */
4151 breakpoint_inserted_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
4153 struct bp_location
**blp
, **blp_tmp
= NULL
;
4155 ALL_BP_LOCATIONS_AT_ADDR (blp
, blp_tmp
, pc
)
4157 struct bp_location
*bl
= *blp
;
4159 if (bl
->loc_type
!= bp_loc_software_breakpoint
4160 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4163 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4169 /* This function returns non-zero iff there is a software breakpoint
4173 software_breakpoint_inserted_here_p (struct address_space
*aspace
,
4176 struct bp_location
**blp
, **blp_tmp
= NULL
;
4178 ALL_BP_LOCATIONS_AT_ADDR (blp
, blp_tmp
, pc
)
4180 struct bp_location
*bl
= *blp
;
4182 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
4185 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4192 /* See breakpoint.h. */
4195 hardware_breakpoint_inserted_here_p (struct address_space
*aspace
,
4198 struct bp_location
**blp
, **blp_tmp
= NULL
;
4200 ALL_BP_LOCATIONS_AT_ADDR (blp
, blp_tmp
, pc
)
4202 struct bp_location
*bl
= *blp
;
4204 if (bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4207 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4215 hardware_watchpoint_inserted_in_range (struct address_space
*aspace
,
4216 CORE_ADDR addr
, ULONGEST len
)
4218 struct breakpoint
*bpt
;
4220 ALL_BREAKPOINTS (bpt
)
4222 struct bp_location
*loc
;
4224 if (bpt
->type
!= bp_hardware_watchpoint
4225 && bpt
->type
!= bp_access_watchpoint
)
4228 if (!breakpoint_enabled (bpt
))
4231 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
4232 if (loc
->pspace
->aspace
== aspace
&& loc
->inserted
)
4236 /* Check for intersection. */
4237 l
= std::max
<CORE_ADDR
> (loc
->address
, addr
);
4238 h
= std::min
<CORE_ADDR
> (loc
->address
+ loc
->length
, addr
+ len
);
4247 /* bpstat stuff. External routines' interfaces are documented
4251 is_catchpoint (struct breakpoint
*ep
)
4253 return (ep
->type
== bp_catchpoint
);
4256 /* Frees any storage that is part of a bpstat. Does not walk the
4259 bpstats::~bpstats ()
4261 if (old_val
!= NULL
)
4262 value_free (old_val
);
4263 if (bp_location_at
!= NULL
)
4264 decref_bp_location (&bp_location_at
);
4267 /* Clear a bpstat so that it says we are not at any breakpoint.
4268 Also free any storage that is part of a bpstat. */
4271 bpstat_clear (bpstat
*bsp
)
4288 bpstats::bpstats (const bpstats
&other
)
4290 bp_location_at (other
.bp_location_at
),
4291 breakpoint_at (other
.breakpoint_at
),
4292 commands (other
.commands
),
4293 old_val (other
.old_val
),
4294 print (other
.print
),
4296 print_it (other
.print_it
)
4298 if (old_val
!= NULL
)
4300 old_val
= value_copy (old_val
);
4301 release_value (old_val
);
4303 incref_bp_location (bp_location_at
);
4306 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
4307 is part of the bpstat is copied as well. */
4310 bpstat_copy (bpstat bs
)
4314 bpstat retval
= NULL
;
4319 for (; bs
!= NULL
; bs
= bs
->next
)
4321 tmp
= new bpstats (*bs
);
4324 /* This is the first thing in the chain. */
4334 /* Find the bpstat associated with this breakpoint. */
4337 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
4342 for (; bsp
!= NULL
; bsp
= bsp
->next
)
4344 if (bsp
->breakpoint_at
== breakpoint
)
4350 /* See breakpoint.h. */
4353 bpstat_explains_signal (bpstat bsp
, enum gdb_signal sig
)
4355 for (; bsp
!= NULL
; bsp
= bsp
->next
)
4357 if (bsp
->breakpoint_at
== NULL
)
4359 /* A moribund location can never explain a signal other than
4361 if (sig
== GDB_SIGNAL_TRAP
)
4366 if (bsp
->breakpoint_at
->ops
->explains_signal (bsp
->breakpoint_at
,
4375 /* Put in *NUM the breakpoint number of the first breakpoint we are
4376 stopped at. *BSP upon return is a bpstat which points to the
4377 remaining breakpoints stopped at (but which is not guaranteed to be
4378 good for anything but further calls to bpstat_num).
4380 Return 0 if passed a bpstat which does not indicate any breakpoints.
4381 Return -1 if stopped at a breakpoint that has been deleted since
4383 Return 1 otherwise. */
4386 bpstat_num (bpstat
*bsp
, int *num
)
4388 struct breakpoint
*b
;
4391 return 0; /* No more breakpoint values */
4393 /* We assume we'll never have several bpstats that correspond to a
4394 single breakpoint -- otherwise, this function might return the
4395 same number more than once and this will look ugly. */
4396 b
= (*bsp
)->breakpoint_at
;
4397 *bsp
= (*bsp
)->next
;
4399 return -1; /* breakpoint that's been deleted since */
4401 *num
= b
->number
; /* We have its number */
4405 /* See breakpoint.h. */
4408 bpstat_clear_actions (void)
4410 struct thread_info
*tp
;
4413 if (ptid_equal (inferior_ptid
, null_ptid
))
4416 tp
= find_thread_ptid (inferior_ptid
);
4420 for (bs
= tp
->control
.stop_bpstat
; bs
!= NULL
; bs
= bs
->next
)
4422 bs
->commands
= NULL
;
4424 if (bs
->old_val
!= NULL
)
4426 value_free (bs
->old_val
);
4432 /* Called when a command is about to proceed the inferior. */
4435 breakpoint_about_to_proceed (void)
4437 if (!ptid_equal (inferior_ptid
, null_ptid
))
4439 struct thread_info
*tp
= inferior_thread ();
4441 /* Allow inferior function calls in breakpoint commands to not
4442 interrupt the command list. When the call finishes
4443 successfully, the inferior will be standing at the same
4444 breakpoint as if nothing happened. */
4445 if (tp
->control
.in_infcall
)
4449 breakpoint_proceeded
= 1;
4452 /* Return non-zero iff CMD as the first line of a command sequence is `silent'
4453 or its equivalent. */
4456 command_line_is_silent (struct command_line
*cmd
)
4458 return cmd
&& (strcmp ("silent", cmd
->line
) == 0);
4461 /* Execute all the commands associated with all the breakpoints at
4462 this location. Any of these commands could cause the process to
4463 proceed beyond this point, etc. We look out for such changes by
4464 checking the global "breakpoint_proceeded" after each command.
4466 Returns true if a breakpoint command resumed the inferior. In that
4467 case, it is the caller's responsibility to recall it again with the
4468 bpstat of the current thread. */
4471 bpstat_do_actions_1 (bpstat
*bsp
)
4476 /* Avoid endless recursion if a `source' command is contained
4478 if (executing_breakpoint_commands
)
4481 scoped_restore save_executing
4482 = make_scoped_restore (&executing_breakpoint_commands
, 1);
4484 scoped_restore preventer
= prevent_dont_repeat ();
4486 /* This pointer will iterate over the list of bpstat's. */
4489 breakpoint_proceeded
= 0;
4490 for (; bs
!= NULL
; bs
= bs
->next
)
4492 struct command_line
*cmd
= NULL
;
4494 /* Take ownership of the BSP's command tree, if it has one.
4496 The command tree could legitimately contain commands like
4497 'step' and 'next', which call clear_proceed_status, which
4498 frees stop_bpstat's command tree. To make sure this doesn't
4499 free the tree we're executing out from under us, we need to
4500 take ownership of the tree ourselves. Since a given bpstat's
4501 commands are only executed once, we don't need to copy it; we
4502 can clear the pointer in the bpstat, and make sure we free
4503 the tree when we're done. */
4504 counted_command_line ccmd
= bs
->commands
;
4505 bs
->commands
= NULL
;
4508 if (command_line_is_silent (cmd
))
4510 /* The action has been already done by bpstat_stop_status. */
4516 execute_control_command (cmd
);
4518 if (breakpoint_proceeded
)
4524 if (breakpoint_proceeded
)
4526 if (current_ui
->async
)
4527 /* If we are in async mode, then the target might be still
4528 running, not stopped at any breakpoint, so nothing for
4529 us to do here -- just return to the event loop. */
4532 /* In sync mode, when execute_control_command returns
4533 we're already standing on the next breakpoint.
4534 Breakpoint commands for that stop were not run, since
4535 execute_command does not run breakpoint commands --
4536 only command_line_handler does, but that one is not
4537 involved in execution of breakpoint commands. So, we
4538 can now execute breakpoint commands. It should be
4539 noted that making execute_command do bpstat actions is
4540 not an option -- in this case we'll have recursive
4541 invocation of bpstat for each breakpoint with a
4542 command, and can easily blow up GDB stack. Instead, we
4543 return true, which will trigger the caller to recall us
4544 with the new stop_bpstat. */
4553 bpstat_do_actions (void)
4555 struct cleanup
*cleanup_if_error
= make_bpstat_clear_actions_cleanup ();
4557 /* Do any commands attached to breakpoint we are stopped at. */
4558 while (!ptid_equal (inferior_ptid
, null_ptid
)
4559 && target_has_execution
4560 && !is_exited (inferior_ptid
)
4561 && !is_executing (inferior_ptid
))
4562 /* Since in sync mode, bpstat_do_actions may resume the inferior,
4563 and only return when it is stopped at the next breakpoint, we
4564 keep doing breakpoint actions until it returns false to
4565 indicate the inferior was not resumed. */
4566 if (!bpstat_do_actions_1 (&inferior_thread ()->control
.stop_bpstat
))
4569 discard_cleanups (cleanup_if_error
);
4572 /* Print out the (old or new) value associated with a watchpoint. */
4575 watchpoint_value_print (struct value
*val
, struct ui_file
*stream
)
4578 fprintf_unfiltered (stream
, _("<unreadable>"));
4581 struct value_print_options opts
;
4582 get_user_print_options (&opts
);
4583 value_print (val
, stream
, &opts
);
4587 /* Print the "Thread ID hit" part of "Thread ID hit Breakpoint N" if
4588 debugging multiple threads. */
4591 maybe_print_thread_hit_breakpoint (struct ui_out
*uiout
)
4593 if (uiout
->is_mi_like_p ())
4598 if (show_thread_that_caused_stop ())
4601 struct thread_info
*thr
= inferior_thread ();
4603 uiout
->text ("Thread ");
4604 uiout
->field_fmt ("thread-id", "%s", print_thread_id (thr
));
4606 name
= thr
->name
!= NULL
? thr
->name
: target_thread_name (thr
);
4609 uiout
->text (" \"");
4610 uiout
->field_fmt ("name", "%s", name
);
4614 uiout
->text (" hit ");
4618 /* Generic routine for printing messages indicating why we
4619 stopped. The behavior of this function depends on the value
4620 'print_it' in the bpstat structure. Under some circumstances we
4621 may decide not to print anything here and delegate the task to
4624 static enum print_stop_action
4625 print_bp_stop_message (bpstat bs
)
4627 switch (bs
->print_it
)
4630 /* Nothing should be printed for this bpstat entry. */
4631 return PRINT_UNKNOWN
;
4635 /* We still want to print the frame, but we already printed the
4636 relevant messages. */
4637 return PRINT_SRC_AND_LOC
;
4640 case print_it_normal
:
4642 struct breakpoint
*b
= bs
->breakpoint_at
;
4644 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
4645 which has since been deleted. */
4647 return PRINT_UNKNOWN
;
4649 /* Normal case. Call the breakpoint's print_it method. */
4650 return b
->ops
->print_it (bs
);
4655 internal_error (__FILE__
, __LINE__
,
4656 _("print_bp_stop_message: unrecognized enum value"));
4661 /* A helper function that prints a shared library stopped event. */
4664 print_solib_event (int is_catchpoint
)
4667 = !VEC_empty (char_ptr
, current_program_space
->deleted_solibs
);
4669 = !VEC_empty (so_list_ptr
, current_program_space
->added_solibs
);
4673 if (any_added
|| any_deleted
)
4674 current_uiout
->text (_("Stopped due to shared library event:\n"));
4676 current_uiout
->text (_("Stopped due to shared library event (no "
4677 "libraries added or removed)\n"));
4680 if (current_uiout
->is_mi_like_p ())
4681 current_uiout
->field_string ("reason",
4682 async_reason_lookup (EXEC_ASYNC_SOLIB_EVENT
));
4689 current_uiout
->text (_(" Inferior unloaded "));
4690 ui_out_emit_list
list_emitter (current_uiout
, "removed");
4692 VEC_iterate (char_ptr
, current_program_space
->deleted_solibs
,
4697 current_uiout
->text (" ");
4698 current_uiout
->field_string ("library", name
);
4699 current_uiout
->text ("\n");
4705 struct so_list
*iter
;
4708 current_uiout
->text (_(" Inferior loaded "));
4709 ui_out_emit_list
list_emitter (current_uiout
, "added");
4711 VEC_iterate (so_list_ptr
, current_program_space
->added_solibs
,
4716 current_uiout
->text (" ");
4717 current_uiout
->field_string ("library", iter
->so_name
);
4718 current_uiout
->text ("\n");
4723 /* Print a message indicating what happened. This is called from
4724 normal_stop(). The input to this routine is the head of the bpstat
4725 list - a list of the eventpoints that caused this stop. KIND is
4726 the target_waitkind for the stopping event. This
4727 routine calls the generic print routine for printing a message
4728 about reasons for stopping. This will print (for example) the
4729 "Breakpoint n," part of the output. The return value of this
4732 PRINT_UNKNOWN: Means we printed nothing.
4733 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
4734 code to print the location. An example is
4735 "Breakpoint 1, " which should be followed by
4737 PRINT_SRC_ONLY: Means we printed something, but there is no need
4738 to also print the location part of the message.
4739 An example is the catch/throw messages, which
4740 don't require a location appended to the end.
4741 PRINT_NOTHING: We have done some printing and we don't need any
4742 further info to be printed. */
4744 enum print_stop_action
4745 bpstat_print (bpstat bs
, int kind
)
4747 enum print_stop_action val
;
4749 /* Maybe another breakpoint in the chain caused us to stop.
4750 (Currently all watchpoints go on the bpstat whether hit or not.
4751 That probably could (should) be changed, provided care is taken
4752 with respect to bpstat_explains_signal). */
4753 for (; bs
; bs
= bs
->next
)
4755 val
= print_bp_stop_message (bs
);
4756 if (val
== PRINT_SRC_ONLY
4757 || val
== PRINT_SRC_AND_LOC
4758 || val
== PRINT_NOTHING
)
4762 /* If we had hit a shared library event breakpoint,
4763 print_bp_stop_message would print out this message. If we hit an
4764 OS-level shared library event, do the same thing. */
4765 if (kind
== TARGET_WAITKIND_LOADED
)
4767 print_solib_event (0);
4768 return PRINT_NOTHING
;
4771 /* We reached the end of the chain, or we got a null BS to start
4772 with and nothing was printed. */
4773 return PRINT_UNKNOWN
;
4776 /* Evaluate the boolean expression EXP and return the result. */
4779 breakpoint_cond_eval (expression
*exp
)
4781 struct value
*mark
= value_mark ();
4782 bool res
= value_true (evaluate_expression (exp
));
4784 value_free_to_mark (mark
);
4788 /* Allocate a new bpstat. Link it to the FIFO list by BS_LINK_POINTER. */
4790 bpstats::bpstats (struct bp_location
*bl
, bpstat
**bs_link_pointer
)
4792 bp_location_at (bl
),
4793 breakpoint_at (bl
->owner
),
4798 print_it (print_it_normal
)
4800 incref_bp_location (bl
);
4801 **bs_link_pointer
= this;
4802 *bs_link_pointer
= &next
;
4807 bp_location_at (NULL
),
4808 breakpoint_at (NULL
),
4813 print_it (print_it_normal
)
4817 /* The target has stopped with waitstatus WS. Check if any hardware
4818 watchpoints have triggered, according to the target. */
4821 watchpoints_triggered (struct target_waitstatus
*ws
)
4823 int stopped_by_watchpoint
= target_stopped_by_watchpoint ();
4825 struct breakpoint
*b
;
4827 if (!stopped_by_watchpoint
)
4829 /* We were not stopped by a watchpoint. Mark all watchpoints
4830 as not triggered. */
4832 if (is_hardware_watchpoint (b
))
4834 struct watchpoint
*w
= (struct watchpoint
*) b
;
4836 w
->watchpoint_triggered
= watch_triggered_no
;
4842 if (!target_stopped_data_address (¤t_target
, &addr
))
4844 /* We were stopped by a watchpoint, but we don't know where.
4845 Mark all watchpoints as unknown. */
4847 if (is_hardware_watchpoint (b
))
4849 struct watchpoint
*w
= (struct watchpoint
*) b
;
4851 w
->watchpoint_triggered
= watch_triggered_unknown
;
4857 /* The target could report the data address. Mark watchpoints
4858 affected by this data address as triggered, and all others as not
4862 if (is_hardware_watchpoint (b
))
4864 struct watchpoint
*w
= (struct watchpoint
*) b
;
4865 struct bp_location
*loc
;
4867 w
->watchpoint_triggered
= watch_triggered_no
;
4868 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
4870 if (is_masked_watchpoint (b
))
4872 CORE_ADDR newaddr
= addr
& w
->hw_wp_mask
;
4873 CORE_ADDR start
= loc
->address
& w
->hw_wp_mask
;
4875 if (newaddr
== start
)
4877 w
->watchpoint_triggered
= watch_triggered_yes
;
4881 /* Exact match not required. Within range is sufficient. */
4882 else if (target_watchpoint_addr_within_range (¤t_target
,
4886 w
->watchpoint_triggered
= watch_triggered_yes
;
4895 /* Possible return values for watchpoint_check. */
4896 enum wp_check_result
4898 /* The watchpoint has been deleted. */
4901 /* The value has changed. */
4902 WP_VALUE_CHANGED
= 2,
4904 /* The value has not changed. */
4905 WP_VALUE_NOT_CHANGED
= 3,
4907 /* Ignore this watchpoint, no matter if the value changed or not. */
4911 #define BP_TEMPFLAG 1
4912 #define BP_HARDWAREFLAG 2
4914 /* Evaluate watchpoint condition expression and check if its value
4917 static wp_check_result
4918 watchpoint_check (bpstat bs
)
4920 struct watchpoint
*b
;
4921 struct frame_info
*fr
;
4922 int within_current_scope
;
4924 /* BS is built from an existing struct breakpoint. */
4925 gdb_assert (bs
->breakpoint_at
!= NULL
);
4926 b
= (struct watchpoint
*) bs
->breakpoint_at
;
4928 /* If this is a local watchpoint, we only want to check if the
4929 watchpoint frame is in scope if the current thread is the thread
4930 that was used to create the watchpoint. */
4931 if (!watchpoint_in_thread_scope (b
))
4934 if (b
->exp_valid_block
== NULL
)
4935 within_current_scope
= 1;
4938 struct frame_info
*frame
= get_current_frame ();
4939 struct gdbarch
*frame_arch
= get_frame_arch (frame
);
4940 CORE_ADDR frame_pc
= get_frame_pc (frame
);
4942 /* stack_frame_destroyed_p() returns a non-zero value if we're
4943 still in the function but the stack frame has already been
4944 invalidated. Since we can't rely on the values of local
4945 variables after the stack has been destroyed, we are treating
4946 the watchpoint in that state as `not changed' without further
4947 checking. Don't mark watchpoints as changed if the current
4948 frame is in an epilogue - even if they are in some other
4949 frame, our view of the stack is likely to be wrong and
4950 frame_find_by_id could error out. */
4951 if (gdbarch_stack_frame_destroyed_p (frame_arch
, frame_pc
))
4954 fr
= frame_find_by_id (b
->watchpoint_frame
);
4955 within_current_scope
= (fr
!= NULL
);
4957 /* If we've gotten confused in the unwinder, we might have
4958 returned a frame that can't describe this variable. */
4959 if (within_current_scope
)
4961 struct symbol
*function
;
4963 function
= get_frame_function (fr
);
4964 if (function
== NULL
4965 || !contained_in (b
->exp_valid_block
,
4966 SYMBOL_BLOCK_VALUE (function
)))
4967 within_current_scope
= 0;
4970 if (within_current_scope
)
4971 /* If we end up stopping, the current frame will get selected
4972 in normal_stop. So this call to select_frame won't affect
4977 if (within_current_scope
)
4979 /* We use value_{,free_to_}mark because it could be a *long*
4980 time before we return to the command level and call
4981 free_all_values. We can't call free_all_values because we
4982 might be in the middle of evaluating a function call. */
4986 struct value
*new_val
;
4988 if (is_masked_watchpoint (b
))
4989 /* Since we don't know the exact trigger address (from
4990 stopped_data_address), just tell the user we've triggered
4991 a mask watchpoint. */
4992 return WP_VALUE_CHANGED
;
4994 mark
= value_mark ();
4995 fetch_subexp_value (b
->exp
.get (), &pc
, &new_val
, NULL
, NULL
, 0);
4997 if (b
->val_bitsize
!= 0)
4998 new_val
= extract_bitfield_from_watchpoint_value (b
, new_val
);
5000 /* We use value_equal_contents instead of value_equal because
5001 the latter coerces an array to a pointer, thus comparing just
5002 the address of the array instead of its contents. This is
5003 not what we want. */
5004 if ((b
->val
!= NULL
) != (new_val
!= NULL
)
5005 || (b
->val
!= NULL
&& !value_equal_contents (b
->val
, new_val
)))
5007 if (new_val
!= NULL
)
5009 release_value (new_val
);
5010 value_free_to_mark (mark
);
5012 bs
->old_val
= b
->val
;
5015 return WP_VALUE_CHANGED
;
5019 /* Nothing changed. */
5020 value_free_to_mark (mark
);
5021 return WP_VALUE_NOT_CHANGED
;
5026 /* This seems like the only logical thing to do because
5027 if we temporarily ignored the watchpoint, then when
5028 we reenter the block in which it is valid it contains
5029 garbage (in the case of a function, it may have two
5030 garbage values, one before and one after the prologue).
5031 So we can't even detect the first assignment to it and
5032 watch after that (since the garbage may or may not equal
5033 the first value assigned). */
5034 /* We print all the stop information in
5035 breakpoint_ops->print_it, but in this case, by the time we
5036 call breakpoint_ops->print_it this bp will be deleted
5037 already. So we have no choice but print the information
5040 SWITCH_THRU_ALL_UIS ()
5042 struct ui_out
*uiout
= current_uiout
;
5044 if (uiout
->is_mi_like_p ())
5046 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
5047 uiout
->text ("\nWatchpoint ");
5048 uiout
->field_int ("wpnum", b
->number
);
5049 uiout
->text (" deleted because the program has left the block in\n"
5050 "which its expression is valid.\n");
5053 /* Make sure the watchpoint's commands aren't executed. */
5055 watchpoint_del_at_next_stop (b
);
5061 /* Return true if it looks like target has stopped due to hitting
5062 breakpoint location BL. This function does not check if we should
5063 stop, only if BL explains the stop. */
5066 bpstat_check_location (const struct bp_location
*bl
,
5067 struct address_space
*aspace
, CORE_ADDR bp_addr
,
5068 const struct target_waitstatus
*ws
)
5070 struct breakpoint
*b
= bl
->owner
;
5072 /* BL is from an existing breakpoint. */
5073 gdb_assert (b
!= NULL
);
5075 return b
->ops
->breakpoint_hit (bl
, aspace
, bp_addr
, ws
);
5078 /* Determine if the watched values have actually changed, and we
5079 should stop. If not, set BS->stop to 0. */
5082 bpstat_check_watchpoint (bpstat bs
)
5084 const struct bp_location
*bl
;
5085 struct watchpoint
*b
;
5087 /* BS is built for existing struct breakpoint. */
5088 bl
= bs
->bp_location_at
;
5089 gdb_assert (bl
!= NULL
);
5090 b
= (struct watchpoint
*) bs
->breakpoint_at
;
5091 gdb_assert (b
!= NULL
);
5094 int must_check_value
= 0;
5096 if (b
->type
== bp_watchpoint
)
5097 /* For a software watchpoint, we must always check the
5099 must_check_value
= 1;
5100 else if (b
->watchpoint_triggered
== watch_triggered_yes
)
5101 /* We have a hardware watchpoint (read, write, or access)
5102 and the target earlier reported an address watched by
5104 must_check_value
= 1;
5105 else if (b
->watchpoint_triggered
== watch_triggered_unknown
5106 && b
->type
== bp_hardware_watchpoint
)
5107 /* We were stopped by a hardware watchpoint, but the target could
5108 not report the data address. We must check the watchpoint's
5109 value. Access and read watchpoints are out of luck; without
5110 a data address, we can't figure it out. */
5111 must_check_value
= 1;
5113 if (must_check_value
)
5119 e
= watchpoint_check (bs
);
5121 CATCH (ex
, RETURN_MASK_ALL
)
5123 exception_fprintf (gdb_stderr
, ex
,
5124 "Error evaluating expression "
5125 "for watchpoint %d\n",
5128 SWITCH_THRU_ALL_UIS ()
5130 printf_filtered (_("Watchpoint %d deleted.\n"),
5133 watchpoint_del_at_next_stop (b
);
5141 /* We've already printed what needs to be printed. */
5142 bs
->print_it
= print_it_done
;
5146 bs
->print_it
= print_it_noop
;
5149 case WP_VALUE_CHANGED
:
5150 if (b
->type
== bp_read_watchpoint
)
5152 /* There are two cases to consider here:
5154 1. We're watching the triggered memory for reads.
5155 In that case, trust the target, and always report
5156 the watchpoint hit to the user. Even though
5157 reads don't cause value changes, the value may
5158 have changed since the last time it was read, and
5159 since we're not trapping writes, we will not see
5160 those, and as such we should ignore our notion of
5163 2. We're watching the triggered memory for both
5164 reads and writes. There are two ways this may
5167 2.1. This is a target that can't break on data
5168 reads only, but can break on accesses (reads or
5169 writes), such as e.g., x86. We detect this case
5170 at the time we try to insert read watchpoints.
5172 2.2. Otherwise, the target supports read
5173 watchpoints, but, the user set an access or write
5174 watchpoint watching the same memory as this read
5177 If we're watching memory writes as well as reads,
5178 ignore watchpoint hits when we find that the
5179 value hasn't changed, as reads don't cause
5180 changes. This still gives false positives when
5181 the program writes the same value to memory as
5182 what there was already in memory (we will confuse
5183 it for a read), but it's much better than
5186 int other_write_watchpoint
= 0;
5188 if (bl
->watchpoint_type
== hw_read
)
5190 struct breakpoint
*other_b
;
5192 ALL_BREAKPOINTS (other_b
)
5193 if (other_b
->type
== bp_hardware_watchpoint
5194 || other_b
->type
== bp_access_watchpoint
)
5196 struct watchpoint
*other_w
=
5197 (struct watchpoint
*) other_b
;
5199 if (other_w
->watchpoint_triggered
5200 == watch_triggered_yes
)
5202 other_write_watchpoint
= 1;
5208 if (other_write_watchpoint
5209 || bl
->watchpoint_type
== hw_access
)
5211 /* We're watching the same memory for writes,
5212 and the value changed since the last time we
5213 updated it, so this trap must be for a write.
5215 bs
->print_it
= print_it_noop
;
5220 case WP_VALUE_NOT_CHANGED
:
5221 if (b
->type
== bp_hardware_watchpoint
5222 || b
->type
== bp_watchpoint
)
5224 /* Don't stop: write watchpoints shouldn't fire if
5225 the value hasn't changed. */
5226 bs
->print_it
= print_it_noop
;
5236 else /* must_check_value == 0 */
5238 /* This is a case where some watchpoint(s) triggered, but
5239 not at the address of this watchpoint, or else no
5240 watchpoint triggered after all. So don't print
5241 anything for this watchpoint. */
5242 bs
->print_it
= print_it_noop
;
5248 /* For breakpoints that are currently marked as telling gdb to stop,
5249 check conditions (condition proper, frame, thread and ignore count)
5250 of breakpoint referred to by BS. If we should not stop for this
5251 breakpoint, set BS->stop to 0. */
5254 bpstat_check_breakpoint_conditions (bpstat bs
, ptid_t ptid
)
5256 const struct bp_location
*bl
;
5257 struct breakpoint
*b
;
5259 bool condition_result
= true;
5260 struct expression
*cond
;
5262 gdb_assert (bs
->stop
);
5264 /* BS is built for existing struct breakpoint. */
5265 bl
= bs
->bp_location_at
;
5266 gdb_assert (bl
!= NULL
);
5267 b
= bs
->breakpoint_at
;
5268 gdb_assert (b
!= NULL
);
5270 /* Even if the target evaluated the condition on its end and notified GDB, we
5271 need to do so again since GDB does not know if we stopped due to a
5272 breakpoint or a single step breakpoint. */
5274 if (frame_id_p (b
->frame_id
)
5275 && !frame_id_eq (b
->frame_id
, get_stack_frame_id (get_current_frame ())))
5281 /* If this is a thread/task-specific breakpoint, don't waste cpu
5282 evaluating the condition if this isn't the specified
5284 if ((b
->thread
!= -1 && b
->thread
!= ptid_to_global_thread_id (ptid
))
5285 || (b
->task
!= 0 && b
->task
!= ada_get_task_number (ptid
)))
5292 /* Evaluate extension language breakpoints that have a "stop" method
5294 bs
->stop
= breakpoint_ext_lang_cond_says_stop (b
);
5296 if (is_watchpoint (b
))
5298 struct watchpoint
*w
= (struct watchpoint
*) b
;
5300 cond
= w
->cond_exp
.get ();
5303 cond
= bl
->cond
.get ();
5305 if (cond
&& b
->disposition
!= disp_del_at_next_stop
)
5307 int within_current_scope
= 1;
5308 struct watchpoint
* w
;
5310 /* We use value_mark and value_free_to_mark because it could
5311 be a long time before we return to the command level and
5312 call free_all_values. We can't call free_all_values
5313 because we might be in the middle of evaluating a
5315 struct value
*mark
= value_mark ();
5317 if (is_watchpoint (b
))
5318 w
= (struct watchpoint
*) b
;
5322 /* Need to select the frame, with all that implies so that
5323 the conditions will have the right context. Because we
5324 use the frame, we will not see an inlined function's
5325 variables when we arrive at a breakpoint at the start
5326 of the inlined function; the current frame will be the
5328 if (w
== NULL
|| w
->cond_exp_valid_block
== NULL
)
5329 select_frame (get_current_frame ());
5332 struct frame_info
*frame
;
5334 /* For local watchpoint expressions, which particular
5335 instance of a local is being watched matters, so we
5336 keep track of the frame to evaluate the expression
5337 in. To evaluate the condition however, it doesn't
5338 really matter which instantiation of the function
5339 where the condition makes sense triggers the
5340 watchpoint. This allows an expression like "watch
5341 global if q > 10" set in `func', catch writes to
5342 global on all threads that call `func', or catch
5343 writes on all recursive calls of `func' by a single
5344 thread. We simply always evaluate the condition in
5345 the innermost frame that's executing where it makes
5346 sense to evaluate the condition. It seems
5348 frame
= block_innermost_frame (w
->cond_exp_valid_block
);
5350 select_frame (frame
);
5352 within_current_scope
= 0;
5354 if (within_current_scope
)
5358 condition_result
= breakpoint_cond_eval (cond
);
5360 CATCH (ex
, RETURN_MASK_ALL
)
5362 exception_fprintf (gdb_stderr
, ex
,
5363 "Error in testing breakpoint condition:\n");
5369 warning (_("Watchpoint condition cannot be tested "
5370 "in the current scope"));
5371 /* If we failed to set the right context for this
5372 watchpoint, unconditionally report it. */
5374 /* FIXME-someday, should give breakpoint #. */
5375 value_free_to_mark (mark
);
5378 if (cond
&& !condition_result
)
5382 else if (b
->ignore_count
> 0)
5386 /* Increase the hit count even though we don't stop. */
5388 observer_notify_breakpoint_modified (b
);
5392 /* Returns true if we need to track moribund locations of LOC's type
5393 on the current target. */
5396 need_moribund_for_location_type (struct bp_location
*loc
)
5398 return ((loc
->loc_type
== bp_loc_software_breakpoint
5399 && !target_supports_stopped_by_sw_breakpoint ())
5400 || (loc
->loc_type
== bp_loc_hardware_breakpoint
5401 && !target_supports_stopped_by_hw_breakpoint ()));
5405 /* Get a bpstat associated with having just stopped at address
5406 BP_ADDR in thread PTID.
5408 Determine whether we stopped at a breakpoint, etc, or whether we
5409 don't understand this stop. Result is a chain of bpstat's such
5412 if we don't understand the stop, the result is a null pointer.
5414 if we understand why we stopped, the result is not null.
5416 Each element of the chain refers to a particular breakpoint or
5417 watchpoint at which we have stopped. (We may have stopped for
5418 several reasons concurrently.)
5420 Each element of the chain has valid next, breakpoint_at,
5421 commands, FIXME??? fields. */
5424 bpstat_stop_status (struct address_space
*aspace
,
5425 CORE_ADDR bp_addr
, ptid_t ptid
,
5426 const struct target_waitstatus
*ws
)
5428 struct breakpoint
*b
= NULL
;
5429 struct bp_location
*bl
;
5430 struct bp_location
*loc
;
5431 /* First item of allocated bpstat's. */
5432 bpstat bs_head
= NULL
, *bs_link
= &bs_head
;
5433 /* Pointer to the last thing in the chain currently. */
5436 int need_remove_insert
;
5439 /* First, build the bpstat chain with locations that explain a
5440 target stop, while being careful to not set the target running,
5441 as that may invalidate locations (in particular watchpoint
5442 locations are recreated). Resuming will happen here with
5443 breakpoint conditions or watchpoint expressions that include
5444 inferior function calls. */
5448 if (!breakpoint_enabled (b
))
5451 for (bl
= b
->loc
; bl
!= NULL
; bl
= bl
->next
)
5453 /* For hardware watchpoints, we look only at the first
5454 location. The watchpoint_check function will work on the
5455 entire expression, not the individual locations. For
5456 read watchpoints, the watchpoints_triggered function has
5457 checked all locations already. */
5458 if (b
->type
== bp_hardware_watchpoint
&& bl
!= b
->loc
)
5461 if (!bl
->enabled
|| bl
->shlib_disabled
)
5464 if (!bpstat_check_location (bl
, aspace
, bp_addr
, ws
))
5467 /* Come here if it's a watchpoint, or if the break address
5470 bs
= new bpstats (bl
, &bs_link
); /* Alloc a bpstat to
5473 /* Assume we stop. Should we find a watchpoint that is not
5474 actually triggered, or if the condition of the breakpoint
5475 evaluates as false, we'll reset 'stop' to 0. */
5479 /* If this is a scope breakpoint, mark the associated
5480 watchpoint as triggered so that we will handle the
5481 out-of-scope event. We'll get to the watchpoint next
5483 if (b
->type
== bp_watchpoint_scope
&& b
->related_breakpoint
!= b
)
5485 struct watchpoint
*w
= (struct watchpoint
*) b
->related_breakpoint
;
5487 w
->watchpoint_triggered
= watch_triggered_yes
;
5492 /* Check if a moribund breakpoint explains the stop. */
5493 if (!target_supports_stopped_by_sw_breakpoint ()
5494 || !target_supports_stopped_by_hw_breakpoint ())
5496 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
5498 if (breakpoint_location_address_match (loc
, aspace
, bp_addr
)
5499 && need_moribund_for_location_type (loc
))
5501 bs
= new bpstats (loc
, &bs_link
);
5502 /* For hits of moribund locations, we should just proceed. */
5505 bs
->print_it
= print_it_noop
;
5510 /* A bit of special processing for shlib breakpoints. We need to
5511 process solib loading here, so that the lists of loaded and
5512 unloaded libraries are correct before we handle "catch load" and
5514 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5516 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->type
== bp_shlib_event
)
5518 handle_solib_event ();
5523 /* Now go through the locations that caused the target to stop, and
5524 check whether we're interested in reporting this stop to higher
5525 layers, or whether we should resume the target transparently. */
5529 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5534 b
= bs
->breakpoint_at
;
5535 b
->ops
->check_status (bs
);
5538 bpstat_check_breakpoint_conditions (bs
, ptid
);
5543 observer_notify_breakpoint_modified (b
);
5545 /* We will stop here. */
5546 if (b
->disposition
== disp_disable
)
5548 --(b
->enable_count
);
5549 if (b
->enable_count
<= 0)
5550 b
->enable_state
= bp_disabled
;
5555 bs
->commands
= b
->commands
;
5556 if (command_line_is_silent (bs
->commands
5557 ? bs
->commands
.get () : NULL
))
5560 b
->ops
->after_condition_true (bs
);
5565 /* Print nothing for this entry if we don't stop or don't
5567 if (!bs
->stop
|| !bs
->print
)
5568 bs
->print_it
= print_it_noop
;
5571 /* If we aren't stopping, the value of some hardware watchpoint may
5572 not have changed, but the intermediate memory locations we are
5573 watching may have. Don't bother if we're stopping; this will get
5575 need_remove_insert
= 0;
5576 if (! bpstat_causes_stop (bs_head
))
5577 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5579 && bs
->breakpoint_at
5580 && is_hardware_watchpoint (bs
->breakpoint_at
))
5582 struct watchpoint
*w
= (struct watchpoint
*) bs
->breakpoint_at
;
5584 update_watchpoint (w
, 0 /* don't reparse. */);
5585 need_remove_insert
= 1;
5588 if (need_remove_insert
)
5589 update_global_location_list (UGLL_MAY_INSERT
);
5590 else if (removed_any
)
5591 update_global_location_list (UGLL_DONT_INSERT
);
5597 handle_jit_event (void)
5599 struct frame_info
*frame
;
5600 struct gdbarch
*gdbarch
;
5603 fprintf_unfiltered (gdb_stdlog
, "handling bp_jit_event\n");
5605 /* Switch terminal for any messages produced by
5606 breakpoint_re_set. */
5607 target_terminal::ours_for_output ();
5609 frame
= get_current_frame ();
5610 gdbarch
= get_frame_arch (frame
);
5612 jit_event_handler (gdbarch
);
5614 target_terminal::inferior ();
5617 /* Prepare WHAT final decision for infrun. */
5619 /* Decide what infrun needs to do with this bpstat. */
5622 bpstat_what (bpstat bs_head
)
5624 struct bpstat_what retval
;
5627 retval
.main_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5628 retval
.call_dummy
= STOP_NONE
;
5629 retval
.is_longjmp
= 0;
5631 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5633 /* Extract this BS's action. After processing each BS, we check
5634 if its action overrides all we've seem so far. */
5635 enum bpstat_what_main_action this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5638 if (bs
->breakpoint_at
== NULL
)
5640 /* I suspect this can happen if it was a momentary
5641 breakpoint which has since been deleted. */
5645 bptype
= bs
->breakpoint_at
->type
;
5652 case bp_hardware_breakpoint
:
5653 case bp_single_step
:
5656 case bp_shlib_event
:
5660 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5662 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5665 this_action
= BPSTAT_WHAT_SINGLE
;
5668 case bp_hardware_watchpoint
:
5669 case bp_read_watchpoint
:
5670 case bp_access_watchpoint
:
5674 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5676 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5680 /* There was a watchpoint, but we're not stopping.
5681 This requires no further action. */
5685 case bp_longjmp_call_dummy
:
5689 this_action
= BPSTAT_WHAT_SET_LONGJMP_RESUME
;
5690 retval
.is_longjmp
= bptype
!= bp_exception
;
5693 this_action
= BPSTAT_WHAT_SINGLE
;
5695 case bp_longjmp_resume
:
5696 case bp_exception_resume
:
5699 this_action
= BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
;
5700 retval
.is_longjmp
= bptype
== bp_longjmp_resume
;
5703 this_action
= BPSTAT_WHAT_SINGLE
;
5705 case bp_step_resume
:
5707 this_action
= BPSTAT_WHAT_STEP_RESUME
;
5710 /* It is for the wrong frame. */
5711 this_action
= BPSTAT_WHAT_SINGLE
;
5714 case bp_hp_step_resume
:
5716 this_action
= BPSTAT_WHAT_HP_STEP_RESUME
;
5719 /* It is for the wrong frame. */
5720 this_action
= BPSTAT_WHAT_SINGLE
;
5723 case bp_watchpoint_scope
:
5724 case bp_thread_event
:
5725 case bp_overlay_event
:
5726 case bp_longjmp_master
:
5727 case bp_std_terminate_master
:
5728 case bp_exception_master
:
5729 this_action
= BPSTAT_WHAT_SINGLE
;
5735 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5737 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5741 /* There was a catchpoint, but we're not stopping.
5742 This requires no further action. */
5746 this_action
= BPSTAT_WHAT_SINGLE
;
5749 /* Make sure the action is stop (silent or noisy),
5750 so infrun.c pops the dummy frame. */
5751 retval
.call_dummy
= STOP_STACK_DUMMY
;
5752 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5754 case bp_std_terminate
:
5755 /* Make sure the action is stop (silent or noisy),
5756 so infrun.c pops the dummy frame. */
5757 retval
.call_dummy
= STOP_STD_TERMINATE
;
5758 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5761 case bp_fast_tracepoint
:
5762 case bp_static_tracepoint
:
5763 /* Tracepoint hits should not be reported back to GDB, and
5764 if one got through somehow, it should have been filtered
5766 internal_error (__FILE__
, __LINE__
,
5767 _("bpstat_what: tracepoint encountered"));
5769 case bp_gnu_ifunc_resolver
:
5770 /* Step over it (and insert bp_gnu_ifunc_resolver_return). */
5771 this_action
= BPSTAT_WHAT_SINGLE
;
5773 case bp_gnu_ifunc_resolver_return
:
5774 /* The breakpoint will be removed, execution will restart from the
5775 PC of the former breakpoint. */
5776 this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5781 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5783 this_action
= BPSTAT_WHAT_SINGLE
;
5787 internal_error (__FILE__
, __LINE__
,
5788 _("bpstat_what: unhandled bptype %d"), (int) bptype
);
5791 retval
.main_action
= std::max (retval
.main_action
, this_action
);
5798 bpstat_run_callbacks (bpstat bs_head
)
5802 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5804 struct breakpoint
*b
= bs
->breakpoint_at
;
5811 handle_jit_event ();
5813 case bp_gnu_ifunc_resolver
:
5814 gnu_ifunc_resolver_stop (b
);
5816 case bp_gnu_ifunc_resolver_return
:
5817 gnu_ifunc_resolver_return_stop (b
);
5823 /* Nonzero if we should step constantly (e.g. watchpoints on machines
5824 without hardware support). This isn't related to a specific bpstat,
5825 just to things like whether watchpoints are set. */
5828 bpstat_should_step (void)
5830 struct breakpoint
*b
;
5833 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
&& b
->loc
!= NULL
)
5839 bpstat_causes_stop (bpstat bs
)
5841 for (; bs
!= NULL
; bs
= bs
->next
)
5850 /* Compute a string of spaces suitable to indent the next line
5851 so it starts at the position corresponding to the table column
5852 named COL_NAME in the currently active table of UIOUT. */
5855 wrap_indent_at_field (struct ui_out
*uiout
, const char *col_name
)
5857 static char wrap_indent
[80];
5858 int i
, total_width
, width
, align
;
5862 for (i
= 1; uiout
->query_table_field (i
, &width
, &align
, &text
); i
++)
5864 if (strcmp (text
, col_name
) == 0)
5866 gdb_assert (total_width
< sizeof wrap_indent
);
5867 memset (wrap_indent
, ' ', total_width
);
5868 wrap_indent
[total_width
] = 0;
5873 total_width
+= width
+ 1;
5879 /* Determine if the locations of this breakpoint will have their conditions
5880 evaluated by the target, host or a mix of both. Returns the following:
5882 "host": Host evals condition.
5883 "host or target": Host or Target evals condition.
5884 "target": Target evals condition.
5888 bp_condition_evaluator (struct breakpoint
*b
)
5890 struct bp_location
*bl
;
5891 char host_evals
= 0;
5892 char target_evals
= 0;
5897 if (!is_breakpoint (b
))
5900 if (gdb_evaluates_breakpoint_condition_p ()
5901 || !target_supports_evaluation_of_breakpoint_conditions ())
5902 return condition_evaluation_host
;
5904 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
5906 if (bl
->cond_bytecode
)
5912 if (host_evals
&& target_evals
)
5913 return condition_evaluation_both
;
5914 else if (target_evals
)
5915 return condition_evaluation_target
;
5917 return condition_evaluation_host
;
5920 /* Determine the breakpoint location's condition evaluator. This is
5921 similar to bp_condition_evaluator, but for locations. */
5924 bp_location_condition_evaluator (struct bp_location
*bl
)
5926 if (bl
&& !is_breakpoint (bl
->owner
))
5929 if (gdb_evaluates_breakpoint_condition_p ()
5930 || !target_supports_evaluation_of_breakpoint_conditions ())
5931 return condition_evaluation_host
;
5933 if (bl
&& bl
->cond_bytecode
)
5934 return condition_evaluation_target
;
5936 return condition_evaluation_host
;
5939 /* Print the LOC location out of the list of B->LOC locations. */
5942 print_breakpoint_location (struct breakpoint
*b
,
5943 struct bp_location
*loc
)
5945 struct ui_out
*uiout
= current_uiout
;
5947 scoped_restore_current_program_space restore_pspace
;
5949 if (loc
!= NULL
&& loc
->shlib_disabled
)
5953 set_current_program_space (loc
->pspace
);
5955 if (b
->display_canonical
)
5956 uiout
->field_string ("what", event_location_to_string (b
->location
.get ()));
5957 else if (loc
&& loc
->symtab
)
5960 = find_pc_sect_function (loc
->address
, loc
->section
);
5963 uiout
->text ("in ");
5964 uiout
->field_string ("func", SYMBOL_PRINT_NAME (sym
));
5966 uiout
->wrap_hint (wrap_indent_at_field (uiout
, "what"));
5967 uiout
->text ("at ");
5969 uiout
->field_string ("file",
5970 symtab_to_filename_for_display (loc
->symtab
));
5973 if (uiout
->is_mi_like_p ())
5974 uiout
->field_string ("fullname", symtab_to_fullname (loc
->symtab
));
5976 uiout
->field_int ("line", loc
->line_number
);
5982 print_address_symbolic (loc
->gdbarch
, loc
->address
, &stb
,
5984 uiout
->field_stream ("at", stb
);
5988 uiout
->field_string ("pending",
5989 event_location_to_string (b
->location
.get ()));
5990 /* If extra_string is available, it could be holding a condition
5991 or dprintf arguments. In either case, make sure it is printed,
5992 too, but only for non-MI streams. */
5993 if (!uiout
->is_mi_like_p () && b
->extra_string
!= NULL
)
5995 if (b
->type
== bp_dprintf
)
5999 uiout
->text (b
->extra_string
);
6003 if (loc
&& is_breakpoint (b
)
6004 && breakpoint_condition_evaluation_mode () == condition_evaluation_target
6005 && bp_condition_evaluator (b
) == condition_evaluation_both
)
6008 uiout
->field_string ("evaluated-by",
6009 bp_location_condition_evaluator (loc
));
6015 bptype_string (enum bptype type
)
6017 struct ep_type_description
6020 const char *description
;
6022 static struct ep_type_description bptypes
[] =
6024 {bp_none
, "?deleted?"},
6025 {bp_breakpoint
, "breakpoint"},
6026 {bp_hardware_breakpoint
, "hw breakpoint"},
6027 {bp_single_step
, "sw single-step"},
6028 {bp_until
, "until"},
6029 {bp_finish
, "finish"},
6030 {bp_watchpoint
, "watchpoint"},
6031 {bp_hardware_watchpoint
, "hw watchpoint"},
6032 {bp_read_watchpoint
, "read watchpoint"},
6033 {bp_access_watchpoint
, "acc watchpoint"},
6034 {bp_longjmp
, "longjmp"},
6035 {bp_longjmp_resume
, "longjmp resume"},
6036 {bp_longjmp_call_dummy
, "longjmp for call dummy"},
6037 {bp_exception
, "exception"},
6038 {bp_exception_resume
, "exception resume"},
6039 {bp_step_resume
, "step resume"},
6040 {bp_hp_step_resume
, "high-priority step resume"},
6041 {bp_watchpoint_scope
, "watchpoint scope"},
6042 {bp_call_dummy
, "call dummy"},
6043 {bp_std_terminate
, "std::terminate"},
6044 {bp_shlib_event
, "shlib events"},
6045 {bp_thread_event
, "thread events"},
6046 {bp_overlay_event
, "overlay events"},
6047 {bp_longjmp_master
, "longjmp master"},
6048 {bp_std_terminate_master
, "std::terminate master"},
6049 {bp_exception_master
, "exception master"},
6050 {bp_catchpoint
, "catchpoint"},
6051 {bp_tracepoint
, "tracepoint"},
6052 {bp_fast_tracepoint
, "fast tracepoint"},
6053 {bp_static_tracepoint
, "static tracepoint"},
6054 {bp_dprintf
, "dprintf"},
6055 {bp_jit_event
, "jit events"},
6056 {bp_gnu_ifunc_resolver
, "STT_GNU_IFUNC resolver"},
6057 {bp_gnu_ifunc_resolver_return
, "STT_GNU_IFUNC resolver return"},
6060 if (((int) type
>= (sizeof (bptypes
) / sizeof (bptypes
[0])))
6061 || ((int) type
!= bptypes
[(int) type
].type
))
6062 internal_error (__FILE__
, __LINE__
,
6063 _("bptypes table does not describe type #%d."),
6066 return bptypes
[(int) type
].description
;
6069 /* For MI, output a field named 'thread-groups' with a list as the value.
6070 For CLI, prefix the list with the string 'inf'. */
6073 output_thread_groups (struct ui_out
*uiout
,
6074 const char *field_name
,
6078 int is_mi
= uiout
->is_mi_like_p ();
6082 /* For backward compatibility, don't display inferiors in CLI unless
6083 there are several. Always display them for MI. */
6084 if (!is_mi
&& mi_only
)
6087 ui_out_emit_list
list_emitter (uiout
, field_name
);
6089 for (i
= 0; VEC_iterate (int, inf_num
, i
, inf
); ++i
)
6095 xsnprintf (mi_group
, sizeof (mi_group
), "i%d", inf
);
6096 uiout
->field_string (NULL
, mi_group
);
6101 uiout
->text (" inf ");
6105 uiout
->text (plongest (inf
));
6110 /* Print B to gdb_stdout. */
6113 print_one_breakpoint_location (struct breakpoint
*b
,
6114 struct bp_location
*loc
,
6116 struct bp_location
**last_loc
,
6119 struct command_line
*l
;
6120 static char bpenables
[] = "nynny";
6122 struct ui_out
*uiout
= current_uiout
;
6123 int header_of_multiple
= 0;
6124 int part_of_multiple
= (loc
!= NULL
);
6125 struct value_print_options opts
;
6127 get_user_print_options (&opts
);
6129 gdb_assert (!loc
|| loc_number
!= 0);
6130 /* See comment in print_one_breakpoint concerning treatment of
6131 breakpoints with single disabled location. */
6134 && (b
->loc
->next
!= NULL
|| !b
->loc
->enabled
)))
6135 header_of_multiple
= 1;
6143 if (part_of_multiple
)
6146 formatted
= xstrprintf ("%d.%d", b
->number
, loc_number
);
6147 uiout
->field_string ("number", formatted
);
6152 uiout
->field_int ("number", b
->number
);
6157 if (part_of_multiple
)
6158 uiout
->field_skip ("type");
6160 uiout
->field_string ("type", bptype_string (b
->type
));
6164 if (part_of_multiple
)
6165 uiout
->field_skip ("disp");
6167 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
6172 if (part_of_multiple
)
6173 uiout
->field_string ("enabled", loc
->enabled
? "y" : "n");
6175 uiout
->field_fmt ("enabled", "%c", bpenables
[(int) b
->enable_state
]);
6180 if (b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
6182 /* Although the print_one can possibly print all locations,
6183 calling it here is not likely to get any nice result. So,
6184 make sure there's just one location. */
6185 gdb_assert (b
->loc
== NULL
|| b
->loc
->next
== NULL
);
6186 b
->ops
->print_one (b
, last_loc
);
6192 internal_error (__FILE__
, __LINE__
,
6193 _("print_one_breakpoint: bp_none encountered\n"));
6197 case bp_hardware_watchpoint
:
6198 case bp_read_watchpoint
:
6199 case bp_access_watchpoint
:
6201 struct watchpoint
*w
= (struct watchpoint
*) b
;
6203 /* Field 4, the address, is omitted (which makes the columns
6204 not line up too nicely with the headers, but the effect
6205 is relatively readable). */
6206 if (opts
.addressprint
)
6207 uiout
->field_skip ("addr");
6209 uiout
->field_string ("what", w
->exp_string
);
6214 case bp_hardware_breakpoint
:
6215 case bp_single_step
:
6219 case bp_longjmp_resume
:
6220 case bp_longjmp_call_dummy
:
6222 case bp_exception_resume
:
6223 case bp_step_resume
:
6224 case bp_hp_step_resume
:
6225 case bp_watchpoint_scope
:
6227 case bp_std_terminate
:
6228 case bp_shlib_event
:
6229 case bp_thread_event
:
6230 case bp_overlay_event
:
6231 case bp_longjmp_master
:
6232 case bp_std_terminate_master
:
6233 case bp_exception_master
:
6235 case bp_fast_tracepoint
:
6236 case bp_static_tracepoint
:
6239 case bp_gnu_ifunc_resolver
:
6240 case bp_gnu_ifunc_resolver_return
:
6241 if (opts
.addressprint
)
6244 if (header_of_multiple
)
6245 uiout
->field_string ("addr", "<MULTIPLE>");
6246 else if (b
->loc
== NULL
|| loc
->shlib_disabled
)
6247 uiout
->field_string ("addr", "<PENDING>");
6249 uiout
->field_core_addr ("addr",
6250 loc
->gdbarch
, loc
->address
);
6253 if (!header_of_multiple
)
6254 print_breakpoint_location (b
, loc
);
6261 if (loc
!= NULL
&& !header_of_multiple
)
6263 struct inferior
*inf
;
6264 VEC(int) *inf_num
= NULL
;
6269 if (inf
->pspace
== loc
->pspace
)
6270 VEC_safe_push (int, inf_num
, inf
->num
);
6273 /* For backward compatibility, don't display inferiors in CLI unless
6274 there are several. Always display for MI. */
6276 || (!gdbarch_has_global_breakpoints (target_gdbarch ())
6277 && (number_of_program_spaces () > 1
6278 || number_of_inferiors () > 1)
6279 /* LOC is for existing B, it cannot be in
6280 moribund_locations and thus having NULL OWNER. */
6281 && loc
->owner
->type
!= bp_catchpoint
))
6283 output_thread_groups (uiout
, "thread-groups", inf_num
, mi_only
);
6284 VEC_free (int, inf_num
);
6287 if (!part_of_multiple
)
6289 if (b
->thread
!= -1)
6291 /* FIXME: This seems to be redundant and lost here; see the
6292 "stop only in" line a little further down. */
6293 uiout
->text (" thread ");
6294 uiout
->field_int ("thread", b
->thread
);
6296 else if (b
->task
!= 0)
6298 uiout
->text (" task ");
6299 uiout
->field_int ("task", b
->task
);
6305 if (!part_of_multiple
)
6306 b
->ops
->print_one_detail (b
, uiout
);
6308 if (part_of_multiple
&& frame_id_p (b
->frame_id
))
6311 uiout
->text ("\tstop only in stack frame at ");
6312 /* FIXME: cagney/2002-12-01: Shouldn't be poking around inside
6314 uiout
->field_core_addr ("frame",
6315 b
->gdbarch
, b
->frame_id
.stack_addr
);
6319 if (!part_of_multiple
&& b
->cond_string
)
6322 if (is_tracepoint (b
))
6323 uiout
->text ("\ttrace only if ");
6325 uiout
->text ("\tstop only if ");
6326 uiout
->field_string ("cond", b
->cond_string
);
6328 /* Print whether the target is doing the breakpoint's condition
6329 evaluation. If GDB is doing the evaluation, don't print anything. */
6330 if (is_breakpoint (b
)
6331 && breakpoint_condition_evaluation_mode ()
6332 == condition_evaluation_target
)
6335 uiout
->field_string ("evaluated-by",
6336 bp_condition_evaluator (b
));
6337 uiout
->text (" evals)");
6342 if (!part_of_multiple
&& b
->thread
!= -1)
6344 /* FIXME should make an annotation for this. */
6345 uiout
->text ("\tstop only in thread ");
6346 if (uiout
->is_mi_like_p ())
6347 uiout
->field_int ("thread", b
->thread
);
6350 struct thread_info
*thr
= find_thread_global_id (b
->thread
);
6352 uiout
->field_string ("thread", print_thread_id (thr
));
6357 if (!part_of_multiple
)
6361 /* FIXME should make an annotation for this. */
6362 if (is_catchpoint (b
))
6363 uiout
->text ("\tcatchpoint");
6364 else if (is_tracepoint (b
))
6365 uiout
->text ("\ttracepoint");
6367 uiout
->text ("\tbreakpoint");
6368 uiout
->text (" already hit ");
6369 uiout
->field_int ("times", b
->hit_count
);
6370 if (b
->hit_count
== 1)
6371 uiout
->text (" time\n");
6373 uiout
->text (" times\n");
6377 /* Output the count also if it is zero, but only if this is mi. */
6378 if (uiout
->is_mi_like_p ())
6379 uiout
->field_int ("times", b
->hit_count
);
6383 if (!part_of_multiple
&& b
->ignore_count
)
6386 uiout
->text ("\tignore next ");
6387 uiout
->field_int ("ignore", b
->ignore_count
);
6388 uiout
->text (" hits\n");
6391 /* Note that an enable count of 1 corresponds to "enable once"
6392 behavior, which is reported by the combination of enablement and
6393 disposition, so we don't need to mention it here. */
6394 if (!part_of_multiple
&& b
->enable_count
> 1)
6397 uiout
->text ("\tdisable after ");
6398 /* Tweak the wording to clarify that ignore and enable counts
6399 are distinct, and have additive effect. */
6400 if (b
->ignore_count
)
6401 uiout
->text ("additional ");
6403 uiout
->text ("next ");
6404 uiout
->field_int ("enable", b
->enable_count
);
6405 uiout
->text (" hits\n");
6408 if (!part_of_multiple
&& is_tracepoint (b
))
6410 struct tracepoint
*tp
= (struct tracepoint
*) b
;
6412 if (tp
->traceframe_usage
)
6414 uiout
->text ("\ttrace buffer usage ");
6415 uiout
->field_int ("traceframe-usage", tp
->traceframe_usage
);
6416 uiout
->text (" bytes\n");
6420 l
= b
->commands
? b
->commands
.get () : NULL
;
6421 if (!part_of_multiple
&& l
)
6424 ui_out_emit_tuple
tuple_emitter (uiout
, "script");
6425 print_command_lines (uiout
, l
, 4);
6428 if (is_tracepoint (b
))
6430 struct tracepoint
*t
= (struct tracepoint
*) b
;
6432 if (!part_of_multiple
&& t
->pass_count
)
6434 annotate_field (10);
6435 uiout
->text ("\tpass count ");
6436 uiout
->field_int ("pass", t
->pass_count
);
6437 uiout
->text (" \n");
6440 /* Don't display it when tracepoint or tracepoint location is
6442 if (!header_of_multiple
&& loc
!= NULL
&& !loc
->shlib_disabled
)
6444 annotate_field (11);
6446 if (uiout
->is_mi_like_p ())
6447 uiout
->field_string ("installed",
6448 loc
->inserted
? "y" : "n");
6454 uiout
->text ("\tnot ");
6455 uiout
->text ("installed on target\n");
6460 if (uiout
->is_mi_like_p () && !part_of_multiple
)
6462 if (is_watchpoint (b
))
6464 struct watchpoint
*w
= (struct watchpoint
*) b
;
6466 uiout
->field_string ("original-location", w
->exp_string
);
6468 else if (b
->location
!= NULL
6469 && event_location_to_string (b
->location
.get ()) != NULL
)
6470 uiout
->field_string ("original-location",
6471 event_location_to_string (b
->location
.get ()));
6476 print_one_breakpoint (struct breakpoint
*b
,
6477 struct bp_location
**last_loc
,
6480 struct ui_out
*uiout
= current_uiout
;
6483 ui_out_emit_tuple
tuple_emitter (uiout
, "bkpt");
6485 print_one_breakpoint_location (b
, NULL
, 0, last_loc
, allflag
);
6488 /* If this breakpoint has custom print function,
6489 it's already printed. Otherwise, print individual
6490 locations, if any. */
6491 if (b
->ops
== NULL
|| b
->ops
->print_one
== NULL
)
6493 /* If breakpoint has a single location that is disabled, we
6494 print it as if it had several locations, since otherwise it's
6495 hard to represent "breakpoint enabled, location disabled"
6498 Note that while hardware watchpoints have several locations
6499 internally, that's not a property exposed to user. */
6501 && !is_hardware_watchpoint (b
)
6502 && (b
->loc
->next
|| !b
->loc
->enabled
))
6504 struct bp_location
*loc
;
6507 for (loc
= b
->loc
; loc
; loc
= loc
->next
, ++n
)
6509 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
6510 print_one_breakpoint_location (b
, loc
, n
, last_loc
, allflag
);
6517 breakpoint_address_bits (struct breakpoint
*b
)
6519 int print_address_bits
= 0;
6520 struct bp_location
*loc
;
6522 /* Software watchpoints that aren't watching memory don't have an
6523 address to print. */
6524 if (is_no_memory_software_watchpoint (b
))
6527 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
6531 addr_bit
= gdbarch_addr_bit (loc
->gdbarch
);
6532 if (addr_bit
> print_address_bits
)
6533 print_address_bits
= addr_bit
;
6536 return print_address_bits
;
6539 /* See breakpoint.h. */
6542 print_breakpoint (breakpoint
*b
)
6544 struct bp_location
*dummy_loc
= NULL
;
6545 print_one_breakpoint (b
, &dummy_loc
, 0);
6548 /* Return true if this breakpoint was set by the user, false if it is
6549 internal or momentary. */
6552 user_breakpoint_p (struct breakpoint
*b
)
6554 return b
->number
> 0;
6557 /* See breakpoint.h. */
6560 pending_breakpoint_p (struct breakpoint
*b
)
6562 return b
->loc
== NULL
;
6565 /* Print information on user settable breakpoint (watchpoint, etc)
6566 number BNUM. If BNUM is -1 print all user-settable breakpoints.
6567 If ALLFLAG is non-zero, include non-user-settable breakpoints. If
6568 FILTER is non-NULL, call it on each breakpoint and only include the
6569 ones for which it returns non-zero. Return the total number of
6570 breakpoints listed. */
6573 breakpoint_1 (const char *args
, int allflag
,
6574 int (*filter
) (const struct breakpoint
*))
6576 struct breakpoint
*b
;
6577 struct bp_location
*last_loc
= NULL
;
6578 int nr_printable_breakpoints
;
6579 struct value_print_options opts
;
6580 int print_address_bits
= 0;
6581 int print_type_col_width
= 14;
6582 struct ui_out
*uiout
= current_uiout
;
6584 get_user_print_options (&opts
);
6586 /* Compute the number of rows in the table, as well as the size
6587 required for address fields. */
6588 nr_printable_breakpoints
= 0;
6591 /* If we have a filter, only list the breakpoints it accepts. */
6592 if (filter
&& !filter (b
))
6595 /* If we have an "args" string, it is a list of breakpoints to
6596 accept. Skip the others. */
6597 if (args
!= NULL
&& *args
!= '\0')
6599 if (allflag
&& parse_and_eval_long (args
) != b
->number
)
6601 if (!allflag
&& !number_is_in_list (args
, b
->number
))
6605 if (allflag
|| user_breakpoint_p (b
))
6607 int addr_bit
, type_len
;
6609 addr_bit
= breakpoint_address_bits (b
);
6610 if (addr_bit
> print_address_bits
)
6611 print_address_bits
= addr_bit
;
6613 type_len
= strlen (bptype_string (b
->type
));
6614 if (type_len
> print_type_col_width
)
6615 print_type_col_width
= type_len
;
6617 nr_printable_breakpoints
++;
6622 ui_out_emit_table
table_emitter (uiout
,
6623 opts
.addressprint
? 6 : 5,
6624 nr_printable_breakpoints
,
6627 if (nr_printable_breakpoints
> 0)
6628 annotate_breakpoints_headers ();
6629 if (nr_printable_breakpoints
> 0)
6631 uiout
->table_header (7, ui_left
, "number", "Num"); /* 1 */
6632 if (nr_printable_breakpoints
> 0)
6634 uiout
->table_header (print_type_col_width
, ui_left
, "type", "Type"); /* 2 */
6635 if (nr_printable_breakpoints
> 0)
6637 uiout
->table_header (4, ui_left
, "disp", "Disp"); /* 3 */
6638 if (nr_printable_breakpoints
> 0)
6640 uiout
->table_header (3, ui_left
, "enabled", "Enb"); /* 4 */
6641 if (opts
.addressprint
)
6643 if (nr_printable_breakpoints
> 0)
6645 if (print_address_bits
<= 32)
6646 uiout
->table_header (10, ui_left
, "addr", "Address"); /* 5 */
6648 uiout
->table_header (18, ui_left
, "addr", "Address"); /* 5 */
6650 if (nr_printable_breakpoints
> 0)
6652 uiout
->table_header (40, ui_noalign
, "what", "What"); /* 6 */
6653 uiout
->table_body ();
6654 if (nr_printable_breakpoints
> 0)
6655 annotate_breakpoints_table ();
6660 /* If we have a filter, only list the breakpoints it accepts. */
6661 if (filter
&& !filter (b
))
6664 /* If we have an "args" string, it is a list of breakpoints to
6665 accept. Skip the others. */
6667 if (args
!= NULL
&& *args
!= '\0')
6669 if (allflag
) /* maintenance info breakpoint */
6671 if (parse_and_eval_long (args
) != b
->number
)
6674 else /* all others */
6676 if (!number_is_in_list (args
, b
->number
))
6680 /* We only print out user settable breakpoints unless the
6682 if (allflag
|| user_breakpoint_p (b
))
6683 print_one_breakpoint (b
, &last_loc
, allflag
);
6687 if (nr_printable_breakpoints
== 0)
6689 /* If there's a filter, let the caller decide how to report
6693 if (args
== NULL
|| *args
== '\0')
6694 uiout
->message ("No breakpoints or watchpoints.\n");
6696 uiout
->message ("No breakpoint or watchpoint matching '%s'.\n",
6702 if (last_loc
&& !server_command
)
6703 set_next_address (last_loc
->gdbarch
, last_loc
->address
);
6706 /* FIXME? Should this be moved up so that it is only called when
6707 there have been breakpoints? */
6708 annotate_breakpoints_table_end ();
6710 return nr_printable_breakpoints
;
6713 /* Display the value of default-collect in a way that is generally
6714 compatible with the breakpoint list. */
6717 default_collect_info (void)
6719 struct ui_out
*uiout
= current_uiout
;
6721 /* If it has no value (which is frequently the case), say nothing; a
6722 message like "No default-collect." gets in user's face when it's
6724 if (!*default_collect
)
6727 /* The following phrase lines up nicely with per-tracepoint collect
6729 uiout
->text ("default collect ");
6730 uiout
->field_string ("default-collect", default_collect
);
6731 uiout
->text (" \n");
6735 info_breakpoints_command (char *args
, int from_tty
)
6737 breakpoint_1 (args
, 0, NULL
);
6739 default_collect_info ();
6743 info_watchpoints_command (char *args
, int from_tty
)
6745 int num_printed
= breakpoint_1 (args
, 0, is_watchpoint
);
6746 struct ui_out
*uiout
= current_uiout
;
6748 if (num_printed
== 0)
6750 if (args
== NULL
|| *args
== '\0')
6751 uiout
->message ("No watchpoints.\n");
6753 uiout
->message ("No watchpoint matching '%s'.\n", args
);
6758 maintenance_info_breakpoints (const char *args
, int from_tty
)
6760 breakpoint_1 (args
, 1, NULL
);
6762 default_collect_info ();
6766 breakpoint_has_pc (struct breakpoint
*b
,
6767 struct program_space
*pspace
,
6768 CORE_ADDR pc
, struct obj_section
*section
)
6770 struct bp_location
*bl
= b
->loc
;
6772 for (; bl
; bl
= bl
->next
)
6774 if (bl
->pspace
== pspace
6775 && bl
->address
== pc
6776 && (!overlay_debugging
|| bl
->section
== section
))
6782 /* Print a message describing any user-breakpoints set at PC. This
6783 concerns with logical breakpoints, so we match program spaces, not
6787 describe_other_breakpoints (struct gdbarch
*gdbarch
,
6788 struct program_space
*pspace
, CORE_ADDR pc
,
6789 struct obj_section
*section
, int thread
)
6792 struct breakpoint
*b
;
6795 others
+= (user_breakpoint_p (b
)
6796 && breakpoint_has_pc (b
, pspace
, pc
, section
));
6800 printf_filtered (_("Note: breakpoint "));
6801 else /* if (others == ???) */
6802 printf_filtered (_("Note: breakpoints "));
6804 if (user_breakpoint_p (b
) && breakpoint_has_pc (b
, pspace
, pc
, section
))
6807 printf_filtered ("%d", b
->number
);
6808 if (b
->thread
== -1 && thread
!= -1)
6809 printf_filtered (" (all threads)");
6810 else if (b
->thread
!= -1)
6811 printf_filtered (" (thread %d)", b
->thread
);
6812 printf_filtered ("%s%s ",
6813 ((b
->enable_state
== bp_disabled
6814 || b
->enable_state
== bp_call_disabled
)
6818 : ((others
== 1) ? " and" : ""));
6820 printf_filtered (_("also set at pc "));
6821 fputs_filtered (paddress (gdbarch
, pc
), gdb_stdout
);
6822 printf_filtered (".\n");
6827 /* Return true iff it is meaningful to use the address member of
6828 BPT locations. For some breakpoint types, the locations' address members
6829 are irrelevant and it makes no sense to attempt to compare them to other
6830 addresses (or use them for any other purpose either).
6832 More specifically, each of the following breakpoint types will
6833 always have a zero valued location address and we don't want to mark
6834 breakpoints of any of these types to be a duplicate of an actual
6835 breakpoint location at address zero:
6843 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
6845 enum bptype type
= bpt
->type
;
6847 return (type
!= bp_watchpoint
&& type
!= bp_catchpoint
);
6850 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
6851 true if LOC1 and LOC2 represent the same watchpoint location. */
6854 watchpoint_locations_match (struct bp_location
*loc1
,
6855 struct bp_location
*loc2
)
6857 struct watchpoint
*w1
= (struct watchpoint
*) loc1
->owner
;
6858 struct watchpoint
*w2
= (struct watchpoint
*) loc2
->owner
;
6860 /* Both of them must exist. */
6861 gdb_assert (w1
!= NULL
);
6862 gdb_assert (w2
!= NULL
);
6864 /* If the target can evaluate the condition expression in hardware,
6865 then we we need to insert both watchpoints even if they are at
6866 the same place. Otherwise the watchpoint will only trigger when
6867 the condition of whichever watchpoint was inserted evaluates to
6868 true, not giving a chance for GDB to check the condition of the
6869 other watchpoint. */
6871 && target_can_accel_watchpoint_condition (loc1
->address
,
6873 loc1
->watchpoint_type
,
6874 w1
->cond_exp
.get ()))
6876 && target_can_accel_watchpoint_condition (loc2
->address
,
6878 loc2
->watchpoint_type
,
6879 w2
->cond_exp
.get ())))
6882 /* Note that this checks the owner's type, not the location's. In
6883 case the target does not support read watchpoints, but does
6884 support access watchpoints, we'll have bp_read_watchpoint
6885 watchpoints with hw_access locations. Those should be considered
6886 duplicates of hw_read locations. The hw_read locations will
6887 become hw_access locations later. */
6888 return (loc1
->owner
->type
== loc2
->owner
->type
6889 && loc1
->pspace
->aspace
== loc2
->pspace
->aspace
6890 && loc1
->address
== loc2
->address
6891 && loc1
->length
== loc2
->length
);
6894 /* See breakpoint.h. */
6897 breakpoint_address_match (struct address_space
*aspace1
, CORE_ADDR addr1
,
6898 struct address_space
*aspace2
, CORE_ADDR addr2
)
6900 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
6901 || aspace1
== aspace2
)
6905 /* Returns true if {ASPACE2,ADDR2} falls within the range determined by
6906 {ASPACE1,ADDR1,LEN1}. In most targets, this can only be true if ASPACE1
6907 matches ASPACE2. On targets that have global breakpoints, the address
6908 space doesn't really matter. */
6911 breakpoint_address_match_range (struct address_space
*aspace1
, CORE_ADDR addr1
,
6912 int len1
, struct address_space
*aspace2
,
6915 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
6916 || aspace1
== aspace2
)
6917 && addr2
>= addr1
&& addr2
< addr1
+ len1
);
6920 /* Returns true if {ASPACE,ADDR} matches the breakpoint BL. BL may be
6921 a ranged breakpoint. In most targets, a match happens only if ASPACE
6922 matches the breakpoint's address space. On targets that have global
6923 breakpoints, the address space doesn't really matter. */
6926 breakpoint_location_address_match (struct bp_location
*bl
,
6927 struct address_space
*aspace
,
6930 return (breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
6933 && breakpoint_address_match_range (bl
->pspace
->aspace
,
6934 bl
->address
, bl
->length
,
6938 /* Returns true if the [ADDR,ADDR+LEN) range in ASPACE overlaps
6939 breakpoint BL. BL may be a ranged breakpoint. In most targets, a
6940 match happens only if ASPACE matches the breakpoint's address
6941 space. On targets that have global breakpoints, the address space
6942 doesn't really matter. */
6945 breakpoint_location_address_range_overlap (struct bp_location
*bl
,
6946 struct address_space
*aspace
,
6947 CORE_ADDR addr
, int len
)
6949 if (gdbarch_has_global_breakpoints (target_gdbarch ())
6950 || bl
->pspace
->aspace
== aspace
)
6952 int bl_len
= bl
->length
!= 0 ? bl
->length
: 1;
6954 if (mem_ranges_overlap (addr
, len
, bl
->address
, bl_len
))
6960 /* If LOC1 and LOC2's owners are not tracepoints, returns false directly.
6961 Then, if LOC1 and LOC2 represent the same tracepoint location, returns
6962 true, otherwise returns false. */
6965 tracepoint_locations_match (struct bp_location
*loc1
,
6966 struct bp_location
*loc2
)
6968 if (is_tracepoint (loc1
->owner
) && is_tracepoint (loc2
->owner
))
6969 /* Since tracepoint locations are never duplicated with others', tracepoint
6970 locations at the same address of different tracepoints are regarded as
6971 different locations. */
6972 return (loc1
->address
== loc2
->address
&& loc1
->owner
== loc2
->owner
);
6977 /* Assuming LOC1 and LOC2's types' have meaningful target addresses
6978 (breakpoint_address_is_meaningful), returns true if LOC1 and LOC2
6979 represent the same location. */
6982 breakpoint_locations_match (struct bp_location
*loc1
,
6983 struct bp_location
*loc2
)
6985 int hw_point1
, hw_point2
;
6987 /* Both of them must not be in moribund_locations. */
6988 gdb_assert (loc1
->owner
!= NULL
);
6989 gdb_assert (loc2
->owner
!= NULL
);
6991 hw_point1
= is_hardware_watchpoint (loc1
->owner
);
6992 hw_point2
= is_hardware_watchpoint (loc2
->owner
);
6994 if (hw_point1
!= hw_point2
)
6997 return watchpoint_locations_match (loc1
, loc2
);
6998 else if (is_tracepoint (loc1
->owner
) || is_tracepoint (loc2
->owner
))
6999 return tracepoint_locations_match (loc1
, loc2
);
7001 /* We compare bp_location.length in order to cover ranged breakpoints. */
7002 return (breakpoint_address_match (loc1
->pspace
->aspace
, loc1
->address
,
7003 loc2
->pspace
->aspace
, loc2
->address
)
7004 && loc1
->length
== loc2
->length
);
7008 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
7009 int bnum
, int have_bnum
)
7011 /* The longest string possibly returned by hex_string_custom
7012 is 50 chars. These must be at least that big for safety. */
7016 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
7017 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
7019 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
7020 bnum
, astr1
, astr2
);
7022 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
7025 /* Adjust a breakpoint's address to account for architectural
7026 constraints on breakpoint placement. Return the adjusted address.
7027 Note: Very few targets require this kind of adjustment. For most
7028 targets, this function is simply the identity function. */
7031 adjust_breakpoint_address (struct gdbarch
*gdbarch
,
7032 CORE_ADDR bpaddr
, enum bptype bptype
)
7034 if (!gdbarch_adjust_breakpoint_address_p (gdbarch
))
7036 /* Very few targets need any kind of breakpoint adjustment. */
7039 else if (bptype
== bp_watchpoint
7040 || bptype
== bp_hardware_watchpoint
7041 || bptype
== bp_read_watchpoint
7042 || bptype
== bp_access_watchpoint
7043 || bptype
== bp_catchpoint
)
7045 /* Watchpoints and the various bp_catch_* eventpoints should not
7046 have their addresses modified. */
7049 else if (bptype
== bp_single_step
)
7051 /* Single-step breakpoints should not have their addresses
7052 modified. If there's any architectural constrain that
7053 applies to this address, then it should have already been
7054 taken into account when the breakpoint was created in the
7055 first place. If we didn't do this, stepping through e.g.,
7056 Thumb-2 IT blocks would break. */
7061 CORE_ADDR adjusted_bpaddr
;
7063 /* Some targets have architectural constraints on the placement
7064 of breakpoint instructions. Obtain the adjusted address. */
7065 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (gdbarch
, bpaddr
);
7067 /* An adjusted breakpoint address can significantly alter
7068 a user's expectations. Print a warning if an adjustment
7070 if (adjusted_bpaddr
!= bpaddr
)
7071 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
7073 return adjusted_bpaddr
;
7077 bp_location::bp_location (const bp_location_ops
*ops
, breakpoint
*owner
)
7079 bp_location
*loc
= this;
7081 gdb_assert (ops
!= NULL
);
7085 loc
->cond_bytecode
= NULL
;
7086 loc
->shlib_disabled
= 0;
7089 switch (owner
->type
)
7092 case bp_single_step
:
7096 case bp_longjmp_resume
:
7097 case bp_longjmp_call_dummy
:
7099 case bp_exception_resume
:
7100 case bp_step_resume
:
7101 case bp_hp_step_resume
:
7102 case bp_watchpoint_scope
:
7104 case bp_std_terminate
:
7105 case bp_shlib_event
:
7106 case bp_thread_event
:
7107 case bp_overlay_event
:
7109 case bp_longjmp_master
:
7110 case bp_std_terminate_master
:
7111 case bp_exception_master
:
7112 case bp_gnu_ifunc_resolver
:
7113 case bp_gnu_ifunc_resolver_return
:
7115 loc
->loc_type
= bp_loc_software_breakpoint
;
7116 mark_breakpoint_location_modified (loc
);
7118 case bp_hardware_breakpoint
:
7119 loc
->loc_type
= bp_loc_hardware_breakpoint
;
7120 mark_breakpoint_location_modified (loc
);
7122 case bp_hardware_watchpoint
:
7123 case bp_read_watchpoint
:
7124 case bp_access_watchpoint
:
7125 loc
->loc_type
= bp_loc_hardware_watchpoint
;
7130 case bp_fast_tracepoint
:
7131 case bp_static_tracepoint
:
7132 loc
->loc_type
= bp_loc_other
;
7135 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
7141 /* Allocate a struct bp_location. */
7143 static struct bp_location
*
7144 allocate_bp_location (struct breakpoint
*bpt
)
7146 return bpt
->ops
->allocate_location (bpt
);
7150 free_bp_location (struct bp_location
*loc
)
7152 loc
->ops
->dtor (loc
);
7156 /* Increment reference count. */
7159 incref_bp_location (struct bp_location
*bl
)
7164 /* Decrement reference count. If the reference count reaches 0,
7165 destroy the bp_location. Sets *BLP to NULL. */
7168 decref_bp_location (struct bp_location
**blp
)
7170 gdb_assert ((*blp
)->refc
> 0);
7172 if (--(*blp
)->refc
== 0)
7173 free_bp_location (*blp
);
7177 /* Add breakpoint B at the end of the global breakpoint chain. */
7180 add_to_breakpoint_chain (std::unique_ptr
<breakpoint
> &&b
)
7182 struct breakpoint
*b1
;
7183 struct breakpoint
*result
= b
.get ();
7185 /* Add this breakpoint to the end of the chain so that a list of
7186 breakpoints will come out in order of increasing numbers. */
7188 b1
= breakpoint_chain
;
7190 breakpoint_chain
= b
.release ();
7195 b1
->next
= b
.release ();
7201 /* Initializes breakpoint B with type BPTYPE and no locations yet. */
7204 init_raw_breakpoint_without_location (struct breakpoint
*b
,
7205 struct gdbarch
*gdbarch
,
7207 const struct breakpoint_ops
*ops
)
7209 gdb_assert (ops
!= NULL
);
7213 b
->gdbarch
= gdbarch
;
7214 b
->language
= current_language
->la_language
;
7215 b
->input_radix
= input_radix
;
7216 b
->related_breakpoint
= b
;
7219 /* Helper to set_raw_breakpoint below. Creates a breakpoint
7220 that has type BPTYPE and has no locations as yet. */
7222 static struct breakpoint
*
7223 set_raw_breakpoint_without_location (struct gdbarch
*gdbarch
,
7225 const struct breakpoint_ops
*ops
)
7227 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (bptype
);
7229 init_raw_breakpoint_without_location (b
.get (), gdbarch
, bptype
, ops
);
7230 return add_to_breakpoint_chain (std::move (b
));
7233 /* Initialize loc->function_name. EXPLICIT_LOC says no indirect function
7234 resolutions should be made as the user specified the location explicitly
7238 set_breakpoint_location_function (struct bp_location
*loc
, int explicit_loc
)
7240 gdb_assert (loc
->owner
!= NULL
);
7242 if (loc
->owner
->type
== bp_breakpoint
7243 || loc
->owner
->type
== bp_hardware_breakpoint
7244 || is_tracepoint (loc
->owner
))
7247 const char *function_name
;
7248 CORE_ADDR func_addr
;
7250 find_pc_partial_function_gnu_ifunc (loc
->address
, &function_name
,
7251 &func_addr
, NULL
, &is_gnu_ifunc
);
7253 if (is_gnu_ifunc
&& !explicit_loc
)
7255 struct breakpoint
*b
= loc
->owner
;
7257 gdb_assert (loc
->pspace
== current_program_space
);
7258 if (gnu_ifunc_resolve_name (function_name
,
7259 &loc
->requested_address
))
7261 /* Recalculate ADDRESS based on new REQUESTED_ADDRESS. */
7262 loc
->address
= adjust_breakpoint_address (loc
->gdbarch
,
7263 loc
->requested_address
,
7266 else if (b
->type
== bp_breakpoint
&& b
->loc
== loc
7267 && loc
->next
== NULL
&& b
->related_breakpoint
== b
)
7269 /* Create only the whole new breakpoint of this type but do not
7270 mess more complicated breakpoints with multiple locations. */
7271 b
->type
= bp_gnu_ifunc_resolver
;
7272 /* Remember the resolver's address for use by the return
7274 loc
->related_address
= func_addr
;
7279 loc
->function_name
= xstrdup (function_name
);
7283 /* Attempt to determine architecture of location identified by SAL. */
7285 get_sal_arch (struct symtab_and_line sal
)
7288 return get_objfile_arch (sal
.section
->objfile
);
7290 return get_objfile_arch (SYMTAB_OBJFILE (sal
.symtab
));
7295 /* Low level routine for partially initializing a breakpoint of type
7296 BPTYPE. The newly created breakpoint's address, section, source
7297 file name, and line number are provided by SAL.
7299 It is expected that the caller will complete the initialization of
7300 the newly created breakpoint struct as well as output any status
7301 information regarding the creation of a new breakpoint. */
7304 init_raw_breakpoint (struct breakpoint
*b
, struct gdbarch
*gdbarch
,
7305 struct symtab_and_line sal
, enum bptype bptype
,
7306 const struct breakpoint_ops
*ops
)
7308 init_raw_breakpoint_without_location (b
, gdbarch
, bptype
, ops
);
7310 add_location_to_breakpoint (b
, &sal
);
7312 if (bptype
!= bp_catchpoint
)
7313 gdb_assert (sal
.pspace
!= NULL
);
7315 /* Store the program space that was used to set the breakpoint,
7316 except for ordinary breakpoints, which are independent of the
7318 if (bptype
!= bp_breakpoint
&& bptype
!= bp_hardware_breakpoint
)
7319 b
->pspace
= sal
.pspace
;
7322 /* set_raw_breakpoint is a low level routine for allocating and
7323 partially initializing a breakpoint of type BPTYPE. The newly
7324 created breakpoint's address, section, source file name, and line
7325 number are provided by SAL. The newly created and partially
7326 initialized breakpoint is added to the breakpoint chain and
7327 is also returned as the value of this function.
7329 It is expected that the caller will complete the initialization of
7330 the newly created breakpoint struct as well as output any status
7331 information regarding the creation of a new breakpoint. In
7332 particular, set_raw_breakpoint does NOT set the breakpoint
7333 number! Care should be taken to not allow an error to occur
7334 prior to completing the initialization of the breakpoint. If this
7335 should happen, a bogus breakpoint will be left on the chain. */
7338 set_raw_breakpoint (struct gdbarch
*gdbarch
,
7339 struct symtab_and_line sal
, enum bptype bptype
,
7340 const struct breakpoint_ops
*ops
)
7342 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (bptype
);
7344 init_raw_breakpoint (b
.get (), gdbarch
, sal
, bptype
, ops
);
7345 return add_to_breakpoint_chain (std::move (b
));
7348 /* Call this routine when stepping and nexting to enable a breakpoint
7349 if we do a longjmp() or 'throw' in TP. FRAME is the frame which
7350 initiated the operation. */
7353 set_longjmp_breakpoint (struct thread_info
*tp
, struct frame_id frame
)
7355 struct breakpoint
*b
, *b_tmp
;
7356 int thread
= tp
->global_num
;
7358 /* To avoid having to rescan all objfile symbols at every step,
7359 we maintain a list of continually-inserted but always disabled
7360 longjmp "master" breakpoints. Here, we simply create momentary
7361 clones of those and enable them for the requested thread. */
7362 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7363 if (b
->pspace
== current_program_space
7364 && (b
->type
== bp_longjmp_master
7365 || b
->type
== bp_exception_master
))
7367 enum bptype type
= b
->type
== bp_longjmp_master
? bp_longjmp
: bp_exception
;
7368 struct breakpoint
*clone
;
7370 /* longjmp_breakpoint_ops ensures INITIATING_FRAME is cleared again
7371 after their removal. */
7372 clone
= momentary_breakpoint_from_master (b
, type
,
7373 &momentary_breakpoint_ops
, 1);
7374 clone
->thread
= thread
;
7377 tp
->initiating_frame
= frame
;
7380 /* Delete all longjmp breakpoints from THREAD. */
7382 delete_longjmp_breakpoint (int thread
)
7384 struct breakpoint
*b
, *b_tmp
;
7386 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7387 if (b
->type
== bp_longjmp
|| b
->type
== bp_exception
)
7389 if (b
->thread
== thread
)
7390 delete_breakpoint (b
);
7395 delete_longjmp_breakpoint_at_next_stop (int thread
)
7397 struct breakpoint
*b
, *b_tmp
;
7399 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7400 if (b
->type
== bp_longjmp
|| b
->type
== bp_exception
)
7402 if (b
->thread
== thread
)
7403 b
->disposition
= disp_del_at_next_stop
;
7407 /* Place breakpoints of type bp_longjmp_call_dummy to catch longjmp for
7408 INFERIOR_PTID thread. Chain them all by RELATED_BREAKPOINT and return
7409 pointer to any of them. Return NULL if this system cannot place longjmp
7413 set_longjmp_breakpoint_for_call_dummy (void)
7415 struct breakpoint
*b
, *retval
= NULL
;
7418 if (b
->pspace
== current_program_space
&& b
->type
== bp_longjmp_master
)
7420 struct breakpoint
*new_b
;
7422 new_b
= momentary_breakpoint_from_master (b
, bp_longjmp_call_dummy
,
7423 &momentary_breakpoint_ops
,
7425 new_b
->thread
= ptid_to_global_thread_id (inferior_ptid
);
7427 /* Link NEW_B into the chain of RETVAL breakpoints. */
7429 gdb_assert (new_b
->related_breakpoint
== new_b
);
7432 new_b
->related_breakpoint
= retval
;
7433 while (retval
->related_breakpoint
!= new_b
->related_breakpoint
)
7434 retval
= retval
->related_breakpoint
;
7435 retval
->related_breakpoint
= new_b
;
7441 /* Verify all existing dummy frames and their associated breakpoints for
7442 TP. Remove those which can no longer be found in the current frame
7445 You should call this function only at places where it is safe to currently
7446 unwind the whole stack. Failed stack unwind would discard live dummy
7450 check_longjmp_breakpoint_for_call_dummy (struct thread_info
*tp
)
7452 struct breakpoint
*b
, *b_tmp
;
7454 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7455 if (b
->type
== bp_longjmp_call_dummy
&& b
->thread
== tp
->global_num
)
7457 struct breakpoint
*dummy_b
= b
->related_breakpoint
;
7459 while (dummy_b
!= b
&& dummy_b
->type
!= bp_call_dummy
)
7460 dummy_b
= dummy_b
->related_breakpoint
;
7461 if (dummy_b
->type
!= bp_call_dummy
7462 || frame_find_by_id (dummy_b
->frame_id
) != NULL
)
7465 dummy_frame_discard (dummy_b
->frame_id
, tp
->ptid
);
7467 while (b
->related_breakpoint
!= b
)
7469 if (b_tmp
== b
->related_breakpoint
)
7470 b_tmp
= b
->related_breakpoint
->next
;
7471 delete_breakpoint (b
->related_breakpoint
);
7473 delete_breakpoint (b
);
7478 enable_overlay_breakpoints (void)
7480 struct breakpoint
*b
;
7483 if (b
->type
== bp_overlay_event
)
7485 b
->enable_state
= bp_enabled
;
7486 update_global_location_list (UGLL_MAY_INSERT
);
7487 overlay_events_enabled
= 1;
7492 disable_overlay_breakpoints (void)
7494 struct breakpoint
*b
;
7497 if (b
->type
== bp_overlay_event
)
7499 b
->enable_state
= bp_disabled
;
7500 update_global_location_list (UGLL_DONT_INSERT
);
7501 overlay_events_enabled
= 0;
7505 /* Set an active std::terminate breakpoint for each std::terminate
7506 master breakpoint. */
7508 set_std_terminate_breakpoint (void)
7510 struct breakpoint
*b
, *b_tmp
;
7512 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7513 if (b
->pspace
== current_program_space
7514 && b
->type
== bp_std_terminate_master
)
7516 momentary_breakpoint_from_master (b
, bp_std_terminate
,
7517 &momentary_breakpoint_ops
, 1);
7521 /* Delete all the std::terminate breakpoints. */
7523 delete_std_terminate_breakpoint (void)
7525 struct breakpoint
*b
, *b_tmp
;
7527 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7528 if (b
->type
== bp_std_terminate
)
7529 delete_breakpoint (b
);
7533 create_thread_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7535 struct breakpoint
*b
;
7537 b
= create_internal_breakpoint (gdbarch
, address
, bp_thread_event
,
7538 &internal_breakpoint_ops
);
7540 b
->enable_state
= bp_enabled
;
7541 /* location has to be used or breakpoint_re_set will delete me. */
7542 b
->location
= new_address_location (b
->loc
->address
, NULL
, 0);
7544 update_global_location_list_nothrow (UGLL_MAY_INSERT
);
7549 struct lang_and_radix
7555 /* Create a breakpoint for JIT code registration and unregistration. */
7558 create_jit_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7560 return create_internal_breakpoint (gdbarch
, address
, bp_jit_event
,
7561 &internal_breakpoint_ops
);
7564 /* Remove JIT code registration and unregistration breakpoint(s). */
7567 remove_jit_event_breakpoints (void)
7569 struct breakpoint
*b
, *b_tmp
;
7571 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7572 if (b
->type
== bp_jit_event
7573 && b
->loc
->pspace
== current_program_space
)
7574 delete_breakpoint (b
);
7578 remove_solib_event_breakpoints (void)
7580 struct breakpoint
*b
, *b_tmp
;
7582 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7583 if (b
->type
== bp_shlib_event
7584 && b
->loc
->pspace
== current_program_space
)
7585 delete_breakpoint (b
);
7588 /* See breakpoint.h. */
7591 remove_solib_event_breakpoints_at_next_stop (void)
7593 struct breakpoint
*b
, *b_tmp
;
7595 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7596 if (b
->type
== bp_shlib_event
7597 && b
->loc
->pspace
== current_program_space
)
7598 b
->disposition
= disp_del_at_next_stop
;
7601 /* Helper for create_solib_event_breakpoint /
7602 create_and_insert_solib_event_breakpoint. Allows specifying which
7603 INSERT_MODE to pass through to update_global_location_list. */
7605 static struct breakpoint
*
7606 create_solib_event_breakpoint_1 (struct gdbarch
*gdbarch
, CORE_ADDR address
,
7607 enum ugll_insert_mode insert_mode
)
7609 struct breakpoint
*b
;
7611 b
= create_internal_breakpoint (gdbarch
, address
, bp_shlib_event
,
7612 &internal_breakpoint_ops
);
7613 update_global_location_list_nothrow (insert_mode
);
7618 create_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7620 return create_solib_event_breakpoint_1 (gdbarch
, address
, UGLL_MAY_INSERT
);
7623 /* See breakpoint.h. */
7626 create_and_insert_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7628 struct breakpoint
*b
;
7630 /* Explicitly tell update_global_location_list to insert
7632 b
= create_solib_event_breakpoint_1 (gdbarch
, address
, UGLL_INSERT
);
7633 if (!b
->loc
->inserted
)
7635 delete_breakpoint (b
);
7641 /* Disable any breakpoints that are on code in shared libraries. Only
7642 apply to enabled breakpoints, disabled ones can just stay disabled. */
7645 disable_breakpoints_in_shlibs (void)
7647 struct bp_location
*loc
, **locp_tmp
;
7649 ALL_BP_LOCATIONS (loc
, locp_tmp
)
7651 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7652 struct breakpoint
*b
= loc
->owner
;
7654 /* We apply the check to all breakpoints, including disabled for
7655 those with loc->duplicate set. This is so that when breakpoint
7656 becomes enabled, or the duplicate is removed, gdb will try to
7657 insert all breakpoints. If we don't set shlib_disabled here,
7658 we'll try to insert those breakpoints and fail. */
7659 if (((b
->type
== bp_breakpoint
)
7660 || (b
->type
== bp_jit_event
)
7661 || (b
->type
== bp_hardware_breakpoint
)
7662 || (is_tracepoint (b
)))
7663 && loc
->pspace
== current_program_space
7664 && !loc
->shlib_disabled
7665 && solib_name_from_address (loc
->pspace
, loc
->address
)
7668 loc
->shlib_disabled
= 1;
7673 /* Disable any breakpoints and tracepoints that are in SOLIB upon
7674 notification of unloaded_shlib. Only apply to enabled breakpoints,
7675 disabled ones can just stay disabled. */
7678 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
7680 struct bp_location
*loc
, **locp_tmp
;
7681 int disabled_shlib_breaks
= 0;
7683 ALL_BP_LOCATIONS (loc
, locp_tmp
)
7685 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7686 struct breakpoint
*b
= loc
->owner
;
7688 if (solib
->pspace
== loc
->pspace
7689 && !loc
->shlib_disabled
7690 && (((b
->type
== bp_breakpoint
7691 || b
->type
== bp_jit_event
7692 || b
->type
== bp_hardware_breakpoint
)
7693 && (loc
->loc_type
== bp_loc_hardware_breakpoint
7694 || loc
->loc_type
== bp_loc_software_breakpoint
))
7695 || is_tracepoint (b
))
7696 && solib_contains_address_p (solib
, loc
->address
))
7698 loc
->shlib_disabled
= 1;
7699 /* At this point, we cannot rely on remove_breakpoint
7700 succeeding so we must mark the breakpoint as not inserted
7701 to prevent future errors occurring in remove_breakpoints. */
7704 /* This may cause duplicate notifications for the same breakpoint. */
7705 observer_notify_breakpoint_modified (b
);
7707 if (!disabled_shlib_breaks
)
7709 target_terminal::ours_for_output ();
7710 warning (_("Temporarily disabling breakpoints "
7711 "for unloaded shared library \"%s\""),
7714 disabled_shlib_breaks
= 1;
7719 /* Disable any breakpoints and tracepoints in OBJFILE upon
7720 notification of free_objfile. Only apply to enabled breakpoints,
7721 disabled ones can just stay disabled. */
7724 disable_breakpoints_in_freed_objfile (struct objfile
*objfile
)
7726 struct breakpoint
*b
;
7728 if (objfile
== NULL
)
7731 /* OBJF_SHARED|OBJF_USERLOADED objfiles are dynamic modules manually
7732 managed by the user with add-symbol-file/remove-symbol-file.
7733 Similarly to how breakpoints in shared libraries are handled in
7734 response to "nosharedlibrary", mark breakpoints in such modules
7735 shlib_disabled so they end up uninserted on the next global
7736 location list update. Shared libraries not loaded by the user
7737 aren't handled here -- they're already handled in
7738 disable_breakpoints_in_unloaded_shlib, called by solib.c's
7739 solib_unloaded observer. We skip objfiles that are not
7740 OBJF_SHARED as those aren't considered dynamic objects (e.g. the
7742 if ((objfile
->flags
& OBJF_SHARED
) == 0
7743 || (objfile
->flags
& OBJF_USERLOADED
) == 0)
7748 struct bp_location
*loc
;
7749 int bp_modified
= 0;
7751 if (!is_breakpoint (b
) && !is_tracepoint (b
))
7754 for (loc
= b
->loc
; loc
!= NULL
; loc
= loc
->next
)
7756 CORE_ADDR loc_addr
= loc
->address
;
7758 if (loc
->loc_type
!= bp_loc_hardware_breakpoint
7759 && loc
->loc_type
!= bp_loc_software_breakpoint
)
7762 if (loc
->shlib_disabled
!= 0)
7765 if (objfile
->pspace
!= loc
->pspace
)
7768 if (loc
->loc_type
!= bp_loc_hardware_breakpoint
7769 && loc
->loc_type
!= bp_loc_software_breakpoint
)
7772 if (is_addr_in_objfile (loc_addr
, objfile
))
7774 loc
->shlib_disabled
= 1;
7775 /* At this point, we don't know whether the object was
7776 unmapped from the inferior or not, so leave the
7777 inserted flag alone. We'll handle failure to
7778 uninsert quietly, in case the object was indeed
7781 mark_breakpoint_location_modified (loc
);
7788 observer_notify_breakpoint_modified (b
);
7792 /* FORK & VFORK catchpoints. */
7794 /* An instance of this type is used to represent a fork or vfork
7795 catchpoint. A breakpoint is really of this type iff its ops pointer points
7796 to CATCH_FORK_BREAKPOINT_OPS. */
7798 struct fork_catchpoint
: public breakpoint
7800 /* Process id of a child process whose forking triggered this
7801 catchpoint. This field is only valid immediately after this
7802 catchpoint has triggered. */
7803 ptid_t forked_inferior_pid
;
7806 /* Implement the "insert" breakpoint_ops method for fork
7810 insert_catch_fork (struct bp_location
*bl
)
7812 return target_insert_fork_catchpoint (ptid_get_pid (inferior_ptid
));
7815 /* Implement the "remove" breakpoint_ops method for fork
7819 remove_catch_fork (struct bp_location
*bl
, enum remove_bp_reason reason
)
7821 return target_remove_fork_catchpoint (ptid_get_pid (inferior_ptid
));
7824 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
7828 breakpoint_hit_catch_fork (const struct bp_location
*bl
,
7829 struct address_space
*aspace
, CORE_ADDR bp_addr
,
7830 const struct target_waitstatus
*ws
)
7832 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bl
->owner
;
7834 if (ws
->kind
!= TARGET_WAITKIND_FORKED
)
7837 c
->forked_inferior_pid
= ws
->value
.related_pid
;
7841 /* Implement the "print_it" breakpoint_ops method for fork
7844 static enum print_stop_action
7845 print_it_catch_fork (bpstat bs
)
7847 struct ui_out
*uiout
= current_uiout
;
7848 struct breakpoint
*b
= bs
->breakpoint_at
;
7849 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bs
->breakpoint_at
;
7851 annotate_catchpoint (b
->number
);
7852 maybe_print_thread_hit_breakpoint (uiout
);
7853 if (b
->disposition
== disp_del
)
7854 uiout
->text ("Temporary catchpoint ");
7856 uiout
->text ("Catchpoint ");
7857 if (uiout
->is_mi_like_p ())
7859 uiout
->field_string ("reason", async_reason_lookup (EXEC_ASYNC_FORK
));
7860 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
7862 uiout
->field_int ("bkptno", b
->number
);
7863 uiout
->text (" (forked process ");
7864 uiout
->field_int ("newpid", ptid_get_pid (c
->forked_inferior_pid
));
7865 uiout
->text ("), ");
7866 return PRINT_SRC_AND_LOC
;
7869 /* Implement the "print_one" breakpoint_ops method for fork
7873 print_one_catch_fork (struct breakpoint
*b
, struct bp_location
**last_loc
)
7875 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
7876 struct value_print_options opts
;
7877 struct ui_out
*uiout
= current_uiout
;
7879 get_user_print_options (&opts
);
7881 /* Field 4, the address, is omitted (which makes the columns not
7882 line up too nicely with the headers, but the effect is relatively
7884 if (opts
.addressprint
)
7885 uiout
->field_skip ("addr");
7887 uiout
->text ("fork");
7888 if (!ptid_equal (c
->forked_inferior_pid
, null_ptid
))
7890 uiout
->text (", process ");
7891 uiout
->field_int ("what", ptid_get_pid (c
->forked_inferior_pid
));
7895 if (uiout
->is_mi_like_p ())
7896 uiout
->field_string ("catch-type", "fork");
7899 /* Implement the "print_mention" breakpoint_ops method for fork
7903 print_mention_catch_fork (struct breakpoint
*b
)
7905 printf_filtered (_("Catchpoint %d (fork)"), b
->number
);
7908 /* Implement the "print_recreate" breakpoint_ops method for fork
7912 print_recreate_catch_fork (struct breakpoint
*b
, struct ui_file
*fp
)
7914 fprintf_unfiltered (fp
, "catch fork");
7915 print_recreate_thread (b
, fp
);
7918 /* The breakpoint_ops structure to be used in fork catchpoints. */
7920 static struct breakpoint_ops catch_fork_breakpoint_ops
;
7922 /* Implement the "insert" breakpoint_ops method for vfork
7926 insert_catch_vfork (struct bp_location
*bl
)
7928 return target_insert_vfork_catchpoint (ptid_get_pid (inferior_ptid
));
7931 /* Implement the "remove" breakpoint_ops method for vfork
7935 remove_catch_vfork (struct bp_location
*bl
, enum remove_bp_reason reason
)
7937 return target_remove_vfork_catchpoint (ptid_get_pid (inferior_ptid
));
7940 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
7944 breakpoint_hit_catch_vfork (const struct bp_location
*bl
,
7945 struct address_space
*aspace
, CORE_ADDR bp_addr
,
7946 const struct target_waitstatus
*ws
)
7948 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bl
->owner
;
7950 if (ws
->kind
!= TARGET_WAITKIND_VFORKED
)
7953 c
->forked_inferior_pid
= ws
->value
.related_pid
;
7957 /* Implement the "print_it" breakpoint_ops method for vfork
7960 static enum print_stop_action
7961 print_it_catch_vfork (bpstat bs
)
7963 struct ui_out
*uiout
= current_uiout
;
7964 struct breakpoint
*b
= bs
->breakpoint_at
;
7965 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
7967 annotate_catchpoint (b
->number
);
7968 maybe_print_thread_hit_breakpoint (uiout
);
7969 if (b
->disposition
== disp_del
)
7970 uiout
->text ("Temporary catchpoint ");
7972 uiout
->text ("Catchpoint ");
7973 if (uiout
->is_mi_like_p ())
7975 uiout
->field_string ("reason", async_reason_lookup (EXEC_ASYNC_VFORK
));
7976 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
7978 uiout
->field_int ("bkptno", b
->number
);
7979 uiout
->text (" (vforked process ");
7980 uiout
->field_int ("newpid", ptid_get_pid (c
->forked_inferior_pid
));
7981 uiout
->text ("), ");
7982 return PRINT_SRC_AND_LOC
;
7985 /* Implement the "print_one" breakpoint_ops method for vfork
7989 print_one_catch_vfork (struct breakpoint
*b
, struct bp_location
**last_loc
)
7991 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
7992 struct value_print_options opts
;
7993 struct ui_out
*uiout
= current_uiout
;
7995 get_user_print_options (&opts
);
7996 /* Field 4, the address, is omitted (which makes the columns not
7997 line up too nicely with the headers, but the effect is relatively
7999 if (opts
.addressprint
)
8000 uiout
->field_skip ("addr");
8002 uiout
->text ("vfork");
8003 if (!ptid_equal (c
->forked_inferior_pid
, null_ptid
))
8005 uiout
->text (", process ");
8006 uiout
->field_int ("what", ptid_get_pid (c
->forked_inferior_pid
));
8010 if (uiout
->is_mi_like_p ())
8011 uiout
->field_string ("catch-type", "vfork");
8014 /* Implement the "print_mention" breakpoint_ops method for vfork
8018 print_mention_catch_vfork (struct breakpoint
*b
)
8020 printf_filtered (_("Catchpoint %d (vfork)"), b
->number
);
8023 /* Implement the "print_recreate" breakpoint_ops method for vfork
8027 print_recreate_catch_vfork (struct breakpoint
*b
, struct ui_file
*fp
)
8029 fprintf_unfiltered (fp
, "catch vfork");
8030 print_recreate_thread (b
, fp
);
8033 /* The breakpoint_ops structure to be used in vfork catchpoints. */
8035 static struct breakpoint_ops catch_vfork_breakpoint_ops
;
8037 /* An instance of this type is used to represent an solib catchpoint.
8038 A breakpoint is really of this type iff its ops pointer points to
8039 CATCH_SOLIB_BREAKPOINT_OPS. */
8041 struct solib_catchpoint
: public breakpoint
8043 ~solib_catchpoint () override
;
8045 /* True for "catch load", false for "catch unload". */
8046 unsigned char is_load
;
8048 /* Regular expression to match, if any. COMPILED is only valid when
8049 REGEX is non-NULL. */
8051 std::unique_ptr
<compiled_regex
> compiled
;
8054 solib_catchpoint::~solib_catchpoint ()
8056 xfree (this->regex
);
8060 insert_catch_solib (struct bp_location
*ignore
)
8066 remove_catch_solib (struct bp_location
*ignore
, enum remove_bp_reason reason
)
8072 breakpoint_hit_catch_solib (const struct bp_location
*bl
,
8073 struct address_space
*aspace
,
8075 const struct target_waitstatus
*ws
)
8077 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) bl
->owner
;
8078 struct breakpoint
*other
;
8080 if (ws
->kind
== TARGET_WAITKIND_LOADED
)
8083 ALL_BREAKPOINTS (other
)
8085 struct bp_location
*other_bl
;
8087 if (other
== bl
->owner
)
8090 if (other
->type
!= bp_shlib_event
)
8093 if (self
->pspace
!= NULL
&& other
->pspace
!= self
->pspace
)
8096 for (other_bl
= other
->loc
; other_bl
!= NULL
; other_bl
= other_bl
->next
)
8098 if (other
->ops
->breakpoint_hit (other_bl
, aspace
, bp_addr
, ws
))
8107 check_status_catch_solib (struct bpstats
*bs
)
8109 struct solib_catchpoint
*self
8110 = (struct solib_catchpoint
*) bs
->breakpoint_at
;
8115 struct so_list
*iter
;
8118 VEC_iterate (so_list_ptr
, current_program_space
->added_solibs
,
8123 || self
->compiled
->exec (iter
->so_name
, 0, NULL
, 0) == 0)
8132 VEC_iterate (char_ptr
, current_program_space
->deleted_solibs
,
8137 || self
->compiled
->exec (iter
, 0, NULL
, 0) == 0)
8143 bs
->print_it
= print_it_noop
;
8146 static enum print_stop_action
8147 print_it_catch_solib (bpstat bs
)
8149 struct breakpoint
*b
= bs
->breakpoint_at
;
8150 struct ui_out
*uiout
= current_uiout
;
8152 annotate_catchpoint (b
->number
);
8153 maybe_print_thread_hit_breakpoint (uiout
);
8154 if (b
->disposition
== disp_del
)
8155 uiout
->text ("Temporary catchpoint ");
8157 uiout
->text ("Catchpoint ");
8158 uiout
->field_int ("bkptno", b
->number
);
8160 if (uiout
->is_mi_like_p ())
8161 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
8162 print_solib_event (1);
8163 return PRINT_SRC_AND_LOC
;
8167 print_one_catch_solib (struct breakpoint
*b
, struct bp_location
**locs
)
8169 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8170 struct value_print_options opts
;
8171 struct ui_out
*uiout
= current_uiout
;
8174 get_user_print_options (&opts
);
8175 /* Field 4, the address, is omitted (which makes the columns not
8176 line up too nicely with the headers, but the effect is relatively
8178 if (opts
.addressprint
)
8181 uiout
->field_skip ("addr");
8188 msg
= xstrprintf (_("load of library matching %s"), self
->regex
);
8190 msg
= xstrdup (_("load of library"));
8195 msg
= xstrprintf (_("unload of library matching %s"), self
->regex
);
8197 msg
= xstrdup (_("unload of library"));
8199 uiout
->field_string ("what", msg
);
8202 if (uiout
->is_mi_like_p ())
8203 uiout
->field_string ("catch-type", self
->is_load
? "load" : "unload");
8207 print_mention_catch_solib (struct breakpoint
*b
)
8209 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8211 printf_filtered (_("Catchpoint %d (%s)"), b
->number
,
8212 self
->is_load
? "load" : "unload");
8216 print_recreate_catch_solib (struct breakpoint
*b
, struct ui_file
*fp
)
8218 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8220 fprintf_unfiltered (fp
, "%s %s",
8221 b
->disposition
== disp_del
? "tcatch" : "catch",
8222 self
->is_load
? "load" : "unload");
8224 fprintf_unfiltered (fp
, " %s", self
->regex
);
8225 fprintf_unfiltered (fp
, "\n");
8228 static struct breakpoint_ops catch_solib_breakpoint_ops
;
8230 /* Shared helper function (MI and CLI) for creating and installing
8231 a shared object event catchpoint. If IS_LOAD is non-zero then
8232 the events to be caught are load events, otherwise they are
8233 unload events. If IS_TEMP is non-zero the catchpoint is a
8234 temporary one. If ENABLED is non-zero the catchpoint is
8235 created in an enabled state. */
8238 add_solib_catchpoint (const char *arg
, int is_load
, int is_temp
, int enabled
)
8240 struct gdbarch
*gdbarch
= get_current_arch ();
8244 arg
= skip_spaces (arg
);
8246 std::unique_ptr
<solib_catchpoint
> c (new solib_catchpoint ());
8250 c
->compiled
.reset (new compiled_regex (arg
, REG_NOSUB
,
8251 _("Invalid regexp")));
8252 c
->regex
= xstrdup (arg
);
8255 c
->is_load
= is_load
;
8256 init_catchpoint (c
.get (), gdbarch
, is_temp
, NULL
,
8257 &catch_solib_breakpoint_ops
);
8259 c
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
8261 install_breakpoint (0, std::move (c
), 1);
8264 /* A helper function that does all the work for "catch load" and
8268 catch_load_or_unload (char *arg
, int from_tty
, int is_load
,
8269 struct cmd_list_element
*command
)
8272 const int enabled
= 1;
8274 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
8276 add_solib_catchpoint (arg
, is_load
, tempflag
, enabled
);
8280 catch_load_command_1 (char *arg
, int from_tty
,
8281 struct cmd_list_element
*command
)
8283 catch_load_or_unload (arg
, from_tty
, 1, command
);
8287 catch_unload_command_1 (char *arg
, int from_tty
,
8288 struct cmd_list_element
*command
)
8290 catch_load_or_unload (arg
, from_tty
, 0, command
);
8293 /* Initialize a new breakpoint of the bp_catchpoint kind. If TEMPFLAG
8294 is non-zero, then make the breakpoint temporary. If COND_STRING is
8295 not NULL, then store it in the breakpoint. OPS, if not NULL, is
8296 the breakpoint_ops structure associated to the catchpoint. */
8299 init_catchpoint (struct breakpoint
*b
,
8300 struct gdbarch
*gdbarch
, int tempflag
,
8301 const char *cond_string
,
8302 const struct breakpoint_ops
*ops
)
8304 symtab_and_line sal
;
8305 sal
.pspace
= current_program_space
;
8307 init_raw_breakpoint (b
, gdbarch
, sal
, bp_catchpoint
, ops
);
8309 b
->cond_string
= (cond_string
== NULL
) ? NULL
: xstrdup (cond_string
);
8310 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
8314 install_breakpoint (int internal
, std::unique_ptr
<breakpoint
> &&arg
, int update_gll
)
8316 breakpoint
*b
= add_to_breakpoint_chain (std::move (arg
));
8317 set_breakpoint_number (internal
, b
);
8318 if (is_tracepoint (b
))
8319 set_tracepoint_count (breakpoint_count
);
8322 observer_notify_breakpoint_created (b
);
8325 update_global_location_list (UGLL_MAY_INSERT
);
8329 create_fork_vfork_event_catchpoint (struct gdbarch
*gdbarch
,
8330 int tempflag
, const char *cond_string
,
8331 const struct breakpoint_ops
*ops
)
8333 std::unique_ptr
<fork_catchpoint
> c (new fork_catchpoint ());
8335 init_catchpoint (c
.get (), gdbarch
, tempflag
, cond_string
, ops
);
8337 c
->forked_inferior_pid
= null_ptid
;
8339 install_breakpoint (0, std::move (c
), 1);
8342 /* Exec catchpoints. */
8344 /* An instance of this type is used to represent an exec catchpoint.
8345 A breakpoint is really of this type iff its ops pointer points to
8346 CATCH_EXEC_BREAKPOINT_OPS. */
8348 struct exec_catchpoint
: public breakpoint
8350 ~exec_catchpoint () override
;
8352 /* Filename of a program whose exec triggered this catchpoint.
8353 This field is only valid immediately after this catchpoint has
8355 char *exec_pathname
;
8358 /* Exec catchpoint destructor. */
8360 exec_catchpoint::~exec_catchpoint ()
8362 xfree (this->exec_pathname
);
8366 insert_catch_exec (struct bp_location
*bl
)
8368 return target_insert_exec_catchpoint (ptid_get_pid (inferior_ptid
));
8372 remove_catch_exec (struct bp_location
*bl
, enum remove_bp_reason reason
)
8374 return target_remove_exec_catchpoint (ptid_get_pid (inferior_ptid
));
8378 breakpoint_hit_catch_exec (const struct bp_location
*bl
,
8379 struct address_space
*aspace
, CORE_ADDR bp_addr
,
8380 const struct target_waitstatus
*ws
)
8382 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) bl
->owner
;
8384 if (ws
->kind
!= TARGET_WAITKIND_EXECD
)
8387 c
->exec_pathname
= xstrdup (ws
->value
.execd_pathname
);
8391 static enum print_stop_action
8392 print_it_catch_exec (bpstat bs
)
8394 struct ui_out
*uiout
= current_uiout
;
8395 struct breakpoint
*b
= bs
->breakpoint_at
;
8396 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
8398 annotate_catchpoint (b
->number
);
8399 maybe_print_thread_hit_breakpoint (uiout
);
8400 if (b
->disposition
== disp_del
)
8401 uiout
->text ("Temporary catchpoint ");
8403 uiout
->text ("Catchpoint ");
8404 if (uiout
->is_mi_like_p ())
8406 uiout
->field_string ("reason", async_reason_lookup (EXEC_ASYNC_EXEC
));
8407 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
8409 uiout
->field_int ("bkptno", b
->number
);
8410 uiout
->text (" (exec'd ");
8411 uiout
->field_string ("new-exec", c
->exec_pathname
);
8412 uiout
->text ("), ");
8414 return PRINT_SRC_AND_LOC
;
8418 print_one_catch_exec (struct breakpoint
*b
, struct bp_location
**last_loc
)
8420 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
8421 struct value_print_options opts
;
8422 struct ui_out
*uiout
= current_uiout
;
8424 get_user_print_options (&opts
);
8426 /* Field 4, the address, is omitted (which makes the columns
8427 not line up too nicely with the headers, but the effect
8428 is relatively readable). */
8429 if (opts
.addressprint
)
8430 uiout
->field_skip ("addr");
8432 uiout
->text ("exec");
8433 if (c
->exec_pathname
!= NULL
)
8435 uiout
->text (", program \"");
8436 uiout
->field_string ("what", c
->exec_pathname
);
8437 uiout
->text ("\" ");
8440 if (uiout
->is_mi_like_p ())
8441 uiout
->field_string ("catch-type", "exec");
8445 print_mention_catch_exec (struct breakpoint
*b
)
8447 printf_filtered (_("Catchpoint %d (exec)"), b
->number
);
8450 /* Implement the "print_recreate" breakpoint_ops method for exec
8454 print_recreate_catch_exec (struct breakpoint
*b
, struct ui_file
*fp
)
8456 fprintf_unfiltered (fp
, "catch exec");
8457 print_recreate_thread (b
, fp
);
8460 static struct breakpoint_ops catch_exec_breakpoint_ops
;
8463 hw_breakpoint_used_count (void)
8466 struct breakpoint
*b
;
8467 struct bp_location
*bl
;
8471 if (b
->type
== bp_hardware_breakpoint
&& breakpoint_enabled (b
))
8472 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
8474 /* Special types of hardware breakpoints may use more than
8476 i
+= b
->ops
->resources_needed (bl
);
8483 /* Returns the resources B would use if it were a hardware
8487 hw_watchpoint_use_count (struct breakpoint
*b
)
8490 struct bp_location
*bl
;
8492 if (!breakpoint_enabled (b
))
8495 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
8497 /* Special types of hardware watchpoints may use more than
8499 i
+= b
->ops
->resources_needed (bl
);
8505 /* Returns the sum the used resources of all hardware watchpoints of
8506 type TYPE in the breakpoints list. Also returns in OTHER_TYPE_USED
8507 the sum of the used resources of all hardware watchpoints of other
8508 types _not_ TYPE. */
8511 hw_watchpoint_used_count_others (struct breakpoint
*except
,
8512 enum bptype type
, int *other_type_used
)
8515 struct breakpoint
*b
;
8517 *other_type_used
= 0;
8522 if (!breakpoint_enabled (b
))
8525 if (b
->type
== type
)
8526 i
+= hw_watchpoint_use_count (b
);
8527 else if (is_hardware_watchpoint (b
))
8528 *other_type_used
= 1;
8535 disable_watchpoints_before_interactive_call_start (void)
8537 struct breakpoint
*b
;
8541 if (is_watchpoint (b
) && breakpoint_enabled (b
))
8543 b
->enable_state
= bp_call_disabled
;
8544 update_global_location_list (UGLL_DONT_INSERT
);
8550 enable_watchpoints_after_interactive_call_stop (void)
8552 struct breakpoint
*b
;
8556 if (is_watchpoint (b
) && b
->enable_state
== bp_call_disabled
)
8558 b
->enable_state
= bp_enabled
;
8559 update_global_location_list (UGLL_MAY_INSERT
);
8565 disable_breakpoints_before_startup (void)
8567 current_program_space
->executing_startup
= 1;
8568 update_global_location_list (UGLL_DONT_INSERT
);
8572 enable_breakpoints_after_startup (void)
8574 current_program_space
->executing_startup
= 0;
8575 breakpoint_re_set ();
8578 /* Create a new single-step breakpoint for thread THREAD, with no
8581 static struct breakpoint
*
8582 new_single_step_breakpoint (int thread
, struct gdbarch
*gdbarch
)
8584 std::unique_ptr
<breakpoint
> b (new breakpoint ());
8586 init_raw_breakpoint_without_location (b
.get (), gdbarch
, bp_single_step
,
8587 &momentary_breakpoint_ops
);
8589 b
->disposition
= disp_donttouch
;
8590 b
->frame_id
= null_frame_id
;
8593 gdb_assert (b
->thread
!= 0);
8595 return add_to_breakpoint_chain (std::move (b
));
8598 /* Set a momentary breakpoint of type TYPE at address specified by
8599 SAL. If FRAME_ID is valid, the breakpoint is restricted to that
8603 set_momentary_breakpoint (struct gdbarch
*gdbarch
, struct symtab_and_line sal
,
8604 struct frame_id frame_id
, enum bptype type
)
8606 struct breakpoint
*b
;
8608 /* If FRAME_ID is valid, it should be a real frame, not an inlined or
8610 gdb_assert (!frame_id_artificial_p (frame_id
));
8612 b
= set_raw_breakpoint (gdbarch
, sal
, type
, &momentary_breakpoint_ops
);
8613 b
->enable_state
= bp_enabled
;
8614 b
->disposition
= disp_donttouch
;
8615 b
->frame_id
= frame_id
;
8617 /* If we're debugging a multi-threaded program, then we want
8618 momentary breakpoints to be active in only a single thread of
8620 if (in_thread_list (inferior_ptid
))
8621 b
->thread
= ptid_to_global_thread_id (inferior_ptid
);
8623 update_global_location_list_nothrow (UGLL_MAY_INSERT
);
8628 /* Make a momentary breakpoint based on the master breakpoint ORIG.
8629 The new breakpoint will have type TYPE, use OPS as its
8630 breakpoint_ops, and will set enabled to LOC_ENABLED. */
8632 static struct breakpoint
*
8633 momentary_breakpoint_from_master (struct breakpoint
*orig
,
8635 const struct breakpoint_ops
*ops
,
8638 struct breakpoint
*copy
;
8640 copy
= set_raw_breakpoint_without_location (orig
->gdbarch
, type
, ops
);
8641 copy
->loc
= allocate_bp_location (copy
);
8642 set_breakpoint_location_function (copy
->loc
, 1);
8644 copy
->loc
->gdbarch
= orig
->loc
->gdbarch
;
8645 copy
->loc
->requested_address
= orig
->loc
->requested_address
;
8646 copy
->loc
->address
= orig
->loc
->address
;
8647 copy
->loc
->section
= orig
->loc
->section
;
8648 copy
->loc
->pspace
= orig
->loc
->pspace
;
8649 copy
->loc
->probe
= orig
->loc
->probe
;
8650 copy
->loc
->line_number
= orig
->loc
->line_number
;
8651 copy
->loc
->symtab
= orig
->loc
->symtab
;
8652 copy
->loc
->enabled
= loc_enabled
;
8653 copy
->frame_id
= orig
->frame_id
;
8654 copy
->thread
= orig
->thread
;
8655 copy
->pspace
= orig
->pspace
;
8657 copy
->enable_state
= bp_enabled
;
8658 copy
->disposition
= disp_donttouch
;
8659 copy
->number
= internal_breakpoint_number
--;
8661 update_global_location_list_nothrow (UGLL_DONT_INSERT
);
8665 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
8669 clone_momentary_breakpoint (struct breakpoint
*orig
)
8671 /* If there's nothing to clone, then return nothing. */
8675 return momentary_breakpoint_from_master (orig
, orig
->type
, orig
->ops
, 0);
8679 set_momentary_breakpoint_at_pc (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
8682 struct symtab_and_line sal
;
8684 sal
= find_pc_line (pc
, 0);
8686 sal
.section
= find_pc_overlay (pc
);
8687 sal
.explicit_pc
= 1;
8689 return set_momentary_breakpoint (gdbarch
, sal
, null_frame_id
, type
);
8693 /* Tell the user we have just set a breakpoint B. */
8696 mention (struct breakpoint
*b
)
8698 b
->ops
->print_mention (b
);
8699 if (current_uiout
->is_mi_like_p ())
8701 printf_filtered ("\n");
8705 static int bp_loc_is_permanent (struct bp_location
*loc
);
8707 static struct bp_location
*
8708 add_location_to_breakpoint (struct breakpoint
*b
,
8709 const struct symtab_and_line
*sal
)
8711 struct bp_location
*loc
, **tmp
;
8712 CORE_ADDR adjusted_address
;
8713 struct gdbarch
*loc_gdbarch
= get_sal_arch (*sal
);
8715 if (loc_gdbarch
== NULL
)
8716 loc_gdbarch
= b
->gdbarch
;
8718 /* Adjust the breakpoint's address prior to allocating a location.
8719 Once we call allocate_bp_location(), that mostly uninitialized
8720 location will be placed on the location chain. Adjustment of the
8721 breakpoint may cause target_read_memory() to be called and we do
8722 not want its scan of the location chain to find a breakpoint and
8723 location that's only been partially initialized. */
8724 adjusted_address
= adjust_breakpoint_address (loc_gdbarch
,
8727 /* Sort the locations by their ADDRESS. */
8728 loc
= allocate_bp_location (b
);
8729 for (tmp
= &(b
->loc
); *tmp
!= NULL
&& (*tmp
)->address
<= adjusted_address
;
8730 tmp
= &((*tmp
)->next
))
8735 loc
->requested_address
= sal
->pc
;
8736 loc
->address
= adjusted_address
;
8737 loc
->pspace
= sal
->pspace
;
8738 loc
->probe
.probe
= sal
->probe
;
8739 loc
->probe
.objfile
= sal
->objfile
;
8740 gdb_assert (loc
->pspace
!= NULL
);
8741 loc
->section
= sal
->section
;
8742 loc
->gdbarch
= loc_gdbarch
;
8743 loc
->line_number
= sal
->line
;
8744 loc
->symtab
= sal
->symtab
;
8746 set_breakpoint_location_function (loc
,
8747 sal
->explicit_pc
|| sal
->explicit_line
);
8749 /* While by definition, permanent breakpoints are already present in the
8750 code, we don't mark the location as inserted. Normally one would expect
8751 that GDB could rely on that breakpoint instruction to stop the program,
8752 thus removing the need to insert its own breakpoint, except that executing
8753 the breakpoint instruction can kill the target instead of reporting a
8754 SIGTRAP. E.g., on SPARC, when interrupts are disabled, executing the
8755 instruction resets the CPU, so QEMU 2.0.0 for SPARC correspondingly dies
8756 with "Trap 0x02 while interrupts disabled, Error state". Letting the
8757 breakpoint be inserted normally results in QEMU knowing about the GDB
8758 breakpoint, and thus trap before the breakpoint instruction is executed.
8759 (If GDB later needs to continue execution past the permanent breakpoint,
8760 it manually increments the PC, thus avoiding executing the breakpoint
8762 if (bp_loc_is_permanent (loc
))
8769 /* See breakpoint.h. */
8772 program_breakpoint_here_p (struct gdbarch
*gdbarch
, CORE_ADDR address
)
8776 const gdb_byte
*bpoint
;
8777 gdb_byte
*target_mem
;
8780 bpoint
= gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &len
);
8782 /* Software breakpoints unsupported? */
8786 target_mem
= (gdb_byte
*) alloca (len
);
8788 /* Enable the automatic memory restoration from breakpoints while
8789 we read the memory. Otherwise we could say about our temporary
8790 breakpoints they are permanent. */
8791 scoped_restore restore_memory
8792 = make_scoped_restore_show_memory_breakpoints (0);
8794 if (target_read_memory (address
, target_mem
, len
) == 0
8795 && memcmp (target_mem
, bpoint
, len
) == 0)
8801 /* Return 1 if LOC is pointing to a permanent breakpoint,
8802 return 0 otherwise. */
8805 bp_loc_is_permanent (struct bp_location
*loc
)
8807 gdb_assert (loc
!= NULL
);
8809 /* If we have a catchpoint or a watchpoint, just return 0. We should not
8810 attempt to read from the addresses the locations of these breakpoint types
8811 point to. program_breakpoint_here_p, below, will attempt to read
8813 if (!breakpoint_address_is_meaningful (loc
->owner
))
8816 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
8817 switch_to_program_space_and_thread (loc
->pspace
);
8818 return program_breakpoint_here_p (loc
->gdbarch
, loc
->address
);
8821 /* Build a command list for the dprintf corresponding to the current
8822 settings of the dprintf style options. */
8825 update_dprintf_command_list (struct breakpoint
*b
)
8827 char *dprintf_args
= b
->extra_string
;
8828 char *printf_line
= NULL
;
8833 dprintf_args
= skip_spaces (dprintf_args
);
8835 /* Allow a comma, as it may have terminated a location, but don't
8837 if (*dprintf_args
== ',')
8839 dprintf_args
= skip_spaces (dprintf_args
);
8841 if (*dprintf_args
!= '"')
8842 error (_("Bad format string, missing '\"'."));
8844 if (strcmp (dprintf_style
, dprintf_style_gdb
) == 0)
8845 printf_line
= xstrprintf ("printf %s", dprintf_args
);
8846 else if (strcmp (dprintf_style
, dprintf_style_call
) == 0)
8848 if (!dprintf_function
)
8849 error (_("No function supplied for dprintf call"));
8851 if (dprintf_channel
&& strlen (dprintf_channel
) > 0)
8852 printf_line
= xstrprintf ("call (void) %s (%s,%s)",
8857 printf_line
= xstrprintf ("call (void) %s (%s)",
8861 else if (strcmp (dprintf_style
, dprintf_style_agent
) == 0)
8863 if (target_can_run_breakpoint_commands ())
8864 printf_line
= xstrprintf ("agent-printf %s", dprintf_args
);
8867 warning (_("Target cannot run dprintf commands, falling back to GDB printf"));
8868 printf_line
= xstrprintf ("printf %s", dprintf_args
);
8872 internal_error (__FILE__
, __LINE__
,
8873 _("Invalid dprintf style."));
8875 gdb_assert (printf_line
!= NULL
);
8876 /* Manufacture a printf sequence. */
8878 struct command_line
*printf_cmd_line
= XNEW (struct command_line
);
8880 printf_cmd_line
->control_type
= simple_control
;
8881 printf_cmd_line
->body_count
= 0;
8882 printf_cmd_line
->body_list
= NULL
;
8883 printf_cmd_line
->next
= NULL
;
8884 printf_cmd_line
->line
= printf_line
;
8886 breakpoint_set_commands (b
, command_line_up (printf_cmd_line
));
8890 /* Update all dprintf commands, making their command lists reflect
8891 current style settings. */
8894 update_dprintf_commands (char *args
, int from_tty
,
8895 struct cmd_list_element
*c
)
8897 struct breakpoint
*b
;
8901 if (b
->type
== bp_dprintf
)
8902 update_dprintf_command_list (b
);
8906 /* Create a breakpoint with SAL as location. Use LOCATION
8907 as a description of the location, and COND_STRING
8908 as condition expression. If LOCATION is NULL then create an
8909 "address location" from the address in the SAL. */
8912 init_breakpoint_sal (struct breakpoint
*b
, struct gdbarch
*gdbarch
,
8913 gdb::array_view
<const symtab_and_line
> sals
,
8914 event_location_up
&&location
,
8915 gdb::unique_xmalloc_ptr
<char> filter
,
8916 gdb::unique_xmalloc_ptr
<char> cond_string
,
8917 gdb::unique_xmalloc_ptr
<char> extra_string
,
8918 enum bptype type
, enum bpdisp disposition
,
8919 int thread
, int task
, int ignore_count
,
8920 const struct breakpoint_ops
*ops
, int from_tty
,
8921 int enabled
, int internal
, unsigned flags
,
8922 int display_canonical
)
8926 if (type
== bp_hardware_breakpoint
)
8928 int target_resources_ok
;
8930 i
= hw_breakpoint_used_count ();
8931 target_resources_ok
=
8932 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
8934 if (target_resources_ok
== 0)
8935 error (_("No hardware breakpoint support in the target."));
8936 else if (target_resources_ok
< 0)
8937 error (_("Hardware breakpoints used exceeds limit."));
8940 gdb_assert (!sals
.empty ());
8942 for (const auto &sal
: sals
)
8944 struct bp_location
*loc
;
8948 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
8950 loc_gdbarch
= gdbarch
;
8952 describe_other_breakpoints (loc_gdbarch
,
8953 sal
.pspace
, sal
.pc
, sal
.section
, thread
);
8956 if (&sal
== &sals
[0])
8958 init_raw_breakpoint (b
, gdbarch
, sal
, type
, ops
);
8962 b
->cond_string
= cond_string
.release ();
8963 b
->extra_string
= extra_string
.release ();
8964 b
->ignore_count
= ignore_count
;
8965 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
8966 b
->disposition
= disposition
;
8968 if ((flags
& CREATE_BREAKPOINT_FLAGS_INSERTED
) != 0)
8969 b
->loc
->inserted
= 1;
8971 if (type
== bp_static_tracepoint
)
8973 struct tracepoint
*t
= (struct tracepoint
*) b
;
8974 struct static_tracepoint_marker marker
;
8976 if (strace_marker_p (b
))
8978 /* We already know the marker exists, otherwise, we
8979 wouldn't see a sal for it. */
8981 = &event_location_to_string (b
->location
.get ())[3];
8985 p
= skip_spaces (p
);
8987 endp
= skip_to_space (p
);
8989 marker_str
= savestring (p
, endp
- p
);
8990 t
->static_trace_marker_id
= marker_str
;
8992 printf_filtered (_("Probed static tracepoint "
8994 t
->static_trace_marker_id
);
8996 else if (target_static_tracepoint_marker_at (sal
.pc
, &marker
))
8998 t
->static_trace_marker_id
= xstrdup (marker
.str_id
);
8999 release_static_tracepoint_marker (&marker
);
9001 printf_filtered (_("Probed static tracepoint "
9003 t
->static_trace_marker_id
);
9006 warning (_("Couldn't determine the static "
9007 "tracepoint marker to probe"));
9014 loc
= add_location_to_breakpoint (b
, &sal
);
9015 if ((flags
& CREATE_BREAKPOINT_FLAGS_INSERTED
) != 0)
9021 const char *arg
= b
->cond_string
;
9023 loc
->cond
= parse_exp_1 (&arg
, loc
->address
,
9024 block_for_pc (loc
->address
), 0);
9026 error (_("Garbage '%s' follows condition"), arg
);
9029 /* Dynamic printf requires and uses additional arguments on the
9030 command line, otherwise it's an error. */
9031 if (type
== bp_dprintf
)
9033 if (b
->extra_string
)
9034 update_dprintf_command_list (b
);
9036 error (_("Format string required"));
9038 else if (b
->extra_string
)
9039 error (_("Garbage '%s' at end of command"), b
->extra_string
);
9042 b
->display_canonical
= display_canonical
;
9043 if (location
!= NULL
)
9044 b
->location
= std::move (location
);
9046 b
->location
= new_address_location (b
->loc
->address
, NULL
, 0);
9047 b
->filter
= filter
.release ();
9051 create_breakpoint_sal (struct gdbarch
*gdbarch
,
9052 gdb::array_view
<const symtab_and_line
> sals
,
9053 event_location_up
&&location
,
9054 gdb::unique_xmalloc_ptr
<char> filter
,
9055 gdb::unique_xmalloc_ptr
<char> cond_string
,
9056 gdb::unique_xmalloc_ptr
<char> extra_string
,
9057 enum bptype type
, enum bpdisp disposition
,
9058 int thread
, int task
, int ignore_count
,
9059 const struct breakpoint_ops
*ops
, int from_tty
,
9060 int enabled
, int internal
, unsigned flags
,
9061 int display_canonical
)
9063 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (type
);
9065 init_breakpoint_sal (b
.get (), gdbarch
,
9066 sals
, std::move (location
),
9068 std::move (cond_string
),
9069 std::move (extra_string
),
9071 thread
, task
, ignore_count
,
9073 enabled
, internal
, flags
,
9076 install_breakpoint (internal
, std::move (b
), 0);
9079 /* Add SALS.nelts breakpoints to the breakpoint table. For each
9080 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
9081 value. COND_STRING, if not NULL, specified the condition to be
9082 used for all breakpoints. Essentially the only case where
9083 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
9084 function. In that case, it's still not possible to specify
9085 separate conditions for different overloaded functions, so
9086 we take just a single condition string.
9088 NOTE: If the function succeeds, the caller is expected to cleanup
9089 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
9090 array contents). If the function fails (error() is called), the
9091 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
9092 COND and SALS arrays and each of those arrays contents. */
9095 create_breakpoints_sal (struct gdbarch
*gdbarch
,
9096 struct linespec_result
*canonical
,
9097 gdb::unique_xmalloc_ptr
<char> cond_string
,
9098 gdb::unique_xmalloc_ptr
<char> extra_string
,
9099 enum bptype type
, enum bpdisp disposition
,
9100 int thread
, int task
, int ignore_count
,
9101 const struct breakpoint_ops
*ops
, int from_tty
,
9102 int enabled
, int internal
, unsigned flags
)
9104 if (canonical
->pre_expanded
)
9105 gdb_assert (canonical
->lsals
.size () == 1);
9107 for (const auto &lsal
: canonical
->lsals
)
9109 /* Note that 'location' can be NULL in the case of a plain
9110 'break', without arguments. */
9111 event_location_up location
9112 = (canonical
->location
!= NULL
9113 ? copy_event_location (canonical
->location
.get ()) : NULL
);
9114 gdb::unique_xmalloc_ptr
<char> filter_string
9115 (lsal
.canonical
!= NULL
? xstrdup (lsal
.canonical
) : NULL
);
9117 create_breakpoint_sal (gdbarch
, lsal
.sals
,
9118 std::move (location
),
9119 std::move (filter_string
),
9120 std::move (cond_string
),
9121 std::move (extra_string
),
9123 thread
, task
, ignore_count
, ops
,
9124 from_tty
, enabled
, internal
, flags
,
9125 canonical
->special_display
);
9129 /* Parse LOCATION which is assumed to be a SAL specification possibly
9130 followed by conditionals. On return, SALS contains an array of SAL
9131 addresses found. LOCATION points to the end of the SAL (for
9132 linespec locations).
9134 The array and the line spec strings are allocated on the heap, it is
9135 the caller's responsibility to free them. */
9138 parse_breakpoint_sals (const struct event_location
*location
,
9139 struct linespec_result
*canonical
)
9141 struct symtab_and_line cursal
;
9143 if (event_location_type (location
) == LINESPEC_LOCATION
)
9145 const char *address
= get_linespec_location (location
);
9147 if (address
== NULL
)
9149 /* The last displayed codepoint, if it's valid, is our default
9150 breakpoint address. */
9151 if (last_displayed_sal_is_valid ())
9153 /* Set sal's pspace, pc, symtab, and line to the values
9154 corresponding to the last call to print_frame_info.
9155 Be sure to reinitialize LINE with NOTCURRENT == 0
9156 as the breakpoint line number is inappropriate otherwise.
9157 find_pc_line would adjust PC, re-set it back. */
9158 symtab_and_line sal
= get_last_displayed_sal ();
9159 CORE_ADDR pc
= sal
.pc
;
9161 sal
= find_pc_line (pc
, 0);
9163 /* "break" without arguments is equivalent to "break *PC"
9164 where PC is the last displayed codepoint's address. So
9165 make sure to set sal.explicit_pc to prevent GDB from
9166 trying to expand the list of sals to include all other
9167 instances with the same symtab and line. */
9169 sal
.explicit_pc
= 1;
9171 struct linespec_sals lsal
;
9173 lsal
.canonical
= NULL
;
9175 canonical
->lsals
.push_back (std::move (lsal
));
9179 error (_("No default breakpoint address now."));
9183 /* Force almost all breakpoints to be in terms of the
9184 current_source_symtab (which is decode_line_1's default).
9185 This should produce the results we want almost all of the
9186 time while leaving default_breakpoint_* alone.
9188 ObjC: However, don't match an Objective-C method name which
9189 may have a '+' or '-' succeeded by a '['. */
9190 cursal
= get_current_source_symtab_and_line ();
9191 if (last_displayed_sal_is_valid ())
9193 const char *address
= NULL
;
9195 if (event_location_type (location
) == LINESPEC_LOCATION
)
9196 address
= get_linespec_location (location
);
9200 && strchr ("+-", address
[0]) != NULL
9201 && address
[1] != '['))
9203 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, NULL
,
9204 get_last_displayed_symtab (),
9205 get_last_displayed_line (),
9206 canonical
, NULL
, NULL
);
9211 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, NULL
,
9212 cursal
.symtab
, cursal
.line
, canonical
, NULL
, NULL
);
9216 /* Convert each SAL into a real PC. Verify that the PC can be
9217 inserted as a breakpoint. If it can't throw an error. */
9220 breakpoint_sals_to_pc (std::vector
<symtab_and_line
> &sals
)
9222 for (auto &sal
: sals
)
9223 resolve_sal_pc (&sal
);
9226 /* Fast tracepoints may have restrictions on valid locations. For
9227 instance, a fast tracepoint using a jump instead of a trap will
9228 likely have to overwrite more bytes than a trap would, and so can
9229 only be placed where the instruction is longer than the jump, or a
9230 multi-instruction sequence does not have a jump into the middle of
9234 check_fast_tracepoint_sals (struct gdbarch
*gdbarch
,
9235 gdb::array_view
<const symtab_and_line
> sals
)
9239 struct cleanup
*old_chain
;
9241 for (const auto &sal
: sals
)
9243 struct gdbarch
*sarch
;
9245 sarch
= get_sal_arch (sal
);
9246 /* We fall back to GDBARCH if there is no architecture
9247 associated with SAL. */
9250 rslt
= gdbarch_fast_tracepoint_valid_at (sarch
, sal
.pc
, &msg
);
9251 old_chain
= make_cleanup (xfree
, msg
);
9254 error (_("May not have a fast tracepoint at %s%s"),
9255 paddress (sarch
, sal
.pc
), (msg
? msg
: ""));
9257 do_cleanups (old_chain
);
9261 /* Given TOK, a string specification of condition and thread, as
9262 accepted by the 'break' command, extract the condition
9263 string and thread number and set *COND_STRING and *THREAD.
9264 PC identifies the context at which the condition should be parsed.
9265 If no condition is found, *COND_STRING is set to NULL.
9266 If no thread is found, *THREAD is set to -1. */
9269 find_condition_and_thread (const char *tok
, CORE_ADDR pc
,
9270 char **cond_string
, int *thread
, int *task
,
9273 *cond_string
= NULL
;
9280 const char *end_tok
;
9282 const char *cond_start
= NULL
;
9283 const char *cond_end
= NULL
;
9285 tok
= skip_spaces (tok
);
9287 if ((*tok
== '"' || *tok
== ',') && rest
)
9289 *rest
= savestring (tok
, strlen (tok
));
9293 end_tok
= skip_to_space (tok
);
9295 toklen
= end_tok
- tok
;
9297 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
9299 tok
= cond_start
= end_tok
+ 1;
9300 parse_exp_1 (&tok
, pc
, block_for_pc (pc
), 0);
9302 *cond_string
= savestring (cond_start
, cond_end
- cond_start
);
9304 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
9307 struct thread_info
*thr
;
9310 thr
= parse_thread_id (tok
, &tmptok
);
9312 error (_("Junk after thread keyword."));
9313 *thread
= thr
->global_num
;
9316 else if (toklen
>= 1 && strncmp (tok
, "task", toklen
) == 0)
9321 *task
= strtol (tok
, &tmptok
, 0);
9323 error (_("Junk after task keyword."));
9324 if (!valid_task_id (*task
))
9325 error (_("Unknown task %d."), *task
);
9330 *rest
= savestring (tok
, strlen (tok
));
9334 error (_("Junk at end of arguments."));
9338 /* Decode a static tracepoint marker spec. */
9340 static std::vector
<symtab_and_line
>
9341 decode_static_tracepoint_spec (const char **arg_p
)
9343 VEC(static_tracepoint_marker_p
) *markers
= NULL
;
9344 const char *p
= &(*arg_p
)[3];
9348 p
= skip_spaces (p
);
9350 endp
= skip_to_space (p
);
9352 std::string
marker_str (p
, endp
- p
);
9354 markers
= target_static_tracepoint_markers_by_strid (marker_str
.c_str ());
9355 if (VEC_empty(static_tracepoint_marker_p
, markers
))
9356 error (_("No known static tracepoint marker named %s"),
9357 marker_str
.c_str ());
9359 std::vector
<symtab_and_line
> sals
;
9360 sals
.reserve (VEC_length(static_tracepoint_marker_p
, markers
));
9362 for (i
= 0; i
< VEC_length(static_tracepoint_marker_p
, markers
); i
++)
9364 struct static_tracepoint_marker
*marker
;
9366 marker
= VEC_index (static_tracepoint_marker_p
, markers
, i
);
9368 symtab_and_line sal
= find_pc_line (marker
->address
, 0);
9369 sal
.pc
= marker
->address
;
9370 sals
.push_back (sal
);
9372 release_static_tracepoint_marker (marker
);
9379 /* See breakpoint.h. */
9382 create_breakpoint (struct gdbarch
*gdbarch
,
9383 const struct event_location
*location
,
9384 const char *cond_string
,
9385 int thread
, const char *extra_string
,
9387 int tempflag
, enum bptype type_wanted
,
9389 enum auto_boolean pending_break_support
,
9390 const struct breakpoint_ops
*ops
,
9391 int from_tty
, int enabled
, int internal
,
9394 struct linespec_result canonical
;
9395 struct cleanup
*bkpt_chain
= NULL
;
9398 int prev_bkpt_count
= breakpoint_count
;
9400 gdb_assert (ops
!= NULL
);
9402 /* If extra_string isn't useful, set it to NULL. */
9403 if (extra_string
!= NULL
&& *extra_string
== '\0')
9404 extra_string
= NULL
;
9408 ops
->create_sals_from_location (location
, &canonical
, type_wanted
);
9410 CATCH (e
, RETURN_MASK_ERROR
)
9412 /* If caller is interested in rc value from parse, set
9414 if (e
.error
== NOT_FOUND_ERROR
)
9416 /* If pending breakpoint support is turned off, throw
9419 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
9420 throw_exception (e
);
9422 exception_print (gdb_stderr
, e
);
9424 /* If pending breakpoint support is auto query and the user
9425 selects no, then simply return the error code. */
9426 if (pending_break_support
== AUTO_BOOLEAN_AUTO
9427 && !nquery (_("Make %s pending on future shared library load? "),
9428 bptype_string (type_wanted
)))
9431 /* At this point, either the user was queried about setting
9432 a pending breakpoint and selected yes, or pending
9433 breakpoint behavior is on and thus a pending breakpoint
9434 is defaulted on behalf of the user. */
9438 throw_exception (e
);
9442 if (!pending
&& canonical
.lsals
.empty ())
9445 /* ----------------------------- SNIP -----------------------------
9446 Anything added to the cleanup chain beyond this point is assumed
9447 to be part of a breakpoint. If the breakpoint create succeeds
9448 then the memory is not reclaimed. */
9449 bkpt_chain
= make_cleanup (null_cleanup
, 0);
9451 /* Resolve all line numbers to PC's and verify that the addresses
9452 are ok for the target. */
9455 for (auto &lsal
: canonical
.lsals
)
9456 breakpoint_sals_to_pc (lsal
.sals
);
9459 /* Fast tracepoints may have additional restrictions on location. */
9460 if (!pending
&& type_wanted
== bp_fast_tracepoint
)
9462 for (const auto &lsal
: canonical
.lsals
)
9463 check_fast_tracepoint_sals (gdbarch
, lsal
.sals
);
9466 /* Verify that condition can be parsed, before setting any
9467 breakpoints. Allocate a separate condition expression for each
9471 gdb::unique_xmalloc_ptr
<char> cond_string_copy
;
9472 gdb::unique_xmalloc_ptr
<char> extra_string_copy
;
9479 const linespec_sals
&lsal
= canonical
.lsals
[0];
9481 /* Here we only parse 'arg' to separate condition
9482 from thread number, so parsing in context of first
9483 sal is OK. When setting the breakpoint we'll
9484 re-parse it in context of each sal. */
9486 find_condition_and_thread (extra_string
, lsal
.sals
[0].pc
,
9487 &cond
, &thread
, &task
, &rest
);
9488 cond_string_copy
.reset (cond
);
9489 extra_string_copy
.reset (rest
);
9493 if (type_wanted
!= bp_dprintf
9494 && extra_string
!= NULL
&& *extra_string
!= '\0')
9495 error (_("Garbage '%s' at end of location"), extra_string
);
9497 /* Create a private copy of condition string. */
9499 cond_string_copy
.reset (xstrdup (cond_string
));
9500 /* Create a private copy of any extra string. */
9502 extra_string_copy
.reset (xstrdup (extra_string
));
9505 ops
->create_breakpoints_sal (gdbarch
, &canonical
,
9506 std::move (cond_string_copy
),
9507 std::move (extra_string_copy
),
9509 tempflag
? disp_del
: disp_donttouch
,
9510 thread
, task
, ignore_count
, ops
,
9511 from_tty
, enabled
, internal
, flags
);
9515 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (type_wanted
);
9517 init_raw_breakpoint_without_location (b
.get (), gdbarch
, type_wanted
, ops
);
9518 b
->location
= copy_event_location (location
);
9521 b
->cond_string
= NULL
;
9524 /* Create a private copy of condition string. */
9525 b
->cond_string
= cond_string
!= NULL
? xstrdup (cond_string
) : NULL
;
9529 /* Create a private copy of any extra string. */
9530 b
->extra_string
= extra_string
!= NULL
? xstrdup (extra_string
) : NULL
;
9531 b
->ignore_count
= ignore_count
;
9532 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
9533 b
->condition_not_parsed
= 1;
9534 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
9535 if ((type_wanted
!= bp_breakpoint
9536 && type_wanted
!= bp_hardware_breakpoint
) || thread
!= -1)
9537 b
->pspace
= current_program_space
;
9539 install_breakpoint (internal
, std::move (b
), 0);
9542 if (canonical
.lsals
.size () > 1)
9544 warning (_("Multiple breakpoints were set.\nUse the "
9545 "\"delete\" command to delete unwanted breakpoints."));
9546 prev_breakpoint_count
= prev_bkpt_count
;
9549 /* That's it. Discard the cleanups for data inserted into the
9551 discard_cleanups (bkpt_chain
);
9553 /* error call may happen here - have BKPT_CHAIN already discarded. */
9554 update_global_location_list (UGLL_MAY_INSERT
);
9559 /* Set a breakpoint.
9560 ARG is a string describing breakpoint address,
9561 condition, and thread.
9562 FLAG specifies if a breakpoint is hardware on,
9563 and if breakpoint is temporary, using BP_HARDWARE_FLAG
9567 break_command_1 (const char *arg
, int flag
, int from_tty
)
9569 int tempflag
= flag
& BP_TEMPFLAG
;
9570 enum bptype type_wanted
= (flag
& BP_HARDWAREFLAG
9571 ? bp_hardware_breakpoint
9573 struct breakpoint_ops
*ops
;
9575 event_location_up location
= string_to_event_location (&arg
, current_language
);
9577 /* Matching breakpoints on probes. */
9578 if (location
!= NULL
9579 && event_location_type (location
.get ()) == PROBE_LOCATION
)
9580 ops
= &bkpt_probe_breakpoint_ops
;
9582 ops
= &bkpt_breakpoint_ops
;
9584 create_breakpoint (get_current_arch (),
9586 NULL
, 0, arg
, 1 /* parse arg */,
9587 tempflag
, type_wanted
,
9588 0 /* Ignore count */,
9589 pending_break_support
,
9597 /* Helper function for break_command_1 and disassemble_command. */
9600 resolve_sal_pc (struct symtab_and_line
*sal
)
9604 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
9606 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
9607 error (_("No line %d in file \"%s\"."),
9608 sal
->line
, symtab_to_filename_for_display (sal
->symtab
));
9611 /* If this SAL corresponds to a breakpoint inserted using a line
9612 number, then skip the function prologue if necessary. */
9613 if (sal
->explicit_line
)
9614 skip_prologue_sal (sal
);
9617 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
9619 const struct blockvector
*bv
;
9620 const struct block
*b
;
9623 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
,
9624 SYMTAB_COMPUNIT (sal
->symtab
));
9627 sym
= block_linkage_function (b
);
9630 fixup_symbol_section (sym
, SYMTAB_OBJFILE (sal
->symtab
));
9631 sal
->section
= SYMBOL_OBJ_SECTION (SYMTAB_OBJFILE (sal
->symtab
),
9636 /* It really is worthwhile to have the section, so we'll
9637 just have to look harder. This case can be executed
9638 if we have line numbers but no functions (as can
9639 happen in assembly source). */
9641 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
9642 switch_to_program_space_and_thread (sal
->pspace
);
9644 bound_minimal_symbol msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
9646 sal
->section
= MSYMBOL_OBJ_SECTION (msym
.objfile
, msym
.minsym
);
9653 break_command (char *arg
, int from_tty
)
9655 break_command_1 (arg
, 0, from_tty
);
9659 tbreak_command (char *arg
, int from_tty
)
9661 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
9665 hbreak_command (char *arg
, int from_tty
)
9667 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
9671 thbreak_command (char *arg
, int from_tty
)
9673 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
9677 stop_command (char *arg
, int from_tty
)
9679 printf_filtered (_("Specify the type of breakpoint to set.\n\
9680 Usage: stop in <function | address>\n\
9681 stop at <line>\n"));
9685 stopin_command (const char *arg
, int from_tty
)
9689 if (arg
== (char *) NULL
)
9691 else if (*arg
!= '*')
9693 const char *argptr
= arg
;
9696 /* Look for a ':'. If this is a line number specification, then
9697 say it is bad, otherwise, it should be an address or
9698 function/method name. */
9699 while (*argptr
&& !hasColon
)
9701 hasColon
= (*argptr
== ':');
9706 badInput
= (*argptr
!= ':'); /* Not a class::method */
9708 badInput
= isdigit (*arg
); /* a simple line number */
9712 printf_filtered (_("Usage: stop in <function | address>\n"));
9714 break_command_1 (arg
, 0, from_tty
);
9718 stopat_command (const char *arg
, int from_tty
)
9722 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
9726 const char *argptr
= arg
;
9729 /* Look for a ':'. If there is a '::' then get out, otherwise
9730 it is probably a line number. */
9731 while (*argptr
&& !hasColon
)
9733 hasColon
= (*argptr
== ':');
9738 badInput
= (*argptr
== ':'); /* we have class::method */
9740 badInput
= !isdigit (*arg
); /* not a line number */
9744 printf_filtered (_("Usage: stop at <line>\n"));
9746 break_command_1 (arg
, 0, from_tty
);
9749 /* The dynamic printf command is mostly like a regular breakpoint, but
9750 with a prewired command list consisting of a single output command,
9751 built from extra arguments supplied on the dprintf command
9755 dprintf_command (char *arg_in
, int from_tty
)
9757 const char *arg
= arg_in
;
9758 event_location_up location
= string_to_event_location (&arg
, current_language
);
9760 /* If non-NULL, ARG should have been advanced past the location;
9761 the next character must be ','. */
9764 if (arg
[0] != ',' || arg
[1] == '\0')
9765 error (_("Format string required"));
9768 /* Skip the comma. */
9773 create_breakpoint (get_current_arch (),
9775 NULL
, 0, arg
, 1 /* parse arg */,
9777 0 /* Ignore count */,
9778 pending_break_support
,
9779 &dprintf_breakpoint_ops
,
9787 agent_printf_command (char *arg
, int from_tty
)
9789 error (_("May only run agent-printf on the target"));
9792 /* Implement the "breakpoint_hit" breakpoint_ops method for
9793 ranged breakpoints. */
9796 breakpoint_hit_ranged_breakpoint (const struct bp_location
*bl
,
9797 struct address_space
*aspace
,
9799 const struct target_waitstatus
*ws
)
9801 if (ws
->kind
!= TARGET_WAITKIND_STOPPED
9802 || ws
->value
.sig
!= GDB_SIGNAL_TRAP
)
9805 return breakpoint_address_match_range (bl
->pspace
->aspace
, bl
->address
,
9806 bl
->length
, aspace
, bp_addr
);
9809 /* Implement the "resources_needed" breakpoint_ops method for
9810 ranged breakpoints. */
9813 resources_needed_ranged_breakpoint (const struct bp_location
*bl
)
9815 return target_ranged_break_num_registers ();
9818 /* Implement the "print_it" breakpoint_ops method for
9819 ranged breakpoints. */
9821 static enum print_stop_action
9822 print_it_ranged_breakpoint (bpstat bs
)
9824 struct breakpoint
*b
= bs
->breakpoint_at
;
9825 struct bp_location
*bl
= b
->loc
;
9826 struct ui_out
*uiout
= current_uiout
;
9828 gdb_assert (b
->type
== bp_hardware_breakpoint
);
9830 /* Ranged breakpoints have only one location. */
9831 gdb_assert (bl
&& bl
->next
== NULL
);
9833 annotate_breakpoint (b
->number
);
9835 maybe_print_thread_hit_breakpoint (uiout
);
9837 if (b
->disposition
== disp_del
)
9838 uiout
->text ("Temporary ranged breakpoint ");
9840 uiout
->text ("Ranged breakpoint ");
9841 if (uiout
->is_mi_like_p ())
9843 uiout
->field_string ("reason",
9844 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
9845 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
9847 uiout
->field_int ("bkptno", b
->number
);
9850 return PRINT_SRC_AND_LOC
;
9853 /* Implement the "print_one" breakpoint_ops method for
9854 ranged breakpoints. */
9857 print_one_ranged_breakpoint (struct breakpoint
*b
,
9858 struct bp_location
**last_loc
)
9860 struct bp_location
*bl
= b
->loc
;
9861 struct value_print_options opts
;
9862 struct ui_out
*uiout
= current_uiout
;
9864 /* Ranged breakpoints have only one location. */
9865 gdb_assert (bl
&& bl
->next
== NULL
);
9867 get_user_print_options (&opts
);
9869 if (opts
.addressprint
)
9870 /* We don't print the address range here, it will be printed later
9871 by print_one_detail_ranged_breakpoint. */
9872 uiout
->field_skip ("addr");
9874 print_breakpoint_location (b
, bl
);
9878 /* Implement the "print_one_detail" breakpoint_ops method for
9879 ranged breakpoints. */
9882 print_one_detail_ranged_breakpoint (const struct breakpoint
*b
,
9883 struct ui_out
*uiout
)
9885 CORE_ADDR address_start
, address_end
;
9886 struct bp_location
*bl
= b
->loc
;
9891 address_start
= bl
->address
;
9892 address_end
= address_start
+ bl
->length
- 1;
9894 uiout
->text ("\taddress range: ");
9895 stb
.printf ("[%s, %s]",
9896 print_core_address (bl
->gdbarch
, address_start
),
9897 print_core_address (bl
->gdbarch
, address_end
));
9898 uiout
->field_stream ("addr", stb
);
9902 /* Implement the "print_mention" breakpoint_ops method for
9903 ranged breakpoints. */
9906 print_mention_ranged_breakpoint (struct breakpoint
*b
)
9908 struct bp_location
*bl
= b
->loc
;
9909 struct ui_out
*uiout
= current_uiout
;
9912 gdb_assert (b
->type
== bp_hardware_breakpoint
);
9914 if (uiout
->is_mi_like_p ())
9917 printf_filtered (_("Hardware assisted ranged breakpoint %d from %s to %s."),
9918 b
->number
, paddress (bl
->gdbarch
, bl
->address
),
9919 paddress (bl
->gdbarch
, bl
->address
+ bl
->length
- 1));
9922 /* Implement the "print_recreate" breakpoint_ops method for
9923 ranged breakpoints. */
9926 print_recreate_ranged_breakpoint (struct breakpoint
*b
, struct ui_file
*fp
)
9928 fprintf_unfiltered (fp
, "break-range %s, %s",
9929 event_location_to_string (b
->location
.get ()),
9930 event_location_to_string (b
->location_range_end
.get ()));
9931 print_recreate_thread (b
, fp
);
9934 /* The breakpoint_ops structure to be used in ranged breakpoints. */
9936 static struct breakpoint_ops ranged_breakpoint_ops
;
9938 /* Find the address where the end of the breakpoint range should be
9939 placed, given the SAL of the end of the range. This is so that if
9940 the user provides a line number, the end of the range is set to the
9941 last instruction of the given line. */
9944 find_breakpoint_range_end (struct symtab_and_line sal
)
9948 /* If the user provided a PC value, use it. Otherwise,
9949 find the address of the end of the given location. */
9950 if (sal
.explicit_pc
)
9957 ret
= find_line_pc_range (sal
, &start
, &end
);
9959 error (_("Could not find location of the end of the range."));
9961 /* find_line_pc_range returns the start of the next line. */
9968 /* Implement the "break-range" CLI command. */
9971 break_range_command (char *arg_in
, int from_tty
)
9973 const char *arg
= arg_in
;
9974 const char *arg_start
;
9975 struct linespec_result canonical_start
, canonical_end
;
9976 int bp_count
, can_use_bp
, length
;
9978 struct breakpoint
*b
;
9980 /* We don't support software ranged breakpoints. */
9981 if (target_ranged_break_num_registers () < 0)
9982 error (_("This target does not support hardware ranged breakpoints."));
9984 bp_count
= hw_breakpoint_used_count ();
9985 bp_count
+= target_ranged_break_num_registers ();
9986 can_use_bp
= target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
9989 error (_("Hardware breakpoints used exceeds limit."));
9991 arg
= skip_spaces (arg
);
9992 if (arg
== NULL
|| arg
[0] == '\0')
9993 error(_("No address range specified."));
9996 event_location_up start_location
= string_to_event_location (&arg
,
9998 parse_breakpoint_sals (start_location
.get (), &canonical_start
);
10001 error (_("Too few arguments."));
10002 else if (canonical_start
.lsals
.empty ())
10003 error (_("Could not find location of the beginning of the range."));
10005 const linespec_sals
&lsal_start
= canonical_start
.lsals
[0];
10007 if (canonical_start
.lsals
.size () > 1
10008 || lsal_start
.sals
.size () != 1)
10009 error (_("Cannot create a ranged breakpoint with multiple locations."));
10011 const symtab_and_line
&sal_start
= lsal_start
.sals
[0];
10012 std::string
addr_string_start (arg_start
, arg
- arg_start
);
10014 arg
++; /* Skip the comma. */
10015 arg
= skip_spaces (arg
);
10017 /* Parse the end location. */
10021 /* We call decode_line_full directly here instead of using
10022 parse_breakpoint_sals because we need to specify the start location's
10023 symtab and line as the default symtab and line for the end of the
10024 range. This makes it possible to have ranges like "foo.c:27, +14",
10025 where +14 means 14 lines from the start location. */
10026 event_location_up end_location
= string_to_event_location (&arg
,
10028 decode_line_full (end_location
.get (), DECODE_LINE_FUNFIRSTLINE
, NULL
,
10029 sal_start
.symtab
, sal_start
.line
,
10030 &canonical_end
, NULL
, NULL
);
10032 if (canonical_end
.lsals
.empty ())
10033 error (_("Could not find location of the end of the range."));
10035 const linespec_sals
&lsal_end
= canonical_end
.lsals
[0];
10036 if (canonical_end
.lsals
.size () > 1
10037 || lsal_end
.sals
.size () != 1)
10038 error (_("Cannot create a ranged breakpoint with multiple locations."));
10040 const symtab_and_line
&sal_end
= lsal_end
.sals
[0];
10042 end
= find_breakpoint_range_end (sal_end
);
10043 if (sal_start
.pc
> end
)
10044 error (_("Invalid address range, end precedes start."));
10046 length
= end
- sal_start
.pc
+ 1;
10048 /* Length overflowed. */
10049 error (_("Address range too large."));
10050 else if (length
== 1)
10052 /* This range is simple enough to be handled by
10053 the `hbreak' command. */
10054 hbreak_command (&addr_string_start
[0], 1);
10059 /* Now set up the breakpoint. */
10060 b
= set_raw_breakpoint (get_current_arch (), sal_start
,
10061 bp_hardware_breakpoint
, &ranged_breakpoint_ops
);
10062 set_breakpoint_count (breakpoint_count
+ 1);
10063 b
->number
= breakpoint_count
;
10064 b
->disposition
= disp_donttouch
;
10065 b
->location
= std::move (start_location
);
10066 b
->location_range_end
= std::move (end_location
);
10067 b
->loc
->length
= length
;
10070 observer_notify_breakpoint_created (b
);
10071 update_global_location_list (UGLL_MAY_INSERT
);
10074 /* Return non-zero if EXP is verified as constant. Returned zero
10075 means EXP is variable. Also the constant detection may fail for
10076 some constant expressions and in such case still falsely return
10080 watchpoint_exp_is_const (const struct expression
*exp
)
10082 int i
= exp
->nelts
;
10088 /* We are only interested in the descriptor of each element. */
10089 operator_length (exp
, i
, &oplenp
, &argsp
);
10092 switch (exp
->elts
[i
].opcode
)
10102 case BINOP_LOGICAL_AND
:
10103 case BINOP_LOGICAL_OR
:
10104 case BINOP_BITWISE_AND
:
10105 case BINOP_BITWISE_IOR
:
10106 case BINOP_BITWISE_XOR
:
10108 case BINOP_NOTEQUAL
:
10134 case OP_OBJC_NSSTRING
:
10137 case UNOP_LOGICAL_NOT
:
10138 case UNOP_COMPLEMENT
:
10143 case UNOP_CAST_TYPE
:
10144 case UNOP_REINTERPRET_CAST
:
10145 case UNOP_DYNAMIC_CAST
:
10146 /* Unary, binary and ternary operators: We have to check
10147 their operands. If they are constant, then so is the
10148 result of that operation. For instance, if A and B are
10149 determined to be constants, then so is "A + B".
10151 UNOP_IND is one exception to the rule above, because the
10152 value of *ADDR is not necessarily a constant, even when
10157 /* Check whether the associated symbol is a constant.
10159 We use SYMBOL_CLASS rather than TYPE_CONST because it's
10160 possible that a buggy compiler could mark a variable as
10161 constant even when it is not, and TYPE_CONST would return
10162 true in this case, while SYMBOL_CLASS wouldn't.
10164 We also have to check for function symbols because they
10165 are always constant. */
10167 struct symbol
*s
= exp
->elts
[i
+ 2].symbol
;
10169 if (SYMBOL_CLASS (s
) != LOC_BLOCK
10170 && SYMBOL_CLASS (s
) != LOC_CONST
10171 && SYMBOL_CLASS (s
) != LOC_CONST_BYTES
)
10176 /* The default action is to return 0 because we are using
10177 the optimistic approach here: If we don't know something,
10178 then it is not a constant. */
10187 /* Watchpoint destructor. */
10189 watchpoint::~watchpoint ()
10191 xfree (this->exp_string
);
10192 xfree (this->exp_string_reparse
);
10193 value_free (this->val
);
10196 /* Implement the "re_set" breakpoint_ops method for watchpoints. */
10199 re_set_watchpoint (struct breakpoint
*b
)
10201 struct watchpoint
*w
= (struct watchpoint
*) b
;
10203 /* Watchpoint can be either on expression using entirely global
10204 variables, or it can be on local variables.
10206 Watchpoints of the first kind are never auto-deleted, and even
10207 persist across program restarts. Since they can use variables
10208 from shared libraries, we need to reparse expression as libraries
10209 are loaded and unloaded.
10211 Watchpoints on local variables can also change meaning as result
10212 of solib event. For example, if a watchpoint uses both a local
10213 and a global variables in expression, it's a local watchpoint,
10214 but unloading of a shared library will make the expression
10215 invalid. This is not a very common use case, but we still
10216 re-evaluate expression, to avoid surprises to the user.
10218 Note that for local watchpoints, we re-evaluate it only if
10219 watchpoints frame id is still valid. If it's not, it means the
10220 watchpoint is out of scope and will be deleted soon. In fact,
10221 I'm not sure we'll ever be called in this case.
10223 If a local watchpoint's frame id is still valid, then
10224 w->exp_valid_block is likewise valid, and we can safely use it.
10226 Don't do anything about disabled watchpoints, since they will be
10227 reevaluated again when enabled. */
10228 update_watchpoint (w
, 1 /* reparse */);
10231 /* Implement the "insert" breakpoint_ops method for hardware watchpoints. */
10234 insert_watchpoint (struct bp_location
*bl
)
10236 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10237 int length
= w
->exact
? 1 : bl
->length
;
10239 return target_insert_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
10240 w
->cond_exp
.get ());
10243 /* Implement the "remove" breakpoint_ops method for hardware watchpoints. */
10246 remove_watchpoint (struct bp_location
*bl
, enum remove_bp_reason reason
)
10248 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10249 int length
= w
->exact
? 1 : bl
->length
;
10251 return target_remove_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
10252 w
->cond_exp
.get ());
10256 breakpoint_hit_watchpoint (const struct bp_location
*bl
,
10257 struct address_space
*aspace
, CORE_ADDR bp_addr
,
10258 const struct target_waitstatus
*ws
)
10260 struct breakpoint
*b
= bl
->owner
;
10261 struct watchpoint
*w
= (struct watchpoint
*) b
;
10263 /* Continuable hardware watchpoints are treated as non-existent if the
10264 reason we stopped wasn't a hardware watchpoint (we didn't stop on
10265 some data address). Otherwise gdb won't stop on a break instruction
10266 in the code (not from a breakpoint) when a hardware watchpoint has
10267 been defined. Also skip watchpoints which we know did not trigger
10268 (did not match the data address). */
10269 if (is_hardware_watchpoint (b
)
10270 && w
->watchpoint_triggered
== watch_triggered_no
)
10277 check_status_watchpoint (bpstat bs
)
10279 gdb_assert (is_watchpoint (bs
->breakpoint_at
));
10281 bpstat_check_watchpoint (bs
);
10284 /* Implement the "resources_needed" breakpoint_ops method for
10285 hardware watchpoints. */
10288 resources_needed_watchpoint (const struct bp_location
*bl
)
10290 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10291 int length
= w
->exact
? 1 : bl
->length
;
10293 return target_region_ok_for_hw_watchpoint (bl
->address
, length
);
10296 /* Implement the "works_in_software_mode" breakpoint_ops method for
10297 hardware watchpoints. */
10300 works_in_software_mode_watchpoint (const struct breakpoint
*b
)
10302 /* Read and access watchpoints only work with hardware support. */
10303 return b
->type
== bp_watchpoint
|| b
->type
== bp_hardware_watchpoint
;
10306 static enum print_stop_action
10307 print_it_watchpoint (bpstat bs
)
10309 struct breakpoint
*b
;
10310 enum print_stop_action result
;
10311 struct watchpoint
*w
;
10312 struct ui_out
*uiout
= current_uiout
;
10314 gdb_assert (bs
->bp_location_at
!= NULL
);
10316 b
= bs
->breakpoint_at
;
10317 w
= (struct watchpoint
*) b
;
10319 annotate_watchpoint (b
->number
);
10320 maybe_print_thread_hit_breakpoint (uiout
);
10324 gdb::optional
<ui_out_emit_tuple
> tuple_emitter
;
10327 case bp_watchpoint
:
10328 case bp_hardware_watchpoint
:
10329 if (uiout
->is_mi_like_p ())
10330 uiout
->field_string
10331 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
10333 tuple_emitter
.emplace (uiout
, "value");
10334 uiout
->text ("\nOld value = ");
10335 watchpoint_value_print (bs
->old_val
, &stb
);
10336 uiout
->field_stream ("old", stb
);
10337 uiout
->text ("\nNew value = ");
10338 watchpoint_value_print (w
->val
, &stb
);
10339 uiout
->field_stream ("new", stb
);
10340 uiout
->text ("\n");
10341 /* More than one watchpoint may have been triggered. */
10342 result
= PRINT_UNKNOWN
;
10345 case bp_read_watchpoint
:
10346 if (uiout
->is_mi_like_p ())
10347 uiout
->field_string
10348 ("reason", async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
10350 tuple_emitter
.emplace (uiout
, "value");
10351 uiout
->text ("\nValue = ");
10352 watchpoint_value_print (w
->val
, &stb
);
10353 uiout
->field_stream ("value", stb
);
10354 uiout
->text ("\n");
10355 result
= PRINT_UNKNOWN
;
10358 case bp_access_watchpoint
:
10359 if (bs
->old_val
!= NULL
)
10361 if (uiout
->is_mi_like_p ())
10362 uiout
->field_string
10364 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
10366 tuple_emitter
.emplace (uiout
, "value");
10367 uiout
->text ("\nOld value = ");
10368 watchpoint_value_print (bs
->old_val
, &stb
);
10369 uiout
->field_stream ("old", stb
);
10370 uiout
->text ("\nNew value = ");
10375 if (uiout
->is_mi_like_p ())
10376 uiout
->field_string
10378 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
10379 tuple_emitter
.emplace (uiout
, "value");
10380 uiout
->text ("\nValue = ");
10382 watchpoint_value_print (w
->val
, &stb
);
10383 uiout
->field_stream ("new", stb
);
10384 uiout
->text ("\n");
10385 result
= PRINT_UNKNOWN
;
10388 result
= PRINT_UNKNOWN
;
10394 /* Implement the "print_mention" breakpoint_ops method for hardware
10398 print_mention_watchpoint (struct breakpoint
*b
)
10400 struct watchpoint
*w
= (struct watchpoint
*) b
;
10401 struct ui_out
*uiout
= current_uiout
;
10402 const char *tuple_name
;
10406 case bp_watchpoint
:
10407 uiout
->text ("Watchpoint ");
10408 tuple_name
= "wpt";
10410 case bp_hardware_watchpoint
:
10411 uiout
->text ("Hardware watchpoint ");
10412 tuple_name
= "wpt";
10414 case bp_read_watchpoint
:
10415 uiout
->text ("Hardware read watchpoint ");
10416 tuple_name
= "hw-rwpt";
10418 case bp_access_watchpoint
:
10419 uiout
->text ("Hardware access (read/write) watchpoint ");
10420 tuple_name
= "hw-awpt";
10423 internal_error (__FILE__
, __LINE__
,
10424 _("Invalid hardware watchpoint type."));
10427 ui_out_emit_tuple
tuple_emitter (uiout
, tuple_name
);
10428 uiout
->field_int ("number", b
->number
);
10429 uiout
->text (": ");
10430 uiout
->field_string ("exp", w
->exp_string
);
10433 /* Implement the "print_recreate" breakpoint_ops method for
10437 print_recreate_watchpoint (struct breakpoint
*b
, struct ui_file
*fp
)
10439 struct watchpoint
*w
= (struct watchpoint
*) b
;
10443 case bp_watchpoint
:
10444 case bp_hardware_watchpoint
:
10445 fprintf_unfiltered (fp
, "watch");
10447 case bp_read_watchpoint
:
10448 fprintf_unfiltered (fp
, "rwatch");
10450 case bp_access_watchpoint
:
10451 fprintf_unfiltered (fp
, "awatch");
10454 internal_error (__FILE__
, __LINE__
,
10455 _("Invalid watchpoint type."));
10458 fprintf_unfiltered (fp
, " %s", w
->exp_string
);
10459 print_recreate_thread (b
, fp
);
10462 /* Implement the "explains_signal" breakpoint_ops method for
10466 explains_signal_watchpoint (struct breakpoint
*b
, enum gdb_signal sig
)
10468 /* A software watchpoint cannot cause a signal other than
10469 GDB_SIGNAL_TRAP. */
10470 if (b
->type
== bp_watchpoint
&& sig
!= GDB_SIGNAL_TRAP
)
10476 /* The breakpoint_ops structure to be used in hardware watchpoints. */
10478 static struct breakpoint_ops watchpoint_breakpoint_ops
;
10480 /* Implement the "insert" breakpoint_ops method for
10481 masked hardware watchpoints. */
10484 insert_masked_watchpoint (struct bp_location
*bl
)
10486 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10488 return target_insert_mask_watchpoint (bl
->address
, w
->hw_wp_mask
,
10489 bl
->watchpoint_type
);
10492 /* Implement the "remove" breakpoint_ops method for
10493 masked hardware watchpoints. */
10496 remove_masked_watchpoint (struct bp_location
*bl
, enum remove_bp_reason reason
)
10498 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10500 return target_remove_mask_watchpoint (bl
->address
, w
->hw_wp_mask
,
10501 bl
->watchpoint_type
);
10504 /* Implement the "resources_needed" breakpoint_ops method for
10505 masked hardware watchpoints. */
10508 resources_needed_masked_watchpoint (const struct bp_location
*bl
)
10510 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10512 return target_masked_watch_num_registers (bl
->address
, w
->hw_wp_mask
);
10515 /* Implement the "works_in_software_mode" breakpoint_ops method for
10516 masked hardware watchpoints. */
10519 works_in_software_mode_masked_watchpoint (const struct breakpoint
*b
)
10524 /* Implement the "print_it" breakpoint_ops method for
10525 masked hardware watchpoints. */
10527 static enum print_stop_action
10528 print_it_masked_watchpoint (bpstat bs
)
10530 struct breakpoint
*b
= bs
->breakpoint_at
;
10531 struct ui_out
*uiout
= current_uiout
;
10533 /* Masked watchpoints have only one location. */
10534 gdb_assert (b
->loc
&& b
->loc
->next
== NULL
);
10536 annotate_watchpoint (b
->number
);
10537 maybe_print_thread_hit_breakpoint (uiout
);
10541 case bp_hardware_watchpoint
:
10542 if (uiout
->is_mi_like_p ())
10543 uiout
->field_string
10544 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
10547 case bp_read_watchpoint
:
10548 if (uiout
->is_mi_like_p ())
10549 uiout
->field_string
10550 ("reason", async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
10553 case bp_access_watchpoint
:
10554 if (uiout
->is_mi_like_p ())
10555 uiout
->field_string
10557 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
10560 internal_error (__FILE__
, __LINE__
,
10561 _("Invalid hardware watchpoint type."));
10565 uiout
->text (_("\n\
10566 Check the underlying instruction at PC for the memory\n\
10567 address and value which triggered this watchpoint.\n"));
10568 uiout
->text ("\n");
10570 /* More than one watchpoint may have been triggered. */
10571 return PRINT_UNKNOWN
;
10574 /* Implement the "print_one_detail" breakpoint_ops method for
10575 masked hardware watchpoints. */
10578 print_one_detail_masked_watchpoint (const struct breakpoint
*b
,
10579 struct ui_out
*uiout
)
10581 struct watchpoint
*w
= (struct watchpoint
*) b
;
10583 /* Masked watchpoints have only one location. */
10584 gdb_assert (b
->loc
&& b
->loc
->next
== NULL
);
10586 uiout
->text ("\tmask ");
10587 uiout
->field_core_addr ("mask", b
->loc
->gdbarch
, w
->hw_wp_mask
);
10588 uiout
->text ("\n");
10591 /* Implement the "print_mention" breakpoint_ops method for
10592 masked hardware watchpoints. */
10595 print_mention_masked_watchpoint (struct breakpoint
*b
)
10597 struct watchpoint
*w
= (struct watchpoint
*) b
;
10598 struct ui_out
*uiout
= current_uiout
;
10599 const char *tuple_name
;
10603 case bp_hardware_watchpoint
:
10604 uiout
->text ("Masked hardware watchpoint ");
10605 tuple_name
= "wpt";
10607 case bp_read_watchpoint
:
10608 uiout
->text ("Masked hardware read watchpoint ");
10609 tuple_name
= "hw-rwpt";
10611 case bp_access_watchpoint
:
10612 uiout
->text ("Masked hardware access (read/write) watchpoint ");
10613 tuple_name
= "hw-awpt";
10616 internal_error (__FILE__
, __LINE__
,
10617 _("Invalid hardware watchpoint type."));
10620 ui_out_emit_tuple
tuple_emitter (uiout
, tuple_name
);
10621 uiout
->field_int ("number", b
->number
);
10622 uiout
->text (": ");
10623 uiout
->field_string ("exp", w
->exp_string
);
10626 /* Implement the "print_recreate" breakpoint_ops method for
10627 masked hardware watchpoints. */
10630 print_recreate_masked_watchpoint (struct breakpoint
*b
, struct ui_file
*fp
)
10632 struct watchpoint
*w
= (struct watchpoint
*) b
;
10637 case bp_hardware_watchpoint
:
10638 fprintf_unfiltered (fp
, "watch");
10640 case bp_read_watchpoint
:
10641 fprintf_unfiltered (fp
, "rwatch");
10643 case bp_access_watchpoint
:
10644 fprintf_unfiltered (fp
, "awatch");
10647 internal_error (__FILE__
, __LINE__
,
10648 _("Invalid hardware watchpoint type."));
10651 sprintf_vma (tmp
, w
->hw_wp_mask
);
10652 fprintf_unfiltered (fp
, " %s mask 0x%s", w
->exp_string
, tmp
);
10653 print_recreate_thread (b
, fp
);
10656 /* The breakpoint_ops structure to be used in masked hardware watchpoints. */
10658 static struct breakpoint_ops masked_watchpoint_breakpoint_ops
;
10660 /* Tell whether the given watchpoint is a masked hardware watchpoint. */
10663 is_masked_watchpoint (const struct breakpoint
*b
)
10665 return b
->ops
== &masked_watchpoint_breakpoint_ops
;
10668 /* accessflag: hw_write: watch write,
10669 hw_read: watch read,
10670 hw_access: watch access (read or write) */
10672 watch_command_1 (const char *arg
, int accessflag
, int from_tty
,
10673 int just_location
, int internal
)
10675 struct breakpoint
*scope_breakpoint
= NULL
;
10676 const struct block
*exp_valid_block
= NULL
, *cond_exp_valid_block
= NULL
;
10677 struct value
*val
, *mark
, *result
;
10678 int saved_bitpos
= 0, saved_bitsize
= 0;
10679 const char *exp_start
= NULL
;
10680 const char *exp_end
= NULL
;
10681 const char *tok
, *end_tok
;
10683 const char *cond_start
= NULL
;
10684 const char *cond_end
= NULL
;
10685 enum bptype bp_type
;
10688 /* Flag to indicate whether we are going to use masks for
10689 the hardware watchpoint. */
10691 CORE_ADDR mask
= 0;
10693 /* Make sure that we actually have parameters to parse. */
10694 if (arg
!= NULL
&& arg
[0] != '\0')
10696 const char *value_start
;
10698 exp_end
= arg
+ strlen (arg
);
10700 /* Look for "parameter value" pairs at the end
10701 of the arguments string. */
10702 for (tok
= exp_end
- 1; tok
> arg
; tok
--)
10704 /* Skip whitespace at the end of the argument list. */
10705 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
10708 /* Find the beginning of the last token.
10709 This is the value of the parameter. */
10710 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
10712 value_start
= tok
+ 1;
10714 /* Skip whitespace. */
10715 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
10720 /* Find the beginning of the second to last token.
10721 This is the parameter itself. */
10722 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
10725 toklen
= end_tok
- tok
+ 1;
10727 if (toklen
== 6 && startswith (tok
, "thread"))
10729 struct thread_info
*thr
;
10730 /* At this point we've found a "thread" token, which means
10731 the user is trying to set a watchpoint that triggers
10732 only in a specific thread. */
10736 error(_("You can specify only one thread."));
10738 /* Extract the thread ID from the next token. */
10739 thr
= parse_thread_id (value_start
, &endp
);
10741 /* Check if the user provided a valid thread ID. */
10742 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
10743 invalid_thread_id_error (value_start
);
10745 thread
= thr
->global_num
;
10747 else if (toklen
== 4 && startswith (tok
, "mask"))
10749 /* We've found a "mask" token, which means the user wants to
10750 create a hardware watchpoint that is going to have the mask
10752 struct value
*mask_value
, *mark
;
10755 error(_("You can specify only one mask."));
10757 use_mask
= just_location
= 1;
10759 mark
= value_mark ();
10760 mask_value
= parse_to_comma_and_eval (&value_start
);
10761 mask
= value_as_address (mask_value
);
10762 value_free_to_mark (mark
);
10765 /* We didn't recognize what we found. We should stop here. */
10768 /* Truncate the string and get rid of the "parameter value" pair before
10769 the arguments string is parsed by the parse_exp_1 function. */
10776 /* Parse the rest of the arguments. From here on out, everything
10777 is in terms of a newly allocated string instead of the original
10779 innermost_block
= NULL
;
10780 std::string
expression (arg
, exp_end
- arg
);
10781 exp_start
= arg
= expression
.c_str ();
10782 expression_up exp
= parse_exp_1 (&arg
, 0, 0, 0);
10784 /* Remove trailing whitespace from the expression before saving it.
10785 This makes the eventual display of the expression string a bit
10787 while (exp_end
> exp_start
&& (exp_end
[-1] == ' ' || exp_end
[-1] == '\t'))
10790 /* Checking if the expression is not constant. */
10791 if (watchpoint_exp_is_const (exp
.get ()))
10795 len
= exp_end
- exp_start
;
10796 while (len
> 0 && isspace (exp_start
[len
- 1]))
10798 error (_("Cannot watch constant value `%.*s'."), len
, exp_start
);
10801 exp_valid_block
= innermost_block
;
10802 mark
= value_mark ();
10803 fetch_subexp_value (exp
.get (), &pc
, &val
, &result
, NULL
, just_location
);
10805 if (val
!= NULL
&& just_location
)
10807 saved_bitpos
= value_bitpos (val
);
10808 saved_bitsize
= value_bitsize (val
);
10815 exp_valid_block
= NULL
;
10816 val
= value_addr (result
);
10817 release_value (val
);
10818 value_free_to_mark (mark
);
10822 ret
= target_masked_watch_num_registers (value_as_address (val
),
10825 error (_("This target does not support masked watchpoints."));
10826 else if (ret
== -2)
10827 error (_("Invalid mask or memory region."));
10830 else if (val
!= NULL
)
10831 release_value (val
);
10833 tok
= skip_spaces (arg
);
10834 end_tok
= skip_to_space (tok
);
10836 toklen
= end_tok
- tok
;
10837 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
10839 innermost_block
= NULL
;
10840 tok
= cond_start
= end_tok
+ 1;
10841 parse_exp_1 (&tok
, 0, 0, 0);
10843 /* The watchpoint expression may not be local, but the condition
10844 may still be. E.g.: `watch global if local > 0'. */
10845 cond_exp_valid_block
= innermost_block
;
10850 error (_("Junk at end of command."));
10852 frame_info
*wp_frame
= block_innermost_frame (exp_valid_block
);
10854 /* Save this because create_internal_breakpoint below invalidates
10856 frame_id watchpoint_frame
= get_frame_id (wp_frame
);
10858 /* If the expression is "local", then set up a "watchpoint scope"
10859 breakpoint at the point where we've left the scope of the watchpoint
10860 expression. Create the scope breakpoint before the watchpoint, so
10861 that we will encounter it first in bpstat_stop_status. */
10862 if (exp_valid_block
!= NULL
&& wp_frame
!= NULL
)
10864 frame_id caller_frame_id
= frame_unwind_caller_id (wp_frame
);
10866 if (frame_id_p (caller_frame_id
))
10868 gdbarch
*caller_arch
= frame_unwind_caller_arch (wp_frame
);
10869 CORE_ADDR caller_pc
= frame_unwind_caller_pc (wp_frame
);
10872 = create_internal_breakpoint (caller_arch
, caller_pc
,
10873 bp_watchpoint_scope
,
10874 &momentary_breakpoint_ops
);
10876 /* create_internal_breakpoint could invalidate WP_FRAME. */
10879 scope_breakpoint
->enable_state
= bp_enabled
;
10881 /* Automatically delete the breakpoint when it hits. */
10882 scope_breakpoint
->disposition
= disp_del
;
10884 /* Only break in the proper frame (help with recursion). */
10885 scope_breakpoint
->frame_id
= caller_frame_id
;
10887 /* Set the address at which we will stop. */
10888 scope_breakpoint
->loc
->gdbarch
= caller_arch
;
10889 scope_breakpoint
->loc
->requested_address
= caller_pc
;
10890 scope_breakpoint
->loc
->address
10891 = adjust_breakpoint_address (scope_breakpoint
->loc
->gdbarch
,
10892 scope_breakpoint
->loc
->requested_address
,
10893 scope_breakpoint
->type
);
10897 /* Now set up the breakpoint. We create all watchpoints as hardware
10898 watchpoints here even if hardware watchpoints are turned off, a call
10899 to update_watchpoint later in this function will cause the type to
10900 drop back to bp_watchpoint (software watchpoint) if required. */
10902 if (accessflag
== hw_read
)
10903 bp_type
= bp_read_watchpoint
;
10904 else if (accessflag
== hw_access
)
10905 bp_type
= bp_access_watchpoint
;
10907 bp_type
= bp_hardware_watchpoint
;
10909 std::unique_ptr
<watchpoint
> w (new watchpoint ());
10912 init_raw_breakpoint_without_location (w
.get (), NULL
, bp_type
,
10913 &masked_watchpoint_breakpoint_ops
);
10915 init_raw_breakpoint_without_location (w
.get (), NULL
, bp_type
,
10916 &watchpoint_breakpoint_ops
);
10917 w
->thread
= thread
;
10918 w
->disposition
= disp_donttouch
;
10919 w
->pspace
= current_program_space
;
10920 w
->exp
= std::move (exp
);
10921 w
->exp_valid_block
= exp_valid_block
;
10922 w
->cond_exp_valid_block
= cond_exp_valid_block
;
10925 struct type
*t
= value_type (val
);
10926 CORE_ADDR addr
= value_as_address (val
);
10928 w
->exp_string_reparse
10929 = current_language
->la_watch_location_expression (t
, addr
).release ();
10931 w
->exp_string
= xstrprintf ("-location %.*s",
10932 (int) (exp_end
- exp_start
), exp_start
);
10935 w
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
10939 w
->hw_wp_mask
= mask
;
10944 w
->val_bitpos
= saved_bitpos
;
10945 w
->val_bitsize
= saved_bitsize
;
10950 w
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
10952 w
->cond_string
= 0;
10954 if (frame_id_p (watchpoint_frame
))
10956 w
->watchpoint_frame
= watchpoint_frame
;
10957 w
->watchpoint_thread
= inferior_ptid
;
10961 w
->watchpoint_frame
= null_frame_id
;
10962 w
->watchpoint_thread
= null_ptid
;
10965 if (scope_breakpoint
!= NULL
)
10967 /* The scope breakpoint is related to the watchpoint. We will
10968 need to act on them together. */
10969 w
->related_breakpoint
= scope_breakpoint
;
10970 scope_breakpoint
->related_breakpoint
= w
.get ();
10973 if (!just_location
)
10974 value_free_to_mark (mark
);
10976 /* Finally update the new watchpoint. This creates the locations
10977 that should be inserted. */
10978 update_watchpoint (w
.get (), 1);
10980 install_breakpoint (internal
, std::move (w
), 1);
10983 /* Return count of debug registers needed to watch the given expression.
10984 If the watchpoint cannot be handled in hardware return zero. */
10987 can_use_hardware_watchpoint (struct value
*v
)
10989 int found_memory_cnt
= 0;
10990 struct value
*head
= v
;
10992 /* Did the user specifically forbid us to use hardware watchpoints? */
10993 if (!can_use_hw_watchpoints
)
10996 /* Make sure that the value of the expression depends only upon
10997 memory contents, and values computed from them within GDB. If we
10998 find any register references or function calls, we can't use a
10999 hardware watchpoint.
11001 The idea here is that evaluating an expression generates a series
11002 of values, one holding the value of every subexpression. (The
11003 expression a*b+c has five subexpressions: a, b, a*b, c, and
11004 a*b+c.) GDB's values hold almost enough information to establish
11005 the criteria given above --- they identify memory lvalues,
11006 register lvalues, computed values, etcetera. So we can evaluate
11007 the expression, and then scan the chain of values that leaves
11008 behind to decide whether we can detect any possible change to the
11009 expression's final value using only hardware watchpoints.
11011 However, I don't think that the values returned by inferior
11012 function calls are special in any way. So this function may not
11013 notice that an expression involving an inferior function call
11014 can't be watched with hardware watchpoints. FIXME. */
11015 for (; v
; v
= value_next (v
))
11017 if (VALUE_LVAL (v
) == lval_memory
)
11019 if (v
!= head
&& value_lazy (v
))
11020 /* A lazy memory lvalue in the chain is one that GDB never
11021 needed to fetch; we either just used its address (e.g.,
11022 `a' in `a.b') or we never needed it at all (e.g., `a'
11023 in `a,b'). This doesn't apply to HEAD; if that is
11024 lazy then it was not readable, but watch it anyway. */
11028 /* Ahh, memory we actually used! Check if we can cover
11029 it with hardware watchpoints. */
11030 struct type
*vtype
= check_typedef (value_type (v
));
11032 /* We only watch structs and arrays if user asked for it
11033 explicitly, never if they just happen to appear in a
11034 middle of some value chain. */
11036 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
11037 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
11039 CORE_ADDR vaddr
= value_address (v
);
11043 len
= (target_exact_watchpoints
11044 && is_scalar_type_recursive (vtype
))?
11045 1 : TYPE_LENGTH (value_type (v
));
11047 num_regs
= target_region_ok_for_hw_watchpoint (vaddr
, len
);
11051 found_memory_cnt
+= num_regs
;
11055 else if (VALUE_LVAL (v
) != not_lval
11056 && deprecated_value_modifiable (v
) == 0)
11057 return 0; /* These are values from the history (e.g., $1). */
11058 else if (VALUE_LVAL (v
) == lval_register
)
11059 return 0; /* Cannot watch a register with a HW watchpoint. */
11062 /* The expression itself looks suitable for using a hardware
11063 watchpoint, but give the target machine a chance to reject it. */
11064 return found_memory_cnt
;
11068 watch_command_wrapper (const char *arg
, int from_tty
, int internal
)
11070 watch_command_1 (arg
, hw_write
, from_tty
, 0, internal
);
11073 /* A helper function that looks for the "-location" argument and then
11074 calls watch_command_1. */
11077 watch_maybe_just_location (char *arg
, int accessflag
, int from_tty
)
11079 int just_location
= 0;
11082 && (check_for_argument (&arg
, "-location", sizeof ("-location") - 1)
11083 || check_for_argument (&arg
, "-l", sizeof ("-l") - 1)))
11085 arg
= skip_spaces (arg
);
11089 watch_command_1 (arg
, accessflag
, from_tty
, just_location
, 0);
11093 watch_command (char *arg
, int from_tty
)
11095 watch_maybe_just_location (arg
, hw_write
, from_tty
);
11099 rwatch_command_wrapper (const char *arg
, int from_tty
, int internal
)
11101 watch_command_1 (arg
, hw_read
, from_tty
, 0, internal
);
11105 rwatch_command (char *arg
, int from_tty
)
11107 watch_maybe_just_location (arg
, hw_read
, from_tty
);
11111 awatch_command_wrapper (const char *arg
, int from_tty
, int internal
)
11113 watch_command_1 (arg
, hw_access
, from_tty
, 0, internal
);
11117 awatch_command (char *arg
, int from_tty
)
11119 watch_maybe_just_location (arg
, hw_access
, from_tty
);
11123 /* Data for the FSM that manages the until(location)/advance commands
11124 in infcmd.c. Here because it uses the mechanisms of
11127 struct until_break_fsm
11129 /* The base class. */
11130 struct thread_fsm thread_fsm
;
11132 /* The thread that as current when the command was executed. */
11135 /* The breakpoint set at the destination location. */
11136 struct breakpoint
*location_breakpoint
;
11138 /* Breakpoint set at the return address in the caller frame. May be
11140 struct breakpoint
*caller_breakpoint
;
11143 static void until_break_fsm_clean_up (struct thread_fsm
*self
,
11144 struct thread_info
*thread
);
11145 static int until_break_fsm_should_stop (struct thread_fsm
*self
,
11146 struct thread_info
*thread
);
11147 static enum async_reply_reason
11148 until_break_fsm_async_reply_reason (struct thread_fsm
*self
);
11150 /* until_break_fsm's vtable. */
11152 static struct thread_fsm_ops until_break_fsm_ops
=
11155 until_break_fsm_clean_up
,
11156 until_break_fsm_should_stop
,
11157 NULL
, /* return_value */
11158 until_break_fsm_async_reply_reason
,
11161 /* Allocate a new until_break_command_fsm. */
11163 static struct until_break_fsm
*
11164 new_until_break_fsm (struct interp
*cmd_interp
, int thread
,
11165 struct breakpoint
*location_breakpoint
,
11166 struct breakpoint
*caller_breakpoint
)
11168 struct until_break_fsm
*sm
;
11170 sm
= XCNEW (struct until_break_fsm
);
11171 thread_fsm_ctor (&sm
->thread_fsm
, &until_break_fsm_ops
, cmd_interp
);
11173 sm
->thread
= thread
;
11174 sm
->location_breakpoint
= location_breakpoint
;
11175 sm
->caller_breakpoint
= caller_breakpoint
;
11180 /* Implementation of the 'should_stop' FSM method for the
11181 until(location)/advance commands. */
11184 until_break_fsm_should_stop (struct thread_fsm
*self
,
11185 struct thread_info
*tp
)
11187 struct until_break_fsm
*sm
= (struct until_break_fsm
*) self
;
11189 if (bpstat_find_breakpoint (tp
->control
.stop_bpstat
,
11190 sm
->location_breakpoint
) != NULL
11191 || (sm
->caller_breakpoint
!= NULL
11192 && bpstat_find_breakpoint (tp
->control
.stop_bpstat
,
11193 sm
->caller_breakpoint
) != NULL
))
11194 thread_fsm_set_finished (self
);
11199 /* Implementation of the 'clean_up' FSM method for the
11200 until(location)/advance commands. */
11203 until_break_fsm_clean_up (struct thread_fsm
*self
,
11204 struct thread_info
*thread
)
11206 struct until_break_fsm
*sm
= (struct until_break_fsm
*) self
;
11208 /* Clean up our temporary breakpoints. */
11209 if (sm
->location_breakpoint
!= NULL
)
11211 delete_breakpoint (sm
->location_breakpoint
);
11212 sm
->location_breakpoint
= NULL
;
11214 if (sm
->caller_breakpoint
!= NULL
)
11216 delete_breakpoint (sm
->caller_breakpoint
);
11217 sm
->caller_breakpoint
= NULL
;
11219 delete_longjmp_breakpoint (sm
->thread
);
11222 /* Implementation of the 'async_reply_reason' FSM method for the
11223 until(location)/advance commands. */
11225 static enum async_reply_reason
11226 until_break_fsm_async_reply_reason (struct thread_fsm
*self
)
11228 return EXEC_ASYNC_LOCATION_REACHED
;
11232 until_break_command (const char *arg
, int from_tty
, int anywhere
)
11234 struct frame_info
*frame
;
11235 struct gdbarch
*frame_gdbarch
;
11236 struct frame_id stack_frame_id
;
11237 struct frame_id caller_frame_id
;
11238 struct breakpoint
*location_breakpoint
;
11239 struct breakpoint
*caller_breakpoint
= NULL
;
11240 struct cleanup
*old_chain
;
11242 struct thread_info
*tp
;
11243 struct until_break_fsm
*sm
;
11245 clear_proceed_status (0);
11247 /* Set a breakpoint where the user wants it and at return from
11250 event_location_up location
= string_to_event_location (&arg
, current_language
);
11252 std::vector
<symtab_and_line
> sals
11253 = (last_displayed_sal_is_valid ()
11254 ? decode_line_1 (location
.get (), DECODE_LINE_FUNFIRSTLINE
, NULL
,
11255 get_last_displayed_symtab (),
11256 get_last_displayed_line ())
11257 : decode_line_1 (location
.get (), DECODE_LINE_FUNFIRSTLINE
,
11258 NULL
, (struct symtab
*) NULL
, 0));
11260 if (sals
.size () != 1)
11261 error (_("Couldn't get information on specified line."));
11263 symtab_and_line
&sal
= sals
[0];
11266 error (_("Junk at end of arguments."));
11268 resolve_sal_pc (&sal
);
11270 tp
= inferior_thread ();
11271 thread
= tp
->global_num
;
11273 old_chain
= make_cleanup (null_cleanup
, NULL
);
11275 /* Note linespec handling above invalidates the frame chain.
11276 Installing a breakpoint also invalidates the frame chain (as it
11277 may need to switch threads), so do any frame handling before
11280 frame
= get_selected_frame (NULL
);
11281 frame_gdbarch
= get_frame_arch (frame
);
11282 stack_frame_id
= get_stack_frame_id (frame
);
11283 caller_frame_id
= frame_unwind_caller_id (frame
);
11285 /* Keep within the current frame, or in frames called by the current
11288 if (frame_id_p (caller_frame_id
))
11290 struct symtab_and_line sal2
;
11291 struct gdbarch
*caller_gdbarch
;
11293 sal2
= find_pc_line (frame_unwind_caller_pc (frame
), 0);
11294 sal2
.pc
= frame_unwind_caller_pc (frame
);
11295 caller_gdbarch
= frame_unwind_caller_arch (frame
);
11296 caller_breakpoint
= set_momentary_breakpoint (caller_gdbarch
,
11300 make_cleanup_delete_breakpoint (caller_breakpoint
);
11302 set_longjmp_breakpoint (tp
, caller_frame_id
);
11303 make_cleanup (delete_longjmp_breakpoint_cleanup
, &thread
);
11306 /* set_momentary_breakpoint could invalidate FRAME. */
11310 /* If the user told us to continue until a specified location,
11311 we don't specify a frame at which we need to stop. */
11312 location_breakpoint
= set_momentary_breakpoint (frame_gdbarch
, sal
,
11313 null_frame_id
, bp_until
);
11315 /* Otherwise, specify the selected frame, because we want to stop
11316 only at the very same frame. */
11317 location_breakpoint
= set_momentary_breakpoint (frame_gdbarch
, sal
,
11318 stack_frame_id
, bp_until
);
11319 make_cleanup_delete_breakpoint (location_breakpoint
);
11321 sm
= new_until_break_fsm (command_interp (), tp
->global_num
,
11322 location_breakpoint
, caller_breakpoint
);
11323 tp
->thread_fsm
= &sm
->thread_fsm
;
11325 discard_cleanups (old_chain
);
11327 proceed (-1, GDB_SIGNAL_DEFAULT
);
11330 /* This function attempts to parse an optional "if <cond>" clause
11331 from the arg string. If one is not found, it returns NULL.
11333 Else, it returns a pointer to the condition string. (It does not
11334 attempt to evaluate the string against a particular block.) And,
11335 it updates arg to point to the first character following the parsed
11336 if clause in the arg string. */
11339 ep_parse_optional_if_clause (const char **arg
)
11341 const char *cond_string
;
11343 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
11346 /* Skip the "if" keyword. */
11349 /* Skip any extra leading whitespace, and record the start of the
11350 condition string. */
11351 *arg
= skip_spaces (*arg
);
11352 cond_string
= *arg
;
11354 /* Assume that the condition occupies the remainder of the arg
11356 (*arg
) += strlen (cond_string
);
11358 return cond_string
;
11361 /* Commands to deal with catching events, such as signals, exceptions,
11362 process start/exit, etc. */
11366 catch_fork_temporary
, catch_vfork_temporary
,
11367 catch_fork_permanent
, catch_vfork_permanent
11372 catch_fork_command_1 (char *arg_entry
, int from_tty
,
11373 struct cmd_list_element
*command
)
11375 const char *arg
= arg_entry
;
11376 struct gdbarch
*gdbarch
= get_current_arch ();
11377 const char *cond_string
= NULL
;
11378 catch_fork_kind fork_kind
;
11381 fork_kind
= (catch_fork_kind
) (uintptr_t) get_cmd_context (command
);
11382 tempflag
= (fork_kind
== catch_fork_temporary
11383 || fork_kind
== catch_vfork_temporary
);
11387 arg
= skip_spaces (arg
);
11389 /* The allowed syntax is:
11391 catch [v]fork if <cond>
11393 First, check if there's an if clause. */
11394 cond_string
= ep_parse_optional_if_clause (&arg
);
11396 if ((*arg
!= '\0') && !isspace (*arg
))
11397 error (_("Junk at end of arguments."));
11399 /* If this target supports it, create a fork or vfork catchpoint
11400 and enable reporting of such events. */
11403 case catch_fork_temporary
:
11404 case catch_fork_permanent
:
11405 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
11406 &catch_fork_breakpoint_ops
);
11408 case catch_vfork_temporary
:
11409 case catch_vfork_permanent
:
11410 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
11411 &catch_vfork_breakpoint_ops
);
11414 error (_("unsupported or unknown fork kind; cannot catch it"));
11420 catch_exec_command_1 (char *arg_entry
, int from_tty
,
11421 struct cmd_list_element
*command
)
11423 const char *arg
= arg_entry
;
11424 struct gdbarch
*gdbarch
= get_current_arch ();
11426 const char *cond_string
= NULL
;
11428 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
11432 arg
= skip_spaces (arg
);
11434 /* The allowed syntax is:
11436 catch exec if <cond>
11438 First, check if there's an if clause. */
11439 cond_string
= ep_parse_optional_if_clause (&arg
);
11441 if ((*arg
!= '\0') && !isspace (*arg
))
11442 error (_("Junk at end of arguments."));
11444 std::unique_ptr
<exec_catchpoint
> c (new exec_catchpoint ());
11445 init_catchpoint (c
.get (), gdbarch
, tempflag
, cond_string
,
11446 &catch_exec_breakpoint_ops
);
11447 c
->exec_pathname
= NULL
;
11449 install_breakpoint (0, std::move (c
), 1);
11453 init_ada_exception_breakpoint (struct breakpoint
*b
,
11454 struct gdbarch
*gdbarch
,
11455 struct symtab_and_line sal
,
11456 const char *addr_string
,
11457 const struct breakpoint_ops
*ops
,
11464 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
11466 loc_gdbarch
= gdbarch
;
11468 describe_other_breakpoints (loc_gdbarch
,
11469 sal
.pspace
, sal
.pc
, sal
.section
, -1);
11470 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
11471 version for exception catchpoints, because two catchpoints
11472 used for different exception names will use the same address.
11473 In this case, a "breakpoint ... also set at..." warning is
11474 unproductive. Besides, the warning phrasing is also a bit
11475 inappropriate, we should use the word catchpoint, and tell
11476 the user what type of catchpoint it is. The above is good
11477 enough for now, though. */
11480 init_raw_breakpoint (b
, gdbarch
, sal
, bp_breakpoint
, ops
);
11482 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
11483 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
11484 b
->location
= string_to_event_location (&addr_string
,
11485 language_def (language_ada
));
11486 b
->language
= language_ada
;
11490 catch_command (const char *arg
, int from_tty
)
11492 error (_("Catch requires an event name."));
11497 tcatch_command (const char *arg
, int from_tty
)
11499 error (_("Catch requires an event name."));
11502 /* Compare two breakpoints and return a strcmp-like result. */
11505 compare_breakpoints (const breakpoint
*a
, const breakpoint
*b
)
11507 uintptr_t ua
= (uintptr_t) a
;
11508 uintptr_t ub
= (uintptr_t) b
;
11510 if (a
->number
< b
->number
)
11512 else if (a
->number
> b
->number
)
11515 /* Now sort by address, in case we see, e..g, two breakpoints with
11519 return ua
> ub
? 1 : 0;
11522 /* Delete breakpoints by address or line. */
11525 clear_command (char *arg
, int from_tty
)
11527 struct breakpoint
*b
;
11531 std::vector
<symtab_and_line
> decoded_sals
;
11532 symtab_and_line last_sal
;
11533 gdb::array_view
<symtab_and_line
> sals
;
11537 = decode_line_with_current_source (arg
,
11538 (DECODE_LINE_FUNFIRSTLINE
11539 | DECODE_LINE_LIST_MODE
));
11541 sals
= decoded_sals
;
11545 /* Set sal's line, symtab, pc, and pspace to the values
11546 corresponding to the last call to print_frame_info. If the
11547 codepoint is not valid, this will set all the fields to 0. */
11548 last_sal
= get_last_displayed_sal ();
11549 if (last_sal
.symtab
== 0)
11550 error (_("No source file specified."));
11556 /* We don't call resolve_sal_pc here. That's not as bad as it
11557 seems, because all existing breakpoints typically have both
11558 file/line and pc set. So, if clear is given file/line, we can
11559 match this to existing breakpoint without obtaining pc at all.
11561 We only support clearing given the address explicitly
11562 present in breakpoint table. Say, we've set breakpoint
11563 at file:line. There were several PC values for that file:line,
11564 due to optimization, all in one block.
11566 We've picked one PC value. If "clear" is issued with another
11567 PC corresponding to the same file:line, the breakpoint won't
11568 be cleared. We probably can still clear the breakpoint, but
11569 since the other PC value is never presented to user, user
11570 can only find it by guessing, and it does not seem important
11571 to support that. */
11573 /* For each line spec given, delete bps which correspond to it. Do
11574 it in two passes, solely to preserve the current behavior that
11575 from_tty is forced true if we delete more than one
11578 std::vector
<struct breakpoint
*> found
;
11579 for (const auto &sal
: sals
)
11581 const char *sal_fullname
;
11583 /* If exact pc given, clear bpts at that pc.
11584 If line given (pc == 0), clear all bpts on specified line.
11585 If defaulting, clear all bpts on default line
11588 defaulting sal.pc != 0 tests to do
11593 1 0 <can't happen> */
11595 sal_fullname
= (sal
.symtab
== NULL
11596 ? NULL
: symtab_to_fullname (sal
.symtab
));
11598 /* Find all matching breakpoints and add them to 'found'. */
11599 ALL_BREAKPOINTS (b
)
11602 /* Are we going to delete b? */
11603 if (b
->type
!= bp_none
&& !is_watchpoint (b
))
11605 struct bp_location
*loc
= b
->loc
;
11606 for (; loc
; loc
= loc
->next
)
11608 /* If the user specified file:line, don't allow a PC
11609 match. This matches historical gdb behavior. */
11610 int pc_match
= (!sal
.explicit_line
11612 && (loc
->pspace
== sal
.pspace
)
11613 && (loc
->address
== sal
.pc
)
11614 && (!section_is_overlay (loc
->section
)
11615 || loc
->section
== sal
.section
));
11616 int line_match
= 0;
11618 if ((default_match
|| sal
.explicit_line
)
11619 && loc
->symtab
!= NULL
11620 && sal_fullname
!= NULL
11621 && sal
.pspace
== loc
->pspace
11622 && loc
->line_number
== sal
.line
11623 && filename_cmp (symtab_to_fullname (loc
->symtab
),
11624 sal_fullname
) == 0)
11627 if (pc_match
|| line_match
)
11636 found
.push_back (b
);
11640 /* Now go thru the 'found' chain and delete them. */
11641 if (found
.empty ())
11644 error (_("No breakpoint at %s."), arg
);
11646 error (_("No breakpoint at this line."));
11649 /* Remove duplicates from the vec. */
11650 std::sort (found
.begin (), found
.end (),
11651 [] (const breakpoint
*a
, const breakpoint
*b
)
11653 return compare_breakpoints (a
, b
) < 0;
11655 found
.erase (std::unique (found
.begin (), found
.end (),
11656 [] (const breakpoint
*a
, const breakpoint
*b
)
11658 return compare_breakpoints (a
, b
) == 0;
11662 if (found
.size () > 1)
11663 from_tty
= 1; /* Always report if deleted more than one. */
11666 if (found
.size () == 1)
11667 printf_unfiltered (_("Deleted breakpoint "));
11669 printf_unfiltered (_("Deleted breakpoints "));
11672 for (breakpoint
*iter
: found
)
11675 printf_unfiltered ("%d ", iter
->number
);
11676 delete_breakpoint (iter
);
11679 putchar_unfiltered ('\n');
11682 /* Delete breakpoint in BS if they are `delete' breakpoints and
11683 all breakpoints that are marked for deletion, whether hit or not.
11684 This is called after any breakpoint is hit, or after errors. */
11687 breakpoint_auto_delete (bpstat bs
)
11689 struct breakpoint
*b
, *b_tmp
;
11691 for (; bs
; bs
= bs
->next
)
11692 if (bs
->breakpoint_at
11693 && bs
->breakpoint_at
->disposition
== disp_del
11695 delete_breakpoint (bs
->breakpoint_at
);
11697 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
11699 if (b
->disposition
== disp_del_at_next_stop
)
11700 delete_breakpoint (b
);
11704 /* A comparison function for bp_location AP and BP being interfaced to
11705 qsort. Sort elements primarily by their ADDRESS (no matter what
11706 does breakpoint_address_is_meaningful say for its OWNER),
11707 secondarily by ordering first permanent elements and
11708 terciarily just ensuring the array is sorted stable way despite
11709 qsort being an unstable algorithm. */
11712 bp_locations_compare (const void *ap
, const void *bp
)
11714 const struct bp_location
*a
= *(const struct bp_location
**) ap
;
11715 const struct bp_location
*b
= *(const struct bp_location
**) bp
;
11717 if (a
->address
!= b
->address
)
11718 return (a
->address
> b
->address
) - (a
->address
< b
->address
);
11720 /* Sort locations at the same address by their pspace number, keeping
11721 locations of the same inferior (in a multi-inferior environment)
11724 if (a
->pspace
->num
!= b
->pspace
->num
)
11725 return ((a
->pspace
->num
> b
->pspace
->num
)
11726 - (a
->pspace
->num
< b
->pspace
->num
));
11728 /* Sort permanent breakpoints first. */
11729 if (a
->permanent
!= b
->permanent
)
11730 return (a
->permanent
< b
->permanent
) - (a
->permanent
> b
->permanent
);
11732 /* Make the internal GDB representation stable across GDB runs
11733 where A and B memory inside GDB can differ. Breakpoint locations of
11734 the same type at the same address can be sorted in arbitrary order. */
11736 if (a
->owner
->number
!= b
->owner
->number
)
11737 return ((a
->owner
->number
> b
->owner
->number
)
11738 - (a
->owner
->number
< b
->owner
->number
));
11740 return (a
> b
) - (a
< b
);
11743 /* Set bp_locations_placed_address_before_address_max and
11744 bp_locations_shadow_len_after_address_max according to the current
11745 content of the bp_locations array. */
11748 bp_locations_target_extensions_update (void)
11750 struct bp_location
*bl
, **blp_tmp
;
11752 bp_locations_placed_address_before_address_max
= 0;
11753 bp_locations_shadow_len_after_address_max
= 0;
11755 ALL_BP_LOCATIONS (bl
, blp_tmp
)
11757 CORE_ADDR start
, end
, addr
;
11759 if (!bp_location_has_shadow (bl
))
11762 start
= bl
->target_info
.placed_address
;
11763 end
= start
+ bl
->target_info
.shadow_len
;
11765 gdb_assert (bl
->address
>= start
);
11766 addr
= bl
->address
- start
;
11767 if (addr
> bp_locations_placed_address_before_address_max
)
11768 bp_locations_placed_address_before_address_max
= addr
;
11770 /* Zero SHADOW_LEN would not pass bp_location_has_shadow. */
11772 gdb_assert (bl
->address
< end
);
11773 addr
= end
- bl
->address
;
11774 if (addr
> bp_locations_shadow_len_after_address_max
)
11775 bp_locations_shadow_len_after_address_max
= addr
;
11779 /* Download tracepoint locations if they haven't been. */
11782 download_tracepoint_locations (void)
11784 struct breakpoint
*b
;
11785 enum tribool can_download_tracepoint
= TRIBOOL_UNKNOWN
;
11787 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
11789 ALL_TRACEPOINTS (b
)
11791 struct bp_location
*bl
;
11792 struct tracepoint
*t
;
11793 int bp_location_downloaded
= 0;
11795 if ((b
->type
== bp_fast_tracepoint
11796 ? !may_insert_fast_tracepoints
11797 : !may_insert_tracepoints
))
11800 if (can_download_tracepoint
== TRIBOOL_UNKNOWN
)
11802 if (target_can_download_tracepoint ())
11803 can_download_tracepoint
= TRIBOOL_TRUE
;
11805 can_download_tracepoint
= TRIBOOL_FALSE
;
11808 if (can_download_tracepoint
== TRIBOOL_FALSE
)
11811 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
11813 /* In tracepoint, locations are _never_ duplicated, so
11814 should_be_inserted is equivalent to
11815 unduplicated_should_be_inserted. */
11816 if (!should_be_inserted (bl
) || bl
->inserted
)
11819 switch_to_program_space_and_thread (bl
->pspace
);
11821 target_download_tracepoint (bl
);
11824 bp_location_downloaded
= 1;
11826 t
= (struct tracepoint
*) b
;
11827 t
->number_on_target
= b
->number
;
11828 if (bp_location_downloaded
)
11829 observer_notify_breakpoint_modified (b
);
11833 /* Swap the insertion/duplication state between two locations. */
11836 swap_insertion (struct bp_location
*left
, struct bp_location
*right
)
11838 const int left_inserted
= left
->inserted
;
11839 const int left_duplicate
= left
->duplicate
;
11840 const int left_needs_update
= left
->needs_update
;
11841 const struct bp_target_info left_target_info
= left
->target_info
;
11843 /* Locations of tracepoints can never be duplicated. */
11844 if (is_tracepoint (left
->owner
))
11845 gdb_assert (!left
->duplicate
);
11846 if (is_tracepoint (right
->owner
))
11847 gdb_assert (!right
->duplicate
);
11849 left
->inserted
= right
->inserted
;
11850 left
->duplicate
= right
->duplicate
;
11851 left
->needs_update
= right
->needs_update
;
11852 left
->target_info
= right
->target_info
;
11853 right
->inserted
= left_inserted
;
11854 right
->duplicate
= left_duplicate
;
11855 right
->needs_update
= left_needs_update
;
11856 right
->target_info
= left_target_info
;
11859 /* Force the re-insertion of the locations at ADDRESS. This is called
11860 once a new/deleted/modified duplicate location is found and we are evaluating
11861 conditions on the target's side. Such conditions need to be updated on
11865 force_breakpoint_reinsertion (struct bp_location
*bl
)
11867 struct bp_location
**locp
= NULL
, **loc2p
;
11868 struct bp_location
*loc
;
11869 CORE_ADDR address
= 0;
11872 address
= bl
->address
;
11873 pspace_num
= bl
->pspace
->num
;
11875 /* This is only meaningful if the target is
11876 evaluating conditions and if the user has
11877 opted for condition evaluation on the target's
11879 if (gdb_evaluates_breakpoint_condition_p ()
11880 || !target_supports_evaluation_of_breakpoint_conditions ())
11883 /* Flag all breakpoint locations with this address and
11884 the same program space as the location
11885 as "its condition has changed". We need to
11886 update the conditions on the target's side. */
11887 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, address
)
11891 if (!is_breakpoint (loc
->owner
)
11892 || pspace_num
!= loc
->pspace
->num
)
11895 /* Flag the location appropriately. We use a different state to
11896 let everyone know that we already updated the set of locations
11897 with addr bl->address and program space bl->pspace. This is so
11898 we don't have to keep calling these functions just to mark locations
11899 that have already been marked. */
11900 loc
->condition_changed
= condition_updated
;
11902 /* Free the agent expression bytecode as well. We will compute
11904 loc
->cond_bytecode
.reset ();
11907 /* Called whether new breakpoints are created, or existing breakpoints
11908 deleted, to update the global location list and recompute which
11909 locations are duplicate of which.
11911 The INSERT_MODE flag determines whether locations may not, may, or
11912 shall be inserted now. See 'enum ugll_insert_mode' for more
11916 update_global_location_list (enum ugll_insert_mode insert_mode
)
11918 struct breakpoint
*b
;
11919 struct bp_location
**locp
, *loc
;
11920 /* Last breakpoint location address that was marked for update. */
11921 CORE_ADDR last_addr
= 0;
11922 /* Last breakpoint location program space that was marked for update. */
11923 int last_pspace_num
= -1;
11925 /* Used in the duplicates detection below. When iterating over all
11926 bp_locations, points to the first bp_location of a given address.
11927 Breakpoints and watchpoints of different types are never
11928 duplicates of each other. Keep one pointer for each type of
11929 breakpoint/watchpoint, so we only need to loop over all locations
11931 struct bp_location
*bp_loc_first
; /* breakpoint */
11932 struct bp_location
*wp_loc_first
; /* hardware watchpoint */
11933 struct bp_location
*awp_loc_first
; /* access watchpoint */
11934 struct bp_location
*rwp_loc_first
; /* read watchpoint */
11936 /* Saved former bp_locations array which we compare against the newly
11937 built bp_locations from the current state of ALL_BREAKPOINTS. */
11938 struct bp_location
**old_locp
;
11939 unsigned old_locations_count
;
11940 gdb::unique_xmalloc_ptr
<struct bp_location
*> old_locations (bp_locations
);
11942 old_locations_count
= bp_locations_count
;
11943 bp_locations
= NULL
;
11944 bp_locations_count
= 0;
11946 ALL_BREAKPOINTS (b
)
11947 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
11948 bp_locations_count
++;
11950 bp_locations
= XNEWVEC (struct bp_location
*, bp_locations_count
);
11951 locp
= bp_locations
;
11952 ALL_BREAKPOINTS (b
)
11953 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
11955 qsort (bp_locations
, bp_locations_count
, sizeof (*bp_locations
),
11956 bp_locations_compare
);
11958 bp_locations_target_extensions_update ();
11960 /* Identify bp_location instances that are no longer present in the
11961 new list, and therefore should be freed. Note that it's not
11962 necessary that those locations should be removed from inferior --
11963 if there's another location at the same address (previously
11964 marked as duplicate), we don't need to remove/insert the
11967 LOCP is kept in sync with OLD_LOCP, each pointing to the current
11968 and former bp_location array state respectively. */
11970 locp
= bp_locations
;
11971 for (old_locp
= old_locations
.get ();
11972 old_locp
< old_locations
.get () + old_locations_count
;
11975 struct bp_location
*old_loc
= *old_locp
;
11976 struct bp_location
**loc2p
;
11978 /* Tells if 'old_loc' is found among the new locations. If
11979 not, we have to free it. */
11980 int found_object
= 0;
11981 /* Tells if the location should remain inserted in the target. */
11982 int keep_in_target
= 0;
11985 /* Skip LOCP entries which will definitely never be needed.
11986 Stop either at or being the one matching OLD_LOC. */
11987 while (locp
< bp_locations
+ bp_locations_count
11988 && (*locp
)->address
< old_loc
->address
)
11992 (loc2p
< bp_locations
+ bp_locations_count
11993 && (*loc2p
)->address
== old_loc
->address
);
11996 /* Check if this is a new/duplicated location or a duplicated
11997 location that had its condition modified. If so, we want to send
11998 its condition to the target if evaluation of conditions is taking
12000 if ((*loc2p
)->condition_changed
== condition_modified
12001 && (last_addr
!= old_loc
->address
12002 || last_pspace_num
!= old_loc
->pspace
->num
))
12004 force_breakpoint_reinsertion (*loc2p
);
12005 last_pspace_num
= old_loc
->pspace
->num
;
12008 if (*loc2p
== old_loc
)
12012 /* We have already handled this address, update it so that we don't
12013 have to go through updates again. */
12014 last_addr
= old_loc
->address
;
12016 /* Target-side condition evaluation: Handle deleted locations. */
12018 force_breakpoint_reinsertion (old_loc
);
12020 /* If this location is no longer present, and inserted, look if
12021 there's maybe a new location at the same address. If so,
12022 mark that one inserted, and don't remove this one. This is
12023 needed so that we don't have a time window where a breakpoint
12024 at certain location is not inserted. */
12026 if (old_loc
->inserted
)
12028 /* If the location is inserted now, we might have to remove
12031 if (found_object
&& should_be_inserted (old_loc
))
12033 /* The location is still present in the location list,
12034 and still should be inserted. Don't do anything. */
12035 keep_in_target
= 1;
12039 /* This location still exists, but it won't be kept in the
12040 target since it may have been disabled. We proceed to
12041 remove its target-side condition. */
12043 /* The location is either no longer present, or got
12044 disabled. See if there's another location at the
12045 same address, in which case we don't need to remove
12046 this one from the target. */
12048 /* OLD_LOC comes from existing struct breakpoint. */
12049 if (breakpoint_address_is_meaningful (old_loc
->owner
))
12052 (loc2p
< bp_locations
+ bp_locations_count
12053 && (*loc2p
)->address
== old_loc
->address
);
12056 struct bp_location
*loc2
= *loc2p
;
12058 if (breakpoint_locations_match (loc2
, old_loc
))
12060 /* Read watchpoint locations are switched to
12061 access watchpoints, if the former are not
12062 supported, but the latter are. */
12063 if (is_hardware_watchpoint (old_loc
->owner
))
12065 gdb_assert (is_hardware_watchpoint (loc2
->owner
));
12066 loc2
->watchpoint_type
= old_loc
->watchpoint_type
;
12069 /* loc2 is a duplicated location. We need to check
12070 if it should be inserted in case it will be
12072 if (loc2
!= old_loc
12073 && unduplicated_should_be_inserted (loc2
))
12075 swap_insertion (old_loc
, loc2
);
12076 keep_in_target
= 1;
12084 if (!keep_in_target
)
12086 if (remove_breakpoint (old_loc
))
12088 /* This is just about all we can do. We could keep
12089 this location on the global list, and try to
12090 remove it next time, but there's no particular
12091 reason why we will succeed next time.
12093 Note that at this point, old_loc->owner is still
12094 valid, as delete_breakpoint frees the breakpoint
12095 only after calling us. */
12096 printf_filtered (_("warning: Error removing "
12097 "breakpoint %d\n"),
12098 old_loc
->owner
->number
);
12106 if (removed
&& target_is_non_stop_p ()
12107 && need_moribund_for_location_type (old_loc
))
12109 /* This location was removed from the target. In
12110 non-stop mode, a race condition is possible where
12111 we've removed a breakpoint, but stop events for that
12112 breakpoint are already queued and will arrive later.
12113 We apply an heuristic to be able to distinguish such
12114 SIGTRAPs from other random SIGTRAPs: we keep this
12115 breakpoint location for a bit, and will retire it
12116 after we see some number of events. The theory here
12117 is that reporting of events should, "on the average",
12118 be fair, so after a while we'll see events from all
12119 threads that have anything of interest, and no longer
12120 need to keep this breakpoint location around. We
12121 don't hold locations forever so to reduce chances of
12122 mistaking a non-breakpoint SIGTRAP for a breakpoint
12125 The heuristic failing can be disastrous on
12126 decr_pc_after_break targets.
12128 On decr_pc_after_break targets, like e.g., x86-linux,
12129 if we fail to recognize a late breakpoint SIGTRAP,
12130 because events_till_retirement has reached 0 too
12131 soon, we'll fail to do the PC adjustment, and report
12132 a random SIGTRAP to the user. When the user resumes
12133 the inferior, it will most likely immediately crash
12134 with SIGILL/SIGBUS/SIGSEGV, or worse, get silently
12135 corrupted, because of being resumed e.g., in the
12136 middle of a multi-byte instruction, or skipped a
12137 one-byte instruction. This was actually seen happen
12138 on native x86-linux, and should be less rare on
12139 targets that do not support new thread events, like
12140 remote, due to the heuristic depending on
12143 Mistaking a random SIGTRAP for a breakpoint trap
12144 causes similar symptoms (PC adjustment applied when
12145 it shouldn't), but then again, playing with SIGTRAPs
12146 behind the debugger's back is asking for trouble.
12148 Since hardware watchpoint traps are always
12149 distinguishable from other traps, so we don't need to
12150 apply keep hardware watchpoint moribund locations
12151 around. We simply always ignore hardware watchpoint
12152 traps we can no longer explain. */
12154 old_loc
->events_till_retirement
= 3 * (thread_count () + 1);
12155 old_loc
->owner
= NULL
;
12157 VEC_safe_push (bp_location_p
, moribund_locations
, old_loc
);
12161 old_loc
->owner
= NULL
;
12162 decref_bp_location (&old_loc
);
12167 /* Rescan breakpoints at the same address and section, marking the
12168 first one as "first" and any others as "duplicates". This is so
12169 that the bpt instruction is only inserted once. If we have a
12170 permanent breakpoint at the same place as BPT, make that one the
12171 official one, and the rest as duplicates. Permanent breakpoints
12172 are sorted first for the same address.
12174 Do the same for hardware watchpoints, but also considering the
12175 watchpoint's type (regular/access/read) and length. */
12177 bp_loc_first
= NULL
;
12178 wp_loc_first
= NULL
;
12179 awp_loc_first
= NULL
;
12180 rwp_loc_first
= NULL
;
12181 ALL_BP_LOCATIONS (loc
, locp
)
12183 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always
12185 struct bp_location
**loc_first_p
;
12188 if (!unduplicated_should_be_inserted (loc
)
12189 || !breakpoint_address_is_meaningful (b
)
12190 /* Don't detect duplicate for tracepoint locations because they are
12191 never duplicated. See the comments in field `duplicate' of
12192 `struct bp_location'. */
12193 || is_tracepoint (b
))
12195 /* Clear the condition modification flag. */
12196 loc
->condition_changed
= condition_unchanged
;
12200 if (b
->type
== bp_hardware_watchpoint
)
12201 loc_first_p
= &wp_loc_first
;
12202 else if (b
->type
== bp_read_watchpoint
)
12203 loc_first_p
= &rwp_loc_first
;
12204 else if (b
->type
== bp_access_watchpoint
)
12205 loc_first_p
= &awp_loc_first
;
12207 loc_first_p
= &bp_loc_first
;
12209 if (*loc_first_p
== NULL
12210 || (overlay_debugging
&& loc
->section
!= (*loc_first_p
)->section
)
12211 || !breakpoint_locations_match (loc
, *loc_first_p
))
12213 *loc_first_p
= loc
;
12214 loc
->duplicate
= 0;
12216 if (is_breakpoint (loc
->owner
) && loc
->condition_changed
)
12218 loc
->needs_update
= 1;
12219 /* Clear the condition modification flag. */
12220 loc
->condition_changed
= condition_unchanged
;
12226 /* This and the above ensure the invariant that the first location
12227 is not duplicated, and is the inserted one.
12228 All following are marked as duplicated, and are not inserted. */
12230 swap_insertion (loc
, *loc_first_p
);
12231 loc
->duplicate
= 1;
12233 /* Clear the condition modification flag. */
12234 loc
->condition_changed
= condition_unchanged
;
12237 if (insert_mode
== UGLL_INSERT
|| breakpoints_should_be_inserted_now ())
12239 if (insert_mode
!= UGLL_DONT_INSERT
)
12240 insert_breakpoint_locations ();
12243 /* Even though the caller told us to not insert new
12244 locations, we may still need to update conditions on the
12245 target's side of breakpoints that were already inserted
12246 if the target is evaluating breakpoint conditions. We
12247 only update conditions for locations that are marked
12249 update_inserted_breakpoint_locations ();
12253 if (insert_mode
!= UGLL_DONT_INSERT
)
12254 download_tracepoint_locations ();
12258 breakpoint_retire_moribund (void)
12260 struct bp_location
*loc
;
12263 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
12264 if (--(loc
->events_till_retirement
) == 0)
12266 decref_bp_location (&loc
);
12267 VEC_unordered_remove (bp_location_p
, moribund_locations
, ix
);
12273 update_global_location_list_nothrow (enum ugll_insert_mode insert_mode
)
12278 update_global_location_list (insert_mode
);
12280 CATCH (e
, RETURN_MASK_ERROR
)
12286 /* Clear BKP from a BPS. */
12289 bpstat_remove_bp_location (bpstat bps
, struct breakpoint
*bpt
)
12293 for (bs
= bps
; bs
; bs
= bs
->next
)
12294 if (bs
->breakpoint_at
== bpt
)
12296 bs
->breakpoint_at
= NULL
;
12297 bs
->old_val
= NULL
;
12298 /* bs->commands will be freed later. */
12302 /* Callback for iterate_over_threads. */
12304 bpstat_remove_breakpoint_callback (struct thread_info
*th
, void *data
)
12306 struct breakpoint
*bpt
= (struct breakpoint
*) data
;
12308 bpstat_remove_bp_location (th
->control
.stop_bpstat
, bpt
);
12312 /* Helper for breakpoint and tracepoint breakpoint_ops->mention
12316 say_where (struct breakpoint
*b
)
12318 struct value_print_options opts
;
12320 get_user_print_options (&opts
);
12322 /* i18n: cagney/2005-02-11: Below needs to be merged into a
12324 if (b
->loc
== NULL
)
12326 /* For pending locations, the output differs slightly based
12327 on b->extra_string. If this is non-NULL, it contains either
12328 a condition or dprintf arguments. */
12329 if (b
->extra_string
== NULL
)
12331 printf_filtered (_(" (%s) pending."),
12332 event_location_to_string (b
->location
.get ()));
12334 else if (b
->type
== bp_dprintf
)
12336 printf_filtered (_(" (%s,%s) pending."),
12337 event_location_to_string (b
->location
.get ()),
12342 printf_filtered (_(" (%s %s) pending."),
12343 event_location_to_string (b
->location
.get ()),
12349 if (opts
.addressprint
|| b
->loc
->symtab
== NULL
)
12351 printf_filtered (" at ");
12352 fputs_filtered (paddress (b
->loc
->gdbarch
, b
->loc
->address
),
12355 if (b
->loc
->symtab
!= NULL
)
12357 /* If there is a single location, we can print the location
12359 if (b
->loc
->next
== NULL
)
12360 printf_filtered (": file %s, line %d.",
12361 symtab_to_filename_for_display (b
->loc
->symtab
),
12362 b
->loc
->line_number
);
12364 /* This is not ideal, but each location may have a
12365 different file name, and this at least reflects the
12366 real situation somewhat. */
12367 printf_filtered (": %s.",
12368 event_location_to_string (b
->location
.get ()));
12373 struct bp_location
*loc
= b
->loc
;
12375 for (; loc
; loc
= loc
->next
)
12377 printf_filtered (" (%d locations)", n
);
12382 /* Default bp_location_ops methods. */
12385 bp_location_dtor (struct bp_location
*self
)
12387 xfree (self
->function_name
);
12390 static const struct bp_location_ops bp_location_ops
=
12395 /* Destructor for the breakpoint base class. */
12397 breakpoint::~breakpoint ()
12399 xfree (this->cond_string
);
12400 xfree (this->extra_string
);
12401 xfree (this->filter
);
12404 static struct bp_location
*
12405 base_breakpoint_allocate_location (struct breakpoint
*self
)
12407 return new bp_location (&bp_location_ops
, self
);
12411 base_breakpoint_re_set (struct breakpoint
*b
)
12413 /* Nothing to re-set. */
12416 #define internal_error_pure_virtual_called() \
12417 gdb_assert_not_reached ("pure virtual function called")
12420 base_breakpoint_insert_location (struct bp_location
*bl
)
12422 internal_error_pure_virtual_called ();
12426 base_breakpoint_remove_location (struct bp_location
*bl
,
12427 enum remove_bp_reason reason
)
12429 internal_error_pure_virtual_called ();
12433 base_breakpoint_breakpoint_hit (const struct bp_location
*bl
,
12434 struct address_space
*aspace
,
12436 const struct target_waitstatus
*ws
)
12438 internal_error_pure_virtual_called ();
12442 base_breakpoint_check_status (bpstat bs
)
12447 /* A "works_in_software_mode" breakpoint_ops method that just internal
12451 base_breakpoint_works_in_software_mode (const struct breakpoint
*b
)
12453 internal_error_pure_virtual_called ();
12456 /* A "resources_needed" breakpoint_ops method that just internal
12460 base_breakpoint_resources_needed (const struct bp_location
*bl
)
12462 internal_error_pure_virtual_called ();
12465 static enum print_stop_action
12466 base_breakpoint_print_it (bpstat bs
)
12468 internal_error_pure_virtual_called ();
12472 base_breakpoint_print_one_detail (const struct breakpoint
*self
,
12473 struct ui_out
*uiout
)
12479 base_breakpoint_print_mention (struct breakpoint
*b
)
12481 internal_error_pure_virtual_called ();
12485 base_breakpoint_print_recreate (struct breakpoint
*b
, struct ui_file
*fp
)
12487 internal_error_pure_virtual_called ();
12491 base_breakpoint_create_sals_from_location
12492 (const struct event_location
*location
,
12493 struct linespec_result
*canonical
,
12494 enum bptype type_wanted
)
12496 internal_error_pure_virtual_called ();
12500 base_breakpoint_create_breakpoints_sal (struct gdbarch
*gdbarch
,
12501 struct linespec_result
*c
,
12502 gdb::unique_xmalloc_ptr
<char> cond_string
,
12503 gdb::unique_xmalloc_ptr
<char> extra_string
,
12504 enum bptype type_wanted
,
12505 enum bpdisp disposition
,
12507 int task
, int ignore_count
,
12508 const struct breakpoint_ops
*o
,
12509 int from_tty
, int enabled
,
12510 int internal
, unsigned flags
)
12512 internal_error_pure_virtual_called ();
12515 static std::vector
<symtab_and_line
>
12516 base_breakpoint_decode_location (struct breakpoint
*b
,
12517 const struct event_location
*location
,
12518 struct program_space
*search_pspace
)
12520 internal_error_pure_virtual_called ();
12523 /* The default 'explains_signal' method. */
12526 base_breakpoint_explains_signal (struct breakpoint
*b
, enum gdb_signal sig
)
12531 /* The default "after_condition_true" method. */
12534 base_breakpoint_after_condition_true (struct bpstats
*bs
)
12536 /* Nothing to do. */
12539 struct breakpoint_ops base_breakpoint_ops
=
12541 base_breakpoint_allocate_location
,
12542 base_breakpoint_re_set
,
12543 base_breakpoint_insert_location
,
12544 base_breakpoint_remove_location
,
12545 base_breakpoint_breakpoint_hit
,
12546 base_breakpoint_check_status
,
12547 base_breakpoint_resources_needed
,
12548 base_breakpoint_works_in_software_mode
,
12549 base_breakpoint_print_it
,
12551 base_breakpoint_print_one_detail
,
12552 base_breakpoint_print_mention
,
12553 base_breakpoint_print_recreate
,
12554 base_breakpoint_create_sals_from_location
,
12555 base_breakpoint_create_breakpoints_sal
,
12556 base_breakpoint_decode_location
,
12557 base_breakpoint_explains_signal
,
12558 base_breakpoint_after_condition_true
,
12561 /* Default breakpoint_ops methods. */
12564 bkpt_re_set (struct breakpoint
*b
)
12566 /* FIXME: is this still reachable? */
12567 if (breakpoint_event_location_empty_p (b
))
12569 /* Anything without a location can't be re-set. */
12570 delete_breakpoint (b
);
12574 breakpoint_re_set_default (b
);
12578 bkpt_insert_location (struct bp_location
*bl
)
12580 CORE_ADDR addr
= bl
->target_info
.reqstd_address
;
12582 bl
->target_info
.kind
= breakpoint_kind (bl
, &addr
);
12583 bl
->target_info
.placed_address
= addr
;
12585 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
12586 return target_insert_hw_breakpoint (bl
->gdbarch
, &bl
->target_info
);
12588 return target_insert_breakpoint (bl
->gdbarch
, &bl
->target_info
);
12592 bkpt_remove_location (struct bp_location
*bl
, enum remove_bp_reason reason
)
12594 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
12595 return target_remove_hw_breakpoint (bl
->gdbarch
, &bl
->target_info
);
12597 return target_remove_breakpoint (bl
->gdbarch
, &bl
->target_info
, reason
);
12601 bkpt_breakpoint_hit (const struct bp_location
*bl
,
12602 struct address_space
*aspace
, CORE_ADDR bp_addr
,
12603 const struct target_waitstatus
*ws
)
12605 if (ws
->kind
!= TARGET_WAITKIND_STOPPED
12606 || ws
->value
.sig
!= GDB_SIGNAL_TRAP
)
12609 if (!breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
12613 if (overlay_debugging
/* unmapped overlay section */
12614 && section_is_overlay (bl
->section
)
12615 && !section_is_mapped (bl
->section
))
12622 dprintf_breakpoint_hit (const struct bp_location
*bl
,
12623 struct address_space
*aspace
, CORE_ADDR bp_addr
,
12624 const struct target_waitstatus
*ws
)
12626 if (dprintf_style
== dprintf_style_agent
12627 && target_can_run_breakpoint_commands ())
12629 /* An agent-style dprintf never causes a stop. If we see a trap
12630 for this address it must be for a breakpoint that happens to
12631 be set at the same address. */
12635 return bkpt_breakpoint_hit (bl
, aspace
, bp_addr
, ws
);
12639 bkpt_resources_needed (const struct bp_location
*bl
)
12641 gdb_assert (bl
->owner
->type
== bp_hardware_breakpoint
);
12646 static enum print_stop_action
12647 bkpt_print_it (bpstat bs
)
12649 struct breakpoint
*b
;
12650 const struct bp_location
*bl
;
12652 struct ui_out
*uiout
= current_uiout
;
12654 gdb_assert (bs
->bp_location_at
!= NULL
);
12656 bl
= bs
->bp_location_at
;
12657 b
= bs
->breakpoint_at
;
12659 bp_temp
= b
->disposition
== disp_del
;
12660 if (bl
->address
!= bl
->requested_address
)
12661 breakpoint_adjustment_warning (bl
->requested_address
,
12664 annotate_breakpoint (b
->number
);
12665 maybe_print_thread_hit_breakpoint (uiout
);
12668 uiout
->text ("Temporary breakpoint ");
12670 uiout
->text ("Breakpoint ");
12671 if (uiout
->is_mi_like_p ())
12673 uiout
->field_string ("reason",
12674 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
12675 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
12677 uiout
->field_int ("bkptno", b
->number
);
12678 uiout
->text (", ");
12680 return PRINT_SRC_AND_LOC
;
12684 bkpt_print_mention (struct breakpoint
*b
)
12686 if (current_uiout
->is_mi_like_p ())
12691 case bp_breakpoint
:
12692 case bp_gnu_ifunc_resolver
:
12693 if (b
->disposition
== disp_del
)
12694 printf_filtered (_("Temporary breakpoint"));
12696 printf_filtered (_("Breakpoint"));
12697 printf_filtered (_(" %d"), b
->number
);
12698 if (b
->type
== bp_gnu_ifunc_resolver
)
12699 printf_filtered (_(" at gnu-indirect-function resolver"));
12701 case bp_hardware_breakpoint
:
12702 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
12705 printf_filtered (_("Dprintf %d"), b
->number
);
12713 bkpt_print_recreate (struct breakpoint
*tp
, struct ui_file
*fp
)
12715 if (tp
->type
== bp_breakpoint
&& tp
->disposition
== disp_del
)
12716 fprintf_unfiltered (fp
, "tbreak");
12717 else if (tp
->type
== bp_breakpoint
)
12718 fprintf_unfiltered (fp
, "break");
12719 else if (tp
->type
== bp_hardware_breakpoint
12720 && tp
->disposition
== disp_del
)
12721 fprintf_unfiltered (fp
, "thbreak");
12722 else if (tp
->type
== bp_hardware_breakpoint
)
12723 fprintf_unfiltered (fp
, "hbreak");
12725 internal_error (__FILE__
, __LINE__
,
12726 _("unhandled breakpoint type %d"), (int) tp
->type
);
12728 fprintf_unfiltered (fp
, " %s",
12729 event_location_to_string (tp
->location
.get ()));
12731 /* Print out extra_string if this breakpoint is pending. It might
12732 contain, for example, conditions that were set by the user. */
12733 if (tp
->loc
== NULL
&& tp
->extra_string
!= NULL
)
12734 fprintf_unfiltered (fp
, " %s", tp
->extra_string
);
12736 print_recreate_thread (tp
, fp
);
12740 bkpt_create_sals_from_location (const struct event_location
*location
,
12741 struct linespec_result
*canonical
,
12742 enum bptype type_wanted
)
12744 create_sals_from_location_default (location
, canonical
, type_wanted
);
12748 bkpt_create_breakpoints_sal (struct gdbarch
*gdbarch
,
12749 struct linespec_result
*canonical
,
12750 gdb::unique_xmalloc_ptr
<char> cond_string
,
12751 gdb::unique_xmalloc_ptr
<char> extra_string
,
12752 enum bptype type_wanted
,
12753 enum bpdisp disposition
,
12755 int task
, int ignore_count
,
12756 const struct breakpoint_ops
*ops
,
12757 int from_tty
, int enabled
,
12758 int internal
, unsigned flags
)
12760 create_breakpoints_sal_default (gdbarch
, canonical
,
12761 std::move (cond_string
),
12762 std::move (extra_string
),
12764 disposition
, thread
, task
,
12765 ignore_count
, ops
, from_tty
,
12766 enabled
, internal
, flags
);
12769 static std::vector
<symtab_and_line
>
12770 bkpt_decode_location (struct breakpoint
*b
,
12771 const struct event_location
*location
,
12772 struct program_space
*search_pspace
)
12774 return decode_location_default (b
, location
, search_pspace
);
12777 /* Virtual table for internal breakpoints. */
12780 internal_bkpt_re_set (struct breakpoint
*b
)
12784 /* Delete overlay event and longjmp master breakpoints; they
12785 will be reset later by breakpoint_re_set. */
12786 case bp_overlay_event
:
12787 case bp_longjmp_master
:
12788 case bp_std_terminate_master
:
12789 case bp_exception_master
:
12790 delete_breakpoint (b
);
12793 /* This breakpoint is special, it's set up when the inferior
12794 starts and we really don't want to touch it. */
12795 case bp_shlib_event
:
12797 /* Like bp_shlib_event, this breakpoint type is special. Once
12798 it is set up, we do not want to touch it. */
12799 case bp_thread_event
:
12805 internal_bkpt_check_status (bpstat bs
)
12807 if (bs
->breakpoint_at
->type
== bp_shlib_event
)
12809 /* If requested, stop when the dynamic linker notifies GDB of
12810 events. This allows the user to get control and place
12811 breakpoints in initializer routines for dynamically loaded
12812 objects (among other things). */
12813 bs
->stop
= stop_on_solib_events
;
12814 bs
->print
= stop_on_solib_events
;
12820 static enum print_stop_action
12821 internal_bkpt_print_it (bpstat bs
)
12823 struct breakpoint
*b
;
12825 b
= bs
->breakpoint_at
;
12829 case bp_shlib_event
:
12830 /* Did we stop because the user set the stop_on_solib_events
12831 variable? (If so, we report this as a generic, "Stopped due
12832 to shlib event" message.) */
12833 print_solib_event (0);
12836 case bp_thread_event
:
12837 /* Not sure how we will get here.
12838 GDB should not stop for these breakpoints. */
12839 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
12842 case bp_overlay_event
:
12843 /* By analogy with the thread event, GDB should not stop for these. */
12844 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
12847 case bp_longjmp_master
:
12848 /* These should never be enabled. */
12849 printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
12852 case bp_std_terminate_master
:
12853 /* These should never be enabled. */
12854 printf_filtered (_("std::terminate Master Breakpoint: "
12855 "gdb should not stop!\n"));
12858 case bp_exception_master
:
12859 /* These should never be enabled. */
12860 printf_filtered (_("Exception Master Breakpoint: "
12861 "gdb should not stop!\n"));
12865 return PRINT_NOTHING
;
12869 internal_bkpt_print_mention (struct breakpoint
*b
)
12871 /* Nothing to mention. These breakpoints are internal. */
12874 /* Virtual table for momentary breakpoints */
12877 momentary_bkpt_re_set (struct breakpoint
*b
)
12879 /* Keep temporary breakpoints, which can be encountered when we step
12880 over a dlopen call and solib_add is resetting the breakpoints.
12881 Otherwise these should have been blown away via the cleanup chain
12882 or by breakpoint_init_inferior when we rerun the executable. */
12886 momentary_bkpt_check_status (bpstat bs
)
12888 /* Nothing. The point of these breakpoints is causing a stop. */
12891 static enum print_stop_action
12892 momentary_bkpt_print_it (bpstat bs
)
12894 return PRINT_UNKNOWN
;
12898 momentary_bkpt_print_mention (struct breakpoint
*b
)
12900 /* Nothing to mention. These breakpoints are internal. */
12903 /* Ensure INITIATING_FRAME is cleared when no such breakpoint exists.
12905 It gets cleared already on the removal of the first one of such placed
12906 breakpoints. This is OK as they get all removed altogether. */
12908 longjmp_breakpoint::~longjmp_breakpoint ()
12910 thread_info
*tp
= find_thread_global_id (this->thread
);
12913 tp
->initiating_frame
= null_frame_id
;
12916 /* Specific methods for probe breakpoints. */
12919 bkpt_probe_insert_location (struct bp_location
*bl
)
12921 int v
= bkpt_insert_location (bl
);
12925 /* The insertion was successful, now let's set the probe's semaphore
12927 if (bl
->probe
.probe
->pops
->set_semaphore
!= NULL
)
12928 bl
->probe
.probe
->pops
->set_semaphore (bl
->probe
.probe
,
12937 bkpt_probe_remove_location (struct bp_location
*bl
,
12938 enum remove_bp_reason reason
)
12940 /* Let's clear the semaphore before removing the location. */
12941 if (bl
->probe
.probe
->pops
->clear_semaphore
!= NULL
)
12942 bl
->probe
.probe
->pops
->clear_semaphore (bl
->probe
.probe
,
12946 return bkpt_remove_location (bl
, reason
);
12950 bkpt_probe_create_sals_from_location (const struct event_location
*location
,
12951 struct linespec_result
*canonical
,
12952 enum bptype type_wanted
)
12954 struct linespec_sals lsal
;
12956 lsal
.sals
= parse_probes (location
, NULL
, canonical
);
12958 = xstrdup (event_location_to_string (canonical
->location
.get ()));
12959 canonical
->lsals
.push_back (std::move (lsal
));
12962 static std::vector
<symtab_and_line
>
12963 bkpt_probe_decode_location (struct breakpoint
*b
,
12964 const struct event_location
*location
,
12965 struct program_space
*search_pspace
)
12967 std::vector
<symtab_and_line
> sals
= parse_probes (location
, search_pspace
, NULL
);
12969 error (_("probe not found"));
12973 /* The breakpoint_ops structure to be used in tracepoints. */
12976 tracepoint_re_set (struct breakpoint
*b
)
12978 breakpoint_re_set_default (b
);
12982 tracepoint_breakpoint_hit (const struct bp_location
*bl
,
12983 struct address_space
*aspace
, CORE_ADDR bp_addr
,
12984 const struct target_waitstatus
*ws
)
12986 /* By definition, the inferior does not report stops at
12992 tracepoint_print_one_detail (const struct breakpoint
*self
,
12993 struct ui_out
*uiout
)
12995 struct tracepoint
*tp
= (struct tracepoint
*) self
;
12996 if (tp
->static_trace_marker_id
)
12998 gdb_assert (self
->type
== bp_static_tracepoint
);
13000 uiout
->text ("\tmarker id is ");
13001 uiout
->field_string ("static-tracepoint-marker-string-id",
13002 tp
->static_trace_marker_id
);
13003 uiout
->text ("\n");
13008 tracepoint_print_mention (struct breakpoint
*b
)
13010 if (current_uiout
->is_mi_like_p ())
13015 case bp_tracepoint
:
13016 printf_filtered (_("Tracepoint"));
13017 printf_filtered (_(" %d"), b
->number
);
13019 case bp_fast_tracepoint
:
13020 printf_filtered (_("Fast tracepoint"));
13021 printf_filtered (_(" %d"), b
->number
);
13023 case bp_static_tracepoint
:
13024 printf_filtered (_("Static tracepoint"));
13025 printf_filtered (_(" %d"), b
->number
);
13028 internal_error (__FILE__
, __LINE__
,
13029 _("unhandled tracepoint type %d"), (int) b
->type
);
13036 tracepoint_print_recreate (struct breakpoint
*self
, struct ui_file
*fp
)
13038 struct tracepoint
*tp
= (struct tracepoint
*) self
;
13040 if (self
->type
== bp_fast_tracepoint
)
13041 fprintf_unfiltered (fp
, "ftrace");
13042 else if (self
->type
== bp_static_tracepoint
)
13043 fprintf_unfiltered (fp
, "strace");
13044 else if (self
->type
== bp_tracepoint
)
13045 fprintf_unfiltered (fp
, "trace");
13047 internal_error (__FILE__
, __LINE__
,
13048 _("unhandled tracepoint type %d"), (int) self
->type
);
13050 fprintf_unfiltered (fp
, " %s",
13051 event_location_to_string (self
->location
.get ()));
13052 print_recreate_thread (self
, fp
);
13054 if (tp
->pass_count
)
13055 fprintf_unfiltered (fp
, " passcount %d\n", tp
->pass_count
);
13059 tracepoint_create_sals_from_location (const struct event_location
*location
,
13060 struct linespec_result
*canonical
,
13061 enum bptype type_wanted
)
13063 create_sals_from_location_default (location
, canonical
, type_wanted
);
13067 tracepoint_create_breakpoints_sal (struct gdbarch
*gdbarch
,
13068 struct linespec_result
*canonical
,
13069 gdb::unique_xmalloc_ptr
<char> cond_string
,
13070 gdb::unique_xmalloc_ptr
<char> extra_string
,
13071 enum bptype type_wanted
,
13072 enum bpdisp disposition
,
13074 int task
, int ignore_count
,
13075 const struct breakpoint_ops
*ops
,
13076 int from_tty
, int enabled
,
13077 int internal
, unsigned flags
)
13079 create_breakpoints_sal_default (gdbarch
, canonical
,
13080 std::move (cond_string
),
13081 std::move (extra_string
),
13083 disposition
, thread
, task
,
13084 ignore_count
, ops
, from_tty
,
13085 enabled
, internal
, flags
);
13088 static std::vector
<symtab_and_line
>
13089 tracepoint_decode_location (struct breakpoint
*b
,
13090 const struct event_location
*location
,
13091 struct program_space
*search_pspace
)
13093 return decode_location_default (b
, location
, search_pspace
);
13096 struct breakpoint_ops tracepoint_breakpoint_ops
;
13098 /* The breakpoint_ops structure to be use on tracepoints placed in a
13102 tracepoint_probe_create_sals_from_location
13103 (const struct event_location
*location
,
13104 struct linespec_result
*canonical
,
13105 enum bptype type_wanted
)
13107 /* We use the same method for breakpoint on probes. */
13108 bkpt_probe_create_sals_from_location (location
, canonical
, type_wanted
);
13111 static std::vector
<symtab_and_line
>
13112 tracepoint_probe_decode_location (struct breakpoint
*b
,
13113 const struct event_location
*location
,
13114 struct program_space
*search_pspace
)
13116 /* We use the same method for breakpoint on probes. */
13117 return bkpt_probe_decode_location (b
, location
, search_pspace
);
13120 static struct breakpoint_ops tracepoint_probe_breakpoint_ops
;
13122 /* Dprintf breakpoint_ops methods. */
13125 dprintf_re_set (struct breakpoint
*b
)
13127 breakpoint_re_set_default (b
);
13129 /* extra_string should never be non-NULL for dprintf. */
13130 gdb_assert (b
->extra_string
!= NULL
);
13132 /* 1 - connect to target 1, that can run breakpoint commands.
13133 2 - create a dprintf, which resolves fine.
13134 3 - disconnect from target 1
13135 4 - connect to target 2, that can NOT run breakpoint commands.
13137 After steps #3/#4, you'll want the dprintf command list to
13138 be updated, because target 1 and 2 may well return different
13139 answers for target_can_run_breakpoint_commands().
13140 Given absence of finer grained resetting, we get to do
13141 it all the time. */
13142 if (b
->extra_string
!= NULL
)
13143 update_dprintf_command_list (b
);
13146 /* Implement the "print_recreate" breakpoint_ops method for dprintf. */
13149 dprintf_print_recreate (struct breakpoint
*tp
, struct ui_file
*fp
)
13151 fprintf_unfiltered (fp
, "dprintf %s,%s",
13152 event_location_to_string (tp
->location
.get ()),
13154 print_recreate_thread (tp
, fp
);
13157 /* Implement the "after_condition_true" breakpoint_ops method for
13160 dprintf's are implemented with regular commands in their command
13161 list, but we run the commands here instead of before presenting the
13162 stop to the user, as dprintf's don't actually cause a stop. This
13163 also makes it so that the commands of multiple dprintfs at the same
13164 address are all handled. */
13167 dprintf_after_condition_true (struct bpstats
*bs
)
13169 struct bpstats tmp_bs
;
13170 struct bpstats
*tmp_bs_p
= &tmp_bs
;
13172 /* dprintf's never cause a stop. This wasn't set in the
13173 check_status hook instead because that would make the dprintf's
13174 condition not be evaluated. */
13177 /* Run the command list here. Take ownership of it instead of
13178 copying. We never want these commands to run later in
13179 bpstat_do_actions, if a breakpoint that causes a stop happens to
13180 be set at same address as this dprintf, or even if running the
13181 commands here throws. */
13182 tmp_bs
.commands
= bs
->commands
;
13183 bs
->commands
= NULL
;
13185 bpstat_do_actions_1 (&tmp_bs_p
);
13187 /* 'tmp_bs.commands' will usually be NULL by now, but
13188 bpstat_do_actions_1 may return early without processing the whole
13192 /* The breakpoint_ops structure to be used on static tracepoints with
13196 strace_marker_create_sals_from_location (const struct event_location
*location
,
13197 struct linespec_result
*canonical
,
13198 enum bptype type_wanted
)
13200 struct linespec_sals lsal
;
13201 const char *arg_start
, *arg
;
13203 arg
= arg_start
= get_linespec_location (location
);
13204 lsal
.sals
= decode_static_tracepoint_spec (&arg
);
13206 std::string
str (arg_start
, arg
- arg_start
);
13207 const char *ptr
= str
.c_str ();
13208 canonical
->location
= new_linespec_location (&ptr
);
13211 = xstrdup (event_location_to_string (canonical
->location
.get ()));
13212 canonical
->lsals
.push_back (std::move (lsal
));
13216 strace_marker_create_breakpoints_sal (struct gdbarch
*gdbarch
,
13217 struct linespec_result
*canonical
,
13218 gdb::unique_xmalloc_ptr
<char> cond_string
,
13219 gdb::unique_xmalloc_ptr
<char> extra_string
,
13220 enum bptype type_wanted
,
13221 enum bpdisp disposition
,
13223 int task
, int ignore_count
,
13224 const struct breakpoint_ops
*ops
,
13225 int from_tty
, int enabled
,
13226 int internal
, unsigned flags
)
13228 const linespec_sals
&lsal
= canonical
->lsals
[0];
13230 /* If the user is creating a static tracepoint by marker id
13231 (strace -m MARKER_ID), then store the sals index, so that
13232 breakpoint_re_set can try to match up which of the newly
13233 found markers corresponds to this one, and, don't try to
13234 expand multiple locations for each sal, given than SALS
13235 already should contain all sals for MARKER_ID. */
13237 for (size_t i
= 0; i
< lsal
.sals
.size (); i
++)
13239 event_location_up location
13240 = copy_event_location (canonical
->location
.get ());
13242 std::unique_ptr
<tracepoint
> tp (new tracepoint ());
13243 init_breakpoint_sal (tp
.get (), gdbarch
, lsal
.sals
[i
],
13244 std::move (location
), NULL
,
13245 std::move (cond_string
),
13246 std::move (extra_string
),
13247 type_wanted
, disposition
,
13248 thread
, task
, ignore_count
, ops
,
13249 from_tty
, enabled
, internal
, flags
,
13250 canonical
->special_display
);
13251 /* Given that its possible to have multiple markers with
13252 the same string id, if the user is creating a static
13253 tracepoint by marker id ("strace -m MARKER_ID"), then
13254 store the sals index, so that breakpoint_re_set can
13255 try to match up which of the newly found markers
13256 corresponds to this one */
13257 tp
->static_trace_marker_id_idx
= i
;
13259 install_breakpoint (internal
, std::move (tp
), 0);
13263 static std::vector
<symtab_and_line
>
13264 strace_marker_decode_location (struct breakpoint
*b
,
13265 const struct event_location
*location
,
13266 struct program_space
*search_pspace
)
13268 struct tracepoint
*tp
= (struct tracepoint
*) b
;
13269 const char *s
= get_linespec_location (location
);
13271 std::vector
<symtab_and_line
> sals
= decode_static_tracepoint_spec (&s
);
13272 if (sals
.size () > tp
->static_trace_marker_id_idx
)
13274 sals
[0] = sals
[tp
->static_trace_marker_id_idx
];
13279 error (_("marker %s not found"), tp
->static_trace_marker_id
);
13282 static struct breakpoint_ops strace_marker_breakpoint_ops
;
13285 strace_marker_p (struct breakpoint
*b
)
13287 return b
->ops
== &strace_marker_breakpoint_ops
;
13290 /* Delete a breakpoint and clean up all traces of it in the data
13294 delete_breakpoint (struct breakpoint
*bpt
)
13296 struct breakpoint
*b
;
13298 gdb_assert (bpt
!= NULL
);
13300 /* Has this bp already been deleted? This can happen because
13301 multiple lists can hold pointers to bp's. bpstat lists are
13304 One example of this happening is a watchpoint's scope bp. When
13305 the scope bp triggers, we notice that the watchpoint is out of
13306 scope, and delete it. We also delete its scope bp. But the
13307 scope bp is marked "auto-deleting", and is already on a bpstat.
13308 That bpstat is then checked for auto-deleting bp's, which are
13311 A real solution to this problem might involve reference counts in
13312 bp's, and/or giving them pointers back to their referencing
13313 bpstat's, and teaching delete_breakpoint to only free a bp's
13314 storage when no more references were extent. A cheaper bandaid
13316 if (bpt
->type
== bp_none
)
13319 /* At least avoid this stale reference until the reference counting
13320 of breakpoints gets resolved. */
13321 if (bpt
->related_breakpoint
!= bpt
)
13323 struct breakpoint
*related
;
13324 struct watchpoint
*w
;
13326 if (bpt
->type
== bp_watchpoint_scope
)
13327 w
= (struct watchpoint
*) bpt
->related_breakpoint
;
13328 else if (bpt
->related_breakpoint
->type
== bp_watchpoint_scope
)
13329 w
= (struct watchpoint
*) bpt
;
13333 watchpoint_del_at_next_stop (w
);
13335 /* Unlink bpt from the bpt->related_breakpoint ring. */
13336 for (related
= bpt
; related
->related_breakpoint
!= bpt
;
13337 related
= related
->related_breakpoint
);
13338 related
->related_breakpoint
= bpt
->related_breakpoint
;
13339 bpt
->related_breakpoint
= bpt
;
13342 /* watch_command_1 creates a watchpoint but only sets its number if
13343 update_watchpoint succeeds in creating its bp_locations. If there's
13344 a problem in that process, we'll be asked to delete the half-created
13345 watchpoint. In that case, don't announce the deletion. */
13347 observer_notify_breakpoint_deleted (bpt
);
13349 if (breakpoint_chain
== bpt
)
13350 breakpoint_chain
= bpt
->next
;
13352 ALL_BREAKPOINTS (b
)
13353 if (b
->next
== bpt
)
13355 b
->next
= bpt
->next
;
13359 /* Be sure no bpstat's are pointing at the breakpoint after it's
13361 /* FIXME, how can we find all bpstat's? We just check stop_bpstat
13362 in all threads for now. Note that we cannot just remove bpstats
13363 pointing at bpt from the stop_bpstat list entirely, as breakpoint
13364 commands are associated with the bpstat; if we remove it here,
13365 then the later call to bpstat_do_actions (&stop_bpstat); in
13366 event-top.c won't do anything, and temporary breakpoints with
13367 commands won't work. */
13369 iterate_over_threads (bpstat_remove_breakpoint_callback
, bpt
);
13371 /* Now that breakpoint is removed from breakpoint list, update the
13372 global location list. This will remove locations that used to
13373 belong to this breakpoint. Do this before freeing the breakpoint
13374 itself, since remove_breakpoint looks at location's owner. It
13375 might be better design to have location completely
13376 self-contained, but it's not the case now. */
13377 update_global_location_list (UGLL_DONT_INSERT
);
13379 /* On the chance that someone will soon try again to delete this
13380 same bp, we mark it as deleted before freeing its storage. */
13381 bpt
->type
= bp_none
;
13386 do_delete_breakpoint_cleanup (void *b
)
13388 delete_breakpoint ((struct breakpoint
*) b
);
13392 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
13394 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
13397 /* Iterator function to call a user-provided callback function once
13398 for each of B and its related breakpoints. */
13401 iterate_over_related_breakpoints (struct breakpoint
*b
,
13402 gdb::function_view
<void (breakpoint
*)> function
)
13404 struct breakpoint
*related
;
13409 struct breakpoint
*next
;
13411 /* FUNCTION may delete RELATED. */
13412 next
= related
->related_breakpoint
;
13414 if (next
== related
)
13416 /* RELATED is the last ring entry. */
13417 function (related
);
13419 /* FUNCTION may have deleted it, so we'd never reach back to
13420 B. There's nothing left to do anyway, so just break
13425 function (related
);
13429 while (related
!= b
);
13433 delete_command (const char *arg
, int from_tty
)
13435 struct breakpoint
*b
, *b_tmp
;
13441 int breaks_to_delete
= 0;
13443 /* Delete all breakpoints if no argument. Do not delete
13444 internal breakpoints, these have to be deleted with an
13445 explicit breakpoint number argument. */
13446 ALL_BREAKPOINTS (b
)
13447 if (user_breakpoint_p (b
))
13449 breaks_to_delete
= 1;
13453 /* Ask user only if there are some breakpoints to delete. */
13455 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
13457 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
13458 if (user_breakpoint_p (b
))
13459 delete_breakpoint (b
);
13463 map_breakpoint_numbers
13464 (arg
, [&] (breakpoint
*b
)
13466 iterate_over_related_breakpoints (b
, delete_breakpoint
);
13470 /* Return true if all locations of B bound to PSPACE are pending. If
13471 PSPACE is NULL, all locations of all program spaces are
13475 all_locations_are_pending (struct breakpoint
*b
, struct program_space
*pspace
)
13477 struct bp_location
*loc
;
13479 for (loc
= b
->loc
; loc
!= NULL
; loc
= loc
->next
)
13480 if ((pspace
== NULL
13481 || loc
->pspace
== pspace
)
13482 && !loc
->shlib_disabled
13483 && !loc
->pspace
->executing_startup
)
13488 /* Subroutine of update_breakpoint_locations to simplify it.
13489 Return non-zero if multiple fns in list LOC have the same name.
13490 Null names are ignored. */
13493 ambiguous_names_p (struct bp_location
*loc
)
13495 struct bp_location
*l
;
13496 htab_t htab
= htab_create_alloc (13, htab_hash_string
,
13497 (int (*) (const void *,
13498 const void *)) streq
,
13499 NULL
, xcalloc
, xfree
);
13501 for (l
= loc
; l
!= NULL
; l
= l
->next
)
13504 const char *name
= l
->function_name
;
13506 /* Allow for some names to be NULL, ignore them. */
13510 slot
= (const char **) htab_find_slot (htab
, (const void *) name
,
13512 /* NOTE: We can assume slot != NULL here because xcalloc never
13516 htab_delete (htab
);
13522 htab_delete (htab
);
13526 /* When symbols change, it probably means the sources changed as well,
13527 and it might mean the static tracepoint markers are no longer at
13528 the same address or line numbers they used to be at last we
13529 checked. Losing your static tracepoints whenever you rebuild is
13530 undesirable. This function tries to resync/rematch gdb static
13531 tracepoints with the markers on the target, for static tracepoints
13532 that have not been set by marker id. Static tracepoint that have
13533 been set by marker id are reset by marker id in breakpoint_re_set.
13536 1) For a tracepoint set at a specific address, look for a marker at
13537 the old PC. If one is found there, assume to be the same marker.
13538 If the name / string id of the marker found is different from the
13539 previous known name, assume that means the user renamed the marker
13540 in the sources, and output a warning.
13542 2) For a tracepoint set at a given line number, look for a marker
13543 at the new address of the old line number. If one is found there,
13544 assume to be the same marker. If the name / string id of the
13545 marker found is different from the previous known name, assume that
13546 means the user renamed the marker in the sources, and output a
13549 3) If a marker is no longer found at the same address or line, it
13550 may mean the marker no longer exists. But it may also just mean
13551 the code changed a bit. Maybe the user added a few lines of code
13552 that made the marker move up or down (in line number terms). Ask
13553 the target for info about the marker with the string id as we knew
13554 it. If found, update line number and address in the matching
13555 static tracepoint. This will get confused if there's more than one
13556 marker with the same ID (possible in UST, although unadvised
13557 precisely because it confuses tools). */
13559 static struct symtab_and_line
13560 update_static_tracepoint (struct breakpoint
*b
, struct symtab_and_line sal
)
13562 struct tracepoint
*tp
= (struct tracepoint
*) b
;
13563 struct static_tracepoint_marker marker
;
13568 find_line_pc (sal
.symtab
, sal
.line
, &pc
);
13570 if (target_static_tracepoint_marker_at (pc
, &marker
))
13572 if (strcmp (tp
->static_trace_marker_id
, marker
.str_id
) != 0)
13573 warning (_("static tracepoint %d changed probed marker from %s to %s"),
13575 tp
->static_trace_marker_id
, marker
.str_id
);
13577 xfree (tp
->static_trace_marker_id
);
13578 tp
->static_trace_marker_id
= xstrdup (marker
.str_id
);
13579 release_static_tracepoint_marker (&marker
);
13584 /* Old marker wasn't found on target at lineno. Try looking it up
13586 if (!sal
.explicit_pc
13588 && sal
.symtab
!= NULL
13589 && tp
->static_trace_marker_id
!= NULL
)
13591 VEC(static_tracepoint_marker_p
) *markers
;
13594 = target_static_tracepoint_markers_by_strid (tp
->static_trace_marker_id
);
13596 if (!VEC_empty(static_tracepoint_marker_p
, markers
))
13598 struct symbol
*sym
;
13599 struct static_tracepoint_marker
*tpmarker
;
13600 struct ui_out
*uiout
= current_uiout
;
13601 struct explicit_location explicit_loc
;
13603 tpmarker
= VEC_index (static_tracepoint_marker_p
, markers
, 0);
13605 xfree (tp
->static_trace_marker_id
);
13606 tp
->static_trace_marker_id
= xstrdup (tpmarker
->str_id
);
13608 warning (_("marker for static tracepoint %d (%s) not "
13609 "found at previous line number"),
13610 b
->number
, tp
->static_trace_marker_id
);
13612 symtab_and_line sal2
= find_pc_line (tpmarker
->address
, 0);
13613 sym
= find_pc_sect_function (tpmarker
->address
, NULL
);
13614 uiout
->text ("Now in ");
13617 uiout
->field_string ("func", SYMBOL_PRINT_NAME (sym
));
13618 uiout
->text (" at ");
13620 uiout
->field_string ("file",
13621 symtab_to_filename_for_display (sal2
.symtab
));
13624 if (uiout
->is_mi_like_p ())
13626 const char *fullname
= symtab_to_fullname (sal2
.symtab
);
13628 uiout
->field_string ("fullname", fullname
);
13631 uiout
->field_int ("line", sal2
.line
);
13632 uiout
->text ("\n");
13634 b
->loc
->line_number
= sal2
.line
;
13635 b
->loc
->symtab
= sym
!= NULL
? sal2
.symtab
: NULL
;
13637 b
->location
.reset (NULL
);
13638 initialize_explicit_location (&explicit_loc
);
13639 explicit_loc
.source_filename
13640 = ASTRDUP (symtab_to_filename_for_display (sal2
.symtab
));
13641 explicit_loc
.line_offset
.offset
= b
->loc
->line_number
;
13642 explicit_loc
.line_offset
.sign
= LINE_OFFSET_NONE
;
13643 b
->location
= new_explicit_location (&explicit_loc
);
13645 /* Might be nice to check if function changed, and warn if
13648 release_static_tracepoint_marker (tpmarker
);
13654 /* Returns 1 iff locations A and B are sufficiently same that
13655 we don't need to report breakpoint as changed. */
13658 locations_are_equal (struct bp_location
*a
, struct bp_location
*b
)
13662 if (a
->address
!= b
->address
)
13665 if (a
->shlib_disabled
!= b
->shlib_disabled
)
13668 if (a
->enabled
!= b
->enabled
)
13675 if ((a
== NULL
) != (b
== NULL
))
13681 /* Split all locations of B that are bound to PSPACE out of B's
13682 location list to a separate list and return that list's head. If
13683 PSPACE is NULL, hoist out all locations of B. */
13685 static struct bp_location
*
13686 hoist_existing_locations (struct breakpoint
*b
, struct program_space
*pspace
)
13688 struct bp_location head
;
13689 struct bp_location
*i
= b
->loc
;
13690 struct bp_location
**i_link
= &b
->loc
;
13691 struct bp_location
*hoisted
= &head
;
13693 if (pspace
== NULL
)
13704 if (i
->pspace
== pspace
)
13719 /* Create new breakpoint locations for B (a hardware or software
13720 breakpoint) based on SALS and SALS_END. If SALS_END.NELTS is not
13721 zero, then B is a ranged breakpoint. Only recreates locations for
13722 FILTER_PSPACE. Locations of other program spaces are left
13726 update_breakpoint_locations (struct breakpoint
*b
,
13727 struct program_space
*filter_pspace
,
13728 gdb::array_view
<const symtab_and_line
> sals
,
13729 gdb::array_view
<const symtab_and_line
> sals_end
)
13732 struct bp_location
*existing_locations
;
13734 if (!sals_end
.empty () && (sals
.size () != 1 || sals_end
.size () != 1))
13736 /* Ranged breakpoints have only one start location and one end
13738 b
->enable_state
= bp_disabled
;
13739 printf_unfiltered (_("Could not reset ranged breakpoint %d: "
13740 "multiple locations found\n"),
13745 /* If there's no new locations, and all existing locations are
13746 pending, don't do anything. This optimizes the common case where
13747 all locations are in the same shared library, that was unloaded.
13748 We'd like to retain the location, so that when the library is
13749 loaded again, we don't loose the enabled/disabled status of the
13750 individual locations. */
13751 if (all_locations_are_pending (b
, filter_pspace
) && sals
.empty ())
13754 existing_locations
= hoist_existing_locations (b
, filter_pspace
);
13756 for (const auto &sal
: sals
)
13758 struct bp_location
*new_loc
;
13760 switch_to_program_space_and_thread (sal
.pspace
);
13762 new_loc
= add_location_to_breakpoint (b
, &sal
);
13764 /* Reparse conditions, they might contain references to the
13766 if (b
->cond_string
!= NULL
)
13770 s
= b
->cond_string
;
13773 new_loc
->cond
= parse_exp_1 (&s
, sal
.pc
,
13774 block_for_pc (sal
.pc
),
13777 CATCH (e
, RETURN_MASK_ERROR
)
13779 warning (_("failed to reevaluate condition "
13780 "for breakpoint %d: %s"),
13781 b
->number
, e
.message
);
13782 new_loc
->enabled
= 0;
13787 if (!sals_end
.empty ())
13789 CORE_ADDR end
= find_breakpoint_range_end (sals_end
[0]);
13791 new_loc
->length
= end
- sals
[0].pc
+ 1;
13795 /* If possible, carry over 'disable' status from existing
13798 struct bp_location
*e
= existing_locations
;
13799 /* If there are multiple breakpoints with the same function name,
13800 e.g. for inline functions, comparing function names won't work.
13801 Instead compare pc addresses; this is just a heuristic as things
13802 may have moved, but in practice it gives the correct answer
13803 often enough until a better solution is found. */
13804 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
13806 for (; e
; e
= e
->next
)
13808 if (!e
->enabled
&& e
->function_name
)
13810 struct bp_location
*l
= b
->loc
;
13811 if (have_ambiguous_names
)
13813 for (; l
; l
= l
->next
)
13814 if (breakpoint_locations_match (e
, l
))
13822 for (; l
; l
= l
->next
)
13823 if (l
->function_name
13824 && strcmp (e
->function_name
, l
->function_name
) == 0)
13834 if (!locations_are_equal (existing_locations
, b
->loc
))
13835 observer_notify_breakpoint_modified (b
);
13838 /* Find the SaL locations corresponding to the given LOCATION.
13839 On return, FOUND will be 1 if any SaL was found, zero otherwise. */
13841 static std::vector
<symtab_and_line
>
13842 location_to_sals (struct breakpoint
*b
, struct event_location
*location
,
13843 struct program_space
*search_pspace
, int *found
)
13845 struct gdb_exception exception
= exception_none
;
13847 gdb_assert (b
->ops
!= NULL
);
13849 std::vector
<symtab_and_line
> sals
;
13853 sals
= b
->ops
->decode_location (b
, location
, search_pspace
);
13855 CATCH (e
, RETURN_MASK_ERROR
)
13857 int not_found_and_ok
= 0;
13861 /* For pending breakpoints, it's expected that parsing will
13862 fail until the right shared library is loaded. User has
13863 already told to create pending breakpoints and don't need
13864 extra messages. If breakpoint is in bp_shlib_disabled
13865 state, then user already saw the message about that
13866 breakpoint being disabled, and don't want to see more
13868 if (e
.error
== NOT_FOUND_ERROR
13869 && (b
->condition_not_parsed
13871 && search_pspace
!= NULL
13872 && b
->loc
->pspace
!= search_pspace
)
13873 || (b
->loc
&& b
->loc
->shlib_disabled
)
13874 || (b
->loc
&& b
->loc
->pspace
->executing_startup
)
13875 || b
->enable_state
== bp_disabled
))
13876 not_found_and_ok
= 1;
13878 if (!not_found_and_ok
)
13880 /* We surely don't want to warn about the same breakpoint
13881 10 times. One solution, implemented here, is disable
13882 the breakpoint on error. Another solution would be to
13883 have separate 'warning emitted' flag. Since this
13884 happens only when a binary has changed, I don't know
13885 which approach is better. */
13886 b
->enable_state
= bp_disabled
;
13887 throw_exception (e
);
13892 if (exception
.reason
== 0 || exception
.error
!= NOT_FOUND_ERROR
)
13894 for (auto &sal
: sals
)
13895 resolve_sal_pc (&sal
);
13896 if (b
->condition_not_parsed
&& b
->extra_string
!= NULL
)
13898 char *cond_string
, *extra_string
;
13901 find_condition_and_thread (b
->extra_string
, sals
[0].pc
,
13902 &cond_string
, &thread
, &task
,
13904 gdb_assert (b
->cond_string
== NULL
);
13906 b
->cond_string
= cond_string
;
13907 b
->thread
= thread
;
13911 xfree (b
->extra_string
);
13912 b
->extra_string
= extra_string
;
13914 b
->condition_not_parsed
= 0;
13917 if (b
->type
== bp_static_tracepoint
&& !strace_marker_p (b
))
13918 sals
[0] = update_static_tracepoint (b
, sals
[0]);
13928 /* The default re_set method, for typical hardware or software
13929 breakpoints. Reevaluate the breakpoint and recreate its
13933 breakpoint_re_set_default (struct breakpoint
*b
)
13935 struct program_space
*filter_pspace
= current_program_space
;
13936 std::vector
<symtab_and_line
> expanded
, expanded_end
;
13939 std::vector
<symtab_and_line
> sals
= location_to_sals (b
, b
->location
.get (),
13940 filter_pspace
, &found
);
13942 expanded
= std::move (sals
);
13944 if (b
->location_range_end
!= NULL
)
13946 std::vector
<symtab_and_line
> sals_end
13947 = location_to_sals (b
, b
->location_range_end
.get (),
13948 filter_pspace
, &found
);
13950 expanded_end
= std::move (sals_end
);
13953 update_breakpoint_locations (b
, filter_pspace
, expanded
, expanded_end
);
13956 /* Default method for creating SALs from an address string. It basically
13957 calls parse_breakpoint_sals. Return 1 for success, zero for failure. */
13960 create_sals_from_location_default (const struct event_location
*location
,
13961 struct linespec_result
*canonical
,
13962 enum bptype type_wanted
)
13964 parse_breakpoint_sals (location
, canonical
);
13967 /* Call create_breakpoints_sal for the given arguments. This is the default
13968 function for the `create_breakpoints_sal' method of
13972 create_breakpoints_sal_default (struct gdbarch
*gdbarch
,
13973 struct linespec_result
*canonical
,
13974 gdb::unique_xmalloc_ptr
<char> cond_string
,
13975 gdb::unique_xmalloc_ptr
<char> extra_string
,
13976 enum bptype type_wanted
,
13977 enum bpdisp disposition
,
13979 int task
, int ignore_count
,
13980 const struct breakpoint_ops
*ops
,
13981 int from_tty
, int enabled
,
13982 int internal
, unsigned flags
)
13984 create_breakpoints_sal (gdbarch
, canonical
,
13985 std::move (cond_string
),
13986 std::move (extra_string
),
13987 type_wanted
, disposition
,
13988 thread
, task
, ignore_count
, ops
, from_tty
,
13989 enabled
, internal
, flags
);
13992 /* Decode the line represented by S by calling decode_line_full. This is the
13993 default function for the `decode_location' method of breakpoint_ops. */
13995 static std::vector
<symtab_and_line
>
13996 decode_location_default (struct breakpoint
*b
,
13997 const struct event_location
*location
,
13998 struct program_space
*search_pspace
)
14000 struct linespec_result canonical
;
14002 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, search_pspace
,
14003 (struct symtab
*) NULL
, 0,
14004 &canonical
, multiple_symbols_all
,
14007 /* We should get 0 or 1 resulting SALs. */
14008 gdb_assert (canonical
.lsals
.size () < 2);
14010 if (!canonical
.lsals
.empty ())
14012 const linespec_sals
&lsal
= canonical
.lsals
[0];
14013 return std::move (lsal
.sals
);
14018 /* Reset a breakpoint. */
14021 breakpoint_re_set_one (breakpoint
*b
)
14023 input_radix
= b
->input_radix
;
14024 set_language (b
->language
);
14026 b
->ops
->re_set (b
);
14029 /* Re-set breakpoint locations for the current program space.
14030 Locations bound to other program spaces are left untouched. */
14033 breakpoint_re_set (void)
14035 struct breakpoint
*b
, *b_tmp
;
14038 scoped_restore_current_language save_language
;
14039 scoped_restore save_input_radix
= make_scoped_restore (&input_radix
);
14040 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
14042 /* Note: we must not try to insert locations until after all
14043 breakpoints have been re-set. Otherwise, e.g., when re-setting
14044 breakpoint 1, we'd insert the locations of breakpoint 2, which
14045 hadn't been re-set yet, and thus may have stale locations. */
14047 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
14051 breakpoint_re_set_one (b
);
14053 CATCH (ex
, RETURN_MASK_ALL
)
14055 exception_fprintf (gdb_stderr
, ex
,
14056 "Error in re-setting breakpoint %d: ",
14062 jit_breakpoint_re_set ();
14065 create_overlay_event_breakpoint ();
14066 create_longjmp_master_breakpoint ();
14067 create_std_terminate_master_breakpoint ();
14068 create_exception_master_breakpoint ();
14070 /* Now we can insert. */
14071 update_global_location_list (UGLL_MAY_INSERT
);
14074 /* Reset the thread number of this breakpoint:
14076 - If the breakpoint is for all threads, leave it as-is.
14077 - Else, reset it to the current thread for inferior_ptid. */
14079 breakpoint_re_set_thread (struct breakpoint
*b
)
14081 if (b
->thread
!= -1)
14083 if (in_thread_list (inferior_ptid
))
14084 b
->thread
= ptid_to_global_thread_id (inferior_ptid
);
14086 /* We're being called after following a fork. The new fork is
14087 selected as current, and unless this was a vfork will have a
14088 different program space from the original thread. Reset that
14090 b
->loc
->pspace
= current_program_space
;
14094 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14095 If from_tty is nonzero, it prints a message to that effect,
14096 which ends with a period (no newline). */
14099 set_ignore_count (int bptnum
, int count
, int from_tty
)
14101 struct breakpoint
*b
;
14106 ALL_BREAKPOINTS (b
)
14107 if (b
->number
== bptnum
)
14109 if (is_tracepoint (b
))
14111 if (from_tty
&& count
!= 0)
14112 printf_filtered (_("Ignore count ignored for tracepoint %d."),
14117 b
->ignore_count
= count
;
14121 printf_filtered (_("Will stop next time "
14122 "breakpoint %d is reached."),
14124 else if (count
== 1)
14125 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
14128 printf_filtered (_("Will ignore next %d "
14129 "crossings of breakpoint %d."),
14132 observer_notify_breakpoint_modified (b
);
14136 error (_("No breakpoint number %d."), bptnum
);
14139 /* Command to set ignore-count of breakpoint N to COUNT. */
14142 ignore_command (char *args
, int from_tty
)
14148 error_no_arg (_("a breakpoint number"));
14150 num
= get_number (&p
);
14152 error (_("bad breakpoint number: '%s'"), args
);
14154 error (_("Second argument (specified ignore-count) is missing."));
14156 set_ignore_count (num
,
14157 longest_to_int (value_as_long (parse_and_eval (p
))),
14160 printf_filtered ("\n");
14163 /* Call FUNCTION on each of the breakpoints
14164 whose numbers are given in ARGS. */
14167 map_breakpoint_numbers (const char *args
,
14168 gdb::function_view
<void (breakpoint
*)> function
)
14171 struct breakpoint
*b
, *tmp
;
14173 if (args
== 0 || *args
== '\0')
14174 error_no_arg (_("one or more breakpoint numbers"));
14176 number_or_range_parser
parser (args
);
14178 while (!parser
.finished ())
14180 const char *p
= parser
.cur_tok ();
14181 bool match
= false;
14183 num
= parser
.get_number ();
14186 warning (_("bad breakpoint number at or near '%s'"), p
);
14190 ALL_BREAKPOINTS_SAFE (b
, tmp
)
14191 if (b
->number
== num
)
14198 printf_unfiltered (_("No breakpoint number %d.\n"), num
);
14203 static struct bp_location
*
14204 find_location_by_number (const char *number
)
14209 struct breakpoint
*b
;
14210 struct bp_location
*loc
;
14213 bp_num
= get_number_trailer (&p1
, '.');
14214 if (bp_num
== 0 || p1
[0] != '.')
14215 error (_("Bad breakpoint number '%s'"), number
);
14217 ALL_BREAKPOINTS (b
)
14218 if (b
->number
== bp_num
)
14223 if (!b
|| b
->number
!= bp_num
)
14224 error (_("Bad breakpoint number '%s'"), number
);
14226 /* Skip the dot. */
14228 const char *save
= p1
;
14229 loc_num
= get_number (&p1
);
14231 error (_("Bad breakpoint location number '%s'"), number
);
14235 for (;loc_num
&& loc
; --loc_num
, loc
= loc
->next
)
14238 error (_("Bad breakpoint location number '%s'"), save
);
14244 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14245 If from_tty is nonzero, it prints a message to that effect,
14246 which ends with a period (no newline). */
14249 disable_breakpoint (struct breakpoint
*bpt
)
14251 /* Never disable a watchpoint scope breakpoint; we want to
14252 hit them when we leave scope so we can delete both the
14253 watchpoint and its scope breakpoint at that time. */
14254 if (bpt
->type
== bp_watchpoint_scope
)
14257 bpt
->enable_state
= bp_disabled
;
14259 /* Mark breakpoint locations modified. */
14260 mark_breakpoint_modified (bpt
);
14262 if (target_supports_enable_disable_tracepoint ()
14263 && current_trace_status ()->running
&& is_tracepoint (bpt
))
14265 struct bp_location
*location
;
14267 for (location
= bpt
->loc
; location
; location
= location
->next
)
14268 target_disable_tracepoint (location
);
14271 update_global_location_list (UGLL_DONT_INSERT
);
14273 observer_notify_breakpoint_modified (bpt
);
14277 disable_command (const char *args
, int from_tty
)
14281 struct breakpoint
*bpt
;
14283 ALL_BREAKPOINTS (bpt
)
14284 if (user_breakpoint_p (bpt
))
14285 disable_breakpoint (bpt
);
14289 std::string num
= extract_arg (&args
);
14291 while (!num
.empty ())
14293 if (num
.find ('.') != std::string::npos
)
14295 struct bp_location
*loc
= find_location_by_number (num
.c_str ());
14302 mark_breakpoint_location_modified (loc
);
14304 if (target_supports_enable_disable_tracepoint ()
14305 && current_trace_status ()->running
&& loc
->owner
14306 && is_tracepoint (loc
->owner
))
14307 target_disable_tracepoint (loc
);
14309 update_global_location_list (UGLL_DONT_INSERT
);
14312 map_breakpoint_numbers
14313 (num
.c_str (), [&] (breakpoint
*b
)
14315 iterate_over_related_breakpoints (b
, disable_breakpoint
);
14317 num
= extract_arg (&args
);
14323 enable_breakpoint_disp (struct breakpoint
*bpt
, enum bpdisp disposition
,
14326 int target_resources_ok
;
14328 if (bpt
->type
== bp_hardware_breakpoint
)
14331 i
= hw_breakpoint_used_count ();
14332 target_resources_ok
=
14333 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
14335 if (target_resources_ok
== 0)
14336 error (_("No hardware breakpoint support in the target."));
14337 else if (target_resources_ok
< 0)
14338 error (_("Hardware breakpoints used exceeds limit."));
14341 if (is_watchpoint (bpt
))
14343 /* Initialize it just to avoid a GCC false warning. */
14344 enum enable_state orig_enable_state
= bp_disabled
;
14348 struct watchpoint
*w
= (struct watchpoint
*) bpt
;
14350 orig_enable_state
= bpt
->enable_state
;
14351 bpt
->enable_state
= bp_enabled
;
14352 update_watchpoint (w
, 1 /* reparse */);
14354 CATCH (e
, RETURN_MASK_ALL
)
14356 bpt
->enable_state
= orig_enable_state
;
14357 exception_fprintf (gdb_stderr
, e
, _("Cannot enable watchpoint %d: "),
14364 bpt
->enable_state
= bp_enabled
;
14366 /* Mark breakpoint locations modified. */
14367 mark_breakpoint_modified (bpt
);
14369 if (target_supports_enable_disable_tracepoint ()
14370 && current_trace_status ()->running
&& is_tracepoint (bpt
))
14372 struct bp_location
*location
;
14374 for (location
= bpt
->loc
; location
; location
= location
->next
)
14375 target_enable_tracepoint (location
);
14378 bpt
->disposition
= disposition
;
14379 bpt
->enable_count
= count
;
14380 update_global_location_list (UGLL_MAY_INSERT
);
14382 observer_notify_breakpoint_modified (bpt
);
14387 enable_breakpoint (struct breakpoint
*bpt
)
14389 enable_breakpoint_disp (bpt
, bpt
->disposition
, 0);
14392 /* The enable command enables the specified breakpoints (or all defined
14393 breakpoints) so they once again become (or continue to be) effective
14394 in stopping the inferior. */
14397 enable_command (const char *args
, int from_tty
)
14401 struct breakpoint
*bpt
;
14403 ALL_BREAKPOINTS (bpt
)
14404 if (user_breakpoint_p (bpt
))
14405 enable_breakpoint (bpt
);
14409 std::string num
= extract_arg (&args
);
14411 while (!num
.empty ())
14413 if (num
.find ('.') != std::string::npos
)
14415 struct bp_location
*loc
= find_location_by_number (num
.c_str ());
14422 mark_breakpoint_location_modified (loc
);
14424 if (target_supports_enable_disable_tracepoint ()
14425 && current_trace_status ()->running
&& loc
->owner
14426 && is_tracepoint (loc
->owner
))
14427 target_enable_tracepoint (loc
);
14429 update_global_location_list (UGLL_MAY_INSERT
);
14432 map_breakpoint_numbers
14433 (num
.c_str (), [&] (breakpoint
*b
)
14435 iterate_over_related_breakpoints (b
, enable_breakpoint
);
14437 num
= extract_arg (&args
);
14443 enable_once_command (const char *args
, int from_tty
)
14445 map_breakpoint_numbers
14446 (args
, [&] (breakpoint
*b
)
14448 iterate_over_related_breakpoints
14449 (b
, [&] (breakpoint
*bpt
)
14451 enable_breakpoint_disp (bpt
, disp_disable
, 1);
14457 enable_count_command (const char *args
, int from_tty
)
14462 error_no_arg (_("hit count"));
14464 count
= get_number (&args
);
14466 map_breakpoint_numbers
14467 (args
, [&] (breakpoint
*b
)
14469 iterate_over_related_breakpoints
14470 (b
, [&] (breakpoint
*bpt
)
14472 enable_breakpoint_disp (bpt
, disp_disable
, count
);
14478 enable_delete_command (const char *args
, int from_tty
)
14480 map_breakpoint_numbers
14481 (args
, [&] (breakpoint
*b
)
14483 iterate_over_related_breakpoints
14484 (b
, [&] (breakpoint
*bpt
)
14486 enable_breakpoint_disp (bpt
, disp_del
, 1);
14492 set_breakpoint_cmd (const char *args
, int from_tty
)
14497 show_breakpoint_cmd (const char *args
, int from_tty
)
14501 /* Invalidate last known value of any hardware watchpoint if
14502 the memory which that value represents has been written to by
14506 invalidate_bp_value_on_memory_change (struct inferior
*inferior
,
14507 CORE_ADDR addr
, ssize_t len
,
14508 const bfd_byte
*data
)
14510 struct breakpoint
*bp
;
14512 ALL_BREAKPOINTS (bp
)
14513 if (bp
->enable_state
== bp_enabled
14514 && bp
->type
== bp_hardware_watchpoint
)
14516 struct watchpoint
*wp
= (struct watchpoint
*) bp
;
14518 if (wp
->val_valid
&& wp
->val
)
14520 struct bp_location
*loc
;
14522 for (loc
= bp
->loc
; loc
!= NULL
; loc
= loc
->next
)
14523 if (loc
->loc_type
== bp_loc_hardware_watchpoint
14524 && loc
->address
+ loc
->length
> addr
14525 && addr
+ len
> loc
->address
)
14527 value_free (wp
->val
);
14535 /* Create and insert a breakpoint for software single step. */
14538 insert_single_step_breakpoint (struct gdbarch
*gdbarch
,
14539 struct address_space
*aspace
,
14542 struct thread_info
*tp
= inferior_thread ();
14543 struct symtab_and_line sal
;
14544 CORE_ADDR pc
= next_pc
;
14546 if (tp
->control
.single_step_breakpoints
== NULL
)
14548 tp
->control
.single_step_breakpoints
14549 = new_single_step_breakpoint (tp
->global_num
, gdbarch
);
14552 sal
= find_pc_line (pc
, 0);
14554 sal
.section
= find_pc_overlay (pc
);
14555 sal
.explicit_pc
= 1;
14556 add_location_to_breakpoint (tp
->control
.single_step_breakpoints
, &sal
);
14558 update_global_location_list (UGLL_INSERT
);
14561 /* Insert single step breakpoints according to the current state. */
14564 insert_single_step_breakpoints (struct gdbarch
*gdbarch
)
14566 struct regcache
*regcache
= get_current_regcache ();
14567 std::vector
<CORE_ADDR
> next_pcs
;
14569 next_pcs
= gdbarch_software_single_step (gdbarch
, regcache
);
14571 if (!next_pcs
.empty ())
14573 struct frame_info
*frame
= get_current_frame ();
14574 struct address_space
*aspace
= get_frame_address_space (frame
);
14576 for (CORE_ADDR pc
: next_pcs
)
14577 insert_single_step_breakpoint (gdbarch
, aspace
, pc
);
14585 /* See breakpoint.h. */
14588 breakpoint_has_location_inserted_here (struct breakpoint
*bp
,
14589 struct address_space
*aspace
,
14592 struct bp_location
*loc
;
14594 for (loc
= bp
->loc
; loc
!= NULL
; loc
= loc
->next
)
14596 && breakpoint_location_address_match (loc
, aspace
, pc
))
14602 /* Check whether a software single-step breakpoint is inserted at
14606 single_step_breakpoint_inserted_here_p (struct address_space
*aspace
,
14609 struct breakpoint
*bpt
;
14611 ALL_BREAKPOINTS (bpt
)
14613 if (bpt
->type
== bp_single_step
14614 && breakpoint_has_location_inserted_here (bpt
, aspace
, pc
))
14620 /* Tracepoint-specific operations. */
14622 /* Set tracepoint count to NUM. */
14624 set_tracepoint_count (int num
)
14626 tracepoint_count
= num
;
14627 set_internalvar_integer (lookup_internalvar ("tpnum"), num
);
14631 trace_command (char *arg_in
, int from_tty
)
14633 const char *arg
= arg_in
;
14634 struct breakpoint_ops
*ops
;
14636 event_location_up location
= string_to_event_location (&arg
,
14638 if (location
!= NULL
14639 && event_location_type (location
.get ()) == PROBE_LOCATION
)
14640 ops
= &tracepoint_probe_breakpoint_ops
;
14642 ops
= &tracepoint_breakpoint_ops
;
14644 create_breakpoint (get_current_arch (),
14646 NULL
, 0, arg
, 1 /* parse arg */,
14648 bp_tracepoint
/* type_wanted */,
14649 0 /* Ignore count */,
14650 pending_break_support
,
14654 0 /* internal */, 0);
14658 ftrace_command (char *arg_in
, int from_tty
)
14660 const char *arg
= arg_in
;
14661 event_location_up location
= string_to_event_location (&arg
,
14663 create_breakpoint (get_current_arch (),
14665 NULL
, 0, arg
, 1 /* parse arg */,
14667 bp_fast_tracepoint
/* type_wanted */,
14668 0 /* Ignore count */,
14669 pending_break_support
,
14670 &tracepoint_breakpoint_ops
,
14673 0 /* internal */, 0);
14676 /* strace command implementation. Creates a static tracepoint. */
14679 strace_command (char *arg_in
, int from_tty
)
14681 const char *arg
= arg_in
;
14682 struct breakpoint_ops
*ops
;
14683 event_location_up location
;
14685 /* Decide if we are dealing with a static tracepoint marker (`-m'),
14686 or with a normal static tracepoint. */
14687 if (arg
&& startswith (arg
, "-m") && isspace (arg
[2]))
14689 ops
= &strace_marker_breakpoint_ops
;
14690 location
= new_linespec_location (&arg
);
14694 ops
= &tracepoint_breakpoint_ops
;
14695 location
= string_to_event_location (&arg
, current_language
);
14698 create_breakpoint (get_current_arch (),
14700 NULL
, 0, arg
, 1 /* parse arg */,
14702 bp_static_tracepoint
/* type_wanted */,
14703 0 /* Ignore count */,
14704 pending_break_support
,
14708 0 /* internal */, 0);
14711 /* Set up a fake reader function that gets command lines from a linked
14712 list that was acquired during tracepoint uploading. */
14714 static struct uploaded_tp
*this_utp
;
14715 static int next_cmd
;
14718 read_uploaded_action (void)
14722 VEC_iterate (char_ptr
, this_utp
->cmd_strings
, next_cmd
, rslt
);
14729 /* Given information about a tracepoint as recorded on a target (which
14730 can be either a live system or a trace file), attempt to create an
14731 equivalent GDB tracepoint. This is not a reliable process, since
14732 the target does not necessarily have all the information used when
14733 the tracepoint was originally defined. */
14735 struct tracepoint
*
14736 create_tracepoint_from_upload (struct uploaded_tp
*utp
)
14738 const char *addr_str
;
14739 char small_buf
[100];
14740 struct tracepoint
*tp
;
14742 if (utp
->at_string
)
14743 addr_str
= utp
->at_string
;
14746 /* In the absence of a source location, fall back to raw
14747 address. Since there is no way to confirm that the address
14748 means the same thing as when the trace was started, warn the
14750 warning (_("Uploaded tracepoint %d has no "
14751 "source location, using raw address"),
14753 xsnprintf (small_buf
, sizeof (small_buf
), "*%s", hex_string (utp
->addr
));
14754 addr_str
= small_buf
;
14757 /* There's not much we can do with a sequence of bytecodes. */
14758 if (utp
->cond
&& !utp
->cond_string
)
14759 warning (_("Uploaded tracepoint %d condition "
14760 "has no source form, ignoring it"),
14763 event_location_up location
= string_to_event_location (&addr_str
,
14765 if (!create_breakpoint (get_current_arch (),
14767 utp
->cond_string
, -1, addr_str
,
14768 0 /* parse cond/thread */,
14770 utp
->type
/* type_wanted */,
14771 0 /* Ignore count */,
14772 pending_break_support
,
14773 &tracepoint_breakpoint_ops
,
14775 utp
->enabled
/* enabled */,
14777 CREATE_BREAKPOINT_FLAGS_INSERTED
))
14780 /* Get the tracepoint we just created. */
14781 tp
= get_tracepoint (tracepoint_count
);
14782 gdb_assert (tp
!= NULL
);
14786 xsnprintf (small_buf
, sizeof (small_buf
), "%d %d", utp
->pass
,
14789 trace_pass_command (small_buf
, 0);
14792 /* If we have uploaded versions of the original commands, set up a
14793 special-purpose "reader" function and call the usual command line
14794 reader, then pass the result to the breakpoint command-setting
14796 if (!VEC_empty (char_ptr
, utp
->cmd_strings
))
14798 command_line_up cmd_list
;
14803 cmd_list
= read_command_lines_1 (read_uploaded_action
, 1, NULL
, NULL
);
14805 breakpoint_set_commands (tp
, std::move (cmd_list
));
14807 else if (!VEC_empty (char_ptr
, utp
->actions
)
14808 || !VEC_empty (char_ptr
, utp
->step_actions
))
14809 warning (_("Uploaded tracepoint %d actions "
14810 "have no source form, ignoring them"),
14813 /* Copy any status information that might be available. */
14814 tp
->hit_count
= utp
->hit_count
;
14815 tp
->traceframe_usage
= utp
->traceframe_usage
;
14820 /* Print information on tracepoint number TPNUM_EXP, or all if
14824 info_tracepoints_command (char *args
, int from_tty
)
14826 struct ui_out
*uiout
= current_uiout
;
14829 num_printed
= breakpoint_1 (args
, 0, is_tracepoint
);
14831 if (num_printed
== 0)
14833 if (args
== NULL
|| *args
== '\0')
14834 uiout
->message ("No tracepoints.\n");
14836 uiout
->message ("No tracepoint matching '%s'.\n", args
);
14839 default_collect_info ();
14842 /* The 'enable trace' command enables tracepoints.
14843 Not supported by all targets. */
14845 enable_trace_command (char *args
, int from_tty
)
14847 enable_command (args
, from_tty
);
14850 /* The 'disable trace' command disables tracepoints.
14851 Not supported by all targets. */
14853 disable_trace_command (char *args
, int from_tty
)
14855 disable_command (args
, from_tty
);
14858 /* Remove a tracepoint (or all if no argument). */
14860 delete_trace_command (const char *arg
, int from_tty
)
14862 struct breakpoint
*b
, *b_tmp
;
14868 int breaks_to_delete
= 0;
14870 /* Delete all breakpoints if no argument.
14871 Do not delete internal or call-dummy breakpoints, these
14872 have to be deleted with an explicit breakpoint number
14874 ALL_TRACEPOINTS (b
)
14875 if (is_tracepoint (b
) && user_breakpoint_p (b
))
14877 breaks_to_delete
= 1;
14881 /* Ask user only if there are some breakpoints to delete. */
14883 || (breaks_to_delete
&& query (_("Delete all tracepoints? "))))
14885 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
14886 if (is_tracepoint (b
) && user_breakpoint_p (b
))
14887 delete_breakpoint (b
);
14891 map_breakpoint_numbers
14892 (arg
, [&] (breakpoint
*b
)
14894 iterate_over_related_breakpoints (b
, delete_breakpoint
);
14898 /* Helper function for trace_pass_command. */
14901 trace_pass_set_count (struct tracepoint
*tp
, int count
, int from_tty
)
14903 tp
->pass_count
= count
;
14904 observer_notify_breakpoint_modified (tp
);
14906 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
14907 tp
->number
, count
);
14910 /* Set passcount for tracepoint.
14912 First command argument is passcount, second is tracepoint number.
14913 If tracepoint number omitted, apply to most recently defined.
14914 Also accepts special argument "all". */
14917 trace_pass_command (char *args
, int from_tty
)
14919 struct tracepoint
*t1
;
14920 unsigned int count
;
14922 if (args
== 0 || *args
== 0)
14923 error (_("passcount command requires an "
14924 "argument (count + optional TP num)"));
14926 count
= strtoul (args
, &args
, 10); /* Count comes first, then TP num. */
14928 args
= skip_spaces (args
);
14929 if (*args
&& strncasecmp (args
, "all", 3) == 0)
14931 struct breakpoint
*b
;
14933 args
+= 3; /* Skip special argument "all". */
14935 error (_("Junk at end of arguments."));
14937 ALL_TRACEPOINTS (b
)
14939 t1
= (struct tracepoint
*) b
;
14940 trace_pass_set_count (t1
, count
, from_tty
);
14943 else if (*args
== '\0')
14945 t1
= get_tracepoint_by_number (&args
, NULL
);
14947 trace_pass_set_count (t1
, count
, from_tty
);
14951 number_or_range_parser
parser (args
);
14952 while (!parser
.finished ())
14954 t1
= get_tracepoint_by_number (&args
, &parser
);
14956 trace_pass_set_count (t1
, count
, from_tty
);
14961 struct tracepoint
*
14962 get_tracepoint (int num
)
14964 struct breakpoint
*t
;
14966 ALL_TRACEPOINTS (t
)
14967 if (t
->number
== num
)
14968 return (struct tracepoint
*) t
;
14973 /* Find the tracepoint with the given target-side number (which may be
14974 different from the tracepoint number after disconnecting and
14977 struct tracepoint
*
14978 get_tracepoint_by_number_on_target (int num
)
14980 struct breakpoint
*b
;
14982 ALL_TRACEPOINTS (b
)
14984 struct tracepoint
*t
= (struct tracepoint
*) b
;
14986 if (t
->number_on_target
== num
)
14993 /* Utility: parse a tracepoint number and look it up in the list.
14994 If STATE is not NULL, use, get_number_or_range_state and ignore ARG.
14995 If the argument is missing, the most recent tracepoint
14996 (tracepoint_count) is returned. */
14998 struct tracepoint
*
14999 get_tracepoint_by_number (char **arg
,
15000 number_or_range_parser
*parser
)
15002 struct breakpoint
*t
;
15004 char *instring
= arg
== NULL
? NULL
: *arg
;
15006 if (parser
!= NULL
)
15008 gdb_assert (!parser
->finished ());
15009 tpnum
= parser
->get_number ();
15011 else if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
15012 tpnum
= tracepoint_count
;
15014 tpnum
= get_number (arg
);
15018 if (instring
&& *instring
)
15019 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
15022 printf_filtered (_("No previous tracepoint\n"));
15026 ALL_TRACEPOINTS (t
)
15027 if (t
->number
== tpnum
)
15029 return (struct tracepoint
*) t
;
15032 printf_unfiltered ("No tracepoint number %d.\n", tpnum
);
15037 print_recreate_thread (struct breakpoint
*b
, struct ui_file
*fp
)
15039 if (b
->thread
!= -1)
15040 fprintf_unfiltered (fp
, " thread %d", b
->thread
);
15043 fprintf_unfiltered (fp
, " task %d", b
->task
);
15045 fprintf_unfiltered (fp
, "\n");
15048 /* Save information on user settable breakpoints (watchpoints, etc) to
15049 a new script file named FILENAME. If FILTER is non-NULL, call it
15050 on each breakpoint and only include the ones for which it returns
15054 save_breakpoints (const char *filename
, int from_tty
,
15055 int (*filter
) (const struct breakpoint
*))
15057 struct breakpoint
*tp
;
15059 int extra_trace_bits
= 0;
15061 if (filename
== 0 || *filename
== 0)
15062 error (_("Argument required (file name in which to save)"));
15064 /* See if we have anything to save. */
15065 ALL_BREAKPOINTS (tp
)
15067 /* Skip internal and momentary breakpoints. */
15068 if (!user_breakpoint_p (tp
))
15071 /* If we have a filter, only save the breakpoints it accepts. */
15072 if (filter
&& !filter (tp
))
15077 if (is_tracepoint (tp
))
15079 extra_trace_bits
= 1;
15081 /* We can stop searching. */
15088 warning (_("Nothing to save."));
15092 gdb::unique_xmalloc_ptr
<char> expanded_filename (tilde_expand (filename
));
15096 if (!fp
.open (expanded_filename
.get (), "w"))
15097 error (_("Unable to open file '%s' for saving (%s)"),
15098 expanded_filename
.get (), safe_strerror (errno
));
15100 if (extra_trace_bits
)
15101 save_trace_state_variables (&fp
);
15103 ALL_BREAKPOINTS (tp
)
15105 /* Skip internal and momentary breakpoints. */
15106 if (!user_breakpoint_p (tp
))
15109 /* If we have a filter, only save the breakpoints it accepts. */
15110 if (filter
&& !filter (tp
))
15113 tp
->ops
->print_recreate (tp
, &fp
);
15115 /* Note, we can't rely on tp->number for anything, as we can't
15116 assume the recreated breakpoint numbers will match. Use $bpnum
15119 if (tp
->cond_string
)
15120 fp
.printf (" condition $bpnum %s\n", tp
->cond_string
);
15122 if (tp
->ignore_count
)
15123 fp
.printf (" ignore $bpnum %d\n", tp
->ignore_count
);
15125 if (tp
->type
!= bp_dprintf
&& tp
->commands
)
15127 fp
.puts (" commands\n");
15129 current_uiout
->redirect (&fp
);
15132 print_command_lines (current_uiout
, tp
->commands
.get (), 2);
15134 CATCH (ex
, RETURN_MASK_ALL
)
15136 current_uiout
->redirect (NULL
);
15137 throw_exception (ex
);
15141 current_uiout
->redirect (NULL
);
15142 fp
.puts (" end\n");
15145 if (tp
->enable_state
== bp_disabled
)
15146 fp
.puts ("disable $bpnum\n");
15148 /* If this is a multi-location breakpoint, check if the locations
15149 should be individually disabled. Watchpoint locations are
15150 special, and not user visible. */
15151 if (!is_watchpoint (tp
) && tp
->loc
&& tp
->loc
->next
)
15153 struct bp_location
*loc
;
15156 for (loc
= tp
->loc
; loc
!= NULL
; loc
= loc
->next
, n
++)
15158 fp
.printf ("disable $bpnum.%d\n", n
);
15162 if (extra_trace_bits
&& *default_collect
)
15163 fp
.printf ("set default-collect %s\n", default_collect
);
15166 printf_filtered (_("Saved to file '%s'.\n"), expanded_filename
.get ());
15169 /* The `save breakpoints' command. */
15172 save_breakpoints_command (const char *args
, int from_tty
)
15174 save_breakpoints (args
, from_tty
, NULL
);
15177 /* The `save tracepoints' command. */
15180 save_tracepoints_command (const char *args
, int from_tty
)
15182 save_breakpoints (args
, from_tty
, is_tracepoint
);
15185 /* Create a vector of all tracepoints. */
15187 VEC(breakpoint_p
) *
15188 all_tracepoints (void)
15190 VEC(breakpoint_p
) *tp_vec
= 0;
15191 struct breakpoint
*tp
;
15193 ALL_TRACEPOINTS (tp
)
15195 VEC_safe_push (breakpoint_p
, tp_vec
, tp
);
15202 /* This help string is used to consolidate all the help string for specifying
15203 locations used by several commands. */
15205 #define LOCATION_HELP_STRING \
15206 "Linespecs are colon-separated lists of location parameters, such as\n\
15207 source filename, function name, label name, and line number.\n\
15208 Example: To specify the start of a label named \"the_top\" in the\n\
15209 function \"fact\" in the file \"factorial.c\", use\n\
15210 \"factorial.c:fact:the_top\".\n\
15212 Address locations begin with \"*\" and specify an exact address in the\n\
15213 program. Example: To specify the fourth byte past the start function\n\
15214 \"main\", use \"*main + 4\".\n\
15216 Explicit locations are similar to linespecs but use an option/argument\n\
15217 syntax to specify location parameters.\n\
15218 Example: To specify the start of the label named \"the_top\" in the\n\
15219 function \"fact\" in the file \"factorial.c\", use \"-source factorial.c\n\
15220 -function fact -label the_top\".\n"
15222 /* This help string is used for the break, hbreak, tbreak and thbreak
15223 commands. It is defined as a macro to prevent duplication.
15224 COMMAND should be a string constant containing the name of the
15227 #define BREAK_ARGS_HELP(command) \
15228 command" [PROBE_MODIFIER] [LOCATION] [thread THREADNUM] [if CONDITION]\n\
15229 PROBE_MODIFIER shall be present if the command is to be placed in a\n\
15230 probe point. Accepted values are `-probe' (for a generic, automatically\n\
15231 guessed probe type), `-probe-stap' (for a SystemTap probe) or \n\
15232 `-probe-dtrace' (for a DTrace probe).\n\
15233 LOCATION may be a linespec, address, or explicit location as described\n\
15236 With no LOCATION, uses current execution address of the selected\n\
15237 stack frame. This is useful for breaking on return to a stack frame.\n\
15239 THREADNUM is the number from \"info threads\".\n\
15240 CONDITION is a boolean expression.\n\
15241 \n" LOCATION_HELP_STRING "\n\
15242 Multiple breakpoints at one place are permitted, and useful if their\n\
15243 conditions are different.\n\
15245 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
15247 /* List of subcommands for "catch". */
15248 static struct cmd_list_element
*catch_cmdlist
;
15250 /* List of subcommands for "tcatch". */
15251 static struct cmd_list_element
*tcatch_cmdlist
;
15254 add_catch_command (const char *name
, const char *docstring
,
15255 cmd_sfunc_ftype
*sfunc
,
15256 completer_ftype
*completer
,
15257 void *user_data_catch
,
15258 void *user_data_tcatch
)
15260 struct cmd_list_element
*command
;
15262 command
= add_cmd (name
, class_breakpoint
, docstring
,
15264 set_cmd_sfunc (command
, sfunc
);
15265 set_cmd_context (command
, user_data_catch
);
15266 set_cmd_completer (command
, completer
);
15268 command
= add_cmd (name
, class_breakpoint
, docstring
,
15270 set_cmd_sfunc (command
, sfunc
);
15271 set_cmd_context (command
, user_data_tcatch
);
15272 set_cmd_completer (command
, completer
);
15276 save_command (const char *arg
, int from_tty
)
15278 printf_unfiltered (_("\"save\" must be followed by "
15279 "the name of a save subcommand.\n"));
15280 help_list (save_cmdlist
, "save ", all_commands
, gdb_stdout
);
15283 struct breakpoint
*
15284 iterate_over_breakpoints (int (*callback
) (struct breakpoint
*, void *),
15287 struct breakpoint
*b
, *b_tmp
;
15289 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
15291 if ((*callback
) (b
, data
))
15298 /* Zero if any of the breakpoint's locations could be a location where
15299 functions have been inlined, nonzero otherwise. */
15302 is_non_inline_function (struct breakpoint
*b
)
15304 /* The shared library event breakpoint is set on the address of a
15305 non-inline function. */
15306 if (b
->type
== bp_shlib_event
)
15312 /* Nonzero if the specified PC cannot be a location where functions
15313 have been inlined. */
15316 pc_at_non_inline_function (struct address_space
*aspace
, CORE_ADDR pc
,
15317 const struct target_waitstatus
*ws
)
15319 struct breakpoint
*b
;
15320 struct bp_location
*bl
;
15322 ALL_BREAKPOINTS (b
)
15324 if (!is_non_inline_function (b
))
15327 for (bl
= b
->loc
; bl
!= NULL
; bl
= bl
->next
)
15329 if (!bl
->shlib_disabled
15330 && bpstat_check_location (bl
, aspace
, pc
, ws
))
15338 /* Remove any references to OBJFILE which is going to be freed. */
15341 breakpoint_free_objfile (struct objfile
*objfile
)
15343 struct bp_location
**locp
, *loc
;
15345 ALL_BP_LOCATIONS (loc
, locp
)
15346 if (loc
->symtab
!= NULL
&& SYMTAB_OBJFILE (loc
->symtab
) == objfile
)
15347 loc
->symtab
= NULL
;
15351 initialize_breakpoint_ops (void)
15353 static int initialized
= 0;
15355 struct breakpoint_ops
*ops
;
15361 /* The breakpoint_ops structure to be inherit by all kinds of
15362 breakpoints (real breakpoints, i.e., user "break" breakpoints,
15363 internal and momentary breakpoints, etc.). */
15364 ops
= &bkpt_base_breakpoint_ops
;
15365 *ops
= base_breakpoint_ops
;
15366 ops
->re_set
= bkpt_re_set
;
15367 ops
->insert_location
= bkpt_insert_location
;
15368 ops
->remove_location
= bkpt_remove_location
;
15369 ops
->breakpoint_hit
= bkpt_breakpoint_hit
;
15370 ops
->create_sals_from_location
= bkpt_create_sals_from_location
;
15371 ops
->create_breakpoints_sal
= bkpt_create_breakpoints_sal
;
15372 ops
->decode_location
= bkpt_decode_location
;
15374 /* The breakpoint_ops structure to be used in regular breakpoints. */
15375 ops
= &bkpt_breakpoint_ops
;
15376 *ops
= bkpt_base_breakpoint_ops
;
15377 ops
->re_set
= bkpt_re_set
;
15378 ops
->resources_needed
= bkpt_resources_needed
;
15379 ops
->print_it
= bkpt_print_it
;
15380 ops
->print_mention
= bkpt_print_mention
;
15381 ops
->print_recreate
= bkpt_print_recreate
;
15383 /* Ranged breakpoints. */
15384 ops
= &ranged_breakpoint_ops
;
15385 *ops
= bkpt_breakpoint_ops
;
15386 ops
->breakpoint_hit
= breakpoint_hit_ranged_breakpoint
;
15387 ops
->resources_needed
= resources_needed_ranged_breakpoint
;
15388 ops
->print_it
= print_it_ranged_breakpoint
;
15389 ops
->print_one
= print_one_ranged_breakpoint
;
15390 ops
->print_one_detail
= print_one_detail_ranged_breakpoint
;
15391 ops
->print_mention
= print_mention_ranged_breakpoint
;
15392 ops
->print_recreate
= print_recreate_ranged_breakpoint
;
15394 /* Internal breakpoints. */
15395 ops
= &internal_breakpoint_ops
;
15396 *ops
= bkpt_base_breakpoint_ops
;
15397 ops
->re_set
= internal_bkpt_re_set
;
15398 ops
->check_status
= internal_bkpt_check_status
;
15399 ops
->print_it
= internal_bkpt_print_it
;
15400 ops
->print_mention
= internal_bkpt_print_mention
;
15402 /* Momentary breakpoints. */
15403 ops
= &momentary_breakpoint_ops
;
15404 *ops
= bkpt_base_breakpoint_ops
;
15405 ops
->re_set
= momentary_bkpt_re_set
;
15406 ops
->check_status
= momentary_bkpt_check_status
;
15407 ops
->print_it
= momentary_bkpt_print_it
;
15408 ops
->print_mention
= momentary_bkpt_print_mention
;
15410 /* Probe breakpoints. */
15411 ops
= &bkpt_probe_breakpoint_ops
;
15412 *ops
= bkpt_breakpoint_ops
;
15413 ops
->insert_location
= bkpt_probe_insert_location
;
15414 ops
->remove_location
= bkpt_probe_remove_location
;
15415 ops
->create_sals_from_location
= bkpt_probe_create_sals_from_location
;
15416 ops
->decode_location
= bkpt_probe_decode_location
;
15419 ops
= &watchpoint_breakpoint_ops
;
15420 *ops
= base_breakpoint_ops
;
15421 ops
->re_set
= re_set_watchpoint
;
15422 ops
->insert_location
= insert_watchpoint
;
15423 ops
->remove_location
= remove_watchpoint
;
15424 ops
->breakpoint_hit
= breakpoint_hit_watchpoint
;
15425 ops
->check_status
= check_status_watchpoint
;
15426 ops
->resources_needed
= resources_needed_watchpoint
;
15427 ops
->works_in_software_mode
= works_in_software_mode_watchpoint
;
15428 ops
->print_it
= print_it_watchpoint
;
15429 ops
->print_mention
= print_mention_watchpoint
;
15430 ops
->print_recreate
= print_recreate_watchpoint
;
15431 ops
->explains_signal
= explains_signal_watchpoint
;
15433 /* Masked watchpoints. */
15434 ops
= &masked_watchpoint_breakpoint_ops
;
15435 *ops
= watchpoint_breakpoint_ops
;
15436 ops
->insert_location
= insert_masked_watchpoint
;
15437 ops
->remove_location
= remove_masked_watchpoint
;
15438 ops
->resources_needed
= resources_needed_masked_watchpoint
;
15439 ops
->works_in_software_mode
= works_in_software_mode_masked_watchpoint
;
15440 ops
->print_it
= print_it_masked_watchpoint
;
15441 ops
->print_one_detail
= print_one_detail_masked_watchpoint
;
15442 ops
->print_mention
= print_mention_masked_watchpoint
;
15443 ops
->print_recreate
= print_recreate_masked_watchpoint
;
15446 ops
= &tracepoint_breakpoint_ops
;
15447 *ops
= base_breakpoint_ops
;
15448 ops
->re_set
= tracepoint_re_set
;
15449 ops
->breakpoint_hit
= tracepoint_breakpoint_hit
;
15450 ops
->print_one_detail
= tracepoint_print_one_detail
;
15451 ops
->print_mention
= tracepoint_print_mention
;
15452 ops
->print_recreate
= tracepoint_print_recreate
;
15453 ops
->create_sals_from_location
= tracepoint_create_sals_from_location
;
15454 ops
->create_breakpoints_sal
= tracepoint_create_breakpoints_sal
;
15455 ops
->decode_location
= tracepoint_decode_location
;
15457 /* Probe tracepoints. */
15458 ops
= &tracepoint_probe_breakpoint_ops
;
15459 *ops
= tracepoint_breakpoint_ops
;
15460 ops
->create_sals_from_location
= tracepoint_probe_create_sals_from_location
;
15461 ops
->decode_location
= tracepoint_probe_decode_location
;
15463 /* Static tracepoints with marker (`-m'). */
15464 ops
= &strace_marker_breakpoint_ops
;
15465 *ops
= tracepoint_breakpoint_ops
;
15466 ops
->create_sals_from_location
= strace_marker_create_sals_from_location
;
15467 ops
->create_breakpoints_sal
= strace_marker_create_breakpoints_sal
;
15468 ops
->decode_location
= strace_marker_decode_location
;
15470 /* Fork catchpoints. */
15471 ops
= &catch_fork_breakpoint_ops
;
15472 *ops
= base_breakpoint_ops
;
15473 ops
->insert_location
= insert_catch_fork
;
15474 ops
->remove_location
= remove_catch_fork
;
15475 ops
->breakpoint_hit
= breakpoint_hit_catch_fork
;
15476 ops
->print_it
= print_it_catch_fork
;
15477 ops
->print_one
= print_one_catch_fork
;
15478 ops
->print_mention
= print_mention_catch_fork
;
15479 ops
->print_recreate
= print_recreate_catch_fork
;
15481 /* Vfork catchpoints. */
15482 ops
= &catch_vfork_breakpoint_ops
;
15483 *ops
= base_breakpoint_ops
;
15484 ops
->insert_location
= insert_catch_vfork
;
15485 ops
->remove_location
= remove_catch_vfork
;
15486 ops
->breakpoint_hit
= breakpoint_hit_catch_vfork
;
15487 ops
->print_it
= print_it_catch_vfork
;
15488 ops
->print_one
= print_one_catch_vfork
;
15489 ops
->print_mention
= print_mention_catch_vfork
;
15490 ops
->print_recreate
= print_recreate_catch_vfork
;
15492 /* Exec catchpoints. */
15493 ops
= &catch_exec_breakpoint_ops
;
15494 *ops
= base_breakpoint_ops
;
15495 ops
->insert_location
= insert_catch_exec
;
15496 ops
->remove_location
= remove_catch_exec
;
15497 ops
->breakpoint_hit
= breakpoint_hit_catch_exec
;
15498 ops
->print_it
= print_it_catch_exec
;
15499 ops
->print_one
= print_one_catch_exec
;
15500 ops
->print_mention
= print_mention_catch_exec
;
15501 ops
->print_recreate
= print_recreate_catch_exec
;
15503 /* Solib-related catchpoints. */
15504 ops
= &catch_solib_breakpoint_ops
;
15505 *ops
= base_breakpoint_ops
;
15506 ops
->insert_location
= insert_catch_solib
;
15507 ops
->remove_location
= remove_catch_solib
;
15508 ops
->breakpoint_hit
= breakpoint_hit_catch_solib
;
15509 ops
->check_status
= check_status_catch_solib
;
15510 ops
->print_it
= print_it_catch_solib
;
15511 ops
->print_one
= print_one_catch_solib
;
15512 ops
->print_mention
= print_mention_catch_solib
;
15513 ops
->print_recreate
= print_recreate_catch_solib
;
15515 ops
= &dprintf_breakpoint_ops
;
15516 *ops
= bkpt_base_breakpoint_ops
;
15517 ops
->re_set
= dprintf_re_set
;
15518 ops
->resources_needed
= bkpt_resources_needed
;
15519 ops
->print_it
= bkpt_print_it
;
15520 ops
->print_mention
= bkpt_print_mention
;
15521 ops
->print_recreate
= dprintf_print_recreate
;
15522 ops
->after_condition_true
= dprintf_after_condition_true
;
15523 ops
->breakpoint_hit
= dprintf_breakpoint_hit
;
15526 /* Chain containing all defined "enable breakpoint" subcommands. */
15528 static struct cmd_list_element
*enablebreaklist
= NULL
;
15531 _initialize_breakpoint (void)
15533 struct cmd_list_element
*c
;
15535 initialize_breakpoint_ops ();
15537 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
15538 observer_attach_free_objfile (disable_breakpoints_in_freed_objfile
);
15539 observer_attach_memory_changed (invalidate_bp_value_on_memory_change
);
15541 breakpoint_objfile_key
15542 = register_objfile_data_with_cleanup (NULL
, free_breakpoint_probes
);
15544 breakpoint_chain
= 0;
15545 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
15546 before a breakpoint is set. */
15547 breakpoint_count
= 0;
15549 tracepoint_count
= 0;
15551 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
15552 Set ignore-count of breakpoint number N to COUNT.\n\
15553 Usage is `ignore N COUNT'."));
15555 add_com ("commands", class_breakpoint
, commands_command
, _("\
15556 Set commands to be executed when the given breakpoints are hit.\n\
15557 Give a space-separated breakpoint list as argument after \"commands\".\n\
15558 A list element can be a breakpoint number (e.g. `5') or a range of numbers\n\
15560 With no argument, the targeted breakpoint is the last one set.\n\
15561 The commands themselves follow starting on the next line.\n\
15562 Type a line containing \"end\" to indicate the end of them.\n\
15563 Give \"silent\" as the first line to make the breakpoint silent;\n\
15564 then no output is printed when it is hit, except what the commands print."));
15566 c
= add_com ("condition", class_breakpoint
, condition_command
, _("\
15567 Specify breakpoint number N to break only if COND is true.\n\
15568 Usage is `condition N COND', where N is an integer and COND is an\n\
15569 expression to be evaluated whenever breakpoint N is reached."));
15570 set_cmd_completer (c
, condition_completer
);
15572 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
15573 Set a temporary breakpoint.\n\
15574 Like \"break\" except the breakpoint is only temporary,\n\
15575 so it will be deleted when hit. Equivalent to \"break\" followed\n\
15576 by using \"enable delete\" on the breakpoint number.\n\
15578 BREAK_ARGS_HELP ("tbreak")));
15579 set_cmd_completer (c
, location_completer
);
15581 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
15582 Set a hardware assisted breakpoint.\n\
15583 Like \"break\" except the breakpoint requires hardware support,\n\
15584 some target hardware may not have this support.\n\
15586 BREAK_ARGS_HELP ("hbreak")));
15587 set_cmd_completer (c
, location_completer
);
15589 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
15590 Set a temporary hardware assisted breakpoint.\n\
15591 Like \"hbreak\" except the breakpoint is only temporary,\n\
15592 so it will be deleted when hit.\n\
15594 BREAK_ARGS_HELP ("thbreak")));
15595 set_cmd_completer (c
, location_completer
);
15597 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
15598 Enable some breakpoints.\n\
15599 Give breakpoint numbers (separated by spaces) as arguments.\n\
15600 With no subcommand, breakpoints are enabled until you command otherwise.\n\
15601 This is used to cancel the effect of the \"disable\" command.\n\
15602 With a subcommand you can enable temporarily."),
15603 &enablelist
, "enable ", 1, &cmdlist
);
15605 add_com_alias ("en", "enable", class_breakpoint
, 1);
15607 add_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
15608 Enable some breakpoints.\n\
15609 Give breakpoint numbers (separated by spaces) as arguments.\n\
15610 This is used to cancel the effect of the \"disable\" command.\n\
15611 May be abbreviated to simply \"enable\".\n"),
15612 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
15614 add_cmd ("once", no_class
, enable_once_command
, _("\
15615 Enable breakpoints for one hit. Give breakpoint numbers.\n\
15616 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
15619 add_cmd ("delete", no_class
, enable_delete_command
, _("\
15620 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
15621 If a breakpoint is hit while enabled in this fashion, it is deleted."),
15624 add_cmd ("count", no_class
, enable_count_command
, _("\
15625 Enable breakpoints for COUNT hits. Give count and then breakpoint numbers.\n\
15626 If a breakpoint is hit while enabled in this fashion,\n\
15627 the count is decremented; when it reaches zero, the breakpoint is disabled."),
15630 add_cmd ("delete", no_class
, enable_delete_command
, _("\
15631 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
15632 If a breakpoint is hit while enabled in this fashion, it is deleted."),
15635 add_cmd ("once", no_class
, enable_once_command
, _("\
15636 Enable breakpoints for one hit. Give breakpoint numbers.\n\
15637 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
15640 add_cmd ("count", no_class
, enable_count_command
, _("\
15641 Enable breakpoints for COUNT hits. Give count and then breakpoint numbers.\n\
15642 If a breakpoint is hit while enabled in this fashion,\n\
15643 the count is decremented; when it reaches zero, the breakpoint is disabled."),
15646 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
15647 Disable some breakpoints.\n\
15648 Arguments are breakpoint numbers with spaces in between.\n\
15649 To disable all breakpoints, give no argument.\n\
15650 A disabled breakpoint is not forgotten, but has no effect until re-enabled."),
15651 &disablelist
, "disable ", 1, &cmdlist
);
15652 add_com_alias ("dis", "disable", class_breakpoint
, 1);
15653 add_com_alias ("disa", "disable", class_breakpoint
, 1);
15655 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
15656 Disable some breakpoints.\n\
15657 Arguments are breakpoint numbers with spaces in between.\n\
15658 To disable all breakpoints, give no argument.\n\
15659 A disabled breakpoint is not forgotten, but has no effect until re-enabled.\n\
15660 This command may be abbreviated \"disable\"."),
15663 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
15664 Delete some breakpoints or auto-display expressions.\n\
15665 Arguments are breakpoint numbers with spaces in between.\n\
15666 To delete all breakpoints, give no argument.\n\
15668 Also a prefix command for deletion of other GDB objects.\n\
15669 The \"unset\" command is also an alias for \"delete\"."),
15670 &deletelist
, "delete ", 1, &cmdlist
);
15671 add_com_alias ("d", "delete", class_breakpoint
, 1);
15672 add_com_alias ("del", "delete", class_breakpoint
, 1);
15674 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
15675 Delete some breakpoints or auto-display expressions.\n\
15676 Arguments are breakpoint numbers with spaces in between.\n\
15677 To delete all breakpoints, give no argument.\n\
15678 This command may be abbreviated \"delete\"."),
15681 add_com ("clear", class_breakpoint
, clear_command
, _("\
15682 Clear breakpoint at specified location.\n\
15683 Argument may be a linespec, explicit, or address location as described below.\n\
15685 With no argument, clears all breakpoints in the line that the selected frame\n\
15686 is executing in.\n"
15687 "\n" LOCATION_HELP_STRING
"\n\
15688 See also the \"delete\" command which clears breakpoints by number."));
15689 add_com_alias ("cl", "clear", class_breakpoint
, 1);
15691 c
= add_com ("break", class_breakpoint
, break_command
, _("\
15692 Set breakpoint at specified location.\n"
15693 BREAK_ARGS_HELP ("break")));
15694 set_cmd_completer (c
, location_completer
);
15696 add_com_alias ("b", "break", class_run
, 1);
15697 add_com_alias ("br", "break", class_run
, 1);
15698 add_com_alias ("bre", "break", class_run
, 1);
15699 add_com_alias ("brea", "break", class_run
, 1);
15703 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
15704 Break in function/address or break at a line in the current file."),
15705 &stoplist
, "stop ", 1, &cmdlist
);
15706 add_cmd ("in", class_breakpoint
, stopin_command
,
15707 _("Break in function or address."), &stoplist
);
15708 add_cmd ("at", class_breakpoint
, stopat_command
,
15709 _("Break at a line in the current file."), &stoplist
);
15710 add_com ("status", class_info
, info_breakpoints_command
, _("\
15711 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
15712 The \"Type\" column indicates one of:\n\
15713 \tbreakpoint - normal breakpoint\n\
15714 \twatchpoint - watchpoint\n\
15715 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15716 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
15717 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
15718 address and file/line number respectively.\n\
15720 Convenience variable \"$_\" and default examine address for \"x\"\n\
15721 are set to the address of the last breakpoint listed unless the command\n\
15722 is prefixed with \"server \".\n\n\
15723 Convenience variable \"$bpnum\" contains the number of the last\n\
15724 breakpoint set."));
15727 add_info ("breakpoints", info_breakpoints_command
, _("\
15728 Status of specified breakpoints (all user-settable breakpoints if no argument).\n\
15729 The \"Type\" column indicates one of:\n\
15730 \tbreakpoint - normal breakpoint\n\
15731 \twatchpoint - watchpoint\n\
15732 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15733 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
15734 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
15735 address and file/line number respectively.\n\
15737 Convenience variable \"$_\" and default examine address for \"x\"\n\
15738 are set to the address of the last breakpoint listed unless the command\n\
15739 is prefixed with \"server \".\n\n\
15740 Convenience variable \"$bpnum\" contains the number of the last\n\
15741 breakpoint set."));
15743 add_info_alias ("b", "breakpoints", 1);
15745 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
15746 Status of all breakpoints, or breakpoint number NUMBER.\n\
15747 The \"Type\" column indicates one of:\n\
15748 \tbreakpoint - normal breakpoint\n\
15749 \twatchpoint - watchpoint\n\
15750 \tlongjmp - internal breakpoint used to step through longjmp()\n\
15751 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
15752 \tuntil - internal breakpoint used by the \"until\" command\n\
15753 \tfinish - internal breakpoint used by the \"finish\" command\n\
15754 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15755 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
15756 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
15757 address and file/line number respectively.\n\
15759 Convenience variable \"$_\" and default examine address for \"x\"\n\
15760 are set to the address of the last breakpoint listed unless the command\n\
15761 is prefixed with \"server \".\n\n\
15762 Convenience variable \"$bpnum\" contains the number of the last\n\
15764 &maintenanceinfolist
);
15766 add_prefix_cmd ("catch", class_breakpoint
, catch_command
, _("\
15767 Set catchpoints to catch events."),
15768 &catch_cmdlist
, "catch ",
15769 0/*allow-unknown*/, &cmdlist
);
15771 add_prefix_cmd ("tcatch", class_breakpoint
, tcatch_command
, _("\
15772 Set temporary catchpoints to catch events."),
15773 &tcatch_cmdlist
, "tcatch ",
15774 0/*allow-unknown*/, &cmdlist
);
15776 add_catch_command ("fork", _("Catch calls to fork."),
15777 catch_fork_command_1
,
15779 (void *) (uintptr_t) catch_fork_permanent
,
15780 (void *) (uintptr_t) catch_fork_temporary
);
15781 add_catch_command ("vfork", _("Catch calls to vfork."),
15782 catch_fork_command_1
,
15784 (void *) (uintptr_t) catch_vfork_permanent
,
15785 (void *) (uintptr_t) catch_vfork_temporary
);
15786 add_catch_command ("exec", _("Catch calls to exec."),
15787 catch_exec_command_1
,
15791 add_catch_command ("load", _("Catch loads of shared libraries.\n\
15792 Usage: catch load [REGEX]\n\
15793 If REGEX is given, only stop for libraries matching the regular expression."),
15794 catch_load_command_1
,
15798 add_catch_command ("unload", _("Catch unloads of shared libraries.\n\
15799 Usage: catch unload [REGEX]\n\
15800 If REGEX is given, only stop for libraries matching the regular expression."),
15801 catch_unload_command_1
,
15806 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
15807 Set a watchpoint for an expression.\n\
15808 Usage: watch [-l|-location] EXPRESSION\n\
15809 A watchpoint stops execution of your program whenever the value of\n\
15810 an expression changes.\n\
15811 If -l or -location is given, this evaluates EXPRESSION and watches\n\
15812 the memory to which it refers."));
15813 set_cmd_completer (c
, expression_completer
);
15815 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
15816 Set a read watchpoint for an expression.\n\
15817 Usage: rwatch [-l|-location] EXPRESSION\n\
15818 A watchpoint stops execution of your program whenever the value of\n\
15819 an expression is read.\n\
15820 If -l or -location is given, this evaluates EXPRESSION and watches\n\
15821 the memory to which it refers."));
15822 set_cmd_completer (c
, expression_completer
);
15824 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
15825 Set a watchpoint for an expression.\n\
15826 Usage: awatch [-l|-location] EXPRESSION\n\
15827 A watchpoint stops execution of your program whenever the value of\n\
15828 an expression is either read or written.\n\
15829 If -l or -location is given, this evaluates EXPRESSION and watches\n\
15830 the memory to which it refers."));
15831 set_cmd_completer (c
, expression_completer
);
15833 add_info ("watchpoints", info_watchpoints_command
, _("\
15834 Status of specified watchpoints (all watchpoints if no argument)."));
15836 /* XXX: cagney/2005-02-23: This should be a boolean, and should
15837 respond to changes - contrary to the description. */
15838 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
15839 &can_use_hw_watchpoints
, _("\
15840 Set debugger's willingness to use watchpoint hardware."), _("\
15841 Show debugger's willingness to use watchpoint hardware."), _("\
15842 If zero, gdb will not use hardware for new watchpoints, even if\n\
15843 such is available. (However, any hardware watchpoints that were\n\
15844 created before setting this to nonzero, will continue to use watchpoint\n\
15847 show_can_use_hw_watchpoints
,
15848 &setlist
, &showlist
);
15850 can_use_hw_watchpoints
= 1;
15852 /* Tracepoint manipulation commands. */
15854 c
= add_com ("trace", class_breakpoint
, trace_command
, _("\
15855 Set a tracepoint at specified location.\n\
15857 BREAK_ARGS_HELP ("trace") "\n\
15858 Do \"help tracepoints\" for info on other tracepoint commands."));
15859 set_cmd_completer (c
, location_completer
);
15861 add_com_alias ("tp", "trace", class_alias
, 0);
15862 add_com_alias ("tr", "trace", class_alias
, 1);
15863 add_com_alias ("tra", "trace", class_alias
, 1);
15864 add_com_alias ("trac", "trace", class_alias
, 1);
15866 c
= add_com ("ftrace", class_breakpoint
, ftrace_command
, _("\
15867 Set a fast tracepoint at specified location.\n\
15869 BREAK_ARGS_HELP ("ftrace") "\n\
15870 Do \"help tracepoints\" for info on other tracepoint commands."));
15871 set_cmd_completer (c
, location_completer
);
15873 c
= add_com ("strace", class_breakpoint
, strace_command
, _("\
15874 Set a static tracepoint at location or marker.\n\
15876 strace [LOCATION] [if CONDITION]\n\
15877 LOCATION may be a linespec, explicit, or address location (described below) \n\
15878 or -m MARKER_ID.\n\n\
15879 If a marker id is specified, probe the marker with that name. With\n\
15880 no LOCATION, uses current execution address of the selected stack frame.\n\
15881 Static tracepoints accept an extra collect action -- ``collect $_sdata''.\n\
15882 This collects arbitrary user data passed in the probe point call to the\n\
15883 tracing library. You can inspect it when analyzing the trace buffer,\n\
15884 by printing the $_sdata variable like any other convenience variable.\n\
15886 CONDITION is a boolean expression.\n\
15887 \n" LOCATION_HELP_STRING
"\n\
15888 Multiple tracepoints at one place are permitted, and useful if their\n\
15889 conditions are different.\n\
15891 Do \"help breakpoints\" for info on other commands dealing with breakpoints.\n\
15892 Do \"help tracepoints\" for info on other tracepoint commands."));
15893 set_cmd_completer (c
, location_completer
);
15895 add_info ("tracepoints", info_tracepoints_command
, _("\
15896 Status of specified tracepoints (all tracepoints if no argument).\n\
15897 Convenience variable \"$tpnum\" contains the number of the\n\
15898 last tracepoint set."));
15900 add_info_alias ("tp", "tracepoints", 1);
15902 add_cmd ("tracepoints", class_trace
, delete_trace_command
, _("\
15903 Delete specified tracepoints.\n\
15904 Arguments are tracepoint numbers, separated by spaces.\n\
15905 No argument means delete all tracepoints."),
15907 add_alias_cmd ("tr", "tracepoints", class_trace
, 1, &deletelist
);
15909 c
= add_cmd ("tracepoints", class_trace
, disable_trace_command
, _("\
15910 Disable specified tracepoints.\n\
15911 Arguments are tracepoint numbers, separated by spaces.\n\
15912 No argument means disable all tracepoints."),
15914 deprecate_cmd (c
, "disable");
15916 c
= add_cmd ("tracepoints", class_trace
, enable_trace_command
, _("\
15917 Enable specified tracepoints.\n\
15918 Arguments are tracepoint numbers, separated by spaces.\n\
15919 No argument means enable all tracepoints."),
15921 deprecate_cmd (c
, "enable");
15923 add_com ("passcount", class_trace
, trace_pass_command
, _("\
15924 Set the passcount for a tracepoint.\n\
15925 The trace will end when the tracepoint has been passed 'count' times.\n\
15926 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
15927 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
15929 add_prefix_cmd ("save", class_breakpoint
, save_command
,
15930 _("Save breakpoint definitions as a script."),
15931 &save_cmdlist
, "save ",
15932 0/*allow-unknown*/, &cmdlist
);
15934 c
= add_cmd ("breakpoints", class_breakpoint
, save_breakpoints_command
, _("\
15935 Save current breakpoint definitions as a script.\n\
15936 This includes all types of breakpoints (breakpoints, watchpoints,\n\
15937 catchpoints, tracepoints). Use the 'source' command in another debug\n\
15938 session to restore them."),
15940 set_cmd_completer (c
, filename_completer
);
15942 c
= add_cmd ("tracepoints", class_trace
, save_tracepoints_command
, _("\
15943 Save current tracepoint definitions as a script.\n\
15944 Use the 'source' command in another debug session to restore them."),
15946 set_cmd_completer (c
, filename_completer
);
15948 c
= add_com_alias ("save-tracepoints", "save tracepoints", class_trace
, 0);
15949 deprecate_cmd (c
, "save tracepoints");
15951 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
15952 Breakpoint specific settings\n\
15953 Configure various breakpoint-specific variables such as\n\
15954 pending breakpoint behavior"),
15955 &breakpoint_set_cmdlist
, "set breakpoint ",
15956 0/*allow-unknown*/, &setlist
);
15957 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
15958 Breakpoint specific settings\n\
15959 Configure various breakpoint-specific variables such as\n\
15960 pending breakpoint behavior"),
15961 &breakpoint_show_cmdlist
, "show breakpoint ",
15962 0/*allow-unknown*/, &showlist
);
15964 add_setshow_auto_boolean_cmd ("pending", no_class
,
15965 &pending_break_support
, _("\
15966 Set debugger's behavior regarding pending breakpoints."), _("\
15967 Show debugger's behavior regarding pending breakpoints."), _("\
15968 If on, an unrecognized breakpoint location will cause gdb to create a\n\
15969 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
15970 an error. If auto, an unrecognized breakpoint location results in a\n\
15971 user-query to see if a pending breakpoint should be created."),
15973 show_pending_break_support
,
15974 &breakpoint_set_cmdlist
,
15975 &breakpoint_show_cmdlist
);
15977 pending_break_support
= AUTO_BOOLEAN_AUTO
;
15979 add_setshow_boolean_cmd ("auto-hw", no_class
,
15980 &automatic_hardware_breakpoints
, _("\
15981 Set automatic usage of hardware breakpoints."), _("\
15982 Show automatic usage of hardware breakpoints."), _("\
15983 If set, the debugger will automatically use hardware breakpoints for\n\
15984 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
15985 a warning will be emitted for such breakpoints."),
15987 show_automatic_hardware_breakpoints
,
15988 &breakpoint_set_cmdlist
,
15989 &breakpoint_show_cmdlist
);
15991 add_setshow_boolean_cmd ("always-inserted", class_support
,
15992 &always_inserted_mode
, _("\
15993 Set mode for inserting breakpoints."), _("\
15994 Show mode for inserting breakpoints."), _("\
15995 When this mode is on, breakpoints are inserted immediately as soon as\n\
15996 they're created, kept inserted even when execution stops, and removed\n\
15997 only when the user deletes them. When this mode is off (the default),\n\
15998 breakpoints are inserted only when execution continues, and removed\n\
15999 when execution stops."),
16001 &show_always_inserted_mode
,
16002 &breakpoint_set_cmdlist
,
16003 &breakpoint_show_cmdlist
);
16005 add_setshow_enum_cmd ("condition-evaluation", class_breakpoint
,
16006 condition_evaluation_enums
,
16007 &condition_evaluation_mode_1
, _("\
16008 Set mode of breakpoint condition evaluation."), _("\
16009 Show mode of breakpoint condition evaluation."), _("\
16010 When this is set to \"host\", breakpoint conditions will be\n\
16011 evaluated on the host's side by GDB. When it is set to \"target\",\n\
16012 breakpoint conditions will be downloaded to the target (if the target\n\
16013 supports such feature) and conditions will be evaluated on the target's side.\n\
16014 If this is set to \"auto\" (default), this will be automatically set to\n\
16015 \"target\" if it supports condition evaluation, otherwise it will\n\
16016 be set to \"gdb\""),
16017 &set_condition_evaluation_mode
,
16018 &show_condition_evaluation_mode
,
16019 &breakpoint_set_cmdlist
,
16020 &breakpoint_show_cmdlist
);
16022 add_com ("break-range", class_breakpoint
, break_range_command
, _("\
16023 Set a breakpoint for an address range.\n\
16024 break-range START-LOCATION, END-LOCATION\n\
16025 where START-LOCATION and END-LOCATION can be one of the following:\n\
16026 LINENUM, for that line in the current file,\n\
16027 FILE:LINENUM, for that line in that file,\n\
16028 +OFFSET, for that number of lines after the current line\n\
16029 or the start of the range\n\
16030 FUNCTION, for the first line in that function,\n\
16031 FILE:FUNCTION, to distinguish among like-named static functions.\n\
16032 *ADDRESS, for the instruction at that address.\n\
16034 The breakpoint will stop execution of the inferior whenever it executes\n\
16035 an instruction at any address within the [START-LOCATION, END-LOCATION]\n\
16036 range (including START-LOCATION and END-LOCATION)."));
16038 c
= add_com ("dprintf", class_breakpoint
, dprintf_command
, _("\
16039 Set a dynamic printf at specified location.\n\
16040 dprintf location,format string,arg1,arg2,...\n\
16041 location may be a linespec, explicit, or address location.\n"
16042 "\n" LOCATION_HELP_STRING
));
16043 set_cmd_completer (c
, location_completer
);
16045 add_setshow_enum_cmd ("dprintf-style", class_support
,
16046 dprintf_style_enums
, &dprintf_style
, _("\
16047 Set the style of usage for dynamic printf."), _("\
16048 Show the style of usage for dynamic printf."), _("\
16049 This setting chooses how GDB will do a dynamic printf.\n\
16050 If the value is \"gdb\", then the printing is done by GDB to its own\n\
16051 console, as with the \"printf\" command.\n\
16052 If the value is \"call\", the print is done by calling a function in your\n\
16053 program; by default printf(), but you can choose a different function or\n\
16054 output stream by setting dprintf-function and dprintf-channel."),
16055 update_dprintf_commands
, NULL
,
16056 &setlist
, &showlist
);
16058 dprintf_function
= xstrdup ("printf");
16059 add_setshow_string_cmd ("dprintf-function", class_support
,
16060 &dprintf_function
, _("\
16061 Set the function to use for dynamic printf"), _("\
16062 Show the function to use for dynamic printf"), NULL
,
16063 update_dprintf_commands
, NULL
,
16064 &setlist
, &showlist
);
16066 dprintf_channel
= xstrdup ("");
16067 add_setshow_string_cmd ("dprintf-channel", class_support
,
16068 &dprintf_channel
, _("\
16069 Set the channel to use for dynamic printf"), _("\
16070 Show the channel to use for dynamic printf"), NULL
,
16071 update_dprintf_commands
, NULL
,
16072 &setlist
, &showlist
);
16074 add_setshow_boolean_cmd ("disconnected-dprintf", no_class
,
16075 &disconnected_dprintf
, _("\
16076 Set whether dprintf continues after GDB disconnects."), _("\
16077 Show whether dprintf continues after GDB disconnects."), _("\
16078 Use this to let dprintf commands continue to hit and produce output\n\
16079 even if GDB disconnects or detaches from the target."),
16082 &setlist
, &showlist
);
16084 add_com ("agent-printf", class_vars
, agent_printf_command
, _("\
16085 agent-printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
16086 (target agent only) This is useful for formatted output in user-defined commands."));
16088 automatic_hardware_breakpoints
= 1;
16090 observer_attach_about_to_proceed (breakpoint_about_to_proceed
);
16091 observer_attach_thread_exit (remove_threaded_breakpoints
);