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 disable_command (char *, int);
98 static void enable_command (char *, int);
100 static void map_breakpoint_numbers (const char *,
101 gdb::function_view
<void (breakpoint
*)>);
103 static void ignore_command (char *, int);
105 static void breakpoint_re_set_default (struct breakpoint
*);
108 create_sals_from_location_default (const struct event_location
*location
,
109 struct linespec_result
*canonical
,
110 enum bptype type_wanted
);
112 static void create_breakpoints_sal_default (struct gdbarch
*,
113 struct linespec_result
*,
114 gdb::unique_xmalloc_ptr
<char>,
115 gdb::unique_xmalloc_ptr
<char>,
117 enum bpdisp
, int, int,
119 const struct breakpoint_ops
*,
120 int, int, int, unsigned);
122 static std::vector
<symtab_and_line
> decode_location_default
123 (struct breakpoint
*b
, const struct event_location
*location
,
124 struct program_space
*search_pspace
);
126 static void clear_command (char *, int);
128 static void catch_command (char *, int);
130 static int can_use_hardware_watchpoint (struct value
*);
132 static void mention (struct breakpoint
*);
134 static struct breakpoint
*set_raw_breakpoint_without_location (struct gdbarch
*,
136 const struct breakpoint_ops
*);
137 static struct bp_location
*add_location_to_breakpoint (struct breakpoint
*,
138 const struct symtab_and_line
*);
140 /* This function is used in gdbtk sources and thus can not be made
142 struct breakpoint
*set_raw_breakpoint (struct gdbarch
*gdbarch
,
143 struct symtab_and_line
,
145 const struct breakpoint_ops
*);
147 static struct breakpoint
*
148 momentary_breakpoint_from_master (struct breakpoint
*orig
,
150 const struct breakpoint_ops
*ops
,
153 static void breakpoint_adjustment_warning (CORE_ADDR
, CORE_ADDR
, int, int);
155 static CORE_ADDR
adjust_breakpoint_address (struct gdbarch
*gdbarch
,
159 static void describe_other_breakpoints (struct gdbarch
*,
160 struct program_space
*, CORE_ADDR
,
161 struct obj_section
*, int);
163 static int watchpoint_locations_match (struct bp_location
*loc1
,
164 struct bp_location
*loc2
);
166 static int breakpoint_location_address_match (struct bp_location
*bl
,
167 struct address_space
*aspace
,
170 static int breakpoint_location_address_range_overlap (struct bp_location
*,
171 struct address_space
*,
174 static void info_breakpoints_command (char *, int);
176 static void info_watchpoints_command (char *, int);
178 static void cleanup_executing_breakpoints (void *);
180 static void commands_command (char *, int);
182 static void condition_command (char *, int);
184 static int remove_breakpoint (struct bp_location
*);
185 static int remove_breakpoint_1 (struct bp_location
*, enum remove_bp_reason
);
187 static enum print_stop_action
print_bp_stop_message (bpstat bs
);
189 static int hw_breakpoint_used_count (void);
191 static int hw_watchpoint_use_count (struct breakpoint
*);
193 static int hw_watchpoint_used_count_others (struct breakpoint
*except
,
195 int *other_type_used
);
197 static void hbreak_command (char *, int);
199 static void thbreak_command (char *, int);
201 static void enable_breakpoint_disp (struct breakpoint
*, enum bpdisp
,
204 static void stop_command (char *arg
, int from_tty
);
206 static void tcatch_command (char *arg
, int from_tty
);
208 static void free_bp_location (struct bp_location
*loc
);
209 static void incref_bp_location (struct bp_location
*loc
);
210 static void decref_bp_location (struct bp_location
**loc
);
212 static struct bp_location
*allocate_bp_location (struct breakpoint
*bpt
);
214 /* update_global_location_list's modes of operation wrt to whether to
215 insert locations now. */
216 enum ugll_insert_mode
218 /* Don't insert any breakpoint locations into the inferior, only
219 remove already-inserted locations that no longer should be
220 inserted. Functions that delete a breakpoint or breakpoints
221 should specify this mode, so that deleting a breakpoint doesn't
222 have the side effect of inserting the locations of other
223 breakpoints that are marked not-inserted, but should_be_inserted
224 returns true on them.
226 This behavior is useful is situations close to tear-down -- e.g.,
227 after an exec, while the target still has execution, but
228 breakpoint shadows of the previous executable image should *NOT*
229 be restored to the new image; or before detaching, where the
230 target still has execution and wants to delete breakpoints from
231 GDB's lists, and all breakpoints had already been removed from
235 /* May insert breakpoints iff breakpoints_should_be_inserted_now
236 claims breakpoints should be inserted now. */
239 /* Insert locations now, irrespective of
240 breakpoints_should_be_inserted_now. E.g., say all threads are
241 stopped right now, and the user did "continue". We need to
242 insert breakpoints _before_ resuming the target, but
243 UGLL_MAY_INSERT wouldn't insert them, because
244 breakpoints_should_be_inserted_now returns false at that point,
245 as no thread is running yet. */
249 static void update_global_location_list (enum ugll_insert_mode
);
251 static void update_global_location_list_nothrow (enum ugll_insert_mode
);
253 static int is_hardware_watchpoint (const struct breakpoint
*bpt
);
255 static void insert_breakpoint_locations (void);
257 static void info_tracepoints_command (char *, int);
259 static void enable_trace_command (char *, int);
261 static void disable_trace_command (char *, int);
263 static void trace_pass_command (char *, int);
265 static void set_tracepoint_count (int num
);
267 static int is_masked_watchpoint (const struct breakpoint
*b
);
269 static struct bp_location
**get_first_locp_gte_addr (CORE_ADDR address
);
271 /* Return 1 if B refers to a static tracepoint set by marker ("-m"), zero
274 static int strace_marker_p (struct breakpoint
*b
);
276 /* The breakpoint_ops structure to be inherited by all breakpoint_ops
277 that are implemented on top of software or hardware breakpoints
278 (user breakpoints, internal and momentary breakpoints, etc.). */
279 static struct breakpoint_ops bkpt_base_breakpoint_ops
;
281 /* Internal breakpoints class type. */
282 static struct breakpoint_ops internal_breakpoint_ops
;
284 /* Momentary breakpoints class type. */
285 static struct breakpoint_ops momentary_breakpoint_ops
;
287 /* The breakpoint_ops structure to be used in regular user created
289 struct breakpoint_ops bkpt_breakpoint_ops
;
291 /* Breakpoints set on probes. */
292 static struct breakpoint_ops bkpt_probe_breakpoint_ops
;
294 /* Dynamic printf class type. */
295 struct breakpoint_ops dprintf_breakpoint_ops
;
297 /* The style in which to perform a dynamic printf. This is a user
298 option because different output options have different tradeoffs;
299 if GDB does the printing, there is better error handling if there
300 is a problem with any of the arguments, but using an inferior
301 function lets you have special-purpose printers and sending of
302 output to the same place as compiled-in print functions. */
304 static const char dprintf_style_gdb
[] = "gdb";
305 static const char dprintf_style_call
[] = "call";
306 static const char dprintf_style_agent
[] = "agent";
307 static const char *const dprintf_style_enums
[] = {
313 static const char *dprintf_style
= dprintf_style_gdb
;
315 /* The function to use for dynamic printf if the preferred style is to
316 call into the inferior. The value is simply a string that is
317 copied into the command, so it can be anything that GDB can
318 evaluate to a callable address, not necessarily a function name. */
320 static char *dprintf_function
;
322 /* The channel to use for dynamic printf if the preferred style is to
323 call into the inferior; if a nonempty string, it will be passed to
324 the call as the first argument, with the format string as the
325 second. As with the dprintf function, this can be anything that
326 GDB knows how to evaluate, so in addition to common choices like
327 "stderr", this could be an app-specific expression like
328 "mystreams[curlogger]". */
330 static char *dprintf_channel
;
332 /* True if dprintf commands should continue to operate even if GDB
334 static int disconnected_dprintf
= 1;
336 struct command_line
*
337 breakpoint_commands (struct breakpoint
*b
)
339 return b
->commands
? b
->commands
.get () : NULL
;
342 /* Flag indicating that a command has proceeded the inferior past the
343 current breakpoint. */
345 static int breakpoint_proceeded
;
348 bpdisp_text (enum bpdisp disp
)
350 /* NOTE: the following values are a part of MI protocol and
351 represent values of 'disp' field returned when inferior stops at
353 static const char * const bpdisps
[] = {"del", "dstp", "dis", "keep"};
355 return bpdisps
[(int) disp
];
358 /* Prototypes for exported functions. */
359 /* If FALSE, gdb will not use hardware support for watchpoints, even
360 if such is available. */
361 static int can_use_hw_watchpoints
;
364 show_can_use_hw_watchpoints (struct ui_file
*file
, int from_tty
,
365 struct cmd_list_element
*c
,
368 fprintf_filtered (file
,
369 _("Debugger's willingness to use "
370 "watchpoint hardware is %s.\n"),
374 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
375 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
376 for unrecognized breakpoint locations.
377 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
378 static enum auto_boolean pending_break_support
;
380 show_pending_break_support (struct ui_file
*file
, int from_tty
,
381 struct cmd_list_element
*c
,
384 fprintf_filtered (file
,
385 _("Debugger's behavior regarding "
386 "pending breakpoints is %s.\n"),
390 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
391 set with "break" but falling in read-only memory.
392 If 0, gdb will warn about such breakpoints, but won't automatically
393 use hardware breakpoints. */
394 static int automatic_hardware_breakpoints
;
396 show_automatic_hardware_breakpoints (struct ui_file
*file
, int from_tty
,
397 struct cmd_list_element
*c
,
400 fprintf_filtered (file
,
401 _("Automatic usage of hardware breakpoints is %s.\n"),
405 /* If on, GDB keeps breakpoints inserted even if the inferior is
406 stopped, and immediately inserts any new breakpoints as soon as
407 they're created. If off (default), GDB keeps breakpoints off of
408 the target as long as possible. That is, it delays inserting
409 breakpoints until the next resume, and removes them again when the
410 target fully stops. This is a bit safer in case GDB crashes while
411 processing user input. */
412 static int always_inserted_mode
= 0;
415 show_always_inserted_mode (struct ui_file
*file
, int from_tty
,
416 struct cmd_list_element
*c
, const char *value
)
418 fprintf_filtered (file
, _("Always inserted breakpoint mode is %s.\n"),
422 /* See breakpoint.h. */
425 breakpoints_should_be_inserted_now (void)
427 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
429 /* If breakpoints are global, they should be inserted even if no
430 thread under gdb's control is running, or even if there are
431 no threads under GDB's control yet. */
434 else if (target_has_execution
)
436 struct thread_info
*tp
;
438 if (always_inserted_mode
)
440 /* The user wants breakpoints inserted even if all threads
445 if (threads_are_executing ())
448 /* Don't remove breakpoints yet if, even though all threads are
449 stopped, we still have events to process. */
450 ALL_NON_EXITED_THREADS (tp
)
452 && tp
->suspend
.waitstatus_pending_p
)
458 static const char condition_evaluation_both
[] = "host or target";
460 /* Modes for breakpoint condition evaluation. */
461 static const char condition_evaluation_auto
[] = "auto";
462 static const char condition_evaluation_host
[] = "host";
463 static const char condition_evaluation_target
[] = "target";
464 static const char *const condition_evaluation_enums
[] = {
465 condition_evaluation_auto
,
466 condition_evaluation_host
,
467 condition_evaluation_target
,
471 /* Global that holds the current mode for breakpoint condition evaluation. */
472 static const char *condition_evaluation_mode_1
= condition_evaluation_auto
;
474 /* Global that we use to display information to the user (gets its value from
475 condition_evaluation_mode_1. */
476 static const char *condition_evaluation_mode
= condition_evaluation_auto
;
478 /* Translate a condition evaluation mode MODE into either "host"
479 or "target". This is used mostly to translate from "auto" to the
480 real setting that is being used. It returns the translated
484 translate_condition_evaluation_mode (const char *mode
)
486 if (mode
== condition_evaluation_auto
)
488 if (target_supports_evaluation_of_breakpoint_conditions ())
489 return condition_evaluation_target
;
491 return condition_evaluation_host
;
497 /* Discovers what condition_evaluation_auto translates to. */
500 breakpoint_condition_evaluation_mode (void)
502 return translate_condition_evaluation_mode (condition_evaluation_mode
);
505 /* Return true if GDB should evaluate breakpoint conditions or false
509 gdb_evaluates_breakpoint_condition_p (void)
511 const char *mode
= breakpoint_condition_evaluation_mode ();
513 return (mode
== condition_evaluation_host
);
516 /* Are we executing breakpoint commands? */
517 static int executing_breakpoint_commands
;
519 /* Are overlay event breakpoints enabled? */
520 static int overlay_events_enabled
;
522 /* See description in breakpoint.h. */
523 int target_exact_watchpoints
= 0;
525 /* Walk the following statement or block through all breakpoints.
526 ALL_BREAKPOINTS_SAFE does so even if the statement deletes the
527 current breakpoint. */
529 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
531 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
532 for (B = breakpoint_chain; \
533 B ? (TMP=B->next, 1): 0; \
536 /* Similar iterator for the low-level breakpoints. SAFE variant is
537 not provided so update_global_location_list must not be called
538 while executing the block of ALL_BP_LOCATIONS. */
540 #define ALL_BP_LOCATIONS(B,BP_TMP) \
541 for (BP_TMP = bp_locations; \
542 BP_TMP < bp_locations + bp_locations_count && (B = *BP_TMP);\
545 /* Iterates through locations with address ADDRESS for the currently selected
546 program space. BP_LOCP_TMP points to each object. BP_LOCP_START points
547 to where the loop should start from.
548 If BP_LOCP_START is a NULL pointer, the macro automatically seeks the
549 appropriate location to start with. */
551 #define ALL_BP_LOCATIONS_AT_ADDR(BP_LOCP_TMP, BP_LOCP_START, ADDRESS) \
552 for (BP_LOCP_START = BP_LOCP_START == NULL ? get_first_locp_gte_addr (ADDRESS) : BP_LOCP_START, \
553 BP_LOCP_TMP = BP_LOCP_START; \
555 && (BP_LOCP_TMP < bp_locations + bp_locations_count \
556 && (*BP_LOCP_TMP)->address == ADDRESS); \
559 /* Iterator for tracepoints only. */
561 #define ALL_TRACEPOINTS(B) \
562 for (B = breakpoint_chain; B; B = B->next) \
563 if (is_tracepoint (B))
565 /* Chains of all breakpoints defined. */
567 struct breakpoint
*breakpoint_chain
;
569 /* Array is sorted by bp_locations_compare - primarily by the ADDRESS. */
571 static struct bp_location
**bp_locations
;
573 /* Number of elements of BP_LOCATIONS. */
575 static unsigned bp_locations_count
;
577 /* Maximum alignment offset between bp_target_info.PLACED_ADDRESS and
578 ADDRESS for the current elements of BP_LOCATIONS which get a valid
579 result from bp_location_has_shadow. You can use it for roughly
580 limiting the subrange of BP_LOCATIONS to scan for shadow bytes for
581 an address you need to read. */
583 static CORE_ADDR bp_locations_placed_address_before_address_max
;
585 /* Maximum offset plus alignment between bp_target_info.PLACED_ADDRESS
586 + bp_target_info.SHADOW_LEN and ADDRESS for the current elements of
587 BP_LOCATIONS which get a valid result from bp_location_has_shadow.
588 You can use it for roughly limiting the subrange of BP_LOCATIONS to
589 scan for shadow bytes for an address you need to read. */
591 static CORE_ADDR bp_locations_shadow_len_after_address_max
;
593 /* The locations that no longer correspond to any breakpoint, unlinked
594 from the bp_locations array, but for which a hit may still be
595 reported by a target. */
596 VEC(bp_location_p
) *moribund_locations
= NULL
;
598 /* Number of last breakpoint made. */
600 static int breakpoint_count
;
602 /* The value of `breakpoint_count' before the last command that
603 created breakpoints. If the last (break-like) command created more
604 than one breakpoint, then the difference between BREAKPOINT_COUNT
605 and PREV_BREAKPOINT_COUNT is more than one. */
606 static int prev_breakpoint_count
;
608 /* Number of last tracepoint made. */
610 static int tracepoint_count
;
612 static struct cmd_list_element
*breakpoint_set_cmdlist
;
613 static struct cmd_list_element
*breakpoint_show_cmdlist
;
614 struct cmd_list_element
*save_cmdlist
;
616 /* See declaration at breakpoint.h. */
619 breakpoint_find_if (int (*func
) (struct breakpoint
*b
, void *d
),
622 struct breakpoint
*b
= NULL
;
626 if (func (b
, user_data
) != 0)
633 /* Return whether a breakpoint is an active enabled breakpoint. */
635 breakpoint_enabled (struct breakpoint
*b
)
637 return (b
->enable_state
== bp_enabled
);
640 /* Set breakpoint count to NUM. */
643 set_breakpoint_count (int num
)
645 prev_breakpoint_count
= breakpoint_count
;
646 breakpoint_count
= num
;
647 set_internalvar_integer (lookup_internalvar ("bpnum"), num
);
650 /* Used by `start_rbreak_breakpoints' below, to record the current
651 breakpoint count before "rbreak" creates any breakpoint. */
652 static int rbreak_start_breakpoint_count
;
654 /* Called at the start an "rbreak" command to record the first
658 start_rbreak_breakpoints (void)
660 rbreak_start_breakpoint_count
= breakpoint_count
;
663 /* Called at the end of an "rbreak" command to record the last
667 end_rbreak_breakpoints (void)
669 prev_breakpoint_count
= rbreak_start_breakpoint_count
;
672 /* Used in run_command to zero the hit count when a new run starts. */
675 clear_breakpoint_hit_counts (void)
677 struct breakpoint
*b
;
684 /* Return the breakpoint with the specified number, or NULL
685 if the number does not refer to an existing breakpoint. */
688 get_breakpoint (int num
)
690 struct breakpoint
*b
;
693 if (b
->number
== num
)
701 /* Mark locations as "conditions have changed" in case the target supports
702 evaluating conditions on its side. */
705 mark_breakpoint_modified (struct breakpoint
*b
)
707 struct bp_location
*loc
;
709 /* This is only meaningful if the target is
710 evaluating conditions and if the user has
711 opted for condition evaluation on the target's
713 if (gdb_evaluates_breakpoint_condition_p ()
714 || !target_supports_evaluation_of_breakpoint_conditions ())
717 if (!is_breakpoint (b
))
720 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
721 loc
->condition_changed
= condition_modified
;
724 /* Mark location as "conditions have changed" in case the target supports
725 evaluating conditions on its side. */
728 mark_breakpoint_location_modified (struct bp_location
*loc
)
730 /* This is only meaningful if the target is
731 evaluating conditions and if the user has
732 opted for condition evaluation on the target's
734 if (gdb_evaluates_breakpoint_condition_p ()
735 || !target_supports_evaluation_of_breakpoint_conditions ())
739 if (!is_breakpoint (loc
->owner
))
742 loc
->condition_changed
= condition_modified
;
745 /* Sets the condition-evaluation mode using the static global
746 condition_evaluation_mode. */
749 set_condition_evaluation_mode (char *args
, int from_tty
,
750 struct cmd_list_element
*c
)
752 const char *old_mode
, *new_mode
;
754 if ((condition_evaluation_mode_1
== condition_evaluation_target
)
755 && !target_supports_evaluation_of_breakpoint_conditions ())
757 condition_evaluation_mode_1
= condition_evaluation_mode
;
758 warning (_("Target does not support breakpoint condition evaluation.\n"
759 "Using host evaluation mode instead."));
763 new_mode
= translate_condition_evaluation_mode (condition_evaluation_mode_1
);
764 old_mode
= translate_condition_evaluation_mode (condition_evaluation_mode
);
766 /* Flip the switch. Flip it even if OLD_MODE == NEW_MODE as one of the
767 settings was "auto". */
768 condition_evaluation_mode
= condition_evaluation_mode_1
;
770 /* Only update the mode if the user picked a different one. */
771 if (new_mode
!= old_mode
)
773 struct bp_location
*loc
, **loc_tmp
;
774 /* If the user switched to a different evaluation mode, we
775 need to synch the changes with the target as follows:
777 "host" -> "target": Send all (valid) conditions to the target.
778 "target" -> "host": Remove all the conditions from the target.
781 if (new_mode
== condition_evaluation_target
)
783 /* Mark everything modified and synch conditions with the
785 ALL_BP_LOCATIONS (loc
, loc_tmp
)
786 mark_breakpoint_location_modified (loc
);
790 /* Manually mark non-duplicate locations to synch conditions
791 with the target. We do this to remove all the conditions the
792 target knows about. */
793 ALL_BP_LOCATIONS (loc
, loc_tmp
)
794 if (is_breakpoint (loc
->owner
) && loc
->inserted
)
795 loc
->needs_update
= 1;
799 update_global_location_list (UGLL_MAY_INSERT
);
805 /* Shows the current mode of breakpoint condition evaluation. Explicitly shows
806 what "auto" is translating to. */
809 show_condition_evaluation_mode (struct ui_file
*file
, int from_tty
,
810 struct cmd_list_element
*c
, const char *value
)
812 if (condition_evaluation_mode
== condition_evaluation_auto
)
813 fprintf_filtered (file
,
814 _("Breakpoint condition evaluation "
815 "mode is %s (currently %s).\n"),
817 breakpoint_condition_evaluation_mode ());
819 fprintf_filtered (file
, _("Breakpoint condition evaluation mode is %s.\n"),
823 /* A comparison function for bp_location AP and BP that is used by
824 bsearch. This comparison function only cares about addresses, unlike
825 the more general bp_locations_compare function. */
828 bp_locations_compare_addrs (const void *ap
, const void *bp
)
830 const struct bp_location
*a
= *(const struct bp_location
**) ap
;
831 const struct bp_location
*b
= *(const struct bp_location
**) bp
;
833 if (a
->address
== b
->address
)
836 return ((a
->address
> b
->address
) - (a
->address
< b
->address
));
839 /* Helper function to skip all bp_locations with addresses
840 less than ADDRESS. It returns the first bp_location that
841 is greater than or equal to ADDRESS. If none is found, just
844 static struct bp_location
**
845 get_first_locp_gte_addr (CORE_ADDR address
)
847 struct bp_location dummy_loc
;
848 struct bp_location
*dummy_locp
= &dummy_loc
;
849 struct bp_location
**locp_found
= NULL
;
851 /* Initialize the dummy location's address field. */
852 dummy_loc
.address
= address
;
854 /* Find a close match to the first location at ADDRESS. */
855 locp_found
= ((struct bp_location
**)
856 bsearch (&dummy_locp
, bp_locations
, bp_locations_count
,
857 sizeof (struct bp_location
**),
858 bp_locations_compare_addrs
));
860 /* Nothing was found, nothing left to do. */
861 if (locp_found
== NULL
)
864 /* We may have found a location that is at ADDRESS but is not the first in the
865 location's list. Go backwards (if possible) and locate the first one. */
866 while ((locp_found
- 1) >= bp_locations
867 && (*(locp_found
- 1))->address
== address
)
874 set_breakpoint_condition (struct breakpoint
*b
, const char *exp
,
877 xfree (b
->cond_string
);
878 b
->cond_string
= NULL
;
880 if (is_watchpoint (b
))
882 struct watchpoint
*w
= (struct watchpoint
*) b
;
884 w
->cond_exp
.reset ();
888 struct bp_location
*loc
;
890 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
894 /* No need to free the condition agent expression
895 bytecode (if we have one). We will handle this
896 when we go through update_global_location_list. */
903 printf_filtered (_("Breakpoint %d now unconditional.\n"), b
->number
);
907 const char *arg
= exp
;
909 /* I don't know if it matters whether this is the string the user
910 typed in or the decompiled expression. */
911 b
->cond_string
= xstrdup (arg
);
912 b
->condition_not_parsed
= 0;
914 if (is_watchpoint (b
))
916 struct watchpoint
*w
= (struct watchpoint
*) b
;
918 innermost_block
= NULL
;
920 w
->cond_exp
= parse_exp_1 (&arg
, 0, 0, 0);
922 error (_("Junk at end of expression"));
923 w
->cond_exp_valid_block
= innermost_block
;
927 struct bp_location
*loc
;
929 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
933 parse_exp_1 (&arg
, loc
->address
,
934 block_for_pc (loc
->address
), 0);
936 error (_("Junk at end of expression"));
940 mark_breakpoint_modified (b
);
942 observer_notify_breakpoint_modified (b
);
945 /* Completion for the "condition" command. */
948 condition_completer (struct cmd_list_element
*cmd
,
949 completion_tracker
&tracker
,
950 const char *text
, const char *word
)
954 text
= skip_spaces (text
);
955 space
= skip_to_space (text
);
959 struct breakpoint
*b
;
960 VEC (char_ptr
) *result
= NULL
;
964 /* We don't support completion of history indices. */
965 if (!isdigit (text
[1]))
966 complete_internalvar (tracker
, &text
[1]);
970 /* We're completing the breakpoint number. */
977 xsnprintf (number
, sizeof (number
), "%d", b
->number
);
979 if (strncmp (number
, text
, len
) == 0)
981 gdb::unique_xmalloc_ptr
<char> copy (xstrdup (number
));
982 tracker
.add_completion (std::move (copy
));
989 /* We're completing the expression part. */
990 text
= skip_spaces (space
);
991 expression_completer (cmd
, tracker
, text
, word
);
994 /* condition N EXP -- set break condition of breakpoint N to EXP. */
997 condition_command (char *arg
, int from_tty
)
999 struct breakpoint
*b
;
1004 error_no_arg (_("breakpoint number"));
1007 bnum
= get_number (&p
);
1009 error (_("Bad breakpoint argument: '%s'"), arg
);
1012 if (b
->number
== bnum
)
1014 /* Check if this breakpoint has a "stop" method implemented in an
1015 extension language. This method and conditions entered into GDB
1016 from the CLI are mutually exclusive. */
1017 const struct extension_language_defn
*extlang
1018 = get_breakpoint_cond_ext_lang (b
, EXT_LANG_NONE
);
1020 if (extlang
!= NULL
)
1022 error (_("Only one stop condition allowed. There is currently"
1023 " a %s stop condition defined for this breakpoint."),
1024 ext_lang_capitalized_name (extlang
));
1026 set_breakpoint_condition (b
, p
, from_tty
);
1028 if (is_breakpoint (b
))
1029 update_global_location_list (UGLL_MAY_INSERT
);
1034 error (_("No breakpoint number %d."), bnum
);
1037 /* Check that COMMAND do not contain commands that are suitable
1038 only for tracepoints and not suitable for ordinary breakpoints.
1039 Throw if any such commands is found. */
1042 check_no_tracepoint_commands (struct command_line
*commands
)
1044 struct command_line
*c
;
1046 for (c
= commands
; c
; c
= c
->next
)
1050 if (c
->control_type
== while_stepping_control
)
1051 error (_("The 'while-stepping' command can "
1052 "only be used for tracepoints"));
1054 for (i
= 0; i
< c
->body_count
; ++i
)
1055 check_no_tracepoint_commands ((c
->body_list
)[i
]);
1057 /* Not that command parsing removes leading whitespace and comment
1058 lines and also empty lines. So, we only need to check for
1059 command directly. */
1060 if (strstr (c
->line
, "collect ") == c
->line
)
1061 error (_("The 'collect' command can only be used for tracepoints"));
1063 if (strstr (c
->line
, "teval ") == c
->line
)
1064 error (_("The 'teval' command can only be used for tracepoints"));
1068 struct longjmp_breakpoint
: public breakpoint
1070 ~longjmp_breakpoint () override
;
1073 /* Encapsulate tests for different types of tracepoints. */
1076 is_tracepoint_type (bptype type
)
1078 return (type
== bp_tracepoint
1079 || type
== bp_fast_tracepoint
1080 || type
== bp_static_tracepoint
);
1084 is_longjmp_type (bptype type
)
1086 return type
== bp_longjmp
|| type
== bp_exception
;
1090 is_tracepoint (const struct breakpoint
*b
)
1092 return is_tracepoint_type (b
->type
);
1095 /* Factory function to create an appropriate instance of breakpoint given
1098 static std::unique_ptr
<breakpoint
>
1099 new_breakpoint_from_type (bptype type
)
1103 if (is_tracepoint_type (type
))
1104 b
= new tracepoint ();
1105 else if (is_longjmp_type (type
))
1106 b
= new longjmp_breakpoint ();
1108 b
= new breakpoint ();
1110 return std::unique_ptr
<breakpoint
> (b
);
1113 /* A helper function that validates that COMMANDS are valid for a
1114 breakpoint. This function will throw an exception if a problem is
1118 validate_commands_for_breakpoint (struct breakpoint
*b
,
1119 struct command_line
*commands
)
1121 if (is_tracepoint (b
))
1123 struct tracepoint
*t
= (struct tracepoint
*) b
;
1124 struct command_line
*c
;
1125 struct command_line
*while_stepping
= 0;
1127 /* Reset the while-stepping step count. The previous commands
1128 might have included a while-stepping action, while the new
1132 /* We need to verify that each top-level element of commands is
1133 valid for tracepoints, that there's at most one
1134 while-stepping element, and that the while-stepping's body
1135 has valid tracing commands excluding nested while-stepping.
1136 We also need to validate the tracepoint action line in the
1137 context of the tracepoint --- validate_actionline actually
1138 has side effects, like setting the tracepoint's
1139 while-stepping STEP_COUNT, in addition to checking if the
1140 collect/teval actions parse and make sense in the
1141 tracepoint's context. */
1142 for (c
= commands
; c
; c
= c
->next
)
1144 if (c
->control_type
== while_stepping_control
)
1146 if (b
->type
== bp_fast_tracepoint
)
1147 error (_("The 'while-stepping' command "
1148 "cannot be used for fast tracepoint"));
1149 else if (b
->type
== bp_static_tracepoint
)
1150 error (_("The 'while-stepping' command "
1151 "cannot be used for static tracepoint"));
1154 error (_("The 'while-stepping' command "
1155 "can be used only once"));
1160 validate_actionline (c
->line
, b
);
1164 struct command_line
*c2
;
1166 gdb_assert (while_stepping
->body_count
== 1);
1167 c2
= while_stepping
->body_list
[0];
1168 for (; c2
; c2
= c2
->next
)
1170 if (c2
->control_type
== while_stepping_control
)
1171 error (_("The 'while-stepping' command cannot be nested"));
1177 check_no_tracepoint_commands (commands
);
1181 /* Return a vector of all the static tracepoints set at ADDR. The
1182 caller is responsible for releasing the vector. */
1185 static_tracepoints_here (CORE_ADDR addr
)
1187 struct breakpoint
*b
;
1188 VEC(breakpoint_p
) *found
= 0;
1189 struct bp_location
*loc
;
1192 if (b
->type
== bp_static_tracepoint
)
1194 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1195 if (loc
->address
== addr
)
1196 VEC_safe_push(breakpoint_p
, found
, b
);
1202 /* Set the command list of B to COMMANDS. If breakpoint is tracepoint,
1203 validate that only allowed commands are included. */
1206 breakpoint_set_commands (struct breakpoint
*b
,
1207 command_line_up
&&commands
)
1209 validate_commands_for_breakpoint (b
, commands
.get ());
1211 b
->commands
= std::move (commands
);
1212 observer_notify_breakpoint_modified (b
);
1215 /* Set the internal `silent' flag on the breakpoint. Note that this
1216 is not the same as the "silent" that may appear in the breakpoint's
1220 breakpoint_set_silent (struct breakpoint
*b
, int silent
)
1222 int old_silent
= b
->silent
;
1225 if (old_silent
!= silent
)
1226 observer_notify_breakpoint_modified (b
);
1229 /* Set the thread for this breakpoint. If THREAD is -1, make the
1230 breakpoint work for any thread. */
1233 breakpoint_set_thread (struct breakpoint
*b
, int thread
)
1235 int old_thread
= b
->thread
;
1238 if (old_thread
!= thread
)
1239 observer_notify_breakpoint_modified (b
);
1242 /* Set the task for this breakpoint. If TASK is 0, make the
1243 breakpoint work for any task. */
1246 breakpoint_set_task (struct breakpoint
*b
, int task
)
1248 int old_task
= b
->task
;
1251 if (old_task
!= task
)
1252 observer_notify_breakpoint_modified (b
);
1256 check_tracepoint_command (char *line
, void *closure
)
1258 struct breakpoint
*b
= (struct breakpoint
*) closure
;
1260 validate_actionline (line
, b
);
1264 commands_command_1 (const char *arg
, int from_tty
,
1265 struct command_line
*control
)
1267 counted_command_line cmd
;
1269 std::string new_arg
;
1271 if (arg
== NULL
|| !*arg
)
1273 if (breakpoint_count
- prev_breakpoint_count
> 1)
1274 new_arg
= string_printf ("%d-%d", prev_breakpoint_count
+ 1,
1276 else if (breakpoint_count
> 0)
1277 new_arg
= string_printf ("%d", breakpoint_count
);
1278 arg
= new_arg
.c_str ();
1281 map_breakpoint_numbers
1282 (arg
, [&] (breakpoint
*b
)
1286 if (control
!= NULL
)
1287 cmd
= copy_command_lines (control
->body_list
[0]);
1290 struct cleanup
*old_chain
;
1293 str
= xstrprintf (_("Type commands for breakpoint(s) "
1294 "%s, one per line."),
1297 old_chain
= make_cleanup (xfree
, str
);
1299 cmd
= read_command_lines (str
,
1302 ? check_tracepoint_command
: 0),
1305 do_cleanups (old_chain
);
1309 /* If a breakpoint was on the list more than once, we don't need to
1311 if (b
->commands
!= cmd
)
1313 validate_commands_for_breakpoint (b
, cmd
.get ());
1315 observer_notify_breakpoint_modified (b
);
1320 error (_("No breakpoints specified."));
1324 commands_command (char *arg
, int from_tty
)
1326 commands_command_1 (arg
, from_tty
, NULL
);
1329 /* Like commands_command, but instead of reading the commands from
1330 input stream, takes them from an already parsed command structure.
1332 This is used by cli-script.c to DTRT with breakpoint commands
1333 that are part of if and while bodies. */
1334 enum command_control_type
1335 commands_from_control_command (const char *arg
, struct command_line
*cmd
)
1337 commands_command_1 (arg
, 0, cmd
);
1338 return simple_control
;
1341 /* Return non-zero if BL->TARGET_INFO contains valid information. */
1344 bp_location_has_shadow (struct bp_location
*bl
)
1346 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
1350 if (bl
->target_info
.shadow_len
== 0)
1351 /* BL isn't valid, or doesn't shadow memory. */
1356 /* Update BUF, which is LEN bytes read from the target address
1357 MEMADDR, by replacing a memory breakpoint with its shadowed
1360 If READBUF is not NULL, this buffer must not overlap with the of
1361 the breakpoint location's shadow_contents buffer. Otherwise, a
1362 failed assertion internal error will be raised. */
1365 one_breakpoint_xfer_memory (gdb_byte
*readbuf
, gdb_byte
*writebuf
,
1366 const gdb_byte
*writebuf_org
,
1367 ULONGEST memaddr
, LONGEST len
,
1368 struct bp_target_info
*target_info
,
1369 struct gdbarch
*gdbarch
)
1371 /* Now do full processing of the found relevant range of elements. */
1372 CORE_ADDR bp_addr
= 0;
1376 if (!breakpoint_address_match (target_info
->placed_address_space
, 0,
1377 current_program_space
->aspace
, 0))
1379 /* The breakpoint is inserted in a different address space. */
1383 /* Addresses and length of the part of the breakpoint that
1385 bp_addr
= target_info
->placed_address
;
1386 bp_size
= target_info
->shadow_len
;
1388 if (bp_addr
+ bp_size
<= memaddr
)
1390 /* The breakpoint is entirely before the chunk of memory we are
1395 if (bp_addr
>= memaddr
+ len
)
1397 /* The breakpoint is entirely after the chunk of memory we are
1402 /* Offset within shadow_contents. */
1403 if (bp_addr
< memaddr
)
1405 /* Only copy the second part of the breakpoint. */
1406 bp_size
-= memaddr
- bp_addr
;
1407 bptoffset
= memaddr
- bp_addr
;
1411 if (bp_addr
+ bp_size
> memaddr
+ len
)
1413 /* Only copy the first part of the breakpoint. */
1414 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
1417 if (readbuf
!= NULL
)
1419 /* Verify that the readbuf buffer does not overlap with the
1420 shadow_contents buffer. */
1421 gdb_assert (target_info
->shadow_contents
>= readbuf
+ len
1422 || readbuf
>= (target_info
->shadow_contents
1423 + target_info
->shadow_len
));
1425 /* Update the read buffer with this inserted breakpoint's
1427 memcpy (readbuf
+ bp_addr
- memaddr
,
1428 target_info
->shadow_contents
+ bptoffset
, bp_size
);
1432 const unsigned char *bp
;
1433 CORE_ADDR addr
= target_info
->reqstd_address
;
1436 /* Update the shadow with what we want to write to memory. */
1437 memcpy (target_info
->shadow_contents
+ bptoffset
,
1438 writebuf_org
+ bp_addr
- memaddr
, bp_size
);
1440 /* Determine appropriate breakpoint contents and size for this
1442 bp
= gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &placed_size
);
1444 /* Update the final write buffer with this inserted
1445 breakpoint's INSN. */
1446 memcpy (writebuf
+ bp_addr
- memaddr
, bp
+ bptoffset
, bp_size
);
1450 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
1451 by replacing any memory breakpoints with their shadowed contents.
1453 If READBUF is not NULL, this buffer must not overlap with any of
1454 the breakpoint location's shadow_contents buffers. Otherwise,
1455 a failed assertion internal error will be raised.
1457 The range of shadowed area by each bp_location is:
1458 bl->address - bp_locations_placed_address_before_address_max
1459 up to bl->address + bp_locations_shadow_len_after_address_max
1460 The range we were requested to resolve shadows for is:
1461 memaddr ... memaddr + len
1462 Thus the safe cutoff boundaries for performance optimization are
1463 memaddr + len <= (bl->address
1464 - bp_locations_placed_address_before_address_max)
1466 bl->address + bp_locations_shadow_len_after_address_max <= memaddr */
1469 breakpoint_xfer_memory (gdb_byte
*readbuf
, gdb_byte
*writebuf
,
1470 const gdb_byte
*writebuf_org
,
1471 ULONGEST memaddr
, LONGEST len
)
1473 /* Left boundary, right boundary and median element of our binary
1475 unsigned bc_l
, bc_r
, bc
;
1477 /* Find BC_L which is a leftmost element which may affect BUF
1478 content. It is safe to report lower value but a failure to
1479 report higher one. */
1482 bc_r
= bp_locations_count
;
1483 while (bc_l
+ 1 < bc_r
)
1485 struct bp_location
*bl
;
1487 bc
= (bc_l
+ bc_r
) / 2;
1488 bl
= bp_locations
[bc
];
1490 /* Check first BL->ADDRESS will not overflow due to the added
1491 constant. Then advance the left boundary only if we are sure
1492 the BC element can in no way affect the BUF content (MEMADDR
1493 to MEMADDR + LEN range).
1495 Use the BP_LOCATIONS_SHADOW_LEN_AFTER_ADDRESS_MAX safety
1496 offset so that we cannot miss a breakpoint with its shadow
1497 range tail still reaching MEMADDR. */
1499 if ((bl
->address
+ bp_locations_shadow_len_after_address_max
1501 && (bl
->address
+ bp_locations_shadow_len_after_address_max
1508 /* Due to the binary search above, we need to make sure we pick the
1509 first location that's at BC_L's address. E.g., if there are
1510 multiple locations at the same address, BC_L may end up pointing
1511 at a duplicate location, and miss the "master"/"inserted"
1512 location. Say, given locations L1, L2 and L3 at addresses A and
1515 L1@A, L2@A, L3@B, ...
1517 BC_L could end up pointing at location L2, while the "master"
1518 location could be L1. Since the `loc->inserted' flag is only set
1519 on "master" locations, we'd forget to restore the shadow of L1
1522 && bp_locations
[bc_l
]->address
== bp_locations
[bc_l
- 1]->address
)
1525 /* Now do full processing of the found relevant range of elements. */
1527 for (bc
= bc_l
; bc
< bp_locations_count
; bc
++)
1529 struct bp_location
*bl
= bp_locations
[bc
];
1531 /* bp_location array has BL->OWNER always non-NULL. */
1532 if (bl
->owner
->type
== bp_none
)
1533 warning (_("reading through apparently deleted breakpoint #%d?"),
1536 /* Performance optimization: any further element can no longer affect BUF
1539 if (bl
->address
>= bp_locations_placed_address_before_address_max
1540 && memaddr
+ len
<= (bl
->address
1541 - bp_locations_placed_address_before_address_max
))
1544 if (!bp_location_has_shadow (bl
))
1547 one_breakpoint_xfer_memory (readbuf
, writebuf
, writebuf_org
,
1548 memaddr
, len
, &bl
->target_info
, bl
->gdbarch
);
1554 /* Return true if BPT is either a software breakpoint or a hardware
1558 is_breakpoint (const struct breakpoint
*bpt
)
1560 return (bpt
->type
== bp_breakpoint
1561 || bpt
->type
== bp_hardware_breakpoint
1562 || bpt
->type
== bp_dprintf
);
1565 /* Return true if BPT is of any hardware watchpoint kind. */
1568 is_hardware_watchpoint (const struct breakpoint
*bpt
)
1570 return (bpt
->type
== bp_hardware_watchpoint
1571 || bpt
->type
== bp_read_watchpoint
1572 || bpt
->type
== bp_access_watchpoint
);
1575 /* Return true if BPT is of any watchpoint kind, hardware or
1579 is_watchpoint (const struct breakpoint
*bpt
)
1581 return (is_hardware_watchpoint (bpt
)
1582 || bpt
->type
== bp_watchpoint
);
1585 /* Returns true if the current thread and its running state are safe
1586 to evaluate or update watchpoint B. Watchpoints on local
1587 expressions need to be evaluated in the context of the thread that
1588 was current when the watchpoint was created, and, that thread needs
1589 to be stopped to be able to select the correct frame context.
1590 Watchpoints on global expressions can be evaluated on any thread,
1591 and in any state. It is presently left to the target allowing
1592 memory accesses when threads are running. */
1595 watchpoint_in_thread_scope (struct watchpoint
*b
)
1597 return (b
->pspace
== current_program_space
1598 && (ptid_equal (b
->watchpoint_thread
, null_ptid
)
1599 || (ptid_equal (inferior_ptid
, b
->watchpoint_thread
)
1600 && !is_executing (inferior_ptid
))));
1603 /* Set watchpoint B to disp_del_at_next_stop, even including its possible
1604 associated bp_watchpoint_scope breakpoint. */
1607 watchpoint_del_at_next_stop (struct watchpoint
*w
)
1609 if (w
->related_breakpoint
!= w
)
1611 gdb_assert (w
->related_breakpoint
->type
== bp_watchpoint_scope
);
1612 gdb_assert (w
->related_breakpoint
->related_breakpoint
== w
);
1613 w
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
1614 w
->related_breakpoint
->related_breakpoint
= w
->related_breakpoint
;
1615 w
->related_breakpoint
= w
;
1617 w
->disposition
= disp_del_at_next_stop
;
1620 /* Extract a bitfield value from value VAL using the bit parameters contained in
1623 static struct value
*
1624 extract_bitfield_from_watchpoint_value (struct watchpoint
*w
, struct value
*val
)
1626 struct value
*bit_val
;
1631 bit_val
= allocate_value (value_type (val
));
1633 unpack_value_bitfield (bit_val
,
1636 value_contents_for_printing (val
),
1643 /* Allocate a dummy location and add it to B, which must be a software
1644 watchpoint. This is required because even if a software watchpoint
1645 is not watching any memory, bpstat_stop_status requires a location
1646 to be able to report stops. */
1649 software_watchpoint_add_no_memory_location (struct breakpoint
*b
,
1650 struct program_space
*pspace
)
1652 gdb_assert (b
->type
== bp_watchpoint
&& b
->loc
== NULL
);
1654 b
->loc
= allocate_bp_location (b
);
1655 b
->loc
->pspace
= pspace
;
1656 b
->loc
->address
= -1;
1657 b
->loc
->length
= -1;
1660 /* Returns true if B is a software watchpoint that is not watching any
1661 memory (e.g., "watch $pc"). */
1664 is_no_memory_software_watchpoint (struct breakpoint
*b
)
1666 return (b
->type
== bp_watchpoint
1668 && b
->loc
->next
== NULL
1669 && b
->loc
->address
== -1
1670 && b
->loc
->length
== -1);
1673 /* Assuming that B is a watchpoint:
1674 - Reparse watchpoint expression, if REPARSE is non-zero
1675 - Evaluate expression and store the result in B->val
1676 - Evaluate the condition if there is one, and store the result
1678 - Update the list of values that must be watched in B->loc.
1680 If the watchpoint disposition is disp_del_at_next_stop, then do
1681 nothing. If this is local watchpoint that is out of scope, delete
1684 Even with `set breakpoint always-inserted on' the watchpoints are
1685 removed + inserted on each stop here. Normal breakpoints must
1686 never be removed because they might be missed by a running thread
1687 when debugging in non-stop mode. On the other hand, hardware
1688 watchpoints (is_hardware_watchpoint; processed here) are specific
1689 to each LWP since they are stored in each LWP's hardware debug
1690 registers. Therefore, such LWP must be stopped first in order to
1691 be able to modify its hardware watchpoints.
1693 Hardware watchpoints must be reset exactly once after being
1694 presented to the user. It cannot be done sooner, because it would
1695 reset the data used to present the watchpoint hit to the user. And
1696 it must not be done later because it could display the same single
1697 watchpoint hit during multiple GDB stops. Note that the latter is
1698 relevant only to the hardware watchpoint types bp_read_watchpoint
1699 and bp_access_watchpoint. False hit by bp_hardware_watchpoint is
1700 not user-visible - its hit is suppressed if the memory content has
1703 The following constraints influence the location where we can reset
1704 hardware watchpoints:
1706 * target_stopped_by_watchpoint and target_stopped_data_address are
1707 called several times when GDB stops.
1710 * Multiple hardware watchpoints can be hit at the same time,
1711 causing GDB to stop. GDB only presents one hardware watchpoint
1712 hit at a time as the reason for stopping, and all the other hits
1713 are presented later, one after the other, each time the user
1714 requests the execution to be resumed. Execution is not resumed
1715 for the threads still having pending hit event stored in
1716 LWP_INFO->STATUS. While the watchpoint is already removed from
1717 the inferior on the first stop the thread hit event is kept being
1718 reported from its cached value by linux_nat_stopped_data_address
1719 until the real thread resume happens after the watchpoint gets
1720 presented and thus its LWP_INFO->STATUS gets reset.
1722 Therefore the hardware watchpoint hit can get safely reset on the
1723 watchpoint removal from inferior. */
1726 update_watchpoint (struct watchpoint
*b
, int reparse
)
1728 int within_current_scope
;
1729 struct frame_id saved_frame_id
;
1732 /* If this is a local watchpoint, we only want to check if the
1733 watchpoint frame is in scope if the current thread is the thread
1734 that was used to create the watchpoint. */
1735 if (!watchpoint_in_thread_scope (b
))
1738 if (b
->disposition
== disp_del_at_next_stop
)
1743 /* Determine if the watchpoint is within scope. */
1744 if (b
->exp_valid_block
== NULL
)
1745 within_current_scope
= 1;
1748 struct frame_info
*fi
= get_current_frame ();
1749 struct gdbarch
*frame_arch
= get_frame_arch (fi
);
1750 CORE_ADDR frame_pc
= get_frame_pc (fi
);
1752 /* If we're at a point where the stack has been destroyed
1753 (e.g. in a function epilogue), unwinding may not work
1754 properly. Do not attempt to recreate locations at this
1755 point. See similar comments in watchpoint_check. */
1756 if (gdbarch_stack_frame_destroyed_p (frame_arch
, frame_pc
))
1759 /* Save the current frame's ID so we can restore it after
1760 evaluating the watchpoint expression on its own frame. */
1761 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
1762 took a frame parameter, so that we didn't have to change the
1765 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
1767 fi
= frame_find_by_id (b
->watchpoint_frame
);
1768 within_current_scope
= (fi
!= NULL
);
1769 if (within_current_scope
)
1773 /* We don't free locations. They are stored in the bp_location array
1774 and update_global_location_list will eventually delete them and
1775 remove breakpoints if needed. */
1778 if (within_current_scope
&& reparse
)
1783 s
= b
->exp_string_reparse
? b
->exp_string_reparse
: b
->exp_string
;
1784 b
->exp
= parse_exp_1 (&s
, 0, b
->exp_valid_block
, 0);
1785 /* If the meaning of expression itself changed, the old value is
1786 no longer relevant. We don't want to report a watchpoint hit
1787 to the user when the old value and the new value may actually
1788 be completely different objects. */
1789 value_free (b
->val
);
1793 /* Note that unlike with breakpoints, the watchpoint's condition
1794 expression is stored in the breakpoint object, not in the
1795 locations (re)created below. */
1796 if (b
->cond_string
!= NULL
)
1798 b
->cond_exp
.reset ();
1801 b
->cond_exp
= parse_exp_1 (&s
, 0, b
->cond_exp_valid_block
, 0);
1805 /* If we failed to parse the expression, for example because
1806 it refers to a global variable in a not-yet-loaded shared library,
1807 don't try to insert watchpoint. We don't automatically delete
1808 such watchpoint, though, since failure to parse expression
1809 is different from out-of-scope watchpoint. */
1810 if (!target_has_execution
)
1812 /* Without execution, memory can't change. No use to try and
1813 set watchpoint locations. The watchpoint will be reset when
1814 the target gains execution, through breakpoint_re_set. */
1815 if (!can_use_hw_watchpoints
)
1817 if (b
->ops
->works_in_software_mode (b
))
1818 b
->type
= bp_watchpoint
;
1820 error (_("Can't set read/access watchpoint when "
1821 "hardware watchpoints are disabled."));
1824 else if (within_current_scope
&& b
->exp
)
1827 struct value
*val_chain
, *v
, *result
, *next
;
1828 struct program_space
*frame_pspace
;
1830 fetch_subexp_value (b
->exp
.get (), &pc
, &v
, &result
, &val_chain
, 0);
1832 /* Avoid setting b->val if it's already set. The meaning of
1833 b->val is 'the last value' user saw, and we should update
1834 it only if we reported that last value to user. As it
1835 happens, the code that reports it updates b->val directly.
1836 We don't keep track of the memory value for masked
1838 if (!b
->val_valid
&& !is_masked_watchpoint (b
))
1840 if (b
->val_bitsize
!= 0)
1842 v
= extract_bitfield_from_watchpoint_value (b
, v
);
1850 frame_pspace
= get_frame_program_space (get_selected_frame (NULL
));
1852 /* Look at each value on the value chain. */
1853 for (v
= val_chain
; v
; v
= value_next (v
))
1855 /* If it's a memory location, and GDB actually needed
1856 its contents to evaluate the expression, then we
1857 must watch it. If the first value returned is
1858 still lazy, that means an error occurred reading it;
1859 watch it anyway in case it becomes readable. */
1860 if (VALUE_LVAL (v
) == lval_memory
1861 && (v
== val_chain
|| ! value_lazy (v
)))
1863 struct type
*vtype
= check_typedef (value_type (v
));
1865 /* We only watch structs and arrays if user asked
1866 for it explicitly, never if they just happen to
1867 appear in the middle of some value chain. */
1869 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
1870 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
1873 enum target_hw_bp_type type
;
1874 struct bp_location
*loc
, **tmp
;
1875 int bitpos
= 0, bitsize
= 0;
1877 if (value_bitsize (v
) != 0)
1879 /* Extract the bit parameters out from the bitfield
1881 bitpos
= value_bitpos (v
);
1882 bitsize
= value_bitsize (v
);
1884 else if (v
== result
&& b
->val_bitsize
!= 0)
1886 /* If VAL_BITSIZE != 0 then RESULT is actually a bitfield
1887 lvalue whose bit parameters are saved in the fields
1888 VAL_BITPOS and VAL_BITSIZE. */
1889 bitpos
= b
->val_bitpos
;
1890 bitsize
= b
->val_bitsize
;
1893 addr
= value_address (v
);
1896 /* Skip the bytes that don't contain the bitfield. */
1901 if (b
->type
== bp_read_watchpoint
)
1903 else if (b
->type
== bp_access_watchpoint
)
1906 loc
= allocate_bp_location (b
);
1907 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
1910 loc
->gdbarch
= get_type_arch (value_type (v
));
1912 loc
->pspace
= frame_pspace
;
1913 loc
->address
= addr
;
1917 /* Just cover the bytes that make up the bitfield. */
1918 loc
->length
= ((bitpos
% 8) + bitsize
+ 7) / 8;
1921 loc
->length
= TYPE_LENGTH (value_type (v
));
1923 loc
->watchpoint_type
= type
;
1928 /* Change the type of breakpoint between hardware assisted or
1929 an ordinary watchpoint depending on the hardware support
1930 and free hardware slots. REPARSE is set when the inferior
1935 enum bp_loc_type loc_type
;
1936 struct bp_location
*bl
;
1938 reg_cnt
= can_use_hardware_watchpoint (val_chain
);
1942 int i
, target_resources_ok
, other_type_used
;
1945 /* Use an exact watchpoint when there's only one memory region to be
1946 watched, and only one debug register is needed to watch it. */
1947 b
->exact
= target_exact_watchpoints
&& reg_cnt
== 1;
1949 /* We need to determine how many resources are already
1950 used for all other hardware watchpoints plus this one
1951 to see if we still have enough resources to also fit
1952 this watchpoint in as well. */
1954 /* If this is a software watchpoint, we try to turn it
1955 to a hardware one -- count resources as if B was of
1956 hardware watchpoint type. */
1958 if (type
== bp_watchpoint
)
1959 type
= bp_hardware_watchpoint
;
1961 /* This watchpoint may or may not have been placed on
1962 the list yet at this point (it won't be in the list
1963 if we're trying to create it for the first time,
1964 through watch_command), so always account for it
1967 /* Count resources used by all watchpoints except B. */
1968 i
= hw_watchpoint_used_count_others (b
, type
, &other_type_used
);
1970 /* Add in the resources needed for B. */
1971 i
+= hw_watchpoint_use_count (b
);
1974 = target_can_use_hardware_watchpoint (type
, i
, other_type_used
);
1975 if (target_resources_ok
<= 0)
1977 int sw_mode
= b
->ops
->works_in_software_mode (b
);
1979 if (target_resources_ok
== 0 && !sw_mode
)
1980 error (_("Target does not support this type of "
1981 "hardware watchpoint."));
1982 else if (target_resources_ok
< 0 && !sw_mode
)
1983 error (_("There are not enough available hardware "
1984 "resources for this watchpoint."));
1986 /* Downgrade to software watchpoint. */
1987 b
->type
= bp_watchpoint
;
1991 /* If this was a software watchpoint, we've just
1992 found we have enough resources to turn it to a
1993 hardware watchpoint. Otherwise, this is a
1998 else if (!b
->ops
->works_in_software_mode (b
))
2000 if (!can_use_hw_watchpoints
)
2001 error (_("Can't set read/access watchpoint when "
2002 "hardware watchpoints are disabled."));
2004 error (_("Expression cannot be implemented with "
2005 "read/access watchpoint."));
2008 b
->type
= bp_watchpoint
;
2010 loc_type
= (b
->type
== bp_watchpoint
? bp_loc_other
2011 : bp_loc_hardware_watchpoint
);
2012 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
2013 bl
->loc_type
= loc_type
;
2016 for (v
= val_chain
; v
; v
= next
)
2018 next
= value_next (v
);
2023 /* If a software watchpoint is not watching any memory, then the
2024 above left it without any location set up. But,
2025 bpstat_stop_status requires a location to be able to report
2026 stops, so make sure there's at least a dummy one. */
2027 if (b
->type
== bp_watchpoint
&& b
->loc
== NULL
)
2028 software_watchpoint_add_no_memory_location (b
, frame_pspace
);
2030 else if (!within_current_scope
)
2032 printf_filtered (_("\
2033 Watchpoint %d deleted because the program has left the block\n\
2034 in which its expression is valid.\n"),
2036 watchpoint_del_at_next_stop (b
);
2039 /* Restore the selected frame. */
2041 select_frame (frame_find_by_id (saved_frame_id
));
2045 /* Returns 1 iff breakpoint location should be
2046 inserted in the inferior. We don't differentiate the type of BL's owner
2047 (breakpoint vs. tracepoint), although insert_location in tracepoint's
2048 breakpoint_ops is not defined, because in insert_bp_location,
2049 tracepoint's insert_location will not be called. */
2051 should_be_inserted (struct bp_location
*bl
)
2053 if (bl
->owner
== NULL
|| !breakpoint_enabled (bl
->owner
))
2056 if (bl
->owner
->disposition
== disp_del_at_next_stop
)
2059 if (!bl
->enabled
|| bl
->shlib_disabled
|| bl
->duplicate
)
2062 if (user_breakpoint_p (bl
->owner
) && bl
->pspace
->executing_startup
)
2065 /* This is set for example, when we're attached to the parent of a
2066 vfork, and have detached from the child. The child is running
2067 free, and we expect it to do an exec or exit, at which point the
2068 OS makes the parent schedulable again (and the target reports
2069 that the vfork is done). Until the child is done with the shared
2070 memory region, do not insert breakpoints in the parent, otherwise
2071 the child could still trip on the parent's breakpoints. Since
2072 the parent is blocked anyway, it won't miss any breakpoint. */
2073 if (bl
->pspace
->breakpoints_not_allowed
)
2076 /* Don't insert a breakpoint if we're trying to step past its
2077 location, except if the breakpoint is a single-step breakpoint,
2078 and the breakpoint's thread is the thread which is stepping past
2080 if ((bl
->loc_type
== bp_loc_software_breakpoint
2081 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
2082 && stepping_past_instruction_at (bl
->pspace
->aspace
,
2084 /* The single-step breakpoint may be inserted at the location
2085 we're trying to step if the instruction branches to itself.
2086 However, the instruction won't be executed at all and it may
2087 break the semantics of the instruction, for example, the
2088 instruction is a conditional branch or updates some flags.
2089 We can't fix it unless GDB is able to emulate the instruction
2090 or switch to displaced stepping. */
2091 && !(bl
->owner
->type
== bp_single_step
2092 && thread_is_stepping_over_breakpoint (bl
->owner
->thread
)))
2096 fprintf_unfiltered (gdb_stdlog
,
2097 "infrun: skipping breakpoint: "
2098 "stepping past insn at: %s\n",
2099 paddress (bl
->gdbarch
, bl
->address
));
2104 /* Don't insert watchpoints if we're trying to step past the
2105 instruction that triggered one. */
2106 if ((bl
->loc_type
== bp_loc_hardware_watchpoint
)
2107 && stepping_past_nonsteppable_watchpoint ())
2111 fprintf_unfiltered (gdb_stdlog
,
2112 "infrun: stepping past non-steppable watchpoint. "
2113 "skipping watchpoint at %s:%d\n",
2114 paddress (bl
->gdbarch
, bl
->address
),
2123 /* Same as should_be_inserted but does the check assuming
2124 that the location is not duplicated. */
2127 unduplicated_should_be_inserted (struct bp_location
*bl
)
2130 const int save_duplicate
= bl
->duplicate
;
2133 result
= should_be_inserted (bl
);
2134 bl
->duplicate
= save_duplicate
;
2138 /* Parses a conditional described by an expression COND into an
2139 agent expression bytecode suitable for evaluation
2140 by the bytecode interpreter. Return NULL if there was
2141 any error during parsing. */
2143 static agent_expr_up
2144 parse_cond_to_aexpr (CORE_ADDR scope
, struct expression
*cond
)
2149 agent_expr_up aexpr
;
2151 /* We don't want to stop processing, so catch any errors
2152 that may show up. */
2155 aexpr
= gen_eval_for_expr (scope
, cond
);
2158 CATCH (ex
, RETURN_MASK_ERROR
)
2160 /* If we got here, it means the condition could not be parsed to a valid
2161 bytecode expression and thus can't be evaluated on the target's side.
2162 It's no use iterating through the conditions. */
2166 /* We have a valid agent expression. */
2170 /* Based on location BL, create a list of breakpoint conditions to be
2171 passed on to the target. If we have duplicated locations with different
2172 conditions, we will add such conditions to the list. The idea is that the
2173 target will evaluate the list of conditions and will only notify GDB when
2174 one of them is true. */
2177 build_target_condition_list (struct bp_location
*bl
)
2179 struct bp_location
**locp
= NULL
, **loc2p
;
2180 int null_condition_or_parse_error
= 0;
2181 int modified
= bl
->needs_update
;
2182 struct bp_location
*loc
;
2184 /* Release conditions left over from a previous insert. */
2185 bl
->target_info
.conditions
.clear ();
2187 /* This is only meaningful if the target is
2188 evaluating conditions and if the user has
2189 opted for condition evaluation on the target's
2191 if (gdb_evaluates_breakpoint_condition_p ()
2192 || !target_supports_evaluation_of_breakpoint_conditions ())
2195 /* Do a first pass to check for locations with no assigned
2196 conditions or conditions that fail to parse to a valid agent expression
2197 bytecode. If any of these happen, then it's no use to send conditions
2198 to the target since this location will always trigger and generate a
2199 response back to GDB. */
2200 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2203 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2207 /* Re-parse the conditions since something changed. In that
2208 case we already freed the condition bytecodes (see
2209 force_breakpoint_reinsertion). We just
2210 need to parse the condition to bytecodes again. */
2211 loc
->cond_bytecode
= parse_cond_to_aexpr (bl
->address
,
2215 /* If we have a NULL bytecode expression, it means something
2216 went wrong or we have a null condition expression. */
2217 if (!loc
->cond_bytecode
)
2219 null_condition_or_parse_error
= 1;
2225 /* If any of these happened, it means we will have to evaluate the conditions
2226 for the location's address on gdb's side. It is no use keeping bytecodes
2227 for all the other duplicate locations, thus we free all of them here.
2229 This is so we have a finer control over which locations' conditions are
2230 being evaluated by GDB or the remote stub. */
2231 if (null_condition_or_parse_error
)
2233 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2236 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2238 /* Only go as far as the first NULL bytecode is
2240 if (!loc
->cond_bytecode
)
2243 loc
->cond_bytecode
.reset ();
2248 /* No NULL conditions or failed bytecode generation. Build a condition list
2249 for this location's address. */
2250 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2254 && is_breakpoint (loc
->owner
)
2255 && loc
->pspace
->num
== bl
->pspace
->num
2256 && loc
->owner
->enable_state
== bp_enabled
2259 /* Add the condition to the vector. This will be used later
2260 to send the conditions to the target. */
2261 bl
->target_info
.conditions
.push_back (loc
->cond_bytecode
.get ());
2268 /* Parses a command described by string CMD into an agent expression
2269 bytecode suitable for evaluation by the bytecode interpreter.
2270 Return NULL if there was any error during parsing. */
2272 static agent_expr_up
2273 parse_cmd_to_aexpr (CORE_ADDR scope
, char *cmd
)
2275 struct cleanup
*old_cleanups
= 0;
2276 struct expression
**argvec
;
2277 const char *cmdrest
;
2278 const char *format_start
, *format_end
;
2279 struct format_piece
*fpieces
;
2281 struct gdbarch
*gdbarch
= get_current_arch ();
2288 if (*cmdrest
== ',')
2290 cmdrest
= skip_spaces (cmdrest
);
2292 if (*cmdrest
++ != '"')
2293 error (_("No format string following the location"));
2295 format_start
= cmdrest
;
2297 fpieces
= parse_format_string (&cmdrest
);
2299 old_cleanups
= make_cleanup (free_format_pieces_cleanup
, &fpieces
);
2301 format_end
= cmdrest
;
2303 if (*cmdrest
++ != '"')
2304 error (_("Bad format string, non-terminated '\"'."));
2306 cmdrest
= skip_spaces (cmdrest
);
2308 if (!(*cmdrest
== ',' || *cmdrest
== '\0'))
2309 error (_("Invalid argument syntax"));
2311 if (*cmdrest
== ',')
2313 cmdrest
= skip_spaces (cmdrest
);
2315 /* For each argument, make an expression. */
2317 argvec
= (struct expression
**) alloca (strlen (cmd
)
2318 * sizeof (struct expression
*));
2321 while (*cmdrest
!= '\0')
2326 expression_up expr
= parse_exp_1 (&cmd1
, scope
, block_for_pc (scope
), 1);
2327 argvec
[nargs
++] = expr
.release ();
2329 if (*cmdrest
== ',')
2333 agent_expr_up aexpr
;
2335 /* We don't want to stop processing, so catch any errors
2336 that may show up. */
2339 aexpr
= gen_printf (scope
, gdbarch
, 0, 0,
2340 format_start
, format_end
- format_start
,
2341 fpieces
, nargs
, argvec
);
2343 CATCH (ex
, RETURN_MASK_ERROR
)
2345 /* If we got here, it means the command could not be parsed to a valid
2346 bytecode expression and thus can't be evaluated on the target's side.
2347 It's no use iterating through the other commands. */
2351 do_cleanups (old_cleanups
);
2353 /* We have a valid agent expression, return it. */
2357 /* Based on location BL, create a list of breakpoint commands to be
2358 passed on to the target. If we have duplicated locations with
2359 different commands, we will add any such to the list. */
2362 build_target_command_list (struct bp_location
*bl
)
2364 struct bp_location
**locp
= NULL
, **loc2p
;
2365 int null_command_or_parse_error
= 0;
2366 int modified
= bl
->needs_update
;
2367 struct bp_location
*loc
;
2369 /* Clear commands left over from a previous insert. */
2370 bl
->target_info
.tcommands
.clear ();
2372 if (!target_can_run_breakpoint_commands ())
2375 /* For now, limit to agent-style dprintf breakpoints. */
2376 if (dprintf_style
!= dprintf_style_agent
)
2379 /* For now, if we have any duplicate location that isn't a dprintf,
2380 don't install the target-side commands, as that would make the
2381 breakpoint not be reported to the core, and we'd lose
2383 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2386 if (is_breakpoint (loc
->owner
)
2387 && loc
->pspace
->num
== bl
->pspace
->num
2388 && loc
->owner
->type
!= bp_dprintf
)
2392 /* Do a first pass to check for locations with no assigned
2393 conditions or conditions that fail to parse to a valid agent expression
2394 bytecode. If any of these happen, then it's no use to send conditions
2395 to the target since this location will always trigger and generate a
2396 response back to GDB. */
2397 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2400 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2404 /* Re-parse the commands since something changed. In that
2405 case we already freed the command bytecodes (see
2406 force_breakpoint_reinsertion). We just
2407 need to parse the command to bytecodes again. */
2409 = parse_cmd_to_aexpr (bl
->address
,
2410 loc
->owner
->extra_string
);
2413 /* If we have a NULL bytecode expression, it means something
2414 went wrong or we have a null command expression. */
2415 if (!loc
->cmd_bytecode
)
2417 null_command_or_parse_error
= 1;
2423 /* If anything failed, then we're not doing target-side commands,
2425 if (null_command_or_parse_error
)
2427 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2430 if (is_breakpoint (loc
->owner
)
2431 && loc
->pspace
->num
== bl
->pspace
->num
)
2433 /* Only go as far as the first NULL bytecode is
2435 if (loc
->cmd_bytecode
== NULL
)
2438 loc
->cmd_bytecode
.reset ();
2443 /* No NULL commands or failed bytecode generation. Build a command list
2444 for this location's address. */
2445 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2448 if (loc
->owner
->extra_string
2449 && is_breakpoint (loc
->owner
)
2450 && loc
->pspace
->num
== bl
->pspace
->num
2451 && loc
->owner
->enable_state
== bp_enabled
2454 /* Add the command to the vector. This will be used later
2455 to send the commands to the target. */
2456 bl
->target_info
.tcommands
.push_back (loc
->cmd_bytecode
.get ());
2460 bl
->target_info
.persist
= 0;
2461 /* Maybe flag this location as persistent. */
2462 if (bl
->owner
->type
== bp_dprintf
&& disconnected_dprintf
)
2463 bl
->target_info
.persist
= 1;
2466 /* Return the kind of breakpoint on address *ADDR. Get the kind
2467 of breakpoint according to ADDR except single-step breakpoint.
2468 Get the kind of single-step breakpoint according to the current
2472 breakpoint_kind (struct bp_location
*bl
, CORE_ADDR
*addr
)
2474 if (bl
->owner
->type
== bp_single_step
)
2476 struct thread_info
*thr
= find_thread_global_id (bl
->owner
->thread
);
2477 struct regcache
*regcache
;
2479 regcache
= get_thread_regcache (thr
->ptid
);
2481 return gdbarch_breakpoint_kind_from_current_state (bl
->gdbarch
,
2485 return gdbarch_breakpoint_kind_from_pc (bl
->gdbarch
, addr
);
2488 /* Insert a low-level "breakpoint" of some type. BL is the breakpoint
2489 location. Any error messages are printed to TMP_ERROR_STREAM; and
2490 DISABLED_BREAKS, and HW_BREAKPOINT_ERROR are used to report problems.
2491 Returns 0 for success, 1 if the bp_location type is not supported or
2494 NOTE drow/2003-09-09: This routine could be broken down to an
2495 object-style method for each breakpoint or catchpoint type. */
2497 insert_bp_location (struct bp_location
*bl
,
2498 struct ui_file
*tmp_error_stream
,
2499 int *disabled_breaks
,
2500 int *hw_breakpoint_error
,
2501 int *hw_bp_error_explained_already
)
2503 enum errors bp_err
= GDB_NO_ERROR
;
2504 const char *bp_err_message
= NULL
;
2506 if (!should_be_inserted (bl
) || (bl
->inserted
&& !bl
->needs_update
))
2509 /* Note we don't initialize bl->target_info, as that wipes out
2510 the breakpoint location's shadow_contents if the breakpoint
2511 is still inserted at that location. This in turn breaks
2512 target_read_memory which depends on these buffers when
2513 a memory read is requested at the breakpoint location:
2514 Once the target_info has been wiped, we fail to see that
2515 we have a breakpoint inserted at that address and thus
2516 read the breakpoint instead of returning the data saved in
2517 the breakpoint location's shadow contents. */
2518 bl
->target_info
.reqstd_address
= bl
->address
;
2519 bl
->target_info
.placed_address_space
= bl
->pspace
->aspace
;
2520 bl
->target_info
.length
= bl
->length
;
2522 /* When working with target-side conditions, we must pass all the conditions
2523 for the same breakpoint address down to the target since GDB will not
2524 insert those locations. With a list of breakpoint conditions, the target
2525 can decide when to stop and notify GDB. */
2527 if (is_breakpoint (bl
->owner
))
2529 build_target_condition_list (bl
);
2530 build_target_command_list (bl
);
2531 /* Reset the modification marker. */
2532 bl
->needs_update
= 0;
2535 if (bl
->loc_type
== bp_loc_software_breakpoint
2536 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
2538 if (bl
->owner
->type
!= bp_hardware_breakpoint
)
2540 /* If the explicitly specified breakpoint type
2541 is not hardware breakpoint, check the memory map to see
2542 if the breakpoint address is in read only memory or not.
2544 Two important cases are:
2545 - location type is not hardware breakpoint, memory
2546 is readonly. We change the type of the location to
2547 hardware breakpoint.
2548 - location type is hardware breakpoint, memory is
2549 read-write. This means we've previously made the
2550 location hardware one, but then the memory map changed,
2553 When breakpoints are removed, remove_breakpoints will use
2554 location types we've just set here, the only possible
2555 problem is that memory map has changed during running
2556 program, but it's not going to work anyway with current
2558 struct mem_region
*mr
2559 = lookup_mem_region (bl
->target_info
.reqstd_address
);
2563 if (automatic_hardware_breakpoints
)
2565 enum bp_loc_type new_type
;
2567 if (mr
->attrib
.mode
!= MEM_RW
)
2568 new_type
= bp_loc_hardware_breakpoint
;
2570 new_type
= bp_loc_software_breakpoint
;
2572 if (new_type
!= bl
->loc_type
)
2574 static int said
= 0;
2576 bl
->loc_type
= new_type
;
2579 fprintf_filtered (gdb_stdout
,
2580 _("Note: automatically using "
2581 "hardware breakpoints for "
2582 "read-only addresses.\n"));
2587 else if (bl
->loc_type
== bp_loc_software_breakpoint
2588 && mr
->attrib
.mode
!= MEM_RW
)
2590 fprintf_unfiltered (tmp_error_stream
,
2591 _("Cannot insert breakpoint %d.\n"
2592 "Cannot set software breakpoint "
2593 "at read-only address %s\n"),
2595 paddress (bl
->gdbarch
, bl
->address
));
2601 /* First check to see if we have to handle an overlay. */
2602 if (overlay_debugging
== ovly_off
2603 || bl
->section
== NULL
2604 || !(section_is_overlay (bl
->section
)))
2606 /* No overlay handling: just set the breakpoint. */
2611 val
= bl
->owner
->ops
->insert_location (bl
);
2613 bp_err
= GENERIC_ERROR
;
2615 CATCH (e
, RETURN_MASK_ALL
)
2618 bp_err_message
= e
.message
;
2624 /* This breakpoint is in an overlay section.
2625 Shall we set a breakpoint at the LMA? */
2626 if (!overlay_events_enabled
)
2628 /* Yes -- overlay event support is not active,
2629 so we must try to set a breakpoint at the LMA.
2630 This will not work for a hardware breakpoint. */
2631 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
2632 warning (_("hardware breakpoint %d not supported in overlay!"),
2636 CORE_ADDR addr
= overlay_unmapped_address (bl
->address
,
2638 /* Set a software (trap) breakpoint at the LMA. */
2639 bl
->overlay_target_info
= bl
->target_info
;
2640 bl
->overlay_target_info
.reqstd_address
= addr
;
2642 /* No overlay handling: just set the breakpoint. */
2647 bl
->overlay_target_info
.kind
2648 = breakpoint_kind (bl
, &addr
);
2649 bl
->overlay_target_info
.placed_address
= addr
;
2650 val
= target_insert_breakpoint (bl
->gdbarch
,
2651 &bl
->overlay_target_info
);
2653 bp_err
= GENERIC_ERROR
;
2655 CATCH (e
, RETURN_MASK_ALL
)
2658 bp_err_message
= e
.message
;
2662 if (bp_err
!= GDB_NO_ERROR
)
2663 fprintf_unfiltered (tmp_error_stream
,
2664 "Overlay breakpoint %d "
2665 "failed: in ROM?\n",
2669 /* Shall we set a breakpoint at the VMA? */
2670 if (section_is_mapped (bl
->section
))
2672 /* Yes. This overlay section is mapped into memory. */
2677 val
= bl
->owner
->ops
->insert_location (bl
);
2679 bp_err
= GENERIC_ERROR
;
2681 CATCH (e
, RETURN_MASK_ALL
)
2684 bp_err_message
= e
.message
;
2690 /* No. This breakpoint will not be inserted.
2691 No error, but do not mark the bp as 'inserted'. */
2696 if (bp_err
!= GDB_NO_ERROR
)
2698 /* Can't set the breakpoint. */
2700 /* In some cases, we might not be able to insert a
2701 breakpoint in a shared library that has already been
2702 removed, but we have not yet processed the shlib unload
2703 event. Unfortunately, some targets that implement
2704 breakpoint insertion themselves can't tell why the
2705 breakpoint insertion failed (e.g., the remote target
2706 doesn't define error codes), so we must treat generic
2707 errors as memory errors. */
2708 if ((bp_err
== GENERIC_ERROR
|| bp_err
== MEMORY_ERROR
)
2709 && bl
->loc_type
== bp_loc_software_breakpoint
2710 && (solib_name_from_address (bl
->pspace
, bl
->address
)
2711 || shared_objfile_contains_address_p (bl
->pspace
,
2714 /* See also: disable_breakpoints_in_shlibs. */
2715 bl
->shlib_disabled
= 1;
2716 observer_notify_breakpoint_modified (bl
->owner
);
2717 if (!*disabled_breaks
)
2719 fprintf_unfiltered (tmp_error_stream
,
2720 "Cannot insert breakpoint %d.\n",
2722 fprintf_unfiltered (tmp_error_stream
,
2723 "Temporarily disabling shared "
2724 "library breakpoints:\n");
2726 *disabled_breaks
= 1;
2727 fprintf_unfiltered (tmp_error_stream
,
2728 "breakpoint #%d\n", bl
->owner
->number
);
2733 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
2735 *hw_breakpoint_error
= 1;
2736 *hw_bp_error_explained_already
= bp_err_message
!= NULL
;
2737 fprintf_unfiltered (tmp_error_stream
,
2738 "Cannot insert hardware breakpoint %d%s",
2739 bl
->owner
->number
, bp_err_message
? ":" : ".\n");
2740 if (bp_err_message
!= NULL
)
2741 fprintf_unfiltered (tmp_error_stream
, "%s.\n", bp_err_message
);
2745 if (bp_err_message
== NULL
)
2748 = memory_error_message (TARGET_XFER_E_IO
,
2749 bl
->gdbarch
, bl
->address
);
2751 fprintf_unfiltered (tmp_error_stream
,
2752 "Cannot insert breakpoint %d.\n"
2754 bl
->owner
->number
, message
.c_str ());
2758 fprintf_unfiltered (tmp_error_stream
,
2759 "Cannot insert breakpoint %d: %s\n",
2774 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
2775 /* NOTE drow/2003-09-08: This state only exists for removing
2776 watchpoints. It's not clear that it's necessary... */
2777 && bl
->owner
->disposition
!= disp_del_at_next_stop
)
2781 gdb_assert (bl
->owner
->ops
!= NULL
2782 && bl
->owner
->ops
->insert_location
!= NULL
);
2784 val
= bl
->owner
->ops
->insert_location (bl
);
2786 /* If trying to set a read-watchpoint, and it turns out it's not
2787 supported, try emulating one with an access watchpoint. */
2788 if (val
== 1 && bl
->watchpoint_type
== hw_read
)
2790 struct bp_location
*loc
, **loc_temp
;
2792 /* But don't try to insert it, if there's already another
2793 hw_access location that would be considered a duplicate
2795 ALL_BP_LOCATIONS (loc
, loc_temp
)
2797 && loc
->watchpoint_type
== hw_access
2798 && watchpoint_locations_match (bl
, loc
))
2802 bl
->target_info
= loc
->target_info
;
2803 bl
->watchpoint_type
= hw_access
;
2810 bl
->watchpoint_type
= hw_access
;
2811 val
= bl
->owner
->ops
->insert_location (bl
);
2814 /* Back to the original value. */
2815 bl
->watchpoint_type
= hw_read
;
2819 bl
->inserted
= (val
== 0);
2822 else if (bl
->owner
->type
== bp_catchpoint
)
2826 gdb_assert (bl
->owner
->ops
!= NULL
2827 && bl
->owner
->ops
->insert_location
!= NULL
);
2829 val
= bl
->owner
->ops
->insert_location (bl
);
2832 bl
->owner
->enable_state
= bp_disabled
;
2836 Error inserting catchpoint %d: Your system does not support this type\n\
2837 of catchpoint."), bl
->owner
->number
);
2839 warning (_("Error inserting catchpoint %d."), bl
->owner
->number
);
2842 bl
->inserted
= (val
== 0);
2844 /* We've already printed an error message if there was a problem
2845 inserting this catchpoint, and we've disabled the catchpoint,
2846 so just return success. */
2853 /* This function is called when program space PSPACE is about to be
2854 deleted. It takes care of updating breakpoints to not reference
2858 breakpoint_program_space_exit (struct program_space
*pspace
)
2860 struct breakpoint
*b
, *b_temp
;
2861 struct bp_location
*loc
, **loc_temp
;
2863 /* Remove any breakpoint that was set through this program space. */
2864 ALL_BREAKPOINTS_SAFE (b
, b_temp
)
2866 if (b
->pspace
== pspace
)
2867 delete_breakpoint (b
);
2870 /* Breakpoints set through other program spaces could have locations
2871 bound to PSPACE as well. Remove those. */
2872 ALL_BP_LOCATIONS (loc
, loc_temp
)
2874 struct bp_location
*tmp
;
2876 if (loc
->pspace
== pspace
)
2878 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
2879 if (loc
->owner
->loc
== loc
)
2880 loc
->owner
->loc
= loc
->next
;
2882 for (tmp
= loc
->owner
->loc
; tmp
->next
!= NULL
; tmp
= tmp
->next
)
2883 if (tmp
->next
== loc
)
2885 tmp
->next
= loc
->next
;
2891 /* Now update the global location list to permanently delete the
2892 removed locations above. */
2893 update_global_location_list (UGLL_DONT_INSERT
);
2896 /* Make sure all breakpoints are inserted in inferior.
2897 Throws exception on any error.
2898 A breakpoint that is already inserted won't be inserted
2899 again, so calling this function twice is safe. */
2901 insert_breakpoints (void)
2903 struct breakpoint
*bpt
;
2905 ALL_BREAKPOINTS (bpt
)
2906 if (is_hardware_watchpoint (bpt
))
2908 struct watchpoint
*w
= (struct watchpoint
*) bpt
;
2910 update_watchpoint (w
, 0 /* don't reparse. */);
2913 /* Updating watchpoints creates new locations, so update the global
2914 location list. Explicitly tell ugll to insert locations and
2915 ignore breakpoints_always_inserted_mode. */
2916 update_global_location_list (UGLL_INSERT
);
2919 /* Invoke CALLBACK for each of bp_location. */
2922 iterate_over_bp_locations (walk_bp_location_callback callback
)
2924 struct bp_location
*loc
, **loc_tmp
;
2926 ALL_BP_LOCATIONS (loc
, loc_tmp
)
2928 callback (loc
, NULL
);
2932 /* This is used when we need to synch breakpoint conditions between GDB and the
2933 target. It is the case with deleting and disabling of breakpoints when using
2934 always-inserted mode. */
2937 update_inserted_breakpoint_locations (void)
2939 struct bp_location
*bl
, **blp_tmp
;
2942 int disabled_breaks
= 0;
2943 int hw_breakpoint_error
= 0;
2944 int hw_bp_details_reported
= 0;
2946 string_file tmp_error_stream
;
2948 /* Explicitly mark the warning -- this will only be printed if
2949 there was an error. */
2950 tmp_error_stream
.puts ("Warning:\n");
2952 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
2954 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2956 /* We only want to update software breakpoints and hardware
2958 if (!is_breakpoint (bl
->owner
))
2961 /* We only want to update locations that are already inserted
2962 and need updating. This is to avoid unwanted insertion during
2963 deletion of breakpoints. */
2964 if (!bl
->inserted
|| (bl
->inserted
&& !bl
->needs_update
))
2967 switch_to_program_space_and_thread (bl
->pspace
);
2969 /* For targets that support global breakpoints, there's no need
2970 to select an inferior to insert breakpoint to. In fact, even
2971 if we aren't attached to any process yet, we should still
2972 insert breakpoints. */
2973 if (!gdbarch_has_global_breakpoints (target_gdbarch ())
2974 && ptid_equal (inferior_ptid
, null_ptid
))
2977 val
= insert_bp_location (bl
, &tmp_error_stream
, &disabled_breaks
,
2978 &hw_breakpoint_error
, &hw_bp_details_reported
);
2985 target_terminal::ours_for_output ();
2986 error_stream (tmp_error_stream
);
2990 /* Used when starting or continuing the program. */
2993 insert_breakpoint_locations (void)
2995 struct breakpoint
*bpt
;
2996 struct bp_location
*bl
, **blp_tmp
;
2999 int disabled_breaks
= 0;
3000 int hw_breakpoint_error
= 0;
3001 int hw_bp_error_explained_already
= 0;
3003 string_file tmp_error_stream
;
3005 /* Explicitly mark the warning -- this will only be printed if
3006 there was an error. */
3007 tmp_error_stream
.puts ("Warning:\n");
3009 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
3011 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3013 if (!should_be_inserted (bl
) || (bl
->inserted
&& !bl
->needs_update
))
3016 /* There is no point inserting thread-specific breakpoints if
3017 the thread no longer exists. ALL_BP_LOCATIONS bp_location
3018 has BL->OWNER always non-NULL. */
3019 if (bl
->owner
->thread
!= -1
3020 && !valid_global_thread_id (bl
->owner
->thread
))
3023 switch_to_program_space_and_thread (bl
->pspace
);
3025 /* For targets that support global breakpoints, there's no need
3026 to select an inferior to insert breakpoint to. In fact, even
3027 if we aren't attached to any process yet, we should still
3028 insert breakpoints. */
3029 if (!gdbarch_has_global_breakpoints (target_gdbarch ())
3030 && ptid_equal (inferior_ptid
, null_ptid
))
3033 val
= insert_bp_location (bl
, &tmp_error_stream
, &disabled_breaks
,
3034 &hw_breakpoint_error
, &hw_bp_error_explained_already
);
3039 /* If we failed to insert all locations of a watchpoint, remove
3040 them, as half-inserted watchpoint is of limited use. */
3041 ALL_BREAKPOINTS (bpt
)
3043 int some_failed
= 0;
3044 struct bp_location
*loc
;
3046 if (!is_hardware_watchpoint (bpt
))
3049 if (!breakpoint_enabled (bpt
))
3052 if (bpt
->disposition
== disp_del_at_next_stop
)
3055 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
3056 if (!loc
->inserted
&& should_be_inserted (loc
))
3063 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
3065 remove_breakpoint (loc
);
3067 hw_breakpoint_error
= 1;
3068 tmp_error_stream
.printf ("Could not insert "
3069 "hardware watchpoint %d.\n",
3077 /* If a hardware breakpoint or watchpoint was inserted, add a
3078 message about possibly exhausted resources. */
3079 if (hw_breakpoint_error
&& !hw_bp_error_explained_already
)
3081 tmp_error_stream
.printf ("Could not insert hardware breakpoints:\n\
3082 You may have requested too many hardware breakpoints/watchpoints.\n");
3084 target_terminal::ours_for_output ();
3085 error_stream (tmp_error_stream
);
3089 /* Used when the program stops.
3090 Returns zero if successful, or non-zero if there was a problem
3091 removing a breakpoint location. */
3094 remove_breakpoints (void)
3096 struct bp_location
*bl
, **blp_tmp
;
3099 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3101 if (bl
->inserted
&& !is_tracepoint (bl
->owner
))
3102 val
|= remove_breakpoint (bl
);
3107 /* When a thread exits, remove breakpoints that are related to
3111 remove_threaded_breakpoints (struct thread_info
*tp
, int silent
)
3113 struct breakpoint
*b
, *b_tmp
;
3115 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
3117 if (b
->thread
== tp
->global_num
&& user_breakpoint_p (b
))
3119 b
->disposition
= disp_del_at_next_stop
;
3121 printf_filtered (_("\
3122 Thread-specific breakpoint %d deleted - thread %s no longer in the thread list.\n"),
3123 b
->number
, print_thread_id (tp
));
3125 /* Hide it from the user. */
3131 /* Remove breakpoints of process PID. */
3134 remove_breakpoints_pid (int pid
)
3136 struct bp_location
*bl
, **blp_tmp
;
3138 struct inferior
*inf
= find_inferior_pid (pid
);
3140 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3142 if (bl
->pspace
!= inf
->pspace
)
3145 if (bl
->inserted
&& !bl
->target_info
.persist
)
3147 val
= remove_breakpoint (bl
);
3156 reattach_breakpoints (int pid
)
3158 struct bp_location
*bl
, **blp_tmp
;
3160 int dummy1
= 0, dummy2
= 0, dummy3
= 0;
3161 struct inferior
*inf
;
3162 struct thread_info
*tp
;
3164 tp
= any_live_thread_of_process (pid
);
3168 inf
= find_inferior_pid (pid
);
3170 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
3171 inferior_ptid
= tp
->ptid
;
3173 string_file tmp_error_stream
;
3175 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3177 if (bl
->pspace
!= inf
->pspace
)
3183 val
= insert_bp_location (bl
, &tmp_error_stream
, &dummy1
, &dummy2
, &dummy3
);
3191 static int internal_breakpoint_number
= -1;
3193 /* Set the breakpoint number of B, depending on the value of INTERNAL.
3194 If INTERNAL is non-zero, the breakpoint number will be populated
3195 from internal_breakpoint_number and that variable decremented.
3196 Otherwise the breakpoint number will be populated from
3197 breakpoint_count and that value incremented. Internal breakpoints
3198 do not set the internal var bpnum. */
3200 set_breakpoint_number (int internal
, struct breakpoint
*b
)
3203 b
->number
= internal_breakpoint_number
--;
3206 set_breakpoint_count (breakpoint_count
+ 1);
3207 b
->number
= breakpoint_count
;
3211 static struct breakpoint
*
3212 create_internal_breakpoint (struct gdbarch
*gdbarch
,
3213 CORE_ADDR address
, enum bptype type
,
3214 const struct breakpoint_ops
*ops
)
3216 symtab_and_line sal
;
3218 sal
.section
= find_pc_overlay (sal
.pc
);
3219 sal
.pspace
= current_program_space
;
3221 breakpoint
*b
= set_raw_breakpoint (gdbarch
, sal
, type
, ops
);
3222 b
->number
= internal_breakpoint_number
--;
3223 b
->disposition
= disp_donttouch
;
3228 static const char *const longjmp_names
[] =
3230 "longjmp", "_longjmp", "siglongjmp", "_siglongjmp"
3232 #define NUM_LONGJMP_NAMES ARRAY_SIZE(longjmp_names)
3234 /* Per-objfile data private to breakpoint.c. */
3235 struct breakpoint_objfile_data
3237 /* Minimal symbol for "_ovly_debug_event" (if any). */
3238 struct bound_minimal_symbol overlay_msym
;
3240 /* Minimal symbol(s) for "longjmp", "siglongjmp", etc. (if any). */
3241 struct bound_minimal_symbol longjmp_msym
[NUM_LONGJMP_NAMES
];
3243 /* True if we have looked for longjmp probes. */
3244 int longjmp_searched
;
3246 /* SystemTap probe points for longjmp (if any). */
3247 VEC (probe_p
) *longjmp_probes
;
3249 /* Minimal symbol for "std::terminate()" (if any). */
3250 struct bound_minimal_symbol terminate_msym
;
3252 /* Minimal symbol for "_Unwind_DebugHook" (if any). */
3253 struct bound_minimal_symbol exception_msym
;
3255 /* True if we have looked for exception probes. */
3256 int exception_searched
;
3258 /* SystemTap probe points for unwinding (if any). */
3259 VEC (probe_p
) *exception_probes
;
3262 static const struct objfile_data
*breakpoint_objfile_key
;
3264 /* Minimal symbol not found sentinel. */
3265 static struct minimal_symbol msym_not_found
;
3267 /* Returns TRUE if MSYM point to the "not found" sentinel. */
3270 msym_not_found_p (const struct minimal_symbol
*msym
)
3272 return msym
== &msym_not_found
;
3275 /* Return per-objfile data needed by breakpoint.c.
3276 Allocate the data if necessary. */
3278 static struct breakpoint_objfile_data
*
3279 get_breakpoint_objfile_data (struct objfile
*objfile
)
3281 struct breakpoint_objfile_data
*bp_objfile_data
;
3283 bp_objfile_data
= ((struct breakpoint_objfile_data
*)
3284 objfile_data (objfile
, breakpoint_objfile_key
));
3285 if (bp_objfile_data
== NULL
)
3288 XOBNEW (&objfile
->objfile_obstack
, struct breakpoint_objfile_data
);
3290 memset (bp_objfile_data
, 0, sizeof (*bp_objfile_data
));
3291 set_objfile_data (objfile
, breakpoint_objfile_key
, bp_objfile_data
);
3293 return bp_objfile_data
;
3297 free_breakpoint_probes (struct objfile
*obj
, void *data
)
3299 struct breakpoint_objfile_data
*bp_objfile_data
3300 = (struct breakpoint_objfile_data
*) data
;
3302 VEC_free (probe_p
, bp_objfile_data
->longjmp_probes
);
3303 VEC_free (probe_p
, bp_objfile_data
->exception_probes
);
3307 create_overlay_event_breakpoint (void)
3309 struct objfile
*objfile
;
3310 const char *const func_name
= "_ovly_debug_event";
3312 ALL_OBJFILES (objfile
)
3314 struct breakpoint
*b
;
3315 struct breakpoint_objfile_data
*bp_objfile_data
;
3317 struct explicit_location explicit_loc
;
3319 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3321 if (msym_not_found_p (bp_objfile_data
->overlay_msym
.minsym
))
3324 if (bp_objfile_data
->overlay_msym
.minsym
== NULL
)
3326 struct bound_minimal_symbol m
;
3328 m
= lookup_minimal_symbol_text (func_name
, objfile
);
3329 if (m
.minsym
== NULL
)
3331 /* Avoid future lookups in this objfile. */
3332 bp_objfile_data
->overlay_msym
.minsym
= &msym_not_found
;
3335 bp_objfile_data
->overlay_msym
= m
;
3338 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->overlay_msym
);
3339 b
= create_internal_breakpoint (get_objfile_arch (objfile
), addr
,
3341 &internal_breakpoint_ops
);
3342 initialize_explicit_location (&explicit_loc
);
3343 explicit_loc
.function_name
= ASTRDUP (func_name
);
3344 b
->location
= new_explicit_location (&explicit_loc
);
3346 if (overlay_debugging
== ovly_auto
)
3348 b
->enable_state
= bp_enabled
;
3349 overlay_events_enabled
= 1;
3353 b
->enable_state
= bp_disabled
;
3354 overlay_events_enabled
= 0;
3360 create_longjmp_master_breakpoint (void)
3362 struct program_space
*pspace
;
3364 scoped_restore_current_program_space restore_pspace
;
3366 ALL_PSPACES (pspace
)
3368 struct objfile
*objfile
;
3370 set_current_program_space (pspace
);
3372 ALL_OBJFILES (objfile
)
3375 struct gdbarch
*gdbarch
;
3376 struct breakpoint_objfile_data
*bp_objfile_data
;
3378 gdbarch
= get_objfile_arch (objfile
);
3380 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3382 if (!bp_objfile_data
->longjmp_searched
)
3386 ret
= find_probes_in_objfile (objfile
, "libc", "longjmp");
3389 /* We are only interested in checking one element. */
3390 struct probe
*p
= VEC_index (probe_p
, ret
, 0);
3392 if (!can_evaluate_probe_arguments (p
))
3394 /* We cannot use the probe interface here, because it does
3395 not know how to evaluate arguments. */
3396 VEC_free (probe_p
, ret
);
3400 bp_objfile_data
->longjmp_probes
= ret
;
3401 bp_objfile_data
->longjmp_searched
= 1;
3404 if (bp_objfile_data
->longjmp_probes
!= NULL
)
3407 struct probe
*probe
;
3408 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3411 VEC_iterate (probe_p
,
3412 bp_objfile_data
->longjmp_probes
,
3416 struct breakpoint
*b
;
3418 b
= create_internal_breakpoint (gdbarch
,
3419 get_probe_address (probe
,
3422 &internal_breakpoint_ops
);
3423 b
->location
= new_probe_location ("-probe-stap libc:longjmp");
3424 b
->enable_state
= bp_disabled
;
3430 if (!gdbarch_get_longjmp_target_p (gdbarch
))
3433 for (i
= 0; i
< NUM_LONGJMP_NAMES
; i
++)
3435 struct breakpoint
*b
;
3436 const char *func_name
;
3438 struct explicit_location explicit_loc
;
3440 if (msym_not_found_p (bp_objfile_data
->longjmp_msym
[i
].minsym
))
3443 func_name
= longjmp_names
[i
];
3444 if (bp_objfile_data
->longjmp_msym
[i
].minsym
== NULL
)
3446 struct bound_minimal_symbol m
;
3448 m
= lookup_minimal_symbol_text (func_name
, objfile
);
3449 if (m
.minsym
== NULL
)
3451 /* Prevent future lookups in this objfile. */
3452 bp_objfile_data
->longjmp_msym
[i
].minsym
= &msym_not_found
;
3455 bp_objfile_data
->longjmp_msym
[i
] = m
;
3458 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->longjmp_msym
[i
]);
3459 b
= create_internal_breakpoint (gdbarch
, addr
, bp_longjmp_master
,
3460 &internal_breakpoint_ops
);
3461 initialize_explicit_location (&explicit_loc
);
3462 explicit_loc
.function_name
= ASTRDUP (func_name
);
3463 b
->location
= new_explicit_location (&explicit_loc
);
3464 b
->enable_state
= bp_disabled
;
3470 /* Create a master std::terminate breakpoint. */
3472 create_std_terminate_master_breakpoint (void)
3474 struct program_space
*pspace
;
3475 const char *const func_name
= "std::terminate()";
3477 scoped_restore_current_program_space restore_pspace
;
3479 ALL_PSPACES (pspace
)
3481 struct objfile
*objfile
;
3484 set_current_program_space (pspace
);
3486 ALL_OBJFILES (objfile
)
3488 struct breakpoint
*b
;
3489 struct breakpoint_objfile_data
*bp_objfile_data
;
3490 struct explicit_location explicit_loc
;
3492 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3494 if (msym_not_found_p (bp_objfile_data
->terminate_msym
.minsym
))
3497 if (bp_objfile_data
->terminate_msym
.minsym
== NULL
)
3499 struct bound_minimal_symbol m
;
3501 m
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
3502 if (m
.minsym
== NULL
|| (MSYMBOL_TYPE (m
.minsym
) != mst_text
3503 && MSYMBOL_TYPE (m
.minsym
) != mst_file_text
))
3505 /* Prevent future lookups in this objfile. */
3506 bp_objfile_data
->terminate_msym
.minsym
= &msym_not_found
;
3509 bp_objfile_data
->terminate_msym
= m
;
3512 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->terminate_msym
);
3513 b
= create_internal_breakpoint (get_objfile_arch (objfile
), addr
,
3514 bp_std_terminate_master
,
3515 &internal_breakpoint_ops
);
3516 initialize_explicit_location (&explicit_loc
);
3517 explicit_loc
.function_name
= ASTRDUP (func_name
);
3518 b
->location
= new_explicit_location (&explicit_loc
);
3519 b
->enable_state
= bp_disabled
;
3524 /* Install a master breakpoint on the unwinder's debug hook. */
3527 create_exception_master_breakpoint (void)
3529 struct objfile
*objfile
;
3530 const char *const func_name
= "_Unwind_DebugHook";
3532 ALL_OBJFILES (objfile
)
3534 struct breakpoint
*b
;
3535 struct gdbarch
*gdbarch
;
3536 struct breakpoint_objfile_data
*bp_objfile_data
;
3538 struct explicit_location explicit_loc
;
3540 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3542 /* We prefer the SystemTap probe point if it exists. */
3543 if (!bp_objfile_data
->exception_searched
)
3547 ret
= find_probes_in_objfile (objfile
, "libgcc", "unwind");
3551 /* We are only interested in checking one element. */
3552 struct probe
*p
= VEC_index (probe_p
, ret
, 0);
3554 if (!can_evaluate_probe_arguments (p
))
3556 /* We cannot use the probe interface here, because it does
3557 not know how to evaluate arguments. */
3558 VEC_free (probe_p
, ret
);
3562 bp_objfile_data
->exception_probes
= ret
;
3563 bp_objfile_data
->exception_searched
= 1;
3566 if (bp_objfile_data
->exception_probes
!= NULL
)
3568 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3570 struct probe
*probe
;
3573 VEC_iterate (probe_p
,
3574 bp_objfile_data
->exception_probes
,
3578 struct breakpoint
*b
;
3580 b
= create_internal_breakpoint (gdbarch
,
3581 get_probe_address (probe
,
3583 bp_exception_master
,
3584 &internal_breakpoint_ops
);
3585 b
->location
= new_probe_location ("-probe-stap libgcc:unwind");
3586 b
->enable_state
= bp_disabled
;
3592 /* Otherwise, try the hook function. */
3594 if (msym_not_found_p (bp_objfile_data
->exception_msym
.minsym
))
3597 gdbarch
= get_objfile_arch (objfile
);
3599 if (bp_objfile_data
->exception_msym
.minsym
== NULL
)
3601 struct bound_minimal_symbol debug_hook
;
3603 debug_hook
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
3604 if (debug_hook
.minsym
== NULL
)
3606 bp_objfile_data
->exception_msym
.minsym
= &msym_not_found
;
3610 bp_objfile_data
->exception_msym
= debug_hook
;
3613 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->exception_msym
);
3614 addr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, addr
,
3616 b
= create_internal_breakpoint (gdbarch
, addr
, bp_exception_master
,
3617 &internal_breakpoint_ops
);
3618 initialize_explicit_location (&explicit_loc
);
3619 explicit_loc
.function_name
= ASTRDUP (func_name
);
3620 b
->location
= new_explicit_location (&explicit_loc
);
3621 b
->enable_state
= bp_disabled
;
3625 /* Does B have a location spec? */
3628 breakpoint_event_location_empty_p (const struct breakpoint
*b
)
3630 return b
->location
!= NULL
&& event_location_empty_p (b
->location
.get ());
3634 update_breakpoints_after_exec (void)
3636 struct breakpoint
*b
, *b_tmp
;
3637 struct bp_location
*bploc
, **bplocp_tmp
;
3639 /* We're about to delete breakpoints from GDB's lists. If the
3640 INSERTED flag is true, GDB will try to lift the breakpoints by
3641 writing the breakpoints' "shadow contents" back into memory. The
3642 "shadow contents" are NOT valid after an exec, so GDB should not
3643 do that. Instead, the target is responsible from marking
3644 breakpoints out as soon as it detects an exec. We don't do that
3645 here instead, because there may be other attempts to delete
3646 breakpoints after detecting an exec and before reaching here. */
3647 ALL_BP_LOCATIONS (bploc
, bplocp_tmp
)
3648 if (bploc
->pspace
== current_program_space
)
3649 gdb_assert (!bploc
->inserted
);
3651 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
3653 if (b
->pspace
!= current_program_space
)
3656 /* Solib breakpoints must be explicitly reset after an exec(). */
3657 if (b
->type
== bp_shlib_event
)
3659 delete_breakpoint (b
);
3663 /* JIT breakpoints must be explicitly reset after an exec(). */
3664 if (b
->type
== bp_jit_event
)
3666 delete_breakpoint (b
);
3670 /* Thread event breakpoints must be set anew after an exec(),
3671 as must overlay event and longjmp master breakpoints. */
3672 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
3673 || b
->type
== bp_longjmp_master
|| b
->type
== bp_std_terminate_master
3674 || b
->type
== bp_exception_master
)
3676 delete_breakpoint (b
);
3680 /* Step-resume breakpoints are meaningless after an exec(). */
3681 if (b
->type
== bp_step_resume
|| b
->type
== bp_hp_step_resume
)
3683 delete_breakpoint (b
);
3687 /* Just like single-step breakpoints. */
3688 if (b
->type
== bp_single_step
)
3690 delete_breakpoint (b
);
3694 /* Longjmp and longjmp-resume breakpoints are also meaningless
3696 if (b
->type
== bp_longjmp
|| b
->type
== bp_longjmp_resume
3697 || b
->type
== bp_longjmp_call_dummy
3698 || b
->type
== bp_exception
|| b
->type
== bp_exception_resume
)
3700 delete_breakpoint (b
);
3704 if (b
->type
== bp_catchpoint
)
3706 /* For now, none of the bp_catchpoint breakpoints need to
3707 do anything at this point. In the future, if some of
3708 the catchpoints need to something, we will need to add
3709 a new method, and call this method from here. */
3713 /* bp_finish is a special case. The only way we ought to be able
3714 to see one of these when an exec() has happened, is if the user
3715 caught a vfork, and then said "finish". Ordinarily a finish just
3716 carries them to the call-site of the current callee, by setting
3717 a temporary bp there and resuming. But in this case, the finish
3718 will carry them entirely through the vfork & exec.
3720 We don't want to allow a bp_finish to remain inserted now. But
3721 we can't safely delete it, 'cause finish_command has a handle to
3722 the bp on a bpstat, and will later want to delete it. There's a
3723 chance (and I've seen it happen) that if we delete the bp_finish
3724 here, that its storage will get reused by the time finish_command
3725 gets 'round to deleting the "use to be a bp_finish" breakpoint.
3726 We really must allow finish_command to delete a bp_finish.
3728 In the absence of a general solution for the "how do we know
3729 it's safe to delete something others may have handles to?"
3730 problem, what we'll do here is just uninsert the bp_finish, and
3731 let finish_command delete it.
3733 (We know the bp_finish is "doomed" in the sense that it's
3734 momentary, and will be deleted as soon as finish_command sees
3735 the inferior stopped. So it doesn't matter that the bp's
3736 address is probably bogus in the new a.out, unlike e.g., the
3737 solib breakpoints.) */
3739 if (b
->type
== bp_finish
)
3744 /* Without a symbolic address, we have little hope of the
3745 pre-exec() address meaning the same thing in the post-exec()
3747 if (breakpoint_event_location_empty_p (b
))
3749 delete_breakpoint (b
);
3756 detach_breakpoints (ptid_t ptid
)
3758 struct bp_location
*bl
, **blp_tmp
;
3760 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
3761 struct inferior
*inf
= current_inferior ();
3763 if (ptid_get_pid (ptid
) == ptid_get_pid (inferior_ptid
))
3764 error (_("Cannot detach breakpoints of inferior_ptid"));
3766 /* Set inferior_ptid; remove_breakpoint_1 uses this global. */
3767 inferior_ptid
= ptid
;
3768 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3770 if (bl
->pspace
!= inf
->pspace
)
3773 /* This function must physically remove breakpoints locations
3774 from the specified ptid, without modifying the breakpoint
3775 package's state. Locations of type bp_loc_other are only
3776 maintained at GDB side. So, there is no need to remove
3777 these bp_loc_other locations. Moreover, removing these
3778 would modify the breakpoint package's state. */
3779 if (bl
->loc_type
== bp_loc_other
)
3783 val
|= remove_breakpoint_1 (bl
, DETACH_BREAKPOINT
);
3789 /* Remove the breakpoint location BL from the current address space.
3790 Note that this is used to detach breakpoints from a child fork.
3791 When we get here, the child isn't in the inferior list, and neither
3792 do we have objects to represent its address space --- we should
3793 *not* look at bl->pspace->aspace here. */
3796 remove_breakpoint_1 (struct bp_location
*bl
, enum remove_bp_reason reason
)
3800 /* BL is never in moribund_locations by our callers. */
3801 gdb_assert (bl
->owner
!= NULL
);
3803 /* The type of none suggests that owner is actually deleted.
3804 This should not ever happen. */
3805 gdb_assert (bl
->owner
->type
!= bp_none
);
3807 if (bl
->loc_type
== bp_loc_software_breakpoint
3808 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
3810 /* "Normal" instruction breakpoint: either the standard
3811 trap-instruction bp (bp_breakpoint), or a
3812 bp_hardware_breakpoint. */
3814 /* First check to see if we have to handle an overlay. */
3815 if (overlay_debugging
== ovly_off
3816 || bl
->section
== NULL
3817 || !(section_is_overlay (bl
->section
)))
3819 /* No overlay handling: just remove the breakpoint. */
3821 /* If we're trying to uninsert a memory breakpoint that we
3822 know is set in a dynamic object that is marked
3823 shlib_disabled, then either the dynamic object was
3824 removed with "remove-symbol-file" or with
3825 "nosharedlibrary". In the former case, we don't know
3826 whether another dynamic object might have loaded over the
3827 breakpoint's address -- the user might well let us know
3828 about it next with add-symbol-file (the whole point of
3829 add-symbol-file is letting the user manually maintain a
3830 list of dynamically loaded objects). If we have the
3831 breakpoint's shadow memory, that is, this is a software
3832 breakpoint managed by GDB, check whether the breakpoint
3833 is still inserted in memory, to avoid overwriting wrong
3834 code with stale saved shadow contents. Note that HW
3835 breakpoints don't have shadow memory, as they're
3836 implemented using a mechanism that is not dependent on
3837 being able to modify the target's memory, and as such
3838 they should always be removed. */
3839 if (bl
->shlib_disabled
3840 && bl
->target_info
.shadow_len
!= 0
3841 && !memory_validate_breakpoint (bl
->gdbarch
, &bl
->target_info
))
3844 val
= bl
->owner
->ops
->remove_location (bl
, reason
);
3848 /* This breakpoint is in an overlay section.
3849 Did we set a breakpoint at the LMA? */
3850 if (!overlay_events_enabled
)
3852 /* Yes -- overlay event support is not active, so we
3853 should have set a breakpoint at the LMA. Remove it.
3855 /* Ignore any failures: if the LMA is in ROM, we will
3856 have already warned when we failed to insert it. */
3857 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
3858 target_remove_hw_breakpoint (bl
->gdbarch
,
3859 &bl
->overlay_target_info
);
3861 target_remove_breakpoint (bl
->gdbarch
,
3862 &bl
->overlay_target_info
,
3865 /* Did we set a breakpoint at the VMA?
3866 If so, we will have marked the breakpoint 'inserted'. */
3869 /* Yes -- remove it. Previously we did not bother to
3870 remove the breakpoint if the section had been
3871 unmapped, but let's not rely on that being safe. We
3872 don't know what the overlay manager might do. */
3874 /* However, we should remove *software* breakpoints only
3875 if the section is still mapped, or else we overwrite
3876 wrong code with the saved shadow contents. */
3877 if (bl
->loc_type
== bp_loc_hardware_breakpoint
3878 || section_is_mapped (bl
->section
))
3879 val
= bl
->owner
->ops
->remove_location (bl
, reason
);
3885 /* No -- not inserted, so no need to remove. No error. */
3890 /* In some cases, we might not be able to remove a breakpoint in
3891 a shared library that has already been removed, but we have
3892 not yet processed the shlib unload event. Similarly for an
3893 unloaded add-symbol-file object - the user might not yet have
3894 had the chance to remove-symbol-file it. shlib_disabled will
3895 be set if the library/object has already been removed, but
3896 the breakpoint hasn't been uninserted yet, e.g., after
3897 "nosharedlibrary" or "remove-symbol-file" with breakpoints
3898 always-inserted mode. */
3900 && (bl
->loc_type
== bp_loc_software_breakpoint
3901 && (bl
->shlib_disabled
3902 || solib_name_from_address (bl
->pspace
, bl
->address
)
3903 || shared_objfile_contains_address_p (bl
->pspace
,
3909 bl
->inserted
= (reason
== DETACH_BREAKPOINT
);
3911 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
)
3913 gdb_assert (bl
->owner
->ops
!= NULL
3914 && bl
->owner
->ops
->remove_location
!= NULL
);
3916 bl
->inserted
= (reason
== DETACH_BREAKPOINT
);
3917 bl
->owner
->ops
->remove_location (bl
, reason
);
3919 /* Failure to remove any of the hardware watchpoints comes here. */
3920 if (reason
== REMOVE_BREAKPOINT
&& bl
->inserted
)
3921 warning (_("Could not remove hardware watchpoint %d."),
3924 else if (bl
->owner
->type
== bp_catchpoint
3925 && breakpoint_enabled (bl
->owner
)
3928 gdb_assert (bl
->owner
->ops
!= NULL
3929 && bl
->owner
->ops
->remove_location
!= NULL
);
3931 val
= bl
->owner
->ops
->remove_location (bl
, reason
);
3935 bl
->inserted
= (reason
== DETACH_BREAKPOINT
);
3942 remove_breakpoint (struct bp_location
*bl
)
3944 /* BL is never in moribund_locations by our callers. */
3945 gdb_assert (bl
->owner
!= NULL
);
3947 /* The type of none suggests that owner is actually deleted.
3948 This should not ever happen. */
3949 gdb_assert (bl
->owner
->type
!= bp_none
);
3951 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
3953 switch_to_program_space_and_thread (bl
->pspace
);
3955 return remove_breakpoint_1 (bl
, REMOVE_BREAKPOINT
);
3958 /* Clear the "inserted" flag in all breakpoints. */
3961 mark_breakpoints_out (void)
3963 struct bp_location
*bl
, **blp_tmp
;
3965 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3966 if (bl
->pspace
== current_program_space
)
3970 /* Clear the "inserted" flag in all breakpoints and delete any
3971 breakpoints which should go away between runs of the program.
3973 Plus other such housekeeping that has to be done for breakpoints
3976 Note: this function gets called at the end of a run (by
3977 generic_mourn_inferior) and when a run begins (by
3978 init_wait_for_inferior). */
3983 breakpoint_init_inferior (enum inf_context context
)
3985 struct breakpoint
*b
, *b_tmp
;
3986 struct bp_location
*bl
;
3988 struct program_space
*pspace
= current_program_space
;
3990 /* If breakpoint locations are shared across processes, then there's
3992 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
3995 mark_breakpoints_out ();
3997 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
3999 if (b
->loc
&& b
->loc
->pspace
!= pspace
)
4005 case bp_longjmp_call_dummy
:
4007 /* If the call dummy breakpoint is at the entry point it will
4008 cause problems when the inferior is rerun, so we better get
4011 case bp_watchpoint_scope
:
4013 /* Also get rid of scope breakpoints. */
4015 case bp_shlib_event
:
4017 /* Also remove solib event breakpoints. Their addresses may
4018 have changed since the last time we ran the program.
4019 Actually we may now be debugging against different target;
4020 and so the solib backend that installed this breakpoint may
4021 not be used in by the target. E.g.,
4023 (gdb) file prog-linux
4024 (gdb) run # native linux target
4027 (gdb) file prog-win.exe
4028 (gdb) tar rem :9999 # remote Windows gdbserver.
4031 case bp_step_resume
:
4033 /* Also remove step-resume breakpoints. */
4035 case bp_single_step
:
4037 /* Also remove single-step breakpoints. */
4039 delete_breakpoint (b
);
4043 case bp_hardware_watchpoint
:
4044 case bp_read_watchpoint
:
4045 case bp_access_watchpoint
:
4047 struct watchpoint
*w
= (struct watchpoint
*) b
;
4049 /* Likewise for watchpoints on local expressions. */
4050 if (w
->exp_valid_block
!= NULL
)
4051 delete_breakpoint (b
);
4054 /* Get rid of existing locations, which are no longer
4055 valid. New ones will be created in
4056 update_watchpoint, when the inferior is restarted.
4057 The next update_global_location_list call will
4058 garbage collect them. */
4061 if (context
== inf_starting
)
4063 /* Reset val field to force reread of starting value in
4064 insert_breakpoints. */
4066 value_free (w
->val
);
4078 /* Get rid of the moribund locations. */
4079 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, bl
); ++ix
)
4080 decref_bp_location (&bl
);
4081 VEC_free (bp_location_p
, moribund_locations
);
4084 /* These functions concern about actual breakpoints inserted in the
4085 target --- to e.g. check if we need to do decr_pc adjustment or if
4086 we need to hop over the bkpt --- so we check for address space
4087 match, not program space. */
4089 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
4090 exists at PC. It returns ordinary_breakpoint_here if it's an
4091 ordinary breakpoint, or permanent_breakpoint_here if it's a
4092 permanent breakpoint.
4093 - When continuing from a location with an ordinary breakpoint, we
4094 actually single step once before calling insert_breakpoints.
4095 - When continuing from a location with a permanent breakpoint, we
4096 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
4097 the target, to advance the PC past the breakpoint. */
4099 enum breakpoint_here
4100 breakpoint_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
4102 struct bp_location
*bl
, **blp_tmp
;
4103 int any_breakpoint_here
= 0;
4105 ALL_BP_LOCATIONS (bl
, blp_tmp
)
4107 if (bl
->loc_type
!= bp_loc_software_breakpoint
4108 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4111 /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
4112 if ((breakpoint_enabled (bl
->owner
)
4114 && breakpoint_location_address_match (bl
, aspace
, pc
))
4116 if (overlay_debugging
4117 && section_is_overlay (bl
->section
)
4118 && !section_is_mapped (bl
->section
))
4119 continue; /* unmapped overlay -- can't be a match */
4120 else if (bl
->permanent
)
4121 return permanent_breakpoint_here
;
4123 any_breakpoint_here
= 1;
4127 return any_breakpoint_here
? ordinary_breakpoint_here
: no_breakpoint_here
;
4130 /* See breakpoint.h. */
4133 breakpoint_in_range_p (struct address_space
*aspace
,
4134 CORE_ADDR addr
, ULONGEST len
)
4136 struct bp_location
*bl
, **blp_tmp
;
4138 ALL_BP_LOCATIONS (bl
, blp_tmp
)
4140 if (bl
->loc_type
!= bp_loc_software_breakpoint
4141 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4144 if ((breakpoint_enabled (bl
->owner
)
4146 && breakpoint_location_address_range_overlap (bl
, aspace
,
4149 if (overlay_debugging
4150 && section_is_overlay (bl
->section
)
4151 && !section_is_mapped (bl
->section
))
4153 /* Unmapped overlay -- can't be a match. */
4164 /* Return true if there's a moribund breakpoint at PC. */
4167 moribund_breakpoint_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
4169 struct bp_location
*loc
;
4172 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
4173 if (breakpoint_location_address_match (loc
, aspace
, pc
))
4179 /* Returns non-zero iff BL is inserted at PC, in address space
4183 bp_location_inserted_here_p (struct bp_location
*bl
,
4184 struct address_space
*aspace
, CORE_ADDR pc
)
4187 && breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
4190 if (overlay_debugging
4191 && section_is_overlay (bl
->section
)
4192 && !section_is_mapped (bl
->section
))
4193 return 0; /* unmapped overlay -- can't be a match */
4200 /* Returns non-zero iff there's a breakpoint inserted at PC. */
4203 breakpoint_inserted_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
4205 struct bp_location
**blp
, **blp_tmp
= NULL
;
4207 ALL_BP_LOCATIONS_AT_ADDR (blp
, blp_tmp
, pc
)
4209 struct bp_location
*bl
= *blp
;
4211 if (bl
->loc_type
!= bp_loc_software_breakpoint
4212 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4215 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4221 /* This function returns non-zero iff there is a software breakpoint
4225 software_breakpoint_inserted_here_p (struct address_space
*aspace
,
4228 struct bp_location
**blp
, **blp_tmp
= NULL
;
4230 ALL_BP_LOCATIONS_AT_ADDR (blp
, blp_tmp
, pc
)
4232 struct bp_location
*bl
= *blp
;
4234 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
4237 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4244 /* See breakpoint.h. */
4247 hardware_breakpoint_inserted_here_p (struct address_space
*aspace
,
4250 struct bp_location
**blp
, **blp_tmp
= NULL
;
4252 ALL_BP_LOCATIONS_AT_ADDR (blp
, blp_tmp
, pc
)
4254 struct bp_location
*bl
= *blp
;
4256 if (bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4259 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4267 hardware_watchpoint_inserted_in_range (struct address_space
*aspace
,
4268 CORE_ADDR addr
, ULONGEST len
)
4270 struct breakpoint
*bpt
;
4272 ALL_BREAKPOINTS (bpt
)
4274 struct bp_location
*loc
;
4276 if (bpt
->type
!= bp_hardware_watchpoint
4277 && bpt
->type
!= bp_access_watchpoint
)
4280 if (!breakpoint_enabled (bpt
))
4283 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
4284 if (loc
->pspace
->aspace
== aspace
&& loc
->inserted
)
4288 /* Check for intersection. */
4289 l
= std::max
<CORE_ADDR
> (loc
->address
, addr
);
4290 h
= std::min
<CORE_ADDR
> (loc
->address
+ loc
->length
, addr
+ len
);
4299 /* bpstat stuff. External routines' interfaces are documented
4303 is_catchpoint (struct breakpoint
*ep
)
4305 return (ep
->type
== bp_catchpoint
);
4308 /* Frees any storage that is part of a bpstat. Does not walk the
4311 bpstats::~bpstats ()
4313 if (old_val
!= NULL
)
4314 value_free (old_val
);
4315 if (bp_location_at
!= NULL
)
4316 decref_bp_location (&bp_location_at
);
4319 /* Clear a bpstat so that it says we are not at any breakpoint.
4320 Also free any storage that is part of a bpstat. */
4323 bpstat_clear (bpstat
*bsp
)
4340 bpstats::bpstats (const bpstats
&other
)
4342 bp_location_at (other
.bp_location_at
),
4343 breakpoint_at (other
.breakpoint_at
),
4344 commands (other
.commands
),
4345 old_val (other
.old_val
),
4346 print (other
.print
),
4348 print_it (other
.print_it
)
4350 if (old_val
!= NULL
)
4352 old_val
= value_copy (old_val
);
4353 release_value (old_val
);
4355 incref_bp_location (bp_location_at
);
4358 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
4359 is part of the bpstat is copied as well. */
4362 bpstat_copy (bpstat bs
)
4366 bpstat retval
= NULL
;
4371 for (; bs
!= NULL
; bs
= bs
->next
)
4373 tmp
= new bpstats (*bs
);
4376 /* This is the first thing in the chain. */
4386 /* Find the bpstat associated with this breakpoint. */
4389 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
4394 for (; bsp
!= NULL
; bsp
= bsp
->next
)
4396 if (bsp
->breakpoint_at
== breakpoint
)
4402 /* See breakpoint.h. */
4405 bpstat_explains_signal (bpstat bsp
, enum gdb_signal sig
)
4407 for (; bsp
!= NULL
; bsp
= bsp
->next
)
4409 if (bsp
->breakpoint_at
== NULL
)
4411 /* A moribund location can never explain a signal other than
4413 if (sig
== GDB_SIGNAL_TRAP
)
4418 if (bsp
->breakpoint_at
->ops
->explains_signal (bsp
->breakpoint_at
,
4427 /* Put in *NUM the breakpoint number of the first breakpoint we are
4428 stopped at. *BSP upon return is a bpstat which points to the
4429 remaining breakpoints stopped at (but which is not guaranteed to be
4430 good for anything but further calls to bpstat_num).
4432 Return 0 if passed a bpstat which does not indicate any breakpoints.
4433 Return -1 if stopped at a breakpoint that has been deleted since
4435 Return 1 otherwise. */
4438 bpstat_num (bpstat
*bsp
, int *num
)
4440 struct breakpoint
*b
;
4443 return 0; /* No more breakpoint values */
4445 /* We assume we'll never have several bpstats that correspond to a
4446 single breakpoint -- otherwise, this function might return the
4447 same number more than once and this will look ugly. */
4448 b
= (*bsp
)->breakpoint_at
;
4449 *bsp
= (*bsp
)->next
;
4451 return -1; /* breakpoint that's been deleted since */
4453 *num
= b
->number
; /* We have its number */
4457 /* See breakpoint.h. */
4460 bpstat_clear_actions (void)
4462 struct thread_info
*tp
;
4465 if (ptid_equal (inferior_ptid
, null_ptid
))
4468 tp
= find_thread_ptid (inferior_ptid
);
4472 for (bs
= tp
->control
.stop_bpstat
; bs
!= NULL
; bs
= bs
->next
)
4474 bs
->commands
= NULL
;
4476 if (bs
->old_val
!= NULL
)
4478 value_free (bs
->old_val
);
4484 /* Called when a command is about to proceed the inferior. */
4487 breakpoint_about_to_proceed (void)
4489 if (!ptid_equal (inferior_ptid
, null_ptid
))
4491 struct thread_info
*tp
= inferior_thread ();
4493 /* Allow inferior function calls in breakpoint commands to not
4494 interrupt the command list. When the call finishes
4495 successfully, the inferior will be standing at the same
4496 breakpoint as if nothing happened. */
4497 if (tp
->control
.in_infcall
)
4501 breakpoint_proceeded
= 1;
4504 /* Stub for cleaning up our state if we error-out of a breakpoint
4507 cleanup_executing_breakpoints (void *ignore
)
4509 executing_breakpoint_commands
= 0;
4512 /* Return non-zero iff CMD as the first line of a command sequence is `silent'
4513 or its equivalent. */
4516 command_line_is_silent (struct command_line
*cmd
)
4518 return cmd
&& (strcmp ("silent", cmd
->line
) == 0);
4521 /* Execute all the commands associated with all the breakpoints at
4522 this location. Any of these commands could cause the process to
4523 proceed beyond this point, etc. We look out for such changes by
4524 checking the global "breakpoint_proceeded" after each command.
4526 Returns true if a breakpoint command resumed the inferior. In that
4527 case, it is the caller's responsibility to recall it again with the
4528 bpstat of the current thread. */
4531 bpstat_do_actions_1 (bpstat
*bsp
)
4534 struct cleanup
*old_chain
;
4537 /* Avoid endless recursion if a `source' command is contained
4539 if (executing_breakpoint_commands
)
4542 executing_breakpoint_commands
= 1;
4543 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
4545 scoped_restore preventer
= prevent_dont_repeat ();
4547 /* This pointer will iterate over the list of bpstat's. */
4550 breakpoint_proceeded
= 0;
4551 for (; bs
!= NULL
; bs
= bs
->next
)
4553 struct command_line
*cmd
= NULL
;
4555 /* Take ownership of the BSP's command tree, if it has one.
4557 The command tree could legitimately contain commands like
4558 'step' and 'next', which call clear_proceed_status, which
4559 frees stop_bpstat's command tree. To make sure this doesn't
4560 free the tree we're executing out from under us, we need to
4561 take ownership of the tree ourselves. Since a given bpstat's
4562 commands are only executed once, we don't need to copy it; we
4563 can clear the pointer in the bpstat, and make sure we free
4564 the tree when we're done. */
4565 counted_command_line ccmd
= bs
->commands
;
4566 bs
->commands
= NULL
;
4569 if (command_line_is_silent (cmd
))
4571 /* The action has been already done by bpstat_stop_status. */
4577 execute_control_command (cmd
);
4579 if (breakpoint_proceeded
)
4585 if (breakpoint_proceeded
)
4587 if (current_ui
->async
)
4588 /* If we are in async mode, then the target might be still
4589 running, not stopped at any breakpoint, so nothing for
4590 us to do here -- just return to the event loop. */
4593 /* In sync mode, when execute_control_command returns
4594 we're already standing on the next breakpoint.
4595 Breakpoint commands for that stop were not run, since
4596 execute_command does not run breakpoint commands --
4597 only command_line_handler does, but that one is not
4598 involved in execution of breakpoint commands. So, we
4599 can now execute breakpoint commands. It should be
4600 noted that making execute_command do bpstat actions is
4601 not an option -- in this case we'll have recursive
4602 invocation of bpstat for each breakpoint with a
4603 command, and can easily blow up GDB stack. Instead, we
4604 return true, which will trigger the caller to recall us
4605 with the new stop_bpstat. */
4610 do_cleanups (old_chain
);
4615 bpstat_do_actions (void)
4617 struct cleanup
*cleanup_if_error
= make_bpstat_clear_actions_cleanup ();
4619 /* Do any commands attached to breakpoint we are stopped at. */
4620 while (!ptid_equal (inferior_ptid
, null_ptid
)
4621 && target_has_execution
4622 && !is_exited (inferior_ptid
)
4623 && !is_executing (inferior_ptid
))
4624 /* Since in sync mode, bpstat_do_actions may resume the inferior,
4625 and only return when it is stopped at the next breakpoint, we
4626 keep doing breakpoint actions until it returns false to
4627 indicate the inferior was not resumed. */
4628 if (!bpstat_do_actions_1 (&inferior_thread ()->control
.stop_bpstat
))
4631 discard_cleanups (cleanup_if_error
);
4634 /* Print out the (old or new) value associated with a watchpoint. */
4637 watchpoint_value_print (struct value
*val
, struct ui_file
*stream
)
4640 fprintf_unfiltered (stream
, _("<unreadable>"));
4643 struct value_print_options opts
;
4644 get_user_print_options (&opts
);
4645 value_print (val
, stream
, &opts
);
4649 /* Print the "Thread ID hit" part of "Thread ID hit Breakpoint N" if
4650 debugging multiple threads. */
4653 maybe_print_thread_hit_breakpoint (struct ui_out
*uiout
)
4655 if (uiout
->is_mi_like_p ())
4660 if (show_thread_that_caused_stop ())
4663 struct thread_info
*thr
= inferior_thread ();
4665 uiout
->text ("Thread ");
4666 uiout
->field_fmt ("thread-id", "%s", print_thread_id (thr
));
4668 name
= thr
->name
!= NULL
? thr
->name
: target_thread_name (thr
);
4671 uiout
->text (" \"");
4672 uiout
->field_fmt ("name", "%s", name
);
4676 uiout
->text (" hit ");
4680 /* Generic routine for printing messages indicating why we
4681 stopped. The behavior of this function depends on the value
4682 'print_it' in the bpstat structure. Under some circumstances we
4683 may decide not to print anything here and delegate the task to
4686 static enum print_stop_action
4687 print_bp_stop_message (bpstat bs
)
4689 switch (bs
->print_it
)
4692 /* Nothing should be printed for this bpstat entry. */
4693 return PRINT_UNKNOWN
;
4697 /* We still want to print the frame, but we already printed the
4698 relevant messages. */
4699 return PRINT_SRC_AND_LOC
;
4702 case print_it_normal
:
4704 struct breakpoint
*b
= bs
->breakpoint_at
;
4706 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
4707 which has since been deleted. */
4709 return PRINT_UNKNOWN
;
4711 /* Normal case. Call the breakpoint's print_it method. */
4712 return b
->ops
->print_it (bs
);
4717 internal_error (__FILE__
, __LINE__
,
4718 _("print_bp_stop_message: unrecognized enum value"));
4723 /* A helper function that prints a shared library stopped event. */
4726 print_solib_event (int is_catchpoint
)
4729 = !VEC_empty (char_ptr
, current_program_space
->deleted_solibs
);
4731 = !VEC_empty (so_list_ptr
, current_program_space
->added_solibs
);
4735 if (any_added
|| any_deleted
)
4736 current_uiout
->text (_("Stopped due to shared library event:\n"));
4738 current_uiout
->text (_("Stopped due to shared library event (no "
4739 "libraries added or removed)\n"));
4742 if (current_uiout
->is_mi_like_p ())
4743 current_uiout
->field_string ("reason",
4744 async_reason_lookup (EXEC_ASYNC_SOLIB_EVENT
));
4751 current_uiout
->text (_(" Inferior unloaded "));
4752 ui_out_emit_list
list_emitter (current_uiout
, "removed");
4754 VEC_iterate (char_ptr
, current_program_space
->deleted_solibs
,
4759 current_uiout
->text (" ");
4760 current_uiout
->field_string ("library", name
);
4761 current_uiout
->text ("\n");
4767 struct so_list
*iter
;
4770 current_uiout
->text (_(" Inferior loaded "));
4771 ui_out_emit_list
list_emitter (current_uiout
, "added");
4773 VEC_iterate (so_list_ptr
, current_program_space
->added_solibs
,
4778 current_uiout
->text (" ");
4779 current_uiout
->field_string ("library", iter
->so_name
);
4780 current_uiout
->text ("\n");
4785 /* Print a message indicating what happened. This is called from
4786 normal_stop(). The input to this routine is the head of the bpstat
4787 list - a list of the eventpoints that caused this stop. KIND is
4788 the target_waitkind for the stopping event. This
4789 routine calls the generic print routine for printing a message
4790 about reasons for stopping. This will print (for example) the
4791 "Breakpoint n," part of the output. The return value of this
4794 PRINT_UNKNOWN: Means we printed nothing.
4795 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
4796 code to print the location. An example is
4797 "Breakpoint 1, " which should be followed by
4799 PRINT_SRC_ONLY: Means we printed something, but there is no need
4800 to also print the location part of the message.
4801 An example is the catch/throw messages, which
4802 don't require a location appended to the end.
4803 PRINT_NOTHING: We have done some printing and we don't need any
4804 further info to be printed. */
4806 enum print_stop_action
4807 bpstat_print (bpstat bs
, int kind
)
4809 enum print_stop_action val
;
4811 /* Maybe another breakpoint in the chain caused us to stop.
4812 (Currently all watchpoints go on the bpstat whether hit or not.
4813 That probably could (should) be changed, provided care is taken
4814 with respect to bpstat_explains_signal). */
4815 for (; bs
; bs
= bs
->next
)
4817 val
= print_bp_stop_message (bs
);
4818 if (val
== PRINT_SRC_ONLY
4819 || val
== PRINT_SRC_AND_LOC
4820 || val
== PRINT_NOTHING
)
4824 /* If we had hit a shared library event breakpoint,
4825 print_bp_stop_message would print out this message. If we hit an
4826 OS-level shared library event, do the same thing. */
4827 if (kind
== TARGET_WAITKIND_LOADED
)
4829 print_solib_event (0);
4830 return PRINT_NOTHING
;
4833 /* We reached the end of the chain, or we got a null BS to start
4834 with and nothing was printed. */
4835 return PRINT_UNKNOWN
;
4838 /* Evaluate the boolean expression EXP and return the result. */
4841 breakpoint_cond_eval (expression
*exp
)
4843 struct value
*mark
= value_mark ();
4844 bool res
= value_true (evaluate_expression (exp
));
4846 value_free_to_mark (mark
);
4850 /* Allocate a new bpstat. Link it to the FIFO list by BS_LINK_POINTER. */
4852 bpstats::bpstats (struct bp_location
*bl
, bpstat
**bs_link_pointer
)
4854 bp_location_at (bl
),
4855 breakpoint_at (bl
->owner
),
4860 print_it (print_it_normal
)
4862 incref_bp_location (bl
);
4863 **bs_link_pointer
= this;
4864 *bs_link_pointer
= &next
;
4869 bp_location_at (NULL
),
4870 breakpoint_at (NULL
),
4875 print_it (print_it_normal
)
4879 /* The target has stopped with waitstatus WS. Check if any hardware
4880 watchpoints have triggered, according to the target. */
4883 watchpoints_triggered (struct target_waitstatus
*ws
)
4885 int stopped_by_watchpoint
= target_stopped_by_watchpoint ();
4887 struct breakpoint
*b
;
4889 if (!stopped_by_watchpoint
)
4891 /* We were not stopped by a watchpoint. Mark all watchpoints
4892 as not triggered. */
4894 if (is_hardware_watchpoint (b
))
4896 struct watchpoint
*w
= (struct watchpoint
*) b
;
4898 w
->watchpoint_triggered
= watch_triggered_no
;
4904 if (!target_stopped_data_address (¤t_target
, &addr
))
4906 /* We were stopped by a watchpoint, but we don't know where.
4907 Mark all watchpoints as unknown. */
4909 if (is_hardware_watchpoint (b
))
4911 struct watchpoint
*w
= (struct watchpoint
*) b
;
4913 w
->watchpoint_triggered
= watch_triggered_unknown
;
4919 /* The target could report the data address. Mark watchpoints
4920 affected by this data address as triggered, and all others as not
4924 if (is_hardware_watchpoint (b
))
4926 struct watchpoint
*w
= (struct watchpoint
*) b
;
4927 struct bp_location
*loc
;
4929 w
->watchpoint_triggered
= watch_triggered_no
;
4930 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
4932 if (is_masked_watchpoint (b
))
4934 CORE_ADDR newaddr
= addr
& w
->hw_wp_mask
;
4935 CORE_ADDR start
= loc
->address
& w
->hw_wp_mask
;
4937 if (newaddr
== start
)
4939 w
->watchpoint_triggered
= watch_triggered_yes
;
4943 /* Exact match not required. Within range is sufficient. */
4944 else if (target_watchpoint_addr_within_range (¤t_target
,
4948 w
->watchpoint_triggered
= watch_triggered_yes
;
4957 /* Possible return values for watchpoint_check. */
4958 enum wp_check_result
4960 /* The watchpoint has been deleted. */
4963 /* The value has changed. */
4964 WP_VALUE_CHANGED
= 2,
4966 /* The value has not changed. */
4967 WP_VALUE_NOT_CHANGED
= 3,
4969 /* Ignore this watchpoint, no matter if the value changed or not. */
4973 #define BP_TEMPFLAG 1
4974 #define BP_HARDWAREFLAG 2
4976 /* Evaluate watchpoint condition expression and check if its value
4979 static wp_check_result
4980 watchpoint_check (bpstat bs
)
4982 struct watchpoint
*b
;
4983 struct frame_info
*fr
;
4984 int within_current_scope
;
4986 /* BS is built from an existing struct breakpoint. */
4987 gdb_assert (bs
->breakpoint_at
!= NULL
);
4988 b
= (struct watchpoint
*) bs
->breakpoint_at
;
4990 /* If this is a local watchpoint, we only want to check if the
4991 watchpoint frame is in scope if the current thread is the thread
4992 that was used to create the watchpoint. */
4993 if (!watchpoint_in_thread_scope (b
))
4996 if (b
->exp_valid_block
== NULL
)
4997 within_current_scope
= 1;
5000 struct frame_info
*frame
= get_current_frame ();
5001 struct gdbarch
*frame_arch
= get_frame_arch (frame
);
5002 CORE_ADDR frame_pc
= get_frame_pc (frame
);
5004 /* stack_frame_destroyed_p() returns a non-zero value if we're
5005 still in the function but the stack frame has already been
5006 invalidated. Since we can't rely on the values of local
5007 variables after the stack has been destroyed, we are treating
5008 the watchpoint in that state as `not changed' without further
5009 checking. Don't mark watchpoints as changed if the current
5010 frame is in an epilogue - even if they are in some other
5011 frame, our view of the stack is likely to be wrong and
5012 frame_find_by_id could error out. */
5013 if (gdbarch_stack_frame_destroyed_p (frame_arch
, frame_pc
))
5016 fr
= frame_find_by_id (b
->watchpoint_frame
);
5017 within_current_scope
= (fr
!= NULL
);
5019 /* If we've gotten confused in the unwinder, we might have
5020 returned a frame that can't describe this variable. */
5021 if (within_current_scope
)
5023 struct symbol
*function
;
5025 function
= get_frame_function (fr
);
5026 if (function
== NULL
5027 || !contained_in (b
->exp_valid_block
,
5028 SYMBOL_BLOCK_VALUE (function
)))
5029 within_current_scope
= 0;
5032 if (within_current_scope
)
5033 /* If we end up stopping, the current frame will get selected
5034 in normal_stop. So this call to select_frame won't affect
5039 if (within_current_scope
)
5041 /* We use value_{,free_to_}mark because it could be a *long*
5042 time before we return to the command level and call
5043 free_all_values. We can't call free_all_values because we
5044 might be in the middle of evaluating a function call. */
5048 struct value
*new_val
;
5050 if (is_masked_watchpoint (b
))
5051 /* Since we don't know the exact trigger address (from
5052 stopped_data_address), just tell the user we've triggered
5053 a mask watchpoint. */
5054 return WP_VALUE_CHANGED
;
5056 mark
= value_mark ();
5057 fetch_subexp_value (b
->exp
.get (), &pc
, &new_val
, NULL
, NULL
, 0);
5059 if (b
->val_bitsize
!= 0)
5060 new_val
= extract_bitfield_from_watchpoint_value (b
, new_val
);
5062 /* We use value_equal_contents instead of value_equal because
5063 the latter coerces an array to a pointer, thus comparing just
5064 the address of the array instead of its contents. This is
5065 not what we want. */
5066 if ((b
->val
!= NULL
) != (new_val
!= NULL
)
5067 || (b
->val
!= NULL
&& !value_equal_contents (b
->val
, new_val
)))
5069 if (new_val
!= NULL
)
5071 release_value (new_val
);
5072 value_free_to_mark (mark
);
5074 bs
->old_val
= b
->val
;
5077 return WP_VALUE_CHANGED
;
5081 /* Nothing changed. */
5082 value_free_to_mark (mark
);
5083 return WP_VALUE_NOT_CHANGED
;
5088 /* This seems like the only logical thing to do because
5089 if we temporarily ignored the watchpoint, then when
5090 we reenter the block in which it is valid it contains
5091 garbage (in the case of a function, it may have two
5092 garbage values, one before and one after the prologue).
5093 So we can't even detect the first assignment to it and
5094 watch after that (since the garbage may or may not equal
5095 the first value assigned). */
5096 /* We print all the stop information in
5097 breakpoint_ops->print_it, but in this case, by the time we
5098 call breakpoint_ops->print_it this bp will be deleted
5099 already. So we have no choice but print the information
5102 SWITCH_THRU_ALL_UIS ()
5104 struct ui_out
*uiout
= current_uiout
;
5106 if (uiout
->is_mi_like_p ())
5108 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
5109 uiout
->text ("\nWatchpoint ");
5110 uiout
->field_int ("wpnum", b
->number
);
5111 uiout
->text (" deleted because the program has left the block in\n"
5112 "which its expression is valid.\n");
5115 /* Make sure the watchpoint's commands aren't executed. */
5117 watchpoint_del_at_next_stop (b
);
5123 /* Return true if it looks like target has stopped due to hitting
5124 breakpoint location BL. This function does not check if we should
5125 stop, only if BL explains the stop. */
5128 bpstat_check_location (const struct bp_location
*bl
,
5129 struct address_space
*aspace
, CORE_ADDR bp_addr
,
5130 const struct target_waitstatus
*ws
)
5132 struct breakpoint
*b
= bl
->owner
;
5134 /* BL is from an existing breakpoint. */
5135 gdb_assert (b
!= NULL
);
5137 return b
->ops
->breakpoint_hit (bl
, aspace
, bp_addr
, ws
);
5140 /* Determine if the watched values have actually changed, and we
5141 should stop. If not, set BS->stop to 0. */
5144 bpstat_check_watchpoint (bpstat bs
)
5146 const struct bp_location
*bl
;
5147 struct watchpoint
*b
;
5149 /* BS is built for existing struct breakpoint. */
5150 bl
= bs
->bp_location_at
;
5151 gdb_assert (bl
!= NULL
);
5152 b
= (struct watchpoint
*) bs
->breakpoint_at
;
5153 gdb_assert (b
!= NULL
);
5156 int must_check_value
= 0;
5158 if (b
->type
== bp_watchpoint
)
5159 /* For a software watchpoint, we must always check the
5161 must_check_value
= 1;
5162 else if (b
->watchpoint_triggered
== watch_triggered_yes
)
5163 /* We have a hardware watchpoint (read, write, or access)
5164 and the target earlier reported an address watched by
5166 must_check_value
= 1;
5167 else if (b
->watchpoint_triggered
== watch_triggered_unknown
5168 && b
->type
== bp_hardware_watchpoint
)
5169 /* We were stopped by a hardware watchpoint, but the target could
5170 not report the data address. We must check the watchpoint's
5171 value. Access and read watchpoints are out of luck; without
5172 a data address, we can't figure it out. */
5173 must_check_value
= 1;
5175 if (must_check_value
)
5181 e
= watchpoint_check (bs
);
5183 CATCH (ex
, RETURN_MASK_ALL
)
5185 exception_fprintf (gdb_stderr
, ex
,
5186 "Error evaluating expression "
5187 "for watchpoint %d\n",
5190 SWITCH_THRU_ALL_UIS ()
5192 printf_filtered (_("Watchpoint %d deleted.\n"),
5195 watchpoint_del_at_next_stop (b
);
5203 /* We've already printed what needs to be printed. */
5204 bs
->print_it
= print_it_done
;
5208 bs
->print_it
= print_it_noop
;
5211 case WP_VALUE_CHANGED
:
5212 if (b
->type
== bp_read_watchpoint
)
5214 /* There are two cases to consider here:
5216 1. We're watching the triggered memory for reads.
5217 In that case, trust the target, and always report
5218 the watchpoint hit to the user. Even though
5219 reads don't cause value changes, the value may
5220 have changed since the last time it was read, and
5221 since we're not trapping writes, we will not see
5222 those, and as such we should ignore our notion of
5225 2. We're watching the triggered memory for both
5226 reads and writes. There are two ways this may
5229 2.1. This is a target that can't break on data
5230 reads only, but can break on accesses (reads or
5231 writes), such as e.g., x86. We detect this case
5232 at the time we try to insert read watchpoints.
5234 2.2. Otherwise, the target supports read
5235 watchpoints, but, the user set an access or write
5236 watchpoint watching the same memory as this read
5239 If we're watching memory writes as well as reads,
5240 ignore watchpoint hits when we find that the
5241 value hasn't changed, as reads don't cause
5242 changes. This still gives false positives when
5243 the program writes the same value to memory as
5244 what there was already in memory (we will confuse
5245 it for a read), but it's much better than
5248 int other_write_watchpoint
= 0;
5250 if (bl
->watchpoint_type
== hw_read
)
5252 struct breakpoint
*other_b
;
5254 ALL_BREAKPOINTS (other_b
)
5255 if (other_b
->type
== bp_hardware_watchpoint
5256 || other_b
->type
== bp_access_watchpoint
)
5258 struct watchpoint
*other_w
=
5259 (struct watchpoint
*) other_b
;
5261 if (other_w
->watchpoint_triggered
5262 == watch_triggered_yes
)
5264 other_write_watchpoint
= 1;
5270 if (other_write_watchpoint
5271 || bl
->watchpoint_type
== hw_access
)
5273 /* We're watching the same memory for writes,
5274 and the value changed since the last time we
5275 updated it, so this trap must be for a write.
5277 bs
->print_it
= print_it_noop
;
5282 case WP_VALUE_NOT_CHANGED
:
5283 if (b
->type
== bp_hardware_watchpoint
5284 || b
->type
== bp_watchpoint
)
5286 /* Don't stop: write watchpoints shouldn't fire if
5287 the value hasn't changed. */
5288 bs
->print_it
= print_it_noop
;
5298 else /* must_check_value == 0 */
5300 /* This is a case where some watchpoint(s) triggered, but
5301 not at the address of this watchpoint, or else no
5302 watchpoint triggered after all. So don't print
5303 anything for this watchpoint. */
5304 bs
->print_it
= print_it_noop
;
5310 /* For breakpoints that are currently marked as telling gdb to stop,
5311 check conditions (condition proper, frame, thread and ignore count)
5312 of breakpoint referred to by BS. If we should not stop for this
5313 breakpoint, set BS->stop to 0. */
5316 bpstat_check_breakpoint_conditions (bpstat bs
, ptid_t ptid
)
5318 const struct bp_location
*bl
;
5319 struct breakpoint
*b
;
5321 bool condition_result
= true;
5322 struct expression
*cond
;
5324 gdb_assert (bs
->stop
);
5326 /* BS is built for existing struct breakpoint. */
5327 bl
= bs
->bp_location_at
;
5328 gdb_assert (bl
!= NULL
);
5329 b
= bs
->breakpoint_at
;
5330 gdb_assert (b
!= NULL
);
5332 /* Even if the target evaluated the condition on its end and notified GDB, we
5333 need to do so again since GDB does not know if we stopped due to a
5334 breakpoint or a single step breakpoint. */
5336 if (frame_id_p (b
->frame_id
)
5337 && !frame_id_eq (b
->frame_id
, get_stack_frame_id (get_current_frame ())))
5343 /* If this is a thread/task-specific breakpoint, don't waste cpu
5344 evaluating the condition if this isn't the specified
5346 if ((b
->thread
!= -1 && b
->thread
!= ptid_to_global_thread_id (ptid
))
5347 || (b
->task
!= 0 && b
->task
!= ada_get_task_number (ptid
)))
5354 /* Evaluate extension language breakpoints that have a "stop" method
5356 bs
->stop
= breakpoint_ext_lang_cond_says_stop (b
);
5358 if (is_watchpoint (b
))
5360 struct watchpoint
*w
= (struct watchpoint
*) b
;
5362 cond
= w
->cond_exp
.get ();
5365 cond
= bl
->cond
.get ();
5367 if (cond
&& b
->disposition
!= disp_del_at_next_stop
)
5369 int within_current_scope
= 1;
5370 struct watchpoint
* w
;
5372 /* We use value_mark and value_free_to_mark because it could
5373 be a long time before we return to the command level and
5374 call free_all_values. We can't call free_all_values
5375 because we might be in the middle of evaluating a
5377 struct value
*mark
= value_mark ();
5379 if (is_watchpoint (b
))
5380 w
= (struct watchpoint
*) b
;
5384 /* Need to select the frame, with all that implies so that
5385 the conditions will have the right context. Because we
5386 use the frame, we will not see an inlined function's
5387 variables when we arrive at a breakpoint at the start
5388 of the inlined function; the current frame will be the
5390 if (w
== NULL
|| w
->cond_exp_valid_block
== NULL
)
5391 select_frame (get_current_frame ());
5394 struct frame_info
*frame
;
5396 /* For local watchpoint expressions, which particular
5397 instance of a local is being watched matters, so we
5398 keep track of the frame to evaluate the expression
5399 in. To evaluate the condition however, it doesn't
5400 really matter which instantiation of the function
5401 where the condition makes sense triggers the
5402 watchpoint. This allows an expression like "watch
5403 global if q > 10" set in `func', catch writes to
5404 global on all threads that call `func', or catch
5405 writes on all recursive calls of `func' by a single
5406 thread. We simply always evaluate the condition in
5407 the innermost frame that's executing where it makes
5408 sense to evaluate the condition. It seems
5410 frame
= block_innermost_frame (w
->cond_exp_valid_block
);
5412 select_frame (frame
);
5414 within_current_scope
= 0;
5416 if (within_current_scope
)
5420 condition_result
= breakpoint_cond_eval (cond
);
5422 CATCH (ex
, RETURN_MASK_ALL
)
5424 exception_fprintf (gdb_stderr
, ex
,
5425 "Error in testing breakpoint condition:\n");
5431 warning (_("Watchpoint condition cannot be tested "
5432 "in the current scope"));
5433 /* If we failed to set the right context for this
5434 watchpoint, unconditionally report it. */
5436 /* FIXME-someday, should give breakpoint #. */
5437 value_free_to_mark (mark
);
5440 if (cond
&& !condition_result
)
5444 else if (b
->ignore_count
> 0)
5448 /* Increase the hit count even though we don't stop. */
5450 observer_notify_breakpoint_modified (b
);
5454 /* Returns true if we need to track moribund locations of LOC's type
5455 on the current target. */
5458 need_moribund_for_location_type (struct bp_location
*loc
)
5460 return ((loc
->loc_type
== bp_loc_software_breakpoint
5461 && !target_supports_stopped_by_sw_breakpoint ())
5462 || (loc
->loc_type
== bp_loc_hardware_breakpoint
5463 && !target_supports_stopped_by_hw_breakpoint ()));
5467 /* Get a bpstat associated with having just stopped at address
5468 BP_ADDR in thread PTID.
5470 Determine whether we stopped at a breakpoint, etc, or whether we
5471 don't understand this stop. Result is a chain of bpstat's such
5474 if we don't understand the stop, the result is a null pointer.
5476 if we understand why we stopped, the result is not null.
5478 Each element of the chain refers to a particular breakpoint or
5479 watchpoint at which we have stopped. (We may have stopped for
5480 several reasons concurrently.)
5482 Each element of the chain has valid next, breakpoint_at,
5483 commands, FIXME??? fields. */
5486 bpstat_stop_status (struct address_space
*aspace
,
5487 CORE_ADDR bp_addr
, ptid_t ptid
,
5488 const struct target_waitstatus
*ws
)
5490 struct breakpoint
*b
= NULL
;
5491 struct bp_location
*bl
;
5492 struct bp_location
*loc
;
5493 /* First item of allocated bpstat's. */
5494 bpstat bs_head
= NULL
, *bs_link
= &bs_head
;
5495 /* Pointer to the last thing in the chain currently. */
5498 int need_remove_insert
;
5501 /* First, build the bpstat chain with locations that explain a
5502 target stop, while being careful to not set the target running,
5503 as that may invalidate locations (in particular watchpoint
5504 locations are recreated). Resuming will happen here with
5505 breakpoint conditions or watchpoint expressions that include
5506 inferior function calls. */
5510 if (!breakpoint_enabled (b
))
5513 for (bl
= b
->loc
; bl
!= NULL
; bl
= bl
->next
)
5515 /* For hardware watchpoints, we look only at the first
5516 location. The watchpoint_check function will work on the
5517 entire expression, not the individual locations. For
5518 read watchpoints, the watchpoints_triggered function has
5519 checked all locations already. */
5520 if (b
->type
== bp_hardware_watchpoint
&& bl
!= b
->loc
)
5523 if (!bl
->enabled
|| bl
->shlib_disabled
)
5526 if (!bpstat_check_location (bl
, aspace
, bp_addr
, ws
))
5529 /* Come here if it's a watchpoint, or if the break address
5532 bs
= new bpstats (bl
, &bs_link
); /* Alloc a bpstat to
5535 /* Assume we stop. Should we find a watchpoint that is not
5536 actually triggered, or if the condition of the breakpoint
5537 evaluates as false, we'll reset 'stop' to 0. */
5541 /* If this is a scope breakpoint, mark the associated
5542 watchpoint as triggered so that we will handle the
5543 out-of-scope event. We'll get to the watchpoint next
5545 if (b
->type
== bp_watchpoint_scope
&& b
->related_breakpoint
!= b
)
5547 struct watchpoint
*w
= (struct watchpoint
*) b
->related_breakpoint
;
5549 w
->watchpoint_triggered
= watch_triggered_yes
;
5554 /* Check if a moribund breakpoint explains the stop. */
5555 if (!target_supports_stopped_by_sw_breakpoint ()
5556 || !target_supports_stopped_by_hw_breakpoint ())
5558 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
5560 if (breakpoint_location_address_match (loc
, aspace
, bp_addr
)
5561 && need_moribund_for_location_type (loc
))
5563 bs
= new bpstats (loc
, &bs_link
);
5564 /* For hits of moribund locations, we should just proceed. */
5567 bs
->print_it
= print_it_noop
;
5572 /* A bit of special processing for shlib breakpoints. We need to
5573 process solib loading here, so that the lists of loaded and
5574 unloaded libraries are correct before we handle "catch load" and
5576 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5578 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->type
== bp_shlib_event
)
5580 handle_solib_event ();
5585 /* Now go through the locations that caused the target to stop, and
5586 check whether we're interested in reporting this stop to higher
5587 layers, or whether we should resume the target transparently. */
5591 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5596 b
= bs
->breakpoint_at
;
5597 b
->ops
->check_status (bs
);
5600 bpstat_check_breakpoint_conditions (bs
, ptid
);
5605 observer_notify_breakpoint_modified (b
);
5607 /* We will stop here. */
5608 if (b
->disposition
== disp_disable
)
5610 --(b
->enable_count
);
5611 if (b
->enable_count
<= 0)
5612 b
->enable_state
= bp_disabled
;
5617 bs
->commands
= b
->commands
;
5618 if (command_line_is_silent (bs
->commands
5619 ? bs
->commands
.get () : NULL
))
5622 b
->ops
->after_condition_true (bs
);
5627 /* Print nothing for this entry if we don't stop or don't
5629 if (!bs
->stop
|| !bs
->print
)
5630 bs
->print_it
= print_it_noop
;
5633 /* If we aren't stopping, the value of some hardware watchpoint may
5634 not have changed, but the intermediate memory locations we are
5635 watching may have. Don't bother if we're stopping; this will get
5637 need_remove_insert
= 0;
5638 if (! bpstat_causes_stop (bs_head
))
5639 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5641 && bs
->breakpoint_at
5642 && is_hardware_watchpoint (bs
->breakpoint_at
))
5644 struct watchpoint
*w
= (struct watchpoint
*) bs
->breakpoint_at
;
5646 update_watchpoint (w
, 0 /* don't reparse. */);
5647 need_remove_insert
= 1;
5650 if (need_remove_insert
)
5651 update_global_location_list (UGLL_MAY_INSERT
);
5652 else if (removed_any
)
5653 update_global_location_list (UGLL_DONT_INSERT
);
5659 handle_jit_event (void)
5661 struct frame_info
*frame
;
5662 struct gdbarch
*gdbarch
;
5665 fprintf_unfiltered (gdb_stdlog
, "handling bp_jit_event\n");
5667 /* Switch terminal for any messages produced by
5668 breakpoint_re_set. */
5669 target_terminal::ours_for_output ();
5671 frame
= get_current_frame ();
5672 gdbarch
= get_frame_arch (frame
);
5674 jit_event_handler (gdbarch
);
5676 target_terminal::inferior ();
5679 /* Prepare WHAT final decision for infrun. */
5681 /* Decide what infrun needs to do with this bpstat. */
5684 bpstat_what (bpstat bs_head
)
5686 struct bpstat_what retval
;
5689 retval
.main_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5690 retval
.call_dummy
= STOP_NONE
;
5691 retval
.is_longjmp
= 0;
5693 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5695 /* Extract this BS's action. After processing each BS, we check
5696 if its action overrides all we've seem so far. */
5697 enum bpstat_what_main_action this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5700 if (bs
->breakpoint_at
== NULL
)
5702 /* I suspect this can happen if it was a momentary
5703 breakpoint which has since been deleted. */
5707 bptype
= bs
->breakpoint_at
->type
;
5714 case bp_hardware_breakpoint
:
5715 case bp_single_step
:
5718 case bp_shlib_event
:
5722 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5724 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5727 this_action
= BPSTAT_WHAT_SINGLE
;
5730 case bp_hardware_watchpoint
:
5731 case bp_read_watchpoint
:
5732 case bp_access_watchpoint
:
5736 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5738 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5742 /* There was a watchpoint, but we're not stopping.
5743 This requires no further action. */
5747 case bp_longjmp_call_dummy
:
5751 this_action
= BPSTAT_WHAT_SET_LONGJMP_RESUME
;
5752 retval
.is_longjmp
= bptype
!= bp_exception
;
5755 this_action
= BPSTAT_WHAT_SINGLE
;
5757 case bp_longjmp_resume
:
5758 case bp_exception_resume
:
5761 this_action
= BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
;
5762 retval
.is_longjmp
= bptype
== bp_longjmp_resume
;
5765 this_action
= BPSTAT_WHAT_SINGLE
;
5767 case bp_step_resume
:
5769 this_action
= BPSTAT_WHAT_STEP_RESUME
;
5772 /* It is for the wrong frame. */
5773 this_action
= BPSTAT_WHAT_SINGLE
;
5776 case bp_hp_step_resume
:
5778 this_action
= BPSTAT_WHAT_HP_STEP_RESUME
;
5781 /* It is for the wrong frame. */
5782 this_action
= BPSTAT_WHAT_SINGLE
;
5785 case bp_watchpoint_scope
:
5786 case bp_thread_event
:
5787 case bp_overlay_event
:
5788 case bp_longjmp_master
:
5789 case bp_std_terminate_master
:
5790 case bp_exception_master
:
5791 this_action
= BPSTAT_WHAT_SINGLE
;
5797 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5799 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5803 /* There was a catchpoint, but we're not stopping.
5804 This requires no further action. */
5808 this_action
= BPSTAT_WHAT_SINGLE
;
5811 /* Make sure the action is stop (silent or noisy),
5812 so infrun.c pops the dummy frame. */
5813 retval
.call_dummy
= STOP_STACK_DUMMY
;
5814 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5816 case bp_std_terminate
:
5817 /* Make sure the action is stop (silent or noisy),
5818 so infrun.c pops the dummy frame. */
5819 retval
.call_dummy
= STOP_STD_TERMINATE
;
5820 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5823 case bp_fast_tracepoint
:
5824 case bp_static_tracepoint
:
5825 /* Tracepoint hits should not be reported back to GDB, and
5826 if one got through somehow, it should have been filtered
5828 internal_error (__FILE__
, __LINE__
,
5829 _("bpstat_what: tracepoint encountered"));
5831 case bp_gnu_ifunc_resolver
:
5832 /* Step over it (and insert bp_gnu_ifunc_resolver_return). */
5833 this_action
= BPSTAT_WHAT_SINGLE
;
5835 case bp_gnu_ifunc_resolver_return
:
5836 /* The breakpoint will be removed, execution will restart from the
5837 PC of the former breakpoint. */
5838 this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5843 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5845 this_action
= BPSTAT_WHAT_SINGLE
;
5849 internal_error (__FILE__
, __LINE__
,
5850 _("bpstat_what: unhandled bptype %d"), (int) bptype
);
5853 retval
.main_action
= std::max (retval
.main_action
, this_action
);
5860 bpstat_run_callbacks (bpstat bs_head
)
5864 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5866 struct breakpoint
*b
= bs
->breakpoint_at
;
5873 handle_jit_event ();
5875 case bp_gnu_ifunc_resolver
:
5876 gnu_ifunc_resolver_stop (b
);
5878 case bp_gnu_ifunc_resolver_return
:
5879 gnu_ifunc_resolver_return_stop (b
);
5885 /* Nonzero if we should step constantly (e.g. watchpoints on machines
5886 without hardware support). This isn't related to a specific bpstat,
5887 just to things like whether watchpoints are set. */
5890 bpstat_should_step (void)
5892 struct breakpoint
*b
;
5895 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
&& b
->loc
!= NULL
)
5901 bpstat_causes_stop (bpstat bs
)
5903 for (; bs
!= NULL
; bs
= bs
->next
)
5912 /* Compute a string of spaces suitable to indent the next line
5913 so it starts at the position corresponding to the table column
5914 named COL_NAME in the currently active table of UIOUT. */
5917 wrap_indent_at_field (struct ui_out
*uiout
, const char *col_name
)
5919 static char wrap_indent
[80];
5920 int i
, total_width
, width
, align
;
5924 for (i
= 1; uiout
->query_table_field (i
, &width
, &align
, &text
); i
++)
5926 if (strcmp (text
, col_name
) == 0)
5928 gdb_assert (total_width
< sizeof wrap_indent
);
5929 memset (wrap_indent
, ' ', total_width
);
5930 wrap_indent
[total_width
] = 0;
5935 total_width
+= width
+ 1;
5941 /* Determine if the locations of this breakpoint will have their conditions
5942 evaluated by the target, host or a mix of both. Returns the following:
5944 "host": Host evals condition.
5945 "host or target": Host or Target evals condition.
5946 "target": Target evals condition.
5950 bp_condition_evaluator (struct breakpoint
*b
)
5952 struct bp_location
*bl
;
5953 char host_evals
= 0;
5954 char target_evals
= 0;
5959 if (!is_breakpoint (b
))
5962 if (gdb_evaluates_breakpoint_condition_p ()
5963 || !target_supports_evaluation_of_breakpoint_conditions ())
5964 return condition_evaluation_host
;
5966 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
5968 if (bl
->cond_bytecode
)
5974 if (host_evals
&& target_evals
)
5975 return condition_evaluation_both
;
5976 else if (target_evals
)
5977 return condition_evaluation_target
;
5979 return condition_evaluation_host
;
5982 /* Determine the breakpoint location's condition evaluator. This is
5983 similar to bp_condition_evaluator, but for locations. */
5986 bp_location_condition_evaluator (struct bp_location
*bl
)
5988 if (bl
&& !is_breakpoint (bl
->owner
))
5991 if (gdb_evaluates_breakpoint_condition_p ()
5992 || !target_supports_evaluation_of_breakpoint_conditions ())
5993 return condition_evaluation_host
;
5995 if (bl
&& bl
->cond_bytecode
)
5996 return condition_evaluation_target
;
5998 return condition_evaluation_host
;
6001 /* Print the LOC location out of the list of B->LOC locations. */
6004 print_breakpoint_location (struct breakpoint
*b
,
6005 struct bp_location
*loc
)
6007 struct ui_out
*uiout
= current_uiout
;
6009 scoped_restore_current_program_space restore_pspace
;
6011 if (loc
!= NULL
&& loc
->shlib_disabled
)
6015 set_current_program_space (loc
->pspace
);
6017 if (b
->display_canonical
)
6018 uiout
->field_string ("what", event_location_to_string (b
->location
.get ()));
6019 else if (loc
&& loc
->symtab
)
6022 = find_pc_sect_function (loc
->address
, loc
->section
);
6025 uiout
->text ("in ");
6026 uiout
->field_string ("func", SYMBOL_PRINT_NAME (sym
));
6028 uiout
->wrap_hint (wrap_indent_at_field (uiout
, "what"));
6029 uiout
->text ("at ");
6031 uiout
->field_string ("file",
6032 symtab_to_filename_for_display (loc
->symtab
));
6035 if (uiout
->is_mi_like_p ())
6036 uiout
->field_string ("fullname", symtab_to_fullname (loc
->symtab
));
6038 uiout
->field_int ("line", loc
->line_number
);
6044 print_address_symbolic (loc
->gdbarch
, loc
->address
, &stb
,
6046 uiout
->field_stream ("at", stb
);
6050 uiout
->field_string ("pending",
6051 event_location_to_string (b
->location
.get ()));
6052 /* If extra_string is available, it could be holding a condition
6053 or dprintf arguments. In either case, make sure it is printed,
6054 too, but only for non-MI streams. */
6055 if (!uiout
->is_mi_like_p () && b
->extra_string
!= NULL
)
6057 if (b
->type
== bp_dprintf
)
6061 uiout
->text (b
->extra_string
);
6065 if (loc
&& is_breakpoint (b
)
6066 && breakpoint_condition_evaluation_mode () == condition_evaluation_target
6067 && bp_condition_evaluator (b
) == condition_evaluation_both
)
6070 uiout
->field_string ("evaluated-by",
6071 bp_location_condition_evaluator (loc
));
6077 bptype_string (enum bptype type
)
6079 struct ep_type_description
6082 const char *description
;
6084 static struct ep_type_description bptypes
[] =
6086 {bp_none
, "?deleted?"},
6087 {bp_breakpoint
, "breakpoint"},
6088 {bp_hardware_breakpoint
, "hw breakpoint"},
6089 {bp_single_step
, "sw single-step"},
6090 {bp_until
, "until"},
6091 {bp_finish
, "finish"},
6092 {bp_watchpoint
, "watchpoint"},
6093 {bp_hardware_watchpoint
, "hw watchpoint"},
6094 {bp_read_watchpoint
, "read watchpoint"},
6095 {bp_access_watchpoint
, "acc watchpoint"},
6096 {bp_longjmp
, "longjmp"},
6097 {bp_longjmp_resume
, "longjmp resume"},
6098 {bp_longjmp_call_dummy
, "longjmp for call dummy"},
6099 {bp_exception
, "exception"},
6100 {bp_exception_resume
, "exception resume"},
6101 {bp_step_resume
, "step resume"},
6102 {bp_hp_step_resume
, "high-priority step resume"},
6103 {bp_watchpoint_scope
, "watchpoint scope"},
6104 {bp_call_dummy
, "call dummy"},
6105 {bp_std_terminate
, "std::terminate"},
6106 {bp_shlib_event
, "shlib events"},
6107 {bp_thread_event
, "thread events"},
6108 {bp_overlay_event
, "overlay events"},
6109 {bp_longjmp_master
, "longjmp master"},
6110 {bp_std_terminate_master
, "std::terminate master"},
6111 {bp_exception_master
, "exception master"},
6112 {bp_catchpoint
, "catchpoint"},
6113 {bp_tracepoint
, "tracepoint"},
6114 {bp_fast_tracepoint
, "fast tracepoint"},
6115 {bp_static_tracepoint
, "static tracepoint"},
6116 {bp_dprintf
, "dprintf"},
6117 {bp_jit_event
, "jit events"},
6118 {bp_gnu_ifunc_resolver
, "STT_GNU_IFUNC resolver"},
6119 {bp_gnu_ifunc_resolver_return
, "STT_GNU_IFUNC resolver return"},
6122 if (((int) type
>= (sizeof (bptypes
) / sizeof (bptypes
[0])))
6123 || ((int) type
!= bptypes
[(int) type
].type
))
6124 internal_error (__FILE__
, __LINE__
,
6125 _("bptypes table does not describe type #%d."),
6128 return bptypes
[(int) type
].description
;
6131 /* For MI, output a field named 'thread-groups' with a list as the value.
6132 For CLI, prefix the list with the string 'inf'. */
6135 output_thread_groups (struct ui_out
*uiout
,
6136 const char *field_name
,
6140 int is_mi
= uiout
->is_mi_like_p ();
6144 /* For backward compatibility, don't display inferiors in CLI unless
6145 there are several. Always display them for MI. */
6146 if (!is_mi
&& mi_only
)
6149 ui_out_emit_list
list_emitter (uiout
, field_name
);
6151 for (i
= 0; VEC_iterate (int, inf_num
, i
, inf
); ++i
)
6157 xsnprintf (mi_group
, sizeof (mi_group
), "i%d", inf
);
6158 uiout
->field_string (NULL
, mi_group
);
6163 uiout
->text (" inf ");
6167 uiout
->text (plongest (inf
));
6172 /* Print B to gdb_stdout. */
6175 print_one_breakpoint_location (struct breakpoint
*b
,
6176 struct bp_location
*loc
,
6178 struct bp_location
**last_loc
,
6181 struct command_line
*l
;
6182 static char bpenables
[] = "nynny";
6184 struct ui_out
*uiout
= current_uiout
;
6185 int header_of_multiple
= 0;
6186 int part_of_multiple
= (loc
!= NULL
);
6187 struct value_print_options opts
;
6189 get_user_print_options (&opts
);
6191 gdb_assert (!loc
|| loc_number
!= 0);
6192 /* See comment in print_one_breakpoint concerning treatment of
6193 breakpoints with single disabled location. */
6196 && (b
->loc
->next
!= NULL
|| !b
->loc
->enabled
)))
6197 header_of_multiple
= 1;
6205 if (part_of_multiple
)
6208 formatted
= xstrprintf ("%d.%d", b
->number
, loc_number
);
6209 uiout
->field_string ("number", formatted
);
6214 uiout
->field_int ("number", b
->number
);
6219 if (part_of_multiple
)
6220 uiout
->field_skip ("type");
6222 uiout
->field_string ("type", bptype_string (b
->type
));
6226 if (part_of_multiple
)
6227 uiout
->field_skip ("disp");
6229 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
6234 if (part_of_multiple
)
6235 uiout
->field_string ("enabled", loc
->enabled
? "y" : "n");
6237 uiout
->field_fmt ("enabled", "%c", bpenables
[(int) b
->enable_state
]);
6242 if (b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
6244 /* Although the print_one can possibly print all locations,
6245 calling it here is not likely to get any nice result. So,
6246 make sure there's just one location. */
6247 gdb_assert (b
->loc
== NULL
|| b
->loc
->next
== NULL
);
6248 b
->ops
->print_one (b
, last_loc
);
6254 internal_error (__FILE__
, __LINE__
,
6255 _("print_one_breakpoint: bp_none encountered\n"));
6259 case bp_hardware_watchpoint
:
6260 case bp_read_watchpoint
:
6261 case bp_access_watchpoint
:
6263 struct watchpoint
*w
= (struct watchpoint
*) b
;
6265 /* Field 4, the address, is omitted (which makes the columns
6266 not line up too nicely with the headers, but the effect
6267 is relatively readable). */
6268 if (opts
.addressprint
)
6269 uiout
->field_skip ("addr");
6271 uiout
->field_string ("what", w
->exp_string
);
6276 case bp_hardware_breakpoint
:
6277 case bp_single_step
:
6281 case bp_longjmp_resume
:
6282 case bp_longjmp_call_dummy
:
6284 case bp_exception_resume
:
6285 case bp_step_resume
:
6286 case bp_hp_step_resume
:
6287 case bp_watchpoint_scope
:
6289 case bp_std_terminate
:
6290 case bp_shlib_event
:
6291 case bp_thread_event
:
6292 case bp_overlay_event
:
6293 case bp_longjmp_master
:
6294 case bp_std_terminate_master
:
6295 case bp_exception_master
:
6297 case bp_fast_tracepoint
:
6298 case bp_static_tracepoint
:
6301 case bp_gnu_ifunc_resolver
:
6302 case bp_gnu_ifunc_resolver_return
:
6303 if (opts
.addressprint
)
6306 if (header_of_multiple
)
6307 uiout
->field_string ("addr", "<MULTIPLE>");
6308 else if (b
->loc
== NULL
|| loc
->shlib_disabled
)
6309 uiout
->field_string ("addr", "<PENDING>");
6311 uiout
->field_core_addr ("addr",
6312 loc
->gdbarch
, loc
->address
);
6315 if (!header_of_multiple
)
6316 print_breakpoint_location (b
, loc
);
6323 if (loc
!= NULL
&& !header_of_multiple
)
6325 struct inferior
*inf
;
6326 VEC(int) *inf_num
= NULL
;
6331 if (inf
->pspace
== loc
->pspace
)
6332 VEC_safe_push (int, inf_num
, inf
->num
);
6335 /* For backward compatibility, don't display inferiors in CLI unless
6336 there are several. Always display for MI. */
6338 || (!gdbarch_has_global_breakpoints (target_gdbarch ())
6339 && (number_of_program_spaces () > 1
6340 || number_of_inferiors () > 1)
6341 /* LOC is for existing B, it cannot be in
6342 moribund_locations and thus having NULL OWNER. */
6343 && loc
->owner
->type
!= bp_catchpoint
))
6345 output_thread_groups (uiout
, "thread-groups", inf_num
, mi_only
);
6346 VEC_free (int, inf_num
);
6349 if (!part_of_multiple
)
6351 if (b
->thread
!= -1)
6353 /* FIXME: This seems to be redundant and lost here; see the
6354 "stop only in" line a little further down. */
6355 uiout
->text (" thread ");
6356 uiout
->field_int ("thread", b
->thread
);
6358 else if (b
->task
!= 0)
6360 uiout
->text (" task ");
6361 uiout
->field_int ("task", b
->task
);
6367 if (!part_of_multiple
)
6368 b
->ops
->print_one_detail (b
, uiout
);
6370 if (part_of_multiple
&& frame_id_p (b
->frame_id
))
6373 uiout
->text ("\tstop only in stack frame at ");
6374 /* FIXME: cagney/2002-12-01: Shouldn't be poking around inside
6376 uiout
->field_core_addr ("frame",
6377 b
->gdbarch
, b
->frame_id
.stack_addr
);
6381 if (!part_of_multiple
&& b
->cond_string
)
6384 if (is_tracepoint (b
))
6385 uiout
->text ("\ttrace only if ");
6387 uiout
->text ("\tstop only if ");
6388 uiout
->field_string ("cond", b
->cond_string
);
6390 /* Print whether the target is doing the breakpoint's condition
6391 evaluation. If GDB is doing the evaluation, don't print anything. */
6392 if (is_breakpoint (b
)
6393 && breakpoint_condition_evaluation_mode ()
6394 == condition_evaluation_target
)
6397 uiout
->field_string ("evaluated-by",
6398 bp_condition_evaluator (b
));
6399 uiout
->text (" evals)");
6404 if (!part_of_multiple
&& b
->thread
!= -1)
6406 /* FIXME should make an annotation for this. */
6407 uiout
->text ("\tstop only in thread ");
6408 if (uiout
->is_mi_like_p ())
6409 uiout
->field_int ("thread", b
->thread
);
6412 struct thread_info
*thr
= find_thread_global_id (b
->thread
);
6414 uiout
->field_string ("thread", print_thread_id (thr
));
6419 if (!part_of_multiple
)
6423 /* FIXME should make an annotation for this. */
6424 if (is_catchpoint (b
))
6425 uiout
->text ("\tcatchpoint");
6426 else if (is_tracepoint (b
))
6427 uiout
->text ("\ttracepoint");
6429 uiout
->text ("\tbreakpoint");
6430 uiout
->text (" already hit ");
6431 uiout
->field_int ("times", b
->hit_count
);
6432 if (b
->hit_count
== 1)
6433 uiout
->text (" time\n");
6435 uiout
->text (" times\n");
6439 /* Output the count also if it is zero, but only if this is mi. */
6440 if (uiout
->is_mi_like_p ())
6441 uiout
->field_int ("times", b
->hit_count
);
6445 if (!part_of_multiple
&& b
->ignore_count
)
6448 uiout
->text ("\tignore next ");
6449 uiout
->field_int ("ignore", b
->ignore_count
);
6450 uiout
->text (" hits\n");
6453 /* Note that an enable count of 1 corresponds to "enable once"
6454 behavior, which is reported by the combination of enablement and
6455 disposition, so we don't need to mention it here. */
6456 if (!part_of_multiple
&& b
->enable_count
> 1)
6459 uiout
->text ("\tdisable after ");
6460 /* Tweak the wording to clarify that ignore and enable counts
6461 are distinct, and have additive effect. */
6462 if (b
->ignore_count
)
6463 uiout
->text ("additional ");
6465 uiout
->text ("next ");
6466 uiout
->field_int ("enable", b
->enable_count
);
6467 uiout
->text (" hits\n");
6470 if (!part_of_multiple
&& is_tracepoint (b
))
6472 struct tracepoint
*tp
= (struct tracepoint
*) b
;
6474 if (tp
->traceframe_usage
)
6476 uiout
->text ("\ttrace buffer usage ");
6477 uiout
->field_int ("traceframe-usage", tp
->traceframe_usage
);
6478 uiout
->text (" bytes\n");
6482 l
= b
->commands
? b
->commands
.get () : NULL
;
6483 if (!part_of_multiple
&& l
)
6486 ui_out_emit_tuple
tuple_emitter (uiout
, "script");
6487 print_command_lines (uiout
, l
, 4);
6490 if (is_tracepoint (b
))
6492 struct tracepoint
*t
= (struct tracepoint
*) b
;
6494 if (!part_of_multiple
&& t
->pass_count
)
6496 annotate_field (10);
6497 uiout
->text ("\tpass count ");
6498 uiout
->field_int ("pass", t
->pass_count
);
6499 uiout
->text (" \n");
6502 /* Don't display it when tracepoint or tracepoint location is
6504 if (!header_of_multiple
&& loc
!= NULL
&& !loc
->shlib_disabled
)
6506 annotate_field (11);
6508 if (uiout
->is_mi_like_p ())
6509 uiout
->field_string ("installed",
6510 loc
->inserted
? "y" : "n");
6516 uiout
->text ("\tnot ");
6517 uiout
->text ("installed on target\n");
6522 if (uiout
->is_mi_like_p () && !part_of_multiple
)
6524 if (is_watchpoint (b
))
6526 struct watchpoint
*w
= (struct watchpoint
*) b
;
6528 uiout
->field_string ("original-location", w
->exp_string
);
6530 else if (b
->location
!= NULL
6531 && event_location_to_string (b
->location
.get ()) != NULL
)
6532 uiout
->field_string ("original-location",
6533 event_location_to_string (b
->location
.get ()));
6538 print_one_breakpoint (struct breakpoint
*b
,
6539 struct bp_location
**last_loc
,
6542 struct ui_out
*uiout
= current_uiout
;
6545 ui_out_emit_tuple
tuple_emitter (uiout
, "bkpt");
6547 print_one_breakpoint_location (b
, NULL
, 0, last_loc
, allflag
);
6550 /* If this breakpoint has custom print function,
6551 it's already printed. Otherwise, print individual
6552 locations, if any. */
6553 if (b
->ops
== NULL
|| b
->ops
->print_one
== NULL
)
6555 /* If breakpoint has a single location that is disabled, we
6556 print it as if it had several locations, since otherwise it's
6557 hard to represent "breakpoint enabled, location disabled"
6560 Note that while hardware watchpoints have several locations
6561 internally, that's not a property exposed to user. */
6563 && !is_hardware_watchpoint (b
)
6564 && (b
->loc
->next
|| !b
->loc
->enabled
))
6566 struct bp_location
*loc
;
6569 for (loc
= b
->loc
; loc
; loc
= loc
->next
, ++n
)
6571 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
6572 print_one_breakpoint_location (b
, loc
, n
, last_loc
, allflag
);
6579 breakpoint_address_bits (struct breakpoint
*b
)
6581 int print_address_bits
= 0;
6582 struct bp_location
*loc
;
6584 /* Software watchpoints that aren't watching memory don't have an
6585 address to print. */
6586 if (is_no_memory_software_watchpoint (b
))
6589 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
6593 addr_bit
= gdbarch_addr_bit (loc
->gdbarch
);
6594 if (addr_bit
> print_address_bits
)
6595 print_address_bits
= addr_bit
;
6598 return print_address_bits
;
6601 /* See breakpoint.h. */
6604 print_breakpoint (breakpoint
*b
)
6606 struct bp_location
*dummy_loc
= NULL
;
6607 print_one_breakpoint (b
, &dummy_loc
, 0);
6610 /* Return true if this breakpoint was set by the user, false if it is
6611 internal or momentary. */
6614 user_breakpoint_p (struct breakpoint
*b
)
6616 return b
->number
> 0;
6619 /* See breakpoint.h. */
6622 pending_breakpoint_p (struct breakpoint
*b
)
6624 return b
->loc
== NULL
;
6627 /* Print information on user settable breakpoint (watchpoint, etc)
6628 number BNUM. If BNUM is -1 print all user-settable breakpoints.
6629 If ALLFLAG is non-zero, include non-user-settable breakpoints. If
6630 FILTER is non-NULL, call it on each breakpoint and only include the
6631 ones for which it returns non-zero. Return the total number of
6632 breakpoints listed. */
6635 breakpoint_1 (const char *args
, int allflag
,
6636 int (*filter
) (const struct breakpoint
*))
6638 struct breakpoint
*b
;
6639 struct bp_location
*last_loc
= NULL
;
6640 int nr_printable_breakpoints
;
6641 struct value_print_options opts
;
6642 int print_address_bits
= 0;
6643 int print_type_col_width
= 14;
6644 struct ui_out
*uiout
= current_uiout
;
6646 get_user_print_options (&opts
);
6648 /* Compute the number of rows in the table, as well as the size
6649 required for address fields. */
6650 nr_printable_breakpoints
= 0;
6653 /* If we have a filter, only list the breakpoints it accepts. */
6654 if (filter
&& !filter (b
))
6657 /* If we have an "args" string, it is a list of breakpoints to
6658 accept. Skip the others. */
6659 if (args
!= NULL
&& *args
!= '\0')
6661 if (allflag
&& parse_and_eval_long (args
) != b
->number
)
6663 if (!allflag
&& !number_is_in_list (args
, b
->number
))
6667 if (allflag
|| user_breakpoint_p (b
))
6669 int addr_bit
, type_len
;
6671 addr_bit
= breakpoint_address_bits (b
);
6672 if (addr_bit
> print_address_bits
)
6673 print_address_bits
= addr_bit
;
6675 type_len
= strlen (bptype_string (b
->type
));
6676 if (type_len
> print_type_col_width
)
6677 print_type_col_width
= type_len
;
6679 nr_printable_breakpoints
++;
6684 ui_out_emit_table
table_emitter (uiout
,
6685 opts
.addressprint
? 6 : 5,
6686 nr_printable_breakpoints
,
6689 if (nr_printable_breakpoints
> 0)
6690 annotate_breakpoints_headers ();
6691 if (nr_printable_breakpoints
> 0)
6693 uiout
->table_header (7, ui_left
, "number", "Num"); /* 1 */
6694 if (nr_printable_breakpoints
> 0)
6696 uiout
->table_header (print_type_col_width
, ui_left
, "type", "Type"); /* 2 */
6697 if (nr_printable_breakpoints
> 0)
6699 uiout
->table_header (4, ui_left
, "disp", "Disp"); /* 3 */
6700 if (nr_printable_breakpoints
> 0)
6702 uiout
->table_header (3, ui_left
, "enabled", "Enb"); /* 4 */
6703 if (opts
.addressprint
)
6705 if (nr_printable_breakpoints
> 0)
6707 if (print_address_bits
<= 32)
6708 uiout
->table_header (10, ui_left
, "addr", "Address"); /* 5 */
6710 uiout
->table_header (18, ui_left
, "addr", "Address"); /* 5 */
6712 if (nr_printable_breakpoints
> 0)
6714 uiout
->table_header (40, ui_noalign
, "what", "What"); /* 6 */
6715 uiout
->table_body ();
6716 if (nr_printable_breakpoints
> 0)
6717 annotate_breakpoints_table ();
6722 /* If we have a filter, only list the breakpoints it accepts. */
6723 if (filter
&& !filter (b
))
6726 /* If we have an "args" string, it is a list of breakpoints to
6727 accept. Skip the others. */
6729 if (args
!= NULL
&& *args
!= '\0')
6731 if (allflag
) /* maintenance info breakpoint */
6733 if (parse_and_eval_long (args
) != b
->number
)
6736 else /* all others */
6738 if (!number_is_in_list (args
, b
->number
))
6742 /* We only print out user settable breakpoints unless the
6744 if (allflag
|| user_breakpoint_p (b
))
6745 print_one_breakpoint (b
, &last_loc
, allflag
);
6749 if (nr_printable_breakpoints
== 0)
6751 /* If there's a filter, let the caller decide how to report
6755 if (args
== NULL
|| *args
== '\0')
6756 uiout
->message ("No breakpoints or watchpoints.\n");
6758 uiout
->message ("No breakpoint or watchpoint matching '%s'.\n",
6764 if (last_loc
&& !server_command
)
6765 set_next_address (last_loc
->gdbarch
, last_loc
->address
);
6768 /* FIXME? Should this be moved up so that it is only called when
6769 there have been breakpoints? */
6770 annotate_breakpoints_table_end ();
6772 return nr_printable_breakpoints
;
6775 /* Display the value of default-collect in a way that is generally
6776 compatible with the breakpoint list. */
6779 default_collect_info (void)
6781 struct ui_out
*uiout
= current_uiout
;
6783 /* If it has no value (which is frequently the case), say nothing; a
6784 message like "No default-collect." gets in user's face when it's
6786 if (!*default_collect
)
6789 /* The following phrase lines up nicely with per-tracepoint collect
6791 uiout
->text ("default collect ");
6792 uiout
->field_string ("default-collect", default_collect
);
6793 uiout
->text (" \n");
6797 info_breakpoints_command (char *args
, int from_tty
)
6799 breakpoint_1 (args
, 0, NULL
);
6801 default_collect_info ();
6805 info_watchpoints_command (char *args
, int from_tty
)
6807 int num_printed
= breakpoint_1 (args
, 0, is_watchpoint
);
6808 struct ui_out
*uiout
= current_uiout
;
6810 if (num_printed
== 0)
6812 if (args
== NULL
|| *args
== '\0')
6813 uiout
->message ("No watchpoints.\n");
6815 uiout
->message ("No watchpoint matching '%s'.\n", args
);
6820 maintenance_info_breakpoints (const char *args
, int from_tty
)
6822 breakpoint_1 (args
, 1, NULL
);
6824 default_collect_info ();
6828 breakpoint_has_pc (struct breakpoint
*b
,
6829 struct program_space
*pspace
,
6830 CORE_ADDR pc
, struct obj_section
*section
)
6832 struct bp_location
*bl
= b
->loc
;
6834 for (; bl
; bl
= bl
->next
)
6836 if (bl
->pspace
== pspace
6837 && bl
->address
== pc
6838 && (!overlay_debugging
|| bl
->section
== section
))
6844 /* Print a message describing any user-breakpoints set at PC. This
6845 concerns with logical breakpoints, so we match program spaces, not
6849 describe_other_breakpoints (struct gdbarch
*gdbarch
,
6850 struct program_space
*pspace
, CORE_ADDR pc
,
6851 struct obj_section
*section
, int thread
)
6854 struct breakpoint
*b
;
6857 others
+= (user_breakpoint_p (b
)
6858 && breakpoint_has_pc (b
, pspace
, pc
, section
));
6862 printf_filtered (_("Note: breakpoint "));
6863 else /* if (others == ???) */
6864 printf_filtered (_("Note: breakpoints "));
6866 if (user_breakpoint_p (b
) && breakpoint_has_pc (b
, pspace
, pc
, section
))
6869 printf_filtered ("%d", b
->number
);
6870 if (b
->thread
== -1 && thread
!= -1)
6871 printf_filtered (" (all threads)");
6872 else if (b
->thread
!= -1)
6873 printf_filtered (" (thread %d)", b
->thread
);
6874 printf_filtered ("%s%s ",
6875 ((b
->enable_state
== bp_disabled
6876 || b
->enable_state
== bp_call_disabled
)
6880 : ((others
== 1) ? " and" : ""));
6882 printf_filtered (_("also set at pc "));
6883 fputs_filtered (paddress (gdbarch
, pc
), gdb_stdout
);
6884 printf_filtered (".\n");
6889 /* Return true iff it is meaningful to use the address member of
6890 BPT locations. For some breakpoint types, the locations' address members
6891 are irrelevant and it makes no sense to attempt to compare them to other
6892 addresses (or use them for any other purpose either).
6894 More specifically, each of the following breakpoint types will
6895 always have a zero valued location address and we don't want to mark
6896 breakpoints of any of these types to be a duplicate of an actual
6897 breakpoint location at address zero:
6905 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
6907 enum bptype type
= bpt
->type
;
6909 return (type
!= bp_watchpoint
&& type
!= bp_catchpoint
);
6912 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
6913 true if LOC1 and LOC2 represent the same watchpoint location. */
6916 watchpoint_locations_match (struct bp_location
*loc1
,
6917 struct bp_location
*loc2
)
6919 struct watchpoint
*w1
= (struct watchpoint
*) loc1
->owner
;
6920 struct watchpoint
*w2
= (struct watchpoint
*) loc2
->owner
;
6922 /* Both of them must exist. */
6923 gdb_assert (w1
!= NULL
);
6924 gdb_assert (w2
!= NULL
);
6926 /* If the target can evaluate the condition expression in hardware,
6927 then we we need to insert both watchpoints even if they are at
6928 the same place. Otherwise the watchpoint will only trigger when
6929 the condition of whichever watchpoint was inserted evaluates to
6930 true, not giving a chance for GDB to check the condition of the
6931 other watchpoint. */
6933 && target_can_accel_watchpoint_condition (loc1
->address
,
6935 loc1
->watchpoint_type
,
6936 w1
->cond_exp
.get ()))
6938 && target_can_accel_watchpoint_condition (loc2
->address
,
6940 loc2
->watchpoint_type
,
6941 w2
->cond_exp
.get ())))
6944 /* Note that this checks the owner's type, not the location's. In
6945 case the target does not support read watchpoints, but does
6946 support access watchpoints, we'll have bp_read_watchpoint
6947 watchpoints with hw_access locations. Those should be considered
6948 duplicates of hw_read locations. The hw_read locations will
6949 become hw_access locations later. */
6950 return (loc1
->owner
->type
== loc2
->owner
->type
6951 && loc1
->pspace
->aspace
== loc2
->pspace
->aspace
6952 && loc1
->address
== loc2
->address
6953 && loc1
->length
== loc2
->length
);
6956 /* See breakpoint.h. */
6959 breakpoint_address_match (struct address_space
*aspace1
, CORE_ADDR addr1
,
6960 struct address_space
*aspace2
, CORE_ADDR addr2
)
6962 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
6963 || aspace1
== aspace2
)
6967 /* Returns true if {ASPACE2,ADDR2} falls within the range determined by
6968 {ASPACE1,ADDR1,LEN1}. In most targets, this can only be true if ASPACE1
6969 matches ASPACE2. On targets that have global breakpoints, the address
6970 space doesn't really matter. */
6973 breakpoint_address_match_range (struct address_space
*aspace1
, CORE_ADDR addr1
,
6974 int len1
, struct address_space
*aspace2
,
6977 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
6978 || aspace1
== aspace2
)
6979 && addr2
>= addr1
&& addr2
< addr1
+ len1
);
6982 /* Returns true if {ASPACE,ADDR} matches the breakpoint BL. BL may be
6983 a ranged breakpoint. In most targets, a match happens only if ASPACE
6984 matches the breakpoint's address space. On targets that have global
6985 breakpoints, the address space doesn't really matter. */
6988 breakpoint_location_address_match (struct bp_location
*bl
,
6989 struct address_space
*aspace
,
6992 return (breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
6995 && breakpoint_address_match_range (bl
->pspace
->aspace
,
6996 bl
->address
, bl
->length
,
7000 /* Returns true if the [ADDR,ADDR+LEN) range in ASPACE overlaps
7001 breakpoint BL. BL may be a ranged breakpoint. In most targets, a
7002 match happens only if ASPACE matches the breakpoint's address
7003 space. On targets that have global breakpoints, the address space
7004 doesn't really matter. */
7007 breakpoint_location_address_range_overlap (struct bp_location
*bl
,
7008 struct address_space
*aspace
,
7009 CORE_ADDR addr
, int len
)
7011 if (gdbarch_has_global_breakpoints (target_gdbarch ())
7012 || bl
->pspace
->aspace
== aspace
)
7014 int bl_len
= bl
->length
!= 0 ? bl
->length
: 1;
7016 if (mem_ranges_overlap (addr
, len
, bl
->address
, bl_len
))
7022 /* If LOC1 and LOC2's owners are not tracepoints, returns false directly.
7023 Then, if LOC1 and LOC2 represent the same tracepoint location, returns
7024 true, otherwise returns false. */
7027 tracepoint_locations_match (struct bp_location
*loc1
,
7028 struct bp_location
*loc2
)
7030 if (is_tracepoint (loc1
->owner
) && is_tracepoint (loc2
->owner
))
7031 /* Since tracepoint locations are never duplicated with others', tracepoint
7032 locations at the same address of different tracepoints are regarded as
7033 different locations. */
7034 return (loc1
->address
== loc2
->address
&& loc1
->owner
== loc2
->owner
);
7039 /* Assuming LOC1 and LOC2's types' have meaningful target addresses
7040 (breakpoint_address_is_meaningful), returns true if LOC1 and LOC2
7041 represent the same location. */
7044 breakpoint_locations_match (struct bp_location
*loc1
,
7045 struct bp_location
*loc2
)
7047 int hw_point1
, hw_point2
;
7049 /* Both of them must not be in moribund_locations. */
7050 gdb_assert (loc1
->owner
!= NULL
);
7051 gdb_assert (loc2
->owner
!= NULL
);
7053 hw_point1
= is_hardware_watchpoint (loc1
->owner
);
7054 hw_point2
= is_hardware_watchpoint (loc2
->owner
);
7056 if (hw_point1
!= hw_point2
)
7059 return watchpoint_locations_match (loc1
, loc2
);
7060 else if (is_tracepoint (loc1
->owner
) || is_tracepoint (loc2
->owner
))
7061 return tracepoint_locations_match (loc1
, loc2
);
7063 /* We compare bp_location.length in order to cover ranged breakpoints. */
7064 return (breakpoint_address_match (loc1
->pspace
->aspace
, loc1
->address
,
7065 loc2
->pspace
->aspace
, loc2
->address
)
7066 && loc1
->length
== loc2
->length
);
7070 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
7071 int bnum
, int have_bnum
)
7073 /* The longest string possibly returned by hex_string_custom
7074 is 50 chars. These must be at least that big for safety. */
7078 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
7079 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
7081 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
7082 bnum
, astr1
, astr2
);
7084 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
7087 /* Adjust a breakpoint's address to account for architectural
7088 constraints on breakpoint placement. Return the adjusted address.
7089 Note: Very few targets require this kind of adjustment. For most
7090 targets, this function is simply the identity function. */
7093 adjust_breakpoint_address (struct gdbarch
*gdbarch
,
7094 CORE_ADDR bpaddr
, enum bptype bptype
)
7096 if (!gdbarch_adjust_breakpoint_address_p (gdbarch
))
7098 /* Very few targets need any kind of breakpoint adjustment. */
7101 else if (bptype
== bp_watchpoint
7102 || bptype
== bp_hardware_watchpoint
7103 || bptype
== bp_read_watchpoint
7104 || bptype
== bp_access_watchpoint
7105 || bptype
== bp_catchpoint
)
7107 /* Watchpoints and the various bp_catch_* eventpoints should not
7108 have their addresses modified. */
7111 else if (bptype
== bp_single_step
)
7113 /* Single-step breakpoints should not have their addresses
7114 modified. If there's any architectural constrain that
7115 applies to this address, then it should have already been
7116 taken into account when the breakpoint was created in the
7117 first place. If we didn't do this, stepping through e.g.,
7118 Thumb-2 IT blocks would break. */
7123 CORE_ADDR adjusted_bpaddr
;
7125 /* Some targets have architectural constraints on the placement
7126 of breakpoint instructions. Obtain the adjusted address. */
7127 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (gdbarch
, bpaddr
);
7129 /* An adjusted breakpoint address can significantly alter
7130 a user's expectations. Print a warning if an adjustment
7132 if (adjusted_bpaddr
!= bpaddr
)
7133 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
7135 return adjusted_bpaddr
;
7139 bp_location::bp_location (const bp_location_ops
*ops
, breakpoint
*owner
)
7141 bp_location
*loc
= this;
7143 gdb_assert (ops
!= NULL
);
7147 loc
->cond_bytecode
= NULL
;
7148 loc
->shlib_disabled
= 0;
7151 switch (owner
->type
)
7154 case bp_single_step
:
7158 case bp_longjmp_resume
:
7159 case bp_longjmp_call_dummy
:
7161 case bp_exception_resume
:
7162 case bp_step_resume
:
7163 case bp_hp_step_resume
:
7164 case bp_watchpoint_scope
:
7166 case bp_std_terminate
:
7167 case bp_shlib_event
:
7168 case bp_thread_event
:
7169 case bp_overlay_event
:
7171 case bp_longjmp_master
:
7172 case bp_std_terminate_master
:
7173 case bp_exception_master
:
7174 case bp_gnu_ifunc_resolver
:
7175 case bp_gnu_ifunc_resolver_return
:
7177 loc
->loc_type
= bp_loc_software_breakpoint
;
7178 mark_breakpoint_location_modified (loc
);
7180 case bp_hardware_breakpoint
:
7181 loc
->loc_type
= bp_loc_hardware_breakpoint
;
7182 mark_breakpoint_location_modified (loc
);
7184 case bp_hardware_watchpoint
:
7185 case bp_read_watchpoint
:
7186 case bp_access_watchpoint
:
7187 loc
->loc_type
= bp_loc_hardware_watchpoint
;
7192 case bp_fast_tracepoint
:
7193 case bp_static_tracepoint
:
7194 loc
->loc_type
= bp_loc_other
;
7197 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
7203 /* Allocate a struct bp_location. */
7205 static struct bp_location
*
7206 allocate_bp_location (struct breakpoint
*bpt
)
7208 return bpt
->ops
->allocate_location (bpt
);
7212 free_bp_location (struct bp_location
*loc
)
7214 loc
->ops
->dtor (loc
);
7218 /* Increment reference count. */
7221 incref_bp_location (struct bp_location
*bl
)
7226 /* Decrement reference count. If the reference count reaches 0,
7227 destroy the bp_location. Sets *BLP to NULL. */
7230 decref_bp_location (struct bp_location
**blp
)
7232 gdb_assert ((*blp
)->refc
> 0);
7234 if (--(*blp
)->refc
== 0)
7235 free_bp_location (*blp
);
7239 /* Add breakpoint B at the end of the global breakpoint chain. */
7242 add_to_breakpoint_chain (std::unique_ptr
<breakpoint
> &&b
)
7244 struct breakpoint
*b1
;
7245 struct breakpoint
*result
= b
.get ();
7247 /* Add this breakpoint to the end of the chain so that a list of
7248 breakpoints will come out in order of increasing numbers. */
7250 b1
= breakpoint_chain
;
7252 breakpoint_chain
= b
.release ();
7257 b1
->next
= b
.release ();
7263 /* Initializes breakpoint B with type BPTYPE and no locations yet. */
7266 init_raw_breakpoint_without_location (struct breakpoint
*b
,
7267 struct gdbarch
*gdbarch
,
7269 const struct breakpoint_ops
*ops
)
7271 gdb_assert (ops
!= NULL
);
7275 b
->gdbarch
= gdbarch
;
7276 b
->language
= current_language
->la_language
;
7277 b
->input_radix
= input_radix
;
7278 b
->related_breakpoint
= b
;
7281 /* Helper to set_raw_breakpoint below. Creates a breakpoint
7282 that has type BPTYPE and has no locations as yet. */
7284 static struct breakpoint
*
7285 set_raw_breakpoint_without_location (struct gdbarch
*gdbarch
,
7287 const struct breakpoint_ops
*ops
)
7289 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (bptype
);
7291 init_raw_breakpoint_without_location (b
.get (), gdbarch
, bptype
, ops
);
7292 return add_to_breakpoint_chain (std::move (b
));
7295 /* Initialize loc->function_name. EXPLICIT_LOC says no indirect function
7296 resolutions should be made as the user specified the location explicitly
7300 set_breakpoint_location_function (struct bp_location
*loc
, int explicit_loc
)
7302 gdb_assert (loc
->owner
!= NULL
);
7304 if (loc
->owner
->type
== bp_breakpoint
7305 || loc
->owner
->type
== bp_hardware_breakpoint
7306 || is_tracepoint (loc
->owner
))
7309 const char *function_name
;
7310 CORE_ADDR func_addr
;
7312 find_pc_partial_function_gnu_ifunc (loc
->address
, &function_name
,
7313 &func_addr
, NULL
, &is_gnu_ifunc
);
7315 if (is_gnu_ifunc
&& !explicit_loc
)
7317 struct breakpoint
*b
= loc
->owner
;
7319 gdb_assert (loc
->pspace
== current_program_space
);
7320 if (gnu_ifunc_resolve_name (function_name
,
7321 &loc
->requested_address
))
7323 /* Recalculate ADDRESS based on new REQUESTED_ADDRESS. */
7324 loc
->address
= adjust_breakpoint_address (loc
->gdbarch
,
7325 loc
->requested_address
,
7328 else if (b
->type
== bp_breakpoint
&& b
->loc
== loc
7329 && loc
->next
== NULL
&& b
->related_breakpoint
== b
)
7331 /* Create only the whole new breakpoint of this type but do not
7332 mess more complicated breakpoints with multiple locations. */
7333 b
->type
= bp_gnu_ifunc_resolver
;
7334 /* Remember the resolver's address for use by the return
7336 loc
->related_address
= func_addr
;
7341 loc
->function_name
= xstrdup (function_name
);
7345 /* Attempt to determine architecture of location identified by SAL. */
7347 get_sal_arch (struct symtab_and_line sal
)
7350 return get_objfile_arch (sal
.section
->objfile
);
7352 return get_objfile_arch (SYMTAB_OBJFILE (sal
.symtab
));
7357 /* Low level routine for partially initializing a breakpoint of type
7358 BPTYPE. The newly created breakpoint's address, section, source
7359 file name, and line number are provided by SAL.
7361 It is expected that the caller will complete the initialization of
7362 the newly created breakpoint struct as well as output any status
7363 information regarding the creation of a new breakpoint. */
7366 init_raw_breakpoint (struct breakpoint
*b
, struct gdbarch
*gdbarch
,
7367 struct symtab_and_line sal
, enum bptype bptype
,
7368 const struct breakpoint_ops
*ops
)
7370 init_raw_breakpoint_without_location (b
, gdbarch
, bptype
, ops
);
7372 add_location_to_breakpoint (b
, &sal
);
7374 if (bptype
!= bp_catchpoint
)
7375 gdb_assert (sal
.pspace
!= NULL
);
7377 /* Store the program space that was used to set the breakpoint,
7378 except for ordinary breakpoints, which are independent of the
7380 if (bptype
!= bp_breakpoint
&& bptype
!= bp_hardware_breakpoint
)
7381 b
->pspace
= sal
.pspace
;
7384 /* set_raw_breakpoint is a low level routine for allocating and
7385 partially initializing a breakpoint of type BPTYPE. The newly
7386 created breakpoint's address, section, source file name, and line
7387 number are provided by SAL. The newly created and partially
7388 initialized breakpoint is added to the breakpoint chain and
7389 is also returned as the value of this function.
7391 It is expected that the caller will complete the initialization of
7392 the newly created breakpoint struct as well as output any status
7393 information regarding the creation of a new breakpoint. In
7394 particular, set_raw_breakpoint does NOT set the breakpoint
7395 number! Care should be taken to not allow an error to occur
7396 prior to completing the initialization of the breakpoint. If this
7397 should happen, a bogus breakpoint will be left on the chain. */
7400 set_raw_breakpoint (struct gdbarch
*gdbarch
,
7401 struct symtab_and_line sal
, enum bptype bptype
,
7402 const struct breakpoint_ops
*ops
)
7404 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (bptype
);
7406 init_raw_breakpoint (b
.get (), gdbarch
, sal
, bptype
, ops
);
7407 return add_to_breakpoint_chain (std::move (b
));
7410 /* Call this routine when stepping and nexting to enable a breakpoint
7411 if we do a longjmp() or 'throw' in TP. FRAME is the frame which
7412 initiated the operation. */
7415 set_longjmp_breakpoint (struct thread_info
*tp
, struct frame_id frame
)
7417 struct breakpoint
*b
, *b_tmp
;
7418 int thread
= tp
->global_num
;
7420 /* To avoid having to rescan all objfile symbols at every step,
7421 we maintain a list of continually-inserted but always disabled
7422 longjmp "master" breakpoints. Here, we simply create momentary
7423 clones of those and enable them for the requested thread. */
7424 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7425 if (b
->pspace
== current_program_space
7426 && (b
->type
== bp_longjmp_master
7427 || b
->type
== bp_exception_master
))
7429 enum bptype type
= b
->type
== bp_longjmp_master
? bp_longjmp
: bp_exception
;
7430 struct breakpoint
*clone
;
7432 /* longjmp_breakpoint_ops ensures INITIATING_FRAME is cleared again
7433 after their removal. */
7434 clone
= momentary_breakpoint_from_master (b
, type
,
7435 &momentary_breakpoint_ops
, 1);
7436 clone
->thread
= thread
;
7439 tp
->initiating_frame
= frame
;
7442 /* Delete all longjmp breakpoints from THREAD. */
7444 delete_longjmp_breakpoint (int thread
)
7446 struct breakpoint
*b
, *b_tmp
;
7448 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7449 if (b
->type
== bp_longjmp
|| b
->type
== bp_exception
)
7451 if (b
->thread
== thread
)
7452 delete_breakpoint (b
);
7457 delete_longjmp_breakpoint_at_next_stop (int thread
)
7459 struct breakpoint
*b
, *b_tmp
;
7461 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7462 if (b
->type
== bp_longjmp
|| b
->type
== bp_exception
)
7464 if (b
->thread
== thread
)
7465 b
->disposition
= disp_del_at_next_stop
;
7469 /* Place breakpoints of type bp_longjmp_call_dummy to catch longjmp for
7470 INFERIOR_PTID thread. Chain them all by RELATED_BREAKPOINT and return
7471 pointer to any of them. Return NULL if this system cannot place longjmp
7475 set_longjmp_breakpoint_for_call_dummy (void)
7477 struct breakpoint
*b
, *retval
= NULL
;
7480 if (b
->pspace
== current_program_space
&& b
->type
== bp_longjmp_master
)
7482 struct breakpoint
*new_b
;
7484 new_b
= momentary_breakpoint_from_master (b
, bp_longjmp_call_dummy
,
7485 &momentary_breakpoint_ops
,
7487 new_b
->thread
= ptid_to_global_thread_id (inferior_ptid
);
7489 /* Link NEW_B into the chain of RETVAL breakpoints. */
7491 gdb_assert (new_b
->related_breakpoint
== new_b
);
7494 new_b
->related_breakpoint
= retval
;
7495 while (retval
->related_breakpoint
!= new_b
->related_breakpoint
)
7496 retval
= retval
->related_breakpoint
;
7497 retval
->related_breakpoint
= new_b
;
7503 /* Verify all existing dummy frames and their associated breakpoints for
7504 TP. Remove those which can no longer be found in the current frame
7507 You should call this function only at places where it is safe to currently
7508 unwind the whole stack. Failed stack unwind would discard live dummy
7512 check_longjmp_breakpoint_for_call_dummy (struct thread_info
*tp
)
7514 struct breakpoint
*b
, *b_tmp
;
7516 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7517 if (b
->type
== bp_longjmp_call_dummy
&& b
->thread
== tp
->global_num
)
7519 struct breakpoint
*dummy_b
= b
->related_breakpoint
;
7521 while (dummy_b
!= b
&& dummy_b
->type
!= bp_call_dummy
)
7522 dummy_b
= dummy_b
->related_breakpoint
;
7523 if (dummy_b
->type
!= bp_call_dummy
7524 || frame_find_by_id (dummy_b
->frame_id
) != NULL
)
7527 dummy_frame_discard (dummy_b
->frame_id
, tp
->ptid
);
7529 while (b
->related_breakpoint
!= b
)
7531 if (b_tmp
== b
->related_breakpoint
)
7532 b_tmp
= b
->related_breakpoint
->next
;
7533 delete_breakpoint (b
->related_breakpoint
);
7535 delete_breakpoint (b
);
7540 enable_overlay_breakpoints (void)
7542 struct breakpoint
*b
;
7545 if (b
->type
== bp_overlay_event
)
7547 b
->enable_state
= bp_enabled
;
7548 update_global_location_list (UGLL_MAY_INSERT
);
7549 overlay_events_enabled
= 1;
7554 disable_overlay_breakpoints (void)
7556 struct breakpoint
*b
;
7559 if (b
->type
== bp_overlay_event
)
7561 b
->enable_state
= bp_disabled
;
7562 update_global_location_list (UGLL_DONT_INSERT
);
7563 overlay_events_enabled
= 0;
7567 /* Set an active std::terminate breakpoint for each std::terminate
7568 master breakpoint. */
7570 set_std_terminate_breakpoint (void)
7572 struct breakpoint
*b
, *b_tmp
;
7574 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7575 if (b
->pspace
== current_program_space
7576 && b
->type
== bp_std_terminate_master
)
7578 momentary_breakpoint_from_master (b
, bp_std_terminate
,
7579 &momentary_breakpoint_ops
, 1);
7583 /* Delete all the std::terminate breakpoints. */
7585 delete_std_terminate_breakpoint (void)
7587 struct breakpoint
*b
, *b_tmp
;
7589 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7590 if (b
->type
== bp_std_terminate
)
7591 delete_breakpoint (b
);
7595 create_thread_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7597 struct breakpoint
*b
;
7599 b
= create_internal_breakpoint (gdbarch
, address
, bp_thread_event
,
7600 &internal_breakpoint_ops
);
7602 b
->enable_state
= bp_enabled
;
7603 /* location has to be used or breakpoint_re_set will delete me. */
7604 b
->location
= new_address_location (b
->loc
->address
, NULL
, 0);
7606 update_global_location_list_nothrow (UGLL_MAY_INSERT
);
7611 struct lang_and_radix
7617 /* Create a breakpoint for JIT code registration and unregistration. */
7620 create_jit_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7622 return create_internal_breakpoint (gdbarch
, address
, bp_jit_event
,
7623 &internal_breakpoint_ops
);
7626 /* Remove JIT code registration and unregistration breakpoint(s). */
7629 remove_jit_event_breakpoints (void)
7631 struct breakpoint
*b
, *b_tmp
;
7633 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7634 if (b
->type
== bp_jit_event
7635 && b
->loc
->pspace
== current_program_space
)
7636 delete_breakpoint (b
);
7640 remove_solib_event_breakpoints (void)
7642 struct breakpoint
*b
, *b_tmp
;
7644 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7645 if (b
->type
== bp_shlib_event
7646 && b
->loc
->pspace
== current_program_space
)
7647 delete_breakpoint (b
);
7650 /* See breakpoint.h. */
7653 remove_solib_event_breakpoints_at_next_stop (void)
7655 struct breakpoint
*b
, *b_tmp
;
7657 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7658 if (b
->type
== bp_shlib_event
7659 && b
->loc
->pspace
== current_program_space
)
7660 b
->disposition
= disp_del_at_next_stop
;
7663 /* Helper for create_solib_event_breakpoint /
7664 create_and_insert_solib_event_breakpoint. Allows specifying which
7665 INSERT_MODE to pass through to update_global_location_list. */
7667 static struct breakpoint
*
7668 create_solib_event_breakpoint_1 (struct gdbarch
*gdbarch
, CORE_ADDR address
,
7669 enum ugll_insert_mode insert_mode
)
7671 struct breakpoint
*b
;
7673 b
= create_internal_breakpoint (gdbarch
, address
, bp_shlib_event
,
7674 &internal_breakpoint_ops
);
7675 update_global_location_list_nothrow (insert_mode
);
7680 create_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7682 return create_solib_event_breakpoint_1 (gdbarch
, address
, UGLL_MAY_INSERT
);
7685 /* See breakpoint.h. */
7688 create_and_insert_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7690 struct breakpoint
*b
;
7692 /* Explicitly tell update_global_location_list to insert
7694 b
= create_solib_event_breakpoint_1 (gdbarch
, address
, UGLL_INSERT
);
7695 if (!b
->loc
->inserted
)
7697 delete_breakpoint (b
);
7703 /* Disable any breakpoints that are on code in shared libraries. Only
7704 apply to enabled breakpoints, disabled ones can just stay disabled. */
7707 disable_breakpoints_in_shlibs (void)
7709 struct bp_location
*loc
, **locp_tmp
;
7711 ALL_BP_LOCATIONS (loc
, locp_tmp
)
7713 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7714 struct breakpoint
*b
= loc
->owner
;
7716 /* We apply the check to all breakpoints, including disabled for
7717 those with loc->duplicate set. This is so that when breakpoint
7718 becomes enabled, or the duplicate is removed, gdb will try to
7719 insert all breakpoints. If we don't set shlib_disabled here,
7720 we'll try to insert those breakpoints and fail. */
7721 if (((b
->type
== bp_breakpoint
)
7722 || (b
->type
== bp_jit_event
)
7723 || (b
->type
== bp_hardware_breakpoint
)
7724 || (is_tracepoint (b
)))
7725 && loc
->pspace
== current_program_space
7726 && !loc
->shlib_disabled
7727 && solib_name_from_address (loc
->pspace
, loc
->address
)
7730 loc
->shlib_disabled
= 1;
7735 /* Disable any breakpoints and tracepoints that are in SOLIB upon
7736 notification of unloaded_shlib. Only apply to enabled breakpoints,
7737 disabled ones can just stay disabled. */
7740 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
7742 struct bp_location
*loc
, **locp_tmp
;
7743 int disabled_shlib_breaks
= 0;
7745 ALL_BP_LOCATIONS (loc
, locp_tmp
)
7747 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7748 struct breakpoint
*b
= loc
->owner
;
7750 if (solib
->pspace
== loc
->pspace
7751 && !loc
->shlib_disabled
7752 && (((b
->type
== bp_breakpoint
7753 || b
->type
== bp_jit_event
7754 || b
->type
== bp_hardware_breakpoint
)
7755 && (loc
->loc_type
== bp_loc_hardware_breakpoint
7756 || loc
->loc_type
== bp_loc_software_breakpoint
))
7757 || is_tracepoint (b
))
7758 && solib_contains_address_p (solib
, loc
->address
))
7760 loc
->shlib_disabled
= 1;
7761 /* At this point, we cannot rely on remove_breakpoint
7762 succeeding so we must mark the breakpoint as not inserted
7763 to prevent future errors occurring in remove_breakpoints. */
7766 /* This may cause duplicate notifications for the same breakpoint. */
7767 observer_notify_breakpoint_modified (b
);
7769 if (!disabled_shlib_breaks
)
7771 target_terminal::ours_for_output ();
7772 warning (_("Temporarily disabling breakpoints "
7773 "for unloaded shared library \"%s\""),
7776 disabled_shlib_breaks
= 1;
7781 /* Disable any breakpoints and tracepoints in OBJFILE upon
7782 notification of free_objfile. Only apply to enabled breakpoints,
7783 disabled ones can just stay disabled. */
7786 disable_breakpoints_in_freed_objfile (struct objfile
*objfile
)
7788 struct breakpoint
*b
;
7790 if (objfile
== NULL
)
7793 /* OBJF_SHARED|OBJF_USERLOADED objfiles are dynamic modules manually
7794 managed by the user with add-symbol-file/remove-symbol-file.
7795 Similarly to how breakpoints in shared libraries are handled in
7796 response to "nosharedlibrary", mark breakpoints in such modules
7797 shlib_disabled so they end up uninserted on the next global
7798 location list update. Shared libraries not loaded by the user
7799 aren't handled here -- they're already handled in
7800 disable_breakpoints_in_unloaded_shlib, called by solib.c's
7801 solib_unloaded observer. We skip objfiles that are not
7802 OBJF_SHARED as those aren't considered dynamic objects (e.g. the
7804 if ((objfile
->flags
& OBJF_SHARED
) == 0
7805 || (objfile
->flags
& OBJF_USERLOADED
) == 0)
7810 struct bp_location
*loc
;
7811 int bp_modified
= 0;
7813 if (!is_breakpoint (b
) && !is_tracepoint (b
))
7816 for (loc
= b
->loc
; loc
!= NULL
; loc
= loc
->next
)
7818 CORE_ADDR loc_addr
= loc
->address
;
7820 if (loc
->loc_type
!= bp_loc_hardware_breakpoint
7821 && loc
->loc_type
!= bp_loc_software_breakpoint
)
7824 if (loc
->shlib_disabled
!= 0)
7827 if (objfile
->pspace
!= loc
->pspace
)
7830 if (loc
->loc_type
!= bp_loc_hardware_breakpoint
7831 && loc
->loc_type
!= bp_loc_software_breakpoint
)
7834 if (is_addr_in_objfile (loc_addr
, objfile
))
7836 loc
->shlib_disabled
= 1;
7837 /* At this point, we don't know whether the object was
7838 unmapped from the inferior or not, so leave the
7839 inserted flag alone. We'll handle failure to
7840 uninsert quietly, in case the object was indeed
7843 mark_breakpoint_location_modified (loc
);
7850 observer_notify_breakpoint_modified (b
);
7854 /* FORK & VFORK catchpoints. */
7856 /* An instance of this type is used to represent a fork or vfork
7857 catchpoint. A breakpoint is really of this type iff its ops pointer points
7858 to CATCH_FORK_BREAKPOINT_OPS. */
7860 struct fork_catchpoint
: public breakpoint
7862 /* Process id of a child process whose forking triggered this
7863 catchpoint. This field is only valid immediately after this
7864 catchpoint has triggered. */
7865 ptid_t forked_inferior_pid
;
7868 /* Implement the "insert" breakpoint_ops method for fork
7872 insert_catch_fork (struct bp_location
*bl
)
7874 return target_insert_fork_catchpoint (ptid_get_pid (inferior_ptid
));
7877 /* Implement the "remove" breakpoint_ops method for fork
7881 remove_catch_fork (struct bp_location
*bl
, enum remove_bp_reason reason
)
7883 return target_remove_fork_catchpoint (ptid_get_pid (inferior_ptid
));
7886 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
7890 breakpoint_hit_catch_fork (const struct bp_location
*bl
,
7891 struct address_space
*aspace
, CORE_ADDR bp_addr
,
7892 const struct target_waitstatus
*ws
)
7894 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bl
->owner
;
7896 if (ws
->kind
!= TARGET_WAITKIND_FORKED
)
7899 c
->forked_inferior_pid
= ws
->value
.related_pid
;
7903 /* Implement the "print_it" breakpoint_ops method for fork
7906 static enum print_stop_action
7907 print_it_catch_fork (bpstat bs
)
7909 struct ui_out
*uiout
= current_uiout
;
7910 struct breakpoint
*b
= bs
->breakpoint_at
;
7911 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bs
->breakpoint_at
;
7913 annotate_catchpoint (b
->number
);
7914 maybe_print_thread_hit_breakpoint (uiout
);
7915 if (b
->disposition
== disp_del
)
7916 uiout
->text ("Temporary catchpoint ");
7918 uiout
->text ("Catchpoint ");
7919 if (uiout
->is_mi_like_p ())
7921 uiout
->field_string ("reason", async_reason_lookup (EXEC_ASYNC_FORK
));
7922 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
7924 uiout
->field_int ("bkptno", b
->number
);
7925 uiout
->text (" (forked process ");
7926 uiout
->field_int ("newpid", ptid_get_pid (c
->forked_inferior_pid
));
7927 uiout
->text ("), ");
7928 return PRINT_SRC_AND_LOC
;
7931 /* Implement the "print_one" breakpoint_ops method for fork
7935 print_one_catch_fork (struct breakpoint
*b
, struct bp_location
**last_loc
)
7937 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
7938 struct value_print_options opts
;
7939 struct ui_out
*uiout
= current_uiout
;
7941 get_user_print_options (&opts
);
7943 /* Field 4, the address, is omitted (which makes the columns not
7944 line up too nicely with the headers, but the effect is relatively
7946 if (opts
.addressprint
)
7947 uiout
->field_skip ("addr");
7949 uiout
->text ("fork");
7950 if (!ptid_equal (c
->forked_inferior_pid
, null_ptid
))
7952 uiout
->text (", process ");
7953 uiout
->field_int ("what", ptid_get_pid (c
->forked_inferior_pid
));
7957 if (uiout
->is_mi_like_p ())
7958 uiout
->field_string ("catch-type", "fork");
7961 /* Implement the "print_mention" breakpoint_ops method for fork
7965 print_mention_catch_fork (struct breakpoint
*b
)
7967 printf_filtered (_("Catchpoint %d (fork)"), b
->number
);
7970 /* Implement the "print_recreate" breakpoint_ops method for fork
7974 print_recreate_catch_fork (struct breakpoint
*b
, struct ui_file
*fp
)
7976 fprintf_unfiltered (fp
, "catch fork");
7977 print_recreate_thread (b
, fp
);
7980 /* The breakpoint_ops structure to be used in fork catchpoints. */
7982 static struct breakpoint_ops catch_fork_breakpoint_ops
;
7984 /* Implement the "insert" breakpoint_ops method for vfork
7988 insert_catch_vfork (struct bp_location
*bl
)
7990 return target_insert_vfork_catchpoint (ptid_get_pid (inferior_ptid
));
7993 /* Implement the "remove" breakpoint_ops method for vfork
7997 remove_catch_vfork (struct bp_location
*bl
, enum remove_bp_reason reason
)
7999 return target_remove_vfork_catchpoint (ptid_get_pid (inferior_ptid
));
8002 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
8006 breakpoint_hit_catch_vfork (const struct bp_location
*bl
,
8007 struct address_space
*aspace
, CORE_ADDR bp_addr
,
8008 const struct target_waitstatus
*ws
)
8010 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bl
->owner
;
8012 if (ws
->kind
!= TARGET_WAITKIND_VFORKED
)
8015 c
->forked_inferior_pid
= ws
->value
.related_pid
;
8019 /* Implement the "print_it" breakpoint_ops method for vfork
8022 static enum print_stop_action
8023 print_it_catch_vfork (bpstat bs
)
8025 struct ui_out
*uiout
= current_uiout
;
8026 struct breakpoint
*b
= bs
->breakpoint_at
;
8027 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
8029 annotate_catchpoint (b
->number
);
8030 maybe_print_thread_hit_breakpoint (uiout
);
8031 if (b
->disposition
== disp_del
)
8032 uiout
->text ("Temporary catchpoint ");
8034 uiout
->text ("Catchpoint ");
8035 if (uiout
->is_mi_like_p ())
8037 uiout
->field_string ("reason", async_reason_lookup (EXEC_ASYNC_VFORK
));
8038 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
8040 uiout
->field_int ("bkptno", b
->number
);
8041 uiout
->text (" (vforked process ");
8042 uiout
->field_int ("newpid", ptid_get_pid (c
->forked_inferior_pid
));
8043 uiout
->text ("), ");
8044 return PRINT_SRC_AND_LOC
;
8047 /* Implement the "print_one" breakpoint_ops method for vfork
8051 print_one_catch_vfork (struct breakpoint
*b
, struct bp_location
**last_loc
)
8053 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
8054 struct value_print_options opts
;
8055 struct ui_out
*uiout
= current_uiout
;
8057 get_user_print_options (&opts
);
8058 /* Field 4, the address, is omitted (which makes the columns not
8059 line up too nicely with the headers, but the effect is relatively
8061 if (opts
.addressprint
)
8062 uiout
->field_skip ("addr");
8064 uiout
->text ("vfork");
8065 if (!ptid_equal (c
->forked_inferior_pid
, null_ptid
))
8067 uiout
->text (", process ");
8068 uiout
->field_int ("what", ptid_get_pid (c
->forked_inferior_pid
));
8072 if (uiout
->is_mi_like_p ())
8073 uiout
->field_string ("catch-type", "vfork");
8076 /* Implement the "print_mention" breakpoint_ops method for vfork
8080 print_mention_catch_vfork (struct breakpoint
*b
)
8082 printf_filtered (_("Catchpoint %d (vfork)"), b
->number
);
8085 /* Implement the "print_recreate" breakpoint_ops method for vfork
8089 print_recreate_catch_vfork (struct breakpoint
*b
, struct ui_file
*fp
)
8091 fprintf_unfiltered (fp
, "catch vfork");
8092 print_recreate_thread (b
, fp
);
8095 /* The breakpoint_ops structure to be used in vfork catchpoints. */
8097 static struct breakpoint_ops catch_vfork_breakpoint_ops
;
8099 /* An instance of this type is used to represent an solib catchpoint.
8100 A breakpoint is really of this type iff its ops pointer points to
8101 CATCH_SOLIB_BREAKPOINT_OPS. */
8103 struct solib_catchpoint
: public breakpoint
8105 ~solib_catchpoint () override
;
8107 /* True for "catch load", false for "catch unload". */
8108 unsigned char is_load
;
8110 /* Regular expression to match, if any. COMPILED is only valid when
8111 REGEX is non-NULL. */
8113 std::unique_ptr
<compiled_regex
> compiled
;
8116 solib_catchpoint::~solib_catchpoint ()
8118 xfree (this->regex
);
8122 insert_catch_solib (struct bp_location
*ignore
)
8128 remove_catch_solib (struct bp_location
*ignore
, enum remove_bp_reason reason
)
8134 breakpoint_hit_catch_solib (const struct bp_location
*bl
,
8135 struct address_space
*aspace
,
8137 const struct target_waitstatus
*ws
)
8139 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) bl
->owner
;
8140 struct breakpoint
*other
;
8142 if (ws
->kind
== TARGET_WAITKIND_LOADED
)
8145 ALL_BREAKPOINTS (other
)
8147 struct bp_location
*other_bl
;
8149 if (other
== bl
->owner
)
8152 if (other
->type
!= bp_shlib_event
)
8155 if (self
->pspace
!= NULL
&& other
->pspace
!= self
->pspace
)
8158 for (other_bl
= other
->loc
; other_bl
!= NULL
; other_bl
= other_bl
->next
)
8160 if (other
->ops
->breakpoint_hit (other_bl
, aspace
, bp_addr
, ws
))
8169 check_status_catch_solib (struct bpstats
*bs
)
8171 struct solib_catchpoint
*self
8172 = (struct solib_catchpoint
*) bs
->breakpoint_at
;
8177 struct so_list
*iter
;
8180 VEC_iterate (so_list_ptr
, current_program_space
->added_solibs
,
8185 || self
->compiled
->exec (iter
->so_name
, 0, NULL
, 0) == 0)
8194 VEC_iterate (char_ptr
, current_program_space
->deleted_solibs
,
8199 || self
->compiled
->exec (iter
, 0, NULL
, 0) == 0)
8205 bs
->print_it
= print_it_noop
;
8208 static enum print_stop_action
8209 print_it_catch_solib (bpstat bs
)
8211 struct breakpoint
*b
= bs
->breakpoint_at
;
8212 struct ui_out
*uiout
= current_uiout
;
8214 annotate_catchpoint (b
->number
);
8215 maybe_print_thread_hit_breakpoint (uiout
);
8216 if (b
->disposition
== disp_del
)
8217 uiout
->text ("Temporary catchpoint ");
8219 uiout
->text ("Catchpoint ");
8220 uiout
->field_int ("bkptno", b
->number
);
8222 if (uiout
->is_mi_like_p ())
8223 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
8224 print_solib_event (1);
8225 return PRINT_SRC_AND_LOC
;
8229 print_one_catch_solib (struct breakpoint
*b
, struct bp_location
**locs
)
8231 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8232 struct value_print_options opts
;
8233 struct ui_out
*uiout
= current_uiout
;
8236 get_user_print_options (&opts
);
8237 /* Field 4, the address, is omitted (which makes the columns not
8238 line up too nicely with the headers, but the effect is relatively
8240 if (opts
.addressprint
)
8243 uiout
->field_skip ("addr");
8250 msg
= xstrprintf (_("load of library matching %s"), self
->regex
);
8252 msg
= xstrdup (_("load of library"));
8257 msg
= xstrprintf (_("unload of library matching %s"), self
->regex
);
8259 msg
= xstrdup (_("unload of library"));
8261 uiout
->field_string ("what", msg
);
8264 if (uiout
->is_mi_like_p ())
8265 uiout
->field_string ("catch-type", self
->is_load
? "load" : "unload");
8269 print_mention_catch_solib (struct breakpoint
*b
)
8271 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8273 printf_filtered (_("Catchpoint %d (%s)"), b
->number
,
8274 self
->is_load
? "load" : "unload");
8278 print_recreate_catch_solib (struct breakpoint
*b
, struct ui_file
*fp
)
8280 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8282 fprintf_unfiltered (fp
, "%s %s",
8283 b
->disposition
== disp_del
? "tcatch" : "catch",
8284 self
->is_load
? "load" : "unload");
8286 fprintf_unfiltered (fp
, " %s", self
->regex
);
8287 fprintf_unfiltered (fp
, "\n");
8290 static struct breakpoint_ops catch_solib_breakpoint_ops
;
8292 /* Shared helper function (MI and CLI) for creating and installing
8293 a shared object event catchpoint. If IS_LOAD is non-zero then
8294 the events to be caught are load events, otherwise they are
8295 unload events. If IS_TEMP is non-zero the catchpoint is a
8296 temporary one. If ENABLED is non-zero the catchpoint is
8297 created in an enabled state. */
8300 add_solib_catchpoint (const char *arg
, int is_load
, int is_temp
, int enabled
)
8302 struct gdbarch
*gdbarch
= get_current_arch ();
8306 arg
= skip_spaces (arg
);
8308 std::unique_ptr
<solib_catchpoint
> c (new solib_catchpoint ());
8312 c
->compiled
.reset (new compiled_regex (arg
, REG_NOSUB
,
8313 _("Invalid regexp")));
8314 c
->regex
= xstrdup (arg
);
8317 c
->is_load
= is_load
;
8318 init_catchpoint (c
.get (), gdbarch
, is_temp
, NULL
,
8319 &catch_solib_breakpoint_ops
);
8321 c
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
8323 install_breakpoint (0, std::move (c
), 1);
8326 /* A helper function that does all the work for "catch load" and
8330 catch_load_or_unload (char *arg
, int from_tty
, int is_load
,
8331 struct cmd_list_element
*command
)
8334 const int enabled
= 1;
8336 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
8338 add_solib_catchpoint (arg
, is_load
, tempflag
, enabled
);
8342 catch_load_command_1 (char *arg
, int from_tty
,
8343 struct cmd_list_element
*command
)
8345 catch_load_or_unload (arg
, from_tty
, 1, command
);
8349 catch_unload_command_1 (char *arg
, int from_tty
,
8350 struct cmd_list_element
*command
)
8352 catch_load_or_unload (arg
, from_tty
, 0, command
);
8355 /* Initialize a new breakpoint of the bp_catchpoint kind. If TEMPFLAG
8356 is non-zero, then make the breakpoint temporary. If COND_STRING is
8357 not NULL, then store it in the breakpoint. OPS, if not NULL, is
8358 the breakpoint_ops structure associated to the catchpoint. */
8361 init_catchpoint (struct breakpoint
*b
,
8362 struct gdbarch
*gdbarch
, int tempflag
,
8363 const char *cond_string
,
8364 const struct breakpoint_ops
*ops
)
8366 symtab_and_line sal
;
8367 sal
.pspace
= current_program_space
;
8369 init_raw_breakpoint (b
, gdbarch
, sal
, bp_catchpoint
, ops
);
8371 b
->cond_string
= (cond_string
== NULL
) ? NULL
: xstrdup (cond_string
);
8372 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
8376 install_breakpoint (int internal
, std::unique_ptr
<breakpoint
> &&arg
, int update_gll
)
8378 breakpoint
*b
= add_to_breakpoint_chain (std::move (arg
));
8379 set_breakpoint_number (internal
, b
);
8380 if (is_tracepoint (b
))
8381 set_tracepoint_count (breakpoint_count
);
8384 observer_notify_breakpoint_created (b
);
8387 update_global_location_list (UGLL_MAY_INSERT
);
8391 create_fork_vfork_event_catchpoint (struct gdbarch
*gdbarch
,
8392 int tempflag
, const char *cond_string
,
8393 const struct breakpoint_ops
*ops
)
8395 std::unique_ptr
<fork_catchpoint
> c (new fork_catchpoint ());
8397 init_catchpoint (c
.get (), gdbarch
, tempflag
, cond_string
, ops
);
8399 c
->forked_inferior_pid
= null_ptid
;
8401 install_breakpoint (0, std::move (c
), 1);
8404 /* Exec catchpoints. */
8406 /* An instance of this type is used to represent an exec catchpoint.
8407 A breakpoint is really of this type iff its ops pointer points to
8408 CATCH_EXEC_BREAKPOINT_OPS. */
8410 struct exec_catchpoint
: public breakpoint
8412 ~exec_catchpoint () override
;
8414 /* Filename of a program whose exec triggered this catchpoint.
8415 This field is only valid immediately after this catchpoint has
8417 char *exec_pathname
;
8420 /* Exec catchpoint destructor. */
8422 exec_catchpoint::~exec_catchpoint ()
8424 xfree (this->exec_pathname
);
8428 insert_catch_exec (struct bp_location
*bl
)
8430 return target_insert_exec_catchpoint (ptid_get_pid (inferior_ptid
));
8434 remove_catch_exec (struct bp_location
*bl
, enum remove_bp_reason reason
)
8436 return target_remove_exec_catchpoint (ptid_get_pid (inferior_ptid
));
8440 breakpoint_hit_catch_exec (const struct bp_location
*bl
,
8441 struct address_space
*aspace
, CORE_ADDR bp_addr
,
8442 const struct target_waitstatus
*ws
)
8444 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) bl
->owner
;
8446 if (ws
->kind
!= TARGET_WAITKIND_EXECD
)
8449 c
->exec_pathname
= xstrdup (ws
->value
.execd_pathname
);
8453 static enum print_stop_action
8454 print_it_catch_exec (bpstat bs
)
8456 struct ui_out
*uiout
= current_uiout
;
8457 struct breakpoint
*b
= bs
->breakpoint_at
;
8458 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
8460 annotate_catchpoint (b
->number
);
8461 maybe_print_thread_hit_breakpoint (uiout
);
8462 if (b
->disposition
== disp_del
)
8463 uiout
->text ("Temporary catchpoint ");
8465 uiout
->text ("Catchpoint ");
8466 if (uiout
->is_mi_like_p ())
8468 uiout
->field_string ("reason", async_reason_lookup (EXEC_ASYNC_EXEC
));
8469 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
8471 uiout
->field_int ("bkptno", b
->number
);
8472 uiout
->text (" (exec'd ");
8473 uiout
->field_string ("new-exec", c
->exec_pathname
);
8474 uiout
->text ("), ");
8476 return PRINT_SRC_AND_LOC
;
8480 print_one_catch_exec (struct breakpoint
*b
, struct bp_location
**last_loc
)
8482 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
8483 struct value_print_options opts
;
8484 struct ui_out
*uiout
= current_uiout
;
8486 get_user_print_options (&opts
);
8488 /* Field 4, the address, is omitted (which makes the columns
8489 not line up too nicely with the headers, but the effect
8490 is relatively readable). */
8491 if (opts
.addressprint
)
8492 uiout
->field_skip ("addr");
8494 uiout
->text ("exec");
8495 if (c
->exec_pathname
!= NULL
)
8497 uiout
->text (", program \"");
8498 uiout
->field_string ("what", c
->exec_pathname
);
8499 uiout
->text ("\" ");
8502 if (uiout
->is_mi_like_p ())
8503 uiout
->field_string ("catch-type", "exec");
8507 print_mention_catch_exec (struct breakpoint
*b
)
8509 printf_filtered (_("Catchpoint %d (exec)"), b
->number
);
8512 /* Implement the "print_recreate" breakpoint_ops method for exec
8516 print_recreate_catch_exec (struct breakpoint
*b
, struct ui_file
*fp
)
8518 fprintf_unfiltered (fp
, "catch exec");
8519 print_recreate_thread (b
, fp
);
8522 static struct breakpoint_ops catch_exec_breakpoint_ops
;
8525 hw_breakpoint_used_count (void)
8528 struct breakpoint
*b
;
8529 struct bp_location
*bl
;
8533 if (b
->type
== bp_hardware_breakpoint
&& breakpoint_enabled (b
))
8534 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
8536 /* Special types of hardware breakpoints may use more than
8538 i
+= b
->ops
->resources_needed (bl
);
8545 /* Returns the resources B would use if it were a hardware
8549 hw_watchpoint_use_count (struct breakpoint
*b
)
8552 struct bp_location
*bl
;
8554 if (!breakpoint_enabled (b
))
8557 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
8559 /* Special types of hardware watchpoints may use more than
8561 i
+= b
->ops
->resources_needed (bl
);
8567 /* Returns the sum the used resources of all hardware watchpoints of
8568 type TYPE in the breakpoints list. Also returns in OTHER_TYPE_USED
8569 the sum of the used resources of all hardware watchpoints of other
8570 types _not_ TYPE. */
8573 hw_watchpoint_used_count_others (struct breakpoint
*except
,
8574 enum bptype type
, int *other_type_used
)
8577 struct breakpoint
*b
;
8579 *other_type_used
= 0;
8584 if (!breakpoint_enabled (b
))
8587 if (b
->type
== type
)
8588 i
+= hw_watchpoint_use_count (b
);
8589 else if (is_hardware_watchpoint (b
))
8590 *other_type_used
= 1;
8597 disable_watchpoints_before_interactive_call_start (void)
8599 struct breakpoint
*b
;
8603 if (is_watchpoint (b
) && breakpoint_enabled (b
))
8605 b
->enable_state
= bp_call_disabled
;
8606 update_global_location_list (UGLL_DONT_INSERT
);
8612 enable_watchpoints_after_interactive_call_stop (void)
8614 struct breakpoint
*b
;
8618 if (is_watchpoint (b
) && b
->enable_state
== bp_call_disabled
)
8620 b
->enable_state
= bp_enabled
;
8621 update_global_location_list (UGLL_MAY_INSERT
);
8627 disable_breakpoints_before_startup (void)
8629 current_program_space
->executing_startup
= 1;
8630 update_global_location_list (UGLL_DONT_INSERT
);
8634 enable_breakpoints_after_startup (void)
8636 current_program_space
->executing_startup
= 0;
8637 breakpoint_re_set ();
8640 /* Create a new single-step breakpoint for thread THREAD, with no
8643 static struct breakpoint
*
8644 new_single_step_breakpoint (int thread
, struct gdbarch
*gdbarch
)
8646 std::unique_ptr
<breakpoint
> b (new breakpoint ());
8648 init_raw_breakpoint_without_location (b
.get (), gdbarch
, bp_single_step
,
8649 &momentary_breakpoint_ops
);
8651 b
->disposition
= disp_donttouch
;
8652 b
->frame_id
= null_frame_id
;
8655 gdb_assert (b
->thread
!= 0);
8657 return add_to_breakpoint_chain (std::move (b
));
8660 /* Set a momentary breakpoint of type TYPE at address specified by
8661 SAL. If FRAME_ID is valid, the breakpoint is restricted to that
8665 set_momentary_breakpoint (struct gdbarch
*gdbarch
, struct symtab_and_line sal
,
8666 struct frame_id frame_id
, enum bptype type
)
8668 struct breakpoint
*b
;
8670 /* If FRAME_ID is valid, it should be a real frame, not an inlined or
8672 gdb_assert (!frame_id_artificial_p (frame_id
));
8674 b
= set_raw_breakpoint (gdbarch
, sal
, type
, &momentary_breakpoint_ops
);
8675 b
->enable_state
= bp_enabled
;
8676 b
->disposition
= disp_donttouch
;
8677 b
->frame_id
= frame_id
;
8679 /* If we're debugging a multi-threaded program, then we want
8680 momentary breakpoints to be active in only a single thread of
8682 if (in_thread_list (inferior_ptid
))
8683 b
->thread
= ptid_to_global_thread_id (inferior_ptid
);
8685 update_global_location_list_nothrow (UGLL_MAY_INSERT
);
8690 /* Make a momentary breakpoint based on the master breakpoint ORIG.
8691 The new breakpoint will have type TYPE, use OPS as its
8692 breakpoint_ops, and will set enabled to LOC_ENABLED. */
8694 static struct breakpoint
*
8695 momentary_breakpoint_from_master (struct breakpoint
*orig
,
8697 const struct breakpoint_ops
*ops
,
8700 struct breakpoint
*copy
;
8702 copy
= set_raw_breakpoint_without_location (orig
->gdbarch
, type
, ops
);
8703 copy
->loc
= allocate_bp_location (copy
);
8704 set_breakpoint_location_function (copy
->loc
, 1);
8706 copy
->loc
->gdbarch
= orig
->loc
->gdbarch
;
8707 copy
->loc
->requested_address
= orig
->loc
->requested_address
;
8708 copy
->loc
->address
= orig
->loc
->address
;
8709 copy
->loc
->section
= orig
->loc
->section
;
8710 copy
->loc
->pspace
= orig
->loc
->pspace
;
8711 copy
->loc
->probe
= orig
->loc
->probe
;
8712 copy
->loc
->line_number
= orig
->loc
->line_number
;
8713 copy
->loc
->symtab
= orig
->loc
->symtab
;
8714 copy
->loc
->enabled
= loc_enabled
;
8715 copy
->frame_id
= orig
->frame_id
;
8716 copy
->thread
= orig
->thread
;
8717 copy
->pspace
= orig
->pspace
;
8719 copy
->enable_state
= bp_enabled
;
8720 copy
->disposition
= disp_donttouch
;
8721 copy
->number
= internal_breakpoint_number
--;
8723 update_global_location_list_nothrow (UGLL_DONT_INSERT
);
8727 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
8731 clone_momentary_breakpoint (struct breakpoint
*orig
)
8733 /* If there's nothing to clone, then return nothing. */
8737 return momentary_breakpoint_from_master (orig
, orig
->type
, orig
->ops
, 0);
8741 set_momentary_breakpoint_at_pc (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
8744 struct symtab_and_line sal
;
8746 sal
= find_pc_line (pc
, 0);
8748 sal
.section
= find_pc_overlay (pc
);
8749 sal
.explicit_pc
= 1;
8751 return set_momentary_breakpoint (gdbarch
, sal
, null_frame_id
, type
);
8755 /* Tell the user we have just set a breakpoint B. */
8758 mention (struct breakpoint
*b
)
8760 b
->ops
->print_mention (b
);
8761 if (current_uiout
->is_mi_like_p ())
8763 printf_filtered ("\n");
8767 static int bp_loc_is_permanent (struct bp_location
*loc
);
8769 static struct bp_location
*
8770 add_location_to_breakpoint (struct breakpoint
*b
,
8771 const struct symtab_and_line
*sal
)
8773 struct bp_location
*loc
, **tmp
;
8774 CORE_ADDR adjusted_address
;
8775 struct gdbarch
*loc_gdbarch
= get_sal_arch (*sal
);
8777 if (loc_gdbarch
== NULL
)
8778 loc_gdbarch
= b
->gdbarch
;
8780 /* Adjust the breakpoint's address prior to allocating a location.
8781 Once we call allocate_bp_location(), that mostly uninitialized
8782 location will be placed on the location chain. Adjustment of the
8783 breakpoint may cause target_read_memory() to be called and we do
8784 not want its scan of the location chain to find a breakpoint and
8785 location that's only been partially initialized. */
8786 adjusted_address
= adjust_breakpoint_address (loc_gdbarch
,
8789 /* Sort the locations by their ADDRESS. */
8790 loc
= allocate_bp_location (b
);
8791 for (tmp
= &(b
->loc
); *tmp
!= NULL
&& (*tmp
)->address
<= adjusted_address
;
8792 tmp
= &((*tmp
)->next
))
8797 loc
->requested_address
= sal
->pc
;
8798 loc
->address
= adjusted_address
;
8799 loc
->pspace
= sal
->pspace
;
8800 loc
->probe
.probe
= sal
->probe
;
8801 loc
->probe
.objfile
= sal
->objfile
;
8802 gdb_assert (loc
->pspace
!= NULL
);
8803 loc
->section
= sal
->section
;
8804 loc
->gdbarch
= loc_gdbarch
;
8805 loc
->line_number
= sal
->line
;
8806 loc
->symtab
= sal
->symtab
;
8808 set_breakpoint_location_function (loc
,
8809 sal
->explicit_pc
|| sal
->explicit_line
);
8811 /* While by definition, permanent breakpoints are already present in the
8812 code, we don't mark the location as inserted. Normally one would expect
8813 that GDB could rely on that breakpoint instruction to stop the program,
8814 thus removing the need to insert its own breakpoint, except that executing
8815 the breakpoint instruction can kill the target instead of reporting a
8816 SIGTRAP. E.g., on SPARC, when interrupts are disabled, executing the
8817 instruction resets the CPU, so QEMU 2.0.0 for SPARC correspondingly dies
8818 with "Trap 0x02 while interrupts disabled, Error state". Letting the
8819 breakpoint be inserted normally results in QEMU knowing about the GDB
8820 breakpoint, and thus trap before the breakpoint instruction is executed.
8821 (If GDB later needs to continue execution past the permanent breakpoint,
8822 it manually increments the PC, thus avoiding executing the breakpoint
8824 if (bp_loc_is_permanent (loc
))
8831 /* See breakpoint.h. */
8834 program_breakpoint_here_p (struct gdbarch
*gdbarch
, CORE_ADDR address
)
8838 const gdb_byte
*bpoint
;
8839 gdb_byte
*target_mem
;
8842 bpoint
= gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &len
);
8844 /* Software breakpoints unsupported? */
8848 target_mem
= (gdb_byte
*) alloca (len
);
8850 /* Enable the automatic memory restoration from breakpoints while
8851 we read the memory. Otherwise we could say about our temporary
8852 breakpoints they are permanent. */
8853 scoped_restore restore_memory
8854 = make_scoped_restore_show_memory_breakpoints (0);
8856 if (target_read_memory (address
, target_mem
, len
) == 0
8857 && memcmp (target_mem
, bpoint
, len
) == 0)
8863 /* Return 1 if LOC is pointing to a permanent breakpoint,
8864 return 0 otherwise. */
8867 bp_loc_is_permanent (struct bp_location
*loc
)
8869 gdb_assert (loc
!= NULL
);
8871 /* If we have a catchpoint or a watchpoint, just return 0. We should not
8872 attempt to read from the addresses the locations of these breakpoint types
8873 point to. program_breakpoint_here_p, below, will attempt to read
8875 if (!breakpoint_address_is_meaningful (loc
->owner
))
8878 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
8879 switch_to_program_space_and_thread (loc
->pspace
);
8880 return program_breakpoint_here_p (loc
->gdbarch
, loc
->address
);
8883 /* Build a command list for the dprintf corresponding to the current
8884 settings of the dprintf style options. */
8887 update_dprintf_command_list (struct breakpoint
*b
)
8889 char *dprintf_args
= b
->extra_string
;
8890 char *printf_line
= NULL
;
8895 dprintf_args
= skip_spaces (dprintf_args
);
8897 /* Allow a comma, as it may have terminated a location, but don't
8899 if (*dprintf_args
== ',')
8901 dprintf_args
= skip_spaces (dprintf_args
);
8903 if (*dprintf_args
!= '"')
8904 error (_("Bad format string, missing '\"'."));
8906 if (strcmp (dprintf_style
, dprintf_style_gdb
) == 0)
8907 printf_line
= xstrprintf ("printf %s", dprintf_args
);
8908 else if (strcmp (dprintf_style
, dprintf_style_call
) == 0)
8910 if (!dprintf_function
)
8911 error (_("No function supplied for dprintf call"));
8913 if (dprintf_channel
&& strlen (dprintf_channel
) > 0)
8914 printf_line
= xstrprintf ("call (void) %s (%s,%s)",
8919 printf_line
= xstrprintf ("call (void) %s (%s)",
8923 else if (strcmp (dprintf_style
, dprintf_style_agent
) == 0)
8925 if (target_can_run_breakpoint_commands ())
8926 printf_line
= xstrprintf ("agent-printf %s", dprintf_args
);
8929 warning (_("Target cannot run dprintf commands, falling back to GDB printf"));
8930 printf_line
= xstrprintf ("printf %s", dprintf_args
);
8934 internal_error (__FILE__
, __LINE__
,
8935 _("Invalid dprintf style."));
8937 gdb_assert (printf_line
!= NULL
);
8938 /* Manufacture a printf sequence. */
8940 struct command_line
*printf_cmd_line
= XNEW (struct command_line
);
8942 printf_cmd_line
->control_type
= simple_control
;
8943 printf_cmd_line
->body_count
= 0;
8944 printf_cmd_line
->body_list
= NULL
;
8945 printf_cmd_line
->next
= NULL
;
8946 printf_cmd_line
->line
= printf_line
;
8948 breakpoint_set_commands (b
, command_line_up (printf_cmd_line
));
8952 /* Update all dprintf commands, making their command lists reflect
8953 current style settings. */
8956 update_dprintf_commands (char *args
, int from_tty
,
8957 struct cmd_list_element
*c
)
8959 struct breakpoint
*b
;
8963 if (b
->type
== bp_dprintf
)
8964 update_dprintf_command_list (b
);
8968 /* Create a breakpoint with SAL as location. Use LOCATION
8969 as a description of the location, and COND_STRING
8970 as condition expression. If LOCATION is NULL then create an
8971 "address location" from the address in the SAL. */
8974 init_breakpoint_sal (struct breakpoint
*b
, struct gdbarch
*gdbarch
,
8975 gdb::array_view
<const symtab_and_line
> sals
,
8976 event_location_up
&&location
,
8977 gdb::unique_xmalloc_ptr
<char> filter
,
8978 gdb::unique_xmalloc_ptr
<char> cond_string
,
8979 gdb::unique_xmalloc_ptr
<char> extra_string
,
8980 enum bptype type
, enum bpdisp disposition
,
8981 int thread
, int task
, int ignore_count
,
8982 const struct breakpoint_ops
*ops
, int from_tty
,
8983 int enabled
, int internal
, unsigned flags
,
8984 int display_canonical
)
8988 if (type
== bp_hardware_breakpoint
)
8990 int target_resources_ok
;
8992 i
= hw_breakpoint_used_count ();
8993 target_resources_ok
=
8994 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
8996 if (target_resources_ok
== 0)
8997 error (_("No hardware breakpoint support in the target."));
8998 else if (target_resources_ok
< 0)
8999 error (_("Hardware breakpoints used exceeds limit."));
9002 gdb_assert (!sals
.empty ());
9004 for (const auto &sal
: sals
)
9006 struct bp_location
*loc
;
9010 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
9012 loc_gdbarch
= gdbarch
;
9014 describe_other_breakpoints (loc_gdbarch
,
9015 sal
.pspace
, sal
.pc
, sal
.section
, thread
);
9018 if (&sal
== &sals
[0])
9020 init_raw_breakpoint (b
, gdbarch
, sal
, type
, ops
);
9024 b
->cond_string
= cond_string
.release ();
9025 b
->extra_string
= extra_string
.release ();
9026 b
->ignore_count
= ignore_count
;
9027 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
9028 b
->disposition
= disposition
;
9030 if ((flags
& CREATE_BREAKPOINT_FLAGS_INSERTED
) != 0)
9031 b
->loc
->inserted
= 1;
9033 if (type
== bp_static_tracepoint
)
9035 struct tracepoint
*t
= (struct tracepoint
*) b
;
9036 struct static_tracepoint_marker marker
;
9038 if (strace_marker_p (b
))
9040 /* We already know the marker exists, otherwise, we
9041 wouldn't see a sal for it. */
9043 = &event_location_to_string (b
->location
.get ())[3];
9047 p
= skip_spaces (p
);
9049 endp
= skip_to_space (p
);
9051 marker_str
= savestring (p
, endp
- p
);
9052 t
->static_trace_marker_id
= marker_str
;
9054 printf_filtered (_("Probed static tracepoint "
9056 t
->static_trace_marker_id
);
9058 else if (target_static_tracepoint_marker_at (sal
.pc
, &marker
))
9060 t
->static_trace_marker_id
= xstrdup (marker
.str_id
);
9061 release_static_tracepoint_marker (&marker
);
9063 printf_filtered (_("Probed static tracepoint "
9065 t
->static_trace_marker_id
);
9068 warning (_("Couldn't determine the static "
9069 "tracepoint marker to probe"));
9076 loc
= add_location_to_breakpoint (b
, &sal
);
9077 if ((flags
& CREATE_BREAKPOINT_FLAGS_INSERTED
) != 0)
9083 const char *arg
= b
->cond_string
;
9085 loc
->cond
= parse_exp_1 (&arg
, loc
->address
,
9086 block_for_pc (loc
->address
), 0);
9088 error (_("Garbage '%s' follows condition"), arg
);
9091 /* Dynamic printf requires and uses additional arguments on the
9092 command line, otherwise it's an error. */
9093 if (type
== bp_dprintf
)
9095 if (b
->extra_string
)
9096 update_dprintf_command_list (b
);
9098 error (_("Format string required"));
9100 else if (b
->extra_string
)
9101 error (_("Garbage '%s' at end of command"), b
->extra_string
);
9104 b
->display_canonical
= display_canonical
;
9105 if (location
!= NULL
)
9106 b
->location
= std::move (location
);
9108 b
->location
= new_address_location (b
->loc
->address
, NULL
, 0);
9109 b
->filter
= filter
.release ();
9113 create_breakpoint_sal (struct gdbarch
*gdbarch
,
9114 gdb::array_view
<const symtab_and_line
> sals
,
9115 event_location_up
&&location
,
9116 gdb::unique_xmalloc_ptr
<char> filter
,
9117 gdb::unique_xmalloc_ptr
<char> cond_string
,
9118 gdb::unique_xmalloc_ptr
<char> extra_string
,
9119 enum bptype type
, enum bpdisp disposition
,
9120 int thread
, int task
, int ignore_count
,
9121 const struct breakpoint_ops
*ops
, int from_tty
,
9122 int enabled
, int internal
, unsigned flags
,
9123 int display_canonical
)
9125 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (type
);
9127 init_breakpoint_sal (b
.get (), gdbarch
,
9128 sals
, std::move (location
),
9130 std::move (cond_string
),
9131 std::move (extra_string
),
9133 thread
, task
, ignore_count
,
9135 enabled
, internal
, flags
,
9138 install_breakpoint (internal
, std::move (b
), 0);
9141 /* Add SALS.nelts breakpoints to the breakpoint table. For each
9142 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
9143 value. COND_STRING, if not NULL, specified the condition to be
9144 used for all breakpoints. Essentially the only case where
9145 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
9146 function. In that case, it's still not possible to specify
9147 separate conditions for different overloaded functions, so
9148 we take just a single condition string.
9150 NOTE: If the function succeeds, the caller is expected to cleanup
9151 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
9152 array contents). If the function fails (error() is called), the
9153 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
9154 COND and SALS arrays and each of those arrays contents. */
9157 create_breakpoints_sal (struct gdbarch
*gdbarch
,
9158 struct linespec_result
*canonical
,
9159 gdb::unique_xmalloc_ptr
<char> cond_string
,
9160 gdb::unique_xmalloc_ptr
<char> extra_string
,
9161 enum bptype type
, enum bpdisp disposition
,
9162 int thread
, int task
, int ignore_count
,
9163 const struct breakpoint_ops
*ops
, int from_tty
,
9164 int enabled
, int internal
, unsigned flags
)
9166 if (canonical
->pre_expanded
)
9167 gdb_assert (canonical
->lsals
.size () == 1);
9169 for (const auto &lsal
: canonical
->lsals
)
9171 /* Note that 'location' can be NULL in the case of a plain
9172 'break', without arguments. */
9173 event_location_up location
9174 = (canonical
->location
!= NULL
9175 ? copy_event_location (canonical
->location
.get ()) : NULL
);
9176 gdb::unique_xmalloc_ptr
<char> filter_string
9177 (lsal
.canonical
!= NULL
? xstrdup (lsal
.canonical
) : NULL
);
9179 create_breakpoint_sal (gdbarch
, lsal
.sals
,
9180 std::move (location
),
9181 std::move (filter_string
),
9182 std::move (cond_string
),
9183 std::move (extra_string
),
9185 thread
, task
, ignore_count
, ops
,
9186 from_tty
, enabled
, internal
, flags
,
9187 canonical
->special_display
);
9191 /* Parse LOCATION which is assumed to be a SAL specification possibly
9192 followed by conditionals. On return, SALS contains an array of SAL
9193 addresses found. LOCATION points to the end of the SAL (for
9194 linespec locations).
9196 The array and the line spec strings are allocated on the heap, it is
9197 the caller's responsibility to free them. */
9200 parse_breakpoint_sals (const struct event_location
*location
,
9201 struct linespec_result
*canonical
)
9203 struct symtab_and_line cursal
;
9205 if (event_location_type (location
) == LINESPEC_LOCATION
)
9207 const char *address
= get_linespec_location (location
);
9209 if (address
== NULL
)
9211 /* The last displayed codepoint, if it's valid, is our default
9212 breakpoint address. */
9213 if (last_displayed_sal_is_valid ())
9215 /* Set sal's pspace, pc, symtab, and line to the values
9216 corresponding to the last call to print_frame_info.
9217 Be sure to reinitialize LINE with NOTCURRENT == 0
9218 as the breakpoint line number is inappropriate otherwise.
9219 find_pc_line would adjust PC, re-set it back. */
9220 symtab_and_line sal
= get_last_displayed_sal ();
9221 CORE_ADDR pc
= sal
.pc
;
9223 sal
= find_pc_line (pc
, 0);
9225 /* "break" without arguments is equivalent to "break *PC"
9226 where PC is the last displayed codepoint's address. So
9227 make sure to set sal.explicit_pc to prevent GDB from
9228 trying to expand the list of sals to include all other
9229 instances with the same symtab and line. */
9231 sal
.explicit_pc
= 1;
9233 struct linespec_sals lsal
;
9235 lsal
.canonical
= NULL
;
9237 canonical
->lsals
.push_back (std::move (lsal
));
9241 error (_("No default breakpoint address now."));
9245 /* Force almost all breakpoints to be in terms of the
9246 current_source_symtab (which is decode_line_1's default).
9247 This should produce the results we want almost all of the
9248 time while leaving default_breakpoint_* alone.
9250 ObjC: However, don't match an Objective-C method name which
9251 may have a '+' or '-' succeeded by a '['. */
9252 cursal
= get_current_source_symtab_and_line ();
9253 if (last_displayed_sal_is_valid ())
9255 const char *address
= NULL
;
9257 if (event_location_type (location
) == LINESPEC_LOCATION
)
9258 address
= get_linespec_location (location
);
9262 && strchr ("+-", address
[0]) != NULL
9263 && address
[1] != '['))
9265 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, NULL
,
9266 get_last_displayed_symtab (),
9267 get_last_displayed_line (),
9268 canonical
, NULL
, NULL
);
9273 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, NULL
,
9274 cursal
.symtab
, cursal
.line
, canonical
, NULL
, NULL
);
9278 /* Convert each SAL into a real PC. Verify that the PC can be
9279 inserted as a breakpoint. If it can't throw an error. */
9282 breakpoint_sals_to_pc (std::vector
<symtab_and_line
> &sals
)
9284 for (auto &sal
: sals
)
9285 resolve_sal_pc (&sal
);
9288 /* Fast tracepoints may have restrictions on valid locations. For
9289 instance, a fast tracepoint using a jump instead of a trap will
9290 likely have to overwrite more bytes than a trap would, and so can
9291 only be placed where the instruction is longer than the jump, or a
9292 multi-instruction sequence does not have a jump into the middle of
9296 check_fast_tracepoint_sals (struct gdbarch
*gdbarch
,
9297 gdb::array_view
<const symtab_and_line
> sals
)
9301 struct cleanup
*old_chain
;
9303 for (const auto &sal
: sals
)
9305 struct gdbarch
*sarch
;
9307 sarch
= get_sal_arch (sal
);
9308 /* We fall back to GDBARCH if there is no architecture
9309 associated with SAL. */
9312 rslt
= gdbarch_fast_tracepoint_valid_at (sarch
, sal
.pc
, &msg
);
9313 old_chain
= make_cleanup (xfree
, msg
);
9316 error (_("May not have a fast tracepoint at %s%s"),
9317 paddress (sarch
, sal
.pc
), (msg
? msg
: ""));
9319 do_cleanups (old_chain
);
9323 /* Given TOK, a string specification of condition and thread, as
9324 accepted by the 'break' command, extract the condition
9325 string and thread number and set *COND_STRING and *THREAD.
9326 PC identifies the context at which the condition should be parsed.
9327 If no condition is found, *COND_STRING is set to NULL.
9328 If no thread is found, *THREAD is set to -1. */
9331 find_condition_and_thread (const char *tok
, CORE_ADDR pc
,
9332 char **cond_string
, int *thread
, int *task
,
9335 *cond_string
= NULL
;
9342 const char *end_tok
;
9344 const char *cond_start
= NULL
;
9345 const char *cond_end
= NULL
;
9347 tok
= skip_spaces (tok
);
9349 if ((*tok
== '"' || *tok
== ',') && rest
)
9351 *rest
= savestring (tok
, strlen (tok
));
9355 end_tok
= skip_to_space (tok
);
9357 toklen
= end_tok
- tok
;
9359 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
9361 tok
= cond_start
= end_tok
+ 1;
9362 parse_exp_1 (&tok
, pc
, block_for_pc (pc
), 0);
9364 *cond_string
= savestring (cond_start
, cond_end
- cond_start
);
9366 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
9369 struct thread_info
*thr
;
9372 thr
= parse_thread_id (tok
, &tmptok
);
9374 error (_("Junk after thread keyword."));
9375 *thread
= thr
->global_num
;
9378 else if (toklen
>= 1 && strncmp (tok
, "task", toklen
) == 0)
9383 *task
= strtol (tok
, &tmptok
, 0);
9385 error (_("Junk after task keyword."));
9386 if (!valid_task_id (*task
))
9387 error (_("Unknown task %d."), *task
);
9392 *rest
= savestring (tok
, strlen (tok
));
9396 error (_("Junk at end of arguments."));
9400 /* Decode a static tracepoint marker spec. */
9402 static std::vector
<symtab_and_line
>
9403 decode_static_tracepoint_spec (const char **arg_p
)
9405 VEC(static_tracepoint_marker_p
) *markers
= NULL
;
9406 struct cleanup
*old_chain
;
9407 const char *p
= &(*arg_p
)[3];
9412 p
= skip_spaces (p
);
9414 endp
= skip_to_space (p
);
9416 marker_str
= savestring (p
, endp
- p
);
9417 old_chain
= make_cleanup (xfree
, marker_str
);
9419 markers
= target_static_tracepoint_markers_by_strid (marker_str
);
9420 if (VEC_empty(static_tracepoint_marker_p
, markers
))
9421 error (_("No known static tracepoint marker named %s"), marker_str
);
9423 std::vector
<symtab_and_line
> sals
;
9424 sals
.reserve (VEC_length(static_tracepoint_marker_p
, markers
));
9426 for (i
= 0; i
< VEC_length(static_tracepoint_marker_p
, markers
); i
++)
9428 struct static_tracepoint_marker
*marker
;
9430 marker
= VEC_index (static_tracepoint_marker_p
, markers
, i
);
9432 symtab_and_line sal
= find_pc_line (marker
->address
, 0);
9433 sal
.pc
= marker
->address
;
9434 sals
.push_back (sal
);
9436 release_static_tracepoint_marker (marker
);
9439 do_cleanups (old_chain
);
9445 /* See breakpoint.h. */
9448 create_breakpoint (struct gdbarch
*gdbarch
,
9449 const struct event_location
*location
,
9450 const char *cond_string
,
9451 int thread
, const char *extra_string
,
9453 int tempflag
, enum bptype type_wanted
,
9455 enum auto_boolean pending_break_support
,
9456 const struct breakpoint_ops
*ops
,
9457 int from_tty
, int enabled
, int internal
,
9460 struct linespec_result canonical
;
9461 struct cleanup
*bkpt_chain
= NULL
;
9464 int prev_bkpt_count
= breakpoint_count
;
9466 gdb_assert (ops
!= NULL
);
9468 /* If extra_string isn't useful, set it to NULL. */
9469 if (extra_string
!= NULL
&& *extra_string
== '\0')
9470 extra_string
= NULL
;
9474 ops
->create_sals_from_location (location
, &canonical
, type_wanted
);
9476 CATCH (e
, RETURN_MASK_ERROR
)
9478 /* If caller is interested in rc value from parse, set
9480 if (e
.error
== NOT_FOUND_ERROR
)
9482 /* If pending breakpoint support is turned off, throw
9485 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
9486 throw_exception (e
);
9488 exception_print (gdb_stderr
, e
);
9490 /* If pending breakpoint support is auto query and the user
9491 selects no, then simply return the error code. */
9492 if (pending_break_support
== AUTO_BOOLEAN_AUTO
9493 && !nquery (_("Make %s pending on future shared library load? "),
9494 bptype_string (type_wanted
)))
9497 /* At this point, either the user was queried about setting
9498 a pending breakpoint and selected yes, or pending
9499 breakpoint behavior is on and thus a pending breakpoint
9500 is defaulted on behalf of the user. */
9504 throw_exception (e
);
9508 if (!pending
&& canonical
.lsals
.empty ())
9511 /* ----------------------------- SNIP -----------------------------
9512 Anything added to the cleanup chain beyond this point is assumed
9513 to be part of a breakpoint. If the breakpoint create succeeds
9514 then the memory is not reclaimed. */
9515 bkpt_chain
= make_cleanup (null_cleanup
, 0);
9517 /* Resolve all line numbers to PC's and verify that the addresses
9518 are ok for the target. */
9521 for (auto &lsal
: canonical
.lsals
)
9522 breakpoint_sals_to_pc (lsal
.sals
);
9525 /* Fast tracepoints may have additional restrictions on location. */
9526 if (!pending
&& type_wanted
== bp_fast_tracepoint
)
9528 for (const auto &lsal
: canonical
.lsals
)
9529 check_fast_tracepoint_sals (gdbarch
, lsal
.sals
);
9532 /* Verify that condition can be parsed, before setting any
9533 breakpoints. Allocate a separate condition expression for each
9537 gdb::unique_xmalloc_ptr
<char> cond_string_copy
;
9538 gdb::unique_xmalloc_ptr
<char> extra_string_copy
;
9545 const linespec_sals
&lsal
= canonical
.lsals
[0];
9547 /* Here we only parse 'arg' to separate condition
9548 from thread number, so parsing in context of first
9549 sal is OK. When setting the breakpoint we'll
9550 re-parse it in context of each sal. */
9552 find_condition_and_thread (extra_string
, lsal
.sals
[0].pc
,
9553 &cond
, &thread
, &task
, &rest
);
9554 cond_string_copy
.reset (cond
);
9555 extra_string_copy
.reset (rest
);
9559 if (type_wanted
!= bp_dprintf
9560 && extra_string
!= NULL
&& *extra_string
!= '\0')
9561 error (_("Garbage '%s' at end of location"), extra_string
);
9563 /* Create a private copy of condition string. */
9565 cond_string_copy
.reset (xstrdup (cond_string
));
9566 /* Create a private copy of any extra string. */
9568 extra_string_copy
.reset (xstrdup (extra_string
));
9571 ops
->create_breakpoints_sal (gdbarch
, &canonical
,
9572 std::move (cond_string_copy
),
9573 std::move (extra_string_copy
),
9575 tempflag
? disp_del
: disp_donttouch
,
9576 thread
, task
, ignore_count
, ops
,
9577 from_tty
, enabled
, internal
, flags
);
9581 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (type_wanted
);
9583 init_raw_breakpoint_without_location (b
.get (), gdbarch
, type_wanted
, ops
);
9584 b
->location
= copy_event_location (location
);
9587 b
->cond_string
= NULL
;
9590 /* Create a private copy of condition string. */
9591 b
->cond_string
= cond_string
!= NULL
? xstrdup (cond_string
) : NULL
;
9595 /* Create a private copy of any extra string. */
9596 b
->extra_string
= extra_string
!= NULL
? xstrdup (extra_string
) : NULL
;
9597 b
->ignore_count
= ignore_count
;
9598 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
9599 b
->condition_not_parsed
= 1;
9600 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
9601 if ((type_wanted
!= bp_breakpoint
9602 && type_wanted
!= bp_hardware_breakpoint
) || thread
!= -1)
9603 b
->pspace
= current_program_space
;
9605 install_breakpoint (internal
, std::move (b
), 0);
9608 if (canonical
.lsals
.size () > 1)
9610 warning (_("Multiple breakpoints were set.\nUse the "
9611 "\"delete\" command to delete unwanted breakpoints."));
9612 prev_breakpoint_count
= prev_bkpt_count
;
9615 /* That's it. Discard the cleanups for data inserted into the
9617 discard_cleanups (bkpt_chain
);
9619 /* error call may happen here - have BKPT_CHAIN already discarded. */
9620 update_global_location_list (UGLL_MAY_INSERT
);
9625 /* Set a breakpoint.
9626 ARG is a string describing breakpoint address,
9627 condition, and thread.
9628 FLAG specifies if a breakpoint is hardware on,
9629 and if breakpoint is temporary, using BP_HARDWARE_FLAG
9633 break_command_1 (const char *arg
, int flag
, int from_tty
)
9635 int tempflag
= flag
& BP_TEMPFLAG
;
9636 enum bptype type_wanted
= (flag
& BP_HARDWAREFLAG
9637 ? bp_hardware_breakpoint
9639 struct breakpoint_ops
*ops
;
9641 event_location_up location
= string_to_event_location (&arg
, current_language
);
9643 /* Matching breakpoints on probes. */
9644 if (location
!= NULL
9645 && event_location_type (location
.get ()) == PROBE_LOCATION
)
9646 ops
= &bkpt_probe_breakpoint_ops
;
9648 ops
= &bkpt_breakpoint_ops
;
9650 create_breakpoint (get_current_arch (),
9652 NULL
, 0, arg
, 1 /* parse arg */,
9653 tempflag
, type_wanted
,
9654 0 /* Ignore count */,
9655 pending_break_support
,
9663 /* Helper function for break_command_1 and disassemble_command. */
9666 resolve_sal_pc (struct symtab_and_line
*sal
)
9670 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
9672 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
9673 error (_("No line %d in file \"%s\"."),
9674 sal
->line
, symtab_to_filename_for_display (sal
->symtab
));
9677 /* If this SAL corresponds to a breakpoint inserted using a line
9678 number, then skip the function prologue if necessary. */
9679 if (sal
->explicit_line
)
9680 skip_prologue_sal (sal
);
9683 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
9685 const struct blockvector
*bv
;
9686 const struct block
*b
;
9689 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
,
9690 SYMTAB_COMPUNIT (sal
->symtab
));
9693 sym
= block_linkage_function (b
);
9696 fixup_symbol_section (sym
, SYMTAB_OBJFILE (sal
->symtab
));
9697 sal
->section
= SYMBOL_OBJ_SECTION (SYMTAB_OBJFILE (sal
->symtab
),
9702 /* It really is worthwhile to have the section, so we'll
9703 just have to look harder. This case can be executed
9704 if we have line numbers but no functions (as can
9705 happen in assembly source). */
9707 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
9708 switch_to_program_space_and_thread (sal
->pspace
);
9710 bound_minimal_symbol msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
9712 sal
->section
= MSYMBOL_OBJ_SECTION (msym
.objfile
, msym
.minsym
);
9719 break_command (char *arg
, int from_tty
)
9721 break_command_1 (arg
, 0, from_tty
);
9725 tbreak_command (char *arg
, int from_tty
)
9727 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
9731 hbreak_command (char *arg
, int from_tty
)
9733 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
9737 thbreak_command (char *arg
, int from_tty
)
9739 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
9743 stop_command (char *arg
, int from_tty
)
9745 printf_filtered (_("Specify the type of breakpoint to set.\n\
9746 Usage: stop in <function | address>\n\
9747 stop at <line>\n"));
9751 stopin_command (const char *arg
, int from_tty
)
9755 if (arg
== (char *) NULL
)
9757 else if (*arg
!= '*')
9759 const char *argptr
= arg
;
9762 /* Look for a ':'. If this is a line number specification, then
9763 say it is bad, otherwise, it should be an address or
9764 function/method name. */
9765 while (*argptr
&& !hasColon
)
9767 hasColon
= (*argptr
== ':');
9772 badInput
= (*argptr
!= ':'); /* Not a class::method */
9774 badInput
= isdigit (*arg
); /* a simple line number */
9778 printf_filtered (_("Usage: stop in <function | address>\n"));
9780 break_command_1 (arg
, 0, from_tty
);
9784 stopat_command (const char *arg
, int from_tty
)
9788 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
9792 const char *argptr
= arg
;
9795 /* Look for a ':'. If there is a '::' then get out, otherwise
9796 it is probably a line number. */
9797 while (*argptr
&& !hasColon
)
9799 hasColon
= (*argptr
== ':');
9804 badInput
= (*argptr
== ':'); /* we have class::method */
9806 badInput
= !isdigit (*arg
); /* not a line number */
9810 printf_filtered (_("Usage: stop at <line>\n"));
9812 break_command_1 (arg
, 0, from_tty
);
9815 /* The dynamic printf command is mostly like a regular breakpoint, but
9816 with a prewired command list consisting of a single output command,
9817 built from extra arguments supplied on the dprintf command
9821 dprintf_command (char *arg_in
, int from_tty
)
9823 const char *arg
= arg_in
;
9824 event_location_up location
= string_to_event_location (&arg
, current_language
);
9826 /* If non-NULL, ARG should have been advanced past the location;
9827 the next character must be ','. */
9830 if (arg
[0] != ',' || arg
[1] == '\0')
9831 error (_("Format string required"));
9834 /* Skip the comma. */
9839 create_breakpoint (get_current_arch (),
9841 NULL
, 0, arg
, 1 /* parse arg */,
9843 0 /* Ignore count */,
9844 pending_break_support
,
9845 &dprintf_breakpoint_ops
,
9853 agent_printf_command (char *arg
, int from_tty
)
9855 error (_("May only run agent-printf on the target"));
9858 /* Implement the "breakpoint_hit" breakpoint_ops method for
9859 ranged breakpoints. */
9862 breakpoint_hit_ranged_breakpoint (const struct bp_location
*bl
,
9863 struct address_space
*aspace
,
9865 const struct target_waitstatus
*ws
)
9867 if (ws
->kind
!= TARGET_WAITKIND_STOPPED
9868 || ws
->value
.sig
!= GDB_SIGNAL_TRAP
)
9871 return breakpoint_address_match_range (bl
->pspace
->aspace
, bl
->address
,
9872 bl
->length
, aspace
, bp_addr
);
9875 /* Implement the "resources_needed" breakpoint_ops method for
9876 ranged breakpoints. */
9879 resources_needed_ranged_breakpoint (const struct bp_location
*bl
)
9881 return target_ranged_break_num_registers ();
9884 /* Implement the "print_it" breakpoint_ops method for
9885 ranged breakpoints. */
9887 static enum print_stop_action
9888 print_it_ranged_breakpoint (bpstat bs
)
9890 struct breakpoint
*b
= bs
->breakpoint_at
;
9891 struct bp_location
*bl
= b
->loc
;
9892 struct ui_out
*uiout
= current_uiout
;
9894 gdb_assert (b
->type
== bp_hardware_breakpoint
);
9896 /* Ranged breakpoints have only one location. */
9897 gdb_assert (bl
&& bl
->next
== NULL
);
9899 annotate_breakpoint (b
->number
);
9901 maybe_print_thread_hit_breakpoint (uiout
);
9903 if (b
->disposition
== disp_del
)
9904 uiout
->text ("Temporary ranged breakpoint ");
9906 uiout
->text ("Ranged breakpoint ");
9907 if (uiout
->is_mi_like_p ())
9909 uiout
->field_string ("reason",
9910 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
9911 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
9913 uiout
->field_int ("bkptno", b
->number
);
9916 return PRINT_SRC_AND_LOC
;
9919 /* Implement the "print_one" breakpoint_ops method for
9920 ranged breakpoints. */
9923 print_one_ranged_breakpoint (struct breakpoint
*b
,
9924 struct bp_location
**last_loc
)
9926 struct bp_location
*bl
= b
->loc
;
9927 struct value_print_options opts
;
9928 struct ui_out
*uiout
= current_uiout
;
9930 /* Ranged breakpoints have only one location. */
9931 gdb_assert (bl
&& bl
->next
== NULL
);
9933 get_user_print_options (&opts
);
9935 if (opts
.addressprint
)
9936 /* We don't print the address range here, it will be printed later
9937 by print_one_detail_ranged_breakpoint. */
9938 uiout
->field_skip ("addr");
9940 print_breakpoint_location (b
, bl
);
9944 /* Implement the "print_one_detail" breakpoint_ops method for
9945 ranged breakpoints. */
9948 print_one_detail_ranged_breakpoint (const struct breakpoint
*b
,
9949 struct ui_out
*uiout
)
9951 CORE_ADDR address_start
, address_end
;
9952 struct bp_location
*bl
= b
->loc
;
9957 address_start
= bl
->address
;
9958 address_end
= address_start
+ bl
->length
- 1;
9960 uiout
->text ("\taddress range: ");
9961 stb
.printf ("[%s, %s]",
9962 print_core_address (bl
->gdbarch
, address_start
),
9963 print_core_address (bl
->gdbarch
, address_end
));
9964 uiout
->field_stream ("addr", stb
);
9968 /* Implement the "print_mention" breakpoint_ops method for
9969 ranged breakpoints. */
9972 print_mention_ranged_breakpoint (struct breakpoint
*b
)
9974 struct bp_location
*bl
= b
->loc
;
9975 struct ui_out
*uiout
= current_uiout
;
9978 gdb_assert (b
->type
== bp_hardware_breakpoint
);
9980 if (uiout
->is_mi_like_p ())
9983 printf_filtered (_("Hardware assisted ranged breakpoint %d from %s to %s."),
9984 b
->number
, paddress (bl
->gdbarch
, bl
->address
),
9985 paddress (bl
->gdbarch
, bl
->address
+ bl
->length
- 1));
9988 /* Implement the "print_recreate" breakpoint_ops method for
9989 ranged breakpoints. */
9992 print_recreate_ranged_breakpoint (struct breakpoint
*b
, struct ui_file
*fp
)
9994 fprintf_unfiltered (fp
, "break-range %s, %s",
9995 event_location_to_string (b
->location
.get ()),
9996 event_location_to_string (b
->location_range_end
.get ()));
9997 print_recreate_thread (b
, fp
);
10000 /* The breakpoint_ops structure to be used in ranged breakpoints. */
10002 static struct breakpoint_ops ranged_breakpoint_ops
;
10004 /* Find the address where the end of the breakpoint range should be
10005 placed, given the SAL of the end of the range. This is so that if
10006 the user provides a line number, the end of the range is set to the
10007 last instruction of the given line. */
10010 find_breakpoint_range_end (struct symtab_and_line sal
)
10014 /* If the user provided a PC value, use it. Otherwise,
10015 find the address of the end of the given location. */
10016 if (sal
.explicit_pc
)
10023 ret
= find_line_pc_range (sal
, &start
, &end
);
10025 error (_("Could not find location of the end of the range."));
10027 /* find_line_pc_range returns the start of the next line. */
10034 /* Implement the "break-range" CLI command. */
10037 break_range_command (char *arg_in
, int from_tty
)
10039 const char *arg
= arg_in
;
10040 const char *arg_start
;
10041 char *addr_string_start
;
10042 struct linespec_result canonical_start
, canonical_end
;
10043 int bp_count
, can_use_bp
, length
;
10045 struct breakpoint
*b
;
10046 struct cleanup
*cleanup_bkpt
;
10048 /* We don't support software ranged breakpoints. */
10049 if (target_ranged_break_num_registers () < 0)
10050 error (_("This target does not support hardware ranged breakpoints."));
10052 bp_count
= hw_breakpoint_used_count ();
10053 bp_count
+= target_ranged_break_num_registers ();
10054 can_use_bp
= target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
10056 if (can_use_bp
< 0)
10057 error (_("Hardware breakpoints used exceeds limit."));
10059 arg
= skip_spaces (arg
);
10060 if (arg
== NULL
|| arg
[0] == '\0')
10061 error(_("No address range specified."));
10064 event_location_up start_location
= string_to_event_location (&arg
,
10066 parse_breakpoint_sals (start_location
.get (), &canonical_start
);
10069 error (_("Too few arguments."));
10070 else if (canonical_start
.lsals
.empty ())
10071 error (_("Could not find location of the beginning of the range."));
10073 const linespec_sals
&lsal_start
= canonical_start
.lsals
[0];
10075 if (canonical_start
.lsals
.size () > 1
10076 || lsal_start
.sals
.size () != 1)
10077 error (_("Cannot create a ranged breakpoint with multiple locations."));
10079 const symtab_and_line
&sal_start
= lsal_start
.sals
[0];
10080 addr_string_start
= savestring (arg_start
, arg
- arg_start
);
10081 cleanup_bkpt
= make_cleanup (xfree
, addr_string_start
);
10083 arg
++; /* Skip the comma. */
10084 arg
= skip_spaces (arg
);
10086 /* Parse the end location. */
10090 /* We call decode_line_full directly here instead of using
10091 parse_breakpoint_sals because we need to specify the start location's
10092 symtab and line as the default symtab and line for the end of the
10093 range. This makes it possible to have ranges like "foo.c:27, +14",
10094 where +14 means 14 lines from the start location. */
10095 event_location_up end_location
= string_to_event_location (&arg
,
10097 decode_line_full (end_location
.get (), DECODE_LINE_FUNFIRSTLINE
, NULL
,
10098 sal_start
.symtab
, sal_start
.line
,
10099 &canonical_end
, NULL
, NULL
);
10101 if (canonical_end
.lsals
.empty ())
10102 error (_("Could not find location of the end of the range."));
10104 const linespec_sals
&lsal_end
= canonical_end
.lsals
[0];
10105 if (canonical_end
.lsals
.size () > 1
10106 || lsal_end
.sals
.size () != 1)
10107 error (_("Cannot create a ranged breakpoint with multiple locations."));
10109 const symtab_and_line
&sal_end
= lsal_end
.sals
[0];
10111 end
= find_breakpoint_range_end (sal_end
);
10112 if (sal_start
.pc
> end
)
10113 error (_("Invalid address range, end precedes start."));
10115 length
= end
- sal_start
.pc
+ 1;
10117 /* Length overflowed. */
10118 error (_("Address range too large."));
10119 else if (length
== 1)
10121 /* This range is simple enough to be handled by
10122 the `hbreak' command. */
10123 hbreak_command (addr_string_start
, 1);
10125 do_cleanups (cleanup_bkpt
);
10130 /* Now set up the breakpoint. */
10131 b
= set_raw_breakpoint (get_current_arch (), sal_start
,
10132 bp_hardware_breakpoint
, &ranged_breakpoint_ops
);
10133 set_breakpoint_count (breakpoint_count
+ 1);
10134 b
->number
= breakpoint_count
;
10135 b
->disposition
= disp_donttouch
;
10136 b
->location
= std::move (start_location
);
10137 b
->location_range_end
= std::move (end_location
);
10138 b
->loc
->length
= length
;
10140 do_cleanups (cleanup_bkpt
);
10143 observer_notify_breakpoint_created (b
);
10144 update_global_location_list (UGLL_MAY_INSERT
);
10147 /* Return non-zero if EXP is verified as constant. Returned zero
10148 means EXP is variable. Also the constant detection may fail for
10149 some constant expressions and in such case still falsely return
10153 watchpoint_exp_is_const (const struct expression
*exp
)
10155 int i
= exp
->nelts
;
10161 /* We are only interested in the descriptor of each element. */
10162 operator_length (exp
, i
, &oplenp
, &argsp
);
10165 switch (exp
->elts
[i
].opcode
)
10175 case BINOP_LOGICAL_AND
:
10176 case BINOP_LOGICAL_OR
:
10177 case BINOP_BITWISE_AND
:
10178 case BINOP_BITWISE_IOR
:
10179 case BINOP_BITWISE_XOR
:
10181 case BINOP_NOTEQUAL
:
10208 case OP_OBJC_NSSTRING
:
10211 case UNOP_LOGICAL_NOT
:
10212 case UNOP_COMPLEMENT
:
10217 case UNOP_CAST_TYPE
:
10218 case UNOP_REINTERPRET_CAST
:
10219 case UNOP_DYNAMIC_CAST
:
10220 /* Unary, binary and ternary operators: We have to check
10221 their operands. If they are constant, then so is the
10222 result of that operation. For instance, if A and B are
10223 determined to be constants, then so is "A + B".
10225 UNOP_IND is one exception to the rule above, because the
10226 value of *ADDR is not necessarily a constant, even when
10231 /* Check whether the associated symbol is a constant.
10233 We use SYMBOL_CLASS rather than TYPE_CONST because it's
10234 possible that a buggy compiler could mark a variable as
10235 constant even when it is not, and TYPE_CONST would return
10236 true in this case, while SYMBOL_CLASS wouldn't.
10238 We also have to check for function symbols because they
10239 are always constant. */
10241 struct symbol
*s
= exp
->elts
[i
+ 2].symbol
;
10243 if (SYMBOL_CLASS (s
) != LOC_BLOCK
10244 && SYMBOL_CLASS (s
) != LOC_CONST
10245 && SYMBOL_CLASS (s
) != LOC_CONST_BYTES
)
10250 /* The default action is to return 0 because we are using
10251 the optimistic approach here: If we don't know something,
10252 then it is not a constant. */
10261 /* Watchpoint destructor. */
10263 watchpoint::~watchpoint ()
10265 xfree (this->exp_string
);
10266 xfree (this->exp_string_reparse
);
10267 value_free (this->val
);
10270 /* Implement the "re_set" breakpoint_ops method for watchpoints. */
10273 re_set_watchpoint (struct breakpoint
*b
)
10275 struct watchpoint
*w
= (struct watchpoint
*) b
;
10277 /* Watchpoint can be either on expression using entirely global
10278 variables, or it can be on local variables.
10280 Watchpoints of the first kind are never auto-deleted, and even
10281 persist across program restarts. Since they can use variables
10282 from shared libraries, we need to reparse expression as libraries
10283 are loaded and unloaded.
10285 Watchpoints on local variables can also change meaning as result
10286 of solib event. For example, if a watchpoint uses both a local
10287 and a global variables in expression, it's a local watchpoint,
10288 but unloading of a shared library will make the expression
10289 invalid. This is not a very common use case, but we still
10290 re-evaluate expression, to avoid surprises to the user.
10292 Note that for local watchpoints, we re-evaluate it only if
10293 watchpoints frame id is still valid. If it's not, it means the
10294 watchpoint is out of scope and will be deleted soon. In fact,
10295 I'm not sure we'll ever be called in this case.
10297 If a local watchpoint's frame id is still valid, then
10298 w->exp_valid_block is likewise valid, and we can safely use it.
10300 Don't do anything about disabled watchpoints, since they will be
10301 reevaluated again when enabled. */
10302 update_watchpoint (w
, 1 /* reparse */);
10305 /* Implement the "insert" breakpoint_ops method for hardware watchpoints. */
10308 insert_watchpoint (struct bp_location
*bl
)
10310 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10311 int length
= w
->exact
? 1 : bl
->length
;
10313 return target_insert_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
10314 w
->cond_exp
.get ());
10317 /* Implement the "remove" breakpoint_ops method for hardware watchpoints. */
10320 remove_watchpoint (struct bp_location
*bl
, enum remove_bp_reason reason
)
10322 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10323 int length
= w
->exact
? 1 : bl
->length
;
10325 return target_remove_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
10326 w
->cond_exp
.get ());
10330 breakpoint_hit_watchpoint (const struct bp_location
*bl
,
10331 struct address_space
*aspace
, CORE_ADDR bp_addr
,
10332 const struct target_waitstatus
*ws
)
10334 struct breakpoint
*b
= bl
->owner
;
10335 struct watchpoint
*w
= (struct watchpoint
*) b
;
10337 /* Continuable hardware watchpoints are treated as non-existent if the
10338 reason we stopped wasn't a hardware watchpoint (we didn't stop on
10339 some data address). Otherwise gdb won't stop on a break instruction
10340 in the code (not from a breakpoint) when a hardware watchpoint has
10341 been defined. Also skip watchpoints which we know did not trigger
10342 (did not match the data address). */
10343 if (is_hardware_watchpoint (b
)
10344 && w
->watchpoint_triggered
== watch_triggered_no
)
10351 check_status_watchpoint (bpstat bs
)
10353 gdb_assert (is_watchpoint (bs
->breakpoint_at
));
10355 bpstat_check_watchpoint (bs
);
10358 /* Implement the "resources_needed" breakpoint_ops method for
10359 hardware watchpoints. */
10362 resources_needed_watchpoint (const struct bp_location
*bl
)
10364 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10365 int length
= w
->exact
? 1 : bl
->length
;
10367 return target_region_ok_for_hw_watchpoint (bl
->address
, length
);
10370 /* Implement the "works_in_software_mode" breakpoint_ops method for
10371 hardware watchpoints. */
10374 works_in_software_mode_watchpoint (const struct breakpoint
*b
)
10376 /* Read and access watchpoints only work with hardware support. */
10377 return b
->type
== bp_watchpoint
|| b
->type
== bp_hardware_watchpoint
;
10380 static enum print_stop_action
10381 print_it_watchpoint (bpstat bs
)
10383 struct breakpoint
*b
;
10384 enum print_stop_action result
;
10385 struct watchpoint
*w
;
10386 struct ui_out
*uiout
= current_uiout
;
10388 gdb_assert (bs
->bp_location_at
!= NULL
);
10390 b
= bs
->breakpoint_at
;
10391 w
= (struct watchpoint
*) b
;
10393 annotate_watchpoint (b
->number
);
10394 maybe_print_thread_hit_breakpoint (uiout
);
10398 gdb::optional
<ui_out_emit_tuple
> tuple_emitter
;
10401 case bp_watchpoint
:
10402 case bp_hardware_watchpoint
:
10403 if (uiout
->is_mi_like_p ())
10404 uiout
->field_string
10405 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
10407 tuple_emitter
.emplace (uiout
, "value");
10408 uiout
->text ("\nOld value = ");
10409 watchpoint_value_print (bs
->old_val
, &stb
);
10410 uiout
->field_stream ("old", stb
);
10411 uiout
->text ("\nNew value = ");
10412 watchpoint_value_print (w
->val
, &stb
);
10413 uiout
->field_stream ("new", stb
);
10414 uiout
->text ("\n");
10415 /* More than one watchpoint may have been triggered. */
10416 result
= PRINT_UNKNOWN
;
10419 case bp_read_watchpoint
:
10420 if (uiout
->is_mi_like_p ())
10421 uiout
->field_string
10422 ("reason", async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
10424 tuple_emitter
.emplace (uiout
, "value");
10425 uiout
->text ("\nValue = ");
10426 watchpoint_value_print (w
->val
, &stb
);
10427 uiout
->field_stream ("value", stb
);
10428 uiout
->text ("\n");
10429 result
= PRINT_UNKNOWN
;
10432 case bp_access_watchpoint
:
10433 if (bs
->old_val
!= NULL
)
10435 if (uiout
->is_mi_like_p ())
10436 uiout
->field_string
10438 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
10440 tuple_emitter
.emplace (uiout
, "value");
10441 uiout
->text ("\nOld value = ");
10442 watchpoint_value_print (bs
->old_val
, &stb
);
10443 uiout
->field_stream ("old", stb
);
10444 uiout
->text ("\nNew value = ");
10449 if (uiout
->is_mi_like_p ())
10450 uiout
->field_string
10452 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
10453 tuple_emitter
.emplace (uiout
, "value");
10454 uiout
->text ("\nValue = ");
10456 watchpoint_value_print (w
->val
, &stb
);
10457 uiout
->field_stream ("new", stb
);
10458 uiout
->text ("\n");
10459 result
= PRINT_UNKNOWN
;
10462 result
= PRINT_UNKNOWN
;
10468 /* Implement the "print_mention" breakpoint_ops method for hardware
10472 print_mention_watchpoint (struct breakpoint
*b
)
10474 struct watchpoint
*w
= (struct watchpoint
*) b
;
10475 struct ui_out
*uiout
= current_uiout
;
10476 const char *tuple_name
;
10480 case bp_watchpoint
:
10481 uiout
->text ("Watchpoint ");
10482 tuple_name
= "wpt";
10484 case bp_hardware_watchpoint
:
10485 uiout
->text ("Hardware watchpoint ");
10486 tuple_name
= "wpt";
10488 case bp_read_watchpoint
:
10489 uiout
->text ("Hardware read watchpoint ");
10490 tuple_name
= "hw-rwpt";
10492 case bp_access_watchpoint
:
10493 uiout
->text ("Hardware access (read/write) watchpoint ");
10494 tuple_name
= "hw-awpt";
10497 internal_error (__FILE__
, __LINE__
,
10498 _("Invalid hardware watchpoint type."));
10501 ui_out_emit_tuple
tuple_emitter (uiout
, tuple_name
);
10502 uiout
->field_int ("number", b
->number
);
10503 uiout
->text (": ");
10504 uiout
->field_string ("exp", w
->exp_string
);
10507 /* Implement the "print_recreate" breakpoint_ops method for
10511 print_recreate_watchpoint (struct breakpoint
*b
, struct ui_file
*fp
)
10513 struct watchpoint
*w
= (struct watchpoint
*) b
;
10517 case bp_watchpoint
:
10518 case bp_hardware_watchpoint
:
10519 fprintf_unfiltered (fp
, "watch");
10521 case bp_read_watchpoint
:
10522 fprintf_unfiltered (fp
, "rwatch");
10524 case bp_access_watchpoint
:
10525 fprintf_unfiltered (fp
, "awatch");
10528 internal_error (__FILE__
, __LINE__
,
10529 _("Invalid watchpoint type."));
10532 fprintf_unfiltered (fp
, " %s", w
->exp_string
);
10533 print_recreate_thread (b
, fp
);
10536 /* Implement the "explains_signal" breakpoint_ops method for
10540 explains_signal_watchpoint (struct breakpoint
*b
, enum gdb_signal sig
)
10542 /* A software watchpoint cannot cause a signal other than
10543 GDB_SIGNAL_TRAP. */
10544 if (b
->type
== bp_watchpoint
&& sig
!= GDB_SIGNAL_TRAP
)
10550 /* The breakpoint_ops structure to be used in hardware watchpoints. */
10552 static struct breakpoint_ops watchpoint_breakpoint_ops
;
10554 /* Implement the "insert" breakpoint_ops method for
10555 masked hardware watchpoints. */
10558 insert_masked_watchpoint (struct bp_location
*bl
)
10560 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10562 return target_insert_mask_watchpoint (bl
->address
, w
->hw_wp_mask
,
10563 bl
->watchpoint_type
);
10566 /* Implement the "remove" breakpoint_ops method for
10567 masked hardware watchpoints. */
10570 remove_masked_watchpoint (struct bp_location
*bl
, enum remove_bp_reason reason
)
10572 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10574 return target_remove_mask_watchpoint (bl
->address
, w
->hw_wp_mask
,
10575 bl
->watchpoint_type
);
10578 /* Implement the "resources_needed" breakpoint_ops method for
10579 masked hardware watchpoints. */
10582 resources_needed_masked_watchpoint (const struct bp_location
*bl
)
10584 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10586 return target_masked_watch_num_registers (bl
->address
, w
->hw_wp_mask
);
10589 /* Implement the "works_in_software_mode" breakpoint_ops method for
10590 masked hardware watchpoints. */
10593 works_in_software_mode_masked_watchpoint (const struct breakpoint
*b
)
10598 /* Implement the "print_it" breakpoint_ops method for
10599 masked hardware watchpoints. */
10601 static enum print_stop_action
10602 print_it_masked_watchpoint (bpstat bs
)
10604 struct breakpoint
*b
= bs
->breakpoint_at
;
10605 struct ui_out
*uiout
= current_uiout
;
10607 /* Masked watchpoints have only one location. */
10608 gdb_assert (b
->loc
&& b
->loc
->next
== NULL
);
10610 annotate_watchpoint (b
->number
);
10611 maybe_print_thread_hit_breakpoint (uiout
);
10615 case bp_hardware_watchpoint
:
10616 if (uiout
->is_mi_like_p ())
10617 uiout
->field_string
10618 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
10621 case bp_read_watchpoint
:
10622 if (uiout
->is_mi_like_p ())
10623 uiout
->field_string
10624 ("reason", async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
10627 case bp_access_watchpoint
:
10628 if (uiout
->is_mi_like_p ())
10629 uiout
->field_string
10631 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
10634 internal_error (__FILE__
, __LINE__
,
10635 _("Invalid hardware watchpoint type."));
10639 uiout
->text (_("\n\
10640 Check the underlying instruction at PC for the memory\n\
10641 address and value which triggered this watchpoint.\n"));
10642 uiout
->text ("\n");
10644 /* More than one watchpoint may have been triggered. */
10645 return PRINT_UNKNOWN
;
10648 /* Implement the "print_one_detail" breakpoint_ops method for
10649 masked hardware watchpoints. */
10652 print_one_detail_masked_watchpoint (const struct breakpoint
*b
,
10653 struct ui_out
*uiout
)
10655 struct watchpoint
*w
= (struct watchpoint
*) b
;
10657 /* Masked watchpoints have only one location. */
10658 gdb_assert (b
->loc
&& b
->loc
->next
== NULL
);
10660 uiout
->text ("\tmask ");
10661 uiout
->field_core_addr ("mask", b
->loc
->gdbarch
, w
->hw_wp_mask
);
10662 uiout
->text ("\n");
10665 /* Implement the "print_mention" breakpoint_ops method for
10666 masked hardware watchpoints. */
10669 print_mention_masked_watchpoint (struct breakpoint
*b
)
10671 struct watchpoint
*w
= (struct watchpoint
*) b
;
10672 struct ui_out
*uiout
= current_uiout
;
10673 const char *tuple_name
;
10677 case bp_hardware_watchpoint
:
10678 uiout
->text ("Masked hardware watchpoint ");
10679 tuple_name
= "wpt";
10681 case bp_read_watchpoint
:
10682 uiout
->text ("Masked hardware read watchpoint ");
10683 tuple_name
= "hw-rwpt";
10685 case bp_access_watchpoint
:
10686 uiout
->text ("Masked hardware access (read/write) watchpoint ");
10687 tuple_name
= "hw-awpt";
10690 internal_error (__FILE__
, __LINE__
,
10691 _("Invalid hardware watchpoint type."));
10694 ui_out_emit_tuple
tuple_emitter (uiout
, tuple_name
);
10695 uiout
->field_int ("number", b
->number
);
10696 uiout
->text (": ");
10697 uiout
->field_string ("exp", w
->exp_string
);
10700 /* Implement the "print_recreate" breakpoint_ops method for
10701 masked hardware watchpoints. */
10704 print_recreate_masked_watchpoint (struct breakpoint
*b
, struct ui_file
*fp
)
10706 struct watchpoint
*w
= (struct watchpoint
*) b
;
10711 case bp_hardware_watchpoint
:
10712 fprintf_unfiltered (fp
, "watch");
10714 case bp_read_watchpoint
:
10715 fprintf_unfiltered (fp
, "rwatch");
10717 case bp_access_watchpoint
:
10718 fprintf_unfiltered (fp
, "awatch");
10721 internal_error (__FILE__
, __LINE__
,
10722 _("Invalid hardware watchpoint type."));
10725 sprintf_vma (tmp
, w
->hw_wp_mask
);
10726 fprintf_unfiltered (fp
, " %s mask 0x%s", w
->exp_string
, tmp
);
10727 print_recreate_thread (b
, fp
);
10730 /* The breakpoint_ops structure to be used in masked hardware watchpoints. */
10732 static struct breakpoint_ops masked_watchpoint_breakpoint_ops
;
10734 /* Tell whether the given watchpoint is a masked hardware watchpoint. */
10737 is_masked_watchpoint (const struct breakpoint
*b
)
10739 return b
->ops
== &masked_watchpoint_breakpoint_ops
;
10742 /* accessflag: hw_write: watch write,
10743 hw_read: watch read,
10744 hw_access: watch access (read or write) */
10746 watch_command_1 (const char *arg
, int accessflag
, int from_tty
,
10747 int just_location
, int internal
)
10749 struct breakpoint
*scope_breakpoint
= NULL
;
10750 const struct block
*exp_valid_block
= NULL
, *cond_exp_valid_block
= NULL
;
10751 struct value
*val
, *mark
, *result
;
10752 int saved_bitpos
= 0, saved_bitsize
= 0;
10753 const char *exp_start
= NULL
;
10754 const char *exp_end
= NULL
;
10755 const char *tok
, *end_tok
;
10757 const char *cond_start
= NULL
;
10758 const char *cond_end
= NULL
;
10759 enum bptype bp_type
;
10762 /* Flag to indicate whether we are going to use masks for
10763 the hardware watchpoint. */
10765 CORE_ADDR mask
= 0;
10767 struct cleanup
*back_to
;
10769 /* Make sure that we actually have parameters to parse. */
10770 if (arg
!= NULL
&& arg
[0] != '\0')
10772 const char *value_start
;
10774 exp_end
= arg
+ strlen (arg
);
10776 /* Look for "parameter value" pairs at the end
10777 of the arguments string. */
10778 for (tok
= exp_end
- 1; tok
> arg
; tok
--)
10780 /* Skip whitespace at the end of the argument list. */
10781 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
10784 /* Find the beginning of the last token.
10785 This is the value of the parameter. */
10786 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
10788 value_start
= tok
+ 1;
10790 /* Skip whitespace. */
10791 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
10796 /* Find the beginning of the second to last token.
10797 This is the parameter itself. */
10798 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
10801 toklen
= end_tok
- tok
+ 1;
10803 if (toklen
== 6 && startswith (tok
, "thread"))
10805 struct thread_info
*thr
;
10806 /* At this point we've found a "thread" token, which means
10807 the user is trying to set a watchpoint that triggers
10808 only in a specific thread. */
10812 error(_("You can specify only one thread."));
10814 /* Extract the thread ID from the next token. */
10815 thr
= parse_thread_id (value_start
, &endp
);
10817 /* Check if the user provided a valid thread ID. */
10818 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
10819 invalid_thread_id_error (value_start
);
10821 thread
= thr
->global_num
;
10823 else if (toklen
== 4 && startswith (tok
, "mask"))
10825 /* We've found a "mask" token, which means the user wants to
10826 create a hardware watchpoint that is going to have the mask
10828 struct value
*mask_value
, *mark
;
10831 error(_("You can specify only one mask."));
10833 use_mask
= just_location
= 1;
10835 mark
= value_mark ();
10836 mask_value
= parse_to_comma_and_eval (&value_start
);
10837 mask
= value_as_address (mask_value
);
10838 value_free_to_mark (mark
);
10841 /* We didn't recognize what we found. We should stop here. */
10844 /* Truncate the string and get rid of the "parameter value" pair before
10845 the arguments string is parsed by the parse_exp_1 function. */
10852 /* Parse the rest of the arguments. From here on out, everything
10853 is in terms of a newly allocated string instead of the original
10855 innermost_block
= NULL
;
10856 expression
= savestring (arg
, exp_end
- arg
);
10857 back_to
= make_cleanup (xfree
, expression
);
10858 exp_start
= arg
= expression
;
10859 expression_up exp
= parse_exp_1 (&arg
, 0, 0, 0);
10861 /* Remove trailing whitespace from the expression before saving it.
10862 This makes the eventual display of the expression string a bit
10864 while (exp_end
> exp_start
&& (exp_end
[-1] == ' ' || exp_end
[-1] == '\t'))
10867 /* Checking if the expression is not constant. */
10868 if (watchpoint_exp_is_const (exp
.get ()))
10872 len
= exp_end
- exp_start
;
10873 while (len
> 0 && isspace (exp_start
[len
- 1]))
10875 error (_("Cannot watch constant value `%.*s'."), len
, exp_start
);
10878 exp_valid_block
= innermost_block
;
10879 mark
= value_mark ();
10880 fetch_subexp_value (exp
.get (), &pc
, &val
, &result
, NULL
, just_location
);
10882 if (val
!= NULL
&& just_location
)
10884 saved_bitpos
= value_bitpos (val
);
10885 saved_bitsize
= value_bitsize (val
);
10892 exp_valid_block
= NULL
;
10893 val
= value_addr (result
);
10894 release_value (val
);
10895 value_free_to_mark (mark
);
10899 ret
= target_masked_watch_num_registers (value_as_address (val
),
10902 error (_("This target does not support masked watchpoints."));
10903 else if (ret
== -2)
10904 error (_("Invalid mask or memory region."));
10907 else if (val
!= NULL
)
10908 release_value (val
);
10910 tok
= skip_spaces (arg
);
10911 end_tok
= skip_to_space (tok
);
10913 toklen
= end_tok
- tok
;
10914 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
10916 innermost_block
= NULL
;
10917 tok
= cond_start
= end_tok
+ 1;
10918 parse_exp_1 (&tok
, 0, 0, 0);
10920 /* The watchpoint expression may not be local, but the condition
10921 may still be. E.g.: `watch global if local > 0'. */
10922 cond_exp_valid_block
= innermost_block
;
10927 error (_("Junk at end of command."));
10929 frame_info
*wp_frame
= block_innermost_frame (exp_valid_block
);
10931 /* Save this because create_internal_breakpoint below invalidates
10933 frame_id watchpoint_frame
= get_frame_id (wp_frame
);
10935 /* If the expression is "local", then set up a "watchpoint scope"
10936 breakpoint at the point where we've left the scope of the watchpoint
10937 expression. Create the scope breakpoint before the watchpoint, so
10938 that we will encounter it first in bpstat_stop_status. */
10939 if (exp_valid_block
!= NULL
&& wp_frame
!= NULL
)
10941 frame_id caller_frame_id
= frame_unwind_caller_id (wp_frame
);
10943 if (frame_id_p (caller_frame_id
))
10945 gdbarch
*caller_arch
= frame_unwind_caller_arch (wp_frame
);
10946 CORE_ADDR caller_pc
= frame_unwind_caller_pc (wp_frame
);
10949 = create_internal_breakpoint (caller_arch
, caller_pc
,
10950 bp_watchpoint_scope
,
10951 &momentary_breakpoint_ops
);
10953 /* create_internal_breakpoint could invalidate WP_FRAME. */
10956 scope_breakpoint
->enable_state
= bp_enabled
;
10958 /* Automatically delete the breakpoint when it hits. */
10959 scope_breakpoint
->disposition
= disp_del
;
10961 /* Only break in the proper frame (help with recursion). */
10962 scope_breakpoint
->frame_id
= caller_frame_id
;
10964 /* Set the address at which we will stop. */
10965 scope_breakpoint
->loc
->gdbarch
= caller_arch
;
10966 scope_breakpoint
->loc
->requested_address
= caller_pc
;
10967 scope_breakpoint
->loc
->address
10968 = adjust_breakpoint_address (scope_breakpoint
->loc
->gdbarch
,
10969 scope_breakpoint
->loc
->requested_address
,
10970 scope_breakpoint
->type
);
10974 /* Now set up the breakpoint. We create all watchpoints as hardware
10975 watchpoints here even if hardware watchpoints are turned off, a call
10976 to update_watchpoint later in this function will cause the type to
10977 drop back to bp_watchpoint (software watchpoint) if required. */
10979 if (accessflag
== hw_read
)
10980 bp_type
= bp_read_watchpoint
;
10981 else if (accessflag
== hw_access
)
10982 bp_type
= bp_access_watchpoint
;
10984 bp_type
= bp_hardware_watchpoint
;
10986 std::unique_ptr
<watchpoint
> w (new watchpoint ());
10989 init_raw_breakpoint_without_location (w
.get (), NULL
, bp_type
,
10990 &masked_watchpoint_breakpoint_ops
);
10992 init_raw_breakpoint_without_location (w
.get (), NULL
, bp_type
,
10993 &watchpoint_breakpoint_ops
);
10994 w
->thread
= thread
;
10995 w
->disposition
= disp_donttouch
;
10996 w
->pspace
= current_program_space
;
10997 w
->exp
= std::move (exp
);
10998 w
->exp_valid_block
= exp_valid_block
;
10999 w
->cond_exp_valid_block
= cond_exp_valid_block
;
11002 struct type
*t
= value_type (val
);
11003 CORE_ADDR addr
= value_as_address (val
);
11005 w
->exp_string_reparse
11006 = current_language
->la_watch_location_expression (t
, addr
).release ();
11008 w
->exp_string
= xstrprintf ("-location %.*s",
11009 (int) (exp_end
- exp_start
), exp_start
);
11012 w
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
11016 w
->hw_wp_mask
= mask
;
11021 w
->val_bitpos
= saved_bitpos
;
11022 w
->val_bitsize
= saved_bitsize
;
11027 w
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
11029 w
->cond_string
= 0;
11031 if (frame_id_p (watchpoint_frame
))
11033 w
->watchpoint_frame
= watchpoint_frame
;
11034 w
->watchpoint_thread
= inferior_ptid
;
11038 w
->watchpoint_frame
= null_frame_id
;
11039 w
->watchpoint_thread
= null_ptid
;
11042 if (scope_breakpoint
!= NULL
)
11044 /* The scope breakpoint is related to the watchpoint. We will
11045 need to act on them together. */
11046 w
->related_breakpoint
= scope_breakpoint
;
11047 scope_breakpoint
->related_breakpoint
= w
.get ();
11050 if (!just_location
)
11051 value_free_to_mark (mark
);
11053 /* Finally update the new watchpoint. This creates the locations
11054 that should be inserted. */
11055 update_watchpoint (w
.get (), 1);
11057 install_breakpoint (internal
, std::move (w
), 1);
11058 do_cleanups (back_to
);
11061 /* Return count of debug registers needed to watch the given expression.
11062 If the watchpoint cannot be handled in hardware return zero. */
11065 can_use_hardware_watchpoint (struct value
*v
)
11067 int found_memory_cnt
= 0;
11068 struct value
*head
= v
;
11070 /* Did the user specifically forbid us to use hardware watchpoints? */
11071 if (!can_use_hw_watchpoints
)
11074 /* Make sure that the value of the expression depends only upon
11075 memory contents, and values computed from them within GDB. If we
11076 find any register references or function calls, we can't use a
11077 hardware watchpoint.
11079 The idea here is that evaluating an expression generates a series
11080 of values, one holding the value of every subexpression. (The
11081 expression a*b+c has five subexpressions: a, b, a*b, c, and
11082 a*b+c.) GDB's values hold almost enough information to establish
11083 the criteria given above --- they identify memory lvalues,
11084 register lvalues, computed values, etcetera. So we can evaluate
11085 the expression, and then scan the chain of values that leaves
11086 behind to decide whether we can detect any possible change to the
11087 expression's final value using only hardware watchpoints.
11089 However, I don't think that the values returned by inferior
11090 function calls are special in any way. So this function may not
11091 notice that an expression involving an inferior function call
11092 can't be watched with hardware watchpoints. FIXME. */
11093 for (; v
; v
= value_next (v
))
11095 if (VALUE_LVAL (v
) == lval_memory
)
11097 if (v
!= head
&& value_lazy (v
))
11098 /* A lazy memory lvalue in the chain is one that GDB never
11099 needed to fetch; we either just used its address (e.g.,
11100 `a' in `a.b') or we never needed it at all (e.g., `a'
11101 in `a,b'). This doesn't apply to HEAD; if that is
11102 lazy then it was not readable, but watch it anyway. */
11106 /* Ahh, memory we actually used! Check if we can cover
11107 it with hardware watchpoints. */
11108 struct type
*vtype
= check_typedef (value_type (v
));
11110 /* We only watch structs and arrays if user asked for it
11111 explicitly, never if they just happen to appear in a
11112 middle of some value chain. */
11114 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
11115 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
11117 CORE_ADDR vaddr
= value_address (v
);
11121 len
= (target_exact_watchpoints
11122 && is_scalar_type_recursive (vtype
))?
11123 1 : TYPE_LENGTH (value_type (v
));
11125 num_regs
= target_region_ok_for_hw_watchpoint (vaddr
, len
);
11129 found_memory_cnt
+= num_regs
;
11133 else if (VALUE_LVAL (v
) != not_lval
11134 && deprecated_value_modifiable (v
) == 0)
11135 return 0; /* These are values from the history (e.g., $1). */
11136 else if (VALUE_LVAL (v
) == lval_register
)
11137 return 0; /* Cannot watch a register with a HW watchpoint. */
11140 /* The expression itself looks suitable for using a hardware
11141 watchpoint, but give the target machine a chance to reject it. */
11142 return found_memory_cnt
;
11146 watch_command_wrapper (const char *arg
, int from_tty
, int internal
)
11148 watch_command_1 (arg
, hw_write
, from_tty
, 0, internal
);
11151 /* A helper function that looks for the "-location" argument and then
11152 calls watch_command_1. */
11155 watch_maybe_just_location (char *arg
, int accessflag
, int from_tty
)
11157 int just_location
= 0;
11160 && (check_for_argument (&arg
, "-location", sizeof ("-location") - 1)
11161 || check_for_argument (&arg
, "-l", sizeof ("-l") - 1)))
11163 arg
= skip_spaces (arg
);
11167 watch_command_1 (arg
, accessflag
, from_tty
, just_location
, 0);
11171 watch_command (char *arg
, int from_tty
)
11173 watch_maybe_just_location (arg
, hw_write
, from_tty
);
11177 rwatch_command_wrapper (const char *arg
, int from_tty
, int internal
)
11179 watch_command_1 (arg
, hw_read
, from_tty
, 0, internal
);
11183 rwatch_command (char *arg
, int from_tty
)
11185 watch_maybe_just_location (arg
, hw_read
, from_tty
);
11189 awatch_command_wrapper (const char *arg
, int from_tty
, int internal
)
11191 watch_command_1 (arg
, hw_access
, from_tty
, 0, internal
);
11195 awatch_command (char *arg
, int from_tty
)
11197 watch_maybe_just_location (arg
, hw_access
, from_tty
);
11201 /* Data for the FSM that manages the until(location)/advance commands
11202 in infcmd.c. Here because it uses the mechanisms of
11205 struct until_break_fsm
11207 /* The base class. */
11208 struct thread_fsm thread_fsm
;
11210 /* The thread that as current when the command was executed. */
11213 /* The breakpoint set at the destination location. */
11214 struct breakpoint
*location_breakpoint
;
11216 /* Breakpoint set at the return address in the caller frame. May be
11218 struct breakpoint
*caller_breakpoint
;
11221 static void until_break_fsm_clean_up (struct thread_fsm
*self
,
11222 struct thread_info
*thread
);
11223 static int until_break_fsm_should_stop (struct thread_fsm
*self
,
11224 struct thread_info
*thread
);
11225 static enum async_reply_reason
11226 until_break_fsm_async_reply_reason (struct thread_fsm
*self
);
11228 /* until_break_fsm's vtable. */
11230 static struct thread_fsm_ops until_break_fsm_ops
=
11233 until_break_fsm_clean_up
,
11234 until_break_fsm_should_stop
,
11235 NULL
, /* return_value */
11236 until_break_fsm_async_reply_reason
,
11239 /* Allocate a new until_break_command_fsm. */
11241 static struct until_break_fsm
*
11242 new_until_break_fsm (struct interp
*cmd_interp
, int thread
,
11243 struct breakpoint
*location_breakpoint
,
11244 struct breakpoint
*caller_breakpoint
)
11246 struct until_break_fsm
*sm
;
11248 sm
= XCNEW (struct until_break_fsm
);
11249 thread_fsm_ctor (&sm
->thread_fsm
, &until_break_fsm_ops
, cmd_interp
);
11251 sm
->thread
= thread
;
11252 sm
->location_breakpoint
= location_breakpoint
;
11253 sm
->caller_breakpoint
= caller_breakpoint
;
11258 /* Implementation of the 'should_stop' FSM method for the
11259 until(location)/advance commands. */
11262 until_break_fsm_should_stop (struct thread_fsm
*self
,
11263 struct thread_info
*tp
)
11265 struct until_break_fsm
*sm
= (struct until_break_fsm
*) self
;
11267 if (bpstat_find_breakpoint (tp
->control
.stop_bpstat
,
11268 sm
->location_breakpoint
) != NULL
11269 || (sm
->caller_breakpoint
!= NULL
11270 && bpstat_find_breakpoint (tp
->control
.stop_bpstat
,
11271 sm
->caller_breakpoint
) != NULL
))
11272 thread_fsm_set_finished (self
);
11277 /* Implementation of the 'clean_up' FSM method for the
11278 until(location)/advance commands. */
11281 until_break_fsm_clean_up (struct thread_fsm
*self
,
11282 struct thread_info
*thread
)
11284 struct until_break_fsm
*sm
= (struct until_break_fsm
*) self
;
11286 /* Clean up our temporary breakpoints. */
11287 if (sm
->location_breakpoint
!= NULL
)
11289 delete_breakpoint (sm
->location_breakpoint
);
11290 sm
->location_breakpoint
= NULL
;
11292 if (sm
->caller_breakpoint
!= NULL
)
11294 delete_breakpoint (sm
->caller_breakpoint
);
11295 sm
->caller_breakpoint
= NULL
;
11297 delete_longjmp_breakpoint (sm
->thread
);
11300 /* Implementation of the 'async_reply_reason' FSM method for the
11301 until(location)/advance commands. */
11303 static enum async_reply_reason
11304 until_break_fsm_async_reply_reason (struct thread_fsm
*self
)
11306 return EXEC_ASYNC_LOCATION_REACHED
;
11310 until_break_command (const char *arg
, int from_tty
, int anywhere
)
11312 struct frame_info
*frame
;
11313 struct gdbarch
*frame_gdbarch
;
11314 struct frame_id stack_frame_id
;
11315 struct frame_id caller_frame_id
;
11316 struct breakpoint
*location_breakpoint
;
11317 struct breakpoint
*caller_breakpoint
= NULL
;
11318 struct cleanup
*old_chain
;
11320 struct thread_info
*tp
;
11321 struct until_break_fsm
*sm
;
11323 clear_proceed_status (0);
11325 /* Set a breakpoint where the user wants it and at return from
11328 event_location_up location
= string_to_event_location (&arg
, current_language
);
11330 std::vector
<symtab_and_line
> sals
11331 = (last_displayed_sal_is_valid ()
11332 ? decode_line_1 (location
.get (), DECODE_LINE_FUNFIRSTLINE
, NULL
,
11333 get_last_displayed_symtab (),
11334 get_last_displayed_line ())
11335 : decode_line_1 (location
.get (), DECODE_LINE_FUNFIRSTLINE
,
11336 NULL
, (struct symtab
*) NULL
, 0));
11338 if (sals
.size () != 1)
11339 error (_("Couldn't get information on specified line."));
11341 symtab_and_line
&sal
= sals
[0];
11344 error (_("Junk at end of arguments."));
11346 resolve_sal_pc (&sal
);
11348 tp
= inferior_thread ();
11349 thread
= tp
->global_num
;
11351 old_chain
= make_cleanup (null_cleanup
, NULL
);
11353 /* Note linespec handling above invalidates the frame chain.
11354 Installing a breakpoint also invalidates the frame chain (as it
11355 may need to switch threads), so do any frame handling before
11358 frame
= get_selected_frame (NULL
);
11359 frame_gdbarch
= get_frame_arch (frame
);
11360 stack_frame_id
= get_stack_frame_id (frame
);
11361 caller_frame_id
= frame_unwind_caller_id (frame
);
11363 /* Keep within the current frame, or in frames called by the current
11366 if (frame_id_p (caller_frame_id
))
11368 struct symtab_and_line sal2
;
11369 struct gdbarch
*caller_gdbarch
;
11371 sal2
= find_pc_line (frame_unwind_caller_pc (frame
), 0);
11372 sal2
.pc
= frame_unwind_caller_pc (frame
);
11373 caller_gdbarch
= frame_unwind_caller_arch (frame
);
11374 caller_breakpoint
= set_momentary_breakpoint (caller_gdbarch
,
11378 make_cleanup_delete_breakpoint (caller_breakpoint
);
11380 set_longjmp_breakpoint (tp
, caller_frame_id
);
11381 make_cleanup (delete_longjmp_breakpoint_cleanup
, &thread
);
11384 /* set_momentary_breakpoint could invalidate FRAME. */
11388 /* If the user told us to continue until a specified location,
11389 we don't specify a frame at which we need to stop. */
11390 location_breakpoint
= set_momentary_breakpoint (frame_gdbarch
, sal
,
11391 null_frame_id
, bp_until
);
11393 /* Otherwise, specify the selected frame, because we want to stop
11394 only at the very same frame. */
11395 location_breakpoint
= set_momentary_breakpoint (frame_gdbarch
, sal
,
11396 stack_frame_id
, bp_until
);
11397 make_cleanup_delete_breakpoint (location_breakpoint
);
11399 sm
= new_until_break_fsm (command_interp (), tp
->global_num
,
11400 location_breakpoint
, caller_breakpoint
);
11401 tp
->thread_fsm
= &sm
->thread_fsm
;
11403 discard_cleanups (old_chain
);
11405 proceed (-1, GDB_SIGNAL_DEFAULT
);
11408 /* This function attempts to parse an optional "if <cond>" clause
11409 from the arg string. If one is not found, it returns NULL.
11411 Else, it returns a pointer to the condition string. (It does not
11412 attempt to evaluate the string against a particular block.) And,
11413 it updates arg to point to the first character following the parsed
11414 if clause in the arg string. */
11417 ep_parse_optional_if_clause (const char **arg
)
11419 const char *cond_string
;
11421 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
11424 /* Skip the "if" keyword. */
11427 /* Skip any extra leading whitespace, and record the start of the
11428 condition string. */
11429 *arg
= skip_spaces (*arg
);
11430 cond_string
= *arg
;
11432 /* Assume that the condition occupies the remainder of the arg
11434 (*arg
) += strlen (cond_string
);
11436 return cond_string
;
11439 /* Commands to deal with catching events, such as signals, exceptions,
11440 process start/exit, etc. */
11444 catch_fork_temporary
, catch_vfork_temporary
,
11445 catch_fork_permanent
, catch_vfork_permanent
11450 catch_fork_command_1 (char *arg_entry
, int from_tty
,
11451 struct cmd_list_element
*command
)
11453 const char *arg
= arg_entry
;
11454 struct gdbarch
*gdbarch
= get_current_arch ();
11455 const char *cond_string
= NULL
;
11456 catch_fork_kind fork_kind
;
11459 fork_kind
= (catch_fork_kind
) (uintptr_t) get_cmd_context (command
);
11460 tempflag
= (fork_kind
== catch_fork_temporary
11461 || fork_kind
== catch_vfork_temporary
);
11465 arg
= skip_spaces (arg
);
11467 /* The allowed syntax is:
11469 catch [v]fork if <cond>
11471 First, check if there's an if clause. */
11472 cond_string
= ep_parse_optional_if_clause (&arg
);
11474 if ((*arg
!= '\0') && !isspace (*arg
))
11475 error (_("Junk at end of arguments."));
11477 /* If this target supports it, create a fork or vfork catchpoint
11478 and enable reporting of such events. */
11481 case catch_fork_temporary
:
11482 case catch_fork_permanent
:
11483 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
11484 &catch_fork_breakpoint_ops
);
11486 case catch_vfork_temporary
:
11487 case catch_vfork_permanent
:
11488 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
11489 &catch_vfork_breakpoint_ops
);
11492 error (_("unsupported or unknown fork kind; cannot catch it"));
11498 catch_exec_command_1 (char *arg_entry
, int from_tty
,
11499 struct cmd_list_element
*command
)
11501 const char *arg
= arg_entry
;
11502 struct gdbarch
*gdbarch
= get_current_arch ();
11504 const char *cond_string
= NULL
;
11506 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
11510 arg
= skip_spaces (arg
);
11512 /* The allowed syntax is:
11514 catch exec if <cond>
11516 First, check if there's an if clause. */
11517 cond_string
= ep_parse_optional_if_clause (&arg
);
11519 if ((*arg
!= '\0') && !isspace (*arg
))
11520 error (_("Junk at end of arguments."));
11522 std::unique_ptr
<exec_catchpoint
> c (new exec_catchpoint ());
11523 init_catchpoint (c
.get (), gdbarch
, tempflag
, cond_string
,
11524 &catch_exec_breakpoint_ops
);
11525 c
->exec_pathname
= NULL
;
11527 install_breakpoint (0, std::move (c
), 1);
11531 init_ada_exception_breakpoint (struct breakpoint
*b
,
11532 struct gdbarch
*gdbarch
,
11533 struct symtab_and_line sal
,
11534 const char *addr_string
,
11535 const struct breakpoint_ops
*ops
,
11542 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
11544 loc_gdbarch
= gdbarch
;
11546 describe_other_breakpoints (loc_gdbarch
,
11547 sal
.pspace
, sal
.pc
, sal
.section
, -1);
11548 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
11549 version for exception catchpoints, because two catchpoints
11550 used for different exception names will use the same address.
11551 In this case, a "breakpoint ... also set at..." warning is
11552 unproductive. Besides, the warning phrasing is also a bit
11553 inappropriate, we should use the word catchpoint, and tell
11554 the user what type of catchpoint it is. The above is good
11555 enough for now, though. */
11558 init_raw_breakpoint (b
, gdbarch
, sal
, bp_breakpoint
, ops
);
11560 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
11561 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
11562 b
->location
= string_to_event_location (&addr_string
,
11563 language_def (language_ada
));
11564 b
->language
= language_ada
;
11568 catch_command (char *arg
, int from_tty
)
11570 error (_("Catch requires an event name."));
11575 tcatch_command (char *arg
, int from_tty
)
11577 error (_("Catch requires an event name."));
11580 /* A qsort comparison function that sorts breakpoints in order. */
11583 compare_breakpoints (const void *a
, const void *b
)
11585 const breakpoint_p
*ba
= (const breakpoint_p
*) a
;
11586 uintptr_t ua
= (uintptr_t) *ba
;
11587 const breakpoint_p
*bb
= (const breakpoint_p
*) b
;
11588 uintptr_t ub
= (uintptr_t) *bb
;
11590 if ((*ba
)->number
< (*bb
)->number
)
11592 else if ((*ba
)->number
> (*bb
)->number
)
11595 /* Now sort by address, in case we see, e..g, two breakpoints with
11599 return ua
> ub
? 1 : 0;
11602 /* Delete breakpoints by address or line. */
11605 clear_command (char *arg
, int from_tty
)
11607 struct breakpoint
*b
, *prev
;
11608 VEC(breakpoint_p
) *found
= 0;
11612 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
11614 std::vector
<symtab_and_line
> decoded_sals
;
11615 symtab_and_line last_sal
;
11616 gdb::array_view
<symtab_and_line
> sals
;
11620 = decode_line_with_current_source (arg
,
11621 (DECODE_LINE_FUNFIRSTLINE
11622 | DECODE_LINE_LIST_MODE
));
11624 sals
= decoded_sals
;
11628 /* Set sal's line, symtab, pc, and pspace to the values
11629 corresponding to the last call to print_frame_info. If the
11630 codepoint is not valid, this will set all the fields to 0. */
11631 last_sal
= get_last_displayed_sal ();
11632 if (last_sal
.symtab
== 0)
11633 error (_("No source file specified."));
11639 /* We don't call resolve_sal_pc here. That's not as bad as it
11640 seems, because all existing breakpoints typically have both
11641 file/line and pc set. So, if clear is given file/line, we can
11642 match this to existing breakpoint without obtaining pc at all.
11644 We only support clearing given the address explicitly
11645 present in breakpoint table. Say, we've set breakpoint
11646 at file:line. There were several PC values for that file:line,
11647 due to optimization, all in one block.
11649 We've picked one PC value. If "clear" is issued with another
11650 PC corresponding to the same file:line, the breakpoint won't
11651 be cleared. We probably can still clear the breakpoint, but
11652 since the other PC value is never presented to user, user
11653 can only find it by guessing, and it does not seem important
11654 to support that. */
11656 /* For each line spec given, delete bps which correspond to it. Do
11657 it in two passes, solely to preserve the current behavior that
11658 from_tty is forced true if we delete more than one
11662 make_cleanup (VEC_cleanup (breakpoint_p
), &found
);
11663 for (const auto &sal
: sals
)
11665 const char *sal_fullname
;
11667 /* If exact pc given, clear bpts at that pc.
11668 If line given (pc == 0), clear all bpts on specified line.
11669 If defaulting, clear all bpts on default line
11672 defaulting sal.pc != 0 tests to do
11677 1 0 <can't happen> */
11679 sal_fullname
= (sal
.symtab
== NULL
11680 ? NULL
: symtab_to_fullname (sal
.symtab
));
11682 /* Find all matching breakpoints and add them to 'found'. */
11683 ALL_BREAKPOINTS (b
)
11686 /* Are we going to delete b? */
11687 if (b
->type
!= bp_none
&& !is_watchpoint (b
))
11689 struct bp_location
*loc
= b
->loc
;
11690 for (; loc
; loc
= loc
->next
)
11692 /* If the user specified file:line, don't allow a PC
11693 match. This matches historical gdb behavior. */
11694 int pc_match
= (!sal
.explicit_line
11696 && (loc
->pspace
== sal
.pspace
)
11697 && (loc
->address
== sal
.pc
)
11698 && (!section_is_overlay (loc
->section
)
11699 || loc
->section
== sal
.section
));
11700 int line_match
= 0;
11702 if ((default_match
|| sal
.explicit_line
)
11703 && loc
->symtab
!= NULL
11704 && sal_fullname
!= NULL
11705 && sal
.pspace
== loc
->pspace
11706 && loc
->line_number
== sal
.line
11707 && filename_cmp (symtab_to_fullname (loc
->symtab
),
11708 sal_fullname
) == 0)
11711 if (pc_match
|| line_match
)
11720 VEC_safe_push(breakpoint_p
, found
, b
);
11724 /* Now go thru the 'found' chain and delete them. */
11725 if (VEC_empty(breakpoint_p
, found
))
11728 error (_("No breakpoint at %s."), arg
);
11730 error (_("No breakpoint at this line."));
11733 /* Remove duplicates from the vec. */
11734 qsort (VEC_address (breakpoint_p
, found
),
11735 VEC_length (breakpoint_p
, found
),
11736 sizeof (breakpoint_p
),
11737 compare_breakpoints
);
11738 prev
= VEC_index (breakpoint_p
, found
, 0);
11739 for (ix
= 1; VEC_iterate (breakpoint_p
, found
, ix
, b
); ++ix
)
11743 VEC_ordered_remove (breakpoint_p
, found
, ix
);
11748 if (VEC_length(breakpoint_p
, found
) > 1)
11749 from_tty
= 1; /* Always report if deleted more than one. */
11752 if (VEC_length(breakpoint_p
, found
) == 1)
11753 printf_unfiltered (_("Deleted breakpoint "));
11755 printf_unfiltered (_("Deleted breakpoints "));
11758 for (ix
= 0; VEC_iterate(breakpoint_p
, found
, ix
, b
); ix
++)
11761 printf_unfiltered ("%d ", b
->number
);
11762 delete_breakpoint (b
);
11765 putchar_unfiltered ('\n');
11767 do_cleanups (cleanups
);
11770 /* Delete breakpoint in BS if they are `delete' breakpoints and
11771 all breakpoints that are marked for deletion, whether hit or not.
11772 This is called after any breakpoint is hit, or after errors. */
11775 breakpoint_auto_delete (bpstat bs
)
11777 struct breakpoint
*b
, *b_tmp
;
11779 for (; bs
; bs
= bs
->next
)
11780 if (bs
->breakpoint_at
11781 && bs
->breakpoint_at
->disposition
== disp_del
11783 delete_breakpoint (bs
->breakpoint_at
);
11785 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
11787 if (b
->disposition
== disp_del_at_next_stop
)
11788 delete_breakpoint (b
);
11792 /* A comparison function for bp_location AP and BP being interfaced to
11793 qsort. Sort elements primarily by their ADDRESS (no matter what
11794 does breakpoint_address_is_meaningful say for its OWNER),
11795 secondarily by ordering first permanent elements and
11796 terciarily just ensuring the array is sorted stable way despite
11797 qsort being an unstable algorithm. */
11800 bp_locations_compare (const void *ap
, const void *bp
)
11802 const struct bp_location
*a
= *(const struct bp_location
**) ap
;
11803 const struct bp_location
*b
= *(const struct bp_location
**) bp
;
11805 if (a
->address
!= b
->address
)
11806 return (a
->address
> b
->address
) - (a
->address
< b
->address
);
11808 /* Sort locations at the same address by their pspace number, keeping
11809 locations of the same inferior (in a multi-inferior environment)
11812 if (a
->pspace
->num
!= b
->pspace
->num
)
11813 return ((a
->pspace
->num
> b
->pspace
->num
)
11814 - (a
->pspace
->num
< b
->pspace
->num
));
11816 /* Sort permanent breakpoints first. */
11817 if (a
->permanent
!= b
->permanent
)
11818 return (a
->permanent
< b
->permanent
) - (a
->permanent
> b
->permanent
);
11820 /* Make the internal GDB representation stable across GDB runs
11821 where A and B memory inside GDB can differ. Breakpoint locations of
11822 the same type at the same address can be sorted in arbitrary order. */
11824 if (a
->owner
->number
!= b
->owner
->number
)
11825 return ((a
->owner
->number
> b
->owner
->number
)
11826 - (a
->owner
->number
< b
->owner
->number
));
11828 return (a
> b
) - (a
< b
);
11831 /* Set bp_locations_placed_address_before_address_max and
11832 bp_locations_shadow_len_after_address_max according to the current
11833 content of the bp_locations array. */
11836 bp_locations_target_extensions_update (void)
11838 struct bp_location
*bl
, **blp_tmp
;
11840 bp_locations_placed_address_before_address_max
= 0;
11841 bp_locations_shadow_len_after_address_max
= 0;
11843 ALL_BP_LOCATIONS (bl
, blp_tmp
)
11845 CORE_ADDR start
, end
, addr
;
11847 if (!bp_location_has_shadow (bl
))
11850 start
= bl
->target_info
.placed_address
;
11851 end
= start
+ bl
->target_info
.shadow_len
;
11853 gdb_assert (bl
->address
>= start
);
11854 addr
= bl
->address
- start
;
11855 if (addr
> bp_locations_placed_address_before_address_max
)
11856 bp_locations_placed_address_before_address_max
= addr
;
11858 /* Zero SHADOW_LEN would not pass bp_location_has_shadow. */
11860 gdb_assert (bl
->address
< end
);
11861 addr
= end
- bl
->address
;
11862 if (addr
> bp_locations_shadow_len_after_address_max
)
11863 bp_locations_shadow_len_after_address_max
= addr
;
11867 /* Download tracepoint locations if they haven't been. */
11870 download_tracepoint_locations (void)
11872 struct breakpoint
*b
;
11873 enum tribool can_download_tracepoint
= TRIBOOL_UNKNOWN
;
11875 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
11877 ALL_TRACEPOINTS (b
)
11879 struct bp_location
*bl
;
11880 struct tracepoint
*t
;
11881 int bp_location_downloaded
= 0;
11883 if ((b
->type
== bp_fast_tracepoint
11884 ? !may_insert_fast_tracepoints
11885 : !may_insert_tracepoints
))
11888 if (can_download_tracepoint
== TRIBOOL_UNKNOWN
)
11890 if (target_can_download_tracepoint ())
11891 can_download_tracepoint
= TRIBOOL_TRUE
;
11893 can_download_tracepoint
= TRIBOOL_FALSE
;
11896 if (can_download_tracepoint
== TRIBOOL_FALSE
)
11899 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
11901 /* In tracepoint, locations are _never_ duplicated, so
11902 should_be_inserted is equivalent to
11903 unduplicated_should_be_inserted. */
11904 if (!should_be_inserted (bl
) || bl
->inserted
)
11907 switch_to_program_space_and_thread (bl
->pspace
);
11909 target_download_tracepoint (bl
);
11912 bp_location_downloaded
= 1;
11914 t
= (struct tracepoint
*) b
;
11915 t
->number_on_target
= b
->number
;
11916 if (bp_location_downloaded
)
11917 observer_notify_breakpoint_modified (b
);
11921 /* Swap the insertion/duplication state between two locations. */
11924 swap_insertion (struct bp_location
*left
, struct bp_location
*right
)
11926 const int left_inserted
= left
->inserted
;
11927 const int left_duplicate
= left
->duplicate
;
11928 const int left_needs_update
= left
->needs_update
;
11929 const struct bp_target_info left_target_info
= left
->target_info
;
11931 /* Locations of tracepoints can never be duplicated. */
11932 if (is_tracepoint (left
->owner
))
11933 gdb_assert (!left
->duplicate
);
11934 if (is_tracepoint (right
->owner
))
11935 gdb_assert (!right
->duplicate
);
11937 left
->inserted
= right
->inserted
;
11938 left
->duplicate
= right
->duplicate
;
11939 left
->needs_update
= right
->needs_update
;
11940 left
->target_info
= right
->target_info
;
11941 right
->inserted
= left_inserted
;
11942 right
->duplicate
= left_duplicate
;
11943 right
->needs_update
= left_needs_update
;
11944 right
->target_info
= left_target_info
;
11947 /* Force the re-insertion of the locations at ADDRESS. This is called
11948 once a new/deleted/modified duplicate location is found and we are evaluating
11949 conditions on the target's side. Such conditions need to be updated on
11953 force_breakpoint_reinsertion (struct bp_location
*bl
)
11955 struct bp_location
**locp
= NULL
, **loc2p
;
11956 struct bp_location
*loc
;
11957 CORE_ADDR address
= 0;
11960 address
= bl
->address
;
11961 pspace_num
= bl
->pspace
->num
;
11963 /* This is only meaningful if the target is
11964 evaluating conditions and if the user has
11965 opted for condition evaluation on the target's
11967 if (gdb_evaluates_breakpoint_condition_p ()
11968 || !target_supports_evaluation_of_breakpoint_conditions ())
11971 /* Flag all breakpoint locations with this address and
11972 the same program space as the location
11973 as "its condition has changed". We need to
11974 update the conditions on the target's side. */
11975 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, address
)
11979 if (!is_breakpoint (loc
->owner
)
11980 || pspace_num
!= loc
->pspace
->num
)
11983 /* Flag the location appropriately. We use a different state to
11984 let everyone know that we already updated the set of locations
11985 with addr bl->address and program space bl->pspace. This is so
11986 we don't have to keep calling these functions just to mark locations
11987 that have already been marked. */
11988 loc
->condition_changed
= condition_updated
;
11990 /* Free the agent expression bytecode as well. We will compute
11992 loc
->cond_bytecode
.reset ();
11995 /* Called whether new breakpoints are created, or existing breakpoints
11996 deleted, to update the global location list and recompute which
11997 locations are duplicate of which.
11999 The INSERT_MODE flag determines whether locations may not, may, or
12000 shall be inserted now. See 'enum ugll_insert_mode' for more
12004 update_global_location_list (enum ugll_insert_mode insert_mode
)
12006 struct breakpoint
*b
;
12007 struct bp_location
**locp
, *loc
;
12008 struct cleanup
*cleanups
;
12009 /* Last breakpoint location address that was marked for update. */
12010 CORE_ADDR last_addr
= 0;
12011 /* Last breakpoint location program space that was marked for update. */
12012 int last_pspace_num
= -1;
12014 /* Used in the duplicates detection below. When iterating over all
12015 bp_locations, points to the first bp_location of a given address.
12016 Breakpoints and watchpoints of different types are never
12017 duplicates of each other. Keep one pointer for each type of
12018 breakpoint/watchpoint, so we only need to loop over all locations
12020 struct bp_location
*bp_loc_first
; /* breakpoint */
12021 struct bp_location
*wp_loc_first
; /* hardware watchpoint */
12022 struct bp_location
*awp_loc_first
; /* access watchpoint */
12023 struct bp_location
*rwp_loc_first
; /* read watchpoint */
12025 /* Saved former bp_locations array which we compare against the newly
12026 built bp_locations from the current state of ALL_BREAKPOINTS. */
12027 struct bp_location
**old_locations
, **old_locp
;
12028 unsigned old_locations_count
;
12030 old_locations
= bp_locations
;
12031 old_locations_count
= bp_locations_count
;
12032 bp_locations
= NULL
;
12033 bp_locations_count
= 0;
12034 cleanups
= make_cleanup (xfree
, old_locations
);
12036 ALL_BREAKPOINTS (b
)
12037 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
12038 bp_locations_count
++;
12040 bp_locations
= XNEWVEC (struct bp_location
*, bp_locations_count
);
12041 locp
= bp_locations
;
12042 ALL_BREAKPOINTS (b
)
12043 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
12045 qsort (bp_locations
, bp_locations_count
, sizeof (*bp_locations
),
12046 bp_locations_compare
);
12048 bp_locations_target_extensions_update ();
12050 /* Identify bp_location instances that are no longer present in the
12051 new list, and therefore should be freed. Note that it's not
12052 necessary that those locations should be removed from inferior --
12053 if there's another location at the same address (previously
12054 marked as duplicate), we don't need to remove/insert the
12057 LOCP is kept in sync with OLD_LOCP, each pointing to the current
12058 and former bp_location array state respectively. */
12060 locp
= bp_locations
;
12061 for (old_locp
= old_locations
;
12062 old_locp
< old_locations
+ old_locations_count
;
12065 struct bp_location
*old_loc
= *old_locp
;
12066 struct bp_location
**loc2p
;
12068 /* Tells if 'old_loc' is found among the new locations. If
12069 not, we have to free it. */
12070 int found_object
= 0;
12071 /* Tells if the location should remain inserted in the target. */
12072 int keep_in_target
= 0;
12075 /* Skip LOCP entries which will definitely never be needed.
12076 Stop either at or being the one matching OLD_LOC. */
12077 while (locp
< bp_locations
+ bp_locations_count
12078 && (*locp
)->address
< old_loc
->address
)
12082 (loc2p
< bp_locations
+ bp_locations_count
12083 && (*loc2p
)->address
== old_loc
->address
);
12086 /* Check if this is a new/duplicated location or a duplicated
12087 location that had its condition modified. If so, we want to send
12088 its condition to the target if evaluation of conditions is taking
12090 if ((*loc2p
)->condition_changed
== condition_modified
12091 && (last_addr
!= old_loc
->address
12092 || last_pspace_num
!= old_loc
->pspace
->num
))
12094 force_breakpoint_reinsertion (*loc2p
);
12095 last_pspace_num
= old_loc
->pspace
->num
;
12098 if (*loc2p
== old_loc
)
12102 /* We have already handled this address, update it so that we don't
12103 have to go through updates again. */
12104 last_addr
= old_loc
->address
;
12106 /* Target-side condition evaluation: Handle deleted locations. */
12108 force_breakpoint_reinsertion (old_loc
);
12110 /* If this location is no longer present, and inserted, look if
12111 there's maybe a new location at the same address. If so,
12112 mark that one inserted, and don't remove this one. This is
12113 needed so that we don't have a time window where a breakpoint
12114 at certain location is not inserted. */
12116 if (old_loc
->inserted
)
12118 /* If the location is inserted now, we might have to remove
12121 if (found_object
&& should_be_inserted (old_loc
))
12123 /* The location is still present in the location list,
12124 and still should be inserted. Don't do anything. */
12125 keep_in_target
= 1;
12129 /* This location still exists, but it won't be kept in the
12130 target since it may have been disabled. We proceed to
12131 remove its target-side condition. */
12133 /* The location is either no longer present, or got
12134 disabled. See if there's another location at the
12135 same address, in which case we don't need to remove
12136 this one from the target. */
12138 /* OLD_LOC comes from existing struct breakpoint. */
12139 if (breakpoint_address_is_meaningful (old_loc
->owner
))
12142 (loc2p
< bp_locations
+ bp_locations_count
12143 && (*loc2p
)->address
== old_loc
->address
);
12146 struct bp_location
*loc2
= *loc2p
;
12148 if (breakpoint_locations_match (loc2
, old_loc
))
12150 /* Read watchpoint locations are switched to
12151 access watchpoints, if the former are not
12152 supported, but the latter are. */
12153 if (is_hardware_watchpoint (old_loc
->owner
))
12155 gdb_assert (is_hardware_watchpoint (loc2
->owner
));
12156 loc2
->watchpoint_type
= old_loc
->watchpoint_type
;
12159 /* loc2 is a duplicated location. We need to check
12160 if it should be inserted in case it will be
12162 if (loc2
!= old_loc
12163 && unduplicated_should_be_inserted (loc2
))
12165 swap_insertion (old_loc
, loc2
);
12166 keep_in_target
= 1;
12174 if (!keep_in_target
)
12176 if (remove_breakpoint (old_loc
))
12178 /* This is just about all we can do. We could keep
12179 this location on the global list, and try to
12180 remove it next time, but there's no particular
12181 reason why we will succeed next time.
12183 Note that at this point, old_loc->owner is still
12184 valid, as delete_breakpoint frees the breakpoint
12185 only after calling us. */
12186 printf_filtered (_("warning: Error removing "
12187 "breakpoint %d\n"),
12188 old_loc
->owner
->number
);
12196 if (removed
&& target_is_non_stop_p ()
12197 && need_moribund_for_location_type (old_loc
))
12199 /* This location was removed from the target. In
12200 non-stop mode, a race condition is possible where
12201 we've removed a breakpoint, but stop events for that
12202 breakpoint are already queued and will arrive later.
12203 We apply an heuristic to be able to distinguish such
12204 SIGTRAPs from other random SIGTRAPs: we keep this
12205 breakpoint location for a bit, and will retire it
12206 after we see some number of events. The theory here
12207 is that reporting of events should, "on the average",
12208 be fair, so after a while we'll see events from all
12209 threads that have anything of interest, and no longer
12210 need to keep this breakpoint location around. We
12211 don't hold locations forever so to reduce chances of
12212 mistaking a non-breakpoint SIGTRAP for a breakpoint
12215 The heuristic failing can be disastrous on
12216 decr_pc_after_break targets.
12218 On decr_pc_after_break targets, like e.g., x86-linux,
12219 if we fail to recognize a late breakpoint SIGTRAP,
12220 because events_till_retirement has reached 0 too
12221 soon, we'll fail to do the PC adjustment, and report
12222 a random SIGTRAP to the user. When the user resumes
12223 the inferior, it will most likely immediately crash
12224 with SIGILL/SIGBUS/SIGSEGV, or worse, get silently
12225 corrupted, because of being resumed e.g., in the
12226 middle of a multi-byte instruction, or skipped a
12227 one-byte instruction. This was actually seen happen
12228 on native x86-linux, and should be less rare on
12229 targets that do not support new thread events, like
12230 remote, due to the heuristic depending on
12233 Mistaking a random SIGTRAP for a breakpoint trap
12234 causes similar symptoms (PC adjustment applied when
12235 it shouldn't), but then again, playing with SIGTRAPs
12236 behind the debugger's back is asking for trouble.
12238 Since hardware watchpoint traps are always
12239 distinguishable from other traps, so we don't need to
12240 apply keep hardware watchpoint moribund locations
12241 around. We simply always ignore hardware watchpoint
12242 traps we can no longer explain. */
12244 old_loc
->events_till_retirement
= 3 * (thread_count () + 1);
12245 old_loc
->owner
= NULL
;
12247 VEC_safe_push (bp_location_p
, moribund_locations
, old_loc
);
12251 old_loc
->owner
= NULL
;
12252 decref_bp_location (&old_loc
);
12257 /* Rescan breakpoints at the same address and section, marking the
12258 first one as "first" and any others as "duplicates". This is so
12259 that the bpt instruction is only inserted once. If we have a
12260 permanent breakpoint at the same place as BPT, make that one the
12261 official one, and the rest as duplicates. Permanent breakpoints
12262 are sorted first for the same address.
12264 Do the same for hardware watchpoints, but also considering the
12265 watchpoint's type (regular/access/read) and length. */
12267 bp_loc_first
= NULL
;
12268 wp_loc_first
= NULL
;
12269 awp_loc_first
= NULL
;
12270 rwp_loc_first
= NULL
;
12271 ALL_BP_LOCATIONS (loc
, locp
)
12273 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always
12275 struct bp_location
**loc_first_p
;
12278 if (!unduplicated_should_be_inserted (loc
)
12279 || !breakpoint_address_is_meaningful (b
)
12280 /* Don't detect duplicate for tracepoint locations because they are
12281 never duplicated. See the comments in field `duplicate' of
12282 `struct bp_location'. */
12283 || is_tracepoint (b
))
12285 /* Clear the condition modification flag. */
12286 loc
->condition_changed
= condition_unchanged
;
12290 if (b
->type
== bp_hardware_watchpoint
)
12291 loc_first_p
= &wp_loc_first
;
12292 else if (b
->type
== bp_read_watchpoint
)
12293 loc_first_p
= &rwp_loc_first
;
12294 else if (b
->type
== bp_access_watchpoint
)
12295 loc_first_p
= &awp_loc_first
;
12297 loc_first_p
= &bp_loc_first
;
12299 if (*loc_first_p
== NULL
12300 || (overlay_debugging
&& loc
->section
!= (*loc_first_p
)->section
)
12301 || !breakpoint_locations_match (loc
, *loc_first_p
))
12303 *loc_first_p
= loc
;
12304 loc
->duplicate
= 0;
12306 if (is_breakpoint (loc
->owner
) && loc
->condition_changed
)
12308 loc
->needs_update
= 1;
12309 /* Clear the condition modification flag. */
12310 loc
->condition_changed
= condition_unchanged
;
12316 /* This and the above ensure the invariant that the first location
12317 is not duplicated, and is the inserted one.
12318 All following are marked as duplicated, and are not inserted. */
12320 swap_insertion (loc
, *loc_first_p
);
12321 loc
->duplicate
= 1;
12323 /* Clear the condition modification flag. */
12324 loc
->condition_changed
= condition_unchanged
;
12327 if (insert_mode
== UGLL_INSERT
|| breakpoints_should_be_inserted_now ())
12329 if (insert_mode
!= UGLL_DONT_INSERT
)
12330 insert_breakpoint_locations ();
12333 /* Even though the caller told us to not insert new
12334 locations, we may still need to update conditions on the
12335 target's side of breakpoints that were already inserted
12336 if the target is evaluating breakpoint conditions. We
12337 only update conditions for locations that are marked
12339 update_inserted_breakpoint_locations ();
12343 if (insert_mode
!= UGLL_DONT_INSERT
)
12344 download_tracepoint_locations ();
12346 do_cleanups (cleanups
);
12350 breakpoint_retire_moribund (void)
12352 struct bp_location
*loc
;
12355 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
12356 if (--(loc
->events_till_retirement
) == 0)
12358 decref_bp_location (&loc
);
12359 VEC_unordered_remove (bp_location_p
, moribund_locations
, ix
);
12365 update_global_location_list_nothrow (enum ugll_insert_mode insert_mode
)
12370 update_global_location_list (insert_mode
);
12372 CATCH (e
, RETURN_MASK_ERROR
)
12378 /* Clear BKP from a BPS. */
12381 bpstat_remove_bp_location (bpstat bps
, struct breakpoint
*bpt
)
12385 for (bs
= bps
; bs
; bs
= bs
->next
)
12386 if (bs
->breakpoint_at
== bpt
)
12388 bs
->breakpoint_at
= NULL
;
12389 bs
->old_val
= NULL
;
12390 /* bs->commands will be freed later. */
12394 /* Callback for iterate_over_threads. */
12396 bpstat_remove_breakpoint_callback (struct thread_info
*th
, void *data
)
12398 struct breakpoint
*bpt
= (struct breakpoint
*) data
;
12400 bpstat_remove_bp_location (th
->control
.stop_bpstat
, bpt
);
12404 /* Helper for breakpoint and tracepoint breakpoint_ops->mention
12408 say_where (struct breakpoint
*b
)
12410 struct value_print_options opts
;
12412 get_user_print_options (&opts
);
12414 /* i18n: cagney/2005-02-11: Below needs to be merged into a
12416 if (b
->loc
== NULL
)
12418 /* For pending locations, the output differs slightly based
12419 on b->extra_string. If this is non-NULL, it contains either
12420 a condition or dprintf arguments. */
12421 if (b
->extra_string
== NULL
)
12423 printf_filtered (_(" (%s) pending."),
12424 event_location_to_string (b
->location
.get ()));
12426 else if (b
->type
== bp_dprintf
)
12428 printf_filtered (_(" (%s,%s) pending."),
12429 event_location_to_string (b
->location
.get ()),
12434 printf_filtered (_(" (%s %s) pending."),
12435 event_location_to_string (b
->location
.get ()),
12441 if (opts
.addressprint
|| b
->loc
->symtab
== NULL
)
12443 printf_filtered (" at ");
12444 fputs_filtered (paddress (b
->loc
->gdbarch
, b
->loc
->address
),
12447 if (b
->loc
->symtab
!= NULL
)
12449 /* If there is a single location, we can print the location
12451 if (b
->loc
->next
== NULL
)
12452 printf_filtered (": file %s, line %d.",
12453 symtab_to_filename_for_display (b
->loc
->symtab
),
12454 b
->loc
->line_number
);
12456 /* This is not ideal, but each location may have a
12457 different file name, and this at least reflects the
12458 real situation somewhat. */
12459 printf_filtered (": %s.",
12460 event_location_to_string (b
->location
.get ()));
12465 struct bp_location
*loc
= b
->loc
;
12467 for (; loc
; loc
= loc
->next
)
12469 printf_filtered (" (%d locations)", n
);
12474 /* Default bp_location_ops methods. */
12477 bp_location_dtor (struct bp_location
*self
)
12479 xfree (self
->function_name
);
12482 static const struct bp_location_ops bp_location_ops
=
12487 /* Destructor for the breakpoint base class. */
12489 breakpoint::~breakpoint ()
12491 xfree (this->cond_string
);
12492 xfree (this->extra_string
);
12493 xfree (this->filter
);
12496 static struct bp_location
*
12497 base_breakpoint_allocate_location (struct breakpoint
*self
)
12499 return new bp_location (&bp_location_ops
, self
);
12503 base_breakpoint_re_set (struct breakpoint
*b
)
12505 /* Nothing to re-set. */
12508 #define internal_error_pure_virtual_called() \
12509 gdb_assert_not_reached ("pure virtual function called")
12512 base_breakpoint_insert_location (struct bp_location
*bl
)
12514 internal_error_pure_virtual_called ();
12518 base_breakpoint_remove_location (struct bp_location
*bl
,
12519 enum remove_bp_reason reason
)
12521 internal_error_pure_virtual_called ();
12525 base_breakpoint_breakpoint_hit (const struct bp_location
*bl
,
12526 struct address_space
*aspace
,
12528 const struct target_waitstatus
*ws
)
12530 internal_error_pure_virtual_called ();
12534 base_breakpoint_check_status (bpstat bs
)
12539 /* A "works_in_software_mode" breakpoint_ops method that just internal
12543 base_breakpoint_works_in_software_mode (const struct breakpoint
*b
)
12545 internal_error_pure_virtual_called ();
12548 /* A "resources_needed" breakpoint_ops method that just internal
12552 base_breakpoint_resources_needed (const struct bp_location
*bl
)
12554 internal_error_pure_virtual_called ();
12557 static enum print_stop_action
12558 base_breakpoint_print_it (bpstat bs
)
12560 internal_error_pure_virtual_called ();
12564 base_breakpoint_print_one_detail (const struct breakpoint
*self
,
12565 struct ui_out
*uiout
)
12571 base_breakpoint_print_mention (struct breakpoint
*b
)
12573 internal_error_pure_virtual_called ();
12577 base_breakpoint_print_recreate (struct breakpoint
*b
, struct ui_file
*fp
)
12579 internal_error_pure_virtual_called ();
12583 base_breakpoint_create_sals_from_location
12584 (const struct event_location
*location
,
12585 struct linespec_result
*canonical
,
12586 enum bptype type_wanted
)
12588 internal_error_pure_virtual_called ();
12592 base_breakpoint_create_breakpoints_sal (struct gdbarch
*gdbarch
,
12593 struct linespec_result
*c
,
12594 gdb::unique_xmalloc_ptr
<char> cond_string
,
12595 gdb::unique_xmalloc_ptr
<char> extra_string
,
12596 enum bptype type_wanted
,
12597 enum bpdisp disposition
,
12599 int task
, int ignore_count
,
12600 const struct breakpoint_ops
*o
,
12601 int from_tty
, int enabled
,
12602 int internal
, unsigned flags
)
12604 internal_error_pure_virtual_called ();
12607 static std::vector
<symtab_and_line
>
12608 base_breakpoint_decode_location (struct breakpoint
*b
,
12609 const struct event_location
*location
,
12610 struct program_space
*search_pspace
)
12612 internal_error_pure_virtual_called ();
12615 /* The default 'explains_signal' method. */
12618 base_breakpoint_explains_signal (struct breakpoint
*b
, enum gdb_signal sig
)
12623 /* The default "after_condition_true" method. */
12626 base_breakpoint_after_condition_true (struct bpstats
*bs
)
12628 /* Nothing to do. */
12631 struct breakpoint_ops base_breakpoint_ops
=
12633 base_breakpoint_allocate_location
,
12634 base_breakpoint_re_set
,
12635 base_breakpoint_insert_location
,
12636 base_breakpoint_remove_location
,
12637 base_breakpoint_breakpoint_hit
,
12638 base_breakpoint_check_status
,
12639 base_breakpoint_resources_needed
,
12640 base_breakpoint_works_in_software_mode
,
12641 base_breakpoint_print_it
,
12643 base_breakpoint_print_one_detail
,
12644 base_breakpoint_print_mention
,
12645 base_breakpoint_print_recreate
,
12646 base_breakpoint_create_sals_from_location
,
12647 base_breakpoint_create_breakpoints_sal
,
12648 base_breakpoint_decode_location
,
12649 base_breakpoint_explains_signal
,
12650 base_breakpoint_after_condition_true
,
12653 /* Default breakpoint_ops methods. */
12656 bkpt_re_set (struct breakpoint
*b
)
12658 /* FIXME: is this still reachable? */
12659 if (breakpoint_event_location_empty_p (b
))
12661 /* Anything without a location can't be re-set. */
12662 delete_breakpoint (b
);
12666 breakpoint_re_set_default (b
);
12670 bkpt_insert_location (struct bp_location
*bl
)
12672 CORE_ADDR addr
= bl
->target_info
.reqstd_address
;
12674 bl
->target_info
.kind
= breakpoint_kind (bl
, &addr
);
12675 bl
->target_info
.placed_address
= addr
;
12677 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
12678 return target_insert_hw_breakpoint (bl
->gdbarch
, &bl
->target_info
);
12680 return target_insert_breakpoint (bl
->gdbarch
, &bl
->target_info
);
12684 bkpt_remove_location (struct bp_location
*bl
, enum remove_bp_reason reason
)
12686 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
12687 return target_remove_hw_breakpoint (bl
->gdbarch
, &bl
->target_info
);
12689 return target_remove_breakpoint (bl
->gdbarch
, &bl
->target_info
, reason
);
12693 bkpt_breakpoint_hit (const struct bp_location
*bl
,
12694 struct address_space
*aspace
, CORE_ADDR bp_addr
,
12695 const struct target_waitstatus
*ws
)
12697 if (ws
->kind
!= TARGET_WAITKIND_STOPPED
12698 || ws
->value
.sig
!= GDB_SIGNAL_TRAP
)
12701 if (!breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
12705 if (overlay_debugging
/* unmapped overlay section */
12706 && section_is_overlay (bl
->section
)
12707 && !section_is_mapped (bl
->section
))
12714 dprintf_breakpoint_hit (const struct bp_location
*bl
,
12715 struct address_space
*aspace
, CORE_ADDR bp_addr
,
12716 const struct target_waitstatus
*ws
)
12718 if (dprintf_style
== dprintf_style_agent
12719 && target_can_run_breakpoint_commands ())
12721 /* An agent-style dprintf never causes a stop. If we see a trap
12722 for this address it must be for a breakpoint that happens to
12723 be set at the same address. */
12727 return bkpt_breakpoint_hit (bl
, aspace
, bp_addr
, ws
);
12731 bkpt_resources_needed (const struct bp_location
*bl
)
12733 gdb_assert (bl
->owner
->type
== bp_hardware_breakpoint
);
12738 static enum print_stop_action
12739 bkpt_print_it (bpstat bs
)
12741 struct breakpoint
*b
;
12742 const struct bp_location
*bl
;
12744 struct ui_out
*uiout
= current_uiout
;
12746 gdb_assert (bs
->bp_location_at
!= NULL
);
12748 bl
= bs
->bp_location_at
;
12749 b
= bs
->breakpoint_at
;
12751 bp_temp
= b
->disposition
== disp_del
;
12752 if (bl
->address
!= bl
->requested_address
)
12753 breakpoint_adjustment_warning (bl
->requested_address
,
12756 annotate_breakpoint (b
->number
);
12757 maybe_print_thread_hit_breakpoint (uiout
);
12760 uiout
->text ("Temporary breakpoint ");
12762 uiout
->text ("Breakpoint ");
12763 if (uiout
->is_mi_like_p ())
12765 uiout
->field_string ("reason",
12766 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
12767 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
12769 uiout
->field_int ("bkptno", b
->number
);
12770 uiout
->text (", ");
12772 return PRINT_SRC_AND_LOC
;
12776 bkpt_print_mention (struct breakpoint
*b
)
12778 if (current_uiout
->is_mi_like_p ())
12783 case bp_breakpoint
:
12784 case bp_gnu_ifunc_resolver
:
12785 if (b
->disposition
== disp_del
)
12786 printf_filtered (_("Temporary breakpoint"));
12788 printf_filtered (_("Breakpoint"));
12789 printf_filtered (_(" %d"), b
->number
);
12790 if (b
->type
== bp_gnu_ifunc_resolver
)
12791 printf_filtered (_(" at gnu-indirect-function resolver"));
12793 case bp_hardware_breakpoint
:
12794 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
12797 printf_filtered (_("Dprintf %d"), b
->number
);
12805 bkpt_print_recreate (struct breakpoint
*tp
, struct ui_file
*fp
)
12807 if (tp
->type
== bp_breakpoint
&& tp
->disposition
== disp_del
)
12808 fprintf_unfiltered (fp
, "tbreak");
12809 else if (tp
->type
== bp_breakpoint
)
12810 fprintf_unfiltered (fp
, "break");
12811 else if (tp
->type
== bp_hardware_breakpoint
12812 && tp
->disposition
== disp_del
)
12813 fprintf_unfiltered (fp
, "thbreak");
12814 else if (tp
->type
== bp_hardware_breakpoint
)
12815 fprintf_unfiltered (fp
, "hbreak");
12817 internal_error (__FILE__
, __LINE__
,
12818 _("unhandled breakpoint type %d"), (int) tp
->type
);
12820 fprintf_unfiltered (fp
, " %s",
12821 event_location_to_string (tp
->location
.get ()));
12823 /* Print out extra_string if this breakpoint is pending. It might
12824 contain, for example, conditions that were set by the user. */
12825 if (tp
->loc
== NULL
&& tp
->extra_string
!= NULL
)
12826 fprintf_unfiltered (fp
, " %s", tp
->extra_string
);
12828 print_recreate_thread (tp
, fp
);
12832 bkpt_create_sals_from_location (const struct event_location
*location
,
12833 struct linespec_result
*canonical
,
12834 enum bptype type_wanted
)
12836 create_sals_from_location_default (location
, canonical
, type_wanted
);
12840 bkpt_create_breakpoints_sal (struct gdbarch
*gdbarch
,
12841 struct linespec_result
*canonical
,
12842 gdb::unique_xmalloc_ptr
<char> cond_string
,
12843 gdb::unique_xmalloc_ptr
<char> extra_string
,
12844 enum bptype type_wanted
,
12845 enum bpdisp disposition
,
12847 int task
, int ignore_count
,
12848 const struct breakpoint_ops
*ops
,
12849 int from_tty
, int enabled
,
12850 int internal
, unsigned flags
)
12852 create_breakpoints_sal_default (gdbarch
, canonical
,
12853 std::move (cond_string
),
12854 std::move (extra_string
),
12856 disposition
, thread
, task
,
12857 ignore_count
, ops
, from_tty
,
12858 enabled
, internal
, flags
);
12861 static std::vector
<symtab_and_line
>
12862 bkpt_decode_location (struct breakpoint
*b
,
12863 const struct event_location
*location
,
12864 struct program_space
*search_pspace
)
12866 return decode_location_default (b
, location
, search_pspace
);
12869 /* Virtual table for internal breakpoints. */
12872 internal_bkpt_re_set (struct breakpoint
*b
)
12876 /* Delete overlay event and longjmp master breakpoints; they
12877 will be reset later by breakpoint_re_set. */
12878 case bp_overlay_event
:
12879 case bp_longjmp_master
:
12880 case bp_std_terminate_master
:
12881 case bp_exception_master
:
12882 delete_breakpoint (b
);
12885 /* This breakpoint is special, it's set up when the inferior
12886 starts and we really don't want to touch it. */
12887 case bp_shlib_event
:
12889 /* Like bp_shlib_event, this breakpoint type is special. Once
12890 it is set up, we do not want to touch it. */
12891 case bp_thread_event
:
12897 internal_bkpt_check_status (bpstat bs
)
12899 if (bs
->breakpoint_at
->type
== bp_shlib_event
)
12901 /* If requested, stop when the dynamic linker notifies GDB of
12902 events. This allows the user to get control and place
12903 breakpoints in initializer routines for dynamically loaded
12904 objects (among other things). */
12905 bs
->stop
= stop_on_solib_events
;
12906 bs
->print
= stop_on_solib_events
;
12912 static enum print_stop_action
12913 internal_bkpt_print_it (bpstat bs
)
12915 struct breakpoint
*b
;
12917 b
= bs
->breakpoint_at
;
12921 case bp_shlib_event
:
12922 /* Did we stop because the user set the stop_on_solib_events
12923 variable? (If so, we report this as a generic, "Stopped due
12924 to shlib event" message.) */
12925 print_solib_event (0);
12928 case bp_thread_event
:
12929 /* Not sure how we will get here.
12930 GDB should not stop for these breakpoints. */
12931 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
12934 case bp_overlay_event
:
12935 /* By analogy with the thread event, GDB should not stop for these. */
12936 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
12939 case bp_longjmp_master
:
12940 /* These should never be enabled. */
12941 printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
12944 case bp_std_terminate_master
:
12945 /* These should never be enabled. */
12946 printf_filtered (_("std::terminate Master Breakpoint: "
12947 "gdb should not stop!\n"));
12950 case bp_exception_master
:
12951 /* These should never be enabled. */
12952 printf_filtered (_("Exception Master Breakpoint: "
12953 "gdb should not stop!\n"));
12957 return PRINT_NOTHING
;
12961 internal_bkpt_print_mention (struct breakpoint
*b
)
12963 /* Nothing to mention. These breakpoints are internal. */
12966 /* Virtual table for momentary breakpoints */
12969 momentary_bkpt_re_set (struct breakpoint
*b
)
12971 /* Keep temporary breakpoints, which can be encountered when we step
12972 over a dlopen call and solib_add is resetting the breakpoints.
12973 Otherwise these should have been blown away via the cleanup chain
12974 or by breakpoint_init_inferior when we rerun the executable. */
12978 momentary_bkpt_check_status (bpstat bs
)
12980 /* Nothing. The point of these breakpoints is causing a stop. */
12983 static enum print_stop_action
12984 momentary_bkpt_print_it (bpstat bs
)
12986 return PRINT_UNKNOWN
;
12990 momentary_bkpt_print_mention (struct breakpoint
*b
)
12992 /* Nothing to mention. These breakpoints are internal. */
12995 /* Ensure INITIATING_FRAME is cleared when no such breakpoint exists.
12997 It gets cleared already on the removal of the first one of such placed
12998 breakpoints. This is OK as they get all removed altogether. */
13000 longjmp_breakpoint::~longjmp_breakpoint ()
13002 thread_info
*tp
= find_thread_global_id (this->thread
);
13005 tp
->initiating_frame
= null_frame_id
;
13008 /* Specific methods for probe breakpoints. */
13011 bkpt_probe_insert_location (struct bp_location
*bl
)
13013 int v
= bkpt_insert_location (bl
);
13017 /* The insertion was successful, now let's set the probe's semaphore
13019 if (bl
->probe
.probe
->pops
->set_semaphore
!= NULL
)
13020 bl
->probe
.probe
->pops
->set_semaphore (bl
->probe
.probe
,
13029 bkpt_probe_remove_location (struct bp_location
*bl
,
13030 enum remove_bp_reason reason
)
13032 /* Let's clear the semaphore before removing the location. */
13033 if (bl
->probe
.probe
->pops
->clear_semaphore
!= NULL
)
13034 bl
->probe
.probe
->pops
->clear_semaphore (bl
->probe
.probe
,
13038 return bkpt_remove_location (bl
, reason
);
13042 bkpt_probe_create_sals_from_location (const struct event_location
*location
,
13043 struct linespec_result
*canonical
,
13044 enum bptype type_wanted
)
13046 struct linespec_sals lsal
;
13048 lsal
.sals
= parse_probes (location
, NULL
, canonical
);
13050 = xstrdup (event_location_to_string (canonical
->location
.get ()));
13051 canonical
->lsals
.push_back (std::move (lsal
));
13054 static std::vector
<symtab_and_line
>
13055 bkpt_probe_decode_location (struct breakpoint
*b
,
13056 const struct event_location
*location
,
13057 struct program_space
*search_pspace
)
13059 std::vector
<symtab_and_line
> sals
= parse_probes (location
, search_pspace
, NULL
);
13061 error (_("probe not found"));
13065 /* The breakpoint_ops structure to be used in tracepoints. */
13068 tracepoint_re_set (struct breakpoint
*b
)
13070 breakpoint_re_set_default (b
);
13074 tracepoint_breakpoint_hit (const struct bp_location
*bl
,
13075 struct address_space
*aspace
, CORE_ADDR bp_addr
,
13076 const struct target_waitstatus
*ws
)
13078 /* By definition, the inferior does not report stops at
13084 tracepoint_print_one_detail (const struct breakpoint
*self
,
13085 struct ui_out
*uiout
)
13087 struct tracepoint
*tp
= (struct tracepoint
*) self
;
13088 if (tp
->static_trace_marker_id
)
13090 gdb_assert (self
->type
== bp_static_tracepoint
);
13092 uiout
->text ("\tmarker id is ");
13093 uiout
->field_string ("static-tracepoint-marker-string-id",
13094 tp
->static_trace_marker_id
);
13095 uiout
->text ("\n");
13100 tracepoint_print_mention (struct breakpoint
*b
)
13102 if (current_uiout
->is_mi_like_p ())
13107 case bp_tracepoint
:
13108 printf_filtered (_("Tracepoint"));
13109 printf_filtered (_(" %d"), b
->number
);
13111 case bp_fast_tracepoint
:
13112 printf_filtered (_("Fast tracepoint"));
13113 printf_filtered (_(" %d"), b
->number
);
13115 case bp_static_tracepoint
:
13116 printf_filtered (_("Static tracepoint"));
13117 printf_filtered (_(" %d"), b
->number
);
13120 internal_error (__FILE__
, __LINE__
,
13121 _("unhandled tracepoint type %d"), (int) b
->type
);
13128 tracepoint_print_recreate (struct breakpoint
*self
, struct ui_file
*fp
)
13130 struct tracepoint
*tp
= (struct tracepoint
*) self
;
13132 if (self
->type
== bp_fast_tracepoint
)
13133 fprintf_unfiltered (fp
, "ftrace");
13134 else if (self
->type
== bp_static_tracepoint
)
13135 fprintf_unfiltered (fp
, "strace");
13136 else if (self
->type
== bp_tracepoint
)
13137 fprintf_unfiltered (fp
, "trace");
13139 internal_error (__FILE__
, __LINE__
,
13140 _("unhandled tracepoint type %d"), (int) self
->type
);
13142 fprintf_unfiltered (fp
, " %s",
13143 event_location_to_string (self
->location
.get ()));
13144 print_recreate_thread (self
, fp
);
13146 if (tp
->pass_count
)
13147 fprintf_unfiltered (fp
, " passcount %d\n", tp
->pass_count
);
13151 tracepoint_create_sals_from_location (const struct event_location
*location
,
13152 struct linespec_result
*canonical
,
13153 enum bptype type_wanted
)
13155 create_sals_from_location_default (location
, canonical
, type_wanted
);
13159 tracepoint_create_breakpoints_sal (struct gdbarch
*gdbarch
,
13160 struct linespec_result
*canonical
,
13161 gdb::unique_xmalloc_ptr
<char> cond_string
,
13162 gdb::unique_xmalloc_ptr
<char> extra_string
,
13163 enum bptype type_wanted
,
13164 enum bpdisp disposition
,
13166 int task
, int ignore_count
,
13167 const struct breakpoint_ops
*ops
,
13168 int from_tty
, int enabled
,
13169 int internal
, unsigned flags
)
13171 create_breakpoints_sal_default (gdbarch
, canonical
,
13172 std::move (cond_string
),
13173 std::move (extra_string
),
13175 disposition
, thread
, task
,
13176 ignore_count
, ops
, from_tty
,
13177 enabled
, internal
, flags
);
13180 static std::vector
<symtab_and_line
>
13181 tracepoint_decode_location (struct breakpoint
*b
,
13182 const struct event_location
*location
,
13183 struct program_space
*search_pspace
)
13185 return decode_location_default (b
, location
, search_pspace
);
13188 struct breakpoint_ops tracepoint_breakpoint_ops
;
13190 /* The breakpoint_ops structure to be use on tracepoints placed in a
13194 tracepoint_probe_create_sals_from_location
13195 (const struct event_location
*location
,
13196 struct linespec_result
*canonical
,
13197 enum bptype type_wanted
)
13199 /* We use the same method for breakpoint on probes. */
13200 bkpt_probe_create_sals_from_location (location
, canonical
, type_wanted
);
13203 static std::vector
<symtab_and_line
>
13204 tracepoint_probe_decode_location (struct breakpoint
*b
,
13205 const struct event_location
*location
,
13206 struct program_space
*search_pspace
)
13208 /* We use the same method for breakpoint on probes. */
13209 return bkpt_probe_decode_location (b
, location
, search_pspace
);
13212 static struct breakpoint_ops tracepoint_probe_breakpoint_ops
;
13214 /* Dprintf breakpoint_ops methods. */
13217 dprintf_re_set (struct breakpoint
*b
)
13219 breakpoint_re_set_default (b
);
13221 /* extra_string should never be non-NULL for dprintf. */
13222 gdb_assert (b
->extra_string
!= NULL
);
13224 /* 1 - connect to target 1, that can run breakpoint commands.
13225 2 - create a dprintf, which resolves fine.
13226 3 - disconnect from target 1
13227 4 - connect to target 2, that can NOT run breakpoint commands.
13229 After steps #3/#4, you'll want the dprintf command list to
13230 be updated, because target 1 and 2 may well return different
13231 answers for target_can_run_breakpoint_commands().
13232 Given absence of finer grained resetting, we get to do
13233 it all the time. */
13234 if (b
->extra_string
!= NULL
)
13235 update_dprintf_command_list (b
);
13238 /* Implement the "print_recreate" breakpoint_ops method for dprintf. */
13241 dprintf_print_recreate (struct breakpoint
*tp
, struct ui_file
*fp
)
13243 fprintf_unfiltered (fp
, "dprintf %s,%s",
13244 event_location_to_string (tp
->location
.get ()),
13246 print_recreate_thread (tp
, fp
);
13249 /* Implement the "after_condition_true" breakpoint_ops method for
13252 dprintf's are implemented with regular commands in their command
13253 list, but we run the commands here instead of before presenting the
13254 stop to the user, as dprintf's don't actually cause a stop. This
13255 also makes it so that the commands of multiple dprintfs at the same
13256 address are all handled. */
13259 dprintf_after_condition_true (struct bpstats
*bs
)
13261 struct bpstats tmp_bs
;
13262 struct bpstats
*tmp_bs_p
= &tmp_bs
;
13264 /* dprintf's never cause a stop. This wasn't set in the
13265 check_status hook instead because that would make the dprintf's
13266 condition not be evaluated. */
13269 /* Run the command list here. Take ownership of it instead of
13270 copying. We never want these commands to run later in
13271 bpstat_do_actions, if a breakpoint that causes a stop happens to
13272 be set at same address as this dprintf, or even if running the
13273 commands here throws. */
13274 tmp_bs
.commands
= bs
->commands
;
13275 bs
->commands
= NULL
;
13277 bpstat_do_actions_1 (&tmp_bs_p
);
13279 /* 'tmp_bs.commands' will usually be NULL by now, but
13280 bpstat_do_actions_1 may return early without processing the whole
13284 /* The breakpoint_ops structure to be used on static tracepoints with
13288 strace_marker_create_sals_from_location (const struct event_location
*location
,
13289 struct linespec_result
*canonical
,
13290 enum bptype type_wanted
)
13292 struct linespec_sals lsal
;
13293 const char *arg_start
, *arg
;
13295 arg
= arg_start
= get_linespec_location (location
);
13296 lsal
.sals
= decode_static_tracepoint_spec (&arg
);
13298 std::string
str (arg_start
, arg
- arg_start
);
13299 const char *ptr
= str
.c_str ();
13300 canonical
->location
= new_linespec_location (&ptr
);
13303 = xstrdup (event_location_to_string (canonical
->location
.get ()));
13304 canonical
->lsals
.push_back (std::move (lsal
));
13308 strace_marker_create_breakpoints_sal (struct gdbarch
*gdbarch
,
13309 struct linespec_result
*canonical
,
13310 gdb::unique_xmalloc_ptr
<char> cond_string
,
13311 gdb::unique_xmalloc_ptr
<char> extra_string
,
13312 enum bptype type_wanted
,
13313 enum bpdisp disposition
,
13315 int task
, int ignore_count
,
13316 const struct breakpoint_ops
*ops
,
13317 int from_tty
, int enabled
,
13318 int internal
, unsigned flags
)
13320 const linespec_sals
&lsal
= canonical
->lsals
[0];
13322 /* If the user is creating a static tracepoint by marker id
13323 (strace -m MARKER_ID), then store the sals index, so that
13324 breakpoint_re_set can try to match up which of the newly
13325 found markers corresponds to this one, and, don't try to
13326 expand multiple locations for each sal, given than SALS
13327 already should contain all sals for MARKER_ID. */
13329 for (size_t i
= 0; i
< lsal
.sals
.size (); i
++)
13331 event_location_up location
13332 = copy_event_location (canonical
->location
.get ());
13334 std::unique_ptr
<tracepoint
> tp (new tracepoint ());
13335 init_breakpoint_sal (tp
.get (), gdbarch
, lsal
.sals
[i
],
13336 std::move (location
), NULL
,
13337 std::move (cond_string
),
13338 std::move (extra_string
),
13339 type_wanted
, disposition
,
13340 thread
, task
, ignore_count
, ops
,
13341 from_tty
, enabled
, internal
, flags
,
13342 canonical
->special_display
);
13343 /* Given that its possible to have multiple markers with
13344 the same string id, if the user is creating a static
13345 tracepoint by marker id ("strace -m MARKER_ID"), then
13346 store the sals index, so that breakpoint_re_set can
13347 try to match up which of the newly found markers
13348 corresponds to this one */
13349 tp
->static_trace_marker_id_idx
= i
;
13351 install_breakpoint (internal
, std::move (tp
), 0);
13355 static std::vector
<symtab_and_line
>
13356 strace_marker_decode_location (struct breakpoint
*b
,
13357 const struct event_location
*location
,
13358 struct program_space
*search_pspace
)
13360 struct tracepoint
*tp
= (struct tracepoint
*) b
;
13361 const char *s
= get_linespec_location (location
);
13363 std::vector
<symtab_and_line
> sals
= decode_static_tracepoint_spec (&s
);
13364 if (sals
.size () > tp
->static_trace_marker_id_idx
)
13366 sals
[0] = sals
[tp
->static_trace_marker_id_idx
];
13371 error (_("marker %s not found"), tp
->static_trace_marker_id
);
13374 static struct breakpoint_ops strace_marker_breakpoint_ops
;
13377 strace_marker_p (struct breakpoint
*b
)
13379 return b
->ops
== &strace_marker_breakpoint_ops
;
13382 /* Delete a breakpoint and clean up all traces of it in the data
13386 delete_breakpoint (struct breakpoint
*bpt
)
13388 struct breakpoint
*b
;
13390 gdb_assert (bpt
!= NULL
);
13392 /* Has this bp already been deleted? This can happen because
13393 multiple lists can hold pointers to bp's. bpstat lists are
13396 One example of this happening is a watchpoint's scope bp. When
13397 the scope bp triggers, we notice that the watchpoint is out of
13398 scope, and delete it. We also delete its scope bp. But the
13399 scope bp is marked "auto-deleting", and is already on a bpstat.
13400 That bpstat is then checked for auto-deleting bp's, which are
13403 A real solution to this problem might involve reference counts in
13404 bp's, and/or giving them pointers back to their referencing
13405 bpstat's, and teaching delete_breakpoint to only free a bp's
13406 storage when no more references were extent. A cheaper bandaid
13408 if (bpt
->type
== bp_none
)
13411 /* At least avoid this stale reference until the reference counting
13412 of breakpoints gets resolved. */
13413 if (bpt
->related_breakpoint
!= bpt
)
13415 struct breakpoint
*related
;
13416 struct watchpoint
*w
;
13418 if (bpt
->type
== bp_watchpoint_scope
)
13419 w
= (struct watchpoint
*) bpt
->related_breakpoint
;
13420 else if (bpt
->related_breakpoint
->type
== bp_watchpoint_scope
)
13421 w
= (struct watchpoint
*) bpt
;
13425 watchpoint_del_at_next_stop (w
);
13427 /* Unlink bpt from the bpt->related_breakpoint ring. */
13428 for (related
= bpt
; related
->related_breakpoint
!= bpt
;
13429 related
= related
->related_breakpoint
);
13430 related
->related_breakpoint
= bpt
->related_breakpoint
;
13431 bpt
->related_breakpoint
= bpt
;
13434 /* watch_command_1 creates a watchpoint but only sets its number if
13435 update_watchpoint succeeds in creating its bp_locations. If there's
13436 a problem in that process, we'll be asked to delete the half-created
13437 watchpoint. In that case, don't announce the deletion. */
13439 observer_notify_breakpoint_deleted (bpt
);
13441 if (breakpoint_chain
== bpt
)
13442 breakpoint_chain
= bpt
->next
;
13444 ALL_BREAKPOINTS (b
)
13445 if (b
->next
== bpt
)
13447 b
->next
= bpt
->next
;
13451 /* Be sure no bpstat's are pointing at the breakpoint after it's
13453 /* FIXME, how can we find all bpstat's? We just check stop_bpstat
13454 in all threads for now. Note that we cannot just remove bpstats
13455 pointing at bpt from the stop_bpstat list entirely, as breakpoint
13456 commands are associated with the bpstat; if we remove it here,
13457 then the later call to bpstat_do_actions (&stop_bpstat); in
13458 event-top.c won't do anything, and temporary breakpoints with
13459 commands won't work. */
13461 iterate_over_threads (bpstat_remove_breakpoint_callback
, bpt
);
13463 /* Now that breakpoint is removed from breakpoint list, update the
13464 global location list. This will remove locations that used to
13465 belong to this breakpoint. Do this before freeing the breakpoint
13466 itself, since remove_breakpoint looks at location's owner. It
13467 might be better design to have location completely
13468 self-contained, but it's not the case now. */
13469 update_global_location_list (UGLL_DONT_INSERT
);
13471 /* On the chance that someone will soon try again to delete this
13472 same bp, we mark it as deleted before freeing its storage. */
13473 bpt
->type
= bp_none
;
13478 do_delete_breakpoint_cleanup (void *b
)
13480 delete_breakpoint ((struct breakpoint
*) b
);
13484 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
13486 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
13489 /* Iterator function to call a user-provided callback function once
13490 for each of B and its related breakpoints. */
13493 iterate_over_related_breakpoints (struct breakpoint
*b
,
13494 gdb::function_view
<void (breakpoint
*)> function
)
13496 struct breakpoint
*related
;
13501 struct breakpoint
*next
;
13503 /* FUNCTION may delete RELATED. */
13504 next
= related
->related_breakpoint
;
13506 if (next
== related
)
13508 /* RELATED is the last ring entry. */
13509 function (related
);
13511 /* FUNCTION may have deleted it, so we'd never reach back to
13512 B. There's nothing left to do anyway, so just break
13517 function (related
);
13521 while (related
!= b
);
13525 delete_command (char *arg
, int from_tty
)
13527 struct breakpoint
*b
, *b_tmp
;
13533 int breaks_to_delete
= 0;
13535 /* Delete all breakpoints if no argument. Do not delete
13536 internal breakpoints, these have to be deleted with an
13537 explicit breakpoint number argument. */
13538 ALL_BREAKPOINTS (b
)
13539 if (user_breakpoint_p (b
))
13541 breaks_to_delete
= 1;
13545 /* Ask user only if there are some breakpoints to delete. */
13547 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
13549 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
13550 if (user_breakpoint_p (b
))
13551 delete_breakpoint (b
);
13555 map_breakpoint_numbers
13556 (arg
, [&] (breakpoint
*b
)
13558 iterate_over_related_breakpoints (b
, delete_breakpoint
);
13562 /* Return true if all locations of B bound to PSPACE are pending. If
13563 PSPACE is NULL, all locations of all program spaces are
13567 all_locations_are_pending (struct breakpoint
*b
, struct program_space
*pspace
)
13569 struct bp_location
*loc
;
13571 for (loc
= b
->loc
; loc
!= NULL
; loc
= loc
->next
)
13572 if ((pspace
== NULL
13573 || loc
->pspace
== pspace
)
13574 && !loc
->shlib_disabled
13575 && !loc
->pspace
->executing_startup
)
13580 /* Subroutine of update_breakpoint_locations to simplify it.
13581 Return non-zero if multiple fns in list LOC have the same name.
13582 Null names are ignored. */
13585 ambiguous_names_p (struct bp_location
*loc
)
13587 struct bp_location
*l
;
13588 htab_t htab
= htab_create_alloc (13, htab_hash_string
,
13589 (int (*) (const void *,
13590 const void *)) streq
,
13591 NULL
, xcalloc
, xfree
);
13593 for (l
= loc
; l
!= NULL
; l
= l
->next
)
13596 const char *name
= l
->function_name
;
13598 /* Allow for some names to be NULL, ignore them. */
13602 slot
= (const char **) htab_find_slot (htab
, (const void *) name
,
13604 /* NOTE: We can assume slot != NULL here because xcalloc never
13608 htab_delete (htab
);
13614 htab_delete (htab
);
13618 /* When symbols change, it probably means the sources changed as well,
13619 and it might mean the static tracepoint markers are no longer at
13620 the same address or line numbers they used to be at last we
13621 checked. Losing your static tracepoints whenever you rebuild is
13622 undesirable. This function tries to resync/rematch gdb static
13623 tracepoints with the markers on the target, for static tracepoints
13624 that have not been set by marker id. Static tracepoint that have
13625 been set by marker id are reset by marker id in breakpoint_re_set.
13628 1) For a tracepoint set at a specific address, look for a marker at
13629 the old PC. If one is found there, assume to be the same marker.
13630 If the name / string id of the marker found is different from the
13631 previous known name, assume that means the user renamed the marker
13632 in the sources, and output a warning.
13634 2) For a tracepoint set at a given line number, look for a marker
13635 at the new address of the old line number. If one is found there,
13636 assume to be the same marker. If the name / string id of the
13637 marker found is different from the previous known name, assume that
13638 means the user renamed the marker in the sources, and output a
13641 3) If a marker is no longer found at the same address or line, it
13642 may mean the marker no longer exists. But it may also just mean
13643 the code changed a bit. Maybe the user added a few lines of code
13644 that made the marker move up or down (in line number terms). Ask
13645 the target for info about the marker with the string id as we knew
13646 it. If found, update line number and address in the matching
13647 static tracepoint. This will get confused if there's more than one
13648 marker with the same ID (possible in UST, although unadvised
13649 precisely because it confuses tools). */
13651 static struct symtab_and_line
13652 update_static_tracepoint (struct breakpoint
*b
, struct symtab_and_line sal
)
13654 struct tracepoint
*tp
= (struct tracepoint
*) b
;
13655 struct static_tracepoint_marker marker
;
13660 find_line_pc (sal
.symtab
, sal
.line
, &pc
);
13662 if (target_static_tracepoint_marker_at (pc
, &marker
))
13664 if (strcmp (tp
->static_trace_marker_id
, marker
.str_id
) != 0)
13665 warning (_("static tracepoint %d changed probed marker from %s to %s"),
13667 tp
->static_trace_marker_id
, marker
.str_id
);
13669 xfree (tp
->static_trace_marker_id
);
13670 tp
->static_trace_marker_id
= xstrdup (marker
.str_id
);
13671 release_static_tracepoint_marker (&marker
);
13676 /* Old marker wasn't found on target at lineno. Try looking it up
13678 if (!sal
.explicit_pc
13680 && sal
.symtab
!= NULL
13681 && tp
->static_trace_marker_id
!= NULL
)
13683 VEC(static_tracepoint_marker_p
) *markers
;
13686 = target_static_tracepoint_markers_by_strid (tp
->static_trace_marker_id
);
13688 if (!VEC_empty(static_tracepoint_marker_p
, markers
))
13690 struct symbol
*sym
;
13691 struct static_tracepoint_marker
*tpmarker
;
13692 struct ui_out
*uiout
= current_uiout
;
13693 struct explicit_location explicit_loc
;
13695 tpmarker
= VEC_index (static_tracepoint_marker_p
, markers
, 0);
13697 xfree (tp
->static_trace_marker_id
);
13698 tp
->static_trace_marker_id
= xstrdup (tpmarker
->str_id
);
13700 warning (_("marker for static tracepoint %d (%s) not "
13701 "found at previous line number"),
13702 b
->number
, tp
->static_trace_marker_id
);
13704 symtab_and_line sal2
= find_pc_line (tpmarker
->address
, 0);
13705 sym
= find_pc_sect_function (tpmarker
->address
, NULL
);
13706 uiout
->text ("Now in ");
13709 uiout
->field_string ("func", SYMBOL_PRINT_NAME (sym
));
13710 uiout
->text (" at ");
13712 uiout
->field_string ("file",
13713 symtab_to_filename_for_display (sal2
.symtab
));
13716 if (uiout
->is_mi_like_p ())
13718 const char *fullname
= symtab_to_fullname (sal2
.symtab
);
13720 uiout
->field_string ("fullname", fullname
);
13723 uiout
->field_int ("line", sal2
.line
);
13724 uiout
->text ("\n");
13726 b
->loc
->line_number
= sal2
.line
;
13727 b
->loc
->symtab
= sym
!= NULL
? sal2
.symtab
: NULL
;
13729 b
->location
.reset (NULL
);
13730 initialize_explicit_location (&explicit_loc
);
13731 explicit_loc
.source_filename
13732 = ASTRDUP (symtab_to_filename_for_display (sal2
.symtab
));
13733 explicit_loc
.line_offset
.offset
= b
->loc
->line_number
;
13734 explicit_loc
.line_offset
.sign
= LINE_OFFSET_NONE
;
13735 b
->location
= new_explicit_location (&explicit_loc
);
13737 /* Might be nice to check if function changed, and warn if
13740 release_static_tracepoint_marker (tpmarker
);
13746 /* Returns 1 iff locations A and B are sufficiently same that
13747 we don't need to report breakpoint as changed. */
13750 locations_are_equal (struct bp_location
*a
, struct bp_location
*b
)
13754 if (a
->address
!= b
->address
)
13757 if (a
->shlib_disabled
!= b
->shlib_disabled
)
13760 if (a
->enabled
!= b
->enabled
)
13767 if ((a
== NULL
) != (b
== NULL
))
13773 /* Split all locations of B that are bound to PSPACE out of B's
13774 location list to a separate list and return that list's head. If
13775 PSPACE is NULL, hoist out all locations of B. */
13777 static struct bp_location
*
13778 hoist_existing_locations (struct breakpoint
*b
, struct program_space
*pspace
)
13780 struct bp_location head
;
13781 struct bp_location
*i
= b
->loc
;
13782 struct bp_location
**i_link
= &b
->loc
;
13783 struct bp_location
*hoisted
= &head
;
13785 if (pspace
== NULL
)
13796 if (i
->pspace
== pspace
)
13811 /* Create new breakpoint locations for B (a hardware or software
13812 breakpoint) based on SALS and SALS_END. If SALS_END.NELTS is not
13813 zero, then B is a ranged breakpoint. Only recreates locations for
13814 FILTER_PSPACE. Locations of other program spaces are left
13818 update_breakpoint_locations (struct breakpoint
*b
,
13819 struct program_space
*filter_pspace
,
13820 gdb::array_view
<const symtab_and_line
> sals
,
13821 gdb::array_view
<const symtab_and_line
> sals_end
)
13824 struct bp_location
*existing_locations
;
13826 if (!sals_end
.empty () && (sals
.size () != 1 || sals_end
.size () != 1))
13828 /* Ranged breakpoints have only one start location and one end
13830 b
->enable_state
= bp_disabled
;
13831 printf_unfiltered (_("Could not reset ranged breakpoint %d: "
13832 "multiple locations found\n"),
13837 /* If there's no new locations, and all existing locations are
13838 pending, don't do anything. This optimizes the common case where
13839 all locations are in the same shared library, that was unloaded.
13840 We'd like to retain the location, so that when the library is
13841 loaded again, we don't loose the enabled/disabled status of the
13842 individual locations. */
13843 if (all_locations_are_pending (b
, filter_pspace
) && sals
.empty ())
13846 existing_locations
= hoist_existing_locations (b
, filter_pspace
);
13848 for (const auto &sal
: sals
)
13850 struct bp_location
*new_loc
;
13852 switch_to_program_space_and_thread (sal
.pspace
);
13854 new_loc
= add_location_to_breakpoint (b
, &sal
);
13856 /* Reparse conditions, they might contain references to the
13858 if (b
->cond_string
!= NULL
)
13862 s
= b
->cond_string
;
13865 new_loc
->cond
= parse_exp_1 (&s
, sal
.pc
,
13866 block_for_pc (sal
.pc
),
13869 CATCH (e
, RETURN_MASK_ERROR
)
13871 warning (_("failed to reevaluate condition "
13872 "for breakpoint %d: %s"),
13873 b
->number
, e
.message
);
13874 new_loc
->enabled
= 0;
13879 if (!sals_end
.empty ())
13881 CORE_ADDR end
= find_breakpoint_range_end (sals_end
[0]);
13883 new_loc
->length
= end
- sals
[0].pc
+ 1;
13887 /* If possible, carry over 'disable' status from existing
13890 struct bp_location
*e
= existing_locations
;
13891 /* If there are multiple breakpoints with the same function name,
13892 e.g. for inline functions, comparing function names won't work.
13893 Instead compare pc addresses; this is just a heuristic as things
13894 may have moved, but in practice it gives the correct answer
13895 often enough until a better solution is found. */
13896 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
13898 for (; e
; e
= e
->next
)
13900 if (!e
->enabled
&& e
->function_name
)
13902 struct bp_location
*l
= b
->loc
;
13903 if (have_ambiguous_names
)
13905 for (; l
; l
= l
->next
)
13906 if (breakpoint_locations_match (e
, l
))
13914 for (; l
; l
= l
->next
)
13915 if (l
->function_name
13916 && strcmp (e
->function_name
, l
->function_name
) == 0)
13926 if (!locations_are_equal (existing_locations
, b
->loc
))
13927 observer_notify_breakpoint_modified (b
);
13930 /* Find the SaL locations corresponding to the given LOCATION.
13931 On return, FOUND will be 1 if any SaL was found, zero otherwise. */
13933 static std::vector
<symtab_and_line
>
13934 location_to_sals (struct breakpoint
*b
, struct event_location
*location
,
13935 struct program_space
*search_pspace
, int *found
)
13937 struct gdb_exception exception
= exception_none
;
13939 gdb_assert (b
->ops
!= NULL
);
13941 std::vector
<symtab_and_line
> sals
;
13945 sals
= b
->ops
->decode_location (b
, location
, search_pspace
);
13947 CATCH (e
, RETURN_MASK_ERROR
)
13949 int not_found_and_ok
= 0;
13953 /* For pending breakpoints, it's expected that parsing will
13954 fail until the right shared library is loaded. User has
13955 already told to create pending breakpoints and don't need
13956 extra messages. If breakpoint is in bp_shlib_disabled
13957 state, then user already saw the message about that
13958 breakpoint being disabled, and don't want to see more
13960 if (e
.error
== NOT_FOUND_ERROR
13961 && (b
->condition_not_parsed
13963 && search_pspace
!= NULL
13964 && b
->loc
->pspace
!= search_pspace
)
13965 || (b
->loc
&& b
->loc
->shlib_disabled
)
13966 || (b
->loc
&& b
->loc
->pspace
->executing_startup
)
13967 || b
->enable_state
== bp_disabled
))
13968 not_found_and_ok
= 1;
13970 if (!not_found_and_ok
)
13972 /* We surely don't want to warn about the same breakpoint
13973 10 times. One solution, implemented here, is disable
13974 the breakpoint on error. Another solution would be to
13975 have separate 'warning emitted' flag. Since this
13976 happens only when a binary has changed, I don't know
13977 which approach is better. */
13978 b
->enable_state
= bp_disabled
;
13979 throw_exception (e
);
13984 if (exception
.reason
== 0 || exception
.error
!= NOT_FOUND_ERROR
)
13986 for (auto &sal
: sals
)
13987 resolve_sal_pc (&sal
);
13988 if (b
->condition_not_parsed
&& b
->extra_string
!= NULL
)
13990 char *cond_string
, *extra_string
;
13993 find_condition_and_thread (b
->extra_string
, sals
[0].pc
,
13994 &cond_string
, &thread
, &task
,
13996 gdb_assert (b
->cond_string
== NULL
);
13998 b
->cond_string
= cond_string
;
13999 b
->thread
= thread
;
14003 xfree (b
->extra_string
);
14004 b
->extra_string
= extra_string
;
14006 b
->condition_not_parsed
= 0;
14009 if (b
->type
== bp_static_tracepoint
&& !strace_marker_p (b
))
14010 sals
[0] = update_static_tracepoint (b
, sals
[0]);
14020 /* The default re_set method, for typical hardware or software
14021 breakpoints. Reevaluate the breakpoint and recreate its
14025 breakpoint_re_set_default (struct breakpoint
*b
)
14027 struct program_space
*filter_pspace
= current_program_space
;
14028 std::vector
<symtab_and_line
> expanded
, expanded_end
;
14031 std::vector
<symtab_and_line
> sals
= location_to_sals (b
, b
->location
.get (),
14032 filter_pspace
, &found
);
14034 expanded
= std::move (sals
);
14036 if (b
->location_range_end
!= NULL
)
14038 std::vector
<symtab_and_line
> sals_end
14039 = location_to_sals (b
, b
->location_range_end
.get (),
14040 filter_pspace
, &found
);
14042 expanded_end
= std::move (sals_end
);
14045 update_breakpoint_locations (b
, filter_pspace
, expanded
, expanded_end
);
14048 /* Default method for creating SALs from an address string. It basically
14049 calls parse_breakpoint_sals. Return 1 for success, zero for failure. */
14052 create_sals_from_location_default (const struct event_location
*location
,
14053 struct linespec_result
*canonical
,
14054 enum bptype type_wanted
)
14056 parse_breakpoint_sals (location
, canonical
);
14059 /* Call create_breakpoints_sal for the given arguments. This is the default
14060 function for the `create_breakpoints_sal' method of
14064 create_breakpoints_sal_default (struct gdbarch
*gdbarch
,
14065 struct linespec_result
*canonical
,
14066 gdb::unique_xmalloc_ptr
<char> cond_string
,
14067 gdb::unique_xmalloc_ptr
<char> extra_string
,
14068 enum bptype type_wanted
,
14069 enum bpdisp disposition
,
14071 int task
, int ignore_count
,
14072 const struct breakpoint_ops
*ops
,
14073 int from_tty
, int enabled
,
14074 int internal
, unsigned flags
)
14076 create_breakpoints_sal (gdbarch
, canonical
,
14077 std::move (cond_string
),
14078 std::move (extra_string
),
14079 type_wanted
, disposition
,
14080 thread
, task
, ignore_count
, ops
, from_tty
,
14081 enabled
, internal
, flags
);
14084 /* Decode the line represented by S by calling decode_line_full. This is the
14085 default function for the `decode_location' method of breakpoint_ops. */
14087 static std::vector
<symtab_and_line
>
14088 decode_location_default (struct breakpoint
*b
,
14089 const struct event_location
*location
,
14090 struct program_space
*search_pspace
)
14092 struct linespec_result canonical
;
14094 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, search_pspace
,
14095 (struct symtab
*) NULL
, 0,
14096 &canonical
, multiple_symbols_all
,
14099 /* We should get 0 or 1 resulting SALs. */
14100 gdb_assert (canonical
.lsals
.size () < 2);
14102 if (!canonical
.lsals
.empty ())
14104 const linespec_sals
&lsal
= canonical
.lsals
[0];
14105 return std::move (lsal
.sals
);
14110 /* Prepare the global context for a re-set of breakpoint B. */
14112 static struct cleanup
*
14113 prepare_re_set_context (struct breakpoint
*b
)
14115 input_radix
= b
->input_radix
;
14116 set_language (b
->language
);
14118 return make_cleanup (null_cleanup
, NULL
);
14121 /* Reset a breakpoint. */
14124 breakpoint_re_set_one (breakpoint
*b
)
14126 struct cleanup
*cleanups
;
14128 cleanups
= prepare_re_set_context (b
);
14129 b
->ops
->re_set (b
);
14130 do_cleanups (cleanups
);
14133 /* Re-set breakpoint locations for the current program space.
14134 Locations bound to other program spaces are left untouched. */
14137 breakpoint_re_set (void)
14139 struct breakpoint
*b
, *b_tmp
;
14140 enum language save_language
;
14141 int save_input_radix
;
14143 save_language
= current_language
->la_language
;
14144 save_input_radix
= input_radix
;
14147 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
14149 /* Note: we must not try to insert locations until after all
14150 breakpoints have been re-set. Otherwise, e.g., when re-setting
14151 breakpoint 1, we'd insert the locations of breakpoint 2, which
14152 hadn't been re-set yet, and thus may have stale locations. */
14154 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
14158 breakpoint_re_set_one (b
);
14160 CATCH (ex
, RETURN_MASK_ALL
)
14162 exception_fprintf (gdb_stderr
, ex
,
14163 "Error in re-setting breakpoint %d: ",
14168 set_language (save_language
);
14169 input_radix
= save_input_radix
;
14171 jit_breakpoint_re_set ();
14174 create_overlay_event_breakpoint ();
14175 create_longjmp_master_breakpoint ();
14176 create_std_terminate_master_breakpoint ();
14177 create_exception_master_breakpoint ();
14179 /* Now we can insert. */
14180 update_global_location_list (UGLL_MAY_INSERT
);
14183 /* Reset the thread number of this breakpoint:
14185 - If the breakpoint is for all threads, leave it as-is.
14186 - Else, reset it to the current thread for inferior_ptid. */
14188 breakpoint_re_set_thread (struct breakpoint
*b
)
14190 if (b
->thread
!= -1)
14192 if (in_thread_list (inferior_ptid
))
14193 b
->thread
= ptid_to_global_thread_id (inferior_ptid
);
14195 /* We're being called after following a fork. The new fork is
14196 selected as current, and unless this was a vfork will have a
14197 different program space from the original thread. Reset that
14199 b
->loc
->pspace
= current_program_space
;
14203 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14204 If from_tty is nonzero, it prints a message to that effect,
14205 which ends with a period (no newline). */
14208 set_ignore_count (int bptnum
, int count
, int from_tty
)
14210 struct breakpoint
*b
;
14215 ALL_BREAKPOINTS (b
)
14216 if (b
->number
== bptnum
)
14218 if (is_tracepoint (b
))
14220 if (from_tty
&& count
!= 0)
14221 printf_filtered (_("Ignore count ignored for tracepoint %d."),
14226 b
->ignore_count
= count
;
14230 printf_filtered (_("Will stop next time "
14231 "breakpoint %d is reached."),
14233 else if (count
== 1)
14234 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
14237 printf_filtered (_("Will ignore next %d "
14238 "crossings of breakpoint %d."),
14241 observer_notify_breakpoint_modified (b
);
14245 error (_("No breakpoint number %d."), bptnum
);
14248 /* Command to set ignore-count of breakpoint N to COUNT. */
14251 ignore_command (char *args
, int from_tty
)
14257 error_no_arg (_("a breakpoint number"));
14259 num
= get_number (&p
);
14261 error (_("bad breakpoint number: '%s'"), args
);
14263 error (_("Second argument (specified ignore-count) is missing."));
14265 set_ignore_count (num
,
14266 longest_to_int (value_as_long (parse_and_eval (p
))),
14269 printf_filtered ("\n");
14272 /* Call FUNCTION on each of the breakpoints
14273 whose numbers are given in ARGS. */
14276 map_breakpoint_numbers (const char *args
,
14277 gdb::function_view
<void (breakpoint
*)> function
)
14280 struct breakpoint
*b
, *tmp
;
14282 if (args
== 0 || *args
== '\0')
14283 error_no_arg (_("one or more breakpoint numbers"));
14285 number_or_range_parser
parser (args
);
14287 while (!parser
.finished ())
14289 const char *p
= parser
.cur_tok ();
14290 bool match
= false;
14292 num
= parser
.get_number ();
14295 warning (_("bad breakpoint number at or near '%s'"), p
);
14299 ALL_BREAKPOINTS_SAFE (b
, tmp
)
14300 if (b
->number
== num
)
14307 printf_unfiltered (_("No breakpoint number %d.\n"), num
);
14312 static struct bp_location
*
14313 find_location_by_number (const char *number
)
14318 struct breakpoint
*b
;
14319 struct bp_location
*loc
;
14322 bp_num
= get_number_trailer (&p1
, '.');
14323 if (bp_num
== 0 || p1
[0] != '.')
14324 error (_("Bad breakpoint number '%s'"), number
);
14326 ALL_BREAKPOINTS (b
)
14327 if (b
->number
== bp_num
)
14332 if (!b
|| b
->number
!= bp_num
)
14333 error (_("Bad breakpoint number '%s'"), number
);
14335 /* Skip the dot. */
14337 const char *save
= p1
;
14338 loc_num
= get_number (&p1
);
14340 error (_("Bad breakpoint location number '%s'"), number
);
14344 for (;loc_num
&& loc
; --loc_num
, loc
= loc
->next
)
14347 error (_("Bad breakpoint location number '%s'"), save
);
14353 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14354 If from_tty is nonzero, it prints a message to that effect,
14355 which ends with a period (no newline). */
14358 disable_breakpoint (struct breakpoint
*bpt
)
14360 /* Never disable a watchpoint scope breakpoint; we want to
14361 hit them when we leave scope so we can delete both the
14362 watchpoint and its scope breakpoint at that time. */
14363 if (bpt
->type
== bp_watchpoint_scope
)
14366 bpt
->enable_state
= bp_disabled
;
14368 /* Mark breakpoint locations modified. */
14369 mark_breakpoint_modified (bpt
);
14371 if (target_supports_enable_disable_tracepoint ()
14372 && current_trace_status ()->running
&& is_tracepoint (bpt
))
14374 struct bp_location
*location
;
14376 for (location
= bpt
->loc
; location
; location
= location
->next
)
14377 target_disable_tracepoint (location
);
14380 update_global_location_list (UGLL_DONT_INSERT
);
14382 observer_notify_breakpoint_modified (bpt
);
14386 disable_command (char *args
, int from_tty
)
14390 struct breakpoint
*bpt
;
14392 ALL_BREAKPOINTS (bpt
)
14393 if (user_breakpoint_p (bpt
))
14394 disable_breakpoint (bpt
);
14398 std::string num
= extract_arg (&args
);
14400 while (!num
.empty ())
14402 if (num
.find ('.') != std::string::npos
)
14404 struct bp_location
*loc
= find_location_by_number (num
.c_str ());
14411 mark_breakpoint_location_modified (loc
);
14413 if (target_supports_enable_disable_tracepoint ()
14414 && current_trace_status ()->running
&& loc
->owner
14415 && is_tracepoint (loc
->owner
))
14416 target_disable_tracepoint (loc
);
14418 update_global_location_list (UGLL_DONT_INSERT
);
14421 map_breakpoint_numbers
14422 (num
.c_str (), [&] (breakpoint
*b
)
14424 iterate_over_related_breakpoints (b
, disable_breakpoint
);
14426 num
= extract_arg (&args
);
14432 enable_breakpoint_disp (struct breakpoint
*bpt
, enum bpdisp disposition
,
14435 int target_resources_ok
;
14437 if (bpt
->type
== bp_hardware_breakpoint
)
14440 i
= hw_breakpoint_used_count ();
14441 target_resources_ok
=
14442 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
14444 if (target_resources_ok
== 0)
14445 error (_("No hardware breakpoint support in the target."));
14446 else if (target_resources_ok
< 0)
14447 error (_("Hardware breakpoints used exceeds limit."));
14450 if (is_watchpoint (bpt
))
14452 /* Initialize it just to avoid a GCC false warning. */
14453 enum enable_state orig_enable_state
= bp_disabled
;
14457 struct watchpoint
*w
= (struct watchpoint
*) bpt
;
14459 orig_enable_state
= bpt
->enable_state
;
14460 bpt
->enable_state
= bp_enabled
;
14461 update_watchpoint (w
, 1 /* reparse */);
14463 CATCH (e
, RETURN_MASK_ALL
)
14465 bpt
->enable_state
= orig_enable_state
;
14466 exception_fprintf (gdb_stderr
, e
, _("Cannot enable watchpoint %d: "),
14473 bpt
->enable_state
= bp_enabled
;
14475 /* Mark breakpoint locations modified. */
14476 mark_breakpoint_modified (bpt
);
14478 if (target_supports_enable_disable_tracepoint ()
14479 && current_trace_status ()->running
&& is_tracepoint (bpt
))
14481 struct bp_location
*location
;
14483 for (location
= bpt
->loc
; location
; location
= location
->next
)
14484 target_enable_tracepoint (location
);
14487 bpt
->disposition
= disposition
;
14488 bpt
->enable_count
= count
;
14489 update_global_location_list (UGLL_MAY_INSERT
);
14491 observer_notify_breakpoint_modified (bpt
);
14496 enable_breakpoint (struct breakpoint
*bpt
)
14498 enable_breakpoint_disp (bpt
, bpt
->disposition
, 0);
14501 /* The enable command enables the specified breakpoints (or all defined
14502 breakpoints) so they once again become (or continue to be) effective
14503 in stopping the inferior. */
14506 enable_command (char *args
, int from_tty
)
14510 struct breakpoint
*bpt
;
14512 ALL_BREAKPOINTS (bpt
)
14513 if (user_breakpoint_p (bpt
))
14514 enable_breakpoint (bpt
);
14518 std::string num
= extract_arg (&args
);
14520 while (!num
.empty ())
14522 if (num
.find ('.') != std::string::npos
)
14524 struct bp_location
*loc
= find_location_by_number (num
.c_str ());
14531 mark_breakpoint_location_modified (loc
);
14533 if (target_supports_enable_disable_tracepoint ()
14534 && current_trace_status ()->running
&& loc
->owner
14535 && is_tracepoint (loc
->owner
))
14536 target_enable_tracepoint (loc
);
14538 update_global_location_list (UGLL_MAY_INSERT
);
14541 map_breakpoint_numbers
14542 (num
.c_str (), [&] (breakpoint
*b
)
14544 iterate_over_related_breakpoints (b
, enable_breakpoint
);
14546 num
= extract_arg (&args
);
14552 enable_once_command (const char *args
, int from_tty
)
14554 map_breakpoint_numbers
14555 (args
, [&] (breakpoint
*b
)
14557 iterate_over_related_breakpoints
14558 (b
, [&] (breakpoint
*bpt
)
14560 enable_breakpoint_disp (bpt
, disp_disable
, 1);
14566 enable_count_command (const char *args
, int from_tty
)
14571 error_no_arg (_("hit count"));
14573 count
= get_number (&args
);
14575 map_breakpoint_numbers
14576 (args
, [&] (breakpoint
*b
)
14578 iterate_over_related_breakpoints
14579 (b
, [&] (breakpoint
*bpt
)
14581 enable_breakpoint_disp (bpt
, disp_disable
, count
);
14587 enable_delete_command (const char *args
, int from_tty
)
14589 map_breakpoint_numbers
14590 (args
, [&] (breakpoint
*b
)
14592 iterate_over_related_breakpoints
14593 (b
, [&] (breakpoint
*bpt
)
14595 enable_breakpoint_disp (bpt
, disp_del
, 1);
14601 set_breakpoint_cmd (char *args
, int from_tty
)
14606 show_breakpoint_cmd (char *args
, int from_tty
)
14610 /* Invalidate last known value of any hardware watchpoint if
14611 the memory which that value represents has been written to by
14615 invalidate_bp_value_on_memory_change (struct inferior
*inferior
,
14616 CORE_ADDR addr
, ssize_t len
,
14617 const bfd_byte
*data
)
14619 struct breakpoint
*bp
;
14621 ALL_BREAKPOINTS (bp
)
14622 if (bp
->enable_state
== bp_enabled
14623 && bp
->type
== bp_hardware_watchpoint
)
14625 struct watchpoint
*wp
= (struct watchpoint
*) bp
;
14627 if (wp
->val_valid
&& wp
->val
)
14629 struct bp_location
*loc
;
14631 for (loc
= bp
->loc
; loc
!= NULL
; loc
= loc
->next
)
14632 if (loc
->loc_type
== bp_loc_hardware_watchpoint
14633 && loc
->address
+ loc
->length
> addr
14634 && addr
+ len
> loc
->address
)
14636 value_free (wp
->val
);
14644 /* Create and insert a breakpoint for software single step. */
14647 insert_single_step_breakpoint (struct gdbarch
*gdbarch
,
14648 struct address_space
*aspace
,
14651 struct thread_info
*tp
= inferior_thread ();
14652 struct symtab_and_line sal
;
14653 CORE_ADDR pc
= next_pc
;
14655 if (tp
->control
.single_step_breakpoints
== NULL
)
14657 tp
->control
.single_step_breakpoints
14658 = new_single_step_breakpoint (tp
->global_num
, gdbarch
);
14661 sal
= find_pc_line (pc
, 0);
14663 sal
.section
= find_pc_overlay (pc
);
14664 sal
.explicit_pc
= 1;
14665 add_location_to_breakpoint (tp
->control
.single_step_breakpoints
, &sal
);
14667 update_global_location_list (UGLL_INSERT
);
14670 /* Insert single step breakpoints according to the current state. */
14673 insert_single_step_breakpoints (struct gdbarch
*gdbarch
)
14675 struct regcache
*regcache
= get_current_regcache ();
14676 std::vector
<CORE_ADDR
> next_pcs
;
14678 next_pcs
= gdbarch_software_single_step (gdbarch
, regcache
);
14680 if (!next_pcs
.empty ())
14682 struct frame_info
*frame
= get_current_frame ();
14683 struct address_space
*aspace
= get_frame_address_space (frame
);
14685 for (CORE_ADDR pc
: next_pcs
)
14686 insert_single_step_breakpoint (gdbarch
, aspace
, pc
);
14694 /* See breakpoint.h. */
14697 breakpoint_has_location_inserted_here (struct breakpoint
*bp
,
14698 struct address_space
*aspace
,
14701 struct bp_location
*loc
;
14703 for (loc
= bp
->loc
; loc
!= NULL
; loc
= loc
->next
)
14705 && breakpoint_location_address_match (loc
, aspace
, pc
))
14711 /* Check whether a software single-step breakpoint is inserted at
14715 single_step_breakpoint_inserted_here_p (struct address_space
*aspace
,
14718 struct breakpoint
*bpt
;
14720 ALL_BREAKPOINTS (bpt
)
14722 if (bpt
->type
== bp_single_step
14723 && breakpoint_has_location_inserted_here (bpt
, aspace
, pc
))
14729 /* Tracepoint-specific operations. */
14731 /* Set tracepoint count to NUM. */
14733 set_tracepoint_count (int num
)
14735 tracepoint_count
= num
;
14736 set_internalvar_integer (lookup_internalvar ("tpnum"), num
);
14740 trace_command (char *arg_in
, int from_tty
)
14742 const char *arg
= arg_in
;
14743 struct breakpoint_ops
*ops
;
14745 event_location_up location
= string_to_event_location (&arg
,
14747 if (location
!= NULL
14748 && event_location_type (location
.get ()) == PROBE_LOCATION
)
14749 ops
= &tracepoint_probe_breakpoint_ops
;
14751 ops
= &tracepoint_breakpoint_ops
;
14753 create_breakpoint (get_current_arch (),
14755 NULL
, 0, arg
, 1 /* parse arg */,
14757 bp_tracepoint
/* type_wanted */,
14758 0 /* Ignore count */,
14759 pending_break_support
,
14763 0 /* internal */, 0);
14767 ftrace_command (char *arg_in
, int from_tty
)
14769 const char *arg
= arg_in
;
14770 event_location_up location
= string_to_event_location (&arg
,
14772 create_breakpoint (get_current_arch (),
14774 NULL
, 0, arg
, 1 /* parse arg */,
14776 bp_fast_tracepoint
/* type_wanted */,
14777 0 /* Ignore count */,
14778 pending_break_support
,
14779 &tracepoint_breakpoint_ops
,
14782 0 /* internal */, 0);
14785 /* strace command implementation. Creates a static tracepoint. */
14788 strace_command (char *arg_in
, int from_tty
)
14790 const char *arg
= arg_in
;
14791 struct breakpoint_ops
*ops
;
14792 event_location_up location
;
14793 struct cleanup
*back_to
;
14795 /* Decide if we are dealing with a static tracepoint marker (`-m'),
14796 or with a normal static tracepoint. */
14797 if (arg
&& startswith (arg
, "-m") && isspace (arg
[2]))
14799 ops
= &strace_marker_breakpoint_ops
;
14800 location
= new_linespec_location (&arg
);
14804 ops
= &tracepoint_breakpoint_ops
;
14805 location
= string_to_event_location (&arg
, current_language
);
14808 create_breakpoint (get_current_arch (),
14810 NULL
, 0, arg
, 1 /* parse arg */,
14812 bp_static_tracepoint
/* type_wanted */,
14813 0 /* Ignore count */,
14814 pending_break_support
,
14818 0 /* internal */, 0);
14821 /* Set up a fake reader function that gets command lines from a linked
14822 list that was acquired during tracepoint uploading. */
14824 static struct uploaded_tp
*this_utp
;
14825 static int next_cmd
;
14828 read_uploaded_action (void)
14832 VEC_iterate (char_ptr
, this_utp
->cmd_strings
, next_cmd
, rslt
);
14839 /* Given information about a tracepoint as recorded on a target (which
14840 can be either a live system or a trace file), attempt to create an
14841 equivalent GDB tracepoint. This is not a reliable process, since
14842 the target does not necessarily have all the information used when
14843 the tracepoint was originally defined. */
14845 struct tracepoint
*
14846 create_tracepoint_from_upload (struct uploaded_tp
*utp
)
14848 const char *addr_str
;
14849 char small_buf
[100];
14850 struct tracepoint
*tp
;
14852 if (utp
->at_string
)
14853 addr_str
= utp
->at_string
;
14856 /* In the absence of a source location, fall back to raw
14857 address. Since there is no way to confirm that the address
14858 means the same thing as when the trace was started, warn the
14860 warning (_("Uploaded tracepoint %d has no "
14861 "source location, using raw address"),
14863 xsnprintf (small_buf
, sizeof (small_buf
), "*%s", hex_string (utp
->addr
));
14864 addr_str
= small_buf
;
14867 /* There's not much we can do with a sequence of bytecodes. */
14868 if (utp
->cond
&& !utp
->cond_string
)
14869 warning (_("Uploaded tracepoint %d condition "
14870 "has no source form, ignoring it"),
14873 event_location_up location
= string_to_event_location (&addr_str
,
14875 if (!create_breakpoint (get_current_arch (),
14877 utp
->cond_string
, -1, addr_str
,
14878 0 /* parse cond/thread */,
14880 utp
->type
/* type_wanted */,
14881 0 /* Ignore count */,
14882 pending_break_support
,
14883 &tracepoint_breakpoint_ops
,
14885 utp
->enabled
/* enabled */,
14887 CREATE_BREAKPOINT_FLAGS_INSERTED
))
14890 /* Get the tracepoint we just created. */
14891 tp
= get_tracepoint (tracepoint_count
);
14892 gdb_assert (tp
!= NULL
);
14896 xsnprintf (small_buf
, sizeof (small_buf
), "%d %d", utp
->pass
,
14899 trace_pass_command (small_buf
, 0);
14902 /* If we have uploaded versions of the original commands, set up a
14903 special-purpose "reader" function and call the usual command line
14904 reader, then pass the result to the breakpoint command-setting
14906 if (!VEC_empty (char_ptr
, utp
->cmd_strings
))
14908 command_line_up cmd_list
;
14913 cmd_list
= read_command_lines_1 (read_uploaded_action
, 1, NULL
, NULL
);
14915 breakpoint_set_commands (tp
, std::move (cmd_list
));
14917 else if (!VEC_empty (char_ptr
, utp
->actions
)
14918 || !VEC_empty (char_ptr
, utp
->step_actions
))
14919 warning (_("Uploaded tracepoint %d actions "
14920 "have no source form, ignoring them"),
14923 /* Copy any status information that might be available. */
14924 tp
->hit_count
= utp
->hit_count
;
14925 tp
->traceframe_usage
= utp
->traceframe_usage
;
14930 /* Print information on tracepoint number TPNUM_EXP, or all if
14934 info_tracepoints_command (char *args
, int from_tty
)
14936 struct ui_out
*uiout
= current_uiout
;
14939 num_printed
= breakpoint_1 (args
, 0, is_tracepoint
);
14941 if (num_printed
== 0)
14943 if (args
== NULL
|| *args
== '\0')
14944 uiout
->message ("No tracepoints.\n");
14946 uiout
->message ("No tracepoint matching '%s'.\n", args
);
14949 default_collect_info ();
14952 /* The 'enable trace' command enables tracepoints.
14953 Not supported by all targets. */
14955 enable_trace_command (char *args
, int from_tty
)
14957 enable_command (args
, from_tty
);
14960 /* The 'disable trace' command disables tracepoints.
14961 Not supported by all targets. */
14963 disable_trace_command (char *args
, int from_tty
)
14965 disable_command (args
, from_tty
);
14968 /* Remove a tracepoint (or all if no argument). */
14970 delete_trace_command (const char *arg
, int from_tty
)
14972 struct breakpoint
*b
, *b_tmp
;
14978 int breaks_to_delete
= 0;
14980 /* Delete all breakpoints if no argument.
14981 Do not delete internal or call-dummy breakpoints, these
14982 have to be deleted with an explicit breakpoint number
14984 ALL_TRACEPOINTS (b
)
14985 if (is_tracepoint (b
) && user_breakpoint_p (b
))
14987 breaks_to_delete
= 1;
14991 /* Ask user only if there are some breakpoints to delete. */
14993 || (breaks_to_delete
&& query (_("Delete all tracepoints? "))))
14995 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
14996 if (is_tracepoint (b
) && user_breakpoint_p (b
))
14997 delete_breakpoint (b
);
15001 map_breakpoint_numbers
15002 (arg
, [&] (breakpoint
*b
)
15004 iterate_over_related_breakpoints (b
, delete_breakpoint
);
15008 /* Helper function for trace_pass_command. */
15011 trace_pass_set_count (struct tracepoint
*tp
, int count
, int from_tty
)
15013 tp
->pass_count
= count
;
15014 observer_notify_breakpoint_modified (tp
);
15016 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
15017 tp
->number
, count
);
15020 /* Set passcount for tracepoint.
15022 First command argument is passcount, second is tracepoint number.
15023 If tracepoint number omitted, apply to most recently defined.
15024 Also accepts special argument "all". */
15027 trace_pass_command (char *args
, int from_tty
)
15029 struct tracepoint
*t1
;
15030 unsigned int count
;
15032 if (args
== 0 || *args
== 0)
15033 error (_("passcount command requires an "
15034 "argument (count + optional TP num)"));
15036 count
= strtoul (args
, &args
, 10); /* Count comes first, then TP num. */
15038 args
= skip_spaces (args
);
15039 if (*args
&& strncasecmp (args
, "all", 3) == 0)
15041 struct breakpoint
*b
;
15043 args
+= 3; /* Skip special argument "all". */
15045 error (_("Junk at end of arguments."));
15047 ALL_TRACEPOINTS (b
)
15049 t1
= (struct tracepoint
*) b
;
15050 trace_pass_set_count (t1
, count
, from_tty
);
15053 else if (*args
== '\0')
15055 t1
= get_tracepoint_by_number (&args
, NULL
);
15057 trace_pass_set_count (t1
, count
, from_tty
);
15061 number_or_range_parser
parser (args
);
15062 while (!parser
.finished ())
15064 t1
= get_tracepoint_by_number (&args
, &parser
);
15066 trace_pass_set_count (t1
, count
, from_tty
);
15071 struct tracepoint
*
15072 get_tracepoint (int num
)
15074 struct breakpoint
*t
;
15076 ALL_TRACEPOINTS (t
)
15077 if (t
->number
== num
)
15078 return (struct tracepoint
*) t
;
15083 /* Find the tracepoint with the given target-side number (which may be
15084 different from the tracepoint number after disconnecting and
15087 struct tracepoint
*
15088 get_tracepoint_by_number_on_target (int num
)
15090 struct breakpoint
*b
;
15092 ALL_TRACEPOINTS (b
)
15094 struct tracepoint
*t
= (struct tracepoint
*) b
;
15096 if (t
->number_on_target
== num
)
15103 /* Utility: parse a tracepoint number and look it up in the list.
15104 If STATE is not NULL, use, get_number_or_range_state and ignore ARG.
15105 If the argument is missing, the most recent tracepoint
15106 (tracepoint_count) is returned. */
15108 struct tracepoint
*
15109 get_tracepoint_by_number (char **arg
,
15110 number_or_range_parser
*parser
)
15112 struct breakpoint
*t
;
15114 char *instring
= arg
== NULL
? NULL
: *arg
;
15116 if (parser
!= NULL
)
15118 gdb_assert (!parser
->finished ());
15119 tpnum
= parser
->get_number ();
15121 else if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
15122 tpnum
= tracepoint_count
;
15124 tpnum
= get_number (arg
);
15128 if (instring
&& *instring
)
15129 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
15132 printf_filtered (_("No previous tracepoint\n"));
15136 ALL_TRACEPOINTS (t
)
15137 if (t
->number
== tpnum
)
15139 return (struct tracepoint
*) t
;
15142 printf_unfiltered ("No tracepoint number %d.\n", tpnum
);
15147 print_recreate_thread (struct breakpoint
*b
, struct ui_file
*fp
)
15149 if (b
->thread
!= -1)
15150 fprintf_unfiltered (fp
, " thread %d", b
->thread
);
15153 fprintf_unfiltered (fp
, " task %d", b
->task
);
15155 fprintf_unfiltered (fp
, "\n");
15158 /* Save information on user settable breakpoints (watchpoints, etc) to
15159 a new script file named FILENAME. If FILTER is non-NULL, call it
15160 on each breakpoint and only include the ones for which it returns
15164 save_breakpoints (const char *filename
, int from_tty
,
15165 int (*filter
) (const struct breakpoint
*))
15167 struct breakpoint
*tp
;
15169 int extra_trace_bits
= 0;
15171 if (filename
== 0 || *filename
== 0)
15172 error (_("Argument required (file name in which to save)"));
15174 /* See if we have anything to save. */
15175 ALL_BREAKPOINTS (tp
)
15177 /* Skip internal and momentary breakpoints. */
15178 if (!user_breakpoint_p (tp
))
15181 /* If we have a filter, only save the breakpoints it accepts. */
15182 if (filter
&& !filter (tp
))
15187 if (is_tracepoint (tp
))
15189 extra_trace_bits
= 1;
15191 /* We can stop searching. */
15198 warning (_("Nothing to save."));
15202 gdb::unique_xmalloc_ptr
<char> expanded_filename (tilde_expand (filename
));
15206 if (!fp
.open (expanded_filename
.get (), "w"))
15207 error (_("Unable to open file '%s' for saving (%s)"),
15208 expanded_filename
.get (), safe_strerror (errno
));
15210 if (extra_trace_bits
)
15211 save_trace_state_variables (&fp
);
15213 ALL_BREAKPOINTS (tp
)
15215 /* Skip internal and momentary breakpoints. */
15216 if (!user_breakpoint_p (tp
))
15219 /* If we have a filter, only save the breakpoints it accepts. */
15220 if (filter
&& !filter (tp
))
15223 tp
->ops
->print_recreate (tp
, &fp
);
15225 /* Note, we can't rely on tp->number for anything, as we can't
15226 assume the recreated breakpoint numbers will match. Use $bpnum
15229 if (tp
->cond_string
)
15230 fp
.printf (" condition $bpnum %s\n", tp
->cond_string
);
15232 if (tp
->ignore_count
)
15233 fp
.printf (" ignore $bpnum %d\n", tp
->ignore_count
);
15235 if (tp
->type
!= bp_dprintf
&& tp
->commands
)
15237 fp
.puts (" commands\n");
15239 current_uiout
->redirect (&fp
);
15242 print_command_lines (current_uiout
, tp
->commands
.get (), 2);
15244 CATCH (ex
, RETURN_MASK_ALL
)
15246 current_uiout
->redirect (NULL
);
15247 throw_exception (ex
);
15251 current_uiout
->redirect (NULL
);
15252 fp
.puts (" end\n");
15255 if (tp
->enable_state
== bp_disabled
)
15256 fp
.puts ("disable $bpnum\n");
15258 /* If this is a multi-location breakpoint, check if the locations
15259 should be individually disabled. Watchpoint locations are
15260 special, and not user visible. */
15261 if (!is_watchpoint (tp
) && tp
->loc
&& tp
->loc
->next
)
15263 struct bp_location
*loc
;
15266 for (loc
= tp
->loc
; loc
!= NULL
; loc
= loc
->next
, n
++)
15268 fp
.printf ("disable $bpnum.%d\n", n
);
15272 if (extra_trace_bits
&& *default_collect
)
15273 fp
.printf ("set default-collect %s\n", default_collect
);
15276 printf_filtered (_("Saved to file '%s'.\n"), expanded_filename
.get ());
15279 /* The `save breakpoints' command. */
15282 save_breakpoints_command (const char *args
, int from_tty
)
15284 save_breakpoints (args
, from_tty
, NULL
);
15287 /* The `save tracepoints' command. */
15290 save_tracepoints_command (const char *args
, int from_tty
)
15292 save_breakpoints (args
, from_tty
, is_tracepoint
);
15295 /* Create a vector of all tracepoints. */
15297 VEC(breakpoint_p
) *
15298 all_tracepoints (void)
15300 VEC(breakpoint_p
) *tp_vec
= 0;
15301 struct breakpoint
*tp
;
15303 ALL_TRACEPOINTS (tp
)
15305 VEC_safe_push (breakpoint_p
, tp_vec
, tp
);
15312 /* This help string is used to consolidate all the help string for specifying
15313 locations used by several commands. */
15315 #define LOCATION_HELP_STRING \
15316 "Linespecs are colon-separated lists of location parameters, such as\n\
15317 source filename, function name, label name, and line number.\n\
15318 Example: To specify the start of a label named \"the_top\" in the\n\
15319 function \"fact\" in the file \"factorial.c\", use\n\
15320 \"factorial.c:fact:the_top\".\n\
15322 Address locations begin with \"*\" and specify an exact address in the\n\
15323 program. Example: To specify the fourth byte past the start function\n\
15324 \"main\", use \"*main + 4\".\n\
15326 Explicit locations are similar to linespecs but use an option/argument\n\
15327 syntax to specify location parameters.\n\
15328 Example: To specify the start of the label named \"the_top\" in the\n\
15329 function \"fact\" in the file \"factorial.c\", use \"-source factorial.c\n\
15330 -function fact -label the_top\".\n"
15332 /* This help string is used for the break, hbreak, tbreak and thbreak
15333 commands. It is defined as a macro to prevent duplication.
15334 COMMAND should be a string constant containing the name of the
15337 #define BREAK_ARGS_HELP(command) \
15338 command" [PROBE_MODIFIER] [LOCATION] [thread THREADNUM] [if CONDITION]\n\
15339 PROBE_MODIFIER shall be present if the command is to be placed in a\n\
15340 probe point. Accepted values are `-probe' (for a generic, automatically\n\
15341 guessed probe type), `-probe-stap' (for a SystemTap probe) or \n\
15342 `-probe-dtrace' (for a DTrace probe).\n\
15343 LOCATION may be a linespec, address, or explicit location as described\n\
15346 With no LOCATION, uses current execution address of the selected\n\
15347 stack frame. This is useful for breaking on return to a stack frame.\n\
15349 THREADNUM is the number from \"info threads\".\n\
15350 CONDITION is a boolean expression.\n\
15351 \n" LOCATION_HELP_STRING "\n\
15352 Multiple breakpoints at one place are permitted, and useful if their\n\
15353 conditions are different.\n\
15355 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
15357 /* List of subcommands for "catch". */
15358 static struct cmd_list_element
*catch_cmdlist
;
15360 /* List of subcommands for "tcatch". */
15361 static struct cmd_list_element
*tcatch_cmdlist
;
15364 add_catch_command (const char *name
, const char *docstring
,
15365 cmd_sfunc_ftype
*sfunc
,
15366 completer_ftype
*completer
,
15367 void *user_data_catch
,
15368 void *user_data_tcatch
)
15370 struct cmd_list_element
*command
;
15372 command
= add_cmd (name
, class_breakpoint
, docstring
,
15374 set_cmd_sfunc (command
, sfunc
);
15375 set_cmd_context (command
, user_data_catch
);
15376 set_cmd_completer (command
, completer
);
15378 command
= add_cmd (name
, class_breakpoint
, docstring
,
15380 set_cmd_sfunc (command
, sfunc
);
15381 set_cmd_context (command
, user_data_tcatch
);
15382 set_cmd_completer (command
, completer
);
15386 save_command (char *arg
, int from_tty
)
15388 printf_unfiltered (_("\"save\" must be followed by "
15389 "the name of a save subcommand.\n"));
15390 help_list (save_cmdlist
, "save ", all_commands
, gdb_stdout
);
15393 struct breakpoint
*
15394 iterate_over_breakpoints (int (*callback
) (struct breakpoint
*, void *),
15397 struct breakpoint
*b
, *b_tmp
;
15399 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
15401 if ((*callback
) (b
, data
))
15408 /* Zero if any of the breakpoint's locations could be a location where
15409 functions have been inlined, nonzero otherwise. */
15412 is_non_inline_function (struct breakpoint
*b
)
15414 /* The shared library event breakpoint is set on the address of a
15415 non-inline function. */
15416 if (b
->type
== bp_shlib_event
)
15422 /* Nonzero if the specified PC cannot be a location where functions
15423 have been inlined. */
15426 pc_at_non_inline_function (struct address_space
*aspace
, CORE_ADDR pc
,
15427 const struct target_waitstatus
*ws
)
15429 struct breakpoint
*b
;
15430 struct bp_location
*bl
;
15432 ALL_BREAKPOINTS (b
)
15434 if (!is_non_inline_function (b
))
15437 for (bl
= b
->loc
; bl
!= NULL
; bl
= bl
->next
)
15439 if (!bl
->shlib_disabled
15440 && bpstat_check_location (bl
, aspace
, pc
, ws
))
15448 /* Remove any references to OBJFILE which is going to be freed. */
15451 breakpoint_free_objfile (struct objfile
*objfile
)
15453 struct bp_location
**locp
, *loc
;
15455 ALL_BP_LOCATIONS (loc
, locp
)
15456 if (loc
->symtab
!= NULL
&& SYMTAB_OBJFILE (loc
->symtab
) == objfile
)
15457 loc
->symtab
= NULL
;
15461 initialize_breakpoint_ops (void)
15463 static int initialized
= 0;
15465 struct breakpoint_ops
*ops
;
15471 /* The breakpoint_ops structure to be inherit by all kinds of
15472 breakpoints (real breakpoints, i.e., user "break" breakpoints,
15473 internal and momentary breakpoints, etc.). */
15474 ops
= &bkpt_base_breakpoint_ops
;
15475 *ops
= base_breakpoint_ops
;
15476 ops
->re_set
= bkpt_re_set
;
15477 ops
->insert_location
= bkpt_insert_location
;
15478 ops
->remove_location
= bkpt_remove_location
;
15479 ops
->breakpoint_hit
= bkpt_breakpoint_hit
;
15480 ops
->create_sals_from_location
= bkpt_create_sals_from_location
;
15481 ops
->create_breakpoints_sal
= bkpt_create_breakpoints_sal
;
15482 ops
->decode_location
= bkpt_decode_location
;
15484 /* The breakpoint_ops structure to be used in regular breakpoints. */
15485 ops
= &bkpt_breakpoint_ops
;
15486 *ops
= bkpt_base_breakpoint_ops
;
15487 ops
->re_set
= bkpt_re_set
;
15488 ops
->resources_needed
= bkpt_resources_needed
;
15489 ops
->print_it
= bkpt_print_it
;
15490 ops
->print_mention
= bkpt_print_mention
;
15491 ops
->print_recreate
= bkpt_print_recreate
;
15493 /* Ranged breakpoints. */
15494 ops
= &ranged_breakpoint_ops
;
15495 *ops
= bkpt_breakpoint_ops
;
15496 ops
->breakpoint_hit
= breakpoint_hit_ranged_breakpoint
;
15497 ops
->resources_needed
= resources_needed_ranged_breakpoint
;
15498 ops
->print_it
= print_it_ranged_breakpoint
;
15499 ops
->print_one
= print_one_ranged_breakpoint
;
15500 ops
->print_one_detail
= print_one_detail_ranged_breakpoint
;
15501 ops
->print_mention
= print_mention_ranged_breakpoint
;
15502 ops
->print_recreate
= print_recreate_ranged_breakpoint
;
15504 /* Internal breakpoints. */
15505 ops
= &internal_breakpoint_ops
;
15506 *ops
= bkpt_base_breakpoint_ops
;
15507 ops
->re_set
= internal_bkpt_re_set
;
15508 ops
->check_status
= internal_bkpt_check_status
;
15509 ops
->print_it
= internal_bkpt_print_it
;
15510 ops
->print_mention
= internal_bkpt_print_mention
;
15512 /* Momentary breakpoints. */
15513 ops
= &momentary_breakpoint_ops
;
15514 *ops
= bkpt_base_breakpoint_ops
;
15515 ops
->re_set
= momentary_bkpt_re_set
;
15516 ops
->check_status
= momentary_bkpt_check_status
;
15517 ops
->print_it
= momentary_bkpt_print_it
;
15518 ops
->print_mention
= momentary_bkpt_print_mention
;
15520 /* Probe breakpoints. */
15521 ops
= &bkpt_probe_breakpoint_ops
;
15522 *ops
= bkpt_breakpoint_ops
;
15523 ops
->insert_location
= bkpt_probe_insert_location
;
15524 ops
->remove_location
= bkpt_probe_remove_location
;
15525 ops
->create_sals_from_location
= bkpt_probe_create_sals_from_location
;
15526 ops
->decode_location
= bkpt_probe_decode_location
;
15529 ops
= &watchpoint_breakpoint_ops
;
15530 *ops
= base_breakpoint_ops
;
15531 ops
->re_set
= re_set_watchpoint
;
15532 ops
->insert_location
= insert_watchpoint
;
15533 ops
->remove_location
= remove_watchpoint
;
15534 ops
->breakpoint_hit
= breakpoint_hit_watchpoint
;
15535 ops
->check_status
= check_status_watchpoint
;
15536 ops
->resources_needed
= resources_needed_watchpoint
;
15537 ops
->works_in_software_mode
= works_in_software_mode_watchpoint
;
15538 ops
->print_it
= print_it_watchpoint
;
15539 ops
->print_mention
= print_mention_watchpoint
;
15540 ops
->print_recreate
= print_recreate_watchpoint
;
15541 ops
->explains_signal
= explains_signal_watchpoint
;
15543 /* Masked watchpoints. */
15544 ops
= &masked_watchpoint_breakpoint_ops
;
15545 *ops
= watchpoint_breakpoint_ops
;
15546 ops
->insert_location
= insert_masked_watchpoint
;
15547 ops
->remove_location
= remove_masked_watchpoint
;
15548 ops
->resources_needed
= resources_needed_masked_watchpoint
;
15549 ops
->works_in_software_mode
= works_in_software_mode_masked_watchpoint
;
15550 ops
->print_it
= print_it_masked_watchpoint
;
15551 ops
->print_one_detail
= print_one_detail_masked_watchpoint
;
15552 ops
->print_mention
= print_mention_masked_watchpoint
;
15553 ops
->print_recreate
= print_recreate_masked_watchpoint
;
15556 ops
= &tracepoint_breakpoint_ops
;
15557 *ops
= base_breakpoint_ops
;
15558 ops
->re_set
= tracepoint_re_set
;
15559 ops
->breakpoint_hit
= tracepoint_breakpoint_hit
;
15560 ops
->print_one_detail
= tracepoint_print_one_detail
;
15561 ops
->print_mention
= tracepoint_print_mention
;
15562 ops
->print_recreate
= tracepoint_print_recreate
;
15563 ops
->create_sals_from_location
= tracepoint_create_sals_from_location
;
15564 ops
->create_breakpoints_sal
= tracepoint_create_breakpoints_sal
;
15565 ops
->decode_location
= tracepoint_decode_location
;
15567 /* Probe tracepoints. */
15568 ops
= &tracepoint_probe_breakpoint_ops
;
15569 *ops
= tracepoint_breakpoint_ops
;
15570 ops
->create_sals_from_location
= tracepoint_probe_create_sals_from_location
;
15571 ops
->decode_location
= tracepoint_probe_decode_location
;
15573 /* Static tracepoints with marker (`-m'). */
15574 ops
= &strace_marker_breakpoint_ops
;
15575 *ops
= tracepoint_breakpoint_ops
;
15576 ops
->create_sals_from_location
= strace_marker_create_sals_from_location
;
15577 ops
->create_breakpoints_sal
= strace_marker_create_breakpoints_sal
;
15578 ops
->decode_location
= strace_marker_decode_location
;
15580 /* Fork catchpoints. */
15581 ops
= &catch_fork_breakpoint_ops
;
15582 *ops
= base_breakpoint_ops
;
15583 ops
->insert_location
= insert_catch_fork
;
15584 ops
->remove_location
= remove_catch_fork
;
15585 ops
->breakpoint_hit
= breakpoint_hit_catch_fork
;
15586 ops
->print_it
= print_it_catch_fork
;
15587 ops
->print_one
= print_one_catch_fork
;
15588 ops
->print_mention
= print_mention_catch_fork
;
15589 ops
->print_recreate
= print_recreate_catch_fork
;
15591 /* Vfork catchpoints. */
15592 ops
= &catch_vfork_breakpoint_ops
;
15593 *ops
= base_breakpoint_ops
;
15594 ops
->insert_location
= insert_catch_vfork
;
15595 ops
->remove_location
= remove_catch_vfork
;
15596 ops
->breakpoint_hit
= breakpoint_hit_catch_vfork
;
15597 ops
->print_it
= print_it_catch_vfork
;
15598 ops
->print_one
= print_one_catch_vfork
;
15599 ops
->print_mention
= print_mention_catch_vfork
;
15600 ops
->print_recreate
= print_recreate_catch_vfork
;
15602 /* Exec catchpoints. */
15603 ops
= &catch_exec_breakpoint_ops
;
15604 *ops
= base_breakpoint_ops
;
15605 ops
->insert_location
= insert_catch_exec
;
15606 ops
->remove_location
= remove_catch_exec
;
15607 ops
->breakpoint_hit
= breakpoint_hit_catch_exec
;
15608 ops
->print_it
= print_it_catch_exec
;
15609 ops
->print_one
= print_one_catch_exec
;
15610 ops
->print_mention
= print_mention_catch_exec
;
15611 ops
->print_recreate
= print_recreate_catch_exec
;
15613 /* Solib-related catchpoints. */
15614 ops
= &catch_solib_breakpoint_ops
;
15615 *ops
= base_breakpoint_ops
;
15616 ops
->insert_location
= insert_catch_solib
;
15617 ops
->remove_location
= remove_catch_solib
;
15618 ops
->breakpoint_hit
= breakpoint_hit_catch_solib
;
15619 ops
->check_status
= check_status_catch_solib
;
15620 ops
->print_it
= print_it_catch_solib
;
15621 ops
->print_one
= print_one_catch_solib
;
15622 ops
->print_mention
= print_mention_catch_solib
;
15623 ops
->print_recreate
= print_recreate_catch_solib
;
15625 ops
= &dprintf_breakpoint_ops
;
15626 *ops
= bkpt_base_breakpoint_ops
;
15627 ops
->re_set
= dprintf_re_set
;
15628 ops
->resources_needed
= bkpt_resources_needed
;
15629 ops
->print_it
= bkpt_print_it
;
15630 ops
->print_mention
= bkpt_print_mention
;
15631 ops
->print_recreate
= dprintf_print_recreate
;
15632 ops
->after_condition_true
= dprintf_after_condition_true
;
15633 ops
->breakpoint_hit
= dprintf_breakpoint_hit
;
15636 /* Chain containing all defined "enable breakpoint" subcommands. */
15638 static struct cmd_list_element
*enablebreaklist
= NULL
;
15641 _initialize_breakpoint (void)
15643 struct cmd_list_element
*c
;
15645 initialize_breakpoint_ops ();
15647 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
15648 observer_attach_free_objfile (disable_breakpoints_in_freed_objfile
);
15649 observer_attach_memory_changed (invalidate_bp_value_on_memory_change
);
15651 breakpoint_objfile_key
15652 = register_objfile_data_with_cleanup (NULL
, free_breakpoint_probes
);
15654 breakpoint_chain
= 0;
15655 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
15656 before a breakpoint is set. */
15657 breakpoint_count
= 0;
15659 tracepoint_count
= 0;
15661 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
15662 Set ignore-count of breakpoint number N to COUNT.\n\
15663 Usage is `ignore N COUNT'."));
15665 add_com ("commands", class_breakpoint
, commands_command
, _("\
15666 Set commands to be executed when the given breakpoints are hit.\n\
15667 Give a space-separated breakpoint list as argument after \"commands\".\n\
15668 A list element can be a breakpoint number (e.g. `5') or a range of numbers\n\
15670 With no argument, the targeted breakpoint is the last one set.\n\
15671 The commands themselves follow starting on the next line.\n\
15672 Type a line containing \"end\" to indicate the end of them.\n\
15673 Give \"silent\" as the first line to make the breakpoint silent;\n\
15674 then no output is printed when it is hit, except what the commands print."));
15676 c
= add_com ("condition", class_breakpoint
, condition_command
, _("\
15677 Specify breakpoint number N to break only if COND is true.\n\
15678 Usage is `condition N COND', where N is an integer and COND is an\n\
15679 expression to be evaluated whenever breakpoint N is reached."));
15680 set_cmd_completer (c
, condition_completer
);
15682 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
15683 Set a temporary breakpoint.\n\
15684 Like \"break\" except the breakpoint is only temporary,\n\
15685 so it will be deleted when hit. Equivalent to \"break\" followed\n\
15686 by using \"enable delete\" on the breakpoint number.\n\
15688 BREAK_ARGS_HELP ("tbreak")));
15689 set_cmd_completer (c
, location_completer
);
15691 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
15692 Set a hardware assisted breakpoint.\n\
15693 Like \"break\" except the breakpoint requires hardware support,\n\
15694 some target hardware may not have this support.\n\
15696 BREAK_ARGS_HELP ("hbreak")));
15697 set_cmd_completer (c
, location_completer
);
15699 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
15700 Set a temporary hardware assisted breakpoint.\n\
15701 Like \"hbreak\" except the breakpoint is only temporary,\n\
15702 so it will be deleted when hit.\n\
15704 BREAK_ARGS_HELP ("thbreak")));
15705 set_cmd_completer (c
, location_completer
);
15707 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
15708 Enable some breakpoints.\n\
15709 Give breakpoint numbers (separated by spaces) as arguments.\n\
15710 With no subcommand, breakpoints are enabled until you command otherwise.\n\
15711 This is used to cancel the effect of the \"disable\" command.\n\
15712 With a subcommand you can enable temporarily."),
15713 &enablelist
, "enable ", 1, &cmdlist
);
15715 add_com_alias ("en", "enable", class_breakpoint
, 1);
15717 add_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
15718 Enable some breakpoints.\n\
15719 Give breakpoint numbers (separated by spaces) as arguments.\n\
15720 This is used to cancel the effect of the \"disable\" command.\n\
15721 May be abbreviated to simply \"enable\".\n"),
15722 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
15724 add_cmd ("once", no_class
, enable_once_command
, _("\
15725 Enable breakpoints for one hit. Give breakpoint numbers.\n\
15726 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
15729 add_cmd ("delete", no_class
, enable_delete_command
, _("\
15730 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
15731 If a breakpoint is hit while enabled in this fashion, it is deleted."),
15734 add_cmd ("count", no_class
, enable_count_command
, _("\
15735 Enable breakpoints for COUNT hits. Give count and then breakpoint numbers.\n\
15736 If a breakpoint is hit while enabled in this fashion,\n\
15737 the count is decremented; when it reaches zero, the breakpoint is disabled."),
15740 add_cmd ("delete", no_class
, enable_delete_command
, _("\
15741 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
15742 If a breakpoint is hit while enabled in this fashion, it is deleted."),
15745 add_cmd ("once", no_class
, enable_once_command
, _("\
15746 Enable breakpoints for one hit. Give breakpoint numbers.\n\
15747 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
15750 add_cmd ("count", no_class
, enable_count_command
, _("\
15751 Enable breakpoints for COUNT hits. Give count and then breakpoint numbers.\n\
15752 If a breakpoint is hit while enabled in this fashion,\n\
15753 the count is decremented; when it reaches zero, the breakpoint is disabled."),
15756 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
15757 Disable some breakpoints.\n\
15758 Arguments are breakpoint numbers with spaces in between.\n\
15759 To disable all breakpoints, give no argument.\n\
15760 A disabled breakpoint is not forgotten, but has no effect until re-enabled."),
15761 &disablelist
, "disable ", 1, &cmdlist
);
15762 add_com_alias ("dis", "disable", class_breakpoint
, 1);
15763 add_com_alias ("disa", "disable", class_breakpoint
, 1);
15765 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
15766 Disable some breakpoints.\n\
15767 Arguments are breakpoint numbers with spaces in between.\n\
15768 To disable all breakpoints, give no argument.\n\
15769 A disabled breakpoint is not forgotten, but has no effect until re-enabled.\n\
15770 This command may be abbreviated \"disable\"."),
15773 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
15774 Delete some breakpoints or auto-display expressions.\n\
15775 Arguments are breakpoint numbers with spaces in between.\n\
15776 To delete all breakpoints, give no argument.\n\
15778 Also a prefix command for deletion of other GDB objects.\n\
15779 The \"unset\" command is also an alias for \"delete\"."),
15780 &deletelist
, "delete ", 1, &cmdlist
);
15781 add_com_alias ("d", "delete", class_breakpoint
, 1);
15782 add_com_alias ("del", "delete", class_breakpoint
, 1);
15784 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
15785 Delete some breakpoints or auto-display expressions.\n\
15786 Arguments are breakpoint numbers with spaces in between.\n\
15787 To delete all breakpoints, give no argument.\n\
15788 This command may be abbreviated \"delete\"."),
15791 add_com ("clear", class_breakpoint
, clear_command
, _("\
15792 Clear breakpoint at specified location.\n\
15793 Argument may be a linespec, explicit, or address location as described below.\n\
15795 With no argument, clears all breakpoints in the line that the selected frame\n\
15796 is executing in.\n"
15797 "\n" LOCATION_HELP_STRING
"\n\
15798 See also the \"delete\" command which clears breakpoints by number."));
15799 add_com_alias ("cl", "clear", class_breakpoint
, 1);
15801 c
= add_com ("break", class_breakpoint
, break_command
, _("\
15802 Set breakpoint at specified location.\n"
15803 BREAK_ARGS_HELP ("break")));
15804 set_cmd_completer (c
, location_completer
);
15806 add_com_alias ("b", "break", class_run
, 1);
15807 add_com_alias ("br", "break", class_run
, 1);
15808 add_com_alias ("bre", "break", class_run
, 1);
15809 add_com_alias ("brea", "break", class_run
, 1);
15813 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
15814 Break in function/address or break at a line in the current file."),
15815 &stoplist
, "stop ", 1, &cmdlist
);
15816 add_cmd ("in", class_breakpoint
, stopin_command
,
15817 _("Break in function or address."), &stoplist
);
15818 add_cmd ("at", class_breakpoint
, stopat_command
,
15819 _("Break at a line in the current file."), &stoplist
);
15820 add_com ("status", class_info
, info_breakpoints_command
, _("\
15821 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
15822 The \"Type\" column indicates one of:\n\
15823 \tbreakpoint - normal breakpoint\n\
15824 \twatchpoint - watchpoint\n\
15825 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15826 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
15827 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
15828 address and file/line number respectively.\n\
15830 Convenience variable \"$_\" and default examine address for \"x\"\n\
15831 are set to the address of the last breakpoint listed unless the command\n\
15832 is prefixed with \"server \".\n\n\
15833 Convenience variable \"$bpnum\" contains the number of the last\n\
15834 breakpoint set."));
15837 add_info ("breakpoints", info_breakpoints_command
, _("\
15838 Status of specified breakpoints (all user-settable breakpoints if no argument).\n\
15839 The \"Type\" column indicates one of:\n\
15840 \tbreakpoint - normal breakpoint\n\
15841 \twatchpoint - watchpoint\n\
15842 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15843 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
15844 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
15845 address and file/line number respectively.\n\
15847 Convenience variable \"$_\" and default examine address for \"x\"\n\
15848 are set to the address of the last breakpoint listed unless the command\n\
15849 is prefixed with \"server \".\n\n\
15850 Convenience variable \"$bpnum\" contains the number of the last\n\
15851 breakpoint set."));
15853 add_info_alias ("b", "breakpoints", 1);
15855 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
15856 Status of all breakpoints, or breakpoint number NUMBER.\n\
15857 The \"Type\" column indicates one of:\n\
15858 \tbreakpoint - normal breakpoint\n\
15859 \twatchpoint - watchpoint\n\
15860 \tlongjmp - internal breakpoint used to step through longjmp()\n\
15861 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
15862 \tuntil - internal breakpoint used by the \"until\" command\n\
15863 \tfinish - internal breakpoint used by the \"finish\" command\n\
15864 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15865 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
15866 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
15867 address and file/line number respectively.\n\
15869 Convenience variable \"$_\" and default examine address for \"x\"\n\
15870 are set to the address of the last breakpoint listed unless the command\n\
15871 is prefixed with \"server \".\n\n\
15872 Convenience variable \"$bpnum\" contains the number of the last\n\
15874 &maintenanceinfolist
);
15876 add_prefix_cmd ("catch", class_breakpoint
, catch_command
, _("\
15877 Set catchpoints to catch events."),
15878 &catch_cmdlist
, "catch ",
15879 0/*allow-unknown*/, &cmdlist
);
15881 add_prefix_cmd ("tcatch", class_breakpoint
, tcatch_command
, _("\
15882 Set temporary catchpoints to catch events."),
15883 &tcatch_cmdlist
, "tcatch ",
15884 0/*allow-unknown*/, &cmdlist
);
15886 add_catch_command ("fork", _("Catch calls to fork."),
15887 catch_fork_command_1
,
15889 (void *) (uintptr_t) catch_fork_permanent
,
15890 (void *) (uintptr_t) catch_fork_temporary
);
15891 add_catch_command ("vfork", _("Catch calls to vfork."),
15892 catch_fork_command_1
,
15894 (void *) (uintptr_t) catch_vfork_permanent
,
15895 (void *) (uintptr_t) catch_vfork_temporary
);
15896 add_catch_command ("exec", _("Catch calls to exec."),
15897 catch_exec_command_1
,
15901 add_catch_command ("load", _("Catch loads of shared libraries.\n\
15902 Usage: catch load [REGEX]\n\
15903 If REGEX is given, only stop for libraries matching the regular expression."),
15904 catch_load_command_1
,
15908 add_catch_command ("unload", _("Catch unloads of shared libraries.\n\
15909 Usage: catch unload [REGEX]\n\
15910 If REGEX is given, only stop for libraries matching the regular expression."),
15911 catch_unload_command_1
,
15916 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
15917 Set a watchpoint for an expression.\n\
15918 Usage: watch [-l|-location] EXPRESSION\n\
15919 A watchpoint stops execution of your program whenever the value of\n\
15920 an expression changes.\n\
15921 If -l or -location is given, this evaluates EXPRESSION and watches\n\
15922 the memory to which it refers."));
15923 set_cmd_completer (c
, expression_completer
);
15925 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
15926 Set a read watchpoint for an expression.\n\
15927 Usage: rwatch [-l|-location] EXPRESSION\n\
15928 A watchpoint stops execution of your program whenever the value of\n\
15929 an expression is read.\n\
15930 If -l or -location is given, this evaluates EXPRESSION and watches\n\
15931 the memory to which it refers."));
15932 set_cmd_completer (c
, expression_completer
);
15934 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
15935 Set a watchpoint for an expression.\n\
15936 Usage: awatch [-l|-location] EXPRESSION\n\
15937 A watchpoint stops execution of your program whenever the value of\n\
15938 an expression is either read or written.\n\
15939 If -l or -location is given, this evaluates EXPRESSION and watches\n\
15940 the memory to which it refers."));
15941 set_cmd_completer (c
, expression_completer
);
15943 add_info ("watchpoints", info_watchpoints_command
, _("\
15944 Status of specified watchpoints (all watchpoints if no argument)."));
15946 /* XXX: cagney/2005-02-23: This should be a boolean, and should
15947 respond to changes - contrary to the description. */
15948 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
15949 &can_use_hw_watchpoints
, _("\
15950 Set debugger's willingness to use watchpoint hardware."), _("\
15951 Show debugger's willingness to use watchpoint hardware."), _("\
15952 If zero, gdb will not use hardware for new watchpoints, even if\n\
15953 such is available. (However, any hardware watchpoints that were\n\
15954 created before setting this to nonzero, will continue to use watchpoint\n\
15957 show_can_use_hw_watchpoints
,
15958 &setlist
, &showlist
);
15960 can_use_hw_watchpoints
= 1;
15962 /* Tracepoint manipulation commands. */
15964 c
= add_com ("trace", class_breakpoint
, trace_command
, _("\
15965 Set a tracepoint at specified location.\n\
15967 BREAK_ARGS_HELP ("trace") "\n\
15968 Do \"help tracepoints\" for info on other tracepoint commands."));
15969 set_cmd_completer (c
, location_completer
);
15971 add_com_alias ("tp", "trace", class_alias
, 0);
15972 add_com_alias ("tr", "trace", class_alias
, 1);
15973 add_com_alias ("tra", "trace", class_alias
, 1);
15974 add_com_alias ("trac", "trace", class_alias
, 1);
15976 c
= add_com ("ftrace", class_breakpoint
, ftrace_command
, _("\
15977 Set a fast tracepoint at specified location.\n\
15979 BREAK_ARGS_HELP ("ftrace") "\n\
15980 Do \"help tracepoints\" for info on other tracepoint commands."));
15981 set_cmd_completer (c
, location_completer
);
15983 c
= add_com ("strace", class_breakpoint
, strace_command
, _("\
15984 Set a static tracepoint at location or marker.\n\
15986 strace [LOCATION] [if CONDITION]\n\
15987 LOCATION may be a linespec, explicit, or address location (described below) \n\
15988 or -m MARKER_ID.\n\n\
15989 If a marker id is specified, probe the marker with that name. With\n\
15990 no LOCATION, uses current execution address of the selected stack frame.\n\
15991 Static tracepoints accept an extra collect action -- ``collect $_sdata''.\n\
15992 This collects arbitrary user data passed in the probe point call to the\n\
15993 tracing library. You can inspect it when analyzing the trace buffer,\n\
15994 by printing the $_sdata variable like any other convenience variable.\n\
15996 CONDITION is a boolean expression.\n\
15997 \n" LOCATION_HELP_STRING
"\n\
15998 Multiple tracepoints at one place are permitted, and useful if their\n\
15999 conditions are different.\n\
16001 Do \"help breakpoints\" for info on other commands dealing with breakpoints.\n\
16002 Do \"help tracepoints\" for info on other tracepoint commands."));
16003 set_cmd_completer (c
, location_completer
);
16005 add_info ("tracepoints", info_tracepoints_command
, _("\
16006 Status of specified tracepoints (all tracepoints if no argument).\n\
16007 Convenience variable \"$tpnum\" contains the number of the\n\
16008 last tracepoint set."));
16010 add_info_alias ("tp", "tracepoints", 1);
16012 add_cmd ("tracepoints", class_trace
, delete_trace_command
, _("\
16013 Delete specified tracepoints.\n\
16014 Arguments are tracepoint numbers, separated by spaces.\n\
16015 No argument means delete all tracepoints."),
16017 add_alias_cmd ("tr", "tracepoints", class_trace
, 1, &deletelist
);
16019 c
= add_cmd ("tracepoints", class_trace
, disable_trace_command
, _("\
16020 Disable specified tracepoints.\n\
16021 Arguments are tracepoint numbers, separated by spaces.\n\
16022 No argument means disable all tracepoints."),
16024 deprecate_cmd (c
, "disable");
16026 c
= add_cmd ("tracepoints", class_trace
, enable_trace_command
, _("\
16027 Enable specified tracepoints.\n\
16028 Arguments are tracepoint numbers, separated by spaces.\n\
16029 No argument means enable all tracepoints."),
16031 deprecate_cmd (c
, "enable");
16033 add_com ("passcount", class_trace
, trace_pass_command
, _("\
16034 Set the passcount for a tracepoint.\n\
16035 The trace will end when the tracepoint has been passed 'count' times.\n\
16036 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
16037 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
16039 add_prefix_cmd ("save", class_breakpoint
, save_command
,
16040 _("Save breakpoint definitions as a script."),
16041 &save_cmdlist
, "save ",
16042 0/*allow-unknown*/, &cmdlist
);
16044 c
= add_cmd ("breakpoints", class_breakpoint
, save_breakpoints_command
, _("\
16045 Save current breakpoint definitions as a script.\n\
16046 This includes all types of breakpoints (breakpoints, watchpoints,\n\
16047 catchpoints, tracepoints). Use the 'source' command in another debug\n\
16048 session to restore them."),
16050 set_cmd_completer (c
, filename_completer
);
16052 c
= add_cmd ("tracepoints", class_trace
, save_tracepoints_command
, _("\
16053 Save current tracepoint definitions as a script.\n\
16054 Use the 'source' command in another debug session to restore them."),
16056 set_cmd_completer (c
, filename_completer
);
16058 c
= add_com_alias ("save-tracepoints", "save tracepoints", class_trace
, 0);
16059 deprecate_cmd (c
, "save tracepoints");
16061 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
16062 Breakpoint specific settings\n\
16063 Configure various breakpoint-specific variables such as\n\
16064 pending breakpoint behavior"),
16065 &breakpoint_set_cmdlist
, "set breakpoint ",
16066 0/*allow-unknown*/, &setlist
);
16067 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
16068 Breakpoint specific settings\n\
16069 Configure various breakpoint-specific variables such as\n\
16070 pending breakpoint behavior"),
16071 &breakpoint_show_cmdlist
, "show breakpoint ",
16072 0/*allow-unknown*/, &showlist
);
16074 add_setshow_auto_boolean_cmd ("pending", no_class
,
16075 &pending_break_support
, _("\
16076 Set debugger's behavior regarding pending breakpoints."), _("\
16077 Show debugger's behavior regarding pending breakpoints."), _("\
16078 If on, an unrecognized breakpoint location will cause gdb to create a\n\
16079 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
16080 an error. If auto, an unrecognized breakpoint location results in a\n\
16081 user-query to see if a pending breakpoint should be created."),
16083 show_pending_break_support
,
16084 &breakpoint_set_cmdlist
,
16085 &breakpoint_show_cmdlist
);
16087 pending_break_support
= AUTO_BOOLEAN_AUTO
;
16089 add_setshow_boolean_cmd ("auto-hw", no_class
,
16090 &automatic_hardware_breakpoints
, _("\
16091 Set automatic usage of hardware breakpoints."), _("\
16092 Show automatic usage of hardware breakpoints."), _("\
16093 If set, the debugger will automatically use hardware breakpoints for\n\
16094 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
16095 a warning will be emitted for such breakpoints."),
16097 show_automatic_hardware_breakpoints
,
16098 &breakpoint_set_cmdlist
,
16099 &breakpoint_show_cmdlist
);
16101 add_setshow_boolean_cmd ("always-inserted", class_support
,
16102 &always_inserted_mode
, _("\
16103 Set mode for inserting breakpoints."), _("\
16104 Show mode for inserting breakpoints."), _("\
16105 When this mode is on, breakpoints are inserted immediately as soon as\n\
16106 they're created, kept inserted even when execution stops, and removed\n\
16107 only when the user deletes them. When this mode is off (the default),\n\
16108 breakpoints are inserted only when execution continues, and removed\n\
16109 when execution stops."),
16111 &show_always_inserted_mode
,
16112 &breakpoint_set_cmdlist
,
16113 &breakpoint_show_cmdlist
);
16115 add_setshow_enum_cmd ("condition-evaluation", class_breakpoint
,
16116 condition_evaluation_enums
,
16117 &condition_evaluation_mode_1
, _("\
16118 Set mode of breakpoint condition evaluation."), _("\
16119 Show mode of breakpoint condition evaluation."), _("\
16120 When this is set to \"host\", breakpoint conditions will be\n\
16121 evaluated on the host's side by GDB. When it is set to \"target\",\n\
16122 breakpoint conditions will be downloaded to the target (if the target\n\
16123 supports such feature) and conditions will be evaluated on the target's side.\n\
16124 If this is set to \"auto\" (default), this will be automatically set to\n\
16125 \"target\" if it supports condition evaluation, otherwise it will\n\
16126 be set to \"gdb\""),
16127 &set_condition_evaluation_mode
,
16128 &show_condition_evaluation_mode
,
16129 &breakpoint_set_cmdlist
,
16130 &breakpoint_show_cmdlist
);
16132 add_com ("break-range", class_breakpoint
, break_range_command
, _("\
16133 Set a breakpoint for an address range.\n\
16134 break-range START-LOCATION, END-LOCATION\n\
16135 where START-LOCATION and END-LOCATION can be one of the following:\n\
16136 LINENUM, for that line in the current file,\n\
16137 FILE:LINENUM, for that line in that file,\n\
16138 +OFFSET, for that number of lines after the current line\n\
16139 or the start of the range\n\
16140 FUNCTION, for the first line in that function,\n\
16141 FILE:FUNCTION, to distinguish among like-named static functions.\n\
16142 *ADDRESS, for the instruction at that address.\n\
16144 The breakpoint will stop execution of the inferior whenever it executes\n\
16145 an instruction at any address within the [START-LOCATION, END-LOCATION]\n\
16146 range (including START-LOCATION and END-LOCATION)."));
16148 c
= add_com ("dprintf", class_breakpoint
, dprintf_command
, _("\
16149 Set a dynamic printf at specified location.\n\
16150 dprintf location,format string,arg1,arg2,...\n\
16151 location may be a linespec, explicit, or address location.\n"
16152 "\n" LOCATION_HELP_STRING
));
16153 set_cmd_completer (c
, location_completer
);
16155 add_setshow_enum_cmd ("dprintf-style", class_support
,
16156 dprintf_style_enums
, &dprintf_style
, _("\
16157 Set the style of usage for dynamic printf."), _("\
16158 Show the style of usage for dynamic printf."), _("\
16159 This setting chooses how GDB will do a dynamic printf.\n\
16160 If the value is \"gdb\", then the printing is done by GDB to its own\n\
16161 console, as with the \"printf\" command.\n\
16162 If the value is \"call\", the print is done by calling a function in your\n\
16163 program; by default printf(), but you can choose a different function or\n\
16164 output stream by setting dprintf-function and dprintf-channel."),
16165 update_dprintf_commands
, NULL
,
16166 &setlist
, &showlist
);
16168 dprintf_function
= xstrdup ("printf");
16169 add_setshow_string_cmd ("dprintf-function", class_support
,
16170 &dprintf_function
, _("\
16171 Set the function to use for dynamic printf"), _("\
16172 Show the function to use for dynamic printf"), NULL
,
16173 update_dprintf_commands
, NULL
,
16174 &setlist
, &showlist
);
16176 dprintf_channel
= xstrdup ("");
16177 add_setshow_string_cmd ("dprintf-channel", class_support
,
16178 &dprintf_channel
, _("\
16179 Set the channel to use for dynamic printf"), _("\
16180 Show the channel to use for dynamic printf"), NULL
,
16181 update_dprintf_commands
, NULL
,
16182 &setlist
, &showlist
);
16184 add_setshow_boolean_cmd ("disconnected-dprintf", no_class
,
16185 &disconnected_dprintf
, _("\
16186 Set whether dprintf continues after GDB disconnects."), _("\
16187 Show whether dprintf continues after GDB disconnects."), _("\
16188 Use this to let dprintf commands continue to hit and produce output\n\
16189 even if GDB disconnects or detaches from the target."),
16192 &setlist
, &showlist
);
16194 add_com ("agent-printf", class_vars
, agent_printf_command
, _("\
16195 agent-printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
16196 (target agent only) This is useful for formatted output in user-defined commands."));
16198 automatic_hardware_breakpoints
= 1;
16200 observer_attach_about_to_proceed (breakpoint_about_to_proceed
);
16201 observer_attach_thread_exit (remove_threaded_breakpoints
);