1 /* Everything about breakpoints, for GDB.
3 Copyright (C) 1986-2017 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "arch-utils.h"
26 #include "breakpoint.h"
27 #include "tracepoint.h"
29 #include "expression.h"
36 #include "gdbthread.h"
39 #include "gdb-demangle.h"
40 #include "filenames.h"
46 #include "completer.h"
48 #include "cli/cli-script.h"
58 #include "parser-defs.h"
59 #include "gdb_regex.h"
61 #include "cli/cli-utils.h"
62 #include "continuations.h"
66 #include "dummy-frame.h"
69 #include "thread-fsm.h"
70 #include "tid-parse.h"
72 /* readline include files */
73 #include "readline/readline.h"
74 #include "readline/history.h"
76 /* readline defines this. */
79 #include "mi/mi-common.h"
80 #include "extension.h"
82 #include "progspace-and-thread.h"
83 #include "common/array-view.h"
84 #include "common/gdb_optional.h"
86 /* Enums for exception-handling support. */
87 enum exception_event_kind
94 /* Prototypes for local functions. */
96 static void map_breakpoint_numbers (const char *,
97 gdb::function_view
<void (breakpoint
*)>);
99 static void 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
= NULL
;
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
;
891 struct bp_location
*loc
;
893 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
897 parse_exp_1 (&arg
, loc
->address
,
898 block_for_pc (loc
->address
), 0);
900 error (_("Junk at end of expression"));
904 mark_breakpoint_modified (b
);
906 observer_notify_breakpoint_modified (b
);
909 /* Completion for the "condition" command. */
912 condition_completer (struct cmd_list_element
*cmd
,
913 completion_tracker
&tracker
,
914 const char *text
, const char *word
)
918 text
= skip_spaces (text
);
919 space
= skip_to_space (text
);
923 struct breakpoint
*b
;
924 VEC (char_ptr
) *result
= NULL
;
928 /* We don't support completion of history indices. */
929 if (!isdigit (text
[1]))
930 complete_internalvar (tracker
, &text
[1]);
934 /* We're completing the breakpoint number. */
941 xsnprintf (number
, sizeof (number
), "%d", b
->number
);
943 if (strncmp (number
, text
, len
) == 0)
945 gdb::unique_xmalloc_ptr
<char> copy (xstrdup (number
));
946 tracker
.add_completion (std::move (copy
));
953 /* We're completing the expression part. */
954 text
= skip_spaces (space
);
955 expression_completer (cmd
, tracker
, text
, word
);
958 /* condition N EXP -- set break condition of breakpoint N to EXP. */
961 condition_command (const char *arg
, int from_tty
)
963 struct breakpoint
*b
;
968 error_no_arg (_("breakpoint number"));
971 bnum
= get_number (&p
);
973 error (_("Bad breakpoint argument: '%s'"), arg
);
976 if (b
->number
== bnum
)
978 /* Check if this breakpoint has a "stop" method implemented in an
979 extension language. This method and conditions entered into GDB
980 from the CLI are mutually exclusive. */
981 const struct extension_language_defn
*extlang
982 = get_breakpoint_cond_ext_lang (b
, EXT_LANG_NONE
);
986 error (_("Only one stop condition allowed. There is currently"
987 " a %s stop condition defined for this breakpoint."),
988 ext_lang_capitalized_name (extlang
));
990 set_breakpoint_condition (b
, p
, from_tty
);
992 if (is_breakpoint (b
))
993 update_global_location_list (UGLL_MAY_INSERT
);
998 error (_("No breakpoint number %d."), bnum
);
1001 /* Check that COMMAND do not contain commands that are suitable
1002 only for tracepoints and not suitable for ordinary breakpoints.
1003 Throw if any such commands is found. */
1006 check_no_tracepoint_commands (struct command_line
*commands
)
1008 struct command_line
*c
;
1010 for (c
= commands
; c
; c
= c
->next
)
1014 if (c
->control_type
== while_stepping_control
)
1015 error (_("The 'while-stepping' command can "
1016 "only be used for tracepoints"));
1018 for (i
= 0; i
< c
->body_count
; ++i
)
1019 check_no_tracepoint_commands ((c
->body_list
)[i
]);
1021 /* Not that command parsing removes leading whitespace and comment
1022 lines and also empty lines. So, we only need to check for
1023 command directly. */
1024 if (strstr (c
->line
, "collect ") == c
->line
)
1025 error (_("The 'collect' command can only be used for tracepoints"));
1027 if (strstr (c
->line
, "teval ") == c
->line
)
1028 error (_("The 'teval' command can only be used for tracepoints"));
1032 struct longjmp_breakpoint
: public breakpoint
1034 ~longjmp_breakpoint () override
;
1037 /* Encapsulate tests for different types of tracepoints. */
1040 is_tracepoint_type (bptype type
)
1042 return (type
== bp_tracepoint
1043 || type
== bp_fast_tracepoint
1044 || type
== bp_static_tracepoint
);
1048 is_longjmp_type (bptype type
)
1050 return type
== bp_longjmp
|| type
== bp_exception
;
1054 is_tracepoint (const struct breakpoint
*b
)
1056 return is_tracepoint_type (b
->type
);
1059 /* Factory function to create an appropriate instance of breakpoint given
1062 static std::unique_ptr
<breakpoint
>
1063 new_breakpoint_from_type (bptype type
)
1067 if (is_tracepoint_type (type
))
1068 b
= new tracepoint ();
1069 else if (is_longjmp_type (type
))
1070 b
= new longjmp_breakpoint ();
1072 b
= new breakpoint ();
1074 return std::unique_ptr
<breakpoint
> (b
);
1077 /* A helper function that validates that COMMANDS are valid for a
1078 breakpoint. This function will throw an exception if a problem is
1082 validate_commands_for_breakpoint (struct breakpoint
*b
,
1083 struct command_line
*commands
)
1085 if (is_tracepoint (b
))
1087 struct tracepoint
*t
= (struct tracepoint
*) b
;
1088 struct command_line
*c
;
1089 struct command_line
*while_stepping
= 0;
1091 /* Reset the while-stepping step count. The previous commands
1092 might have included a while-stepping action, while the new
1096 /* We need to verify that each top-level element of commands is
1097 valid for tracepoints, that there's at most one
1098 while-stepping element, and that the while-stepping's body
1099 has valid tracing commands excluding nested while-stepping.
1100 We also need to validate the tracepoint action line in the
1101 context of the tracepoint --- validate_actionline actually
1102 has side effects, like setting the tracepoint's
1103 while-stepping STEP_COUNT, in addition to checking if the
1104 collect/teval actions parse and make sense in the
1105 tracepoint's context. */
1106 for (c
= commands
; c
; c
= c
->next
)
1108 if (c
->control_type
== while_stepping_control
)
1110 if (b
->type
== bp_fast_tracepoint
)
1111 error (_("The 'while-stepping' command "
1112 "cannot be used for fast tracepoint"));
1113 else if (b
->type
== bp_static_tracepoint
)
1114 error (_("The 'while-stepping' command "
1115 "cannot be used for static tracepoint"));
1118 error (_("The 'while-stepping' command "
1119 "can be used only once"));
1124 validate_actionline (c
->line
, b
);
1128 struct command_line
*c2
;
1130 gdb_assert (while_stepping
->body_count
== 1);
1131 c2
= while_stepping
->body_list
[0];
1132 for (; c2
; c2
= c2
->next
)
1134 if (c2
->control_type
== while_stepping_control
)
1135 error (_("The 'while-stepping' command cannot be nested"));
1141 check_no_tracepoint_commands (commands
);
1145 /* Return a vector of all the static tracepoints set at ADDR. The
1146 caller is responsible for releasing the vector. */
1149 static_tracepoints_here (CORE_ADDR addr
)
1151 struct breakpoint
*b
;
1152 VEC(breakpoint_p
) *found
= 0;
1153 struct bp_location
*loc
;
1156 if (b
->type
== bp_static_tracepoint
)
1158 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1159 if (loc
->address
== addr
)
1160 VEC_safe_push(breakpoint_p
, found
, b
);
1166 /* Set the command list of B to COMMANDS. If breakpoint is tracepoint,
1167 validate that only allowed commands are included. */
1170 breakpoint_set_commands (struct breakpoint
*b
,
1171 command_line_up
&&commands
)
1173 validate_commands_for_breakpoint (b
, commands
.get ());
1175 b
->commands
= std::move (commands
);
1176 observer_notify_breakpoint_modified (b
);
1179 /* Set the internal `silent' flag on the breakpoint. Note that this
1180 is not the same as the "silent" that may appear in the breakpoint's
1184 breakpoint_set_silent (struct breakpoint
*b
, int silent
)
1186 int old_silent
= b
->silent
;
1189 if (old_silent
!= silent
)
1190 observer_notify_breakpoint_modified (b
);
1193 /* Set the thread for this breakpoint. If THREAD is -1, make the
1194 breakpoint work for any thread. */
1197 breakpoint_set_thread (struct breakpoint
*b
, int thread
)
1199 int old_thread
= b
->thread
;
1202 if (old_thread
!= thread
)
1203 observer_notify_breakpoint_modified (b
);
1206 /* Set the task for this breakpoint. If TASK is 0, make the
1207 breakpoint work for any task. */
1210 breakpoint_set_task (struct breakpoint
*b
, int task
)
1212 int old_task
= b
->task
;
1215 if (old_task
!= task
)
1216 observer_notify_breakpoint_modified (b
);
1220 check_tracepoint_command (char *line
, void *closure
)
1222 struct breakpoint
*b
= (struct breakpoint
*) closure
;
1224 validate_actionline (line
, b
);
1228 commands_command_1 (const char *arg
, int from_tty
,
1229 struct command_line
*control
)
1231 counted_command_line cmd
;
1233 std::string new_arg
;
1235 if (arg
== NULL
|| !*arg
)
1237 if (breakpoint_count
- prev_breakpoint_count
> 1)
1238 new_arg
= string_printf ("%d-%d", prev_breakpoint_count
+ 1,
1240 else if (breakpoint_count
> 0)
1241 new_arg
= string_printf ("%d", breakpoint_count
);
1242 arg
= new_arg
.c_str ();
1245 map_breakpoint_numbers
1246 (arg
, [&] (breakpoint
*b
)
1250 if (control
!= NULL
)
1251 cmd
= copy_command_lines (control
->body_list
[0]);
1255 = string_printf (_("Type commands for breakpoint(s) "
1256 "%s, one per line."),
1259 cmd
= read_command_lines (&str
[0],
1262 ? check_tracepoint_command
: 0),
1267 /* If a breakpoint was on the list more than once, we don't need to
1269 if (b
->commands
!= cmd
)
1271 validate_commands_for_breakpoint (b
, cmd
.get ());
1273 observer_notify_breakpoint_modified (b
);
1278 error (_("No breakpoints specified."));
1282 commands_command (const char *arg
, int from_tty
)
1284 commands_command_1 (arg
, from_tty
, NULL
);
1287 /* Like commands_command, but instead of reading the commands from
1288 input stream, takes them from an already parsed command structure.
1290 This is used by cli-script.c to DTRT with breakpoint commands
1291 that are part of if and while bodies. */
1292 enum command_control_type
1293 commands_from_control_command (const char *arg
, struct command_line
*cmd
)
1295 commands_command_1 (arg
, 0, cmd
);
1296 return simple_control
;
1299 /* Return non-zero if BL->TARGET_INFO contains valid information. */
1302 bp_location_has_shadow (struct bp_location
*bl
)
1304 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
1308 if (bl
->target_info
.shadow_len
== 0)
1309 /* BL isn't valid, or doesn't shadow memory. */
1314 /* Update BUF, which is LEN bytes read from the target address
1315 MEMADDR, by replacing a memory breakpoint with its shadowed
1318 If READBUF is not NULL, this buffer must not overlap with the of
1319 the breakpoint location's shadow_contents buffer. Otherwise, a
1320 failed assertion internal error will be raised. */
1323 one_breakpoint_xfer_memory (gdb_byte
*readbuf
, gdb_byte
*writebuf
,
1324 const gdb_byte
*writebuf_org
,
1325 ULONGEST memaddr
, LONGEST len
,
1326 struct bp_target_info
*target_info
,
1327 struct gdbarch
*gdbarch
)
1329 /* Now do full processing of the found relevant range of elements. */
1330 CORE_ADDR bp_addr
= 0;
1334 if (!breakpoint_address_match (target_info
->placed_address_space
, 0,
1335 current_program_space
->aspace
, 0))
1337 /* The breakpoint is inserted in a different address space. */
1341 /* Addresses and length of the part of the breakpoint that
1343 bp_addr
= target_info
->placed_address
;
1344 bp_size
= target_info
->shadow_len
;
1346 if (bp_addr
+ bp_size
<= memaddr
)
1348 /* The breakpoint is entirely before the chunk of memory we are
1353 if (bp_addr
>= memaddr
+ len
)
1355 /* The breakpoint is entirely after the chunk of memory we are
1360 /* Offset within shadow_contents. */
1361 if (bp_addr
< memaddr
)
1363 /* Only copy the second part of the breakpoint. */
1364 bp_size
-= memaddr
- bp_addr
;
1365 bptoffset
= memaddr
- bp_addr
;
1369 if (bp_addr
+ bp_size
> memaddr
+ len
)
1371 /* Only copy the first part of the breakpoint. */
1372 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
1375 if (readbuf
!= NULL
)
1377 /* Verify that the readbuf buffer does not overlap with the
1378 shadow_contents buffer. */
1379 gdb_assert (target_info
->shadow_contents
>= readbuf
+ len
1380 || readbuf
>= (target_info
->shadow_contents
1381 + target_info
->shadow_len
));
1383 /* Update the read buffer with this inserted breakpoint's
1385 memcpy (readbuf
+ bp_addr
- memaddr
,
1386 target_info
->shadow_contents
+ bptoffset
, bp_size
);
1390 const unsigned char *bp
;
1391 CORE_ADDR addr
= target_info
->reqstd_address
;
1394 /* Update the shadow with what we want to write to memory. */
1395 memcpy (target_info
->shadow_contents
+ bptoffset
,
1396 writebuf_org
+ bp_addr
- memaddr
, bp_size
);
1398 /* Determine appropriate breakpoint contents and size for this
1400 bp
= gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &placed_size
);
1402 /* Update the final write buffer with this inserted
1403 breakpoint's INSN. */
1404 memcpy (writebuf
+ bp_addr
- memaddr
, bp
+ bptoffset
, bp_size
);
1408 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
1409 by replacing any memory breakpoints with their shadowed contents.
1411 If READBUF is not NULL, this buffer must not overlap with any of
1412 the breakpoint location's shadow_contents buffers. Otherwise,
1413 a failed assertion internal error will be raised.
1415 The range of shadowed area by each bp_location is:
1416 bl->address - bp_locations_placed_address_before_address_max
1417 up to bl->address + bp_locations_shadow_len_after_address_max
1418 The range we were requested to resolve shadows for is:
1419 memaddr ... memaddr + len
1420 Thus the safe cutoff boundaries for performance optimization are
1421 memaddr + len <= (bl->address
1422 - bp_locations_placed_address_before_address_max)
1424 bl->address + bp_locations_shadow_len_after_address_max <= memaddr */
1427 breakpoint_xfer_memory (gdb_byte
*readbuf
, gdb_byte
*writebuf
,
1428 const gdb_byte
*writebuf_org
,
1429 ULONGEST memaddr
, LONGEST len
)
1431 /* Left boundary, right boundary and median element of our binary
1433 unsigned bc_l
, bc_r
, bc
;
1435 /* Find BC_L which is a leftmost element which may affect BUF
1436 content. It is safe to report lower value but a failure to
1437 report higher one. */
1440 bc_r
= bp_locations_count
;
1441 while (bc_l
+ 1 < bc_r
)
1443 struct bp_location
*bl
;
1445 bc
= (bc_l
+ bc_r
) / 2;
1446 bl
= bp_locations
[bc
];
1448 /* Check first BL->ADDRESS will not overflow due to the added
1449 constant. Then advance the left boundary only if we are sure
1450 the BC element can in no way affect the BUF content (MEMADDR
1451 to MEMADDR + LEN range).
1453 Use the BP_LOCATIONS_SHADOW_LEN_AFTER_ADDRESS_MAX safety
1454 offset so that we cannot miss a breakpoint with its shadow
1455 range tail still reaching MEMADDR. */
1457 if ((bl
->address
+ bp_locations_shadow_len_after_address_max
1459 && (bl
->address
+ bp_locations_shadow_len_after_address_max
1466 /* Due to the binary search above, we need to make sure we pick the
1467 first location that's at BC_L's address. E.g., if there are
1468 multiple locations at the same address, BC_L may end up pointing
1469 at a duplicate location, and miss the "master"/"inserted"
1470 location. Say, given locations L1, L2 and L3 at addresses A and
1473 L1@A, L2@A, L3@B, ...
1475 BC_L could end up pointing at location L2, while the "master"
1476 location could be L1. Since the `loc->inserted' flag is only set
1477 on "master" locations, we'd forget to restore the shadow of L1
1480 && bp_locations
[bc_l
]->address
== bp_locations
[bc_l
- 1]->address
)
1483 /* Now do full processing of the found relevant range of elements. */
1485 for (bc
= bc_l
; bc
< bp_locations_count
; bc
++)
1487 struct bp_location
*bl
= bp_locations
[bc
];
1489 /* bp_location array has BL->OWNER always non-NULL. */
1490 if (bl
->owner
->type
== bp_none
)
1491 warning (_("reading through apparently deleted breakpoint #%d?"),
1494 /* Performance optimization: any further element can no longer affect BUF
1497 if (bl
->address
>= bp_locations_placed_address_before_address_max
1498 && memaddr
+ len
<= (bl
->address
1499 - bp_locations_placed_address_before_address_max
))
1502 if (!bp_location_has_shadow (bl
))
1505 one_breakpoint_xfer_memory (readbuf
, writebuf
, writebuf_org
,
1506 memaddr
, len
, &bl
->target_info
, bl
->gdbarch
);
1512 /* Return true if BPT is either a software breakpoint or a hardware
1516 is_breakpoint (const struct breakpoint
*bpt
)
1518 return (bpt
->type
== bp_breakpoint
1519 || bpt
->type
== bp_hardware_breakpoint
1520 || bpt
->type
== bp_dprintf
);
1523 /* Return true if BPT is of any hardware watchpoint kind. */
1526 is_hardware_watchpoint (const struct breakpoint
*bpt
)
1528 return (bpt
->type
== bp_hardware_watchpoint
1529 || bpt
->type
== bp_read_watchpoint
1530 || bpt
->type
== bp_access_watchpoint
);
1533 /* Return true if BPT is of any watchpoint kind, hardware or
1537 is_watchpoint (const struct breakpoint
*bpt
)
1539 return (is_hardware_watchpoint (bpt
)
1540 || bpt
->type
== bp_watchpoint
);
1543 /* Returns true if the current thread and its running state are safe
1544 to evaluate or update watchpoint B. Watchpoints on local
1545 expressions need to be evaluated in the context of the thread that
1546 was current when the watchpoint was created, and, that thread needs
1547 to be stopped to be able to select the correct frame context.
1548 Watchpoints on global expressions can be evaluated on any thread,
1549 and in any state. It is presently left to the target allowing
1550 memory accesses when threads are running. */
1553 watchpoint_in_thread_scope (struct watchpoint
*b
)
1555 return (b
->pspace
== current_program_space
1556 && (ptid_equal (b
->watchpoint_thread
, null_ptid
)
1557 || (ptid_equal (inferior_ptid
, b
->watchpoint_thread
)
1558 && !is_executing (inferior_ptid
))));
1561 /* Set watchpoint B to disp_del_at_next_stop, even including its possible
1562 associated bp_watchpoint_scope breakpoint. */
1565 watchpoint_del_at_next_stop (struct watchpoint
*w
)
1567 if (w
->related_breakpoint
!= w
)
1569 gdb_assert (w
->related_breakpoint
->type
== bp_watchpoint_scope
);
1570 gdb_assert (w
->related_breakpoint
->related_breakpoint
== w
);
1571 w
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
1572 w
->related_breakpoint
->related_breakpoint
= w
->related_breakpoint
;
1573 w
->related_breakpoint
= w
;
1575 w
->disposition
= disp_del_at_next_stop
;
1578 /* Extract a bitfield value from value VAL using the bit parameters contained in
1581 static struct value
*
1582 extract_bitfield_from_watchpoint_value (struct watchpoint
*w
, struct value
*val
)
1584 struct value
*bit_val
;
1589 bit_val
= allocate_value (value_type (val
));
1591 unpack_value_bitfield (bit_val
,
1594 value_contents_for_printing (val
),
1601 /* Allocate a dummy location and add it to B, which must be a software
1602 watchpoint. This is required because even if a software watchpoint
1603 is not watching any memory, bpstat_stop_status requires a location
1604 to be able to report stops. */
1607 software_watchpoint_add_no_memory_location (struct breakpoint
*b
,
1608 struct program_space
*pspace
)
1610 gdb_assert (b
->type
== bp_watchpoint
&& b
->loc
== NULL
);
1612 b
->loc
= allocate_bp_location (b
);
1613 b
->loc
->pspace
= pspace
;
1614 b
->loc
->address
= -1;
1615 b
->loc
->length
= -1;
1618 /* Returns true if B is a software watchpoint that is not watching any
1619 memory (e.g., "watch $pc"). */
1622 is_no_memory_software_watchpoint (struct breakpoint
*b
)
1624 return (b
->type
== bp_watchpoint
1626 && b
->loc
->next
== NULL
1627 && b
->loc
->address
== -1
1628 && b
->loc
->length
== -1);
1631 /* Assuming that B is a watchpoint:
1632 - Reparse watchpoint expression, if REPARSE is non-zero
1633 - Evaluate expression and store the result in B->val
1634 - Evaluate the condition if there is one, and store the result
1636 - Update the list of values that must be watched in B->loc.
1638 If the watchpoint disposition is disp_del_at_next_stop, then do
1639 nothing. If this is local watchpoint that is out of scope, delete
1642 Even with `set breakpoint always-inserted on' the watchpoints are
1643 removed + inserted on each stop here. Normal breakpoints must
1644 never be removed because they might be missed by a running thread
1645 when debugging in non-stop mode. On the other hand, hardware
1646 watchpoints (is_hardware_watchpoint; processed here) are specific
1647 to each LWP since they are stored in each LWP's hardware debug
1648 registers. Therefore, such LWP must be stopped first in order to
1649 be able to modify its hardware watchpoints.
1651 Hardware watchpoints must be reset exactly once after being
1652 presented to the user. It cannot be done sooner, because it would
1653 reset the data used to present the watchpoint hit to the user. And
1654 it must not be done later because it could display the same single
1655 watchpoint hit during multiple GDB stops. Note that the latter is
1656 relevant only to the hardware watchpoint types bp_read_watchpoint
1657 and bp_access_watchpoint. False hit by bp_hardware_watchpoint is
1658 not user-visible - its hit is suppressed if the memory content has
1661 The following constraints influence the location where we can reset
1662 hardware watchpoints:
1664 * target_stopped_by_watchpoint and target_stopped_data_address are
1665 called several times when GDB stops.
1668 * Multiple hardware watchpoints can be hit at the same time,
1669 causing GDB to stop. GDB only presents one hardware watchpoint
1670 hit at a time as the reason for stopping, and all the other hits
1671 are presented later, one after the other, each time the user
1672 requests the execution to be resumed. Execution is not resumed
1673 for the threads still having pending hit event stored in
1674 LWP_INFO->STATUS. While the watchpoint is already removed from
1675 the inferior on the first stop the thread hit event is kept being
1676 reported from its cached value by linux_nat_stopped_data_address
1677 until the real thread resume happens after the watchpoint gets
1678 presented and thus its LWP_INFO->STATUS gets reset.
1680 Therefore the hardware watchpoint hit can get safely reset on the
1681 watchpoint removal from inferior. */
1684 update_watchpoint (struct watchpoint
*b
, int reparse
)
1686 int within_current_scope
;
1687 struct frame_id saved_frame_id
;
1690 /* If this is a local watchpoint, we only want to check if the
1691 watchpoint frame is in scope if the current thread is the thread
1692 that was used to create the watchpoint. */
1693 if (!watchpoint_in_thread_scope (b
))
1696 if (b
->disposition
== disp_del_at_next_stop
)
1701 /* Determine if the watchpoint is within scope. */
1702 if (b
->exp_valid_block
== NULL
)
1703 within_current_scope
= 1;
1706 struct frame_info
*fi
= get_current_frame ();
1707 struct gdbarch
*frame_arch
= get_frame_arch (fi
);
1708 CORE_ADDR frame_pc
= get_frame_pc (fi
);
1710 /* If we're at a point where the stack has been destroyed
1711 (e.g. in a function epilogue), unwinding may not work
1712 properly. Do not attempt to recreate locations at this
1713 point. See similar comments in watchpoint_check. */
1714 if (gdbarch_stack_frame_destroyed_p (frame_arch
, frame_pc
))
1717 /* Save the current frame's ID so we can restore it after
1718 evaluating the watchpoint expression on its own frame. */
1719 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
1720 took a frame parameter, so that we didn't have to change the
1723 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
1725 fi
= frame_find_by_id (b
->watchpoint_frame
);
1726 within_current_scope
= (fi
!= NULL
);
1727 if (within_current_scope
)
1731 /* We don't free locations. They are stored in the bp_location array
1732 and update_global_location_list will eventually delete them and
1733 remove breakpoints if needed. */
1736 if (within_current_scope
&& reparse
)
1741 s
= b
->exp_string_reparse
? b
->exp_string_reparse
: b
->exp_string
;
1742 b
->exp
= parse_exp_1 (&s
, 0, b
->exp_valid_block
, 0);
1743 /* If the meaning of expression itself changed, the old value is
1744 no longer relevant. We don't want to report a watchpoint hit
1745 to the user when the old value and the new value may actually
1746 be completely different objects. */
1747 value_free (b
->val
);
1751 /* Note that unlike with breakpoints, the watchpoint's condition
1752 expression is stored in the breakpoint object, not in the
1753 locations (re)created below. */
1754 if (b
->cond_string
!= NULL
)
1756 b
->cond_exp
.reset ();
1759 b
->cond_exp
= parse_exp_1 (&s
, 0, b
->cond_exp_valid_block
, 0);
1763 /* If we failed to parse the expression, for example because
1764 it refers to a global variable in a not-yet-loaded shared library,
1765 don't try to insert watchpoint. We don't automatically delete
1766 such watchpoint, though, since failure to parse expression
1767 is different from out-of-scope watchpoint. */
1768 if (!target_has_execution
)
1770 /* Without execution, memory can't change. No use to try and
1771 set watchpoint locations. The watchpoint will be reset when
1772 the target gains execution, through breakpoint_re_set. */
1773 if (!can_use_hw_watchpoints
)
1775 if (b
->ops
->works_in_software_mode (b
))
1776 b
->type
= bp_watchpoint
;
1778 error (_("Can't set read/access watchpoint when "
1779 "hardware watchpoints are disabled."));
1782 else if (within_current_scope
&& b
->exp
)
1785 struct value
*val_chain
, *v
, *result
, *next
;
1786 struct program_space
*frame_pspace
;
1788 fetch_subexp_value (b
->exp
.get (), &pc
, &v
, &result
, &val_chain
, 0);
1790 /* Avoid setting b->val if it's already set. The meaning of
1791 b->val is 'the last value' user saw, and we should update
1792 it only if we reported that last value to user. As it
1793 happens, the code that reports it updates b->val directly.
1794 We don't keep track of the memory value for masked
1796 if (!b
->val_valid
&& !is_masked_watchpoint (b
))
1798 if (b
->val_bitsize
!= 0)
1800 v
= extract_bitfield_from_watchpoint_value (b
, v
);
1808 frame_pspace
= get_frame_program_space (get_selected_frame (NULL
));
1810 /* Look at each value on the value chain. */
1811 for (v
= val_chain
; v
; v
= value_next (v
))
1813 /* If it's a memory location, and GDB actually needed
1814 its contents to evaluate the expression, then we
1815 must watch it. If the first value returned is
1816 still lazy, that means an error occurred reading it;
1817 watch it anyway in case it becomes readable. */
1818 if (VALUE_LVAL (v
) == lval_memory
1819 && (v
== val_chain
|| ! value_lazy (v
)))
1821 struct type
*vtype
= check_typedef (value_type (v
));
1823 /* We only watch structs and arrays if user asked
1824 for it explicitly, never if they just happen to
1825 appear in the middle of some value chain. */
1827 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
1828 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
1831 enum target_hw_bp_type type
;
1832 struct bp_location
*loc
, **tmp
;
1833 int bitpos
= 0, bitsize
= 0;
1835 if (value_bitsize (v
) != 0)
1837 /* Extract the bit parameters out from the bitfield
1839 bitpos
= value_bitpos (v
);
1840 bitsize
= value_bitsize (v
);
1842 else if (v
== result
&& b
->val_bitsize
!= 0)
1844 /* If VAL_BITSIZE != 0 then RESULT is actually a bitfield
1845 lvalue whose bit parameters are saved in the fields
1846 VAL_BITPOS and VAL_BITSIZE. */
1847 bitpos
= b
->val_bitpos
;
1848 bitsize
= b
->val_bitsize
;
1851 addr
= value_address (v
);
1854 /* Skip the bytes that don't contain the bitfield. */
1859 if (b
->type
== bp_read_watchpoint
)
1861 else if (b
->type
== bp_access_watchpoint
)
1864 loc
= allocate_bp_location (b
);
1865 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
1868 loc
->gdbarch
= get_type_arch (value_type (v
));
1870 loc
->pspace
= frame_pspace
;
1871 loc
->address
= addr
;
1875 /* Just cover the bytes that make up the bitfield. */
1876 loc
->length
= ((bitpos
% 8) + bitsize
+ 7) / 8;
1879 loc
->length
= TYPE_LENGTH (value_type (v
));
1881 loc
->watchpoint_type
= type
;
1886 /* Change the type of breakpoint between hardware assisted or
1887 an ordinary watchpoint depending on the hardware support
1888 and free hardware slots. REPARSE is set when the inferior
1893 enum bp_loc_type loc_type
;
1894 struct bp_location
*bl
;
1896 reg_cnt
= can_use_hardware_watchpoint (val_chain
);
1900 int i
, target_resources_ok
, other_type_used
;
1903 /* Use an exact watchpoint when there's only one memory region to be
1904 watched, and only one debug register is needed to watch it. */
1905 b
->exact
= target_exact_watchpoints
&& reg_cnt
== 1;
1907 /* We need to determine how many resources are already
1908 used for all other hardware watchpoints plus this one
1909 to see if we still have enough resources to also fit
1910 this watchpoint in as well. */
1912 /* If this is a software watchpoint, we try to turn it
1913 to a hardware one -- count resources as if B was of
1914 hardware watchpoint type. */
1916 if (type
== bp_watchpoint
)
1917 type
= bp_hardware_watchpoint
;
1919 /* This watchpoint may or may not have been placed on
1920 the list yet at this point (it won't be in the list
1921 if we're trying to create it for the first time,
1922 through watch_command), so always account for it
1925 /* Count resources used by all watchpoints except B. */
1926 i
= hw_watchpoint_used_count_others (b
, type
, &other_type_used
);
1928 /* Add in the resources needed for B. */
1929 i
+= hw_watchpoint_use_count (b
);
1932 = target_can_use_hardware_watchpoint (type
, i
, other_type_used
);
1933 if (target_resources_ok
<= 0)
1935 int sw_mode
= b
->ops
->works_in_software_mode (b
);
1937 if (target_resources_ok
== 0 && !sw_mode
)
1938 error (_("Target does not support this type of "
1939 "hardware watchpoint."));
1940 else if (target_resources_ok
< 0 && !sw_mode
)
1941 error (_("There are not enough available hardware "
1942 "resources for this watchpoint."));
1944 /* Downgrade to software watchpoint. */
1945 b
->type
= bp_watchpoint
;
1949 /* If this was a software watchpoint, we've just
1950 found we have enough resources to turn it to a
1951 hardware watchpoint. Otherwise, this is a
1956 else if (!b
->ops
->works_in_software_mode (b
))
1958 if (!can_use_hw_watchpoints
)
1959 error (_("Can't set read/access watchpoint when "
1960 "hardware watchpoints are disabled."));
1962 error (_("Expression cannot be implemented with "
1963 "read/access watchpoint."));
1966 b
->type
= bp_watchpoint
;
1968 loc_type
= (b
->type
== bp_watchpoint
? bp_loc_other
1969 : bp_loc_hardware_watchpoint
);
1970 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
1971 bl
->loc_type
= loc_type
;
1974 for (v
= val_chain
; v
; v
= next
)
1976 next
= value_next (v
);
1981 /* If a software watchpoint is not watching any memory, then the
1982 above left it without any location set up. But,
1983 bpstat_stop_status requires a location to be able to report
1984 stops, so make sure there's at least a dummy one. */
1985 if (b
->type
== bp_watchpoint
&& b
->loc
== NULL
)
1986 software_watchpoint_add_no_memory_location (b
, frame_pspace
);
1988 else if (!within_current_scope
)
1990 printf_filtered (_("\
1991 Watchpoint %d deleted because the program has left the block\n\
1992 in which its expression is valid.\n"),
1994 watchpoint_del_at_next_stop (b
);
1997 /* Restore the selected frame. */
1999 select_frame (frame_find_by_id (saved_frame_id
));
2003 /* Returns 1 iff breakpoint location should be
2004 inserted in the inferior. We don't differentiate the type of BL's owner
2005 (breakpoint vs. tracepoint), although insert_location in tracepoint's
2006 breakpoint_ops is not defined, because in insert_bp_location,
2007 tracepoint's insert_location will not be called. */
2009 should_be_inserted (struct bp_location
*bl
)
2011 if (bl
->owner
== NULL
|| !breakpoint_enabled (bl
->owner
))
2014 if (bl
->owner
->disposition
== disp_del_at_next_stop
)
2017 if (!bl
->enabled
|| bl
->shlib_disabled
|| bl
->duplicate
)
2020 if (user_breakpoint_p (bl
->owner
) && bl
->pspace
->executing_startup
)
2023 /* This is set for example, when we're attached to the parent of a
2024 vfork, and have detached from the child. The child is running
2025 free, and we expect it to do an exec or exit, at which point the
2026 OS makes the parent schedulable again (and the target reports
2027 that the vfork is done). Until the child is done with the shared
2028 memory region, do not insert breakpoints in the parent, otherwise
2029 the child could still trip on the parent's breakpoints. Since
2030 the parent is blocked anyway, it won't miss any breakpoint. */
2031 if (bl
->pspace
->breakpoints_not_allowed
)
2034 /* Don't insert a breakpoint if we're trying to step past its
2035 location, except if the breakpoint is a single-step breakpoint,
2036 and the breakpoint's thread is the thread which is stepping past
2038 if ((bl
->loc_type
== bp_loc_software_breakpoint
2039 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
2040 && stepping_past_instruction_at (bl
->pspace
->aspace
,
2042 /* The single-step breakpoint may be inserted at the location
2043 we're trying to step if the instruction branches to itself.
2044 However, the instruction won't be executed at all and it may
2045 break the semantics of the instruction, for example, the
2046 instruction is a conditional branch or updates some flags.
2047 We can't fix it unless GDB is able to emulate the instruction
2048 or switch to displaced stepping. */
2049 && !(bl
->owner
->type
== bp_single_step
2050 && thread_is_stepping_over_breakpoint (bl
->owner
->thread
)))
2054 fprintf_unfiltered (gdb_stdlog
,
2055 "infrun: skipping breakpoint: "
2056 "stepping past insn at: %s\n",
2057 paddress (bl
->gdbarch
, bl
->address
));
2062 /* Don't insert watchpoints if we're trying to step past the
2063 instruction that triggered one. */
2064 if ((bl
->loc_type
== bp_loc_hardware_watchpoint
)
2065 && stepping_past_nonsteppable_watchpoint ())
2069 fprintf_unfiltered (gdb_stdlog
,
2070 "infrun: stepping past non-steppable watchpoint. "
2071 "skipping watchpoint at %s:%d\n",
2072 paddress (bl
->gdbarch
, bl
->address
),
2081 /* Same as should_be_inserted but does the check assuming
2082 that the location is not duplicated. */
2085 unduplicated_should_be_inserted (struct bp_location
*bl
)
2088 const int save_duplicate
= bl
->duplicate
;
2091 result
= should_be_inserted (bl
);
2092 bl
->duplicate
= save_duplicate
;
2096 /* Parses a conditional described by an expression COND into an
2097 agent expression bytecode suitable for evaluation
2098 by the bytecode interpreter. Return NULL if there was
2099 any error during parsing. */
2101 static agent_expr_up
2102 parse_cond_to_aexpr (CORE_ADDR scope
, struct expression
*cond
)
2107 agent_expr_up aexpr
;
2109 /* We don't want to stop processing, so catch any errors
2110 that may show up. */
2113 aexpr
= gen_eval_for_expr (scope
, cond
);
2116 CATCH (ex
, RETURN_MASK_ERROR
)
2118 /* If we got here, it means the condition could not be parsed to a valid
2119 bytecode expression and thus can't be evaluated on the target's side.
2120 It's no use iterating through the conditions. */
2124 /* We have a valid agent expression. */
2128 /* Based on location BL, create a list of breakpoint conditions to be
2129 passed on to the target. If we have duplicated locations with different
2130 conditions, we will add such conditions to the list. The idea is that the
2131 target will evaluate the list of conditions and will only notify GDB when
2132 one of them is true. */
2135 build_target_condition_list (struct bp_location
*bl
)
2137 struct bp_location
**locp
= NULL
, **loc2p
;
2138 int null_condition_or_parse_error
= 0;
2139 int modified
= bl
->needs_update
;
2140 struct bp_location
*loc
;
2142 /* Release conditions left over from a previous insert. */
2143 bl
->target_info
.conditions
.clear ();
2145 /* This is only meaningful if the target is
2146 evaluating conditions and if the user has
2147 opted for condition evaluation on the target's
2149 if (gdb_evaluates_breakpoint_condition_p ()
2150 || !target_supports_evaluation_of_breakpoint_conditions ())
2153 /* Do a first pass to check for locations with no assigned
2154 conditions or conditions that fail to parse to a valid agent expression
2155 bytecode. If any of these happen, then it's no use to send conditions
2156 to the target since this location will always trigger and generate a
2157 response back to GDB. */
2158 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2161 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2165 /* Re-parse the conditions since something changed. In that
2166 case we already freed the condition bytecodes (see
2167 force_breakpoint_reinsertion). We just
2168 need to parse the condition to bytecodes again. */
2169 loc
->cond_bytecode
= parse_cond_to_aexpr (bl
->address
,
2173 /* If we have a NULL bytecode expression, it means something
2174 went wrong or we have a null condition expression. */
2175 if (!loc
->cond_bytecode
)
2177 null_condition_or_parse_error
= 1;
2183 /* If any of these happened, it means we will have to evaluate the conditions
2184 for the location's address on gdb's side. It is no use keeping bytecodes
2185 for all the other duplicate locations, thus we free all of them here.
2187 This is so we have a finer control over which locations' conditions are
2188 being evaluated by GDB or the remote stub. */
2189 if (null_condition_or_parse_error
)
2191 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2194 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2196 /* Only go as far as the first NULL bytecode is
2198 if (!loc
->cond_bytecode
)
2201 loc
->cond_bytecode
.reset ();
2206 /* No NULL conditions or failed bytecode generation. Build a condition list
2207 for this location's address. */
2208 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2212 && is_breakpoint (loc
->owner
)
2213 && loc
->pspace
->num
== bl
->pspace
->num
2214 && loc
->owner
->enable_state
== bp_enabled
2217 /* Add the condition to the vector. This will be used later
2218 to send the conditions to the target. */
2219 bl
->target_info
.conditions
.push_back (loc
->cond_bytecode
.get ());
2226 /* Parses a command described by string CMD into an agent expression
2227 bytecode suitable for evaluation by the bytecode interpreter.
2228 Return NULL if there was any error during parsing. */
2230 static agent_expr_up
2231 parse_cmd_to_aexpr (CORE_ADDR scope
, char *cmd
)
2233 struct cleanup
*old_cleanups
= 0;
2234 struct expression
**argvec
;
2235 const char *cmdrest
;
2236 const char *format_start
, *format_end
;
2237 struct format_piece
*fpieces
;
2239 struct gdbarch
*gdbarch
= get_current_arch ();
2246 if (*cmdrest
== ',')
2248 cmdrest
= skip_spaces (cmdrest
);
2250 if (*cmdrest
++ != '"')
2251 error (_("No format string following the location"));
2253 format_start
= cmdrest
;
2255 fpieces
= parse_format_string (&cmdrest
);
2257 old_cleanups
= make_cleanup (free_format_pieces_cleanup
, &fpieces
);
2259 format_end
= cmdrest
;
2261 if (*cmdrest
++ != '"')
2262 error (_("Bad format string, non-terminated '\"'."));
2264 cmdrest
= skip_spaces (cmdrest
);
2266 if (!(*cmdrest
== ',' || *cmdrest
== '\0'))
2267 error (_("Invalid argument syntax"));
2269 if (*cmdrest
== ',')
2271 cmdrest
= skip_spaces (cmdrest
);
2273 /* For each argument, make an expression. */
2275 argvec
= (struct expression
**) alloca (strlen (cmd
)
2276 * sizeof (struct expression
*));
2279 while (*cmdrest
!= '\0')
2284 expression_up expr
= parse_exp_1 (&cmd1
, scope
, block_for_pc (scope
), 1);
2285 argvec
[nargs
++] = expr
.release ();
2287 if (*cmdrest
== ',')
2291 agent_expr_up aexpr
;
2293 /* We don't want to stop processing, so catch any errors
2294 that may show up. */
2297 aexpr
= gen_printf (scope
, gdbarch
, 0, 0,
2298 format_start
, format_end
- format_start
,
2299 fpieces
, nargs
, argvec
);
2301 CATCH (ex
, RETURN_MASK_ERROR
)
2303 /* If we got here, it means the command could not be parsed to a valid
2304 bytecode expression and thus can't be evaluated on the target's side.
2305 It's no use iterating through the other commands. */
2309 do_cleanups (old_cleanups
);
2311 /* We have a valid agent expression, return it. */
2315 /* Based on location BL, create a list of breakpoint commands to be
2316 passed on to the target. If we have duplicated locations with
2317 different commands, we will add any such to the list. */
2320 build_target_command_list (struct bp_location
*bl
)
2322 struct bp_location
**locp
= NULL
, **loc2p
;
2323 int null_command_or_parse_error
= 0;
2324 int modified
= bl
->needs_update
;
2325 struct bp_location
*loc
;
2327 /* Clear commands left over from a previous insert. */
2328 bl
->target_info
.tcommands
.clear ();
2330 if (!target_can_run_breakpoint_commands ())
2333 /* For now, limit to agent-style dprintf breakpoints. */
2334 if (dprintf_style
!= dprintf_style_agent
)
2337 /* For now, if we have any duplicate location that isn't a dprintf,
2338 don't install the target-side commands, as that would make the
2339 breakpoint not be reported to the core, and we'd lose
2341 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2344 if (is_breakpoint (loc
->owner
)
2345 && loc
->pspace
->num
== bl
->pspace
->num
2346 && loc
->owner
->type
!= bp_dprintf
)
2350 /* Do a first pass to check for locations with no assigned
2351 conditions or conditions that fail to parse to a valid agent expression
2352 bytecode. If any of these happen, then it's no use to send conditions
2353 to the target since this location will always trigger and generate a
2354 response back to GDB. */
2355 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2358 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2362 /* Re-parse the commands since something changed. In that
2363 case we already freed the command bytecodes (see
2364 force_breakpoint_reinsertion). We just
2365 need to parse the command to bytecodes again. */
2367 = parse_cmd_to_aexpr (bl
->address
,
2368 loc
->owner
->extra_string
);
2371 /* If we have a NULL bytecode expression, it means something
2372 went wrong or we have a null command expression. */
2373 if (!loc
->cmd_bytecode
)
2375 null_command_or_parse_error
= 1;
2381 /* If anything failed, then we're not doing target-side commands,
2383 if (null_command_or_parse_error
)
2385 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2388 if (is_breakpoint (loc
->owner
)
2389 && loc
->pspace
->num
== bl
->pspace
->num
)
2391 /* Only go as far as the first NULL bytecode is
2393 if (loc
->cmd_bytecode
== NULL
)
2396 loc
->cmd_bytecode
.reset ();
2401 /* No NULL commands or failed bytecode generation. Build a command list
2402 for this location's address. */
2403 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2406 if (loc
->owner
->extra_string
2407 && is_breakpoint (loc
->owner
)
2408 && loc
->pspace
->num
== bl
->pspace
->num
2409 && loc
->owner
->enable_state
== bp_enabled
2412 /* Add the command to the vector. This will be used later
2413 to send the commands to the target. */
2414 bl
->target_info
.tcommands
.push_back (loc
->cmd_bytecode
.get ());
2418 bl
->target_info
.persist
= 0;
2419 /* Maybe flag this location as persistent. */
2420 if (bl
->owner
->type
== bp_dprintf
&& disconnected_dprintf
)
2421 bl
->target_info
.persist
= 1;
2424 /* Return the kind of breakpoint on address *ADDR. Get the kind
2425 of breakpoint according to ADDR except single-step breakpoint.
2426 Get the kind of single-step breakpoint according to the current
2430 breakpoint_kind (struct bp_location
*bl
, CORE_ADDR
*addr
)
2432 if (bl
->owner
->type
== bp_single_step
)
2434 struct thread_info
*thr
= find_thread_global_id (bl
->owner
->thread
);
2435 struct regcache
*regcache
;
2437 regcache
= get_thread_regcache (thr
->ptid
);
2439 return gdbarch_breakpoint_kind_from_current_state (bl
->gdbarch
,
2443 return gdbarch_breakpoint_kind_from_pc (bl
->gdbarch
, addr
);
2446 /* Insert a low-level "breakpoint" of some type. BL is the breakpoint
2447 location. Any error messages are printed to TMP_ERROR_STREAM; and
2448 DISABLED_BREAKS, and HW_BREAKPOINT_ERROR are used to report problems.
2449 Returns 0 for success, 1 if the bp_location type is not supported or
2452 NOTE drow/2003-09-09: This routine could be broken down to an
2453 object-style method for each breakpoint or catchpoint type. */
2455 insert_bp_location (struct bp_location
*bl
,
2456 struct ui_file
*tmp_error_stream
,
2457 int *disabled_breaks
,
2458 int *hw_breakpoint_error
,
2459 int *hw_bp_error_explained_already
)
2461 gdb_exception bp_excpt
= exception_none
;
2463 if (!should_be_inserted (bl
) || (bl
->inserted
&& !bl
->needs_update
))
2466 /* Note we don't initialize bl->target_info, as that wipes out
2467 the breakpoint location's shadow_contents if the breakpoint
2468 is still inserted at that location. This in turn breaks
2469 target_read_memory which depends on these buffers when
2470 a memory read is requested at the breakpoint location:
2471 Once the target_info has been wiped, we fail to see that
2472 we have a breakpoint inserted at that address and thus
2473 read the breakpoint instead of returning the data saved in
2474 the breakpoint location's shadow contents. */
2475 bl
->target_info
.reqstd_address
= bl
->address
;
2476 bl
->target_info
.placed_address_space
= bl
->pspace
->aspace
;
2477 bl
->target_info
.length
= bl
->length
;
2479 /* When working with target-side conditions, we must pass all the conditions
2480 for the same breakpoint address down to the target since GDB will not
2481 insert those locations. With a list of breakpoint conditions, the target
2482 can decide when to stop and notify GDB. */
2484 if (is_breakpoint (bl
->owner
))
2486 build_target_condition_list (bl
);
2487 build_target_command_list (bl
);
2488 /* Reset the modification marker. */
2489 bl
->needs_update
= 0;
2492 if (bl
->loc_type
== bp_loc_software_breakpoint
2493 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
2495 if (bl
->owner
->type
!= bp_hardware_breakpoint
)
2497 /* If the explicitly specified breakpoint type
2498 is not hardware breakpoint, check the memory map to see
2499 if the breakpoint address is in read only memory or not.
2501 Two important cases are:
2502 - location type is not hardware breakpoint, memory
2503 is readonly. We change the type of the location to
2504 hardware breakpoint.
2505 - location type is hardware breakpoint, memory is
2506 read-write. This means we've previously made the
2507 location hardware one, but then the memory map changed,
2510 When breakpoints are removed, remove_breakpoints will use
2511 location types we've just set here, the only possible
2512 problem is that memory map has changed during running
2513 program, but it's not going to work anyway with current
2515 struct mem_region
*mr
2516 = lookup_mem_region (bl
->target_info
.reqstd_address
);
2520 if (automatic_hardware_breakpoints
)
2522 enum bp_loc_type new_type
;
2524 if (mr
->attrib
.mode
!= MEM_RW
)
2525 new_type
= bp_loc_hardware_breakpoint
;
2527 new_type
= bp_loc_software_breakpoint
;
2529 if (new_type
!= bl
->loc_type
)
2531 static int said
= 0;
2533 bl
->loc_type
= new_type
;
2536 fprintf_filtered (gdb_stdout
,
2537 _("Note: automatically using "
2538 "hardware breakpoints for "
2539 "read-only addresses.\n"));
2544 else if (bl
->loc_type
== bp_loc_software_breakpoint
2545 && mr
->attrib
.mode
!= MEM_RW
)
2547 fprintf_unfiltered (tmp_error_stream
,
2548 _("Cannot insert breakpoint %d.\n"
2549 "Cannot set software breakpoint "
2550 "at read-only address %s\n"),
2552 paddress (bl
->gdbarch
, bl
->address
));
2558 /* First check to see if we have to handle an overlay. */
2559 if (overlay_debugging
== ovly_off
2560 || bl
->section
== NULL
2561 || !(section_is_overlay (bl
->section
)))
2563 /* No overlay handling: just set the breakpoint. */
2568 val
= bl
->owner
->ops
->insert_location (bl
);
2570 bp_excpt
= gdb_exception
{RETURN_ERROR
, GENERIC_ERROR
};
2572 CATCH (e
, RETURN_MASK_ALL
)
2580 /* This breakpoint is in an overlay section.
2581 Shall we set a breakpoint at the LMA? */
2582 if (!overlay_events_enabled
)
2584 /* Yes -- overlay event support is not active,
2585 so we must try to set a breakpoint at the LMA.
2586 This will not work for a hardware breakpoint. */
2587 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
2588 warning (_("hardware breakpoint %d not supported in overlay!"),
2592 CORE_ADDR addr
= overlay_unmapped_address (bl
->address
,
2594 /* Set a software (trap) breakpoint at the LMA. */
2595 bl
->overlay_target_info
= bl
->target_info
;
2596 bl
->overlay_target_info
.reqstd_address
= addr
;
2598 /* No overlay handling: just set the breakpoint. */
2603 bl
->overlay_target_info
.kind
2604 = breakpoint_kind (bl
, &addr
);
2605 bl
->overlay_target_info
.placed_address
= addr
;
2606 val
= target_insert_breakpoint (bl
->gdbarch
,
2607 &bl
->overlay_target_info
);
2610 = gdb_exception
{RETURN_ERROR
, GENERIC_ERROR
};
2612 CATCH (e
, RETURN_MASK_ALL
)
2618 if (bp_excpt
.reason
!= 0)
2619 fprintf_unfiltered (tmp_error_stream
,
2620 "Overlay breakpoint %d "
2621 "failed: in ROM?\n",
2625 /* Shall we set a breakpoint at the VMA? */
2626 if (section_is_mapped (bl
->section
))
2628 /* Yes. This overlay section is mapped into memory. */
2633 val
= bl
->owner
->ops
->insert_location (bl
);
2635 bp_excpt
= gdb_exception
{RETURN_ERROR
, GENERIC_ERROR
};
2637 CATCH (e
, RETURN_MASK_ALL
)
2645 /* No. This breakpoint will not be inserted.
2646 No error, but do not mark the bp as 'inserted'. */
2651 if (bp_excpt
.reason
!= 0)
2653 /* Can't set the breakpoint. */
2655 /* In some cases, we might not be able to insert a
2656 breakpoint in a shared library that has already been
2657 removed, but we have not yet processed the shlib unload
2658 event. Unfortunately, some targets that implement
2659 breakpoint insertion themselves can't tell why the
2660 breakpoint insertion failed (e.g., the remote target
2661 doesn't define error codes), so we must treat generic
2662 errors as memory errors. */
2663 if (bp_excpt
.reason
== RETURN_ERROR
2664 && (bp_excpt
.error
== GENERIC_ERROR
2665 || bp_excpt
.error
== MEMORY_ERROR
)
2666 && bl
->loc_type
== bp_loc_software_breakpoint
2667 && (solib_name_from_address (bl
->pspace
, bl
->address
)
2668 || shared_objfile_contains_address_p (bl
->pspace
,
2671 /* See also: disable_breakpoints_in_shlibs. */
2672 bl
->shlib_disabled
= 1;
2673 observer_notify_breakpoint_modified (bl
->owner
);
2674 if (!*disabled_breaks
)
2676 fprintf_unfiltered (tmp_error_stream
,
2677 "Cannot insert breakpoint %d.\n",
2679 fprintf_unfiltered (tmp_error_stream
,
2680 "Temporarily disabling shared "
2681 "library breakpoints:\n");
2683 *disabled_breaks
= 1;
2684 fprintf_unfiltered (tmp_error_stream
,
2685 "breakpoint #%d\n", bl
->owner
->number
);
2690 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
2692 *hw_breakpoint_error
= 1;
2693 *hw_bp_error_explained_already
= bp_excpt
.message
!= NULL
;
2694 fprintf_unfiltered (tmp_error_stream
,
2695 "Cannot insert hardware breakpoint %d%s",
2697 bp_excpt
.message
? ":" : ".\n");
2698 if (bp_excpt
.message
!= NULL
)
2699 fprintf_unfiltered (tmp_error_stream
, "%s.\n",
2704 if (bp_excpt
.message
== NULL
)
2707 = memory_error_message (TARGET_XFER_E_IO
,
2708 bl
->gdbarch
, bl
->address
);
2710 fprintf_unfiltered (tmp_error_stream
,
2711 "Cannot insert breakpoint %d.\n"
2713 bl
->owner
->number
, message
.c_str ());
2717 fprintf_unfiltered (tmp_error_stream
,
2718 "Cannot insert breakpoint %d: %s\n",
2733 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
2734 /* NOTE drow/2003-09-08: This state only exists for removing
2735 watchpoints. It's not clear that it's necessary... */
2736 && bl
->owner
->disposition
!= disp_del_at_next_stop
)
2740 gdb_assert (bl
->owner
->ops
!= NULL
2741 && bl
->owner
->ops
->insert_location
!= NULL
);
2743 val
= bl
->owner
->ops
->insert_location (bl
);
2745 /* If trying to set a read-watchpoint, and it turns out it's not
2746 supported, try emulating one with an access watchpoint. */
2747 if (val
== 1 && bl
->watchpoint_type
== hw_read
)
2749 struct bp_location
*loc
, **loc_temp
;
2751 /* But don't try to insert it, if there's already another
2752 hw_access location that would be considered a duplicate
2754 ALL_BP_LOCATIONS (loc
, loc_temp
)
2756 && loc
->watchpoint_type
== hw_access
2757 && watchpoint_locations_match (bl
, loc
))
2761 bl
->target_info
= loc
->target_info
;
2762 bl
->watchpoint_type
= hw_access
;
2769 bl
->watchpoint_type
= hw_access
;
2770 val
= bl
->owner
->ops
->insert_location (bl
);
2773 /* Back to the original value. */
2774 bl
->watchpoint_type
= hw_read
;
2778 bl
->inserted
= (val
== 0);
2781 else if (bl
->owner
->type
== bp_catchpoint
)
2785 gdb_assert (bl
->owner
->ops
!= NULL
2786 && bl
->owner
->ops
->insert_location
!= NULL
);
2788 val
= bl
->owner
->ops
->insert_location (bl
);
2791 bl
->owner
->enable_state
= bp_disabled
;
2795 Error inserting catchpoint %d: Your system does not support this type\n\
2796 of catchpoint."), bl
->owner
->number
);
2798 warning (_("Error inserting catchpoint %d."), bl
->owner
->number
);
2801 bl
->inserted
= (val
== 0);
2803 /* We've already printed an error message if there was a problem
2804 inserting this catchpoint, and we've disabled the catchpoint,
2805 so just return success. */
2812 /* This function is called when program space PSPACE is about to be
2813 deleted. It takes care of updating breakpoints to not reference
2817 breakpoint_program_space_exit (struct program_space
*pspace
)
2819 struct breakpoint
*b
, *b_temp
;
2820 struct bp_location
*loc
, **loc_temp
;
2822 /* Remove any breakpoint that was set through this program space. */
2823 ALL_BREAKPOINTS_SAFE (b
, b_temp
)
2825 if (b
->pspace
== pspace
)
2826 delete_breakpoint (b
);
2829 /* Breakpoints set through other program spaces could have locations
2830 bound to PSPACE as well. Remove those. */
2831 ALL_BP_LOCATIONS (loc
, loc_temp
)
2833 struct bp_location
*tmp
;
2835 if (loc
->pspace
== pspace
)
2837 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
2838 if (loc
->owner
->loc
== loc
)
2839 loc
->owner
->loc
= loc
->next
;
2841 for (tmp
= loc
->owner
->loc
; tmp
->next
!= NULL
; tmp
= tmp
->next
)
2842 if (tmp
->next
== loc
)
2844 tmp
->next
= loc
->next
;
2850 /* Now update the global location list to permanently delete the
2851 removed locations above. */
2852 update_global_location_list (UGLL_DONT_INSERT
);
2855 /* Make sure all breakpoints are inserted in inferior.
2856 Throws exception on any error.
2857 A breakpoint that is already inserted won't be inserted
2858 again, so calling this function twice is safe. */
2860 insert_breakpoints (void)
2862 struct breakpoint
*bpt
;
2864 ALL_BREAKPOINTS (bpt
)
2865 if (is_hardware_watchpoint (bpt
))
2867 struct watchpoint
*w
= (struct watchpoint
*) bpt
;
2869 update_watchpoint (w
, 0 /* don't reparse. */);
2872 /* Updating watchpoints creates new locations, so update the global
2873 location list. Explicitly tell ugll to insert locations and
2874 ignore breakpoints_always_inserted_mode. */
2875 update_global_location_list (UGLL_INSERT
);
2878 /* Invoke CALLBACK for each of bp_location. */
2881 iterate_over_bp_locations (walk_bp_location_callback callback
)
2883 struct bp_location
*loc
, **loc_tmp
;
2885 ALL_BP_LOCATIONS (loc
, loc_tmp
)
2887 callback (loc
, NULL
);
2891 /* This is used when we need to synch breakpoint conditions between GDB and the
2892 target. It is the case with deleting and disabling of breakpoints when using
2893 always-inserted mode. */
2896 update_inserted_breakpoint_locations (void)
2898 struct bp_location
*bl
, **blp_tmp
;
2901 int disabled_breaks
= 0;
2902 int hw_breakpoint_error
= 0;
2903 int hw_bp_details_reported
= 0;
2905 string_file tmp_error_stream
;
2907 /* Explicitly mark the warning -- this will only be printed if
2908 there was an error. */
2909 tmp_error_stream
.puts ("Warning:\n");
2911 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
2913 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2915 /* We only want to update software breakpoints and hardware
2917 if (!is_breakpoint (bl
->owner
))
2920 /* We only want to update locations that are already inserted
2921 and need updating. This is to avoid unwanted insertion during
2922 deletion of breakpoints. */
2923 if (!bl
->inserted
|| (bl
->inserted
&& !bl
->needs_update
))
2926 switch_to_program_space_and_thread (bl
->pspace
);
2928 /* For targets that support global breakpoints, there's no need
2929 to select an inferior to insert breakpoint to. In fact, even
2930 if we aren't attached to any process yet, we should still
2931 insert breakpoints. */
2932 if (!gdbarch_has_global_breakpoints (target_gdbarch ())
2933 && ptid_equal (inferior_ptid
, null_ptid
))
2936 val
= insert_bp_location (bl
, &tmp_error_stream
, &disabled_breaks
,
2937 &hw_breakpoint_error
, &hw_bp_details_reported
);
2944 target_terminal::ours_for_output ();
2945 error_stream (tmp_error_stream
);
2949 /* Used when starting or continuing the program. */
2952 insert_breakpoint_locations (void)
2954 struct breakpoint
*bpt
;
2955 struct bp_location
*bl
, **blp_tmp
;
2958 int disabled_breaks
= 0;
2959 int hw_breakpoint_error
= 0;
2960 int hw_bp_error_explained_already
= 0;
2962 string_file tmp_error_stream
;
2964 /* Explicitly mark the warning -- this will only be printed if
2965 there was an error. */
2966 tmp_error_stream
.puts ("Warning:\n");
2968 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
2970 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2972 if (!should_be_inserted (bl
) || (bl
->inserted
&& !bl
->needs_update
))
2975 /* There is no point inserting thread-specific breakpoints if
2976 the thread no longer exists. ALL_BP_LOCATIONS bp_location
2977 has BL->OWNER always non-NULL. */
2978 if (bl
->owner
->thread
!= -1
2979 && !valid_global_thread_id (bl
->owner
->thread
))
2982 switch_to_program_space_and_thread (bl
->pspace
);
2984 /* For targets that support global breakpoints, there's no need
2985 to select an inferior to insert breakpoint to. In fact, even
2986 if we aren't attached to any process yet, we should still
2987 insert breakpoints. */
2988 if (!gdbarch_has_global_breakpoints (target_gdbarch ())
2989 && ptid_equal (inferior_ptid
, null_ptid
))
2992 val
= insert_bp_location (bl
, &tmp_error_stream
, &disabled_breaks
,
2993 &hw_breakpoint_error
, &hw_bp_error_explained_already
);
2998 /* If we failed to insert all locations of a watchpoint, remove
2999 them, as half-inserted watchpoint is of limited use. */
3000 ALL_BREAKPOINTS (bpt
)
3002 int some_failed
= 0;
3003 struct bp_location
*loc
;
3005 if (!is_hardware_watchpoint (bpt
))
3008 if (!breakpoint_enabled (bpt
))
3011 if (bpt
->disposition
== disp_del_at_next_stop
)
3014 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
3015 if (!loc
->inserted
&& should_be_inserted (loc
))
3022 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
3024 remove_breakpoint (loc
);
3026 hw_breakpoint_error
= 1;
3027 tmp_error_stream
.printf ("Could not insert "
3028 "hardware watchpoint %d.\n",
3036 /* If a hardware breakpoint or watchpoint was inserted, add a
3037 message about possibly exhausted resources. */
3038 if (hw_breakpoint_error
&& !hw_bp_error_explained_already
)
3040 tmp_error_stream
.printf ("Could not insert hardware breakpoints:\n\
3041 You may have requested too many hardware breakpoints/watchpoints.\n");
3043 target_terminal::ours_for_output ();
3044 error_stream (tmp_error_stream
);
3048 /* Used when the program stops.
3049 Returns zero if successful, or non-zero if there was a problem
3050 removing a breakpoint location. */
3053 remove_breakpoints (void)
3055 struct bp_location
*bl
, **blp_tmp
;
3058 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3060 if (bl
->inserted
&& !is_tracepoint (bl
->owner
))
3061 val
|= remove_breakpoint (bl
);
3066 /* When a thread exits, remove breakpoints that are related to
3070 remove_threaded_breakpoints (struct thread_info
*tp
, int silent
)
3072 struct breakpoint
*b
, *b_tmp
;
3074 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
3076 if (b
->thread
== tp
->global_num
&& user_breakpoint_p (b
))
3078 b
->disposition
= disp_del_at_next_stop
;
3080 printf_filtered (_("\
3081 Thread-specific breakpoint %d deleted - thread %s no longer in the thread list.\n"),
3082 b
->number
, print_thread_id (tp
));
3084 /* Hide it from the user. */
3090 /* Remove breakpoints of process PID. */
3093 remove_breakpoints_pid (int pid
)
3095 struct bp_location
*bl
, **blp_tmp
;
3097 struct inferior
*inf
= find_inferior_pid (pid
);
3099 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3101 if (bl
->pspace
!= inf
->pspace
)
3104 if (bl
->inserted
&& !bl
->target_info
.persist
)
3106 val
= remove_breakpoint (bl
);
3114 static int internal_breakpoint_number
= -1;
3116 /* Set the breakpoint number of B, depending on the value of INTERNAL.
3117 If INTERNAL is non-zero, the breakpoint number will be populated
3118 from internal_breakpoint_number and that variable decremented.
3119 Otherwise the breakpoint number will be populated from
3120 breakpoint_count and that value incremented. Internal breakpoints
3121 do not set the internal var bpnum. */
3123 set_breakpoint_number (int internal
, struct breakpoint
*b
)
3126 b
->number
= internal_breakpoint_number
--;
3129 set_breakpoint_count (breakpoint_count
+ 1);
3130 b
->number
= breakpoint_count
;
3134 static struct breakpoint
*
3135 create_internal_breakpoint (struct gdbarch
*gdbarch
,
3136 CORE_ADDR address
, enum bptype type
,
3137 const struct breakpoint_ops
*ops
)
3139 symtab_and_line sal
;
3141 sal
.section
= find_pc_overlay (sal
.pc
);
3142 sal
.pspace
= current_program_space
;
3144 breakpoint
*b
= set_raw_breakpoint (gdbarch
, sal
, type
, ops
);
3145 b
->number
= internal_breakpoint_number
--;
3146 b
->disposition
= disp_donttouch
;
3151 static const char *const longjmp_names
[] =
3153 "longjmp", "_longjmp", "siglongjmp", "_siglongjmp"
3155 #define NUM_LONGJMP_NAMES ARRAY_SIZE(longjmp_names)
3157 /* Per-objfile data private to breakpoint.c. */
3158 struct breakpoint_objfile_data
3160 /* Minimal symbol for "_ovly_debug_event" (if any). */
3161 struct bound_minimal_symbol overlay_msym
{};
3163 /* Minimal symbol(s) for "longjmp", "siglongjmp", etc. (if any). */
3164 struct bound_minimal_symbol longjmp_msym
[NUM_LONGJMP_NAMES
] {};
3166 /* True if we have looked for longjmp probes. */
3167 int longjmp_searched
= 0;
3169 /* SystemTap probe points for longjmp (if any). These are non-owning
3171 std::vector
<probe
*> longjmp_probes
;
3173 /* Minimal symbol for "std::terminate()" (if any). */
3174 struct bound_minimal_symbol terminate_msym
{};
3176 /* Minimal symbol for "_Unwind_DebugHook" (if any). */
3177 struct bound_minimal_symbol exception_msym
{};
3179 /* True if we have looked for exception probes. */
3180 int exception_searched
= 0;
3182 /* SystemTap probe points for unwinding (if any). These are non-owning
3184 std::vector
<probe
*> exception_probes
;
3187 static const struct objfile_data
*breakpoint_objfile_key
;
3189 /* Minimal symbol not found sentinel. */
3190 static struct minimal_symbol msym_not_found
;
3192 /* Returns TRUE if MSYM point to the "not found" sentinel. */
3195 msym_not_found_p (const struct minimal_symbol
*msym
)
3197 return msym
== &msym_not_found
;
3200 /* Return per-objfile data needed by breakpoint.c.
3201 Allocate the data if necessary. */
3203 static struct breakpoint_objfile_data
*
3204 get_breakpoint_objfile_data (struct objfile
*objfile
)
3206 struct breakpoint_objfile_data
*bp_objfile_data
;
3208 bp_objfile_data
= ((struct breakpoint_objfile_data
*)
3209 objfile_data (objfile
, breakpoint_objfile_key
));
3210 if (bp_objfile_data
== NULL
)
3212 bp_objfile_data
= new breakpoint_objfile_data ();
3213 set_objfile_data (objfile
, breakpoint_objfile_key
, bp_objfile_data
);
3215 return bp_objfile_data
;
3219 free_breakpoint_objfile_data (struct objfile
*obj
, void *data
)
3221 struct breakpoint_objfile_data
*bp_objfile_data
3222 = (struct breakpoint_objfile_data
*) data
;
3224 delete bp_objfile_data
;
3228 create_overlay_event_breakpoint (void)
3230 struct objfile
*objfile
;
3231 const char *const func_name
= "_ovly_debug_event";
3233 ALL_OBJFILES (objfile
)
3235 struct breakpoint
*b
;
3236 struct breakpoint_objfile_data
*bp_objfile_data
;
3238 struct explicit_location explicit_loc
;
3240 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3242 if (msym_not_found_p (bp_objfile_data
->overlay_msym
.minsym
))
3245 if (bp_objfile_data
->overlay_msym
.minsym
== NULL
)
3247 struct bound_minimal_symbol m
;
3249 m
= lookup_minimal_symbol_text (func_name
, objfile
);
3250 if (m
.minsym
== NULL
)
3252 /* Avoid future lookups in this objfile. */
3253 bp_objfile_data
->overlay_msym
.minsym
= &msym_not_found
;
3256 bp_objfile_data
->overlay_msym
= m
;
3259 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->overlay_msym
);
3260 b
= create_internal_breakpoint (get_objfile_arch (objfile
), addr
,
3262 &internal_breakpoint_ops
);
3263 initialize_explicit_location (&explicit_loc
);
3264 explicit_loc
.function_name
= ASTRDUP (func_name
);
3265 b
->location
= new_explicit_location (&explicit_loc
);
3267 if (overlay_debugging
== ovly_auto
)
3269 b
->enable_state
= bp_enabled
;
3270 overlay_events_enabled
= 1;
3274 b
->enable_state
= bp_disabled
;
3275 overlay_events_enabled
= 0;
3281 create_longjmp_master_breakpoint (void)
3283 struct program_space
*pspace
;
3285 scoped_restore_current_program_space restore_pspace
;
3287 ALL_PSPACES (pspace
)
3289 struct objfile
*objfile
;
3291 set_current_program_space (pspace
);
3293 ALL_OBJFILES (objfile
)
3296 struct gdbarch
*gdbarch
;
3297 struct breakpoint_objfile_data
*bp_objfile_data
;
3299 gdbarch
= get_objfile_arch (objfile
);
3301 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3303 if (!bp_objfile_data
->longjmp_searched
)
3305 std::vector
<probe
*> ret
3306 = find_probes_in_objfile (objfile
, "libc", "longjmp");
3310 /* We are only interested in checking one element. */
3313 if (!can_evaluate_probe_arguments (p
))
3315 /* We cannot use the probe interface here, because it does
3316 not know how to evaluate arguments. */
3320 bp_objfile_data
->longjmp_probes
= ret
;
3321 bp_objfile_data
->longjmp_searched
= 1;
3324 if (!bp_objfile_data
->longjmp_probes
.empty ())
3326 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3328 for (probe
*p
: bp_objfile_data
->longjmp_probes
)
3330 struct breakpoint
*b
;
3332 b
= create_internal_breakpoint (gdbarch
,
3333 get_probe_address (p
, objfile
),
3335 &internal_breakpoint_ops
);
3336 b
->location
= new_probe_location ("-probe-stap libc:longjmp");
3337 b
->enable_state
= bp_disabled
;
3343 if (!gdbarch_get_longjmp_target_p (gdbarch
))
3346 for (i
= 0; i
< NUM_LONGJMP_NAMES
; i
++)
3348 struct breakpoint
*b
;
3349 const char *func_name
;
3351 struct explicit_location explicit_loc
;
3353 if (msym_not_found_p (bp_objfile_data
->longjmp_msym
[i
].minsym
))
3356 func_name
= longjmp_names
[i
];
3357 if (bp_objfile_data
->longjmp_msym
[i
].minsym
== NULL
)
3359 struct bound_minimal_symbol m
;
3361 m
= lookup_minimal_symbol_text (func_name
, objfile
);
3362 if (m
.minsym
== NULL
)
3364 /* Prevent future lookups in this objfile. */
3365 bp_objfile_data
->longjmp_msym
[i
].minsym
= &msym_not_found
;
3368 bp_objfile_data
->longjmp_msym
[i
] = m
;
3371 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->longjmp_msym
[i
]);
3372 b
= create_internal_breakpoint (gdbarch
, addr
, bp_longjmp_master
,
3373 &internal_breakpoint_ops
);
3374 initialize_explicit_location (&explicit_loc
);
3375 explicit_loc
.function_name
= ASTRDUP (func_name
);
3376 b
->location
= new_explicit_location (&explicit_loc
);
3377 b
->enable_state
= bp_disabled
;
3383 /* Create a master std::terminate breakpoint. */
3385 create_std_terminate_master_breakpoint (void)
3387 struct program_space
*pspace
;
3388 const char *const func_name
= "std::terminate()";
3390 scoped_restore_current_program_space restore_pspace
;
3392 ALL_PSPACES (pspace
)
3394 struct objfile
*objfile
;
3397 set_current_program_space (pspace
);
3399 ALL_OBJFILES (objfile
)
3401 struct breakpoint
*b
;
3402 struct breakpoint_objfile_data
*bp_objfile_data
;
3403 struct explicit_location explicit_loc
;
3405 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3407 if (msym_not_found_p (bp_objfile_data
->terminate_msym
.minsym
))
3410 if (bp_objfile_data
->terminate_msym
.minsym
== NULL
)
3412 struct bound_minimal_symbol m
;
3414 m
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
3415 if (m
.minsym
== NULL
|| (MSYMBOL_TYPE (m
.minsym
) != mst_text
3416 && MSYMBOL_TYPE (m
.minsym
) != mst_file_text
))
3418 /* Prevent future lookups in this objfile. */
3419 bp_objfile_data
->terminate_msym
.minsym
= &msym_not_found
;
3422 bp_objfile_data
->terminate_msym
= m
;
3425 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->terminate_msym
);
3426 b
= create_internal_breakpoint (get_objfile_arch (objfile
), addr
,
3427 bp_std_terminate_master
,
3428 &internal_breakpoint_ops
);
3429 initialize_explicit_location (&explicit_loc
);
3430 explicit_loc
.function_name
= ASTRDUP (func_name
);
3431 b
->location
= new_explicit_location (&explicit_loc
);
3432 b
->enable_state
= bp_disabled
;
3437 /* Install a master breakpoint on the unwinder's debug hook. */
3440 create_exception_master_breakpoint (void)
3442 struct objfile
*objfile
;
3443 const char *const func_name
= "_Unwind_DebugHook";
3445 ALL_OBJFILES (objfile
)
3447 struct breakpoint
*b
;
3448 struct gdbarch
*gdbarch
;
3449 struct breakpoint_objfile_data
*bp_objfile_data
;
3451 struct explicit_location explicit_loc
;
3453 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3455 /* We prefer the SystemTap probe point if it exists. */
3456 if (!bp_objfile_data
->exception_searched
)
3458 std::vector
<probe
*> ret
3459 = find_probes_in_objfile (objfile
, "libgcc", "unwind");
3463 /* We are only interested in checking one element. */
3466 if (!can_evaluate_probe_arguments (p
))
3468 /* We cannot use the probe interface here, because it does
3469 not know how to evaluate arguments. */
3473 bp_objfile_data
->exception_probes
= ret
;
3474 bp_objfile_data
->exception_searched
= 1;
3477 if (!bp_objfile_data
->exception_probes
.empty ())
3479 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3481 for (probe
*p
: bp_objfile_data
->exception_probes
)
3483 struct breakpoint
*b
;
3485 b
= create_internal_breakpoint (gdbarch
,
3486 get_probe_address (p
, objfile
),
3487 bp_exception_master
,
3488 &internal_breakpoint_ops
);
3489 b
->location
= new_probe_location ("-probe-stap libgcc:unwind");
3490 b
->enable_state
= bp_disabled
;
3496 /* Otherwise, try the hook function. */
3498 if (msym_not_found_p (bp_objfile_data
->exception_msym
.minsym
))
3501 gdbarch
= get_objfile_arch (objfile
);
3503 if (bp_objfile_data
->exception_msym
.minsym
== NULL
)
3505 struct bound_minimal_symbol debug_hook
;
3507 debug_hook
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
3508 if (debug_hook
.minsym
== NULL
)
3510 bp_objfile_data
->exception_msym
.minsym
= &msym_not_found
;
3514 bp_objfile_data
->exception_msym
= debug_hook
;
3517 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->exception_msym
);
3518 addr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, addr
,
3520 b
= create_internal_breakpoint (gdbarch
, addr
, bp_exception_master
,
3521 &internal_breakpoint_ops
);
3522 initialize_explicit_location (&explicit_loc
);
3523 explicit_loc
.function_name
= ASTRDUP (func_name
);
3524 b
->location
= new_explicit_location (&explicit_loc
);
3525 b
->enable_state
= bp_disabled
;
3529 /* Does B have a location spec? */
3532 breakpoint_event_location_empty_p (const struct breakpoint
*b
)
3534 return b
->location
!= NULL
&& event_location_empty_p (b
->location
.get ());
3538 update_breakpoints_after_exec (void)
3540 struct breakpoint
*b
, *b_tmp
;
3541 struct bp_location
*bploc
, **bplocp_tmp
;
3543 /* We're about to delete breakpoints from GDB's lists. If the
3544 INSERTED flag is true, GDB will try to lift the breakpoints by
3545 writing the breakpoints' "shadow contents" back into memory. The
3546 "shadow contents" are NOT valid after an exec, so GDB should not
3547 do that. Instead, the target is responsible from marking
3548 breakpoints out as soon as it detects an exec. We don't do that
3549 here instead, because there may be other attempts to delete
3550 breakpoints after detecting an exec and before reaching here. */
3551 ALL_BP_LOCATIONS (bploc
, bplocp_tmp
)
3552 if (bploc
->pspace
== current_program_space
)
3553 gdb_assert (!bploc
->inserted
);
3555 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
3557 if (b
->pspace
!= current_program_space
)
3560 /* Solib breakpoints must be explicitly reset after an exec(). */
3561 if (b
->type
== bp_shlib_event
)
3563 delete_breakpoint (b
);
3567 /* JIT breakpoints must be explicitly reset after an exec(). */
3568 if (b
->type
== bp_jit_event
)
3570 delete_breakpoint (b
);
3574 /* Thread event breakpoints must be set anew after an exec(),
3575 as must overlay event and longjmp master breakpoints. */
3576 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
3577 || b
->type
== bp_longjmp_master
|| b
->type
== bp_std_terminate_master
3578 || b
->type
== bp_exception_master
)
3580 delete_breakpoint (b
);
3584 /* Step-resume breakpoints are meaningless after an exec(). */
3585 if (b
->type
== bp_step_resume
|| b
->type
== bp_hp_step_resume
)
3587 delete_breakpoint (b
);
3591 /* Just like single-step breakpoints. */
3592 if (b
->type
== bp_single_step
)
3594 delete_breakpoint (b
);
3598 /* Longjmp and longjmp-resume breakpoints are also meaningless
3600 if (b
->type
== bp_longjmp
|| b
->type
== bp_longjmp_resume
3601 || b
->type
== bp_longjmp_call_dummy
3602 || b
->type
== bp_exception
|| b
->type
== bp_exception_resume
)
3604 delete_breakpoint (b
);
3608 if (b
->type
== bp_catchpoint
)
3610 /* For now, none of the bp_catchpoint breakpoints need to
3611 do anything at this point. In the future, if some of
3612 the catchpoints need to something, we will need to add
3613 a new method, and call this method from here. */
3617 /* bp_finish is a special case. The only way we ought to be able
3618 to see one of these when an exec() has happened, is if the user
3619 caught a vfork, and then said "finish". Ordinarily a finish just
3620 carries them to the call-site of the current callee, by setting
3621 a temporary bp there and resuming. But in this case, the finish
3622 will carry them entirely through the vfork & exec.
3624 We don't want to allow a bp_finish to remain inserted now. But
3625 we can't safely delete it, 'cause finish_command has a handle to
3626 the bp on a bpstat, and will later want to delete it. There's a
3627 chance (and I've seen it happen) that if we delete the bp_finish
3628 here, that its storage will get reused by the time finish_command
3629 gets 'round to deleting the "use to be a bp_finish" breakpoint.
3630 We really must allow finish_command to delete a bp_finish.
3632 In the absence of a general solution for the "how do we know
3633 it's safe to delete something others may have handles to?"
3634 problem, what we'll do here is just uninsert the bp_finish, and
3635 let finish_command delete it.
3637 (We know the bp_finish is "doomed" in the sense that it's
3638 momentary, and will be deleted as soon as finish_command sees
3639 the inferior stopped. So it doesn't matter that the bp's
3640 address is probably bogus in the new a.out, unlike e.g., the
3641 solib breakpoints.) */
3643 if (b
->type
== bp_finish
)
3648 /* Without a symbolic address, we have little hope of the
3649 pre-exec() address meaning the same thing in the post-exec()
3651 if (breakpoint_event_location_empty_p (b
))
3653 delete_breakpoint (b
);
3660 detach_breakpoints (ptid_t ptid
)
3662 struct bp_location
*bl
, **blp_tmp
;
3664 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
3665 struct inferior
*inf
= current_inferior ();
3667 if (ptid_get_pid (ptid
) == ptid_get_pid (inferior_ptid
))
3668 error (_("Cannot detach breakpoints of inferior_ptid"));
3670 /* Set inferior_ptid; remove_breakpoint_1 uses this global. */
3671 inferior_ptid
= ptid
;
3672 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3674 if (bl
->pspace
!= inf
->pspace
)
3677 /* This function must physically remove breakpoints locations
3678 from the specified ptid, without modifying the breakpoint
3679 package's state. Locations of type bp_loc_other are only
3680 maintained at GDB side. So, there is no need to remove
3681 these bp_loc_other locations. Moreover, removing these
3682 would modify the breakpoint package's state. */
3683 if (bl
->loc_type
== bp_loc_other
)
3687 val
|= remove_breakpoint_1 (bl
, DETACH_BREAKPOINT
);
3693 /* Remove the breakpoint location BL from the current address space.
3694 Note that this is used to detach breakpoints from a child fork.
3695 When we get here, the child isn't in the inferior list, and neither
3696 do we have objects to represent its address space --- we should
3697 *not* look at bl->pspace->aspace here. */
3700 remove_breakpoint_1 (struct bp_location
*bl
, enum remove_bp_reason reason
)
3704 /* BL is never in moribund_locations by our callers. */
3705 gdb_assert (bl
->owner
!= NULL
);
3707 /* The type of none suggests that owner is actually deleted.
3708 This should not ever happen. */
3709 gdb_assert (bl
->owner
->type
!= bp_none
);
3711 if (bl
->loc_type
== bp_loc_software_breakpoint
3712 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
3714 /* "Normal" instruction breakpoint: either the standard
3715 trap-instruction bp (bp_breakpoint), or a
3716 bp_hardware_breakpoint. */
3718 /* First check to see if we have to handle an overlay. */
3719 if (overlay_debugging
== ovly_off
3720 || bl
->section
== NULL
3721 || !(section_is_overlay (bl
->section
)))
3723 /* No overlay handling: just remove the breakpoint. */
3725 /* If we're trying to uninsert a memory breakpoint that we
3726 know is set in a dynamic object that is marked
3727 shlib_disabled, then either the dynamic object was
3728 removed with "remove-symbol-file" or with
3729 "nosharedlibrary". In the former case, we don't know
3730 whether another dynamic object might have loaded over the
3731 breakpoint's address -- the user might well let us know
3732 about it next with add-symbol-file (the whole point of
3733 add-symbol-file is letting the user manually maintain a
3734 list of dynamically loaded objects). If we have the
3735 breakpoint's shadow memory, that is, this is a software
3736 breakpoint managed by GDB, check whether the breakpoint
3737 is still inserted in memory, to avoid overwriting wrong
3738 code with stale saved shadow contents. Note that HW
3739 breakpoints don't have shadow memory, as they're
3740 implemented using a mechanism that is not dependent on
3741 being able to modify the target's memory, and as such
3742 they should always be removed. */
3743 if (bl
->shlib_disabled
3744 && bl
->target_info
.shadow_len
!= 0
3745 && !memory_validate_breakpoint (bl
->gdbarch
, &bl
->target_info
))
3748 val
= bl
->owner
->ops
->remove_location (bl
, reason
);
3752 /* This breakpoint is in an overlay section.
3753 Did we set a breakpoint at the LMA? */
3754 if (!overlay_events_enabled
)
3756 /* Yes -- overlay event support is not active, so we
3757 should have set a breakpoint at the LMA. Remove it.
3759 /* Ignore any failures: if the LMA is in ROM, we will
3760 have already warned when we failed to insert it. */
3761 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
3762 target_remove_hw_breakpoint (bl
->gdbarch
,
3763 &bl
->overlay_target_info
);
3765 target_remove_breakpoint (bl
->gdbarch
,
3766 &bl
->overlay_target_info
,
3769 /* Did we set a breakpoint at the VMA?
3770 If so, we will have marked the breakpoint 'inserted'. */
3773 /* Yes -- remove it. Previously we did not bother to
3774 remove the breakpoint if the section had been
3775 unmapped, but let's not rely on that being safe. We
3776 don't know what the overlay manager might do. */
3778 /* However, we should remove *software* breakpoints only
3779 if the section is still mapped, or else we overwrite
3780 wrong code with the saved shadow contents. */
3781 if (bl
->loc_type
== bp_loc_hardware_breakpoint
3782 || section_is_mapped (bl
->section
))
3783 val
= bl
->owner
->ops
->remove_location (bl
, reason
);
3789 /* No -- not inserted, so no need to remove. No error. */
3794 /* In some cases, we might not be able to remove a breakpoint in
3795 a shared library that has already been removed, but we have
3796 not yet processed the shlib unload event. Similarly for an
3797 unloaded add-symbol-file object - the user might not yet have
3798 had the chance to remove-symbol-file it. shlib_disabled will
3799 be set if the library/object has already been removed, but
3800 the breakpoint hasn't been uninserted yet, e.g., after
3801 "nosharedlibrary" or "remove-symbol-file" with breakpoints
3802 always-inserted mode. */
3804 && (bl
->loc_type
== bp_loc_software_breakpoint
3805 && (bl
->shlib_disabled
3806 || solib_name_from_address (bl
->pspace
, bl
->address
)
3807 || shared_objfile_contains_address_p (bl
->pspace
,
3813 bl
->inserted
= (reason
== DETACH_BREAKPOINT
);
3815 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
)
3817 gdb_assert (bl
->owner
->ops
!= NULL
3818 && bl
->owner
->ops
->remove_location
!= NULL
);
3820 bl
->inserted
= (reason
== DETACH_BREAKPOINT
);
3821 bl
->owner
->ops
->remove_location (bl
, reason
);
3823 /* Failure to remove any of the hardware watchpoints comes here. */
3824 if (reason
== REMOVE_BREAKPOINT
&& bl
->inserted
)
3825 warning (_("Could not remove hardware watchpoint %d."),
3828 else if (bl
->owner
->type
== bp_catchpoint
3829 && breakpoint_enabled (bl
->owner
)
3832 gdb_assert (bl
->owner
->ops
!= NULL
3833 && bl
->owner
->ops
->remove_location
!= NULL
);
3835 val
= bl
->owner
->ops
->remove_location (bl
, reason
);
3839 bl
->inserted
= (reason
== DETACH_BREAKPOINT
);
3846 remove_breakpoint (struct bp_location
*bl
)
3848 /* BL is never in moribund_locations by our callers. */
3849 gdb_assert (bl
->owner
!= NULL
);
3851 /* The type of none suggests that owner is actually deleted.
3852 This should not ever happen. */
3853 gdb_assert (bl
->owner
->type
!= bp_none
);
3855 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
3857 switch_to_program_space_and_thread (bl
->pspace
);
3859 return remove_breakpoint_1 (bl
, REMOVE_BREAKPOINT
);
3862 /* Clear the "inserted" flag in all breakpoints. */
3865 mark_breakpoints_out (void)
3867 struct bp_location
*bl
, **blp_tmp
;
3869 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3870 if (bl
->pspace
== current_program_space
)
3874 /* Clear the "inserted" flag in all breakpoints and delete any
3875 breakpoints which should go away between runs of the program.
3877 Plus other such housekeeping that has to be done for breakpoints
3880 Note: this function gets called at the end of a run (by
3881 generic_mourn_inferior) and when a run begins (by
3882 init_wait_for_inferior). */
3887 breakpoint_init_inferior (enum inf_context context
)
3889 struct breakpoint
*b
, *b_tmp
;
3890 struct bp_location
*bl
;
3892 struct program_space
*pspace
= current_program_space
;
3894 /* If breakpoint locations are shared across processes, then there's
3896 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
3899 mark_breakpoints_out ();
3901 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
3903 if (b
->loc
&& b
->loc
->pspace
!= pspace
)
3909 case bp_longjmp_call_dummy
:
3911 /* If the call dummy breakpoint is at the entry point it will
3912 cause problems when the inferior is rerun, so we better get
3915 case bp_watchpoint_scope
:
3917 /* Also get rid of scope breakpoints. */
3919 case bp_shlib_event
:
3921 /* Also remove solib event breakpoints. Their addresses may
3922 have changed since the last time we ran the program.
3923 Actually we may now be debugging against different target;
3924 and so the solib backend that installed this breakpoint may
3925 not be used in by the target. E.g.,
3927 (gdb) file prog-linux
3928 (gdb) run # native linux target
3931 (gdb) file prog-win.exe
3932 (gdb) tar rem :9999 # remote Windows gdbserver.
3935 case bp_step_resume
:
3937 /* Also remove step-resume breakpoints. */
3939 case bp_single_step
:
3941 /* Also remove single-step breakpoints. */
3943 delete_breakpoint (b
);
3947 case bp_hardware_watchpoint
:
3948 case bp_read_watchpoint
:
3949 case bp_access_watchpoint
:
3951 struct watchpoint
*w
= (struct watchpoint
*) b
;
3953 /* Likewise for watchpoints on local expressions. */
3954 if (w
->exp_valid_block
!= NULL
)
3955 delete_breakpoint (b
);
3958 /* Get rid of existing locations, which are no longer
3959 valid. New ones will be created in
3960 update_watchpoint, when the inferior is restarted.
3961 The next update_global_location_list call will
3962 garbage collect them. */
3965 if (context
== inf_starting
)
3967 /* Reset val field to force reread of starting value in
3968 insert_breakpoints. */
3970 value_free (w
->val
);
3982 /* Get rid of the moribund locations. */
3983 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, bl
); ++ix
)
3984 decref_bp_location (&bl
);
3985 VEC_free (bp_location_p
, moribund_locations
);
3988 /* These functions concern about actual breakpoints inserted in the
3989 target --- to e.g. check if we need to do decr_pc adjustment or if
3990 we need to hop over the bkpt --- so we check for address space
3991 match, not program space. */
3993 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
3994 exists at PC. It returns ordinary_breakpoint_here if it's an
3995 ordinary breakpoint, or permanent_breakpoint_here if it's a
3996 permanent breakpoint.
3997 - When continuing from a location with an ordinary breakpoint, we
3998 actually single step once before calling insert_breakpoints.
3999 - When continuing from a location with a permanent breakpoint, we
4000 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
4001 the target, to advance the PC past the breakpoint. */
4003 enum breakpoint_here
4004 breakpoint_here_p (const address_space
*aspace
, CORE_ADDR pc
)
4006 struct bp_location
*bl
, **blp_tmp
;
4007 int any_breakpoint_here
= 0;
4009 ALL_BP_LOCATIONS (bl
, blp_tmp
)
4011 if (bl
->loc_type
!= bp_loc_software_breakpoint
4012 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4015 /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
4016 if ((breakpoint_enabled (bl
->owner
)
4018 && breakpoint_location_address_match (bl
, aspace
, pc
))
4020 if (overlay_debugging
4021 && section_is_overlay (bl
->section
)
4022 && !section_is_mapped (bl
->section
))
4023 continue; /* unmapped overlay -- can't be a match */
4024 else if (bl
->permanent
)
4025 return permanent_breakpoint_here
;
4027 any_breakpoint_here
= 1;
4031 return any_breakpoint_here
? ordinary_breakpoint_here
: no_breakpoint_here
;
4034 /* See breakpoint.h. */
4037 breakpoint_in_range_p (const address_space
*aspace
,
4038 CORE_ADDR addr
, ULONGEST len
)
4040 struct bp_location
*bl
, **blp_tmp
;
4042 ALL_BP_LOCATIONS (bl
, blp_tmp
)
4044 if (bl
->loc_type
!= bp_loc_software_breakpoint
4045 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4048 if ((breakpoint_enabled (bl
->owner
)
4050 && breakpoint_location_address_range_overlap (bl
, aspace
,
4053 if (overlay_debugging
4054 && section_is_overlay (bl
->section
)
4055 && !section_is_mapped (bl
->section
))
4057 /* Unmapped overlay -- can't be a match. */
4068 /* Return true if there's a moribund breakpoint at PC. */
4071 moribund_breakpoint_here_p (const address_space
*aspace
, CORE_ADDR pc
)
4073 struct bp_location
*loc
;
4076 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
4077 if (breakpoint_location_address_match (loc
, aspace
, pc
))
4083 /* Returns non-zero iff BL is inserted at PC, in address space
4087 bp_location_inserted_here_p (struct bp_location
*bl
,
4088 const address_space
*aspace
, CORE_ADDR pc
)
4091 && breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
4094 if (overlay_debugging
4095 && section_is_overlay (bl
->section
)
4096 && !section_is_mapped (bl
->section
))
4097 return 0; /* unmapped overlay -- can't be a match */
4104 /* Returns non-zero iff there's a breakpoint inserted at PC. */
4107 breakpoint_inserted_here_p (const address_space
*aspace
, CORE_ADDR pc
)
4109 struct bp_location
**blp
, **blp_tmp
= NULL
;
4111 ALL_BP_LOCATIONS_AT_ADDR (blp
, blp_tmp
, pc
)
4113 struct bp_location
*bl
= *blp
;
4115 if (bl
->loc_type
!= bp_loc_software_breakpoint
4116 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4119 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4125 /* This function returns non-zero iff there is a software breakpoint
4129 software_breakpoint_inserted_here_p (const address_space
*aspace
,
4132 struct bp_location
**blp
, **blp_tmp
= NULL
;
4134 ALL_BP_LOCATIONS_AT_ADDR (blp
, blp_tmp
, pc
)
4136 struct bp_location
*bl
= *blp
;
4138 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
4141 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4148 /* See breakpoint.h. */
4151 hardware_breakpoint_inserted_here_p (const address_space
*aspace
,
4154 struct bp_location
**blp
, **blp_tmp
= NULL
;
4156 ALL_BP_LOCATIONS_AT_ADDR (blp
, blp_tmp
, pc
)
4158 struct bp_location
*bl
= *blp
;
4160 if (bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4163 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4171 hardware_watchpoint_inserted_in_range (const address_space
*aspace
,
4172 CORE_ADDR addr
, ULONGEST len
)
4174 struct breakpoint
*bpt
;
4176 ALL_BREAKPOINTS (bpt
)
4178 struct bp_location
*loc
;
4180 if (bpt
->type
!= bp_hardware_watchpoint
4181 && bpt
->type
!= bp_access_watchpoint
)
4184 if (!breakpoint_enabled (bpt
))
4187 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
4188 if (loc
->pspace
->aspace
== aspace
&& loc
->inserted
)
4192 /* Check for intersection. */
4193 l
= std::max
<CORE_ADDR
> (loc
->address
, addr
);
4194 h
= std::min
<CORE_ADDR
> (loc
->address
+ loc
->length
, addr
+ len
);
4203 /* bpstat stuff. External routines' interfaces are documented
4207 is_catchpoint (struct breakpoint
*ep
)
4209 return (ep
->type
== bp_catchpoint
);
4212 /* Frees any storage that is part of a bpstat. Does not walk the
4215 bpstats::~bpstats ()
4217 if (old_val
!= NULL
)
4218 value_free (old_val
);
4219 if (bp_location_at
!= NULL
)
4220 decref_bp_location (&bp_location_at
);
4223 /* Clear a bpstat so that it says we are not at any breakpoint.
4224 Also free any storage that is part of a bpstat. */
4227 bpstat_clear (bpstat
*bsp
)
4244 bpstats::bpstats (const bpstats
&other
)
4246 bp_location_at (other
.bp_location_at
),
4247 breakpoint_at (other
.breakpoint_at
),
4248 commands (other
.commands
),
4249 old_val (other
.old_val
),
4250 print (other
.print
),
4252 print_it (other
.print_it
)
4254 if (old_val
!= NULL
)
4256 old_val
= value_copy (old_val
);
4257 release_value (old_val
);
4259 incref_bp_location (bp_location_at
);
4262 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
4263 is part of the bpstat is copied as well. */
4266 bpstat_copy (bpstat bs
)
4270 bpstat retval
= NULL
;
4275 for (; bs
!= NULL
; bs
= bs
->next
)
4277 tmp
= new bpstats (*bs
);
4280 /* This is the first thing in the chain. */
4290 /* Find the bpstat associated with this breakpoint. */
4293 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
4298 for (; bsp
!= NULL
; bsp
= bsp
->next
)
4300 if (bsp
->breakpoint_at
== breakpoint
)
4306 /* See breakpoint.h. */
4309 bpstat_explains_signal (bpstat bsp
, enum gdb_signal sig
)
4311 for (; bsp
!= NULL
; bsp
= bsp
->next
)
4313 if (bsp
->breakpoint_at
== NULL
)
4315 /* A moribund location can never explain a signal other than
4317 if (sig
== GDB_SIGNAL_TRAP
)
4322 if (bsp
->breakpoint_at
->ops
->explains_signal (bsp
->breakpoint_at
,
4331 /* Put in *NUM the breakpoint number of the first breakpoint we are
4332 stopped at. *BSP upon return is a bpstat which points to the
4333 remaining breakpoints stopped at (but which is not guaranteed to be
4334 good for anything but further calls to bpstat_num).
4336 Return 0 if passed a bpstat which does not indicate any breakpoints.
4337 Return -1 if stopped at a breakpoint that has been deleted since
4339 Return 1 otherwise. */
4342 bpstat_num (bpstat
*bsp
, int *num
)
4344 struct breakpoint
*b
;
4347 return 0; /* No more breakpoint values */
4349 /* We assume we'll never have several bpstats that correspond to a
4350 single breakpoint -- otherwise, this function might return the
4351 same number more than once and this will look ugly. */
4352 b
= (*bsp
)->breakpoint_at
;
4353 *bsp
= (*bsp
)->next
;
4355 return -1; /* breakpoint that's been deleted since */
4357 *num
= b
->number
; /* We have its number */
4361 /* See breakpoint.h. */
4364 bpstat_clear_actions (void)
4366 struct thread_info
*tp
;
4369 if (ptid_equal (inferior_ptid
, null_ptid
))
4372 tp
= find_thread_ptid (inferior_ptid
);
4376 for (bs
= tp
->control
.stop_bpstat
; bs
!= NULL
; bs
= bs
->next
)
4378 bs
->commands
= NULL
;
4380 if (bs
->old_val
!= NULL
)
4382 value_free (bs
->old_val
);
4388 /* Called when a command is about to proceed the inferior. */
4391 breakpoint_about_to_proceed (void)
4393 if (!ptid_equal (inferior_ptid
, null_ptid
))
4395 struct thread_info
*tp
= inferior_thread ();
4397 /* Allow inferior function calls in breakpoint commands to not
4398 interrupt the command list. When the call finishes
4399 successfully, the inferior will be standing at the same
4400 breakpoint as if nothing happened. */
4401 if (tp
->control
.in_infcall
)
4405 breakpoint_proceeded
= 1;
4408 /* Return non-zero iff CMD as the first line of a command sequence is `silent'
4409 or its equivalent. */
4412 command_line_is_silent (struct command_line
*cmd
)
4414 return cmd
&& (strcmp ("silent", cmd
->line
) == 0);
4417 /* Execute all the commands associated with all the breakpoints at
4418 this location. Any of these commands could cause the process to
4419 proceed beyond this point, etc. We look out for such changes by
4420 checking the global "breakpoint_proceeded" after each command.
4422 Returns true if a breakpoint command resumed the inferior. In that
4423 case, it is the caller's responsibility to recall it again with the
4424 bpstat of the current thread. */
4427 bpstat_do_actions_1 (bpstat
*bsp
)
4432 /* Avoid endless recursion if a `source' command is contained
4434 if (executing_breakpoint_commands
)
4437 scoped_restore save_executing
4438 = make_scoped_restore (&executing_breakpoint_commands
, 1);
4440 scoped_restore preventer
= prevent_dont_repeat ();
4442 /* This pointer will iterate over the list of bpstat's. */
4445 breakpoint_proceeded
= 0;
4446 for (; bs
!= NULL
; bs
= bs
->next
)
4448 struct command_line
*cmd
= NULL
;
4450 /* Take ownership of the BSP's command tree, if it has one.
4452 The command tree could legitimately contain commands like
4453 'step' and 'next', which call clear_proceed_status, which
4454 frees stop_bpstat's command tree. To make sure this doesn't
4455 free the tree we're executing out from under us, we need to
4456 take ownership of the tree ourselves. Since a given bpstat's
4457 commands are only executed once, we don't need to copy it; we
4458 can clear the pointer in the bpstat, and make sure we free
4459 the tree when we're done. */
4460 counted_command_line ccmd
= bs
->commands
;
4461 bs
->commands
= NULL
;
4464 if (command_line_is_silent (cmd
))
4466 /* The action has been already done by bpstat_stop_status. */
4472 execute_control_command (cmd
);
4474 if (breakpoint_proceeded
)
4480 if (breakpoint_proceeded
)
4482 if (current_ui
->async
)
4483 /* If we are in async mode, then the target might be still
4484 running, not stopped at any breakpoint, so nothing for
4485 us to do here -- just return to the event loop. */
4488 /* In sync mode, when execute_control_command returns
4489 we're already standing on the next breakpoint.
4490 Breakpoint commands for that stop were not run, since
4491 execute_command does not run breakpoint commands --
4492 only command_line_handler does, but that one is not
4493 involved in execution of breakpoint commands. So, we
4494 can now execute breakpoint commands. It should be
4495 noted that making execute_command do bpstat actions is
4496 not an option -- in this case we'll have recursive
4497 invocation of bpstat for each breakpoint with a
4498 command, and can easily blow up GDB stack. Instead, we
4499 return true, which will trigger the caller to recall us
4500 with the new stop_bpstat. */
4509 bpstat_do_actions (void)
4511 struct cleanup
*cleanup_if_error
= make_bpstat_clear_actions_cleanup ();
4513 /* Do any commands attached to breakpoint we are stopped at. */
4514 while (!ptid_equal (inferior_ptid
, null_ptid
)
4515 && target_has_execution
4516 && !is_exited (inferior_ptid
)
4517 && !is_executing (inferior_ptid
))
4518 /* Since in sync mode, bpstat_do_actions may resume the inferior,
4519 and only return when it is stopped at the next breakpoint, we
4520 keep doing breakpoint actions until it returns false to
4521 indicate the inferior was not resumed. */
4522 if (!bpstat_do_actions_1 (&inferior_thread ()->control
.stop_bpstat
))
4525 discard_cleanups (cleanup_if_error
);
4528 /* Print out the (old or new) value associated with a watchpoint. */
4531 watchpoint_value_print (struct value
*val
, struct ui_file
*stream
)
4534 fprintf_unfiltered (stream
, _("<unreadable>"));
4537 struct value_print_options opts
;
4538 get_user_print_options (&opts
);
4539 value_print (val
, stream
, &opts
);
4543 /* Print the "Thread ID hit" part of "Thread ID hit Breakpoint N" if
4544 debugging multiple threads. */
4547 maybe_print_thread_hit_breakpoint (struct ui_out
*uiout
)
4549 if (uiout
->is_mi_like_p ())
4554 if (show_thread_that_caused_stop ())
4557 struct thread_info
*thr
= inferior_thread ();
4559 uiout
->text ("Thread ");
4560 uiout
->field_fmt ("thread-id", "%s", print_thread_id (thr
));
4562 name
= thr
->name
!= NULL
? thr
->name
: target_thread_name (thr
);
4565 uiout
->text (" \"");
4566 uiout
->field_fmt ("name", "%s", name
);
4570 uiout
->text (" hit ");
4574 /* Generic routine for printing messages indicating why we
4575 stopped. The behavior of this function depends on the value
4576 'print_it' in the bpstat structure. Under some circumstances we
4577 may decide not to print anything here and delegate the task to
4580 static enum print_stop_action
4581 print_bp_stop_message (bpstat bs
)
4583 switch (bs
->print_it
)
4586 /* Nothing should be printed for this bpstat entry. */
4587 return PRINT_UNKNOWN
;
4591 /* We still want to print the frame, but we already printed the
4592 relevant messages. */
4593 return PRINT_SRC_AND_LOC
;
4596 case print_it_normal
:
4598 struct breakpoint
*b
= bs
->breakpoint_at
;
4600 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
4601 which has since been deleted. */
4603 return PRINT_UNKNOWN
;
4605 /* Normal case. Call the breakpoint's print_it method. */
4606 return b
->ops
->print_it (bs
);
4611 internal_error (__FILE__
, __LINE__
,
4612 _("print_bp_stop_message: unrecognized enum value"));
4617 /* A helper function that prints a shared library stopped event. */
4620 print_solib_event (int is_catchpoint
)
4623 = !VEC_empty (char_ptr
, current_program_space
->deleted_solibs
);
4625 = !VEC_empty (so_list_ptr
, current_program_space
->added_solibs
);
4629 if (any_added
|| any_deleted
)
4630 current_uiout
->text (_("Stopped due to shared library event:\n"));
4632 current_uiout
->text (_("Stopped due to shared library event (no "
4633 "libraries added or removed)\n"));
4636 if (current_uiout
->is_mi_like_p ())
4637 current_uiout
->field_string ("reason",
4638 async_reason_lookup (EXEC_ASYNC_SOLIB_EVENT
));
4645 current_uiout
->text (_(" Inferior unloaded "));
4646 ui_out_emit_list
list_emitter (current_uiout
, "removed");
4648 VEC_iterate (char_ptr
, current_program_space
->deleted_solibs
,
4653 current_uiout
->text (" ");
4654 current_uiout
->field_string ("library", name
);
4655 current_uiout
->text ("\n");
4661 struct so_list
*iter
;
4664 current_uiout
->text (_(" Inferior loaded "));
4665 ui_out_emit_list
list_emitter (current_uiout
, "added");
4667 VEC_iterate (so_list_ptr
, current_program_space
->added_solibs
,
4672 current_uiout
->text (" ");
4673 current_uiout
->field_string ("library", iter
->so_name
);
4674 current_uiout
->text ("\n");
4679 /* Print a message indicating what happened. This is called from
4680 normal_stop(). The input to this routine is the head of the bpstat
4681 list - a list of the eventpoints that caused this stop. KIND is
4682 the target_waitkind for the stopping event. This
4683 routine calls the generic print routine for printing a message
4684 about reasons for stopping. This will print (for example) the
4685 "Breakpoint n," part of the output. The return value of this
4688 PRINT_UNKNOWN: Means we printed nothing.
4689 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
4690 code to print the location. An example is
4691 "Breakpoint 1, " which should be followed by
4693 PRINT_SRC_ONLY: Means we printed something, but there is no need
4694 to also print the location part of the message.
4695 An example is the catch/throw messages, which
4696 don't require a location appended to the end.
4697 PRINT_NOTHING: We have done some printing and we don't need any
4698 further info to be printed. */
4700 enum print_stop_action
4701 bpstat_print (bpstat bs
, int kind
)
4703 enum print_stop_action val
;
4705 /* Maybe another breakpoint in the chain caused us to stop.
4706 (Currently all watchpoints go on the bpstat whether hit or not.
4707 That probably could (should) be changed, provided care is taken
4708 with respect to bpstat_explains_signal). */
4709 for (; bs
; bs
= bs
->next
)
4711 val
= print_bp_stop_message (bs
);
4712 if (val
== PRINT_SRC_ONLY
4713 || val
== PRINT_SRC_AND_LOC
4714 || val
== PRINT_NOTHING
)
4718 /* If we had hit a shared library event breakpoint,
4719 print_bp_stop_message would print out this message. If we hit an
4720 OS-level shared library event, do the same thing. */
4721 if (kind
== TARGET_WAITKIND_LOADED
)
4723 print_solib_event (0);
4724 return PRINT_NOTHING
;
4727 /* We reached the end of the chain, or we got a null BS to start
4728 with and nothing was printed. */
4729 return PRINT_UNKNOWN
;
4732 /* Evaluate the boolean expression EXP and return the result. */
4735 breakpoint_cond_eval (expression
*exp
)
4737 struct value
*mark
= value_mark ();
4738 bool res
= value_true (evaluate_expression (exp
));
4740 value_free_to_mark (mark
);
4744 /* Allocate a new bpstat. Link it to the FIFO list by BS_LINK_POINTER. */
4746 bpstats::bpstats (struct bp_location
*bl
, bpstat
**bs_link_pointer
)
4748 bp_location_at (bl
),
4749 breakpoint_at (bl
->owner
),
4754 print_it (print_it_normal
)
4756 incref_bp_location (bl
);
4757 **bs_link_pointer
= this;
4758 *bs_link_pointer
= &next
;
4763 bp_location_at (NULL
),
4764 breakpoint_at (NULL
),
4769 print_it (print_it_normal
)
4773 /* The target has stopped with waitstatus WS. Check if any hardware
4774 watchpoints have triggered, according to the target. */
4777 watchpoints_triggered (struct target_waitstatus
*ws
)
4779 int stopped_by_watchpoint
= target_stopped_by_watchpoint ();
4781 struct breakpoint
*b
;
4783 if (!stopped_by_watchpoint
)
4785 /* We were not stopped by a watchpoint. Mark all watchpoints
4786 as not triggered. */
4788 if (is_hardware_watchpoint (b
))
4790 struct watchpoint
*w
= (struct watchpoint
*) b
;
4792 w
->watchpoint_triggered
= watch_triggered_no
;
4798 if (!target_stopped_data_address (¤t_target
, &addr
))
4800 /* We were stopped by a watchpoint, but we don't know where.
4801 Mark all watchpoints as unknown. */
4803 if (is_hardware_watchpoint (b
))
4805 struct watchpoint
*w
= (struct watchpoint
*) b
;
4807 w
->watchpoint_triggered
= watch_triggered_unknown
;
4813 /* The target could report the data address. Mark watchpoints
4814 affected by this data address as triggered, and all others as not
4818 if (is_hardware_watchpoint (b
))
4820 struct watchpoint
*w
= (struct watchpoint
*) b
;
4821 struct bp_location
*loc
;
4823 w
->watchpoint_triggered
= watch_triggered_no
;
4824 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
4826 if (is_masked_watchpoint (b
))
4828 CORE_ADDR newaddr
= addr
& w
->hw_wp_mask
;
4829 CORE_ADDR start
= loc
->address
& w
->hw_wp_mask
;
4831 if (newaddr
== start
)
4833 w
->watchpoint_triggered
= watch_triggered_yes
;
4837 /* Exact match not required. Within range is sufficient. */
4838 else if (target_watchpoint_addr_within_range (¤t_target
,
4842 w
->watchpoint_triggered
= watch_triggered_yes
;
4851 /* Possible return values for watchpoint_check. */
4852 enum wp_check_result
4854 /* The watchpoint has been deleted. */
4857 /* The value has changed. */
4858 WP_VALUE_CHANGED
= 2,
4860 /* The value has not changed. */
4861 WP_VALUE_NOT_CHANGED
= 3,
4863 /* Ignore this watchpoint, no matter if the value changed or not. */
4867 #define BP_TEMPFLAG 1
4868 #define BP_HARDWAREFLAG 2
4870 /* Evaluate watchpoint condition expression and check if its value
4873 static wp_check_result
4874 watchpoint_check (bpstat bs
)
4876 struct watchpoint
*b
;
4877 struct frame_info
*fr
;
4878 int within_current_scope
;
4880 /* BS is built from an existing struct breakpoint. */
4881 gdb_assert (bs
->breakpoint_at
!= NULL
);
4882 b
= (struct watchpoint
*) bs
->breakpoint_at
;
4884 /* If this is a local watchpoint, we only want to check if the
4885 watchpoint frame is in scope if the current thread is the thread
4886 that was used to create the watchpoint. */
4887 if (!watchpoint_in_thread_scope (b
))
4890 if (b
->exp_valid_block
== NULL
)
4891 within_current_scope
= 1;
4894 struct frame_info
*frame
= get_current_frame ();
4895 struct gdbarch
*frame_arch
= get_frame_arch (frame
);
4896 CORE_ADDR frame_pc
= get_frame_pc (frame
);
4898 /* stack_frame_destroyed_p() returns a non-zero value if we're
4899 still in the function but the stack frame has already been
4900 invalidated. Since we can't rely on the values of local
4901 variables after the stack has been destroyed, we are treating
4902 the watchpoint in that state as `not changed' without further
4903 checking. Don't mark watchpoints as changed if the current
4904 frame is in an epilogue - even if they are in some other
4905 frame, our view of the stack is likely to be wrong and
4906 frame_find_by_id could error out. */
4907 if (gdbarch_stack_frame_destroyed_p (frame_arch
, frame_pc
))
4910 fr
= frame_find_by_id (b
->watchpoint_frame
);
4911 within_current_scope
= (fr
!= NULL
);
4913 /* If we've gotten confused in the unwinder, we might have
4914 returned a frame that can't describe this variable. */
4915 if (within_current_scope
)
4917 struct symbol
*function
;
4919 function
= get_frame_function (fr
);
4920 if (function
== NULL
4921 || !contained_in (b
->exp_valid_block
,
4922 SYMBOL_BLOCK_VALUE (function
)))
4923 within_current_scope
= 0;
4926 if (within_current_scope
)
4927 /* If we end up stopping, the current frame will get selected
4928 in normal_stop. So this call to select_frame won't affect
4933 if (within_current_scope
)
4935 /* We use value_{,free_to_}mark because it could be a *long*
4936 time before we return to the command level and call
4937 free_all_values. We can't call free_all_values because we
4938 might be in the middle of evaluating a function call. */
4942 struct value
*new_val
;
4944 if (is_masked_watchpoint (b
))
4945 /* Since we don't know the exact trigger address (from
4946 stopped_data_address), just tell the user we've triggered
4947 a mask watchpoint. */
4948 return WP_VALUE_CHANGED
;
4950 mark
= value_mark ();
4951 fetch_subexp_value (b
->exp
.get (), &pc
, &new_val
, NULL
, NULL
, 0);
4953 if (b
->val_bitsize
!= 0)
4954 new_val
= extract_bitfield_from_watchpoint_value (b
, new_val
);
4956 /* We use value_equal_contents instead of value_equal because
4957 the latter coerces an array to a pointer, thus comparing just
4958 the address of the array instead of its contents. This is
4959 not what we want. */
4960 if ((b
->val
!= NULL
) != (new_val
!= NULL
)
4961 || (b
->val
!= NULL
&& !value_equal_contents (b
->val
, new_val
)))
4963 if (new_val
!= NULL
)
4965 release_value (new_val
);
4966 value_free_to_mark (mark
);
4968 bs
->old_val
= b
->val
;
4971 return WP_VALUE_CHANGED
;
4975 /* Nothing changed. */
4976 value_free_to_mark (mark
);
4977 return WP_VALUE_NOT_CHANGED
;
4982 /* This seems like the only logical thing to do because
4983 if we temporarily ignored the watchpoint, then when
4984 we reenter the block in which it is valid it contains
4985 garbage (in the case of a function, it may have two
4986 garbage values, one before and one after the prologue).
4987 So we can't even detect the first assignment to it and
4988 watch after that (since the garbage may or may not equal
4989 the first value assigned). */
4990 /* We print all the stop information in
4991 breakpoint_ops->print_it, but in this case, by the time we
4992 call breakpoint_ops->print_it this bp will be deleted
4993 already. So we have no choice but print the information
4996 SWITCH_THRU_ALL_UIS ()
4998 struct ui_out
*uiout
= current_uiout
;
5000 if (uiout
->is_mi_like_p ())
5002 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
5003 uiout
->text ("\nWatchpoint ");
5004 uiout
->field_int ("wpnum", b
->number
);
5005 uiout
->text (" deleted because the program has left the block in\n"
5006 "which its expression is valid.\n");
5009 /* Make sure the watchpoint's commands aren't executed. */
5011 watchpoint_del_at_next_stop (b
);
5017 /* Return true if it looks like target has stopped due to hitting
5018 breakpoint location BL. This function does not check if we should
5019 stop, only if BL explains the stop. */
5022 bpstat_check_location (const struct bp_location
*bl
,
5023 const address_space
*aspace
, CORE_ADDR bp_addr
,
5024 const struct target_waitstatus
*ws
)
5026 struct breakpoint
*b
= bl
->owner
;
5028 /* BL is from an existing breakpoint. */
5029 gdb_assert (b
!= NULL
);
5031 return b
->ops
->breakpoint_hit (bl
, aspace
, bp_addr
, ws
);
5034 /* Determine if the watched values have actually changed, and we
5035 should stop. If not, set BS->stop to 0. */
5038 bpstat_check_watchpoint (bpstat bs
)
5040 const struct bp_location
*bl
;
5041 struct watchpoint
*b
;
5043 /* BS is built for existing struct breakpoint. */
5044 bl
= bs
->bp_location_at
;
5045 gdb_assert (bl
!= NULL
);
5046 b
= (struct watchpoint
*) bs
->breakpoint_at
;
5047 gdb_assert (b
!= NULL
);
5050 int must_check_value
= 0;
5052 if (b
->type
== bp_watchpoint
)
5053 /* For a software watchpoint, we must always check the
5055 must_check_value
= 1;
5056 else if (b
->watchpoint_triggered
== watch_triggered_yes
)
5057 /* We have a hardware watchpoint (read, write, or access)
5058 and the target earlier reported an address watched by
5060 must_check_value
= 1;
5061 else if (b
->watchpoint_triggered
== watch_triggered_unknown
5062 && b
->type
== bp_hardware_watchpoint
)
5063 /* We were stopped by a hardware watchpoint, but the target could
5064 not report the data address. We must check the watchpoint's
5065 value. Access and read watchpoints are out of luck; without
5066 a data address, we can't figure it out. */
5067 must_check_value
= 1;
5069 if (must_check_value
)
5075 e
= watchpoint_check (bs
);
5077 CATCH (ex
, RETURN_MASK_ALL
)
5079 exception_fprintf (gdb_stderr
, ex
,
5080 "Error evaluating expression "
5081 "for watchpoint %d\n",
5084 SWITCH_THRU_ALL_UIS ()
5086 printf_filtered (_("Watchpoint %d deleted.\n"),
5089 watchpoint_del_at_next_stop (b
);
5097 /* We've already printed what needs to be printed. */
5098 bs
->print_it
= print_it_done
;
5102 bs
->print_it
= print_it_noop
;
5105 case WP_VALUE_CHANGED
:
5106 if (b
->type
== bp_read_watchpoint
)
5108 /* There are two cases to consider here:
5110 1. We're watching the triggered memory for reads.
5111 In that case, trust the target, and always report
5112 the watchpoint hit to the user. Even though
5113 reads don't cause value changes, the value may
5114 have changed since the last time it was read, and
5115 since we're not trapping writes, we will not see
5116 those, and as such we should ignore our notion of
5119 2. We're watching the triggered memory for both
5120 reads and writes. There are two ways this may
5123 2.1. This is a target that can't break on data
5124 reads only, but can break on accesses (reads or
5125 writes), such as e.g., x86. We detect this case
5126 at the time we try to insert read watchpoints.
5128 2.2. Otherwise, the target supports read
5129 watchpoints, but, the user set an access or write
5130 watchpoint watching the same memory as this read
5133 If we're watching memory writes as well as reads,
5134 ignore watchpoint hits when we find that the
5135 value hasn't changed, as reads don't cause
5136 changes. This still gives false positives when
5137 the program writes the same value to memory as
5138 what there was already in memory (we will confuse
5139 it for a read), but it's much better than
5142 int other_write_watchpoint
= 0;
5144 if (bl
->watchpoint_type
== hw_read
)
5146 struct breakpoint
*other_b
;
5148 ALL_BREAKPOINTS (other_b
)
5149 if (other_b
->type
== bp_hardware_watchpoint
5150 || other_b
->type
== bp_access_watchpoint
)
5152 struct watchpoint
*other_w
=
5153 (struct watchpoint
*) other_b
;
5155 if (other_w
->watchpoint_triggered
5156 == watch_triggered_yes
)
5158 other_write_watchpoint
= 1;
5164 if (other_write_watchpoint
5165 || bl
->watchpoint_type
== hw_access
)
5167 /* We're watching the same memory for writes,
5168 and the value changed since the last time we
5169 updated it, so this trap must be for a write.
5171 bs
->print_it
= print_it_noop
;
5176 case WP_VALUE_NOT_CHANGED
:
5177 if (b
->type
== bp_hardware_watchpoint
5178 || b
->type
== bp_watchpoint
)
5180 /* Don't stop: write watchpoints shouldn't fire if
5181 the value hasn't changed. */
5182 bs
->print_it
= print_it_noop
;
5192 else /* must_check_value == 0 */
5194 /* This is a case where some watchpoint(s) triggered, but
5195 not at the address of this watchpoint, or else no
5196 watchpoint triggered after all. So don't print
5197 anything for this watchpoint. */
5198 bs
->print_it
= print_it_noop
;
5204 /* For breakpoints that are currently marked as telling gdb to stop,
5205 check conditions (condition proper, frame, thread and ignore count)
5206 of breakpoint referred to by BS. If we should not stop for this
5207 breakpoint, set BS->stop to 0. */
5210 bpstat_check_breakpoint_conditions (bpstat bs
, ptid_t ptid
)
5212 const struct bp_location
*bl
;
5213 struct breakpoint
*b
;
5215 bool condition_result
= true;
5216 struct expression
*cond
;
5218 gdb_assert (bs
->stop
);
5220 /* BS is built for existing struct breakpoint. */
5221 bl
= bs
->bp_location_at
;
5222 gdb_assert (bl
!= NULL
);
5223 b
= bs
->breakpoint_at
;
5224 gdb_assert (b
!= NULL
);
5226 /* Even if the target evaluated the condition on its end and notified GDB, we
5227 need to do so again since GDB does not know if we stopped due to a
5228 breakpoint or a single step breakpoint. */
5230 if (frame_id_p (b
->frame_id
)
5231 && !frame_id_eq (b
->frame_id
, get_stack_frame_id (get_current_frame ())))
5237 /* If this is a thread/task-specific breakpoint, don't waste cpu
5238 evaluating the condition if this isn't the specified
5240 if ((b
->thread
!= -1 && b
->thread
!= ptid_to_global_thread_id (ptid
))
5241 || (b
->task
!= 0 && b
->task
!= ada_get_task_number (ptid
)))
5248 /* Evaluate extension language breakpoints that have a "stop" method
5250 bs
->stop
= breakpoint_ext_lang_cond_says_stop (b
);
5252 if (is_watchpoint (b
))
5254 struct watchpoint
*w
= (struct watchpoint
*) b
;
5256 cond
= w
->cond_exp
.get ();
5259 cond
= bl
->cond
.get ();
5261 if (cond
&& b
->disposition
!= disp_del_at_next_stop
)
5263 int within_current_scope
= 1;
5264 struct watchpoint
* w
;
5266 /* We use value_mark and value_free_to_mark because it could
5267 be a long time before we return to the command level and
5268 call free_all_values. We can't call free_all_values
5269 because we might be in the middle of evaluating a
5271 struct value
*mark
= value_mark ();
5273 if (is_watchpoint (b
))
5274 w
= (struct watchpoint
*) b
;
5278 /* Need to select the frame, with all that implies so that
5279 the conditions will have the right context. Because we
5280 use the frame, we will not see an inlined function's
5281 variables when we arrive at a breakpoint at the start
5282 of the inlined function; the current frame will be the
5284 if (w
== NULL
|| w
->cond_exp_valid_block
== NULL
)
5285 select_frame (get_current_frame ());
5288 struct frame_info
*frame
;
5290 /* For local watchpoint expressions, which particular
5291 instance of a local is being watched matters, so we
5292 keep track of the frame to evaluate the expression
5293 in. To evaluate the condition however, it doesn't
5294 really matter which instantiation of the function
5295 where the condition makes sense triggers the
5296 watchpoint. This allows an expression like "watch
5297 global if q > 10" set in `func', catch writes to
5298 global on all threads that call `func', or catch
5299 writes on all recursive calls of `func' by a single
5300 thread. We simply always evaluate the condition in
5301 the innermost frame that's executing where it makes
5302 sense to evaluate the condition. It seems
5304 frame
= block_innermost_frame (w
->cond_exp_valid_block
);
5306 select_frame (frame
);
5308 within_current_scope
= 0;
5310 if (within_current_scope
)
5314 condition_result
= breakpoint_cond_eval (cond
);
5316 CATCH (ex
, RETURN_MASK_ALL
)
5318 exception_fprintf (gdb_stderr
, ex
,
5319 "Error in testing breakpoint condition:\n");
5325 warning (_("Watchpoint condition cannot be tested "
5326 "in the current scope"));
5327 /* If we failed to set the right context for this
5328 watchpoint, unconditionally report it. */
5330 /* FIXME-someday, should give breakpoint #. */
5331 value_free_to_mark (mark
);
5334 if (cond
&& !condition_result
)
5338 else if (b
->ignore_count
> 0)
5342 /* Increase the hit count even though we don't stop. */
5344 observer_notify_breakpoint_modified (b
);
5348 /* Returns true if we need to track moribund locations of LOC's type
5349 on the current target. */
5352 need_moribund_for_location_type (struct bp_location
*loc
)
5354 return ((loc
->loc_type
== bp_loc_software_breakpoint
5355 && !target_supports_stopped_by_sw_breakpoint ())
5356 || (loc
->loc_type
== bp_loc_hardware_breakpoint
5357 && !target_supports_stopped_by_hw_breakpoint ()));
5361 /* Get a bpstat associated with having just stopped at address
5362 BP_ADDR in thread PTID.
5364 Determine whether we stopped at a breakpoint, etc, or whether we
5365 don't understand this stop. Result is a chain of bpstat's such
5368 if we don't understand the stop, the result is a null pointer.
5370 if we understand why we stopped, the result is not null.
5372 Each element of the chain refers to a particular breakpoint or
5373 watchpoint at which we have stopped. (We may have stopped for
5374 several reasons concurrently.)
5376 Each element of the chain has valid next, breakpoint_at,
5377 commands, FIXME??? fields. */
5380 bpstat_stop_status (const address_space
*aspace
,
5381 CORE_ADDR bp_addr
, ptid_t ptid
,
5382 const struct target_waitstatus
*ws
)
5384 struct breakpoint
*b
= NULL
;
5385 struct bp_location
*bl
;
5386 struct bp_location
*loc
;
5387 /* First item of allocated bpstat's. */
5388 bpstat bs_head
= NULL
, *bs_link
= &bs_head
;
5389 /* Pointer to the last thing in the chain currently. */
5392 int need_remove_insert
;
5395 /* First, build the bpstat chain with locations that explain a
5396 target stop, while being careful to not set the target running,
5397 as that may invalidate locations (in particular watchpoint
5398 locations are recreated). Resuming will happen here with
5399 breakpoint conditions or watchpoint expressions that include
5400 inferior function calls. */
5404 if (!breakpoint_enabled (b
))
5407 for (bl
= b
->loc
; bl
!= NULL
; bl
= bl
->next
)
5409 /* For hardware watchpoints, we look only at the first
5410 location. The watchpoint_check function will work on the
5411 entire expression, not the individual locations. For
5412 read watchpoints, the watchpoints_triggered function has
5413 checked all locations already. */
5414 if (b
->type
== bp_hardware_watchpoint
&& bl
!= b
->loc
)
5417 if (!bl
->enabled
|| bl
->shlib_disabled
)
5420 if (!bpstat_check_location (bl
, aspace
, bp_addr
, ws
))
5423 /* Come here if it's a watchpoint, or if the break address
5426 bs
= new bpstats (bl
, &bs_link
); /* Alloc a bpstat to
5429 /* Assume we stop. Should we find a watchpoint that is not
5430 actually triggered, or if the condition of the breakpoint
5431 evaluates as false, we'll reset 'stop' to 0. */
5435 /* If this is a scope breakpoint, mark the associated
5436 watchpoint as triggered so that we will handle the
5437 out-of-scope event. We'll get to the watchpoint next
5439 if (b
->type
== bp_watchpoint_scope
&& b
->related_breakpoint
!= b
)
5441 struct watchpoint
*w
= (struct watchpoint
*) b
->related_breakpoint
;
5443 w
->watchpoint_triggered
= watch_triggered_yes
;
5448 /* Check if a moribund breakpoint explains the stop. */
5449 if (!target_supports_stopped_by_sw_breakpoint ()
5450 || !target_supports_stopped_by_hw_breakpoint ())
5452 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
5454 if (breakpoint_location_address_match (loc
, aspace
, bp_addr
)
5455 && need_moribund_for_location_type (loc
))
5457 bs
= new bpstats (loc
, &bs_link
);
5458 /* For hits of moribund locations, we should just proceed. */
5461 bs
->print_it
= print_it_noop
;
5466 /* A bit of special processing for shlib breakpoints. We need to
5467 process solib loading here, so that the lists of loaded and
5468 unloaded libraries are correct before we handle "catch load" and
5470 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5472 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->type
== bp_shlib_event
)
5474 handle_solib_event ();
5479 /* Now go through the locations that caused the target to stop, and
5480 check whether we're interested in reporting this stop to higher
5481 layers, or whether we should resume the target transparently. */
5485 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5490 b
= bs
->breakpoint_at
;
5491 b
->ops
->check_status (bs
);
5494 bpstat_check_breakpoint_conditions (bs
, ptid
);
5499 observer_notify_breakpoint_modified (b
);
5501 /* We will stop here. */
5502 if (b
->disposition
== disp_disable
)
5504 --(b
->enable_count
);
5505 if (b
->enable_count
<= 0)
5506 b
->enable_state
= bp_disabled
;
5511 bs
->commands
= b
->commands
;
5512 if (command_line_is_silent (bs
->commands
5513 ? bs
->commands
.get () : NULL
))
5516 b
->ops
->after_condition_true (bs
);
5521 /* Print nothing for this entry if we don't stop or don't
5523 if (!bs
->stop
|| !bs
->print
)
5524 bs
->print_it
= print_it_noop
;
5527 /* If we aren't stopping, the value of some hardware watchpoint may
5528 not have changed, but the intermediate memory locations we are
5529 watching may have. Don't bother if we're stopping; this will get
5531 need_remove_insert
= 0;
5532 if (! bpstat_causes_stop (bs_head
))
5533 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5535 && bs
->breakpoint_at
5536 && is_hardware_watchpoint (bs
->breakpoint_at
))
5538 struct watchpoint
*w
= (struct watchpoint
*) bs
->breakpoint_at
;
5540 update_watchpoint (w
, 0 /* don't reparse. */);
5541 need_remove_insert
= 1;
5544 if (need_remove_insert
)
5545 update_global_location_list (UGLL_MAY_INSERT
);
5546 else if (removed_any
)
5547 update_global_location_list (UGLL_DONT_INSERT
);
5553 handle_jit_event (void)
5555 struct frame_info
*frame
;
5556 struct gdbarch
*gdbarch
;
5559 fprintf_unfiltered (gdb_stdlog
, "handling bp_jit_event\n");
5561 /* Switch terminal for any messages produced by
5562 breakpoint_re_set. */
5563 target_terminal::ours_for_output ();
5565 frame
= get_current_frame ();
5566 gdbarch
= get_frame_arch (frame
);
5568 jit_event_handler (gdbarch
);
5570 target_terminal::inferior ();
5573 /* Prepare WHAT final decision for infrun. */
5575 /* Decide what infrun needs to do with this bpstat. */
5578 bpstat_what (bpstat bs_head
)
5580 struct bpstat_what retval
;
5583 retval
.main_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5584 retval
.call_dummy
= STOP_NONE
;
5585 retval
.is_longjmp
= 0;
5587 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5589 /* Extract this BS's action. After processing each BS, we check
5590 if its action overrides all we've seem so far. */
5591 enum bpstat_what_main_action this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5594 if (bs
->breakpoint_at
== NULL
)
5596 /* I suspect this can happen if it was a momentary
5597 breakpoint which has since been deleted. */
5601 bptype
= bs
->breakpoint_at
->type
;
5608 case bp_hardware_breakpoint
:
5609 case bp_single_step
:
5612 case bp_shlib_event
:
5616 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5618 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5621 this_action
= BPSTAT_WHAT_SINGLE
;
5624 case bp_hardware_watchpoint
:
5625 case bp_read_watchpoint
:
5626 case bp_access_watchpoint
:
5630 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5632 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5636 /* There was a watchpoint, but we're not stopping.
5637 This requires no further action. */
5641 case bp_longjmp_call_dummy
:
5645 this_action
= BPSTAT_WHAT_SET_LONGJMP_RESUME
;
5646 retval
.is_longjmp
= bptype
!= bp_exception
;
5649 this_action
= BPSTAT_WHAT_SINGLE
;
5651 case bp_longjmp_resume
:
5652 case bp_exception_resume
:
5655 this_action
= BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
;
5656 retval
.is_longjmp
= bptype
== bp_longjmp_resume
;
5659 this_action
= BPSTAT_WHAT_SINGLE
;
5661 case bp_step_resume
:
5663 this_action
= BPSTAT_WHAT_STEP_RESUME
;
5666 /* It is for the wrong frame. */
5667 this_action
= BPSTAT_WHAT_SINGLE
;
5670 case bp_hp_step_resume
:
5672 this_action
= BPSTAT_WHAT_HP_STEP_RESUME
;
5675 /* It is for the wrong frame. */
5676 this_action
= BPSTAT_WHAT_SINGLE
;
5679 case bp_watchpoint_scope
:
5680 case bp_thread_event
:
5681 case bp_overlay_event
:
5682 case bp_longjmp_master
:
5683 case bp_std_terminate_master
:
5684 case bp_exception_master
:
5685 this_action
= BPSTAT_WHAT_SINGLE
;
5691 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5693 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5697 /* There was a catchpoint, but we're not stopping.
5698 This requires no further action. */
5702 this_action
= BPSTAT_WHAT_SINGLE
;
5705 /* Make sure the action is stop (silent or noisy),
5706 so infrun.c pops the dummy frame. */
5707 retval
.call_dummy
= STOP_STACK_DUMMY
;
5708 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5710 case bp_std_terminate
:
5711 /* Make sure the action is stop (silent or noisy),
5712 so infrun.c pops the dummy frame. */
5713 retval
.call_dummy
= STOP_STD_TERMINATE
;
5714 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5717 case bp_fast_tracepoint
:
5718 case bp_static_tracepoint
:
5719 /* Tracepoint hits should not be reported back to GDB, and
5720 if one got through somehow, it should have been filtered
5722 internal_error (__FILE__
, __LINE__
,
5723 _("bpstat_what: tracepoint encountered"));
5725 case bp_gnu_ifunc_resolver
:
5726 /* Step over it (and insert bp_gnu_ifunc_resolver_return). */
5727 this_action
= BPSTAT_WHAT_SINGLE
;
5729 case bp_gnu_ifunc_resolver_return
:
5730 /* The breakpoint will be removed, execution will restart from the
5731 PC of the former breakpoint. */
5732 this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5737 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5739 this_action
= BPSTAT_WHAT_SINGLE
;
5743 internal_error (__FILE__
, __LINE__
,
5744 _("bpstat_what: unhandled bptype %d"), (int) bptype
);
5747 retval
.main_action
= std::max (retval
.main_action
, this_action
);
5754 bpstat_run_callbacks (bpstat bs_head
)
5758 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5760 struct breakpoint
*b
= bs
->breakpoint_at
;
5767 handle_jit_event ();
5769 case bp_gnu_ifunc_resolver
:
5770 gnu_ifunc_resolver_stop (b
);
5772 case bp_gnu_ifunc_resolver_return
:
5773 gnu_ifunc_resolver_return_stop (b
);
5779 /* Nonzero if we should step constantly (e.g. watchpoints on machines
5780 without hardware support). This isn't related to a specific bpstat,
5781 just to things like whether watchpoints are set. */
5784 bpstat_should_step (void)
5786 struct breakpoint
*b
;
5789 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
&& b
->loc
!= NULL
)
5795 bpstat_causes_stop (bpstat bs
)
5797 for (; bs
!= NULL
; bs
= bs
->next
)
5806 /* Compute a string of spaces suitable to indent the next line
5807 so it starts at the position corresponding to the table column
5808 named COL_NAME in the currently active table of UIOUT. */
5811 wrap_indent_at_field (struct ui_out
*uiout
, const char *col_name
)
5813 static char wrap_indent
[80];
5814 int i
, total_width
, width
, align
;
5818 for (i
= 1; uiout
->query_table_field (i
, &width
, &align
, &text
); i
++)
5820 if (strcmp (text
, col_name
) == 0)
5822 gdb_assert (total_width
< sizeof wrap_indent
);
5823 memset (wrap_indent
, ' ', total_width
);
5824 wrap_indent
[total_width
] = 0;
5829 total_width
+= width
+ 1;
5835 /* Determine if the locations of this breakpoint will have their conditions
5836 evaluated by the target, host or a mix of both. Returns the following:
5838 "host": Host evals condition.
5839 "host or target": Host or Target evals condition.
5840 "target": Target evals condition.
5844 bp_condition_evaluator (struct breakpoint
*b
)
5846 struct bp_location
*bl
;
5847 char host_evals
= 0;
5848 char target_evals
= 0;
5853 if (!is_breakpoint (b
))
5856 if (gdb_evaluates_breakpoint_condition_p ()
5857 || !target_supports_evaluation_of_breakpoint_conditions ())
5858 return condition_evaluation_host
;
5860 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
5862 if (bl
->cond_bytecode
)
5868 if (host_evals
&& target_evals
)
5869 return condition_evaluation_both
;
5870 else if (target_evals
)
5871 return condition_evaluation_target
;
5873 return condition_evaluation_host
;
5876 /* Determine the breakpoint location's condition evaluator. This is
5877 similar to bp_condition_evaluator, but for locations. */
5880 bp_location_condition_evaluator (struct bp_location
*bl
)
5882 if (bl
&& !is_breakpoint (bl
->owner
))
5885 if (gdb_evaluates_breakpoint_condition_p ()
5886 || !target_supports_evaluation_of_breakpoint_conditions ())
5887 return condition_evaluation_host
;
5889 if (bl
&& bl
->cond_bytecode
)
5890 return condition_evaluation_target
;
5892 return condition_evaluation_host
;
5895 /* Print the LOC location out of the list of B->LOC locations. */
5898 print_breakpoint_location (struct breakpoint
*b
,
5899 struct bp_location
*loc
)
5901 struct ui_out
*uiout
= current_uiout
;
5903 scoped_restore_current_program_space restore_pspace
;
5905 if (loc
!= NULL
&& loc
->shlib_disabled
)
5909 set_current_program_space (loc
->pspace
);
5911 if (b
->display_canonical
)
5912 uiout
->field_string ("what", event_location_to_string (b
->location
.get ()));
5913 else if (loc
&& loc
->symtab
)
5915 const struct symbol
*sym
= loc
->symbol
;
5918 sym
= find_pc_sect_function (loc
->address
, loc
->section
);
5922 uiout
->text ("in ");
5923 uiout
->field_string ("func", SYMBOL_PRINT_NAME (sym
));
5925 uiout
->wrap_hint (wrap_indent_at_field (uiout
, "what"));
5926 uiout
->text ("at ");
5928 uiout
->field_string ("file",
5929 symtab_to_filename_for_display (loc
->symtab
));
5932 if (uiout
->is_mi_like_p ())
5933 uiout
->field_string ("fullname", symtab_to_fullname (loc
->symtab
));
5935 uiout
->field_int ("line", loc
->line_number
);
5941 print_address_symbolic (loc
->gdbarch
, loc
->address
, &stb
,
5943 uiout
->field_stream ("at", stb
);
5947 uiout
->field_string ("pending",
5948 event_location_to_string (b
->location
.get ()));
5949 /* If extra_string is available, it could be holding a condition
5950 or dprintf arguments. In either case, make sure it is printed,
5951 too, but only for non-MI streams. */
5952 if (!uiout
->is_mi_like_p () && b
->extra_string
!= NULL
)
5954 if (b
->type
== bp_dprintf
)
5958 uiout
->text (b
->extra_string
);
5962 if (loc
&& is_breakpoint (b
)
5963 && breakpoint_condition_evaluation_mode () == condition_evaluation_target
5964 && bp_condition_evaluator (b
) == condition_evaluation_both
)
5967 uiout
->field_string ("evaluated-by",
5968 bp_location_condition_evaluator (loc
));
5974 bptype_string (enum bptype type
)
5976 struct ep_type_description
5979 const char *description
;
5981 static struct ep_type_description bptypes
[] =
5983 {bp_none
, "?deleted?"},
5984 {bp_breakpoint
, "breakpoint"},
5985 {bp_hardware_breakpoint
, "hw breakpoint"},
5986 {bp_single_step
, "sw single-step"},
5987 {bp_until
, "until"},
5988 {bp_finish
, "finish"},
5989 {bp_watchpoint
, "watchpoint"},
5990 {bp_hardware_watchpoint
, "hw watchpoint"},
5991 {bp_read_watchpoint
, "read watchpoint"},
5992 {bp_access_watchpoint
, "acc watchpoint"},
5993 {bp_longjmp
, "longjmp"},
5994 {bp_longjmp_resume
, "longjmp resume"},
5995 {bp_longjmp_call_dummy
, "longjmp for call dummy"},
5996 {bp_exception
, "exception"},
5997 {bp_exception_resume
, "exception resume"},
5998 {bp_step_resume
, "step resume"},
5999 {bp_hp_step_resume
, "high-priority step resume"},
6000 {bp_watchpoint_scope
, "watchpoint scope"},
6001 {bp_call_dummy
, "call dummy"},
6002 {bp_std_terminate
, "std::terminate"},
6003 {bp_shlib_event
, "shlib events"},
6004 {bp_thread_event
, "thread events"},
6005 {bp_overlay_event
, "overlay events"},
6006 {bp_longjmp_master
, "longjmp master"},
6007 {bp_std_terminate_master
, "std::terminate master"},
6008 {bp_exception_master
, "exception master"},
6009 {bp_catchpoint
, "catchpoint"},
6010 {bp_tracepoint
, "tracepoint"},
6011 {bp_fast_tracepoint
, "fast tracepoint"},
6012 {bp_static_tracepoint
, "static tracepoint"},
6013 {bp_dprintf
, "dprintf"},
6014 {bp_jit_event
, "jit events"},
6015 {bp_gnu_ifunc_resolver
, "STT_GNU_IFUNC resolver"},
6016 {bp_gnu_ifunc_resolver_return
, "STT_GNU_IFUNC resolver return"},
6019 if (((int) type
>= (sizeof (bptypes
) / sizeof (bptypes
[0])))
6020 || ((int) type
!= bptypes
[(int) type
].type
))
6021 internal_error (__FILE__
, __LINE__
,
6022 _("bptypes table does not describe type #%d."),
6025 return bptypes
[(int) type
].description
;
6028 /* For MI, output a field named 'thread-groups' with a list as the value.
6029 For CLI, prefix the list with the string 'inf'. */
6032 output_thread_groups (struct ui_out
*uiout
,
6033 const char *field_name
,
6037 int is_mi
= uiout
->is_mi_like_p ();
6041 /* For backward compatibility, don't display inferiors in CLI unless
6042 there are several. Always display them for MI. */
6043 if (!is_mi
&& mi_only
)
6046 ui_out_emit_list
list_emitter (uiout
, field_name
);
6048 for (i
= 0; VEC_iterate (int, inf_num
, i
, inf
); ++i
)
6054 xsnprintf (mi_group
, sizeof (mi_group
), "i%d", inf
);
6055 uiout
->field_string (NULL
, mi_group
);
6060 uiout
->text (" inf ");
6064 uiout
->text (plongest (inf
));
6069 /* Print B to gdb_stdout. */
6072 print_one_breakpoint_location (struct breakpoint
*b
,
6073 struct bp_location
*loc
,
6075 struct bp_location
**last_loc
,
6078 struct command_line
*l
;
6079 static char bpenables
[] = "nynny";
6081 struct ui_out
*uiout
= current_uiout
;
6082 int header_of_multiple
= 0;
6083 int part_of_multiple
= (loc
!= NULL
);
6084 struct value_print_options opts
;
6086 get_user_print_options (&opts
);
6088 gdb_assert (!loc
|| loc_number
!= 0);
6089 /* See comment in print_one_breakpoint concerning treatment of
6090 breakpoints with single disabled location. */
6093 && (b
->loc
->next
!= NULL
|| !b
->loc
->enabled
)))
6094 header_of_multiple
= 1;
6102 if (part_of_multiple
)
6105 formatted
= xstrprintf ("%d.%d", b
->number
, loc_number
);
6106 uiout
->field_string ("number", formatted
);
6111 uiout
->field_int ("number", b
->number
);
6116 if (part_of_multiple
)
6117 uiout
->field_skip ("type");
6119 uiout
->field_string ("type", bptype_string (b
->type
));
6123 if (part_of_multiple
)
6124 uiout
->field_skip ("disp");
6126 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
6131 if (part_of_multiple
)
6132 uiout
->field_string ("enabled", loc
->enabled
? "y" : "n");
6134 uiout
->field_fmt ("enabled", "%c", bpenables
[(int) b
->enable_state
]);
6139 if (b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
6141 /* Although the print_one can possibly print all locations,
6142 calling it here is not likely to get any nice result. So,
6143 make sure there's just one location. */
6144 gdb_assert (b
->loc
== NULL
|| b
->loc
->next
== NULL
);
6145 b
->ops
->print_one (b
, last_loc
);
6151 internal_error (__FILE__
, __LINE__
,
6152 _("print_one_breakpoint: bp_none encountered\n"));
6156 case bp_hardware_watchpoint
:
6157 case bp_read_watchpoint
:
6158 case bp_access_watchpoint
:
6160 struct watchpoint
*w
= (struct watchpoint
*) b
;
6162 /* Field 4, the address, is omitted (which makes the columns
6163 not line up too nicely with the headers, but the effect
6164 is relatively readable). */
6165 if (opts
.addressprint
)
6166 uiout
->field_skip ("addr");
6168 uiout
->field_string ("what", w
->exp_string
);
6173 case bp_hardware_breakpoint
:
6174 case bp_single_step
:
6178 case bp_longjmp_resume
:
6179 case bp_longjmp_call_dummy
:
6181 case bp_exception_resume
:
6182 case bp_step_resume
:
6183 case bp_hp_step_resume
:
6184 case bp_watchpoint_scope
:
6186 case bp_std_terminate
:
6187 case bp_shlib_event
:
6188 case bp_thread_event
:
6189 case bp_overlay_event
:
6190 case bp_longjmp_master
:
6191 case bp_std_terminate_master
:
6192 case bp_exception_master
:
6194 case bp_fast_tracepoint
:
6195 case bp_static_tracepoint
:
6198 case bp_gnu_ifunc_resolver
:
6199 case bp_gnu_ifunc_resolver_return
:
6200 if (opts
.addressprint
)
6203 if (header_of_multiple
)
6204 uiout
->field_string ("addr", "<MULTIPLE>");
6205 else if (b
->loc
== NULL
|| loc
->shlib_disabled
)
6206 uiout
->field_string ("addr", "<PENDING>");
6208 uiout
->field_core_addr ("addr",
6209 loc
->gdbarch
, loc
->address
);
6212 if (!header_of_multiple
)
6213 print_breakpoint_location (b
, loc
);
6220 if (loc
!= NULL
&& !header_of_multiple
)
6222 struct inferior
*inf
;
6223 VEC(int) *inf_num
= NULL
;
6228 if (inf
->pspace
== loc
->pspace
)
6229 VEC_safe_push (int, inf_num
, inf
->num
);
6232 /* For backward compatibility, don't display inferiors in CLI unless
6233 there are several. Always display for MI. */
6235 || (!gdbarch_has_global_breakpoints (target_gdbarch ())
6236 && (number_of_program_spaces () > 1
6237 || number_of_inferiors () > 1)
6238 /* LOC is for existing B, it cannot be in
6239 moribund_locations and thus having NULL OWNER. */
6240 && loc
->owner
->type
!= bp_catchpoint
))
6242 output_thread_groups (uiout
, "thread-groups", inf_num
, mi_only
);
6243 VEC_free (int, inf_num
);
6246 if (!part_of_multiple
)
6248 if (b
->thread
!= -1)
6250 /* FIXME: This seems to be redundant and lost here; see the
6251 "stop only in" line a little further down. */
6252 uiout
->text (" thread ");
6253 uiout
->field_int ("thread", b
->thread
);
6255 else if (b
->task
!= 0)
6257 uiout
->text (" task ");
6258 uiout
->field_int ("task", b
->task
);
6264 if (!part_of_multiple
)
6265 b
->ops
->print_one_detail (b
, uiout
);
6267 if (part_of_multiple
&& frame_id_p (b
->frame_id
))
6270 uiout
->text ("\tstop only in stack frame at ");
6271 /* FIXME: cagney/2002-12-01: Shouldn't be poking around inside
6273 uiout
->field_core_addr ("frame",
6274 b
->gdbarch
, b
->frame_id
.stack_addr
);
6278 if (!part_of_multiple
&& b
->cond_string
)
6281 if (is_tracepoint (b
))
6282 uiout
->text ("\ttrace only if ");
6284 uiout
->text ("\tstop only if ");
6285 uiout
->field_string ("cond", b
->cond_string
);
6287 /* Print whether the target is doing the breakpoint's condition
6288 evaluation. If GDB is doing the evaluation, don't print anything. */
6289 if (is_breakpoint (b
)
6290 && breakpoint_condition_evaluation_mode ()
6291 == condition_evaluation_target
)
6294 uiout
->field_string ("evaluated-by",
6295 bp_condition_evaluator (b
));
6296 uiout
->text (" evals)");
6301 if (!part_of_multiple
&& b
->thread
!= -1)
6303 /* FIXME should make an annotation for this. */
6304 uiout
->text ("\tstop only in thread ");
6305 if (uiout
->is_mi_like_p ())
6306 uiout
->field_int ("thread", b
->thread
);
6309 struct thread_info
*thr
= find_thread_global_id (b
->thread
);
6311 uiout
->field_string ("thread", print_thread_id (thr
));
6316 if (!part_of_multiple
)
6320 /* FIXME should make an annotation for this. */
6321 if (is_catchpoint (b
))
6322 uiout
->text ("\tcatchpoint");
6323 else if (is_tracepoint (b
))
6324 uiout
->text ("\ttracepoint");
6326 uiout
->text ("\tbreakpoint");
6327 uiout
->text (" already hit ");
6328 uiout
->field_int ("times", b
->hit_count
);
6329 if (b
->hit_count
== 1)
6330 uiout
->text (" time\n");
6332 uiout
->text (" times\n");
6336 /* Output the count also if it is zero, but only if this is mi. */
6337 if (uiout
->is_mi_like_p ())
6338 uiout
->field_int ("times", b
->hit_count
);
6342 if (!part_of_multiple
&& b
->ignore_count
)
6345 uiout
->text ("\tignore next ");
6346 uiout
->field_int ("ignore", b
->ignore_count
);
6347 uiout
->text (" hits\n");
6350 /* Note that an enable count of 1 corresponds to "enable once"
6351 behavior, which is reported by the combination of enablement and
6352 disposition, so we don't need to mention it here. */
6353 if (!part_of_multiple
&& b
->enable_count
> 1)
6356 uiout
->text ("\tdisable after ");
6357 /* Tweak the wording to clarify that ignore and enable counts
6358 are distinct, and have additive effect. */
6359 if (b
->ignore_count
)
6360 uiout
->text ("additional ");
6362 uiout
->text ("next ");
6363 uiout
->field_int ("enable", b
->enable_count
);
6364 uiout
->text (" hits\n");
6367 if (!part_of_multiple
&& is_tracepoint (b
))
6369 struct tracepoint
*tp
= (struct tracepoint
*) b
;
6371 if (tp
->traceframe_usage
)
6373 uiout
->text ("\ttrace buffer usage ");
6374 uiout
->field_int ("traceframe-usage", tp
->traceframe_usage
);
6375 uiout
->text (" bytes\n");
6379 l
= b
->commands
? b
->commands
.get () : NULL
;
6380 if (!part_of_multiple
&& l
)
6383 ui_out_emit_tuple
tuple_emitter (uiout
, "script");
6384 print_command_lines (uiout
, l
, 4);
6387 if (is_tracepoint (b
))
6389 struct tracepoint
*t
= (struct tracepoint
*) b
;
6391 if (!part_of_multiple
&& t
->pass_count
)
6393 annotate_field (10);
6394 uiout
->text ("\tpass count ");
6395 uiout
->field_int ("pass", t
->pass_count
);
6396 uiout
->text (" \n");
6399 /* Don't display it when tracepoint or tracepoint location is
6401 if (!header_of_multiple
&& loc
!= NULL
&& !loc
->shlib_disabled
)
6403 annotate_field (11);
6405 if (uiout
->is_mi_like_p ())
6406 uiout
->field_string ("installed",
6407 loc
->inserted
? "y" : "n");
6413 uiout
->text ("\tnot ");
6414 uiout
->text ("installed on target\n");
6419 if (uiout
->is_mi_like_p () && !part_of_multiple
)
6421 if (is_watchpoint (b
))
6423 struct watchpoint
*w
= (struct watchpoint
*) b
;
6425 uiout
->field_string ("original-location", w
->exp_string
);
6427 else if (b
->location
!= NULL
6428 && event_location_to_string (b
->location
.get ()) != NULL
)
6429 uiout
->field_string ("original-location",
6430 event_location_to_string (b
->location
.get ()));
6435 print_one_breakpoint (struct breakpoint
*b
,
6436 struct bp_location
**last_loc
,
6439 struct ui_out
*uiout
= current_uiout
;
6442 ui_out_emit_tuple
tuple_emitter (uiout
, "bkpt");
6444 print_one_breakpoint_location (b
, NULL
, 0, last_loc
, allflag
);
6447 /* If this breakpoint has custom print function,
6448 it's already printed. Otherwise, print individual
6449 locations, if any. */
6450 if (b
->ops
== NULL
|| b
->ops
->print_one
== NULL
)
6452 /* If breakpoint has a single location that is disabled, we
6453 print it as if it had several locations, since otherwise it's
6454 hard to represent "breakpoint enabled, location disabled"
6457 Note that while hardware watchpoints have several locations
6458 internally, that's not a property exposed to user. */
6460 && !is_hardware_watchpoint (b
)
6461 && (b
->loc
->next
|| !b
->loc
->enabled
))
6463 struct bp_location
*loc
;
6466 for (loc
= b
->loc
; loc
; loc
= loc
->next
, ++n
)
6468 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
6469 print_one_breakpoint_location (b
, loc
, n
, last_loc
, allflag
);
6476 breakpoint_address_bits (struct breakpoint
*b
)
6478 int print_address_bits
= 0;
6479 struct bp_location
*loc
;
6481 /* Software watchpoints that aren't watching memory don't have an
6482 address to print. */
6483 if (is_no_memory_software_watchpoint (b
))
6486 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
6490 addr_bit
= gdbarch_addr_bit (loc
->gdbarch
);
6491 if (addr_bit
> print_address_bits
)
6492 print_address_bits
= addr_bit
;
6495 return print_address_bits
;
6498 /* See breakpoint.h. */
6501 print_breakpoint (breakpoint
*b
)
6503 struct bp_location
*dummy_loc
= NULL
;
6504 print_one_breakpoint (b
, &dummy_loc
, 0);
6507 /* Return true if this breakpoint was set by the user, false if it is
6508 internal or momentary. */
6511 user_breakpoint_p (struct breakpoint
*b
)
6513 return b
->number
> 0;
6516 /* See breakpoint.h. */
6519 pending_breakpoint_p (struct breakpoint
*b
)
6521 return b
->loc
== NULL
;
6524 /* Print information on user settable breakpoint (watchpoint, etc)
6525 number BNUM. If BNUM is -1 print all user-settable breakpoints.
6526 If ALLFLAG is non-zero, include non-user-settable breakpoints. If
6527 FILTER is non-NULL, call it on each breakpoint and only include the
6528 ones for which it returns non-zero. Return the total number of
6529 breakpoints listed. */
6532 breakpoint_1 (const char *args
, int allflag
,
6533 int (*filter
) (const struct breakpoint
*))
6535 struct breakpoint
*b
;
6536 struct bp_location
*last_loc
= NULL
;
6537 int nr_printable_breakpoints
;
6538 struct value_print_options opts
;
6539 int print_address_bits
= 0;
6540 int print_type_col_width
= 14;
6541 struct ui_out
*uiout
= current_uiout
;
6543 get_user_print_options (&opts
);
6545 /* Compute the number of rows in the table, as well as the size
6546 required for address fields. */
6547 nr_printable_breakpoints
= 0;
6550 /* If we have a filter, only list the breakpoints it accepts. */
6551 if (filter
&& !filter (b
))
6554 /* If we have an "args" string, it is a list of breakpoints to
6555 accept. Skip the others. */
6556 if (args
!= NULL
&& *args
!= '\0')
6558 if (allflag
&& parse_and_eval_long (args
) != b
->number
)
6560 if (!allflag
&& !number_is_in_list (args
, b
->number
))
6564 if (allflag
|| user_breakpoint_p (b
))
6566 int addr_bit
, type_len
;
6568 addr_bit
= breakpoint_address_bits (b
);
6569 if (addr_bit
> print_address_bits
)
6570 print_address_bits
= addr_bit
;
6572 type_len
= strlen (bptype_string (b
->type
));
6573 if (type_len
> print_type_col_width
)
6574 print_type_col_width
= type_len
;
6576 nr_printable_breakpoints
++;
6581 ui_out_emit_table
table_emitter (uiout
,
6582 opts
.addressprint
? 6 : 5,
6583 nr_printable_breakpoints
,
6586 if (nr_printable_breakpoints
> 0)
6587 annotate_breakpoints_headers ();
6588 if (nr_printable_breakpoints
> 0)
6590 uiout
->table_header (7, ui_left
, "number", "Num"); /* 1 */
6591 if (nr_printable_breakpoints
> 0)
6593 uiout
->table_header (print_type_col_width
, ui_left
, "type", "Type"); /* 2 */
6594 if (nr_printable_breakpoints
> 0)
6596 uiout
->table_header (4, ui_left
, "disp", "Disp"); /* 3 */
6597 if (nr_printable_breakpoints
> 0)
6599 uiout
->table_header (3, ui_left
, "enabled", "Enb"); /* 4 */
6600 if (opts
.addressprint
)
6602 if (nr_printable_breakpoints
> 0)
6604 if (print_address_bits
<= 32)
6605 uiout
->table_header (10, ui_left
, "addr", "Address"); /* 5 */
6607 uiout
->table_header (18, ui_left
, "addr", "Address"); /* 5 */
6609 if (nr_printable_breakpoints
> 0)
6611 uiout
->table_header (40, ui_noalign
, "what", "What"); /* 6 */
6612 uiout
->table_body ();
6613 if (nr_printable_breakpoints
> 0)
6614 annotate_breakpoints_table ();
6619 /* If we have a filter, only list the breakpoints it accepts. */
6620 if (filter
&& !filter (b
))
6623 /* If we have an "args" string, it is a list of breakpoints to
6624 accept. Skip the others. */
6626 if (args
!= NULL
&& *args
!= '\0')
6628 if (allflag
) /* maintenance info breakpoint */
6630 if (parse_and_eval_long (args
) != b
->number
)
6633 else /* all others */
6635 if (!number_is_in_list (args
, b
->number
))
6639 /* We only print out user settable breakpoints unless the
6641 if (allflag
|| user_breakpoint_p (b
))
6642 print_one_breakpoint (b
, &last_loc
, allflag
);
6646 if (nr_printable_breakpoints
== 0)
6648 /* If there's a filter, let the caller decide how to report
6652 if (args
== NULL
|| *args
== '\0')
6653 uiout
->message ("No breakpoints or watchpoints.\n");
6655 uiout
->message ("No breakpoint or watchpoint matching '%s'.\n",
6661 if (last_loc
&& !server_command
)
6662 set_next_address (last_loc
->gdbarch
, last_loc
->address
);
6665 /* FIXME? Should this be moved up so that it is only called when
6666 there have been breakpoints? */
6667 annotate_breakpoints_table_end ();
6669 return nr_printable_breakpoints
;
6672 /* Display the value of default-collect in a way that is generally
6673 compatible with the breakpoint list. */
6676 default_collect_info (void)
6678 struct ui_out
*uiout
= current_uiout
;
6680 /* If it has no value (which is frequently the case), say nothing; a
6681 message like "No default-collect." gets in user's face when it's
6683 if (!*default_collect
)
6686 /* The following phrase lines up nicely with per-tracepoint collect
6688 uiout
->text ("default collect ");
6689 uiout
->field_string ("default-collect", default_collect
);
6690 uiout
->text (" \n");
6694 info_breakpoints_command (const char *args
, int from_tty
)
6696 breakpoint_1 (args
, 0, NULL
);
6698 default_collect_info ();
6702 info_watchpoints_command (const char *args
, int from_tty
)
6704 int num_printed
= breakpoint_1 (args
, 0, is_watchpoint
);
6705 struct ui_out
*uiout
= current_uiout
;
6707 if (num_printed
== 0)
6709 if (args
== NULL
|| *args
== '\0')
6710 uiout
->message ("No watchpoints.\n");
6712 uiout
->message ("No watchpoint matching '%s'.\n", args
);
6717 maintenance_info_breakpoints (const char *args
, int from_tty
)
6719 breakpoint_1 (args
, 1, NULL
);
6721 default_collect_info ();
6725 breakpoint_has_pc (struct breakpoint
*b
,
6726 struct program_space
*pspace
,
6727 CORE_ADDR pc
, struct obj_section
*section
)
6729 struct bp_location
*bl
= b
->loc
;
6731 for (; bl
; bl
= bl
->next
)
6733 if (bl
->pspace
== pspace
6734 && bl
->address
== pc
6735 && (!overlay_debugging
|| bl
->section
== section
))
6741 /* Print a message describing any user-breakpoints set at PC. This
6742 concerns with logical breakpoints, so we match program spaces, not
6746 describe_other_breakpoints (struct gdbarch
*gdbarch
,
6747 struct program_space
*pspace
, CORE_ADDR pc
,
6748 struct obj_section
*section
, int thread
)
6751 struct breakpoint
*b
;
6754 others
+= (user_breakpoint_p (b
)
6755 && breakpoint_has_pc (b
, pspace
, pc
, section
));
6759 printf_filtered (_("Note: breakpoint "));
6760 else /* if (others == ???) */
6761 printf_filtered (_("Note: breakpoints "));
6763 if (user_breakpoint_p (b
) && breakpoint_has_pc (b
, pspace
, pc
, section
))
6766 printf_filtered ("%d", b
->number
);
6767 if (b
->thread
== -1 && thread
!= -1)
6768 printf_filtered (" (all threads)");
6769 else if (b
->thread
!= -1)
6770 printf_filtered (" (thread %d)", b
->thread
);
6771 printf_filtered ("%s%s ",
6772 ((b
->enable_state
== bp_disabled
6773 || b
->enable_state
== bp_call_disabled
)
6777 : ((others
== 1) ? " and" : ""));
6779 printf_filtered (_("also set at pc "));
6780 fputs_filtered (paddress (gdbarch
, pc
), gdb_stdout
);
6781 printf_filtered (".\n");
6786 /* Return true iff it is meaningful to use the address member of
6787 BPT locations. For some breakpoint types, the locations' address members
6788 are irrelevant and it makes no sense to attempt to compare them to other
6789 addresses (or use them for any other purpose either).
6791 More specifically, each of the following breakpoint types will
6792 always have a zero valued location address and we don't want to mark
6793 breakpoints of any of these types to be a duplicate of an actual
6794 breakpoint location at address zero:
6802 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
6804 enum bptype type
= bpt
->type
;
6806 return (type
!= bp_watchpoint
&& type
!= bp_catchpoint
);
6809 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
6810 true if LOC1 and LOC2 represent the same watchpoint location. */
6813 watchpoint_locations_match (struct bp_location
*loc1
,
6814 struct bp_location
*loc2
)
6816 struct watchpoint
*w1
= (struct watchpoint
*) loc1
->owner
;
6817 struct watchpoint
*w2
= (struct watchpoint
*) loc2
->owner
;
6819 /* Both of them must exist. */
6820 gdb_assert (w1
!= NULL
);
6821 gdb_assert (w2
!= NULL
);
6823 /* If the target can evaluate the condition expression in hardware,
6824 then we we need to insert both watchpoints even if they are at
6825 the same place. Otherwise the watchpoint will only trigger when
6826 the condition of whichever watchpoint was inserted evaluates to
6827 true, not giving a chance for GDB to check the condition of the
6828 other watchpoint. */
6830 && target_can_accel_watchpoint_condition (loc1
->address
,
6832 loc1
->watchpoint_type
,
6833 w1
->cond_exp
.get ()))
6835 && target_can_accel_watchpoint_condition (loc2
->address
,
6837 loc2
->watchpoint_type
,
6838 w2
->cond_exp
.get ())))
6841 /* Note that this checks the owner's type, not the location's. In
6842 case the target does not support read watchpoints, but does
6843 support access watchpoints, we'll have bp_read_watchpoint
6844 watchpoints with hw_access locations. Those should be considered
6845 duplicates of hw_read locations. The hw_read locations will
6846 become hw_access locations later. */
6847 return (loc1
->owner
->type
== loc2
->owner
->type
6848 && loc1
->pspace
->aspace
== loc2
->pspace
->aspace
6849 && loc1
->address
== loc2
->address
6850 && loc1
->length
== loc2
->length
);
6853 /* See breakpoint.h. */
6856 breakpoint_address_match (const address_space
*aspace1
, CORE_ADDR addr1
,
6857 const address_space
*aspace2
, CORE_ADDR addr2
)
6859 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
6860 || aspace1
== aspace2
)
6864 /* Returns true if {ASPACE2,ADDR2} falls within the range determined by
6865 {ASPACE1,ADDR1,LEN1}. In most targets, this can only be true if ASPACE1
6866 matches ASPACE2. On targets that have global breakpoints, the address
6867 space doesn't really matter. */
6870 breakpoint_address_match_range (const address_space
*aspace1
,
6872 int len1
, const address_space
*aspace2
,
6875 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
6876 || aspace1
== aspace2
)
6877 && addr2
>= addr1
&& addr2
< addr1
+ len1
);
6880 /* Returns true if {ASPACE,ADDR} matches the breakpoint BL. BL may be
6881 a ranged breakpoint. In most targets, a match happens only if ASPACE
6882 matches the breakpoint's address space. On targets that have global
6883 breakpoints, the address space doesn't really matter. */
6886 breakpoint_location_address_match (struct bp_location
*bl
,
6887 const address_space
*aspace
,
6890 return (breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
6893 && breakpoint_address_match_range (bl
->pspace
->aspace
,
6894 bl
->address
, bl
->length
,
6898 /* Returns true if the [ADDR,ADDR+LEN) range in ASPACE overlaps
6899 breakpoint BL. BL may be a ranged breakpoint. In most targets, a
6900 match happens only if ASPACE matches the breakpoint's address
6901 space. On targets that have global breakpoints, the address space
6902 doesn't really matter. */
6905 breakpoint_location_address_range_overlap (struct bp_location
*bl
,
6906 const address_space
*aspace
,
6907 CORE_ADDR addr
, int len
)
6909 if (gdbarch_has_global_breakpoints (target_gdbarch ())
6910 || bl
->pspace
->aspace
== aspace
)
6912 int bl_len
= bl
->length
!= 0 ? bl
->length
: 1;
6914 if (mem_ranges_overlap (addr
, len
, bl
->address
, bl_len
))
6920 /* If LOC1 and LOC2's owners are not tracepoints, returns false directly.
6921 Then, if LOC1 and LOC2 represent the same tracepoint location, returns
6922 true, otherwise returns false. */
6925 tracepoint_locations_match (struct bp_location
*loc1
,
6926 struct bp_location
*loc2
)
6928 if (is_tracepoint (loc1
->owner
) && is_tracepoint (loc2
->owner
))
6929 /* Since tracepoint locations are never duplicated with others', tracepoint
6930 locations at the same address of different tracepoints are regarded as
6931 different locations. */
6932 return (loc1
->address
== loc2
->address
&& loc1
->owner
== loc2
->owner
);
6937 /* Assuming LOC1 and LOC2's types' have meaningful target addresses
6938 (breakpoint_address_is_meaningful), returns true if LOC1 and LOC2
6939 represent the same location. */
6942 breakpoint_locations_match (struct bp_location
*loc1
,
6943 struct bp_location
*loc2
)
6945 int hw_point1
, hw_point2
;
6947 /* Both of them must not be in moribund_locations. */
6948 gdb_assert (loc1
->owner
!= NULL
);
6949 gdb_assert (loc2
->owner
!= NULL
);
6951 hw_point1
= is_hardware_watchpoint (loc1
->owner
);
6952 hw_point2
= is_hardware_watchpoint (loc2
->owner
);
6954 if (hw_point1
!= hw_point2
)
6957 return watchpoint_locations_match (loc1
, loc2
);
6958 else if (is_tracepoint (loc1
->owner
) || is_tracepoint (loc2
->owner
))
6959 return tracepoint_locations_match (loc1
, loc2
);
6961 /* We compare bp_location.length in order to cover ranged breakpoints. */
6962 return (breakpoint_address_match (loc1
->pspace
->aspace
, loc1
->address
,
6963 loc2
->pspace
->aspace
, loc2
->address
)
6964 && loc1
->length
== loc2
->length
);
6968 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
6969 int bnum
, int have_bnum
)
6971 /* The longest string possibly returned by hex_string_custom
6972 is 50 chars. These must be at least that big for safety. */
6976 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
6977 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
6979 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
6980 bnum
, astr1
, astr2
);
6982 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
6985 /* Adjust a breakpoint's address to account for architectural
6986 constraints on breakpoint placement. Return the adjusted address.
6987 Note: Very few targets require this kind of adjustment. For most
6988 targets, this function is simply the identity function. */
6991 adjust_breakpoint_address (struct gdbarch
*gdbarch
,
6992 CORE_ADDR bpaddr
, enum bptype bptype
)
6994 if (!gdbarch_adjust_breakpoint_address_p (gdbarch
))
6996 /* Very few targets need any kind of breakpoint adjustment. */
6999 else if (bptype
== bp_watchpoint
7000 || bptype
== bp_hardware_watchpoint
7001 || bptype
== bp_read_watchpoint
7002 || bptype
== bp_access_watchpoint
7003 || bptype
== bp_catchpoint
)
7005 /* Watchpoints and the various bp_catch_* eventpoints should not
7006 have their addresses modified. */
7009 else if (bptype
== bp_single_step
)
7011 /* Single-step breakpoints should not have their addresses
7012 modified. If there's any architectural constrain that
7013 applies to this address, then it should have already been
7014 taken into account when the breakpoint was created in the
7015 first place. If we didn't do this, stepping through e.g.,
7016 Thumb-2 IT blocks would break. */
7021 CORE_ADDR adjusted_bpaddr
;
7023 /* Some targets have architectural constraints on the placement
7024 of breakpoint instructions. Obtain the adjusted address. */
7025 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (gdbarch
, bpaddr
);
7027 /* An adjusted breakpoint address can significantly alter
7028 a user's expectations. Print a warning if an adjustment
7030 if (adjusted_bpaddr
!= bpaddr
)
7031 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
7033 return adjusted_bpaddr
;
7037 bp_location::bp_location (const bp_location_ops
*ops
, breakpoint
*owner
)
7039 bp_location
*loc
= this;
7041 gdb_assert (ops
!= NULL
);
7045 loc
->cond_bytecode
= NULL
;
7046 loc
->shlib_disabled
= 0;
7049 switch (owner
->type
)
7052 case bp_single_step
:
7056 case bp_longjmp_resume
:
7057 case bp_longjmp_call_dummy
:
7059 case bp_exception_resume
:
7060 case bp_step_resume
:
7061 case bp_hp_step_resume
:
7062 case bp_watchpoint_scope
:
7064 case bp_std_terminate
:
7065 case bp_shlib_event
:
7066 case bp_thread_event
:
7067 case bp_overlay_event
:
7069 case bp_longjmp_master
:
7070 case bp_std_terminate_master
:
7071 case bp_exception_master
:
7072 case bp_gnu_ifunc_resolver
:
7073 case bp_gnu_ifunc_resolver_return
:
7075 loc
->loc_type
= bp_loc_software_breakpoint
;
7076 mark_breakpoint_location_modified (loc
);
7078 case bp_hardware_breakpoint
:
7079 loc
->loc_type
= bp_loc_hardware_breakpoint
;
7080 mark_breakpoint_location_modified (loc
);
7082 case bp_hardware_watchpoint
:
7083 case bp_read_watchpoint
:
7084 case bp_access_watchpoint
:
7085 loc
->loc_type
= bp_loc_hardware_watchpoint
;
7090 case bp_fast_tracepoint
:
7091 case bp_static_tracepoint
:
7092 loc
->loc_type
= bp_loc_other
;
7095 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
7101 /* Allocate a struct bp_location. */
7103 static struct bp_location
*
7104 allocate_bp_location (struct breakpoint
*bpt
)
7106 return bpt
->ops
->allocate_location (bpt
);
7110 free_bp_location (struct bp_location
*loc
)
7112 loc
->ops
->dtor (loc
);
7116 /* Increment reference count. */
7119 incref_bp_location (struct bp_location
*bl
)
7124 /* Decrement reference count. If the reference count reaches 0,
7125 destroy the bp_location. Sets *BLP to NULL. */
7128 decref_bp_location (struct bp_location
**blp
)
7130 gdb_assert ((*blp
)->refc
> 0);
7132 if (--(*blp
)->refc
== 0)
7133 free_bp_location (*blp
);
7137 /* Add breakpoint B at the end of the global breakpoint chain. */
7140 add_to_breakpoint_chain (std::unique_ptr
<breakpoint
> &&b
)
7142 struct breakpoint
*b1
;
7143 struct breakpoint
*result
= b
.get ();
7145 /* Add this breakpoint to the end of the chain so that a list of
7146 breakpoints will come out in order of increasing numbers. */
7148 b1
= breakpoint_chain
;
7150 breakpoint_chain
= b
.release ();
7155 b1
->next
= b
.release ();
7161 /* Initializes breakpoint B with type BPTYPE and no locations yet. */
7164 init_raw_breakpoint_without_location (struct breakpoint
*b
,
7165 struct gdbarch
*gdbarch
,
7167 const struct breakpoint_ops
*ops
)
7169 gdb_assert (ops
!= NULL
);
7173 b
->gdbarch
= gdbarch
;
7174 b
->language
= current_language
->la_language
;
7175 b
->input_radix
= input_radix
;
7176 b
->related_breakpoint
= b
;
7179 /* Helper to set_raw_breakpoint below. Creates a breakpoint
7180 that has type BPTYPE and has no locations as yet. */
7182 static struct breakpoint
*
7183 set_raw_breakpoint_without_location (struct gdbarch
*gdbarch
,
7185 const struct breakpoint_ops
*ops
)
7187 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (bptype
);
7189 init_raw_breakpoint_without_location (b
.get (), gdbarch
, bptype
, ops
);
7190 return add_to_breakpoint_chain (std::move (b
));
7193 /* Initialize loc->function_name. EXPLICIT_LOC says no indirect function
7194 resolutions should be made as the user specified the location explicitly
7198 set_breakpoint_location_function (struct bp_location
*loc
, int explicit_loc
)
7200 gdb_assert (loc
->owner
!= NULL
);
7202 if (loc
->owner
->type
== bp_breakpoint
7203 || loc
->owner
->type
== bp_hardware_breakpoint
7204 || is_tracepoint (loc
->owner
))
7207 const char *function_name
;
7208 CORE_ADDR func_addr
;
7210 find_pc_partial_function_gnu_ifunc (loc
->address
, &function_name
,
7211 &func_addr
, NULL
, &is_gnu_ifunc
);
7213 if (is_gnu_ifunc
&& !explicit_loc
)
7215 struct breakpoint
*b
= loc
->owner
;
7217 gdb_assert (loc
->pspace
== current_program_space
);
7218 if (gnu_ifunc_resolve_name (function_name
,
7219 &loc
->requested_address
))
7221 /* Recalculate ADDRESS based on new REQUESTED_ADDRESS. */
7222 loc
->address
= adjust_breakpoint_address (loc
->gdbarch
,
7223 loc
->requested_address
,
7226 else if (b
->type
== bp_breakpoint
&& b
->loc
== loc
7227 && loc
->next
== NULL
&& b
->related_breakpoint
== b
)
7229 /* Create only the whole new breakpoint of this type but do not
7230 mess more complicated breakpoints with multiple locations. */
7231 b
->type
= bp_gnu_ifunc_resolver
;
7232 /* Remember the resolver's address for use by the return
7234 loc
->related_address
= func_addr
;
7239 loc
->function_name
= xstrdup (function_name
);
7243 /* Attempt to determine architecture of location identified by SAL. */
7245 get_sal_arch (struct symtab_and_line sal
)
7248 return get_objfile_arch (sal
.section
->objfile
);
7250 return get_objfile_arch (SYMTAB_OBJFILE (sal
.symtab
));
7255 /* Low level routine for partially initializing a breakpoint of type
7256 BPTYPE. The newly created breakpoint's address, section, source
7257 file name, and line number are provided by SAL.
7259 It is expected that the caller will complete the initialization of
7260 the newly created breakpoint struct as well as output any status
7261 information regarding the creation of a new breakpoint. */
7264 init_raw_breakpoint (struct breakpoint
*b
, struct gdbarch
*gdbarch
,
7265 struct symtab_and_line sal
, enum bptype bptype
,
7266 const struct breakpoint_ops
*ops
)
7268 init_raw_breakpoint_without_location (b
, gdbarch
, bptype
, ops
);
7270 add_location_to_breakpoint (b
, &sal
);
7272 if (bptype
!= bp_catchpoint
)
7273 gdb_assert (sal
.pspace
!= NULL
);
7275 /* Store the program space that was used to set the breakpoint,
7276 except for ordinary breakpoints, which are independent of the
7278 if (bptype
!= bp_breakpoint
&& bptype
!= bp_hardware_breakpoint
)
7279 b
->pspace
= sal
.pspace
;
7282 /* set_raw_breakpoint is a low level routine for allocating and
7283 partially initializing a breakpoint of type BPTYPE. The newly
7284 created breakpoint's address, section, source file name, and line
7285 number are provided by SAL. The newly created and partially
7286 initialized breakpoint is added to the breakpoint chain and
7287 is also returned as the value of this function.
7289 It is expected that the caller will complete the initialization of
7290 the newly created breakpoint struct as well as output any status
7291 information regarding the creation of a new breakpoint. In
7292 particular, set_raw_breakpoint does NOT set the breakpoint
7293 number! Care should be taken to not allow an error to occur
7294 prior to completing the initialization of the breakpoint. If this
7295 should happen, a bogus breakpoint will be left on the chain. */
7298 set_raw_breakpoint (struct gdbarch
*gdbarch
,
7299 struct symtab_and_line sal
, enum bptype bptype
,
7300 const struct breakpoint_ops
*ops
)
7302 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (bptype
);
7304 init_raw_breakpoint (b
.get (), gdbarch
, sal
, bptype
, ops
);
7305 return add_to_breakpoint_chain (std::move (b
));
7308 /* Call this routine when stepping and nexting to enable a breakpoint
7309 if we do a longjmp() or 'throw' in TP. FRAME is the frame which
7310 initiated the operation. */
7313 set_longjmp_breakpoint (struct thread_info
*tp
, struct frame_id frame
)
7315 struct breakpoint
*b
, *b_tmp
;
7316 int thread
= tp
->global_num
;
7318 /* To avoid having to rescan all objfile symbols at every step,
7319 we maintain a list of continually-inserted but always disabled
7320 longjmp "master" breakpoints. Here, we simply create momentary
7321 clones of those and enable them for the requested thread. */
7322 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7323 if (b
->pspace
== current_program_space
7324 && (b
->type
== bp_longjmp_master
7325 || b
->type
== bp_exception_master
))
7327 enum bptype type
= b
->type
== bp_longjmp_master
? bp_longjmp
: bp_exception
;
7328 struct breakpoint
*clone
;
7330 /* longjmp_breakpoint_ops ensures INITIATING_FRAME is cleared again
7331 after their removal. */
7332 clone
= momentary_breakpoint_from_master (b
, type
,
7333 &momentary_breakpoint_ops
, 1);
7334 clone
->thread
= thread
;
7337 tp
->initiating_frame
= frame
;
7340 /* Delete all longjmp breakpoints from THREAD. */
7342 delete_longjmp_breakpoint (int thread
)
7344 struct breakpoint
*b
, *b_tmp
;
7346 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7347 if (b
->type
== bp_longjmp
|| b
->type
== bp_exception
)
7349 if (b
->thread
== thread
)
7350 delete_breakpoint (b
);
7355 delete_longjmp_breakpoint_at_next_stop (int thread
)
7357 struct breakpoint
*b
, *b_tmp
;
7359 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7360 if (b
->type
== bp_longjmp
|| b
->type
== bp_exception
)
7362 if (b
->thread
== thread
)
7363 b
->disposition
= disp_del_at_next_stop
;
7367 /* Place breakpoints of type bp_longjmp_call_dummy to catch longjmp for
7368 INFERIOR_PTID thread. Chain them all by RELATED_BREAKPOINT and return
7369 pointer to any of them. Return NULL if this system cannot place longjmp
7373 set_longjmp_breakpoint_for_call_dummy (void)
7375 struct breakpoint
*b
, *retval
= NULL
;
7378 if (b
->pspace
== current_program_space
&& b
->type
== bp_longjmp_master
)
7380 struct breakpoint
*new_b
;
7382 new_b
= momentary_breakpoint_from_master (b
, bp_longjmp_call_dummy
,
7383 &momentary_breakpoint_ops
,
7385 new_b
->thread
= ptid_to_global_thread_id (inferior_ptid
);
7387 /* Link NEW_B into the chain of RETVAL breakpoints. */
7389 gdb_assert (new_b
->related_breakpoint
== new_b
);
7392 new_b
->related_breakpoint
= retval
;
7393 while (retval
->related_breakpoint
!= new_b
->related_breakpoint
)
7394 retval
= retval
->related_breakpoint
;
7395 retval
->related_breakpoint
= new_b
;
7401 /* Verify all existing dummy frames and their associated breakpoints for
7402 TP. Remove those which can no longer be found in the current frame
7405 You should call this function only at places where it is safe to currently
7406 unwind the whole stack. Failed stack unwind would discard live dummy
7410 check_longjmp_breakpoint_for_call_dummy (struct thread_info
*tp
)
7412 struct breakpoint
*b
, *b_tmp
;
7414 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7415 if (b
->type
== bp_longjmp_call_dummy
&& b
->thread
== tp
->global_num
)
7417 struct breakpoint
*dummy_b
= b
->related_breakpoint
;
7419 while (dummy_b
!= b
&& dummy_b
->type
!= bp_call_dummy
)
7420 dummy_b
= dummy_b
->related_breakpoint
;
7421 if (dummy_b
->type
!= bp_call_dummy
7422 || frame_find_by_id (dummy_b
->frame_id
) != NULL
)
7425 dummy_frame_discard (dummy_b
->frame_id
, tp
->ptid
);
7427 while (b
->related_breakpoint
!= b
)
7429 if (b_tmp
== b
->related_breakpoint
)
7430 b_tmp
= b
->related_breakpoint
->next
;
7431 delete_breakpoint (b
->related_breakpoint
);
7433 delete_breakpoint (b
);
7438 enable_overlay_breakpoints (void)
7440 struct breakpoint
*b
;
7443 if (b
->type
== bp_overlay_event
)
7445 b
->enable_state
= bp_enabled
;
7446 update_global_location_list (UGLL_MAY_INSERT
);
7447 overlay_events_enabled
= 1;
7452 disable_overlay_breakpoints (void)
7454 struct breakpoint
*b
;
7457 if (b
->type
== bp_overlay_event
)
7459 b
->enable_state
= bp_disabled
;
7460 update_global_location_list (UGLL_DONT_INSERT
);
7461 overlay_events_enabled
= 0;
7465 /* Set an active std::terminate breakpoint for each std::terminate
7466 master breakpoint. */
7468 set_std_terminate_breakpoint (void)
7470 struct breakpoint
*b
, *b_tmp
;
7472 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7473 if (b
->pspace
== current_program_space
7474 && b
->type
== bp_std_terminate_master
)
7476 momentary_breakpoint_from_master (b
, bp_std_terminate
,
7477 &momentary_breakpoint_ops
, 1);
7481 /* Delete all the std::terminate breakpoints. */
7483 delete_std_terminate_breakpoint (void)
7485 struct breakpoint
*b
, *b_tmp
;
7487 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7488 if (b
->type
== bp_std_terminate
)
7489 delete_breakpoint (b
);
7493 create_thread_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7495 struct breakpoint
*b
;
7497 b
= create_internal_breakpoint (gdbarch
, address
, bp_thread_event
,
7498 &internal_breakpoint_ops
);
7500 b
->enable_state
= bp_enabled
;
7501 /* location has to be used or breakpoint_re_set will delete me. */
7502 b
->location
= new_address_location (b
->loc
->address
, NULL
, 0);
7504 update_global_location_list_nothrow (UGLL_MAY_INSERT
);
7509 struct lang_and_radix
7515 /* Create a breakpoint for JIT code registration and unregistration. */
7518 create_jit_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7520 return create_internal_breakpoint (gdbarch
, address
, bp_jit_event
,
7521 &internal_breakpoint_ops
);
7524 /* Remove JIT code registration and unregistration breakpoint(s). */
7527 remove_jit_event_breakpoints (void)
7529 struct breakpoint
*b
, *b_tmp
;
7531 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7532 if (b
->type
== bp_jit_event
7533 && b
->loc
->pspace
== current_program_space
)
7534 delete_breakpoint (b
);
7538 remove_solib_event_breakpoints (void)
7540 struct breakpoint
*b
, *b_tmp
;
7542 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7543 if (b
->type
== bp_shlib_event
7544 && b
->loc
->pspace
== current_program_space
)
7545 delete_breakpoint (b
);
7548 /* See breakpoint.h. */
7551 remove_solib_event_breakpoints_at_next_stop (void)
7553 struct breakpoint
*b
, *b_tmp
;
7555 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7556 if (b
->type
== bp_shlib_event
7557 && b
->loc
->pspace
== current_program_space
)
7558 b
->disposition
= disp_del_at_next_stop
;
7561 /* Helper for create_solib_event_breakpoint /
7562 create_and_insert_solib_event_breakpoint. Allows specifying which
7563 INSERT_MODE to pass through to update_global_location_list. */
7565 static struct breakpoint
*
7566 create_solib_event_breakpoint_1 (struct gdbarch
*gdbarch
, CORE_ADDR address
,
7567 enum ugll_insert_mode insert_mode
)
7569 struct breakpoint
*b
;
7571 b
= create_internal_breakpoint (gdbarch
, address
, bp_shlib_event
,
7572 &internal_breakpoint_ops
);
7573 update_global_location_list_nothrow (insert_mode
);
7578 create_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7580 return create_solib_event_breakpoint_1 (gdbarch
, address
, UGLL_MAY_INSERT
);
7583 /* See breakpoint.h. */
7586 create_and_insert_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7588 struct breakpoint
*b
;
7590 /* Explicitly tell update_global_location_list to insert
7592 b
= create_solib_event_breakpoint_1 (gdbarch
, address
, UGLL_INSERT
);
7593 if (!b
->loc
->inserted
)
7595 delete_breakpoint (b
);
7601 /* Disable any breakpoints that are on code in shared libraries. Only
7602 apply to enabled breakpoints, disabled ones can just stay disabled. */
7605 disable_breakpoints_in_shlibs (void)
7607 struct bp_location
*loc
, **locp_tmp
;
7609 ALL_BP_LOCATIONS (loc
, locp_tmp
)
7611 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7612 struct breakpoint
*b
= loc
->owner
;
7614 /* We apply the check to all breakpoints, including disabled for
7615 those with loc->duplicate set. This is so that when breakpoint
7616 becomes enabled, or the duplicate is removed, gdb will try to
7617 insert all breakpoints. If we don't set shlib_disabled here,
7618 we'll try to insert those breakpoints and fail. */
7619 if (((b
->type
== bp_breakpoint
)
7620 || (b
->type
== bp_jit_event
)
7621 || (b
->type
== bp_hardware_breakpoint
)
7622 || (is_tracepoint (b
)))
7623 && loc
->pspace
== current_program_space
7624 && !loc
->shlib_disabled
7625 && solib_name_from_address (loc
->pspace
, loc
->address
)
7628 loc
->shlib_disabled
= 1;
7633 /* Disable any breakpoints and tracepoints that are in SOLIB upon
7634 notification of unloaded_shlib. Only apply to enabled breakpoints,
7635 disabled ones can just stay disabled. */
7638 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
7640 struct bp_location
*loc
, **locp_tmp
;
7641 int disabled_shlib_breaks
= 0;
7643 ALL_BP_LOCATIONS (loc
, locp_tmp
)
7645 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7646 struct breakpoint
*b
= loc
->owner
;
7648 if (solib
->pspace
== loc
->pspace
7649 && !loc
->shlib_disabled
7650 && (((b
->type
== bp_breakpoint
7651 || b
->type
== bp_jit_event
7652 || b
->type
== bp_hardware_breakpoint
)
7653 && (loc
->loc_type
== bp_loc_hardware_breakpoint
7654 || loc
->loc_type
== bp_loc_software_breakpoint
))
7655 || is_tracepoint (b
))
7656 && solib_contains_address_p (solib
, loc
->address
))
7658 loc
->shlib_disabled
= 1;
7659 /* At this point, we cannot rely on remove_breakpoint
7660 succeeding so we must mark the breakpoint as not inserted
7661 to prevent future errors occurring in remove_breakpoints. */
7664 /* This may cause duplicate notifications for the same breakpoint. */
7665 observer_notify_breakpoint_modified (b
);
7667 if (!disabled_shlib_breaks
)
7669 target_terminal::ours_for_output ();
7670 warning (_("Temporarily disabling breakpoints "
7671 "for unloaded shared library \"%s\""),
7674 disabled_shlib_breaks
= 1;
7679 /* Disable any breakpoints and tracepoints in OBJFILE upon
7680 notification of free_objfile. Only apply to enabled breakpoints,
7681 disabled ones can just stay disabled. */
7684 disable_breakpoints_in_freed_objfile (struct objfile
*objfile
)
7686 struct breakpoint
*b
;
7688 if (objfile
== NULL
)
7691 /* OBJF_SHARED|OBJF_USERLOADED objfiles are dynamic modules manually
7692 managed by the user with add-symbol-file/remove-symbol-file.
7693 Similarly to how breakpoints in shared libraries are handled in
7694 response to "nosharedlibrary", mark breakpoints in such modules
7695 shlib_disabled so they end up uninserted on the next global
7696 location list update. Shared libraries not loaded by the user
7697 aren't handled here -- they're already handled in
7698 disable_breakpoints_in_unloaded_shlib, called by solib.c's
7699 solib_unloaded observer. We skip objfiles that are not
7700 OBJF_SHARED as those aren't considered dynamic objects (e.g. the
7702 if ((objfile
->flags
& OBJF_SHARED
) == 0
7703 || (objfile
->flags
& OBJF_USERLOADED
) == 0)
7708 struct bp_location
*loc
;
7709 int bp_modified
= 0;
7711 if (!is_breakpoint (b
) && !is_tracepoint (b
))
7714 for (loc
= b
->loc
; loc
!= NULL
; loc
= loc
->next
)
7716 CORE_ADDR loc_addr
= loc
->address
;
7718 if (loc
->loc_type
!= bp_loc_hardware_breakpoint
7719 && loc
->loc_type
!= bp_loc_software_breakpoint
)
7722 if (loc
->shlib_disabled
!= 0)
7725 if (objfile
->pspace
!= loc
->pspace
)
7728 if (loc
->loc_type
!= bp_loc_hardware_breakpoint
7729 && loc
->loc_type
!= bp_loc_software_breakpoint
)
7732 if (is_addr_in_objfile (loc_addr
, objfile
))
7734 loc
->shlib_disabled
= 1;
7735 /* At this point, we don't know whether the object was
7736 unmapped from the inferior or not, so leave the
7737 inserted flag alone. We'll handle failure to
7738 uninsert quietly, in case the object was indeed
7741 mark_breakpoint_location_modified (loc
);
7748 observer_notify_breakpoint_modified (b
);
7752 /* FORK & VFORK catchpoints. */
7754 /* An instance of this type is used to represent a fork or vfork
7755 catchpoint. A breakpoint is really of this type iff its ops pointer points
7756 to CATCH_FORK_BREAKPOINT_OPS. */
7758 struct fork_catchpoint
: public breakpoint
7760 /* Process id of a child process whose forking triggered this
7761 catchpoint. This field is only valid immediately after this
7762 catchpoint has triggered. */
7763 ptid_t forked_inferior_pid
;
7766 /* Implement the "insert" breakpoint_ops method for fork
7770 insert_catch_fork (struct bp_location
*bl
)
7772 return target_insert_fork_catchpoint (ptid_get_pid (inferior_ptid
));
7775 /* Implement the "remove" breakpoint_ops method for fork
7779 remove_catch_fork (struct bp_location
*bl
, enum remove_bp_reason reason
)
7781 return target_remove_fork_catchpoint (ptid_get_pid (inferior_ptid
));
7784 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
7788 breakpoint_hit_catch_fork (const struct bp_location
*bl
,
7789 const address_space
*aspace
, CORE_ADDR bp_addr
,
7790 const struct target_waitstatus
*ws
)
7792 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bl
->owner
;
7794 if (ws
->kind
!= TARGET_WAITKIND_FORKED
)
7797 c
->forked_inferior_pid
= ws
->value
.related_pid
;
7801 /* Implement the "print_it" breakpoint_ops method for fork
7804 static enum print_stop_action
7805 print_it_catch_fork (bpstat bs
)
7807 struct ui_out
*uiout
= current_uiout
;
7808 struct breakpoint
*b
= bs
->breakpoint_at
;
7809 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bs
->breakpoint_at
;
7811 annotate_catchpoint (b
->number
);
7812 maybe_print_thread_hit_breakpoint (uiout
);
7813 if (b
->disposition
== disp_del
)
7814 uiout
->text ("Temporary catchpoint ");
7816 uiout
->text ("Catchpoint ");
7817 if (uiout
->is_mi_like_p ())
7819 uiout
->field_string ("reason", async_reason_lookup (EXEC_ASYNC_FORK
));
7820 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
7822 uiout
->field_int ("bkptno", b
->number
);
7823 uiout
->text (" (forked process ");
7824 uiout
->field_int ("newpid", ptid_get_pid (c
->forked_inferior_pid
));
7825 uiout
->text ("), ");
7826 return PRINT_SRC_AND_LOC
;
7829 /* Implement the "print_one" breakpoint_ops method for fork
7833 print_one_catch_fork (struct breakpoint
*b
, struct bp_location
**last_loc
)
7835 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
7836 struct value_print_options opts
;
7837 struct ui_out
*uiout
= current_uiout
;
7839 get_user_print_options (&opts
);
7841 /* Field 4, the address, is omitted (which makes the columns not
7842 line up too nicely with the headers, but the effect is relatively
7844 if (opts
.addressprint
)
7845 uiout
->field_skip ("addr");
7847 uiout
->text ("fork");
7848 if (!ptid_equal (c
->forked_inferior_pid
, null_ptid
))
7850 uiout
->text (", process ");
7851 uiout
->field_int ("what", ptid_get_pid (c
->forked_inferior_pid
));
7855 if (uiout
->is_mi_like_p ())
7856 uiout
->field_string ("catch-type", "fork");
7859 /* Implement the "print_mention" breakpoint_ops method for fork
7863 print_mention_catch_fork (struct breakpoint
*b
)
7865 printf_filtered (_("Catchpoint %d (fork)"), b
->number
);
7868 /* Implement the "print_recreate" breakpoint_ops method for fork
7872 print_recreate_catch_fork (struct breakpoint
*b
, struct ui_file
*fp
)
7874 fprintf_unfiltered (fp
, "catch fork");
7875 print_recreate_thread (b
, fp
);
7878 /* The breakpoint_ops structure to be used in fork catchpoints. */
7880 static struct breakpoint_ops catch_fork_breakpoint_ops
;
7882 /* Implement the "insert" breakpoint_ops method for vfork
7886 insert_catch_vfork (struct bp_location
*bl
)
7888 return target_insert_vfork_catchpoint (ptid_get_pid (inferior_ptid
));
7891 /* Implement the "remove" breakpoint_ops method for vfork
7895 remove_catch_vfork (struct bp_location
*bl
, enum remove_bp_reason reason
)
7897 return target_remove_vfork_catchpoint (ptid_get_pid (inferior_ptid
));
7900 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
7904 breakpoint_hit_catch_vfork (const struct bp_location
*bl
,
7905 const address_space
*aspace
, CORE_ADDR bp_addr
,
7906 const struct target_waitstatus
*ws
)
7908 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bl
->owner
;
7910 if (ws
->kind
!= TARGET_WAITKIND_VFORKED
)
7913 c
->forked_inferior_pid
= ws
->value
.related_pid
;
7917 /* Implement the "print_it" breakpoint_ops method for vfork
7920 static enum print_stop_action
7921 print_it_catch_vfork (bpstat bs
)
7923 struct ui_out
*uiout
= current_uiout
;
7924 struct breakpoint
*b
= bs
->breakpoint_at
;
7925 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
7927 annotate_catchpoint (b
->number
);
7928 maybe_print_thread_hit_breakpoint (uiout
);
7929 if (b
->disposition
== disp_del
)
7930 uiout
->text ("Temporary catchpoint ");
7932 uiout
->text ("Catchpoint ");
7933 if (uiout
->is_mi_like_p ())
7935 uiout
->field_string ("reason", async_reason_lookup (EXEC_ASYNC_VFORK
));
7936 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
7938 uiout
->field_int ("bkptno", b
->number
);
7939 uiout
->text (" (vforked process ");
7940 uiout
->field_int ("newpid", ptid_get_pid (c
->forked_inferior_pid
));
7941 uiout
->text ("), ");
7942 return PRINT_SRC_AND_LOC
;
7945 /* Implement the "print_one" breakpoint_ops method for vfork
7949 print_one_catch_vfork (struct breakpoint
*b
, struct bp_location
**last_loc
)
7951 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
7952 struct value_print_options opts
;
7953 struct ui_out
*uiout
= current_uiout
;
7955 get_user_print_options (&opts
);
7956 /* Field 4, the address, is omitted (which makes the columns not
7957 line up too nicely with the headers, but the effect is relatively
7959 if (opts
.addressprint
)
7960 uiout
->field_skip ("addr");
7962 uiout
->text ("vfork");
7963 if (!ptid_equal (c
->forked_inferior_pid
, null_ptid
))
7965 uiout
->text (", process ");
7966 uiout
->field_int ("what", ptid_get_pid (c
->forked_inferior_pid
));
7970 if (uiout
->is_mi_like_p ())
7971 uiout
->field_string ("catch-type", "vfork");
7974 /* Implement the "print_mention" breakpoint_ops method for vfork
7978 print_mention_catch_vfork (struct breakpoint
*b
)
7980 printf_filtered (_("Catchpoint %d (vfork)"), b
->number
);
7983 /* Implement the "print_recreate" breakpoint_ops method for vfork
7987 print_recreate_catch_vfork (struct breakpoint
*b
, struct ui_file
*fp
)
7989 fprintf_unfiltered (fp
, "catch vfork");
7990 print_recreate_thread (b
, fp
);
7993 /* The breakpoint_ops structure to be used in vfork catchpoints. */
7995 static struct breakpoint_ops catch_vfork_breakpoint_ops
;
7997 /* An instance of this type is used to represent an solib catchpoint.
7998 A breakpoint is really of this type iff its ops pointer points to
7999 CATCH_SOLIB_BREAKPOINT_OPS. */
8001 struct solib_catchpoint
: public breakpoint
8003 ~solib_catchpoint () override
;
8005 /* True for "catch load", false for "catch unload". */
8006 unsigned char is_load
;
8008 /* Regular expression to match, if any. COMPILED is only valid when
8009 REGEX is non-NULL. */
8011 std::unique_ptr
<compiled_regex
> compiled
;
8014 solib_catchpoint::~solib_catchpoint ()
8016 xfree (this->regex
);
8020 insert_catch_solib (struct bp_location
*ignore
)
8026 remove_catch_solib (struct bp_location
*ignore
, enum remove_bp_reason reason
)
8032 breakpoint_hit_catch_solib (const struct bp_location
*bl
,
8033 const address_space
*aspace
,
8035 const struct target_waitstatus
*ws
)
8037 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) bl
->owner
;
8038 struct breakpoint
*other
;
8040 if (ws
->kind
== TARGET_WAITKIND_LOADED
)
8043 ALL_BREAKPOINTS (other
)
8045 struct bp_location
*other_bl
;
8047 if (other
== bl
->owner
)
8050 if (other
->type
!= bp_shlib_event
)
8053 if (self
->pspace
!= NULL
&& other
->pspace
!= self
->pspace
)
8056 for (other_bl
= other
->loc
; other_bl
!= NULL
; other_bl
= other_bl
->next
)
8058 if (other
->ops
->breakpoint_hit (other_bl
, aspace
, bp_addr
, ws
))
8067 check_status_catch_solib (struct bpstats
*bs
)
8069 struct solib_catchpoint
*self
8070 = (struct solib_catchpoint
*) bs
->breakpoint_at
;
8075 struct so_list
*iter
;
8078 VEC_iterate (so_list_ptr
, current_program_space
->added_solibs
,
8083 || self
->compiled
->exec (iter
->so_name
, 0, NULL
, 0) == 0)
8092 VEC_iterate (char_ptr
, current_program_space
->deleted_solibs
,
8097 || self
->compiled
->exec (iter
, 0, NULL
, 0) == 0)
8103 bs
->print_it
= print_it_noop
;
8106 static enum print_stop_action
8107 print_it_catch_solib (bpstat bs
)
8109 struct breakpoint
*b
= bs
->breakpoint_at
;
8110 struct ui_out
*uiout
= current_uiout
;
8112 annotate_catchpoint (b
->number
);
8113 maybe_print_thread_hit_breakpoint (uiout
);
8114 if (b
->disposition
== disp_del
)
8115 uiout
->text ("Temporary catchpoint ");
8117 uiout
->text ("Catchpoint ");
8118 uiout
->field_int ("bkptno", b
->number
);
8120 if (uiout
->is_mi_like_p ())
8121 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
8122 print_solib_event (1);
8123 return PRINT_SRC_AND_LOC
;
8127 print_one_catch_solib (struct breakpoint
*b
, struct bp_location
**locs
)
8129 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8130 struct value_print_options opts
;
8131 struct ui_out
*uiout
= current_uiout
;
8134 get_user_print_options (&opts
);
8135 /* Field 4, the address, is omitted (which makes the columns not
8136 line up too nicely with the headers, but the effect is relatively
8138 if (opts
.addressprint
)
8141 uiout
->field_skip ("addr");
8148 msg
= xstrprintf (_("load of library matching %s"), self
->regex
);
8150 msg
= xstrdup (_("load of library"));
8155 msg
= xstrprintf (_("unload of library matching %s"), self
->regex
);
8157 msg
= xstrdup (_("unload of library"));
8159 uiout
->field_string ("what", msg
);
8162 if (uiout
->is_mi_like_p ())
8163 uiout
->field_string ("catch-type", self
->is_load
? "load" : "unload");
8167 print_mention_catch_solib (struct breakpoint
*b
)
8169 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8171 printf_filtered (_("Catchpoint %d (%s)"), b
->number
,
8172 self
->is_load
? "load" : "unload");
8176 print_recreate_catch_solib (struct breakpoint
*b
, struct ui_file
*fp
)
8178 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8180 fprintf_unfiltered (fp
, "%s %s",
8181 b
->disposition
== disp_del
? "tcatch" : "catch",
8182 self
->is_load
? "load" : "unload");
8184 fprintf_unfiltered (fp
, " %s", self
->regex
);
8185 fprintf_unfiltered (fp
, "\n");
8188 static struct breakpoint_ops catch_solib_breakpoint_ops
;
8190 /* Shared helper function (MI and CLI) for creating and installing
8191 a shared object event catchpoint. If IS_LOAD is non-zero then
8192 the events to be caught are load events, otherwise they are
8193 unload events. If IS_TEMP is non-zero the catchpoint is a
8194 temporary one. If ENABLED is non-zero the catchpoint is
8195 created in an enabled state. */
8198 add_solib_catchpoint (const char *arg
, int is_load
, int is_temp
, int enabled
)
8200 struct gdbarch
*gdbarch
= get_current_arch ();
8204 arg
= skip_spaces (arg
);
8206 std::unique_ptr
<solib_catchpoint
> c (new solib_catchpoint ());
8210 c
->compiled
.reset (new compiled_regex (arg
, REG_NOSUB
,
8211 _("Invalid regexp")));
8212 c
->regex
= xstrdup (arg
);
8215 c
->is_load
= is_load
;
8216 init_catchpoint (c
.get (), gdbarch
, is_temp
, NULL
,
8217 &catch_solib_breakpoint_ops
);
8219 c
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
8221 install_breakpoint (0, std::move (c
), 1);
8224 /* A helper function that does all the work for "catch load" and
8228 catch_load_or_unload (const char *arg
, int from_tty
, int is_load
,
8229 struct cmd_list_element
*command
)
8232 const int enabled
= 1;
8234 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
8236 add_solib_catchpoint (arg
, is_load
, tempflag
, enabled
);
8240 catch_load_command_1 (const char *arg
, int from_tty
,
8241 struct cmd_list_element
*command
)
8243 catch_load_or_unload (arg
, from_tty
, 1, command
);
8247 catch_unload_command_1 (const char *arg
, int from_tty
,
8248 struct cmd_list_element
*command
)
8250 catch_load_or_unload (arg
, from_tty
, 0, command
);
8253 /* Initialize a new breakpoint of the bp_catchpoint kind. If TEMPFLAG
8254 is non-zero, then make the breakpoint temporary. If COND_STRING is
8255 not NULL, then store it in the breakpoint. OPS, if not NULL, is
8256 the breakpoint_ops structure associated to the catchpoint. */
8259 init_catchpoint (struct breakpoint
*b
,
8260 struct gdbarch
*gdbarch
, int tempflag
,
8261 const char *cond_string
,
8262 const struct breakpoint_ops
*ops
)
8264 symtab_and_line sal
;
8265 sal
.pspace
= current_program_space
;
8267 init_raw_breakpoint (b
, gdbarch
, sal
, bp_catchpoint
, ops
);
8269 b
->cond_string
= (cond_string
== NULL
) ? NULL
: xstrdup (cond_string
);
8270 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
8274 install_breakpoint (int internal
, std::unique_ptr
<breakpoint
> &&arg
, int update_gll
)
8276 breakpoint
*b
= add_to_breakpoint_chain (std::move (arg
));
8277 set_breakpoint_number (internal
, b
);
8278 if (is_tracepoint (b
))
8279 set_tracepoint_count (breakpoint_count
);
8282 observer_notify_breakpoint_created (b
);
8285 update_global_location_list (UGLL_MAY_INSERT
);
8289 create_fork_vfork_event_catchpoint (struct gdbarch
*gdbarch
,
8290 int tempflag
, const char *cond_string
,
8291 const struct breakpoint_ops
*ops
)
8293 std::unique_ptr
<fork_catchpoint
> c (new fork_catchpoint ());
8295 init_catchpoint (c
.get (), gdbarch
, tempflag
, cond_string
, ops
);
8297 c
->forked_inferior_pid
= null_ptid
;
8299 install_breakpoint (0, std::move (c
), 1);
8302 /* Exec catchpoints. */
8304 /* An instance of this type is used to represent an exec catchpoint.
8305 A breakpoint is really of this type iff its ops pointer points to
8306 CATCH_EXEC_BREAKPOINT_OPS. */
8308 struct exec_catchpoint
: public breakpoint
8310 ~exec_catchpoint () override
;
8312 /* Filename of a program whose exec triggered this catchpoint.
8313 This field is only valid immediately after this catchpoint has
8315 char *exec_pathname
;
8318 /* Exec catchpoint destructor. */
8320 exec_catchpoint::~exec_catchpoint ()
8322 xfree (this->exec_pathname
);
8326 insert_catch_exec (struct bp_location
*bl
)
8328 return target_insert_exec_catchpoint (ptid_get_pid (inferior_ptid
));
8332 remove_catch_exec (struct bp_location
*bl
, enum remove_bp_reason reason
)
8334 return target_remove_exec_catchpoint (ptid_get_pid (inferior_ptid
));
8338 breakpoint_hit_catch_exec (const struct bp_location
*bl
,
8339 const address_space
*aspace
, CORE_ADDR bp_addr
,
8340 const struct target_waitstatus
*ws
)
8342 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) bl
->owner
;
8344 if (ws
->kind
!= TARGET_WAITKIND_EXECD
)
8347 c
->exec_pathname
= xstrdup (ws
->value
.execd_pathname
);
8351 static enum print_stop_action
8352 print_it_catch_exec (bpstat bs
)
8354 struct ui_out
*uiout
= current_uiout
;
8355 struct breakpoint
*b
= bs
->breakpoint_at
;
8356 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
8358 annotate_catchpoint (b
->number
);
8359 maybe_print_thread_hit_breakpoint (uiout
);
8360 if (b
->disposition
== disp_del
)
8361 uiout
->text ("Temporary catchpoint ");
8363 uiout
->text ("Catchpoint ");
8364 if (uiout
->is_mi_like_p ())
8366 uiout
->field_string ("reason", async_reason_lookup (EXEC_ASYNC_EXEC
));
8367 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
8369 uiout
->field_int ("bkptno", b
->number
);
8370 uiout
->text (" (exec'd ");
8371 uiout
->field_string ("new-exec", c
->exec_pathname
);
8372 uiout
->text ("), ");
8374 return PRINT_SRC_AND_LOC
;
8378 print_one_catch_exec (struct breakpoint
*b
, struct bp_location
**last_loc
)
8380 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
8381 struct value_print_options opts
;
8382 struct ui_out
*uiout
= current_uiout
;
8384 get_user_print_options (&opts
);
8386 /* Field 4, the address, is omitted (which makes the columns
8387 not line up too nicely with the headers, but the effect
8388 is relatively readable). */
8389 if (opts
.addressprint
)
8390 uiout
->field_skip ("addr");
8392 uiout
->text ("exec");
8393 if (c
->exec_pathname
!= NULL
)
8395 uiout
->text (", program \"");
8396 uiout
->field_string ("what", c
->exec_pathname
);
8397 uiout
->text ("\" ");
8400 if (uiout
->is_mi_like_p ())
8401 uiout
->field_string ("catch-type", "exec");
8405 print_mention_catch_exec (struct breakpoint
*b
)
8407 printf_filtered (_("Catchpoint %d (exec)"), b
->number
);
8410 /* Implement the "print_recreate" breakpoint_ops method for exec
8414 print_recreate_catch_exec (struct breakpoint
*b
, struct ui_file
*fp
)
8416 fprintf_unfiltered (fp
, "catch exec");
8417 print_recreate_thread (b
, fp
);
8420 static struct breakpoint_ops catch_exec_breakpoint_ops
;
8423 hw_breakpoint_used_count (void)
8426 struct breakpoint
*b
;
8427 struct bp_location
*bl
;
8431 if (b
->type
== bp_hardware_breakpoint
&& breakpoint_enabled (b
))
8432 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
8434 /* Special types of hardware breakpoints may use more than
8436 i
+= b
->ops
->resources_needed (bl
);
8443 /* Returns the resources B would use if it were a hardware
8447 hw_watchpoint_use_count (struct breakpoint
*b
)
8450 struct bp_location
*bl
;
8452 if (!breakpoint_enabled (b
))
8455 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
8457 /* Special types of hardware watchpoints may use more than
8459 i
+= b
->ops
->resources_needed (bl
);
8465 /* Returns the sum the used resources of all hardware watchpoints of
8466 type TYPE in the breakpoints list. Also returns in OTHER_TYPE_USED
8467 the sum of the used resources of all hardware watchpoints of other
8468 types _not_ TYPE. */
8471 hw_watchpoint_used_count_others (struct breakpoint
*except
,
8472 enum bptype type
, int *other_type_used
)
8475 struct breakpoint
*b
;
8477 *other_type_used
= 0;
8482 if (!breakpoint_enabled (b
))
8485 if (b
->type
== type
)
8486 i
+= hw_watchpoint_use_count (b
);
8487 else if (is_hardware_watchpoint (b
))
8488 *other_type_used
= 1;
8495 disable_watchpoints_before_interactive_call_start (void)
8497 struct breakpoint
*b
;
8501 if (is_watchpoint (b
) && breakpoint_enabled (b
))
8503 b
->enable_state
= bp_call_disabled
;
8504 update_global_location_list (UGLL_DONT_INSERT
);
8510 enable_watchpoints_after_interactive_call_stop (void)
8512 struct breakpoint
*b
;
8516 if (is_watchpoint (b
) && b
->enable_state
== bp_call_disabled
)
8518 b
->enable_state
= bp_enabled
;
8519 update_global_location_list (UGLL_MAY_INSERT
);
8525 disable_breakpoints_before_startup (void)
8527 current_program_space
->executing_startup
= 1;
8528 update_global_location_list (UGLL_DONT_INSERT
);
8532 enable_breakpoints_after_startup (void)
8534 current_program_space
->executing_startup
= 0;
8535 breakpoint_re_set ();
8538 /* Create a new single-step breakpoint for thread THREAD, with no
8541 static struct breakpoint
*
8542 new_single_step_breakpoint (int thread
, struct gdbarch
*gdbarch
)
8544 std::unique_ptr
<breakpoint
> b (new breakpoint ());
8546 init_raw_breakpoint_without_location (b
.get (), gdbarch
, bp_single_step
,
8547 &momentary_breakpoint_ops
);
8549 b
->disposition
= disp_donttouch
;
8550 b
->frame_id
= null_frame_id
;
8553 gdb_assert (b
->thread
!= 0);
8555 return add_to_breakpoint_chain (std::move (b
));
8558 /* Set a momentary breakpoint of type TYPE at address specified by
8559 SAL. If FRAME_ID is valid, the breakpoint is restricted to that
8563 set_momentary_breakpoint (struct gdbarch
*gdbarch
, struct symtab_and_line sal
,
8564 struct frame_id frame_id
, enum bptype type
)
8566 struct breakpoint
*b
;
8568 /* If FRAME_ID is valid, it should be a real frame, not an inlined or
8570 gdb_assert (!frame_id_artificial_p (frame_id
));
8572 b
= set_raw_breakpoint (gdbarch
, sal
, type
, &momentary_breakpoint_ops
);
8573 b
->enable_state
= bp_enabled
;
8574 b
->disposition
= disp_donttouch
;
8575 b
->frame_id
= frame_id
;
8577 /* If we're debugging a multi-threaded program, then we want
8578 momentary breakpoints to be active in only a single thread of
8580 if (in_thread_list (inferior_ptid
))
8581 b
->thread
= ptid_to_global_thread_id (inferior_ptid
);
8583 update_global_location_list_nothrow (UGLL_MAY_INSERT
);
8585 return breakpoint_up (b
);
8588 /* Make a momentary breakpoint based on the master breakpoint ORIG.
8589 The new breakpoint will have type TYPE, use OPS as its
8590 breakpoint_ops, and will set enabled to LOC_ENABLED. */
8592 static struct breakpoint
*
8593 momentary_breakpoint_from_master (struct breakpoint
*orig
,
8595 const struct breakpoint_ops
*ops
,
8598 struct breakpoint
*copy
;
8600 copy
= set_raw_breakpoint_without_location (orig
->gdbarch
, type
, ops
);
8601 copy
->loc
= allocate_bp_location (copy
);
8602 set_breakpoint_location_function (copy
->loc
, 1);
8604 copy
->loc
->gdbarch
= orig
->loc
->gdbarch
;
8605 copy
->loc
->requested_address
= orig
->loc
->requested_address
;
8606 copy
->loc
->address
= orig
->loc
->address
;
8607 copy
->loc
->section
= orig
->loc
->section
;
8608 copy
->loc
->pspace
= orig
->loc
->pspace
;
8609 copy
->loc
->probe
= orig
->loc
->probe
;
8610 copy
->loc
->line_number
= orig
->loc
->line_number
;
8611 copy
->loc
->symtab
= orig
->loc
->symtab
;
8612 copy
->loc
->enabled
= loc_enabled
;
8613 copy
->frame_id
= orig
->frame_id
;
8614 copy
->thread
= orig
->thread
;
8615 copy
->pspace
= orig
->pspace
;
8617 copy
->enable_state
= bp_enabled
;
8618 copy
->disposition
= disp_donttouch
;
8619 copy
->number
= internal_breakpoint_number
--;
8621 update_global_location_list_nothrow (UGLL_DONT_INSERT
);
8625 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
8629 clone_momentary_breakpoint (struct breakpoint
*orig
)
8631 /* If there's nothing to clone, then return nothing. */
8635 return momentary_breakpoint_from_master (orig
, orig
->type
, orig
->ops
, 0);
8639 set_momentary_breakpoint_at_pc (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
8642 struct symtab_and_line sal
;
8644 sal
= find_pc_line (pc
, 0);
8646 sal
.section
= find_pc_overlay (pc
);
8647 sal
.explicit_pc
= 1;
8649 return set_momentary_breakpoint (gdbarch
, sal
, null_frame_id
, type
);
8653 /* Tell the user we have just set a breakpoint B. */
8656 mention (struct breakpoint
*b
)
8658 b
->ops
->print_mention (b
);
8659 if (current_uiout
->is_mi_like_p ())
8661 printf_filtered ("\n");
8665 static int bp_loc_is_permanent (struct bp_location
*loc
);
8667 static struct bp_location
*
8668 add_location_to_breakpoint (struct breakpoint
*b
,
8669 const struct symtab_and_line
*sal
)
8671 struct bp_location
*loc
, **tmp
;
8672 CORE_ADDR adjusted_address
;
8673 struct gdbarch
*loc_gdbarch
= get_sal_arch (*sal
);
8675 if (loc_gdbarch
== NULL
)
8676 loc_gdbarch
= b
->gdbarch
;
8678 /* Adjust the breakpoint's address prior to allocating a location.
8679 Once we call allocate_bp_location(), that mostly uninitialized
8680 location will be placed on the location chain. Adjustment of the
8681 breakpoint may cause target_read_memory() to be called and we do
8682 not want its scan of the location chain to find a breakpoint and
8683 location that's only been partially initialized. */
8684 adjusted_address
= adjust_breakpoint_address (loc_gdbarch
,
8687 /* Sort the locations by their ADDRESS. */
8688 loc
= allocate_bp_location (b
);
8689 for (tmp
= &(b
->loc
); *tmp
!= NULL
&& (*tmp
)->address
<= adjusted_address
;
8690 tmp
= &((*tmp
)->next
))
8695 loc
->requested_address
= sal
->pc
;
8696 loc
->address
= adjusted_address
;
8697 loc
->pspace
= sal
->pspace
;
8698 loc
->probe
.probe
= sal
->probe
;
8699 loc
->probe
.objfile
= sal
->objfile
;
8700 gdb_assert (loc
->pspace
!= NULL
);
8701 loc
->section
= sal
->section
;
8702 loc
->gdbarch
= loc_gdbarch
;
8703 loc
->line_number
= sal
->line
;
8704 loc
->symtab
= sal
->symtab
;
8705 loc
->symbol
= sal
->symbol
;
8707 set_breakpoint_location_function (loc
,
8708 sal
->explicit_pc
|| sal
->explicit_line
);
8710 /* While by definition, permanent breakpoints are already present in the
8711 code, we don't mark the location as inserted. Normally one would expect
8712 that GDB could rely on that breakpoint instruction to stop the program,
8713 thus removing the need to insert its own breakpoint, except that executing
8714 the breakpoint instruction can kill the target instead of reporting a
8715 SIGTRAP. E.g., on SPARC, when interrupts are disabled, executing the
8716 instruction resets the CPU, so QEMU 2.0.0 for SPARC correspondingly dies
8717 with "Trap 0x02 while interrupts disabled, Error state". Letting the
8718 breakpoint be inserted normally results in QEMU knowing about the GDB
8719 breakpoint, and thus trap before the breakpoint instruction is executed.
8720 (If GDB later needs to continue execution past the permanent breakpoint,
8721 it manually increments the PC, thus avoiding executing the breakpoint
8723 if (bp_loc_is_permanent (loc
))
8730 /* See breakpoint.h. */
8733 program_breakpoint_here_p (struct gdbarch
*gdbarch
, CORE_ADDR address
)
8737 const gdb_byte
*bpoint
;
8738 gdb_byte
*target_mem
;
8741 bpoint
= gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &len
);
8743 /* Software breakpoints unsupported? */
8747 target_mem
= (gdb_byte
*) alloca (len
);
8749 /* Enable the automatic memory restoration from breakpoints while
8750 we read the memory. Otherwise we could say about our temporary
8751 breakpoints they are permanent. */
8752 scoped_restore restore_memory
8753 = make_scoped_restore_show_memory_breakpoints (0);
8755 if (target_read_memory (address
, target_mem
, len
) == 0
8756 && memcmp (target_mem
, bpoint
, len
) == 0)
8762 /* Return 1 if LOC is pointing to a permanent breakpoint,
8763 return 0 otherwise. */
8766 bp_loc_is_permanent (struct bp_location
*loc
)
8768 gdb_assert (loc
!= NULL
);
8770 /* If we have a catchpoint or a watchpoint, just return 0. We should not
8771 attempt to read from the addresses the locations of these breakpoint types
8772 point to. program_breakpoint_here_p, below, will attempt to read
8774 if (!breakpoint_address_is_meaningful (loc
->owner
))
8777 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
8778 switch_to_program_space_and_thread (loc
->pspace
);
8779 return program_breakpoint_here_p (loc
->gdbarch
, loc
->address
);
8782 /* Build a command list for the dprintf corresponding to the current
8783 settings of the dprintf style options. */
8786 update_dprintf_command_list (struct breakpoint
*b
)
8788 char *dprintf_args
= b
->extra_string
;
8789 char *printf_line
= NULL
;
8794 dprintf_args
= skip_spaces (dprintf_args
);
8796 /* Allow a comma, as it may have terminated a location, but don't
8798 if (*dprintf_args
== ',')
8800 dprintf_args
= skip_spaces (dprintf_args
);
8802 if (*dprintf_args
!= '"')
8803 error (_("Bad format string, missing '\"'."));
8805 if (strcmp (dprintf_style
, dprintf_style_gdb
) == 0)
8806 printf_line
= xstrprintf ("printf %s", dprintf_args
);
8807 else if (strcmp (dprintf_style
, dprintf_style_call
) == 0)
8809 if (!dprintf_function
)
8810 error (_("No function supplied for dprintf call"));
8812 if (dprintf_channel
&& strlen (dprintf_channel
) > 0)
8813 printf_line
= xstrprintf ("call (void) %s (%s,%s)",
8818 printf_line
= xstrprintf ("call (void) %s (%s)",
8822 else if (strcmp (dprintf_style
, dprintf_style_agent
) == 0)
8824 if (target_can_run_breakpoint_commands ())
8825 printf_line
= xstrprintf ("agent-printf %s", dprintf_args
);
8828 warning (_("Target cannot run dprintf commands, falling back to GDB printf"));
8829 printf_line
= xstrprintf ("printf %s", dprintf_args
);
8833 internal_error (__FILE__
, __LINE__
,
8834 _("Invalid dprintf style."));
8836 gdb_assert (printf_line
!= NULL
);
8837 /* Manufacture a printf sequence. */
8839 struct command_line
*printf_cmd_line
= XNEW (struct command_line
);
8841 printf_cmd_line
->control_type
= simple_control
;
8842 printf_cmd_line
->body_count
= 0;
8843 printf_cmd_line
->body_list
= NULL
;
8844 printf_cmd_line
->next
= NULL
;
8845 printf_cmd_line
->line
= printf_line
;
8847 breakpoint_set_commands (b
, command_line_up (printf_cmd_line
));
8851 /* Update all dprintf commands, making their command lists reflect
8852 current style settings. */
8855 update_dprintf_commands (const char *args
, int from_tty
,
8856 struct cmd_list_element
*c
)
8858 struct breakpoint
*b
;
8862 if (b
->type
== bp_dprintf
)
8863 update_dprintf_command_list (b
);
8867 /* Create a breakpoint with SAL as location. Use LOCATION
8868 as a description of the location, and COND_STRING
8869 as condition expression. If LOCATION is NULL then create an
8870 "address location" from the address in the SAL. */
8873 init_breakpoint_sal (struct breakpoint
*b
, struct gdbarch
*gdbarch
,
8874 gdb::array_view
<const symtab_and_line
> sals
,
8875 event_location_up
&&location
,
8876 gdb::unique_xmalloc_ptr
<char> filter
,
8877 gdb::unique_xmalloc_ptr
<char> cond_string
,
8878 gdb::unique_xmalloc_ptr
<char> extra_string
,
8879 enum bptype type
, enum bpdisp disposition
,
8880 int thread
, int task
, int ignore_count
,
8881 const struct breakpoint_ops
*ops
, int from_tty
,
8882 int enabled
, int internal
, unsigned flags
,
8883 int display_canonical
)
8887 if (type
== bp_hardware_breakpoint
)
8889 int target_resources_ok
;
8891 i
= hw_breakpoint_used_count ();
8892 target_resources_ok
=
8893 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
8895 if (target_resources_ok
== 0)
8896 error (_("No hardware breakpoint support in the target."));
8897 else if (target_resources_ok
< 0)
8898 error (_("Hardware breakpoints used exceeds limit."));
8901 gdb_assert (!sals
.empty ());
8903 for (const auto &sal
: sals
)
8905 struct bp_location
*loc
;
8909 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
8911 loc_gdbarch
= gdbarch
;
8913 describe_other_breakpoints (loc_gdbarch
,
8914 sal
.pspace
, sal
.pc
, sal
.section
, thread
);
8917 if (&sal
== &sals
[0])
8919 init_raw_breakpoint (b
, gdbarch
, sal
, type
, ops
);
8923 b
->cond_string
= cond_string
.release ();
8924 b
->extra_string
= extra_string
.release ();
8925 b
->ignore_count
= ignore_count
;
8926 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
8927 b
->disposition
= disposition
;
8929 if ((flags
& CREATE_BREAKPOINT_FLAGS_INSERTED
) != 0)
8930 b
->loc
->inserted
= 1;
8932 if (type
== bp_static_tracepoint
)
8934 struct tracepoint
*t
= (struct tracepoint
*) b
;
8935 struct static_tracepoint_marker marker
;
8937 if (strace_marker_p (b
))
8939 /* We already know the marker exists, otherwise, we
8940 wouldn't see a sal for it. */
8942 = &event_location_to_string (b
->location
.get ())[3];
8946 p
= skip_spaces (p
);
8948 endp
= skip_to_space (p
);
8950 marker_str
= savestring (p
, endp
- p
);
8951 t
->static_trace_marker_id
= marker_str
;
8953 printf_filtered (_("Probed static tracepoint "
8955 t
->static_trace_marker_id
);
8957 else if (target_static_tracepoint_marker_at (sal
.pc
, &marker
))
8959 t
->static_trace_marker_id
= xstrdup (marker
.str_id
);
8960 release_static_tracepoint_marker (&marker
);
8962 printf_filtered (_("Probed static tracepoint "
8964 t
->static_trace_marker_id
);
8967 warning (_("Couldn't determine the static "
8968 "tracepoint marker to probe"));
8975 loc
= add_location_to_breakpoint (b
, &sal
);
8976 if ((flags
& CREATE_BREAKPOINT_FLAGS_INSERTED
) != 0)
8982 const char *arg
= b
->cond_string
;
8984 loc
->cond
= parse_exp_1 (&arg
, loc
->address
,
8985 block_for_pc (loc
->address
), 0);
8987 error (_("Garbage '%s' follows condition"), arg
);
8990 /* Dynamic printf requires and uses additional arguments on the
8991 command line, otherwise it's an error. */
8992 if (type
== bp_dprintf
)
8994 if (b
->extra_string
)
8995 update_dprintf_command_list (b
);
8997 error (_("Format string required"));
8999 else if (b
->extra_string
)
9000 error (_("Garbage '%s' at end of command"), b
->extra_string
);
9003 b
->display_canonical
= display_canonical
;
9004 if (location
!= NULL
)
9005 b
->location
= std::move (location
);
9007 b
->location
= new_address_location (b
->loc
->address
, NULL
, 0);
9008 b
->filter
= filter
.release ();
9012 create_breakpoint_sal (struct gdbarch
*gdbarch
,
9013 gdb::array_view
<const symtab_and_line
> sals
,
9014 event_location_up
&&location
,
9015 gdb::unique_xmalloc_ptr
<char> filter
,
9016 gdb::unique_xmalloc_ptr
<char> cond_string
,
9017 gdb::unique_xmalloc_ptr
<char> extra_string
,
9018 enum bptype type
, enum bpdisp disposition
,
9019 int thread
, int task
, int ignore_count
,
9020 const struct breakpoint_ops
*ops
, int from_tty
,
9021 int enabled
, int internal
, unsigned flags
,
9022 int display_canonical
)
9024 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (type
);
9026 init_breakpoint_sal (b
.get (), gdbarch
,
9027 sals
, std::move (location
),
9029 std::move (cond_string
),
9030 std::move (extra_string
),
9032 thread
, task
, ignore_count
,
9034 enabled
, internal
, flags
,
9037 install_breakpoint (internal
, std::move (b
), 0);
9040 /* Add SALS.nelts breakpoints to the breakpoint table. For each
9041 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
9042 value. COND_STRING, if not NULL, specified the condition to be
9043 used for all breakpoints. Essentially the only case where
9044 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
9045 function. In that case, it's still not possible to specify
9046 separate conditions for different overloaded functions, so
9047 we take just a single condition string.
9049 NOTE: If the function succeeds, the caller is expected to cleanup
9050 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
9051 array contents). If the function fails (error() is called), the
9052 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
9053 COND and SALS arrays and each of those arrays contents. */
9056 create_breakpoints_sal (struct gdbarch
*gdbarch
,
9057 struct linespec_result
*canonical
,
9058 gdb::unique_xmalloc_ptr
<char> cond_string
,
9059 gdb::unique_xmalloc_ptr
<char> extra_string
,
9060 enum bptype type
, enum bpdisp disposition
,
9061 int thread
, int task
, int ignore_count
,
9062 const struct breakpoint_ops
*ops
, int from_tty
,
9063 int enabled
, int internal
, unsigned flags
)
9065 if (canonical
->pre_expanded
)
9066 gdb_assert (canonical
->lsals
.size () == 1);
9068 for (const auto &lsal
: canonical
->lsals
)
9070 /* Note that 'location' can be NULL in the case of a plain
9071 'break', without arguments. */
9072 event_location_up location
9073 = (canonical
->location
!= NULL
9074 ? copy_event_location (canonical
->location
.get ()) : NULL
);
9075 gdb::unique_xmalloc_ptr
<char> filter_string
9076 (lsal
.canonical
!= NULL
? xstrdup (lsal
.canonical
) : NULL
);
9078 create_breakpoint_sal (gdbarch
, lsal
.sals
,
9079 std::move (location
),
9080 std::move (filter_string
),
9081 std::move (cond_string
),
9082 std::move (extra_string
),
9084 thread
, task
, ignore_count
, ops
,
9085 from_tty
, enabled
, internal
, flags
,
9086 canonical
->special_display
);
9090 /* Parse LOCATION which is assumed to be a SAL specification possibly
9091 followed by conditionals. On return, SALS contains an array of SAL
9092 addresses found. LOCATION points to the end of the SAL (for
9093 linespec locations).
9095 The array and the line spec strings are allocated on the heap, it is
9096 the caller's responsibility to free them. */
9099 parse_breakpoint_sals (const struct event_location
*location
,
9100 struct linespec_result
*canonical
)
9102 struct symtab_and_line cursal
;
9104 if (event_location_type (location
) == LINESPEC_LOCATION
)
9106 const char *address
= get_linespec_location (location
);
9108 if (address
== NULL
)
9110 /* The last displayed codepoint, if it's valid, is our default
9111 breakpoint address. */
9112 if (last_displayed_sal_is_valid ())
9114 /* Set sal's pspace, pc, symtab, and line to the values
9115 corresponding to the last call to print_frame_info.
9116 Be sure to reinitialize LINE with NOTCURRENT == 0
9117 as the breakpoint line number is inappropriate otherwise.
9118 find_pc_line would adjust PC, re-set it back. */
9119 symtab_and_line sal
= get_last_displayed_sal ();
9120 CORE_ADDR pc
= sal
.pc
;
9122 sal
= find_pc_line (pc
, 0);
9124 /* "break" without arguments is equivalent to "break *PC"
9125 where PC is the last displayed codepoint's address. So
9126 make sure to set sal.explicit_pc to prevent GDB from
9127 trying to expand the list of sals to include all other
9128 instances with the same symtab and line. */
9130 sal
.explicit_pc
= 1;
9132 struct linespec_sals lsal
;
9134 lsal
.canonical
= NULL
;
9136 canonical
->lsals
.push_back (std::move (lsal
));
9140 error (_("No default breakpoint address now."));
9144 /* Force almost all breakpoints to be in terms of the
9145 current_source_symtab (which is decode_line_1's default).
9146 This should produce the results we want almost all of the
9147 time while leaving default_breakpoint_* alone.
9149 ObjC: However, don't match an Objective-C method name which
9150 may have a '+' or '-' succeeded by a '['. */
9151 cursal
= get_current_source_symtab_and_line ();
9152 if (last_displayed_sal_is_valid ())
9154 const char *address
= NULL
;
9156 if (event_location_type (location
) == LINESPEC_LOCATION
)
9157 address
= get_linespec_location (location
);
9161 && strchr ("+-", address
[0]) != NULL
9162 && address
[1] != '['))
9164 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, NULL
,
9165 get_last_displayed_symtab (),
9166 get_last_displayed_line (),
9167 canonical
, NULL
, NULL
);
9172 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, NULL
,
9173 cursal
.symtab
, cursal
.line
, canonical
, NULL
, NULL
);
9177 /* Convert each SAL into a real PC. Verify that the PC can be
9178 inserted as a breakpoint. If it can't throw an error. */
9181 breakpoint_sals_to_pc (std::vector
<symtab_and_line
> &sals
)
9183 for (auto &sal
: sals
)
9184 resolve_sal_pc (&sal
);
9187 /* Fast tracepoints may have restrictions on valid locations. For
9188 instance, a fast tracepoint using a jump instead of a trap will
9189 likely have to overwrite more bytes than a trap would, and so can
9190 only be placed where the instruction is longer than the jump, or a
9191 multi-instruction sequence does not have a jump into the middle of
9195 check_fast_tracepoint_sals (struct gdbarch
*gdbarch
,
9196 gdb::array_view
<const symtab_and_line
> sals
)
9200 struct cleanup
*old_chain
;
9202 for (const auto &sal
: sals
)
9204 struct gdbarch
*sarch
;
9206 sarch
= get_sal_arch (sal
);
9207 /* We fall back to GDBARCH if there is no architecture
9208 associated with SAL. */
9211 rslt
= gdbarch_fast_tracepoint_valid_at (sarch
, sal
.pc
, &msg
);
9212 old_chain
= make_cleanup (xfree
, msg
);
9215 error (_("May not have a fast tracepoint at %s%s"),
9216 paddress (sarch
, sal
.pc
), (msg
? msg
: ""));
9218 do_cleanups (old_chain
);
9222 /* Given TOK, a string specification of condition and thread, as
9223 accepted by the 'break' command, extract the condition
9224 string and thread number and set *COND_STRING and *THREAD.
9225 PC identifies the context at which the condition should be parsed.
9226 If no condition is found, *COND_STRING is set to NULL.
9227 If no thread is found, *THREAD is set to -1. */
9230 find_condition_and_thread (const char *tok
, CORE_ADDR pc
,
9231 char **cond_string
, int *thread
, int *task
,
9234 *cond_string
= NULL
;
9241 const char *end_tok
;
9243 const char *cond_start
= NULL
;
9244 const char *cond_end
= NULL
;
9246 tok
= skip_spaces (tok
);
9248 if ((*tok
== '"' || *tok
== ',') && rest
)
9250 *rest
= savestring (tok
, strlen (tok
));
9254 end_tok
= skip_to_space (tok
);
9256 toklen
= end_tok
- tok
;
9258 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
9260 tok
= cond_start
= end_tok
+ 1;
9261 parse_exp_1 (&tok
, pc
, block_for_pc (pc
), 0);
9263 *cond_string
= savestring (cond_start
, cond_end
- cond_start
);
9265 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
9268 struct thread_info
*thr
;
9271 thr
= parse_thread_id (tok
, &tmptok
);
9273 error (_("Junk after thread keyword."));
9274 *thread
= thr
->global_num
;
9277 else if (toklen
>= 1 && strncmp (tok
, "task", toklen
) == 0)
9282 *task
= strtol (tok
, &tmptok
, 0);
9284 error (_("Junk after task keyword."));
9285 if (!valid_task_id (*task
))
9286 error (_("Unknown task %d."), *task
);
9291 *rest
= savestring (tok
, strlen (tok
));
9295 error (_("Junk at end of arguments."));
9299 /* Decode a static tracepoint marker spec. */
9301 static std::vector
<symtab_and_line
>
9302 decode_static_tracepoint_spec (const char **arg_p
)
9304 VEC(static_tracepoint_marker_p
) *markers
= NULL
;
9305 const char *p
= &(*arg_p
)[3];
9309 p
= skip_spaces (p
);
9311 endp
= skip_to_space (p
);
9313 std::string
marker_str (p
, endp
- p
);
9315 markers
= target_static_tracepoint_markers_by_strid (marker_str
.c_str ());
9316 if (VEC_empty(static_tracepoint_marker_p
, markers
))
9317 error (_("No known static tracepoint marker named %s"),
9318 marker_str
.c_str ());
9320 std::vector
<symtab_and_line
> sals
;
9321 sals
.reserve (VEC_length(static_tracepoint_marker_p
, markers
));
9323 for (i
= 0; i
< VEC_length(static_tracepoint_marker_p
, markers
); i
++)
9325 struct static_tracepoint_marker
*marker
;
9327 marker
= VEC_index (static_tracepoint_marker_p
, markers
, i
);
9329 symtab_and_line sal
= find_pc_line (marker
->address
, 0);
9330 sal
.pc
= marker
->address
;
9331 sals
.push_back (sal
);
9333 release_static_tracepoint_marker (marker
);
9340 /* See breakpoint.h. */
9343 create_breakpoint (struct gdbarch
*gdbarch
,
9344 const struct event_location
*location
,
9345 const char *cond_string
,
9346 int thread
, const char *extra_string
,
9348 int tempflag
, enum bptype type_wanted
,
9350 enum auto_boolean pending_break_support
,
9351 const struct breakpoint_ops
*ops
,
9352 int from_tty
, int enabled
, int internal
,
9355 struct linespec_result canonical
;
9356 struct cleanup
*bkpt_chain
= NULL
;
9359 int prev_bkpt_count
= breakpoint_count
;
9361 gdb_assert (ops
!= NULL
);
9363 /* If extra_string isn't useful, set it to NULL. */
9364 if (extra_string
!= NULL
&& *extra_string
== '\0')
9365 extra_string
= NULL
;
9369 ops
->create_sals_from_location (location
, &canonical
, type_wanted
);
9371 CATCH (e
, RETURN_MASK_ERROR
)
9373 /* If caller is interested in rc value from parse, set
9375 if (e
.error
== NOT_FOUND_ERROR
)
9377 /* If pending breakpoint support is turned off, throw
9380 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
9381 throw_exception (e
);
9383 exception_print (gdb_stderr
, e
);
9385 /* If pending breakpoint support is auto query and the user
9386 selects no, then simply return the error code. */
9387 if (pending_break_support
== AUTO_BOOLEAN_AUTO
9388 && !nquery (_("Make %s pending on future shared library load? "),
9389 bptype_string (type_wanted
)))
9392 /* At this point, either the user was queried about setting
9393 a pending breakpoint and selected yes, or pending
9394 breakpoint behavior is on and thus a pending breakpoint
9395 is defaulted on behalf of the user. */
9399 throw_exception (e
);
9403 if (!pending
&& canonical
.lsals
.empty ())
9406 /* ----------------------------- SNIP -----------------------------
9407 Anything added to the cleanup chain beyond this point is assumed
9408 to be part of a breakpoint. If the breakpoint create succeeds
9409 then the memory is not reclaimed. */
9410 bkpt_chain
= make_cleanup (null_cleanup
, 0);
9412 /* Resolve all line numbers to PC's and verify that the addresses
9413 are ok for the target. */
9416 for (auto &lsal
: canonical
.lsals
)
9417 breakpoint_sals_to_pc (lsal
.sals
);
9420 /* Fast tracepoints may have additional restrictions on location. */
9421 if (!pending
&& type_wanted
== bp_fast_tracepoint
)
9423 for (const auto &lsal
: canonical
.lsals
)
9424 check_fast_tracepoint_sals (gdbarch
, lsal
.sals
);
9427 /* Verify that condition can be parsed, before setting any
9428 breakpoints. Allocate a separate condition expression for each
9432 gdb::unique_xmalloc_ptr
<char> cond_string_copy
;
9433 gdb::unique_xmalloc_ptr
<char> extra_string_copy
;
9440 const linespec_sals
&lsal
= canonical
.lsals
[0];
9442 /* Here we only parse 'arg' to separate condition
9443 from thread number, so parsing in context of first
9444 sal is OK. When setting the breakpoint we'll
9445 re-parse it in context of each sal. */
9447 find_condition_and_thread (extra_string
, lsal
.sals
[0].pc
,
9448 &cond
, &thread
, &task
, &rest
);
9449 cond_string_copy
.reset (cond
);
9450 extra_string_copy
.reset (rest
);
9454 if (type_wanted
!= bp_dprintf
9455 && extra_string
!= NULL
&& *extra_string
!= '\0')
9456 error (_("Garbage '%s' at end of location"), extra_string
);
9458 /* Create a private copy of condition string. */
9460 cond_string_copy
.reset (xstrdup (cond_string
));
9461 /* Create a private copy of any extra string. */
9463 extra_string_copy
.reset (xstrdup (extra_string
));
9466 ops
->create_breakpoints_sal (gdbarch
, &canonical
,
9467 std::move (cond_string_copy
),
9468 std::move (extra_string_copy
),
9470 tempflag
? disp_del
: disp_donttouch
,
9471 thread
, task
, ignore_count
, ops
,
9472 from_tty
, enabled
, internal
, flags
);
9476 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (type_wanted
);
9478 init_raw_breakpoint_without_location (b
.get (), gdbarch
, type_wanted
, ops
);
9479 b
->location
= copy_event_location (location
);
9482 b
->cond_string
= NULL
;
9485 /* Create a private copy of condition string. */
9486 b
->cond_string
= cond_string
!= NULL
? xstrdup (cond_string
) : NULL
;
9490 /* Create a private copy of any extra string. */
9491 b
->extra_string
= extra_string
!= NULL
? xstrdup (extra_string
) : NULL
;
9492 b
->ignore_count
= ignore_count
;
9493 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
9494 b
->condition_not_parsed
= 1;
9495 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
9496 if ((type_wanted
!= bp_breakpoint
9497 && type_wanted
!= bp_hardware_breakpoint
) || thread
!= -1)
9498 b
->pspace
= current_program_space
;
9500 install_breakpoint (internal
, std::move (b
), 0);
9503 if (canonical
.lsals
.size () > 1)
9505 warning (_("Multiple breakpoints were set.\nUse the "
9506 "\"delete\" command to delete unwanted breakpoints."));
9507 prev_breakpoint_count
= prev_bkpt_count
;
9510 /* That's it. Discard the cleanups for data inserted into the
9512 discard_cleanups (bkpt_chain
);
9514 /* error call may happen here - have BKPT_CHAIN already discarded. */
9515 update_global_location_list (UGLL_MAY_INSERT
);
9520 /* Set a breakpoint.
9521 ARG is a string describing breakpoint address,
9522 condition, and thread.
9523 FLAG specifies if a breakpoint is hardware on,
9524 and if breakpoint is temporary, using BP_HARDWARE_FLAG
9528 break_command_1 (const char *arg
, int flag
, int from_tty
)
9530 int tempflag
= flag
& BP_TEMPFLAG
;
9531 enum bptype type_wanted
= (flag
& BP_HARDWAREFLAG
9532 ? bp_hardware_breakpoint
9534 struct breakpoint_ops
*ops
;
9536 event_location_up location
= string_to_event_location (&arg
, current_language
);
9538 /* Matching breakpoints on probes. */
9539 if (location
!= NULL
9540 && event_location_type (location
.get ()) == PROBE_LOCATION
)
9541 ops
= &bkpt_probe_breakpoint_ops
;
9543 ops
= &bkpt_breakpoint_ops
;
9545 create_breakpoint (get_current_arch (),
9547 NULL
, 0, arg
, 1 /* parse arg */,
9548 tempflag
, type_wanted
,
9549 0 /* Ignore count */,
9550 pending_break_support
,
9558 /* Helper function for break_command_1 and disassemble_command. */
9561 resolve_sal_pc (struct symtab_and_line
*sal
)
9565 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
9567 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
9568 error (_("No line %d in file \"%s\"."),
9569 sal
->line
, symtab_to_filename_for_display (sal
->symtab
));
9572 /* If this SAL corresponds to a breakpoint inserted using a line
9573 number, then skip the function prologue if necessary. */
9574 if (sal
->explicit_line
)
9575 skip_prologue_sal (sal
);
9578 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
9580 const struct blockvector
*bv
;
9581 const struct block
*b
;
9584 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
,
9585 SYMTAB_COMPUNIT (sal
->symtab
));
9588 sym
= block_linkage_function (b
);
9591 fixup_symbol_section (sym
, SYMTAB_OBJFILE (sal
->symtab
));
9592 sal
->section
= SYMBOL_OBJ_SECTION (SYMTAB_OBJFILE (sal
->symtab
),
9597 /* It really is worthwhile to have the section, so we'll
9598 just have to look harder. This case can be executed
9599 if we have line numbers but no functions (as can
9600 happen in assembly source). */
9602 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
9603 switch_to_program_space_and_thread (sal
->pspace
);
9605 bound_minimal_symbol msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
9607 sal
->section
= MSYMBOL_OBJ_SECTION (msym
.objfile
, msym
.minsym
);
9614 break_command (const char *arg
, int from_tty
)
9616 break_command_1 (arg
, 0, from_tty
);
9620 tbreak_command (const char *arg
, int from_tty
)
9622 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
9626 hbreak_command (const char *arg
, int from_tty
)
9628 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
9632 thbreak_command (const char *arg
, int from_tty
)
9634 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
9638 stop_command (const char *arg
, int from_tty
)
9640 printf_filtered (_("Specify the type of breakpoint to set.\n\
9641 Usage: stop in <function | address>\n\
9642 stop at <line>\n"));
9646 stopin_command (const char *arg
, int from_tty
)
9650 if (arg
== (char *) NULL
)
9652 else if (*arg
!= '*')
9654 const char *argptr
= arg
;
9657 /* Look for a ':'. If this is a line number specification, then
9658 say it is bad, otherwise, it should be an address or
9659 function/method name. */
9660 while (*argptr
&& !hasColon
)
9662 hasColon
= (*argptr
== ':');
9667 badInput
= (*argptr
!= ':'); /* Not a class::method */
9669 badInput
= isdigit (*arg
); /* a simple line number */
9673 printf_filtered (_("Usage: stop in <function | address>\n"));
9675 break_command_1 (arg
, 0, from_tty
);
9679 stopat_command (const char *arg
, int from_tty
)
9683 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
9687 const char *argptr
= arg
;
9690 /* Look for a ':'. If there is a '::' then get out, otherwise
9691 it is probably a line number. */
9692 while (*argptr
&& !hasColon
)
9694 hasColon
= (*argptr
== ':');
9699 badInput
= (*argptr
== ':'); /* we have class::method */
9701 badInput
= !isdigit (*arg
); /* not a line number */
9705 printf_filtered (_("Usage: stop at <line>\n"));
9707 break_command_1 (arg
, 0, from_tty
);
9710 /* The dynamic printf command is mostly like a regular breakpoint, but
9711 with a prewired command list consisting of a single output command,
9712 built from extra arguments supplied on the dprintf command
9716 dprintf_command (const char *arg
, int from_tty
)
9718 event_location_up location
= string_to_event_location (&arg
, current_language
);
9720 /* If non-NULL, ARG should have been advanced past the location;
9721 the next character must be ','. */
9724 if (arg
[0] != ',' || arg
[1] == '\0')
9725 error (_("Format string required"));
9728 /* Skip the comma. */
9733 create_breakpoint (get_current_arch (),
9735 NULL
, 0, arg
, 1 /* parse arg */,
9737 0 /* Ignore count */,
9738 pending_break_support
,
9739 &dprintf_breakpoint_ops
,
9747 agent_printf_command (const char *arg
, int from_tty
)
9749 error (_("May only run agent-printf on the target"));
9752 /* Implement the "breakpoint_hit" breakpoint_ops method for
9753 ranged breakpoints. */
9756 breakpoint_hit_ranged_breakpoint (const struct bp_location
*bl
,
9757 const address_space
*aspace
,
9759 const struct target_waitstatus
*ws
)
9761 if (ws
->kind
!= TARGET_WAITKIND_STOPPED
9762 || ws
->value
.sig
!= GDB_SIGNAL_TRAP
)
9765 return breakpoint_address_match_range (bl
->pspace
->aspace
, bl
->address
,
9766 bl
->length
, aspace
, bp_addr
);
9769 /* Implement the "resources_needed" breakpoint_ops method for
9770 ranged breakpoints. */
9773 resources_needed_ranged_breakpoint (const struct bp_location
*bl
)
9775 return target_ranged_break_num_registers ();
9778 /* Implement the "print_it" breakpoint_ops method for
9779 ranged breakpoints. */
9781 static enum print_stop_action
9782 print_it_ranged_breakpoint (bpstat bs
)
9784 struct breakpoint
*b
= bs
->breakpoint_at
;
9785 struct bp_location
*bl
= b
->loc
;
9786 struct ui_out
*uiout
= current_uiout
;
9788 gdb_assert (b
->type
== bp_hardware_breakpoint
);
9790 /* Ranged breakpoints have only one location. */
9791 gdb_assert (bl
&& bl
->next
== NULL
);
9793 annotate_breakpoint (b
->number
);
9795 maybe_print_thread_hit_breakpoint (uiout
);
9797 if (b
->disposition
== disp_del
)
9798 uiout
->text ("Temporary ranged breakpoint ");
9800 uiout
->text ("Ranged breakpoint ");
9801 if (uiout
->is_mi_like_p ())
9803 uiout
->field_string ("reason",
9804 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
9805 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
9807 uiout
->field_int ("bkptno", b
->number
);
9810 return PRINT_SRC_AND_LOC
;
9813 /* Implement the "print_one" breakpoint_ops method for
9814 ranged breakpoints. */
9817 print_one_ranged_breakpoint (struct breakpoint
*b
,
9818 struct bp_location
**last_loc
)
9820 struct bp_location
*bl
= b
->loc
;
9821 struct value_print_options opts
;
9822 struct ui_out
*uiout
= current_uiout
;
9824 /* Ranged breakpoints have only one location. */
9825 gdb_assert (bl
&& bl
->next
== NULL
);
9827 get_user_print_options (&opts
);
9829 if (opts
.addressprint
)
9830 /* We don't print the address range here, it will be printed later
9831 by print_one_detail_ranged_breakpoint. */
9832 uiout
->field_skip ("addr");
9834 print_breakpoint_location (b
, bl
);
9838 /* Implement the "print_one_detail" breakpoint_ops method for
9839 ranged breakpoints. */
9842 print_one_detail_ranged_breakpoint (const struct breakpoint
*b
,
9843 struct ui_out
*uiout
)
9845 CORE_ADDR address_start
, address_end
;
9846 struct bp_location
*bl
= b
->loc
;
9851 address_start
= bl
->address
;
9852 address_end
= address_start
+ bl
->length
- 1;
9854 uiout
->text ("\taddress range: ");
9855 stb
.printf ("[%s, %s]",
9856 print_core_address (bl
->gdbarch
, address_start
),
9857 print_core_address (bl
->gdbarch
, address_end
));
9858 uiout
->field_stream ("addr", stb
);
9862 /* Implement the "print_mention" breakpoint_ops method for
9863 ranged breakpoints. */
9866 print_mention_ranged_breakpoint (struct breakpoint
*b
)
9868 struct bp_location
*bl
= b
->loc
;
9869 struct ui_out
*uiout
= current_uiout
;
9872 gdb_assert (b
->type
== bp_hardware_breakpoint
);
9874 if (uiout
->is_mi_like_p ())
9877 printf_filtered (_("Hardware assisted ranged breakpoint %d from %s to %s."),
9878 b
->number
, paddress (bl
->gdbarch
, bl
->address
),
9879 paddress (bl
->gdbarch
, bl
->address
+ bl
->length
- 1));
9882 /* Implement the "print_recreate" breakpoint_ops method for
9883 ranged breakpoints. */
9886 print_recreate_ranged_breakpoint (struct breakpoint
*b
, struct ui_file
*fp
)
9888 fprintf_unfiltered (fp
, "break-range %s, %s",
9889 event_location_to_string (b
->location
.get ()),
9890 event_location_to_string (b
->location_range_end
.get ()));
9891 print_recreate_thread (b
, fp
);
9894 /* The breakpoint_ops structure to be used in ranged breakpoints. */
9896 static struct breakpoint_ops ranged_breakpoint_ops
;
9898 /* Find the address where the end of the breakpoint range should be
9899 placed, given the SAL of the end of the range. This is so that if
9900 the user provides a line number, the end of the range is set to the
9901 last instruction of the given line. */
9904 find_breakpoint_range_end (struct symtab_and_line sal
)
9908 /* If the user provided a PC value, use it. Otherwise,
9909 find the address of the end of the given location. */
9910 if (sal
.explicit_pc
)
9917 ret
= find_line_pc_range (sal
, &start
, &end
);
9919 error (_("Could not find location of the end of the range."));
9921 /* find_line_pc_range returns the start of the next line. */
9928 /* Implement the "break-range" CLI command. */
9931 break_range_command (const char *arg
, int from_tty
)
9933 const char *arg_start
;
9934 struct linespec_result canonical_start
, canonical_end
;
9935 int bp_count
, can_use_bp
, length
;
9937 struct breakpoint
*b
;
9939 /* We don't support software ranged breakpoints. */
9940 if (target_ranged_break_num_registers () < 0)
9941 error (_("This target does not support hardware ranged breakpoints."));
9943 bp_count
= hw_breakpoint_used_count ();
9944 bp_count
+= target_ranged_break_num_registers ();
9945 can_use_bp
= target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
9948 error (_("Hardware breakpoints used exceeds limit."));
9950 arg
= skip_spaces (arg
);
9951 if (arg
== NULL
|| arg
[0] == '\0')
9952 error(_("No address range specified."));
9955 event_location_up start_location
= string_to_event_location (&arg
,
9957 parse_breakpoint_sals (start_location
.get (), &canonical_start
);
9960 error (_("Too few arguments."));
9961 else if (canonical_start
.lsals
.empty ())
9962 error (_("Could not find location of the beginning of the range."));
9964 const linespec_sals
&lsal_start
= canonical_start
.lsals
[0];
9966 if (canonical_start
.lsals
.size () > 1
9967 || lsal_start
.sals
.size () != 1)
9968 error (_("Cannot create a ranged breakpoint with multiple locations."));
9970 const symtab_and_line
&sal_start
= lsal_start
.sals
[0];
9971 std::string
addr_string_start (arg_start
, arg
- arg_start
);
9973 arg
++; /* Skip the comma. */
9974 arg
= skip_spaces (arg
);
9976 /* Parse the end location. */
9980 /* We call decode_line_full directly here instead of using
9981 parse_breakpoint_sals because we need to specify the start location's
9982 symtab and line as the default symtab and line for the end of the
9983 range. This makes it possible to have ranges like "foo.c:27, +14",
9984 where +14 means 14 lines from the start location. */
9985 event_location_up end_location
= string_to_event_location (&arg
,
9987 decode_line_full (end_location
.get (), DECODE_LINE_FUNFIRSTLINE
, NULL
,
9988 sal_start
.symtab
, sal_start
.line
,
9989 &canonical_end
, NULL
, NULL
);
9991 if (canonical_end
.lsals
.empty ())
9992 error (_("Could not find location of the end of the range."));
9994 const linespec_sals
&lsal_end
= canonical_end
.lsals
[0];
9995 if (canonical_end
.lsals
.size () > 1
9996 || lsal_end
.sals
.size () != 1)
9997 error (_("Cannot create a ranged breakpoint with multiple locations."));
9999 const symtab_and_line
&sal_end
= lsal_end
.sals
[0];
10001 end
= find_breakpoint_range_end (sal_end
);
10002 if (sal_start
.pc
> end
)
10003 error (_("Invalid address range, end precedes start."));
10005 length
= end
- sal_start
.pc
+ 1;
10007 /* Length overflowed. */
10008 error (_("Address range too large."));
10009 else if (length
== 1)
10011 /* This range is simple enough to be handled by
10012 the `hbreak' command. */
10013 hbreak_command (&addr_string_start
[0], 1);
10018 /* Now set up the breakpoint. */
10019 b
= set_raw_breakpoint (get_current_arch (), sal_start
,
10020 bp_hardware_breakpoint
, &ranged_breakpoint_ops
);
10021 set_breakpoint_count (breakpoint_count
+ 1);
10022 b
->number
= breakpoint_count
;
10023 b
->disposition
= disp_donttouch
;
10024 b
->location
= std::move (start_location
);
10025 b
->location_range_end
= std::move (end_location
);
10026 b
->loc
->length
= length
;
10029 observer_notify_breakpoint_created (b
);
10030 update_global_location_list (UGLL_MAY_INSERT
);
10033 /* Return non-zero if EXP is verified as constant. Returned zero
10034 means EXP is variable. Also the constant detection may fail for
10035 some constant expressions and in such case still falsely return
10039 watchpoint_exp_is_const (const struct expression
*exp
)
10041 int i
= exp
->nelts
;
10047 /* We are only interested in the descriptor of each element. */
10048 operator_length (exp
, i
, &oplenp
, &argsp
);
10051 switch (exp
->elts
[i
].opcode
)
10061 case BINOP_LOGICAL_AND
:
10062 case BINOP_LOGICAL_OR
:
10063 case BINOP_BITWISE_AND
:
10064 case BINOP_BITWISE_IOR
:
10065 case BINOP_BITWISE_XOR
:
10067 case BINOP_NOTEQUAL
:
10093 case OP_OBJC_NSSTRING
:
10096 case UNOP_LOGICAL_NOT
:
10097 case UNOP_COMPLEMENT
:
10102 case UNOP_CAST_TYPE
:
10103 case UNOP_REINTERPRET_CAST
:
10104 case UNOP_DYNAMIC_CAST
:
10105 /* Unary, binary and ternary operators: We have to check
10106 their operands. If they are constant, then so is the
10107 result of that operation. For instance, if A and B are
10108 determined to be constants, then so is "A + B".
10110 UNOP_IND is one exception to the rule above, because the
10111 value of *ADDR is not necessarily a constant, even when
10116 /* Check whether the associated symbol is a constant.
10118 We use SYMBOL_CLASS rather than TYPE_CONST because it's
10119 possible that a buggy compiler could mark a variable as
10120 constant even when it is not, and TYPE_CONST would return
10121 true in this case, while SYMBOL_CLASS wouldn't.
10123 We also have to check for function symbols because they
10124 are always constant. */
10126 struct symbol
*s
= exp
->elts
[i
+ 2].symbol
;
10128 if (SYMBOL_CLASS (s
) != LOC_BLOCK
10129 && SYMBOL_CLASS (s
) != LOC_CONST
10130 && SYMBOL_CLASS (s
) != LOC_CONST_BYTES
)
10135 /* The default action is to return 0 because we are using
10136 the optimistic approach here: If we don't know something,
10137 then it is not a constant. */
10146 /* Watchpoint destructor. */
10148 watchpoint::~watchpoint ()
10150 xfree (this->exp_string
);
10151 xfree (this->exp_string_reparse
);
10152 value_free (this->val
);
10155 /* Implement the "re_set" breakpoint_ops method for watchpoints. */
10158 re_set_watchpoint (struct breakpoint
*b
)
10160 struct watchpoint
*w
= (struct watchpoint
*) b
;
10162 /* Watchpoint can be either on expression using entirely global
10163 variables, or it can be on local variables.
10165 Watchpoints of the first kind are never auto-deleted, and even
10166 persist across program restarts. Since they can use variables
10167 from shared libraries, we need to reparse expression as libraries
10168 are loaded and unloaded.
10170 Watchpoints on local variables can also change meaning as result
10171 of solib event. For example, if a watchpoint uses both a local
10172 and a global variables in expression, it's a local watchpoint,
10173 but unloading of a shared library will make the expression
10174 invalid. This is not a very common use case, but we still
10175 re-evaluate expression, to avoid surprises to the user.
10177 Note that for local watchpoints, we re-evaluate it only if
10178 watchpoints frame id is still valid. If it's not, it means the
10179 watchpoint is out of scope and will be deleted soon. In fact,
10180 I'm not sure we'll ever be called in this case.
10182 If a local watchpoint's frame id is still valid, then
10183 w->exp_valid_block is likewise valid, and we can safely use it.
10185 Don't do anything about disabled watchpoints, since they will be
10186 reevaluated again when enabled. */
10187 update_watchpoint (w
, 1 /* reparse */);
10190 /* Implement the "insert" breakpoint_ops method for hardware watchpoints. */
10193 insert_watchpoint (struct bp_location
*bl
)
10195 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10196 int length
= w
->exact
? 1 : bl
->length
;
10198 return target_insert_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
10199 w
->cond_exp
.get ());
10202 /* Implement the "remove" breakpoint_ops method for hardware watchpoints. */
10205 remove_watchpoint (struct bp_location
*bl
, enum remove_bp_reason reason
)
10207 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10208 int length
= w
->exact
? 1 : bl
->length
;
10210 return target_remove_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
10211 w
->cond_exp
.get ());
10215 breakpoint_hit_watchpoint (const struct bp_location
*bl
,
10216 const address_space
*aspace
, CORE_ADDR bp_addr
,
10217 const struct target_waitstatus
*ws
)
10219 struct breakpoint
*b
= bl
->owner
;
10220 struct watchpoint
*w
= (struct watchpoint
*) b
;
10222 /* Continuable hardware watchpoints are treated as non-existent if the
10223 reason we stopped wasn't a hardware watchpoint (we didn't stop on
10224 some data address). Otherwise gdb won't stop on a break instruction
10225 in the code (not from a breakpoint) when a hardware watchpoint has
10226 been defined. Also skip watchpoints which we know did not trigger
10227 (did not match the data address). */
10228 if (is_hardware_watchpoint (b
)
10229 && w
->watchpoint_triggered
== watch_triggered_no
)
10236 check_status_watchpoint (bpstat bs
)
10238 gdb_assert (is_watchpoint (bs
->breakpoint_at
));
10240 bpstat_check_watchpoint (bs
);
10243 /* Implement the "resources_needed" breakpoint_ops method for
10244 hardware watchpoints. */
10247 resources_needed_watchpoint (const struct bp_location
*bl
)
10249 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10250 int length
= w
->exact
? 1 : bl
->length
;
10252 return target_region_ok_for_hw_watchpoint (bl
->address
, length
);
10255 /* Implement the "works_in_software_mode" breakpoint_ops method for
10256 hardware watchpoints. */
10259 works_in_software_mode_watchpoint (const struct breakpoint
*b
)
10261 /* Read and access watchpoints only work with hardware support. */
10262 return b
->type
== bp_watchpoint
|| b
->type
== bp_hardware_watchpoint
;
10265 static enum print_stop_action
10266 print_it_watchpoint (bpstat bs
)
10268 struct breakpoint
*b
;
10269 enum print_stop_action result
;
10270 struct watchpoint
*w
;
10271 struct ui_out
*uiout
= current_uiout
;
10273 gdb_assert (bs
->bp_location_at
!= NULL
);
10275 b
= bs
->breakpoint_at
;
10276 w
= (struct watchpoint
*) b
;
10278 annotate_watchpoint (b
->number
);
10279 maybe_print_thread_hit_breakpoint (uiout
);
10283 gdb::optional
<ui_out_emit_tuple
> tuple_emitter
;
10286 case bp_watchpoint
:
10287 case bp_hardware_watchpoint
:
10288 if (uiout
->is_mi_like_p ())
10289 uiout
->field_string
10290 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
10292 tuple_emitter
.emplace (uiout
, "value");
10293 uiout
->text ("\nOld value = ");
10294 watchpoint_value_print (bs
->old_val
, &stb
);
10295 uiout
->field_stream ("old", stb
);
10296 uiout
->text ("\nNew value = ");
10297 watchpoint_value_print (w
->val
, &stb
);
10298 uiout
->field_stream ("new", stb
);
10299 uiout
->text ("\n");
10300 /* More than one watchpoint may have been triggered. */
10301 result
= PRINT_UNKNOWN
;
10304 case bp_read_watchpoint
:
10305 if (uiout
->is_mi_like_p ())
10306 uiout
->field_string
10307 ("reason", async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
10309 tuple_emitter
.emplace (uiout
, "value");
10310 uiout
->text ("\nValue = ");
10311 watchpoint_value_print (w
->val
, &stb
);
10312 uiout
->field_stream ("value", stb
);
10313 uiout
->text ("\n");
10314 result
= PRINT_UNKNOWN
;
10317 case bp_access_watchpoint
:
10318 if (bs
->old_val
!= NULL
)
10320 if (uiout
->is_mi_like_p ())
10321 uiout
->field_string
10323 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
10325 tuple_emitter
.emplace (uiout
, "value");
10326 uiout
->text ("\nOld value = ");
10327 watchpoint_value_print (bs
->old_val
, &stb
);
10328 uiout
->field_stream ("old", stb
);
10329 uiout
->text ("\nNew value = ");
10334 if (uiout
->is_mi_like_p ())
10335 uiout
->field_string
10337 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
10338 tuple_emitter
.emplace (uiout
, "value");
10339 uiout
->text ("\nValue = ");
10341 watchpoint_value_print (w
->val
, &stb
);
10342 uiout
->field_stream ("new", stb
);
10343 uiout
->text ("\n");
10344 result
= PRINT_UNKNOWN
;
10347 result
= PRINT_UNKNOWN
;
10353 /* Implement the "print_mention" breakpoint_ops method for hardware
10357 print_mention_watchpoint (struct breakpoint
*b
)
10359 struct watchpoint
*w
= (struct watchpoint
*) b
;
10360 struct ui_out
*uiout
= current_uiout
;
10361 const char *tuple_name
;
10365 case bp_watchpoint
:
10366 uiout
->text ("Watchpoint ");
10367 tuple_name
= "wpt";
10369 case bp_hardware_watchpoint
:
10370 uiout
->text ("Hardware watchpoint ");
10371 tuple_name
= "wpt";
10373 case bp_read_watchpoint
:
10374 uiout
->text ("Hardware read watchpoint ");
10375 tuple_name
= "hw-rwpt";
10377 case bp_access_watchpoint
:
10378 uiout
->text ("Hardware access (read/write) watchpoint ");
10379 tuple_name
= "hw-awpt";
10382 internal_error (__FILE__
, __LINE__
,
10383 _("Invalid hardware watchpoint type."));
10386 ui_out_emit_tuple
tuple_emitter (uiout
, tuple_name
);
10387 uiout
->field_int ("number", b
->number
);
10388 uiout
->text (": ");
10389 uiout
->field_string ("exp", w
->exp_string
);
10392 /* Implement the "print_recreate" breakpoint_ops method for
10396 print_recreate_watchpoint (struct breakpoint
*b
, struct ui_file
*fp
)
10398 struct watchpoint
*w
= (struct watchpoint
*) b
;
10402 case bp_watchpoint
:
10403 case bp_hardware_watchpoint
:
10404 fprintf_unfiltered (fp
, "watch");
10406 case bp_read_watchpoint
:
10407 fprintf_unfiltered (fp
, "rwatch");
10409 case bp_access_watchpoint
:
10410 fprintf_unfiltered (fp
, "awatch");
10413 internal_error (__FILE__
, __LINE__
,
10414 _("Invalid watchpoint type."));
10417 fprintf_unfiltered (fp
, " %s", w
->exp_string
);
10418 print_recreate_thread (b
, fp
);
10421 /* Implement the "explains_signal" breakpoint_ops method for
10425 explains_signal_watchpoint (struct breakpoint
*b
, enum gdb_signal sig
)
10427 /* A software watchpoint cannot cause a signal other than
10428 GDB_SIGNAL_TRAP. */
10429 if (b
->type
== bp_watchpoint
&& sig
!= GDB_SIGNAL_TRAP
)
10435 /* The breakpoint_ops structure to be used in hardware watchpoints. */
10437 static struct breakpoint_ops watchpoint_breakpoint_ops
;
10439 /* Implement the "insert" breakpoint_ops method for
10440 masked hardware watchpoints. */
10443 insert_masked_watchpoint (struct bp_location
*bl
)
10445 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10447 return target_insert_mask_watchpoint (bl
->address
, w
->hw_wp_mask
,
10448 bl
->watchpoint_type
);
10451 /* Implement the "remove" breakpoint_ops method for
10452 masked hardware watchpoints. */
10455 remove_masked_watchpoint (struct bp_location
*bl
, enum remove_bp_reason reason
)
10457 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10459 return target_remove_mask_watchpoint (bl
->address
, w
->hw_wp_mask
,
10460 bl
->watchpoint_type
);
10463 /* Implement the "resources_needed" breakpoint_ops method for
10464 masked hardware watchpoints. */
10467 resources_needed_masked_watchpoint (const struct bp_location
*bl
)
10469 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10471 return target_masked_watch_num_registers (bl
->address
, w
->hw_wp_mask
);
10474 /* Implement the "works_in_software_mode" breakpoint_ops method for
10475 masked hardware watchpoints. */
10478 works_in_software_mode_masked_watchpoint (const struct breakpoint
*b
)
10483 /* Implement the "print_it" breakpoint_ops method for
10484 masked hardware watchpoints. */
10486 static enum print_stop_action
10487 print_it_masked_watchpoint (bpstat bs
)
10489 struct breakpoint
*b
= bs
->breakpoint_at
;
10490 struct ui_out
*uiout
= current_uiout
;
10492 /* Masked watchpoints have only one location. */
10493 gdb_assert (b
->loc
&& b
->loc
->next
== NULL
);
10495 annotate_watchpoint (b
->number
);
10496 maybe_print_thread_hit_breakpoint (uiout
);
10500 case bp_hardware_watchpoint
:
10501 if (uiout
->is_mi_like_p ())
10502 uiout
->field_string
10503 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
10506 case bp_read_watchpoint
:
10507 if (uiout
->is_mi_like_p ())
10508 uiout
->field_string
10509 ("reason", async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
10512 case bp_access_watchpoint
:
10513 if (uiout
->is_mi_like_p ())
10514 uiout
->field_string
10516 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
10519 internal_error (__FILE__
, __LINE__
,
10520 _("Invalid hardware watchpoint type."));
10524 uiout
->text (_("\n\
10525 Check the underlying instruction at PC for the memory\n\
10526 address and value which triggered this watchpoint.\n"));
10527 uiout
->text ("\n");
10529 /* More than one watchpoint may have been triggered. */
10530 return PRINT_UNKNOWN
;
10533 /* Implement the "print_one_detail" breakpoint_ops method for
10534 masked hardware watchpoints. */
10537 print_one_detail_masked_watchpoint (const struct breakpoint
*b
,
10538 struct ui_out
*uiout
)
10540 struct watchpoint
*w
= (struct watchpoint
*) b
;
10542 /* Masked watchpoints have only one location. */
10543 gdb_assert (b
->loc
&& b
->loc
->next
== NULL
);
10545 uiout
->text ("\tmask ");
10546 uiout
->field_core_addr ("mask", b
->loc
->gdbarch
, w
->hw_wp_mask
);
10547 uiout
->text ("\n");
10550 /* Implement the "print_mention" breakpoint_ops method for
10551 masked hardware watchpoints. */
10554 print_mention_masked_watchpoint (struct breakpoint
*b
)
10556 struct watchpoint
*w
= (struct watchpoint
*) b
;
10557 struct ui_out
*uiout
= current_uiout
;
10558 const char *tuple_name
;
10562 case bp_hardware_watchpoint
:
10563 uiout
->text ("Masked hardware watchpoint ");
10564 tuple_name
= "wpt";
10566 case bp_read_watchpoint
:
10567 uiout
->text ("Masked hardware read watchpoint ");
10568 tuple_name
= "hw-rwpt";
10570 case bp_access_watchpoint
:
10571 uiout
->text ("Masked hardware access (read/write) watchpoint ");
10572 tuple_name
= "hw-awpt";
10575 internal_error (__FILE__
, __LINE__
,
10576 _("Invalid hardware watchpoint type."));
10579 ui_out_emit_tuple
tuple_emitter (uiout
, tuple_name
);
10580 uiout
->field_int ("number", b
->number
);
10581 uiout
->text (": ");
10582 uiout
->field_string ("exp", w
->exp_string
);
10585 /* Implement the "print_recreate" breakpoint_ops method for
10586 masked hardware watchpoints. */
10589 print_recreate_masked_watchpoint (struct breakpoint
*b
, struct ui_file
*fp
)
10591 struct watchpoint
*w
= (struct watchpoint
*) b
;
10596 case bp_hardware_watchpoint
:
10597 fprintf_unfiltered (fp
, "watch");
10599 case bp_read_watchpoint
:
10600 fprintf_unfiltered (fp
, "rwatch");
10602 case bp_access_watchpoint
:
10603 fprintf_unfiltered (fp
, "awatch");
10606 internal_error (__FILE__
, __LINE__
,
10607 _("Invalid hardware watchpoint type."));
10610 sprintf_vma (tmp
, w
->hw_wp_mask
);
10611 fprintf_unfiltered (fp
, " %s mask 0x%s", w
->exp_string
, tmp
);
10612 print_recreate_thread (b
, fp
);
10615 /* The breakpoint_ops structure to be used in masked hardware watchpoints. */
10617 static struct breakpoint_ops masked_watchpoint_breakpoint_ops
;
10619 /* Tell whether the given watchpoint is a masked hardware watchpoint. */
10622 is_masked_watchpoint (const struct breakpoint
*b
)
10624 return b
->ops
== &masked_watchpoint_breakpoint_ops
;
10627 /* accessflag: hw_write: watch write,
10628 hw_read: watch read,
10629 hw_access: watch access (read or write) */
10631 watch_command_1 (const char *arg
, int accessflag
, int from_tty
,
10632 int just_location
, int internal
)
10634 struct breakpoint
*scope_breakpoint
= NULL
;
10635 const struct block
*exp_valid_block
= NULL
, *cond_exp_valid_block
= NULL
;
10636 struct value
*val
, *mark
, *result
;
10637 int saved_bitpos
= 0, saved_bitsize
= 0;
10638 const char *exp_start
= NULL
;
10639 const char *exp_end
= NULL
;
10640 const char *tok
, *end_tok
;
10642 const char *cond_start
= NULL
;
10643 const char *cond_end
= NULL
;
10644 enum bptype bp_type
;
10647 /* Flag to indicate whether we are going to use masks for
10648 the hardware watchpoint. */
10650 CORE_ADDR mask
= 0;
10652 /* Make sure that we actually have parameters to parse. */
10653 if (arg
!= NULL
&& arg
[0] != '\0')
10655 const char *value_start
;
10657 exp_end
= arg
+ strlen (arg
);
10659 /* Look for "parameter value" pairs at the end
10660 of the arguments string. */
10661 for (tok
= exp_end
- 1; tok
> arg
; tok
--)
10663 /* Skip whitespace at the end of the argument list. */
10664 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
10667 /* Find the beginning of the last token.
10668 This is the value of the parameter. */
10669 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
10671 value_start
= tok
+ 1;
10673 /* Skip whitespace. */
10674 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
10679 /* Find the beginning of the second to last token.
10680 This is the parameter itself. */
10681 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
10684 toklen
= end_tok
- tok
+ 1;
10686 if (toklen
== 6 && startswith (tok
, "thread"))
10688 struct thread_info
*thr
;
10689 /* At this point we've found a "thread" token, which means
10690 the user is trying to set a watchpoint that triggers
10691 only in a specific thread. */
10695 error(_("You can specify only one thread."));
10697 /* Extract the thread ID from the next token. */
10698 thr
= parse_thread_id (value_start
, &endp
);
10700 /* Check if the user provided a valid thread ID. */
10701 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
10702 invalid_thread_id_error (value_start
);
10704 thread
= thr
->global_num
;
10706 else if (toklen
== 4 && startswith (tok
, "mask"))
10708 /* We've found a "mask" token, which means the user wants to
10709 create a hardware watchpoint that is going to have the mask
10711 struct value
*mask_value
, *mark
;
10714 error(_("You can specify only one mask."));
10716 use_mask
= just_location
= 1;
10718 mark
= value_mark ();
10719 mask_value
= parse_to_comma_and_eval (&value_start
);
10720 mask
= value_as_address (mask_value
);
10721 value_free_to_mark (mark
);
10724 /* We didn't recognize what we found. We should stop here. */
10727 /* Truncate the string and get rid of the "parameter value" pair before
10728 the arguments string is parsed by the parse_exp_1 function. */
10735 /* Parse the rest of the arguments. From here on out, everything
10736 is in terms of a newly allocated string instead of the original
10738 innermost_block
= NULL
;
10739 std::string
expression (arg
, exp_end
- arg
);
10740 exp_start
= arg
= expression
.c_str ();
10741 expression_up exp
= parse_exp_1 (&arg
, 0, 0, 0);
10743 /* Remove trailing whitespace from the expression before saving it.
10744 This makes the eventual display of the expression string a bit
10746 while (exp_end
> exp_start
&& (exp_end
[-1] == ' ' || exp_end
[-1] == '\t'))
10749 /* Checking if the expression is not constant. */
10750 if (watchpoint_exp_is_const (exp
.get ()))
10754 len
= exp_end
- exp_start
;
10755 while (len
> 0 && isspace (exp_start
[len
- 1]))
10757 error (_("Cannot watch constant value `%.*s'."), len
, exp_start
);
10760 exp_valid_block
= innermost_block
;
10761 mark
= value_mark ();
10762 fetch_subexp_value (exp
.get (), &pc
, &val
, &result
, NULL
, just_location
);
10764 if (val
!= NULL
&& just_location
)
10766 saved_bitpos
= value_bitpos (val
);
10767 saved_bitsize
= value_bitsize (val
);
10774 exp_valid_block
= NULL
;
10775 val
= value_addr (result
);
10776 release_value (val
);
10777 value_free_to_mark (mark
);
10781 ret
= target_masked_watch_num_registers (value_as_address (val
),
10784 error (_("This target does not support masked watchpoints."));
10785 else if (ret
== -2)
10786 error (_("Invalid mask or memory region."));
10789 else if (val
!= NULL
)
10790 release_value (val
);
10792 tok
= skip_spaces (arg
);
10793 end_tok
= skip_to_space (tok
);
10795 toklen
= end_tok
- tok
;
10796 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
10798 innermost_block
= NULL
;
10799 tok
= cond_start
= end_tok
+ 1;
10800 parse_exp_1 (&tok
, 0, 0, 0);
10802 /* The watchpoint expression may not be local, but the condition
10803 may still be. E.g.: `watch global if local > 0'. */
10804 cond_exp_valid_block
= innermost_block
;
10809 error (_("Junk at end of command."));
10811 frame_info
*wp_frame
= block_innermost_frame (exp_valid_block
);
10813 /* Save this because create_internal_breakpoint below invalidates
10815 frame_id watchpoint_frame
= get_frame_id (wp_frame
);
10817 /* If the expression is "local", then set up a "watchpoint scope"
10818 breakpoint at the point where we've left the scope of the watchpoint
10819 expression. Create the scope breakpoint before the watchpoint, so
10820 that we will encounter it first in bpstat_stop_status. */
10821 if (exp_valid_block
!= NULL
&& wp_frame
!= NULL
)
10823 frame_id caller_frame_id
= frame_unwind_caller_id (wp_frame
);
10825 if (frame_id_p (caller_frame_id
))
10827 gdbarch
*caller_arch
= frame_unwind_caller_arch (wp_frame
);
10828 CORE_ADDR caller_pc
= frame_unwind_caller_pc (wp_frame
);
10831 = create_internal_breakpoint (caller_arch
, caller_pc
,
10832 bp_watchpoint_scope
,
10833 &momentary_breakpoint_ops
);
10835 /* create_internal_breakpoint could invalidate WP_FRAME. */
10838 scope_breakpoint
->enable_state
= bp_enabled
;
10840 /* Automatically delete the breakpoint when it hits. */
10841 scope_breakpoint
->disposition
= disp_del
;
10843 /* Only break in the proper frame (help with recursion). */
10844 scope_breakpoint
->frame_id
= caller_frame_id
;
10846 /* Set the address at which we will stop. */
10847 scope_breakpoint
->loc
->gdbarch
= caller_arch
;
10848 scope_breakpoint
->loc
->requested_address
= caller_pc
;
10849 scope_breakpoint
->loc
->address
10850 = adjust_breakpoint_address (scope_breakpoint
->loc
->gdbarch
,
10851 scope_breakpoint
->loc
->requested_address
,
10852 scope_breakpoint
->type
);
10856 /* Now set up the breakpoint. We create all watchpoints as hardware
10857 watchpoints here even if hardware watchpoints are turned off, a call
10858 to update_watchpoint later in this function will cause the type to
10859 drop back to bp_watchpoint (software watchpoint) if required. */
10861 if (accessflag
== hw_read
)
10862 bp_type
= bp_read_watchpoint
;
10863 else if (accessflag
== hw_access
)
10864 bp_type
= bp_access_watchpoint
;
10866 bp_type
= bp_hardware_watchpoint
;
10868 std::unique_ptr
<watchpoint
> w (new watchpoint ());
10871 init_raw_breakpoint_without_location (w
.get (), NULL
, bp_type
,
10872 &masked_watchpoint_breakpoint_ops
);
10874 init_raw_breakpoint_without_location (w
.get (), NULL
, bp_type
,
10875 &watchpoint_breakpoint_ops
);
10876 w
->thread
= thread
;
10877 w
->disposition
= disp_donttouch
;
10878 w
->pspace
= current_program_space
;
10879 w
->exp
= std::move (exp
);
10880 w
->exp_valid_block
= exp_valid_block
;
10881 w
->cond_exp_valid_block
= cond_exp_valid_block
;
10884 struct type
*t
= value_type (val
);
10885 CORE_ADDR addr
= value_as_address (val
);
10887 w
->exp_string_reparse
10888 = current_language
->la_watch_location_expression (t
, addr
).release ();
10890 w
->exp_string
= xstrprintf ("-location %.*s",
10891 (int) (exp_end
- exp_start
), exp_start
);
10894 w
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
10898 w
->hw_wp_mask
= mask
;
10903 w
->val_bitpos
= saved_bitpos
;
10904 w
->val_bitsize
= saved_bitsize
;
10909 w
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
10911 w
->cond_string
= 0;
10913 if (frame_id_p (watchpoint_frame
))
10915 w
->watchpoint_frame
= watchpoint_frame
;
10916 w
->watchpoint_thread
= inferior_ptid
;
10920 w
->watchpoint_frame
= null_frame_id
;
10921 w
->watchpoint_thread
= null_ptid
;
10924 if (scope_breakpoint
!= NULL
)
10926 /* The scope breakpoint is related to the watchpoint. We will
10927 need to act on them together. */
10928 w
->related_breakpoint
= scope_breakpoint
;
10929 scope_breakpoint
->related_breakpoint
= w
.get ();
10932 if (!just_location
)
10933 value_free_to_mark (mark
);
10935 /* Finally update the new watchpoint. This creates the locations
10936 that should be inserted. */
10937 update_watchpoint (w
.get (), 1);
10939 install_breakpoint (internal
, std::move (w
), 1);
10942 /* Return count of debug registers needed to watch the given expression.
10943 If the watchpoint cannot be handled in hardware return zero. */
10946 can_use_hardware_watchpoint (struct value
*v
)
10948 int found_memory_cnt
= 0;
10949 struct value
*head
= v
;
10951 /* Did the user specifically forbid us to use hardware watchpoints? */
10952 if (!can_use_hw_watchpoints
)
10955 /* Make sure that the value of the expression depends only upon
10956 memory contents, and values computed from them within GDB. If we
10957 find any register references or function calls, we can't use a
10958 hardware watchpoint.
10960 The idea here is that evaluating an expression generates a series
10961 of values, one holding the value of every subexpression. (The
10962 expression a*b+c has five subexpressions: a, b, a*b, c, and
10963 a*b+c.) GDB's values hold almost enough information to establish
10964 the criteria given above --- they identify memory lvalues,
10965 register lvalues, computed values, etcetera. So we can evaluate
10966 the expression, and then scan the chain of values that leaves
10967 behind to decide whether we can detect any possible change to the
10968 expression's final value using only hardware watchpoints.
10970 However, I don't think that the values returned by inferior
10971 function calls are special in any way. So this function may not
10972 notice that an expression involving an inferior function call
10973 can't be watched with hardware watchpoints. FIXME. */
10974 for (; v
; v
= value_next (v
))
10976 if (VALUE_LVAL (v
) == lval_memory
)
10978 if (v
!= head
&& value_lazy (v
))
10979 /* A lazy memory lvalue in the chain is one that GDB never
10980 needed to fetch; we either just used its address (e.g.,
10981 `a' in `a.b') or we never needed it at all (e.g., `a'
10982 in `a,b'). This doesn't apply to HEAD; if that is
10983 lazy then it was not readable, but watch it anyway. */
10987 /* Ahh, memory we actually used! Check if we can cover
10988 it with hardware watchpoints. */
10989 struct type
*vtype
= check_typedef (value_type (v
));
10991 /* We only watch structs and arrays if user asked for it
10992 explicitly, never if they just happen to appear in a
10993 middle of some value chain. */
10995 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
10996 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
10998 CORE_ADDR vaddr
= value_address (v
);
11002 len
= (target_exact_watchpoints
11003 && is_scalar_type_recursive (vtype
))?
11004 1 : TYPE_LENGTH (value_type (v
));
11006 num_regs
= target_region_ok_for_hw_watchpoint (vaddr
, len
);
11010 found_memory_cnt
+= num_regs
;
11014 else if (VALUE_LVAL (v
) != not_lval
11015 && deprecated_value_modifiable (v
) == 0)
11016 return 0; /* These are values from the history (e.g., $1). */
11017 else if (VALUE_LVAL (v
) == lval_register
)
11018 return 0; /* Cannot watch a register with a HW watchpoint. */
11021 /* The expression itself looks suitable for using a hardware
11022 watchpoint, but give the target machine a chance to reject it. */
11023 return found_memory_cnt
;
11027 watch_command_wrapper (const char *arg
, int from_tty
, int internal
)
11029 watch_command_1 (arg
, hw_write
, from_tty
, 0, internal
);
11032 /* A helper function that looks for the "-location" argument and then
11033 calls watch_command_1. */
11036 watch_maybe_just_location (const char *arg
, int accessflag
, int from_tty
)
11038 int just_location
= 0;
11041 && (check_for_argument (&arg
, "-location", sizeof ("-location") - 1)
11042 || check_for_argument (&arg
, "-l", sizeof ("-l") - 1)))
11044 arg
= skip_spaces (arg
);
11048 watch_command_1 (arg
, accessflag
, from_tty
, just_location
, 0);
11052 watch_command (const char *arg
, int from_tty
)
11054 watch_maybe_just_location (arg
, hw_write
, from_tty
);
11058 rwatch_command_wrapper (const char *arg
, int from_tty
, int internal
)
11060 watch_command_1 (arg
, hw_read
, from_tty
, 0, internal
);
11064 rwatch_command (const char *arg
, int from_tty
)
11066 watch_maybe_just_location (arg
, hw_read
, from_tty
);
11070 awatch_command_wrapper (const char *arg
, int from_tty
, int internal
)
11072 watch_command_1 (arg
, hw_access
, from_tty
, 0, internal
);
11076 awatch_command (const char *arg
, int from_tty
)
11078 watch_maybe_just_location (arg
, hw_access
, from_tty
);
11082 /* Data for the FSM that manages the until(location)/advance commands
11083 in infcmd.c. Here because it uses the mechanisms of
11086 struct until_break_fsm
11088 /* The base class. */
11089 struct thread_fsm thread_fsm
;
11091 /* The thread that as current when the command was executed. */
11094 /* The breakpoint set at the destination location. */
11095 struct breakpoint
*location_breakpoint
;
11097 /* Breakpoint set at the return address in the caller frame. May be
11099 struct breakpoint
*caller_breakpoint
;
11102 static void until_break_fsm_clean_up (struct thread_fsm
*self
,
11103 struct thread_info
*thread
);
11104 static int until_break_fsm_should_stop (struct thread_fsm
*self
,
11105 struct thread_info
*thread
);
11106 static enum async_reply_reason
11107 until_break_fsm_async_reply_reason (struct thread_fsm
*self
);
11109 /* until_break_fsm's vtable. */
11111 static struct thread_fsm_ops until_break_fsm_ops
=
11114 until_break_fsm_clean_up
,
11115 until_break_fsm_should_stop
,
11116 NULL
, /* return_value */
11117 until_break_fsm_async_reply_reason
,
11120 /* Allocate a new until_break_command_fsm. */
11122 static struct until_break_fsm
*
11123 new_until_break_fsm (struct interp
*cmd_interp
, int thread
,
11124 breakpoint_up
&&location_breakpoint
,
11125 breakpoint_up
&&caller_breakpoint
)
11127 struct until_break_fsm
*sm
;
11129 sm
= XCNEW (struct until_break_fsm
);
11130 thread_fsm_ctor (&sm
->thread_fsm
, &until_break_fsm_ops
, cmd_interp
);
11132 sm
->thread
= thread
;
11133 sm
->location_breakpoint
= location_breakpoint
.release ();
11134 sm
->caller_breakpoint
= caller_breakpoint
.release ();
11139 /* Implementation of the 'should_stop' FSM method for the
11140 until(location)/advance commands. */
11143 until_break_fsm_should_stop (struct thread_fsm
*self
,
11144 struct thread_info
*tp
)
11146 struct until_break_fsm
*sm
= (struct until_break_fsm
*) self
;
11148 if (bpstat_find_breakpoint (tp
->control
.stop_bpstat
,
11149 sm
->location_breakpoint
) != NULL
11150 || (sm
->caller_breakpoint
!= NULL
11151 && bpstat_find_breakpoint (tp
->control
.stop_bpstat
,
11152 sm
->caller_breakpoint
) != NULL
))
11153 thread_fsm_set_finished (self
);
11158 /* Implementation of the 'clean_up' FSM method for the
11159 until(location)/advance commands. */
11162 until_break_fsm_clean_up (struct thread_fsm
*self
,
11163 struct thread_info
*thread
)
11165 struct until_break_fsm
*sm
= (struct until_break_fsm
*) self
;
11167 /* Clean up our temporary breakpoints. */
11168 if (sm
->location_breakpoint
!= NULL
)
11170 delete_breakpoint (sm
->location_breakpoint
);
11171 sm
->location_breakpoint
= NULL
;
11173 if (sm
->caller_breakpoint
!= NULL
)
11175 delete_breakpoint (sm
->caller_breakpoint
);
11176 sm
->caller_breakpoint
= NULL
;
11178 delete_longjmp_breakpoint (sm
->thread
);
11181 /* Implementation of the 'async_reply_reason' FSM method for the
11182 until(location)/advance commands. */
11184 static enum async_reply_reason
11185 until_break_fsm_async_reply_reason (struct thread_fsm
*self
)
11187 return EXEC_ASYNC_LOCATION_REACHED
;
11191 until_break_command (const char *arg
, int from_tty
, int anywhere
)
11193 struct frame_info
*frame
;
11194 struct gdbarch
*frame_gdbarch
;
11195 struct frame_id stack_frame_id
;
11196 struct frame_id caller_frame_id
;
11197 struct cleanup
*old_chain
;
11199 struct thread_info
*tp
;
11200 struct until_break_fsm
*sm
;
11202 clear_proceed_status (0);
11204 /* Set a breakpoint where the user wants it and at return from
11207 event_location_up location
= string_to_event_location (&arg
, current_language
);
11209 std::vector
<symtab_and_line
> sals
11210 = (last_displayed_sal_is_valid ()
11211 ? decode_line_1 (location
.get (), DECODE_LINE_FUNFIRSTLINE
, NULL
,
11212 get_last_displayed_symtab (),
11213 get_last_displayed_line ())
11214 : decode_line_1 (location
.get (), DECODE_LINE_FUNFIRSTLINE
,
11215 NULL
, (struct symtab
*) NULL
, 0));
11217 if (sals
.size () != 1)
11218 error (_("Couldn't get information on specified line."));
11220 symtab_and_line
&sal
= sals
[0];
11223 error (_("Junk at end of arguments."));
11225 resolve_sal_pc (&sal
);
11227 tp
= inferior_thread ();
11228 thread
= tp
->global_num
;
11230 old_chain
= make_cleanup (null_cleanup
, NULL
);
11232 /* Note linespec handling above invalidates the frame chain.
11233 Installing a breakpoint also invalidates the frame chain (as it
11234 may need to switch threads), so do any frame handling before
11237 frame
= get_selected_frame (NULL
);
11238 frame_gdbarch
= get_frame_arch (frame
);
11239 stack_frame_id
= get_stack_frame_id (frame
);
11240 caller_frame_id
= frame_unwind_caller_id (frame
);
11242 /* Keep within the current frame, or in frames called by the current
11245 breakpoint_up caller_breakpoint
;
11246 if (frame_id_p (caller_frame_id
))
11248 struct symtab_and_line sal2
;
11249 struct gdbarch
*caller_gdbarch
;
11251 sal2
= find_pc_line (frame_unwind_caller_pc (frame
), 0);
11252 sal2
.pc
= frame_unwind_caller_pc (frame
);
11253 caller_gdbarch
= frame_unwind_caller_arch (frame
);
11254 caller_breakpoint
= set_momentary_breakpoint (caller_gdbarch
,
11259 set_longjmp_breakpoint (tp
, caller_frame_id
);
11260 make_cleanup (delete_longjmp_breakpoint_cleanup
, &thread
);
11263 /* set_momentary_breakpoint could invalidate FRAME. */
11266 breakpoint_up location_breakpoint
;
11268 /* If the user told us to continue until a specified location,
11269 we don't specify a frame at which we need to stop. */
11270 location_breakpoint
= set_momentary_breakpoint (frame_gdbarch
, sal
,
11271 null_frame_id
, bp_until
);
11273 /* Otherwise, specify the selected frame, because we want to stop
11274 only at the very same frame. */
11275 location_breakpoint
= set_momentary_breakpoint (frame_gdbarch
, sal
,
11276 stack_frame_id
, bp_until
);
11278 sm
= new_until_break_fsm (command_interp (), tp
->global_num
,
11279 std::move (location_breakpoint
),
11280 std::move (caller_breakpoint
));
11281 tp
->thread_fsm
= &sm
->thread_fsm
;
11283 discard_cleanups (old_chain
);
11285 proceed (-1, GDB_SIGNAL_DEFAULT
);
11288 /* This function attempts to parse an optional "if <cond>" clause
11289 from the arg string. If one is not found, it returns NULL.
11291 Else, it returns a pointer to the condition string. (It does not
11292 attempt to evaluate the string against a particular block.) And,
11293 it updates arg to point to the first character following the parsed
11294 if clause in the arg string. */
11297 ep_parse_optional_if_clause (const char **arg
)
11299 const char *cond_string
;
11301 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
11304 /* Skip the "if" keyword. */
11307 /* Skip any extra leading whitespace, and record the start of the
11308 condition string. */
11309 *arg
= skip_spaces (*arg
);
11310 cond_string
= *arg
;
11312 /* Assume that the condition occupies the remainder of the arg
11314 (*arg
) += strlen (cond_string
);
11316 return cond_string
;
11319 /* Commands to deal with catching events, such as signals, exceptions,
11320 process start/exit, etc. */
11324 catch_fork_temporary
, catch_vfork_temporary
,
11325 catch_fork_permanent
, catch_vfork_permanent
11330 catch_fork_command_1 (const char *arg
, int from_tty
,
11331 struct cmd_list_element
*command
)
11333 struct gdbarch
*gdbarch
= get_current_arch ();
11334 const char *cond_string
= NULL
;
11335 catch_fork_kind fork_kind
;
11338 fork_kind
= (catch_fork_kind
) (uintptr_t) get_cmd_context (command
);
11339 tempflag
= (fork_kind
== catch_fork_temporary
11340 || fork_kind
== catch_vfork_temporary
);
11344 arg
= skip_spaces (arg
);
11346 /* The allowed syntax is:
11348 catch [v]fork if <cond>
11350 First, check if there's an if clause. */
11351 cond_string
= ep_parse_optional_if_clause (&arg
);
11353 if ((*arg
!= '\0') && !isspace (*arg
))
11354 error (_("Junk at end of arguments."));
11356 /* If this target supports it, create a fork or vfork catchpoint
11357 and enable reporting of such events. */
11360 case catch_fork_temporary
:
11361 case catch_fork_permanent
:
11362 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
11363 &catch_fork_breakpoint_ops
);
11365 case catch_vfork_temporary
:
11366 case catch_vfork_permanent
:
11367 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
11368 &catch_vfork_breakpoint_ops
);
11371 error (_("unsupported or unknown fork kind; cannot catch it"));
11377 catch_exec_command_1 (const char *arg
, int from_tty
,
11378 struct cmd_list_element
*command
)
11380 struct gdbarch
*gdbarch
= get_current_arch ();
11382 const char *cond_string
= NULL
;
11384 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
11388 arg
= skip_spaces (arg
);
11390 /* The allowed syntax is:
11392 catch exec if <cond>
11394 First, check if there's an if clause. */
11395 cond_string
= ep_parse_optional_if_clause (&arg
);
11397 if ((*arg
!= '\0') && !isspace (*arg
))
11398 error (_("Junk at end of arguments."));
11400 std::unique_ptr
<exec_catchpoint
> c (new exec_catchpoint ());
11401 init_catchpoint (c
.get (), gdbarch
, tempflag
, cond_string
,
11402 &catch_exec_breakpoint_ops
);
11403 c
->exec_pathname
= NULL
;
11405 install_breakpoint (0, std::move (c
), 1);
11409 init_ada_exception_breakpoint (struct breakpoint
*b
,
11410 struct gdbarch
*gdbarch
,
11411 struct symtab_and_line sal
,
11412 const char *addr_string
,
11413 const struct breakpoint_ops
*ops
,
11420 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
11422 loc_gdbarch
= gdbarch
;
11424 describe_other_breakpoints (loc_gdbarch
,
11425 sal
.pspace
, sal
.pc
, sal
.section
, -1);
11426 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
11427 version for exception catchpoints, because two catchpoints
11428 used for different exception names will use the same address.
11429 In this case, a "breakpoint ... also set at..." warning is
11430 unproductive. Besides, the warning phrasing is also a bit
11431 inappropriate, we should use the word catchpoint, and tell
11432 the user what type of catchpoint it is. The above is good
11433 enough for now, though. */
11436 init_raw_breakpoint (b
, gdbarch
, sal
, bp_breakpoint
, ops
);
11438 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
11439 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
11440 b
->location
= string_to_event_location (&addr_string
,
11441 language_def (language_ada
));
11442 b
->language
= language_ada
;
11446 catch_command (const char *arg
, int from_tty
)
11448 error (_("Catch requires an event name."));
11453 tcatch_command (const char *arg
, int from_tty
)
11455 error (_("Catch requires an event name."));
11458 /* Compare two breakpoints and return a strcmp-like result. */
11461 compare_breakpoints (const breakpoint
*a
, const breakpoint
*b
)
11463 uintptr_t ua
= (uintptr_t) a
;
11464 uintptr_t ub
= (uintptr_t) b
;
11466 if (a
->number
< b
->number
)
11468 else if (a
->number
> b
->number
)
11471 /* Now sort by address, in case we see, e..g, two breakpoints with
11475 return ua
> ub
? 1 : 0;
11478 /* Delete breakpoints by address or line. */
11481 clear_command (const char *arg
, int from_tty
)
11483 struct breakpoint
*b
;
11487 std::vector
<symtab_and_line
> decoded_sals
;
11488 symtab_and_line last_sal
;
11489 gdb::array_view
<symtab_and_line
> sals
;
11493 = decode_line_with_current_source (arg
,
11494 (DECODE_LINE_FUNFIRSTLINE
11495 | DECODE_LINE_LIST_MODE
));
11497 sals
= decoded_sals
;
11501 /* Set sal's line, symtab, pc, and pspace to the values
11502 corresponding to the last call to print_frame_info. If the
11503 codepoint is not valid, this will set all the fields to 0. */
11504 last_sal
= get_last_displayed_sal ();
11505 if (last_sal
.symtab
== 0)
11506 error (_("No source file specified."));
11512 /* We don't call resolve_sal_pc here. That's not as bad as it
11513 seems, because all existing breakpoints typically have both
11514 file/line and pc set. So, if clear is given file/line, we can
11515 match this to existing breakpoint without obtaining pc at all.
11517 We only support clearing given the address explicitly
11518 present in breakpoint table. Say, we've set breakpoint
11519 at file:line. There were several PC values for that file:line,
11520 due to optimization, all in one block.
11522 We've picked one PC value. If "clear" is issued with another
11523 PC corresponding to the same file:line, the breakpoint won't
11524 be cleared. We probably can still clear the breakpoint, but
11525 since the other PC value is never presented to user, user
11526 can only find it by guessing, and it does not seem important
11527 to support that. */
11529 /* For each line spec given, delete bps which correspond to it. Do
11530 it in two passes, solely to preserve the current behavior that
11531 from_tty is forced true if we delete more than one
11534 std::vector
<struct breakpoint
*> found
;
11535 for (const auto &sal
: sals
)
11537 const char *sal_fullname
;
11539 /* If exact pc given, clear bpts at that pc.
11540 If line given (pc == 0), clear all bpts on specified line.
11541 If defaulting, clear all bpts on default line
11544 defaulting sal.pc != 0 tests to do
11549 1 0 <can't happen> */
11551 sal_fullname
= (sal
.symtab
== NULL
11552 ? NULL
: symtab_to_fullname (sal
.symtab
));
11554 /* Find all matching breakpoints and add them to 'found'. */
11555 ALL_BREAKPOINTS (b
)
11558 /* Are we going to delete b? */
11559 if (b
->type
!= bp_none
&& !is_watchpoint (b
))
11561 struct bp_location
*loc
= b
->loc
;
11562 for (; loc
; loc
= loc
->next
)
11564 /* If the user specified file:line, don't allow a PC
11565 match. This matches historical gdb behavior. */
11566 int pc_match
= (!sal
.explicit_line
11568 && (loc
->pspace
== sal
.pspace
)
11569 && (loc
->address
== sal
.pc
)
11570 && (!section_is_overlay (loc
->section
)
11571 || loc
->section
== sal
.section
));
11572 int line_match
= 0;
11574 if ((default_match
|| sal
.explicit_line
)
11575 && loc
->symtab
!= NULL
11576 && sal_fullname
!= NULL
11577 && sal
.pspace
== loc
->pspace
11578 && loc
->line_number
== sal
.line
11579 && filename_cmp (symtab_to_fullname (loc
->symtab
),
11580 sal_fullname
) == 0)
11583 if (pc_match
|| line_match
)
11592 found
.push_back (b
);
11596 /* Now go thru the 'found' chain and delete them. */
11597 if (found
.empty ())
11600 error (_("No breakpoint at %s."), arg
);
11602 error (_("No breakpoint at this line."));
11605 /* Remove duplicates from the vec. */
11606 std::sort (found
.begin (), found
.end (),
11607 [] (const breakpoint
*a
, const breakpoint
*b
)
11609 return compare_breakpoints (a
, b
) < 0;
11611 found
.erase (std::unique (found
.begin (), found
.end (),
11612 [] (const breakpoint
*a
, const breakpoint
*b
)
11614 return compare_breakpoints (a
, b
) == 0;
11618 if (found
.size () > 1)
11619 from_tty
= 1; /* Always report if deleted more than one. */
11622 if (found
.size () == 1)
11623 printf_unfiltered (_("Deleted breakpoint "));
11625 printf_unfiltered (_("Deleted breakpoints "));
11628 for (breakpoint
*iter
: found
)
11631 printf_unfiltered ("%d ", iter
->number
);
11632 delete_breakpoint (iter
);
11635 putchar_unfiltered ('\n');
11638 /* Delete breakpoint in BS if they are `delete' breakpoints and
11639 all breakpoints that are marked for deletion, whether hit or not.
11640 This is called after any breakpoint is hit, or after errors. */
11643 breakpoint_auto_delete (bpstat bs
)
11645 struct breakpoint
*b
, *b_tmp
;
11647 for (; bs
; bs
= bs
->next
)
11648 if (bs
->breakpoint_at
11649 && bs
->breakpoint_at
->disposition
== disp_del
11651 delete_breakpoint (bs
->breakpoint_at
);
11653 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
11655 if (b
->disposition
== disp_del_at_next_stop
)
11656 delete_breakpoint (b
);
11660 /* A comparison function for bp_location AP and BP being interfaced to
11661 qsort. Sort elements primarily by their ADDRESS (no matter what
11662 does breakpoint_address_is_meaningful say for its OWNER),
11663 secondarily by ordering first permanent elements and
11664 terciarily just ensuring the array is sorted stable way despite
11665 qsort being an unstable algorithm. */
11668 bp_locations_compare (const void *ap
, const void *bp
)
11670 const struct bp_location
*a
= *(const struct bp_location
**) ap
;
11671 const struct bp_location
*b
= *(const struct bp_location
**) bp
;
11673 if (a
->address
!= b
->address
)
11674 return (a
->address
> b
->address
) - (a
->address
< b
->address
);
11676 /* Sort locations at the same address by their pspace number, keeping
11677 locations of the same inferior (in a multi-inferior environment)
11680 if (a
->pspace
->num
!= b
->pspace
->num
)
11681 return ((a
->pspace
->num
> b
->pspace
->num
)
11682 - (a
->pspace
->num
< b
->pspace
->num
));
11684 /* Sort permanent breakpoints first. */
11685 if (a
->permanent
!= b
->permanent
)
11686 return (a
->permanent
< b
->permanent
) - (a
->permanent
> b
->permanent
);
11688 /* Make the internal GDB representation stable across GDB runs
11689 where A and B memory inside GDB can differ. Breakpoint locations of
11690 the same type at the same address can be sorted in arbitrary order. */
11692 if (a
->owner
->number
!= b
->owner
->number
)
11693 return ((a
->owner
->number
> b
->owner
->number
)
11694 - (a
->owner
->number
< b
->owner
->number
));
11696 return (a
> b
) - (a
< b
);
11699 /* Set bp_locations_placed_address_before_address_max and
11700 bp_locations_shadow_len_after_address_max according to the current
11701 content of the bp_locations array. */
11704 bp_locations_target_extensions_update (void)
11706 struct bp_location
*bl
, **blp_tmp
;
11708 bp_locations_placed_address_before_address_max
= 0;
11709 bp_locations_shadow_len_after_address_max
= 0;
11711 ALL_BP_LOCATIONS (bl
, blp_tmp
)
11713 CORE_ADDR start
, end
, addr
;
11715 if (!bp_location_has_shadow (bl
))
11718 start
= bl
->target_info
.placed_address
;
11719 end
= start
+ bl
->target_info
.shadow_len
;
11721 gdb_assert (bl
->address
>= start
);
11722 addr
= bl
->address
- start
;
11723 if (addr
> bp_locations_placed_address_before_address_max
)
11724 bp_locations_placed_address_before_address_max
= addr
;
11726 /* Zero SHADOW_LEN would not pass bp_location_has_shadow. */
11728 gdb_assert (bl
->address
< end
);
11729 addr
= end
- bl
->address
;
11730 if (addr
> bp_locations_shadow_len_after_address_max
)
11731 bp_locations_shadow_len_after_address_max
= addr
;
11735 /* Download tracepoint locations if they haven't been. */
11738 download_tracepoint_locations (void)
11740 struct breakpoint
*b
;
11741 enum tribool can_download_tracepoint
= TRIBOOL_UNKNOWN
;
11743 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
11745 ALL_TRACEPOINTS (b
)
11747 struct bp_location
*bl
;
11748 struct tracepoint
*t
;
11749 int bp_location_downloaded
= 0;
11751 if ((b
->type
== bp_fast_tracepoint
11752 ? !may_insert_fast_tracepoints
11753 : !may_insert_tracepoints
))
11756 if (can_download_tracepoint
== TRIBOOL_UNKNOWN
)
11758 if (target_can_download_tracepoint ())
11759 can_download_tracepoint
= TRIBOOL_TRUE
;
11761 can_download_tracepoint
= TRIBOOL_FALSE
;
11764 if (can_download_tracepoint
== TRIBOOL_FALSE
)
11767 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
11769 /* In tracepoint, locations are _never_ duplicated, so
11770 should_be_inserted is equivalent to
11771 unduplicated_should_be_inserted. */
11772 if (!should_be_inserted (bl
) || bl
->inserted
)
11775 switch_to_program_space_and_thread (bl
->pspace
);
11777 target_download_tracepoint (bl
);
11780 bp_location_downloaded
= 1;
11782 t
= (struct tracepoint
*) b
;
11783 t
->number_on_target
= b
->number
;
11784 if (bp_location_downloaded
)
11785 observer_notify_breakpoint_modified (b
);
11789 /* Swap the insertion/duplication state between two locations. */
11792 swap_insertion (struct bp_location
*left
, struct bp_location
*right
)
11794 const int left_inserted
= left
->inserted
;
11795 const int left_duplicate
= left
->duplicate
;
11796 const int left_needs_update
= left
->needs_update
;
11797 const struct bp_target_info left_target_info
= left
->target_info
;
11799 /* Locations of tracepoints can never be duplicated. */
11800 if (is_tracepoint (left
->owner
))
11801 gdb_assert (!left
->duplicate
);
11802 if (is_tracepoint (right
->owner
))
11803 gdb_assert (!right
->duplicate
);
11805 left
->inserted
= right
->inserted
;
11806 left
->duplicate
= right
->duplicate
;
11807 left
->needs_update
= right
->needs_update
;
11808 left
->target_info
= right
->target_info
;
11809 right
->inserted
= left_inserted
;
11810 right
->duplicate
= left_duplicate
;
11811 right
->needs_update
= left_needs_update
;
11812 right
->target_info
= left_target_info
;
11815 /* Force the re-insertion of the locations at ADDRESS. This is called
11816 once a new/deleted/modified duplicate location is found and we are evaluating
11817 conditions on the target's side. Such conditions need to be updated on
11821 force_breakpoint_reinsertion (struct bp_location
*bl
)
11823 struct bp_location
**locp
= NULL
, **loc2p
;
11824 struct bp_location
*loc
;
11825 CORE_ADDR address
= 0;
11828 address
= bl
->address
;
11829 pspace_num
= bl
->pspace
->num
;
11831 /* This is only meaningful if the target is
11832 evaluating conditions and if the user has
11833 opted for condition evaluation on the target's
11835 if (gdb_evaluates_breakpoint_condition_p ()
11836 || !target_supports_evaluation_of_breakpoint_conditions ())
11839 /* Flag all breakpoint locations with this address and
11840 the same program space as the location
11841 as "its condition has changed". We need to
11842 update the conditions on the target's side. */
11843 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, address
)
11847 if (!is_breakpoint (loc
->owner
)
11848 || pspace_num
!= loc
->pspace
->num
)
11851 /* Flag the location appropriately. We use a different state to
11852 let everyone know that we already updated the set of locations
11853 with addr bl->address and program space bl->pspace. This is so
11854 we don't have to keep calling these functions just to mark locations
11855 that have already been marked. */
11856 loc
->condition_changed
= condition_updated
;
11858 /* Free the agent expression bytecode as well. We will compute
11860 loc
->cond_bytecode
.reset ();
11863 /* Called whether new breakpoints are created, or existing breakpoints
11864 deleted, to update the global location list and recompute which
11865 locations are duplicate of which.
11867 The INSERT_MODE flag determines whether locations may not, may, or
11868 shall be inserted now. See 'enum ugll_insert_mode' for more
11872 update_global_location_list (enum ugll_insert_mode insert_mode
)
11874 struct breakpoint
*b
;
11875 struct bp_location
**locp
, *loc
;
11876 /* Last breakpoint location address that was marked for update. */
11877 CORE_ADDR last_addr
= 0;
11878 /* Last breakpoint location program space that was marked for update. */
11879 int last_pspace_num
= -1;
11881 /* Used in the duplicates detection below. When iterating over all
11882 bp_locations, points to the first bp_location of a given address.
11883 Breakpoints and watchpoints of different types are never
11884 duplicates of each other. Keep one pointer for each type of
11885 breakpoint/watchpoint, so we only need to loop over all locations
11887 struct bp_location
*bp_loc_first
; /* breakpoint */
11888 struct bp_location
*wp_loc_first
; /* hardware watchpoint */
11889 struct bp_location
*awp_loc_first
; /* access watchpoint */
11890 struct bp_location
*rwp_loc_first
; /* read watchpoint */
11892 /* Saved former bp_locations array which we compare against the newly
11893 built bp_locations from the current state of ALL_BREAKPOINTS. */
11894 struct bp_location
**old_locp
;
11895 unsigned old_locations_count
;
11896 gdb::unique_xmalloc_ptr
<struct bp_location
*> old_locations (bp_locations
);
11898 old_locations_count
= bp_locations_count
;
11899 bp_locations
= NULL
;
11900 bp_locations_count
= 0;
11902 ALL_BREAKPOINTS (b
)
11903 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
11904 bp_locations_count
++;
11906 bp_locations
= XNEWVEC (struct bp_location
*, bp_locations_count
);
11907 locp
= bp_locations
;
11908 ALL_BREAKPOINTS (b
)
11909 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
11911 qsort (bp_locations
, bp_locations_count
, sizeof (*bp_locations
),
11912 bp_locations_compare
);
11914 bp_locations_target_extensions_update ();
11916 /* Identify bp_location instances that are no longer present in the
11917 new list, and therefore should be freed. Note that it's not
11918 necessary that those locations should be removed from inferior --
11919 if there's another location at the same address (previously
11920 marked as duplicate), we don't need to remove/insert the
11923 LOCP is kept in sync with OLD_LOCP, each pointing to the current
11924 and former bp_location array state respectively. */
11926 locp
= bp_locations
;
11927 for (old_locp
= old_locations
.get ();
11928 old_locp
< old_locations
.get () + old_locations_count
;
11931 struct bp_location
*old_loc
= *old_locp
;
11932 struct bp_location
**loc2p
;
11934 /* Tells if 'old_loc' is found among the new locations. If
11935 not, we have to free it. */
11936 int found_object
= 0;
11937 /* Tells if the location should remain inserted in the target. */
11938 int keep_in_target
= 0;
11941 /* Skip LOCP entries which will definitely never be needed.
11942 Stop either at or being the one matching OLD_LOC. */
11943 while (locp
< bp_locations
+ bp_locations_count
11944 && (*locp
)->address
< old_loc
->address
)
11948 (loc2p
< bp_locations
+ bp_locations_count
11949 && (*loc2p
)->address
== old_loc
->address
);
11952 /* Check if this is a new/duplicated location or a duplicated
11953 location that had its condition modified. If so, we want to send
11954 its condition to the target if evaluation of conditions is taking
11956 if ((*loc2p
)->condition_changed
== condition_modified
11957 && (last_addr
!= old_loc
->address
11958 || last_pspace_num
!= old_loc
->pspace
->num
))
11960 force_breakpoint_reinsertion (*loc2p
);
11961 last_pspace_num
= old_loc
->pspace
->num
;
11964 if (*loc2p
== old_loc
)
11968 /* We have already handled this address, update it so that we don't
11969 have to go through updates again. */
11970 last_addr
= old_loc
->address
;
11972 /* Target-side condition evaluation: Handle deleted locations. */
11974 force_breakpoint_reinsertion (old_loc
);
11976 /* If this location is no longer present, and inserted, look if
11977 there's maybe a new location at the same address. If so,
11978 mark that one inserted, and don't remove this one. This is
11979 needed so that we don't have a time window where a breakpoint
11980 at certain location is not inserted. */
11982 if (old_loc
->inserted
)
11984 /* If the location is inserted now, we might have to remove
11987 if (found_object
&& should_be_inserted (old_loc
))
11989 /* The location is still present in the location list,
11990 and still should be inserted. Don't do anything. */
11991 keep_in_target
= 1;
11995 /* This location still exists, but it won't be kept in the
11996 target since it may have been disabled. We proceed to
11997 remove its target-side condition. */
11999 /* The location is either no longer present, or got
12000 disabled. See if there's another location at the
12001 same address, in which case we don't need to remove
12002 this one from the target. */
12004 /* OLD_LOC comes from existing struct breakpoint. */
12005 if (breakpoint_address_is_meaningful (old_loc
->owner
))
12008 (loc2p
< bp_locations
+ bp_locations_count
12009 && (*loc2p
)->address
== old_loc
->address
);
12012 struct bp_location
*loc2
= *loc2p
;
12014 if (breakpoint_locations_match (loc2
, old_loc
))
12016 /* Read watchpoint locations are switched to
12017 access watchpoints, if the former are not
12018 supported, but the latter are. */
12019 if (is_hardware_watchpoint (old_loc
->owner
))
12021 gdb_assert (is_hardware_watchpoint (loc2
->owner
));
12022 loc2
->watchpoint_type
= old_loc
->watchpoint_type
;
12025 /* loc2 is a duplicated location. We need to check
12026 if it should be inserted in case it will be
12028 if (loc2
!= old_loc
12029 && unduplicated_should_be_inserted (loc2
))
12031 swap_insertion (old_loc
, loc2
);
12032 keep_in_target
= 1;
12040 if (!keep_in_target
)
12042 if (remove_breakpoint (old_loc
))
12044 /* This is just about all we can do. We could keep
12045 this location on the global list, and try to
12046 remove it next time, but there's no particular
12047 reason why we will succeed next time.
12049 Note that at this point, old_loc->owner is still
12050 valid, as delete_breakpoint frees the breakpoint
12051 only after calling us. */
12052 printf_filtered (_("warning: Error removing "
12053 "breakpoint %d\n"),
12054 old_loc
->owner
->number
);
12062 if (removed
&& target_is_non_stop_p ()
12063 && need_moribund_for_location_type (old_loc
))
12065 /* This location was removed from the target. In
12066 non-stop mode, a race condition is possible where
12067 we've removed a breakpoint, but stop events for that
12068 breakpoint are already queued and will arrive later.
12069 We apply an heuristic to be able to distinguish such
12070 SIGTRAPs from other random SIGTRAPs: we keep this
12071 breakpoint location for a bit, and will retire it
12072 after we see some number of events. The theory here
12073 is that reporting of events should, "on the average",
12074 be fair, so after a while we'll see events from all
12075 threads that have anything of interest, and no longer
12076 need to keep this breakpoint location around. We
12077 don't hold locations forever so to reduce chances of
12078 mistaking a non-breakpoint SIGTRAP for a breakpoint
12081 The heuristic failing can be disastrous on
12082 decr_pc_after_break targets.
12084 On decr_pc_after_break targets, like e.g., x86-linux,
12085 if we fail to recognize a late breakpoint SIGTRAP,
12086 because events_till_retirement has reached 0 too
12087 soon, we'll fail to do the PC adjustment, and report
12088 a random SIGTRAP to the user. When the user resumes
12089 the inferior, it will most likely immediately crash
12090 with SIGILL/SIGBUS/SIGSEGV, or worse, get silently
12091 corrupted, because of being resumed e.g., in the
12092 middle of a multi-byte instruction, or skipped a
12093 one-byte instruction. This was actually seen happen
12094 on native x86-linux, and should be less rare on
12095 targets that do not support new thread events, like
12096 remote, due to the heuristic depending on
12099 Mistaking a random SIGTRAP for a breakpoint trap
12100 causes similar symptoms (PC adjustment applied when
12101 it shouldn't), but then again, playing with SIGTRAPs
12102 behind the debugger's back is asking for trouble.
12104 Since hardware watchpoint traps are always
12105 distinguishable from other traps, so we don't need to
12106 apply keep hardware watchpoint moribund locations
12107 around. We simply always ignore hardware watchpoint
12108 traps we can no longer explain. */
12110 old_loc
->events_till_retirement
= 3 * (thread_count () + 1);
12111 old_loc
->owner
= NULL
;
12113 VEC_safe_push (bp_location_p
, moribund_locations
, old_loc
);
12117 old_loc
->owner
= NULL
;
12118 decref_bp_location (&old_loc
);
12123 /* Rescan breakpoints at the same address and section, marking the
12124 first one as "first" and any others as "duplicates". This is so
12125 that the bpt instruction is only inserted once. If we have a
12126 permanent breakpoint at the same place as BPT, make that one the
12127 official one, and the rest as duplicates. Permanent breakpoints
12128 are sorted first for the same address.
12130 Do the same for hardware watchpoints, but also considering the
12131 watchpoint's type (regular/access/read) and length. */
12133 bp_loc_first
= NULL
;
12134 wp_loc_first
= NULL
;
12135 awp_loc_first
= NULL
;
12136 rwp_loc_first
= NULL
;
12137 ALL_BP_LOCATIONS (loc
, locp
)
12139 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always
12141 struct bp_location
**loc_first_p
;
12144 if (!unduplicated_should_be_inserted (loc
)
12145 || !breakpoint_address_is_meaningful (b
)
12146 /* Don't detect duplicate for tracepoint locations because they are
12147 never duplicated. See the comments in field `duplicate' of
12148 `struct bp_location'. */
12149 || is_tracepoint (b
))
12151 /* Clear the condition modification flag. */
12152 loc
->condition_changed
= condition_unchanged
;
12156 if (b
->type
== bp_hardware_watchpoint
)
12157 loc_first_p
= &wp_loc_first
;
12158 else if (b
->type
== bp_read_watchpoint
)
12159 loc_first_p
= &rwp_loc_first
;
12160 else if (b
->type
== bp_access_watchpoint
)
12161 loc_first_p
= &awp_loc_first
;
12163 loc_first_p
= &bp_loc_first
;
12165 if (*loc_first_p
== NULL
12166 || (overlay_debugging
&& loc
->section
!= (*loc_first_p
)->section
)
12167 || !breakpoint_locations_match (loc
, *loc_first_p
))
12169 *loc_first_p
= loc
;
12170 loc
->duplicate
= 0;
12172 if (is_breakpoint (loc
->owner
) && loc
->condition_changed
)
12174 loc
->needs_update
= 1;
12175 /* Clear the condition modification flag. */
12176 loc
->condition_changed
= condition_unchanged
;
12182 /* This and the above ensure the invariant that the first location
12183 is not duplicated, and is the inserted one.
12184 All following are marked as duplicated, and are not inserted. */
12186 swap_insertion (loc
, *loc_first_p
);
12187 loc
->duplicate
= 1;
12189 /* Clear the condition modification flag. */
12190 loc
->condition_changed
= condition_unchanged
;
12193 if (insert_mode
== UGLL_INSERT
|| breakpoints_should_be_inserted_now ())
12195 if (insert_mode
!= UGLL_DONT_INSERT
)
12196 insert_breakpoint_locations ();
12199 /* Even though the caller told us to not insert new
12200 locations, we may still need to update conditions on the
12201 target's side of breakpoints that were already inserted
12202 if the target is evaluating breakpoint conditions. We
12203 only update conditions for locations that are marked
12205 update_inserted_breakpoint_locations ();
12209 if (insert_mode
!= UGLL_DONT_INSERT
)
12210 download_tracepoint_locations ();
12214 breakpoint_retire_moribund (void)
12216 struct bp_location
*loc
;
12219 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
12220 if (--(loc
->events_till_retirement
) == 0)
12222 decref_bp_location (&loc
);
12223 VEC_unordered_remove (bp_location_p
, moribund_locations
, ix
);
12229 update_global_location_list_nothrow (enum ugll_insert_mode insert_mode
)
12234 update_global_location_list (insert_mode
);
12236 CATCH (e
, RETURN_MASK_ERROR
)
12242 /* Clear BKP from a BPS. */
12245 bpstat_remove_bp_location (bpstat bps
, struct breakpoint
*bpt
)
12249 for (bs
= bps
; bs
; bs
= bs
->next
)
12250 if (bs
->breakpoint_at
== bpt
)
12252 bs
->breakpoint_at
= NULL
;
12253 bs
->old_val
= NULL
;
12254 /* bs->commands will be freed later. */
12258 /* Callback for iterate_over_threads. */
12260 bpstat_remove_breakpoint_callback (struct thread_info
*th
, void *data
)
12262 struct breakpoint
*bpt
= (struct breakpoint
*) data
;
12264 bpstat_remove_bp_location (th
->control
.stop_bpstat
, bpt
);
12268 /* Helper for breakpoint and tracepoint breakpoint_ops->mention
12272 say_where (struct breakpoint
*b
)
12274 struct value_print_options opts
;
12276 get_user_print_options (&opts
);
12278 /* i18n: cagney/2005-02-11: Below needs to be merged into a
12280 if (b
->loc
== NULL
)
12282 /* For pending locations, the output differs slightly based
12283 on b->extra_string. If this is non-NULL, it contains either
12284 a condition or dprintf arguments. */
12285 if (b
->extra_string
== NULL
)
12287 printf_filtered (_(" (%s) pending."),
12288 event_location_to_string (b
->location
.get ()));
12290 else if (b
->type
== bp_dprintf
)
12292 printf_filtered (_(" (%s,%s) pending."),
12293 event_location_to_string (b
->location
.get ()),
12298 printf_filtered (_(" (%s %s) pending."),
12299 event_location_to_string (b
->location
.get ()),
12305 if (opts
.addressprint
|| b
->loc
->symtab
== NULL
)
12307 printf_filtered (" at ");
12308 fputs_filtered (paddress (b
->loc
->gdbarch
, b
->loc
->address
),
12311 if (b
->loc
->symtab
!= NULL
)
12313 /* If there is a single location, we can print the location
12315 if (b
->loc
->next
== NULL
)
12316 printf_filtered (": file %s, line %d.",
12317 symtab_to_filename_for_display (b
->loc
->symtab
),
12318 b
->loc
->line_number
);
12320 /* This is not ideal, but each location may have a
12321 different file name, and this at least reflects the
12322 real situation somewhat. */
12323 printf_filtered (": %s.",
12324 event_location_to_string (b
->location
.get ()));
12329 struct bp_location
*loc
= b
->loc
;
12331 for (; loc
; loc
= loc
->next
)
12333 printf_filtered (" (%d locations)", n
);
12338 /* Default bp_location_ops methods. */
12341 bp_location_dtor (struct bp_location
*self
)
12343 xfree (self
->function_name
);
12346 static const struct bp_location_ops bp_location_ops
=
12351 /* Destructor for the breakpoint base class. */
12353 breakpoint::~breakpoint ()
12355 xfree (this->cond_string
);
12356 xfree (this->extra_string
);
12357 xfree (this->filter
);
12360 static struct bp_location
*
12361 base_breakpoint_allocate_location (struct breakpoint
*self
)
12363 return new bp_location (&bp_location_ops
, self
);
12367 base_breakpoint_re_set (struct breakpoint
*b
)
12369 /* Nothing to re-set. */
12372 #define internal_error_pure_virtual_called() \
12373 gdb_assert_not_reached ("pure virtual function called")
12376 base_breakpoint_insert_location (struct bp_location
*bl
)
12378 internal_error_pure_virtual_called ();
12382 base_breakpoint_remove_location (struct bp_location
*bl
,
12383 enum remove_bp_reason reason
)
12385 internal_error_pure_virtual_called ();
12389 base_breakpoint_breakpoint_hit (const struct bp_location
*bl
,
12390 const address_space
*aspace
,
12392 const struct target_waitstatus
*ws
)
12394 internal_error_pure_virtual_called ();
12398 base_breakpoint_check_status (bpstat bs
)
12403 /* A "works_in_software_mode" breakpoint_ops method that just internal
12407 base_breakpoint_works_in_software_mode (const struct breakpoint
*b
)
12409 internal_error_pure_virtual_called ();
12412 /* A "resources_needed" breakpoint_ops method that just internal
12416 base_breakpoint_resources_needed (const struct bp_location
*bl
)
12418 internal_error_pure_virtual_called ();
12421 static enum print_stop_action
12422 base_breakpoint_print_it (bpstat bs
)
12424 internal_error_pure_virtual_called ();
12428 base_breakpoint_print_one_detail (const struct breakpoint
*self
,
12429 struct ui_out
*uiout
)
12435 base_breakpoint_print_mention (struct breakpoint
*b
)
12437 internal_error_pure_virtual_called ();
12441 base_breakpoint_print_recreate (struct breakpoint
*b
, struct ui_file
*fp
)
12443 internal_error_pure_virtual_called ();
12447 base_breakpoint_create_sals_from_location
12448 (const struct event_location
*location
,
12449 struct linespec_result
*canonical
,
12450 enum bptype type_wanted
)
12452 internal_error_pure_virtual_called ();
12456 base_breakpoint_create_breakpoints_sal (struct gdbarch
*gdbarch
,
12457 struct linespec_result
*c
,
12458 gdb::unique_xmalloc_ptr
<char> cond_string
,
12459 gdb::unique_xmalloc_ptr
<char> extra_string
,
12460 enum bptype type_wanted
,
12461 enum bpdisp disposition
,
12463 int task
, int ignore_count
,
12464 const struct breakpoint_ops
*o
,
12465 int from_tty
, int enabled
,
12466 int internal
, unsigned flags
)
12468 internal_error_pure_virtual_called ();
12471 static std::vector
<symtab_and_line
>
12472 base_breakpoint_decode_location (struct breakpoint
*b
,
12473 const struct event_location
*location
,
12474 struct program_space
*search_pspace
)
12476 internal_error_pure_virtual_called ();
12479 /* The default 'explains_signal' method. */
12482 base_breakpoint_explains_signal (struct breakpoint
*b
, enum gdb_signal sig
)
12487 /* The default "after_condition_true" method. */
12490 base_breakpoint_after_condition_true (struct bpstats
*bs
)
12492 /* Nothing to do. */
12495 struct breakpoint_ops base_breakpoint_ops
=
12497 base_breakpoint_allocate_location
,
12498 base_breakpoint_re_set
,
12499 base_breakpoint_insert_location
,
12500 base_breakpoint_remove_location
,
12501 base_breakpoint_breakpoint_hit
,
12502 base_breakpoint_check_status
,
12503 base_breakpoint_resources_needed
,
12504 base_breakpoint_works_in_software_mode
,
12505 base_breakpoint_print_it
,
12507 base_breakpoint_print_one_detail
,
12508 base_breakpoint_print_mention
,
12509 base_breakpoint_print_recreate
,
12510 base_breakpoint_create_sals_from_location
,
12511 base_breakpoint_create_breakpoints_sal
,
12512 base_breakpoint_decode_location
,
12513 base_breakpoint_explains_signal
,
12514 base_breakpoint_after_condition_true
,
12517 /* Default breakpoint_ops methods. */
12520 bkpt_re_set (struct breakpoint
*b
)
12522 /* FIXME: is this still reachable? */
12523 if (breakpoint_event_location_empty_p (b
))
12525 /* Anything without a location can't be re-set. */
12526 delete_breakpoint (b
);
12530 breakpoint_re_set_default (b
);
12534 bkpt_insert_location (struct bp_location
*bl
)
12536 CORE_ADDR addr
= bl
->target_info
.reqstd_address
;
12538 bl
->target_info
.kind
= breakpoint_kind (bl
, &addr
);
12539 bl
->target_info
.placed_address
= addr
;
12541 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
12542 return target_insert_hw_breakpoint (bl
->gdbarch
, &bl
->target_info
);
12544 return target_insert_breakpoint (bl
->gdbarch
, &bl
->target_info
);
12548 bkpt_remove_location (struct bp_location
*bl
, enum remove_bp_reason reason
)
12550 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
12551 return target_remove_hw_breakpoint (bl
->gdbarch
, &bl
->target_info
);
12553 return target_remove_breakpoint (bl
->gdbarch
, &bl
->target_info
, reason
);
12557 bkpt_breakpoint_hit (const struct bp_location
*bl
,
12558 const address_space
*aspace
, CORE_ADDR bp_addr
,
12559 const struct target_waitstatus
*ws
)
12561 if (ws
->kind
!= TARGET_WAITKIND_STOPPED
12562 || ws
->value
.sig
!= GDB_SIGNAL_TRAP
)
12565 if (!breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
12569 if (overlay_debugging
/* unmapped overlay section */
12570 && section_is_overlay (bl
->section
)
12571 && !section_is_mapped (bl
->section
))
12578 dprintf_breakpoint_hit (const struct bp_location
*bl
,
12579 const address_space
*aspace
, CORE_ADDR bp_addr
,
12580 const struct target_waitstatus
*ws
)
12582 if (dprintf_style
== dprintf_style_agent
12583 && target_can_run_breakpoint_commands ())
12585 /* An agent-style dprintf never causes a stop. If we see a trap
12586 for this address it must be for a breakpoint that happens to
12587 be set at the same address. */
12591 return bkpt_breakpoint_hit (bl
, aspace
, bp_addr
, ws
);
12595 bkpt_resources_needed (const struct bp_location
*bl
)
12597 gdb_assert (bl
->owner
->type
== bp_hardware_breakpoint
);
12602 static enum print_stop_action
12603 bkpt_print_it (bpstat bs
)
12605 struct breakpoint
*b
;
12606 const struct bp_location
*bl
;
12608 struct ui_out
*uiout
= current_uiout
;
12610 gdb_assert (bs
->bp_location_at
!= NULL
);
12612 bl
= bs
->bp_location_at
;
12613 b
= bs
->breakpoint_at
;
12615 bp_temp
= b
->disposition
== disp_del
;
12616 if (bl
->address
!= bl
->requested_address
)
12617 breakpoint_adjustment_warning (bl
->requested_address
,
12620 annotate_breakpoint (b
->number
);
12621 maybe_print_thread_hit_breakpoint (uiout
);
12624 uiout
->text ("Temporary breakpoint ");
12626 uiout
->text ("Breakpoint ");
12627 if (uiout
->is_mi_like_p ())
12629 uiout
->field_string ("reason",
12630 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
12631 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
12633 uiout
->field_int ("bkptno", b
->number
);
12634 uiout
->text (", ");
12636 return PRINT_SRC_AND_LOC
;
12640 bkpt_print_mention (struct breakpoint
*b
)
12642 if (current_uiout
->is_mi_like_p ())
12647 case bp_breakpoint
:
12648 case bp_gnu_ifunc_resolver
:
12649 if (b
->disposition
== disp_del
)
12650 printf_filtered (_("Temporary breakpoint"));
12652 printf_filtered (_("Breakpoint"));
12653 printf_filtered (_(" %d"), b
->number
);
12654 if (b
->type
== bp_gnu_ifunc_resolver
)
12655 printf_filtered (_(" at gnu-indirect-function resolver"));
12657 case bp_hardware_breakpoint
:
12658 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
12661 printf_filtered (_("Dprintf %d"), b
->number
);
12669 bkpt_print_recreate (struct breakpoint
*tp
, struct ui_file
*fp
)
12671 if (tp
->type
== bp_breakpoint
&& tp
->disposition
== disp_del
)
12672 fprintf_unfiltered (fp
, "tbreak");
12673 else if (tp
->type
== bp_breakpoint
)
12674 fprintf_unfiltered (fp
, "break");
12675 else if (tp
->type
== bp_hardware_breakpoint
12676 && tp
->disposition
== disp_del
)
12677 fprintf_unfiltered (fp
, "thbreak");
12678 else if (tp
->type
== bp_hardware_breakpoint
)
12679 fprintf_unfiltered (fp
, "hbreak");
12681 internal_error (__FILE__
, __LINE__
,
12682 _("unhandled breakpoint type %d"), (int) tp
->type
);
12684 fprintf_unfiltered (fp
, " %s",
12685 event_location_to_string (tp
->location
.get ()));
12687 /* Print out extra_string if this breakpoint is pending. It might
12688 contain, for example, conditions that were set by the user. */
12689 if (tp
->loc
== NULL
&& tp
->extra_string
!= NULL
)
12690 fprintf_unfiltered (fp
, " %s", tp
->extra_string
);
12692 print_recreate_thread (tp
, fp
);
12696 bkpt_create_sals_from_location (const struct event_location
*location
,
12697 struct linespec_result
*canonical
,
12698 enum bptype type_wanted
)
12700 create_sals_from_location_default (location
, canonical
, type_wanted
);
12704 bkpt_create_breakpoints_sal (struct gdbarch
*gdbarch
,
12705 struct linespec_result
*canonical
,
12706 gdb::unique_xmalloc_ptr
<char> cond_string
,
12707 gdb::unique_xmalloc_ptr
<char> extra_string
,
12708 enum bptype type_wanted
,
12709 enum bpdisp disposition
,
12711 int task
, int ignore_count
,
12712 const struct breakpoint_ops
*ops
,
12713 int from_tty
, int enabled
,
12714 int internal
, unsigned flags
)
12716 create_breakpoints_sal_default (gdbarch
, canonical
,
12717 std::move (cond_string
),
12718 std::move (extra_string
),
12720 disposition
, thread
, task
,
12721 ignore_count
, ops
, from_tty
,
12722 enabled
, internal
, flags
);
12725 static std::vector
<symtab_and_line
>
12726 bkpt_decode_location (struct breakpoint
*b
,
12727 const struct event_location
*location
,
12728 struct program_space
*search_pspace
)
12730 return decode_location_default (b
, location
, search_pspace
);
12733 /* Virtual table for internal breakpoints. */
12736 internal_bkpt_re_set (struct breakpoint
*b
)
12740 /* Delete overlay event and longjmp master breakpoints; they
12741 will be reset later by breakpoint_re_set. */
12742 case bp_overlay_event
:
12743 case bp_longjmp_master
:
12744 case bp_std_terminate_master
:
12745 case bp_exception_master
:
12746 delete_breakpoint (b
);
12749 /* This breakpoint is special, it's set up when the inferior
12750 starts and we really don't want to touch it. */
12751 case bp_shlib_event
:
12753 /* Like bp_shlib_event, this breakpoint type is special. Once
12754 it is set up, we do not want to touch it. */
12755 case bp_thread_event
:
12761 internal_bkpt_check_status (bpstat bs
)
12763 if (bs
->breakpoint_at
->type
== bp_shlib_event
)
12765 /* If requested, stop when the dynamic linker notifies GDB of
12766 events. This allows the user to get control and place
12767 breakpoints in initializer routines for dynamically loaded
12768 objects (among other things). */
12769 bs
->stop
= stop_on_solib_events
;
12770 bs
->print
= stop_on_solib_events
;
12776 static enum print_stop_action
12777 internal_bkpt_print_it (bpstat bs
)
12779 struct breakpoint
*b
;
12781 b
= bs
->breakpoint_at
;
12785 case bp_shlib_event
:
12786 /* Did we stop because the user set the stop_on_solib_events
12787 variable? (If so, we report this as a generic, "Stopped due
12788 to shlib event" message.) */
12789 print_solib_event (0);
12792 case bp_thread_event
:
12793 /* Not sure how we will get here.
12794 GDB should not stop for these breakpoints. */
12795 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
12798 case bp_overlay_event
:
12799 /* By analogy with the thread event, GDB should not stop for these. */
12800 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
12803 case bp_longjmp_master
:
12804 /* These should never be enabled. */
12805 printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
12808 case bp_std_terminate_master
:
12809 /* These should never be enabled. */
12810 printf_filtered (_("std::terminate Master Breakpoint: "
12811 "gdb should not stop!\n"));
12814 case bp_exception_master
:
12815 /* These should never be enabled. */
12816 printf_filtered (_("Exception Master Breakpoint: "
12817 "gdb should not stop!\n"));
12821 return PRINT_NOTHING
;
12825 internal_bkpt_print_mention (struct breakpoint
*b
)
12827 /* Nothing to mention. These breakpoints are internal. */
12830 /* Virtual table for momentary breakpoints */
12833 momentary_bkpt_re_set (struct breakpoint
*b
)
12835 /* Keep temporary breakpoints, which can be encountered when we step
12836 over a dlopen call and solib_add is resetting the breakpoints.
12837 Otherwise these should have been blown away via the cleanup chain
12838 or by breakpoint_init_inferior when we rerun the executable. */
12842 momentary_bkpt_check_status (bpstat bs
)
12844 /* Nothing. The point of these breakpoints is causing a stop. */
12847 static enum print_stop_action
12848 momentary_bkpt_print_it (bpstat bs
)
12850 return PRINT_UNKNOWN
;
12854 momentary_bkpt_print_mention (struct breakpoint
*b
)
12856 /* Nothing to mention. These breakpoints are internal. */
12859 /* Ensure INITIATING_FRAME is cleared when no such breakpoint exists.
12861 It gets cleared already on the removal of the first one of such placed
12862 breakpoints. This is OK as they get all removed altogether. */
12864 longjmp_breakpoint::~longjmp_breakpoint ()
12866 thread_info
*tp
= find_thread_global_id (this->thread
);
12869 tp
->initiating_frame
= null_frame_id
;
12872 /* Specific methods for probe breakpoints. */
12875 bkpt_probe_insert_location (struct bp_location
*bl
)
12877 int v
= bkpt_insert_location (bl
);
12881 /* The insertion was successful, now let's set the probe's semaphore
12883 if (bl
->probe
.probe
->pops
->set_semaphore
!= NULL
)
12884 bl
->probe
.probe
->pops
->set_semaphore (bl
->probe
.probe
,
12893 bkpt_probe_remove_location (struct bp_location
*bl
,
12894 enum remove_bp_reason reason
)
12896 /* Let's clear the semaphore before removing the location. */
12897 if (bl
->probe
.probe
->pops
->clear_semaphore
!= NULL
)
12898 bl
->probe
.probe
->pops
->clear_semaphore (bl
->probe
.probe
,
12902 return bkpt_remove_location (bl
, reason
);
12906 bkpt_probe_create_sals_from_location (const struct event_location
*location
,
12907 struct linespec_result
*canonical
,
12908 enum bptype type_wanted
)
12910 struct linespec_sals lsal
;
12912 lsal
.sals
= parse_probes (location
, NULL
, canonical
);
12914 = xstrdup (event_location_to_string (canonical
->location
.get ()));
12915 canonical
->lsals
.push_back (std::move (lsal
));
12918 static std::vector
<symtab_and_line
>
12919 bkpt_probe_decode_location (struct breakpoint
*b
,
12920 const struct event_location
*location
,
12921 struct program_space
*search_pspace
)
12923 std::vector
<symtab_and_line
> sals
= parse_probes (location
, search_pspace
, NULL
);
12925 error (_("probe not found"));
12929 /* The breakpoint_ops structure to be used in tracepoints. */
12932 tracepoint_re_set (struct breakpoint
*b
)
12934 breakpoint_re_set_default (b
);
12938 tracepoint_breakpoint_hit (const struct bp_location
*bl
,
12939 const address_space
*aspace
, CORE_ADDR bp_addr
,
12940 const struct target_waitstatus
*ws
)
12942 /* By definition, the inferior does not report stops at
12948 tracepoint_print_one_detail (const struct breakpoint
*self
,
12949 struct ui_out
*uiout
)
12951 struct tracepoint
*tp
= (struct tracepoint
*) self
;
12952 if (tp
->static_trace_marker_id
)
12954 gdb_assert (self
->type
== bp_static_tracepoint
);
12956 uiout
->text ("\tmarker id is ");
12957 uiout
->field_string ("static-tracepoint-marker-string-id",
12958 tp
->static_trace_marker_id
);
12959 uiout
->text ("\n");
12964 tracepoint_print_mention (struct breakpoint
*b
)
12966 if (current_uiout
->is_mi_like_p ())
12971 case bp_tracepoint
:
12972 printf_filtered (_("Tracepoint"));
12973 printf_filtered (_(" %d"), b
->number
);
12975 case bp_fast_tracepoint
:
12976 printf_filtered (_("Fast tracepoint"));
12977 printf_filtered (_(" %d"), b
->number
);
12979 case bp_static_tracepoint
:
12980 printf_filtered (_("Static tracepoint"));
12981 printf_filtered (_(" %d"), b
->number
);
12984 internal_error (__FILE__
, __LINE__
,
12985 _("unhandled tracepoint type %d"), (int) b
->type
);
12992 tracepoint_print_recreate (struct breakpoint
*self
, struct ui_file
*fp
)
12994 struct tracepoint
*tp
= (struct tracepoint
*) self
;
12996 if (self
->type
== bp_fast_tracepoint
)
12997 fprintf_unfiltered (fp
, "ftrace");
12998 else if (self
->type
== bp_static_tracepoint
)
12999 fprintf_unfiltered (fp
, "strace");
13000 else if (self
->type
== bp_tracepoint
)
13001 fprintf_unfiltered (fp
, "trace");
13003 internal_error (__FILE__
, __LINE__
,
13004 _("unhandled tracepoint type %d"), (int) self
->type
);
13006 fprintf_unfiltered (fp
, " %s",
13007 event_location_to_string (self
->location
.get ()));
13008 print_recreate_thread (self
, fp
);
13010 if (tp
->pass_count
)
13011 fprintf_unfiltered (fp
, " passcount %d\n", tp
->pass_count
);
13015 tracepoint_create_sals_from_location (const struct event_location
*location
,
13016 struct linespec_result
*canonical
,
13017 enum bptype type_wanted
)
13019 create_sals_from_location_default (location
, canonical
, type_wanted
);
13023 tracepoint_create_breakpoints_sal (struct gdbarch
*gdbarch
,
13024 struct linespec_result
*canonical
,
13025 gdb::unique_xmalloc_ptr
<char> cond_string
,
13026 gdb::unique_xmalloc_ptr
<char> extra_string
,
13027 enum bptype type_wanted
,
13028 enum bpdisp disposition
,
13030 int task
, int ignore_count
,
13031 const struct breakpoint_ops
*ops
,
13032 int from_tty
, int enabled
,
13033 int internal
, unsigned flags
)
13035 create_breakpoints_sal_default (gdbarch
, canonical
,
13036 std::move (cond_string
),
13037 std::move (extra_string
),
13039 disposition
, thread
, task
,
13040 ignore_count
, ops
, from_tty
,
13041 enabled
, internal
, flags
);
13044 static std::vector
<symtab_and_line
>
13045 tracepoint_decode_location (struct breakpoint
*b
,
13046 const struct event_location
*location
,
13047 struct program_space
*search_pspace
)
13049 return decode_location_default (b
, location
, search_pspace
);
13052 struct breakpoint_ops tracepoint_breakpoint_ops
;
13054 /* The breakpoint_ops structure to be use on tracepoints placed in a
13058 tracepoint_probe_create_sals_from_location
13059 (const struct event_location
*location
,
13060 struct linespec_result
*canonical
,
13061 enum bptype type_wanted
)
13063 /* We use the same method for breakpoint on probes. */
13064 bkpt_probe_create_sals_from_location (location
, canonical
, type_wanted
);
13067 static std::vector
<symtab_and_line
>
13068 tracepoint_probe_decode_location (struct breakpoint
*b
,
13069 const struct event_location
*location
,
13070 struct program_space
*search_pspace
)
13072 /* We use the same method for breakpoint on probes. */
13073 return bkpt_probe_decode_location (b
, location
, search_pspace
);
13076 static struct breakpoint_ops tracepoint_probe_breakpoint_ops
;
13078 /* Dprintf breakpoint_ops methods. */
13081 dprintf_re_set (struct breakpoint
*b
)
13083 breakpoint_re_set_default (b
);
13085 /* extra_string should never be non-NULL for dprintf. */
13086 gdb_assert (b
->extra_string
!= NULL
);
13088 /* 1 - connect to target 1, that can run breakpoint commands.
13089 2 - create a dprintf, which resolves fine.
13090 3 - disconnect from target 1
13091 4 - connect to target 2, that can NOT run breakpoint commands.
13093 After steps #3/#4, you'll want the dprintf command list to
13094 be updated, because target 1 and 2 may well return different
13095 answers for target_can_run_breakpoint_commands().
13096 Given absence of finer grained resetting, we get to do
13097 it all the time. */
13098 if (b
->extra_string
!= NULL
)
13099 update_dprintf_command_list (b
);
13102 /* Implement the "print_recreate" breakpoint_ops method for dprintf. */
13105 dprintf_print_recreate (struct breakpoint
*tp
, struct ui_file
*fp
)
13107 fprintf_unfiltered (fp
, "dprintf %s,%s",
13108 event_location_to_string (tp
->location
.get ()),
13110 print_recreate_thread (tp
, fp
);
13113 /* Implement the "after_condition_true" breakpoint_ops method for
13116 dprintf's are implemented with regular commands in their command
13117 list, but we run the commands here instead of before presenting the
13118 stop to the user, as dprintf's don't actually cause a stop. This
13119 also makes it so that the commands of multiple dprintfs at the same
13120 address are all handled. */
13123 dprintf_after_condition_true (struct bpstats
*bs
)
13125 struct bpstats tmp_bs
;
13126 struct bpstats
*tmp_bs_p
= &tmp_bs
;
13128 /* dprintf's never cause a stop. This wasn't set in the
13129 check_status hook instead because that would make the dprintf's
13130 condition not be evaluated. */
13133 /* Run the command list here. Take ownership of it instead of
13134 copying. We never want these commands to run later in
13135 bpstat_do_actions, if a breakpoint that causes a stop happens to
13136 be set at same address as this dprintf, or even if running the
13137 commands here throws. */
13138 tmp_bs
.commands
= bs
->commands
;
13139 bs
->commands
= NULL
;
13141 bpstat_do_actions_1 (&tmp_bs_p
);
13143 /* 'tmp_bs.commands' will usually be NULL by now, but
13144 bpstat_do_actions_1 may return early without processing the whole
13148 /* The breakpoint_ops structure to be used on static tracepoints with
13152 strace_marker_create_sals_from_location (const struct event_location
*location
,
13153 struct linespec_result
*canonical
,
13154 enum bptype type_wanted
)
13156 struct linespec_sals lsal
;
13157 const char *arg_start
, *arg
;
13159 arg
= arg_start
= get_linespec_location (location
);
13160 lsal
.sals
= decode_static_tracepoint_spec (&arg
);
13162 std::string
str (arg_start
, arg
- arg_start
);
13163 const char *ptr
= str
.c_str ();
13164 canonical
->location
= new_linespec_location (&ptr
);
13167 = xstrdup (event_location_to_string (canonical
->location
.get ()));
13168 canonical
->lsals
.push_back (std::move (lsal
));
13172 strace_marker_create_breakpoints_sal (struct gdbarch
*gdbarch
,
13173 struct linespec_result
*canonical
,
13174 gdb::unique_xmalloc_ptr
<char> cond_string
,
13175 gdb::unique_xmalloc_ptr
<char> extra_string
,
13176 enum bptype type_wanted
,
13177 enum bpdisp disposition
,
13179 int task
, int ignore_count
,
13180 const struct breakpoint_ops
*ops
,
13181 int from_tty
, int enabled
,
13182 int internal
, unsigned flags
)
13184 const linespec_sals
&lsal
= canonical
->lsals
[0];
13186 /* If the user is creating a static tracepoint by marker id
13187 (strace -m MARKER_ID), then store the sals index, so that
13188 breakpoint_re_set can try to match up which of the newly
13189 found markers corresponds to this one, and, don't try to
13190 expand multiple locations for each sal, given than SALS
13191 already should contain all sals for MARKER_ID. */
13193 for (size_t i
= 0; i
< lsal
.sals
.size (); i
++)
13195 event_location_up location
13196 = copy_event_location (canonical
->location
.get ());
13198 std::unique_ptr
<tracepoint
> tp (new tracepoint ());
13199 init_breakpoint_sal (tp
.get (), gdbarch
, lsal
.sals
[i
],
13200 std::move (location
), NULL
,
13201 std::move (cond_string
),
13202 std::move (extra_string
),
13203 type_wanted
, disposition
,
13204 thread
, task
, ignore_count
, ops
,
13205 from_tty
, enabled
, internal
, flags
,
13206 canonical
->special_display
);
13207 /* Given that its possible to have multiple markers with
13208 the same string id, if the user is creating a static
13209 tracepoint by marker id ("strace -m MARKER_ID"), then
13210 store the sals index, so that breakpoint_re_set can
13211 try to match up which of the newly found markers
13212 corresponds to this one */
13213 tp
->static_trace_marker_id_idx
= i
;
13215 install_breakpoint (internal
, std::move (tp
), 0);
13219 static std::vector
<symtab_and_line
>
13220 strace_marker_decode_location (struct breakpoint
*b
,
13221 const struct event_location
*location
,
13222 struct program_space
*search_pspace
)
13224 struct tracepoint
*tp
= (struct tracepoint
*) b
;
13225 const char *s
= get_linespec_location (location
);
13227 std::vector
<symtab_and_line
> sals
= decode_static_tracepoint_spec (&s
);
13228 if (sals
.size () > tp
->static_trace_marker_id_idx
)
13230 sals
[0] = sals
[tp
->static_trace_marker_id_idx
];
13235 error (_("marker %s not found"), tp
->static_trace_marker_id
);
13238 static struct breakpoint_ops strace_marker_breakpoint_ops
;
13241 strace_marker_p (struct breakpoint
*b
)
13243 return b
->ops
== &strace_marker_breakpoint_ops
;
13246 /* Delete a breakpoint and clean up all traces of it in the data
13250 delete_breakpoint (struct breakpoint
*bpt
)
13252 struct breakpoint
*b
;
13254 gdb_assert (bpt
!= NULL
);
13256 /* Has this bp already been deleted? This can happen because
13257 multiple lists can hold pointers to bp's. bpstat lists are
13260 One example of this happening is a watchpoint's scope bp. When
13261 the scope bp triggers, we notice that the watchpoint is out of
13262 scope, and delete it. We also delete its scope bp. But the
13263 scope bp is marked "auto-deleting", and is already on a bpstat.
13264 That bpstat is then checked for auto-deleting bp's, which are
13267 A real solution to this problem might involve reference counts in
13268 bp's, and/or giving them pointers back to their referencing
13269 bpstat's, and teaching delete_breakpoint to only free a bp's
13270 storage when no more references were extent. A cheaper bandaid
13272 if (bpt
->type
== bp_none
)
13275 /* At least avoid this stale reference until the reference counting
13276 of breakpoints gets resolved. */
13277 if (bpt
->related_breakpoint
!= bpt
)
13279 struct breakpoint
*related
;
13280 struct watchpoint
*w
;
13282 if (bpt
->type
== bp_watchpoint_scope
)
13283 w
= (struct watchpoint
*) bpt
->related_breakpoint
;
13284 else if (bpt
->related_breakpoint
->type
== bp_watchpoint_scope
)
13285 w
= (struct watchpoint
*) bpt
;
13289 watchpoint_del_at_next_stop (w
);
13291 /* Unlink bpt from the bpt->related_breakpoint ring. */
13292 for (related
= bpt
; related
->related_breakpoint
!= bpt
;
13293 related
= related
->related_breakpoint
);
13294 related
->related_breakpoint
= bpt
->related_breakpoint
;
13295 bpt
->related_breakpoint
= bpt
;
13298 /* watch_command_1 creates a watchpoint but only sets its number if
13299 update_watchpoint succeeds in creating its bp_locations. If there's
13300 a problem in that process, we'll be asked to delete the half-created
13301 watchpoint. In that case, don't announce the deletion. */
13303 observer_notify_breakpoint_deleted (bpt
);
13305 if (breakpoint_chain
== bpt
)
13306 breakpoint_chain
= bpt
->next
;
13308 ALL_BREAKPOINTS (b
)
13309 if (b
->next
== bpt
)
13311 b
->next
= bpt
->next
;
13315 /* Be sure no bpstat's are pointing at the breakpoint after it's
13317 /* FIXME, how can we find all bpstat's? We just check stop_bpstat
13318 in all threads for now. Note that we cannot just remove bpstats
13319 pointing at bpt from the stop_bpstat list entirely, as breakpoint
13320 commands are associated with the bpstat; if we remove it here,
13321 then the later call to bpstat_do_actions (&stop_bpstat); in
13322 event-top.c won't do anything, and temporary breakpoints with
13323 commands won't work. */
13325 iterate_over_threads (bpstat_remove_breakpoint_callback
, bpt
);
13327 /* Now that breakpoint is removed from breakpoint list, update the
13328 global location list. This will remove locations that used to
13329 belong to this breakpoint. Do this before freeing the breakpoint
13330 itself, since remove_breakpoint looks at location's owner. It
13331 might be better design to have location completely
13332 self-contained, but it's not the case now. */
13333 update_global_location_list (UGLL_DONT_INSERT
);
13335 /* On the chance that someone will soon try again to delete this
13336 same bp, we mark it as deleted before freeing its storage. */
13337 bpt
->type
= bp_none
;
13341 /* Iterator function to call a user-provided callback function once
13342 for each of B and its related breakpoints. */
13345 iterate_over_related_breakpoints (struct breakpoint
*b
,
13346 gdb::function_view
<void (breakpoint
*)> function
)
13348 struct breakpoint
*related
;
13353 struct breakpoint
*next
;
13355 /* FUNCTION may delete RELATED. */
13356 next
= related
->related_breakpoint
;
13358 if (next
== related
)
13360 /* RELATED is the last ring entry. */
13361 function (related
);
13363 /* FUNCTION may have deleted it, so we'd never reach back to
13364 B. There's nothing left to do anyway, so just break
13369 function (related
);
13373 while (related
!= b
);
13377 delete_command (const char *arg
, int from_tty
)
13379 struct breakpoint
*b
, *b_tmp
;
13385 int breaks_to_delete
= 0;
13387 /* Delete all breakpoints if no argument. Do not delete
13388 internal breakpoints, these have to be deleted with an
13389 explicit breakpoint number argument. */
13390 ALL_BREAKPOINTS (b
)
13391 if (user_breakpoint_p (b
))
13393 breaks_to_delete
= 1;
13397 /* Ask user only if there are some breakpoints to delete. */
13399 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
13401 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
13402 if (user_breakpoint_p (b
))
13403 delete_breakpoint (b
);
13407 map_breakpoint_numbers
13408 (arg
, [&] (breakpoint
*b
)
13410 iterate_over_related_breakpoints (b
, delete_breakpoint
);
13414 /* Return true if all locations of B bound to PSPACE are pending. If
13415 PSPACE is NULL, all locations of all program spaces are
13419 all_locations_are_pending (struct breakpoint
*b
, struct program_space
*pspace
)
13421 struct bp_location
*loc
;
13423 for (loc
= b
->loc
; loc
!= NULL
; loc
= loc
->next
)
13424 if ((pspace
== NULL
13425 || loc
->pspace
== pspace
)
13426 && !loc
->shlib_disabled
13427 && !loc
->pspace
->executing_startup
)
13432 /* Subroutine of update_breakpoint_locations to simplify it.
13433 Return non-zero if multiple fns in list LOC have the same name.
13434 Null names are ignored. */
13437 ambiguous_names_p (struct bp_location
*loc
)
13439 struct bp_location
*l
;
13440 htab_t htab
= htab_create_alloc (13, htab_hash_string
,
13441 (int (*) (const void *,
13442 const void *)) streq
,
13443 NULL
, xcalloc
, xfree
);
13445 for (l
= loc
; l
!= NULL
; l
= l
->next
)
13448 const char *name
= l
->function_name
;
13450 /* Allow for some names to be NULL, ignore them. */
13454 slot
= (const char **) htab_find_slot (htab
, (const void *) name
,
13456 /* NOTE: We can assume slot != NULL here because xcalloc never
13460 htab_delete (htab
);
13466 htab_delete (htab
);
13470 /* When symbols change, it probably means the sources changed as well,
13471 and it might mean the static tracepoint markers are no longer at
13472 the same address or line numbers they used to be at last we
13473 checked. Losing your static tracepoints whenever you rebuild is
13474 undesirable. This function tries to resync/rematch gdb static
13475 tracepoints with the markers on the target, for static tracepoints
13476 that have not been set by marker id. Static tracepoint that have
13477 been set by marker id are reset by marker id in breakpoint_re_set.
13480 1) For a tracepoint set at a specific address, look for a marker at
13481 the old PC. If one is found there, assume to be the same marker.
13482 If the name / string id of the marker found is different from the
13483 previous known name, assume that means the user renamed the marker
13484 in the sources, and output a warning.
13486 2) For a tracepoint set at a given line number, look for a marker
13487 at the new address of the old line number. If one is found there,
13488 assume to be the same marker. If the name / string id of the
13489 marker found is different from the previous known name, assume that
13490 means the user renamed the marker in the sources, and output a
13493 3) If a marker is no longer found at the same address or line, it
13494 may mean the marker no longer exists. But it may also just mean
13495 the code changed a bit. Maybe the user added a few lines of code
13496 that made the marker move up or down (in line number terms). Ask
13497 the target for info about the marker with the string id as we knew
13498 it. If found, update line number and address in the matching
13499 static tracepoint. This will get confused if there's more than one
13500 marker with the same ID (possible in UST, although unadvised
13501 precisely because it confuses tools). */
13503 static struct symtab_and_line
13504 update_static_tracepoint (struct breakpoint
*b
, struct symtab_and_line sal
)
13506 struct tracepoint
*tp
= (struct tracepoint
*) b
;
13507 struct static_tracepoint_marker marker
;
13512 find_line_pc (sal
.symtab
, sal
.line
, &pc
);
13514 if (target_static_tracepoint_marker_at (pc
, &marker
))
13516 if (strcmp (tp
->static_trace_marker_id
, marker
.str_id
) != 0)
13517 warning (_("static tracepoint %d changed probed marker from %s to %s"),
13519 tp
->static_trace_marker_id
, marker
.str_id
);
13521 xfree (tp
->static_trace_marker_id
);
13522 tp
->static_trace_marker_id
= xstrdup (marker
.str_id
);
13523 release_static_tracepoint_marker (&marker
);
13528 /* Old marker wasn't found on target at lineno. Try looking it up
13530 if (!sal
.explicit_pc
13532 && sal
.symtab
!= NULL
13533 && tp
->static_trace_marker_id
!= NULL
)
13535 VEC(static_tracepoint_marker_p
) *markers
;
13538 = target_static_tracepoint_markers_by_strid (tp
->static_trace_marker_id
);
13540 if (!VEC_empty(static_tracepoint_marker_p
, markers
))
13542 struct symbol
*sym
;
13543 struct static_tracepoint_marker
*tpmarker
;
13544 struct ui_out
*uiout
= current_uiout
;
13545 struct explicit_location explicit_loc
;
13547 tpmarker
= VEC_index (static_tracepoint_marker_p
, markers
, 0);
13549 xfree (tp
->static_trace_marker_id
);
13550 tp
->static_trace_marker_id
= xstrdup (tpmarker
->str_id
);
13552 warning (_("marker for static tracepoint %d (%s) not "
13553 "found at previous line number"),
13554 b
->number
, tp
->static_trace_marker_id
);
13556 symtab_and_line sal2
= find_pc_line (tpmarker
->address
, 0);
13557 sym
= find_pc_sect_function (tpmarker
->address
, NULL
);
13558 uiout
->text ("Now in ");
13561 uiout
->field_string ("func", SYMBOL_PRINT_NAME (sym
));
13562 uiout
->text (" at ");
13564 uiout
->field_string ("file",
13565 symtab_to_filename_for_display (sal2
.symtab
));
13568 if (uiout
->is_mi_like_p ())
13570 const char *fullname
= symtab_to_fullname (sal2
.symtab
);
13572 uiout
->field_string ("fullname", fullname
);
13575 uiout
->field_int ("line", sal2
.line
);
13576 uiout
->text ("\n");
13578 b
->loc
->line_number
= sal2
.line
;
13579 b
->loc
->symtab
= sym
!= NULL
? sal2
.symtab
: NULL
;
13581 b
->location
.reset (NULL
);
13582 initialize_explicit_location (&explicit_loc
);
13583 explicit_loc
.source_filename
13584 = ASTRDUP (symtab_to_filename_for_display (sal2
.symtab
));
13585 explicit_loc
.line_offset
.offset
= b
->loc
->line_number
;
13586 explicit_loc
.line_offset
.sign
= LINE_OFFSET_NONE
;
13587 b
->location
= new_explicit_location (&explicit_loc
);
13589 /* Might be nice to check if function changed, and warn if
13592 release_static_tracepoint_marker (tpmarker
);
13598 /* Returns 1 iff locations A and B are sufficiently same that
13599 we don't need to report breakpoint as changed. */
13602 locations_are_equal (struct bp_location
*a
, struct bp_location
*b
)
13606 if (a
->address
!= b
->address
)
13609 if (a
->shlib_disabled
!= b
->shlib_disabled
)
13612 if (a
->enabled
!= b
->enabled
)
13619 if ((a
== NULL
) != (b
== NULL
))
13625 /* Split all locations of B that are bound to PSPACE out of B's
13626 location list to a separate list and return that list's head. If
13627 PSPACE is NULL, hoist out all locations of B. */
13629 static struct bp_location
*
13630 hoist_existing_locations (struct breakpoint
*b
, struct program_space
*pspace
)
13632 struct bp_location head
;
13633 struct bp_location
*i
= b
->loc
;
13634 struct bp_location
**i_link
= &b
->loc
;
13635 struct bp_location
*hoisted
= &head
;
13637 if (pspace
== NULL
)
13648 if (i
->pspace
== pspace
)
13663 /* Create new breakpoint locations for B (a hardware or software
13664 breakpoint) based on SALS and SALS_END. If SALS_END.NELTS is not
13665 zero, then B is a ranged breakpoint. Only recreates locations for
13666 FILTER_PSPACE. Locations of other program spaces are left
13670 update_breakpoint_locations (struct breakpoint
*b
,
13671 struct program_space
*filter_pspace
,
13672 gdb::array_view
<const symtab_and_line
> sals
,
13673 gdb::array_view
<const symtab_and_line
> sals_end
)
13676 struct bp_location
*existing_locations
;
13678 if (!sals_end
.empty () && (sals
.size () != 1 || sals_end
.size () != 1))
13680 /* Ranged breakpoints have only one start location and one end
13682 b
->enable_state
= bp_disabled
;
13683 printf_unfiltered (_("Could not reset ranged breakpoint %d: "
13684 "multiple locations found\n"),
13689 /* If there's no new locations, and all existing locations are
13690 pending, don't do anything. This optimizes the common case where
13691 all locations are in the same shared library, that was unloaded.
13692 We'd like to retain the location, so that when the library is
13693 loaded again, we don't loose the enabled/disabled status of the
13694 individual locations. */
13695 if (all_locations_are_pending (b
, filter_pspace
) && sals
.empty ())
13698 existing_locations
= hoist_existing_locations (b
, filter_pspace
);
13700 for (const auto &sal
: sals
)
13702 struct bp_location
*new_loc
;
13704 switch_to_program_space_and_thread (sal
.pspace
);
13706 new_loc
= add_location_to_breakpoint (b
, &sal
);
13708 /* Reparse conditions, they might contain references to the
13710 if (b
->cond_string
!= NULL
)
13714 s
= b
->cond_string
;
13717 new_loc
->cond
= parse_exp_1 (&s
, sal
.pc
,
13718 block_for_pc (sal
.pc
),
13721 CATCH (e
, RETURN_MASK_ERROR
)
13723 warning (_("failed to reevaluate condition "
13724 "for breakpoint %d: %s"),
13725 b
->number
, e
.message
);
13726 new_loc
->enabled
= 0;
13731 if (!sals_end
.empty ())
13733 CORE_ADDR end
= find_breakpoint_range_end (sals_end
[0]);
13735 new_loc
->length
= end
- sals
[0].pc
+ 1;
13739 /* If possible, carry over 'disable' status from existing
13742 struct bp_location
*e
= existing_locations
;
13743 /* If there are multiple breakpoints with the same function name,
13744 e.g. for inline functions, comparing function names won't work.
13745 Instead compare pc addresses; this is just a heuristic as things
13746 may have moved, but in practice it gives the correct answer
13747 often enough until a better solution is found. */
13748 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
13750 for (; e
; e
= e
->next
)
13752 if (!e
->enabled
&& e
->function_name
)
13754 struct bp_location
*l
= b
->loc
;
13755 if (have_ambiguous_names
)
13757 for (; l
; l
= l
->next
)
13758 if (breakpoint_locations_match (e
, l
))
13766 for (; l
; l
= l
->next
)
13767 if (l
->function_name
13768 && strcmp (e
->function_name
, l
->function_name
) == 0)
13778 if (!locations_are_equal (existing_locations
, b
->loc
))
13779 observer_notify_breakpoint_modified (b
);
13782 /* Find the SaL locations corresponding to the given LOCATION.
13783 On return, FOUND will be 1 if any SaL was found, zero otherwise. */
13785 static std::vector
<symtab_and_line
>
13786 location_to_sals (struct breakpoint
*b
, struct event_location
*location
,
13787 struct program_space
*search_pspace
, int *found
)
13789 struct gdb_exception exception
= exception_none
;
13791 gdb_assert (b
->ops
!= NULL
);
13793 std::vector
<symtab_and_line
> sals
;
13797 sals
= b
->ops
->decode_location (b
, location
, search_pspace
);
13799 CATCH (e
, RETURN_MASK_ERROR
)
13801 int not_found_and_ok
= 0;
13805 /* For pending breakpoints, it's expected that parsing will
13806 fail until the right shared library is loaded. User has
13807 already told to create pending breakpoints and don't need
13808 extra messages. If breakpoint is in bp_shlib_disabled
13809 state, then user already saw the message about that
13810 breakpoint being disabled, and don't want to see more
13812 if (e
.error
== NOT_FOUND_ERROR
13813 && (b
->condition_not_parsed
13815 && search_pspace
!= NULL
13816 && b
->loc
->pspace
!= search_pspace
)
13817 || (b
->loc
&& b
->loc
->shlib_disabled
)
13818 || (b
->loc
&& b
->loc
->pspace
->executing_startup
)
13819 || b
->enable_state
== bp_disabled
))
13820 not_found_and_ok
= 1;
13822 if (!not_found_and_ok
)
13824 /* We surely don't want to warn about the same breakpoint
13825 10 times. One solution, implemented here, is disable
13826 the breakpoint on error. Another solution would be to
13827 have separate 'warning emitted' flag. Since this
13828 happens only when a binary has changed, I don't know
13829 which approach is better. */
13830 b
->enable_state
= bp_disabled
;
13831 throw_exception (e
);
13836 if (exception
.reason
== 0 || exception
.error
!= NOT_FOUND_ERROR
)
13838 for (auto &sal
: sals
)
13839 resolve_sal_pc (&sal
);
13840 if (b
->condition_not_parsed
&& b
->extra_string
!= NULL
)
13842 char *cond_string
, *extra_string
;
13845 find_condition_and_thread (b
->extra_string
, sals
[0].pc
,
13846 &cond_string
, &thread
, &task
,
13848 gdb_assert (b
->cond_string
== NULL
);
13850 b
->cond_string
= cond_string
;
13851 b
->thread
= thread
;
13855 xfree (b
->extra_string
);
13856 b
->extra_string
= extra_string
;
13858 b
->condition_not_parsed
= 0;
13861 if (b
->type
== bp_static_tracepoint
&& !strace_marker_p (b
))
13862 sals
[0] = update_static_tracepoint (b
, sals
[0]);
13872 /* The default re_set method, for typical hardware or software
13873 breakpoints. Reevaluate the breakpoint and recreate its
13877 breakpoint_re_set_default (struct breakpoint
*b
)
13879 struct program_space
*filter_pspace
= current_program_space
;
13880 std::vector
<symtab_and_line
> expanded
, expanded_end
;
13883 std::vector
<symtab_and_line
> sals
= location_to_sals (b
, b
->location
.get (),
13884 filter_pspace
, &found
);
13886 expanded
= std::move (sals
);
13888 if (b
->location_range_end
!= NULL
)
13890 std::vector
<symtab_and_line
> sals_end
13891 = location_to_sals (b
, b
->location_range_end
.get (),
13892 filter_pspace
, &found
);
13894 expanded_end
= std::move (sals_end
);
13897 update_breakpoint_locations (b
, filter_pspace
, expanded
, expanded_end
);
13900 /* Default method for creating SALs from an address string. It basically
13901 calls parse_breakpoint_sals. Return 1 for success, zero for failure. */
13904 create_sals_from_location_default (const struct event_location
*location
,
13905 struct linespec_result
*canonical
,
13906 enum bptype type_wanted
)
13908 parse_breakpoint_sals (location
, canonical
);
13911 /* Call create_breakpoints_sal for the given arguments. This is the default
13912 function for the `create_breakpoints_sal' method of
13916 create_breakpoints_sal_default (struct gdbarch
*gdbarch
,
13917 struct linespec_result
*canonical
,
13918 gdb::unique_xmalloc_ptr
<char> cond_string
,
13919 gdb::unique_xmalloc_ptr
<char> extra_string
,
13920 enum bptype type_wanted
,
13921 enum bpdisp disposition
,
13923 int task
, int ignore_count
,
13924 const struct breakpoint_ops
*ops
,
13925 int from_tty
, int enabled
,
13926 int internal
, unsigned flags
)
13928 create_breakpoints_sal (gdbarch
, canonical
,
13929 std::move (cond_string
),
13930 std::move (extra_string
),
13931 type_wanted
, disposition
,
13932 thread
, task
, ignore_count
, ops
, from_tty
,
13933 enabled
, internal
, flags
);
13936 /* Decode the line represented by S by calling decode_line_full. This is the
13937 default function for the `decode_location' method of breakpoint_ops. */
13939 static std::vector
<symtab_and_line
>
13940 decode_location_default (struct breakpoint
*b
,
13941 const struct event_location
*location
,
13942 struct program_space
*search_pspace
)
13944 struct linespec_result canonical
;
13946 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, search_pspace
,
13947 (struct symtab
*) NULL
, 0,
13948 &canonical
, multiple_symbols_all
,
13951 /* We should get 0 or 1 resulting SALs. */
13952 gdb_assert (canonical
.lsals
.size () < 2);
13954 if (!canonical
.lsals
.empty ())
13956 const linespec_sals
&lsal
= canonical
.lsals
[0];
13957 return std::move (lsal
.sals
);
13962 /* Reset a breakpoint. */
13965 breakpoint_re_set_one (breakpoint
*b
)
13967 input_radix
= b
->input_radix
;
13968 set_language (b
->language
);
13970 b
->ops
->re_set (b
);
13973 /* Re-set breakpoint locations for the current program space.
13974 Locations bound to other program spaces are left untouched. */
13977 breakpoint_re_set (void)
13979 struct breakpoint
*b
, *b_tmp
;
13982 scoped_restore_current_language save_language
;
13983 scoped_restore save_input_radix
= make_scoped_restore (&input_radix
);
13984 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
13986 /* Note: we must not try to insert locations until after all
13987 breakpoints have been re-set. Otherwise, e.g., when re-setting
13988 breakpoint 1, we'd insert the locations of breakpoint 2, which
13989 hadn't been re-set yet, and thus may have stale locations. */
13991 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
13995 breakpoint_re_set_one (b
);
13997 CATCH (ex
, RETURN_MASK_ALL
)
13999 exception_fprintf (gdb_stderr
, ex
,
14000 "Error in re-setting breakpoint %d: ",
14006 jit_breakpoint_re_set ();
14009 create_overlay_event_breakpoint ();
14010 create_longjmp_master_breakpoint ();
14011 create_std_terminate_master_breakpoint ();
14012 create_exception_master_breakpoint ();
14014 /* Now we can insert. */
14015 update_global_location_list (UGLL_MAY_INSERT
);
14018 /* Reset the thread number of this breakpoint:
14020 - If the breakpoint is for all threads, leave it as-is.
14021 - Else, reset it to the current thread for inferior_ptid. */
14023 breakpoint_re_set_thread (struct breakpoint
*b
)
14025 if (b
->thread
!= -1)
14027 if (in_thread_list (inferior_ptid
))
14028 b
->thread
= ptid_to_global_thread_id (inferior_ptid
);
14030 /* We're being called after following a fork. The new fork is
14031 selected as current, and unless this was a vfork will have a
14032 different program space from the original thread. Reset that
14034 b
->loc
->pspace
= current_program_space
;
14038 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14039 If from_tty is nonzero, it prints a message to that effect,
14040 which ends with a period (no newline). */
14043 set_ignore_count (int bptnum
, int count
, int from_tty
)
14045 struct breakpoint
*b
;
14050 ALL_BREAKPOINTS (b
)
14051 if (b
->number
== bptnum
)
14053 if (is_tracepoint (b
))
14055 if (from_tty
&& count
!= 0)
14056 printf_filtered (_("Ignore count ignored for tracepoint %d."),
14061 b
->ignore_count
= count
;
14065 printf_filtered (_("Will stop next time "
14066 "breakpoint %d is reached."),
14068 else if (count
== 1)
14069 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
14072 printf_filtered (_("Will ignore next %d "
14073 "crossings of breakpoint %d."),
14076 observer_notify_breakpoint_modified (b
);
14080 error (_("No breakpoint number %d."), bptnum
);
14083 /* Command to set ignore-count of breakpoint N to COUNT. */
14086 ignore_command (const char *args
, int from_tty
)
14088 const char *p
= args
;
14092 error_no_arg (_("a breakpoint number"));
14094 num
= get_number (&p
);
14096 error (_("bad breakpoint number: '%s'"), args
);
14098 error (_("Second argument (specified ignore-count) is missing."));
14100 set_ignore_count (num
,
14101 longest_to_int (value_as_long (parse_and_eval (p
))),
14104 printf_filtered ("\n");
14108 /* Call FUNCTION on each of the breakpoints with numbers in the range
14109 defined by BP_NUM_RANGE (an inclusive range). */
14112 map_breakpoint_number_range (std::pair
<int, int> bp_num_range
,
14113 gdb::function_view
<void (breakpoint
*)> function
)
14115 if (bp_num_range
.first
== 0)
14117 warning (_("bad breakpoint number at or near '%d'"),
14118 bp_num_range
.first
);
14122 struct breakpoint
*b
, *tmp
;
14124 for (int i
= bp_num_range
.first
; i
<= bp_num_range
.second
; i
++)
14126 bool match
= false;
14128 ALL_BREAKPOINTS_SAFE (b
, tmp
)
14129 if (b
->number
== i
)
14136 printf_unfiltered (_("No breakpoint number %d.\n"), i
);
14141 /* Call FUNCTION on each of the breakpoints whose numbers are given in
14145 map_breakpoint_numbers (const char *args
,
14146 gdb::function_view
<void (breakpoint
*)> function
)
14148 if (args
== NULL
|| *args
== '\0')
14149 error_no_arg (_("one or more breakpoint numbers"));
14151 number_or_range_parser
parser (args
);
14153 while (!parser
.finished ())
14155 int num
= parser
.get_number ();
14156 map_breakpoint_number_range (std::make_pair (num
, num
), function
);
14160 /* Return the breakpoint location structure corresponding to the
14161 BP_NUM and LOC_NUM values. */
14163 static struct bp_location
*
14164 find_location_by_number (int bp_num
, int loc_num
)
14166 struct breakpoint
*b
;
14168 ALL_BREAKPOINTS (b
)
14169 if (b
->number
== bp_num
)
14174 if (!b
|| b
->number
!= bp_num
)
14175 error (_("Bad breakpoint number '%d'"), bp_num
);
14178 error (_("Bad breakpoint location number '%d'"), loc_num
);
14181 for (bp_location
*loc
= b
->loc
; loc
!= NULL
; loc
= loc
->next
)
14182 if (++n
== loc_num
)
14185 error (_("Bad breakpoint location number '%d'"), loc_num
);
14188 /* Modes of operation for extract_bp_num. */
14189 enum class extract_bp_kind
14191 /* Extracting a breakpoint number. */
14194 /* Extracting a location number. */
14198 /* Extract a breakpoint or location number (as determined by KIND)
14199 from the string starting at START. TRAILER is a character which
14200 can be found after the number. If you don't want a trailer, use
14201 '\0'. If END_OUT is not NULL, it is set to point after the parsed
14202 string. This always returns a positive integer. */
14205 extract_bp_num (extract_bp_kind kind
, const char *start
,
14206 int trailer
, const char **end_out
= NULL
)
14208 const char *end
= start
;
14209 int num
= get_number_trailer (&end
, trailer
);
14211 error (kind
== extract_bp_kind::bp
14212 ? _("Negative breakpoint number '%.*s'")
14213 : _("Negative breakpoint location number '%.*s'"),
14214 int (end
- start
), start
);
14216 error (kind
== extract_bp_kind::bp
14217 ? _("Bad breakpoint number '%.*s'")
14218 : _("Bad breakpoint location number '%.*s'"),
14219 int (end
- start
), start
);
14221 if (end_out
!= NULL
)
14226 /* Extract a breakpoint or location range (as determined by KIND) in
14227 the form NUM1-NUM2 stored at &ARG[arg_offset]. Returns a std::pair
14228 representing the (inclusive) range. The returned pair's elements
14229 are always positive integers. */
14231 static std::pair
<int, int>
14232 extract_bp_or_bp_range (extract_bp_kind kind
,
14233 const std::string
&arg
,
14234 std::string::size_type arg_offset
)
14236 std::pair
<int, int> range
;
14237 const char *bp_loc
= &arg
[arg_offset
];
14238 std::string::size_type dash
= arg
.find ('-', arg_offset
);
14239 if (dash
!= std::string::npos
)
14241 /* bp_loc is a range (x-z). */
14242 if (arg
.length () == dash
+ 1)
14243 error (kind
== extract_bp_kind::bp
14244 ? _("Bad breakpoint number at or near: '%s'")
14245 : _("Bad breakpoint location number at or near: '%s'"),
14249 const char *start_first
= bp_loc
;
14250 const char *start_second
= &arg
[dash
+ 1];
14251 range
.first
= extract_bp_num (kind
, start_first
, '-');
14252 range
.second
= extract_bp_num (kind
, start_second
, '\0', &end
);
14254 if (range
.first
> range
.second
)
14255 error (kind
== extract_bp_kind::bp
14256 ? _("Inverted breakpoint range at '%.*s'")
14257 : _("Inverted breakpoint location range at '%.*s'"),
14258 int (end
- start_first
), start_first
);
14262 /* bp_loc is a single value. */
14263 range
.first
= extract_bp_num (kind
, bp_loc
, '\0');
14264 range
.second
= range
.first
;
14269 /* Extract the breakpoint/location range specified by ARG. Returns
14270 the breakpoint range in BP_NUM_RANGE, and the location range in
14273 ARG may be in any of the following forms:
14275 x where 'x' is a breakpoint number.
14276 x-y where 'x' and 'y' specify a breakpoint numbers range.
14277 x.y where 'x' is a breakpoint number and 'y' a location number.
14278 x.y-z where 'x' is a breakpoint number and 'y' and 'z' specify a
14279 location number range.
14283 extract_bp_number_and_location (const std::string
&arg
,
14284 std::pair
<int, int> &bp_num_range
,
14285 std::pair
<int, int> &bp_loc_range
)
14287 std::string::size_type dot
= arg
.find ('.');
14289 if (dot
!= std::string::npos
)
14291 /* Handle 'x.y' and 'x.y-z' cases. */
14293 if (arg
.length () == dot
+ 1 || dot
== 0)
14294 error (_("Bad breakpoint number at or near: '%s'"), arg
.c_str ());
14297 = extract_bp_num (extract_bp_kind::bp
, arg
.c_str (), '.');
14298 bp_num_range
.second
= bp_num_range
.first
;
14300 bp_loc_range
= extract_bp_or_bp_range (extract_bp_kind::loc
,
14305 /* Handle x and x-y cases. */
14307 bp_num_range
= extract_bp_or_bp_range (extract_bp_kind::bp
, arg
, 0);
14308 bp_loc_range
.first
= 0;
14309 bp_loc_range
.second
= 0;
14313 /* Enable or disable a breakpoint location BP_NUM.LOC_NUM. ENABLE
14314 specifies whether to enable or disable. */
14317 enable_disable_bp_num_loc (int bp_num
, int loc_num
, bool enable
)
14319 struct bp_location
*loc
= find_location_by_number (bp_num
, loc_num
);
14322 if (loc
->enabled
!= enable
)
14324 loc
->enabled
= enable
;
14325 mark_breakpoint_location_modified (loc
);
14327 if (target_supports_enable_disable_tracepoint ()
14328 && current_trace_status ()->running
&& loc
->owner
14329 && is_tracepoint (loc
->owner
))
14330 target_disable_tracepoint (loc
);
14332 update_global_location_list (UGLL_DONT_INSERT
);
14335 /* Enable or disable a range of breakpoint locations. BP_NUM is the
14336 number of the breakpoint, and BP_LOC_RANGE specifies the
14337 (inclusive) range of location numbers of that breakpoint to
14338 enable/disable. ENABLE specifies whether to enable or disable the
14342 enable_disable_breakpoint_location_range (int bp_num
,
14343 std::pair
<int, int> &bp_loc_range
,
14346 for (int i
= bp_loc_range
.first
; i
<= bp_loc_range
.second
; i
++)
14347 enable_disable_bp_num_loc (bp_num
, i
, enable
);
14350 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14351 If from_tty is nonzero, it prints a message to that effect,
14352 which ends with a period (no newline). */
14355 disable_breakpoint (struct breakpoint
*bpt
)
14357 /* Never disable a watchpoint scope breakpoint; we want to
14358 hit them when we leave scope so we can delete both the
14359 watchpoint and its scope breakpoint at that time. */
14360 if (bpt
->type
== bp_watchpoint_scope
)
14363 bpt
->enable_state
= bp_disabled
;
14365 /* Mark breakpoint locations modified. */
14366 mark_breakpoint_modified (bpt
);
14368 if (target_supports_enable_disable_tracepoint ()
14369 && current_trace_status ()->running
&& is_tracepoint (bpt
))
14371 struct bp_location
*location
;
14373 for (location
= bpt
->loc
; location
; location
= location
->next
)
14374 target_disable_tracepoint (location
);
14377 update_global_location_list (UGLL_DONT_INSERT
);
14379 observer_notify_breakpoint_modified (bpt
);
14382 /* Enable or disable the breakpoint(s) or breakpoint location(s)
14383 specified in ARGS. ARGS may be in any of the formats handled by
14384 extract_bp_number_and_location. ENABLE specifies whether to enable
14385 or disable the breakpoints/locations. */
14388 enable_disable_command (const char *args
, int from_tty
, bool enable
)
14392 struct breakpoint
*bpt
;
14394 ALL_BREAKPOINTS (bpt
)
14395 if (user_breakpoint_p (bpt
))
14398 enable_breakpoint (bpt
);
14400 disable_breakpoint (bpt
);
14405 std::string num
= extract_arg (&args
);
14407 while (!num
.empty ())
14409 std::pair
<int, int> bp_num_range
, bp_loc_range
;
14411 extract_bp_number_and_location (num
, bp_num_range
, bp_loc_range
);
14413 if (bp_loc_range
.first
== bp_loc_range
.second
14414 && bp_loc_range
.first
== 0)
14416 /* Handle breakpoint ids with formats 'x' or 'x-z'. */
14417 map_breakpoint_number_range (bp_num_range
,
14419 ? enable_breakpoint
14420 : disable_breakpoint
);
14424 /* Handle breakpoint ids with formats 'x.y' or
14426 enable_disable_breakpoint_location_range
14427 (bp_num_range
.first
, bp_loc_range
, enable
);
14429 num
= extract_arg (&args
);
14434 /* The disable command disables the specified breakpoints/locations
14435 (or all defined breakpoints) so they're no longer effective in
14436 stopping the inferior. ARGS may be in any of the forms defined in
14437 extract_bp_number_and_location. */
14440 disable_command (const char *args
, int from_tty
)
14442 enable_disable_command (args
, from_tty
, false);
14446 enable_breakpoint_disp (struct breakpoint
*bpt
, enum bpdisp disposition
,
14449 int target_resources_ok
;
14451 if (bpt
->type
== bp_hardware_breakpoint
)
14454 i
= hw_breakpoint_used_count ();
14455 target_resources_ok
=
14456 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
14458 if (target_resources_ok
== 0)
14459 error (_("No hardware breakpoint support in the target."));
14460 else if (target_resources_ok
< 0)
14461 error (_("Hardware breakpoints used exceeds limit."));
14464 if (is_watchpoint (bpt
))
14466 /* Initialize it just to avoid a GCC false warning. */
14467 enum enable_state orig_enable_state
= bp_disabled
;
14471 struct watchpoint
*w
= (struct watchpoint
*) bpt
;
14473 orig_enable_state
= bpt
->enable_state
;
14474 bpt
->enable_state
= bp_enabled
;
14475 update_watchpoint (w
, 1 /* reparse */);
14477 CATCH (e
, RETURN_MASK_ALL
)
14479 bpt
->enable_state
= orig_enable_state
;
14480 exception_fprintf (gdb_stderr
, e
, _("Cannot enable watchpoint %d: "),
14487 bpt
->enable_state
= bp_enabled
;
14489 /* Mark breakpoint locations modified. */
14490 mark_breakpoint_modified (bpt
);
14492 if (target_supports_enable_disable_tracepoint ()
14493 && current_trace_status ()->running
&& is_tracepoint (bpt
))
14495 struct bp_location
*location
;
14497 for (location
= bpt
->loc
; location
; location
= location
->next
)
14498 target_enable_tracepoint (location
);
14501 bpt
->disposition
= disposition
;
14502 bpt
->enable_count
= count
;
14503 update_global_location_list (UGLL_MAY_INSERT
);
14505 observer_notify_breakpoint_modified (bpt
);
14510 enable_breakpoint (struct breakpoint
*bpt
)
14512 enable_breakpoint_disp (bpt
, bpt
->disposition
, 0);
14515 /* The enable command enables the specified breakpoints/locations (or
14516 all defined breakpoints) so they once again become (or continue to
14517 be) effective in stopping the inferior. ARGS may be in any of the
14518 forms defined in extract_bp_number_and_location. */
14521 enable_command (const char *args
, int from_tty
)
14523 enable_disable_command (args
, from_tty
, true);
14527 enable_once_command (const char *args
, int from_tty
)
14529 map_breakpoint_numbers
14530 (args
, [&] (breakpoint
*b
)
14532 iterate_over_related_breakpoints
14533 (b
, [&] (breakpoint
*bpt
)
14535 enable_breakpoint_disp (bpt
, disp_disable
, 1);
14541 enable_count_command (const char *args
, int from_tty
)
14546 error_no_arg (_("hit count"));
14548 count
= get_number (&args
);
14550 map_breakpoint_numbers
14551 (args
, [&] (breakpoint
*b
)
14553 iterate_over_related_breakpoints
14554 (b
, [&] (breakpoint
*bpt
)
14556 enable_breakpoint_disp (bpt
, disp_disable
, count
);
14562 enable_delete_command (const char *args
, int from_tty
)
14564 map_breakpoint_numbers
14565 (args
, [&] (breakpoint
*b
)
14567 iterate_over_related_breakpoints
14568 (b
, [&] (breakpoint
*bpt
)
14570 enable_breakpoint_disp (bpt
, disp_del
, 1);
14576 set_breakpoint_cmd (const char *args
, int from_tty
)
14581 show_breakpoint_cmd (const char *args
, int from_tty
)
14585 /* Invalidate last known value of any hardware watchpoint if
14586 the memory which that value represents has been written to by
14590 invalidate_bp_value_on_memory_change (struct inferior
*inferior
,
14591 CORE_ADDR addr
, ssize_t len
,
14592 const bfd_byte
*data
)
14594 struct breakpoint
*bp
;
14596 ALL_BREAKPOINTS (bp
)
14597 if (bp
->enable_state
== bp_enabled
14598 && bp
->type
== bp_hardware_watchpoint
)
14600 struct watchpoint
*wp
= (struct watchpoint
*) bp
;
14602 if (wp
->val_valid
&& wp
->val
)
14604 struct bp_location
*loc
;
14606 for (loc
= bp
->loc
; loc
!= NULL
; loc
= loc
->next
)
14607 if (loc
->loc_type
== bp_loc_hardware_watchpoint
14608 && loc
->address
+ loc
->length
> addr
14609 && addr
+ len
> loc
->address
)
14611 value_free (wp
->val
);
14619 /* Create and insert a breakpoint for software single step. */
14622 insert_single_step_breakpoint (struct gdbarch
*gdbarch
,
14623 const address_space
*aspace
,
14626 struct thread_info
*tp
= inferior_thread ();
14627 struct symtab_and_line sal
;
14628 CORE_ADDR pc
= next_pc
;
14630 if (tp
->control
.single_step_breakpoints
== NULL
)
14632 tp
->control
.single_step_breakpoints
14633 = new_single_step_breakpoint (tp
->global_num
, gdbarch
);
14636 sal
= find_pc_line (pc
, 0);
14638 sal
.section
= find_pc_overlay (pc
);
14639 sal
.explicit_pc
= 1;
14640 add_location_to_breakpoint (tp
->control
.single_step_breakpoints
, &sal
);
14642 update_global_location_list (UGLL_INSERT
);
14645 /* Insert single step breakpoints according to the current state. */
14648 insert_single_step_breakpoints (struct gdbarch
*gdbarch
)
14650 struct regcache
*regcache
= get_current_regcache ();
14651 std::vector
<CORE_ADDR
> next_pcs
;
14653 next_pcs
= gdbarch_software_single_step (gdbarch
, regcache
);
14655 if (!next_pcs
.empty ())
14657 struct frame_info
*frame
= get_current_frame ();
14658 const address_space
*aspace
= get_frame_address_space (frame
);
14660 for (CORE_ADDR pc
: next_pcs
)
14661 insert_single_step_breakpoint (gdbarch
, aspace
, pc
);
14669 /* See breakpoint.h. */
14672 breakpoint_has_location_inserted_here (struct breakpoint
*bp
,
14673 const address_space
*aspace
,
14676 struct bp_location
*loc
;
14678 for (loc
= bp
->loc
; loc
!= NULL
; loc
= loc
->next
)
14680 && breakpoint_location_address_match (loc
, aspace
, pc
))
14686 /* Check whether a software single-step breakpoint is inserted at
14690 single_step_breakpoint_inserted_here_p (const address_space
*aspace
,
14693 struct breakpoint
*bpt
;
14695 ALL_BREAKPOINTS (bpt
)
14697 if (bpt
->type
== bp_single_step
14698 && breakpoint_has_location_inserted_here (bpt
, aspace
, pc
))
14704 /* Tracepoint-specific operations. */
14706 /* Set tracepoint count to NUM. */
14708 set_tracepoint_count (int num
)
14710 tracepoint_count
= num
;
14711 set_internalvar_integer (lookup_internalvar ("tpnum"), num
);
14715 trace_command (const char *arg
, int from_tty
)
14717 struct breakpoint_ops
*ops
;
14719 event_location_up location
= string_to_event_location (&arg
,
14721 if (location
!= NULL
14722 && event_location_type (location
.get ()) == PROBE_LOCATION
)
14723 ops
= &tracepoint_probe_breakpoint_ops
;
14725 ops
= &tracepoint_breakpoint_ops
;
14727 create_breakpoint (get_current_arch (),
14729 NULL
, 0, arg
, 1 /* parse arg */,
14731 bp_tracepoint
/* type_wanted */,
14732 0 /* Ignore count */,
14733 pending_break_support
,
14737 0 /* internal */, 0);
14741 ftrace_command (const char *arg
, int from_tty
)
14743 event_location_up location
= string_to_event_location (&arg
,
14745 create_breakpoint (get_current_arch (),
14747 NULL
, 0, arg
, 1 /* parse arg */,
14749 bp_fast_tracepoint
/* type_wanted */,
14750 0 /* Ignore count */,
14751 pending_break_support
,
14752 &tracepoint_breakpoint_ops
,
14755 0 /* internal */, 0);
14758 /* strace command implementation. Creates a static tracepoint. */
14761 strace_command (const char *arg
, int from_tty
)
14763 struct breakpoint_ops
*ops
;
14764 event_location_up location
;
14766 /* Decide if we are dealing with a static tracepoint marker (`-m'),
14767 or with a normal static tracepoint. */
14768 if (arg
&& startswith (arg
, "-m") && isspace (arg
[2]))
14770 ops
= &strace_marker_breakpoint_ops
;
14771 location
= new_linespec_location (&arg
);
14775 ops
= &tracepoint_breakpoint_ops
;
14776 location
= string_to_event_location (&arg
, current_language
);
14779 create_breakpoint (get_current_arch (),
14781 NULL
, 0, arg
, 1 /* parse arg */,
14783 bp_static_tracepoint
/* type_wanted */,
14784 0 /* Ignore count */,
14785 pending_break_support
,
14789 0 /* internal */, 0);
14792 /* Set up a fake reader function that gets command lines from a linked
14793 list that was acquired during tracepoint uploading. */
14795 static struct uploaded_tp
*this_utp
;
14796 static int next_cmd
;
14799 read_uploaded_action (void)
14803 VEC_iterate (char_ptr
, this_utp
->cmd_strings
, next_cmd
, rslt
);
14810 /* Given information about a tracepoint as recorded on a target (which
14811 can be either a live system or a trace file), attempt to create an
14812 equivalent GDB tracepoint. This is not a reliable process, since
14813 the target does not necessarily have all the information used when
14814 the tracepoint was originally defined. */
14816 struct tracepoint
*
14817 create_tracepoint_from_upload (struct uploaded_tp
*utp
)
14819 const char *addr_str
;
14820 char small_buf
[100];
14821 struct tracepoint
*tp
;
14823 if (utp
->at_string
)
14824 addr_str
= utp
->at_string
;
14827 /* In the absence of a source location, fall back to raw
14828 address. Since there is no way to confirm that the address
14829 means the same thing as when the trace was started, warn the
14831 warning (_("Uploaded tracepoint %d has no "
14832 "source location, using raw address"),
14834 xsnprintf (small_buf
, sizeof (small_buf
), "*%s", hex_string (utp
->addr
));
14835 addr_str
= small_buf
;
14838 /* There's not much we can do with a sequence of bytecodes. */
14839 if (utp
->cond
&& !utp
->cond_string
)
14840 warning (_("Uploaded tracepoint %d condition "
14841 "has no source form, ignoring it"),
14844 event_location_up location
= string_to_event_location (&addr_str
,
14846 if (!create_breakpoint (get_current_arch (),
14848 utp
->cond_string
, -1, addr_str
,
14849 0 /* parse cond/thread */,
14851 utp
->type
/* type_wanted */,
14852 0 /* Ignore count */,
14853 pending_break_support
,
14854 &tracepoint_breakpoint_ops
,
14856 utp
->enabled
/* enabled */,
14858 CREATE_BREAKPOINT_FLAGS_INSERTED
))
14861 /* Get the tracepoint we just created. */
14862 tp
= get_tracepoint (tracepoint_count
);
14863 gdb_assert (tp
!= NULL
);
14867 xsnprintf (small_buf
, sizeof (small_buf
), "%d %d", utp
->pass
,
14870 trace_pass_command (small_buf
, 0);
14873 /* If we have uploaded versions of the original commands, set up a
14874 special-purpose "reader" function and call the usual command line
14875 reader, then pass the result to the breakpoint command-setting
14877 if (!VEC_empty (char_ptr
, utp
->cmd_strings
))
14879 command_line_up cmd_list
;
14884 cmd_list
= read_command_lines_1 (read_uploaded_action
, 1, NULL
, NULL
);
14886 breakpoint_set_commands (tp
, std::move (cmd_list
));
14888 else if (!VEC_empty (char_ptr
, utp
->actions
)
14889 || !VEC_empty (char_ptr
, utp
->step_actions
))
14890 warning (_("Uploaded tracepoint %d actions "
14891 "have no source form, ignoring them"),
14894 /* Copy any status information that might be available. */
14895 tp
->hit_count
= utp
->hit_count
;
14896 tp
->traceframe_usage
= utp
->traceframe_usage
;
14901 /* Print information on tracepoint number TPNUM_EXP, or all if
14905 info_tracepoints_command (const char *args
, int from_tty
)
14907 struct ui_out
*uiout
= current_uiout
;
14910 num_printed
= breakpoint_1 (args
, 0, is_tracepoint
);
14912 if (num_printed
== 0)
14914 if (args
== NULL
|| *args
== '\0')
14915 uiout
->message ("No tracepoints.\n");
14917 uiout
->message ("No tracepoint matching '%s'.\n", args
);
14920 default_collect_info ();
14923 /* The 'enable trace' command enables tracepoints.
14924 Not supported by all targets. */
14926 enable_trace_command (const char *args
, int from_tty
)
14928 enable_command (args
, from_tty
);
14931 /* The 'disable trace' command disables tracepoints.
14932 Not supported by all targets. */
14934 disable_trace_command (const char *args
, int from_tty
)
14936 disable_command (args
, from_tty
);
14939 /* Remove a tracepoint (or all if no argument). */
14941 delete_trace_command (const char *arg
, int from_tty
)
14943 struct breakpoint
*b
, *b_tmp
;
14949 int breaks_to_delete
= 0;
14951 /* Delete all breakpoints if no argument.
14952 Do not delete internal or call-dummy breakpoints, these
14953 have to be deleted with an explicit breakpoint number
14955 ALL_TRACEPOINTS (b
)
14956 if (is_tracepoint (b
) && user_breakpoint_p (b
))
14958 breaks_to_delete
= 1;
14962 /* Ask user only if there are some breakpoints to delete. */
14964 || (breaks_to_delete
&& query (_("Delete all tracepoints? "))))
14966 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
14967 if (is_tracepoint (b
) && user_breakpoint_p (b
))
14968 delete_breakpoint (b
);
14972 map_breakpoint_numbers
14973 (arg
, [&] (breakpoint
*b
)
14975 iterate_over_related_breakpoints (b
, delete_breakpoint
);
14979 /* Helper function for trace_pass_command. */
14982 trace_pass_set_count (struct tracepoint
*tp
, int count
, int from_tty
)
14984 tp
->pass_count
= count
;
14985 observer_notify_breakpoint_modified (tp
);
14987 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
14988 tp
->number
, count
);
14991 /* Set passcount for tracepoint.
14993 First command argument is passcount, second is tracepoint number.
14994 If tracepoint number omitted, apply to most recently defined.
14995 Also accepts special argument "all". */
14998 trace_pass_command (const char *args
, int from_tty
)
15000 struct tracepoint
*t1
;
15003 if (args
== 0 || *args
== 0)
15004 error (_("passcount command requires an "
15005 "argument (count + optional TP num)"));
15007 count
= strtoulst (args
, &args
, 10); /* Count comes first, then TP num. */
15009 args
= skip_spaces (args
);
15010 if (*args
&& strncasecmp (args
, "all", 3) == 0)
15012 struct breakpoint
*b
;
15014 args
+= 3; /* Skip special argument "all". */
15016 error (_("Junk at end of arguments."));
15018 ALL_TRACEPOINTS (b
)
15020 t1
= (struct tracepoint
*) b
;
15021 trace_pass_set_count (t1
, count
, from_tty
);
15024 else if (*args
== '\0')
15026 t1
= get_tracepoint_by_number (&args
, NULL
);
15028 trace_pass_set_count (t1
, count
, from_tty
);
15032 number_or_range_parser
parser (args
);
15033 while (!parser
.finished ())
15035 t1
= get_tracepoint_by_number (&args
, &parser
);
15037 trace_pass_set_count (t1
, count
, from_tty
);
15042 struct tracepoint
*
15043 get_tracepoint (int num
)
15045 struct breakpoint
*t
;
15047 ALL_TRACEPOINTS (t
)
15048 if (t
->number
== num
)
15049 return (struct tracepoint
*) t
;
15054 /* Find the tracepoint with the given target-side number (which may be
15055 different from the tracepoint number after disconnecting and
15058 struct tracepoint
*
15059 get_tracepoint_by_number_on_target (int num
)
15061 struct breakpoint
*b
;
15063 ALL_TRACEPOINTS (b
)
15065 struct tracepoint
*t
= (struct tracepoint
*) b
;
15067 if (t
->number_on_target
== num
)
15074 /* Utility: parse a tracepoint number and look it up in the list.
15075 If STATE is not NULL, use, get_number_or_range_state and ignore ARG.
15076 If the argument is missing, the most recent tracepoint
15077 (tracepoint_count) is returned. */
15079 struct tracepoint
*
15080 get_tracepoint_by_number (const char **arg
,
15081 number_or_range_parser
*parser
)
15083 struct breakpoint
*t
;
15085 const char *instring
= arg
== NULL
? NULL
: *arg
;
15087 if (parser
!= NULL
)
15089 gdb_assert (!parser
->finished ());
15090 tpnum
= parser
->get_number ();
15092 else if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
15093 tpnum
= tracepoint_count
;
15095 tpnum
= get_number (arg
);
15099 if (instring
&& *instring
)
15100 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
15103 printf_filtered (_("No previous tracepoint\n"));
15107 ALL_TRACEPOINTS (t
)
15108 if (t
->number
== tpnum
)
15110 return (struct tracepoint
*) t
;
15113 printf_unfiltered ("No tracepoint number %d.\n", tpnum
);
15118 print_recreate_thread (struct breakpoint
*b
, struct ui_file
*fp
)
15120 if (b
->thread
!= -1)
15121 fprintf_unfiltered (fp
, " thread %d", b
->thread
);
15124 fprintf_unfiltered (fp
, " task %d", b
->task
);
15126 fprintf_unfiltered (fp
, "\n");
15129 /* Save information on user settable breakpoints (watchpoints, etc) to
15130 a new script file named FILENAME. If FILTER is non-NULL, call it
15131 on each breakpoint and only include the ones for which it returns
15135 save_breakpoints (const char *filename
, int from_tty
,
15136 int (*filter
) (const struct breakpoint
*))
15138 struct breakpoint
*tp
;
15140 int extra_trace_bits
= 0;
15142 if (filename
== 0 || *filename
== 0)
15143 error (_("Argument required (file name in which to save)"));
15145 /* See if we have anything to save. */
15146 ALL_BREAKPOINTS (tp
)
15148 /* Skip internal and momentary breakpoints. */
15149 if (!user_breakpoint_p (tp
))
15152 /* If we have a filter, only save the breakpoints it accepts. */
15153 if (filter
&& !filter (tp
))
15158 if (is_tracepoint (tp
))
15160 extra_trace_bits
= 1;
15162 /* We can stop searching. */
15169 warning (_("Nothing to save."));
15173 gdb::unique_xmalloc_ptr
<char> expanded_filename (tilde_expand (filename
));
15177 if (!fp
.open (expanded_filename
.get (), "w"))
15178 error (_("Unable to open file '%s' for saving (%s)"),
15179 expanded_filename
.get (), safe_strerror (errno
));
15181 if (extra_trace_bits
)
15182 save_trace_state_variables (&fp
);
15184 ALL_BREAKPOINTS (tp
)
15186 /* Skip internal and momentary breakpoints. */
15187 if (!user_breakpoint_p (tp
))
15190 /* If we have a filter, only save the breakpoints it accepts. */
15191 if (filter
&& !filter (tp
))
15194 tp
->ops
->print_recreate (tp
, &fp
);
15196 /* Note, we can't rely on tp->number for anything, as we can't
15197 assume the recreated breakpoint numbers will match. Use $bpnum
15200 if (tp
->cond_string
)
15201 fp
.printf (" condition $bpnum %s\n", tp
->cond_string
);
15203 if (tp
->ignore_count
)
15204 fp
.printf (" ignore $bpnum %d\n", tp
->ignore_count
);
15206 if (tp
->type
!= bp_dprintf
&& tp
->commands
)
15208 fp
.puts (" commands\n");
15210 current_uiout
->redirect (&fp
);
15213 print_command_lines (current_uiout
, tp
->commands
.get (), 2);
15215 CATCH (ex
, RETURN_MASK_ALL
)
15217 current_uiout
->redirect (NULL
);
15218 throw_exception (ex
);
15222 current_uiout
->redirect (NULL
);
15223 fp
.puts (" end\n");
15226 if (tp
->enable_state
== bp_disabled
)
15227 fp
.puts ("disable $bpnum\n");
15229 /* If this is a multi-location breakpoint, check if the locations
15230 should be individually disabled. Watchpoint locations are
15231 special, and not user visible. */
15232 if (!is_watchpoint (tp
) && tp
->loc
&& tp
->loc
->next
)
15234 struct bp_location
*loc
;
15237 for (loc
= tp
->loc
; loc
!= NULL
; loc
= loc
->next
, n
++)
15239 fp
.printf ("disable $bpnum.%d\n", n
);
15243 if (extra_trace_bits
&& *default_collect
)
15244 fp
.printf ("set default-collect %s\n", default_collect
);
15247 printf_filtered (_("Saved to file '%s'.\n"), expanded_filename
.get ());
15250 /* The `save breakpoints' command. */
15253 save_breakpoints_command (const char *args
, int from_tty
)
15255 save_breakpoints (args
, from_tty
, NULL
);
15258 /* The `save tracepoints' command. */
15261 save_tracepoints_command (const char *args
, int from_tty
)
15263 save_breakpoints (args
, from_tty
, is_tracepoint
);
15266 /* Create a vector of all tracepoints. */
15268 VEC(breakpoint_p
) *
15269 all_tracepoints (void)
15271 VEC(breakpoint_p
) *tp_vec
= 0;
15272 struct breakpoint
*tp
;
15274 ALL_TRACEPOINTS (tp
)
15276 VEC_safe_push (breakpoint_p
, tp_vec
, tp
);
15283 /* This help string is used to consolidate all the help string for specifying
15284 locations used by several commands. */
15286 #define LOCATION_HELP_STRING \
15287 "Linespecs are colon-separated lists of location parameters, such as\n\
15288 source filename, function name, label name, and line number.\n\
15289 Example: To specify the start of a label named \"the_top\" in the\n\
15290 function \"fact\" in the file \"factorial.c\", use\n\
15291 \"factorial.c:fact:the_top\".\n\
15293 Address locations begin with \"*\" and specify an exact address in the\n\
15294 program. Example: To specify the fourth byte past the start function\n\
15295 \"main\", use \"*main + 4\".\n\
15297 Explicit locations are similar to linespecs but use an option/argument\n\
15298 syntax to specify location parameters.\n\
15299 Example: To specify the start of the label named \"the_top\" in the\n\
15300 function \"fact\" in the file \"factorial.c\", use \"-source factorial.c\n\
15301 -function fact -label the_top\".\n"
15303 /* This help string is used for the break, hbreak, tbreak and thbreak
15304 commands. It is defined as a macro to prevent duplication.
15305 COMMAND should be a string constant containing the name of the
15308 #define BREAK_ARGS_HELP(command) \
15309 command" [PROBE_MODIFIER] [LOCATION] [thread THREADNUM] [if CONDITION]\n\
15310 PROBE_MODIFIER shall be present if the command is to be placed in a\n\
15311 probe point. Accepted values are `-probe' (for a generic, automatically\n\
15312 guessed probe type), `-probe-stap' (for a SystemTap probe) or \n\
15313 `-probe-dtrace' (for a DTrace probe).\n\
15314 LOCATION may be a linespec, address, or explicit location as described\n\
15317 With no LOCATION, uses current execution address of the selected\n\
15318 stack frame. This is useful for breaking on return to a stack frame.\n\
15320 THREADNUM is the number from \"info threads\".\n\
15321 CONDITION is a boolean expression.\n\
15322 \n" LOCATION_HELP_STRING "\n\
15323 Multiple breakpoints at one place are permitted, and useful if their\n\
15324 conditions are different.\n\
15326 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
15328 /* List of subcommands for "catch". */
15329 static struct cmd_list_element
*catch_cmdlist
;
15331 /* List of subcommands for "tcatch". */
15332 static struct cmd_list_element
*tcatch_cmdlist
;
15335 add_catch_command (const char *name
, const char *docstring
,
15336 cmd_const_sfunc_ftype
*sfunc
,
15337 completer_ftype
*completer
,
15338 void *user_data_catch
,
15339 void *user_data_tcatch
)
15341 struct cmd_list_element
*command
;
15343 command
= add_cmd (name
, class_breakpoint
, docstring
,
15345 set_cmd_sfunc (command
, sfunc
);
15346 set_cmd_context (command
, user_data_catch
);
15347 set_cmd_completer (command
, completer
);
15349 command
= add_cmd (name
, class_breakpoint
, docstring
,
15351 set_cmd_sfunc (command
, sfunc
);
15352 set_cmd_context (command
, user_data_tcatch
);
15353 set_cmd_completer (command
, completer
);
15357 save_command (const char *arg
, int from_tty
)
15359 printf_unfiltered (_("\"save\" must be followed by "
15360 "the name of a save subcommand.\n"));
15361 help_list (save_cmdlist
, "save ", all_commands
, gdb_stdout
);
15364 struct breakpoint
*
15365 iterate_over_breakpoints (int (*callback
) (struct breakpoint
*, void *),
15368 struct breakpoint
*b
, *b_tmp
;
15370 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
15372 if ((*callback
) (b
, data
))
15379 /* Zero if any of the breakpoint's locations could be a location where
15380 functions have been inlined, nonzero otherwise. */
15383 is_non_inline_function (struct breakpoint
*b
)
15385 /* The shared library event breakpoint is set on the address of a
15386 non-inline function. */
15387 if (b
->type
== bp_shlib_event
)
15393 /* Nonzero if the specified PC cannot be a location where functions
15394 have been inlined. */
15397 pc_at_non_inline_function (const address_space
*aspace
, CORE_ADDR pc
,
15398 const struct target_waitstatus
*ws
)
15400 struct breakpoint
*b
;
15401 struct bp_location
*bl
;
15403 ALL_BREAKPOINTS (b
)
15405 if (!is_non_inline_function (b
))
15408 for (bl
= b
->loc
; bl
!= NULL
; bl
= bl
->next
)
15410 if (!bl
->shlib_disabled
15411 && bpstat_check_location (bl
, aspace
, pc
, ws
))
15419 /* Remove any references to OBJFILE which is going to be freed. */
15422 breakpoint_free_objfile (struct objfile
*objfile
)
15424 struct bp_location
**locp
, *loc
;
15426 ALL_BP_LOCATIONS (loc
, locp
)
15427 if (loc
->symtab
!= NULL
&& SYMTAB_OBJFILE (loc
->symtab
) == objfile
)
15428 loc
->symtab
= NULL
;
15432 initialize_breakpoint_ops (void)
15434 static int initialized
= 0;
15436 struct breakpoint_ops
*ops
;
15442 /* The breakpoint_ops structure to be inherit by all kinds of
15443 breakpoints (real breakpoints, i.e., user "break" breakpoints,
15444 internal and momentary breakpoints, etc.). */
15445 ops
= &bkpt_base_breakpoint_ops
;
15446 *ops
= base_breakpoint_ops
;
15447 ops
->re_set
= bkpt_re_set
;
15448 ops
->insert_location
= bkpt_insert_location
;
15449 ops
->remove_location
= bkpt_remove_location
;
15450 ops
->breakpoint_hit
= bkpt_breakpoint_hit
;
15451 ops
->create_sals_from_location
= bkpt_create_sals_from_location
;
15452 ops
->create_breakpoints_sal
= bkpt_create_breakpoints_sal
;
15453 ops
->decode_location
= bkpt_decode_location
;
15455 /* The breakpoint_ops structure to be used in regular breakpoints. */
15456 ops
= &bkpt_breakpoint_ops
;
15457 *ops
= bkpt_base_breakpoint_ops
;
15458 ops
->re_set
= bkpt_re_set
;
15459 ops
->resources_needed
= bkpt_resources_needed
;
15460 ops
->print_it
= bkpt_print_it
;
15461 ops
->print_mention
= bkpt_print_mention
;
15462 ops
->print_recreate
= bkpt_print_recreate
;
15464 /* Ranged breakpoints. */
15465 ops
= &ranged_breakpoint_ops
;
15466 *ops
= bkpt_breakpoint_ops
;
15467 ops
->breakpoint_hit
= breakpoint_hit_ranged_breakpoint
;
15468 ops
->resources_needed
= resources_needed_ranged_breakpoint
;
15469 ops
->print_it
= print_it_ranged_breakpoint
;
15470 ops
->print_one
= print_one_ranged_breakpoint
;
15471 ops
->print_one_detail
= print_one_detail_ranged_breakpoint
;
15472 ops
->print_mention
= print_mention_ranged_breakpoint
;
15473 ops
->print_recreate
= print_recreate_ranged_breakpoint
;
15475 /* Internal breakpoints. */
15476 ops
= &internal_breakpoint_ops
;
15477 *ops
= bkpt_base_breakpoint_ops
;
15478 ops
->re_set
= internal_bkpt_re_set
;
15479 ops
->check_status
= internal_bkpt_check_status
;
15480 ops
->print_it
= internal_bkpt_print_it
;
15481 ops
->print_mention
= internal_bkpt_print_mention
;
15483 /* Momentary breakpoints. */
15484 ops
= &momentary_breakpoint_ops
;
15485 *ops
= bkpt_base_breakpoint_ops
;
15486 ops
->re_set
= momentary_bkpt_re_set
;
15487 ops
->check_status
= momentary_bkpt_check_status
;
15488 ops
->print_it
= momentary_bkpt_print_it
;
15489 ops
->print_mention
= momentary_bkpt_print_mention
;
15491 /* Probe breakpoints. */
15492 ops
= &bkpt_probe_breakpoint_ops
;
15493 *ops
= bkpt_breakpoint_ops
;
15494 ops
->insert_location
= bkpt_probe_insert_location
;
15495 ops
->remove_location
= bkpt_probe_remove_location
;
15496 ops
->create_sals_from_location
= bkpt_probe_create_sals_from_location
;
15497 ops
->decode_location
= bkpt_probe_decode_location
;
15500 ops
= &watchpoint_breakpoint_ops
;
15501 *ops
= base_breakpoint_ops
;
15502 ops
->re_set
= re_set_watchpoint
;
15503 ops
->insert_location
= insert_watchpoint
;
15504 ops
->remove_location
= remove_watchpoint
;
15505 ops
->breakpoint_hit
= breakpoint_hit_watchpoint
;
15506 ops
->check_status
= check_status_watchpoint
;
15507 ops
->resources_needed
= resources_needed_watchpoint
;
15508 ops
->works_in_software_mode
= works_in_software_mode_watchpoint
;
15509 ops
->print_it
= print_it_watchpoint
;
15510 ops
->print_mention
= print_mention_watchpoint
;
15511 ops
->print_recreate
= print_recreate_watchpoint
;
15512 ops
->explains_signal
= explains_signal_watchpoint
;
15514 /* Masked watchpoints. */
15515 ops
= &masked_watchpoint_breakpoint_ops
;
15516 *ops
= watchpoint_breakpoint_ops
;
15517 ops
->insert_location
= insert_masked_watchpoint
;
15518 ops
->remove_location
= remove_masked_watchpoint
;
15519 ops
->resources_needed
= resources_needed_masked_watchpoint
;
15520 ops
->works_in_software_mode
= works_in_software_mode_masked_watchpoint
;
15521 ops
->print_it
= print_it_masked_watchpoint
;
15522 ops
->print_one_detail
= print_one_detail_masked_watchpoint
;
15523 ops
->print_mention
= print_mention_masked_watchpoint
;
15524 ops
->print_recreate
= print_recreate_masked_watchpoint
;
15527 ops
= &tracepoint_breakpoint_ops
;
15528 *ops
= base_breakpoint_ops
;
15529 ops
->re_set
= tracepoint_re_set
;
15530 ops
->breakpoint_hit
= tracepoint_breakpoint_hit
;
15531 ops
->print_one_detail
= tracepoint_print_one_detail
;
15532 ops
->print_mention
= tracepoint_print_mention
;
15533 ops
->print_recreate
= tracepoint_print_recreate
;
15534 ops
->create_sals_from_location
= tracepoint_create_sals_from_location
;
15535 ops
->create_breakpoints_sal
= tracepoint_create_breakpoints_sal
;
15536 ops
->decode_location
= tracepoint_decode_location
;
15538 /* Probe tracepoints. */
15539 ops
= &tracepoint_probe_breakpoint_ops
;
15540 *ops
= tracepoint_breakpoint_ops
;
15541 ops
->create_sals_from_location
= tracepoint_probe_create_sals_from_location
;
15542 ops
->decode_location
= tracepoint_probe_decode_location
;
15544 /* Static tracepoints with marker (`-m'). */
15545 ops
= &strace_marker_breakpoint_ops
;
15546 *ops
= tracepoint_breakpoint_ops
;
15547 ops
->create_sals_from_location
= strace_marker_create_sals_from_location
;
15548 ops
->create_breakpoints_sal
= strace_marker_create_breakpoints_sal
;
15549 ops
->decode_location
= strace_marker_decode_location
;
15551 /* Fork catchpoints. */
15552 ops
= &catch_fork_breakpoint_ops
;
15553 *ops
= base_breakpoint_ops
;
15554 ops
->insert_location
= insert_catch_fork
;
15555 ops
->remove_location
= remove_catch_fork
;
15556 ops
->breakpoint_hit
= breakpoint_hit_catch_fork
;
15557 ops
->print_it
= print_it_catch_fork
;
15558 ops
->print_one
= print_one_catch_fork
;
15559 ops
->print_mention
= print_mention_catch_fork
;
15560 ops
->print_recreate
= print_recreate_catch_fork
;
15562 /* Vfork catchpoints. */
15563 ops
= &catch_vfork_breakpoint_ops
;
15564 *ops
= base_breakpoint_ops
;
15565 ops
->insert_location
= insert_catch_vfork
;
15566 ops
->remove_location
= remove_catch_vfork
;
15567 ops
->breakpoint_hit
= breakpoint_hit_catch_vfork
;
15568 ops
->print_it
= print_it_catch_vfork
;
15569 ops
->print_one
= print_one_catch_vfork
;
15570 ops
->print_mention
= print_mention_catch_vfork
;
15571 ops
->print_recreate
= print_recreate_catch_vfork
;
15573 /* Exec catchpoints. */
15574 ops
= &catch_exec_breakpoint_ops
;
15575 *ops
= base_breakpoint_ops
;
15576 ops
->insert_location
= insert_catch_exec
;
15577 ops
->remove_location
= remove_catch_exec
;
15578 ops
->breakpoint_hit
= breakpoint_hit_catch_exec
;
15579 ops
->print_it
= print_it_catch_exec
;
15580 ops
->print_one
= print_one_catch_exec
;
15581 ops
->print_mention
= print_mention_catch_exec
;
15582 ops
->print_recreate
= print_recreate_catch_exec
;
15584 /* Solib-related catchpoints. */
15585 ops
= &catch_solib_breakpoint_ops
;
15586 *ops
= base_breakpoint_ops
;
15587 ops
->insert_location
= insert_catch_solib
;
15588 ops
->remove_location
= remove_catch_solib
;
15589 ops
->breakpoint_hit
= breakpoint_hit_catch_solib
;
15590 ops
->check_status
= check_status_catch_solib
;
15591 ops
->print_it
= print_it_catch_solib
;
15592 ops
->print_one
= print_one_catch_solib
;
15593 ops
->print_mention
= print_mention_catch_solib
;
15594 ops
->print_recreate
= print_recreate_catch_solib
;
15596 ops
= &dprintf_breakpoint_ops
;
15597 *ops
= bkpt_base_breakpoint_ops
;
15598 ops
->re_set
= dprintf_re_set
;
15599 ops
->resources_needed
= bkpt_resources_needed
;
15600 ops
->print_it
= bkpt_print_it
;
15601 ops
->print_mention
= bkpt_print_mention
;
15602 ops
->print_recreate
= dprintf_print_recreate
;
15603 ops
->after_condition_true
= dprintf_after_condition_true
;
15604 ops
->breakpoint_hit
= dprintf_breakpoint_hit
;
15607 /* Chain containing all defined "enable breakpoint" subcommands. */
15609 static struct cmd_list_element
*enablebreaklist
= NULL
;
15612 _initialize_breakpoint (void)
15614 struct cmd_list_element
*c
;
15616 initialize_breakpoint_ops ();
15618 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
15619 observer_attach_free_objfile (disable_breakpoints_in_freed_objfile
);
15620 observer_attach_memory_changed (invalidate_bp_value_on_memory_change
);
15622 breakpoint_objfile_key
15623 = register_objfile_data_with_cleanup (NULL
, free_breakpoint_objfile_data
);
15625 breakpoint_chain
= 0;
15626 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
15627 before a breakpoint is set. */
15628 breakpoint_count
= 0;
15630 tracepoint_count
= 0;
15632 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
15633 Set ignore-count of breakpoint number N to COUNT.\n\
15634 Usage is `ignore N COUNT'."));
15636 add_com ("commands", class_breakpoint
, commands_command
, _("\
15637 Set commands to be executed when the given breakpoints are hit.\n\
15638 Give a space-separated breakpoint list as argument after \"commands\".\n\
15639 A list element can be a breakpoint number (e.g. `5') or a range of numbers\n\
15641 With no argument, the targeted breakpoint is the last one set.\n\
15642 The commands themselves follow starting on the next line.\n\
15643 Type a line containing \"end\" to indicate the end of them.\n\
15644 Give \"silent\" as the first line to make the breakpoint silent;\n\
15645 then no output is printed when it is hit, except what the commands print."));
15647 c
= add_com ("condition", class_breakpoint
, condition_command
, _("\
15648 Specify breakpoint number N to break only if COND is true.\n\
15649 Usage is `condition N COND', where N is an integer and COND is an\n\
15650 expression to be evaluated whenever breakpoint N is reached."));
15651 set_cmd_completer (c
, condition_completer
);
15653 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
15654 Set a temporary breakpoint.\n\
15655 Like \"break\" except the breakpoint is only temporary,\n\
15656 so it will be deleted when hit. Equivalent to \"break\" followed\n\
15657 by using \"enable delete\" on the breakpoint number.\n\
15659 BREAK_ARGS_HELP ("tbreak")));
15660 set_cmd_completer (c
, location_completer
);
15662 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
15663 Set a hardware assisted breakpoint.\n\
15664 Like \"break\" except the breakpoint requires hardware support,\n\
15665 some target hardware may not have this support.\n\
15667 BREAK_ARGS_HELP ("hbreak")));
15668 set_cmd_completer (c
, location_completer
);
15670 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
15671 Set a temporary hardware assisted breakpoint.\n\
15672 Like \"hbreak\" except the breakpoint is only temporary,\n\
15673 so it will be deleted when hit.\n\
15675 BREAK_ARGS_HELP ("thbreak")));
15676 set_cmd_completer (c
, location_completer
);
15678 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
15679 Enable some breakpoints.\n\
15680 Give breakpoint numbers (separated by spaces) as arguments.\n\
15681 With no subcommand, breakpoints are enabled until you command otherwise.\n\
15682 This is used to cancel the effect of the \"disable\" command.\n\
15683 With a subcommand you can enable temporarily."),
15684 &enablelist
, "enable ", 1, &cmdlist
);
15686 add_com_alias ("en", "enable", class_breakpoint
, 1);
15688 add_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
15689 Enable some breakpoints.\n\
15690 Give breakpoint numbers (separated by spaces) as arguments.\n\
15691 This is used to cancel the effect of the \"disable\" command.\n\
15692 May be abbreviated to simply \"enable\".\n"),
15693 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
15695 add_cmd ("once", no_class
, enable_once_command
, _("\
15696 Enable breakpoints for one hit. Give breakpoint numbers.\n\
15697 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
15700 add_cmd ("delete", no_class
, enable_delete_command
, _("\
15701 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
15702 If a breakpoint is hit while enabled in this fashion, it is deleted."),
15705 add_cmd ("count", no_class
, enable_count_command
, _("\
15706 Enable breakpoints for COUNT hits. Give count and then breakpoint numbers.\n\
15707 If a breakpoint is hit while enabled in this fashion,\n\
15708 the count is decremented; when it reaches zero, the breakpoint is disabled."),
15711 add_cmd ("delete", no_class
, enable_delete_command
, _("\
15712 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
15713 If a breakpoint is hit while enabled in this fashion, it is deleted."),
15716 add_cmd ("once", no_class
, enable_once_command
, _("\
15717 Enable breakpoints for one hit. Give breakpoint numbers.\n\
15718 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
15721 add_cmd ("count", no_class
, enable_count_command
, _("\
15722 Enable breakpoints for COUNT hits. Give count and then breakpoint numbers.\n\
15723 If a breakpoint is hit while enabled in this fashion,\n\
15724 the count is decremented; when it reaches zero, the breakpoint is disabled."),
15727 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
15728 Disable some breakpoints.\n\
15729 Arguments are breakpoint numbers with spaces in between.\n\
15730 To disable all breakpoints, give no argument.\n\
15731 A disabled breakpoint is not forgotten, but has no effect until re-enabled."),
15732 &disablelist
, "disable ", 1, &cmdlist
);
15733 add_com_alias ("dis", "disable", class_breakpoint
, 1);
15734 add_com_alias ("disa", "disable", class_breakpoint
, 1);
15736 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
15737 Disable some breakpoints.\n\
15738 Arguments are breakpoint numbers with spaces in between.\n\
15739 To disable all breakpoints, give no argument.\n\
15740 A disabled breakpoint is not forgotten, but has no effect until re-enabled.\n\
15741 This command may be abbreviated \"disable\"."),
15744 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
15745 Delete some breakpoints or auto-display expressions.\n\
15746 Arguments are breakpoint numbers with spaces in between.\n\
15747 To delete all breakpoints, give no argument.\n\
15749 Also a prefix command for deletion of other GDB objects.\n\
15750 The \"unset\" command is also an alias for \"delete\"."),
15751 &deletelist
, "delete ", 1, &cmdlist
);
15752 add_com_alias ("d", "delete", class_breakpoint
, 1);
15753 add_com_alias ("del", "delete", class_breakpoint
, 1);
15755 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
15756 Delete some breakpoints or auto-display expressions.\n\
15757 Arguments are breakpoint numbers with spaces in between.\n\
15758 To delete all breakpoints, give no argument.\n\
15759 This command may be abbreviated \"delete\"."),
15762 add_com ("clear", class_breakpoint
, clear_command
, _("\
15763 Clear breakpoint at specified location.\n\
15764 Argument may be a linespec, explicit, or address location as described below.\n\
15766 With no argument, clears all breakpoints in the line that the selected frame\n\
15767 is executing in.\n"
15768 "\n" LOCATION_HELP_STRING
"\n\
15769 See also the \"delete\" command which clears breakpoints by number."));
15770 add_com_alias ("cl", "clear", class_breakpoint
, 1);
15772 c
= add_com ("break", class_breakpoint
, break_command
, _("\
15773 Set breakpoint at specified location.\n"
15774 BREAK_ARGS_HELP ("break")));
15775 set_cmd_completer (c
, location_completer
);
15777 add_com_alias ("b", "break", class_run
, 1);
15778 add_com_alias ("br", "break", class_run
, 1);
15779 add_com_alias ("bre", "break", class_run
, 1);
15780 add_com_alias ("brea", "break", class_run
, 1);
15784 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
15785 Break in function/address or break at a line in the current file."),
15786 &stoplist
, "stop ", 1, &cmdlist
);
15787 add_cmd ("in", class_breakpoint
, stopin_command
,
15788 _("Break in function or address."), &stoplist
);
15789 add_cmd ("at", class_breakpoint
, stopat_command
,
15790 _("Break at a line in the current file."), &stoplist
);
15791 add_com ("status", class_info
, info_breakpoints_command
, _("\
15792 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
15793 The \"Type\" column indicates one of:\n\
15794 \tbreakpoint - normal breakpoint\n\
15795 \twatchpoint - watchpoint\n\
15796 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15797 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
15798 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
15799 address and file/line number respectively.\n\
15801 Convenience variable \"$_\" and default examine address for \"x\"\n\
15802 are set to the address of the last breakpoint listed unless the command\n\
15803 is prefixed with \"server \".\n\n\
15804 Convenience variable \"$bpnum\" contains the number of the last\n\
15805 breakpoint set."));
15808 add_info ("breakpoints", info_breakpoints_command
, _("\
15809 Status of specified breakpoints (all user-settable breakpoints if no argument).\n\
15810 The \"Type\" column indicates one of:\n\
15811 \tbreakpoint - normal breakpoint\n\
15812 \twatchpoint - watchpoint\n\
15813 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15814 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
15815 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
15816 address and file/line number respectively.\n\
15818 Convenience variable \"$_\" and default examine address for \"x\"\n\
15819 are set to the address of the last breakpoint listed unless the command\n\
15820 is prefixed with \"server \".\n\n\
15821 Convenience variable \"$bpnum\" contains the number of the last\n\
15822 breakpoint set."));
15824 add_info_alias ("b", "breakpoints", 1);
15826 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
15827 Status of all breakpoints, or breakpoint number NUMBER.\n\
15828 The \"Type\" column indicates one of:\n\
15829 \tbreakpoint - normal breakpoint\n\
15830 \twatchpoint - watchpoint\n\
15831 \tlongjmp - internal breakpoint used to step through longjmp()\n\
15832 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
15833 \tuntil - internal breakpoint used by the \"until\" command\n\
15834 \tfinish - internal breakpoint used by the \"finish\" command\n\
15835 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15836 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
15837 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
15838 address and file/line number respectively.\n\
15840 Convenience variable \"$_\" and default examine address for \"x\"\n\
15841 are set to the address of the last breakpoint listed unless the command\n\
15842 is prefixed with \"server \".\n\n\
15843 Convenience variable \"$bpnum\" contains the number of the last\n\
15845 &maintenanceinfolist
);
15847 add_prefix_cmd ("catch", class_breakpoint
, catch_command
, _("\
15848 Set catchpoints to catch events."),
15849 &catch_cmdlist
, "catch ",
15850 0/*allow-unknown*/, &cmdlist
);
15852 add_prefix_cmd ("tcatch", class_breakpoint
, tcatch_command
, _("\
15853 Set temporary catchpoints to catch events."),
15854 &tcatch_cmdlist
, "tcatch ",
15855 0/*allow-unknown*/, &cmdlist
);
15857 add_catch_command ("fork", _("Catch calls to fork."),
15858 catch_fork_command_1
,
15860 (void *) (uintptr_t) catch_fork_permanent
,
15861 (void *) (uintptr_t) catch_fork_temporary
);
15862 add_catch_command ("vfork", _("Catch calls to vfork."),
15863 catch_fork_command_1
,
15865 (void *) (uintptr_t) catch_vfork_permanent
,
15866 (void *) (uintptr_t) catch_vfork_temporary
);
15867 add_catch_command ("exec", _("Catch calls to exec."),
15868 catch_exec_command_1
,
15872 add_catch_command ("load", _("Catch loads of shared libraries.\n\
15873 Usage: catch load [REGEX]\n\
15874 If REGEX is given, only stop for libraries matching the regular expression."),
15875 catch_load_command_1
,
15879 add_catch_command ("unload", _("Catch unloads of shared libraries.\n\
15880 Usage: catch unload [REGEX]\n\
15881 If REGEX is given, only stop for libraries matching the regular expression."),
15882 catch_unload_command_1
,
15887 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
15888 Set a watchpoint for an expression.\n\
15889 Usage: watch [-l|-location] EXPRESSION\n\
15890 A watchpoint stops execution of your program whenever the value of\n\
15891 an expression changes.\n\
15892 If -l or -location is given, this evaluates EXPRESSION and watches\n\
15893 the memory to which it refers."));
15894 set_cmd_completer (c
, expression_completer
);
15896 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
15897 Set a read watchpoint for an expression.\n\
15898 Usage: rwatch [-l|-location] EXPRESSION\n\
15899 A watchpoint stops execution of your program whenever the value of\n\
15900 an expression is read.\n\
15901 If -l or -location is given, this evaluates EXPRESSION and watches\n\
15902 the memory to which it refers."));
15903 set_cmd_completer (c
, expression_completer
);
15905 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
15906 Set a watchpoint for an expression.\n\
15907 Usage: awatch [-l|-location] EXPRESSION\n\
15908 A watchpoint stops execution of your program whenever the value of\n\
15909 an expression is either read or written.\n\
15910 If -l or -location is given, this evaluates EXPRESSION and watches\n\
15911 the memory to which it refers."));
15912 set_cmd_completer (c
, expression_completer
);
15914 add_info ("watchpoints", info_watchpoints_command
, _("\
15915 Status of specified watchpoints (all watchpoints if no argument)."));
15917 /* XXX: cagney/2005-02-23: This should be a boolean, and should
15918 respond to changes - contrary to the description. */
15919 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
15920 &can_use_hw_watchpoints
, _("\
15921 Set debugger's willingness to use watchpoint hardware."), _("\
15922 Show debugger's willingness to use watchpoint hardware."), _("\
15923 If zero, gdb will not use hardware for new watchpoints, even if\n\
15924 such is available. (However, any hardware watchpoints that were\n\
15925 created before setting this to nonzero, will continue to use watchpoint\n\
15928 show_can_use_hw_watchpoints
,
15929 &setlist
, &showlist
);
15931 can_use_hw_watchpoints
= 1;
15933 /* Tracepoint manipulation commands. */
15935 c
= add_com ("trace", class_breakpoint
, trace_command
, _("\
15936 Set a tracepoint at specified location.\n\
15938 BREAK_ARGS_HELP ("trace") "\n\
15939 Do \"help tracepoints\" for info on other tracepoint commands."));
15940 set_cmd_completer (c
, location_completer
);
15942 add_com_alias ("tp", "trace", class_alias
, 0);
15943 add_com_alias ("tr", "trace", class_alias
, 1);
15944 add_com_alias ("tra", "trace", class_alias
, 1);
15945 add_com_alias ("trac", "trace", class_alias
, 1);
15947 c
= add_com ("ftrace", class_breakpoint
, ftrace_command
, _("\
15948 Set a fast tracepoint at specified location.\n\
15950 BREAK_ARGS_HELP ("ftrace") "\n\
15951 Do \"help tracepoints\" for info on other tracepoint commands."));
15952 set_cmd_completer (c
, location_completer
);
15954 c
= add_com ("strace", class_breakpoint
, strace_command
, _("\
15955 Set a static tracepoint at location or marker.\n\
15957 strace [LOCATION] [if CONDITION]\n\
15958 LOCATION may be a linespec, explicit, or address location (described below) \n\
15959 or -m MARKER_ID.\n\n\
15960 If a marker id is specified, probe the marker with that name. With\n\
15961 no LOCATION, uses current execution address of the selected stack frame.\n\
15962 Static tracepoints accept an extra collect action -- ``collect $_sdata''.\n\
15963 This collects arbitrary user data passed in the probe point call to the\n\
15964 tracing library. You can inspect it when analyzing the trace buffer,\n\
15965 by printing the $_sdata variable like any other convenience variable.\n\
15967 CONDITION is a boolean expression.\n\
15968 \n" LOCATION_HELP_STRING
"\n\
15969 Multiple tracepoints at one place are permitted, and useful if their\n\
15970 conditions are different.\n\
15972 Do \"help breakpoints\" for info on other commands dealing with breakpoints.\n\
15973 Do \"help tracepoints\" for info on other tracepoint commands."));
15974 set_cmd_completer (c
, location_completer
);
15976 add_info ("tracepoints", info_tracepoints_command
, _("\
15977 Status of specified tracepoints (all tracepoints if no argument).\n\
15978 Convenience variable \"$tpnum\" contains the number of the\n\
15979 last tracepoint set."));
15981 add_info_alias ("tp", "tracepoints", 1);
15983 add_cmd ("tracepoints", class_trace
, delete_trace_command
, _("\
15984 Delete specified tracepoints.\n\
15985 Arguments are tracepoint numbers, separated by spaces.\n\
15986 No argument means delete all tracepoints."),
15988 add_alias_cmd ("tr", "tracepoints", class_trace
, 1, &deletelist
);
15990 c
= add_cmd ("tracepoints", class_trace
, disable_trace_command
, _("\
15991 Disable specified tracepoints.\n\
15992 Arguments are tracepoint numbers, separated by spaces.\n\
15993 No argument means disable all tracepoints."),
15995 deprecate_cmd (c
, "disable");
15997 c
= add_cmd ("tracepoints", class_trace
, enable_trace_command
, _("\
15998 Enable specified tracepoints.\n\
15999 Arguments are tracepoint numbers, separated by spaces.\n\
16000 No argument means enable all tracepoints."),
16002 deprecate_cmd (c
, "enable");
16004 add_com ("passcount", class_trace
, trace_pass_command
, _("\
16005 Set the passcount for a tracepoint.\n\
16006 The trace will end when the tracepoint has been passed 'count' times.\n\
16007 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
16008 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
16010 add_prefix_cmd ("save", class_breakpoint
, save_command
,
16011 _("Save breakpoint definitions as a script."),
16012 &save_cmdlist
, "save ",
16013 0/*allow-unknown*/, &cmdlist
);
16015 c
= add_cmd ("breakpoints", class_breakpoint
, save_breakpoints_command
, _("\
16016 Save current breakpoint definitions as a script.\n\
16017 This includes all types of breakpoints (breakpoints, watchpoints,\n\
16018 catchpoints, tracepoints). Use the 'source' command in another debug\n\
16019 session to restore them."),
16021 set_cmd_completer (c
, filename_completer
);
16023 c
= add_cmd ("tracepoints", class_trace
, save_tracepoints_command
, _("\
16024 Save current tracepoint definitions as a script.\n\
16025 Use the 'source' command in another debug session to restore them."),
16027 set_cmd_completer (c
, filename_completer
);
16029 c
= add_com_alias ("save-tracepoints", "save tracepoints", class_trace
, 0);
16030 deprecate_cmd (c
, "save tracepoints");
16032 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
16033 Breakpoint specific settings\n\
16034 Configure various breakpoint-specific variables such as\n\
16035 pending breakpoint behavior"),
16036 &breakpoint_set_cmdlist
, "set breakpoint ",
16037 0/*allow-unknown*/, &setlist
);
16038 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
16039 Breakpoint specific settings\n\
16040 Configure various breakpoint-specific variables such as\n\
16041 pending breakpoint behavior"),
16042 &breakpoint_show_cmdlist
, "show breakpoint ",
16043 0/*allow-unknown*/, &showlist
);
16045 add_setshow_auto_boolean_cmd ("pending", no_class
,
16046 &pending_break_support
, _("\
16047 Set debugger's behavior regarding pending breakpoints."), _("\
16048 Show debugger's behavior regarding pending breakpoints."), _("\
16049 If on, an unrecognized breakpoint location will cause gdb to create a\n\
16050 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
16051 an error. If auto, an unrecognized breakpoint location results in a\n\
16052 user-query to see if a pending breakpoint should be created."),
16054 show_pending_break_support
,
16055 &breakpoint_set_cmdlist
,
16056 &breakpoint_show_cmdlist
);
16058 pending_break_support
= AUTO_BOOLEAN_AUTO
;
16060 add_setshow_boolean_cmd ("auto-hw", no_class
,
16061 &automatic_hardware_breakpoints
, _("\
16062 Set automatic usage of hardware breakpoints."), _("\
16063 Show automatic usage of hardware breakpoints."), _("\
16064 If set, the debugger will automatically use hardware breakpoints for\n\
16065 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
16066 a warning will be emitted for such breakpoints."),
16068 show_automatic_hardware_breakpoints
,
16069 &breakpoint_set_cmdlist
,
16070 &breakpoint_show_cmdlist
);
16072 add_setshow_boolean_cmd ("always-inserted", class_support
,
16073 &always_inserted_mode
, _("\
16074 Set mode for inserting breakpoints."), _("\
16075 Show mode for inserting breakpoints."), _("\
16076 When this mode is on, breakpoints are inserted immediately as soon as\n\
16077 they're created, kept inserted even when execution stops, and removed\n\
16078 only when the user deletes them. When this mode is off (the default),\n\
16079 breakpoints are inserted only when execution continues, and removed\n\
16080 when execution stops."),
16082 &show_always_inserted_mode
,
16083 &breakpoint_set_cmdlist
,
16084 &breakpoint_show_cmdlist
);
16086 add_setshow_enum_cmd ("condition-evaluation", class_breakpoint
,
16087 condition_evaluation_enums
,
16088 &condition_evaluation_mode_1
, _("\
16089 Set mode of breakpoint condition evaluation."), _("\
16090 Show mode of breakpoint condition evaluation."), _("\
16091 When this is set to \"host\", breakpoint conditions will be\n\
16092 evaluated on the host's side by GDB. When it is set to \"target\",\n\
16093 breakpoint conditions will be downloaded to the target (if the target\n\
16094 supports such feature) and conditions will be evaluated on the target's side.\n\
16095 If this is set to \"auto\" (default), this will be automatically set to\n\
16096 \"target\" if it supports condition evaluation, otherwise it will\n\
16097 be set to \"gdb\""),
16098 &set_condition_evaluation_mode
,
16099 &show_condition_evaluation_mode
,
16100 &breakpoint_set_cmdlist
,
16101 &breakpoint_show_cmdlist
);
16103 add_com ("break-range", class_breakpoint
, break_range_command
, _("\
16104 Set a breakpoint for an address range.\n\
16105 break-range START-LOCATION, END-LOCATION\n\
16106 where START-LOCATION and END-LOCATION can be one of the following:\n\
16107 LINENUM, for that line in the current file,\n\
16108 FILE:LINENUM, for that line in that file,\n\
16109 +OFFSET, for that number of lines after the current line\n\
16110 or the start of the range\n\
16111 FUNCTION, for the first line in that function,\n\
16112 FILE:FUNCTION, to distinguish among like-named static functions.\n\
16113 *ADDRESS, for the instruction at that address.\n\
16115 The breakpoint will stop execution of the inferior whenever it executes\n\
16116 an instruction at any address within the [START-LOCATION, END-LOCATION]\n\
16117 range (including START-LOCATION and END-LOCATION)."));
16119 c
= add_com ("dprintf", class_breakpoint
, dprintf_command
, _("\
16120 Set a dynamic printf at specified location.\n\
16121 dprintf location,format string,arg1,arg2,...\n\
16122 location may be a linespec, explicit, or address location.\n"
16123 "\n" LOCATION_HELP_STRING
));
16124 set_cmd_completer (c
, location_completer
);
16126 add_setshow_enum_cmd ("dprintf-style", class_support
,
16127 dprintf_style_enums
, &dprintf_style
, _("\
16128 Set the style of usage for dynamic printf."), _("\
16129 Show the style of usage for dynamic printf."), _("\
16130 This setting chooses how GDB will do a dynamic printf.\n\
16131 If the value is \"gdb\", then the printing is done by GDB to its own\n\
16132 console, as with the \"printf\" command.\n\
16133 If the value is \"call\", the print is done by calling a function in your\n\
16134 program; by default printf(), but you can choose a different function or\n\
16135 output stream by setting dprintf-function and dprintf-channel."),
16136 update_dprintf_commands
, NULL
,
16137 &setlist
, &showlist
);
16139 dprintf_function
= xstrdup ("printf");
16140 add_setshow_string_cmd ("dprintf-function", class_support
,
16141 &dprintf_function
, _("\
16142 Set the function to use for dynamic printf"), _("\
16143 Show the function to use for dynamic printf"), NULL
,
16144 update_dprintf_commands
, NULL
,
16145 &setlist
, &showlist
);
16147 dprintf_channel
= xstrdup ("");
16148 add_setshow_string_cmd ("dprintf-channel", class_support
,
16149 &dprintf_channel
, _("\
16150 Set the channel to use for dynamic printf"), _("\
16151 Show the channel to use for dynamic printf"), NULL
,
16152 update_dprintf_commands
, NULL
,
16153 &setlist
, &showlist
);
16155 add_setshow_boolean_cmd ("disconnected-dprintf", no_class
,
16156 &disconnected_dprintf
, _("\
16157 Set whether dprintf continues after GDB disconnects."), _("\
16158 Show whether dprintf continues after GDB disconnects."), _("\
16159 Use this to let dprintf commands continue to hit and produce output\n\
16160 even if GDB disconnects or detaches from the target."),
16163 &setlist
, &showlist
);
16165 add_com ("agent-printf", class_vars
, agent_printf_command
, _("\
16166 agent-printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
16167 (target agent only) This is useful for formatted output in user-defined commands."));
16169 automatic_hardware_breakpoints
= 1;
16171 observer_attach_about_to_proceed (breakpoint_about_to_proceed
);
16172 observer_attach_thread_exit (remove_threaded_breakpoints
);