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"
49 #include "cli/cli-script.h"
59 #include "parser-defs.h"
60 #include "gdb_regex.h"
62 #include "cli/cli-utils.h"
63 #include "continuations.h"
67 #include "dummy-frame.h"
70 #include "thread-fsm.h"
71 #include "tid-parse.h"
73 /* readline include files */
74 #include "readline/readline.h"
75 #include "readline/history.h"
77 /* readline defines this. */
80 #include "mi/mi-common.h"
81 #include "extension.h"
83 #include "progspace-and-thread.h"
85 /* Enums for exception-handling support. */
86 enum exception_event_kind
93 /* Prototypes for local functions. */
95 static void enable_delete_command (char *, int);
97 static void enable_once_command (char *, int);
99 static void enable_count_command (char *, int);
101 static void disable_command (char *, int);
103 static void enable_command (char *, int);
105 static void map_breakpoint_numbers (const char *,
106 void (*) (struct breakpoint
*,
110 static void ignore_command (char *, int);
112 static int breakpoint_re_set_one (void *);
114 static void breakpoint_re_set_default (struct breakpoint
*);
117 create_sals_from_location_default (const struct event_location
*location
,
118 struct linespec_result
*canonical
,
119 enum bptype type_wanted
);
121 static void create_breakpoints_sal_default (struct gdbarch
*,
122 struct linespec_result
*,
123 gdb::unique_xmalloc_ptr
<char>,
124 gdb::unique_xmalloc_ptr
<char>,
126 enum bpdisp
, int, int,
128 const struct breakpoint_ops
*,
129 int, int, int, unsigned);
131 static void decode_location_default (struct breakpoint
*b
,
132 const struct event_location
*location
,
133 struct program_space
*search_pspace
,
134 struct symtabs_and_lines
*sals
);
136 static void clear_command (char *, int);
138 static void catch_command (char *, int);
140 static int can_use_hardware_watchpoint (struct value
*);
142 static void break_command_1 (char *, int, int);
144 static void mention (struct breakpoint
*);
146 static struct breakpoint
*set_raw_breakpoint_without_location (struct gdbarch
*,
148 const struct breakpoint_ops
*);
149 static struct bp_location
*add_location_to_breakpoint (struct breakpoint
*,
150 const struct symtab_and_line
*);
152 /* This function is used in gdbtk sources and thus can not be made
154 struct breakpoint
*set_raw_breakpoint (struct gdbarch
*gdbarch
,
155 struct symtab_and_line
,
157 const struct breakpoint_ops
*);
159 static struct breakpoint
*
160 momentary_breakpoint_from_master (struct breakpoint
*orig
,
162 const struct breakpoint_ops
*ops
,
165 static void breakpoint_adjustment_warning (CORE_ADDR
, CORE_ADDR
, int, int);
167 static CORE_ADDR
adjust_breakpoint_address (struct gdbarch
*gdbarch
,
171 static void describe_other_breakpoints (struct gdbarch
*,
172 struct program_space
*, CORE_ADDR
,
173 struct obj_section
*, int);
175 static int watchpoint_locations_match (struct bp_location
*loc1
,
176 struct bp_location
*loc2
);
178 static int breakpoint_location_address_match (struct bp_location
*bl
,
179 struct address_space
*aspace
,
182 static int breakpoint_location_address_range_overlap (struct bp_location
*,
183 struct address_space
*,
186 static void breakpoints_info (char *, int);
188 static void watchpoints_info (char *, int);
190 static int breakpoint_1 (char *, int,
191 int (*) (const struct breakpoint
*));
193 static int breakpoint_cond_eval (void *);
195 static void cleanup_executing_breakpoints (void *);
197 static void commands_command (char *, int);
199 static void condition_command (char *, int);
201 static int remove_breakpoint (struct bp_location
*);
202 static int remove_breakpoint_1 (struct bp_location
*, enum remove_bp_reason
);
204 static enum print_stop_action
print_bp_stop_message (bpstat bs
);
206 static int watchpoint_check (void *);
208 static void maintenance_info_breakpoints (char *, int);
210 static int hw_breakpoint_used_count (void);
212 static int hw_watchpoint_use_count (struct breakpoint
*);
214 static int hw_watchpoint_used_count_others (struct breakpoint
*except
,
216 int *other_type_used
);
218 static void hbreak_command (char *, int);
220 static void thbreak_command (char *, int);
222 static void enable_breakpoint_disp (struct breakpoint
*, enum bpdisp
,
225 static void stop_command (char *arg
, int from_tty
);
227 static void stopin_command (char *arg
, int from_tty
);
229 static void stopat_command (char *arg
, int from_tty
);
231 static void tcatch_command (char *arg
, int from_tty
);
233 static void free_bp_location (struct bp_location
*loc
);
234 static void incref_bp_location (struct bp_location
*loc
);
235 static void decref_bp_location (struct bp_location
**loc
);
237 static struct bp_location
*allocate_bp_location (struct breakpoint
*bpt
);
239 /* update_global_location_list's modes of operation wrt to whether to
240 insert locations now. */
241 enum ugll_insert_mode
243 /* Don't insert any breakpoint locations into the inferior, only
244 remove already-inserted locations that no longer should be
245 inserted. Functions that delete a breakpoint or breakpoints
246 should specify this mode, so that deleting a breakpoint doesn't
247 have the side effect of inserting the locations of other
248 breakpoints that are marked not-inserted, but should_be_inserted
249 returns true on them.
251 This behavior is useful is situations close to tear-down -- e.g.,
252 after an exec, while the target still has execution, but
253 breakpoint shadows of the previous executable image should *NOT*
254 be restored to the new image; or before detaching, where the
255 target still has execution and wants to delete breakpoints from
256 GDB's lists, and all breakpoints had already been removed from
260 /* May insert breakpoints iff breakpoints_should_be_inserted_now
261 claims breakpoints should be inserted now. */
264 /* Insert locations now, irrespective of
265 breakpoints_should_be_inserted_now. E.g., say all threads are
266 stopped right now, and the user did "continue". We need to
267 insert breakpoints _before_ resuming the target, but
268 UGLL_MAY_INSERT wouldn't insert them, because
269 breakpoints_should_be_inserted_now returns false at that point,
270 as no thread is running yet. */
274 static void update_global_location_list (enum ugll_insert_mode
);
276 static void update_global_location_list_nothrow (enum ugll_insert_mode
);
278 static int is_hardware_watchpoint (const struct breakpoint
*bpt
);
280 static void insert_breakpoint_locations (void);
282 static void tracepoints_info (char *, int);
284 static void delete_trace_command (char *, int);
286 static void enable_trace_command (char *, int);
288 static void disable_trace_command (char *, int);
290 static void trace_pass_command (char *, int);
292 static void set_tracepoint_count (int num
);
294 static int is_masked_watchpoint (const struct breakpoint
*b
);
296 static struct bp_location
**get_first_locp_gte_addr (CORE_ADDR address
);
298 /* Return 1 if B refers to a static tracepoint set by marker ("-m"), zero
301 static int strace_marker_p (struct breakpoint
*b
);
303 /* The breakpoint_ops structure to be inherited by all breakpoint_ops
304 that are implemented on top of software or hardware breakpoints
305 (user breakpoints, internal and momentary breakpoints, etc.). */
306 static struct breakpoint_ops bkpt_base_breakpoint_ops
;
308 /* Internal breakpoints class type. */
309 static struct breakpoint_ops internal_breakpoint_ops
;
311 /* Momentary breakpoints class type. */
312 static struct breakpoint_ops momentary_breakpoint_ops
;
314 /* The breakpoint_ops structure to be used in regular user created
316 struct breakpoint_ops bkpt_breakpoint_ops
;
318 /* Breakpoints set on probes. */
319 static struct breakpoint_ops bkpt_probe_breakpoint_ops
;
321 /* Dynamic printf class type. */
322 struct breakpoint_ops dprintf_breakpoint_ops
;
324 /* The style in which to perform a dynamic printf. This is a user
325 option because different output options have different tradeoffs;
326 if GDB does the printing, there is better error handling if there
327 is a problem with any of the arguments, but using an inferior
328 function lets you have special-purpose printers and sending of
329 output to the same place as compiled-in print functions. */
331 static const char dprintf_style_gdb
[] = "gdb";
332 static const char dprintf_style_call
[] = "call";
333 static const char dprintf_style_agent
[] = "agent";
334 static const char *const dprintf_style_enums
[] = {
340 static const char *dprintf_style
= dprintf_style_gdb
;
342 /* The function to use for dynamic printf if the preferred style is to
343 call into the inferior. The value is simply a string that is
344 copied into the command, so it can be anything that GDB can
345 evaluate to a callable address, not necessarily a function name. */
347 static char *dprintf_function
;
349 /* The channel to use for dynamic printf if the preferred style is to
350 call into the inferior; if a nonempty string, it will be passed to
351 the call as the first argument, with the format string as the
352 second. As with the dprintf function, this can be anything that
353 GDB knows how to evaluate, so in addition to common choices like
354 "stderr", this could be an app-specific expression like
355 "mystreams[curlogger]". */
357 static char *dprintf_channel
;
359 /* True if dprintf commands should continue to operate even if GDB
361 static int disconnected_dprintf
= 1;
363 /* A reference-counted struct command_line. This lets multiple
364 breakpoints share a single command list. */
365 struct counted_command_line
367 /* The reference count. */
370 /* The command list. */
371 struct command_line
*commands
;
374 struct command_line
*
375 breakpoint_commands (struct breakpoint
*b
)
377 return b
->commands
? b
->commands
->commands
: NULL
;
380 /* Flag indicating that a command has proceeded the inferior past the
381 current breakpoint. */
383 static int breakpoint_proceeded
;
386 bpdisp_text (enum bpdisp disp
)
388 /* NOTE: the following values are a part of MI protocol and
389 represent values of 'disp' field returned when inferior stops at
391 static const char * const bpdisps
[] = {"del", "dstp", "dis", "keep"};
393 return bpdisps
[(int) disp
];
396 /* Prototypes for exported functions. */
397 /* If FALSE, gdb will not use hardware support for watchpoints, even
398 if such is available. */
399 static int can_use_hw_watchpoints
;
402 show_can_use_hw_watchpoints (struct ui_file
*file
, int from_tty
,
403 struct cmd_list_element
*c
,
406 fprintf_filtered (file
,
407 _("Debugger's willingness to use "
408 "watchpoint hardware is %s.\n"),
412 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
413 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
414 for unrecognized breakpoint locations.
415 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
416 static enum auto_boolean pending_break_support
;
418 show_pending_break_support (struct ui_file
*file
, int from_tty
,
419 struct cmd_list_element
*c
,
422 fprintf_filtered (file
,
423 _("Debugger's behavior regarding "
424 "pending breakpoints is %s.\n"),
428 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
429 set with "break" but falling in read-only memory.
430 If 0, gdb will warn about such breakpoints, but won't automatically
431 use hardware breakpoints. */
432 static int automatic_hardware_breakpoints
;
434 show_automatic_hardware_breakpoints (struct ui_file
*file
, int from_tty
,
435 struct cmd_list_element
*c
,
438 fprintf_filtered (file
,
439 _("Automatic usage of hardware breakpoints is %s.\n"),
443 /* If on, GDB keeps breakpoints inserted even if the inferior is
444 stopped, and immediately inserts any new breakpoints as soon as
445 they're created. If off (default), GDB keeps breakpoints off of
446 the target as long as possible. That is, it delays inserting
447 breakpoints until the next resume, and removes them again when the
448 target fully stops. This is a bit safer in case GDB crashes while
449 processing user input. */
450 static int always_inserted_mode
= 0;
453 show_always_inserted_mode (struct ui_file
*file
, int from_tty
,
454 struct cmd_list_element
*c
, const char *value
)
456 fprintf_filtered (file
, _("Always inserted breakpoint mode is %s.\n"),
460 /* See breakpoint.h. */
463 breakpoints_should_be_inserted_now (void)
465 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
467 /* If breakpoints are global, they should be inserted even if no
468 thread under gdb's control is running, or even if there are
469 no threads under GDB's control yet. */
472 else if (target_has_execution
)
474 struct thread_info
*tp
;
476 if (always_inserted_mode
)
478 /* The user wants breakpoints inserted even if all threads
483 if (threads_are_executing ())
486 /* Don't remove breakpoints yet if, even though all threads are
487 stopped, we still have events to process. */
488 ALL_NON_EXITED_THREADS (tp
)
490 && tp
->suspend
.waitstatus_pending_p
)
496 static const char condition_evaluation_both
[] = "host or target";
498 /* Modes for breakpoint condition evaluation. */
499 static const char condition_evaluation_auto
[] = "auto";
500 static const char condition_evaluation_host
[] = "host";
501 static const char condition_evaluation_target
[] = "target";
502 static const char *const condition_evaluation_enums
[] = {
503 condition_evaluation_auto
,
504 condition_evaluation_host
,
505 condition_evaluation_target
,
509 /* Global that holds the current mode for breakpoint condition evaluation. */
510 static const char *condition_evaluation_mode_1
= condition_evaluation_auto
;
512 /* Global that we use to display information to the user (gets its value from
513 condition_evaluation_mode_1. */
514 static const char *condition_evaluation_mode
= condition_evaluation_auto
;
516 /* Translate a condition evaluation mode MODE into either "host"
517 or "target". This is used mostly to translate from "auto" to the
518 real setting that is being used. It returns the translated
522 translate_condition_evaluation_mode (const char *mode
)
524 if (mode
== condition_evaluation_auto
)
526 if (target_supports_evaluation_of_breakpoint_conditions ())
527 return condition_evaluation_target
;
529 return condition_evaluation_host
;
535 /* Discovers what condition_evaluation_auto translates to. */
538 breakpoint_condition_evaluation_mode (void)
540 return translate_condition_evaluation_mode (condition_evaluation_mode
);
543 /* Return true if GDB should evaluate breakpoint conditions or false
547 gdb_evaluates_breakpoint_condition_p (void)
549 const char *mode
= breakpoint_condition_evaluation_mode ();
551 return (mode
== condition_evaluation_host
);
554 void _initialize_breakpoint (void);
556 /* Are we executing breakpoint commands? */
557 static int executing_breakpoint_commands
;
559 /* Are overlay event breakpoints enabled? */
560 static int overlay_events_enabled
;
562 /* See description in breakpoint.h. */
563 int target_exact_watchpoints
= 0;
565 /* Walk the following statement or block through all breakpoints.
566 ALL_BREAKPOINTS_SAFE does so even if the statement deletes the
567 current breakpoint. */
569 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
571 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
572 for (B = breakpoint_chain; \
573 B ? (TMP=B->next, 1): 0; \
576 /* Similar iterator for the low-level breakpoints. SAFE variant is
577 not provided so update_global_location_list must not be called
578 while executing the block of ALL_BP_LOCATIONS. */
580 #define ALL_BP_LOCATIONS(B,BP_TMP) \
581 for (BP_TMP = bp_locations; \
582 BP_TMP < bp_locations + bp_locations_count && (B = *BP_TMP);\
585 /* Iterates through locations with address ADDRESS for the currently selected
586 program space. BP_LOCP_TMP points to each object. BP_LOCP_START points
587 to where the loop should start from.
588 If BP_LOCP_START is a NULL pointer, the macro automatically seeks the
589 appropriate location to start with. */
591 #define ALL_BP_LOCATIONS_AT_ADDR(BP_LOCP_TMP, BP_LOCP_START, ADDRESS) \
592 for (BP_LOCP_START = BP_LOCP_START == NULL ? get_first_locp_gte_addr (ADDRESS) : BP_LOCP_START, \
593 BP_LOCP_TMP = BP_LOCP_START; \
595 && (BP_LOCP_TMP < bp_locations + bp_locations_count \
596 && (*BP_LOCP_TMP)->address == ADDRESS); \
599 /* Iterator for tracepoints only. */
601 #define ALL_TRACEPOINTS(B) \
602 for (B = breakpoint_chain; B; B = B->next) \
603 if (is_tracepoint (B))
605 /* Chains of all breakpoints defined. */
607 struct breakpoint
*breakpoint_chain
;
609 /* Array is sorted by bp_locations_compare - primarily by the ADDRESS. */
611 static struct bp_location
**bp_locations
;
613 /* Number of elements of BP_LOCATIONS. */
615 static unsigned bp_locations_count
;
617 /* Maximum alignment offset between bp_target_info.PLACED_ADDRESS and
618 ADDRESS for the current elements of BP_LOCATIONS which get a valid
619 result from bp_location_has_shadow. You can use it for roughly
620 limiting the subrange of BP_LOCATIONS to scan for shadow bytes for
621 an address you need to read. */
623 static CORE_ADDR bp_locations_placed_address_before_address_max
;
625 /* Maximum offset plus alignment between bp_target_info.PLACED_ADDRESS
626 + bp_target_info.SHADOW_LEN and ADDRESS for the current elements of
627 BP_LOCATIONS which get a valid result from bp_location_has_shadow.
628 You can use it for roughly limiting the subrange of BP_LOCATIONS to
629 scan for shadow bytes for an address you need to read. */
631 static CORE_ADDR bp_locations_shadow_len_after_address_max
;
633 /* The locations that no longer correspond to any breakpoint, unlinked
634 from the bp_locations array, but for which a hit may still be
635 reported by a target. */
636 VEC(bp_location_p
) *moribund_locations
= NULL
;
638 /* Number of last breakpoint made. */
640 static int breakpoint_count
;
642 /* The value of `breakpoint_count' before the last command that
643 created breakpoints. If the last (break-like) command created more
644 than one breakpoint, then the difference between BREAKPOINT_COUNT
645 and PREV_BREAKPOINT_COUNT is more than one. */
646 static int prev_breakpoint_count
;
648 /* Number of last tracepoint made. */
650 static int tracepoint_count
;
652 static struct cmd_list_element
*breakpoint_set_cmdlist
;
653 static struct cmd_list_element
*breakpoint_show_cmdlist
;
654 struct cmd_list_element
*save_cmdlist
;
656 /* See declaration at breakpoint.h. */
659 breakpoint_find_if (int (*func
) (struct breakpoint
*b
, void *d
),
662 struct breakpoint
*b
= NULL
;
666 if (func (b
, user_data
) != 0)
673 /* Return whether a breakpoint is an active enabled breakpoint. */
675 breakpoint_enabled (struct breakpoint
*b
)
677 return (b
->enable_state
== bp_enabled
);
680 /* Set breakpoint count to NUM. */
683 set_breakpoint_count (int num
)
685 prev_breakpoint_count
= breakpoint_count
;
686 breakpoint_count
= num
;
687 set_internalvar_integer (lookup_internalvar ("bpnum"), num
);
690 /* Used by `start_rbreak_breakpoints' below, to record the current
691 breakpoint count before "rbreak" creates any breakpoint. */
692 static int rbreak_start_breakpoint_count
;
694 /* Called at the start an "rbreak" command to record the first
698 start_rbreak_breakpoints (void)
700 rbreak_start_breakpoint_count
= breakpoint_count
;
703 /* Called at the end of an "rbreak" command to record the last
707 end_rbreak_breakpoints (void)
709 prev_breakpoint_count
= rbreak_start_breakpoint_count
;
712 /* Used in run_command to zero the hit count when a new run starts. */
715 clear_breakpoint_hit_counts (void)
717 struct breakpoint
*b
;
723 /* Allocate a new counted_command_line with reference count of 1.
724 The new structure owns COMMANDS. */
726 static struct counted_command_line
*
727 alloc_counted_command_line (struct command_line
*commands
)
729 struct counted_command_line
*result
= XNEW (struct counted_command_line
);
732 result
->commands
= commands
;
737 /* Increment reference count. This does nothing if CMD is NULL. */
740 incref_counted_command_line (struct counted_command_line
*cmd
)
746 /* Decrement reference count. If the reference count reaches 0,
747 destroy the counted_command_line. Sets *CMDP to NULL. This does
748 nothing if *CMDP is NULL. */
751 decref_counted_command_line (struct counted_command_line
**cmdp
)
755 if (--(*cmdp
)->refc
== 0)
757 free_command_lines (&(*cmdp
)->commands
);
764 /* A cleanup function that calls decref_counted_command_line. */
767 do_cleanup_counted_command_line (void *arg
)
769 decref_counted_command_line ((struct counted_command_line
**) arg
);
772 /* Create a cleanup that calls decref_counted_command_line on the
775 static struct cleanup
*
776 make_cleanup_decref_counted_command_line (struct counted_command_line
**cmdp
)
778 return make_cleanup (do_cleanup_counted_command_line
, cmdp
);
782 /* Return the breakpoint with the specified number, or NULL
783 if the number does not refer to an existing breakpoint. */
786 get_breakpoint (int num
)
788 struct breakpoint
*b
;
791 if (b
->number
== num
)
799 /* Mark locations as "conditions have changed" in case the target supports
800 evaluating conditions on its side. */
803 mark_breakpoint_modified (struct breakpoint
*b
)
805 struct bp_location
*loc
;
807 /* This is only meaningful if the target is
808 evaluating conditions and if the user has
809 opted for condition evaluation on the target's
811 if (gdb_evaluates_breakpoint_condition_p ()
812 || !target_supports_evaluation_of_breakpoint_conditions ())
815 if (!is_breakpoint (b
))
818 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
819 loc
->condition_changed
= condition_modified
;
822 /* Mark location as "conditions have changed" in case the target supports
823 evaluating conditions on its side. */
826 mark_breakpoint_location_modified (struct bp_location
*loc
)
828 /* This is only meaningful if the target is
829 evaluating conditions and if the user has
830 opted for condition evaluation on the target's
832 if (gdb_evaluates_breakpoint_condition_p ()
833 || !target_supports_evaluation_of_breakpoint_conditions ())
837 if (!is_breakpoint (loc
->owner
))
840 loc
->condition_changed
= condition_modified
;
843 /* Sets the condition-evaluation mode using the static global
844 condition_evaluation_mode. */
847 set_condition_evaluation_mode (char *args
, int from_tty
,
848 struct cmd_list_element
*c
)
850 const char *old_mode
, *new_mode
;
852 if ((condition_evaluation_mode_1
== condition_evaluation_target
)
853 && !target_supports_evaluation_of_breakpoint_conditions ())
855 condition_evaluation_mode_1
= condition_evaluation_mode
;
856 warning (_("Target does not support breakpoint condition evaluation.\n"
857 "Using host evaluation mode instead."));
861 new_mode
= translate_condition_evaluation_mode (condition_evaluation_mode_1
);
862 old_mode
= translate_condition_evaluation_mode (condition_evaluation_mode
);
864 /* Flip the switch. Flip it even if OLD_MODE == NEW_MODE as one of the
865 settings was "auto". */
866 condition_evaluation_mode
= condition_evaluation_mode_1
;
868 /* Only update the mode if the user picked a different one. */
869 if (new_mode
!= old_mode
)
871 struct bp_location
*loc
, **loc_tmp
;
872 /* If the user switched to a different evaluation mode, we
873 need to synch the changes with the target as follows:
875 "host" -> "target": Send all (valid) conditions to the target.
876 "target" -> "host": Remove all the conditions from the target.
879 if (new_mode
== condition_evaluation_target
)
881 /* Mark everything modified and synch conditions with the
883 ALL_BP_LOCATIONS (loc
, loc_tmp
)
884 mark_breakpoint_location_modified (loc
);
888 /* Manually mark non-duplicate locations to synch conditions
889 with the target. We do this to remove all the conditions the
890 target knows about. */
891 ALL_BP_LOCATIONS (loc
, loc_tmp
)
892 if (is_breakpoint (loc
->owner
) && loc
->inserted
)
893 loc
->needs_update
= 1;
897 update_global_location_list (UGLL_MAY_INSERT
);
903 /* Shows the current mode of breakpoint condition evaluation. Explicitly shows
904 what "auto" is translating to. */
907 show_condition_evaluation_mode (struct ui_file
*file
, int from_tty
,
908 struct cmd_list_element
*c
, const char *value
)
910 if (condition_evaluation_mode
== condition_evaluation_auto
)
911 fprintf_filtered (file
,
912 _("Breakpoint condition evaluation "
913 "mode is %s (currently %s).\n"),
915 breakpoint_condition_evaluation_mode ());
917 fprintf_filtered (file
, _("Breakpoint condition evaluation mode is %s.\n"),
921 /* A comparison function for bp_location AP and BP that is used by
922 bsearch. This comparison function only cares about addresses, unlike
923 the more general bp_locations_compare function. */
926 bp_locations_compare_addrs (const void *ap
, const void *bp
)
928 const struct bp_location
*a
= *(const struct bp_location
**) ap
;
929 const struct bp_location
*b
= *(const struct bp_location
**) bp
;
931 if (a
->address
== b
->address
)
934 return ((a
->address
> b
->address
) - (a
->address
< b
->address
));
937 /* Helper function to skip all bp_locations with addresses
938 less than ADDRESS. It returns the first bp_location that
939 is greater than or equal to ADDRESS. If none is found, just
942 static struct bp_location
**
943 get_first_locp_gte_addr (CORE_ADDR address
)
945 struct bp_location dummy_loc
;
946 struct bp_location
*dummy_locp
= &dummy_loc
;
947 struct bp_location
**locp_found
= NULL
;
949 /* Initialize the dummy location's address field. */
950 dummy_loc
.address
= address
;
952 /* Find a close match to the first location at ADDRESS. */
953 locp_found
= ((struct bp_location
**)
954 bsearch (&dummy_locp
, bp_locations
, bp_locations_count
,
955 sizeof (struct bp_location
**),
956 bp_locations_compare_addrs
));
958 /* Nothing was found, nothing left to do. */
959 if (locp_found
== NULL
)
962 /* We may have found a location that is at ADDRESS but is not the first in the
963 location's list. Go backwards (if possible) and locate the first one. */
964 while ((locp_found
- 1) >= bp_locations
965 && (*(locp_found
- 1))->address
== address
)
972 set_breakpoint_condition (struct breakpoint
*b
, const char *exp
,
975 xfree (b
->cond_string
);
976 b
->cond_string
= NULL
;
978 if (is_watchpoint (b
))
980 struct watchpoint
*w
= (struct watchpoint
*) b
;
982 w
->cond_exp
.reset ();
986 struct bp_location
*loc
;
988 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
992 /* No need to free the condition agent expression
993 bytecode (if we have one). We will handle this
994 when we go through update_global_location_list. */
1001 printf_filtered (_("Breakpoint %d now unconditional.\n"), b
->number
);
1005 const char *arg
= exp
;
1007 /* I don't know if it matters whether this is the string the user
1008 typed in or the decompiled expression. */
1009 b
->cond_string
= xstrdup (arg
);
1010 b
->condition_not_parsed
= 0;
1012 if (is_watchpoint (b
))
1014 struct watchpoint
*w
= (struct watchpoint
*) b
;
1016 innermost_block
= NULL
;
1018 w
->cond_exp
= parse_exp_1 (&arg
, 0, 0, 0);
1020 error (_("Junk at end of expression"));
1021 w
->cond_exp_valid_block
= innermost_block
;
1025 struct bp_location
*loc
;
1027 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1031 parse_exp_1 (&arg
, loc
->address
,
1032 block_for_pc (loc
->address
), 0);
1034 error (_("Junk at end of expression"));
1038 mark_breakpoint_modified (b
);
1040 observer_notify_breakpoint_modified (b
);
1043 /* Completion for the "condition" command. */
1046 condition_completer (struct cmd_list_element
*cmd
,
1047 completion_tracker
&tracker
,
1048 const char *text
, const char *word
)
1052 text
= skip_spaces_const (text
);
1053 space
= skip_to_space_const (text
);
1057 struct breakpoint
*b
;
1058 VEC (char_ptr
) *result
= NULL
;
1062 /* We don't support completion of history indices. */
1063 if (!isdigit (text
[1]))
1064 complete_internalvar (tracker
, &text
[1]);
1068 /* We're completing the breakpoint number. */
1069 len
= strlen (text
);
1075 xsnprintf (number
, sizeof (number
), "%d", b
->number
);
1077 if (strncmp (number
, text
, len
) == 0)
1079 gdb::unique_xmalloc_ptr
<char> copy (xstrdup (number
));
1080 tracker
.add_completion (std::move (copy
));
1087 /* We're completing the expression part. */
1088 text
= skip_spaces_const (space
);
1089 expression_completer (cmd
, tracker
, text
, word
);
1092 /* condition N EXP -- set break condition of breakpoint N to EXP. */
1095 condition_command (char *arg
, int from_tty
)
1097 struct breakpoint
*b
;
1102 error_no_arg (_("breakpoint number"));
1105 bnum
= get_number (&p
);
1107 error (_("Bad breakpoint argument: '%s'"), arg
);
1110 if (b
->number
== bnum
)
1112 /* Check if this breakpoint has a "stop" method implemented in an
1113 extension language. This method and conditions entered into GDB
1114 from the CLI are mutually exclusive. */
1115 const struct extension_language_defn
*extlang
1116 = get_breakpoint_cond_ext_lang (b
, EXT_LANG_NONE
);
1118 if (extlang
!= NULL
)
1120 error (_("Only one stop condition allowed. There is currently"
1121 " a %s stop condition defined for this breakpoint."),
1122 ext_lang_capitalized_name (extlang
));
1124 set_breakpoint_condition (b
, p
, from_tty
);
1126 if (is_breakpoint (b
))
1127 update_global_location_list (UGLL_MAY_INSERT
);
1132 error (_("No breakpoint number %d."), bnum
);
1135 /* Check that COMMAND do not contain commands that are suitable
1136 only for tracepoints and not suitable for ordinary breakpoints.
1137 Throw if any such commands is found. */
1140 check_no_tracepoint_commands (struct command_line
*commands
)
1142 struct command_line
*c
;
1144 for (c
= commands
; c
; c
= c
->next
)
1148 if (c
->control_type
== while_stepping_control
)
1149 error (_("The 'while-stepping' command can "
1150 "only be used for tracepoints"));
1152 for (i
= 0; i
< c
->body_count
; ++i
)
1153 check_no_tracepoint_commands ((c
->body_list
)[i
]);
1155 /* Not that command parsing removes leading whitespace and comment
1156 lines and also empty lines. So, we only need to check for
1157 command directly. */
1158 if (strstr (c
->line
, "collect ") == c
->line
)
1159 error (_("The 'collect' command can only be used for tracepoints"));
1161 if (strstr (c
->line
, "teval ") == c
->line
)
1162 error (_("The 'teval' command can only be used for tracepoints"));
1166 struct longjmp_breakpoint
: public breakpoint
1168 ~longjmp_breakpoint () override
;
1171 /* Encapsulate tests for different types of tracepoints. */
1174 is_tracepoint_type (bptype type
)
1176 return (type
== bp_tracepoint
1177 || type
== bp_fast_tracepoint
1178 || type
== bp_static_tracepoint
);
1182 is_longjmp_type (bptype type
)
1184 return type
== bp_longjmp
|| type
== bp_exception
;
1188 is_tracepoint (const struct breakpoint
*b
)
1190 return is_tracepoint_type (b
->type
);
1193 /* Factory function to create an appropriate instance of breakpoint given
1196 static std::unique_ptr
<breakpoint
>
1197 new_breakpoint_from_type (bptype type
)
1201 if (is_tracepoint_type (type
))
1202 b
= new tracepoint ();
1203 else if (is_longjmp_type (type
))
1204 b
= new longjmp_breakpoint ();
1206 b
= new breakpoint ();
1208 return std::unique_ptr
<breakpoint
> (b
);
1211 /* A helper function that validates that COMMANDS are valid for a
1212 breakpoint. This function will throw an exception if a problem is
1216 validate_commands_for_breakpoint (struct breakpoint
*b
,
1217 struct command_line
*commands
)
1219 if (is_tracepoint (b
))
1221 struct tracepoint
*t
= (struct tracepoint
*) b
;
1222 struct command_line
*c
;
1223 struct command_line
*while_stepping
= 0;
1225 /* Reset the while-stepping step count. The previous commands
1226 might have included a while-stepping action, while the new
1230 /* We need to verify that each top-level element of commands is
1231 valid for tracepoints, that there's at most one
1232 while-stepping element, and that the while-stepping's body
1233 has valid tracing commands excluding nested while-stepping.
1234 We also need to validate the tracepoint action line in the
1235 context of the tracepoint --- validate_actionline actually
1236 has side effects, like setting the tracepoint's
1237 while-stepping STEP_COUNT, in addition to checking if the
1238 collect/teval actions parse and make sense in the
1239 tracepoint's context. */
1240 for (c
= commands
; c
; c
= c
->next
)
1242 if (c
->control_type
== while_stepping_control
)
1244 if (b
->type
== bp_fast_tracepoint
)
1245 error (_("The 'while-stepping' command "
1246 "cannot be used for fast tracepoint"));
1247 else if (b
->type
== bp_static_tracepoint
)
1248 error (_("The 'while-stepping' command "
1249 "cannot be used for static tracepoint"));
1252 error (_("The 'while-stepping' command "
1253 "can be used only once"));
1258 validate_actionline (c
->line
, b
);
1262 struct command_line
*c2
;
1264 gdb_assert (while_stepping
->body_count
== 1);
1265 c2
= while_stepping
->body_list
[0];
1266 for (; c2
; c2
= c2
->next
)
1268 if (c2
->control_type
== while_stepping_control
)
1269 error (_("The 'while-stepping' command cannot be nested"));
1275 check_no_tracepoint_commands (commands
);
1279 /* Return a vector of all the static tracepoints set at ADDR. The
1280 caller is responsible for releasing the vector. */
1283 static_tracepoints_here (CORE_ADDR addr
)
1285 struct breakpoint
*b
;
1286 VEC(breakpoint_p
) *found
= 0;
1287 struct bp_location
*loc
;
1290 if (b
->type
== bp_static_tracepoint
)
1292 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1293 if (loc
->address
== addr
)
1294 VEC_safe_push(breakpoint_p
, found
, b
);
1300 /* Set the command list of B to COMMANDS. If breakpoint is tracepoint,
1301 validate that only allowed commands are included. */
1304 breakpoint_set_commands (struct breakpoint
*b
,
1305 command_line_up
&&commands
)
1307 validate_commands_for_breakpoint (b
, commands
.get ());
1309 decref_counted_command_line (&b
->commands
);
1310 b
->commands
= alloc_counted_command_line (commands
.release ());
1311 observer_notify_breakpoint_modified (b
);
1314 /* Set the internal `silent' flag on the breakpoint. Note that this
1315 is not the same as the "silent" that may appear in the breakpoint's
1319 breakpoint_set_silent (struct breakpoint
*b
, int silent
)
1321 int old_silent
= b
->silent
;
1324 if (old_silent
!= silent
)
1325 observer_notify_breakpoint_modified (b
);
1328 /* Set the thread for this breakpoint. If THREAD is -1, make the
1329 breakpoint work for any thread. */
1332 breakpoint_set_thread (struct breakpoint
*b
, int thread
)
1334 int old_thread
= b
->thread
;
1337 if (old_thread
!= thread
)
1338 observer_notify_breakpoint_modified (b
);
1341 /* Set the task for this breakpoint. If TASK is 0, make the
1342 breakpoint work for any task. */
1345 breakpoint_set_task (struct breakpoint
*b
, int task
)
1347 int old_task
= b
->task
;
1350 if (old_task
!= task
)
1351 observer_notify_breakpoint_modified (b
);
1355 check_tracepoint_command (char *line
, void *closure
)
1357 struct breakpoint
*b
= (struct breakpoint
*) closure
;
1359 validate_actionline (line
, b
);
1362 /* A structure used to pass information through
1363 map_breakpoint_numbers. */
1365 struct commands_info
1367 /* True if the command was typed at a tty. */
1370 /* The breakpoint range spec. */
1373 /* Non-NULL if the body of the commands are being read from this
1374 already-parsed command. */
1375 struct command_line
*control
;
1377 /* The command lines read from the user, or NULL if they have not
1379 struct counted_command_line
*cmd
;
1382 /* A callback for map_breakpoint_numbers that sets the commands for
1383 commands_command. */
1386 do_map_commands_command (struct breakpoint
*b
, void *data
)
1388 struct commands_info
*info
= (struct commands_info
*) data
;
1390 if (info
->cmd
== NULL
)
1394 if (info
->control
!= NULL
)
1395 l
= copy_command_lines (info
->control
->body_list
[0]);
1398 struct cleanup
*old_chain
;
1401 str
= xstrprintf (_("Type commands for breakpoint(s) "
1402 "%s, one per line."),
1405 old_chain
= make_cleanup (xfree
, str
);
1407 l
= read_command_lines (str
,
1410 ? check_tracepoint_command
: 0),
1413 do_cleanups (old_chain
);
1416 info
->cmd
= alloc_counted_command_line (l
.release ());
1419 /* If a breakpoint was on the list more than once, we don't need to
1421 if (b
->commands
!= info
->cmd
)
1423 validate_commands_for_breakpoint (b
, info
->cmd
->commands
);
1424 incref_counted_command_line (info
->cmd
);
1425 decref_counted_command_line (&b
->commands
);
1426 b
->commands
= info
->cmd
;
1427 observer_notify_breakpoint_modified (b
);
1432 commands_command_1 (const char *arg
, int from_tty
,
1433 struct command_line
*control
)
1435 struct cleanup
*cleanups
;
1436 struct commands_info info
;
1438 info
.from_tty
= from_tty
;
1439 info
.control
= control
;
1441 /* If we read command lines from the user, then `info' will hold an
1442 extra reference to the commands that we must clean up. */
1443 cleanups
= make_cleanup_decref_counted_command_line (&info
.cmd
);
1445 std::string new_arg
;
1447 if (arg
== NULL
|| !*arg
)
1449 if (breakpoint_count
- prev_breakpoint_count
> 1)
1450 new_arg
= string_printf ("%d-%d", prev_breakpoint_count
+ 1,
1452 else if (breakpoint_count
> 0)
1453 new_arg
= string_printf ("%d", breakpoint_count
);
1458 info
.arg
= new_arg
.c_str ();
1460 map_breakpoint_numbers (info
.arg
, do_map_commands_command
, &info
);
1462 if (info
.cmd
== NULL
)
1463 error (_("No breakpoints specified."));
1465 do_cleanups (cleanups
);
1469 commands_command (char *arg
, int from_tty
)
1471 commands_command_1 (arg
, from_tty
, NULL
);
1474 /* Like commands_command, but instead of reading the commands from
1475 input stream, takes them from an already parsed command structure.
1477 This is used by cli-script.c to DTRT with breakpoint commands
1478 that are part of if and while bodies. */
1479 enum command_control_type
1480 commands_from_control_command (const char *arg
, struct command_line
*cmd
)
1482 commands_command_1 (arg
, 0, cmd
);
1483 return simple_control
;
1486 /* Return non-zero if BL->TARGET_INFO contains valid information. */
1489 bp_location_has_shadow (struct bp_location
*bl
)
1491 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
1495 if (bl
->target_info
.shadow_len
== 0)
1496 /* BL isn't valid, or doesn't shadow memory. */
1501 /* Update BUF, which is LEN bytes read from the target address
1502 MEMADDR, by replacing a memory breakpoint with its shadowed
1505 If READBUF is not NULL, this buffer must not overlap with the of
1506 the breakpoint location's shadow_contents buffer. Otherwise, a
1507 failed assertion internal error will be raised. */
1510 one_breakpoint_xfer_memory (gdb_byte
*readbuf
, gdb_byte
*writebuf
,
1511 const gdb_byte
*writebuf_org
,
1512 ULONGEST memaddr
, LONGEST len
,
1513 struct bp_target_info
*target_info
,
1514 struct gdbarch
*gdbarch
)
1516 /* Now do full processing of the found relevant range of elements. */
1517 CORE_ADDR bp_addr
= 0;
1521 if (!breakpoint_address_match (target_info
->placed_address_space
, 0,
1522 current_program_space
->aspace
, 0))
1524 /* The breakpoint is inserted in a different address space. */
1528 /* Addresses and length of the part of the breakpoint that
1530 bp_addr
= target_info
->placed_address
;
1531 bp_size
= target_info
->shadow_len
;
1533 if (bp_addr
+ bp_size
<= memaddr
)
1535 /* The breakpoint is entirely before the chunk of memory we are
1540 if (bp_addr
>= memaddr
+ len
)
1542 /* The breakpoint is entirely after the chunk of memory we are
1547 /* Offset within shadow_contents. */
1548 if (bp_addr
< memaddr
)
1550 /* Only copy the second part of the breakpoint. */
1551 bp_size
-= memaddr
- bp_addr
;
1552 bptoffset
= memaddr
- bp_addr
;
1556 if (bp_addr
+ bp_size
> memaddr
+ len
)
1558 /* Only copy the first part of the breakpoint. */
1559 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
1562 if (readbuf
!= NULL
)
1564 /* Verify that the readbuf buffer does not overlap with the
1565 shadow_contents buffer. */
1566 gdb_assert (target_info
->shadow_contents
>= readbuf
+ len
1567 || readbuf
>= (target_info
->shadow_contents
1568 + target_info
->shadow_len
));
1570 /* Update the read buffer with this inserted breakpoint's
1572 memcpy (readbuf
+ bp_addr
- memaddr
,
1573 target_info
->shadow_contents
+ bptoffset
, bp_size
);
1577 const unsigned char *bp
;
1578 CORE_ADDR addr
= target_info
->reqstd_address
;
1581 /* Update the shadow with what we want to write to memory. */
1582 memcpy (target_info
->shadow_contents
+ bptoffset
,
1583 writebuf_org
+ bp_addr
- memaddr
, bp_size
);
1585 /* Determine appropriate breakpoint contents and size for this
1587 bp
= gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &placed_size
);
1589 /* Update the final write buffer with this inserted
1590 breakpoint's INSN. */
1591 memcpy (writebuf
+ bp_addr
- memaddr
, bp
+ bptoffset
, bp_size
);
1595 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
1596 by replacing any memory breakpoints with their shadowed contents.
1598 If READBUF is not NULL, this buffer must not overlap with any of
1599 the breakpoint location's shadow_contents buffers. Otherwise,
1600 a failed assertion internal error will be raised.
1602 The range of shadowed area by each bp_location is:
1603 bl->address - bp_locations_placed_address_before_address_max
1604 up to bl->address + bp_locations_shadow_len_after_address_max
1605 The range we were requested to resolve shadows for is:
1606 memaddr ... memaddr + len
1607 Thus the safe cutoff boundaries for performance optimization are
1608 memaddr + len <= (bl->address
1609 - bp_locations_placed_address_before_address_max)
1611 bl->address + bp_locations_shadow_len_after_address_max <= memaddr */
1614 breakpoint_xfer_memory (gdb_byte
*readbuf
, gdb_byte
*writebuf
,
1615 const gdb_byte
*writebuf_org
,
1616 ULONGEST memaddr
, LONGEST len
)
1618 /* Left boundary, right boundary and median element of our binary
1620 unsigned bc_l
, bc_r
, bc
;
1622 /* Find BC_L which is a leftmost element which may affect BUF
1623 content. It is safe to report lower value but a failure to
1624 report higher one. */
1627 bc_r
= bp_locations_count
;
1628 while (bc_l
+ 1 < bc_r
)
1630 struct bp_location
*bl
;
1632 bc
= (bc_l
+ bc_r
) / 2;
1633 bl
= bp_locations
[bc
];
1635 /* Check first BL->ADDRESS will not overflow due to the added
1636 constant. Then advance the left boundary only if we are sure
1637 the BC element can in no way affect the BUF content (MEMADDR
1638 to MEMADDR + LEN range).
1640 Use the BP_LOCATIONS_SHADOW_LEN_AFTER_ADDRESS_MAX safety
1641 offset so that we cannot miss a breakpoint with its shadow
1642 range tail still reaching MEMADDR. */
1644 if ((bl
->address
+ bp_locations_shadow_len_after_address_max
1646 && (bl
->address
+ bp_locations_shadow_len_after_address_max
1653 /* Due to the binary search above, we need to make sure we pick the
1654 first location that's at BC_L's address. E.g., if there are
1655 multiple locations at the same address, BC_L may end up pointing
1656 at a duplicate location, and miss the "master"/"inserted"
1657 location. Say, given locations L1, L2 and L3 at addresses A and
1660 L1@A, L2@A, L3@B, ...
1662 BC_L could end up pointing at location L2, while the "master"
1663 location could be L1. Since the `loc->inserted' flag is only set
1664 on "master" locations, we'd forget to restore the shadow of L1
1667 && bp_locations
[bc_l
]->address
== bp_locations
[bc_l
- 1]->address
)
1670 /* Now do full processing of the found relevant range of elements. */
1672 for (bc
= bc_l
; bc
< bp_locations_count
; bc
++)
1674 struct bp_location
*bl
= bp_locations
[bc
];
1676 /* bp_location array has BL->OWNER always non-NULL. */
1677 if (bl
->owner
->type
== bp_none
)
1678 warning (_("reading through apparently deleted breakpoint #%d?"),
1681 /* Performance optimization: any further element can no longer affect BUF
1684 if (bl
->address
>= bp_locations_placed_address_before_address_max
1685 && memaddr
+ len
<= (bl
->address
1686 - bp_locations_placed_address_before_address_max
))
1689 if (!bp_location_has_shadow (bl
))
1692 one_breakpoint_xfer_memory (readbuf
, writebuf
, writebuf_org
,
1693 memaddr
, len
, &bl
->target_info
, bl
->gdbarch
);
1699 /* Return true if BPT is either a software breakpoint or a hardware
1703 is_breakpoint (const struct breakpoint
*bpt
)
1705 return (bpt
->type
== bp_breakpoint
1706 || bpt
->type
== bp_hardware_breakpoint
1707 || bpt
->type
== bp_dprintf
);
1710 /* Return true if BPT is of any hardware watchpoint kind. */
1713 is_hardware_watchpoint (const struct breakpoint
*bpt
)
1715 return (bpt
->type
== bp_hardware_watchpoint
1716 || bpt
->type
== bp_read_watchpoint
1717 || bpt
->type
== bp_access_watchpoint
);
1720 /* Return true if BPT is of any watchpoint kind, hardware or
1724 is_watchpoint (const struct breakpoint
*bpt
)
1726 return (is_hardware_watchpoint (bpt
)
1727 || bpt
->type
== bp_watchpoint
);
1730 /* Returns true if the current thread and its running state are safe
1731 to evaluate or update watchpoint B. Watchpoints on local
1732 expressions need to be evaluated in the context of the thread that
1733 was current when the watchpoint was created, and, that thread needs
1734 to be stopped to be able to select the correct frame context.
1735 Watchpoints on global expressions can be evaluated on any thread,
1736 and in any state. It is presently left to the target allowing
1737 memory accesses when threads are running. */
1740 watchpoint_in_thread_scope (struct watchpoint
*b
)
1742 return (b
->pspace
== current_program_space
1743 && (ptid_equal (b
->watchpoint_thread
, null_ptid
)
1744 || (ptid_equal (inferior_ptid
, b
->watchpoint_thread
)
1745 && !is_executing (inferior_ptid
))));
1748 /* Set watchpoint B to disp_del_at_next_stop, even including its possible
1749 associated bp_watchpoint_scope breakpoint. */
1752 watchpoint_del_at_next_stop (struct watchpoint
*w
)
1754 if (w
->related_breakpoint
!= w
)
1756 gdb_assert (w
->related_breakpoint
->type
== bp_watchpoint_scope
);
1757 gdb_assert (w
->related_breakpoint
->related_breakpoint
== w
);
1758 w
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
1759 w
->related_breakpoint
->related_breakpoint
= w
->related_breakpoint
;
1760 w
->related_breakpoint
= w
;
1762 w
->disposition
= disp_del_at_next_stop
;
1765 /* Extract a bitfield value from value VAL using the bit parameters contained in
1768 static struct value
*
1769 extract_bitfield_from_watchpoint_value (struct watchpoint
*w
, struct value
*val
)
1771 struct value
*bit_val
;
1776 bit_val
= allocate_value (value_type (val
));
1778 unpack_value_bitfield (bit_val
,
1781 value_contents_for_printing (val
),
1788 /* Allocate a dummy location and add it to B, which must be a software
1789 watchpoint. This is required because even if a software watchpoint
1790 is not watching any memory, bpstat_stop_status requires a location
1791 to be able to report stops. */
1794 software_watchpoint_add_no_memory_location (struct breakpoint
*b
,
1795 struct program_space
*pspace
)
1797 gdb_assert (b
->type
== bp_watchpoint
&& b
->loc
== NULL
);
1799 b
->loc
= allocate_bp_location (b
);
1800 b
->loc
->pspace
= pspace
;
1801 b
->loc
->address
= -1;
1802 b
->loc
->length
= -1;
1805 /* Returns true if B is a software watchpoint that is not watching any
1806 memory (e.g., "watch $pc"). */
1809 is_no_memory_software_watchpoint (struct breakpoint
*b
)
1811 return (b
->type
== bp_watchpoint
1813 && b
->loc
->next
== NULL
1814 && b
->loc
->address
== -1
1815 && b
->loc
->length
== -1);
1818 /* Assuming that B is a watchpoint:
1819 - Reparse watchpoint expression, if REPARSE is non-zero
1820 - Evaluate expression and store the result in B->val
1821 - Evaluate the condition if there is one, and store the result
1823 - Update the list of values that must be watched in B->loc.
1825 If the watchpoint disposition is disp_del_at_next_stop, then do
1826 nothing. If this is local watchpoint that is out of scope, delete
1829 Even with `set breakpoint always-inserted on' the watchpoints are
1830 removed + inserted on each stop here. Normal breakpoints must
1831 never be removed because they might be missed by a running thread
1832 when debugging in non-stop mode. On the other hand, hardware
1833 watchpoints (is_hardware_watchpoint; processed here) are specific
1834 to each LWP since they are stored in each LWP's hardware debug
1835 registers. Therefore, such LWP must be stopped first in order to
1836 be able to modify its hardware watchpoints.
1838 Hardware watchpoints must be reset exactly once after being
1839 presented to the user. It cannot be done sooner, because it would
1840 reset the data used to present the watchpoint hit to the user. And
1841 it must not be done later because it could display the same single
1842 watchpoint hit during multiple GDB stops. Note that the latter is
1843 relevant only to the hardware watchpoint types bp_read_watchpoint
1844 and bp_access_watchpoint. False hit by bp_hardware_watchpoint is
1845 not user-visible - its hit is suppressed if the memory content has
1848 The following constraints influence the location where we can reset
1849 hardware watchpoints:
1851 * target_stopped_by_watchpoint and target_stopped_data_address are
1852 called several times when GDB stops.
1855 * Multiple hardware watchpoints can be hit at the same time,
1856 causing GDB to stop. GDB only presents one hardware watchpoint
1857 hit at a time as the reason for stopping, and all the other hits
1858 are presented later, one after the other, each time the user
1859 requests the execution to be resumed. Execution is not resumed
1860 for the threads still having pending hit event stored in
1861 LWP_INFO->STATUS. While the watchpoint is already removed from
1862 the inferior on the first stop the thread hit event is kept being
1863 reported from its cached value by linux_nat_stopped_data_address
1864 until the real thread resume happens after the watchpoint gets
1865 presented and thus its LWP_INFO->STATUS gets reset.
1867 Therefore the hardware watchpoint hit can get safely reset on the
1868 watchpoint removal from inferior. */
1871 update_watchpoint (struct watchpoint
*b
, int reparse
)
1873 int within_current_scope
;
1874 struct frame_id saved_frame_id
;
1877 /* If this is a local watchpoint, we only want to check if the
1878 watchpoint frame is in scope if the current thread is the thread
1879 that was used to create the watchpoint. */
1880 if (!watchpoint_in_thread_scope (b
))
1883 if (b
->disposition
== disp_del_at_next_stop
)
1888 /* Determine if the watchpoint is within scope. */
1889 if (b
->exp_valid_block
== NULL
)
1890 within_current_scope
= 1;
1893 struct frame_info
*fi
= get_current_frame ();
1894 struct gdbarch
*frame_arch
= get_frame_arch (fi
);
1895 CORE_ADDR frame_pc
= get_frame_pc (fi
);
1897 /* If we're at a point where the stack has been destroyed
1898 (e.g. in a function epilogue), unwinding may not work
1899 properly. Do not attempt to recreate locations at this
1900 point. See similar comments in watchpoint_check. */
1901 if (gdbarch_stack_frame_destroyed_p (frame_arch
, frame_pc
))
1904 /* Save the current frame's ID so we can restore it after
1905 evaluating the watchpoint expression on its own frame. */
1906 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
1907 took a frame parameter, so that we didn't have to change the
1910 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
1912 fi
= frame_find_by_id (b
->watchpoint_frame
);
1913 within_current_scope
= (fi
!= NULL
);
1914 if (within_current_scope
)
1918 /* We don't free locations. They are stored in the bp_location array
1919 and update_global_location_list will eventually delete them and
1920 remove breakpoints if needed. */
1923 if (within_current_scope
&& reparse
)
1928 s
= b
->exp_string_reparse
? b
->exp_string_reparse
: b
->exp_string
;
1929 b
->exp
= parse_exp_1 (&s
, 0, b
->exp_valid_block
, 0);
1930 /* If the meaning of expression itself changed, the old value is
1931 no longer relevant. We don't want to report a watchpoint hit
1932 to the user when the old value and the new value may actually
1933 be completely different objects. */
1934 value_free (b
->val
);
1938 /* Note that unlike with breakpoints, the watchpoint's condition
1939 expression is stored in the breakpoint object, not in the
1940 locations (re)created below. */
1941 if (b
->cond_string
!= NULL
)
1943 b
->cond_exp
.reset ();
1946 b
->cond_exp
= parse_exp_1 (&s
, 0, b
->cond_exp_valid_block
, 0);
1950 /* If we failed to parse the expression, for example because
1951 it refers to a global variable in a not-yet-loaded shared library,
1952 don't try to insert watchpoint. We don't automatically delete
1953 such watchpoint, though, since failure to parse expression
1954 is different from out-of-scope watchpoint. */
1955 if (!target_has_execution
)
1957 /* Without execution, memory can't change. No use to try and
1958 set watchpoint locations. The watchpoint will be reset when
1959 the target gains execution, through breakpoint_re_set. */
1960 if (!can_use_hw_watchpoints
)
1962 if (b
->ops
->works_in_software_mode (b
))
1963 b
->type
= bp_watchpoint
;
1965 error (_("Can't set read/access watchpoint when "
1966 "hardware watchpoints are disabled."));
1969 else if (within_current_scope
&& b
->exp
)
1972 struct value
*val_chain
, *v
, *result
, *next
;
1973 struct program_space
*frame_pspace
;
1975 fetch_subexp_value (b
->exp
.get (), &pc
, &v
, &result
, &val_chain
, 0);
1977 /* Avoid setting b->val if it's already set. The meaning of
1978 b->val is 'the last value' user saw, and we should update
1979 it only if we reported that last value to user. As it
1980 happens, the code that reports it updates b->val directly.
1981 We don't keep track of the memory value for masked
1983 if (!b
->val_valid
&& !is_masked_watchpoint (b
))
1985 if (b
->val_bitsize
!= 0)
1987 v
= extract_bitfield_from_watchpoint_value (b
, v
);
1995 frame_pspace
= get_frame_program_space (get_selected_frame (NULL
));
1997 /* Look at each value on the value chain. */
1998 for (v
= val_chain
; v
; v
= value_next (v
))
2000 /* If it's a memory location, and GDB actually needed
2001 its contents to evaluate the expression, then we
2002 must watch it. If the first value returned is
2003 still lazy, that means an error occurred reading it;
2004 watch it anyway in case it becomes readable. */
2005 if (VALUE_LVAL (v
) == lval_memory
2006 && (v
== val_chain
|| ! value_lazy (v
)))
2008 struct type
*vtype
= check_typedef (value_type (v
));
2010 /* We only watch structs and arrays if user asked
2011 for it explicitly, never if they just happen to
2012 appear in the middle of some value chain. */
2014 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
2015 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
2018 enum target_hw_bp_type type
;
2019 struct bp_location
*loc
, **tmp
;
2020 int bitpos
= 0, bitsize
= 0;
2022 if (value_bitsize (v
) != 0)
2024 /* Extract the bit parameters out from the bitfield
2026 bitpos
= value_bitpos (v
);
2027 bitsize
= value_bitsize (v
);
2029 else if (v
== result
&& b
->val_bitsize
!= 0)
2031 /* If VAL_BITSIZE != 0 then RESULT is actually a bitfield
2032 lvalue whose bit parameters are saved in the fields
2033 VAL_BITPOS and VAL_BITSIZE. */
2034 bitpos
= b
->val_bitpos
;
2035 bitsize
= b
->val_bitsize
;
2038 addr
= value_address (v
);
2041 /* Skip the bytes that don't contain the bitfield. */
2046 if (b
->type
== bp_read_watchpoint
)
2048 else if (b
->type
== bp_access_watchpoint
)
2051 loc
= allocate_bp_location (b
);
2052 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
2055 loc
->gdbarch
= get_type_arch (value_type (v
));
2057 loc
->pspace
= frame_pspace
;
2058 loc
->address
= addr
;
2062 /* Just cover the bytes that make up the bitfield. */
2063 loc
->length
= ((bitpos
% 8) + bitsize
+ 7) / 8;
2066 loc
->length
= TYPE_LENGTH (value_type (v
));
2068 loc
->watchpoint_type
= type
;
2073 /* Change the type of breakpoint between hardware assisted or
2074 an ordinary watchpoint depending on the hardware support
2075 and free hardware slots. REPARSE is set when the inferior
2080 enum bp_loc_type loc_type
;
2081 struct bp_location
*bl
;
2083 reg_cnt
= can_use_hardware_watchpoint (val_chain
);
2087 int i
, target_resources_ok
, other_type_used
;
2090 /* Use an exact watchpoint when there's only one memory region to be
2091 watched, and only one debug register is needed to watch it. */
2092 b
->exact
= target_exact_watchpoints
&& reg_cnt
== 1;
2094 /* We need to determine how many resources are already
2095 used for all other hardware watchpoints plus this one
2096 to see if we still have enough resources to also fit
2097 this watchpoint in as well. */
2099 /* If this is a software watchpoint, we try to turn it
2100 to a hardware one -- count resources as if B was of
2101 hardware watchpoint type. */
2103 if (type
== bp_watchpoint
)
2104 type
= bp_hardware_watchpoint
;
2106 /* This watchpoint may or may not have been placed on
2107 the list yet at this point (it won't be in the list
2108 if we're trying to create it for the first time,
2109 through watch_command), so always account for it
2112 /* Count resources used by all watchpoints except B. */
2113 i
= hw_watchpoint_used_count_others (b
, type
, &other_type_used
);
2115 /* Add in the resources needed for B. */
2116 i
+= hw_watchpoint_use_count (b
);
2119 = target_can_use_hardware_watchpoint (type
, i
, other_type_used
);
2120 if (target_resources_ok
<= 0)
2122 int sw_mode
= b
->ops
->works_in_software_mode (b
);
2124 if (target_resources_ok
== 0 && !sw_mode
)
2125 error (_("Target does not support this type of "
2126 "hardware watchpoint."));
2127 else if (target_resources_ok
< 0 && !sw_mode
)
2128 error (_("There are not enough available hardware "
2129 "resources for this watchpoint."));
2131 /* Downgrade to software watchpoint. */
2132 b
->type
= bp_watchpoint
;
2136 /* If this was a software watchpoint, we've just
2137 found we have enough resources to turn it to a
2138 hardware watchpoint. Otherwise, this is a
2143 else if (!b
->ops
->works_in_software_mode (b
))
2145 if (!can_use_hw_watchpoints
)
2146 error (_("Can't set read/access watchpoint when "
2147 "hardware watchpoints are disabled."));
2149 error (_("Expression cannot be implemented with "
2150 "read/access watchpoint."));
2153 b
->type
= bp_watchpoint
;
2155 loc_type
= (b
->type
== bp_watchpoint
? bp_loc_other
2156 : bp_loc_hardware_watchpoint
);
2157 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
2158 bl
->loc_type
= loc_type
;
2161 for (v
= val_chain
; v
; v
= next
)
2163 next
= value_next (v
);
2168 /* If a software watchpoint is not watching any memory, then the
2169 above left it without any location set up. But,
2170 bpstat_stop_status requires a location to be able to report
2171 stops, so make sure there's at least a dummy one. */
2172 if (b
->type
== bp_watchpoint
&& b
->loc
== NULL
)
2173 software_watchpoint_add_no_memory_location (b
, frame_pspace
);
2175 else if (!within_current_scope
)
2177 printf_filtered (_("\
2178 Watchpoint %d deleted because the program has left the block\n\
2179 in which its expression is valid.\n"),
2181 watchpoint_del_at_next_stop (b
);
2184 /* Restore the selected frame. */
2186 select_frame (frame_find_by_id (saved_frame_id
));
2190 /* Returns 1 iff breakpoint location should be
2191 inserted in the inferior. We don't differentiate the type of BL's owner
2192 (breakpoint vs. tracepoint), although insert_location in tracepoint's
2193 breakpoint_ops is not defined, because in insert_bp_location,
2194 tracepoint's insert_location will not be called. */
2196 should_be_inserted (struct bp_location
*bl
)
2198 if (bl
->owner
== NULL
|| !breakpoint_enabled (bl
->owner
))
2201 if (bl
->owner
->disposition
== disp_del_at_next_stop
)
2204 if (!bl
->enabled
|| bl
->shlib_disabled
|| bl
->duplicate
)
2207 if (user_breakpoint_p (bl
->owner
) && bl
->pspace
->executing_startup
)
2210 /* This is set for example, when we're attached to the parent of a
2211 vfork, and have detached from the child. The child is running
2212 free, and we expect it to do an exec or exit, at which point the
2213 OS makes the parent schedulable again (and the target reports
2214 that the vfork is done). Until the child is done with the shared
2215 memory region, do not insert breakpoints in the parent, otherwise
2216 the child could still trip on the parent's breakpoints. Since
2217 the parent is blocked anyway, it won't miss any breakpoint. */
2218 if (bl
->pspace
->breakpoints_not_allowed
)
2221 /* Don't insert a breakpoint if we're trying to step past its
2222 location, except if the breakpoint is a single-step breakpoint,
2223 and the breakpoint's thread is the thread which is stepping past
2225 if ((bl
->loc_type
== bp_loc_software_breakpoint
2226 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
2227 && stepping_past_instruction_at (bl
->pspace
->aspace
,
2229 /* The single-step breakpoint may be inserted at the location
2230 we're trying to step if the instruction branches to itself.
2231 However, the instruction won't be executed at all and it may
2232 break the semantics of the instruction, for example, the
2233 instruction is a conditional branch or updates some flags.
2234 We can't fix it unless GDB is able to emulate the instruction
2235 or switch to displaced stepping. */
2236 && !(bl
->owner
->type
== bp_single_step
2237 && thread_is_stepping_over_breakpoint (bl
->owner
->thread
)))
2241 fprintf_unfiltered (gdb_stdlog
,
2242 "infrun: skipping breakpoint: "
2243 "stepping past insn at: %s\n",
2244 paddress (bl
->gdbarch
, bl
->address
));
2249 /* Don't insert watchpoints if we're trying to step past the
2250 instruction that triggered one. */
2251 if ((bl
->loc_type
== bp_loc_hardware_watchpoint
)
2252 && stepping_past_nonsteppable_watchpoint ())
2256 fprintf_unfiltered (gdb_stdlog
,
2257 "infrun: stepping past non-steppable watchpoint. "
2258 "skipping watchpoint at %s:%d\n",
2259 paddress (bl
->gdbarch
, bl
->address
),
2268 /* Same as should_be_inserted but does the check assuming
2269 that the location is not duplicated. */
2272 unduplicated_should_be_inserted (struct bp_location
*bl
)
2275 const int save_duplicate
= bl
->duplicate
;
2278 result
= should_be_inserted (bl
);
2279 bl
->duplicate
= save_duplicate
;
2283 /* Parses a conditional described by an expression COND into an
2284 agent expression bytecode suitable for evaluation
2285 by the bytecode interpreter. Return NULL if there was
2286 any error during parsing. */
2288 static agent_expr_up
2289 parse_cond_to_aexpr (CORE_ADDR scope
, struct expression
*cond
)
2294 agent_expr_up aexpr
;
2296 /* We don't want to stop processing, so catch any errors
2297 that may show up. */
2300 aexpr
= gen_eval_for_expr (scope
, cond
);
2303 CATCH (ex
, RETURN_MASK_ERROR
)
2305 /* If we got here, it means the condition could not be parsed to a valid
2306 bytecode expression and thus can't be evaluated on the target's side.
2307 It's no use iterating through the conditions. */
2311 /* We have a valid agent expression. */
2315 /* Based on location BL, create a list of breakpoint conditions to be
2316 passed on to the target. If we have duplicated locations with different
2317 conditions, we will add such conditions to the list. The idea is that the
2318 target will evaluate the list of conditions and will only notify GDB when
2319 one of them is true. */
2322 build_target_condition_list (struct bp_location
*bl
)
2324 struct bp_location
**locp
= NULL
, **loc2p
;
2325 int null_condition_or_parse_error
= 0;
2326 int modified
= bl
->needs_update
;
2327 struct bp_location
*loc
;
2329 /* Release conditions left over from a previous insert. */
2330 bl
->target_info
.conditions
.clear ();
2332 /* This is only meaningful if the target is
2333 evaluating conditions and if the user has
2334 opted for condition evaluation on the target's
2336 if (gdb_evaluates_breakpoint_condition_p ()
2337 || !target_supports_evaluation_of_breakpoint_conditions ())
2340 /* Do a first pass to check for locations with no assigned
2341 conditions or conditions that fail to parse to a valid agent expression
2342 bytecode. If any of these happen, then it's no use to send conditions
2343 to the target since this location will always trigger and generate a
2344 response back to GDB. */
2345 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2348 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2352 /* Re-parse the conditions since something changed. In that
2353 case we already freed the condition bytecodes (see
2354 force_breakpoint_reinsertion). We just
2355 need to parse the condition to bytecodes again. */
2356 loc
->cond_bytecode
= parse_cond_to_aexpr (bl
->address
,
2360 /* If we have a NULL bytecode expression, it means something
2361 went wrong or we have a null condition expression. */
2362 if (!loc
->cond_bytecode
)
2364 null_condition_or_parse_error
= 1;
2370 /* If any of these happened, it means we will have to evaluate the conditions
2371 for the location's address on gdb's side. It is no use keeping bytecodes
2372 for all the other duplicate locations, thus we free all of them here.
2374 This is so we have a finer control over which locations' conditions are
2375 being evaluated by GDB or the remote stub. */
2376 if (null_condition_or_parse_error
)
2378 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2381 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2383 /* Only go as far as the first NULL bytecode is
2385 if (!loc
->cond_bytecode
)
2388 loc
->cond_bytecode
.reset ();
2393 /* No NULL conditions or failed bytecode generation. Build a condition list
2394 for this location's address. */
2395 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2399 && is_breakpoint (loc
->owner
)
2400 && loc
->pspace
->num
== bl
->pspace
->num
2401 && loc
->owner
->enable_state
== bp_enabled
2404 /* Add the condition to the vector. This will be used later
2405 to send the conditions to the target. */
2406 bl
->target_info
.conditions
.push_back (loc
->cond_bytecode
.get ());
2413 /* Parses a command described by string CMD into an agent expression
2414 bytecode suitable for evaluation by the bytecode interpreter.
2415 Return NULL if there was any error during parsing. */
2417 static agent_expr_up
2418 parse_cmd_to_aexpr (CORE_ADDR scope
, char *cmd
)
2420 struct cleanup
*old_cleanups
= 0;
2421 struct expression
**argvec
;
2422 const char *cmdrest
;
2423 const char *format_start
, *format_end
;
2424 struct format_piece
*fpieces
;
2426 struct gdbarch
*gdbarch
= get_current_arch ();
2433 if (*cmdrest
== ',')
2435 cmdrest
= skip_spaces_const (cmdrest
);
2437 if (*cmdrest
++ != '"')
2438 error (_("No format string following the location"));
2440 format_start
= cmdrest
;
2442 fpieces
= parse_format_string (&cmdrest
);
2444 old_cleanups
= make_cleanup (free_format_pieces_cleanup
, &fpieces
);
2446 format_end
= cmdrest
;
2448 if (*cmdrest
++ != '"')
2449 error (_("Bad format string, non-terminated '\"'."));
2451 cmdrest
= skip_spaces_const (cmdrest
);
2453 if (!(*cmdrest
== ',' || *cmdrest
== '\0'))
2454 error (_("Invalid argument syntax"));
2456 if (*cmdrest
== ',')
2458 cmdrest
= skip_spaces_const (cmdrest
);
2460 /* For each argument, make an expression. */
2462 argvec
= (struct expression
**) alloca (strlen (cmd
)
2463 * sizeof (struct expression
*));
2466 while (*cmdrest
!= '\0')
2471 expression_up expr
= parse_exp_1 (&cmd1
, scope
, block_for_pc (scope
), 1);
2472 argvec
[nargs
++] = expr
.release ();
2474 if (*cmdrest
== ',')
2478 agent_expr_up aexpr
;
2480 /* We don't want to stop processing, so catch any errors
2481 that may show up. */
2484 aexpr
= gen_printf (scope
, gdbarch
, 0, 0,
2485 format_start
, format_end
- format_start
,
2486 fpieces
, nargs
, argvec
);
2488 CATCH (ex
, RETURN_MASK_ERROR
)
2490 /* If we got here, it means the command could not be parsed to a valid
2491 bytecode expression and thus can't be evaluated on the target's side.
2492 It's no use iterating through the other commands. */
2496 do_cleanups (old_cleanups
);
2498 /* We have a valid agent expression, return it. */
2502 /* Based on location BL, create a list of breakpoint commands to be
2503 passed on to the target. If we have duplicated locations with
2504 different commands, we will add any such to the list. */
2507 build_target_command_list (struct bp_location
*bl
)
2509 struct bp_location
**locp
= NULL
, **loc2p
;
2510 int null_command_or_parse_error
= 0;
2511 int modified
= bl
->needs_update
;
2512 struct bp_location
*loc
;
2514 /* Clear commands left over from a previous insert. */
2515 bl
->target_info
.tcommands
.clear ();
2517 if (!target_can_run_breakpoint_commands ())
2520 /* For now, limit to agent-style dprintf breakpoints. */
2521 if (dprintf_style
!= dprintf_style_agent
)
2524 /* For now, if we have any duplicate location that isn't a dprintf,
2525 don't install the target-side commands, as that would make the
2526 breakpoint not be reported to the core, and we'd lose
2528 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2531 if (is_breakpoint (loc
->owner
)
2532 && loc
->pspace
->num
== bl
->pspace
->num
2533 && loc
->owner
->type
!= bp_dprintf
)
2537 /* Do a first pass to check for locations with no assigned
2538 conditions or conditions that fail to parse to a valid agent expression
2539 bytecode. If any of these happen, then it's no use to send conditions
2540 to the target since this location will always trigger and generate a
2541 response back to GDB. */
2542 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2545 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2549 /* Re-parse the commands since something changed. In that
2550 case we already freed the command bytecodes (see
2551 force_breakpoint_reinsertion). We just
2552 need to parse the command to bytecodes again. */
2554 = parse_cmd_to_aexpr (bl
->address
,
2555 loc
->owner
->extra_string
);
2558 /* If we have a NULL bytecode expression, it means something
2559 went wrong or we have a null command expression. */
2560 if (!loc
->cmd_bytecode
)
2562 null_command_or_parse_error
= 1;
2568 /* If anything failed, then we're not doing target-side commands,
2570 if (null_command_or_parse_error
)
2572 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2575 if (is_breakpoint (loc
->owner
)
2576 && loc
->pspace
->num
== bl
->pspace
->num
)
2578 /* Only go as far as the first NULL bytecode is
2580 if (loc
->cmd_bytecode
== NULL
)
2583 loc
->cmd_bytecode
.reset ();
2588 /* No NULL commands or failed bytecode generation. Build a command list
2589 for this location's address. */
2590 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2593 if (loc
->owner
->extra_string
2594 && is_breakpoint (loc
->owner
)
2595 && loc
->pspace
->num
== bl
->pspace
->num
2596 && loc
->owner
->enable_state
== bp_enabled
2599 /* Add the command to the vector. This will be used later
2600 to send the commands to the target. */
2601 bl
->target_info
.tcommands
.push_back (loc
->cmd_bytecode
.get ());
2605 bl
->target_info
.persist
= 0;
2606 /* Maybe flag this location as persistent. */
2607 if (bl
->owner
->type
== bp_dprintf
&& disconnected_dprintf
)
2608 bl
->target_info
.persist
= 1;
2611 /* Return the kind of breakpoint on address *ADDR. Get the kind
2612 of breakpoint according to ADDR except single-step breakpoint.
2613 Get the kind of single-step breakpoint according to the current
2617 breakpoint_kind (struct bp_location
*bl
, CORE_ADDR
*addr
)
2619 if (bl
->owner
->type
== bp_single_step
)
2621 struct thread_info
*thr
= find_thread_global_id (bl
->owner
->thread
);
2622 struct regcache
*regcache
;
2624 regcache
= get_thread_regcache (thr
->ptid
);
2626 return gdbarch_breakpoint_kind_from_current_state (bl
->gdbarch
,
2630 return gdbarch_breakpoint_kind_from_pc (bl
->gdbarch
, addr
);
2633 /* Insert a low-level "breakpoint" of some type. BL is the breakpoint
2634 location. Any error messages are printed to TMP_ERROR_STREAM; and
2635 DISABLED_BREAKS, and HW_BREAKPOINT_ERROR are used to report problems.
2636 Returns 0 for success, 1 if the bp_location type is not supported or
2639 NOTE drow/2003-09-09: This routine could be broken down to an
2640 object-style method for each breakpoint or catchpoint type. */
2642 insert_bp_location (struct bp_location
*bl
,
2643 struct ui_file
*tmp_error_stream
,
2644 int *disabled_breaks
,
2645 int *hw_breakpoint_error
,
2646 int *hw_bp_error_explained_already
)
2648 enum errors bp_err
= GDB_NO_ERROR
;
2649 const char *bp_err_message
= NULL
;
2651 if (!should_be_inserted (bl
) || (bl
->inserted
&& !bl
->needs_update
))
2654 /* Note we don't initialize bl->target_info, as that wipes out
2655 the breakpoint location's shadow_contents if the breakpoint
2656 is still inserted at that location. This in turn breaks
2657 target_read_memory which depends on these buffers when
2658 a memory read is requested at the breakpoint location:
2659 Once the target_info has been wiped, we fail to see that
2660 we have a breakpoint inserted at that address and thus
2661 read the breakpoint instead of returning the data saved in
2662 the breakpoint location's shadow contents. */
2663 bl
->target_info
.reqstd_address
= bl
->address
;
2664 bl
->target_info
.placed_address_space
= bl
->pspace
->aspace
;
2665 bl
->target_info
.length
= bl
->length
;
2667 /* When working with target-side conditions, we must pass all the conditions
2668 for the same breakpoint address down to the target since GDB will not
2669 insert those locations. With a list of breakpoint conditions, the target
2670 can decide when to stop and notify GDB. */
2672 if (is_breakpoint (bl
->owner
))
2674 build_target_condition_list (bl
);
2675 build_target_command_list (bl
);
2676 /* Reset the modification marker. */
2677 bl
->needs_update
= 0;
2680 if (bl
->loc_type
== bp_loc_software_breakpoint
2681 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
2683 if (bl
->owner
->type
!= bp_hardware_breakpoint
)
2685 /* If the explicitly specified breakpoint type
2686 is not hardware breakpoint, check the memory map to see
2687 if the breakpoint address is in read only memory or not.
2689 Two important cases are:
2690 - location type is not hardware breakpoint, memory
2691 is readonly. We change the type of the location to
2692 hardware breakpoint.
2693 - location type is hardware breakpoint, memory is
2694 read-write. This means we've previously made the
2695 location hardware one, but then the memory map changed,
2698 When breakpoints are removed, remove_breakpoints will use
2699 location types we've just set here, the only possible
2700 problem is that memory map has changed during running
2701 program, but it's not going to work anyway with current
2703 struct mem_region
*mr
2704 = lookup_mem_region (bl
->target_info
.reqstd_address
);
2708 if (automatic_hardware_breakpoints
)
2710 enum bp_loc_type new_type
;
2712 if (mr
->attrib
.mode
!= MEM_RW
)
2713 new_type
= bp_loc_hardware_breakpoint
;
2715 new_type
= bp_loc_software_breakpoint
;
2717 if (new_type
!= bl
->loc_type
)
2719 static int said
= 0;
2721 bl
->loc_type
= new_type
;
2724 fprintf_filtered (gdb_stdout
,
2725 _("Note: automatically using "
2726 "hardware breakpoints for "
2727 "read-only addresses.\n"));
2732 else if (bl
->loc_type
== bp_loc_software_breakpoint
2733 && mr
->attrib
.mode
!= MEM_RW
)
2735 fprintf_unfiltered (tmp_error_stream
,
2736 _("Cannot insert breakpoint %d.\n"
2737 "Cannot set software breakpoint "
2738 "at read-only address %s\n"),
2740 paddress (bl
->gdbarch
, bl
->address
));
2746 /* First check to see if we have to handle an overlay. */
2747 if (overlay_debugging
== ovly_off
2748 || bl
->section
== NULL
2749 || !(section_is_overlay (bl
->section
)))
2751 /* No overlay handling: just set the breakpoint. */
2756 val
= bl
->owner
->ops
->insert_location (bl
);
2758 bp_err
= GENERIC_ERROR
;
2760 CATCH (e
, RETURN_MASK_ALL
)
2763 bp_err_message
= e
.message
;
2769 /* This breakpoint is in an overlay section.
2770 Shall we set a breakpoint at the LMA? */
2771 if (!overlay_events_enabled
)
2773 /* Yes -- overlay event support is not active,
2774 so we must try to set a breakpoint at the LMA.
2775 This will not work for a hardware breakpoint. */
2776 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
2777 warning (_("hardware breakpoint %d not supported in overlay!"),
2781 CORE_ADDR addr
= overlay_unmapped_address (bl
->address
,
2783 /* Set a software (trap) breakpoint at the LMA. */
2784 bl
->overlay_target_info
= bl
->target_info
;
2785 bl
->overlay_target_info
.reqstd_address
= addr
;
2787 /* No overlay handling: just set the breakpoint. */
2792 bl
->overlay_target_info
.kind
2793 = breakpoint_kind (bl
, &addr
);
2794 bl
->overlay_target_info
.placed_address
= addr
;
2795 val
= target_insert_breakpoint (bl
->gdbarch
,
2796 &bl
->overlay_target_info
);
2798 bp_err
= GENERIC_ERROR
;
2800 CATCH (e
, RETURN_MASK_ALL
)
2803 bp_err_message
= e
.message
;
2807 if (bp_err
!= GDB_NO_ERROR
)
2808 fprintf_unfiltered (tmp_error_stream
,
2809 "Overlay breakpoint %d "
2810 "failed: in ROM?\n",
2814 /* Shall we set a breakpoint at the VMA? */
2815 if (section_is_mapped (bl
->section
))
2817 /* Yes. This overlay section is mapped into memory. */
2822 val
= bl
->owner
->ops
->insert_location (bl
);
2824 bp_err
= GENERIC_ERROR
;
2826 CATCH (e
, RETURN_MASK_ALL
)
2829 bp_err_message
= e
.message
;
2835 /* No. This breakpoint will not be inserted.
2836 No error, but do not mark the bp as 'inserted'. */
2841 if (bp_err
!= GDB_NO_ERROR
)
2843 /* Can't set the breakpoint. */
2845 /* In some cases, we might not be able to insert a
2846 breakpoint in a shared library that has already been
2847 removed, but we have not yet processed the shlib unload
2848 event. Unfortunately, some targets that implement
2849 breakpoint insertion themselves can't tell why the
2850 breakpoint insertion failed (e.g., the remote target
2851 doesn't define error codes), so we must treat generic
2852 errors as memory errors. */
2853 if ((bp_err
== GENERIC_ERROR
|| bp_err
== MEMORY_ERROR
)
2854 && bl
->loc_type
== bp_loc_software_breakpoint
2855 && (solib_name_from_address (bl
->pspace
, bl
->address
)
2856 || shared_objfile_contains_address_p (bl
->pspace
,
2859 /* See also: disable_breakpoints_in_shlibs. */
2860 bl
->shlib_disabled
= 1;
2861 observer_notify_breakpoint_modified (bl
->owner
);
2862 if (!*disabled_breaks
)
2864 fprintf_unfiltered (tmp_error_stream
,
2865 "Cannot insert breakpoint %d.\n",
2867 fprintf_unfiltered (tmp_error_stream
,
2868 "Temporarily disabling shared "
2869 "library breakpoints:\n");
2871 *disabled_breaks
= 1;
2872 fprintf_unfiltered (tmp_error_stream
,
2873 "breakpoint #%d\n", bl
->owner
->number
);
2878 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
2880 *hw_breakpoint_error
= 1;
2881 *hw_bp_error_explained_already
= bp_err_message
!= NULL
;
2882 fprintf_unfiltered (tmp_error_stream
,
2883 "Cannot insert hardware breakpoint %d%s",
2884 bl
->owner
->number
, bp_err_message
? ":" : ".\n");
2885 if (bp_err_message
!= NULL
)
2886 fprintf_unfiltered (tmp_error_stream
, "%s.\n", bp_err_message
);
2890 if (bp_err_message
== NULL
)
2893 = memory_error_message (TARGET_XFER_E_IO
,
2894 bl
->gdbarch
, bl
->address
);
2895 struct cleanup
*old_chain
= make_cleanup (xfree
, message
);
2897 fprintf_unfiltered (tmp_error_stream
,
2898 "Cannot insert breakpoint %d.\n"
2900 bl
->owner
->number
, message
);
2901 do_cleanups (old_chain
);
2905 fprintf_unfiltered (tmp_error_stream
,
2906 "Cannot insert breakpoint %d: %s\n",
2921 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
2922 /* NOTE drow/2003-09-08: This state only exists for removing
2923 watchpoints. It's not clear that it's necessary... */
2924 && bl
->owner
->disposition
!= disp_del_at_next_stop
)
2928 gdb_assert (bl
->owner
->ops
!= NULL
2929 && bl
->owner
->ops
->insert_location
!= NULL
);
2931 val
= bl
->owner
->ops
->insert_location (bl
);
2933 /* If trying to set a read-watchpoint, and it turns out it's not
2934 supported, try emulating one with an access watchpoint. */
2935 if (val
== 1 && bl
->watchpoint_type
== hw_read
)
2937 struct bp_location
*loc
, **loc_temp
;
2939 /* But don't try to insert it, if there's already another
2940 hw_access location that would be considered a duplicate
2942 ALL_BP_LOCATIONS (loc
, loc_temp
)
2944 && loc
->watchpoint_type
== hw_access
2945 && watchpoint_locations_match (bl
, loc
))
2949 bl
->target_info
= loc
->target_info
;
2950 bl
->watchpoint_type
= hw_access
;
2957 bl
->watchpoint_type
= hw_access
;
2958 val
= bl
->owner
->ops
->insert_location (bl
);
2961 /* Back to the original value. */
2962 bl
->watchpoint_type
= hw_read
;
2966 bl
->inserted
= (val
== 0);
2969 else if (bl
->owner
->type
== bp_catchpoint
)
2973 gdb_assert (bl
->owner
->ops
!= NULL
2974 && bl
->owner
->ops
->insert_location
!= NULL
);
2976 val
= bl
->owner
->ops
->insert_location (bl
);
2979 bl
->owner
->enable_state
= bp_disabled
;
2983 Error inserting catchpoint %d: Your system does not support this type\n\
2984 of catchpoint."), bl
->owner
->number
);
2986 warning (_("Error inserting catchpoint %d."), bl
->owner
->number
);
2989 bl
->inserted
= (val
== 0);
2991 /* We've already printed an error message if there was a problem
2992 inserting this catchpoint, and we've disabled the catchpoint,
2993 so just return success. */
3000 /* This function is called when program space PSPACE is about to be
3001 deleted. It takes care of updating breakpoints to not reference
3005 breakpoint_program_space_exit (struct program_space
*pspace
)
3007 struct breakpoint
*b
, *b_temp
;
3008 struct bp_location
*loc
, **loc_temp
;
3010 /* Remove any breakpoint that was set through this program space. */
3011 ALL_BREAKPOINTS_SAFE (b
, b_temp
)
3013 if (b
->pspace
== pspace
)
3014 delete_breakpoint (b
);
3017 /* Breakpoints set through other program spaces could have locations
3018 bound to PSPACE as well. Remove those. */
3019 ALL_BP_LOCATIONS (loc
, loc_temp
)
3021 struct bp_location
*tmp
;
3023 if (loc
->pspace
== pspace
)
3025 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
3026 if (loc
->owner
->loc
== loc
)
3027 loc
->owner
->loc
= loc
->next
;
3029 for (tmp
= loc
->owner
->loc
; tmp
->next
!= NULL
; tmp
= tmp
->next
)
3030 if (tmp
->next
== loc
)
3032 tmp
->next
= loc
->next
;
3038 /* Now update the global location list to permanently delete the
3039 removed locations above. */
3040 update_global_location_list (UGLL_DONT_INSERT
);
3043 /* Make sure all breakpoints are inserted in inferior.
3044 Throws exception on any error.
3045 A breakpoint that is already inserted won't be inserted
3046 again, so calling this function twice is safe. */
3048 insert_breakpoints (void)
3050 struct breakpoint
*bpt
;
3052 ALL_BREAKPOINTS (bpt
)
3053 if (is_hardware_watchpoint (bpt
))
3055 struct watchpoint
*w
= (struct watchpoint
*) bpt
;
3057 update_watchpoint (w
, 0 /* don't reparse. */);
3060 /* Updating watchpoints creates new locations, so update the global
3061 location list. Explicitly tell ugll to insert locations and
3062 ignore breakpoints_always_inserted_mode. */
3063 update_global_location_list (UGLL_INSERT
);
3066 /* Invoke CALLBACK for each of bp_location. */
3069 iterate_over_bp_locations (walk_bp_location_callback callback
)
3071 struct bp_location
*loc
, **loc_tmp
;
3073 ALL_BP_LOCATIONS (loc
, loc_tmp
)
3075 callback (loc
, NULL
);
3079 /* This is used when we need to synch breakpoint conditions between GDB and the
3080 target. It is the case with deleting and disabling of breakpoints when using
3081 always-inserted mode. */
3084 update_inserted_breakpoint_locations (void)
3086 struct bp_location
*bl
, **blp_tmp
;
3089 int disabled_breaks
= 0;
3090 int hw_breakpoint_error
= 0;
3091 int hw_bp_details_reported
= 0;
3093 string_file tmp_error_stream
;
3095 /* Explicitly mark the warning -- this will only be printed if
3096 there was an error. */
3097 tmp_error_stream
.puts ("Warning:\n");
3099 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
3101 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3103 /* We only want to update software breakpoints and hardware
3105 if (!is_breakpoint (bl
->owner
))
3108 /* We only want to update locations that are already inserted
3109 and need updating. This is to avoid unwanted insertion during
3110 deletion of breakpoints. */
3111 if (!bl
->inserted
|| (bl
->inserted
&& !bl
->needs_update
))
3114 switch_to_program_space_and_thread (bl
->pspace
);
3116 /* For targets that support global breakpoints, there's no need
3117 to select an inferior to insert breakpoint to. In fact, even
3118 if we aren't attached to any process yet, we should still
3119 insert breakpoints. */
3120 if (!gdbarch_has_global_breakpoints (target_gdbarch ())
3121 && ptid_equal (inferior_ptid
, null_ptid
))
3124 val
= insert_bp_location (bl
, &tmp_error_stream
, &disabled_breaks
,
3125 &hw_breakpoint_error
, &hw_bp_details_reported
);
3132 target_terminal_ours_for_output ();
3133 error_stream (tmp_error_stream
);
3137 /* Used when starting or continuing the program. */
3140 insert_breakpoint_locations (void)
3142 struct breakpoint
*bpt
;
3143 struct bp_location
*bl
, **blp_tmp
;
3146 int disabled_breaks
= 0;
3147 int hw_breakpoint_error
= 0;
3148 int hw_bp_error_explained_already
= 0;
3150 string_file tmp_error_stream
;
3152 /* Explicitly mark the warning -- this will only be printed if
3153 there was an error. */
3154 tmp_error_stream
.puts ("Warning:\n");
3156 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
3158 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3160 if (!should_be_inserted (bl
) || (bl
->inserted
&& !bl
->needs_update
))
3163 /* There is no point inserting thread-specific breakpoints if
3164 the thread no longer exists. ALL_BP_LOCATIONS bp_location
3165 has BL->OWNER always non-NULL. */
3166 if (bl
->owner
->thread
!= -1
3167 && !valid_global_thread_id (bl
->owner
->thread
))
3170 switch_to_program_space_and_thread (bl
->pspace
);
3172 /* For targets that support global breakpoints, there's no need
3173 to select an inferior to insert breakpoint to. In fact, even
3174 if we aren't attached to any process yet, we should still
3175 insert breakpoints. */
3176 if (!gdbarch_has_global_breakpoints (target_gdbarch ())
3177 && ptid_equal (inferior_ptid
, null_ptid
))
3180 val
= insert_bp_location (bl
, &tmp_error_stream
, &disabled_breaks
,
3181 &hw_breakpoint_error
, &hw_bp_error_explained_already
);
3186 /* If we failed to insert all locations of a watchpoint, remove
3187 them, as half-inserted watchpoint is of limited use. */
3188 ALL_BREAKPOINTS (bpt
)
3190 int some_failed
= 0;
3191 struct bp_location
*loc
;
3193 if (!is_hardware_watchpoint (bpt
))
3196 if (!breakpoint_enabled (bpt
))
3199 if (bpt
->disposition
== disp_del_at_next_stop
)
3202 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
3203 if (!loc
->inserted
&& should_be_inserted (loc
))
3210 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
3212 remove_breakpoint (loc
);
3214 hw_breakpoint_error
= 1;
3215 tmp_error_stream
.printf ("Could not insert "
3216 "hardware watchpoint %d.\n",
3224 /* If a hardware breakpoint or watchpoint was inserted, add a
3225 message about possibly exhausted resources. */
3226 if (hw_breakpoint_error
&& !hw_bp_error_explained_already
)
3228 tmp_error_stream
.printf ("Could not insert hardware breakpoints:\n\
3229 You may have requested too many hardware breakpoints/watchpoints.\n");
3231 target_terminal_ours_for_output ();
3232 error_stream (tmp_error_stream
);
3236 /* Used when the program stops.
3237 Returns zero if successful, or non-zero if there was a problem
3238 removing a breakpoint location. */
3241 remove_breakpoints (void)
3243 struct bp_location
*bl
, **blp_tmp
;
3246 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3248 if (bl
->inserted
&& !is_tracepoint (bl
->owner
))
3249 val
|= remove_breakpoint (bl
);
3254 /* When a thread exits, remove breakpoints that are related to
3258 remove_threaded_breakpoints (struct thread_info
*tp
, int silent
)
3260 struct breakpoint
*b
, *b_tmp
;
3262 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
3264 if (b
->thread
== tp
->global_num
&& user_breakpoint_p (b
))
3266 b
->disposition
= disp_del_at_next_stop
;
3268 printf_filtered (_("\
3269 Thread-specific breakpoint %d deleted - thread %s no longer in the thread list.\n"),
3270 b
->number
, print_thread_id (tp
));
3272 /* Hide it from the user. */
3278 /* Remove breakpoints of process PID. */
3281 remove_breakpoints_pid (int pid
)
3283 struct bp_location
*bl
, **blp_tmp
;
3285 struct inferior
*inf
= find_inferior_pid (pid
);
3287 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3289 if (bl
->pspace
!= inf
->pspace
)
3292 if (bl
->inserted
&& !bl
->target_info
.persist
)
3294 val
= remove_breakpoint (bl
);
3303 reattach_breakpoints (int pid
)
3305 struct bp_location
*bl
, **blp_tmp
;
3307 int dummy1
= 0, dummy2
= 0, dummy3
= 0;
3308 struct inferior
*inf
;
3309 struct thread_info
*tp
;
3311 tp
= any_live_thread_of_process (pid
);
3315 inf
= find_inferior_pid (pid
);
3317 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
3318 inferior_ptid
= tp
->ptid
;
3320 string_file tmp_error_stream
;
3322 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3324 if (bl
->pspace
!= inf
->pspace
)
3330 val
= insert_bp_location (bl
, &tmp_error_stream
, &dummy1
, &dummy2
, &dummy3
);
3338 static int internal_breakpoint_number
= -1;
3340 /* Set the breakpoint number of B, depending on the value of INTERNAL.
3341 If INTERNAL is non-zero, the breakpoint number will be populated
3342 from internal_breakpoint_number and that variable decremented.
3343 Otherwise the breakpoint number will be populated from
3344 breakpoint_count and that value incremented. Internal breakpoints
3345 do not set the internal var bpnum. */
3347 set_breakpoint_number (int internal
, struct breakpoint
*b
)
3350 b
->number
= internal_breakpoint_number
--;
3353 set_breakpoint_count (breakpoint_count
+ 1);
3354 b
->number
= breakpoint_count
;
3358 static struct breakpoint
*
3359 create_internal_breakpoint (struct gdbarch
*gdbarch
,
3360 CORE_ADDR address
, enum bptype type
,
3361 const struct breakpoint_ops
*ops
)
3363 struct symtab_and_line sal
;
3364 struct breakpoint
*b
;
3366 init_sal (&sal
); /* Initialize to zeroes. */
3369 sal
.section
= find_pc_overlay (sal
.pc
);
3370 sal
.pspace
= current_program_space
;
3372 b
= set_raw_breakpoint (gdbarch
, sal
, type
, ops
);
3373 b
->number
= internal_breakpoint_number
--;
3374 b
->disposition
= disp_donttouch
;
3379 static const char *const longjmp_names
[] =
3381 "longjmp", "_longjmp", "siglongjmp", "_siglongjmp"
3383 #define NUM_LONGJMP_NAMES ARRAY_SIZE(longjmp_names)
3385 /* Per-objfile data private to breakpoint.c. */
3386 struct breakpoint_objfile_data
3388 /* Minimal symbol for "_ovly_debug_event" (if any). */
3389 struct bound_minimal_symbol overlay_msym
;
3391 /* Minimal symbol(s) for "longjmp", "siglongjmp", etc. (if any). */
3392 struct bound_minimal_symbol longjmp_msym
[NUM_LONGJMP_NAMES
];
3394 /* True if we have looked for longjmp probes. */
3395 int longjmp_searched
;
3397 /* SystemTap probe points for longjmp (if any). */
3398 VEC (probe_p
) *longjmp_probes
;
3400 /* Minimal symbol for "std::terminate()" (if any). */
3401 struct bound_minimal_symbol terminate_msym
;
3403 /* Minimal symbol for "_Unwind_DebugHook" (if any). */
3404 struct bound_minimal_symbol exception_msym
;
3406 /* True if we have looked for exception probes. */
3407 int exception_searched
;
3409 /* SystemTap probe points for unwinding (if any). */
3410 VEC (probe_p
) *exception_probes
;
3413 static const struct objfile_data
*breakpoint_objfile_key
;
3415 /* Minimal symbol not found sentinel. */
3416 static struct minimal_symbol msym_not_found
;
3418 /* Returns TRUE if MSYM point to the "not found" sentinel. */
3421 msym_not_found_p (const struct minimal_symbol
*msym
)
3423 return msym
== &msym_not_found
;
3426 /* Return per-objfile data needed by breakpoint.c.
3427 Allocate the data if necessary. */
3429 static struct breakpoint_objfile_data
*
3430 get_breakpoint_objfile_data (struct objfile
*objfile
)
3432 struct breakpoint_objfile_data
*bp_objfile_data
;
3434 bp_objfile_data
= ((struct breakpoint_objfile_data
*)
3435 objfile_data (objfile
, breakpoint_objfile_key
));
3436 if (bp_objfile_data
== NULL
)
3439 XOBNEW (&objfile
->objfile_obstack
, struct breakpoint_objfile_data
);
3441 memset (bp_objfile_data
, 0, sizeof (*bp_objfile_data
));
3442 set_objfile_data (objfile
, breakpoint_objfile_key
, bp_objfile_data
);
3444 return bp_objfile_data
;
3448 free_breakpoint_probes (struct objfile
*obj
, void *data
)
3450 struct breakpoint_objfile_data
*bp_objfile_data
3451 = (struct breakpoint_objfile_data
*) data
;
3453 VEC_free (probe_p
, bp_objfile_data
->longjmp_probes
);
3454 VEC_free (probe_p
, bp_objfile_data
->exception_probes
);
3458 create_overlay_event_breakpoint (void)
3460 struct objfile
*objfile
;
3461 const char *const func_name
= "_ovly_debug_event";
3463 ALL_OBJFILES (objfile
)
3465 struct breakpoint
*b
;
3466 struct breakpoint_objfile_data
*bp_objfile_data
;
3468 struct explicit_location explicit_loc
;
3470 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3472 if (msym_not_found_p (bp_objfile_data
->overlay_msym
.minsym
))
3475 if (bp_objfile_data
->overlay_msym
.minsym
== NULL
)
3477 struct bound_minimal_symbol m
;
3479 m
= lookup_minimal_symbol_text (func_name
, objfile
);
3480 if (m
.minsym
== NULL
)
3482 /* Avoid future lookups in this objfile. */
3483 bp_objfile_data
->overlay_msym
.minsym
= &msym_not_found
;
3486 bp_objfile_data
->overlay_msym
= m
;
3489 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->overlay_msym
);
3490 b
= create_internal_breakpoint (get_objfile_arch (objfile
), addr
,
3492 &internal_breakpoint_ops
);
3493 initialize_explicit_location (&explicit_loc
);
3494 explicit_loc
.function_name
= ASTRDUP (func_name
);
3495 b
->location
= new_explicit_location (&explicit_loc
);
3497 if (overlay_debugging
== ovly_auto
)
3499 b
->enable_state
= bp_enabled
;
3500 overlay_events_enabled
= 1;
3504 b
->enable_state
= bp_disabled
;
3505 overlay_events_enabled
= 0;
3511 create_longjmp_master_breakpoint (void)
3513 struct program_space
*pspace
;
3515 scoped_restore_current_program_space restore_pspace
;
3517 ALL_PSPACES (pspace
)
3519 struct objfile
*objfile
;
3521 set_current_program_space (pspace
);
3523 ALL_OBJFILES (objfile
)
3526 struct gdbarch
*gdbarch
;
3527 struct breakpoint_objfile_data
*bp_objfile_data
;
3529 gdbarch
= get_objfile_arch (objfile
);
3531 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3533 if (!bp_objfile_data
->longjmp_searched
)
3537 ret
= find_probes_in_objfile (objfile
, "libc", "longjmp");
3540 /* We are only interested in checking one element. */
3541 struct probe
*p
= VEC_index (probe_p
, ret
, 0);
3543 if (!can_evaluate_probe_arguments (p
))
3545 /* We cannot use the probe interface here, because it does
3546 not know how to evaluate arguments. */
3547 VEC_free (probe_p
, ret
);
3551 bp_objfile_data
->longjmp_probes
= ret
;
3552 bp_objfile_data
->longjmp_searched
= 1;
3555 if (bp_objfile_data
->longjmp_probes
!= NULL
)
3558 struct probe
*probe
;
3559 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3562 VEC_iterate (probe_p
,
3563 bp_objfile_data
->longjmp_probes
,
3567 struct breakpoint
*b
;
3569 b
= create_internal_breakpoint (gdbarch
,
3570 get_probe_address (probe
,
3573 &internal_breakpoint_ops
);
3574 b
->location
= new_probe_location ("-probe-stap libc:longjmp");
3575 b
->enable_state
= bp_disabled
;
3581 if (!gdbarch_get_longjmp_target_p (gdbarch
))
3584 for (i
= 0; i
< NUM_LONGJMP_NAMES
; i
++)
3586 struct breakpoint
*b
;
3587 const char *func_name
;
3589 struct explicit_location explicit_loc
;
3591 if (msym_not_found_p (bp_objfile_data
->longjmp_msym
[i
].minsym
))
3594 func_name
= longjmp_names
[i
];
3595 if (bp_objfile_data
->longjmp_msym
[i
].minsym
== NULL
)
3597 struct bound_minimal_symbol m
;
3599 m
= lookup_minimal_symbol_text (func_name
, objfile
);
3600 if (m
.minsym
== NULL
)
3602 /* Prevent future lookups in this objfile. */
3603 bp_objfile_data
->longjmp_msym
[i
].minsym
= &msym_not_found
;
3606 bp_objfile_data
->longjmp_msym
[i
] = m
;
3609 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->longjmp_msym
[i
]);
3610 b
= create_internal_breakpoint (gdbarch
, addr
, bp_longjmp_master
,
3611 &internal_breakpoint_ops
);
3612 initialize_explicit_location (&explicit_loc
);
3613 explicit_loc
.function_name
= ASTRDUP (func_name
);
3614 b
->location
= new_explicit_location (&explicit_loc
);
3615 b
->enable_state
= bp_disabled
;
3621 /* Create a master std::terminate breakpoint. */
3623 create_std_terminate_master_breakpoint (void)
3625 struct program_space
*pspace
;
3626 const char *const func_name
= "std::terminate()";
3628 scoped_restore_current_program_space restore_pspace
;
3630 ALL_PSPACES (pspace
)
3632 struct objfile
*objfile
;
3635 set_current_program_space (pspace
);
3637 ALL_OBJFILES (objfile
)
3639 struct breakpoint
*b
;
3640 struct breakpoint_objfile_data
*bp_objfile_data
;
3641 struct explicit_location explicit_loc
;
3643 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3645 if (msym_not_found_p (bp_objfile_data
->terminate_msym
.minsym
))
3648 if (bp_objfile_data
->terminate_msym
.minsym
== NULL
)
3650 struct bound_minimal_symbol m
;
3652 m
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
3653 if (m
.minsym
== NULL
|| (MSYMBOL_TYPE (m
.minsym
) != mst_text
3654 && MSYMBOL_TYPE (m
.minsym
) != mst_file_text
))
3656 /* Prevent future lookups in this objfile. */
3657 bp_objfile_data
->terminate_msym
.minsym
= &msym_not_found
;
3660 bp_objfile_data
->terminate_msym
= m
;
3663 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->terminate_msym
);
3664 b
= create_internal_breakpoint (get_objfile_arch (objfile
), addr
,
3665 bp_std_terminate_master
,
3666 &internal_breakpoint_ops
);
3667 initialize_explicit_location (&explicit_loc
);
3668 explicit_loc
.function_name
= ASTRDUP (func_name
);
3669 b
->location
= new_explicit_location (&explicit_loc
);
3670 b
->enable_state
= bp_disabled
;
3675 /* Install a master breakpoint on the unwinder's debug hook. */
3678 create_exception_master_breakpoint (void)
3680 struct objfile
*objfile
;
3681 const char *const func_name
= "_Unwind_DebugHook";
3683 ALL_OBJFILES (objfile
)
3685 struct breakpoint
*b
;
3686 struct gdbarch
*gdbarch
;
3687 struct breakpoint_objfile_data
*bp_objfile_data
;
3689 struct explicit_location explicit_loc
;
3691 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3693 /* We prefer the SystemTap probe point if it exists. */
3694 if (!bp_objfile_data
->exception_searched
)
3698 ret
= find_probes_in_objfile (objfile
, "libgcc", "unwind");
3702 /* We are only interested in checking one element. */
3703 struct probe
*p
= VEC_index (probe_p
, ret
, 0);
3705 if (!can_evaluate_probe_arguments (p
))
3707 /* We cannot use the probe interface here, because it does
3708 not know how to evaluate arguments. */
3709 VEC_free (probe_p
, ret
);
3713 bp_objfile_data
->exception_probes
= ret
;
3714 bp_objfile_data
->exception_searched
= 1;
3717 if (bp_objfile_data
->exception_probes
!= NULL
)
3719 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3721 struct probe
*probe
;
3724 VEC_iterate (probe_p
,
3725 bp_objfile_data
->exception_probes
,
3729 struct breakpoint
*b
;
3731 b
= create_internal_breakpoint (gdbarch
,
3732 get_probe_address (probe
,
3734 bp_exception_master
,
3735 &internal_breakpoint_ops
);
3736 b
->location
= new_probe_location ("-probe-stap libgcc:unwind");
3737 b
->enable_state
= bp_disabled
;
3743 /* Otherwise, try the hook function. */
3745 if (msym_not_found_p (bp_objfile_data
->exception_msym
.minsym
))
3748 gdbarch
= get_objfile_arch (objfile
);
3750 if (bp_objfile_data
->exception_msym
.minsym
== NULL
)
3752 struct bound_minimal_symbol debug_hook
;
3754 debug_hook
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
3755 if (debug_hook
.minsym
== NULL
)
3757 bp_objfile_data
->exception_msym
.minsym
= &msym_not_found
;
3761 bp_objfile_data
->exception_msym
= debug_hook
;
3764 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->exception_msym
);
3765 addr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, addr
,
3767 b
= create_internal_breakpoint (gdbarch
, addr
, bp_exception_master
,
3768 &internal_breakpoint_ops
);
3769 initialize_explicit_location (&explicit_loc
);
3770 explicit_loc
.function_name
= ASTRDUP (func_name
);
3771 b
->location
= new_explicit_location (&explicit_loc
);
3772 b
->enable_state
= bp_disabled
;
3776 /* Does B have a location spec? */
3779 breakpoint_event_location_empty_p (const struct breakpoint
*b
)
3781 return b
->location
!= NULL
&& event_location_empty_p (b
->location
.get ());
3785 update_breakpoints_after_exec (void)
3787 struct breakpoint
*b
, *b_tmp
;
3788 struct bp_location
*bploc
, **bplocp_tmp
;
3790 /* We're about to delete breakpoints from GDB's lists. If the
3791 INSERTED flag is true, GDB will try to lift the breakpoints by
3792 writing the breakpoints' "shadow contents" back into memory. The
3793 "shadow contents" are NOT valid after an exec, so GDB should not
3794 do that. Instead, the target is responsible from marking
3795 breakpoints out as soon as it detects an exec. We don't do that
3796 here instead, because there may be other attempts to delete
3797 breakpoints after detecting an exec and before reaching here. */
3798 ALL_BP_LOCATIONS (bploc
, bplocp_tmp
)
3799 if (bploc
->pspace
== current_program_space
)
3800 gdb_assert (!bploc
->inserted
);
3802 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
3804 if (b
->pspace
!= current_program_space
)
3807 /* Solib breakpoints must be explicitly reset after an exec(). */
3808 if (b
->type
== bp_shlib_event
)
3810 delete_breakpoint (b
);
3814 /* JIT breakpoints must be explicitly reset after an exec(). */
3815 if (b
->type
== bp_jit_event
)
3817 delete_breakpoint (b
);
3821 /* Thread event breakpoints must be set anew after an exec(),
3822 as must overlay event and longjmp master breakpoints. */
3823 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
3824 || b
->type
== bp_longjmp_master
|| b
->type
== bp_std_terminate_master
3825 || b
->type
== bp_exception_master
)
3827 delete_breakpoint (b
);
3831 /* Step-resume breakpoints are meaningless after an exec(). */
3832 if (b
->type
== bp_step_resume
|| b
->type
== bp_hp_step_resume
)
3834 delete_breakpoint (b
);
3838 /* Just like single-step breakpoints. */
3839 if (b
->type
== bp_single_step
)
3841 delete_breakpoint (b
);
3845 /* Longjmp and longjmp-resume breakpoints are also meaningless
3847 if (b
->type
== bp_longjmp
|| b
->type
== bp_longjmp_resume
3848 || b
->type
== bp_longjmp_call_dummy
3849 || b
->type
== bp_exception
|| b
->type
== bp_exception_resume
)
3851 delete_breakpoint (b
);
3855 if (b
->type
== bp_catchpoint
)
3857 /* For now, none of the bp_catchpoint breakpoints need to
3858 do anything at this point. In the future, if some of
3859 the catchpoints need to something, we will need to add
3860 a new method, and call this method from here. */
3864 /* bp_finish is a special case. The only way we ought to be able
3865 to see one of these when an exec() has happened, is if the user
3866 caught a vfork, and then said "finish". Ordinarily a finish just
3867 carries them to the call-site of the current callee, by setting
3868 a temporary bp there and resuming. But in this case, the finish
3869 will carry them entirely through the vfork & exec.
3871 We don't want to allow a bp_finish to remain inserted now. But
3872 we can't safely delete it, 'cause finish_command has a handle to
3873 the bp on a bpstat, and will later want to delete it. There's a
3874 chance (and I've seen it happen) that if we delete the bp_finish
3875 here, that its storage will get reused by the time finish_command
3876 gets 'round to deleting the "use to be a bp_finish" breakpoint.
3877 We really must allow finish_command to delete a bp_finish.
3879 In the absence of a general solution for the "how do we know
3880 it's safe to delete something others may have handles to?"
3881 problem, what we'll do here is just uninsert the bp_finish, and
3882 let finish_command delete it.
3884 (We know the bp_finish is "doomed" in the sense that it's
3885 momentary, and will be deleted as soon as finish_command sees
3886 the inferior stopped. So it doesn't matter that the bp's
3887 address is probably bogus in the new a.out, unlike e.g., the
3888 solib breakpoints.) */
3890 if (b
->type
== bp_finish
)
3895 /* Without a symbolic address, we have little hope of the
3896 pre-exec() address meaning the same thing in the post-exec()
3898 if (breakpoint_event_location_empty_p (b
))
3900 delete_breakpoint (b
);
3907 detach_breakpoints (ptid_t ptid
)
3909 struct bp_location
*bl
, **blp_tmp
;
3911 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
3912 struct inferior
*inf
= current_inferior ();
3914 if (ptid_get_pid (ptid
) == ptid_get_pid (inferior_ptid
))
3915 error (_("Cannot detach breakpoints of inferior_ptid"));
3917 /* Set inferior_ptid; remove_breakpoint_1 uses this global. */
3918 inferior_ptid
= ptid
;
3919 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3921 if (bl
->pspace
!= inf
->pspace
)
3924 /* This function must physically remove breakpoints locations
3925 from the specified ptid, without modifying the breakpoint
3926 package's state. Locations of type bp_loc_other are only
3927 maintained at GDB side. So, there is no need to remove
3928 these bp_loc_other locations. Moreover, removing these
3929 would modify the breakpoint package's state. */
3930 if (bl
->loc_type
== bp_loc_other
)
3934 val
|= remove_breakpoint_1 (bl
, DETACH_BREAKPOINT
);
3940 /* Remove the breakpoint location BL from the current address space.
3941 Note that this is used to detach breakpoints from a child fork.
3942 When we get here, the child isn't in the inferior list, and neither
3943 do we have objects to represent its address space --- we should
3944 *not* look at bl->pspace->aspace here. */
3947 remove_breakpoint_1 (struct bp_location
*bl
, enum remove_bp_reason reason
)
3951 /* BL is never in moribund_locations by our callers. */
3952 gdb_assert (bl
->owner
!= NULL
);
3954 /* The type of none suggests that owner is actually deleted.
3955 This should not ever happen. */
3956 gdb_assert (bl
->owner
->type
!= bp_none
);
3958 if (bl
->loc_type
== bp_loc_software_breakpoint
3959 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
3961 /* "Normal" instruction breakpoint: either the standard
3962 trap-instruction bp (bp_breakpoint), or a
3963 bp_hardware_breakpoint. */
3965 /* First check to see if we have to handle an overlay. */
3966 if (overlay_debugging
== ovly_off
3967 || bl
->section
== NULL
3968 || !(section_is_overlay (bl
->section
)))
3970 /* No overlay handling: just remove the breakpoint. */
3972 /* If we're trying to uninsert a memory breakpoint that we
3973 know is set in a dynamic object that is marked
3974 shlib_disabled, then either the dynamic object was
3975 removed with "remove-symbol-file" or with
3976 "nosharedlibrary". In the former case, we don't know
3977 whether another dynamic object might have loaded over the
3978 breakpoint's address -- the user might well let us know
3979 about it next with add-symbol-file (the whole point of
3980 add-symbol-file is letting the user manually maintain a
3981 list of dynamically loaded objects). If we have the
3982 breakpoint's shadow memory, that is, this is a software
3983 breakpoint managed by GDB, check whether the breakpoint
3984 is still inserted in memory, to avoid overwriting wrong
3985 code with stale saved shadow contents. Note that HW
3986 breakpoints don't have shadow memory, as they're
3987 implemented using a mechanism that is not dependent on
3988 being able to modify the target's memory, and as such
3989 they should always be removed. */
3990 if (bl
->shlib_disabled
3991 && bl
->target_info
.shadow_len
!= 0
3992 && !memory_validate_breakpoint (bl
->gdbarch
, &bl
->target_info
))
3995 val
= bl
->owner
->ops
->remove_location (bl
, reason
);
3999 /* This breakpoint is in an overlay section.
4000 Did we set a breakpoint at the LMA? */
4001 if (!overlay_events_enabled
)
4003 /* Yes -- overlay event support is not active, so we
4004 should have set a breakpoint at the LMA. Remove it.
4006 /* Ignore any failures: if the LMA is in ROM, we will
4007 have already warned when we failed to insert it. */
4008 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
4009 target_remove_hw_breakpoint (bl
->gdbarch
,
4010 &bl
->overlay_target_info
);
4012 target_remove_breakpoint (bl
->gdbarch
,
4013 &bl
->overlay_target_info
,
4016 /* Did we set a breakpoint at the VMA?
4017 If so, we will have marked the breakpoint 'inserted'. */
4020 /* Yes -- remove it. Previously we did not bother to
4021 remove the breakpoint if the section had been
4022 unmapped, but let's not rely on that being safe. We
4023 don't know what the overlay manager might do. */
4025 /* However, we should remove *software* breakpoints only
4026 if the section is still mapped, or else we overwrite
4027 wrong code with the saved shadow contents. */
4028 if (bl
->loc_type
== bp_loc_hardware_breakpoint
4029 || section_is_mapped (bl
->section
))
4030 val
= bl
->owner
->ops
->remove_location (bl
, reason
);
4036 /* No -- not inserted, so no need to remove. No error. */
4041 /* In some cases, we might not be able to remove a breakpoint in
4042 a shared library that has already been removed, but we have
4043 not yet processed the shlib unload event. Similarly for an
4044 unloaded add-symbol-file object - the user might not yet have
4045 had the chance to remove-symbol-file it. shlib_disabled will
4046 be set if the library/object has already been removed, but
4047 the breakpoint hasn't been uninserted yet, e.g., after
4048 "nosharedlibrary" or "remove-symbol-file" with breakpoints
4049 always-inserted mode. */
4051 && (bl
->loc_type
== bp_loc_software_breakpoint
4052 && (bl
->shlib_disabled
4053 || solib_name_from_address (bl
->pspace
, bl
->address
)
4054 || shared_objfile_contains_address_p (bl
->pspace
,
4060 bl
->inserted
= (reason
== DETACH_BREAKPOINT
);
4062 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
)
4064 gdb_assert (bl
->owner
->ops
!= NULL
4065 && bl
->owner
->ops
->remove_location
!= NULL
);
4067 bl
->inserted
= (reason
== DETACH_BREAKPOINT
);
4068 bl
->owner
->ops
->remove_location (bl
, reason
);
4070 /* Failure to remove any of the hardware watchpoints comes here. */
4071 if (reason
== REMOVE_BREAKPOINT
&& bl
->inserted
)
4072 warning (_("Could not remove hardware watchpoint %d."),
4075 else if (bl
->owner
->type
== bp_catchpoint
4076 && breakpoint_enabled (bl
->owner
)
4079 gdb_assert (bl
->owner
->ops
!= NULL
4080 && bl
->owner
->ops
->remove_location
!= NULL
);
4082 val
= bl
->owner
->ops
->remove_location (bl
, reason
);
4086 bl
->inserted
= (reason
== DETACH_BREAKPOINT
);
4093 remove_breakpoint (struct bp_location
*bl
)
4095 /* BL is never in moribund_locations by our callers. */
4096 gdb_assert (bl
->owner
!= NULL
);
4098 /* The type of none suggests that owner is actually deleted.
4099 This should not ever happen. */
4100 gdb_assert (bl
->owner
->type
!= bp_none
);
4102 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
4104 switch_to_program_space_and_thread (bl
->pspace
);
4106 return remove_breakpoint_1 (bl
, REMOVE_BREAKPOINT
);
4109 /* Clear the "inserted" flag in all breakpoints. */
4112 mark_breakpoints_out (void)
4114 struct bp_location
*bl
, **blp_tmp
;
4116 ALL_BP_LOCATIONS (bl
, blp_tmp
)
4117 if (bl
->pspace
== current_program_space
)
4121 /* Clear the "inserted" flag in all breakpoints and delete any
4122 breakpoints which should go away between runs of the program.
4124 Plus other such housekeeping that has to be done for breakpoints
4127 Note: this function gets called at the end of a run (by
4128 generic_mourn_inferior) and when a run begins (by
4129 init_wait_for_inferior). */
4134 breakpoint_init_inferior (enum inf_context context
)
4136 struct breakpoint
*b
, *b_tmp
;
4137 struct bp_location
*bl
;
4139 struct program_space
*pspace
= current_program_space
;
4141 /* If breakpoint locations are shared across processes, then there's
4143 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
4146 mark_breakpoints_out ();
4148 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
4150 if (b
->loc
&& b
->loc
->pspace
!= pspace
)
4156 case bp_longjmp_call_dummy
:
4158 /* If the call dummy breakpoint is at the entry point it will
4159 cause problems when the inferior is rerun, so we better get
4162 case bp_watchpoint_scope
:
4164 /* Also get rid of scope breakpoints. */
4166 case bp_shlib_event
:
4168 /* Also remove solib event breakpoints. Their addresses may
4169 have changed since the last time we ran the program.
4170 Actually we may now be debugging against different target;
4171 and so the solib backend that installed this breakpoint may
4172 not be used in by the target. E.g.,
4174 (gdb) file prog-linux
4175 (gdb) run # native linux target
4178 (gdb) file prog-win.exe
4179 (gdb) tar rem :9999 # remote Windows gdbserver.
4182 case bp_step_resume
:
4184 /* Also remove step-resume breakpoints. */
4186 case bp_single_step
:
4188 /* Also remove single-step breakpoints. */
4190 delete_breakpoint (b
);
4194 case bp_hardware_watchpoint
:
4195 case bp_read_watchpoint
:
4196 case bp_access_watchpoint
:
4198 struct watchpoint
*w
= (struct watchpoint
*) b
;
4200 /* Likewise for watchpoints on local expressions. */
4201 if (w
->exp_valid_block
!= NULL
)
4202 delete_breakpoint (b
);
4205 /* Get rid of existing locations, which are no longer
4206 valid. New ones will be created in
4207 update_watchpoint, when the inferior is restarted.
4208 The next update_global_location_list call will
4209 garbage collect them. */
4212 if (context
== inf_starting
)
4214 /* Reset val field to force reread of starting value in
4215 insert_breakpoints. */
4217 value_free (w
->val
);
4229 /* Get rid of the moribund locations. */
4230 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, bl
); ++ix
)
4231 decref_bp_location (&bl
);
4232 VEC_free (bp_location_p
, moribund_locations
);
4235 /* These functions concern about actual breakpoints inserted in the
4236 target --- to e.g. check if we need to do decr_pc adjustment or if
4237 we need to hop over the bkpt --- so we check for address space
4238 match, not program space. */
4240 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
4241 exists at PC. It returns ordinary_breakpoint_here if it's an
4242 ordinary breakpoint, or permanent_breakpoint_here if it's a
4243 permanent breakpoint.
4244 - When continuing from a location with an ordinary breakpoint, we
4245 actually single step once before calling insert_breakpoints.
4246 - When continuing from a location with a permanent breakpoint, we
4247 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
4248 the target, to advance the PC past the breakpoint. */
4250 enum breakpoint_here
4251 breakpoint_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
4253 struct bp_location
*bl
, **blp_tmp
;
4254 int any_breakpoint_here
= 0;
4256 ALL_BP_LOCATIONS (bl
, blp_tmp
)
4258 if (bl
->loc_type
!= bp_loc_software_breakpoint
4259 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4262 /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
4263 if ((breakpoint_enabled (bl
->owner
)
4265 && breakpoint_location_address_match (bl
, aspace
, pc
))
4267 if (overlay_debugging
4268 && section_is_overlay (bl
->section
)
4269 && !section_is_mapped (bl
->section
))
4270 continue; /* unmapped overlay -- can't be a match */
4271 else if (bl
->permanent
)
4272 return permanent_breakpoint_here
;
4274 any_breakpoint_here
= 1;
4278 return any_breakpoint_here
? ordinary_breakpoint_here
: no_breakpoint_here
;
4281 /* See breakpoint.h. */
4284 breakpoint_in_range_p (struct address_space
*aspace
,
4285 CORE_ADDR addr
, ULONGEST len
)
4287 struct bp_location
*bl
, **blp_tmp
;
4289 ALL_BP_LOCATIONS (bl
, blp_tmp
)
4291 if (bl
->loc_type
!= bp_loc_software_breakpoint
4292 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4295 if ((breakpoint_enabled (bl
->owner
)
4297 && breakpoint_location_address_range_overlap (bl
, aspace
,
4300 if (overlay_debugging
4301 && section_is_overlay (bl
->section
)
4302 && !section_is_mapped (bl
->section
))
4304 /* Unmapped overlay -- can't be a match. */
4315 /* Return true if there's a moribund breakpoint at PC. */
4318 moribund_breakpoint_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
4320 struct bp_location
*loc
;
4323 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
4324 if (breakpoint_location_address_match (loc
, aspace
, pc
))
4330 /* Returns non-zero iff BL is inserted at PC, in address space
4334 bp_location_inserted_here_p (struct bp_location
*bl
,
4335 struct address_space
*aspace
, CORE_ADDR pc
)
4338 && breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
4341 if (overlay_debugging
4342 && section_is_overlay (bl
->section
)
4343 && !section_is_mapped (bl
->section
))
4344 return 0; /* unmapped overlay -- can't be a match */
4351 /* Returns non-zero iff there's a breakpoint inserted at PC. */
4354 breakpoint_inserted_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
4356 struct bp_location
**blp
, **blp_tmp
= NULL
;
4358 ALL_BP_LOCATIONS_AT_ADDR (blp
, blp_tmp
, pc
)
4360 struct bp_location
*bl
= *blp
;
4362 if (bl
->loc_type
!= bp_loc_software_breakpoint
4363 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4366 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4372 /* This function returns non-zero iff there is a software breakpoint
4376 software_breakpoint_inserted_here_p (struct address_space
*aspace
,
4379 struct bp_location
**blp
, **blp_tmp
= NULL
;
4381 ALL_BP_LOCATIONS_AT_ADDR (blp
, blp_tmp
, pc
)
4383 struct bp_location
*bl
= *blp
;
4385 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
4388 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4395 /* See breakpoint.h. */
4398 hardware_breakpoint_inserted_here_p (struct address_space
*aspace
,
4401 struct bp_location
**blp
, **blp_tmp
= NULL
;
4403 ALL_BP_LOCATIONS_AT_ADDR (blp
, blp_tmp
, pc
)
4405 struct bp_location
*bl
= *blp
;
4407 if (bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4410 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4418 hardware_watchpoint_inserted_in_range (struct address_space
*aspace
,
4419 CORE_ADDR addr
, ULONGEST len
)
4421 struct breakpoint
*bpt
;
4423 ALL_BREAKPOINTS (bpt
)
4425 struct bp_location
*loc
;
4427 if (bpt
->type
!= bp_hardware_watchpoint
4428 && bpt
->type
!= bp_access_watchpoint
)
4431 if (!breakpoint_enabled (bpt
))
4434 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
4435 if (loc
->pspace
->aspace
== aspace
&& loc
->inserted
)
4439 /* Check for intersection. */
4440 l
= std::max
<CORE_ADDR
> (loc
->address
, addr
);
4441 h
= std::min
<CORE_ADDR
> (loc
->address
+ loc
->length
, addr
+ len
);
4450 /* bpstat stuff. External routines' interfaces are documented
4454 is_catchpoint (struct breakpoint
*ep
)
4456 return (ep
->type
== bp_catchpoint
);
4459 /* Frees any storage that is part of a bpstat. Does not walk the
4463 bpstat_free (bpstat bs
)
4465 if (bs
->old_val
!= NULL
)
4466 value_free (bs
->old_val
);
4467 decref_counted_command_line (&bs
->commands
);
4468 decref_bp_location (&bs
->bp_location_at
);
4472 /* Clear a bpstat so that it says we are not at any breakpoint.
4473 Also free any storage that is part of a bpstat. */
4476 bpstat_clear (bpstat
*bsp
)
4493 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
4494 is part of the bpstat is copied as well. */
4497 bpstat_copy (bpstat bs
)
4501 bpstat retval
= NULL
;
4506 for (; bs
!= NULL
; bs
= bs
->next
)
4508 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
4509 memcpy (tmp
, bs
, sizeof (*tmp
));
4510 incref_counted_command_line (tmp
->commands
);
4511 incref_bp_location (tmp
->bp_location_at
);
4512 if (bs
->old_val
!= NULL
)
4514 tmp
->old_val
= value_copy (bs
->old_val
);
4515 release_value (tmp
->old_val
);
4519 /* This is the first thing in the chain. */
4529 /* Find the bpstat associated with this breakpoint. */
4532 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
4537 for (; bsp
!= NULL
; bsp
= bsp
->next
)
4539 if (bsp
->breakpoint_at
== breakpoint
)
4545 /* See breakpoint.h. */
4548 bpstat_explains_signal (bpstat bsp
, enum gdb_signal sig
)
4550 for (; bsp
!= NULL
; bsp
= bsp
->next
)
4552 if (bsp
->breakpoint_at
== NULL
)
4554 /* A moribund location can never explain a signal other than
4556 if (sig
== GDB_SIGNAL_TRAP
)
4561 if (bsp
->breakpoint_at
->ops
->explains_signal (bsp
->breakpoint_at
,
4570 /* Put in *NUM the breakpoint number of the first breakpoint we are
4571 stopped at. *BSP upon return is a bpstat which points to the
4572 remaining breakpoints stopped at (but which is not guaranteed to be
4573 good for anything but further calls to bpstat_num).
4575 Return 0 if passed a bpstat which does not indicate any breakpoints.
4576 Return -1 if stopped at a breakpoint that has been deleted since
4578 Return 1 otherwise. */
4581 bpstat_num (bpstat
*bsp
, int *num
)
4583 struct breakpoint
*b
;
4586 return 0; /* No more breakpoint values */
4588 /* We assume we'll never have several bpstats that correspond to a
4589 single breakpoint -- otherwise, this function might return the
4590 same number more than once and this will look ugly. */
4591 b
= (*bsp
)->breakpoint_at
;
4592 *bsp
= (*bsp
)->next
;
4594 return -1; /* breakpoint that's been deleted since */
4596 *num
= b
->number
; /* We have its number */
4600 /* See breakpoint.h. */
4603 bpstat_clear_actions (void)
4605 struct thread_info
*tp
;
4608 if (ptid_equal (inferior_ptid
, null_ptid
))
4611 tp
= find_thread_ptid (inferior_ptid
);
4615 for (bs
= tp
->control
.stop_bpstat
; bs
!= NULL
; bs
= bs
->next
)
4617 decref_counted_command_line (&bs
->commands
);
4619 if (bs
->old_val
!= NULL
)
4621 value_free (bs
->old_val
);
4627 /* Called when a command is about to proceed the inferior. */
4630 breakpoint_about_to_proceed (void)
4632 if (!ptid_equal (inferior_ptid
, null_ptid
))
4634 struct thread_info
*tp
= inferior_thread ();
4636 /* Allow inferior function calls in breakpoint commands to not
4637 interrupt the command list. When the call finishes
4638 successfully, the inferior will be standing at the same
4639 breakpoint as if nothing happened. */
4640 if (tp
->control
.in_infcall
)
4644 breakpoint_proceeded
= 1;
4647 /* Stub for cleaning up our state if we error-out of a breakpoint
4650 cleanup_executing_breakpoints (void *ignore
)
4652 executing_breakpoint_commands
= 0;
4655 /* Return non-zero iff CMD as the first line of a command sequence is `silent'
4656 or its equivalent. */
4659 command_line_is_silent (struct command_line
*cmd
)
4661 return cmd
&& (strcmp ("silent", cmd
->line
) == 0);
4664 /* Execute all the commands associated with all the breakpoints at
4665 this location. Any of these commands could cause the process to
4666 proceed beyond this point, etc. We look out for such changes by
4667 checking the global "breakpoint_proceeded" after each command.
4669 Returns true if a breakpoint command resumed the inferior. In that
4670 case, it is the caller's responsibility to recall it again with the
4671 bpstat of the current thread. */
4674 bpstat_do_actions_1 (bpstat
*bsp
)
4677 struct cleanup
*old_chain
;
4680 /* Avoid endless recursion if a `source' command is contained
4682 if (executing_breakpoint_commands
)
4685 executing_breakpoint_commands
= 1;
4686 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
4688 scoped_restore preventer
= prevent_dont_repeat ();
4690 /* This pointer will iterate over the list of bpstat's. */
4693 breakpoint_proceeded
= 0;
4694 for (; bs
!= NULL
; bs
= bs
->next
)
4696 struct counted_command_line
*ccmd
;
4697 struct command_line
*cmd
;
4698 struct cleanup
*this_cmd_tree_chain
;
4700 /* Take ownership of the BSP's command tree, if it has one.
4702 The command tree could legitimately contain commands like
4703 'step' and 'next', which call clear_proceed_status, which
4704 frees stop_bpstat's command tree. To make sure this doesn't
4705 free the tree we're executing out from under us, we need to
4706 take ownership of the tree ourselves. Since a given bpstat's
4707 commands are only executed once, we don't need to copy it; we
4708 can clear the pointer in the bpstat, and make sure we free
4709 the tree when we're done. */
4710 ccmd
= bs
->commands
;
4711 bs
->commands
= NULL
;
4712 this_cmd_tree_chain
= make_cleanup_decref_counted_command_line (&ccmd
);
4713 cmd
= ccmd
? ccmd
->commands
: NULL
;
4714 if (command_line_is_silent (cmd
))
4716 /* The action has been already done by bpstat_stop_status. */
4722 execute_control_command (cmd
);
4724 if (breakpoint_proceeded
)
4730 /* We can free this command tree now. */
4731 do_cleanups (this_cmd_tree_chain
);
4733 if (breakpoint_proceeded
)
4735 if (current_ui
->async
)
4736 /* If we are in async mode, then the target might be still
4737 running, not stopped at any breakpoint, so nothing for
4738 us to do here -- just return to the event loop. */
4741 /* In sync mode, when execute_control_command returns
4742 we're already standing on the next breakpoint.
4743 Breakpoint commands for that stop were not run, since
4744 execute_command does not run breakpoint commands --
4745 only command_line_handler does, but that one is not
4746 involved in execution of breakpoint commands. So, we
4747 can now execute breakpoint commands. It should be
4748 noted that making execute_command do bpstat actions is
4749 not an option -- in this case we'll have recursive
4750 invocation of bpstat for each breakpoint with a
4751 command, and can easily blow up GDB stack. Instead, we
4752 return true, which will trigger the caller to recall us
4753 with the new stop_bpstat. */
4758 do_cleanups (old_chain
);
4763 bpstat_do_actions (void)
4765 struct cleanup
*cleanup_if_error
= make_bpstat_clear_actions_cleanup ();
4767 /* Do any commands attached to breakpoint we are stopped at. */
4768 while (!ptid_equal (inferior_ptid
, null_ptid
)
4769 && target_has_execution
4770 && !is_exited (inferior_ptid
)
4771 && !is_executing (inferior_ptid
))
4772 /* Since in sync mode, bpstat_do_actions may resume the inferior,
4773 and only return when it is stopped at the next breakpoint, we
4774 keep doing breakpoint actions until it returns false to
4775 indicate the inferior was not resumed. */
4776 if (!bpstat_do_actions_1 (&inferior_thread ()->control
.stop_bpstat
))
4779 discard_cleanups (cleanup_if_error
);
4782 /* Print out the (old or new) value associated with a watchpoint. */
4785 watchpoint_value_print (struct value
*val
, struct ui_file
*stream
)
4788 fprintf_unfiltered (stream
, _("<unreadable>"));
4791 struct value_print_options opts
;
4792 get_user_print_options (&opts
);
4793 value_print (val
, stream
, &opts
);
4797 /* Print the "Thread ID hit" part of "Thread ID hit Breakpoint N" if
4798 debugging multiple threads. */
4801 maybe_print_thread_hit_breakpoint (struct ui_out
*uiout
)
4803 if (uiout
->is_mi_like_p ())
4808 if (show_thread_that_caused_stop ())
4811 struct thread_info
*thr
= inferior_thread ();
4813 uiout
->text ("Thread ");
4814 uiout
->field_fmt ("thread-id", "%s", print_thread_id (thr
));
4816 name
= thr
->name
!= NULL
? thr
->name
: target_thread_name (thr
);
4819 uiout
->text (" \"");
4820 uiout
->field_fmt ("name", "%s", name
);
4824 uiout
->text (" hit ");
4828 /* Generic routine for printing messages indicating why we
4829 stopped. The behavior of this function depends on the value
4830 'print_it' in the bpstat structure. Under some circumstances we
4831 may decide not to print anything here and delegate the task to
4834 static enum print_stop_action
4835 print_bp_stop_message (bpstat bs
)
4837 switch (bs
->print_it
)
4840 /* Nothing should be printed for this bpstat entry. */
4841 return PRINT_UNKNOWN
;
4845 /* We still want to print the frame, but we already printed the
4846 relevant messages. */
4847 return PRINT_SRC_AND_LOC
;
4850 case print_it_normal
:
4852 struct breakpoint
*b
= bs
->breakpoint_at
;
4854 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
4855 which has since been deleted. */
4857 return PRINT_UNKNOWN
;
4859 /* Normal case. Call the breakpoint's print_it method. */
4860 return b
->ops
->print_it (bs
);
4865 internal_error (__FILE__
, __LINE__
,
4866 _("print_bp_stop_message: unrecognized enum value"));
4871 /* A helper function that prints a shared library stopped event. */
4874 print_solib_event (int is_catchpoint
)
4877 = !VEC_empty (char_ptr
, current_program_space
->deleted_solibs
);
4879 = !VEC_empty (so_list_ptr
, current_program_space
->added_solibs
);
4883 if (any_added
|| any_deleted
)
4884 current_uiout
->text (_("Stopped due to shared library event:\n"));
4886 current_uiout
->text (_("Stopped due to shared library event (no "
4887 "libraries added or removed)\n"));
4890 if (current_uiout
->is_mi_like_p ())
4891 current_uiout
->field_string ("reason",
4892 async_reason_lookup (EXEC_ASYNC_SOLIB_EVENT
));
4899 current_uiout
->text (_(" Inferior unloaded "));
4900 ui_out_emit_list
list_emitter (current_uiout
, "removed");
4902 VEC_iterate (char_ptr
, current_program_space
->deleted_solibs
,
4907 current_uiout
->text (" ");
4908 current_uiout
->field_string ("library", name
);
4909 current_uiout
->text ("\n");
4915 struct so_list
*iter
;
4918 current_uiout
->text (_(" Inferior loaded "));
4919 ui_out_emit_list
list_emitter (current_uiout
, "added");
4921 VEC_iterate (so_list_ptr
, current_program_space
->added_solibs
,
4926 current_uiout
->text (" ");
4927 current_uiout
->field_string ("library", iter
->so_name
);
4928 current_uiout
->text ("\n");
4933 /* Print a message indicating what happened. This is called from
4934 normal_stop(). The input to this routine is the head of the bpstat
4935 list - a list of the eventpoints that caused this stop. KIND is
4936 the target_waitkind for the stopping event. This
4937 routine calls the generic print routine for printing a message
4938 about reasons for stopping. This will print (for example) the
4939 "Breakpoint n," part of the output. The return value of this
4942 PRINT_UNKNOWN: Means we printed nothing.
4943 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
4944 code to print the location. An example is
4945 "Breakpoint 1, " which should be followed by
4947 PRINT_SRC_ONLY: Means we printed something, but there is no need
4948 to also print the location part of the message.
4949 An example is the catch/throw messages, which
4950 don't require a location appended to the end.
4951 PRINT_NOTHING: We have done some printing and we don't need any
4952 further info to be printed. */
4954 enum print_stop_action
4955 bpstat_print (bpstat bs
, int kind
)
4957 enum print_stop_action val
;
4959 /* Maybe another breakpoint in the chain caused us to stop.
4960 (Currently all watchpoints go on the bpstat whether hit or not.
4961 That probably could (should) be changed, provided care is taken
4962 with respect to bpstat_explains_signal). */
4963 for (; bs
; bs
= bs
->next
)
4965 val
= print_bp_stop_message (bs
);
4966 if (val
== PRINT_SRC_ONLY
4967 || val
== PRINT_SRC_AND_LOC
4968 || val
== PRINT_NOTHING
)
4972 /* If we had hit a shared library event breakpoint,
4973 print_bp_stop_message would print out this message. If we hit an
4974 OS-level shared library event, do the same thing. */
4975 if (kind
== TARGET_WAITKIND_LOADED
)
4977 print_solib_event (0);
4978 return PRINT_NOTHING
;
4981 /* We reached the end of the chain, or we got a null BS to start
4982 with and nothing was printed. */
4983 return PRINT_UNKNOWN
;
4986 /* Evaluate the expression EXP and return 1 if value is zero.
4987 This returns the inverse of the condition because it is called
4988 from catch_errors which returns 0 if an exception happened, and if an
4989 exception happens we want execution to stop.
4990 The argument is a "struct expression *" that has been cast to a
4991 "void *" to make it pass through catch_errors. */
4994 breakpoint_cond_eval (void *exp
)
4996 struct value
*mark
= value_mark ();
4997 int i
= !value_true (evaluate_expression ((struct expression
*) exp
));
4999 value_free_to_mark (mark
);
5003 /* Allocate a new bpstat. Link it to the FIFO list by BS_LINK_POINTER. */
5006 bpstat_alloc (struct bp_location
*bl
, bpstat
**bs_link_pointer
)
5010 bs
= (bpstat
) xmalloc (sizeof (*bs
));
5012 **bs_link_pointer
= bs
;
5013 *bs_link_pointer
= &bs
->next
;
5014 bs
->breakpoint_at
= bl
->owner
;
5015 bs
->bp_location_at
= bl
;
5016 incref_bp_location (bl
);
5017 /* If the condition is false, etc., don't do the commands. */
5018 bs
->commands
= NULL
;
5020 bs
->print_it
= print_it_normal
;
5024 /* The target has stopped with waitstatus WS. Check if any hardware
5025 watchpoints have triggered, according to the target. */
5028 watchpoints_triggered (struct target_waitstatus
*ws
)
5030 int stopped_by_watchpoint
= target_stopped_by_watchpoint ();
5032 struct breakpoint
*b
;
5034 if (!stopped_by_watchpoint
)
5036 /* We were not stopped by a watchpoint. Mark all watchpoints
5037 as not triggered. */
5039 if (is_hardware_watchpoint (b
))
5041 struct watchpoint
*w
= (struct watchpoint
*) b
;
5043 w
->watchpoint_triggered
= watch_triggered_no
;
5049 if (!target_stopped_data_address (¤t_target
, &addr
))
5051 /* We were stopped by a watchpoint, but we don't know where.
5052 Mark all watchpoints as unknown. */
5054 if (is_hardware_watchpoint (b
))
5056 struct watchpoint
*w
= (struct watchpoint
*) b
;
5058 w
->watchpoint_triggered
= watch_triggered_unknown
;
5064 /* The target could report the data address. Mark watchpoints
5065 affected by this data address as triggered, and all others as not
5069 if (is_hardware_watchpoint (b
))
5071 struct watchpoint
*w
= (struct watchpoint
*) b
;
5072 struct bp_location
*loc
;
5074 w
->watchpoint_triggered
= watch_triggered_no
;
5075 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
5077 if (is_masked_watchpoint (b
))
5079 CORE_ADDR newaddr
= addr
& w
->hw_wp_mask
;
5080 CORE_ADDR start
= loc
->address
& w
->hw_wp_mask
;
5082 if (newaddr
== start
)
5084 w
->watchpoint_triggered
= watch_triggered_yes
;
5088 /* Exact match not required. Within range is sufficient. */
5089 else if (target_watchpoint_addr_within_range (¤t_target
,
5093 w
->watchpoint_triggered
= watch_triggered_yes
;
5102 /* Possible return values for watchpoint_check (this can't be an enum
5103 because of check_errors). */
5104 /* The watchpoint has been deleted. */
5105 #define WP_DELETED 1
5106 /* The value has changed. */
5107 #define WP_VALUE_CHANGED 2
5108 /* The value has not changed. */
5109 #define WP_VALUE_NOT_CHANGED 3
5110 /* Ignore this watchpoint, no matter if the value changed or not. */
5113 #define BP_TEMPFLAG 1
5114 #define BP_HARDWAREFLAG 2
5116 /* Evaluate watchpoint condition expression and check if its value
5119 P should be a pointer to struct bpstat, but is defined as a void *
5120 in order for this function to be usable with catch_errors. */
5123 watchpoint_check (void *p
)
5125 bpstat bs
= (bpstat
) p
;
5126 struct watchpoint
*b
;
5127 struct frame_info
*fr
;
5128 int within_current_scope
;
5130 /* BS is built from an existing struct breakpoint. */
5131 gdb_assert (bs
->breakpoint_at
!= NULL
);
5132 b
= (struct watchpoint
*) bs
->breakpoint_at
;
5134 /* If this is a local watchpoint, we only want to check if the
5135 watchpoint frame is in scope if the current thread is the thread
5136 that was used to create the watchpoint. */
5137 if (!watchpoint_in_thread_scope (b
))
5140 if (b
->exp_valid_block
== NULL
)
5141 within_current_scope
= 1;
5144 struct frame_info
*frame
= get_current_frame ();
5145 struct gdbarch
*frame_arch
= get_frame_arch (frame
);
5146 CORE_ADDR frame_pc
= get_frame_pc (frame
);
5148 /* stack_frame_destroyed_p() returns a non-zero value if we're
5149 still in the function but the stack frame has already been
5150 invalidated. Since we can't rely on the values of local
5151 variables after the stack has been destroyed, we are treating
5152 the watchpoint in that state as `not changed' without further
5153 checking. Don't mark watchpoints as changed if the current
5154 frame is in an epilogue - even if they are in some other
5155 frame, our view of the stack is likely to be wrong and
5156 frame_find_by_id could error out. */
5157 if (gdbarch_stack_frame_destroyed_p (frame_arch
, frame_pc
))
5160 fr
= frame_find_by_id (b
->watchpoint_frame
);
5161 within_current_scope
= (fr
!= NULL
);
5163 /* If we've gotten confused in the unwinder, we might have
5164 returned a frame that can't describe this variable. */
5165 if (within_current_scope
)
5167 struct symbol
*function
;
5169 function
= get_frame_function (fr
);
5170 if (function
== NULL
5171 || !contained_in (b
->exp_valid_block
,
5172 SYMBOL_BLOCK_VALUE (function
)))
5173 within_current_scope
= 0;
5176 if (within_current_scope
)
5177 /* If we end up stopping, the current frame will get selected
5178 in normal_stop. So this call to select_frame won't affect
5183 if (within_current_scope
)
5185 /* We use value_{,free_to_}mark because it could be a *long*
5186 time before we return to the command level and call
5187 free_all_values. We can't call free_all_values because we
5188 might be in the middle of evaluating a function call. */
5192 struct value
*new_val
;
5194 if (is_masked_watchpoint (b
))
5195 /* Since we don't know the exact trigger address (from
5196 stopped_data_address), just tell the user we've triggered
5197 a mask watchpoint. */
5198 return WP_VALUE_CHANGED
;
5200 mark
= value_mark ();
5201 fetch_subexp_value (b
->exp
.get (), &pc
, &new_val
, NULL
, NULL
, 0);
5203 if (b
->val_bitsize
!= 0)
5204 new_val
= extract_bitfield_from_watchpoint_value (b
, new_val
);
5206 /* We use value_equal_contents instead of value_equal because
5207 the latter coerces an array to a pointer, thus comparing just
5208 the address of the array instead of its contents. This is
5209 not what we want. */
5210 if ((b
->val
!= NULL
) != (new_val
!= NULL
)
5211 || (b
->val
!= NULL
&& !value_equal_contents (b
->val
, new_val
)))
5213 if (new_val
!= NULL
)
5215 release_value (new_val
);
5216 value_free_to_mark (mark
);
5218 bs
->old_val
= b
->val
;
5221 return WP_VALUE_CHANGED
;
5225 /* Nothing changed. */
5226 value_free_to_mark (mark
);
5227 return WP_VALUE_NOT_CHANGED
;
5232 /* This seems like the only logical thing to do because
5233 if we temporarily ignored the watchpoint, then when
5234 we reenter the block in which it is valid it contains
5235 garbage (in the case of a function, it may have two
5236 garbage values, one before and one after the prologue).
5237 So we can't even detect the first assignment to it and
5238 watch after that (since the garbage may or may not equal
5239 the first value assigned). */
5240 /* We print all the stop information in
5241 breakpoint_ops->print_it, but in this case, by the time we
5242 call breakpoint_ops->print_it this bp will be deleted
5243 already. So we have no choice but print the information
5246 SWITCH_THRU_ALL_UIS ()
5248 struct ui_out
*uiout
= current_uiout
;
5250 if (uiout
->is_mi_like_p ())
5252 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
5253 uiout
->text ("\nWatchpoint ");
5254 uiout
->field_int ("wpnum", b
->number
);
5255 uiout
->text (" deleted because the program has left the block in\n"
5256 "which its expression is valid.\n");
5259 /* Make sure the watchpoint's commands aren't executed. */
5260 decref_counted_command_line (&b
->commands
);
5261 watchpoint_del_at_next_stop (b
);
5267 /* Return true if it looks like target has stopped due to hitting
5268 breakpoint location BL. This function does not check if we should
5269 stop, only if BL explains the stop. */
5272 bpstat_check_location (const struct bp_location
*bl
,
5273 struct address_space
*aspace
, CORE_ADDR bp_addr
,
5274 const struct target_waitstatus
*ws
)
5276 struct breakpoint
*b
= bl
->owner
;
5278 /* BL is from an existing breakpoint. */
5279 gdb_assert (b
!= NULL
);
5281 return b
->ops
->breakpoint_hit (bl
, aspace
, bp_addr
, ws
);
5284 /* Determine if the watched values have actually changed, and we
5285 should stop. If not, set BS->stop to 0. */
5288 bpstat_check_watchpoint (bpstat bs
)
5290 const struct bp_location
*bl
;
5291 struct watchpoint
*b
;
5293 /* BS is built for existing struct breakpoint. */
5294 bl
= bs
->bp_location_at
;
5295 gdb_assert (bl
!= NULL
);
5296 b
= (struct watchpoint
*) bs
->breakpoint_at
;
5297 gdb_assert (b
!= NULL
);
5300 int must_check_value
= 0;
5302 if (b
->type
== bp_watchpoint
)
5303 /* For a software watchpoint, we must always check the
5305 must_check_value
= 1;
5306 else if (b
->watchpoint_triggered
== watch_triggered_yes
)
5307 /* We have a hardware watchpoint (read, write, or access)
5308 and the target earlier reported an address watched by
5310 must_check_value
= 1;
5311 else if (b
->watchpoint_triggered
== watch_triggered_unknown
5312 && b
->type
== bp_hardware_watchpoint
)
5313 /* We were stopped by a hardware watchpoint, but the target could
5314 not report the data address. We must check the watchpoint's
5315 value. Access and read watchpoints are out of luck; without
5316 a data address, we can't figure it out. */
5317 must_check_value
= 1;
5319 if (must_check_value
)
5322 = xstrprintf ("Error evaluating expression for watchpoint %d\n",
5324 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
5325 int e
= catch_errors (watchpoint_check
, bs
, message
,
5327 do_cleanups (cleanups
);
5331 /* We've already printed what needs to be printed. */
5332 bs
->print_it
= print_it_done
;
5336 bs
->print_it
= print_it_noop
;
5339 case WP_VALUE_CHANGED
:
5340 if (b
->type
== bp_read_watchpoint
)
5342 /* There are two cases to consider here:
5344 1. We're watching the triggered memory for reads.
5345 In that case, trust the target, and always report
5346 the watchpoint hit to the user. Even though
5347 reads don't cause value changes, the value may
5348 have changed since the last time it was read, and
5349 since we're not trapping writes, we will not see
5350 those, and as such we should ignore our notion of
5353 2. We're watching the triggered memory for both
5354 reads and writes. There are two ways this may
5357 2.1. This is a target that can't break on data
5358 reads only, but can break on accesses (reads or
5359 writes), such as e.g., x86. We detect this case
5360 at the time we try to insert read watchpoints.
5362 2.2. Otherwise, the target supports read
5363 watchpoints, but, the user set an access or write
5364 watchpoint watching the same memory as this read
5367 If we're watching memory writes as well as reads,
5368 ignore watchpoint hits when we find that the
5369 value hasn't changed, as reads don't cause
5370 changes. This still gives false positives when
5371 the program writes the same value to memory as
5372 what there was already in memory (we will confuse
5373 it for a read), but it's much better than
5376 int other_write_watchpoint
= 0;
5378 if (bl
->watchpoint_type
== hw_read
)
5380 struct breakpoint
*other_b
;
5382 ALL_BREAKPOINTS (other_b
)
5383 if (other_b
->type
== bp_hardware_watchpoint
5384 || other_b
->type
== bp_access_watchpoint
)
5386 struct watchpoint
*other_w
=
5387 (struct watchpoint
*) other_b
;
5389 if (other_w
->watchpoint_triggered
5390 == watch_triggered_yes
)
5392 other_write_watchpoint
= 1;
5398 if (other_write_watchpoint
5399 || bl
->watchpoint_type
== hw_access
)
5401 /* We're watching the same memory for writes,
5402 and the value changed since the last time we
5403 updated it, so this trap must be for a write.
5405 bs
->print_it
= print_it_noop
;
5410 case WP_VALUE_NOT_CHANGED
:
5411 if (b
->type
== bp_hardware_watchpoint
5412 || b
->type
== bp_watchpoint
)
5414 /* Don't stop: write watchpoints shouldn't fire if
5415 the value hasn't changed. */
5416 bs
->print_it
= print_it_noop
;
5424 /* Error from catch_errors. */
5426 SWITCH_THRU_ALL_UIS ()
5428 printf_filtered (_("Watchpoint %d deleted.\n"),
5431 watchpoint_del_at_next_stop (b
);
5432 /* We've already printed what needs to be printed. */
5433 bs
->print_it
= print_it_done
;
5438 else /* must_check_value == 0 */
5440 /* This is a case where some watchpoint(s) triggered, but
5441 not at the address of this watchpoint, or else no
5442 watchpoint triggered after all. So don't print
5443 anything for this watchpoint. */
5444 bs
->print_it
= print_it_noop
;
5450 /* For breakpoints that are currently marked as telling gdb to stop,
5451 check conditions (condition proper, frame, thread and ignore count)
5452 of breakpoint referred to by BS. If we should not stop for this
5453 breakpoint, set BS->stop to 0. */
5456 bpstat_check_breakpoint_conditions (bpstat bs
, ptid_t ptid
)
5458 const struct bp_location
*bl
;
5459 struct breakpoint
*b
;
5460 int value_is_zero
= 0;
5461 struct expression
*cond
;
5463 gdb_assert (bs
->stop
);
5465 /* BS is built for existing struct breakpoint. */
5466 bl
= bs
->bp_location_at
;
5467 gdb_assert (bl
!= NULL
);
5468 b
= bs
->breakpoint_at
;
5469 gdb_assert (b
!= NULL
);
5471 /* Even if the target evaluated the condition on its end and notified GDB, we
5472 need to do so again since GDB does not know if we stopped due to a
5473 breakpoint or a single step breakpoint. */
5475 if (frame_id_p (b
->frame_id
)
5476 && !frame_id_eq (b
->frame_id
, get_stack_frame_id (get_current_frame ())))
5482 /* If this is a thread/task-specific breakpoint, don't waste cpu
5483 evaluating the condition if this isn't the specified
5485 if ((b
->thread
!= -1 && b
->thread
!= ptid_to_global_thread_id (ptid
))
5486 || (b
->task
!= 0 && b
->task
!= ada_get_task_number (ptid
)))
5493 /* Evaluate extension language breakpoints that have a "stop" method
5495 bs
->stop
= breakpoint_ext_lang_cond_says_stop (b
);
5497 if (is_watchpoint (b
))
5499 struct watchpoint
*w
= (struct watchpoint
*) b
;
5501 cond
= w
->cond_exp
.get ();
5504 cond
= bl
->cond
.get ();
5506 if (cond
&& b
->disposition
!= disp_del_at_next_stop
)
5508 int within_current_scope
= 1;
5509 struct watchpoint
* w
;
5511 /* We use value_mark and value_free_to_mark because it could
5512 be a long time before we return to the command level and
5513 call free_all_values. We can't call free_all_values
5514 because we might be in the middle of evaluating a
5516 struct value
*mark
= value_mark ();
5518 if (is_watchpoint (b
))
5519 w
= (struct watchpoint
*) b
;
5523 /* Need to select the frame, with all that implies so that
5524 the conditions will have the right context. Because we
5525 use the frame, we will not see an inlined function's
5526 variables when we arrive at a breakpoint at the start
5527 of the inlined function; the current frame will be the
5529 if (w
== NULL
|| w
->cond_exp_valid_block
== NULL
)
5530 select_frame (get_current_frame ());
5533 struct frame_info
*frame
;
5535 /* For local watchpoint expressions, which particular
5536 instance of a local is being watched matters, so we
5537 keep track of the frame to evaluate the expression
5538 in. To evaluate the condition however, it doesn't
5539 really matter which instantiation of the function
5540 where the condition makes sense triggers the
5541 watchpoint. This allows an expression like "watch
5542 global if q > 10" set in `func', catch writes to
5543 global on all threads that call `func', or catch
5544 writes on all recursive calls of `func' by a single
5545 thread. We simply always evaluate the condition in
5546 the innermost frame that's executing where it makes
5547 sense to evaluate the condition. It seems
5549 frame
= block_innermost_frame (w
->cond_exp_valid_block
);
5551 select_frame (frame
);
5553 within_current_scope
= 0;
5555 if (within_current_scope
)
5557 = catch_errors (breakpoint_cond_eval
, cond
,
5558 "Error in testing breakpoint condition:\n",
5562 warning (_("Watchpoint condition cannot be tested "
5563 "in the current scope"));
5564 /* If we failed to set the right context for this
5565 watchpoint, unconditionally report it. */
5568 /* FIXME-someday, should give breakpoint #. */
5569 value_free_to_mark (mark
);
5572 if (cond
&& value_is_zero
)
5576 else if (b
->ignore_count
> 0)
5580 /* Increase the hit count even though we don't stop. */
5582 observer_notify_breakpoint_modified (b
);
5586 /* Returns true if we need to track moribund locations of LOC's type
5587 on the current target. */
5590 need_moribund_for_location_type (struct bp_location
*loc
)
5592 return ((loc
->loc_type
== bp_loc_software_breakpoint
5593 && !target_supports_stopped_by_sw_breakpoint ())
5594 || (loc
->loc_type
== bp_loc_hardware_breakpoint
5595 && !target_supports_stopped_by_hw_breakpoint ()));
5599 /* Get a bpstat associated with having just stopped at address
5600 BP_ADDR in thread PTID.
5602 Determine whether we stopped at a breakpoint, etc, or whether we
5603 don't understand this stop. Result is a chain of bpstat's such
5606 if we don't understand the stop, the result is a null pointer.
5608 if we understand why we stopped, the result is not null.
5610 Each element of the chain refers to a particular breakpoint or
5611 watchpoint at which we have stopped. (We may have stopped for
5612 several reasons concurrently.)
5614 Each element of the chain has valid next, breakpoint_at,
5615 commands, FIXME??? fields. */
5618 bpstat_stop_status (struct address_space
*aspace
,
5619 CORE_ADDR bp_addr
, ptid_t ptid
,
5620 const struct target_waitstatus
*ws
)
5622 struct breakpoint
*b
= NULL
;
5623 struct bp_location
*bl
;
5624 struct bp_location
*loc
;
5625 /* First item of allocated bpstat's. */
5626 bpstat bs_head
= NULL
, *bs_link
= &bs_head
;
5627 /* Pointer to the last thing in the chain currently. */
5630 int need_remove_insert
;
5633 /* First, build the bpstat chain with locations that explain a
5634 target stop, while being careful to not set the target running,
5635 as that may invalidate locations (in particular watchpoint
5636 locations are recreated). Resuming will happen here with
5637 breakpoint conditions or watchpoint expressions that include
5638 inferior function calls. */
5642 if (!breakpoint_enabled (b
))
5645 for (bl
= b
->loc
; bl
!= NULL
; bl
= bl
->next
)
5647 /* For hardware watchpoints, we look only at the first
5648 location. The watchpoint_check function will work on the
5649 entire expression, not the individual locations. For
5650 read watchpoints, the watchpoints_triggered function has
5651 checked all locations already. */
5652 if (b
->type
== bp_hardware_watchpoint
&& bl
!= b
->loc
)
5655 if (!bl
->enabled
|| bl
->shlib_disabled
)
5658 if (!bpstat_check_location (bl
, aspace
, bp_addr
, ws
))
5661 /* Come here if it's a watchpoint, or if the break address
5664 bs
= bpstat_alloc (bl
, &bs_link
); /* Alloc a bpstat to
5667 /* Assume we stop. Should we find a watchpoint that is not
5668 actually triggered, or if the condition of the breakpoint
5669 evaluates as false, we'll reset 'stop' to 0. */
5673 /* If this is a scope breakpoint, mark the associated
5674 watchpoint as triggered so that we will handle the
5675 out-of-scope event. We'll get to the watchpoint next
5677 if (b
->type
== bp_watchpoint_scope
&& b
->related_breakpoint
!= b
)
5679 struct watchpoint
*w
= (struct watchpoint
*) b
->related_breakpoint
;
5681 w
->watchpoint_triggered
= watch_triggered_yes
;
5686 /* Check if a moribund breakpoint explains the stop. */
5687 if (!target_supports_stopped_by_sw_breakpoint ()
5688 || !target_supports_stopped_by_hw_breakpoint ())
5690 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
5692 if (breakpoint_location_address_match (loc
, aspace
, bp_addr
)
5693 && need_moribund_for_location_type (loc
))
5695 bs
= bpstat_alloc (loc
, &bs_link
);
5696 /* For hits of moribund locations, we should just proceed. */
5699 bs
->print_it
= print_it_noop
;
5704 /* A bit of special processing for shlib breakpoints. We need to
5705 process solib loading here, so that the lists of loaded and
5706 unloaded libraries are correct before we handle "catch load" and
5708 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5710 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->type
== bp_shlib_event
)
5712 handle_solib_event ();
5717 /* Now go through the locations that caused the target to stop, and
5718 check whether we're interested in reporting this stop to higher
5719 layers, or whether we should resume the target transparently. */
5723 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5728 b
= bs
->breakpoint_at
;
5729 b
->ops
->check_status (bs
);
5732 bpstat_check_breakpoint_conditions (bs
, ptid
);
5737 observer_notify_breakpoint_modified (b
);
5739 /* We will stop here. */
5740 if (b
->disposition
== disp_disable
)
5742 --(b
->enable_count
);
5743 if (b
->enable_count
<= 0)
5744 b
->enable_state
= bp_disabled
;
5749 bs
->commands
= b
->commands
;
5750 incref_counted_command_line (bs
->commands
);
5751 if (command_line_is_silent (bs
->commands
5752 ? bs
->commands
->commands
: NULL
))
5755 b
->ops
->after_condition_true (bs
);
5760 /* Print nothing for this entry if we don't stop or don't
5762 if (!bs
->stop
|| !bs
->print
)
5763 bs
->print_it
= print_it_noop
;
5766 /* If we aren't stopping, the value of some hardware watchpoint may
5767 not have changed, but the intermediate memory locations we are
5768 watching may have. Don't bother if we're stopping; this will get
5770 need_remove_insert
= 0;
5771 if (! bpstat_causes_stop (bs_head
))
5772 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5774 && bs
->breakpoint_at
5775 && is_hardware_watchpoint (bs
->breakpoint_at
))
5777 struct watchpoint
*w
= (struct watchpoint
*) bs
->breakpoint_at
;
5779 update_watchpoint (w
, 0 /* don't reparse. */);
5780 need_remove_insert
= 1;
5783 if (need_remove_insert
)
5784 update_global_location_list (UGLL_MAY_INSERT
);
5785 else if (removed_any
)
5786 update_global_location_list (UGLL_DONT_INSERT
);
5792 handle_jit_event (void)
5794 struct frame_info
*frame
;
5795 struct gdbarch
*gdbarch
;
5798 fprintf_unfiltered (gdb_stdlog
, "handling bp_jit_event\n");
5800 /* Switch terminal for any messages produced by
5801 breakpoint_re_set. */
5802 target_terminal_ours_for_output ();
5804 frame
= get_current_frame ();
5805 gdbarch
= get_frame_arch (frame
);
5807 jit_event_handler (gdbarch
);
5809 target_terminal_inferior ();
5812 /* Prepare WHAT final decision for infrun. */
5814 /* Decide what infrun needs to do with this bpstat. */
5817 bpstat_what (bpstat bs_head
)
5819 struct bpstat_what retval
;
5822 retval
.main_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5823 retval
.call_dummy
= STOP_NONE
;
5824 retval
.is_longjmp
= 0;
5826 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5828 /* Extract this BS's action. After processing each BS, we check
5829 if its action overrides all we've seem so far. */
5830 enum bpstat_what_main_action this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5833 if (bs
->breakpoint_at
== NULL
)
5835 /* I suspect this can happen if it was a momentary
5836 breakpoint which has since been deleted. */
5840 bptype
= bs
->breakpoint_at
->type
;
5847 case bp_hardware_breakpoint
:
5848 case bp_single_step
:
5851 case bp_shlib_event
:
5855 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5857 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5860 this_action
= BPSTAT_WHAT_SINGLE
;
5863 case bp_hardware_watchpoint
:
5864 case bp_read_watchpoint
:
5865 case bp_access_watchpoint
:
5869 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5871 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5875 /* There was a watchpoint, but we're not stopping.
5876 This requires no further action. */
5880 case bp_longjmp_call_dummy
:
5884 this_action
= BPSTAT_WHAT_SET_LONGJMP_RESUME
;
5885 retval
.is_longjmp
= bptype
!= bp_exception
;
5888 this_action
= BPSTAT_WHAT_SINGLE
;
5890 case bp_longjmp_resume
:
5891 case bp_exception_resume
:
5894 this_action
= BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
;
5895 retval
.is_longjmp
= bptype
== bp_longjmp_resume
;
5898 this_action
= BPSTAT_WHAT_SINGLE
;
5900 case bp_step_resume
:
5902 this_action
= BPSTAT_WHAT_STEP_RESUME
;
5905 /* It is for the wrong frame. */
5906 this_action
= BPSTAT_WHAT_SINGLE
;
5909 case bp_hp_step_resume
:
5911 this_action
= BPSTAT_WHAT_HP_STEP_RESUME
;
5914 /* It is for the wrong frame. */
5915 this_action
= BPSTAT_WHAT_SINGLE
;
5918 case bp_watchpoint_scope
:
5919 case bp_thread_event
:
5920 case bp_overlay_event
:
5921 case bp_longjmp_master
:
5922 case bp_std_terminate_master
:
5923 case bp_exception_master
:
5924 this_action
= BPSTAT_WHAT_SINGLE
;
5930 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5932 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5936 /* There was a catchpoint, but we're not stopping.
5937 This requires no further action. */
5941 this_action
= BPSTAT_WHAT_SINGLE
;
5944 /* Make sure the action is stop (silent or noisy),
5945 so infrun.c pops the dummy frame. */
5946 retval
.call_dummy
= STOP_STACK_DUMMY
;
5947 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5949 case bp_std_terminate
:
5950 /* Make sure the action is stop (silent or noisy),
5951 so infrun.c pops the dummy frame. */
5952 retval
.call_dummy
= STOP_STD_TERMINATE
;
5953 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5956 case bp_fast_tracepoint
:
5957 case bp_static_tracepoint
:
5958 /* Tracepoint hits should not be reported back to GDB, and
5959 if one got through somehow, it should have been filtered
5961 internal_error (__FILE__
, __LINE__
,
5962 _("bpstat_what: tracepoint encountered"));
5964 case bp_gnu_ifunc_resolver
:
5965 /* Step over it (and insert bp_gnu_ifunc_resolver_return). */
5966 this_action
= BPSTAT_WHAT_SINGLE
;
5968 case bp_gnu_ifunc_resolver_return
:
5969 /* The breakpoint will be removed, execution will restart from the
5970 PC of the former breakpoint. */
5971 this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5976 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5978 this_action
= BPSTAT_WHAT_SINGLE
;
5982 internal_error (__FILE__
, __LINE__
,
5983 _("bpstat_what: unhandled bptype %d"), (int) bptype
);
5986 retval
.main_action
= std::max (retval
.main_action
, this_action
);
5993 bpstat_run_callbacks (bpstat bs_head
)
5997 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5999 struct breakpoint
*b
= bs
->breakpoint_at
;
6006 handle_jit_event ();
6008 case bp_gnu_ifunc_resolver
:
6009 gnu_ifunc_resolver_stop (b
);
6011 case bp_gnu_ifunc_resolver_return
:
6012 gnu_ifunc_resolver_return_stop (b
);
6018 /* Nonzero if we should step constantly (e.g. watchpoints on machines
6019 without hardware support). This isn't related to a specific bpstat,
6020 just to things like whether watchpoints are set. */
6023 bpstat_should_step (void)
6025 struct breakpoint
*b
;
6028 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
&& b
->loc
!= NULL
)
6034 bpstat_causes_stop (bpstat bs
)
6036 for (; bs
!= NULL
; bs
= bs
->next
)
6045 /* Compute a string of spaces suitable to indent the next line
6046 so it starts at the position corresponding to the table column
6047 named COL_NAME in the currently active table of UIOUT. */
6050 wrap_indent_at_field (struct ui_out
*uiout
, const char *col_name
)
6052 static char wrap_indent
[80];
6053 int i
, total_width
, width
, align
;
6057 for (i
= 1; uiout
->query_table_field (i
, &width
, &align
, &text
); i
++)
6059 if (strcmp (text
, col_name
) == 0)
6061 gdb_assert (total_width
< sizeof wrap_indent
);
6062 memset (wrap_indent
, ' ', total_width
);
6063 wrap_indent
[total_width
] = 0;
6068 total_width
+= width
+ 1;
6074 /* Determine if the locations of this breakpoint will have their conditions
6075 evaluated by the target, host or a mix of both. Returns the following:
6077 "host": Host evals condition.
6078 "host or target": Host or Target evals condition.
6079 "target": Target evals condition.
6083 bp_condition_evaluator (struct breakpoint
*b
)
6085 struct bp_location
*bl
;
6086 char host_evals
= 0;
6087 char target_evals
= 0;
6092 if (!is_breakpoint (b
))
6095 if (gdb_evaluates_breakpoint_condition_p ()
6096 || !target_supports_evaluation_of_breakpoint_conditions ())
6097 return condition_evaluation_host
;
6099 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
6101 if (bl
->cond_bytecode
)
6107 if (host_evals
&& target_evals
)
6108 return condition_evaluation_both
;
6109 else if (target_evals
)
6110 return condition_evaluation_target
;
6112 return condition_evaluation_host
;
6115 /* Determine the breakpoint location's condition evaluator. This is
6116 similar to bp_condition_evaluator, but for locations. */
6119 bp_location_condition_evaluator (struct bp_location
*bl
)
6121 if (bl
&& !is_breakpoint (bl
->owner
))
6124 if (gdb_evaluates_breakpoint_condition_p ()
6125 || !target_supports_evaluation_of_breakpoint_conditions ())
6126 return condition_evaluation_host
;
6128 if (bl
&& bl
->cond_bytecode
)
6129 return condition_evaluation_target
;
6131 return condition_evaluation_host
;
6134 /* Print the LOC location out of the list of B->LOC locations. */
6137 print_breakpoint_location (struct breakpoint
*b
,
6138 struct bp_location
*loc
)
6140 struct ui_out
*uiout
= current_uiout
;
6142 scoped_restore_current_program_space restore_pspace
;
6144 if (loc
!= NULL
&& loc
->shlib_disabled
)
6148 set_current_program_space (loc
->pspace
);
6150 if (b
->display_canonical
)
6151 uiout
->field_string ("what", event_location_to_string (b
->location
.get ()));
6152 else if (loc
&& loc
->symtab
)
6155 = find_pc_sect_function (loc
->address
, loc
->section
);
6158 uiout
->text ("in ");
6159 uiout
->field_string ("func", SYMBOL_PRINT_NAME (sym
));
6161 uiout
->wrap_hint (wrap_indent_at_field (uiout
, "what"));
6162 uiout
->text ("at ");
6164 uiout
->field_string ("file",
6165 symtab_to_filename_for_display (loc
->symtab
));
6168 if (uiout
->is_mi_like_p ())
6169 uiout
->field_string ("fullname", symtab_to_fullname (loc
->symtab
));
6171 uiout
->field_int ("line", loc
->line_number
);
6177 print_address_symbolic (loc
->gdbarch
, loc
->address
, &stb
,
6179 uiout
->field_stream ("at", stb
);
6183 uiout
->field_string ("pending",
6184 event_location_to_string (b
->location
.get ()));
6185 /* If extra_string is available, it could be holding a condition
6186 or dprintf arguments. In either case, make sure it is printed,
6187 too, but only for non-MI streams. */
6188 if (!uiout
->is_mi_like_p () && b
->extra_string
!= NULL
)
6190 if (b
->type
== bp_dprintf
)
6194 uiout
->text (b
->extra_string
);
6198 if (loc
&& is_breakpoint (b
)
6199 && breakpoint_condition_evaluation_mode () == condition_evaluation_target
6200 && bp_condition_evaluator (b
) == condition_evaluation_both
)
6203 uiout
->field_string ("evaluated-by",
6204 bp_location_condition_evaluator (loc
));
6210 bptype_string (enum bptype type
)
6212 struct ep_type_description
6215 const char *description
;
6217 static struct ep_type_description bptypes
[] =
6219 {bp_none
, "?deleted?"},
6220 {bp_breakpoint
, "breakpoint"},
6221 {bp_hardware_breakpoint
, "hw breakpoint"},
6222 {bp_single_step
, "sw single-step"},
6223 {bp_until
, "until"},
6224 {bp_finish
, "finish"},
6225 {bp_watchpoint
, "watchpoint"},
6226 {bp_hardware_watchpoint
, "hw watchpoint"},
6227 {bp_read_watchpoint
, "read watchpoint"},
6228 {bp_access_watchpoint
, "acc watchpoint"},
6229 {bp_longjmp
, "longjmp"},
6230 {bp_longjmp_resume
, "longjmp resume"},
6231 {bp_longjmp_call_dummy
, "longjmp for call dummy"},
6232 {bp_exception
, "exception"},
6233 {bp_exception_resume
, "exception resume"},
6234 {bp_step_resume
, "step resume"},
6235 {bp_hp_step_resume
, "high-priority step resume"},
6236 {bp_watchpoint_scope
, "watchpoint scope"},
6237 {bp_call_dummy
, "call dummy"},
6238 {bp_std_terminate
, "std::terminate"},
6239 {bp_shlib_event
, "shlib events"},
6240 {bp_thread_event
, "thread events"},
6241 {bp_overlay_event
, "overlay events"},
6242 {bp_longjmp_master
, "longjmp master"},
6243 {bp_std_terminate_master
, "std::terminate master"},
6244 {bp_exception_master
, "exception master"},
6245 {bp_catchpoint
, "catchpoint"},
6246 {bp_tracepoint
, "tracepoint"},
6247 {bp_fast_tracepoint
, "fast tracepoint"},
6248 {bp_static_tracepoint
, "static tracepoint"},
6249 {bp_dprintf
, "dprintf"},
6250 {bp_jit_event
, "jit events"},
6251 {bp_gnu_ifunc_resolver
, "STT_GNU_IFUNC resolver"},
6252 {bp_gnu_ifunc_resolver_return
, "STT_GNU_IFUNC resolver return"},
6255 if (((int) type
>= (sizeof (bptypes
) / sizeof (bptypes
[0])))
6256 || ((int) type
!= bptypes
[(int) type
].type
))
6257 internal_error (__FILE__
, __LINE__
,
6258 _("bptypes table does not describe type #%d."),
6261 return bptypes
[(int) type
].description
;
6264 /* For MI, output a field named 'thread-groups' with a list as the value.
6265 For CLI, prefix the list with the string 'inf'. */
6268 output_thread_groups (struct ui_out
*uiout
,
6269 const char *field_name
,
6273 int is_mi
= uiout
->is_mi_like_p ();
6277 /* For backward compatibility, don't display inferiors in CLI unless
6278 there are several. Always display them for MI. */
6279 if (!is_mi
&& mi_only
)
6282 ui_out_emit_list
list_emitter (uiout
, field_name
);
6284 for (i
= 0; VEC_iterate (int, inf_num
, i
, inf
); ++i
)
6290 xsnprintf (mi_group
, sizeof (mi_group
), "i%d", inf
);
6291 uiout
->field_string (NULL
, mi_group
);
6296 uiout
->text (" inf ");
6300 uiout
->text (plongest (inf
));
6305 /* Print B to gdb_stdout. */
6308 print_one_breakpoint_location (struct breakpoint
*b
,
6309 struct bp_location
*loc
,
6311 struct bp_location
**last_loc
,
6314 struct command_line
*l
;
6315 static char bpenables
[] = "nynny";
6317 struct ui_out
*uiout
= current_uiout
;
6318 int header_of_multiple
= 0;
6319 int part_of_multiple
= (loc
!= NULL
);
6320 struct value_print_options opts
;
6322 get_user_print_options (&opts
);
6324 gdb_assert (!loc
|| loc_number
!= 0);
6325 /* See comment in print_one_breakpoint concerning treatment of
6326 breakpoints with single disabled location. */
6329 && (b
->loc
->next
!= NULL
|| !b
->loc
->enabled
)))
6330 header_of_multiple
= 1;
6338 if (part_of_multiple
)
6341 formatted
= xstrprintf ("%d.%d", b
->number
, loc_number
);
6342 uiout
->field_string ("number", formatted
);
6347 uiout
->field_int ("number", b
->number
);
6352 if (part_of_multiple
)
6353 uiout
->field_skip ("type");
6355 uiout
->field_string ("type", bptype_string (b
->type
));
6359 if (part_of_multiple
)
6360 uiout
->field_skip ("disp");
6362 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
6367 if (part_of_multiple
)
6368 uiout
->field_string ("enabled", loc
->enabled
? "y" : "n");
6370 uiout
->field_fmt ("enabled", "%c", bpenables
[(int) b
->enable_state
]);
6375 if (b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
6377 /* Although the print_one can possibly print all locations,
6378 calling it here is not likely to get any nice result. So,
6379 make sure there's just one location. */
6380 gdb_assert (b
->loc
== NULL
|| b
->loc
->next
== NULL
);
6381 b
->ops
->print_one (b
, last_loc
);
6387 internal_error (__FILE__
, __LINE__
,
6388 _("print_one_breakpoint: bp_none encountered\n"));
6392 case bp_hardware_watchpoint
:
6393 case bp_read_watchpoint
:
6394 case bp_access_watchpoint
:
6396 struct watchpoint
*w
= (struct watchpoint
*) b
;
6398 /* Field 4, the address, is omitted (which makes the columns
6399 not line up too nicely with the headers, but the effect
6400 is relatively readable). */
6401 if (opts
.addressprint
)
6402 uiout
->field_skip ("addr");
6404 uiout
->field_string ("what", w
->exp_string
);
6409 case bp_hardware_breakpoint
:
6410 case bp_single_step
:
6414 case bp_longjmp_resume
:
6415 case bp_longjmp_call_dummy
:
6417 case bp_exception_resume
:
6418 case bp_step_resume
:
6419 case bp_hp_step_resume
:
6420 case bp_watchpoint_scope
:
6422 case bp_std_terminate
:
6423 case bp_shlib_event
:
6424 case bp_thread_event
:
6425 case bp_overlay_event
:
6426 case bp_longjmp_master
:
6427 case bp_std_terminate_master
:
6428 case bp_exception_master
:
6430 case bp_fast_tracepoint
:
6431 case bp_static_tracepoint
:
6434 case bp_gnu_ifunc_resolver
:
6435 case bp_gnu_ifunc_resolver_return
:
6436 if (opts
.addressprint
)
6439 if (header_of_multiple
)
6440 uiout
->field_string ("addr", "<MULTIPLE>");
6441 else if (b
->loc
== NULL
|| loc
->shlib_disabled
)
6442 uiout
->field_string ("addr", "<PENDING>");
6444 uiout
->field_core_addr ("addr",
6445 loc
->gdbarch
, loc
->address
);
6448 if (!header_of_multiple
)
6449 print_breakpoint_location (b
, loc
);
6456 if (loc
!= NULL
&& !header_of_multiple
)
6458 struct inferior
*inf
;
6459 VEC(int) *inf_num
= NULL
;
6464 if (inf
->pspace
== loc
->pspace
)
6465 VEC_safe_push (int, inf_num
, inf
->num
);
6468 /* For backward compatibility, don't display inferiors in CLI unless
6469 there are several. Always display for MI. */
6471 || (!gdbarch_has_global_breakpoints (target_gdbarch ())
6472 && (number_of_program_spaces () > 1
6473 || number_of_inferiors () > 1)
6474 /* LOC is for existing B, it cannot be in
6475 moribund_locations and thus having NULL OWNER. */
6476 && loc
->owner
->type
!= bp_catchpoint
))
6478 output_thread_groups (uiout
, "thread-groups", inf_num
, mi_only
);
6479 VEC_free (int, inf_num
);
6482 if (!part_of_multiple
)
6484 if (b
->thread
!= -1)
6486 /* FIXME: This seems to be redundant and lost here; see the
6487 "stop only in" line a little further down. */
6488 uiout
->text (" thread ");
6489 uiout
->field_int ("thread", b
->thread
);
6491 else if (b
->task
!= 0)
6493 uiout
->text (" task ");
6494 uiout
->field_int ("task", b
->task
);
6500 if (!part_of_multiple
)
6501 b
->ops
->print_one_detail (b
, uiout
);
6503 if (part_of_multiple
&& frame_id_p (b
->frame_id
))
6506 uiout
->text ("\tstop only in stack frame at ");
6507 /* FIXME: cagney/2002-12-01: Shouldn't be poking around inside
6509 uiout
->field_core_addr ("frame",
6510 b
->gdbarch
, b
->frame_id
.stack_addr
);
6514 if (!part_of_multiple
&& b
->cond_string
)
6517 if (is_tracepoint (b
))
6518 uiout
->text ("\ttrace only if ");
6520 uiout
->text ("\tstop only if ");
6521 uiout
->field_string ("cond", b
->cond_string
);
6523 /* Print whether the target is doing the breakpoint's condition
6524 evaluation. If GDB is doing the evaluation, don't print anything. */
6525 if (is_breakpoint (b
)
6526 && breakpoint_condition_evaluation_mode ()
6527 == condition_evaluation_target
)
6530 uiout
->field_string ("evaluated-by",
6531 bp_condition_evaluator (b
));
6532 uiout
->text (" evals)");
6537 if (!part_of_multiple
&& b
->thread
!= -1)
6539 /* FIXME should make an annotation for this. */
6540 uiout
->text ("\tstop only in thread ");
6541 if (uiout
->is_mi_like_p ())
6542 uiout
->field_int ("thread", b
->thread
);
6545 struct thread_info
*thr
= find_thread_global_id (b
->thread
);
6547 uiout
->field_string ("thread", print_thread_id (thr
));
6552 if (!part_of_multiple
)
6556 /* FIXME should make an annotation for this. */
6557 if (is_catchpoint (b
))
6558 uiout
->text ("\tcatchpoint");
6559 else if (is_tracepoint (b
))
6560 uiout
->text ("\ttracepoint");
6562 uiout
->text ("\tbreakpoint");
6563 uiout
->text (" already hit ");
6564 uiout
->field_int ("times", b
->hit_count
);
6565 if (b
->hit_count
== 1)
6566 uiout
->text (" time\n");
6568 uiout
->text (" times\n");
6572 /* Output the count also if it is zero, but only if this is mi. */
6573 if (uiout
->is_mi_like_p ())
6574 uiout
->field_int ("times", b
->hit_count
);
6578 if (!part_of_multiple
&& b
->ignore_count
)
6581 uiout
->text ("\tignore next ");
6582 uiout
->field_int ("ignore", b
->ignore_count
);
6583 uiout
->text (" hits\n");
6586 /* Note that an enable count of 1 corresponds to "enable once"
6587 behavior, which is reported by the combination of enablement and
6588 disposition, so we don't need to mention it here. */
6589 if (!part_of_multiple
&& b
->enable_count
> 1)
6592 uiout
->text ("\tdisable after ");
6593 /* Tweak the wording to clarify that ignore and enable counts
6594 are distinct, and have additive effect. */
6595 if (b
->ignore_count
)
6596 uiout
->text ("additional ");
6598 uiout
->text ("next ");
6599 uiout
->field_int ("enable", b
->enable_count
);
6600 uiout
->text (" hits\n");
6603 if (!part_of_multiple
&& is_tracepoint (b
))
6605 struct tracepoint
*tp
= (struct tracepoint
*) b
;
6607 if (tp
->traceframe_usage
)
6609 uiout
->text ("\ttrace buffer usage ");
6610 uiout
->field_int ("traceframe-usage", tp
->traceframe_usage
);
6611 uiout
->text (" bytes\n");
6615 l
= b
->commands
? b
->commands
->commands
: NULL
;
6616 if (!part_of_multiple
&& l
)
6619 ui_out_emit_tuple
tuple_emitter (uiout
, "script");
6620 print_command_lines (uiout
, l
, 4);
6623 if (is_tracepoint (b
))
6625 struct tracepoint
*t
= (struct tracepoint
*) b
;
6627 if (!part_of_multiple
&& t
->pass_count
)
6629 annotate_field (10);
6630 uiout
->text ("\tpass count ");
6631 uiout
->field_int ("pass", t
->pass_count
);
6632 uiout
->text (" \n");
6635 /* Don't display it when tracepoint or tracepoint location is
6637 if (!header_of_multiple
&& loc
!= NULL
&& !loc
->shlib_disabled
)
6639 annotate_field (11);
6641 if (uiout
->is_mi_like_p ())
6642 uiout
->field_string ("installed",
6643 loc
->inserted
? "y" : "n");
6649 uiout
->text ("\tnot ");
6650 uiout
->text ("installed on target\n");
6655 if (uiout
->is_mi_like_p () && !part_of_multiple
)
6657 if (is_watchpoint (b
))
6659 struct watchpoint
*w
= (struct watchpoint
*) b
;
6661 uiout
->field_string ("original-location", w
->exp_string
);
6663 else if (b
->location
!= NULL
6664 && event_location_to_string (b
->location
.get ()) != NULL
)
6665 uiout
->field_string ("original-location",
6666 event_location_to_string (b
->location
.get ()));
6671 print_one_breakpoint (struct breakpoint
*b
,
6672 struct bp_location
**last_loc
,
6675 struct ui_out
*uiout
= current_uiout
;
6678 ui_out_emit_tuple
tuple_emitter (uiout
, "bkpt");
6680 print_one_breakpoint_location (b
, NULL
, 0, last_loc
, allflag
);
6683 /* If this breakpoint has custom print function,
6684 it's already printed. Otherwise, print individual
6685 locations, if any. */
6686 if (b
->ops
== NULL
|| b
->ops
->print_one
== NULL
)
6688 /* If breakpoint has a single location that is disabled, we
6689 print it as if it had several locations, since otherwise it's
6690 hard to represent "breakpoint enabled, location disabled"
6693 Note that while hardware watchpoints have several locations
6694 internally, that's not a property exposed to user. */
6696 && !is_hardware_watchpoint (b
)
6697 && (b
->loc
->next
|| !b
->loc
->enabled
))
6699 struct bp_location
*loc
;
6702 for (loc
= b
->loc
; loc
; loc
= loc
->next
, ++n
)
6704 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
6705 print_one_breakpoint_location (b
, loc
, n
, last_loc
, allflag
);
6712 breakpoint_address_bits (struct breakpoint
*b
)
6714 int print_address_bits
= 0;
6715 struct bp_location
*loc
;
6717 /* Software watchpoints that aren't watching memory don't have an
6718 address to print. */
6719 if (is_no_memory_software_watchpoint (b
))
6722 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
6726 addr_bit
= gdbarch_addr_bit (loc
->gdbarch
);
6727 if (addr_bit
> print_address_bits
)
6728 print_address_bits
= addr_bit
;
6731 return print_address_bits
;
6734 struct captured_breakpoint_query_args
6740 do_captured_breakpoint_query (struct ui_out
*uiout
, void *data
)
6742 struct captured_breakpoint_query_args
*args
6743 = (struct captured_breakpoint_query_args
*) data
;
6744 struct breakpoint
*b
;
6745 struct bp_location
*dummy_loc
= NULL
;
6749 if (args
->bnum
== b
->number
)
6751 print_one_breakpoint (b
, &dummy_loc
, 0);
6759 gdb_breakpoint_query (struct ui_out
*uiout
, int bnum
,
6760 char **error_message
)
6762 struct captured_breakpoint_query_args args
;
6765 /* For the moment we don't trust print_one_breakpoint() to not throw
6767 if (catch_exceptions_with_msg (uiout
, do_captured_breakpoint_query
, &args
,
6768 error_message
, RETURN_MASK_ALL
) < 0)
6774 /* Return true if this breakpoint was set by the user, false if it is
6775 internal or momentary. */
6778 user_breakpoint_p (struct breakpoint
*b
)
6780 return b
->number
> 0;
6783 /* See breakpoint.h. */
6786 pending_breakpoint_p (struct breakpoint
*b
)
6788 return b
->loc
== NULL
;
6791 /* Print information on user settable breakpoint (watchpoint, etc)
6792 number BNUM. If BNUM is -1 print all user-settable breakpoints.
6793 If ALLFLAG is non-zero, include non-user-settable breakpoints. If
6794 FILTER is non-NULL, call it on each breakpoint and only include the
6795 ones for which it returns non-zero. Return the total number of
6796 breakpoints listed. */
6799 breakpoint_1 (char *args
, int allflag
,
6800 int (*filter
) (const struct breakpoint
*))
6802 struct breakpoint
*b
;
6803 struct bp_location
*last_loc
= NULL
;
6804 int nr_printable_breakpoints
;
6805 struct value_print_options opts
;
6806 int print_address_bits
= 0;
6807 int print_type_col_width
= 14;
6808 struct ui_out
*uiout
= current_uiout
;
6810 get_user_print_options (&opts
);
6812 /* Compute the number of rows in the table, as well as the size
6813 required for address fields. */
6814 nr_printable_breakpoints
= 0;
6817 /* If we have a filter, only list the breakpoints it accepts. */
6818 if (filter
&& !filter (b
))
6821 /* If we have an "args" string, it is a list of breakpoints to
6822 accept. Skip the others. */
6823 if (args
!= NULL
&& *args
!= '\0')
6825 if (allflag
&& parse_and_eval_long (args
) != b
->number
)
6827 if (!allflag
&& !number_is_in_list (args
, b
->number
))
6831 if (allflag
|| user_breakpoint_p (b
))
6833 int addr_bit
, type_len
;
6835 addr_bit
= breakpoint_address_bits (b
);
6836 if (addr_bit
> print_address_bits
)
6837 print_address_bits
= addr_bit
;
6839 type_len
= strlen (bptype_string (b
->type
));
6840 if (type_len
> print_type_col_width
)
6841 print_type_col_width
= type_len
;
6843 nr_printable_breakpoints
++;
6848 ui_out_emit_table
table_emitter (uiout
,
6849 opts
.addressprint
? 6 : 5,
6850 nr_printable_breakpoints
,
6853 if (nr_printable_breakpoints
> 0)
6854 annotate_breakpoints_headers ();
6855 if (nr_printable_breakpoints
> 0)
6857 uiout
->table_header (7, ui_left
, "number", "Num"); /* 1 */
6858 if (nr_printable_breakpoints
> 0)
6860 uiout
->table_header (print_type_col_width
, ui_left
, "type", "Type"); /* 2 */
6861 if (nr_printable_breakpoints
> 0)
6863 uiout
->table_header (4, ui_left
, "disp", "Disp"); /* 3 */
6864 if (nr_printable_breakpoints
> 0)
6866 uiout
->table_header (3, ui_left
, "enabled", "Enb"); /* 4 */
6867 if (opts
.addressprint
)
6869 if (nr_printable_breakpoints
> 0)
6871 if (print_address_bits
<= 32)
6872 uiout
->table_header (10, ui_left
, "addr", "Address"); /* 5 */
6874 uiout
->table_header (18, ui_left
, "addr", "Address"); /* 5 */
6876 if (nr_printable_breakpoints
> 0)
6878 uiout
->table_header (40, ui_noalign
, "what", "What"); /* 6 */
6879 uiout
->table_body ();
6880 if (nr_printable_breakpoints
> 0)
6881 annotate_breakpoints_table ();
6886 /* If we have a filter, only list the breakpoints it accepts. */
6887 if (filter
&& !filter (b
))
6890 /* If we have an "args" string, it is a list of breakpoints to
6891 accept. Skip the others. */
6893 if (args
!= NULL
&& *args
!= '\0')
6895 if (allflag
) /* maintenance info breakpoint */
6897 if (parse_and_eval_long (args
) != b
->number
)
6900 else /* all others */
6902 if (!number_is_in_list (args
, b
->number
))
6906 /* We only print out user settable breakpoints unless the
6908 if (allflag
|| user_breakpoint_p (b
))
6909 print_one_breakpoint (b
, &last_loc
, allflag
);
6913 if (nr_printable_breakpoints
== 0)
6915 /* If there's a filter, let the caller decide how to report
6919 if (args
== NULL
|| *args
== '\0')
6920 uiout
->message ("No breakpoints or watchpoints.\n");
6922 uiout
->message ("No breakpoint or watchpoint matching '%s'.\n",
6928 if (last_loc
&& !server_command
)
6929 set_next_address (last_loc
->gdbarch
, last_loc
->address
);
6932 /* FIXME? Should this be moved up so that it is only called when
6933 there have been breakpoints? */
6934 annotate_breakpoints_table_end ();
6936 return nr_printable_breakpoints
;
6939 /* Display the value of default-collect in a way that is generally
6940 compatible with the breakpoint list. */
6943 default_collect_info (void)
6945 struct ui_out
*uiout
= current_uiout
;
6947 /* If it has no value (which is frequently the case), say nothing; a
6948 message like "No default-collect." gets in user's face when it's
6950 if (!*default_collect
)
6953 /* The following phrase lines up nicely with per-tracepoint collect
6955 uiout
->text ("default collect ");
6956 uiout
->field_string ("default-collect", default_collect
);
6957 uiout
->text (" \n");
6961 breakpoints_info (char *args
, int from_tty
)
6963 breakpoint_1 (args
, 0, NULL
);
6965 default_collect_info ();
6969 watchpoints_info (char *args
, int from_tty
)
6971 int num_printed
= breakpoint_1 (args
, 0, is_watchpoint
);
6972 struct ui_out
*uiout
= current_uiout
;
6974 if (num_printed
== 0)
6976 if (args
== NULL
|| *args
== '\0')
6977 uiout
->message ("No watchpoints.\n");
6979 uiout
->message ("No watchpoint matching '%s'.\n", args
);
6984 maintenance_info_breakpoints (char *args
, int from_tty
)
6986 breakpoint_1 (args
, 1, NULL
);
6988 default_collect_info ();
6992 breakpoint_has_pc (struct breakpoint
*b
,
6993 struct program_space
*pspace
,
6994 CORE_ADDR pc
, struct obj_section
*section
)
6996 struct bp_location
*bl
= b
->loc
;
6998 for (; bl
; bl
= bl
->next
)
7000 if (bl
->pspace
== pspace
7001 && bl
->address
== pc
7002 && (!overlay_debugging
|| bl
->section
== section
))
7008 /* Print a message describing any user-breakpoints set at PC. This
7009 concerns with logical breakpoints, so we match program spaces, not
7013 describe_other_breakpoints (struct gdbarch
*gdbarch
,
7014 struct program_space
*pspace
, CORE_ADDR pc
,
7015 struct obj_section
*section
, int thread
)
7018 struct breakpoint
*b
;
7021 others
+= (user_breakpoint_p (b
)
7022 && breakpoint_has_pc (b
, pspace
, pc
, section
));
7026 printf_filtered (_("Note: breakpoint "));
7027 else /* if (others == ???) */
7028 printf_filtered (_("Note: breakpoints "));
7030 if (user_breakpoint_p (b
) && breakpoint_has_pc (b
, pspace
, pc
, section
))
7033 printf_filtered ("%d", b
->number
);
7034 if (b
->thread
== -1 && thread
!= -1)
7035 printf_filtered (" (all threads)");
7036 else if (b
->thread
!= -1)
7037 printf_filtered (" (thread %d)", b
->thread
);
7038 printf_filtered ("%s%s ",
7039 ((b
->enable_state
== bp_disabled
7040 || b
->enable_state
== bp_call_disabled
)
7044 : ((others
== 1) ? " and" : ""));
7046 printf_filtered (_("also set at pc "));
7047 fputs_filtered (paddress (gdbarch
, pc
), gdb_stdout
);
7048 printf_filtered (".\n");
7053 /* Return true iff it is meaningful to use the address member of
7054 BPT locations. For some breakpoint types, the locations' address members
7055 are irrelevant and it makes no sense to attempt to compare them to other
7056 addresses (or use them for any other purpose either).
7058 More specifically, each of the following breakpoint types will
7059 always have a zero valued location address and we don't want to mark
7060 breakpoints of any of these types to be a duplicate of an actual
7061 breakpoint location at address zero:
7069 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
7071 enum bptype type
= bpt
->type
;
7073 return (type
!= bp_watchpoint
&& type
!= bp_catchpoint
);
7076 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
7077 true if LOC1 and LOC2 represent the same watchpoint location. */
7080 watchpoint_locations_match (struct bp_location
*loc1
,
7081 struct bp_location
*loc2
)
7083 struct watchpoint
*w1
= (struct watchpoint
*) loc1
->owner
;
7084 struct watchpoint
*w2
= (struct watchpoint
*) loc2
->owner
;
7086 /* Both of them must exist. */
7087 gdb_assert (w1
!= NULL
);
7088 gdb_assert (w2
!= NULL
);
7090 /* If the target can evaluate the condition expression in hardware,
7091 then we we need to insert both watchpoints even if they are at
7092 the same place. Otherwise the watchpoint will only trigger when
7093 the condition of whichever watchpoint was inserted evaluates to
7094 true, not giving a chance for GDB to check the condition of the
7095 other watchpoint. */
7097 && target_can_accel_watchpoint_condition (loc1
->address
,
7099 loc1
->watchpoint_type
,
7100 w1
->cond_exp
.get ()))
7102 && target_can_accel_watchpoint_condition (loc2
->address
,
7104 loc2
->watchpoint_type
,
7105 w2
->cond_exp
.get ())))
7108 /* Note that this checks the owner's type, not the location's. In
7109 case the target does not support read watchpoints, but does
7110 support access watchpoints, we'll have bp_read_watchpoint
7111 watchpoints with hw_access locations. Those should be considered
7112 duplicates of hw_read locations. The hw_read locations will
7113 become hw_access locations later. */
7114 return (loc1
->owner
->type
== loc2
->owner
->type
7115 && loc1
->pspace
->aspace
== loc2
->pspace
->aspace
7116 && loc1
->address
== loc2
->address
7117 && loc1
->length
== loc2
->length
);
7120 /* See breakpoint.h. */
7123 breakpoint_address_match (struct address_space
*aspace1
, CORE_ADDR addr1
,
7124 struct address_space
*aspace2
, CORE_ADDR addr2
)
7126 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
7127 || aspace1
== aspace2
)
7131 /* Returns true if {ASPACE2,ADDR2} falls within the range determined by
7132 {ASPACE1,ADDR1,LEN1}. In most targets, this can only be true if ASPACE1
7133 matches ASPACE2. On targets that have global breakpoints, the address
7134 space doesn't really matter. */
7137 breakpoint_address_match_range (struct address_space
*aspace1
, CORE_ADDR addr1
,
7138 int len1
, struct address_space
*aspace2
,
7141 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
7142 || aspace1
== aspace2
)
7143 && addr2
>= addr1
&& addr2
< addr1
+ len1
);
7146 /* Returns true if {ASPACE,ADDR} matches the breakpoint BL. BL may be
7147 a ranged breakpoint. In most targets, a match happens only if ASPACE
7148 matches the breakpoint's address space. On targets that have global
7149 breakpoints, the address space doesn't really matter. */
7152 breakpoint_location_address_match (struct bp_location
*bl
,
7153 struct address_space
*aspace
,
7156 return (breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
7159 && breakpoint_address_match_range (bl
->pspace
->aspace
,
7160 bl
->address
, bl
->length
,
7164 /* Returns true if the [ADDR,ADDR+LEN) range in ASPACE overlaps
7165 breakpoint BL. BL may be a ranged breakpoint. In most targets, a
7166 match happens only if ASPACE matches the breakpoint's address
7167 space. On targets that have global breakpoints, the address space
7168 doesn't really matter. */
7171 breakpoint_location_address_range_overlap (struct bp_location
*bl
,
7172 struct address_space
*aspace
,
7173 CORE_ADDR addr
, int len
)
7175 if (gdbarch_has_global_breakpoints (target_gdbarch ())
7176 || bl
->pspace
->aspace
== aspace
)
7178 int bl_len
= bl
->length
!= 0 ? bl
->length
: 1;
7180 if (mem_ranges_overlap (addr
, len
, bl
->address
, bl_len
))
7186 /* If LOC1 and LOC2's owners are not tracepoints, returns false directly.
7187 Then, if LOC1 and LOC2 represent the same tracepoint location, returns
7188 true, otherwise returns false. */
7191 tracepoint_locations_match (struct bp_location
*loc1
,
7192 struct bp_location
*loc2
)
7194 if (is_tracepoint (loc1
->owner
) && is_tracepoint (loc2
->owner
))
7195 /* Since tracepoint locations are never duplicated with others', tracepoint
7196 locations at the same address of different tracepoints are regarded as
7197 different locations. */
7198 return (loc1
->address
== loc2
->address
&& loc1
->owner
== loc2
->owner
);
7203 /* Assuming LOC1 and LOC2's types' have meaningful target addresses
7204 (breakpoint_address_is_meaningful), returns true if LOC1 and LOC2
7205 represent the same location. */
7208 breakpoint_locations_match (struct bp_location
*loc1
,
7209 struct bp_location
*loc2
)
7211 int hw_point1
, hw_point2
;
7213 /* Both of them must not be in moribund_locations. */
7214 gdb_assert (loc1
->owner
!= NULL
);
7215 gdb_assert (loc2
->owner
!= NULL
);
7217 hw_point1
= is_hardware_watchpoint (loc1
->owner
);
7218 hw_point2
= is_hardware_watchpoint (loc2
->owner
);
7220 if (hw_point1
!= hw_point2
)
7223 return watchpoint_locations_match (loc1
, loc2
);
7224 else if (is_tracepoint (loc1
->owner
) || is_tracepoint (loc2
->owner
))
7225 return tracepoint_locations_match (loc1
, loc2
);
7227 /* We compare bp_location.length in order to cover ranged breakpoints. */
7228 return (breakpoint_address_match (loc1
->pspace
->aspace
, loc1
->address
,
7229 loc2
->pspace
->aspace
, loc2
->address
)
7230 && loc1
->length
== loc2
->length
);
7234 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
7235 int bnum
, int have_bnum
)
7237 /* The longest string possibly returned by hex_string_custom
7238 is 50 chars. These must be at least that big for safety. */
7242 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
7243 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
7245 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
7246 bnum
, astr1
, astr2
);
7248 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
7251 /* Adjust a breakpoint's address to account for architectural
7252 constraints on breakpoint placement. Return the adjusted address.
7253 Note: Very few targets require this kind of adjustment. For most
7254 targets, this function is simply the identity function. */
7257 adjust_breakpoint_address (struct gdbarch
*gdbarch
,
7258 CORE_ADDR bpaddr
, enum bptype bptype
)
7260 if (!gdbarch_adjust_breakpoint_address_p (gdbarch
))
7262 /* Very few targets need any kind of breakpoint adjustment. */
7265 else if (bptype
== bp_watchpoint
7266 || bptype
== bp_hardware_watchpoint
7267 || bptype
== bp_read_watchpoint
7268 || bptype
== bp_access_watchpoint
7269 || bptype
== bp_catchpoint
)
7271 /* Watchpoints and the various bp_catch_* eventpoints should not
7272 have their addresses modified. */
7275 else if (bptype
== bp_single_step
)
7277 /* Single-step breakpoints should not have their addresses
7278 modified. If there's any architectural constrain that
7279 applies to this address, then it should have already been
7280 taken into account when the breakpoint was created in the
7281 first place. If we didn't do this, stepping through e.g.,
7282 Thumb-2 IT blocks would break. */
7287 CORE_ADDR adjusted_bpaddr
;
7289 /* Some targets have architectural constraints on the placement
7290 of breakpoint instructions. Obtain the adjusted address. */
7291 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (gdbarch
, bpaddr
);
7293 /* An adjusted breakpoint address can significantly alter
7294 a user's expectations. Print a warning if an adjustment
7296 if (adjusted_bpaddr
!= bpaddr
)
7297 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
7299 return adjusted_bpaddr
;
7303 bp_location::bp_location (const bp_location_ops
*ops
, breakpoint
*owner
)
7305 bp_location
*loc
= this;
7307 gdb_assert (ops
!= NULL
);
7311 loc
->cond_bytecode
= NULL
;
7312 loc
->shlib_disabled
= 0;
7315 switch (owner
->type
)
7318 case bp_single_step
:
7322 case bp_longjmp_resume
:
7323 case bp_longjmp_call_dummy
:
7325 case bp_exception_resume
:
7326 case bp_step_resume
:
7327 case bp_hp_step_resume
:
7328 case bp_watchpoint_scope
:
7330 case bp_std_terminate
:
7331 case bp_shlib_event
:
7332 case bp_thread_event
:
7333 case bp_overlay_event
:
7335 case bp_longjmp_master
:
7336 case bp_std_terminate_master
:
7337 case bp_exception_master
:
7338 case bp_gnu_ifunc_resolver
:
7339 case bp_gnu_ifunc_resolver_return
:
7341 loc
->loc_type
= bp_loc_software_breakpoint
;
7342 mark_breakpoint_location_modified (loc
);
7344 case bp_hardware_breakpoint
:
7345 loc
->loc_type
= bp_loc_hardware_breakpoint
;
7346 mark_breakpoint_location_modified (loc
);
7348 case bp_hardware_watchpoint
:
7349 case bp_read_watchpoint
:
7350 case bp_access_watchpoint
:
7351 loc
->loc_type
= bp_loc_hardware_watchpoint
;
7356 case bp_fast_tracepoint
:
7357 case bp_static_tracepoint
:
7358 loc
->loc_type
= bp_loc_other
;
7361 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
7367 /* Allocate a struct bp_location. */
7369 static struct bp_location
*
7370 allocate_bp_location (struct breakpoint
*bpt
)
7372 return bpt
->ops
->allocate_location (bpt
);
7376 free_bp_location (struct bp_location
*loc
)
7378 loc
->ops
->dtor (loc
);
7382 /* Increment reference count. */
7385 incref_bp_location (struct bp_location
*bl
)
7390 /* Decrement reference count. If the reference count reaches 0,
7391 destroy the bp_location. Sets *BLP to NULL. */
7394 decref_bp_location (struct bp_location
**blp
)
7396 gdb_assert ((*blp
)->refc
> 0);
7398 if (--(*blp
)->refc
== 0)
7399 free_bp_location (*blp
);
7403 /* Add breakpoint B at the end of the global breakpoint chain. */
7406 add_to_breakpoint_chain (struct breakpoint
*b
)
7408 struct breakpoint
*b1
;
7410 /* Add this breakpoint to the end of the chain so that a list of
7411 breakpoints will come out in order of increasing numbers. */
7413 b1
= breakpoint_chain
;
7415 breakpoint_chain
= b
;
7424 /* Initializes breakpoint B with type BPTYPE and no locations yet. */
7427 init_raw_breakpoint_without_location (struct breakpoint
*b
,
7428 struct gdbarch
*gdbarch
,
7430 const struct breakpoint_ops
*ops
)
7432 gdb_assert (ops
!= NULL
);
7436 b
->gdbarch
= gdbarch
;
7437 b
->language
= current_language
->la_language
;
7438 b
->input_radix
= input_radix
;
7439 b
->related_breakpoint
= b
;
7442 /* Helper to set_raw_breakpoint below. Creates a breakpoint
7443 that has type BPTYPE and has no locations as yet. */
7445 static struct breakpoint
*
7446 set_raw_breakpoint_without_location (struct gdbarch
*gdbarch
,
7448 const struct breakpoint_ops
*ops
)
7450 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (bptype
);
7452 init_raw_breakpoint_without_location (b
.get (), gdbarch
, bptype
, ops
);
7453 add_to_breakpoint_chain (b
.get ());
7455 return b
.release ();
7458 /* Initialize loc->function_name. EXPLICIT_LOC says no indirect function
7459 resolutions should be made as the user specified the location explicitly
7463 set_breakpoint_location_function (struct bp_location
*loc
, int explicit_loc
)
7465 gdb_assert (loc
->owner
!= NULL
);
7467 if (loc
->owner
->type
== bp_breakpoint
7468 || loc
->owner
->type
== bp_hardware_breakpoint
7469 || is_tracepoint (loc
->owner
))
7472 const char *function_name
;
7473 CORE_ADDR func_addr
;
7475 find_pc_partial_function_gnu_ifunc (loc
->address
, &function_name
,
7476 &func_addr
, NULL
, &is_gnu_ifunc
);
7478 if (is_gnu_ifunc
&& !explicit_loc
)
7480 struct breakpoint
*b
= loc
->owner
;
7482 gdb_assert (loc
->pspace
== current_program_space
);
7483 if (gnu_ifunc_resolve_name (function_name
,
7484 &loc
->requested_address
))
7486 /* Recalculate ADDRESS based on new REQUESTED_ADDRESS. */
7487 loc
->address
= adjust_breakpoint_address (loc
->gdbarch
,
7488 loc
->requested_address
,
7491 else if (b
->type
== bp_breakpoint
&& b
->loc
== loc
7492 && loc
->next
== NULL
&& b
->related_breakpoint
== b
)
7494 /* Create only the whole new breakpoint of this type but do not
7495 mess more complicated breakpoints with multiple locations. */
7496 b
->type
= bp_gnu_ifunc_resolver
;
7497 /* Remember the resolver's address for use by the return
7499 loc
->related_address
= func_addr
;
7504 loc
->function_name
= xstrdup (function_name
);
7508 /* Attempt to determine architecture of location identified by SAL. */
7510 get_sal_arch (struct symtab_and_line sal
)
7513 return get_objfile_arch (sal
.section
->objfile
);
7515 return get_objfile_arch (SYMTAB_OBJFILE (sal
.symtab
));
7520 /* Low level routine for partially initializing a breakpoint of type
7521 BPTYPE. The newly created breakpoint's address, section, source
7522 file name, and line number are provided by SAL.
7524 It is expected that the caller will complete the initialization of
7525 the newly created breakpoint struct as well as output any status
7526 information regarding the creation of a new breakpoint. */
7529 init_raw_breakpoint (struct breakpoint
*b
, struct gdbarch
*gdbarch
,
7530 struct symtab_and_line sal
, enum bptype bptype
,
7531 const struct breakpoint_ops
*ops
)
7533 init_raw_breakpoint_without_location (b
, gdbarch
, bptype
, ops
);
7535 add_location_to_breakpoint (b
, &sal
);
7537 if (bptype
!= bp_catchpoint
)
7538 gdb_assert (sal
.pspace
!= NULL
);
7540 /* Store the program space that was used to set the breakpoint,
7541 except for ordinary breakpoints, which are independent of the
7543 if (bptype
!= bp_breakpoint
&& bptype
!= bp_hardware_breakpoint
)
7544 b
->pspace
= sal
.pspace
;
7547 /* set_raw_breakpoint is a low level routine for allocating and
7548 partially initializing a breakpoint of type BPTYPE. The newly
7549 created breakpoint's address, section, source file name, and line
7550 number are provided by SAL. The newly created and partially
7551 initialized breakpoint is added to the breakpoint chain and
7552 is also returned as the value of this function.
7554 It is expected that the caller will complete the initialization of
7555 the newly created breakpoint struct as well as output any status
7556 information regarding the creation of a new breakpoint. In
7557 particular, set_raw_breakpoint does NOT set the breakpoint
7558 number! Care should be taken to not allow an error to occur
7559 prior to completing the initialization of the breakpoint. If this
7560 should happen, a bogus breakpoint will be left on the chain. */
7563 set_raw_breakpoint (struct gdbarch
*gdbarch
,
7564 struct symtab_and_line sal
, enum bptype bptype
,
7565 const struct breakpoint_ops
*ops
)
7567 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (bptype
);
7569 init_raw_breakpoint (b
.get (), gdbarch
, sal
, bptype
, ops
);
7570 add_to_breakpoint_chain (b
.get ());
7572 return b
.release ();
7575 /* Call this routine when stepping and nexting to enable a breakpoint
7576 if we do a longjmp() or 'throw' in TP. FRAME is the frame which
7577 initiated the operation. */
7580 set_longjmp_breakpoint (struct thread_info
*tp
, struct frame_id frame
)
7582 struct breakpoint
*b
, *b_tmp
;
7583 int thread
= tp
->global_num
;
7585 /* To avoid having to rescan all objfile symbols at every step,
7586 we maintain a list of continually-inserted but always disabled
7587 longjmp "master" breakpoints. Here, we simply create momentary
7588 clones of those and enable them for the requested thread. */
7589 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7590 if (b
->pspace
== current_program_space
7591 && (b
->type
== bp_longjmp_master
7592 || b
->type
== bp_exception_master
))
7594 enum bptype type
= b
->type
== bp_longjmp_master
? bp_longjmp
: bp_exception
;
7595 struct breakpoint
*clone
;
7597 /* longjmp_breakpoint_ops ensures INITIATING_FRAME is cleared again
7598 after their removal. */
7599 clone
= momentary_breakpoint_from_master (b
, type
,
7600 &momentary_breakpoint_ops
, 1);
7601 clone
->thread
= thread
;
7604 tp
->initiating_frame
= frame
;
7607 /* Delete all longjmp breakpoints from THREAD. */
7609 delete_longjmp_breakpoint (int thread
)
7611 struct breakpoint
*b
, *b_tmp
;
7613 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7614 if (b
->type
== bp_longjmp
|| b
->type
== bp_exception
)
7616 if (b
->thread
== thread
)
7617 delete_breakpoint (b
);
7622 delete_longjmp_breakpoint_at_next_stop (int thread
)
7624 struct breakpoint
*b
, *b_tmp
;
7626 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7627 if (b
->type
== bp_longjmp
|| b
->type
== bp_exception
)
7629 if (b
->thread
== thread
)
7630 b
->disposition
= disp_del_at_next_stop
;
7634 /* Place breakpoints of type bp_longjmp_call_dummy to catch longjmp for
7635 INFERIOR_PTID thread. Chain them all by RELATED_BREAKPOINT and return
7636 pointer to any of them. Return NULL if this system cannot place longjmp
7640 set_longjmp_breakpoint_for_call_dummy (void)
7642 struct breakpoint
*b
, *retval
= NULL
;
7645 if (b
->pspace
== current_program_space
&& b
->type
== bp_longjmp_master
)
7647 struct breakpoint
*new_b
;
7649 new_b
= momentary_breakpoint_from_master (b
, bp_longjmp_call_dummy
,
7650 &momentary_breakpoint_ops
,
7652 new_b
->thread
= ptid_to_global_thread_id (inferior_ptid
);
7654 /* Link NEW_B into the chain of RETVAL breakpoints. */
7656 gdb_assert (new_b
->related_breakpoint
== new_b
);
7659 new_b
->related_breakpoint
= retval
;
7660 while (retval
->related_breakpoint
!= new_b
->related_breakpoint
)
7661 retval
= retval
->related_breakpoint
;
7662 retval
->related_breakpoint
= new_b
;
7668 /* Verify all existing dummy frames and their associated breakpoints for
7669 TP. Remove those which can no longer be found in the current frame
7672 You should call this function only at places where it is safe to currently
7673 unwind the whole stack. Failed stack unwind would discard live dummy
7677 check_longjmp_breakpoint_for_call_dummy (struct thread_info
*tp
)
7679 struct breakpoint
*b
, *b_tmp
;
7681 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7682 if (b
->type
== bp_longjmp_call_dummy
&& b
->thread
== tp
->global_num
)
7684 struct breakpoint
*dummy_b
= b
->related_breakpoint
;
7686 while (dummy_b
!= b
&& dummy_b
->type
!= bp_call_dummy
)
7687 dummy_b
= dummy_b
->related_breakpoint
;
7688 if (dummy_b
->type
!= bp_call_dummy
7689 || frame_find_by_id (dummy_b
->frame_id
) != NULL
)
7692 dummy_frame_discard (dummy_b
->frame_id
, tp
->ptid
);
7694 while (b
->related_breakpoint
!= b
)
7696 if (b_tmp
== b
->related_breakpoint
)
7697 b_tmp
= b
->related_breakpoint
->next
;
7698 delete_breakpoint (b
->related_breakpoint
);
7700 delete_breakpoint (b
);
7705 enable_overlay_breakpoints (void)
7707 struct breakpoint
*b
;
7710 if (b
->type
== bp_overlay_event
)
7712 b
->enable_state
= bp_enabled
;
7713 update_global_location_list (UGLL_MAY_INSERT
);
7714 overlay_events_enabled
= 1;
7719 disable_overlay_breakpoints (void)
7721 struct breakpoint
*b
;
7724 if (b
->type
== bp_overlay_event
)
7726 b
->enable_state
= bp_disabled
;
7727 update_global_location_list (UGLL_DONT_INSERT
);
7728 overlay_events_enabled
= 0;
7732 /* Set an active std::terminate breakpoint for each std::terminate
7733 master breakpoint. */
7735 set_std_terminate_breakpoint (void)
7737 struct breakpoint
*b
, *b_tmp
;
7739 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7740 if (b
->pspace
== current_program_space
7741 && b
->type
== bp_std_terminate_master
)
7743 momentary_breakpoint_from_master (b
, bp_std_terminate
,
7744 &momentary_breakpoint_ops
, 1);
7748 /* Delete all the std::terminate breakpoints. */
7750 delete_std_terminate_breakpoint (void)
7752 struct breakpoint
*b
, *b_tmp
;
7754 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7755 if (b
->type
== bp_std_terminate
)
7756 delete_breakpoint (b
);
7760 create_thread_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7762 struct breakpoint
*b
;
7764 b
= create_internal_breakpoint (gdbarch
, address
, bp_thread_event
,
7765 &internal_breakpoint_ops
);
7767 b
->enable_state
= bp_enabled
;
7768 /* location has to be used or breakpoint_re_set will delete me. */
7769 b
->location
= new_address_location (b
->loc
->address
, NULL
, 0);
7771 update_global_location_list_nothrow (UGLL_MAY_INSERT
);
7776 struct lang_and_radix
7782 /* Create a breakpoint for JIT code registration and unregistration. */
7785 create_jit_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7787 return create_internal_breakpoint (gdbarch
, address
, bp_jit_event
,
7788 &internal_breakpoint_ops
);
7791 /* Remove JIT code registration and unregistration breakpoint(s). */
7794 remove_jit_event_breakpoints (void)
7796 struct breakpoint
*b
, *b_tmp
;
7798 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7799 if (b
->type
== bp_jit_event
7800 && b
->loc
->pspace
== current_program_space
)
7801 delete_breakpoint (b
);
7805 remove_solib_event_breakpoints (void)
7807 struct breakpoint
*b
, *b_tmp
;
7809 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7810 if (b
->type
== bp_shlib_event
7811 && b
->loc
->pspace
== current_program_space
)
7812 delete_breakpoint (b
);
7815 /* See breakpoint.h. */
7818 remove_solib_event_breakpoints_at_next_stop (void)
7820 struct breakpoint
*b
, *b_tmp
;
7822 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7823 if (b
->type
== bp_shlib_event
7824 && b
->loc
->pspace
== current_program_space
)
7825 b
->disposition
= disp_del_at_next_stop
;
7828 /* Helper for create_solib_event_breakpoint /
7829 create_and_insert_solib_event_breakpoint. Allows specifying which
7830 INSERT_MODE to pass through to update_global_location_list. */
7832 static struct breakpoint
*
7833 create_solib_event_breakpoint_1 (struct gdbarch
*gdbarch
, CORE_ADDR address
,
7834 enum ugll_insert_mode insert_mode
)
7836 struct breakpoint
*b
;
7838 b
= create_internal_breakpoint (gdbarch
, address
, bp_shlib_event
,
7839 &internal_breakpoint_ops
);
7840 update_global_location_list_nothrow (insert_mode
);
7845 create_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7847 return create_solib_event_breakpoint_1 (gdbarch
, address
, UGLL_MAY_INSERT
);
7850 /* See breakpoint.h. */
7853 create_and_insert_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7855 struct breakpoint
*b
;
7857 /* Explicitly tell update_global_location_list to insert
7859 b
= create_solib_event_breakpoint_1 (gdbarch
, address
, UGLL_INSERT
);
7860 if (!b
->loc
->inserted
)
7862 delete_breakpoint (b
);
7868 /* Disable any breakpoints that are on code in shared libraries. Only
7869 apply to enabled breakpoints, disabled ones can just stay disabled. */
7872 disable_breakpoints_in_shlibs (void)
7874 struct bp_location
*loc
, **locp_tmp
;
7876 ALL_BP_LOCATIONS (loc
, locp_tmp
)
7878 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7879 struct breakpoint
*b
= loc
->owner
;
7881 /* We apply the check to all breakpoints, including disabled for
7882 those with loc->duplicate set. This is so that when breakpoint
7883 becomes enabled, or the duplicate is removed, gdb will try to
7884 insert all breakpoints. If we don't set shlib_disabled here,
7885 we'll try to insert those breakpoints and fail. */
7886 if (((b
->type
== bp_breakpoint
)
7887 || (b
->type
== bp_jit_event
)
7888 || (b
->type
== bp_hardware_breakpoint
)
7889 || (is_tracepoint (b
)))
7890 && loc
->pspace
== current_program_space
7891 && !loc
->shlib_disabled
7892 && solib_name_from_address (loc
->pspace
, loc
->address
)
7895 loc
->shlib_disabled
= 1;
7900 /* Disable any breakpoints and tracepoints that are in SOLIB upon
7901 notification of unloaded_shlib. Only apply to enabled breakpoints,
7902 disabled ones can just stay disabled. */
7905 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
7907 struct bp_location
*loc
, **locp_tmp
;
7908 int disabled_shlib_breaks
= 0;
7910 ALL_BP_LOCATIONS (loc
, locp_tmp
)
7912 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7913 struct breakpoint
*b
= loc
->owner
;
7915 if (solib
->pspace
== loc
->pspace
7916 && !loc
->shlib_disabled
7917 && (((b
->type
== bp_breakpoint
7918 || b
->type
== bp_jit_event
7919 || b
->type
== bp_hardware_breakpoint
)
7920 && (loc
->loc_type
== bp_loc_hardware_breakpoint
7921 || loc
->loc_type
== bp_loc_software_breakpoint
))
7922 || is_tracepoint (b
))
7923 && solib_contains_address_p (solib
, loc
->address
))
7925 loc
->shlib_disabled
= 1;
7926 /* At this point, we cannot rely on remove_breakpoint
7927 succeeding so we must mark the breakpoint as not inserted
7928 to prevent future errors occurring in remove_breakpoints. */
7931 /* This may cause duplicate notifications for the same breakpoint. */
7932 observer_notify_breakpoint_modified (b
);
7934 if (!disabled_shlib_breaks
)
7936 target_terminal_ours_for_output ();
7937 warning (_("Temporarily disabling breakpoints "
7938 "for unloaded shared library \"%s\""),
7941 disabled_shlib_breaks
= 1;
7946 /* Disable any breakpoints and tracepoints in OBJFILE upon
7947 notification of free_objfile. Only apply to enabled breakpoints,
7948 disabled ones can just stay disabled. */
7951 disable_breakpoints_in_freed_objfile (struct objfile
*objfile
)
7953 struct breakpoint
*b
;
7955 if (objfile
== NULL
)
7958 /* OBJF_SHARED|OBJF_USERLOADED objfiles are dynamic modules manually
7959 managed by the user with add-symbol-file/remove-symbol-file.
7960 Similarly to how breakpoints in shared libraries are handled in
7961 response to "nosharedlibrary", mark breakpoints in such modules
7962 shlib_disabled so they end up uninserted on the next global
7963 location list update. Shared libraries not loaded by the user
7964 aren't handled here -- they're already handled in
7965 disable_breakpoints_in_unloaded_shlib, called by solib.c's
7966 solib_unloaded observer. We skip objfiles that are not
7967 OBJF_SHARED as those aren't considered dynamic objects (e.g. the
7969 if ((objfile
->flags
& OBJF_SHARED
) == 0
7970 || (objfile
->flags
& OBJF_USERLOADED
) == 0)
7975 struct bp_location
*loc
;
7976 int bp_modified
= 0;
7978 if (!is_breakpoint (b
) && !is_tracepoint (b
))
7981 for (loc
= b
->loc
; loc
!= NULL
; loc
= loc
->next
)
7983 CORE_ADDR loc_addr
= loc
->address
;
7985 if (loc
->loc_type
!= bp_loc_hardware_breakpoint
7986 && loc
->loc_type
!= bp_loc_software_breakpoint
)
7989 if (loc
->shlib_disabled
!= 0)
7992 if (objfile
->pspace
!= loc
->pspace
)
7995 if (loc
->loc_type
!= bp_loc_hardware_breakpoint
7996 && loc
->loc_type
!= bp_loc_software_breakpoint
)
7999 if (is_addr_in_objfile (loc_addr
, objfile
))
8001 loc
->shlib_disabled
= 1;
8002 /* At this point, we don't know whether the object was
8003 unmapped from the inferior or not, so leave the
8004 inserted flag alone. We'll handle failure to
8005 uninsert quietly, in case the object was indeed
8008 mark_breakpoint_location_modified (loc
);
8015 observer_notify_breakpoint_modified (b
);
8019 /* FORK & VFORK catchpoints. */
8021 /* An instance of this type is used to represent a fork or vfork
8022 catchpoint. A breakpoint is really of this type iff its ops pointer points
8023 to CATCH_FORK_BREAKPOINT_OPS. */
8025 struct fork_catchpoint
: public breakpoint
8027 /* Process id of a child process whose forking triggered this
8028 catchpoint. This field is only valid immediately after this
8029 catchpoint has triggered. */
8030 ptid_t forked_inferior_pid
;
8033 /* Implement the "insert" breakpoint_ops method for fork
8037 insert_catch_fork (struct bp_location
*bl
)
8039 return target_insert_fork_catchpoint (ptid_get_pid (inferior_ptid
));
8042 /* Implement the "remove" breakpoint_ops method for fork
8046 remove_catch_fork (struct bp_location
*bl
, enum remove_bp_reason reason
)
8048 return target_remove_fork_catchpoint (ptid_get_pid (inferior_ptid
));
8051 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
8055 breakpoint_hit_catch_fork (const struct bp_location
*bl
,
8056 struct address_space
*aspace
, CORE_ADDR bp_addr
,
8057 const struct target_waitstatus
*ws
)
8059 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bl
->owner
;
8061 if (ws
->kind
!= TARGET_WAITKIND_FORKED
)
8064 c
->forked_inferior_pid
= ws
->value
.related_pid
;
8068 /* Implement the "print_it" breakpoint_ops method for fork
8071 static enum print_stop_action
8072 print_it_catch_fork (bpstat bs
)
8074 struct ui_out
*uiout
= current_uiout
;
8075 struct breakpoint
*b
= bs
->breakpoint_at
;
8076 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bs
->breakpoint_at
;
8078 annotate_catchpoint (b
->number
);
8079 maybe_print_thread_hit_breakpoint (uiout
);
8080 if (b
->disposition
== disp_del
)
8081 uiout
->text ("Temporary catchpoint ");
8083 uiout
->text ("Catchpoint ");
8084 if (uiout
->is_mi_like_p ())
8086 uiout
->field_string ("reason", async_reason_lookup (EXEC_ASYNC_FORK
));
8087 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
8089 uiout
->field_int ("bkptno", b
->number
);
8090 uiout
->text (" (forked process ");
8091 uiout
->field_int ("newpid", ptid_get_pid (c
->forked_inferior_pid
));
8092 uiout
->text ("), ");
8093 return PRINT_SRC_AND_LOC
;
8096 /* Implement the "print_one" breakpoint_ops method for fork
8100 print_one_catch_fork (struct breakpoint
*b
, struct bp_location
**last_loc
)
8102 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
8103 struct value_print_options opts
;
8104 struct ui_out
*uiout
= current_uiout
;
8106 get_user_print_options (&opts
);
8108 /* Field 4, the address, is omitted (which makes the columns not
8109 line up too nicely with the headers, but the effect is relatively
8111 if (opts
.addressprint
)
8112 uiout
->field_skip ("addr");
8114 uiout
->text ("fork");
8115 if (!ptid_equal (c
->forked_inferior_pid
, null_ptid
))
8117 uiout
->text (", process ");
8118 uiout
->field_int ("what", ptid_get_pid (c
->forked_inferior_pid
));
8122 if (uiout
->is_mi_like_p ())
8123 uiout
->field_string ("catch-type", "fork");
8126 /* Implement the "print_mention" breakpoint_ops method for fork
8130 print_mention_catch_fork (struct breakpoint
*b
)
8132 printf_filtered (_("Catchpoint %d (fork)"), b
->number
);
8135 /* Implement the "print_recreate" breakpoint_ops method for fork
8139 print_recreate_catch_fork (struct breakpoint
*b
, struct ui_file
*fp
)
8141 fprintf_unfiltered (fp
, "catch fork");
8142 print_recreate_thread (b
, fp
);
8145 /* The breakpoint_ops structure to be used in fork catchpoints. */
8147 static struct breakpoint_ops catch_fork_breakpoint_ops
;
8149 /* Implement the "insert" breakpoint_ops method for vfork
8153 insert_catch_vfork (struct bp_location
*bl
)
8155 return target_insert_vfork_catchpoint (ptid_get_pid (inferior_ptid
));
8158 /* Implement the "remove" breakpoint_ops method for vfork
8162 remove_catch_vfork (struct bp_location
*bl
, enum remove_bp_reason reason
)
8164 return target_remove_vfork_catchpoint (ptid_get_pid (inferior_ptid
));
8167 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
8171 breakpoint_hit_catch_vfork (const struct bp_location
*bl
,
8172 struct address_space
*aspace
, CORE_ADDR bp_addr
,
8173 const struct target_waitstatus
*ws
)
8175 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bl
->owner
;
8177 if (ws
->kind
!= TARGET_WAITKIND_VFORKED
)
8180 c
->forked_inferior_pid
= ws
->value
.related_pid
;
8184 /* Implement the "print_it" breakpoint_ops method for vfork
8187 static enum print_stop_action
8188 print_it_catch_vfork (bpstat bs
)
8190 struct ui_out
*uiout
= current_uiout
;
8191 struct breakpoint
*b
= bs
->breakpoint_at
;
8192 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
8194 annotate_catchpoint (b
->number
);
8195 maybe_print_thread_hit_breakpoint (uiout
);
8196 if (b
->disposition
== disp_del
)
8197 uiout
->text ("Temporary catchpoint ");
8199 uiout
->text ("Catchpoint ");
8200 if (uiout
->is_mi_like_p ())
8202 uiout
->field_string ("reason", async_reason_lookup (EXEC_ASYNC_VFORK
));
8203 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
8205 uiout
->field_int ("bkptno", b
->number
);
8206 uiout
->text (" (vforked process ");
8207 uiout
->field_int ("newpid", ptid_get_pid (c
->forked_inferior_pid
));
8208 uiout
->text ("), ");
8209 return PRINT_SRC_AND_LOC
;
8212 /* Implement the "print_one" breakpoint_ops method for vfork
8216 print_one_catch_vfork (struct breakpoint
*b
, struct bp_location
**last_loc
)
8218 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
8219 struct value_print_options opts
;
8220 struct ui_out
*uiout
= current_uiout
;
8222 get_user_print_options (&opts
);
8223 /* Field 4, the address, is omitted (which makes the columns not
8224 line up too nicely with the headers, but the effect is relatively
8226 if (opts
.addressprint
)
8227 uiout
->field_skip ("addr");
8229 uiout
->text ("vfork");
8230 if (!ptid_equal (c
->forked_inferior_pid
, null_ptid
))
8232 uiout
->text (", process ");
8233 uiout
->field_int ("what", ptid_get_pid (c
->forked_inferior_pid
));
8237 if (uiout
->is_mi_like_p ())
8238 uiout
->field_string ("catch-type", "vfork");
8241 /* Implement the "print_mention" breakpoint_ops method for vfork
8245 print_mention_catch_vfork (struct breakpoint
*b
)
8247 printf_filtered (_("Catchpoint %d (vfork)"), b
->number
);
8250 /* Implement the "print_recreate" breakpoint_ops method for vfork
8254 print_recreate_catch_vfork (struct breakpoint
*b
, struct ui_file
*fp
)
8256 fprintf_unfiltered (fp
, "catch vfork");
8257 print_recreate_thread (b
, fp
);
8260 /* The breakpoint_ops structure to be used in vfork catchpoints. */
8262 static struct breakpoint_ops catch_vfork_breakpoint_ops
;
8264 /* An instance of this type is used to represent an solib catchpoint.
8265 A breakpoint is really of this type iff its ops pointer points to
8266 CATCH_SOLIB_BREAKPOINT_OPS. */
8268 struct solib_catchpoint
: public breakpoint
8270 ~solib_catchpoint () override
;
8272 /* True for "catch load", false for "catch unload". */
8273 unsigned char is_load
;
8275 /* Regular expression to match, if any. COMPILED is only valid when
8276 REGEX is non-NULL. */
8278 std::unique_ptr
<compiled_regex
> compiled
;
8281 solib_catchpoint::~solib_catchpoint ()
8283 xfree (this->regex
);
8287 insert_catch_solib (struct bp_location
*ignore
)
8293 remove_catch_solib (struct bp_location
*ignore
, enum remove_bp_reason reason
)
8299 breakpoint_hit_catch_solib (const struct bp_location
*bl
,
8300 struct address_space
*aspace
,
8302 const struct target_waitstatus
*ws
)
8304 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) bl
->owner
;
8305 struct breakpoint
*other
;
8307 if (ws
->kind
== TARGET_WAITKIND_LOADED
)
8310 ALL_BREAKPOINTS (other
)
8312 struct bp_location
*other_bl
;
8314 if (other
== bl
->owner
)
8317 if (other
->type
!= bp_shlib_event
)
8320 if (self
->pspace
!= NULL
&& other
->pspace
!= self
->pspace
)
8323 for (other_bl
= other
->loc
; other_bl
!= NULL
; other_bl
= other_bl
->next
)
8325 if (other
->ops
->breakpoint_hit (other_bl
, aspace
, bp_addr
, ws
))
8334 check_status_catch_solib (struct bpstats
*bs
)
8336 struct solib_catchpoint
*self
8337 = (struct solib_catchpoint
*) bs
->breakpoint_at
;
8342 struct so_list
*iter
;
8345 VEC_iterate (so_list_ptr
, current_program_space
->added_solibs
,
8350 || self
->compiled
->exec (iter
->so_name
, 0, NULL
, 0) == 0)
8359 VEC_iterate (char_ptr
, current_program_space
->deleted_solibs
,
8364 || self
->compiled
->exec (iter
, 0, NULL
, 0) == 0)
8370 bs
->print_it
= print_it_noop
;
8373 static enum print_stop_action
8374 print_it_catch_solib (bpstat bs
)
8376 struct breakpoint
*b
= bs
->breakpoint_at
;
8377 struct ui_out
*uiout
= current_uiout
;
8379 annotate_catchpoint (b
->number
);
8380 maybe_print_thread_hit_breakpoint (uiout
);
8381 if (b
->disposition
== disp_del
)
8382 uiout
->text ("Temporary catchpoint ");
8384 uiout
->text ("Catchpoint ");
8385 uiout
->field_int ("bkptno", b
->number
);
8387 if (uiout
->is_mi_like_p ())
8388 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
8389 print_solib_event (1);
8390 return PRINT_SRC_AND_LOC
;
8394 print_one_catch_solib (struct breakpoint
*b
, struct bp_location
**locs
)
8396 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8397 struct value_print_options opts
;
8398 struct ui_out
*uiout
= current_uiout
;
8401 get_user_print_options (&opts
);
8402 /* Field 4, the address, is omitted (which makes the columns not
8403 line up too nicely with the headers, but the effect is relatively
8405 if (opts
.addressprint
)
8408 uiout
->field_skip ("addr");
8415 msg
= xstrprintf (_("load of library matching %s"), self
->regex
);
8417 msg
= xstrdup (_("load of library"));
8422 msg
= xstrprintf (_("unload of library matching %s"), self
->regex
);
8424 msg
= xstrdup (_("unload of library"));
8426 uiout
->field_string ("what", msg
);
8429 if (uiout
->is_mi_like_p ())
8430 uiout
->field_string ("catch-type", self
->is_load
? "load" : "unload");
8434 print_mention_catch_solib (struct breakpoint
*b
)
8436 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8438 printf_filtered (_("Catchpoint %d (%s)"), b
->number
,
8439 self
->is_load
? "load" : "unload");
8443 print_recreate_catch_solib (struct breakpoint
*b
, struct ui_file
*fp
)
8445 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8447 fprintf_unfiltered (fp
, "%s %s",
8448 b
->disposition
== disp_del
? "tcatch" : "catch",
8449 self
->is_load
? "load" : "unload");
8451 fprintf_unfiltered (fp
, " %s", self
->regex
);
8452 fprintf_unfiltered (fp
, "\n");
8455 static struct breakpoint_ops catch_solib_breakpoint_ops
;
8457 /* Shared helper function (MI and CLI) for creating and installing
8458 a shared object event catchpoint. If IS_LOAD is non-zero then
8459 the events to be caught are load events, otherwise they are
8460 unload events. If IS_TEMP is non-zero the catchpoint is a
8461 temporary one. If ENABLED is non-zero the catchpoint is
8462 created in an enabled state. */
8465 add_solib_catchpoint (const char *arg
, int is_load
, int is_temp
, int enabled
)
8467 struct solib_catchpoint
*c
;
8468 struct gdbarch
*gdbarch
= get_current_arch ();
8469 struct cleanup
*cleanup
;
8473 arg
= skip_spaces_const (arg
);
8475 c
= new solib_catchpoint ();
8476 cleanup
= make_cleanup (xfree
, c
);
8480 c
->compiled
.reset (new compiled_regex (arg
, REG_NOSUB
,
8481 _("Invalid regexp")));
8482 c
->regex
= xstrdup (arg
);
8485 c
->is_load
= is_load
;
8486 init_catchpoint (c
, gdbarch
, is_temp
, NULL
,
8487 &catch_solib_breakpoint_ops
);
8489 c
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
8491 discard_cleanups (cleanup
);
8492 install_breakpoint (0, c
, 1);
8495 /* A helper function that does all the work for "catch load" and
8499 catch_load_or_unload (char *arg
, int from_tty
, int is_load
,
8500 struct cmd_list_element
*command
)
8503 const int enabled
= 1;
8505 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
8507 add_solib_catchpoint (arg
, is_load
, tempflag
, enabled
);
8511 catch_load_command_1 (char *arg
, int from_tty
,
8512 struct cmd_list_element
*command
)
8514 catch_load_or_unload (arg
, from_tty
, 1, command
);
8518 catch_unload_command_1 (char *arg
, int from_tty
,
8519 struct cmd_list_element
*command
)
8521 catch_load_or_unload (arg
, from_tty
, 0, command
);
8524 /* Initialize a new breakpoint of the bp_catchpoint kind. If TEMPFLAG
8525 is non-zero, then make the breakpoint temporary. If COND_STRING is
8526 not NULL, then store it in the breakpoint. OPS, if not NULL, is
8527 the breakpoint_ops structure associated to the catchpoint. */
8530 init_catchpoint (struct breakpoint
*b
,
8531 struct gdbarch
*gdbarch
, int tempflag
,
8532 const char *cond_string
,
8533 const struct breakpoint_ops
*ops
)
8535 struct symtab_and_line sal
;
8538 sal
.pspace
= current_program_space
;
8540 init_raw_breakpoint (b
, gdbarch
, sal
, bp_catchpoint
, ops
);
8542 b
->cond_string
= (cond_string
== NULL
) ? NULL
: xstrdup (cond_string
);
8543 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
8547 install_breakpoint (int internal
, struct breakpoint
*b
, int update_gll
)
8549 add_to_breakpoint_chain (b
);
8550 set_breakpoint_number (internal
, b
);
8551 if (is_tracepoint (b
))
8552 set_tracepoint_count (breakpoint_count
);
8555 observer_notify_breakpoint_created (b
);
8558 update_global_location_list (UGLL_MAY_INSERT
);
8562 create_fork_vfork_event_catchpoint (struct gdbarch
*gdbarch
,
8563 int tempflag
, const char *cond_string
,
8564 const struct breakpoint_ops
*ops
)
8566 struct fork_catchpoint
*c
= new fork_catchpoint ();
8568 init_catchpoint (c
, gdbarch
, tempflag
, cond_string
, ops
);
8570 c
->forked_inferior_pid
= null_ptid
;
8572 install_breakpoint (0, c
, 1);
8575 /* Exec catchpoints. */
8577 /* An instance of this type is used to represent an exec catchpoint.
8578 A breakpoint is really of this type iff its ops pointer points to
8579 CATCH_EXEC_BREAKPOINT_OPS. */
8581 struct exec_catchpoint
: public breakpoint
8583 ~exec_catchpoint () override
;
8585 /* Filename of a program whose exec triggered this catchpoint.
8586 This field is only valid immediately after this catchpoint has
8588 char *exec_pathname
;
8591 /* Exec catchpoint destructor. */
8593 exec_catchpoint::~exec_catchpoint ()
8595 xfree (this->exec_pathname
);
8599 insert_catch_exec (struct bp_location
*bl
)
8601 return target_insert_exec_catchpoint (ptid_get_pid (inferior_ptid
));
8605 remove_catch_exec (struct bp_location
*bl
, enum remove_bp_reason reason
)
8607 return target_remove_exec_catchpoint (ptid_get_pid (inferior_ptid
));
8611 breakpoint_hit_catch_exec (const struct bp_location
*bl
,
8612 struct address_space
*aspace
, CORE_ADDR bp_addr
,
8613 const struct target_waitstatus
*ws
)
8615 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) bl
->owner
;
8617 if (ws
->kind
!= TARGET_WAITKIND_EXECD
)
8620 c
->exec_pathname
= xstrdup (ws
->value
.execd_pathname
);
8624 static enum print_stop_action
8625 print_it_catch_exec (bpstat bs
)
8627 struct ui_out
*uiout
= current_uiout
;
8628 struct breakpoint
*b
= bs
->breakpoint_at
;
8629 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
8631 annotate_catchpoint (b
->number
);
8632 maybe_print_thread_hit_breakpoint (uiout
);
8633 if (b
->disposition
== disp_del
)
8634 uiout
->text ("Temporary catchpoint ");
8636 uiout
->text ("Catchpoint ");
8637 if (uiout
->is_mi_like_p ())
8639 uiout
->field_string ("reason", async_reason_lookup (EXEC_ASYNC_EXEC
));
8640 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
8642 uiout
->field_int ("bkptno", b
->number
);
8643 uiout
->text (" (exec'd ");
8644 uiout
->field_string ("new-exec", c
->exec_pathname
);
8645 uiout
->text ("), ");
8647 return PRINT_SRC_AND_LOC
;
8651 print_one_catch_exec (struct breakpoint
*b
, struct bp_location
**last_loc
)
8653 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
8654 struct value_print_options opts
;
8655 struct ui_out
*uiout
= current_uiout
;
8657 get_user_print_options (&opts
);
8659 /* Field 4, the address, is omitted (which makes the columns
8660 not line up too nicely with the headers, but the effect
8661 is relatively readable). */
8662 if (opts
.addressprint
)
8663 uiout
->field_skip ("addr");
8665 uiout
->text ("exec");
8666 if (c
->exec_pathname
!= NULL
)
8668 uiout
->text (", program \"");
8669 uiout
->field_string ("what", c
->exec_pathname
);
8670 uiout
->text ("\" ");
8673 if (uiout
->is_mi_like_p ())
8674 uiout
->field_string ("catch-type", "exec");
8678 print_mention_catch_exec (struct breakpoint
*b
)
8680 printf_filtered (_("Catchpoint %d (exec)"), b
->number
);
8683 /* Implement the "print_recreate" breakpoint_ops method for exec
8687 print_recreate_catch_exec (struct breakpoint
*b
, struct ui_file
*fp
)
8689 fprintf_unfiltered (fp
, "catch exec");
8690 print_recreate_thread (b
, fp
);
8693 static struct breakpoint_ops catch_exec_breakpoint_ops
;
8696 hw_breakpoint_used_count (void)
8699 struct breakpoint
*b
;
8700 struct bp_location
*bl
;
8704 if (b
->type
== bp_hardware_breakpoint
&& breakpoint_enabled (b
))
8705 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
8707 /* Special types of hardware breakpoints may use more than
8709 i
+= b
->ops
->resources_needed (bl
);
8716 /* Returns the resources B would use if it were a hardware
8720 hw_watchpoint_use_count (struct breakpoint
*b
)
8723 struct bp_location
*bl
;
8725 if (!breakpoint_enabled (b
))
8728 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
8730 /* Special types of hardware watchpoints may use more than
8732 i
+= b
->ops
->resources_needed (bl
);
8738 /* Returns the sum the used resources of all hardware watchpoints of
8739 type TYPE in the breakpoints list. Also returns in OTHER_TYPE_USED
8740 the sum of the used resources of all hardware watchpoints of other
8741 types _not_ TYPE. */
8744 hw_watchpoint_used_count_others (struct breakpoint
*except
,
8745 enum bptype type
, int *other_type_used
)
8748 struct breakpoint
*b
;
8750 *other_type_used
= 0;
8755 if (!breakpoint_enabled (b
))
8758 if (b
->type
== type
)
8759 i
+= hw_watchpoint_use_count (b
);
8760 else if (is_hardware_watchpoint (b
))
8761 *other_type_used
= 1;
8768 disable_watchpoints_before_interactive_call_start (void)
8770 struct breakpoint
*b
;
8774 if (is_watchpoint (b
) && breakpoint_enabled (b
))
8776 b
->enable_state
= bp_call_disabled
;
8777 update_global_location_list (UGLL_DONT_INSERT
);
8783 enable_watchpoints_after_interactive_call_stop (void)
8785 struct breakpoint
*b
;
8789 if (is_watchpoint (b
) && b
->enable_state
== bp_call_disabled
)
8791 b
->enable_state
= bp_enabled
;
8792 update_global_location_list (UGLL_MAY_INSERT
);
8798 disable_breakpoints_before_startup (void)
8800 current_program_space
->executing_startup
= 1;
8801 update_global_location_list (UGLL_DONT_INSERT
);
8805 enable_breakpoints_after_startup (void)
8807 current_program_space
->executing_startup
= 0;
8808 breakpoint_re_set ();
8811 /* Create a new single-step breakpoint for thread THREAD, with no
8814 static struct breakpoint
*
8815 new_single_step_breakpoint (int thread
, struct gdbarch
*gdbarch
)
8817 struct breakpoint
*b
= new breakpoint ();
8819 init_raw_breakpoint_without_location (b
, gdbarch
, bp_single_step
,
8820 &momentary_breakpoint_ops
);
8822 b
->disposition
= disp_donttouch
;
8823 b
->frame_id
= null_frame_id
;
8826 gdb_assert (b
->thread
!= 0);
8828 add_to_breakpoint_chain (b
);
8833 /* Set a momentary breakpoint of type TYPE at address specified by
8834 SAL. If FRAME_ID is valid, the breakpoint is restricted to that
8838 set_momentary_breakpoint (struct gdbarch
*gdbarch
, struct symtab_and_line sal
,
8839 struct frame_id frame_id
, enum bptype type
)
8841 struct breakpoint
*b
;
8843 /* If FRAME_ID is valid, it should be a real frame, not an inlined or
8845 gdb_assert (!frame_id_artificial_p (frame_id
));
8847 b
= set_raw_breakpoint (gdbarch
, sal
, type
, &momentary_breakpoint_ops
);
8848 b
->enable_state
= bp_enabled
;
8849 b
->disposition
= disp_donttouch
;
8850 b
->frame_id
= frame_id
;
8852 /* If we're debugging a multi-threaded program, then we want
8853 momentary breakpoints to be active in only a single thread of
8855 if (in_thread_list (inferior_ptid
))
8856 b
->thread
= ptid_to_global_thread_id (inferior_ptid
);
8858 update_global_location_list_nothrow (UGLL_MAY_INSERT
);
8863 /* Make a momentary breakpoint based on the master breakpoint ORIG.
8864 The new breakpoint will have type TYPE, use OPS as its
8865 breakpoint_ops, and will set enabled to LOC_ENABLED. */
8867 static struct breakpoint
*
8868 momentary_breakpoint_from_master (struct breakpoint
*orig
,
8870 const struct breakpoint_ops
*ops
,
8873 struct breakpoint
*copy
;
8875 copy
= set_raw_breakpoint_without_location (orig
->gdbarch
, type
, ops
);
8876 copy
->loc
= allocate_bp_location (copy
);
8877 set_breakpoint_location_function (copy
->loc
, 1);
8879 copy
->loc
->gdbarch
= orig
->loc
->gdbarch
;
8880 copy
->loc
->requested_address
= orig
->loc
->requested_address
;
8881 copy
->loc
->address
= orig
->loc
->address
;
8882 copy
->loc
->section
= orig
->loc
->section
;
8883 copy
->loc
->pspace
= orig
->loc
->pspace
;
8884 copy
->loc
->probe
= orig
->loc
->probe
;
8885 copy
->loc
->line_number
= orig
->loc
->line_number
;
8886 copy
->loc
->symtab
= orig
->loc
->symtab
;
8887 copy
->loc
->enabled
= loc_enabled
;
8888 copy
->frame_id
= orig
->frame_id
;
8889 copy
->thread
= orig
->thread
;
8890 copy
->pspace
= orig
->pspace
;
8892 copy
->enable_state
= bp_enabled
;
8893 copy
->disposition
= disp_donttouch
;
8894 copy
->number
= internal_breakpoint_number
--;
8896 update_global_location_list_nothrow (UGLL_DONT_INSERT
);
8900 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
8904 clone_momentary_breakpoint (struct breakpoint
*orig
)
8906 /* If there's nothing to clone, then return nothing. */
8910 return momentary_breakpoint_from_master (orig
, orig
->type
, orig
->ops
, 0);
8914 set_momentary_breakpoint_at_pc (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
8917 struct symtab_and_line sal
;
8919 sal
= find_pc_line (pc
, 0);
8921 sal
.section
= find_pc_overlay (pc
);
8922 sal
.explicit_pc
= 1;
8924 return set_momentary_breakpoint (gdbarch
, sal
, null_frame_id
, type
);
8928 /* Tell the user we have just set a breakpoint B. */
8931 mention (struct breakpoint
*b
)
8933 b
->ops
->print_mention (b
);
8934 if (current_uiout
->is_mi_like_p ())
8936 printf_filtered ("\n");
8940 static int bp_loc_is_permanent (struct bp_location
*loc
);
8942 static struct bp_location
*
8943 add_location_to_breakpoint (struct breakpoint
*b
,
8944 const struct symtab_and_line
*sal
)
8946 struct bp_location
*loc
, **tmp
;
8947 CORE_ADDR adjusted_address
;
8948 struct gdbarch
*loc_gdbarch
= get_sal_arch (*sal
);
8950 if (loc_gdbarch
== NULL
)
8951 loc_gdbarch
= b
->gdbarch
;
8953 /* Adjust the breakpoint's address prior to allocating a location.
8954 Once we call allocate_bp_location(), that mostly uninitialized
8955 location will be placed on the location chain. Adjustment of the
8956 breakpoint may cause target_read_memory() to be called and we do
8957 not want its scan of the location chain to find a breakpoint and
8958 location that's only been partially initialized. */
8959 adjusted_address
= adjust_breakpoint_address (loc_gdbarch
,
8962 /* Sort the locations by their ADDRESS. */
8963 loc
= allocate_bp_location (b
);
8964 for (tmp
= &(b
->loc
); *tmp
!= NULL
&& (*tmp
)->address
<= adjusted_address
;
8965 tmp
= &((*tmp
)->next
))
8970 loc
->requested_address
= sal
->pc
;
8971 loc
->address
= adjusted_address
;
8972 loc
->pspace
= sal
->pspace
;
8973 loc
->probe
.probe
= sal
->probe
;
8974 loc
->probe
.objfile
= sal
->objfile
;
8975 gdb_assert (loc
->pspace
!= NULL
);
8976 loc
->section
= sal
->section
;
8977 loc
->gdbarch
= loc_gdbarch
;
8978 loc
->line_number
= sal
->line
;
8979 loc
->symtab
= sal
->symtab
;
8981 set_breakpoint_location_function (loc
,
8982 sal
->explicit_pc
|| sal
->explicit_line
);
8984 /* While by definition, permanent breakpoints are already present in the
8985 code, we don't mark the location as inserted. Normally one would expect
8986 that GDB could rely on that breakpoint instruction to stop the program,
8987 thus removing the need to insert its own breakpoint, except that executing
8988 the breakpoint instruction can kill the target instead of reporting a
8989 SIGTRAP. E.g., on SPARC, when interrupts are disabled, executing the
8990 instruction resets the CPU, so QEMU 2.0.0 for SPARC correspondingly dies
8991 with "Trap 0x02 while interrupts disabled, Error state". Letting the
8992 breakpoint be inserted normally results in QEMU knowing about the GDB
8993 breakpoint, and thus trap before the breakpoint instruction is executed.
8994 (If GDB later needs to continue execution past the permanent breakpoint,
8995 it manually increments the PC, thus avoiding executing the breakpoint
8997 if (bp_loc_is_permanent (loc
))
9004 /* See breakpoint.h. */
9007 program_breakpoint_here_p (struct gdbarch
*gdbarch
, CORE_ADDR address
)
9011 const gdb_byte
*bpoint
;
9012 gdb_byte
*target_mem
;
9013 struct cleanup
*cleanup
;
9017 bpoint
= gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &len
);
9019 /* Software breakpoints unsupported? */
9023 target_mem
= (gdb_byte
*) alloca (len
);
9025 /* Enable the automatic memory restoration from breakpoints while
9026 we read the memory. Otherwise we could say about our temporary
9027 breakpoints they are permanent. */
9028 cleanup
= make_show_memory_breakpoints_cleanup (0);
9030 if (target_read_memory (address
, target_mem
, len
) == 0
9031 && memcmp (target_mem
, bpoint
, len
) == 0)
9034 do_cleanups (cleanup
);
9039 /* Return 1 if LOC is pointing to a permanent breakpoint,
9040 return 0 otherwise. */
9043 bp_loc_is_permanent (struct bp_location
*loc
)
9045 gdb_assert (loc
!= NULL
);
9047 /* If we have a catchpoint or a watchpoint, just return 0. We should not
9048 attempt to read from the addresses the locations of these breakpoint types
9049 point to. program_breakpoint_here_p, below, will attempt to read
9051 if (!breakpoint_address_is_meaningful (loc
->owner
))
9054 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
9055 switch_to_program_space_and_thread (loc
->pspace
);
9056 return program_breakpoint_here_p (loc
->gdbarch
, loc
->address
);
9059 /* Build a command list for the dprintf corresponding to the current
9060 settings of the dprintf style options. */
9063 update_dprintf_command_list (struct breakpoint
*b
)
9065 char *dprintf_args
= b
->extra_string
;
9066 char *printf_line
= NULL
;
9071 dprintf_args
= skip_spaces (dprintf_args
);
9073 /* Allow a comma, as it may have terminated a location, but don't
9075 if (*dprintf_args
== ',')
9077 dprintf_args
= skip_spaces (dprintf_args
);
9079 if (*dprintf_args
!= '"')
9080 error (_("Bad format string, missing '\"'."));
9082 if (strcmp (dprintf_style
, dprintf_style_gdb
) == 0)
9083 printf_line
= xstrprintf ("printf %s", dprintf_args
);
9084 else if (strcmp (dprintf_style
, dprintf_style_call
) == 0)
9086 if (!dprintf_function
)
9087 error (_("No function supplied for dprintf call"));
9089 if (dprintf_channel
&& strlen (dprintf_channel
) > 0)
9090 printf_line
= xstrprintf ("call (void) %s (%s,%s)",
9095 printf_line
= xstrprintf ("call (void) %s (%s)",
9099 else if (strcmp (dprintf_style
, dprintf_style_agent
) == 0)
9101 if (target_can_run_breakpoint_commands ())
9102 printf_line
= xstrprintf ("agent-printf %s", dprintf_args
);
9105 warning (_("Target cannot run dprintf commands, falling back to GDB printf"));
9106 printf_line
= xstrprintf ("printf %s", dprintf_args
);
9110 internal_error (__FILE__
, __LINE__
,
9111 _("Invalid dprintf style."));
9113 gdb_assert (printf_line
!= NULL
);
9114 /* Manufacture a printf sequence. */
9116 struct command_line
*printf_cmd_line
= XNEW (struct command_line
);
9118 printf_cmd_line
->control_type
= simple_control
;
9119 printf_cmd_line
->body_count
= 0;
9120 printf_cmd_line
->body_list
= NULL
;
9121 printf_cmd_line
->next
= NULL
;
9122 printf_cmd_line
->line
= printf_line
;
9124 breakpoint_set_commands (b
, command_line_up (printf_cmd_line
));
9128 /* Update all dprintf commands, making their command lists reflect
9129 current style settings. */
9132 update_dprintf_commands (char *args
, int from_tty
,
9133 struct cmd_list_element
*c
)
9135 struct breakpoint
*b
;
9139 if (b
->type
== bp_dprintf
)
9140 update_dprintf_command_list (b
);
9144 /* Create a breakpoint with SAL as location. Use LOCATION
9145 as a description of the location, and COND_STRING
9146 as condition expression. If LOCATION is NULL then create an
9147 "address location" from the address in the SAL. */
9150 init_breakpoint_sal (struct breakpoint
*b
, struct gdbarch
*gdbarch
,
9151 struct symtabs_and_lines sals
,
9152 event_location_up
&&location
,
9153 gdb::unique_xmalloc_ptr
<char> filter
,
9154 gdb::unique_xmalloc_ptr
<char> cond_string
,
9155 gdb::unique_xmalloc_ptr
<char> extra_string
,
9156 enum bptype type
, enum bpdisp disposition
,
9157 int thread
, int task
, int ignore_count
,
9158 const struct breakpoint_ops
*ops
, int from_tty
,
9159 int enabled
, int internal
, unsigned flags
,
9160 int display_canonical
)
9164 if (type
== bp_hardware_breakpoint
)
9166 int target_resources_ok
;
9168 i
= hw_breakpoint_used_count ();
9169 target_resources_ok
=
9170 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
9172 if (target_resources_ok
== 0)
9173 error (_("No hardware breakpoint support in the target."));
9174 else if (target_resources_ok
< 0)
9175 error (_("Hardware breakpoints used exceeds limit."));
9178 gdb_assert (sals
.nelts
> 0);
9180 for (i
= 0; i
< sals
.nelts
; ++i
)
9182 struct symtab_and_line sal
= sals
.sals
[i
];
9183 struct bp_location
*loc
;
9187 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
9189 loc_gdbarch
= gdbarch
;
9191 describe_other_breakpoints (loc_gdbarch
,
9192 sal
.pspace
, sal
.pc
, sal
.section
, thread
);
9197 init_raw_breakpoint (b
, gdbarch
, sal
, type
, ops
);
9201 b
->cond_string
= cond_string
.release ();
9202 b
->extra_string
= extra_string
.release ();
9203 b
->ignore_count
= ignore_count
;
9204 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
9205 b
->disposition
= disposition
;
9207 if ((flags
& CREATE_BREAKPOINT_FLAGS_INSERTED
) != 0)
9208 b
->loc
->inserted
= 1;
9210 if (type
== bp_static_tracepoint
)
9212 struct tracepoint
*t
= (struct tracepoint
*) b
;
9213 struct static_tracepoint_marker marker
;
9215 if (strace_marker_p (b
))
9217 /* We already know the marker exists, otherwise, we
9218 wouldn't see a sal for it. */
9220 = &event_location_to_string (b
->location
.get ())[3];
9224 p
= skip_spaces_const (p
);
9226 endp
= skip_to_space_const (p
);
9228 marker_str
= savestring (p
, endp
- p
);
9229 t
->static_trace_marker_id
= marker_str
;
9231 printf_filtered (_("Probed static tracepoint "
9233 t
->static_trace_marker_id
);
9235 else if (target_static_tracepoint_marker_at (sal
.pc
, &marker
))
9237 t
->static_trace_marker_id
= xstrdup (marker
.str_id
);
9238 release_static_tracepoint_marker (&marker
);
9240 printf_filtered (_("Probed static tracepoint "
9242 t
->static_trace_marker_id
);
9245 warning (_("Couldn't determine the static "
9246 "tracepoint marker to probe"));
9253 loc
= add_location_to_breakpoint (b
, &sal
);
9254 if ((flags
& CREATE_BREAKPOINT_FLAGS_INSERTED
) != 0)
9260 const char *arg
= b
->cond_string
;
9262 loc
->cond
= parse_exp_1 (&arg
, loc
->address
,
9263 block_for_pc (loc
->address
), 0);
9265 error (_("Garbage '%s' follows condition"), arg
);
9268 /* Dynamic printf requires and uses additional arguments on the
9269 command line, otherwise it's an error. */
9270 if (type
== bp_dprintf
)
9272 if (b
->extra_string
)
9273 update_dprintf_command_list (b
);
9275 error (_("Format string required"));
9277 else if (b
->extra_string
)
9278 error (_("Garbage '%s' at end of command"), b
->extra_string
);
9281 b
->display_canonical
= display_canonical
;
9282 if (location
!= NULL
)
9283 b
->location
= std::move (location
);
9285 b
->location
= new_address_location (b
->loc
->address
, NULL
, 0);
9286 b
->filter
= filter
.release ();
9290 create_breakpoint_sal (struct gdbarch
*gdbarch
,
9291 struct symtabs_and_lines sals
,
9292 event_location_up
&&location
,
9293 gdb::unique_xmalloc_ptr
<char> filter
,
9294 gdb::unique_xmalloc_ptr
<char> cond_string
,
9295 gdb::unique_xmalloc_ptr
<char> extra_string
,
9296 enum bptype type
, enum bpdisp disposition
,
9297 int thread
, int task
, int ignore_count
,
9298 const struct breakpoint_ops
*ops
, int from_tty
,
9299 int enabled
, int internal
, unsigned flags
,
9300 int display_canonical
)
9302 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (type
);
9304 init_breakpoint_sal (b
.get (), gdbarch
,
9305 sals
, std::move (location
),
9307 std::move (cond_string
),
9308 std::move (extra_string
),
9310 thread
, task
, ignore_count
,
9312 enabled
, internal
, flags
,
9315 install_breakpoint (internal
, b
.release (), 0);
9318 /* Add SALS.nelts breakpoints to the breakpoint table. For each
9319 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
9320 value. COND_STRING, if not NULL, specified the condition to be
9321 used for all breakpoints. Essentially the only case where
9322 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
9323 function. In that case, it's still not possible to specify
9324 separate conditions for different overloaded functions, so
9325 we take just a single condition string.
9327 NOTE: If the function succeeds, the caller is expected to cleanup
9328 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
9329 array contents). If the function fails (error() is called), the
9330 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
9331 COND and SALS arrays and each of those arrays contents. */
9334 create_breakpoints_sal (struct gdbarch
*gdbarch
,
9335 struct linespec_result
*canonical
,
9336 gdb::unique_xmalloc_ptr
<char> cond_string
,
9337 gdb::unique_xmalloc_ptr
<char> extra_string
,
9338 enum bptype type
, enum bpdisp disposition
,
9339 int thread
, int task
, int ignore_count
,
9340 const struct breakpoint_ops
*ops
, int from_tty
,
9341 int enabled
, int internal
, unsigned flags
)
9344 struct linespec_sals
*lsal
;
9346 if (canonical
->pre_expanded
)
9347 gdb_assert (VEC_length (linespec_sals
, canonical
->sals
) == 1);
9349 for (i
= 0; VEC_iterate (linespec_sals
, canonical
->sals
, i
, lsal
); ++i
)
9351 /* Note that 'location' can be NULL in the case of a plain
9352 'break', without arguments. */
9353 event_location_up location
9354 = (canonical
->location
!= NULL
9355 ? copy_event_location (canonical
->location
.get ()) : NULL
);
9356 gdb::unique_xmalloc_ptr
<char> filter_string
9357 (lsal
->canonical
!= NULL
? xstrdup (lsal
->canonical
) : NULL
);
9359 create_breakpoint_sal (gdbarch
, lsal
->sals
,
9360 std::move (location
),
9361 std::move (filter_string
),
9362 std::move (cond_string
),
9363 std::move (extra_string
),
9365 thread
, task
, ignore_count
, ops
,
9366 from_tty
, enabled
, internal
, flags
,
9367 canonical
->special_display
);
9371 /* Parse LOCATION which is assumed to be a SAL specification possibly
9372 followed by conditionals. On return, SALS contains an array of SAL
9373 addresses found. LOCATION points to the end of the SAL (for
9374 linespec locations).
9376 The array and the line spec strings are allocated on the heap, it is
9377 the caller's responsibility to free them. */
9380 parse_breakpoint_sals (const struct event_location
*location
,
9381 struct linespec_result
*canonical
)
9383 struct symtab_and_line cursal
;
9385 if (event_location_type (location
) == LINESPEC_LOCATION
)
9387 const char *address
= get_linespec_location (location
);
9389 if (address
== NULL
)
9391 /* The last displayed codepoint, if it's valid, is our default
9392 breakpoint address. */
9393 if (last_displayed_sal_is_valid ())
9395 struct linespec_sals lsal
;
9396 struct symtab_and_line sal
;
9399 init_sal (&sal
); /* Initialize to zeroes. */
9400 lsal
.sals
.sals
= XNEW (struct symtab_and_line
);
9402 /* Set sal's pspace, pc, symtab, and line to the values
9403 corresponding to the last call to print_frame_info.
9404 Be sure to reinitialize LINE with NOTCURRENT == 0
9405 as the breakpoint line number is inappropriate otherwise.
9406 find_pc_line would adjust PC, re-set it back. */
9407 get_last_displayed_sal (&sal
);
9409 sal
= find_pc_line (pc
, 0);
9411 /* "break" without arguments is equivalent to "break *PC"
9412 where PC is the last displayed codepoint's address. So
9413 make sure to set sal.explicit_pc to prevent GDB from
9414 trying to expand the list of sals to include all other
9415 instances with the same symtab and line. */
9417 sal
.explicit_pc
= 1;
9419 lsal
.sals
.sals
[0] = sal
;
9420 lsal
.sals
.nelts
= 1;
9421 lsal
.canonical
= NULL
;
9423 VEC_safe_push (linespec_sals
, canonical
->sals
, &lsal
);
9427 error (_("No default breakpoint address now."));
9431 /* Force almost all breakpoints to be in terms of the
9432 current_source_symtab (which is decode_line_1's default).
9433 This should produce the results we want almost all of the
9434 time while leaving default_breakpoint_* alone.
9436 ObjC: However, don't match an Objective-C method name which
9437 may have a '+' or '-' succeeded by a '['. */
9438 cursal
= get_current_source_symtab_and_line ();
9439 if (last_displayed_sal_is_valid ())
9441 const char *address
= NULL
;
9443 if (event_location_type (location
) == LINESPEC_LOCATION
)
9444 address
= get_linespec_location (location
);
9448 && strchr ("+-", address
[0]) != NULL
9449 && address
[1] != '['))
9451 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, NULL
,
9452 get_last_displayed_symtab (),
9453 get_last_displayed_line (),
9454 canonical
, NULL
, NULL
);
9459 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, NULL
,
9460 cursal
.symtab
, cursal
.line
, canonical
, NULL
, NULL
);
9464 /* Convert each SAL into a real PC. Verify that the PC can be
9465 inserted as a breakpoint. If it can't throw an error. */
9468 breakpoint_sals_to_pc (struct symtabs_and_lines
*sals
)
9472 for (i
= 0; i
< sals
->nelts
; i
++)
9473 resolve_sal_pc (&sals
->sals
[i
]);
9476 /* Fast tracepoints may have restrictions on valid locations. For
9477 instance, a fast tracepoint using a jump instead of a trap will
9478 likely have to overwrite more bytes than a trap would, and so can
9479 only be placed where the instruction is longer than the jump, or a
9480 multi-instruction sequence does not have a jump into the middle of
9484 check_fast_tracepoint_sals (struct gdbarch
*gdbarch
,
9485 struct symtabs_and_lines
*sals
)
9488 struct symtab_and_line
*sal
;
9490 struct cleanup
*old_chain
;
9492 for (i
= 0; i
< sals
->nelts
; i
++)
9494 struct gdbarch
*sarch
;
9496 sal
= &sals
->sals
[i
];
9498 sarch
= get_sal_arch (*sal
);
9499 /* We fall back to GDBARCH if there is no architecture
9500 associated with SAL. */
9503 rslt
= gdbarch_fast_tracepoint_valid_at (sarch
, sal
->pc
, &msg
);
9504 old_chain
= make_cleanup (xfree
, msg
);
9507 error (_("May not have a fast tracepoint at %s%s"),
9508 paddress (sarch
, sal
->pc
), (msg
? msg
: ""));
9510 do_cleanups (old_chain
);
9514 /* Given TOK, a string specification of condition and thread, as
9515 accepted by the 'break' command, extract the condition
9516 string and thread number and set *COND_STRING and *THREAD.
9517 PC identifies the context at which the condition should be parsed.
9518 If no condition is found, *COND_STRING is set to NULL.
9519 If no thread is found, *THREAD is set to -1. */
9522 find_condition_and_thread (const char *tok
, CORE_ADDR pc
,
9523 char **cond_string
, int *thread
, int *task
,
9526 *cond_string
= NULL
;
9533 const char *end_tok
;
9535 const char *cond_start
= NULL
;
9536 const char *cond_end
= NULL
;
9538 tok
= skip_spaces_const (tok
);
9540 if ((*tok
== '"' || *tok
== ',') && rest
)
9542 *rest
= savestring (tok
, strlen (tok
));
9546 end_tok
= skip_to_space_const (tok
);
9548 toklen
= end_tok
- tok
;
9550 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
9552 tok
= cond_start
= end_tok
+ 1;
9553 parse_exp_1 (&tok
, pc
, block_for_pc (pc
), 0);
9555 *cond_string
= savestring (cond_start
, cond_end
- cond_start
);
9557 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
9560 struct thread_info
*thr
;
9563 thr
= parse_thread_id (tok
, &tmptok
);
9565 error (_("Junk after thread keyword."));
9566 *thread
= thr
->global_num
;
9569 else if (toklen
>= 1 && strncmp (tok
, "task", toklen
) == 0)
9574 *task
= strtol (tok
, &tmptok
, 0);
9576 error (_("Junk after task keyword."));
9577 if (!valid_task_id (*task
))
9578 error (_("Unknown task %d."), *task
);
9583 *rest
= savestring (tok
, strlen (tok
));
9587 error (_("Junk at end of arguments."));
9591 /* Decode a static tracepoint marker spec. */
9593 static struct symtabs_and_lines
9594 decode_static_tracepoint_spec (const char **arg_p
)
9596 VEC(static_tracepoint_marker_p
) *markers
= NULL
;
9597 struct symtabs_and_lines sals
;
9598 struct cleanup
*old_chain
;
9599 const char *p
= &(*arg_p
)[3];
9604 p
= skip_spaces_const (p
);
9606 endp
= skip_to_space_const (p
);
9608 marker_str
= savestring (p
, endp
- p
);
9609 old_chain
= make_cleanup (xfree
, marker_str
);
9611 markers
= target_static_tracepoint_markers_by_strid (marker_str
);
9612 if (VEC_empty(static_tracepoint_marker_p
, markers
))
9613 error (_("No known static tracepoint marker named %s"), marker_str
);
9615 sals
.nelts
= VEC_length(static_tracepoint_marker_p
, markers
);
9616 sals
.sals
= XNEWVEC (struct symtab_and_line
, sals
.nelts
);
9618 for (i
= 0; i
< sals
.nelts
; i
++)
9620 struct static_tracepoint_marker
*marker
;
9622 marker
= VEC_index (static_tracepoint_marker_p
, markers
, i
);
9624 init_sal (&sals
.sals
[i
]);
9626 sals
.sals
[i
] = find_pc_line (marker
->address
, 0);
9627 sals
.sals
[i
].pc
= marker
->address
;
9629 release_static_tracepoint_marker (marker
);
9632 do_cleanups (old_chain
);
9638 /* See breakpoint.h. */
9641 create_breakpoint (struct gdbarch
*gdbarch
,
9642 const struct event_location
*location
,
9643 const char *cond_string
,
9644 int thread
, const char *extra_string
,
9646 int tempflag
, enum bptype type_wanted
,
9648 enum auto_boolean pending_break_support
,
9649 const struct breakpoint_ops
*ops
,
9650 int from_tty
, int enabled
, int internal
,
9653 struct linespec_result canonical
;
9654 struct cleanup
*bkpt_chain
= NULL
;
9657 int prev_bkpt_count
= breakpoint_count
;
9659 gdb_assert (ops
!= NULL
);
9661 /* If extra_string isn't useful, set it to NULL. */
9662 if (extra_string
!= NULL
&& *extra_string
== '\0')
9663 extra_string
= NULL
;
9667 ops
->create_sals_from_location (location
, &canonical
, type_wanted
);
9669 CATCH (e
, RETURN_MASK_ERROR
)
9671 /* If caller is interested in rc value from parse, set
9673 if (e
.error
== NOT_FOUND_ERROR
)
9675 /* If pending breakpoint support is turned off, throw
9678 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
9679 throw_exception (e
);
9681 exception_print (gdb_stderr
, e
);
9683 /* If pending breakpoint support is auto query and the user
9684 selects no, then simply return the error code. */
9685 if (pending_break_support
== AUTO_BOOLEAN_AUTO
9686 && !nquery (_("Make %s pending on future shared library load? "),
9687 bptype_string (type_wanted
)))
9690 /* At this point, either the user was queried about setting
9691 a pending breakpoint and selected yes, or pending
9692 breakpoint behavior is on and thus a pending breakpoint
9693 is defaulted on behalf of the user. */
9697 throw_exception (e
);
9701 if (!pending
&& VEC_empty (linespec_sals
, canonical
.sals
))
9704 /* ----------------------------- SNIP -----------------------------
9705 Anything added to the cleanup chain beyond this point is assumed
9706 to be part of a breakpoint. If the breakpoint create succeeds
9707 then the memory is not reclaimed. */
9708 bkpt_chain
= make_cleanup (null_cleanup
, 0);
9710 /* Resolve all line numbers to PC's and verify that the addresses
9711 are ok for the target. */
9715 struct linespec_sals
*iter
;
9717 for (ix
= 0; VEC_iterate (linespec_sals
, canonical
.sals
, ix
, iter
); ++ix
)
9718 breakpoint_sals_to_pc (&iter
->sals
);
9721 /* Fast tracepoints may have additional restrictions on location. */
9722 if (!pending
&& type_wanted
== bp_fast_tracepoint
)
9725 struct linespec_sals
*iter
;
9727 for (ix
= 0; VEC_iterate (linespec_sals
, canonical
.sals
, ix
, iter
); ++ix
)
9728 check_fast_tracepoint_sals (gdbarch
, &iter
->sals
);
9731 /* Verify that condition can be parsed, before setting any
9732 breakpoints. Allocate a separate condition expression for each
9736 gdb::unique_xmalloc_ptr
<char> cond_string_copy
;
9737 gdb::unique_xmalloc_ptr
<char> extra_string_copy
;
9743 struct linespec_sals
*lsal
;
9745 lsal
= VEC_index (linespec_sals
, canonical
.sals
, 0);
9747 /* Here we only parse 'arg' to separate condition
9748 from thread number, so parsing in context of first
9749 sal is OK. When setting the breakpoint we'll
9750 re-parse it in context of each sal. */
9752 find_condition_and_thread (extra_string
, lsal
->sals
.sals
[0].pc
,
9753 &cond
, &thread
, &task
, &rest
);
9754 cond_string_copy
.reset (cond
);
9755 extra_string_copy
.reset (rest
);
9759 if (type_wanted
!= bp_dprintf
9760 && extra_string
!= NULL
&& *extra_string
!= '\0')
9761 error (_("Garbage '%s' at end of location"), extra_string
);
9763 /* Create a private copy of condition string. */
9765 cond_string_copy
.reset (xstrdup (cond_string
));
9766 /* Create a private copy of any extra string. */
9768 extra_string_copy
.reset (xstrdup (extra_string
));
9771 ops
->create_breakpoints_sal (gdbarch
, &canonical
,
9772 std::move (cond_string_copy
),
9773 std::move (extra_string_copy
),
9775 tempflag
? disp_del
: disp_donttouch
,
9776 thread
, task
, ignore_count
, ops
,
9777 from_tty
, enabled
, internal
, flags
);
9781 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (type_wanted
);
9783 init_raw_breakpoint_without_location (b
.get (), gdbarch
, type_wanted
, ops
);
9784 b
->location
= copy_event_location (location
);
9787 b
->cond_string
= NULL
;
9790 /* Create a private copy of condition string. */
9791 b
->cond_string
= cond_string
!= NULL
? xstrdup (cond_string
) : NULL
;
9795 /* Create a private copy of any extra string. */
9796 b
->extra_string
= extra_string
!= NULL
? xstrdup (extra_string
) : NULL
;
9797 b
->ignore_count
= ignore_count
;
9798 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
9799 b
->condition_not_parsed
= 1;
9800 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
9801 if ((type_wanted
!= bp_breakpoint
9802 && type_wanted
!= bp_hardware_breakpoint
) || thread
!= -1)
9803 b
->pspace
= current_program_space
;
9805 install_breakpoint (internal
, b
.release (), 0);
9808 if (VEC_length (linespec_sals
, canonical
.sals
) > 1)
9810 warning (_("Multiple breakpoints were set.\nUse the "
9811 "\"delete\" command to delete unwanted breakpoints."));
9812 prev_breakpoint_count
= prev_bkpt_count
;
9815 /* That's it. Discard the cleanups for data inserted into the
9817 discard_cleanups (bkpt_chain
);
9819 /* error call may happen here - have BKPT_CHAIN already discarded. */
9820 update_global_location_list (UGLL_MAY_INSERT
);
9825 /* Set a breakpoint.
9826 ARG is a string describing breakpoint address,
9827 condition, and thread.
9828 FLAG specifies if a breakpoint is hardware on,
9829 and if breakpoint is temporary, using BP_HARDWARE_FLAG
9833 break_command_1 (char *arg
, int flag
, int from_tty
)
9835 int tempflag
= flag
& BP_TEMPFLAG
;
9836 enum bptype type_wanted
= (flag
& BP_HARDWAREFLAG
9837 ? bp_hardware_breakpoint
9839 struct breakpoint_ops
*ops
;
9841 event_location_up location
= string_to_event_location (&arg
, current_language
);
9843 /* Matching breakpoints on probes. */
9844 if (location
!= NULL
9845 && event_location_type (location
.get ()) == PROBE_LOCATION
)
9846 ops
= &bkpt_probe_breakpoint_ops
;
9848 ops
= &bkpt_breakpoint_ops
;
9850 create_breakpoint (get_current_arch (),
9852 NULL
, 0, arg
, 1 /* parse arg */,
9853 tempflag
, type_wanted
,
9854 0 /* Ignore count */,
9855 pending_break_support
,
9863 /* Helper function for break_command_1 and disassemble_command. */
9866 resolve_sal_pc (struct symtab_and_line
*sal
)
9870 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
9872 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
9873 error (_("No line %d in file \"%s\"."),
9874 sal
->line
, symtab_to_filename_for_display (sal
->symtab
));
9877 /* If this SAL corresponds to a breakpoint inserted using a line
9878 number, then skip the function prologue if necessary. */
9879 if (sal
->explicit_line
)
9880 skip_prologue_sal (sal
);
9883 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
9885 const struct blockvector
*bv
;
9886 const struct block
*b
;
9889 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
,
9890 SYMTAB_COMPUNIT (sal
->symtab
));
9893 sym
= block_linkage_function (b
);
9896 fixup_symbol_section (sym
, SYMTAB_OBJFILE (sal
->symtab
));
9897 sal
->section
= SYMBOL_OBJ_SECTION (SYMTAB_OBJFILE (sal
->symtab
),
9902 /* It really is worthwhile to have the section, so we'll
9903 just have to look harder. This case can be executed
9904 if we have line numbers but no functions (as can
9905 happen in assembly source). */
9907 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
9908 switch_to_program_space_and_thread (sal
->pspace
);
9910 bound_minimal_symbol msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
9912 sal
->section
= MSYMBOL_OBJ_SECTION (msym
.objfile
, msym
.minsym
);
9919 break_command (char *arg
, int from_tty
)
9921 break_command_1 (arg
, 0, from_tty
);
9925 tbreak_command (char *arg
, int from_tty
)
9927 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
9931 hbreak_command (char *arg
, int from_tty
)
9933 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
9937 thbreak_command (char *arg
, int from_tty
)
9939 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
9943 stop_command (char *arg
, int from_tty
)
9945 printf_filtered (_("Specify the type of breakpoint to set.\n\
9946 Usage: stop in <function | address>\n\
9947 stop at <line>\n"));
9951 stopin_command (char *arg
, int from_tty
)
9955 if (arg
== (char *) NULL
)
9957 else if (*arg
!= '*')
9962 /* Look for a ':'. If this is a line number specification, then
9963 say it is bad, otherwise, it should be an address or
9964 function/method name. */
9965 while (*argptr
&& !hasColon
)
9967 hasColon
= (*argptr
== ':');
9972 badInput
= (*argptr
!= ':'); /* Not a class::method */
9974 badInput
= isdigit (*arg
); /* a simple line number */
9978 printf_filtered (_("Usage: stop in <function | address>\n"));
9980 break_command_1 (arg
, 0, from_tty
);
9984 stopat_command (char *arg
, int from_tty
)
9988 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
9995 /* Look for a ':'. If there is a '::' then get out, otherwise
9996 it is probably a line number. */
9997 while (*argptr
&& !hasColon
)
9999 hasColon
= (*argptr
== ':');
10004 badInput
= (*argptr
== ':'); /* we have class::method */
10006 badInput
= !isdigit (*arg
); /* not a line number */
10010 printf_filtered (_("Usage: stop at <line>\n"));
10012 break_command_1 (arg
, 0, from_tty
);
10015 /* The dynamic printf command is mostly like a regular breakpoint, but
10016 with a prewired command list consisting of a single output command,
10017 built from extra arguments supplied on the dprintf command
10021 dprintf_command (char *arg
, int from_tty
)
10023 event_location_up location
= string_to_event_location (&arg
, current_language
);
10025 /* If non-NULL, ARG should have been advanced past the location;
10026 the next character must be ','. */
10029 if (arg
[0] != ',' || arg
[1] == '\0')
10030 error (_("Format string required"));
10033 /* Skip the comma. */
10038 create_breakpoint (get_current_arch (),
10040 NULL
, 0, arg
, 1 /* parse arg */,
10042 0 /* Ignore count */,
10043 pending_break_support
,
10044 &dprintf_breakpoint_ops
,
10052 agent_printf_command (char *arg
, int from_tty
)
10054 error (_("May only run agent-printf on the target"));
10057 /* Implement the "breakpoint_hit" breakpoint_ops method for
10058 ranged breakpoints. */
10061 breakpoint_hit_ranged_breakpoint (const struct bp_location
*bl
,
10062 struct address_space
*aspace
,
10064 const struct target_waitstatus
*ws
)
10066 if (ws
->kind
!= TARGET_WAITKIND_STOPPED
10067 || ws
->value
.sig
!= GDB_SIGNAL_TRAP
)
10070 return breakpoint_address_match_range (bl
->pspace
->aspace
, bl
->address
,
10071 bl
->length
, aspace
, bp_addr
);
10074 /* Implement the "resources_needed" breakpoint_ops method for
10075 ranged breakpoints. */
10078 resources_needed_ranged_breakpoint (const struct bp_location
*bl
)
10080 return target_ranged_break_num_registers ();
10083 /* Implement the "print_it" breakpoint_ops method for
10084 ranged breakpoints. */
10086 static enum print_stop_action
10087 print_it_ranged_breakpoint (bpstat bs
)
10089 struct breakpoint
*b
= bs
->breakpoint_at
;
10090 struct bp_location
*bl
= b
->loc
;
10091 struct ui_out
*uiout
= current_uiout
;
10093 gdb_assert (b
->type
== bp_hardware_breakpoint
);
10095 /* Ranged breakpoints have only one location. */
10096 gdb_assert (bl
&& bl
->next
== NULL
);
10098 annotate_breakpoint (b
->number
);
10100 maybe_print_thread_hit_breakpoint (uiout
);
10102 if (b
->disposition
== disp_del
)
10103 uiout
->text ("Temporary ranged breakpoint ");
10105 uiout
->text ("Ranged breakpoint ");
10106 if (uiout
->is_mi_like_p ())
10108 uiout
->field_string ("reason",
10109 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
10110 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
10112 uiout
->field_int ("bkptno", b
->number
);
10113 uiout
->text (", ");
10115 return PRINT_SRC_AND_LOC
;
10118 /* Implement the "print_one" breakpoint_ops method for
10119 ranged breakpoints. */
10122 print_one_ranged_breakpoint (struct breakpoint
*b
,
10123 struct bp_location
**last_loc
)
10125 struct bp_location
*bl
= b
->loc
;
10126 struct value_print_options opts
;
10127 struct ui_out
*uiout
= current_uiout
;
10129 /* Ranged breakpoints have only one location. */
10130 gdb_assert (bl
&& bl
->next
== NULL
);
10132 get_user_print_options (&opts
);
10134 if (opts
.addressprint
)
10135 /* We don't print the address range here, it will be printed later
10136 by print_one_detail_ranged_breakpoint. */
10137 uiout
->field_skip ("addr");
10138 annotate_field (5);
10139 print_breakpoint_location (b
, bl
);
10143 /* Implement the "print_one_detail" breakpoint_ops method for
10144 ranged breakpoints. */
10147 print_one_detail_ranged_breakpoint (const struct breakpoint
*b
,
10148 struct ui_out
*uiout
)
10150 CORE_ADDR address_start
, address_end
;
10151 struct bp_location
*bl
= b
->loc
;
10156 address_start
= bl
->address
;
10157 address_end
= address_start
+ bl
->length
- 1;
10159 uiout
->text ("\taddress range: ");
10160 stb
.printf ("[%s, %s]",
10161 print_core_address (bl
->gdbarch
, address_start
),
10162 print_core_address (bl
->gdbarch
, address_end
));
10163 uiout
->field_stream ("addr", stb
);
10164 uiout
->text ("\n");
10167 /* Implement the "print_mention" breakpoint_ops method for
10168 ranged breakpoints. */
10171 print_mention_ranged_breakpoint (struct breakpoint
*b
)
10173 struct bp_location
*bl
= b
->loc
;
10174 struct ui_out
*uiout
= current_uiout
;
10177 gdb_assert (b
->type
== bp_hardware_breakpoint
);
10179 if (uiout
->is_mi_like_p ())
10182 printf_filtered (_("Hardware assisted ranged breakpoint %d from %s to %s."),
10183 b
->number
, paddress (bl
->gdbarch
, bl
->address
),
10184 paddress (bl
->gdbarch
, bl
->address
+ bl
->length
- 1));
10187 /* Implement the "print_recreate" breakpoint_ops method for
10188 ranged breakpoints. */
10191 print_recreate_ranged_breakpoint (struct breakpoint
*b
, struct ui_file
*fp
)
10193 fprintf_unfiltered (fp
, "break-range %s, %s",
10194 event_location_to_string (b
->location
.get ()),
10195 event_location_to_string (b
->location_range_end
.get ()));
10196 print_recreate_thread (b
, fp
);
10199 /* The breakpoint_ops structure to be used in ranged breakpoints. */
10201 static struct breakpoint_ops ranged_breakpoint_ops
;
10203 /* Find the address where the end of the breakpoint range should be
10204 placed, given the SAL of the end of the range. This is so that if
10205 the user provides a line number, the end of the range is set to the
10206 last instruction of the given line. */
10209 find_breakpoint_range_end (struct symtab_and_line sal
)
10213 /* If the user provided a PC value, use it. Otherwise,
10214 find the address of the end of the given location. */
10215 if (sal
.explicit_pc
)
10222 ret
= find_line_pc_range (sal
, &start
, &end
);
10224 error (_("Could not find location of the end of the range."));
10226 /* find_line_pc_range returns the start of the next line. */
10233 /* Implement the "break-range" CLI command. */
10236 break_range_command (char *arg
, int from_tty
)
10238 char *arg_start
, *addr_string_start
;
10239 struct linespec_result canonical_start
, canonical_end
;
10240 int bp_count
, can_use_bp
, length
;
10242 struct breakpoint
*b
;
10243 struct symtab_and_line sal_start
, sal_end
;
10244 struct cleanup
*cleanup_bkpt
;
10245 struct linespec_sals
*lsal_start
, *lsal_end
;
10247 /* We don't support software ranged breakpoints. */
10248 if (target_ranged_break_num_registers () < 0)
10249 error (_("This target does not support hardware ranged breakpoints."));
10251 bp_count
= hw_breakpoint_used_count ();
10252 bp_count
+= target_ranged_break_num_registers ();
10253 can_use_bp
= target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
10255 if (can_use_bp
< 0)
10256 error (_("Hardware breakpoints used exceeds limit."));
10258 arg
= skip_spaces (arg
);
10259 if (arg
== NULL
|| arg
[0] == '\0')
10260 error(_("No address range specified."));
10263 event_location_up start_location
= string_to_event_location (&arg
,
10265 parse_breakpoint_sals (start_location
.get (), &canonical_start
);
10268 error (_("Too few arguments."));
10269 else if (VEC_empty (linespec_sals
, canonical_start
.sals
))
10270 error (_("Could not find location of the beginning of the range."));
10272 lsal_start
= VEC_index (linespec_sals
, canonical_start
.sals
, 0);
10274 if (VEC_length (linespec_sals
, canonical_start
.sals
) > 1
10275 || lsal_start
->sals
.nelts
!= 1)
10276 error (_("Cannot create a ranged breakpoint with multiple locations."));
10278 sal_start
= lsal_start
->sals
.sals
[0];
10279 addr_string_start
= savestring (arg_start
, arg
- arg_start
);
10280 cleanup_bkpt
= make_cleanup (xfree
, addr_string_start
);
10282 arg
++; /* Skip the comma. */
10283 arg
= skip_spaces (arg
);
10285 /* Parse the end location. */
10289 /* We call decode_line_full directly here instead of using
10290 parse_breakpoint_sals because we need to specify the start location's
10291 symtab and line as the default symtab and line for the end of the
10292 range. This makes it possible to have ranges like "foo.c:27, +14",
10293 where +14 means 14 lines from the start location. */
10294 event_location_up end_location
= string_to_event_location (&arg
,
10296 decode_line_full (end_location
.get (), DECODE_LINE_FUNFIRSTLINE
, NULL
,
10297 sal_start
.symtab
, sal_start
.line
,
10298 &canonical_end
, NULL
, NULL
);
10300 if (VEC_empty (linespec_sals
, canonical_end
.sals
))
10301 error (_("Could not find location of the end of the range."));
10303 lsal_end
= VEC_index (linespec_sals
, canonical_end
.sals
, 0);
10304 if (VEC_length (linespec_sals
, canonical_end
.sals
) > 1
10305 || lsal_end
->sals
.nelts
!= 1)
10306 error (_("Cannot create a ranged breakpoint with multiple locations."));
10308 sal_end
= lsal_end
->sals
.sals
[0];
10310 end
= find_breakpoint_range_end (sal_end
);
10311 if (sal_start
.pc
> end
)
10312 error (_("Invalid address range, end precedes start."));
10314 length
= end
- sal_start
.pc
+ 1;
10316 /* Length overflowed. */
10317 error (_("Address range too large."));
10318 else if (length
== 1)
10320 /* This range is simple enough to be handled by
10321 the `hbreak' command. */
10322 hbreak_command (addr_string_start
, 1);
10324 do_cleanups (cleanup_bkpt
);
10329 /* Now set up the breakpoint. */
10330 b
= set_raw_breakpoint (get_current_arch (), sal_start
,
10331 bp_hardware_breakpoint
, &ranged_breakpoint_ops
);
10332 set_breakpoint_count (breakpoint_count
+ 1);
10333 b
->number
= breakpoint_count
;
10334 b
->disposition
= disp_donttouch
;
10335 b
->location
= std::move (start_location
);
10336 b
->location_range_end
= std::move (end_location
);
10337 b
->loc
->length
= length
;
10339 do_cleanups (cleanup_bkpt
);
10342 observer_notify_breakpoint_created (b
);
10343 update_global_location_list (UGLL_MAY_INSERT
);
10346 /* Return non-zero if EXP is verified as constant. Returned zero
10347 means EXP is variable. Also the constant detection may fail for
10348 some constant expressions and in such case still falsely return
10352 watchpoint_exp_is_const (const struct expression
*exp
)
10354 int i
= exp
->nelts
;
10360 /* We are only interested in the descriptor of each element. */
10361 operator_length (exp
, i
, &oplenp
, &argsp
);
10364 switch (exp
->elts
[i
].opcode
)
10374 case BINOP_LOGICAL_AND
:
10375 case BINOP_LOGICAL_OR
:
10376 case BINOP_BITWISE_AND
:
10377 case BINOP_BITWISE_IOR
:
10378 case BINOP_BITWISE_XOR
:
10380 case BINOP_NOTEQUAL
:
10407 case OP_OBJC_NSSTRING
:
10410 case UNOP_LOGICAL_NOT
:
10411 case UNOP_COMPLEMENT
:
10416 case UNOP_CAST_TYPE
:
10417 case UNOP_REINTERPRET_CAST
:
10418 case UNOP_DYNAMIC_CAST
:
10419 /* Unary, binary and ternary operators: We have to check
10420 their operands. If they are constant, then so is the
10421 result of that operation. For instance, if A and B are
10422 determined to be constants, then so is "A + B".
10424 UNOP_IND is one exception to the rule above, because the
10425 value of *ADDR is not necessarily a constant, even when
10430 /* Check whether the associated symbol is a constant.
10432 We use SYMBOL_CLASS rather than TYPE_CONST because it's
10433 possible that a buggy compiler could mark a variable as
10434 constant even when it is not, and TYPE_CONST would return
10435 true in this case, while SYMBOL_CLASS wouldn't.
10437 We also have to check for function symbols because they
10438 are always constant. */
10440 struct symbol
*s
= exp
->elts
[i
+ 2].symbol
;
10442 if (SYMBOL_CLASS (s
) != LOC_BLOCK
10443 && SYMBOL_CLASS (s
) != LOC_CONST
10444 && SYMBOL_CLASS (s
) != LOC_CONST_BYTES
)
10449 /* The default action is to return 0 because we are using
10450 the optimistic approach here: If we don't know something,
10451 then it is not a constant. */
10460 /* Watchpoint destructor. */
10462 watchpoint::~watchpoint ()
10464 xfree (this->exp_string
);
10465 xfree (this->exp_string_reparse
);
10466 value_free (this->val
);
10469 /* Implement the "re_set" breakpoint_ops method for watchpoints. */
10472 re_set_watchpoint (struct breakpoint
*b
)
10474 struct watchpoint
*w
= (struct watchpoint
*) b
;
10476 /* Watchpoint can be either on expression using entirely global
10477 variables, or it can be on local variables.
10479 Watchpoints of the first kind are never auto-deleted, and even
10480 persist across program restarts. Since they can use variables
10481 from shared libraries, we need to reparse expression as libraries
10482 are loaded and unloaded.
10484 Watchpoints on local variables can also change meaning as result
10485 of solib event. For example, if a watchpoint uses both a local
10486 and a global variables in expression, it's a local watchpoint,
10487 but unloading of a shared library will make the expression
10488 invalid. This is not a very common use case, but we still
10489 re-evaluate expression, to avoid surprises to the user.
10491 Note that for local watchpoints, we re-evaluate it only if
10492 watchpoints frame id is still valid. If it's not, it means the
10493 watchpoint is out of scope and will be deleted soon. In fact,
10494 I'm not sure we'll ever be called in this case.
10496 If a local watchpoint's frame id is still valid, then
10497 w->exp_valid_block is likewise valid, and we can safely use it.
10499 Don't do anything about disabled watchpoints, since they will be
10500 reevaluated again when enabled. */
10501 update_watchpoint (w
, 1 /* reparse */);
10504 /* Implement the "insert" breakpoint_ops method for hardware watchpoints. */
10507 insert_watchpoint (struct bp_location
*bl
)
10509 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10510 int length
= w
->exact
? 1 : bl
->length
;
10512 return target_insert_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
10513 w
->cond_exp
.get ());
10516 /* Implement the "remove" breakpoint_ops method for hardware watchpoints. */
10519 remove_watchpoint (struct bp_location
*bl
, enum remove_bp_reason reason
)
10521 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10522 int length
= w
->exact
? 1 : bl
->length
;
10524 return target_remove_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
10525 w
->cond_exp
.get ());
10529 breakpoint_hit_watchpoint (const struct bp_location
*bl
,
10530 struct address_space
*aspace
, CORE_ADDR bp_addr
,
10531 const struct target_waitstatus
*ws
)
10533 struct breakpoint
*b
= bl
->owner
;
10534 struct watchpoint
*w
= (struct watchpoint
*) b
;
10536 /* Continuable hardware watchpoints are treated as non-existent if the
10537 reason we stopped wasn't a hardware watchpoint (we didn't stop on
10538 some data address). Otherwise gdb won't stop on a break instruction
10539 in the code (not from a breakpoint) when a hardware watchpoint has
10540 been defined. Also skip watchpoints which we know did not trigger
10541 (did not match the data address). */
10542 if (is_hardware_watchpoint (b
)
10543 && w
->watchpoint_triggered
== watch_triggered_no
)
10550 check_status_watchpoint (bpstat bs
)
10552 gdb_assert (is_watchpoint (bs
->breakpoint_at
));
10554 bpstat_check_watchpoint (bs
);
10557 /* Implement the "resources_needed" breakpoint_ops method for
10558 hardware watchpoints. */
10561 resources_needed_watchpoint (const struct bp_location
*bl
)
10563 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10564 int length
= w
->exact
? 1 : bl
->length
;
10566 return target_region_ok_for_hw_watchpoint (bl
->address
, length
);
10569 /* Implement the "works_in_software_mode" breakpoint_ops method for
10570 hardware watchpoints. */
10573 works_in_software_mode_watchpoint (const struct breakpoint
*b
)
10575 /* Read and access watchpoints only work with hardware support. */
10576 return b
->type
== bp_watchpoint
|| b
->type
== bp_hardware_watchpoint
;
10579 static enum print_stop_action
10580 print_it_watchpoint (bpstat bs
)
10582 struct cleanup
*old_chain
;
10583 struct breakpoint
*b
;
10584 enum print_stop_action result
;
10585 struct watchpoint
*w
;
10586 struct ui_out
*uiout
= current_uiout
;
10588 gdb_assert (bs
->bp_location_at
!= NULL
);
10590 b
= bs
->breakpoint_at
;
10591 w
= (struct watchpoint
*) b
;
10593 old_chain
= make_cleanup (null_cleanup
, NULL
);
10595 annotate_watchpoint (b
->number
);
10596 maybe_print_thread_hit_breakpoint (uiout
);
10602 case bp_watchpoint
:
10603 case bp_hardware_watchpoint
:
10604 if (uiout
->is_mi_like_p ())
10605 uiout
->field_string
10606 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
10608 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
10609 uiout
->text ("\nOld value = ");
10610 watchpoint_value_print (bs
->old_val
, &stb
);
10611 uiout
->field_stream ("old", stb
);
10612 uiout
->text ("\nNew value = ");
10613 watchpoint_value_print (w
->val
, &stb
);
10614 uiout
->field_stream ("new", stb
);
10615 uiout
->text ("\n");
10616 /* More than one watchpoint may have been triggered. */
10617 result
= PRINT_UNKNOWN
;
10620 case bp_read_watchpoint
:
10621 if (uiout
->is_mi_like_p ())
10622 uiout
->field_string
10623 ("reason", async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
10625 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
10626 uiout
->text ("\nValue = ");
10627 watchpoint_value_print (w
->val
, &stb
);
10628 uiout
->field_stream ("value", stb
);
10629 uiout
->text ("\n");
10630 result
= PRINT_UNKNOWN
;
10633 case bp_access_watchpoint
:
10634 if (bs
->old_val
!= NULL
)
10636 if (uiout
->is_mi_like_p ())
10637 uiout
->field_string
10639 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
10641 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
10642 uiout
->text ("\nOld value = ");
10643 watchpoint_value_print (bs
->old_val
, &stb
);
10644 uiout
->field_stream ("old", stb
);
10645 uiout
->text ("\nNew value = ");
10650 if (uiout
->is_mi_like_p ())
10651 uiout
->field_string
10653 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
10654 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
10655 uiout
->text ("\nValue = ");
10657 watchpoint_value_print (w
->val
, &stb
);
10658 uiout
->field_stream ("new", stb
);
10659 uiout
->text ("\n");
10660 result
= PRINT_UNKNOWN
;
10663 result
= PRINT_UNKNOWN
;
10666 do_cleanups (old_chain
);
10670 /* Implement the "print_mention" breakpoint_ops method for hardware
10674 print_mention_watchpoint (struct breakpoint
*b
)
10676 struct watchpoint
*w
= (struct watchpoint
*) b
;
10677 struct ui_out
*uiout
= current_uiout
;
10678 const char *tuple_name
;
10682 case bp_watchpoint
:
10683 uiout
->text ("Watchpoint ");
10684 tuple_name
= "wpt";
10686 case bp_hardware_watchpoint
:
10687 uiout
->text ("Hardware watchpoint ");
10688 tuple_name
= "wpt";
10690 case bp_read_watchpoint
:
10691 uiout
->text ("Hardware read watchpoint ");
10692 tuple_name
= "hw-rwpt";
10694 case bp_access_watchpoint
:
10695 uiout
->text ("Hardware access (read/write) watchpoint ");
10696 tuple_name
= "hw-awpt";
10699 internal_error (__FILE__
, __LINE__
,
10700 _("Invalid hardware watchpoint type."));
10703 ui_out_emit_tuple
tuple_emitter (uiout
, tuple_name
);
10704 uiout
->field_int ("number", b
->number
);
10705 uiout
->text (": ");
10706 uiout
->field_string ("exp", w
->exp_string
);
10709 /* Implement the "print_recreate" breakpoint_ops method for
10713 print_recreate_watchpoint (struct breakpoint
*b
, struct ui_file
*fp
)
10715 struct watchpoint
*w
= (struct watchpoint
*) b
;
10719 case bp_watchpoint
:
10720 case bp_hardware_watchpoint
:
10721 fprintf_unfiltered (fp
, "watch");
10723 case bp_read_watchpoint
:
10724 fprintf_unfiltered (fp
, "rwatch");
10726 case bp_access_watchpoint
:
10727 fprintf_unfiltered (fp
, "awatch");
10730 internal_error (__FILE__
, __LINE__
,
10731 _("Invalid watchpoint type."));
10734 fprintf_unfiltered (fp
, " %s", w
->exp_string
);
10735 print_recreate_thread (b
, fp
);
10738 /* Implement the "explains_signal" breakpoint_ops method for
10742 explains_signal_watchpoint (struct breakpoint
*b
, enum gdb_signal sig
)
10744 /* A software watchpoint cannot cause a signal other than
10745 GDB_SIGNAL_TRAP. */
10746 if (b
->type
== bp_watchpoint
&& sig
!= GDB_SIGNAL_TRAP
)
10752 /* The breakpoint_ops structure to be used in hardware watchpoints. */
10754 static struct breakpoint_ops watchpoint_breakpoint_ops
;
10756 /* Implement the "insert" breakpoint_ops method for
10757 masked hardware watchpoints. */
10760 insert_masked_watchpoint (struct bp_location
*bl
)
10762 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10764 return target_insert_mask_watchpoint (bl
->address
, w
->hw_wp_mask
,
10765 bl
->watchpoint_type
);
10768 /* Implement the "remove" breakpoint_ops method for
10769 masked hardware watchpoints. */
10772 remove_masked_watchpoint (struct bp_location
*bl
, enum remove_bp_reason reason
)
10774 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10776 return target_remove_mask_watchpoint (bl
->address
, w
->hw_wp_mask
,
10777 bl
->watchpoint_type
);
10780 /* Implement the "resources_needed" breakpoint_ops method for
10781 masked hardware watchpoints. */
10784 resources_needed_masked_watchpoint (const struct bp_location
*bl
)
10786 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10788 return target_masked_watch_num_registers (bl
->address
, w
->hw_wp_mask
);
10791 /* Implement the "works_in_software_mode" breakpoint_ops method for
10792 masked hardware watchpoints. */
10795 works_in_software_mode_masked_watchpoint (const struct breakpoint
*b
)
10800 /* Implement the "print_it" breakpoint_ops method for
10801 masked hardware watchpoints. */
10803 static enum print_stop_action
10804 print_it_masked_watchpoint (bpstat bs
)
10806 struct breakpoint
*b
= bs
->breakpoint_at
;
10807 struct ui_out
*uiout
= current_uiout
;
10809 /* Masked watchpoints have only one location. */
10810 gdb_assert (b
->loc
&& b
->loc
->next
== NULL
);
10812 annotate_watchpoint (b
->number
);
10813 maybe_print_thread_hit_breakpoint (uiout
);
10817 case bp_hardware_watchpoint
:
10818 if (uiout
->is_mi_like_p ())
10819 uiout
->field_string
10820 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
10823 case bp_read_watchpoint
:
10824 if (uiout
->is_mi_like_p ())
10825 uiout
->field_string
10826 ("reason", async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
10829 case bp_access_watchpoint
:
10830 if (uiout
->is_mi_like_p ())
10831 uiout
->field_string
10833 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
10836 internal_error (__FILE__
, __LINE__
,
10837 _("Invalid hardware watchpoint type."));
10841 uiout
->text (_("\n\
10842 Check the underlying instruction at PC for the memory\n\
10843 address and value which triggered this watchpoint.\n"));
10844 uiout
->text ("\n");
10846 /* More than one watchpoint may have been triggered. */
10847 return PRINT_UNKNOWN
;
10850 /* Implement the "print_one_detail" breakpoint_ops method for
10851 masked hardware watchpoints. */
10854 print_one_detail_masked_watchpoint (const struct breakpoint
*b
,
10855 struct ui_out
*uiout
)
10857 struct watchpoint
*w
= (struct watchpoint
*) b
;
10859 /* Masked watchpoints have only one location. */
10860 gdb_assert (b
->loc
&& b
->loc
->next
== NULL
);
10862 uiout
->text ("\tmask ");
10863 uiout
->field_core_addr ("mask", b
->loc
->gdbarch
, w
->hw_wp_mask
);
10864 uiout
->text ("\n");
10867 /* Implement the "print_mention" breakpoint_ops method for
10868 masked hardware watchpoints. */
10871 print_mention_masked_watchpoint (struct breakpoint
*b
)
10873 struct watchpoint
*w
= (struct watchpoint
*) b
;
10874 struct ui_out
*uiout
= current_uiout
;
10875 const char *tuple_name
;
10879 case bp_hardware_watchpoint
:
10880 uiout
->text ("Masked hardware watchpoint ");
10881 tuple_name
= "wpt";
10883 case bp_read_watchpoint
:
10884 uiout
->text ("Masked hardware read watchpoint ");
10885 tuple_name
= "hw-rwpt";
10887 case bp_access_watchpoint
:
10888 uiout
->text ("Masked hardware access (read/write) watchpoint ");
10889 tuple_name
= "hw-awpt";
10892 internal_error (__FILE__
, __LINE__
,
10893 _("Invalid hardware watchpoint type."));
10896 ui_out_emit_tuple
tuple_emitter (uiout
, tuple_name
);
10897 uiout
->field_int ("number", b
->number
);
10898 uiout
->text (": ");
10899 uiout
->field_string ("exp", w
->exp_string
);
10902 /* Implement the "print_recreate" breakpoint_ops method for
10903 masked hardware watchpoints. */
10906 print_recreate_masked_watchpoint (struct breakpoint
*b
, struct ui_file
*fp
)
10908 struct watchpoint
*w
= (struct watchpoint
*) b
;
10913 case bp_hardware_watchpoint
:
10914 fprintf_unfiltered (fp
, "watch");
10916 case bp_read_watchpoint
:
10917 fprintf_unfiltered (fp
, "rwatch");
10919 case bp_access_watchpoint
:
10920 fprintf_unfiltered (fp
, "awatch");
10923 internal_error (__FILE__
, __LINE__
,
10924 _("Invalid hardware watchpoint type."));
10927 sprintf_vma (tmp
, w
->hw_wp_mask
);
10928 fprintf_unfiltered (fp
, " %s mask 0x%s", w
->exp_string
, tmp
);
10929 print_recreate_thread (b
, fp
);
10932 /* The breakpoint_ops structure to be used in masked hardware watchpoints. */
10934 static struct breakpoint_ops masked_watchpoint_breakpoint_ops
;
10936 /* Tell whether the given watchpoint is a masked hardware watchpoint. */
10939 is_masked_watchpoint (const struct breakpoint
*b
)
10941 return b
->ops
== &masked_watchpoint_breakpoint_ops
;
10944 /* accessflag: hw_write: watch write,
10945 hw_read: watch read,
10946 hw_access: watch access (read or write) */
10948 watch_command_1 (const char *arg
, int accessflag
, int from_tty
,
10949 int just_location
, int internal
)
10951 struct breakpoint
*scope_breakpoint
= NULL
;
10952 const struct block
*exp_valid_block
= NULL
, *cond_exp_valid_block
= NULL
;
10953 struct value
*val
, *mark
, *result
;
10954 int saved_bitpos
= 0, saved_bitsize
= 0;
10955 const char *exp_start
= NULL
;
10956 const char *exp_end
= NULL
;
10957 const char *tok
, *end_tok
;
10959 const char *cond_start
= NULL
;
10960 const char *cond_end
= NULL
;
10961 enum bptype bp_type
;
10964 /* Flag to indicate whether we are going to use masks for
10965 the hardware watchpoint. */
10967 CORE_ADDR mask
= 0;
10968 struct watchpoint
*w
;
10970 struct cleanup
*back_to
;
10972 /* Make sure that we actually have parameters to parse. */
10973 if (arg
!= NULL
&& arg
[0] != '\0')
10975 const char *value_start
;
10977 exp_end
= arg
+ strlen (arg
);
10979 /* Look for "parameter value" pairs at the end
10980 of the arguments string. */
10981 for (tok
= exp_end
- 1; tok
> arg
; tok
--)
10983 /* Skip whitespace at the end of the argument list. */
10984 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
10987 /* Find the beginning of the last token.
10988 This is the value of the parameter. */
10989 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
10991 value_start
= tok
+ 1;
10993 /* Skip whitespace. */
10994 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
10999 /* Find the beginning of the second to last token.
11000 This is the parameter itself. */
11001 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
11004 toklen
= end_tok
- tok
+ 1;
11006 if (toklen
== 6 && startswith (tok
, "thread"))
11008 struct thread_info
*thr
;
11009 /* At this point we've found a "thread" token, which means
11010 the user is trying to set a watchpoint that triggers
11011 only in a specific thread. */
11015 error(_("You can specify only one thread."));
11017 /* Extract the thread ID from the next token. */
11018 thr
= parse_thread_id (value_start
, &endp
);
11020 /* Check if the user provided a valid thread ID. */
11021 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
11022 invalid_thread_id_error (value_start
);
11024 thread
= thr
->global_num
;
11026 else if (toklen
== 4 && startswith (tok
, "mask"))
11028 /* We've found a "mask" token, which means the user wants to
11029 create a hardware watchpoint that is going to have the mask
11031 struct value
*mask_value
, *mark
;
11034 error(_("You can specify only one mask."));
11036 use_mask
= just_location
= 1;
11038 mark
= value_mark ();
11039 mask_value
= parse_to_comma_and_eval (&value_start
);
11040 mask
= value_as_address (mask_value
);
11041 value_free_to_mark (mark
);
11044 /* We didn't recognize what we found. We should stop here. */
11047 /* Truncate the string and get rid of the "parameter value" pair before
11048 the arguments string is parsed by the parse_exp_1 function. */
11055 /* Parse the rest of the arguments. From here on out, everything
11056 is in terms of a newly allocated string instead of the original
11058 innermost_block
= NULL
;
11059 expression
= savestring (arg
, exp_end
- arg
);
11060 back_to
= make_cleanup (xfree
, expression
);
11061 exp_start
= arg
= expression
;
11062 expression_up exp
= parse_exp_1 (&arg
, 0, 0, 0);
11064 /* Remove trailing whitespace from the expression before saving it.
11065 This makes the eventual display of the expression string a bit
11067 while (exp_end
> exp_start
&& (exp_end
[-1] == ' ' || exp_end
[-1] == '\t'))
11070 /* Checking if the expression is not constant. */
11071 if (watchpoint_exp_is_const (exp
.get ()))
11075 len
= exp_end
- exp_start
;
11076 while (len
> 0 && isspace (exp_start
[len
- 1]))
11078 error (_("Cannot watch constant value `%.*s'."), len
, exp_start
);
11081 exp_valid_block
= innermost_block
;
11082 mark
= value_mark ();
11083 fetch_subexp_value (exp
.get (), &pc
, &val
, &result
, NULL
, just_location
);
11085 if (val
!= NULL
&& just_location
)
11087 saved_bitpos
= value_bitpos (val
);
11088 saved_bitsize
= value_bitsize (val
);
11095 exp_valid_block
= NULL
;
11096 val
= value_addr (result
);
11097 release_value (val
);
11098 value_free_to_mark (mark
);
11102 ret
= target_masked_watch_num_registers (value_as_address (val
),
11105 error (_("This target does not support masked watchpoints."));
11106 else if (ret
== -2)
11107 error (_("Invalid mask or memory region."));
11110 else if (val
!= NULL
)
11111 release_value (val
);
11113 tok
= skip_spaces_const (arg
);
11114 end_tok
= skip_to_space_const (tok
);
11116 toklen
= end_tok
- tok
;
11117 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
11119 innermost_block
= NULL
;
11120 tok
= cond_start
= end_tok
+ 1;
11121 parse_exp_1 (&tok
, 0, 0, 0);
11123 /* The watchpoint expression may not be local, but the condition
11124 may still be. E.g.: `watch global if local > 0'. */
11125 cond_exp_valid_block
= innermost_block
;
11130 error (_("Junk at end of command."));
11132 frame_info
*wp_frame
= block_innermost_frame (exp_valid_block
);
11134 /* Save this because create_internal_breakpoint below invalidates
11136 frame_id watchpoint_frame
= get_frame_id (wp_frame
);
11138 /* If the expression is "local", then set up a "watchpoint scope"
11139 breakpoint at the point where we've left the scope of the watchpoint
11140 expression. Create the scope breakpoint before the watchpoint, so
11141 that we will encounter it first in bpstat_stop_status. */
11142 if (exp_valid_block
!= NULL
&& wp_frame
!= NULL
)
11144 frame_id caller_frame_id
= frame_unwind_caller_id (wp_frame
);
11146 if (frame_id_p (caller_frame_id
))
11148 gdbarch
*caller_arch
= frame_unwind_caller_arch (wp_frame
);
11149 CORE_ADDR caller_pc
= frame_unwind_caller_pc (wp_frame
);
11152 = create_internal_breakpoint (caller_arch
, caller_pc
,
11153 bp_watchpoint_scope
,
11154 &momentary_breakpoint_ops
);
11156 /* create_internal_breakpoint could invalidate WP_FRAME. */
11159 scope_breakpoint
->enable_state
= bp_enabled
;
11161 /* Automatically delete the breakpoint when it hits. */
11162 scope_breakpoint
->disposition
= disp_del
;
11164 /* Only break in the proper frame (help with recursion). */
11165 scope_breakpoint
->frame_id
= caller_frame_id
;
11167 /* Set the address at which we will stop. */
11168 scope_breakpoint
->loc
->gdbarch
= caller_arch
;
11169 scope_breakpoint
->loc
->requested_address
= caller_pc
;
11170 scope_breakpoint
->loc
->address
11171 = adjust_breakpoint_address (scope_breakpoint
->loc
->gdbarch
,
11172 scope_breakpoint
->loc
->requested_address
,
11173 scope_breakpoint
->type
);
11177 /* Now set up the breakpoint. We create all watchpoints as hardware
11178 watchpoints here even if hardware watchpoints are turned off, a call
11179 to update_watchpoint later in this function will cause the type to
11180 drop back to bp_watchpoint (software watchpoint) if required. */
11182 if (accessflag
== hw_read
)
11183 bp_type
= bp_read_watchpoint
;
11184 else if (accessflag
== hw_access
)
11185 bp_type
= bp_access_watchpoint
;
11187 bp_type
= bp_hardware_watchpoint
;
11189 w
= new watchpoint ();
11192 init_raw_breakpoint_without_location (w
, NULL
, bp_type
,
11193 &masked_watchpoint_breakpoint_ops
);
11195 init_raw_breakpoint_without_location (w
, NULL
, bp_type
,
11196 &watchpoint_breakpoint_ops
);
11197 w
->thread
= thread
;
11198 w
->disposition
= disp_donttouch
;
11199 w
->pspace
= current_program_space
;
11200 w
->exp
= std::move (exp
);
11201 w
->exp_valid_block
= exp_valid_block
;
11202 w
->cond_exp_valid_block
= cond_exp_valid_block
;
11205 struct type
*t
= value_type (val
);
11206 CORE_ADDR addr
= value_as_address (val
);
11208 w
->exp_string_reparse
11209 = current_language
->la_watch_location_expression (t
, addr
).release ();
11211 w
->exp_string
= xstrprintf ("-location %.*s",
11212 (int) (exp_end
- exp_start
), exp_start
);
11215 w
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
11219 w
->hw_wp_mask
= mask
;
11224 w
->val_bitpos
= saved_bitpos
;
11225 w
->val_bitsize
= saved_bitsize
;
11230 w
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
11232 w
->cond_string
= 0;
11234 if (frame_id_p (watchpoint_frame
))
11236 w
->watchpoint_frame
= watchpoint_frame
;
11237 w
->watchpoint_thread
= inferior_ptid
;
11241 w
->watchpoint_frame
= null_frame_id
;
11242 w
->watchpoint_thread
= null_ptid
;
11245 if (scope_breakpoint
!= NULL
)
11247 /* The scope breakpoint is related to the watchpoint. We will
11248 need to act on them together. */
11249 w
->related_breakpoint
= scope_breakpoint
;
11250 scope_breakpoint
->related_breakpoint
= w
;
11253 if (!just_location
)
11254 value_free_to_mark (mark
);
11258 /* Finally update the new watchpoint. This creates the locations
11259 that should be inserted. */
11260 update_watchpoint (w
, 1);
11262 CATCH (e
, RETURN_MASK_ALL
)
11264 delete_breakpoint (w
);
11265 throw_exception (e
);
11269 install_breakpoint (internal
, w
, 1);
11270 do_cleanups (back_to
);
11273 /* Return count of debug registers needed to watch the given expression.
11274 If the watchpoint cannot be handled in hardware return zero. */
11277 can_use_hardware_watchpoint (struct value
*v
)
11279 int found_memory_cnt
= 0;
11280 struct value
*head
= v
;
11282 /* Did the user specifically forbid us to use hardware watchpoints? */
11283 if (!can_use_hw_watchpoints
)
11286 /* Make sure that the value of the expression depends only upon
11287 memory contents, and values computed from them within GDB. If we
11288 find any register references or function calls, we can't use a
11289 hardware watchpoint.
11291 The idea here is that evaluating an expression generates a series
11292 of values, one holding the value of every subexpression. (The
11293 expression a*b+c has five subexpressions: a, b, a*b, c, and
11294 a*b+c.) GDB's values hold almost enough information to establish
11295 the criteria given above --- they identify memory lvalues,
11296 register lvalues, computed values, etcetera. So we can evaluate
11297 the expression, and then scan the chain of values that leaves
11298 behind to decide whether we can detect any possible change to the
11299 expression's final value using only hardware watchpoints.
11301 However, I don't think that the values returned by inferior
11302 function calls are special in any way. So this function may not
11303 notice that an expression involving an inferior function call
11304 can't be watched with hardware watchpoints. FIXME. */
11305 for (; v
; v
= value_next (v
))
11307 if (VALUE_LVAL (v
) == lval_memory
)
11309 if (v
!= head
&& value_lazy (v
))
11310 /* A lazy memory lvalue in the chain is one that GDB never
11311 needed to fetch; we either just used its address (e.g.,
11312 `a' in `a.b') or we never needed it at all (e.g., `a'
11313 in `a,b'). This doesn't apply to HEAD; if that is
11314 lazy then it was not readable, but watch it anyway. */
11318 /* Ahh, memory we actually used! Check if we can cover
11319 it with hardware watchpoints. */
11320 struct type
*vtype
= check_typedef (value_type (v
));
11322 /* We only watch structs and arrays if user asked for it
11323 explicitly, never if they just happen to appear in a
11324 middle of some value chain. */
11326 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
11327 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
11329 CORE_ADDR vaddr
= value_address (v
);
11333 len
= (target_exact_watchpoints
11334 && is_scalar_type_recursive (vtype
))?
11335 1 : TYPE_LENGTH (value_type (v
));
11337 num_regs
= target_region_ok_for_hw_watchpoint (vaddr
, len
);
11341 found_memory_cnt
+= num_regs
;
11345 else if (VALUE_LVAL (v
) != not_lval
11346 && deprecated_value_modifiable (v
) == 0)
11347 return 0; /* These are values from the history (e.g., $1). */
11348 else if (VALUE_LVAL (v
) == lval_register
)
11349 return 0; /* Cannot watch a register with a HW watchpoint. */
11352 /* The expression itself looks suitable for using a hardware
11353 watchpoint, but give the target machine a chance to reject it. */
11354 return found_memory_cnt
;
11358 watch_command_wrapper (char *arg
, int from_tty
, int internal
)
11360 watch_command_1 (arg
, hw_write
, from_tty
, 0, internal
);
11363 /* A helper function that looks for the "-location" argument and then
11364 calls watch_command_1. */
11367 watch_maybe_just_location (char *arg
, int accessflag
, int from_tty
)
11369 int just_location
= 0;
11372 && (check_for_argument (&arg
, "-location", sizeof ("-location") - 1)
11373 || check_for_argument (&arg
, "-l", sizeof ("-l") - 1)))
11375 arg
= skip_spaces (arg
);
11379 watch_command_1 (arg
, accessflag
, from_tty
, just_location
, 0);
11383 watch_command (char *arg
, int from_tty
)
11385 watch_maybe_just_location (arg
, hw_write
, from_tty
);
11389 rwatch_command_wrapper (char *arg
, int from_tty
, int internal
)
11391 watch_command_1 (arg
, hw_read
, from_tty
, 0, internal
);
11395 rwatch_command (char *arg
, int from_tty
)
11397 watch_maybe_just_location (arg
, hw_read
, from_tty
);
11401 awatch_command_wrapper (char *arg
, int from_tty
, int internal
)
11403 watch_command_1 (arg
, hw_access
, from_tty
, 0, internal
);
11407 awatch_command (char *arg
, int from_tty
)
11409 watch_maybe_just_location (arg
, hw_access
, from_tty
);
11413 /* Data for the FSM that manages the until(location)/advance commands
11414 in infcmd.c. Here because it uses the mechanisms of
11417 struct until_break_fsm
11419 /* The base class. */
11420 struct thread_fsm thread_fsm
;
11422 /* The thread that as current when the command was executed. */
11425 /* The breakpoint set at the destination location. */
11426 struct breakpoint
*location_breakpoint
;
11428 /* Breakpoint set at the return address in the caller frame. May be
11430 struct breakpoint
*caller_breakpoint
;
11433 static void until_break_fsm_clean_up (struct thread_fsm
*self
,
11434 struct thread_info
*thread
);
11435 static int until_break_fsm_should_stop (struct thread_fsm
*self
,
11436 struct thread_info
*thread
);
11437 static enum async_reply_reason
11438 until_break_fsm_async_reply_reason (struct thread_fsm
*self
);
11440 /* until_break_fsm's vtable. */
11442 static struct thread_fsm_ops until_break_fsm_ops
=
11445 until_break_fsm_clean_up
,
11446 until_break_fsm_should_stop
,
11447 NULL
, /* return_value */
11448 until_break_fsm_async_reply_reason
,
11451 /* Allocate a new until_break_command_fsm. */
11453 static struct until_break_fsm
*
11454 new_until_break_fsm (struct interp
*cmd_interp
, int thread
,
11455 struct breakpoint
*location_breakpoint
,
11456 struct breakpoint
*caller_breakpoint
)
11458 struct until_break_fsm
*sm
;
11460 sm
= XCNEW (struct until_break_fsm
);
11461 thread_fsm_ctor (&sm
->thread_fsm
, &until_break_fsm_ops
, cmd_interp
);
11463 sm
->thread
= thread
;
11464 sm
->location_breakpoint
= location_breakpoint
;
11465 sm
->caller_breakpoint
= caller_breakpoint
;
11470 /* Implementation of the 'should_stop' FSM method for the
11471 until(location)/advance commands. */
11474 until_break_fsm_should_stop (struct thread_fsm
*self
,
11475 struct thread_info
*tp
)
11477 struct until_break_fsm
*sm
= (struct until_break_fsm
*) self
;
11479 if (bpstat_find_breakpoint (tp
->control
.stop_bpstat
,
11480 sm
->location_breakpoint
) != NULL
11481 || (sm
->caller_breakpoint
!= NULL
11482 && bpstat_find_breakpoint (tp
->control
.stop_bpstat
,
11483 sm
->caller_breakpoint
) != NULL
))
11484 thread_fsm_set_finished (self
);
11489 /* Implementation of the 'clean_up' FSM method for the
11490 until(location)/advance commands. */
11493 until_break_fsm_clean_up (struct thread_fsm
*self
,
11494 struct thread_info
*thread
)
11496 struct until_break_fsm
*sm
= (struct until_break_fsm
*) self
;
11498 /* Clean up our temporary breakpoints. */
11499 if (sm
->location_breakpoint
!= NULL
)
11501 delete_breakpoint (sm
->location_breakpoint
);
11502 sm
->location_breakpoint
= NULL
;
11504 if (sm
->caller_breakpoint
!= NULL
)
11506 delete_breakpoint (sm
->caller_breakpoint
);
11507 sm
->caller_breakpoint
= NULL
;
11509 delete_longjmp_breakpoint (sm
->thread
);
11512 /* Implementation of the 'async_reply_reason' FSM method for the
11513 until(location)/advance commands. */
11515 static enum async_reply_reason
11516 until_break_fsm_async_reply_reason (struct thread_fsm
*self
)
11518 return EXEC_ASYNC_LOCATION_REACHED
;
11522 until_break_command (char *arg
, int from_tty
, int anywhere
)
11524 struct symtabs_and_lines sals
;
11525 struct symtab_and_line sal
;
11526 struct frame_info
*frame
;
11527 struct gdbarch
*frame_gdbarch
;
11528 struct frame_id stack_frame_id
;
11529 struct frame_id caller_frame_id
;
11530 struct breakpoint
*location_breakpoint
;
11531 struct breakpoint
*caller_breakpoint
= NULL
;
11532 struct cleanup
*old_chain
;
11534 struct thread_info
*tp
;
11535 struct until_break_fsm
*sm
;
11537 clear_proceed_status (0);
11539 /* Set a breakpoint where the user wants it and at return from
11542 event_location_up location
= string_to_event_location (&arg
, current_language
);
11544 if (last_displayed_sal_is_valid ())
11545 sals
= decode_line_1 (location
.get (), DECODE_LINE_FUNFIRSTLINE
, NULL
,
11546 get_last_displayed_symtab (),
11547 get_last_displayed_line ());
11549 sals
= decode_line_1 (location
.get (), DECODE_LINE_FUNFIRSTLINE
,
11550 NULL
, (struct symtab
*) NULL
, 0);
11552 if (sals
.nelts
!= 1)
11553 error (_("Couldn't get information on specified line."));
11555 sal
= sals
.sals
[0];
11556 xfree (sals
.sals
); /* malloc'd, so freed. */
11559 error (_("Junk at end of arguments."));
11561 resolve_sal_pc (&sal
);
11563 tp
= inferior_thread ();
11564 thread
= tp
->global_num
;
11566 old_chain
= make_cleanup (null_cleanup
, NULL
);
11568 /* Note linespec handling above invalidates the frame chain.
11569 Installing a breakpoint also invalidates the frame chain (as it
11570 may need to switch threads), so do any frame handling before
11573 frame
= get_selected_frame (NULL
);
11574 frame_gdbarch
= get_frame_arch (frame
);
11575 stack_frame_id
= get_stack_frame_id (frame
);
11576 caller_frame_id
= frame_unwind_caller_id (frame
);
11578 /* Keep within the current frame, or in frames called by the current
11581 if (frame_id_p (caller_frame_id
))
11583 struct symtab_and_line sal2
;
11584 struct gdbarch
*caller_gdbarch
;
11586 sal2
= find_pc_line (frame_unwind_caller_pc (frame
), 0);
11587 sal2
.pc
= frame_unwind_caller_pc (frame
);
11588 caller_gdbarch
= frame_unwind_caller_arch (frame
);
11589 caller_breakpoint
= set_momentary_breakpoint (caller_gdbarch
,
11593 make_cleanup_delete_breakpoint (caller_breakpoint
);
11595 set_longjmp_breakpoint (tp
, caller_frame_id
);
11596 make_cleanup (delete_longjmp_breakpoint_cleanup
, &thread
);
11599 /* set_momentary_breakpoint could invalidate FRAME. */
11603 /* If the user told us to continue until a specified location,
11604 we don't specify a frame at which we need to stop. */
11605 location_breakpoint
= set_momentary_breakpoint (frame_gdbarch
, sal
,
11606 null_frame_id
, bp_until
);
11608 /* Otherwise, specify the selected frame, because we want to stop
11609 only at the very same frame. */
11610 location_breakpoint
= set_momentary_breakpoint (frame_gdbarch
, sal
,
11611 stack_frame_id
, bp_until
);
11612 make_cleanup_delete_breakpoint (location_breakpoint
);
11614 sm
= new_until_break_fsm (command_interp (), tp
->global_num
,
11615 location_breakpoint
, caller_breakpoint
);
11616 tp
->thread_fsm
= &sm
->thread_fsm
;
11618 discard_cleanups (old_chain
);
11620 proceed (-1, GDB_SIGNAL_DEFAULT
);
11623 /* This function attempts to parse an optional "if <cond>" clause
11624 from the arg string. If one is not found, it returns NULL.
11626 Else, it returns a pointer to the condition string. (It does not
11627 attempt to evaluate the string against a particular block.) And,
11628 it updates arg to point to the first character following the parsed
11629 if clause in the arg string. */
11632 ep_parse_optional_if_clause (const char **arg
)
11634 const char *cond_string
;
11636 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
11639 /* Skip the "if" keyword. */
11642 /* Skip any extra leading whitespace, and record the start of the
11643 condition string. */
11644 *arg
= skip_spaces_const (*arg
);
11645 cond_string
= *arg
;
11647 /* Assume that the condition occupies the remainder of the arg
11649 (*arg
) += strlen (cond_string
);
11651 return cond_string
;
11654 /* Commands to deal with catching events, such as signals, exceptions,
11655 process start/exit, etc. */
11659 catch_fork_temporary
, catch_vfork_temporary
,
11660 catch_fork_permanent
, catch_vfork_permanent
11665 catch_fork_command_1 (char *arg_entry
, int from_tty
,
11666 struct cmd_list_element
*command
)
11668 const char *arg
= arg_entry
;
11669 struct gdbarch
*gdbarch
= get_current_arch ();
11670 const char *cond_string
= NULL
;
11671 catch_fork_kind fork_kind
;
11674 fork_kind
= (catch_fork_kind
) (uintptr_t) get_cmd_context (command
);
11675 tempflag
= (fork_kind
== catch_fork_temporary
11676 || fork_kind
== catch_vfork_temporary
);
11680 arg
= skip_spaces_const (arg
);
11682 /* The allowed syntax is:
11684 catch [v]fork if <cond>
11686 First, check if there's an if clause. */
11687 cond_string
= ep_parse_optional_if_clause (&arg
);
11689 if ((*arg
!= '\0') && !isspace (*arg
))
11690 error (_("Junk at end of arguments."));
11692 /* If this target supports it, create a fork or vfork catchpoint
11693 and enable reporting of such events. */
11696 case catch_fork_temporary
:
11697 case catch_fork_permanent
:
11698 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
11699 &catch_fork_breakpoint_ops
);
11701 case catch_vfork_temporary
:
11702 case catch_vfork_permanent
:
11703 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
11704 &catch_vfork_breakpoint_ops
);
11707 error (_("unsupported or unknown fork kind; cannot catch it"));
11713 catch_exec_command_1 (char *arg_entry
, int from_tty
,
11714 struct cmd_list_element
*command
)
11716 const char *arg
= arg_entry
;
11717 struct exec_catchpoint
*c
;
11718 struct gdbarch
*gdbarch
= get_current_arch ();
11720 const char *cond_string
= NULL
;
11722 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
11726 arg
= skip_spaces_const (arg
);
11728 /* The allowed syntax is:
11730 catch exec if <cond>
11732 First, check if there's an if clause. */
11733 cond_string
= ep_parse_optional_if_clause (&arg
);
11735 if ((*arg
!= '\0') && !isspace (*arg
))
11736 error (_("Junk at end of arguments."));
11738 c
= new exec_catchpoint ();
11739 init_catchpoint (c
, gdbarch
, tempflag
, cond_string
,
11740 &catch_exec_breakpoint_ops
);
11741 c
->exec_pathname
= NULL
;
11743 install_breakpoint (0, c
, 1);
11747 init_ada_exception_breakpoint (struct breakpoint
*b
,
11748 struct gdbarch
*gdbarch
,
11749 struct symtab_and_line sal
,
11751 const struct breakpoint_ops
*ops
,
11758 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
11760 loc_gdbarch
= gdbarch
;
11762 describe_other_breakpoints (loc_gdbarch
,
11763 sal
.pspace
, sal
.pc
, sal
.section
, -1);
11764 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
11765 version for exception catchpoints, because two catchpoints
11766 used for different exception names will use the same address.
11767 In this case, a "breakpoint ... also set at..." warning is
11768 unproductive. Besides, the warning phrasing is also a bit
11769 inappropriate, we should use the word catchpoint, and tell
11770 the user what type of catchpoint it is. The above is good
11771 enough for now, though. */
11774 init_raw_breakpoint (b
, gdbarch
, sal
, bp_breakpoint
, ops
);
11776 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
11777 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
11778 b
->location
= string_to_event_location (&addr_string
,
11779 language_def (language_ada
));
11780 b
->language
= language_ada
;
11784 catch_command (char *arg
, int from_tty
)
11786 error (_("Catch requires an event name."));
11791 tcatch_command (char *arg
, int from_tty
)
11793 error (_("Catch requires an event name."));
11796 /* A qsort comparison function that sorts breakpoints in order. */
11799 compare_breakpoints (const void *a
, const void *b
)
11801 const breakpoint_p
*ba
= (const breakpoint_p
*) a
;
11802 uintptr_t ua
= (uintptr_t) *ba
;
11803 const breakpoint_p
*bb
= (const breakpoint_p
*) b
;
11804 uintptr_t ub
= (uintptr_t) *bb
;
11806 if ((*ba
)->number
< (*bb
)->number
)
11808 else if ((*ba
)->number
> (*bb
)->number
)
11811 /* Now sort by address, in case we see, e..g, two breakpoints with
11815 return ua
> ub
? 1 : 0;
11818 /* Delete breakpoints by address or line. */
11821 clear_command (char *arg
, int from_tty
)
11823 struct breakpoint
*b
, *prev
;
11824 VEC(breakpoint_p
) *found
= 0;
11827 struct symtabs_and_lines sals
;
11828 struct symtab_and_line sal
;
11830 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
11834 sals
= decode_line_with_current_source (arg
,
11835 (DECODE_LINE_FUNFIRSTLINE
11836 | DECODE_LINE_LIST_MODE
));
11837 make_cleanup (xfree
, sals
.sals
);
11842 sals
.sals
= XNEW (struct symtab_and_line
);
11843 make_cleanup (xfree
, sals
.sals
);
11844 init_sal (&sal
); /* Initialize to zeroes. */
11846 /* Set sal's line, symtab, pc, and pspace to the values
11847 corresponding to the last call to print_frame_info. If the
11848 codepoint is not valid, this will set all the fields to 0. */
11849 get_last_displayed_sal (&sal
);
11850 if (sal
.symtab
== 0)
11851 error (_("No source file specified."));
11853 sals
.sals
[0] = sal
;
11859 /* We don't call resolve_sal_pc here. That's not as bad as it
11860 seems, because all existing breakpoints typically have both
11861 file/line and pc set. So, if clear is given file/line, we can
11862 match this to existing breakpoint without obtaining pc at all.
11864 We only support clearing given the address explicitly
11865 present in breakpoint table. Say, we've set breakpoint
11866 at file:line. There were several PC values for that file:line,
11867 due to optimization, all in one block.
11869 We've picked one PC value. If "clear" is issued with another
11870 PC corresponding to the same file:line, the breakpoint won't
11871 be cleared. We probably can still clear the breakpoint, but
11872 since the other PC value is never presented to user, user
11873 can only find it by guessing, and it does not seem important
11874 to support that. */
11876 /* For each line spec given, delete bps which correspond to it. Do
11877 it in two passes, solely to preserve the current behavior that
11878 from_tty is forced true if we delete more than one
11882 make_cleanup (VEC_cleanup (breakpoint_p
), &found
);
11883 for (i
= 0; i
< sals
.nelts
; i
++)
11885 const char *sal_fullname
;
11887 /* If exact pc given, clear bpts at that pc.
11888 If line given (pc == 0), clear all bpts on specified line.
11889 If defaulting, clear all bpts on default line
11892 defaulting sal.pc != 0 tests to do
11897 1 0 <can't happen> */
11899 sal
= sals
.sals
[i
];
11900 sal_fullname
= (sal
.symtab
== NULL
11901 ? NULL
: symtab_to_fullname (sal
.symtab
));
11903 /* Find all matching breakpoints and add them to 'found'. */
11904 ALL_BREAKPOINTS (b
)
11907 /* Are we going to delete b? */
11908 if (b
->type
!= bp_none
&& !is_watchpoint (b
))
11910 struct bp_location
*loc
= b
->loc
;
11911 for (; loc
; loc
= loc
->next
)
11913 /* If the user specified file:line, don't allow a PC
11914 match. This matches historical gdb behavior. */
11915 int pc_match
= (!sal
.explicit_line
11917 && (loc
->pspace
== sal
.pspace
)
11918 && (loc
->address
== sal
.pc
)
11919 && (!section_is_overlay (loc
->section
)
11920 || loc
->section
== sal
.section
));
11921 int line_match
= 0;
11923 if ((default_match
|| sal
.explicit_line
)
11924 && loc
->symtab
!= NULL
11925 && sal_fullname
!= NULL
11926 && sal
.pspace
== loc
->pspace
11927 && loc
->line_number
== sal
.line
11928 && filename_cmp (symtab_to_fullname (loc
->symtab
),
11929 sal_fullname
) == 0)
11932 if (pc_match
|| line_match
)
11941 VEC_safe_push(breakpoint_p
, found
, b
);
11945 /* Now go thru the 'found' chain and delete them. */
11946 if (VEC_empty(breakpoint_p
, found
))
11949 error (_("No breakpoint at %s."), arg
);
11951 error (_("No breakpoint at this line."));
11954 /* Remove duplicates from the vec. */
11955 qsort (VEC_address (breakpoint_p
, found
),
11956 VEC_length (breakpoint_p
, found
),
11957 sizeof (breakpoint_p
),
11958 compare_breakpoints
);
11959 prev
= VEC_index (breakpoint_p
, found
, 0);
11960 for (ix
= 1; VEC_iterate (breakpoint_p
, found
, ix
, b
); ++ix
)
11964 VEC_ordered_remove (breakpoint_p
, found
, ix
);
11969 if (VEC_length(breakpoint_p
, found
) > 1)
11970 from_tty
= 1; /* Always report if deleted more than one. */
11973 if (VEC_length(breakpoint_p
, found
) == 1)
11974 printf_unfiltered (_("Deleted breakpoint "));
11976 printf_unfiltered (_("Deleted breakpoints "));
11979 for (ix
= 0; VEC_iterate(breakpoint_p
, found
, ix
, b
); ix
++)
11982 printf_unfiltered ("%d ", b
->number
);
11983 delete_breakpoint (b
);
11986 putchar_unfiltered ('\n');
11988 do_cleanups (cleanups
);
11991 /* Delete breakpoint in BS if they are `delete' breakpoints and
11992 all breakpoints that are marked for deletion, whether hit or not.
11993 This is called after any breakpoint is hit, or after errors. */
11996 breakpoint_auto_delete (bpstat bs
)
11998 struct breakpoint
*b
, *b_tmp
;
12000 for (; bs
; bs
= bs
->next
)
12001 if (bs
->breakpoint_at
12002 && bs
->breakpoint_at
->disposition
== disp_del
12004 delete_breakpoint (bs
->breakpoint_at
);
12006 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
12008 if (b
->disposition
== disp_del_at_next_stop
)
12009 delete_breakpoint (b
);
12013 /* A comparison function for bp_location AP and BP being interfaced to
12014 qsort. Sort elements primarily by their ADDRESS (no matter what
12015 does breakpoint_address_is_meaningful say for its OWNER),
12016 secondarily by ordering first permanent elements and
12017 terciarily just ensuring the array is sorted stable way despite
12018 qsort being an unstable algorithm. */
12021 bp_locations_compare (const void *ap
, const void *bp
)
12023 const struct bp_location
*a
= *(const struct bp_location
**) ap
;
12024 const struct bp_location
*b
= *(const struct bp_location
**) bp
;
12026 if (a
->address
!= b
->address
)
12027 return (a
->address
> b
->address
) - (a
->address
< b
->address
);
12029 /* Sort locations at the same address by their pspace number, keeping
12030 locations of the same inferior (in a multi-inferior environment)
12033 if (a
->pspace
->num
!= b
->pspace
->num
)
12034 return ((a
->pspace
->num
> b
->pspace
->num
)
12035 - (a
->pspace
->num
< b
->pspace
->num
));
12037 /* Sort permanent breakpoints first. */
12038 if (a
->permanent
!= b
->permanent
)
12039 return (a
->permanent
< b
->permanent
) - (a
->permanent
> b
->permanent
);
12041 /* Make the internal GDB representation stable across GDB runs
12042 where A and B memory inside GDB can differ. Breakpoint locations of
12043 the same type at the same address can be sorted in arbitrary order. */
12045 if (a
->owner
->number
!= b
->owner
->number
)
12046 return ((a
->owner
->number
> b
->owner
->number
)
12047 - (a
->owner
->number
< b
->owner
->number
));
12049 return (a
> b
) - (a
< b
);
12052 /* Set bp_locations_placed_address_before_address_max and
12053 bp_locations_shadow_len_after_address_max according to the current
12054 content of the bp_locations array. */
12057 bp_locations_target_extensions_update (void)
12059 struct bp_location
*bl
, **blp_tmp
;
12061 bp_locations_placed_address_before_address_max
= 0;
12062 bp_locations_shadow_len_after_address_max
= 0;
12064 ALL_BP_LOCATIONS (bl
, blp_tmp
)
12066 CORE_ADDR start
, end
, addr
;
12068 if (!bp_location_has_shadow (bl
))
12071 start
= bl
->target_info
.placed_address
;
12072 end
= start
+ bl
->target_info
.shadow_len
;
12074 gdb_assert (bl
->address
>= start
);
12075 addr
= bl
->address
- start
;
12076 if (addr
> bp_locations_placed_address_before_address_max
)
12077 bp_locations_placed_address_before_address_max
= addr
;
12079 /* Zero SHADOW_LEN would not pass bp_location_has_shadow. */
12081 gdb_assert (bl
->address
< end
);
12082 addr
= end
- bl
->address
;
12083 if (addr
> bp_locations_shadow_len_after_address_max
)
12084 bp_locations_shadow_len_after_address_max
= addr
;
12088 /* Download tracepoint locations if they haven't been. */
12091 download_tracepoint_locations (void)
12093 struct breakpoint
*b
;
12094 enum tribool can_download_tracepoint
= TRIBOOL_UNKNOWN
;
12096 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
12098 ALL_TRACEPOINTS (b
)
12100 struct bp_location
*bl
;
12101 struct tracepoint
*t
;
12102 int bp_location_downloaded
= 0;
12104 if ((b
->type
== bp_fast_tracepoint
12105 ? !may_insert_fast_tracepoints
12106 : !may_insert_tracepoints
))
12109 if (can_download_tracepoint
== TRIBOOL_UNKNOWN
)
12111 if (target_can_download_tracepoint ())
12112 can_download_tracepoint
= TRIBOOL_TRUE
;
12114 can_download_tracepoint
= TRIBOOL_FALSE
;
12117 if (can_download_tracepoint
== TRIBOOL_FALSE
)
12120 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
12122 /* In tracepoint, locations are _never_ duplicated, so
12123 should_be_inserted is equivalent to
12124 unduplicated_should_be_inserted. */
12125 if (!should_be_inserted (bl
) || bl
->inserted
)
12128 switch_to_program_space_and_thread (bl
->pspace
);
12130 target_download_tracepoint (bl
);
12133 bp_location_downloaded
= 1;
12135 t
= (struct tracepoint
*) b
;
12136 t
->number_on_target
= b
->number
;
12137 if (bp_location_downloaded
)
12138 observer_notify_breakpoint_modified (b
);
12142 /* Swap the insertion/duplication state between two locations. */
12145 swap_insertion (struct bp_location
*left
, struct bp_location
*right
)
12147 const int left_inserted
= left
->inserted
;
12148 const int left_duplicate
= left
->duplicate
;
12149 const int left_needs_update
= left
->needs_update
;
12150 const struct bp_target_info left_target_info
= left
->target_info
;
12152 /* Locations of tracepoints can never be duplicated. */
12153 if (is_tracepoint (left
->owner
))
12154 gdb_assert (!left
->duplicate
);
12155 if (is_tracepoint (right
->owner
))
12156 gdb_assert (!right
->duplicate
);
12158 left
->inserted
= right
->inserted
;
12159 left
->duplicate
= right
->duplicate
;
12160 left
->needs_update
= right
->needs_update
;
12161 left
->target_info
= right
->target_info
;
12162 right
->inserted
= left_inserted
;
12163 right
->duplicate
= left_duplicate
;
12164 right
->needs_update
= left_needs_update
;
12165 right
->target_info
= left_target_info
;
12168 /* Force the re-insertion of the locations at ADDRESS. This is called
12169 once a new/deleted/modified duplicate location is found and we are evaluating
12170 conditions on the target's side. Such conditions need to be updated on
12174 force_breakpoint_reinsertion (struct bp_location
*bl
)
12176 struct bp_location
**locp
= NULL
, **loc2p
;
12177 struct bp_location
*loc
;
12178 CORE_ADDR address
= 0;
12181 address
= bl
->address
;
12182 pspace_num
= bl
->pspace
->num
;
12184 /* This is only meaningful if the target is
12185 evaluating conditions and if the user has
12186 opted for condition evaluation on the target's
12188 if (gdb_evaluates_breakpoint_condition_p ()
12189 || !target_supports_evaluation_of_breakpoint_conditions ())
12192 /* Flag all breakpoint locations with this address and
12193 the same program space as the location
12194 as "its condition has changed". We need to
12195 update the conditions on the target's side. */
12196 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, address
)
12200 if (!is_breakpoint (loc
->owner
)
12201 || pspace_num
!= loc
->pspace
->num
)
12204 /* Flag the location appropriately. We use a different state to
12205 let everyone know that we already updated the set of locations
12206 with addr bl->address and program space bl->pspace. This is so
12207 we don't have to keep calling these functions just to mark locations
12208 that have already been marked. */
12209 loc
->condition_changed
= condition_updated
;
12211 /* Free the agent expression bytecode as well. We will compute
12213 loc
->cond_bytecode
.reset ();
12216 /* Called whether new breakpoints are created, or existing breakpoints
12217 deleted, to update the global location list and recompute which
12218 locations are duplicate of which.
12220 The INSERT_MODE flag determines whether locations may not, may, or
12221 shall be inserted now. See 'enum ugll_insert_mode' for more
12225 update_global_location_list (enum ugll_insert_mode insert_mode
)
12227 struct breakpoint
*b
;
12228 struct bp_location
**locp
, *loc
;
12229 struct cleanup
*cleanups
;
12230 /* Last breakpoint location address that was marked for update. */
12231 CORE_ADDR last_addr
= 0;
12232 /* Last breakpoint location program space that was marked for update. */
12233 int last_pspace_num
= -1;
12235 /* Used in the duplicates detection below. When iterating over all
12236 bp_locations, points to the first bp_location of a given address.
12237 Breakpoints and watchpoints of different types are never
12238 duplicates of each other. Keep one pointer for each type of
12239 breakpoint/watchpoint, so we only need to loop over all locations
12241 struct bp_location
*bp_loc_first
; /* breakpoint */
12242 struct bp_location
*wp_loc_first
; /* hardware watchpoint */
12243 struct bp_location
*awp_loc_first
; /* access watchpoint */
12244 struct bp_location
*rwp_loc_first
; /* read watchpoint */
12246 /* Saved former bp_locations array which we compare against the newly
12247 built bp_locations from the current state of ALL_BREAKPOINTS. */
12248 struct bp_location
**old_locations
, **old_locp
;
12249 unsigned old_locations_count
;
12251 old_locations
= bp_locations
;
12252 old_locations_count
= bp_locations_count
;
12253 bp_locations
= NULL
;
12254 bp_locations_count
= 0;
12255 cleanups
= make_cleanup (xfree
, old_locations
);
12257 ALL_BREAKPOINTS (b
)
12258 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
12259 bp_locations_count
++;
12261 bp_locations
= XNEWVEC (struct bp_location
*, bp_locations_count
);
12262 locp
= bp_locations
;
12263 ALL_BREAKPOINTS (b
)
12264 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
12266 qsort (bp_locations
, bp_locations_count
, sizeof (*bp_locations
),
12267 bp_locations_compare
);
12269 bp_locations_target_extensions_update ();
12271 /* Identify bp_location instances that are no longer present in the
12272 new list, and therefore should be freed. Note that it's not
12273 necessary that those locations should be removed from inferior --
12274 if there's another location at the same address (previously
12275 marked as duplicate), we don't need to remove/insert the
12278 LOCP is kept in sync with OLD_LOCP, each pointing to the current
12279 and former bp_location array state respectively. */
12281 locp
= bp_locations
;
12282 for (old_locp
= old_locations
;
12283 old_locp
< old_locations
+ old_locations_count
;
12286 struct bp_location
*old_loc
= *old_locp
;
12287 struct bp_location
**loc2p
;
12289 /* Tells if 'old_loc' is found among the new locations. If
12290 not, we have to free it. */
12291 int found_object
= 0;
12292 /* Tells if the location should remain inserted in the target. */
12293 int keep_in_target
= 0;
12296 /* Skip LOCP entries which will definitely never be needed.
12297 Stop either at or being the one matching OLD_LOC. */
12298 while (locp
< bp_locations
+ bp_locations_count
12299 && (*locp
)->address
< old_loc
->address
)
12303 (loc2p
< bp_locations
+ bp_locations_count
12304 && (*loc2p
)->address
== old_loc
->address
);
12307 /* Check if this is a new/duplicated location or a duplicated
12308 location that had its condition modified. If so, we want to send
12309 its condition to the target if evaluation of conditions is taking
12311 if ((*loc2p
)->condition_changed
== condition_modified
12312 && (last_addr
!= old_loc
->address
12313 || last_pspace_num
!= old_loc
->pspace
->num
))
12315 force_breakpoint_reinsertion (*loc2p
);
12316 last_pspace_num
= old_loc
->pspace
->num
;
12319 if (*loc2p
== old_loc
)
12323 /* We have already handled this address, update it so that we don't
12324 have to go through updates again. */
12325 last_addr
= old_loc
->address
;
12327 /* Target-side condition evaluation: Handle deleted locations. */
12329 force_breakpoint_reinsertion (old_loc
);
12331 /* If this location is no longer present, and inserted, look if
12332 there's maybe a new location at the same address. If so,
12333 mark that one inserted, and don't remove this one. This is
12334 needed so that we don't have a time window where a breakpoint
12335 at certain location is not inserted. */
12337 if (old_loc
->inserted
)
12339 /* If the location is inserted now, we might have to remove
12342 if (found_object
&& should_be_inserted (old_loc
))
12344 /* The location is still present in the location list,
12345 and still should be inserted. Don't do anything. */
12346 keep_in_target
= 1;
12350 /* This location still exists, but it won't be kept in the
12351 target since it may have been disabled. We proceed to
12352 remove its target-side condition. */
12354 /* The location is either no longer present, or got
12355 disabled. See if there's another location at the
12356 same address, in which case we don't need to remove
12357 this one from the target. */
12359 /* OLD_LOC comes from existing struct breakpoint. */
12360 if (breakpoint_address_is_meaningful (old_loc
->owner
))
12363 (loc2p
< bp_locations
+ bp_locations_count
12364 && (*loc2p
)->address
== old_loc
->address
);
12367 struct bp_location
*loc2
= *loc2p
;
12369 if (breakpoint_locations_match (loc2
, old_loc
))
12371 /* Read watchpoint locations are switched to
12372 access watchpoints, if the former are not
12373 supported, but the latter are. */
12374 if (is_hardware_watchpoint (old_loc
->owner
))
12376 gdb_assert (is_hardware_watchpoint (loc2
->owner
));
12377 loc2
->watchpoint_type
= old_loc
->watchpoint_type
;
12380 /* loc2 is a duplicated location. We need to check
12381 if it should be inserted in case it will be
12383 if (loc2
!= old_loc
12384 && unduplicated_should_be_inserted (loc2
))
12386 swap_insertion (old_loc
, loc2
);
12387 keep_in_target
= 1;
12395 if (!keep_in_target
)
12397 if (remove_breakpoint (old_loc
))
12399 /* This is just about all we can do. We could keep
12400 this location on the global list, and try to
12401 remove it next time, but there's no particular
12402 reason why we will succeed next time.
12404 Note that at this point, old_loc->owner is still
12405 valid, as delete_breakpoint frees the breakpoint
12406 only after calling us. */
12407 printf_filtered (_("warning: Error removing "
12408 "breakpoint %d\n"),
12409 old_loc
->owner
->number
);
12417 if (removed
&& target_is_non_stop_p ()
12418 && need_moribund_for_location_type (old_loc
))
12420 /* This location was removed from the target. In
12421 non-stop mode, a race condition is possible where
12422 we've removed a breakpoint, but stop events for that
12423 breakpoint are already queued and will arrive later.
12424 We apply an heuristic to be able to distinguish such
12425 SIGTRAPs from other random SIGTRAPs: we keep this
12426 breakpoint location for a bit, and will retire it
12427 after we see some number of events. The theory here
12428 is that reporting of events should, "on the average",
12429 be fair, so after a while we'll see events from all
12430 threads that have anything of interest, and no longer
12431 need to keep this breakpoint location around. We
12432 don't hold locations forever so to reduce chances of
12433 mistaking a non-breakpoint SIGTRAP for a breakpoint
12436 The heuristic failing can be disastrous on
12437 decr_pc_after_break targets.
12439 On decr_pc_after_break targets, like e.g., x86-linux,
12440 if we fail to recognize a late breakpoint SIGTRAP,
12441 because events_till_retirement has reached 0 too
12442 soon, we'll fail to do the PC adjustment, and report
12443 a random SIGTRAP to the user. When the user resumes
12444 the inferior, it will most likely immediately crash
12445 with SIGILL/SIGBUS/SIGSEGV, or worse, get silently
12446 corrupted, because of being resumed e.g., in the
12447 middle of a multi-byte instruction, or skipped a
12448 one-byte instruction. This was actually seen happen
12449 on native x86-linux, and should be less rare on
12450 targets that do not support new thread events, like
12451 remote, due to the heuristic depending on
12454 Mistaking a random SIGTRAP for a breakpoint trap
12455 causes similar symptoms (PC adjustment applied when
12456 it shouldn't), but then again, playing with SIGTRAPs
12457 behind the debugger's back is asking for trouble.
12459 Since hardware watchpoint traps are always
12460 distinguishable from other traps, so we don't need to
12461 apply keep hardware watchpoint moribund locations
12462 around. We simply always ignore hardware watchpoint
12463 traps we can no longer explain. */
12465 old_loc
->events_till_retirement
= 3 * (thread_count () + 1);
12466 old_loc
->owner
= NULL
;
12468 VEC_safe_push (bp_location_p
, moribund_locations
, old_loc
);
12472 old_loc
->owner
= NULL
;
12473 decref_bp_location (&old_loc
);
12478 /* Rescan breakpoints at the same address and section, marking the
12479 first one as "first" and any others as "duplicates". This is so
12480 that the bpt instruction is only inserted once. If we have a
12481 permanent breakpoint at the same place as BPT, make that one the
12482 official one, and the rest as duplicates. Permanent breakpoints
12483 are sorted first for the same address.
12485 Do the same for hardware watchpoints, but also considering the
12486 watchpoint's type (regular/access/read) and length. */
12488 bp_loc_first
= NULL
;
12489 wp_loc_first
= NULL
;
12490 awp_loc_first
= NULL
;
12491 rwp_loc_first
= NULL
;
12492 ALL_BP_LOCATIONS (loc
, locp
)
12494 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always
12496 struct bp_location
**loc_first_p
;
12499 if (!unduplicated_should_be_inserted (loc
)
12500 || !breakpoint_address_is_meaningful (b
)
12501 /* Don't detect duplicate for tracepoint locations because they are
12502 never duplicated. See the comments in field `duplicate' of
12503 `struct bp_location'. */
12504 || is_tracepoint (b
))
12506 /* Clear the condition modification flag. */
12507 loc
->condition_changed
= condition_unchanged
;
12511 if (b
->type
== bp_hardware_watchpoint
)
12512 loc_first_p
= &wp_loc_first
;
12513 else if (b
->type
== bp_read_watchpoint
)
12514 loc_first_p
= &rwp_loc_first
;
12515 else if (b
->type
== bp_access_watchpoint
)
12516 loc_first_p
= &awp_loc_first
;
12518 loc_first_p
= &bp_loc_first
;
12520 if (*loc_first_p
== NULL
12521 || (overlay_debugging
&& loc
->section
!= (*loc_first_p
)->section
)
12522 || !breakpoint_locations_match (loc
, *loc_first_p
))
12524 *loc_first_p
= loc
;
12525 loc
->duplicate
= 0;
12527 if (is_breakpoint (loc
->owner
) && loc
->condition_changed
)
12529 loc
->needs_update
= 1;
12530 /* Clear the condition modification flag. */
12531 loc
->condition_changed
= condition_unchanged
;
12537 /* This and the above ensure the invariant that the first location
12538 is not duplicated, and is the inserted one.
12539 All following are marked as duplicated, and are not inserted. */
12541 swap_insertion (loc
, *loc_first_p
);
12542 loc
->duplicate
= 1;
12544 /* Clear the condition modification flag. */
12545 loc
->condition_changed
= condition_unchanged
;
12548 if (insert_mode
== UGLL_INSERT
|| breakpoints_should_be_inserted_now ())
12550 if (insert_mode
!= UGLL_DONT_INSERT
)
12551 insert_breakpoint_locations ();
12554 /* Even though the caller told us to not insert new
12555 locations, we may still need to update conditions on the
12556 target's side of breakpoints that were already inserted
12557 if the target is evaluating breakpoint conditions. We
12558 only update conditions for locations that are marked
12560 update_inserted_breakpoint_locations ();
12564 if (insert_mode
!= UGLL_DONT_INSERT
)
12565 download_tracepoint_locations ();
12567 do_cleanups (cleanups
);
12571 breakpoint_retire_moribund (void)
12573 struct bp_location
*loc
;
12576 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
12577 if (--(loc
->events_till_retirement
) == 0)
12579 decref_bp_location (&loc
);
12580 VEC_unordered_remove (bp_location_p
, moribund_locations
, ix
);
12586 update_global_location_list_nothrow (enum ugll_insert_mode insert_mode
)
12591 update_global_location_list (insert_mode
);
12593 CATCH (e
, RETURN_MASK_ERROR
)
12599 /* Clear BKP from a BPS. */
12602 bpstat_remove_bp_location (bpstat bps
, struct breakpoint
*bpt
)
12606 for (bs
= bps
; bs
; bs
= bs
->next
)
12607 if (bs
->breakpoint_at
== bpt
)
12609 bs
->breakpoint_at
= NULL
;
12610 bs
->old_val
= NULL
;
12611 /* bs->commands will be freed later. */
12615 /* Callback for iterate_over_threads. */
12617 bpstat_remove_breakpoint_callback (struct thread_info
*th
, void *data
)
12619 struct breakpoint
*bpt
= (struct breakpoint
*) data
;
12621 bpstat_remove_bp_location (th
->control
.stop_bpstat
, bpt
);
12625 /* Helper for breakpoint and tracepoint breakpoint_ops->mention
12629 say_where (struct breakpoint
*b
)
12631 struct value_print_options opts
;
12633 get_user_print_options (&opts
);
12635 /* i18n: cagney/2005-02-11: Below needs to be merged into a
12637 if (b
->loc
== NULL
)
12639 /* For pending locations, the output differs slightly based
12640 on b->extra_string. If this is non-NULL, it contains either
12641 a condition or dprintf arguments. */
12642 if (b
->extra_string
== NULL
)
12644 printf_filtered (_(" (%s) pending."),
12645 event_location_to_string (b
->location
.get ()));
12647 else if (b
->type
== bp_dprintf
)
12649 printf_filtered (_(" (%s,%s) pending."),
12650 event_location_to_string (b
->location
.get ()),
12655 printf_filtered (_(" (%s %s) pending."),
12656 event_location_to_string (b
->location
.get ()),
12662 if (opts
.addressprint
|| b
->loc
->symtab
== NULL
)
12664 printf_filtered (" at ");
12665 fputs_filtered (paddress (b
->loc
->gdbarch
, b
->loc
->address
),
12668 if (b
->loc
->symtab
!= NULL
)
12670 /* If there is a single location, we can print the location
12672 if (b
->loc
->next
== NULL
)
12673 printf_filtered (": file %s, line %d.",
12674 symtab_to_filename_for_display (b
->loc
->symtab
),
12675 b
->loc
->line_number
);
12677 /* This is not ideal, but each location may have a
12678 different file name, and this at least reflects the
12679 real situation somewhat. */
12680 printf_filtered (": %s.",
12681 event_location_to_string (b
->location
.get ()));
12686 struct bp_location
*loc
= b
->loc
;
12688 for (; loc
; loc
= loc
->next
)
12690 printf_filtered (" (%d locations)", n
);
12695 /* Default bp_location_ops methods. */
12698 bp_location_dtor (struct bp_location
*self
)
12700 xfree (self
->function_name
);
12703 static const struct bp_location_ops bp_location_ops
=
12708 /* Destructor for the breakpoint base class. */
12710 breakpoint::~breakpoint ()
12712 decref_counted_command_line (&this->commands
);
12713 xfree (this->cond_string
);
12714 xfree (this->extra_string
);
12715 xfree (this->filter
);
12718 static struct bp_location
*
12719 base_breakpoint_allocate_location (struct breakpoint
*self
)
12721 return new bp_location (&bp_location_ops
, self
);
12725 base_breakpoint_re_set (struct breakpoint
*b
)
12727 /* Nothing to re-set. */
12730 #define internal_error_pure_virtual_called() \
12731 gdb_assert_not_reached ("pure virtual function called")
12734 base_breakpoint_insert_location (struct bp_location
*bl
)
12736 internal_error_pure_virtual_called ();
12740 base_breakpoint_remove_location (struct bp_location
*bl
,
12741 enum remove_bp_reason reason
)
12743 internal_error_pure_virtual_called ();
12747 base_breakpoint_breakpoint_hit (const struct bp_location
*bl
,
12748 struct address_space
*aspace
,
12750 const struct target_waitstatus
*ws
)
12752 internal_error_pure_virtual_called ();
12756 base_breakpoint_check_status (bpstat bs
)
12761 /* A "works_in_software_mode" breakpoint_ops method that just internal
12765 base_breakpoint_works_in_software_mode (const struct breakpoint
*b
)
12767 internal_error_pure_virtual_called ();
12770 /* A "resources_needed" breakpoint_ops method that just internal
12774 base_breakpoint_resources_needed (const struct bp_location
*bl
)
12776 internal_error_pure_virtual_called ();
12779 static enum print_stop_action
12780 base_breakpoint_print_it (bpstat bs
)
12782 internal_error_pure_virtual_called ();
12786 base_breakpoint_print_one_detail (const struct breakpoint
*self
,
12787 struct ui_out
*uiout
)
12793 base_breakpoint_print_mention (struct breakpoint
*b
)
12795 internal_error_pure_virtual_called ();
12799 base_breakpoint_print_recreate (struct breakpoint
*b
, struct ui_file
*fp
)
12801 internal_error_pure_virtual_called ();
12805 base_breakpoint_create_sals_from_location
12806 (const struct event_location
*location
,
12807 struct linespec_result
*canonical
,
12808 enum bptype type_wanted
)
12810 internal_error_pure_virtual_called ();
12814 base_breakpoint_create_breakpoints_sal (struct gdbarch
*gdbarch
,
12815 struct linespec_result
*c
,
12816 gdb::unique_xmalloc_ptr
<char> cond_string
,
12817 gdb::unique_xmalloc_ptr
<char> extra_string
,
12818 enum bptype type_wanted
,
12819 enum bpdisp disposition
,
12821 int task
, int ignore_count
,
12822 const struct breakpoint_ops
*o
,
12823 int from_tty
, int enabled
,
12824 int internal
, unsigned flags
)
12826 internal_error_pure_virtual_called ();
12830 base_breakpoint_decode_location (struct breakpoint
*b
,
12831 const struct event_location
*location
,
12832 struct program_space
*search_pspace
,
12833 struct symtabs_and_lines
*sals
)
12835 internal_error_pure_virtual_called ();
12838 /* The default 'explains_signal' method. */
12841 base_breakpoint_explains_signal (struct breakpoint
*b
, enum gdb_signal sig
)
12846 /* The default "after_condition_true" method. */
12849 base_breakpoint_after_condition_true (struct bpstats
*bs
)
12851 /* Nothing to do. */
12854 struct breakpoint_ops base_breakpoint_ops
=
12856 base_breakpoint_allocate_location
,
12857 base_breakpoint_re_set
,
12858 base_breakpoint_insert_location
,
12859 base_breakpoint_remove_location
,
12860 base_breakpoint_breakpoint_hit
,
12861 base_breakpoint_check_status
,
12862 base_breakpoint_resources_needed
,
12863 base_breakpoint_works_in_software_mode
,
12864 base_breakpoint_print_it
,
12866 base_breakpoint_print_one_detail
,
12867 base_breakpoint_print_mention
,
12868 base_breakpoint_print_recreate
,
12869 base_breakpoint_create_sals_from_location
,
12870 base_breakpoint_create_breakpoints_sal
,
12871 base_breakpoint_decode_location
,
12872 base_breakpoint_explains_signal
,
12873 base_breakpoint_after_condition_true
,
12876 /* Default breakpoint_ops methods. */
12879 bkpt_re_set (struct breakpoint
*b
)
12881 /* FIXME: is this still reachable? */
12882 if (breakpoint_event_location_empty_p (b
))
12884 /* Anything without a location can't be re-set. */
12885 delete_breakpoint (b
);
12889 breakpoint_re_set_default (b
);
12893 bkpt_insert_location (struct bp_location
*bl
)
12895 CORE_ADDR addr
= bl
->target_info
.reqstd_address
;
12897 bl
->target_info
.kind
= breakpoint_kind (bl
, &addr
);
12898 bl
->target_info
.placed_address
= addr
;
12900 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
12901 return target_insert_hw_breakpoint (bl
->gdbarch
, &bl
->target_info
);
12903 return target_insert_breakpoint (bl
->gdbarch
, &bl
->target_info
);
12907 bkpt_remove_location (struct bp_location
*bl
, enum remove_bp_reason reason
)
12909 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
12910 return target_remove_hw_breakpoint (bl
->gdbarch
, &bl
->target_info
);
12912 return target_remove_breakpoint (bl
->gdbarch
, &bl
->target_info
, reason
);
12916 bkpt_breakpoint_hit (const struct bp_location
*bl
,
12917 struct address_space
*aspace
, CORE_ADDR bp_addr
,
12918 const struct target_waitstatus
*ws
)
12920 if (ws
->kind
!= TARGET_WAITKIND_STOPPED
12921 || ws
->value
.sig
!= GDB_SIGNAL_TRAP
)
12924 if (!breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
12928 if (overlay_debugging
/* unmapped overlay section */
12929 && section_is_overlay (bl
->section
)
12930 && !section_is_mapped (bl
->section
))
12937 dprintf_breakpoint_hit (const struct bp_location
*bl
,
12938 struct address_space
*aspace
, CORE_ADDR bp_addr
,
12939 const struct target_waitstatus
*ws
)
12941 if (dprintf_style
== dprintf_style_agent
12942 && target_can_run_breakpoint_commands ())
12944 /* An agent-style dprintf never causes a stop. If we see a trap
12945 for this address it must be for a breakpoint that happens to
12946 be set at the same address. */
12950 return bkpt_breakpoint_hit (bl
, aspace
, bp_addr
, ws
);
12954 bkpt_resources_needed (const struct bp_location
*bl
)
12956 gdb_assert (bl
->owner
->type
== bp_hardware_breakpoint
);
12961 static enum print_stop_action
12962 bkpt_print_it (bpstat bs
)
12964 struct breakpoint
*b
;
12965 const struct bp_location
*bl
;
12967 struct ui_out
*uiout
= current_uiout
;
12969 gdb_assert (bs
->bp_location_at
!= NULL
);
12971 bl
= bs
->bp_location_at
;
12972 b
= bs
->breakpoint_at
;
12974 bp_temp
= b
->disposition
== disp_del
;
12975 if (bl
->address
!= bl
->requested_address
)
12976 breakpoint_adjustment_warning (bl
->requested_address
,
12979 annotate_breakpoint (b
->number
);
12980 maybe_print_thread_hit_breakpoint (uiout
);
12983 uiout
->text ("Temporary breakpoint ");
12985 uiout
->text ("Breakpoint ");
12986 if (uiout
->is_mi_like_p ())
12988 uiout
->field_string ("reason",
12989 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
12990 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
12992 uiout
->field_int ("bkptno", b
->number
);
12993 uiout
->text (", ");
12995 return PRINT_SRC_AND_LOC
;
12999 bkpt_print_mention (struct breakpoint
*b
)
13001 if (current_uiout
->is_mi_like_p ())
13006 case bp_breakpoint
:
13007 case bp_gnu_ifunc_resolver
:
13008 if (b
->disposition
== disp_del
)
13009 printf_filtered (_("Temporary breakpoint"));
13011 printf_filtered (_("Breakpoint"));
13012 printf_filtered (_(" %d"), b
->number
);
13013 if (b
->type
== bp_gnu_ifunc_resolver
)
13014 printf_filtered (_(" at gnu-indirect-function resolver"));
13016 case bp_hardware_breakpoint
:
13017 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
13020 printf_filtered (_("Dprintf %d"), b
->number
);
13028 bkpt_print_recreate (struct breakpoint
*tp
, struct ui_file
*fp
)
13030 if (tp
->type
== bp_breakpoint
&& tp
->disposition
== disp_del
)
13031 fprintf_unfiltered (fp
, "tbreak");
13032 else if (tp
->type
== bp_breakpoint
)
13033 fprintf_unfiltered (fp
, "break");
13034 else if (tp
->type
== bp_hardware_breakpoint
13035 && tp
->disposition
== disp_del
)
13036 fprintf_unfiltered (fp
, "thbreak");
13037 else if (tp
->type
== bp_hardware_breakpoint
)
13038 fprintf_unfiltered (fp
, "hbreak");
13040 internal_error (__FILE__
, __LINE__
,
13041 _("unhandled breakpoint type %d"), (int) tp
->type
);
13043 fprintf_unfiltered (fp
, " %s",
13044 event_location_to_string (tp
->location
.get ()));
13046 /* Print out extra_string if this breakpoint is pending. It might
13047 contain, for example, conditions that were set by the user. */
13048 if (tp
->loc
== NULL
&& tp
->extra_string
!= NULL
)
13049 fprintf_unfiltered (fp
, " %s", tp
->extra_string
);
13051 print_recreate_thread (tp
, fp
);
13055 bkpt_create_sals_from_location (const struct event_location
*location
,
13056 struct linespec_result
*canonical
,
13057 enum bptype type_wanted
)
13059 create_sals_from_location_default (location
, canonical
, type_wanted
);
13063 bkpt_create_breakpoints_sal (struct gdbarch
*gdbarch
,
13064 struct linespec_result
*canonical
,
13065 gdb::unique_xmalloc_ptr
<char> cond_string
,
13066 gdb::unique_xmalloc_ptr
<char> extra_string
,
13067 enum bptype type_wanted
,
13068 enum bpdisp disposition
,
13070 int task
, int ignore_count
,
13071 const struct breakpoint_ops
*ops
,
13072 int from_tty
, int enabled
,
13073 int internal
, unsigned flags
)
13075 create_breakpoints_sal_default (gdbarch
, canonical
,
13076 std::move (cond_string
),
13077 std::move (extra_string
),
13079 disposition
, thread
, task
,
13080 ignore_count
, ops
, from_tty
,
13081 enabled
, internal
, flags
);
13085 bkpt_decode_location (struct breakpoint
*b
,
13086 const struct event_location
*location
,
13087 struct program_space
*search_pspace
,
13088 struct symtabs_and_lines
*sals
)
13090 decode_location_default (b
, location
, search_pspace
, sals
);
13093 /* Virtual table for internal breakpoints. */
13096 internal_bkpt_re_set (struct breakpoint
*b
)
13100 /* Delete overlay event and longjmp master breakpoints; they
13101 will be reset later by breakpoint_re_set. */
13102 case bp_overlay_event
:
13103 case bp_longjmp_master
:
13104 case bp_std_terminate_master
:
13105 case bp_exception_master
:
13106 delete_breakpoint (b
);
13109 /* This breakpoint is special, it's set up when the inferior
13110 starts and we really don't want to touch it. */
13111 case bp_shlib_event
:
13113 /* Like bp_shlib_event, this breakpoint type is special. Once
13114 it is set up, we do not want to touch it. */
13115 case bp_thread_event
:
13121 internal_bkpt_check_status (bpstat bs
)
13123 if (bs
->breakpoint_at
->type
== bp_shlib_event
)
13125 /* If requested, stop when the dynamic linker notifies GDB of
13126 events. This allows the user to get control and place
13127 breakpoints in initializer routines for dynamically loaded
13128 objects (among other things). */
13129 bs
->stop
= stop_on_solib_events
;
13130 bs
->print
= stop_on_solib_events
;
13136 static enum print_stop_action
13137 internal_bkpt_print_it (bpstat bs
)
13139 struct breakpoint
*b
;
13141 b
= bs
->breakpoint_at
;
13145 case bp_shlib_event
:
13146 /* Did we stop because the user set the stop_on_solib_events
13147 variable? (If so, we report this as a generic, "Stopped due
13148 to shlib event" message.) */
13149 print_solib_event (0);
13152 case bp_thread_event
:
13153 /* Not sure how we will get here.
13154 GDB should not stop for these breakpoints. */
13155 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
13158 case bp_overlay_event
:
13159 /* By analogy with the thread event, GDB should not stop for these. */
13160 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
13163 case bp_longjmp_master
:
13164 /* These should never be enabled. */
13165 printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
13168 case bp_std_terminate_master
:
13169 /* These should never be enabled. */
13170 printf_filtered (_("std::terminate Master Breakpoint: "
13171 "gdb should not stop!\n"));
13174 case bp_exception_master
:
13175 /* These should never be enabled. */
13176 printf_filtered (_("Exception Master Breakpoint: "
13177 "gdb should not stop!\n"));
13181 return PRINT_NOTHING
;
13185 internal_bkpt_print_mention (struct breakpoint
*b
)
13187 /* Nothing to mention. These breakpoints are internal. */
13190 /* Virtual table for momentary breakpoints */
13193 momentary_bkpt_re_set (struct breakpoint
*b
)
13195 /* Keep temporary breakpoints, which can be encountered when we step
13196 over a dlopen call and solib_add is resetting the breakpoints.
13197 Otherwise these should have been blown away via the cleanup chain
13198 or by breakpoint_init_inferior when we rerun the executable. */
13202 momentary_bkpt_check_status (bpstat bs
)
13204 /* Nothing. The point of these breakpoints is causing a stop. */
13207 static enum print_stop_action
13208 momentary_bkpt_print_it (bpstat bs
)
13210 return PRINT_UNKNOWN
;
13214 momentary_bkpt_print_mention (struct breakpoint
*b
)
13216 /* Nothing to mention. These breakpoints are internal. */
13219 /* Ensure INITIATING_FRAME is cleared when no such breakpoint exists.
13221 It gets cleared already on the removal of the first one of such placed
13222 breakpoints. This is OK as they get all removed altogether. */
13224 longjmp_breakpoint::~longjmp_breakpoint ()
13226 thread_info
*tp
= find_thread_global_id (this->thread
);
13229 tp
->initiating_frame
= null_frame_id
;
13232 /* Specific methods for probe breakpoints. */
13235 bkpt_probe_insert_location (struct bp_location
*bl
)
13237 int v
= bkpt_insert_location (bl
);
13241 /* The insertion was successful, now let's set the probe's semaphore
13243 if (bl
->probe
.probe
->pops
->set_semaphore
!= NULL
)
13244 bl
->probe
.probe
->pops
->set_semaphore (bl
->probe
.probe
,
13253 bkpt_probe_remove_location (struct bp_location
*bl
,
13254 enum remove_bp_reason reason
)
13256 /* Let's clear the semaphore before removing the location. */
13257 if (bl
->probe
.probe
->pops
->clear_semaphore
!= NULL
)
13258 bl
->probe
.probe
->pops
->clear_semaphore (bl
->probe
.probe
,
13262 return bkpt_remove_location (bl
, reason
);
13266 bkpt_probe_create_sals_from_location (const struct event_location
*location
,
13267 struct linespec_result
*canonical
,
13268 enum bptype type_wanted
)
13270 struct linespec_sals lsal
;
13272 lsal
.sals
= parse_probes (location
, NULL
, canonical
);
13274 = xstrdup (event_location_to_string (canonical
->location
.get ()));
13275 VEC_safe_push (linespec_sals
, canonical
->sals
, &lsal
);
13279 bkpt_probe_decode_location (struct breakpoint
*b
,
13280 const struct event_location
*location
,
13281 struct program_space
*search_pspace
,
13282 struct symtabs_and_lines
*sals
)
13284 *sals
= parse_probes (location
, search_pspace
, NULL
);
13286 error (_("probe not found"));
13289 /* The breakpoint_ops structure to be used in tracepoints. */
13292 tracepoint_re_set (struct breakpoint
*b
)
13294 breakpoint_re_set_default (b
);
13298 tracepoint_breakpoint_hit (const struct bp_location
*bl
,
13299 struct address_space
*aspace
, CORE_ADDR bp_addr
,
13300 const struct target_waitstatus
*ws
)
13302 /* By definition, the inferior does not report stops at
13308 tracepoint_print_one_detail (const struct breakpoint
*self
,
13309 struct ui_out
*uiout
)
13311 struct tracepoint
*tp
= (struct tracepoint
*) self
;
13312 if (tp
->static_trace_marker_id
)
13314 gdb_assert (self
->type
== bp_static_tracepoint
);
13316 uiout
->text ("\tmarker id is ");
13317 uiout
->field_string ("static-tracepoint-marker-string-id",
13318 tp
->static_trace_marker_id
);
13319 uiout
->text ("\n");
13324 tracepoint_print_mention (struct breakpoint
*b
)
13326 if (current_uiout
->is_mi_like_p ())
13331 case bp_tracepoint
:
13332 printf_filtered (_("Tracepoint"));
13333 printf_filtered (_(" %d"), b
->number
);
13335 case bp_fast_tracepoint
:
13336 printf_filtered (_("Fast tracepoint"));
13337 printf_filtered (_(" %d"), b
->number
);
13339 case bp_static_tracepoint
:
13340 printf_filtered (_("Static tracepoint"));
13341 printf_filtered (_(" %d"), b
->number
);
13344 internal_error (__FILE__
, __LINE__
,
13345 _("unhandled tracepoint type %d"), (int) b
->type
);
13352 tracepoint_print_recreate (struct breakpoint
*self
, struct ui_file
*fp
)
13354 struct tracepoint
*tp
= (struct tracepoint
*) self
;
13356 if (self
->type
== bp_fast_tracepoint
)
13357 fprintf_unfiltered (fp
, "ftrace");
13358 else if (self
->type
== bp_static_tracepoint
)
13359 fprintf_unfiltered (fp
, "strace");
13360 else if (self
->type
== bp_tracepoint
)
13361 fprintf_unfiltered (fp
, "trace");
13363 internal_error (__FILE__
, __LINE__
,
13364 _("unhandled tracepoint type %d"), (int) self
->type
);
13366 fprintf_unfiltered (fp
, " %s",
13367 event_location_to_string (self
->location
.get ()));
13368 print_recreate_thread (self
, fp
);
13370 if (tp
->pass_count
)
13371 fprintf_unfiltered (fp
, " passcount %d\n", tp
->pass_count
);
13375 tracepoint_create_sals_from_location (const struct event_location
*location
,
13376 struct linespec_result
*canonical
,
13377 enum bptype type_wanted
)
13379 create_sals_from_location_default (location
, canonical
, type_wanted
);
13383 tracepoint_create_breakpoints_sal (struct gdbarch
*gdbarch
,
13384 struct linespec_result
*canonical
,
13385 gdb::unique_xmalloc_ptr
<char> cond_string
,
13386 gdb::unique_xmalloc_ptr
<char> extra_string
,
13387 enum bptype type_wanted
,
13388 enum bpdisp disposition
,
13390 int task
, int ignore_count
,
13391 const struct breakpoint_ops
*ops
,
13392 int from_tty
, int enabled
,
13393 int internal
, unsigned flags
)
13395 create_breakpoints_sal_default (gdbarch
, canonical
,
13396 std::move (cond_string
),
13397 std::move (extra_string
),
13399 disposition
, thread
, task
,
13400 ignore_count
, ops
, from_tty
,
13401 enabled
, internal
, flags
);
13405 tracepoint_decode_location (struct breakpoint
*b
,
13406 const struct event_location
*location
,
13407 struct program_space
*search_pspace
,
13408 struct symtabs_and_lines
*sals
)
13410 decode_location_default (b
, location
, search_pspace
, sals
);
13413 struct breakpoint_ops tracepoint_breakpoint_ops
;
13415 /* The breakpoint_ops structure to be use on tracepoints placed in a
13419 tracepoint_probe_create_sals_from_location
13420 (const struct event_location
*location
,
13421 struct linespec_result
*canonical
,
13422 enum bptype type_wanted
)
13424 /* We use the same method for breakpoint on probes. */
13425 bkpt_probe_create_sals_from_location (location
, canonical
, type_wanted
);
13429 tracepoint_probe_decode_location (struct breakpoint
*b
,
13430 const struct event_location
*location
,
13431 struct program_space
*search_pspace
,
13432 struct symtabs_and_lines
*sals
)
13434 /* We use the same method for breakpoint on probes. */
13435 bkpt_probe_decode_location (b
, location
, search_pspace
, sals
);
13438 static struct breakpoint_ops tracepoint_probe_breakpoint_ops
;
13440 /* Dprintf breakpoint_ops methods. */
13443 dprintf_re_set (struct breakpoint
*b
)
13445 breakpoint_re_set_default (b
);
13447 /* extra_string should never be non-NULL for dprintf. */
13448 gdb_assert (b
->extra_string
!= NULL
);
13450 /* 1 - connect to target 1, that can run breakpoint commands.
13451 2 - create a dprintf, which resolves fine.
13452 3 - disconnect from target 1
13453 4 - connect to target 2, that can NOT run breakpoint commands.
13455 After steps #3/#4, you'll want the dprintf command list to
13456 be updated, because target 1 and 2 may well return different
13457 answers for target_can_run_breakpoint_commands().
13458 Given absence of finer grained resetting, we get to do
13459 it all the time. */
13460 if (b
->extra_string
!= NULL
)
13461 update_dprintf_command_list (b
);
13464 /* Implement the "print_recreate" breakpoint_ops method for dprintf. */
13467 dprintf_print_recreate (struct breakpoint
*tp
, struct ui_file
*fp
)
13469 fprintf_unfiltered (fp
, "dprintf %s,%s",
13470 event_location_to_string (tp
->location
.get ()),
13472 print_recreate_thread (tp
, fp
);
13475 /* Implement the "after_condition_true" breakpoint_ops method for
13478 dprintf's are implemented with regular commands in their command
13479 list, but we run the commands here instead of before presenting the
13480 stop to the user, as dprintf's don't actually cause a stop. This
13481 also makes it so that the commands of multiple dprintfs at the same
13482 address are all handled. */
13485 dprintf_after_condition_true (struct bpstats
*bs
)
13487 struct cleanup
*old_chain
;
13488 struct bpstats tmp_bs
= { NULL
};
13489 struct bpstats
*tmp_bs_p
= &tmp_bs
;
13491 /* dprintf's never cause a stop. This wasn't set in the
13492 check_status hook instead because that would make the dprintf's
13493 condition not be evaluated. */
13496 /* Run the command list here. Take ownership of it instead of
13497 copying. We never want these commands to run later in
13498 bpstat_do_actions, if a breakpoint that causes a stop happens to
13499 be set at same address as this dprintf, or even if running the
13500 commands here throws. */
13501 tmp_bs
.commands
= bs
->commands
;
13502 bs
->commands
= NULL
;
13503 old_chain
= make_cleanup_decref_counted_command_line (&tmp_bs
.commands
);
13505 bpstat_do_actions_1 (&tmp_bs_p
);
13507 /* 'tmp_bs.commands' will usually be NULL by now, but
13508 bpstat_do_actions_1 may return early without processing the whole
13510 do_cleanups (old_chain
);
13513 /* The breakpoint_ops structure to be used on static tracepoints with
13517 strace_marker_create_sals_from_location (const struct event_location
*location
,
13518 struct linespec_result
*canonical
,
13519 enum bptype type_wanted
)
13521 struct linespec_sals lsal
;
13522 const char *arg_start
, *arg
;
13524 struct cleanup
*cleanup
;
13526 arg
= arg_start
= get_linespec_location (location
);
13527 lsal
.sals
= decode_static_tracepoint_spec (&arg
);
13529 str
= savestring (arg_start
, arg
- arg_start
);
13530 cleanup
= make_cleanup (xfree
, str
);
13531 canonical
->location
= new_linespec_location (&str
);
13532 do_cleanups (cleanup
);
13535 = xstrdup (event_location_to_string (canonical
->location
.get ()));
13536 VEC_safe_push (linespec_sals
, canonical
->sals
, &lsal
);
13540 strace_marker_create_breakpoints_sal (struct gdbarch
*gdbarch
,
13541 struct linespec_result
*canonical
,
13542 gdb::unique_xmalloc_ptr
<char> cond_string
,
13543 gdb::unique_xmalloc_ptr
<char> extra_string
,
13544 enum bptype type_wanted
,
13545 enum bpdisp disposition
,
13547 int task
, int ignore_count
,
13548 const struct breakpoint_ops
*ops
,
13549 int from_tty
, int enabled
,
13550 int internal
, unsigned flags
)
13553 struct linespec_sals
*lsal
= VEC_index (linespec_sals
,
13554 canonical
->sals
, 0);
13556 /* If the user is creating a static tracepoint by marker id
13557 (strace -m MARKER_ID), then store the sals index, so that
13558 breakpoint_re_set can try to match up which of the newly
13559 found markers corresponds to this one, and, don't try to
13560 expand multiple locations for each sal, given than SALS
13561 already should contain all sals for MARKER_ID. */
13563 for (i
= 0; i
< lsal
->sals
.nelts
; ++i
)
13565 struct symtabs_and_lines expanded
;
13566 struct tracepoint
*tp
;
13567 event_location_up location
;
13569 expanded
.nelts
= 1;
13570 expanded
.sals
= &lsal
->sals
.sals
[i
];
13572 location
= copy_event_location (canonical
->location
.get ());
13574 tp
= new tracepoint ();
13575 init_breakpoint_sal (tp
, gdbarch
, expanded
,
13576 std::move (location
), NULL
,
13577 std::move (cond_string
),
13578 std::move (extra_string
),
13579 type_wanted
, disposition
,
13580 thread
, task
, ignore_count
, ops
,
13581 from_tty
, enabled
, internal
, flags
,
13582 canonical
->special_display
);
13583 /* Given that its possible to have multiple markers with
13584 the same string id, if the user is creating a static
13585 tracepoint by marker id ("strace -m MARKER_ID"), then
13586 store the sals index, so that breakpoint_re_set can
13587 try to match up which of the newly found markers
13588 corresponds to this one */
13589 tp
->static_trace_marker_id_idx
= i
;
13591 install_breakpoint (internal
, tp
, 0);
13596 strace_marker_decode_location (struct breakpoint
*b
,
13597 const struct event_location
*location
,
13598 struct program_space
*search_pspace
,
13599 struct symtabs_and_lines
*sals
)
13601 struct tracepoint
*tp
= (struct tracepoint
*) b
;
13602 const char *s
= get_linespec_location (location
);
13604 *sals
= decode_static_tracepoint_spec (&s
);
13605 if (sals
->nelts
> tp
->static_trace_marker_id_idx
)
13607 sals
->sals
[0] = sals
->sals
[tp
->static_trace_marker_id_idx
];
13611 error (_("marker %s not found"), tp
->static_trace_marker_id
);
13614 static struct breakpoint_ops strace_marker_breakpoint_ops
;
13617 strace_marker_p (struct breakpoint
*b
)
13619 return b
->ops
== &strace_marker_breakpoint_ops
;
13622 /* Delete a breakpoint and clean up all traces of it in the data
13626 delete_breakpoint (struct breakpoint
*bpt
)
13628 struct breakpoint
*b
;
13630 gdb_assert (bpt
!= NULL
);
13632 /* Has this bp already been deleted? This can happen because
13633 multiple lists can hold pointers to bp's. bpstat lists are
13636 One example of this happening is a watchpoint's scope bp. When
13637 the scope bp triggers, we notice that the watchpoint is out of
13638 scope, and delete it. We also delete its scope bp. But the
13639 scope bp is marked "auto-deleting", and is already on a bpstat.
13640 That bpstat is then checked for auto-deleting bp's, which are
13643 A real solution to this problem might involve reference counts in
13644 bp's, and/or giving them pointers back to their referencing
13645 bpstat's, and teaching delete_breakpoint to only free a bp's
13646 storage when no more references were extent. A cheaper bandaid
13648 if (bpt
->type
== bp_none
)
13651 /* At least avoid this stale reference until the reference counting
13652 of breakpoints gets resolved. */
13653 if (bpt
->related_breakpoint
!= bpt
)
13655 struct breakpoint
*related
;
13656 struct watchpoint
*w
;
13658 if (bpt
->type
== bp_watchpoint_scope
)
13659 w
= (struct watchpoint
*) bpt
->related_breakpoint
;
13660 else if (bpt
->related_breakpoint
->type
== bp_watchpoint_scope
)
13661 w
= (struct watchpoint
*) bpt
;
13665 watchpoint_del_at_next_stop (w
);
13667 /* Unlink bpt from the bpt->related_breakpoint ring. */
13668 for (related
= bpt
; related
->related_breakpoint
!= bpt
;
13669 related
= related
->related_breakpoint
);
13670 related
->related_breakpoint
= bpt
->related_breakpoint
;
13671 bpt
->related_breakpoint
= bpt
;
13674 /* watch_command_1 creates a watchpoint but only sets its number if
13675 update_watchpoint succeeds in creating its bp_locations. If there's
13676 a problem in that process, we'll be asked to delete the half-created
13677 watchpoint. In that case, don't announce the deletion. */
13679 observer_notify_breakpoint_deleted (bpt
);
13681 if (breakpoint_chain
== bpt
)
13682 breakpoint_chain
= bpt
->next
;
13684 ALL_BREAKPOINTS (b
)
13685 if (b
->next
== bpt
)
13687 b
->next
= bpt
->next
;
13691 /* Be sure no bpstat's are pointing at the breakpoint after it's
13693 /* FIXME, how can we find all bpstat's? We just check stop_bpstat
13694 in all threads for now. Note that we cannot just remove bpstats
13695 pointing at bpt from the stop_bpstat list entirely, as breakpoint
13696 commands are associated with the bpstat; if we remove it here,
13697 then the later call to bpstat_do_actions (&stop_bpstat); in
13698 event-top.c won't do anything, and temporary breakpoints with
13699 commands won't work. */
13701 iterate_over_threads (bpstat_remove_breakpoint_callback
, bpt
);
13703 /* Now that breakpoint is removed from breakpoint list, update the
13704 global location list. This will remove locations that used to
13705 belong to this breakpoint. Do this before freeing the breakpoint
13706 itself, since remove_breakpoint looks at location's owner. It
13707 might be better design to have location completely
13708 self-contained, but it's not the case now. */
13709 update_global_location_list (UGLL_DONT_INSERT
);
13711 /* On the chance that someone will soon try again to delete this
13712 same bp, we mark it as deleted before freeing its storage. */
13713 bpt
->type
= bp_none
;
13718 do_delete_breakpoint_cleanup (void *b
)
13720 delete_breakpoint ((struct breakpoint
*) b
);
13724 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
13726 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
13729 /* Iterator function to call a user-provided callback function once
13730 for each of B and its related breakpoints. */
13733 iterate_over_related_breakpoints (struct breakpoint
*b
,
13734 void (*function
) (struct breakpoint
*,
13738 struct breakpoint
*related
;
13743 struct breakpoint
*next
;
13745 /* FUNCTION may delete RELATED. */
13746 next
= related
->related_breakpoint
;
13748 if (next
== related
)
13750 /* RELATED is the last ring entry. */
13751 function (related
, data
);
13753 /* FUNCTION may have deleted it, so we'd never reach back to
13754 B. There's nothing left to do anyway, so just break
13759 function (related
, data
);
13763 while (related
!= b
);
13767 do_delete_breakpoint (struct breakpoint
*b
, void *ignore
)
13769 delete_breakpoint (b
);
13772 /* A callback for map_breakpoint_numbers that calls
13773 delete_breakpoint. */
13776 do_map_delete_breakpoint (struct breakpoint
*b
, void *ignore
)
13778 iterate_over_related_breakpoints (b
, do_delete_breakpoint
, NULL
);
13782 delete_command (char *arg
, int from_tty
)
13784 struct breakpoint
*b
, *b_tmp
;
13790 int breaks_to_delete
= 0;
13792 /* Delete all breakpoints if no argument. Do not delete
13793 internal breakpoints, these have to be deleted with an
13794 explicit breakpoint number argument. */
13795 ALL_BREAKPOINTS (b
)
13796 if (user_breakpoint_p (b
))
13798 breaks_to_delete
= 1;
13802 /* Ask user only if there are some breakpoints to delete. */
13804 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
13806 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
13807 if (user_breakpoint_p (b
))
13808 delete_breakpoint (b
);
13812 map_breakpoint_numbers (arg
, do_map_delete_breakpoint
, NULL
);
13815 /* Return true if all locations of B bound to PSPACE are pending. If
13816 PSPACE is NULL, all locations of all program spaces are
13820 all_locations_are_pending (struct breakpoint
*b
, struct program_space
*pspace
)
13822 struct bp_location
*loc
;
13824 for (loc
= b
->loc
; loc
!= NULL
; loc
= loc
->next
)
13825 if ((pspace
== NULL
13826 || loc
->pspace
== pspace
)
13827 && !loc
->shlib_disabled
13828 && !loc
->pspace
->executing_startup
)
13833 /* Subroutine of update_breakpoint_locations to simplify it.
13834 Return non-zero if multiple fns in list LOC have the same name.
13835 Null names are ignored. */
13838 ambiguous_names_p (struct bp_location
*loc
)
13840 struct bp_location
*l
;
13841 htab_t htab
= htab_create_alloc (13, htab_hash_string
,
13842 (int (*) (const void *,
13843 const void *)) streq
,
13844 NULL
, xcalloc
, xfree
);
13846 for (l
= loc
; l
!= NULL
; l
= l
->next
)
13849 const char *name
= l
->function_name
;
13851 /* Allow for some names to be NULL, ignore them. */
13855 slot
= (const char **) htab_find_slot (htab
, (const void *) name
,
13857 /* NOTE: We can assume slot != NULL here because xcalloc never
13861 htab_delete (htab
);
13867 htab_delete (htab
);
13871 /* When symbols change, it probably means the sources changed as well,
13872 and it might mean the static tracepoint markers are no longer at
13873 the same address or line numbers they used to be at last we
13874 checked. Losing your static tracepoints whenever you rebuild is
13875 undesirable. This function tries to resync/rematch gdb static
13876 tracepoints with the markers on the target, for static tracepoints
13877 that have not been set by marker id. Static tracepoint that have
13878 been set by marker id are reset by marker id in breakpoint_re_set.
13881 1) For a tracepoint set at a specific address, look for a marker at
13882 the old PC. If one is found there, assume to be the same marker.
13883 If the name / string id of the marker found is different from the
13884 previous known name, assume that means the user renamed the marker
13885 in the sources, and output a warning.
13887 2) For a tracepoint set at a given line number, look for a marker
13888 at the new address of the old line number. If one is found there,
13889 assume to be the same marker. If the name / string id of the
13890 marker found is different from the previous known name, assume that
13891 means the user renamed the marker in the sources, and output a
13894 3) If a marker is no longer found at the same address or line, it
13895 may mean the marker no longer exists. But it may also just mean
13896 the code changed a bit. Maybe the user added a few lines of code
13897 that made the marker move up or down (in line number terms). Ask
13898 the target for info about the marker with the string id as we knew
13899 it. If found, update line number and address in the matching
13900 static tracepoint. This will get confused if there's more than one
13901 marker with the same ID (possible in UST, although unadvised
13902 precisely because it confuses tools). */
13904 static struct symtab_and_line
13905 update_static_tracepoint (struct breakpoint
*b
, struct symtab_and_line sal
)
13907 struct tracepoint
*tp
= (struct tracepoint
*) b
;
13908 struct static_tracepoint_marker marker
;
13913 find_line_pc (sal
.symtab
, sal
.line
, &pc
);
13915 if (target_static_tracepoint_marker_at (pc
, &marker
))
13917 if (strcmp (tp
->static_trace_marker_id
, marker
.str_id
) != 0)
13918 warning (_("static tracepoint %d changed probed marker from %s to %s"),
13920 tp
->static_trace_marker_id
, marker
.str_id
);
13922 xfree (tp
->static_trace_marker_id
);
13923 tp
->static_trace_marker_id
= xstrdup (marker
.str_id
);
13924 release_static_tracepoint_marker (&marker
);
13929 /* Old marker wasn't found on target at lineno. Try looking it up
13931 if (!sal
.explicit_pc
13933 && sal
.symtab
!= NULL
13934 && tp
->static_trace_marker_id
!= NULL
)
13936 VEC(static_tracepoint_marker_p
) *markers
;
13939 = target_static_tracepoint_markers_by_strid (tp
->static_trace_marker_id
);
13941 if (!VEC_empty(static_tracepoint_marker_p
, markers
))
13943 struct symtab_and_line sal2
;
13944 struct symbol
*sym
;
13945 struct static_tracepoint_marker
*tpmarker
;
13946 struct ui_out
*uiout
= current_uiout
;
13947 struct explicit_location explicit_loc
;
13949 tpmarker
= VEC_index (static_tracepoint_marker_p
, markers
, 0);
13951 xfree (tp
->static_trace_marker_id
);
13952 tp
->static_trace_marker_id
= xstrdup (tpmarker
->str_id
);
13954 warning (_("marker for static tracepoint %d (%s) not "
13955 "found at previous line number"),
13956 b
->number
, tp
->static_trace_marker_id
);
13960 sal2
.pc
= tpmarker
->address
;
13962 sal2
= find_pc_line (tpmarker
->address
, 0);
13963 sym
= find_pc_sect_function (tpmarker
->address
, NULL
);
13964 uiout
->text ("Now in ");
13967 uiout
->field_string ("func", SYMBOL_PRINT_NAME (sym
));
13968 uiout
->text (" at ");
13970 uiout
->field_string ("file",
13971 symtab_to_filename_for_display (sal2
.symtab
));
13974 if (uiout
->is_mi_like_p ())
13976 const char *fullname
= symtab_to_fullname (sal2
.symtab
);
13978 uiout
->field_string ("fullname", fullname
);
13981 uiout
->field_int ("line", sal2
.line
);
13982 uiout
->text ("\n");
13984 b
->loc
->line_number
= sal2
.line
;
13985 b
->loc
->symtab
= sym
!= NULL
? sal2
.symtab
: NULL
;
13987 b
->location
.reset (NULL
);
13988 initialize_explicit_location (&explicit_loc
);
13989 explicit_loc
.source_filename
13990 = ASTRDUP (symtab_to_filename_for_display (sal2
.symtab
));
13991 explicit_loc
.line_offset
.offset
= b
->loc
->line_number
;
13992 explicit_loc
.line_offset
.sign
= LINE_OFFSET_NONE
;
13993 b
->location
= new_explicit_location (&explicit_loc
);
13995 /* Might be nice to check if function changed, and warn if
13998 release_static_tracepoint_marker (tpmarker
);
14004 /* Returns 1 iff locations A and B are sufficiently same that
14005 we don't need to report breakpoint as changed. */
14008 locations_are_equal (struct bp_location
*a
, struct bp_location
*b
)
14012 if (a
->address
!= b
->address
)
14015 if (a
->shlib_disabled
!= b
->shlib_disabled
)
14018 if (a
->enabled
!= b
->enabled
)
14025 if ((a
== NULL
) != (b
== NULL
))
14031 /* Split all locations of B that are bound to PSPACE out of B's
14032 location list to a separate list and return that list's head. If
14033 PSPACE is NULL, hoist out all locations of B. */
14035 static struct bp_location
*
14036 hoist_existing_locations (struct breakpoint
*b
, struct program_space
*pspace
)
14038 struct bp_location head
;
14039 struct bp_location
*i
= b
->loc
;
14040 struct bp_location
**i_link
= &b
->loc
;
14041 struct bp_location
*hoisted
= &head
;
14043 if (pspace
== NULL
)
14054 if (i
->pspace
== pspace
)
14069 /* Create new breakpoint locations for B (a hardware or software
14070 breakpoint) based on SALS and SALS_END. If SALS_END.NELTS is not
14071 zero, then B is a ranged breakpoint. Only recreates locations for
14072 FILTER_PSPACE. Locations of other program spaces are left
14076 update_breakpoint_locations (struct breakpoint
*b
,
14077 struct program_space
*filter_pspace
,
14078 struct symtabs_and_lines sals
,
14079 struct symtabs_and_lines sals_end
)
14082 struct bp_location
*existing_locations
;
14084 if (sals_end
.nelts
!= 0 && (sals
.nelts
!= 1 || sals_end
.nelts
!= 1))
14086 /* Ranged breakpoints have only one start location and one end
14088 b
->enable_state
= bp_disabled
;
14089 printf_unfiltered (_("Could not reset ranged breakpoint %d: "
14090 "multiple locations found\n"),
14095 /* If there's no new locations, and all existing locations are
14096 pending, don't do anything. This optimizes the common case where
14097 all locations are in the same shared library, that was unloaded.
14098 We'd like to retain the location, so that when the library is
14099 loaded again, we don't loose the enabled/disabled status of the
14100 individual locations. */
14101 if (all_locations_are_pending (b
, filter_pspace
) && sals
.nelts
== 0)
14104 existing_locations
= hoist_existing_locations (b
, filter_pspace
);
14106 for (i
= 0; i
< sals
.nelts
; ++i
)
14108 struct bp_location
*new_loc
;
14110 switch_to_program_space_and_thread (sals
.sals
[i
].pspace
);
14112 new_loc
= add_location_to_breakpoint (b
, &(sals
.sals
[i
]));
14114 /* Reparse conditions, they might contain references to the
14116 if (b
->cond_string
!= NULL
)
14120 s
= b
->cond_string
;
14123 new_loc
->cond
= parse_exp_1 (&s
, sals
.sals
[i
].pc
,
14124 block_for_pc (sals
.sals
[i
].pc
),
14127 CATCH (e
, RETURN_MASK_ERROR
)
14129 warning (_("failed to reevaluate condition "
14130 "for breakpoint %d: %s"),
14131 b
->number
, e
.message
);
14132 new_loc
->enabled
= 0;
14137 if (sals_end
.nelts
)
14139 CORE_ADDR end
= find_breakpoint_range_end (sals_end
.sals
[0]);
14141 new_loc
->length
= end
- sals
.sals
[0].pc
+ 1;
14145 /* If possible, carry over 'disable' status from existing
14148 struct bp_location
*e
= existing_locations
;
14149 /* If there are multiple breakpoints with the same function name,
14150 e.g. for inline functions, comparing function names won't work.
14151 Instead compare pc addresses; this is just a heuristic as things
14152 may have moved, but in practice it gives the correct answer
14153 often enough until a better solution is found. */
14154 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
14156 for (; e
; e
= e
->next
)
14158 if (!e
->enabled
&& e
->function_name
)
14160 struct bp_location
*l
= b
->loc
;
14161 if (have_ambiguous_names
)
14163 for (; l
; l
= l
->next
)
14164 if (breakpoint_locations_match (e
, l
))
14172 for (; l
; l
= l
->next
)
14173 if (l
->function_name
14174 && strcmp (e
->function_name
, l
->function_name
) == 0)
14184 if (!locations_are_equal (existing_locations
, b
->loc
))
14185 observer_notify_breakpoint_modified (b
);
14188 /* Find the SaL locations corresponding to the given LOCATION.
14189 On return, FOUND will be 1 if any SaL was found, zero otherwise. */
14191 static struct symtabs_and_lines
14192 location_to_sals (struct breakpoint
*b
, struct event_location
*location
,
14193 struct program_space
*search_pspace
, int *found
)
14195 struct symtabs_and_lines sals
= {0};
14196 struct gdb_exception exception
= exception_none
;
14198 gdb_assert (b
->ops
!= NULL
);
14202 b
->ops
->decode_location (b
, location
, search_pspace
, &sals
);
14204 CATCH (e
, RETURN_MASK_ERROR
)
14206 int not_found_and_ok
= 0;
14210 /* For pending breakpoints, it's expected that parsing will
14211 fail until the right shared library is loaded. User has
14212 already told to create pending breakpoints and don't need
14213 extra messages. If breakpoint is in bp_shlib_disabled
14214 state, then user already saw the message about that
14215 breakpoint being disabled, and don't want to see more
14217 if (e
.error
== NOT_FOUND_ERROR
14218 && (b
->condition_not_parsed
14220 && search_pspace
!= NULL
14221 && b
->loc
->pspace
!= search_pspace
)
14222 || (b
->loc
&& b
->loc
->shlib_disabled
)
14223 || (b
->loc
&& b
->loc
->pspace
->executing_startup
)
14224 || b
->enable_state
== bp_disabled
))
14225 not_found_and_ok
= 1;
14227 if (!not_found_and_ok
)
14229 /* We surely don't want to warn about the same breakpoint
14230 10 times. One solution, implemented here, is disable
14231 the breakpoint on error. Another solution would be to
14232 have separate 'warning emitted' flag. Since this
14233 happens only when a binary has changed, I don't know
14234 which approach is better. */
14235 b
->enable_state
= bp_disabled
;
14236 throw_exception (e
);
14241 if (exception
.reason
== 0 || exception
.error
!= NOT_FOUND_ERROR
)
14245 for (i
= 0; i
< sals
.nelts
; ++i
)
14246 resolve_sal_pc (&sals
.sals
[i
]);
14247 if (b
->condition_not_parsed
&& b
->extra_string
!= NULL
)
14249 char *cond_string
, *extra_string
;
14252 find_condition_and_thread (b
->extra_string
, sals
.sals
[0].pc
,
14253 &cond_string
, &thread
, &task
,
14255 gdb_assert (b
->cond_string
== NULL
);
14257 b
->cond_string
= cond_string
;
14258 b
->thread
= thread
;
14262 xfree (b
->extra_string
);
14263 b
->extra_string
= extra_string
;
14265 b
->condition_not_parsed
= 0;
14268 if (b
->type
== bp_static_tracepoint
&& !strace_marker_p (b
))
14269 sals
.sals
[0] = update_static_tracepoint (b
, sals
.sals
[0]);
14279 /* The default re_set method, for typical hardware or software
14280 breakpoints. Reevaluate the breakpoint and recreate its
14284 breakpoint_re_set_default (struct breakpoint
*b
)
14287 struct symtabs_and_lines sals
, sals_end
;
14288 struct symtabs_and_lines expanded
= {0};
14289 struct symtabs_and_lines expanded_end
= {0};
14290 struct program_space
*filter_pspace
= current_program_space
;
14292 sals
= location_to_sals (b
, b
->location
.get (), filter_pspace
, &found
);
14295 make_cleanup (xfree
, sals
.sals
);
14299 if (b
->location_range_end
!= NULL
)
14301 sals_end
= location_to_sals (b
, b
->location_range_end
.get (),
14302 filter_pspace
, &found
);
14305 make_cleanup (xfree
, sals_end
.sals
);
14306 expanded_end
= sals_end
;
14310 update_breakpoint_locations (b
, filter_pspace
, expanded
, expanded_end
);
14313 /* Default method for creating SALs from an address string. It basically
14314 calls parse_breakpoint_sals. Return 1 for success, zero for failure. */
14317 create_sals_from_location_default (const struct event_location
*location
,
14318 struct linespec_result
*canonical
,
14319 enum bptype type_wanted
)
14321 parse_breakpoint_sals (location
, canonical
);
14324 /* Call create_breakpoints_sal for the given arguments. This is the default
14325 function for the `create_breakpoints_sal' method of
14329 create_breakpoints_sal_default (struct gdbarch
*gdbarch
,
14330 struct linespec_result
*canonical
,
14331 gdb::unique_xmalloc_ptr
<char> cond_string
,
14332 gdb::unique_xmalloc_ptr
<char> extra_string
,
14333 enum bptype type_wanted
,
14334 enum bpdisp disposition
,
14336 int task
, int ignore_count
,
14337 const struct breakpoint_ops
*ops
,
14338 int from_tty
, int enabled
,
14339 int internal
, unsigned flags
)
14341 create_breakpoints_sal (gdbarch
, canonical
,
14342 std::move (cond_string
),
14343 std::move (extra_string
),
14344 type_wanted
, disposition
,
14345 thread
, task
, ignore_count
, ops
, from_tty
,
14346 enabled
, internal
, flags
);
14349 /* Decode the line represented by S by calling decode_line_full. This is the
14350 default function for the `decode_location' method of breakpoint_ops. */
14353 decode_location_default (struct breakpoint
*b
,
14354 const struct event_location
*location
,
14355 struct program_space
*search_pspace
,
14356 struct symtabs_and_lines
*sals
)
14358 struct linespec_result canonical
;
14360 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, search_pspace
,
14361 (struct symtab
*) NULL
, 0,
14362 &canonical
, multiple_symbols_all
,
14365 /* We should get 0 or 1 resulting SALs. */
14366 gdb_assert (VEC_length (linespec_sals
, canonical
.sals
) < 2);
14368 if (VEC_length (linespec_sals
, canonical
.sals
) > 0)
14370 struct linespec_sals
*lsal
;
14372 lsal
= VEC_index (linespec_sals
, canonical
.sals
, 0);
14373 *sals
= lsal
->sals
;
14374 /* Arrange it so the destructor does not free the
14376 lsal
->sals
.sals
= NULL
;
14380 /* Prepare the global context for a re-set of breakpoint B. */
14382 static struct cleanup
*
14383 prepare_re_set_context (struct breakpoint
*b
)
14385 input_radix
= b
->input_radix
;
14386 set_language (b
->language
);
14388 return make_cleanup (null_cleanup
, NULL
);
14391 /* Reset a breakpoint given it's struct breakpoint * BINT.
14392 The value we return ends up being the return value from catch_errors.
14393 Unused in this case. */
14396 breakpoint_re_set_one (void *bint
)
14398 /* Get past catch_errs. */
14399 struct breakpoint
*b
= (struct breakpoint
*) bint
;
14400 struct cleanup
*cleanups
;
14402 cleanups
= prepare_re_set_context (b
);
14403 b
->ops
->re_set (b
);
14404 do_cleanups (cleanups
);
14408 /* Re-set breakpoint locations for the current program space.
14409 Locations bound to other program spaces are left untouched. */
14412 breakpoint_re_set (void)
14414 struct breakpoint
*b
, *b_tmp
;
14415 enum language save_language
;
14416 int save_input_radix
;
14418 save_language
= current_language
->la_language
;
14419 save_input_radix
= input_radix
;
14422 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
14424 /* Note: we must not try to insert locations until after all
14425 breakpoints have been re-set. Otherwise, e.g., when re-setting
14426 breakpoint 1, we'd insert the locations of breakpoint 2, which
14427 hadn't been re-set yet, and thus may have stale locations. */
14429 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
14431 /* Format possible error msg. */
14432 char *message
= xstrprintf ("Error in re-setting breakpoint %d: ",
14434 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
14435 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
14436 do_cleanups (cleanups
);
14438 set_language (save_language
);
14439 input_radix
= save_input_radix
;
14441 jit_breakpoint_re_set ();
14444 create_overlay_event_breakpoint ();
14445 create_longjmp_master_breakpoint ();
14446 create_std_terminate_master_breakpoint ();
14447 create_exception_master_breakpoint ();
14449 /* Now we can insert. */
14450 update_global_location_list (UGLL_MAY_INSERT
);
14453 /* Reset the thread number of this breakpoint:
14455 - If the breakpoint is for all threads, leave it as-is.
14456 - Else, reset it to the current thread for inferior_ptid. */
14458 breakpoint_re_set_thread (struct breakpoint
*b
)
14460 if (b
->thread
!= -1)
14462 if (in_thread_list (inferior_ptid
))
14463 b
->thread
= ptid_to_global_thread_id (inferior_ptid
);
14465 /* We're being called after following a fork. The new fork is
14466 selected as current, and unless this was a vfork will have a
14467 different program space from the original thread. Reset that
14469 b
->loc
->pspace
= current_program_space
;
14473 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14474 If from_tty is nonzero, it prints a message to that effect,
14475 which ends with a period (no newline). */
14478 set_ignore_count (int bptnum
, int count
, int from_tty
)
14480 struct breakpoint
*b
;
14485 ALL_BREAKPOINTS (b
)
14486 if (b
->number
== bptnum
)
14488 if (is_tracepoint (b
))
14490 if (from_tty
&& count
!= 0)
14491 printf_filtered (_("Ignore count ignored for tracepoint %d."),
14496 b
->ignore_count
= count
;
14500 printf_filtered (_("Will stop next time "
14501 "breakpoint %d is reached."),
14503 else if (count
== 1)
14504 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
14507 printf_filtered (_("Will ignore next %d "
14508 "crossings of breakpoint %d."),
14511 observer_notify_breakpoint_modified (b
);
14515 error (_("No breakpoint number %d."), bptnum
);
14518 /* Command to set ignore-count of breakpoint N to COUNT. */
14521 ignore_command (char *args
, int from_tty
)
14527 error_no_arg (_("a breakpoint number"));
14529 num
= get_number (&p
);
14531 error (_("bad breakpoint number: '%s'"), args
);
14533 error (_("Second argument (specified ignore-count) is missing."));
14535 set_ignore_count (num
,
14536 longest_to_int (value_as_long (parse_and_eval (p
))),
14539 printf_filtered ("\n");
14542 /* Call FUNCTION on each of the breakpoints
14543 whose numbers are given in ARGS. */
14546 map_breakpoint_numbers (const char *args
,
14547 void (*function
) (struct breakpoint
*,
14552 struct breakpoint
*b
, *tmp
;
14554 if (args
== 0 || *args
== '\0')
14555 error_no_arg (_("one or more breakpoint numbers"));
14557 number_or_range_parser
parser (args
);
14559 while (!parser
.finished ())
14561 const char *p
= parser
.cur_tok ();
14562 bool match
= false;
14564 num
= parser
.get_number ();
14567 warning (_("bad breakpoint number at or near '%s'"), p
);
14571 ALL_BREAKPOINTS_SAFE (b
, tmp
)
14572 if (b
->number
== num
)
14575 function (b
, data
);
14579 printf_unfiltered (_("No breakpoint number %d.\n"), num
);
14584 static struct bp_location
*
14585 find_location_by_number (char *number
)
14587 char *dot
= strchr (number
, '.');
14591 struct breakpoint
*b
;
14592 struct bp_location
*loc
;
14597 bp_num
= get_number (&p1
);
14599 error (_("Bad breakpoint number '%s'"), number
);
14601 ALL_BREAKPOINTS (b
)
14602 if (b
->number
== bp_num
)
14607 if (!b
|| b
->number
!= bp_num
)
14608 error (_("Bad breakpoint number '%s'"), number
);
14611 loc_num
= get_number (&p1
);
14613 error (_("Bad breakpoint location number '%s'"), number
);
14617 for (;loc_num
&& loc
; --loc_num
, loc
= loc
->next
)
14620 error (_("Bad breakpoint location number '%s'"), dot
+1);
14626 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14627 If from_tty is nonzero, it prints a message to that effect,
14628 which ends with a period (no newline). */
14631 disable_breakpoint (struct breakpoint
*bpt
)
14633 /* Never disable a watchpoint scope breakpoint; we want to
14634 hit them when we leave scope so we can delete both the
14635 watchpoint and its scope breakpoint at that time. */
14636 if (bpt
->type
== bp_watchpoint_scope
)
14639 bpt
->enable_state
= bp_disabled
;
14641 /* Mark breakpoint locations modified. */
14642 mark_breakpoint_modified (bpt
);
14644 if (target_supports_enable_disable_tracepoint ()
14645 && current_trace_status ()->running
&& is_tracepoint (bpt
))
14647 struct bp_location
*location
;
14649 for (location
= bpt
->loc
; location
; location
= location
->next
)
14650 target_disable_tracepoint (location
);
14653 update_global_location_list (UGLL_DONT_INSERT
);
14655 observer_notify_breakpoint_modified (bpt
);
14658 /* A callback for iterate_over_related_breakpoints. */
14661 do_disable_breakpoint (struct breakpoint
*b
, void *ignore
)
14663 disable_breakpoint (b
);
14666 /* A callback for map_breakpoint_numbers that calls
14667 disable_breakpoint. */
14670 do_map_disable_breakpoint (struct breakpoint
*b
, void *ignore
)
14672 iterate_over_related_breakpoints (b
, do_disable_breakpoint
, NULL
);
14676 disable_command (char *args
, int from_tty
)
14680 struct breakpoint
*bpt
;
14682 ALL_BREAKPOINTS (bpt
)
14683 if (user_breakpoint_p (bpt
))
14684 disable_breakpoint (bpt
);
14688 char *num
= extract_arg (&args
);
14692 if (strchr (num
, '.'))
14694 struct bp_location
*loc
= find_location_by_number (num
);
14701 mark_breakpoint_location_modified (loc
);
14703 if (target_supports_enable_disable_tracepoint ()
14704 && current_trace_status ()->running
&& loc
->owner
14705 && is_tracepoint (loc
->owner
))
14706 target_disable_tracepoint (loc
);
14708 update_global_location_list (UGLL_DONT_INSERT
);
14711 map_breakpoint_numbers (num
, do_map_disable_breakpoint
, NULL
);
14712 num
= extract_arg (&args
);
14718 enable_breakpoint_disp (struct breakpoint
*bpt
, enum bpdisp disposition
,
14721 int target_resources_ok
;
14723 if (bpt
->type
== bp_hardware_breakpoint
)
14726 i
= hw_breakpoint_used_count ();
14727 target_resources_ok
=
14728 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
14730 if (target_resources_ok
== 0)
14731 error (_("No hardware breakpoint support in the target."));
14732 else if (target_resources_ok
< 0)
14733 error (_("Hardware breakpoints used exceeds limit."));
14736 if (is_watchpoint (bpt
))
14738 /* Initialize it just to avoid a GCC false warning. */
14739 enum enable_state orig_enable_state
= bp_disabled
;
14743 struct watchpoint
*w
= (struct watchpoint
*) bpt
;
14745 orig_enable_state
= bpt
->enable_state
;
14746 bpt
->enable_state
= bp_enabled
;
14747 update_watchpoint (w
, 1 /* reparse */);
14749 CATCH (e
, RETURN_MASK_ALL
)
14751 bpt
->enable_state
= orig_enable_state
;
14752 exception_fprintf (gdb_stderr
, e
, _("Cannot enable watchpoint %d: "),
14759 bpt
->enable_state
= bp_enabled
;
14761 /* Mark breakpoint locations modified. */
14762 mark_breakpoint_modified (bpt
);
14764 if (target_supports_enable_disable_tracepoint ()
14765 && current_trace_status ()->running
&& is_tracepoint (bpt
))
14767 struct bp_location
*location
;
14769 for (location
= bpt
->loc
; location
; location
= location
->next
)
14770 target_enable_tracepoint (location
);
14773 bpt
->disposition
= disposition
;
14774 bpt
->enable_count
= count
;
14775 update_global_location_list (UGLL_MAY_INSERT
);
14777 observer_notify_breakpoint_modified (bpt
);
14782 enable_breakpoint (struct breakpoint
*bpt
)
14784 enable_breakpoint_disp (bpt
, bpt
->disposition
, 0);
14788 do_enable_breakpoint (struct breakpoint
*bpt
, void *arg
)
14790 enable_breakpoint (bpt
);
14793 /* A callback for map_breakpoint_numbers that calls
14794 enable_breakpoint. */
14797 do_map_enable_breakpoint (struct breakpoint
*b
, void *ignore
)
14799 iterate_over_related_breakpoints (b
, do_enable_breakpoint
, NULL
);
14802 /* The enable command enables the specified breakpoints (or all defined
14803 breakpoints) so they once again become (or continue to be) effective
14804 in stopping the inferior. */
14807 enable_command (char *args
, int from_tty
)
14811 struct breakpoint
*bpt
;
14813 ALL_BREAKPOINTS (bpt
)
14814 if (user_breakpoint_p (bpt
))
14815 enable_breakpoint (bpt
);
14819 char *num
= extract_arg (&args
);
14823 if (strchr (num
, '.'))
14825 struct bp_location
*loc
= find_location_by_number (num
);
14832 mark_breakpoint_location_modified (loc
);
14834 if (target_supports_enable_disable_tracepoint ()
14835 && current_trace_status ()->running
&& loc
->owner
14836 && is_tracepoint (loc
->owner
))
14837 target_enable_tracepoint (loc
);
14839 update_global_location_list (UGLL_MAY_INSERT
);
14842 map_breakpoint_numbers (num
, do_map_enable_breakpoint
, NULL
);
14843 num
= extract_arg (&args
);
14848 /* This struct packages up disposition data for application to multiple
14858 do_enable_breakpoint_disp (struct breakpoint
*bpt
, void *arg
)
14860 struct disp_data disp_data
= *(struct disp_data
*) arg
;
14862 enable_breakpoint_disp (bpt
, disp_data
.disp
, disp_data
.count
);
14866 do_map_enable_once_breakpoint (struct breakpoint
*bpt
, void *ignore
)
14868 struct disp_data disp
= { disp_disable
, 1 };
14870 iterate_over_related_breakpoints (bpt
, do_enable_breakpoint_disp
, &disp
);
14874 enable_once_command (char *args
, int from_tty
)
14876 map_breakpoint_numbers (args
, do_map_enable_once_breakpoint
, NULL
);
14880 do_map_enable_count_breakpoint (struct breakpoint
*bpt
, void *countptr
)
14882 struct disp_data disp
= { disp_disable
, *(int *) countptr
};
14884 iterate_over_related_breakpoints (bpt
, do_enable_breakpoint_disp
, &disp
);
14888 enable_count_command (char *args
, int from_tty
)
14893 error_no_arg (_("hit count"));
14895 count
= get_number (&args
);
14897 map_breakpoint_numbers (args
, do_map_enable_count_breakpoint
, &count
);
14901 do_map_enable_delete_breakpoint (struct breakpoint
*bpt
, void *ignore
)
14903 struct disp_data disp
= { disp_del
, 1 };
14905 iterate_over_related_breakpoints (bpt
, do_enable_breakpoint_disp
, &disp
);
14909 enable_delete_command (char *args
, int from_tty
)
14911 map_breakpoint_numbers (args
, do_map_enable_delete_breakpoint
, NULL
);
14915 set_breakpoint_cmd (char *args
, int from_tty
)
14920 show_breakpoint_cmd (char *args
, int from_tty
)
14924 /* Invalidate last known value of any hardware watchpoint if
14925 the memory which that value represents has been written to by
14929 invalidate_bp_value_on_memory_change (struct inferior
*inferior
,
14930 CORE_ADDR addr
, ssize_t len
,
14931 const bfd_byte
*data
)
14933 struct breakpoint
*bp
;
14935 ALL_BREAKPOINTS (bp
)
14936 if (bp
->enable_state
== bp_enabled
14937 && bp
->type
== bp_hardware_watchpoint
)
14939 struct watchpoint
*wp
= (struct watchpoint
*) bp
;
14941 if (wp
->val_valid
&& wp
->val
)
14943 struct bp_location
*loc
;
14945 for (loc
= bp
->loc
; loc
!= NULL
; loc
= loc
->next
)
14946 if (loc
->loc_type
== bp_loc_hardware_watchpoint
14947 && loc
->address
+ loc
->length
> addr
14948 && addr
+ len
> loc
->address
)
14950 value_free (wp
->val
);
14958 /* Create and insert a breakpoint for software single step. */
14961 insert_single_step_breakpoint (struct gdbarch
*gdbarch
,
14962 struct address_space
*aspace
,
14965 struct thread_info
*tp
= inferior_thread ();
14966 struct symtab_and_line sal
;
14967 CORE_ADDR pc
= next_pc
;
14969 if (tp
->control
.single_step_breakpoints
== NULL
)
14971 tp
->control
.single_step_breakpoints
14972 = new_single_step_breakpoint (tp
->global_num
, gdbarch
);
14975 sal
= find_pc_line (pc
, 0);
14977 sal
.section
= find_pc_overlay (pc
);
14978 sal
.explicit_pc
= 1;
14979 add_location_to_breakpoint (tp
->control
.single_step_breakpoints
, &sal
);
14981 update_global_location_list (UGLL_INSERT
);
14984 /* Insert single step breakpoints according to the current state. */
14987 insert_single_step_breakpoints (struct gdbarch
*gdbarch
)
14989 struct regcache
*regcache
= get_current_regcache ();
14990 std::vector
<CORE_ADDR
> next_pcs
;
14992 next_pcs
= gdbarch_software_single_step (gdbarch
, regcache
);
14994 if (!next_pcs
.empty ())
14996 struct frame_info
*frame
= get_current_frame ();
14997 struct address_space
*aspace
= get_frame_address_space (frame
);
14999 for (CORE_ADDR pc
: next_pcs
)
15000 insert_single_step_breakpoint (gdbarch
, aspace
, pc
);
15008 /* See breakpoint.h. */
15011 breakpoint_has_location_inserted_here (struct breakpoint
*bp
,
15012 struct address_space
*aspace
,
15015 struct bp_location
*loc
;
15017 for (loc
= bp
->loc
; loc
!= NULL
; loc
= loc
->next
)
15019 && breakpoint_location_address_match (loc
, aspace
, pc
))
15025 /* Check whether a software single-step breakpoint is inserted at
15029 single_step_breakpoint_inserted_here_p (struct address_space
*aspace
,
15032 struct breakpoint
*bpt
;
15034 ALL_BREAKPOINTS (bpt
)
15036 if (bpt
->type
== bp_single_step
15037 && breakpoint_has_location_inserted_here (bpt
, aspace
, pc
))
15043 /* Tracepoint-specific operations. */
15045 /* Set tracepoint count to NUM. */
15047 set_tracepoint_count (int num
)
15049 tracepoint_count
= num
;
15050 set_internalvar_integer (lookup_internalvar ("tpnum"), num
);
15054 trace_command (char *arg
, int from_tty
)
15056 struct breakpoint_ops
*ops
;
15058 event_location_up location
= string_to_event_location (&arg
,
15060 if (location
!= NULL
15061 && event_location_type (location
.get ()) == PROBE_LOCATION
)
15062 ops
= &tracepoint_probe_breakpoint_ops
;
15064 ops
= &tracepoint_breakpoint_ops
;
15066 create_breakpoint (get_current_arch (),
15068 NULL
, 0, arg
, 1 /* parse arg */,
15070 bp_tracepoint
/* type_wanted */,
15071 0 /* Ignore count */,
15072 pending_break_support
,
15076 0 /* internal */, 0);
15080 ftrace_command (char *arg
, int from_tty
)
15082 event_location_up location
= string_to_event_location (&arg
,
15084 create_breakpoint (get_current_arch (),
15086 NULL
, 0, arg
, 1 /* parse arg */,
15088 bp_fast_tracepoint
/* type_wanted */,
15089 0 /* Ignore count */,
15090 pending_break_support
,
15091 &tracepoint_breakpoint_ops
,
15094 0 /* internal */, 0);
15097 /* strace command implementation. Creates a static tracepoint. */
15100 strace_command (char *arg
, int from_tty
)
15102 struct breakpoint_ops
*ops
;
15103 event_location_up location
;
15104 struct cleanup
*back_to
;
15106 /* Decide if we are dealing with a static tracepoint marker (`-m'),
15107 or with a normal static tracepoint. */
15108 if (arg
&& startswith (arg
, "-m") && isspace (arg
[2]))
15110 ops
= &strace_marker_breakpoint_ops
;
15111 location
= new_linespec_location (&arg
);
15115 ops
= &tracepoint_breakpoint_ops
;
15116 location
= string_to_event_location (&arg
, current_language
);
15119 create_breakpoint (get_current_arch (),
15121 NULL
, 0, arg
, 1 /* parse arg */,
15123 bp_static_tracepoint
/* type_wanted */,
15124 0 /* Ignore count */,
15125 pending_break_support
,
15129 0 /* internal */, 0);
15132 /* Set up a fake reader function that gets command lines from a linked
15133 list that was acquired during tracepoint uploading. */
15135 static struct uploaded_tp
*this_utp
;
15136 static int next_cmd
;
15139 read_uploaded_action (void)
15143 VEC_iterate (char_ptr
, this_utp
->cmd_strings
, next_cmd
, rslt
);
15150 /* Given information about a tracepoint as recorded on a target (which
15151 can be either a live system or a trace file), attempt to create an
15152 equivalent GDB tracepoint. This is not a reliable process, since
15153 the target does not necessarily have all the information used when
15154 the tracepoint was originally defined. */
15156 struct tracepoint
*
15157 create_tracepoint_from_upload (struct uploaded_tp
*utp
)
15159 char *addr_str
, small_buf
[100];
15160 struct tracepoint
*tp
;
15162 if (utp
->at_string
)
15163 addr_str
= utp
->at_string
;
15166 /* In the absence of a source location, fall back to raw
15167 address. Since there is no way to confirm that the address
15168 means the same thing as when the trace was started, warn the
15170 warning (_("Uploaded tracepoint %d has no "
15171 "source location, using raw address"),
15173 xsnprintf (small_buf
, sizeof (small_buf
), "*%s", hex_string (utp
->addr
));
15174 addr_str
= small_buf
;
15177 /* There's not much we can do with a sequence of bytecodes. */
15178 if (utp
->cond
&& !utp
->cond_string
)
15179 warning (_("Uploaded tracepoint %d condition "
15180 "has no source form, ignoring it"),
15183 event_location_up location
= string_to_event_location (&addr_str
,
15185 if (!create_breakpoint (get_current_arch (),
15187 utp
->cond_string
, -1, addr_str
,
15188 0 /* parse cond/thread */,
15190 utp
->type
/* type_wanted */,
15191 0 /* Ignore count */,
15192 pending_break_support
,
15193 &tracepoint_breakpoint_ops
,
15195 utp
->enabled
/* enabled */,
15197 CREATE_BREAKPOINT_FLAGS_INSERTED
))
15200 /* Get the tracepoint we just created. */
15201 tp
= get_tracepoint (tracepoint_count
);
15202 gdb_assert (tp
!= NULL
);
15206 xsnprintf (small_buf
, sizeof (small_buf
), "%d %d", utp
->pass
,
15209 trace_pass_command (small_buf
, 0);
15212 /* If we have uploaded versions of the original commands, set up a
15213 special-purpose "reader" function and call the usual command line
15214 reader, then pass the result to the breakpoint command-setting
15216 if (!VEC_empty (char_ptr
, utp
->cmd_strings
))
15218 command_line_up cmd_list
;
15223 cmd_list
= read_command_lines_1 (read_uploaded_action
, 1, NULL
, NULL
);
15225 breakpoint_set_commands (tp
, std::move (cmd_list
));
15227 else if (!VEC_empty (char_ptr
, utp
->actions
)
15228 || !VEC_empty (char_ptr
, utp
->step_actions
))
15229 warning (_("Uploaded tracepoint %d actions "
15230 "have no source form, ignoring them"),
15233 /* Copy any status information that might be available. */
15234 tp
->hit_count
= utp
->hit_count
;
15235 tp
->traceframe_usage
= utp
->traceframe_usage
;
15240 /* Print information on tracepoint number TPNUM_EXP, or all if
15244 tracepoints_info (char *args
, int from_tty
)
15246 struct ui_out
*uiout
= current_uiout
;
15249 num_printed
= breakpoint_1 (args
, 0, is_tracepoint
);
15251 if (num_printed
== 0)
15253 if (args
== NULL
|| *args
== '\0')
15254 uiout
->message ("No tracepoints.\n");
15256 uiout
->message ("No tracepoint matching '%s'.\n", args
);
15259 default_collect_info ();
15262 /* The 'enable trace' command enables tracepoints.
15263 Not supported by all targets. */
15265 enable_trace_command (char *args
, int from_tty
)
15267 enable_command (args
, from_tty
);
15270 /* The 'disable trace' command disables tracepoints.
15271 Not supported by all targets. */
15273 disable_trace_command (char *args
, int from_tty
)
15275 disable_command (args
, from_tty
);
15278 /* Remove a tracepoint (or all if no argument). */
15280 delete_trace_command (char *arg
, int from_tty
)
15282 struct breakpoint
*b
, *b_tmp
;
15288 int breaks_to_delete
= 0;
15290 /* Delete all breakpoints if no argument.
15291 Do not delete internal or call-dummy breakpoints, these
15292 have to be deleted with an explicit breakpoint number
15294 ALL_TRACEPOINTS (b
)
15295 if (is_tracepoint (b
) && user_breakpoint_p (b
))
15297 breaks_to_delete
= 1;
15301 /* Ask user only if there are some breakpoints to delete. */
15303 || (breaks_to_delete
&& query (_("Delete all tracepoints? "))))
15305 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
15306 if (is_tracepoint (b
) && user_breakpoint_p (b
))
15307 delete_breakpoint (b
);
15311 map_breakpoint_numbers (arg
, do_map_delete_breakpoint
, NULL
);
15314 /* Helper function for trace_pass_command. */
15317 trace_pass_set_count (struct tracepoint
*tp
, int count
, int from_tty
)
15319 tp
->pass_count
= count
;
15320 observer_notify_breakpoint_modified (tp
);
15322 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
15323 tp
->number
, count
);
15326 /* Set passcount for tracepoint.
15328 First command argument is passcount, second is tracepoint number.
15329 If tracepoint number omitted, apply to most recently defined.
15330 Also accepts special argument "all". */
15333 trace_pass_command (char *args
, int from_tty
)
15335 struct tracepoint
*t1
;
15336 unsigned int count
;
15338 if (args
== 0 || *args
== 0)
15339 error (_("passcount command requires an "
15340 "argument (count + optional TP num)"));
15342 count
= strtoul (args
, &args
, 10); /* Count comes first, then TP num. */
15344 args
= skip_spaces (args
);
15345 if (*args
&& strncasecmp (args
, "all", 3) == 0)
15347 struct breakpoint
*b
;
15349 args
+= 3; /* Skip special argument "all". */
15351 error (_("Junk at end of arguments."));
15353 ALL_TRACEPOINTS (b
)
15355 t1
= (struct tracepoint
*) b
;
15356 trace_pass_set_count (t1
, count
, from_tty
);
15359 else if (*args
== '\0')
15361 t1
= get_tracepoint_by_number (&args
, NULL
);
15363 trace_pass_set_count (t1
, count
, from_tty
);
15367 number_or_range_parser
parser (args
);
15368 while (!parser
.finished ())
15370 t1
= get_tracepoint_by_number (&args
, &parser
);
15372 trace_pass_set_count (t1
, count
, from_tty
);
15377 struct tracepoint
*
15378 get_tracepoint (int num
)
15380 struct breakpoint
*t
;
15382 ALL_TRACEPOINTS (t
)
15383 if (t
->number
== num
)
15384 return (struct tracepoint
*) t
;
15389 /* Find the tracepoint with the given target-side number (which may be
15390 different from the tracepoint number after disconnecting and
15393 struct tracepoint
*
15394 get_tracepoint_by_number_on_target (int num
)
15396 struct breakpoint
*b
;
15398 ALL_TRACEPOINTS (b
)
15400 struct tracepoint
*t
= (struct tracepoint
*) b
;
15402 if (t
->number_on_target
== num
)
15409 /* Utility: parse a tracepoint number and look it up in the list.
15410 If STATE is not NULL, use, get_number_or_range_state and ignore ARG.
15411 If the argument is missing, the most recent tracepoint
15412 (tracepoint_count) is returned. */
15414 struct tracepoint
*
15415 get_tracepoint_by_number (char **arg
,
15416 number_or_range_parser
*parser
)
15418 struct breakpoint
*t
;
15420 char *instring
= arg
== NULL
? NULL
: *arg
;
15422 if (parser
!= NULL
)
15424 gdb_assert (!parser
->finished ());
15425 tpnum
= parser
->get_number ();
15427 else if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
15428 tpnum
= tracepoint_count
;
15430 tpnum
= get_number (arg
);
15434 if (instring
&& *instring
)
15435 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
15438 printf_filtered (_("No previous tracepoint\n"));
15442 ALL_TRACEPOINTS (t
)
15443 if (t
->number
== tpnum
)
15445 return (struct tracepoint
*) t
;
15448 printf_unfiltered ("No tracepoint number %d.\n", tpnum
);
15453 print_recreate_thread (struct breakpoint
*b
, struct ui_file
*fp
)
15455 if (b
->thread
!= -1)
15456 fprintf_unfiltered (fp
, " thread %d", b
->thread
);
15459 fprintf_unfiltered (fp
, " task %d", b
->task
);
15461 fprintf_unfiltered (fp
, "\n");
15464 /* Save information on user settable breakpoints (watchpoints, etc) to
15465 a new script file named FILENAME. If FILTER is non-NULL, call it
15466 on each breakpoint and only include the ones for which it returns
15470 save_breakpoints (char *filename
, int from_tty
,
15471 int (*filter
) (const struct breakpoint
*))
15473 struct breakpoint
*tp
;
15475 int extra_trace_bits
= 0;
15477 if (filename
== 0 || *filename
== 0)
15478 error (_("Argument required (file name in which to save)"));
15480 /* See if we have anything to save. */
15481 ALL_BREAKPOINTS (tp
)
15483 /* Skip internal and momentary breakpoints. */
15484 if (!user_breakpoint_p (tp
))
15487 /* If we have a filter, only save the breakpoints it accepts. */
15488 if (filter
&& !filter (tp
))
15493 if (is_tracepoint (tp
))
15495 extra_trace_bits
= 1;
15497 /* We can stop searching. */
15504 warning (_("Nothing to save."));
15508 gdb::unique_xmalloc_ptr
<char> expanded_filename (tilde_expand (filename
));
15512 if (!fp
.open (expanded_filename
.get (), "w"))
15513 error (_("Unable to open file '%s' for saving (%s)"),
15514 expanded_filename
.get (), safe_strerror (errno
));
15516 if (extra_trace_bits
)
15517 save_trace_state_variables (&fp
);
15519 ALL_BREAKPOINTS (tp
)
15521 /* Skip internal and momentary breakpoints. */
15522 if (!user_breakpoint_p (tp
))
15525 /* If we have a filter, only save the breakpoints it accepts. */
15526 if (filter
&& !filter (tp
))
15529 tp
->ops
->print_recreate (tp
, &fp
);
15531 /* Note, we can't rely on tp->number for anything, as we can't
15532 assume the recreated breakpoint numbers will match. Use $bpnum
15535 if (tp
->cond_string
)
15536 fp
.printf (" condition $bpnum %s\n", tp
->cond_string
);
15538 if (tp
->ignore_count
)
15539 fp
.printf (" ignore $bpnum %d\n", tp
->ignore_count
);
15541 if (tp
->type
!= bp_dprintf
&& tp
->commands
)
15543 fp
.puts (" commands\n");
15545 current_uiout
->redirect (&fp
);
15548 print_command_lines (current_uiout
, tp
->commands
->commands
, 2);
15550 CATCH (ex
, RETURN_MASK_ALL
)
15552 current_uiout
->redirect (NULL
);
15553 throw_exception (ex
);
15557 current_uiout
->redirect (NULL
);
15558 fp
.puts (" end\n");
15561 if (tp
->enable_state
== bp_disabled
)
15562 fp
.puts ("disable $bpnum\n");
15564 /* If this is a multi-location breakpoint, check if the locations
15565 should be individually disabled. Watchpoint locations are
15566 special, and not user visible. */
15567 if (!is_watchpoint (tp
) && tp
->loc
&& tp
->loc
->next
)
15569 struct bp_location
*loc
;
15572 for (loc
= tp
->loc
; loc
!= NULL
; loc
= loc
->next
, n
++)
15574 fp
.printf ("disable $bpnum.%d\n", n
);
15578 if (extra_trace_bits
&& *default_collect
)
15579 fp
.printf ("set default-collect %s\n", default_collect
);
15582 printf_filtered (_("Saved to file '%s'.\n"), expanded_filename
.get ());
15585 /* The `save breakpoints' command. */
15588 save_breakpoints_command (char *args
, int from_tty
)
15590 save_breakpoints (args
, from_tty
, NULL
);
15593 /* The `save tracepoints' command. */
15596 save_tracepoints_command (char *args
, int from_tty
)
15598 save_breakpoints (args
, from_tty
, is_tracepoint
);
15601 /* Create a vector of all tracepoints. */
15603 VEC(breakpoint_p
) *
15604 all_tracepoints (void)
15606 VEC(breakpoint_p
) *tp_vec
= 0;
15607 struct breakpoint
*tp
;
15609 ALL_TRACEPOINTS (tp
)
15611 VEC_safe_push (breakpoint_p
, tp_vec
, tp
);
15618 /* This help string is used to consolidate all the help string for specifying
15619 locations used by several commands. */
15621 #define LOCATION_HELP_STRING \
15622 "Linespecs are colon-separated lists of location parameters, such as\n\
15623 source filename, function name, label name, and line number.\n\
15624 Example: To specify the start of a label named \"the_top\" in the\n\
15625 function \"fact\" in the file \"factorial.c\", use\n\
15626 \"factorial.c:fact:the_top\".\n\
15628 Address locations begin with \"*\" and specify an exact address in the\n\
15629 program. Example: To specify the fourth byte past the start function\n\
15630 \"main\", use \"*main + 4\".\n\
15632 Explicit locations are similar to linespecs but use an option/argument\n\
15633 syntax to specify location parameters.\n\
15634 Example: To specify the start of the label named \"the_top\" in the\n\
15635 function \"fact\" in the file \"factorial.c\", use \"-source factorial.c\n\
15636 -function fact -label the_top\".\n"
15638 /* This help string is used for the break, hbreak, tbreak and thbreak
15639 commands. It is defined as a macro to prevent duplication.
15640 COMMAND should be a string constant containing the name of the
15643 #define BREAK_ARGS_HELP(command) \
15644 command" [PROBE_MODIFIER] [LOCATION] [thread THREADNUM] [if CONDITION]\n\
15645 PROBE_MODIFIER shall be present if the command is to be placed in a\n\
15646 probe point. Accepted values are `-probe' (for a generic, automatically\n\
15647 guessed probe type), `-probe-stap' (for a SystemTap probe) or \n\
15648 `-probe-dtrace' (for a DTrace probe).\n\
15649 LOCATION may be a linespec, address, or explicit location as described\n\
15652 With no LOCATION, uses current execution address of the selected\n\
15653 stack frame. This is useful for breaking on return to a stack frame.\n\
15655 THREADNUM is the number from \"info threads\".\n\
15656 CONDITION is a boolean expression.\n\
15657 \n" LOCATION_HELP_STRING "\n\
15658 Multiple breakpoints at one place are permitted, and useful if their\n\
15659 conditions are different.\n\
15661 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
15663 /* List of subcommands for "catch". */
15664 static struct cmd_list_element
*catch_cmdlist
;
15666 /* List of subcommands for "tcatch". */
15667 static struct cmd_list_element
*tcatch_cmdlist
;
15670 add_catch_command (const char *name
, const char *docstring
,
15671 cmd_sfunc_ftype
*sfunc
,
15672 completer_ftype
*completer
,
15673 void *user_data_catch
,
15674 void *user_data_tcatch
)
15676 struct cmd_list_element
*command
;
15678 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
15680 set_cmd_sfunc (command
, sfunc
);
15681 set_cmd_context (command
, user_data_catch
);
15682 set_cmd_completer (command
, completer
);
15684 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
15686 set_cmd_sfunc (command
, sfunc
);
15687 set_cmd_context (command
, user_data_tcatch
);
15688 set_cmd_completer (command
, completer
);
15692 save_command (char *arg
, int from_tty
)
15694 printf_unfiltered (_("\"save\" must be followed by "
15695 "the name of a save subcommand.\n"));
15696 help_list (save_cmdlist
, "save ", all_commands
, gdb_stdout
);
15699 struct breakpoint
*
15700 iterate_over_breakpoints (int (*callback
) (struct breakpoint
*, void *),
15703 struct breakpoint
*b
, *b_tmp
;
15705 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
15707 if ((*callback
) (b
, data
))
15714 /* Zero if any of the breakpoint's locations could be a location where
15715 functions have been inlined, nonzero otherwise. */
15718 is_non_inline_function (struct breakpoint
*b
)
15720 /* The shared library event breakpoint is set on the address of a
15721 non-inline function. */
15722 if (b
->type
== bp_shlib_event
)
15728 /* Nonzero if the specified PC cannot be a location where functions
15729 have been inlined. */
15732 pc_at_non_inline_function (struct address_space
*aspace
, CORE_ADDR pc
,
15733 const struct target_waitstatus
*ws
)
15735 struct breakpoint
*b
;
15736 struct bp_location
*bl
;
15738 ALL_BREAKPOINTS (b
)
15740 if (!is_non_inline_function (b
))
15743 for (bl
= b
->loc
; bl
!= NULL
; bl
= bl
->next
)
15745 if (!bl
->shlib_disabled
15746 && bpstat_check_location (bl
, aspace
, pc
, ws
))
15754 /* Remove any references to OBJFILE which is going to be freed. */
15757 breakpoint_free_objfile (struct objfile
*objfile
)
15759 struct bp_location
**locp
, *loc
;
15761 ALL_BP_LOCATIONS (loc
, locp
)
15762 if (loc
->symtab
!= NULL
&& SYMTAB_OBJFILE (loc
->symtab
) == objfile
)
15763 loc
->symtab
= NULL
;
15767 initialize_breakpoint_ops (void)
15769 static int initialized
= 0;
15771 struct breakpoint_ops
*ops
;
15777 /* The breakpoint_ops structure to be inherit by all kinds of
15778 breakpoints (real breakpoints, i.e., user "break" breakpoints,
15779 internal and momentary breakpoints, etc.). */
15780 ops
= &bkpt_base_breakpoint_ops
;
15781 *ops
= base_breakpoint_ops
;
15782 ops
->re_set
= bkpt_re_set
;
15783 ops
->insert_location
= bkpt_insert_location
;
15784 ops
->remove_location
= bkpt_remove_location
;
15785 ops
->breakpoint_hit
= bkpt_breakpoint_hit
;
15786 ops
->create_sals_from_location
= bkpt_create_sals_from_location
;
15787 ops
->create_breakpoints_sal
= bkpt_create_breakpoints_sal
;
15788 ops
->decode_location
= bkpt_decode_location
;
15790 /* The breakpoint_ops structure to be used in regular breakpoints. */
15791 ops
= &bkpt_breakpoint_ops
;
15792 *ops
= bkpt_base_breakpoint_ops
;
15793 ops
->re_set
= bkpt_re_set
;
15794 ops
->resources_needed
= bkpt_resources_needed
;
15795 ops
->print_it
= bkpt_print_it
;
15796 ops
->print_mention
= bkpt_print_mention
;
15797 ops
->print_recreate
= bkpt_print_recreate
;
15799 /* Ranged breakpoints. */
15800 ops
= &ranged_breakpoint_ops
;
15801 *ops
= bkpt_breakpoint_ops
;
15802 ops
->breakpoint_hit
= breakpoint_hit_ranged_breakpoint
;
15803 ops
->resources_needed
= resources_needed_ranged_breakpoint
;
15804 ops
->print_it
= print_it_ranged_breakpoint
;
15805 ops
->print_one
= print_one_ranged_breakpoint
;
15806 ops
->print_one_detail
= print_one_detail_ranged_breakpoint
;
15807 ops
->print_mention
= print_mention_ranged_breakpoint
;
15808 ops
->print_recreate
= print_recreate_ranged_breakpoint
;
15810 /* Internal breakpoints. */
15811 ops
= &internal_breakpoint_ops
;
15812 *ops
= bkpt_base_breakpoint_ops
;
15813 ops
->re_set
= internal_bkpt_re_set
;
15814 ops
->check_status
= internal_bkpt_check_status
;
15815 ops
->print_it
= internal_bkpt_print_it
;
15816 ops
->print_mention
= internal_bkpt_print_mention
;
15818 /* Momentary breakpoints. */
15819 ops
= &momentary_breakpoint_ops
;
15820 *ops
= bkpt_base_breakpoint_ops
;
15821 ops
->re_set
= momentary_bkpt_re_set
;
15822 ops
->check_status
= momentary_bkpt_check_status
;
15823 ops
->print_it
= momentary_bkpt_print_it
;
15824 ops
->print_mention
= momentary_bkpt_print_mention
;
15826 /* Probe breakpoints. */
15827 ops
= &bkpt_probe_breakpoint_ops
;
15828 *ops
= bkpt_breakpoint_ops
;
15829 ops
->insert_location
= bkpt_probe_insert_location
;
15830 ops
->remove_location
= bkpt_probe_remove_location
;
15831 ops
->create_sals_from_location
= bkpt_probe_create_sals_from_location
;
15832 ops
->decode_location
= bkpt_probe_decode_location
;
15835 ops
= &watchpoint_breakpoint_ops
;
15836 *ops
= base_breakpoint_ops
;
15837 ops
->re_set
= re_set_watchpoint
;
15838 ops
->insert_location
= insert_watchpoint
;
15839 ops
->remove_location
= remove_watchpoint
;
15840 ops
->breakpoint_hit
= breakpoint_hit_watchpoint
;
15841 ops
->check_status
= check_status_watchpoint
;
15842 ops
->resources_needed
= resources_needed_watchpoint
;
15843 ops
->works_in_software_mode
= works_in_software_mode_watchpoint
;
15844 ops
->print_it
= print_it_watchpoint
;
15845 ops
->print_mention
= print_mention_watchpoint
;
15846 ops
->print_recreate
= print_recreate_watchpoint
;
15847 ops
->explains_signal
= explains_signal_watchpoint
;
15849 /* Masked watchpoints. */
15850 ops
= &masked_watchpoint_breakpoint_ops
;
15851 *ops
= watchpoint_breakpoint_ops
;
15852 ops
->insert_location
= insert_masked_watchpoint
;
15853 ops
->remove_location
= remove_masked_watchpoint
;
15854 ops
->resources_needed
= resources_needed_masked_watchpoint
;
15855 ops
->works_in_software_mode
= works_in_software_mode_masked_watchpoint
;
15856 ops
->print_it
= print_it_masked_watchpoint
;
15857 ops
->print_one_detail
= print_one_detail_masked_watchpoint
;
15858 ops
->print_mention
= print_mention_masked_watchpoint
;
15859 ops
->print_recreate
= print_recreate_masked_watchpoint
;
15862 ops
= &tracepoint_breakpoint_ops
;
15863 *ops
= base_breakpoint_ops
;
15864 ops
->re_set
= tracepoint_re_set
;
15865 ops
->breakpoint_hit
= tracepoint_breakpoint_hit
;
15866 ops
->print_one_detail
= tracepoint_print_one_detail
;
15867 ops
->print_mention
= tracepoint_print_mention
;
15868 ops
->print_recreate
= tracepoint_print_recreate
;
15869 ops
->create_sals_from_location
= tracepoint_create_sals_from_location
;
15870 ops
->create_breakpoints_sal
= tracepoint_create_breakpoints_sal
;
15871 ops
->decode_location
= tracepoint_decode_location
;
15873 /* Probe tracepoints. */
15874 ops
= &tracepoint_probe_breakpoint_ops
;
15875 *ops
= tracepoint_breakpoint_ops
;
15876 ops
->create_sals_from_location
= tracepoint_probe_create_sals_from_location
;
15877 ops
->decode_location
= tracepoint_probe_decode_location
;
15879 /* Static tracepoints with marker (`-m'). */
15880 ops
= &strace_marker_breakpoint_ops
;
15881 *ops
= tracepoint_breakpoint_ops
;
15882 ops
->create_sals_from_location
= strace_marker_create_sals_from_location
;
15883 ops
->create_breakpoints_sal
= strace_marker_create_breakpoints_sal
;
15884 ops
->decode_location
= strace_marker_decode_location
;
15886 /* Fork catchpoints. */
15887 ops
= &catch_fork_breakpoint_ops
;
15888 *ops
= base_breakpoint_ops
;
15889 ops
->insert_location
= insert_catch_fork
;
15890 ops
->remove_location
= remove_catch_fork
;
15891 ops
->breakpoint_hit
= breakpoint_hit_catch_fork
;
15892 ops
->print_it
= print_it_catch_fork
;
15893 ops
->print_one
= print_one_catch_fork
;
15894 ops
->print_mention
= print_mention_catch_fork
;
15895 ops
->print_recreate
= print_recreate_catch_fork
;
15897 /* Vfork catchpoints. */
15898 ops
= &catch_vfork_breakpoint_ops
;
15899 *ops
= base_breakpoint_ops
;
15900 ops
->insert_location
= insert_catch_vfork
;
15901 ops
->remove_location
= remove_catch_vfork
;
15902 ops
->breakpoint_hit
= breakpoint_hit_catch_vfork
;
15903 ops
->print_it
= print_it_catch_vfork
;
15904 ops
->print_one
= print_one_catch_vfork
;
15905 ops
->print_mention
= print_mention_catch_vfork
;
15906 ops
->print_recreate
= print_recreate_catch_vfork
;
15908 /* Exec catchpoints. */
15909 ops
= &catch_exec_breakpoint_ops
;
15910 *ops
= base_breakpoint_ops
;
15911 ops
->insert_location
= insert_catch_exec
;
15912 ops
->remove_location
= remove_catch_exec
;
15913 ops
->breakpoint_hit
= breakpoint_hit_catch_exec
;
15914 ops
->print_it
= print_it_catch_exec
;
15915 ops
->print_one
= print_one_catch_exec
;
15916 ops
->print_mention
= print_mention_catch_exec
;
15917 ops
->print_recreate
= print_recreate_catch_exec
;
15919 /* Solib-related catchpoints. */
15920 ops
= &catch_solib_breakpoint_ops
;
15921 *ops
= base_breakpoint_ops
;
15922 ops
->insert_location
= insert_catch_solib
;
15923 ops
->remove_location
= remove_catch_solib
;
15924 ops
->breakpoint_hit
= breakpoint_hit_catch_solib
;
15925 ops
->check_status
= check_status_catch_solib
;
15926 ops
->print_it
= print_it_catch_solib
;
15927 ops
->print_one
= print_one_catch_solib
;
15928 ops
->print_mention
= print_mention_catch_solib
;
15929 ops
->print_recreate
= print_recreate_catch_solib
;
15931 ops
= &dprintf_breakpoint_ops
;
15932 *ops
= bkpt_base_breakpoint_ops
;
15933 ops
->re_set
= dprintf_re_set
;
15934 ops
->resources_needed
= bkpt_resources_needed
;
15935 ops
->print_it
= bkpt_print_it
;
15936 ops
->print_mention
= bkpt_print_mention
;
15937 ops
->print_recreate
= dprintf_print_recreate
;
15938 ops
->after_condition_true
= dprintf_after_condition_true
;
15939 ops
->breakpoint_hit
= dprintf_breakpoint_hit
;
15942 /* Chain containing all defined "enable breakpoint" subcommands. */
15944 static struct cmd_list_element
*enablebreaklist
= NULL
;
15947 _initialize_breakpoint (void)
15949 struct cmd_list_element
*c
;
15951 initialize_breakpoint_ops ();
15953 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
15954 observer_attach_free_objfile (disable_breakpoints_in_freed_objfile
);
15955 observer_attach_memory_changed (invalidate_bp_value_on_memory_change
);
15957 breakpoint_objfile_key
15958 = register_objfile_data_with_cleanup (NULL
, free_breakpoint_probes
);
15960 breakpoint_chain
= 0;
15961 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
15962 before a breakpoint is set. */
15963 breakpoint_count
= 0;
15965 tracepoint_count
= 0;
15967 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
15968 Set ignore-count of breakpoint number N to COUNT.\n\
15969 Usage is `ignore N COUNT'."));
15971 add_com ("commands", class_breakpoint
, commands_command
, _("\
15972 Set commands to be executed when the given breakpoints are hit.\n\
15973 Give a space-separated breakpoint list as argument after \"commands\".\n\
15974 A list element can be a breakpoint number (e.g. `5') or a range of numbers\n\
15976 With no argument, the targeted breakpoint is the last one set.\n\
15977 The commands themselves follow starting on the next line.\n\
15978 Type a line containing \"end\" to indicate the end of them.\n\
15979 Give \"silent\" as the first line to make the breakpoint silent;\n\
15980 then no output is printed when it is hit, except what the commands print."));
15982 c
= add_com ("condition", class_breakpoint
, condition_command
, _("\
15983 Specify breakpoint number N to break only if COND is true.\n\
15984 Usage is `condition N COND', where N is an integer and COND is an\n\
15985 expression to be evaluated whenever breakpoint N is reached."));
15986 set_cmd_completer (c
, condition_completer
);
15988 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
15989 Set a temporary breakpoint.\n\
15990 Like \"break\" except the breakpoint is only temporary,\n\
15991 so it will be deleted when hit. Equivalent to \"break\" followed\n\
15992 by using \"enable delete\" on the breakpoint number.\n\
15994 BREAK_ARGS_HELP ("tbreak")));
15995 set_cmd_completer (c
, location_completer
);
15997 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
15998 Set a hardware assisted breakpoint.\n\
15999 Like \"break\" except the breakpoint requires hardware support,\n\
16000 some target hardware may not have this support.\n\
16002 BREAK_ARGS_HELP ("hbreak")));
16003 set_cmd_completer (c
, location_completer
);
16005 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
16006 Set a temporary hardware assisted breakpoint.\n\
16007 Like \"hbreak\" except the breakpoint is only temporary,\n\
16008 so it will be deleted when hit.\n\
16010 BREAK_ARGS_HELP ("thbreak")));
16011 set_cmd_completer (c
, location_completer
);
16013 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
16014 Enable some breakpoints.\n\
16015 Give breakpoint numbers (separated by spaces) as arguments.\n\
16016 With no subcommand, breakpoints are enabled until you command otherwise.\n\
16017 This is used to cancel the effect of the \"disable\" command.\n\
16018 With a subcommand you can enable temporarily."),
16019 &enablelist
, "enable ", 1, &cmdlist
);
16021 add_com_alias ("en", "enable", class_breakpoint
, 1);
16023 add_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
16024 Enable some breakpoints.\n\
16025 Give breakpoint numbers (separated by spaces) as arguments.\n\
16026 This is used to cancel the effect of the \"disable\" command.\n\
16027 May be abbreviated to simply \"enable\".\n"),
16028 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
16030 add_cmd ("once", no_class
, enable_once_command
, _("\
16031 Enable breakpoints for one hit. Give breakpoint numbers.\n\
16032 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
16035 add_cmd ("delete", no_class
, enable_delete_command
, _("\
16036 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
16037 If a breakpoint is hit while enabled in this fashion, it is deleted."),
16040 add_cmd ("count", no_class
, enable_count_command
, _("\
16041 Enable breakpoints for COUNT hits. Give count and then breakpoint numbers.\n\
16042 If a breakpoint is hit while enabled in this fashion,\n\
16043 the count is decremented; when it reaches zero, the breakpoint is disabled."),
16046 add_cmd ("delete", no_class
, enable_delete_command
, _("\
16047 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
16048 If a breakpoint is hit while enabled in this fashion, it is deleted."),
16051 add_cmd ("once", no_class
, enable_once_command
, _("\
16052 Enable breakpoints for one hit. Give breakpoint numbers.\n\
16053 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
16056 add_cmd ("count", no_class
, enable_count_command
, _("\
16057 Enable breakpoints for COUNT hits. Give count and then breakpoint numbers.\n\
16058 If a breakpoint is hit while enabled in this fashion,\n\
16059 the count is decremented; when it reaches zero, the breakpoint is disabled."),
16062 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
16063 Disable some breakpoints.\n\
16064 Arguments are breakpoint numbers with spaces in between.\n\
16065 To disable all breakpoints, give no argument.\n\
16066 A disabled breakpoint is not forgotten, but has no effect until re-enabled."),
16067 &disablelist
, "disable ", 1, &cmdlist
);
16068 add_com_alias ("dis", "disable", class_breakpoint
, 1);
16069 add_com_alias ("disa", "disable", class_breakpoint
, 1);
16071 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
16072 Disable some breakpoints.\n\
16073 Arguments are breakpoint numbers with spaces in between.\n\
16074 To disable all breakpoints, give no argument.\n\
16075 A disabled breakpoint is not forgotten, but has no effect until re-enabled.\n\
16076 This command may be abbreviated \"disable\"."),
16079 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
16080 Delete some breakpoints or auto-display expressions.\n\
16081 Arguments are breakpoint numbers with spaces in between.\n\
16082 To delete all breakpoints, give no argument.\n\
16084 Also a prefix command for deletion of other GDB objects.\n\
16085 The \"unset\" command is also an alias for \"delete\"."),
16086 &deletelist
, "delete ", 1, &cmdlist
);
16087 add_com_alias ("d", "delete", class_breakpoint
, 1);
16088 add_com_alias ("del", "delete", class_breakpoint
, 1);
16090 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
16091 Delete some breakpoints or auto-display expressions.\n\
16092 Arguments are breakpoint numbers with spaces in between.\n\
16093 To delete all breakpoints, give no argument.\n\
16094 This command may be abbreviated \"delete\"."),
16097 add_com ("clear", class_breakpoint
, clear_command
, _("\
16098 Clear breakpoint at specified location.\n\
16099 Argument may be a linespec, explicit, or address location as described below.\n\
16101 With no argument, clears all breakpoints in the line that the selected frame\n\
16102 is executing in.\n"
16103 "\n" LOCATION_HELP_STRING
"\n\
16104 See also the \"delete\" command which clears breakpoints by number."));
16105 add_com_alias ("cl", "clear", class_breakpoint
, 1);
16107 c
= add_com ("break", class_breakpoint
, break_command
, _("\
16108 Set breakpoint at specified location.\n"
16109 BREAK_ARGS_HELP ("break")));
16110 set_cmd_completer (c
, location_completer
);
16112 add_com_alias ("b", "break", class_run
, 1);
16113 add_com_alias ("br", "break", class_run
, 1);
16114 add_com_alias ("bre", "break", class_run
, 1);
16115 add_com_alias ("brea", "break", class_run
, 1);
16119 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
16120 Break in function/address or break at a line in the current file."),
16121 &stoplist
, "stop ", 1, &cmdlist
);
16122 add_cmd ("in", class_breakpoint
, stopin_command
,
16123 _("Break in function or address."), &stoplist
);
16124 add_cmd ("at", class_breakpoint
, stopat_command
,
16125 _("Break at a line in the current file."), &stoplist
);
16126 add_com ("status", class_info
, breakpoints_info
, _("\
16127 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
16128 The \"Type\" column indicates one of:\n\
16129 \tbreakpoint - normal breakpoint\n\
16130 \twatchpoint - watchpoint\n\
16131 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
16132 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
16133 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
16134 address and file/line number respectively.\n\
16136 Convenience variable \"$_\" and default examine address for \"x\"\n\
16137 are set to the address of the last breakpoint listed unless the command\n\
16138 is prefixed with \"server \".\n\n\
16139 Convenience variable \"$bpnum\" contains the number of the last\n\
16140 breakpoint set."));
16143 add_info ("breakpoints", breakpoints_info
, _("\
16144 Status of specified breakpoints (all user-settable breakpoints if no argument).\n\
16145 The \"Type\" column indicates one of:\n\
16146 \tbreakpoint - normal breakpoint\n\
16147 \twatchpoint - watchpoint\n\
16148 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
16149 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
16150 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
16151 address and file/line number respectively.\n\
16153 Convenience variable \"$_\" and default examine address for \"x\"\n\
16154 are set to the address of the last breakpoint listed unless the command\n\
16155 is prefixed with \"server \".\n\n\
16156 Convenience variable \"$bpnum\" contains the number of the last\n\
16157 breakpoint set."));
16159 add_info_alias ("b", "breakpoints", 1);
16161 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
16162 Status of all breakpoints, or breakpoint number NUMBER.\n\
16163 The \"Type\" column indicates one of:\n\
16164 \tbreakpoint - normal breakpoint\n\
16165 \twatchpoint - watchpoint\n\
16166 \tlongjmp - internal breakpoint used to step through longjmp()\n\
16167 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
16168 \tuntil - internal breakpoint used by the \"until\" command\n\
16169 \tfinish - internal breakpoint used by the \"finish\" command\n\
16170 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
16171 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
16172 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
16173 address and file/line number respectively.\n\
16175 Convenience variable \"$_\" and default examine address for \"x\"\n\
16176 are set to the address of the last breakpoint listed unless the command\n\
16177 is prefixed with \"server \".\n\n\
16178 Convenience variable \"$bpnum\" contains the number of the last\n\
16180 &maintenanceinfolist
);
16182 add_prefix_cmd ("catch", class_breakpoint
, catch_command
, _("\
16183 Set catchpoints to catch events."),
16184 &catch_cmdlist
, "catch ",
16185 0/*allow-unknown*/, &cmdlist
);
16187 add_prefix_cmd ("tcatch", class_breakpoint
, tcatch_command
, _("\
16188 Set temporary catchpoints to catch events."),
16189 &tcatch_cmdlist
, "tcatch ",
16190 0/*allow-unknown*/, &cmdlist
);
16192 add_catch_command ("fork", _("Catch calls to fork."),
16193 catch_fork_command_1
,
16195 (void *) (uintptr_t) catch_fork_permanent
,
16196 (void *) (uintptr_t) catch_fork_temporary
);
16197 add_catch_command ("vfork", _("Catch calls to vfork."),
16198 catch_fork_command_1
,
16200 (void *) (uintptr_t) catch_vfork_permanent
,
16201 (void *) (uintptr_t) catch_vfork_temporary
);
16202 add_catch_command ("exec", _("Catch calls to exec."),
16203 catch_exec_command_1
,
16207 add_catch_command ("load", _("Catch loads of shared libraries.\n\
16208 Usage: catch load [REGEX]\n\
16209 If REGEX is given, only stop for libraries matching the regular expression."),
16210 catch_load_command_1
,
16214 add_catch_command ("unload", _("Catch unloads of shared libraries.\n\
16215 Usage: catch unload [REGEX]\n\
16216 If REGEX is given, only stop for libraries matching the regular expression."),
16217 catch_unload_command_1
,
16222 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
16223 Set a watchpoint for an expression.\n\
16224 Usage: watch [-l|-location] EXPRESSION\n\
16225 A watchpoint stops execution of your program whenever the value of\n\
16226 an expression changes.\n\
16227 If -l or -location is given, this evaluates EXPRESSION and watches\n\
16228 the memory to which it refers."));
16229 set_cmd_completer (c
, expression_completer
);
16231 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
16232 Set a read watchpoint for an expression.\n\
16233 Usage: rwatch [-l|-location] EXPRESSION\n\
16234 A watchpoint stops execution of your program whenever the value of\n\
16235 an expression is read.\n\
16236 If -l or -location is given, this evaluates EXPRESSION and watches\n\
16237 the memory to which it refers."));
16238 set_cmd_completer (c
, expression_completer
);
16240 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
16241 Set a watchpoint for an expression.\n\
16242 Usage: awatch [-l|-location] EXPRESSION\n\
16243 A watchpoint stops execution of your program whenever the value of\n\
16244 an expression is either read or written.\n\
16245 If -l or -location is given, this evaluates EXPRESSION and watches\n\
16246 the memory to which it refers."));
16247 set_cmd_completer (c
, expression_completer
);
16249 add_info ("watchpoints", watchpoints_info
, _("\
16250 Status of specified watchpoints (all watchpoints if no argument)."));
16252 /* XXX: cagney/2005-02-23: This should be a boolean, and should
16253 respond to changes - contrary to the description. */
16254 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
16255 &can_use_hw_watchpoints
, _("\
16256 Set debugger's willingness to use watchpoint hardware."), _("\
16257 Show debugger's willingness to use watchpoint hardware."), _("\
16258 If zero, gdb will not use hardware for new watchpoints, even if\n\
16259 such is available. (However, any hardware watchpoints that were\n\
16260 created before setting this to nonzero, will continue to use watchpoint\n\
16263 show_can_use_hw_watchpoints
,
16264 &setlist
, &showlist
);
16266 can_use_hw_watchpoints
= 1;
16268 /* Tracepoint manipulation commands. */
16270 c
= add_com ("trace", class_breakpoint
, trace_command
, _("\
16271 Set a tracepoint at specified location.\n\
16273 BREAK_ARGS_HELP ("trace") "\n\
16274 Do \"help tracepoints\" for info on other tracepoint commands."));
16275 set_cmd_completer (c
, location_completer
);
16277 add_com_alias ("tp", "trace", class_alias
, 0);
16278 add_com_alias ("tr", "trace", class_alias
, 1);
16279 add_com_alias ("tra", "trace", class_alias
, 1);
16280 add_com_alias ("trac", "trace", class_alias
, 1);
16282 c
= add_com ("ftrace", class_breakpoint
, ftrace_command
, _("\
16283 Set a fast tracepoint at specified location.\n\
16285 BREAK_ARGS_HELP ("ftrace") "\n\
16286 Do \"help tracepoints\" for info on other tracepoint commands."));
16287 set_cmd_completer (c
, location_completer
);
16289 c
= add_com ("strace", class_breakpoint
, strace_command
, _("\
16290 Set a static tracepoint at location or marker.\n\
16292 strace [LOCATION] [if CONDITION]\n\
16293 LOCATION may be a linespec, explicit, or address location (described below) \n\
16294 or -m MARKER_ID.\n\n\
16295 If a marker id is specified, probe the marker with that name. With\n\
16296 no LOCATION, uses current execution address of the selected stack frame.\n\
16297 Static tracepoints accept an extra collect action -- ``collect $_sdata''.\n\
16298 This collects arbitrary user data passed in the probe point call to the\n\
16299 tracing library. You can inspect it when analyzing the trace buffer,\n\
16300 by printing the $_sdata variable like any other convenience variable.\n\
16302 CONDITION is a boolean expression.\n\
16303 \n" LOCATION_HELP_STRING
"\n\
16304 Multiple tracepoints at one place are permitted, and useful if their\n\
16305 conditions are different.\n\
16307 Do \"help breakpoints\" for info on other commands dealing with breakpoints.\n\
16308 Do \"help tracepoints\" for info on other tracepoint commands."));
16309 set_cmd_completer (c
, location_completer
);
16311 add_info ("tracepoints", tracepoints_info
, _("\
16312 Status of specified tracepoints (all tracepoints if no argument).\n\
16313 Convenience variable \"$tpnum\" contains the number of the\n\
16314 last tracepoint set."));
16316 add_info_alias ("tp", "tracepoints", 1);
16318 add_cmd ("tracepoints", class_trace
, delete_trace_command
, _("\
16319 Delete specified tracepoints.\n\
16320 Arguments are tracepoint numbers, separated by spaces.\n\
16321 No argument means delete all tracepoints."),
16323 add_alias_cmd ("tr", "tracepoints", class_trace
, 1, &deletelist
);
16325 c
= add_cmd ("tracepoints", class_trace
, disable_trace_command
, _("\
16326 Disable specified tracepoints.\n\
16327 Arguments are tracepoint numbers, separated by spaces.\n\
16328 No argument means disable all tracepoints."),
16330 deprecate_cmd (c
, "disable");
16332 c
= add_cmd ("tracepoints", class_trace
, enable_trace_command
, _("\
16333 Enable specified tracepoints.\n\
16334 Arguments are tracepoint numbers, separated by spaces.\n\
16335 No argument means enable all tracepoints."),
16337 deprecate_cmd (c
, "enable");
16339 add_com ("passcount", class_trace
, trace_pass_command
, _("\
16340 Set the passcount for a tracepoint.\n\
16341 The trace will end when the tracepoint has been passed 'count' times.\n\
16342 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
16343 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
16345 add_prefix_cmd ("save", class_breakpoint
, save_command
,
16346 _("Save breakpoint definitions as a script."),
16347 &save_cmdlist
, "save ",
16348 0/*allow-unknown*/, &cmdlist
);
16350 c
= add_cmd ("breakpoints", class_breakpoint
, save_breakpoints_command
, _("\
16351 Save current breakpoint definitions as a script.\n\
16352 This includes all types of breakpoints (breakpoints, watchpoints,\n\
16353 catchpoints, tracepoints). Use the 'source' command in another debug\n\
16354 session to restore them."),
16356 set_cmd_completer (c
, filename_completer
);
16358 c
= add_cmd ("tracepoints", class_trace
, save_tracepoints_command
, _("\
16359 Save current tracepoint definitions as a script.\n\
16360 Use the 'source' command in another debug session to restore them."),
16362 set_cmd_completer (c
, filename_completer
);
16364 c
= add_com_alias ("save-tracepoints", "save tracepoints", class_trace
, 0);
16365 deprecate_cmd (c
, "save tracepoints");
16367 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
16368 Breakpoint specific settings\n\
16369 Configure various breakpoint-specific variables such as\n\
16370 pending breakpoint behavior"),
16371 &breakpoint_set_cmdlist
, "set breakpoint ",
16372 0/*allow-unknown*/, &setlist
);
16373 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
16374 Breakpoint specific settings\n\
16375 Configure various breakpoint-specific variables such as\n\
16376 pending breakpoint behavior"),
16377 &breakpoint_show_cmdlist
, "show breakpoint ",
16378 0/*allow-unknown*/, &showlist
);
16380 add_setshow_auto_boolean_cmd ("pending", no_class
,
16381 &pending_break_support
, _("\
16382 Set debugger's behavior regarding pending breakpoints."), _("\
16383 Show debugger's behavior regarding pending breakpoints."), _("\
16384 If on, an unrecognized breakpoint location will cause gdb to create a\n\
16385 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
16386 an error. If auto, an unrecognized breakpoint location results in a\n\
16387 user-query to see if a pending breakpoint should be created."),
16389 show_pending_break_support
,
16390 &breakpoint_set_cmdlist
,
16391 &breakpoint_show_cmdlist
);
16393 pending_break_support
= AUTO_BOOLEAN_AUTO
;
16395 add_setshow_boolean_cmd ("auto-hw", no_class
,
16396 &automatic_hardware_breakpoints
, _("\
16397 Set automatic usage of hardware breakpoints."), _("\
16398 Show automatic usage of hardware breakpoints."), _("\
16399 If set, the debugger will automatically use hardware breakpoints for\n\
16400 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
16401 a warning will be emitted for such breakpoints."),
16403 show_automatic_hardware_breakpoints
,
16404 &breakpoint_set_cmdlist
,
16405 &breakpoint_show_cmdlist
);
16407 add_setshow_boolean_cmd ("always-inserted", class_support
,
16408 &always_inserted_mode
, _("\
16409 Set mode for inserting breakpoints."), _("\
16410 Show mode for inserting breakpoints."), _("\
16411 When this mode is on, breakpoints are inserted immediately as soon as\n\
16412 they're created, kept inserted even when execution stops, and removed\n\
16413 only when the user deletes them. When this mode is off (the default),\n\
16414 breakpoints are inserted only when execution continues, and removed\n\
16415 when execution stops."),
16417 &show_always_inserted_mode
,
16418 &breakpoint_set_cmdlist
,
16419 &breakpoint_show_cmdlist
);
16421 add_setshow_enum_cmd ("condition-evaluation", class_breakpoint
,
16422 condition_evaluation_enums
,
16423 &condition_evaluation_mode_1
, _("\
16424 Set mode of breakpoint condition evaluation."), _("\
16425 Show mode of breakpoint condition evaluation."), _("\
16426 When this is set to \"host\", breakpoint conditions will be\n\
16427 evaluated on the host's side by GDB. When it is set to \"target\",\n\
16428 breakpoint conditions will be downloaded to the target (if the target\n\
16429 supports such feature) and conditions will be evaluated on the target's side.\n\
16430 If this is set to \"auto\" (default), this will be automatically set to\n\
16431 \"target\" if it supports condition evaluation, otherwise it will\n\
16432 be set to \"gdb\""),
16433 &set_condition_evaluation_mode
,
16434 &show_condition_evaluation_mode
,
16435 &breakpoint_set_cmdlist
,
16436 &breakpoint_show_cmdlist
);
16438 add_com ("break-range", class_breakpoint
, break_range_command
, _("\
16439 Set a breakpoint for an address range.\n\
16440 break-range START-LOCATION, END-LOCATION\n\
16441 where START-LOCATION and END-LOCATION can be one of the following:\n\
16442 LINENUM, for that line in the current file,\n\
16443 FILE:LINENUM, for that line in that file,\n\
16444 +OFFSET, for that number of lines after the current line\n\
16445 or the start of the range\n\
16446 FUNCTION, for the first line in that function,\n\
16447 FILE:FUNCTION, to distinguish among like-named static functions.\n\
16448 *ADDRESS, for the instruction at that address.\n\
16450 The breakpoint will stop execution of the inferior whenever it executes\n\
16451 an instruction at any address within the [START-LOCATION, END-LOCATION]\n\
16452 range (including START-LOCATION and END-LOCATION)."));
16454 c
= add_com ("dprintf", class_breakpoint
, dprintf_command
, _("\
16455 Set a dynamic printf at specified location.\n\
16456 dprintf location,format string,arg1,arg2,...\n\
16457 location may be a linespec, explicit, or address location.\n"
16458 "\n" LOCATION_HELP_STRING
));
16459 set_cmd_completer (c
, location_completer
);
16461 add_setshow_enum_cmd ("dprintf-style", class_support
,
16462 dprintf_style_enums
, &dprintf_style
, _("\
16463 Set the style of usage for dynamic printf."), _("\
16464 Show the style of usage for dynamic printf."), _("\
16465 This setting chooses how GDB will do a dynamic printf.\n\
16466 If the value is \"gdb\", then the printing is done by GDB to its own\n\
16467 console, as with the \"printf\" command.\n\
16468 If the value is \"call\", the print is done by calling a function in your\n\
16469 program; by default printf(), but you can choose a different function or\n\
16470 output stream by setting dprintf-function and dprintf-channel."),
16471 update_dprintf_commands
, NULL
,
16472 &setlist
, &showlist
);
16474 dprintf_function
= xstrdup ("printf");
16475 add_setshow_string_cmd ("dprintf-function", class_support
,
16476 &dprintf_function
, _("\
16477 Set the function to use for dynamic printf"), _("\
16478 Show the function to use for dynamic printf"), NULL
,
16479 update_dprintf_commands
, NULL
,
16480 &setlist
, &showlist
);
16482 dprintf_channel
= xstrdup ("");
16483 add_setshow_string_cmd ("dprintf-channel", class_support
,
16484 &dprintf_channel
, _("\
16485 Set the channel to use for dynamic printf"), _("\
16486 Show the channel to use for dynamic printf"), NULL
,
16487 update_dprintf_commands
, NULL
,
16488 &setlist
, &showlist
);
16490 add_setshow_boolean_cmd ("disconnected-dprintf", no_class
,
16491 &disconnected_dprintf
, _("\
16492 Set whether dprintf continues after GDB disconnects."), _("\
16493 Show whether dprintf continues after GDB disconnects."), _("\
16494 Use this to let dprintf commands continue to hit and produce output\n\
16495 even if GDB disconnects or detaches from the target."),
16498 &setlist
, &showlist
);
16500 add_com ("agent-printf", class_vars
, agent_printf_command
, _("\
16501 agent-printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
16502 (target agent only) This is useful for formatted output in user-defined commands."));
16504 automatic_hardware_breakpoints
= 1;
16506 observer_attach_about_to_proceed (breakpoint_about_to_proceed
);
16507 observer_attach_thread_exit (remove_threaded_breakpoints
);