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"
52 #include "observable.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 gdb::observers::breakpoint_modified
.notify (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 gdb::observers::breakpoint_modified
.notify (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 gdb::observers::breakpoint_modified
.notify (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 gdb::observers::breakpoint_modified
.notify (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 gdb::observers::breakpoint_modified
.notify (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 gdb::observers::breakpoint_modified
.notify (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_decref (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
);
1798 release_value (v
).release ();
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 gdb::observers::breakpoint_modified
.notify (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_decref (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_decref (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
)
4240 old_val
= release_value (value_copy (old_val
)).release ();
4241 incref_bp_location (bp_location_at
);
4244 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
4245 is part of the bpstat is copied as well. */
4248 bpstat_copy (bpstat bs
)
4252 bpstat retval
= NULL
;
4257 for (; bs
!= NULL
; bs
= bs
->next
)
4259 tmp
= new bpstats (*bs
);
4262 /* This is the first thing in the chain. */
4272 /* Find the bpstat associated with this breakpoint. */
4275 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
4280 for (; bsp
!= NULL
; bsp
= bsp
->next
)
4282 if (bsp
->breakpoint_at
== breakpoint
)
4288 /* See breakpoint.h. */
4291 bpstat_explains_signal (bpstat bsp
, enum gdb_signal sig
)
4293 for (; bsp
!= NULL
; bsp
= bsp
->next
)
4295 if (bsp
->breakpoint_at
== NULL
)
4297 /* A moribund location can never explain a signal other than
4299 if (sig
== GDB_SIGNAL_TRAP
)
4304 if (bsp
->breakpoint_at
->ops
->explains_signal (bsp
->breakpoint_at
,
4313 /* Put in *NUM the breakpoint number of the first breakpoint we are
4314 stopped at. *BSP upon return is a bpstat which points to the
4315 remaining breakpoints stopped at (but which is not guaranteed to be
4316 good for anything but further calls to bpstat_num).
4318 Return 0 if passed a bpstat which does not indicate any breakpoints.
4319 Return -1 if stopped at a breakpoint that has been deleted since
4321 Return 1 otherwise. */
4324 bpstat_num (bpstat
*bsp
, int *num
)
4326 struct breakpoint
*b
;
4329 return 0; /* No more breakpoint values */
4331 /* We assume we'll never have several bpstats that correspond to a
4332 single breakpoint -- otherwise, this function might return the
4333 same number more than once and this will look ugly. */
4334 b
= (*bsp
)->breakpoint_at
;
4335 *bsp
= (*bsp
)->next
;
4337 return -1; /* breakpoint that's been deleted since */
4339 *num
= b
->number
; /* We have its number */
4343 /* See breakpoint.h. */
4346 bpstat_clear_actions (void)
4348 struct thread_info
*tp
;
4351 if (ptid_equal (inferior_ptid
, null_ptid
))
4354 tp
= find_thread_ptid (inferior_ptid
);
4358 for (bs
= tp
->control
.stop_bpstat
; bs
!= NULL
; bs
= bs
->next
)
4360 bs
->commands
= NULL
;
4362 if (bs
->old_val
!= NULL
)
4364 value_decref (bs
->old_val
);
4370 /* Called when a command is about to proceed the inferior. */
4373 breakpoint_about_to_proceed (void)
4375 if (!ptid_equal (inferior_ptid
, null_ptid
))
4377 struct thread_info
*tp
= inferior_thread ();
4379 /* Allow inferior function calls in breakpoint commands to not
4380 interrupt the command list. When the call finishes
4381 successfully, the inferior will be standing at the same
4382 breakpoint as if nothing happened. */
4383 if (tp
->control
.in_infcall
)
4387 breakpoint_proceeded
= 1;
4390 /* Return non-zero iff CMD as the first line of a command sequence is `silent'
4391 or its equivalent. */
4394 command_line_is_silent (struct command_line
*cmd
)
4396 return cmd
&& (strcmp ("silent", cmd
->line
) == 0);
4399 /* Execute all the commands associated with all the breakpoints at
4400 this location. Any of these commands could cause the process to
4401 proceed beyond this point, etc. We look out for such changes by
4402 checking the global "breakpoint_proceeded" after each command.
4404 Returns true if a breakpoint command resumed the inferior. In that
4405 case, it is the caller's responsibility to recall it again with the
4406 bpstat of the current thread. */
4409 bpstat_do_actions_1 (bpstat
*bsp
)
4414 /* Avoid endless recursion if a `source' command is contained
4416 if (executing_breakpoint_commands
)
4419 scoped_restore save_executing
4420 = make_scoped_restore (&executing_breakpoint_commands
, 1);
4422 scoped_restore preventer
= prevent_dont_repeat ();
4424 /* This pointer will iterate over the list of bpstat's. */
4427 breakpoint_proceeded
= 0;
4428 for (; bs
!= NULL
; bs
= bs
->next
)
4430 struct command_line
*cmd
= NULL
;
4432 /* Take ownership of the BSP's command tree, if it has one.
4434 The command tree could legitimately contain commands like
4435 'step' and 'next', which call clear_proceed_status, which
4436 frees stop_bpstat's command tree. To make sure this doesn't
4437 free the tree we're executing out from under us, we need to
4438 take ownership of the tree ourselves. Since a given bpstat's
4439 commands are only executed once, we don't need to copy it; we
4440 can clear the pointer in the bpstat, and make sure we free
4441 the tree when we're done. */
4442 counted_command_line ccmd
= bs
->commands
;
4443 bs
->commands
= NULL
;
4446 if (command_line_is_silent (cmd
))
4448 /* The action has been already done by bpstat_stop_status. */
4454 execute_control_command (cmd
);
4456 if (breakpoint_proceeded
)
4462 if (breakpoint_proceeded
)
4464 if (current_ui
->async
)
4465 /* If we are in async mode, then the target might be still
4466 running, not stopped at any breakpoint, so nothing for
4467 us to do here -- just return to the event loop. */
4470 /* In sync mode, when execute_control_command returns
4471 we're already standing on the next breakpoint.
4472 Breakpoint commands for that stop were not run, since
4473 execute_command does not run breakpoint commands --
4474 only command_line_handler does, but that one is not
4475 involved in execution of breakpoint commands. So, we
4476 can now execute breakpoint commands. It should be
4477 noted that making execute_command do bpstat actions is
4478 not an option -- in this case we'll have recursive
4479 invocation of bpstat for each breakpoint with a
4480 command, and can easily blow up GDB stack. Instead, we
4481 return true, which will trigger the caller to recall us
4482 with the new stop_bpstat. */
4491 bpstat_do_actions (void)
4493 struct cleanup
*cleanup_if_error
= make_bpstat_clear_actions_cleanup ();
4495 /* Do any commands attached to breakpoint we are stopped at. */
4496 while (!ptid_equal (inferior_ptid
, null_ptid
)
4497 && target_has_execution
4498 && !is_exited (inferior_ptid
)
4499 && !is_executing (inferior_ptid
))
4500 /* Since in sync mode, bpstat_do_actions may resume the inferior,
4501 and only return when it is stopped at the next breakpoint, we
4502 keep doing breakpoint actions until it returns false to
4503 indicate the inferior was not resumed. */
4504 if (!bpstat_do_actions_1 (&inferior_thread ()->control
.stop_bpstat
))
4507 discard_cleanups (cleanup_if_error
);
4510 /* Print out the (old or new) value associated with a watchpoint. */
4513 watchpoint_value_print (struct value
*val
, struct ui_file
*stream
)
4516 fprintf_unfiltered (stream
, _("<unreadable>"));
4519 struct value_print_options opts
;
4520 get_user_print_options (&opts
);
4521 value_print (val
, stream
, &opts
);
4525 /* Print the "Thread ID hit" part of "Thread ID hit Breakpoint N" if
4526 debugging multiple threads. */
4529 maybe_print_thread_hit_breakpoint (struct ui_out
*uiout
)
4531 if (uiout
->is_mi_like_p ())
4536 if (show_thread_that_caused_stop ())
4539 struct thread_info
*thr
= inferior_thread ();
4541 uiout
->text ("Thread ");
4542 uiout
->field_fmt ("thread-id", "%s", print_thread_id (thr
));
4544 name
= thr
->name
!= NULL
? thr
->name
: target_thread_name (thr
);
4547 uiout
->text (" \"");
4548 uiout
->field_fmt ("name", "%s", name
);
4552 uiout
->text (" hit ");
4556 /* Generic routine for printing messages indicating why we
4557 stopped. The behavior of this function depends on the value
4558 'print_it' in the bpstat structure. Under some circumstances we
4559 may decide not to print anything here and delegate the task to
4562 static enum print_stop_action
4563 print_bp_stop_message (bpstat bs
)
4565 switch (bs
->print_it
)
4568 /* Nothing should be printed for this bpstat entry. */
4569 return PRINT_UNKNOWN
;
4573 /* We still want to print the frame, but we already printed the
4574 relevant messages. */
4575 return PRINT_SRC_AND_LOC
;
4578 case print_it_normal
:
4580 struct breakpoint
*b
= bs
->breakpoint_at
;
4582 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
4583 which has since been deleted. */
4585 return PRINT_UNKNOWN
;
4587 /* Normal case. Call the breakpoint's print_it method. */
4588 return b
->ops
->print_it (bs
);
4593 internal_error (__FILE__
, __LINE__
,
4594 _("print_bp_stop_message: unrecognized enum value"));
4599 /* A helper function that prints a shared library stopped event. */
4602 print_solib_event (int is_catchpoint
)
4604 bool any_deleted
= !current_program_space
->deleted_solibs
.empty ();
4606 = !VEC_empty (so_list_ptr
, current_program_space
->added_solibs
);
4610 if (any_added
|| any_deleted
)
4611 current_uiout
->text (_("Stopped due to shared library event:\n"));
4613 current_uiout
->text (_("Stopped due to shared library event (no "
4614 "libraries added or removed)\n"));
4617 if (current_uiout
->is_mi_like_p ())
4618 current_uiout
->field_string ("reason",
4619 async_reason_lookup (EXEC_ASYNC_SOLIB_EVENT
));
4623 current_uiout
->text (_(" Inferior unloaded "));
4624 ui_out_emit_list
list_emitter (current_uiout
, "removed");
4625 for (int ix
= 0; ix
< current_program_space
->deleted_solibs
.size (); ix
++)
4627 const std::string
&name
= current_program_space
->deleted_solibs
[ix
];
4630 current_uiout
->text (" ");
4631 current_uiout
->field_string ("library", name
);
4632 current_uiout
->text ("\n");
4638 struct so_list
*iter
;
4641 current_uiout
->text (_(" Inferior loaded "));
4642 ui_out_emit_list
list_emitter (current_uiout
, "added");
4644 VEC_iterate (so_list_ptr
, current_program_space
->added_solibs
,
4649 current_uiout
->text (" ");
4650 current_uiout
->field_string ("library", iter
->so_name
);
4651 current_uiout
->text ("\n");
4656 /* Print a message indicating what happened. This is called from
4657 normal_stop(). The input to this routine is the head of the bpstat
4658 list - a list of the eventpoints that caused this stop. KIND is
4659 the target_waitkind for the stopping event. This
4660 routine calls the generic print routine for printing a message
4661 about reasons for stopping. This will print (for example) the
4662 "Breakpoint n," part of the output. The return value of this
4665 PRINT_UNKNOWN: Means we printed nothing.
4666 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
4667 code to print the location. An example is
4668 "Breakpoint 1, " which should be followed by
4670 PRINT_SRC_ONLY: Means we printed something, but there is no need
4671 to also print the location part of the message.
4672 An example is the catch/throw messages, which
4673 don't require a location appended to the end.
4674 PRINT_NOTHING: We have done some printing and we don't need any
4675 further info to be printed. */
4677 enum print_stop_action
4678 bpstat_print (bpstat bs
, int kind
)
4680 enum print_stop_action val
;
4682 /* Maybe another breakpoint in the chain caused us to stop.
4683 (Currently all watchpoints go on the bpstat whether hit or not.
4684 That probably could (should) be changed, provided care is taken
4685 with respect to bpstat_explains_signal). */
4686 for (; bs
; bs
= bs
->next
)
4688 val
= print_bp_stop_message (bs
);
4689 if (val
== PRINT_SRC_ONLY
4690 || val
== PRINT_SRC_AND_LOC
4691 || val
== PRINT_NOTHING
)
4695 /* If we had hit a shared library event breakpoint,
4696 print_bp_stop_message would print out this message. If we hit an
4697 OS-level shared library event, do the same thing. */
4698 if (kind
== TARGET_WAITKIND_LOADED
)
4700 print_solib_event (0);
4701 return PRINT_NOTHING
;
4704 /* We reached the end of the chain, or we got a null BS to start
4705 with and nothing was printed. */
4706 return PRINT_UNKNOWN
;
4709 /* Evaluate the boolean expression EXP and return the result. */
4712 breakpoint_cond_eval (expression
*exp
)
4714 struct value
*mark
= value_mark ();
4715 bool res
= value_true (evaluate_expression (exp
));
4717 value_free_to_mark (mark
);
4721 /* Allocate a new bpstat. Link it to the FIFO list by BS_LINK_POINTER. */
4723 bpstats::bpstats (struct bp_location
*bl
, bpstat
**bs_link_pointer
)
4725 bp_location_at (bl
),
4726 breakpoint_at (bl
->owner
),
4731 print_it (print_it_normal
)
4733 incref_bp_location (bl
);
4734 **bs_link_pointer
= this;
4735 *bs_link_pointer
= &next
;
4740 bp_location_at (NULL
),
4741 breakpoint_at (NULL
),
4746 print_it (print_it_normal
)
4750 /* The target has stopped with waitstatus WS. Check if any hardware
4751 watchpoints have triggered, according to the target. */
4754 watchpoints_triggered (struct target_waitstatus
*ws
)
4756 int stopped_by_watchpoint
= target_stopped_by_watchpoint ();
4758 struct breakpoint
*b
;
4760 if (!stopped_by_watchpoint
)
4762 /* We were not stopped by a watchpoint. Mark all watchpoints
4763 as not triggered. */
4765 if (is_hardware_watchpoint (b
))
4767 struct watchpoint
*w
= (struct watchpoint
*) b
;
4769 w
->watchpoint_triggered
= watch_triggered_no
;
4775 if (!target_stopped_data_address (¤t_target
, &addr
))
4777 /* We were stopped by a watchpoint, but we don't know where.
4778 Mark all watchpoints as unknown. */
4780 if (is_hardware_watchpoint (b
))
4782 struct watchpoint
*w
= (struct watchpoint
*) b
;
4784 w
->watchpoint_triggered
= watch_triggered_unknown
;
4790 /* The target could report the data address. Mark watchpoints
4791 affected by this data address as triggered, and all others as not
4795 if (is_hardware_watchpoint (b
))
4797 struct watchpoint
*w
= (struct watchpoint
*) b
;
4798 struct bp_location
*loc
;
4800 w
->watchpoint_triggered
= watch_triggered_no
;
4801 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
4803 if (is_masked_watchpoint (b
))
4805 CORE_ADDR newaddr
= addr
& w
->hw_wp_mask
;
4806 CORE_ADDR start
= loc
->address
& w
->hw_wp_mask
;
4808 if (newaddr
== start
)
4810 w
->watchpoint_triggered
= watch_triggered_yes
;
4814 /* Exact match not required. Within range is sufficient. */
4815 else if (target_watchpoint_addr_within_range (¤t_target
,
4819 w
->watchpoint_triggered
= watch_triggered_yes
;
4828 /* Possible return values for watchpoint_check. */
4829 enum wp_check_result
4831 /* The watchpoint has been deleted. */
4834 /* The value has changed. */
4835 WP_VALUE_CHANGED
= 2,
4837 /* The value has not changed. */
4838 WP_VALUE_NOT_CHANGED
= 3,
4840 /* Ignore this watchpoint, no matter if the value changed or not. */
4844 #define BP_TEMPFLAG 1
4845 #define BP_HARDWAREFLAG 2
4847 /* Evaluate watchpoint condition expression and check if its value
4850 static wp_check_result
4851 watchpoint_check (bpstat bs
)
4853 struct watchpoint
*b
;
4854 struct frame_info
*fr
;
4855 int within_current_scope
;
4857 /* BS is built from an existing struct breakpoint. */
4858 gdb_assert (bs
->breakpoint_at
!= NULL
);
4859 b
= (struct watchpoint
*) bs
->breakpoint_at
;
4861 /* If this is a local watchpoint, we only want to check if the
4862 watchpoint frame is in scope if the current thread is the thread
4863 that was used to create the watchpoint. */
4864 if (!watchpoint_in_thread_scope (b
))
4867 if (b
->exp_valid_block
== NULL
)
4868 within_current_scope
= 1;
4871 struct frame_info
*frame
= get_current_frame ();
4872 struct gdbarch
*frame_arch
= get_frame_arch (frame
);
4873 CORE_ADDR frame_pc
= get_frame_pc (frame
);
4875 /* stack_frame_destroyed_p() returns a non-zero value if we're
4876 still in the function but the stack frame has already been
4877 invalidated. Since we can't rely on the values of local
4878 variables after the stack has been destroyed, we are treating
4879 the watchpoint in that state as `not changed' without further
4880 checking. Don't mark watchpoints as changed if the current
4881 frame is in an epilogue - even if they are in some other
4882 frame, our view of the stack is likely to be wrong and
4883 frame_find_by_id could error out. */
4884 if (gdbarch_stack_frame_destroyed_p (frame_arch
, frame_pc
))
4887 fr
= frame_find_by_id (b
->watchpoint_frame
);
4888 within_current_scope
= (fr
!= NULL
);
4890 /* If we've gotten confused in the unwinder, we might have
4891 returned a frame that can't describe this variable. */
4892 if (within_current_scope
)
4894 struct symbol
*function
;
4896 function
= get_frame_function (fr
);
4897 if (function
== NULL
4898 || !contained_in (b
->exp_valid_block
,
4899 SYMBOL_BLOCK_VALUE (function
)))
4900 within_current_scope
= 0;
4903 if (within_current_scope
)
4904 /* If we end up stopping, the current frame will get selected
4905 in normal_stop. So this call to select_frame won't affect
4910 if (within_current_scope
)
4912 /* We use value_{,free_to_}mark because it could be a *long*
4913 time before we return to the command level and call
4914 free_all_values. We can't call free_all_values because we
4915 might be in the middle of evaluating a function call. */
4919 struct value
*new_val
;
4921 if (is_masked_watchpoint (b
))
4922 /* Since we don't know the exact trigger address (from
4923 stopped_data_address), just tell the user we've triggered
4924 a mask watchpoint. */
4925 return WP_VALUE_CHANGED
;
4927 mark
= value_mark ();
4928 fetch_subexp_value (b
->exp
.get (), &pc
, &new_val
, NULL
, NULL
, 0);
4930 if (b
->val_bitsize
!= 0)
4931 new_val
= extract_bitfield_from_watchpoint_value (b
, new_val
);
4933 /* We use value_equal_contents instead of value_equal because
4934 the latter coerces an array to a pointer, thus comparing just
4935 the address of the array instead of its contents. This is
4936 not what we want. */
4937 if ((b
->val
!= NULL
) != (new_val
!= NULL
)
4938 || (b
->val
!= NULL
&& !value_equal_contents (b
->val
, new_val
)))
4940 if (new_val
!= NULL
)
4942 release_value (new_val
).release ();
4943 value_free_to_mark (mark
);
4945 bs
->old_val
= b
->val
;
4948 return WP_VALUE_CHANGED
;
4952 /* Nothing changed. */
4953 value_free_to_mark (mark
);
4954 return WP_VALUE_NOT_CHANGED
;
4959 /* This seems like the only logical thing to do because
4960 if we temporarily ignored the watchpoint, then when
4961 we reenter the block in which it is valid it contains
4962 garbage (in the case of a function, it may have two
4963 garbage values, one before and one after the prologue).
4964 So we can't even detect the first assignment to it and
4965 watch after that (since the garbage may or may not equal
4966 the first value assigned). */
4967 /* We print all the stop information in
4968 breakpoint_ops->print_it, but in this case, by the time we
4969 call breakpoint_ops->print_it this bp will be deleted
4970 already. So we have no choice but print the information
4973 SWITCH_THRU_ALL_UIS ()
4975 struct ui_out
*uiout
= current_uiout
;
4977 if (uiout
->is_mi_like_p ())
4979 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
4980 uiout
->text ("\nWatchpoint ");
4981 uiout
->field_int ("wpnum", b
->number
);
4982 uiout
->text (" deleted because the program has left the block in\n"
4983 "which its expression is valid.\n");
4986 /* Make sure the watchpoint's commands aren't executed. */
4988 watchpoint_del_at_next_stop (b
);
4994 /* Return true if it looks like target has stopped due to hitting
4995 breakpoint location BL. This function does not check if we should
4996 stop, only if BL explains the stop. */
4999 bpstat_check_location (const struct bp_location
*bl
,
5000 const address_space
*aspace
, CORE_ADDR bp_addr
,
5001 const struct target_waitstatus
*ws
)
5003 struct breakpoint
*b
= bl
->owner
;
5005 /* BL is from an existing breakpoint. */
5006 gdb_assert (b
!= NULL
);
5008 return b
->ops
->breakpoint_hit (bl
, aspace
, bp_addr
, ws
);
5011 /* Determine if the watched values have actually changed, and we
5012 should stop. If not, set BS->stop to 0. */
5015 bpstat_check_watchpoint (bpstat bs
)
5017 const struct bp_location
*bl
;
5018 struct watchpoint
*b
;
5020 /* BS is built for existing struct breakpoint. */
5021 bl
= bs
->bp_location_at
;
5022 gdb_assert (bl
!= NULL
);
5023 b
= (struct watchpoint
*) bs
->breakpoint_at
;
5024 gdb_assert (b
!= NULL
);
5027 int must_check_value
= 0;
5029 if (b
->type
== bp_watchpoint
)
5030 /* For a software watchpoint, we must always check the
5032 must_check_value
= 1;
5033 else if (b
->watchpoint_triggered
== watch_triggered_yes
)
5034 /* We have a hardware watchpoint (read, write, or access)
5035 and the target earlier reported an address watched by
5037 must_check_value
= 1;
5038 else if (b
->watchpoint_triggered
== watch_triggered_unknown
5039 && b
->type
== bp_hardware_watchpoint
)
5040 /* We were stopped by a hardware watchpoint, but the target could
5041 not report the data address. We must check the watchpoint's
5042 value. Access and read watchpoints are out of luck; without
5043 a data address, we can't figure it out. */
5044 must_check_value
= 1;
5046 if (must_check_value
)
5052 e
= watchpoint_check (bs
);
5054 CATCH (ex
, RETURN_MASK_ALL
)
5056 exception_fprintf (gdb_stderr
, ex
,
5057 "Error evaluating expression "
5058 "for watchpoint %d\n",
5061 SWITCH_THRU_ALL_UIS ()
5063 printf_filtered (_("Watchpoint %d deleted.\n"),
5066 watchpoint_del_at_next_stop (b
);
5074 /* We've already printed what needs to be printed. */
5075 bs
->print_it
= print_it_done
;
5079 bs
->print_it
= print_it_noop
;
5082 case WP_VALUE_CHANGED
:
5083 if (b
->type
== bp_read_watchpoint
)
5085 /* There are two cases to consider here:
5087 1. We're watching the triggered memory for reads.
5088 In that case, trust the target, and always report
5089 the watchpoint hit to the user. Even though
5090 reads don't cause value changes, the value may
5091 have changed since the last time it was read, and
5092 since we're not trapping writes, we will not see
5093 those, and as such we should ignore our notion of
5096 2. We're watching the triggered memory for both
5097 reads and writes. There are two ways this may
5100 2.1. This is a target that can't break on data
5101 reads only, but can break on accesses (reads or
5102 writes), such as e.g., x86. We detect this case
5103 at the time we try to insert read watchpoints.
5105 2.2. Otherwise, the target supports read
5106 watchpoints, but, the user set an access or write
5107 watchpoint watching the same memory as this read
5110 If we're watching memory writes as well as reads,
5111 ignore watchpoint hits when we find that the
5112 value hasn't changed, as reads don't cause
5113 changes. This still gives false positives when
5114 the program writes the same value to memory as
5115 what there was already in memory (we will confuse
5116 it for a read), but it's much better than
5119 int other_write_watchpoint
= 0;
5121 if (bl
->watchpoint_type
== hw_read
)
5123 struct breakpoint
*other_b
;
5125 ALL_BREAKPOINTS (other_b
)
5126 if (other_b
->type
== bp_hardware_watchpoint
5127 || other_b
->type
== bp_access_watchpoint
)
5129 struct watchpoint
*other_w
=
5130 (struct watchpoint
*) other_b
;
5132 if (other_w
->watchpoint_triggered
5133 == watch_triggered_yes
)
5135 other_write_watchpoint
= 1;
5141 if (other_write_watchpoint
5142 || bl
->watchpoint_type
== hw_access
)
5144 /* We're watching the same memory for writes,
5145 and the value changed since the last time we
5146 updated it, so this trap must be for a write.
5148 bs
->print_it
= print_it_noop
;
5153 case WP_VALUE_NOT_CHANGED
:
5154 if (b
->type
== bp_hardware_watchpoint
5155 || b
->type
== bp_watchpoint
)
5157 /* Don't stop: write watchpoints shouldn't fire if
5158 the value hasn't changed. */
5159 bs
->print_it
= print_it_noop
;
5169 else /* must_check_value == 0 */
5171 /* This is a case where some watchpoint(s) triggered, but
5172 not at the address of this watchpoint, or else no
5173 watchpoint triggered after all. So don't print
5174 anything for this watchpoint. */
5175 bs
->print_it
= print_it_noop
;
5181 /* For breakpoints that are currently marked as telling gdb to stop,
5182 check conditions (condition proper, frame, thread and ignore count)
5183 of breakpoint referred to by BS. If we should not stop for this
5184 breakpoint, set BS->stop to 0. */
5187 bpstat_check_breakpoint_conditions (bpstat bs
, ptid_t ptid
)
5189 const struct bp_location
*bl
;
5190 struct breakpoint
*b
;
5192 bool condition_result
= true;
5193 struct expression
*cond
;
5195 gdb_assert (bs
->stop
);
5197 /* BS is built for existing struct breakpoint. */
5198 bl
= bs
->bp_location_at
;
5199 gdb_assert (bl
!= NULL
);
5200 b
= bs
->breakpoint_at
;
5201 gdb_assert (b
!= NULL
);
5203 /* Even if the target evaluated the condition on its end and notified GDB, we
5204 need to do so again since GDB does not know if we stopped due to a
5205 breakpoint or a single step breakpoint. */
5207 if (frame_id_p (b
->frame_id
)
5208 && !frame_id_eq (b
->frame_id
, get_stack_frame_id (get_current_frame ())))
5214 /* If this is a thread/task-specific breakpoint, don't waste cpu
5215 evaluating the condition if this isn't the specified
5217 if ((b
->thread
!= -1 && b
->thread
!= ptid_to_global_thread_id (ptid
))
5218 || (b
->task
!= 0 && b
->task
!= ada_get_task_number (ptid
)))
5225 /* Evaluate extension language breakpoints that have a "stop" method
5227 bs
->stop
= breakpoint_ext_lang_cond_says_stop (b
);
5229 if (is_watchpoint (b
))
5231 struct watchpoint
*w
= (struct watchpoint
*) b
;
5233 cond
= w
->cond_exp
.get ();
5236 cond
= bl
->cond
.get ();
5238 if (cond
&& b
->disposition
!= disp_del_at_next_stop
)
5240 int within_current_scope
= 1;
5241 struct watchpoint
* w
;
5243 /* We use value_mark and value_free_to_mark because it could
5244 be a long time before we return to the command level and
5245 call free_all_values. We can't call free_all_values
5246 because we might be in the middle of evaluating a
5248 struct value
*mark
= value_mark ();
5250 if (is_watchpoint (b
))
5251 w
= (struct watchpoint
*) b
;
5255 /* Need to select the frame, with all that implies so that
5256 the conditions will have the right context. Because we
5257 use the frame, we will not see an inlined function's
5258 variables when we arrive at a breakpoint at the start
5259 of the inlined function; the current frame will be the
5261 if (w
== NULL
|| w
->cond_exp_valid_block
== NULL
)
5262 select_frame (get_current_frame ());
5265 struct frame_info
*frame
;
5267 /* For local watchpoint expressions, which particular
5268 instance of a local is being watched matters, so we
5269 keep track of the frame to evaluate the expression
5270 in. To evaluate the condition however, it doesn't
5271 really matter which instantiation of the function
5272 where the condition makes sense triggers the
5273 watchpoint. This allows an expression like "watch
5274 global if q > 10" set in `func', catch writes to
5275 global on all threads that call `func', or catch
5276 writes on all recursive calls of `func' by a single
5277 thread. We simply always evaluate the condition in
5278 the innermost frame that's executing where it makes
5279 sense to evaluate the condition. It seems
5281 frame
= block_innermost_frame (w
->cond_exp_valid_block
);
5283 select_frame (frame
);
5285 within_current_scope
= 0;
5287 if (within_current_scope
)
5291 condition_result
= breakpoint_cond_eval (cond
);
5293 CATCH (ex
, RETURN_MASK_ALL
)
5295 exception_fprintf (gdb_stderr
, ex
,
5296 "Error in testing breakpoint condition:\n");
5302 warning (_("Watchpoint condition cannot be tested "
5303 "in the current scope"));
5304 /* If we failed to set the right context for this
5305 watchpoint, unconditionally report it. */
5307 /* FIXME-someday, should give breakpoint #. */
5308 value_free_to_mark (mark
);
5311 if (cond
&& !condition_result
)
5315 else if (b
->ignore_count
> 0)
5319 /* Increase the hit count even though we don't stop. */
5321 gdb::observers::breakpoint_modified
.notify (b
);
5325 /* Returns true if we need to track moribund locations of LOC's type
5326 on the current target. */
5329 need_moribund_for_location_type (struct bp_location
*loc
)
5331 return ((loc
->loc_type
== bp_loc_software_breakpoint
5332 && !target_supports_stopped_by_sw_breakpoint ())
5333 || (loc
->loc_type
== bp_loc_hardware_breakpoint
5334 && !target_supports_stopped_by_hw_breakpoint ()));
5338 /* Get a bpstat associated with having just stopped at address
5339 BP_ADDR in thread PTID.
5341 Determine whether we stopped at a breakpoint, etc, or whether we
5342 don't understand this stop. Result is a chain of bpstat's such
5345 if we don't understand the stop, the result is a null pointer.
5347 if we understand why we stopped, the result is not null.
5349 Each element of the chain refers to a particular breakpoint or
5350 watchpoint at which we have stopped. (We may have stopped for
5351 several reasons concurrently.)
5353 Each element of the chain has valid next, breakpoint_at,
5354 commands, FIXME??? fields. */
5357 bpstat_stop_status (const address_space
*aspace
,
5358 CORE_ADDR bp_addr
, ptid_t ptid
,
5359 const struct target_waitstatus
*ws
)
5361 struct breakpoint
*b
= NULL
;
5362 struct bp_location
*bl
;
5363 struct bp_location
*loc
;
5364 /* First item of allocated bpstat's. */
5365 bpstat bs_head
= NULL
, *bs_link
= &bs_head
;
5366 /* Pointer to the last thing in the chain currently. */
5369 int need_remove_insert
;
5372 /* First, build the bpstat chain with locations that explain a
5373 target stop, while being careful to not set the target running,
5374 as that may invalidate locations (in particular watchpoint
5375 locations are recreated). Resuming will happen here with
5376 breakpoint conditions or watchpoint expressions that include
5377 inferior function calls. */
5381 if (!breakpoint_enabled (b
))
5384 for (bl
= b
->loc
; bl
!= NULL
; bl
= bl
->next
)
5386 /* For hardware watchpoints, we look only at the first
5387 location. The watchpoint_check function will work on the
5388 entire expression, not the individual locations. For
5389 read watchpoints, the watchpoints_triggered function has
5390 checked all locations already. */
5391 if (b
->type
== bp_hardware_watchpoint
&& bl
!= b
->loc
)
5394 if (!bl
->enabled
|| bl
->shlib_disabled
)
5397 if (!bpstat_check_location (bl
, aspace
, bp_addr
, ws
))
5400 /* Come here if it's a watchpoint, or if the break address
5403 bs
= new bpstats (bl
, &bs_link
); /* Alloc a bpstat to
5406 /* Assume we stop. Should we find a watchpoint that is not
5407 actually triggered, or if the condition of the breakpoint
5408 evaluates as false, we'll reset 'stop' to 0. */
5412 /* If this is a scope breakpoint, mark the associated
5413 watchpoint as triggered so that we will handle the
5414 out-of-scope event. We'll get to the watchpoint next
5416 if (b
->type
== bp_watchpoint_scope
&& b
->related_breakpoint
!= b
)
5418 struct watchpoint
*w
= (struct watchpoint
*) b
->related_breakpoint
;
5420 w
->watchpoint_triggered
= watch_triggered_yes
;
5425 /* Check if a moribund breakpoint explains the stop. */
5426 if (!target_supports_stopped_by_sw_breakpoint ()
5427 || !target_supports_stopped_by_hw_breakpoint ())
5429 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
5431 if (breakpoint_location_address_match (loc
, aspace
, bp_addr
)
5432 && need_moribund_for_location_type (loc
))
5434 bs
= new bpstats (loc
, &bs_link
);
5435 /* For hits of moribund locations, we should just proceed. */
5438 bs
->print_it
= print_it_noop
;
5443 /* A bit of special processing for shlib breakpoints. We need to
5444 process solib loading here, so that the lists of loaded and
5445 unloaded libraries are correct before we handle "catch load" and
5447 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5449 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->type
== bp_shlib_event
)
5451 handle_solib_event ();
5456 /* Now go through the locations that caused the target to stop, and
5457 check whether we're interested in reporting this stop to higher
5458 layers, or whether we should resume the target transparently. */
5462 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5467 b
= bs
->breakpoint_at
;
5468 b
->ops
->check_status (bs
);
5471 bpstat_check_breakpoint_conditions (bs
, ptid
);
5476 gdb::observers::breakpoint_modified
.notify (b
);
5478 /* We will stop here. */
5479 if (b
->disposition
== disp_disable
)
5481 --(b
->enable_count
);
5482 if (b
->enable_count
<= 0)
5483 b
->enable_state
= bp_disabled
;
5488 bs
->commands
= b
->commands
;
5489 if (command_line_is_silent (bs
->commands
5490 ? bs
->commands
.get () : NULL
))
5493 b
->ops
->after_condition_true (bs
);
5498 /* Print nothing for this entry if we don't stop or don't
5500 if (!bs
->stop
|| !bs
->print
)
5501 bs
->print_it
= print_it_noop
;
5504 /* If we aren't stopping, the value of some hardware watchpoint may
5505 not have changed, but the intermediate memory locations we are
5506 watching may have. Don't bother if we're stopping; this will get
5508 need_remove_insert
= 0;
5509 if (! bpstat_causes_stop (bs_head
))
5510 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5512 && bs
->breakpoint_at
5513 && is_hardware_watchpoint (bs
->breakpoint_at
))
5515 struct watchpoint
*w
= (struct watchpoint
*) bs
->breakpoint_at
;
5517 update_watchpoint (w
, 0 /* don't reparse. */);
5518 need_remove_insert
= 1;
5521 if (need_remove_insert
)
5522 update_global_location_list (UGLL_MAY_INSERT
);
5523 else if (removed_any
)
5524 update_global_location_list (UGLL_DONT_INSERT
);
5530 handle_jit_event (void)
5532 struct frame_info
*frame
;
5533 struct gdbarch
*gdbarch
;
5536 fprintf_unfiltered (gdb_stdlog
, "handling bp_jit_event\n");
5538 /* Switch terminal for any messages produced by
5539 breakpoint_re_set. */
5540 target_terminal::ours_for_output ();
5542 frame
= get_current_frame ();
5543 gdbarch
= get_frame_arch (frame
);
5545 jit_event_handler (gdbarch
);
5547 target_terminal::inferior ();
5550 /* Prepare WHAT final decision for infrun. */
5552 /* Decide what infrun needs to do with this bpstat. */
5555 bpstat_what (bpstat bs_head
)
5557 struct bpstat_what retval
;
5560 retval
.main_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5561 retval
.call_dummy
= STOP_NONE
;
5562 retval
.is_longjmp
= 0;
5564 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5566 /* Extract this BS's action. After processing each BS, we check
5567 if its action overrides all we've seem so far. */
5568 enum bpstat_what_main_action this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5571 if (bs
->breakpoint_at
== NULL
)
5573 /* I suspect this can happen if it was a momentary
5574 breakpoint which has since been deleted. */
5578 bptype
= bs
->breakpoint_at
->type
;
5585 case bp_hardware_breakpoint
:
5586 case bp_single_step
:
5589 case bp_shlib_event
:
5593 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5595 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5598 this_action
= BPSTAT_WHAT_SINGLE
;
5601 case bp_hardware_watchpoint
:
5602 case bp_read_watchpoint
:
5603 case bp_access_watchpoint
:
5607 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5609 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5613 /* There was a watchpoint, but we're not stopping.
5614 This requires no further action. */
5618 case bp_longjmp_call_dummy
:
5622 this_action
= BPSTAT_WHAT_SET_LONGJMP_RESUME
;
5623 retval
.is_longjmp
= bptype
!= bp_exception
;
5626 this_action
= BPSTAT_WHAT_SINGLE
;
5628 case bp_longjmp_resume
:
5629 case bp_exception_resume
:
5632 this_action
= BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
;
5633 retval
.is_longjmp
= bptype
== bp_longjmp_resume
;
5636 this_action
= BPSTAT_WHAT_SINGLE
;
5638 case bp_step_resume
:
5640 this_action
= BPSTAT_WHAT_STEP_RESUME
;
5643 /* It is for the wrong frame. */
5644 this_action
= BPSTAT_WHAT_SINGLE
;
5647 case bp_hp_step_resume
:
5649 this_action
= BPSTAT_WHAT_HP_STEP_RESUME
;
5652 /* It is for the wrong frame. */
5653 this_action
= BPSTAT_WHAT_SINGLE
;
5656 case bp_watchpoint_scope
:
5657 case bp_thread_event
:
5658 case bp_overlay_event
:
5659 case bp_longjmp_master
:
5660 case bp_std_terminate_master
:
5661 case bp_exception_master
:
5662 this_action
= BPSTAT_WHAT_SINGLE
;
5668 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5670 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5674 /* There was a catchpoint, but we're not stopping.
5675 This requires no further action. */
5679 this_action
= BPSTAT_WHAT_SINGLE
;
5682 /* Make sure the action is stop (silent or noisy),
5683 so infrun.c pops the dummy frame. */
5684 retval
.call_dummy
= STOP_STACK_DUMMY
;
5685 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5687 case bp_std_terminate
:
5688 /* Make sure the action is stop (silent or noisy),
5689 so infrun.c pops the dummy frame. */
5690 retval
.call_dummy
= STOP_STD_TERMINATE
;
5691 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5694 case bp_fast_tracepoint
:
5695 case bp_static_tracepoint
:
5696 /* Tracepoint hits should not be reported back to GDB, and
5697 if one got through somehow, it should have been filtered
5699 internal_error (__FILE__
, __LINE__
,
5700 _("bpstat_what: tracepoint encountered"));
5702 case bp_gnu_ifunc_resolver
:
5703 /* Step over it (and insert bp_gnu_ifunc_resolver_return). */
5704 this_action
= BPSTAT_WHAT_SINGLE
;
5706 case bp_gnu_ifunc_resolver_return
:
5707 /* The breakpoint will be removed, execution will restart from the
5708 PC of the former breakpoint. */
5709 this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5714 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5716 this_action
= BPSTAT_WHAT_SINGLE
;
5720 internal_error (__FILE__
, __LINE__
,
5721 _("bpstat_what: unhandled bptype %d"), (int) bptype
);
5724 retval
.main_action
= std::max (retval
.main_action
, this_action
);
5731 bpstat_run_callbacks (bpstat bs_head
)
5735 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5737 struct breakpoint
*b
= bs
->breakpoint_at
;
5744 handle_jit_event ();
5746 case bp_gnu_ifunc_resolver
:
5747 gnu_ifunc_resolver_stop (b
);
5749 case bp_gnu_ifunc_resolver_return
:
5750 gnu_ifunc_resolver_return_stop (b
);
5756 /* Nonzero if we should step constantly (e.g. watchpoints on machines
5757 without hardware support). This isn't related to a specific bpstat,
5758 just to things like whether watchpoints are set. */
5761 bpstat_should_step (void)
5763 struct breakpoint
*b
;
5766 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
&& b
->loc
!= NULL
)
5772 bpstat_causes_stop (bpstat bs
)
5774 for (; bs
!= NULL
; bs
= bs
->next
)
5783 /* Compute a string of spaces suitable to indent the next line
5784 so it starts at the position corresponding to the table column
5785 named COL_NAME in the currently active table of UIOUT. */
5788 wrap_indent_at_field (struct ui_out
*uiout
, const char *col_name
)
5790 static char wrap_indent
[80];
5791 int i
, total_width
, width
, align
;
5795 for (i
= 1; uiout
->query_table_field (i
, &width
, &align
, &text
); i
++)
5797 if (strcmp (text
, col_name
) == 0)
5799 gdb_assert (total_width
< sizeof wrap_indent
);
5800 memset (wrap_indent
, ' ', total_width
);
5801 wrap_indent
[total_width
] = 0;
5806 total_width
+= width
+ 1;
5812 /* Determine if the locations of this breakpoint will have their conditions
5813 evaluated by the target, host or a mix of both. Returns the following:
5815 "host": Host evals condition.
5816 "host or target": Host or Target evals condition.
5817 "target": Target evals condition.
5821 bp_condition_evaluator (struct breakpoint
*b
)
5823 struct bp_location
*bl
;
5824 char host_evals
= 0;
5825 char target_evals
= 0;
5830 if (!is_breakpoint (b
))
5833 if (gdb_evaluates_breakpoint_condition_p ()
5834 || !target_supports_evaluation_of_breakpoint_conditions ())
5835 return condition_evaluation_host
;
5837 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
5839 if (bl
->cond_bytecode
)
5845 if (host_evals
&& target_evals
)
5846 return condition_evaluation_both
;
5847 else if (target_evals
)
5848 return condition_evaluation_target
;
5850 return condition_evaluation_host
;
5853 /* Determine the breakpoint location's condition evaluator. This is
5854 similar to bp_condition_evaluator, but for locations. */
5857 bp_location_condition_evaluator (struct bp_location
*bl
)
5859 if (bl
&& !is_breakpoint (bl
->owner
))
5862 if (gdb_evaluates_breakpoint_condition_p ()
5863 || !target_supports_evaluation_of_breakpoint_conditions ())
5864 return condition_evaluation_host
;
5866 if (bl
&& bl
->cond_bytecode
)
5867 return condition_evaluation_target
;
5869 return condition_evaluation_host
;
5872 /* Print the LOC location out of the list of B->LOC locations. */
5875 print_breakpoint_location (struct breakpoint
*b
,
5876 struct bp_location
*loc
)
5878 struct ui_out
*uiout
= current_uiout
;
5880 scoped_restore_current_program_space restore_pspace
;
5882 if (loc
!= NULL
&& loc
->shlib_disabled
)
5886 set_current_program_space (loc
->pspace
);
5888 if (b
->display_canonical
)
5889 uiout
->field_string ("what", event_location_to_string (b
->location
.get ()));
5890 else if (loc
&& loc
->symtab
)
5892 const struct symbol
*sym
= loc
->symbol
;
5895 sym
= find_pc_sect_function (loc
->address
, loc
->section
);
5899 uiout
->text ("in ");
5900 uiout
->field_string ("func", SYMBOL_PRINT_NAME (sym
));
5902 uiout
->wrap_hint (wrap_indent_at_field (uiout
, "what"));
5903 uiout
->text ("at ");
5905 uiout
->field_string ("file",
5906 symtab_to_filename_for_display (loc
->symtab
));
5909 if (uiout
->is_mi_like_p ())
5910 uiout
->field_string ("fullname", symtab_to_fullname (loc
->symtab
));
5912 uiout
->field_int ("line", loc
->line_number
);
5918 print_address_symbolic (loc
->gdbarch
, loc
->address
, &stb
,
5920 uiout
->field_stream ("at", stb
);
5924 uiout
->field_string ("pending",
5925 event_location_to_string (b
->location
.get ()));
5926 /* If extra_string is available, it could be holding a condition
5927 or dprintf arguments. In either case, make sure it is printed,
5928 too, but only for non-MI streams. */
5929 if (!uiout
->is_mi_like_p () && b
->extra_string
!= NULL
)
5931 if (b
->type
== bp_dprintf
)
5935 uiout
->text (b
->extra_string
);
5939 if (loc
&& is_breakpoint (b
)
5940 && breakpoint_condition_evaluation_mode () == condition_evaluation_target
5941 && bp_condition_evaluator (b
) == condition_evaluation_both
)
5944 uiout
->field_string ("evaluated-by",
5945 bp_location_condition_evaluator (loc
));
5951 bptype_string (enum bptype type
)
5953 struct ep_type_description
5956 const char *description
;
5958 static struct ep_type_description bptypes
[] =
5960 {bp_none
, "?deleted?"},
5961 {bp_breakpoint
, "breakpoint"},
5962 {bp_hardware_breakpoint
, "hw breakpoint"},
5963 {bp_single_step
, "sw single-step"},
5964 {bp_until
, "until"},
5965 {bp_finish
, "finish"},
5966 {bp_watchpoint
, "watchpoint"},
5967 {bp_hardware_watchpoint
, "hw watchpoint"},
5968 {bp_read_watchpoint
, "read watchpoint"},
5969 {bp_access_watchpoint
, "acc watchpoint"},
5970 {bp_longjmp
, "longjmp"},
5971 {bp_longjmp_resume
, "longjmp resume"},
5972 {bp_longjmp_call_dummy
, "longjmp for call dummy"},
5973 {bp_exception
, "exception"},
5974 {bp_exception_resume
, "exception resume"},
5975 {bp_step_resume
, "step resume"},
5976 {bp_hp_step_resume
, "high-priority step resume"},
5977 {bp_watchpoint_scope
, "watchpoint scope"},
5978 {bp_call_dummy
, "call dummy"},
5979 {bp_std_terminate
, "std::terminate"},
5980 {bp_shlib_event
, "shlib events"},
5981 {bp_thread_event
, "thread events"},
5982 {bp_overlay_event
, "overlay events"},
5983 {bp_longjmp_master
, "longjmp master"},
5984 {bp_std_terminate_master
, "std::terminate master"},
5985 {bp_exception_master
, "exception master"},
5986 {bp_catchpoint
, "catchpoint"},
5987 {bp_tracepoint
, "tracepoint"},
5988 {bp_fast_tracepoint
, "fast tracepoint"},
5989 {bp_static_tracepoint
, "static tracepoint"},
5990 {bp_dprintf
, "dprintf"},
5991 {bp_jit_event
, "jit events"},
5992 {bp_gnu_ifunc_resolver
, "STT_GNU_IFUNC resolver"},
5993 {bp_gnu_ifunc_resolver_return
, "STT_GNU_IFUNC resolver return"},
5996 if (((int) type
>= (sizeof (bptypes
) / sizeof (bptypes
[0])))
5997 || ((int) type
!= bptypes
[(int) type
].type
))
5998 internal_error (__FILE__
, __LINE__
,
5999 _("bptypes table does not describe type #%d."),
6002 return bptypes
[(int) type
].description
;
6005 /* For MI, output a field named 'thread-groups' with a list as the value.
6006 For CLI, prefix the list with the string 'inf'. */
6009 output_thread_groups (struct ui_out
*uiout
,
6010 const char *field_name
,
6011 const std::vector
<int> &inf_nums
,
6014 int is_mi
= uiout
->is_mi_like_p ();
6016 /* For backward compatibility, don't display inferiors in CLI unless
6017 there are several. Always display them for MI. */
6018 if (!is_mi
&& mi_only
)
6021 ui_out_emit_list
list_emitter (uiout
, field_name
);
6023 for (size_t i
= 0; i
< inf_nums
.size (); i
++)
6029 xsnprintf (mi_group
, sizeof (mi_group
), "i%d", inf_nums
[i
]);
6030 uiout
->field_string (NULL
, mi_group
);
6035 uiout
->text (" inf ");
6039 uiout
->text (plongest (inf_nums
[i
]));
6044 /* Print B to gdb_stdout. */
6047 print_one_breakpoint_location (struct breakpoint
*b
,
6048 struct bp_location
*loc
,
6050 struct bp_location
**last_loc
,
6053 struct command_line
*l
;
6054 static char bpenables
[] = "nynny";
6056 struct ui_out
*uiout
= current_uiout
;
6057 int header_of_multiple
= 0;
6058 int part_of_multiple
= (loc
!= NULL
);
6059 struct value_print_options opts
;
6061 get_user_print_options (&opts
);
6063 gdb_assert (!loc
|| loc_number
!= 0);
6064 /* See comment in print_one_breakpoint concerning treatment of
6065 breakpoints with single disabled location. */
6068 && (b
->loc
->next
!= NULL
|| !b
->loc
->enabled
)))
6069 header_of_multiple
= 1;
6077 if (part_of_multiple
)
6080 formatted
= xstrprintf ("%d.%d", b
->number
, loc_number
);
6081 uiout
->field_string ("number", formatted
);
6086 uiout
->field_int ("number", b
->number
);
6091 if (part_of_multiple
)
6092 uiout
->field_skip ("type");
6094 uiout
->field_string ("type", bptype_string (b
->type
));
6098 if (part_of_multiple
)
6099 uiout
->field_skip ("disp");
6101 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
6106 if (part_of_multiple
)
6107 uiout
->field_string ("enabled", loc
->enabled
? "y" : "n");
6109 uiout
->field_fmt ("enabled", "%c", bpenables
[(int) b
->enable_state
]);
6114 if (b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
6116 /* Although the print_one can possibly print all locations,
6117 calling it here is not likely to get any nice result. So,
6118 make sure there's just one location. */
6119 gdb_assert (b
->loc
== NULL
|| b
->loc
->next
== NULL
);
6120 b
->ops
->print_one (b
, last_loc
);
6126 internal_error (__FILE__
, __LINE__
,
6127 _("print_one_breakpoint: bp_none encountered\n"));
6131 case bp_hardware_watchpoint
:
6132 case bp_read_watchpoint
:
6133 case bp_access_watchpoint
:
6135 struct watchpoint
*w
= (struct watchpoint
*) b
;
6137 /* Field 4, the address, is omitted (which makes the columns
6138 not line up too nicely with the headers, but the effect
6139 is relatively readable). */
6140 if (opts
.addressprint
)
6141 uiout
->field_skip ("addr");
6143 uiout
->field_string ("what", w
->exp_string
);
6148 case bp_hardware_breakpoint
:
6149 case bp_single_step
:
6153 case bp_longjmp_resume
:
6154 case bp_longjmp_call_dummy
:
6156 case bp_exception_resume
:
6157 case bp_step_resume
:
6158 case bp_hp_step_resume
:
6159 case bp_watchpoint_scope
:
6161 case bp_std_terminate
:
6162 case bp_shlib_event
:
6163 case bp_thread_event
:
6164 case bp_overlay_event
:
6165 case bp_longjmp_master
:
6166 case bp_std_terminate_master
:
6167 case bp_exception_master
:
6169 case bp_fast_tracepoint
:
6170 case bp_static_tracepoint
:
6173 case bp_gnu_ifunc_resolver
:
6174 case bp_gnu_ifunc_resolver_return
:
6175 if (opts
.addressprint
)
6178 if (header_of_multiple
)
6179 uiout
->field_string ("addr", "<MULTIPLE>");
6180 else if (b
->loc
== NULL
|| loc
->shlib_disabled
)
6181 uiout
->field_string ("addr", "<PENDING>");
6183 uiout
->field_core_addr ("addr",
6184 loc
->gdbarch
, loc
->address
);
6187 if (!header_of_multiple
)
6188 print_breakpoint_location (b
, loc
);
6195 if (loc
!= NULL
&& !header_of_multiple
)
6197 struct inferior
*inf
;
6198 std::vector
<int> inf_nums
;
6203 if (inf
->pspace
== loc
->pspace
)
6204 inf_nums
.push_back (inf
->num
);
6207 /* For backward compatibility, don't display inferiors in CLI unless
6208 there are several. Always display for MI. */
6210 || (!gdbarch_has_global_breakpoints (target_gdbarch ())
6211 && (number_of_program_spaces () > 1
6212 || number_of_inferiors () > 1)
6213 /* LOC is for existing B, it cannot be in
6214 moribund_locations and thus having NULL OWNER. */
6215 && loc
->owner
->type
!= bp_catchpoint
))
6217 output_thread_groups (uiout
, "thread-groups", inf_nums
, mi_only
);
6220 if (!part_of_multiple
)
6222 if (b
->thread
!= -1)
6224 /* FIXME: This seems to be redundant and lost here; see the
6225 "stop only in" line a little further down. */
6226 uiout
->text (" thread ");
6227 uiout
->field_int ("thread", b
->thread
);
6229 else if (b
->task
!= 0)
6231 uiout
->text (" task ");
6232 uiout
->field_int ("task", b
->task
);
6238 if (!part_of_multiple
)
6239 b
->ops
->print_one_detail (b
, uiout
);
6241 if (part_of_multiple
&& frame_id_p (b
->frame_id
))
6244 uiout
->text ("\tstop only in stack frame at ");
6245 /* FIXME: cagney/2002-12-01: Shouldn't be poking around inside
6247 uiout
->field_core_addr ("frame",
6248 b
->gdbarch
, b
->frame_id
.stack_addr
);
6252 if (!part_of_multiple
&& b
->cond_string
)
6255 if (is_tracepoint (b
))
6256 uiout
->text ("\ttrace only if ");
6258 uiout
->text ("\tstop only if ");
6259 uiout
->field_string ("cond", b
->cond_string
);
6261 /* Print whether the target is doing the breakpoint's condition
6262 evaluation. If GDB is doing the evaluation, don't print anything. */
6263 if (is_breakpoint (b
)
6264 && breakpoint_condition_evaluation_mode ()
6265 == condition_evaluation_target
)
6268 uiout
->field_string ("evaluated-by",
6269 bp_condition_evaluator (b
));
6270 uiout
->text (" evals)");
6275 if (!part_of_multiple
&& b
->thread
!= -1)
6277 /* FIXME should make an annotation for this. */
6278 uiout
->text ("\tstop only in thread ");
6279 if (uiout
->is_mi_like_p ())
6280 uiout
->field_int ("thread", b
->thread
);
6283 struct thread_info
*thr
= find_thread_global_id (b
->thread
);
6285 uiout
->field_string ("thread", print_thread_id (thr
));
6290 if (!part_of_multiple
)
6294 /* FIXME should make an annotation for this. */
6295 if (is_catchpoint (b
))
6296 uiout
->text ("\tcatchpoint");
6297 else if (is_tracepoint (b
))
6298 uiout
->text ("\ttracepoint");
6300 uiout
->text ("\tbreakpoint");
6301 uiout
->text (" already hit ");
6302 uiout
->field_int ("times", b
->hit_count
);
6303 if (b
->hit_count
== 1)
6304 uiout
->text (" time\n");
6306 uiout
->text (" times\n");
6310 /* Output the count also if it is zero, but only if this is mi. */
6311 if (uiout
->is_mi_like_p ())
6312 uiout
->field_int ("times", b
->hit_count
);
6316 if (!part_of_multiple
&& b
->ignore_count
)
6319 uiout
->text ("\tignore next ");
6320 uiout
->field_int ("ignore", b
->ignore_count
);
6321 uiout
->text (" hits\n");
6324 /* Note that an enable count of 1 corresponds to "enable once"
6325 behavior, which is reported by the combination of enablement and
6326 disposition, so we don't need to mention it here. */
6327 if (!part_of_multiple
&& b
->enable_count
> 1)
6330 uiout
->text ("\tdisable after ");
6331 /* Tweak the wording to clarify that ignore and enable counts
6332 are distinct, and have additive effect. */
6333 if (b
->ignore_count
)
6334 uiout
->text ("additional ");
6336 uiout
->text ("next ");
6337 uiout
->field_int ("enable", b
->enable_count
);
6338 uiout
->text (" hits\n");
6341 if (!part_of_multiple
&& is_tracepoint (b
))
6343 struct tracepoint
*tp
= (struct tracepoint
*) b
;
6345 if (tp
->traceframe_usage
)
6347 uiout
->text ("\ttrace buffer usage ");
6348 uiout
->field_int ("traceframe-usage", tp
->traceframe_usage
);
6349 uiout
->text (" bytes\n");
6353 l
= b
->commands
? b
->commands
.get () : NULL
;
6354 if (!part_of_multiple
&& l
)
6357 ui_out_emit_tuple
tuple_emitter (uiout
, "script");
6358 print_command_lines (uiout
, l
, 4);
6361 if (is_tracepoint (b
))
6363 struct tracepoint
*t
= (struct tracepoint
*) b
;
6365 if (!part_of_multiple
&& t
->pass_count
)
6367 annotate_field (10);
6368 uiout
->text ("\tpass count ");
6369 uiout
->field_int ("pass", t
->pass_count
);
6370 uiout
->text (" \n");
6373 /* Don't display it when tracepoint or tracepoint location is
6375 if (!header_of_multiple
&& loc
!= NULL
&& !loc
->shlib_disabled
)
6377 annotate_field (11);
6379 if (uiout
->is_mi_like_p ())
6380 uiout
->field_string ("installed",
6381 loc
->inserted
? "y" : "n");
6387 uiout
->text ("\tnot ");
6388 uiout
->text ("installed on target\n");
6393 if (uiout
->is_mi_like_p () && !part_of_multiple
)
6395 if (is_watchpoint (b
))
6397 struct watchpoint
*w
= (struct watchpoint
*) b
;
6399 uiout
->field_string ("original-location", w
->exp_string
);
6401 else if (b
->location
!= NULL
6402 && event_location_to_string (b
->location
.get ()) != NULL
)
6403 uiout
->field_string ("original-location",
6404 event_location_to_string (b
->location
.get ()));
6409 print_one_breakpoint (struct breakpoint
*b
,
6410 struct bp_location
**last_loc
,
6413 struct ui_out
*uiout
= current_uiout
;
6416 ui_out_emit_tuple
tuple_emitter (uiout
, "bkpt");
6418 print_one_breakpoint_location (b
, NULL
, 0, last_loc
, allflag
);
6421 /* If this breakpoint has custom print function,
6422 it's already printed. Otherwise, print individual
6423 locations, if any. */
6424 if (b
->ops
== NULL
|| b
->ops
->print_one
== NULL
)
6426 /* If breakpoint has a single location that is disabled, we
6427 print it as if it had several locations, since otherwise it's
6428 hard to represent "breakpoint enabled, location disabled"
6431 Note that while hardware watchpoints have several locations
6432 internally, that's not a property exposed to user. */
6434 && !is_hardware_watchpoint (b
)
6435 && (b
->loc
->next
|| !b
->loc
->enabled
))
6437 struct bp_location
*loc
;
6440 for (loc
= b
->loc
; loc
; loc
= loc
->next
, ++n
)
6442 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
6443 print_one_breakpoint_location (b
, loc
, n
, last_loc
, allflag
);
6450 breakpoint_address_bits (struct breakpoint
*b
)
6452 int print_address_bits
= 0;
6453 struct bp_location
*loc
;
6455 /* Software watchpoints that aren't watching memory don't have an
6456 address to print. */
6457 if (is_no_memory_software_watchpoint (b
))
6460 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
6464 addr_bit
= gdbarch_addr_bit (loc
->gdbarch
);
6465 if (addr_bit
> print_address_bits
)
6466 print_address_bits
= addr_bit
;
6469 return print_address_bits
;
6472 /* See breakpoint.h. */
6475 print_breakpoint (breakpoint
*b
)
6477 struct bp_location
*dummy_loc
= NULL
;
6478 print_one_breakpoint (b
, &dummy_loc
, 0);
6481 /* Return true if this breakpoint was set by the user, false if it is
6482 internal or momentary. */
6485 user_breakpoint_p (struct breakpoint
*b
)
6487 return b
->number
> 0;
6490 /* See breakpoint.h. */
6493 pending_breakpoint_p (struct breakpoint
*b
)
6495 return b
->loc
== NULL
;
6498 /* Print information on user settable breakpoint (watchpoint, etc)
6499 number BNUM. If BNUM is -1 print all user-settable breakpoints.
6500 If ALLFLAG is non-zero, include non-user-settable breakpoints. If
6501 FILTER is non-NULL, call it on each breakpoint and only include the
6502 ones for which it returns non-zero. Return the total number of
6503 breakpoints listed. */
6506 breakpoint_1 (const char *args
, int allflag
,
6507 int (*filter
) (const struct breakpoint
*))
6509 struct breakpoint
*b
;
6510 struct bp_location
*last_loc
= NULL
;
6511 int nr_printable_breakpoints
;
6512 struct value_print_options opts
;
6513 int print_address_bits
= 0;
6514 int print_type_col_width
= 14;
6515 struct ui_out
*uiout
= current_uiout
;
6517 get_user_print_options (&opts
);
6519 /* Compute the number of rows in the table, as well as the size
6520 required for address fields. */
6521 nr_printable_breakpoints
= 0;
6524 /* If we have a filter, only list the breakpoints it accepts. */
6525 if (filter
&& !filter (b
))
6528 /* If we have an "args" string, it is a list of breakpoints to
6529 accept. Skip the others. */
6530 if (args
!= NULL
&& *args
!= '\0')
6532 if (allflag
&& parse_and_eval_long (args
) != b
->number
)
6534 if (!allflag
&& !number_is_in_list (args
, b
->number
))
6538 if (allflag
|| user_breakpoint_p (b
))
6540 int addr_bit
, type_len
;
6542 addr_bit
= breakpoint_address_bits (b
);
6543 if (addr_bit
> print_address_bits
)
6544 print_address_bits
= addr_bit
;
6546 type_len
= strlen (bptype_string (b
->type
));
6547 if (type_len
> print_type_col_width
)
6548 print_type_col_width
= type_len
;
6550 nr_printable_breakpoints
++;
6555 ui_out_emit_table
table_emitter (uiout
,
6556 opts
.addressprint
? 6 : 5,
6557 nr_printable_breakpoints
,
6560 if (nr_printable_breakpoints
> 0)
6561 annotate_breakpoints_headers ();
6562 if (nr_printable_breakpoints
> 0)
6564 uiout
->table_header (7, ui_left
, "number", "Num"); /* 1 */
6565 if (nr_printable_breakpoints
> 0)
6567 uiout
->table_header (print_type_col_width
, ui_left
, "type", "Type"); /* 2 */
6568 if (nr_printable_breakpoints
> 0)
6570 uiout
->table_header (4, ui_left
, "disp", "Disp"); /* 3 */
6571 if (nr_printable_breakpoints
> 0)
6573 uiout
->table_header (3, ui_left
, "enabled", "Enb"); /* 4 */
6574 if (opts
.addressprint
)
6576 if (nr_printable_breakpoints
> 0)
6578 if (print_address_bits
<= 32)
6579 uiout
->table_header (10, ui_left
, "addr", "Address"); /* 5 */
6581 uiout
->table_header (18, ui_left
, "addr", "Address"); /* 5 */
6583 if (nr_printable_breakpoints
> 0)
6585 uiout
->table_header (40, ui_noalign
, "what", "What"); /* 6 */
6586 uiout
->table_body ();
6587 if (nr_printable_breakpoints
> 0)
6588 annotate_breakpoints_table ();
6593 /* If we have a filter, only list the breakpoints it accepts. */
6594 if (filter
&& !filter (b
))
6597 /* If we have an "args" string, it is a list of breakpoints to
6598 accept. Skip the others. */
6600 if (args
!= NULL
&& *args
!= '\0')
6602 if (allflag
) /* maintenance info breakpoint */
6604 if (parse_and_eval_long (args
) != b
->number
)
6607 else /* all others */
6609 if (!number_is_in_list (args
, b
->number
))
6613 /* We only print out user settable breakpoints unless the
6615 if (allflag
|| user_breakpoint_p (b
))
6616 print_one_breakpoint (b
, &last_loc
, allflag
);
6620 if (nr_printable_breakpoints
== 0)
6622 /* If there's a filter, let the caller decide how to report
6626 if (args
== NULL
|| *args
== '\0')
6627 uiout
->message ("No breakpoints or watchpoints.\n");
6629 uiout
->message ("No breakpoint or watchpoint matching '%s'.\n",
6635 if (last_loc
&& !server_command
)
6636 set_next_address (last_loc
->gdbarch
, last_loc
->address
);
6639 /* FIXME? Should this be moved up so that it is only called when
6640 there have been breakpoints? */
6641 annotate_breakpoints_table_end ();
6643 return nr_printable_breakpoints
;
6646 /* Display the value of default-collect in a way that is generally
6647 compatible with the breakpoint list. */
6650 default_collect_info (void)
6652 struct ui_out
*uiout
= current_uiout
;
6654 /* If it has no value (which is frequently the case), say nothing; a
6655 message like "No default-collect." gets in user's face when it's
6657 if (!*default_collect
)
6660 /* The following phrase lines up nicely with per-tracepoint collect
6662 uiout
->text ("default collect ");
6663 uiout
->field_string ("default-collect", default_collect
);
6664 uiout
->text (" \n");
6668 info_breakpoints_command (const char *args
, int from_tty
)
6670 breakpoint_1 (args
, 0, NULL
);
6672 default_collect_info ();
6676 info_watchpoints_command (const char *args
, int from_tty
)
6678 int num_printed
= breakpoint_1 (args
, 0, is_watchpoint
);
6679 struct ui_out
*uiout
= current_uiout
;
6681 if (num_printed
== 0)
6683 if (args
== NULL
|| *args
== '\0')
6684 uiout
->message ("No watchpoints.\n");
6686 uiout
->message ("No watchpoint matching '%s'.\n", args
);
6691 maintenance_info_breakpoints (const char *args
, int from_tty
)
6693 breakpoint_1 (args
, 1, NULL
);
6695 default_collect_info ();
6699 breakpoint_has_pc (struct breakpoint
*b
,
6700 struct program_space
*pspace
,
6701 CORE_ADDR pc
, struct obj_section
*section
)
6703 struct bp_location
*bl
= b
->loc
;
6705 for (; bl
; bl
= bl
->next
)
6707 if (bl
->pspace
== pspace
6708 && bl
->address
== pc
6709 && (!overlay_debugging
|| bl
->section
== section
))
6715 /* Print a message describing any user-breakpoints set at PC. This
6716 concerns with logical breakpoints, so we match program spaces, not
6720 describe_other_breakpoints (struct gdbarch
*gdbarch
,
6721 struct program_space
*pspace
, CORE_ADDR pc
,
6722 struct obj_section
*section
, int thread
)
6725 struct breakpoint
*b
;
6728 others
+= (user_breakpoint_p (b
)
6729 && breakpoint_has_pc (b
, pspace
, pc
, section
));
6733 printf_filtered (_("Note: breakpoint "));
6734 else /* if (others == ???) */
6735 printf_filtered (_("Note: breakpoints "));
6737 if (user_breakpoint_p (b
) && breakpoint_has_pc (b
, pspace
, pc
, section
))
6740 printf_filtered ("%d", b
->number
);
6741 if (b
->thread
== -1 && thread
!= -1)
6742 printf_filtered (" (all threads)");
6743 else if (b
->thread
!= -1)
6744 printf_filtered (" (thread %d)", b
->thread
);
6745 printf_filtered ("%s%s ",
6746 ((b
->enable_state
== bp_disabled
6747 || b
->enable_state
== bp_call_disabled
)
6751 : ((others
== 1) ? " and" : ""));
6753 printf_filtered (_("also set at pc "));
6754 fputs_filtered (paddress (gdbarch
, pc
), gdb_stdout
);
6755 printf_filtered (".\n");
6760 /* Return true iff it is meaningful to use the address member of
6761 BPT locations. For some breakpoint types, the locations' address members
6762 are irrelevant and it makes no sense to attempt to compare them to other
6763 addresses (or use them for any other purpose either).
6765 More specifically, each of the following breakpoint types will
6766 always have a zero valued location address and we don't want to mark
6767 breakpoints of any of these types to be a duplicate of an actual
6768 breakpoint location at address zero:
6776 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
6778 enum bptype type
= bpt
->type
;
6780 return (type
!= bp_watchpoint
&& type
!= bp_catchpoint
);
6783 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
6784 true if LOC1 and LOC2 represent the same watchpoint location. */
6787 watchpoint_locations_match (struct bp_location
*loc1
,
6788 struct bp_location
*loc2
)
6790 struct watchpoint
*w1
= (struct watchpoint
*) loc1
->owner
;
6791 struct watchpoint
*w2
= (struct watchpoint
*) loc2
->owner
;
6793 /* Both of them must exist. */
6794 gdb_assert (w1
!= NULL
);
6795 gdb_assert (w2
!= NULL
);
6797 /* If the target can evaluate the condition expression in hardware,
6798 then we we need to insert both watchpoints even if they are at
6799 the same place. Otherwise the watchpoint will only trigger when
6800 the condition of whichever watchpoint was inserted evaluates to
6801 true, not giving a chance for GDB to check the condition of the
6802 other watchpoint. */
6804 && target_can_accel_watchpoint_condition (loc1
->address
,
6806 loc1
->watchpoint_type
,
6807 w1
->cond_exp
.get ()))
6809 && target_can_accel_watchpoint_condition (loc2
->address
,
6811 loc2
->watchpoint_type
,
6812 w2
->cond_exp
.get ())))
6815 /* Note that this checks the owner's type, not the location's. In
6816 case the target does not support read watchpoints, but does
6817 support access watchpoints, we'll have bp_read_watchpoint
6818 watchpoints with hw_access locations. Those should be considered
6819 duplicates of hw_read locations. The hw_read locations will
6820 become hw_access locations later. */
6821 return (loc1
->owner
->type
== loc2
->owner
->type
6822 && loc1
->pspace
->aspace
== loc2
->pspace
->aspace
6823 && loc1
->address
== loc2
->address
6824 && loc1
->length
== loc2
->length
);
6827 /* See breakpoint.h. */
6830 breakpoint_address_match (const address_space
*aspace1
, CORE_ADDR addr1
,
6831 const address_space
*aspace2
, CORE_ADDR addr2
)
6833 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
6834 || aspace1
== aspace2
)
6838 /* Returns true if {ASPACE2,ADDR2} falls within the range determined by
6839 {ASPACE1,ADDR1,LEN1}. In most targets, this can only be true if ASPACE1
6840 matches ASPACE2. On targets that have global breakpoints, the address
6841 space doesn't really matter. */
6844 breakpoint_address_match_range (const address_space
*aspace1
,
6846 int len1
, const address_space
*aspace2
,
6849 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
6850 || aspace1
== aspace2
)
6851 && addr2
>= addr1
&& addr2
< addr1
+ len1
);
6854 /* Returns true if {ASPACE,ADDR} matches the breakpoint BL. BL may be
6855 a ranged breakpoint. In most targets, a match happens only if ASPACE
6856 matches the breakpoint's address space. On targets that have global
6857 breakpoints, the address space doesn't really matter. */
6860 breakpoint_location_address_match (struct bp_location
*bl
,
6861 const address_space
*aspace
,
6864 return (breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
6867 && breakpoint_address_match_range (bl
->pspace
->aspace
,
6868 bl
->address
, bl
->length
,
6872 /* Returns true if the [ADDR,ADDR+LEN) range in ASPACE overlaps
6873 breakpoint BL. BL may be a ranged breakpoint. In most targets, a
6874 match happens only if ASPACE matches the breakpoint's address
6875 space. On targets that have global breakpoints, the address space
6876 doesn't really matter. */
6879 breakpoint_location_address_range_overlap (struct bp_location
*bl
,
6880 const address_space
*aspace
,
6881 CORE_ADDR addr
, int len
)
6883 if (gdbarch_has_global_breakpoints (target_gdbarch ())
6884 || bl
->pspace
->aspace
== aspace
)
6886 int bl_len
= bl
->length
!= 0 ? bl
->length
: 1;
6888 if (mem_ranges_overlap (addr
, len
, bl
->address
, bl_len
))
6894 /* If LOC1 and LOC2's owners are not tracepoints, returns false directly.
6895 Then, if LOC1 and LOC2 represent the same tracepoint location, returns
6896 true, otherwise returns false. */
6899 tracepoint_locations_match (struct bp_location
*loc1
,
6900 struct bp_location
*loc2
)
6902 if (is_tracepoint (loc1
->owner
) && is_tracepoint (loc2
->owner
))
6903 /* Since tracepoint locations are never duplicated with others', tracepoint
6904 locations at the same address of different tracepoints are regarded as
6905 different locations. */
6906 return (loc1
->address
== loc2
->address
&& loc1
->owner
== loc2
->owner
);
6911 /* Assuming LOC1 and LOC2's types' have meaningful target addresses
6912 (breakpoint_address_is_meaningful), returns true if LOC1 and LOC2
6913 represent the same location. */
6916 breakpoint_locations_match (struct bp_location
*loc1
,
6917 struct bp_location
*loc2
)
6919 int hw_point1
, hw_point2
;
6921 /* Both of them must not be in moribund_locations. */
6922 gdb_assert (loc1
->owner
!= NULL
);
6923 gdb_assert (loc2
->owner
!= NULL
);
6925 hw_point1
= is_hardware_watchpoint (loc1
->owner
);
6926 hw_point2
= is_hardware_watchpoint (loc2
->owner
);
6928 if (hw_point1
!= hw_point2
)
6931 return watchpoint_locations_match (loc1
, loc2
);
6932 else if (is_tracepoint (loc1
->owner
) || is_tracepoint (loc2
->owner
))
6933 return tracepoint_locations_match (loc1
, loc2
);
6935 /* We compare bp_location.length in order to cover ranged breakpoints. */
6936 return (breakpoint_address_match (loc1
->pspace
->aspace
, loc1
->address
,
6937 loc2
->pspace
->aspace
, loc2
->address
)
6938 && loc1
->length
== loc2
->length
);
6942 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
6943 int bnum
, int have_bnum
)
6945 /* The longest string possibly returned by hex_string_custom
6946 is 50 chars. These must be at least that big for safety. */
6950 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
6951 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
6953 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
6954 bnum
, astr1
, astr2
);
6956 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
6959 /* Adjust a breakpoint's address to account for architectural
6960 constraints on breakpoint placement. Return the adjusted address.
6961 Note: Very few targets require this kind of adjustment. For most
6962 targets, this function is simply the identity function. */
6965 adjust_breakpoint_address (struct gdbarch
*gdbarch
,
6966 CORE_ADDR bpaddr
, enum bptype bptype
)
6968 if (bptype
== bp_watchpoint
6969 || bptype
== bp_hardware_watchpoint
6970 || bptype
== bp_read_watchpoint
6971 || bptype
== bp_access_watchpoint
6972 || bptype
== bp_catchpoint
)
6974 /* Watchpoints and the various bp_catch_* eventpoints should not
6975 have their addresses modified. */
6978 else if (bptype
== bp_single_step
)
6980 /* Single-step breakpoints should not have their addresses
6981 modified. If there's any architectural constrain that
6982 applies to this address, then it should have already been
6983 taken into account when the breakpoint was created in the
6984 first place. If we didn't do this, stepping through e.g.,
6985 Thumb-2 IT blocks would break. */
6990 CORE_ADDR adjusted_bpaddr
= bpaddr
;
6992 if (gdbarch_adjust_breakpoint_address_p (gdbarch
))
6994 /* Some targets have architectural constraints on the placement
6995 of breakpoint instructions. Obtain the adjusted address. */
6996 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (gdbarch
, bpaddr
);
6999 adjusted_bpaddr
= address_significant (gdbarch
, adjusted_bpaddr
);
7001 /* An adjusted breakpoint address can significantly alter
7002 a user's expectations. Print a warning if an adjustment
7004 if (adjusted_bpaddr
!= bpaddr
)
7005 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
7007 return adjusted_bpaddr
;
7011 bp_location::bp_location (const bp_location_ops
*ops
, breakpoint
*owner
)
7013 bp_location
*loc
= this;
7015 gdb_assert (ops
!= NULL
);
7019 loc
->cond_bytecode
= NULL
;
7020 loc
->shlib_disabled
= 0;
7023 switch (owner
->type
)
7026 case bp_single_step
:
7030 case bp_longjmp_resume
:
7031 case bp_longjmp_call_dummy
:
7033 case bp_exception_resume
:
7034 case bp_step_resume
:
7035 case bp_hp_step_resume
:
7036 case bp_watchpoint_scope
:
7038 case bp_std_terminate
:
7039 case bp_shlib_event
:
7040 case bp_thread_event
:
7041 case bp_overlay_event
:
7043 case bp_longjmp_master
:
7044 case bp_std_terminate_master
:
7045 case bp_exception_master
:
7046 case bp_gnu_ifunc_resolver
:
7047 case bp_gnu_ifunc_resolver_return
:
7049 loc
->loc_type
= bp_loc_software_breakpoint
;
7050 mark_breakpoint_location_modified (loc
);
7052 case bp_hardware_breakpoint
:
7053 loc
->loc_type
= bp_loc_hardware_breakpoint
;
7054 mark_breakpoint_location_modified (loc
);
7056 case bp_hardware_watchpoint
:
7057 case bp_read_watchpoint
:
7058 case bp_access_watchpoint
:
7059 loc
->loc_type
= bp_loc_hardware_watchpoint
;
7064 case bp_fast_tracepoint
:
7065 case bp_static_tracepoint
:
7066 loc
->loc_type
= bp_loc_other
;
7069 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
7075 /* Allocate a struct bp_location. */
7077 static struct bp_location
*
7078 allocate_bp_location (struct breakpoint
*bpt
)
7080 return bpt
->ops
->allocate_location (bpt
);
7084 free_bp_location (struct bp_location
*loc
)
7086 loc
->ops
->dtor (loc
);
7090 /* Increment reference count. */
7093 incref_bp_location (struct bp_location
*bl
)
7098 /* Decrement reference count. If the reference count reaches 0,
7099 destroy the bp_location. Sets *BLP to NULL. */
7102 decref_bp_location (struct bp_location
**blp
)
7104 gdb_assert ((*blp
)->refc
> 0);
7106 if (--(*blp
)->refc
== 0)
7107 free_bp_location (*blp
);
7111 /* Add breakpoint B at the end of the global breakpoint chain. */
7114 add_to_breakpoint_chain (std::unique_ptr
<breakpoint
> &&b
)
7116 struct breakpoint
*b1
;
7117 struct breakpoint
*result
= b
.get ();
7119 /* Add this breakpoint to the end of the chain so that a list of
7120 breakpoints will come out in order of increasing numbers. */
7122 b1
= breakpoint_chain
;
7124 breakpoint_chain
= b
.release ();
7129 b1
->next
= b
.release ();
7135 /* Initializes breakpoint B with type BPTYPE and no locations yet. */
7138 init_raw_breakpoint_without_location (struct breakpoint
*b
,
7139 struct gdbarch
*gdbarch
,
7141 const struct breakpoint_ops
*ops
)
7143 gdb_assert (ops
!= NULL
);
7147 b
->gdbarch
= gdbarch
;
7148 b
->language
= current_language
->la_language
;
7149 b
->input_radix
= input_radix
;
7150 b
->related_breakpoint
= b
;
7153 /* Helper to set_raw_breakpoint below. Creates a breakpoint
7154 that has type BPTYPE and has no locations as yet. */
7156 static struct breakpoint
*
7157 set_raw_breakpoint_without_location (struct gdbarch
*gdbarch
,
7159 const struct breakpoint_ops
*ops
)
7161 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (bptype
);
7163 init_raw_breakpoint_without_location (b
.get (), gdbarch
, bptype
, ops
);
7164 return add_to_breakpoint_chain (std::move (b
));
7167 /* Initialize loc->function_name. EXPLICIT_LOC says no indirect function
7168 resolutions should be made as the user specified the location explicitly
7172 set_breakpoint_location_function (struct bp_location
*loc
, int explicit_loc
)
7174 gdb_assert (loc
->owner
!= NULL
);
7176 if (loc
->owner
->type
== bp_breakpoint
7177 || loc
->owner
->type
== bp_hardware_breakpoint
7178 || is_tracepoint (loc
->owner
))
7181 const char *function_name
;
7182 CORE_ADDR func_addr
;
7184 find_pc_partial_function_gnu_ifunc (loc
->address
, &function_name
,
7185 &func_addr
, NULL
, &is_gnu_ifunc
);
7187 if (is_gnu_ifunc
&& !explicit_loc
)
7189 struct breakpoint
*b
= loc
->owner
;
7191 gdb_assert (loc
->pspace
== current_program_space
);
7192 if (gnu_ifunc_resolve_name (function_name
,
7193 &loc
->requested_address
))
7195 /* Recalculate ADDRESS based on new REQUESTED_ADDRESS. */
7196 loc
->address
= adjust_breakpoint_address (loc
->gdbarch
,
7197 loc
->requested_address
,
7200 else if (b
->type
== bp_breakpoint
&& b
->loc
== loc
7201 && loc
->next
== NULL
&& b
->related_breakpoint
== b
)
7203 /* Create only the whole new breakpoint of this type but do not
7204 mess more complicated breakpoints with multiple locations. */
7205 b
->type
= bp_gnu_ifunc_resolver
;
7206 /* Remember the resolver's address for use by the return
7208 loc
->related_address
= func_addr
;
7213 loc
->function_name
= xstrdup (function_name
);
7217 /* Attempt to determine architecture of location identified by SAL. */
7219 get_sal_arch (struct symtab_and_line sal
)
7222 return get_objfile_arch (sal
.section
->objfile
);
7224 return get_objfile_arch (SYMTAB_OBJFILE (sal
.symtab
));
7229 /* Low level routine for partially initializing a breakpoint of type
7230 BPTYPE. The newly created breakpoint's address, section, source
7231 file name, and line number are provided by SAL.
7233 It is expected that the caller will complete the initialization of
7234 the newly created breakpoint struct as well as output any status
7235 information regarding the creation of a new breakpoint. */
7238 init_raw_breakpoint (struct breakpoint
*b
, struct gdbarch
*gdbarch
,
7239 struct symtab_and_line sal
, enum bptype bptype
,
7240 const struct breakpoint_ops
*ops
)
7242 init_raw_breakpoint_without_location (b
, gdbarch
, bptype
, ops
);
7244 add_location_to_breakpoint (b
, &sal
);
7246 if (bptype
!= bp_catchpoint
)
7247 gdb_assert (sal
.pspace
!= NULL
);
7249 /* Store the program space that was used to set the breakpoint,
7250 except for ordinary breakpoints, which are independent of the
7252 if (bptype
!= bp_breakpoint
&& bptype
!= bp_hardware_breakpoint
)
7253 b
->pspace
= sal
.pspace
;
7256 /* set_raw_breakpoint is a low level routine for allocating and
7257 partially initializing a breakpoint of type BPTYPE. The newly
7258 created breakpoint's address, section, source file name, and line
7259 number are provided by SAL. The newly created and partially
7260 initialized breakpoint is added to the breakpoint chain and
7261 is also returned as the value of this function.
7263 It is expected that the caller will complete the initialization of
7264 the newly created breakpoint struct as well as output any status
7265 information regarding the creation of a new breakpoint. In
7266 particular, set_raw_breakpoint does NOT set the breakpoint
7267 number! Care should be taken to not allow an error to occur
7268 prior to completing the initialization of the breakpoint. If this
7269 should happen, a bogus breakpoint will be left on the chain. */
7272 set_raw_breakpoint (struct gdbarch
*gdbarch
,
7273 struct symtab_and_line sal
, enum bptype bptype
,
7274 const struct breakpoint_ops
*ops
)
7276 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (bptype
);
7278 init_raw_breakpoint (b
.get (), gdbarch
, sal
, bptype
, ops
);
7279 return add_to_breakpoint_chain (std::move (b
));
7282 /* Call this routine when stepping and nexting to enable a breakpoint
7283 if we do a longjmp() or 'throw' in TP. FRAME is the frame which
7284 initiated the operation. */
7287 set_longjmp_breakpoint (struct thread_info
*tp
, struct frame_id frame
)
7289 struct breakpoint
*b
, *b_tmp
;
7290 int thread
= tp
->global_num
;
7292 /* To avoid having to rescan all objfile symbols at every step,
7293 we maintain a list of continually-inserted but always disabled
7294 longjmp "master" breakpoints. Here, we simply create momentary
7295 clones of those and enable them for the requested thread. */
7296 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7297 if (b
->pspace
== current_program_space
7298 && (b
->type
== bp_longjmp_master
7299 || b
->type
== bp_exception_master
))
7301 enum bptype type
= b
->type
== bp_longjmp_master
? bp_longjmp
: bp_exception
;
7302 struct breakpoint
*clone
;
7304 /* longjmp_breakpoint_ops ensures INITIATING_FRAME is cleared again
7305 after their removal. */
7306 clone
= momentary_breakpoint_from_master (b
, type
,
7307 &momentary_breakpoint_ops
, 1);
7308 clone
->thread
= thread
;
7311 tp
->initiating_frame
= frame
;
7314 /* Delete all longjmp breakpoints from THREAD. */
7316 delete_longjmp_breakpoint (int thread
)
7318 struct breakpoint
*b
, *b_tmp
;
7320 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7321 if (b
->type
== bp_longjmp
|| b
->type
== bp_exception
)
7323 if (b
->thread
== thread
)
7324 delete_breakpoint (b
);
7329 delete_longjmp_breakpoint_at_next_stop (int thread
)
7331 struct breakpoint
*b
, *b_tmp
;
7333 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7334 if (b
->type
== bp_longjmp
|| b
->type
== bp_exception
)
7336 if (b
->thread
== thread
)
7337 b
->disposition
= disp_del_at_next_stop
;
7341 /* Place breakpoints of type bp_longjmp_call_dummy to catch longjmp for
7342 INFERIOR_PTID thread. Chain them all by RELATED_BREAKPOINT and return
7343 pointer to any of them. Return NULL if this system cannot place longjmp
7347 set_longjmp_breakpoint_for_call_dummy (void)
7349 struct breakpoint
*b
, *retval
= NULL
;
7352 if (b
->pspace
== current_program_space
&& b
->type
== bp_longjmp_master
)
7354 struct breakpoint
*new_b
;
7356 new_b
= momentary_breakpoint_from_master (b
, bp_longjmp_call_dummy
,
7357 &momentary_breakpoint_ops
,
7359 new_b
->thread
= ptid_to_global_thread_id (inferior_ptid
);
7361 /* Link NEW_B into the chain of RETVAL breakpoints. */
7363 gdb_assert (new_b
->related_breakpoint
== new_b
);
7366 new_b
->related_breakpoint
= retval
;
7367 while (retval
->related_breakpoint
!= new_b
->related_breakpoint
)
7368 retval
= retval
->related_breakpoint
;
7369 retval
->related_breakpoint
= new_b
;
7375 /* Verify all existing dummy frames and their associated breakpoints for
7376 TP. Remove those which can no longer be found in the current frame
7379 You should call this function only at places where it is safe to currently
7380 unwind the whole stack. Failed stack unwind would discard live dummy
7384 check_longjmp_breakpoint_for_call_dummy (struct thread_info
*tp
)
7386 struct breakpoint
*b
, *b_tmp
;
7388 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7389 if (b
->type
== bp_longjmp_call_dummy
&& b
->thread
== tp
->global_num
)
7391 struct breakpoint
*dummy_b
= b
->related_breakpoint
;
7393 while (dummy_b
!= b
&& dummy_b
->type
!= bp_call_dummy
)
7394 dummy_b
= dummy_b
->related_breakpoint
;
7395 if (dummy_b
->type
!= bp_call_dummy
7396 || frame_find_by_id (dummy_b
->frame_id
) != NULL
)
7399 dummy_frame_discard (dummy_b
->frame_id
, tp
->ptid
);
7401 while (b
->related_breakpoint
!= b
)
7403 if (b_tmp
== b
->related_breakpoint
)
7404 b_tmp
= b
->related_breakpoint
->next
;
7405 delete_breakpoint (b
->related_breakpoint
);
7407 delete_breakpoint (b
);
7412 enable_overlay_breakpoints (void)
7414 struct breakpoint
*b
;
7417 if (b
->type
== bp_overlay_event
)
7419 b
->enable_state
= bp_enabled
;
7420 update_global_location_list (UGLL_MAY_INSERT
);
7421 overlay_events_enabled
= 1;
7426 disable_overlay_breakpoints (void)
7428 struct breakpoint
*b
;
7431 if (b
->type
== bp_overlay_event
)
7433 b
->enable_state
= bp_disabled
;
7434 update_global_location_list (UGLL_DONT_INSERT
);
7435 overlay_events_enabled
= 0;
7439 /* Set an active std::terminate breakpoint for each std::terminate
7440 master breakpoint. */
7442 set_std_terminate_breakpoint (void)
7444 struct breakpoint
*b
, *b_tmp
;
7446 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7447 if (b
->pspace
== current_program_space
7448 && b
->type
== bp_std_terminate_master
)
7450 momentary_breakpoint_from_master (b
, bp_std_terminate
,
7451 &momentary_breakpoint_ops
, 1);
7455 /* Delete all the std::terminate breakpoints. */
7457 delete_std_terminate_breakpoint (void)
7459 struct breakpoint
*b
, *b_tmp
;
7461 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7462 if (b
->type
== bp_std_terminate
)
7463 delete_breakpoint (b
);
7467 create_thread_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7469 struct breakpoint
*b
;
7471 b
= create_internal_breakpoint (gdbarch
, address
, bp_thread_event
,
7472 &internal_breakpoint_ops
);
7474 b
->enable_state
= bp_enabled
;
7475 /* location has to be used or breakpoint_re_set will delete me. */
7476 b
->location
= new_address_location (b
->loc
->address
, NULL
, 0);
7478 update_global_location_list_nothrow (UGLL_MAY_INSERT
);
7483 struct lang_and_radix
7489 /* Create a breakpoint for JIT code registration and unregistration. */
7492 create_jit_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7494 return create_internal_breakpoint (gdbarch
, address
, bp_jit_event
,
7495 &internal_breakpoint_ops
);
7498 /* Remove JIT code registration and unregistration breakpoint(s). */
7501 remove_jit_event_breakpoints (void)
7503 struct breakpoint
*b
, *b_tmp
;
7505 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7506 if (b
->type
== bp_jit_event
7507 && b
->loc
->pspace
== current_program_space
)
7508 delete_breakpoint (b
);
7512 remove_solib_event_breakpoints (void)
7514 struct breakpoint
*b
, *b_tmp
;
7516 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7517 if (b
->type
== bp_shlib_event
7518 && b
->loc
->pspace
== current_program_space
)
7519 delete_breakpoint (b
);
7522 /* See breakpoint.h. */
7525 remove_solib_event_breakpoints_at_next_stop (void)
7527 struct breakpoint
*b
, *b_tmp
;
7529 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7530 if (b
->type
== bp_shlib_event
7531 && b
->loc
->pspace
== current_program_space
)
7532 b
->disposition
= disp_del_at_next_stop
;
7535 /* Helper for create_solib_event_breakpoint /
7536 create_and_insert_solib_event_breakpoint. Allows specifying which
7537 INSERT_MODE to pass through to update_global_location_list. */
7539 static struct breakpoint
*
7540 create_solib_event_breakpoint_1 (struct gdbarch
*gdbarch
, CORE_ADDR address
,
7541 enum ugll_insert_mode insert_mode
)
7543 struct breakpoint
*b
;
7545 b
= create_internal_breakpoint (gdbarch
, address
, bp_shlib_event
,
7546 &internal_breakpoint_ops
);
7547 update_global_location_list_nothrow (insert_mode
);
7552 create_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7554 return create_solib_event_breakpoint_1 (gdbarch
, address
, UGLL_MAY_INSERT
);
7557 /* See breakpoint.h. */
7560 create_and_insert_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7562 struct breakpoint
*b
;
7564 /* Explicitly tell update_global_location_list to insert
7566 b
= create_solib_event_breakpoint_1 (gdbarch
, address
, UGLL_INSERT
);
7567 if (!b
->loc
->inserted
)
7569 delete_breakpoint (b
);
7575 /* Disable any breakpoints that are on code in shared libraries. Only
7576 apply to enabled breakpoints, disabled ones can just stay disabled. */
7579 disable_breakpoints_in_shlibs (void)
7581 struct bp_location
*loc
, **locp_tmp
;
7583 ALL_BP_LOCATIONS (loc
, locp_tmp
)
7585 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7586 struct breakpoint
*b
= loc
->owner
;
7588 /* We apply the check to all breakpoints, including disabled for
7589 those with loc->duplicate set. This is so that when breakpoint
7590 becomes enabled, or the duplicate is removed, gdb will try to
7591 insert all breakpoints. If we don't set shlib_disabled here,
7592 we'll try to insert those breakpoints and fail. */
7593 if (((b
->type
== bp_breakpoint
)
7594 || (b
->type
== bp_jit_event
)
7595 || (b
->type
== bp_hardware_breakpoint
)
7596 || (is_tracepoint (b
)))
7597 && loc
->pspace
== current_program_space
7598 && !loc
->shlib_disabled
7599 && solib_name_from_address (loc
->pspace
, loc
->address
)
7602 loc
->shlib_disabled
= 1;
7607 /* Disable any breakpoints and tracepoints that are in SOLIB upon
7608 notification of unloaded_shlib. Only apply to enabled breakpoints,
7609 disabled ones can just stay disabled. */
7612 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
7614 struct bp_location
*loc
, **locp_tmp
;
7615 int disabled_shlib_breaks
= 0;
7617 ALL_BP_LOCATIONS (loc
, locp_tmp
)
7619 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7620 struct breakpoint
*b
= loc
->owner
;
7622 if (solib
->pspace
== loc
->pspace
7623 && !loc
->shlib_disabled
7624 && (((b
->type
== bp_breakpoint
7625 || b
->type
== bp_jit_event
7626 || b
->type
== bp_hardware_breakpoint
)
7627 && (loc
->loc_type
== bp_loc_hardware_breakpoint
7628 || loc
->loc_type
== bp_loc_software_breakpoint
))
7629 || is_tracepoint (b
))
7630 && solib_contains_address_p (solib
, loc
->address
))
7632 loc
->shlib_disabled
= 1;
7633 /* At this point, we cannot rely on remove_breakpoint
7634 succeeding so we must mark the breakpoint as not inserted
7635 to prevent future errors occurring in remove_breakpoints. */
7638 /* This may cause duplicate notifications for the same breakpoint. */
7639 gdb::observers::breakpoint_modified
.notify (b
);
7641 if (!disabled_shlib_breaks
)
7643 target_terminal::ours_for_output ();
7644 warning (_("Temporarily disabling breakpoints "
7645 "for unloaded shared library \"%s\""),
7648 disabled_shlib_breaks
= 1;
7653 /* Disable any breakpoints and tracepoints in OBJFILE upon
7654 notification of free_objfile. Only apply to enabled breakpoints,
7655 disabled ones can just stay disabled. */
7658 disable_breakpoints_in_freed_objfile (struct objfile
*objfile
)
7660 struct breakpoint
*b
;
7662 if (objfile
== NULL
)
7665 /* OBJF_SHARED|OBJF_USERLOADED objfiles are dynamic modules manually
7666 managed by the user with add-symbol-file/remove-symbol-file.
7667 Similarly to how breakpoints in shared libraries are handled in
7668 response to "nosharedlibrary", mark breakpoints in such modules
7669 shlib_disabled so they end up uninserted on the next global
7670 location list update. Shared libraries not loaded by the user
7671 aren't handled here -- they're already handled in
7672 disable_breakpoints_in_unloaded_shlib, called by solib.c's
7673 solib_unloaded observer. We skip objfiles that are not
7674 OBJF_SHARED as those aren't considered dynamic objects (e.g. the
7676 if ((objfile
->flags
& OBJF_SHARED
) == 0
7677 || (objfile
->flags
& OBJF_USERLOADED
) == 0)
7682 struct bp_location
*loc
;
7683 int bp_modified
= 0;
7685 if (!is_breakpoint (b
) && !is_tracepoint (b
))
7688 for (loc
= b
->loc
; loc
!= NULL
; loc
= loc
->next
)
7690 CORE_ADDR loc_addr
= loc
->address
;
7692 if (loc
->loc_type
!= bp_loc_hardware_breakpoint
7693 && loc
->loc_type
!= bp_loc_software_breakpoint
)
7696 if (loc
->shlib_disabled
!= 0)
7699 if (objfile
->pspace
!= loc
->pspace
)
7702 if (loc
->loc_type
!= bp_loc_hardware_breakpoint
7703 && loc
->loc_type
!= bp_loc_software_breakpoint
)
7706 if (is_addr_in_objfile (loc_addr
, objfile
))
7708 loc
->shlib_disabled
= 1;
7709 /* At this point, we don't know whether the object was
7710 unmapped from the inferior or not, so leave the
7711 inserted flag alone. We'll handle failure to
7712 uninsert quietly, in case the object was indeed
7715 mark_breakpoint_location_modified (loc
);
7722 gdb::observers::breakpoint_modified
.notify (b
);
7726 /* FORK & VFORK catchpoints. */
7728 /* An instance of this type is used to represent a fork or vfork
7729 catchpoint. A breakpoint is really of this type iff its ops pointer points
7730 to CATCH_FORK_BREAKPOINT_OPS. */
7732 struct fork_catchpoint
: public breakpoint
7734 /* Process id of a child process whose forking triggered this
7735 catchpoint. This field is only valid immediately after this
7736 catchpoint has triggered. */
7737 ptid_t forked_inferior_pid
;
7740 /* Implement the "insert" breakpoint_ops method for fork
7744 insert_catch_fork (struct bp_location
*bl
)
7746 return target_insert_fork_catchpoint (ptid_get_pid (inferior_ptid
));
7749 /* Implement the "remove" breakpoint_ops method for fork
7753 remove_catch_fork (struct bp_location
*bl
, enum remove_bp_reason reason
)
7755 return target_remove_fork_catchpoint (ptid_get_pid (inferior_ptid
));
7758 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
7762 breakpoint_hit_catch_fork (const struct bp_location
*bl
,
7763 const address_space
*aspace
, CORE_ADDR bp_addr
,
7764 const struct target_waitstatus
*ws
)
7766 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bl
->owner
;
7768 if (ws
->kind
!= TARGET_WAITKIND_FORKED
)
7771 c
->forked_inferior_pid
= ws
->value
.related_pid
;
7775 /* Implement the "print_it" breakpoint_ops method for fork
7778 static enum print_stop_action
7779 print_it_catch_fork (bpstat bs
)
7781 struct ui_out
*uiout
= current_uiout
;
7782 struct breakpoint
*b
= bs
->breakpoint_at
;
7783 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bs
->breakpoint_at
;
7785 annotate_catchpoint (b
->number
);
7786 maybe_print_thread_hit_breakpoint (uiout
);
7787 if (b
->disposition
== disp_del
)
7788 uiout
->text ("Temporary catchpoint ");
7790 uiout
->text ("Catchpoint ");
7791 if (uiout
->is_mi_like_p ())
7793 uiout
->field_string ("reason", async_reason_lookup (EXEC_ASYNC_FORK
));
7794 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
7796 uiout
->field_int ("bkptno", b
->number
);
7797 uiout
->text (" (forked process ");
7798 uiout
->field_int ("newpid", ptid_get_pid (c
->forked_inferior_pid
));
7799 uiout
->text ("), ");
7800 return PRINT_SRC_AND_LOC
;
7803 /* Implement the "print_one" breakpoint_ops method for fork
7807 print_one_catch_fork (struct breakpoint
*b
, struct bp_location
**last_loc
)
7809 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
7810 struct value_print_options opts
;
7811 struct ui_out
*uiout
= current_uiout
;
7813 get_user_print_options (&opts
);
7815 /* Field 4, the address, is omitted (which makes the columns not
7816 line up too nicely with the headers, but the effect is relatively
7818 if (opts
.addressprint
)
7819 uiout
->field_skip ("addr");
7821 uiout
->text ("fork");
7822 if (!ptid_equal (c
->forked_inferior_pid
, null_ptid
))
7824 uiout
->text (", process ");
7825 uiout
->field_int ("what", ptid_get_pid (c
->forked_inferior_pid
));
7829 if (uiout
->is_mi_like_p ())
7830 uiout
->field_string ("catch-type", "fork");
7833 /* Implement the "print_mention" breakpoint_ops method for fork
7837 print_mention_catch_fork (struct breakpoint
*b
)
7839 printf_filtered (_("Catchpoint %d (fork)"), b
->number
);
7842 /* Implement the "print_recreate" breakpoint_ops method for fork
7846 print_recreate_catch_fork (struct breakpoint
*b
, struct ui_file
*fp
)
7848 fprintf_unfiltered (fp
, "catch fork");
7849 print_recreate_thread (b
, fp
);
7852 /* The breakpoint_ops structure to be used in fork catchpoints. */
7854 static struct breakpoint_ops catch_fork_breakpoint_ops
;
7856 /* Implement the "insert" breakpoint_ops method for vfork
7860 insert_catch_vfork (struct bp_location
*bl
)
7862 return target_insert_vfork_catchpoint (ptid_get_pid (inferior_ptid
));
7865 /* Implement the "remove" breakpoint_ops method for vfork
7869 remove_catch_vfork (struct bp_location
*bl
, enum remove_bp_reason reason
)
7871 return target_remove_vfork_catchpoint (ptid_get_pid (inferior_ptid
));
7874 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
7878 breakpoint_hit_catch_vfork (const struct bp_location
*bl
,
7879 const address_space
*aspace
, CORE_ADDR bp_addr
,
7880 const struct target_waitstatus
*ws
)
7882 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bl
->owner
;
7884 if (ws
->kind
!= TARGET_WAITKIND_VFORKED
)
7887 c
->forked_inferior_pid
= ws
->value
.related_pid
;
7891 /* Implement the "print_it" breakpoint_ops method for vfork
7894 static enum print_stop_action
7895 print_it_catch_vfork (bpstat bs
)
7897 struct ui_out
*uiout
= current_uiout
;
7898 struct breakpoint
*b
= bs
->breakpoint_at
;
7899 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
7901 annotate_catchpoint (b
->number
);
7902 maybe_print_thread_hit_breakpoint (uiout
);
7903 if (b
->disposition
== disp_del
)
7904 uiout
->text ("Temporary catchpoint ");
7906 uiout
->text ("Catchpoint ");
7907 if (uiout
->is_mi_like_p ())
7909 uiout
->field_string ("reason", async_reason_lookup (EXEC_ASYNC_VFORK
));
7910 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
7912 uiout
->field_int ("bkptno", b
->number
);
7913 uiout
->text (" (vforked process ");
7914 uiout
->field_int ("newpid", ptid_get_pid (c
->forked_inferior_pid
));
7915 uiout
->text ("), ");
7916 return PRINT_SRC_AND_LOC
;
7919 /* Implement the "print_one" breakpoint_ops method for vfork
7923 print_one_catch_vfork (struct breakpoint
*b
, struct bp_location
**last_loc
)
7925 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
7926 struct value_print_options opts
;
7927 struct ui_out
*uiout
= current_uiout
;
7929 get_user_print_options (&opts
);
7930 /* Field 4, the address, is omitted (which makes the columns not
7931 line up too nicely with the headers, but the effect is relatively
7933 if (opts
.addressprint
)
7934 uiout
->field_skip ("addr");
7936 uiout
->text ("vfork");
7937 if (!ptid_equal (c
->forked_inferior_pid
, null_ptid
))
7939 uiout
->text (", process ");
7940 uiout
->field_int ("what", ptid_get_pid (c
->forked_inferior_pid
));
7944 if (uiout
->is_mi_like_p ())
7945 uiout
->field_string ("catch-type", "vfork");
7948 /* Implement the "print_mention" breakpoint_ops method for vfork
7952 print_mention_catch_vfork (struct breakpoint
*b
)
7954 printf_filtered (_("Catchpoint %d (vfork)"), b
->number
);
7957 /* Implement the "print_recreate" breakpoint_ops method for vfork
7961 print_recreate_catch_vfork (struct breakpoint
*b
, struct ui_file
*fp
)
7963 fprintf_unfiltered (fp
, "catch vfork");
7964 print_recreate_thread (b
, fp
);
7967 /* The breakpoint_ops structure to be used in vfork catchpoints. */
7969 static struct breakpoint_ops catch_vfork_breakpoint_ops
;
7971 /* An instance of this type is used to represent an solib catchpoint.
7972 A breakpoint is really of this type iff its ops pointer points to
7973 CATCH_SOLIB_BREAKPOINT_OPS. */
7975 struct solib_catchpoint
: public breakpoint
7977 ~solib_catchpoint () override
;
7979 /* True for "catch load", false for "catch unload". */
7980 unsigned char is_load
;
7982 /* Regular expression to match, if any. COMPILED is only valid when
7983 REGEX is non-NULL. */
7985 std::unique_ptr
<compiled_regex
> compiled
;
7988 solib_catchpoint::~solib_catchpoint ()
7990 xfree (this->regex
);
7994 insert_catch_solib (struct bp_location
*ignore
)
8000 remove_catch_solib (struct bp_location
*ignore
, enum remove_bp_reason reason
)
8006 breakpoint_hit_catch_solib (const struct bp_location
*bl
,
8007 const address_space
*aspace
,
8009 const struct target_waitstatus
*ws
)
8011 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) bl
->owner
;
8012 struct breakpoint
*other
;
8014 if (ws
->kind
== TARGET_WAITKIND_LOADED
)
8017 ALL_BREAKPOINTS (other
)
8019 struct bp_location
*other_bl
;
8021 if (other
== bl
->owner
)
8024 if (other
->type
!= bp_shlib_event
)
8027 if (self
->pspace
!= NULL
&& other
->pspace
!= self
->pspace
)
8030 for (other_bl
= other
->loc
; other_bl
!= NULL
; other_bl
= other_bl
->next
)
8032 if (other
->ops
->breakpoint_hit (other_bl
, aspace
, bp_addr
, ws
))
8041 check_status_catch_solib (struct bpstats
*bs
)
8043 struct solib_catchpoint
*self
8044 = (struct solib_catchpoint
*) bs
->breakpoint_at
;
8048 struct so_list
*iter
;
8051 VEC_iterate (so_list_ptr
, current_program_space
->added_solibs
,
8056 || self
->compiled
->exec (iter
->so_name
, 0, NULL
, 0) == 0)
8062 for (const std::string
&iter
: current_program_space
->deleted_solibs
)
8065 || self
->compiled
->exec (iter
.c_str (), 0, NULL
, 0) == 0)
8071 bs
->print_it
= print_it_noop
;
8074 static enum print_stop_action
8075 print_it_catch_solib (bpstat bs
)
8077 struct breakpoint
*b
= bs
->breakpoint_at
;
8078 struct ui_out
*uiout
= current_uiout
;
8080 annotate_catchpoint (b
->number
);
8081 maybe_print_thread_hit_breakpoint (uiout
);
8082 if (b
->disposition
== disp_del
)
8083 uiout
->text ("Temporary catchpoint ");
8085 uiout
->text ("Catchpoint ");
8086 uiout
->field_int ("bkptno", b
->number
);
8088 if (uiout
->is_mi_like_p ())
8089 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
8090 print_solib_event (1);
8091 return PRINT_SRC_AND_LOC
;
8095 print_one_catch_solib (struct breakpoint
*b
, struct bp_location
**locs
)
8097 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8098 struct value_print_options opts
;
8099 struct ui_out
*uiout
= current_uiout
;
8102 get_user_print_options (&opts
);
8103 /* Field 4, the address, is omitted (which makes the columns not
8104 line up too nicely with the headers, but the effect is relatively
8106 if (opts
.addressprint
)
8109 uiout
->field_skip ("addr");
8116 msg
= xstrprintf (_("load of library matching %s"), self
->regex
);
8118 msg
= xstrdup (_("load of library"));
8123 msg
= xstrprintf (_("unload of library matching %s"), self
->regex
);
8125 msg
= xstrdup (_("unload of library"));
8127 uiout
->field_string ("what", msg
);
8130 if (uiout
->is_mi_like_p ())
8131 uiout
->field_string ("catch-type", self
->is_load
? "load" : "unload");
8135 print_mention_catch_solib (struct breakpoint
*b
)
8137 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8139 printf_filtered (_("Catchpoint %d (%s)"), b
->number
,
8140 self
->is_load
? "load" : "unload");
8144 print_recreate_catch_solib (struct breakpoint
*b
, struct ui_file
*fp
)
8146 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8148 fprintf_unfiltered (fp
, "%s %s",
8149 b
->disposition
== disp_del
? "tcatch" : "catch",
8150 self
->is_load
? "load" : "unload");
8152 fprintf_unfiltered (fp
, " %s", self
->regex
);
8153 fprintf_unfiltered (fp
, "\n");
8156 static struct breakpoint_ops catch_solib_breakpoint_ops
;
8158 /* Shared helper function (MI and CLI) for creating and installing
8159 a shared object event catchpoint. If IS_LOAD is non-zero then
8160 the events to be caught are load events, otherwise they are
8161 unload events. If IS_TEMP is non-zero the catchpoint is a
8162 temporary one. If ENABLED is non-zero the catchpoint is
8163 created in an enabled state. */
8166 add_solib_catchpoint (const char *arg
, int is_load
, int is_temp
, int enabled
)
8168 struct gdbarch
*gdbarch
= get_current_arch ();
8172 arg
= skip_spaces (arg
);
8174 std::unique_ptr
<solib_catchpoint
> c (new solib_catchpoint ());
8178 c
->compiled
.reset (new compiled_regex (arg
, REG_NOSUB
,
8179 _("Invalid regexp")));
8180 c
->regex
= xstrdup (arg
);
8183 c
->is_load
= is_load
;
8184 init_catchpoint (c
.get (), gdbarch
, is_temp
, NULL
,
8185 &catch_solib_breakpoint_ops
);
8187 c
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
8189 install_breakpoint (0, std::move (c
), 1);
8192 /* A helper function that does all the work for "catch load" and
8196 catch_load_or_unload (const char *arg
, int from_tty
, int is_load
,
8197 struct cmd_list_element
*command
)
8200 const int enabled
= 1;
8202 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
8204 add_solib_catchpoint (arg
, is_load
, tempflag
, enabled
);
8208 catch_load_command_1 (const char *arg
, int from_tty
,
8209 struct cmd_list_element
*command
)
8211 catch_load_or_unload (arg
, from_tty
, 1, command
);
8215 catch_unload_command_1 (const char *arg
, int from_tty
,
8216 struct cmd_list_element
*command
)
8218 catch_load_or_unload (arg
, from_tty
, 0, command
);
8221 /* Initialize a new breakpoint of the bp_catchpoint kind. If TEMPFLAG
8222 is non-zero, then make the breakpoint temporary. If COND_STRING is
8223 not NULL, then store it in the breakpoint. OPS, if not NULL, is
8224 the breakpoint_ops structure associated to the catchpoint. */
8227 init_catchpoint (struct breakpoint
*b
,
8228 struct gdbarch
*gdbarch
, int tempflag
,
8229 const char *cond_string
,
8230 const struct breakpoint_ops
*ops
)
8232 symtab_and_line sal
;
8233 sal
.pspace
= current_program_space
;
8235 init_raw_breakpoint (b
, gdbarch
, sal
, bp_catchpoint
, ops
);
8237 b
->cond_string
= (cond_string
== NULL
) ? NULL
: xstrdup (cond_string
);
8238 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
8242 install_breakpoint (int internal
, std::unique_ptr
<breakpoint
> &&arg
, int update_gll
)
8244 breakpoint
*b
= add_to_breakpoint_chain (std::move (arg
));
8245 set_breakpoint_number (internal
, b
);
8246 if (is_tracepoint (b
))
8247 set_tracepoint_count (breakpoint_count
);
8250 gdb::observers::breakpoint_created
.notify (b
);
8253 update_global_location_list (UGLL_MAY_INSERT
);
8257 create_fork_vfork_event_catchpoint (struct gdbarch
*gdbarch
,
8258 int tempflag
, const char *cond_string
,
8259 const struct breakpoint_ops
*ops
)
8261 std::unique_ptr
<fork_catchpoint
> c (new fork_catchpoint ());
8263 init_catchpoint (c
.get (), gdbarch
, tempflag
, cond_string
, ops
);
8265 c
->forked_inferior_pid
= null_ptid
;
8267 install_breakpoint (0, std::move (c
), 1);
8270 /* Exec catchpoints. */
8272 /* An instance of this type is used to represent an exec catchpoint.
8273 A breakpoint is really of this type iff its ops pointer points to
8274 CATCH_EXEC_BREAKPOINT_OPS. */
8276 struct exec_catchpoint
: public breakpoint
8278 ~exec_catchpoint () override
;
8280 /* Filename of a program whose exec triggered this catchpoint.
8281 This field is only valid immediately after this catchpoint has
8283 char *exec_pathname
;
8286 /* Exec catchpoint destructor. */
8288 exec_catchpoint::~exec_catchpoint ()
8290 xfree (this->exec_pathname
);
8294 insert_catch_exec (struct bp_location
*bl
)
8296 return target_insert_exec_catchpoint (ptid_get_pid (inferior_ptid
));
8300 remove_catch_exec (struct bp_location
*bl
, enum remove_bp_reason reason
)
8302 return target_remove_exec_catchpoint (ptid_get_pid (inferior_ptid
));
8306 breakpoint_hit_catch_exec (const struct bp_location
*bl
,
8307 const address_space
*aspace
, CORE_ADDR bp_addr
,
8308 const struct target_waitstatus
*ws
)
8310 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) bl
->owner
;
8312 if (ws
->kind
!= TARGET_WAITKIND_EXECD
)
8315 c
->exec_pathname
= xstrdup (ws
->value
.execd_pathname
);
8319 static enum print_stop_action
8320 print_it_catch_exec (bpstat bs
)
8322 struct ui_out
*uiout
= current_uiout
;
8323 struct breakpoint
*b
= bs
->breakpoint_at
;
8324 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
8326 annotate_catchpoint (b
->number
);
8327 maybe_print_thread_hit_breakpoint (uiout
);
8328 if (b
->disposition
== disp_del
)
8329 uiout
->text ("Temporary catchpoint ");
8331 uiout
->text ("Catchpoint ");
8332 if (uiout
->is_mi_like_p ())
8334 uiout
->field_string ("reason", async_reason_lookup (EXEC_ASYNC_EXEC
));
8335 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
8337 uiout
->field_int ("bkptno", b
->number
);
8338 uiout
->text (" (exec'd ");
8339 uiout
->field_string ("new-exec", c
->exec_pathname
);
8340 uiout
->text ("), ");
8342 return PRINT_SRC_AND_LOC
;
8346 print_one_catch_exec (struct breakpoint
*b
, struct bp_location
**last_loc
)
8348 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
8349 struct value_print_options opts
;
8350 struct ui_out
*uiout
= current_uiout
;
8352 get_user_print_options (&opts
);
8354 /* Field 4, the address, is omitted (which makes the columns
8355 not line up too nicely with the headers, but the effect
8356 is relatively readable). */
8357 if (opts
.addressprint
)
8358 uiout
->field_skip ("addr");
8360 uiout
->text ("exec");
8361 if (c
->exec_pathname
!= NULL
)
8363 uiout
->text (", program \"");
8364 uiout
->field_string ("what", c
->exec_pathname
);
8365 uiout
->text ("\" ");
8368 if (uiout
->is_mi_like_p ())
8369 uiout
->field_string ("catch-type", "exec");
8373 print_mention_catch_exec (struct breakpoint
*b
)
8375 printf_filtered (_("Catchpoint %d (exec)"), b
->number
);
8378 /* Implement the "print_recreate" breakpoint_ops method for exec
8382 print_recreate_catch_exec (struct breakpoint
*b
, struct ui_file
*fp
)
8384 fprintf_unfiltered (fp
, "catch exec");
8385 print_recreate_thread (b
, fp
);
8388 static struct breakpoint_ops catch_exec_breakpoint_ops
;
8391 hw_breakpoint_used_count (void)
8394 struct breakpoint
*b
;
8395 struct bp_location
*bl
;
8399 if (b
->type
== bp_hardware_breakpoint
&& breakpoint_enabled (b
))
8400 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
8402 /* Special types of hardware breakpoints may use more than
8404 i
+= b
->ops
->resources_needed (bl
);
8411 /* Returns the resources B would use if it were a hardware
8415 hw_watchpoint_use_count (struct breakpoint
*b
)
8418 struct bp_location
*bl
;
8420 if (!breakpoint_enabled (b
))
8423 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
8425 /* Special types of hardware watchpoints may use more than
8427 i
+= b
->ops
->resources_needed (bl
);
8433 /* Returns the sum the used resources of all hardware watchpoints of
8434 type TYPE in the breakpoints list. Also returns in OTHER_TYPE_USED
8435 the sum of the used resources of all hardware watchpoints of other
8436 types _not_ TYPE. */
8439 hw_watchpoint_used_count_others (struct breakpoint
*except
,
8440 enum bptype type
, int *other_type_used
)
8443 struct breakpoint
*b
;
8445 *other_type_used
= 0;
8450 if (!breakpoint_enabled (b
))
8453 if (b
->type
== type
)
8454 i
+= hw_watchpoint_use_count (b
);
8455 else if (is_hardware_watchpoint (b
))
8456 *other_type_used
= 1;
8463 disable_watchpoints_before_interactive_call_start (void)
8465 struct breakpoint
*b
;
8469 if (is_watchpoint (b
) && breakpoint_enabled (b
))
8471 b
->enable_state
= bp_call_disabled
;
8472 update_global_location_list (UGLL_DONT_INSERT
);
8478 enable_watchpoints_after_interactive_call_stop (void)
8480 struct breakpoint
*b
;
8484 if (is_watchpoint (b
) && b
->enable_state
== bp_call_disabled
)
8486 b
->enable_state
= bp_enabled
;
8487 update_global_location_list (UGLL_MAY_INSERT
);
8493 disable_breakpoints_before_startup (void)
8495 current_program_space
->executing_startup
= 1;
8496 update_global_location_list (UGLL_DONT_INSERT
);
8500 enable_breakpoints_after_startup (void)
8502 current_program_space
->executing_startup
= 0;
8503 breakpoint_re_set ();
8506 /* Create a new single-step breakpoint for thread THREAD, with no
8509 static struct breakpoint
*
8510 new_single_step_breakpoint (int thread
, struct gdbarch
*gdbarch
)
8512 std::unique_ptr
<breakpoint
> b (new breakpoint ());
8514 init_raw_breakpoint_without_location (b
.get (), gdbarch
, bp_single_step
,
8515 &momentary_breakpoint_ops
);
8517 b
->disposition
= disp_donttouch
;
8518 b
->frame_id
= null_frame_id
;
8521 gdb_assert (b
->thread
!= 0);
8523 return add_to_breakpoint_chain (std::move (b
));
8526 /* Set a momentary breakpoint of type TYPE at address specified by
8527 SAL. If FRAME_ID is valid, the breakpoint is restricted to that
8531 set_momentary_breakpoint (struct gdbarch
*gdbarch
, struct symtab_and_line sal
,
8532 struct frame_id frame_id
, enum bptype type
)
8534 struct breakpoint
*b
;
8536 /* If FRAME_ID is valid, it should be a real frame, not an inlined or
8538 gdb_assert (!frame_id_artificial_p (frame_id
));
8540 b
= set_raw_breakpoint (gdbarch
, sal
, type
, &momentary_breakpoint_ops
);
8541 b
->enable_state
= bp_enabled
;
8542 b
->disposition
= disp_donttouch
;
8543 b
->frame_id
= frame_id
;
8545 /* If we're debugging a multi-threaded program, then we want
8546 momentary breakpoints to be active in only a single thread of
8548 if (in_thread_list (inferior_ptid
))
8549 b
->thread
= ptid_to_global_thread_id (inferior_ptid
);
8551 update_global_location_list_nothrow (UGLL_MAY_INSERT
);
8553 return breakpoint_up (b
);
8556 /* Make a momentary breakpoint based on the master breakpoint ORIG.
8557 The new breakpoint will have type TYPE, use OPS as its
8558 breakpoint_ops, and will set enabled to LOC_ENABLED. */
8560 static struct breakpoint
*
8561 momentary_breakpoint_from_master (struct breakpoint
*orig
,
8563 const struct breakpoint_ops
*ops
,
8566 struct breakpoint
*copy
;
8568 copy
= set_raw_breakpoint_without_location (orig
->gdbarch
, type
, ops
);
8569 copy
->loc
= allocate_bp_location (copy
);
8570 set_breakpoint_location_function (copy
->loc
, 1);
8572 copy
->loc
->gdbarch
= orig
->loc
->gdbarch
;
8573 copy
->loc
->requested_address
= orig
->loc
->requested_address
;
8574 copy
->loc
->address
= orig
->loc
->address
;
8575 copy
->loc
->section
= orig
->loc
->section
;
8576 copy
->loc
->pspace
= orig
->loc
->pspace
;
8577 copy
->loc
->probe
= orig
->loc
->probe
;
8578 copy
->loc
->line_number
= orig
->loc
->line_number
;
8579 copy
->loc
->symtab
= orig
->loc
->symtab
;
8580 copy
->loc
->enabled
= loc_enabled
;
8581 copy
->frame_id
= orig
->frame_id
;
8582 copy
->thread
= orig
->thread
;
8583 copy
->pspace
= orig
->pspace
;
8585 copy
->enable_state
= bp_enabled
;
8586 copy
->disposition
= disp_donttouch
;
8587 copy
->number
= internal_breakpoint_number
--;
8589 update_global_location_list_nothrow (UGLL_DONT_INSERT
);
8593 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
8597 clone_momentary_breakpoint (struct breakpoint
*orig
)
8599 /* If there's nothing to clone, then return nothing. */
8603 return momentary_breakpoint_from_master (orig
, orig
->type
, orig
->ops
, 0);
8607 set_momentary_breakpoint_at_pc (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
8610 struct symtab_and_line sal
;
8612 sal
= find_pc_line (pc
, 0);
8614 sal
.section
= find_pc_overlay (pc
);
8615 sal
.explicit_pc
= 1;
8617 return set_momentary_breakpoint (gdbarch
, sal
, null_frame_id
, type
);
8621 /* Tell the user we have just set a breakpoint B. */
8624 mention (struct breakpoint
*b
)
8626 b
->ops
->print_mention (b
);
8627 if (current_uiout
->is_mi_like_p ())
8629 printf_filtered ("\n");
8633 static int bp_loc_is_permanent (struct bp_location
*loc
);
8635 static struct bp_location
*
8636 add_location_to_breakpoint (struct breakpoint
*b
,
8637 const struct symtab_and_line
*sal
)
8639 struct bp_location
*loc
, **tmp
;
8640 CORE_ADDR adjusted_address
;
8641 struct gdbarch
*loc_gdbarch
= get_sal_arch (*sal
);
8643 if (loc_gdbarch
== NULL
)
8644 loc_gdbarch
= b
->gdbarch
;
8646 /* Adjust the breakpoint's address prior to allocating a location.
8647 Once we call allocate_bp_location(), that mostly uninitialized
8648 location will be placed on the location chain. Adjustment of the
8649 breakpoint may cause target_read_memory() to be called and we do
8650 not want its scan of the location chain to find a breakpoint and
8651 location that's only been partially initialized. */
8652 adjusted_address
= adjust_breakpoint_address (loc_gdbarch
,
8655 /* Sort the locations by their ADDRESS. */
8656 loc
= allocate_bp_location (b
);
8657 for (tmp
= &(b
->loc
); *tmp
!= NULL
&& (*tmp
)->address
<= adjusted_address
;
8658 tmp
= &((*tmp
)->next
))
8663 loc
->requested_address
= sal
->pc
;
8664 loc
->address
= adjusted_address
;
8665 loc
->pspace
= sal
->pspace
;
8666 loc
->probe
.prob
= sal
->prob
;
8667 loc
->probe
.objfile
= sal
->objfile
;
8668 gdb_assert (loc
->pspace
!= NULL
);
8669 loc
->section
= sal
->section
;
8670 loc
->gdbarch
= loc_gdbarch
;
8671 loc
->line_number
= sal
->line
;
8672 loc
->symtab
= sal
->symtab
;
8673 loc
->symbol
= sal
->symbol
;
8675 set_breakpoint_location_function (loc
,
8676 sal
->explicit_pc
|| sal
->explicit_line
);
8678 /* While by definition, permanent breakpoints are already present in the
8679 code, we don't mark the location as inserted. Normally one would expect
8680 that GDB could rely on that breakpoint instruction to stop the program,
8681 thus removing the need to insert its own breakpoint, except that executing
8682 the breakpoint instruction can kill the target instead of reporting a
8683 SIGTRAP. E.g., on SPARC, when interrupts are disabled, executing the
8684 instruction resets the CPU, so QEMU 2.0.0 for SPARC correspondingly dies
8685 with "Trap 0x02 while interrupts disabled, Error state". Letting the
8686 breakpoint be inserted normally results in QEMU knowing about the GDB
8687 breakpoint, and thus trap before the breakpoint instruction is executed.
8688 (If GDB later needs to continue execution past the permanent breakpoint,
8689 it manually increments the PC, thus avoiding executing the breakpoint
8691 if (bp_loc_is_permanent (loc
))
8698 /* See breakpoint.h. */
8701 program_breakpoint_here_p (struct gdbarch
*gdbarch
, CORE_ADDR address
)
8705 const gdb_byte
*bpoint
;
8706 gdb_byte
*target_mem
;
8709 bpoint
= gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &len
);
8711 /* Software breakpoints unsupported? */
8715 target_mem
= (gdb_byte
*) alloca (len
);
8717 /* Enable the automatic memory restoration from breakpoints while
8718 we read the memory. Otherwise we could say about our temporary
8719 breakpoints they are permanent. */
8720 scoped_restore restore_memory
8721 = make_scoped_restore_show_memory_breakpoints (0);
8723 if (target_read_memory (address
, target_mem
, len
) == 0
8724 && memcmp (target_mem
, bpoint
, len
) == 0)
8730 /* Return 1 if LOC is pointing to a permanent breakpoint,
8731 return 0 otherwise. */
8734 bp_loc_is_permanent (struct bp_location
*loc
)
8736 gdb_assert (loc
!= NULL
);
8738 /* If we have a catchpoint or a watchpoint, just return 0. We should not
8739 attempt to read from the addresses the locations of these breakpoint types
8740 point to. program_breakpoint_here_p, below, will attempt to read
8742 if (!breakpoint_address_is_meaningful (loc
->owner
))
8745 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
8746 switch_to_program_space_and_thread (loc
->pspace
);
8747 return program_breakpoint_here_p (loc
->gdbarch
, loc
->address
);
8750 /* Build a command list for the dprintf corresponding to the current
8751 settings of the dprintf style options. */
8754 update_dprintf_command_list (struct breakpoint
*b
)
8756 char *dprintf_args
= b
->extra_string
;
8757 char *printf_line
= NULL
;
8762 dprintf_args
= skip_spaces (dprintf_args
);
8764 /* Allow a comma, as it may have terminated a location, but don't
8766 if (*dprintf_args
== ',')
8768 dprintf_args
= skip_spaces (dprintf_args
);
8770 if (*dprintf_args
!= '"')
8771 error (_("Bad format string, missing '\"'."));
8773 if (strcmp (dprintf_style
, dprintf_style_gdb
) == 0)
8774 printf_line
= xstrprintf ("printf %s", dprintf_args
);
8775 else if (strcmp (dprintf_style
, dprintf_style_call
) == 0)
8777 if (!dprintf_function
)
8778 error (_("No function supplied for dprintf call"));
8780 if (dprintf_channel
&& strlen (dprintf_channel
) > 0)
8781 printf_line
= xstrprintf ("call (void) %s (%s,%s)",
8786 printf_line
= xstrprintf ("call (void) %s (%s)",
8790 else if (strcmp (dprintf_style
, dprintf_style_agent
) == 0)
8792 if (target_can_run_breakpoint_commands ())
8793 printf_line
= xstrprintf ("agent-printf %s", dprintf_args
);
8796 warning (_("Target cannot run dprintf commands, falling back to GDB printf"));
8797 printf_line
= xstrprintf ("printf %s", dprintf_args
);
8801 internal_error (__FILE__
, __LINE__
,
8802 _("Invalid dprintf style."));
8804 gdb_assert (printf_line
!= NULL
);
8805 /* Manufacture a printf sequence. */
8807 struct command_line
*printf_cmd_line
= XNEW (struct command_line
);
8809 printf_cmd_line
->control_type
= simple_control
;
8810 printf_cmd_line
->body_count
= 0;
8811 printf_cmd_line
->body_list
= NULL
;
8812 printf_cmd_line
->next
= NULL
;
8813 printf_cmd_line
->line
= printf_line
;
8815 breakpoint_set_commands (b
, command_line_up (printf_cmd_line
));
8819 /* Update all dprintf commands, making their command lists reflect
8820 current style settings. */
8823 update_dprintf_commands (const char *args
, int from_tty
,
8824 struct cmd_list_element
*c
)
8826 struct breakpoint
*b
;
8830 if (b
->type
== bp_dprintf
)
8831 update_dprintf_command_list (b
);
8835 /* Create a breakpoint with SAL as location. Use LOCATION
8836 as a description of the location, and COND_STRING
8837 as condition expression. If LOCATION is NULL then create an
8838 "address location" from the address in the SAL. */
8841 init_breakpoint_sal (struct breakpoint
*b
, struct gdbarch
*gdbarch
,
8842 gdb::array_view
<const symtab_and_line
> sals
,
8843 event_location_up
&&location
,
8844 gdb::unique_xmalloc_ptr
<char> filter
,
8845 gdb::unique_xmalloc_ptr
<char> cond_string
,
8846 gdb::unique_xmalloc_ptr
<char> extra_string
,
8847 enum bptype type
, enum bpdisp disposition
,
8848 int thread
, int task
, int ignore_count
,
8849 const struct breakpoint_ops
*ops
, int from_tty
,
8850 int enabled
, int internal
, unsigned flags
,
8851 int display_canonical
)
8855 if (type
== bp_hardware_breakpoint
)
8857 int target_resources_ok
;
8859 i
= hw_breakpoint_used_count ();
8860 target_resources_ok
=
8861 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
8863 if (target_resources_ok
== 0)
8864 error (_("No hardware breakpoint support in the target."));
8865 else if (target_resources_ok
< 0)
8866 error (_("Hardware breakpoints used exceeds limit."));
8869 gdb_assert (!sals
.empty ());
8871 for (const auto &sal
: sals
)
8873 struct bp_location
*loc
;
8877 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
8879 loc_gdbarch
= gdbarch
;
8881 describe_other_breakpoints (loc_gdbarch
,
8882 sal
.pspace
, sal
.pc
, sal
.section
, thread
);
8885 if (&sal
== &sals
[0])
8887 init_raw_breakpoint (b
, gdbarch
, sal
, type
, ops
);
8891 b
->cond_string
= cond_string
.release ();
8892 b
->extra_string
= extra_string
.release ();
8893 b
->ignore_count
= ignore_count
;
8894 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
8895 b
->disposition
= disposition
;
8897 if ((flags
& CREATE_BREAKPOINT_FLAGS_INSERTED
) != 0)
8898 b
->loc
->inserted
= 1;
8900 if (type
== bp_static_tracepoint
)
8902 struct tracepoint
*t
= (struct tracepoint
*) b
;
8903 struct static_tracepoint_marker marker
;
8905 if (strace_marker_p (b
))
8907 /* We already know the marker exists, otherwise, we
8908 wouldn't see a sal for it. */
8910 = &event_location_to_string (b
->location
.get ())[3];
8913 p
= skip_spaces (p
);
8915 endp
= skip_to_space (p
);
8917 t
->static_trace_marker_id
.assign (p
, endp
- p
);
8919 printf_filtered (_("Probed static tracepoint "
8921 t
->static_trace_marker_id
.c_str ());
8923 else if (target_static_tracepoint_marker_at (sal
.pc
, &marker
))
8925 t
->static_trace_marker_id
= std::move (marker
.str_id
);
8927 printf_filtered (_("Probed static tracepoint "
8929 t
->static_trace_marker_id
.c_str ());
8932 warning (_("Couldn't determine the static "
8933 "tracepoint marker to probe"));
8940 loc
= add_location_to_breakpoint (b
, &sal
);
8941 if ((flags
& CREATE_BREAKPOINT_FLAGS_INSERTED
) != 0)
8947 const char *arg
= b
->cond_string
;
8949 loc
->cond
= parse_exp_1 (&arg
, loc
->address
,
8950 block_for_pc (loc
->address
), 0);
8952 error (_("Garbage '%s' follows condition"), arg
);
8955 /* Dynamic printf requires and uses additional arguments on the
8956 command line, otherwise it's an error. */
8957 if (type
== bp_dprintf
)
8959 if (b
->extra_string
)
8960 update_dprintf_command_list (b
);
8962 error (_("Format string required"));
8964 else if (b
->extra_string
)
8965 error (_("Garbage '%s' at end of command"), b
->extra_string
);
8968 b
->display_canonical
= display_canonical
;
8969 if (location
!= NULL
)
8970 b
->location
= std::move (location
);
8972 b
->location
= new_address_location (b
->loc
->address
, NULL
, 0);
8973 b
->filter
= filter
.release ();
8977 create_breakpoint_sal (struct gdbarch
*gdbarch
,
8978 gdb::array_view
<const symtab_and_line
> sals
,
8979 event_location_up
&&location
,
8980 gdb::unique_xmalloc_ptr
<char> filter
,
8981 gdb::unique_xmalloc_ptr
<char> cond_string
,
8982 gdb::unique_xmalloc_ptr
<char> extra_string
,
8983 enum bptype type
, enum bpdisp disposition
,
8984 int thread
, int task
, int ignore_count
,
8985 const struct breakpoint_ops
*ops
, int from_tty
,
8986 int enabled
, int internal
, unsigned flags
,
8987 int display_canonical
)
8989 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (type
);
8991 init_breakpoint_sal (b
.get (), gdbarch
,
8992 sals
, std::move (location
),
8994 std::move (cond_string
),
8995 std::move (extra_string
),
8997 thread
, task
, ignore_count
,
8999 enabled
, internal
, flags
,
9002 install_breakpoint (internal
, std::move (b
), 0);
9005 /* Add SALS.nelts breakpoints to the breakpoint table. For each
9006 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
9007 value. COND_STRING, if not NULL, specified the condition to be
9008 used for all breakpoints. Essentially the only case where
9009 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
9010 function. In that case, it's still not possible to specify
9011 separate conditions for different overloaded functions, so
9012 we take just a single condition string.
9014 NOTE: If the function succeeds, the caller is expected to cleanup
9015 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
9016 array contents). If the function fails (error() is called), the
9017 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
9018 COND and SALS arrays and each of those arrays contents. */
9021 create_breakpoints_sal (struct gdbarch
*gdbarch
,
9022 struct linespec_result
*canonical
,
9023 gdb::unique_xmalloc_ptr
<char> cond_string
,
9024 gdb::unique_xmalloc_ptr
<char> extra_string
,
9025 enum bptype type
, enum bpdisp disposition
,
9026 int thread
, int task
, int ignore_count
,
9027 const struct breakpoint_ops
*ops
, int from_tty
,
9028 int enabled
, int internal
, unsigned flags
)
9030 if (canonical
->pre_expanded
)
9031 gdb_assert (canonical
->lsals
.size () == 1);
9033 for (const auto &lsal
: canonical
->lsals
)
9035 /* Note that 'location' can be NULL in the case of a plain
9036 'break', without arguments. */
9037 event_location_up location
9038 = (canonical
->location
!= NULL
9039 ? copy_event_location (canonical
->location
.get ()) : NULL
);
9040 gdb::unique_xmalloc_ptr
<char> filter_string
9041 (lsal
.canonical
!= NULL
? xstrdup (lsal
.canonical
) : NULL
);
9043 create_breakpoint_sal (gdbarch
, lsal
.sals
,
9044 std::move (location
),
9045 std::move (filter_string
),
9046 std::move (cond_string
),
9047 std::move (extra_string
),
9049 thread
, task
, ignore_count
, ops
,
9050 from_tty
, enabled
, internal
, flags
,
9051 canonical
->special_display
);
9055 /* Parse LOCATION which is assumed to be a SAL specification possibly
9056 followed by conditionals. On return, SALS contains an array of SAL
9057 addresses found. LOCATION points to the end of the SAL (for
9058 linespec locations).
9060 The array and the line spec strings are allocated on the heap, it is
9061 the caller's responsibility to free them. */
9064 parse_breakpoint_sals (const struct event_location
*location
,
9065 struct linespec_result
*canonical
)
9067 struct symtab_and_line cursal
;
9069 if (event_location_type (location
) == LINESPEC_LOCATION
)
9071 const char *spec
= get_linespec_location (location
)->spec_string
;
9075 /* The last displayed codepoint, if it's valid, is our default
9076 breakpoint address. */
9077 if (last_displayed_sal_is_valid ())
9079 /* Set sal's pspace, pc, symtab, and line to the values
9080 corresponding to the last call to print_frame_info.
9081 Be sure to reinitialize LINE with NOTCURRENT == 0
9082 as the breakpoint line number is inappropriate otherwise.
9083 find_pc_line would adjust PC, re-set it back. */
9084 symtab_and_line sal
= get_last_displayed_sal ();
9085 CORE_ADDR pc
= sal
.pc
;
9087 sal
= find_pc_line (pc
, 0);
9089 /* "break" without arguments is equivalent to "break *PC"
9090 where PC is the last displayed codepoint's address. So
9091 make sure to set sal.explicit_pc to prevent GDB from
9092 trying to expand the list of sals to include all other
9093 instances with the same symtab and line. */
9095 sal
.explicit_pc
= 1;
9097 struct linespec_sals lsal
;
9099 lsal
.canonical
= NULL
;
9101 canonical
->lsals
.push_back (std::move (lsal
));
9105 error (_("No default breakpoint address now."));
9109 /* Force almost all breakpoints to be in terms of the
9110 current_source_symtab (which is decode_line_1's default).
9111 This should produce the results we want almost all of the
9112 time while leaving default_breakpoint_* alone.
9114 ObjC: However, don't match an Objective-C method name which
9115 may have a '+' or '-' succeeded by a '['. */
9116 cursal
= get_current_source_symtab_and_line ();
9117 if (last_displayed_sal_is_valid ())
9119 const char *spec
= NULL
;
9121 if (event_location_type (location
) == LINESPEC_LOCATION
)
9122 spec
= get_linespec_location (location
)->spec_string
;
9126 && strchr ("+-", spec
[0]) != NULL
9129 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, NULL
,
9130 get_last_displayed_symtab (),
9131 get_last_displayed_line (),
9132 canonical
, NULL
, NULL
);
9137 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, NULL
,
9138 cursal
.symtab
, cursal
.line
, canonical
, NULL
, NULL
);
9142 /* Convert each SAL into a real PC. Verify that the PC can be
9143 inserted as a breakpoint. If it can't throw an error. */
9146 breakpoint_sals_to_pc (std::vector
<symtab_and_line
> &sals
)
9148 for (auto &sal
: sals
)
9149 resolve_sal_pc (&sal
);
9152 /* Fast tracepoints may have restrictions on valid locations. For
9153 instance, a fast tracepoint using a jump instead of a trap will
9154 likely have to overwrite more bytes than a trap would, and so can
9155 only be placed where the instruction is longer than the jump, or a
9156 multi-instruction sequence does not have a jump into the middle of
9160 check_fast_tracepoint_sals (struct gdbarch
*gdbarch
,
9161 gdb::array_view
<const symtab_and_line
> sals
)
9163 for (const auto &sal
: sals
)
9165 struct gdbarch
*sarch
;
9167 sarch
= get_sal_arch (sal
);
9168 /* We fall back to GDBARCH if there is no architecture
9169 associated with SAL. */
9173 if (!gdbarch_fast_tracepoint_valid_at (sarch
, sal
.pc
, &msg
))
9174 error (_("May not have a fast tracepoint at %s%s"),
9175 paddress (sarch
, sal
.pc
), msg
.c_str ());
9179 /* Given TOK, a string specification of condition and thread, as
9180 accepted by the 'break' command, extract the condition
9181 string and thread number and set *COND_STRING and *THREAD.
9182 PC identifies the context at which the condition should be parsed.
9183 If no condition is found, *COND_STRING is set to NULL.
9184 If no thread is found, *THREAD is set to -1. */
9187 find_condition_and_thread (const char *tok
, CORE_ADDR pc
,
9188 char **cond_string
, int *thread
, int *task
,
9191 *cond_string
= NULL
;
9198 const char *end_tok
;
9200 const char *cond_start
= NULL
;
9201 const char *cond_end
= NULL
;
9203 tok
= skip_spaces (tok
);
9205 if ((*tok
== '"' || *tok
== ',') && rest
)
9207 *rest
= savestring (tok
, strlen (tok
));
9211 end_tok
= skip_to_space (tok
);
9213 toklen
= end_tok
- tok
;
9215 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
9217 tok
= cond_start
= end_tok
+ 1;
9218 parse_exp_1 (&tok
, pc
, block_for_pc (pc
), 0);
9220 *cond_string
= savestring (cond_start
, cond_end
- cond_start
);
9222 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
9225 struct thread_info
*thr
;
9228 thr
= parse_thread_id (tok
, &tmptok
);
9230 error (_("Junk after thread keyword."));
9231 *thread
= thr
->global_num
;
9234 else if (toklen
>= 1 && strncmp (tok
, "task", toklen
) == 0)
9239 *task
= strtol (tok
, &tmptok
, 0);
9241 error (_("Junk after task keyword."));
9242 if (!valid_task_id (*task
))
9243 error (_("Unknown task %d."), *task
);
9248 *rest
= savestring (tok
, strlen (tok
));
9252 error (_("Junk at end of arguments."));
9256 /* Decode a static tracepoint marker spec. */
9258 static std::vector
<symtab_and_line
>
9259 decode_static_tracepoint_spec (const char **arg_p
)
9261 const char *p
= &(*arg_p
)[3];
9264 p
= skip_spaces (p
);
9266 endp
= skip_to_space (p
);
9268 std::string
marker_str (p
, endp
- p
);
9270 std::vector
<static_tracepoint_marker
> markers
9271 = target_static_tracepoint_markers_by_strid (marker_str
.c_str ());
9272 if (markers
.empty ())
9273 error (_("No known static tracepoint marker named %s"),
9274 marker_str
.c_str ());
9276 std::vector
<symtab_and_line
> sals
;
9277 sals
.reserve (markers
.size ());
9279 for (const static_tracepoint_marker
&marker
: markers
)
9281 symtab_and_line sal
= find_pc_line (marker
.address
, 0);
9282 sal
.pc
= marker
.address
;
9283 sals
.push_back (sal
);
9290 /* See breakpoint.h. */
9293 create_breakpoint (struct gdbarch
*gdbarch
,
9294 const struct event_location
*location
,
9295 const char *cond_string
,
9296 int thread
, const char *extra_string
,
9298 int tempflag
, enum bptype type_wanted
,
9300 enum auto_boolean pending_break_support
,
9301 const struct breakpoint_ops
*ops
,
9302 int from_tty
, int enabled
, int internal
,
9305 struct linespec_result canonical
;
9306 struct cleanup
*bkpt_chain
= NULL
;
9309 int prev_bkpt_count
= breakpoint_count
;
9311 gdb_assert (ops
!= NULL
);
9313 /* If extra_string isn't useful, set it to NULL. */
9314 if (extra_string
!= NULL
&& *extra_string
== '\0')
9315 extra_string
= NULL
;
9319 ops
->create_sals_from_location (location
, &canonical
, type_wanted
);
9321 CATCH (e
, RETURN_MASK_ERROR
)
9323 /* If caller is interested in rc value from parse, set
9325 if (e
.error
== NOT_FOUND_ERROR
)
9327 /* If pending breakpoint support is turned off, throw
9330 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
9331 throw_exception (e
);
9333 exception_print (gdb_stderr
, e
);
9335 /* If pending breakpoint support is auto query and the user
9336 selects no, then simply return the error code. */
9337 if (pending_break_support
== AUTO_BOOLEAN_AUTO
9338 && !nquery (_("Make %s pending on future shared library load? "),
9339 bptype_string (type_wanted
)))
9342 /* At this point, either the user was queried about setting
9343 a pending breakpoint and selected yes, or pending
9344 breakpoint behavior is on and thus a pending breakpoint
9345 is defaulted on behalf of the user. */
9349 throw_exception (e
);
9353 if (!pending
&& canonical
.lsals
.empty ())
9356 /* ----------------------------- SNIP -----------------------------
9357 Anything added to the cleanup chain beyond this point is assumed
9358 to be part of a breakpoint. If the breakpoint create succeeds
9359 then the memory is not reclaimed. */
9360 bkpt_chain
= make_cleanup (null_cleanup
, 0);
9362 /* Resolve all line numbers to PC's and verify that the addresses
9363 are ok for the target. */
9366 for (auto &lsal
: canonical
.lsals
)
9367 breakpoint_sals_to_pc (lsal
.sals
);
9370 /* Fast tracepoints may have additional restrictions on location. */
9371 if (!pending
&& type_wanted
== bp_fast_tracepoint
)
9373 for (const auto &lsal
: canonical
.lsals
)
9374 check_fast_tracepoint_sals (gdbarch
, lsal
.sals
);
9377 /* Verify that condition can be parsed, before setting any
9378 breakpoints. Allocate a separate condition expression for each
9382 gdb::unique_xmalloc_ptr
<char> cond_string_copy
;
9383 gdb::unique_xmalloc_ptr
<char> extra_string_copy
;
9390 const linespec_sals
&lsal
= canonical
.lsals
[0];
9392 /* Here we only parse 'arg' to separate condition
9393 from thread number, so parsing in context of first
9394 sal is OK. When setting the breakpoint we'll
9395 re-parse it in context of each sal. */
9397 find_condition_and_thread (extra_string
, lsal
.sals
[0].pc
,
9398 &cond
, &thread
, &task
, &rest
);
9399 cond_string_copy
.reset (cond
);
9400 extra_string_copy
.reset (rest
);
9404 if (type_wanted
!= bp_dprintf
9405 && extra_string
!= NULL
&& *extra_string
!= '\0')
9406 error (_("Garbage '%s' at end of location"), extra_string
);
9408 /* Create a private copy of condition string. */
9410 cond_string_copy
.reset (xstrdup (cond_string
));
9411 /* Create a private copy of any extra string. */
9413 extra_string_copy
.reset (xstrdup (extra_string
));
9416 ops
->create_breakpoints_sal (gdbarch
, &canonical
,
9417 std::move (cond_string_copy
),
9418 std::move (extra_string_copy
),
9420 tempflag
? disp_del
: disp_donttouch
,
9421 thread
, task
, ignore_count
, ops
,
9422 from_tty
, enabled
, internal
, flags
);
9426 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (type_wanted
);
9428 init_raw_breakpoint_without_location (b
.get (), gdbarch
, type_wanted
, ops
);
9429 b
->location
= copy_event_location (location
);
9432 b
->cond_string
= NULL
;
9435 /* Create a private copy of condition string. */
9436 b
->cond_string
= cond_string
!= NULL
? xstrdup (cond_string
) : NULL
;
9440 /* Create a private copy of any extra string. */
9441 b
->extra_string
= extra_string
!= NULL
? xstrdup (extra_string
) : NULL
;
9442 b
->ignore_count
= ignore_count
;
9443 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
9444 b
->condition_not_parsed
= 1;
9445 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
9446 if ((type_wanted
!= bp_breakpoint
9447 && type_wanted
!= bp_hardware_breakpoint
) || thread
!= -1)
9448 b
->pspace
= current_program_space
;
9450 install_breakpoint (internal
, std::move (b
), 0);
9453 if (canonical
.lsals
.size () > 1)
9455 warning (_("Multiple breakpoints were set.\nUse the "
9456 "\"delete\" command to delete unwanted breakpoints."));
9457 prev_breakpoint_count
= prev_bkpt_count
;
9460 /* That's it. Discard the cleanups for data inserted into the
9462 discard_cleanups (bkpt_chain
);
9464 /* error call may happen here - have BKPT_CHAIN already discarded. */
9465 update_global_location_list (UGLL_MAY_INSERT
);
9470 /* Set a breakpoint.
9471 ARG is a string describing breakpoint address,
9472 condition, and thread.
9473 FLAG specifies if a breakpoint is hardware on,
9474 and if breakpoint is temporary, using BP_HARDWARE_FLAG
9478 break_command_1 (const char *arg
, int flag
, int from_tty
)
9480 int tempflag
= flag
& BP_TEMPFLAG
;
9481 enum bptype type_wanted
= (flag
& BP_HARDWAREFLAG
9482 ? bp_hardware_breakpoint
9484 struct breakpoint_ops
*ops
;
9486 event_location_up location
= string_to_event_location (&arg
, current_language
);
9488 /* Matching breakpoints on probes. */
9489 if (location
!= NULL
9490 && event_location_type (location
.get ()) == PROBE_LOCATION
)
9491 ops
= &bkpt_probe_breakpoint_ops
;
9493 ops
= &bkpt_breakpoint_ops
;
9495 create_breakpoint (get_current_arch (),
9497 NULL
, 0, arg
, 1 /* parse arg */,
9498 tempflag
, type_wanted
,
9499 0 /* Ignore count */,
9500 pending_break_support
,
9508 /* Helper function for break_command_1 and disassemble_command. */
9511 resolve_sal_pc (struct symtab_and_line
*sal
)
9515 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
9517 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
9518 error (_("No line %d in file \"%s\"."),
9519 sal
->line
, symtab_to_filename_for_display (sal
->symtab
));
9522 /* If this SAL corresponds to a breakpoint inserted using a line
9523 number, then skip the function prologue if necessary. */
9524 if (sal
->explicit_line
)
9525 skip_prologue_sal (sal
);
9528 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
9530 const struct blockvector
*bv
;
9531 const struct block
*b
;
9534 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
,
9535 SYMTAB_COMPUNIT (sal
->symtab
));
9538 sym
= block_linkage_function (b
);
9541 fixup_symbol_section (sym
, SYMTAB_OBJFILE (sal
->symtab
));
9542 sal
->section
= SYMBOL_OBJ_SECTION (SYMTAB_OBJFILE (sal
->symtab
),
9547 /* It really is worthwhile to have the section, so we'll
9548 just have to look harder. This case can be executed
9549 if we have line numbers but no functions (as can
9550 happen in assembly source). */
9552 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
9553 switch_to_program_space_and_thread (sal
->pspace
);
9555 bound_minimal_symbol msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
9557 sal
->section
= MSYMBOL_OBJ_SECTION (msym
.objfile
, msym
.minsym
);
9564 break_command (const char *arg
, int from_tty
)
9566 break_command_1 (arg
, 0, from_tty
);
9570 tbreak_command (const char *arg
, int from_tty
)
9572 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
9576 hbreak_command (const char *arg
, int from_tty
)
9578 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
9582 thbreak_command (const char *arg
, int from_tty
)
9584 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
9588 stop_command (const char *arg
, int from_tty
)
9590 printf_filtered (_("Specify the type of breakpoint to set.\n\
9591 Usage: stop in <function | address>\n\
9592 stop at <line>\n"));
9596 stopin_command (const char *arg
, int from_tty
)
9600 if (arg
== (char *) NULL
)
9602 else if (*arg
!= '*')
9604 const char *argptr
= arg
;
9607 /* Look for a ':'. If this is a line number specification, then
9608 say it is bad, otherwise, it should be an address or
9609 function/method name. */
9610 while (*argptr
&& !hasColon
)
9612 hasColon
= (*argptr
== ':');
9617 badInput
= (*argptr
!= ':'); /* Not a class::method */
9619 badInput
= isdigit (*arg
); /* a simple line number */
9623 printf_filtered (_("Usage: stop in <function | address>\n"));
9625 break_command_1 (arg
, 0, from_tty
);
9629 stopat_command (const char *arg
, int from_tty
)
9633 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
9637 const char *argptr
= arg
;
9640 /* Look for a ':'. If there is a '::' then get out, otherwise
9641 it is probably a line number. */
9642 while (*argptr
&& !hasColon
)
9644 hasColon
= (*argptr
== ':');
9649 badInput
= (*argptr
== ':'); /* we have class::method */
9651 badInput
= !isdigit (*arg
); /* not a line number */
9655 printf_filtered (_("Usage: stop at <line>\n"));
9657 break_command_1 (arg
, 0, from_tty
);
9660 /* The dynamic printf command is mostly like a regular breakpoint, but
9661 with a prewired command list consisting of a single output command,
9662 built from extra arguments supplied on the dprintf command
9666 dprintf_command (const char *arg
, int from_tty
)
9668 event_location_up location
= string_to_event_location (&arg
, current_language
);
9670 /* If non-NULL, ARG should have been advanced past the location;
9671 the next character must be ','. */
9674 if (arg
[0] != ',' || arg
[1] == '\0')
9675 error (_("Format string required"));
9678 /* Skip the comma. */
9683 create_breakpoint (get_current_arch (),
9685 NULL
, 0, arg
, 1 /* parse arg */,
9687 0 /* Ignore count */,
9688 pending_break_support
,
9689 &dprintf_breakpoint_ops
,
9697 agent_printf_command (const char *arg
, int from_tty
)
9699 error (_("May only run agent-printf on the target"));
9702 /* Implement the "breakpoint_hit" breakpoint_ops method for
9703 ranged breakpoints. */
9706 breakpoint_hit_ranged_breakpoint (const struct bp_location
*bl
,
9707 const address_space
*aspace
,
9709 const struct target_waitstatus
*ws
)
9711 if (ws
->kind
!= TARGET_WAITKIND_STOPPED
9712 || ws
->value
.sig
!= GDB_SIGNAL_TRAP
)
9715 return breakpoint_address_match_range (bl
->pspace
->aspace
, bl
->address
,
9716 bl
->length
, aspace
, bp_addr
);
9719 /* Implement the "resources_needed" breakpoint_ops method for
9720 ranged breakpoints. */
9723 resources_needed_ranged_breakpoint (const struct bp_location
*bl
)
9725 return target_ranged_break_num_registers ();
9728 /* Implement the "print_it" breakpoint_ops method for
9729 ranged breakpoints. */
9731 static enum print_stop_action
9732 print_it_ranged_breakpoint (bpstat bs
)
9734 struct breakpoint
*b
= bs
->breakpoint_at
;
9735 struct bp_location
*bl
= b
->loc
;
9736 struct ui_out
*uiout
= current_uiout
;
9738 gdb_assert (b
->type
== bp_hardware_breakpoint
);
9740 /* Ranged breakpoints have only one location. */
9741 gdb_assert (bl
&& bl
->next
== NULL
);
9743 annotate_breakpoint (b
->number
);
9745 maybe_print_thread_hit_breakpoint (uiout
);
9747 if (b
->disposition
== disp_del
)
9748 uiout
->text ("Temporary ranged breakpoint ");
9750 uiout
->text ("Ranged breakpoint ");
9751 if (uiout
->is_mi_like_p ())
9753 uiout
->field_string ("reason",
9754 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
9755 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
9757 uiout
->field_int ("bkptno", b
->number
);
9760 return PRINT_SRC_AND_LOC
;
9763 /* Implement the "print_one" breakpoint_ops method for
9764 ranged breakpoints. */
9767 print_one_ranged_breakpoint (struct breakpoint
*b
,
9768 struct bp_location
**last_loc
)
9770 struct bp_location
*bl
= b
->loc
;
9771 struct value_print_options opts
;
9772 struct ui_out
*uiout
= current_uiout
;
9774 /* Ranged breakpoints have only one location. */
9775 gdb_assert (bl
&& bl
->next
== NULL
);
9777 get_user_print_options (&opts
);
9779 if (opts
.addressprint
)
9780 /* We don't print the address range here, it will be printed later
9781 by print_one_detail_ranged_breakpoint. */
9782 uiout
->field_skip ("addr");
9784 print_breakpoint_location (b
, bl
);
9788 /* Implement the "print_one_detail" breakpoint_ops method for
9789 ranged breakpoints. */
9792 print_one_detail_ranged_breakpoint (const struct breakpoint
*b
,
9793 struct ui_out
*uiout
)
9795 CORE_ADDR address_start
, address_end
;
9796 struct bp_location
*bl
= b
->loc
;
9801 address_start
= bl
->address
;
9802 address_end
= address_start
+ bl
->length
- 1;
9804 uiout
->text ("\taddress range: ");
9805 stb
.printf ("[%s, %s]",
9806 print_core_address (bl
->gdbarch
, address_start
),
9807 print_core_address (bl
->gdbarch
, address_end
));
9808 uiout
->field_stream ("addr", stb
);
9812 /* Implement the "print_mention" breakpoint_ops method for
9813 ranged breakpoints. */
9816 print_mention_ranged_breakpoint (struct breakpoint
*b
)
9818 struct bp_location
*bl
= b
->loc
;
9819 struct ui_out
*uiout
= current_uiout
;
9822 gdb_assert (b
->type
== bp_hardware_breakpoint
);
9824 if (uiout
->is_mi_like_p ())
9827 printf_filtered (_("Hardware assisted ranged breakpoint %d from %s to %s."),
9828 b
->number
, paddress (bl
->gdbarch
, bl
->address
),
9829 paddress (bl
->gdbarch
, bl
->address
+ bl
->length
- 1));
9832 /* Implement the "print_recreate" breakpoint_ops method for
9833 ranged breakpoints. */
9836 print_recreate_ranged_breakpoint (struct breakpoint
*b
, struct ui_file
*fp
)
9838 fprintf_unfiltered (fp
, "break-range %s, %s",
9839 event_location_to_string (b
->location
.get ()),
9840 event_location_to_string (b
->location_range_end
.get ()));
9841 print_recreate_thread (b
, fp
);
9844 /* The breakpoint_ops structure to be used in ranged breakpoints. */
9846 static struct breakpoint_ops ranged_breakpoint_ops
;
9848 /* Find the address where the end of the breakpoint range should be
9849 placed, given the SAL of the end of the range. This is so that if
9850 the user provides a line number, the end of the range is set to the
9851 last instruction of the given line. */
9854 find_breakpoint_range_end (struct symtab_and_line sal
)
9858 /* If the user provided a PC value, use it. Otherwise,
9859 find the address of the end of the given location. */
9860 if (sal
.explicit_pc
)
9867 ret
= find_line_pc_range (sal
, &start
, &end
);
9869 error (_("Could not find location of the end of the range."));
9871 /* find_line_pc_range returns the start of the next line. */
9878 /* Implement the "break-range" CLI command. */
9881 break_range_command (const char *arg
, int from_tty
)
9883 const char *arg_start
;
9884 struct linespec_result canonical_start
, canonical_end
;
9885 int bp_count
, can_use_bp
, length
;
9887 struct breakpoint
*b
;
9889 /* We don't support software ranged breakpoints. */
9890 if (target_ranged_break_num_registers () < 0)
9891 error (_("This target does not support hardware ranged breakpoints."));
9893 bp_count
= hw_breakpoint_used_count ();
9894 bp_count
+= target_ranged_break_num_registers ();
9895 can_use_bp
= target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
9898 error (_("Hardware breakpoints used exceeds limit."));
9900 arg
= skip_spaces (arg
);
9901 if (arg
== NULL
|| arg
[0] == '\0')
9902 error(_("No address range specified."));
9905 event_location_up start_location
= string_to_event_location (&arg
,
9907 parse_breakpoint_sals (start_location
.get (), &canonical_start
);
9910 error (_("Too few arguments."));
9911 else if (canonical_start
.lsals
.empty ())
9912 error (_("Could not find location of the beginning of the range."));
9914 const linespec_sals
&lsal_start
= canonical_start
.lsals
[0];
9916 if (canonical_start
.lsals
.size () > 1
9917 || lsal_start
.sals
.size () != 1)
9918 error (_("Cannot create a ranged breakpoint with multiple locations."));
9920 const symtab_and_line
&sal_start
= lsal_start
.sals
[0];
9921 std::string
addr_string_start (arg_start
, arg
- arg_start
);
9923 arg
++; /* Skip the comma. */
9924 arg
= skip_spaces (arg
);
9926 /* Parse the end location. */
9930 /* We call decode_line_full directly here instead of using
9931 parse_breakpoint_sals because we need to specify the start location's
9932 symtab and line as the default symtab and line for the end of the
9933 range. This makes it possible to have ranges like "foo.c:27, +14",
9934 where +14 means 14 lines from the start location. */
9935 event_location_up end_location
= string_to_event_location (&arg
,
9937 decode_line_full (end_location
.get (), DECODE_LINE_FUNFIRSTLINE
, NULL
,
9938 sal_start
.symtab
, sal_start
.line
,
9939 &canonical_end
, NULL
, NULL
);
9941 if (canonical_end
.lsals
.empty ())
9942 error (_("Could not find location of the end of the range."));
9944 const linespec_sals
&lsal_end
= canonical_end
.lsals
[0];
9945 if (canonical_end
.lsals
.size () > 1
9946 || lsal_end
.sals
.size () != 1)
9947 error (_("Cannot create a ranged breakpoint with multiple locations."));
9949 const symtab_and_line
&sal_end
= lsal_end
.sals
[0];
9951 end
= find_breakpoint_range_end (sal_end
);
9952 if (sal_start
.pc
> end
)
9953 error (_("Invalid address range, end precedes start."));
9955 length
= end
- sal_start
.pc
+ 1;
9957 /* Length overflowed. */
9958 error (_("Address range too large."));
9959 else if (length
== 1)
9961 /* This range is simple enough to be handled by
9962 the `hbreak' command. */
9963 hbreak_command (&addr_string_start
[0], 1);
9968 /* Now set up the breakpoint. */
9969 b
= set_raw_breakpoint (get_current_arch (), sal_start
,
9970 bp_hardware_breakpoint
, &ranged_breakpoint_ops
);
9971 set_breakpoint_count (breakpoint_count
+ 1);
9972 b
->number
= breakpoint_count
;
9973 b
->disposition
= disp_donttouch
;
9974 b
->location
= std::move (start_location
);
9975 b
->location_range_end
= std::move (end_location
);
9976 b
->loc
->length
= length
;
9979 gdb::observers::breakpoint_created
.notify (b
);
9980 update_global_location_list (UGLL_MAY_INSERT
);
9983 /* Return non-zero if EXP is verified as constant. Returned zero
9984 means EXP is variable. Also the constant detection may fail for
9985 some constant expressions and in such case still falsely return
9989 watchpoint_exp_is_const (const struct expression
*exp
)
9997 /* We are only interested in the descriptor of each element. */
9998 operator_length (exp
, i
, &oplenp
, &argsp
);
10001 switch (exp
->elts
[i
].opcode
)
10011 case BINOP_LOGICAL_AND
:
10012 case BINOP_LOGICAL_OR
:
10013 case BINOP_BITWISE_AND
:
10014 case BINOP_BITWISE_IOR
:
10015 case BINOP_BITWISE_XOR
:
10017 case BINOP_NOTEQUAL
:
10043 case OP_OBJC_NSSTRING
:
10046 case UNOP_LOGICAL_NOT
:
10047 case UNOP_COMPLEMENT
:
10052 case UNOP_CAST_TYPE
:
10053 case UNOP_REINTERPRET_CAST
:
10054 case UNOP_DYNAMIC_CAST
:
10055 /* Unary, binary and ternary operators: We have to check
10056 their operands. If they are constant, then so is the
10057 result of that operation. For instance, if A and B are
10058 determined to be constants, then so is "A + B".
10060 UNOP_IND is one exception to the rule above, because the
10061 value of *ADDR is not necessarily a constant, even when
10066 /* Check whether the associated symbol is a constant.
10068 We use SYMBOL_CLASS rather than TYPE_CONST because it's
10069 possible that a buggy compiler could mark a variable as
10070 constant even when it is not, and TYPE_CONST would return
10071 true in this case, while SYMBOL_CLASS wouldn't.
10073 We also have to check for function symbols because they
10074 are always constant. */
10076 struct symbol
*s
= exp
->elts
[i
+ 2].symbol
;
10078 if (SYMBOL_CLASS (s
) != LOC_BLOCK
10079 && SYMBOL_CLASS (s
) != LOC_CONST
10080 && SYMBOL_CLASS (s
) != LOC_CONST_BYTES
)
10085 /* The default action is to return 0 because we are using
10086 the optimistic approach here: If we don't know something,
10087 then it is not a constant. */
10096 /* Watchpoint destructor. */
10098 watchpoint::~watchpoint ()
10100 xfree (this->exp_string
);
10101 xfree (this->exp_string_reparse
);
10102 value_decref (this->val
);
10105 /* Implement the "re_set" breakpoint_ops method for watchpoints. */
10108 re_set_watchpoint (struct breakpoint
*b
)
10110 struct watchpoint
*w
= (struct watchpoint
*) b
;
10112 /* Watchpoint can be either on expression using entirely global
10113 variables, or it can be on local variables.
10115 Watchpoints of the first kind are never auto-deleted, and even
10116 persist across program restarts. Since they can use variables
10117 from shared libraries, we need to reparse expression as libraries
10118 are loaded and unloaded.
10120 Watchpoints on local variables can also change meaning as result
10121 of solib event. For example, if a watchpoint uses both a local
10122 and a global variables in expression, it's a local watchpoint,
10123 but unloading of a shared library will make the expression
10124 invalid. This is not a very common use case, but we still
10125 re-evaluate expression, to avoid surprises to the user.
10127 Note that for local watchpoints, we re-evaluate it only if
10128 watchpoints frame id is still valid. If it's not, it means the
10129 watchpoint is out of scope and will be deleted soon. In fact,
10130 I'm not sure we'll ever be called in this case.
10132 If a local watchpoint's frame id is still valid, then
10133 w->exp_valid_block is likewise valid, and we can safely use it.
10135 Don't do anything about disabled watchpoints, since they will be
10136 reevaluated again when enabled. */
10137 update_watchpoint (w
, 1 /* reparse */);
10140 /* Implement the "insert" breakpoint_ops method for hardware watchpoints. */
10143 insert_watchpoint (struct bp_location
*bl
)
10145 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10146 int length
= w
->exact
? 1 : bl
->length
;
10148 return target_insert_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
10149 w
->cond_exp
.get ());
10152 /* Implement the "remove" breakpoint_ops method for hardware watchpoints. */
10155 remove_watchpoint (struct bp_location
*bl
, enum remove_bp_reason reason
)
10157 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10158 int length
= w
->exact
? 1 : bl
->length
;
10160 return target_remove_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
10161 w
->cond_exp
.get ());
10165 breakpoint_hit_watchpoint (const struct bp_location
*bl
,
10166 const address_space
*aspace
, CORE_ADDR bp_addr
,
10167 const struct target_waitstatus
*ws
)
10169 struct breakpoint
*b
= bl
->owner
;
10170 struct watchpoint
*w
= (struct watchpoint
*) b
;
10172 /* Continuable hardware watchpoints are treated as non-existent if the
10173 reason we stopped wasn't a hardware watchpoint (we didn't stop on
10174 some data address). Otherwise gdb won't stop on a break instruction
10175 in the code (not from a breakpoint) when a hardware watchpoint has
10176 been defined. Also skip watchpoints which we know did not trigger
10177 (did not match the data address). */
10178 if (is_hardware_watchpoint (b
)
10179 && w
->watchpoint_triggered
== watch_triggered_no
)
10186 check_status_watchpoint (bpstat bs
)
10188 gdb_assert (is_watchpoint (bs
->breakpoint_at
));
10190 bpstat_check_watchpoint (bs
);
10193 /* Implement the "resources_needed" breakpoint_ops method for
10194 hardware watchpoints. */
10197 resources_needed_watchpoint (const struct bp_location
*bl
)
10199 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10200 int length
= w
->exact
? 1 : bl
->length
;
10202 return target_region_ok_for_hw_watchpoint (bl
->address
, length
);
10205 /* Implement the "works_in_software_mode" breakpoint_ops method for
10206 hardware watchpoints. */
10209 works_in_software_mode_watchpoint (const struct breakpoint
*b
)
10211 /* Read and access watchpoints only work with hardware support. */
10212 return b
->type
== bp_watchpoint
|| b
->type
== bp_hardware_watchpoint
;
10215 static enum print_stop_action
10216 print_it_watchpoint (bpstat bs
)
10218 struct breakpoint
*b
;
10219 enum print_stop_action result
;
10220 struct watchpoint
*w
;
10221 struct ui_out
*uiout
= current_uiout
;
10223 gdb_assert (bs
->bp_location_at
!= NULL
);
10225 b
= bs
->breakpoint_at
;
10226 w
= (struct watchpoint
*) b
;
10228 annotate_watchpoint (b
->number
);
10229 maybe_print_thread_hit_breakpoint (uiout
);
10233 gdb::optional
<ui_out_emit_tuple
> tuple_emitter
;
10236 case bp_watchpoint
:
10237 case bp_hardware_watchpoint
:
10238 if (uiout
->is_mi_like_p ())
10239 uiout
->field_string
10240 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
10242 tuple_emitter
.emplace (uiout
, "value");
10243 uiout
->text ("\nOld value = ");
10244 watchpoint_value_print (bs
->old_val
, &stb
);
10245 uiout
->field_stream ("old", stb
);
10246 uiout
->text ("\nNew value = ");
10247 watchpoint_value_print (w
->val
, &stb
);
10248 uiout
->field_stream ("new", stb
);
10249 uiout
->text ("\n");
10250 /* More than one watchpoint may have been triggered. */
10251 result
= PRINT_UNKNOWN
;
10254 case bp_read_watchpoint
:
10255 if (uiout
->is_mi_like_p ())
10256 uiout
->field_string
10257 ("reason", async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
10259 tuple_emitter
.emplace (uiout
, "value");
10260 uiout
->text ("\nValue = ");
10261 watchpoint_value_print (w
->val
, &stb
);
10262 uiout
->field_stream ("value", stb
);
10263 uiout
->text ("\n");
10264 result
= PRINT_UNKNOWN
;
10267 case bp_access_watchpoint
:
10268 if (bs
->old_val
!= NULL
)
10270 if (uiout
->is_mi_like_p ())
10271 uiout
->field_string
10273 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
10275 tuple_emitter
.emplace (uiout
, "value");
10276 uiout
->text ("\nOld value = ");
10277 watchpoint_value_print (bs
->old_val
, &stb
);
10278 uiout
->field_stream ("old", stb
);
10279 uiout
->text ("\nNew value = ");
10284 if (uiout
->is_mi_like_p ())
10285 uiout
->field_string
10287 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
10288 tuple_emitter
.emplace (uiout
, "value");
10289 uiout
->text ("\nValue = ");
10291 watchpoint_value_print (w
->val
, &stb
);
10292 uiout
->field_stream ("new", stb
);
10293 uiout
->text ("\n");
10294 result
= PRINT_UNKNOWN
;
10297 result
= PRINT_UNKNOWN
;
10303 /* Implement the "print_mention" breakpoint_ops method for hardware
10307 print_mention_watchpoint (struct breakpoint
*b
)
10309 struct watchpoint
*w
= (struct watchpoint
*) b
;
10310 struct ui_out
*uiout
= current_uiout
;
10311 const char *tuple_name
;
10315 case bp_watchpoint
:
10316 uiout
->text ("Watchpoint ");
10317 tuple_name
= "wpt";
10319 case bp_hardware_watchpoint
:
10320 uiout
->text ("Hardware watchpoint ");
10321 tuple_name
= "wpt";
10323 case bp_read_watchpoint
:
10324 uiout
->text ("Hardware read watchpoint ");
10325 tuple_name
= "hw-rwpt";
10327 case bp_access_watchpoint
:
10328 uiout
->text ("Hardware access (read/write) watchpoint ");
10329 tuple_name
= "hw-awpt";
10332 internal_error (__FILE__
, __LINE__
,
10333 _("Invalid hardware watchpoint type."));
10336 ui_out_emit_tuple
tuple_emitter (uiout
, tuple_name
);
10337 uiout
->field_int ("number", b
->number
);
10338 uiout
->text (": ");
10339 uiout
->field_string ("exp", w
->exp_string
);
10342 /* Implement the "print_recreate" breakpoint_ops method for
10346 print_recreate_watchpoint (struct breakpoint
*b
, struct ui_file
*fp
)
10348 struct watchpoint
*w
= (struct watchpoint
*) b
;
10352 case bp_watchpoint
:
10353 case bp_hardware_watchpoint
:
10354 fprintf_unfiltered (fp
, "watch");
10356 case bp_read_watchpoint
:
10357 fprintf_unfiltered (fp
, "rwatch");
10359 case bp_access_watchpoint
:
10360 fprintf_unfiltered (fp
, "awatch");
10363 internal_error (__FILE__
, __LINE__
,
10364 _("Invalid watchpoint type."));
10367 fprintf_unfiltered (fp
, " %s", w
->exp_string
);
10368 print_recreate_thread (b
, fp
);
10371 /* Implement the "explains_signal" breakpoint_ops method for
10375 explains_signal_watchpoint (struct breakpoint
*b
, enum gdb_signal sig
)
10377 /* A software watchpoint cannot cause a signal other than
10378 GDB_SIGNAL_TRAP. */
10379 if (b
->type
== bp_watchpoint
&& sig
!= GDB_SIGNAL_TRAP
)
10385 /* The breakpoint_ops structure to be used in hardware watchpoints. */
10387 static struct breakpoint_ops watchpoint_breakpoint_ops
;
10389 /* Implement the "insert" breakpoint_ops method for
10390 masked hardware watchpoints. */
10393 insert_masked_watchpoint (struct bp_location
*bl
)
10395 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10397 return target_insert_mask_watchpoint (bl
->address
, w
->hw_wp_mask
,
10398 bl
->watchpoint_type
);
10401 /* Implement the "remove" breakpoint_ops method for
10402 masked hardware watchpoints. */
10405 remove_masked_watchpoint (struct bp_location
*bl
, enum remove_bp_reason reason
)
10407 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10409 return target_remove_mask_watchpoint (bl
->address
, w
->hw_wp_mask
,
10410 bl
->watchpoint_type
);
10413 /* Implement the "resources_needed" breakpoint_ops method for
10414 masked hardware watchpoints. */
10417 resources_needed_masked_watchpoint (const struct bp_location
*bl
)
10419 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10421 return target_masked_watch_num_registers (bl
->address
, w
->hw_wp_mask
);
10424 /* Implement the "works_in_software_mode" breakpoint_ops method for
10425 masked hardware watchpoints. */
10428 works_in_software_mode_masked_watchpoint (const struct breakpoint
*b
)
10433 /* Implement the "print_it" breakpoint_ops method for
10434 masked hardware watchpoints. */
10436 static enum print_stop_action
10437 print_it_masked_watchpoint (bpstat bs
)
10439 struct breakpoint
*b
= bs
->breakpoint_at
;
10440 struct ui_out
*uiout
= current_uiout
;
10442 /* Masked watchpoints have only one location. */
10443 gdb_assert (b
->loc
&& b
->loc
->next
== NULL
);
10445 annotate_watchpoint (b
->number
);
10446 maybe_print_thread_hit_breakpoint (uiout
);
10450 case bp_hardware_watchpoint
:
10451 if (uiout
->is_mi_like_p ())
10452 uiout
->field_string
10453 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
10456 case bp_read_watchpoint
:
10457 if (uiout
->is_mi_like_p ())
10458 uiout
->field_string
10459 ("reason", async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
10462 case bp_access_watchpoint
:
10463 if (uiout
->is_mi_like_p ())
10464 uiout
->field_string
10466 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
10469 internal_error (__FILE__
, __LINE__
,
10470 _("Invalid hardware watchpoint type."));
10474 uiout
->text (_("\n\
10475 Check the underlying instruction at PC for the memory\n\
10476 address and value which triggered this watchpoint.\n"));
10477 uiout
->text ("\n");
10479 /* More than one watchpoint may have been triggered. */
10480 return PRINT_UNKNOWN
;
10483 /* Implement the "print_one_detail" breakpoint_ops method for
10484 masked hardware watchpoints. */
10487 print_one_detail_masked_watchpoint (const struct breakpoint
*b
,
10488 struct ui_out
*uiout
)
10490 struct watchpoint
*w
= (struct watchpoint
*) b
;
10492 /* Masked watchpoints have only one location. */
10493 gdb_assert (b
->loc
&& b
->loc
->next
== NULL
);
10495 uiout
->text ("\tmask ");
10496 uiout
->field_core_addr ("mask", b
->loc
->gdbarch
, w
->hw_wp_mask
);
10497 uiout
->text ("\n");
10500 /* Implement the "print_mention" breakpoint_ops method for
10501 masked hardware watchpoints. */
10504 print_mention_masked_watchpoint (struct breakpoint
*b
)
10506 struct watchpoint
*w
= (struct watchpoint
*) b
;
10507 struct ui_out
*uiout
= current_uiout
;
10508 const char *tuple_name
;
10512 case bp_hardware_watchpoint
:
10513 uiout
->text ("Masked hardware watchpoint ");
10514 tuple_name
= "wpt";
10516 case bp_read_watchpoint
:
10517 uiout
->text ("Masked hardware read watchpoint ");
10518 tuple_name
= "hw-rwpt";
10520 case bp_access_watchpoint
:
10521 uiout
->text ("Masked hardware access (read/write) watchpoint ");
10522 tuple_name
= "hw-awpt";
10525 internal_error (__FILE__
, __LINE__
,
10526 _("Invalid hardware watchpoint type."));
10529 ui_out_emit_tuple
tuple_emitter (uiout
, tuple_name
);
10530 uiout
->field_int ("number", b
->number
);
10531 uiout
->text (": ");
10532 uiout
->field_string ("exp", w
->exp_string
);
10535 /* Implement the "print_recreate" breakpoint_ops method for
10536 masked hardware watchpoints. */
10539 print_recreate_masked_watchpoint (struct breakpoint
*b
, struct ui_file
*fp
)
10541 struct watchpoint
*w
= (struct watchpoint
*) b
;
10546 case bp_hardware_watchpoint
:
10547 fprintf_unfiltered (fp
, "watch");
10549 case bp_read_watchpoint
:
10550 fprintf_unfiltered (fp
, "rwatch");
10552 case bp_access_watchpoint
:
10553 fprintf_unfiltered (fp
, "awatch");
10556 internal_error (__FILE__
, __LINE__
,
10557 _("Invalid hardware watchpoint type."));
10560 sprintf_vma (tmp
, w
->hw_wp_mask
);
10561 fprintf_unfiltered (fp
, " %s mask 0x%s", w
->exp_string
, tmp
);
10562 print_recreate_thread (b
, fp
);
10565 /* The breakpoint_ops structure to be used in masked hardware watchpoints. */
10567 static struct breakpoint_ops masked_watchpoint_breakpoint_ops
;
10569 /* Tell whether the given watchpoint is a masked hardware watchpoint. */
10572 is_masked_watchpoint (const struct breakpoint
*b
)
10574 return b
->ops
== &masked_watchpoint_breakpoint_ops
;
10577 /* accessflag: hw_write: watch write,
10578 hw_read: watch read,
10579 hw_access: watch access (read or write) */
10581 watch_command_1 (const char *arg
, int accessflag
, int from_tty
,
10582 int just_location
, int internal
)
10584 struct breakpoint
*scope_breakpoint
= NULL
;
10585 const struct block
*exp_valid_block
= NULL
, *cond_exp_valid_block
= NULL
;
10586 struct value
*val
, *mark
, *result
;
10587 int saved_bitpos
= 0, saved_bitsize
= 0;
10588 const char *exp_start
= NULL
;
10589 const char *exp_end
= NULL
;
10590 const char *tok
, *end_tok
;
10592 const char *cond_start
= NULL
;
10593 const char *cond_end
= NULL
;
10594 enum bptype bp_type
;
10597 /* Flag to indicate whether we are going to use masks for
10598 the hardware watchpoint. */
10600 CORE_ADDR mask
= 0;
10602 /* Make sure that we actually have parameters to parse. */
10603 if (arg
!= NULL
&& arg
[0] != '\0')
10605 const char *value_start
;
10607 exp_end
= arg
+ strlen (arg
);
10609 /* Look for "parameter value" pairs at the end
10610 of the arguments string. */
10611 for (tok
= exp_end
- 1; tok
> arg
; tok
--)
10613 /* Skip whitespace at the end of the argument list. */
10614 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
10617 /* Find the beginning of the last token.
10618 This is the value of the parameter. */
10619 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
10621 value_start
= tok
+ 1;
10623 /* Skip whitespace. */
10624 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
10629 /* Find the beginning of the second to last token.
10630 This is the parameter itself. */
10631 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
10634 toklen
= end_tok
- tok
+ 1;
10636 if (toklen
== 6 && startswith (tok
, "thread"))
10638 struct thread_info
*thr
;
10639 /* At this point we've found a "thread" token, which means
10640 the user is trying to set a watchpoint that triggers
10641 only in a specific thread. */
10645 error(_("You can specify only one thread."));
10647 /* Extract the thread ID from the next token. */
10648 thr
= parse_thread_id (value_start
, &endp
);
10650 /* Check if the user provided a valid thread ID. */
10651 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
10652 invalid_thread_id_error (value_start
);
10654 thread
= thr
->global_num
;
10656 else if (toklen
== 4 && startswith (tok
, "mask"))
10658 /* We've found a "mask" token, which means the user wants to
10659 create a hardware watchpoint that is going to have the mask
10661 struct value
*mask_value
, *mark
;
10664 error(_("You can specify only one mask."));
10666 use_mask
= just_location
= 1;
10668 mark
= value_mark ();
10669 mask_value
= parse_to_comma_and_eval (&value_start
);
10670 mask
= value_as_address (mask_value
);
10671 value_free_to_mark (mark
);
10674 /* We didn't recognize what we found. We should stop here. */
10677 /* Truncate the string and get rid of the "parameter value" pair before
10678 the arguments string is parsed by the parse_exp_1 function. */
10685 /* Parse the rest of the arguments. From here on out, everything
10686 is in terms of a newly allocated string instead of the original
10688 innermost_block
.reset ();
10689 std::string
expression (arg
, exp_end
- arg
);
10690 exp_start
= arg
= expression
.c_str ();
10691 expression_up exp
= parse_exp_1 (&arg
, 0, 0, 0);
10693 /* Remove trailing whitespace from the expression before saving it.
10694 This makes the eventual display of the expression string a bit
10696 while (exp_end
> exp_start
&& (exp_end
[-1] == ' ' || exp_end
[-1] == '\t'))
10699 /* Checking if the expression is not constant. */
10700 if (watchpoint_exp_is_const (exp
.get ()))
10704 len
= exp_end
- exp_start
;
10705 while (len
> 0 && isspace (exp_start
[len
- 1]))
10707 error (_("Cannot watch constant value `%.*s'."), len
, exp_start
);
10710 exp_valid_block
= innermost_block
.block ();
10711 mark
= value_mark ();
10712 fetch_subexp_value (exp
.get (), &pc
, &val
, &result
, NULL
, just_location
);
10714 if (val
!= NULL
&& just_location
)
10716 saved_bitpos
= value_bitpos (val
);
10717 saved_bitsize
= value_bitsize (val
);
10724 exp_valid_block
= NULL
;
10725 val
= release_value (value_addr (result
)).release ();
10726 value_free_to_mark (mark
);
10730 ret
= target_masked_watch_num_registers (value_as_address (val
),
10733 error (_("This target does not support masked watchpoints."));
10734 else if (ret
== -2)
10735 error (_("Invalid mask or memory region."));
10738 else if (val
!= NULL
)
10739 release_value (val
).release ();
10741 tok
= skip_spaces (arg
);
10742 end_tok
= skip_to_space (tok
);
10744 toklen
= end_tok
- tok
;
10745 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
10747 innermost_block
.reset ();
10748 tok
= cond_start
= end_tok
+ 1;
10749 parse_exp_1 (&tok
, 0, 0, 0);
10751 /* The watchpoint expression may not be local, but the condition
10752 may still be. E.g.: `watch global if local > 0'. */
10753 cond_exp_valid_block
= innermost_block
.block ();
10758 error (_("Junk at end of command."));
10760 frame_info
*wp_frame
= block_innermost_frame (exp_valid_block
);
10762 /* Save this because create_internal_breakpoint below invalidates
10764 frame_id watchpoint_frame
= get_frame_id (wp_frame
);
10766 /* If the expression is "local", then set up a "watchpoint scope"
10767 breakpoint at the point where we've left the scope of the watchpoint
10768 expression. Create the scope breakpoint before the watchpoint, so
10769 that we will encounter it first in bpstat_stop_status. */
10770 if (exp_valid_block
!= NULL
&& wp_frame
!= NULL
)
10772 frame_id caller_frame_id
= frame_unwind_caller_id (wp_frame
);
10774 if (frame_id_p (caller_frame_id
))
10776 gdbarch
*caller_arch
= frame_unwind_caller_arch (wp_frame
);
10777 CORE_ADDR caller_pc
= frame_unwind_caller_pc (wp_frame
);
10780 = create_internal_breakpoint (caller_arch
, caller_pc
,
10781 bp_watchpoint_scope
,
10782 &momentary_breakpoint_ops
);
10784 /* create_internal_breakpoint could invalidate WP_FRAME. */
10787 scope_breakpoint
->enable_state
= bp_enabled
;
10789 /* Automatically delete the breakpoint when it hits. */
10790 scope_breakpoint
->disposition
= disp_del
;
10792 /* Only break in the proper frame (help with recursion). */
10793 scope_breakpoint
->frame_id
= caller_frame_id
;
10795 /* Set the address at which we will stop. */
10796 scope_breakpoint
->loc
->gdbarch
= caller_arch
;
10797 scope_breakpoint
->loc
->requested_address
= caller_pc
;
10798 scope_breakpoint
->loc
->address
10799 = adjust_breakpoint_address (scope_breakpoint
->loc
->gdbarch
,
10800 scope_breakpoint
->loc
->requested_address
,
10801 scope_breakpoint
->type
);
10805 /* Now set up the breakpoint. We create all watchpoints as hardware
10806 watchpoints here even if hardware watchpoints are turned off, a call
10807 to update_watchpoint later in this function will cause the type to
10808 drop back to bp_watchpoint (software watchpoint) if required. */
10810 if (accessflag
== hw_read
)
10811 bp_type
= bp_read_watchpoint
;
10812 else if (accessflag
== hw_access
)
10813 bp_type
= bp_access_watchpoint
;
10815 bp_type
= bp_hardware_watchpoint
;
10817 std::unique_ptr
<watchpoint
> w (new watchpoint ());
10820 init_raw_breakpoint_without_location (w
.get (), NULL
, bp_type
,
10821 &masked_watchpoint_breakpoint_ops
);
10823 init_raw_breakpoint_without_location (w
.get (), NULL
, bp_type
,
10824 &watchpoint_breakpoint_ops
);
10825 w
->thread
= thread
;
10826 w
->disposition
= disp_donttouch
;
10827 w
->pspace
= current_program_space
;
10828 w
->exp
= std::move (exp
);
10829 w
->exp_valid_block
= exp_valid_block
;
10830 w
->cond_exp_valid_block
= cond_exp_valid_block
;
10833 struct type
*t
= value_type (val
);
10834 CORE_ADDR addr
= value_as_address (val
);
10836 w
->exp_string_reparse
10837 = current_language
->la_watch_location_expression (t
, addr
).release ();
10839 w
->exp_string
= xstrprintf ("-location %.*s",
10840 (int) (exp_end
- exp_start
), exp_start
);
10843 w
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
10847 w
->hw_wp_mask
= mask
;
10852 w
->val_bitpos
= saved_bitpos
;
10853 w
->val_bitsize
= saved_bitsize
;
10858 w
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
10860 w
->cond_string
= 0;
10862 if (frame_id_p (watchpoint_frame
))
10864 w
->watchpoint_frame
= watchpoint_frame
;
10865 w
->watchpoint_thread
= inferior_ptid
;
10869 w
->watchpoint_frame
= null_frame_id
;
10870 w
->watchpoint_thread
= null_ptid
;
10873 if (scope_breakpoint
!= NULL
)
10875 /* The scope breakpoint is related to the watchpoint. We will
10876 need to act on them together. */
10877 w
->related_breakpoint
= scope_breakpoint
;
10878 scope_breakpoint
->related_breakpoint
= w
.get ();
10881 if (!just_location
)
10882 value_free_to_mark (mark
);
10884 /* Finally update the new watchpoint. This creates the locations
10885 that should be inserted. */
10886 update_watchpoint (w
.get (), 1);
10888 install_breakpoint (internal
, std::move (w
), 1);
10891 /* Return count of debug registers needed to watch the given expression.
10892 If the watchpoint cannot be handled in hardware return zero. */
10895 can_use_hardware_watchpoint (struct value
*v
)
10897 int found_memory_cnt
= 0;
10898 struct value
*head
= v
;
10900 /* Did the user specifically forbid us to use hardware watchpoints? */
10901 if (!can_use_hw_watchpoints
)
10904 /* Make sure that the value of the expression depends only upon
10905 memory contents, and values computed from them within GDB. If we
10906 find any register references or function calls, we can't use a
10907 hardware watchpoint.
10909 The idea here is that evaluating an expression generates a series
10910 of values, one holding the value of every subexpression. (The
10911 expression a*b+c has five subexpressions: a, b, a*b, c, and
10912 a*b+c.) GDB's values hold almost enough information to establish
10913 the criteria given above --- they identify memory lvalues,
10914 register lvalues, computed values, etcetera. So we can evaluate
10915 the expression, and then scan the chain of values that leaves
10916 behind to decide whether we can detect any possible change to the
10917 expression's final value using only hardware watchpoints.
10919 However, I don't think that the values returned by inferior
10920 function calls are special in any way. So this function may not
10921 notice that an expression involving an inferior function call
10922 can't be watched with hardware watchpoints. FIXME. */
10923 for (; v
; v
= value_next (v
))
10925 if (VALUE_LVAL (v
) == lval_memory
)
10927 if (v
!= head
&& value_lazy (v
))
10928 /* A lazy memory lvalue in the chain is one that GDB never
10929 needed to fetch; we either just used its address (e.g.,
10930 `a' in `a.b') or we never needed it at all (e.g., `a'
10931 in `a,b'). This doesn't apply to HEAD; if that is
10932 lazy then it was not readable, but watch it anyway. */
10936 /* Ahh, memory we actually used! Check if we can cover
10937 it with hardware watchpoints. */
10938 struct type
*vtype
= check_typedef (value_type (v
));
10940 /* We only watch structs and arrays if user asked for it
10941 explicitly, never if they just happen to appear in a
10942 middle of some value chain. */
10944 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
10945 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
10947 CORE_ADDR vaddr
= value_address (v
);
10951 len
= (target_exact_watchpoints
10952 && is_scalar_type_recursive (vtype
))?
10953 1 : TYPE_LENGTH (value_type (v
));
10955 num_regs
= target_region_ok_for_hw_watchpoint (vaddr
, len
);
10959 found_memory_cnt
+= num_regs
;
10963 else if (VALUE_LVAL (v
) != not_lval
10964 && deprecated_value_modifiable (v
) == 0)
10965 return 0; /* These are values from the history (e.g., $1). */
10966 else if (VALUE_LVAL (v
) == lval_register
)
10967 return 0; /* Cannot watch a register with a HW watchpoint. */
10970 /* The expression itself looks suitable for using a hardware
10971 watchpoint, but give the target machine a chance to reject it. */
10972 return found_memory_cnt
;
10976 watch_command_wrapper (const char *arg
, int from_tty
, int internal
)
10978 watch_command_1 (arg
, hw_write
, from_tty
, 0, internal
);
10981 /* A helper function that looks for the "-location" argument and then
10982 calls watch_command_1. */
10985 watch_maybe_just_location (const char *arg
, int accessflag
, int from_tty
)
10987 int just_location
= 0;
10990 && (check_for_argument (&arg
, "-location", sizeof ("-location") - 1)
10991 || check_for_argument (&arg
, "-l", sizeof ("-l") - 1)))
10993 arg
= skip_spaces (arg
);
10997 watch_command_1 (arg
, accessflag
, from_tty
, just_location
, 0);
11001 watch_command (const char *arg
, int from_tty
)
11003 watch_maybe_just_location (arg
, hw_write
, from_tty
);
11007 rwatch_command_wrapper (const char *arg
, int from_tty
, int internal
)
11009 watch_command_1 (arg
, hw_read
, from_tty
, 0, internal
);
11013 rwatch_command (const char *arg
, int from_tty
)
11015 watch_maybe_just_location (arg
, hw_read
, from_tty
);
11019 awatch_command_wrapper (const char *arg
, int from_tty
, int internal
)
11021 watch_command_1 (arg
, hw_access
, from_tty
, 0, internal
);
11025 awatch_command (const char *arg
, int from_tty
)
11027 watch_maybe_just_location (arg
, hw_access
, from_tty
);
11031 /* Data for the FSM that manages the until(location)/advance commands
11032 in infcmd.c. Here because it uses the mechanisms of
11035 struct until_break_fsm
11037 /* The base class. */
11038 struct thread_fsm thread_fsm
;
11040 /* The thread that as current when the command was executed. */
11043 /* The breakpoint set at the destination location. */
11044 struct breakpoint
*location_breakpoint
;
11046 /* Breakpoint set at the return address in the caller frame. May be
11048 struct breakpoint
*caller_breakpoint
;
11051 static void until_break_fsm_clean_up (struct thread_fsm
*self
,
11052 struct thread_info
*thread
);
11053 static int until_break_fsm_should_stop (struct thread_fsm
*self
,
11054 struct thread_info
*thread
);
11055 static enum async_reply_reason
11056 until_break_fsm_async_reply_reason (struct thread_fsm
*self
);
11058 /* until_break_fsm's vtable. */
11060 static struct thread_fsm_ops until_break_fsm_ops
=
11063 until_break_fsm_clean_up
,
11064 until_break_fsm_should_stop
,
11065 NULL
, /* return_value */
11066 until_break_fsm_async_reply_reason
,
11069 /* Allocate a new until_break_command_fsm. */
11071 static struct until_break_fsm
*
11072 new_until_break_fsm (struct interp
*cmd_interp
, int thread
,
11073 breakpoint_up
&&location_breakpoint
,
11074 breakpoint_up
&&caller_breakpoint
)
11076 struct until_break_fsm
*sm
;
11078 sm
= XCNEW (struct until_break_fsm
);
11079 thread_fsm_ctor (&sm
->thread_fsm
, &until_break_fsm_ops
, cmd_interp
);
11081 sm
->thread
= thread
;
11082 sm
->location_breakpoint
= location_breakpoint
.release ();
11083 sm
->caller_breakpoint
= caller_breakpoint
.release ();
11088 /* Implementation of the 'should_stop' FSM method for the
11089 until(location)/advance commands. */
11092 until_break_fsm_should_stop (struct thread_fsm
*self
,
11093 struct thread_info
*tp
)
11095 struct until_break_fsm
*sm
= (struct until_break_fsm
*) self
;
11097 if (bpstat_find_breakpoint (tp
->control
.stop_bpstat
,
11098 sm
->location_breakpoint
) != NULL
11099 || (sm
->caller_breakpoint
!= NULL
11100 && bpstat_find_breakpoint (tp
->control
.stop_bpstat
,
11101 sm
->caller_breakpoint
) != NULL
))
11102 thread_fsm_set_finished (self
);
11107 /* Implementation of the 'clean_up' FSM method for the
11108 until(location)/advance commands. */
11111 until_break_fsm_clean_up (struct thread_fsm
*self
,
11112 struct thread_info
*thread
)
11114 struct until_break_fsm
*sm
= (struct until_break_fsm
*) self
;
11116 /* Clean up our temporary breakpoints. */
11117 if (sm
->location_breakpoint
!= NULL
)
11119 delete_breakpoint (sm
->location_breakpoint
);
11120 sm
->location_breakpoint
= NULL
;
11122 if (sm
->caller_breakpoint
!= NULL
)
11124 delete_breakpoint (sm
->caller_breakpoint
);
11125 sm
->caller_breakpoint
= NULL
;
11127 delete_longjmp_breakpoint (sm
->thread
);
11130 /* Implementation of the 'async_reply_reason' FSM method for the
11131 until(location)/advance commands. */
11133 static enum async_reply_reason
11134 until_break_fsm_async_reply_reason (struct thread_fsm
*self
)
11136 return EXEC_ASYNC_LOCATION_REACHED
;
11140 until_break_command (const char *arg
, int from_tty
, int anywhere
)
11142 struct frame_info
*frame
;
11143 struct gdbarch
*frame_gdbarch
;
11144 struct frame_id stack_frame_id
;
11145 struct frame_id caller_frame_id
;
11146 struct cleanup
*old_chain
;
11148 struct thread_info
*tp
;
11149 struct until_break_fsm
*sm
;
11151 clear_proceed_status (0);
11153 /* Set a breakpoint where the user wants it and at return from
11156 event_location_up location
= string_to_event_location (&arg
, current_language
);
11158 std::vector
<symtab_and_line
> sals
11159 = (last_displayed_sal_is_valid ()
11160 ? decode_line_1 (location
.get (), DECODE_LINE_FUNFIRSTLINE
, NULL
,
11161 get_last_displayed_symtab (),
11162 get_last_displayed_line ())
11163 : decode_line_1 (location
.get (), DECODE_LINE_FUNFIRSTLINE
,
11164 NULL
, (struct symtab
*) NULL
, 0));
11166 if (sals
.size () != 1)
11167 error (_("Couldn't get information on specified line."));
11169 symtab_and_line
&sal
= sals
[0];
11172 error (_("Junk at end of arguments."));
11174 resolve_sal_pc (&sal
);
11176 tp
= inferior_thread ();
11177 thread
= tp
->global_num
;
11179 old_chain
= make_cleanup (null_cleanup
, NULL
);
11181 /* Note linespec handling above invalidates the frame chain.
11182 Installing a breakpoint also invalidates the frame chain (as it
11183 may need to switch threads), so do any frame handling before
11186 frame
= get_selected_frame (NULL
);
11187 frame_gdbarch
= get_frame_arch (frame
);
11188 stack_frame_id
= get_stack_frame_id (frame
);
11189 caller_frame_id
= frame_unwind_caller_id (frame
);
11191 /* Keep within the current frame, or in frames called by the current
11194 breakpoint_up caller_breakpoint
;
11195 if (frame_id_p (caller_frame_id
))
11197 struct symtab_and_line sal2
;
11198 struct gdbarch
*caller_gdbarch
;
11200 sal2
= find_pc_line (frame_unwind_caller_pc (frame
), 0);
11201 sal2
.pc
= frame_unwind_caller_pc (frame
);
11202 caller_gdbarch
= frame_unwind_caller_arch (frame
);
11203 caller_breakpoint
= set_momentary_breakpoint (caller_gdbarch
,
11208 set_longjmp_breakpoint (tp
, caller_frame_id
);
11209 make_cleanup (delete_longjmp_breakpoint_cleanup
, &thread
);
11212 /* set_momentary_breakpoint could invalidate FRAME. */
11215 breakpoint_up location_breakpoint
;
11217 /* If the user told us to continue until a specified location,
11218 we don't specify a frame at which we need to stop. */
11219 location_breakpoint
= set_momentary_breakpoint (frame_gdbarch
, sal
,
11220 null_frame_id
, bp_until
);
11222 /* Otherwise, specify the selected frame, because we want to stop
11223 only at the very same frame. */
11224 location_breakpoint
= set_momentary_breakpoint (frame_gdbarch
, sal
,
11225 stack_frame_id
, bp_until
);
11227 sm
= new_until_break_fsm (command_interp (), tp
->global_num
,
11228 std::move (location_breakpoint
),
11229 std::move (caller_breakpoint
));
11230 tp
->thread_fsm
= &sm
->thread_fsm
;
11232 discard_cleanups (old_chain
);
11234 proceed (-1, GDB_SIGNAL_DEFAULT
);
11237 /* This function attempts to parse an optional "if <cond>" clause
11238 from the arg string. If one is not found, it returns NULL.
11240 Else, it returns a pointer to the condition string. (It does not
11241 attempt to evaluate the string against a particular block.) And,
11242 it updates arg to point to the first character following the parsed
11243 if clause in the arg string. */
11246 ep_parse_optional_if_clause (const char **arg
)
11248 const char *cond_string
;
11250 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
11253 /* Skip the "if" keyword. */
11256 /* Skip any extra leading whitespace, and record the start of the
11257 condition string. */
11258 *arg
= skip_spaces (*arg
);
11259 cond_string
= *arg
;
11261 /* Assume that the condition occupies the remainder of the arg
11263 (*arg
) += strlen (cond_string
);
11265 return cond_string
;
11268 /* Commands to deal with catching events, such as signals, exceptions,
11269 process start/exit, etc. */
11273 catch_fork_temporary
, catch_vfork_temporary
,
11274 catch_fork_permanent
, catch_vfork_permanent
11279 catch_fork_command_1 (const char *arg
, int from_tty
,
11280 struct cmd_list_element
*command
)
11282 struct gdbarch
*gdbarch
= get_current_arch ();
11283 const char *cond_string
= NULL
;
11284 catch_fork_kind fork_kind
;
11287 fork_kind
= (catch_fork_kind
) (uintptr_t) get_cmd_context (command
);
11288 tempflag
= (fork_kind
== catch_fork_temporary
11289 || fork_kind
== catch_vfork_temporary
);
11293 arg
= skip_spaces (arg
);
11295 /* The allowed syntax is:
11297 catch [v]fork if <cond>
11299 First, check if there's an if clause. */
11300 cond_string
= ep_parse_optional_if_clause (&arg
);
11302 if ((*arg
!= '\0') && !isspace (*arg
))
11303 error (_("Junk at end of arguments."));
11305 /* If this target supports it, create a fork or vfork catchpoint
11306 and enable reporting of such events. */
11309 case catch_fork_temporary
:
11310 case catch_fork_permanent
:
11311 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
11312 &catch_fork_breakpoint_ops
);
11314 case catch_vfork_temporary
:
11315 case catch_vfork_permanent
:
11316 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
11317 &catch_vfork_breakpoint_ops
);
11320 error (_("unsupported or unknown fork kind; cannot catch it"));
11326 catch_exec_command_1 (const char *arg
, int from_tty
,
11327 struct cmd_list_element
*command
)
11329 struct gdbarch
*gdbarch
= get_current_arch ();
11331 const char *cond_string
= NULL
;
11333 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
11337 arg
= skip_spaces (arg
);
11339 /* The allowed syntax is:
11341 catch exec if <cond>
11343 First, check if there's an if clause. */
11344 cond_string
= ep_parse_optional_if_clause (&arg
);
11346 if ((*arg
!= '\0') && !isspace (*arg
))
11347 error (_("Junk at end of arguments."));
11349 std::unique_ptr
<exec_catchpoint
> c (new exec_catchpoint ());
11350 init_catchpoint (c
.get (), gdbarch
, tempflag
, cond_string
,
11351 &catch_exec_breakpoint_ops
);
11352 c
->exec_pathname
= NULL
;
11354 install_breakpoint (0, std::move (c
), 1);
11358 init_ada_exception_breakpoint (struct breakpoint
*b
,
11359 struct gdbarch
*gdbarch
,
11360 struct symtab_and_line sal
,
11361 const char *addr_string
,
11362 const struct breakpoint_ops
*ops
,
11369 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
11371 loc_gdbarch
= gdbarch
;
11373 describe_other_breakpoints (loc_gdbarch
,
11374 sal
.pspace
, sal
.pc
, sal
.section
, -1);
11375 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
11376 version for exception catchpoints, because two catchpoints
11377 used for different exception names will use the same address.
11378 In this case, a "breakpoint ... also set at..." warning is
11379 unproductive. Besides, the warning phrasing is also a bit
11380 inappropriate, we should use the word catchpoint, and tell
11381 the user what type of catchpoint it is. The above is good
11382 enough for now, though. */
11385 init_raw_breakpoint (b
, gdbarch
, sal
, bp_breakpoint
, ops
);
11387 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
11388 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
11389 b
->location
= string_to_event_location (&addr_string
,
11390 language_def (language_ada
));
11391 b
->language
= language_ada
;
11395 catch_command (const char *arg
, int from_tty
)
11397 error (_("Catch requires an event name."));
11402 tcatch_command (const char *arg
, int from_tty
)
11404 error (_("Catch requires an event name."));
11407 /* Compare two breakpoints and return a strcmp-like result. */
11410 compare_breakpoints (const breakpoint
*a
, const breakpoint
*b
)
11412 uintptr_t ua
= (uintptr_t) a
;
11413 uintptr_t ub
= (uintptr_t) b
;
11415 if (a
->number
< b
->number
)
11417 else if (a
->number
> b
->number
)
11420 /* Now sort by address, in case we see, e..g, two breakpoints with
11424 return ua
> ub
? 1 : 0;
11427 /* Delete breakpoints by address or line. */
11430 clear_command (const char *arg
, int from_tty
)
11432 struct breakpoint
*b
;
11435 std::vector
<symtab_and_line
> decoded_sals
;
11436 symtab_and_line last_sal
;
11437 gdb::array_view
<symtab_and_line
> sals
;
11441 = decode_line_with_current_source (arg
,
11442 (DECODE_LINE_FUNFIRSTLINE
11443 | DECODE_LINE_LIST_MODE
));
11445 sals
= decoded_sals
;
11449 /* Set sal's line, symtab, pc, and pspace to the values
11450 corresponding to the last call to print_frame_info. If the
11451 codepoint is not valid, this will set all the fields to 0. */
11452 last_sal
= get_last_displayed_sal ();
11453 if (last_sal
.symtab
== 0)
11454 error (_("No source file specified."));
11460 /* We don't call resolve_sal_pc here. That's not as bad as it
11461 seems, because all existing breakpoints typically have both
11462 file/line and pc set. So, if clear is given file/line, we can
11463 match this to existing breakpoint without obtaining pc at all.
11465 We only support clearing given the address explicitly
11466 present in breakpoint table. Say, we've set breakpoint
11467 at file:line. There were several PC values for that file:line,
11468 due to optimization, all in one block.
11470 We've picked one PC value. If "clear" is issued with another
11471 PC corresponding to the same file:line, the breakpoint won't
11472 be cleared. We probably can still clear the breakpoint, but
11473 since the other PC value is never presented to user, user
11474 can only find it by guessing, and it does not seem important
11475 to support that. */
11477 /* For each line spec given, delete bps which correspond to it. Do
11478 it in two passes, solely to preserve the current behavior that
11479 from_tty is forced true if we delete more than one
11482 std::vector
<struct breakpoint
*> found
;
11483 for (const auto &sal
: sals
)
11485 const char *sal_fullname
;
11487 /* If exact pc given, clear bpts at that pc.
11488 If line given (pc == 0), clear all bpts on specified line.
11489 If defaulting, clear all bpts on default line
11492 defaulting sal.pc != 0 tests to do
11497 1 0 <can't happen> */
11499 sal_fullname
= (sal
.symtab
== NULL
11500 ? NULL
: symtab_to_fullname (sal
.symtab
));
11502 /* Find all matching breakpoints and add them to 'found'. */
11503 ALL_BREAKPOINTS (b
)
11506 /* Are we going to delete b? */
11507 if (b
->type
!= bp_none
&& !is_watchpoint (b
))
11509 struct bp_location
*loc
= b
->loc
;
11510 for (; loc
; loc
= loc
->next
)
11512 /* If the user specified file:line, don't allow a PC
11513 match. This matches historical gdb behavior. */
11514 int pc_match
= (!sal
.explicit_line
11516 && (loc
->pspace
== sal
.pspace
)
11517 && (loc
->address
== sal
.pc
)
11518 && (!section_is_overlay (loc
->section
)
11519 || loc
->section
== sal
.section
));
11520 int line_match
= 0;
11522 if ((default_match
|| sal
.explicit_line
)
11523 && loc
->symtab
!= NULL
11524 && sal_fullname
!= NULL
11525 && sal
.pspace
== loc
->pspace
11526 && loc
->line_number
== sal
.line
11527 && filename_cmp (symtab_to_fullname (loc
->symtab
),
11528 sal_fullname
) == 0)
11531 if (pc_match
|| line_match
)
11540 found
.push_back (b
);
11544 /* Now go thru the 'found' chain and delete them. */
11545 if (found
.empty ())
11548 error (_("No breakpoint at %s."), arg
);
11550 error (_("No breakpoint at this line."));
11553 /* Remove duplicates from the vec. */
11554 std::sort (found
.begin (), found
.end (),
11555 [] (const breakpoint
*a
, const breakpoint
*b
)
11557 return compare_breakpoints (a
, b
) < 0;
11559 found
.erase (std::unique (found
.begin (), found
.end (),
11560 [] (const breakpoint
*a
, const breakpoint
*b
)
11562 return compare_breakpoints (a
, b
) == 0;
11566 if (found
.size () > 1)
11567 from_tty
= 1; /* Always report if deleted more than one. */
11570 if (found
.size () == 1)
11571 printf_unfiltered (_("Deleted breakpoint "));
11573 printf_unfiltered (_("Deleted breakpoints "));
11576 for (breakpoint
*iter
: found
)
11579 printf_unfiltered ("%d ", iter
->number
);
11580 delete_breakpoint (iter
);
11583 putchar_unfiltered ('\n');
11586 /* Delete breakpoint in BS if they are `delete' breakpoints and
11587 all breakpoints that are marked for deletion, whether hit or not.
11588 This is called after any breakpoint is hit, or after errors. */
11591 breakpoint_auto_delete (bpstat bs
)
11593 struct breakpoint
*b
, *b_tmp
;
11595 for (; bs
; bs
= bs
->next
)
11596 if (bs
->breakpoint_at
11597 && bs
->breakpoint_at
->disposition
== disp_del
11599 delete_breakpoint (bs
->breakpoint_at
);
11601 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
11603 if (b
->disposition
== disp_del_at_next_stop
)
11604 delete_breakpoint (b
);
11608 /* A comparison function for bp_location AP and BP being interfaced to
11609 qsort. Sort elements primarily by their ADDRESS (no matter what
11610 does breakpoint_address_is_meaningful say for its OWNER),
11611 secondarily by ordering first permanent elements and
11612 terciarily just ensuring the array is sorted stable way despite
11613 qsort being an unstable algorithm. */
11616 bp_locations_compare (const void *ap
, const void *bp
)
11618 const struct bp_location
*a
= *(const struct bp_location
**) ap
;
11619 const struct bp_location
*b
= *(const struct bp_location
**) bp
;
11621 if (a
->address
!= b
->address
)
11622 return (a
->address
> b
->address
) - (a
->address
< b
->address
);
11624 /* Sort locations at the same address by their pspace number, keeping
11625 locations of the same inferior (in a multi-inferior environment)
11628 if (a
->pspace
->num
!= b
->pspace
->num
)
11629 return ((a
->pspace
->num
> b
->pspace
->num
)
11630 - (a
->pspace
->num
< b
->pspace
->num
));
11632 /* Sort permanent breakpoints first. */
11633 if (a
->permanent
!= b
->permanent
)
11634 return (a
->permanent
< b
->permanent
) - (a
->permanent
> b
->permanent
);
11636 /* Make the internal GDB representation stable across GDB runs
11637 where A and B memory inside GDB can differ. Breakpoint locations of
11638 the same type at the same address can be sorted in arbitrary order. */
11640 if (a
->owner
->number
!= b
->owner
->number
)
11641 return ((a
->owner
->number
> b
->owner
->number
)
11642 - (a
->owner
->number
< b
->owner
->number
));
11644 return (a
> b
) - (a
< b
);
11647 /* Set bp_locations_placed_address_before_address_max and
11648 bp_locations_shadow_len_after_address_max according to the current
11649 content of the bp_locations array. */
11652 bp_locations_target_extensions_update (void)
11654 struct bp_location
*bl
, **blp_tmp
;
11656 bp_locations_placed_address_before_address_max
= 0;
11657 bp_locations_shadow_len_after_address_max
= 0;
11659 ALL_BP_LOCATIONS (bl
, blp_tmp
)
11661 CORE_ADDR start
, end
, addr
;
11663 if (!bp_location_has_shadow (bl
))
11666 start
= bl
->target_info
.placed_address
;
11667 end
= start
+ bl
->target_info
.shadow_len
;
11669 gdb_assert (bl
->address
>= start
);
11670 addr
= bl
->address
- start
;
11671 if (addr
> bp_locations_placed_address_before_address_max
)
11672 bp_locations_placed_address_before_address_max
= addr
;
11674 /* Zero SHADOW_LEN would not pass bp_location_has_shadow. */
11676 gdb_assert (bl
->address
< end
);
11677 addr
= end
- bl
->address
;
11678 if (addr
> bp_locations_shadow_len_after_address_max
)
11679 bp_locations_shadow_len_after_address_max
= addr
;
11683 /* Download tracepoint locations if they haven't been. */
11686 download_tracepoint_locations (void)
11688 struct breakpoint
*b
;
11689 enum tribool can_download_tracepoint
= TRIBOOL_UNKNOWN
;
11691 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
11693 ALL_TRACEPOINTS (b
)
11695 struct bp_location
*bl
;
11696 struct tracepoint
*t
;
11697 int bp_location_downloaded
= 0;
11699 if ((b
->type
== bp_fast_tracepoint
11700 ? !may_insert_fast_tracepoints
11701 : !may_insert_tracepoints
))
11704 if (can_download_tracepoint
== TRIBOOL_UNKNOWN
)
11706 if (target_can_download_tracepoint ())
11707 can_download_tracepoint
= TRIBOOL_TRUE
;
11709 can_download_tracepoint
= TRIBOOL_FALSE
;
11712 if (can_download_tracepoint
== TRIBOOL_FALSE
)
11715 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
11717 /* In tracepoint, locations are _never_ duplicated, so
11718 should_be_inserted is equivalent to
11719 unduplicated_should_be_inserted. */
11720 if (!should_be_inserted (bl
) || bl
->inserted
)
11723 switch_to_program_space_and_thread (bl
->pspace
);
11725 target_download_tracepoint (bl
);
11728 bp_location_downloaded
= 1;
11730 t
= (struct tracepoint
*) b
;
11731 t
->number_on_target
= b
->number
;
11732 if (bp_location_downloaded
)
11733 gdb::observers::breakpoint_modified
.notify (b
);
11737 /* Swap the insertion/duplication state between two locations. */
11740 swap_insertion (struct bp_location
*left
, struct bp_location
*right
)
11742 const int left_inserted
= left
->inserted
;
11743 const int left_duplicate
= left
->duplicate
;
11744 const int left_needs_update
= left
->needs_update
;
11745 const struct bp_target_info left_target_info
= left
->target_info
;
11747 /* Locations of tracepoints can never be duplicated. */
11748 if (is_tracepoint (left
->owner
))
11749 gdb_assert (!left
->duplicate
);
11750 if (is_tracepoint (right
->owner
))
11751 gdb_assert (!right
->duplicate
);
11753 left
->inserted
= right
->inserted
;
11754 left
->duplicate
= right
->duplicate
;
11755 left
->needs_update
= right
->needs_update
;
11756 left
->target_info
= right
->target_info
;
11757 right
->inserted
= left_inserted
;
11758 right
->duplicate
= left_duplicate
;
11759 right
->needs_update
= left_needs_update
;
11760 right
->target_info
= left_target_info
;
11763 /* Force the re-insertion of the locations at ADDRESS. This is called
11764 once a new/deleted/modified duplicate location is found and we are evaluating
11765 conditions on the target's side. Such conditions need to be updated on
11769 force_breakpoint_reinsertion (struct bp_location
*bl
)
11771 struct bp_location
**locp
= NULL
, **loc2p
;
11772 struct bp_location
*loc
;
11773 CORE_ADDR address
= 0;
11776 address
= bl
->address
;
11777 pspace_num
= bl
->pspace
->num
;
11779 /* This is only meaningful if the target is
11780 evaluating conditions and if the user has
11781 opted for condition evaluation on the target's
11783 if (gdb_evaluates_breakpoint_condition_p ()
11784 || !target_supports_evaluation_of_breakpoint_conditions ())
11787 /* Flag all breakpoint locations with this address and
11788 the same program space as the location
11789 as "its condition has changed". We need to
11790 update the conditions on the target's side. */
11791 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, address
)
11795 if (!is_breakpoint (loc
->owner
)
11796 || pspace_num
!= loc
->pspace
->num
)
11799 /* Flag the location appropriately. We use a different state to
11800 let everyone know that we already updated the set of locations
11801 with addr bl->address and program space bl->pspace. This is so
11802 we don't have to keep calling these functions just to mark locations
11803 that have already been marked. */
11804 loc
->condition_changed
= condition_updated
;
11806 /* Free the agent expression bytecode as well. We will compute
11808 loc
->cond_bytecode
.reset ();
11811 /* Called whether new breakpoints are created, or existing breakpoints
11812 deleted, to update the global location list and recompute which
11813 locations are duplicate of which.
11815 The INSERT_MODE flag determines whether locations may not, may, or
11816 shall be inserted now. See 'enum ugll_insert_mode' for more
11820 update_global_location_list (enum ugll_insert_mode insert_mode
)
11822 struct breakpoint
*b
;
11823 struct bp_location
**locp
, *loc
;
11824 /* Last breakpoint location address that was marked for update. */
11825 CORE_ADDR last_addr
= 0;
11826 /* Last breakpoint location program space that was marked for update. */
11827 int last_pspace_num
= -1;
11829 /* Used in the duplicates detection below. When iterating over all
11830 bp_locations, points to the first bp_location of a given address.
11831 Breakpoints and watchpoints of different types are never
11832 duplicates of each other. Keep one pointer for each type of
11833 breakpoint/watchpoint, so we only need to loop over all locations
11835 struct bp_location
*bp_loc_first
; /* breakpoint */
11836 struct bp_location
*wp_loc_first
; /* hardware watchpoint */
11837 struct bp_location
*awp_loc_first
; /* access watchpoint */
11838 struct bp_location
*rwp_loc_first
; /* read watchpoint */
11840 /* Saved former bp_locations array which we compare against the newly
11841 built bp_locations from the current state of ALL_BREAKPOINTS. */
11842 struct bp_location
**old_locp
;
11843 unsigned old_locations_count
;
11844 gdb::unique_xmalloc_ptr
<struct bp_location
*> old_locations (bp_locations
);
11846 old_locations_count
= bp_locations_count
;
11847 bp_locations
= NULL
;
11848 bp_locations_count
= 0;
11850 ALL_BREAKPOINTS (b
)
11851 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
11852 bp_locations_count
++;
11854 bp_locations
= XNEWVEC (struct bp_location
*, bp_locations_count
);
11855 locp
= bp_locations
;
11856 ALL_BREAKPOINTS (b
)
11857 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
11859 qsort (bp_locations
, bp_locations_count
, sizeof (*bp_locations
),
11860 bp_locations_compare
);
11862 bp_locations_target_extensions_update ();
11864 /* Identify bp_location instances that are no longer present in the
11865 new list, and therefore should be freed. Note that it's not
11866 necessary that those locations should be removed from inferior --
11867 if there's another location at the same address (previously
11868 marked as duplicate), we don't need to remove/insert the
11871 LOCP is kept in sync with OLD_LOCP, each pointing to the current
11872 and former bp_location array state respectively. */
11874 locp
= bp_locations
;
11875 for (old_locp
= old_locations
.get ();
11876 old_locp
< old_locations
.get () + old_locations_count
;
11879 struct bp_location
*old_loc
= *old_locp
;
11880 struct bp_location
**loc2p
;
11882 /* Tells if 'old_loc' is found among the new locations. If
11883 not, we have to free it. */
11884 int found_object
= 0;
11885 /* Tells if the location should remain inserted in the target. */
11886 int keep_in_target
= 0;
11889 /* Skip LOCP entries which will definitely never be needed.
11890 Stop either at or being the one matching OLD_LOC. */
11891 while (locp
< bp_locations
+ bp_locations_count
11892 && (*locp
)->address
< old_loc
->address
)
11896 (loc2p
< bp_locations
+ bp_locations_count
11897 && (*loc2p
)->address
== old_loc
->address
);
11900 /* Check if this is a new/duplicated location or a duplicated
11901 location that had its condition modified. If so, we want to send
11902 its condition to the target if evaluation of conditions is taking
11904 if ((*loc2p
)->condition_changed
== condition_modified
11905 && (last_addr
!= old_loc
->address
11906 || last_pspace_num
!= old_loc
->pspace
->num
))
11908 force_breakpoint_reinsertion (*loc2p
);
11909 last_pspace_num
= old_loc
->pspace
->num
;
11912 if (*loc2p
== old_loc
)
11916 /* We have already handled this address, update it so that we don't
11917 have to go through updates again. */
11918 last_addr
= old_loc
->address
;
11920 /* Target-side condition evaluation: Handle deleted locations. */
11922 force_breakpoint_reinsertion (old_loc
);
11924 /* If this location is no longer present, and inserted, look if
11925 there's maybe a new location at the same address. If so,
11926 mark that one inserted, and don't remove this one. This is
11927 needed so that we don't have a time window where a breakpoint
11928 at certain location is not inserted. */
11930 if (old_loc
->inserted
)
11932 /* If the location is inserted now, we might have to remove
11935 if (found_object
&& should_be_inserted (old_loc
))
11937 /* The location is still present in the location list,
11938 and still should be inserted. Don't do anything. */
11939 keep_in_target
= 1;
11943 /* This location still exists, but it won't be kept in the
11944 target since it may have been disabled. We proceed to
11945 remove its target-side condition. */
11947 /* The location is either no longer present, or got
11948 disabled. See if there's another location at the
11949 same address, in which case we don't need to remove
11950 this one from the target. */
11952 /* OLD_LOC comes from existing struct breakpoint. */
11953 if (breakpoint_address_is_meaningful (old_loc
->owner
))
11956 (loc2p
< bp_locations
+ bp_locations_count
11957 && (*loc2p
)->address
== old_loc
->address
);
11960 struct bp_location
*loc2
= *loc2p
;
11962 if (breakpoint_locations_match (loc2
, old_loc
))
11964 /* Read watchpoint locations are switched to
11965 access watchpoints, if the former are not
11966 supported, but the latter are. */
11967 if (is_hardware_watchpoint (old_loc
->owner
))
11969 gdb_assert (is_hardware_watchpoint (loc2
->owner
));
11970 loc2
->watchpoint_type
= old_loc
->watchpoint_type
;
11973 /* loc2 is a duplicated location. We need to check
11974 if it should be inserted in case it will be
11976 if (loc2
!= old_loc
11977 && unduplicated_should_be_inserted (loc2
))
11979 swap_insertion (old_loc
, loc2
);
11980 keep_in_target
= 1;
11988 if (!keep_in_target
)
11990 if (remove_breakpoint (old_loc
))
11992 /* This is just about all we can do. We could keep
11993 this location on the global list, and try to
11994 remove it next time, but there's no particular
11995 reason why we will succeed next time.
11997 Note that at this point, old_loc->owner is still
11998 valid, as delete_breakpoint frees the breakpoint
11999 only after calling us. */
12000 printf_filtered (_("warning: Error removing "
12001 "breakpoint %d\n"),
12002 old_loc
->owner
->number
);
12010 if (removed
&& target_is_non_stop_p ()
12011 && need_moribund_for_location_type (old_loc
))
12013 /* This location was removed from the target. In
12014 non-stop mode, a race condition is possible where
12015 we've removed a breakpoint, but stop events for that
12016 breakpoint are already queued and will arrive later.
12017 We apply an heuristic to be able to distinguish such
12018 SIGTRAPs from other random SIGTRAPs: we keep this
12019 breakpoint location for a bit, and will retire it
12020 after we see some number of events. The theory here
12021 is that reporting of events should, "on the average",
12022 be fair, so after a while we'll see events from all
12023 threads that have anything of interest, and no longer
12024 need to keep this breakpoint location around. We
12025 don't hold locations forever so to reduce chances of
12026 mistaking a non-breakpoint SIGTRAP for a breakpoint
12029 The heuristic failing can be disastrous on
12030 decr_pc_after_break targets.
12032 On decr_pc_after_break targets, like e.g., x86-linux,
12033 if we fail to recognize a late breakpoint SIGTRAP,
12034 because events_till_retirement has reached 0 too
12035 soon, we'll fail to do the PC adjustment, and report
12036 a random SIGTRAP to the user. When the user resumes
12037 the inferior, it will most likely immediately crash
12038 with SIGILL/SIGBUS/SIGSEGV, or worse, get silently
12039 corrupted, because of being resumed e.g., in the
12040 middle of a multi-byte instruction, or skipped a
12041 one-byte instruction. This was actually seen happen
12042 on native x86-linux, and should be less rare on
12043 targets that do not support new thread events, like
12044 remote, due to the heuristic depending on
12047 Mistaking a random SIGTRAP for a breakpoint trap
12048 causes similar symptoms (PC adjustment applied when
12049 it shouldn't), but then again, playing with SIGTRAPs
12050 behind the debugger's back is asking for trouble.
12052 Since hardware watchpoint traps are always
12053 distinguishable from other traps, so we don't need to
12054 apply keep hardware watchpoint moribund locations
12055 around. We simply always ignore hardware watchpoint
12056 traps we can no longer explain. */
12058 old_loc
->events_till_retirement
= 3 * (thread_count () + 1);
12059 old_loc
->owner
= NULL
;
12061 VEC_safe_push (bp_location_p
, moribund_locations
, old_loc
);
12065 old_loc
->owner
= NULL
;
12066 decref_bp_location (&old_loc
);
12071 /* Rescan breakpoints at the same address and section, marking the
12072 first one as "first" and any others as "duplicates". This is so
12073 that the bpt instruction is only inserted once. If we have a
12074 permanent breakpoint at the same place as BPT, make that one the
12075 official one, and the rest as duplicates. Permanent breakpoints
12076 are sorted first for the same address.
12078 Do the same for hardware watchpoints, but also considering the
12079 watchpoint's type (regular/access/read) and length. */
12081 bp_loc_first
= NULL
;
12082 wp_loc_first
= NULL
;
12083 awp_loc_first
= NULL
;
12084 rwp_loc_first
= NULL
;
12085 ALL_BP_LOCATIONS (loc
, locp
)
12087 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always
12089 struct bp_location
**loc_first_p
;
12092 if (!unduplicated_should_be_inserted (loc
)
12093 || !breakpoint_address_is_meaningful (b
)
12094 /* Don't detect duplicate for tracepoint locations because they are
12095 never duplicated. See the comments in field `duplicate' of
12096 `struct bp_location'. */
12097 || is_tracepoint (b
))
12099 /* Clear the condition modification flag. */
12100 loc
->condition_changed
= condition_unchanged
;
12104 if (b
->type
== bp_hardware_watchpoint
)
12105 loc_first_p
= &wp_loc_first
;
12106 else if (b
->type
== bp_read_watchpoint
)
12107 loc_first_p
= &rwp_loc_first
;
12108 else if (b
->type
== bp_access_watchpoint
)
12109 loc_first_p
= &awp_loc_first
;
12111 loc_first_p
= &bp_loc_first
;
12113 if (*loc_first_p
== NULL
12114 || (overlay_debugging
&& loc
->section
!= (*loc_first_p
)->section
)
12115 || !breakpoint_locations_match (loc
, *loc_first_p
))
12117 *loc_first_p
= loc
;
12118 loc
->duplicate
= 0;
12120 if (is_breakpoint (loc
->owner
) && loc
->condition_changed
)
12122 loc
->needs_update
= 1;
12123 /* Clear the condition modification flag. */
12124 loc
->condition_changed
= condition_unchanged
;
12130 /* This and the above ensure the invariant that the first location
12131 is not duplicated, and is the inserted one.
12132 All following are marked as duplicated, and are not inserted. */
12134 swap_insertion (loc
, *loc_first_p
);
12135 loc
->duplicate
= 1;
12137 /* Clear the condition modification flag. */
12138 loc
->condition_changed
= condition_unchanged
;
12141 if (insert_mode
== UGLL_INSERT
|| breakpoints_should_be_inserted_now ())
12143 if (insert_mode
!= UGLL_DONT_INSERT
)
12144 insert_breakpoint_locations ();
12147 /* Even though the caller told us to not insert new
12148 locations, we may still need to update conditions on the
12149 target's side of breakpoints that were already inserted
12150 if the target is evaluating breakpoint conditions. We
12151 only update conditions for locations that are marked
12153 update_inserted_breakpoint_locations ();
12157 if (insert_mode
!= UGLL_DONT_INSERT
)
12158 download_tracepoint_locations ();
12162 breakpoint_retire_moribund (void)
12164 struct bp_location
*loc
;
12167 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
12168 if (--(loc
->events_till_retirement
) == 0)
12170 decref_bp_location (&loc
);
12171 VEC_unordered_remove (bp_location_p
, moribund_locations
, ix
);
12177 update_global_location_list_nothrow (enum ugll_insert_mode insert_mode
)
12182 update_global_location_list (insert_mode
);
12184 CATCH (e
, RETURN_MASK_ERROR
)
12190 /* Clear BKP from a BPS. */
12193 bpstat_remove_bp_location (bpstat bps
, struct breakpoint
*bpt
)
12197 for (bs
= bps
; bs
; bs
= bs
->next
)
12198 if (bs
->breakpoint_at
== bpt
)
12200 bs
->breakpoint_at
= NULL
;
12201 bs
->old_val
= NULL
;
12202 /* bs->commands will be freed later. */
12206 /* Callback for iterate_over_threads. */
12208 bpstat_remove_breakpoint_callback (struct thread_info
*th
, void *data
)
12210 struct breakpoint
*bpt
= (struct breakpoint
*) data
;
12212 bpstat_remove_bp_location (th
->control
.stop_bpstat
, bpt
);
12216 /* Helper for breakpoint and tracepoint breakpoint_ops->mention
12220 say_where (struct breakpoint
*b
)
12222 struct value_print_options opts
;
12224 get_user_print_options (&opts
);
12226 /* i18n: cagney/2005-02-11: Below needs to be merged into a
12228 if (b
->loc
== NULL
)
12230 /* For pending locations, the output differs slightly based
12231 on b->extra_string. If this is non-NULL, it contains either
12232 a condition or dprintf arguments. */
12233 if (b
->extra_string
== NULL
)
12235 printf_filtered (_(" (%s) pending."),
12236 event_location_to_string (b
->location
.get ()));
12238 else if (b
->type
== bp_dprintf
)
12240 printf_filtered (_(" (%s,%s) pending."),
12241 event_location_to_string (b
->location
.get ()),
12246 printf_filtered (_(" (%s %s) pending."),
12247 event_location_to_string (b
->location
.get ()),
12253 if (opts
.addressprint
|| b
->loc
->symtab
== NULL
)
12255 printf_filtered (" at ");
12256 fputs_filtered (paddress (b
->loc
->gdbarch
, b
->loc
->address
),
12259 if (b
->loc
->symtab
!= NULL
)
12261 /* If there is a single location, we can print the location
12263 if (b
->loc
->next
== NULL
)
12264 printf_filtered (": file %s, line %d.",
12265 symtab_to_filename_for_display (b
->loc
->symtab
),
12266 b
->loc
->line_number
);
12268 /* This is not ideal, but each location may have a
12269 different file name, and this at least reflects the
12270 real situation somewhat. */
12271 printf_filtered (": %s.",
12272 event_location_to_string (b
->location
.get ()));
12277 struct bp_location
*loc
= b
->loc
;
12279 for (; loc
; loc
= loc
->next
)
12281 printf_filtered (" (%d locations)", n
);
12286 /* Default bp_location_ops methods. */
12289 bp_location_dtor (struct bp_location
*self
)
12291 xfree (self
->function_name
);
12294 static const struct bp_location_ops bp_location_ops
=
12299 /* Destructor for the breakpoint base class. */
12301 breakpoint::~breakpoint ()
12303 xfree (this->cond_string
);
12304 xfree (this->extra_string
);
12305 xfree (this->filter
);
12308 static struct bp_location
*
12309 base_breakpoint_allocate_location (struct breakpoint
*self
)
12311 return new bp_location (&bp_location_ops
, self
);
12315 base_breakpoint_re_set (struct breakpoint
*b
)
12317 /* Nothing to re-set. */
12320 #define internal_error_pure_virtual_called() \
12321 gdb_assert_not_reached ("pure virtual function called")
12324 base_breakpoint_insert_location (struct bp_location
*bl
)
12326 internal_error_pure_virtual_called ();
12330 base_breakpoint_remove_location (struct bp_location
*bl
,
12331 enum remove_bp_reason reason
)
12333 internal_error_pure_virtual_called ();
12337 base_breakpoint_breakpoint_hit (const struct bp_location
*bl
,
12338 const address_space
*aspace
,
12340 const struct target_waitstatus
*ws
)
12342 internal_error_pure_virtual_called ();
12346 base_breakpoint_check_status (bpstat bs
)
12351 /* A "works_in_software_mode" breakpoint_ops method that just internal
12355 base_breakpoint_works_in_software_mode (const struct breakpoint
*b
)
12357 internal_error_pure_virtual_called ();
12360 /* A "resources_needed" breakpoint_ops method that just internal
12364 base_breakpoint_resources_needed (const struct bp_location
*bl
)
12366 internal_error_pure_virtual_called ();
12369 static enum print_stop_action
12370 base_breakpoint_print_it (bpstat bs
)
12372 internal_error_pure_virtual_called ();
12376 base_breakpoint_print_one_detail (const struct breakpoint
*self
,
12377 struct ui_out
*uiout
)
12383 base_breakpoint_print_mention (struct breakpoint
*b
)
12385 internal_error_pure_virtual_called ();
12389 base_breakpoint_print_recreate (struct breakpoint
*b
, struct ui_file
*fp
)
12391 internal_error_pure_virtual_called ();
12395 base_breakpoint_create_sals_from_location
12396 (const struct event_location
*location
,
12397 struct linespec_result
*canonical
,
12398 enum bptype type_wanted
)
12400 internal_error_pure_virtual_called ();
12404 base_breakpoint_create_breakpoints_sal (struct gdbarch
*gdbarch
,
12405 struct linespec_result
*c
,
12406 gdb::unique_xmalloc_ptr
<char> cond_string
,
12407 gdb::unique_xmalloc_ptr
<char> extra_string
,
12408 enum bptype type_wanted
,
12409 enum bpdisp disposition
,
12411 int task
, int ignore_count
,
12412 const struct breakpoint_ops
*o
,
12413 int from_tty
, int enabled
,
12414 int internal
, unsigned flags
)
12416 internal_error_pure_virtual_called ();
12419 static std::vector
<symtab_and_line
>
12420 base_breakpoint_decode_location (struct breakpoint
*b
,
12421 const struct event_location
*location
,
12422 struct program_space
*search_pspace
)
12424 internal_error_pure_virtual_called ();
12427 /* The default 'explains_signal' method. */
12430 base_breakpoint_explains_signal (struct breakpoint
*b
, enum gdb_signal sig
)
12435 /* The default "after_condition_true" method. */
12438 base_breakpoint_after_condition_true (struct bpstats
*bs
)
12440 /* Nothing to do. */
12443 struct breakpoint_ops base_breakpoint_ops
=
12445 base_breakpoint_allocate_location
,
12446 base_breakpoint_re_set
,
12447 base_breakpoint_insert_location
,
12448 base_breakpoint_remove_location
,
12449 base_breakpoint_breakpoint_hit
,
12450 base_breakpoint_check_status
,
12451 base_breakpoint_resources_needed
,
12452 base_breakpoint_works_in_software_mode
,
12453 base_breakpoint_print_it
,
12455 base_breakpoint_print_one_detail
,
12456 base_breakpoint_print_mention
,
12457 base_breakpoint_print_recreate
,
12458 base_breakpoint_create_sals_from_location
,
12459 base_breakpoint_create_breakpoints_sal
,
12460 base_breakpoint_decode_location
,
12461 base_breakpoint_explains_signal
,
12462 base_breakpoint_after_condition_true
,
12465 /* Default breakpoint_ops methods. */
12468 bkpt_re_set (struct breakpoint
*b
)
12470 /* FIXME: is this still reachable? */
12471 if (breakpoint_event_location_empty_p (b
))
12473 /* Anything without a location can't be re-set. */
12474 delete_breakpoint (b
);
12478 breakpoint_re_set_default (b
);
12482 bkpt_insert_location (struct bp_location
*bl
)
12484 CORE_ADDR addr
= bl
->target_info
.reqstd_address
;
12486 bl
->target_info
.kind
= breakpoint_kind (bl
, &addr
);
12487 bl
->target_info
.placed_address
= addr
;
12489 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
12490 return target_insert_hw_breakpoint (bl
->gdbarch
, &bl
->target_info
);
12492 return target_insert_breakpoint (bl
->gdbarch
, &bl
->target_info
);
12496 bkpt_remove_location (struct bp_location
*bl
, enum remove_bp_reason reason
)
12498 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
12499 return target_remove_hw_breakpoint (bl
->gdbarch
, &bl
->target_info
);
12501 return target_remove_breakpoint (bl
->gdbarch
, &bl
->target_info
, reason
);
12505 bkpt_breakpoint_hit (const struct bp_location
*bl
,
12506 const address_space
*aspace
, CORE_ADDR bp_addr
,
12507 const struct target_waitstatus
*ws
)
12509 if (ws
->kind
!= TARGET_WAITKIND_STOPPED
12510 || ws
->value
.sig
!= GDB_SIGNAL_TRAP
)
12513 if (!breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
12517 if (overlay_debugging
/* unmapped overlay section */
12518 && section_is_overlay (bl
->section
)
12519 && !section_is_mapped (bl
->section
))
12526 dprintf_breakpoint_hit (const struct bp_location
*bl
,
12527 const address_space
*aspace
, CORE_ADDR bp_addr
,
12528 const struct target_waitstatus
*ws
)
12530 if (dprintf_style
== dprintf_style_agent
12531 && target_can_run_breakpoint_commands ())
12533 /* An agent-style dprintf never causes a stop. If we see a trap
12534 for this address it must be for a breakpoint that happens to
12535 be set at the same address. */
12539 return bkpt_breakpoint_hit (bl
, aspace
, bp_addr
, ws
);
12543 bkpt_resources_needed (const struct bp_location
*bl
)
12545 gdb_assert (bl
->owner
->type
== bp_hardware_breakpoint
);
12550 static enum print_stop_action
12551 bkpt_print_it (bpstat bs
)
12553 struct breakpoint
*b
;
12554 const struct bp_location
*bl
;
12556 struct ui_out
*uiout
= current_uiout
;
12558 gdb_assert (bs
->bp_location_at
!= NULL
);
12560 bl
= bs
->bp_location_at
;
12561 b
= bs
->breakpoint_at
;
12563 bp_temp
= b
->disposition
== disp_del
;
12564 if (bl
->address
!= bl
->requested_address
)
12565 breakpoint_adjustment_warning (bl
->requested_address
,
12568 annotate_breakpoint (b
->number
);
12569 maybe_print_thread_hit_breakpoint (uiout
);
12572 uiout
->text ("Temporary breakpoint ");
12574 uiout
->text ("Breakpoint ");
12575 if (uiout
->is_mi_like_p ())
12577 uiout
->field_string ("reason",
12578 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
12579 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
12581 uiout
->field_int ("bkptno", b
->number
);
12582 uiout
->text (", ");
12584 return PRINT_SRC_AND_LOC
;
12588 bkpt_print_mention (struct breakpoint
*b
)
12590 if (current_uiout
->is_mi_like_p ())
12595 case bp_breakpoint
:
12596 case bp_gnu_ifunc_resolver
:
12597 if (b
->disposition
== disp_del
)
12598 printf_filtered (_("Temporary breakpoint"));
12600 printf_filtered (_("Breakpoint"));
12601 printf_filtered (_(" %d"), b
->number
);
12602 if (b
->type
== bp_gnu_ifunc_resolver
)
12603 printf_filtered (_(" at gnu-indirect-function resolver"));
12605 case bp_hardware_breakpoint
:
12606 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
12609 printf_filtered (_("Dprintf %d"), b
->number
);
12617 bkpt_print_recreate (struct breakpoint
*tp
, struct ui_file
*fp
)
12619 if (tp
->type
== bp_breakpoint
&& tp
->disposition
== disp_del
)
12620 fprintf_unfiltered (fp
, "tbreak");
12621 else if (tp
->type
== bp_breakpoint
)
12622 fprintf_unfiltered (fp
, "break");
12623 else if (tp
->type
== bp_hardware_breakpoint
12624 && tp
->disposition
== disp_del
)
12625 fprintf_unfiltered (fp
, "thbreak");
12626 else if (tp
->type
== bp_hardware_breakpoint
)
12627 fprintf_unfiltered (fp
, "hbreak");
12629 internal_error (__FILE__
, __LINE__
,
12630 _("unhandled breakpoint type %d"), (int) tp
->type
);
12632 fprintf_unfiltered (fp
, " %s",
12633 event_location_to_string (tp
->location
.get ()));
12635 /* Print out extra_string if this breakpoint is pending. It might
12636 contain, for example, conditions that were set by the user. */
12637 if (tp
->loc
== NULL
&& tp
->extra_string
!= NULL
)
12638 fprintf_unfiltered (fp
, " %s", tp
->extra_string
);
12640 print_recreate_thread (tp
, fp
);
12644 bkpt_create_sals_from_location (const struct event_location
*location
,
12645 struct linespec_result
*canonical
,
12646 enum bptype type_wanted
)
12648 create_sals_from_location_default (location
, canonical
, type_wanted
);
12652 bkpt_create_breakpoints_sal (struct gdbarch
*gdbarch
,
12653 struct linespec_result
*canonical
,
12654 gdb::unique_xmalloc_ptr
<char> cond_string
,
12655 gdb::unique_xmalloc_ptr
<char> extra_string
,
12656 enum bptype type_wanted
,
12657 enum bpdisp disposition
,
12659 int task
, int ignore_count
,
12660 const struct breakpoint_ops
*ops
,
12661 int from_tty
, int enabled
,
12662 int internal
, unsigned flags
)
12664 create_breakpoints_sal_default (gdbarch
, canonical
,
12665 std::move (cond_string
),
12666 std::move (extra_string
),
12668 disposition
, thread
, task
,
12669 ignore_count
, ops
, from_tty
,
12670 enabled
, internal
, flags
);
12673 static std::vector
<symtab_and_line
>
12674 bkpt_decode_location (struct breakpoint
*b
,
12675 const struct event_location
*location
,
12676 struct program_space
*search_pspace
)
12678 return decode_location_default (b
, location
, search_pspace
);
12681 /* Virtual table for internal breakpoints. */
12684 internal_bkpt_re_set (struct breakpoint
*b
)
12688 /* Delete overlay event and longjmp master breakpoints; they
12689 will be reset later by breakpoint_re_set. */
12690 case bp_overlay_event
:
12691 case bp_longjmp_master
:
12692 case bp_std_terminate_master
:
12693 case bp_exception_master
:
12694 delete_breakpoint (b
);
12697 /* This breakpoint is special, it's set up when the inferior
12698 starts and we really don't want to touch it. */
12699 case bp_shlib_event
:
12701 /* Like bp_shlib_event, this breakpoint type is special. Once
12702 it is set up, we do not want to touch it. */
12703 case bp_thread_event
:
12709 internal_bkpt_check_status (bpstat bs
)
12711 if (bs
->breakpoint_at
->type
== bp_shlib_event
)
12713 /* If requested, stop when the dynamic linker notifies GDB of
12714 events. This allows the user to get control and place
12715 breakpoints in initializer routines for dynamically loaded
12716 objects (among other things). */
12717 bs
->stop
= stop_on_solib_events
;
12718 bs
->print
= stop_on_solib_events
;
12724 static enum print_stop_action
12725 internal_bkpt_print_it (bpstat bs
)
12727 struct breakpoint
*b
;
12729 b
= bs
->breakpoint_at
;
12733 case bp_shlib_event
:
12734 /* Did we stop because the user set the stop_on_solib_events
12735 variable? (If so, we report this as a generic, "Stopped due
12736 to shlib event" message.) */
12737 print_solib_event (0);
12740 case bp_thread_event
:
12741 /* Not sure how we will get here.
12742 GDB should not stop for these breakpoints. */
12743 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
12746 case bp_overlay_event
:
12747 /* By analogy with the thread event, GDB should not stop for these. */
12748 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
12751 case bp_longjmp_master
:
12752 /* These should never be enabled. */
12753 printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
12756 case bp_std_terminate_master
:
12757 /* These should never be enabled. */
12758 printf_filtered (_("std::terminate Master Breakpoint: "
12759 "gdb should not stop!\n"));
12762 case bp_exception_master
:
12763 /* These should never be enabled. */
12764 printf_filtered (_("Exception Master Breakpoint: "
12765 "gdb should not stop!\n"));
12769 return PRINT_NOTHING
;
12773 internal_bkpt_print_mention (struct breakpoint
*b
)
12775 /* Nothing to mention. These breakpoints are internal. */
12778 /* Virtual table for momentary breakpoints */
12781 momentary_bkpt_re_set (struct breakpoint
*b
)
12783 /* Keep temporary breakpoints, which can be encountered when we step
12784 over a dlopen call and solib_add is resetting the breakpoints.
12785 Otherwise these should have been blown away via the cleanup chain
12786 or by breakpoint_init_inferior when we rerun the executable. */
12790 momentary_bkpt_check_status (bpstat bs
)
12792 /* Nothing. The point of these breakpoints is causing a stop. */
12795 static enum print_stop_action
12796 momentary_bkpt_print_it (bpstat bs
)
12798 return PRINT_UNKNOWN
;
12802 momentary_bkpt_print_mention (struct breakpoint
*b
)
12804 /* Nothing to mention. These breakpoints are internal. */
12807 /* Ensure INITIATING_FRAME is cleared when no such breakpoint exists.
12809 It gets cleared already on the removal of the first one of such placed
12810 breakpoints. This is OK as they get all removed altogether. */
12812 longjmp_breakpoint::~longjmp_breakpoint ()
12814 thread_info
*tp
= find_thread_global_id (this->thread
);
12817 tp
->initiating_frame
= null_frame_id
;
12820 /* Specific methods for probe breakpoints. */
12823 bkpt_probe_insert_location (struct bp_location
*bl
)
12825 int v
= bkpt_insert_location (bl
);
12829 /* The insertion was successful, now let's set the probe's semaphore
12831 bl
->probe
.prob
->set_semaphore (bl
->probe
.objfile
, bl
->gdbarch
);
12838 bkpt_probe_remove_location (struct bp_location
*bl
,
12839 enum remove_bp_reason reason
)
12841 /* Let's clear the semaphore before removing the location. */
12842 bl
->probe
.prob
->clear_semaphore (bl
->probe
.objfile
, bl
->gdbarch
);
12844 return bkpt_remove_location (bl
, reason
);
12848 bkpt_probe_create_sals_from_location (const struct event_location
*location
,
12849 struct linespec_result
*canonical
,
12850 enum bptype type_wanted
)
12852 struct linespec_sals lsal
;
12854 lsal
.sals
= parse_probes (location
, NULL
, canonical
);
12856 = xstrdup (event_location_to_string (canonical
->location
.get ()));
12857 canonical
->lsals
.push_back (std::move (lsal
));
12860 static std::vector
<symtab_and_line
>
12861 bkpt_probe_decode_location (struct breakpoint
*b
,
12862 const struct event_location
*location
,
12863 struct program_space
*search_pspace
)
12865 std::vector
<symtab_and_line
> sals
= parse_probes (location
, search_pspace
, NULL
);
12867 error (_("probe not found"));
12871 /* The breakpoint_ops structure to be used in tracepoints. */
12874 tracepoint_re_set (struct breakpoint
*b
)
12876 breakpoint_re_set_default (b
);
12880 tracepoint_breakpoint_hit (const struct bp_location
*bl
,
12881 const address_space
*aspace
, CORE_ADDR bp_addr
,
12882 const struct target_waitstatus
*ws
)
12884 /* By definition, the inferior does not report stops at
12890 tracepoint_print_one_detail (const struct breakpoint
*self
,
12891 struct ui_out
*uiout
)
12893 struct tracepoint
*tp
= (struct tracepoint
*) self
;
12894 if (!tp
->static_trace_marker_id
.empty ())
12896 gdb_assert (self
->type
== bp_static_tracepoint
);
12898 uiout
->text ("\tmarker id is ");
12899 uiout
->field_string ("static-tracepoint-marker-string-id",
12900 tp
->static_trace_marker_id
);
12901 uiout
->text ("\n");
12906 tracepoint_print_mention (struct breakpoint
*b
)
12908 if (current_uiout
->is_mi_like_p ())
12913 case bp_tracepoint
:
12914 printf_filtered (_("Tracepoint"));
12915 printf_filtered (_(" %d"), b
->number
);
12917 case bp_fast_tracepoint
:
12918 printf_filtered (_("Fast tracepoint"));
12919 printf_filtered (_(" %d"), b
->number
);
12921 case bp_static_tracepoint
:
12922 printf_filtered (_("Static tracepoint"));
12923 printf_filtered (_(" %d"), b
->number
);
12926 internal_error (__FILE__
, __LINE__
,
12927 _("unhandled tracepoint type %d"), (int) b
->type
);
12934 tracepoint_print_recreate (struct breakpoint
*self
, struct ui_file
*fp
)
12936 struct tracepoint
*tp
= (struct tracepoint
*) self
;
12938 if (self
->type
== bp_fast_tracepoint
)
12939 fprintf_unfiltered (fp
, "ftrace");
12940 else if (self
->type
== bp_static_tracepoint
)
12941 fprintf_unfiltered (fp
, "strace");
12942 else if (self
->type
== bp_tracepoint
)
12943 fprintf_unfiltered (fp
, "trace");
12945 internal_error (__FILE__
, __LINE__
,
12946 _("unhandled tracepoint type %d"), (int) self
->type
);
12948 fprintf_unfiltered (fp
, " %s",
12949 event_location_to_string (self
->location
.get ()));
12950 print_recreate_thread (self
, fp
);
12952 if (tp
->pass_count
)
12953 fprintf_unfiltered (fp
, " passcount %d\n", tp
->pass_count
);
12957 tracepoint_create_sals_from_location (const struct event_location
*location
,
12958 struct linespec_result
*canonical
,
12959 enum bptype type_wanted
)
12961 create_sals_from_location_default (location
, canonical
, type_wanted
);
12965 tracepoint_create_breakpoints_sal (struct gdbarch
*gdbarch
,
12966 struct linespec_result
*canonical
,
12967 gdb::unique_xmalloc_ptr
<char> cond_string
,
12968 gdb::unique_xmalloc_ptr
<char> extra_string
,
12969 enum bptype type_wanted
,
12970 enum bpdisp disposition
,
12972 int task
, int ignore_count
,
12973 const struct breakpoint_ops
*ops
,
12974 int from_tty
, int enabled
,
12975 int internal
, unsigned flags
)
12977 create_breakpoints_sal_default (gdbarch
, canonical
,
12978 std::move (cond_string
),
12979 std::move (extra_string
),
12981 disposition
, thread
, task
,
12982 ignore_count
, ops
, from_tty
,
12983 enabled
, internal
, flags
);
12986 static std::vector
<symtab_and_line
>
12987 tracepoint_decode_location (struct breakpoint
*b
,
12988 const struct event_location
*location
,
12989 struct program_space
*search_pspace
)
12991 return decode_location_default (b
, location
, search_pspace
);
12994 struct breakpoint_ops tracepoint_breakpoint_ops
;
12996 /* The breakpoint_ops structure to be use on tracepoints placed in a
13000 tracepoint_probe_create_sals_from_location
13001 (const struct event_location
*location
,
13002 struct linespec_result
*canonical
,
13003 enum bptype type_wanted
)
13005 /* We use the same method for breakpoint on probes. */
13006 bkpt_probe_create_sals_from_location (location
, canonical
, type_wanted
);
13009 static std::vector
<symtab_and_line
>
13010 tracepoint_probe_decode_location (struct breakpoint
*b
,
13011 const struct event_location
*location
,
13012 struct program_space
*search_pspace
)
13014 /* We use the same method for breakpoint on probes. */
13015 return bkpt_probe_decode_location (b
, location
, search_pspace
);
13018 static struct breakpoint_ops tracepoint_probe_breakpoint_ops
;
13020 /* Dprintf breakpoint_ops methods. */
13023 dprintf_re_set (struct breakpoint
*b
)
13025 breakpoint_re_set_default (b
);
13027 /* extra_string should never be non-NULL for dprintf. */
13028 gdb_assert (b
->extra_string
!= NULL
);
13030 /* 1 - connect to target 1, that can run breakpoint commands.
13031 2 - create a dprintf, which resolves fine.
13032 3 - disconnect from target 1
13033 4 - connect to target 2, that can NOT run breakpoint commands.
13035 After steps #3/#4, you'll want the dprintf command list to
13036 be updated, because target 1 and 2 may well return different
13037 answers for target_can_run_breakpoint_commands().
13038 Given absence of finer grained resetting, we get to do
13039 it all the time. */
13040 if (b
->extra_string
!= NULL
)
13041 update_dprintf_command_list (b
);
13044 /* Implement the "print_recreate" breakpoint_ops method for dprintf. */
13047 dprintf_print_recreate (struct breakpoint
*tp
, struct ui_file
*fp
)
13049 fprintf_unfiltered (fp
, "dprintf %s,%s",
13050 event_location_to_string (tp
->location
.get ()),
13052 print_recreate_thread (tp
, fp
);
13055 /* Implement the "after_condition_true" breakpoint_ops method for
13058 dprintf's are implemented with regular commands in their command
13059 list, but we run the commands here instead of before presenting the
13060 stop to the user, as dprintf's don't actually cause a stop. This
13061 also makes it so that the commands of multiple dprintfs at the same
13062 address are all handled. */
13065 dprintf_after_condition_true (struct bpstats
*bs
)
13067 struct bpstats tmp_bs
;
13068 struct bpstats
*tmp_bs_p
= &tmp_bs
;
13070 /* dprintf's never cause a stop. This wasn't set in the
13071 check_status hook instead because that would make the dprintf's
13072 condition not be evaluated. */
13075 /* Run the command list here. Take ownership of it instead of
13076 copying. We never want these commands to run later in
13077 bpstat_do_actions, if a breakpoint that causes a stop happens to
13078 be set at same address as this dprintf, or even if running the
13079 commands here throws. */
13080 tmp_bs
.commands
= bs
->commands
;
13081 bs
->commands
= NULL
;
13083 bpstat_do_actions_1 (&tmp_bs_p
);
13085 /* 'tmp_bs.commands' will usually be NULL by now, but
13086 bpstat_do_actions_1 may return early without processing the whole
13090 /* The breakpoint_ops structure to be used on static tracepoints with
13094 strace_marker_create_sals_from_location (const struct event_location
*location
,
13095 struct linespec_result
*canonical
,
13096 enum bptype type_wanted
)
13098 struct linespec_sals lsal
;
13099 const char *arg_start
, *arg
;
13101 arg
= arg_start
= get_linespec_location (location
)->spec_string
;
13102 lsal
.sals
= decode_static_tracepoint_spec (&arg
);
13104 std::string
str (arg_start
, arg
- arg_start
);
13105 const char *ptr
= str
.c_str ();
13106 canonical
->location
13107 = new_linespec_location (&ptr
, symbol_name_match_type::FULL
);
13110 = xstrdup (event_location_to_string (canonical
->location
.get ()));
13111 canonical
->lsals
.push_back (std::move (lsal
));
13115 strace_marker_create_breakpoints_sal (struct gdbarch
*gdbarch
,
13116 struct linespec_result
*canonical
,
13117 gdb::unique_xmalloc_ptr
<char> cond_string
,
13118 gdb::unique_xmalloc_ptr
<char> extra_string
,
13119 enum bptype type_wanted
,
13120 enum bpdisp disposition
,
13122 int task
, int ignore_count
,
13123 const struct breakpoint_ops
*ops
,
13124 int from_tty
, int enabled
,
13125 int internal
, unsigned flags
)
13127 const linespec_sals
&lsal
= canonical
->lsals
[0];
13129 /* If the user is creating a static tracepoint by marker id
13130 (strace -m MARKER_ID), then store the sals index, so that
13131 breakpoint_re_set can try to match up which of the newly
13132 found markers corresponds to this one, and, don't try to
13133 expand multiple locations for each sal, given than SALS
13134 already should contain all sals for MARKER_ID. */
13136 for (size_t i
= 0; i
< lsal
.sals
.size (); i
++)
13138 event_location_up location
13139 = copy_event_location (canonical
->location
.get ());
13141 std::unique_ptr
<tracepoint
> tp (new tracepoint ());
13142 init_breakpoint_sal (tp
.get (), gdbarch
, lsal
.sals
[i
],
13143 std::move (location
), NULL
,
13144 std::move (cond_string
),
13145 std::move (extra_string
),
13146 type_wanted
, disposition
,
13147 thread
, task
, ignore_count
, ops
,
13148 from_tty
, enabled
, internal
, flags
,
13149 canonical
->special_display
);
13150 /* Given that its possible to have multiple markers with
13151 the same string id, if the user is creating a static
13152 tracepoint by marker id ("strace -m MARKER_ID"), then
13153 store the sals index, so that breakpoint_re_set can
13154 try to match up which of the newly found markers
13155 corresponds to this one */
13156 tp
->static_trace_marker_id_idx
= i
;
13158 install_breakpoint (internal
, std::move (tp
), 0);
13162 static std::vector
<symtab_and_line
>
13163 strace_marker_decode_location (struct breakpoint
*b
,
13164 const struct event_location
*location
,
13165 struct program_space
*search_pspace
)
13167 struct tracepoint
*tp
= (struct tracepoint
*) b
;
13168 const char *s
= get_linespec_location (location
)->spec_string
;
13170 std::vector
<symtab_and_line
> sals
= decode_static_tracepoint_spec (&s
);
13171 if (sals
.size () > tp
->static_trace_marker_id_idx
)
13173 sals
[0] = sals
[tp
->static_trace_marker_id_idx
];
13178 error (_("marker %s not found"), tp
->static_trace_marker_id
.c_str ());
13181 static struct breakpoint_ops strace_marker_breakpoint_ops
;
13184 strace_marker_p (struct breakpoint
*b
)
13186 return b
->ops
== &strace_marker_breakpoint_ops
;
13189 /* Delete a breakpoint and clean up all traces of it in the data
13193 delete_breakpoint (struct breakpoint
*bpt
)
13195 struct breakpoint
*b
;
13197 gdb_assert (bpt
!= NULL
);
13199 /* Has this bp already been deleted? This can happen because
13200 multiple lists can hold pointers to bp's. bpstat lists are
13203 One example of this happening is a watchpoint's scope bp. When
13204 the scope bp triggers, we notice that the watchpoint is out of
13205 scope, and delete it. We also delete its scope bp. But the
13206 scope bp is marked "auto-deleting", and is already on a bpstat.
13207 That bpstat is then checked for auto-deleting bp's, which are
13210 A real solution to this problem might involve reference counts in
13211 bp's, and/or giving them pointers back to their referencing
13212 bpstat's, and teaching delete_breakpoint to only free a bp's
13213 storage when no more references were extent. A cheaper bandaid
13215 if (bpt
->type
== bp_none
)
13218 /* At least avoid this stale reference until the reference counting
13219 of breakpoints gets resolved. */
13220 if (bpt
->related_breakpoint
!= bpt
)
13222 struct breakpoint
*related
;
13223 struct watchpoint
*w
;
13225 if (bpt
->type
== bp_watchpoint_scope
)
13226 w
= (struct watchpoint
*) bpt
->related_breakpoint
;
13227 else if (bpt
->related_breakpoint
->type
== bp_watchpoint_scope
)
13228 w
= (struct watchpoint
*) bpt
;
13232 watchpoint_del_at_next_stop (w
);
13234 /* Unlink bpt from the bpt->related_breakpoint ring. */
13235 for (related
= bpt
; related
->related_breakpoint
!= bpt
;
13236 related
= related
->related_breakpoint
);
13237 related
->related_breakpoint
= bpt
->related_breakpoint
;
13238 bpt
->related_breakpoint
= bpt
;
13241 /* watch_command_1 creates a watchpoint but only sets its number if
13242 update_watchpoint succeeds in creating its bp_locations. If there's
13243 a problem in that process, we'll be asked to delete the half-created
13244 watchpoint. In that case, don't announce the deletion. */
13246 gdb::observers::breakpoint_deleted
.notify (bpt
);
13248 if (breakpoint_chain
== bpt
)
13249 breakpoint_chain
= bpt
->next
;
13251 ALL_BREAKPOINTS (b
)
13252 if (b
->next
== bpt
)
13254 b
->next
= bpt
->next
;
13258 /* Be sure no bpstat's are pointing at the breakpoint after it's
13260 /* FIXME, how can we find all bpstat's? We just check stop_bpstat
13261 in all threads for now. Note that we cannot just remove bpstats
13262 pointing at bpt from the stop_bpstat list entirely, as breakpoint
13263 commands are associated with the bpstat; if we remove it here,
13264 then the later call to bpstat_do_actions (&stop_bpstat); in
13265 event-top.c won't do anything, and temporary breakpoints with
13266 commands won't work. */
13268 iterate_over_threads (bpstat_remove_breakpoint_callback
, bpt
);
13270 /* Now that breakpoint is removed from breakpoint list, update the
13271 global location list. This will remove locations that used to
13272 belong to this breakpoint. Do this before freeing the breakpoint
13273 itself, since remove_breakpoint looks at location's owner. It
13274 might be better design to have location completely
13275 self-contained, but it's not the case now. */
13276 update_global_location_list (UGLL_DONT_INSERT
);
13278 /* On the chance that someone will soon try again to delete this
13279 same bp, we mark it as deleted before freeing its storage. */
13280 bpt
->type
= bp_none
;
13284 /* Iterator function to call a user-provided callback function once
13285 for each of B and its related breakpoints. */
13288 iterate_over_related_breakpoints (struct breakpoint
*b
,
13289 gdb::function_view
<void (breakpoint
*)> function
)
13291 struct breakpoint
*related
;
13296 struct breakpoint
*next
;
13298 /* FUNCTION may delete RELATED. */
13299 next
= related
->related_breakpoint
;
13301 if (next
== related
)
13303 /* RELATED is the last ring entry. */
13304 function (related
);
13306 /* FUNCTION may have deleted it, so we'd never reach back to
13307 B. There's nothing left to do anyway, so just break
13312 function (related
);
13316 while (related
!= b
);
13320 delete_command (const char *arg
, int from_tty
)
13322 struct breakpoint
*b
, *b_tmp
;
13328 int breaks_to_delete
= 0;
13330 /* Delete all breakpoints if no argument. Do not delete
13331 internal breakpoints, these have to be deleted with an
13332 explicit breakpoint number argument. */
13333 ALL_BREAKPOINTS (b
)
13334 if (user_breakpoint_p (b
))
13336 breaks_to_delete
= 1;
13340 /* Ask user only if there are some breakpoints to delete. */
13342 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
13344 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
13345 if (user_breakpoint_p (b
))
13346 delete_breakpoint (b
);
13350 map_breakpoint_numbers
13351 (arg
, [&] (breakpoint
*b
)
13353 iterate_over_related_breakpoints (b
, delete_breakpoint
);
13357 /* Return true if all locations of B bound to PSPACE are pending. If
13358 PSPACE is NULL, all locations of all program spaces are
13362 all_locations_are_pending (struct breakpoint
*b
, struct program_space
*pspace
)
13364 struct bp_location
*loc
;
13366 for (loc
= b
->loc
; loc
!= NULL
; loc
= loc
->next
)
13367 if ((pspace
== NULL
13368 || loc
->pspace
== pspace
)
13369 && !loc
->shlib_disabled
13370 && !loc
->pspace
->executing_startup
)
13375 /* Subroutine of update_breakpoint_locations to simplify it.
13376 Return non-zero if multiple fns in list LOC have the same name.
13377 Null names are ignored. */
13380 ambiguous_names_p (struct bp_location
*loc
)
13382 struct bp_location
*l
;
13383 htab_t htab
= htab_create_alloc (13, htab_hash_string
, streq_hash
, NULL
,
13386 for (l
= loc
; l
!= NULL
; l
= l
->next
)
13389 const char *name
= l
->function_name
;
13391 /* Allow for some names to be NULL, ignore them. */
13395 slot
= (const char **) htab_find_slot (htab
, (const void *) name
,
13397 /* NOTE: We can assume slot != NULL here because xcalloc never
13401 htab_delete (htab
);
13407 htab_delete (htab
);
13411 /* When symbols change, it probably means the sources changed as well,
13412 and it might mean the static tracepoint markers are no longer at
13413 the same address or line numbers they used to be at last we
13414 checked. Losing your static tracepoints whenever you rebuild is
13415 undesirable. This function tries to resync/rematch gdb static
13416 tracepoints with the markers on the target, for static tracepoints
13417 that have not been set by marker id. Static tracepoint that have
13418 been set by marker id are reset by marker id in breakpoint_re_set.
13421 1) For a tracepoint set at a specific address, look for a marker at
13422 the old PC. If one is found there, assume to be the same marker.
13423 If the name / string id of the marker found is different from the
13424 previous known name, assume that means the user renamed the marker
13425 in the sources, and output a warning.
13427 2) For a tracepoint set at a given line number, look for a marker
13428 at the new address of the old line number. If one is found there,
13429 assume to be the same marker. If the name / string id of the
13430 marker found is different from the previous known name, assume that
13431 means the user renamed the marker in the sources, and output a
13434 3) If a marker is no longer found at the same address or line, it
13435 may mean the marker no longer exists. But it may also just mean
13436 the code changed a bit. Maybe the user added a few lines of code
13437 that made the marker move up or down (in line number terms). Ask
13438 the target for info about the marker with the string id as we knew
13439 it. If found, update line number and address in the matching
13440 static tracepoint. This will get confused if there's more than one
13441 marker with the same ID (possible in UST, although unadvised
13442 precisely because it confuses tools). */
13444 static struct symtab_and_line
13445 update_static_tracepoint (struct breakpoint
*b
, struct symtab_and_line sal
)
13447 struct tracepoint
*tp
= (struct tracepoint
*) b
;
13448 struct static_tracepoint_marker marker
;
13453 find_line_pc (sal
.symtab
, sal
.line
, &pc
);
13455 if (target_static_tracepoint_marker_at (pc
, &marker
))
13457 if (tp
->static_trace_marker_id
!= marker
.str_id
)
13458 warning (_("static tracepoint %d changed probed marker from %s to %s"),
13459 b
->number
, tp
->static_trace_marker_id
.c_str (),
13460 marker
.str_id
.c_str ());
13462 tp
->static_trace_marker_id
= std::move (marker
.str_id
);
13467 /* Old marker wasn't found on target at lineno. Try looking it up
13469 if (!sal
.explicit_pc
13471 && sal
.symtab
!= NULL
13472 && !tp
->static_trace_marker_id
.empty ())
13474 std::vector
<static_tracepoint_marker
> markers
13475 = target_static_tracepoint_markers_by_strid
13476 (tp
->static_trace_marker_id
.c_str ());
13478 if (!markers
.empty ())
13480 struct symbol
*sym
;
13481 struct static_tracepoint_marker
*tpmarker
;
13482 struct ui_out
*uiout
= current_uiout
;
13483 struct explicit_location explicit_loc
;
13485 tpmarker
= &markers
[0];
13487 tp
->static_trace_marker_id
= std::move (tpmarker
->str_id
);
13489 warning (_("marker for static tracepoint %d (%s) not "
13490 "found at previous line number"),
13491 b
->number
, tp
->static_trace_marker_id
.c_str ());
13493 symtab_and_line sal2
= find_pc_line (tpmarker
->address
, 0);
13494 sym
= find_pc_sect_function (tpmarker
->address
, NULL
);
13495 uiout
->text ("Now in ");
13498 uiout
->field_string ("func", SYMBOL_PRINT_NAME (sym
));
13499 uiout
->text (" at ");
13501 uiout
->field_string ("file",
13502 symtab_to_filename_for_display (sal2
.symtab
));
13505 if (uiout
->is_mi_like_p ())
13507 const char *fullname
= symtab_to_fullname (sal2
.symtab
);
13509 uiout
->field_string ("fullname", fullname
);
13512 uiout
->field_int ("line", sal2
.line
);
13513 uiout
->text ("\n");
13515 b
->loc
->line_number
= sal2
.line
;
13516 b
->loc
->symtab
= sym
!= NULL
? sal2
.symtab
: NULL
;
13518 b
->location
.reset (NULL
);
13519 initialize_explicit_location (&explicit_loc
);
13520 explicit_loc
.source_filename
13521 = ASTRDUP (symtab_to_filename_for_display (sal2
.symtab
));
13522 explicit_loc
.line_offset
.offset
= b
->loc
->line_number
;
13523 explicit_loc
.line_offset
.sign
= LINE_OFFSET_NONE
;
13524 b
->location
= new_explicit_location (&explicit_loc
);
13526 /* Might be nice to check if function changed, and warn if
13533 /* Returns 1 iff locations A and B are sufficiently same that
13534 we don't need to report breakpoint as changed. */
13537 locations_are_equal (struct bp_location
*a
, struct bp_location
*b
)
13541 if (a
->address
!= b
->address
)
13544 if (a
->shlib_disabled
!= b
->shlib_disabled
)
13547 if (a
->enabled
!= b
->enabled
)
13554 if ((a
== NULL
) != (b
== NULL
))
13560 /* Split all locations of B that are bound to PSPACE out of B's
13561 location list to a separate list and return that list's head. If
13562 PSPACE is NULL, hoist out all locations of B. */
13564 static struct bp_location
*
13565 hoist_existing_locations (struct breakpoint
*b
, struct program_space
*pspace
)
13567 struct bp_location head
;
13568 struct bp_location
*i
= b
->loc
;
13569 struct bp_location
**i_link
= &b
->loc
;
13570 struct bp_location
*hoisted
= &head
;
13572 if (pspace
== NULL
)
13583 if (i
->pspace
== pspace
)
13598 /* Create new breakpoint locations for B (a hardware or software
13599 breakpoint) based on SALS and SALS_END. If SALS_END.NELTS is not
13600 zero, then B is a ranged breakpoint. Only recreates locations for
13601 FILTER_PSPACE. Locations of other program spaces are left
13605 update_breakpoint_locations (struct breakpoint
*b
,
13606 struct program_space
*filter_pspace
,
13607 gdb::array_view
<const symtab_and_line
> sals
,
13608 gdb::array_view
<const symtab_and_line
> sals_end
)
13610 struct bp_location
*existing_locations
;
13612 if (!sals_end
.empty () && (sals
.size () != 1 || sals_end
.size () != 1))
13614 /* Ranged breakpoints have only one start location and one end
13616 b
->enable_state
= bp_disabled
;
13617 printf_unfiltered (_("Could not reset ranged breakpoint %d: "
13618 "multiple locations found\n"),
13623 /* If there's no new locations, and all existing locations are
13624 pending, don't do anything. This optimizes the common case where
13625 all locations are in the same shared library, that was unloaded.
13626 We'd like to retain the location, so that when the library is
13627 loaded again, we don't loose the enabled/disabled status of the
13628 individual locations. */
13629 if (all_locations_are_pending (b
, filter_pspace
) && sals
.empty ())
13632 existing_locations
= hoist_existing_locations (b
, filter_pspace
);
13634 for (const auto &sal
: sals
)
13636 struct bp_location
*new_loc
;
13638 switch_to_program_space_and_thread (sal
.pspace
);
13640 new_loc
= add_location_to_breakpoint (b
, &sal
);
13642 /* Reparse conditions, they might contain references to the
13644 if (b
->cond_string
!= NULL
)
13648 s
= b
->cond_string
;
13651 new_loc
->cond
= parse_exp_1 (&s
, sal
.pc
,
13652 block_for_pc (sal
.pc
),
13655 CATCH (e
, RETURN_MASK_ERROR
)
13657 warning (_("failed to reevaluate condition "
13658 "for breakpoint %d: %s"),
13659 b
->number
, e
.message
);
13660 new_loc
->enabled
= 0;
13665 if (!sals_end
.empty ())
13667 CORE_ADDR end
= find_breakpoint_range_end (sals_end
[0]);
13669 new_loc
->length
= end
- sals
[0].pc
+ 1;
13673 /* If possible, carry over 'disable' status from existing
13676 struct bp_location
*e
= existing_locations
;
13677 /* If there are multiple breakpoints with the same function name,
13678 e.g. for inline functions, comparing function names won't work.
13679 Instead compare pc addresses; this is just a heuristic as things
13680 may have moved, but in practice it gives the correct answer
13681 often enough until a better solution is found. */
13682 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
13684 for (; e
; e
= e
->next
)
13686 if (!e
->enabled
&& e
->function_name
)
13688 struct bp_location
*l
= b
->loc
;
13689 if (have_ambiguous_names
)
13691 for (; l
; l
= l
->next
)
13692 if (breakpoint_locations_match (e
, l
))
13700 for (; l
; l
= l
->next
)
13701 if (l
->function_name
13702 && strcmp (e
->function_name
, l
->function_name
) == 0)
13712 if (!locations_are_equal (existing_locations
, b
->loc
))
13713 gdb::observers::breakpoint_modified
.notify (b
);
13716 /* Find the SaL locations corresponding to the given LOCATION.
13717 On return, FOUND will be 1 if any SaL was found, zero otherwise. */
13719 static std::vector
<symtab_and_line
>
13720 location_to_sals (struct breakpoint
*b
, struct event_location
*location
,
13721 struct program_space
*search_pspace
, int *found
)
13723 struct gdb_exception exception
= exception_none
;
13725 gdb_assert (b
->ops
!= NULL
);
13727 std::vector
<symtab_and_line
> sals
;
13731 sals
= b
->ops
->decode_location (b
, location
, search_pspace
);
13733 CATCH (e
, RETURN_MASK_ERROR
)
13735 int not_found_and_ok
= 0;
13739 /* For pending breakpoints, it's expected that parsing will
13740 fail until the right shared library is loaded. User has
13741 already told to create pending breakpoints and don't need
13742 extra messages. If breakpoint is in bp_shlib_disabled
13743 state, then user already saw the message about that
13744 breakpoint being disabled, and don't want to see more
13746 if (e
.error
== NOT_FOUND_ERROR
13747 && (b
->condition_not_parsed
13749 && search_pspace
!= NULL
13750 && b
->loc
->pspace
!= search_pspace
)
13751 || (b
->loc
&& b
->loc
->shlib_disabled
)
13752 || (b
->loc
&& b
->loc
->pspace
->executing_startup
)
13753 || b
->enable_state
== bp_disabled
))
13754 not_found_and_ok
= 1;
13756 if (!not_found_and_ok
)
13758 /* We surely don't want to warn about the same breakpoint
13759 10 times. One solution, implemented here, is disable
13760 the breakpoint on error. Another solution would be to
13761 have separate 'warning emitted' flag. Since this
13762 happens only when a binary has changed, I don't know
13763 which approach is better. */
13764 b
->enable_state
= bp_disabled
;
13765 throw_exception (e
);
13770 if (exception
.reason
== 0 || exception
.error
!= NOT_FOUND_ERROR
)
13772 for (auto &sal
: sals
)
13773 resolve_sal_pc (&sal
);
13774 if (b
->condition_not_parsed
&& b
->extra_string
!= NULL
)
13776 char *cond_string
, *extra_string
;
13779 find_condition_and_thread (b
->extra_string
, sals
[0].pc
,
13780 &cond_string
, &thread
, &task
,
13782 gdb_assert (b
->cond_string
== NULL
);
13784 b
->cond_string
= cond_string
;
13785 b
->thread
= thread
;
13789 xfree (b
->extra_string
);
13790 b
->extra_string
= extra_string
;
13792 b
->condition_not_parsed
= 0;
13795 if (b
->type
== bp_static_tracepoint
&& !strace_marker_p (b
))
13796 sals
[0] = update_static_tracepoint (b
, sals
[0]);
13806 /* The default re_set method, for typical hardware or software
13807 breakpoints. Reevaluate the breakpoint and recreate its
13811 breakpoint_re_set_default (struct breakpoint
*b
)
13813 struct program_space
*filter_pspace
= current_program_space
;
13814 std::vector
<symtab_and_line
> expanded
, expanded_end
;
13817 std::vector
<symtab_and_line
> sals
= location_to_sals (b
, b
->location
.get (),
13818 filter_pspace
, &found
);
13820 expanded
= std::move (sals
);
13822 if (b
->location_range_end
!= NULL
)
13824 std::vector
<symtab_and_line
> sals_end
13825 = location_to_sals (b
, b
->location_range_end
.get (),
13826 filter_pspace
, &found
);
13828 expanded_end
= std::move (sals_end
);
13831 update_breakpoint_locations (b
, filter_pspace
, expanded
, expanded_end
);
13834 /* Default method for creating SALs from an address string. It basically
13835 calls parse_breakpoint_sals. Return 1 for success, zero for failure. */
13838 create_sals_from_location_default (const struct event_location
*location
,
13839 struct linespec_result
*canonical
,
13840 enum bptype type_wanted
)
13842 parse_breakpoint_sals (location
, canonical
);
13845 /* Call create_breakpoints_sal for the given arguments. This is the default
13846 function for the `create_breakpoints_sal' method of
13850 create_breakpoints_sal_default (struct gdbarch
*gdbarch
,
13851 struct linespec_result
*canonical
,
13852 gdb::unique_xmalloc_ptr
<char> cond_string
,
13853 gdb::unique_xmalloc_ptr
<char> extra_string
,
13854 enum bptype type_wanted
,
13855 enum bpdisp disposition
,
13857 int task
, int ignore_count
,
13858 const struct breakpoint_ops
*ops
,
13859 int from_tty
, int enabled
,
13860 int internal
, unsigned flags
)
13862 create_breakpoints_sal (gdbarch
, canonical
,
13863 std::move (cond_string
),
13864 std::move (extra_string
),
13865 type_wanted
, disposition
,
13866 thread
, task
, ignore_count
, ops
, from_tty
,
13867 enabled
, internal
, flags
);
13870 /* Decode the line represented by S by calling decode_line_full. This is the
13871 default function for the `decode_location' method of breakpoint_ops. */
13873 static std::vector
<symtab_and_line
>
13874 decode_location_default (struct breakpoint
*b
,
13875 const struct event_location
*location
,
13876 struct program_space
*search_pspace
)
13878 struct linespec_result canonical
;
13880 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, search_pspace
,
13881 (struct symtab
*) NULL
, 0,
13882 &canonical
, multiple_symbols_all
,
13885 /* We should get 0 or 1 resulting SALs. */
13886 gdb_assert (canonical
.lsals
.size () < 2);
13888 if (!canonical
.lsals
.empty ())
13890 const linespec_sals
&lsal
= canonical
.lsals
[0];
13891 return std::move (lsal
.sals
);
13896 /* Reset a breakpoint. */
13899 breakpoint_re_set_one (breakpoint
*b
)
13901 input_radix
= b
->input_radix
;
13902 set_language (b
->language
);
13904 b
->ops
->re_set (b
);
13907 /* Re-set breakpoint locations for the current program space.
13908 Locations bound to other program spaces are left untouched. */
13911 breakpoint_re_set (void)
13913 struct breakpoint
*b
, *b_tmp
;
13916 scoped_restore_current_language save_language
;
13917 scoped_restore save_input_radix
= make_scoped_restore (&input_radix
);
13918 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
13920 /* Note: we must not try to insert locations until after all
13921 breakpoints have been re-set. Otherwise, e.g., when re-setting
13922 breakpoint 1, we'd insert the locations of breakpoint 2, which
13923 hadn't been re-set yet, and thus may have stale locations. */
13925 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
13929 breakpoint_re_set_one (b
);
13931 CATCH (ex
, RETURN_MASK_ALL
)
13933 exception_fprintf (gdb_stderr
, ex
,
13934 "Error in re-setting breakpoint %d: ",
13940 jit_breakpoint_re_set ();
13943 create_overlay_event_breakpoint ();
13944 create_longjmp_master_breakpoint ();
13945 create_std_terminate_master_breakpoint ();
13946 create_exception_master_breakpoint ();
13948 /* Now we can insert. */
13949 update_global_location_list (UGLL_MAY_INSERT
);
13952 /* Reset the thread number of this breakpoint:
13954 - If the breakpoint is for all threads, leave it as-is.
13955 - Else, reset it to the current thread for inferior_ptid. */
13957 breakpoint_re_set_thread (struct breakpoint
*b
)
13959 if (b
->thread
!= -1)
13961 if (in_thread_list (inferior_ptid
))
13962 b
->thread
= ptid_to_global_thread_id (inferior_ptid
);
13964 /* We're being called after following a fork. The new fork is
13965 selected as current, and unless this was a vfork will have a
13966 different program space from the original thread. Reset that
13968 b
->loc
->pspace
= current_program_space
;
13972 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
13973 If from_tty is nonzero, it prints a message to that effect,
13974 which ends with a period (no newline). */
13977 set_ignore_count (int bptnum
, int count
, int from_tty
)
13979 struct breakpoint
*b
;
13984 ALL_BREAKPOINTS (b
)
13985 if (b
->number
== bptnum
)
13987 if (is_tracepoint (b
))
13989 if (from_tty
&& count
!= 0)
13990 printf_filtered (_("Ignore count ignored for tracepoint %d."),
13995 b
->ignore_count
= count
;
13999 printf_filtered (_("Will stop next time "
14000 "breakpoint %d is reached."),
14002 else if (count
== 1)
14003 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
14006 printf_filtered (_("Will ignore next %d "
14007 "crossings of breakpoint %d."),
14010 gdb::observers::breakpoint_modified
.notify (b
);
14014 error (_("No breakpoint number %d."), bptnum
);
14017 /* Command to set ignore-count of breakpoint N to COUNT. */
14020 ignore_command (const char *args
, int from_tty
)
14022 const char *p
= args
;
14026 error_no_arg (_("a breakpoint number"));
14028 num
= get_number (&p
);
14030 error (_("bad breakpoint number: '%s'"), args
);
14032 error (_("Second argument (specified ignore-count) is missing."));
14034 set_ignore_count (num
,
14035 longest_to_int (value_as_long (parse_and_eval (p
))),
14038 printf_filtered ("\n");
14042 /* Call FUNCTION on each of the breakpoints with numbers in the range
14043 defined by BP_NUM_RANGE (an inclusive range). */
14046 map_breakpoint_number_range (std::pair
<int, int> bp_num_range
,
14047 gdb::function_view
<void (breakpoint
*)> function
)
14049 if (bp_num_range
.first
== 0)
14051 warning (_("bad breakpoint number at or near '%d'"),
14052 bp_num_range
.first
);
14056 struct breakpoint
*b
, *tmp
;
14058 for (int i
= bp_num_range
.first
; i
<= bp_num_range
.second
; i
++)
14060 bool match
= false;
14062 ALL_BREAKPOINTS_SAFE (b
, tmp
)
14063 if (b
->number
== i
)
14070 printf_unfiltered (_("No breakpoint number %d.\n"), i
);
14075 /* Call FUNCTION on each of the breakpoints whose numbers are given in
14079 map_breakpoint_numbers (const char *args
,
14080 gdb::function_view
<void (breakpoint
*)> function
)
14082 if (args
== NULL
|| *args
== '\0')
14083 error_no_arg (_("one or more breakpoint numbers"));
14085 number_or_range_parser
parser (args
);
14087 while (!parser
.finished ())
14089 int num
= parser
.get_number ();
14090 map_breakpoint_number_range (std::make_pair (num
, num
), function
);
14094 /* Return the breakpoint location structure corresponding to the
14095 BP_NUM and LOC_NUM values. */
14097 static struct bp_location
*
14098 find_location_by_number (int bp_num
, int loc_num
)
14100 struct breakpoint
*b
;
14102 ALL_BREAKPOINTS (b
)
14103 if (b
->number
== bp_num
)
14108 if (!b
|| b
->number
!= bp_num
)
14109 error (_("Bad breakpoint number '%d'"), bp_num
);
14112 error (_("Bad breakpoint location number '%d'"), loc_num
);
14115 for (bp_location
*loc
= b
->loc
; loc
!= NULL
; loc
= loc
->next
)
14116 if (++n
== loc_num
)
14119 error (_("Bad breakpoint location number '%d'"), loc_num
);
14122 /* Modes of operation for extract_bp_num. */
14123 enum class extract_bp_kind
14125 /* Extracting a breakpoint number. */
14128 /* Extracting a location number. */
14132 /* Extract a breakpoint or location number (as determined by KIND)
14133 from the string starting at START. TRAILER is a character which
14134 can be found after the number. If you don't want a trailer, use
14135 '\0'. If END_OUT is not NULL, it is set to point after the parsed
14136 string. This always returns a positive integer. */
14139 extract_bp_num (extract_bp_kind kind
, const char *start
,
14140 int trailer
, const char **end_out
= NULL
)
14142 const char *end
= start
;
14143 int num
= get_number_trailer (&end
, trailer
);
14145 error (kind
== extract_bp_kind::bp
14146 ? _("Negative breakpoint number '%.*s'")
14147 : _("Negative breakpoint location number '%.*s'"),
14148 int (end
- start
), start
);
14150 error (kind
== extract_bp_kind::bp
14151 ? _("Bad breakpoint number '%.*s'")
14152 : _("Bad breakpoint location number '%.*s'"),
14153 int (end
- start
), start
);
14155 if (end_out
!= NULL
)
14160 /* Extract a breakpoint or location range (as determined by KIND) in
14161 the form NUM1-NUM2 stored at &ARG[arg_offset]. Returns a std::pair
14162 representing the (inclusive) range. The returned pair's elements
14163 are always positive integers. */
14165 static std::pair
<int, int>
14166 extract_bp_or_bp_range (extract_bp_kind kind
,
14167 const std::string
&arg
,
14168 std::string::size_type arg_offset
)
14170 std::pair
<int, int> range
;
14171 const char *bp_loc
= &arg
[arg_offset
];
14172 std::string::size_type dash
= arg
.find ('-', arg_offset
);
14173 if (dash
!= std::string::npos
)
14175 /* bp_loc is a range (x-z). */
14176 if (arg
.length () == dash
+ 1)
14177 error (kind
== extract_bp_kind::bp
14178 ? _("Bad breakpoint number at or near: '%s'")
14179 : _("Bad breakpoint location number at or near: '%s'"),
14183 const char *start_first
= bp_loc
;
14184 const char *start_second
= &arg
[dash
+ 1];
14185 range
.first
= extract_bp_num (kind
, start_first
, '-');
14186 range
.second
= extract_bp_num (kind
, start_second
, '\0', &end
);
14188 if (range
.first
> range
.second
)
14189 error (kind
== extract_bp_kind::bp
14190 ? _("Inverted breakpoint range at '%.*s'")
14191 : _("Inverted breakpoint location range at '%.*s'"),
14192 int (end
- start_first
), start_first
);
14196 /* bp_loc is a single value. */
14197 range
.first
= extract_bp_num (kind
, bp_loc
, '\0');
14198 range
.second
= range
.first
;
14203 /* Extract the breakpoint/location range specified by ARG. Returns
14204 the breakpoint range in BP_NUM_RANGE, and the location range in
14207 ARG may be in any of the following forms:
14209 x where 'x' is a breakpoint number.
14210 x-y where 'x' and 'y' specify a breakpoint numbers range.
14211 x.y where 'x' is a breakpoint number and 'y' a location number.
14212 x.y-z where 'x' is a breakpoint number and 'y' and 'z' specify a
14213 location number range.
14217 extract_bp_number_and_location (const std::string
&arg
,
14218 std::pair
<int, int> &bp_num_range
,
14219 std::pair
<int, int> &bp_loc_range
)
14221 std::string::size_type dot
= arg
.find ('.');
14223 if (dot
!= std::string::npos
)
14225 /* Handle 'x.y' and 'x.y-z' cases. */
14227 if (arg
.length () == dot
+ 1 || dot
== 0)
14228 error (_("Bad breakpoint number at or near: '%s'"), arg
.c_str ());
14231 = extract_bp_num (extract_bp_kind::bp
, arg
.c_str (), '.');
14232 bp_num_range
.second
= bp_num_range
.first
;
14234 bp_loc_range
= extract_bp_or_bp_range (extract_bp_kind::loc
,
14239 /* Handle x and x-y cases. */
14241 bp_num_range
= extract_bp_or_bp_range (extract_bp_kind::bp
, arg
, 0);
14242 bp_loc_range
.first
= 0;
14243 bp_loc_range
.second
= 0;
14247 /* Enable or disable a breakpoint location BP_NUM.LOC_NUM. ENABLE
14248 specifies whether to enable or disable. */
14251 enable_disable_bp_num_loc (int bp_num
, int loc_num
, bool enable
)
14253 struct bp_location
*loc
= find_location_by_number (bp_num
, loc_num
);
14256 if (loc
->enabled
!= enable
)
14258 loc
->enabled
= enable
;
14259 mark_breakpoint_location_modified (loc
);
14261 if (target_supports_enable_disable_tracepoint ()
14262 && current_trace_status ()->running
&& loc
->owner
14263 && is_tracepoint (loc
->owner
))
14264 target_disable_tracepoint (loc
);
14266 update_global_location_list (UGLL_DONT_INSERT
);
14269 /* Enable or disable a range of breakpoint locations. BP_NUM is the
14270 number of the breakpoint, and BP_LOC_RANGE specifies the
14271 (inclusive) range of location numbers of that breakpoint to
14272 enable/disable. ENABLE specifies whether to enable or disable the
14276 enable_disable_breakpoint_location_range (int bp_num
,
14277 std::pair
<int, int> &bp_loc_range
,
14280 for (int i
= bp_loc_range
.first
; i
<= bp_loc_range
.second
; i
++)
14281 enable_disable_bp_num_loc (bp_num
, i
, enable
);
14284 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14285 If from_tty is nonzero, it prints a message to that effect,
14286 which ends with a period (no newline). */
14289 disable_breakpoint (struct breakpoint
*bpt
)
14291 /* Never disable a watchpoint scope breakpoint; we want to
14292 hit them when we leave scope so we can delete both the
14293 watchpoint and its scope breakpoint at that time. */
14294 if (bpt
->type
== bp_watchpoint_scope
)
14297 bpt
->enable_state
= bp_disabled
;
14299 /* Mark breakpoint locations modified. */
14300 mark_breakpoint_modified (bpt
);
14302 if (target_supports_enable_disable_tracepoint ()
14303 && current_trace_status ()->running
&& is_tracepoint (bpt
))
14305 struct bp_location
*location
;
14307 for (location
= bpt
->loc
; location
; location
= location
->next
)
14308 target_disable_tracepoint (location
);
14311 update_global_location_list (UGLL_DONT_INSERT
);
14313 gdb::observers::breakpoint_modified
.notify (bpt
);
14316 /* Enable or disable the breakpoint(s) or breakpoint location(s)
14317 specified in ARGS. ARGS may be in any of the formats handled by
14318 extract_bp_number_and_location. ENABLE specifies whether to enable
14319 or disable the breakpoints/locations. */
14322 enable_disable_command (const char *args
, int from_tty
, bool enable
)
14326 struct breakpoint
*bpt
;
14328 ALL_BREAKPOINTS (bpt
)
14329 if (user_breakpoint_p (bpt
))
14332 enable_breakpoint (bpt
);
14334 disable_breakpoint (bpt
);
14339 std::string num
= extract_arg (&args
);
14341 while (!num
.empty ())
14343 std::pair
<int, int> bp_num_range
, bp_loc_range
;
14345 extract_bp_number_and_location (num
, bp_num_range
, bp_loc_range
);
14347 if (bp_loc_range
.first
== bp_loc_range
.second
14348 && bp_loc_range
.first
== 0)
14350 /* Handle breakpoint ids with formats 'x' or 'x-z'. */
14351 map_breakpoint_number_range (bp_num_range
,
14353 ? enable_breakpoint
14354 : disable_breakpoint
);
14358 /* Handle breakpoint ids with formats 'x.y' or
14360 enable_disable_breakpoint_location_range
14361 (bp_num_range
.first
, bp_loc_range
, enable
);
14363 num
= extract_arg (&args
);
14368 /* The disable command disables the specified breakpoints/locations
14369 (or all defined breakpoints) so they're no longer effective in
14370 stopping the inferior. ARGS may be in any of the forms defined in
14371 extract_bp_number_and_location. */
14374 disable_command (const char *args
, int from_tty
)
14376 enable_disable_command (args
, from_tty
, false);
14380 enable_breakpoint_disp (struct breakpoint
*bpt
, enum bpdisp disposition
,
14383 int target_resources_ok
;
14385 if (bpt
->type
== bp_hardware_breakpoint
)
14388 i
= hw_breakpoint_used_count ();
14389 target_resources_ok
=
14390 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
14392 if (target_resources_ok
== 0)
14393 error (_("No hardware breakpoint support in the target."));
14394 else if (target_resources_ok
< 0)
14395 error (_("Hardware breakpoints used exceeds limit."));
14398 if (is_watchpoint (bpt
))
14400 /* Initialize it just to avoid a GCC false warning. */
14401 enum enable_state orig_enable_state
= bp_disabled
;
14405 struct watchpoint
*w
= (struct watchpoint
*) bpt
;
14407 orig_enable_state
= bpt
->enable_state
;
14408 bpt
->enable_state
= bp_enabled
;
14409 update_watchpoint (w
, 1 /* reparse */);
14411 CATCH (e
, RETURN_MASK_ALL
)
14413 bpt
->enable_state
= orig_enable_state
;
14414 exception_fprintf (gdb_stderr
, e
, _("Cannot enable watchpoint %d: "),
14421 bpt
->enable_state
= bp_enabled
;
14423 /* Mark breakpoint locations modified. */
14424 mark_breakpoint_modified (bpt
);
14426 if (target_supports_enable_disable_tracepoint ()
14427 && current_trace_status ()->running
&& is_tracepoint (bpt
))
14429 struct bp_location
*location
;
14431 for (location
= bpt
->loc
; location
; location
= location
->next
)
14432 target_enable_tracepoint (location
);
14435 bpt
->disposition
= disposition
;
14436 bpt
->enable_count
= count
;
14437 update_global_location_list (UGLL_MAY_INSERT
);
14439 gdb::observers::breakpoint_modified
.notify (bpt
);
14444 enable_breakpoint (struct breakpoint
*bpt
)
14446 enable_breakpoint_disp (bpt
, bpt
->disposition
, 0);
14449 /* The enable command enables the specified breakpoints/locations (or
14450 all defined breakpoints) so they once again become (or continue to
14451 be) effective in stopping the inferior. ARGS may be in any of the
14452 forms defined in extract_bp_number_and_location. */
14455 enable_command (const char *args
, int from_tty
)
14457 enable_disable_command (args
, from_tty
, true);
14461 enable_once_command (const char *args
, int from_tty
)
14463 map_breakpoint_numbers
14464 (args
, [&] (breakpoint
*b
)
14466 iterate_over_related_breakpoints
14467 (b
, [&] (breakpoint
*bpt
)
14469 enable_breakpoint_disp (bpt
, disp_disable
, 1);
14475 enable_count_command (const char *args
, int from_tty
)
14480 error_no_arg (_("hit count"));
14482 count
= get_number (&args
);
14484 map_breakpoint_numbers
14485 (args
, [&] (breakpoint
*b
)
14487 iterate_over_related_breakpoints
14488 (b
, [&] (breakpoint
*bpt
)
14490 enable_breakpoint_disp (bpt
, disp_disable
, count
);
14496 enable_delete_command (const char *args
, int from_tty
)
14498 map_breakpoint_numbers
14499 (args
, [&] (breakpoint
*b
)
14501 iterate_over_related_breakpoints
14502 (b
, [&] (breakpoint
*bpt
)
14504 enable_breakpoint_disp (bpt
, disp_del
, 1);
14510 set_breakpoint_cmd (const char *args
, int from_tty
)
14515 show_breakpoint_cmd (const char *args
, int from_tty
)
14519 /* Invalidate last known value of any hardware watchpoint if
14520 the memory which that value represents has been written to by
14524 invalidate_bp_value_on_memory_change (struct inferior
*inferior
,
14525 CORE_ADDR addr
, ssize_t len
,
14526 const bfd_byte
*data
)
14528 struct breakpoint
*bp
;
14530 ALL_BREAKPOINTS (bp
)
14531 if (bp
->enable_state
== bp_enabled
14532 && bp
->type
== bp_hardware_watchpoint
)
14534 struct watchpoint
*wp
= (struct watchpoint
*) bp
;
14536 if (wp
->val_valid
&& wp
->val
)
14538 struct bp_location
*loc
;
14540 for (loc
= bp
->loc
; loc
!= NULL
; loc
= loc
->next
)
14541 if (loc
->loc_type
== bp_loc_hardware_watchpoint
14542 && loc
->address
+ loc
->length
> addr
14543 && addr
+ len
> loc
->address
)
14545 value_decref (wp
->val
);
14553 /* Create and insert a breakpoint for software single step. */
14556 insert_single_step_breakpoint (struct gdbarch
*gdbarch
,
14557 const address_space
*aspace
,
14560 struct thread_info
*tp
= inferior_thread ();
14561 struct symtab_and_line sal
;
14562 CORE_ADDR pc
= next_pc
;
14564 if (tp
->control
.single_step_breakpoints
== NULL
)
14566 tp
->control
.single_step_breakpoints
14567 = new_single_step_breakpoint (tp
->global_num
, gdbarch
);
14570 sal
= find_pc_line (pc
, 0);
14572 sal
.section
= find_pc_overlay (pc
);
14573 sal
.explicit_pc
= 1;
14574 add_location_to_breakpoint (tp
->control
.single_step_breakpoints
, &sal
);
14576 update_global_location_list (UGLL_INSERT
);
14579 /* Insert single step breakpoints according to the current state. */
14582 insert_single_step_breakpoints (struct gdbarch
*gdbarch
)
14584 struct regcache
*regcache
= get_current_regcache ();
14585 std::vector
<CORE_ADDR
> next_pcs
;
14587 next_pcs
= gdbarch_software_single_step (gdbarch
, regcache
);
14589 if (!next_pcs
.empty ())
14591 struct frame_info
*frame
= get_current_frame ();
14592 const address_space
*aspace
= get_frame_address_space (frame
);
14594 for (CORE_ADDR pc
: next_pcs
)
14595 insert_single_step_breakpoint (gdbarch
, aspace
, pc
);
14603 /* See breakpoint.h. */
14606 breakpoint_has_location_inserted_here (struct breakpoint
*bp
,
14607 const address_space
*aspace
,
14610 struct bp_location
*loc
;
14612 for (loc
= bp
->loc
; loc
!= NULL
; loc
= loc
->next
)
14614 && breakpoint_location_address_match (loc
, aspace
, pc
))
14620 /* Check whether a software single-step breakpoint is inserted at
14624 single_step_breakpoint_inserted_here_p (const address_space
*aspace
,
14627 struct breakpoint
*bpt
;
14629 ALL_BREAKPOINTS (bpt
)
14631 if (bpt
->type
== bp_single_step
14632 && breakpoint_has_location_inserted_here (bpt
, aspace
, pc
))
14638 /* Tracepoint-specific operations. */
14640 /* Set tracepoint count to NUM. */
14642 set_tracepoint_count (int num
)
14644 tracepoint_count
= num
;
14645 set_internalvar_integer (lookup_internalvar ("tpnum"), num
);
14649 trace_command (const char *arg
, int from_tty
)
14651 struct breakpoint_ops
*ops
;
14653 event_location_up location
= string_to_event_location (&arg
,
14655 if (location
!= NULL
14656 && event_location_type (location
.get ()) == PROBE_LOCATION
)
14657 ops
= &tracepoint_probe_breakpoint_ops
;
14659 ops
= &tracepoint_breakpoint_ops
;
14661 create_breakpoint (get_current_arch (),
14663 NULL
, 0, arg
, 1 /* parse arg */,
14665 bp_tracepoint
/* type_wanted */,
14666 0 /* Ignore count */,
14667 pending_break_support
,
14671 0 /* internal */, 0);
14675 ftrace_command (const char *arg
, int from_tty
)
14677 event_location_up location
= string_to_event_location (&arg
,
14679 create_breakpoint (get_current_arch (),
14681 NULL
, 0, arg
, 1 /* parse arg */,
14683 bp_fast_tracepoint
/* type_wanted */,
14684 0 /* Ignore count */,
14685 pending_break_support
,
14686 &tracepoint_breakpoint_ops
,
14689 0 /* internal */, 0);
14692 /* strace command implementation. Creates a static tracepoint. */
14695 strace_command (const char *arg
, int from_tty
)
14697 struct breakpoint_ops
*ops
;
14698 event_location_up location
;
14700 /* Decide if we are dealing with a static tracepoint marker (`-m'),
14701 or with a normal static tracepoint. */
14702 if (arg
&& startswith (arg
, "-m") && isspace (arg
[2]))
14704 ops
= &strace_marker_breakpoint_ops
;
14705 location
= new_linespec_location (&arg
, symbol_name_match_type::FULL
);
14709 ops
= &tracepoint_breakpoint_ops
;
14710 location
= string_to_event_location (&arg
, current_language
);
14713 create_breakpoint (get_current_arch (),
14715 NULL
, 0, arg
, 1 /* parse arg */,
14717 bp_static_tracepoint
/* type_wanted */,
14718 0 /* Ignore count */,
14719 pending_break_support
,
14723 0 /* internal */, 0);
14726 /* Set up a fake reader function that gets command lines from a linked
14727 list that was acquired during tracepoint uploading. */
14729 static struct uploaded_tp
*this_utp
;
14730 static int next_cmd
;
14733 read_uploaded_action (void)
14735 char *rslt
= nullptr;
14737 if (next_cmd
< this_utp
->cmd_strings
.size ())
14739 rslt
= this_utp
->cmd_strings
[next_cmd
];
14746 /* Given information about a tracepoint as recorded on a target (which
14747 can be either a live system or a trace file), attempt to create an
14748 equivalent GDB tracepoint. This is not a reliable process, since
14749 the target does not necessarily have all the information used when
14750 the tracepoint was originally defined. */
14752 struct tracepoint
*
14753 create_tracepoint_from_upload (struct uploaded_tp
*utp
)
14755 const char *addr_str
;
14756 char small_buf
[100];
14757 struct tracepoint
*tp
;
14759 if (utp
->at_string
)
14760 addr_str
= utp
->at_string
;
14763 /* In the absence of a source location, fall back to raw
14764 address. Since there is no way to confirm that the address
14765 means the same thing as when the trace was started, warn the
14767 warning (_("Uploaded tracepoint %d has no "
14768 "source location, using raw address"),
14770 xsnprintf (small_buf
, sizeof (small_buf
), "*%s", hex_string (utp
->addr
));
14771 addr_str
= small_buf
;
14774 /* There's not much we can do with a sequence of bytecodes. */
14775 if (utp
->cond
&& !utp
->cond_string
)
14776 warning (_("Uploaded tracepoint %d condition "
14777 "has no source form, ignoring it"),
14780 event_location_up location
= string_to_event_location (&addr_str
,
14782 if (!create_breakpoint (get_current_arch (),
14784 utp
->cond_string
, -1, addr_str
,
14785 0 /* parse cond/thread */,
14787 utp
->type
/* type_wanted */,
14788 0 /* Ignore count */,
14789 pending_break_support
,
14790 &tracepoint_breakpoint_ops
,
14792 utp
->enabled
/* enabled */,
14794 CREATE_BREAKPOINT_FLAGS_INSERTED
))
14797 /* Get the tracepoint we just created. */
14798 tp
= get_tracepoint (tracepoint_count
);
14799 gdb_assert (tp
!= NULL
);
14803 xsnprintf (small_buf
, sizeof (small_buf
), "%d %d", utp
->pass
,
14806 trace_pass_command (small_buf
, 0);
14809 /* If we have uploaded versions of the original commands, set up a
14810 special-purpose "reader" function and call the usual command line
14811 reader, then pass the result to the breakpoint command-setting
14813 if (!utp
->cmd_strings
.empty ())
14815 command_line_up cmd_list
;
14820 cmd_list
= read_command_lines_1 (read_uploaded_action
, 1, NULL
, NULL
);
14822 breakpoint_set_commands (tp
, std::move (cmd_list
));
14824 else if (!utp
->actions
.empty ()
14825 || !utp
->step_actions
.empty ())
14826 warning (_("Uploaded tracepoint %d actions "
14827 "have no source form, ignoring them"),
14830 /* Copy any status information that might be available. */
14831 tp
->hit_count
= utp
->hit_count
;
14832 tp
->traceframe_usage
= utp
->traceframe_usage
;
14837 /* Print information on tracepoint number TPNUM_EXP, or all if
14841 info_tracepoints_command (const char *args
, int from_tty
)
14843 struct ui_out
*uiout
= current_uiout
;
14846 num_printed
= breakpoint_1 (args
, 0, is_tracepoint
);
14848 if (num_printed
== 0)
14850 if (args
== NULL
|| *args
== '\0')
14851 uiout
->message ("No tracepoints.\n");
14853 uiout
->message ("No tracepoint matching '%s'.\n", args
);
14856 default_collect_info ();
14859 /* The 'enable trace' command enables tracepoints.
14860 Not supported by all targets. */
14862 enable_trace_command (const char *args
, int from_tty
)
14864 enable_command (args
, from_tty
);
14867 /* The 'disable trace' command disables tracepoints.
14868 Not supported by all targets. */
14870 disable_trace_command (const char *args
, int from_tty
)
14872 disable_command (args
, from_tty
);
14875 /* Remove a tracepoint (or all if no argument). */
14877 delete_trace_command (const char *arg
, int from_tty
)
14879 struct breakpoint
*b
, *b_tmp
;
14885 int breaks_to_delete
= 0;
14887 /* Delete all breakpoints if no argument.
14888 Do not delete internal or call-dummy breakpoints, these
14889 have to be deleted with an explicit breakpoint number
14891 ALL_TRACEPOINTS (b
)
14892 if (is_tracepoint (b
) && user_breakpoint_p (b
))
14894 breaks_to_delete
= 1;
14898 /* Ask user only if there are some breakpoints to delete. */
14900 || (breaks_to_delete
&& query (_("Delete all tracepoints? "))))
14902 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
14903 if (is_tracepoint (b
) && user_breakpoint_p (b
))
14904 delete_breakpoint (b
);
14908 map_breakpoint_numbers
14909 (arg
, [&] (breakpoint
*b
)
14911 iterate_over_related_breakpoints (b
, delete_breakpoint
);
14915 /* Helper function for trace_pass_command. */
14918 trace_pass_set_count (struct tracepoint
*tp
, int count
, int from_tty
)
14920 tp
->pass_count
= count
;
14921 gdb::observers::breakpoint_modified
.notify (tp
);
14923 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
14924 tp
->number
, count
);
14927 /* Set passcount for tracepoint.
14929 First command argument is passcount, second is tracepoint number.
14930 If tracepoint number omitted, apply to most recently defined.
14931 Also accepts special argument "all". */
14934 trace_pass_command (const char *args
, int from_tty
)
14936 struct tracepoint
*t1
;
14939 if (args
== 0 || *args
== 0)
14940 error (_("passcount command requires an "
14941 "argument (count + optional TP num)"));
14943 count
= strtoulst (args
, &args
, 10); /* Count comes first, then TP num. */
14945 args
= skip_spaces (args
);
14946 if (*args
&& strncasecmp (args
, "all", 3) == 0)
14948 struct breakpoint
*b
;
14950 args
+= 3; /* Skip special argument "all". */
14952 error (_("Junk at end of arguments."));
14954 ALL_TRACEPOINTS (b
)
14956 t1
= (struct tracepoint
*) b
;
14957 trace_pass_set_count (t1
, count
, from_tty
);
14960 else if (*args
== '\0')
14962 t1
= get_tracepoint_by_number (&args
, NULL
);
14964 trace_pass_set_count (t1
, count
, from_tty
);
14968 number_or_range_parser
parser (args
);
14969 while (!parser
.finished ())
14971 t1
= get_tracepoint_by_number (&args
, &parser
);
14973 trace_pass_set_count (t1
, count
, from_tty
);
14978 struct tracepoint
*
14979 get_tracepoint (int num
)
14981 struct breakpoint
*t
;
14983 ALL_TRACEPOINTS (t
)
14984 if (t
->number
== num
)
14985 return (struct tracepoint
*) t
;
14990 /* Find the tracepoint with the given target-side number (which may be
14991 different from the tracepoint number after disconnecting and
14994 struct tracepoint
*
14995 get_tracepoint_by_number_on_target (int num
)
14997 struct breakpoint
*b
;
14999 ALL_TRACEPOINTS (b
)
15001 struct tracepoint
*t
= (struct tracepoint
*) b
;
15003 if (t
->number_on_target
== num
)
15010 /* Utility: parse a tracepoint number and look it up in the list.
15011 If STATE is not NULL, use, get_number_or_range_state and ignore ARG.
15012 If the argument is missing, the most recent tracepoint
15013 (tracepoint_count) is returned. */
15015 struct tracepoint
*
15016 get_tracepoint_by_number (const char **arg
,
15017 number_or_range_parser
*parser
)
15019 struct breakpoint
*t
;
15021 const char *instring
= arg
== NULL
? NULL
: *arg
;
15023 if (parser
!= NULL
)
15025 gdb_assert (!parser
->finished ());
15026 tpnum
= parser
->get_number ();
15028 else if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
15029 tpnum
= tracepoint_count
;
15031 tpnum
= get_number (arg
);
15035 if (instring
&& *instring
)
15036 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
15039 printf_filtered (_("No previous tracepoint\n"));
15043 ALL_TRACEPOINTS (t
)
15044 if (t
->number
== tpnum
)
15046 return (struct tracepoint
*) t
;
15049 printf_unfiltered ("No tracepoint number %d.\n", tpnum
);
15054 print_recreate_thread (struct breakpoint
*b
, struct ui_file
*fp
)
15056 if (b
->thread
!= -1)
15057 fprintf_unfiltered (fp
, " thread %d", b
->thread
);
15060 fprintf_unfiltered (fp
, " task %d", b
->task
);
15062 fprintf_unfiltered (fp
, "\n");
15065 /* Save information on user settable breakpoints (watchpoints, etc) to
15066 a new script file named FILENAME. If FILTER is non-NULL, call it
15067 on each breakpoint and only include the ones for which it returns
15071 save_breakpoints (const char *filename
, int from_tty
,
15072 int (*filter
) (const struct breakpoint
*))
15074 struct breakpoint
*tp
;
15076 int extra_trace_bits
= 0;
15078 if (filename
== 0 || *filename
== 0)
15079 error (_("Argument required (file name in which to save)"));
15081 /* See if we have anything to save. */
15082 ALL_BREAKPOINTS (tp
)
15084 /* Skip internal and momentary breakpoints. */
15085 if (!user_breakpoint_p (tp
))
15088 /* If we have a filter, only save the breakpoints it accepts. */
15089 if (filter
&& !filter (tp
))
15094 if (is_tracepoint (tp
))
15096 extra_trace_bits
= 1;
15098 /* We can stop searching. */
15105 warning (_("Nothing to save."));
15109 gdb::unique_xmalloc_ptr
<char> expanded_filename (tilde_expand (filename
));
15113 if (!fp
.open (expanded_filename
.get (), "w"))
15114 error (_("Unable to open file '%s' for saving (%s)"),
15115 expanded_filename
.get (), safe_strerror (errno
));
15117 if (extra_trace_bits
)
15118 save_trace_state_variables (&fp
);
15120 ALL_BREAKPOINTS (tp
)
15122 /* Skip internal and momentary breakpoints. */
15123 if (!user_breakpoint_p (tp
))
15126 /* If we have a filter, only save the breakpoints it accepts. */
15127 if (filter
&& !filter (tp
))
15130 tp
->ops
->print_recreate (tp
, &fp
);
15132 /* Note, we can't rely on tp->number for anything, as we can't
15133 assume the recreated breakpoint numbers will match. Use $bpnum
15136 if (tp
->cond_string
)
15137 fp
.printf (" condition $bpnum %s\n", tp
->cond_string
);
15139 if (tp
->ignore_count
)
15140 fp
.printf (" ignore $bpnum %d\n", tp
->ignore_count
);
15142 if (tp
->type
!= bp_dprintf
&& tp
->commands
)
15144 fp
.puts (" commands\n");
15146 current_uiout
->redirect (&fp
);
15149 print_command_lines (current_uiout
, tp
->commands
.get (), 2);
15151 CATCH (ex
, RETURN_MASK_ALL
)
15153 current_uiout
->redirect (NULL
);
15154 throw_exception (ex
);
15158 current_uiout
->redirect (NULL
);
15159 fp
.puts (" end\n");
15162 if (tp
->enable_state
== bp_disabled
)
15163 fp
.puts ("disable $bpnum\n");
15165 /* If this is a multi-location breakpoint, check if the locations
15166 should be individually disabled. Watchpoint locations are
15167 special, and not user visible. */
15168 if (!is_watchpoint (tp
) && tp
->loc
&& tp
->loc
->next
)
15170 struct bp_location
*loc
;
15173 for (loc
= tp
->loc
; loc
!= NULL
; loc
= loc
->next
, n
++)
15175 fp
.printf ("disable $bpnum.%d\n", n
);
15179 if (extra_trace_bits
&& *default_collect
)
15180 fp
.printf ("set default-collect %s\n", default_collect
);
15183 printf_filtered (_("Saved to file '%s'.\n"), expanded_filename
.get ());
15186 /* The `save breakpoints' command. */
15189 save_breakpoints_command (const char *args
, int from_tty
)
15191 save_breakpoints (args
, from_tty
, NULL
);
15194 /* The `save tracepoints' command. */
15197 save_tracepoints_command (const char *args
, int from_tty
)
15199 save_breakpoints (args
, from_tty
, is_tracepoint
);
15202 /* Create a vector of all tracepoints. */
15204 VEC(breakpoint_p
) *
15205 all_tracepoints (void)
15207 VEC(breakpoint_p
) *tp_vec
= 0;
15208 struct breakpoint
*tp
;
15210 ALL_TRACEPOINTS (tp
)
15212 VEC_safe_push (breakpoint_p
, tp_vec
, tp
);
15219 /* This help string is used to consolidate all the help string for specifying
15220 locations used by several commands. */
15222 #define LOCATION_HELP_STRING \
15223 "Linespecs are colon-separated lists of location parameters, such as\n\
15224 source filename, function name, label name, and line number.\n\
15225 Example: To specify the start of a label named \"the_top\" in the\n\
15226 function \"fact\" in the file \"factorial.c\", use\n\
15227 \"factorial.c:fact:the_top\".\n\
15229 Address locations begin with \"*\" and specify an exact address in the\n\
15230 program. Example: To specify the fourth byte past the start function\n\
15231 \"main\", use \"*main + 4\".\n\
15233 Explicit locations are similar to linespecs but use an option/argument\n\
15234 syntax to specify location parameters.\n\
15235 Example: To specify the start of the label named \"the_top\" in the\n\
15236 function \"fact\" in the file \"factorial.c\", use \"-source factorial.c\n\
15237 -function fact -label the_top\".\n\
15239 By default, a specified function is matched against the program's\n\
15240 functions in all scopes. For C++, this means in all namespaces and\n\
15241 classes. For Ada, this means in all packages. E.g., in C++,\n\
15242 \"func()\" matches \"A::func()\", \"A::B::func()\", etc. The\n\
15243 \"-qualified\" flag overrides this behavior, making GDB interpret the\n\
15244 specified name as a complete fully-qualified name instead.\n"
15246 /* This help string is used for the break, hbreak, tbreak and thbreak
15247 commands. It is defined as a macro to prevent duplication.
15248 COMMAND should be a string constant containing the name of the
15251 #define BREAK_ARGS_HELP(command) \
15252 command" [PROBE_MODIFIER] [LOCATION] [thread THREADNUM] [if CONDITION]\n\
15253 PROBE_MODIFIER shall be present if the command is to be placed in a\n\
15254 probe point. Accepted values are `-probe' (for a generic, automatically\n\
15255 guessed probe type), `-probe-stap' (for a SystemTap probe) or \n\
15256 `-probe-dtrace' (for a DTrace probe).\n\
15257 LOCATION may be a linespec, address, or explicit location as described\n\
15260 With no LOCATION, uses current execution address of the selected\n\
15261 stack frame. This is useful for breaking on return to a stack frame.\n\
15263 THREADNUM is the number from \"info threads\".\n\
15264 CONDITION is a boolean expression.\n\
15265 \n" LOCATION_HELP_STRING "\n\
15266 Multiple breakpoints at one place are permitted, and useful if their\n\
15267 conditions are different.\n\
15269 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
15271 /* List of subcommands for "catch". */
15272 static struct cmd_list_element
*catch_cmdlist
;
15274 /* List of subcommands for "tcatch". */
15275 static struct cmd_list_element
*tcatch_cmdlist
;
15278 add_catch_command (const char *name
, const char *docstring
,
15279 cmd_const_sfunc_ftype
*sfunc
,
15280 completer_ftype
*completer
,
15281 void *user_data_catch
,
15282 void *user_data_tcatch
)
15284 struct cmd_list_element
*command
;
15286 command
= add_cmd (name
, class_breakpoint
, docstring
,
15288 set_cmd_sfunc (command
, sfunc
);
15289 set_cmd_context (command
, user_data_catch
);
15290 set_cmd_completer (command
, completer
);
15292 command
= add_cmd (name
, class_breakpoint
, docstring
,
15294 set_cmd_sfunc (command
, sfunc
);
15295 set_cmd_context (command
, user_data_tcatch
);
15296 set_cmd_completer (command
, completer
);
15300 save_command (const char *arg
, int from_tty
)
15302 printf_unfiltered (_("\"save\" must be followed by "
15303 "the name of a save subcommand.\n"));
15304 help_list (save_cmdlist
, "save ", all_commands
, gdb_stdout
);
15307 struct breakpoint
*
15308 iterate_over_breakpoints (int (*callback
) (struct breakpoint
*, void *),
15311 struct breakpoint
*b
, *b_tmp
;
15313 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
15315 if ((*callback
) (b
, data
))
15322 /* Zero if any of the breakpoint's locations could be a location where
15323 functions have been inlined, nonzero otherwise. */
15326 is_non_inline_function (struct breakpoint
*b
)
15328 /* The shared library event breakpoint is set on the address of a
15329 non-inline function. */
15330 if (b
->type
== bp_shlib_event
)
15336 /* Nonzero if the specified PC cannot be a location where functions
15337 have been inlined. */
15340 pc_at_non_inline_function (const address_space
*aspace
, CORE_ADDR pc
,
15341 const struct target_waitstatus
*ws
)
15343 struct breakpoint
*b
;
15344 struct bp_location
*bl
;
15346 ALL_BREAKPOINTS (b
)
15348 if (!is_non_inline_function (b
))
15351 for (bl
= b
->loc
; bl
!= NULL
; bl
= bl
->next
)
15353 if (!bl
->shlib_disabled
15354 && bpstat_check_location (bl
, aspace
, pc
, ws
))
15362 /* Remove any references to OBJFILE which is going to be freed. */
15365 breakpoint_free_objfile (struct objfile
*objfile
)
15367 struct bp_location
**locp
, *loc
;
15369 ALL_BP_LOCATIONS (loc
, locp
)
15370 if (loc
->symtab
!= NULL
&& SYMTAB_OBJFILE (loc
->symtab
) == objfile
)
15371 loc
->symtab
= NULL
;
15375 initialize_breakpoint_ops (void)
15377 static int initialized
= 0;
15379 struct breakpoint_ops
*ops
;
15385 /* The breakpoint_ops structure to be inherit by all kinds of
15386 breakpoints (real breakpoints, i.e., user "break" breakpoints,
15387 internal and momentary breakpoints, etc.). */
15388 ops
= &bkpt_base_breakpoint_ops
;
15389 *ops
= base_breakpoint_ops
;
15390 ops
->re_set
= bkpt_re_set
;
15391 ops
->insert_location
= bkpt_insert_location
;
15392 ops
->remove_location
= bkpt_remove_location
;
15393 ops
->breakpoint_hit
= bkpt_breakpoint_hit
;
15394 ops
->create_sals_from_location
= bkpt_create_sals_from_location
;
15395 ops
->create_breakpoints_sal
= bkpt_create_breakpoints_sal
;
15396 ops
->decode_location
= bkpt_decode_location
;
15398 /* The breakpoint_ops structure to be used in regular breakpoints. */
15399 ops
= &bkpt_breakpoint_ops
;
15400 *ops
= bkpt_base_breakpoint_ops
;
15401 ops
->re_set
= bkpt_re_set
;
15402 ops
->resources_needed
= bkpt_resources_needed
;
15403 ops
->print_it
= bkpt_print_it
;
15404 ops
->print_mention
= bkpt_print_mention
;
15405 ops
->print_recreate
= bkpt_print_recreate
;
15407 /* Ranged breakpoints. */
15408 ops
= &ranged_breakpoint_ops
;
15409 *ops
= bkpt_breakpoint_ops
;
15410 ops
->breakpoint_hit
= breakpoint_hit_ranged_breakpoint
;
15411 ops
->resources_needed
= resources_needed_ranged_breakpoint
;
15412 ops
->print_it
= print_it_ranged_breakpoint
;
15413 ops
->print_one
= print_one_ranged_breakpoint
;
15414 ops
->print_one_detail
= print_one_detail_ranged_breakpoint
;
15415 ops
->print_mention
= print_mention_ranged_breakpoint
;
15416 ops
->print_recreate
= print_recreate_ranged_breakpoint
;
15418 /* Internal breakpoints. */
15419 ops
= &internal_breakpoint_ops
;
15420 *ops
= bkpt_base_breakpoint_ops
;
15421 ops
->re_set
= internal_bkpt_re_set
;
15422 ops
->check_status
= internal_bkpt_check_status
;
15423 ops
->print_it
= internal_bkpt_print_it
;
15424 ops
->print_mention
= internal_bkpt_print_mention
;
15426 /* Momentary breakpoints. */
15427 ops
= &momentary_breakpoint_ops
;
15428 *ops
= bkpt_base_breakpoint_ops
;
15429 ops
->re_set
= momentary_bkpt_re_set
;
15430 ops
->check_status
= momentary_bkpt_check_status
;
15431 ops
->print_it
= momentary_bkpt_print_it
;
15432 ops
->print_mention
= momentary_bkpt_print_mention
;
15434 /* Probe breakpoints. */
15435 ops
= &bkpt_probe_breakpoint_ops
;
15436 *ops
= bkpt_breakpoint_ops
;
15437 ops
->insert_location
= bkpt_probe_insert_location
;
15438 ops
->remove_location
= bkpt_probe_remove_location
;
15439 ops
->create_sals_from_location
= bkpt_probe_create_sals_from_location
;
15440 ops
->decode_location
= bkpt_probe_decode_location
;
15443 ops
= &watchpoint_breakpoint_ops
;
15444 *ops
= base_breakpoint_ops
;
15445 ops
->re_set
= re_set_watchpoint
;
15446 ops
->insert_location
= insert_watchpoint
;
15447 ops
->remove_location
= remove_watchpoint
;
15448 ops
->breakpoint_hit
= breakpoint_hit_watchpoint
;
15449 ops
->check_status
= check_status_watchpoint
;
15450 ops
->resources_needed
= resources_needed_watchpoint
;
15451 ops
->works_in_software_mode
= works_in_software_mode_watchpoint
;
15452 ops
->print_it
= print_it_watchpoint
;
15453 ops
->print_mention
= print_mention_watchpoint
;
15454 ops
->print_recreate
= print_recreate_watchpoint
;
15455 ops
->explains_signal
= explains_signal_watchpoint
;
15457 /* Masked watchpoints. */
15458 ops
= &masked_watchpoint_breakpoint_ops
;
15459 *ops
= watchpoint_breakpoint_ops
;
15460 ops
->insert_location
= insert_masked_watchpoint
;
15461 ops
->remove_location
= remove_masked_watchpoint
;
15462 ops
->resources_needed
= resources_needed_masked_watchpoint
;
15463 ops
->works_in_software_mode
= works_in_software_mode_masked_watchpoint
;
15464 ops
->print_it
= print_it_masked_watchpoint
;
15465 ops
->print_one_detail
= print_one_detail_masked_watchpoint
;
15466 ops
->print_mention
= print_mention_masked_watchpoint
;
15467 ops
->print_recreate
= print_recreate_masked_watchpoint
;
15470 ops
= &tracepoint_breakpoint_ops
;
15471 *ops
= base_breakpoint_ops
;
15472 ops
->re_set
= tracepoint_re_set
;
15473 ops
->breakpoint_hit
= tracepoint_breakpoint_hit
;
15474 ops
->print_one_detail
= tracepoint_print_one_detail
;
15475 ops
->print_mention
= tracepoint_print_mention
;
15476 ops
->print_recreate
= tracepoint_print_recreate
;
15477 ops
->create_sals_from_location
= tracepoint_create_sals_from_location
;
15478 ops
->create_breakpoints_sal
= tracepoint_create_breakpoints_sal
;
15479 ops
->decode_location
= tracepoint_decode_location
;
15481 /* Probe tracepoints. */
15482 ops
= &tracepoint_probe_breakpoint_ops
;
15483 *ops
= tracepoint_breakpoint_ops
;
15484 ops
->create_sals_from_location
= tracepoint_probe_create_sals_from_location
;
15485 ops
->decode_location
= tracepoint_probe_decode_location
;
15487 /* Static tracepoints with marker (`-m'). */
15488 ops
= &strace_marker_breakpoint_ops
;
15489 *ops
= tracepoint_breakpoint_ops
;
15490 ops
->create_sals_from_location
= strace_marker_create_sals_from_location
;
15491 ops
->create_breakpoints_sal
= strace_marker_create_breakpoints_sal
;
15492 ops
->decode_location
= strace_marker_decode_location
;
15494 /* Fork catchpoints. */
15495 ops
= &catch_fork_breakpoint_ops
;
15496 *ops
= base_breakpoint_ops
;
15497 ops
->insert_location
= insert_catch_fork
;
15498 ops
->remove_location
= remove_catch_fork
;
15499 ops
->breakpoint_hit
= breakpoint_hit_catch_fork
;
15500 ops
->print_it
= print_it_catch_fork
;
15501 ops
->print_one
= print_one_catch_fork
;
15502 ops
->print_mention
= print_mention_catch_fork
;
15503 ops
->print_recreate
= print_recreate_catch_fork
;
15505 /* Vfork catchpoints. */
15506 ops
= &catch_vfork_breakpoint_ops
;
15507 *ops
= base_breakpoint_ops
;
15508 ops
->insert_location
= insert_catch_vfork
;
15509 ops
->remove_location
= remove_catch_vfork
;
15510 ops
->breakpoint_hit
= breakpoint_hit_catch_vfork
;
15511 ops
->print_it
= print_it_catch_vfork
;
15512 ops
->print_one
= print_one_catch_vfork
;
15513 ops
->print_mention
= print_mention_catch_vfork
;
15514 ops
->print_recreate
= print_recreate_catch_vfork
;
15516 /* Exec catchpoints. */
15517 ops
= &catch_exec_breakpoint_ops
;
15518 *ops
= base_breakpoint_ops
;
15519 ops
->insert_location
= insert_catch_exec
;
15520 ops
->remove_location
= remove_catch_exec
;
15521 ops
->breakpoint_hit
= breakpoint_hit_catch_exec
;
15522 ops
->print_it
= print_it_catch_exec
;
15523 ops
->print_one
= print_one_catch_exec
;
15524 ops
->print_mention
= print_mention_catch_exec
;
15525 ops
->print_recreate
= print_recreate_catch_exec
;
15527 /* Solib-related catchpoints. */
15528 ops
= &catch_solib_breakpoint_ops
;
15529 *ops
= base_breakpoint_ops
;
15530 ops
->insert_location
= insert_catch_solib
;
15531 ops
->remove_location
= remove_catch_solib
;
15532 ops
->breakpoint_hit
= breakpoint_hit_catch_solib
;
15533 ops
->check_status
= check_status_catch_solib
;
15534 ops
->print_it
= print_it_catch_solib
;
15535 ops
->print_one
= print_one_catch_solib
;
15536 ops
->print_mention
= print_mention_catch_solib
;
15537 ops
->print_recreate
= print_recreate_catch_solib
;
15539 ops
= &dprintf_breakpoint_ops
;
15540 *ops
= bkpt_base_breakpoint_ops
;
15541 ops
->re_set
= dprintf_re_set
;
15542 ops
->resources_needed
= bkpt_resources_needed
;
15543 ops
->print_it
= bkpt_print_it
;
15544 ops
->print_mention
= bkpt_print_mention
;
15545 ops
->print_recreate
= dprintf_print_recreate
;
15546 ops
->after_condition_true
= dprintf_after_condition_true
;
15547 ops
->breakpoint_hit
= dprintf_breakpoint_hit
;
15550 /* Chain containing all defined "enable breakpoint" subcommands. */
15552 static struct cmd_list_element
*enablebreaklist
= NULL
;
15555 _initialize_breakpoint (void)
15557 struct cmd_list_element
*c
;
15559 initialize_breakpoint_ops ();
15561 gdb::observers::solib_unloaded
.attach (disable_breakpoints_in_unloaded_shlib
);
15562 gdb::observers::free_objfile
.attach (disable_breakpoints_in_freed_objfile
);
15563 gdb::observers::memory_changed
.attach (invalidate_bp_value_on_memory_change
);
15565 breakpoint_objfile_key
15566 = register_objfile_data_with_cleanup (NULL
, free_breakpoint_objfile_data
);
15568 breakpoint_chain
= 0;
15569 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
15570 before a breakpoint is set. */
15571 breakpoint_count
= 0;
15573 tracepoint_count
= 0;
15575 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
15576 Set ignore-count of breakpoint number N to COUNT.\n\
15577 Usage is `ignore N COUNT'."));
15579 add_com ("commands", class_breakpoint
, commands_command
, _("\
15580 Set commands to be executed when the given breakpoints are hit.\n\
15581 Give a space-separated breakpoint list as argument after \"commands\".\n\
15582 A list element can be a breakpoint number (e.g. `5') or a range of numbers\n\
15584 With no argument, the targeted breakpoint is the last one set.\n\
15585 The commands themselves follow starting on the next line.\n\
15586 Type a line containing \"end\" to indicate the end of them.\n\
15587 Give \"silent\" as the first line to make the breakpoint silent;\n\
15588 then no output is printed when it is hit, except what the commands print."));
15590 c
= add_com ("condition", class_breakpoint
, condition_command
, _("\
15591 Specify breakpoint number N to break only if COND is true.\n\
15592 Usage is `condition N COND', where N is an integer and COND is an\n\
15593 expression to be evaluated whenever breakpoint N is reached."));
15594 set_cmd_completer (c
, condition_completer
);
15596 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
15597 Set a temporary breakpoint.\n\
15598 Like \"break\" except the breakpoint is only temporary,\n\
15599 so it will be deleted when hit. Equivalent to \"break\" followed\n\
15600 by using \"enable delete\" on the breakpoint number.\n\
15602 BREAK_ARGS_HELP ("tbreak")));
15603 set_cmd_completer (c
, location_completer
);
15605 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
15606 Set a hardware assisted breakpoint.\n\
15607 Like \"break\" except the breakpoint requires hardware support,\n\
15608 some target hardware may not have this support.\n\
15610 BREAK_ARGS_HELP ("hbreak")));
15611 set_cmd_completer (c
, location_completer
);
15613 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
15614 Set a temporary hardware assisted breakpoint.\n\
15615 Like \"hbreak\" except the breakpoint is only temporary,\n\
15616 so it will be deleted when hit.\n\
15618 BREAK_ARGS_HELP ("thbreak")));
15619 set_cmd_completer (c
, location_completer
);
15621 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
15622 Enable some breakpoints.\n\
15623 Give breakpoint numbers (separated by spaces) as arguments.\n\
15624 With no subcommand, breakpoints are enabled until you command otherwise.\n\
15625 This is used to cancel the effect of the \"disable\" command.\n\
15626 With a subcommand you can enable temporarily."),
15627 &enablelist
, "enable ", 1, &cmdlist
);
15629 add_com_alias ("en", "enable", class_breakpoint
, 1);
15631 add_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
15632 Enable some breakpoints.\n\
15633 Give breakpoint numbers (separated by spaces) as arguments.\n\
15634 This is used to cancel the effect of the \"disable\" command.\n\
15635 May be abbreviated to simply \"enable\".\n"),
15636 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
15638 add_cmd ("once", no_class
, enable_once_command
, _("\
15639 Enable breakpoints for one hit. Give breakpoint numbers.\n\
15640 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
15643 add_cmd ("delete", no_class
, enable_delete_command
, _("\
15644 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
15645 If a breakpoint is hit while enabled in this fashion, it is deleted."),
15648 add_cmd ("count", no_class
, enable_count_command
, _("\
15649 Enable breakpoints for COUNT hits. Give count and then breakpoint numbers.\n\
15650 If a breakpoint is hit while enabled in this fashion,\n\
15651 the count is decremented; when it reaches zero, the breakpoint is disabled."),
15654 add_cmd ("delete", no_class
, enable_delete_command
, _("\
15655 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
15656 If a breakpoint is hit while enabled in this fashion, it is deleted."),
15659 add_cmd ("once", no_class
, enable_once_command
, _("\
15660 Enable breakpoints for one hit. Give breakpoint numbers.\n\
15661 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
15664 add_cmd ("count", no_class
, enable_count_command
, _("\
15665 Enable breakpoints for COUNT hits. Give count and then breakpoint numbers.\n\
15666 If a breakpoint is hit while enabled in this fashion,\n\
15667 the count is decremented; when it reaches zero, the breakpoint is disabled."),
15670 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
15671 Disable some breakpoints.\n\
15672 Arguments are breakpoint numbers with spaces in between.\n\
15673 To disable all breakpoints, give no argument.\n\
15674 A disabled breakpoint is not forgotten, but has no effect until re-enabled."),
15675 &disablelist
, "disable ", 1, &cmdlist
);
15676 add_com_alias ("dis", "disable", class_breakpoint
, 1);
15677 add_com_alias ("disa", "disable", class_breakpoint
, 1);
15679 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
15680 Disable some breakpoints.\n\
15681 Arguments are breakpoint numbers with spaces in between.\n\
15682 To disable all breakpoints, give no argument.\n\
15683 A disabled breakpoint is not forgotten, but has no effect until re-enabled.\n\
15684 This command may be abbreviated \"disable\"."),
15687 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
15688 Delete some breakpoints or auto-display expressions.\n\
15689 Arguments are breakpoint numbers with spaces in between.\n\
15690 To delete all breakpoints, give no argument.\n\
15692 Also a prefix command for deletion of other GDB objects.\n\
15693 The \"unset\" command is also an alias for \"delete\"."),
15694 &deletelist
, "delete ", 1, &cmdlist
);
15695 add_com_alias ("d", "delete", class_breakpoint
, 1);
15696 add_com_alias ("del", "delete", class_breakpoint
, 1);
15698 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
15699 Delete some breakpoints or auto-display expressions.\n\
15700 Arguments are breakpoint numbers with spaces in between.\n\
15701 To delete all breakpoints, give no argument.\n\
15702 This command may be abbreviated \"delete\"."),
15705 add_com ("clear", class_breakpoint
, clear_command
, _("\
15706 Clear breakpoint at specified location.\n\
15707 Argument may be a linespec, explicit, or address location as described below.\n\
15709 With no argument, clears all breakpoints in the line that the selected frame\n\
15710 is executing in.\n"
15711 "\n" LOCATION_HELP_STRING
"\n\
15712 See also the \"delete\" command which clears breakpoints by number."));
15713 add_com_alias ("cl", "clear", class_breakpoint
, 1);
15715 c
= add_com ("break", class_breakpoint
, break_command
, _("\
15716 Set breakpoint at specified location.\n"
15717 BREAK_ARGS_HELP ("break")));
15718 set_cmd_completer (c
, location_completer
);
15720 add_com_alias ("b", "break", class_run
, 1);
15721 add_com_alias ("br", "break", class_run
, 1);
15722 add_com_alias ("bre", "break", class_run
, 1);
15723 add_com_alias ("brea", "break", class_run
, 1);
15727 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
15728 Break in function/address or break at a line in the current file."),
15729 &stoplist
, "stop ", 1, &cmdlist
);
15730 add_cmd ("in", class_breakpoint
, stopin_command
,
15731 _("Break in function or address."), &stoplist
);
15732 add_cmd ("at", class_breakpoint
, stopat_command
,
15733 _("Break at a line in the current file."), &stoplist
);
15734 add_com ("status", class_info
, info_breakpoints_command
, _("\
15735 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
15736 The \"Type\" column indicates one of:\n\
15737 \tbreakpoint - normal breakpoint\n\
15738 \twatchpoint - watchpoint\n\
15739 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15740 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
15741 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
15742 address and file/line number respectively.\n\
15744 Convenience variable \"$_\" and default examine address for \"x\"\n\
15745 are set to the address of the last breakpoint listed unless the command\n\
15746 is prefixed with \"server \".\n\n\
15747 Convenience variable \"$bpnum\" contains the number of the last\n\
15748 breakpoint set."));
15751 add_info ("breakpoints", info_breakpoints_command
, _("\
15752 Status of specified breakpoints (all user-settable breakpoints if no argument).\n\
15753 The \"Type\" column indicates one of:\n\
15754 \tbreakpoint - normal breakpoint\n\
15755 \twatchpoint - watchpoint\n\
15756 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15757 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
15758 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
15759 address and file/line number respectively.\n\
15761 Convenience variable \"$_\" and default examine address for \"x\"\n\
15762 are set to the address of the last breakpoint listed unless the command\n\
15763 is prefixed with \"server \".\n\n\
15764 Convenience variable \"$bpnum\" contains the number of the last\n\
15765 breakpoint set."));
15767 add_info_alias ("b", "breakpoints", 1);
15769 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
15770 Status of all breakpoints, or breakpoint number NUMBER.\n\
15771 The \"Type\" column indicates one of:\n\
15772 \tbreakpoint - normal breakpoint\n\
15773 \twatchpoint - watchpoint\n\
15774 \tlongjmp - internal breakpoint used to step through longjmp()\n\
15775 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
15776 \tuntil - internal breakpoint used by the \"until\" command\n\
15777 \tfinish - internal breakpoint used by the \"finish\" command\n\
15778 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15779 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
15780 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
15781 address and file/line number respectively.\n\
15783 Convenience variable \"$_\" and default examine address for \"x\"\n\
15784 are set to the address of the last breakpoint listed unless the command\n\
15785 is prefixed with \"server \".\n\n\
15786 Convenience variable \"$bpnum\" contains the number of the last\n\
15788 &maintenanceinfolist
);
15790 add_prefix_cmd ("catch", class_breakpoint
, catch_command
, _("\
15791 Set catchpoints to catch events."),
15792 &catch_cmdlist
, "catch ",
15793 0/*allow-unknown*/, &cmdlist
);
15795 add_prefix_cmd ("tcatch", class_breakpoint
, tcatch_command
, _("\
15796 Set temporary catchpoints to catch events."),
15797 &tcatch_cmdlist
, "tcatch ",
15798 0/*allow-unknown*/, &cmdlist
);
15800 add_catch_command ("fork", _("Catch calls to fork."),
15801 catch_fork_command_1
,
15803 (void *) (uintptr_t) catch_fork_permanent
,
15804 (void *) (uintptr_t) catch_fork_temporary
);
15805 add_catch_command ("vfork", _("Catch calls to vfork."),
15806 catch_fork_command_1
,
15808 (void *) (uintptr_t) catch_vfork_permanent
,
15809 (void *) (uintptr_t) catch_vfork_temporary
);
15810 add_catch_command ("exec", _("Catch calls to exec."),
15811 catch_exec_command_1
,
15815 add_catch_command ("load", _("Catch loads of shared libraries.\n\
15816 Usage: catch load [REGEX]\n\
15817 If REGEX is given, only stop for libraries matching the regular expression."),
15818 catch_load_command_1
,
15822 add_catch_command ("unload", _("Catch unloads of shared libraries.\n\
15823 Usage: catch unload [REGEX]\n\
15824 If REGEX is given, only stop for libraries matching the regular expression."),
15825 catch_unload_command_1
,
15830 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
15831 Set a watchpoint for an expression.\n\
15832 Usage: watch [-l|-location] EXPRESSION\n\
15833 A watchpoint stops execution of your program whenever the value of\n\
15834 an expression changes.\n\
15835 If -l or -location is given, this evaluates EXPRESSION and watches\n\
15836 the memory to which it refers."));
15837 set_cmd_completer (c
, expression_completer
);
15839 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
15840 Set a read watchpoint for an expression.\n\
15841 Usage: rwatch [-l|-location] EXPRESSION\n\
15842 A watchpoint stops execution of your program whenever the value of\n\
15843 an expression is read.\n\
15844 If -l or -location is given, this evaluates EXPRESSION and watches\n\
15845 the memory to which it refers."));
15846 set_cmd_completer (c
, expression_completer
);
15848 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
15849 Set a watchpoint for an expression.\n\
15850 Usage: awatch [-l|-location] EXPRESSION\n\
15851 A watchpoint stops execution of your program whenever the value of\n\
15852 an expression is either read or written.\n\
15853 If -l or -location is given, this evaluates EXPRESSION and watches\n\
15854 the memory to which it refers."));
15855 set_cmd_completer (c
, expression_completer
);
15857 add_info ("watchpoints", info_watchpoints_command
, _("\
15858 Status of specified watchpoints (all watchpoints if no argument)."));
15860 /* XXX: cagney/2005-02-23: This should be a boolean, and should
15861 respond to changes - contrary to the description. */
15862 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
15863 &can_use_hw_watchpoints
, _("\
15864 Set debugger's willingness to use watchpoint hardware."), _("\
15865 Show debugger's willingness to use watchpoint hardware."), _("\
15866 If zero, gdb will not use hardware for new watchpoints, even if\n\
15867 such is available. (However, any hardware watchpoints that were\n\
15868 created before setting this to nonzero, will continue to use watchpoint\n\
15871 show_can_use_hw_watchpoints
,
15872 &setlist
, &showlist
);
15874 can_use_hw_watchpoints
= 1;
15876 /* Tracepoint manipulation commands. */
15878 c
= add_com ("trace", class_breakpoint
, trace_command
, _("\
15879 Set a tracepoint at specified location.\n\
15881 BREAK_ARGS_HELP ("trace") "\n\
15882 Do \"help tracepoints\" for info on other tracepoint commands."));
15883 set_cmd_completer (c
, location_completer
);
15885 add_com_alias ("tp", "trace", class_alias
, 0);
15886 add_com_alias ("tr", "trace", class_alias
, 1);
15887 add_com_alias ("tra", "trace", class_alias
, 1);
15888 add_com_alias ("trac", "trace", class_alias
, 1);
15890 c
= add_com ("ftrace", class_breakpoint
, ftrace_command
, _("\
15891 Set a fast tracepoint at specified location.\n\
15893 BREAK_ARGS_HELP ("ftrace") "\n\
15894 Do \"help tracepoints\" for info on other tracepoint commands."));
15895 set_cmd_completer (c
, location_completer
);
15897 c
= add_com ("strace", class_breakpoint
, strace_command
, _("\
15898 Set a static tracepoint at location or marker.\n\
15900 strace [LOCATION] [if CONDITION]\n\
15901 LOCATION may be a linespec, explicit, or address location (described below) \n\
15902 or -m MARKER_ID.\n\n\
15903 If a marker id is specified, probe the marker with that name. With\n\
15904 no LOCATION, uses current execution address of the selected stack frame.\n\
15905 Static tracepoints accept an extra collect action -- ``collect $_sdata''.\n\
15906 This collects arbitrary user data passed in the probe point call to the\n\
15907 tracing library. You can inspect it when analyzing the trace buffer,\n\
15908 by printing the $_sdata variable like any other convenience variable.\n\
15910 CONDITION is a boolean expression.\n\
15911 \n" LOCATION_HELP_STRING
"\n\
15912 Multiple tracepoints at one place are permitted, and useful if their\n\
15913 conditions are different.\n\
15915 Do \"help breakpoints\" for info on other commands dealing with breakpoints.\n\
15916 Do \"help tracepoints\" for info on other tracepoint commands."));
15917 set_cmd_completer (c
, location_completer
);
15919 add_info ("tracepoints", info_tracepoints_command
, _("\
15920 Status of specified tracepoints (all tracepoints if no argument).\n\
15921 Convenience variable \"$tpnum\" contains the number of the\n\
15922 last tracepoint set."));
15924 add_info_alias ("tp", "tracepoints", 1);
15926 add_cmd ("tracepoints", class_trace
, delete_trace_command
, _("\
15927 Delete specified tracepoints.\n\
15928 Arguments are tracepoint numbers, separated by spaces.\n\
15929 No argument means delete all tracepoints."),
15931 add_alias_cmd ("tr", "tracepoints", class_trace
, 1, &deletelist
);
15933 c
= add_cmd ("tracepoints", class_trace
, disable_trace_command
, _("\
15934 Disable specified tracepoints.\n\
15935 Arguments are tracepoint numbers, separated by spaces.\n\
15936 No argument means disable all tracepoints."),
15938 deprecate_cmd (c
, "disable");
15940 c
= add_cmd ("tracepoints", class_trace
, enable_trace_command
, _("\
15941 Enable specified tracepoints.\n\
15942 Arguments are tracepoint numbers, separated by spaces.\n\
15943 No argument means enable all tracepoints."),
15945 deprecate_cmd (c
, "enable");
15947 add_com ("passcount", class_trace
, trace_pass_command
, _("\
15948 Set the passcount for a tracepoint.\n\
15949 The trace will end when the tracepoint has been passed 'count' times.\n\
15950 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
15951 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
15953 add_prefix_cmd ("save", class_breakpoint
, save_command
,
15954 _("Save breakpoint definitions as a script."),
15955 &save_cmdlist
, "save ",
15956 0/*allow-unknown*/, &cmdlist
);
15958 c
= add_cmd ("breakpoints", class_breakpoint
, save_breakpoints_command
, _("\
15959 Save current breakpoint definitions as a script.\n\
15960 This includes all types of breakpoints (breakpoints, watchpoints,\n\
15961 catchpoints, tracepoints). Use the 'source' command in another debug\n\
15962 session to restore them."),
15964 set_cmd_completer (c
, filename_completer
);
15966 c
= add_cmd ("tracepoints", class_trace
, save_tracepoints_command
, _("\
15967 Save current tracepoint definitions as a script.\n\
15968 Use the 'source' command in another debug session to restore them."),
15970 set_cmd_completer (c
, filename_completer
);
15972 c
= add_com_alias ("save-tracepoints", "save tracepoints", class_trace
, 0);
15973 deprecate_cmd (c
, "save tracepoints");
15975 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
15976 Breakpoint specific settings\n\
15977 Configure various breakpoint-specific variables such as\n\
15978 pending breakpoint behavior"),
15979 &breakpoint_set_cmdlist
, "set breakpoint ",
15980 0/*allow-unknown*/, &setlist
);
15981 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
15982 Breakpoint specific settings\n\
15983 Configure various breakpoint-specific variables such as\n\
15984 pending breakpoint behavior"),
15985 &breakpoint_show_cmdlist
, "show breakpoint ",
15986 0/*allow-unknown*/, &showlist
);
15988 add_setshow_auto_boolean_cmd ("pending", no_class
,
15989 &pending_break_support
, _("\
15990 Set debugger's behavior regarding pending breakpoints."), _("\
15991 Show debugger's behavior regarding pending breakpoints."), _("\
15992 If on, an unrecognized breakpoint location will cause gdb to create a\n\
15993 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
15994 an error. If auto, an unrecognized breakpoint location results in a\n\
15995 user-query to see if a pending breakpoint should be created."),
15997 show_pending_break_support
,
15998 &breakpoint_set_cmdlist
,
15999 &breakpoint_show_cmdlist
);
16001 pending_break_support
= AUTO_BOOLEAN_AUTO
;
16003 add_setshow_boolean_cmd ("auto-hw", no_class
,
16004 &automatic_hardware_breakpoints
, _("\
16005 Set automatic usage of hardware breakpoints."), _("\
16006 Show automatic usage of hardware breakpoints."), _("\
16007 If set, the debugger will automatically use hardware breakpoints for\n\
16008 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
16009 a warning will be emitted for such breakpoints."),
16011 show_automatic_hardware_breakpoints
,
16012 &breakpoint_set_cmdlist
,
16013 &breakpoint_show_cmdlist
);
16015 add_setshow_boolean_cmd ("always-inserted", class_support
,
16016 &always_inserted_mode
, _("\
16017 Set mode for inserting breakpoints."), _("\
16018 Show mode for inserting breakpoints."), _("\
16019 When this mode is on, breakpoints are inserted immediately as soon as\n\
16020 they're created, kept inserted even when execution stops, and removed\n\
16021 only when the user deletes them. When this mode is off (the default),\n\
16022 breakpoints are inserted only when execution continues, and removed\n\
16023 when execution stops."),
16025 &show_always_inserted_mode
,
16026 &breakpoint_set_cmdlist
,
16027 &breakpoint_show_cmdlist
);
16029 add_setshow_enum_cmd ("condition-evaluation", class_breakpoint
,
16030 condition_evaluation_enums
,
16031 &condition_evaluation_mode_1
, _("\
16032 Set mode of breakpoint condition evaluation."), _("\
16033 Show mode of breakpoint condition evaluation."), _("\
16034 When this is set to \"host\", breakpoint conditions will be\n\
16035 evaluated on the host's side by GDB. When it is set to \"target\",\n\
16036 breakpoint conditions will be downloaded to the target (if the target\n\
16037 supports such feature) and conditions will be evaluated on the target's side.\n\
16038 If this is set to \"auto\" (default), this will be automatically set to\n\
16039 \"target\" if it supports condition evaluation, otherwise it will\n\
16040 be set to \"gdb\""),
16041 &set_condition_evaluation_mode
,
16042 &show_condition_evaluation_mode
,
16043 &breakpoint_set_cmdlist
,
16044 &breakpoint_show_cmdlist
);
16046 add_com ("break-range", class_breakpoint
, break_range_command
, _("\
16047 Set a breakpoint for an address range.\n\
16048 break-range START-LOCATION, END-LOCATION\n\
16049 where START-LOCATION and END-LOCATION can be one of the following:\n\
16050 LINENUM, for that line in the current file,\n\
16051 FILE:LINENUM, for that line in that file,\n\
16052 +OFFSET, for that number of lines after the current line\n\
16053 or the start of the range\n\
16054 FUNCTION, for the first line in that function,\n\
16055 FILE:FUNCTION, to distinguish among like-named static functions.\n\
16056 *ADDRESS, for the instruction at that address.\n\
16058 The breakpoint will stop execution of the inferior whenever it executes\n\
16059 an instruction at any address within the [START-LOCATION, END-LOCATION]\n\
16060 range (including START-LOCATION and END-LOCATION)."));
16062 c
= add_com ("dprintf", class_breakpoint
, dprintf_command
, _("\
16063 Set a dynamic printf at specified location.\n\
16064 dprintf location,format string,arg1,arg2,...\n\
16065 location may be a linespec, explicit, or address location.\n"
16066 "\n" LOCATION_HELP_STRING
));
16067 set_cmd_completer (c
, location_completer
);
16069 add_setshow_enum_cmd ("dprintf-style", class_support
,
16070 dprintf_style_enums
, &dprintf_style
, _("\
16071 Set the style of usage for dynamic printf."), _("\
16072 Show the style of usage for dynamic printf."), _("\
16073 This setting chooses how GDB will do a dynamic printf.\n\
16074 If the value is \"gdb\", then the printing is done by GDB to its own\n\
16075 console, as with the \"printf\" command.\n\
16076 If the value is \"call\", the print is done by calling a function in your\n\
16077 program; by default printf(), but you can choose a different function or\n\
16078 output stream by setting dprintf-function and dprintf-channel."),
16079 update_dprintf_commands
, NULL
,
16080 &setlist
, &showlist
);
16082 dprintf_function
= xstrdup ("printf");
16083 add_setshow_string_cmd ("dprintf-function", class_support
,
16084 &dprintf_function
, _("\
16085 Set the function to use for dynamic printf"), _("\
16086 Show the function to use for dynamic printf"), NULL
,
16087 update_dprintf_commands
, NULL
,
16088 &setlist
, &showlist
);
16090 dprintf_channel
= xstrdup ("");
16091 add_setshow_string_cmd ("dprintf-channel", class_support
,
16092 &dprintf_channel
, _("\
16093 Set the channel to use for dynamic printf"), _("\
16094 Show the channel to use for dynamic printf"), NULL
,
16095 update_dprintf_commands
, NULL
,
16096 &setlist
, &showlist
);
16098 add_setshow_boolean_cmd ("disconnected-dprintf", no_class
,
16099 &disconnected_dprintf
, _("\
16100 Set whether dprintf continues after GDB disconnects."), _("\
16101 Show whether dprintf continues after GDB disconnects."), _("\
16102 Use this to let dprintf commands continue to hit and produce output\n\
16103 even if GDB disconnects or detaches from the target."),
16106 &setlist
, &showlist
);
16108 add_com ("agent-printf", class_vars
, agent_printf_command
, _("\
16109 agent-printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
16110 (target agent only) This is useful for formatted output in user-defined commands."));
16112 automatic_hardware_breakpoints
= 1;
16114 gdb::observers::about_to_proceed
.attach (breakpoint_about_to_proceed
);
16115 gdb::observers::thread_exit
.attach (remove_threaded_breakpoints
);