1 /* Everything about breakpoints, for GDB.
3 Copyright (C) 1986-2016 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"
71 #include "thread-fsm.h"
72 #include "tid-parse.h"
74 /* readline include files */
75 #include "readline/readline.h"
76 #include "readline/history.h"
78 /* readline defines this. */
81 #include "mi/mi-common.h"
82 #include "extension.h"
84 /* Enums for exception-handling support. */
85 enum exception_event_kind
92 /* Prototypes for local functions. */
94 static void enable_delete_command (char *, int);
96 static void enable_once_command (char *, int);
98 static void enable_count_command (char *, int);
100 static void disable_command (char *, int);
102 static void enable_command (char *, int);
104 static void map_breakpoint_numbers (char *, void (*) (struct breakpoint
*,
108 static void ignore_command (char *, int);
110 static int breakpoint_re_set_one (void *);
112 static void breakpoint_re_set_default (struct breakpoint
*);
115 create_sals_from_location_default (const struct event_location
*location
,
116 struct linespec_result
*canonical
,
117 enum bptype type_wanted
);
119 static void create_breakpoints_sal_default (struct gdbarch
*,
120 struct linespec_result
*,
121 char *, char *, enum bptype
,
122 enum bpdisp
, int, int,
124 const struct breakpoint_ops
*,
125 int, int, int, unsigned);
127 static void decode_location_default (struct breakpoint
*b
,
128 const struct event_location
*location
,
129 struct program_space
*search_pspace
,
130 struct symtabs_and_lines
*sals
);
132 static void clear_command (char *, int);
134 static void catch_command (char *, int);
136 static int can_use_hardware_watchpoint (struct value
*);
138 static void break_command_1 (char *, int, int);
140 static void mention (struct breakpoint
*);
142 static struct breakpoint
*set_raw_breakpoint_without_location (struct gdbarch
*,
144 const struct breakpoint_ops
*);
145 static struct bp_location
*add_location_to_breakpoint (struct breakpoint
*,
146 const struct symtab_and_line
*);
148 /* This function is used in gdbtk sources and thus can not be made
150 struct breakpoint
*set_raw_breakpoint (struct gdbarch
*gdbarch
,
151 struct symtab_and_line
,
153 const struct breakpoint_ops
*);
155 static struct breakpoint
*
156 momentary_breakpoint_from_master (struct breakpoint
*orig
,
158 const struct breakpoint_ops
*ops
,
161 static void breakpoint_adjustment_warning (CORE_ADDR
, CORE_ADDR
, int, int);
163 static CORE_ADDR
adjust_breakpoint_address (struct gdbarch
*gdbarch
,
167 static void describe_other_breakpoints (struct gdbarch
*,
168 struct program_space
*, CORE_ADDR
,
169 struct obj_section
*, int);
171 static int watchpoint_locations_match (struct bp_location
*loc1
,
172 struct bp_location
*loc2
);
174 static int breakpoint_location_address_match (struct bp_location
*bl
,
175 struct address_space
*aspace
,
178 static int breakpoint_location_address_range_overlap (struct bp_location
*,
179 struct address_space
*,
182 static void breakpoints_info (char *, int);
184 static void watchpoints_info (char *, int);
186 static int breakpoint_1 (char *, int,
187 int (*) (const struct breakpoint
*));
189 static int breakpoint_cond_eval (void *);
191 static void cleanup_executing_breakpoints (void *);
193 static void commands_command (char *, int);
195 static void condition_command (char *, int);
204 static int remove_breakpoint (struct bp_location
*, insertion_state_t
);
205 static int remove_breakpoint_1 (struct bp_location
*, insertion_state_t
);
207 static enum print_stop_action
print_bp_stop_message (bpstat bs
);
209 static int watchpoint_check (void *);
211 static void maintenance_info_breakpoints (char *, int);
213 static int hw_breakpoint_used_count (void);
215 static int hw_watchpoint_use_count (struct breakpoint
*);
217 static int hw_watchpoint_used_count_others (struct breakpoint
*except
,
219 int *other_type_used
);
221 static void hbreak_command (char *, int);
223 static void thbreak_command (char *, int);
225 static void enable_breakpoint_disp (struct breakpoint
*, enum bpdisp
,
228 static void stop_command (char *arg
, int from_tty
);
230 static void stopin_command (char *arg
, int from_tty
);
232 static void stopat_command (char *arg
, int from_tty
);
234 static void tcatch_command (char *arg
, int from_tty
);
236 static void free_bp_location (struct bp_location
*loc
);
237 static void incref_bp_location (struct bp_location
*loc
);
238 static void decref_bp_location (struct bp_location
**loc
);
240 static struct bp_location
*allocate_bp_location (struct breakpoint
*bpt
);
242 /* update_global_location_list's modes of operation wrt to whether to
243 insert locations now. */
244 enum ugll_insert_mode
246 /* Don't insert any breakpoint locations into the inferior, only
247 remove already-inserted locations that no longer should be
248 inserted. Functions that delete a breakpoint or breakpoints
249 should specify this mode, so that deleting a breakpoint doesn't
250 have the side effect of inserting the locations of other
251 breakpoints that are marked not-inserted, but should_be_inserted
252 returns true on them.
254 This behavior is useful is situations close to tear-down -- e.g.,
255 after an exec, while the target still has execution, but
256 breakpoint shadows of the previous executable image should *NOT*
257 be restored to the new image; or before detaching, where the
258 target still has execution and wants to delete breakpoints from
259 GDB's lists, and all breakpoints had already been removed from
263 /* May insert breakpoints iff breakpoints_should_be_inserted_now
264 claims breakpoints should be inserted now. */
267 /* Insert locations now, irrespective of
268 breakpoints_should_be_inserted_now. E.g., say all threads are
269 stopped right now, and the user did "continue". We need to
270 insert breakpoints _before_ resuming the target, but
271 UGLL_MAY_INSERT wouldn't insert them, because
272 breakpoints_should_be_inserted_now returns false at that point,
273 as no thread is running yet. */
277 static void update_global_location_list (enum ugll_insert_mode
);
279 static void update_global_location_list_nothrow (enum ugll_insert_mode
);
281 static int is_hardware_watchpoint (const struct breakpoint
*bpt
);
283 static void insert_breakpoint_locations (void);
285 static void tracepoints_info (char *, int);
287 static void delete_trace_command (char *, int);
289 static void enable_trace_command (char *, int);
291 static void disable_trace_command (char *, int);
293 static void trace_pass_command (char *, int);
295 static void set_tracepoint_count (int num
);
297 static int is_masked_watchpoint (const struct breakpoint
*b
);
299 static struct bp_location
**get_first_locp_gte_addr (CORE_ADDR address
);
301 /* Return 1 if B refers to a static tracepoint set by marker ("-m"), zero
304 static int strace_marker_p (struct breakpoint
*b
);
306 /* The breakpoint_ops structure to be inherited by all breakpoint_ops
307 that are implemented on top of software or hardware breakpoints
308 (user breakpoints, internal and momentary breakpoints, etc.). */
309 static struct breakpoint_ops bkpt_base_breakpoint_ops
;
311 /* Internal breakpoints class type. */
312 static struct breakpoint_ops internal_breakpoint_ops
;
314 /* Momentary breakpoints class type. */
315 static struct breakpoint_ops momentary_breakpoint_ops
;
317 /* Momentary breakpoints for bp_longjmp and bp_exception class type. */
318 static struct breakpoint_ops longjmp_breakpoint_ops
;
320 /* The breakpoint_ops structure to be used in regular user created
322 struct breakpoint_ops bkpt_breakpoint_ops
;
324 /* Breakpoints set on probes. */
325 static struct breakpoint_ops bkpt_probe_breakpoint_ops
;
327 /* Dynamic printf class type. */
328 struct breakpoint_ops dprintf_breakpoint_ops
;
330 /* The style in which to perform a dynamic printf. This is a user
331 option because different output options have different tradeoffs;
332 if GDB does the printing, there is better error handling if there
333 is a problem with any of the arguments, but using an inferior
334 function lets you have special-purpose printers and sending of
335 output to the same place as compiled-in print functions. */
337 static const char dprintf_style_gdb
[] = "gdb";
338 static const char dprintf_style_call
[] = "call";
339 static const char dprintf_style_agent
[] = "agent";
340 static const char *const dprintf_style_enums
[] = {
346 static const char *dprintf_style
= dprintf_style_gdb
;
348 /* The function to use for dynamic printf if the preferred style is to
349 call into the inferior. The value is simply a string that is
350 copied into the command, so it can be anything that GDB can
351 evaluate to a callable address, not necessarily a function name. */
353 static char *dprintf_function
= "";
355 /* The channel to use for dynamic printf if the preferred style is to
356 call into the inferior; if a nonempty string, it will be passed to
357 the call as the first argument, with the format string as the
358 second. As with the dprintf function, this can be anything that
359 GDB knows how to evaluate, so in addition to common choices like
360 "stderr", this could be an app-specific expression like
361 "mystreams[curlogger]". */
363 static char *dprintf_channel
= "";
365 /* True if dprintf commands should continue to operate even if GDB
367 static int disconnected_dprintf
= 1;
369 /* A reference-counted struct command_line. This lets multiple
370 breakpoints share a single command list. */
371 struct counted_command_line
373 /* The reference count. */
376 /* The command list. */
377 struct command_line
*commands
;
380 struct command_line
*
381 breakpoint_commands (struct breakpoint
*b
)
383 return b
->commands
? b
->commands
->commands
: NULL
;
386 /* Flag indicating that a command has proceeded the inferior past the
387 current breakpoint. */
389 static int breakpoint_proceeded
;
392 bpdisp_text (enum bpdisp disp
)
394 /* NOTE: the following values are a part of MI protocol and
395 represent values of 'disp' field returned when inferior stops at
397 static const char * const bpdisps
[] = {"del", "dstp", "dis", "keep"};
399 return bpdisps
[(int) disp
];
402 /* Prototypes for exported functions. */
403 /* If FALSE, gdb will not use hardware support for watchpoints, even
404 if such is available. */
405 static int can_use_hw_watchpoints
;
408 show_can_use_hw_watchpoints (struct ui_file
*file
, int from_tty
,
409 struct cmd_list_element
*c
,
412 fprintf_filtered (file
,
413 _("Debugger's willingness to use "
414 "watchpoint hardware is %s.\n"),
418 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
419 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
420 for unrecognized breakpoint locations.
421 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
422 static enum auto_boolean pending_break_support
;
424 show_pending_break_support (struct ui_file
*file
, int from_tty
,
425 struct cmd_list_element
*c
,
428 fprintf_filtered (file
,
429 _("Debugger's behavior regarding "
430 "pending breakpoints is %s.\n"),
434 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
435 set with "break" but falling in read-only memory.
436 If 0, gdb will warn about such breakpoints, but won't automatically
437 use hardware breakpoints. */
438 static int automatic_hardware_breakpoints
;
440 show_automatic_hardware_breakpoints (struct ui_file
*file
, int from_tty
,
441 struct cmd_list_element
*c
,
444 fprintf_filtered (file
,
445 _("Automatic usage of hardware breakpoints is %s.\n"),
449 /* If on, GDB keeps breakpoints inserted even if the inferior is
450 stopped, and immediately inserts any new breakpoints as soon as
451 they're created. If off (default), GDB keeps breakpoints off of
452 the target as long as possible. That is, it delays inserting
453 breakpoints until the next resume, and removes them again when the
454 target fully stops. This is a bit safer in case GDB crashes while
455 processing user input. */
456 static int always_inserted_mode
= 0;
459 show_always_inserted_mode (struct ui_file
*file
, int from_tty
,
460 struct cmd_list_element
*c
, const char *value
)
462 fprintf_filtered (file
, _("Always inserted breakpoint mode is %s.\n"),
466 /* See breakpoint.h. */
469 breakpoints_should_be_inserted_now (void)
471 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
473 /* If breakpoints are global, they should be inserted even if no
474 thread under gdb's control is running, or even if there are
475 no threads under GDB's control yet. */
478 else if (target_has_execution
)
480 struct thread_info
*tp
;
482 if (always_inserted_mode
)
484 /* The user wants breakpoints inserted even if all threads
489 if (threads_are_executing ())
492 /* Don't remove breakpoints yet if, even though all threads are
493 stopped, we still have events to process. */
494 ALL_NON_EXITED_THREADS (tp
)
496 && tp
->suspend
.waitstatus_pending_p
)
502 static const char condition_evaluation_both
[] = "host or target";
504 /* Modes for breakpoint condition evaluation. */
505 static const char condition_evaluation_auto
[] = "auto";
506 static const char condition_evaluation_host
[] = "host";
507 static const char condition_evaluation_target
[] = "target";
508 static const char *const condition_evaluation_enums
[] = {
509 condition_evaluation_auto
,
510 condition_evaluation_host
,
511 condition_evaluation_target
,
515 /* Global that holds the current mode for breakpoint condition evaluation. */
516 static const char *condition_evaluation_mode_1
= condition_evaluation_auto
;
518 /* Global that we use to display information to the user (gets its value from
519 condition_evaluation_mode_1. */
520 static const char *condition_evaluation_mode
= condition_evaluation_auto
;
522 /* Translate a condition evaluation mode MODE into either "host"
523 or "target". This is used mostly to translate from "auto" to the
524 real setting that is being used. It returns the translated
528 translate_condition_evaluation_mode (const char *mode
)
530 if (mode
== condition_evaluation_auto
)
532 if (target_supports_evaluation_of_breakpoint_conditions ())
533 return condition_evaluation_target
;
535 return condition_evaluation_host
;
541 /* Discovers what condition_evaluation_auto translates to. */
544 breakpoint_condition_evaluation_mode (void)
546 return translate_condition_evaluation_mode (condition_evaluation_mode
);
549 /* Return true if GDB should evaluate breakpoint conditions or false
553 gdb_evaluates_breakpoint_condition_p (void)
555 const char *mode
= breakpoint_condition_evaluation_mode ();
557 return (mode
== condition_evaluation_host
);
560 void _initialize_breakpoint (void);
562 /* Are we executing breakpoint commands? */
563 static int executing_breakpoint_commands
;
565 /* Are overlay event breakpoints enabled? */
566 static int overlay_events_enabled
;
568 /* See description in breakpoint.h. */
569 int target_exact_watchpoints
= 0;
571 /* Walk the following statement or block through all breakpoints.
572 ALL_BREAKPOINTS_SAFE does so even if the statement deletes the
573 current breakpoint. */
575 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
577 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
578 for (B = breakpoint_chain; \
579 B ? (TMP=B->next, 1): 0; \
582 /* Similar iterator for the low-level breakpoints. SAFE variant is
583 not provided so update_global_location_list must not be called
584 while executing the block of ALL_BP_LOCATIONS. */
586 #define ALL_BP_LOCATIONS(B,BP_TMP) \
587 for (BP_TMP = bp_location; \
588 BP_TMP < bp_location + bp_location_count && (B = *BP_TMP); \
591 /* Iterates through locations with address ADDRESS for the currently selected
592 program space. BP_LOCP_TMP points to each object. BP_LOCP_START points
593 to where the loop should start from.
594 If BP_LOCP_START is a NULL pointer, the macro automatically seeks the
595 appropriate location to start with. */
597 #define ALL_BP_LOCATIONS_AT_ADDR(BP_LOCP_TMP, BP_LOCP_START, ADDRESS) \
598 for (BP_LOCP_START = BP_LOCP_START == NULL ? get_first_locp_gte_addr (ADDRESS) : BP_LOCP_START, \
599 BP_LOCP_TMP = BP_LOCP_START; \
601 && (BP_LOCP_TMP < bp_location + bp_location_count \
602 && (*BP_LOCP_TMP)->address == ADDRESS); \
605 /* Iterator for tracepoints only. */
607 #define ALL_TRACEPOINTS(B) \
608 for (B = breakpoint_chain; B; B = B->next) \
609 if (is_tracepoint (B))
611 /* Chains of all breakpoints defined. */
613 struct breakpoint
*breakpoint_chain
;
615 /* Array is sorted by bp_location_compare - primarily by the ADDRESS. */
617 static struct bp_location
**bp_location
;
619 /* Number of elements of BP_LOCATION. */
621 static unsigned bp_location_count
;
623 /* Maximum alignment offset between bp_target_info.PLACED_ADDRESS and
624 ADDRESS for the current elements of BP_LOCATION which get a valid
625 result from bp_location_has_shadow. You can use it for roughly
626 limiting the subrange of BP_LOCATION to scan for shadow bytes for
627 an address you need to read. */
629 static CORE_ADDR bp_location_placed_address_before_address_max
;
631 /* Maximum offset plus alignment between bp_target_info.PLACED_ADDRESS
632 + bp_target_info.SHADOW_LEN and ADDRESS for the current elements of
633 BP_LOCATION which get a valid result from bp_location_has_shadow.
634 You can use it for roughly limiting the subrange of BP_LOCATION to
635 scan for shadow bytes for an address you need to read. */
637 static CORE_ADDR bp_location_shadow_len_after_address_max
;
639 /* The locations that no longer correspond to any breakpoint, unlinked
640 from bp_location array, but for which a hit may still be reported
642 VEC(bp_location_p
) *moribund_locations
= NULL
;
644 /* Number of last breakpoint made. */
646 static int breakpoint_count
;
648 /* The value of `breakpoint_count' before the last command that
649 created breakpoints. If the last (break-like) command created more
650 than one breakpoint, then the difference between BREAKPOINT_COUNT
651 and PREV_BREAKPOINT_COUNT is more than one. */
652 static int prev_breakpoint_count
;
654 /* Number of last tracepoint made. */
656 static int tracepoint_count
;
658 static struct cmd_list_element
*breakpoint_set_cmdlist
;
659 static struct cmd_list_element
*breakpoint_show_cmdlist
;
660 struct cmd_list_element
*save_cmdlist
;
662 /* See declaration at breakpoint.h. */
665 breakpoint_find_if (int (*func
) (struct breakpoint
*b
, void *d
),
668 struct breakpoint
*b
= NULL
;
672 if (func (b
, user_data
) != 0)
679 /* Return whether a breakpoint is an active enabled breakpoint. */
681 breakpoint_enabled (struct breakpoint
*b
)
683 return (b
->enable_state
== bp_enabled
);
686 /* Set breakpoint count to NUM. */
689 set_breakpoint_count (int num
)
691 prev_breakpoint_count
= breakpoint_count
;
692 breakpoint_count
= num
;
693 set_internalvar_integer (lookup_internalvar ("bpnum"), num
);
696 /* Used by `start_rbreak_breakpoints' below, to record the current
697 breakpoint count before "rbreak" creates any breakpoint. */
698 static int rbreak_start_breakpoint_count
;
700 /* Called at the start an "rbreak" command to record the first
704 start_rbreak_breakpoints (void)
706 rbreak_start_breakpoint_count
= breakpoint_count
;
709 /* Called at the end of an "rbreak" command to record the last
713 end_rbreak_breakpoints (void)
715 prev_breakpoint_count
= rbreak_start_breakpoint_count
;
718 /* Used in run_command to zero the hit count when a new run starts. */
721 clear_breakpoint_hit_counts (void)
723 struct breakpoint
*b
;
729 /* Allocate a new counted_command_line with reference count of 1.
730 The new structure owns COMMANDS. */
732 static struct counted_command_line
*
733 alloc_counted_command_line (struct command_line
*commands
)
735 struct counted_command_line
*result
= XNEW (struct counted_command_line
);
738 result
->commands
= commands
;
743 /* Increment reference count. This does nothing if CMD is NULL. */
746 incref_counted_command_line (struct counted_command_line
*cmd
)
752 /* Decrement reference count. If the reference count reaches 0,
753 destroy the counted_command_line. Sets *CMDP to NULL. This does
754 nothing if *CMDP is NULL. */
757 decref_counted_command_line (struct counted_command_line
**cmdp
)
761 if (--(*cmdp
)->refc
== 0)
763 free_command_lines (&(*cmdp
)->commands
);
770 /* A cleanup function that calls decref_counted_command_line. */
773 do_cleanup_counted_command_line (void *arg
)
775 decref_counted_command_line ((struct counted_command_line
**) arg
);
778 /* Create a cleanup that calls decref_counted_command_line on the
781 static struct cleanup
*
782 make_cleanup_decref_counted_command_line (struct counted_command_line
**cmdp
)
784 return make_cleanup (do_cleanup_counted_command_line
, cmdp
);
788 /* Return the breakpoint with the specified number, or NULL
789 if the number does not refer to an existing breakpoint. */
792 get_breakpoint (int num
)
794 struct breakpoint
*b
;
797 if (b
->number
== num
)
805 /* Mark locations as "conditions have changed" in case the target supports
806 evaluating conditions on its side. */
809 mark_breakpoint_modified (struct breakpoint
*b
)
811 struct bp_location
*loc
;
813 /* This is only meaningful if the target is
814 evaluating conditions and if the user has
815 opted for condition evaluation on the target's
817 if (gdb_evaluates_breakpoint_condition_p ()
818 || !target_supports_evaluation_of_breakpoint_conditions ())
821 if (!is_breakpoint (b
))
824 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
825 loc
->condition_changed
= condition_modified
;
828 /* Mark location as "conditions have changed" in case the target supports
829 evaluating conditions on its side. */
832 mark_breakpoint_location_modified (struct bp_location
*loc
)
834 /* This is only meaningful if the target is
835 evaluating conditions and if the user has
836 opted for condition evaluation on the target's
838 if (gdb_evaluates_breakpoint_condition_p ()
839 || !target_supports_evaluation_of_breakpoint_conditions ())
843 if (!is_breakpoint (loc
->owner
))
846 loc
->condition_changed
= condition_modified
;
849 /* Sets the condition-evaluation mode using the static global
850 condition_evaluation_mode. */
853 set_condition_evaluation_mode (char *args
, int from_tty
,
854 struct cmd_list_element
*c
)
856 const char *old_mode
, *new_mode
;
858 if ((condition_evaluation_mode_1
== condition_evaluation_target
)
859 && !target_supports_evaluation_of_breakpoint_conditions ())
861 condition_evaluation_mode_1
= condition_evaluation_mode
;
862 warning (_("Target does not support breakpoint condition evaluation.\n"
863 "Using host evaluation mode instead."));
867 new_mode
= translate_condition_evaluation_mode (condition_evaluation_mode_1
);
868 old_mode
= translate_condition_evaluation_mode (condition_evaluation_mode
);
870 /* Flip the switch. Flip it even if OLD_MODE == NEW_MODE as one of the
871 settings was "auto". */
872 condition_evaluation_mode
= condition_evaluation_mode_1
;
874 /* Only update the mode if the user picked a different one. */
875 if (new_mode
!= old_mode
)
877 struct bp_location
*loc
, **loc_tmp
;
878 /* If the user switched to a different evaluation mode, we
879 need to synch the changes with the target as follows:
881 "host" -> "target": Send all (valid) conditions to the target.
882 "target" -> "host": Remove all the conditions from the target.
885 if (new_mode
== condition_evaluation_target
)
887 /* Mark everything modified and synch conditions with the
889 ALL_BP_LOCATIONS (loc
, loc_tmp
)
890 mark_breakpoint_location_modified (loc
);
894 /* Manually mark non-duplicate locations to synch conditions
895 with the target. We do this to remove all the conditions the
896 target knows about. */
897 ALL_BP_LOCATIONS (loc
, loc_tmp
)
898 if (is_breakpoint (loc
->owner
) && loc
->inserted
)
899 loc
->needs_update
= 1;
903 update_global_location_list (UGLL_MAY_INSERT
);
909 /* Shows the current mode of breakpoint condition evaluation. Explicitly shows
910 what "auto" is translating to. */
913 show_condition_evaluation_mode (struct ui_file
*file
, int from_tty
,
914 struct cmd_list_element
*c
, const char *value
)
916 if (condition_evaluation_mode
== condition_evaluation_auto
)
917 fprintf_filtered (file
,
918 _("Breakpoint condition evaluation "
919 "mode is %s (currently %s).\n"),
921 breakpoint_condition_evaluation_mode ());
923 fprintf_filtered (file
, _("Breakpoint condition evaluation mode is %s.\n"),
927 /* A comparison function for bp_location AP and BP that is used by
928 bsearch. This comparison function only cares about addresses, unlike
929 the more general bp_location_compare function. */
932 bp_location_compare_addrs (const void *ap
, const void *bp
)
934 const struct bp_location
*a
= *(const struct bp_location
**) ap
;
935 const struct bp_location
*b
= *(const struct bp_location
**) bp
;
937 if (a
->address
== b
->address
)
940 return ((a
->address
> b
->address
) - (a
->address
< b
->address
));
943 /* Helper function to skip all bp_locations with addresses
944 less than ADDRESS. It returns the first bp_location that
945 is greater than or equal to ADDRESS. If none is found, just
948 static struct bp_location
**
949 get_first_locp_gte_addr (CORE_ADDR address
)
951 struct bp_location dummy_loc
;
952 struct bp_location
*dummy_locp
= &dummy_loc
;
953 struct bp_location
**locp_found
= NULL
;
955 /* Initialize the dummy location's address field. */
956 memset (&dummy_loc
, 0, sizeof (struct bp_location
));
957 dummy_loc
.address
= address
;
959 /* Find a close match to the first location at ADDRESS. */
960 locp_found
= ((struct bp_location
**)
961 bsearch (&dummy_locp
, bp_location
, bp_location_count
,
962 sizeof (struct bp_location
**),
963 bp_location_compare_addrs
));
965 /* Nothing was found, nothing left to do. */
966 if (locp_found
== NULL
)
969 /* We may have found a location that is at ADDRESS but is not the first in the
970 location's list. Go backwards (if possible) and locate the first one. */
971 while ((locp_found
- 1) >= bp_location
972 && (*(locp_found
- 1))->address
== address
)
979 set_breakpoint_condition (struct breakpoint
*b
, const char *exp
,
982 xfree (b
->cond_string
);
983 b
->cond_string
= NULL
;
985 if (is_watchpoint (b
))
987 struct watchpoint
*w
= (struct watchpoint
*) b
;
994 struct bp_location
*loc
;
996 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1001 /* No need to free the condition agent expression
1002 bytecode (if we have one). We will handle this
1003 when we go through update_global_location_list. */
1010 printf_filtered (_("Breakpoint %d now unconditional.\n"), b
->number
);
1014 const char *arg
= exp
;
1016 /* I don't know if it matters whether this is the string the user
1017 typed in or the decompiled expression. */
1018 b
->cond_string
= xstrdup (arg
);
1019 b
->condition_not_parsed
= 0;
1021 if (is_watchpoint (b
))
1023 struct watchpoint
*w
= (struct watchpoint
*) b
;
1025 innermost_block
= NULL
;
1027 w
->cond_exp
= parse_exp_1 (&arg
, 0, 0, 0);
1029 error (_("Junk at end of expression"));
1030 w
->cond_exp_valid_block
= innermost_block
;
1034 struct bp_location
*loc
;
1036 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1040 parse_exp_1 (&arg
, loc
->address
,
1041 block_for_pc (loc
->address
), 0);
1043 error (_("Junk at end of expression"));
1047 mark_breakpoint_modified (b
);
1049 observer_notify_breakpoint_modified (b
);
1052 /* Completion for the "condition" command. */
1054 static VEC (char_ptr
) *
1055 condition_completer (struct cmd_list_element
*cmd
,
1056 const char *text
, const char *word
)
1060 text
= skip_spaces_const (text
);
1061 space
= skip_to_space_const (text
);
1065 struct breakpoint
*b
;
1066 VEC (char_ptr
) *result
= NULL
;
1070 /* We don't support completion of history indices. */
1071 if (isdigit (text
[1]))
1073 return complete_internalvar (&text
[1]);
1076 /* We're completing the breakpoint number. */
1077 len
= strlen (text
);
1083 xsnprintf (number
, sizeof (number
), "%d", b
->number
);
1085 if (strncmp (number
, text
, len
) == 0)
1086 VEC_safe_push (char_ptr
, result
, xstrdup (number
));
1092 /* We're completing the expression part. */
1093 text
= skip_spaces_const (space
);
1094 return expression_completer (cmd
, text
, word
);
1097 /* condition N EXP -- set break condition of breakpoint N to EXP. */
1100 condition_command (char *arg
, int from_tty
)
1102 struct breakpoint
*b
;
1107 error_no_arg (_("breakpoint number"));
1110 bnum
= get_number (&p
);
1112 error (_("Bad breakpoint argument: '%s'"), arg
);
1115 if (b
->number
== bnum
)
1117 /* Check if this breakpoint has a "stop" method implemented in an
1118 extension language. This method and conditions entered into GDB
1119 from the CLI are mutually exclusive. */
1120 const struct extension_language_defn
*extlang
1121 = get_breakpoint_cond_ext_lang (b
, EXT_LANG_NONE
);
1123 if (extlang
!= NULL
)
1125 error (_("Only one stop condition allowed. There is currently"
1126 " a %s stop condition defined for this breakpoint."),
1127 ext_lang_capitalized_name (extlang
));
1129 set_breakpoint_condition (b
, p
, from_tty
);
1131 if (is_breakpoint (b
))
1132 update_global_location_list (UGLL_MAY_INSERT
);
1137 error (_("No breakpoint number %d."), bnum
);
1140 /* Check that COMMAND do not contain commands that are suitable
1141 only for tracepoints and not suitable for ordinary breakpoints.
1142 Throw if any such commands is found. */
1145 check_no_tracepoint_commands (struct command_line
*commands
)
1147 struct command_line
*c
;
1149 for (c
= commands
; c
; c
= c
->next
)
1153 if (c
->control_type
== while_stepping_control
)
1154 error (_("The 'while-stepping' command can "
1155 "only be used for tracepoints"));
1157 for (i
= 0; i
< c
->body_count
; ++i
)
1158 check_no_tracepoint_commands ((c
->body_list
)[i
]);
1160 /* Not that command parsing removes leading whitespace and comment
1161 lines and also empty lines. So, we only need to check for
1162 command directly. */
1163 if (strstr (c
->line
, "collect ") == c
->line
)
1164 error (_("The 'collect' command can only be used for tracepoints"));
1166 if (strstr (c
->line
, "teval ") == c
->line
)
1167 error (_("The 'teval' command can only be used for tracepoints"));
1171 /* Encapsulate tests for different types of tracepoints. */
1174 is_tracepoint_type (enum bptype type
)
1176 return (type
== bp_tracepoint
1177 || type
== bp_fast_tracepoint
1178 || type
== bp_static_tracepoint
);
1182 is_tracepoint (const struct breakpoint
*b
)
1184 return is_tracepoint_type (b
->type
);
1187 /* A helper function that validates that COMMANDS are valid for a
1188 breakpoint. This function will throw an exception if a problem is
1192 validate_commands_for_breakpoint (struct breakpoint
*b
,
1193 struct command_line
*commands
)
1195 if (is_tracepoint (b
))
1197 struct tracepoint
*t
= (struct tracepoint
*) b
;
1198 struct command_line
*c
;
1199 struct command_line
*while_stepping
= 0;
1201 /* Reset the while-stepping step count. The previous commands
1202 might have included a while-stepping action, while the new
1206 /* We need to verify that each top-level element of commands is
1207 valid for tracepoints, that there's at most one
1208 while-stepping element, and that the while-stepping's body
1209 has valid tracing commands excluding nested while-stepping.
1210 We also need to validate the tracepoint action line in the
1211 context of the tracepoint --- validate_actionline actually
1212 has side effects, like setting the tracepoint's
1213 while-stepping STEP_COUNT, in addition to checking if the
1214 collect/teval actions parse and make sense in the
1215 tracepoint's context. */
1216 for (c
= commands
; c
; c
= c
->next
)
1218 if (c
->control_type
== while_stepping_control
)
1220 if (b
->type
== bp_fast_tracepoint
)
1221 error (_("The 'while-stepping' command "
1222 "cannot be used for fast tracepoint"));
1223 else if (b
->type
== bp_static_tracepoint
)
1224 error (_("The 'while-stepping' command "
1225 "cannot be used for static tracepoint"));
1228 error (_("The 'while-stepping' command "
1229 "can be used only once"));
1234 validate_actionline (c
->line
, b
);
1238 struct command_line
*c2
;
1240 gdb_assert (while_stepping
->body_count
== 1);
1241 c2
= while_stepping
->body_list
[0];
1242 for (; c2
; c2
= c2
->next
)
1244 if (c2
->control_type
== while_stepping_control
)
1245 error (_("The 'while-stepping' command cannot be nested"));
1251 check_no_tracepoint_commands (commands
);
1255 /* Return a vector of all the static tracepoints set at ADDR. The
1256 caller is responsible for releasing the vector. */
1259 static_tracepoints_here (CORE_ADDR addr
)
1261 struct breakpoint
*b
;
1262 VEC(breakpoint_p
) *found
= 0;
1263 struct bp_location
*loc
;
1266 if (b
->type
== bp_static_tracepoint
)
1268 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1269 if (loc
->address
== addr
)
1270 VEC_safe_push(breakpoint_p
, found
, b
);
1276 /* Set the command list of B to COMMANDS. If breakpoint is tracepoint,
1277 validate that only allowed commands are included. */
1280 breakpoint_set_commands (struct breakpoint
*b
,
1281 struct command_line
*commands
)
1283 validate_commands_for_breakpoint (b
, commands
);
1285 decref_counted_command_line (&b
->commands
);
1286 b
->commands
= alloc_counted_command_line (commands
);
1287 observer_notify_breakpoint_modified (b
);
1290 /* Set the internal `silent' flag on the breakpoint. Note that this
1291 is not the same as the "silent" that may appear in the breakpoint's
1295 breakpoint_set_silent (struct breakpoint
*b
, int silent
)
1297 int old_silent
= b
->silent
;
1300 if (old_silent
!= silent
)
1301 observer_notify_breakpoint_modified (b
);
1304 /* Set the thread for this breakpoint. If THREAD is -1, make the
1305 breakpoint work for any thread. */
1308 breakpoint_set_thread (struct breakpoint
*b
, int thread
)
1310 int old_thread
= b
->thread
;
1313 if (old_thread
!= thread
)
1314 observer_notify_breakpoint_modified (b
);
1317 /* Set the task for this breakpoint. If TASK is 0, make the
1318 breakpoint work for any task. */
1321 breakpoint_set_task (struct breakpoint
*b
, int task
)
1323 int old_task
= b
->task
;
1326 if (old_task
!= task
)
1327 observer_notify_breakpoint_modified (b
);
1331 check_tracepoint_command (char *line
, void *closure
)
1333 struct breakpoint
*b
= (struct breakpoint
*) closure
;
1335 validate_actionline (line
, b
);
1338 /* A structure used to pass information through
1339 map_breakpoint_numbers. */
1341 struct commands_info
1343 /* True if the command was typed at a tty. */
1346 /* The breakpoint range spec. */
1349 /* Non-NULL if the body of the commands are being read from this
1350 already-parsed command. */
1351 struct command_line
*control
;
1353 /* The command lines read from the user, or NULL if they have not
1355 struct counted_command_line
*cmd
;
1358 /* A callback for map_breakpoint_numbers that sets the commands for
1359 commands_command. */
1362 do_map_commands_command (struct breakpoint
*b
, void *data
)
1364 struct commands_info
*info
= (struct commands_info
*) data
;
1366 if (info
->cmd
== NULL
)
1368 struct command_line
*l
;
1370 if (info
->control
!= NULL
)
1371 l
= copy_command_lines (info
->control
->body_list
[0]);
1374 struct cleanup
*old_chain
;
1377 str
= xstrprintf (_("Type commands for breakpoint(s) "
1378 "%s, one per line."),
1381 old_chain
= make_cleanup (xfree
, str
);
1383 l
= read_command_lines (str
,
1386 ? check_tracepoint_command
: 0),
1389 do_cleanups (old_chain
);
1392 info
->cmd
= alloc_counted_command_line (l
);
1395 /* If a breakpoint was on the list more than once, we don't need to
1397 if (b
->commands
!= info
->cmd
)
1399 validate_commands_for_breakpoint (b
, info
->cmd
->commands
);
1400 incref_counted_command_line (info
->cmd
);
1401 decref_counted_command_line (&b
->commands
);
1402 b
->commands
= info
->cmd
;
1403 observer_notify_breakpoint_modified (b
);
1408 commands_command_1 (char *arg
, int from_tty
,
1409 struct command_line
*control
)
1411 struct cleanup
*cleanups
;
1412 struct commands_info info
;
1414 info
.from_tty
= from_tty
;
1415 info
.control
= control
;
1417 /* If we read command lines from the user, then `info' will hold an
1418 extra reference to the commands that we must clean up. */
1419 cleanups
= make_cleanup_decref_counted_command_line (&info
.cmd
);
1421 if (arg
== NULL
|| !*arg
)
1423 if (breakpoint_count
- prev_breakpoint_count
> 1)
1424 arg
= xstrprintf ("%d-%d", prev_breakpoint_count
+ 1,
1426 else if (breakpoint_count
> 0)
1427 arg
= xstrprintf ("%d", breakpoint_count
);
1430 /* So that we don't try to free the incoming non-NULL
1431 argument in the cleanup below. Mapping breakpoint
1432 numbers will fail in this case. */
1437 /* The command loop has some static state, so we need to preserve
1439 arg
= xstrdup (arg
);
1442 make_cleanup (xfree
, arg
);
1446 map_breakpoint_numbers (arg
, do_map_commands_command
, &info
);
1448 if (info
.cmd
== NULL
)
1449 error (_("No breakpoints specified."));
1451 do_cleanups (cleanups
);
1455 commands_command (char *arg
, int from_tty
)
1457 commands_command_1 (arg
, from_tty
, NULL
);
1460 /* Like commands_command, but instead of reading the commands from
1461 input stream, takes them from an already parsed command structure.
1463 This is used by cli-script.c to DTRT with breakpoint commands
1464 that are part of if and while bodies. */
1465 enum command_control_type
1466 commands_from_control_command (char *arg
, struct command_line
*cmd
)
1468 commands_command_1 (arg
, 0, cmd
);
1469 return simple_control
;
1472 /* Return non-zero if BL->TARGET_INFO contains valid information. */
1475 bp_location_has_shadow (struct bp_location
*bl
)
1477 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
1481 if (bl
->target_info
.shadow_len
== 0)
1482 /* BL isn't valid, or doesn't shadow memory. */
1487 /* Update BUF, which is LEN bytes read from the target address
1488 MEMADDR, by replacing a memory breakpoint with its shadowed
1491 If READBUF is not NULL, this buffer must not overlap with the of
1492 the breakpoint location's shadow_contents buffer. Otherwise, a
1493 failed assertion internal error will be raised. */
1496 one_breakpoint_xfer_memory (gdb_byte
*readbuf
, gdb_byte
*writebuf
,
1497 const gdb_byte
*writebuf_org
,
1498 ULONGEST memaddr
, LONGEST len
,
1499 struct bp_target_info
*target_info
,
1500 struct gdbarch
*gdbarch
)
1502 /* Now do full processing of the found relevant range of elements. */
1503 CORE_ADDR bp_addr
= 0;
1507 if (!breakpoint_address_match (target_info
->placed_address_space
, 0,
1508 current_program_space
->aspace
, 0))
1510 /* The breakpoint is inserted in a different address space. */
1514 /* Addresses and length of the part of the breakpoint that
1516 bp_addr
= target_info
->placed_address
;
1517 bp_size
= target_info
->shadow_len
;
1519 if (bp_addr
+ bp_size
<= memaddr
)
1521 /* The breakpoint is entirely before the chunk of memory we are
1526 if (bp_addr
>= memaddr
+ len
)
1528 /* The breakpoint is entirely after the chunk of memory we are
1533 /* Offset within shadow_contents. */
1534 if (bp_addr
< memaddr
)
1536 /* Only copy the second part of the breakpoint. */
1537 bp_size
-= memaddr
- bp_addr
;
1538 bptoffset
= memaddr
- bp_addr
;
1542 if (bp_addr
+ bp_size
> memaddr
+ len
)
1544 /* Only copy the first part of the breakpoint. */
1545 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
1548 if (readbuf
!= NULL
)
1550 /* Verify that the readbuf buffer does not overlap with the
1551 shadow_contents buffer. */
1552 gdb_assert (target_info
->shadow_contents
>= readbuf
+ len
1553 || readbuf
>= (target_info
->shadow_contents
1554 + target_info
->shadow_len
));
1556 /* Update the read buffer with this inserted breakpoint's
1558 memcpy (readbuf
+ bp_addr
- memaddr
,
1559 target_info
->shadow_contents
+ bptoffset
, bp_size
);
1563 const unsigned char *bp
;
1564 CORE_ADDR addr
= target_info
->reqstd_address
;
1567 /* Update the shadow with what we want to write to memory. */
1568 memcpy (target_info
->shadow_contents
+ bptoffset
,
1569 writebuf_org
+ bp_addr
- memaddr
, bp_size
);
1571 /* Determine appropriate breakpoint contents and size for this
1573 bp
= gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &placed_size
);
1575 /* Update the final write buffer with this inserted
1576 breakpoint's INSN. */
1577 memcpy (writebuf
+ bp_addr
- memaddr
, bp
+ bptoffset
, bp_size
);
1581 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
1582 by replacing any memory breakpoints with their shadowed contents.
1584 If READBUF is not NULL, this buffer must not overlap with any of
1585 the breakpoint location's shadow_contents buffers. Otherwise,
1586 a failed assertion internal error will be raised.
1588 The range of shadowed area by each bp_location is:
1589 bl->address - bp_location_placed_address_before_address_max
1590 up to bl->address + bp_location_shadow_len_after_address_max
1591 The range we were requested to resolve shadows for is:
1592 memaddr ... memaddr + len
1593 Thus the safe cutoff boundaries for performance optimization are
1594 memaddr + len <= (bl->address
1595 - bp_location_placed_address_before_address_max)
1597 bl->address + bp_location_shadow_len_after_address_max <= memaddr */
1600 breakpoint_xfer_memory (gdb_byte
*readbuf
, gdb_byte
*writebuf
,
1601 const gdb_byte
*writebuf_org
,
1602 ULONGEST memaddr
, LONGEST len
)
1604 /* Left boundary, right boundary and median element of our binary
1606 unsigned bc_l
, bc_r
, bc
;
1608 /* Find BC_L which is a leftmost element which may affect BUF
1609 content. It is safe to report lower value but a failure to
1610 report higher one. */
1613 bc_r
= bp_location_count
;
1614 while (bc_l
+ 1 < bc_r
)
1616 struct bp_location
*bl
;
1618 bc
= (bc_l
+ bc_r
) / 2;
1619 bl
= bp_location
[bc
];
1621 /* Check first BL->ADDRESS will not overflow due to the added
1622 constant. Then advance the left boundary only if we are sure
1623 the BC element can in no way affect the BUF content (MEMADDR
1624 to MEMADDR + LEN range).
1626 Use the BP_LOCATION_SHADOW_LEN_AFTER_ADDRESS_MAX safety
1627 offset so that we cannot miss a breakpoint with its shadow
1628 range tail still reaching MEMADDR. */
1630 if ((bl
->address
+ bp_location_shadow_len_after_address_max
1632 && (bl
->address
+ bp_location_shadow_len_after_address_max
1639 /* Due to the binary search above, we need to make sure we pick the
1640 first location that's at BC_L's address. E.g., if there are
1641 multiple locations at the same address, BC_L may end up pointing
1642 at a duplicate location, and miss the "master"/"inserted"
1643 location. Say, given locations L1, L2 and L3 at addresses A and
1646 L1@A, L2@A, L3@B, ...
1648 BC_L could end up pointing at location L2, while the "master"
1649 location could be L1. Since the `loc->inserted' flag is only set
1650 on "master" locations, we'd forget to restore the shadow of L1
1653 && bp_location
[bc_l
]->address
== bp_location
[bc_l
- 1]->address
)
1656 /* Now do full processing of the found relevant range of elements. */
1658 for (bc
= bc_l
; bc
< bp_location_count
; bc
++)
1660 struct bp_location
*bl
= bp_location
[bc
];
1662 /* bp_location array has BL->OWNER always non-NULL. */
1663 if (bl
->owner
->type
== bp_none
)
1664 warning (_("reading through apparently deleted breakpoint #%d?"),
1667 /* Performance optimization: any further element can no longer affect BUF
1670 if (bl
->address
>= bp_location_placed_address_before_address_max
1671 && memaddr
+ len
<= (bl
->address
1672 - bp_location_placed_address_before_address_max
))
1675 if (!bp_location_has_shadow (bl
))
1678 one_breakpoint_xfer_memory (readbuf
, writebuf
, writebuf_org
,
1679 memaddr
, len
, &bl
->target_info
, bl
->gdbarch
);
1685 /* Return true if BPT is either a software breakpoint or a hardware
1689 is_breakpoint (const struct breakpoint
*bpt
)
1691 return (bpt
->type
== bp_breakpoint
1692 || bpt
->type
== bp_hardware_breakpoint
1693 || bpt
->type
== bp_dprintf
);
1696 /* Return true if BPT is of any hardware watchpoint kind. */
1699 is_hardware_watchpoint (const struct breakpoint
*bpt
)
1701 return (bpt
->type
== bp_hardware_watchpoint
1702 || bpt
->type
== bp_read_watchpoint
1703 || bpt
->type
== bp_access_watchpoint
);
1706 /* Return true if BPT is of any watchpoint kind, hardware or
1710 is_watchpoint (const struct breakpoint
*bpt
)
1712 return (is_hardware_watchpoint (bpt
)
1713 || bpt
->type
== bp_watchpoint
);
1716 /* Returns true if the current thread and its running state are safe
1717 to evaluate or update watchpoint B. Watchpoints on local
1718 expressions need to be evaluated in the context of the thread that
1719 was current when the watchpoint was created, and, that thread needs
1720 to be stopped to be able to select the correct frame context.
1721 Watchpoints on global expressions can be evaluated on any thread,
1722 and in any state. It is presently left to the target allowing
1723 memory accesses when threads are running. */
1726 watchpoint_in_thread_scope (struct watchpoint
*b
)
1728 return (b
->base
.pspace
== current_program_space
1729 && (ptid_equal (b
->watchpoint_thread
, null_ptid
)
1730 || (ptid_equal (inferior_ptid
, b
->watchpoint_thread
)
1731 && !is_executing (inferior_ptid
))));
1734 /* Set watchpoint B to disp_del_at_next_stop, even including its possible
1735 associated bp_watchpoint_scope breakpoint. */
1738 watchpoint_del_at_next_stop (struct watchpoint
*w
)
1740 struct breakpoint
*b
= &w
->base
;
1742 if (b
->related_breakpoint
!= b
)
1744 gdb_assert (b
->related_breakpoint
->type
== bp_watchpoint_scope
);
1745 gdb_assert (b
->related_breakpoint
->related_breakpoint
== b
);
1746 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
1747 b
->related_breakpoint
->related_breakpoint
= b
->related_breakpoint
;
1748 b
->related_breakpoint
= b
;
1750 b
->disposition
= disp_del_at_next_stop
;
1753 /* Extract a bitfield value from value VAL using the bit parameters contained in
1756 static struct value
*
1757 extract_bitfield_from_watchpoint_value (struct watchpoint
*w
, struct value
*val
)
1759 struct value
*bit_val
;
1764 bit_val
= allocate_value (value_type (val
));
1766 unpack_value_bitfield (bit_val
,
1769 value_contents_for_printing (val
),
1776 /* Allocate a dummy location and add it to B, which must be a software
1777 watchpoint. This is required because even if a software watchpoint
1778 is not watching any memory, bpstat_stop_status requires a location
1779 to be able to report stops. */
1782 software_watchpoint_add_no_memory_location (struct breakpoint
*b
,
1783 struct program_space
*pspace
)
1785 gdb_assert (b
->type
== bp_watchpoint
&& b
->loc
== NULL
);
1787 b
->loc
= allocate_bp_location (b
);
1788 b
->loc
->pspace
= pspace
;
1789 b
->loc
->address
= -1;
1790 b
->loc
->length
= -1;
1793 /* Returns true if B is a software watchpoint that is not watching any
1794 memory (e.g., "watch $pc"). */
1797 is_no_memory_software_watchpoint (struct breakpoint
*b
)
1799 return (b
->type
== bp_watchpoint
1801 && b
->loc
->next
== NULL
1802 && b
->loc
->address
== -1
1803 && b
->loc
->length
== -1);
1806 /* Assuming that B is a watchpoint:
1807 - Reparse watchpoint expression, if REPARSE is non-zero
1808 - Evaluate expression and store the result in B->val
1809 - Evaluate the condition if there is one, and store the result
1811 - Update the list of values that must be watched in B->loc.
1813 If the watchpoint disposition is disp_del_at_next_stop, then do
1814 nothing. If this is local watchpoint that is out of scope, delete
1817 Even with `set breakpoint always-inserted on' the watchpoints are
1818 removed + inserted on each stop here. Normal breakpoints must
1819 never be removed because they might be missed by a running thread
1820 when debugging in non-stop mode. On the other hand, hardware
1821 watchpoints (is_hardware_watchpoint; processed here) are specific
1822 to each LWP since they are stored in each LWP's hardware debug
1823 registers. Therefore, such LWP must be stopped first in order to
1824 be able to modify its hardware watchpoints.
1826 Hardware watchpoints must be reset exactly once after being
1827 presented to the user. It cannot be done sooner, because it would
1828 reset the data used to present the watchpoint hit to the user. And
1829 it must not be done later because it could display the same single
1830 watchpoint hit during multiple GDB stops. Note that the latter is
1831 relevant only to the hardware watchpoint types bp_read_watchpoint
1832 and bp_access_watchpoint. False hit by bp_hardware_watchpoint is
1833 not user-visible - its hit is suppressed if the memory content has
1836 The following constraints influence the location where we can reset
1837 hardware watchpoints:
1839 * target_stopped_by_watchpoint and target_stopped_data_address are
1840 called several times when GDB stops.
1843 * Multiple hardware watchpoints can be hit at the same time,
1844 causing GDB to stop. GDB only presents one hardware watchpoint
1845 hit at a time as the reason for stopping, and all the other hits
1846 are presented later, one after the other, each time the user
1847 requests the execution to be resumed. Execution is not resumed
1848 for the threads still having pending hit event stored in
1849 LWP_INFO->STATUS. While the watchpoint is already removed from
1850 the inferior on the first stop the thread hit event is kept being
1851 reported from its cached value by linux_nat_stopped_data_address
1852 until the real thread resume happens after the watchpoint gets
1853 presented and thus its LWP_INFO->STATUS gets reset.
1855 Therefore the hardware watchpoint hit can get safely reset on the
1856 watchpoint removal from inferior. */
1859 update_watchpoint (struct watchpoint
*b
, int reparse
)
1861 int within_current_scope
;
1862 struct frame_id saved_frame_id
;
1865 /* If this is a local watchpoint, we only want to check if the
1866 watchpoint frame is in scope if the current thread is the thread
1867 that was used to create the watchpoint. */
1868 if (!watchpoint_in_thread_scope (b
))
1871 if (b
->base
.disposition
== disp_del_at_next_stop
)
1876 /* Determine if the watchpoint is within scope. */
1877 if (b
->exp_valid_block
== NULL
)
1878 within_current_scope
= 1;
1881 struct frame_info
*fi
= get_current_frame ();
1882 struct gdbarch
*frame_arch
= get_frame_arch (fi
);
1883 CORE_ADDR frame_pc
= get_frame_pc (fi
);
1885 /* If we're at a point where the stack has been destroyed
1886 (e.g. in a function epilogue), unwinding may not work
1887 properly. Do not attempt to recreate locations at this
1888 point. See similar comments in watchpoint_check. */
1889 if (gdbarch_stack_frame_destroyed_p (frame_arch
, frame_pc
))
1892 /* Save the current frame's ID so we can restore it after
1893 evaluating the watchpoint expression on its own frame. */
1894 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
1895 took a frame parameter, so that we didn't have to change the
1898 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
1900 fi
= frame_find_by_id (b
->watchpoint_frame
);
1901 within_current_scope
= (fi
!= NULL
);
1902 if (within_current_scope
)
1906 /* We don't free locations. They are stored in the bp_location array
1907 and update_global_location_list will eventually delete them and
1908 remove breakpoints if needed. */
1911 if (within_current_scope
&& reparse
)
1920 s
= b
->exp_string_reparse
? b
->exp_string_reparse
: b
->exp_string
;
1921 b
->exp
= parse_exp_1 (&s
, 0, b
->exp_valid_block
, 0);
1922 /* If the meaning of expression itself changed, the old value is
1923 no longer relevant. We don't want to report a watchpoint hit
1924 to the user when the old value and the new value may actually
1925 be completely different objects. */
1926 value_free (b
->val
);
1930 /* Note that unlike with breakpoints, the watchpoint's condition
1931 expression is stored in the breakpoint object, not in the
1932 locations (re)created below. */
1933 if (b
->base
.cond_string
!= NULL
)
1935 if (b
->cond_exp
!= NULL
)
1937 xfree (b
->cond_exp
);
1941 s
= b
->base
.cond_string
;
1942 b
->cond_exp
= parse_exp_1 (&s
, 0, b
->cond_exp_valid_block
, 0);
1946 /* If we failed to parse the expression, for example because
1947 it refers to a global variable in a not-yet-loaded shared library,
1948 don't try to insert watchpoint. We don't automatically delete
1949 such watchpoint, though, since failure to parse expression
1950 is different from out-of-scope watchpoint. */
1951 if (!target_has_execution
)
1953 /* Without execution, memory can't change. No use to try and
1954 set watchpoint locations. The watchpoint will be reset when
1955 the target gains execution, through breakpoint_re_set. */
1956 if (!can_use_hw_watchpoints
)
1958 if (b
->base
.ops
->works_in_software_mode (&b
->base
))
1959 b
->base
.type
= bp_watchpoint
;
1961 error (_("Can't set read/access watchpoint when "
1962 "hardware watchpoints are disabled."));
1965 else if (within_current_scope
&& b
->exp
)
1968 struct value
*val_chain
, *v
, *result
, *next
;
1969 struct program_space
*frame_pspace
;
1971 fetch_subexp_value (b
->exp
, &pc
, &v
, &result
, &val_chain
, 0);
1973 /* Avoid setting b->val if it's already set. The meaning of
1974 b->val is 'the last value' user saw, and we should update
1975 it only if we reported that last value to user. As it
1976 happens, the code that reports it updates b->val directly.
1977 We don't keep track of the memory value for masked
1979 if (!b
->val_valid
&& !is_masked_watchpoint (&b
->base
))
1981 if (b
->val_bitsize
!= 0)
1983 v
= extract_bitfield_from_watchpoint_value (b
, v
);
1991 frame_pspace
= get_frame_program_space (get_selected_frame (NULL
));
1993 /* Look at each value on the value chain. */
1994 for (v
= val_chain
; v
; v
= value_next (v
))
1996 /* If it's a memory location, and GDB actually needed
1997 its contents to evaluate the expression, then we
1998 must watch it. If the first value returned is
1999 still lazy, that means an error occurred reading it;
2000 watch it anyway in case it becomes readable. */
2001 if (VALUE_LVAL (v
) == lval_memory
2002 && (v
== val_chain
|| ! value_lazy (v
)))
2004 struct type
*vtype
= check_typedef (value_type (v
));
2006 /* We only watch structs and arrays if user asked
2007 for it explicitly, never if they just happen to
2008 appear in the middle of some value chain. */
2010 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
2011 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
2014 enum target_hw_bp_type type
;
2015 struct bp_location
*loc
, **tmp
;
2016 int bitpos
= 0, bitsize
= 0;
2018 if (value_bitsize (v
) != 0)
2020 /* Extract the bit parameters out from the bitfield
2022 bitpos
= value_bitpos (v
);
2023 bitsize
= value_bitsize (v
);
2025 else if (v
== result
&& b
->val_bitsize
!= 0)
2027 /* If VAL_BITSIZE != 0 then RESULT is actually a bitfield
2028 lvalue whose bit parameters are saved in the fields
2029 VAL_BITPOS and VAL_BITSIZE. */
2030 bitpos
= b
->val_bitpos
;
2031 bitsize
= b
->val_bitsize
;
2034 addr
= value_address (v
);
2037 /* Skip the bytes that don't contain the bitfield. */
2042 if (b
->base
.type
== bp_read_watchpoint
)
2044 else if (b
->base
.type
== bp_access_watchpoint
)
2047 loc
= allocate_bp_location (&b
->base
);
2048 for (tmp
= &(b
->base
.loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
2051 loc
->gdbarch
= get_type_arch (value_type (v
));
2053 loc
->pspace
= frame_pspace
;
2054 loc
->address
= addr
;
2058 /* Just cover the bytes that make up the bitfield. */
2059 loc
->length
= ((bitpos
% 8) + bitsize
+ 7) / 8;
2062 loc
->length
= TYPE_LENGTH (value_type (v
));
2064 loc
->watchpoint_type
= type
;
2069 /* Change the type of breakpoint between hardware assisted or
2070 an ordinary watchpoint depending on the hardware support
2071 and free hardware slots. REPARSE is set when the inferior
2076 enum bp_loc_type loc_type
;
2077 struct bp_location
*bl
;
2079 reg_cnt
= can_use_hardware_watchpoint (val_chain
);
2083 int i
, target_resources_ok
, other_type_used
;
2086 /* Use an exact watchpoint when there's only one memory region to be
2087 watched, and only one debug register is needed to watch it. */
2088 b
->exact
= target_exact_watchpoints
&& reg_cnt
== 1;
2090 /* We need to determine how many resources are already
2091 used for all other hardware watchpoints plus this one
2092 to see if we still have enough resources to also fit
2093 this watchpoint in as well. */
2095 /* If this is a software watchpoint, we try to turn it
2096 to a hardware one -- count resources as if B was of
2097 hardware watchpoint type. */
2098 type
= b
->base
.type
;
2099 if (type
== bp_watchpoint
)
2100 type
= bp_hardware_watchpoint
;
2102 /* This watchpoint may or may not have been placed on
2103 the list yet at this point (it won't be in the list
2104 if we're trying to create it for the first time,
2105 through watch_command), so always account for it
2108 /* Count resources used by all watchpoints except B. */
2109 i
= hw_watchpoint_used_count_others (&b
->base
, type
, &other_type_used
);
2111 /* Add in the resources needed for B. */
2112 i
+= hw_watchpoint_use_count (&b
->base
);
2115 = target_can_use_hardware_watchpoint (type
, i
, other_type_used
);
2116 if (target_resources_ok
<= 0)
2118 int sw_mode
= b
->base
.ops
->works_in_software_mode (&b
->base
);
2120 if (target_resources_ok
== 0 && !sw_mode
)
2121 error (_("Target does not support this type of "
2122 "hardware watchpoint."));
2123 else if (target_resources_ok
< 0 && !sw_mode
)
2124 error (_("There are not enough available hardware "
2125 "resources for this watchpoint."));
2127 /* Downgrade to software watchpoint. */
2128 b
->base
.type
= bp_watchpoint
;
2132 /* If this was a software watchpoint, we've just
2133 found we have enough resources to turn it to a
2134 hardware watchpoint. Otherwise, this is a
2136 b
->base
.type
= type
;
2139 else if (!b
->base
.ops
->works_in_software_mode (&b
->base
))
2141 if (!can_use_hw_watchpoints
)
2142 error (_("Can't set read/access watchpoint when "
2143 "hardware watchpoints are disabled."));
2145 error (_("Expression cannot be implemented with "
2146 "read/access watchpoint."));
2149 b
->base
.type
= bp_watchpoint
;
2151 loc_type
= (b
->base
.type
== bp_watchpoint
? bp_loc_other
2152 : bp_loc_hardware_watchpoint
);
2153 for (bl
= b
->base
.loc
; bl
; bl
= bl
->next
)
2154 bl
->loc_type
= loc_type
;
2157 for (v
= val_chain
; v
; v
= next
)
2159 next
= value_next (v
);
2164 /* If a software watchpoint is not watching any memory, then the
2165 above left it without any location set up. But,
2166 bpstat_stop_status requires a location to be able to report
2167 stops, so make sure there's at least a dummy one. */
2168 if (b
->base
.type
== bp_watchpoint
&& b
->base
.loc
== NULL
)
2169 software_watchpoint_add_no_memory_location (&b
->base
, frame_pspace
);
2171 else if (!within_current_scope
)
2173 printf_filtered (_("\
2174 Watchpoint %d deleted because the program has left the block\n\
2175 in which its expression is valid.\n"),
2177 watchpoint_del_at_next_stop (b
);
2180 /* Restore the selected frame. */
2182 select_frame (frame_find_by_id (saved_frame_id
));
2186 /* Returns 1 iff breakpoint location should be
2187 inserted in the inferior. We don't differentiate the type of BL's owner
2188 (breakpoint vs. tracepoint), although insert_location in tracepoint's
2189 breakpoint_ops is not defined, because in insert_bp_location,
2190 tracepoint's insert_location will not be called. */
2192 should_be_inserted (struct bp_location
*bl
)
2194 if (bl
->owner
== NULL
|| !breakpoint_enabled (bl
->owner
))
2197 if (bl
->owner
->disposition
== disp_del_at_next_stop
)
2200 if (!bl
->enabled
|| bl
->shlib_disabled
|| bl
->duplicate
)
2203 if (user_breakpoint_p (bl
->owner
) && bl
->pspace
->executing_startup
)
2206 /* This is set for example, when we're attached to the parent of a
2207 vfork, and have detached from the child. The child is running
2208 free, and we expect it to do an exec or exit, at which point the
2209 OS makes the parent schedulable again (and the target reports
2210 that the vfork is done). Until the child is done with the shared
2211 memory region, do not insert breakpoints in the parent, otherwise
2212 the child could still trip on the parent's breakpoints. Since
2213 the parent is blocked anyway, it won't miss any breakpoint. */
2214 if (bl
->pspace
->breakpoints_not_allowed
)
2217 /* Don't insert a breakpoint if we're trying to step past its
2218 location, except if the breakpoint is a single-step breakpoint,
2219 and the breakpoint's thread is the thread which is stepping past
2221 if ((bl
->loc_type
== bp_loc_software_breakpoint
2222 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
2223 && stepping_past_instruction_at (bl
->pspace
->aspace
,
2225 /* The single-step breakpoint may be inserted at the location
2226 we're trying to step if the instruction branches to itself.
2227 However, the instruction won't be executed at all and it may
2228 break the semantics of the instruction, for example, the
2229 instruction is a conditional branch or updates some flags.
2230 We can't fix it unless GDB is able to emulate the instruction
2231 or switch to displaced stepping. */
2232 && !(bl
->owner
->type
== bp_single_step
2233 && thread_is_stepping_over_breakpoint (bl
->owner
->thread
)))
2237 fprintf_unfiltered (gdb_stdlog
,
2238 "infrun: skipping breakpoint: "
2239 "stepping past insn at: %s\n",
2240 paddress (bl
->gdbarch
, bl
->address
));
2245 /* Don't insert watchpoints if we're trying to step past the
2246 instruction that triggered one. */
2247 if ((bl
->loc_type
== bp_loc_hardware_watchpoint
)
2248 && stepping_past_nonsteppable_watchpoint ())
2252 fprintf_unfiltered (gdb_stdlog
,
2253 "infrun: stepping past non-steppable watchpoint. "
2254 "skipping watchpoint at %s:%d\n",
2255 paddress (bl
->gdbarch
, bl
->address
),
2264 /* Same as should_be_inserted but does the check assuming
2265 that the location is not duplicated. */
2268 unduplicated_should_be_inserted (struct bp_location
*bl
)
2271 const int save_duplicate
= bl
->duplicate
;
2274 result
= should_be_inserted (bl
);
2275 bl
->duplicate
= save_duplicate
;
2279 /* Parses a conditional described by an expression COND into an
2280 agent expression bytecode suitable for evaluation
2281 by the bytecode interpreter. Return NULL if there was
2282 any error during parsing. */
2284 static struct agent_expr
*
2285 parse_cond_to_aexpr (CORE_ADDR scope
, struct expression
*cond
)
2287 struct agent_expr
*aexpr
= NULL
;
2292 /* We don't want to stop processing, so catch any errors
2293 that may show up. */
2296 aexpr
= gen_eval_for_expr (scope
, cond
);
2299 CATCH (ex
, RETURN_MASK_ERROR
)
2301 /* If we got here, it means the condition could not be parsed to a valid
2302 bytecode expression and thus can't be evaluated on the target's side.
2303 It's no use iterating through the conditions. */
2308 /* We have a valid agent expression. */
2312 /* Based on location BL, create a list of breakpoint conditions to be
2313 passed on to the target. If we have duplicated locations with different
2314 conditions, we will add such conditions to the list. The idea is that the
2315 target will evaluate the list of conditions and will only notify GDB when
2316 one of them is true. */
2319 build_target_condition_list (struct bp_location
*bl
)
2321 struct bp_location
**locp
= NULL
, **loc2p
;
2322 int null_condition_or_parse_error
= 0;
2323 int modified
= bl
->needs_update
;
2324 struct bp_location
*loc
;
2326 /* Release conditions left over from a previous insert. */
2327 VEC_free (agent_expr_p
, bl
->target_info
.conditions
);
2329 /* This is only meaningful if the target is
2330 evaluating conditions and if the user has
2331 opted for condition evaluation on the target's
2333 if (gdb_evaluates_breakpoint_condition_p ()
2334 || !target_supports_evaluation_of_breakpoint_conditions ())
2337 /* Do a first pass to check for locations with no assigned
2338 conditions or conditions that fail to parse to a valid agent expression
2339 bytecode. If any of these happen, then it's no use to send conditions
2340 to the target since this location will always trigger and generate a
2341 response back to GDB. */
2342 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2345 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2349 struct agent_expr
*aexpr
;
2351 /* Re-parse the conditions since something changed. In that
2352 case we already freed the condition bytecodes (see
2353 force_breakpoint_reinsertion). We just
2354 need to parse the condition to bytecodes again. */
2355 aexpr
= parse_cond_to_aexpr (bl
->address
, loc
->cond
);
2356 loc
->cond_bytecode
= aexpr
;
2359 /* If we have a NULL bytecode expression, it means something
2360 went wrong or we have a null condition expression. */
2361 if (!loc
->cond_bytecode
)
2363 null_condition_or_parse_error
= 1;
2369 /* If any of these happened, it means we will have to evaluate the conditions
2370 for the location's address on gdb's side. It is no use keeping bytecodes
2371 for all the other duplicate locations, thus we free all of them here.
2373 This is so we have a finer control over which locations' conditions are
2374 being evaluated by GDB or the remote stub. */
2375 if (null_condition_or_parse_error
)
2377 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2380 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2382 /* Only go as far as the first NULL bytecode is
2384 if (!loc
->cond_bytecode
)
2387 free_agent_expr (loc
->cond_bytecode
);
2388 loc
->cond_bytecode
= NULL
;
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
2403 /* Add the condition to the vector. This will be used later to send the
2404 conditions to the target. */
2405 VEC_safe_push (agent_expr_p
, bl
->target_info
.conditions
,
2406 loc
->cond_bytecode
);
2412 /* Parses a command described by string CMD into an agent expression
2413 bytecode suitable for evaluation by the bytecode interpreter.
2414 Return NULL if there was any error during parsing. */
2416 static struct agent_expr
*
2417 parse_cmd_to_aexpr (CORE_ADDR scope
, char *cmd
)
2419 struct cleanup
*old_cleanups
= 0;
2420 struct expression
*expr
, **argvec
;
2421 struct agent_expr
*aexpr
= NULL
;
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 expr
= parse_exp_1 (&cmd1
, scope
, block_for_pc (scope
), 1);
2472 argvec
[nargs
++] = expr
;
2474 if (*cmdrest
== ',')
2478 /* We don't want to stop processing, so catch any errors
2479 that may show up. */
2482 aexpr
= gen_printf (scope
, gdbarch
, 0, 0,
2483 format_start
, format_end
- format_start
,
2484 fpieces
, nargs
, argvec
);
2486 CATCH (ex
, RETURN_MASK_ERROR
)
2488 /* If we got here, it means the command could not be parsed to a valid
2489 bytecode expression and thus can't be evaluated on the target's side.
2490 It's no use iterating through the other commands. */
2495 do_cleanups (old_cleanups
);
2497 /* We have a valid agent expression, return it. */
2501 /* Based on location BL, create a list of breakpoint commands to be
2502 passed on to the target. If we have duplicated locations with
2503 different commands, we will add any such to the list. */
2506 build_target_command_list (struct bp_location
*bl
)
2508 struct bp_location
**locp
= NULL
, **loc2p
;
2509 int null_command_or_parse_error
= 0;
2510 int modified
= bl
->needs_update
;
2511 struct bp_location
*loc
;
2513 /* Release commands left over from a previous insert. */
2514 VEC_free (agent_expr_p
, bl
->target_info
.tcommands
);
2516 if (!target_can_run_breakpoint_commands ())
2519 /* For now, limit to agent-style dprintf breakpoints. */
2520 if (dprintf_style
!= dprintf_style_agent
)
2523 /* For now, if we have any duplicate location that isn't a dprintf,
2524 don't install the target-side commands, as that would make the
2525 breakpoint not be reported to the core, and we'd lose
2527 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2530 if (is_breakpoint (loc
->owner
)
2531 && loc
->pspace
->num
== bl
->pspace
->num
2532 && loc
->owner
->type
!= bp_dprintf
)
2536 /* Do a first pass to check for locations with no assigned
2537 conditions or conditions that fail to parse to a valid agent expression
2538 bytecode. If any of these happen, then it's no use to send conditions
2539 to the target since this location will always trigger and generate a
2540 response back to GDB. */
2541 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2544 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2548 struct agent_expr
*aexpr
;
2550 /* Re-parse the commands since something changed. In that
2551 case we already freed the command bytecodes (see
2552 force_breakpoint_reinsertion). We just
2553 need to parse the command to bytecodes again. */
2554 aexpr
= parse_cmd_to_aexpr (bl
->address
,
2555 loc
->owner
->extra_string
);
2556 loc
->cmd_bytecode
= aexpr
;
2559 /* If we have a NULL bytecode expression, it means something
2560 went wrong or we have a null command expression. */
2561 if (!loc
->cmd_bytecode
)
2563 null_command_or_parse_error
= 1;
2569 /* If anything failed, then we're not doing target-side commands,
2571 if (null_command_or_parse_error
)
2573 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2576 if (is_breakpoint (loc
->owner
)
2577 && loc
->pspace
->num
== bl
->pspace
->num
)
2579 /* Only go as far as the first NULL bytecode is
2581 if (loc
->cmd_bytecode
== NULL
)
2584 free_agent_expr (loc
->cmd_bytecode
);
2585 loc
->cmd_bytecode
= NULL
;
2590 /* No NULL commands or failed bytecode generation. Build a command list
2591 for this location's address. */
2592 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2595 if (loc
->owner
->extra_string
2596 && is_breakpoint (loc
->owner
)
2597 && loc
->pspace
->num
== bl
->pspace
->num
2598 && loc
->owner
->enable_state
== bp_enabled
2600 /* Add the command to the vector. This will be used later
2601 to send the commands to the target. */
2602 VEC_safe_push (agent_expr_p
, bl
->target_info
.tcommands
,
2606 bl
->target_info
.persist
= 0;
2607 /* Maybe flag this location as persistent. */
2608 if (bl
->owner
->type
== bp_dprintf
&& disconnected_dprintf
)
2609 bl
->target_info
.persist
= 1;
2612 /* Insert a low-level "breakpoint" of some type. BL is the breakpoint
2613 location. Any error messages are printed to TMP_ERROR_STREAM; and
2614 DISABLED_BREAKS, and HW_BREAKPOINT_ERROR are used to report problems.
2615 Returns 0 for success, 1 if the bp_location type is not supported or
2618 NOTE drow/2003-09-09: This routine could be broken down to an
2619 object-style method for each breakpoint or catchpoint type. */
2621 insert_bp_location (struct bp_location
*bl
,
2622 struct ui_file
*tmp_error_stream
,
2623 int *disabled_breaks
,
2624 int *hw_breakpoint_error
,
2625 int *hw_bp_error_explained_already
)
2627 enum errors bp_err
= GDB_NO_ERROR
;
2628 const char *bp_err_message
= NULL
;
2630 if (!should_be_inserted (bl
) || (bl
->inserted
&& !bl
->needs_update
))
2633 /* Note we don't initialize bl->target_info, as that wipes out
2634 the breakpoint location's shadow_contents if the breakpoint
2635 is still inserted at that location. This in turn breaks
2636 target_read_memory which depends on these buffers when
2637 a memory read is requested at the breakpoint location:
2638 Once the target_info has been wiped, we fail to see that
2639 we have a breakpoint inserted at that address and thus
2640 read the breakpoint instead of returning the data saved in
2641 the breakpoint location's shadow contents. */
2642 bl
->target_info
.reqstd_address
= bl
->address
;
2643 bl
->target_info
.placed_address_space
= bl
->pspace
->aspace
;
2644 bl
->target_info
.length
= bl
->length
;
2646 /* When working with target-side conditions, we must pass all the conditions
2647 for the same breakpoint address down to the target since GDB will not
2648 insert those locations. With a list of breakpoint conditions, the target
2649 can decide when to stop and notify GDB. */
2651 if (is_breakpoint (bl
->owner
))
2653 build_target_condition_list (bl
);
2654 build_target_command_list (bl
);
2655 /* Reset the modification marker. */
2656 bl
->needs_update
= 0;
2659 if (bl
->loc_type
== bp_loc_software_breakpoint
2660 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
2662 if (bl
->owner
->type
!= bp_hardware_breakpoint
)
2664 /* If the explicitly specified breakpoint type
2665 is not hardware breakpoint, check the memory map to see
2666 if the breakpoint address is in read only memory or not.
2668 Two important cases are:
2669 - location type is not hardware breakpoint, memory
2670 is readonly. We change the type of the location to
2671 hardware breakpoint.
2672 - location type is hardware breakpoint, memory is
2673 read-write. This means we've previously made the
2674 location hardware one, but then the memory map changed,
2677 When breakpoints are removed, remove_breakpoints will use
2678 location types we've just set here, the only possible
2679 problem is that memory map has changed during running
2680 program, but it's not going to work anyway with current
2682 struct mem_region
*mr
2683 = lookup_mem_region (bl
->target_info
.reqstd_address
);
2687 if (automatic_hardware_breakpoints
)
2689 enum bp_loc_type new_type
;
2691 if (mr
->attrib
.mode
!= MEM_RW
)
2692 new_type
= bp_loc_hardware_breakpoint
;
2694 new_type
= bp_loc_software_breakpoint
;
2696 if (new_type
!= bl
->loc_type
)
2698 static int said
= 0;
2700 bl
->loc_type
= new_type
;
2703 fprintf_filtered (gdb_stdout
,
2704 _("Note: automatically using "
2705 "hardware breakpoints for "
2706 "read-only addresses.\n"));
2711 else if (bl
->loc_type
== bp_loc_software_breakpoint
2712 && mr
->attrib
.mode
!= MEM_RW
)
2714 fprintf_unfiltered (tmp_error_stream
,
2715 _("Cannot insert breakpoint %d.\n"
2716 "Cannot set software breakpoint "
2717 "at read-only address %s\n"),
2719 paddress (bl
->gdbarch
, bl
->address
));
2725 /* First check to see if we have to handle an overlay. */
2726 if (overlay_debugging
== ovly_off
2727 || bl
->section
== NULL
2728 || !(section_is_overlay (bl
->section
)))
2730 /* No overlay handling: just set the breakpoint. */
2735 val
= bl
->owner
->ops
->insert_location (bl
);
2737 bp_err
= GENERIC_ERROR
;
2739 CATCH (e
, RETURN_MASK_ALL
)
2742 bp_err_message
= e
.message
;
2748 /* This breakpoint is in an overlay section.
2749 Shall we set a breakpoint at the LMA? */
2750 if (!overlay_events_enabled
)
2752 /* Yes -- overlay event support is not active,
2753 so we must try to set a breakpoint at the LMA.
2754 This will not work for a hardware breakpoint. */
2755 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
2756 warning (_("hardware breakpoint %d not supported in overlay!"),
2760 CORE_ADDR addr
= overlay_unmapped_address (bl
->address
,
2762 /* Set a software (trap) breakpoint at the LMA. */
2763 bl
->overlay_target_info
= bl
->target_info
;
2764 bl
->overlay_target_info
.reqstd_address
= addr
;
2766 /* No overlay handling: just set the breakpoint. */
2771 val
= target_insert_breakpoint (bl
->gdbarch
,
2772 &bl
->overlay_target_info
);
2774 bp_err
= GENERIC_ERROR
;
2776 CATCH (e
, RETURN_MASK_ALL
)
2779 bp_err_message
= e
.message
;
2783 if (bp_err
!= GDB_NO_ERROR
)
2784 fprintf_unfiltered (tmp_error_stream
,
2785 "Overlay breakpoint %d "
2786 "failed: in ROM?\n",
2790 /* Shall we set a breakpoint at the VMA? */
2791 if (section_is_mapped (bl
->section
))
2793 /* Yes. This overlay section is mapped into memory. */
2798 val
= bl
->owner
->ops
->insert_location (bl
);
2800 bp_err
= GENERIC_ERROR
;
2802 CATCH (e
, RETURN_MASK_ALL
)
2805 bp_err_message
= e
.message
;
2811 /* No. This breakpoint will not be inserted.
2812 No error, but do not mark the bp as 'inserted'. */
2817 if (bp_err
!= GDB_NO_ERROR
)
2819 /* Can't set the breakpoint. */
2821 /* In some cases, we might not be able to insert a
2822 breakpoint in a shared library that has already been
2823 removed, but we have not yet processed the shlib unload
2824 event. Unfortunately, some targets that implement
2825 breakpoint insertion themselves can't tell why the
2826 breakpoint insertion failed (e.g., the remote target
2827 doesn't define error codes), so we must treat generic
2828 errors as memory errors. */
2829 if ((bp_err
== GENERIC_ERROR
|| bp_err
== MEMORY_ERROR
)
2830 && bl
->loc_type
== bp_loc_software_breakpoint
2831 && (solib_name_from_address (bl
->pspace
, bl
->address
)
2832 || shared_objfile_contains_address_p (bl
->pspace
,
2835 /* See also: disable_breakpoints_in_shlibs. */
2836 bl
->shlib_disabled
= 1;
2837 observer_notify_breakpoint_modified (bl
->owner
);
2838 if (!*disabled_breaks
)
2840 fprintf_unfiltered (tmp_error_stream
,
2841 "Cannot insert breakpoint %d.\n",
2843 fprintf_unfiltered (tmp_error_stream
,
2844 "Temporarily disabling shared "
2845 "library breakpoints:\n");
2847 *disabled_breaks
= 1;
2848 fprintf_unfiltered (tmp_error_stream
,
2849 "breakpoint #%d\n", bl
->owner
->number
);
2854 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
2856 *hw_breakpoint_error
= 1;
2857 *hw_bp_error_explained_already
= bp_err_message
!= NULL
;
2858 fprintf_unfiltered (tmp_error_stream
,
2859 "Cannot insert hardware breakpoint %d%s",
2860 bl
->owner
->number
, bp_err_message
? ":" : ".\n");
2861 if (bp_err_message
!= NULL
)
2862 fprintf_unfiltered (tmp_error_stream
, "%s.\n", bp_err_message
);
2866 if (bp_err_message
== NULL
)
2869 = memory_error_message (TARGET_XFER_E_IO
,
2870 bl
->gdbarch
, bl
->address
);
2871 struct cleanup
*old_chain
= make_cleanup (xfree
, message
);
2873 fprintf_unfiltered (tmp_error_stream
,
2874 "Cannot insert breakpoint %d.\n"
2876 bl
->owner
->number
, message
);
2877 do_cleanups (old_chain
);
2881 fprintf_unfiltered (tmp_error_stream
,
2882 "Cannot insert breakpoint %d: %s\n",
2897 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
2898 /* NOTE drow/2003-09-08: This state only exists for removing
2899 watchpoints. It's not clear that it's necessary... */
2900 && bl
->owner
->disposition
!= disp_del_at_next_stop
)
2904 gdb_assert (bl
->owner
->ops
!= NULL
2905 && bl
->owner
->ops
->insert_location
!= NULL
);
2907 val
= bl
->owner
->ops
->insert_location (bl
);
2909 /* If trying to set a read-watchpoint, and it turns out it's not
2910 supported, try emulating one with an access watchpoint. */
2911 if (val
== 1 && bl
->watchpoint_type
== hw_read
)
2913 struct bp_location
*loc
, **loc_temp
;
2915 /* But don't try to insert it, if there's already another
2916 hw_access location that would be considered a duplicate
2918 ALL_BP_LOCATIONS (loc
, loc_temp
)
2920 && loc
->watchpoint_type
== hw_access
2921 && watchpoint_locations_match (bl
, loc
))
2925 bl
->target_info
= loc
->target_info
;
2926 bl
->watchpoint_type
= hw_access
;
2933 bl
->watchpoint_type
= hw_access
;
2934 val
= bl
->owner
->ops
->insert_location (bl
);
2937 /* Back to the original value. */
2938 bl
->watchpoint_type
= hw_read
;
2942 bl
->inserted
= (val
== 0);
2945 else if (bl
->owner
->type
== bp_catchpoint
)
2949 gdb_assert (bl
->owner
->ops
!= NULL
2950 && bl
->owner
->ops
->insert_location
!= NULL
);
2952 val
= bl
->owner
->ops
->insert_location (bl
);
2955 bl
->owner
->enable_state
= bp_disabled
;
2959 Error inserting catchpoint %d: Your system does not support this type\n\
2960 of catchpoint."), bl
->owner
->number
);
2962 warning (_("Error inserting catchpoint %d."), bl
->owner
->number
);
2965 bl
->inserted
= (val
== 0);
2967 /* We've already printed an error message if there was a problem
2968 inserting this catchpoint, and we've disabled the catchpoint,
2969 so just return success. */
2976 /* This function is called when program space PSPACE is about to be
2977 deleted. It takes care of updating breakpoints to not reference
2981 breakpoint_program_space_exit (struct program_space
*pspace
)
2983 struct breakpoint
*b
, *b_temp
;
2984 struct bp_location
*loc
, **loc_temp
;
2986 /* Remove any breakpoint that was set through this program space. */
2987 ALL_BREAKPOINTS_SAFE (b
, b_temp
)
2989 if (b
->pspace
== pspace
)
2990 delete_breakpoint (b
);
2993 /* Breakpoints set through other program spaces could have locations
2994 bound to PSPACE as well. Remove those. */
2995 ALL_BP_LOCATIONS (loc
, loc_temp
)
2997 struct bp_location
*tmp
;
2999 if (loc
->pspace
== pspace
)
3001 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
3002 if (loc
->owner
->loc
== loc
)
3003 loc
->owner
->loc
= loc
->next
;
3005 for (tmp
= loc
->owner
->loc
; tmp
->next
!= NULL
; tmp
= tmp
->next
)
3006 if (tmp
->next
== loc
)
3008 tmp
->next
= loc
->next
;
3014 /* Now update the global location list to permanently delete the
3015 removed locations above. */
3016 update_global_location_list (UGLL_DONT_INSERT
);
3019 /* Make sure all breakpoints are inserted in inferior.
3020 Throws exception on any error.
3021 A breakpoint that is already inserted won't be inserted
3022 again, so calling this function twice is safe. */
3024 insert_breakpoints (void)
3026 struct breakpoint
*bpt
;
3028 ALL_BREAKPOINTS (bpt
)
3029 if (is_hardware_watchpoint (bpt
))
3031 struct watchpoint
*w
= (struct watchpoint
*) bpt
;
3033 update_watchpoint (w
, 0 /* don't reparse. */);
3036 /* Updating watchpoints creates new locations, so update the global
3037 location list. Explicitly tell ugll to insert locations and
3038 ignore breakpoints_always_inserted_mode. */
3039 update_global_location_list (UGLL_INSERT
);
3042 /* Invoke CALLBACK for each of bp_location. */
3045 iterate_over_bp_locations (walk_bp_location_callback callback
)
3047 struct bp_location
*loc
, **loc_tmp
;
3049 ALL_BP_LOCATIONS (loc
, loc_tmp
)
3051 callback (loc
, NULL
);
3055 /* This is used when we need to synch breakpoint conditions between GDB and the
3056 target. It is the case with deleting and disabling of breakpoints when using
3057 always-inserted mode. */
3060 update_inserted_breakpoint_locations (void)
3062 struct bp_location
*bl
, **blp_tmp
;
3065 int disabled_breaks
= 0;
3066 int hw_breakpoint_error
= 0;
3067 int hw_bp_details_reported
= 0;
3069 struct ui_file
*tmp_error_stream
= mem_fileopen ();
3070 struct cleanup
*cleanups
= make_cleanup_ui_file_delete (tmp_error_stream
);
3072 /* Explicitly mark the warning -- this will only be printed if
3073 there was an error. */
3074 fprintf_unfiltered (tmp_error_stream
, "Warning:\n");
3076 save_current_space_and_thread ();
3078 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3080 /* We only want to update software breakpoints and hardware
3082 if (!is_breakpoint (bl
->owner
))
3085 /* We only want to update locations that are already inserted
3086 and need updating. This is to avoid unwanted insertion during
3087 deletion of breakpoints. */
3088 if (!bl
->inserted
|| (bl
->inserted
&& !bl
->needs_update
))
3091 switch_to_program_space_and_thread (bl
->pspace
);
3093 /* For targets that support global breakpoints, there's no need
3094 to select an inferior to insert breakpoint to. In fact, even
3095 if we aren't attached to any process yet, we should still
3096 insert breakpoints. */
3097 if (!gdbarch_has_global_breakpoints (target_gdbarch ())
3098 && ptid_equal (inferior_ptid
, null_ptid
))
3101 val
= insert_bp_location (bl
, tmp_error_stream
, &disabled_breaks
,
3102 &hw_breakpoint_error
, &hw_bp_details_reported
);
3109 target_terminal_ours_for_output ();
3110 error_stream (tmp_error_stream
);
3113 do_cleanups (cleanups
);
3116 /* Used when starting or continuing the program. */
3119 insert_breakpoint_locations (void)
3121 struct breakpoint
*bpt
;
3122 struct bp_location
*bl
, **blp_tmp
;
3125 int disabled_breaks
= 0;
3126 int hw_breakpoint_error
= 0;
3127 int hw_bp_error_explained_already
= 0;
3129 struct ui_file
*tmp_error_stream
= mem_fileopen ();
3130 struct cleanup
*cleanups
= make_cleanup_ui_file_delete (tmp_error_stream
);
3132 /* Explicitly mark the warning -- this will only be printed if
3133 there was an error. */
3134 fprintf_unfiltered (tmp_error_stream
, "Warning:\n");
3136 save_current_space_and_thread ();
3138 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3140 if (!should_be_inserted (bl
) || (bl
->inserted
&& !bl
->needs_update
))
3143 /* There is no point inserting thread-specific breakpoints if
3144 the thread no longer exists. ALL_BP_LOCATIONS bp_location
3145 has BL->OWNER always non-NULL. */
3146 if (bl
->owner
->thread
!= -1
3147 && !valid_global_thread_id (bl
->owner
->thread
))
3150 switch_to_program_space_and_thread (bl
->pspace
);
3152 /* For targets that support global breakpoints, there's no need
3153 to select an inferior to insert breakpoint to. In fact, even
3154 if we aren't attached to any process yet, we should still
3155 insert breakpoints. */
3156 if (!gdbarch_has_global_breakpoints (target_gdbarch ())
3157 && ptid_equal (inferior_ptid
, null_ptid
))
3160 val
= insert_bp_location (bl
, tmp_error_stream
, &disabled_breaks
,
3161 &hw_breakpoint_error
, &hw_bp_error_explained_already
);
3166 /* If we failed to insert all locations of a watchpoint, remove
3167 them, as half-inserted watchpoint is of limited use. */
3168 ALL_BREAKPOINTS (bpt
)
3170 int some_failed
= 0;
3171 struct bp_location
*loc
;
3173 if (!is_hardware_watchpoint (bpt
))
3176 if (!breakpoint_enabled (bpt
))
3179 if (bpt
->disposition
== disp_del_at_next_stop
)
3182 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
3183 if (!loc
->inserted
&& should_be_inserted (loc
))
3190 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
3192 remove_breakpoint (loc
, mark_uninserted
);
3194 hw_breakpoint_error
= 1;
3195 fprintf_unfiltered (tmp_error_stream
,
3196 "Could not insert hardware watchpoint %d.\n",
3204 /* If a hardware breakpoint or watchpoint was inserted, add a
3205 message about possibly exhausted resources. */
3206 if (hw_breakpoint_error
&& !hw_bp_error_explained_already
)
3208 fprintf_unfiltered (tmp_error_stream
,
3209 "Could not insert hardware breakpoints:\n\
3210 You may have requested too many hardware breakpoints/watchpoints.\n");
3212 target_terminal_ours_for_output ();
3213 error_stream (tmp_error_stream
);
3216 do_cleanups (cleanups
);
3219 /* Used when the program stops.
3220 Returns zero if successful, or non-zero if there was a problem
3221 removing a breakpoint location. */
3224 remove_breakpoints (void)
3226 struct bp_location
*bl
, **blp_tmp
;
3229 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3231 if (bl
->inserted
&& !is_tracepoint (bl
->owner
))
3232 val
|= remove_breakpoint (bl
, mark_uninserted
);
3237 /* When a thread exits, remove breakpoints that are related to
3241 remove_threaded_breakpoints (struct thread_info
*tp
, int silent
)
3243 struct breakpoint
*b
, *b_tmp
;
3245 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
3247 if (b
->thread
== tp
->global_num
&& user_breakpoint_p (b
))
3249 b
->disposition
= disp_del_at_next_stop
;
3251 printf_filtered (_("\
3252 Thread-specific breakpoint %d deleted - thread %s no longer in the thread list.\n"),
3253 b
->number
, print_thread_id (tp
));
3255 /* Hide it from the user. */
3261 /* Remove breakpoints of process PID. */
3264 remove_breakpoints_pid (int pid
)
3266 struct bp_location
*bl
, **blp_tmp
;
3268 struct inferior
*inf
= find_inferior_pid (pid
);
3270 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3272 if (bl
->pspace
!= inf
->pspace
)
3275 if (bl
->inserted
&& !bl
->target_info
.persist
)
3277 val
= remove_breakpoint (bl
, mark_uninserted
);
3286 reattach_breakpoints (int pid
)
3288 struct cleanup
*old_chain
;
3289 struct bp_location
*bl
, **blp_tmp
;
3291 struct ui_file
*tmp_error_stream
;
3292 int dummy1
= 0, dummy2
= 0, dummy3
= 0;
3293 struct inferior
*inf
;
3294 struct thread_info
*tp
;
3296 tp
= any_live_thread_of_process (pid
);
3300 inf
= find_inferior_pid (pid
);
3301 old_chain
= save_inferior_ptid ();
3303 inferior_ptid
= tp
->ptid
;
3305 tmp_error_stream
= mem_fileopen ();
3306 make_cleanup_ui_file_delete (tmp_error_stream
);
3308 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3310 if (bl
->pspace
!= inf
->pspace
)
3316 val
= insert_bp_location (bl
, tmp_error_stream
, &dummy1
, &dummy2
, &dummy3
);
3319 do_cleanups (old_chain
);
3324 do_cleanups (old_chain
);
3328 static int internal_breakpoint_number
= -1;
3330 /* Set the breakpoint number of B, depending on the value of INTERNAL.
3331 If INTERNAL is non-zero, the breakpoint number will be populated
3332 from internal_breakpoint_number and that variable decremented.
3333 Otherwise the breakpoint number will be populated from
3334 breakpoint_count and that value incremented. Internal breakpoints
3335 do not set the internal var bpnum. */
3337 set_breakpoint_number (int internal
, struct breakpoint
*b
)
3340 b
->number
= internal_breakpoint_number
--;
3343 set_breakpoint_count (breakpoint_count
+ 1);
3344 b
->number
= breakpoint_count
;
3348 static struct breakpoint
*
3349 create_internal_breakpoint (struct gdbarch
*gdbarch
,
3350 CORE_ADDR address
, enum bptype type
,
3351 const struct breakpoint_ops
*ops
)
3353 struct symtab_and_line sal
;
3354 struct breakpoint
*b
;
3356 init_sal (&sal
); /* Initialize to zeroes. */
3359 sal
.section
= find_pc_overlay (sal
.pc
);
3360 sal
.pspace
= current_program_space
;
3362 b
= set_raw_breakpoint (gdbarch
, sal
, type
, ops
);
3363 b
->number
= internal_breakpoint_number
--;
3364 b
->disposition
= disp_donttouch
;
3369 static const char *const longjmp_names
[] =
3371 "longjmp", "_longjmp", "siglongjmp", "_siglongjmp"
3373 #define NUM_LONGJMP_NAMES ARRAY_SIZE(longjmp_names)
3375 /* Per-objfile data private to breakpoint.c. */
3376 struct breakpoint_objfile_data
3378 /* Minimal symbol for "_ovly_debug_event" (if any). */
3379 struct bound_minimal_symbol overlay_msym
;
3381 /* Minimal symbol(s) for "longjmp", "siglongjmp", etc. (if any). */
3382 struct bound_minimal_symbol longjmp_msym
[NUM_LONGJMP_NAMES
];
3384 /* True if we have looked for longjmp probes. */
3385 int longjmp_searched
;
3387 /* SystemTap probe points for longjmp (if any). */
3388 VEC (probe_p
) *longjmp_probes
;
3390 /* Minimal symbol for "std::terminate()" (if any). */
3391 struct bound_minimal_symbol terminate_msym
;
3393 /* Minimal symbol for "_Unwind_DebugHook" (if any). */
3394 struct bound_minimal_symbol exception_msym
;
3396 /* True if we have looked for exception probes. */
3397 int exception_searched
;
3399 /* SystemTap probe points for unwinding (if any). */
3400 VEC (probe_p
) *exception_probes
;
3403 static const struct objfile_data
*breakpoint_objfile_key
;
3405 /* Minimal symbol not found sentinel. */
3406 static struct minimal_symbol msym_not_found
;
3408 /* Returns TRUE if MSYM point to the "not found" sentinel. */
3411 msym_not_found_p (const struct minimal_symbol
*msym
)
3413 return msym
== &msym_not_found
;
3416 /* Return per-objfile data needed by breakpoint.c.
3417 Allocate the data if necessary. */
3419 static struct breakpoint_objfile_data
*
3420 get_breakpoint_objfile_data (struct objfile
*objfile
)
3422 struct breakpoint_objfile_data
*bp_objfile_data
;
3424 bp_objfile_data
= ((struct breakpoint_objfile_data
*)
3425 objfile_data (objfile
, breakpoint_objfile_key
));
3426 if (bp_objfile_data
== NULL
)
3429 XOBNEW (&objfile
->objfile_obstack
, struct breakpoint_objfile_data
);
3431 memset (bp_objfile_data
, 0, sizeof (*bp_objfile_data
));
3432 set_objfile_data (objfile
, breakpoint_objfile_key
, bp_objfile_data
);
3434 return bp_objfile_data
;
3438 free_breakpoint_probes (struct objfile
*obj
, void *data
)
3440 struct breakpoint_objfile_data
*bp_objfile_data
3441 = (struct breakpoint_objfile_data
*) data
;
3443 VEC_free (probe_p
, bp_objfile_data
->longjmp_probes
);
3444 VEC_free (probe_p
, bp_objfile_data
->exception_probes
);
3448 create_overlay_event_breakpoint (void)
3450 struct objfile
*objfile
;
3451 const char *const func_name
= "_ovly_debug_event";
3453 ALL_OBJFILES (objfile
)
3455 struct breakpoint
*b
;
3456 struct breakpoint_objfile_data
*bp_objfile_data
;
3458 struct explicit_location explicit_loc
;
3460 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3462 if (msym_not_found_p (bp_objfile_data
->overlay_msym
.minsym
))
3465 if (bp_objfile_data
->overlay_msym
.minsym
== NULL
)
3467 struct bound_minimal_symbol m
;
3469 m
= lookup_minimal_symbol_text (func_name
, objfile
);
3470 if (m
.minsym
== NULL
)
3472 /* Avoid future lookups in this objfile. */
3473 bp_objfile_data
->overlay_msym
.minsym
= &msym_not_found
;
3476 bp_objfile_data
->overlay_msym
= m
;
3479 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->overlay_msym
);
3480 b
= create_internal_breakpoint (get_objfile_arch (objfile
), addr
,
3482 &internal_breakpoint_ops
);
3483 initialize_explicit_location (&explicit_loc
);
3484 explicit_loc
.function_name
= ASTRDUP (func_name
);
3485 b
->location
= new_explicit_location (&explicit_loc
);
3487 if (overlay_debugging
== ovly_auto
)
3489 b
->enable_state
= bp_enabled
;
3490 overlay_events_enabled
= 1;
3494 b
->enable_state
= bp_disabled
;
3495 overlay_events_enabled
= 0;
3501 create_longjmp_master_breakpoint (void)
3503 struct program_space
*pspace
;
3504 struct cleanup
*old_chain
;
3506 old_chain
= save_current_program_space ();
3508 ALL_PSPACES (pspace
)
3510 struct objfile
*objfile
;
3512 set_current_program_space (pspace
);
3514 ALL_OBJFILES (objfile
)
3517 struct gdbarch
*gdbarch
;
3518 struct breakpoint_objfile_data
*bp_objfile_data
;
3520 gdbarch
= get_objfile_arch (objfile
);
3522 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3524 if (!bp_objfile_data
->longjmp_searched
)
3528 ret
= find_probes_in_objfile (objfile
, "libc", "longjmp");
3531 /* We are only interested in checking one element. */
3532 struct probe
*p
= VEC_index (probe_p
, ret
, 0);
3534 if (!can_evaluate_probe_arguments (p
))
3536 /* We cannot use the probe interface here, because it does
3537 not know how to evaluate arguments. */
3538 VEC_free (probe_p
, ret
);
3542 bp_objfile_data
->longjmp_probes
= ret
;
3543 bp_objfile_data
->longjmp_searched
= 1;
3546 if (bp_objfile_data
->longjmp_probes
!= NULL
)
3549 struct probe
*probe
;
3550 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3553 VEC_iterate (probe_p
,
3554 bp_objfile_data
->longjmp_probes
,
3558 struct breakpoint
*b
;
3560 b
= create_internal_breakpoint (gdbarch
,
3561 get_probe_address (probe
,
3564 &internal_breakpoint_ops
);
3566 = new_probe_location ("-probe-stap libc:longjmp");
3567 b
->enable_state
= bp_disabled
;
3573 if (!gdbarch_get_longjmp_target_p (gdbarch
))
3576 for (i
= 0; i
< NUM_LONGJMP_NAMES
; i
++)
3578 struct breakpoint
*b
;
3579 const char *func_name
;
3581 struct explicit_location explicit_loc
;
3583 if (msym_not_found_p (bp_objfile_data
->longjmp_msym
[i
].minsym
))
3586 func_name
= longjmp_names
[i
];
3587 if (bp_objfile_data
->longjmp_msym
[i
].minsym
== NULL
)
3589 struct bound_minimal_symbol m
;
3591 m
= lookup_minimal_symbol_text (func_name
, objfile
);
3592 if (m
.minsym
== NULL
)
3594 /* Prevent future lookups in this objfile. */
3595 bp_objfile_data
->longjmp_msym
[i
].minsym
= &msym_not_found
;
3598 bp_objfile_data
->longjmp_msym
[i
] = m
;
3601 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->longjmp_msym
[i
]);
3602 b
= create_internal_breakpoint (gdbarch
, addr
, bp_longjmp_master
,
3603 &internal_breakpoint_ops
);
3604 initialize_explicit_location (&explicit_loc
);
3605 explicit_loc
.function_name
= ASTRDUP (func_name
);
3606 b
->location
= new_explicit_location (&explicit_loc
);
3607 b
->enable_state
= bp_disabled
;
3612 do_cleanups (old_chain
);
3615 /* Create a master std::terminate breakpoint. */
3617 create_std_terminate_master_breakpoint (void)
3619 struct program_space
*pspace
;
3620 struct cleanup
*old_chain
;
3621 const char *const func_name
= "std::terminate()";
3623 old_chain
= save_current_program_space ();
3625 ALL_PSPACES (pspace
)
3627 struct objfile
*objfile
;
3630 set_current_program_space (pspace
);
3632 ALL_OBJFILES (objfile
)
3634 struct breakpoint
*b
;
3635 struct breakpoint_objfile_data
*bp_objfile_data
;
3636 struct explicit_location explicit_loc
;
3638 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3640 if (msym_not_found_p (bp_objfile_data
->terminate_msym
.minsym
))
3643 if (bp_objfile_data
->terminate_msym
.minsym
== NULL
)
3645 struct bound_minimal_symbol m
;
3647 m
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
3648 if (m
.minsym
== NULL
|| (MSYMBOL_TYPE (m
.minsym
) != mst_text
3649 && MSYMBOL_TYPE (m
.minsym
) != mst_file_text
))
3651 /* Prevent future lookups in this objfile. */
3652 bp_objfile_data
->terminate_msym
.minsym
= &msym_not_found
;
3655 bp_objfile_data
->terminate_msym
= m
;
3658 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->terminate_msym
);
3659 b
= create_internal_breakpoint (get_objfile_arch (objfile
), addr
,
3660 bp_std_terminate_master
,
3661 &internal_breakpoint_ops
);
3662 initialize_explicit_location (&explicit_loc
);
3663 explicit_loc
.function_name
= ASTRDUP (func_name
);
3664 b
->location
= new_explicit_location (&explicit_loc
);
3665 b
->enable_state
= bp_disabled
;
3669 do_cleanups (old_chain
);
3672 /* Install a master breakpoint on the unwinder's debug hook. */
3675 create_exception_master_breakpoint (void)
3677 struct objfile
*objfile
;
3678 const char *const func_name
= "_Unwind_DebugHook";
3680 ALL_OBJFILES (objfile
)
3682 struct breakpoint
*b
;
3683 struct gdbarch
*gdbarch
;
3684 struct breakpoint_objfile_data
*bp_objfile_data
;
3686 struct explicit_location explicit_loc
;
3688 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3690 /* We prefer the SystemTap probe point if it exists. */
3691 if (!bp_objfile_data
->exception_searched
)
3695 ret
= find_probes_in_objfile (objfile
, "libgcc", "unwind");
3699 /* We are only interested in checking one element. */
3700 struct probe
*p
= VEC_index (probe_p
, ret
, 0);
3702 if (!can_evaluate_probe_arguments (p
))
3704 /* We cannot use the probe interface here, because it does
3705 not know how to evaluate arguments. */
3706 VEC_free (probe_p
, ret
);
3710 bp_objfile_data
->exception_probes
= ret
;
3711 bp_objfile_data
->exception_searched
= 1;
3714 if (bp_objfile_data
->exception_probes
!= NULL
)
3716 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3718 struct probe
*probe
;
3721 VEC_iterate (probe_p
,
3722 bp_objfile_data
->exception_probes
,
3726 struct breakpoint
*b
;
3728 b
= create_internal_breakpoint (gdbarch
,
3729 get_probe_address (probe
,
3731 bp_exception_master
,
3732 &internal_breakpoint_ops
);
3734 = new_probe_location ("-probe-stap libgcc:unwind");
3735 b
->enable_state
= bp_disabled
;
3741 /* Otherwise, try the hook function. */
3743 if (msym_not_found_p (bp_objfile_data
->exception_msym
.minsym
))
3746 gdbarch
= get_objfile_arch (objfile
);
3748 if (bp_objfile_data
->exception_msym
.minsym
== NULL
)
3750 struct bound_minimal_symbol debug_hook
;
3752 debug_hook
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
3753 if (debug_hook
.minsym
== NULL
)
3755 bp_objfile_data
->exception_msym
.minsym
= &msym_not_found
;
3759 bp_objfile_data
->exception_msym
= debug_hook
;
3762 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->exception_msym
);
3763 addr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, addr
,
3765 b
= create_internal_breakpoint (gdbarch
, addr
, bp_exception_master
,
3766 &internal_breakpoint_ops
);
3767 initialize_explicit_location (&explicit_loc
);
3768 explicit_loc
.function_name
= ASTRDUP (func_name
);
3769 b
->location
= new_explicit_location (&explicit_loc
);
3770 b
->enable_state
= bp_disabled
;
3774 /* Does B have a location spec? */
3777 breakpoint_event_location_empty_p (const struct breakpoint
*b
)
3779 return b
->location
!= NULL
&& event_location_empty_p (b
->location
);
3783 update_breakpoints_after_exec (void)
3785 struct breakpoint
*b
, *b_tmp
;
3786 struct bp_location
*bploc
, **bplocp_tmp
;
3788 /* We're about to delete breakpoints from GDB's lists. If the
3789 INSERTED flag is true, GDB will try to lift the breakpoints by
3790 writing the breakpoints' "shadow contents" back into memory. The
3791 "shadow contents" are NOT valid after an exec, so GDB should not
3792 do that. Instead, the target is responsible from marking
3793 breakpoints out as soon as it detects an exec. We don't do that
3794 here instead, because there may be other attempts to delete
3795 breakpoints after detecting an exec and before reaching here. */
3796 ALL_BP_LOCATIONS (bploc
, bplocp_tmp
)
3797 if (bploc
->pspace
== current_program_space
)
3798 gdb_assert (!bploc
->inserted
);
3800 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
3802 if (b
->pspace
!= current_program_space
)
3805 /* Solib breakpoints must be explicitly reset after an exec(). */
3806 if (b
->type
== bp_shlib_event
)
3808 delete_breakpoint (b
);
3812 /* JIT breakpoints must be explicitly reset after an exec(). */
3813 if (b
->type
== bp_jit_event
)
3815 delete_breakpoint (b
);
3819 /* Thread event breakpoints must be set anew after an exec(),
3820 as must overlay event and longjmp master breakpoints. */
3821 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
3822 || b
->type
== bp_longjmp_master
|| b
->type
== bp_std_terminate_master
3823 || b
->type
== bp_exception_master
)
3825 delete_breakpoint (b
);
3829 /* Step-resume breakpoints are meaningless after an exec(). */
3830 if (b
->type
== bp_step_resume
|| b
->type
== bp_hp_step_resume
)
3832 delete_breakpoint (b
);
3836 /* Just like single-step breakpoints. */
3837 if (b
->type
== bp_single_step
)
3839 delete_breakpoint (b
);
3843 /* Longjmp and longjmp-resume breakpoints are also meaningless
3845 if (b
->type
== bp_longjmp
|| b
->type
== bp_longjmp_resume
3846 || b
->type
== bp_longjmp_call_dummy
3847 || b
->type
== bp_exception
|| b
->type
== bp_exception_resume
)
3849 delete_breakpoint (b
);
3853 if (b
->type
== bp_catchpoint
)
3855 /* For now, none of the bp_catchpoint breakpoints need to
3856 do anything at this point. In the future, if some of
3857 the catchpoints need to something, we will need to add
3858 a new method, and call this method from here. */
3862 /* bp_finish is a special case. The only way we ought to be able
3863 to see one of these when an exec() has happened, is if the user
3864 caught a vfork, and then said "finish". Ordinarily a finish just
3865 carries them to the call-site of the current callee, by setting
3866 a temporary bp there and resuming. But in this case, the finish
3867 will carry them entirely through the vfork & exec.
3869 We don't want to allow a bp_finish to remain inserted now. But
3870 we can't safely delete it, 'cause finish_command has a handle to
3871 the bp on a bpstat, and will later want to delete it. There's a
3872 chance (and I've seen it happen) that if we delete the bp_finish
3873 here, that its storage will get reused by the time finish_command
3874 gets 'round to deleting the "use to be a bp_finish" breakpoint.
3875 We really must allow finish_command to delete a bp_finish.
3877 In the absence of a general solution for the "how do we know
3878 it's safe to delete something others may have handles to?"
3879 problem, what we'll do here is just uninsert the bp_finish, and
3880 let finish_command delete it.
3882 (We know the bp_finish is "doomed" in the sense that it's
3883 momentary, and will be deleted as soon as finish_command sees
3884 the inferior stopped. So it doesn't matter that the bp's
3885 address is probably bogus in the new a.out, unlike e.g., the
3886 solib breakpoints.) */
3888 if (b
->type
== bp_finish
)
3893 /* Without a symbolic address, we have little hope of the
3894 pre-exec() address meaning the same thing in the post-exec()
3896 if (breakpoint_event_location_empty_p (b
))
3898 delete_breakpoint (b
);
3905 detach_breakpoints (ptid_t ptid
)
3907 struct bp_location
*bl
, **blp_tmp
;
3909 struct cleanup
*old_chain
= save_inferior_ptid ();
3910 struct inferior
*inf
= current_inferior ();
3912 if (ptid_get_pid (ptid
) == ptid_get_pid (inferior_ptid
))
3913 error (_("Cannot detach breakpoints of inferior_ptid"));
3915 /* Set inferior_ptid; remove_breakpoint_1 uses this global. */
3916 inferior_ptid
= ptid
;
3917 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3919 if (bl
->pspace
!= inf
->pspace
)
3922 /* This function must physically remove breakpoints locations
3923 from the specified ptid, without modifying the breakpoint
3924 package's state. Locations of type bp_loc_other are only
3925 maintained at GDB side. So, there is no need to remove
3926 these bp_loc_other locations. Moreover, removing these
3927 would modify the breakpoint package's state. */
3928 if (bl
->loc_type
== bp_loc_other
)
3932 val
|= remove_breakpoint_1 (bl
, mark_inserted
);
3935 do_cleanups (old_chain
);
3939 /* Remove the breakpoint location BL from the current address space.
3940 Note that this is used to detach breakpoints from a child fork.
3941 When we get here, the child isn't in the inferior list, and neither
3942 do we have objects to represent its address space --- we should
3943 *not* look at bl->pspace->aspace here. */
3946 remove_breakpoint_1 (struct bp_location
*bl
, insertion_state_t is
)
3950 /* BL is never in moribund_locations by our callers. */
3951 gdb_assert (bl
->owner
!= NULL
);
3953 /* The type of none suggests that owner is actually deleted.
3954 This should not ever happen. */
3955 gdb_assert (bl
->owner
->type
!= bp_none
);
3957 if (bl
->loc_type
== bp_loc_software_breakpoint
3958 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
3960 /* "Normal" instruction breakpoint: either the standard
3961 trap-instruction bp (bp_breakpoint), or a
3962 bp_hardware_breakpoint. */
3964 /* First check to see if we have to handle an overlay. */
3965 if (overlay_debugging
== ovly_off
3966 || bl
->section
== NULL
3967 || !(section_is_overlay (bl
->section
)))
3969 /* No overlay handling: just remove the breakpoint. */
3971 /* If we're trying to uninsert a memory breakpoint that we
3972 know is set in a dynamic object that is marked
3973 shlib_disabled, then either the dynamic object was
3974 removed with "remove-symbol-file" or with
3975 "nosharedlibrary". In the former case, we don't know
3976 whether another dynamic object might have loaded over the
3977 breakpoint's address -- the user might well let us know
3978 about it next with add-symbol-file (the whole point of
3979 add-symbol-file is letting the user manually maintain a
3980 list of dynamically loaded objects). If we have the
3981 breakpoint's shadow memory, that is, this is a software
3982 breakpoint managed by GDB, check whether the breakpoint
3983 is still inserted in memory, to avoid overwriting wrong
3984 code with stale saved shadow contents. Note that HW
3985 breakpoints don't have shadow memory, as they're
3986 implemented using a mechanism that is not dependent on
3987 being able to modify the target's memory, and as such
3988 they should always be removed. */
3989 if (bl
->shlib_disabled
3990 && bl
->target_info
.shadow_len
!= 0
3991 && !memory_validate_breakpoint (bl
->gdbarch
, &bl
->target_info
))
3994 val
= bl
->owner
->ops
->remove_location (bl
);
3998 /* This breakpoint is in an overlay section.
3999 Did we set a breakpoint at the LMA? */
4000 if (!overlay_events_enabled
)
4002 /* Yes -- overlay event support is not active, so we
4003 should have set a breakpoint at the LMA. Remove it.
4005 /* Ignore any failures: if the LMA is in ROM, we will
4006 have already warned when we failed to insert it. */
4007 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
4008 target_remove_hw_breakpoint (bl
->gdbarch
,
4009 &bl
->overlay_target_info
);
4011 target_remove_breakpoint (bl
->gdbarch
,
4012 &bl
->overlay_target_info
);
4014 /* Did we set a breakpoint at the VMA?
4015 If so, we will have marked the breakpoint 'inserted'. */
4018 /* Yes -- remove it. Previously we did not bother to
4019 remove the breakpoint if the section had been
4020 unmapped, but let's not rely on that being safe. We
4021 don't know what the overlay manager might do. */
4023 /* However, we should remove *software* breakpoints only
4024 if the section is still mapped, or else we overwrite
4025 wrong code with the saved shadow contents. */
4026 if (bl
->loc_type
== bp_loc_hardware_breakpoint
4027 || section_is_mapped (bl
->section
))
4028 val
= bl
->owner
->ops
->remove_location (bl
);
4034 /* No -- not inserted, so no need to remove. No error. */
4039 /* In some cases, we might not be able to remove a breakpoint in
4040 a shared library that has already been removed, but we have
4041 not yet processed the shlib unload event. Similarly for an
4042 unloaded add-symbol-file object - the user might not yet have
4043 had the chance to remove-symbol-file it. shlib_disabled will
4044 be set if the library/object has already been removed, but
4045 the breakpoint hasn't been uninserted yet, e.g., after
4046 "nosharedlibrary" or "remove-symbol-file" with breakpoints
4047 always-inserted mode. */
4049 && (bl
->loc_type
== bp_loc_software_breakpoint
4050 && (bl
->shlib_disabled
4051 || solib_name_from_address (bl
->pspace
, bl
->address
)
4052 || shared_objfile_contains_address_p (bl
->pspace
,
4058 bl
->inserted
= (is
== mark_inserted
);
4060 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
)
4062 gdb_assert (bl
->owner
->ops
!= NULL
4063 && bl
->owner
->ops
->remove_location
!= NULL
);
4065 bl
->inserted
= (is
== mark_inserted
);
4066 bl
->owner
->ops
->remove_location (bl
);
4068 /* Failure to remove any of the hardware watchpoints comes here. */
4069 if ((is
== mark_uninserted
) && (bl
->inserted
))
4070 warning (_("Could not remove hardware watchpoint %d."),
4073 else if (bl
->owner
->type
== bp_catchpoint
4074 && breakpoint_enabled (bl
->owner
)
4077 gdb_assert (bl
->owner
->ops
!= NULL
4078 && bl
->owner
->ops
->remove_location
!= NULL
);
4080 val
= bl
->owner
->ops
->remove_location (bl
);
4084 bl
->inserted
= (is
== mark_inserted
);
4091 remove_breakpoint (struct bp_location
*bl
, insertion_state_t is
)
4094 struct cleanup
*old_chain
;
4096 /* BL is never in moribund_locations by our callers. */
4097 gdb_assert (bl
->owner
!= NULL
);
4099 /* The type of none suggests that owner is actually deleted.
4100 This should not ever happen. */
4101 gdb_assert (bl
->owner
->type
!= bp_none
);
4103 old_chain
= save_current_space_and_thread ();
4105 switch_to_program_space_and_thread (bl
->pspace
);
4107 ret
= remove_breakpoint_1 (bl
, is
);
4109 do_cleanups (old_chain
);
4113 /* Clear the "inserted" flag in all breakpoints. */
4116 mark_breakpoints_out (void)
4118 struct bp_location
*bl
, **blp_tmp
;
4120 ALL_BP_LOCATIONS (bl
, blp_tmp
)
4121 if (bl
->pspace
== current_program_space
)
4125 /* Clear the "inserted" flag in all breakpoints and delete any
4126 breakpoints which should go away between runs of the program.
4128 Plus other such housekeeping that has to be done for breakpoints
4131 Note: this function gets called at the end of a run (by
4132 generic_mourn_inferior) and when a run begins (by
4133 init_wait_for_inferior). */
4138 breakpoint_init_inferior (enum inf_context context
)
4140 struct breakpoint
*b
, *b_tmp
;
4141 struct bp_location
*bl
;
4143 struct program_space
*pspace
= current_program_space
;
4145 /* If breakpoint locations are shared across processes, then there's
4147 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
4150 mark_breakpoints_out ();
4152 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
4154 if (b
->loc
&& b
->loc
->pspace
!= pspace
)
4160 case bp_longjmp_call_dummy
:
4162 /* If the call dummy breakpoint is at the entry point it will
4163 cause problems when the inferior is rerun, so we better get
4166 case bp_watchpoint_scope
:
4168 /* Also get rid of scope breakpoints. */
4170 case bp_shlib_event
:
4172 /* Also remove solib event breakpoints. Their addresses may
4173 have changed since the last time we ran the program.
4174 Actually we may now be debugging against different target;
4175 and so the solib backend that installed this breakpoint may
4176 not be used in by the target. E.g.,
4178 (gdb) file prog-linux
4179 (gdb) run # native linux target
4182 (gdb) file prog-win.exe
4183 (gdb) tar rem :9999 # remote Windows gdbserver.
4186 case bp_step_resume
:
4188 /* Also remove step-resume breakpoints. */
4190 case bp_single_step
:
4192 /* Also remove single-step breakpoints. */
4194 delete_breakpoint (b
);
4198 case bp_hardware_watchpoint
:
4199 case bp_read_watchpoint
:
4200 case bp_access_watchpoint
:
4202 struct watchpoint
*w
= (struct watchpoint
*) b
;
4204 /* Likewise for watchpoints on local expressions. */
4205 if (w
->exp_valid_block
!= NULL
)
4206 delete_breakpoint (b
);
4209 /* Get rid of existing locations, which are no longer
4210 valid. New ones will be created in
4211 update_watchpoint, when the inferior is restarted.
4212 The next update_global_location_list call will
4213 garbage collect them. */
4216 if (context
== inf_starting
)
4218 /* Reset val field to force reread of starting value in
4219 insert_breakpoints. */
4221 value_free (w
->val
);
4233 /* Get rid of the moribund locations. */
4234 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, bl
); ++ix
)
4235 decref_bp_location (&bl
);
4236 VEC_free (bp_location_p
, moribund_locations
);
4239 /* These functions concern about actual breakpoints inserted in the
4240 target --- to e.g. check if we need to do decr_pc adjustment or if
4241 we need to hop over the bkpt --- so we check for address space
4242 match, not program space. */
4244 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
4245 exists at PC. It returns ordinary_breakpoint_here if it's an
4246 ordinary breakpoint, or permanent_breakpoint_here if it's a
4247 permanent breakpoint.
4248 - When continuing from a location with an ordinary breakpoint, we
4249 actually single step once before calling insert_breakpoints.
4250 - When continuing from a location with a permanent breakpoint, we
4251 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
4252 the target, to advance the PC past the breakpoint. */
4254 enum breakpoint_here
4255 breakpoint_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
4257 struct bp_location
*bl
, **blp_tmp
;
4258 int any_breakpoint_here
= 0;
4260 ALL_BP_LOCATIONS (bl
, blp_tmp
)
4262 if (bl
->loc_type
!= bp_loc_software_breakpoint
4263 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4266 /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
4267 if ((breakpoint_enabled (bl
->owner
)
4269 && breakpoint_location_address_match (bl
, aspace
, pc
))
4271 if (overlay_debugging
4272 && section_is_overlay (bl
->section
)
4273 && !section_is_mapped (bl
->section
))
4274 continue; /* unmapped overlay -- can't be a match */
4275 else if (bl
->permanent
)
4276 return permanent_breakpoint_here
;
4278 any_breakpoint_here
= 1;
4282 return any_breakpoint_here
? ordinary_breakpoint_here
: no_breakpoint_here
;
4285 /* See breakpoint.h. */
4288 breakpoint_in_range_p (struct address_space
*aspace
,
4289 CORE_ADDR addr
, ULONGEST len
)
4291 struct bp_location
*bl
, **blp_tmp
;
4293 ALL_BP_LOCATIONS (bl
, blp_tmp
)
4295 if (bl
->loc_type
!= bp_loc_software_breakpoint
4296 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4299 if ((breakpoint_enabled (bl
->owner
)
4301 && breakpoint_location_address_range_overlap (bl
, aspace
,
4304 if (overlay_debugging
4305 && section_is_overlay (bl
->section
)
4306 && !section_is_mapped (bl
->section
))
4308 /* Unmapped overlay -- can't be a match. */
4319 /* Return true if there's a moribund breakpoint at PC. */
4322 moribund_breakpoint_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
4324 struct bp_location
*loc
;
4327 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
4328 if (breakpoint_location_address_match (loc
, aspace
, pc
))
4334 /* Returns non-zero iff BL is inserted at PC, in address space
4338 bp_location_inserted_here_p (struct bp_location
*bl
,
4339 struct address_space
*aspace
, CORE_ADDR pc
)
4342 && breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
4345 if (overlay_debugging
4346 && section_is_overlay (bl
->section
)
4347 && !section_is_mapped (bl
->section
))
4348 return 0; /* unmapped overlay -- can't be a match */
4355 /* Returns non-zero iff there's a breakpoint inserted at PC. */
4358 breakpoint_inserted_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
4360 struct bp_location
**blp
, **blp_tmp
= NULL
;
4362 ALL_BP_LOCATIONS_AT_ADDR (blp
, blp_tmp
, pc
)
4364 struct bp_location
*bl
= *blp
;
4366 if (bl
->loc_type
!= bp_loc_software_breakpoint
4367 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4370 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4376 /* This function returns non-zero iff there is a software breakpoint
4380 software_breakpoint_inserted_here_p (struct address_space
*aspace
,
4383 struct bp_location
**blp
, **blp_tmp
= NULL
;
4385 ALL_BP_LOCATIONS_AT_ADDR (blp
, blp_tmp
, pc
)
4387 struct bp_location
*bl
= *blp
;
4389 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
4392 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4399 /* See breakpoint.h. */
4402 hardware_breakpoint_inserted_here_p (struct address_space
*aspace
,
4405 struct bp_location
**blp
, **blp_tmp
= NULL
;
4407 ALL_BP_LOCATIONS_AT_ADDR (blp
, blp_tmp
, pc
)
4409 struct bp_location
*bl
= *blp
;
4411 if (bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4414 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4422 hardware_watchpoint_inserted_in_range (struct address_space
*aspace
,
4423 CORE_ADDR addr
, ULONGEST len
)
4425 struct breakpoint
*bpt
;
4427 ALL_BREAKPOINTS (bpt
)
4429 struct bp_location
*loc
;
4431 if (bpt
->type
!= bp_hardware_watchpoint
4432 && bpt
->type
!= bp_access_watchpoint
)
4435 if (!breakpoint_enabled (bpt
))
4438 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
4439 if (loc
->pspace
->aspace
== aspace
&& loc
->inserted
)
4443 /* Check for intersection. */
4444 l
= max (loc
->address
, addr
);
4445 h
= min (loc
->address
+ loc
->length
, addr
+ len
);
4454 /* bpstat stuff. External routines' interfaces are documented
4458 is_catchpoint (struct breakpoint
*ep
)
4460 return (ep
->type
== bp_catchpoint
);
4463 /* Frees any storage that is part of a bpstat. Does not walk the
4467 bpstat_free (bpstat bs
)
4469 if (bs
->old_val
!= NULL
)
4470 value_free (bs
->old_val
);
4471 decref_counted_command_line (&bs
->commands
);
4472 decref_bp_location (&bs
->bp_location_at
);
4476 /* Clear a bpstat so that it says we are not at any breakpoint.
4477 Also free any storage that is part of a bpstat. */
4480 bpstat_clear (bpstat
*bsp
)
4497 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
4498 is part of the bpstat is copied as well. */
4501 bpstat_copy (bpstat bs
)
4505 bpstat retval
= NULL
;
4510 for (; bs
!= NULL
; bs
= bs
->next
)
4512 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
4513 memcpy (tmp
, bs
, sizeof (*tmp
));
4514 incref_counted_command_line (tmp
->commands
);
4515 incref_bp_location (tmp
->bp_location_at
);
4516 if (bs
->old_val
!= NULL
)
4518 tmp
->old_val
= value_copy (bs
->old_val
);
4519 release_value (tmp
->old_val
);
4523 /* This is the first thing in the chain. */
4533 /* Find the bpstat associated with this breakpoint. */
4536 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
4541 for (; bsp
!= NULL
; bsp
= bsp
->next
)
4543 if (bsp
->breakpoint_at
== breakpoint
)
4549 /* See breakpoint.h. */
4552 bpstat_explains_signal (bpstat bsp
, enum gdb_signal sig
)
4554 for (; bsp
!= NULL
; bsp
= bsp
->next
)
4556 if (bsp
->breakpoint_at
== NULL
)
4558 /* A moribund location can never explain a signal other than
4560 if (sig
== GDB_SIGNAL_TRAP
)
4565 if (bsp
->breakpoint_at
->ops
->explains_signal (bsp
->breakpoint_at
,
4574 /* Put in *NUM the breakpoint number of the first breakpoint we are
4575 stopped at. *BSP upon return is a bpstat which points to the
4576 remaining breakpoints stopped at (but which is not guaranteed to be
4577 good for anything but further calls to bpstat_num).
4579 Return 0 if passed a bpstat which does not indicate any breakpoints.
4580 Return -1 if stopped at a breakpoint that has been deleted since
4582 Return 1 otherwise. */
4585 bpstat_num (bpstat
*bsp
, int *num
)
4587 struct breakpoint
*b
;
4590 return 0; /* No more breakpoint values */
4592 /* We assume we'll never have several bpstats that correspond to a
4593 single breakpoint -- otherwise, this function might return the
4594 same number more than once and this will look ugly. */
4595 b
= (*bsp
)->breakpoint_at
;
4596 *bsp
= (*bsp
)->next
;
4598 return -1; /* breakpoint that's been deleted since */
4600 *num
= b
->number
; /* We have its number */
4604 /* See breakpoint.h. */
4607 bpstat_clear_actions (void)
4609 struct thread_info
*tp
;
4612 if (ptid_equal (inferior_ptid
, null_ptid
))
4615 tp
= find_thread_ptid (inferior_ptid
);
4619 for (bs
= tp
->control
.stop_bpstat
; bs
!= NULL
; bs
= bs
->next
)
4621 decref_counted_command_line (&bs
->commands
);
4623 if (bs
->old_val
!= NULL
)
4625 value_free (bs
->old_val
);
4631 /* Called when a command is about to proceed the inferior. */
4634 breakpoint_about_to_proceed (void)
4636 if (!ptid_equal (inferior_ptid
, null_ptid
))
4638 struct thread_info
*tp
= inferior_thread ();
4640 /* Allow inferior function calls in breakpoint commands to not
4641 interrupt the command list. When the call finishes
4642 successfully, the inferior will be standing at the same
4643 breakpoint as if nothing happened. */
4644 if (tp
->control
.in_infcall
)
4648 breakpoint_proceeded
= 1;
4651 /* Stub for cleaning up our state if we error-out of a breakpoint
4654 cleanup_executing_breakpoints (void *ignore
)
4656 executing_breakpoint_commands
= 0;
4659 /* Return non-zero iff CMD as the first line of a command sequence is `silent'
4660 or its equivalent. */
4663 command_line_is_silent (struct command_line
*cmd
)
4665 return cmd
&& (strcmp ("silent", cmd
->line
) == 0);
4668 /* Execute all the commands associated with all the breakpoints at
4669 this location. Any of these commands could cause the process to
4670 proceed beyond this point, etc. We look out for such changes by
4671 checking the global "breakpoint_proceeded" after each command.
4673 Returns true if a breakpoint command resumed the inferior. In that
4674 case, it is the caller's responsibility to recall it again with the
4675 bpstat of the current thread. */
4678 bpstat_do_actions_1 (bpstat
*bsp
)
4681 struct cleanup
*old_chain
;
4684 /* Avoid endless recursion if a `source' command is contained
4686 if (executing_breakpoint_commands
)
4689 executing_breakpoint_commands
= 1;
4690 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
4692 prevent_dont_repeat ();
4694 /* This pointer will iterate over the list of bpstat's. */
4697 breakpoint_proceeded
= 0;
4698 for (; bs
!= NULL
; bs
= bs
->next
)
4700 struct counted_command_line
*ccmd
;
4701 struct command_line
*cmd
;
4702 struct cleanup
*this_cmd_tree_chain
;
4704 /* Take ownership of the BSP's command tree, if it has one.
4706 The command tree could legitimately contain commands like
4707 'step' and 'next', which call clear_proceed_status, which
4708 frees stop_bpstat's command tree. To make sure this doesn't
4709 free the tree we're executing out from under us, we need to
4710 take ownership of the tree ourselves. Since a given bpstat's
4711 commands are only executed once, we don't need to copy it; we
4712 can clear the pointer in the bpstat, and make sure we free
4713 the tree when we're done. */
4714 ccmd
= bs
->commands
;
4715 bs
->commands
= NULL
;
4716 this_cmd_tree_chain
= make_cleanup_decref_counted_command_line (&ccmd
);
4717 cmd
= ccmd
? ccmd
->commands
: NULL
;
4718 if (command_line_is_silent (cmd
))
4720 /* The action has been already done by bpstat_stop_status. */
4726 execute_control_command (cmd
);
4728 if (breakpoint_proceeded
)
4734 /* We can free this command tree now. */
4735 do_cleanups (this_cmd_tree_chain
);
4737 if (breakpoint_proceeded
)
4739 if (current_ui
->async
)
4740 /* If we are in async mode, then the target might be still
4741 running, not stopped at any breakpoint, so nothing for
4742 us to do here -- just return to the event loop. */
4745 /* In sync mode, when execute_control_command returns
4746 we're already standing on the next breakpoint.
4747 Breakpoint commands for that stop were not run, since
4748 execute_command does not run breakpoint commands --
4749 only command_line_handler does, but that one is not
4750 involved in execution of breakpoint commands. So, we
4751 can now execute breakpoint commands. It should be
4752 noted that making execute_command do bpstat actions is
4753 not an option -- in this case we'll have recursive
4754 invocation of bpstat for each breakpoint with a
4755 command, and can easily blow up GDB stack. Instead, we
4756 return true, which will trigger the caller to recall us
4757 with the new stop_bpstat. */
4762 do_cleanups (old_chain
);
4767 bpstat_do_actions (void)
4769 struct cleanup
*cleanup_if_error
= make_bpstat_clear_actions_cleanup ();
4771 /* Do any commands attached to breakpoint we are stopped at. */
4772 while (!ptid_equal (inferior_ptid
, null_ptid
)
4773 && target_has_execution
4774 && !is_exited (inferior_ptid
)
4775 && !is_executing (inferior_ptid
))
4776 /* Since in sync mode, bpstat_do_actions may resume the inferior,
4777 and only return when it is stopped at the next breakpoint, we
4778 keep doing breakpoint actions until it returns false to
4779 indicate the inferior was not resumed. */
4780 if (!bpstat_do_actions_1 (&inferior_thread ()->control
.stop_bpstat
))
4783 discard_cleanups (cleanup_if_error
);
4786 /* Print out the (old or new) value associated with a watchpoint. */
4789 watchpoint_value_print (struct value
*val
, struct ui_file
*stream
)
4792 fprintf_unfiltered (stream
, _("<unreadable>"));
4795 struct value_print_options opts
;
4796 get_user_print_options (&opts
);
4797 value_print (val
, stream
, &opts
);
4801 /* Print the "Thread ID hit" part of "Thread ID hit Breakpoint N" if
4802 debugging multiple threads. */
4805 maybe_print_thread_hit_breakpoint (struct ui_out
*uiout
)
4807 if (ui_out_is_mi_like_p (uiout
))
4810 ui_out_text (uiout
, "\n");
4812 if (show_thread_that_caused_stop ())
4815 struct thread_info
*thr
= inferior_thread ();
4817 ui_out_text (uiout
, "Thread ");
4818 ui_out_field_fmt (uiout
, "thread-id", "%s", print_thread_id (thr
));
4820 name
= thr
->name
!= NULL
? thr
->name
: target_thread_name (thr
);
4823 ui_out_text (uiout
, " \"");
4824 ui_out_field_fmt (uiout
, "name", "%s", name
);
4825 ui_out_text (uiout
, "\"");
4828 ui_out_text (uiout
, " hit ");
4832 /* Generic routine for printing messages indicating why we
4833 stopped. The behavior of this function depends on the value
4834 'print_it' in the bpstat structure. Under some circumstances we
4835 may decide not to print anything here and delegate the task to
4838 static enum print_stop_action
4839 print_bp_stop_message (bpstat bs
)
4841 switch (bs
->print_it
)
4844 /* Nothing should be printed for this bpstat entry. */
4845 return PRINT_UNKNOWN
;
4849 /* We still want to print the frame, but we already printed the
4850 relevant messages. */
4851 return PRINT_SRC_AND_LOC
;
4854 case print_it_normal
:
4856 struct breakpoint
*b
= bs
->breakpoint_at
;
4858 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
4859 which has since been deleted. */
4861 return PRINT_UNKNOWN
;
4863 /* Normal case. Call the breakpoint's print_it method. */
4864 return b
->ops
->print_it (bs
);
4869 internal_error (__FILE__
, __LINE__
,
4870 _("print_bp_stop_message: unrecognized enum value"));
4875 /* A helper function that prints a shared library stopped event. */
4878 print_solib_event (int is_catchpoint
)
4881 = !VEC_empty (char_ptr
, current_program_space
->deleted_solibs
);
4883 = !VEC_empty (so_list_ptr
, current_program_space
->added_solibs
);
4887 if (any_added
|| any_deleted
)
4888 ui_out_text (current_uiout
,
4889 _("Stopped due to shared library event:\n"));
4891 ui_out_text (current_uiout
,
4892 _("Stopped due to shared library event (no "
4893 "libraries added or removed)\n"));
4896 if (ui_out_is_mi_like_p (current_uiout
))
4897 ui_out_field_string (current_uiout
, "reason",
4898 async_reason_lookup (EXEC_ASYNC_SOLIB_EVENT
));
4902 struct cleanup
*cleanup
;
4906 ui_out_text (current_uiout
, _(" Inferior unloaded "));
4907 cleanup
= make_cleanup_ui_out_list_begin_end (current_uiout
,
4910 VEC_iterate (char_ptr
, current_program_space
->deleted_solibs
,
4915 ui_out_text (current_uiout
, " ");
4916 ui_out_field_string (current_uiout
, "library", name
);
4917 ui_out_text (current_uiout
, "\n");
4920 do_cleanups (cleanup
);
4925 struct so_list
*iter
;
4927 struct cleanup
*cleanup
;
4929 ui_out_text (current_uiout
, _(" Inferior loaded "));
4930 cleanup
= make_cleanup_ui_out_list_begin_end (current_uiout
,
4933 VEC_iterate (so_list_ptr
, current_program_space
->added_solibs
,
4938 ui_out_text (current_uiout
, " ");
4939 ui_out_field_string (current_uiout
, "library", iter
->so_name
);
4940 ui_out_text (current_uiout
, "\n");
4943 do_cleanups (cleanup
);
4947 /* Print a message indicating what happened. This is called from
4948 normal_stop(). The input to this routine is the head of the bpstat
4949 list - a list of the eventpoints that caused this stop. KIND is
4950 the target_waitkind for the stopping event. This
4951 routine calls the generic print routine for printing a message
4952 about reasons for stopping. This will print (for example) the
4953 "Breakpoint n," part of the output. The return value of this
4956 PRINT_UNKNOWN: Means we printed nothing.
4957 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
4958 code to print the location. An example is
4959 "Breakpoint 1, " which should be followed by
4961 PRINT_SRC_ONLY: Means we printed something, but there is no need
4962 to also print the location part of the message.
4963 An example is the catch/throw messages, which
4964 don't require a location appended to the end.
4965 PRINT_NOTHING: We have done some printing and we don't need any
4966 further info to be printed. */
4968 enum print_stop_action
4969 bpstat_print (bpstat bs
, int kind
)
4971 enum print_stop_action val
;
4973 /* Maybe another breakpoint in the chain caused us to stop.
4974 (Currently all watchpoints go on the bpstat whether hit or not.
4975 That probably could (should) be changed, provided care is taken
4976 with respect to bpstat_explains_signal). */
4977 for (; bs
; bs
= bs
->next
)
4979 val
= print_bp_stop_message (bs
);
4980 if (val
== PRINT_SRC_ONLY
4981 || val
== PRINT_SRC_AND_LOC
4982 || val
== PRINT_NOTHING
)
4986 /* If we had hit a shared library event breakpoint,
4987 print_bp_stop_message would print out this message. If we hit an
4988 OS-level shared library event, do the same thing. */
4989 if (kind
== TARGET_WAITKIND_LOADED
)
4991 print_solib_event (0);
4992 return PRINT_NOTHING
;
4995 /* We reached the end of the chain, or we got a null BS to start
4996 with and nothing was printed. */
4997 return PRINT_UNKNOWN
;
5000 /* Evaluate the expression EXP and return 1 if value is zero.
5001 This returns the inverse of the condition because it is called
5002 from catch_errors which returns 0 if an exception happened, and if an
5003 exception happens we want execution to stop.
5004 The argument is a "struct expression *" that has been cast to a
5005 "void *" to make it pass through catch_errors. */
5008 breakpoint_cond_eval (void *exp
)
5010 struct value
*mark
= value_mark ();
5011 int i
= !value_true (evaluate_expression ((struct expression
*) exp
));
5013 value_free_to_mark (mark
);
5017 /* Allocate a new bpstat. Link it to the FIFO list by BS_LINK_POINTER. */
5020 bpstat_alloc (struct bp_location
*bl
, bpstat
**bs_link_pointer
)
5024 bs
= (bpstat
) xmalloc (sizeof (*bs
));
5026 **bs_link_pointer
= bs
;
5027 *bs_link_pointer
= &bs
->next
;
5028 bs
->breakpoint_at
= bl
->owner
;
5029 bs
->bp_location_at
= bl
;
5030 incref_bp_location (bl
);
5031 /* If the condition is false, etc., don't do the commands. */
5032 bs
->commands
= NULL
;
5034 bs
->print_it
= print_it_normal
;
5038 /* The target has stopped with waitstatus WS. Check if any hardware
5039 watchpoints have triggered, according to the target. */
5042 watchpoints_triggered (struct target_waitstatus
*ws
)
5044 int stopped_by_watchpoint
= target_stopped_by_watchpoint ();
5046 struct breakpoint
*b
;
5048 if (!stopped_by_watchpoint
)
5050 /* We were not stopped by a watchpoint. Mark all watchpoints
5051 as not triggered. */
5053 if (is_hardware_watchpoint (b
))
5055 struct watchpoint
*w
= (struct watchpoint
*) b
;
5057 w
->watchpoint_triggered
= watch_triggered_no
;
5063 if (!target_stopped_data_address (¤t_target
, &addr
))
5065 /* We were stopped by a watchpoint, but we don't know where.
5066 Mark all watchpoints as unknown. */
5068 if (is_hardware_watchpoint (b
))
5070 struct watchpoint
*w
= (struct watchpoint
*) b
;
5072 w
->watchpoint_triggered
= watch_triggered_unknown
;
5078 /* The target could report the data address. Mark watchpoints
5079 affected by this data address as triggered, and all others as not
5083 if (is_hardware_watchpoint (b
))
5085 struct watchpoint
*w
= (struct watchpoint
*) b
;
5086 struct bp_location
*loc
;
5088 w
->watchpoint_triggered
= watch_triggered_no
;
5089 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
5091 if (is_masked_watchpoint (b
))
5093 CORE_ADDR newaddr
= addr
& w
->hw_wp_mask
;
5094 CORE_ADDR start
= loc
->address
& w
->hw_wp_mask
;
5096 if (newaddr
== start
)
5098 w
->watchpoint_triggered
= watch_triggered_yes
;
5102 /* Exact match not required. Within range is sufficient. */
5103 else if (target_watchpoint_addr_within_range (¤t_target
,
5107 w
->watchpoint_triggered
= watch_triggered_yes
;
5116 /* Possible return values for watchpoint_check (this can't be an enum
5117 because of check_errors). */
5118 /* The watchpoint has been deleted. */
5119 #define WP_DELETED 1
5120 /* The value has changed. */
5121 #define WP_VALUE_CHANGED 2
5122 /* The value has not changed. */
5123 #define WP_VALUE_NOT_CHANGED 3
5124 /* Ignore this watchpoint, no matter if the value changed or not. */
5127 #define BP_TEMPFLAG 1
5128 #define BP_HARDWAREFLAG 2
5130 /* Evaluate watchpoint condition expression and check if its value
5133 P should be a pointer to struct bpstat, but is defined as a void *
5134 in order for this function to be usable with catch_errors. */
5137 watchpoint_check (void *p
)
5139 bpstat bs
= (bpstat
) p
;
5140 struct watchpoint
*b
;
5141 struct frame_info
*fr
;
5142 int within_current_scope
;
5144 /* BS is built from an existing struct breakpoint. */
5145 gdb_assert (bs
->breakpoint_at
!= NULL
);
5146 b
= (struct watchpoint
*) bs
->breakpoint_at
;
5148 /* If this is a local watchpoint, we only want to check if the
5149 watchpoint frame is in scope if the current thread is the thread
5150 that was used to create the watchpoint. */
5151 if (!watchpoint_in_thread_scope (b
))
5154 if (b
->exp_valid_block
== NULL
)
5155 within_current_scope
= 1;
5158 struct frame_info
*frame
= get_current_frame ();
5159 struct gdbarch
*frame_arch
= get_frame_arch (frame
);
5160 CORE_ADDR frame_pc
= get_frame_pc (frame
);
5162 /* stack_frame_destroyed_p() returns a non-zero value if we're
5163 still in the function but the stack frame has already been
5164 invalidated. Since we can't rely on the values of local
5165 variables after the stack has been destroyed, we are treating
5166 the watchpoint in that state as `not changed' without further
5167 checking. Don't mark watchpoints as changed if the current
5168 frame is in an epilogue - even if they are in some other
5169 frame, our view of the stack is likely to be wrong and
5170 frame_find_by_id could error out. */
5171 if (gdbarch_stack_frame_destroyed_p (frame_arch
, frame_pc
))
5174 fr
= frame_find_by_id (b
->watchpoint_frame
);
5175 within_current_scope
= (fr
!= NULL
);
5177 /* If we've gotten confused in the unwinder, we might have
5178 returned a frame that can't describe this variable. */
5179 if (within_current_scope
)
5181 struct symbol
*function
;
5183 function
= get_frame_function (fr
);
5184 if (function
== NULL
5185 || !contained_in (b
->exp_valid_block
,
5186 SYMBOL_BLOCK_VALUE (function
)))
5187 within_current_scope
= 0;
5190 if (within_current_scope
)
5191 /* If we end up stopping, the current frame will get selected
5192 in normal_stop. So this call to select_frame won't affect
5197 if (within_current_scope
)
5199 /* We use value_{,free_to_}mark because it could be a *long*
5200 time before we return to the command level and call
5201 free_all_values. We can't call free_all_values because we
5202 might be in the middle of evaluating a function call. */
5206 struct value
*new_val
;
5208 if (is_masked_watchpoint (&b
->base
))
5209 /* Since we don't know the exact trigger address (from
5210 stopped_data_address), just tell the user we've triggered
5211 a mask watchpoint. */
5212 return WP_VALUE_CHANGED
;
5214 mark
= value_mark ();
5215 fetch_subexp_value (b
->exp
, &pc
, &new_val
, NULL
, NULL
, 0);
5217 if (b
->val_bitsize
!= 0)
5218 new_val
= extract_bitfield_from_watchpoint_value (b
, new_val
);
5220 /* We use value_equal_contents instead of value_equal because
5221 the latter coerces an array to a pointer, thus comparing just
5222 the address of the array instead of its contents. This is
5223 not what we want. */
5224 if ((b
->val
!= NULL
) != (new_val
!= NULL
)
5225 || (b
->val
!= NULL
&& !value_equal_contents (b
->val
, new_val
)))
5227 if (new_val
!= NULL
)
5229 release_value (new_val
);
5230 value_free_to_mark (mark
);
5232 bs
->old_val
= b
->val
;
5235 return WP_VALUE_CHANGED
;
5239 /* Nothing changed. */
5240 value_free_to_mark (mark
);
5241 return WP_VALUE_NOT_CHANGED
;
5246 struct switch_thru_all_uis state
;
5248 /* This seems like the only logical thing to do because
5249 if we temporarily ignored the watchpoint, then when
5250 we reenter the block in which it is valid it contains
5251 garbage (in the case of a function, it may have two
5252 garbage values, one before and one after the prologue).
5253 So we can't even detect the first assignment to it and
5254 watch after that (since the garbage may or may not equal
5255 the first value assigned). */
5256 /* We print all the stop information in
5257 breakpoint_ops->print_it, but in this case, by the time we
5258 call breakpoint_ops->print_it this bp will be deleted
5259 already. So we have no choice but print the information
5262 SWITCH_THRU_ALL_UIS (state
)
5264 struct ui_out
*uiout
= current_uiout
;
5266 if (ui_out_is_mi_like_p (uiout
))
5268 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
5269 ui_out_text (uiout
, "\nWatchpoint ");
5270 ui_out_field_int (uiout
, "wpnum", b
->base
.number
);
5272 " deleted because the program has left the block in\n"
5273 "which its expression is valid.\n");
5276 /* Make sure the watchpoint's commands aren't executed. */
5277 decref_counted_command_line (&b
->base
.commands
);
5278 watchpoint_del_at_next_stop (b
);
5284 /* Return true if it looks like target has stopped due to hitting
5285 breakpoint location BL. This function does not check if we should
5286 stop, only if BL explains the stop. */
5289 bpstat_check_location (const struct bp_location
*bl
,
5290 struct address_space
*aspace
, CORE_ADDR bp_addr
,
5291 const struct target_waitstatus
*ws
)
5293 struct breakpoint
*b
= bl
->owner
;
5295 /* BL is from an existing breakpoint. */
5296 gdb_assert (b
!= NULL
);
5298 return b
->ops
->breakpoint_hit (bl
, aspace
, bp_addr
, ws
);
5301 /* Determine if the watched values have actually changed, and we
5302 should stop. If not, set BS->stop to 0. */
5305 bpstat_check_watchpoint (bpstat bs
)
5307 const struct bp_location
*bl
;
5308 struct watchpoint
*b
;
5310 /* BS is built for existing struct breakpoint. */
5311 bl
= bs
->bp_location_at
;
5312 gdb_assert (bl
!= NULL
);
5313 b
= (struct watchpoint
*) bs
->breakpoint_at
;
5314 gdb_assert (b
!= NULL
);
5317 int must_check_value
= 0;
5319 if (b
->base
.type
== bp_watchpoint
)
5320 /* For a software watchpoint, we must always check the
5322 must_check_value
= 1;
5323 else if (b
->watchpoint_triggered
== watch_triggered_yes
)
5324 /* We have a hardware watchpoint (read, write, or access)
5325 and the target earlier reported an address watched by
5327 must_check_value
= 1;
5328 else if (b
->watchpoint_triggered
== watch_triggered_unknown
5329 && b
->base
.type
== bp_hardware_watchpoint
)
5330 /* We were stopped by a hardware watchpoint, but the target could
5331 not report the data address. We must check the watchpoint's
5332 value. Access and read watchpoints are out of luck; without
5333 a data address, we can't figure it out. */
5334 must_check_value
= 1;
5336 if (must_check_value
)
5339 = xstrprintf ("Error evaluating expression for watchpoint %d\n",
5341 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
5342 int e
= catch_errors (watchpoint_check
, bs
, message
,
5344 do_cleanups (cleanups
);
5348 /* We've already printed what needs to be printed. */
5349 bs
->print_it
= print_it_done
;
5353 bs
->print_it
= print_it_noop
;
5356 case WP_VALUE_CHANGED
:
5357 if (b
->base
.type
== bp_read_watchpoint
)
5359 /* There are two cases to consider here:
5361 1. We're watching the triggered memory for reads.
5362 In that case, trust the target, and always report
5363 the watchpoint hit to the user. Even though
5364 reads don't cause value changes, the value may
5365 have changed since the last time it was read, and
5366 since we're not trapping writes, we will not see
5367 those, and as such we should ignore our notion of
5370 2. We're watching the triggered memory for both
5371 reads and writes. There are two ways this may
5374 2.1. This is a target that can't break on data
5375 reads only, but can break on accesses (reads or
5376 writes), such as e.g., x86. We detect this case
5377 at the time we try to insert read watchpoints.
5379 2.2. Otherwise, the target supports read
5380 watchpoints, but, the user set an access or write
5381 watchpoint watching the same memory as this read
5384 If we're watching memory writes as well as reads,
5385 ignore watchpoint hits when we find that the
5386 value hasn't changed, as reads don't cause
5387 changes. This still gives false positives when
5388 the program writes the same value to memory as
5389 what there was already in memory (we will confuse
5390 it for a read), but it's much better than
5393 int other_write_watchpoint
= 0;
5395 if (bl
->watchpoint_type
== hw_read
)
5397 struct breakpoint
*other_b
;
5399 ALL_BREAKPOINTS (other_b
)
5400 if (other_b
->type
== bp_hardware_watchpoint
5401 || other_b
->type
== bp_access_watchpoint
)
5403 struct watchpoint
*other_w
=
5404 (struct watchpoint
*) other_b
;
5406 if (other_w
->watchpoint_triggered
5407 == watch_triggered_yes
)
5409 other_write_watchpoint
= 1;
5415 if (other_write_watchpoint
5416 || bl
->watchpoint_type
== hw_access
)
5418 /* We're watching the same memory for writes,
5419 and the value changed since the last time we
5420 updated it, so this trap must be for a write.
5422 bs
->print_it
= print_it_noop
;
5427 case WP_VALUE_NOT_CHANGED
:
5428 if (b
->base
.type
== bp_hardware_watchpoint
5429 || b
->base
.type
== bp_watchpoint
)
5431 /* Don't stop: write watchpoints shouldn't fire if
5432 the value hasn't changed. */
5433 bs
->print_it
= print_it_noop
;
5441 /* Error from catch_errors. */
5443 struct switch_thru_all_uis state
;
5445 SWITCH_THRU_ALL_UIS (state
)
5447 printf_filtered (_("Watchpoint %d deleted.\n"),
5450 watchpoint_del_at_next_stop (b
);
5451 /* We've already printed what needs to be printed. */
5452 bs
->print_it
= print_it_done
;
5457 else /* must_check_value == 0 */
5459 /* This is a case where some watchpoint(s) triggered, but
5460 not at the address of this watchpoint, or else no
5461 watchpoint triggered after all. So don't print
5462 anything for this watchpoint. */
5463 bs
->print_it
= print_it_noop
;
5469 /* For breakpoints that are currently marked as telling gdb to stop,
5470 check conditions (condition proper, frame, thread and ignore count)
5471 of breakpoint referred to by BS. If we should not stop for this
5472 breakpoint, set BS->stop to 0. */
5475 bpstat_check_breakpoint_conditions (bpstat bs
, ptid_t ptid
)
5477 const struct bp_location
*bl
;
5478 struct breakpoint
*b
;
5479 int value_is_zero
= 0;
5480 struct expression
*cond
;
5482 gdb_assert (bs
->stop
);
5484 /* BS is built for existing struct breakpoint. */
5485 bl
= bs
->bp_location_at
;
5486 gdb_assert (bl
!= NULL
);
5487 b
= bs
->breakpoint_at
;
5488 gdb_assert (b
!= NULL
);
5490 /* Even if the target evaluated the condition on its end and notified GDB, we
5491 need to do so again since GDB does not know if we stopped due to a
5492 breakpoint or a single step breakpoint. */
5494 if (frame_id_p (b
->frame_id
)
5495 && !frame_id_eq (b
->frame_id
, get_stack_frame_id (get_current_frame ())))
5501 /* If this is a thread/task-specific breakpoint, don't waste cpu
5502 evaluating the condition if this isn't the specified
5504 if ((b
->thread
!= -1 && b
->thread
!= ptid_to_global_thread_id (ptid
))
5505 || (b
->task
!= 0 && b
->task
!= ada_get_task_number (ptid
)))
5512 /* Evaluate extension language breakpoints that have a "stop" method
5514 bs
->stop
= breakpoint_ext_lang_cond_says_stop (b
);
5516 if (is_watchpoint (b
))
5518 struct watchpoint
*w
= (struct watchpoint
*) b
;
5525 if (cond
&& b
->disposition
!= disp_del_at_next_stop
)
5527 int within_current_scope
= 1;
5528 struct watchpoint
* w
;
5530 /* We use value_mark and value_free_to_mark because it could
5531 be a long time before we return to the command level and
5532 call free_all_values. We can't call free_all_values
5533 because we might be in the middle of evaluating a
5535 struct value
*mark
= value_mark ();
5537 if (is_watchpoint (b
))
5538 w
= (struct watchpoint
*) b
;
5542 /* Need to select the frame, with all that implies so that
5543 the conditions will have the right context. Because we
5544 use the frame, we will not see an inlined function's
5545 variables when we arrive at a breakpoint at the start
5546 of the inlined function; the current frame will be the
5548 if (w
== NULL
|| w
->cond_exp_valid_block
== NULL
)
5549 select_frame (get_current_frame ());
5552 struct frame_info
*frame
;
5554 /* For local watchpoint expressions, which particular
5555 instance of a local is being watched matters, so we
5556 keep track of the frame to evaluate the expression
5557 in. To evaluate the condition however, it doesn't
5558 really matter which instantiation of the function
5559 where the condition makes sense triggers the
5560 watchpoint. This allows an expression like "watch
5561 global if q > 10" set in `func', catch writes to
5562 global on all threads that call `func', or catch
5563 writes on all recursive calls of `func' by a single
5564 thread. We simply always evaluate the condition in
5565 the innermost frame that's executing where it makes
5566 sense to evaluate the condition. It seems
5568 frame
= block_innermost_frame (w
->cond_exp_valid_block
);
5570 select_frame (frame
);
5572 within_current_scope
= 0;
5574 if (within_current_scope
)
5576 = catch_errors (breakpoint_cond_eval
, cond
,
5577 "Error in testing breakpoint condition:\n",
5581 warning (_("Watchpoint condition cannot be tested "
5582 "in the current scope"));
5583 /* If we failed to set the right context for this
5584 watchpoint, unconditionally report it. */
5587 /* FIXME-someday, should give breakpoint #. */
5588 value_free_to_mark (mark
);
5591 if (cond
&& value_is_zero
)
5595 else if (b
->ignore_count
> 0)
5599 /* Increase the hit count even though we don't stop. */
5601 observer_notify_breakpoint_modified (b
);
5605 /* Returns true if we need to track moribund locations of LOC's type
5606 on the current target. */
5609 need_moribund_for_location_type (struct bp_location
*loc
)
5611 return ((loc
->loc_type
== bp_loc_software_breakpoint
5612 && !target_supports_stopped_by_sw_breakpoint ())
5613 || (loc
->loc_type
== bp_loc_hardware_breakpoint
5614 && !target_supports_stopped_by_hw_breakpoint ()));
5618 /* Get a bpstat associated with having just stopped at address
5619 BP_ADDR in thread PTID.
5621 Determine whether we stopped at a breakpoint, etc, or whether we
5622 don't understand this stop. Result is a chain of bpstat's such
5625 if we don't understand the stop, the result is a null pointer.
5627 if we understand why we stopped, the result is not null.
5629 Each element of the chain refers to a particular breakpoint or
5630 watchpoint at which we have stopped. (We may have stopped for
5631 several reasons concurrently.)
5633 Each element of the chain has valid next, breakpoint_at,
5634 commands, FIXME??? fields. */
5637 bpstat_stop_status (struct address_space
*aspace
,
5638 CORE_ADDR bp_addr
, ptid_t ptid
,
5639 const struct target_waitstatus
*ws
)
5641 struct breakpoint
*b
= NULL
;
5642 struct bp_location
*bl
;
5643 struct bp_location
*loc
;
5644 /* First item of allocated bpstat's. */
5645 bpstat bs_head
= NULL
, *bs_link
= &bs_head
;
5646 /* Pointer to the last thing in the chain currently. */
5649 int need_remove_insert
;
5652 /* First, build the bpstat chain with locations that explain a
5653 target stop, while being careful to not set the target running,
5654 as that may invalidate locations (in particular watchpoint
5655 locations are recreated). Resuming will happen here with
5656 breakpoint conditions or watchpoint expressions that include
5657 inferior function calls. */
5661 if (!breakpoint_enabled (b
))
5664 for (bl
= b
->loc
; bl
!= NULL
; bl
= bl
->next
)
5666 /* For hardware watchpoints, we look only at the first
5667 location. The watchpoint_check function will work on the
5668 entire expression, not the individual locations. For
5669 read watchpoints, the watchpoints_triggered function has
5670 checked all locations already. */
5671 if (b
->type
== bp_hardware_watchpoint
&& bl
!= b
->loc
)
5674 if (!bl
->enabled
|| bl
->shlib_disabled
)
5677 if (!bpstat_check_location (bl
, aspace
, bp_addr
, ws
))
5680 /* Come here if it's a watchpoint, or if the break address
5683 bs
= bpstat_alloc (bl
, &bs_link
); /* Alloc a bpstat to
5686 /* Assume we stop. Should we find a watchpoint that is not
5687 actually triggered, or if the condition of the breakpoint
5688 evaluates as false, we'll reset 'stop' to 0. */
5692 /* If this is a scope breakpoint, mark the associated
5693 watchpoint as triggered so that we will handle the
5694 out-of-scope event. We'll get to the watchpoint next
5696 if (b
->type
== bp_watchpoint_scope
&& b
->related_breakpoint
!= b
)
5698 struct watchpoint
*w
= (struct watchpoint
*) b
->related_breakpoint
;
5700 w
->watchpoint_triggered
= watch_triggered_yes
;
5705 /* Check if a moribund breakpoint explains the stop. */
5706 if (!target_supports_stopped_by_sw_breakpoint ()
5707 || !target_supports_stopped_by_hw_breakpoint ())
5709 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
5711 if (breakpoint_location_address_match (loc
, aspace
, bp_addr
)
5712 && need_moribund_for_location_type (loc
))
5714 bs
= bpstat_alloc (loc
, &bs_link
);
5715 /* For hits of moribund locations, we should just proceed. */
5718 bs
->print_it
= print_it_noop
;
5723 /* A bit of special processing for shlib breakpoints. We need to
5724 process solib loading here, so that the lists of loaded and
5725 unloaded libraries are correct before we handle "catch load" and
5727 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5729 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->type
== bp_shlib_event
)
5731 handle_solib_event ();
5736 /* Now go through the locations that caused the target to stop, and
5737 check whether we're interested in reporting this stop to higher
5738 layers, or whether we should resume the target transparently. */
5742 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5747 b
= bs
->breakpoint_at
;
5748 b
->ops
->check_status (bs
);
5751 bpstat_check_breakpoint_conditions (bs
, ptid
);
5756 observer_notify_breakpoint_modified (b
);
5758 /* We will stop here. */
5759 if (b
->disposition
== disp_disable
)
5761 --(b
->enable_count
);
5762 if (b
->enable_count
<= 0)
5763 b
->enable_state
= bp_disabled
;
5768 bs
->commands
= b
->commands
;
5769 incref_counted_command_line (bs
->commands
);
5770 if (command_line_is_silent (bs
->commands
5771 ? bs
->commands
->commands
: NULL
))
5774 b
->ops
->after_condition_true (bs
);
5779 /* Print nothing for this entry if we don't stop or don't
5781 if (!bs
->stop
|| !bs
->print
)
5782 bs
->print_it
= print_it_noop
;
5785 /* If we aren't stopping, the value of some hardware watchpoint may
5786 not have changed, but the intermediate memory locations we are
5787 watching may have. Don't bother if we're stopping; this will get
5789 need_remove_insert
= 0;
5790 if (! bpstat_causes_stop (bs_head
))
5791 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5793 && bs
->breakpoint_at
5794 && is_hardware_watchpoint (bs
->breakpoint_at
))
5796 struct watchpoint
*w
= (struct watchpoint
*) bs
->breakpoint_at
;
5798 update_watchpoint (w
, 0 /* don't reparse. */);
5799 need_remove_insert
= 1;
5802 if (need_remove_insert
)
5803 update_global_location_list (UGLL_MAY_INSERT
);
5804 else if (removed_any
)
5805 update_global_location_list (UGLL_DONT_INSERT
);
5811 handle_jit_event (void)
5813 struct frame_info
*frame
;
5814 struct gdbarch
*gdbarch
;
5817 fprintf_unfiltered (gdb_stdlog
, "handling bp_jit_event\n");
5819 /* Switch terminal for any messages produced by
5820 breakpoint_re_set. */
5821 target_terminal_ours_for_output ();
5823 frame
= get_current_frame ();
5824 gdbarch
= get_frame_arch (frame
);
5826 jit_event_handler (gdbarch
);
5828 target_terminal_inferior ();
5831 /* Prepare WHAT final decision for infrun. */
5833 /* Decide what infrun needs to do with this bpstat. */
5836 bpstat_what (bpstat bs_head
)
5838 struct bpstat_what retval
;
5841 retval
.main_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5842 retval
.call_dummy
= STOP_NONE
;
5843 retval
.is_longjmp
= 0;
5845 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5847 /* Extract this BS's action. After processing each BS, we check
5848 if its action overrides all we've seem so far. */
5849 enum bpstat_what_main_action this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5852 if (bs
->breakpoint_at
== NULL
)
5854 /* I suspect this can happen if it was a momentary
5855 breakpoint which has since been deleted. */
5859 bptype
= bs
->breakpoint_at
->type
;
5866 case bp_hardware_breakpoint
:
5867 case bp_single_step
:
5870 case bp_shlib_event
:
5874 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5876 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5879 this_action
= BPSTAT_WHAT_SINGLE
;
5882 case bp_hardware_watchpoint
:
5883 case bp_read_watchpoint
:
5884 case bp_access_watchpoint
:
5888 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5890 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5894 /* There was a watchpoint, but we're not stopping.
5895 This requires no further action. */
5899 case bp_longjmp_call_dummy
:
5903 this_action
= BPSTAT_WHAT_SET_LONGJMP_RESUME
;
5904 retval
.is_longjmp
= bptype
!= bp_exception
;
5907 this_action
= BPSTAT_WHAT_SINGLE
;
5909 case bp_longjmp_resume
:
5910 case bp_exception_resume
:
5913 this_action
= BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
;
5914 retval
.is_longjmp
= bptype
== bp_longjmp_resume
;
5917 this_action
= BPSTAT_WHAT_SINGLE
;
5919 case bp_step_resume
:
5921 this_action
= BPSTAT_WHAT_STEP_RESUME
;
5924 /* It is for the wrong frame. */
5925 this_action
= BPSTAT_WHAT_SINGLE
;
5928 case bp_hp_step_resume
:
5930 this_action
= BPSTAT_WHAT_HP_STEP_RESUME
;
5933 /* It is for the wrong frame. */
5934 this_action
= BPSTAT_WHAT_SINGLE
;
5937 case bp_watchpoint_scope
:
5938 case bp_thread_event
:
5939 case bp_overlay_event
:
5940 case bp_longjmp_master
:
5941 case bp_std_terminate_master
:
5942 case bp_exception_master
:
5943 this_action
= BPSTAT_WHAT_SINGLE
;
5949 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5951 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5955 /* There was a catchpoint, but we're not stopping.
5956 This requires no further action. */
5960 this_action
= BPSTAT_WHAT_SINGLE
;
5963 /* Make sure the action is stop (silent or noisy),
5964 so infrun.c pops the dummy frame. */
5965 retval
.call_dummy
= STOP_STACK_DUMMY
;
5966 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5968 case bp_std_terminate
:
5969 /* Make sure the action is stop (silent or noisy),
5970 so infrun.c pops the dummy frame. */
5971 retval
.call_dummy
= STOP_STD_TERMINATE
;
5972 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5975 case bp_fast_tracepoint
:
5976 case bp_static_tracepoint
:
5977 /* Tracepoint hits should not be reported back to GDB, and
5978 if one got through somehow, it should have been filtered
5980 internal_error (__FILE__
, __LINE__
,
5981 _("bpstat_what: tracepoint encountered"));
5983 case bp_gnu_ifunc_resolver
:
5984 /* Step over it (and insert bp_gnu_ifunc_resolver_return). */
5985 this_action
= BPSTAT_WHAT_SINGLE
;
5987 case bp_gnu_ifunc_resolver_return
:
5988 /* The breakpoint will be removed, execution will restart from the
5989 PC of the former breakpoint. */
5990 this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5995 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5997 this_action
= BPSTAT_WHAT_SINGLE
;
6001 internal_error (__FILE__
, __LINE__
,
6002 _("bpstat_what: unhandled bptype %d"), (int) bptype
);
6005 retval
.main_action
= max (retval
.main_action
, this_action
);
6012 bpstat_run_callbacks (bpstat bs_head
)
6016 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
6018 struct breakpoint
*b
= bs
->breakpoint_at
;
6025 handle_jit_event ();
6027 case bp_gnu_ifunc_resolver
:
6028 gnu_ifunc_resolver_stop (b
);
6030 case bp_gnu_ifunc_resolver_return
:
6031 gnu_ifunc_resolver_return_stop (b
);
6037 /* Nonzero if we should step constantly (e.g. watchpoints on machines
6038 without hardware support). This isn't related to a specific bpstat,
6039 just to things like whether watchpoints are set. */
6042 bpstat_should_step (void)
6044 struct breakpoint
*b
;
6047 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
&& b
->loc
!= NULL
)
6053 bpstat_causes_stop (bpstat bs
)
6055 for (; bs
!= NULL
; bs
= bs
->next
)
6064 /* Compute a string of spaces suitable to indent the next line
6065 so it starts at the position corresponding to the table column
6066 named COL_NAME in the currently active table of UIOUT. */
6069 wrap_indent_at_field (struct ui_out
*uiout
, const char *col_name
)
6071 static char wrap_indent
[80];
6072 int i
, total_width
, width
, align
;
6076 for (i
= 1; ui_out_query_field (uiout
, i
, &width
, &align
, &text
); i
++)
6078 if (strcmp (text
, col_name
) == 0)
6080 gdb_assert (total_width
< sizeof wrap_indent
);
6081 memset (wrap_indent
, ' ', total_width
);
6082 wrap_indent
[total_width
] = 0;
6087 total_width
+= width
+ 1;
6093 /* Determine if the locations of this breakpoint will have their conditions
6094 evaluated by the target, host or a mix of both. Returns the following:
6096 "host": Host evals condition.
6097 "host or target": Host or Target evals condition.
6098 "target": Target evals condition.
6102 bp_condition_evaluator (struct breakpoint
*b
)
6104 struct bp_location
*bl
;
6105 char host_evals
= 0;
6106 char target_evals
= 0;
6111 if (!is_breakpoint (b
))
6114 if (gdb_evaluates_breakpoint_condition_p ()
6115 || !target_supports_evaluation_of_breakpoint_conditions ())
6116 return condition_evaluation_host
;
6118 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
6120 if (bl
->cond_bytecode
)
6126 if (host_evals
&& target_evals
)
6127 return condition_evaluation_both
;
6128 else if (target_evals
)
6129 return condition_evaluation_target
;
6131 return condition_evaluation_host
;
6134 /* Determine the breakpoint location's condition evaluator. This is
6135 similar to bp_condition_evaluator, but for locations. */
6138 bp_location_condition_evaluator (struct bp_location
*bl
)
6140 if (bl
&& !is_breakpoint (bl
->owner
))
6143 if (gdb_evaluates_breakpoint_condition_p ()
6144 || !target_supports_evaluation_of_breakpoint_conditions ())
6145 return condition_evaluation_host
;
6147 if (bl
&& bl
->cond_bytecode
)
6148 return condition_evaluation_target
;
6150 return condition_evaluation_host
;
6153 /* Print the LOC location out of the list of B->LOC locations. */
6156 print_breakpoint_location (struct breakpoint
*b
,
6157 struct bp_location
*loc
)
6159 struct ui_out
*uiout
= current_uiout
;
6160 struct cleanup
*old_chain
= save_current_program_space ();
6162 if (loc
!= NULL
&& loc
->shlib_disabled
)
6166 set_current_program_space (loc
->pspace
);
6168 if (b
->display_canonical
)
6169 ui_out_field_string (uiout
, "what",
6170 event_location_to_string (b
->location
));
6171 else if (loc
&& loc
->symtab
)
6174 = find_pc_sect_function (loc
->address
, loc
->section
);
6177 ui_out_text (uiout
, "in ");
6178 ui_out_field_string (uiout
, "func",
6179 SYMBOL_PRINT_NAME (sym
));
6180 ui_out_text (uiout
, " ");
6181 ui_out_wrap_hint (uiout
, wrap_indent_at_field (uiout
, "what"));
6182 ui_out_text (uiout
, "at ");
6184 ui_out_field_string (uiout
, "file",
6185 symtab_to_filename_for_display (loc
->symtab
));
6186 ui_out_text (uiout
, ":");
6188 if (ui_out_is_mi_like_p (uiout
))
6189 ui_out_field_string (uiout
, "fullname",
6190 symtab_to_fullname (loc
->symtab
));
6192 ui_out_field_int (uiout
, "line", loc
->line_number
);
6196 struct ui_file
*stb
= mem_fileopen ();
6197 struct cleanup
*stb_chain
= make_cleanup_ui_file_delete (stb
);
6199 print_address_symbolic (loc
->gdbarch
, loc
->address
, stb
,
6201 ui_out_field_stream (uiout
, "at", stb
);
6203 do_cleanups (stb_chain
);
6207 ui_out_field_string (uiout
, "pending",
6208 event_location_to_string (b
->location
));
6209 /* If extra_string is available, it could be holding a condition
6210 or dprintf arguments. In either case, make sure it is printed,
6211 too, but only for non-MI streams. */
6212 if (!ui_out_is_mi_like_p (uiout
) && b
->extra_string
!= NULL
)
6214 if (b
->type
== bp_dprintf
)
6215 ui_out_text (uiout
, ",");
6217 ui_out_text (uiout
, " ");
6218 ui_out_text (uiout
, b
->extra_string
);
6222 if (loc
&& is_breakpoint (b
)
6223 && breakpoint_condition_evaluation_mode () == condition_evaluation_target
6224 && bp_condition_evaluator (b
) == condition_evaluation_both
)
6226 ui_out_text (uiout
, " (");
6227 ui_out_field_string (uiout
, "evaluated-by",
6228 bp_location_condition_evaluator (loc
));
6229 ui_out_text (uiout
, ")");
6232 do_cleanups (old_chain
);
6236 bptype_string (enum bptype type
)
6238 struct ep_type_description
6243 static struct ep_type_description bptypes
[] =
6245 {bp_none
, "?deleted?"},
6246 {bp_breakpoint
, "breakpoint"},
6247 {bp_hardware_breakpoint
, "hw breakpoint"},
6248 {bp_single_step
, "sw single-step"},
6249 {bp_until
, "until"},
6250 {bp_finish
, "finish"},
6251 {bp_watchpoint
, "watchpoint"},
6252 {bp_hardware_watchpoint
, "hw watchpoint"},
6253 {bp_read_watchpoint
, "read watchpoint"},
6254 {bp_access_watchpoint
, "acc watchpoint"},
6255 {bp_longjmp
, "longjmp"},
6256 {bp_longjmp_resume
, "longjmp resume"},
6257 {bp_longjmp_call_dummy
, "longjmp for call dummy"},
6258 {bp_exception
, "exception"},
6259 {bp_exception_resume
, "exception resume"},
6260 {bp_step_resume
, "step resume"},
6261 {bp_hp_step_resume
, "high-priority step resume"},
6262 {bp_watchpoint_scope
, "watchpoint scope"},
6263 {bp_call_dummy
, "call dummy"},
6264 {bp_std_terminate
, "std::terminate"},
6265 {bp_shlib_event
, "shlib events"},
6266 {bp_thread_event
, "thread events"},
6267 {bp_overlay_event
, "overlay events"},
6268 {bp_longjmp_master
, "longjmp master"},
6269 {bp_std_terminate_master
, "std::terminate master"},
6270 {bp_exception_master
, "exception master"},
6271 {bp_catchpoint
, "catchpoint"},
6272 {bp_tracepoint
, "tracepoint"},
6273 {bp_fast_tracepoint
, "fast tracepoint"},
6274 {bp_static_tracepoint
, "static tracepoint"},
6275 {bp_dprintf
, "dprintf"},
6276 {bp_jit_event
, "jit events"},
6277 {bp_gnu_ifunc_resolver
, "STT_GNU_IFUNC resolver"},
6278 {bp_gnu_ifunc_resolver_return
, "STT_GNU_IFUNC resolver return"},
6281 if (((int) type
>= (sizeof (bptypes
) / sizeof (bptypes
[0])))
6282 || ((int) type
!= bptypes
[(int) type
].type
))
6283 internal_error (__FILE__
, __LINE__
,
6284 _("bptypes table does not describe type #%d."),
6287 return bptypes
[(int) type
].description
;
6290 /* For MI, output a field named 'thread-groups' with a list as the value.
6291 For CLI, prefix the list with the string 'inf'. */
6294 output_thread_groups (struct ui_out
*uiout
,
6295 const char *field_name
,
6299 struct cleanup
*back_to
;
6300 int is_mi
= ui_out_is_mi_like_p (uiout
);
6304 /* For backward compatibility, don't display inferiors in CLI unless
6305 there are several. Always display them for MI. */
6306 if (!is_mi
&& mi_only
)
6309 back_to
= make_cleanup_ui_out_list_begin_end (uiout
, field_name
);
6311 for (i
= 0; VEC_iterate (int, inf_num
, i
, inf
); ++i
)
6317 xsnprintf (mi_group
, sizeof (mi_group
), "i%d", inf
);
6318 ui_out_field_string (uiout
, NULL
, mi_group
);
6323 ui_out_text (uiout
, " inf ");
6325 ui_out_text (uiout
, ", ");
6327 ui_out_text (uiout
, plongest (inf
));
6331 do_cleanups (back_to
);
6334 /* Print B to gdb_stdout. */
6337 print_one_breakpoint_location (struct breakpoint
*b
,
6338 struct bp_location
*loc
,
6340 struct bp_location
**last_loc
,
6343 struct command_line
*l
;
6344 static char bpenables
[] = "nynny";
6346 struct ui_out
*uiout
= current_uiout
;
6347 int header_of_multiple
= 0;
6348 int part_of_multiple
= (loc
!= NULL
);
6349 struct value_print_options opts
;
6351 get_user_print_options (&opts
);
6353 gdb_assert (!loc
|| loc_number
!= 0);
6354 /* See comment in print_one_breakpoint concerning treatment of
6355 breakpoints with single disabled location. */
6358 && (b
->loc
->next
!= NULL
|| !b
->loc
->enabled
)))
6359 header_of_multiple
= 1;
6367 if (part_of_multiple
)
6370 formatted
= xstrprintf ("%d.%d", b
->number
, loc_number
);
6371 ui_out_field_string (uiout
, "number", formatted
);
6376 ui_out_field_int (uiout
, "number", b
->number
);
6381 if (part_of_multiple
)
6382 ui_out_field_skip (uiout
, "type");
6384 ui_out_field_string (uiout
, "type", bptype_string (b
->type
));
6388 if (part_of_multiple
)
6389 ui_out_field_skip (uiout
, "disp");
6391 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
6396 if (part_of_multiple
)
6397 ui_out_field_string (uiout
, "enabled", loc
->enabled
? "y" : "n");
6399 ui_out_field_fmt (uiout
, "enabled", "%c",
6400 bpenables
[(int) b
->enable_state
]);
6401 ui_out_spaces (uiout
, 2);
6405 if (b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
6407 /* Although the print_one can possibly print all locations,
6408 calling it here is not likely to get any nice result. So,
6409 make sure there's just one location. */
6410 gdb_assert (b
->loc
== NULL
|| b
->loc
->next
== NULL
);
6411 b
->ops
->print_one (b
, last_loc
);
6417 internal_error (__FILE__
, __LINE__
,
6418 _("print_one_breakpoint: bp_none encountered\n"));
6422 case bp_hardware_watchpoint
:
6423 case bp_read_watchpoint
:
6424 case bp_access_watchpoint
:
6426 struct watchpoint
*w
= (struct watchpoint
*) b
;
6428 /* Field 4, the address, is omitted (which makes the columns
6429 not line up too nicely with the headers, but the effect
6430 is relatively readable). */
6431 if (opts
.addressprint
)
6432 ui_out_field_skip (uiout
, "addr");
6434 ui_out_field_string (uiout
, "what", w
->exp_string
);
6439 case bp_hardware_breakpoint
:
6440 case bp_single_step
:
6444 case bp_longjmp_resume
:
6445 case bp_longjmp_call_dummy
:
6447 case bp_exception_resume
:
6448 case bp_step_resume
:
6449 case bp_hp_step_resume
:
6450 case bp_watchpoint_scope
:
6452 case bp_std_terminate
:
6453 case bp_shlib_event
:
6454 case bp_thread_event
:
6455 case bp_overlay_event
:
6456 case bp_longjmp_master
:
6457 case bp_std_terminate_master
:
6458 case bp_exception_master
:
6460 case bp_fast_tracepoint
:
6461 case bp_static_tracepoint
:
6464 case bp_gnu_ifunc_resolver
:
6465 case bp_gnu_ifunc_resolver_return
:
6466 if (opts
.addressprint
)
6469 if (header_of_multiple
)
6470 ui_out_field_string (uiout
, "addr", "<MULTIPLE>");
6471 else if (b
->loc
== NULL
|| loc
->shlib_disabled
)
6472 ui_out_field_string (uiout
, "addr", "<PENDING>");
6474 ui_out_field_core_addr (uiout
, "addr",
6475 loc
->gdbarch
, loc
->address
);
6478 if (!header_of_multiple
)
6479 print_breakpoint_location (b
, loc
);
6486 if (loc
!= NULL
&& !header_of_multiple
)
6488 struct inferior
*inf
;
6489 VEC(int) *inf_num
= NULL
;
6494 if (inf
->pspace
== loc
->pspace
)
6495 VEC_safe_push (int, inf_num
, inf
->num
);
6498 /* For backward compatibility, don't display inferiors in CLI unless
6499 there are several. Always display for MI. */
6501 || (!gdbarch_has_global_breakpoints (target_gdbarch ())
6502 && (number_of_program_spaces () > 1
6503 || number_of_inferiors () > 1)
6504 /* LOC is for existing B, it cannot be in
6505 moribund_locations and thus having NULL OWNER. */
6506 && loc
->owner
->type
!= bp_catchpoint
))
6508 output_thread_groups (uiout
, "thread-groups", inf_num
, mi_only
);
6509 VEC_free (int, inf_num
);
6512 if (!part_of_multiple
)
6514 if (b
->thread
!= -1)
6516 /* FIXME: This seems to be redundant and lost here; see the
6517 "stop only in" line a little further down. */
6518 ui_out_text (uiout
, " thread ");
6519 ui_out_field_int (uiout
, "thread", b
->thread
);
6521 else if (b
->task
!= 0)
6523 ui_out_text (uiout
, " task ");
6524 ui_out_field_int (uiout
, "task", b
->task
);
6528 ui_out_text (uiout
, "\n");
6530 if (!part_of_multiple
)
6531 b
->ops
->print_one_detail (b
, uiout
);
6533 if (part_of_multiple
&& frame_id_p (b
->frame_id
))
6536 ui_out_text (uiout
, "\tstop only in stack frame at ");
6537 /* FIXME: cagney/2002-12-01: Shouldn't be poking around inside
6539 ui_out_field_core_addr (uiout
, "frame",
6540 b
->gdbarch
, b
->frame_id
.stack_addr
);
6541 ui_out_text (uiout
, "\n");
6544 if (!part_of_multiple
&& b
->cond_string
)
6547 if (is_tracepoint (b
))
6548 ui_out_text (uiout
, "\ttrace only if ");
6550 ui_out_text (uiout
, "\tstop only if ");
6551 ui_out_field_string (uiout
, "cond", b
->cond_string
);
6553 /* Print whether the target is doing the breakpoint's condition
6554 evaluation. If GDB is doing the evaluation, don't print anything. */
6555 if (is_breakpoint (b
)
6556 && breakpoint_condition_evaluation_mode ()
6557 == condition_evaluation_target
)
6559 ui_out_text (uiout
, " (");
6560 ui_out_field_string (uiout
, "evaluated-by",
6561 bp_condition_evaluator (b
));
6562 ui_out_text (uiout
, " evals)");
6564 ui_out_text (uiout
, "\n");
6567 if (!part_of_multiple
&& b
->thread
!= -1)
6569 /* FIXME should make an annotation for this. */
6570 ui_out_text (uiout
, "\tstop only in thread ");
6571 if (ui_out_is_mi_like_p (uiout
))
6572 ui_out_field_int (uiout
, "thread", b
->thread
);
6575 struct thread_info
*thr
= find_thread_global_id (b
->thread
);
6577 ui_out_field_string (uiout
, "thread", print_thread_id (thr
));
6579 ui_out_text (uiout
, "\n");
6582 if (!part_of_multiple
)
6586 /* FIXME should make an annotation for this. */
6587 if (is_catchpoint (b
))
6588 ui_out_text (uiout
, "\tcatchpoint");
6589 else if (is_tracepoint (b
))
6590 ui_out_text (uiout
, "\ttracepoint");
6592 ui_out_text (uiout
, "\tbreakpoint");
6593 ui_out_text (uiout
, " already hit ");
6594 ui_out_field_int (uiout
, "times", b
->hit_count
);
6595 if (b
->hit_count
== 1)
6596 ui_out_text (uiout
, " time\n");
6598 ui_out_text (uiout
, " times\n");
6602 /* Output the count also if it is zero, but only if this is mi. */
6603 if (ui_out_is_mi_like_p (uiout
))
6604 ui_out_field_int (uiout
, "times", b
->hit_count
);
6608 if (!part_of_multiple
&& b
->ignore_count
)
6611 ui_out_text (uiout
, "\tignore next ");
6612 ui_out_field_int (uiout
, "ignore", b
->ignore_count
);
6613 ui_out_text (uiout
, " hits\n");
6616 /* Note that an enable count of 1 corresponds to "enable once"
6617 behavior, which is reported by the combination of enablement and
6618 disposition, so we don't need to mention it here. */
6619 if (!part_of_multiple
&& b
->enable_count
> 1)
6622 ui_out_text (uiout
, "\tdisable after ");
6623 /* Tweak the wording to clarify that ignore and enable counts
6624 are distinct, and have additive effect. */
6625 if (b
->ignore_count
)
6626 ui_out_text (uiout
, "additional ");
6628 ui_out_text (uiout
, "next ");
6629 ui_out_field_int (uiout
, "enable", b
->enable_count
);
6630 ui_out_text (uiout
, " hits\n");
6633 if (!part_of_multiple
&& is_tracepoint (b
))
6635 struct tracepoint
*tp
= (struct tracepoint
*) b
;
6637 if (tp
->traceframe_usage
)
6639 ui_out_text (uiout
, "\ttrace buffer usage ");
6640 ui_out_field_int (uiout
, "traceframe-usage", tp
->traceframe_usage
);
6641 ui_out_text (uiout
, " bytes\n");
6645 l
= b
->commands
? b
->commands
->commands
: NULL
;
6646 if (!part_of_multiple
&& l
)
6648 struct cleanup
*script_chain
;
6651 script_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "script");
6652 print_command_lines (uiout
, l
, 4);
6653 do_cleanups (script_chain
);
6656 if (is_tracepoint (b
))
6658 struct tracepoint
*t
= (struct tracepoint
*) b
;
6660 if (!part_of_multiple
&& t
->pass_count
)
6662 annotate_field (10);
6663 ui_out_text (uiout
, "\tpass count ");
6664 ui_out_field_int (uiout
, "pass", t
->pass_count
);
6665 ui_out_text (uiout
, " \n");
6668 /* Don't display it when tracepoint or tracepoint location is
6670 if (!header_of_multiple
&& loc
!= NULL
&& !loc
->shlib_disabled
)
6672 annotate_field (11);
6674 if (ui_out_is_mi_like_p (uiout
))
6675 ui_out_field_string (uiout
, "installed",
6676 loc
->inserted
? "y" : "n");
6680 ui_out_text (uiout
, "\t");
6682 ui_out_text (uiout
, "\tnot ");
6683 ui_out_text (uiout
, "installed on target\n");
6688 if (ui_out_is_mi_like_p (uiout
) && !part_of_multiple
)
6690 if (is_watchpoint (b
))
6692 struct watchpoint
*w
= (struct watchpoint
*) b
;
6694 ui_out_field_string (uiout
, "original-location", w
->exp_string
);
6696 else if (b
->location
!= NULL
6697 && event_location_to_string (b
->location
) != NULL
)
6698 ui_out_field_string (uiout
, "original-location",
6699 event_location_to_string (b
->location
));
6704 print_one_breakpoint (struct breakpoint
*b
,
6705 struct bp_location
**last_loc
,
6708 struct cleanup
*bkpt_chain
;
6709 struct ui_out
*uiout
= current_uiout
;
6711 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "bkpt");
6713 print_one_breakpoint_location (b
, NULL
, 0, last_loc
, allflag
);
6714 do_cleanups (bkpt_chain
);
6716 /* If this breakpoint has custom print function,
6717 it's already printed. Otherwise, print individual
6718 locations, if any. */
6719 if (b
->ops
== NULL
|| b
->ops
->print_one
== NULL
)
6721 /* If breakpoint has a single location that is disabled, we
6722 print it as if it had several locations, since otherwise it's
6723 hard to represent "breakpoint enabled, location disabled"
6726 Note that while hardware watchpoints have several locations
6727 internally, that's not a property exposed to user. */
6729 && !is_hardware_watchpoint (b
)
6730 && (b
->loc
->next
|| !b
->loc
->enabled
))
6732 struct bp_location
*loc
;
6735 for (loc
= b
->loc
; loc
; loc
= loc
->next
, ++n
)
6737 struct cleanup
*inner2
=
6738 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
6739 print_one_breakpoint_location (b
, loc
, n
, last_loc
, allflag
);
6740 do_cleanups (inner2
);
6747 breakpoint_address_bits (struct breakpoint
*b
)
6749 int print_address_bits
= 0;
6750 struct bp_location
*loc
;
6752 /* Software watchpoints that aren't watching memory don't have an
6753 address to print. */
6754 if (is_no_memory_software_watchpoint (b
))
6757 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
6761 addr_bit
= gdbarch_addr_bit (loc
->gdbarch
);
6762 if (addr_bit
> print_address_bits
)
6763 print_address_bits
= addr_bit
;
6766 return print_address_bits
;
6769 struct captured_breakpoint_query_args
6775 do_captured_breakpoint_query (struct ui_out
*uiout
, void *data
)
6777 struct captured_breakpoint_query_args
*args
6778 = (struct captured_breakpoint_query_args
*) data
;
6779 struct breakpoint
*b
;
6780 struct bp_location
*dummy_loc
= NULL
;
6784 if (args
->bnum
== b
->number
)
6786 print_one_breakpoint (b
, &dummy_loc
, 0);
6794 gdb_breakpoint_query (struct ui_out
*uiout
, int bnum
,
6795 char **error_message
)
6797 struct captured_breakpoint_query_args args
;
6800 /* For the moment we don't trust print_one_breakpoint() to not throw
6802 if (catch_exceptions_with_msg (uiout
, do_captured_breakpoint_query
, &args
,
6803 error_message
, RETURN_MASK_ALL
) < 0)
6809 /* Return true if this breakpoint was set by the user, false if it is
6810 internal or momentary. */
6813 user_breakpoint_p (struct breakpoint
*b
)
6815 return b
->number
> 0;
6818 /* See breakpoint.h. */
6821 pending_breakpoint_p (struct breakpoint
*b
)
6823 return b
->loc
== NULL
;
6826 /* Print information on user settable breakpoint (watchpoint, etc)
6827 number BNUM. If BNUM is -1 print all user-settable breakpoints.
6828 If ALLFLAG is non-zero, include non-user-settable breakpoints. If
6829 FILTER is non-NULL, call it on each breakpoint and only include the
6830 ones for which it returns non-zero. Return the total number of
6831 breakpoints listed. */
6834 breakpoint_1 (char *args
, int allflag
,
6835 int (*filter
) (const struct breakpoint
*))
6837 struct breakpoint
*b
;
6838 struct bp_location
*last_loc
= NULL
;
6839 int nr_printable_breakpoints
;
6840 struct cleanup
*bkpttbl_chain
;
6841 struct value_print_options opts
;
6842 int print_address_bits
= 0;
6843 int print_type_col_width
= 14;
6844 struct ui_out
*uiout
= current_uiout
;
6846 get_user_print_options (&opts
);
6848 /* Compute the number of rows in the table, as well as the size
6849 required for address fields. */
6850 nr_printable_breakpoints
= 0;
6853 /* If we have a filter, only list the breakpoints it accepts. */
6854 if (filter
&& !filter (b
))
6857 /* If we have an "args" string, it is a list of breakpoints to
6858 accept. Skip the others. */
6859 if (args
!= NULL
&& *args
!= '\0')
6861 if (allflag
&& parse_and_eval_long (args
) != b
->number
)
6863 if (!allflag
&& !number_is_in_list (args
, b
->number
))
6867 if (allflag
|| user_breakpoint_p (b
))
6869 int addr_bit
, type_len
;
6871 addr_bit
= breakpoint_address_bits (b
);
6872 if (addr_bit
> print_address_bits
)
6873 print_address_bits
= addr_bit
;
6875 type_len
= strlen (bptype_string (b
->type
));
6876 if (type_len
> print_type_col_width
)
6877 print_type_col_width
= type_len
;
6879 nr_printable_breakpoints
++;
6883 if (opts
.addressprint
)
6885 = make_cleanup_ui_out_table_begin_end (uiout
, 6,
6886 nr_printable_breakpoints
,
6890 = make_cleanup_ui_out_table_begin_end (uiout
, 5,
6891 nr_printable_breakpoints
,
6894 if (nr_printable_breakpoints
> 0)
6895 annotate_breakpoints_headers ();
6896 if (nr_printable_breakpoints
> 0)
6898 ui_out_table_header (uiout
, 7, ui_left
, "number", "Num"); /* 1 */
6899 if (nr_printable_breakpoints
> 0)
6901 ui_out_table_header (uiout
, print_type_col_width
, ui_left
,
6902 "type", "Type"); /* 2 */
6903 if (nr_printable_breakpoints
> 0)
6905 ui_out_table_header (uiout
, 4, ui_left
, "disp", "Disp"); /* 3 */
6906 if (nr_printable_breakpoints
> 0)
6908 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb"); /* 4 */
6909 if (opts
.addressprint
)
6911 if (nr_printable_breakpoints
> 0)
6913 if (print_address_bits
<= 32)
6914 ui_out_table_header (uiout
, 10, ui_left
,
6915 "addr", "Address"); /* 5 */
6917 ui_out_table_header (uiout
, 18, ui_left
,
6918 "addr", "Address"); /* 5 */
6920 if (nr_printable_breakpoints
> 0)
6922 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What"); /* 6 */
6923 ui_out_table_body (uiout
);
6924 if (nr_printable_breakpoints
> 0)
6925 annotate_breakpoints_table ();
6930 /* If we have a filter, only list the breakpoints it accepts. */
6931 if (filter
&& !filter (b
))
6934 /* If we have an "args" string, it is a list of breakpoints to
6935 accept. Skip the others. */
6937 if (args
!= NULL
&& *args
!= '\0')
6939 if (allflag
) /* maintenance info breakpoint */
6941 if (parse_and_eval_long (args
) != b
->number
)
6944 else /* all others */
6946 if (!number_is_in_list (args
, b
->number
))
6950 /* We only print out user settable breakpoints unless the
6952 if (allflag
|| user_breakpoint_p (b
))
6953 print_one_breakpoint (b
, &last_loc
, allflag
);
6956 do_cleanups (bkpttbl_chain
);
6958 if (nr_printable_breakpoints
== 0)
6960 /* If there's a filter, let the caller decide how to report
6964 if (args
== NULL
|| *args
== '\0')
6965 ui_out_message (uiout
, 0, "No breakpoints or watchpoints.\n");
6967 ui_out_message (uiout
, 0,
6968 "No breakpoint or watchpoint matching '%s'.\n",
6974 if (last_loc
&& !server_command
)
6975 set_next_address (last_loc
->gdbarch
, last_loc
->address
);
6978 /* FIXME? Should this be moved up so that it is only called when
6979 there have been breakpoints? */
6980 annotate_breakpoints_table_end ();
6982 return nr_printable_breakpoints
;
6985 /* Display the value of default-collect in a way that is generally
6986 compatible with the breakpoint list. */
6989 default_collect_info (void)
6991 struct ui_out
*uiout
= current_uiout
;
6993 /* If it has no value (which is frequently the case), say nothing; a
6994 message like "No default-collect." gets in user's face when it's
6996 if (!*default_collect
)
6999 /* The following phrase lines up nicely with per-tracepoint collect
7001 ui_out_text (uiout
, "default collect ");
7002 ui_out_field_string (uiout
, "default-collect", default_collect
);
7003 ui_out_text (uiout
, " \n");
7007 breakpoints_info (char *args
, int from_tty
)
7009 breakpoint_1 (args
, 0, NULL
);
7011 default_collect_info ();
7015 watchpoints_info (char *args
, int from_tty
)
7017 int num_printed
= breakpoint_1 (args
, 0, is_watchpoint
);
7018 struct ui_out
*uiout
= current_uiout
;
7020 if (num_printed
== 0)
7022 if (args
== NULL
|| *args
== '\0')
7023 ui_out_message (uiout
, 0, "No watchpoints.\n");
7025 ui_out_message (uiout
, 0, "No watchpoint matching '%s'.\n", args
);
7030 maintenance_info_breakpoints (char *args
, int from_tty
)
7032 breakpoint_1 (args
, 1, NULL
);
7034 default_collect_info ();
7038 breakpoint_has_pc (struct breakpoint
*b
,
7039 struct program_space
*pspace
,
7040 CORE_ADDR pc
, struct obj_section
*section
)
7042 struct bp_location
*bl
= b
->loc
;
7044 for (; bl
; bl
= bl
->next
)
7046 if (bl
->pspace
== pspace
7047 && bl
->address
== pc
7048 && (!overlay_debugging
|| bl
->section
== section
))
7054 /* Print a message describing any user-breakpoints set at PC. This
7055 concerns with logical breakpoints, so we match program spaces, not
7059 describe_other_breakpoints (struct gdbarch
*gdbarch
,
7060 struct program_space
*pspace
, CORE_ADDR pc
,
7061 struct obj_section
*section
, int thread
)
7064 struct breakpoint
*b
;
7067 others
+= (user_breakpoint_p (b
)
7068 && breakpoint_has_pc (b
, pspace
, pc
, section
));
7072 printf_filtered (_("Note: breakpoint "));
7073 else /* if (others == ???) */
7074 printf_filtered (_("Note: breakpoints "));
7076 if (user_breakpoint_p (b
) && breakpoint_has_pc (b
, pspace
, pc
, section
))
7079 printf_filtered ("%d", b
->number
);
7080 if (b
->thread
== -1 && thread
!= -1)
7081 printf_filtered (" (all threads)");
7082 else if (b
->thread
!= -1)
7083 printf_filtered (" (thread %d)", b
->thread
);
7084 printf_filtered ("%s%s ",
7085 ((b
->enable_state
== bp_disabled
7086 || b
->enable_state
== bp_call_disabled
)
7090 : ((others
== 1) ? " and" : ""));
7092 printf_filtered (_("also set at pc "));
7093 fputs_filtered (paddress (gdbarch
, pc
), gdb_stdout
);
7094 printf_filtered (".\n");
7099 /* Return true iff it is meaningful to use the address member of
7100 BPT locations. For some breakpoint types, the locations' address members
7101 are irrelevant and it makes no sense to attempt to compare them to other
7102 addresses (or use them for any other purpose either).
7104 More specifically, each of the following breakpoint types will
7105 always have a zero valued location address and we don't want to mark
7106 breakpoints of any of these types to be a duplicate of an actual
7107 breakpoint location at address zero:
7115 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
7117 enum bptype type
= bpt
->type
;
7119 return (type
!= bp_watchpoint
&& type
!= bp_catchpoint
);
7122 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
7123 true if LOC1 and LOC2 represent the same watchpoint location. */
7126 watchpoint_locations_match (struct bp_location
*loc1
,
7127 struct bp_location
*loc2
)
7129 struct watchpoint
*w1
= (struct watchpoint
*) loc1
->owner
;
7130 struct watchpoint
*w2
= (struct watchpoint
*) loc2
->owner
;
7132 /* Both of them must exist. */
7133 gdb_assert (w1
!= NULL
);
7134 gdb_assert (w2
!= NULL
);
7136 /* If the target can evaluate the condition expression in hardware,
7137 then we we need to insert both watchpoints even if they are at
7138 the same place. Otherwise the watchpoint will only trigger when
7139 the condition of whichever watchpoint was inserted evaluates to
7140 true, not giving a chance for GDB to check the condition of the
7141 other watchpoint. */
7143 && target_can_accel_watchpoint_condition (loc1
->address
,
7145 loc1
->watchpoint_type
,
7148 && target_can_accel_watchpoint_condition (loc2
->address
,
7150 loc2
->watchpoint_type
,
7154 /* Note that this checks the owner's type, not the location's. In
7155 case the target does not support read watchpoints, but does
7156 support access watchpoints, we'll have bp_read_watchpoint
7157 watchpoints with hw_access locations. Those should be considered
7158 duplicates of hw_read locations. The hw_read locations will
7159 become hw_access locations later. */
7160 return (loc1
->owner
->type
== loc2
->owner
->type
7161 && loc1
->pspace
->aspace
== loc2
->pspace
->aspace
7162 && loc1
->address
== loc2
->address
7163 && loc1
->length
== loc2
->length
);
7166 /* See breakpoint.h. */
7169 breakpoint_address_match (struct address_space
*aspace1
, CORE_ADDR addr1
,
7170 struct address_space
*aspace2
, CORE_ADDR addr2
)
7172 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
7173 || aspace1
== aspace2
)
7177 /* Returns true if {ASPACE2,ADDR2} falls within the range determined by
7178 {ASPACE1,ADDR1,LEN1}. In most targets, this can only be true if ASPACE1
7179 matches ASPACE2. On targets that have global breakpoints, the address
7180 space doesn't really matter. */
7183 breakpoint_address_match_range (struct address_space
*aspace1
, CORE_ADDR addr1
,
7184 int len1
, struct address_space
*aspace2
,
7187 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
7188 || aspace1
== aspace2
)
7189 && addr2
>= addr1
&& addr2
< addr1
+ len1
);
7192 /* Returns true if {ASPACE,ADDR} matches the breakpoint BL. BL may be
7193 a ranged breakpoint. In most targets, a match happens only if ASPACE
7194 matches the breakpoint's address space. On targets that have global
7195 breakpoints, the address space doesn't really matter. */
7198 breakpoint_location_address_match (struct bp_location
*bl
,
7199 struct address_space
*aspace
,
7202 return (breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
7205 && breakpoint_address_match_range (bl
->pspace
->aspace
,
7206 bl
->address
, bl
->length
,
7210 /* Returns true if the [ADDR,ADDR+LEN) range in ASPACE overlaps
7211 breakpoint BL. BL may be a ranged breakpoint. In most targets, a
7212 match happens only if ASPACE matches the breakpoint's address
7213 space. On targets that have global breakpoints, the address space
7214 doesn't really matter. */
7217 breakpoint_location_address_range_overlap (struct bp_location
*bl
,
7218 struct address_space
*aspace
,
7219 CORE_ADDR addr
, int len
)
7221 if (gdbarch_has_global_breakpoints (target_gdbarch ())
7222 || bl
->pspace
->aspace
== aspace
)
7224 int bl_len
= bl
->length
!= 0 ? bl
->length
: 1;
7226 if (mem_ranges_overlap (addr
, len
, bl
->address
, bl_len
))
7232 /* If LOC1 and LOC2's owners are not tracepoints, returns false directly.
7233 Then, if LOC1 and LOC2 represent the same tracepoint location, returns
7234 true, otherwise returns false. */
7237 tracepoint_locations_match (struct bp_location
*loc1
,
7238 struct bp_location
*loc2
)
7240 if (is_tracepoint (loc1
->owner
) && is_tracepoint (loc2
->owner
))
7241 /* Since tracepoint locations are never duplicated with others', tracepoint
7242 locations at the same address of different tracepoints are regarded as
7243 different locations. */
7244 return (loc1
->address
== loc2
->address
&& loc1
->owner
== loc2
->owner
);
7249 /* Assuming LOC1 and LOC2's types' have meaningful target addresses
7250 (breakpoint_address_is_meaningful), returns true if LOC1 and LOC2
7251 represent the same location. */
7254 breakpoint_locations_match (struct bp_location
*loc1
,
7255 struct bp_location
*loc2
)
7257 int hw_point1
, hw_point2
;
7259 /* Both of them must not be in moribund_locations. */
7260 gdb_assert (loc1
->owner
!= NULL
);
7261 gdb_assert (loc2
->owner
!= NULL
);
7263 hw_point1
= is_hardware_watchpoint (loc1
->owner
);
7264 hw_point2
= is_hardware_watchpoint (loc2
->owner
);
7266 if (hw_point1
!= hw_point2
)
7269 return watchpoint_locations_match (loc1
, loc2
);
7270 else if (is_tracepoint (loc1
->owner
) || is_tracepoint (loc2
->owner
))
7271 return tracepoint_locations_match (loc1
, loc2
);
7273 /* We compare bp_location.length in order to cover ranged breakpoints. */
7274 return (breakpoint_address_match (loc1
->pspace
->aspace
, loc1
->address
,
7275 loc2
->pspace
->aspace
, loc2
->address
)
7276 && loc1
->length
== loc2
->length
);
7280 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
7281 int bnum
, int have_bnum
)
7283 /* The longest string possibly returned by hex_string_custom
7284 is 50 chars. These must be at least that big for safety. */
7288 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
7289 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
7291 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
7292 bnum
, astr1
, astr2
);
7294 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
7297 /* Adjust a breakpoint's address to account for architectural
7298 constraints on breakpoint placement. Return the adjusted address.
7299 Note: Very few targets require this kind of adjustment. For most
7300 targets, this function is simply the identity function. */
7303 adjust_breakpoint_address (struct gdbarch
*gdbarch
,
7304 CORE_ADDR bpaddr
, enum bptype bptype
)
7306 if (!gdbarch_adjust_breakpoint_address_p (gdbarch
))
7308 /* Very few targets need any kind of breakpoint adjustment. */
7311 else if (bptype
== bp_watchpoint
7312 || bptype
== bp_hardware_watchpoint
7313 || bptype
== bp_read_watchpoint
7314 || bptype
== bp_access_watchpoint
7315 || bptype
== bp_catchpoint
)
7317 /* Watchpoints and the various bp_catch_* eventpoints should not
7318 have their addresses modified. */
7321 else if (bptype
== bp_single_step
)
7323 /* Single-step breakpoints should not have their addresses
7324 modified. If there's any architectural constrain that
7325 applies to this address, then it should have already been
7326 taken into account when the breakpoint was created in the
7327 first place. If we didn't do this, stepping through e.g.,
7328 Thumb-2 IT blocks would break. */
7333 CORE_ADDR adjusted_bpaddr
;
7335 /* Some targets have architectural constraints on the placement
7336 of breakpoint instructions. Obtain the adjusted address. */
7337 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (gdbarch
, bpaddr
);
7339 /* An adjusted breakpoint address can significantly alter
7340 a user's expectations. Print a warning if an adjustment
7342 if (adjusted_bpaddr
!= bpaddr
)
7343 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
7345 return adjusted_bpaddr
;
7350 init_bp_location (struct bp_location
*loc
, const struct bp_location_ops
*ops
,
7351 struct breakpoint
*owner
)
7353 memset (loc
, 0, sizeof (*loc
));
7355 gdb_assert (ops
!= NULL
);
7360 loc
->cond_bytecode
= NULL
;
7361 loc
->shlib_disabled
= 0;
7364 switch (owner
->type
)
7367 case bp_single_step
:
7371 case bp_longjmp_resume
:
7372 case bp_longjmp_call_dummy
:
7374 case bp_exception_resume
:
7375 case bp_step_resume
:
7376 case bp_hp_step_resume
:
7377 case bp_watchpoint_scope
:
7379 case bp_std_terminate
:
7380 case bp_shlib_event
:
7381 case bp_thread_event
:
7382 case bp_overlay_event
:
7384 case bp_longjmp_master
:
7385 case bp_std_terminate_master
:
7386 case bp_exception_master
:
7387 case bp_gnu_ifunc_resolver
:
7388 case bp_gnu_ifunc_resolver_return
:
7390 loc
->loc_type
= bp_loc_software_breakpoint
;
7391 mark_breakpoint_location_modified (loc
);
7393 case bp_hardware_breakpoint
:
7394 loc
->loc_type
= bp_loc_hardware_breakpoint
;
7395 mark_breakpoint_location_modified (loc
);
7397 case bp_hardware_watchpoint
:
7398 case bp_read_watchpoint
:
7399 case bp_access_watchpoint
:
7400 loc
->loc_type
= bp_loc_hardware_watchpoint
;
7405 case bp_fast_tracepoint
:
7406 case bp_static_tracepoint
:
7407 loc
->loc_type
= bp_loc_other
;
7410 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
7416 /* Allocate a struct bp_location. */
7418 static struct bp_location
*
7419 allocate_bp_location (struct breakpoint
*bpt
)
7421 return bpt
->ops
->allocate_location (bpt
);
7425 free_bp_location (struct bp_location
*loc
)
7427 loc
->ops
->dtor (loc
);
7431 /* Increment reference count. */
7434 incref_bp_location (struct bp_location
*bl
)
7439 /* Decrement reference count. If the reference count reaches 0,
7440 destroy the bp_location. Sets *BLP to NULL. */
7443 decref_bp_location (struct bp_location
**blp
)
7445 gdb_assert ((*blp
)->refc
> 0);
7447 if (--(*blp
)->refc
== 0)
7448 free_bp_location (*blp
);
7452 /* Add breakpoint B at the end of the global breakpoint chain. */
7455 add_to_breakpoint_chain (struct breakpoint
*b
)
7457 struct breakpoint
*b1
;
7459 /* Add this breakpoint to the end of the chain so that a list of
7460 breakpoints will come out in order of increasing numbers. */
7462 b1
= breakpoint_chain
;
7464 breakpoint_chain
= b
;
7473 /* Initializes breakpoint B with type BPTYPE and no locations yet. */
7476 init_raw_breakpoint_without_location (struct breakpoint
*b
,
7477 struct gdbarch
*gdbarch
,
7479 const struct breakpoint_ops
*ops
)
7481 memset (b
, 0, sizeof (*b
));
7483 gdb_assert (ops
!= NULL
);
7487 b
->gdbarch
= gdbarch
;
7488 b
->language
= current_language
->la_language
;
7489 b
->input_radix
= input_radix
;
7491 b
->enable_state
= bp_enabled
;
7494 b
->ignore_count
= 0;
7496 b
->frame_id
= null_frame_id
;
7497 b
->condition_not_parsed
= 0;
7498 b
->py_bp_object
= NULL
;
7499 b
->related_breakpoint
= b
;
7503 /* Helper to set_raw_breakpoint below. Creates a breakpoint
7504 that has type BPTYPE and has no locations as yet. */
7506 static struct breakpoint
*
7507 set_raw_breakpoint_without_location (struct gdbarch
*gdbarch
,
7509 const struct breakpoint_ops
*ops
)
7511 struct breakpoint
*b
= XNEW (struct breakpoint
);
7513 init_raw_breakpoint_without_location (b
, gdbarch
, bptype
, ops
);
7514 add_to_breakpoint_chain (b
);
7518 /* Initialize loc->function_name. EXPLICIT_LOC says no indirect function
7519 resolutions should be made as the user specified the location explicitly
7523 set_breakpoint_location_function (struct bp_location
*loc
, int explicit_loc
)
7525 gdb_assert (loc
->owner
!= NULL
);
7527 if (loc
->owner
->type
== bp_breakpoint
7528 || loc
->owner
->type
== bp_hardware_breakpoint
7529 || is_tracepoint (loc
->owner
))
7532 const char *function_name
;
7533 CORE_ADDR func_addr
;
7535 find_pc_partial_function_gnu_ifunc (loc
->address
, &function_name
,
7536 &func_addr
, NULL
, &is_gnu_ifunc
);
7538 if (is_gnu_ifunc
&& !explicit_loc
)
7540 struct breakpoint
*b
= loc
->owner
;
7542 gdb_assert (loc
->pspace
== current_program_space
);
7543 if (gnu_ifunc_resolve_name (function_name
,
7544 &loc
->requested_address
))
7546 /* Recalculate ADDRESS based on new REQUESTED_ADDRESS. */
7547 loc
->address
= adjust_breakpoint_address (loc
->gdbarch
,
7548 loc
->requested_address
,
7551 else if (b
->type
== bp_breakpoint
&& b
->loc
== loc
7552 && loc
->next
== NULL
&& b
->related_breakpoint
== b
)
7554 /* Create only the whole new breakpoint of this type but do not
7555 mess more complicated breakpoints with multiple locations. */
7556 b
->type
= bp_gnu_ifunc_resolver
;
7557 /* Remember the resolver's address for use by the return
7559 loc
->related_address
= func_addr
;
7564 loc
->function_name
= xstrdup (function_name
);
7568 /* Attempt to determine architecture of location identified by SAL. */
7570 get_sal_arch (struct symtab_and_line sal
)
7573 return get_objfile_arch (sal
.section
->objfile
);
7575 return get_objfile_arch (SYMTAB_OBJFILE (sal
.symtab
));
7580 /* Low level routine for partially initializing a breakpoint of type
7581 BPTYPE. The newly created breakpoint's address, section, source
7582 file name, and line number are provided by SAL.
7584 It is expected that the caller will complete the initialization of
7585 the newly created breakpoint struct as well as output any status
7586 information regarding the creation of a new breakpoint. */
7589 init_raw_breakpoint (struct breakpoint
*b
, struct gdbarch
*gdbarch
,
7590 struct symtab_and_line sal
, enum bptype bptype
,
7591 const struct breakpoint_ops
*ops
)
7593 init_raw_breakpoint_without_location (b
, gdbarch
, bptype
, ops
);
7595 add_location_to_breakpoint (b
, &sal
);
7597 if (bptype
!= bp_catchpoint
)
7598 gdb_assert (sal
.pspace
!= NULL
);
7600 /* Store the program space that was used to set the breakpoint,
7601 except for ordinary breakpoints, which are independent of the
7603 if (bptype
!= bp_breakpoint
&& bptype
!= bp_hardware_breakpoint
)
7604 b
->pspace
= sal
.pspace
;
7607 /* set_raw_breakpoint is a low level routine for allocating and
7608 partially initializing a breakpoint of type BPTYPE. The newly
7609 created breakpoint's address, section, source file name, and line
7610 number are provided by SAL. The newly created and partially
7611 initialized breakpoint is added to the breakpoint chain and
7612 is also returned as the value of this function.
7614 It is expected that the caller will complete the initialization of
7615 the newly created breakpoint struct as well as output any status
7616 information regarding the creation of a new breakpoint. In
7617 particular, set_raw_breakpoint does NOT set the breakpoint
7618 number! Care should be taken to not allow an error to occur
7619 prior to completing the initialization of the breakpoint. If this
7620 should happen, a bogus breakpoint will be left on the chain. */
7623 set_raw_breakpoint (struct gdbarch
*gdbarch
,
7624 struct symtab_and_line sal
, enum bptype bptype
,
7625 const struct breakpoint_ops
*ops
)
7627 struct breakpoint
*b
= XNEW (struct breakpoint
);
7629 init_raw_breakpoint (b
, gdbarch
, sal
, bptype
, ops
);
7630 add_to_breakpoint_chain (b
);
7634 /* Call this routine when stepping and nexting to enable a breakpoint
7635 if we do a longjmp() or 'throw' in TP. FRAME is the frame which
7636 initiated the operation. */
7639 set_longjmp_breakpoint (struct thread_info
*tp
, struct frame_id frame
)
7641 struct breakpoint
*b
, *b_tmp
;
7642 int thread
= tp
->global_num
;
7644 /* To avoid having to rescan all objfile symbols at every step,
7645 we maintain a list of continually-inserted but always disabled
7646 longjmp "master" breakpoints. Here, we simply create momentary
7647 clones of those and enable them for the requested thread. */
7648 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7649 if (b
->pspace
== current_program_space
7650 && (b
->type
== bp_longjmp_master
7651 || b
->type
== bp_exception_master
))
7653 enum bptype type
= b
->type
== bp_longjmp_master
? bp_longjmp
: bp_exception
;
7654 struct breakpoint
*clone
;
7656 /* longjmp_breakpoint_ops ensures INITIATING_FRAME is cleared again
7657 after their removal. */
7658 clone
= momentary_breakpoint_from_master (b
, type
,
7659 &longjmp_breakpoint_ops
, 1);
7660 clone
->thread
= thread
;
7663 tp
->initiating_frame
= frame
;
7666 /* Delete all longjmp breakpoints from THREAD. */
7668 delete_longjmp_breakpoint (int thread
)
7670 struct breakpoint
*b
, *b_tmp
;
7672 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7673 if (b
->type
== bp_longjmp
|| b
->type
== bp_exception
)
7675 if (b
->thread
== thread
)
7676 delete_breakpoint (b
);
7681 delete_longjmp_breakpoint_at_next_stop (int thread
)
7683 struct breakpoint
*b
, *b_tmp
;
7685 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7686 if (b
->type
== bp_longjmp
|| b
->type
== bp_exception
)
7688 if (b
->thread
== thread
)
7689 b
->disposition
= disp_del_at_next_stop
;
7693 /* Place breakpoints of type bp_longjmp_call_dummy to catch longjmp for
7694 INFERIOR_PTID thread. Chain them all by RELATED_BREAKPOINT and return
7695 pointer to any of them. Return NULL if this system cannot place longjmp
7699 set_longjmp_breakpoint_for_call_dummy (void)
7701 struct breakpoint
*b
, *retval
= NULL
;
7704 if (b
->pspace
== current_program_space
&& b
->type
== bp_longjmp_master
)
7706 struct breakpoint
*new_b
;
7708 new_b
= momentary_breakpoint_from_master (b
, bp_longjmp_call_dummy
,
7709 &momentary_breakpoint_ops
,
7711 new_b
->thread
= ptid_to_global_thread_id (inferior_ptid
);
7713 /* Link NEW_B into the chain of RETVAL breakpoints. */
7715 gdb_assert (new_b
->related_breakpoint
== new_b
);
7718 new_b
->related_breakpoint
= retval
;
7719 while (retval
->related_breakpoint
!= new_b
->related_breakpoint
)
7720 retval
= retval
->related_breakpoint
;
7721 retval
->related_breakpoint
= new_b
;
7727 /* Verify all existing dummy frames and their associated breakpoints for
7728 TP. Remove those which can no longer be found in the current frame
7731 You should call this function only at places where it is safe to currently
7732 unwind the whole stack. Failed stack unwind would discard live dummy
7736 check_longjmp_breakpoint_for_call_dummy (struct thread_info
*tp
)
7738 struct breakpoint
*b
, *b_tmp
;
7740 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7741 if (b
->type
== bp_longjmp_call_dummy
&& b
->thread
== tp
->global_num
)
7743 struct breakpoint
*dummy_b
= b
->related_breakpoint
;
7745 while (dummy_b
!= b
&& dummy_b
->type
!= bp_call_dummy
)
7746 dummy_b
= dummy_b
->related_breakpoint
;
7747 if (dummy_b
->type
!= bp_call_dummy
7748 || frame_find_by_id (dummy_b
->frame_id
) != NULL
)
7751 dummy_frame_discard (dummy_b
->frame_id
, tp
->ptid
);
7753 while (b
->related_breakpoint
!= b
)
7755 if (b_tmp
== b
->related_breakpoint
)
7756 b_tmp
= b
->related_breakpoint
->next
;
7757 delete_breakpoint (b
->related_breakpoint
);
7759 delete_breakpoint (b
);
7764 enable_overlay_breakpoints (void)
7766 struct breakpoint
*b
;
7769 if (b
->type
== bp_overlay_event
)
7771 b
->enable_state
= bp_enabled
;
7772 update_global_location_list (UGLL_MAY_INSERT
);
7773 overlay_events_enabled
= 1;
7778 disable_overlay_breakpoints (void)
7780 struct breakpoint
*b
;
7783 if (b
->type
== bp_overlay_event
)
7785 b
->enable_state
= bp_disabled
;
7786 update_global_location_list (UGLL_DONT_INSERT
);
7787 overlay_events_enabled
= 0;
7791 /* Set an active std::terminate breakpoint for each std::terminate
7792 master breakpoint. */
7794 set_std_terminate_breakpoint (void)
7796 struct breakpoint
*b
, *b_tmp
;
7798 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7799 if (b
->pspace
== current_program_space
7800 && b
->type
== bp_std_terminate_master
)
7802 momentary_breakpoint_from_master (b
, bp_std_terminate
,
7803 &momentary_breakpoint_ops
, 1);
7807 /* Delete all the std::terminate breakpoints. */
7809 delete_std_terminate_breakpoint (void)
7811 struct breakpoint
*b
, *b_tmp
;
7813 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7814 if (b
->type
== bp_std_terminate
)
7815 delete_breakpoint (b
);
7819 create_thread_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7821 struct breakpoint
*b
;
7823 b
= create_internal_breakpoint (gdbarch
, address
, bp_thread_event
,
7824 &internal_breakpoint_ops
);
7826 b
->enable_state
= bp_enabled
;
7827 /* location has to be used or breakpoint_re_set will delete me. */
7828 b
->location
= new_address_location (b
->loc
->address
, NULL
, 0);
7830 update_global_location_list_nothrow (UGLL_MAY_INSERT
);
7835 struct lang_and_radix
7841 /* Create a breakpoint for JIT code registration and unregistration. */
7844 create_jit_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7846 return create_internal_breakpoint (gdbarch
, address
, bp_jit_event
,
7847 &internal_breakpoint_ops
);
7850 /* Remove JIT code registration and unregistration breakpoint(s). */
7853 remove_jit_event_breakpoints (void)
7855 struct breakpoint
*b
, *b_tmp
;
7857 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7858 if (b
->type
== bp_jit_event
7859 && b
->loc
->pspace
== current_program_space
)
7860 delete_breakpoint (b
);
7864 remove_solib_event_breakpoints (void)
7866 struct breakpoint
*b
, *b_tmp
;
7868 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7869 if (b
->type
== bp_shlib_event
7870 && b
->loc
->pspace
== current_program_space
)
7871 delete_breakpoint (b
);
7874 /* See breakpoint.h. */
7877 remove_solib_event_breakpoints_at_next_stop (void)
7879 struct breakpoint
*b
, *b_tmp
;
7881 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7882 if (b
->type
== bp_shlib_event
7883 && b
->loc
->pspace
== current_program_space
)
7884 b
->disposition
= disp_del_at_next_stop
;
7887 /* Helper for create_solib_event_breakpoint /
7888 create_and_insert_solib_event_breakpoint. Allows specifying which
7889 INSERT_MODE to pass through to update_global_location_list. */
7891 static struct breakpoint
*
7892 create_solib_event_breakpoint_1 (struct gdbarch
*gdbarch
, CORE_ADDR address
,
7893 enum ugll_insert_mode insert_mode
)
7895 struct breakpoint
*b
;
7897 b
= create_internal_breakpoint (gdbarch
, address
, bp_shlib_event
,
7898 &internal_breakpoint_ops
);
7899 update_global_location_list_nothrow (insert_mode
);
7904 create_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7906 return create_solib_event_breakpoint_1 (gdbarch
, address
, UGLL_MAY_INSERT
);
7909 /* See breakpoint.h. */
7912 create_and_insert_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7914 struct breakpoint
*b
;
7916 /* Explicitly tell update_global_location_list to insert
7918 b
= create_solib_event_breakpoint_1 (gdbarch
, address
, UGLL_INSERT
);
7919 if (!b
->loc
->inserted
)
7921 delete_breakpoint (b
);
7927 /* Disable any breakpoints that are on code in shared libraries. Only
7928 apply to enabled breakpoints, disabled ones can just stay disabled. */
7931 disable_breakpoints_in_shlibs (void)
7933 struct bp_location
*loc
, **locp_tmp
;
7935 ALL_BP_LOCATIONS (loc
, locp_tmp
)
7937 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7938 struct breakpoint
*b
= loc
->owner
;
7940 /* We apply the check to all breakpoints, including disabled for
7941 those with loc->duplicate set. This is so that when breakpoint
7942 becomes enabled, or the duplicate is removed, gdb will try to
7943 insert all breakpoints. If we don't set shlib_disabled here,
7944 we'll try to insert those breakpoints and fail. */
7945 if (((b
->type
== bp_breakpoint
)
7946 || (b
->type
== bp_jit_event
)
7947 || (b
->type
== bp_hardware_breakpoint
)
7948 || (is_tracepoint (b
)))
7949 && loc
->pspace
== current_program_space
7950 && !loc
->shlib_disabled
7951 && solib_name_from_address (loc
->pspace
, loc
->address
)
7954 loc
->shlib_disabled
= 1;
7959 /* Disable any breakpoints and tracepoints that are in SOLIB upon
7960 notification of unloaded_shlib. Only apply to enabled breakpoints,
7961 disabled ones can just stay disabled. */
7964 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
7966 struct bp_location
*loc
, **locp_tmp
;
7967 int disabled_shlib_breaks
= 0;
7969 /* SunOS a.out shared libraries are always mapped, so do not
7970 disable breakpoints; they will only be reported as unloaded
7971 through clear_solib when GDB discards its shared library
7972 list. See clear_solib for more information. */
7973 if (exec_bfd
!= NULL
7974 && bfd_get_flavour (exec_bfd
) == bfd_target_aout_flavour
)
7977 ALL_BP_LOCATIONS (loc
, locp_tmp
)
7979 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7980 struct breakpoint
*b
= loc
->owner
;
7982 if (solib
->pspace
== loc
->pspace
7983 && !loc
->shlib_disabled
7984 && (((b
->type
== bp_breakpoint
7985 || b
->type
== bp_jit_event
7986 || b
->type
== bp_hardware_breakpoint
)
7987 && (loc
->loc_type
== bp_loc_hardware_breakpoint
7988 || loc
->loc_type
== bp_loc_software_breakpoint
))
7989 || is_tracepoint (b
))
7990 && solib_contains_address_p (solib
, loc
->address
))
7992 loc
->shlib_disabled
= 1;
7993 /* At this point, we cannot rely on remove_breakpoint
7994 succeeding so we must mark the breakpoint as not inserted
7995 to prevent future errors occurring in remove_breakpoints. */
7998 /* This may cause duplicate notifications for the same breakpoint. */
7999 observer_notify_breakpoint_modified (b
);
8001 if (!disabled_shlib_breaks
)
8003 target_terminal_ours_for_output ();
8004 warning (_("Temporarily disabling breakpoints "
8005 "for unloaded shared library \"%s\""),
8008 disabled_shlib_breaks
= 1;
8013 /* Disable any breakpoints and tracepoints in OBJFILE upon
8014 notification of free_objfile. Only apply to enabled breakpoints,
8015 disabled ones can just stay disabled. */
8018 disable_breakpoints_in_freed_objfile (struct objfile
*objfile
)
8020 struct breakpoint
*b
;
8022 if (objfile
== NULL
)
8025 /* OBJF_SHARED|OBJF_USERLOADED objfiles are dynamic modules manually
8026 managed by the user with add-symbol-file/remove-symbol-file.
8027 Similarly to how breakpoints in shared libraries are handled in
8028 response to "nosharedlibrary", mark breakpoints in such modules
8029 shlib_disabled so they end up uninserted on the next global
8030 location list update. Shared libraries not loaded by the user
8031 aren't handled here -- they're already handled in
8032 disable_breakpoints_in_unloaded_shlib, called by solib.c's
8033 solib_unloaded observer. We skip objfiles that are not
8034 OBJF_SHARED as those aren't considered dynamic objects (e.g. the
8036 if ((objfile
->flags
& OBJF_SHARED
) == 0
8037 || (objfile
->flags
& OBJF_USERLOADED
) == 0)
8042 struct bp_location
*loc
;
8043 int bp_modified
= 0;
8045 if (!is_breakpoint (b
) && !is_tracepoint (b
))
8048 for (loc
= b
->loc
; loc
!= NULL
; loc
= loc
->next
)
8050 CORE_ADDR loc_addr
= loc
->address
;
8052 if (loc
->loc_type
!= bp_loc_hardware_breakpoint
8053 && loc
->loc_type
!= bp_loc_software_breakpoint
)
8056 if (loc
->shlib_disabled
!= 0)
8059 if (objfile
->pspace
!= loc
->pspace
)
8062 if (loc
->loc_type
!= bp_loc_hardware_breakpoint
8063 && loc
->loc_type
!= bp_loc_software_breakpoint
)
8066 if (is_addr_in_objfile (loc_addr
, objfile
))
8068 loc
->shlib_disabled
= 1;
8069 /* At this point, we don't know whether the object was
8070 unmapped from the inferior or not, so leave the
8071 inserted flag alone. We'll handle failure to
8072 uninsert quietly, in case the object was indeed
8075 mark_breakpoint_location_modified (loc
);
8082 observer_notify_breakpoint_modified (b
);
8086 /* FORK & VFORK catchpoints. */
8088 /* An instance of this type is used to represent a fork or vfork
8089 catchpoint. It includes a "struct breakpoint" as a kind of base
8090 class; users downcast to "struct breakpoint *" when needed. A
8091 breakpoint is really of this type iff its ops pointer points to
8092 CATCH_FORK_BREAKPOINT_OPS. */
8094 struct fork_catchpoint
8096 /* The base class. */
8097 struct breakpoint base
;
8099 /* Process id of a child process whose forking triggered this
8100 catchpoint. This field is only valid immediately after this
8101 catchpoint has triggered. */
8102 ptid_t forked_inferior_pid
;
8105 /* Implement the "insert" breakpoint_ops method for fork
8109 insert_catch_fork (struct bp_location
*bl
)
8111 return target_insert_fork_catchpoint (ptid_get_pid (inferior_ptid
));
8114 /* Implement the "remove" breakpoint_ops method for fork
8118 remove_catch_fork (struct bp_location
*bl
)
8120 return target_remove_fork_catchpoint (ptid_get_pid (inferior_ptid
));
8123 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
8127 breakpoint_hit_catch_fork (const struct bp_location
*bl
,
8128 struct address_space
*aspace
, CORE_ADDR bp_addr
,
8129 const struct target_waitstatus
*ws
)
8131 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bl
->owner
;
8133 if (ws
->kind
!= TARGET_WAITKIND_FORKED
)
8136 c
->forked_inferior_pid
= ws
->value
.related_pid
;
8140 /* Implement the "print_it" breakpoint_ops method for fork
8143 static enum print_stop_action
8144 print_it_catch_fork (bpstat bs
)
8146 struct ui_out
*uiout
= current_uiout
;
8147 struct breakpoint
*b
= bs
->breakpoint_at
;
8148 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bs
->breakpoint_at
;
8150 annotate_catchpoint (b
->number
);
8151 maybe_print_thread_hit_breakpoint (uiout
);
8152 if (b
->disposition
== disp_del
)
8153 ui_out_text (uiout
, "Temporary catchpoint ");
8155 ui_out_text (uiout
, "Catchpoint ");
8156 if (ui_out_is_mi_like_p (uiout
))
8158 ui_out_field_string (uiout
, "reason",
8159 async_reason_lookup (EXEC_ASYNC_FORK
));
8160 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
8162 ui_out_field_int (uiout
, "bkptno", b
->number
);
8163 ui_out_text (uiout
, " (forked process ");
8164 ui_out_field_int (uiout
, "newpid", ptid_get_pid (c
->forked_inferior_pid
));
8165 ui_out_text (uiout
, "), ");
8166 return PRINT_SRC_AND_LOC
;
8169 /* Implement the "print_one" breakpoint_ops method for fork
8173 print_one_catch_fork (struct breakpoint
*b
, struct bp_location
**last_loc
)
8175 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
8176 struct value_print_options opts
;
8177 struct ui_out
*uiout
= current_uiout
;
8179 get_user_print_options (&opts
);
8181 /* Field 4, the address, is omitted (which makes the columns not
8182 line up too nicely with the headers, but the effect is relatively
8184 if (opts
.addressprint
)
8185 ui_out_field_skip (uiout
, "addr");
8187 ui_out_text (uiout
, "fork");
8188 if (!ptid_equal (c
->forked_inferior_pid
, null_ptid
))
8190 ui_out_text (uiout
, ", process ");
8191 ui_out_field_int (uiout
, "what",
8192 ptid_get_pid (c
->forked_inferior_pid
));
8193 ui_out_spaces (uiout
, 1);
8196 if (ui_out_is_mi_like_p (uiout
))
8197 ui_out_field_string (uiout
, "catch-type", "fork");
8200 /* Implement the "print_mention" breakpoint_ops method for fork
8204 print_mention_catch_fork (struct breakpoint
*b
)
8206 printf_filtered (_("Catchpoint %d (fork)"), b
->number
);
8209 /* Implement the "print_recreate" breakpoint_ops method for fork
8213 print_recreate_catch_fork (struct breakpoint
*b
, struct ui_file
*fp
)
8215 fprintf_unfiltered (fp
, "catch fork");
8216 print_recreate_thread (b
, fp
);
8219 /* The breakpoint_ops structure to be used in fork catchpoints. */
8221 static struct breakpoint_ops catch_fork_breakpoint_ops
;
8223 /* Implement the "insert" breakpoint_ops method for vfork
8227 insert_catch_vfork (struct bp_location
*bl
)
8229 return target_insert_vfork_catchpoint (ptid_get_pid (inferior_ptid
));
8232 /* Implement the "remove" breakpoint_ops method for vfork
8236 remove_catch_vfork (struct bp_location
*bl
)
8238 return target_remove_vfork_catchpoint (ptid_get_pid (inferior_ptid
));
8241 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
8245 breakpoint_hit_catch_vfork (const struct bp_location
*bl
,
8246 struct address_space
*aspace
, CORE_ADDR bp_addr
,
8247 const struct target_waitstatus
*ws
)
8249 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bl
->owner
;
8251 if (ws
->kind
!= TARGET_WAITKIND_VFORKED
)
8254 c
->forked_inferior_pid
= ws
->value
.related_pid
;
8258 /* Implement the "print_it" breakpoint_ops method for vfork
8261 static enum print_stop_action
8262 print_it_catch_vfork (bpstat bs
)
8264 struct ui_out
*uiout
= current_uiout
;
8265 struct breakpoint
*b
= bs
->breakpoint_at
;
8266 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
8268 annotate_catchpoint (b
->number
);
8269 maybe_print_thread_hit_breakpoint (uiout
);
8270 if (b
->disposition
== disp_del
)
8271 ui_out_text (uiout
, "Temporary catchpoint ");
8273 ui_out_text (uiout
, "Catchpoint ");
8274 if (ui_out_is_mi_like_p (uiout
))
8276 ui_out_field_string (uiout
, "reason",
8277 async_reason_lookup (EXEC_ASYNC_VFORK
));
8278 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
8280 ui_out_field_int (uiout
, "bkptno", b
->number
);
8281 ui_out_text (uiout
, " (vforked process ");
8282 ui_out_field_int (uiout
, "newpid", ptid_get_pid (c
->forked_inferior_pid
));
8283 ui_out_text (uiout
, "), ");
8284 return PRINT_SRC_AND_LOC
;
8287 /* Implement the "print_one" breakpoint_ops method for vfork
8291 print_one_catch_vfork (struct breakpoint
*b
, struct bp_location
**last_loc
)
8293 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
8294 struct value_print_options opts
;
8295 struct ui_out
*uiout
= current_uiout
;
8297 get_user_print_options (&opts
);
8298 /* Field 4, the address, is omitted (which makes the columns not
8299 line up too nicely with the headers, but the effect is relatively
8301 if (opts
.addressprint
)
8302 ui_out_field_skip (uiout
, "addr");
8304 ui_out_text (uiout
, "vfork");
8305 if (!ptid_equal (c
->forked_inferior_pid
, null_ptid
))
8307 ui_out_text (uiout
, ", process ");
8308 ui_out_field_int (uiout
, "what",
8309 ptid_get_pid (c
->forked_inferior_pid
));
8310 ui_out_spaces (uiout
, 1);
8313 if (ui_out_is_mi_like_p (uiout
))
8314 ui_out_field_string (uiout
, "catch-type", "vfork");
8317 /* Implement the "print_mention" breakpoint_ops method for vfork
8321 print_mention_catch_vfork (struct breakpoint
*b
)
8323 printf_filtered (_("Catchpoint %d (vfork)"), b
->number
);
8326 /* Implement the "print_recreate" breakpoint_ops method for vfork
8330 print_recreate_catch_vfork (struct breakpoint
*b
, struct ui_file
*fp
)
8332 fprintf_unfiltered (fp
, "catch vfork");
8333 print_recreate_thread (b
, fp
);
8336 /* The breakpoint_ops structure to be used in vfork catchpoints. */
8338 static struct breakpoint_ops catch_vfork_breakpoint_ops
;
8340 /* An instance of this type is used to represent an solib catchpoint.
8341 It includes a "struct breakpoint" as a kind of base class; users
8342 downcast to "struct breakpoint *" when needed. A breakpoint is
8343 really of this type iff its ops pointer points to
8344 CATCH_SOLIB_BREAKPOINT_OPS. */
8346 struct solib_catchpoint
8348 /* The base class. */
8349 struct breakpoint base
;
8351 /* True for "catch load", false for "catch unload". */
8352 unsigned char is_load
;
8354 /* Regular expression to match, if any. COMPILED is only valid when
8355 REGEX is non-NULL. */
8361 dtor_catch_solib (struct breakpoint
*b
)
8363 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8366 regfree (&self
->compiled
);
8367 xfree (self
->regex
);
8369 base_breakpoint_ops
.dtor (b
);
8373 insert_catch_solib (struct bp_location
*ignore
)
8379 remove_catch_solib (struct bp_location
*ignore
)
8385 breakpoint_hit_catch_solib (const struct bp_location
*bl
,
8386 struct address_space
*aspace
,
8388 const struct target_waitstatus
*ws
)
8390 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) bl
->owner
;
8391 struct breakpoint
*other
;
8393 if (ws
->kind
== TARGET_WAITKIND_LOADED
)
8396 ALL_BREAKPOINTS (other
)
8398 struct bp_location
*other_bl
;
8400 if (other
== bl
->owner
)
8403 if (other
->type
!= bp_shlib_event
)
8406 if (self
->base
.pspace
!= NULL
&& other
->pspace
!= self
->base
.pspace
)
8409 for (other_bl
= other
->loc
; other_bl
!= NULL
; other_bl
= other_bl
->next
)
8411 if (other
->ops
->breakpoint_hit (other_bl
, aspace
, bp_addr
, ws
))
8420 check_status_catch_solib (struct bpstats
*bs
)
8422 struct solib_catchpoint
*self
8423 = (struct solib_catchpoint
*) bs
->breakpoint_at
;
8428 struct so_list
*iter
;
8431 VEC_iterate (so_list_ptr
, current_program_space
->added_solibs
,
8436 || regexec (&self
->compiled
, iter
->so_name
, 0, NULL
, 0) == 0)
8445 VEC_iterate (char_ptr
, current_program_space
->deleted_solibs
,
8450 || regexec (&self
->compiled
, iter
, 0, NULL
, 0) == 0)
8456 bs
->print_it
= print_it_noop
;
8459 static enum print_stop_action
8460 print_it_catch_solib (bpstat bs
)
8462 struct breakpoint
*b
= bs
->breakpoint_at
;
8463 struct ui_out
*uiout
= current_uiout
;
8465 annotate_catchpoint (b
->number
);
8466 maybe_print_thread_hit_breakpoint (uiout
);
8467 if (b
->disposition
== disp_del
)
8468 ui_out_text (uiout
, "Temporary catchpoint ");
8470 ui_out_text (uiout
, "Catchpoint ");
8471 ui_out_field_int (uiout
, "bkptno", b
->number
);
8472 ui_out_text (uiout
, "\n");
8473 if (ui_out_is_mi_like_p (uiout
))
8474 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
8475 print_solib_event (1);
8476 return PRINT_SRC_AND_LOC
;
8480 print_one_catch_solib (struct breakpoint
*b
, struct bp_location
**locs
)
8482 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8483 struct value_print_options opts
;
8484 struct ui_out
*uiout
= current_uiout
;
8487 get_user_print_options (&opts
);
8488 /* Field 4, the address, is omitted (which makes the columns not
8489 line up too nicely with the headers, but the effect is relatively
8491 if (opts
.addressprint
)
8494 ui_out_field_skip (uiout
, "addr");
8501 msg
= xstrprintf (_("load of library matching %s"), self
->regex
);
8503 msg
= xstrdup (_("load of library"));
8508 msg
= xstrprintf (_("unload of library matching %s"), self
->regex
);
8510 msg
= xstrdup (_("unload of library"));
8512 ui_out_field_string (uiout
, "what", msg
);
8515 if (ui_out_is_mi_like_p (uiout
))
8516 ui_out_field_string (uiout
, "catch-type",
8517 self
->is_load
? "load" : "unload");
8521 print_mention_catch_solib (struct breakpoint
*b
)
8523 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8525 printf_filtered (_("Catchpoint %d (%s)"), b
->number
,
8526 self
->is_load
? "load" : "unload");
8530 print_recreate_catch_solib (struct breakpoint
*b
, struct ui_file
*fp
)
8532 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8534 fprintf_unfiltered (fp
, "%s %s",
8535 b
->disposition
== disp_del
? "tcatch" : "catch",
8536 self
->is_load
? "load" : "unload");
8538 fprintf_unfiltered (fp
, " %s", self
->regex
);
8539 fprintf_unfiltered (fp
, "\n");
8542 static struct breakpoint_ops catch_solib_breakpoint_ops
;
8544 /* Shared helper function (MI and CLI) for creating and installing
8545 a shared object event catchpoint. If IS_LOAD is non-zero then
8546 the events to be caught are load events, otherwise they are
8547 unload events. If IS_TEMP is non-zero the catchpoint is a
8548 temporary one. If ENABLED is non-zero the catchpoint is
8549 created in an enabled state. */
8552 add_solib_catchpoint (char *arg
, int is_load
, int is_temp
, int enabled
)
8554 struct solib_catchpoint
*c
;
8555 struct gdbarch
*gdbarch
= get_current_arch ();
8556 struct cleanup
*cleanup
;
8560 arg
= skip_spaces (arg
);
8562 c
= XCNEW (struct solib_catchpoint
);
8563 cleanup
= make_cleanup (xfree
, c
);
8569 errcode
= regcomp (&c
->compiled
, arg
, REG_NOSUB
);
8572 char *err
= get_regcomp_error (errcode
, &c
->compiled
);
8574 make_cleanup (xfree
, err
);
8575 error (_("Invalid regexp (%s): %s"), err
, arg
);
8577 c
->regex
= xstrdup (arg
);
8580 c
->is_load
= is_load
;
8581 init_catchpoint (&c
->base
, gdbarch
, is_temp
, NULL
,
8582 &catch_solib_breakpoint_ops
);
8584 c
->base
.enable_state
= enabled
? bp_enabled
: bp_disabled
;
8586 discard_cleanups (cleanup
);
8587 install_breakpoint (0, &c
->base
, 1);
8590 /* A helper function that does all the work for "catch load" and
8594 catch_load_or_unload (char *arg
, int from_tty
, int is_load
,
8595 struct cmd_list_element
*command
)
8598 const int enabled
= 1;
8600 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
8602 add_solib_catchpoint (arg
, is_load
, tempflag
, enabled
);
8606 catch_load_command_1 (char *arg
, int from_tty
,
8607 struct cmd_list_element
*command
)
8609 catch_load_or_unload (arg
, from_tty
, 1, command
);
8613 catch_unload_command_1 (char *arg
, int from_tty
,
8614 struct cmd_list_element
*command
)
8616 catch_load_or_unload (arg
, from_tty
, 0, command
);
8619 /* Initialize a new breakpoint of the bp_catchpoint kind. If TEMPFLAG
8620 is non-zero, then make the breakpoint temporary. If COND_STRING is
8621 not NULL, then store it in the breakpoint. OPS, if not NULL, is
8622 the breakpoint_ops structure associated to the catchpoint. */
8625 init_catchpoint (struct breakpoint
*b
,
8626 struct gdbarch
*gdbarch
, int tempflag
,
8628 const struct breakpoint_ops
*ops
)
8630 struct symtab_and_line sal
;
8633 sal
.pspace
= current_program_space
;
8635 init_raw_breakpoint (b
, gdbarch
, sal
, bp_catchpoint
, ops
);
8637 b
->cond_string
= (cond_string
== NULL
) ? NULL
: xstrdup (cond_string
);
8638 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
8642 install_breakpoint (int internal
, struct breakpoint
*b
, int update_gll
)
8644 add_to_breakpoint_chain (b
);
8645 set_breakpoint_number (internal
, b
);
8646 if (is_tracepoint (b
))
8647 set_tracepoint_count (breakpoint_count
);
8650 observer_notify_breakpoint_created (b
);
8653 update_global_location_list (UGLL_MAY_INSERT
);
8657 create_fork_vfork_event_catchpoint (struct gdbarch
*gdbarch
,
8658 int tempflag
, char *cond_string
,
8659 const struct breakpoint_ops
*ops
)
8661 struct fork_catchpoint
*c
= XNEW (struct fork_catchpoint
);
8663 init_catchpoint (&c
->base
, gdbarch
, tempflag
, cond_string
, ops
);
8665 c
->forked_inferior_pid
= null_ptid
;
8667 install_breakpoint (0, &c
->base
, 1);
8670 /* Exec catchpoints. */
8672 /* An instance of this type is used to represent an exec catchpoint.
8673 It includes a "struct breakpoint" as a kind of base class; users
8674 downcast to "struct breakpoint *" when needed. A breakpoint is
8675 really of this type iff its ops pointer points to
8676 CATCH_EXEC_BREAKPOINT_OPS. */
8678 struct exec_catchpoint
8680 /* The base class. */
8681 struct breakpoint base
;
8683 /* Filename of a program whose exec triggered this catchpoint.
8684 This field is only valid immediately after this catchpoint has
8686 char *exec_pathname
;
8689 /* Implement the "dtor" breakpoint_ops method for exec
8693 dtor_catch_exec (struct breakpoint
*b
)
8695 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
8697 xfree (c
->exec_pathname
);
8699 base_breakpoint_ops
.dtor (b
);
8703 insert_catch_exec (struct bp_location
*bl
)
8705 return target_insert_exec_catchpoint (ptid_get_pid (inferior_ptid
));
8709 remove_catch_exec (struct bp_location
*bl
)
8711 return target_remove_exec_catchpoint (ptid_get_pid (inferior_ptid
));
8715 breakpoint_hit_catch_exec (const struct bp_location
*bl
,
8716 struct address_space
*aspace
, CORE_ADDR bp_addr
,
8717 const struct target_waitstatus
*ws
)
8719 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) bl
->owner
;
8721 if (ws
->kind
!= TARGET_WAITKIND_EXECD
)
8724 c
->exec_pathname
= xstrdup (ws
->value
.execd_pathname
);
8728 static enum print_stop_action
8729 print_it_catch_exec (bpstat bs
)
8731 struct ui_out
*uiout
= current_uiout
;
8732 struct breakpoint
*b
= bs
->breakpoint_at
;
8733 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
8735 annotate_catchpoint (b
->number
);
8736 maybe_print_thread_hit_breakpoint (uiout
);
8737 if (b
->disposition
== disp_del
)
8738 ui_out_text (uiout
, "Temporary catchpoint ");
8740 ui_out_text (uiout
, "Catchpoint ");
8741 if (ui_out_is_mi_like_p (uiout
))
8743 ui_out_field_string (uiout
, "reason",
8744 async_reason_lookup (EXEC_ASYNC_EXEC
));
8745 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
8747 ui_out_field_int (uiout
, "bkptno", b
->number
);
8748 ui_out_text (uiout
, " (exec'd ");
8749 ui_out_field_string (uiout
, "new-exec", c
->exec_pathname
);
8750 ui_out_text (uiout
, "), ");
8752 return PRINT_SRC_AND_LOC
;
8756 print_one_catch_exec (struct breakpoint
*b
, struct bp_location
**last_loc
)
8758 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
8759 struct value_print_options opts
;
8760 struct ui_out
*uiout
= current_uiout
;
8762 get_user_print_options (&opts
);
8764 /* Field 4, the address, is omitted (which makes the columns
8765 not line up too nicely with the headers, but the effect
8766 is relatively readable). */
8767 if (opts
.addressprint
)
8768 ui_out_field_skip (uiout
, "addr");
8770 ui_out_text (uiout
, "exec");
8771 if (c
->exec_pathname
!= NULL
)
8773 ui_out_text (uiout
, ", program \"");
8774 ui_out_field_string (uiout
, "what", c
->exec_pathname
);
8775 ui_out_text (uiout
, "\" ");
8778 if (ui_out_is_mi_like_p (uiout
))
8779 ui_out_field_string (uiout
, "catch-type", "exec");
8783 print_mention_catch_exec (struct breakpoint
*b
)
8785 printf_filtered (_("Catchpoint %d (exec)"), b
->number
);
8788 /* Implement the "print_recreate" breakpoint_ops method for exec
8792 print_recreate_catch_exec (struct breakpoint
*b
, struct ui_file
*fp
)
8794 fprintf_unfiltered (fp
, "catch exec");
8795 print_recreate_thread (b
, fp
);
8798 static struct breakpoint_ops catch_exec_breakpoint_ops
;
8801 hw_breakpoint_used_count (void)
8804 struct breakpoint
*b
;
8805 struct bp_location
*bl
;
8809 if (b
->type
== bp_hardware_breakpoint
&& breakpoint_enabled (b
))
8810 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
8812 /* Special types of hardware breakpoints may use more than
8814 i
+= b
->ops
->resources_needed (bl
);
8821 /* Returns the resources B would use if it were a hardware
8825 hw_watchpoint_use_count (struct breakpoint
*b
)
8828 struct bp_location
*bl
;
8830 if (!breakpoint_enabled (b
))
8833 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
8835 /* Special types of hardware watchpoints may use more than
8837 i
+= b
->ops
->resources_needed (bl
);
8843 /* Returns the sum the used resources of all hardware watchpoints of
8844 type TYPE in the breakpoints list. Also returns in OTHER_TYPE_USED
8845 the sum of the used resources of all hardware watchpoints of other
8846 types _not_ TYPE. */
8849 hw_watchpoint_used_count_others (struct breakpoint
*except
,
8850 enum bptype type
, int *other_type_used
)
8853 struct breakpoint
*b
;
8855 *other_type_used
= 0;
8860 if (!breakpoint_enabled (b
))
8863 if (b
->type
== type
)
8864 i
+= hw_watchpoint_use_count (b
);
8865 else if (is_hardware_watchpoint (b
))
8866 *other_type_used
= 1;
8873 disable_watchpoints_before_interactive_call_start (void)
8875 struct breakpoint
*b
;
8879 if (is_watchpoint (b
) && breakpoint_enabled (b
))
8881 b
->enable_state
= bp_call_disabled
;
8882 update_global_location_list (UGLL_DONT_INSERT
);
8888 enable_watchpoints_after_interactive_call_stop (void)
8890 struct breakpoint
*b
;
8894 if (is_watchpoint (b
) && b
->enable_state
== bp_call_disabled
)
8896 b
->enable_state
= bp_enabled
;
8897 update_global_location_list (UGLL_MAY_INSERT
);
8903 disable_breakpoints_before_startup (void)
8905 current_program_space
->executing_startup
= 1;
8906 update_global_location_list (UGLL_DONT_INSERT
);
8910 enable_breakpoints_after_startup (void)
8912 current_program_space
->executing_startup
= 0;
8913 breakpoint_re_set ();
8916 /* Create a new single-step breakpoint for thread THREAD, with no
8919 static struct breakpoint
*
8920 new_single_step_breakpoint (int thread
, struct gdbarch
*gdbarch
)
8922 struct breakpoint
*b
= XNEW (struct breakpoint
);
8924 init_raw_breakpoint_without_location (b
, gdbarch
, bp_single_step
,
8925 &momentary_breakpoint_ops
);
8927 b
->disposition
= disp_donttouch
;
8928 b
->frame_id
= null_frame_id
;
8931 gdb_assert (b
->thread
!= 0);
8933 add_to_breakpoint_chain (b
);
8938 /* Set a momentary breakpoint of type TYPE at address specified by
8939 SAL. If FRAME_ID is valid, the breakpoint is restricted to that
8943 set_momentary_breakpoint (struct gdbarch
*gdbarch
, struct symtab_and_line sal
,
8944 struct frame_id frame_id
, enum bptype type
)
8946 struct breakpoint
*b
;
8948 /* If FRAME_ID is valid, it should be a real frame, not an inlined or
8950 gdb_assert (!frame_id_artificial_p (frame_id
));
8952 b
= set_raw_breakpoint (gdbarch
, sal
, type
, &momentary_breakpoint_ops
);
8953 b
->enable_state
= bp_enabled
;
8954 b
->disposition
= disp_donttouch
;
8955 b
->frame_id
= frame_id
;
8957 /* If we're debugging a multi-threaded program, then we want
8958 momentary breakpoints to be active in only a single thread of
8960 if (in_thread_list (inferior_ptid
))
8961 b
->thread
= ptid_to_global_thread_id (inferior_ptid
);
8963 update_global_location_list_nothrow (UGLL_MAY_INSERT
);
8968 /* Make a momentary breakpoint based on the master breakpoint ORIG.
8969 The new breakpoint will have type TYPE, use OPS as its
8970 breakpoint_ops, and will set enabled to LOC_ENABLED. */
8972 static struct breakpoint
*
8973 momentary_breakpoint_from_master (struct breakpoint
*orig
,
8975 const struct breakpoint_ops
*ops
,
8978 struct breakpoint
*copy
;
8980 copy
= set_raw_breakpoint_without_location (orig
->gdbarch
, type
, ops
);
8981 copy
->loc
= allocate_bp_location (copy
);
8982 set_breakpoint_location_function (copy
->loc
, 1);
8984 copy
->loc
->gdbarch
= orig
->loc
->gdbarch
;
8985 copy
->loc
->requested_address
= orig
->loc
->requested_address
;
8986 copy
->loc
->address
= orig
->loc
->address
;
8987 copy
->loc
->section
= orig
->loc
->section
;
8988 copy
->loc
->pspace
= orig
->loc
->pspace
;
8989 copy
->loc
->probe
= orig
->loc
->probe
;
8990 copy
->loc
->line_number
= orig
->loc
->line_number
;
8991 copy
->loc
->symtab
= orig
->loc
->symtab
;
8992 copy
->loc
->enabled
= loc_enabled
;
8993 copy
->frame_id
= orig
->frame_id
;
8994 copy
->thread
= orig
->thread
;
8995 copy
->pspace
= orig
->pspace
;
8997 copy
->enable_state
= bp_enabled
;
8998 copy
->disposition
= disp_donttouch
;
8999 copy
->number
= internal_breakpoint_number
--;
9001 update_global_location_list_nothrow (UGLL_DONT_INSERT
);
9005 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
9009 clone_momentary_breakpoint (struct breakpoint
*orig
)
9011 /* If there's nothing to clone, then return nothing. */
9015 return momentary_breakpoint_from_master (orig
, orig
->type
, orig
->ops
, 0);
9019 set_momentary_breakpoint_at_pc (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
9022 struct symtab_and_line sal
;
9024 sal
= find_pc_line (pc
, 0);
9026 sal
.section
= find_pc_overlay (pc
);
9027 sal
.explicit_pc
= 1;
9029 return set_momentary_breakpoint (gdbarch
, sal
, null_frame_id
, type
);
9033 /* Tell the user we have just set a breakpoint B. */
9036 mention (struct breakpoint
*b
)
9038 b
->ops
->print_mention (b
);
9039 if (ui_out_is_mi_like_p (current_uiout
))
9041 printf_filtered ("\n");
9045 static int bp_loc_is_permanent (struct bp_location
*loc
);
9047 static struct bp_location
*
9048 add_location_to_breakpoint (struct breakpoint
*b
,
9049 const struct symtab_and_line
*sal
)
9051 struct bp_location
*loc
, **tmp
;
9052 CORE_ADDR adjusted_address
;
9053 struct gdbarch
*loc_gdbarch
= get_sal_arch (*sal
);
9055 if (loc_gdbarch
== NULL
)
9056 loc_gdbarch
= b
->gdbarch
;
9058 /* Adjust the breakpoint's address prior to allocating a location.
9059 Once we call allocate_bp_location(), that mostly uninitialized
9060 location will be placed on the location chain. Adjustment of the
9061 breakpoint may cause target_read_memory() to be called and we do
9062 not want its scan of the location chain to find a breakpoint and
9063 location that's only been partially initialized. */
9064 adjusted_address
= adjust_breakpoint_address (loc_gdbarch
,
9067 /* Sort the locations by their ADDRESS. */
9068 loc
= allocate_bp_location (b
);
9069 for (tmp
= &(b
->loc
); *tmp
!= NULL
&& (*tmp
)->address
<= adjusted_address
;
9070 tmp
= &((*tmp
)->next
))
9075 loc
->requested_address
= sal
->pc
;
9076 loc
->address
= adjusted_address
;
9077 loc
->pspace
= sal
->pspace
;
9078 loc
->probe
.probe
= sal
->probe
;
9079 loc
->probe
.objfile
= sal
->objfile
;
9080 gdb_assert (loc
->pspace
!= NULL
);
9081 loc
->section
= sal
->section
;
9082 loc
->gdbarch
= loc_gdbarch
;
9083 loc
->line_number
= sal
->line
;
9084 loc
->symtab
= sal
->symtab
;
9086 set_breakpoint_location_function (loc
,
9087 sal
->explicit_pc
|| sal
->explicit_line
);
9089 /* While by definition, permanent breakpoints are already present in the
9090 code, we don't mark the location as inserted. Normally one would expect
9091 that GDB could rely on that breakpoint instruction to stop the program,
9092 thus removing the need to insert its own breakpoint, except that executing
9093 the breakpoint instruction can kill the target instead of reporting a
9094 SIGTRAP. E.g., on SPARC, when interrupts are disabled, executing the
9095 instruction resets the CPU, so QEMU 2.0.0 for SPARC correspondingly dies
9096 with "Trap 0x02 while interrupts disabled, Error state". Letting the
9097 breakpoint be inserted normally results in QEMU knowing about the GDB
9098 breakpoint, and thus trap before the breakpoint instruction is executed.
9099 (If GDB later needs to continue execution past the permanent breakpoint,
9100 it manually increments the PC, thus avoiding executing the breakpoint
9102 if (bp_loc_is_permanent (loc
))
9109 /* See breakpoint.h. */
9112 program_breakpoint_here_p (struct gdbarch
*gdbarch
, CORE_ADDR address
)
9116 const gdb_byte
*bpoint
;
9117 gdb_byte
*target_mem
;
9118 struct cleanup
*cleanup
;
9122 bpoint
= gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &len
);
9124 /* Software breakpoints unsupported? */
9128 target_mem
= (gdb_byte
*) alloca (len
);
9130 /* Enable the automatic memory restoration from breakpoints while
9131 we read the memory. Otherwise we could say about our temporary
9132 breakpoints they are permanent. */
9133 cleanup
= make_show_memory_breakpoints_cleanup (0);
9135 if (target_read_memory (address
, target_mem
, len
) == 0
9136 && memcmp (target_mem
, bpoint
, len
) == 0)
9139 do_cleanups (cleanup
);
9144 /* Return 1 if LOC is pointing to a permanent breakpoint,
9145 return 0 otherwise. */
9148 bp_loc_is_permanent (struct bp_location
*loc
)
9150 struct cleanup
*cleanup
;
9153 gdb_assert (loc
!= NULL
);
9155 /* If we have a catchpoint or a watchpoint, just return 0. We should not
9156 attempt to read from the addresses the locations of these breakpoint types
9157 point to. program_breakpoint_here_p, below, will attempt to read
9159 if (!breakpoint_address_is_meaningful (loc
->owner
))
9162 cleanup
= save_current_space_and_thread ();
9163 switch_to_program_space_and_thread (loc
->pspace
);
9165 retval
= program_breakpoint_here_p (loc
->gdbarch
, loc
->address
);
9167 do_cleanups (cleanup
);
9172 /* Build a command list for the dprintf corresponding to the current
9173 settings of the dprintf style options. */
9176 update_dprintf_command_list (struct breakpoint
*b
)
9178 char *dprintf_args
= b
->extra_string
;
9179 char *printf_line
= NULL
;
9184 dprintf_args
= skip_spaces (dprintf_args
);
9186 /* Allow a comma, as it may have terminated a location, but don't
9188 if (*dprintf_args
== ',')
9190 dprintf_args
= skip_spaces (dprintf_args
);
9192 if (*dprintf_args
!= '"')
9193 error (_("Bad format string, missing '\"'."));
9195 if (strcmp (dprintf_style
, dprintf_style_gdb
) == 0)
9196 printf_line
= xstrprintf ("printf %s", dprintf_args
);
9197 else if (strcmp (dprintf_style
, dprintf_style_call
) == 0)
9199 if (!dprintf_function
)
9200 error (_("No function supplied for dprintf call"));
9202 if (dprintf_channel
&& strlen (dprintf_channel
) > 0)
9203 printf_line
= xstrprintf ("call (void) %s (%s,%s)",
9208 printf_line
= xstrprintf ("call (void) %s (%s)",
9212 else if (strcmp (dprintf_style
, dprintf_style_agent
) == 0)
9214 if (target_can_run_breakpoint_commands ())
9215 printf_line
= xstrprintf ("agent-printf %s", dprintf_args
);
9218 warning (_("Target cannot run dprintf commands, falling back to GDB printf"));
9219 printf_line
= xstrprintf ("printf %s", dprintf_args
);
9223 internal_error (__FILE__
, __LINE__
,
9224 _("Invalid dprintf style."));
9226 gdb_assert (printf_line
!= NULL
);
9227 /* Manufacture a printf sequence. */
9229 struct command_line
*printf_cmd_line
= XNEW (struct command_line
);
9231 printf_cmd_line
->control_type
= simple_control
;
9232 printf_cmd_line
->body_count
= 0;
9233 printf_cmd_line
->body_list
= NULL
;
9234 printf_cmd_line
->next
= NULL
;
9235 printf_cmd_line
->line
= printf_line
;
9237 breakpoint_set_commands (b
, printf_cmd_line
);
9241 /* Update all dprintf commands, making their command lists reflect
9242 current style settings. */
9245 update_dprintf_commands (char *args
, int from_tty
,
9246 struct cmd_list_element
*c
)
9248 struct breakpoint
*b
;
9252 if (b
->type
== bp_dprintf
)
9253 update_dprintf_command_list (b
);
9257 /* Create a breakpoint with SAL as location. Use LOCATION
9258 as a description of the location, and COND_STRING
9259 as condition expression. If LOCATION is NULL then create an
9260 "address location" from the address in the SAL. */
9263 init_breakpoint_sal (struct breakpoint
*b
, struct gdbarch
*gdbarch
,
9264 struct symtabs_and_lines sals
,
9265 struct event_location
*location
,
9266 char *filter
, char *cond_string
,
9268 enum bptype type
, enum bpdisp disposition
,
9269 int thread
, int task
, int ignore_count
,
9270 const struct breakpoint_ops
*ops
, int from_tty
,
9271 int enabled
, int internal
, unsigned flags
,
9272 int display_canonical
)
9276 if (type
== bp_hardware_breakpoint
)
9278 int target_resources_ok
;
9280 i
= hw_breakpoint_used_count ();
9281 target_resources_ok
=
9282 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
9284 if (target_resources_ok
== 0)
9285 error (_("No hardware breakpoint support in the target."));
9286 else if (target_resources_ok
< 0)
9287 error (_("Hardware breakpoints used exceeds limit."));
9290 gdb_assert (sals
.nelts
> 0);
9292 for (i
= 0; i
< sals
.nelts
; ++i
)
9294 struct symtab_and_line sal
= sals
.sals
[i
];
9295 struct bp_location
*loc
;
9299 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
9301 loc_gdbarch
= gdbarch
;
9303 describe_other_breakpoints (loc_gdbarch
,
9304 sal
.pspace
, sal
.pc
, sal
.section
, thread
);
9309 init_raw_breakpoint (b
, gdbarch
, sal
, type
, ops
);
9313 b
->cond_string
= cond_string
;
9314 b
->extra_string
= extra_string
;
9315 b
->ignore_count
= ignore_count
;
9316 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
9317 b
->disposition
= disposition
;
9319 if ((flags
& CREATE_BREAKPOINT_FLAGS_INSERTED
) != 0)
9320 b
->loc
->inserted
= 1;
9322 if (type
== bp_static_tracepoint
)
9324 struct tracepoint
*t
= (struct tracepoint
*) b
;
9325 struct static_tracepoint_marker marker
;
9327 if (strace_marker_p (b
))
9329 /* We already know the marker exists, otherwise, we
9330 wouldn't see a sal for it. */
9331 const char *p
= &event_location_to_string (b
->location
)[3];
9335 p
= skip_spaces_const (p
);
9337 endp
= skip_to_space_const (p
);
9339 marker_str
= savestring (p
, endp
- p
);
9340 t
->static_trace_marker_id
= marker_str
;
9342 printf_filtered (_("Probed static tracepoint "
9344 t
->static_trace_marker_id
);
9346 else if (target_static_tracepoint_marker_at (sal
.pc
, &marker
))
9348 t
->static_trace_marker_id
= xstrdup (marker
.str_id
);
9349 release_static_tracepoint_marker (&marker
);
9351 printf_filtered (_("Probed static tracepoint "
9353 t
->static_trace_marker_id
);
9356 warning (_("Couldn't determine the static "
9357 "tracepoint marker to probe"));
9364 loc
= add_location_to_breakpoint (b
, &sal
);
9365 if ((flags
& CREATE_BREAKPOINT_FLAGS_INSERTED
) != 0)
9371 const char *arg
= b
->cond_string
;
9373 loc
->cond
= parse_exp_1 (&arg
, loc
->address
,
9374 block_for_pc (loc
->address
), 0);
9376 error (_("Garbage '%s' follows condition"), arg
);
9379 /* Dynamic printf requires and uses additional arguments on the
9380 command line, otherwise it's an error. */
9381 if (type
== bp_dprintf
)
9383 if (b
->extra_string
)
9384 update_dprintf_command_list (b
);
9386 error (_("Format string required"));
9388 else if (b
->extra_string
)
9389 error (_("Garbage '%s' at end of command"), b
->extra_string
);
9392 b
->display_canonical
= display_canonical
;
9393 if (location
!= NULL
)
9394 b
->location
= location
;
9397 const char *addr_string
= NULL
;
9398 int addr_string_len
= 0;
9400 if (location
!= NULL
)
9401 addr_string
= event_location_to_string (location
);
9402 if (addr_string
!= NULL
)
9403 addr_string_len
= strlen (addr_string
);
9405 b
->location
= new_address_location (b
->loc
->address
,
9406 addr_string
, addr_string_len
);
9412 create_breakpoint_sal (struct gdbarch
*gdbarch
,
9413 struct symtabs_and_lines sals
,
9414 struct event_location
*location
,
9415 char *filter
, char *cond_string
,
9417 enum bptype type
, enum bpdisp disposition
,
9418 int thread
, int task
, int ignore_count
,
9419 const struct breakpoint_ops
*ops
, int from_tty
,
9420 int enabled
, int internal
, unsigned flags
,
9421 int display_canonical
)
9423 struct breakpoint
*b
;
9424 struct cleanup
*old_chain
;
9426 if (is_tracepoint_type (type
))
9428 struct tracepoint
*t
;
9430 t
= XCNEW (struct tracepoint
);
9434 b
= XNEW (struct breakpoint
);
9436 old_chain
= make_cleanup (xfree
, b
);
9438 init_breakpoint_sal (b
, gdbarch
,
9440 filter
, cond_string
, extra_string
,
9442 thread
, task
, ignore_count
,
9444 enabled
, internal
, flags
,
9446 discard_cleanups (old_chain
);
9448 install_breakpoint (internal
, b
, 0);
9451 /* Add SALS.nelts breakpoints to the breakpoint table. For each
9452 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
9453 value. COND_STRING, if not NULL, specified the condition to be
9454 used for all breakpoints. Essentially the only case where
9455 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
9456 function. In that case, it's still not possible to specify
9457 separate conditions for different overloaded functions, so
9458 we take just a single condition string.
9460 NOTE: If the function succeeds, the caller is expected to cleanup
9461 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
9462 array contents). If the function fails (error() is called), the
9463 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
9464 COND and SALS arrays and each of those arrays contents. */
9467 create_breakpoints_sal (struct gdbarch
*gdbarch
,
9468 struct linespec_result
*canonical
,
9469 char *cond_string
, char *extra_string
,
9470 enum bptype type
, enum bpdisp disposition
,
9471 int thread
, int task
, int ignore_count
,
9472 const struct breakpoint_ops
*ops
, int from_tty
,
9473 int enabled
, int internal
, unsigned flags
)
9476 struct linespec_sals
*lsal
;
9478 if (canonical
->pre_expanded
)
9479 gdb_assert (VEC_length (linespec_sals
, canonical
->sals
) == 1);
9481 for (i
= 0; VEC_iterate (linespec_sals
, canonical
->sals
, i
, lsal
); ++i
)
9483 /* Note that 'location' can be NULL in the case of a plain
9484 'break', without arguments. */
9485 struct event_location
*location
9486 = (canonical
->location
!= NULL
9487 ? copy_event_location (canonical
->location
) : NULL
);
9488 char *filter_string
= lsal
->canonical
? xstrdup (lsal
->canonical
) : NULL
;
9489 struct cleanup
*inner
= make_cleanup_delete_event_location (location
);
9491 make_cleanup (xfree
, filter_string
);
9492 create_breakpoint_sal (gdbarch
, lsal
->sals
,
9495 cond_string
, extra_string
,
9497 thread
, task
, ignore_count
, ops
,
9498 from_tty
, enabled
, internal
, flags
,
9499 canonical
->special_display
);
9500 discard_cleanups (inner
);
9504 /* Parse LOCATION which is assumed to be a SAL specification possibly
9505 followed by conditionals. On return, SALS contains an array of SAL
9506 addresses found. LOCATION points to the end of the SAL (for
9507 linespec locations).
9509 The array and the line spec strings are allocated on the heap, it is
9510 the caller's responsibility to free them. */
9513 parse_breakpoint_sals (const struct event_location
*location
,
9514 struct linespec_result
*canonical
)
9516 struct symtab_and_line cursal
;
9518 if (event_location_type (location
) == LINESPEC_LOCATION
)
9520 const char *address
= get_linespec_location (location
);
9522 if (address
== NULL
)
9524 /* The last displayed codepoint, if it's valid, is our default
9525 breakpoint address. */
9526 if (last_displayed_sal_is_valid ())
9528 struct linespec_sals lsal
;
9529 struct symtab_and_line sal
;
9532 init_sal (&sal
); /* Initialize to zeroes. */
9533 lsal
.sals
.sals
= XNEW (struct symtab_and_line
);
9535 /* Set sal's pspace, pc, symtab, and line to the values
9536 corresponding to the last call to print_frame_info.
9537 Be sure to reinitialize LINE with NOTCURRENT == 0
9538 as the breakpoint line number is inappropriate otherwise.
9539 find_pc_line would adjust PC, re-set it back. */
9540 get_last_displayed_sal (&sal
);
9542 sal
= find_pc_line (pc
, 0);
9544 /* "break" without arguments is equivalent to "break *PC"
9545 where PC is the last displayed codepoint's address. So
9546 make sure to set sal.explicit_pc to prevent GDB from
9547 trying to expand the list of sals to include all other
9548 instances with the same symtab and line. */
9550 sal
.explicit_pc
= 1;
9552 lsal
.sals
.sals
[0] = sal
;
9553 lsal
.sals
.nelts
= 1;
9554 lsal
.canonical
= NULL
;
9556 VEC_safe_push (linespec_sals
, canonical
->sals
, &lsal
);
9560 error (_("No default breakpoint address now."));
9564 /* Force almost all breakpoints to be in terms of the
9565 current_source_symtab (which is decode_line_1's default).
9566 This should produce the results we want almost all of the
9567 time while leaving default_breakpoint_* alone.
9569 ObjC: However, don't match an Objective-C method name which
9570 may have a '+' or '-' succeeded by a '['. */
9571 cursal
= get_current_source_symtab_and_line ();
9572 if (last_displayed_sal_is_valid ())
9574 const char *address
= NULL
;
9576 if (event_location_type (location
) == LINESPEC_LOCATION
)
9577 address
= get_linespec_location (location
);
9581 && strchr ("+-", address
[0]) != NULL
9582 && address
[1] != '['))
9584 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, NULL
,
9585 get_last_displayed_symtab (),
9586 get_last_displayed_line (),
9587 canonical
, NULL
, NULL
);
9592 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, NULL
,
9593 cursal
.symtab
, cursal
.line
, canonical
, NULL
, NULL
);
9597 /* Convert each SAL into a real PC. Verify that the PC can be
9598 inserted as a breakpoint. If it can't throw an error. */
9601 breakpoint_sals_to_pc (struct symtabs_and_lines
*sals
)
9605 for (i
= 0; i
< sals
->nelts
; i
++)
9606 resolve_sal_pc (&sals
->sals
[i
]);
9609 /* Fast tracepoints may have restrictions on valid locations. For
9610 instance, a fast tracepoint using a jump instead of a trap will
9611 likely have to overwrite more bytes than a trap would, and so can
9612 only be placed where the instruction is longer than the jump, or a
9613 multi-instruction sequence does not have a jump into the middle of
9617 check_fast_tracepoint_sals (struct gdbarch
*gdbarch
,
9618 struct symtabs_and_lines
*sals
)
9621 struct symtab_and_line
*sal
;
9623 struct cleanup
*old_chain
;
9625 for (i
= 0; i
< sals
->nelts
; i
++)
9627 struct gdbarch
*sarch
;
9629 sal
= &sals
->sals
[i
];
9631 sarch
= get_sal_arch (*sal
);
9632 /* We fall back to GDBARCH if there is no architecture
9633 associated with SAL. */
9636 rslt
= gdbarch_fast_tracepoint_valid_at (sarch
, sal
->pc
, &msg
);
9637 old_chain
= make_cleanup (xfree
, msg
);
9640 error (_("May not have a fast tracepoint at 0x%s%s"),
9641 paddress (sarch
, sal
->pc
), (msg
? msg
: ""));
9643 do_cleanups (old_chain
);
9647 /* Given TOK, a string specification of condition and thread, as
9648 accepted by the 'break' command, extract the condition
9649 string and thread number and set *COND_STRING and *THREAD.
9650 PC identifies the context at which the condition should be parsed.
9651 If no condition is found, *COND_STRING is set to NULL.
9652 If no thread is found, *THREAD is set to -1. */
9655 find_condition_and_thread (const char *tok
, CORE_ADDR pc
,
9656 char **cond_string
, int *thread
, int *task
,
9659 *cond_string
= NULL
;
9666 const char *end_tok
;
9668 const char *cond_start
= NULL
;
9669 const char *cond_end
= NULL
;
9671 tok
= skip_spaces_const (tok
);
9673 if ((*tok
== '"' || *tok
== ',') && rest
)
9675 *rest
= savestring (tok
, strlen (tok
));
9679 end_tok
= skip_to_space_const (tok
);
9681 toklen
= end_tok
- tok
;
9683 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
9685 struct expression
*expr
;
9687 tok
= cond_start
= end_tok
+ 1;
9688 expr
= parse_exp_1 (&tok
, pc
, block_for_pc (pc
), 0);
9691 *cond_string
= savestring (cond_start
, cond_end
- cond_start
);
9693 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
9696 struct thread_info
*thr
;
9699 thr
= parse_thread_id (tok
, &tmptok
);
9701 error (_("Junk after thread keyword."));
9702 *thread
= thr
->global_num
;
9705 else if (toklen
>= 1 && strncmp (tok
, "task", toklen
) == 0)
9710 *task
= strtol (tok
, &tmptok
, 0);
9712 error (_("Junk after task keyword."));
9713 if (!valid_task_id (*task
))
9714 error (_("Unknown task %d."), *task
);
9719 *rest
= savestring (tok
, strlen (tok
));
9723 error (_("Junk at end of arguments."));
9727 /* Decode a static tracepoint marker spec. */
9729 static struct symtabs_and_lines
9730 decode_static_tracepoint_spec (const char **arg_p
)
9732 VEC(static_tracepoint_marker_p
) *markers
= NULL
;
9733 struct symtabs_and_lines sals
;
9734 struct cleanup
*old_chain
;
9735 const char *p
= &(*arg_p
)[3];
9740 p
= skip_spaces_const (p
);
9742 endp
= skip_to_space_const (p
);
9744 marker_str
= savestring (p
, endp
- p
);
9745 old_chain
= make_cleanup (xfree
, marker_str
);
9747 markers
= target_static_tracepoint_markers_by_strid (marker_str
);
9748 if (VEC_empty(static_tracepoint_marker_p
, markers
))
9749 error (_("No known static tracepoint marker named %s"), marker_str
);
9751 sals
.nelts
= VEC_length(static_tracepoint_marker_p
, markers
);
9752 sals
.sals
= XNEWVEC (struct symtab_and_line
, sals
.nelts
);
9754 for (i
= 0; i
< sals
.nelts
; i
++)
9756 struct static_tracepoint_marker
*marker
;
9758 marker
= VEC_index (static_tracepoint_marker_p
, markers
, i
);
9760 init_sal (&sals
.sals
[i
]);
9762 sals
.sals
[i
] = find_pc_line (marker
->address
, 0);
9763 sals
.sals
[i
].pc
= marker
->address
;
9765 release_static_tracepoint_marker (marker
);
9768 do_cleanups (old_chain
);
9774 /* See breakpoint.h. */
9777 create_breakpoint (struct gdbarch
*gdbarch
,
9778 const struct event_location
*location
, char *cond_string
,
9779 int thread
, char *extra_string
,
9781 int tempflag
, enum bptype type_wanted
,
9783 enum auto_boolean pending_break_support
,
9784 const struct breakpoint_ops
*ops
,
9785 int from_tty
, int enabled
, int internal
,
9788 struct linespec_result canonical
;
9789 struct cleanup
*old_chain
;
9790 struct cleanup
*bkpt_chain
= NULL
;
9793 int prev_bkpt_count
= breakpoint_count
;
9795 gdb_assert (ops
!= NULL
);
9797 /* If extra_string isn't useful, set it to NULL. */
9798 if (extra_string
!= NULL
&& *extra_string
== '\0')
9799 extra_string
= NULL
;
9801 init_linespec_result (&canonical
);
9805 ops
->create_sals_from_location (location
, &canonical
, type_wanted
);
9807 CATCH (e
, RETURN_MASK_ERROR
)
9809 /* If caller is interested in rc value from parse, set
9811 if (e
.error
== NOT_FOUND_ERROR
)
9813 /* If pending breakpoint support is turned off, throw
9816 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
9817 throw_exception (e
);
9819 exception_print (gdb_stderr
, e
);
9821 /* If pending breakpoint support is auto query and the user
9822 selects no, then simply return the error code. */
9823 if (pending_break_support
== AUTO_BOOLEAN_AUTO
9824 && !nquery (_("Make %s pending on future shared library load? "),
9825 bptype_string (type_wanted
)))
9828 /* At this point, either the user was queried about setting
9829 a pending breakpoint and selected yes, or pending
9830 breakpoint behavior is on and thus a pending breakpoint
9831 is defaulted on behalf of the user. */
9835 throw_exception (e
);
9839 if (!pending
&& VEC_empty (linespec_sals
, canonical
.sals
))
9842 /* Create a chain of things that always need to be cleaned up. */
9843 old_chain
= make_cleanup_destroy_linespec_result (&canonical
);
9845 /* ----------------------------- SNIP -----------------------------
9846 Anything added to the cleanup chain beyond this point is assumed
9847 to be part of a breakpoint. If the breakpoint create succeeds
9848 then the memory is not reclaimed. */
9849 bkpt_chain
= make_cleanup (null_cleanup
, 0);
9851 /* Resolve all line numbers to PC's and verify that the addresses
9852 are ok for the target. */
9856 struct linespec_sals
*iter
;
9858 for (ix
= 0; VEC_iterate (linespec_sals
, canonical
.sals
, ix
, iter
); ++ix
)
9859 breakpoint_sals_to_pc (&iter
->sals
);
9862 /* Fast tracepoints may have additional restrictions on location. */
9863 if (!pending
&& type_wanted
== bp_fast_tracepoint
)
9866 struct linespec_sals
*iter
;
9868 for (ix
= 0; VEC_iterate (linespec_sals
, canonical
.sals
, ix
, iter
); ++ix
)
9869 check_fast_tracepoint_sals (gdbarch
, &iter
->sals
);
9872 /* Verify that condition can be parsed, before setting any
9873 breakpoints. Allocate a separate condition expression for each
9880 struct linespec_sals
*lsal
;
9882 lsal
= VEC_index (linespec_sals
, canonical
.sals
, 0);
9884 /* Here we only parse 'arg' to separate condition
9885 from thread number, so parsing in context of first
9886 sal is OK. When setting the breakpoint we'll
9887 re-parse it in context of each sal. */
9889 find_condition_and_thread (extra_string
, lsal
->sals
.sals
[0].pc
,
9890 &cond_string
, &thread
, &task
, &rest
);
9892 make_cleanup (xfree
, cond_string
);
9894 make_cleanup (xfree
, rest
);
9896 extra_string
= rest
;
9898 extra_string
= NULL
;
9902 if (type_wanted
!= bp_dprintf
9903 && extra_string
!= NULL
&& *extra_string
!= '\0')
9904 error (_("Garbage '%s' at end of location"), extra_string
);
9906 /* Create a private copy of condition string. */
9909 cond_string
= xstrdup (cond_string
);
9910 make_cleanup (xfree
, cond_string
);
9912 /* Create a private copy of any extra string. */
9915 extra_string
= xstrdup (extra_string
);
9916 make_cleanup (xfree
, extra_string
);
9920 ops
->create_breakpoints_sal (gdbarch
, &canonical
,
9921 cond_string
, extra_string
, type_wanted
,
9922 tempflag
? disp_del
: disp_donttouch
,
9923 thread
, task
, ignore_count
, ops
,
9924 from_tty
, enabled
, internal
, flags
);
9928 struct breakpoint
*b
;
9930 if (is_tracepoint_type (type_wanted
))
9932 struct tracepoint
*t
;
9934 t
= XCNEW (struct tracepoint
);
9938 b
= XNEW (struct breakpoint
);
9940 init_raw_breakpoint_without_location (b
, gdbarch
, type_wanted
, ops
);
9941 b
->location
= copy_event_location (location
);
9944 b
->cond_string
= NULL
;
9947 /* Create a private copy of condition string. */
9950 cond_string
= xstrdup (cond_string
);
9951 make_cleanup (xfree
, cond_string
);
9953 b
->cond_string
= cond_string
;
9957 /* Create a private copy of any extra string. */
9958 if (extra_string
!= NULL
)
9960 extra_string
= xstrdup (extra_string
);
9961 make_cleanup (xfree
, extra_string
);
9963 b
->extra_string
= extra_string
;
9964 b
->ignore_count
= ignore_count
;
9965 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
9966 b
->condition_not_parsed
= 1;
9967 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
9968 if ((type_wanted
!= bp_breakpoint
9969 && type_wanted
!= bp_hardware_breakpoint
) || thread
!= -1)
9970 b
->pspace
= current_program_space
;
9972 install_breakpoint (internal
, b
, 0);
9975 if (VEC_length (linespec_sals
, canonical
.sals
) > 1)
9977 warning (_("Multiple breakpoints were set.\nUse the "
9978 "\"delete\" command to delete unwanted breakpoints."));
9979 prev_breakpoint_count
= prev_bkpt_count
;
9982 /* That's it. Discard the cleanups for data inserted into the
9984 discard_cleanups (bkpt_chain
);
9985 /* But cleanup everything else. */
9986 do_cleanups (old_chain
);
9988 /* error call may happen here - have BKPT_CHAIN already discarded. */
9989 update_global_location_list (UGLL_MAY_INSERT
);
9994 /* Set a breakpoint.
9995 ARG is a string describing breakpoint address,
9996 condition, and thread.
9997 FLAG specifies if a breakpoint is hardware on,
9998 and if breakpoint is temporary, using BP_HARDWARE_FLAG
10002 break_command_1 (char *arg
, int flag
, int from_tty
)
10004 int tempflag
= flag
& BP_TEMPFLAG
;
10005 enum bptype type_wanted
= (flag
& BP_HARDWAREFLAG
10006 ? bp_hardware_breakpoint
10008 struct breakpoint_ops
*ops
;
10009 struct event_location
*location
;
10010 struct cleanup
*cleanup
;
10012 location
= string_to_event_location (&arg
, current_language
);
10013 cleanup
= make_cleanup_delete_event_location (location
);
10015 /* Matching breakpoints on probes. */
10016 if (location
!= NULL
10017 && event_location_type (location
) == PROBE_LOCATION
)
10018 ops
= &bkpt_probe_breakpoint_ops
;
10020 ops
= &bkpt_breakpoint_ops
;
10022 create_breakpoint (get_current_arch (),
10024 NULL
, 0, arg
, 1 /* parse arg */,
10025 tempflag
, type_wanted
,
10026 0 /* Ignore count */,
10027 pending_break_support
,
10033 do_cleanups (cleanup
);
10036 /* Helper function for break_command_1 and disassemble_command. */
10039 resolve_sal_pc (struct symtab_and_line
*sal
)
10043 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
10045 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
10046 error (_("No line %d in file \"%s\"."),
10047 sal
->line
, symtab_to_filename_for_display (sal
->symtab
));
10050 /* If this SAL corresponds to a breakpoint inserted using a line
10051 number, then skip the function prologue if necessary. */
10052 if (sal
->explicit_line
)
10053 skip_prologue_sal (sal
);
10056 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
10058 const struct blockvector
*bv
;
10059 const struct block
*b
;
10060 struct symbol
*sym
;
10062 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
,
10063 SYMTAB_COMPUNIT (sal
->symtab
));
10066 sym
= block_linkage_function (b
);
10069 fixup_symbol_section (sym
, SYMTAB_OBJFILE (sal
->symtab
));
10070 sal
->section
= SYMBOL_OBJ_SECTION (SYMTAB_OBJFILE (sal
->symtab
),
10075 /* It really is worthwhile to have the section, so we'll
10076 just have to look harder. This case can be executed
10077 if we have line numbers but no functions (as can
10078 happen in assembly source). */
10080 struct bound_minimal_symbol msym
;
10081 struct cleanup
*old_chain
= save_current_space_and_thread ();
10083 switch_to_program_space_and_thread (sal
->pspace
);
10085 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
10087 sal
->section
= MSYMBOL_OBJ_SECTION (msym
.objfile
, msym
.minsym
);
10089 do_cleanups (old_chain
);
10096 break_command (char *arg
, int from_tty
)
10098 break_command_1 (arg
, 0, from_tty
);
10102 tbreak_command (char *arg
, int from_tty
)
10104 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
10108 hbreak_command (char *arg
, int from_tty
)
10110 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
10114 thbreak_command (char *arg
, int from_tty
)
10116 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
10120 stop_command (char *arg
, int from_tty
)
10122 printf_filtered (_("Specify the type of breakpoint to set.\n\
10123 Usage: stop in <function | address>\n\
10124 stop at <line>\n"));
10128 stopin_command (char *arg
, int from_tty
)
10132 if (arg
== (char *) NULL
)
10134 else if (*arg
!= '*')
10136 char *argptr
= arg
;
10139 /* Look for a ':'. If this is a line number specification, then
10140 say it is bad, otherwise, it should be an address or
10141 function/method name. */
10142 while (*argptr
&& !hasColon
)
10144 hasColon
= (*argptr
== ':');
10149 badInput
= (*argptr
!= ':'); /* Not a class::method */
10151 badInput
= isdigit (*arg
); /* a simple line number */
10155 printf_filtered (_("Usage: stop in <function | address>\n"));
10157 break_command_1 (arg
, 0, from_tty
);
10161 stopat_command (char *arg
, int from_tty
)
10165 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
10169 char *argptr
= arg
;
10172 /* Look for a ':'. If there is a '::' then get out, otherwise
10173 it is probably a line number. */
10174 while (*argptr
&& !hasColon
)
10176 hasColon
= (*argptr
== ':');
10181 badInput
= (*argptr
== ':'); /* we have class::method */
10183 badInput
= !isdigit (*arg
); /* not a line number */
10187 printf_filtered (_("Usage: stop at <line>\n"));
10189 break_command_1 (arg
, 0, from_tty
);
10192 /* The dynamic printf command is mostly like a regular breakpoint, but
10193 with a prewired command list consisting of a single output command,
10194 built from extra arguments supplied on the dprintf command
10198 dprintf_command (char *arg
, int from_tty
)
10200 struct event_location
*location
;
10201 struct cleanup
*cleanup
;
10203 location
= string_to_event_location (&arg
, current_language
);
10204 cleanup
= make_cleanup_delete_event_location (location
);
10206 /* If non-NULL, ARG should have been advanced past the location;
10207 the next character must be ','. */
10210 if (arg
[0] != ',' || arg
[1] == '\0')
10211 error (_("Format string required"));
10214 /* Skip the comma. */
10219 create_breakpoint (get_current_arch (),
10221 NULL
, 0, arg
, 1 /* parse arg */,
10223 0 /* Ignore count */,
10224 pending_break_support
,
10225 &dprintf_breakpoint_ops
,
10230 do_cleanups (cleanup
);
10234 agent_printf_command (char *arg
, int from_tty
)
10236 error (_("May only run agent-printf on the target"));
10239 /* Implement the "breakpoint_hit" breakpoint_ops method for
10240 ranged breakpoints. */
10243 breakpoint_hit_ranged_breakpoint (const struct bp_location
*bl
,
10244 struct address_space
*aspace
,
10246 const struct target_waitstatus
*ws
)
10248 if (ws
->kind
!= TARGET_WAITKIND_STOPPED
10249 || ws
->value
.sig
!= GDB_SIGNAL_TRAP
)
10252 return breakpoint_address_match_range (bl
->pspace
->aspace
, bl
->address
,
10253 bl
->length
, aspace
, bp_addr
);
10256 /* Implement the "resources_needed" breakpoint_ops method for
10257 ranged breakpoints. */
10260 resources_needed_ranged_breakpoint (const struct bp_location
*bl
)
10262 return target_ranged_break_num_registers ();
10265 /* Implement the "print_it" breakpoint_ops method for
10266 ranged breakpoints. */
10268 static enum print_stop_action
10269 print_it_ranged_breakpoint (bpstat bs
)
10271 struct breakpoint
*b
= bs
->breakpoint_at
;
10272 struct bp_location
*bl
= b
->loc
;
10273 struct ui_out
*uiout
= current_uiout
;
10275 gdb_assert (b
->type
== bp_hardware_breakpoint
);
10277 /* Ranged breakpoints have only one location. */
10278 gdb_assert (bl
&& bl
->next
== NULL
);
10280 annotate_breakpoint (b
->number
);
10282 maybe_print_thread_hit_breakpoint (uiout
);
10284 if (b
->disposition
== disp_del
)
10285 ui_out_text (uiout
, "Temporary ranged breakpoint ");
10287 ui_out_text (uiout
, "Ranged breakpoint ");
10288 if (ui_out_is_mi_like_p (uiout
))
10290 ui_out_field_string (uiout
, "reason",
10291 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
10292 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
10294 ui_out_field_int (uiout
, "bkptno", b
->number
);
10295 ui_out_text (uiout
, ", ");
10297 return PRINT_SRC_AND_LOC
;
10300 /* Implement the "print_one" breakpoint_ops method for
10301 ranged breakpoints. */
10304 print_one_ranged_breakpoint (struct breakpoint
*b
,
10305 struct bp_location
**last_loc
)
10307 struct bp_location
*bl
= b
->loc
;
10308 struct value_print_options opts
;
10309 struct ui_out
*uiout
= current_uiout
;
10311 /* Ranged breakpoints have only one location. */
10312 gdb_assert (bl
&& bl
->next
== NULL
);
10314 get_user_print_options (&opts
);
10316 if (opts
.addressprint
)
10317 /* We don't print the address range here, it will be printed later
10318 by print_one_detail_ranged_breakpoint. */
10319 ui_out_field_skip (uiout
, "addr");
10320 annotate_field (5);
10321 print_breakpoint_location (b
, bl
);
10325 /* Implement the "print_one_detail" breakpoint_ops method for
10326 ranged breakpoints. */
10329 print_one_detail_ranged_breakpoint (const struct breakpoint
*b
,
10330 struct ui_out
*uiout
)
10332 CORE_ADDR address_start
, address_end
;
10333 struct bp_location
*bl
= b
->loc
;
10334 struct ui_file
*stb
= mem_fileopen ();
10335 struct cleanup
*cleanup
= make_cleanup_ui_file_delete (stb
);
10339 address_start
= bl
->address
;
10340 address_end
= address_start
+ bl
->length
- 1;
10342 ui_out_text (uiout
, "\taddress range: ");
10343 fprintf_unfiltered (stb
, "[%s, %s]",
10344 print_core_address (bl
->gdbarch
, address_start
),
10345 print_core_address (bl
->gdbarch
, address_end
));
10346 ui_out_field_stream (uiout
, "addr", stb
);
10347 ui_out_text (uiout
, "\n");
10349 do_cleanups (cleanup
);
10352 /* Implement the "print_mention" breakpoint_ops method for
10353 ranged breakpoints. */
10356 print_mention_ranged_breakpoint (struct breakpoint
*b
)
10358 struct bp_location
*bl
= b
->loc
;
10359 struct ui_out
*uiout
= current_uiout
;
10362 gdb_assert (b
->type
== bp_hardware_breakpoint
);
10364 if (ui_out_is_mi_like_p (uiout
))
10367 printf_filtered (_("Hardware assisted ranged breakpoint %d from %s to %s."),
10368 b
->number
, paddress (bl
->gdbarch
, bl
->address
),
10369 paddress (bl
->gdbarch
, bl
->address
+ bl
->length
- 1));
10372 /* Implement the "print_recreate" breakpoint_ops method for
10373 ranged breakpoints. */
10376 print_recreate_ranged_breakpoint (struct breakpoint
*b
, struct ui_file
*fp
)
10378 fprintf_unfiltered (fp
, "break-range %s, %s",
10379 event_location_to_string (b
->location
),
10380 event_location_to_string (b
->location_range_end
));
10381 print_recreate_thread (b
, fp
);
10384 /* The breakpoint_ops structure to be used in ranged breakpoints. */
10386 static struct breakpoint_ops ranged_breakpoint_ops
;
10388 /* Find the address where the end of the breakpoint range should be
10389 placed, given the SAL of the end of the range. This is so that if
10390 the user provides a line number, the end of the range is set to the
10391 last instruction of the given line. */
10394 find_breakpoint_range_end (struct symtab_and_line sal
)
10398 /* If the user provided a PC value, use it. Otherwise,
10399 find the address of the end of the given location. */
10400 if (sal
.explicit_pc
)
10407 ret
= find_line_pc_range (sal
, &start
, &end
);
10409 error (_("Could not find location of the end of the range."));
10411 /* find_line_pc_range returns the start of the next line. */
10418 /* Implement the "break-range" CLI command. */
10421 break_range_command (char *arg
, int from_tty
)
10423 char *arg_start
, *addr_string_start
;
10424 struct linespec_result canonical_start
, canonical_end
;
10425 int bp_count
, can_use_bp
, length
;
10427 struct breakpoint
*b
;
10428 struct symtab_and_line sal_start
, sal_end
;
10429 struct cleanup
*cleanup_bkpt
;
10430 struct linespec_sals
*lsal_start
, *lsal_end
;
10431 struct event_location
*start_location
, *end_location
;
10433 /* We don't support software ranged breakpoints. */
10434 if (target_ranged_break_num_registers () < 0)
10435 error (_("This target does not support hardware ranged breakpoints."));
10437 bp_count
= hw_breakpoint_used_count ();
10438 bp_count
+= target_ranged_break_num_registers ();
10439 can_use_bp
= target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
10441 if (can_use_bp
< 0)
10442 error (_("Hardware breakpoints used exceeds limit."));
10444 arg
= skip_spaces (arg
);
10445 if (arg
== NULL
|| arg
[0] == '\0')
10446 error(_("No address range specified."));
10448 init_linespec_result (&canonical_start
);
10451 start_location
= string_to_event_location (&arg
, current_language
);
10452 cleanup_bkpt
= make_cleanup_delete_event_location (start_location
);
10453 parse_breakpoint_sals (start_location
, &canonical_start
);
10454 make_cleanup_destroy_linespec_result (&canonical_start
);
10457 error (_("Too few arguments."));
10458 else if (VEC_empty (linespec_sals
, canonical_start
.sals
))
10459 error (_("Could not find location of the beginning of the range."));
10461 lsal_start
= VEC_index (linespec_sals
, canonical_start
.sals
, 0);
10463 if (VEC_length (linespec_sals
, canonical_start
.sals
) > 1
10464 || lsal_start
->sals
.nelts
!= 1)
10465 error (_("Cannot create a ranged breakpoint with multiple locations."));
10467 sal_start
= lsal_start
->sals
.sals
[0];
10468 addr_string_start
= savestring (arg_start
, arg
- arg_start
);
10469 make_cleanup (xfree
, addr_string_start
);
10471 arg
++; /* Skip the comma. */
10472 arg
= skip_spaces (arg
);
10474 /* Parse the end location. */
10476 init_linespec_result (&canonical_end
);
10479 /* We call decode_line_full directly here instead of using
10480 parse_breakpoint_sals because we need to specify the start location's
10481 symtab and line as the default symtab and line for the end of the
10482 range. This makes it possible to have ranges like "foo.c:27, +14",
10483 where +14 means 14 lines from the start location. */
10484 end_location
= string_to_event_location (&arg
, current_language
);
10485 make_cleanup_delete_event_location (end_location
);
10486 decode_line_full (end_location
, DECODE_LINE_FUNFIRSTLINE
, NULL
,
10487 sal_start
.symtab
, sal_start
.line
,
10488 &canonical_end
, NULL
, NULL
);
10490 make_cleanup_destroy_linespec_result (&canonical_end
);
10492 if (VEC_empty (linespec_sals
, canonical_end
.sals
))
10493 error (_("Could not find location of the end of the range."));
10495 lsal_end
= VEC_index (linespec_sals
, canonical_end
.sals
, 0);
10496 if (VEC_length (linespec_sals
, canonical_end
.sals
) > 1
10497 || lsal_end
->sals
.nelts
!= 1)
10498 error (_("Cannot create a ranged breakpoint with multiple locations."));
10500 sal_end
= lsal_end
->sals
.sals
[0];
10502 end
= find_breakpoint_range_end (sal_end
);
10503 if (sal_start
.pc
> end
)
10504 error (_("Invalid address range, end precedes start."));
10506 length
= end
- sal_start
.pc
+ 1;
10508 /* Length overflowed. */
10509 error (_("Address range too large."));
10510 else if (length
== 1)
10512 /* This range is simple enough to be handled by
10513 the `hbreak' command. */
10514 hbreak_command (addr_string_start
, 1);
10516 do_cleanups (cleanup_bkpt
);
10521 /* Now set up the breakpoint. */
10522 b
= set_raw_breakpoint (get_current_arch (), sal_start
,
10523 bp_hardware_breakpoint
, &ranged_breakpoint_ops
);
10524 set_breakpoint_count (breakpoint_count
+ 1);
10525 b
->number
= breakpoint_count
;
10526 b
->disposition
= disp_donttouch
;
10527 b
->location
= copy_event_location (start_location
);
10528 b
->location_range_end
= copy_event_location (end_location
);
10529 b
->loc
->length
= length
;
10531 do_cleanups (cleanup_bkpt
);
10534 observer_notify_breakpoint_created (b
);
10535 update_global_location_list (UGLL_MAY_INSERT
);
10538 /* Return non-zero if EXP is verified as constant. Returned zero
10539 means EXP is variable. Also the constant detection may fail for
10540 some constant expressions and in such case still falsely return
10544 watchpoint_exp_is_const (const struct expression
*exp
)
10546 int i
= exp
->nelts
;
10552 /* We are only interested in the descriptor of each element. */
10553 operator_length (exp
, i
, &oplenp
, &argsp
);
10556 switch (exp
->elts
[i
].opcode
)
10566 case BINOP_LOGICAL_AND
:
10567 case BINOP_LOGICAL_OR
:
10568 case BINOP_BITWISE_AND
:
10569 case BINOP_BITWISE_IOR
:
10570 case BINOP_BITWISE_XOR
:
10572 case BINOP_NOTEQUAL
:
10599 case OP_OBJC_NSSTRING
:
10602 case UNOP_LOGICAL_NOT
:
10603 case UNOP_COMPLEMENT
:
10608 case UNOP_CAST_TYPE
:
10609 case UNOP_REINTERPRET_CAST
:
10610 case UNOP_DYNAMIC_CAST
:
10611 /* Unary, binary and ternary operators: We have to check
10612 their operands. If they are constant, then so is the
10613 result of that operation. For instance, if A and B are
10614 determined to be constants, then so is "A + B".
10616 UNOP_IND is one exception to the rule above, because the
10617 value of *ADDR is not necessarily a constant, even when
10622 /* Check whether the associated symbol is a constant.
10624 We use SYMBOL_CLASS rather than TYPE_CONST because it's
10625 possible that a buggy compiler could mark a variable as
10626 constant even when it is not, and TYPE_CONST would return
10627 true in this case, while SYMBOL_CLASS wouldn't.
10629 We also have to check for function symbols because they
10630 are always constant. */
10632 struct symbol
*s
= exp
->elts
[i
+ 2].symbol
;
10634 if (SYMBOL_CLASS (s
) != LOC_BLOCK
10635 && SYMBOL_CLASS (s
) != LOC_CONST
10636 && SYMBOL_CLASS (s
) != LOC_CONST_BYTES
)
10641 /* The default action is to return 0 because we are using
10642 the optimistic approach here: If we don't know something,
10643 then it is not a constant. */
10652 /* Implement the "dtor" breakpoint_ops method for watchpoints. */
10655 dtor_watchpoint (struct breakpoint
*self
)
10657 struct watchpoint
*w
= (struct watchpoint
*) self
;
10659 xfree (w
->cond_exp
);
10661 xfree (w
->exp_string
);
10662 xfree (w
->exp_string_reparse
);
10663 value_free (w
->val
);
10665 base_breakpoint_ops
.dtor (self
);
10668 /* Implement the "re_set" breakpoint_ops method for watchpoints. */
10671 re_set_watchpoint (struct breakpoint
*b
)
10673 struct watchpoint
*w
= (struct watchpoint
*) b
;
10675 /* Watchpoint can be either on expression using entirely global
10676 variables, or it can be on local variables.
10678 Watchpoints of the first kind are never auto-deleted, and even
10679 persist across program restarts. Since they can use variables
10680 from shared libraries, we need to reparse expression as libraries
10681 are loaded and unloaded.
10683 Watchpoints on local variables can also change meaning as result
10684 of solib event. For example, if a watchpoint uses both a local
10685 and a global variables in expression, it's a local watchpoint,
10686 but unloading of a shared library will make the expression
10687 invalid. This is not a very common use case, but we still
10688 re-evaluate expression, to avoid surprises to the user.
10690 Note that for local watchpoints, we re-evaluate it only if
10691 watchpoints frame id is still valid. If it's not, it means the
10692 watchpoint is out of scope and will be deleted soon. In fact,
10693 I'm not sure we'll ever be called in this case.
10695 If a local watchpoint's frame id is still valid, then
10696 w->exp_valid_block is likewise valid, and we can safely use it.
10698 Don't do anything about disabled watchpoints, since they will be
10699 reevaluated again when enabled. */
10700 update_watchpoint (w
, 1 /* reparse */);
10703 /* Implement the "insert" breakpoint_ops method for hardware watchpoints. */
10706 insert_watchpoint (struct bp_location
*bl
)
10708 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10709 int length
= w
->exact
? 1 : bl
->length
;
10711 return target_insert_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
10715 /* Implement the "remove" breakpoint_ops method for hardware watchpoints. */
10718 remove_watchpoint (struct bp_location
*bl
)
10720 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10721 int length
= w
->exact
? 1 : bl
->length
;
10723 return target_remove_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
10728 breakpoint_hit_watchpoint (const struct bp_location
*bl
,
10729 struct address_space
*aspace
, CORE_ADDR bp_addr
,
10730 const struct target_waitstatus
*ws
)
10732 struct breakpoint
*b
= bl
->owner
;
10733 struct watchpoint
*w
= (struct watchpoint
*) b
;
10735 /* Continuable hardware watchpoints are treated as non-existent if the
10736 reason we stopped wasn't a hardware watchpoint (we didn't stop on
10737 some data address). Otherwise gdb won't stop on a break instruction
10738 in the code (not from a breakpoint) when a hardware watchpoint has
10739 been defined. Also skip watchpoints which we know did not trigger
10740 (did not match the data address). */
10741 if (is_hardware_watchpoint (b
)
10742 && w
->watchpoint_triggered
== watch_triggered_no
)
10749 check_status_watchpoint (bpstat bs
)
10751 gdb_assert (is_watchpoint (bs
->breakpoint_at
));
10753 bpstat_check_watchpoint (bs
);
10756 /* Implement the "resources_needed" breakpoint_ops method for
10757 hardware watchpoints. */
10760 resources_needed_watchpoint (const struct bp_location
*bl
)
10762 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10763 int length
= w
->exact
? 1 : bl
->length
;
10765 return target_region_ok_for_hw_watchpoint (bl
->address
, length
);
10768 /* Implement the "works_in_software_mode" breakpoint_ops method for
10769 hardware watchpoints. */
10772 works_in_software_mode_watchpoint (const struct breakpoint
*b
)
10774 /* Read and access watchpoints only work with hardware support. */
10775 return b
->type
== bp_watchpoint
|| b
->type
== bp_hardware_watchpoint
;
10778 static enum print_stop_action
10779 print_it_watchpoint (bpstat bs
)
10781 struct cleanup
*old_chain
;
10782 struct breakpoint
*b
;
10783 struct ui_file
*stb
;
10784 enum print_stop_action result
;
10785 struct watchpoint
*w
;
10786 struct ui_out
*uiout
= current_uiout
;
10788 gdb_assert (bs
->bp_location_at
!= NULL
);
10790 b
= bs
->breakpoint_at
;
10791 w
= (struct watchpoint
*) b
;
10793 stb
= mem_fileopen ();
10794 old_chain
= make_cleanup_ui_file_delete (stb
);
10796 annotate_watchpoint (b
->number
);
10797 maybe_print_thread_hit_breakpoint (uiout
);
10801 case bp_watchpoint
:
10802 case bp_hardware_watchpoint
:
10803 if (ui_out_is_mi_like_p (uiout
))
10804 ui_out_field_string
10806 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
10808 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
10809 ui_out_text (uiout
, "\nOld value = ");
10810 watchpoint_value_print (bs
->old_val
, stb
);
10811 ui_out_field_stream (uiout
, "old", stb
);
10812 ui_out_text (uiout
, "\nNew value = ");
10813 watchpoint_value_print (w
->val
, stb
);
10814 ui_out_field_stream (uiout
, "new", stb
);
10815 ui_out_text (uiout
, "\n");
10816 /* More than one watchpoint may have been triggered. */
10817 result
= PRINT_UNKNOWN
;
10820 case bp_read_watchpoint
:
10821 if (ui_out_is_mi_like_p (uiout
))
10822 ui_out_field_string
10824 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
10826 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
10827 ui_out_text (uiout
, "\nValue = ");
10828 watchpoint_value_print (w
->val
, stb
);
10829 ui_out_field_stream (uiout
, "value", stb
);
10830 ui_out_text (uiout
, "\n");
10831 result
= PRINT_UNKNOWN
;
10834 case bp_access_watchpoint
:
10835 if (bs
->old_val
!= NULL
)
10837 if (ui_out_is_mi_like_p (uiout
))
10838 ui_out_field_string
10840 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
10842 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
10843 ui_out_text (uiout
, "\nOld value = ");
10844 watchpoint_value_print (bs
->old_val
, stb
);
10845 ui_out_field_stream (uiout
, "old", stb
);
10846 ui_out_text (uiout
, "\nNew value = ");
10851 if (ui_out_is_mi_like_p (uiout
))
10852 ui_out_field_string
10854 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
10855 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
10856 ui_out_text (uiout
, "\nValue = ");
10858 watchpoint_value_print (w
->val
, stb
);
10859 ui_out_field_stream (uiout
, "new", stb
);
10860 ui_out_text (uiout
, "\n");
10861 result
= PRINT_UNKNOWN
;
10864 result
= PRINT_UNKNOWN
;
10867 do_cleanups (old_chain
);
10871 /* Implement the "print_mention" breakpoint_ops method for hardware
10875 print_mention_watchpoint (struct breakpoint
*b
)
10877 struct cleanup
*ui_out_chain
;
10878 struct watchpoint
*w
= (struct watchpoint
*) b
;
10879 struct ui_out
*uiout
= current_uiout
;
10883 case bp_watchpoint
:
10884 ui_out_text (uiout
, "Watchpoint ");
10885 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
10887 case bp_hardware_watchpoint
:
10888 ui_out_text (uiout
, "Hardware watchpoint ");
10889 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
10891 case bp_read_watchpoint
:
10892 ui_out_text (uiout
, "Hardware read watchpoint ");
10893 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
10895 case bp_access_watchpoint
:
10896 ui_out_text (uiout
, "Hardware access (read/write) watchpoint ");
10897 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
10900 internal_error (__FILE__
, __LINE__
,
10901 _("Invalid hardware watchpoint type."));
10904 ui_out_field_int (uiout
, "number", b
->number
);
10905 ui_out_text (uiout
, ": ");
10906 ui_out_field_string (uiout
, "exp", w
->exp_string
);
10907 do_cleanups (ui_out_chain
);
10910 /* Implement the "print_recreate" breakpoint_ops method for
10914 print_recreate_watchpoint (struct breakpoint
*b
, struct ui_file
*fp
)
10916 struct watchpoint
*w
= (struct watchpoint
*) b
;
10920 case bp_watchpoint
:
10921 case bp_hardware_watchpoint
:
10922 fprintf_unfiltered (fp
, "watch");
10924 case bp_read_watchpoint
:
10925 fprintf_unfiltered (fp
, "rwatch");
10927 case bp_access_watchpoint
:
10928 fprintf_unfiltered (fp
, "awatch");
10931 internal_error (__FILE__
, __LINE__
,
10932 _("Invalid watchpoint type."));
10935 fprintf_unfiltered (fp
, " %s", w
->exp_string
);
10936 print_recreate_thread (b
, fp
);
10939 /* Implement the "explains_signal" breakpoint_ops method for
10943 explains_signal_watchpoint (struct breakpoint
*b
, enum gdb_signal sig
)
10945 /* A software watchpoint cannot cause a signal other than
10946 GDB_SIGNAL_TRAP. */
10947 if (b
->type
== bp_watchpoint
&& sig
!= GDB_SIGNAL_TRAP
)
10953 /* The breakpoint_ops structure to be used in hardware watchpoints. */
10955 static struct breakpoint_ops watchpoint_breakpoint_ops
;
10957 /* Implement the "insert" breakpoint_ops method for
10958 masked hardware watchpoints. */
10961 insert_masked_watchpoint (struct bp_location
*bl
)
10963 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10965 return target_insert_mask_watchpoint (bl
->address
, w
->hw_wp_mask
,
10966 bl
->watchpoint_type
);
10969 /* Implement the "remove" breakpoint_ops method for
10970 masked hardware watchpoints. */
10973 remove_masked_watchpoint (struct bp_location
*bl
)
10975 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10977 return target_remove_mask_watchpoint (bl
->address
, w
->hw_wp_mask
,
10978 bl
->watchpoint_type
);
10981 /* Implement the "resources_needed" breakpoint_ops method for
10982 masked hardware watchpoints. */
10985 resources_needed_masked_watchpoint (const struct bp_location
*bl
)
10987 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10989 return target_masked_watch_num_registers (bl
->address
, w
->hw_wp_mask
);
10992 /* Implement the "works_in_software_mode" breakpoint_ops method for
10993 masked hardware watchpoints. */
10996 works_in_software_mode_masked_watchpoint (const struct breakpoint
*b
)
11001 /* Implement the "print_it" breakpoint_ops method for
11002 masked hardware watchpoints. */
11004 static enum print_stop_action
11005 print_it_masked_watchpoint (bpstat bs
)
11007 struct breakpoint
*b
= bs
->breakpoint_at
;
11008 struct ui_out
*uiout
= current_uiout
;
11010 /* Masked watchpoints have only one location. */
11011 gdb_assert (b
->loc
&& b
->loc
->next
== NULL
);
11013 annotate_watchpoint (b
->number
);
11014 maybe_print_thread_hit_breakpoint (uiout
);
11018 case bp_hardware_watchpoint
:
11019 if (ui_out_is_mi_like_p (uiout
))
11020 ui_out_field_string
11022 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
11025 case bp_read_watchpoint
:
11026 if (ui_out_is_mi_like_p (uiout
))
11027 ui_out_field_string
11029 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
11032 case bp_access_watchpoint
:
11033 if (ui_out_is_mi_like_p (uiout
))
11034 ui_out_field_string
11036 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
11039 internal_error (__FILE__
, __LINE__
,
11040 _("Invalid hardware watchpoint type."));
11044 ui_out_text (uiout
, _("\n\
11045 Check the underlying instruction at PC for the memory\n\
11046 address and value which triggered this watchpoint.\n"));
11047 ui_out_text (uiout
, "\n");
11049 /* More than one watchpoint may have been triggered. */
11050 return PRINT_UNKNOWN
;
11053 /* Implement the "print_one_detail" breakpoint_ops method for
11054 masked hardware watchpoints. */
11057 print_one_detail_masked_watchpoint (const struct breakpoint
*b
,
11058 struct ui_out
*uiout
)
11060 struct watchpoint
*w
= (struct watchpoint
*) b
;
11062 /* Masked watchpoints have only one location. */
11063 gdb_assert (b
->loc
&& b
->loc
->next
== NULL
);
11065 ui_out_text (uiout
, "\tmask ");
11066 ui_out_field_core_addr (uiout
, "mask", b
->loc
->gdbarch
, w
->hw_wp_mask
);
11067 ui_out_text (uiout
, "\n");
11070 /* Implement the "print_mention" breakpoint_ops method for
11071 masked hardware watchpoints. */
11074 print_mention_masked_watchpoint (struct breakpoint
*b
)
11076 struct watchpoint
*w
= (struct watchpoint
*) b
;
11077 struct ui_out
*uiout
= current_uiout
;
11078 struct cleanup
*ui_out_chain
;
11082 case bp_hardware_watchpoint
:
11083 ui_out_text (uiout
, "Masked hardware watchpoint ");
11084 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
11086 case bp_read_watchpoint
:
11087 ui_out_text (uiout
, "Masked hardware read watchpoint ");
11088 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
11090 case bp_access_watchpoint
:
11091 ui_out_text (uiout
, "Masked hardware access (read/write) watchpoint ");
11092 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
11095 internal_error (__FILE__
, __LINE__
,
11096 _("Invalid hardware watchpoint type."));
11099 ui_out_field_int (uiout
, "number", b
->number
);
11100 ui_out_text (uiout
, ": ");
11101 ui_out_field_string (uiout
, "exp", w
->exp_string
);
11102 do_cleanups (ui_out_chain
);
11105 /* Implement the "print_recreate" breakpoint_ops method for
11106 masked hardware watchpoints. */
11109 print_recreate_masked_watchpoint (struct breakpoint
*b
, struct ui_file
*fp
)
11111 struct watchpoint
*w
= (struct watchpoint
*) b
;
11116 case bp_hardware_watchpoint
:
11117 fprintf_unfiltered (fp
, "watch");
11119 case bp_read_watchpoint
:
11120 fprintf_unfiltered (fp
, "rwatch");
11122 case bp_access_watchpoint
:
11123 fprintf_unfiltered (fp
, "awatch");
11126 internal_error (__FILE__
, __LINE__
,
11127 _("Invalid hardware watchpoint type."));
11130 sprintf_vma (tmp
, w
->hw_wp_mask
);
11131 fprintf_unfiltered (fp
, " %s mask 0x%s", w
->exp_string
, tmp
);
11132 print_recreate_thread (b
, fp
);
11135 /* The breakpoint_ops structure to be used in masked hardware watchpoints. */
11137 static struct breakpoint_ops masked_watchpoint_breakpoint_ops
;
11139 /* Tell whether the given watchpoint is a masked hardware watchpoint. */
11142 is_masked_watchpoint (const struct breakpoint
*b
)
11144 return b
->ops
== &masked_watchpoint_breakpoint_ops
;
11147 /* accessflag: hw_write: watch write,
11148 hw_read: watch read,
11149 hw_access: watch access (read or write) */
11151 watch_command_1 (const char *arg
, int accessflag
, int from_tty
,
11152 int just_location
, int internal
)
11154 struct breakpoint
*b
, *scope_breakpoint
= NULL
;
11155 struct expression
*exp
;
11156 const struct block
*exp_valid_block
= NULL
, *cond_exp_valid_block
= NULL
;
11157 struct value
*val
, *mark
, *result
;
11158 int saved_bitpos
= 0, saved_bitsize
= 0;
11159 struct frame_info
*frame
;
11160 const char *exp_start
= NULL
;
11161 const char *exp_end
= NULL
;
11162 const char *tok
, *end_tok
;
11164 const char *cond_start
= NULL
;
11165 const char *cond_end
= NULL
;
11166 enum bptype bp_type
;
11169 /* Flag to indicate whether we are going to use masks for
11170 the hardware watchpoint. */
11172 CORE_ADDR mask
= 0;
11173 struct watchpoint
*w
;
11175 struct cleanup
*back_to
;
11177 /* Make sure that we actually have parameters to parse. */
11178 if (arg
!= NULL
&& arg
[0] != '\0')
11180 const char *value_start
;
11182 exp_end
= arg
+ strlen (arg
);
11184 /* Look for "parameter value" pairs at the end
11185 of the arguments string. */
11186 for (tok
= exp_end
- 1; tok
> arg
; tok
--)
11188 /* Skip whitespace at the end of the argument list. */
11189 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
11192 /* Find the beginning of the last token.
11193 This is the value of the parameter. */
11194 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
11196 value_start
= tok
+ 1;
11198 /* Skip whitespace. */
11199 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
11204 /* Find the beginning of the second to last token.
11205 This is the parameter itself. */
11206 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
11209 toklen
= end_tok
- tok
+ 1;
11211 if (toklen
== 6 && startswith (tok
, "thread"))
11213 struct thread_info
*thr
;
11214 /* At this point we've found a "thread" token, which means
11215 the user is trying to set a watchpoint that triggers
11216 only in a specific thread. */
11220 error(_("You can specify only one thread."));
11222 /* Extract the thread ID from the next token. */
11223 thr
= parse_thread_id (value_start
, &endp
);
11225 /* Check if the user provided a valid thread ID. */
11226 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
11227 invalid_thread_id_error (value_start
);
11229 thread
= thr
->global_num
;
11231 else if (toklen
== 4 && startswith (tok
, "mask"))
11233 /* We've found a "mask" token, which means the user wants to
11234 create a hardware watchpoint that is going to have the mask
11236 struct value
*mask_value
, *mark
;
11239 error(_("You can specify only one mask."));
11241 use_mask
= just_location
= 1;
11243 mark
= value_mark ();
11244 mask_value
= parse_to_comma_and_eval (&value_start
);
11245 mask
= value_as_address (mask_value
);
11246 value_free_to_mark (mark
);
11249 /* We didn't recognize what we found. We should stop here. */
11252 /* Truncate the string and get rid of the "parameter value" pair before
11253 the arguments string is parsed by the parse_exp_1 function. */
11260 /* Parse the rest of the arguments. From here on out, everything
11261 is in terms of a newly allocated string instead of the original
11263 innermost_block
= NULL
;
11264 expression
= savestring (arg
, exp_end
- arg
);
11265 back_to
= make_cleanup (xfree
, expression
);
11266 exp_start
= arg
= expression
;
11267 exp
= parse_exp_1 (&arg
, 0, 0, 0);
11269 /* Remove trailing whitespace from the expression before saving it.
11270 This makes the eventual display of the expression string a bit
11272 while (exp_end
> exp_start
&& (exp_end
[-1] == ' ' || exp_end
[-1] == '\t'))
11275 /* Checking if the expression is not constant. */
11276 if (watchpoint_exp_is_const (exp
))
11280 len
= exp_end
- exp_start
;
11281 while (len
> 0 && isspace (exp_start
[len
- 1]))
11283 error (_("Cannot watch constant value `%.*s'."), len
, exp_start
);
11286 exp_valid_block
= innermost_block
;
11287 mark
= value_mark ();
11288 fetch_subexp_value (exp
, &pc
, &val
, &result
, NULL
, just_location
);
11290 if (val
!= NULL
&& just_location
)
11292 saved_bitpos
= value_bitpos (val
);
11293 saved_bitsize
= value_bitsize (val
);
11300 exp_valid_block
= NULL
;
11301 val
= value_addr (result
);
11302 release_value (val
);
11303 value_free_to_mark (mark
);
11307 ret
= target_masked_watch_num_registers (value_as_address (val
),
11310 error (_("This target does not support masked watchpoints."));
11311 else if (ret
== -2)
11312 error (_("Invalid mask or memory region."));
11315 else if (val
!= NULL
)
11316 release_value (val
);
11318 tok
= skip_spaces_const (arg
);
11319 end_tok
= skip_to_space_const (tok
);
11321 toklen
= end_tok
- tok
;
11322 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
11324 struct expression
*cond
;
11326 innermost_block
= NULL
;
11327 tok
= cond_start
= end_tok
+ 1;
11328 cond
= parse_exp_1 (&tok
, 0, 0, 0);
11330 /* The watchpoint expression may not be local, but the condition
11331 may still be. E.g.: `watch global if local > 0'. */
11332 cond_exp_valid_block
= innermost_block
;
11338 error (_("Junk at end of command."));
11340 frame
= block_innermost_frame (exp_valid_block
);
11342 /* If the expression is "local", then set up a "watchpoint scope"
11343 breakpoint at the point where we've left the scope of the watchpoint
11344 expression. Create the scope breakpoint before the watchpoint, so
11345 that we will encounter it first in bpstat_stop_status. */
11346 if (exp_valid_block
&& frame
)
11348 if (frame_id_p (frame_unwind_caller_id (frame
)))
11351 = create_internal_breakpoint (frame_unwind_caller_arch (frame
),
11352 frame_unwind_caller_pc (frame
),
11353 bp_watchpoint_scope
,
11354 &momentary_breakpoint_ops
);
11356 scope_breakpoint
->enable_state
= bp_enabled
;
11358 /* Automatically delete the breakpoint when it hits. */
11359 scope_breakpoint
->disposition
= disp_del
;
11361 /* Only break in the proper frame (help with recursion). */
11362 scope_breakpoint
->frame_id
= frame_unwind_caller_id (frame
);
11364 /* Set the address at which we will stop. */
11365 scope_breakpoint
->loc
->gdbarch
11366 = frame_unwind_caller_arch (frame
);
11367 scope_breakpoint
->loc
->requested_address
11368 = frame_unwind_caller_pc (frame
);
11369 scope_breakpoint
->loc
->address
11370 = adjust_breakpoint_address (scope_breakpoint
->loc
->gdbarch
,
11371 scope_breakpoint
->loc
->requested_address
,
11372 scope_breakpoint
->type
);
11376 /* Now set up the breakpoint. We create all watchpoints as hardware
11377 watchpoints here even if hardware watchpoints are turned off, a call
11378 to update_watchpoint later in this function will cause the type to
11379 drop back to bp_watchpoint (software watchpoint) if required. */
11381 if (accessflag
== hw_read
)
11382 bp_type
= bp_read_watchpoint
;
11383 else if (accessflag
== hw_access
)
11384 bp_type
= bp_access_watchpoint
;
11386 bp_type
= bp_hardware_watchpoint
;
11388 w
= XCNEW (struct watchpoint
);
11391 init_raw_breakpoint_without_location (b
, NULL
, bp_type
,
11392 &masked_watchpoint_breakpoint_ops
);
11394 init_raw_breakpoint_without_location (b
, NULL
, bp_type
,
11395 &watchpoint_breakpoint_ops
);
11396 b
->thread
= thread
;
11397 b
->disposition
= disp_donttouch
;
11398 b
->pspace
= current_program_space
;
11400 w
->exp_valid_block
= exp_valid_block
;
11401 w
->cond_exp_valid_block
= cond_exp_valid_block
;
11404 struct type
*t
= value_type (val
);
11405 CORE_ADDR addr
= value_as_address (val
);
11408 t
= check_typedef (TYPE_TARGET_TYPE (check_typedef (t
)));
11409 name
= type_to_string (t
);
11411 w
->exp_string_reparse
= xstrprintf ("* (%s *) %s", name
,
11412 core_addr_to_string (addr
));
11415 w
->exp_string
= xstrprintf ("-location %.*s",
11416 (int) (exp_end
- exp_start
), exp_start
);
11418 /* The above expression is in C. */
11419 b
->language
= language_c
;
11422 w
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
11426 w
->hw_wp_mask
= mask
;
11431 w
->val_bitpos
= saved_bitpos
;
11432 w
->val_bitsize
= saved_bitsize
;
11437 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
11439 b
->cond_string
= 0;
11443 w
->watchpoint_frame
= get_frame_id (frame
);
11444 w
->watchpoint_thread
= inferior_ptid
;
11448 w
->watchpoint_frame
= null_frame_id
;
11449 w
->watchpoint_thread
= null_ptid
;
11452 if (scope_breakpoint
!= NULL
)
11454 /* The scope breakpoint is related to the watchpoint. We will
11455 need to act on them together. */
11456 b
->related_breakpoint
= scope_breakpoint
;
11457 scope_breakpoint
->related_breakpoint
= b
;
11460 if (!just_location
)
11461 value_free_to_mark (mark
);
11465 /* Finally update the new watchpoint. This creates the locations
11466 that should be inserted. */
11467 update_watchpoint (w
, 1);
11469 CATCH (e
, RETURN_MASK_ALL
)
11471 delete_breakpoint (b
);
11472 throw_exception (e
);
11476 install_breakpoint (internal
, b
, 1);
11477 do_cleanups (back_to
);
11480 /* Return count of debug registers needed to watch the given expression.
11481 If the watchpoint cannot be handled in hardware return zero. */
11484 can_use_hardware_watchpoint (struct value
*v
)
11486 int found_memory_cnt
= 0;
11487 struct value
*head
= v
;
11489 /* Did the user specifically forbid us to use hardware watchpoints? */
11490 if (!can_use_hw_watchpoints
)
11493 /* Make sure that the value of the expression depends only upon
11494 memory contents, and values computed from them within GDB. If we
11495 find any register references or function calls, we can't use a
11496 hardware watchpoint.
11498 The idea here is that evaluating an expression generates a series
11499 of values, one holding the value of every subexpression. (The
11500 expression a*b+c has five subexpressions: a, b, a*b, c, and
11501 a*b+c.) GDB's values hold almost enough information to establish
11502 the criteria given above --- they identify memory lvalues,
11503 register lvalues, computed values, etcetera. So we can evaluate
11504 the expression, and then scan the chain of values that leaves
11505 behind to decide whether we can detect any possible change to the
11506 expression's final value using only hardware watchpoints.
11508 However, I don't think that the values returned by inferior
11509 function calls are special in any way. So this function may not
11510 notice that an expression involving an inferior function call
11511 can't be watched with hardware watchpoints. FIXME. */
11512 for (; v
; v
= value_next (v
))
11514 if (VALUE_LVAL (v
) == lval_memory
)
11516 if (v
!= head
&& value_lazy (v
))
11517 /* A lazy memory lvalue in the chain is one that GDB never
11518 needed to fetch; we either just used its address (e.g.,
11519 `a' in `a.b') or we never needed it at all (e.g., `a'
11520 in `a,b'). This doesn't apply to HEAD; if that is
11521 lazy then it was not readable, but watch it anyway. */
11525 /* Ahh, memory we actually used! Check if we can cover
11526 it with hardware watchpoints. */
11527 struct type
*vtype
= check_typedef (value_type (v
));
11529 /* We only watch structs and arrays if user asked for it
11530 explicitly, never if they just happen to appear in a
11531 middle of some value chain. */
11533 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
11534 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
11536 CORE_ADDR vaddr
= value_address (v
);
11540 len
= (target_exact_watchpoints
11541 && is_scalar_type_recursive (vtype
))?
11542 1 : TYPE_LENGTH (value_type (v
));
11544 num_regs
= target_region_ok_for_hw_watchpoint (vaddr
, len
);
11548 found_memory_cnt
+= num_regs
;
11552 else if (VALUE_LVAL (v
) != not_lval
11553 && deprecated_value_modifiable (v
) == 0)
11554 return 0; /* These are values from the history (e.g., $1). */
11555 else if (VALUE_LVAL (v
) == lval_register
)
11556 return 0; /* Cannot watch a register with a HW watchpoint. */
11559 /* The expression itself looks suitable for using a hardware
11560 watchpoint, but give the target machine a chance to reject it. */
11561 return found_memory_cnt
;
11565 watch_command_wrapper (char *arg
, int from_tty
, int internal
)
11567 watch_command_1 (arg
, hw_write
, from_tty
, 0, internal
);
11570 /* A helper function that looks for the "-location" argument and then
11571 calls watch_command_1. */
11574 watch_maybe_just_location (char *arg
, int accessflag
, int from_tty
)
11576 int just_location
= 0;
11579 && (check_for_argument (&arg
, "-location", sizeof ("-location") - 1)
11580 || check_for_argument (&arg
, "-l", sizeof ("-l") - 1)))
11582 arg
= skip_spaces (arg
);
11586 watch_command_1 (arg
, accessflag
, from_tty
, just_location
, 0);
11590 watch_command (char *arg
, int from_tty
)
11592 watch_maybe_just_location (arg
, hw_write
, from_tty
);
11596 rwatch_command_wrapper (char *arg
, int from_tty
, int internal
)
11598 watch_command_1 (arg
, hw_read
, from_tty
, 0, internal
);
11602 rwatch_command (char *arg
, int from_tty
)
11604 watch_maybe_just_location (arg
, hw_read
, from_tty
);
11608 awatch_command_wrapper (char *arg
, int from_tty
, int internal
)
11610 watch_command_1 (arg
, hw_access
, from_tty
, 0, internal
);
11614 awatch_command (char *arg
, int from_tty
)
11616 watch_maybe_just_location (arg
, hw_access
, from_tty
);
11620 /* Data for the FSM that manages the until(location)/advance commands
11621 in infcmd.c. Here because it uses the mechanisms of
11624 struct until_break_fsm
11626 /* The base class. */
11627 struct thread_fsm thread_fsm
;
11629 /* The thread that as current when the command was executed. */
11632 /* The breakpoint set at the destination location. */
11633 struct breakpoint
*location_breakpoint
;
11635 /* Breakpoint set at the return address in the caller frame. May be
11637 struct breakpoint
*caller_breakpoint
;
11640 static void until_break_fsm_clean_up (struct thread_fsm
*self
,
11641 struct thread_info
*thread
);
11642 static int until_break_fsm_should_stop (struct thread_fsm
*self
,
11643 struct thread_info
*thread
);
11644 static enum async_reply_reason
11645 until_break_fsm_async_reply_reason (struct thread_fsm
*self
);
11647 /* until_break_fsm's vtable. */
11649 static struct thread_fsm_ops until_break_fsm_ops
=
11652 until_break_fsm_clean_up
,
11653 until_break_fsm_should_stop
,
11654 NULL
, /* return_value */
11655 until_break_fsm_async_reply_reason
,
11658 /* Allocate a new until_break_command_fsm. */
11660 static struct until_break_fsm
*
11661 new_until_break_fsm (struct interp
*cmd_interp
, int thread
,
11662 struct breakpoint
*location_breakpoint
,
11663 struct breakpoint
*caller_breakpoint
)
11665 struct until_break_fsm
*sm
;
11667 sm
= XCNEW (struct until_break_fsm
);
11668 thread_fsm_ctor (&sm
->thread_fsm
, &until_break_fsm_ops
, cmd_interp
);
11670 sm
->thread
= thread
;
11671 sm
->location_breakpoint
= location_breakpoint
;
11672 sm
->caller_breakpoint
= caller_breakpoint
;
11677 /* Implementation of the 'should_stop' FSM method for the
11678 until(location)/advance commands. */
11681 until_break_fsm_should_stop (struct thread_fsm
*self
,
11682 struct thread_info
*tp
)
11684 struct until_break_fsm
*sm
= (struct until_break_fsm
*) self
;
11686 if (bpstat_find_breakpoint (tp
->control
.stop_bpstat
,
11687 sm
->location_breakpoint
) != NULL
11688 || (sm
->caller_breakpoint
!= NULL
11689 && bpstat_find_breakpoint (tp
->control
.stop_bpstat
,
11690 sm
->caller_breakpoint
) != NULL
))
11691 thread_fsm_set_finished (self
);
11696 /* Implementation of the 'clean_up' FSM method for the
11697 until(location)/advance commands. */
11700 until_break_fsm_clean_up (struct thread_fsm
*self
,
11701 struct thread_info
*thread
)
11703 struct until_break_fsm
*sm
= (struct until_break_fsm
*) self
;
11705 /* Clean up our temporary breakpoints. */
11706 if (sm
->location_breakpoint
!= NULL
)
11708 delete_breakpoint (sm
->location_breakpoint
);
11709 sm
->location_breakpoint
= NULL
;
11711 if (sm
->caller_breakpoint
!= NULL
)
11713 delete_breakpoint (sm
->caller_breakpoint
);
11714 sm
->caller_breakpoint
= NULL
;
11716 delete_longjmp_breakpoint (sm
->thread
);
11719 /* Implementation of the 'async_reply_reason' FSM method for the
11720 until(location)/advance commands. */
11722 static enum async_reply_reason
11723 until_break_fsm_async_reply_reason (struct thread_fsm
*self
)
11725 return EXEC_ASYNC_LOCATION_REACHED
;
11729 until_break_command (char *arg
, int from_tty
, int anywhere
)
11731 struct symtabs_and_lines sals
;
11732 struct symtab_and_line sal
;
11733 struct frame_info
*frame
;
11734 struct gdbarch
*frame_gdbarch
;
11735 struct frame_id stack_frame_id
;
11736 struct frame_id caller_frame_id
;
11737 struct breakpoint
*location_breakpoint
;
11738 struct breakpoint
*caller_breakpoint
= NULL
;
11739 struct cleanup
*old_chain
, *cleanup
;
11741 struct thread_info
*tp
;
11742 struct event_location
*location
;
11743 struct until_break_fsm
*sm
;
11745 clear_proceed_status (0);
11747 /* Set a breakpoint where the user wants it and at return from
11750 location
= string_to_event_location (&arg
, current_language
);
11751 cleanup
= make_cleanup_delete_event_location (location
);
11753 if (last_displayed_sal_is_valid ())
11754 sals
= decode_line_1 (location
, DECODE_LINE_FUNFIRSTLINE
, NULL
,
11755 get_last_displayed_symtab (),
11756 get_last_displayed_line ());
11758 sals
= decode_line_1 (location
, DECODE_LINE_FUNFIRSTLINE
,
11759 NULL
, (struct symtab
*) NULL
, 0);
11761 if (sals
.nelts
!= 1)
11762 error (_("Couldn't get information on specified line."));
11764 sal
= sals
.sals
[0];
11765 xfree (sals
.sals
); /* malloc'd, so freed. */
11768 error (_("Junk at end of arguments."));
11770 resolve_sal_pc (&sal
);
11772 tp
= inferior_thread ();
11773 thread
= tp
->global_num
;
11775 old_chain
= make_cleanup (null_cleanup
, NULL
);
11777 /* Note linespec handling above invalidates the frame chain.
11778 Installing a breakpoint also invalidates the frame chain (as it
11779 may need to switch threads), so do any frame handling before
11782 frame
= get_selected_frame (NULL
);
11783 frame_gdbarch
= get_frame_arch (frame
);
11784 stack_frame_id
= get_stack_frame_id (frame
);
11785 caller_frame_id
= frame_unwind_caller_id (frame
);
11787 /* Keep within the current frame, or in frames called by the current
11790 if (frame_id_p (caller_frame_id
))
11792 struct symtab_and_line sal2
;
11793 struct gdbarch
*caller_gdbarch
;
11795 sal2
= find_pc_line (frame_unwind_caller_pc (frame
), 0);
11796 sal2
.pc
= frame_unwind_caller_pc (frame
);
11797 caller_gdbarch
= frame_unwind_caller_arch (frame
);
11798 caller_breakpoint
= set_momentary_breakpoint (caller_gdbarch
,
11802 make_cleanup_delete_breakpoint (caller_breakpoint
);
11804 set_longjmp_breakpoint (tp
, caller_frame_id
);
11805 make_cleanup (delete_longjmp_breakpoint_cleanup
, &thread
);
11808 /* set_momentary_breakpoint could invalidate FRAME. */
11812 /* If the user told us to continue until a specified location,
11813 we don't specify a frame at which we need to stop. */
11814 location_breakpoint
= set_momentary_breakpoint (frame_gdbarch
, sal
,
11815 null_frame_id
, bp_until
);
11817 /* Otherwise, specify the selected frame, because we want to stop
11818 only at the very same frame. */
11819 location_breakpoint
= set_momentary_breakpoint (frame_gdbarch
, sal
,
11820 stack_frame_id
, bp_until
);
11821 make_cleanup_delete_breakpoint (location_breakpoint
);
11823 sm
= new_until_break_fsm (command_interp (), tp
->global_num
,
11824 location_breakpoint
, caller_breakpoint
);
11825 tp
->thread_fsm
= &sm
->thread_fsm
;
11827 discard_cleanups (old_chain
);
11829 proceed (-1, GDB_SIGNAL_DEFAULT
);
11831 do_cleanups (cleanup
);
11834 /* This function attempts to parse an optional "if <cond>" clause
11835 from the arg string. If one is not found, it returns NULL.
11837 Else, it returns a pointer to the condition string. (It does not
11838 attempt to evaluate the string against a particular block.) And,
11839 it updates arg to point to the first character following the parsed
11840 if clause in the arg string. */
11843 ep_parse_optional_if_clause (char **arg
)
11847 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
11850 /* Skip the "if" keyword. */
11853 /* Skip any extra leading whitespace, and record the start of the
11854 condition string. */
11855 *arg
= skip_spaces (*arg
);
11856 cond_string
= *arg
;
11858 /* Assume that the condition occupies the remainder of the arg
11860 (*arg
) += strlen (cond_string
);
11862 return cond_string
;
11865 /* Commands to deal with catching events, such as signals, exceptions,
11866 process start/exit, etc. */
11870 catch_fork_temporary
, catch_vfork_temporary
,
11871 catch_fork_permanent
, catch_vfork_permanent
11876 catch_fork_command_1 (char *arg
, int from_tty
,
11877 struct cmd_list_element
*command
)
11879 struct gdbarch
*gdbarch
= get_current_arch ();
11880 char *cond_string
= NULL
;
11881 catch_fork_kind fork_kind
;
11884 fork_kind
= (catch_fork_kind
) (uintptr_t) get_cmd_context (command
);
11885 tempflag
= (fork_kind
== catch_fork_temporary
11886 || fork_kind
== catch_vfork_temporary
);
11890 arg
= skip_spaces (arg
);
11892 /* The allowed syntax is:
11894 catch [v]fork if <cond>
11896 First, check if there's an if clause. */
11897 cond_string
= ep_parse_optional_if_clause (&arg
);
11899 if ((*arg
!= '\0') && !isspace (*arg
))
11900 error (_("Junk at end of arguments."));
11902 /* If this target supports it, create a fork or vfork catchpoint
11903 and enable reporting of such events. */
11906 case catch_fork_temporary
:
11907 case catch_fork_permanent
:
11908 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
11909 &catch_fork_breakpoint_ops
);
11911 case catch_vfork_temporary
:
11912 case catch_vfork_permanent
:
11913 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
11914 &catch_vfork_breakpoint_ops
);
11917 error (_("unsupported or unknown fork kind; cannot catch it"));
11923 catch_exec_command_1 (char *arg
, int from_tty
,
11924 struct cmd_list_element
*command
)
11926 struct exec_catchpoint
*c
;
11927 struct gdbarch
*gdbarch
= get_current_arch ();
11929 char *cond_string
= NULL
;
11931 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
11935 arg
= skip_spaces (arg
);
11937 /* The allowed syntax is:
11939 catch exec if <cond>
11941 First, check if there's an if clause. */
11942 cond_string
= ep_parse_optional_if_clause (&arg
);
11944 if ((*arg
!= '\0') && !isspace (*arg
))
11945 error (_("Junk at end of arguments."));
11947 c
= XNEW (struct exec_catchpoint
);
11948 init_catchpoint (&c
->base
, gdbarch
, tempflag
, cond_string
,
11949 &catch_exec_breakpoint_ops
);
11950 c
->exec_pathname
= NULL
;
11952 install_breakpoint (0, &c
->base
, 1);
11956 init_ada_exception_breakpoint (struct breakpoint
*b
,
11957 struct gdbarch
*gdbarch
,
11958 struct symtab_and_line sal
,
11960 const struct breakpoint_ops
*ops
,
11967 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
11969 loc_gdbarch
= gdbarch
;
11971 describe_other_breakpoints (loc_gdbarch
,
11972 sal
.pspace
, sal
.pc
, sal
.section
, -1);
11973 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
11974 version for exception catchpoints, because two catchpoints
11975 used for different exception names will use the same address.
11976 In this case, a "breakpoint ... also set at..." warning is
11977 unproductive. Besides, the warning phrasing is also a bit
11978 inappropriate, we should use the word catchpoint, and tell
11979 the user what type of catchpoint it is. The above is good
11980 enough for now, though. */
11983 init_raw_breakpoint (b
, gdbarch
, sal
, bp_breakpoint
, ops
);
11985 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
11986 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
11987 b
->location
= string_to_event_location (&addr_string
,
11988 language_def (language_ada
));
11989 b
->language
= language_ada
;
11993 catch_command (char *arg
, int from_tty
)
11995 error (_("Catch requires an event name."));
12000 tcatch_command (char *arg
, int from_tty
)
12002 error (_("Catch requires an event name."));
12005 /* A qsort comparison function that sorts breakpoints in order. */
12008 compare_breakpoints (const void *a
, const void *b
)
12010 const breakpoint_p
*ba
= (const breakpoint_p
*) a
;
12011 uintptr_t ua
= (uintptr_t) *ba
;
12012 const breakpoint_p
*bb
= (const breakpoint_p
*) b
;
12013 uintptr_t ub
= (uintptr_t) *bb
;
12015 if ((*ba
)->number
< (*bb
)->number
)
12017 else if ((*ba
)->number
> (*bb
)->number
)
12020 /* Now sort by address, in case we see, e..g, two breakpoints with
12024 return ua
> ub
? 1 : 0;
12027 /* Delete breakpoints by address or line. */
12030 clear_command (char *arg
, int from_tty
)
12032 struct breakpoint
*b
, *prev
;
12033 VEC(breakpoint_p
) *found
= 0;
12036 struct symtabs_and_lines sals
;
12037 struct symtab_and_line sal
;
12039 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
12043 sals
= decode_line_with_current_source (arg
,
12044 (DECODE_LINE_FUNFIRSTLINE
12045 | DECODE_LINE_LIST_MODE
));
12046 make_cleanup (xfree
, sals
.sals
);
12051 sals
.sals
= XNEW (struct symtab_and_line
);
12052 make_cleanup (xfree
, sals
.sals
);
12053 init_sal (&sal
); /* Initialize to zeroes. */
12055 /* Set sal's line, symtab, pc, and pspace to the values
12056 corresponding to the last call to print_frame_info. If the
12057 codepoint is not valid, this will set all the fields to 0. */
12058 get_last_displayed_sal (&sal
);
12059 if (sal
.symtab
== 0)
12060 error (_("No source file specified."));
12062 sals
.sals
[0] = sal
;
12068 /* We don't call resolve_sal_pc here. That's not as bad as it
12069 seems, because all existing breakpoints typically have both
12070 file/line and pc set. So, if clear is given file/line, we can
12071 match this to existing breakpoint without obtaining pc at all.
12073 We only support clearing given the address explicitly
12074 present in breakpoint table. Say, we've set breakpoint
12075 at file:line. There were several PC values for that file:line,
12076 due to optimization, all in one block.
12078 We've picked one PC value. If "clear" is issued with another
12079 PC corresponding to the same file:line, the breakpoint won't
12080 be cleared. We probably can still clear the breakpoint, but
12081 since the other PC value is never presented to user, user
12082 can only find it by guessing, and it does not seem important
12083 to support that. */
12085 /* For each line spec given, delete bps which correspond to it. Do
12086 it in two passes, solely to preserve the current behavior that
12087 from_tty is forced true if we delete more than one
12091 make_cleanup (VEC_cleanup (breakpoint_p
), &found
);
12092 for (i
= 0; i
< sals
.nelts
; i
++)
12094 const char *sal_fullname
;
12096 /* If exact pc given, clear bpts at that pc.
12097 If line given (pc == 0), clear all bpts on specified line.
12098 If defaulting, clear all bpts on default line
12101 defaulting sal.pc != 0 tests to do
12106 1 0 <can't happen> */
12108 sal
= sals
.sals
[i
];
12109 sal_fullname
= (sal
.symtab
== NULL
12110 ? NULL
: symtab_to_fullname (sal
.symtab
));
12112 /* Find all matching breakpoints and add them to 'found'. */
12113 ALL_BREAKPOINTS (b
)
12116 /* Are we going to delete b? */
12117 if (b
->type
!= bp_none
&& !is_watchpoint (b
))
12119 struct bp_location
*loc
= b
->loc
;
12120 for (; loc
; loc
= loc
->next
)
12122 /* If the user specified file:line, don't allow a PC
12123 match. This matches historical gdb behavior. */
12124 int pc_match
= (!sal
.explicit_line
12126 && (loc
->pspace
== sal
.pspace
)
12127 && (loc
->address
== sal
.pc
)
12128 && (!section_is_overlay (loc
->section
)
12129 || loc
->section
== sal
.section
));
12130 int line_match
= 0;
12132 if ((default_match
|| sal
.explicit_line
)
12133 && loc
->symtab
!= NULL
12134 && sal_fullname
!= NULL
12135 && sal
.pspace
== loc
->pspace
12136 && loc
->line_number
== sal
.line
12137 && filename_cmp (symtab_to_fullname (loc
->symtab
),
12138 sal_fullname
) == 0)
12141 if (pc_match
|| line_match
)
12150 VEC_safe_push(breakpoint_p
, found
, b
);
12154 /* Now go thru the 'found' chain and delete them. */
12155 if (VEC_empty(breakpoint_p
, found
))
12158 error (_("No breakpoint at %s."), arg
);
12160 error (_("No breakpoint at this line."));
12163 /* Remove duplicates from the vec. */
12164 qsort (VEC_address (breakpoint_p
, found
),
12165 VEC_length (breakpoint_p
, found
),
12166 sizeof (breakpoint_p
),
12167 compare_breakpoints
);
12168 prev
= VEC_index (breakpoint_p
, found
, 0);
12169 for (ix
= 1; VEC_iterate (breakpoint_p
, found
, ix
, b
); ++ix
)
12173 VEC_ordered_remove (breakpoint_p
, found
, ix
);
12178 if (VEC_length(breakpoint_p
, found
) > 1)
12179 from_tty
= 1; /* Always report if deleted more than one. */
12182 if (VEC_length(breakpoint_p
, found
) == 1)
12183 printf_unfiltered (_("Deleted breakpoint "));
12185 printf_unfiltered (_("Deleted breakpoints "));
12188 for (ix
= 0; VEC_iterate(breakpoint_p
, found
, ix
, b
); ix
++)
12191 printf_unfiltered ("%d ", b
->number
);
12192 delete_breakpoint (b
);
12195 putchar_unfiltered ('\n');
12197 do_cleanups (cleanups
);
12200 /* Delete breakpoint in BS if they are `delete' breakpoints and
12201 all breakpoints that are marked for deletion, whether hit or not.
12202 This is called after any breakpoint is hit, or after errors. */
12205 breakpoint_auto_delete (bpstat bs
)
12207 struct breakpoint
*b
, *b_tmp
;
12209 for (; bs
; bs
= bs
->next
)
12210 if (bs
->breakpoint_at
12211 && bs
->breakpoint_at
->disposition
== disp_del
12213 delete_breakpoint (bs
->breakpoint_at
);
12215 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
12217 if (b
->disposition
== disp_del_at_next_stop
)
12218 delete_breakpoint (b
);
12222 /* A comparison function for bp_location AP and BP being interfaced to
12223 qsort. Sort elements primarily by their ADDRESS (no matter what
12224 does breakpoint_address_is_meaningful say for its OWNER),
12225 secondarily by ordering first permanent elements and
12226 terciarily just ensuring the array is sorted stable way despite
12227 qsort being an unstable algorithm. */
12230 bp_location_compare (const void *ap
, const void *bp
)
12232 const struct bp_location
*a
= *(const struct bp_location
**) ap
;
12233 const struct bp_location
*b
= *(const struct bp_location
**) bp
;
12235 if (a
->address
!= b
->address
)
12236 return (a
->address
> b
->address
) - (a
->address
< b
->address
);
12238 /* Sort locations at the same address by their pspace number, keeping
12239 locations of the same inferior (in a multi-inferior environment)
12242 if (a
->pspace
->num
!= b
->pspace
->num
)
12243 return ((a
->pspace
->num
> b
->pspace
->num
)
12244 - (a
->pspace
->num
< b
->pspace
->num
));
12246 /* Sort permanent breakpoints first. */
12247 if (a
->permanent
!= b
->permanent
)
12248 return (a
->permanent
< b
->permanent
) - (a
->permanent
> b
->permanent
);
12250 /* Make the internal GDB representation stable across GDB runs
12251 where A and B memory inside GDB can differ. Breakpoint locations of
12252 the same type at the same address can be sorted in arbitrary order. */
12254 if (a
->owner
->number
!= b
->owner
->number
)
12255 return ((a
->owner
->number
> b
->owner
->number
)
12256 - (a
->owner
->number
< b
->owner
->number
));
12258 return (a
> b
) - (a
< b
);
12261 /* Set bp_location_placed_address_before_address_max and
12262 bp_location_shadow_len_after_address_max according to the current
12263 content of the bp_location array. */
12266 bp_location_target_extensions_update (void)
12268 struct bp_location
*bl
, **blp_tmp
;
12270 bp_location_placed_address_before_address_max
= 0;
12271 bp_location_shadow_len_after_address_max
= 0;
12273 ALL_BP_LOCATIONS (bl
, blp_tmp
)
12275 CORE_ADDR start
, end
, addr
;
12277 if (!bp_location_has_shadow (bl
))
12280 start
= bl
->target_info
.placed_address
;
12281 end
= start
+ bl
->target_info
.shadow_len
;
12283 gdb_assert (bl
->address
>= start
);
12284 addr
= bl
->address
- start
;
12285 if (addr
> bp_location_placed_address_before_address_max
)
12286 bp_location_placed_address_before_address_max
= addr
;
12288 /* Zero SHADOW_LEN would not pass bp_location_has_shadow. */
12290 gdb_assert (bl
->address
< end
);
12291 addr
= end
- bl
->address
;
12292 if (addr
> bp_location_shadow_len_after_address_max
)
12293 bp_location_shadow_len_after_address_max
= addr
;
12297 /* Download tracepoint locations if they haven't been. */
12300 download_tracepoint_locations (void)
12302 struct breakpoint
*b
;
12303 struct cleanup
*old_chain
;
12304 enum tribool can_download_tracepoint
= TRIBOOL_UNKNOWN
;
12306 old_chain
= save_current_space_and_thread ();
12308 ALL_TRACEPOINTS (b
)
12310 struct bp_location
*bl
;
12311 struct tracepoint
*t
;
12312 int bp_location_downloaded
= 0;
12314 if ((b
->type
== bp_fast_tracepoint
12315 ? !may_insert_fast_tracepoints
12316 : !may_insert_tracepoints
))
12319 if (can_download_tracepoint
== TRIBOOL_UNKNOWN
)
12321 if (target_can_download_tracepoint ())
12322 can_download_tracepoint
= TRIBOOL_TRUE
;
12324 can_download_tracepoint
= TRIBOOL_FALSE
;
12327 if (can_download_tracepoint
== TRIBOOL_FALSE
)
12330 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
12332 /* In tracepoint, locations are _never_ duplicated, so
12333 should_be_inserted is equivalent to
12334 unduplicated_should_be_inserted. */
12335 if (!should_be_inserted (bl
) || bl
->inserted
)
12338 switch_to_program_space_and_thread (bl
->pspace
);
12340 target_download_tracepoint (bl
);
12343 bp_location_downloaded
= 1;
12345 t
= (struct tracepoint
*) b
;
12346 t
->number_on_target
= b
->number
;
12347 if (bp_location_downloaded
)
12348 observer_notify_breakpoint_modified (b
);
12351 do_cleanups (old_chain
);
12354 /* Swap the insertion/duplication state between two locations. */
12357 swap_insertion (struct bp_location
*left
, struct bp_location
*right
)
12359 const int left_inserted
= left
->inserted
;
12360 const int left_duplicate
= left
->duplicate
;
12361 const int left_needs_update
= left
->needs_update
;
12362 const struct bp_target_info left_target_info
= left
->target_info
;
12364 /* Locations of tracepoints can never be duplicated. */
12365 if (is_tracepoint (left
->owner
))
12366 gdb_assert (!left
->duplicate
);
12367 if (is_tracepoint (right
->owner
))
12368 gdb_assert (!right
->duplicate
);
12370 left
->inserted
= right
->inserted
;
12371 left
->duplicate
= right
->duplicate
;
12372 left
->needs_update
= right
->needs_update
;
12373 left
->target_info
= right
->target_info
;
12374 right
->inserted
= left_inserted
;
12375 right
->duplicate
= left_duplicate
;
12376 right
->needs_update
= left_needs_update
;
12377 right
->target_info
= left_target_info
;
12380 /* Force the re-insertion of the locations at ADDRESS. This is called
12381 once a new/deleted/modified duplicate location is found and we are evaluating
12382 conditions on the target's side. Such conditions need to be updated on
12386 force_breakpoint_reinsertion (struct bp_location
*bl
)
12388 struct bp_location
**locp
= NULL
, **loc2p
;
12389 struct bp_location
*loc
;
12390 CORE_ADDR address
= 0;
12393 address
= bl
->address
;
12394 pspace_num
= bl
->pspace
->num
;
12396 /* This is only meaningful if the target is
12397 evaluating conditions and if the user has
12398 opted for condition evaluation on the target's
12400 if (gdb_evaluates_breakpoint_condition_p ()
12401 || !target_supports_evaluation_of_breakpoint_conditions ())
12404 /* Flag all breakpoint locations with this address and
12405 the same program space as the location
12406 as "its condition has changed". We need to
12407 update the conditions on the target's side. */
12408 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, address
)
12412 if (!is_breakpoint (loc
->owner
)
12413 || pspace_num
!= loc
->pspace
->num
)
12416 /* Flag the location appropriately. We use a different state to
12417 let everyone know that we already updated the set of locations
12418 with addr bl->address and program space bl->pspace. This is so
12419 we don't have to keep calling these functions just to mark locations
12420 that have already been marked. */
12421 loc
->condition_changed
= condition_updated
;
12423 /* Free the agent expression bytecode as well. We will compute
12425 if (loc
->cond_bytecode
)
12427 free_agent_expr (loc
->cond_bytecode
);
12428 loc
->cond_bytecode
= NULL
;
12432 /* Called whether new breakpoints are created, or existing breakpoints
12433 deleted, to update the global location list and recompute which
12434 locations are duplicate of which.
12436 The INSERT_MODE flag determines whether locations may not, may, or
12437 shall be inserted now. See 'enum ugll_insert_mode' for more
12441 update_global_location_list (enum ugll_insert_mode insert_mode
)
12443 struct breakpoint
*b
;
12444 struct bp_location
**locp
, *loc
;
12445 struct cleanup
*cleanups
;
12446 /* Last breakpoint location address that was marked for update. */
12447 CORE_ADDR last_addr
= 0;
12448 /* Last breakpoint location program space that was marked for update. */
12449 int last_pspace_num
= -1;
12451 /* Used in the duplicates detection below. When iterating over all
12452 bp_locations, points to the first bp_location of a given address.
12453 Breakpoints and watchpoints of different types are never
12454 duplicates of each other. Keep one pointer for each type of
12455 breakpoint/watchpoint, so we only need to loop over all locations
12457 struct bp_location
*bp_loc_first
; /* breakpoint */
12458 struct bp_location
*wp_loc_first
; /* hardware watchpoint */
12459 struct bp_location
*awp_loc_first
; /* access watchpoint */
12460 struct bp_location
*rwp_loc_first
; /* read watchpoint */
12462 /* Saved former bp_location array which we compare against the newly
12463 built bp_location from the current state of ALL_BREAKPOINTS. */
12464 struct bp_location
**old_location
, **old_locp
;
12465 unsigned old_location_count
;
12467 old_location
= bp_location
;
12468 old_location_count
= bp_location_count
;
12469 bp_location
= NULL
;
12470 bp_location_count
= 0;
12471 cleanups
= make_cleanup (xfree
, old_location
);
12473 ALL_BREAKPOINTS (b
)
12474 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
12475 bp_location_count
++;
12477 bp_location
= XNEWVEC (struct bp_location
*, bp_location_count
);
12478 locp
= bp_location
;
12479 ALL_BREAKPOINTS (b
)
12480 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
12482 qsort (bp_location
, bp_location_count
, sizeof (*bp_location
),
12483 bp_location_compare
);
12485 bp_location_target_extensions_update ();
12487 /* Identify bp_location instances that are no longer present in the
12488 new list, and therefore should be freed. Note that it's not
12489 necessary that those locations should be removed from inferior --
12490 if there's another location at the same address (previously
12491 marked as duplicate), we don't need to remove/insert the
12494 LOCP is kept in sync with OLD_LOCP, each pointing to the current
12495 and former bp_location array state respectively. */
12497 locp
= bp_location
;
12498 for (old_locp
= old_location
; old_locp
< old_location
+ old_location_count
;
12501 struct bp_location
*old_loc
= *old_locp
;
12502 struct bp_location
**loc2p
;
12504 /* Tells if 'old_loc' is found among the new locations. If
12505 not, we have to free it. */
12506 int found_object
= 0;
12507 /* Tells if the location should remain inserted in the target. */
12508 int keep_in_target
= 0;
12511 /* Skip LOCP entries which will definitely never be needed.
12512 Stop either at or being the one matching OLD_LOC. */
12513 while (locp
< bp_location
+ bp_location_count
12514 && (*locp
)->address
< old_loc
->address
)
12518 (loc2p
< bp_location
+ bp_location_count
12519 && (*loc2p
)->address
== old_loc
->address
);
12522 /* Check if this is a new/duplicated location or a duplicated
12523 location that had its condition modified. If so, we want to send
12524 its condition to the target if evaluation of conditions is taking
12526 if ((*loc2p
)->condition_changed
== condition_modified
12527 && (last_addr
!= old_loc
->address
12528 || last_pspace_num
!= old_loc
->pspace
->num
))
12530 force_breakpoint_reinsertion (*loc2p
);
12531 last_pspace_num
= old_loc
->pspace
->num
;
12534 if (*loc2p
== old_loc
)
12538 /* We have already handled this address, update it so that we don't
12539 have to go through updates again. */
12540 last_addr
= old_loc
->address
;
12542 /* Target-side condition evaluation: Handle deleted locations. */
12544 force_breakpoint_reinsertion (old_loc
);
12546 /* If this location is no longer present, and inserted, look if
12547 there's maybe a new location at the same address. If so,
12548 mark that one inserted, and don't remove this one. This is
12549 needed so that we don't have a time window where a breakpoint
12550 at certain location is not inserted. */
12552 if (old_loc
->inserted
)
12554 /* If the location is inserted now, we might have to remove
12557 if (found_object
&& should_be_inserted (old_loc
))
12559 /* The location is still present in the location list,
12560 and still should be inserted. Don't do anything. */
12561 keep_in_target
= 1;
12565 /* This location still exists, but it won't be kept in the
12566 target since it may have been disabled. We proceed to
12567 remove its target-side condition. */
12569 /* The location is either no longer present, or got
12570 disabled. See if there's another location at the
12571 same address, in which case we don't need to remove
12572 this one from the target. */
12574 /* OLD_LOC comes from existing struct breakpoint. */
12575 if (breakpoint_address_is_meaningful (old_loc
->owner
))
12578 (loc2p
< bp_location
+ bp_location_count
12579 && (*loc2p
)->address
== old_loc
->address
);
12582 struct bp_location
*loc2
= *loc2p
;
12584 if (breakpoint_locations_match (loc2
, old_loc
))
12586 /* Read watchpoint locations are switched to
12587 access watchpoints, if the former are not
12588 supported, but the latter are. */
12589 if (is_hardware_watchpoint (old_loc
->owner
))
12591 gdb_assert (is_hardware_watchpoint (loc2
->owner
));
12592 loc2
->watchpoint_type
= old_loc
->watchpoint_type
;
12595 /* loc2 is a duplicated location. We need to check
12596 if it should be inserted in case it will be
12598 if (loc2
!= old_loc
12599 && unduplicated_should_be_inserted (loc2
))
12601 swap_insertion (old_loc
, loc2
);
12602 keep_in_target
= 1;
12610 if (!keep_in_target
)
12612 if (remove_breakpoint (old_loc
, mark_uninserted
))
12614 /* This is just about all we can do. We could keep
12615 this location on the global list, and try to
12616 remove it next time, but there's no particular
12617 reason why we will succeed next time.
12619 Note that at this point, old_loc->owner is still
12620 valid, as delete_breakpoint frees the breakpoint
12621 only after calling us. */
12622 printf_filtered (_("warning: Error removing "
12623 "breakpoint %d\n"),
12624 old_loc
->owner
->number
);
12632 if (removed
&& target_is_non_stop_p ()
12633 && need_moribund_for_location_type (old_loc
))
12635 /* This location was removed from the target. In
12636 non-stop mode, a race condition is possible where
12637 we've removed a breakpoint, but stop events for that
12638 breakpoint are already queued and will arrive later.
12639 We apply an heuristic to be able to distinguish such
12640 SIGTRAPs from other random SIGTRAPs: we keep this
12641 breakpoint location for a bit, and will retire it
12642 after we see some number of events. The theory here
12643 is that reporting of events should, "on the average",
12644 be fair, so after a while we'll see events from all
12645 threads that have anything of interest, and no longer
12646 need to keep this breakpoint location around. We
12647 don't hold locations forever so to reduce chances of
12648 mistaking a non-breakpoint SIGTRAP for a breakpoint
12651 The heuristic failing can be disastrous on
12652 decr_pc_after_break targets.
12654 On decr_pc_after_break targets, like e.g., x86-linux,
12655 if we fail to recognize a late breakpoint SIGTRAP,
12656 because events_till_retirement has reached 0 too
12657 soon, we'll fail to do the PC adjustment, and report
12658 a random SIGTRAP to the user. When the user resumes
12659 the inferior, it will most likely immediately crash
12660 with SIGILL/SIGBUS/SIGSEGV, or worse, get silently
12661 corrupted, because of being resumed e.g., in the
12662 middle of a multi-byte instruction, or skipped a
12663 one-byte instruction. This was actually seen happen
12664 on native x86-linux, and should be less rare on
12665 targets that do not support new thread events, like
12666 remote, due to the heuristic depending on
12669 Mistaking a random SIGTRAP for a breakpoint trap
12670 causes similar symptoms (PC adjustment applied when
12671 it shouldn't), but then again, playing with SIGTRAPs
12672 behind the debugger's back is asking for trouble.
12674 Since hardware watchpoint traps are always
12675 distinguishable from other traps, so we don't need to
12676 apply keep hardware watchpoint moribund locations
12677 around. We simply always ignore hardware watchpoint
12678 traps we can no longer explain. */
12680 old_loc
->events_till_retirement
= 3 * (thread_count () + 1);
12681 old_loc
->owner
= NULL
;
12683 VEC_safe_push (bp_location_p
, moribund_locations
, old_loc
);
12687 old_loc
->owner
= NULL
;
12688 decref_bp_location (&old_loc
);
12693 /* Rescan breakpoints at the same address and section, marking the
12694 first one as "first" and any others as "duplicates". This is so
12695 that the bpt instruction is only inserted once. If we have a
12696 permanent breakpoint at the same place as BPT, make that one the
12697 official one, and the rest as duplicates. Permanent breakpoints
12698 are sorted first for the same address.
12700 Do the same for hardware watchpoints, but also considering the
12701 watchpoint's type (regular/access/read) and length. */
12703 bp_loc_first
= NULL
;
12704 wp_loc_first
= NULL
;
12705 awp_loc_first
= NULL
;
12706 rwp_loc_first
= NULL
;
12707 ALL_BP_LOCATIONS (loc
, locp
)
12709 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always
12711 struct bp_location
**loc_first_p
;
12714 if (!unduplicated_should_be_inserted (loc
)
12715 || !breakpoint_address_is_meaningful (b
)
12716 /* Don't detect duplicate for tracepoint locations because they are
12717 never duplicated. See the comments in field `duplicate' of
12718 `struct bp_location'. */
12719 || is_tracepoint (b
))
12721 /* Clear the condition modification flag. */
12722 loc
->condition_changed
= condition_unchanged
;
12726 if (b
->type
== bp_hardware_watchpoint
)
12727 loc_first_p
= &wp_loc_first
;
12728 else if (b
->type
== bp_read_watchpoint
)
12729 loc_first_p
= &rwp_loc_first
;
12730 else if (b
->type
== bp_access_watchpoint
)
12731 loc_first_p
= &awp_loc_first
;
12733 loc_first_p
= &bp_loc_first
;
12735 if (*loc_first_p
== NULL
12736 || (overlay_debugging
&& loc
->section
!= (*loc_first_p
)->section
)
12737 || !breakpoint_locations_match (loc
, *loc_first_p
))
12739 *loc_first_p
= loc
;
12740 loc
->duplicate
= 0;
12742 if (is_breakpoint (loc
->owner
) && loc
->condition_changed
)
12744 loc
->needs_update
= 1;
12745 /* Clear the condition modification flag. */
12746 loc
->condition_changed
= condition_unchanged
;
12752 /* This and the above ensure the invariant that the first location
12753 is not duplicated, and is the inserted one.
12754 All following are marked as duplicated, and are not inserted. */
12756 swap_insertion (loc
, *loc_first_p
);
12757 loc
->duplicate
= 1;
12759 /* Clear the condition modification flag. */
12760 loc
->condition_changed
= condition_unchanged
;
12763 if (insert_mode
== UGLL_INSERT
|| breakpoints_should_be_inserted_now ())
12765 if (insert_mode
!= UGLL_DONT_INSERT
)
12766 insert_breakpoint_locations ();
12769 /* Even though the caller told us to not insert new
12770 locations, we may still need to update conditions on the
12771 target's side of breakpoints that were already inserted
12772 if the target is evaluating breakpoint conditions. We
12773 only update conditions for locations that are marked
12775 update_inserted_breakpoint_locations ();
12779 if (insert_mode
!= UGLL_DONT_INSERT
)
12780 download_tracepoint_locations ();
12782 do_cleanups (cleanups
);
12786 breakpoint_retire_moribund (void)
12788 struct bp_location
*loc
;
12791 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
12792 if (--(loc
->events_till_retirement
) == 0)
12794 decref_bp_location (&loc
);
12795 VEC_unordered_remove (bp_location_p
, moribund_locations
, ix
);
12801 update_global_location_list_nothrow (enum ugll_insert_mode insert_mode
)
12806 update_global_location_list (insert_mode
);
12808 CATCH (e
, RETURN_MASK_ERROR
)
12814 /* Clear BKP from a BPS. */
12817 bpstat_remove_bp_location (bpstat bps
, struct breakpoint
*bpt
)
12821 for (bs
= bps
; bs
; bs
= bs
->next
)
12822 if (bs
->breakpoint_at
== bpt
)
12824 bs
->breakpoint_at
= NULL
;
12825 bs
->old_val
= NULL
;
12826 /* bs->commands will be freed later. */
12830 /* Callback for iterate_over_threads. */
12832 bpstat_remove_breakpoint_callback (struct thread_info
*th
, void *data
)
12834 struct breakpoint
*bpt
= (struct breakpoint
*) data
;
12836 bpstat_remove_bp_location (th
->control
.stop_bpstat
, bpt
);
12840 /* Helper for breakpoint and tracepoint breakpoint_ops->mention
12844 say_where (struct breakpoint
*b
)
12846 struct value_print_options opts
;
12848 get_user_print_options (&opts
);
12850 /* i18n: cagney/2005-02-11: Below needs to be merged into a
12852 if (b
->loc
== NULL
)
12854 /* For pending locations, the output differs slightly based
12855 on b->extra_string. If this is non-NULL, it contains either
12856 a condition or dprintf arguments. */
12857 if (b
->extra_string
== NULL
)
12859 printf_filtered (_(" (%s) pending."),
12860 event_location_to_string (b
->location
));
12862 else if (b
->type
== bp_dprintf
)
12864 printf_filtered (_(" (%s,%s) pending."),
12865 event_location_to_string (b
->location
),
12870 printf_filtered (_(" (%s %s) pending."),
12871 event_location_to_string (b
->location
),
12877 if (opts
.addressprint
|| b
->loc
->symtab
== NULL
)
12879 printf_filtered (" at ");
12880 fputs_filtered (paddress (b
->loc
->gdbarch
, b
->loc
->address
),
12883 if (b
->loc
->symtab
!= NULL
)
12885 /* If there is a single location, we can print the location
12887 if (b
->loc
->next
== NULL
)
12888 printf_filtered (": file %s, line %d.",
12889 symtab_to_filename_for_display (b
->loc
->symtab
),
12890 b
->loc
->line_number
);
12892 /* This is not ideal, but each location may have a
12893 different file name, and this at least reflects the
12894 real situation somewhat. */
12895 printf_filtered (": %s.",
12896 event_location_to_string (b
->location
));
12901 struct bp_location
*loc
= b
->loc
;
12903 for (; loc
; loc
= loc
->next
)
12905 printf_filtered (" (%d locations)", n
);
12910 /* Default bp_location_ops methods. */
12913 bp_location_dtor (struct bp_location
*self
)
12915 xfree (self
->cond
);
12916 if (self
->cond_bytecode
)
12917 free_agent_expr (self
->cond_bytecode
);
12918 xfree (self
->function_name
);
12920 VEC_free (agent_expr_p
, self
->target_info
.conditions
);
12921 VEC_free (agent_expr_p
, self
->target_info
.tcommands
);
12924 static const struct bp_location_ops bp_location_ops
=
12929 /* Default breakpoint_ops methods all breakpoint_ops ultimately
12933 base_breakpoint_dtor (struct breakpoint
*self
)
12935 decref_counted_command_line (&self
->commands
);
12936 xfree (self
->cond_string
);
12937 xfree (self
->extra_string
);
12938 xfree (self
->filter
);
12939 delete_event_location (self
->location
);
12940 delete_event_location (self
->location_range_end
);
12943 static struct bp_location
*
12944 base_breakpoint_allocate_location (struct breakpoint
*self
)
12946 struct bp_location
*loc
;
12948 loc
= XNEW (struct bp_location
);
12949 init_bp_location (loc
, &bp_location_ops
, self
);
12954 base_breakpoint_re_set (struct breakpoint
*b
)
12956 /* Nothing to re-set. */
12959 #define internal_error_pure_virtual_called() \
12960 gdb_assert_not_reached ("pure virtual function called")
12963 base_breakpoint_insert_location (struct bp_location
*bl
)
12965 internal_error_pure_virtual_called ();
12969 base_breakpoint_remove_location (struct bp_location
*bl
)
12971 internal_error_pure_virtual_called ();
12975 base_breakpoint_breakpoint_hit (const struct bp_location
*bl
,
12976 struct address_space
*aspace
,
12978 const struct target_waitstatus
*ws
)
12980 internal_error_pure_virtual_called ();
12984 base_breakpoint_check_status (bpstat bs
)
12989 /* A "works_in_software_mode" breakpoint_ops method that just internal
12993 base_breakpoint_works_in_software_mode (const struct breakpoint
*b
)
12995 internal_error_pure_virtual_called ();
12998 /* A "resources_needed" breakpoint_ops method that just internal
13002 base_breakpoint_resources_needed (const struct bp_location
*bl
)
13004 internal_error_pure_virtual_called ();
13007 static enum print_stop_action
13008 base_breakpoint_print_it (bpstat bs
)
13010 internal_error_pure_virtual_called ();
13014 base_breakpoint_print_one_detail (const struct breakpoint
*self
,
13015 struct ui_out
*uiout
)
13021 base_breakpoint_print_mention (struct breakpoint
*b
)
13023 internal_error_pure_virtual_called ();
13027 base_breakpoint_print_recreate (struct breakpoint
*b
, struct ui_file
*fp
)
13029 internal_error_pure_virtual_called ();
13033 base_breakpoint_create_sals_from_location
13034 (const struct event_location
*location
,
13035 struct linespec_result
*canonical
,
13036 enum bptype type_wanted
)
13038 internal_error_pure_virtual_called ();
13042 base_breakpoint_create_breakpoints_sal (struct gdbarch
*gdbarch
,
13043 struct linespec_result
*c
,
13045 char *extra_string
,
13046 enum bptype type_wanted
,
13047 enum bpdisp disposition
,
13049 int task
, int ignore_count
,
13050 const struct breakpoint_ops
*o
,
13051 int from_tty
, int enabled
,
13052 int internal
, unsigned flags
)
13054 internal_error_pure_virtual_called ();
13058 base_breakpoint_decode_location (struct breakpoint
*b
,
13059 const struct event_location
*location
,
13060 struct program_space
*search_pspace
,
13061 struct symtabs_and_lines
*sals
)
13063 internal_error_pure_virtual_called ();
13066 /* The default 'explains_signal' method. */
13069 base_breakpoint_explains_signal (struct breakpoint
*b
, enum gdb_signal sig
)
13074 /* The default "after_condition_true" method. */
13077 base_breakpoint_after_condition_true (struct bpstats
*bs
)
13079 /* Nothing to do. */
13082 struct breakpoint_ops base_breakpoint_ops
=
13084 base_breakpoint_dtor
,
13085 base_breakpoint_allocate_location
,
13086 base_breakpoint_re_set
,
13087 base_breakpoint_insert_location
,
13088 base_breakpoint_remove_location
,
13089 base_breakpoint_breakpoint_hit
,
13090 base_breakpoint_check_status
,
13091 base_breakpoint_resources_needed
,
13092 base_breakpoint_works_in_software_mode
,
13093 base_breakpoint_print_it
,
13095 base_breakpoint_print_one_detail
,
13096 base_breakpoint_print_mention
,
13097 base_breakpoint_print_recreate
,
13098 base_breakpoint_create_sals_from_location
,
13099 base_breakpoint_create_breakpoints_sal
,
13100 base_breakpoint_decode_location
,
13101 base_breakpoint_explains_signal
,
13102 base_breakpoint_after_condition_true
,
13105 /* Default breakpoint_ops methods. */
13108 bkpt_re_set (struct breakpoint
*b
)
13110 /* FIXME: is this still reachable? */
13111 if (breakpoint_event_location_empty_p (b
))
13113 /* Anything without a location can't be re-set. */
13114 delete_breakpoint (b
);
13118 breakpoint_re_set_default (b
);
13122 bkpt_insert_location (struct bp_location
*bl
)
13124 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
13125 return target_insert_hw_breakpoint (bl
->gdbarch
, &bl
->target_info
);
13127 return target_insert_breakpoint (bl
->gdbarch
, &bl
->target_info
);
13131 bkpt_remove_location (struct bp_location
*bl
)
13133 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
13134 return target_remove_hw_breakpoint (bl
->gdbarch
, &bl
->target_info
);
13136 return target_remove_breakpoint (bl
->gdbarch
, &bl
->target_info
);
13140 bkpt_breakpoint_hit (const struct bp_location
*bl
,
13141 struct address_space
*aspace
, CORE_ADDR bp_addr
,
13142 const struct target_waitstatus
*ws
)
13144 if (ws
->kind
!= TARGET_WAITKIND_STOPPED
13145 || ws
->value
.sig
!= GDB_SIGNAL_TRAP
)
13148 if (!breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
13152 if (overlay_debugging
/* unmapped overlay section */
13153 && section_is_overlay (bl
->section
)
13154 && !section_is_mapped (bl
->section
))
13161 dprintf_breakpoint_hit (const struct bp_location
*bl
,
13162 struct address_space
*aspace
, CORE_ADDR bp_addr
,
13163 const struct target_waitstatus
*ws
)
13165 if (dprintf_style
== dprintf_style_agent
13166 && target_can_run_breakpoint_commands ())
13168 /* An agent-style dprintf never causes a stop. If we see a trap
13169 for this address it must be for a breakpoint that happens to
13170 be set at the same address. */
13174 return bkpt_breakpoint_hit (bl
, aspace
, bp_addr
, ws
);
13178 bkpt_resources_needed (const struct bp_location
*bl
)
13180 gdb_assert (bl
->owner
->type
== bp_hardware_breakpoint
);
13185 static enum print_stop_action
13186 bkpt_print_it (bpstat bs
)
13188 struct breakpoint
*b
;
13189 const struct bp_location
*bl
;
13191 struct ui_out
*uiout
= current_uiout
;
13193 gdb_assert (bs
->bp_location_at
!= NULL
);
13195 bl
= bs
->bp_location_at
;
13196 b
= bs
->breakpoint_at
;
13198 bp_temp
= b
->disposition
== disp_del
;
13199 if (bl
->address
!= bl
->requested_address
)
13200 breakpoint_adjustment_warning (bl
->requested_address
,
13203 annotate_breakpoint (b
->number
);
13204 maybe_print_thread_hit_breakpoint (uiout
);
13207 ui_out_text (uiout
, "Temporary breakpoint ");
13209 ui_out_text (uiout
, "Breakpoint ");
13210 if (ui_out_is_mi_like_p (uiout
))
13212 ui_out_field_string (uiout
, "reason",
13213 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
13214 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
13216 ui_out_field_int (uiout
, "bkptno", b
->number
);
13217 ui_out_text (uiout
, ", ");
13219 return PRINT_SRC_AND_LOC
;
13223 bkpt_print_mention (struct breakpoint
*b
)
13225 if (ui_out_is_mi_like_p (current_uiout
))
13230 case bp_breakpoint
:
13231 case bp_gnu_ifunc_resolver
:
13232 if (b
->disposition
== disp_del
)
13233 printf_filtered (_("Temporary breakpoint"));
13235 printf_filtered (_("Breakpoint"));
13236 printf_filtered (_(" %d"), b
->number
);
13237 if (b
->type
== bp_gnu_ifunc_resolver
)
13238 printf_filtered (_(" at gnu-indirect-function resolver"));
13240 case bp_hardware_breakpoint
:
13241 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
13244 printf_filtered (_("Dprintf %d"), b
->number
);
13252 bkpt_print_recreate (struct breakpoint
*tp
, struct ui_file
*fp
)
13254 if (tp
->type
== bp_breakpoint
&& tp
->disposition
== disp_del
)
13255 fprintf_unfiltered (fp
, "tbreak");
13256 else if (tp
->type
== bp_breakpoint
)
13257 fprintf_unfiltered (fp
, "break");
13258 else if (tp
->type
== bp_hardware_breakpoint
13259 && tp
->disposition
== disp_del
)
13260 fprintf_unfiltered (fp
, "thbreak");
13261 else if (tp
->type
== bp_hardware_breakpoint
)
13262 fprintf_unfiltered (fp
, "hbreak");
13264 internal_error (__FILE__
, __LINE__
,
13265 _("unhandled breakpoint type %d"), (int) tp
->type
);
13267 fprintf_unfiltered (fp
, " %s",
13268 event_location_to_string (tp
->location
));
13270 /* Print out extra_string if this breakpoint is pending. It might
13271 contain, for example, conditions that were set by the user. */
13272 if (tp
->loc
== NULL
&& tp
->extra_string
!= NULL
)
13273 fprintf_unfiltered (fp
, " %s", tp
->extra_string
);
13275 print_recreate_thread (tp
, fp
);
13279 bkpt_create_sals_from_location (const struct event_location
*location
,
13280 struct linespec_result
*canonical
,
13281 enum bptype type_wanted
)
13283 create_sals_from_location_default (location
, canonical
, type_wanted
);
13287 bkpt_create_breakpoints_sal (struct gdbarch
*gdbarch
,
13288 struct linespec_result
*canonical
,
13290 char *extra_string
,
13291 enum bptype type_wanted
,
13292 enum bpdisp disposition
,
13294 int task
, int ignore_count
,
13295 const struct breakpoint_ops
*ops
,
13296 int from_tty
, int enabled
,
13297 int internal
, unsigned flags
)
13299 create_breakpoints_sal_default (gdbarch
, canonical
,
13300 cond_string
, extra_string
,
13302 disposition
, thread
, task
,
13303 ignore_count
, ops
, from_tty
,
13304 enabled
, internal
, flags
);
13308 bkpt_decode_location (struct breakpoint
*b
,
13309 const struct event_location
*location
,
13310 struct program_space
*search_pspace
,
13311 struct symtabs_and_lines
*sals
)
13313 decode_location_default (b
, location
, search_pspace
, sals
);
13316 /* Virtual table for internal breakpoints. */
13319 internal_bkpt_re_set (struct breakpoint
*b
)
13323 /* Delete overlay event and longjmp master breakpoints; they
13324 will be reset later by breakpoint_re_set. */
13325 case bp_overlay_event
:
13326 case bp_longjmp_master
:
13327 case bp_std_terminate_master
:
13328 case bp_exception_master
:
13329 delete_breakpoint (b
);
13332 /* This breakpoint is special, it's set up when the inferior
13333 starts and we really don't want to touch it. */
13334 case bp_shlib_event
:
13336 /* Like bp_shlib_event, this breakpoint type is special. Once
13337 it is set up, we do not want to touch it. */
13338 case bp_thread_event
:
13344 internal_bkpt_check_status (bpstat bs
)
13346 if (bs
->breakpoint_at
->type
== bp_shlib_event
)
13348 /* If requested, stop when the dynamic linker notifies GDB of
13349 events. This allows the user to get control and place
13350 breakpoints in initializer routines for dynamically loaded
13351 objects (among other things). */
13352 bs
->stop
= stop_on_solib_events
;
13353 bs
->print
= stop_on_solib_events
;
13359 static enum print_stop_action
13360 internal_bkpt_print_it (bpstat bs
)
13362 struct breakpoint
*b
;
13364 b
= bs
->breakpoint_at
;
13368 case bp_shlib_event
:
13369 /* Did we stop because the user set the stop_on_solib_events
13370 variable? (If so, we report this as a generic, "Stopped due
13371 to shlib event" message.) */
13372 print_solib_event (0);
13375 case bp_thread_event
:
13376 /* Not sure how we will get here.
13377 GDB should not stop for these breakpoints. */
13378 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
13381 case bp_overlay_event
:
13382 /* By analogy with the thread event, GDB should not stop for these. */
13383 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
13386 case bp_longjmp_master
:
13387 /* These should never be enabled. */
13388 printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
13391 case bp_std_terminate_master
:
13392 /* These should never be enabled. */
13393 printf_filtered (_("std::terminate Master Breakpoint: "
13394 "gdb should not stop!\n"));
13397 case bp_exception_master
:
13398 /* These should never be enabled. */
13399 printf_filtered (_("Exception Master Breakpoint: "
13400 "gdb should not stop!\n"));
13404 return PRINT_NOTHING
;
13408 internal_bkpt_print_mention (struct breakpoint
*b
)
13410 /* Nothing to mention. These breakpoints are internal. */
13413 /* Virtual table for momentary breakpoints */
13416 momentary_bkpt_re_set (struct breakpoint
*b
)
13418 /* Keep temporary breakpoints, which can be encountered when we step
13419 over a dlopen call and solib_add is resetting the breakpoints.
13420 Otherwise these should have been blown away via the cleanup chain
13421 or by breakpoint_init_inferior when we rerun the executable. */
13425 momentary_bkpt_check_status (bpstat bs
)
13427 /* Nothing. The point of these breakpoints is causing a stop. */
13430 static enum print_stop_action
13431 momentary_bkpt_print_it (bpstat bs
)
13433 return PRINT_UNKNOWN
;
13437 momentary_bkpt_print_mention (struct breakpoint
*b
)
13439 /* Nothing to mention. These breakpoints are internal. */
13442 /* Ensure INITIATING_FRAME is cleared when no such breakpoint exists.
13444 It gets cleared already on the removal of the first one of such placed
13445 breakpoints. This is OK as they get all removed altogether. */
13448 longjmp_bkpt_dtor (struct breakpoint
*self
)
13450 struct thread_info
*tp
= find_thread_global_id (self
->thread
);
13453 tp
->initiating_frame
= null_frame_id
;
13455 momentary_breakpoint_ops
.dtor (self
);
13458 /* Specific methods for probe breakpoints. */
13461 bkpt_probe_insert_location (struct bp_location
*bl
)
13463 int v
= bkpt_insert_location (bl
);
13467 /* The insertion was successful, now let's set the probe's semaphore
13469 if (bl
->probe
.probe
->pops
->set_semaphore
!= NULL
)
13470 bl
->probe
.probe
->pops
->set_semaphore (bl
->probe
.probe
,
13479 bkpt_probe_remove_location (struct bp_location
*bl
)
13481 /* Let's clear the semaphore before removing the location. */
13482 if (bl
->probe
.probe
->pops
->clear_semaphore
!= NULL
)
13483 bl
->probe
.probe
->pops
->clear_semaphore (bl
->probe
.probe
,
13487 return bkpt_remove_location (bl
);
13491 bkpt_probe_create_sals_from_location (const struct event_location
*location
,
13492 struct linespec_result
*canonical
,
13493 enum bptype type_wanted
)
13495 struct linespec_sals lsal
;
13497 lsal
.sals
= parse_probes (location
, NULL
, canonical
);
13498 lsal
.canonical
= xstrdup (event_location_to_string (canonical
->location
));
13499 VEC_safe_push (linespec_sals
, canonical
->sals
, &lsal
);
13503 bkpt_probe_decode_location (struct breakpoint
*b
,
13504 const struct event_location
*location
,
13505 struct program_space
*search_pspace
,
13506 struct symtabs_and_lines
*sals
)
13508 *sals
= parse_probes (location
, search_pspace
, NULL
);
13510 error (_("probe not found"));
13513 /* The breakpoint_ops structure to be used in tracepoints. */
13516 tracepoint_re_set (struct breakpoint
*b
)
13518 breakpoint_re_set_default (b
);
13522 tracepoint_breakpoint_hit (const struct bp_location
*bl
,
13523 struct address_space
*aspace
, CORE_ADDR bp_addr
,
13524 const struct target_waitstatus
*ws
)
13526 /* By definition, the inferior does not report stops at
13532 tracepoint_print_one_detail (const struct breakpoint
*self
,
13533 struct ui_out
*uiout
)
13535 struct tracepoint
*tp
= (struct tracepoint
*) self
;
13536 if (tp
->static_trace_marker_id
)
13538 gdb_assert (self
->type
== bp_static_tracepoint
);
13540 ui_out_text (uiout
, "\tmarker id is ");
13541 ui_out_field_string (uiout
, "static-tracepoint-marker-string-id",
13542 tp
->static_trace_marker_id
);
13543 ui_out_text (uiout
, "\n");
13548 tracepoint_print_mention (struct breakpoint
*b
)
13550 if (ui_out_is_mi_like_p (current_uiout
))
13555 case bp_tracepoint
:
13556 printf_filtered (_("Tracepoint"));
13557 printf_filtered (_(" %d"), b
->number
);
13559 case bp_fast_tracepoint
:
13560 printf_filtered (_("Fast tracepoint"));
13561 printf_filtered (_(" %d"), b
->number
);
13563 case bp_static_tracepoint
:
13564 printf_filtered (_("Static tracepoint"));
13565 printf_filtered (_(" %d"), b
->number
);
13568 internal_error (__FILE__
, __LINE__
,
13569 _("unhandled tracepoint type %d"), (int) b
->type
);
13576 tracepoint_print_recreate (struct breakpoint
*self
, struct ui_file
*fp
)
13578 struct tracepoint
*tp
= (struct tracepoint
*) self
;
13580 if (self
->type
== bp_fast_tracepoint
)
13581 fprintf_unfiltered (fp
, "ftrace");
13582 else if (self
->type
== bp_static_tracepoint
)
13583 fprintf_unfiltered (fp
, "strace");
13584 else if (self
->type
== bp_tracepoint
)
13585 fprintf_unfiltered (fp
, "trace");
13587 internal_error (__FILE__
, __LINE__
,
13588 _("unhandled tracepoint type %d"), (int) self
->type
);
13590 fprintf_unfiltered (fp
, " %s",
13591 event_location_to_string (self
->location
));
13592 print_recreate_thread (self
, fp
);
13594 if (tp
->pass_count
)
13595 fprintf_unfiltered (fp
, " passcount %d\n", tp
->pass_count
);
13599 tracepoint_create_sals_from_location (const struct event_location
*location
,
13600 struct linespec_result
*canonical
,
13601 enum bptype type_wanted
)
13603 create_sals_from_location_default (location
, canonical
, type_wanted
);
13607 tracepoint_create_breakpoints_sal (struct gdbarch
*gdbarch
,
13608 struct linespec_result
*canonical
,
13610 char *extra_string
,
13611 enum bptype type_wanted
,
13612 enum bpdisp disposition
,
13614 int task
, int ignore_count
,
13615 const struct breakpoint_ops
*ops
,
13616 int from_tty
, int enabled
,
13617 int internal
, unsigned flags
)
13619 create_breakpoints_sal_default (gdbarch
, canonical
,
13620 cond_string
, extra_string
,
13622 disposition
, thread
, task
,
13623 ignore_count
, ops
, from_tty
,
13624 enabled
, internal
, flags
);
13628 tracepoint_decode_location (struct breakpoint
*b
,
13629 const struct event_location
*location
,
13630 struct program_space
*search_pspace
,
13631 struct symtabs_and_lines
*sals
)
13633 decode_location_default (b
, location
, search_pspace
, sals
);
13636 struct breakpoint_ops tracepoint_breakpoint_ops
;
13638 /* The breakpoint_ops structure to be use on tracepoints placed in a
13642 tracepoint_probe_create_sals_from_location
13643 (const struct event_location
*location
,
13644 struct linespec_result
*canonical
,
13645 enum bptype type_wanted
)
13647 /* We use the same method for breakpoint on probes. */
13648 bkpt_probe_create_sals_from_location (location
, canonical
, type_wanted
);
13652 tracepoint_probe_decode_location (struct breakpoint
*b
,
13653 const struct event_location
*location
,
13654 struct program_space
*search_pspace
,
13655 struct symtabs_and_lines
*sals
)
13657 /* We use the same method for breakpoint on probes. */
13658 bkpt_probe_decode_location (b
, location
, search_pspace
, sals
);
13661 static struct breakpoint_ops tracepoint_probe_breakpoint_ops
;
13663 /* Dprintf breakpoint_ops methods. */
13666 dprintf_re_set (struct breakpoint
*b
)
13668 breakpoint_re_set_default (b
);
13670 /* extra_string should never be non-NULL for dprintf. */
13671 gdb_assert (b
->extra_string
!= NULL
);
13673 /* 1 - connect to target 1, that can run breakpoint commands.
13674 2 - create a dprintf, which resolves fine.
13675 3 - disconnect from target 1
13676 4 - connect to target 2, that can NOT run breakpoint commands.
13678 After steps #3/#4, you'll want the dprintf command list to
13679 be updated, because target 1 and 2 may well return different
13680 answers for target_can_run_breakpoint_commands().
13681 Given absence of finer grained resetting, we get to do
13682 it all the time. */
13683 if (b
->extra_string
!= NULL
)
13684 update_dprintf_command_list (b
);
13687 /* Implement the "print_recreate" breakpoint_ops method for dprintf. */
13690 dprintf_print_recreate (struct breakpoint
*tp
, struct ui_file
*fp
)
13692 fprintf_unfiltered (fp
, "dprintf %s,%s",
13693 event_location_to_string (tp
->location
),
13695 print_recreate_thread (tp
, fp
);
13698 /* Implement the "after_condition_true" breakpoint_ops method for
13701 dprintf's are implemented with regular commands in their command
13702 list, but we run the commands here instead of before presenting the
13703 stop to the user, as dprintf's don't actually cause a stop. This
13704 also makes it so that the commands of multiple dprintfs at the same
13705 address are all handled. */
13708 dprintf_after_condition_true (struct bpstats
*bs
)
13710 struct cleanup
*old_chain
;
13711 struct bpstats tmp_bs
= { NULL
};
13712 struct bpstats
*tmp_bs_p
= &tmp_bs
;
13714 /* dprintf's never cause a stop. This wasn't set in the
13715 check_status hook instead because that would make the dprintf's
13716 condition not be evaluated. */
13719 /* Run the command list here. Take ownership of it instead of
13720 copying. We never want these commands to run later in
13721 bpstat_do_actions, if a breakpoint that causes a stop happens to
13722 be set at same address as this dprintf, or even if running the
13723 commands here throws. */
13724 tmp_bs
.commands
= bs
->commands
;
13725 bs
->commands
= NULL
;
13726 old_chain
= make_cleanup_decref_counted_command_line (&tmp_bs
.commands
);
13728 bpstat_do_actions_1 (&tmp_bs_p
);
13730 /* 'tmp_bs.commands' will usually be NULL by now, but
13731 bpstat_do_actions_1 may return early without processing the whole
13733 do_cleanups (old_chain
);
13736 /* The breakpoint_ops structure to be used on static tracepoints with
13740 strace_marker_create_sals_from_location (const struct event_location
*location
,
13741 struct linespec_result
*canonical
,
13742 enum bptype type_wanted
)
13744 struct linespec_sals lsal
;
13745 const char *arg_start
, *arg
;
13747 struct cleanup
*cleanup
;
13749 arg
= arg_start
= get_linespec_location (location
);
13750 lsal
.sals
= decode_static_tracepoint_spec (&arg
);
13752 str
= savestring (arg_start
, arg
- arg_start
);
13753 cleanup
= make_cleanup (xfree
, str
);
13754 canonical
->location
= new_linespec_location (&str
);
13755 do_cleanups (cleanup
);
13757 lsal
.canonical
= xstrdup (event_location_to_string (canonical
->location
));
13758 VEC_safe_push (linespec_sals
, canonical
->sals
, &lsal
);
13762 strace_marker_create_breakpoints_sal (struct gdbarch
*gdbarch
,
13763 struct linespec_result
*canonical
,
13765 char *extra_string
,
13766 enum bptype type_wanted
,
13767 enum bpdisp disposition
,
13769 int task
, int ignore_count
,
13770 const struct breakpoint_ops
*ops
,
13771 int from_tty
, int enabled
,
13772 int internal
, unsigned flags
)
13775 struct linespec_sals
*lsal
= VEC_index (linespec_sals
,
13776 canonical
->sals
, 0);
13778 /* If the user is creating a static tracepoint by marker id
13779 (strace -m MARKER_ID), then store the sals index, so that
13780 breakpoint_re_set can try to match up which of the newly
13781 found markers corresponds to this one, and, don't try to
13782 expand multiple locations for each sal, given than SALS
13783 already should contain all sals for MARKER_ID. */
13785 for (i
= 0; i
< lsal
->sals
.nelts
; ++i
)
13787 struct symtabs_and_lines expanded
;
13788 struct tracepoint
*tp
;
13789 struct cleanup
*old_chain
;
13790 struct event_location
*location
;
13792 expanded
.nelts
= 1;
13793 expanded
.sals
= &lsal
->sals
.sals
[i
];
13795 location
= copy_event_location (canonical
->location
);
13796 old_chain
= make_cleanup_delete_event_location (location
);
13798 tp
= XCNEW (struct tracepoint
);
13799 init_breakpoint_sal (&tp
->base
, gdbarch
, expanded
,
13801 cond_string
, extra_string
,
13802 type_wanted
, disposition
,
13803 thread
, task
, ignore_count
, ops
,
13804 from_tty
, enabled
, internal
, flags
,
13805 canonical
->special_display
);
13806 /* Given that its possible to have multiple markers with
13807 the same string id, if the user is creating a static
13808 tracepoint by marker id ("strace -m MARKER_ID"), then
13809 store the sals index, so that breakpoint_re_set can
13810 try to match up which of the newly found markers
13811 corresponds to this one */
13812 tp
->static_trace_marker_id_idx
= i
;
13814 install_breakpoint (internal
, &tp
->base
, 0);
13816 discard_cleanups (old_chain
);
13821 strace_marker_decode_location (struct breakpoint
*b
,
13822 const struct event_location
*location
,
13823 struct program_space
*search_pspace
,
13824 struct symtabs_and_lines
*sals
)
13826 struct tracepoint
*tp
= (struct tracepoint
*) b
;
13827 const char *s
= get_linespec_location (location
);
13829 *sals
= decode_static_tracepoint_spec (&s
);
13830 if (sals
->nelts
> tp
->static_trace_marker_id_idx
)
13832 sals
->sals
[0] = sals
->sals
[tp
->static_trace_marker_id_idx
];
13836 error (_("marker %s not found"), tp
->static_trace_marker_id
);
13839 static struct breakpoint_ops strace_marker_breakpoint_ops
;
13842 strace_marker_p (struct breakpoint
*b
)
13844 return b
->ops
== &strace_marker_breakpoint_ops
;
13847 /* Delete a breakpoint and clean up all traces of it in the data
13851 delete_breakpoint (struct breakpoint
*bpt
)
13853 struct breakpoint
*b
;
13855 gdb_assert (bpt
!= NULL
);
13857 /* Has this bp already been deleted? This can happen because
13858 multiple lists can hold pointers to bp's. bpstat lists are
13861 One example of this happening is a watchpoint's scope bp. When
13862 the scope bp triggers, we notice that the watchpoint is out of
13863 scope, and delete it. We also delete its scope bp. But the
13864 scope bp is marked "auto-deleting", and is already on a bpstat.
13865 That bpstat is then checked for auto-deleting bp's, which are
13868 A real solution to this problem might involve reference counts in
13869 bp's, and/or giving them pointers back to their referencing
13870 bpstat's, and teaching delete_breakpoint to only free a bp's
13871 storage when no more references were extent. A cheaper bandaid
13873 if (bpt
->type
== bp_none
)
13876 /* At least avoid this stale reference until the reference counting
13877 of breakpoints gets resolved. */
13878 if (bpt
->related_breakpoint
!= bpt
)
13880 struct breakpoint
*related
;
13881 struct watchpoint
*w
;
13883 if (bpt
->type
== bp_watchpoint_scope
)
13884 w
= (struct watchpoint
*) bpt
->related_breakpoint
;
13885 else if (bpt
->related_breakpoint
->type
== bp_watchpoint_scope
)
13886 w
= (struct watchpoint
*) bpt
;
13890 watchpoint_del_at_next_stop (w
);
13892 /* Unlink bpt from the bpt->related_breakpoint ring. */
13893 for (related
= bpt
; related
->related_breakpoint
!= bpt
;
13894 related
= related
->related_breakpoint
);
13895 related
->related_breakpoint
= bpt
->related_breakpoint
;
13896 bpt
->related_breakpoint
= bpt
;
13899 /* watch_command_1 creates a watchpoint but only sets its number if
13900 update_watchpoint succeeds in creating its bp_locations. If there's
13901 a problem in that process, we'll be asked to delete the half-created
13902 watchpoint. In that case, don't announce the deletion. */
13904 observer_notify_breakpoint_deleted (bpt
);
13906 if (breakpoint_chain
== bpt
)
13907 breakpoint_chain
= bpt
->next
;
13909 ALL_BREAKPOINTS (b
)
13910 if (b
->next
== bpt
)
13912 b
->next
= bpt
->next
;
13916 /* Be sure no bpstat's are pointing at the breakpoint after it's
13918 /* FIXME, how can we find all bpstat's? We just check stop_bpstat
13919 in all threads for now. Note that we cannot just remove bpstats
13920 pointing at bpt from the stop_bpstat list entirely, as breakpoint
13921 commands are associated with the bpstat; if we remove it here,
13922 then the later call to bpstat_do_actions (&stop_bpstat); in
13923 event-top.c won't do anything, and temporary breakpoints with
13924 commands won't work. */
13926 iterate_over_threads (bpstat_remove_breakpoint_callback
, bpt
);
13928 /* Now that breakpoint is removed from breakpoint list, update the
13929 global location list. This will remove locations that used to
13930 belong to this breakpoint. Do this before freeing the breakpoint
13931 itself, since remove_breakpoint looks at location's owner. It
13932 might be better design to have location completely
13933 self-contained, but it's not the case now. */
13934 update_global_location_list (UGLL_DONT_INSERT
);
13936 bpt
->ops
->dtor (bpt
);
13937 /* On the chance that someone will soon try again to delete this
13938 same bp, we mark it as deleted before freeing its storage. */
13939 bpt
->type
= bp_none
;
13944 do_delete_breakpoint_cleanup (void *b
)
13946 delete_breakpoint ((struct breakpoint
*) b
);
13950 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
13952 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
13955 /* Iterator function to call a user-provided callback function once
13956 for each of B and its related breakpoints. */
13959 iterate_over_related_breakpoints (struct breakpoint
*b
,
13960 void (*function
) (struct breakpoint
*,
13964 struct breakpoint
*related
;
13969 struct breakpoint
*next
;
13971 /* FUNCTION may delete RELATED. */
13972 next
= related
->related_breakpoint
;
13974 if (next
== related
)
13976 /* RELATED is the last ring entry. */
13977 function (related
, data
);
13979 /* FUNCTION may have deleted it, so we'd never reach back to
13980 B. There's nothing left to do anyway, so just break
13985 function (related
, data
);
13989 while (related
!= b
);
13993 do_delete_breakpoint (struct breakpoint
*b
, void *ignore
)
13995 delete_breakpoint (b
);
13998 /* A callback for map_breakpoint_numbers that calls
13999 delete_breakpoint. */
14002 do_map_delete_breakpoint (struct breakpoint
*b
, void *ignore
)
14004 iterate_over_related_breakpoints (b
, do_delete_breakpoint
, NULL
);
14008 delete_command (char *arg
, int from_tty
)
14010 struct breakpoint
*b
, *b_tmp
;
14016 int breaks_to_delete
= 0;
14018 /* Delete all breakpoints if no argument. Do not delete
14019 internal breakpoints, these have to be deleted with an
14020 explicit breakpoint number argument. */
14021 ALL_BREAKPOINTS (b
)
14022 if (user_breakpoint_p (b
))
14024 breaks_to_delete
= 1;
14028 /* Ask user only if there are some breakpoints to delete. */
14030 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
14032 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
14033 if (user_breakpoint_p (b
))
14034 delete_breakpoint (b
);
14038 map_breakpoint_numbers (arg
, do_map_delete_breakpoint
, NULL
);
14041 /* Return true if all locations of B bound to PSPACE are pending. If
14042 PSPACE is NULL, all locations of all program spaces are
14046 all_locations_are_pending (struct breakpoint
*b
, struct program_space
*pspace
)
14048 struct bp_location
*loc
;
14050 for (loc
= b
->loc
; loc
!= NULL
; loc
= loc
->next
)
14051 if ((pspace
== NULL
14052 || loc
->pspace
== pspace
)
14053 && !loc
->shlib_disabled
14054 && !loc
->pspace
->executing_startup
)
14059 /* Subroutine of update_breakpoint_locations to simplify it.
14060 Return non-zero if multiple fns in list LOC have the same name.
14061 Null names are ignored. */
14064 ambiguous_names_p (struct bp_location
*loc
)
14066 struct bp_location
*l
;
14067 htab_t htab
= htab_create_alloc (13, htab_hash_string
,
14068 (int (*) (const void *,
14069 const void *)) streq
,
14070 NULL
, xcalloc
, xfree
);
14072 for (l
= loc
; l
!= NULL
; l
= l
->next
)
14075 const char *name
= l
->function_name
;
14077 /* Allow for some names to be NULL, ignore them. */
14081 slot
= (const char **) htab_find_slot (htab
, (const void *) name
,
14083 /* NOTE: We can assume slot != NULL here because xcalloc never
14087 htab_delete (htab
);
14093 htab_delete (htab
);
14097 /* When symbols change, it probably means the sources changed as well,
14098 and it might mean the static tracepoint markers are no longer at
14099 the same address or line numbers they used to be at last we
14100 checked. Losing your static tracepoints whenever you rebuild is
14101 undesirable. This function tries to resync/rematch gdb static
14102 tracepoints with the markers on the target, for static tracepoints
14103 that have not been set by marker id. Static tracepoint that have
14104 been set by marker id are reset by marker id in breakpoint_re_set.
14107 1) For a tracepoint set at a specific address, look for a marker at
14108 the old PC. If one is found there, assume to be the same marker.
14109 If the name / string id of the marker found is different from the
14110 previous known name, assume that means the user renamed the marker
14111 in the sources, and output a warning.
14113 2) For a tracepoint set at a given line number, look for a marker
14114 at the new address of the old line number. If one is found there,
14115 assume to be the same marker. If the name / string id of the
14116 marker found is different from the previous known name, assume that
14117 means the user renamed the marker in the sources, and output a
14120 3) If a marker is no longer found at the same address or line, it
14121 may mean the marker no longer exists. But it may also just mean
14122 the code changed a bit. Maybe the user added a few lines of code
14123 that made the marker move up or down (in line number terms). Ask
14124 the target for info about the marker with the string id as we knew
14125 it. If found, update line number and address in the matching
14126 static tracepoint. This will get confused if there's more than one
14127 marker with the same ID (possible in UST, although unadvised
14128 precisely because it confuses tools). */
14130 static struct symtab_and_line
14131 update_static_tracepoint (struct breakpoint
*b
, struct symtab_and_line sal
)
14133 struct tracepoint
*tp
= (struct tracepoint
*) b
;
14134 struct static_tracepoint_marker marker
;
14139 find_line_pc (sal
.symtab
, sal
.line
, &pc
);
14141 if (target_static_tracepoint_marker_at (pc
, &marker
))
14143 if (strcmp (tp
->static_trace_marker_id
, marker
.str_id
) != 0)
14144 warning (_("static tracepoint %d changed probed marker from %s to %s"),
14146 tp
->static_trace_marker_id
, marker
.str_id
);
14148 xfree (tp
->static_trace_marker_id
);
14149 tp
->static_trace_marker_id
= xstrdup (marker
.str_id
);
14150 release_static_tracepoint_marker (&marker
);
14155 /* Old marker wasn't found on target at lineno. Try looking it up
14157 if (!sal
.explicit_pc
14159 && sal
.symtab
!= NULL
14160 && tp
->static_trace_marker_id
!= NULL
)
14162 VEC(static_tracepoint_marker_p
) *markers
;
14165 = target_static_tracepoint_markers_by_strid (tp
->static_trace_marker_id
);
14167 if (!VEC_empty(static_tracepoint_marker_p
, markers
))
14169 struct symtab_and_line sal2
;
14170 struct symbol
*sym
;
14171 struct static_tracepoint_marker
*tpmarker
;
14172 struct ui_out
*uiout
= current_uiout
;
14173 struct explicit_location explicit_loc
;
14175 tpmarker
= VEC_index (static_tracepoint_marker_p
, markers
, 0);
14177 xfree (tp
->static_trace_marker_id
);
14178 tp
->static_trace_marker_id
= xstrdup (tpmarker
->str_id
);
14180 warning (_("marker for static tracepoint %d (%s) not "
14181 "found at previous line number"),
14182 b
->number
, tp
->static_trace_marker_id
);
14186 sal2
.pc
= tpmarker
->address
;
14188 sal2
= find_pc_line (tpmarker
->address
, 0);
14189 sym
= find_pc_sect_function (tpmarker
->address
, NULL
);
14190 ui_out_text (uiout
, "Now in ");
14193 ui_out_field_string (uiout
, "func",
14194 SYMBOL_PRINT_NAME (sym
));
14195 ui_out_text (uiout
, " at ");
14197 ui_out_field_string (uiout
, "file",
14198 symtab_to_filename_for_display (sal2
.symtab
));
14199 ui_out_text (uiout
, ":");
14201 if (ui_out_is_mi_like_p (uiout
))
14203 const char *fullname
= symtab_to_fullname (sal2
.symtab
);
14205 ui_out_field_string (uiout
, "fullname", fullname
);
14208 ui_out_field_int (uiout
, "line", sal2
.line
);
14209 ui_out_text (uiout
, "\n");
14211 b
->loc
->line_number
= sal2
.line
;
14212 b
->loc
->symtab
= sym
!= NULL
? sal2
.symtab
: NULL
;
14214 delete_event_location (b
->location
);
14215 initialize_explicit_location (&explicit_loc
);
14216 explicit_loc
.source_filename
14217 = ASTRDUP (symtab_to_filename_for_display (sal2
.symtab
));
14218 explicit_loc
.line_offset
.offset
= b
->loc
->line_number
;
14219 explicit_loc
.line_offset
.sign
= LINE_OFFSET_NONE
;
14220 b
->location
= new_explicit_location (&explicit_loc
);
14222 /* Might be nice to check if function changed, and warn if
14225 release_static_tracepoint_marker (tpmarker
);
14231 /* Returns 1 iff locations A and B are sufficiently same that
14232 we don't need to report breakpoint as changed. */
14235 locations_are_equal (struct bp_location
*a
, struct bp_location
*b
)
14239 if (a
->address
!= b
->address
)
14242 if (a
->shlib_disabled
!= b
->shlib_disabled
)
14245 if (a
->enabled
!= b
->enabled
)
14252 if ((a
== NULL
) != (b
== NULL
))
14258 /* Split all locations of B that are bound to PSPACE out of B's
14259 location list to a separate list and return that list's head. If
14260 PSPACE is NULL, hoist out all locations of B. */
14262 static struct bp_location
*
14263 hoist_existing_locations (struct breakpoint
*b
, struct program_space
*pspace
)
14265 struct bp_location head
;
14266 struct bp_location
*i
= b
->loc
;
14267 struct bp_location
**i_link
= &b
->loc
;
14268 struct bp_location
*hoisted
= &head
;
14270 if (pspace
== NULL
)
14281 if (i
->pspace
== pspace
)
14296 /* Create new breakpoint locations for B (a hardware or software
14297 breakpoint) based on SALS and SALS_END. If SALS_END.NELTS is not
14298 zero, then B is a ranged breakpoint. Only recreates locations for
14299 FILTER_PSPACE. Locations of other program spaces are left
14303 update_breakpoint_locations (struct breakpoint
*b
,
14304 struct program_space
*filter_pspace
,
14305 struct symtabs_and_lines sals
,
14306 struct symtabs_and_lines sals_end
)
14309 struct bp_location
*existing_locations
;
14311 if (sals_end
.nelts
!= 0 && (sals
.nelts
!= 1 || sals_end
.nelts
!= 1))
14313 /* Ranged breakpoints have only one start location and one end
14315 b
->enable_state
= bp_disabled
;
14316 printf_unfiltered (_("Could not reset ranged breakpoint %d: "
14317 "multiple locations found\n"),
14322 /* If there's no new locations, and all existing locations are
14323 pending, don't do anything. This optimizes the common case where
14324 all locations are in the same shared library, that was unloaded.
14325 We'd like to retain the location, so that when the library is
14326 loaded again, we don't loose the enabled/disabled status of the
14327 individual locations. */
14328 if (all_locations_are_pending (b
, filter_pspace
) && sals
.nelts
== 0)
14331 existing_locations
= hoist_existing_locations (b
, filter_pspace
);
14333 for (i
= 0; i
< sals
.nelts
; ++i
)
14335 struct bp_location
*new_loc
;
14337 switch_to_program_space_and_thread (sals
.sals
[i
].pspace
);
14339 new_loc
= add_location_to_breakpoint (b
, &(sals
.sals
[i
]));
14341 /* Reparse conditions, they might contain references to the
14343 if (b
->cond_string
!= NULL
)
14347 s
= b
->cond_string
;
14350 new_loc
->cond
= parse_exp_1 (&s
, sals
.sals
[i
].pc
,
14351 block_for_pc (sals
.sals
[i
].pc
),
14354 CATCH (e
, RETURN_MASK_ERROR
)
14356 warning (_("failed to reevaluate condition "
14357 "for breakpoint %d: %s"),
14358 b
->number
, e
.message
);
14359 new_loc
->enabled
= 0;
14364 if (sals_end
.nelts
)
14366 CORE_ADDR end
= find_breakpoint_range_end (sals_end
.sals
[0]);
14368 new_loc
->length
= end
- sals
.sals
[0].pc
+ 1;
14372 /* If possible, carry over 'disable' status from existing
14375 struct bp_location
*e
= existing_locations
;
14376 /* If there are multiple breakpoints with the same function name,
14377 e.g. for inline functions, comparing function names won't work.
14378 Instead compare pc addresses; this is just a heuristic as things
14379 may have moved, but in practice it gives the correct answer
14380 often enough until a better solution is found. */
14381 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
14383 for (; e
; e
= e
->next
)
14385 if (!e
->enabled
&& e
->function_name
)
14387 struct bp_location
*l
= b
->loc
;
14388 if (have_ambiguous_names
)
14390 for (; l
; l
= l
->next
)
14391 if (breakpoint_locations_match (e
, l
))
14399 for (; l
; l
= l
->next
)
14400 if (l
->function_name
14401 && strcmp (e
->function_name
, l
->function_name
) == 0)
14411 if (!locations_are_equal (existing_locations
, b
->loc
))
14412 observer_notify_breakpoint_modified (b
);
14415 /* Find the SaL locations corresponding to the given LOCATION.
14416 On return, FOUND will be 1 if any SaL was found, zero otherwise. */
14418 static struct symtabs_and_lines
14419 location_to_sals (struct breakpoint
*b
, struct event_location
*location
,
14420 struct program_space
*search_pspace
, int *found
)
14422 struct symtabs_and_lines sals
= {0};
14423 struct gdb_exception exception
= exception_none
;
14425 gdb_assert (b
->ops
!= NULL
);
14429 b
->ops
->decode_location (b
, location
, search_pspace
, &sals
);
14431 CATCH (e
, RETURN_MASK_ERROR
)
14433 int not_found_and_ok
= 0;
14437 /* For pending breakpoints, it's expected that parsing will
14438 fail until the right shared library is loaded. User has
14439 already told to create pending breakpoints and don't need
14440 extra messages. If breakpoint is in bp_shlib_disabled
14441 state, then user already saw the message about that
14442 breakpoint being disabled, and don't want to see more
14444 if (e
.error
== NOT_FOUND_ERROR
14445 && (b
->condition_not_parsed
14447 && search_pspace
!= NULL
14448 && b
->loc
->pspace
!= search_pspace
)
14449 || (b
->loc
&& b
->loc
->shlib_disabled
)
14450 || (b
->loc
&& b
->loc
->pspace
->executing_startup
)
14451 || b
->enable_state
== bp_disabled
))
14452 not_found_and_ok
= 1;
14454 if (!not_found_and_ok
)
14456 /* We surely don't want to warn about the same breakpoint
14457 10 times. One solution, implemented here, is disable
14458 the breakpoint on error. Another solution would be to
14459 have separate 'warning emitted' flag. Since this
14460 happens only when a binary has changed, I don't know
14461 which approach is better. */
14462 b
->enable_state
= bp_disabled
;
14463 throw_exception (e
);
14468 if (exception
.reason
== 0 || exception
.error
!= NOT_FOUND_ERROR
)
14472 for (i
= 0; i
< sals
.nelts
; ++i
)
14473 resolve_sal_pc (&sals
.sals
[i
]);
14474 if (b
->condition_not_parsed
&& b
->extra_string
!= NULL
)
14476 char *cond_string
, *extra_string
;
14479 find_condition_and_thread (b
->extra_string
, sals
.sals
[0].pc
,
14480 &cond_string
, &thread
, &task
,
14482 gdb_assert (b
->cond_string
== NULL
);
14484 b
->cond_string
= cond_string
;
14485 b
->thread
= thread
;
14489 xfree (b
->extra_string
);
14490 b
->extra_string
= extra_string
;
14492 b
->condition_not_parsed
= 0;
14495 if (b
->type
== bp_static_tracepoint
&& !strace_marker_p (b
))
14496 sals
.sals
[0] = update_static_tracepoint (b
, sals
.sals
[0]);
14506 /* The default re_set method, for typical hardware or software
14507 breakpoints. Reevaluate the breakpoint and recreate its
14511 breakpoint_re_set_default (struct breakpoint
*b
)
14514 struct symtabs_and_lines sals
, sals_end
;
14515 struct symtabs_and_lines expanded
= {0};
14516 struct symtabs_and_lines expanded_end
= {0};
14517 struct program_space
*filter_pspace
= current_program_space
;
14519 sals
= location_to_sals (b
, b
->location
, filter_pspace
, &found
);
14522 make_cleanup (xfree
, sals
.sals
);
14526 if (b
->location_range_end
!= NULL
)
14528 sals_end
= location_to_sals (b
, b
->location_range_end
,
14529 filter_pspace
, &found
);
14532 make_cleanup (xfree
, sals_end
.sals
);
14533 expanded_end
= sals_end
;
14537 update_breakpoint_locations (b
, filter_pspace
, expanded
, expanded_end
);
14540 /* Default method for creating SALs from an address string. It basically
14541 calls parse_breakpoint_sals. Return 1 for success, zero for failure. */
14544 create_sals_from_location_default (const struct event_location
*location
,
14545 struct linespec_result
*canonical
,
14546 enum bptype type_wanted
)
14548 parse_breakpoint_sals (location
, canonical
);
14551 /* Call create_breakpoints_sal for the given arguments. This is the default
14552 function for the `create_breakpoints_sal' method of
14556 create_breakpoints_sal_default (struct gdbarch
*gdbarch
,
14557 struct linespec_result
*canonical
,
14559 char *extra_string
,
14560 enum bptype type_wanted
,
14561 enum bpdisp disposition
,
14563 int task
, int ignore_count
,
14564 const struct breakpoint_ops
*ops
,
14565 int from_tty
, int enabled
,
14566 int internal
, unsigned flags
)
14568 create_breakpoints_sal (gdbarch
, canonical
, cond_string
,
14570 type_wanted
, disposition
,
14571 thread
, task
, ignore_count
, ops
, from_tty
,
14572 enabled
, internal
, flags
);
14575 /* Decode the line represented by S by calling decode_line_full. This is the
14576 default function for the `decode_location' method of breakpoint_ops. */
14579 decode_location_default (struct breakpoint
*b
,
14580 const struct event_location
*location
,
14581 struct program_space
*search_pspace
,
14582 struct symtabs_and_lines
*sals
)
14584 struct linespec_result canonical
;
14586 init_linespec_result (&canonical
);
14587 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, search_pspace
,
14588 (struct symtab
*) NULL
, 0,
14589 &canonical
, multiple_symbols_all
,
14592 /* We should get 0 or 1 resulting SALs. */
14593 gdb_assert (VEC_length (linespec_sals
, canonical
.sals
) < 2);
14595 if (VEC_length (linespec_sals
, canonical
.sals
) > 0)
14597 struct linespec_sals
*lsal
;
14599 lsal
= VEC_index (linespec_sals
, canonical
.sals
, 0);
14600 *sals
= lsal
->sals
;
14601 /* Arrange it so the destructor does not free the
14603 lsal
->sals
.sals
= NULL
;
14606 destroy_linespec_result (&canonical
);
14609 /* Prepare the global context for a re-set of breakpoint B. */
14611 static struct cleanup
*
14612 prepare_re_set_context (struct breakpoint
*b
)
14614 input_radix
= b
->input_radix
;
14615 set_language (b
->language
);
14617 return make_cleanup (null_cleanup
, NULL
);
14620 /* Reset a breakpoint given it's struct breakpoint * BINT.
14621 The value we return ends up being the return value from catch_errors.
14622 Unused in this case. */
14625 breakpoint_re_set_one (void *bint
)
14627 /* Get past catch_errs. */
14628 struct breakpoint
*b
= (struct breakpoint
*) bint
;
14629 struct cleanup
*cleanups
;
14631 cleanups
= prepare_re_set_context (b
);
14632 b
->ops
->re_set (b
);
14633 do_cleanups (cleanups
);
14637 /* Re-set breakpoint locations for the current program space.
14638 Locations bound to other program spaces are left untouched. */
14641 breakpoint_re_set (void)
14643 struct breakpoint
*b
, *b_tmp
;
14644 enum language save_language
;
14645 int save_input_radix
;
14646 struct cleanup
*old_chain
;
14648 save_language
= current_language
->la_language
;
14649 save_input_radix
= input_radix
;
14650 old_chain
= save_current_space_and_thread ();
14652 /* Note: we must not try to insert locations until after all
14653 breakpoints have been re-set. Otherwise, e.g., when re-setting
14654 breakpoint 1, we'd insert the locations of breakpoint 2, which
14655 hadn't been re-set yet, and thus may have stale locations. */
14657 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
14659 /* Format possible error msg. */
14660 char *message
= xstrprintf ("Error in re-setting breakpoint %d: ",
14662 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
14663 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
14664 do_cleanups (cleanups
);
14666 set_language (save_language
);
14667 input_radix
= save_input_radix
;
14669 jit_breakpoint_re_set ();
14671 do_cleanups (old_chain
);
14673 create_overlay_event_breakpoint ();
14674 create_longjmp_master_breakpoint ();
14675 create_std_terminate_master_breakpoint ();
14676 create_exception_master_breakpoint ();
14678 /* Now we can insert. */
14679 update_global_location_list (UGLL_MAY_INSERT
);
14682 /* Reset the thread number of this breakpoint:
14684 - If the breakpoint is for all threads, leave it as-is.
14685 - Else, reset it to the current thread for inferior_ptid. */
14687 breakpoint_re_set_thread (struct breakpoint
*b
)
14689 if (b
->thread
!= -1)
14691 if (in_thread_list (inferior_ptid
))
14692 b
->thread
= ptid_to_global_thread_id (inferior_ptid
);
14694 /* We're being called after following a fork. The new fork is
14695 selected as current, and unless this was a vfork will have a
14696 different program space from the original thread. Reset that
14698 b
->loc
->pspace
= current_program_space
;
14702 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14703 If from_tty is nonzero, it prints a message to that effect,
14704 which ends with a period (no newline). */
14707 set_ignore_count (int bptnum
, int count
, int from_tty
)
14709 struct breakpoint
*b
;
14714 ALL_BREAKPOINTS (b
)
14715 if (b
->number
== bptnum
)
14717 if (is_tracepoint (b
))
14719 if (from_tty
&& count
!= 0)
14720 printf_filtered (_("Ignore count ignored for tracepoint %d."),
14725 b
->ignore_count
= count
;
14729 printf_filtered (_("Will stop next time "
14730 "breakpoint %d is reached."),
14732 else if (count
== 1)
14733 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
14736 printf_filtered (_("Will ignore next %d "
14737 "crossings of breakpoint %d."),
14740 observer_notify_breakpoint_modified (b
);
14744 error (_("No breakpoint number %d."), bptnum
);
14747 /* Command to set ignore-count of breakpoint N to COUNT. */
14750 ignore_command (char *args
, int from_tty
)
14756 error_no_arg (_("a breakpoint number"));
14758 num
= get_number (&p
);
14760 error (_("bad breakpoint number: '%s'"), args
);
14762 error (_("Second argument (specified ignore-count) is missing."));
14764 set_ignore_count (num
,
14765 longest_to_int (value_as_long (parse_and_eval (p
))),
14768 printf_filtered ("\n");
14771 /* Call FUNCTION on each of the breakpoints
14772 whose numbers are given in ARGS. */
14775 map_breakpoint_numbers (char *args
, void (*function
) (struct breakpoint
*,
14780 struct breakpoint
*b
, *tmp
;
14782 struct get_number_or_range_state state
;
14784 if (args
== 0 || *args
== '\0')
14785 error_no_arg (_("one or more breakpoint numbers"));
14787 init_number_or_range (&state
, args
);
14789 while (!state
.finished
)
14791 const char *p
= state
.string
;
14795 num
= get_number_or_range (&state
);
14798 warning (_("bad breakpoint number at or near '%s'"), p
);
14802 ALL_BREAKPOINTS_SAFE (b
, tmp
)
14803 if (b
->number
== num
)
14806 function (b
, data
);
14810 printf_unfiltered (_("No breakpoint number %d.\n"), num
);
14815 static struct bp_location
*
14816 find_location_by_number (char *number
)
14818 char *dot
= strchr (number
, '.');
14822 struct breakpoint
*b
;
14823 struct bp_location
*loc
;
14828 bp_num
= get_number (&p1
);
14830 error (_("Bad breakpoint number '%s'"), number
);
14832 ALL_BREAKPOINTS (b
)
14833 if (b
->number
== bp_num
)
14838 if (!b
|| b
->number
!= bp_num
)
14839 error (_("Bad breakpoint number '%s'"), number
);
14842 loc_num
= get_number (&p1
);
14844 error (_("Bad breakpoint location number '%s'"), number
);
14848 for (;loc_num
&& loc
; --loc_num
, loc
= loc
->next
)
14851 error (_("Bad breakpoint location number '%s'"), dot
+1);
14857 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14858 If from_tty is nonzero, it prints a message to that effect,
14859 which ends with a period (no newline). */
14862 disable_breakpoint (struct breakpoint
*bpt
)
14864 /* Never disable a watchpoint scope breakpoint; we want to
14865 hit them when we leave scope so we can delete both the
14866 watchpoint and its scope breakpoint at that time. */
14867 if (bpt
->type
== bp_watchpoint_scope
)
14870 bpt
->enable_state
= bp_disabled
;
14872 /* Mark breakpoint locations modified. */
14873 mark_breakpoint_modified (bpt
);
14875 if (target_supports_enable_disable_tracepoint ()
14876 && current_trace_status ()->running
&& is_tracepoint (bpt
))
14878 struct bp_location
*location
;
14880 for (location
= bpt
->loc
; location
; location
= location
->next
)
14881 target_disable_tracepoint (location
);
14884 update_global_location_list (UGLL_DONT_INSERT
);
14886 observer_notify_breakpoint_modified (bpt
);
14889 /* A callback for iterate_over_related_breakpoints. */
14892 do_disable_breakpoint (struct breakpoint
*b
, void *ignore
)
14894 disable_breakpoint (b
);
14897 /* A callback for map_breakpoint_numbers that calls
14898 disable_breakpoint. */
14901 do_map_disable_breakpoint (struct breakpoint
*b
, void *ignore
)
14903 iterate_over_related_breakpoints (b
, do_disable_breakpoint
, NULL
);
14907 disable_command (char *args
, int from_tty
)
14911 struct breakpoint
*bpt
;
14913 ALL_BREAKPOINTS (bpt
)
14914 if (user_breakpoint_p (bpt
))
14915 disable_breakpoint (bpt
);
14919 char *num
= extract_arg (&args
);
14923 if (strchr (num
, '.'))
14925 struct bp_location
*loc
= find_location_by_number (num
);
14932 mark_breakpoint_location_modified (loc
);
14934 if (target_supports_enable_disable_tracepoint ()
14935 && current_trace_status ()->running
&& loc
->owner
14936 && is_tracepoint (loc
->owner
))
14937 target_disable_tracepoint (loc
);
14939 update_global_location_list (UGLL_DONT_INSERT
);
14942 map_breakpoint_numbers (num
, do_map_disable_breakpoint
, NULL
);
14943 num
= extract_arg (&args
);
14949 enable_breakpoint_disp (struct breakpoint
*bpt
, enum bpdisp disposition
,
14952 int target_resources_ok
;
14954 if (bpt
->type
== bp_hardware_breakpoint
)
14957 i
= hw_breakpoint_used_count ();
14958 target_resources_ok
=
14959 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
14961 if (target_resources_ok
== 0)
14962 error (_("No hardware breakpoint support in the target."));
14963 else if (target_resources_ok
< 0)
14964 error (_("Hardware breakpoints used exceeds limit."));
14967 if (is_watchpoint (bpt
))
14969 /* Initialize it just to avoid a GCC false warning. */
14970 enum enable_state orig_enable_state
= bp_disabled
;
14974 struct watchpoint
*w
= (struct watchpoint
*) bpt
;
14976 orig_enable_state
= bpt
->enable_state
;
14977 bpt
->enable_state
= bp_enabled
;
14978 update_watchpoint (w
, 1 /* reparse */);
14980 CATCH (e
, RETURN_MASK_ALL
)
14982 bpt
->enable_state
= orig_enable_state
;
14983 exception_fprintf (gdb_stderr
, e
, _("Cannot enable watchpoint %d: "),
14990 bpt
->enable_state
= bp_enabled
;
14992 /* Mark breakpoint locations modified. */
14993 mark_breakpoint_modified (bpt
);
14995 if (target_supports_enable_disable_tracepoint ()
14996 && current_trace_status ()->running
&& is_tracepoint (bpt
))
14998 struct bp_location
*location
;
15000 for (location
= bpt
->loc
; location
; location
= location
->next
)
15001 target_enable_tracepoint (location
);
15004 bpt
->disposition
= disposition
;
15005 bpt
->enable_count
= count
;
15006 update_global_location_list (UGLL_MAY_INSERT
);
15008 observer_notify_breakpoint_modified (bpt
);
15013 enable_breakpoint (struct breakpoint
*bpt
)
15015 enable_breakpoint_disp (bpt
, bpt
->disposition
, 0);
15019 do_enable_breakpoint (struct breakpoint
*bpt
, void *arg
)
15021 enable_breakpoint (bpt
);
15024 /* A callback for map_breakpoint_numbers that calls
15025 enable_breakpoint. */
15028 do_map_enable_breakpoint (struct breakpoint
*b
, void *ignore
)
15030 iterate_over_related_breakpoints (b
, do_enable_breakpoint
, NULL
);
15033 /* The enable command enables the specified breakpoints (or all defined
15034 breakpoints) so they once again become (or continue to be) effective
15035 in stopping the inferior. */
15038 enable_command (char *args
, int from_tty
)
15042 struct breakpoint
*bpt
;
15044 ALL_BREAKPOINTS (bpt
)
15045 if (user_breakpoint_p (bpt
))
15046 enable_breakpoint (bpt
);
15050 char *num
= extract_arg (&args
);
15054 if (strchr (num
, '.'))
15056 struct bp_location
*loc
= find_location_by_number (num
);
15063 mark_breakpoint_location_modified (loc
);
15065 if (target_supports_enable_disable_tracepoint ()
15066 && current_trace_status ()->running
&& loc
->owner
15067 && is_tracepoint (loc
->owner
))
15068 target_enable_tracepoint (loc
);
15070 update_global_location_list (UGLL_MAY_INSERT
);
15073 map_breakpoint_numbers (num
, do_map_enable_breakpoint
, NULL
);
15074 num
= extract_arg (&args
);
15079 /* This struct packages up disposition data for application to multiple
15089 do_enable_breakpoint_disp (struct breakpoint
*bpt
, void *arg
)
15091 struct disp_data disp_data
= *(struct disp_data
*) arg
;
15093 enable_breakpoint_disp (bpt
, disp_data
.disp
, disp_data
.count
);
15097 do_map_enable_once_breakpoint (struct breakpoint
*bpt
, void *ignore
)
15099 struct disp_data disp
= { disp_disable
, 1 };
15101 iterate_over_related_breakpoints (bpt
, do_enable_breakpoint_disp
, &disp
);
15105 enable_once_command (char *args
, int from_tty
)
15107 map_breakpoint_numbers (args
, do_map_enable_once_breakpoint
, NULL
);
15111 do_map_enable_count_breakpoint (struct breakpoint
*bpt
, void *countptr
)
15113 struct disp_data disp
= { disp_disable
, *(int *) countptr
};
15115 iterate_over_related_breakpoints (bpt
, do_enable_breakpoint_disp
, &disp
);
15119 enable_count_command (char *args
, int from_tty
)
15124 error_no_arg (_("hit count"));
15126 count
= get_number (&args
);
15128 map_breakpoint_numbers (args
, do_map_enable_count_breakpoint
, &count
);
15132 do_map_enable_delete_breakpoint (struct breakpoint
*bpt
, void *ignore
)
15134 struct disp_data disp
= { disp_del
, 1 };
15136 iterate_over_related_breakpoints (bpt
, do_enable_breakpoint_disp
, &disp
);
15140 enable_delete_command (char *args
, int from_tty
)
15142 map_breakpoint_numbers (args
, do_map_enable_delete_breakpoint
, NULL
);
15146 set_breakpoint_cmd (char *args
, int from_tty
)
15151 show_breakpoint_cmd (char *args
, int from_tty
)
15155 /* Invalidate last known value of any hardware watchpoint if
15156 the memory which that value represents has been written to by
15160 invalidate_bp_value_on_memory_change (struct inferior
*inferior
,
15161 CORE_ADDR addr
, ssize_t len
,
15162 const bfd_byte
*data
)
15164 struct breakpoint
*bp
;
15166 ALL_BREAKPOINTS (bp
)
15167 if (bp
->enable_state
== bp_enabled
15168 && bp
->type
== bp_hardware_watchpoint
)
15170 struct watchpoint
*wp
= (struct watchpoint
*) bp
;
15172 if (wp
->val_valid
&& wp
->val
)
15174 struct bp_location
*loc
;
15176 for (loc
= bp
->loc
; loc
!= NULL
; loc
= loc
->next
)
15177 if (loc
->loc_type
== bp_loc_hardware_watchpoint
15178 && loc
->address
+ loc
->length
> addr
15179 && addr
+ len
> loc
->address
)
15181 value_free (wp
->val
);
15189 /* Create and insert a breakpoint for software single step. */
15192 insert_single_step_breakpoint (struct gdbarch
*gdbarch
,
15193 struct address_space
*aspace
,
15196 struct thread_info
*tp
= inferior_thread ();
15197 struct symtab_and_line sal
;
15198 CORE_ADDR pc
= next_pc
;
15200 if (tp
->control
.single_step_breakpoints
== NULL
)
15202 tp
->control
.single_step_breakpoints
15203 = new_single_step_breakpoint (tp
->global_num
, gdbarch
);
15206 sal
= find_pc_line (pc
, 0);
15208 sal
.section
= find_pc_overlay (pc
);
15209 sal
.explicit_pc
= 1;
15210 add_location_to_breakpoint (tp
->control
.single_step_breakpoints
, &sal
);
15212 update_global_location_list (UGLL_INSERT
);
15215 /* See breakpoint.h. */
15218 breakpoint_has_location_inserted_here (struct breakpoint
*bp
,
15219 struct address_space
*aspace
,
15222 struct bp_location
*loc
;
15224 for (loc
= bp
->loc
; loc
!= NULL
; loc
= loc
->next
)
15226 && breakpoint_location_address_match (loc
, aspace
, pc
))
15232 /* Check whether a software single-step breakpoint is inserted at
15236 single_step_breakpoint_inserted_here_p (struct address_space
*aspace
,
15239 struct breakpoint
*bpt
;
15241 ALL_BREAKPOINTS (bpt
)
15243 if (bpt
->type
== bp_single_step
15244 && breakpoint_has_location_inserted_here (bpt
, aspace
, pc
))
15250 /* Tracepoint-specific operations. */
15252 /* Set tracepoint count to NUM. */
15254 set_tracepoint_count (int num
)
15256 tracepoint_count
= num
;
15257 set_internalvar_integer (lookup_internalvar ("tpnum"), num
);
15261 trace_command (char *arg
, int from_tty
)
15263 struct breakpoint_ops
*ops
;
15264 struct event_location
*location
;
15265 struct cleanup
*back_to
;
15267 location
= string_to_event_location (&arg
, current_language
);
15268 back_to
= make_cleanup_delete_event_location (location
);
15269 if (location
!= NULL
15270 && event_location_type (location
) == PROBE_LOCATION
)
15271 ops
= &tracepoint_probe_breakpoint_ops
;
15273 ops
= &tracepoint_breakpoint_ops
;
15275 create_breakpoint (get_current_arch (),
15277 NULL
, 0, arg
, 1 /* parse arg */,
15279 bp_tracepoint
/* type_wanted */,
15280 0 /* Ignore count */,
15281 pending_break_support
,
15285 0 /* internal */, 0);
15286 do_cleanups (back_to
);
15290 ftrace_command (char *arg
, int from_tty
)
15292 struct event_location
*location
;
15293 struct cleanup
*back_to
;
15295 location
= string_to_event_location (&arg
, current_language
);
15296 back_to
= make_cleanup_delete_event_location (location
);
15297 create_breakpoint (get_current_arch (),
15299 NULL
, 0, arg
, 1 /* parse arg */,
15301 bp_fast_tracepoint
/* type_wanted */,
15302 0 /* Ignore count */,
15303 pending_break_support
,
15304 &tracepoint_breakpoint_ops
,
15307 0 /* internal */, 0);
15308 do_cleanups (back_to
);
15311 /* strace command implementation. Creates a static tracepoint. */
15314 strace_command (char *arg
, int from_tty
)
15316 struct breakpoint_ops
*ops
;
15317 struct event_location
*location
;
15318 struct cleanup
*back_to
;
15320 /* Decide if we are dealing with a static tracepoint marker (`-m'),
15321 or with a normal static tracepoint. */
15322 if (arg
&& startswith (arg
, "-m") && isspace (arg
[2]))
15324 ops
= &strace_marker_breakpoint_ops
;
15325 location
= new_linespec_location (&arg
);
15329 ops
= &tracepoint_breakpoint_ops
;
15330 location
= string_to_event_location (&arg
, current_language
);
15333 back_to
= make_cleanup_delete_event_location (location
);
15334 create_breakpoint (get_current_arch (),
15336 NULL
, 0, arg
, 1 /* parse arg */,
15338 bp_static_tracepoint
/* type_wanted */,
15339 0 /* Ignore count */,
15340 pending_break_support
,
15344 0 /* internal */, 0);
15345 do_cleanups (back_to
);
15348 /* Set up a fake reader function that gets command lines from a linked
15349 list that was acquired during tracepoint uploading. */
15351 static struct uploaded_tp
*this_utp
;
15352 static int next_cmd
;
15355 read_uploaded_action (void)
15359 VEC_iterate (char_ptr
, this_utp
->cmd_strings
, next_cmd
, rslt
);
15366 /* Given information about a tracepoint as recorded on a target (which
15367 can be either a live system or a trace file), attempt to create an
15368 equivalent GDB tracepoint. This is not a reliable process, since
15369 the target does not necessarily have all the information used when
15370 the tracepoint was originally defined. */
15372 struct tracepoint
*
15373 create_tracepoint_from_upload (struct uploaded_tp
*utp
)
15375 char *addr_str
, small_buf
[100];
15376 struct tracepoint
*tp
;
15377 struct event_location
*location
;
15378 struct cleanup
*cleanup
;
15380 if (utp
->at_string
)
15381 addr_str
= utp
->at_string
;
15384 /* In the absence of a source location, fall back to raw
15385 address. Since there is no way to confirm that the address
15386 means the same thing as when the trace was started, warn the
15388 warning (_("Uploaded tracepoint %d has no "
15389 "source location, using raw address"),
15391 xsnprintf (small_buf
, sizeof (small_buf
), "*%s", hex_string (utp
->addr
));
15392 addr_str
= small_buf
;
15395 /* There's not much we can do with a sequence of bytecodes. */
15396 if (utp
->cond
&& !utp
->cond_string
)
15397 warning (_("Uploaded tracepoint %d condition "
15398 "has no source form, ignoring it"),
15401 location
= string_to_event_location (&addr_str
, current_language
);
15402 cleanup
= make_cleanup_delete_event_location (location
);
15403 if (!create_breakpoint (get_current_arch (),
15405 utp
->cond_string
, -1, addr_str
,
15406 0 /* parse cond/thread */,
15408 utp
->type
/* type_wanted */,
15409 0 /* Ignore count */,
15410 pending_break_support
,
15411 &tracepoint_breakpoint_ops
,
15413 utp
->enabled
/* enabled */,
15415 CREATE_BREAKPOINT_FLAGS_INSERTED
))
15417 do_cleanups (cleanup
);
15421 do_cleanups (cleanup
);
15423 /* Get the tracepoint we just created. */
15424 tp
= get_tracepoint (tracepoint_count
);
15425 gdb_assert (tp
!= NULL
);
15429 xsnprintf (small_buf
, sizeof (small_buf
), "%d %d", utp
->pass
,
15432 trace_pass_command (small_buf
, 0);
15435 /* If we have uploaded versions of the original commands, set up a
15436 special-purpose "reader" function and call the usual command line
15437 reader, then pass the result to the breakpoint command-setting
15439 if (!VEC_empty (char_ptr
, utp
->cmd_strings
))
15441 struct command_line
*cmd_list
;
15446 cmd_list
= read_command_lines_1 (read_uploaded_action
, 1, NULL
, NULL
);
15448 breakpoint_set_commands (&tp
->base
, cmd_list
);
15450 else if (!VEC_empty (char_ptr
, utp
->actions
)
15451 || !VEC_empty (char_ptr
, utp
->step_actions
))
15452 warning (_("Uploaded tracepoint %d actions "
15453 "have no source form, ignoring them"),
15456 /* Copy any status information that might be available. */
15457 tp
->base
.hit_count
= utp
->hit_count
;
15458 tp
->traceframe_usage
= utp
->traceframe_usage
;
15463 /* Print information on tracepoint number TPNUM_EXP, or all if
15467 tracepoints_info (char *args
, int from_tty
)
15469 struct ui_out
*uiout
= current_uiout
;
15472 num_printed
= breakpoint_1 (args
, 0, is_tracepoint
);
15474 if (num_printed
== 0)
15476 if (args
== NULL
|| *args
== '\0')
15477 ui_out_message (uiout
, 0, "No tracepoints.\n");
15479 ui_out_message (uiout
, 0, "No tracepoint matching '%s'.\n", args
);
15482 default_collect_info ();
15485 /* The 'enable trace' command enables tracepoints.
15486 Not supported by all targets. */
15488 enable_trace_command (char *args
, int from_tty
)
15490 enable_command (args
, from_tty
);
15493 /* The 'disable trace' command disables tracepoints.
15494 Not supported by all targets. */
15496 disable_trace_command (char *args
, int from_tty
)
15498 disable_command (args
, from_tty
);
15501 /* Remove a tracepoint (or all if no argument). */
15503 delete_trace_command (char *arg
, int from_tty
)
15505 struct breakpoint
*b
, *b_tmp
;
15511 int breaks_to_delete
= 0;
15513 /* Delete all breakpoints if no argument.
15514 Do not delete internal or call-dummy breakpoints, these
15515 have to be deleted with an explicit breakpoint number
15517 ALL_TRACEPOINTS (b
)
15518 if (is_tracepoint (b
) && user_breakpoint_p (b
))
15520 breaks_to_delete
= 1;
15524 /* Ask user only if there are some breakpoints to delete. */
15526 || (breaks_to_delete
&& query (_("Delete all tracepoints? "))))
15528 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
15529 if (is_tracepoint (b
) && user_breakpoint_p (b
))
15530 delete_breakpoint (b
);
15534 map_breakpoint_numbers (arg
, do_map_delete_breakpoint
, NULL
);
15537 /* Helper function for trace_pass_command. */
15540 trace_pass_set_count (struct tracepoint
*tp
, int count
, int from_tty
)
15542 tp
->pass_count
= count
;
15543 observer_notify_breakpoint_modified (&tp
->base
);
15545 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
15546 tp
->base
.number
, count
);
15549 /* Set passcount for tracepoint.
15551 First command argument is passcount, second is tracepoint number.
15552 If tracepoint number omitted, apply to most recently defined.
15553 Also accepts special argument "all". */
15556 trace_pass_command (char *args
, int from_tty
)
15558 struct tracepoint
*t1
;
15559 unsigned int count
;
15561 if (args
== 0 || *args
== 0)
15562 error (_("passcount command requires an "
15563 "argument (count + optional TP num)"));
15565 count
= strtoul (args
, &args
, 10); /* Count comes first, then TP num. */
15567 args
= skip_spaces (args
);
15568 if (*args
&& strncasecmp (args
, "all", 3) == 0)
15570 struct breakpoint
*b
;
15572 args
+= 3; /* Skip special argument "all". */
15574 error (_("Junk at end of arguments."));
15576 ALL_TRACEPOINTS (b
)
15578 t1
= (struct tracepoint
*) b
;
15579 trace_pass_set_count (t1
, count
, from_tty
);
15582 else if (*args
== '\0')
15584 t1
= get_tracepoint_by_number (&args
, NULL
);
15586 trace_pass_set_count (t1
, count
, from_tty
);
15590 struct get_number_or_range_state state
;
15592 init_number_or_range (&state
, args
);
15593 while (!state
.finished
)
15595 t1
= get_tracepoint_by_number (&args
, &state
);
15597 trace_pass_set_count (t1
, count
, from_tty
);
15602 struct tracepoint
*
15603 get_tracepoint (int num
)
15605 struct breakpoint
*t
;
15607 ALL_TRACEPOINTS (t
)
15608 if (t
->number
== num
)
15609 return (struct tracepoint
*) t
;
15614 /* Find the tracepoint with the given target-side number (which may be
15615 different from the tracepoint number after disconnecting and
15618 struct tracepoint
*
15619 get_tracepoint_by_number_on_target (int num
)
15621 struct breakpoint
*b
;
15623 ALL_TRACEPOINTS (b
)
15625 struct tracepoint
*t
= (struct tracepoint
*) b
;
15627 if (t
->number_on_target
== num
)
15634 /* Utility: parse a tracepoint number and look it up in the list.
15635 If STATE is not NULL, use, get_number_or_range_state and ignore ARG.
15636 If the argument is missing, the most recent tracepoint
15637 (tracepoint_count) is returned. */
15639 struct tracepoint
*
15640 get_tracepoint_by_number (char **arg
,
15641 struct get_number_or_range_state
*state
)
15643 struct breakpoint
*t
;
15645 char *instring
= arg
== NULL
? NULL
: *arg
;
15649 gdb_assert (!state
->finished
);
15650 tpnum
= get_number_or_range (state
);
15652 else if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
15653 tpnum
= tracepoint_count
;
15655 tpnum
= get_number (arg
);
15659 if (instring
&& *instring
)
15660 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
15663 printf_filtered (_("No previous tracepoint\n"));
15667 ALL_TRACEPOINTS (t
)
15668 if (t
->number
== tpnum
)
15670 return (struct tracepoint
*) t
;
15673 printf_unfiltered ("No tracepoint number %d.\n", tpnum
);
15678 print_recreate_thread (struct breakpoint
*b
, struct ui_file
*fp
)
15680 if (b
->thread
!= -1)
15681 fprintf_unfiltered (fp
, " thread %d", b
->thread
);
15684 fprintf_unfiltered (fp
, " task %d", b
->task
);
15686 fprintf_unfiltered (fp
, "\n");
15689 /* Save information on user settable breakpoints (watchpoints, etc) to
15690 a new script file named FILENAME. If FILTER is non-NULL, call it
15691 on each breakpoint and only include the ones for which it returns
15695 save_breakpoints (char *filename
, int from_tty
,
15696 int (*filter
) (const struct breakpoint
*))
15698 struct breakpoint
*tp
;
15700 struct cleanup
*cleanup
;
15701 struct ui_file
*fp
;
15702 int extra_trace_bits
= 0;
15704 if (filename
== 0 || *filename
== 0)
15705 error (_("Argument required (file name in which to save)"));
15707 /* See if we have anything to save. */
15708 ALL_BREAKPOINTS (tp
)
15710 /* Skip internal and momentary breakpoints. */
15711 if (!user_breakpoint_p (tp
))
15714 /* If we have a filter, only save the breakpoints it accepts. */
15715 if (filter
&& !filter (tp
))
15720 if (is_tracepoint (tp
))
15722 extra_trace_bits
= 1;
15724 /* We can stop searching. */
15731 warning (_("Nothing to save."));
15735 filename
= tilde_expand (filename
);
15736 cleanup
= make_cleanup (xfree
, filename
);
15737 fp
= gdb_fopen (filename
, "w");
15739 error (_("Unable to open file '%s' for saving (%s)"),
15740 filename
, safe_strerror (errno
));
15741 make_cleanup_ui_file_delete (fp
);
15743 if (extra_trace_bits
)
15744 save_trace_state_variables (fp
);
15746 ALL_BREAKPOINTS (tp
)
15748 /* Skip internal and momentary breakpoints. */
15749 if (!user_breakpoint_p (tp
))
15752 /* If we have a filter, only save the breakpoints it accepts. */
15753 if (filter
&& !filter (tp
))
15756 tp
->ops
->print_recreate (tp
, fp
);
15758 /* Note, we can't rely on tp->number for anything, as we can't
15759 assume the recreated breakpoint numbers will match. Use $bpnum
15762 if (tp
->cond_string
)
15763 fprintf_unfiltered (fp
, " condition $bpnum %s\n", tp
->cond_string
);
15765 if (tp
->ignore_count
)
15766 fprintf_unfiltered (fp
, " ignore $bpnum %d\n", tp
->ignore_count
);
15768 if (tp
->type
!= bp_dprintf
&& tp
->commands
)
15770 fprintf_unfiltered (fp
, " commands\n");
15772 ui_out_redirect (current_uiout
, fp
);
15775 print_command_lines (current_uiout
, tp
->commands
->commands
, 2);
15777 CATCH (ex
, RETURN_MASK_ALL
)
15779 ui_out_redirect (current_uiout
, NULL
);
15780 throw_exception (ex
);
15784 ui_out_redirect (current_uiout
, NULL
);
15785 fprintf_unfiltered (fp
, " end\n");
15788 if (tp
->enable_state
== bp_disabled
)
15789 fprintf_unfiltered (fp
, "disable $bpnum\n");
15791 /* If this is a multi-location breakpoint, check if the locations
15792 should be individually disabled. Watchpoint locations are
15793 special, and not user visible. */
15794 if (!is_watchpoint (tp
) && tp
->loc
&& tp
->loc
->next
)
15796 struct bp_location
*loc
;
15799 for (loc
= tp
->loc
; loc
!= NULL
; loc
= loc
->next
, n
++)
15801 fprintf_unfiltered (fp
, "disable $bpnum.%d\n", n
);
15805 if (extra_trace_bits
&& *default_collect
)
15806 fprintf_unfiltered (fp
, "set default-collect %s\n", default_collect
);
15809 printf_filtered (_("Saved to file '%s'.\n"), filename
);
15810 do_cleanups (cleanup
);
15813 /* The `save breakpoints' command. */
15816 save_breakpoints_command (char *args
, int from_tty
)
15818 save_breakpoints (args
, from_tty
, NULL
);
15821 /* The `save tracepoints' command. */
15824 save_tracepoints_command (char *args
, int from_tty
)
15826 save_breakpoints (args
, from_tty
, is_tracepoint
);
15829 /* Create a vector of all tracepoints. */
15831 VEC(breakpoint_p
) *
15832 all_tracepoints (void)
15834 VEC(breakpoint_p
) *tp_vec
= 0;
15835 struct breakpoint
*tp
;
15837 ALL_TRACEPOINTS (tp
)
15839 VEC_safe_push (breakpoint_p
, tp_vec
, tp
);
15846 /* This help string is used to consolidate all the help string for specifying
15847 locations used by several commands. */
15849 #define LOCATION_HELP_STRING \
15850 "Linespecs are colon-separated lists of location parameters, such as\n\
15851 source filename, function name, label name, and line number.\n\
15852 Example: To specify the start of a label named \"the_top\" in the\n\
15853 function \"fact\" in the file \"factorial.c\", use\n\
15854 \"factorial.c:fact:the_top\".\n\
15856 Address locations begin with \"*\" and specify an exact address in the\n\
15857 program. Example: To specify the fourth byte past the start function\n\
15858 \"main\", use \"*main + 4\".\n\
15860 Explicit locations are similar to linespecs but use an option/argument\n\
15861 syntax to specify location parameters.\n\
15862 Example: To specify the start of the label named \"the_top\" in the\n\
15863 function \"fact\" in the file \"factorial.c\", use \"-source factorial.c\n\
15864 -function fact -label the_top\".\n"
15866 /* This help string is used for the break, hbreak, tbreak and thbreak
15867 commands. It is defined as a macro to prevent duplication.
15868 COMMAND should be a string constant containing the name of the
15871 #define BREAK_ARGS_HELP(command) \
15872 command" [PROBE_MODIFIER] [LOCATION] [thread THREADNUM] [if CONDITION]\n\
15873 PROBE_MODIFIER shall be present if the command is to be placed in a\n\
15874 probe point. Accepted values are `-probe' (for a generic, automatically\n\
15875 guessed probe type), `-probe-stap' (for a SystemTap probe) or \n\
15876 `-probe-dtrace' (for a DTrace probe).\n\
15877 LOCATION may be a linespec, address, or explicit location as described\n\
15880 With no LOCATION, uses current execution address of the selected\n\
15881 stack frame. This is useful for breaking on return to a stack frame.\n\
15883 THREADNUM is the number from \"info threads\".\n\
15884 CONDITION is a boolean expression.\n\
15885 \n" LOCATION_HELP_STRING "\n\
15886 Multiple breakpoints at one place are permitted, and useful if their\n\
15887 conditions are different.\n\
15889 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
15891 /* List of subcommands for "catch". */
15892 static struct cmd_list_element
*catch_cmdlist
;
15894 /* List of subcommands for "tcatch". */
15895 static struct cmd_list_element
*tcatch_cmdlist
;
15898 add_catch_command (char *name
, char *docstring
,
15899 cmd_sfunc_ftype
*sfunc
,
15900 completer_ftype
*completer
,
15901 void *user_data_catch
,
15902 void *user_data_tcatch
)
15904 struct cmd_list_element
*command
;
15906 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
15908 set_cmd_sfunc (command
, sfunc
);
15909 set_cmd_context (command
, user_data_catch
);
15910 set_cmd_completer (command
, completer
);
15912 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
15914 set_cmd_sfunc (command
, sfunc
);
15915 set_cmd_context (command
, user_data_tcatch
);
15916 set_cmd_completer (command
, completer
);
15920 save_command (char *arg
, int from_tty
)
15922 printf_unfiltered (_("\"save\" must be followed by "
15923 "the name of a save subcommand.\n"));
15924 help_list (save_cmdlist
, "save ", all_commands
, gdb_stdout
);
15927 struct breakpoint
*
15928 iterate_over_breakpoints (int (*callback
) (struct breakpoint
*, void *),
15931 struct breakpoint
*b
, *b_tmp
;
15933 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
15935 if ((*callback
) (b
, data
))
15942 /* Zero if any of the breakpoint's locations could be a location where
15943 functions have been inlined, nonzero otherwise. */
15946 is_non_inline_function (struct breakpoint
*b
)
15948 /* The shared library event breakpoint is set on the address of a
15949 non-inline function. */
15950 if (b
->type
== bp_shlib_event
)
15956 /* Nonzero if the specified PC cannot be a location where functions
15957 have been inlined. */
15960 pc_at_non_inline_function (struct address_space
*aspace
, CORE_ADDR pc
,
15961 const struct target_waitstatus
*ws
)
15963 struct breakpoint
*b
;
15964 struct bp_location
*bl
;
15966 ALL_BREAKPOINTS (b
)
15968 if (!is_non_inline_function (b
))
15971 for (bl
= b
->loc
; bl
!= NULL
; bl
= bl
->next
)
15973 if (!bl
->shlib_disabled
15974 && bpstat_check_location (bl
, aspace
, pc
, ws
))
15982 /* Remove any references to OBJFILE which is going to be freed. */
15985 breakpoint_free_objfile (struct objfile
*objfile
)
15987 struct bp_location
**locp
, *loc
;
15989 ALL_BP_LOCATIONS (loc
, locp
)
15990 if (loc
->symtab
!= NULL
&& SYMTAB_OBJFILE (loc
->symtab
) == objfile
)
15991 loc
->symtab
= NULL
;
15995 initialize_breakpoint_ops (void)
15997 static int initialized
= 0;
15999 struct breakpoint_ops
*ops
;
16005 /* The breakpoint_ops structure to be inherit by all kinds of
16006 breakpoints (real breakpoints, i.e., user "break" breakpoints,
16007 internal and momentary breakpoints, etc.). */
16008 ops
= &bkpt_base_breakpoint_ops
;
16009 *ops
= base_breakpoint_ops
;
16010 ops
->re_set
= bkpt_re_set
;
16011 ops
->insert_location
= bkpt_insert_location
;
16012 ops
->remove_location
= bkpt_remove_location
;
16013 ops
->breakpoint_hit
= bkpt_breakpoint_hit
;
16014 ops
->create_sals_from_location
= bkpt_create_sals_from_location
;
16015 ops
->create_breakpoints_sal
= bkpt_create_breakpoints_sal
;
16016 ops
->decode_location
= bkpt_decode_location
;
16018 /* The breakpoint_ops structure to be used in regular breakpoints. */
16019 ops
= &bkpt_breakpoint_ops
;
16020 *ops
= bkpt_base_breakpoint_ops
;
16021 ops
->re_set
= bkpt_re_set
;
16022 ops
->resources_needed
= bkpt_resources_needed
;
16023 ops
->print_it
= bkpt_print_it
;
16024 ops
->print_mention
= bkpt_print_mention
;
16025 ops
->print_recreate
= bkpt_print_recreate
;
16027 /* Ranged breakpoints. */
16028 ops
= &ranged_breakpoint_ops
;
16029 *ops
= bkpt_breakpoint_ops
;
16030 ops
->breakpoint_hit
= breakpoint_hit_ranged_breakpoint
;
16031 ops
->resources_needed
= resources_needed_ranged_breakpoint
;
16032 ops
->print_it
= print_it_ranged_breakpoint
;
16033 ops
->print_one
= print_one_ranged_breakpoint
;
16034 ops
->print_one_detail
= print_one_detail_ranged_breakpoint
;
16035 ops
->print_mention
= print_mention_ranged_breakpoint
;
16036 ops
->print_recreate
= print_recreate_ranged_breakpoint
;
16038 /* Internal breakpoints. */
16039 ops
= &internal_breakpoint_ops
;
16040 *ops
= bkpt_base_breakpoint_ops
;
16041 ops
->re_set
= internal_bkpt_re_set
;
16042 ops
->check_status
= internal_bkpt_check_status
;
16043 ops
->print_it
= internal_bkpt_print_it
;
16044 ops
->print_mention
= internal_bkpt_print_mention
;
16046 /* Momentary breakpoints. */
16047 ops
= &momentary_breakpoint_ops
;
16048 *ops
= bkpt_base_breakpoint_ops
;
16049 ops
->re_set
= momentary_bkpt_re_set
;
16050 ops
->check_status
= momentary_bkpt_check_status
;
16051 ops
->print_it
= momentary_bkpt_print_it
;
16052 ops
->print_mention
= momentary_bkpt_print_mention
;
16054 /* Momentary breakpoints for bp_longjmp and bp_exception. */
16055 ops
= &longjmp_breakpoint_ops
;
16056 *ops
= momentary_breakpoint_ops
;
16057 ops
->dtor
= longjmp_bkpt_dtor
;
16059 /* Probe breakpoints. */
16060 ops
= &bkpt_probe_breakpoint_ops
;
16061 *ops
= bkpt_breakpoint_ops
;
16062 ops
->insert_location
= bkpt_probe_insert_location
;
16063 ops
->remove_location
= bkpt_probe_remove_location
;
16064 ops
->create_sals_from_location
= bkpt_probe_create_sals_from_location
;
16065 ops
->decode_location
= bkpt_probe_decode_location
;
16068 ops
= &watchpoint_breakpoint_ops
;
16069 *ops
= base_breakpoint_ops
;
16070 ops
->dtor
= dtor_watchpoint
;
16071 ops
->re_set
= re_set_watchpoint
;
16072 ops
->insert_location
= insert_watchpoint
;
16073 ops
->remove_location
= remove_watchpoint
;
16074 ops
->breakpoint_hit
= breakpoint_hit_watchpoint
;
16075 ops
->check_status
= check_status_watchpoint
;
16076 ops
->resources_needed
= resources_needed_watchpoint
;
16077 ops
->works_in_software_mode
= works_in_software_mode_watchpoint
;
16078 ops
->print_it
= print_it_watchpoint
;
16079 ops
->print_mention
= print_mention_watchpoint
;
16080 ops
->print_recreate
= print_recreate_watchpoint
;
16081 ops
->explains_signal
= explains_signal_watchpoint
;
16083 /* Masked watchpoints. */
16084 ops
= &masked_watchpoint_breakpoint_ops
;
16085 *ops
= watchpoint_breakpoint_ops
;
16086 ops
->insert_location
= insert_masked_watchpoint
;
16087 ops
->remove_location
= remove_masked_watchpoint
;
16088 ops
->resources_needed
= resources_needed_masked_watchpoint
;
16089 ops
->works_in_software_mode
= works_in_software_mode_masked_watchpoint
;
16090 ops
->print_it
= print_it_masked_watchpoint
;
16091 ops
->print_one_detail
= print_one_detail_masked_watchpoint
;
16092 ops
->print_mention
= print_mention_masked_watchpoint
;
16093 ops
->print_recreate
= print_recreate_masked_watchpoint
;
16096 ops
= &tracepoint_breakpoint_ops
;
16097 *ops
= base_breakpoint_ops
;
16098 ops
->re_set
= tracepoint_re_set
;
16099 ops
->breakpoint_hit
= tracepoint_breakpoint_hit
;
16100 ops
->print_one_detail
= tracepoint_print_one_detail
;
16101 ops
->print_mention
= tracepoint_print_mention
;
16102 ops
->print_recreate
= tracepoint_print_recreate
;
16103 ops
->create_sals_from_location
= tracepoint_create_sals_from_location
;
16104 ops
->create_breakpoints_sal
= tracepoint_create_breakpoints_sal
;
16105 ops
->decode_location
= tracepoint_decode_location
;
16107 /* Probe tracepoints. */
16108 ops
= &tracepoint_probe_breakpoint_ops
;
16109 *ops
= tracepoint_breakpoint_ops
;
16110 ops
->create_sals_from_location
= tracepoint_probe_create_sals_from_location
;
16111 ops
->decode_location
= tracepoint_probe_decode_location
;
16113 /* Static tracepoints with marker (`-m'). */
16114 ops
= &strace_marker_breakpoint_ops
;
16115 *ops
= tracepoint_breakpoint_ops
;
16116 ops
->create_sals_from_location
= strace_marker_create_sals_from_location
;
16117 ops
->create_breakpoints_sal
= strace_marker_create_breakpoints_sal
;
16118 ops
->decode_location
= strace_marker_decode_location
;
16120 /* Fork catchpoints. */
16121 ops
= &catch_fork_breakpoint_ops
;
16122 *ops
= base_breakpoint_ops
;
16123 ops
->insert_location
= insert_catch_fork
;
16124 ops
->remove_location
= remove_catch_fork
;
16125 ops
->breakpoint_hit
= breakpoint_hit_catch_fork
;
16126 ops
->print_it
= print_it_catch_fork
;
16127 ops
->print_one
= print_one_catch_fork
;
16128 ops
->print_mention
= print_mention_catch_fork
;
16129 ops
->print_recreate
= print_recreate_catch_fork
;
16131 /* Vfork catchpoints. */
16132 ops
= &catch_vfork_breakpoint_ops
;
16133 *ops
= base_breakpoint_ops
;
16134 ops
->insert_location
= insert_catch_vfork
;
16135 ops
->remove_location
= remove_catch_vfork
;
16136 ops
->breakpoint_hit
= breakpoint_hit_catch_vfork
;
16137 ops
->print_it
= print_it_catch_vfork
;
16138 ops
->print_one
= print_one_catch_vfork
;
16139 ops
->print_mention
= print_mention_catch_vfork
;
16140 ops
->print_recreate
= print_recreate_catch_vfork
;
16142 /* Exec catchpoints. */
16143 ops
= &catch_exec_breakpoint_ops
;
16144 *ops
= base_breakpoint_ops
;
16145 ops
->dtor
= dtor_catch_exec
;
16146 ops
->insert_location
= insert_catch_exec
;
16147 ops
->remove_location
= remove_catch_exec
;
16148 ops
->breakpoint_hit
= breakpoint_hit_catch_exec
;
16149 ops
->print_it
= print_it_catch_exec
;
16150 ops
->print_one
= print_one_catch_exec
;
16151 ops
->print_mention
= print_mention_catch_exec
;
16152 ops
->print_recreate
= print_recreate_catch_exec
;
16154 /* Solib-related catchpoints. */
16155 ops
= &catch_solib_breakpoint_ops
;
16156 *ops
= base_breakpoint_ops
;
16157 ops
->dtor
= dtor_catch_solib
;
16158 ops
->insert_location
= insert_catch_solib
;
16159 ops
->remove_location
= remove_catch_solib
;
16160 ops
->breakpoint_hit
= breakpoint_hit_catch_solib
;
16161 ops
->check_status
= check_status_catch_solib
;
16162 ops
->print_it
= print_it_catch_solib
;
16163 ops
->print_one
= print_one_catch_solib
;
16164 ops
->print_mention
= print_mention_catch_solib
;
16165 ops
->print_recreate
= print_recreate_catch_solib
;
16167 ops
= &dprintf_breakpoint_ops
;
16168 *ops
= bkpt_base_breakpoint_ops
;
16169 ops
->re_set
= dprintf_re_set
;
16170 ops
->resources_needed
= bkpt_resources_needed
;
16171 ops
->print_it
= bkpt_print_it
;
16172 ops
->print_mention
= bkpt_print_mention
;
16173 ops
->print_recreate
= dprintf_print_recreate
;
16174 ops
->after_condition_true
= dprintf_after_condition_true
;
16175 ops
->breakpoint_hit
= dprintf_breakpoint_hit
;
16178 /* Chain containing all defined "enable breakpoint" subcommands. */
16180 static struct cmd_list_element
*enablebreaklist
= NULL
;
16183 _initialize_breakpoint (void)
16185 struct cmd_list_element
*c
;
16187 initialize_breakpoint_ops ();
16189 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
16190 observer_attach_free_objfile (disable_breakpoints_in_freed_objfile
);
16191 observer_attach_memory_changed (invalidate_bp_value_on_memory_change
);
16193 breakpoint_objfile_key
16194 = register_objfile_data_with_cleanup (NULL
, free_breakpoint_probes
);
16196 breakpoint_chain
= 0;
16197 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
16198 before a breakpoint is set. */
16199 breakpoint_count
= 0;
16201 tracepoint_count
= 0;
16203 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
16204 Set ignore-count of breakpoint number N to COUNT.\n\
16205 Usage is `ignore N COUNT'."));
16207 add_com ("commands", class_breakpoint
, commands_command
, _("\
16208 Set commands to be executed when a breakpoint is hit.\n\
16209 Give breakpoint number as argument after \"commands\".\n\
16210 With no argument, the targeted breakpoint is the last one set.\n\
16211 The commands themselves follow starting on the next line.\n\
16212 Type a line containing \"end\" to indicate the end of them.\n\
16213 Give \"silent\" as the first line to make the breakpoint silent;\n\
16214 then no output is printed when it is hit, except what the commands print."));
16216 c
= add_com ("condition", class_breakpoint
, condition_command
, _("\
16217 Specify breakpoint number N to break only if COND is true.\n\
16218 Usage is `condition N COND', where N is an integer and COND is an\n\
16219 expression to be evaluated whenever breakpoint N is reached."));
16220 set_cmd_completer (c
, condition_completer
);
16222 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
16223 Set a temporary breakpoint.\n\
16224 Like \"break\" except the breakpoint is only temporary,\n\
16225 so it will be deleted when hit. Equivalent to \"break\" followed\n\
16226 by using \"enable delete\" on the breakpoint number.\n\
16228 BREAK_ARGS_HELP ("tbreak")));
16229 set_cmd_completer (c
, location_completer
);
16231 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
16232 Set a hardware assisted breakpoint.\n\
16233 Like \"break\" except the breakpoint requires hardware support,\n\
16234 some target hardware may not have this support.\n\
16236 BREAK_ARGS_HELP ("hbreak")));
16237 set_cmd_completer (c
, location_completer
);
16239 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
16240 Set a temporary hardware assisted breakpoint.\n\
16241 Like \"hbreak\" except the breakpoint is only temporary,\n\
16242 so it will be deleted when hit.\n\
16244 BREAK_ARGS_HELP ("thbreak")));
16245 set_cmd_completer (c
, location_completer
);
16247 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
16248 Enable some breakpoints.\n\
16249 Give breakpoint numbers (separated by spaces) as arguments.\n\
16250 With no subcommand, breakpoints are enabled until you command otherwise.\n\
16251 This is used to cancel the effect of the \"disable\" command.\n\
16252 With a subcommand you can enable temporarily."),
16253 &enablelist
, "enable ", 1, &cmdlist
);
16255 add_com_alias ("en", "enable", class_breakpoint
, 1);
16257 add_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
16258 Enable some breakpoints.\n\
16259 Give breakpoint numbers (separated by spaces) as arguments.\n\
16260 This is used to cancel the effect of the \"disable\" command.\n\
16261 May be abbreviated to simply \"enable\".\n"),
16262 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
16264 add_cmd ("once", no_class
, enable_once_command
, _("\
16265 Enable breakpoints for one hit. Give breakpoint numbers.\n\
16266 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
16269 add_cmd ("delete", no_class
, enable_delete_command
, _("\
16270 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
16271 If a breakpoint is hit while enabled in this fashion, it is deleted."),
16274 add_cmd ("count", no_class
, enable_count_command
, _("\
16275 Enable breakpoints for COUNT hits. Give count and then breakpoint numbers.\n\
16276 If a breakpoint is hit while enabled in this fashion,\n\
16277 the count is decremented; when it reaches zero, the breakpoint is disabled."),
16280 add_cmd ("delete", no_class
, enable_delete_command
, _("\
16281 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
16282 If a breakpoint is hit while enabled in this fashion, it is deleted."),
16285 add_cmd ("once", no_class
, enable_once_command
, _("\
16286 Enable breakpoints for one hit. Give breakpoint numbers.\n\
16287 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
16290 add_cmd ("count", no_class
, enable_count_command
, _("\
16291 Enable breakpoints for COUNT hits. Give count and then breakpoint numbers.\n\
16292 If a breakpoint is hit while enabled in this fashion,\n\
16293 the count is decremented; when it reaches zero, the breakpoint is disabled."),
16296 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
16297 Disable some breakpoints.\n\
16298 Arguments are breakpoint numbers with spaces in between.\n\
16299 To disable all breakpoints, give no argument.\n\
16300 A disabled breakpoint is not forgotten, but has no effect until re-enabled."),
16301 &disablelist
, "disable ", 1, &cmdlist
);
16302 add_com_alias ("dis", "disable", class_breakpoint
, 1);
16303 add_com_alias ("disa", "disable", class_breakpoint
, 1);
16305 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
16306 Disable some breakpoints.\n\
16307 Arguments are breakpoint numbers with spaces in between.\n\
16308 To disable all breakpoints, give no argument.\n\
16309 A disabled breakpoint is not forgotten, but has no effect until re-enabled.\n\
16310 This command may be abbreviated \"disable\"."),
16313 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
16314 Delete some breakpoints or auto-display expressions.\n\
16315 Arguments are breakpoint numbers with spaces in between.\n\
16316 To delete all breakpoints, give no argument.\n\
16318 Also a prefix command for deletion of other GDB objects.\n\
16319 The \"unset\" command is also an alias for \"delete\"."),
16320 &deletelist
, "delete ", 1, &cmdlist
);
16321 add_com_alias ("d", "delete", class_breakpoint
, 1);
16322 add_com_alias ("del", "delete", class_breakpoint
, 1);
16324 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
16325 Delete some breakpoints or auto-display expressions.\n\
16326 Arguments are breakpoint numbers with spaces in between.\n\
16327 To delete all breakpoints, give no argument.\n\
16328 This command may be abbreviated \"delete\"."),
16331 add_com ("clear", class_breakpoint
, clear_command
, _("\
16332 Clear breakpoint at specified location.\n\
16333 Argument may be a linespec, explicit, or address location as described below.\n\
16335 With no argument, clears all breakpoints in the line that the selected frame\n\
16336 is executing in.\n"
16337 "\n" LOCATION_HELP_STRING
"\n\
16338 See also the \"delete\" command which clears breakpoints by number."));
16339 add_com_alias ("cl", "clear", class_breakpoint
, 1);
16341 c
= add_com ("break", class_breakpoint
, break_command
, _("\
16342 Set breakpoint at specified location.\n"
16343 BREAK_ARGS_HELP ("break")));
16344 set_cmd_completer (c
, location_completer
);
16346 add_com_alias ("b", "break", class_run
, 1);
16347 add_com_alias ("br", "break", class_run
, 1);
16348 add_com_alias ("bre", "break", class_run
, 1);
16349 add_com_alias ("brea", "break", class_run
, 1);
16353 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
16354 Break in function/address or break at a line in the current file."),
16355 &stoplist
, "stop ", 1, &cmdlist
);
16356 add_cmd ("in", class_breakpoint
, stopin_command
,
16357 _("Break in function or address."), &stoplist
);
16358 add_cmd ("at", class_breakpoint
, stopat_command
,
16359 _("Break at a line in the current file."), &stoplist
);
16360 add_com ("status", class_info
, breakpoints_info
, _("\
16361 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
16362 The \"Type\" column indicates one of:\n\
16363 \tbreakpoint - normal breakpoint\n\
16364 \twatchpoint - watchpoint\n\
16365 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
16366 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
16367 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
16368 address and file/line number respectively.\n\
16370 Convenience variable \"$_\" and default examine address for \"x\"\n\
16371 are set to the address of the last breakpoint listed unless the command\n\
16372 is prefixed with \"server \".\n\n\
16373 Convenience variable \"$bpnum\" contains the number of the last\n\
16374 breakpoint set."));
16377 add_info ("breakpoints", breakpoints_info
, _("\
16378 Status of specified breakpoints (all user-settable breakpoints if no argument).\n\
16379 The \"Type\" column indicates one of:\n\
16380 \tbreakpoint - normal breakpoint\n\
16381 \twatchpoint - watchpoint\n\
16382 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
16383 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
16384 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
16385 address and file/line number respectively.\n\
16387 Convenience variable \"$_\" and default examine address for \"x\"\n\
16388 are set to the address of the last breakpoint listed unless the command\n\
16389 is prefixed with \"server \".\n\n\
16390 Convenience variable \"$bpnum\" contains the number of the last\n\
16391 breakpoint set."));
16393 add_info_alias ("b", "breakpoints", 1);
16395 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
16396 Status of all breakpoints, or breakpoint number NUMBER.\n\
16397 The \"Type\" column indicates one of:\n\
16398 \tbreakpoint - normal breakpoint\n\
16399 \twatchpoint - watchpoint\n\
16400 \tlongjmp - internal breakpoint used to step through longjmp()\n\
16401 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
16402 \tuntil - internal breakpoint used by the \"until\" command\n\
16403 \tfinish - internal breakpoint used by the \"finish\" command\n\
16404 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
16405 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
16406 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
16407 address and file/line number respectively.\n\
16409 Convenience variable \"$_\" and default examine address for \"x\"\n\
16410 are set to the address of the last breakpoint listed unless the command\n\
16411 is prefixed with \"server \".\n\n\
16412 Convenience variable \"$bpnum\" contains the number of the last\n\
16414 &maintenanceinfolist
);
16416 add_prefix_cmd ("catch", class_breakpoint
, catch_command
, _("\
16417 Set catchpoints to catch events."),
16418 &catch_cmdlist
, "catch ",
16419 0/*allow-unknown*/, &cmdlist
);
16421 add_prefix_cmd ("tcatch", class_breakpoint
, tcatch_command
, _("\
16422 Set temporary catchpoints to catch events."),
16423 &tcatch_cmdlist
, "tcatch ",
16424 0/*allow-unknown*/, &cmdlist
);
16426 add_catch_command ("fork", _("Catch calls to fork."),
16427 catch_fork_command_1
,
16429 (void *) (uintptr_t) catch_fork_permanent
,
16430 (void *) (uintptr_t) catch_fork_temporary
);
16431 add_catch_command ("vfork", _("Catch calls to vfork."),
16432 catch_fork_command_1
,
16434 (void *) (uintptr_t) catch_vfork_permanent
,
16435 (void *) (uintptr_t) catch_vfork_temporary
);
16436 add_catch_command ("exec", _("Catch calls to exec."),
16437 catch_exec_command_1
,
16441 add_catch_command ("load", _("Catch loads of shared libraries.\n\
16442 Usage: catch load [REGEX]\n\
16443 If REGEX is given, only stop for libraries matching the regular expression."),
16444 catch_load_command_1
,
16448 add_catch_command ("unload", _("Catch unloads of shared libraries.\n\
16449 Usage: catch unload [REGEX]\n\
16450 If REGEX is given, only stop for libraries matching the regular expression."),
16451 catch_unload_command_1
,
16456 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
16457 Set a watchpoint for an expression.\n\
16458 Usage: watch [-l|-location] EXPRESSION\n\
16459 A watchpoint stops execution of your program whenever the value of\n\
16460 an expression changes.\n\
16461 If -l or -location is given, this evaluates EXPRESSION and watches\n\
16462 the memory to which it refers."));
16463 set_cmd_completer (c
, expression_completer
);
16465 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
16466 Set a read watchpoint for an expression.\n\
16467 Usage: rwatch [-l|-location] EXPRESSION\n\
16468 A watchpoint stops execution of your program whenever the value of\n\
16469 an expression is read.\n\
16470 If -l or -location is given, this evaluates EXPRESSION and watches\n\
16471 the memory to which it refers."));
16472 set_cmd_completer (c
, expression_completer
);
16474 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
16475 Set a watchpoint for an expression.\n\
16476 Usage: awatch [-l|-location] EXPRESSION\n\
16477 A watchpoint stops execution of your program whenever the value of\n\
16478 an expression is either read or written.\n\
16479 If -l or -location is given, this evaluates EXPRESSION and watches\n\
16480 the memory to which it refers."));
16481 set_cmd_completer (c
, expression_completer
);
16483 add_info ("watchpoints", watchpoints_info
, _("\
16484 Status of specified watchpoints (all watchpoints if no argument)."));
16486 /* XXX: cagney/2005-02-23: This should be a boolean, and should
16487 respond to changes - contrary to the description. */
16488 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
16489 &can_use_hw_watchpoints
, _("\
16490 Set debugger's willingness to use watchpoint hardware."), _("\
16491 Show debugger's willingness to use watchpoint hardware."), _("\
16492 If zero, gdb will not use hardware for new watchpoints, even if\n\
16493 such is available. (However, any hardware watchpoints that were\n\
16494 created before setting this to nonzero, will continue to use watchpoint\n\
16497 show_can_use_hw_watchpoints
,
16498 &setlist
, &showlist
);
16500 can_use_hw_watchpoints
= 1;
16502 /* Tracepoint manipulation commands. */
16504 c
= add_com ("trace", class_breakpoint
, trace_command
, _("\
16505 Set a tracepoint at specified location.\n\
16507 BREAK_ARGS_HELP ("trace") "\n\
16508 Do \"help tracepoints\" for info on other tracepoint commands."));
16509 set_cmd_completer (c
, location_completer
);
16511 add_com_alias ("tp", "trace", class_alias
, 0);
16512 add_com_alias ("tr", "trace", class_alias
, 1);
16513 add_com_alias ("tra", "trace", class_alias
, 1);
16514 add_com_alias ("trac", "trace", class_alias
, 1);
16516 c
= add_com ("ftrace", class_breakpoint
, ftrace_command
, _("\
16517 Set a fast tracepoint at specified location.\n\
16519 BREAK_ARGS_HELP ("ftrace") "\n\
16520 Do \"help tracepoints\" for info on other tracepoint commands."));
16521 set_cmd_completer (c
, location_completer
);
16523 c
= add_com ("strace", class_breakpoint
, strace_command
, _("\
16524 Set a static tracepoint at location or marker.\n\
16526 strace [LOCATION] [if CONDITION]\n\
16527 LOCATION may be a linespec, explicit, or address location (described below) \n\
16528 or -m MARKER_ID.\n\n\
16529 If a marker id is specified, probe the marker with that name. With\n\
16530 no LOCATION, uses current execution address of the selected stack frame.\n\
16531 Static tracepoints accept an extra collect action -- ``collect $_sdata''.\n\
16532 This collects arbitrary user data passed in the probe point call to the\n\
16533 tracing library. You can inspect it when analyzing the trace buffer,\n\
16534 by printing the $_sdata variable like any other convenience variable.\n\
16536 CONDITION is a boolean expression.\n\
16537 \n" LOCATION_HELP_STRING
"\n\
16538 Multiple tracepoints at one place are permitted, and useful if their\n\
16539 conditions are different.\n\
16541 Do \"help breakpoints\" for info on other commands dealing with breakpoints.\n\
16542 Do \"help tracepoints\" for info on other tracepoint commands."));
16543 set_cmd_completer (c
, location_completer
);
16545 add_info ("tracepoints", tracepoints_info
, _("\
16546 Status of specified tracepoints (all tracepoints if no argument).\n\
16547 Convenience variable \"$tpnum\" contains the number of the\n\
16548 last tracepoint set."));
16550 add_info_alias ("tp", "tracepoints", 1);
16552 add_cmd ("tracepoints", class_trace
, delete_trace_command
, _("\
16553 Delete specified tracepoints.\n\
16554 Arguments are tracepoint numbers, separated by spaces.\n\
16555 No argument means delete all tracepoints."),
16557 add_alias_cmd ("tr", "tracepoints", class_trace
, 1, &deletelist
);
16559 c
= add_cmd ("tracepoints", class_trace
, disable_trace_command
, _("\
16560 Disable specified tracepoints.\n\
16561 Arguments are tracepoint numbers, separated by spaces.\n\
16562 No argument means disable all tracepoints."),
16564 deprecate_cmd (c
, "disable");
16566 c
= add_cmd ("tracepoints", class_trace
, enable_trace_command
, _("\
16567 Enable specified tracepoints.\n\
16568 Arguments are tracepoint numbers, separated by spaces.\n\
16569 No argument means enable all tracepoints."),
16571 deprecate_cmd (c
, "enable");
16573 add_com ("passcount", class_trace
, trace_pass_command
, _("\
16574 Set the passcount for a tracepoint.\n\
16575 The trace will end when the tracepoint has been passed 'count' times.\n\
16576 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
16577 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
16579 add_prefix_cmd ("save", class_breakpoint
, save_command
,
16580 _("Save breakpoint definitions as a script."),
16581 &save_cmdlist
, "save ",
16582 0/*allow-unknown*/, &cmdlist
);
16584 c
= add_cmd ("breakpoints", class_breakpoint
, save_breakpoints_command
, _("\
16585 Save current breakpoint definitions as a script.\n\
16586 This includes all types of breakpoints (breakpoints, watchpoints,\n\
16587 catchpoints, tracepoints). Use the 'source' command in another debug\n\
16588 session to restore them."),
16590 set_cmd_completer (c
, filename_completer
);
16592 c
= add_cmd ("tracepoints", class_trace
, save_tracepoints_command
, _("\
16593 Save current tracepoint definitions as a script.\n\
16594 Use the 'source' command in another debug session to restore them."),
16596 set_cmd_completer (c
, filename_completer
);
16598 c
= add_com_alias ("save-tracepoints", "save tracepoints", class_trace
, 0);
16599 deprecate_cmd (c
, "save tracepoints");
16601 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
16602 Breakpoint specific settings\n\
16603 Configure various breakpoint-specific variables such as\n\
16604 pending breakpoint behavior"),
16605 &breakpoint_set_cmdlist
, "set breakpoint ",
16606 0/*allow-unknown*/, &setlist
);
16607 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
16608 Breakpoint specific settings\n\
16609 Configure various breakpoint-specific variables such as\n\
16610 pending breakpoint behavior"),
16611 &breakpoint_show_cmdlist
, "show breakpoint ",
16612 0/*allow-unknown*/, &showlist
);
16614 add_setshow_auto_boolean_cmd ("pending", no_class
,
16615 &pending_break_support
, _("\
16616 Set debugger's behavior regarding pending breakpoints."), _("\
16617 Show debugger's behavior regarding pending breakpoints."), _("\
16618 If on, an unrecognized breakpoint location will cause gdb to create a\n\
16619 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
16620 an error. If auto, an unrecognized breakpoint location results in a\n\
16621 user-query to see if a pending breakpoint should be created."),
16623 show_pending_break_support
,
16624 &breakpoint_set_cmdlist
,
16625 &breakpoint_show_cmdlist
);
16627 pending_break_support
= AUTO_BOOLEAN_AUTO
;
16629 add_setshow_boolean_cmd ("auto-hw", no_class
,
16630 &automatic_hardware_breakpoints
, _("\
16631 Set automatic usage of hardware breakpoints."), _("\
16632 Show automatic usage of hardware breakpoints."), _("\
16633 If set, the debugger will automatically use hardware breakpoints for\n\
16634 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
16635 a warning will be emitted for such breakpoints."),
16637 show_automatic_hardware_breakpoints
,
16638 &breakpoint_set_cmdlist
,
16639 &breakpoint_show_cmdlist
);
16641 add_setshow_boolean_cmd ("always-inserted", class_support
,
16642 &always_inserted_mode
, _("\
16643 Set mode for inserting breakpoints."), _("\
16644 Show mode for inserting breakpoints."), _("\
16645 When this mode is on, breakpoints are inserted immediately as soon as\n\
16646 they're created, kept inserted even when execution stops, and removed\n\
16647 only when the user deletes them. When this mode is off (the default),\n\
16648 breakpoints are inserted only when execution continues, and removed\n\
16649 when execution stops."),
16651 &show_always_inserted_mode
,
16652 &breakpoint_set_cmdlist
,
16653 &breakpoint_show_cmdlist
);
16655 add_setshow_enum_cmd ("condition-evaluation", class_breakpoint
,
16656 condition_evaluation_enums
,
16657 &condition_evaluation_mode_1
, _("\
16658 Set mode of breakpoint condition evaluation."), _("\
16659 Show mode of breakpoint condition evaluation."), _("\
16660 When this is set to \"host\", breakpoint conditions will be\n\
16661 evaluated on the host's side by GDB. When it is set to \"target\",\n\
16662 breakpoint conditions will be downloaded to the target (if the target\n\
16663 supports such feature) and conditions will be evaluated on the target's side.\n\
16664 If this is set to \"auto\" (default), this will be automatically set to\n\
16665 \"target\" if it supports condition evaluation, otherwise it will\n\
16666 be set to \"gdb\""),
16667 &set_condition_evaluation_mode
,
16668 &show_condition_evaluation_mode
,
16669 &breakpoint_set_cmdlist
,
16670 &breakpoint_show_cmdlist
);
16672 add_com ("break-range", class_breakpoint
, break_range_command
, _("\
16673 Set a breakpoint for an address range.\n\
16674 break-range START-LOCATION, END-LOCATION\n\
16675 where START-LOCATION and END-LOCATION can be one of the following:\n\
16676 LINENUM, for that line in the current file,\n\
16677 FILE:LINENUM, for that line in that file,\n\
16678 +OFFSET, for that number of lines after the current line\n\
16679 or the start of the range\n\
16680 FUNCTION, for the first line in that function,\n\
16681 FILE:FUNCTION, to distinguish among like-named static functions.\n\
16682 *ADDRESS, for the instruction at that address.\n\
16684 The breakpoint will stop execution of the inferior whenever it executes\n\
16685 an instruction at any address within the [START-LOCATION, END-LOCATION]\n\
16686 range (including START-LOCATION and END-LOCATION)."));
16688 c
= add_com ("dprintf", class_breakpoint
, dprintf_command
, _("\
16689 Set a dynamic printf at specified location.\n\
16690 dprintf location,format string,arg1,arg2,...\n\
16691 location may be a linespec, explicit, or address location.\n"
16692 "\n" LOCATION_HELP_STRING
));
16693 set_cmd_completer (c
, location_completer
);
16695 add_setshow_enum_cmd ("dprintf-style", class_support
,
16696 dprintf_style_enums
, &dprintf_style
, _("\
16697 Set the style of usage for dynamic printf."), _("\
16698 Show the style of usage for dynamic printf."), _("\
16699 This setting chooses how GDB will do a dynamic printf.\n\
16700 If the value is \"gdb\", then the printing is done by GDB to its own\n\
16701 console, as with the \"printf\" command.\n\
16702 If the value is \"call\", the print is done by calling a function in your\n\
16703 program; by default printf(), but you can choose a different function or\n\
16704 output stream by setting dprintf-function and dprintf-channel."),
16705 update_dprintf_commands
, NULL
,
16706 &setlist
, &showlist
);
16708 dprintf_function
= xstrdup ("printf");
16709 add_setshow_string_cmd ("dprintf-function", class_support
,
16710 &dprintf_function
, _("\
16711 Set the function to use for dynamic printf"), _("\
16712 Show the function to use for dynamic printf"), NULL
,
16713 update_dprintf_commands
, NULL
,
16714 &setlist
, &showlist
);
16716 dprintf_channel
= xstrdup ("");
16717 add_setshow_string_cmd ("dprintf-channel", class_support
,
16718 &dprintf_channel
, _("\
16719 Set the channel to use for dynamic printf"), _("\
16720 Show the channel to use for dynamic printf"), NULL
,
16721 update_dprintf_commands
, NULL
,
16722 &setlist
, &showlist
);
16724 add_setshow_boolean_cmd ("disconnected-dprintf", no_class
,
16725 &disconnected_dprintf
, _("\
16726 Set whether dprintf continues after GDB disconnects."), _("\
16727 Show whether dprintf continues after GDB disconnects."), _("\
16728 Use this to let dprintf commands continue to hit and produce output\n\
16729 even if GDB disconnects or detaches from the target."),
16732 &setlist
, &showlist
);
16734 add_com ("agent-printf", class_vars
, agent_printf_command
, _("\
16735 agent-printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
16736 (target agent only) This is useful for formatted output in user-defined commands."));
16738 automatic_hardware_breakpoints
= 1;
16740 observer_attach_about_to_proceed (breakpoint_about_to_proceed
);
16741 observer_attach_thread_exit (remove_threaded_breakpoints
);