1 /* Everything about breakpoints, for GDB.
3 Copyright (C) 1986-2018 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 breakpoint_re_set_default (struct breakpoint
*);
102 create_sals_from_location_default (const struct event_location
*location
,
103 struct linespec_result
*canonical
,
104 enum bptype type_wanted
);
106 static void create_breakpoints_sal_default (struct gdbarch
*,
107 struct linespec_result
*,
108 gdb::unique_xmalloc_ptr
<char>,
109 gdb::unique_xmalloc_ptr
<char>,
111 enum bpdisp
, int, int,
113 const struct breakpoint_ops
*,
114 int, int, int, unsigned);
116 static std::vector
<symtab_and_line
> decode_location_default
117 (struct breakpoint
*b
, const struct event_location
*location
,
118 struct program_space
*search_pspace
);
120 static int can_use_hardware_watchpoint (struct value
*);
122 static void mention (struct breakpoint
*);
124 static struct breakpoint
*set_raw_breakpoint_without_location (struct gdbarch
*,
126 const struct breakpoint_ops
*);
127 static struct bp_location
*add_location_to_breakpoint (struct breakpoint
*,
128 const struct symtab_and_line
*);
130 /* This function is used in gdbtk sources and thus can not be made
132 struct breakpoint
*set_raw_breakpoint (struct gdbarch
*gdbarch
,
133 struct symtab_and_line
,
135 const struct breakpoint_ops
*);
137 static struct breakpoint
*
138 momentary_breakpoint_from_master (struct breakpoint
*orig
,
140 const struct breakpoint_ops
*ops
,
143 static void breakpoint_adjustment_warning (CORE_ADDR
, CORE_ADDR
, int, int);
145 static CORE_ADDR
adjust_breakpoint_address (struct gdbarch
*gdbarch
,
149 static void describe_other_breakpoints (struct gdbarch
*,
150 struct program_space
*, CORE_ADDR
,
151 struct obj_section
*, int);
153 static int watchpoint_locations_match (struct bp_location
*loc1
,
154 struct bp_location
*loc2
);
156 static int breakpoint_location_address_match (struct bp_location
*bl
,
157 const struct address_space
*aspace
,
160 static int breakpoint_location_address_range_overlap (struct bp_location
*,
161 const address_space
*,
164 static int remove_breakpoint (struct bp_location
*);
165 static int remove_breakpoint_1 (struct bp_location
*, enum remove_bp_reason
);
167 static enum print_stop_action
print_bp_stop_message (bpstat bs
);
169 static int hw_breakpoint_used_count (void);
171 static int hw_watchpoint_use_count (struct breakpoint
*);
173 static int hw_watchpoint_used_count_others (struct breakpoint
*except
,
175 int *other_type_used
);
177 static void enable_breakpoint_disp (struct breakpoint
*, enum bpdisp
,
180 static void free_bp_location (struct bp_location
*loc
);
181 static void incref_bp_location (struct bp_location
*loc
);
182 static void decref_bp_location (struct bp_location
**loc
);
184 static struct bp_location
*allocate_bp_location (struct breakpoint
*bpt
);
186 /* update_global_location_list's modes of operation wrt to whether to
187 insert locations now. */
188 enum ugll_insert_mode
190 /* Don't insert any breakpoint locations into the inferior, only
191 remove already-inserted locations that no longer should be
192 inserted. Functions that delete a breakpoint or breakpoints
193 should specify this mode, so that deleting a breakpoint doesn't
194 have the side effect of inserting the locations of other
195 breakpoints that are marked not-inserted, but should_be_inserted
196 returns true on them.
198 This behavior is useful is situations close to tear-down -- e.g.,
199 after an exec, while the target still has execution, but
200 breakpoint shadows of the previous executable image should *NOT*
201 be restored to the new image; or before detaching, where the
202 target still has execution and wants to delete breakpoints from
203 GDB's lists, and all breakpoints had already been removed from
207 /* May insert breakpoints iff breakpoints_should_be_inserted_now
208 claims breakpoints should be inserted now. */
211 /* Insert locations now, irrespective of
212 breakpoints_should_be_inserted_now. E.g., say all threads are
213 stopped right now, and the user did "continue". We need to
214 insert breakpoints _before_ resuming the target, but
215 UGLL_MAY_INSERT wouldn't insert them, because
216 breakpoints_should_be_inserted_now returns false at that point,
217 as no thread is running yet. */
221 static void update_global_location_list (enum ugll_insert_mode
);
223 static void update_global_location_list_nothrow (enum ugll_insert_mode
);
225 static int is_hardware_watchpoint (const struct breakpoint
*bpt
);
227 static void insert_breakpoint_locations (void);
229 static void trace_pass_command (const char *, int);
231 static void set_tracepoint_count (int num
);
233 static int is_masked_watchpoint (const struct breakpoint
*b
);
235 static struct bp_location
**get_first_locp_gte_addr (CORE_ADDR address
);
237 /* Return 1 if B refers to a static tracepoint set by marker ("-m"), zero
240 static int strace_marker_p (struct breakpoint
*b
);
242 /* The breakpoint_ops structure to be inherited by all breakpoint_ops
243 that are implemented on top of software or hardware breakpoints
244 (user breakpoints, internal and momentary breakpoints, etc.). */
245 static struct breakpoint_ops bkpt_base_breakpoint_ops
;
247 /* Internal breakpoints class type. */
248 static struct breakpoint_ops internal_breakpoint_ops
;
250 /* Momentary breakpoints class type. */
251 static struct breakpoint_ops momentary_breakpoint_ops
;
253 /* The breakpoint_ops structure to be used in regular user created
255 struct breakpoint_ops bkpt_breakpoint_ops
;
257 /* Breakpoints set on probes. */
258 static struct breakpoint_ops bkpt_probe_breakpoint_ops
;
260 /* Dynamic printf class type. */
261 struct breakpoint_ops dprintf_breakpoint_ops
;
263 /* The style in which to perform a dynamic printf. This is a user
264 option because different output options have different tradeoffs;
265 if GDB does the printing, there is better error handling if there
266 is a problem with any of the arguments, but using an inferior
267 function lets you have special-purpose printers and sending of
268 output to the same place as compiled-in print functions. */
270 static const char dprintf_style_gdb
[] = "gdb";
271 static const char dprintf_style_call
[] = "call";
272 static const char dprintf_style_agent
[] = "agent";
273 static const char *const dprintf_style_enums
[] = {
279 static const char *dprintf_style
= dprintf_style_gdb
;
281 /* The function to use for dynamic printf if the preferred style is to
282 call into the inferior. The value is simply a string that is
283 copied into the command, so it can be anything that GDB can
284 evaluate to a callable address, not necessarily a function name. */
286 static char *dprintf_function
;
288 /* The channel to use for dynamic printf if the preferred style is to
289 call into the inferior; if a nonempty string, it will be passed to
290 the call as the first argument, with the format string as the
291 second. As with the dprintf function, this can be anything that
292 GDB knows how to evaluate, so in addition to common choices like
293 "stderr", this could be an app-specific expression like
294 "mystreams[curlogger]". */
296 static char *dprintf_channel
;
298 /* True if dprintf commands should continue to operate even if GDB
300 static int disconnected_dprintf
= 1;
302 struct command_line
*
303 breakpoint_commands (struct breakpoint
*b
)
305 return b
->commands
? b
->commands
.get () : NULL
;
308 /* Flag indicating that a command has proceeded the inferior past the
309 current breakpoint. */
311 static int breakpoint_proceeded
;
314 bpdisp_text (enum bpdisp disp
)
316 /* NOTE: the following values are a part of MI protocol and
317 represent values of 'disp' field returned when inferior stops at
319 static const char * const bpdisps
[] = {"del", "dstp", "dis", "keep"};
321 return bpdisps
[(int) disp
];
324 /* Prototypes for exported functions. */
325 /* If FALSE, gdb will not use hardware support for watchpoints, even
326 if such is available. */
327 static int can_use_hw_watchpoints
;
330 show_can_use_hw_watchpoints (struct ui_file
*file
, int from_tty
,
331 struct cmd_list_element
*c
,
334 fprintf_filtered (file
,
335 _("Debugger's willingness to use "
336 "watchpoint hardware is %s.\n"),
340 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
341 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
342 for unrecognized breakpoint locations.
343 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
344 static enum auto_boolean pending_break_support
;
346 show_pending_break_support (struct ui_file
*file
, int from_tty
,
347 struct cmd_list_element
*c
,
350 fprintf_filtered (file
,
351 _("Debugger's behavior regarding "
352 "pending breakpoints is %s.\n"),
356 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
357 set with "break" but falling in read-only memory.
358 If 0, gdb will warn about such breakpoints, but won't automatically
359 use hardware breakpoints. */
360 static int automatic_hardware_breakpoints
;
362 show_automatic_hardware_breakpoints (struct ui_file
*file
, int from_tty
,
363 struct cmd_list_element
*c
,
366 fprintf_filtered (file
,
367 _("Automatic usage of hardware breakpoints is %s.\n"),
371 /* If on, GDB keeps breakpoints inserted even if the inferior is
372 stopped, and immediately inserts any new breakpoints as soon as
373 they're created. If off (default), GDB keeps breakpoints off of
374 the target as long as possible. That is, it delays inserting
375 breakpoints until the next resume, and removes them again when the
376 target fully stops. This is a bit safer in case GDB crashes while
377 processing user input. */
378 static int always_inserted_mode
= 0;
381 show_always_inserted_mode (struct ui_file
*file
, int from_tty
,
382 struct cmd_list_element
*c
, const char *value
)
384 fprintf_filtered (file
, _("Always inserted breakpoint mode is %s.\n"),
388 /* See breakpoint.h. */
391 breakpoints_should_be_inserted_now (void)
393 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
395 /* If breakpoints are global, they should be inserted even if no
396 thread under gdb's control is running, or even if there are
397 no threads under GDB's control yet. */
400 else if (target_has_execution
)
402 struct thread_info
*tp
;
404 if (always_inserted_mode
)
406 /* The user wants breakpoints inserted even if all threads
411 if (threads_are_executing ())
414 /* Don't remove breakpoints yet if, even though all threads are
415 stopped, we still have events to process. */
416 ALL_NON_EXITED_THREADS (tp
)
418 && tp
->suspend
.waitstatus_pending_p
)
424 static const char condition_evaluation_both
[] = "host or target";
426 /* Modes for breakpoint condition evaluation. */
427 static const char condition_evaluation_auto
[] = "auto";
428 static const char condition_evaluation_host
[] = "host";
429 static const char condition_evaluation_target
[] = "target";
430 static const char *const condition_evaluation_enums
[] = {
431 condition_evaluation_auto
,
432 condition_evaluation_host
,
433 condition_evaluation_target
,
437 /* Global that holds the current mode for breakpoint condition evaluation. */
438 static const char *condition_evaluation_mode_1
= condition_evaluation_auto
;
440 /* Global that we use to display information to the user (gets its value from
441 condition_evaluation_mode_1. */
442 static const char *condition_evaluation_mode
= condition_evaluation_auto
;
444 /* Translate a condition evaluation mode MODE into either "host"
445 or "target". This is used mostly to translate from "auto" to the
446 real setting that is being used. It returns the translated
450 translate_condition_evaluation_mode (const char *mode
)
452 if (mode
== condition_evaluation_auto
)
454 if (target_supports_evaluation_of_breakpoint_conditions ())
455 return condition_evaluation_target
;
457 return condition_evaluation_host
;
463 /* Discovers what condition_evaluation_auto translates to. */
466 breakpoint_condition_evaluation_mode (void)
468 return translate_condition_evaluation_mode (condition_evaluation_mode
);
471 /* Return true if GDB should evaluate breakpoint conditions or false
475 gdb_evaluates_breakpoint_condition_p (void)
477 const char *mode
= breakpoint_condition_evaluation_mode ();
479 return (mode
== condition_evaluation_host
);
482 /* Are we executing breakpoint commands? */
483 static int executing_breakpoint_commands
;
485 /* Are overlay event breakpoints enabled? */
486 static int overlay_events_enabled
;
488 /* See description in breakpoint.h. */
489 int target_exact_watchpoints
= 0;
491 /* Walk the following statement or block through all breakpoints.
492 ALL_BREAKPOINTS_SAFE does so even if the statement deletes the
493 current breakpoint. */
495 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
497 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
498 for (B = breakpoint_chain; \
499 B ? (TMP=B->next, 1): 0; \
502 /* Similar iterator for the low-level breakpoints. SAFE variant is
503 not provided so update_global_location_list must not be called
504 while executing the block of ALL_BP_LOCATIONS. */
506 #define ALL_BP_LOCATIONS(B,BP_TMP) \
507 for (BP_TMP = bp_locations; \
508 BP_TMP < bp_locations + bp_locations_count && (B = *BP_TMP);\
511 /* Iterates through locations with address ADDRESS for the currently selected
512 program space. BP_LOCP_TMP points to each object. BP_LOCP_START points
513 to where the loop should start from.
514 If BP_LOCP_START is a NULL pointer, the macro automatically seeks the
515 appropriate location to start with. */
517 #define ALL_BP_LOCATIONS_AT_ADDR(BP_LOCP_TMP, BP_LOCP_START, ADDRESS) \
518 for (BP_LOCP_START = BP_LOCP_START == NULL ? get_first_locp_gte_addr (ADDRESS) : BP_LOCP_START, \
519 BP_LOCP_TMP = BP_LOCP_START; \
521 && (BP_LOCP_TMP < bp_locations + bp_locations_count \
522 && (*BP_LOCP_TMP)->address == ADDRESS); \
525 /* Iterator for tracepoints only. */
527 #define ALL_TRACEPOINTS(B) \
528 for (B = breakpoint_chain; B; B = B->next) \
529 if (is_tracepoint (B))
531 /* Chains of all breakpoints defined. */
533 struct breakpoint
*breakpoint_chain
;
535 /* Array is sorted by bp_locations_compare - primarily by the ADDRESS. */
537 static struct bp_location
**bp_locations
;
539 /* Number of elements of BP_LOCATIONS. */
541 static unsigned bp_locations_count
;
543 /* Maximum alignment offset between bp_target_info.PLACED_ADDRESS and
544 ADDRESS for the current elements of BP_LOCATIONS which get a valid
545 result from bp_location_has_shadow. You can use it for roughly
546 limiting the subrange of BP_LOCATIONS to scan for shadow bytes for
547 an address you need to read. */
549 static CORE_ADDR bp_locations_placed_address_before_address_max
;
551 /* Maximum offset plus alignment between bp_target_info.PLACED_ADDRESS
552 + bp_target_info.SHADOW_LEN and ADDRESS for the current elements of
553 BP_LOCATIONS which get a valid result from bp_location_has_shadow.
554 You can use it for roughly limiting the subrange of BP_LOCATIONS to
555 scan for shadow bytes for an address you need to read. */
557 static CORE_ADDR bp_locations_shadow_len_after_address_max
;
559 /* The locations that no longer correspond to any breakpoint, unlinked
560 from the bp_locations array, but for which a hit may still be
561 reported by a target. */
562 VEC(bp_location_p
) *moribund_locations
= NULL
;
564 /* Number of last breakpoint made. */
566 static int breakpoint_count
;
568 /* The value of `breakpoint_count' before the last command that
569 created breakpoints. If the last (break-like) command created more
570 than one breakpoint, then the difference between BREAKPOINT_COUNT
571 and PREV_BREAKPOINT_COUNT is more than one. */
572 static int prev_breakpoint_count
;
574 /* Number of last tracepoint made. */
576 static int tracepoint_count
;
578 static struct cmd_list_element
*breakpoint_set_cmdlist
;
579 static struct cmd_list_element
*breakpoint_show_cmdlist
;
580 struct cmd_list_element
*save_cmdlist
;
582 /* See declaration at breakpoint.h. */
585 breakpoint_find_if (int (*func
) (struct breakpoint
*b
, void *d
),
588 struct breakpoint
*b
= NULL
;
592 if (func (b
, user_data
) != 0)
599 /* Return whether a breakpoint is an active enabled breakpoint. */
601 breakpoint_enabled (struct breakpoint
*b
)
603 return (b
->enable_state
== bp_enabled
);
606 /* Set breakpoint count to NUM. */
609 set_breakpoint_count (int num
)
611 prev_breakpoint_count
= breakpoint_count
;
612 breakpoint_count
= num
;
613 set_internalvar_integer (lookup_internalvar ("bpnum"), num
);
616 /* Used by `start_rbreak_breakpoints' below, to record the current
617 breakpoint count before "rbreak" creates any breakpoint. */
618 static int rbreak_start_breakpoint_count
;
620 /* Called at the start an "rbreak" command to record the first
623 scoped_rbreak_breakpoints::scoped_rbreak_breakpoints ()
625 rbreak_start_breakpoint_count
= breakpoint_count
;
628 /* Called at the end of an "rbreak" command to record the last
631 scoped_rbreak_breakpoints::~scoped_rbreak_breakpoints ()
633 prev_breakpoint_count
= rbreak_start_breakpoint_count
;
636 /* Used in run_command to zero the hit count when a new run starts. */
639 clear_breakpoint_hit_counts (void)
641 struct breakpoint
*b
;
648 /* Return the breakpoint with the specified number, or NULL
649 if the number does not refer to an existing breakpoint. */
652 get_breakpoint (int num
)
654 struct breakpoint
*b
;
657 if (b
->number
== num
)
665 /* Mark locations as "conditions have changed" in case the target supports
666 evaluating conditions on its side. */
669 mark_breakpoint_modified (struct breakpoint
*b
)
671 struct bp_location
*loc
;
673 /* This is only meaningful if the target is
674 evaluating conditions and if the user has
675 opted for condition evaluation on the target's
677 if (gdb_evaluates_breakpoint_condition_p ()
678 || !target_supports_evaluation_of_breakpoint_conditions ())
681 if (!is_breakpoint (b
))
684 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
685 loc
->condition_changed
= condition_modified
;
688 /* Mark location as "conditions have changed" in case the target supports
689 evaluating conditions on its side. */
692 mark_breakpoint_location_modified (struct bp_location
*loc
)
694 /* This is only meaningful if the target is
695 evaluating conditions and if the user has
696 opted for condition evaluation on the target's
698 if (gdb_evaluates_breakpoint_condition_p ()
699 || !target_supports_evaluation_of_breakpoint_conditions ())
703 if (!is_breakpoint (loc
->owner
))
706 loc
->condition_changed
= condition_modified
;
709 /* Sets the condition-evaluation mode using the static global
710 condition_evaluation_mode. */
713 set_condition_evaluation_mode (const char *args
, int from_tty
,
714 struct cmd_list_element
*c
)
716 const char *old_mode
, *new_mode
;
718 if ((condition_evaluation_mode_1
== condition_evaluation_target
)
719 && !target_supports_evaluation_of_breakpoint_conditions ())
721 condition_evaluation_mode_1
= condition_evaluation_mode
;
722 warning (_("Target does not support breakpoint condition evaluation.\n"
723 "Using host evaluation mode instead."));
727 new_mode
= translate_condition_evaluation_mode (condition_evaluation_mode_1
);
728 old_mode
= translate_condition_evaluation_mode (condition_evaluation_mode
);
730 /* Flip the switch. Flip it even if OLD_MODE == NEW_MODE as one of the
731 settings was "auto". */
732 condition_evaluation_mode
= condition_evaluation_mode_1
;
734 /* Only update the mode if the user picked a different one. */
735 if (new_mode
!= old_mode
)
737 struct bp_location
*loc
, **loc_tmp
;
738 /* If the user switched to a different evaluation mode, we
739 need to synch the changes with the target as follows:
741 "host" -> "target": Send all (valid) conditions to the target.
742 "target" -> "host": Remove all the conditions from the target.
745 if (new_mode
== condition_evaluation_target
)
747 /* Mark everything modified and synch conditions with the
749 ALL_BP_LOCATIONS (loc
, loc_tmp
)
750 mark_breakpoint_location_modified (loc
);
754 /* Manually mark non-duplicate locations to synch conditions
755 with the target. We do this to remove all the conditions the
756 target knows about. */
757 ALL_BP_LOCATIONS (loc
, loc_tmp
)
758 if (is_breakpoint (loc
->owner
) && loc
->inserted
)
759 loc
->needs_update
= 1;
763 update_global_location_list (UGLL_MAY_INSERT
);
769 /* Shows the current mode of breakpoint condition evaluation. Explicitly shows
770 what "auto" is translating to. */
773 show_condition_evaluation_mode (struct ui_file
*file
, int from_tty
,
774 struct cmd_list_element
*c
, const char *value
)
776 if (condition_evaluation_mode
== condition_evaluation_auto
)
777 fprintf_filtered (file
,
778 _("Breakpoint condition evaluation "
779 "mode is %s (currently %s).\n"),
781 breakpoint_condition_evaluation_mode ());
783 fprintf_filtered (file
, _("Breakpoint condition evaluation mode is %s.\n"),
787 /* A comparison function for bp_location AP and BP that is used by
788 bsearch. This comparison function only cares about addresses, unlike
789 the more general bp_locations_compare function. */
792 bp_locations_compare_addrs (const void *ap
, const void *bp
)
794 const struct bp_location
*a
= *(const struct bp_location
**) ap
;
795 const struct bp_location
*b
= *(const struct bp_location
**) bp
;
797 if (a
->address
== b
->address
)
800 return ((a
->address
> b
->address
) - (a
->address
< b
->address
));
803 /* Helper function to skip all bp_locations with addresses
804 less than ADDRESS. It returns the first bp_location that
805 is greater than or equal to ADDRESS. If none is found, just
808 static struct bp_location
**
809 get_first_locp_gte_addr (CORE_ADDR address
)
811 struct bp_location dummy_loc
;
812 struct bp_location
*dummy_locp
= &dummy_loc
;
813 struct bp_location
**locp_found
= NULL
;
815 /* Initialize the dummy location's address field. */
816 dummy_loc
.address
= address
;
818 /* Find a close match to the first location at ADDRESS. */
819 locp_found
= ((struct bp_location
**)
820 bsearch (&dummy_locp
, bp_locations
, bp_locations_count
,
821 sizeof (struct bp_location
**),
822 bp_locations_compare_addrs
));
824 /* Nothing was found, nothing left to do. */
825 if (locp_found
== NULL
)
828 /* We may have found a location that is at ADDRESS but is not the first in the
829 location's list. Go backwards (if possible) and locate the first one. */
830 while ((locp_found
- 1) >= bp_locations
831 && (*(locp_found
- 1))->address
== address
)
838 set_breakpoint_condition (struct breakpoint
*b
, const char *exp
,
841 xfree (b
->cond_string
);
842 b
->cond_string
= NULL
;
844 if (is_watchpoint (b
))
846 struct watchpoint
*w
= (struct watchpoint
*) b
;
848 w
->cond_exp
.reset ();
852 struct bp_location
*loc
;
854 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
858 /* No need to free the condition agent expression
859 bytecode (if we have one). We will handle this
860 when we go through update_global_location_list. */
867 printf_filtered (_("Breakpoint %d now unconditional.\n"), b
->number
);
871 const char *arg
= exp
;
873 /* I don't know if it matters whether this is the string the user
874 typed in or the decompiled expression. */
875 b
->cond_string
= xstrdup (arg
);
876 b
->condition_not_parsed
= 0;
878 if (is_watchpoint (b
))
880 struct watchpoint
*w
= (struct watchpoint
*) b
;
882 innermost_block
.reset ();
884 w
->cond_exp
= parse_exp_1 (&arg
, 0, 0, 0);
886 error (_("Junk at end of expression"));
887 w
->cond_exp_valid_block
= innermost_block
.block ();
891 struct bp_location
*loc
;
893 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
897 parse_exp_1 (&arg
, loc
->address
,
898 block_for_pc (loc
->address
), 0);
900 error (_("Junk at end of expression"));
904 mark_breakpoint_modified (b
);
906 observer_notify_breakpoint_modified (b
);
909 /* Completion for the "condition" command. */
912 condition_completer (struct cmd_list_element
*cmd
,
913 completion_tracker
&tracker
,
914 const char *text
, const char *word
)
918 text
= skip_spaces (text
);
919 space
= skip_to_space (text
);
923 struct breakpoint
*b
;
927 /* We don't support completion of history indices. */
928 if (!isdigit (text
[1]))
929 complete_internalvar (tracker
, &text
[1]);
933 /* We're completing the breakpoint number. */
940 xsnprintf (number
, sizeof (number
), "%d", b
->number
);
942 if (strncmp (number
, text
, len
) == 0)
944 gdb::unique_xmalloc_ptr
<char> copy (xstrdup (number
));
945 tracker
.add_completion (std::move (copy
));
952 /* We're completing the expression part. */
953 text
= skip_spaces (space
);
954 expression_completer (cmd
, tracker
, text
, word
);
957 /* condition N EXP -- set break condition of breakpoint N to EXP. */
960 condition_command (const char *arg
, int from_tty
)
962 struct breakpoint
*b
;
967 error_no_arg (_("breakpoint number"));
970 bnum
= get_number (&p
);
972 error (_("Bad breakpoint argument: '%s'"), arg
);
975 if (b
->number
== bnum
)
977 /* Check if this breakpoint has a "stop" method implemented in an
978 extension language. This method and conditions entered into GDB
979 from the CLI are mutually exclusive. */
980 const struct extension_language_defn
*extlang
981 = get_breakpoint_cond_ext_lang (b
, EXT_LANG_NONE
);
985 error (_("Only one stop condition allowed. There is currently"
986 " a %s stop condition defined for this breakpoint."),
987 ext_lang_capitalized_name (extlang
));
989 set_breakpoint_condition (b
, p
, from_tty
);
991 if (is_breakpoint (b
))
992 update_global_location_list (UGLL_MAY_INSERT
);
997 error (_("No breakpoint number %d."), bnum
);
1000 /* Check that COMMAND do not contain commands that are suitable
1001 only for tracepoints and not suitable for ordinary breakpoints.
1002 Throw if any such commands is found. */
1005 check_no_tracepoint_commands (struct command_line
*commands
)
1007 struct command_line
*c
;
1009 for (c
= commands
; c
; c
= c
->next
)
1013 if (c
->control_type
== while_stepping_control
)
1014 error (_("The 'while-stepping' command can "
1015 "only be used for tracepoints"));
1017 for (i
= 0; i
< c
->body_count
; ++i
)
1018 check_no_tracepoint_commands ((c
->body_list
)[i
]);
1020 /* Not that command parsing removes leading whitespace and comment
1021 lines and also empty lines. So, we only need to check for
1022 command directly. */
1023 if (strstr (c
->line
, "collect ") == c
->line
)
1024 error (_("The 'collect' command can only be used for tracepoints"));
1026 if (strstr (c
->line
, "teval ") == c
->line
)
1027 error (_("The 'teval' command can only be used for tracepoints"));
1031 struct longjmp_breakpoint
: public breakpoint
1033 ~longjmp_breakpoint () override
;
1036 /* Encapsulate tests for different types of tracepoints. */
1039 is_tracepoint_type (bptype type
)
1041 return (type
== bp_tracepoint
1042 || type
== bp_fast_tracepoint
1043 || type
== bp_static_tracepoint
);
1047 is_longjmp_type (bptype type
)
1049 return type
== bp_longjmp
|| type
== bp_exception
;
1053 is_tracepoint (const struct breakpoint
*b
)
1055 return is_tracepoint_type (b
->type
);
1058 /* Factory function to create an appropriate instance of breakpoint given
1061 static std::unique_ptr
<breakpoint
>
1062 new_breakpoint_from_type (bptype type
)
1066 if (is_tracepoint_type (type
))
1067 b
= new tracepoint ();
1068 else if (is_longjmp_type (type
))
1069 b
= new longjmp_breakpoint ();
1071 b
= new breakpoint ();
1073 return std::unique_ptr
<breakpoint
> (b
);
1076 /* A helper function that validates that COMMANDS are valid for a
1077 breakpoint. This function will throw an exception if a problem is
1081 validate_commands_for_breakpoint (struct breakpoint
*b
,
1082 struct command_line
*commands
)
1084 if (is_tracepoint (b
))
1086 struct tracepoint
*t
= (struct tracepoint
*) b
;
1087 struct command_line
*c
;
1088 struct command_line
*while_stepping
= 0;
1090 /* Reset the while-stepping step count. The previous commands
1091 might have included a while-stepping action, while the new
1095 /* We need to verify that each top-level element of commands is
1096 valid for tracepoints, that there's at most one
1097 while-stepping element, and that the while-stepping's body
1098 has valid tracing commands excluding nested while-stepping.
1099 We also need to validate the tracepoint action line in the
1100 context of the tracepoint --- validate_actionline actually
1101 has side effects, like setting the tracepoint's
1102 while-stepping STEP_COUNT, in addition to checking if the
1103 collect/teval actions parse and make sense in the
1104 tracepoint's context. */
1105 for (c
= commands
; c
; c
= c
->next
)
1107 if (c
->control_type
== while_stepping_control
)
1109 if (b
->type
== bp_fast_tracepoint
)
1110 error (_("The 'while-stepping' command "
1111 "cannot be used for fast tracepoint"));
1112 else if (b
->type
== bp_static_tracepoint
)
1113 error (_("The 'while-stepping' command "
1114 "cannot be used for static tracepoint"));
1117 error (_("The 'while-stepping' command "
1118 "can be used only once"));
1123 validate_actionline (c
->line
, b
);
1127 struct command_line
*c2
;
1129 gdb_assert (while_stepping
->body_count
== 1);
1130 c2
= while_stepping
->body_list
[0];
1131 for (; c2
; c2
= c2
->next
)
1133 if (c2
->control_type
== while_stepping_control
)
1134 error (_("The 'while-stepping' command cannot be nested"));
1140 check_no_tracepoint_commands (commands
);
1144 /* Return a vector of all the static tracepoints set at ADDR. The
1145 caller is responsible for releasing the vector. */
1148 static_tracepoints_here (CORE_ADDR addr
)
1150 struct breakpoint
*b
;
1151 VEC(breakpoint_p
) *found
= 0;
1152 struct bp_location
*loc
;
1155 if (b
->type
== bp_static_tracepoint
)
1157 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1158 if (loc
->address
== addr
)
1159 VEC_safe_push(breakpoint_p
, found
, b
);
1165 /* Set the command list of B to COMMANDS. If breakpoint is tracepoint,
1166 validate that only allowed commands are included. */
1169 breakpoint_set_commands (struct breakpoint
*b
,
1170 command_line_up
&&commands
)
1172 validate_commands_for_breakpoint (b
, commands
.get ());
1174 b
->commands
= std::move (commands
);
1175 observer_notify_breakpoint_modified (b
);
1178 /* Set the internal `silent' flag on the breakpoint. Note that this
1179 is not the same as the "silent" that may appear in the breakpoint's
1183 breakpoint_set_silent (struct breakpoint
*b
, int silent
)
1185 int old_silent
= b
->silent
;
1188 if (old_silent
!= silent
)
1189 observer_notify_breakpoint_modified (b
);
1192 /* Set the thread for this breakpoint. If THREAD is -1, make the
1193 breakpoint work for any thread. */
1196 breakpoint_set_thread (struct breakpoint
*b
, int thread
)
1198 int old_thread
= b
->thread
;
1201 if (old_thread
!= thread
)
1202 observer_notify_breakpoint_modified (b
);
1205 /* Set the task for this breakpoint. If TASK is 0, make the
1206 breakpoint work for any task. */
1209 breakpoint_set_task (struct breakpoint
*b
, int task
)
1211 int old_task
= b
->task
;
1214 if (old_task
!= task
)
1215 observer_notify_breakpoint_modified (b
);
1219 check_tracepoint_command (char *line
, void *closure
)
1221 struct breakpoint
*b
= (struct breakpoint
*) closure
;
1223 validate_actionline (line
, b
);
1227 commands_command_1 (const char *arg
, int from_tty
,
1228 struct command_line
*control
)
1230 counted_command_line cmd
;
1232 std::string new_arg
;
1234 if (arg
== NULL
|| !*arg
)
1236 if (breakpoint_count
- prev_breakpoint_count
> 1)
1237 new_arg
= string_printf ("%d-%d", prev_breakpoint_count
+ 1,
1239 else if (breakpoint_count
> 0)
1240 new_arg
= string_printf ("%d", breakpoint_count
);
1241 arg
= new_arg
.c_str ();
1244 map_breakpoint_numbers
1245 (arg
, [&] (breakpoint
*b
)
1249 if (control
!= NULL
)
1250 cmd
= copy_command_lines (control
->body_list
[0]);
1254 = string_printf (_("Type commands for breakpoint(s) "
1255 "%s, one per line."),
1258 cmd
= read_command_lines (&str
[0],
1261 ? check_tracepoint_command
: 0),
1266 /* If a breakpoint was on the list more than once, we don't need to
1268 if (b
->commands
!= cmd
)
1270 validate_commands_for_breakpoint (b
, cmd
.get ());
1272 observer_notify_breakpoint_modified (b
);
1278 commands_command (const char *arg
, int from_tty
)
1280 commands_command_1 (arg
, from_tty
, NULL
);
1283 /* Like commands_command, but instead of reading the commands from
1284 input stream, takes them from an already parsed command structure.
1286 This is used by cli-script.c to DTRT with breakpoint commands
1287 that are part of if and while bodies. */
1288 enum command_control_type
1289 commands_from_control_command (const char *arg
, struct command_line
*cmd
)
1291 commands_command_1 (arg
, 0, cmd
);
1292 return simple_control
;
1295 /* Return non-zero if BL->TARGET_INFO contains valid information. */
1298 bp_location_has_shadow (struct bp_location
*bl
)
1300 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
1304 if (bl
->target_info
.shadow_len
== 0)
1305 /* BL isn't valid, or doesn't shadow memory. */
1310 /* Update BUF, which is LEN bytes read from the target address
1311 MEMADDR, by replacing a memory breakpoint with its shadowed
1314 If READBUF is not NULL, this buffer must not overlap with the of
1315 the breakpoint location's shadow_contents buffer. Otherwise, a
1316 failed assertion internal error will be raised. */
1319 one_breakpoint_xfer_memory (gdb_byte
*readbuf
, gdb_byte
*writebuf
,
1320 const gdb_byte
*writebuf_org
,
1321 ULONGEST memaddr
, LONGEST len
,
1322 struct bp_target_info
*target_info
,
1323 struct gdbarch
*gdbarch
)
1325 /* Now do full processing of the found relevant range of elements. */
1326 CORE_ADDR bp_addr
= 0;
1330 if (!breakpoint_address_match (target_info
->placed_address_space
, 0,
1331 current_program_space
->aspace
, 0))
1333 /* The breakpoint is inserted in a different address space. */
1337 /* Addresses and length of the part of the breakpoint that
1339 bp_addr
= target_info
->placed_address
;
1340 bp_size
= target_info
->shadow_len
;
1342 if (bp_addr
+ bp_size
<= memaddr
)
1344 /* The breakpoint is entirely before the chunk of memory we are
1349 if (bp_addr
>= memaddr
+ len
)
1351 /* The breakpoint is entirely after the chunk of memory we are
1356 /* Offset within shadow_contents. */
1357 if (bp_addr
< memaddr
)
1359 /* Only copy the second part of the breakpoint. */
1360 bp_size
-= memaddr
- bp_addr
;
1361 bptoffset
= memaddr
- bp_addr
;
1365 if (bp_addr
+ bp_size
> memaddr
+ len
)
1367 /* Only copy the first part of the breakpoint. */
1368 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
1371 if (readbuf
!= NULL
)
1373 /* Verify that the readbuf buffer does not overlap with the
1374 shadow_contents buffer. */
1375 gdb_assert (target_info
->shadow_contents
>= readbuf
+ len
1376 || readbuf
>= (target_info
->shadow_contents
1377 + target_info
->shadow_len
));
1379 /* Update the read buffer with this inserted breakpoint's
1381 memcpy (readbuf
+ bp_addr
- memaddr
,
1382 target_info
->shadow_contents
+ bptoffset
, bp_size
);
1386 const unsigned char *bp
;
1387 CORE_ADDR addr
= target_info
->reqstd_address
;
1390 /* Update the shadow with what we want to write to memory. */
1391 memcpy (target_info
->shadow_contents
+ bptoffset
,
1392 writebuf_org
+ bp_addr
- memaddr
, bp_size
);
1394 /* Determine appropriate breakpoint contents and size for this
1396 bp
= gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &placed_size
);
1398 /* Update the final write buffer with this inserted
1399 breakpoint's INSN. */
1400 memcpy (writebuf
+ bp_addr
- memaddr
, bp
+ bptoffset
, bp_size
);
1404 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
1405 by replacing any memory breakpoints with their shadowed contents.
1407 If READBUF is not NULL, this buffer must not overlap with any of
1408 the breakpoint location's shadow_contents buffers. Otherwise,
1409 a failed assertion internal error will be raised.
1411 The range of shadowed area by each bp_location is:
1412 bl->address - bp_locations_placed_address_before_address_max
1413 up to bl->address + bp_locations_shadow_len_after_address_max
1414 The range we were requested to resolve shadows for is:
1415 memaddr ... memaddr + len
1416 Thus the safe cutoff boundaries for performance optimization are
1417 memaddr + len <= (bl->address
1418 - bp_locations_placed_address_before_address_max)
1420 bl->address + bp_locations_shadow_len_after_address_max <= memaddr */
1423 breakpoint_xfer_memory (gdb_byte
*readbuf
, gdb_byte
*writebuf
,
1424 const gdb_byte
*writebuf_org
,
1425 ULONGEST memaddr
, LONGEST len
)
1427 /* Left boundary, right boundary and median element of our binary
1429 unsigned bc_l
, bc_r
, bc
;
1431 /* Find BC_L which is a leftmost element which may affect BUF
1432 content. It is safe to report lower value but a failure to
1433 report higher one. */
1436 bc_r
= bp_locations_count
;
1437 while (bc_l
+ 1 < bc_r
)
1439 struct bp_location
*bl
;
1441 bc
= (bc_l
+ bc_r
) / 2;
1442 bl
= bp_locations
[bc
];
1444 /* Check first BL->ADDRESS will not overflow due to the added
1445 constant. Then advance the left boundary only if we are sure
1446 the BC element can in no way affect the BUF content (MEMADDR
1447 to MEMADDR + LEN range).
1449 Use the BP_LOCATIONS_SHADOW_LEN_AFTER_ADDRESS_MAX safety
1450 offset so that we cannot miss a breakpoint with its shadow
1451 range tail still reaching MEMADDR. */
1453 if ((bl
->address
+ bp_locations_shadow_len_after_address_max
1455 && (bl
->address
+ bp_locations_shadow_len_after_address_max
1462 /* Due to the binary search above, we need to make sure we pick the
1463 first location that's at BC_L's address. E.g., if there are
1464 multiple locations at the same address, BC_L may end up pointing
1465 at a duplicate location, and miss the "master"/"inserted"
1466 location. Say, given locations L1, L2 and L3 at addresses A and
1469 L1@A, L2@A, L3@B, ...
1471 BC_L could end up pointing at location L2, while the "master"
1472 location could be L1. Since the `loc->inserted' flag is only set
1473 on "master" locations, we'd forget to restore the shadow of L1
1476 && bp_locations
[bc_l
]->address
== bp_locations
[bc_l
- 1]->address
)
1479 /* Now do full processing of the found relevant range of elements. */
1481 for (bc
= bc_l
; bc
< bp_locations_count
; bc
++)
1483 struct bp_location
*bl
= bp_locations
[bc
];
1485 /* bp_location array has BL->OWNER always non-NULL. */
1486 if (bl
->owner
->type
== bp_none
)
1487 warning (_("reading through apparently deleted breakpoint #%d?"),
1490 /* Performance optimization: any further element can no longer affect BUF
1493 if (bl
->address
>= bp_locations_placed_address_before_address_max
1494 && memaddr
+ len
<= (bl
->address
1495 - bp_locations_placed_address_before_address_max
))
1498 if (!bp_location_has_shadow (bl
))
1501 one_breakpoint_xfer_memory (readbuf
, writebuf
, writebuf_org
,
1502 memaddr
, len
, &bl
->target_info
, bl
->gdbarch
);
1508 /* Return true if BPT is either a software breakpoint or a hardware
1512 is_breakpoint (const struct breakpoint
*bpt
)
1514 return (bpt
->type
== bp_breakpoint
1515 || bpt
->type
== bp_hardware_breakpoint
1516 || bpt
->type
== bp_dprintf
);
1519 /* Return true if BPT is of any hardware watchpoint kind. */
1522 is_hardware_watchpoint (const struct breakpoint
*bpt
)
1524 return (bpt
->type
== bp_hardware_watchpoint
1525 || bpt
->type
== bp_read_watchpoint
1526 || bpt
->type
== bp_access_watchpoint
);
1529 /* Return true if BPT is of any watchpoint kind, hardware or
1533 is_watchpoint (const struct breakpoint
*bpt
)
1535 return (is_hardware_watchpoint (bpt
)
1536 || bpt
->type
== bp_watchpoint
);
1539 /* Returns true if the current thread and its running state are safe
1540 to evaluate or update watchpoint B. Watchpoints on local
1541 expressions need to be evaluated in the context of the thread that
1542 was current when the watchpoint was created, and, that thread needs
1543 to be stopped to be able to select the correct frame context.
1544 Watchpoints on global expressions can be evaluated on any thread,
1545 and in any state. It is presently left to the target allowing
1546 memory accesses when threads are running. */
1549 watchpoint_in_thread_scope (struct watchpoint
*b
)
1551 return (b
->pspace
== current_program_space
1552 && (ptid_equal (b
->watchpoint_thread
, null_ptid
)
1553 || (ptid_equal (inferior_ptid
, b
->watchpoint_thread
)
1554 && !is_executing (inferior_ptid
))));
1557 /* Set watchpoint B to disp_del_at_next_stop, even including its possible
1558 associated bp_watchpoint_scope breakpoint. */
1561 watchpoint_del_at_next_stop (struct watchpoint
*w
)
1563 if (w
->related_breakpoint
!= w
)
1565 gdb_assert (w
->related_breakpoint
->type
== bp_watchpoint_scope
);
1566 gdb_assert (w
->related_breakpoint
->related_breakpoint
== w
);
1567 w
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
1568 w
->related_breakpoint
->related_breakpoint
= w
->related_breakpoint
;
1569 w
->related_breakpoint
= w
;
1571 w
->disposition
= disp_del_at_next_stop
;
1574 /* Extract a bitfield value from value VAL using the bit parameters contained in
1577 static struct value
*
1578 extract_bitfield_from_watchpoint_value (struct watchpoint
*w
, struct value
*val
)
1580 struct value
*bit_val
;
1585 bit_val
= allocate_value (value_type (val
));
1587 unpack_value_bitfield (bit_val
,
1590 value_contents_for_printing (val
),
1597 /* Allocate a dummy location and add it to B, which must be a software
1598 watchpoint. This is required because even if a software watchpoint
1599 is not watching any memory, bpstat_stop_status requires a location
1600 to be able to report stops. */
1603 software_watchpoint_add_no_memory_location (struct breakpoint
*b
,
1604 struct program_space
*pspace
)
1606 gdb_assert (b
->type
== bp_watchpoint
&& b
->loc
== NULL
);
1608 b
->loc
= allocate_bp_location (b
);
1609 b
->loc
->pspace
= pspace
;
1610 b
->loc
->address
= -1;
1611 b
->loc
->length
= -1;
1614 /* Returns true if B is a software watchpoint that is not watching any
1615 memory (e.g., "watch $pc"). */
1618 is_no_memory_software_watchpoint (struct breakpoint
*b
)
1620 return (b
->type
== bp_watchpoint
1622 && b
->loc
->next
== NULL
1623 && b
->loc
->address
== -1
1624 && b
->loc
->length
== -1);
1627 /* Assuming that B is a watchpoint:
1628 - Reparse watchpoint expression, if REPARSE is non-zero
1629 - Evaluate expression and store the result in B->val
1630 - Evaluate the condition if there is one, and store the result
1632 - Update the list of values that must be watched in B->loc.
1634 If the watchpoint disposition is disp_del_at_next_stop, then do
1635 nothing. If this is local watchpoint that is out of scope, delete
1638 Even with `set breakpoint always-inserted on' the watchpoints are
1639 removed + inserted on each stop here. Normal breakpoints must
1640 never be removed because they might be missed by a running thread
1641 when debugging in non-stop mode. On the other hand, hardware
1642 watchpoints (is_hardware_watchpoint; processed here) are specific
1643 to each LWP since they are stored in each LWP's hardware debug
1644 registers. Therefore, such LWP must be stopped first in order to
1645 be able to modify its hardware watchpoints.
1647 Hardware watchpoints must be reset exactly once after being
1648 presented to the user. It cannot be done sooner, because it would
1649 reset the data used to present the watchpoint hit to the user. And
1650 it must not be done later because it could display the same single
1651 watchpoint hit during multiple GDB stops. Note that the latter is
1652 relevant only to the hardware watchpoint types bp_read_watchpoint
1653 and bp_access_watchpoint. False hit by bp_hardware_watchpoint is
1654 not user-visible - its hit is suppressed if the memory content has
1657 The following constraints influence the location where we can reset
1658 hardware watchpoints:
1660 * target_stopped_by_watchpoint and target_stopped_data_address are
1661 called several times when GDB stops.
1664 * Multiple hardware watchpoints can be hit at the same time,
1665 causing GDB to stop. GDB only presents one hardware watchpoint
1666 hit at a time as the reason for stopping, and all the other hits
1667 are presented later, one after the other, each time the user
1668 requests the execution to be resumed. Execution is not resumed
1669 for the threads still having pending hit event stored in
1670 LWP_INFO->STATUS. While the watchpoint is already removed from
1671 the inferior on the first stop the thread hit event is kept being
1672 reported from its cached value by linux_nat_stopped_data_address
1673 until the real thread resume happens after the watchpoint gets
1674 presented and thus its LWP_INFO->STATUS gets reset.
1676 Therefore the hardware watchpoint hit can get safely reset on the
1677 watchpoint removal from inferior. */
1680 update_watchpoint (struct watchpoint
*b
, int reparse
)
1682 int within_current_scope
;
1683 struct frame_id saved_frame_id
;
1686 /* If this is a local watchpoint, we only want to check if the
1687 watchpoint frame is in scope if the current thread is the thread
1688 that was used to create the watchpoint. */
1689 if (!watchpoint_in_thread_scope (b
))
1692 if (b
->disposition
== disp_del_at_next_stop
)
1697 /* Determine if the watchpoint is within scope. */
1698 if (b
->exp_valid_block
== NULL
)
1699 within_current_scope
= 1;
1702 struct frame_info
*fi
= get_current_frame ();
1703 struct gdbarch
*frame_arch
= get_frame_arch (fi
);
1704 CORE_ADDR frame_pc
= get_frame_pc (fi
);
1706 /* If we're at a point where the stack has been destroyed
1707 (e.g. in a function epilogue), unwinding may not work
1708 properly. Do not attempt to recreate locations at this
1709 point. See similar comments in watchpoint_check. */
1710 if (gdbarch_stack_frame_destroyed_p (frame_arch
, frame_pc
))
1713 /* Save the current frame's ID so we can restore it after
1714 evaluating the watchpoint expression on its own frame. */
1715 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
1716 took a frame parameter, so that we didn't have to change the
1719 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
1721 fi
= frame_find_by_id (b
->watchpoint_frame
);
1722 within_current_scope
= (fi
!= NULL
);
1723 if (within_current_scope
)
1727 /* We don't free locations. They are stored in the bp_location array
1728 and update_global_location_list will eventually delete them and
1729 remove breakpoints if needed. */
1732 if (within_current_scope
&& reparse
)
1737 s
= b
->exp_string_reparse
? b
->exp_string_reparse
: b
->exp_string
;
1738 b
->exp
= parse_exp_1 (&s
, 0, b
->exp_valid_block
, 0);
1739 /* If the meaning of expression itself changed, the old value is
1740 no longer relevant. We don't want to report a watchpoint hit
1741 to the user when the old value and the new value may actually
1742 be completely different objects. */
1743 value_free (b
->val
);
1747 /* Note that unlike with breakpoints, the watchpoint's condition
1748 expression is stored in the breakpoint object, not in the
1749 locations (re)created below. */
1750 if (b
->cond_string
!= NULL
)
1752 b
->cond_exp
.reset ();
1755 b
->cond_exp
= parse_exp_1 (&s
, 0, b
->cond_exp_valid_block
, 0);
1759 /* If we failed to parse the expression, for example because
1760 it refers to a global variable in a not-yet-loaded shared library,
1761 don't try to insert watchpoint. We don't automatically delete
1762 such watchpoint, though, since failure to parse expression
1763 is different from out-of-scope watchpoint. */
1764 if (!target_has_execution
)
1766 /* Without execution, memory can't change. No use to try and
1767 set watchpoint locations. The watchpoint will be reset when
1768 the target gains execution, through breakpoint_re_set. */
1769 if (!can_use_hw_watchpoints
)
1771 if (b
->ops
->works_in_software_mode (b
))
1772 b
->type
= bp_watchpoint
;
1774 error (_("Can't set read/access watchpoint when "
1775 "hardware watchpoints are disabled."));
1778 else if (within_current_scope
&& b
->exp
)
1781 struct value
*val_chain
, *v
, *result
, *next
;
1782 struct program_space
*frame_pspace
;
1784 fetch_subexp_value (b
->exp
.get (), &pc
, &v
, &result
, &val_chain
, 0);
1786 /* Avoid setting b->val if it's already set. The meaning of
1787 b->val is 'the last value' user saw, and we should update
1788 it only if we reported that last value to user. As it
1789 happens, the code that reports it updates b->val directly.
1790 We don't keep track of the memory value for masked
1792 if (!b
->val_valid
&& !is_masked_watchpoint (b
))
1794 if (b
->val_bitsize
!= 0)
1796 v
= extract_bitfield_from_watchpoint_value (b
, v
);
1804 frame_pspace
= get_frame_program_space (get_selected_frame (NULL
));
1806 /* Look at each value on the value chain. */
1807 for (v
= val_chain
; v
; v
= value_next (v
))
1809 /* If it's a memory location, and GDB actually needed
1810 its contents to evaluate the expression, then we
1811 must watch it. If the first value returned is
1812 still lazy, that means an error occurred reading it;
1813 watch it anyway in case it becomes readable. */
1814 if (VALUE_LVAL (v
) == lval_memory
1815 && (v
== val_chain
|| ! value_lazy (v
)))
1817 struct type
*vtype
= check_typedef (value_type (v
));
1819 /* We only watch structs and arrays if user asked
1820 for it explicitly, never if they just happen to
1821 appear in the middle of some value chain. */
1823 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
1824 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
1827 enum target_hw_bp_type type
;
1828 struct bp_location
*loc
, **tmp
;
1829 int bitpos
= 0, bitsize
= 0;
1831 if (value_bitsize (v
) != 0)
1833 /* Extract the bit parameters out from the bitfield
1835 bitpos
= value_bitpos (v
);
1836 bitsize
= value_bitsize (v
);
1838 else if (v
== result
&& b
->val_bitsize
!= 0)
1840 /* If VAL_BITSIZE != 0 then RESULT is actually a bitfield
1841 lvalue whose bit parameters are saved in the fields
1842 VAL_BITPOS and VAL_BITSIZE. */
1843 bitpos
= b
->val_bitpos
;
1844 bitsize
= b
->val_bitsize
;
1847 addr
= value_address (v
);
1850 /* Skip the bytes that don't contain the bitfield. */
1855 if (b
->type
== bp_read_watchpoint
)
1857 else if (b
->type
== bp_access_watchpoint
)
1860 loc
= allocate_bp_location (b
);
1861 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
1864 loc
->gdbarch
= get_type_arch (value_type (v
));
1866 loc
->pspace
= frame_pspace
;
1867 loc
->address
= address_significant (loc
->gdbarch
, addr
);
1871 /* Just cover the bytes that make up the bitfield. */
1872 loc
->length
= ((bitpos
% 8) + bitsize
+ 7) / 8;
1875 loc
->length
= TYPE_LENGTH (value_type (v
));
1877 loc
->watchpoint_type
= type
;
1882 /* Change the type of breakpoint between hardware assisted or
1883 an ordinary watchpoint depending on the hardware support
1884 and free hardware slots. REPARSE is set when the inferior
1889 enum bp_loc_type loc_type
;
1890 struct bp_location
*bl
;
1892 reg_cnt
= can_use_hardware_watchpoint (val_chain
);
1896 int i
, target_resources_ok
, other_type_used
;
1899 /* Use an exact watchpoint when there's only one memory region to be
1900 watched, and only one debug register is needed to watch it. */
1901 b
->exact
= target_exact_watchpoints
&& reg_cnt
== 1;
1903 /* We need to determine how many resources are already
1904 used for all other hardware watchpoints plus this one
1905 to see if we still have enough resources to also fit
1906 this watchpoint in as well. */
1908 /* If this is a software watchpoint, we try to turn it
1909 to a hardware one -- count resources as if B was of
1910 hardware watchpoint type. */
1912 if (type
== bp_watchpoint
)
1913 type
= bp_hardware_watchpoint
;
1915 /* This watchpoint may or may not have been placed on
1916 the list yet at this point (it won't be in the list
1917 if we're trying to create it for the first time,
1918 through watch_command), so always account for it
1921 /* Count resources used by all watchpoints except B. */
1922 i
= hw_watchpoint_used_count_others (b
, type
, &other_type_used
);
1924 /* Add in the resources needed for B. */
1925 i
+= hw_watchpoint_use_count (b
);
1928 = target_can_use_hardware_watchpoint (type
, i
, other_type_used
);
1929 if (target_resources_ok
<= 0)
1931 int sw_mode
= b
->ops
->works_in_software_mode (b
);
1933 if (target_resources_ok
== 0 && !sw_mode
)
1934 error (_("Target does not support this type of "
1935 "hardware watchpoint."));
1936 else if (target_resources_ok
< 0 && !sw_mode
)
1937 error (_("There are not enough available hardware "
1938 "resources for this watchpoint."));
1940 /* Downgrade to software watchpoint. */
1941 b
->type
= bp_watchpoint
;
1945 /* If this was a software watchpoint, we've just
1946 found we have enough resources to turn it to a
1947 hardware watchpoint. Otherwise, this is a
1952 else if (!b
->ops
->works_in_software_mode (b
))
1954 if (!can_use_hw_watchpoints
)
1955 error (_("Can't set read/access watchpoint when "
1956 "hardware watchpoints are disabled."));
1958 error (_("Expression cannot be implemented with "
1959 "read/access watchpoint."));
1962 b
->type
= bp_watchpoint
;
1964 loc_type
= (b
->type
== bp_watchpoint
? bp_loc_other
1965 : bp_loc_hardware_watchpoint
);
1966 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
1967 bl
->loc_type
= loc_type
;
1970 for (v
= val_chain
; v
; v
= next
)
1972 next
= value_next (v
);
1977 /* If a software watchpoint is not watching any memory, then the
1978 above left it without any location set up. But,
1979 bpstat_stop_status requires a location to be able to report
1980 stops, so make sure there's at least a dummy one. */
1981 if (b
->type
== bp_watchpoint
&& b
->loc
== NULL
)
1982 software_watchpoint_add_no_memory_location (b
, frame_pspace
);
1984 else if (!within_current_scope
)
1986 printf_filtered (_("\
1987 Watchpoint %d deleted because the program has left the block\n\
1988 in which its expression is valid.\n"),
1990 watchpoint_del_at_next_stop (b
);
1993 /* Restore the selected frame. */
1995 select_frame (frame_find_by_id (saved_frame_id
));
1999 /* Returns 1 iff breakpoint location should be
2000 inserted in the inferior. We don't differentiate the type of BL's owner
2001 (breakpoint vs. tracepoint), although insert_location in tracepoint's
2002 breakpoint_ops is not defined, because in insert_bp_location,
2003 tracepoint's insert_location will not be called. */
2005 should_be_inserted (struct bp_location
*bl
)
2007 if (bl
->owner
== NULL
|| !breakpoint_enabled (bl
->owner
))
2010 if (bl
->owner
->disposition
== disp_del_at_next_stop
)
2013 if (!bl
->enabled
|| bl
->shlib_disabled
|| bl
->duplicate
)
2016 if (user_breakpoint_p (bl
->owner
) && bl
->pspace
->executing_startup
)
2019 /* This is set for example, when we're attached to the parent of a
2020 vfork, and have detached from the child. The child is running
2021 free, and we expect it to do an exec or exit, at which point the
2022 OS makes the parent schedulable again (and the target reports
2023 that the vfork is done). Until the child is done with the shared
2024 memory region, do not insert breakpoints in the parent, otherwise
2025 the child could still trip on the parent's breakpoints. Since
2026 the parent is blocked anyway, it won't miss any breakpoint. */
2027 if (bl
->pspace
->breakpoints_not_allowed
)
2030 /* Don't insert a breakpoint if we're trying to step past its
2031 location, except if the breakpoint is a single-step breakpoint,
2032 and the breakpoint's thread is the thread which is stepping past
2034 if ((bl
->loc_type
== bp_loc_software_breakpoint
2035 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
2036 && stepping_past_instruction_at (bl
->pspace
->aspace
,
2038 /* The single-step breakpoint may be inserted at the location
2039 we're trying to step if the instruction branches to itself.
2040 However, the instruction won't be executed at all and it may
2041 break the semantics of the instruction, for example, the
2042 instruction is a conditional branch or updates some flags.
2043 We can't fix it unless GDB is able to emulate the instruction
2044 or switch to displaced stepping. */
2045 && !(bl
->owner
->type
== bp_single_step
2046 && thread_is_stepping_over_breakpoint (bl
->owner
->thread
)))
2050 fprintf_unfiltered (gdb_stdlog
,
2051 "infrun: skipping breakpoint: "
2052 "stepping past insn at: %s\n",
2053 paddress (bl
->gdbarch
, bl
->address
));
2058 /* Don't insert watchpoints if we're trying to step past the
2059 instruction that triggered one. */
2060 if ((bl
->loc_type
== bp_loc_hardware_watchpoint
)
2061 && stepping_past_nonsteppable_watchpoint ())
2065 fprintf_unfiltered (gdb_stdlog
,
2066 "infrun: stepping past non-steppable watchpoint. "
2067 "skipping watchpoint at %s:%d\n",
2068 paddress (bl
->gdbarch
, bl
->address
),
2077 /* Same as should_be_inserted but does the check assuming
2078 that the location is not duplicated. */
2081 unduplicated_should_be_inserted (struct bp_location
*bl
)
2084 const int save_duplicate
= bl
->duplicate
;
2087 result
= should_be_inserted (bl
);
2088 bl
->duplicate
= save_duplicate
;
2092 /* Parses a conditional described by an expression COND into an
2093 agent expression bytecode suitable for evaluation
2094 by the bytecode interpreter. Return NULL if there was
2095 any error during parsing. */
2097 static agent_expr_up
2098 parse_cond_to_aexpr (CORE_ADDR scope
, struct expression
*cond
)
2103 agent_expr_up aexpr
;
2105 /* We don't want to stop processing, so catch any errors
2106 that may show up. */
2109 aexpr
= gen_eval_for_expr (scope
, cond
);
2112 CATCH (ex
, RETURN_MASK_ERROR
)
2114 /* If we got here, it means the condition could not be parsed to a valid
2115 bytecode expression and thus can't be evaluated on the target's side.
2116 It's no use iterating through the conditions. */
2120 /* We have a valid agent expression. */
2124 /* Based on location BL, create a list of breakpoint conditions to be
2125 passed on to the target. If we have duplicated locations with different
2126 conditions, we will add such conditions to the list. The idea is that the
2127 target will evaluate the list of conditions and will only notify GDB when
2128 one of them is true. */
2131 build_target_condition_list (struct bp_location
*bl
)
2133 struct bp_location
**locp
= NULL
, **loc2p
;
2134 int null_condition_or_parse_error
= 0;
2135 int modified
= bl
->needs_update
;
2136 struct bp_location
*loc
;
2138 /* Release conditions left over from a previous insert. */
2139 bl
->target_info
.conditions
.clear ();
2141 /* This is only meaningful if the target is
2142 evaluating conditions and if the user has
2143 opted for condition evaluation on the target's
2145 if (gdb_evaluates_breakpoint_condition_p ()
2146 || !target_supports_evaluation_of_breakpoint_conditions ())
2149 /* Do a first pass to check for locations with no assigned
2150 conditions or conditions that fail to parse to a valid agent expression
2151 bytecode. If any of these happen, then it's no use to send conditions
2152 to the target since this location will always trigger and generate a
2153 response back to GDB. */
2154 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2157 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2161 /* Re-parse the conditions since something changed. In that
2162 case we already freed the condition bytecodes (see
2163 force_breakpoint_reinsertion). We just
2164 need to parse the condition to bytecodes again. */
2165 loc
->cond_bytecode
= parse_cond_to_aexpr (bl
->address
,
2169 /* If we have a NULL bytecode expression, it means something
2170 went wrong or we have a null condition expression. */
2171 if (!loc
->cond_bytecode
)
2173 null_condition_or_parse_error
= 1;
2179 /* If any of these happened, it means we will have to evaluate the conditions
2180 for the location's address on gdb's side. It is no use keeping bytecodes
2181 for all the other duplicate locations, thus we free all of them here.
2183 This is so we have a finer control over which locations' conditions are
2184 being evaluated by GDB or the remote stub. */
2185 if (null_condition_or_parse_error
)
2187 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2190 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2192 /* Only go as far as the first NULL bytecode is
2194 if (!loc
->cond_bytecode
)
2197 loc
->cond_bytecode
.reset ();
2202 /* No NULL conditions or failed bytecode generation. Build a condition list
2203 for this location's address. */
2204 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2208 && is_breakpoint (loc
->owner
)
2209 && loc
->pspace
->num
== bl
->pspace
->num
2210 && loc
->owner
->enable_state
== bp_enabled
2213 /* Add the condition to the vector. This will be used later
2214 to send the conditions to the target. */
2215 bl
->target_info
.conditions
.push_back (loc
->cond_bytecode
.get ());
2222 /* Parses a command described by string CMD into an agent expression
2223 bytecode suitable for evaluation by the bytecode interpreter.
2224 Return NULL if there was any error during parsing. */
2226 static agent_expr_up
2227 parse_cmd_to_aexpr (CORE_ADDR scope
, char *cmd
)
2229 const char *cmdrest
;
2230 const char *format_start
, *format_end
;
2231 struct gdbarch
*gdbarch
= get_current_arch ();
2238 if (*cmdrest
== ',')
2240 cmdrest
= skip_spaces (cmdrest
);
2242 if (*cmdrest
++ != '"')
2243 error (_("No format string following the location"));
2245 format_start
= cmdrest
;
2247 format_pieces
fpieces (&cmdrest
);
2249 format_end
= cmdrest
;
2251 if (*cmdrest
++ != '"')
2252 error (_("Bad format string, non-terminated '\"'."));
2254 cmdrest
= skip_spaces (cmdrest
);
2256 if (!(*cmdrest
== ',' || *cmdrest
== '\0'))
2257 error (_("Invalid argument syntax"));
2259 if (*cmdrest
== ',')
2261 cmdrest
= skip_spaces (cmdrest
);
2263 /* For each argument, make an expression. */
2265 std::vector
<struct expression
*> argvec
;
2266 while (*cmdrest
!= '\0')
2271 expression_up expr
= parse_exp_1 (&cmd1
, scope
, block_for_pc (scope
), 1);
2272 argvec
.push_back (expr
.release ());
2274 if (*cmdrest
== ',')
2278 agent_expr_up aexpr
;
2280 /* We don't want to stop processing, so catch any errors
2281 that may show up. */
2284 aexpr
= gen_printf (scope
, gdbarch
, 0, 0,
2285 format_start
, format_end
- format_start
,
2286 argvec
.size (), argvec
.data ());
2288 CATCH (ex
, RETURN_MASK_ERROR
)
2290 /* If we got here, it means the command could not be parsed to a valid
2291 bytecode expression and thus can't be evaluated on the target's side.
2292 It's no use iterating through the other commands. */
2296 /* We have a valid agent expression, return it. */
2300 /* Based on location BL, create a list of breakpoint commands to be
2301 passed on to the target. If we have duplicated locations with
2302 different commands, we will add any such to the list. */
2305 build_target_command_list (struct bp_location
*bl
)
2307 struct bp_location
**locp
= NULL
, **loc2p
;
2308 int null_command_or_parse_error
= 0;
2309 int modified
= bl
->needs_update
;
2310 struct bp_location
*loc
;
2312 /* Clear commands left over from a previous insert. */
2313 bl
->target_info
.tcommands
.clear ();
2315 if (!target_can_run_breakpoint_commands ())
2318 /* For now, limit to agent-style dprintf breakpoints. */
2319 if (dprintf_style
!= dprintf_style_agent
)
2322 /* For now, if we have any duplicate location that isn't a dprintf,
2323 don't install the target-side commands, as that would make the
2324 breakpoint not be reported to the core, and we'd lose
2326 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2329 if (is_breakpoint (loc
->owner
)
2330 && loc
->pspace
->num
== bl
->pspace
->num
2331 && loc
->owner
->type
!= bp_dprintf
)
2335 /* Do a first pass to check for locations with no assigned
2336 conditions or conditions that fail to parse to a valid agent expression
2337 bytecode. If any of these happen, then it's no use to send conditions
2338 to the target since this location will always trigger and generate a
2339 response back to GDB. */
2340 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2343 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2347 /* Re-parse the commands since something changed. In that
2348 case we already freed the command bytecodes (see
2349 force_breakpoint_reinsertion). We just
2350 need to parse the command to bytecodes again. */
2352 = parse_cmd_to_aexpr (bl
->address
,
2353 loc
->owner
->extra_string
);
2356 /* If we have a NULL bytecode expression, it means something
2357 went wrong or we have a null command expression. */
2358 if (!loc
->cmd_bytecode
)
2360 null_command_or_parse_error
= 1;
2366 /* If anything failed, then we're not doing target-side commands,
2368 if (null_command_or_parse_error
)
2370 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2373 if (is_breakpoint (loc
->owner
)
2374 && loc
->pspace
->num
== bl
->pspace
->num
)
2376 /* Only go as far as the first NULL bytecode is
2378 if (loc
->cmd_bytecode
== NULL
)
2381 loc
->cmd_bytecode
.reset ();
2386 /* No NULL commands or failed bytecode generation. Build a command list
2387 for this location's address. */
2388 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2391 if (loc
->owner
->extra_string
2392 && is_breakpoint (loc
->owner
)
2393 && loc
->pspace
->num
== bl
->pspace
->num
2394 && loc
->owner
->enable_state
== bp_enabled
2397 /* Add the command to the vector. This will be used later
2398 to send the commands to the target. */
2399 bl
->target_info
.tcommands
.push_back (loc
->cmd_bytecode
.get ());
2403 bl
->target_info
.persist
= 0;
2404 /* Maybe flag this location as persistent. */
2405 if (bl
->owner
->type
== bp_dprintf
&& disconnected_dprintf
)
2406 bl
->target_info
.persist
= 1;
2409 /* Return the kind of breakpoint on address *ADDR. Get the kind
2410 of breakpoint according to ADDR except single-step breakpoint.
2411 Get the kind of single-step breakpoint according to the current
2415 breakpoint_kind (struct bp_location
*bl
, CORE_ADDR
*addr
)
2417 if (bl
->owner
->type
== bp_single_step
)
2419 struct thread_info
*thr
= find_thread_global_id (bl
->owner
->thread
);
2420 struct regcache
*regcache
;
2422 regcache
= get_thread_regcache (thr
->ptid
);
2424 return gdbarch_breakpoint_kind_from_current_state (bl
->gdbarch
,
2428 return gdbarch_breakpoint_kind_from_pc (bl
->gdbarch
, addr
);
2431 /* Insert a low-level "breakpoint" of some type. BL is the breakpoint
2432 location. Any error messages are printed to TMP_ERROR_STREAM; and
2433 DISABLED_BREAKS, and HW_BREAKPOINT_ERROR are used to report problems.
2434 Returns 0 for success, 1 if the bp_location type is not supported or
2437 NOTE drow/2003-09-09: This routine could be broken down to an
2438 object-style method for each breakpoint or catchpoint type. */
2440 insert_bp_location (struct bp_location
*bl
,
2441 struct ui_file
*tmp_error_stream
,
2442 int *disabled_breaks
,
2443 int *hw_breakpoint_error
,
2444 int *hw_bp_error_explained_already
)
2446 gdb_exception bp_excpt
= exception_none
;
2448 if (!should_be_inserted (bl
) || (bl
->inserted
&& !bl
->needs_update
))
2451 /* Note we don't initialize bl->target_info, as that wipes out
2452 the breakpoint location's shadow_contents if the breakpoint
2453 is still inserted at that location. This in turn breaks
2454 target_read_memory which depends on these buffers when
2455 a memory read is requested at the breakpoint location:
2456 Once the target_info has been wiped, we fail to see that
2457 we have a breakpoint inserted at that address and thus
2458 read the breakpoint instead of returning the data saved in
2459 the breakpoint location's shadow contents. */
2460 bl
->target_info
.reqstd_address
= bl
->address
;
2461 bl
->target_info
.placed_address_space
= bl
->pspace
->aspace
;
2462 bl
->target_info
.length
= bl
->length
;
2464 /* When working with target-side conditions, we must pass all the conditions
2465 for the same breakpoint address down to the target since GDB will not
2466 insert those locations. With a list of breakpoint conditions, the target
2467 can decide when to stop and notify GDB. */
2469 if (is_breakpoint (bl
->owner
))
2471 build_target_condition_list (bl
);
2472 build_target_command_list (bl
);
2473 /* Reset the modification marker. */
2474 bl
->needs_update
= 0;
2477 if (bl
->loc_type
== bp_loc_software_breakpoint
2478 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
2480 if (bl
->owner
->type
!= bp_hardware_breakpoint
)
2482 /* If the explicitly specified breakpoint type
2483 is not hardware breakpoint, check the memory map to see
2484 if the breakpoint address is in read only memory or not.
2486 Two important cases are:
2487 - location type is not hardware breakpoint, memory
2488 is readonly. We change the type of the location to
2489 hardware breakpoint.
2490 - location type is hardware breakpoint, memory is
2491 read-write. This means we've previously made the
2492 location hardware one, but then the memory map changed,
2495 When breakpoints are removed, remove_breakpoints will use
2496 location types we've just set here, the only possible
2497 problem is that memory map has changed during running
2498 program, but it's not going to work anyway with current
2500 struct mem_region
*mr
2501 = lookup_mem_region (bl
->target_info
.reqstd_address
);
2505 if (automatic_hardware_breakpoints
)
2507 enum bp_loc_type new_type
;
2509 if (mr
->attrib
.mode
!= MEM_RW
)
2510 new_type
= bp_loc_hardware_breakpoint
;
2512 new_type
= bp_loc_software_breakpoint
;
2514 if (new_type
!= bl
->loc_type
)
2516 static int said
= 0;
2518 bl
->loc_type
= new_type
;
2521 fprintf_filtered (gdb_stdout
,
2522 _("Note: automatically using "
2523 "hardware breakpoints for "
2524 "read-only addresses.\n"));
2529 else if (bl
->loc_type
== bp_loc_software_breakpoint
2530 && mr
->attrib
.mode
!= MEM_RW
)
2532 fprintf_unfiltered (tmp_error_stream
,
2533 _("Cannot insert breakpoint %d.\n"
2534 "Cannot set software breakpoint "
2535 "at read-only address %s\n"),
2537 paddress (bl
->gdbarch
, bl
->address
));
2543 /* First check to see if we have to handle an overlay. */
2544 if (overlay_debugging
== ovly_off
2545 || bl
->section
== NULL
2546 || !(section_is_overlay (bl
->section
)))
2548 /* No overlay handling: just set the breakpoint. */
2553 val
= bl
->owner
->ops
->insert_location (bl
);
2555 bp_excpt
= gdb_exception
{RETURN_ERROR
, GENERIC_ERROR
};
2557 CATCH (e
, RETURN_MASK_ALL
)
2565 /* This breakpoint is in an overlay section.
2566 Shall we set a breakpoint at the LMA? */
2567 if (!overlay_events_enabled
)
2569 /* Yes -- overlay event support is not active,
2570 so we must try to set a breakpoint at the LMA.
2571 This will not work for a hardware breakpoint. */
2572 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
2573 warning (_("hardware breakpoint %d not supported in overlay!"),
2577 CORE_ADDR addr
= overlay_unmapped_address (bl
->address
,
2579 /* Set a software (trap) breakpoint at the LMA. */
2580 bl
->overlay_target_info
= bl
->target_info
;
2581 bl
->overlay_target_info
.reqstd_address
= addr
;
2583 /* No overlay handling: just set the breakpoint. */
2588 bl
->overlay_target_info
.kind
2589 = breakpoint_kind (bl
, &addr
);
2590 bl
->overlay_target_info
.placed_address
= addr
;
2591 val
= target_insert_breakpoint (bl
->gdbarch
,
2592 &bl
->overlay_target_info
);
2595 = gdb_exception
{RETURN_ERROR
, GENERIC_ERROR
};
2597 CATCH (e
, RETURN_MASK_ALL
)
2603 if (bp_excpt
.reason
!= 0)
2604 fprintf_unfiltered (tmp_error_stream
,
2605 "Overlay breakpoint %d "
2606 "failed: in ROM?\n",
2610 /* Shall we set a breakpoint at the VMA? */
2611 if (section_is_mapped (bl
->section
))
2613 /* Yes. This overlay section is mapped into memory. */
2618 val
= bl
->owner
->ops
->insert_location (bl
);
2620 bp_excpt
= gdb_exception
{RETURN_ERROR
, GENERIC_ERROR
};
2622 CATCH (e
, RETURN_MASK_ALL
)
2630 /* No. This breakpoint will not be inserted.
2631 No error, but do not mark the bp as 'inserted'. */
2636 if (bp_excpt
.reason
!= 0)
2638 /* Can't set the breakpoint. */
2640 /* In some cases, we might not be able to insert a
2641 breakpoint in a shared library that has already been
2642 removed, but we have not yet processed the shlib unload
2643 event. Unfortunately, some targets that implement
2644 breakpoint insertion themselves can't tell why the
2645 breakpoint insertion failed (e.g., the remote target
2646 doesn't define error codes), so we must treat generic
2647 errors as memory errors. */
2648 if (bp_excpt
.reason
== RETURN_ERROR
2649 && (bp_excpt
.error
== GENERIC_ERROR
2650 || bp_excpt
.error
== MEMORY_ERROR
)
2651 && bl
->loc_type
== bp_loc_software_breakpoint
2652 && (solib_name_from_address (bl
->pspace
, bl
->address
)
2653 || shared_objfile_contains_address_p (bl
->pspace
,
2656 /* See also: disable_breakpoints_in_shlibs. */
2657 bl
->shlib_disabled
= 1;
2658 observer_notify_breakpoint_modified (bl
->owner
);
2659 if (!*disabled_breaks
)
2661 fprintf_unfiltered (tmp_error_stream
,
2662 "Cannot insert breakpoint %d.\n",
2664 fprintf_unfiltered (tmp_error_stream
,
2665 "Temporarily disabling shared "
2666 "library breakpoints:\n");
2668 *disabled_breaks
= 1;
2669 fprintf_unfiltered (tmp_error_stream
,
2670 "breakpoint #%d\n", bl
->owner
->number
);
2675 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
2677 *hw_breakpoint_error
= 1;
2678 *hw_bp_error_explained_already
= bp_excpt
.message
!= NULL
;
2679 fprintf_unfiltered (tmp_error_stream
,
2680 "Cannot insert hardware breakpoint %d%s",
2682 bp_excpt
.message
? ":" : ".\n");
2683 if (bp_excpt
.message
!= NULL
)
2684 fprintf_unfiltered (tmp_error_stream
, "%s.\n",
2689 if (bp_excpt
.message
== NULL
)
2692 = memory_error_message (TARGET_XFER_E_IO
,
2693 bl
->gdbarch
, bl
->address
);
2695 fprintf_unfiltered (tmp_error_stream
,
2696 "Cannot insert breakpoint %d.\n"
2698 bl
->owner
->number
, message
.c_str ());
2702 fprintf_unfiltered (tmp_error_stream
,
2703 "Cannot insert breakpoint %d: %s\n",
2718 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
2719 /* NOTE drow/2003-09-08: This state only exists for removing
2720 watchpoints. It's not clear that it's necessary... */
2721 && bl
->owner
->disposition
!= disp_del_at_next_stop
)
2725 gdb_assert (bl
->owner
->ops
!= NULL
2726 && bl
->owner
->ops
->insert_location
!= NULL
);
2728 val
= bl
->owner
->ops
->insert_location (bl
);
2730 /* If trying to set a read-watchpoint, and it turns out it's not
2731 supported, try emulating one with an access watchpoint. */
2732 if (val
== 1 && bl
->watchpoint_type
== hw_read
)
2734 struct bp_location
*loc
, **loc_temp
;
2736 /* But don't try to insert it, if there's already another
2737 hw_access location that would be considered a duplicate
2739 ALL_BP_LOCATIONS (loc
, loc_temp
)
2741 && loc
->watchpoint_type
== hw_access
2742 && watchpoint_locations_match (bl
, loc
))
2746 bl
->target_info
= loc
->target_info
;
2747 bl
->watchpoint_type
= hw_access
;
2754 bl
->watchpoint_type
= hw_access
;
2755 val
= bl
->owner
->ops
->insert_location (bl
);
2758 /* Back to the original value. */
2759 bl
->watchpoint_type
= hw_read
;
2763 bl
->inserted
= (val
== 0);
2766 else if (bl
->owner
->type
== bp_catchpoint
)
2770 gdb_assert (bl
->owner
->ops
!= NULL
2771 && bl
->owner
->ops
->insert_location
!= NULL
);
2773 val
= bl
->owner
->ops
->insert_location (bl
);
2776 bl
->owner
->enable_state
= bp_disabled
;
2780 Error inserting catchpoint %d: Your system does not support this type\n\
2781 of catchpoint."), bl
->owner
->number
);
2783 warning (_("Error inserting catchpoint %d."), bl
->owner
->number
);
2786 bl
->inserted
= (val
== 0);
2788 /* We've already printed an error message if there was a problem
2789 inserting this catchpoint, and we've disabled the catchpoint,
2790 so just return success. */
2797 /* This function is called when program space PSPACE is about to be
2798 deleted. It takes care of updating breakpoints to not reference
2802 breakpoint_program_space_exit (struct program_space
*pspace
)
2804 struct breakpoint
*b
, *b_temp
;
2805 struct bp_location
*loc
, **loc_temp
;
2807 /* Remove any breakpoint that was set through this program space. */
2808 ALL_BREAKPOINTS_SAFE (b
, b_temp
)
2810 if (b
->pspace
== pspace
)
2811 delete_breakpoint (b
);
2814 /* Breakpoints set through other program spaces could have locations
2815 bound to PSPACE as well. Remove those. */
2816 ALL_BP_LOCATIONS (loc
, loc_temp
)
2818 struct bp_location
*tmp
;
2820 if (loc
->pspace
== pspace
)
2822 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
2823 if (loc
->owner
->loc
== loc
)
2824 loc
->owner
->loc
= loc
->next
;
2826 for (tmp
= loc
->owner
->loc
; tmp
->next
!= NULL
; tmp
= tmp
->next
)
2827 if (tmp
->next
== loc
)
2829 tmp
->next
= loc
->next
;
2835 /* Now update the global location list to permanently delete the
2836 removed locations above. */
2837 update_global_location_list (UGLL_DONT_INSERT
);
2840 /* Make sure all breakpoints are inserted in inferior.
2841 Throws exception on any error.
2842 A breakpoint that is already inserted won't be inserted
2843 again, so calling this function twice is safe. */
2845 insert_breakpoints (void)
2847 struct breakpoint
*bpt
;
2849 ALL_BREAKPOINTS (bpt
)
2850 if (is_hardware_watchpoint (bpt
))
2852 struct watchpoint
*w
= (struct watchpoint
*) bpt
;
2854 update_watchpoint (w
, 0 /* don't reparse. */);
2857 /* Updating watchpoints creates new locations, so update the global
2858 location list. Explicitly tell ugll to insert locations and
2859 ignore breakpoints_always_inserted_mode. */
2860 update_global_location_list (UGLL_INSERT
);
2863 /* Invoke CALLBACK for each of bp_location. */
2866 iterate_over_bp_locations (walk_bp_location_callback callback
)
2868 struct bp_location
*loc
, **loc_tmp
;
2870 ALL_BP_LOCATIONS (loc
, loc_tmp
)
2872 callback (loc
, NULL
);
2876 /* This is used when we need to synch breakpoint conditions between GDB and the
2877 target. It is the case with deleting and disabling of breakpoints when using
2878 always-inserted mode. */
2881 update_inserted_breakpoint_locations (void)
2883 struct bp_location
*bl
, **blp_tmp
;
2886 int disabled_breaks
= 0;
2887 int hw_breakpoint_error
= 0;
2888 int hw_bp_details_reported
= 0;
2890 string_file tmp_error_stream
;
2892 /* Explicitly mark the warning -- this will only be printed if
2893 there was an error. */
2894 tmp_error_stream
.puts ("Warning:\n");
2896 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
2898 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2900 /* We only want to update software breakpoints and hardware
2902 if (!is_breakpoint (bl
->owner
))
2905 /* We only want to update locations that are already inserted
2906 and need updating. This is to avoid unwanted insertion during
2907 deletion of breakpoints. */
2908 if (!bl
->inserted
|| (bl
->inserted
&& !bl
->needs_update
))
2911 switch_to_program_space_and_thread (bl
->pspace
);
2913 /* For targets that support global breakpoints, there's no need
2914 to select an inferior to insert breakpoint to. In fact, even
2915 if we aren't attached to any process yet, we should still
2916 insert breakpoints. */
2917 if (!gdbarch_has_global_breakpoints (target_gdbarch ())
2918 && ptid_equal (inferior_ptid
, null_ptid
))
2921 val
= insert_bp_location (bl
, &tmp_error_stream
, &disabled_breaks
,
2922 &hw_breakpoint_error
, &hw_bp_details_reported
);
2929 target_terminal::ours_for_output ();
2930 error_stream (tmp_error_stream
);
2934 /* Used when starting or continuing the program. */
2937 insert_breakpoint_locations (void)
2939 struct breakpoint
*bpt
;
2940 struct bp_location
*bl
, **blp_tmp
;
2943 int disabled_breaks
= 0;
2944 int hw_breakpoint_error
= 0;
2945 int hw_bp_error_explained_already
= 0;
2947 string_file tmp_error_stream
;
2949 /* Explicitly mark the warning -- this will only be printed if
2950 there was an error. */
2951 tmp_error_stream
.puts ("Warning:\n");
2953 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
2955 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2957 if (!should_be_inserted (bl
) || (bl
->inserted
&& !bl
->needs_update
))
2960 /* There is no point inserting thread-specific breakpoints if
2961 the thread no longer exists. ALL_BP_LOCATIONS bp_location
2962 has BL->OWNER always non-NULL. */
2963 if (bl
->owner
->thread
!= -1
2964 && !valid_global_thread_id (bl
->owner
->thread
))
2967 switch_to_program_space_and_thread (bl
->pspace
);
2969 /* For targets that support global breakpoints, there's no need
2970 to select an inferior to insert breakpoint to. In fact, even
2971 if we aren't attached to any process yet, we should still
2972 insert breakpoints. */
2973 if (!gdbarch_has_global_breakpoints (target_gdbarch ())
2974 && ptid_equal (inferior_ptid
, null_ptid
))
2977 val
= insert_bp_location (bl
, &tmp_error_stream
, &disabled_breaks
,
2978 &hw_breakpoint_error
, &hw_bp_error_explained_already
);
2983 /* If we failed to insert all locations of a watchpoint, remove
2984 them, as half-inserted watchpoint is of limited use. */
2985 ALL_BREAKPOINTS (bpt
)
2987 int some_failed
= 0;
2988 struct bp_location
*loc
;
2990 if (!is_hardware_watchpoint (bpt
))
2993 if (!breakpoint_enabled (bpt
))
2996 if (bpt
->disposition
== disp_del_at_next_stop
)
2999 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
3000 if (!loc
->inserted
&& should_be_inserted (loc
))
3007 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
3009 remove_breakpoint (loc
);
3011 hw_breakpoint_error
= 1;
3012 tmp_error_stream
.printf ("Could not insert "
3013 "hardware watchpoint %d.\n",
3021 /* If a hardware breakpoint or watchpoint was inserted, add a
3022 message about possibly exhausted resources. */
3023 if (hw_breakpoint_error
&& !hw_bp_error_explained_already
)
3025 tmp_error_stream
.printf ("Could not insert hardware breakpoints:\n\
3026 You may have requested too many hardware breakpoints/watchpoints.\n");
3028 target_terminal::ours_for_output ();
3029 error_stream (tmp_error_stream
);
3033 /* Used when the program stops.
3034 Returns zero if successful, or non-zero if there was a problem
3035 removing a breakpoint location. */
3038 remove_breakpoints (void)
3040 struct bp_location
*bl
, **blp_tmp
;
3043 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3045 if (bl
->inserted
&& !is_tracepoint (bl
->owner
))
3046 val
|= remove_breakpoint (bl
);
3051 /* When a thread exits, remove breakpoints that are related to
3055 remove_threaded_breakpoints (struct thread_info
*tp
, int silent
)
3057 struct breakpoint
*b
, *b_tmp
;
3059 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
3061 if (b
->thread
== tp
->global_num
&& user_breakpoint_p (b
))
3063 b
->disposition
= disp_del_at_next_stop
;
3065 printf_filtered (_("\
3066 Thread-specific breakpoint %d deleted - thread %s no longer in the thread list.\n"),
3067 b
->number
, print_thread_id (tp
));
3069 /* Hide it from the user. */
3075 /* Remove breakpoints of process PID. */
3078 remove_breakpoints_pid (int pid
)
3080 struct bp_location
*bl
, **blp_tmp
;
3082 struct inferior
*inf
= find_inferior_pid (pid
);
3084 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3086 if (bl
->pspace
!= inf
->pspace
)
3089 if (bl
->inserted
&& !bl
->target_info
.persist
)
3091 val
= remove_breakpoint (bl
);
3099 static int internal_breakpoint_number
= -1;
3101 /* Set the breakpoint number of B, depending on the value of INTERNAL.
3102 If INTERNAL is non-zero, the breakpoint number will be populated
3103 from internal_breakpoint_number and that variable decremented.
3104 Otherwise the breakpoint number will be populated from
3105 breakpoint_count and that value incremented. Internal breakpoints
3106 do not set the internal var bpnum. */
3108 set_breakpoint_number (int internal
, struct breakpoint
*b
)
3111 b
->number
= internal_breakpoint_number
--;
3114 set_breakpoint_count (breakpoint_count
+ 1);
3115 b
->number
= breakpoint_count
;
3119 static struct breakpoint
*
3120 create_internal_breakpoint (struct gdbarch
*gdbarch
,
3121 CORE_ADDR address
, enum bptype type
,
3122 const struct breakpoint_ops
*ops
)
3124 symtab_and_line sal
;
3126 sal
.section
= find_pc_overlay (sal
.pc
);
3127 sal
.pspace
= current_program_space
;
3129 breakpoint
*b
= set_raw_breakpoint (gdbarch
, sal
, type
, ops
);
3130 b
->number
= internal_breakpoint_number
--;
3131 b
->disposition
= disp_donttouch
;
3136 static const char *const longjmp_names
[] =
3138 "longjmp", "_longjmp", "siglongjmp", "_siglongjmp"
3140 #define NUM_LONGJMP_NAMES ARRAY_SIZE(longjmp_names)
3142 /* Per-objfile data private to breakpoint.c. */
3143 struct breakpoint_objfile_data
3145 /* Minimal symbol for "_ovly_debug_event" (if any). */
3146 struct bound_minimal_symbol overlay_msym
{};
3148 /* Minimal symbol(s) for "longjmp", "siglongjmp", etc. (if any). */
3149 struct bound_minimal_symbol longjmp_msym
[NUM_LONGJMP_NAMES
] {};
3151 /* True if we have looked for longjmp probes. */
3152 int longjmp_searched
= 0;
3154 /* SystemTap probe points for longjmp (if any). These are non-owning
3156 std::vector
<probe
*> longjmp_probes
;
3158 /* Minimal symbol for "std::terminate()" (if any). */
3159 struct bound_minimal_symbol terminate_msym
{};
3161 /* Minimal symbol for "_Unwind_DebugHook" (if any). */
3162 struct bound_minimal_symbol exception_msym
{};
3164 /* True if we have looked for exception probes. */
3165 int exception_searched
= 0;
3167 /* SystemTap probe points for unwinding (if any). These are non-owning
3169 std::vector
<probe
*> exception_probes
;
3172 static const struct objfile_data
*breakpoint_objfile_key
;
3174 /* Minimal symbol not found sentinel. */
3175 static struct minimal_symbol msym_not_found
;
3177 /* Returns TRUE if MSYM point to the "not found" sentinel. */
3180 msym_not_found_p (const struct minimal_symbol
*msym
)
3182 return msym
== &msym_not_found
;
3185 /* Return per-objfile data needed by breakpoint.c.
3186 Allocate the data if necessary. */
3188 static struct breakpoint_objfile_data
*
3189 get_breakpoint_objfile_data (struct objfile
*objfile
)
3191 struct breakpoint_objfile_data
*bp_objfile_data
;
3193 bp_objfile_data
= ((struct breakpoint_objfile_data
*)
3194 objfile_data (objfile
, breakpoint_objfile_key
));
3195 if (bp_objfile_data
== NULL
)
3197 bp_objfile_data
= new breakpoint_objfile_data ();
3198 set_objfile_data (objfile
, breakpoint_objfile_key
, bp_objfile_data
);
3200 return bp_objfile_data
;
3204 free_breakpoint_objfile_data (struct objfile
*obj
, void *data
)
3206 struct breakpoint_objfile_data
*bp_objfile_data
3207 = (struct breakpoint_objfile_data
*) data
;
3209 delete bp_objfile_data
;
3213 create_overlay_event_breakpoint (void)
3215 struct objfile
*objfile
;
3216 const char *const func_name
= "_ovly_debug_event";
3218 ALL_OBJFILES (objfile
)
3220 struct breakpoint
*b
;
3221 struct breakpoint_objfile_data
*bp_objfile_data
;
3223 struct explicit_location explicit_loc
;
3225 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3227 if (msym_not_found_p (bp_objfile_data
->overlay_msym
.minsym
))
3230 if (bp_objfile_data
->overlay_msym
.minsym
== NULL
)
3232 struct bound_minimal_symbol m
;
3234 m
= lookup_minimal_symbol_text (func_name
, objfile
);
3235 if (m
.minsym
== NULL
)
3237 /* Avoid future lookups in this objfile. */
3238 bp_objfile_data
->overlay_msym
.minsym
= &msym_not_found
;
3241 bp_objfile_data
->overlay_msym
= m
;
3244 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->overlay_msym
);
3245 b
= create_internal_breakpoint (get_objfile_arch (objfile
), addr
,
3247 &internal_breakpoint_ops
);
3248 initialize_explicit_location (&explicit_loc
);
3249 explicit_loc
.function_name
= ASTRDUP (func_name
);
3250 b
->location
= new_explicit_location (&explicit_loc
);
3252 if (overlay_debugging
== ovly_auto
)
3254 b
->enable_state
= bp_enabled
;
3255 overlay_events_enabled
= 1;
3259 b
->enable_state
= bp_disabled
;
3260 overlay_events_enabled
= 0;
3266 create_longjmp_master_breakpoint (void)
3268 struct program_space
*pspace
;
3270 scoped_restore_current_program_space restore_pspace
;
3272 ALL_PSPACES (pspace
)
3274 struct objfile
*objfile
;
3276 set_current_program_space (pspace
);
3278 ALL_OBJFILES (objfile
)
3281 struct gdbarch
*gdbarch
;
3282 struct breakpoint_objfile_data
*bp_objfile_data
;
3284 gdbarch
= get_objfile_arch (objfile
);
3286 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3288 if (!bp_objfile_data
->longjmp_searched
)
3290 std::vector
<probe
*> ret
3291 = find_probes_in_objfile (objfile
, "libc", "longjmp");
3295 /* We are only interested in checking one element. */
3298 if (!p
->can_evaluate_arguments ())
3300 /* We cannot use the probe interface here, because it does
3301 not know how to evaluate arguments. */
3305 bp_objfile_data
->longjmp_probes
= ret
;
3306 bp_objfile_data
->longjmp_searched
= 1;
3309 if (!bp_objfile_data
->longjmp_probes
.empty ())
3311 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3313 for (probe
*p
: bp_objfile_data
->longjmp_probes
)
3315 struct breakpoint
*b
;
3317 b
= create_internal_breakpoint (gdbarch
,
3318 p
->get_relocated_address (objfile
),
3320 &internal_breakpoint_ops
);
3321 b
->location
= new_probe_location ("-probe-stap libc:longjmp");
3322 b
->enable_state
= bp_disabled
;
3328 if (!gdbarch_get_longjmp_target_p (gdbarch
))
3331 for (i
= 0; i
< NUM_LONGJMP_NAMES
; i
++)
3333 struct breakpoint
*b
;
3334 const char *func_name
;
3336 struct explicit_location explicit_loc
;
3338 if (msym_not_found_p (bp_objfile_data
->longjmp_msym
[i
].minsym
))
3341 func_name
= longjmp_names
[i
];
3342 if (bp_objfile_data
->longjmp_msym
[i
].minsym
== NULL
)
3344 struct bound_minimal_symbol m
;
3346 m
= lookup_minimal_symbol_text (func_name
, objfile
);
3347 if (m
.minsym
== NULL
)
3349 /* Prevent future lookups in this objfile. */
3350 bp_objfile_data
->longjmp_msym
[i
].minsym
= &msym_not_found
;
3353 bp_objfile_data
->longjmp_msym
[i
] = m
;
3356 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->longjmp_msym
[i
]);
3357 b
= create_internal_breakpoint (gdbarch
, addr
, bp_longjmp_master
,
3358 &internal_breakpoint_ops
);
3359 initialize_explicit_location (&explicit_loc
);
3360 explicit_loc
.function_name
= ASTRDUP (func_name
);
3361 b
->location
= new_explicit_location (&explicit_loc
);
3362 b
->enable_state
= bp_disabled
;
3368 /* Create a master std::terminate breakpoint. */
3370 create_std_terminate_master_breakpoint (void)
3372 struct program_space
*pspace
;
3373 const char *const func_name
= "std::terminate()";
3375 scoped_restore_current_program_space restore_pspace
;
3377 ALL_PSPACES (pspace
)
3379 struct objfile
*objfile
;
3382 set_current_program_space (pspace
);
3384 ALL_OBJFILES (objfile
)
3386 struct breakpoint
*b
;
3387 struct breakpoint_objfile_data
*bp_objfile_data
;
3388 struct explicit_location explicit_loc
;
3390 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3392 if (msym_not_found_p (bp_objfile_data
->terminate_msym
.minsym
))
3395 if (bp_objfile_data
->terminate_msym
.minsym
== NULL
)
3397 struct bound_minimal_symbol m
;
3399 m
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
3400 if (m
.minsym
== NULL
|| (MSYMBOL_TYPE (m
.minsym
) != mst_text
3401 && MSYMBOL_TYPE (m
.minsym
) != mst_file_text
))
3403 /* Prevent future lookups in this objfile. */
3404 bp_objfile_data
->terminate_msym
.minsym
= &msym_not_found
;
3407 bp_objfile_data
->terminate_msym
= m
;
3410 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->terminate_msym
);
3411 b
= create_internal_breakpoint (get_objfile_arch (objfile
), addr
,
3412 bp_std_terminate_master
,
3413 &internal_breakpoint_ops
);
3414 initialize_explicit_location (&explicit_loc
);
3415 explicit_loc
.function_name
= ASTRDUP (func_name
);
3416 b
->location
= new_explicit_location (&explicit_loc
);
3417 b
->enable_state
= bp_disabled
;
3422 /* Install a master breakpoint on the unwinder's debug hook. */
3425 create_exception_master_breakpoint (void)
3427 struct objfile
*objfile
;
3428 const char *const func_name
= "_Unwind_DebugHook";
3430 ALL_OBJFILES (objfile
)
3432 struct breakpoint
*b
;
3433 struct gdbarch
*gdbarch
;
3434 struct breakpoint_objfile_data
*bp_objfile_data
;
3436 struct explicit_location explicit_loc
;
3438 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3440 /* We prefer the SystemTap probe point if it exists. */
3441 if (!bp_objfile_data
->exception_searched
)
3443 std::vector
<probe
*> ret
3444 = find_probes_in_objfile (objfile
, "libgcc", "unwind");
3448 /* We are only interested in checking one element. */
3451 if (!p
->can_evaluate_arguments ())
3453 /* We cannot use the probe interface here, because it does
3454 not know how to evaluate arguments. */
3458 bp_objfile_data
->exception_probes
= ret
;
3459 bp_objfile_data
->exception_searched
= 1;
3462 if (!bp_objfile_data
->exception_probes
.empty ())
3464 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3466 for (probe
*p
: bp_objfile_data
->exception_probes
)
3468 struct breakpoint
*b
;
3470 b
= create_internal_breakpoint (gdbarch
,
3471 p
->get_relocated_address (objfile
),
3472 bp_exception_master
,
3473 &internal_breakpoint_ops
);
3474 b
->location
= new_probe_location ("-probe-stap libgcc:unwind");
3475 b
->enable_state
= bp_disabled
;
3481 /* Otherwise, try the hook function. */
3483 if (msym_not_found_p (bp_objfile_data
->exception_msym
.minsym
))
3486 gdbarch
= get_objfile_arch (objfile
);
3488 if (bp_objfile_data
->exception_msym
.minsym
== NULL
)
3490 struct bound_minimal_symbol debug_hook
;
3492 debug_hook
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
3493 if (debug_hook
.minsym
== NULL
)
3495 bp_objfile_data
->exception_msym
.minsym
= &msym_not_found
;
3499 bp_objfile_data
->exception_msym
= debug_hook
;
3502 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->exception_msym
);
3503 addr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, addr
,
3505 b
= create_internal_breakpoint (gdbarch
, addr
, bp_exception_master
,
3506 &internal_breakpoint_ops
);
3507 initialize_explicit_location (&explicit_loc
);
3508 explicit_loc
.function_name
= ASTRDUP (func_name
);
3509 b
->location
= new_explicit_location (&explicit_loc
);
3510 b
->enable_state
= bp_disabled
;
3514 /* Does B have a location spec? */
3517 breakpoint_event_location_empty_p (const struct breakpoint
*b
)
3519 return b
->location
!= NULL
&& event_location_empty_p (b
->location
.get ());
3523 update_breakpoints_after_exec (void)
3525 struct breakpoint
*b
, *b_tmp
;
3526 struct bp_location
*bploc
, **bplocp_tmp
;
3528 /* We're about to delete breakpoints from GDB's lists. If the
3529 INSERTED flag is true, GDB will try to lift the breakpoints by
3530 writing the breakpoints' "shadow contents" back into memory. The
3531 "shadow contents" are NOT valid after an exec, so GDB should not
3532 do that. Instead, the target is responsible from marking
3533 breakpoints out as soon as it detects an exec. We don't do that
3534 here instead, because there may be other attempts to delete
3535 breakpoints after detecting an exec and before reaching here. */
3536 ALL_BP_LOCATIONS (bploc
, bplocp_tmp
)
3537 if (bploc
->pspace
== current_program_space
)
3538 gdb_assert (!bploc
->inserted
);
3540 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
3542 if (b
->pspace
!= current_program_space
)
3545 /* Solib breakpoints must be explicitly reset after an exec(). */
3546 if (b
->type
== bp_shlib_event
)
3548 delete_breakpoint (b
);
3552 /* JIT breakpoints must be explicitly reset after an exec(). */
3553 if (b
->type
== bp_jit_event
)
3555 delete_breakpoint (b
);
3559 /* Thread event breakpoints must be set anew after an exec(),
3560 as must overlay event and longjmp master breakpoints. */
3561 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
3562 || b
->type
== bp_longjmp_master
|| b
->type
== bp_std_terminate_master
3563 || b
->type
== bp_exception_master
)
3565 delete_breakpoint (b
);
3569 /* Step-resume breakpoints are meaningless after an exec(). */
3570 if (b
->type
== bp_step_resume
|| b
->type
== bp_hp_step_resume
)
3572 delete_breakpoint (b
);
3576 /* Just like single-step breakpoints. */
3577 if (b
->type
== bp_single_step
)
3579 delete_breakpoint (b
);
3583 /* Longjmp and longjmp-resume breakpoints are also meaningless
3585 if (b
->type
== bp_longjmp
|| b
->type
== bp_longjmp_resume
3586 || b
->type
== bp_longjmp_call_dummy
3587 || b
->type
== bp_exception
|| b
->type
== bp_exception_resume
)
3589 delete_breakpoint (b
);
3593 if (b
->type
== bp_catchpoint
)
3595 /* For now, none of the bp_catchpoint breakpoints need to
3596 do anything at this point. In the future, if some of
3597 the catchpoints need to something, we will need to add
3598 a new method, and call this method from here. */
3602 /* bp_finish is a special case. The only way we ought to be able
3603 to see one of these when an exec() has happened, is if the user
3604 caught a vfork, and then said "finish". Ordinarily a finish just
3605 carries them to the call-site of the current callee, by setting
3606 a temporary bp there and resuming. But in this case, the finish
3607 will carry them entirely through the vfork & exec.
3609 We don't want to allow a bp_finish to remain inserted now. But
3610 we can't safely delete it, 'cause finish_command has a handle to
3611 the bp on a bpstat, and will later want to delete it. There's a
3612 chance (and I've seen it happen) that if we delete the bp_finish
3613 here, that its storage will get reused by the time finish_command
3614 gets 'round to deleting the "use to be a bp_finish" breakpoint.
3615 We really must allow finish_command to delete a bp_finish.
3617 In the absence of a general solution for the "how do we know
3618 it's safe to delete something others may have handles to?"
3619 problem, what we'll do here is just uninsert the bp_finish, and
3620 let finish_command delete it.
3622 (We know the bp_finish is "doomed" in the sense that it's
3623 momentary, and will be deleted as soon as finish_command sees
3624 the inferior stopped. So it doesn't matter that the bp's
3625 address is probably bogus in the new a.out, unlike e.g., the
3626 solib breakpoints.) */
3628 if (b
->type
== bp_finish
)
3633 /* Without a symbolic address, we have little hope of the
3634 pre-exec() address meaning the same thing in the post-exec()
3636 if (breakpoint_event_location_empty_p (b
))
3638 delete_breakpoint (b
);
3645 detach_breakpoints (ptid_t ptid
)
3647 struct bp_location
*bl
, **blp_tmp
;
3649 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
3650 struct inferior
*inf
= current_inferior ();
3652 if (ptid_get_pid (ptid
) == ptid_get_pid (inferior_ptid
))
3653 error (_("Cannot detach breakpoints of inferior_ptid"));
3655 /* Set inferior_ptid; remove_breakpoint_1 uses this global. */
3656 inferior_ptid
= ptid
;
3657 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3659 if (bl
->pspace
!= inf
->pspace
)
3662 /* This function must physically remove breakpoints locations
3663 from the specified ptid, without modifying the breakpoint
3664 package's state. Locations of type bp_loc_other are only
3665 maintained at GDB side. So, there is no need to remove
3666 these bp_loc_other locations. Moreover, removing these
3667 would modify the breakpoint package's state. */
3668 if (bl
->loc_type
== bp_loc_other
)
3672 val
|= remove_breakpoint_1 (bl
, DETACH_BREAKPOINT
);
3678 /* Remove the breakpoint location BL from the current address space.
3679 Note that this is used to detach breakpoints from a child fork.
3680 When we get here, the child isn't in the inferior list, and neither
3681 do we have objects to represent its address space --- we should
3682 *not* look at bl->pspace->aspace here. */
3685 remove_breakpoint_1 (struct bp_location
*bl
, enum remove_bp_reason reason
)
3689 /* BL is never in moribund_locations by our callers. */
3690 gdb_assert (bl
->owner
!= NULL
);
3692 /* The type of none suggests that owner is actually deleted.
3693 This should not ever happen. */
3694 gdb_assert (bl
->owner
->type
!= bp_none
);
3696 if (bl
->loc_type
== bp_loc_software_breakpoint
3697 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
3699 /* "Normal" instruction breakpoint: either the standard
3700 trap-instruction bp (bp_breakpoint), or a
3701 bp_hardware_breakpoint. */
3703 /* First check to see if we have to handle an overlay. */
3704 if (overlay_debugging
== ovly_off
3705 || bl
->section
== NULL
3706 || !(section_is_overlay (bl
->section
)))
3708 /* No overlay handling: just remove the breakpoint. */
3710 /* If we're trying to uninsert a memory breakpoint that we
3711 know is set in a dynamic object that is marked
3712 shlib_disabled, then either the dynamic object was
3713 removed with "remove-symbol-file" or with
3714 "nosharedlibrary". In the former case, we don't know
3715 whether another dynamic object might have loaded over the
3716 breakpoint's address -- the user might well let us know
3717 about it next with add-symbol-file (the whole point of
3718 add-symbol-file is letting the user manually maintain a
3719 list of dynamically loaded objects). If we have the
3720 breakpoint's shadow memory, that is, this is a software
3721 breakpoint managed by GDB, check whether the breakpoint
3722 is still inserted in memory, to avoid overwriting wrong
3723 code with stale saved shadow contents. Note that HW
3724 breakpoints don't have shadow memory, as they're
3725 implemented using a mechanism that is not dependent on
3726 being able to modify the target's memory, and as such
3727 they should always be removed. */
3728 if (bl
->shlib_disabled
3729 && bl
->target_info
.shadow_len
!= 0
3730 && !memory_validate_breakpoint (bl
->gdbarch
, &bl
->target_info
))
3733 val
= bl
->owner
->ops
->remove_location (bl
, reason
);
3737 /* This breakpoint is in an overlay section.
3738 Did we set a breakpoint at the LMA? */
3739 if (!overlay_events_enabled
)
3741 /* Yes -- overlay event support is not active, so we
3742 should have set a breakpoint at the LMA. Remove it.
3744 /* Ignore any failures: if the LMA is in ROM, we will
3745 have already warned when we failed to insert it. */
3746 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
3747 target_remove_hw_breakpoint (bl
->gdbarch
,
3748 &bl
->overlay_target_info
);
3750 target_remove_breakpoint (bl
->gdbarch
,
3751 &bl
->overlay_target_info
,
3754 /* Did we set a breakpoint at the VMA?
3755 If so, we will have marked the breakpoint 'inserted'. */
3758 /* Yes -- remove it. Previously we did not bother to
3759 remove the breakpoint if the section had been
3760 unmapped, but let's not rely on that being safe. We
3761 don't know what the overlay manager might do. */
3763 /* However, we should remove *software* breakpoints only
3764 if the section is still mapped, or else we overwrite
3765 wrong code with the saved shadow contents. */
3766 if (bl
->loc_type
== bp_loc_hardware_breakpoint
3767 || section_is_mapped (bl
->section
))
3768 val
= bl
->owner
->ops
->remove_location (bl
, reason
);
3774 /* No -- not inserted, so no need to remove. No error. */
3779 /* In some cases, we might not be able to remove a breakpoint in
3780 a shared library that has already been removed, but we have
3781 not yet processed the shlib unload event. Similarly for an
3782 unloaded add-symbol-file object - the user might not yet have
3783 had the chance to remove-symbol-file it. shlib_disabled will
3784 be set if the library/object has already been removed, but
3785 the breakpoint hasn't been uninserted yet, e.g., after
3786 "nosharedlibrary" or "remove-symbol-file" with breakpoints
3787 always-inserted mode. */
3789 && (bl
->loc_type
== bp_loc_software_breakpoint
3790 && (bl
->shlib_disabled
3791 || solib_name_from_address (bl
->pspace
, bl
->address
)
3792 || shared_objfile_contains_address_p (bl
->pspace
,
3798 bl
->inserted
= (reason
== DETACH_BREAKPOINT
);
3800 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
)
3802 gdb_assert (bl
->owner
->ops
!= NULL
3803 && bl
->owner
->ops
->remove_location
!= NULL
);
3805 bl
->inserted
= (reason
== DETACH_BREAKPOINT
);
3806 bl
->owner
->ops
->remove_location (bl
, reason
);
3808 /* Failure to remove any of the hardware watchpoints comes here. */
3809 if (reason
== REMOVE_BREAKPOINT
&& bl
->inserted
)
3810 warning (_("Could not remove hardware watchpoint %d."),
3813 else if (bl
->owner
->type
== bp_catchpoint
3814 && breakpoint_enabled (bl
->owner
)
3817 gdb_assert (bl
->owner
->ops
!= NULL
3818 && bl
->owner
->ops
->remove_location
!= NULL
);
3820 val
= bl
->owner
->ops
->remove_location (bl
, reason
);
3824 bl
->inserted
= (reason
== DETACH_BREAKPOINT
);
3831 remove_breakpoint (struct bp_location
*bl
)
3833 /* BL is never in moribund_locations by our callers. */
3834 gdb_assert (bl
->owner
!= NULL
);
3836 /* The type of none suggests that owner is actually deleted.
3837 This should not ever happen. */
3838 gdb_assert (bl
->owner
->type
!= bp_none
);
3840 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
3842 switch_to_program_space_and_thread (bl
->pspace
);
3844 return remove_breakpoint_1 (bl
, REMOVE_BREAKPOINT
);
3847 /* Clear the "inserted" flag in all breakpoints. */
3850 mark_breakpoints_out (void)
3852 struct bp_location
*bl
, **blp_tmp
;
3854 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3855 if (bl
->pspace
== current_program_space
)
3859 /* Clear the "inserted" flag in all breakpoints and delete any
3860 breakpoints which should go away between runs of the program.
3862 Plus other such housekeeping that has to be done for breakpoints
3865 Note: this function gets called at the end of a run (by
3866 generic_mourn_inferior) and when a run begins (by
3867 init_wait_for_inferior). */
3872 breakpoint_init_inferior (enum inf_context context
)
3874 struct breakpoint
*b
, *b_tmp
;
3875 struct bp_location
*bl
;
3877 struct program_space
*pspace
= current_program_space
;
3879 /* If breakpoint locations are shared across processes, then there's
3881 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
3884 mark_breakpoints_out ();
3886 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
3888 if (b
->loc
&& b
->loc
->pspace
!= pspace
)
3894 case bp_longjmp_call_dummy
:
3896 /* If the call dummy breakpoint is at the entry point it will
3897 cause problems when the inferior is rerun, so we better get
3900 case bp_watchpoint_scope
:
3902 /* Also get rid of scope breakpoints. */
3904 case bp_shlib_event
:
3906 /* Also remove solib event breakpoints. Their addresses may
3907 have changed since the last time we ran the program.
3908 Actually we may now be debugging against different target;
3909 and so the solib backend that installed this breakpoint may
3910 not be used in by the target. E.g.,
3912 (gdb) file prog-linux
3913 (gdb) run # native linux target
3916 (gdb) file prog-win.exe
3917 (gdb) tar rem :9999 # remote Windows gdbserver.
3920 case bp_step_resume
:
3922 /* Also remove step-resume breakpoints. */
3924 case bp_single_step
:
3926 /* Also remove single-step breakpoints. */
3928 delete_breakpoint (b
);
3932 case bp_hardware_watchpoint
:
3933 case bp_read_watchpoint
:
3934 case bp_access_watchpoint
:
3936 struct watchpoint
*w
= (struct watchpoint
*) b
;
3938 /* Likewise for watchpoints on local expressions. */
3939 if (w
->exp_valid_block
!= NULL
)
3940 delete_breakpoint (b
);
3943 /* Get rid of existing locations, which are no longer
3944 valid. New ones will be created in
3945 update_watchpoint, when the inferior is restarted.
3946 The next update_global_location_list call will
3947 garbage collect them. */
3950 if (context
== inf_starting
)
3952 /* Reset val field to force reread of starting value in
3953 insert_breakpoints. */
3955 value_free (w
->val
);
3967 /* Get rid of the moribund locations. */
3968 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, bl
); ++ix
)
3969 decref_bp_location (&bl
);
3970 VEC_free (bp_location_p
, moribund_locations
);
3973 /* These functions concern about actual breakpoints inserted in the
3974 target --- to e.g. check if we need to do decr_pc adjustment or if
3975 we need to hop over the bkpt --- so we check for address space
3976 match, not program space. */
3978 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
3979 exists at PC. It returns ordinary_breakpoint_here if it's an
3980 ordinary breakpoint, or permanent_breakpoint_here if it's a
3981 permanent breakpoint.
3982 - When continuing from a location with an ordinary breakpoint, we
3983 actually single step once before calling insert_breakpoints.
3984 - When continuing from a location with a permanent breakpoint, we
3985 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
3986 the target, to advance the PC past the breakpoint. */
3988 enum breakpoint_here
3989 breakpoint_here_p (const address_space
*aspace
, CORE_ADDR pc
)
3991 struct bp_location
*bl
, **blp_tmp
;
3992 int any_breakpoint_here
= 0;
3994 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3996 if (bl
->loc_type
!= bp_loc_software_breakpoint
3997 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4000 /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
4001 if ((breakpoint_enabled (bl
->owner
)
4003 && breakpoint_location_address_match (bl
, aspace
, pc
))
4005 if (overlay_debugging
4006 && section_is_overlay (bl
->section
)
4007 && !section_is_mapped (bl
->section
))
4008 continue; /* unmapped overlay -- can't be a match */
4009 else if (bl
->permanent
)
4010 return permanent_breakpoint_here
;
4012 any_breakpoint_here
= 1;
4016 return any_breakpoint_here
? ordinary_breakpoint_here
: no_breakpoint_here
;
4019 /* See breakpoint.h. */
4022 breakpoint_in_range_p (const address_space
*aspace
,
4023 CORE_ADDR addr
, ULONGEST len
)
4025 struct bp_location
*bl
, **blp_tmp
;
4027 ALL_BP_LOCATIONS (bl
, blp_tmp
)
4029 if (bl
->loc_type
!= bp_loc_software_breakpoint
4030 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4033 if ((breakpoint_enabled (bl
->owner
)
4035 && breakpoint_location_address_range_overlap (bl
, aspace
,
4038 if (overlay_debugging
4039 && section_is_overlay (bl
->section
)
4040 && !section_is_mapped (bl
->section
))
4042 /* Unmapped overlay -- can't be a match. */
4053 /* Return true if there's a moribund breakpoint at PC. */
4056 moribund_breakpoint_here_p (const address_space
*aspace
, CORE_ADDR pc
)
4058 struct bp_location
*loc
;
4061 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
4062 if (breakpoint_location_address_match (loc
, aspace
, pc
))
4068 /* Returns non-zero iff BL is inserted at PC, in address space
4072 bp_location_inserted_here_p (struct bp_location
*bl
,
4073 const address_space
*aspace
, CORE_ADDR pc
)
4076 && breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
4079 if (overlay_debugging
4080 && section_is_overlay (bl
->section
)
4081 && !section_is_mapped (bl
->section
))
4082 return 0; /* unmapped overlay -- can't be a match */
4089 /* Returns non-zero iff there's a breakpoint inserted at PC. */
4092 breakpoint_inserted_here_p (const address_space
*aspace
, CORE_ADDR pc
)
4094 struct bp_location
**blp
, **blp_tmp
= NULL
;
4096 ALL_BP_LOCATIONS_AT_ADDR (blp
, blp_tmp
, pc
)
4098 struct bp_location
*bl
= *blp
;
4100 if (bl
->loc_type
!= bp_loc_software_breakpoint
4101 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4104 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4110 /* This function returns non-zero iff there is a software breakpoint
4114 software_breakpoint_inserted_here_p (const address_space
*aspace
,
4117 struct bp_location
**blp
, **blp_tmp
= NULL
;
4119 ALL_BP_LOCATIONS_AT_ADDR (blp
, blp_tmp
, pc
)
4121 struct bp_location
*bl
= *blp
;
4123 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
4126 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4133 /* See breakpoint.h. */
4136 hardware_breakpoint_inserted_here_p (const address_space
*aspace
,
4139 struct bp_location
**blp
, **blp_tmp
= NULL
;
4141 ALL_BP_LOCATIONS_AT_ADDR (blp
, blp_tmp
, pc
)
4143 struct bp_location
*bl
= *blp
;
4145 if (bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4148 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4156 hardware_watchpoint_inserted_in_range (const address_space
*aspace
,
4157 CORE_ADDR addr
, ULONGEST len
)
4159 struct breakpoint
*bpt
;
4161 ALL_BREAKPOINTS (bpt
)
4163 struct bp_location
*loc
;
4165 if (bpt
->type
!= bp_hardware_watchpoint
4166 && bpt
->type
!= bp_access_watchpoint
)
4169 if (!breakpoint_enabled (bpt
))
4172 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
4173 if (loc
->pspace
->aspace
== aspace
&& loc
->inserted
)
4177 /* Check for intersection. */
4178 l
= std::max
<CORE_ADDR
> (loc
->address
, addr
);
4179 h
= std::min
<CORE_ADDR
> (loc
->address
+ loc
->length
, addr
+ len
);
4188 /* bpstat stuff. External routines' interfaces are documented
4192 is_catchpoint (struct breakpoint
*ep
)
4194 return (ep
->type
== bp_catchpoint
);
4197 /* Frees any storage that is part of a bpstat. Does not walk the
4200 bpstats::~bpstats ()
4202 if (old_val
!= NULL
)
4203 value_free (old_val
);
4204 if (bp_location_at
!= NULL
)
4205 decref_bp_location (&bp_location_at
);
4208 /* Clear a bpstat so that it says we are not at any breakpoint.
4209 Also free any storage that is part of a bpstat. */
4212 bpstat_clear (bpstat
*bsp
)
4229 bpstats::bpstats (const bpstats
&other
)
4231 bp_location_at (other
.bp_location_at
),
4232 breakpoint_at (other
.breakpoint_at
),
4233 commands (other
.commands
),
4234 old_val (other
.old_val
),
4235 print (other
.print
),
4237 print_it (other
.print_it
)
4239 if (old_val
!= NULL
)
4241 old_val
= value_copy (old_val
);
4242 release_value (old_val
);
4244 incref_bp_location (bp_location_at
);
4247 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
4248 is part of the bpstat is copied as well. */
4251 bpstat_copy (bpstat bs
)
4255 bpstat retval
= NULL
;
4260 for (; bs
!= NULL
; bs
= bs
->next
)
4262 tmp
= new bpstats (*bs
);
4265 /* This is the first thing in the chain. */
4275 /* Find the bpstat associated with this breakpoint. */
4278 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
4283 for (; bsp
!= NULL
; bsp
= bsp
->next
)
4285 if (bsp
->breakpoint_at
== breakpoint
)
4291 /* See breakpoint.h. */
4294 bpstat_explains_signal (bpstat bsp
, enum gdb_signal sig
)
4296 for (; bsp
!= NULL
; bsp
= bsp
->next
)
4298 if (bsp
->breakpoint_at
== NULL
)
4300 /* A moribund location can never explain a signal other than
4302 if (sig
== GDB_SIGNAL_TRAP
)
4307 if (bsp
->breakpoint_at
->ops
->explains_signal (bsp
->breakpoint_at
,
4316 /* Put in *NUM the breakpoint number of the first breakpoint we are
4317 stopped at. *BSP upon return is a bpstat which points to the
4318 remaining breakpoints stopped at (but which is not guaranteed to be
4319 good for anything but further calls to bpstat_num).
4321 Return 0 if passed a bpstat which does not indicate any breakpoints.
4322 Return -1 if stopped at a breakpoint that has been deleted since
4324 Return 1 otherwise. */
4327 bpstat_num (bpstat
*bsp
, int *num
)
4329 struct breakpoint
*b
;
4332 return 0; /* No more breakpoint values */
4334 /* We assume we'll never have several bpstats that correspond to a
4335 single breakpoint -- otherwise, this function might return the
4336 same number more than once and this will look ugly. */
4337 b
= (*bsp
)->breakpoint_at
;
4338 *bsp
= (*bsp
)->next
;
4340 return -1; /* breakpoint that's been deleted since */
4342 *num
= b
->number
; /* We have its number */
4346 /* See breakpoint.h. */
4349 bpstat_clear_actions (void)
4351 struct thread_info
*tp
;
4354 if (ptid_equal (inferior_ptid
, null_ptid
))
4357 tp
= find_thread_ptid (inferior_ptid
);
4361 for (bs
= tp
->control
.stop_bpstat
; bs
!= NULL
; bs
= bs
->next
)
4363 bs
->commands
= NULL
;
4365 if (bs
->old_val
!= NULL
)
4367 value_free (bs
->old_val
);
4373 /* Called when a command is about to proceed the inferior. */
4376 breakpoint_about_to_proceed (void)
4378 if (!ptid_equal (inferior_ptid
, null_ptid
))
4380 struct thread_info
*tp
= inferior_thread ();
4382 /* Allow inferior function calls in breakpoint commands to not
4383 interrupt the command list. When the call finishes
4384 successfully, the inferior will be standing at the same
4385 breakpoint as if nothing happened. */
4386 if (tp
->control
.in_infcall
)
4390 breakpoint_proceeded
= 1;
4393 /* Return non-zero iff CMD as the first line of a command sequence is `silent'
4394 or its equivalent. */
4397 command_line_is_silent (struct command_line
*cmd
)
4399 return cmd
&& (strcmp ("silent", cmd
->line
) == 0);
4402 /* Execute all the commands associated with all the breakpoints at
4403 this location. Any of these commands could cause the process to
4404 proceed beyond this point, etc. We look out for such changes by
4405 checking the global "breakpoint_proceeded" after each command.
4407 Returns true if a breakpoint command resumed the inferior. In that
4408 case, it is the caller's responsibility to recall it again with the
4409 bpstat of the current thread. */
4412 bpstat_do_actions_1 (bpstat
*bsp
)
4417 /* Avoid endless recursion if a `source' command is contained
4419 if (executing_breakpoint_commands
)
4422 scoped_restore save_executing
4423 = make_scoped_restore (&executing_breakpoint_commands
, 1);
4425 scoped_restore preventer
= prevent_dont_repeat ();
4427 /* This pointer will iterate over the list of bpstat's. */
4430 breakpoint_proceeded
= 0;
4431 for (; bs
!= NULL
; bs
= bs
->next
)
4433 struct command_line
*cmd
= NULL
;
4435 /* Take ownership of the BSP's command tree, if it has one.
4437 The command tree could legitimately contain commands like
4438 'step' and 'next', which call clear_proceed_status, which
4439 frees stop_bpstat's command tree. To make sure this doesn't
4440 free the tree we're executing out from under us, we need to
4441 take ownership of the tree ourselves. Since a given bpstat's
4442 commands are only executed once, we don't need to copy it; we
4443 can clear the pointer in the bpstat, and make sure we free
4444 the tree when we're done. */
4445 counted_command_line ccmd
= bs
->commands
;
4446 bs
->commands
= NULL
;
4449 if (command_line_is_silent (cmd
))
4451 /* The action has been already done by bpstat_stop_status. */
4457 execute_control_command (cmd
);
4459 if (breakpoint_proceeded
)
4465 if (breakpoint_proceeded
)
4467 if (current_ui
->async
)
4468 /* If we are in async mode, then the target might be still
4469 running, not stopped at any breakpoint, so nothing for
4470 us to do here -- just return to the event loop. */
4473 /* In sync mode, when execute_control_command returns
4474 we're already standing on the next breakpoint.
4475 Breakpoint commands for that stop were not run, since
4476 execute_command does not run breakpoint commands --
4477 only command_line_handler does, but that one is not
4478 involved in execution of breakpoint commands. So, we
4479 can now execute breakpoint commands. It should be
4480 noted that making execute_command do bpstat actions is
4481 not an option -- in this case we'll have recursive
4482 invocation of bpstat for each breakpoint with a
4483 command, and can easily blow up GDB stack. Instead, we
4484 return true, which will trigger the caller to recall us
4485 with the new stop_bpstat. */
4494 bpstat_do_actions (void)
4496 struct cleanup
*cleanup_if_error
= make_bpstat_clear_actions_cleanup ();
4498 /* Do any commands attached to breakpoint we are stopped at. */
4499 while (!ptid_equal (inferior_ptid
, null_ptid
)
4500 && target_has_execution
4501 && !is_exited (inferior_ptid
)
4502 && !is_executing (inferior_ptid
))
4503 /* Since in sync mode, bpstat_do_actions may resume the inferior,
4504 and only return when it is stopped at the next breakpoint, we
4505 keep doing breakpoint actions until it returns false to
4506 indicate the inferior was not resumed. */
4507 if (!bpstat_do_actions_1 (&inferior_thread ()->control
.stop_bpstat
))
4510 discard_cleanups (cleanup_if_error
);
4513 /* Print out the (old or new) value associated with a watchpoint. */
4516 watchpoint_value_print (struct value
*val
, struct ui_file
*stream
)
4519 fprintf_unfiltered (stream
, _("<unreadable>"));
4522 struct value_print_options opts
;
4523 get_user_print_options (&opts
);
4524 value_print (val
, stream
, &opts
);
4528 /* Print the "Thread ID hit" part of "Thread ID hit Breakpoint N" if
4529 debugging multiple threads. */
4532 maybe_print_thread_hit_breakpoint (struct ui_out
*uiout
)
4534 if (uiout
->is_mi_like_p ())
4539 if (show_thread_that_caused_stop ())
4542 struct thread_info
*thr
= inferior_thread ();
4544 uiout
->text ("Thread ");
4545 uiout
->field_fmt ("thread-id", "%s", print_thread_id (thr
));
4547 name
= thr
->name
!= NULL
? thr
->name
: target_thread_name (thr
);
4550 uiout
->text (" \"");
4551 uiout
->field_fmt ("name", "%s", name
);
4555 uiout
->text (" hit ");
4559 /* Generic routine for printing messages indicating why we
4560 stopped. The behavior of this function depends on the value
4561 'print_it' in the bpstat structure. Under some circumstances we
4562 may decide not to print anything here and delegate the task to
4565 static enum print_stop_action
4566 print_bp_stop_message (bpstat bs
)
4568 switch (bs
->print_it
)
4571 /* Nothing should be printed for this bpstat entry. */
4572 return PRINT_UNKNOWN
;
4576 /* We still want to print the frame, but we already printed the
4577 relevant messages. */
4578 return PRINT_SRC_AND_LOC
;
4581 case print_it_normal
:
4583 struct breakpoint
*b
= bs
->breakpoint_at
;
4585 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
4586 which has since been deleted. */
4588 return PRINT_UNKNOWN
;
4590 /* Normal case. Call the breakpoint's print_it method. */
4591 return b
->ops
->print_it (bs
);
4596 internal_error (__FILE__
, __LINE__
,
4597 _("print_bp_stop_message: unrecognized enum value"));
4602 /* A helper function that prints a shared library stopped event. */
4605 print_solib_event (int is_catchpoint
)
4608 = !VEC_empty (char_ptr
, current_program_space
->deleted_solibs
);
4610 = !VEC_empty (so_list_ptr
, current_program_space
->added_solibs
);
4614 if (any_added
|| any_deleted
)
4615 current_uiout
->text (_("Stopped due to shared library event:\n"));
4617 current_uiout
->text (_("Stopped due to shared library event (no "
4618 "libraries added or removed)\n"));
4621 if (current_uiout
->is_mi_like_p ())
4622 current_uiout
->field_string ("reason",
4623 async_reason_lookup (EXEC_ASYNC_SOLIB_EVENT
));
4630 current_uiout
->text (_(" Inferior unloaded "));
4631 ui_out_emit_list
list_emitter (current_uiout
, "removed");
4633 VEC_iterate (char_ptr
, current_program_space
->deleted_solibs
,
4638 current_uiout
->text (" ");
4639 current_uiout
->field_string ("library", name
);
4640 current_uiout
->text ("\n");
4646 struct so_list
*iter
;
4649 current_uiout
->text (_(" Inferior loaded "));
4650 ui_out_emit_list
list_emitter (current_uiout
, "added");
4652 VEC_iterate (so_list_ptr
, current_program_space
->added_solibs
,
4657 current_uiout
->text (" ");
4658 current_uiout
->field_string ("library", iter
->so_name
);
4659 current_uiout
->text ("\n");
4664 /* Print a message indicating what happened. This is called from
4665 normal_stop(). The input to this routine is the head of the bpstat
4666 list - a list of the eventpoints that caused this stop. KIND is
4667 the target_waitkind for the stopping event. This
4668 routine calls the generic print routine for printing a message
4669 about reasons for stopping. This will print (for example) the
4670 "Breakpoint n," part of the output. The return value of this
4673 PRINT_UNKNOWN: Means we printed nothing.
4674 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
4675 code to print the location. An example is
4676 "Breakpoint 1, " which should be followed by
4678 PRINT_SRC_ONLY: Means we printed something, but there is no need
4679 to also print the location part of the message.
4680 An example is the catch/throw messages, which
4681 don't require a location appended to the end.
4682 PRINT_NOTHING: We have done some printing and we don't need any
4683 further info to be printed. */
4685 enum print_stop_action
4686 bpstat_print (bpstat bs
, int kind
)
4688 enum print_stop_action val
;
4690 /* Maybe another breakpoint in the chain caused us to stop.
4691 (Currently all watchpoints go on the bpstat whether hit or not.
4692 That probably could (should) be changed, provided care is taken
4693 with respect to bpstat_explains_signal). */
4694 for (; bs
; bs
= bs
->next
)
4696 val
= print_bp_stop_message (bs
);
4697 if (val
== PRINT_SRC_ONLY
4698 || val
== PRINT_SRC_AND_LOC
4699 || val
== PRINT_NOTHING
)
4703 /* If we had hit a shared library event breakpoint,
4704 print_bp_stop_message would print out this message. If we hit an
4705 OS-level shared library event, do the same thing. */
4706 if (kind
== TARGET_WAITKIND_LOADED
)
4708 print_solib_event (0);
4709 return PRINT_NOTHING
;
4712 /* We reached the end of the chain, or we got a null BS to start
4713 with and nothing was printed. */
4714 return PRINT_UNKNOWN
;
4717 /* Evaluate the boolean expression EXP and return the result. */
4720 breakpoint_cond_eval (expression
*exp
)
4722 struct value
*mark
= value_mark ();
4723 bool res
= value_true (evaluate_expression (exp
));
4725 value_free_to_mark (mark
);
4729 /* Allocate a new bpstat. Link it to the FIFO list by BS_LINK_POINTER. */
4731 bpstats::bpstats (struct bp_location
*bl
, bpstat
**bs_link_pointer
)
4733 bp_location_at (bl
),
4734 breakpoint_at (bl
->owner
),
4739 print_it (print_it_normal
)
4741 incref_bp_location (bl
);
4742 **bs_link_pointer
= this;
4743 *bs_link_pointer
= &next
;
4748 bp_location_at (NULL
),
4749 breakpoint_at (NULL
),
4754 print_it (print_it_normal
)
4758 /* The target has stopped with waitstatus WS. Check if any hardware
4759 watchpoints have triggered, according to the target. */
4762 watchpoints_triggered (struct target_waitstatus
*ws
)
4764 int stopped_by_watchpoint
= target_stopped_by_watchpoint ();
4766 struct breakpoint
*b
;
4768 if (!stopped_by_watchpoint
)
4770 /* We were not stopped by a watchpoint. Mark all watchpoints
4771 as not triggered. */
4773 if (is_hardware_watchpoint (b
))
4775 struct watchpoint
*w
= (struct watchpoint
*) b
;
4777 w
->watchpoint_triggered
= watch_triggered_no
;
4783 if (!target_stopped_data_address (¤t_target
, &addr
))
4785 /* We were stopped by a watchpoint, but we don't know where.
4786 Mark all watchpoints as unknown. */
4788 if (is_hardware_watchpoint (b
))
4790 struct watchpoint
*w
= (struct watchpoint
*) b
;
4792 w
->watchpoint_triggered
= watch_triggered_unknown
;
4798 /* The target could report the data address. Mark watchpoints
4799 affected by this data address as triggered, and all others as not
4803 if (is_hardware_watchpoint (b
))
4805 struct watchpoint
*w
= (struct watchpoint
*) b
;
4806 struct bp_location
*loc
;
4808 w
->watchpoint_triggered
= watch_triggered_no
;
4809 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
4811 if (is_masked_watchpoint (b
))
4813 CORE_ADDR newaddr
= addr
& w
->hw_wp_mask
;
4814 CORE_ADDR start
= loc
->address
& w
->hw_wp_mask
;
4816 if (newaddr
== start
)
4818 w
->watchpoint_triggered
= watch_triggered_yes
;
4822 /* Exact match not required. Within range is sufficient. */
4823 else if (target_watchpoint_addr_within_range (¤t_target
,
4827 w
->watchpoint_triggered
= watch_triggered_yes
;
4836 /* Possible return values for watchpoint_check. */
4837 enum wp_check_result
4839 /* The watchpoint has been deleted. */
4842 /* The value has changed. */
4843 WP_VALUE_CHANGED
= 2,
4845 /* The value has not changed. */
4846 WP_VALUE_NOT_CHANGED
= 3,
4848 /* Ignore this watchpoint, no matter if the value changed or not. */
4852 #define BP_TEMPFLAG 1
4853 #define BP_HARDWAREFLAG 2
4855 /* Evaluate watchpoint condition expression and check if its value
4858 static wp_check_result
4859 watchpoint_check (bpstat bs
)
4861 struct watchpoint
*b
;
4862 struct frame_info
*fr
;
4863 int within_current_scope
;
4865 /* BS is built from an existing struct breakpoint. */
4866 gdb_assert (bs
->breakpoint_at
!= NULL
);
4867 b
= (struct watchpoint
*) bs
->breakpoint_at
;
4869 /* If this is a local watchpoint, we only want to check if the
4870 watchpoint frame is in scope if the current thread is the thread
4871 that was used to create the watchpoint. */
4872 if (!watchpoint_in_thread_scope (b
))
4875 if (b
->exp_valid_block
== NULL
)
4876 within_current_scope
= 1;
4879 struct frame_info
*frame
= get_current_frame ();
4880 struct gdbarch
*frame_arch
= get_frame_arch (frame
);
4881 CORE_ADDR frame_pc
= get_frame_pc (frame
);
4883 /* stack_frame_destroyed_p() returns a non-zero value if we're
4884 still in the function but the stack frame has already been
4885 invalidated. Since we can't rely on the values of local
4886 variables after the stack has been destroyed, we are treating
4887 the watchpoint in that state as `not changed' without further
4888 checking. Don't mark watchpoints as changed if the current
4889 frame is in an epilogue - even if they are in some other
4890 frame, our view of the stack is likely to be wrong and
4891 frame_find_by_id could error out. */
4892 if (gdbarch_stack_frame_destroyed_p (frame_arch
, frame_pc
))
4895 fr
= frame_find_by_id (b
->watchpoint_frame
);
4896 within_current_scope
= (fr
!= NULL
);
4898 /* If we've gotten confused in the unwinder, we might have
4899 returned a frame that can't describe this variable. */
4900 if (within_current_scope
)
4902 struct symbol
*function
;
4904 function
= get_frame_function (fr
);
4905 if (function
== NULL
4906 || !contained_in (b
->exp_valid_block
,
4907 SYMBOL_BLOCK_VALUE (function
)))
4908 within_current_scope
= 0;
4911 if (within_current_scope
)
4912 /* If we end up stopping, the current frame will get selected
4913 in normal_stop. So this call to select_frame won't affect
4918 if (within_current_scope
)
4920 /* We use value_{,free_to_}mark because it could be a *long*
4921 time before we return to the command level and call
4922 free_all_values. We can't call free_all_values because we
4923 might be in the middle of evaluating a function call. */
4927 struct value
*new_val
;
4929 if (is_masked_watchpoint (b
))
4930 /* Since we don't know the exact trigger address (from
4931 stopped_data_address), just tell the user we've triggered
4932 a mask watchpoint. */
4933 return WP_VALUE_CHANGED
;
4935 mark
= value_mark ();
4936 fetch_subexp_value (b
->exp
.get (), &pc
, &new_val
, NULL
, NULL
, 0);
4938 if (b
->val_bitsize
!= 0)
4939 new_val
= extract_bitfield_from_watchpoint_value (b
, new_val
);
4941 /* We use value_equal_contents instead of value_equal because
4942 the latter coerces an array to a pointer, thus comparing just
4943 the address of the array instead of its contents. This is
4944 not what we want. */
4945 if ((b
->val
!= NULL
) != (new_val
!= NULL
)
4946 || (b
->val
!= NULL
&& !value_equal_contents (b
->val
, new_val
)))
4948 if (new_val
!= NULL
)
4950 release_value (new_val
);
4951 value_free_to_mark (mark
);
4953 bs
->old_val
= b
->val
;
4956 return WP_VALUE_CHANGED
;
4960 /* Nothing changed. */
4961 value_free_to_mark (mark
);
4962 return WP_VALUE_NOT_CHANGED
;
4967 /* This seems like the only logical thing to do because
4968 if we temporarily ignored the watchpoint, then when
4969 we reenter the block in which it is valid it contains
4970 garbage (in the case of a function, it may have two
4971 garbage values, one before and one after the prologue).
4972 So we can't even detect the first assignment to it and
4973 watch after that (since the garbage may or may not equal
4974 the first value assigned). */
4975 /* We print all the stop information in
4976 breakpoint_ops->print_it, but in this case, by the time we
4977 call breakpoint_ops->print_it this bp will be deleted
4978 already. So we have no choice but print the information
4981 SWITCH_THRU_ALL_UIS ()
4983 struct ui_out
*uiout
= current_uiout
;
4985 if (uiout
->is_mi_like_p ())
4987 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
4988 uiout
->text ("\nWatchpoint ");
4989 uiout
->field_int ("wpnum", b
->number
);
4990 uiout
->text (" deleted because the program has left the block in\n"
4991 "which its expression is valid.\n");
4994 /* Make sure the watchpoint's commands aren't executed. */
4996 watchpoint_del_at_next_stop (b
);
5002 /* Return true if it looks like target has stopped due to hitting
5003 breakpoint location BL. This function does not check if we should
5004 stop, only if BL explains the stop. */
5007 bpstat_check_location (const struct bp_location
*bl
,
5008 const address_space
*aspace
, CORE_ADDR bp_addr
,
5009 const struct target_waitstatus
*ws
)
5011 struct breakpoint
*b
= bl
->owner
;
5013 /* BL is from an existing breakpoint. */
5014 gdb_assert (b
!= NULL
);
5016 return b
->ops
->breakpoint_hit (bl
, aspace
, bp_addr
, ws
);
5019 /* Determine if the watched values have actually changed, and we
5020 should stop. If not, set BS->stop to 0. */
5023 bpstat_check_watchpoint (bpstat bs
)
5025 const struct bp_location
*bl
;
5026 struct watchpoint
*b
;
5028 /* BS is built for existing struct breakpoint. */
5029 bl
= bs
->bp_location_at
;
5030 gdb_assert (bl
!= NULL
);
5031 b
= (struct watchpoint
*) bs
->breakpoint_at
;
5032 gdb_assert (b
!= NULL
);
5035 int must_check_value
= 0;
5037 if (b
->type
== bp_watchpoint
)
5038 /* For a software watchpoint, we must always check the
5040 must_check_value
= 1;
5041 else if (b
->watchpoint_triggered
== watch_triggered_yes
)
5042 /* We have a hardware watchpoint (read, write, or access)
5043 and the target earlier reported an address watched by
5045 must_check_value
= 1;
5046 else if (b
->watchpoint_triggered
== watch_triggered_unknown
5047 && b
->type
== bp_hardware_watchpoint
)
5048 /* We were stopped by a hardware watchpoint, but the target could
5049 not report the data address. We must check the watchpoint's
5050 value. Access and read watchpoints are out of luck; without
5051 a data address, we can't figure it out. */
5052 must_check_value
= 1;
5054 if (must_check_value
)
5060 e
= watchpoint_check (bs
);
5062 CATCH (ex
, RETURN_MASK_ALL
)
5064 exception_fprintf (gdb_stderr
, ex
,
5065 "Error evaluating expression "
5066 "for watchpoint %d\n",
5069 SWITCH_THRU_ALL_UIS ()
5071 printf_filtered (_("Watchpoint %d deleted.\n"),
5074 watchpoint_del_at_next_stop (b
);
5082 /* We've already printed what needs to be printed. */
5083 bs
->print_it
= print_it_done
;
5087 bs
->print_it
= print_it_noop
;
5090 case WP_VALUE_CHANGED
:
5091 if (b
->type
== bp_read_watchpoint
)
5093 /* There are two cases to consider here:
5095 1. We're watching the triggered memory for reads.
5096 In that case, trust the target, and always report
5097 the watchpoint hit to the user. Even though
5098 reads don't cause value changes, the value may
5099 have changed since the last time it was read, and
5100 since we're not trapping writes, we will not see
5101 those, and as such we should ignore our notion of
5104 2. We're watching the triggered memory for both
5105 reads and writes. There are two ways this may
5108 2.1. This is a target that can't break on data
5109 reads only, but can break on accesses (reads or
5110 writes), such as e.g., x86. We detect this case
5111 at the time we try to insert read watchpoints.
5113 2.2. Otherwise, the target supports read
5114 watchpoints, but, the user set an access or write
5115 watchpoint watching the same memory as this read
5118 If we're watching memory writes as well as reads,
5119 ignore watchpoint hits when we find that the
5120 value hasn't changed, as reads don't cause
5121 changes. This still gives false positives when
5122 the program writes the same value to memory as
5123 what there was already in memory (we will confuse
5124 it for a read), but it's much better than
5127 int other_write_watchpoint
= 0;
5129 if (bl
->watchpoint_type
== hw_read
)
5131 struct breakpoint
*other_b
;
5133 ALL_BREAKPOINTS (other_b
)
5134 if (other_b
->type
== bp_hardware_watchpoint
5135 || other_b
->type
== bp_access_watchpoint
)
5137 struct watchpoint
*other_w
=
5138 (struct watchpoint
*) other_b
;
5140 if (other_w
->watchpoint_triggered
5141 == watch_triggered_yes
)
5143 other_write_watchpoint
= 1;
5149 if (other_write_watchpoint
5150 || bl
->watchpoint_type
== hw_access
)
5152 /* We're watching the same memory for writes,
5153 and the value changed since the last time we
5154 updated it, so this trap must be for a write.
5156 bs
->print_it
= print_it_noop
;
5161 case WP_VALUE_NOT_CHANGED
:
5162 if (b
->type
== bp_hardware_watchpoint
5163 || b
->type
== bp_watchpoint
)
5165 /* Don't stop: write watchpoints shouldn't fire if
5166 the value hasn't changed. */
5167 bs
->print_it
= print_it_noop
;
5177 else /* must_check_value == 0 */
5179 /* This is a case where some watchpoint(s) triggered, but
5180 not at the address of this watchpoint, or else no
5181 watchpoint triggered after all. So don't print
5182 anything for this watchpoint. */
5183 bs
->print_it
= print_it_noop
;
5189 /* For breakpoints that are currently marked as telling gdb to stop,
5190 check conditions (condition proper, frame, thread and ignore count)
5191 of breakpoint referred to by BS. If we should not stop for this
5192 breakpoint, set BS->stop to 0. */
5195 bpstat_check_breakpoint_conditions (bpstat bs
, ptid_t ptid
)
5197 const struct bp_location
*bl
;
5198 struct breakpoint
*b
;
5200 bool condition_result
= true;
5201 struct expression
*cond
;
5203 gdb_assert (bs
->stop
);
5205 /* BS is built for existing struct breakpoint. */
5206 bl
= bs
->bp_location_at
;
5207 gdb_assert (bl
!= NULL
);
5208 b
= bs
->breakpoint_at
;
5209 gdb_assert (b
!= NULL
);
5211 /* Even if the target evaluated the condition on its end and notified GDB, we
5212 need to do so again since GDB does not know if we stopped due to a
5213 breakpoint or a single step breakpoint. */
5215 if (frame_id_p (b
->frame_id
)
5216 && !frame_id_eq (b
->frame_id
, get_stack_frame_id (get_current_frame ())))
5222 /* If this is a thread/task-specific breakpoint, don't waste cpu
5223 evaluating the condition if this isn't the specified
5225 if ((b
->thread
!= -1 && b
->thread
!= ptid_to_global_thread_id (ptid
))
5226 || (b
->task
!= 0 && b
->task
!= ada_get_task_number (ptid
)))
5233 /* Evaluate extension language breakpoints that have a "stop" method
5235 bs
->stop
= breakpoint_ext_lang_cond_says_stop (b
);
5237 if (is_watchpoint (b
))
5239 struct watchpoint
*w
= (struct watchpoint
*) b
;
5241 cond
= w
->cond_exp
.get ();
5244 cond
= bl
->cond
.get ();
5246 if (cond
&& b
->disposition
!= disp_del_at_next_stop
)
5248 int within_current_scope
= 1;
5249 struct watchpoint
* w
;
5251 /* We use value_mark and value_free_to_mark because it could
5252 be a long time before we return to the command level and
5253 call free_all_values. We can't call free_all_values
5254 because we might be in the middle of evaluating a
5256 struct value
*mark
= value_mark ();
5258 if (is_watchpoint (b
))
5259 w
= (struct watchpoint
*) b
;
5263 /* Need to select the frame, with all that implies so that
5264 the conditions will have the right context. Because we
5265 use the frame, we will not see an inlined function's
5266 variables when we arrive at a breakpoint at the start
5267 of the inlined function; the current frame will be the
5269 if (w
== NULL
|| w
->cond_exp_valid_block
== NULL
)
5270 select_frame (get_current_frame ());
5273 struct frame_info
*frame
;
5275 /* For local watchpoint expressions, which particular
5276 instance of a local is being watched matters, so we
5277 keep track of the frame to evaluate the expression
5278 in. To evaluate the condition however, it doesn't
5279 really matter which instantiation of the function
5280 where the condition makes sense triggers the
5281 watchpoint. This allows an expression like "watch
5282 global if q > 10" set in `func', catch writes to
5283 global on all threads that call `func', or catch
5284 writes on all recursive calls of `func' by a single
5285 thread. We simply always evaluate the condition in
5286 the innermost frame that's executing where it makes
5287 sense to evaluate the condition. It seems
5289 frame
= block_innermost_frame (w
->cond_exp_valid_block
);
5291 select_frame (frame
);
5293 within_current_scope
= 0;
5295 if (within_current_scope
)
5299 condition_result
= breakpoint_cond_eval (cond
);
5301 CATCH (ex
, RETURN_MASK_ALL
)
5303 exception_fprintf (gdb_stderr
, ex
,
5304 "Error in testing breakpoint condition:\n");
5310 warning (_("Watchpoint condition cannot be tested "
5311 "in the current scope"));
5312 /* If we failed to set the right context for this
5313 watchpoint, unconditionally report it. */
5315 /* FIXME-someday, should give breakpoint #. */
5316 value_free_to_mark (mark
);
5319 if (cond
&& !condition_result
)
5323 else if (b
->ignore_count
> 0)
5327 /* Increase the hit count even though we don't stop. */
5329 observer_notify_breakpoint_modified (b
);
5333 /* Returns true if we need to track moribund locations of LOC's type
5334 on the current target. */
5337 need_moribund_for_location_type (struct bp_location
*loc
)
5339 return ((loc
->loc_type
== bp_loc_software_breakpoint
5340 && !target_supports_stopped_by_sw_breakpoint ())
5341 || (loc
->loc_type
== bp_loc_hardware_breakpoint
5342 && !target_supports_stopped_by_hw_breakpoint ()));
5346 /* Get a bpstat associated with having just stopped at address
5347 BP_ADDR in thread PTID.
5349 Determine whether we stopped at a breakpoint, etc, or whether we
5350 don't understand this stop. Result is a chain of bpstat's such
5353 if we don't understand the stop, the result is a null pointer.
5355 if we understand why we stopped, the result is not null.
5357 Each element of the chain refers to a particular breakpoint or
5358 watchpoint at which we have stopped. (We may have stopped for
5359 several reasons concurrently.)
5361 Each element of the chain has valid next, breakpoint_at,
5362 commands, FIXME??? fields. */
5365 bpstat_stop_status (const address_space
*aspace
,
5366 CORE_ADDR bp_addr
, ptid_t ptid
,
5367 const struct target_waitstatus
*ws
)
5369 struct breakpoint
*b
= NULL
;
5370 struct bp_location
*bl
;
5371 struct bp_location
*loc
;
5372 /* First item of allocated bpstat's. */
5373 bpstat bs_head
= NULL
, *bs_link
= &bs_head
;
5374 /* Pointer to the last thing in the chain currently. */
5377 int need_remove_insert
;
5380 /* First, build the bpstat chain with locations that explain a
5381 target stop, while being careful to not set the target running,
5382 as that may invalidate locations (in particular watchpoint
5383 locations are recreated). Resuming will happen here with
5384 breakpoint conditions or watchpoint expressions that include
5385 inferior function calls. */
5389 if (!breakpoint_enabled (b
))
5392 for (bl
= b
->loc
; bl
!= NULL
; bl
= bl
->next
)
5394 /* For hardware watchpoints, we look only at the first
5395 location. The watchpoint_check function will work on the
5396 entire expression, not the individual locations. For
5397 read watchpoints, the watchpoints_triggered function has
5398 checked all locations already. */
5399 if (b
->type
== bp_hardware_watchpoint
&& bl
!= b
->loc
)
5402 if (!bl
->enabled
|| bl
->shlib_disabled
)
5405 if (!bpstat_check_location (bl
, aspace
, bp_addr
, ws
))
5408 /* Come here if it's a watchpoint, or if the break address
5411 bs
= new bpstats (bl
, &bs_link
); /* Alloc a bpstat to
5414 /* Assume we stop. Should we find a watchpoint that is not
5415 actually triggered, or if the condition of the breakpoint
5416 evaluates as false, we'll reset 'stop' to 0. */
5420 /* If this is a scope breakpoint, mark the associated
5421 watchpoint as triggered so that we will handle the
5422 out-of-scope event. We'll get to the watchpoint next
5424 if (b
->type
== bp_watchpoint_scope
&& b
->related_breakpoint
!= b
)
5426 struct watchpoint
*w
= (struct watchpoint
*) b
->related_breakpoint
;
5428 w
->watchpoint_triggered
= watch_triggered_yes
;
5433 /* Check if a moribund breakpoint explains the stop. */
5434 if (!target_supports_stopped_by_sw_breakpoint ()
5435 || !target_supports_stopped_by_hw_breakpoint ())
5437 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
5439 if (breakpoint_location_address_match (loc
, aspace
, bp_addr
)
5440 && need_moribund_for_location_type (loc
))
5442 bs
= new bpstats (loc
, &bs_link
);
5443 /* For hits of moribund locations, we should just proceed. */
5446 bs
->print_it
= print_it_noop
;
5451 /* A bit of special processing for shlib breakpoints. We need to
5452 process solib loading here, so that the lists of loaded and
5453 unloaded libraries are correct before we handle "catch load" and
5455 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5457 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->type
== bp_shlib_event
)
5459 handle_solib_event ();
5464 /* Now go through the locations that caused the target to stop, and
5465 check whether we're interested in reporting this stop to higher
5466 layers, or whether we should resume the target transparently. */
5470 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5475 b
= bs
->breakpoint_at
;
5476 b
->ops
->check_status (bs
);
5479 bpstat_check_breakpoint_conditions (bs
, ptid
);
5484 observer_notify_breakpoint_modified (b
);
5486 /* We will stop here. */
5487 if (b
->disposition
== disp_disable
)
5489 --(b
->enable_count
);
5490 if (b
->enable_count
<= 0)
5491 b
->enable_state
= bp_disabled
;
5496 bs
->commands
= b
->commands
;
5497 if (command_line_is_silent (bs
->commands
5498 ? bs
->commands
.get () : NULL
))
5501 b
->ops
->after_condition_true (bs
);
5506 /* Print nothing for this entry if we don't stop or don't
5508 if (!bs
->stop
|| !bs
->print
)
5509 bs
->print_it
= print_it_noop
;
5512 /* If we aren't stopping, the value of some hardware watchpoint may
5513 not have changed, but the intermediate memory locations we are
5514 watching may have. Don't bother if we're stopping; this will get
5516 need_remove_insert
= 0;
5517 if (! bpstat_causes_stop (bs_head
))
5518 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5520 && bs
->breakpoint_at
5521 && is_hardware_watchpoint (bs
->breakpoint_at
))
5523 struct watchpoint
*w
= (struct watchpoint
*) bs
->breakpoint_at
;
5525 update_watchpoint (w
, 0 /* don't reparse. */);
5526 need_remove_insert
= 1;
5529 if (need_remove_insert
)
5530 update_global_location_list (UGLL_MAY_INSERT
);
5531 else if (removed_any
)
5532 update_global_location_list (UGLL_DONT_INSERT
);
5538 handle_jit_event (void)
5540 struct frame_info
*frame
;
5541 struct gdbarch
*gdbarch
;
5544 fprintf_unfiltered (gdb_stdlog
, "handling bp_jit_event\n");
5546 /* Switch terminal for any messages produced by
5547 breakpoint_re_set. */
5548 target_terminal::ours_for_output ();
5550 frame
= get_current_frame ();
5551 gdbarch
= get_frame_arch (frame
);
5553 jit_event_handler (gdbarch
);
5555 target_terminal::inferior ();
5558 /* Prepare WHAT final decision for infrun. */
5560 /* Decide what infrun needs to do with this bpstat. */
5563 bpstat_what (bpstat bs_head
)
5565 struct bpstat_what retval
;
5568 retval
.main_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5569 retval
.call_dummy
= STOP_NONE
;
5570 retval
.is_longjmp
= 0;
5572 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5574 /* Extract this BS's action. After processing each BS, we check
5575 if its action overrides all we've seem so far. */
5576 enum bpstat_what_main_action this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5579 if (bs
->breakpoint_at
== NULL
)
5581 /* I suspect this can happen if it was a momentary
5582 breakpoint which has since been deleted. */
5586 bptype
= bs
->breakpoint_at
->type
;
5593 case bp_hardware_breakpoint
:
5594 case bp_single_step
:
5597 case bp_shlib_event
:
5601 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5603 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5606 this_action
= BPSTAT_WHAT_SINGLE
;
5609 case bp_hardware_watchpoint
:
5610 case bp_read_watchpoint
:
5611 case bp_access_watchpoint
:
5615 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5617 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5621 /* There was a watchpoint, but we're not stopping.
5622 This requires no further action. */
5626 case bp_longjmp_call_dummy
:
5630 this_action
= BPSTAT_WHAT_SET_LONGJMP_RESUME
;
5631 retval
.is_longjmp
= bptype
!= bp_exception
;
5634 this_action
= BPSTAT_WHAT_SINGLE
;
5636 case bp_longjmp_resume
:
5637 case bp_exception_resume
:
5640 this_action
= BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
;
5641 retval
.is_longjmp
= bptype
== bp_longjmp_resume
;
5644 this_action
= BPSTAT_WHAT_SINGLE
;
5646 case bp_step_resume
:
5648 this_action
= BPSTAT_WHAT_STEP_RESUME
;
5651 /* It is for the wrong frame. */
5652 this_action
= BPSTAT_WHAT_SINGLE
;
5655 case bp_hp_step_resume
:
5657 this_action
= BPSTAT_WHAT_HP_STEP_RESUME
;
5660 /* It is for the wrong frame. */
5661 this_action
= BPSTAT_WHAT_SINGLE
;
5664 case bp_watchpoint_scope
:
5665 case bp_thread_event
:
5666 case bp_overlay_event
:
5667 case bp_longjmp_master
:
5668 case bp_std_terminate_master
:
5669 case bp_exception_master
:
5670 this_action
= BPSTAT_WHAT_SINGLE
;
5676 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5678 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5682 /* There was a catchpoint, but we're not stopping.
5683 This requires no further action. */
5687 this_action
= BPSTAT_WHAT_SINGLE
;
5690 /* Make sure the action is stop (silent or noisy),
5691 so infrun.c pops the dummy frame. */
5692 retval
.call_dummy
= STOP_STACK_DUMMY
;
5693 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5695 case bp_std_terminate
:
5696 /* Make sure the action is stop (silent or noisy),
5697 so infrun.c pops the dummy frame. */
5698 retval
.call_dummy
= STOP_STD_TERMINATE
;
5699 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5702 case bp_fast_tracepoint
:
5703 case bp_static_tracepoint
:
5704 /* Tracepoint hits should not be reported back to GDB, and
5705 if one got through somehow, it should have been filtered
5707 internal_error (__FILE__
, __LINE__
,
5708 _("bpstat_what: tracepoint encountered"));
5710 case bp_gnu_ifunc_resolver
:
5711 /* Step over it (and insert bp_gnu_ifunc_resolver_return). */
5712 this_action
= BPSTAT_WHAT_SINGLE
;
5714 case bp_gnu_ifunc_resolver_return
:
5715 /* The breakpoint will be removed, execution will restart from the
5716 PC of the former breakpoint. */
5717 this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5722 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5724 this_action
= BPSTAT_WHAT_SINGLE
;
5728 internal_error (__FILE__
, __LINE__
,
5729 _("bpstat_what: unhandled bptype %d"), (int) bptype
);
5732 retval
.main_action
= std::max (retval
.main_action
, this_action
);
5739 bpstat_run_callbacks (bpstat bs_head
)
5743 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5745 struct breakpoint
*b
= bs
->breakpoint_at
;
5752 handle_jit_event ();
5754 case bp_gnu_ifunc_resolver
:
5755 gnu_ifunc_resolver_stop (b
);
5757 case bp_gnu_ifunc_resolver_return
:
5758 gnu_ifunc_resolver_return_stop (b
);
5764 /* Nonzero if we should step constantly (e.g. watchpoints on machines
5765 without hardware support). This isn't related to a specific bpstat,
5766 just to things like whether watchpoints are set. */
5769 bpstat_should_step (void)
5771 struct breakpoint
*b
;
5774 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
&& b
->loc
!= NULL
)
5780 bpstat_causes_stop (bpstat bs
)
5782 for (; bs
!= NULL
; bs
= bs
->next
)
5791 /* Compute a string of spaces suitable to indent the next line
5792 so it starts at the position corresponding to the table column
5793 named COL_NAME in the currently active table of UIOUT. */
5796 wrap_indent_at_field (struct ui_out
*uiout
, const char *col_name
)
5798 static char wrap_indent
[80];
5799 int i
, total_width
, width
, align
;
5803 for (i
= 1; uiout
->query_table_field (i
, &width
, &align
, &text
); i
++)
5805 if (strcmp (text
, col_name
) == 0)
5807 gdb_assert (total_width
< sizeof wrap_indent
);
5808 memset (wrap_indent
, ' ', total_width
);
5809 wrap_indent
[total_width
] = 0;
5814 total_width
+= width
+ 1;
5820 /* Determine if the locations of this breakpoint will have their conditions
5821 evaluated by the target, host or a mix of both. Returns the following:
5823 "host": Host evals condition.
5824 "host or target": Host or Target evals condition.
5825 "target": Target evals condition.
5829 bp_condition_evaluator (struct breakpoint
*b
)
5831 struct bp_location
*bl
;
5832 char host_evals
= 0;
5833 char target_evals
= 0;
5838 if (!is_breakpoint (b
))
5841 if (gdb_evaluates_breakpoint_condition_p ()
5842 || !target_supports_evaluation_of_breakpoint_conditions ())
5843 return condition_evaluation_host
;
5845 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
5847 if (bl
->cond_bytecode
)
5853 if (host_evals
&& target_evals
)
5854 return condition_evaluation_both
;
5855 else if (target_evals
)
5856 return condition_evaluation_target
;
5858 return condition_evaluation_host
;
5861 /* Determine the breakpoint location's condition evaluator. This is
5862 similar to bp_condition_evaluator, but for locations. */
5865 bp_location_condition_evaluator (struct bp_location
*bl
)
5867 if (bl
&& !is_breakpoint (bl
->owner
))
5870 if (gdb_evaluates_breakpoint_condition_p ()
5871 || !target_supports_evaluation_of_breakpoint_conditions ())
5872 return condition_evaluation_host
;
5874 if (bl
&& bl
->cond_bytecode
)
5875 return condition_evaluation_target
;
5877 return condition_evaluation_host
;
5880 /* Print the LOC location out of the list of B->LOC locations. */
5883 print_breakpoint_location (struct breakpoint
*b
,
5884 struct bp_location
*loc
)
5886 struct ui_out
*uiout
= current_uiout
;
5888 scoped_restore_current_program_space restore_pspace
;
5890 if (loc
!= NULL
&& loc
->shlib_disabled
)
5894 set_current_program_space (loc
->pspace
);
5896 if (b
->display_canonical
)
5897 uiout
->field_string ("what", event_location_to_string (b
->location
.get ()));
5898 else if (loc
&& loc
->symtab
)
5900 const struct symbol
*sym
= loc
->symbol
;
5903 sym
= find_pc_sect_function (loc
->address
, loc
->section
);
5907 uiout
->text ("in ");
5908 uiout
->field_string ("func", SYMBOL_PRINT_NAME (sym
));
5910 uiout
->wrap_hint (wrap_indent_at_field (uiout
, "what"));
5911 uiout
->text ("at ");
5913 uiout
->field_string ("file",
5914 symtab_to_filename_for_display (loc
->symtab
));
5917 if (uiout
->is_mi_like_p ())
5918 uiout
->field_string ("fullname", symtab_to_fullname (loc
->symtab
));
5920 uiout
->field_int ("line", loc
->line_number
);
5926 print_address_symbolic (loc
->gdbarch
, loc
->address
, &stb
,
5928 uiout
->field_stream ("at", stb
);
5932 uiout
->field_string ("pending",
5933 event_location_to_string (b
->location
.get ()));
5934 /* If extra_string is available, it could be holding a condition
5935 or dprintf arguments. In either case, make sure it is printed,
5936 too, but only for non-MI streams. */
5937 if (!uiout
->is_mi_like_p () && b
->extra_string
!= NULL
)
5939 if (b
->type
== bp_dprintf
)
5943 uiout
->text (b
->extra_string
);
5947 if (loc
&& is_breakpoint (b
)
5948 && breakpoint_condition_evaluation_mode () == condition_evaluation_target
5949 && bp_condition_evaluator (b
) == condition_evaluation_both
)
5952 uiout
->field_string ("evaluated-by",
5953 bp_location_condition_evaluator (loc
));
5959 bptype_string (enum bptype type
)
5961 struct ep_type_description
5964 const char *description
;
5966 static struct ep_type_description bptypes
[] =
5968 {bp_none
, "?deleted?"},
5969 {bp_breakpoint
, "breakpoint"},
5970 {bp_hardware_breakpoint
, "hw breakpoint"},
5971 {bp_single_step
, "sw single-step"},
5972 {bp_until
, "until"},
5973 {bp_finish
, "finish"},
5974 {bp_watchpoint
, "watchpoint"},
5975 {bp_hardware_watchpoint
, "hw watchpoint"},
5976 {bp_read_watchpoint
, "read watchpoint"},
5977 {bp_access_watchpoint
, "acc watchpoint"},
5978 {bp_longjmp
, "longjmp"},
5979 {bp_longjmp_resume
, "longjmp resume"},
5980 {bp_longjmp_call_dummy
, "longjmp for call dummy"},
5981 {bp_exception
, "exception"},
5982 {bp_exception_resume
, "exception resume"},
5983 {bp_step_resume
, "step resume"},
5984 {bp_hp_step_resume
, "high-priority step resume"},
5985 {bp_watchpoint_scope
, "watchpoint scope"},
5986 {bp_call_dummy
, "call dummy"},
5987 {bp_std_terminate
, "std::terminate"},
5988 {bp_shlib_event
, "shlib events"},
5989 {bp_thread_event
, "thread events"},
5990 {bp_overlay_event
, "overlay events"},
5991 {bp_longjmp_master
, "longjmp master"},
5992 {bp_std_terminate_master
, "std::terminate master"},
5993 {bp_exception_master
, "exception master"},
5994 {bp_catchpoint
, "catchpoint"},
5995 {bp_tracepoint
, "tracepoint"},
5996 {bp_fast_tracepoint
, "fast tracepoint"},
5997 {bp_static_tracepoint
, "static tracepoint"},
5998 {bp_dprintf
, "dprintf"},
5999 {bp_jit_event
, "jit events"},
6000 {bp_gnu_ifunc_resolver
, "STT_GNU_IFUNC resolver"},
6001 {bp_gnu_ifunc_resolver_return
, "STT_GNU_IFUNC resolver return"},
6004 if (((int) type
>= (sizeof (bptypes
) / sizeof (bptypes
[0])))
6005 || ((int) type
!= bptypes
[(int) type
].type
))
6006 internal_error (__FILE__
, __LINE__
,
6007 _("bptypes table does not describe type #%d."),
6010 return bptypes
[(int) type
].description
;
6013 /* For MI, output a field named 'thread-groups' with a list as the value.
6014 For CLI, prefix the list with the string 'inf'. */
6017 output_thread_groups (struct ui_out
*uiout
,
6018 const char *field_name
,
6019 const std::vector
<int> &inf_nums
,
6022 int is_mi
= uiout
->is_mi_like_p ();
6024 /* For backward compatibility, don't display inferiors in CLI unless
6025 there are several. Always display them for MI. */
6026 if (!is_mi
&& mi_only
)
6029 ui_out_emit_list
list_emitter (uiout
, field_name
);
6031 for (size_t i
= 0; i
< inf_nums
.size (); i
++)
6037 xsnprintf (mi_group
, sizeof (mi_group
), "i%d", inf_nums
[i
]);
6038 uiout
->field_string (NULL
, mi_group
);
6043 uiout
->text (" inf ");
6047 uiout
->text (plongest (inf_nums
[i
]));
6052 /* Print B to gdb_stdout. */
6055 print_one_breakpoint_location (struct breakpoint
*b
,
6056 struct bp_location
*loc
,
6058 struct bp_location
**last_loc
,
6061 struct command_line
*l
;
6062 static char bpenables
[] = "nynny";
6064 struct ui_out
*uiout
= current_uiout
;
6065 int header_of_multiple
= 0;
6066 int part_of_multiple
= (loc
!= NULL
);
6067 struct value_print_options opts
;
6069 get_user_print_options (&opts
);
6071 gdb_assert (!loc
|| loc_number
!= 0);
6072 /* See comment in print_one_breakpoint concerning treatment of
6073 breakpoints with single disabled location. */
6076 && (b
->loc
->next
!= NULL
|| !b
->loc
->enabled
)))
6077 header_of_multiple
= 1;
6085 if (part_of_multiple
)
6088 formatted
= xstrprintf ("%d.%d", b
->number
, loc_number
);
6089 uiout
->field_string ("number", formatted
);
6094 uiout
->field_int ("number", b
->number
);
6099 if (part_of_multiple
)
6100 uiout
->field_skip ("type");
6102 uiout
->field_string ("type", bptype_string (b
->type
));
6106 if (part_of_multiple
)
6107 uiout
->field_skip ("disp");
6109 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
6114 if (part_of_multiple
)
6115 uiout
->field_string ("enabled", loc
->enabled
? "y" : "n");
6117 uiout
->field_fmt ("enabled", "%c", bpenables
[(int) b
->enable_state
]);
6122 if (b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
6124 /* Although the print_one can possibly print all locations,
6125 calling it here is not likely to get any nice result. So,
6126 make sure there's just one location. */
6127 gdb_assert (b
->loc
== NULL
|| b
->loc
->next
== NULL
);
6128 b
->ops
->print_one (b
, last_loc
);
6134 internal_error (__FILE__
, __LINE__
,
6135 _("print_one_breakpoint: bp_none encountered\n"));
6139 case bp_hardware_watchpoint
:
6140 case bp_read_watchpoint
:
6141 case bp_access_watchpoint
:
6143 struct watchpoint
*w
= (struct watchpoint
*) b
;
6145 /* Field 4, the address, is omitted (which makes the columns
6146 not line up too nicely with the headers, but the effect
6147 is relatively readable). */
6148 if (opts
.addressprint
)
6149 uiout
->field_skip ("addr");
6151 uiout
->field_string ("what", w
->exp_string
);
6156 case bp_hardware_breakpoint
:
6157 case bp_single_step
:
6161 case bp_longjmp_resume
:
6162 case bp_longjmp_call_dummy
:
6164 case bp_exception_resume
:
6165 case bp_step_resume
:
6166 case bp_hp_step_resume
:
6167 case bp_watchpoint_scope
:
6169 case bp_std_terminate
:
6170 case bp_shlib_event
:
6171 case bp_thread_event
:
6172 case bp_overlay_event
:
6173 case bp_longjmp_master
:
6174 case bp_std_terminate_master
:
6175 case bp_exception_master
:
6177 case bp_fast_tracepoint
:
6178 case bp_static_tracepoint
:
6181 case bp_gnu_ifunc_resolver
:
6182 case bp_gnu_ifunc_resolver_return
:
6183 if (opts
.addressprint
)
6186 if (header_of_multiple
)
6187 uiout
->field_string ("addr", "<MULTIPLE>");
6188 else if (b
->loc
== NULL
|| loc
->shlib_disabled
)
6189 uiout
->field_string ("addr", "<PENDING>");
6191 uiout
->field_core_addr ("addr",
6192 loc
->gdbarch
, loc
->address
);
6195 if (!header_of_multiple
)
6196 print_breakpoint_location (b
, loc
);
6203 if (loc
!= NULL
&& !header_of_multiple
)
6205 struct inferior
*inf
;
6206 std::vector
<int> inf_nums
;
6211 if (inf
->pspace
== loc
->pspace
)
6212 inf_nums
.push_back (inf
->num
);
6215 /* For backward compatibility, don't display inferiors in CLI unless
6216 there are several. Always display for MI. */
6218 || (!gdbarch_has_global_breakpoints (target_gdbarch ())
6219 && (number_of_program_spaces () > 1
6220 || number_of_inferiors () > 1)
6221 /* LOC is for existing B, it cannot be in
6222 moribund_locations and thus having NULL OWNER. */
6223 && loc
->owner
->type
!= bp_catchpoint
))
6225 output_thread_groups (uiout
, "thread-groups", inf_nums
, mi_only
);
6228 if (!part_of_multiple
)
6230 if (b
->thread
!= -1)
6232 /* FIXME: This seems to be redundant and lost here; see the
6233 "stop only in" line a little further down. */
6234 uiout
->text (" thread ");
6235 uiout
->field_int ("thread", b
->thread
);
6237 else if (b
->task
!= 0)
6239 uiout
->text (" task ");
6240 uiout
->field_int ("task", b
->task
);
6246 if (!part_of_multiple
)
6247 b
->ops
->print_one_detail (b
, uiout
);
6249 if (part_of_multiple
&& frame_id_p (b
->frame_id
))
6252 uiout
->text ("\tstop only in stack frame at ");
6253 /* FIXME: cagney/2002-12-01: Shouldn't be poking around inside
6255 uiout
->field_core_addr ("frame",
6256 b
->gdbarch
, b
->frame_id
.stack_addr
);
6260 if (!part_of_multiple
&& b
->cond_string
)
6263 if (is_tracepoint (b
))
6264 uiout
->text ("\ttrace only if ");
6266 uiout
->text ("\tstop only if ");
6267 uiout
->field_string ("cond", b
->cond_string
);
6269 /* Print whether the target is doing the breakpoint's condition
6270 evaluation. If GDB is doing the evaluation, don't print anything. */
6271 if (is_breakpoint (b
)
6272 && breakpoint_condition_evaluation_mode ()
6273 == condition_evaluation_target
)
6276 uiout
->field_string ("evaluated-by",
6277 bp_condition_evaluator (b
));
6278 uiout
->text (" evals)");
6283 if (!part_of_multiple
&& b
->thread
!= -1)
6285 /* FIXME should make an annotation for this. */
6286 uiout
->text ("\tstop only in thread ");
6287 if (uiout
->is_mi_like_p ())
6288 uiout
->field_int ("thread", b
->thread
);
6291 struct thread_info
*thr
= find_thread_global_id (b
->thread
);
6293 uiout
->field_string ("thread", print_thread_id (thr
));
6298 if (!part_of_multiple
)
6302 /* FIXME should make an annotation for this. */
6303 if (is_catchpoint (b
))
6304 uiout
->text ("\tcatchpoint");
6305 else if (is_tracepoint (b
))
6306 uiout
->text ("\ttracepoint");
6308 uiout
->text ("\tbreakpoint");
6309 uiout
->text (" already hit ");
6310 uiout
->field_int ("times", b
->hit_count
);
6311 if (b
->hit_count
== 1)
6312 uiout
->text (" time\n");
6314 uiout
->text (" times\n");
6318 /* Output the count also if it is zero, but only if this is mi. */
6319 if (uiout
->is_mi_like_p ())
6320 uiout
->field_int ("times", b
->hit_count
);
6324 if (!part_of_multiple
&& b
->ignore_count
)
6327 uiout
->text ("\tignore next ");
6328 uiout
->field_int ("ignore", b
->ignore_count
);
6329 uiout
->text (" hits\n");
6332 /* Note that an enable count of 1 corresponds to "enable once"
6333 behavior, which is reported by the combination of enablement and
6334 disposition, so we don't need to mention it here. */
6335 if (!part_of_multiple
&& b
->enable_count
> 1)
6338 uiout
->text ("\tdisable after ");
6339 /* Tweak the wording to clarify that ignore and enable counts
6340 are distinct, and have additive effect. */
6341 if (b
->ignore_count
)
6342 uiout
->text ("additional ");
6344 uiout
->text ("next ");
6345 uiout
->field_int ("enable", b
->enable_count
);
6346 uiout
->text (" hits\n");
6349 if (!part_of_multiple
&& is_tracepoint (b
))
6351 struct tracepoint
*tp
= (struct tracepoint
*) b
;
6353 if (tp
->traceframe_usage
)
6355 uiout
->text ("\ttrace buffer usage ");
6356 uiout
->field_int ("traceframe-usage", tp
->traceframe_usage
);
6357 uiout
->text (" bytes\n");
6361 l
= b
->commands
? b
->commands
.get () : NULL
;
6362 if (!part_of_multiple
&& l
)
6365 ui_out_emit_tuple
tuple_emitter (uiout
, "script");
6366 print_command_lines (uiout
, l
, 4);
6369 if (is_tracepoint (b
))
6371 struct tracepoint
*t
= (struct tracepoint
*) b
;
6373 if (!part_of_multiple
&& t
->pass_count
)
6375 annotate_field (10);
6376 uiout
->text ("\tpass count ");
6377 uiout
->field_int ("pass", t
->pass_count
);
6378 uiout
->text (" \n");
6381 /* Don't display it when tracepoint or tracepoint location is
6383 if (!header_of_multiple
&& loc
!= NULL
&& !loc
->shlib_disabled
)
6385 annotate_field (11);
6387 if (uiout
->is_mi_like_p ())
6388 uiout
->field_string ("installed",
6389 loc
->inserted
? "y" : "n");
6395 uiout
->text ("\tnot ");
6396 uiout
->text ("installed on target\n");
6401 if (uiout
->is_mi_like_p () && !part_of_multiple
)
6403 if (is_watchpoint (b
))
6405 struct watchpoint
*w
= (struct watchpoint
*) b
;
6407 uiout
->field_string ("original-location", w
->exp_string
);
6409 else if (b
->location
!= NULL
6410 && event_location_to_string (b
->location
.get ()) != NULL
)
6411 uiout
->field_string ("original-location",
6412 event_location_to_string (b
->location
.get ()));
6417 print_one_breakpoint (struct breakpoint
*b
,
6418 struct bp_location
**last_loc
,
6421 struct ui_out
*uiout
= current_uiout
;
6424 ui_out_emit_tuple
tuple_emitter (uiout
, "bkpt");
6426 print_one_breakpoint_location (b
, NULL
, 0, last_loc
, allflag
);
6429 /* If this breakpoint has custom print function,
6430 it's already printed. Otherwise, print individual
6431 locations, if any. */
6432 if (b
->ops
== NULL
|| b
->ops
->print_one
== NULL
)
6434 /* If breakpoint has a single location that is disabled, we
6435 print it as if it had several locations, since otherwise it's
6436 hard to represent "breakpoint enabled, location disabled"
6439 Note that while hardware watchpoints have several locations
6440 internally, that's not a property exposed to user. */
6442 && !is_hardware_watchpoint (b
)
6443 && (b
->loc
->next
|| !b
->loc
->enabled
))
6445 struct bp_location
*loc
;
6448 for (loc
= b
->loc
; loc
; loc
= loc
->next
, ++n
)
6450 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
6451 print_one_breakpoint_location (b
, loc
, n
, last_loc
, allflag
);
6458 breakpoint_address_bits (struct breakpoint
*b
)
6460 int print_address_bits
= 0;
6461 struct bp_location
*loc
;
6463 /* Software watchpoints that aren't watching memory don't have an
6464 address to print. */
6465 if (is_no_memory_software_watchpoint (b
))
6468 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
6472 addr_bit
= gdbarch_addr_bit (loc
->gdbarch
);
6473 if (addr_bit
> print_address_bits
)
6474 print_address_bits
= addr_bit
;
6477 return print_address_bits
;
6480 /* See breakpoint.h. */
6483 print_breakpoint (breakpoint
*b
)
6485 struct bp_location
*dummy_loc
= NULL
;
6486 print_one_breakpoint (b
, &dummy_loc
, 0);
6489 /* Return true if this breakpoint was set by the user, false if it is
6490 internal or momentary. */
6493 user_breakpoint_p (struct breakpoint
*b
)
6495 return b
->number
> 0;
6498 /* See breakpoint.h. */
6501 pending_breakpoint_p (struct breakpoint
*b
)
6503 return b
->loc
== NULL
;
6506 /* Print information on user settable breakpoint (watchpoint, etc)
6507 number BNUM. If BNUM is -1 print all user-settable breakpoints.
6508 If ALLFLAG is non-zero, include non-user-settable breakpoints. If
6509 FILTER is non-NULL, call it on each breakpoint and only include the
6510 ones for which it returns non-zero. Return the total number of
6511 breakpoints listed. */
6514 breakpoint_1 (const char *args
, int allflag
,
6515 int (*filter
) (const struct breakpoint
*))
6517 struct breakpoint
*b
;
6518 struct bp_location
*last_loc
= NULL
;
6519 int nr_printable_breakpoints
;
6520 struct value_print_options opts
;
6521 int print_address_bits
= 0;
6522 int print_type_col_width
= 14;
6523 struct ui_out
*uiout
= current_uiout
;
6525 get_user_print_options (&opts
);
6527 /* Compute the number of rows in the table, as well as the size
6528 required for address fields. */
6529 nr_printable_breakpoints
= 0;
6532 /* If we have a filter, only list the breakpoints it accepts. */
6533 if (filter
&& !filter (b
))
6536 /* If we have an "args" string, it is a list of breakpoints to
6537 accept. Skip the others. */
6538 if (args
!= NULL
&& *args
!= '\0')
6540 if (allflag
&& parse_and_eval_long (args
) != b
->number
)
6542 if (!allflag
&& !number_is_in_list (args
, b
->number
))
6546 if (allflag
|| user_breakpoint_p (b
))
6548 int addr_bit
, type_len
;
6550 addr_bit
= breakpoint_address_bits (b
);
6551 if (addr_bit
> print_address_bits
)
6552 print_address_bits
= addr_bit
;
6554 type_len
= strlen (bptype_string (b
->type
));
6555 if (type_len
> print_type_col_width
)
6556 print_type_col_width
= type_len
;
6558 nr_printable_breakpoints
++;
6563 ui_out_emit_table
table_emitter (uiout
,
6564 opts
.addressprint
? 6 : 5,
6565 nr_printable_breakpoints
,
6568 if (nr_printable_breakpoints
> 0)
6569 annotate_breakpoints_headers ();
6570 if (nr_printable_breakpoints
> 0)
6572 uiout
->table_header (7, ui_left
, "number", "Num"); /* 1 */
6573 if (nr_printable_breakpoints
> 0)
6575 uiout
->table_header (print_type_col_width
, ui_left
, "type", "Type"); /* 2 */
6576 if (nr_printable_breakpoints
> 0)
6578 uiout
->table_header (4, ui_left
, "disp", "Disp"); /* 3 */
6579 if (nr_printable_breakpoints
> 0)
6581 uiout
->table_header (3, ui_left
, "enabled", "Enb"); /* 4 */
6582 if (opts
.addressprint
)
6584 if (nr_printable_breakpoints
> 0)
6586 if (print_address_bits
<= 32)
6587 uiout
->table_header (10, ui_left
, "addr", "Address"); /* 5 */
6589 uiout
->table_header (18, ui_left
, "addr", "Address"); /* 5 */
6591 if (nr_printable_breakpoints
> 0)
6593 uiout
->table_header (40, ui_noalign
, "what", "What"); /* 6 */
6594 uiout
->table_body ();
6595 if (nr_printable_breakpoints
> 0)
6596 annotate_breakpoints_table ();
6601 /* If we have a filter, only list the breakpoints it accepts. */
6602 if (filter
&& !filter (b
))
6605 /* If we have an "args" string, it is a list of breakpoints to
6606 accept. Skip the others. */
6608 if (args
!= NULL
&& *args
!= '\0')
6610 if (allflag
) /* maintenance info breakpoint */
6612 if (parse_and_eval_long (args
) != b
->number
)
6615 else /* all others */
6617 if (!number_is_in_list (args
, b
->number
))
6621 /* We only print out user settable breakpoints unless the
6623 if (allflag
|| user_breakpoint_p (b
))
6624 print_one_breakpoint (b
, &last_loc
, allflag
);
6628 if (nr_printable_breakpoints
== 0)
6630 /* If there's a filter, let the caller decide how to report
6634 if (args
== NULL
|| *args
== '\0')
6635 uiout
->message ("No breakpoints or watchpoints.\n");
6637 uiout
->message ("No breakpoint or watchpoint matching '%s'.\n",
6643 if (last_loc
&& !server_command
)
6644 set_next_address (last_loc
->gdbarch
, last_loc
->address
);
6647 /* FIXME? Should this be moved up so that it is only called when
6648 there have been breakpoints? */
6649 annotate_breakpoints_table_end ();
6651 return nr_printable_breakpoints
;
6654 /* Display the value of default-collect in a way that is generally
6655 compatible with the breakpoint list. */
6658 default_collect_info (void)
6660 struct ui_out
*uiout
= current_uiout
;
6662 /* If it has no value (which is frequently the case), say nothing; a
6663 message like "No default-collect." gets in user's face when it's
6665 if (!*default_collect
)
6668 /* The following phrase lines up nicely with per-tracepoint collect
6670 uiout
->text ("default collect ");
6671 uiout
->field_string ("default-collect", default_collect
);
6672 uiout
->text (" \n");
6676 info_breakpoints_command (const char *args
, int from_tty
)
6678 breakpoint_1 (args
, 0, NULL
);
6680 default_collect_info ();
6684 info_watchpoints_command (const char *args
, int from_tty
)
6686 int num_printed
= breakpoint_1 (args
, 0, is_watchpoint
);
6687 struct ui_out
*uiout
= current_uiout
;
6689 if (num_printed
== 0)
6691 if (args
== NULL
|| *args
== '\0')
6692 uiout
->message ("No watchpoints.\n");
6694 uiout
->message ("No watchpoint matching '%s'.\n", args
);
6699 maintenance_info_breakpoints (const char *args
, int from_tty
)
6701 breakpoint_1 (args
, 1, NULL
);
6703 default_collect_info ();
6707 breakpoint_has_pc (struct breakpoint
*b
,
6708 struct program_space
*pspace
,
6709 CORE_ADDR pc
, struct obj_section
*section
)
6711 struct bp_location
*bl
= b
->loc
;
6713 for (; bl
; bl
= bl
->next
)
6715 if (bl
->pspace
== pspace
6716 && bl
->address
== pc
6717 && (!overlay_debugging
|| bl
->section
== section
))
6723 /* Print a message describing any user-breakpoints set at PC. This
6724 concerns with logical breakpoints, so we match program spaces, not
6728 describe_other_breakpoints (struct gdbarch
*gdbarch
,
6729 struct program_space
*pspace
, CORE_ADDR pc
,
6730 struct obj_section
*section
, int thread
)
6733 struct breakpoint
*b
;
6736 others
+= (user_breakpoint_p (b
)
6737 && breakpoint_has_pc (b
, pspace
, pc
, section
));
6741 printf_filtered (_("Note: breakpoint "));
6742 else /* if (others == ???) */
6743 printf_filtered (_("Note: breakpoints "));
6745 if (user_breakpoint_p (b
) && breakpoint_has_pc (b
, pspace
, pc
, section
))
6748 printf_filtered ("%d", b
->number
);
6749 if (b
->thread
== -1 && thread
!= -1)
6750 printf_filtered (" (all threads)");
6751 else if (b
->thread
!= -1)
6752 printf_filtered (" (thread %d)", b
->thread
);
6753 printf_filtered ("%s%s ",
6754 ((b
->enable_state
== bp_disabled
6755 || b
->enable_state
== bp_call_disabled
)
6759 : ((others
== 1) ? " and" : ""));
6761 printf_filtered (_("also set at pc "));
6762 fputs_filtered (paddress (gdbarch
, pc
), gdb_stdout
);
6763 printf_filtered (".\n");
6768 /* Return true iff it is meaningful to use the address member of
6769 BPT locations. For some breakpoint types, the locations' address members
6770 are irrelevant and it makes no sense to attempt to compare them to other
6771 addresses (or use them for any other purpose either).
6773 More specifically, each of the following breakpoint types will
6774 always have a zero valued location address and we don't want to mark
6775 breakpoints of any of these types to be a duplicate of an actual
6776 breakpoint location at address zero:
6784 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
6786 enum bptype type
= bpt
->type
;
6788 return (type
!= bp_watchpoint
&& type
!= bp_catchpoint
);
6791 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
6792 true if LOC1 and LOC2 represent the same watchpoint location. */
6795 watchpoint_locations_match (struct bp_location
*loc1
,
6796 struct bp_location
*loc2
)
6798 struct watchpoint
*w1
= (struct watchpoint
*) loc1
->owner
;
6799 struct watchpoint
*w2
= (struct watchpoint
*) loc2
->owner
;
6801 /* Both of them must exist. */
6802 gdb_assert (w1
!= NULL
);
6803 gdb_assert (w2
!= NULL
);
6805 /* If the target can evaluate the condition expression in hardware,
6806 then we we need to insert both watchpoints even if they are at
6807 the same place. Otherwise the watchpoint will only trigger when
6808 the condition of whichever watchpoint was inserted evaluates to
6809 true, not giving a chance for GDB to check the condition of the
6810 other watchpoint. */
6812 && target_can_accel_watchpoint_condition (loc1
->address
,
6814 loc1
->watchpoint_type
,
6815 w1
->cond_exp
.get ()))
6817 && target_can_accel_watchpoint_condition (loc2
->address
,
6819 loc2
->watchpoint_type
,
6820 w2
->cond_exp
.get ())))
6823 /* Note that this checks the owner's type, not the location's. In
6824 case the target does not support read watchpoints, but does
6825 support access watchpoints, we'll have bp_read_watchpoint
6826 watchpoints with hw_access locations. Those should be considered
6827 duplicates of hw_read locations. The hw_read locations will
6828 become hw_access locations later. */
6829 return (loc1
->owner
->type
== loc2
->owner
->type
6830 && loc1
->pspace
->aspace
== loc2
->pspace
->aspace
6831 && loc1
->address
== loc2
->address
6832 && loc1
->length
== loc2
->length
);
6835 /* See breakpoint.h. */
6838 breakpoint_address_match (const address_space
*aspace1
, CORE_ADDR addr1
,
6839 const address_space
*aspace2
, CORE_ADDR addr2
)
6841 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
6842 || aspace1
== aspace2
)
6846 /* Returns true if {ASPACE2,ADDR2} falls within the range determined by
6847 {ASPACE1,ADDR1,LEN1}. In most targets, this can only be true if ASPACE1
6848 matches ASPACE2. On targets that have global breakpoints, the address
6849 space doesn't really matter. */
6852 breakpoint_address_match_range (const address_space
*aspace1
,
6854 int len1
, const address_space
*aspace2
,
6857 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
6858 || aspace1
== aspace2
)
6859 && addr2
>= addr1
&& addr2
< addr1
+ len1
);
6862 /* Returns true if {ASPACE,ADDR} matches the breakpoint BL. BL may be
6863 a ranged breakpoint. In most targets, a match happens only if ASPACE
6864 matches the breakpoint's address space. On targets that have global
6865 breakpoints, the address space doesn't really matter. */
6868 breakpoint_location_address_match (struct bp_location
*bl
,
6869 const address_space
*aspace
,
6872 return (breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
6875 && breakpoint_address_match_range (bl
->pspace
->aspace
,
6876 bl
->address
, bl
->length
,
6880 /* Returns true if the [ADDR,ADDR+LEN) range in ASPACE overlaps
6881 breakpoint BL. BL may be a ranged breakpoint. In most targets, a
6882 match happens only if ASPACE matches the breakpoint's address
6883 space. On targets that have global breakpoints, the address space
6884 doesn't really matter. */
6887 breakpoint_location_address_range_overlap (struct bp_location
*bl
,
6888 const address_space
*aspace
,
6889 CORE_ADDR addr
, int len
)
6891 if (gdbarch_has_global_breakpoints (target_gdbarch ())
6892 || bl
->pspace
->aspace
== aspace
)
6894 int bl_len
= bl
->length
!= 0 ? bl
->length
: 1;
6896 if (mem_ranges_overlap (addr
, len
, bl
->address
, bl_len
))
6902 /* If LOC1 and LOC2's owners are not tracepoints, returns false directly.
6903 Then, if LOC1 and LOC2 represent the same tracepoint location, returns
6904 true, otherwise returns false. */
6907 tracepoint_locations_match (struct bp_location
*loc1
,
6908 struct bp_location
*loc2
)
6910 if (is_tracepoint (loc1
->owner
) && is_tracepoint (loc2
->owner
))
6911 /* Since tracepoint locations are never duplicated with others', tracepoint
6912 locations at the same address of different tracepoints are regarded as
6913 different locations. */
6914 return (loc1
->address
== loc2
->address
&& loc1
->owner
== loc2
->owner
);
6919 /* Assuming LOC1 and LOC2's types' have meaningful target addresses
6920 (breakpoint_address_is_meaningful), returns true if LOC1 and LOC2
6921 represent the same location. */
6924 breakpoint_locations_match (struct bp_location
*loc1
,
6925 struct bp_location
*loc2
)
6927 int hw_point1
, hw_point2
;
6929 /* Both of them must not be in moribund_locations. */
6930 gdb_assert (loc1
->owner
!= NULL
);
6931 gdb_assert (loc2
->owner
!= NULL
);
6933 hw_point1
= is_hardware_watchpoint (loc1
->owner
);
6934 hw_point2
= is_hardware_watchpoint (loc2
->owner
);
6936 if (hw_point1
!= hw_point2
)
6939 return watchpoint_locations_match (loc1
, loc2
);
6940 else if (is_tracepoint (loc1
->owner
) || is_tracepoint (loc2
->owner
))
6941 return tracepoint_locations_match (loc1
, loc2
);
6943 /* We compare bp_location.length in order to cover ranged breakpoints. */
6944 return (breakpoint_address_match (loc1
->pspace
->aspace
, loc1
->address
,
6945 loc2
->pspace
->aspace
, loc2
->address
)
6946 && loc1
->length
== loc2
->length
);
6950 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
6951 int bnum
, int have_bnum
)
6953 /* The longest string possibly returned by hex_string_custom
6954 is 50 chars. These must be at least that big for safety. */
6958 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
6959 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
6961 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
6962 bnum
, astr1
, astr2
);
6964 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
6967 /* Adjust a breakpoint's address to account for architectural
6968 constraints on breakpoint placement. Return the adjusted address.
6969 Note: Very few targets require this kind of adjustment. For most
6970 targets, this function is simply the identity function. */
6973 adjust_breakpoint_address (struct gdbarch
*gdbarch
,
6974 CORE_ADDR bpaddr
, enum bptype bptype
)
6976 if (bptype
== bp_watchpoint
6977 || bptype
== bp_hardware_watchpoint
6978 || bptype
== bp_read_watchpoint
6979 || bptype
== bp_access_watchpoint
6980 || bptype
== bp_catchpoint
)
6982 /* Watchpoints and the various bp_catch_* eventpoints should not
6983 have their addresses modified. */
6986 else if (bptype
== bp_single_step
)
6988 /* Single-step breakpoints should not have their addresses
6989 modified. If there's any architectural constrain that
6990 applies to this address, then it should have already been
6991 taken into account when the breakpoint was created in the
6992 first place. If we didn't do this, stepping through e.g.,
6993 Thumb-2 IT blocks would break. */
6998 CORE_ADDR adjusted_bpaddr
= bpaddr
;
7000 if (gdbarch_adjust_breakpoint_address_p (gdbarch
))
7002 /* Some targets have architectural constraints on the placement
7003 of breakpoint instructions. Obtain the adjusted address. */
7004 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (gdbarch
, bpaddr
);
7007 adjusted_bpaddr
= address_significant (gdbarch
, adjusted_bpaddr
);
7009 /* An adjusted breakpoint address can significantly alter
7010 a user's expectations. Print a warning if an adjustment
7012 if (adjusted_bpaddr
!= bpaddr
)
7013 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
7015 return adjusted_bpaddr
;
7019 bp_location::bp_location (const bp_location_ops
*ops
, breakpoint
*owner
)
7021 bp_location
*loc
= this;
7023 gdb_assert (ops
!= NULL
);
7027 loc
->cond_bytecode
= NULL
;
7028 loc
->shlib_disabled
= 0;
7031 switch (owner
->type
)
7034 case bp_single_step
:
7038 case bp_longjmp_resume
:
7039 case bp_longjmp_call_dummy
:
7041 case bp_exception_resume
:
7042 case bp_step_resume
:
7043 case bp_hp_step_resume
:
7044 case bp_watchpoint_scope
:
7046 case bp_std_terminate
:
7047 case bp_shlib_event
:
7048 case bp_thread_event
:
7049 case bp_overlay_event
:
7051 case bp_longjmp_master
:
7052 case bp_std_terminate_master
:
7053 case bp_exception_master
:
7054 case bp_gnu_ifunc_resolver
:
7055 case bp_gnu_ifunc_resolver_return
:
7057 loc
->loc_type
= bp_loc_software_breakpoint
;
7058 mark_breakpoint_location_modified (loc
);
7060 case bp_hardware_breakpoint
:
7061 loc
->loc_type
= bp_loc_hardware_breakpoint
;
7062 mark_breakpoint_location_modified (loc
);
7064 case bp_hardware_watchpoint
:
7065 case bp_read_watchpoint
:
7066 case bp_access_watchpoint
:
7067 loc
->loc_type
= bp_loc_hardware_watchpoint
;
7072 case bp_fast_tracepoint
:
7073 case bp_static_tracepoint
:
7074 loc
->loc_type
= bp_loc_other
;
7077 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
7083 /* Allocate a struct bp_location. */
7085 static struct bp_location
*
7086 allocate_bp_location (struct breakpoint
*bpt
)
7088 return bpt
->ops
->allocate_location (bpt
);
7092 free_bp_location (struct bp_location
*loc
)
7094 loc
->ops
->dtor (loc
);
7098 /* Increment reference count. */
7101 incref_bp_location (struct bp_location
*bl
)
7106 /* Decrement reference count. If the reference count reaches 0,
7107 destroy the bp_location. Sets *BLP to NULL. */
7110 decref_bp_location (struct bp_location
**blp
)
7112 gdb_assert ((*blp
)->refc
> 0);
7114 if (--(*blp
)->refc
== 0)
7115 free_bp_location (*blp
);
7119 /* Add breakpoint B at the end of the global breakpoint chain. */
7122 add_to_breakpoint_chain (std::unique_ptr
<breakpoint
> &&b
)
7124 struct breakpoint
*b1
;
7125 struct breakpoint
*result
= b
.get ();
7127 /* Add this breakpoint to the end of the chain so that a list of
7128 breakpoints will come out in order of increasing numbers. */
7130 b1
= breakpoint_chain
;
7132 breakpoint_chain
= b
.release ();
7137 b1
->next
= b
.release ();
7143 /* Initializes breakpoint B with type BPTYPE and no locations yet. */
7146 init_raw_breakpoint_without_location (struct breakpoint
*b
,
7147 struct gdbarch
*gdbarch
,
7149 const struct breakpoint_ops
*ops
)
7151 gdb_assert (ops
!= NULL
);
7155 b
->gdbarch
= gdbarch
;
7156 b
->language
= current_language
->la_language
;
7157 b
->input_radix
= input_radix
;
7158 b
->related_breakpoint
= b
;
7161 /* Helper to set_raw_breakpoint below. Creates a breakpoint
7162 that has type BPTYPE and has no locations as yet. */
7164 static struct breakpoint
*
7165 set_raw_breakpoint_without_location (struct gdbarch
*gdbarch
,
7167 const struct breakpoint_ops
*ops
)
7169 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (bptype
);
7171 init_raw_breakpoint_without_location (b
.get (), gdbarch
, bptype
, ops
);
7172 return add_to_breakpoint_chain (std::move (b
));
7175 /* Initialize loc->function_name. EXPLICIT_LOC says no indirect function
7176 resolutions should be made as the user specified the location explicitly
7180 set_breakpoint_location_function (struct bp_location
*loc
, int explicit_loc
)
7182 gdb_assert (loc
->owner
!= NULL
);
7184 if (loc
->owner
->type
== bp_breakpoint
7185 || loc
->owner
->type
== bp_hardware_breakpoint
7186 || is_tracepoint (loc
->owner
))
7189 const char *function_name
;
7190 CORE_ADDR func_addr
;
7192 find_pc_partial_function_gnu_ifunc (loc
->address
, &function_name
,
7193 &func_addr
, NULL
, &is_gnu_ifunc
);
7195 if (is_gnu_ifunc
&& !explicit_loc
)
7197 struct breakpoint
*b
= loc
->owner
;
7199 gdb_assert (loc
->pspace
== current_program_space
);
7200 if (gnu_ifunc_resolve_name (function_name
,
7201 &loc
->requested_address
))
7203 /* Recalculate ADDRESS based on new REQUESTED_ADDRESS. */
7204 loc
->address
= adjust_breakpoint_address (loc
->gdbarch
,
7205 loc
->requested_address
,
7208 else if (b
->type
== bp_breakpoint
&& b
->loc
== loc
7209 && loc
->next
== NULL
&& b
->related_breakpoint
== b
)
7211 /* Create only the whole new breakpoint of this type but do not
7212 mess more complicated breakpoints with multiple locations. */
7213 b
->type
= bp_gnu_ifunc_resolver
;
7214 /* Remember the resolver's address for use by the return
7216 loc
->related_address
= func_addr
;
7221 loc
->function_name
= xstrdup (function_name
);
7225 /* Attempt to determine architecture of location identified by SAL. */
7227 get_sal_arch (struct symtab_and_line sal
)
7230 return get_objfile_arch (sal
.section
->objfile
);
7232 return get_objfile_arch (SYMTAB_OBJFILE (sal
.symtab
));
7237 /* Low level routine for partially initializing a breakpoint of type
7238 BPTYPE. The newly created breakpoint's address, section, source
7239 file name, and line number are provided by SAL.
7241 It is expected that the caller will complete the initialization of
7242 the newly created breakpoint struct as well as output any status
7243 information regarding the creation of a new breakpoint. */
7246 init_raw_breakpoint (struct breakpoint
*b
, struct gdbarch
*gdbarch
,
7247 struct symtab_and_line sal
, enum bptype bptype
,
7248 const struct breakpoint_ops
*ops
)
7250 init_raw_breakpoint_without_location (b
, gdbarch
, bptype
, ops
);
7252 add_location_to_breakpoint (b
, &sal
);
7254 if (bptype
!= bp_catchpoint
)
7255 gdb_assert (sal
.pspace
!= NULL
);
7257 /* Store the program space that was used to set the breakpoint,
7258 except for ordinary breakpoints, which are independent of the
7260 if (bptype
!= bp_breakpoint
&& bptype
!= bp_hardware_breakpoint
)
7261 b
->pspace
= sal
.pspace
;
7264 /* set_raw_breakpoint is a low level routine for allocating and
7265 partially initializing a breakpoint of type BPTYPE. The newly
7266 created breakpoint's address, section, source file name, and line
7267 number are provided by SAL. The newly created and partially
7268 initialized breakpoint is added to the breakpoint chain and
7269 is also returned as the value of this function.
7271 It is expected that the caller will complete the initialization of
7272 the newly created breakpoint struct as well as output any status
7273 information regarding the creation of a new breakpoint. In
7274 particular, set_raw_breakpoint does NOT set the breakpoint
7275 number! Care should be taken to not allow an error to occur
7276 prior to completing the initialization of the breakpoint. If this
7277 should happen, a bogus breakpoint will be left on the chain. */
7280 set_raw_breakpoint (struct gdbarch
*gdbarch
,
7281 struct symtab_and_line sal
, enum bptype bptype
,
7282 const struct breakpoint_ops
*ops
)
7284 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (bptype
);
7286 init_raw_breakpoint (b
.get (), gdbarch
, sal
, bptype
, ops
);
7287 return add_to_breakpoint_chain (std::move (b
));
7290 /* Call this routine when stepping and nexting to enable a breakpoint
7291 if we do a longjmp() or 'throw' in TP. FRAME is the frame which
7292 initiated the operation. */
7295 set_longjmp_breakpoint (struct thread_info
*tp
, struct frame_id frame
)
7297 struct breakpoint
*b
, *b_tmp
;
7298 int thread
= tp
->global_num
;
7300 /* To avoid having to rescan all objfile symbols at every step,
7301 we maintain a list of continually-inserted but always disabled
7302 longjmp "master" breakpoints. Here, we simply create momentary
7303 clones of those and enable them for the requested thread. */
7304 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7305 if (b
->pspace
== current_program_space
7306 && (b
->type
== bp_longjmp_master
7307 || b
->type
== bp_exception_master
))
7309 enum bptype type
= b
->type
== bp_longjmp_master
? bp_longjmp
: bp_exception
;
7310 struct breakpoint
*clone
;
7312 /* longjmp_breakpoint_ops ensures INITIATING_FRAME is cleared again
7313 after their removal. */
7314 clone
= momentary_breakpoint_from_master (b
, type
,
7315 &momentary_breakpoint_ops
, 1);
7316 clone
->thread
= thread
;
7319 tp
->initiating_frame
= frame
;
7322 /* Delete all longjmp breakpoints from THREAD. */
7324 delete_longjmp_breakpoint (int thread
)
7326 struct breakpoint
*b
, *b_tmp
;
7328 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7329 if (b
->type
== bp_longjmp
|| b
->type
== bp_exception
)
7331 if (b
->thread
== thread
)
7332 delete_breakpoint (b
);
7337 delete_longjmp_breakpoint_at_next_stop (int thread
)
7339 struct breakpoint
*b
, *b_tmp
;
7341 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7342 if (b
->type
== bp_longjmp
|| b
->type
== bp_exception
)
7344 if (b
->thread
== thread
)
7345 b
->disposition
= disp_del_at_next_stop
;
7349 /* Place breakpoints of type bp_longjmp_call_dummy to catch longjmp for
7350 INFERIOR_PTID thread. Chain them all by RELATED_BREAKPOINT and return
7351 pointer to any of them. Return NULL if this system cannot place longjmp
7355 set_longjmp_breakpoint_for_call_dummy (void)
7357 struct breakpoint
*b
, *retval
= NULL
;
7360 if (b
->pspace
== current_program_space
&& b
->type
== bp_longjmp_master
)
7362 struct breakpoint
*new_b
;
7364 new_b
= momentary_breakpoint_from_master (b
, bp_longjmp_call_dummy
,
7365 &momentary_breakpoint_ops
,
7367 new_b
->thread
= ptid_to_global_thread_id (inferior_ptid
);
7369 /* Link NEW_B into the chain of RETVAL breakpoints. */
7371 gdb_assert (new_b
->related_breakpoint
== new_b
);
7374 new_b
->related_breakpoint
= retval
;
7375 while (retval
->related_breakpoint
!= new_b
->related_breakpoint
)
7376 retval
= retval
->related_breakpoint
;
7377 retval
->related_breakpoint
= new_b
;
7383 /* Verify all existing dummy frames and their associated breakpoints for
7384 TP. Remove those which can no longer be found in the current frame
7387 You should call this function only at places where it is safe to currently
7388 unwind the whole stack. Failed stack unwind would discard live dummy
7392 check_longjmp_breakpoint_for_call_dummy (struct thread_info
*tp
)
7394 struct breakpoint
*b
, *b_tmp
;
7396 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7397 if (b
->type
== bp_longjmp_call_dummy
&& b
->thread
== tp
->global_num
)
7399 struct breakpoint
*dummy_b
= b
->related_breakpoint
;
7401 while (dummy_b
!= b
&& dummy_b
->type
!= bp_call_dummy
)
7402 dummy_b
= dummy_b
->related_breakpoint
;
7403 if (dummy_b
->type
!= bp_call_dummy
7404 || frame_find_by_id (dummy_b
->frame_id
) != NULL
)
7407 dummy_frame_discard (dummy_b
->frame_id
, tp
->ptid
);
7409 while (b
->related_breakpoint
!= b
)
7411 if (b_tmp
== b
->related_breakpoint
)
7412 b_tmp
= b
->related_breakpoint
->next
;
7413 delete_breakpoint (b
->related_breakpoint
);
7415 delete_breakpoint (b
);
7420 enable_overlay_breakpoints (void)
7422 struct breakpoint
*b
;
7425 if (b
->type
== bp_overlay_event
)
7427 b
->enable_state
= bp_enabled
;
7428 update_global_location_list (UGLL_MAY_INSERT
);
7429 overlay_events_enabled
= 1;
7434 disable_overlay_breakpoints (void)
7436 struct breakpoint
*b
;
7439 if (b
->type
== bp_overlay_event
)
7441 b
->enable_state
= bp_disabled
;
7442 update_global_location_list (UGLL_DONT_INSERT
);
7443 overlay_events_enabled
= 0;
7447 /* Set an active std::terminate breakpoint for each std::terminate
7448 master breakpoint. */
7450 set_std_terminate_breakpoint (void)
7452 struct breakpoint
*b
, *b_tmp
;
7454 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7455 if (b
->pspace
== current_program_space
7456 && b
->type
== bp_std_terminate_master
)
7458 momentary_breakpoint_from_master (b
, bp_std_terminate
,
7459 &momentary_breakpoint_ops
, 1);
7463 /* Delete all the std::terminate breakpoints. */
7465 delete_std_terminate_breakpoint (void)
7467 struct breakpoint
*b
, *b_tmp
;
7469 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7470 if (b
->type
== bp_std_terminate
)
7471 delete_breakpoint (b
);
7475 create_thread_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7477 struct breakpoint
*b
;
7479 b
= create_internal_breakpoint (gdbarch
, address
, bp_thread_event
,
7480 &internal_breakpoint_ops
);
7482 b
->enable_state
= bp_enabled
;
7483 /* location has to be used or breakpoint_re_set will delete me. */
7484 b
->location
= new_address_location (b
->loc
->address
, NULL
, 0);
7486 update_global_location_list_nothrow (UGLL_MAY_INSERT
);
7491 struct lang_and_radix
7497 /* Create a breakpoint for JIT code registration and unregistration. */
7500 create_jit_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7502 return create_internal_breakpoint (gdbarch
, address
, bp_jit_event
,
7503 &internal_breakpoint_ops
);
7506 /* Remove JIT code registration and unregistration breakpoint(s). */
7509 remove_jit_event_breakpoints (void)
7511 struct breakpoint
*b
, *b_tmp
;
7513 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7514 if (b
->type
== bp_jit_event
7515 && b
->loc
->pspace
== current_program_space
)
7516 delete_breakpoint (b
);
7520 remove_solib_event_breakpoints (void)
7522 struct breakpoint
*b
, *b_tmp
;
7524 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7525 if (b
->type
== bp_shlib_event
7526 && b
->loc
->pspace
== current_program_space
)
7527 delete_breakpoint (b
);
7530 /* See breakpoint.h. */
7533 remove_solib_event_breakpoints_at_next_stop (void)
7535 struct breakpoint
*b
, *b_tmp
;
7537 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7538 if (b
->type
== bp_shlib_event
7539 && b
->loc
->pspace
== current_program_space
)
7540 b
->disposition
= disp_del_at_next_stop
;
7543 /* Helper for create_solib_event_breakpoint /
7544 create_and_insert_solib_event_breakpoint. Allows specifying which
7545 INSERT_MODE to pass through to update_global_location_list. */
7547 static struct breakpoint
*
7548 create_solib_event_breakpoint_1 (struct gdbarch
*gdbarch
, CORE_ADDR address
,
7549 enum ugll_insert_mode insert_mode
)
7551 struct breakpoint
*b
;
7553 b
= create_internal_breakpoint (gdbarch
, address
, bp_shlib_event
,
7554 &internal_breakpoint_ops
);
7555 update_global_location_list_nothrow (insert_mode
);
7560 create_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7562 return create_solib_event_breakpoint_1 (gdbarch
, address
, UGLL_MAY_INSERT
);
7565 /* See breakpoint.h. */
7568 create_and_insert_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7570 struct breakpoint
*b
;
7572 /* Explicitly tell update_global_location_list to insert
7574 b
= create_solib_event_breakpoint_1 (gdbarch
, address
, UGLL_INSERT
);
7575 if (!b
->loc
->inserted
)
7577 delete_breakpoint (b
);
7583 /* Disable any breakpoints that are on code in shared libraries. Only
7584 apply to enabled breakpoints, disabled ones can just stay disabled. */
7587 disable_breakpoints_in_shlibs (void)
7589 struct bp_location
*loc
, **locp_tmp
;
7591 ALL_BP_LOCATIONS (loc
, locp_tmp
)
7593 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7594 struct breakpoint
*b
= loc
->owner
;
7596 /* We apply the check to all breakpoints, including disabled for
7597 those with loc->duplicate set. This is so that when breakpoint
7598 becomes enabled, or the duplicate is removed, gdb will try to
7599 insert all breakpoints. If we don't set shlib_disabled here,
7600 we'll try to insert those breakpoints and fail. */
7601 if (((b
->type
== bp_breakpoint
)
7602 || (b
->type
== bp_jit_event
)
7603 || (b
->type
== bp_hardware_breakpoint
)
7604 || (is_tracepoint (b
)))
7605 && loc
->pspace
== current_program_space
7606 && !loc
->shlib_disabled
7607 && solib_name_from_address (loc
->pspace
, loc
->address
)
7610 loc
->shlib_disabled
= 1;
7615 /* Disable any breakpoints and tracepoints that are in SOLIB upon
7616 notification of unloaded_shlib. Only apply to enabled breakpoints,
7617 disabled ones can just stay disabled. */
7620 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
7622 struct bp_location
*loc
, **locp_tmp
;
7623 int disabled_shlib_breaks
= 0;
7625 ALL_BP_LOCATIONS (loc
, locp_tmp
)
7627 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7628 struct breakpoint
*b
= loc
->owner
;
7630 if (solib
->pspace
== loc
->pspace
7631 && !loc
->shlib_disabled
7632 && (((b
->type
== bp_breakpoint
7633 || b
->type
== bp_jit_event
7634 || b
->type
== bp_hardware_breakpoint
)
7635 && (loc
->loc_type
== bp_loc_hardware_breakpoint
7636 || loc
->loc_type
== bp_loc_software_breakpoint
))
7637 || is_tracepoint (b
))
7638 && solib_contains_address_p (solib
, loc
->address
))
7640 loc
->shlib_disabled
= 1;
7641 /* At this point, we cannot rely on remove_breakpoint
7642 succeeding so we must mark the breakpoint as not inserted
7643 to prevent future errors occurring in remove_breakpoints. */
7646 /* This may cause duplicate notifications for the same breakpoint. */
7647 observer_notify_breakpoint_modified (b
);
7649 if (!disabled_shlib_breaks
)
7651 target_terminal::ours_for_output ();
7652 warning (_("Temporarily disabling breakpoints "
7653 "for unloaded shared library \"%s\""),
7656 disabled_shlib_breaks
= 1;
7661 /* Disable any breakpoints and tracepoints in OBJFILE upon
7662 notification of free_objfile. Only apply to enabled breakpoints,
7663 disabled ones can just stay disabled. */
7666 disable_breakpoints_in_freed_objfile (struct objfile
*objfile
)
7668 struct breakpoint
*b
;
7670 if (objfile
== NULL
)
7673 /* OBJF_SHARED|OBJF_USERLOADED objfiles are dynamic modules manually
7674 managed by the user with add-symbol-file/remove-symbol-file.
7675 Similarly to how breakpoints in shared libraries are handled in
7676 response to "nosharedlibrary", mark breakpoints in such modules
7677 shlib_disabled so they end up uninserted on the next global
7678 location list update. Shared libraries not loaded by the user
7679 aren't handled here -- they're already handled in
7680 disable_breakpoints_in_unloaded_shlib, called by solib.c's
7681 solib_unloaded observer. We skip objfiles that are not
7682 OBJF_SHARED as those aren't considered dynamic objects (e.g. the
7684 if ((objfile
->flags
& OBJF_SHARED
) == 0
7685 || (objfile
->flags
& OBJF_USERLOADED
) == 0)
7690 struct bp_location
*loc
;
7691 int bp_modified
= 0;
7693 if (!is_breakpoint (b
) && !is_tracepoint (b
))
7696 for (loc
= b
->loc
; loc
!= NULL
; loc
= loc
->next
)
7698 CORE_ADDR loc_addr
= loc
->address
;
7700 if (loc
->loc_type
!= bp_loc_hardware_breakpoint
7701 && loc
->loc_type
!= bp_loc_software_breakpoint
)
7704 if (loc
->shlib_disabled
!= 0)
7707 if (objfile
->pspace
!= loc
->pspace
)
7710 if (loc
->loc_type
!= bp_loc_hardware_breakpoint
7711 && loc
->loc_type
!= bp_loc_software_breakpoint
)
7714 if (is_addr_in_objfile (loc_addr
, objfile
))
7716 loc
->shlib_disabled
= 1;
7717 /* At this point, we don't know whether the object was
7718 unmapped from the inferior or not, so leave the
7719 inserted flag alone. We'll handle failure to
7720 uninsert quietly, in case the object was indeed
7723 mark_breakpoint_location_modified (loc
);
7730 observer_notify_breakpoint_modified (b
);
7734 /* FORK & VFORK catchpoints. */
7736 /* An instance of this type is used to represent a fork or vfork
7737 catchpoint. A breakpoint is really of this type iff its ops pointer points
7738 to CATCH_FORK_BREAKPOINT_OPS. */
7740 struct fork_catchpoint
: public breakpoint
7742 /* Process id of a child process whose forking triggered this
7743 catchpoint. This field is only valid immediately after this
7744 catchpoint has triggered. */
7745 ptid_t forked_inferior_pid
;
7748 /* Implement the "insert" breakpoint_ops method for fork
7752 insert_catch_fork (struct bp_location
*bl
)
7754 return target_insert_fork_catchpoint (ptid_get_pid (inferior_ptid
));
7757 /* Implement the "remove" breakpoint_ops method for fork
7761 remove_catch_fork (struct bp_location
*bl
, enum remove_bp_reason reason
)
7763 return target_remove_fork_catchpoint (ptid_get_pid (inferior_ptid
));
7766 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
7770 breakpoint_hit_catch_fork (const struct bp_location
*bl
,
7771 const address_space
*aspace
, CORE_ADDR bp_addr
,
7772 const struct target_waitstatus
*ws
)
7774 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bl
->owner
;
7776 if (ws
->kind
!= TARGET_WAITKIND_FORKED
)
7779 c
->forked_inferior_pid
= ws
->value
.related_pid
;
7783 /* Implement the "print_it" breakpoint_ops method for fork
7786 static enum print_stop_action
7787 print_it_catch_fork (bpstat bs
)
7789 struct ui_out
*uiout
= current_uiout
;
7790 struct breakpoint
*b
= bs
->breakpoint_at
;
7791 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bs
->breakpoint_at
;
7793 annotate_catchpoint (b
->number
);
7794 maybe_print_thread_hit_breakpoint (uiout
);
7795 if (b
->disposition
== disp_del
)
7796 uiout
->text ("Temporary catchpoint ");
7798 uiout
->text ("Catchpoint ");
7799 if (uiout
->is_mi_like_p ())
7801 uiout
->field_string ("reason", async_reason_lookup (EXEC_ASYNC_FORK
));
7802 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
7804 uiout
->field_int ("bkptno", b
->number
);
7805 uiout
->text (" (forked process ");
7806 uiout
->field_int ("newpid", ptid_get_pid (c
->forked_inferior_pid
));
7807 uiout
->text ("), ");
7808 return PRINT_SRC_AND_LOC
;
7811 /* Implement the "print_one" breakpoint_ops method for fork
7815 print_one_catch_fork (struct breakpoint
*b
, struct bp_location
**last_loc
)
7817 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
7818 struct value_print_options opts
;
7819 struct ui_out
*uiout
= current_uiout
;
7821 get_user_print_options (&opts
);
7823 /* Field 4, the address, is omitted (which makes the columns not
7824 line up too nicely with the headers, but the effect is relatively
7826 if (opts
.addressprint
)
7827 uiout
->field_skip ("addr");
7829 uiout
->text ("fork");
7830 if (!ptid_equal (c
->forked_inferior_pid
, null_ptid
))
7832 uiout
->text (", process ");
7833 uiout
->field_int ("what", ptid_get_pid (c
->forked_inferior_pid
));
7837 if (uiout
->is_mi_like_p ())
7838 uiout
->field_string ("catch-type", "fork");
7841 /* Implement the "print_mention" breakpoint_ops method for fork
7845 print_mention_catch_fork (struct breakpoint
*b
)
7847 printf_filtered (_("Catchpoint %d (fork)"), b
->number
);
7850 /* Implement the "print_recreate" breakpoint_ops method for fork
7854 print_recreate_catch_fork (struct breakpoint
*b
, struct ui_file
*fp
)
7856 fprintf_unfiltered (fp
, "catch fork");
7857 print_recreate_thread (b
, fp
);
7860 /* The breakpoint_ops structure to be used in fork catchpoints. */
7862 static struct breakpoint_ops catch_fork_breakpoint_ops
;
7864 /* Implement the "insert" breakpoint_ops method for vfork
7868 insert_catch_vfork (struct bp_location
*bl
)
7870 return target_insert_vfork_catchpoint (ptid_get_pid (inferior_ptid
));
7873 /* Implement the "remove" breakpoint_ops method for vfork
7877 remove_catch_vfork (struct bp_location
*bl
, enum remove_bp_reason reason
)
7879 return target_remove_vfork_catchpoint (ptid_get_pid (inferior_ptid
));
7882 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
7886 breakpoint_hit_catch_vfork (const struct bp_location
*bl
,
7887 const address_space
*aspace
, CORE_ADDR bp_addr
,
7888 const struct target_waitstatus
*ws
)
7890 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bl
->owner
;
7892 if (ws
->kind
!= TARGET_WAITKIND_VFORKED
)
7895 c
->forked_inferior_pid
= ws
->value
.related_pid
;
7899 /* Implement the "print_it" breakpoint_ops method for vfork
7902 static enum print_stop_action
7903 print_it_catch_vfork (bpstat bs
)
7905 struct ui_out
*uiout
= current_uiout
;
7906 struct breakpoint
*b
= bs
->breakpoint_at
;
7907 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
7909 annotate_catchpoint (b
->number
);
7910 maybe_print_thread_hit_breakpoint (uiout
);
7911 if (b
->disposition
== disp_del
)
7912 uiout
->text ("Temporary catchpoint ");
7914 uiout
->text ("Catchpoint ");
7915 if (uiout
->is_mi_like_p ())
7917 uiout
->field_string ("reason", async_reason_lookup (EXEC_ASYNC_VFORK
));
7918 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
7920 uiout
->field_int ("bkptno", b
->number
);
7921 uiout
->text (" (vforked process ");
7922 uiout
->field_int ("newpid", ptid_get_pid (c
->forked_inferior_pid
));
7923 uiout
->text ("), ");
7924 return PRINT_SRC_AND_LOC
;
7927 /* Implement the "print_one" breakpoint_ops method for vfork
7931 print_one_catch_vfork (struct breakpoint
*b
, struct bp_location
**last_loc
)
7933 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
7934 struct value_print_options opts
;
7935 struct ui_out
*uiout
= current_uiout
;
7937 get_user_print_options (&opts
);
7938 /* Field 4, the address, is omitted (which makes the columns not
7939 line up too nicely with the headers, but the effect is relatively
7941 if (opts
.addressprint
)
7942 uiout
->field_skip ("addr");
7944 uiout
->text ("vfork");
7945 if (!ptid_equal (c
->forked_inferior_pid
, null_ptid
))
7947 uiout
->text (", process ");
7948 uiout
->field_int ("what", ptid_get_pid (c
->forked_inferior_pid
));
7952 if (uiout
->is_mi_like_p ())
7953 uiout
->field_string ("catch-type", "vfork");
7956 /* Implement the "print_mention" breakpoint_ops method for vfork
7960 print_mention_catch_vfork (struct breakpoint
*b
)
7962 printf_filtered (_("Catchpoint %d (vfork)"), b
->number
);
7965 /* Implement the "print_recreate" breakpoint_ops method for vfork
7969 print_recreate_catch_vfork (struct breakpoint
*b
, struct ui_file
*fp
)
7971 fprintf_unfiltered (fp
, "catch vfork");
7972 print_recreate_thread (b
, fp
);
7975 /* The breakpoint_ops structure to be used in vfork catchpoints. */
7977 static struct breakpoint_ops catch_vfork_breakpoint_ops
;
7979 /* An instance of this type is used to represent an solib catchpoint.
7980 A breakpoint is really of this type iff its ops pointer points to
7981 CATCH_SOLIB_BREAKPOINT_OPS. */
7983 struct solib_catchpoint
: public breakpoint
7985 ~solib_catchpoint () override
;
7987 /* True for "catch load", false for "catch unload". */
7988 unsigned char is_load
;
7990 /* Regular expression to match, if any. COMPILED is only valid when
7991 REGEX is non-NULL. */
7993 std::unique_ptr
<compiled_regex
> compiled
;
7996 solib_catchpoint::~solib_catchpoint ()
7998 xfree (this->regex
);
8002 insert_catch_solib (struct bp_location
*ignore
)
8008 remove_catch_solib (struct bp_location
*ignore
, enum remove_bp_reason reason
)
8014 breakpoint_hit_catch_solib (const struct bp_location
*bl
,
8015 const address_space
*aspace
,
8017 const struct target_waitstatus
*ws
)
8019 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) bl
->owner
;
8020 struct breakpoint
*other
;
8022 if (ws
->kind
== TARGET_WAITKIND_LOADED
)
8025 ALL_BREAKPOINTS (other
)
8027 struct bp_location
*other_bl
;
8029 if (other
== bl
->owner
)
8032 if (other
->type
!= bp_shlib_event
)
8035 if (self
->pspace
!= NULL
&& other
->pspace
!= self
->pspace
)
8038 for (other_bl
= other
->loc
; other_bl
!= NULL
; other_bl
= other_bl
->next
)
8040 if (other
->ops
->breakpoint_hit (other_bl
, aspace
, bp_addr
, ws
))
8049 check_status_catch_solib (struct bpstats
*bs
)
8051 struct solib_catchpoint
*self
8052 = (struct solib_catchpoint
*) bs
->breakpoint_at
;
8057 struct so_list
*iter
;
8060 VEC_iterate (so_list_ptr
, current_program_space
->added_solibs
,
8065 || self
->compiled
->exec (iter
->so_name
, 0, NULL
, 0) == 0)
8074 VEC_iterate (char_ptr
, current_program_space
->deleted_solibs
,
8079 || self
->compiled
->exec (iter
, 0, NULL
, 0) == 0)
8085 bs
->print_it
= print_it_noop
;
8088 static enum print_stop_action
8089 print_it_catch_solib (bpstat bs
)
8091 struct breakpoint
*b
= bs
->breakpoint_at
;
8092 struct ui_out
*uiout
= current_uiout
;
8094 annotate_catchpoint (b
->number
);
8095 maybe_print_thread_hit_breakpoint (uiout
);
8096 if (b
->disposition
== disp_del
)
8097 uiout
->text ("Temporary catchpoint ");
8099 uiout
->text ("Catchpoint ");
8100 uiout
->field_int ("bkptno", b
->number
);
8102 if (uiout
->is_mi_like_p ())
8103 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
8104 print_solib_event (1);
8105 return PRINT_SRC_AND_LOC
;
8109 print_one_catch_solib (struct breakpoint
*b
, struct bp_location
**locs
)
8111 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8112 struct value_print_options opts
;
8113 struct ui_out
*uiout
= current_uiout
;
8116 get_user_print_options (&opts
);
8117 /* Field 4, the address, is omitted (which makes the columns not
8118 line up too nicely with the headers, but the effect is relatively
8120 if (opts
.addressprint
)
8123 uiout
->field_skip ("addr");
8130 msg
= xstrprintf (_("load of library matching %s"), self
->regex
);
8132 msg
= xstrdup (_("load of library"));
8137 msg
= xstrprintf (_("unload of library matching %s"), self
->regex
);
8139 msg
= xstrdup (_("unload of library"));
8141 uiout
->field_string ("what", msg
);
8144 if (uiout
->is_mi_like_p ())
8145 uiout
->field_string ("catch-type", self
->is_load
? "load" : "unload");
8149 print_mention_catch_solib (struct breakpoint
*b
)
8151 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8153 printf_filtered (_("Catchpoint %d (%s)"), b
->number
,
8154 self
->is_load
? "load" : "unload");
8158 print_recreate_catch_solib (struct breakpoint
*b
, struct ui_file
*fp
)
8160 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8162 fprintf_unfiltered (fp
, "%s %s",
8163 b
->disposition
== disp_del
? "tcatch" : "catch",
8164 self
->is_load
? "load" : "unload");
8166 fprintf_unfiltered (fp
, " %s", self
->regex
);
8167 fprintf_unfiltered (fp
, "\n");
8170 static struct breakpoint_ops catch_solib_breakpoint_ops
;
8172 /* Shared helper function (MI and CLI) for creating and installing
8173 a shared object event catchpoint. If IS_LOAD is non-zero then
8174 the events to be caught are load events, otherwise they are
8175 unload events. If IS_TEMP is non-zero the catchpoint is a
8176 temporary one. If ENABLED is non-zero the catchpoint is
8177 created in an enabled state. */
8180 add_solib_catchpoint (const char *arg
, int is_load
, int is_temp
, int enabled
)
8182 struct gdbarch
*gdbarch
= get_current_arch ();
8186 arg
= skip_spaces (arg
);
8188 std::unique_ptr
<solib_catchpoint
> c (new solib_catchpoint ());
8192 c
->compiled
.reset (new compiled_regex (arg
, REG_NOSUB
,
8193 _("Invalid regexp")));
8194 c
->regex
= xstrdup (arg
);
8197 c
->is_load
= is_load
;
8198 init_catchpoint (c
.get (), gdbarch
, is_temp
, NULL
,
8199 &catch_solib_breakpoint_ops
);
8201 c
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
8203 install_breakpoint (0, std::move (c
), 1);
8206 /* A helper function that does all the work for "catch load" and
8210 catch_load_or_unload (const char *arg
, int from_tty
, int is_load
,
8211 struct cmd_list_element
*command
)
8214 const int enabled
= 1;
8216 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
8218 add_solib_catchpoint (arg
, is_load
, tempflag
, enabled
);
8222 catch_load_command_1 (const char *arg
, int from_tty
,
8223 struct cmd_list_element
*command
)
8225 catch_load_or_unload (arg
, from_tty
, 1, command
);
8229 catch_unload_command_1 (const char *arg
, int from_tty
,
8230 struct cmd_list_element
*command
)
8232 catch_load_or_unload (arg
, from_tty
, 0, command
);
8235 /* Initialize a new breakpoint of the bp_catchpoint kind. If TEMPFLAG
8236 is non-zero, then make the breakpoint temporary. If COND_STRING is
8237 not NULL, then store it in the breakpoint. OPS, if not NULL, is
8238 the breakpoint_ops structure associated to the catchpoint. */
8241 init_catchpoint (struct breakpoint
*b
,
8242 struct gdbarch
*gdbarch
, int tempflag
,
8243 const char *cond_string
,
8244 const struct breakpoint_ops
*ops
)
8246 symtab_and_line sal
;
8247 sal
.pspace
= current_program_space
;
8249 init_raw_breakpoint (b
, gdbarch
, sal
, bp_catchpoint
, ops
);
8251 b
->cond_string
= (cond_string
== NULL
) ? NULL
: xstrdup (cond_string
);
8252 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
8256 install_breakpoint (int internal
, std::unique_ptr
<breakpoint
> &&arg
, int update_gll
)
8258 breakpoint
*b
= add_to_breakpoint_chain (std::move (arg
));
8259 set_breakpoint_number (internal
, b
);
8260 if (is_tracepoint (b
))
8261 set_tracepoint_count (breakpoint_count
);
8264 observer_notify_breakpoint_created (b
);
8267 update_global_location_list (UGLL_MAY_INSERT
);
8271 create_fork_vfork_event_catchpoint (struct gdbarch
*gdbarch
,
8272 int tempflag
, const char *cond_string
,
8273 const struct breakpoint_ops
*ops
)
8275 std::unique_ptr
<fork_catchpoint
> c (new fork_catchpoint ());
8277 init_catchpoint (c
.get (), gdbarch
, tempflag
, cond_string
, ops
);
8279 c
->forked_inferior_pid
= null_ptid
;
8281 install_breakpoint (0, std::move (c
), 1);
8284 /* Exec catchpoints. */
8286 /* An instance of this type is used to represent an exec catchpoint.
8287 A breakpoint is really of this type iff its ops pointer points to
8288 CATCH_EXEC_BREAKPOINT_OPS. */
8290 struct exec_catchpoint
: public breakpoint
8292 ~exec_catchpoint () override
;
8294 /* Filename of a program whose exec triggered this catchpoint.
8295 This field is only valid immediately after this catchpoint has
8297 char *exec_pathname
;
8300 /* Exec catchpoint destructor. */
8302 exec_catchpoint::~exec_catchpoint ()
8304 xfree (this->exec_pathname
);
8308 insert_catch_exec (struct bp_location
*bl
)
8310 return target_insert_exec_catchpoint (ptid_get_pid (inferior_ptid
));
8314 remove_catch_exec (struct bp_location
*bl
, enum remove_bp_reason reason
)
8316 return target_remove_exec_catchpoint (ptid_get_pid (inferior_ptid
));
8320 breakpoint_hit_catch_exec (const struct bp_location
*bl
,
8321 const address_space
*aspace
, CORE_ADDR bp_addr
,
8322 const struct target_waitstatus
*ws
)
8324 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) bl
->owner
;
8326 if (ws
->kind
!= TARGET_WAITKIND_EXECD
)
8329 c
->exec_pathname
= xstrdup (ws
->value
.execd_pathname
);
8333 static enum print_stop_action
8334 print_it_catch_exec (bpstat bs
)
8336 struct ui_out
*uiout
= current_uiout
;
8337 struct breakpoint
*b
= bs
->breakpoint_at
;
8338 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
8340 annotate_catchpoint (b
->number
);
8341 maybe_print_thread_hit_breakpoint (uiout
);
8342 if (b
->disposition
== disp_del
)
8343 uiout
->text ("Temporary catchpoint ");
8345 uiout
->text ("Catchpoint ");
8346 if (uiout
->is_mi_like_p ())
8348 uiout
->field_string ("reason", async_reason_lookup (EXEC_ASYNC_EXEC
));
8349 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
8351 uiout
->field_int ("bkptno", b
->number
);
8352 uiout
->text (" (exec'd ");
8353 uiout
->field_string ("new-exec", c
->exec_pathname
);
8354 uiout
->text ("), ");
8356 return PRINT_SRC_AND_LOC
;
8360 print_one_catch_exec (struct breakpoint
*b
, struct bp_location
**last_loc
)
8362 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
8363 struct value_print_options opts
;
8364 struct ui_out
*uiout
= current_uiout
;
8366 get_user_print_options (&opts
);
8368 /* Field 4, the address, is omitted (which makes the columns
8369 not line up too nicely with the headers, but the effect
8370 is relatively readable). */
8371 if (opts
.addressprint
)
8372 uiout
->field_skip ("addr");
8374 uiout
->text ("exec");
8375 if (c
->exec_pathname
!= NULL
)
8377 uiout
->text (", program \"");
8378 uiout
->field_string ("what", c
->exec_pathname
);
8379 uiout
->text ("\" ");
8382 if (uiout
->is_mi_like_p ())
8383 uiout
->field_string ("catch-type", "exec");
8387 print_mention_catch_exec (struct breakpoint
*b
)
8389 printf_filtered (_("Catchpoint %d (exec)"), b
->number
);
8392 /* Implement the "print_recreate" breakpoint_ops method for exec
8396 print_recreate_catch_exec (struct breakpoint
*b
, struct ui_file
*fp
)
8398 fprintf_unfiltered (fp
, "catch exec");
8399 print_recreate_thread (b
, fp
);
8402 static struct breakpoint_ops catch_exec_breakpoint_ops
;
8405 hw_breakpoint_used_count (void)
8408 struct breakpoint
*b
;
8409 struct bp_location
*bl
;
8413 if (b
->type
== bp_hardware_breakpoint
&& breakpoint_enabled (b
))
8414 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
8416 /* Special types of hardware breakpoints may use more than
8418 i
+= b
->ops
->resources_needed (bl
);
8425 /* Returns the resources B would use if it were a hardware
8429 hw_watchpoint_use_count (struct breakpoint
*b
)
8432 struct bp_location
*bl
;
8434 if (!breakpoint_enabled (b
))
8437 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
8439 /* Special types of hardware watchpoints may use more than
8441 i
+= b
->ops
->resources_needed (bl
);
8447 /* Returns the sum the used resources of all hardware watchpoints of
8448 type TYPE in the breakpoints list. Also returns in OTHER_TYPE_USED
8449 the sum of the used resources of all hardware watchpoints of other
8450 types _not_ TYPE. */
8453 hw_watchpoint_used_count_others (struct breakpoint
*except
,
8454 enum bptype type
, int *other_type_used
)
8457 struct breakpoint
*b
;
8459 *other_type_used
= 0;
8464 if (!breakpoint_enabled (b
))
8467 if (b
->type
== type
)
8468 i
+= hw_watchpoint_use_count (b
);
8469 else if (is_hardware_watchpoint (b
))
8470 *other_type_used
= 1;
8477 disable_watchpoints_before_interactive_call_start (void)
8479 struct breakpoint
*b
;
8483 if (is_watchpoint (b
) && breakpoint_enabled (b
))
8485 b
->enable_state
= bp_call_disabled
;
8486 update_global_location_list (UGLL_DONT_INSERT
);
8492 enable_watchpoints_after_interactive_call_stop (void)
8494 struct breakpoint
*b
;
8498 if (is_watchpoint (b
) && b
->enable_state
== bp_call_disabled
)
8500 b
->enable_state
= bp_enabled
;
8501 update_global_location_list (UGLL_MAY_INSERT
);
8507 disable_breakpoints_before_startup (void)
8509 current_program_space
->executing_startup
= 1;
8510 update_global_location_list (UGLL_DONT_INSERT
);
8514 enable_breakpoints_after_startup (void)
8516 current_program_space
->executing_startup
= 0;
8517 breakpoint_re_set ();
8520 /* Create a new single-step breakpoint for thread THREAD, with no
8523 static struct breakpoint
*
8524 new_single_step_breakpoint (int thread
, struct gdbarch
*gdbarch
)
8526 std::unique_ptr
<breakpoint
> b (new breakpoint ());
8528 init_raw_breakpoint_without_location (b
.get (), gdbarch
, bp_single_step
,
8529 &momentary_breakpoint_ops
);
8531 b
->disposition
= disp_donttouch
;
8532 b
->frame_id
= null_frame_id
;
8535 gdb_assert (b
->thread
!= 0);
8537 return add_to_breakpoint_chain (std::move (b
));
8540 /* Set a momentary breakpoint of type TYPE at address specified by
8541 SAL. If FRAME_ID is valid, the breakpoint is restricted to that
8545 set_momentary_breakpoint (struct gdbarch
*gdbarch
, struct symtab_and_line sal
,
8546 struct frame_id frame_id
, enum bptype type
)
8548 struct breakpoint
*b
;
8550 /* If FRAME_ID is valid, it should be a real frame, not an inlined or
8552 gdb_assert (!frame_id_artificial_p (frame_id
));
8554 b
= set_raw_breakpoint (gdbarch
, sal
, type
, &momentary_breakpoint_ops
);
8555 b
->enable_state
= bp_enabled
;
8556 b
->disposition
= disp_donttouch
;
8557 b
->frame_id
= frame_id
;
8559 /* If we're debugging a multi-threaded program, then we want
8560 momentary breakpoints to be active in only a single thread of
8562 if (in_thread_list (inferior_ptid
))
8563 b
->thread
= ptid_to_global_thread_id (inferior_ptid
);
8565 update_global_location_list_nothrow (UGLL_MAY_INSERT
);
8567 return breakpoint_up (b
);
8570 /* Make a momentary breakpoint based on the master breakpoint ORIG.
8571 The new breakpoint will have type TYPE, use OPS as its
8572 breakpoint_ops, and will set enabled to LOC_ENABLED. */
8574 static struct breakpoint
*
8575 momentary_breakpoint_from_master (struct breakpoint
*orig
,
8577 const struct breakpoint_ops
*ops
,
8580 struct breakpoint
*copy
;
8582 copy
= set_raw_breakpoint_without_location (orig
->gdbarch
, type
, ops
);
8583 copy
->loc
= allocate_bp_location (copy
);
8584 set_breakpoint_location_function (copy
->loc
, 1);
8586 copy
->loc
->gdbarch
= orig
->loc
->gdbarch
;
8587 copy
->loc
->requested_address
= orig
->loc
->requested_address
;
8588 copy
->loc
->address
= orig
->loc
->address
;
8589 copy
->loc
->section
= orig
->loc
->section
;
8590 copy
->loc
->pspace
= orig
->loc
->pspace
;
8591 copy
->loc
->probe
= orig
->loc
->probe
;
8592 copy
->loc
->line_number
= orig
->loc
->line_number
;
8593 copy
->loc
->symtab
= orig
->loc
->symtab
;
8594 copy
->loc
->enabled
= loc_enabled
;
8595 copy
->frame_id
= orig
->frame_id
;
8596 copy
->thread
= orig
->thread
;
8597 copy
->pspace
= orig
->pspace
;
8599 copy
->enable_state
= bp_enabled
;
8600 copy
->disposition
= disp_donttouch
;
8601 copy
->number
= internal_breakpoint_number
--;
8603 update_global_location_list_nothrow (UGLL_DONT_INSERT
);
8607 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
8611 clone_momentary_breakpoint (struct breakpoint
*orig
)
8613 /* If there's nothing to clone, then return nothing. */
8617 return momentary_breakpoint_from_master (orig
, orig
->type
, orig
->ops
, 0);
8621 set_momentary_breakpoint_at_pc (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
8624 struct symtab_and_line sal
;
8626 sal
= find_pc_line (pc
, 0);
8628 sal
.section
= find_pc_overlay (pc
);
8629 sal
.explicit_pc
= 1;
8631 return set_momentary_breakpoint (gdbarch
, sal
, null_frame_id
, type
);
8635 /* Tell the user we have just set a breakpoint B. */
8638 mention (struct breakpoint
*b
)
8640 b
->ops
->print_mention (b
);
8641 if (current_uiout
->is_mi_like_p ())
8643 printf_filtered ("\n");
8647 static int bp_loc_is_permanent (struct bp_location
*loc
);
8649 static struct bp_location
*
8650 add_location_to_breakpoint (struct breakpoint
*b
,
8651 const struct symtab_and_line
*sal
)
8653 struct bp_location
*loc
, **tmp
;
8654 CORE_ADDR adjusted_address
;
8655 struct gdbarch
*loc_gdbarch
= get_sal_arch (*sal
);
8657 if (loc_gdbarch
== NULL
)
8658 loc_gdbarch
= b
->gdbarch
;
8660 /* Adjust the breakpoint's address prior to allocating a location.
8661 Once we call allocate_bp_location(), that mostly uninitialized
8662 location will be placed on the location chain. Adjustment of the
8663 breakpoint may cause target_read_memory() to be called and we do
8664 not want its scan of the location chain to find a breakpoint and
8665 location that's only been partially initialized. */
8666 adjusted_address
= adjust_breakpoint_address (loc_gdbarch
,
8669 /* Sort the locations by their ADDRESS. */
8670 loc
= allocate_bp_location (b
);
8671 for (tmp
= &(b
->loc
); *tmp
!= NULL
&& (*tmp
)->address
<= adjusted_address
;
8672 tmp
= &((*tmp
)->next
))
8677 loc
->requested_address
= sal
->pc
;
8678 loc
->address
= adjusted_address
;
8679 loc
->pspace
= sal
->pspace
;
8680 loc
->probe
.prob
= sal
->prob
;
8681 loc
->probe
.objfile
= sal
->objfile
;
8682 gdb_assert (loc
->pspace
!= NULL
);
8683 loc
->section
= sal
->section
;
8684 loc
->gdbarch
= loc_gdbarch
;
8685 loc
->line_number
= sal
->line
;
8686 loc
->symtab
= sal
->symtab
;
8687 loc
->symbol
= sal
->symbol
;
8689 set_breakpoint_location_function (loc
,
8690 sal
->explicit_pc
|| sal
->explicit_line
);
8692 /* While by definition, permanent breakpoints are already present in the
8693 code, we don't mark the location as inserted. Normally one would expect
8694 that GDB could rely on that breakpoint instruction to stop the program,
8695 thus removing the need to insert its own breakpoint, except that executing
8696 the breakpoint instruction can kill the target instead of reporting a
8697 SIGTRAP. E.g., on SPARC, when interrupts are disabled, executing the
8698 instruction resets the CPU, so QEMU 2.0.0 for SPARC correspondingly dies
8699 with "Trap 0x02 while interrupts disabled, Error state". Letting the
8700 breakpoint be inserted normally results in QEMU knowing about the GDB
8701 breakpoint, and thus trap before the breakpoint instruction is executed.
8702 (If GDB later needs to continue execution past the permanent breakpoint,
8703 it manually increments the PC, thus avoiding executing the breakpoint
8705 if (bp_loc_is_permanent (loc
))
8712 /* See breakpoint.h. */
8715 program_breakpoint_here_p (struct gdbarch
*gdbarch
, CORE_ADDR address
)
8719 const gdb_byte
*bpoint
;
8720 gdb_byte
*target_mem
;
8723 bpoint
= gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &len
);
8725 /* Software breakpoints unsupported? */
8729 target_mem
= (gdb_byte
*) alloca (len
);
8731 /* Enable the automatic memory restoration from breakpoints while
8732 we read the memory. Otherwise we could say about our temporary
8733 breakpoints they are permanent. */
8734 scoped_restore restore_memory
8735 = make_scoped_restore_show_memory_breakpoints (0);
8737 if (target_read_memory (address
, target_mem
, len
) == 0
8738 && memcmp (target_mem
, bpoint
, len
) == 0)
8744 /* Return 1 if LOC is pointing to a permanent breakpoint,
8745 return 0 otherwise. */
8748 bp_loc_is_permanent (struct bp_location
*loc
)
8750 gdb_assert (loc
!= NULL
);
8752 /* If we have a catchpoint or a watchpoint, just return 0. We should not
8753 attempt to read from the addresses the locations of these breakpoint types
8754 point to. program_breakpoint_here_p, below, will attempt to read
8756 if (!breakpoint_address_is_meaningful (loc
->owner
))
8759 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
8760 switch_to_program_space_and_thread (loc
->pspace
);
8761 return program_breakpoint_here_p (loc
->gdbarch
, loc
->address
);
8764 /* Build a command list for the dprintf corresponding to the current
8765 settings of the dprintf style options. */
8768 update_dprintf_command_list (struct breakpoint
*b
)
8770 char *dprintf_args
= b
->extra_string
;
8771 char *printf_line
= NULL
;
8776 dprintf_args
= skip_spaces (dprintf_args
);
8778 /* Allow a comma, as it may have terminated a location, but don't
8780 if (*dprintf_args
== ',')
8782 dprintf_args
= skip_spaces (dprintf_args
);
8784 if (*dprintf_args
!= '"')
8785 error (_("Bad format string, missing '\"'."));
8787 if (strcmp (dprintf_style
, dprintf_style_gdb
) == 0)
8788 printf_line
= xstrprintf ("printf %s", dprintf_args
);
8789 else if (strcmp (dprintf_style
, dprintf_style_call
) == 0)
8791 if (!dprintf_function
)
8792 error (_("No function supplied for dprintf call"));
8794 if (dprintf_channel
&& strlen (dprintf_channel
) > 0)
8795 printf_line
= xstrprintf ("call (void) %s (%s,%s)",
8800 printf_line
= xstrprintf ("call (void) %s (%s)",
8804 else if (strcmp (dprintf_style
, dprintf_style_agent
) == 0)
8806 if (target_can_run_breakpoint_commands ())
8807 printf_line
= xstrprintf ("agent-printf %s", dprintf_args
);
8810 warning (_("Target cannot run dprintf commands, falling back to GDB printf"));
8811 printf_line
= xstrprintf ("printf %s", dprintf_args
);
8815 internal_error (__FILE__
, __LINE__
,
8816 _("Invalid dprintf style."));
8818 gdb_assert (printf_line
!= NULL
);
8819 /* Manufacture a printf sequence. */
8821 struct command_line
*printf_cmd_line
= XNEW (struct command_line
);
8823 printf_cmd_line
->control_type
= simple_control
;
8824 printf_cmd_line
->body_count
= 0;
8825 printf_cmd_line
->body_list
= NULL
;
8826 printf_cmd_line
->next
= NULL
;
8827 printf_cmd_line
->line
= printf_line
;
8829 breakpoint_set_commands (b
, command_line_up (printf_cmd_line
));
8833 /* Update all dprintf commands, making their command lists reflect
8834 current style settings. */
8837 update_dprintf_commands (const char *args
, int from_tty
,
8838 struct cmd_list_element
*c
)
8840 struct breakpoint
*b
;
8844 if (b
->type
== bp_dprintf
)
8845 update_dprintf_command_list (b
);
8849 /* Create a breakpoint with SAL as location. Use LOCATION
8850 as a description of the location, and COND_STRING
8851 as condition expression. If LOCATION is NULL then create an
8852 "address location" from the address in the SAL. */
8855 init_breakpoint_sal (struct breakpoint
*b
, struct gdbarch
*gdbarch
,
8856 gdb::array_view
<const symtab_and_line
> sals
,
8857 event_location_up
&&location
,
8858 gdb::unique_xmalloc_ptr
<char> filter
,
8859 gdb::unique_xmalloc_ptr
<char> cond_string
,
8860 gdb::unique_xmalloc_ptr
<char> extra_string
,
8861 enum bptype type
, enum bpdisp disposition
,
8862 int thread
, int task
, int ignore_count
,
8863 const struct breakpoint_ops
*ops
, int from_tty
,
8864 int enabled
, int internal
, unsigned flags
,
8865 int display_canonical
)
8869 if (type
== bp_hardware_breakpoint
)
8871 int target_resources_ok
;
8873 i
= hw_breakpoint_used_count ();
8874 target_resources_ok
=
8875 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
8877 if (target_resources_ok
== 0)
8878 error (_("No hardware breakpoint support in the target."));
8879 else if (target_resources_ok
< 0)
8880 error (_("Hardware breakpoints used exceeds limit."));
8883 gdb_assert (!sals
.empty ());
8885 for (const auto &sal
: sals
)
8887 struct bp_location
*loc
;
8891 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
8893 loc_gdbarch
= gdbarch
;
8895 describe_other_breakpoints (loc_gdbarch
,
8896 sal
.pspace
, sal
.pc
, sal
.section
, thread
);
8899 if (&sal
== &sals
[0])
8901 init_raw_breakpoint (b
, gdbarch
, sal
, type
, ops
);
8905 b
->cond_string
= cond_string
.release ();
8906 b
->extra_string
= extra_string
.release ();
8907 b
->ignore_count
= ignore_count
;
8908 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
8909 b
->disposition
= disposition
;
8911 if ((flags
& CREATE_BREAKPOINT_FLAGS_INSERTED
) != 0)
8912 b
->loc
->inserted
= 1;
8914 if (type
== bp_static_tracepoint
)
8916 struct tracepoint
*t
= (struct tracepoint
*) b
;
8917 struct static_tracepoint_marker marker
;
8919 if (strace_marker_p (b
))
8921 /* We already know the marker exists, otherwise, we
8922 wouldn't see a sal for it. */
8924 = &event_location_to_string (b
->location
.get ())[3];
8928 p
= skip_spaces (p
);
8930 endp
= skip_to_space (p
);
8932 marker_str
= savestring (p
, endp
- p
);
8933 t
->static_trace_marker_id
= marker_str
;
8935 printf_filtered (_("Probed static tracepoint "
8937 t
->static_trace_marker_id
);
8939 else if (target_static_tracepoint_marker_at (sal
.pc
, &marker
))
8941 t
->static_trace_marker_id
= xstrdup (marker
.str_id
);
8942 release_static_tracepoint_marker (&marker
);
8944 printf_filtered (_("Probed static tracepoint "
8946 t
->static_trace_marker_id
);
8949 warning (_("Couldn't determine the static "
8950 "tracepoint marker to probe"));
8957 loc
= add_location_to_breakpoint (b
, &sal
);
8958 if ((flags
& CREATE_BREAKPOINT_FLAGS_INSERTED
) != 0)
8964 const char *arg
= b
->cond_string
;
8966 loc
->cond
= parse_exp_1 (&arg
, loc
->address
,
8967 block_for_pc (loc
->address
), 0);
8969 error (_("Garbage '%s' follows condition"), arg
);
8972 /* Dynamic printf requires and uses additional arguments on the
8973 command line, otherwise it's an error. */
8974 if (type
== bp_dprintf
)
8976 if (b
->extra_string
)
8977 update_dprintf_command_list (b
);
8979 error (_("Format string required"));
8981 else if (b
->extra_string
)
8982 error (_("Garbage '%s' at end of command"), b
->extra_string
);
8985 b
->display_canonical
= display_canonical
;
8986 if (location
!= NULL
)
8987 b
->location
= std::move (location
);
8989 b
->location
= new_address_location (b
->loc
->address
, NULL
, 0);
8990 b
->filter
= filter
.release ();
8994 create_breakpoint_sal (struct gdbarch
*gdbarch
,
8995 gdb::array_view
<const symtab_and_line
> sals
,
8996 event_location_up
&&location
,
8997 gdb::unique_xmalloc_ptr
<char> filter
,
8998 gdb::unique_xmalloc_ptr
<char> cond_string
,
8999 gdb::unique_xmalloc_ptr
<char> extra_string
,
9000 enum bptype type
, enum bpdisp disposition
,
9001 int thread
, int task
, int ignore_count
,
9002 const struct breakpoint_ops
*ops
, int from_tty
,
9003 int enabled
, int internal
, unsigned flags
,
9004 int display_canonical
)
9006 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (type
);
9008 init_breakpoint_sal (b
.get (), gdbarch
,
9009 sals
, std::move (location
),
9011 std::move (cond_string
),
9012 std::move (extra_string
),
9014 thread
, task
, ignore_count
,
9016 enabled
, internal
, flags
,
9019 install_breakpoint (internal
, std::move (b
), 0);
9022 /* Add SALS.nelts breakpoints to the breakpoint table. For each
9023 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
9024 value. COND_STRING, if not NULL, specified the condition to be
9025 used for all breakpoints. Essentially the only case where
9026 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
9027 function. In that case, it's still not possible to specify
9028 separate conditions for different overloaded functions, so
9029 we take just a single condition string.
9031 NOTE: If the function succeeds, the caller is expected to cleanup
9032 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
9033 array contents). If the function fails (error() is called), the
9034 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
9035 COND and SALS arrays and each of those arrays contents. */
9038 create_breakpoints_sal (struct gdbarch
*gdbarch
,
9039 struct linespec_result
*canonical
,
9040 gdb::unique_xmalloc_ptr
<char> cond_string
,
9041 gdb::unique_xmalloc_ptr
<char> extra_string
,
9042 enum bptype type
, enum bpdisp disposition
,
9043 int thread
, int task
, int ignore_count
,
9044 const struct breakpoint_ops
*ops
, int from_tty
,
9045 int enabled
, int internal
, unsigned flags
)
9047 if (canonical
->pre_expanded
)
9048 gdb_assert (canonical
->lsals
.size () == 1);
9050 for (const auto &lsal
: canonical
->lsals
)
9052 /* Note that 'location' can be NULL in the case of a plain
9053 'break', without arguments. */
9054 event_location_up location
9055 = (canonical
->location
!= NULL
9056 ? copy_event_location (canonical
->location
.get ()) : NULL
);
9057 gdb::unique_xmalloc_ptr
<char> filter_string
9058 (lsal
.canonical
!= NULL
? xstrdup (lsal
.canonical
) : NULL
);
9060 create_breakpoint_sal (gdbarch
, lsal
.sals
,
9061 std::move (location
),
9062 std::move (filter_string
),
9063 std::move (cond_string
),
9064 std::move (extra_string
),
9066 thread
, task
, ignore_count
, ops
,
9067 from_tty
, enabled
, internal
, flags
,
9068 canonical
->special_display
);
9072 /* Parse LOCATION which is assumed to be a SAL specification possibly
9073 followed by conditionals. On return, SALS contains an array of SAL
9074 addresses found. LOCATION points to the end of the SAL (for
9075 linespec locations).
9077 The array and the line spec strings are allocated on the heap, it is
9078 the caller's responsibility to free them. */
9081 parse_breakpoint_sals (const struct event_location
*location
,
9082 struct linespec_result
*canonical
)
9084 struct symtab_and_line cursal
;
9086 if (event_location_type (location
) == LINESPEC_LOCATION
)
9088 const char *spec
= get_linespec_location (location
)->spec_string
;
9092 /* The last displayed codepoint, if it's valid, is our default
9093 breakpoint address. */
9094 if (last_displayed_sal_is_valid ())
9096 /* Set sal's pspace, pc, symtab, and line to the values
9097 corresponding to the last call to print_frame_info.
9098 Be sure to reinitialize LINE with NOTCURRENT == 0
9099 as the breakpoint line number is inappropriate otherwise.
9100 find_pc_line would adjust PC, re-set it back. */
9101 symtab_and_line sal
= get_last_displayed_sal ();
9102 CORE_ADDR pc
= sal
.pc
;
9104 sal
= find_pc_line (pc
, 0);
9106 /* "break" without arguments is equivalent to "break *PC"
9107 where PC is the last displayed codepoint's address. So
9108 make sure to set sal.explicit_pc to prevent GDB from
9109 trying to expand the list of sals to include all other
9110 instances with the same symtab and line. */
9112 sal
.explicit_pc
= 1;
9114 struct linespec_sals lsal
;
9116 lsal
.canonical
= NULL
;
9118 canonical
->lsals
.push_back (std::move (lsal
));
9122 error (_("No default breakpoint address now."));
9126 /* Force almost all breakpoints to be in terms of the
9127 current_source_symtab (which is decode_line_1's default).
9128 This should produce the results we want almost all of the
9129 time while leaving default_breakpoint_* alone.
9131 ObjC: However, don't match an Objective-C method name which
9132 may have a '+' or '-' succeeded by a '['. */
9133 cursal
= get_current_source_symtab_and_line ();
9134 if (last_displayed_sal_is_valid ())
9136 const char *spec
= NULL
;
9138 if (event_location_type (location
) == LINESPEC_LOCATION
)
9139 spec
= get_linespec_location (location
)->spec_string
;
9143 && strchr ("+-", spec
[0]) != NULL
9146 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, NULL
,
9147 get_last_displayed_symtab (),
9148 get_last_displayed_line (),
9149 canonical
, NULL
, NULL
);
9154 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, NULL
,
9155 cursal
.symtab
, cursal
.line
, canonical
, NULL
, NULL
);
9159 /* Convert each SAL into a real PC. Verify that the PC can be
9160 inserted as a breakpoint. If it can't throw an error. */
9163 breakpoint_sals_to_pc (std::vector
<symtab_and_line
> &sals
)
9165 for (auto &sal
: sals
)
9166 resolve_sal_pc (&sal
);
9169 /* Fast tracepoints may have restrictions on valid locations. For
9170 instance, a fast tracepoint using a jump instead of a trap will
9171 likely have to overwrite more bytes than a trap would, and so can
9172 only be placed where the instruction is longer than the jump, or a
9173 multi-instruction sequence does not have a jump into the middle of
9177 check_fast_tracepoint_sals (struct gdbarch
*gdbarch
,
9178 gdb::array_view
<const symtab_and_line
> sals
)
9180 for (const auto &sal
: sals
)
9182 struct gdbarch
*sarch
;
9184 sarch
= get_sal_arch (sal
);
9185 /* We fall back to GDBARCH if there is no architecture
9186 associated with SAL. */
9190 if (!gdbarch_fast_tracepoint_valid_at (sarch
, sal
.pc
, &msg
))
9191 error (_("May not have a fast tracepoint at %s%s"),
9192 paddress (sarch
, sal
.pc
), msg
.c_str ());
9196 /* Given TOK, a string specification of condition and thread, as
9197 accepted by the 'break' command, extract the condition
9198 string and thread number and set *COND_STRING and *THREAD.
9199 PC identifies the context at which the condition should be parsed.
9200 If no condition is found, *COND_STRING is set to NULL.
9201 If no thread is found, *THREAD is set to -1. */
9204 find_condition_and_thread (const char *tok
, CORE_ADDR pc
,
9205 char **cond_string
, int *thread
, int *task
,
9208 *cond_string
= NULL
;
9215 const char *end_tok
;
9217 const char *cond_start
= NULL
;
9218 const char *cond_end
= NULL
;
9220 tok
= skip_spaces (tok
);
9222 if ((*tok
== '"' || *tok
== ',') && rest
)
9224 *rest
= savestring (tok
, strlen (tok
));
9228 end_tok
= skip_to_space (tok
);
9230 toklen
= end_tok
- tok
;
9232 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
9234 tok
= cond_start
= end_tok
+ 1;
9235 parse_exp_1 (&tok
, pc
, block_for_pc (pc
), 0);
9237 *cond_string
= savestring (cond_start
, cond_end
- cond_start
);
9239 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
9242 struct thread_info
*thr
;
9245 thr
= parse_thread_id (tok
, &tmptok
);
9247 error (_("Junk after thread keyword."));
9248 *thread
= thr
->global_num
;
9251 else if (toklen
>= 1 && strncmp (tok
, "task", toklen
) == 0)
9256 *task
= strtol (tok
, &tmptok
, 0);
9258 error (_("Junk after task keyword."));
9259 if (!valid_task_id (*task
))
9260 error (_("Unknown task %d."), *task
);
9265 *rest
= savestring (tok
, strlen (tok
));
9269 error (_("Junk at end of arguments."));
9273 /* Decode a static tracepoint marker spec. */
9275 static std::vector
<symtab_and_line
>
9276 decode_static_tracepoint_spec (const char **arg_p
)
9278 VEC(static_tracepoint_marker_p
) *markers
= NULL
;
9279 const char *p
= &(*arg_p
)[3];
9283 p
= skip_spaces (p
);
9285 endp
= skip_to_space (p
);
9287 std::string
marker_str (p
, endp
- p
);
9289 markers
= target_static_tracepoint_markers_by_strid (marker_str
.c_str ());
9290 if (VEC_empty(static_tracepoint_marker_p
, markers
))
9291 error (_("No known static tracepoint marker named %s"),
9292 marker_str
.c_str ());
9294 std::vector
<symtab_and_line
> sals
;
9295 sals
.reserve (VEC_length(static_tracepoint_marker_p
, markers
));
9297 for (i
= 0; i
< VEC_length(static_tracepoint_marker_p
, markers
); i
++)
9299 struct static_tracepoint_marker
*marker
;
9301 marker
= VEC_index (static_tracepoint_marker_p
, markers
, i
);
9303 symtab_and_line sal
= find_pc_line (marker
->address
, 0);
9304 sal
.pc
= marker
->address
;
9305 sals
.push_back (sal
);
9307 release_static_tracepoint_marker (marker
);
9314 /* See breakpoint.h. */
9317 create_breakpoint (struct gdbarch
*gdbarch
,
9318 const struct event_location
*location
,
9319 const char *cond_string
,
9320 int thread
, const char *extra_string
,
9322 int tempflag
, enum bptype type_wanted
,
9324 enum auto_boolean pending_break_support
,
9325 const struct breakpoint_ops
*ops
,
9326 int from_tty
, int enabled
, int internal
,
9329 struct linespec_result canonical
;
9330 struct cleanup
*bkpt_chain
= NULL
;
9333 int prev_bkpt_count
= breakpoint_count
;
9335 gdb_assert (ops
!= NULL
);
9337 /* If extra_string isn't useful, set it to NULL. */
9338 if (extra_string
!= NULL
&& *extra_string
== '\0')
9339 extra_string
= NULL
;
9343 ops
->create_sals_from_location (location
, &canonical
, type_wanted
);
9345 CATCH (e
, RETURN_MASK_ERROR
)
9347 /* If caller is interested in rc value from parse, set
9349 if (e
.error
== NOT_FOUND_ERROR
)
9351 /* If pending breakpoint support is turned off, throw
9354 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
9355 throw_exception (e
);
9357 exception_print (gdb_stderr
, e
);
9359 /* If pending breakpoint support is auto query and the user
9360 selects no, then simply return the error code. */
9361 if (pending_break_support
== AUTO_BOOLEAN_AUTO
9362 && !nquery (_("Make %s pending on future shared library load? "),
9363 bptype_string (type_wanted
)))
9366 /* At this point, either the user was queried about setting
9367 a pending breakpoint and selected yes, or pending
9368 breakpoint behavior is on and thus a pending breakpoint
9369 is defaulted on behalf of the user. */
9373 throw_exception (e
);
9377 if (!pending
&& canonical
.lsals
.empty ())
9380 /* ----------------------------- SNIP -----------------------------
9381 Anything added to the cleanup chain beyond this point is assumed
9382 to be part of a breakpoint. If the breakpoint create succeeds
9383 then the memory is not reclaimed. */
9384 bkpt_chain
= make_cleanup (null_cleanup
, 0);
9386 /* Resolve all line numbers to PC's and verify that the addresses
9387 are ok for the target. */
9390 for (auto &lsal
: canonical
.lsals
)
9391 breakpoint_sals_to_pc (lsal
.sals
);
9394 /* Fast tracepoints may have additional restrictions on location. */
9395 if (!pending
&& type_wanted
== bp_fast_tracepoint
)
9397 for (const auto &lsal
: canonical
.lsals
)
9398 check_fast_tracepoint_sals (gdbarch
, lsal
.sals
);
9401 /* Verify that condition can be parsed, before setting any
9402 breakpoints. Allocate a separate condition expression for each
9406 gdb::unique_xmalloc_ptr
<char> cond_string_copy
;
9407 gdb::unique_xmalloc_ptr
<char> extra_string_copy
;
9414 const linespec_sals
&lsal
= canonical
.lsals
[0];
9416 /* Here we only parse 'arg' to separate condition
9417 from thread number, so parsing in context of first
9418 sal is OK. When setting the breakpoint we'll
9419 re-parse it in context of each sal. */
9421 find_condition_and_thread (extra_string
, lsal
.sals
[0].pc
,
9422 &cond
, &thread
, &task
, &rest
);
9423 cond_string_copy
.reset (cond
);
9424 extra_string_copy
.reset (rest
);
9428 if (type_wanted
!= bp_dprintf
9429 && extra_string
!= NULL
&& *extra_string
!= '\0')
9430 error (_("Garbage '%s' at end of location"), extra_string
);
9432 /* Create a private copy of condition string. */
9434 cond_string_copy
.reset (xstrdup (cond_string
));
9435 /* Create a private copy of any extra string. */
9437 extra_string_copy
.reset (xstrdup (extra_string
));
9440 ops
->create_breakpoints_sal (gdbarch
, &canonical
,
9441 std::move (cond_string_copy
),
9442 std::move (extra_string_copy
),
9444 tempflag
? disp_del
: disp_donttouch
,
9445 thread
, task
, ignore_count
, ops
,
9446 from_tty
, enabled
, internal
, flags
);
9450 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (type_wanted
);
9452 init_raw_breakpoint_without_location (b
.get (), gdbarch
, type_wanted
, ops
);
9453 b
->location
= copy_event_location (location
);
9456 b
->cond_string
= NULL
;
9459 /* Create a private copy of condition string. */
9460 b
->cond_string
= cond_string
!= NULL
? xstrdup (cond_string
) : NULL
;
9464 /* Create a private copy of any extra string. */
9465 b
->extra_string
= extra_string
!= NULL
? xstrdup (extra_string
) : NULL
;
9466 b
->ignore_count
= ignore_count
;
9467 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
9468 b
->condition_not_parsed
= 1;
9469 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
9470 if ((type_wanted
!= bp_breakpoint
9471 && type_wanted
!= bp_hardware_breakpoint
) || thread
!= -1)
9472 b
->pspace
= current_program_space
;
9474 install_breakpoint (internal
, std::move (b
), 0);
9477 if (canonical
.lsals
.size () > 1)
9479 warning (_("Multiple breakpoints were set.\nUse the "
9480 "\"delete\" command to delete unwanted breakpoints."));
9481 prev_breakpoint_count
= prev_bkpt_count
;
9484 /* That's it. Discard the cleanups for data inserted into the
9486 discard_cleanups (bkpt_chain
);
9488 /* error call may happen here - have BKPT_CHAIN already discarded. */
9489 update_global_location_list (UGLL_MAY_INSERT
);
9494 /* Set a breakpoint.
9495 ARG is a string describing breakpoint address,
9496 condition, and thread.
9497 FLAG specifies if a breakpoint is hardware on,
9498 and if breakpoint is temporary, using BP_HARDWARE_FLAG
9502 break_command_1 (const char *arg
, int flag
, int from_tty
)
9504 int tempflag
= flag
& BP_TEMPFLAG
;
9505 enum bptype type_wanted
= (flag
& BP_HARDWAREFLAG
9506 ? bp_hardware_breakpoint
9508 struct breakpoint_ops
*ops
;
9510 event_location_up location
= string_to_event_location (&arg
, current_language
);
9512 /* Matching breakpoints on probes. */
9513 if (location
!= NULL
9514 && event_location_type (location
.get ()) == PROBE_LOCATION
)
9515 ops
= &bkpt_probe_breakpoint_ops
;
9517 ops
= &bkpt_breakpoint_ops
;
9519 create_breakpoint (get_current_arch (),
9521 NULL
, 0, arg
, 1 /* parse arg */,
9522 tempflag
, type_wanted
,
9523 0 /* Ignore count */,
9524 pending_break_support
,
9532 /* Helper function for break_command_1 and disassemble_command. */
9535 resolve_sal_pc (struct symtab_and_line
*sal
)
9539 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
9541 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
9542 error (_("No line %d in file \"%s\"."),
9543 sal
->line
, symtab_to_filename_for_display (sal
->symtab
));
9546 /* If this SAL corresponds to a breakpoint inserted using a line
9547 number, then skip the function prologue if necessary. */
9548 if (sal
->explicit_line
)
9549 skip_prologue_sal (sal
);
9552 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
9554 const struct blockvector
*bv
;
9555 const struct block
*b
;
9558 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
,
9559 SYMTAB_COMPUNIT (sal
->symtab
));
9562 sym
= block_linkage_function (b
);
9565 fixup_symbol_section (sym
, SYMTAB_OBJFILE (sal
->symtab
));
9566 sal
->section
= SYMBOL_OBJ_SECTION (SYMTAB_OBJFILE (sal
->symtab
),
9571 /* It really is worthwhile to have the section, so we'll
9572 just have to look harder. This case can be executed
9573 if we have line numbers but no functions (as can
9574 happen in assembly source). */
9576 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
9577 switch_to_program_space_and_thread (sal
->pspace
);
9579 bound_minimal_symbol msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
9581 sal
->section
= MSYMBOL_OBJ_SECTION (msym
.objfile
, msym
.minsym
);
9588 break_command (const char *arg
, int from_tty
)
9590 break_command_1 (arg
, 0, from_tty
);
9594 tbreak_command (const char *arg
, int from_tty
)
9596 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
9600 hbreak_command (const char *arg
, int from_tty
)
9602 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
9606 thbreak_command (const char *arg
, int from_tty
)
9608 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
9612 stop_command (const char *arg
, int from_tty
)
9614 printf_filtered (_("Specify the type of breakpoint to set.\n\
9615 Usage: stop in <function | address>\n\
9616 stop at <line>\n"));
9620 stopin_command (const char *arg
, int from_tty
)
9624 if (arg
== (char *) NULL
)
9626 else if (*arg
!= '*')
9628 const char *argptr
= arg
;
9631 /* Look for a ':'. If this is a line number specification, then
9632 say it is bad, otherwise, it should be an address or
9633 function/method name. */
9634 while (*argptr
&& !hasColon
)
9636 hasColon
= (*argptr
== ':');
9641 badInput
= (*argptr
!= ':'); /* Not a class::method */
9643 badInput
= isdigit (*arg
); /* a simple line number */
9647 printf_filtered (_("Usage: stop in <function | address>\n"));
9649 break_command_1 (arg
, 0, from_tty
);
9653 stopat_command (const char *arg
, int from_tty
)
9657 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
9661 const char *argptr
= arg
;
9664 /* Look for a ':'. If there is a '::' then get out, otherwise
9665 it is probably a line number. */
9666 while (*argptr
&& !hasColon
)
9668 hasColon
= (*argptr
== ':');
9673 badInput
= (*argptr
== ':'); /* we have class::method */
9675 badInput
= !isdigit (*arg
); /* not a line number */
9679 printf_filtered (_("Usage: stop at <line>\n"));
9681 break_command_1 (arg
, 0, from_tty
);
9684 /* The dynamic printf command is mostly like a regular breakpoint, but
9685 with a prewired command list consisting of a single output command,
9686 built from extra arguments supplied on the dprintf command
9690 dprintf_command (const char *arg
, int from_tty
)
9692 event_location_up location
= string_to_event_location (&arg
, current_language
);
9694 /* If non-NULL, ARG should have been advanced past the location;
9695 the next character must be ','. */
9698 if (arg
[0] != ',' || arg
[1] == '\0')
9699 error (_("Format string required"));
9702 /* Skip the comma. */
9707 create_breakpoint (get_current_arch (),
9709 NULL
, 0, arg
, 1 /* parse arg */,
9711 0 /* Ignore count */,
9712 pending_break_support
,
9713 &dprintf_breakpoint_ops
,
9721 agent_printf_command (const char *arg
, int from_tty
)
9723 error (_("May only run agent-printf on the target"));
9726 /* Implement the "breakpoint_hit" breakpoint_ops method for
9727 ranged breakpoints. */
9730 breakpoint_hit_ranged_breakpoint (const struct bp_location
*bl
,
9731 const address_space
*aspace
,
9733 const struct target_waitstatus
*ws
)
9735 if (ws
->kind
!= TARGET_WAITKIND_STOPPED
9736 || ws
->value
.sig
!= GDB_SIGNAL_TRAP
)
9739 return breakpoint_address_match_range (bl
->pspace
->aspace
, bl
->address
,
9740 bl
->length
, aspace
, bp_addr
);
9743 /* Implement the "resources_needed" breakpoint_ops method for
9744 ranged breakpoints. */
9747 resources_needed_ranged_breakpoint (const struct bp_location
*bl
)
9749 return target_ranged_break_num_registers ();
9752 /* Implement the "print_it" breakpoint_ops method for
9753 ranged breakpoints. */
9755 static enum print_stop_action
9756 print_it_ranged_breakpoint (bpstat bs
)
9758 struct breakpoint
*b
= bs
->breakpoint_at
;
9759 struct bp_location
*bl
= b
->loc
;
9760 struct ui_out
*uiout
= current_uiout
;
9762 gdb_assert (b
->type
== bp_hardware_breakpoint
);
9764 /* Ranged breakpoints have only one location. */
9765 gdb_assert (bl
&& bl
->next
== NULL
);
9767 annotate_breakpoint (b
->number
);
9769 maybe_print_thread_hit_breakpoint (uiout
);
9771 if (b
->disposition
== disp_del
)
9772 uiout
->text ("Temporary ranged breakpoint ");
9774 uiout
->text ("Ranged breakpoint ");
9775 if (uiout
->is_mi_like_p ())
9777 uiout
->field_string ("reason",
9778 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
9779 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
9781 uiout
->field_int ("bkptno", b
->number
);
9784 return PRINT_SRC_AND_LOC
;
9787 /* Implement the "print_one" breakpoint_ops method for
9788 ranged breakpoints. */
9791 print_one_ranged_breakpoint (struct breakpoint
*b
,
9792 struct bp_location
**last_loc
)
9794 struct bp_location
*bl
= b
->loc
;
9795 struct value_print_options opts
;
9796 struct ui_out
*uiout
= current_uiout
;
9798 /* Ranged breakpoints have only one location. */
9799 gdb_assert (bl
&& bl
->next
== NULL
);
9801 get_user_print_options (&opts
);
9803 if (opts
.addressprint
)
9804 /* We don't print the address range here, it will be printed later
9805 by print_one_detail_ranged_breakpoint. */
9806 uiout
->field_skip ("addr");
9808 print_breakpoint_location (b
, bl
);
9812 /* Implement the "print_one_detail" breakpoint_ops method for
9813 ranged breakpoints. */
9816 print_one_detail_ranged_breakpoint (const struct breakpoint
*b
,
9817 struct ui_out
*uiout
)
9819 CORE_ADDR address_start
, address_end
;
9820 struct bp_location
*bl
= b
->loc
;
9825 address_start
= bl
->address
;
9826 address_end
= address_start
+ bl
->length
- 1;
9828 uiout
->text ("\taddress range: ");
9829 stb
.printf ("[%s, %s]",
9830 print_core_address (bl
->gdbarch
, address_start
),
9831 print_core_address (bl
->gdbarch
, address_end
));
9832 uiout
->field_stream ("addr", stb
);
9836 /* Implement the "print_mention" breakpoint_ops method for
9837 ranged breakpoints. */
9840 print_mention_ranged_breakpoint (struct breakpoint
*b
)
9842 struct bp_location
*bl
= b
->loc
;
9843 struct ui_out
*uiout
= current_uiout
;
9846 gdb_assert (b
->type
== bp_hardware_breakpoint
);
9848 if (uiout
->is_mi_like_p ())
9851 printf_filtered (_("Hardware assisted ranged breakpoint %d from %s to %s."),
9852 b
->number
, paddress (bl
->gdbarch
, bl
->address
),
9853 paddress (bl
->gdbarch
, bl
->address
+ bl
->length
- 1));
9856 /* Implement the "print_recreate" breakpoint_ops method for
9857 ranged breakpoints. */
9860 print_recreate_ranged_breakpoint (struct breakpoint
*b
, struct ui_file
*fp
)
9862 fprintf_unfiltered (fp
, "break-range %s, %s",
9863 event_location_to_string (b
->location
.get ()),
9864 event_location_to_string (b
->location_range_end
.get ()));
9865 print_recreate_thread (b
, fp
);
9868 /* The breakpoint_ops structure to be used in ranged breakpoints. */
9870 static struct breakpoint_ops ranged_breakpoint_ops
;
9872 /* Find the address where the end of the breakpoint range should be
9873 placed, given the SAL of the end of the range. This is so that if
9874 the user provides a line number, the end of the range is set to the
9875 last instruction of the given line. */
9878 find_breakpoint_range_end (struct symtab_and_line sal
)
9882 /* If the user provided a PC value, use it. Otherwise,
9883 find the address of the end of the given location. */
9884 if (sal
.explicit_pc
)
9891 ret
= find_line_pc_range (sal
, &start
, &end
);
9893 error (_("Could not find location of the end of the range."));
9895 /* find_line_pc_range returns the start of the next line. */
9902 /* Implement the "break-range" CLI command. */
9905 break_range_command (const char *arg
, int from_tty
)
9907 const char *arg_start
;
9908 struct linespec_result canonical_start
, canonical_end
;
9909 int bp_count
, can_use_bp
, length
;
9911 struct breakpoint
*b
;
9913 /* We don't support software ranged breakpoints. */
9914 if (target_ranged_break_num_registers () < 0)
9915 error (_("This target does not support hardware ranged breakpoints."));
9917 bp_count
= hw_breakpoint_used_count ();
9918 bp_count
+= target_ranged_break_num_registers ();
9919 can_use_bp
= target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
9922 error (_("Hardware breakpoints used exceeds limit."));
9924 arg
= skip_spaces (arg
);
9925 if (arg
== NULL
|| arg
[0] == '\0')
9926 error(_("No address range specified."));
9929 event_location_up start_location
= string_to_event_location (&arg
,
9931 parse_breakpoint_sals (start_location
.get (), &canonical_start
);
9934 error (_("Too few arguments."));
9935 else if (canonical_start
.lsals
.empty ())
9936 error (_("Could not find location of the beginning of the range."));
9938 const linespec_sals
&lsal_start
= canonical_start
.lsals
[0];
9940 if (canonical_start
.lsals
.size () > 1
9941 || lsal_start
.sals
.size () != 1)
9942 error (_("Cannot create a ranged breakpoint with multiple locations."));
9944 const symtab_and_line
&sal_start
= lsal_start
.sals
[0];
9945 std::string
addr_string_start (arg_start
, arg
- arg_start
);
9947 arg
++; /* Skip the comma. */
9948 arg
= skip_spaces (arg
);
9950 /* Parse the end location. */
9954 /* We call decode_line_full directly here instead of using
9955 parse_breakpoint_sals because we need to specify the start location's
9956 symtab and line as the default symtab and line for the end of the
9957 range. This makes it possible to have ranges like "foo.c:27, +14",
9958 where +14 means 14 lines from the start location. */
9959 event_location_up end_location
= string_to_event_location (&arg
,
9961 decode_line_full (end_location
.get (), DECODE_LINE_FUNFIRSTLINE
, NULL
,
9962 sal_start
.symtab
, sal_start
.line
,
9963 &canonical_end
, NULL
, NULL
);
9965 if (canonical_end
.lsals
.empty ())
9966 error (_("Could not find location of the end of the range."));
9968 const linespec_sals
&lsal_end
= canonical_end
.lsals
[0];
9969 if (canonical_end
.lsals
.size () > 1
9970 || lsal_end
.sals
.size () != 1)
9971 error (_("Cannot create a ranged breakpoint with multiple locations."));
9973 const symtab_and_line
&sal_end
= lsal_end
.sals
[0];
9975 end
= find_breakpoint_range_end (sal_end
);
9976 if (sal_start
.pc
> end
)
9977 error (_("Invalid address range, end precedes start."));
9979 length
= end
- sal_start
.pc
+ 1;
9981 /* Length overflowed. */
9982 error (_("Address range too large."));
9983 else if (length
== 1)
9985 /* This range is simple enough to be handled by
9986 the `hbreak' command. */
9987 hbreak_command (&addr_string_start
[0], 1);
9992 /* Now set up the breakpoint. */
9993 b
= set_raw_breakpoint (get_current_arch (), sal_start
,
9994 bp_hardware_breakpoint
, &ranged_breakpoint_ops
);
9995 set_breakpoint_count (breakpoint_count
+ 1);
9996 b
->number
= breakpoint_count
;
9997 b
->disposition
= disp_donttouch
;
9998 b
->location
= std::move (start_location
);
9999 b
->location_range_end
= std::move (end_location
);
10000 b
->loc
->length
= length
;
10003 observer_notify_breakpoint_created (b
);
10004 update_global_location_list (UGLL_MAY_INSERT
);
10007 /* Return non-zero if EXP is verified as constant. Returned zero
10008 means EXP is variable. Also the constant detection may fail for
10009 some constant expressions and in such case still falsely return
10013 watchpoint_exp_is_const (const struct expression
*exp
)
10015 int i
= exp
->nelts
;
10021 /* We are only interested in the descriptor of each element. */
10022 operator_length (exp
, i
, &oplenp
, &argsp
);
10025 switch (exp
->elts
[i
].opcode
)
10035 case BINOP_LOGICAL_AND
:
10036 case BINOP_LOGICAL_OR
:
10037 case BINOP_BITWISE_AND
:
10038 case BINOP_BITWISE_IOR
:
10039 case BINOP_BITWISE_XOR
:
10041 case BINOP_NOTEQUAL
:
10067 case OP_OBJC_NSSTRING
:
10070 case UNOP_LOGICAL_NOT
:
10071 case UNOP_COMPLEMENT
:
10076 case UNOP_CAST_TYPE
:
10077 case UNOP_REINTERPRET_CAST
:
10078 case UNOP_DYNAMIC_CAST
:
10079 /* Unary, binary and ternary operators: We have to check
10080 their operands. If they are constant, then so is the
10081 result of that operation. For instance, if A and B are
10082 determined to be constants, then so is "A + B".
10084 UNOP_IND is one exception to the rule above, because the
10085 value of *ADDR is not necessarily a constant, even when
10090 /* Check whether the associated symbol is a constant.
10092 We use SYMBOL_CLASS rather than TYPE_CONST because it's
10093 possible that a buggy compiler could mark a variable as
10094 constant even when it is not, and TYPE_CONST would return
10095 true in this case, while SYMBOL_CLASS wouldn't.
10097 We also have to check for function symbols because they
10098 are always constant. */
10100 struct symbol
*s
= exp
->elts
[i
+ 2].symbol
;
10102 if (SYMBOL_CLASS (s
) != LOC_BLOCK
10103 && SYMBOL_CLASS (s
) != LOC_CONST
10104 && SYMBOL_CLASS (s
) != LOC_CONST_BYTES
)
10109 /* The default action is to return 0 because we are using
10110 the optimistic approach here: If we don't know something,
10111 then it is not a constant. */
10120 /* Watchpoint destructor. */
10122 watchpoint::~watchpoint ()
10124 xfree (this->exp_string
);
10125 xfree (this->exp_string_reparse
);
10126 value_free (this->val
);
10129 /* Implement the "re_set" breakpoint_ops method for watchpoints. */
10132 re_set_watchpoint (struct breakpoint
*b
)
10134 struct watchpoint
*w
= (struct watchpoint
*) b
;
10136 /* Watchpoint can be either on expression using entirely global
10137 variables, or it can be on local variables.
10139 Watchpoints of the first kind are never auto-deleted, and even
10140 persist across program restarts. Since they can use variables
10141 from shared libraries, we need to reparse expression as libraries
10142 are loaded and unloaded.
10144 Watchpoints on local variables can also change meaning as result
10145 of solib event. For example, if a watchpoint uses both a local
10146 and a global variables in expression, it's a local watchpoint,
10147 but unloading of a shared library will make the expression
10148 invalid. This is not a very common use case, but we still
10149 re-evaluate expression, to avoid surprises to the user.
10151 Note that for local watchpoints, we re-evaluate it only if
10152 watchpoints frame id is still valid. If it's not, it means the
10153 watchpoint is out of scope and will be deleted soon. In fact,
10154 I'm not sure we'll ever be called in this case.
10156 If a local watchpoint's frame id is still valid, then
10157 w->exp_valid_block is likewise valid, and we can safely use it.
10159 Don't do anything about disabled watchpoints, since they will be
10160 reevaluated again when enabled. */
10161 update_watchpoint (w
, 1 /* reparse */);
10164 /* Implement the "insert" breakpoint_ops method for hardware watchpoints. */
10167 insert_watchpoint (struct bp_location
*bl
)
10169 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10170 int length
= w
->exact
? 1 : bl
->length
;
10172 return target_insert_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
10173 w
->cond_exp
.get ());
10176 /* Implement the "remove" breakpoint_ops method for hardware watchpoints. */
10179 remove_watchpoint (struct bp_location
*bl
, enum remove_bp_reason reason
)
10181 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10182 int length
= w
->exact
? 1 : bl
->length
;
10184 return target_remove_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
10185 w
->cond_exp
.get ());
10189 breakpoint_hit_watchpoint (const struct bp_location
*bl
,
10190 const address_space
*aspace
, CORE_ADDR bp_addr
,
10191 const struct target_waitstatus
*ws
)
10193 struct breakpoint
*b
= bl
->owner
;
10194 struct watchpoint
*w
= (struct watchpoint
*) b
;
10196 /* Continuable hardware watchpoints are treated as non-existent if the
10197 reason we stopped wasn't a hardware watchpoint (we didn't stop on
10198 some data address). Otherwise gdb won't stop on a break instruction
10199 in the code (not from a breakpoint) when a hardware watchpoint has
10200 been defined. Also skip watchpoints which we know did not trigger
10201 (did not match the data address). */
10202 if (is_hardware_watchpoint (b
)
10203 && w
->watchpoint_triggered
== watch_triggered_no
)
10210 check_status_watchpoint (bpstat bs
)
10212 gdb_assert (is_watchpoint (bs
->breakpoint_at
));
10214 bpstat_check_watchpoint (bs
);
10217 /* Implement the "resources_needed" breakpoint_ops method for
10218 hardware watchpoints. */
10221 resources_needed_watchpoint (const struct bp_location
*bl
)
10223 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10224 int length
= w
->exact
? 1 : bl
->length
;
10226 return target_region_ok_for_hw_watchpoint (bl
->address
, length
);
10229 /* Implement the "works_in_software_mode" breakpoint_ops method for
10230 hardware watchpoints. */
10233 works_in_software_mode_watchpoint (const struct breakpoint
*b
)
10235 /* Read and access watchpoints only work with hardware support. */
10236 return b
->type
== bp_watchpoint
|| b
->type
== bp_hardware_watchpoint
;
10239 static enum print_stop_action
10240 print_it_watchpoint (bpstat bs
)
10242 struct breakpoint
*b
;
10243 enum print_stop_action result
;
10244 struct watchpoint
*w
;
10245 struct ui_out
*uiout
= current_uiout
;
10247 gdb_assert (bs
->bp_location_at
!= NULL
);
10249 b
= bs
->breakpoint_at
;
10250 w
= (struct watchpoint
*) b
;
10252 annotate_watchpoint (b
->number
);
10253 maybe_print_thread_hit_breakpoint (uiout
);
10257 gdb::optional
<ui_out_emit_tuple
> tuple_emitter
;
10260 case bp_watchpoint
:
10261 case bp_hardware_watchpoint
:
10262 if (uiout
->is_mi_like_p ())
10263 uiout
->field_string
10264 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
10266 tuple_emitter
.emplace (uiout
, "value");
10267 uiout
->text ("\nOld value = ");
10268 watchpoint_value_print (bs
->old_val
, &stb
);
10269 uiout
->field_stream ("old", stb
);
10270 uiout
->text ("\nNew value = ");
10271 watchpoint_value_print (w
->val
, &stb
);
10272 uiout
->field_stream ("new", stb
);
10273 uiout
->text ("\n");
10274 /* More than one watchpoint may have been triggered. */
10275 result
= PRINT_UNKNOWN
;
10278 case bp_read_watchpoint
:
10279 if (uiout
->is_mi_like_p ())
10280 uiout
->field_string
10281 ("reason", async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
10283 tuple_emitter
.emplace (uiout
, "value");
10284 uiout
->text ("\nValue = ");
10285 watchpoint_value_print (w
->val
, &stb
);
10286 uiout
->field_stream ("value", stb
);
10287 uiout
->text ("\n");
10288 result
= PRINT_UNKNOWN
;
10291 case bp_access_watchpoint
:
10292 if (bs
->old_val
!= NULL
)
10294 if (uiout
->is_mi_like_p ())
10295 uiout
->field_string
10297 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
10299 tuple_emitter
.emplace (uiout
, "value");
10300 uiout
->text ("\nOld value = ");
10301 watchpoint_value_print (bs
->old_val
, &stb
);
10302 uiout
->field_stream ("old", stb
);
10303 uiout
->text ("\nNew value = ");
10308 if (uiout
->is_mi_like_p ())
10309 uiout
->field_string
10311 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
10312 tuple_emitter
.emplace (uiout
, "value");
10313 uiout
->text ("\nValue = ");
10315 watchpoint_value_print (w
->val
, &stb
);
10316 uiout
->field_stream ("new", stb
);
10317 uiout
->text ("\n");
10318 result
= PRINT_UNKNOWN
;
10321 result
= PRINT_UNKNOWN
;
10327 /* Implement the "print_mention" breakpoint_ops method for hardware
10331 print_mention_watchpoint (struct breakpoint
*b
)
10333 struct watchpoint
*w
= (struct watchpoint
*) b
;
10334 struct ui_out
*uiout
= current_uiout
;
10335 const char *tuple_name
;
10339 case bp_watchpoint
:
10340 uiout
->text ("Watchpoint ");
10341 tuple_name
= "wpt";
10343 case bp_hardware_watchpoint
:
10344 uiout
->text ("Hardware watchpoint ");
10345 tuple_name
= "wpt";
10347 case bp_read_watchpoint
:
10348 uiout
->text ("Hardware read watchpoint ");
10349 tuple_name
= "hw-rwpt";
10351 case bp_access_watchpoint
:
10352 uiout
->text ("Hardware access (read/write) watchpoint ");
10353 tuple_name
= "hw-awpt";
10356 internal_error (__FILE__
, __LINE__
,
10357 _("Invalid hardware watchpoint type."));
10360 ui_out_emit_tuple
tuple_emitter (uiout
, tuple_name
);
10361 uiout
->field_int ("number", b
->number
);
10362 uiout
->text (": ");
10363 uiout
->field_string ("exp", w
->exp_string
);
10366 /* Implement the "print_recreate" breakpoint_ops method for
10370 print_recreate_watchpoint (struct breakpoint
*b
, struct ui_file
*fp
)
10372 struct watchpoint
*w
= (struct watchpoint
*) b
;
10376 case bp_watchpoint
:
10377 case bp_hardware_watchpoint
:
10378 fprintf_unfiltered (fp
, "watch");
10380 case bp_read_watchpoint
:
10381 fprintf_unfiltered (fp
, "rwatch");
10383 case bp_access_watchpoint
:
10384 fprintf_unfiltered (fp
, "awatch");
10387 internal_error (__FILE__
, __LINE__
,
10388 _("Invalid watchpoint type."));
10391 fprintf_unfiltered (fp
, " %s", w
->exp_string
);
10392 print_recreate_thread (b
, fp
);
10395 /* Implement the "explains_signal" breakpoint_ops method for
10399 explains_signal_watchpoint (struct breakpoint
*b
, enum gdb_signal sig
)
10401 /* A software watchpoint cannot cause a signal other than
10402 GDB_SIGNAL_TRAP. */
10403 if (b
->type
== bp_watchpoint
&& sig
!= GDB_SIGNAL_TRAP
)
10409 /* The breakpoint_ops structure to be used in hardware watchpoints. */
10411 static struct breakpoint_ops watchpoint_breakpoint_ops
;
10413 /* Implement the "insert" breakpoint_ops method for
10414 masked hardware watchpoints. */
10417 insert_masked_watchpoint (struct bp_location
*bl
)
10419 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10421 return target_insert_mask_watchpoint (bl
->address
, w
->hw_wp_mask
,
10422 bl
->watchpoint_type
);
10425 /* Implement the "remove" breakpoint_ops method for
10426 masked hardware watchpoints. */
10429 remove_masked_watchpoint (struct bp_location
*bl
, enum remove_bp_reason reason
)
10431 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10433 return target_remove_mask_watchpoint (bl
->address
, w
->hw_wp_mask
,
10434 bl
->watchpoint_type
);
10437 /* Implement the "resources_needed" breakpoint_ops method for
10438 masked hardware watchpoints. */
10441 resources_needed_masked_watchpoint (const struct bp_location
*bl
)
10443 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10445 return target_masked_watch_num_registers (bl
->address
, w
->hw_wp_mask
);
10448 /* Implement the "works_in_software_mode" breakpoint_ops method for
10449 masked hardware watchpoints. */
10452 works_in_software_mode_masked_watchpoint (const struct breakpoint
*b
)
10457 /* Implement the "print_it" breakpoint_ops method for
10458 masked hardware watchpoints. */
10460 static enum print_stop_action
10461 print_it_masked_watchpoint (bpstat bs
)
10463 struct breakpoint
*b
= bs
->breakpoint_at
;
10464 struct ui_out
*uiout
= current_uiout
;
10466 /* Masked watchpoints have only one location. */
10467 gdb_assert (b
->loc
&& b
->loc
->next
== NULL
);
10469 annotate_watchpoint (b
->number
);
10470 maybe_print_thread_hit_breakpoint (uiout
);
10474 case bp_hardware_watchpoint
:
10475 if (uiout
->is_mi_like_p ())
10476 uiout
->field_string
10477 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
10480 case bp_read_watchpoint
:
10481 if (uiout
->is_mi_like_p ())
10482 uiout
->field_string
10483 ("reason", async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
10486 case bp_access_watchpoint
:
10487 if (uiout
->is_mi_like_p ())
10488 uiout
->field_string
10490 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
10493 internal_error (__FILE__
, __LINE__
,
10494 _("Invalid hardware watchpoint type."));
10498 uiout
->text (_("\n\
10499 Check the underlying instruction at PC for the memory\n\
10500 address and value which triggered this watchpoint.\n"));
10501 uiout
->text ("\n");
10503 /* More than one watchpoint may have been triggered. */
10504 return PRINT_UNKNOWN
;
10507 /* Implement the "print_one_detail" breakpoint_ops method for
10508 masked hardware watchpoints. */
10511 print_one_detail_masked_watchpoint (const struct breakpoint
*b
,
10512 struct ui_out
*uiout
)
10514 struct watchpoint
*w
= (struct watchpoint
*) b
;
10516 /* Masked watchpoints have only one location. */
10517 gdb_assert (b
->loc
&& b
->loc
->next
== NULL
);
10519 uiout
->text ("\tmask ");
10520 uiout
->field_core_addr ("mask", b
->loc
->gdbarch
, w
->hw_wp_mask
);
10521 uiout
->text ("\n");
10524 /* Implement the "print_mention" breakpoint_ops method for
10525 masked hardware watchpoints. */
10528 print_mention_masked_watchpoint (struct breakpoint
*b
)
10530 struct watchpoint
*w
= (struct watchpoint
*) b
;
10531 struct ui_out
*uiout
= current_uiout
;
10532 const char *tuple_name
;
10536 case bp_hardware_watchpoint
:
10537 uiout
->text ("Masked hardware watchpoint ");
10538 tuple_name
= "wpt";
10540 case bp_read_watchpoint
:
10541 uiout
->text ("Masked hardware read watchpoint ");
10542 tuple_name
= "hw-rwpt";
10544 case bp_access_watchpoint
:
10545 uiout
->text ("Masked hardware access (read/write) watchpoint ");
10546 tuple_name
= "hw-awpt";
10549 internal_error (__FILE__
, __LINE__
,
10550 _("Invalid hardware watchpoint type."));
10553 ui_out_emit_tuple
tuple_emitter (uiout
, tuple_name
);
10554 uiout
->field_int ("number", b
->number
);
10555 uiout
->text (": ");
10556 uiout
->field_string ("exp", w
->exp_string
);
10559 /* Implement the "print_recreate" breakpoint_ops method for
10560 masked hardware watchpoints. */
10563 print_recreate_masked_watchpoint (struct breakpoint
*b
, struct ui_file
*fp
)
10565 struct watchpoint
*w
= (struct watchpoint
*) b
;
10570 case bp_hardware_watchpoint
:
10571 fprintf_unfiltered (fp
, "watch");
10573 case bp_read_watchpoint
:
10574 fprintf_unfiltered (fp
, "rwatch");
10576 case bp_access_watchpoint
:
10577 fprintf_unfiltered (fp
, "awatch");
10580 internal_error (__FILE__
, __LINE__
,
10581 _("Invalid hardware watchpoint type."));
10584 sprintf_vma (tmp
, w
->hw_wp_mask
);
10585 fprintf_unfiltered (fp
, " %s mask 0x%s", w
->exp_string
, tmp
);
10586 print_recreate_thread (b
, fp
);
10589 /* The breakpoint_ops structure to be used in masked hardware watchpoints. */
10591 static struct breakpoint_ops masked_watchpoint_breakpoint_ops
;
10593 /* Tell whether the given watchpoint is a masked hardware watchpoint. */
10596 is_masked_watchpoint (const struct breakpoint
*b
)
10598 return b
->ops
== &masked_watchpoint_breakpoint_ops
;
10601 /* accessflag: hw_write: watch write,
10602 hw_read: watch read,
10603 hw_access: watch access (read or write) */
10605 watch_command_1 (const char *arg
, int accessflag
, int from_tty
,
10606 int just_location
, int internal
)
10608 struct breakpoint
*scope_breakpoint
= NULL
;
10609 const struct block
*exp_valid_block
= NULL
, *cond_exp_valid_block
= NULL
;
10610 struct value
*val
, *mark
, *result
;
10611 int saved_bitpos
= 0, saved_bitsize
= 0;
10612 const char *exp_start
= NULL
;
10613 const char *exp_end
= NULL
;
10614 const char *tok
, *end_tok
;
10616 const char *cond_start
= NULL
;
10617 const char *cond_end
= NULL
;
10618 enum bptype bp_type
;
10621 /* Flag to indicate whether we are going to use masks for
10622 the hardware watchpoint. */
10624 CORE_ADDR mask
= 0;
10626 /* Make sure that we actually have parameters to parse. */
10627 if (arg
!= NULL
&& arg
[0] != '\0')
10629 const char *value_start
;
10631 exp_end
= arg
+ strlen (arg
);
10633 /* Look for "parameter value" pairs at the end
10634 of the arguments string. */
10635 for (tok
= exp_end
- 1; tok
> arg
; tok
--)
10637 /* Skip whitespace at the end of the argument list. */
10638 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
10641 /* Find the beginning of the last token.
10642 This is the value of the parameter. */
10643 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
10645 value_start
= tok
+ 1;
10647 /* Skip whitespace. */
10648 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
10653 /* Find the beginning of the second to last token.
10654 This is the parameter itself. */
10655 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
10658 toklen
= end_tok
- tok
+ 1;
10660 if (toklen
== 6 && startswith (tok
, "thread"))
10662 struct thread_info
*thr
;
10663 /* At this point we've found a "thread" token, which means
10664 the user is trying to set a watchpoint that triggers
10665 only in a specific thread. */
10669 error(_("You can specify only one thread."));
10671 /* Extract the thread ID from the next token. */
10672 thr
= parse_thread_id (value_start
, &endp
);
10674 /* Check if the user provided a valid thread ID. */
10675 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
10676 invalid_thread_id_error (value_start
);
10678 thread
= thr
->global_num
;
10680 else if (toklen
== 4 && startswith (tok
, "mask"))
10682 /* We've found a "mask" token, which means the user wants to
10683 create a hardware watchpoint that is going to have the mask
10685 struct value
*mask_value
, *mark
;
10688 error(_("You can specify only one mask."));
10690 use_mask
= just_location
= 1;
10692 mark
= value_mark ();
10693 mask_value
= parse_to_comma_and_eval (&value_start
);
10694 mask
= value_as_address (mask_value
);
10695 value_free_to_mark (mark
);
10698 /* We didn't recognize what we found. We should stop here. */
10701 /* Truncate the string and get rid of the "parameter value" pair before
10702 the arguments string is parsed by the parse_exp_1 function. */
10709 /* Parse the rest of the arguments. From here on out, everything
10710 is in terms of a newly allocated string instead of the original
10712 innermost_block
.reset ();
10713 std::string
expression (arg
, exp_end
- arg
);
10714 exp_start
= arg
= expression
.c_str ();
10715 expression_up exp
= parse_exp_1 (&arg
, 0, 0, 0);
10717 /* Remove trailing whitespace from the expression before saving it.
10718 This makes the eventual display of the expression string a bit
10720 while (exp_end
> exp_start
&& (exp_end
[-1] == ' ' || exp_end
[-1] == '\t'))
10723 /* Checking if the expression is not constant. */
10724 if (watchpoint_exp_is_const (exp
.get ()))
10728 len
= exp_end
- exp_start
;
10729 while (len
> 0 && isspace (exp_start
[len
- 1]))
10731 error (_("Cannot watch constant value `%.*s'."), len
, exp_start
);
10734 exp_valid_block
= innermost_block
.block ();
10735 mark
= value_mark ();
10736 fetch_subexp_value (exp
.get (), &pc
, &val
, &result
, NULL
, just_location
);
10738 if (val
!= NULL
&& just_location
)
10740 saved_bitpos
= value_bitpos (val
);
10741 saved_bitsize
= value_bitsize (val
);
10748 exp_valid_block
= NULL
;
10749 val
= value_addr (result
);
10750 release_value (val
);
10751 value_free_to_mark (mark
);
10755 ret
= target_masked_watch_num_registers (value_as_address (val
),
10758 error (_("This target does not support masked watchpoints."));
10759 else if (ret
== -2)
10760 error (_("Invalid mask or memory region."));
10763 else if (val
!= NULL
)
10764 release_value (val
);
10766 tok
= skip_spaces (arg
);
10767 end_tok
= skip_to_space (tok
);
10769 toklen
= end_tok
- tok
;
10770 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
10772 innermost_block
.reset ();
10773 tok
= cond_start
= end_tok
+ 1;
10774 parse_exp_1 (&tok
, 0, 0, 0);
10776 /* The watchpoint expression may not be local, but the condition
10777 may still be. E.g.: `watch global if local > 0'. */
10778 cond_exp_valid_block
= innermost_block
.block ();
10783 error (_("Junk at end of command."));
10785 frame_info
*wp_frame
= block_innermost_frame (exp_valid_block
);
10787 /* Save this because create_internal_breakpoint below invalidates
10789 frame_id watchpoint_frame
= get_frame_id (wp_frame
);
10791 /* If the expression is "local", then set up a "watchpoint scope"
10792 breakpoint at the point where we've left the scope of the watchpoint
10793 expression. Create the scope breakpoint before the watchpoint, so
10794 that we will encounter it first in bpstat_stop_status. */
10795 if (exp_valid_block
!= NULL
&& wp_frame
!= NULL
)
10797 frame_id caller_frame_id
= frame_unwind_caller_id (wp_frame
);
10799 if (frame_id_p (caller_frame_id
))
10801 gdbarch
*caller_arch
= frame_unwind_caller_arch (wp_frame
);
10802 CORE_ADDR caller_pc
= frame_unwind_caller_pc (wp_frame
);
10805 = create_internal_breakpoint (caller_arch
, caller_pc
,
10806 bp_watchpoint_scope
,
10807 &momentary_breakpoint_ops
);
10809 /* create_internal_breakpoint could invalidate WP_FRAME. */
10812 scope_breakpoint
->enable_state
= bp_enabled
;
10814 /* Automatically delete the breakpoint when it hits. */
10815 scope_breakpoint
->disposition
= disp_del
;
10817 /* Only break in the proper frame (help with recursion). */
10818 scope_breakpoint
->frame_id
= caller_frame_id
;
10820 /* Set the address at which we will stop. */
10821 scope_breakpoint
->loc
->gdbarch
= caller_arch
;
10822 scope_breakpoint
->loc
->requested_address
= caller_pc
;
10823 scope_breakpoint
->loc
->address
10824 = adjust_breakpoint_address (scope_breakpoint
->loc
->gdbarch
,
10825 scope_breakpoint
->loc
->requested_address
,
10826 scope_breakpoint
->type
);
10830 /* Now set up the breakpoint. We create all watchpoints as hardware
10831 watchpoints here even if hardware watchpoints are turned off, a call
10832 to update_watchpoint later in this function will cause the type to
10833 drop back to bp_watchpoint (software watchpoint) if required. */
10835 if (accessflag
== hw_read
)
10836 bp_type
= bp_read_watchpoint
;
10837 else if (accessflag
== hw_access
)
10838 bp_type
= bp_access_watchpoint
;
10840 bp_type
= bp_hardware_watchpoint
;
10842 std::unique_ptr
<watchpoint
> w (new watchpoint ());
10845 init_raw_breakpoint_without_location (w
.get (), NULL
, bp_type
,
10846 &masked_watchpoint_breakpoint_ops
);
10848 init_raw_breakpoint_without_location (w
.get (), NULL
, bp_type
,
10849 &watchpoint_breakpoint_ops
);
10850 w
->thread
= thread
;
10851 w
->disposition
= disp_donttouch
;
10852 w
->pspace
= current_program_space
;
10853 w
->exp
= std::move (exp
);
10854 w
->exp_valid_block
= exp_valid_block
;
10855 w
->cond_exp_valid_block
= cond_exp_valid_block
;
10858 struct type
*t
= value_type (val
);
10859 CORE_ADDR addr
= value_as_address (val
);
10861 w
->exp_string_reparse
10862 = current_language
->la_watch_location_expression (t
, addr
).release ();
10864 w
->exp_string
= xstrprintf ("-location %.*s",
10865 (int) (exp_end
- exp_start
), exp_start
);
10868 w
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
10872 w
->hw_wp_mask
= mask
;
10877 w
->val_bitpos
= saved_bitpos
;
10878 w
->val_bitsize
= saved_bitsize
;
10883 w
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
10885 w
->cond_string
= 0;
10887 if (frame_id_p (watchpoint_frame
))
10889 w
->watchpoint_frame
= watchpoint_frame
;
10890 w
->watchpoint_thread
= inferior_ptid
;
10894 w
->watchpoint_frame
= null_frame_id
;
10895 w
->watchpoint_thread
= null_ptid
;
10898 if (scope_breakpoint
!= NULL
)
10900 /* The scope breakpoint is related to the watchpoint. We will
10901 need to act on them together. */
10902 w
->related_breakpoint
= scope_breakpoint
;
10903 scope_breakpoint
->related_breakpoint
= w
.get ();
10906 if (!just_location
)
10907 value_free_to_mark (mark
);
10909 /* Finally update the new watchpoint. This creates the locations
10910 that should be inserted. */
10911 update_watchpoint (w
.get (), 1);
10913 install_breakpoint (internal
, std::move (w
), 1);
10916 /* Return count of debug registers needed to watch the given expression.
10917 If the watchpoint cannot be handled in hardware return zero. */
10920 can_use_hardware_watchpoint (struct value
*v
)
10922 int found_memory_cnt
= 0;
10923 struct value
*head
= v
;
10925 /* Did the user specifically forbid us to use hardware watchpoints? */
10926 if (!can_use_hw_watchpoints
)
10929 /* Make sure that the value of the expression depends only upon
10930 memory contents, and values computed from them within GDB. If we
10931 find any register references or function calls, we can't use a
10932 hardware watchpoint.
10934 The idea here is that evaluating an expression generates a series
10935 of values, one holding the value of every subexpression. (The
10936 expression a*b+c has five subexpressions: a, b, a*b, c, and
10937 a*b+c.) GDB's values hold almost enough information to establish
10938 the criteria given above --- they identify memory lvalues,
10939 register lvalues, computed values, etcetera. So we can evaluate
10940 the expression, and then scan the chain of values that leaves
10941 behind to decide whether we can detect any possible change to the
10942 expression's final value using only hardware watchpoints.
10944 However, I don't think that the values returned by inferior
10945 function calls are special in any way. So this function may not
10946 notice that an expression involving an inferior function call
10947 can't be watched with hardware watchpoints. FIXME. */
10948 for (; v
; v
= value_next (v
))
10950 if (VALUE_LVAL (v
) == lval_memory
)
10952 if (v
!= head
&& value_lazy (v
))
10953 /* A lazy memory lvalue in the chain is one that GDB never
10954 needed to fetch; we either just used its address (e.g.,
10955 `a' in `a.b') or we never needed it at all (e.g., `a'
10956 in `a,b'). This doesn't apply to HEAD; if that is
10957 lazy then it was not readable, but watch it anyway. */
10961 /* Ahh, memory we actually used! Check if we can cover
10962 it with hardware watchpoints. */
10963 struct type
*vtype
= check_typedef (value_type (v
));
10965 /* We only watch structs and arrays if user asked for it
10966 explicitly, never if they just happen to appear in a
10967 middle of some value chain. */
10969 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
10970 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
10972 CORE_ADDR vaddr
= value_address (v
);
10976 len
= (target_exact_watchpoints
10977 && is_scalar_type_recursive (vtype
))?
10978 1 : TYPE_LENGTH (value_type (v
));
10980 num_regs
= target_region_ok_for_hw_watchpoint (vaddr
, len
);
10984 found_memory_cnt
+= num_regs
;
10988 else if (VALUE_LVAL (v
) != not_lval
10989 && deprecated_value_modifiable (v
) == 0)
10990 return 0; /* These are values from the history (e.g., $1). */
10991 else if (VALUE_LVAL (v
) == lval_register
)
10992 return 0; /* Cannot watch a register with a HW watchpoint. */
10995 /* The expression itself looks suitable for using a hardware
10996 watchpoint, but give the target machine a chance to reject it. */
10997 return found_memory_cnt
;
11001 watch_command_wrapper (const char *arg
, int from_tty
, int internal
)
11003 watch_command_1 (arg
, hw_write
, from_tty
, 0, internal
);
11006 /* A helper function that looks for the "-location" argument and then
11007 calls watch_command_1. */
11010 watch_maybe_just_location (const char *arg
, int accessflag
, int from_tty
)
11012 int just_location
= 0;
11015 && (check_for_argument (&arg
, "-location", sizeof ("-location") - 1)
11016 || check_for_argument (&arg
, "-l", sizeof ("-l") - 1)))
11018 arg
= skip_spaces (arg
);
11022 watch_command_1 (arg
, accessflag
, from_tty
, just_location
, 0);
11026 watch_command (const char *arg
, int from_tty
)
11028 watch_maybe_just_location (arg
, hw_write
, from_tty
);
11032 rwatch_command_wrapper (const char *arg
, int from_tty
, int internal
)
11034 watch_command_1 (arg
, hw_read
, from_tty
, 0, internal
);
11038 rwatch_command (const char *arg
, int from_tty
)
11040 watch_maybe_just_location (arg
, hw_read
, from_tty
);
11044 awatch_command_wrapper (const char *arg
, int from_tty
, int internal
)
11046 watch_command_1 (arg
, hw_access
, from_tty
, 0, internal
);
11050 awatch_command (const char *arg
, int from_tty
)
11052 watch_maybe_just_location (arg
, hw_access
, from_tty
);
11056 /* Data for the FSM that manages the until(location)/advance commands
11057 in infcmd.c. Here because it uses the mechanisms of
11060 struct until_break_fsm
11062 /* The base class. */
11063 struct thread_fsm thread_fsm
;
11065 /* The thread that as current when the command was executed. */
11068 /* The breakpoint set at the destination location. */
11069 struct breakpoint
*location_breakpoint
;
11071 /* Breakpoint set at the return address in the caller frame. May be
11073 struct breakpoint
*caller_breakpoint
;
11076 static void until_break_fsm_clean_up (struct thread_fsm
*self
,
11077 struct thread_info
*thread
);
11078 static int until_break_fsm_should_stop (struct thread_fsm
*self
,
11079 struct thread_info
*thread
);
11080 static enum async_reply_reason
11081 until_break_fsm_async_reply_reason (struct thread_fsm
*self
);
11083 /* until_break_fsm's vtable. */
11085 static struct thread_fsm_ops until_break_fsm_ops
=
11088 until_break_fsm_clean_up
,
11089 until_break_fsm_should_stop
,
11090 NULL
, /* return_value */
11091 until_break_fsm_async_reply_reason
,
11094 /* Allocate a new until_break_command_fsm. */
11096 static struct until_break_fsm
*
11097 new_until_break_fsm (struct interp
*cmd_interp
, int thread
,
11098 breakpoint_up
&&location_breakpoint
,
11099 breakpoint_up
&&caller_breakpoint
)
11101 struct until_break_fsm
*sm
;
11103 sm
= XCNEW (struct until_break_fsm
);
11104 thread_fsm_ctor (&sm
->thread_fsm
, &until_break_fsm_ops
, cmd_interp
);
11106 sm
->thread
= thread
;
11107 sm
->location_breakpoint
= location_breakpoint
.release ();
11108 sm
->caller_breakpoint
= caller_breakpoint
.release ();
11113 /* Implementation of the 'should_stop' FSM method for the
11114 until(location)/advance commands. */
11117 until_break_fsm_should_stop (struct thread_fsm
*self
,
11118 struct thread_info
*tp
)
11120 struct until_break_fsm
*sm
= (struct until_break_fsm
*) self
;
11122 if (bpstat_find_breakpoint (tp
->control
.stop_bpstat
,
11123 sm
->location_breakpoint
) != NULL
11124 || (sm
->caller_breakpoint
!= NULL
11125 && bpstat_find_breakpoint (tp
->control
.stop_bpstat
,
11126 sm
->caller_breakpoint
) != NULL
))
11127 thread_fsm_set_finished (self
);
11132 /* Implementation of the 'clean_up' FSM method for the
11133 until(location)/advance commands. */
11136 until_break_fsm_clean_up (struct thread_fsm
*self
,
11137 struct thread_info
*thread
)
11139 struct until_break_fsm
*sm
= (struct until_break_fsm
*) self
;
11141 /* Clean up our temporary breakpoints. */
11142 if (sm
->location_breakpoint
!= NULL
)
11144 delete_breakpoint (sm
->location_breakpoint
);
11145 sm
->location_breakpoint
= NULL
;
11147 if (sm
->caller_breakpoint
!= NULL
)
11149 delete_breakpoint (sm
->caller_breakpoint
);
11150 sm
->caller_breakpoint
= NULL
;
11152 delete_longjmp_breakpoint (sm
->thread
);
11155 /* Implementation of the 'async_reply_reason' FSM method for the
11156 until(location)/advance commands. */
11158 static enum async_reply_reason
11159 until_break_fsm_async_reply_reason (struct thread_fsm
*self
)
11161 return EXEC_ASYNC_LOCATION_REACHED
;
11165 until_break_command (const char *arg
, int from_tty
, int anywhere
)
11167 struct frame_info
*frame
;
11168 struct gdbarch
*frame_gdbarch
;
11169 struct frame_id stack_frame_id
;
11170 struct frame_id caller_frame_id
;
11171 struct cleanup
*old_chain
;
11173 struct thread_info
*tp
;
11174 struct until_break_fsm
*sm
;
11176 clear_proceed_status (0);
11178 /* Set a breakpoint where the user wants it and at return from
11181 event_location_up location
= string_to_event_location (&arg
, current_language
);
11183 std::vector
<symtab_and_line
> sals
11184 = (last_displayed_sal_is_valid ()
11185 ? decode_line_1 (location
.get (), DECODE_LINE_FUNFIRSTLINE
, NULL
,
11186 get_last_displayed_symtab (),
11187 get_last_displayed_line ())
11188 : decode_line_1 (location
.get (), DECODE_LINE_FUNFIRSTLINE
,
11189 NULL
, (struct symtab
*) NULL
, 0));
11191 if (sals
.size () != 1)
11192 error (_("Couldn't get information on specified line."));
11194 symtab_and_line
&sal
= sals
[0];
11197 error (_("Junk at end of arguments."));
11199 resolve_sal_pc (&sal
);
11201 tp
= inferior_thread ();
11202 thread
= tp
->global_num
;
11204 old_chain
= make_cleanup (null_cleanup
, NULL
);
11206 /* Note linespec handling above invalidates the frame chain.
11207 Installing a breakpoint also invalidates the frame chain (as it
11208 may need to switch threads), so do any frame handling before
11211 frame
= get_selected_frame (NULL
);
11212 frame_gdbarch
= get_frame_arch (frame
);
11213 stack_frame_id
= get_stack_frame_id (frame
);
11214 caller_frame_id
= frame_unwind_caller_id (frame
);
11216 /* Keep within the current frame, or in frames called by the current
11219 breakpoint_up caller_breakpoint
;
11220 if (frame_id_p (caller_frame_id
))
11222 struct symtab_and_line sal2
;
11223 struct gdbarch
*caller_gdbarch
;
11225 sal2
= find_pc_line (frame_unwind_caller_pc (frame
), 0);
11226 sal2
.pc
= frame_unwind_caller_pc (frame
);
11227 caller_gdbarch
= frame_unwind_caller_arch (frame
);
11228 caller_breakpoint
= set_momentary_breakpoint (caller_gdbarch
,
11233 set_longjmp_breakpoint (tp
, caller_frame_id
);
11234 make_cleanup (delete_longjmp_breakpoint_cleanup
, &thread
);
11237 /* set_momentary_breakpoint could invalidate FRAME. */
11240 breakpoint_up location_breakpoint
;
11242 /* If the user told us to continue until a specified location,
11243 we don't specify a frame at which we need to stop. */
11244 location_breakpoint
= set_momentary_breakpoint (frame_gdbarch
, sal
,
11245 null_frame_id
, bp_until
);
11247 /* Otherwise, specify the selected frame, because we want to stop
11248 only at the very same frame. */
11249 location_breakpoint
= set_momentary_breakpoint (frame_gdbarch
, sal
,
11250 stack_frame_id
, bp_until
);
11252 sm
= new_until_break_fsm (command_interp (), tp
->global_num
,
11253 std::move (location_breakpoint
),
11254 std::move (caller_breakpoint
));
11255 tp
->thread_fsm
= &sm
->thread_fsm
;
11257 discard_cleanups (old_chain
);
11259 proceed (-1, GDB_SIGNAL_DEFAULT
);
11262 /* This function attempts to parse an optional "if <cond>" clause
11263 from the arg string. If one is not found, it returns NULL.
11265 Else, it returns a pointer to the condition string. (It does not
11266 attempt to evaluate the string against a particular block.) And,
11267 it updates arg to point to the first character following the parsed
11268 if clause in the arg string. */
11271 ep_parse_optional_if_clause (const char **arg
)
11273 const char *cond_string
;
11275 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
11278 /* Skip the "if" keyword. */
11281 /* Skip any extra leading whitespace, and record the start of the
11282 condition string. */
11283 *arg
= skip_spaces (*arg
);
11284 cond_string
= *arg
;
11286 /* Assume that the condition occupies the remainder of the arg
11288 (*arg
) += strlen (cond_string
);
11290 return cond_string
;
11293 /* Commands to deal with catching events, such as signals, exceptions,
11294 process start/exit, etc. */
11298 catch_fork_temporary
, catch_vfork_temporary
,
11299 catch_fork_permanent
, catch_vfork_permanent
11304 catch_fork_command_1 (const char *arg
, int from_tty
,
11305 struct cmd_list_element
*command
)
11307 struct gdbarch
*gdbarch
= get_current_arch ();
11308 const char *cond_string
= NULL
;
11309 catch_fork_kind fork_kind
;
11312 fork_kind
= (catch_fork_kind
) (uintptr_t) get_cmd_context (command
);
11313 tempflag
= (fork_kind
== catch_fork_temporary
11314 || fork_kind
== catch_vfork_temporary
);
11318 arg
= skip_spaces (arg
);
11320 /* The allowed syntax is:
11322 catch [v]fork if <cond>
11324 First, check if there's an if clause. */
11325 cond_string
= ep_parse_optional_if_clause (&arg
);
11327 if ((*arg
!= '\0') && !isspace (*arg
))
11328 error (_("Junk at end of arguments."));
11330 /* If this target supports it, create a fork or vfork catchpoint
11331 and enable reporting of such events. */
11334 case catch_fork_temporary
:
11335 case catch_fork_permanent
:
11336 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
11337 &catch_fork_breakpoint_ops
);
11339 case catch_vfork_temporary
:
11340 case catch_vfork_permanent
:
11341 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
11342 &catch_vfork_breakpoint_ops
);
11345 error (_("unsupported or unknown fork kind; cannot catch it"));
11351 catch_exec_command_1 (const char *arg
, int from_tty
,
11352 struct cmd_list_element
*command
)
11354 struct gdbarch
*gdbarch
= get_current_arch ();
11356 const char *cond_string
= NULL
;
11358 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
11362 arg
= skip_spaces (arg
);
11364 /* The allowed syntax is:
11366 catch exec if <cond>
11368 First, check if there's an if clause. */
11369 cond_string
= ep_parse_optional_if_clause (&arg
);
11371 if ((*arg
!= '\0') && !isspace (*arg
))
11372 error (_("Junk at end of arguments."));
11374 std::unique_ptr
<exec_catchpoint
> c (new exec_catchpoint ());
11375 init_catchpoint (c
.get (), gdbarch
, tempflag
, cond_string
,
11376 &catch_exec_breakpoint_ops
);
11377 c
->exec_pathname
= NULL
;
11379 install_breakpoint (0, std::move (c
), 1);
11383 init_ada_exception_breakpoint (struct breakpoint
*b
,
11384 struct gdbarch
*gdbarch
,
11385 struct symtab_and_line sal
,
11386 const char *addr_string
,
11387 const struct breakpoint_ops
*ops
,
11394 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
11396 loc_gdbarch
= gdbarch
;
11398 describe_other_breakpoints (loc_gdbarch
,
11399 sal
.pspace
, sal
.pc
, sal
.section
, -1);
11400 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
11401 version for exception catchpoints, because two catchpoints
11402 used for different exception names will use the same address.
11403 In this case, a "breakpoint ... also set at..." warning is
11404 unproductive. Besides, the warning phrasing is also a bit
11405 inappropriate, we should use the word catchpoint, and tell
11406 the user what type of catchpoint it is. The above is good
11407 enough for now, though. */
11410 init_raw_breakpoint (b
, gdbarch
, sal
, bp_breakpoint
, ops
);
11412 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
11413 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
11414 b
->location
= string_to_event_location (&addr_string
,
11415 language_def (language_ada
));
11416 b
->language
= language_ada
;
11420 catch_command (const char *arg
, int from_tty
)
11422 error (_("Catch requires an event name."));
11427 tcatch_command (const char *arg
, int from_tty
)
11429 error (_("Catch requires an event name."));
11432 /* Compare two breakpoints and return a strcmp-like result. */
11435 compare_breakpoints (const breakpoint
*a
, const breakpoint
*b
)
11437 uintptr_t ua
= (uintptr_t) a
;
11438 uintptr_t ub
= (uintptr_t) b
;
11440 if (a
->number
< b
->number
)
11442 else if (a
->number
> b
->number
)
11445 /* Now sort by address, in case we see, e..g, two breakpoints with
11449 return ua
> ub
? 1 : 0;
11452 /* Delete breakpoints by address or line. */
11455 clear_command (const char *arg
, int from_tty
)
11457 struct breakpoint
*b
;
11460 std::vector
<symtab_and_line
> decoded_sals
;
11461 symtab_and_line last_sal
;
11462 gdb::array_view
<symtab_and_line
> sals
;
11466 = decode_line_with_current_source (arg
,
11467 (DECODE_LINE_FUNFIRSTLINE
11468 | DECODE_LINE_LIST_MODE
));
11470 sals
= decoded_sals
;
11474 /* Set sal's line, symtab, pc, and pspace to the values
11475 corresponding to the last call to print_frame_info. If the
11476 codepoint is not valid, this will set all the fields to 0. */
11477 last_sal
= get_last_displayed_sal ();
11478 if (last_sal
.symtab
== 0)
11479 error (_("No source file specified."));
11485 /* We don't call resolve_sal_pc here. That's not as bad as it
11486 seems, because all existing breakpoints typically have both
11487 file/line and pc set. So, if clear is given file/line, we can
11488 match this to existing breakpoint without obtaining pc at all.
11490 We only support clearing given the address explicitly
11491 present in breakpoint table. Say, we've set breakpoint
11492 at file:line. There were several PC values for that file:line,
11493 due to optimization, all in one block.
11495 We've picked one PC value. If "clear" is issued with another
11496 PC corresponding to the same file:line, the breakpoint won't
11497 be cleared. We probably can still clear the breakpoint, but
11498 since the other PC value is never presented to user, user
11499 can only find it by guessing, and it does not seem important
11500 to support that. */
11502 /* For each line spec given, delete bps which correspond to it. Do
11503 it in two passes, solely to preserve the current behavior that
11504 from_tty is forced true if we delete more than one
11507 std::vector
<struct breakpoint
*> found
;
11508 for (const auto &sal
: sals
)
11510 const char *sal_fullname
;
11512 /* If exact pc given, clear bpts at that pc.
11513 If line given (pc == 0), clear all bpts on specified line.
11514 If defaulting, clear all bpts on default line
11517 defaulting sal.pc != 0 tests to do
11522 1 0 <can't happen> */
11524 sal_fullname
= (sal
.symtab
== NULL
11525 ? NULL
: symtab_to_fullname (sal
.symtab
));
11527 /* Find all matching breakpoints and add them to 'found'. */
11528 ALL_BREAKPOINTS (b
)
11531 /* Are we going to delete b? */
11532 if (b
->type
!= bp_none
&& !is_watchpoint (b
))
11534 struct bp_location
*loc
= b
->loc
;
11535 for (; loc
; loc
= loc
->next
)
11537 /* If the user specified file:line, don't allow a PC
11538 match. This matches historical gdb behavior. */
11539 int pc_match
= (!sal
.explicit_line
11541 && (loc
->pspace
== sal
.pspace
)
11542 && (loc
->address
== sal
.pc
)
11543 && (!section_is_overlay (loc
->section
)
11544 || loc
->section
== sal
.section
));
11545 int line_match
= 0;
11547 if ((default_match
|| sal
.explicit_line
)
11548 && loc
->symtab
!= NULL
11549 && sal_fullname
!= NULL
11550 && sal
.pspace
== loc
->pspace
11551 && loc
->line_number
== sal
.line
11552 && filename_cmp (symtab_to_fullname (loc
->symtab
),
11553 sal_fullname
) == 0)
11556 if (pc_match
|| line_match
)
11565 found
.push_back (b
);
11569 /* Now go thru the 'found' chain and delete them. */
11570 if (found
.empty ())
11573 error (_("No breakpoint at %s."), arg
);
11575 error (_("No breakpoint at this line."));
11578 /* Remove duplicates from the vec. */
11579 std::sort (found
.begin (), found
.end (),
11580 [] (const breakpoint
*a
, const breakpoint
*b
)
11582 return compare_breakpoints (a
, b
) < 0;
11584 found
.erase (std::unique (found
.begin (), found
.end (),
11585 [] (const breakpoint
*a
, const breakpoint
*b
)
11587 return compare_breakpoints (a
, b
) == 0;
11591 if (found
.size () > 1)
11592 from_tty
= 1; /* Always report if deleted more than one. */
11595 if (found
.size () == 1)
11596 printf_unfiltered (_("Deleted breakpoint "));
11598 printf_unfiltered (_("Deleted breakpoints "));
11601 for (breakpoint
*iter
: found
)
11604 printf_unfiltered ("%d ", iter
->number
);
11605 delete_breakpoint (iter
);
11608 putchar_unfiltered ('\n');
11611 /* Delete breakpoint in BS if they are `delete' breakpoints and
11612 all breakpoints that are marked for deletion, whether hit or not.
11613 This is called after any breakpoint is hit, or after errors. */
11616 breakpoint_auto_delete (bpstat bs
)
11618 struct breakpoint
*b
, *b_tmp
;
11620 for (; bs
; bs
= bs
->next
)
11621 if (bs
->breakpoint_at
11622 && bs
->breakpoint_at
->disposition
== disp_del
11624 delete_breakpoint (bs
->breakpoint_at
);
11626 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
11628 if (b
->disposition
== disp_del_at_next_stop
)
11629 delete_breakpoint (b
);
11633 /* A comparison function for bp_location AP and BP being interfaced to
11634 qsort. Sort elements primarily by their ADDRESS (no matter what
11635 does breakpoint_address_is_meaningful say for its OWNER),
11636 secondarily by ordering first permanent elements and
11637 terciarily just ensuring the array is sorted stable way despite
11638 qsort being an unstable algorithm. */
11641 bp_locations_compare (const void *ap
, const void *bp
)
11643 const struct bp_location
*a
= *(const struct bp_location
**) ap
;
11644 const struct bp_location
*b
= *(const struct bp_location
**) bp
;
11646 if (a
->address
!= b
->address
)
11647 return (a
->address
> b
->address
) - (a
->address
< b
->address
);
11649 /* Sort locations at the same address by their pspace number, keeping
11650 locations of the same inferior (in a multi-inferior environment)
11653 if (a
->pspace
->num
!= b
->pspace
->num
)
11654 return ((a
->pspace
->num
> b
->pspace
->num
)
11655 - (a
->pspace
->num
< b
->pspace
->num
));
11657 /* Sort permanent breakpoints first. */
11658 if (a
->permanent
!= b
->permanent
)
11659 return (a
->permanent
< b
->permanent
) - (a
->permanent
> b
->permanent
);
11661 /* Make the internal GDB representation stable across GDB runs
11662 where A and B memory inside GDB can differ. Breakpoint locations of
11663 the same type at the same address can be sorted in arbitrary order. */
11665 if (a
->owner
->number
!= b
->owner
->number
)
11666 return ((a
->owner
->number
> b
->owner
->number
)
11667 - (a
->owner
->number
< b
->owner
->number
));
11669 return (a
> b
) - (a
< b
);
11672 /* Set bp_locations_placed_address_before_address_max and
11673 bp_locations_shadow_len_after_address_max according to the current
11674 content of the bp_locations array. */
11677 bp_locations_target_extensions_update (void)
11679 struct bp_location
*bl
, **blp_tmp
;
11681 bp_locations_placed_address_before_address_max
= 0;
11682 bp_locations_shadow_len_after_address_max
= 0;
11684 ALL_BP_LOCATIONS (bl
, blp_tmp
)
11686 CORE_ADDR start
, end
, addr
;
11688 if (!bp_location_has_shadow (bl
))
11691 start
= bl
->target_info
.placed_address
;
11692 end
= start
+ bl
->target_info
.shadow_len
;
11694 gdb_assert (bl
->address
>= start
);
11695 addr
= bl
->address
- start
;
11696 if (addr
> bp_locations_placed_address_before_address_max
)
11697 bp_locations_placed_address_before_address_max
= addr
;
11699 /* Zero SHADOW_LEN would not pass bp_location_has_shadow. */
11701 gdb_assert (bl
->address
< end
);
11702 addr
= end
- bl
->address
;
11703 if (addr
> bp_locations_shadow_len_after_address_max
)
11704 bp_locations_shadow_len_after_address_max
= addr
;
11708 /* Download tracepoint locations if they haven't been. */
11711 download_tracepoint_locations (void)
11713 struct breakpoint
*b
;
11714 enum tribool can_download_tracepoint
= TRIBOOL_UNKNOWN
;
11716 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
11718 ALL_TRACEPOINTS (b
)
11720 struct bp_location
*bl
;
11721 struct tracepoint
*t
;
11722 int bp_location_downloaded
= 0;
11724 if ((b
->type
== bp_fast_tracepoint
11725 ? !may_insert_fast_tracepoints
11726 : !may_insert_tracepoints
))
11729 if (can_download_tracepoint
== TRIBOOL_UNKNOWN
)
11731 if (target_can_download_tracepoint ())
11732 can_download_tracepoint
= TRIBOOL_TRUE
;
11734 can_download_tracepoint
= TRIBOOL_FALSE
;
11737 if (can_download_tracepoint
== TRIBOOL_FALSE
)
11740 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
11742 /* In tracepoint, locations are _never_ duplicated, so
11743 should_be_inserted is equivalent to
11744 unduplicated_should_be_inserted. */
11745 if (!should_be_inserted (bl
) || bl
->inserted
)
11748 switch_to_program_space_and_thread (bl
->pspace
);
11750 target_download_tracepoint (bl
);
11753 bp_location_downloaded
= 1;
11755 t
= (struct tracepoint
*) b
;
11756 t
->number_on_target
= b
->number
;
11757 if (bp_location_downloaded
)
11758 observer_notify_breakpoint_modified (b
);
11762 /* Swap the insertion/duplication state between two locations. */
11765 swap_insertion (struct bp_location
*left
, struct bp_location
*right
)
11767 const int left_inserted
= left
->inserted
;
11768 const int left_duplicate
= left
->duplicate
;
11769 const int left_needs_update
= left
->needs_update
;
11770 const struct bp_target_info left_target_info
= left
->target_info
;
11772 /* Locations of tracepoints can never be duplicated. */
11773 if (is_tracepoint (left
->owner
))
11774 gdb_assert (!left
->duplicate
);
11775 if (is_tracepoint (right
->owner
))
11776 gdb_assert (!right
->duplicate
);
11778 left
->inserted
= right
->inserted
;
11779 left
->duplicate
= right
->duplicate
;
11780 left
->needs_update
= right
->needs_update
;
11781 left
->target_info
= right
->target_info
;
11782 right
->inserted
= left_inserted
;
11783 right
->duplicate
= left_duplicate
;
11784 right
->needs_update
= left_needs_update
;
11785 right
->target_info
= left_target_info
;
11788 /* Force the re-insertion of the locations at ADDRESS. This is called
11789 once a new/deleted/modified duplicate location is found and we are evaluating
11790 conditions on the target's side. Such conditions need to be updated on
11794 force_breakpoint_reinsertion (struct bp_location
*bl
)
11796 struct bp_location
**locp
= NULL
, **loc2p
;
11797 struct bp_location
*loc
;
11798 CORE_ADDR address
= 0;
11801 address
= bl
->address
;
11802 pspace_num
= bl
->pspace
->num
;
11804 /* This is only meaningful if the target is
11805 evaluating conditions and if the user has
11806 opted for condition evaluation on the target's
11808 if (gdb_evaluates_breakpoint_condition_p ()
11809 || !target_supports_evaluation_of_breakpoint_conditions ())
11812 /* Flag all breakpoint locations with this address and
11813 the same program space as the location
11814 as "its condition has changed". We need to
11815 update the conditions on the target's side. */
11816 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, address
)
11820 if (!is_breakpoint (loc
->owner
)
11821 || pspace_num
!= loc
->pspace
->num
)
11824 /* Flag the location appropriately. We use a different state to
11825 let everyone know that we already updated the set of locations
11826 with addr bl->address and program space bl->pspace. This is so
11827 we don't have to keep calling these functions just to mark locations
11828 that have already been marked. */
11829 loc
->condition_changed
= condition_updated
;
11831 /* Free the agent expression bytecode as well. We will compute
11833 loc
->cond_bytecode
.reset ();
11836 /* Called whether new breakpoints are created, or existing breakpoints
11837 deleted, to update the global location list and recompute which
11838 locations are duplicate of which.
11840 The INSERT_MODE flag determines whether locations may not, may, or
11841 shall be inserted now. See 'enum ugll_insert_mode' for more
11845 update_global_location_list (enum ugll_insert_mode insert_mode
)
11847 struct breakpoint
*b
;
11848 struct bp_location
**locp
, *loc
;
11849 /* Last breakpoint location address that was marked for update. */
11850 CORE_ADDR last_addr
= 0;
11851 /* Last breakpoint location program space that was marked for update. */
11852 int last_pspace_num
= -1;
11854 /* Used in the duplicates detection below. When iterating over all
11855 bp_locations, points to the first bp_location of a given address.
11856 Breakpoints and watchpoints of different types are never
11857 duplicates of each other. Keep one pointer for each type of
11858 breakpoint/watchpoint, so we only need to loop over all locations
11860 struct bp_location
*bp_loc_first
; /* breakpoint */
11861 struct bp_location
*wp_loc_first
; /* hardware watchpoint */
11862 struct bp_location
*awp_loc_first
; /* access watchpoint */
11863 struct bp_location
*rwp_loc_first
; /* read watchpoint */
11865 /* Saved former bp_locations array which we compare against the newly
11866 built bp_locations from the current state of ALL_BREAKPOINTS. */
11867 struct bp_location
**old_locp
;
11868 unsigned old_locations_count
;
11869 gdb::unique_xmalloc_ptr
<struct bp_location
*> old_locations (bp_locations
);
11871 old_locations_count
= bp_locations_count
;
11872 bp_locations
= NULL
;
11873 bp_locations_count
= 0;
11875 ALL_BREAKPOINTS (b
)
11876 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
11877 bp_locations_count
++;
11879 bp_locations
= XNEWVEC (struct bp_location
*, bp_locations_count
);
11880 locp
= bp_locations
;
11881 ALL_BREAKPOINTS (b
)
11882 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
11884 qsort (bp_locations
, bp_locations_count
, sizeof (*bp_locations
),
11885 bp_locations_compare
);
11887 bp_locations_target_extensions_update ();
11889 /* Identify bp_location instances that are no longer present in the
11890 new list, and therefore should be freed. Note that it's not
11891 necessary that those locations should be removed from inferior --
11892 if there's another location at the same address (previously
11893 marked as duplicate), we don't need to remove/insert the
11896 LOCP is kept in sync with OLD_LOCP, each pointing to the current
11897 and former bp_location array state respectively. */
11899 locp
= bp_locations
;
11900 for (old_locp
= old_locations
.get ();
11901 old_locp
< old_locations
.get () + old_locations_count
;
11904 struct bp_location
*old_loc
= *old_locp
;
11905 struct bp_location
**loc2p
;
11907 /* Tells if 'old_loc' is found among the new locations. If
11908 not, we have to free it. */
11909 int found_object
= 0;
11910 /* Tells if the location should remain inserted in the target. */
11911 int keep_in_target
= 0;
11914 /* Skip LOCP entries which will definitely never be needed.
11915 Stop either at or being the one matching OLD_LOC. */
11916 while (locp
< bp_locations
+ bp_locations_count
11917 && (*locp
)->address
< old_loc
->address
)
11921 (loc2p
< bp_locations
+ bp_locations_count
11922 && (*loc2p
)->address
== old_loc
->address
);
11925 /* Check if this is a new/duplicated location or a duplicated
11926 location that had its condition modified. If so, we want to send
11927 its condition to the target if evaluation of conditions is taking
11929 if ((*loc2p
)->condition_changed
== condition_modified
11930 && (last_addr
!= old_loc
->address
11931 || last_pspace_num
!= old_loc
->pspace
->num
))
11933 force_breakpoint_reinsertion (*loc2p
);
11934 last_pspace_num
= old_loc
->pspace
->num
;
11937 if (*loc2p
== old_loc
)
11941 /* We have already handled this address, update it so that we don't
11942 have to go through updates again. */
11943 last_addr
= old_loc
->address
;
11945 /* Target-side condition evaluation: Handle deleted locations. */
11947 force_breakpoint_reinsertion (old_loc
);
11949 /* If this location is no longer present, and inserted, look if
11950 there's maybe a new location at the same address. If so,
11951 mark that one inserted, and don't remove this one. This is
11952 needed so that we don't have a time window where a breakpoint
11953 at certain location is not inserted. */
11955 if (old_loc
->inserted
)
11957 /* If the location is inserted now, we might have to remove
11960 if (found_object
&& should_be_inserted (old_loc
))
11962 /* The location is still present in the location list,
11963 and still should be inserted. Don't do anything. */
11964 keep_in_target
= 1;
11968 /* This location still exists, but it won't be kept in the
11969 target since it may have been disabled. We proceed to
11970 remove its target-side condition. */
11972 /* The location is either no longer present, or got
11973 disabled. See if there's another location at the
11974 same address, in which case we don't need to remove
11975 this one from the target. */
11977 /* OLD_LOC comes from existing struct breakpoint. */
11978 if (breakpoint_address_is_meaningful (old_loc
->owner
))
11981 (loc2p
< bp_locations
+ bp_locations_count
11982 && (*loc2p
)->address
== old_loc
->address
);
11985 struct bp_location
*loc2
= *loc2p
;
11987 if (breakpoint_locations_match (loc2
, old_loc
))
11989 /* Read watchpoint locations are switched to
11990 access watchpoints, if the former are not
11991 supported, but the latter are. */
11992 if (is_hardware_watchpoint (old_loc
->owner
))
11994 gdb_assert (is_hardware_watchpoint (loc2
->owner
));
11995 loc2
->watchpoint_type
= old_loc
->watchpoint_type
;
11998 /* loc2 is a duplicated location. We need to check
11999 if it should be inserted in case it will be
12001 if (loc2
!= old_loc
12002 && unduplicated_should_be_inserted (loc2
))
12004 swap_insertion (old_loc
, loc2
);
12005 keep_in_target
= 1;
12013 if (!keep_in_target
)
12015 if (remove_breakpoint (old_loc
))
12017 /* This is just about all we can do. We could keep
12018 this location on the global list, and try to
12019 remove it next time, but there's no particular
12020 reason why we will succeed next time.
12022 Note that at this point, old_loc->owner is still
12023 valid, as delete_breakpoint frees the breakpoint
12024 only after calling us. */
12025 printf_filtered (_("warning: Error removing "
12026 "breakpoint %d\n"),
12027 old_loc
->owner
->number
);
12035 if (removed
&& target_is_non_stop_p ()
12036 && need_moribund_for_location_type (old_loc
))
12038 /* This location was removed from the target. In
12039 non-stop mode, a race condition is possible where
12040 we've removed a breakpoint, but stop events for that
12041 breakpoint are already queued and will arrive later.
12042 We apply an heuristic to be able to distinguish such
12043 SIGTRAPs from other random SIGTRAPs: we keep this
12044 breakpoint location for a bit, and will retire it
12045 after we see some number of events. The theory here
12046 is that reporting of events should, "on the average",
12047 be fair, so after a while we'll see events from all
12048 threads that have anything of interest, and no longer
12049 need to keep this breakpoint location around. We
12050 don't hold locations forever so to reduce chances of
12051 mistaking a non-breakpoint SIGTRAP for a breakpoint
12054 The heuristic failing can be disastrous on
12055 decr_pc_after_break targets.
12057 On decr_pc_after_break targets, like e.g., x86-linux,
12058 if we fail to recognize a late breakpoint SIGTRAP,
12059 because events_till_retirement has reached 0 too
12060 soon, we'll fail to do the PC adjustment, and report
12061 a random SIGTRAP to the user. When the user resumes
12062 the inferior, it will most likely immediately crash
12063 with SIGILL/SIGBUS/SIGSEGV, or worse, get silently
12064 corrupted, because of being resumed e.g., in the
12065 middle of a multi-byte instruction, or skipped a
12066 one-byte instruction. This was actually seen happen
12067 on native x86-linux, and should be less rare on
12068 targets that do not support new thread events, like
12069 remote, due to the heuristic depending on
12072 Mistaking a random SIGTRAP for a breakpoint trap
12073 causes similar symptoms (PC adjustment applied when
12074 it shouldn't), but then again, playing with SIGTRAPs
12075 behind the debugger's back is asking for trouble.
12077 Since hardware watchpoint traps are always
12078 distinguishable from other traps, so we don't need to
12079 apply keep hardware watchpoint moribund locations
12080 around. We simply always ignore hardware watchpoint
12081 traps we can no longer explain. */
12083 old_loc
->events_till_retirement
= 3 * (thread_count () + 1);
12084 old_loc
->owner
= NULL
;
12086 VEC_safe_push (bp_location_p
, moribund_locations
, old_loc
);
12090 old_loc
->owner
= NULL
;
12091 decref_bp_location (&old_loc
);
12096 /* Rescan breakpoints at the same address and section, marking the
12097 first one as "first" and any others as "duplicates". This is so
12098 that the bpt instruction is only inserted once. If we have a
12099 permanent breakpoint at the same place as BPT, make that one the
12100 official one, and the rest as duplicates. Permanent breakpoints
12101 are sorted first for the same address.
12103 Do the same for hardware watchpoints, but also considering the
12104 watchpoint's type (regular/access/read) and length. */
12106 bp_loc_first
= NULL
;
12107 wp_loc_first
= NULL
;
12108 awp_loc_first
= NULL
;
12109 rwp_loc_first
= NULL
;
12110 ALL_BP_LOCATIONS (loc
, locp
)
12112 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always
12114 struct bp_location
**loc_first_p
;
12117 if (!unduplicated_should_be_inserted (loc
)
12118 || !breakpoint_address_is_meaningful (b
)
12119 /* Don't detect duplicate for tracepoint locations because they are
12120 never duplicated. See the comments in field `duplicate' of
12121 `struct bp_location'. */
12122 || is_tracepoint (b
))
12124 /* Clear the condition modification flag. */
12125 loc
->condition_changed
= condition_unchanged
;
12129 if (b
->type
== bp_hardware_watchpoint
)
12130 loc_first_p
= &wp_loc_first
;
12131 else if (b
->type
== bp_read_watchpoint
)
12132 loc_first_p
= &rwp_loc_first
;
12133 else if (b
->type
== bp_access_watchpoint
)
12134 loc_first_p
= &awp_loc_first
;
12136 loc_first_p
= &bp_loc_first
;
12138 if (*loc_first_p
== NULL
12139 || (overlay_debugging
&& loc
->section
!= (*loc_first_p
)->section
)
12140 || !breakpoint_locations_match (loc
, *loc_first_p
))
12142 *loc_first_p
= loc
;
12143 loc
->duplicate
= 0;
12145 if (is_breakpoint (loc
->owner
) && loc
->condition_changed
)
12147 loc
->needs_update
= 1;
12148 /* Clear the condition modification flag. */
12149 loc
->condition_changed
= condition_unchanged
;
12155 /* This and the above ensure the invariant that the first location
12156 is not duplicated, and is the inserted one.
12157 All following are marked as duplicated, and are not inserted. */
12159 swap_insertion (loc
, *loc_first_p
);
12160 loc
->duplicate
= 1;
12162 /* Clear the condition modification flag. */
12163 loc
->condition_changed
= condition_unchanged
;
12166 if (insert_mode
== UGLL_INSERT
|| breakpoints_should_be_inserted_now ())
12168 if (insert_mode
!= UGLL_DONT_INSERT
)
12169 insert_breakpoint_locations ();
12172 /* Even though the caller told us to not insert new
12173 locations, we may still need to update conditions on the
12174 target's side of breakpoints that were already inserted
12175 if the target is evaluating breakpoint conditions. We
12176 only update conditions for locations that are marked
12178 update_inserted_breakpoint_locations ();
12182 if (insert_mode
!= UGLL_DONT_INSERT
)
12183 download_tracepoint_locations ();
12187 breakpoint_retire_moribund (void)
12189 struct bp_location
*loc
;
12192 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
12193 if (--(loc
->events_till_retirement
) == 0)
12195 decref_bp_location (&loc
);
12196 VEC_unordered_remove (bp_location_p
, moribund_locations
, ix
);
12202 update_global_location_list_nothrow (enum ugll_insert_mode insert_mode
)
12207 update_global_location_list (insert_mode
);
12209 CATCH (e
, RETURN_MASK_ERROR
)
12215 /* Clear BKP from a BPS. */
12218 bpstat_remove_bp_location (bpstat bps
, struct breakpoint
*bpt
)
12222 for (bs
= bps
; bs
; bs
= bs
->next
)
12223 if (bs
->breakpoint_at
== bpt
)
12225 bs
->breakpoint_at
= NULL
;
12226 bs
->old_val
= NULL
;
12227 /* bs->commands will be freed later. */
12231 /* Callback for iterate_over_threads. */
12233 bpstat_remove_breakpoint_callback (struct thread_info
*th
, void *data
)
12235 struct breakpoint
*bpt
= (struct breakpoint
*) data
;
12237 bpstat_remove_bp_location (th
->control
.stop_bpstat
, bpt
);
12241 /* Helper for breakpoint and tracepoint breakpoint_ops->mention
12245 say_where (struct breakpoint
*b
)
12247 struct value_print_options opts
;
12249 get_user_print_options (&opts
);
12251 /* i18n: cagney/2005-02-11: Below needs to be merged into a
12253 if (b
->loc
== NULL
)
12255 /* For pending locations, the output differs slightly based
12256 on b->extra_string. If this is non-NULL, it contains either
12257 a condition or dprintf arguments. */
12258 if (b
->extra_string
== NULL
)
12260 printf_filtered (_(" (%s) pending."),
12261 event_location_to_string (b
->location
.get ()));
12263 else if (b
->type
== bp_dprintf
)
12265 printf_filtered (_(" (%s,%s) pending."),
12266 event_location_to_string (b
->location
.get ()),
12271 printf_filtered (_(" (%s %s) pending."),
12272 event_location_to_string (b
->location
.get ()),
12278 if (opts
.addressprint
|| b
->loc
->symtab
== NULL
)
12280 printf_filtered (" at ");
12281 fputs_filtered (paddress (b
->loc
->gdbarch
, b
->loc
->address
),
12284 if (b
->loc
->symtab
!= NULL
)
12286 /* If there is a single location, we can print the location
12288 if (b
->loc
->next
== NULL
)
12289 printf_filtered (": file %s, line %d.",
12290 symtab_to_filename_for_display (b
->loc
->symtab
),
12291 b
->loc
->line_number
);
12293 /* This is not ideal, but each location may have a
12294 different file name, and this at least reflects the
12295 real situation somewhat. */
12296 printf_filtered (": %s.",
12297 event_location_to_string (b
->location
.get ()));
12302 struct bp_location
*loc
= b
->loc
;
12304 for (; loc
; loc
= loc
->next
)
12306 printf_filtered (" (%d locations)", n
);
12311 /* Default bp_location_ops methods. */
12314 bp_location_dtor (struct bp_location
*self
)
12316 xfree (self
->function_name
);
12319 static const struct bp_location_ops bp_location_ops
=
12324 /* Destructor for the breakpoint base class. */
12326 breakpoint::~breakpoint ()
12328 xfree (this->cond_string
);
12329 xfree (this->extra_string
);
12330 xfree (this->filter
);
12333 static struct bp_location
*
12334 base_breakpoint_allocate_location (struct breakpoint
*self
)
12336 return new bp_location (&bp_location_ops
, self
);
12340 base_breakpoint_re_set (struct breakpoint
*b
)
12342 /* Nothing to re-set. */
12345 #define internal_error_pure_virtual_called() \
12346 gdb_assert_not_reached ("pure virtual function called")
12349 base_breakpoint_insert_location (struct bp_location
*bl
)
12351 internal_error_pure_virtual_called ();
12355 base_breakpoint_remove_location (struct bp_location
*bl
,
12356 enum remove_bp_reason reason
)
12358 internal_error_pure_virtual_called ();
12362 base_breakpoint_breakpoint_hit (const struct bp_location
*bl
,
12363 const address_space
*aspace
,
12365 const struct target_waitstatus
*ws
)
12367 internal_error_pure_virtual_called ();
12371 base_breakpoint_check_status (bpstat bs
)
12376 /* A "works_in_software_mode" breakpoint_ops method that just internal
12380 base_breakpoint_works_in_software_mode (const struct breakpoint
*b
)
12382 internal_error_pure_virtual_called ();
12385 /* A "resources_needed" breakpoint_ops method that just internal
12389 base_breakpoint_resources_needed (const struct bp_location
*bl
)
12391 internal_error_pure_virtual_called ();
12394 static enum print_stop_action
12395 base_breakpoint_print_it (bpstat bs
)
12397 internal_error_pure_virtual_called ();
12401 base_breakpoint_print_one_detail (const struct breakpoint
*self
,
12402 struct ui_out
*uiout
)
12408 base_breakpoint_print_mention (struct breakpoint
*b
)
12410 internal_error_pure_virtual_called ();
12414 base_breakpoint_print_recreate (struct breakpoint
*b
, struct ui_file
*fp
)
12416 internal_error_pure_virtual_called ();
12420 base_breakpoint_create_sals_from_location
12421 (const struct event_location
*location
,
12422 struct linespec_result
*canonical
,
12423 enum bptype type_wanted
)
12425 internal_error_pure_virtual_called ();
12429 base_breakpoint_create_breakpoints_sal (struct gdbarch
*gdbarch
,
12430 struct linespec_result
*c
,
12431 gdb::unique_xmalloc_ptr
<char> cond_string
,
12432 gdb::unique_xmalloc_ptr
<char> extra_string
,
12433 enum bptype type_wanted
,
12434 enum bpdisp disposition
,
12436 int task
, int ignore_count
,
12437 const struct breakpoint_ops
*o
,
12438 int from_tty
, int enabled
,
12439 int internal
, unsigned flags
)
12441 internal_error_pure_virtual_called ();
12444 static std::vector
<symtab_and_line
>
12445 base_breakpoint_decode_location (struct breakpoint
*b
,
12446 const struct event_location
*location
,
12447 struct program_space
*search_pspace
)
12449 internal_error_pure_virtual_called ();
12452 /* The default 'explains_signal' method. */
12455 base_breakpoint_explains_signal (struct breakpoint
*b
, enum gdb_signal sig
)
12460 /* The default "after_condition_true" method. */
12463 base_breakpoint_after_condition_true (struct bpstats
*bs
)
12465 /* Nothing to do. */
12468 struct breakpoint_ops base_breakpoint_ops
=
12470 base_breakpoint_allocate_location
,
12471 base_breakpoint_re_set
,
12472 base_breakpoint_insert_location
,
12473 base_breakpoint_remove_location
,
12474 base_breakpoint_breakpoint_hit
,
12475 base_breakpoint_check_status
,
12476 base_breakpoint_resources_needed
,
12477 base_breakpoint_works_in_software_mode
,
12478 base_breakpoint_print_it
,
12480 base_breakpoint_print_one_detail
,
12481 base_breakpoint_print_mention
,
12482 base_breakpoint_print_recreate
,
12483 base_breakpoint_create_sals_from_location
,
12484 base_breakpoint_create_breakpoints_sal
,
12485 base_breakpoint_decode_location
,
12486 base_breakpoint_explains_signal
,
12487 base_breakpoint_after_condition_true
,
12490 /* Default breakpoint_ops methods. */
12493 bkpt_re_set (struct breakpoint
*b
)
12495 /* FIXME: is this still reachable? */
12496 if (breakpoint_event_location_empty_p (b
))
12498 /* Anything without a location can't be re-set. */
12499 delete_breakpoint (b
);
12503 breakpoint_re_set_default (b
);
12507 bkpt_insert_location (struct bp_location
*bl
)
12509 CORE_ADDR addr
= bl
->target_info
.reqstd_address
;
12511 bl
->target_info
.kind
= breakpoint_kind (bl
, &addr
);
12512 bl
->target_info
.placed_address
= addr
;
12514 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
12515 return target_insert_hw_breakpoint (bl
->gdbarch
, &bl
->target_info
);
12517 return target_insert_breakpoint (bl
->gdbarch
, &bl
->target_info
);
12521 bkpt_remove_location (struct bp_location
*bl
, enum remove_bp_reason reason
)
12523 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
12524 return target_remove_hw_breakpoint (bl
->gdbarch
, &bl
->target_info
);
12526 return target_remove_breakpoint (bl
->gdbarch
, &bl
->target_info
, reason
);
12530 bkpt_breakpoint_hit (const struct bp_location
*bl
,
12531 const address_space
*aspace
, CORE_ADDR bp_addr
,
12532 const struct target_waitstatus
*ws
)
12534 if (ws
->kind
!= TARGET_WAITKIND_STOPPED
12535 || ws
->value
.sig
!= GDB_SIGNAL_TRAP
)
12538 if (!breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
12542 if (overlay_debugging
/* unmapped overlay section */
12543 && section_is_overlay (bl
->section
)
12544 && !section_is_mapped (bl
->section
))
12551 dprintf_breakpoint_hit (const struct bp_location
*bl
,
12552 const address_space
*aspace
, CORE_ADDR bp_addr
,
12553 const struct target_waitstatus
*ws
)
12555 if (dprintf_style
== dprintf_style_agent
12556 && target_can_run_breakpoint_commands ())
12558 /* An agent-style dprintf never causes a stop. If we see a trap
12559 for this address it must be for a breakpoint that happens to
12560 be set at the same address. */
12564 return bkpt_breakpoint_hit (bl
, aspace
, bp_addr
, ws
);
12568 bkpt_resources_needed (const struct bp_location
*bl
)
12570 gdb_assert (bl
->owner
->type
== bp_hardware_breakpoint
);
12575 static enum print_stop_action
12576 bkpt_print_it (bpstat bs
)
12578 struct breakpoint
*b
;
12579 const struct bp_location
*bl
;
12581 struct ui_out
*uiout
= current_uiout
;
12583 gdb_assert (bs
->bp_location_at
!= NULL
);
12585 bl
= bs
->bp_location_at
;
12586 b
= bs
->breakpoint_at
;
12588 bp_temp
= b
->disposition
== disp_del
;
12589 if (bl
->address
!= bl
->requested_address
)
12590 breakpoint_adjustment_warning (bl
->requested_address
,
12593 annotate_breakpoint (b
->number
);
12594 maybe_print_thread_hit_breakpoint (uiout
);
12597 uiout
->text ("Temporary breakpoint ");
12599 uiout
->text ("Breakpoint ");
12600 if (uiout
->is_mi_like_p ())
12602 uiout
->field_string ("reason",
12603 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
12604 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
12606 uiout
->field_int ("bkptno", b
->number
);
12607 uiout
->text (", ");
12609 return PRINT_SRC_AND_LOC
;
12613 bkpt_print_mention (struct breakpoint
*b
)
12615 if (current_uiout
->is_mi_like_p ())
12620 case bp_breakpoint
:
12621 case bp_gnu_ifunc_resolver
:
12622 if (b
->disposition
== disp_del
)
12623 printf_filtered (_("Temporary breakpoint"));
12625 printf_filtered (_("Breakpoint"));
12626 printf_filtered (_(" %d"), b
->number
);
12627 if (b
->type
== bp_gnu_ifunc_resolver
)
12628 printf_filtered (_(" at gnu-indirect-function resolver"));
12630 case bp_hardware_breakpoint
:
12631 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
12634 printf_filtered (_("Dprintf %d"), b
->number
);
12642 bkpt_print_recreate (struct breakpoint
*tp
, struct ui_file
*fp
)
12644 if (tp
->type
== bp_breakpoint
&& tp
->disposition
== disp_del
)
12645 fprintf_unfiltered (fp
, "tbreak");
12646 else if (tp
->type
== bp_breakpoint
)
12647 fprintf_unfiltered (fp
, "break");
12648 else if (tp
->type
== bp_hardware_breakpoint
12649 && tp
->disposition
== disp_del
)
12650 fprintf_unfiltered (fp
, "thbreak");
12651 else if (tp
->type
== bp_hardware_breakpoint
)
12652 fprintf_unfiltered (fp
, "hbreak");
12654 internal_error (__FILE__
, __LINE__
,
12655 _("unhandled breakpoint type %d"), (int) tp
->type
);
12657 fprintf_unfiltered (fp
, " %s",
12658 event_location_to_string (tp
->location
.get ()));
12660 /* Print out extra_string if this breakpoint is pending. It might
12661 contain, for example, conditions that were set by the user. */
12662 if (tp
->loc
== NULL
&& tp
->extra_string
!= NULL
)
12663 fprintf_unfiltered (fp
, " %s", tp
->extra_string
);
12665 print_recreate_thread (tp
, fp
);
12669 bkpt_create_sals_from_location (const struct event_location
*location
,
12670 struct linespec_result
*canonical
,
12671 enum bptype type_wanted
)
12673 create_sals_from_location_default (location
, canonical
, type_wanted
);
12677 bkpt_create_breakpoints_sal (struct gdbarch
*gdbarch
,
12678 struct linespec_result
*canonical
,
12679 gdb::unique_xmalloc_ptr
<char> cond_string
,
12680 gdb::unique_xmalloc_ptr
<char> extra_string
,
12681 enum bptype type_wanted
,
12682 enum bpdisp disposition
,
12684 int task
, int ignore_count
,
12685 const struct breakpoint_ops
*ops
,
12686 int from_tty
, int enabled
,
12687 int internal
, unsigned flags
)
12689 create_breakpoints_sal_default (gdbarch
, canonical
,
12690 std::move (cond_string
),
12691 std::move (extra_string
),
12693 disposition
, thread
, task
,
12694 ignore_count
, ops
, from_tty
,
12695 enabled
, internal
, flags
);
12698 static std::vector
<symtab_and_line
>
12699 bkpt_decode_location (struct breakpoint
*b
,
12700 const struct event_location
*location
,
12701 struct program_space
*search_pspace
)
12703 return decode_location_default (b
, location
, search_pspace
);
12706 /* Virtual table for internal breakpoints. */
12709 internal_bkpt_re_set (struct breakpoint
*b
)
12713 /* Delete overlay event and longjmp master breakpoints; they
12714 will be reset later by breakpoint_re_set. */
12715 case bp_overlay_event
:
12716 case bp_longjmp_master
:
12717 case bp_std_terminate_master
:
12718 case bp_exception_master
:
12719 delete_breakpoint (b
);
12722 /* This breakpoint is special, it's set up when the inferior
12723 starts and we really don't want to touch it. */
12724 case bp_shlib_event
:
12726 /* Like bp_shlib_event, this breakpoint type is special. Once
12727 it is set up, we do not want to touch it. */
12728 case bp_thread_event
:
12734 internal_bkpt_check_status (bpstat bs
)
12736 if (bs
->breakpoint_at
->type
== bp_shlib_event
)
12738 /* If requested, stop when the dynamic linker notifies GDB of
12739 events. This allows the user to get control and place
12740 breakpoints in initializer routines for dynamically loaded
12741 objects (among other things). */
12742 bs
->stop
= stop_on_solib_events
;
12743 bs
->print
= stop_on_solib_events
;
12749 static enum print_stop_action
12750 internal_bkpt_print_it (bpstat bs
)
12752 struct breakpoint
*b
;
12754 b
= bs
->breakpoint_at
;
12758 case bp_shlib_event
:
12759 /* Did we stop because the user set the stop_on_solib_events
12760 variable? (If so, we report this as a generic, "Stopped due
12761 to shlib event" message.) */
12762 print_solib_event (0);
12765 case bp_thread_event
:
12766 /* Not sure how we will get here.
12767 GDB should not stop for these breakpoints. */
12768 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
12771 case bp_overlay_event
:
12772 /* By analogy with the thread event, GDB should not stop for these. */
12773 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
12776 case bp_longjmp_master
:
12777 /* These should never be enabled. */
12778 printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
12781 case bp_std_terminate_master
:
12782 /* These should never be enabled. */
12783 printf_filtered (_("std::terminate Master Breakpoint: "
12784 "gdb should not stop!\n"));
12787 case bp_exception_master
:
12788 /* These should never be enabled. */
12789 printf_filtered (_("Exception Master Breakpoint: "
12790 "gdb should not stop!\n"));
12794 return PRINT_NOTHING
;
12798 internal_bkpt_print_mention (struct breakpoint
*b
)
12800 /* Nothing to mention. These breakpoints are internal. */
12803 /* Virtual table for momentary breakpoints */
12806 momentary_bkpt_re_set (struct breakpoint
*b
)
12808 /* Keep temporary breakpoints, which can be encountered when we step
12809 over a dlopen call and solib_add is resetting the breakpoints.
12810 Otherwise these should have been blown away via the cleanup chain
12811 or by breakpoint_init_inferior when we rerun the executable. */
12815 momentary_bkpt_check_status (bpstat bs
)
12817 /* Nothing. The point of these breakpoints is causing a stop. */
12820 static enum print_stop_action
12821 momentary_bkpt_print_it (bpstat bs
)
12823 return PRINT_UNKNOWN
;
12827 momentary_bkpt_print_mention (struct breakpoint
*b
)
12829 /* Nothing to mention. These breakpoints are internal. */
12832 /* Ensure INITIATING_FRAME is cleared when no such breakpoint exists.
12834 It gets cleared already on the removal of the first one of such placed
12835 breakpoints. This is OK as they get all removed altogether. */
12837 longjmp_breakpoint::~longjmp_breakpoint ()
12839 thread_info
*tp
= find_thread_global_id (this->thread
);
12842 tp
->initiating_frame
= null_frame_id
;
12845 /* Specific methods for probe breakpoints. */
12848 bkpt_probe_insert_location (struct bp_location
*bl
)
12850 int v
= bkpt_insert_location (bl
);
12854 /* The insertion was successful, now let's set the probe's semaphore
12856 bl
->probe
.prob
->set_semaphore (bl
->probe
.objfile
, bl
->gdbarch
);
12863 bkpt_probe_remove_location (struct bp_location
*bl
,
12864 enum remove_bp_reason reason
)
12866 /* Let's clear the semaphore before removing the location. */
12867 bl
->probe
.prob
->clear_semaphore (bl
->probe
.objfile
, bl
->gdbarch
);
12869 return bkpt_remove_location (bl
, reason
);
12873 bkpt_probe_create_sals_from_location (const struct event_location
*location
,
12874 struct linespec_result
*canonical
,
12875 enum bptype type_wanted
)
12877 struct linespec_sals lsal
;
12879 lsal
.sals
= parse_probes (location
, NULL
, canonical
);
12881 = xstrdup (event_location_to_string (canonical
->location
.get ()));
12882 canonical
->lsals
.push_back (std::move (lsal
));
12885 static std::vector
<symtab_and_line
>
12886 bkpt_probe_decode_location (struct breakpoint
*b
,
12887 const struct event_location
*location
,
12888 struct program_space
*search_pspace
)
12890 std::vector
<symtab_and_line
> sals
= parse_probes (location
, search_pspace
, NULL
);
12892 error (_("probe not found"));
12896 /* The breakpoint_ops structure to be used in tracepoints. */
12899 tracepoint_re_set (struct breakpoint
*b
)
12901 breakpoint_re_set_default (b
);
12905 tracepoint_breakpoint_hit (const struct bp_location
*bl
,
12906 const address_space
*aspace
, CORE_ADDR bp_addr
,
12907 const struct target_waitstatus
*ws
)
12909 /* By definition, the inferior does not report stops at
12915 tracepoint_print_one_detail (const struct breakpoint
*self
,
12916 struct ui_out
*uiout
)
12918 struct tracepoint
*tp
= (struct tracepoint
*) self
;
12919 if (tp
->static_trace_marker_id
)
12921 gdb_assert (self
->type
== bp_static_tracepoint
);
12923 uiout
->text ("\tmarker id is ");
12924 uiout
->field_string ("static-tracepoint-marker-string-id",
12925 tp
->static_trace_marker_id
);
12926 uiout
->text ("\n");
12931 tracepoint_print_mention (struct breakpoint
*b
)
12933 if (current_uiout
->is_mi_like_p ())
12938 case bp_tracepoint
:
12939 printf_filtered (_("Tracepoint"));
12940 printf_filtered (_(" %d"), b
->number
);
12942 case bp_fast_tracepoint
:
12943 printf_filtered (_("Fast tracepoint"));
12944 printf_filtered (_(" %d"), b
->number
);
12946 case bp_static_tracepoint
:
12947 printf_filtered (_("Static tracepoint"));
12948 printf_filtered (_(" %d"), b
->number
);
12951 internal_error (__FILE__
, __LINE__
,
12952 _("unhandled tracepoint type %d"), (int) b
->type
);
12959 tracepoint_print_recreate (struct breakpoint
*self
, struct ui_file
*fp
)
12961 struct tracepoint
*tp
= (struct tracepoint
*) self
;
12963 if (self
->type
== bp_fast_tracepoint
)
12964 fprintf_unfiltered (fp
, "ftrace");
12965 else if (self
->type
== bp_static_tracepoint
)
12966 fprintf_unfiltered (fp
, "strace");
12967 else if (self
->type
== bp_tracepoint
)
12968 fprintf_unfiltered (fp
, "trace");
12970 internal_error (__FILE__
, __LINE__
,
12971 _("unhandled tracepoint type %d"), (int) self
->type
);
12973 fprintf_unfiltered (fp
, " %s",
12974 event_location_to_string (self
->location
.get ()));
12975 print_recreate_thread (self
, fp
);
12977 if (tp
->pass_count
)
12978 fprintf_unfiltered (fp
, " passcount %d\n", tp
->pass_count
);
12982 tracepoint_create_sals_from_location (const struct event_location
*location
,
12983 struct linespec_result
*canonical
,
12984 enum bptype type_wanted
)
12986 create_sals_from_location_default (location
, canonical
, type_wanted
);
12990 tracepoint_create_breakpoints_sal (struct gdbarch
*gdbarch
,
12991 struct linespec_result
*canonical
,
12992 gdb::unique_xmalloc_ptr
<char> cond_string
,
12993 gdb::unique_xmalloc_ptr
<char> extra_string
,
12994 enum bptype type_wanted
,
12995 enum bpdisp disposition
,
12997 int task
, int ignore_count
,
12998 const struct breakpoint_ops
*ops
,
12999 int from_tty
, int enabled
,
13000 int internal
, unsigned flags
)
13002 create_breakpoints_sal_default (gdbarch
, canonical
,
13003 std::move (cond_string
),
13004 std::move (extra_string
),
13006 disposition
, thread
, task
,
13007 ignore_count
, ops
, from_tty
,
13008 enabled
, internal
, flags
);
13011 static std::vector
<symtab_and_line
>
13012 tracepoint_decode_location (struct breakpoint
*b
,
13013 const struct event_location
*location
,
13014 struct program_space
*search_pspace
)
13016 return decode_location_default (b
, location
, search_pspace
);
13019 struct breakpoint_ops tracepoint_breakpoint_ops
;
13021 /* The breakpoint_ops structure to be use on tracepoints placed in a
13025 tracepoint_probe_create_sals_from_location
13026 (const struct event_location
*location
,
13027 struct linespec_result
*canonical
,
13028 enum bptype type_wanted
)
13030 /* We use the same method for breakpoint on probes. */
13031 bkpt_probe_create_sals_from_location (location
, canonical
, type_wanted
);
13034 static std::vector
<symtab_and_line
>
13035 tracepoint_probe_decode_location (struct breakpoint
*b
,
13036 const struct event_location
*location
,
13037 struct program_space
*search_pspace
)
13039 /* We use the same method for breakpoint on probes. */
13040 return bkpt_probe_decode_location (b
, location
, search_pspace
);
13043 static struct breakpoint_ops tracepoint_probe_breakpoint_ops
;
13045 /* Dprintf breakpoint_ops methods. */
13048 dprintf_re_set (struct breakpoint
*b
)
13050 breakpoint_re_set_default (b
);
13052 /* extra_string should never be non-NULL for dprintf. */
13053 gdb_assert (b
->extra_string
!= NULL
);
13055 /* 1 - connect to target 1, that can run breakpoint commands.
13056 2 - create a dprintf, which resolves fine.
13057 3 - disconnect from target 1
13058 4 - connect to target 2, that can NOT run breakpoint commands.
13060 After steps #3/#4, you'll want the dprintf command list to
13061 be updated, because target 1 and 2 may well return different
13062 answers for target_can_run_breakpoint_commands().
13063 Given absence of finer grained resetting, we get to do
13064 it all the time. */
13065 if (b
->extra_string
!= NULL
)
13066 update_dprintf_command_list (b
);
13069 /* Implement the "print_recreate" breakpoint_ops method for dprintf. */
13072 dprintf_print_recreate (struct breakpoint
*tp
, struct ui_file
*fp
)
13074 fprintf_unfiltered (fp
, "dprintf %s,%s",
13075 event_location_to_string (tp
->location
.get ()),
13077 print_recreate_thread (tp
, fp
);
13080 /* Implement the "after_condition_true" breakpoint_ops method for
13083 dprintf's are implemented with regular commands in their command
13084 list, but we run the commands here instead of before presenting the
13085 stop to the user, as dprintf's don't actually cause a stop. This
13086 also makes it so that the commands of multiple dprintfs at the same
13087 address are all handled. */
13090 dprintf_after_condition_true (struct bpstats
*bs
)
13092 struct bpstats tmp_bs
;
13093 struct bpstats
*tmp_bs_p
= &tmp_bs
;
13095 /* dprintf's never cause a stop. This wasn't set in the
13096 check_status hook instead because that would make the dprintf's
13097 condition not be evaluated. */
13100 /* Run the command list here. Take ownership of it instead of
13101 copying. We never want these commands to run later in
13102 bpstat_do_actions, if a breakpoint that causes a stop happens to
13103 be set at same address as this dprintf, or even if running the
13104 commands here throws. */
13105 tmp_bs
.commands
= bs
->commands
;
13106 bs
->commands
= NULL
;
13108 bpstat_do_actions_1 (&tmp_bs_p
);
13110 /* 'tmp_bs.commands' will usually be NULL by now, but
13111 bpstat_do_actions_1 may return early without processing the whole
13115 /* The breakpoint_ops structure to be used on static tracepoints with
13119 strace_marker_create_sals_from_location (const struct event_location
*location
,
13120 struct linespec_result
*canonical
,
13121 enum bptype type_wanted
)
13123 struct linespec_sals lsal
;
13124 const char *arg_start
, *arg
;
13126 arg
= arg_start
= get_linespec_location (location
)->spec_string
;
13127 lsal
.sals
= decode_static_tracepoint_spec (&arg
);
13129 std::string
str (arg_start
, arg
- arg_start
);
13130 const char *ptr
= str
.c_str ();
13131 canonical
->location
13132 = new_linespec_location (&ptr
, symbol_name_match_type::FULL
);
13135 = xstrdup (event_location_to_string (canonical
->location
.get ()));
13136 canonical
->lsals
.push_back (std::move (lsal
));
13140 strace_marker_create_breakpoints_sal (struct gdbarch
*gdbarch
,
13141 struct linespec_result
*canonical
,
13142 gdb::unique_xmalloc_ptr
<char> cond_string
,
13143 gdb::unique_xmalloc_ptr
<char> extra_string
,
13144 enum bptype type_wanted
,
13145 enum bpdisp disposition
,
13147 int task
, int ignore_count
,
13148 const struct breakpoint_ops
*ops
,
13149 int from_tty
, int enabled
,
13150 int internal
, unsigned flags
)
13152 const linespec_sals
&lsal
= canonical
->lsals
[0];
13154 /* If the user is creating a static tracepoint by marker id
13155 (strace -m MARKER_ID), then store the sals index, so that
13156 breakpoint_re_set can try to match up which of the newly
13157 found markers corresponds to this one, and, don't try to
13158 expand multiple locations for each sal, given than SALS
13159 already should contain all sals for MARKER_ID. */
13161 for (size_t i
= 0; i
< lsal
.sals
.size (); i
++)
13163 event_location_up location
13164 = copy_event_location (canonical
->location
.get ());
13166 std::unique_ptr
<tracepoint
> tp (new tracepoint ());
13167 init_breakpoint_sal (tp
.get (), gdbarch
, lsal
.sals
[i
],
13168 std::move (location
), NULL
,
13169 std::move (cond_string
),
13170 std::move (extra_string
),
13171 type_wanted
, disposition
,
13172 thread
, task
, ignore_count
, ops
,
13173 from_tty
, enabled
, internal
, flags
,
13174 canonical
->special_display
);
13175 /* Given that its possible to have multiple markers with
13176 the same string id, if the user is creating a static
13177 tracepoint by marker id ("strace -m MARKER_ID"), then
13178 store the sals index, so that breakpoint_re_set can
13179 try to match up which of the newly found markers
13180 corresponds to this one */
13181 tp
->static_trace_marker_id_idx
= i
;
13183 install_breakpoint (internal
, std::move (tp
), 0);
13187 static std::vector
<symtab_and_line
>
13188 strace_marker_decode_location (struct breakpoint
*b
,
13189 const struct event_location
*location
,
13190 struct program_space
*search_pspace
)
13192 struct tracepoint
*tp
= (struct tracepoint
*) b
;
13193 const char *s
= get_linespec_location (location
)->spec_string
;
13195 std::vector
<symtab_and_line
> sals
= decode_static_tracepoint_spec (&s
);
13196 if (sals
.size () > tp
->static_trace_marker_id_idx
)
13198 sals
[0] = sals
[tp
->static_trace_marker_id_idx
];
13203 error (_("marker %s not found"), tp
->static_trace_marker_id
);
13206 static struct breakpoint_ops strace_marker_breakpoint_ops
;
13209 strace_marker_p (struct breakpoint
*b
)
13211 return b
->ops
== &strace_marker_breakpoint_ops
;
13214 /* Delete a breakpoint and clean up all traces of it in the data
13218 delete_breakpoint (struct breakpoint
*bpt
)
13220 struct breakpoint
*b
;
13222 gdb_assert (bpt
!= NULL
);
13224 /* Has this bp already been deleted? This can happen because
13225 multiple lists can hold pointers to bp's. bpstat lists are
13228 One example of this happening is a watchpoint's scope bp. When
13229 the scope bp triggers, we notice that the watchpoint is out of
13230 scope, and delete it. We also delete its scope bp. But the
13231 scope bp is marked "auto-deleting", and is already on a bpstat.
13232 That bpstat is then checked for auto-deleting bp's, which are
13235 A real solution to this problem might involve reference counts in
13236 bp's, and/or giving them pointers back to their referencing
13237 bpstat's, and teaching delete_breakpoint to only free a bp's
13238 storage when no more references were extent. A cheaper bandaid
13240 if (bpt
->type
== bp_none
)
13243 /* At least avoid this stale reference until the reference counting
13244 of breakpoints gets resolved. */
13245 if (bpt
->related_breakpoint
!= bpt
)
13247 struct breakpoint
*related
;
13248 struct watchpoint
*w
;
13250 if (bpt
->type
== bp_watchpoint_scope
)
13251 w
= (struct watchpoint
*) bpt
->related_breakpoint
;
13252 else if (bpt
->related_breakpoint
->type
== bp_watchpoint_scope
)
13253 w
= (struct watchpoint
*) bpt
;
13257 watchpoint_del_at_next_stop (w
);
13259 /* Unlink bpt from the bpt->related_breakpoint ring. */
13260 for (related
= bpt
; related
->related_breakpoint
!= bpt
;
13261 related
= related
->related_breakpoint
);
13262 related
->related_breakpoint
= bpt
->related_breakpoint
;
13263 bpt
->related_breakpoint
= bpt
;
13266 /* watch_command_1 creates a watchpoint but only sets its number if
13267 update_watchpoint succeeds in creating its bp_locations. If there's
13268 a problem in that process, we'll be asked to delete the half-created
13269 watchpoint. In that case, don't announce the deletion. */
13271 observer_notify_breakpoint_deleted (bpt
);
13273 if (breakpoint_chain
== bpt
)
13274 breakpoint_chain
= bpt
->next
;
13276 ALL_BREAKPOINTS (b
)
13277 if (b
->next
== bpt
)
13279 b
->next
= bpt
->next
;
13283 /* Be sure no bpstat's are pointing at the breakpoint after it's
13285 /* FIXME, how can we find all bpstat's? We just check stop_bpstat
13286 in all threads for now. Note that we cannot just remove bpstats
13287 pointing at bpt from the stop_bpstat list entirely, as breakpoint
13288 commands are associated with the bpstat; if we remove it here,
13289 then the later call to bpstat_do_actions (&stop_bpstat); in
13290 event-top.c won't do anything, and temporary breakpoints with
13291 commands won't work. */
13293 iterate_over_threads (bpstat_remove_breakpoint_callback
, bpt
);
13295 /* Now that breakpoint is removed from breakpoint list, update the
13296 global location list. This will remove locations that used to
13297 belong to this breakpoint. Do this before freeing the breakpoint
13298 itself, since remove_breakpoint looks at location's owner. It
13299 might be better design to have location completely
13300 self-contained, but it's not the case now. */
13301 update_global_location_list (UGLL_DONT_INSERT
);
13303 /* On the chance that someone will soon try again to delete this
13304 same bp, we mark it as deleted before freeing its storage. */
13305 bpt
->type
= bp_none
;
13309 /* Iterator function to call a user-provided callback function once
13310 for each of B and its related breakpoints. */
13313 iterate_over_related_breakpoints (struct breakpoint
*b
,
13314 gdb::function_view
<void (breakpoint
*)> function
)
13316 struct breakpoint
*related
;
13321 struct breakpoint
*next
;
13323 /* FUNCTION may delete RELATED. */
13324 next
= related
->related_breakpoint
;
13326 if (next
== related
)
13328 /* RELATED is the last ring entry. */
13329 function (related
);
13331 /* FUNCTION may have deleted it, so we'd never reach back to
13332 B. There's nothing left to do anyway, so just break
13337 function (related
);
13341 while (related
!= b
);
13345 delete_command (const char *arg
, int from_tty
)
13347 struct breakpoint
*b
, *b_tmp
;
13353 int breaks_to_delete
= 0;
13355 /* Delete all breakpoints if no argument. Do not delete
13356 internal breakpoints, these have to be deleted with an
13357 explicit breakpoint number argument. */
13358 ALL_BREAKPOINTS (b
)
13359 if (user_breakpoint_p (b
))
13361 breaks_to_delete
= 1;
13365 /* Ask user only if there are some breakpoints to delete. */
13367 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
13369 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
13370 if (user_breakpoint_p (b
))
13371 delete_breakpoint (b
);
13375 map_breakpoint_numbers
13376 (arg
, [&] (breakpoint
*b
)
13378 iterate_over_related_breakpoints (b
, delete_breakpoint
);
13382 /* Return true if all locations of B bound to PSPACE are pending. If
13383 PSPACE is NULL, all locations of all program spaces are
13387 all_locations_are_pending (struct breakpoint
*b
, struct program_space
*pspace
)
13389 struct bp_location
*loc
;
13391 for (loc
= b
->loc
; loc
!= NULL
; loc
= loc
->next
)
13392 if ((pspace
== NULL
13393 || loc
->pspace
== pspace
)
13394 && !loc
->shlib_disabled
13395 && !loc
->pspace
->executing_startup
)
13400 /* Subroutine of update_breakpoint_locations to simplify it.
13401 Return non-zero if multiple fns in list LOC have the same name.
13402 Null names are ignored. */
13405 ambiguous_names_p (struct bp_location
*loc
)
13407 struct bp_location
*l
;
13408 htab_t htab
= htab_create_alloc (13, htab_hash_string
,
13409 (int (*) (const void *,
13410 const void *)) streq
,
13411 NULL
, xcalloc
, xfree
);
13413 for (l
= loc
; l
!= NULL
; l
= l
->next
)
13416 const char *name
= l
->function_name
;
13418 /* Allow for some names to be NULL, ignore them. */
13422 slot
= (const char **) htab_find_slot (htab
, (const void *) name
,
13424 /* NOTE: We can assume slot != NULL here because xcalloc never
13428 htab_delete (htab
);
13434 htab_delete (htab
);
13438 /* When symbols change, it probably means the sources changed as well,
13439 and it might mean the static tracepoint markers are no longer at
13440 the same address or line numbers they used to be at last we
13441 checked. Losing your static tracepoints whenever you rebuild is
13442 undesirable. This function tries to resync/rematch gdb static
13443 tracepoints with the markers on the target, for static tracepoints
13444 that have not been set by marker id. Static tracepoint that have
13445 been set by marker id are reset by marker id in breakpoint_re_set.
13448 1) For a tracepoint set at a specific address, look for a marker at
13449 the old PC. If one is found there, assume to be the same marker.
13450 If the name / string id of the marker found is different from the
13451 previous known name, assume that means the user renamed the marker
13452 in the sources, and output a warning.
13454 2) For a tracepoint set at a given line number, look for a marker
13455 at the new address of the old line number. If one is found there,
13456 assume to be the same marker. If the name / string id of the
13457 marker found is different from the previous known name, assume that
13458 means the user renamed the marker in the sources, and output a
13461 3) If a marker is no longer found at the same address or line, it
13462 may mean the marker no longer exists. But it may also just mean
13463 the code changed a bit. Maybe the user added a few lines of code
13464 that made the marker move up or down (in line number terms). Ask
13465 the target for info about the marker with the string id as we knew
13466 it. If found, update line number and address in the matching
13467 static tracepoint. This will get confused if there's more than one
13468 marker with the same ID (possible in UST, although unadvised
13469 precisely because it confuses tools). */
13471 static struct symtab_and_line
13472 update_static_tracepoint (struct breakpoint
*b
, struct symtab_and_line sal
)
13474 struct tracepoint
*tp
= (struct tracepoint
*) b
;
13475 struct static_tracepoint_marker marker
;
13480 find_line_pc (sal
.symtab
, sal
.line
, &pc
);
13482 if (target_static_tracepoint_marker_at (pc
, &marker
))
13484 if (strcmp (tp
->static_trace_marker_id
, marker
.str_id
) != 0)
13485 warning (_("static tracepoint %d changed probed marker from %s to %s"),
13487 tp
->static_trace_marker_id
, marker
.str_id
);
13489 xfree (tp
->static_trace_marker_id
);
13490 tp
->static_trace_marker_id
= xstrdup (marker
.str_id
);
13491 release_static_tracepoint_marker (&marker
);
13496 /* Old marker wasn't found on target at lineno. Try looking it up
13498 if (!sal
.explicit_pc
13500 && sal
.symtab
!= NULL
13501 && tp
->static_trace_marker_id
!= NULL
)
13503 VEC(static_tracepoint_marker_p
) *markers
;
13506 = target_static_tracepoint_markers_by_strid (tp
->static_trace_marker_id
);
13508 if (!VEC_empty(static_tracepoint_marker_p
, markers
))
13510 struct symbol
*sym
;
13511 struct static_tracepoint_marker
*tpmarker
;
13512 struct ui_out
*uiout
= current_uiout
;
13513 struct explicit_location explicit_loc
;
13515 tpmarker
= VEC_index (static_tracepoint_marker_p
, markers
, 0);
13517 xfree (tp
->static_trace_marker_id
);
13518 tp
->static_trace_marker_id
= xstrdup (tpmarker
->str_id
);
13520 warning (_("marker for static tracepoint %d (%s) not "
13521 "found at previous line number"),
13522 b
->number
, tp
->static_trace_marker_id
);
13524 symtab_and_line sal2
= find_pc_line (tpmarker
->address
, 0);
13525 sym
= find_pc_sect_function (tpmarker
->address
, NULL
);
13526 uiout
->text ("Now in ");
13529 uiout
->field_string ("func", SYMBOL_PRINT_NAME (sym
));
13530 uiout
->text (" at ");
13532 uiout
->field_string ("file",
13533 symtab_to_filename_for_display (sal2
.symtab
));
13536 if (uiout
->is_mi_like_p ())
13538 const char *fullname
= symtab_to_fullname (sal2
.symtab
);
13540 uiout
->field_string ("fullname", fullname
);
13543 uiout
->field_int ("line", sal2
.line
);
13544 uiout
->text ("\n");
13546 b
->loc
->line_number
= sal2
.line
;
13547 b
->loc
->symtab
= sym
!= NULL
? sal2
.symtab
: NULL
;
13549 b
->location
.reset (NULL
);
13550 initialize_explicit_location (&explicit_loc
);
13551 explicit_loc
.source_filename
13552 = ASTRDUP (symtab_to_filename_for_display (sal2
.symtab
));
13553 explicit_loc
.line_offset
.offset
= b
->loc
->line_number
;
13554 explicit_loc
.line_offset
.sign
= LINE_OFFSET_NONE
;
13555 b
->location
= new_explicit_location (&explicit_loc
);
13557 /* Might be nice to check if function changed, and warn if
13560 release_static_tracepoint_marker (tpmarker
);
13566 /* Returns 1 iff locations A and B are sufficiently same that
13567 we don't need to report breakpoint as changed. */
13570 locations_are_equal (struct bp_location
*a
, struct bp_location
*b
)
13574 if (a
->address
!= b
->address
)
13577 if (a
->shlib_disabled
!= b
->shlib_disabled
)
13580 if (a
->enabled
!= b
->enabled
)
13587 if ((a
== NULL
) != (b
== NULL
))
13593 /* Split all locations of B that are bound to PSPACE out of B's
13594 location list to a separate list and return that list's head. If
13595 PSPACE is NULL, hoist out all locations of B. */
13597 static struct bp_location
*
13598 hoist_existing_locations (struct breakpoint
*b
, struct program_space
*pspace
)
13600 struct bp_location head
;
13601 struct bp_location
*i
= b
->loc
;
13602 struct bp_location
**i_link
= &b
->loc
;
13603 struct bp_location
*hoisted
= &head
;
13605 if (pspace
== NULL
)
13616 if (i
->pspace
== pspace
)
13631 /* Create new breakpoint locations for B (a hardware or software
13632 breakpoint) based on SALS and SALS_END. If SALS_END.NELTS is not
13633 zero, then B is a ranged breakpoint. Only recreates locations for
13634 FILTER_PSPACE. Locations of other program spaces are left
13638 update_breakpoint_locations (struct breakpoint
*b
,
13639 struct program_space
*filter_pspace
,
13640 gdb::array_view
<const symtab_and_line
> sals
,
13641 gdb::array_view
<const symtab_and_line
> sals_end
)
13643 struct bp_location
*existing_locations
;
13645 if (!sals_end
.empty () && (sals
.size () != 1 || sals_end
.size () != 1))
13647 /* Ranged breakpoints have only one start location and one end
13649 b
->enable_state
= bp_disabled
;
13650 printf_unfiltered (_("Could not reset ranged breakpoint %d: "
13651 "multiple locations found\n"),
13656 /* If there's no new locations, and all existing locations are
13657 pending, don't do anything. This optimizes the common case where
13658 all locations are in the same shared library, that was unloaded.
13659 We'd like to retain the location, so that when the library is
13660 loaded again, we don't loose the enabled/disabled status of the
13661 individual locations. */
13662 if (all_locations_are_pending (b
, filter_pspace
) && sals
.empty ())
13665 existing_locations
= hoist_existing_locations (b
, filter_pspace
);
13667 for (const auto &sal
: sals
)
13669 struct bp_location
*new_loc
;
13671 switch_to_program_space_and_thread (sal
.pspace
);
13673 new_loc
= add_location_to_breakpoint (b
, &sal
);
13675 /* Reparse conditions, they might contain references to the
13677 if (b
->cond_string
!= NULL
)
13681 s
= b
->cond_string
;
13684 new_loc
->cond
= parse_exp_1 (&s
, sal
.pc
,
13685 block_for_pc (sal
.pc
),
13688 CATCH (e
, RETURN_MASK_ERROR
)
13690 warning (_("failed to reevaluate condition "
13691 "for breakpoint %d: %s"),
13692 b
->number
, e
.message
);
13693 new_loc
->enabled
= 0;
13698 if (!sals_end
.empty ())
13700 CORE_ADDR end
= find_breakpoint_range_end (sals_end
[0]);
13702 new_loc
->length
= end
- sals
[0].pc
+ 1;
13706 /* If possible, carry over 'disable' status from existing
13709 struct bp_location
*e
= existing_locations
;
13710 /* If there are multiple breakpoints with the same function name,
13711 e.g. for inline functions, comparing function names won't work.
13712 Instead compare pc addresses; this is just a heuristic as things
13713 may have moved, but in practice it gives the correct answer
13714 often enough until a better solution is found. */
13715 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
13717 for (; e
; e
= e
->next
)
13719 if (!e
->enabled
&& e
->function_name
)
13721 struct bp_location
*l
= b
->loc
;
13722 if (have_ambiguous_names
)
13724 for (; l
; l
= l
->next
)
13725 if (breakpoint_locations_match (e
, l
))
13733 for (; l
; l
= l
->next
)
13734 if (l
->function_name
13735 && strcmp (e
->function_name
, l
->function_name
) == 0)
13745 if (!locations_are_equal (existing_locations
, b
->loc
))
13746 observer_notify_breakpoint_modified (b
);
13749 /* Find the SaL locations corresponding to the given LOCATION.
13750 On return, FOUND will be 1 if any SaL was found, zero otherwise. */
13752 static std::vector
<symtab_and_line
>
13753 location_to_sals (struct breakpoint
*b
, struct event_location
*location
,
13754 struct program_space
*search_pspace
, int *found
)
13756 struct gdb_exception exception
= exception_none
;
13758 gdb_assert (b
->ops
!= NULL
);
13760 std::vector
<symtab_and_line
> sals
;
13764 sals
= b
->ops
->decode_location (b
, location
, search_pspace
);
13766 CATCH (e
, RETURN_MASK_ERROR
)
13768 int not_found_and_ok
= 0;
13772 /* For pending breakpoints, it's expected that parsing will
13773 fail until the right shared library is loaded. User has
13774 already told to create pending breakpoints and don't need
13775 extra messages. If breakpoint is in bp_shlib_disabled
13776 state, then user already saw the message about that
13777 breakpoint being disabled, and don't want to see more
13779 if (e
.error
== NOT_FOUND_ERROR
13780 && (b
->condition_not_parsed
13782 && search_pspace
!= NULL
13783 && b
->loc
->pspace
!= search_pspace
)
13784 || (b
->loc
&& b
->loc
->shlib_disabled
)
13785 || (b
->loc
&& b
->loc
->pspace
->executing_startup
)
13786 || b
->enable_state
== bp_disabled
))
13787 not_found_and_ok
= 1;
13789 if (!not_found_and_ok
)
13791 /* We surely don't want to warn about the same breakpoint
13792 10 times. One solution, implemented here, is disable
13793 the breakpoint on error. Another solution would be to
13794 have separate 'warning emitted' flag. Since this
13795 happens only when a binary has changed, I don't know
13796 which approach is better. */
13797 b
->enable_state
= bp_disabled
;
13798 throw_exception (e
);
13803 if (exception
.reason
== 0 || exception
.error
!= NOT_FOUND_ERROR
)
13805 for (auto &sal
: sals
)
13806 resolve_sal_pc (&sal
);
13807 if (b
->condition_not_parsed
&& b
->extra_string
!= NULL
)
13809 char *cond_string
, *extra_string
;
13812 find_condition_and_thread (b
->extra_string
, sals
[0].pc
,
13813 &cond_string
, &thread
, &task
,
13815 gdb_assert (b
->cond_string
== NULL
);
13817 b
->cond_string
= cond_string
;
13818 b
->thread
= thread
;
13822 xfree (b
->extra_string
);
13823 b
->extra_string
= extra_string
;
13825 b
->condition_not_parsed
= 0;
13828 if (b
->type
== bp_static_tracepoint
&& !strace_marker_p (b
))
13829 sals
[0] = update_static_tracepoint (b
, sals
[0]);
13839 /* The default re_set method, for typical hardware or software
13840 breakpoints. Reevaluate the breakpoint and recreate its
13844 breakpoint_re_set_default (struct breakpoint
*b
)
13846 struct program_space
*filter_pspace
= current_program_space
;
13847 std::vector
<symtab_and_line
> expanded
, expanded_end
;
13850 std::vector
<symtab_and_line
> sals
= location_to_sals (b
, b
->location
.get (),
13851 filter_pspace
, &found
);
13853 expanded
= std::move (sals
);
13855 if (b
->location_range_end
!= NULL
)
13857 std::vector
<symtab_and_line
> sals_end
13858 = location_to_sals (b
, b
->location_range_end
.get (),
13859 filter_pspace
, &found
);
13861 expanded_end
= std::move (sals_end
);
13864 update_breakpoint_locations (b
, filter_pspace
, expanded
, expanded_end
);
13867 /* Default method for creating SALs from an address string. It basically
13868 calls parse_breakpoint_sals. Return 1 for success, zero for failure. */
13871 create_sals_from_location_default (const struct event_location
*location
,
13872 struct linespec_result
*canonical
,
13873 enum bptype type_wanted
)
13875 parse_breakpoint_sals (location
, canonical
);
13878 /* Call create_breakpoints_sal for the given arguments. This is the default
13879 function for the `create_breakpoints_sal' method of
13883 create_breakpoints_sal_default (struct gdbarch
*gdbarch
,
13884 struct linespec_result
*canonical
,
13885 gdb::unique_xmalloc_ptr
<char> cond_string
,
13886 gdb::unique_xmalloc_ptr
<char> extra_string
,
13887 enum bptype type_wanted
,
13888 enum bpdisp disposition
,
13890 int task
, int ignore_count
,
13891 const struct breakpoint_ops
*ops
,
13892 int from_tty
, int enabled
,
13893 int internal
, unsigned flags
)
13895 create_breakpoints_sal (gdbarch
, canonical
,
13896 std::move (cond_string
),
13897 std::move (extra_string
),
13898 type_wanted
, disposition
,
13899 thread
, task
, ignore_count
, ops
, from_tty
,
13900 enabled
, internal
, flags
);
13903 /* Decode the line represented by S by calling decode_line_full. This is the
13904 default function for the `decode_location' method of breakpoint_ops. */
13906 static std::vector
<symtab_and_line
>
13907 decode_location_default (struct breakpoint
*b
,
13908 const struct event_location
*location
,
13909 struct program_space
*search_pspace
)
13911 struct linespec_result canonical
;
13913 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, search_pspace
,
13914 (struct symtab
*) NULL
, 0,
13915 &canonical
, multiple_symbols_all
,
13918 /* We should get 0 or 1 resulting SALs. */
13919 gdb_assert (canonical
.lsals
.size () < 2);
13921 if (!canonical
.lsals
.empty ())
13923 const linespec_sals
&lsal
= canonical
.lsals
[0];
13924 return std::move (lsal
.sals
);
13929 /* Reset a breakpoint. */
13932 breakpoint_re_set_one (breakpoint
*b
)
13934 input_radix
= b
->input_radix
;
13935 set_language (b
->language
);
13937 b
->ops
->re_set (b
);
13940 /* Re-set breakpoint locations for the current program space.
13941 Locations bound to other program spaces are left untouched. */
13944 breakpoint_re_set (void)
13946 struct breakpoint
*b
, *b_tmp
;
13949 scoped_restore_current_language save_language
;
13950 scoped_restore save_input_radix
= make_scoped_restore (&input_radix
);
13951 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
13953 /* Note: we must not try to insert locations until after all
13954 breakpoints have been re-set. Otherwise, e.g., when re-setting
13955 breakpoint 1, we'd insert the locations of breakpoint 2, which
13956 hadn't been re-set yet, and thus may have stale locations. */
13958 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
13962 breakpoint_re_set_one (b
);
13964 CATCH (ex
, RETURN_MASK_ALL
)
13966 exception_fprintf (gdb_stderr
, ex
,
13967 "Error in re-setting breakpoint %d: ",
13973 jit_breakpoint_re_set ();
13976 create_overlay_event_breakpoint ();
13977 create_longjmp_master_breakpoint ();
13978 create_std_terminate_master_breakpoint ();
13979 create_exception_master_breakpoint ();
13981 /* Now we can insert. */
13982 update_global_location_list (UGLL_MAY_INSERT
);
13985 /* Reset the thread number of this breakpoint:
13987 - If the breakpoint is for all threads, leave it as-is.
13988 - Else, reset it to the current thread for inferior_ptid. */
13990 breakpoint_re_set_thread (struct breakpoint
*b
)
13992 if (b
->thread
!= -1)
13994 if (in_thread_list (inferior_ptid
))
13995 b
->thread
= ptid_to_global_thread_id (inferior_ptid
);
13997 /* We're being called after following a fork. The new fork is
13998 selected as current, and unless this was a vfork will have a
13999 different program space from the original thread. Reset that
14001 b
->loc
->pspace
= current_program_space
;
14005 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14006 If from_tty is nonzero, it prints a message to that effect,
14007 which ends with a period (no newline). */
14010 set_ignore_count (int bptnum
, int count
, int from_tty
)
14012 struct breakpoint
*b
;
14017 ALL_BREAKPOINTS (b
)
14018 if (b
->number
== bptnum
)
14020 if (is_tracepoint (b
))
14022 if (from_tty
&& count
!= 0)
14023 printf_filtered (_("Ignore count ignored for tracepoint %d."),
14028 b
->ignore_count
= count
;
14032 printf_filtered (_("Will stop next time "
14033 "breakpoint %d is reached."),
14035 else if (count
== 1)
14036 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
14039 printf_filtered (_("Will ignore next %d "
14040 "crossings of breakpoint %d."),
14043 observer_notify_breakpoint_modified (b
);
14047 error (_("No breakpoint number %d."), bptnum
);
14050 /* Command to set ignore-count of breakpoint N to COUNT. */
14053 ignore_command (const char *args
, int from_tty
)
14055 const char *p
= args
;
14059 error_no_arg (_("a breakpoint number"));
14061 num
= get_number (&p
);
14063 error (_("bad breakpoint number: '%s'"), args
);
14065 error (_("Second argument (specified ignore-count) is missing."));
14067 set_ignore_count (num
,
14068 longest_to_int (value_as_long (parse_and_eval (p
))),
14071 printf_filtered ("\n");
14075 /* Call FUNCTION on each of the breakpoints with numbers in the range
14076 defined by BP_NUM_RANGE (an inclusive range). */
14079 map_breakpoint_number_range (std::pair
<int, int> bp_num_range
,
14080 gdb::function_view
<void (breakpoint
*)> function
)
14082 if (bp_num_range
.first
== 0)
14084 warning (_("bad breakpoint number at or near '%d'"),
14085 bp_num_range
.first
);
14089 struct breakpoint
*b
, *tmp
;
14091 for (int i
= bp_num_range
.first
; i
<= bp_num_range
.second
; i
++)
14093 bool match
= false;
14095 ALL_BREAKPOINTS_SAFE (b
, tmp
)
14096 if (b
->number
== i
)
14103 printf_unfiltered (_("No breakpoint number %d.\n"), i
);
14108 /* Call FUNCTION on each of the breakpoints whose numbers are given in
14112 map_breakpoint_numbers (const char *args
,
14113 gdb::function_view
<void (breakpoint
*)> function
)
14115 if (args
== NULL
|| *args
== '\0')
14116 error_no_arg (_("one or more breakpoint numbers"));
14118 number_or_range_parser
parser (args
);
14120 while (!parser
.finished ())
14122 int num
= parser
.get_number ();
14123 map_breakpoint_number_range (std::make_pair (num
, num
), function
);
14127 /* Return the breakpoint location structure corresponding to the
14128 BP_NUM and LOC_NUM values. */
14130 static struct bp_location
*
14131 find_location_by_number (int bp_num
, int loc_num
)
14133 struct breakpoint
*b
;
14135 ALL_BREAKPOINTS (b
)
14136 if (b
->number
== bp_num
)
14141 if (!b
|| b
->number
!= bp_num
)
14142 error (_("Bad breakpoint number '%d'"), bp_num
);
14145 error (_("Bad breakpoint location number '%d'"), loc_num
);
14148 for (bp_location
*loc
= b
->loc
; loc
!= NULL
; loc
= loc
->next
)
14149 if (++n
== loc_num
)
14152 error (_("Bad breakpoint location number '%d'"), loc_num
);
14155 /* Modes of operation for extract_bp_num. */
14156 enum class extract_bp_kind
14158 /* Extracting a breakpoint number. */
14161 /* Extracting a location number. */
14165 /* Extract a breakpoint or location number (as determined by KIND)
14166 from the string starting at START. TRAILER is a character which
14167 can be found after the number. If you don't want a trailer, use
14168 '\0'. If END_OUT is not NULL, it is set to point after the parsed
14169 string. This always returns a positive integer. */
14172 extract_bp_num (extract_bp_kind kind
, const char *start
,
14173 int trailer
, const char **end_out
= NULL
)
14175 const char *end
= start
;
14176 int num
= get_number_trailer (&end
, trailer
);
14178 error (kind
== extract_bp_kind::bp
14179 ? _("Negative breakpoint number '%.*s'")
14180 : _("Negative breakpoint location number '%.*s'"),
14181 int (end
- start
), start
);
14183 error (kind
== extract_bp_kind::bp
14184 ? _("Bad breakpoint number '%.*s'")
14185 : _("Bad breakpoint location number '%.*s'"),
14186 int (end
- start
), start
);
14188 if (end_out
!= NULL
)
14193 /* Extract a breakpoint or location range (as determined by KIND) in
14194 the form NUM1-NUM2 stored at &ARG[arg_offset]. Returns a std::pair
14195 representing the (inclusive) range. The returned pair's elements
14196 are always positive integers. */
14198 static std::pair
<int, int>
14199 extract_bp_or_bp_range (extract_bp_kind kind
,
14200 const std::string
&arg
,
14201 std::string::size_type arg_offset
)
14203 std::pair
<int, int> range
;
14204 const char *bp_loc
= &arg
[arg_offset
];
14205 std::string::size_type dash
= arg
.find ('-', arg_offset
);
14206 if (dash
!= std::string::npos
)
14208 /* bp_loc is a range (x-z). */
14209 if (arg
.length () == dash
+ 1)
14210 error (kind
== extract_bp_kind::bp
14211 ? _("Bad breakpoint number at or near: '%s'")
14212 : _("Bad breakpoint location number at or near: '%s'"),
14216 const char *start_first
= bp_loc
;
14217 const char *start_second
= &arg
[dash
+ 1];
14218 range
.first
= extract_bp_num (kind
, start_first
, '-');
14219 range
.second
= extract_bp_num (kind
, start_second
, '\0', &end
);
14221 if (range
.first
> range
.second
)
14222 error (kind
== extract_bp_kind::bp
14223 ? _("Inverted breakpoint range at '%.*s'")
14224 : _("Inverted breakpoint location range at '%.*s'"),
14225 int (end
- start_first
), start_first
);
14229 /* bp_loc is a single value. */
14230 range
.first
= extract_bp_num (kind
, bp_loc
, '\0');
14231 range
.second
= range
.first
;
14236 /* Extract the breakpoint/location range specified by ARG. Returns
14237 the breakpoint range in BP_NUM_RANGE, and the location range in
14240 ARG may be in any of the following forms:
14242 x where 'x' is a breakpoint number.
14243 x-y where 'x' and 'y' specify a breakpoint numbers range.
14244 x.y where 'x' is a breakpoint number and 'y' a location number.
14245 x.y-z where 'x' is a breakpoint number and 'y' and 'z' specify a
14246 location number range.
14250 extract_bp_number_and_location (const std::string
&arg
,
14251 std::pair
<int, int> &bp_num_range
,
14252 std::pair
<int, int> &bp_loc_range
)
14254 std::string::size_type dot
= arg
.find ('.');
14256 if (dot
!= std::string::npos
)
14258 /* Handle 'x.y' and 'x.y-z' cases. */
14260 if (arg
.length () == dot
+ 1 || dot
== 0)
14261 error (_("Bad breakpoint number at or near: '%s'"), arg
.c_str ());
14264 = extract_bp_num (extract_bp_kind::bp
, arg
.c_str (), '.');
14265 bp_num_range
.second
= bp_num_range
.first
;
14267 bp_loc_range
= extract_bp_or_bp_range (extract_bp_kind::loc
,
14272 /* Handle x and x-y cases. */
14274 bp_num_range
= extract_bp_or_bp_range (extract_bp_kind::bp
, arg
, 0);
14275 bp_loc_range
.first
= 0;
14276 bp_loc_range
.second
= 0;
14280 /* Enable or disable a breakpoint location BP_NUM.LOC_NUM. ENABLE
14281 specifies whether to enable or disable. */
14284 enable_disable_bp_num_loc (int bp_num
, int loc_num
, bool enable
)
14286 struct bp_location
*loc
= find_location_by_number (bp_num
, loc_num
);
14289 if (loc
->enabled
!= enable
)
14291 loc
->enabled
= enable
;
14292 mark_breakpoint_location_modified (loc
);
14294 if (target_supports_enable_disable_tracepoint ()
14295 && current_trace_status ()->running
&& loc
->owner
14296 && is_tracepoint (loc
->owner
))
14297 target_disable_tracepoint (loc
);
14299 update_global_location_list (UGLL_DONT_INSERT
);
14302 /* Enable or disable a range of breakpoint locations. BP_NUM is the
14303 number of the breakpoint, and BP_LOC_RANGE specifies the
14304 (inclusive) range of location numbers of that breakpoint to
14305 enable/disable. ENABLE specifies whether to enable or disable the
14309 enable_disable_breakpoint_location_range (int bp_num
,
14310 std::pair
<int, int> &bp_loc_range
,
14313 for (int i
= bp_loc_range
.first
; i
<= bp_loc_range
.second
; i
++)
14314 enable_disable_bp_num_loc (bp_num
, i
, enable
);
14317 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14318 If from_tty is nonzero, it prints a message to that effect,
14319 which ends with a period (no newline). */
14322 disable_breakpoint (struct breakpoint
*bpt
)
14324 /* Never disable a watchpoint scope breakpoint; we want to
14325 hit them when we leave scope so we can delete both the
14326 watchpoint and its scope breakpoint at that time. */
14327 if (bpt
->type
== bp_watchpoint_scope
)
14330 bpt
->enable_state
= bp_disabled
;
14332 /* Mark breakpoint locations modified. */
14333 mark_breakpoint_modified (bpt
);
14335 if (target_supports_enable_disable_tracepoint ()
14336 && current_trace_status ()->running
&& is_tracepoint (bpt
))
14338 struct bp_location
*location
;
14340 for (location
= bpt
->loc
; location
; location
= location
->next
)
14341 target_disable_tracepoint (location
);
14344 update_global_location_list (UGLL_DONT_INSERT
);
14346 observer_notify_breakpoint_modified (bpt
);
14349 /* Enable or disable the breakpoint(s) or breakpoint location(s)
14350 specified in ARGS. ARGS may be in any of the formats handled by
14351 extract_bp_number_and_location. ENABLE specifies whether to enable
14352 or disable the breakpoints/locations. */
14355 enable_disable_command (const char *args
, int from_tty
, bool enable
)
14359 struct breakpoint
*bpt
;
14361 ALL_BREAKPOINTS (bpt
)
14362 if (user_breakpoint_p (bpt
))
14365 enable_breakpoint (bpt
);
14367 disable_breakpoint (bpt
);
14372 std::string num
= extract_arg (&args
);
14374 while (!num
.empty ())
14376 std::pair
<int, int> bp_num_range
, bp_loc_range
;
14378 extract_bp_number_and_location (num
, bp_num_range
, bp_loc_range
);
14380 if (bp_loc_range
.first
== bp_loc_range
.second
14381 && bp_loc_range
.first
== 0)
14383 /* Handle breakpoint ids with formats 'x' or 'x-z'. */
14384 map_breakpoint_number_range (bp_num_range
,
14386 ? enable_breakpoint
14387 : disable_breakpoint
);
14391 /* Handle breakpoint ids with formats 'x.y' or
14393 enable_disable_breakpoint_location_range
14394 (bp_num_range
.first
, bp_loc_range
, enable
);
14396 num
= extract_arg (&args
);
14401 /* The disable command disables the specified breakpoints/locations
14402 (or all defined breakpoints) so they're no longer effective in
14403 stopping the inferior. ARGS may be in any of the forms defined in
14404 extract_bp_number_and_location. */
14407 disable_command (const char *args
, int from_tty
)
14409 enable_disable_command (args
, from_tty
, false);
14413 enable_breakpoint_disp (struct breakpoint
*bpt
, enum bpdisp disposition
,
14416 int target_resources_ok
;
14418 if (bpt
->type
== bp_hardware_breakpoint
)
14421 i
= hw_breakpoint_used_count ();
14422 target_resources_ok
=
14423 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
14425 if (target_resources_ok
== 0)
14426 error (_("No hardware breakpoint support in the target."));
14427 else if (target_resources_ok
< 0)
14428 error (_("Hardware breakpoints used exceeds limit."));
14431 if (is_watchpoint (bpt
))
14433 /* Initialize it just to avoid a GCC false warning. */
14434 enum enable_state orig_enable_state
= bp_disabled
;
14438 struct watchpoint
*w
= (struct watchpoint
*) bpt
;
14440 orig_enable_state
= bpt
->enable_state
;
14441 bpt
->enable_state
= bp_enabled
;
14442 update_watchpoint (w
, 1 /* reparse */);
14444 CATCH (e
, RETURN_MASK_ALL
)
14446 bpt
->enable_state
= orig_enable_state
;
14447 exception_fprintf (gdb_stderr
, e
, _("Cannot enable watchpoint %d: "),
14454 bpt
->enable_state
= bp_enabled
;
14456 /* Mark breakpoint locations modified. */
14457 mark_breakpoint_modified (bpt
);
14459 if (target_supports_enable_disable_tracepoint ()
14460 && current_trace_status ()->running
&& is_tracepoint (bpt
))
14462 struct bp_location
*location
;
14464 for (location
= bpt
->loc
; location
; location
= location
->next
)
14465 target_enable_tracepoint (location
);
14468 bpt
->disposition
= disposition
;
14469 bpt
->enable_count
= count
;
14470 update_global_location_list (UGLL_MAY_INSERT
);
14472 observer_notify_breakpoint_modified (bpt
);
14477 enable_breakpoint (struct breakpoint
*bpt
)
14479 enable_breakpoint_disp (bpt
, bpt
->disposition
, 0);
14482 /* The enable command enables the specified breakpoints/locations (or
14483 all defined breakpoints) so they once again become (or continue to
14484 be) effective in stopping the inferior. ARGS may be in any of the
14485 forms defined in extract_bp_number_and_location. */
14488 enable_command (const char *args
, int from_tty
)
14490 enable_disable_command (args
, from_tty
, true);
14494 enable_once_command (const char *args
, int from_tty
)
14496 map_breakpoint_numbers
14497 (args
, [&] (breakpoint
*b
)
14499 iterate_over_related_breakpoints
14500 (b
, [&] (breakpoint
*bpt
)
14502 enable_breakpoint_disp (bpt
, disp_disable
, 1);
14508 enable_count_command (const char *args
, int from_tty
)
14513 error_no_arg (_("hit count"));
14515 count
= get_number (&args
);
14517 map_breakpoint_numbers
14518 (args
, [&] (breakpoint
*b
)
14520 iterate_over_related_breakpoints
14521 (b
, [&] (breakpoint
*bpt
)
14523 enable_breakpoint_disp (bpt
, disp_disable
, count
);
14529 enable_delete_command (const char *args
, int from_tty
)
14531 map_breakpoint_numbers
14532 (args
, [&] (breakpoint
*b
)
14534 iterate_over_related_breakpoints
14535 (b
, [&] (breakpoint
*bpt
)
14537 enable_breakpoint_disp (bpt
, disp_del
, 1);
14543 set_breakpoint_cmd (const char *args
, int from_tty
)
14548 show_breakpoint_cmd (const char *args
, int from_tty
)
14552 /* Invalidate last known value of any hardware watchpoint if
14553 the memory which that value represents has been written to by
14557 invalidate_bp_value_on_memory_change (struct inferior
*inferior
,
14558 CORE_ADDR addr
, ssize_t len
,
14559 const bfd_byte
*data
)
14561 struct breakpoint
*bp
;
14563 ALL_BREAKPOINTS (bp
)
14564 if (bp
->enable_state
== bp_enabled
14565 && bp
->type
== bp_hardware_watchpoint
)
14567 struct watchpoint
*wp
= (struct watchpoint
*) bp
;
14569 if (wp
->val_valid
&& wp
->val
)
14571 struct bp_location
*loc
;
14573 for (loc
= bp
->loc
; loc
!= NULL
; loc
= loc
->next
)
14574 if (loc
->loc_type
== bp_loc_hardware_watchpoint
14575 && loc
->address
+ loc
->length
> addr
14576 && addr
+ len
> loc
->address
)
14578 value_free (wp
->val
);
14586 /* Create and insert a breakpoint for software single step. */
14589 insert_single_step_breakpoint (struct gdbarch
*gdbarch
,
14590 const address_space
*aspace
,
14593 struct thread_info
*tp
= inferior_thread ();
14594 struct symtab_and_line sal
;
14595 CORE_ADDR pc
= next_pc
;
14597 if (tp
->control
.single_step_breakpoints
== NULL
)
14599 tp
->control
.single_step_breakpoints
14600 = new_single_step_breakpoint (tp
->global_num
, gdbarch
);
14603 sal
= find_pc_line (pc
, 0);
14605 sal
.section
= find_pc_overlay (pc
);
14606 sal
.explicit_pc
= 1;
14607 add_location_to_breakpoint (tp
->control
.single_step_breakpoints
, &sal
);
14609 update_global_location_list (UGLL_INSERT
);
14612 /* Insert single step breakpoints according to the current state. */
14615 insert_single_step_breakpoints (struct gdbarch
*gdbarch
)
14617 struct regcache
*regcache
= get_current_regcache ();
14618 std::vector
<CORE_ADDR
> next_pcs
;
14620 next_pcs
= gdbarch_software_single_step (gdbarch
, regcache
);
14622 if (!next_pcs
.empty ())
14624 struct frame_info
*frame
= get_current_frame ();
14625 const address_space
*aspace
= get_frame_address_space (frame
);
14627 for (CORE_ADDR pc
: next_pcs
)
14628 insert_single_step_breakpoint (gdbarch
, aspace
, pc
);
14636 /* See breakpoint.h. */
14639 breakpoint_has_location_inserted_here (struct breakpoint
*bp
,
14640 const address_space
*aspace
,
14643 struct bp_location
*loc
;
14645 for (loc
= bp
->loc
; loc
!= NULL
; loc
= loc
->next
)
14647 && breakpoint_location_address_match (loc
, aspace
, pc
))
14653 /* Check whether a software single-step breakpoint is inserted at
14657 single_step_breakpoint_inserted_here_p (const address_space
*aspace
,
14660 struct breakpoint
*bpt
;
14662 ALL_BREAKPOINTS (bpt
)
14664 if (bpt
->type
== bp_single_step
14665 && breakpoint_has_location_inserted_here (bpt
, aspace
, pc
))
14671 /* Tracepoint-specific operations. */
14673 /* Set tracepoint count to NUM. */
14675 set_tracepoint_count (int num
)
14677 tracepoint_count
= num
;
14678 set_internalvar_integer (lookup_internalvar ("tpnum"), num
);
14682 trace_command (const char *arg
, int from_tty
)
14684 struct breakpoint_ops
*ops
;
14686 event_location_up location
= string_to_event_location (&arg
,
14688 if (location
!= NULL
14689 && event_location_type (location
.get ()) == PROBE_LOCATION
)
14690 ops
= &tracepoint_probe_breakpoint_ops
;
14692 ops
= &tracepoint_breakpoint_ops
;
14694 create_breakpoint (get_current_arch (),
14696 NULL
, 0, arg
, 1 /* parse arg */,
14698 bp_tracepoint
/* type_wanted */,
14699 0 /* Ignore count */,
14700 pending_break_support
,
14704 0 /* internal */, 0);
14708 ftrace_command (const char *arg
, int from_tty
)
14710 event_location_up location
= string_to_event_location (&arg
,
14712 create_breakpoint (get_current_arch (),
14714 NULL
, 0, arg
, 1 /* parse arg */,
14716 bp_fast_tracepoint
/* type_wanted */,
14717 0 /* Ignore count */,
14718 pending_break_support
,
14719 &tracepoint_breakpoint_ops
,
14722 0 /* internal */, 0);
14725 /* strace command implementation. Creates a static tracepoint. */
14728 strace_command (const char *arg
, int from_tty
)
14730 struct breakpoint_ops
*ops
;
14731 event_location_up location
;
14733 /* Decide if we are dealing with a static tracepoint marker (`-m'),
14734 or with a normal static tracepoint. */
14735 if (arg
&& startswith (arg
, "-m") && isspace (arg
[2]))
14737 ops
= &strace_marker_breakpoint_ops
;
14738 location
= new_linespec_location (&arg
, symbol_name_match_type::FULL
);
14742 ops
= &tracepoint_breakpoint_ops
;
14743 location
= string_to_event_location (&arg
, current_language
);
14746 create_breakpoint (get_current_arch (),
14748 NULL
, 0, arg
, 1 /* parse arg */,
14750 bp_static_tracepoint
/* type_wanted */,
14751 0 /* Ignore count */,
14752 pending_break_support
,
14756 0 /* internal */, 0);
14759 /* Set up a fake reader function that gets command lines from a linked
14760 list that was acquired during tracepoint uploading. */
14762 static struct uploaded_tp
*this_utp
;
14763 static int next_cmd
;
14766 read_uploaded_action (void)
14770 VEC_iterate (char_ptr
, this_utp
->cmd_strings
, next_cmd
, rslt
);
14777 /* Given information about a tracepoint as recorded on a target (which
14778 can be either a live system or a trace file), attempt to create an
14779 equivalent GDB tracepoint. This is not a reliable process, since
14780 the target does not necessarily have all the information used when
14781 the tracepoint was originally defined. */
14783 struct tracepoint
*
14784 create_tracepoint_from_upload (struct uploaded_tp
*utp
)
14786 const char *addr_str
;
14787 char small_buf
[100];
14788 struct tracepoint
*tp
;
14790 if (utp
->at_string
)
14791 addr_str
= utp
->at_string
;
14794 /* In the absence of a source location, fall back to raw
14795 address. Since there is no way to confirm that the address
14796 means the same thing as when the trace was started, warn the
14798 warning (_("Uploaded tracepoint %d has no "
14799 "source location, using raw address"),
14801 xsnprintf (small_buf
, sizeof (small_buf
), "*%s", hex_string (utp
->addr
));
14802 addr_str
= small_buf
;
14805 /* There's not much we can do with a sequence of bytecodes. */
14806 if (utp
->cond
&& !utp
->cond_string
)
14807 warning (_("Uploaded tracepoint %d condition "
14808 "has no source form, ignoring it"),
14811 event_location_up location
= string_to_event_location (&addr_str
,
14813 if (!create_breakpoint (get_current_arch (),
14815 utp
->cond_string
, -1, addr_str
,
14816 0 /* parse cond/thread */,
14818 utp
->type
/* type_wanted */,
14819 0 /* Ignore count */,
14820 pending_break_support
,
14821 &tracepoint_breakpoint_ops
,
14823 utp
->enabled
/* enabled */,
14825 CREATE_BREAKPOINT_FLAGS_INSERTED
))
14828 /* Get the tracepoint we just created. */
14829 tp
= get_tracepoint (tracepoint_count
);
14830 gdb_assert (tp
!= NULL
);
14834 xsnprintf (small_buf
, sizeof (small_buf
), "%d %d", utp
->pass
,
14837 trace_pass_command (small_buf
, 0);
14840 /* If we have uploaded versions of the original commands, set up a
14841 special-purpose "reader" function and call the usual command line
14842 reader, then pass the result to the breakpoint command-setting
14844 if (!VEC_empty (char_ptr
, utp
->cmd_strings
))
14846 command_line_up cmd_list
;
14851 cmd_list
= read_command_lines_1 (read_uploaded_action
, 1, NULL
, NULL
);
14853 breakpoint_set_commands (tp
, std::move (cmd_list
));
14855 else if (!VEC_empty (char_ptr
, utp
->actions
)
14856 || !VEC_empty (char_ptr
, utp
->step_actions
))
14857 warning (_("Uploaded tracepoint %d actions "
14858 "have no source form, ignoring them"),
14861 /* Copy any status information that might be available. */
14862 tp
->hit_count
= utp
->hit_count
;
14863 tp
->traceframe_usage
= utp
->traceframe_usage
;
14868 /* Print information on tracepoint number TPNUM_EXP, or all if
14872 info_tracepoints_command (const char *args
, int from_tty
)
14874 struct ui_out
*uiout
= current_uiout
;
14877 num_printed
= breakpoint_1 (args
, 0, is_tracepoint
);
14879 if (num_printed
== 0)
14881 if (args
== NULL
|| *args
== '\0')
14882 uiout
->message ("No tracepoints.\n");
14884 uiout
->message ("No tracepoint matching '%s'.\n", args
);
14887 default_collect_info ();
14890 /* The 'enable trace' command enables tracepoints.
14891 Not supported by all targets. */
14893 enable_trace_command (const char *args
, int from_tty
)
14895 enable_command (args
, from_tty
);
14898 /* The 'disable trace' command disables tracepoints.
14899 Not supported by all targets. */
14901 disable_trace_command (const char *args
, int from_tty
)
14903 disable_command (args
, from_tty
);
14906 /* Remove a tracepoint (or all if no argument). */
14908 delete_trace_command (const char *arg
, int from_tty
)
14910 struct breakpoint
*b
, *b_tmp
;
14916 int breaks_to_delete
= 0;
14918 /* Delete all breakpoints if no argument.
14919 Do not delete internal or call-dummy breakpoints, these
14920 have to be deleted with an explicit breakpoint number
14922 ALL_TRACEPOINTS (b
)
14923 if (is_tracepoint (b
) && user_breakpoint_p (b
))
14925 breaks_to_delete
= 1;
14929 /* Ask user only if there are some breakpoints to delete. */
14931 || (breaks_to_delete
&& query (_("Delete all tracepoints? "))))
14933 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
14934 if (is_tracepoint (b
) && user_breakpoint_p (b
))
14935 delete_breakpoint (b
);
14939 map_breakpoint_numbers
14940 (arg
, [&] (breakpoint
*b
)
14942 iterate_over_related_breakpoints (b
, delete_breakpoint
);
14946 /* Helper function for trace_pass_command. */
14949 trace_pass_set_count (struct tracepoint
*tp
, int count
, int from_tty
)
14951 tp
->pass_count
= count
;
14952 observer_notify_breakpoint_modified (tp
);
14954 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
14955 tp
->number
, count
);
14958 /* Set passcount for tracepoint.
14960 First command argument is passcount, second is tracepoint number.
14961 If tracepoint number omitted, apply to most recently defined.
14962 Also accepts special argument "all". */
14965 trace_pass_command (const char *args
, int from_tty
)
14967 struct tracepoint
*t1
;
14970 if (args
== 0 || *args
== 0)
14971 error (_("passcount command requires an "
14972 "argument (count + optional TP num)"));
14974 count
= strtoulst (args
, &args
, 10); /* Count comes first, then TP num. */
14976 args
= skip_spaces (args
);
14977 if (*args
&& strncasecmp (args
, "all", 3) == 0)
14979 struct breakpoint
*b
;
14981 args
+= 3; /* Skip special argument "all". */
14983 error (_("Junk at end of arguments."));
14985 ALL_TRACEPOINTS (b
)
14987 t1
= (struct tracepoint
*) b
;
14988 trace_pass_set_count (t1
, count
, from_tty
);
14991 else if (*args
== '\0')
14993 t1
= get_tracepoint_by_number (&args
, NULL
);
14995 trace_pass_set_count (t1
, count
, from_tty
);
14999 number_or_range_parser
parser (args
);
15000 while (!parser
.finished ())
15002 t1
= get_tracepoint_by_number (&args
, &parser
);
15004 trace_pass_set_count (t1
, count
, from_tty
);
15009 struct tracepoint
*
15010 get_tracepoint (int num
)
15012 struct breakpoint
*t
;
15014 ALL_TRACEPOINTS (t
)
15015 if (t
->number
== num
)
15016 return (struct tracepoint
*) t
;
15021 /* Find the tracepoint with the given target-side number (which may be
15022 different from the tracepoint number after disconnecting and
15025 struct tracepoint
*
15026 get_tracepoint_by_number_on_target (int num
)
15028 struct breakpoint
*b
;
15030 ALL_TRACEPOINTS (b
)
15032 struct tracepoint
*t
= (struct tracepoint
*) b
;
15034 if (t
->number_on_target
== num
)
15041 /* Utility: parse a tracepoint number and look it up in the list.
15042 If STATE is not NULL, use, get_number_or_range_state and ignore ARG.
15043 If the argument is missing, the most recent tracepoint
15044 (tracepoint_count) is returned. */
15046 struct tracepoint
*
15047 get_tracepoint_by_number (const char **arg
,
15048 number_or_range_parser
*parser
)
15050 struct breakpoint
*t
;
15052 const char *instring
= arg
== NULL
? NULL
: *arg
;
15054 if (parser
!= NULL
)
15056 gdb_assert (!parser
->finished ());
15057 tpnum
= parser
->get_number ();
15059 else if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
15060 tpnum
= tracepoint_count
;
15062 tpnum
= get_number (arg
);
15066 if (instring
&& *instring
)
15067 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
15070 printf_filtered (_("No previous tracepoint\n"));
15074 ALL_TRACEPOINTS (t
)
15075 if (t
->number
== tpnum
)
15077 return (struct tracepoint
*) t
;
15080 printf_unfiltered ("No tracepoint number %d.\n", tpnum
);
15085 print_recreate_thread (struct breakpoint
*b
, struct ui_file
*fp
)
15087 if (b
->thread
!= -1)
15088 fprintf_unfiltered (fp
, " thread %d", b
->thread
);
15091 fprintf_unfiltered (fp
, " task %d", b
->task
);
15093 fprintf_unfiltered (fp
, "\n");
15096 /* Save information on user settable breakpoints (watchpoints, etc) to
15097 a new script file named FILENAME. If FILTER is non-NULL, call it
15098 on each breakpoint and only include the ones for which it returns
15102 save_breakpoints (const char *filename
, int from_tty
,
15103 int (*filter
) (const struct breakpoint
*))
15105 struct breakpoint
*tp
;
15107 int extra_trace_bits
= 0;
15109 if (filename
== 0 || *filename
== 0)
15110 error (_("Argument required (file name in which to save)"));
15112 /* See if we have anything to save. */
15113 ALL_BREAKPOINTS (tp
)
15115 /* Skip internal and momentary breakpoints. */
15116 if (!user_breakpoint_p (tp
))
15119 /* If we have a filter, only save the breakpoints it accepts. */
15120 if (filter
&& !filter (tp
))
15125 if (is_tracepoint (tp
))
15127 extra_trace_bits
= 1;
15129 /* We can stop searching. */
15136 warning (_("Nothing to save."));
15140 gdb::unique_xmalloc_ptr
<char> expanded_filename (tilde_expand (filename
));
15144 if (!fp
.open (expanded_filename
.get (), "w"))
15145 error (_("Unable to open file '%s' for saving (%s)"),
15146 expanded_filename
.get (), safe_strerror (errno
));
15148 if (extra_trace_bits
)
15149 save_trace_state_variables (&fp
);
15151 ALL_BREAKPOINTS (tp
)
15153 /* Skip internal and momentary breakpoints. */
15154 if (!user_breakpoint_p (tp
))
15157 /* If we have a filter, only save the breakpoints it accepts. */
15158 if (filter
&& !filter (tp
))
15161 tp
->ops
->print_recreate (tp
, &fp
);
15163 /* Note, we can't rely on tp->number for anything, as we can't
15164 assume the recreated breakpoint numbers will match. Use $bpnum
15167 if (tp
->cond_string
)
15168 fp
.printf (" condition $bpnum %s\n", tp
->cond_string
);
15170 if (tp
->ignore_count
)
15171 fp
.printf (" ignore $bpnum %d\n", tp
->ignore_count
);
15173 if (tp
->type
!= bp_dprintf
&& tp
->commands
)
15175 fp
.puts (" commands\n");
15177 current_uiout
->redirect (&fp
);
15180 print_command_lines (current_uiout
, tp
->commands
.get (), 2);
15182 CATCH (ex
, RETURN_MASK_ALL
)
15184 current_uiout
->redirect (NULL
);
15185 throw_exception (ex
);
15189 current_uiout
->redirect (NULL
);
15190 fp
.puts (" end\n");
15193 if (tp
->enable_state
== bp_disabled
)
15194 fp
.puts ("disable $bpnum\n");
15196 /* If this is a multi-location breakpoint, check if the locations
15197 should be individually disabled. Watchpoint locations are
15198 special, and not user visible. */
15199 if (!is_watchpoint (tp
) && tp
->loc
&& tp
->loc
->next
)
15201 struct bp_location
*loc
;
15204 for (loc
= tp
->loc
; loc
!= NULL
; loc
= loc
->next
, n
++)
15206 fp
.printf ("disable $bpnum.%d\n", n
);
15210 if (extra_trace_bits
&& *default_collect
)
15211 fp
.printf ("set default-collect %s\n", default_collect
);
15214 printf_filtered (_("Saved to file '%s'.\n"), expanded_filename
.get ());
15217 /* The `save breakpoints' command. */
15220 save_breakpoints_command (const char *args
, int from_tty
)
15222 save_breakpoints (args
, from_tty
, NULL
);
15225 /* The `save tracepoints' command. */
15228 save_tracepoints_command (const char *args
, int from_tty
)
15230 save_breakpoints (args
, from_tty
, is_tracepoint
);
15233 /* Create a vector of all tracepoints. */
15235 VEC(breakpoint_p
) *
15236 all_tracepoints (void)
15238 VEC(breakpoint_p
) *tp_vec
= 0;
15239 struct breakpoint
*tp
;
15241 ALL_TRACEPOINTS (tp
)
15243 VEC_safe_push (breakpoint_p
, tp_vec
, tp
);
15250 /* This help string is used to consolidate all the help string for specifying
15251 locations used by several commands. */
15253 #define LOCATION_HELP_STRING \
15254 "Linespecs are colon-separated lists of location parameters, such as\n\
15255 source filename, function name, label name, and line number.\n\
15256 Example: To specify the start of a label named \"the_top\" in the\n\
15257 function \"fact\" in the file \"factorial.c\", use\n\
15258 \"factorial.c:fact:the_top\".\n\
15260 Address locations begin with \"*\" and specify an exact address in the\n\
15261 program. Example: To specify the fourth byte past the start function\n\
15262 \"main\", use \"*main + 4\".\n\
15264 Explicit locations are similar to linespecs but use an option/argument\n\
15265 syntax to specify location parameters.\n\
15266 Example: To specify the start of the label named \"the_top\" in the\n\
15267 function \"fact\" in the file \"factorial.c\", use \"-source factorial.c\n\
15268 -function fact -label the_top\".\n\
15270 By default, a specified function is matched against the program's\n\
15271 functions in all scopes. For C++, this means in all namespaces and\n\
15272 classes. For Ada, this means in all packages. E.g., in C++,\n\
15273 \"func()\" matches \"A::func()\", \"A::B::func()\", etc. The\n\
15274 \"-qualified\" flag overrides this behavior, making GDB interpret the\n\
15275 specified name as a complete fully-qualified name instead.\n"
15277 /* This help string is used for the break, hbreak, tbreak and thbreak
15278 commands. It is defined as a macro to prevent duplication.
15279 COMMAND should be a string constant containing the name of the
15282 #define BREAK_ARGS_HELP(command) \
15283 command" [PROBE_MODIFIER] [LOCATION] [thread THREADNUM] [if CONDITION]\n\
15284 PROBE_MODIFIER shall be present if the command is to be placed in a\n\
15285 probe point. Accepted values are `-probe' (for a generic, automatically\n\
15286 guessed probe type), `-probe-stap' (for a SystemTap probe) or \n\
15287 `-probe-dtrace' (for a DTrace probe).\n\
15288 LOCATION may be a linespec, address, or explicit location as described\n\
15291 With no LOCATION, uses current execution address of the selected\n\
15292 stack frame. This is useful for breaking on return to a stack frame.\n\
15294 THREADNUM is the number from \"info threads\".\n\
15295 CONDITION is a boolean expression.\n\
15296 \n" LOCATION_HELP_STRING "\n\
15297 Multiple breakpoints at one place are permitted, and useful if their\n\
15298 conditions are different.\n\
15300 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
15302 /* List of subcommands for "catch". */
15303 static struct cmd_list_element
*catch_cmdlist
;
15305 /* List of subcommands for "tcatch". */
15306 static struct cmd_list_element
*tcatch_cmdlist
;
15309 add_catch_command (const char *name
, const char *docstring
,
15310 cmd_const_sfunc_ftype
*sfunc
,
15311 completer_ftype
*completer
,
15312 void *user_data_catch
,
15313 void *user_data_tcatch
)
15315 struct cmd_list_element
*command
;
15317 command
= add_cmd (name
, class_breakpoint
, docstring
,
15319 set_cmd_sfunc (command
, sfunc
);
15320 set_cmd_context (command
, user_data_catch
);
15321 set_cmd_completer (command
, completer
);
15323 command
= add_cmd (name
, class_breakpoint
, docstring
,
15325 set_cmd_sfunc (command
, sfunc
);
15326 set_cmd_context (command
, user_data_tcatch
);
15327 set_cmd_completer (command
, completer
);
15331 save_command (const char *arg
, int from_tty
)
15333 printf_unfiltered (_("\"save\" must be followed by "
15334 "the name of a save subcommand.\n"));
15335 help_list (save_cmdlist
, "save ", all_commands
, gdb_stdout
);
15338 struct breakpoint
*
15339 iterate_over_breakpoints (int (*callback
) (struct breakpoint
*, void *),
15342 struct breakpoint
*b
, *b_tmp
;
15344 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
15346 if ((*callback
) (b
, data
))
15353 /* Zero if any of the breakpoint's locations could be a location where
15354 functions have been inlined, nonzero otherwise. */
15357 is_non_inline_function (struct breakpoint
*b
)
15359 /* The shared library event breakpoint is set on the address of a
15360 non-inline function. */
15361 if (b
->type
== bp_shlib_event
)
15367 /* Nonzero if the specified PC cannot be a location where functions
15368 have been inlined. */
15371 pc_at_non_inline_function (const address_space
*aspace
, CORE_ADDR pc
,
15372 const struct target_waitstatus
*ws
)
15374 struct breakpoint
*b
;
15375 struct bp_location
*bl
;
15377 ALL_BREAKPOINTS (b
)
15379 if (!is_non_inline_function (b
))
15382 for (bl
= b
->loc
; bl
!= NULL
; bl
= bl
->next
)
15384 if (!bl
->shlib_disabled
15385 && bpstat_check_location (bl
, aspace
, pc
, ws
))
15393 /* Remove any references to OBJFILE which is going to be freed. */
15396 breakpoint_free_objfile (struct objfile
*objfile
)
15398 struct bp_location
**locp
, *loc
;
15400 ALL_BP_LOCATIONS (loc
, locp
)
15401 if (loc
->symtab
!= NULL
&& SYMTAB_OBJFILE (loc
->symtab
) == objfile
)
15402 loc
->symtab
= NULL
;
15406 initialize_breakpoint_ops (void)
15408 static int initialized
= 0;
15410 struct breakpoint_ops
*ops
;
15416 /* The breakpoint_ops structure to be inherit by all kinds of
15417 breakpoints (real breakpoints, i.e., user "break" breakpoints,
15418 internal and momentary breakpoints, etc.). */
15419 ops
= &bkpt_base_breakpoint_ops
;
15420 *ops
= base_breakpoint_ops
;
15421 ops
->re_set
= bkpt_re_set
;
15422 ops
->insert_location
= bkpt_insert_location
;
15423 ops
->remove_location
= bkpt_remove_location
;
15424 ops
->breakpoint_hit
= bkpt_breakpoint_hit
;
15425 ops
->create_sals_from_location
= bkpt_create_sals_from_location
;
15426 ops
->create_breakpoints_sal
= bkpt_create_breakpoints_sal
;
15427 ops
->decode_location
= bkpt_decode_location
;
15429 /* The breakpoint_ops structure to be used in regular breakpoints. */
15430 ops
= &bkpt_breakpoint_ops
;
15431 *ops
= bkpt_base_breakpoint_ops
;
15432 ops
->re_set
= bkpt_re_set
;
15433 ops
->resources_needed
= bkpt_resources_needed
;
15434 ops
->print_it
= bkpt_print_it
;
15435 ops
->print_mention
= bkpt_print_mention
;
15436 ops
->print_recreate
= bkpt_print_recreate
;
15438 /* Ranged breakpoints. */
15439 ops
= &ranged_breakpoint_ops
;
15440 *ops
= bkpt_breakpoint_ops
;
15441 ops
->breakpoint_hit
= breakpoint_hit_ranged_breakpoint
;
15442 ops
->resources_needed
= resources_needed_ranged_breakpoint
;
15443 ops
->print_it
= print_it_ranged_breakpoint
;
15444 ops
->print_one
= print_one_ranged_breakpoint
;
15445 ops
->print_one_detail
= print_one_detail_ranged_breakpoint
;
15446 ops
->print_mention
= print_mention_ranged_breakpoint
;
15447 ops
->print_recreate
= print_recreate_ranged_breakpoint
;
15449 /* Internal breakpoints. */
15450 ops
= &internal_breakpoint_ops
;
15451 *ops
= bkpt_base_breakpoint_ops
;
15452 ops
->re_set
= internal_bkpt_re_set
;
15453 ops
->check_status
= internal_bkpt_check_status
;
15454 ops
->print_it
= internal_bkpt_print_it
;
15455 ops
->print_mention
= internal_bkpt_print_mention
;
15457 /* Momentary breakpoints. */
15458 ops
= &momentary_breakpoint_ops
;
15459 *ops
= bkpt_base_breakpoint_ops
;
15460 ops
->re_set
= momentary_bkpt_re_set
;
15461 ops
->check_status
= momentary_bkpt_check_status
;
15462 ops
->print_it
= momentary_bkpt_print_it
;
15463 ops
->print_mention
= momentary_bkpt_print_mention
;
15465 /* Probe breakpoints. */
15466 ops
= &bkpt_probe_breakpoint_ops
;
15467 *ops
= bkpt_breakpoint_ops
;
15468 ops
->insert_location
= bkpt_probe_insert_location
;
15469 ops
->remove_location
= bkpt_probe_remove_location
;
15470 ops
->create_sals_from_location
= bkpt_probe_create_sals_from_location
;
15471 ops
->decode_location
= bkpt_probe_decode_location
;
15474 ops
= &watchpoint_breakpoint_ops
;
15475 *ops
= base_breakpoint_ops
;
15476 ops
->re_set
= re_set_watchpoint
;
15477 ops
->insert_location
= insert_watchpoint
;
15478 ops
->remove_location
= remove_watchpoint
;
15479 ops
->breakpoint_hit
= breakpoint_hit_watchpoint
;
15480 ops
->check_status
= check_status_watchpoint
;
15481 ops
->resources_needed
= resources_needed_watchpoint
;
15482 ops
->works_in_software_mode
= works_in_software_mode_watchpoint
;
15483 ops
->print_it
= print_it_watchpoint
;
15484 ops
->print_mention
= print_mention_watchpoint
;
15485 ops
->print_recreate
= print_recreate_watchpoint
;
15486 ops
->explains_signal
= explains_signal_watchpoint
;
15488 /* Masked watchpoints. */
15489 ops
= &masked_watchpoint_breakpoint_ops
;
15490 *ops
= watchpoint_breakpoint_ops
;
15491 ops
->insert_location
= insert_masked_watchpoint
;
15492 ops
->remove_location
= remove_masked_watchpoint
;
15493 ops
->resources_needed
= resources_needed_masked_watchpoint
;
15494 ops
->works_in_software_mode
= works_in_software_mode_masked_watchpoint
;
15495 ops
->print_it
= print_it_masked_watchpoint
;
15496 ops
->print_one_detail
= print_one_detail_masked_watchpoint
;
15497 ops
->print_mention
= print_mention_masked_watchpoint
;
15498 ops
->print_recreate
= print_recreate_masked_watchpoint
;
15501 ops
= &tracepoint_breakpoint_ops
;
15502 *ops
= base_breakpoint_ops
;
15503 ops
->re_set
= tracepoint_re_set
;
15504 ops
->breakpoint_hit
= tracepoint_breakpoint_hit
;
15505 ops
->print_one_detail
= tracepoint_print_one_detail
;
15506 ops
->print_mention
= tracepoint_print_mention
;
15507 ops
->print_recreate
= tracepoint_print_recreate
;
15508 ops
->create_sals_from_location
= tracepoint_create_sals_from_location
;
15509 ops
->create_breakpoints_sal
= tracepoint_create_breakpoints_sal
;
15510 ops
->decode_location
= tracepoint_decode_location
;
15512 /* Probe tracepoints. */
15513 ops
= &tracepoint_probe_breakpoint_ops
;
15514 *ops
= tracepoint_breakpoint_ops
;
15515 ops
->create_sals_from_location
= tracepoint_probe_create_sals_from_location
;
15516 ops
->decode_location
= tracepoint_probe_decode_location
;
15518 /* Static tracepoints with marker (`-m'). */
15519 ops
= &strace_marker_breakpoint_ops
;
15520 *ops
= tracepoint_breakpoint_ops
;
15521 ops
->create_sals_from_location
= strace_marker_create_sals_from_location
;
15522 ops
->create_breakpoints_sal
= strace_marker_create_breakpoints_sal
;
15523 ops
->decode_location
= strace_marker_decode_location
;
15525 /* Fork catchpoints. */
15526 ops
= &catch_fork_breakpoint_ops
;
15527 *ops
= base_breakpoint_ops
;
15528 ops
->insert_location
= insert_catch_fork
;
15529 ops
->remove_location
= remove_catch_fork
;
15530 ops
->breakpoint_hit
= breakpoint_hit_catch_fork
;
15531 ops
->print_it
= print_it_catch_fork
;
15532 ops
->print_one
= print_one_catch_fork
;
15533 ops
->print_mention
= print_mention_catch_fork
;
15534 ops
->print_recreate
= print_recreate_catch_fork
;
15536 /* Vfork catchpoints. */
15537 ops
= &catch_vfork_breakpoint_ops
;
15538 *ops
= base_breakpoint_ops
;
15539 ops
->insert_location
= insert_catch_vfork
;
15540 ops
->remove_location
= remove_catch_vfork
;
15541 ops
->breakpoint_hit
= breakpoint_hit_catch_vfork
;
15542 ops
->print_it
= print_it_catch_vfork
;
15543 ops
->print_one
= print_one_catch_vfork
;
15544 ops
->print_mention
= print_mention_catch_vfork
;
15545 ops
->print_recreate
= print_recreate_catch_vfork
;
15547 /* Exec catchpoints. */
15548 ops
= &catch_exec_breakpoint_ops
;
15549 *ops
= base_breakpoint_ops
;
15550 ops
->insert_location
= insert_catch_exec
;
15551 ops
->remove_location
= remove_catch_exec
;
15552 ops
->breakpoint_hit
= breakpoint_hit_catch_exec
;
15553 ops
->print_it
= print_it_catch_exec
;
15554 ops
->print_one
= print_one_catch_exec
;
15555 ops
->print_mention
= print_mention_catch_exec
;
15556 ops
->print_recreate
= print_recreate_catch_exec
;
15558 /* Solib-related catchpoints. */
15559 ops
= &catch_solib_breakpoint_ops
;
15560 *ops
= base_breakpoint_ops
;
15561 ops
->insert_location
= insert_catch_solib
;
15562 ops
->remove_location
= remove_catch_solib
;
15563 ops
->breakpoint_hit
= breakpoint_hit_catch_solib
;
15564 ops
->check_status
= check_status_catch_solib
;
15565 ops
->print_it
= print_it_catch_solib
;
15566 ops
->print_one
= print_one_catch_solib
;
15567 ops
->print_mention
= print_mention_catch_solib
;
15568 ops
->print_recreate
= print_recreate_catch_solib
;
15570 ops
= &dprintf_breakpoint_ops
;
15571 *ops
= bkpt_base_breakpoint_ops
;
15572 ops
->re_set
= dprintf_re_set
;
15573 ops
->resources_needed
= bkpt_resources_needed
;
15574 ops
->print_it
= bkpt_print_it
;
15575 ops
->print_mention
= bkpt_print_mention
;
15576 ops
->print_recreate
= dprintf_print_recreate
;
15577 ops
->after_condition_true
= dprintf_after_condition_true
;
15578 ops
->breakpoint_hit
= dprintf_breakpoint_hit
;
15581 /* Chain containing all defined "enable breakpoint" subcommands. */
15583 static struct cmd_list_element
*enablebreaklist
= NULL
;
15586 _initialize_breakpoint (void)
15588 struct cmd_list_element
*c
;
15590 initialize_breakpoint_ops ();
15592 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
15593 observer_attach_free_objfile (disable_breakpoints_in_freed_objfile
);
15594 observer_attach_memory_changed (invalidate_bp_value_on_memory_change
);
15596 breakpoint_objfile_key
15597 = register_objfile_data_with_cleanup (NULL
, free_breakpoint_objfile_data
);
15599 breakpoint_chain
= 0;
15600 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
15601 before a breakpoint is set. */
15602 breakpoint_count
= 0;
15604 tracepoint_count
= 0;
15606 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
15607 Set ignore-count of breakpoint number N to COUNT.\n\
15608 Usage is `ignore N COUNT'."));
15610 add_com ("commands", class_breakpoint
, commands_command
, _("\
15611 Set commands to be executed when the given breakpoints are hit.\n\
15612 Give a space-separated breakpoint list as argument after \"commands\".\n\
15613 A list element can be a breakpoint number (e.g. `5') or a range of numbers\n\
15615 With no argument, the targeted breakpoint is the last one set.\n\
15616 The commands themselves follow starting on the next line.\n\
15617 Type a line containing \"end\" to indicate the end of them.\n\
15618 Give \"silent\" as the first line to make the breakpoint silent;\n\
15619 then no output is printed when it is hit, except what the commands print."));
15621 c
= add_com ("condition", class_breakpoint
, condition_command
, _("\
15622 Specify breakpoint number N to break only if COND is true.\n\
15623 Usage is `condition N COND', where N is an integer and COND is an\n\
15624 expression to be evaluated whenever breakpoint N is reached."));
15625 set_cmd_completer (c
, condition_completer
);
15627 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
15628 Set a temporary breakpoint.\n\
15629 Like \"break\" except the breakpoint is only temporary,\n\
15630 so it will be deleted when hit. Equivalent to \"break\" followed\n\
15631 by using \"enable delete\" on the breakpoint number.\n\
15633 BREAK_ARGS_HELP ("tbreak")));
15634 set_cmd_completer (c
, location_completer
);
15636 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
15637 Set a hardware assisted breakpoint.\n\
15638 Like \"break\" except the breakpoint requires hardware support,\n\
15639 some target hardware may not have this support.\n\
15641 BREAK_ARGS_HELP ("hbreak")));
15642 set_cmd_completer (c
, location_completer
);
15644 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
15645 Set a temporary hardware assisted breakpoint.\n\
15646 Like \"hbreak\" except the breakpoint is only temporary,\n\
15647 so it will be deleted when hit.\n\
15649 BREAK_ARGS_HELP ("thbreak")));
15650 set_cmd_completer (c
, location_completer
);
15652 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
15653 Enable some breakpoints.\n\
15654 Give breakpoint numbers (separated by spaces) as arguments.\n\
15655 With no subcommand, breakpoints are enabled until you command otherwise.\n\
15656 This is used to cancel the effect of the \"disable\" command.\n\
15657 With a subcommand you can enable temporarily."),
15658 &enablelist
, "enable ", 1, &cmdlist
);
15660 add_com_alias ("en", "enable", class_breakpoint
, 1);
15662 add_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
15663 Enable some breakpoints.\n\
15664 Give breakpoint numbers (separated by spaces) as arguments.\n\
15665 This is used to cancel the effect of the \"disable\" command.\n\
15666 May be abbreviated to simply \"enable\".\n"),
15667 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
15669 add_cmd ("once", no_class
, enable_once_command
, _("\
15670 Enable breakpoints for one hit. Give breakpoint numbers.\n\
15671 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
15674 add_cmd ("delete", no_class
, enable_delete_command
, _("\
15675 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
15676 If a breakpoint is hit while enabled in this fashion, it is deleted."),
15679 add_cmd ("count", no_class
, enable_count_command
, _("\
15680 Enable breakpoints for COUNT hits. Give count and then breakpoint numbers.\n\
15681 If a breakpoint is hit while enabled in this fashion,\n\
15682 the count is decremented; when it reaches zero, the breakpoint is disabled."),
15685 add_cmd ("delete", no_class
, enable_delete_command
, _("\
15686 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
15687 If a breakpoint is hit while enabled in this fashion, it is deleted."),
15690 add_cmd ("once", no_class
, enable_once_command
, _("\
15691 Enable breakpoints for one hit. Give breakpoint numbers.\n\
15692 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
15695 add_cmd ("count", no_class
, enable_count_command
, _("\
15696 Enable breakpoints for COUNT hits. Give count and then breakpoint numbers.\n\
15697 If a breakpoint is hit while enabled in this fashion,\n\
15698 the count is decremented; when it reaches zero, the breakpoint is disabled."),
15701 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
15702 Disable some breakpoints.\n\
15703 Arguments are breakpoint numbers with spaces in between.\n\
15704 To disable all breakpoints, give no argument.\n\
15705 A disabled breakpoint is not forgotten, but has no effect until re-enabled."),
15706 &disablelist
, "disable ", 1, &cmdlist
);
15707 add_com_alias ("dis", "disable", class_breakpoint
, 1);
15708 add_com_alias ("disa", "disable", class_breakpoint
, 1);
15710 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
15711 Disable some breakpoints.\n\
15712 Arguments are breakpoint numbers with spaces in between.\n\
15713 To disable all breakpoints, give no argument.\n\
15714 A disabled breakpoint is not forgotten, but has no effect until re-enabled.\n\
15715 This command may be abbreviated \"disable\"."),
15718 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
15719 Delete some breakpoints or auto-display expressions.\n\
15720 Arguments are breakpoint numbers with spaces in between.\n\
15721 To delete all breakpoints, give no argument.\n\
15723 Also a prefix command for deletion of other GDB objects.\n\
15724 The \"unset\" command is also an alias for \"delete\"."),
15725 &deletelist
, "delete ", 1, &cmdlist
);
15726 add_com_alias ("d", "delete", class_breakpoint
, 1);
15727 add_com_alias ("del", "delete", class_breakpoint
, 1);
15729 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
15730 Delete some breakpoints or auto-display expressions.\n\
15731 Arguments are breakpoint numbers with spaces in between.\n\
15732 To delete all breakpoints, give no argument.\n\
15733 This command may be abbreviated \"delete\"."),
15736 add_com ("clear", class_breakpoint
, clear_command
, _("\
15737 Clear breakpoint at specified location.\n\
15738 Argument may be a linespec, explicit, or address location as described below.\n\
15740 With no argument, clears all breakpoints in the line that the selected frame\n\
15741 is executing in.\n"
15742 "\n" LOCATION_HELP_STRING
"\n\
15743 See also the \"delete\" command which clears breakpoints by number."));
15744 add_com_alias ("cl", "clear", class_breakpoint
, 1);
15746 c
= add_com ("break", class_breakpoint
, break_command
, _("\
15747 Set breakpoint at specified location.\n"
15748 BREAK_ARGS_HELP ("break")));
15749 set_cmd_completer (c
, location_completer
);
15751 add_com_alias ("b", "break", class_run
, 1);
15752 add_com_alias ("br", "break", class_run
, 1);
15753 add_com_alias ("bre", "break", class_run
, 1);
15754 add_com_alias ("brea", "break", class_run
, 1);
15758 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
15759 Break in function/address or break at a line in the current file."),
15760 &stoplist
, "stop ", 1, &cmdlist
);
15761 add_cmd ("in", class_breakpoint
, stopin_command
,
15762 _("Break in function or address."), &stoplist
);
15763 add_cmd ("at", class_breakpoint
, stopat_command
,
15764 _("Break at a line in the current file."), &stoplist
);
15765 add_com ("status", class_info
, info_breakpoints_command
, _("\
15766 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
15767 The \"Type\" column indicates one of:\n\
15768 \tbreakpoint - normal breakpoint\n\
15769 \twatchpoint - watchpoint\n\
15770 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15771 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
15772 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
15773 address and file/line number respectively.\n\
15775 Convenience variable \"$_\" and default examine address for \"x\"\n\
15776 are set to the address of the last breakpoint listed unless the command\n\
15777 is prefixed with \"server \".\n\n\
15778 Convenience variable \"$bpnum\" contains the number of the last\n\
15779 breakpoint set."));
15782 add_info ("breakpoints", info_breakpoints_command
, _("\
15783 Status of specified breakpoints (all user-settable breakpoints if no argument).\n\
15784 The \"Type\" column indicates one of:\n\
15785 \tbreakpoint - normal breakpoint\n\
15786 \twatchpoint - watchpoint\n\
15787 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15788 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
15789 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
15790 address and file/line number respectively.\n\
15792 Convenience variable \"$_\" and default examine address for \"x\"\n\
15793 are set to the address of the last breakpoint listed unless the command\n\
15794 is prefixed with \"server \".\n\n\
15795 Convenience variable \"$bpnum\" contains the number of the last\n\
15796 breakpoint set."));
15798 add_info_alias ("b", "breakpoints", 1);
15800 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
15801 Status of all breakpoints, or breakpoint number NUMBER.\n\
15802 The \"Type\" column indicates one of:\n\
15803 \tbreakpoint - normal breakpoint\n\
15804 \twatchpoint - watchpoint\n\
15805 \tlongjmp - internal breakpoint used to step through longjmp()\n\
15806 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
15807 \tuntil - internal breakpoint used by the \"until\" command\n\
15808 \tfinish - internal breakpoint used by the \"finish\" command\n\
15809 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15810 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
15811 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
15812 address and file/line number respectively.\n\
15814 Convenience variable \"$_\" and default examine address for \"x\"\n\
15815 are set to the address of the last breakpoint listed unless the command\n\
15816 is prefixed with \"server \".\n\n\
15817 Convenience variable \"$bpnum\" contains the number of the last\n\
15819 &maintenanceinfolist
);
15821 add_prefix_cmd ("catch", class_breakpoint
, catch_command
, _("\
15822 Set catchpoints to catch events."),
15823 &catch_cmdlist
, "catch ",
15824 0/*allow-unknown*/, &cmdlist
);
15826 add_prefix_cmd ("tcatch", class_breakpoint
, tcatch_command
, _("\
15827 Set temporary catchpoints to catch events."),
15828 &tcatch_cmdlist
, "tcatch ",
15829 0/*allow-unknown*/, &cmdlist
);
15831 add_catch_command ("fork", _("Catch calls to fork."),
15832 catch_fork_command_1
,
15834 (void *) (uintptr_t) catch_fork_permanent
,
15835 (void *) (uintptr_t) catch_fork_temporary
);
15836 add_catch_command ("vfork", _("Catch calls to vfork."),
15837 catch_fork_command_1
,
15839 (void *) (uintptr_t) catch_vfork_permanent
,
15840 (void *) (uintptr_t) catch_vfork_temporary
);
15841 add_catch_command ("exec", _("Catch calls to exec."),
15842 catch_exec_command_1
,
15846 add_catch_command ("load", _("Catch loads of shared libraries.\n\
15847 Usage: catch load [REGEX]\n\
15848 If REGEX is given, only stop for libraries matching the regular expression."),
15849 catch_load_command_1
,
15853 add_catch_command ("unload", _("Catch unloads of shared libraries.\n\
15854 Usage: catch unload [REGEX]\n\
15855 If REGEX is given, only stop for libraries matching the regular expression."),
15856 catch_unload_command_1
,
15861 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
15862 Set a watchpoint for an expression.\n\
15863 Usage: watch [-l|-location] EXPRESSION\n\
15864 A watchpoint stops execution of your program whenever the value of\n\
15865 an expression changes.\n\
15866 If -l or -location is given, this evaluates EXPRESSION and watches\n\
15867 the memory to which it refers."));
15868 set_cmd_completer (c
, expression_completer
);
15870 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
15871 Set a read watchpoint for an expression.\n\
15872 Usage: rwatch [-l|-location] EXPRESSION\n\
15873 A watchpoint stops execution of your program whenever the value of\n\
15874 an expression is read.\n\
15875 If -l or -location is given, this evaluates EXPRESSION and watches\n\
15876 the memory to which it refers."));
15877 set_cmd_completer (c
, expression_completer
);
15879 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
15880 Set a watchpoint for an expression.\n\
15881 Usage: awatch [-l|-location] EXPRESSION\n\
15882 A watchpoint stops execution of your program whenever the value of\n\
15883 an expression is either read or written.\n\
15884 If -l or -location is given, this evaluates EXPRESSION and watches\n\
15885 the memory to which it refers."));
15886 set_cmd_completer (c
, expression_completer
);
15888 add_info ("watchpoints", info_watchpoints_command
, _("\
15889 Status of specified watchpoints (all watchpoints if no argument)."));
15891 /* XXX: cagney/2005-02-23: This should be a boolean, and should
15892 respond to changes - contrary to the description. */
15893 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
15894 &can_use_hw_watchpoints
, _("\
15895 Set debugger's willingness to use watchpoint hardware."), _("\
15896 Show debugger's willingness to use watchpoint hardware."), _("\
15897 If zero, gdb will not use hardware for new watchpoints, even if\n\
15898 such is available. (However, any hardware watchpoints that were\n\
15899 created before setting this to nonzero, will continue to use watchpoint\n\
15902 show_can_use_hw_watchpoints
,
15903 &setlist
, &showlist
);
15905 can_use_hw_watchpoints
= 1;
15907 /* Tracepoint manipulation commands. */
15909 c
= add_com ("trace", class_breakpoint
, trace_command
, _("\
15910 Set a tracepoint at specified location.\n\
15912 BREAK_ARGS_HELP ("trace") "\n\
15913 Do \"help tracepoints\" for info on other tracepoint commands."));
15914 set_cmd_completer (c
, location_completer
);
15916 add_com_alias ("tp", "trace", class_alias
, 0);
15917 add_com_alias ("tr", "trace", class_alias
, 1);
15918 add_com_alias ("tra", "trace", class_alias
, 1);
15919 add_com_alias ("trac", "trace", class_alias
, 1);
15921 c
= add_com ("ftrace", class_breakpoint
, ftrace_command
, _("\
15922 Set a fast tracepoint at specified location.\n\
15924 BREAK_ARGS_HELP ("ftrace") "\n\
15925 Do \"help tracepoints\" for info on other tracepoint commands."));
15926 set_cmd_completer (c
, location_completer
);
15928 c
= add_com ("strace", class_breakpoint
, strace_command
, _("\
15929 Set a static tracepoint at location or marker.\n\
15931 strace [LOCATION] [if CONDITION]\n\
15932 LOCATION may be a linespec, explicit, or address location (described below) \n\
15933 or -m MARKER_ID.\n\n\
15934 If a marker id is specified, probe the marker with that name. With\n\
15935 no LOCATION, uses current execution address of the selected stack frame.\n\
15936 Static tracepoints accept an extra collect action -- ``collect $_sdata''.\n\
15937 This collects arbitrary user data passed in the probe point call to the\n\
15938 tracing library. You can inspect it when analyzing the trace buffer,\n\
15939 by printing the $_sdata variable like any other convenience variable.\n\
15941 CONDITION is a boolean expression.\n\
15942 \n" LOCATION_HELP_STRING
"\n\
15943 Multiple tracepoints at one place are permitted, and useful if their\n\
15944 conditions are different.\n\
15946 Do \"help breakpoints\" for info on other commands dealing with breakpoints.\n\
15947 Do \"help tracepoints\" for info on other tracepoint commands."));
15948 set_cmd_completer (c
, location_completer
);
15950 add_info ("tracepoints", info_tracepoints_command
, _("\
15951 Status of specified tracepoints (all tracepoints if no argument).\n\
15952 Convenience variable \"$tpnum\" contains the number of the\n\
15953 last tracepoint set."));
15955 add_info_alias ("tp", "tracepoints", 1);
15957 add_cmd ("tracepoints", class_trace
, delete_trace_command
, _("\
15958 Delete specified tracepoints.\n\
15959 Arguments are tracepoint numbers, separated by spaces.\n\
15960 No argument means delete all tracepoints."),
15962 add_alias_cmd ("tr", "tracepoints", class_trace
, 1, &deletelist
);
15964 c
= add_cmd ("tracepoints", class_trace
, disable_trace_command
, _("\
15965 Disable specified tracepoints.\n\
15966 Arguments are tracepoint numbers, separated by spaces.\n\
15967 No argument means disable all tracepoints."),
15969 deprecate_cmd (c
, "disable");
15971 c
= add_cmd ("tracepoints", class_trace
, enable_trace_command
, _("\
15972 Enable specified tracepoints.\n\
15973 Arguments are tracepoint numbers, separated by spaces.\n\
15974 No argument means enable all tracepoints."),
15976 deprecate_cmd (c
, "enable");
15978 add_com ("passcount", class_trace
, trace_pass_command
, _("\
15979 Set the passcount for a tracepoint.\n\
15980 The trace will end when the tracepoint has been passed 'count' times.\n\
15981 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
15982 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
15984 add_prefix_cmd ("save", class_breakpoint
, save_command
,
15985 _("Save breakpoint definitions as a script."),
15986 &save_cmdlist
, "save ",
15987 0/*allow-unknown*/, &cmdlist
);
15989 c
= add_cmd ("breakpoints", class_breakpoint
, save_breakpoints_command
, _("\
15990 Save current breakpoint definitions as a script.\n\
15991 This includes all types of breakpoints (breakpoints, watchpoints,\n\
15992 catchpoints, tracepoints). Use the 'source' command in another debug\n\
15993 session to restore them."),
15995 set_cmd_completer (c
, filename_completer
);
15997 c
= add_cmd ("tracepoints", class_trace
, save_tracepoints_command
, _("\
15998 Save current tracepoint definitions as a script.\n\
15999 Use the 'source' command in another debug session to restore them."),
16001 set_cmd_completer (c
, filename_completer
);
16003 c
= add_com_alias ("save-tracepoints", "save tracepoints", class_trace
, 0);
16004 deprecate_cmd (c
, "save tracepoints");
16006 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
16007 Breakpoint specific settings\n\
16008 Configure various breakpoint-specific variables such as\n\
16009 pending breakpoint behavior"),
16010 &breakpoint_set_cmdlist
, "set breakpoint ",
16011 0/*allow-unknown*/, &setlist
);
16012 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
16013 Breakpoint specific settings\n\
16014 Configure various breakpoint-specific variables such as\n\
16015 pending breakpoint behavior"),
16016 &breakpoint_show_cmdlist
, "show breakpoint ",
16017 0/*allow-unknown*/, &showlist
);
16019 add_setshow_auto_boolean_cmd ("pending", no_class
,
16020 &pending_break_support
, _("\
16021 Set debugger's behavior regarding pending breakpoints."), _("\
16022 Show debugger's behavior regarding pending breakpoints."), _("\
16023 If on, an unrecognized breakpoint location will cause gdb to create a\n\
16024 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
16025 an error. If auto, an unrecognized breakpoint location results in a\n\
16026 user-query to see if a pending breakpoint should be created."),
16028 show_pending_break_support
,
16029 &breakpoint_set_cmdlist
,
16030 &breakpoint_show_cmdlist
);
16032 pending_break_support
= AUTO_BOOLEAN_AUTO
;
16034 add_setshow_boolean_cmd ("auto-hw", no_class
,
16035 &automatic_hardware_breakpoints
, _("\
16036 Set automatic usage of hardware breakpoints."), _("\
16037 Show automatic usage of hardware breakpoints."), _("\
16038 If set, the debugger will automatically use hardware breakpoints for\n\
16039 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
16040 a warning will be emitted for such breakpoints."),
16042 show_automatic_hardware_breakpoints
,
16043 &breakpoint_set_cmdlist
,
16044 &breakpoint_show_cmdlist
);
16046 add_setshow_boolean_cmd ("always-inserted", class_support
,
16047 &always_inserted_mode
, _("\
16048 Set mode for inserting breakpoints."), _("\
16049 Show mode for inserting breakpoints."), _("\
16050 When this mode is on, breakpoints are inserted immediately as soon as\n\
16051 they're created, kept inserted even when execution stops, and removed\n\
16052 only when the user deletes them. When this mode is off (the default),\n\
16053 breakpoints are inserted only when execution continues, and removed\n\
16054 when execution stops."),
16056 &show_always_inserted_mode
,
16057 &breakpoint_set_cmdlist
,
16058 &breakpoint_show_cmdlist
);
16060 add_setshow_enum_cmd ("condition-evaluation", class_breakpoint
,
16061 condition_evaluation_enums
,
16062 &condition_evaluation_mode_1
, _("\
16063 Set mode of breakpoint condition evaluation."), _("\
16064 Show mode of breakpoint condition evaluation."), _("\
16065 When this is set to \"host\", breakpoint conditions will be\n\
16066 evaluated on the host's side by GDB. When it is set to \"target\",\n\
16067 breakpoint conditions will be downloaded to the target (if the target\n\
16068 supports such feature) and conditions will be evaluated on the target's side.\n\
16069 If this is set to \"auto\" (default), this will be automatically set to\n\
16070 \"target\" if it supports condition evaluation, otherwise it will\n\
16071 be set to \"gdb\""),
16072 &set_condition_evaluation_mode
,
16073 &show_condition_evaluation_mode
,
16074 &breakpoint_set_cmdlist
,
16075 &breakpoint_show_cmdlist
);
16077 add_com ("break-range", class_breakpoint
, break_range_command
, _("\
16078 Set a breakpoint for an address range.\n\
16079 break-range START-LOCATION, END-LOCATION\n\
16080 where START-LOCATION and END-LOCATION can be one of the following:\n\
16081 LINENUM, for that line in the current file,\n\
16082 FILE:LINENUM, for that line in that file,\n\
16083 +OFFSET, for that number of lines after the current line\n\
16084 or the start of the range\n\
16085 FUNCTION, for the first line in that function,\n\
16086 FILE:FUNCTION, to distinguish among like-named static functions.\n\
16087 *ADDRESS, for the instruction at that address.\n\
16089 The breakpoint will stop execution of the inferior whenever it executes\n\
16090 an instruction at any address within the [START-LOCATION, END-LOCATION]\n\
16091 range (including START-LOCATION and END-LOCATION)."));
16093 c
= add_com ("dprintf", class_breakpoint
, dprintf_command
, _("\
16094 Set a dynamic printf at specified location.\n\
16095 dprintf location,format string,arg1,arg2,...\n\
16096 location may be a linespec, explicit, or address location.\n"
16097 "\n" LOCATION_HELP_STRING
));
16098 set_cmd_completer (c
, location_completer
);
16100 add_setshow_enum_cmd ("dprintf-style", class_support
,
16101 dprintf_style_enums
, &dprintf_style
, _("\
16102 Set the style of usage for dynamic printf."), _("\
16103 Show the style of usage for dynamic printf."), _("\
16104 This setting chooses how GDB will do a dynamic printf.\n\
16105 If the value is \"gdb\", then the printing is done by GDB to its own\n\
16106 console, as with the \"printf\" command.\n\
16107 If the value is \"call\", the print is done by calling a function in your\n\
16108 program; by default printf(), but you can choose a different function or\n\
16109 output stream by setting dprintf-function and dprintf-channel."),
16110 update_dprintf_commands
, NULL
,
16111 &setlist
, &showlist
);
16113 dprintf_function
= xstrdup ("printf");
16114 add_setshow_string_cmd ("dprintf-function", class_support
,
16115 &dprintf_function
, _("\
16116 Set the function to use for dynamic printf"), _("\
16117 Show the function to use for dynamic printf"), NULL
,
16118 update_dprintf_commands
, NULL
,
16119 &setlist
, &showlist
);
16121 dprintf_channel
= xstrdup ("");
16122 add_setshow_string_cmd ("dprintf-channel", class_support
,
16123 &dprintf_channel
, _("\
16124 Set the channel to use for dynamic printf"), _("\
16125 Show the channel to use for dynamic printf"), NULL
,
16126 update_dprintf_commands
, NULL
,
16127 &setlist
, &showlist
);
16129 add_setshow_boolean_cmd ("disconnected-dprintf", no_class
,
16130 &disconnected_dprintf
, _("\
16131 Set whether dprintf continues after GDB disconnects."), _("\
16132 Show whether dprintf continues after GDB disconnects."), _("\
16133 Use this to let dprintf commands continue to hit and produce output\n\
16134 even if GDB disconnects or detaches from the target."),
16137 &setlist
, &showlist
);
16139 add_com ("agent-printf", class_vars
, agent_printf_command
, _("\
16140 agent-printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
16141 (target agent only) This is useful for formatted output in user-defined commands."));
16143 automatic_hardware_breakpoints
= 1;
16145 observer_attach_about_to_proceed (breakpoint_about_to_proceed
);
16146 observer_attach_thread_exit (remove_threaded_breakpoints
);