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 /* Print information on user settable breakpoint (watchpoint, etc)
6819 number BNUM. If BNUM is -1 print all user-settable breakpoints.
6820 If ALLFLAG is non-zero, include non-user-settable breakpoints. If
6821 FILTER is non-NULL, call it on each breakpoint and only include the
6822 ones for which it returns non-zero. Return the total number of
6823 breakpoints listed. */
6826 breakpoint_1 (char *args
, int allflag
,
6827 int (*filter
) (const struct breakpoint
*))
6829 struct breakpoint
*b
;
6830 struct bp_location
*last_loc
= NULL
;
6831 int nr_printable_breakpoints
;
6832 struct cleanup
*bkpttbl_chain
;
6833 struct value_print_options opts
;
6834 int print_address_bits
= 0;
6835 int print_type_col_width
= 14;
6836 struct ui_out
*uiout
= current_uiout
;
6838 get_user_print_options (&opts
);
6840 /* Compute the number of rows in the table, as well as the size
6841 required for address fields. */
6842 nr_printable_breakpoints
= 0;
6845 /* If we have a filter, only list the breakpoints it accepts. */
6846 if (filter
&& !filter (b
))
6849 /* If we have an "args" string, it is a list of breakpoints to
6850 accept. Skip the others. */
6851 if (args
!= NULL
&& *args
!= '\0')
6853 if (allflag
&& parse_and_eval_long (args
) != b
->number
)
6855 if (!allflag
&& !number_is_in_list (args
, b
->number
))
6859 if (allflag
|| user_breakpoint_p (b
))
6861 int addr_bit
, type_len
;
6863 addr_bit
= breakpoint_address_bits (b
);
6864 if (addr_bit
> print_address_bits
)
6865 print_address_bits
= addr_bit
;
6867 type_len
= strlen (bptype_string (b
->type
));
6868 if (type_len
> print_type_col_width
)
6869 print_type_col_width
= type_len
;
6871 nr_printable_breakpoints
++;
6875 if (opts
.addressprint
)
6877 = make_cleanup_ui_out_table_begin_end (uiout
, 6,
6878 nr_printable_breakpoints
,
6882 = make_cleanup_ui_out_table_begin_end (uiout
, 5,
6883 nr_printable_breakpoints
,
6886 if (nr_printable_breakpoints
> 0)
6887 annotate_breakpoints_headers ();
6888 if (nr_printable_breakpoints
> 0)
6890 ui_out_table_header (uiout
, 7, ui_left
, "number", "Num"); /* 1 */
6891 if (nr_printable_breakpoints
> 0)
6893 ui_out_table_header (uiout
, print_type_col_width
, ui_left
,
6894 "type", "Type"); /* 2 */
6895 if (nr_printable_breakpoints
> 0)
6897 ui_out_table_header (uiout
, 4, ui_left
, "disp", "Disp"); /* 3 */
6898 if (nr_printable_breakpoints
> 0)
6900 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb"); /* 4 */
6901 if (opts
.addressprint
)
6903 if (nr_printable_breakpoints
> 0)
6905 if (print_address_bits
<= 32)
6906 ui_out_table_header (uiout
, 10, ui_left
,
6907 "addr", "Address"); /* 5 */
6909 ui_out_table_header (uiout
, 18, ui_left
,
6910 "addr", "Address"); /* 5 */
6912 if (nr_printable_breakpoints
> 0)
6914 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What"); /* 6 */
6915 ui_out_table_body (uiout
);
6916 if (nr_printable_breakpoints
> 0)
6917 annotate_breakpoints_table ();
6922 /* If we have a filter, only list the breakpoints it accepts. */
6923 if (filter
&& !filter (b
))
6926 /* If we have an "args" string, it is a list of breakpoints to
6927 accept. Skip the others. */
6929 if (args
!= NULL
&& *args
!= '\0')
6931 if (allflag
) /* maintenance info breakpoint */
6933 if (parse_and_eval_long (args
) != b
->number
)
6936 else /* all others */
6938 if (!number_is_in_list (args
, b
->number
))
6942 /* We only print out user settable breakpoints unless the
6944 if (allflag
|| user_breakpoint_p (b
))
6945 print_one_breakpoint (b
, &last_loc
, allflag
);
6948 do_cleanups (bkpttbl_chain
);
6950 if (nr_printable_breakpoints
== 0)
6952 /* If there's a filter, let the caller decide how to report
6956 if (args
== NULL
|| *args
== '\0')
6957 ui_out_message (uiout
, 0, "No breakpoints or watchpoints.\n");
6959 ui_out_message (uiout
, 0,
6960 "No breakpoint or watchpoint matching '%s'.\n",
6966 if (last_loc
&& !server_command
)
6967 set_next_address (last_loc
->gdbarch
, last_loc
->address
);
6970 /* FIXME? Should this be moved up so that it is only called when
6971 there have been breakpoints? */
6972 annotate_breakpoints_table_end ();
6974 return nr_printable_breakpoints
;
6977 /* Display the value of default-collect in a way that is generally
6978 compatible with the breakpoint list. */
6981 default_collect_info (void)
6983 struct ui_out
*uiout
= current_uiout
;
6985 /* If it has no value (which is frequently the case), say nothing; a
6986 message like "No default-collect." gets in user's face when it's
6988 if (!*default_collect
)
6991 /* The following phrase lines up nicely with per-tracepoint collect
6993 ui_out_text (uiout
, "default collect ");
6994 ui_out_field_string (uiout
, "default-collect", default_collect
);
6995 ui_out_text (uiout
, " \n");
6999 breakpoints_info (char *args
, int from_tty
)
7001 breakpoint_1 (args
, 0, NULL
);
7003 default_collect_info ();
7007 watchpoints_info (char *args
, int from_tty
)
7009 int num_printed
= breakpoint_1 (args
, 0, is_watchpoint
);
7010 struct ui_out
*uiout
= current_uiout
;
7012 if (num_printed
== 0)
7014 if (args
== NULL
|| *args
== '\0')
7015 ui_out_message (uiout
, 0, "No watchpoints.\n");
7017 ui_out_message (uiout
, 0, "No watchpoint matching '%s'.\n", args
);
7022 maintenance_info_breakpoints (char *args
, int from_tty
)
7024 breakpoint_1 (args
, 1, NULL
);
7026 default_collect_info ();
7030 breakpoint_has_pc (struct breakpoint
*b
,
7031 struct program_space
*pspace
,
7032 CORE_ADDR pc
, struct obj_section
*section
)
7034 struct bp_location
*bl
= b
->loc
;
7036 for (; bl
; bl
= bl
->next
)
7038 if (bl
->pspace
== pspace
7039 && bl
->address
== pc
7040 && (!overlay_debugging
|| bl
->section
== section
))
7046 /* Print a message describing any user-breakpoints set at PC. This
7047 concerns with logical breakpoints, so we match program spaces, not
7051 describe_other_breakpoints (struct gdbarch
*gdbarch
,
7052 struct program_space
*pspace
, CORE_ADDR pc
,
7053 struct obj_section
*section
, int thread
)
7056 struct breakpoint
*b
;
7059 others
+= (user_breakpoint_p (b
)
7060 && breakpoint_has_pc (b
, pspace
, pc
, section
));
7064 printf_filtered (_("Note: breakpoint "));
7065 else /* if (others == ???) */
7066 printf_filtered (_("Note: breakpoints "));
7068 if (user_breakpoint_p (b
) && breakpoint_has_pc (b
, pspace
, pc
, section
))
7071 printf_filtered ("%d", b
->number
);
7072 if (b
->thread
== -1 && thread
!= -1)
7073 printf_filtered (" (all threads)");
7074 else if (b
->thread
!= -1)
7075 printf_filtered (" (thread %d)", b
->thread
);
7076 printf_filtered ("%s%s ",
7077 ((b
->enable_state
== bp_disabled
7078 || b
->enable_state
== bp_call_disabled
)
7082 : ((others
== 1) ? " and" : ""));
7084 printf_filtered (_("also set at pc "));
7085 fputs_filtered (paddress (gdbarch
, pc
), gdb_stdout
);
7086 printf_filtered (".\n");
7091 /* Return true iff it is meaningful to use the address member of
7092 BPT locations. For some breakpoint types, the locations' address members
7093 are irrelevant and it makes no sense to attempt to compare them to other
7094 addresses (or use them for any other purpose either).
7096 More specifically, each of the following breakpoint types will
7097 always have a zero valued location address and we don't want to mark
7098 breakpoints of any of these types to be a duplicate of an actual
7099 breakpoint location at address zero:
7107 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
7109 enum bptype type
= bpt
->type
;
7111 return (type
!= bp_watchpoint
&& type
!= bp_catchpoint
);
7114 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
7115 true if LOC1 and LOC2 represent the same watchpoint location. */
7118 watchpoint_locations_match (struct bp_location
*loc1
,
7119 struct bp_location
*loc2
)
7121 struct watchpoint
*w1
= (struct watchpoint
*) loc1
->owner
;
7122 struct watchpoint
*w2
= (struct watchpoint
*) loc2
->owner
;
7124 /* Both of them must exist. */
7125 gdb_assert (w1
!= NULL
);
7126 gdb_assert (w2
!= NULL
);
7128 /* If the target can evaluate the condition expression in hardware,
7129 then we we need to insert both watchpoints even if they are at
7130 the same place. Otherwise the watchpoint will only trigger when
7131 the condition of whichever watchpoint was inserted evaluates to
7132 true, not giving a chance for GDB to check the condition of the
7133 other watchpoint. */
7135 && target_can_accel_watchpoint_condition (loc1
->address
,
7137 loc1
->watchpoint_type
,
7140 && target_can_accel_watchpoint_condition (loc2
->address
,
7142 loc2
->watchpoint_type
,
7146 /* Note that this checks the owner's type, not the location's. In
7147 case the target does not support read watchpoints, but does
7148 support access watchpoints, we'll have bp_read_watchpoint
7149 watchpoints with hw_access locations. Those should be considered
7150 duplicates of hw_read locations. The hw_read locations will
7151 become hw_access locations later. */
7152 return (loc1
->owner
->type
== loc2
->owner
->type
7153 && loc1
->pspace
->aspace
== loc2
->pspace
->aspace
7154 && loc1
->address
== loc2
->address
7155 && loc1
->length
== loc2
->length
);
7158 /* See breakpoint.h. */
7161 breakpoint_address_match (struct address_space
*aspace1
, CORE_ADDR addr1
,
7162 struct address_space
*aspace2
, CORE_ADDR addr2
)
7164 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
7165 || aspace1
== aspace2
)
7169 /* Returns true if {ASPACE2,ADDR2} falls within the range determined by
7170 {ASPACE1,ADDR1,LEN1}. In most targets, this can only be true if ASPACE1
7171 matches ASPACE2. On targets that have global breakpoints, the address
7172 space doesn't really matter. */
7175 breakpoint_address_match_range (struct address_space
*aspace1
, CORE_ADDR addr1
,
7176 int len1
, struct address_space
*aspace2
,
7179 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
7180 || aspace1
== aspace2
)
7181 && addr2
>= addr1
&& addr2
< addr1
+ len1
);
7184 /* Returns true if {ASPACE,ADDR} matches the breakpoint BL. BL may be
7185 a ranged breakpoint. In most targets, a match happens only if ASPACE
7186 matches the breakpoint's address space. On targets that have global
7187 breakpoints, the address space doesn't really matter. */
7190 breakpoint_location_address_match (struct bp_location
*bl
,
7191 struct address_space
*aspace
,
7194 return (breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
7197 && breakpoint_address_match_range (bl
->pspace
->aspace
,
7198 bl
->address
, bl
->length
,
7202 /* Returns true if the [ADDR,ADDR+LEN) range in ASPACE overlaps
7203 breakpoint BL. BL may be a ranged breakpoint. In most targets, a
7204 match happens only if ASPACE matches the breakpoint's address
7205 space. On targets that have global breakpoints, the address space
7206 doesn't really matter. */
7209 breakpoint_location_address_range_overlap (struct bp_location
*bl
,
7210 struct address_space
*aspace
,
7211 CORE_ADDR addr
, int len
)
7213 if (gdbarch_has_global_breakpoints (target_gdbarch ())
7214 || bl
->pspace
->aspace
== aspace
)
7216 int bl_len
= bl
->length
!= 0 ? bl
->length
: 1;
7218 if (mem_ranges_overlap (addr
, len
, bl
->address
, bl_len
))
7224 /* If LOC1 and LOC2's owners are not tracepoints, returns false directly.
7225 Then, if LOC1 and LOC2 represent the same tracepoint location, returns
7226 true, otherwise returns false. */
7229 tracepoint_locations_match (struct bp_location
*loc1
,
7230 struct bp_location
*loc2
)
7232 if (is_tracepoint (loc1
->owner
) && is_tracepoint (loc2
->owner
))
7233 /* Since tracepoint locations are never duplicated with others', tracepoint
7234 locations at the same address of different tracepoints are regarded as
7235 different locations. */
7236 return (loc1
->address
== loc2
->address
&& loc1
->owner
== loc2
->owner
);
7241 /* Assuming LOC1 and LOC2's types' have meaningful target addresses
7242 (breakpoint_address_is_meaningful), returns true if LOC1 and LOC2
7243 represent the same location. */
7246 breakpoint_locations_match (struct bp_location
*loc1
,
7247 struct bp_location
*loc2
)
7249 int hw_point1
, hw_point2
;
7251 /* Both of them must not be in moribund_locations. */
7252 gdb_assert (loc1
->owner
!= NULL
);
7253 gdb_assert (loc2
->owner
!= NULL
);
7255 hw_point1
= is_hardware_watchpoint (loc1
->owner
);
7256 hw_point2
= is_hardware_watchpoint (loc2
->owner
);
7258 if (hw_point1
!= hw_point2
)
7261 return watchpoint_locations_match (loc1
, loc2
);
7262 else if (is_tracepoint (loc1
->owner
) || is_tracepoint (loc2
->owner
))
7263 return tracepoint_locations_match (loc1
, loc2
);
7265 /* We compare bp_location.length in order to cover ranged breakpoints. */
7266 return (breakpoint_address_match (loc1
->pspace
->aspace
, loc1
->address
,
7267 loc2
->pspace
->aspace
, loc2
->address
)
7268 && loc1
->length
== loc2
->length
);
7272 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
7273 int bnum
, int have_bnum
)
7275 /* The longest string possibly returned by hex_string_custom
7276 is 50 chars. These must be at least that big for safety. */
7280 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
7281 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
7283 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
7284 bnum
, astr1
, astr2
);
7286 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
7289 /* Adjust a breakpoint's address to account for architectural
7290 constraints on breakpoint placement. Return the adjusted address.
7291 Note: Very few targets require this kind of adjustment. For most
7292 targets, this function is simply the identity function. */
7295 adjust_breakpoint_address (struct gdbarch
*gdbarch
,
7296 CORE_ADDR bpaddr
, enum bptype bptype
)
7298 if (!gdbarch_adjust_breakpoint_address_p (gdbarch
))
7300 /* Very few targets need any kind of breakpoint adjustment. */
7303 else if (bptype
== bp_watchpoint
7304 || bptype
== bp_hardware_watchpoint
7305 || bptype
== bp_read_watchpoint
7306 || bptype
== bp_access_watchpoint
7307 || bptype
== bp_catchpoint
)
7309 /* Watchpoints and the various bp_catch_* eventpoints should not
7310 have their addresses modified. */
7313 else if (bptype
== bp_single_step
)
7315 /* Single-step breakpoints should not have their addresses
7316 modified. If there's any architectural constrain that
7317 applies to this address, then it should have already been
7318 taken into account when the breakpoint was created in the
7319 first place. If we didn't do this, stepping through e.g.,
7320 Thumb-2 IT blocks would break. */
7325 CORE_ADDR adjusted_bpaddr
;
7327 /* Some targets have architectural constraints on the placement
7328 of breakpoint instructions. Obtain the adjusted address. */
7329 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (gdbarch
, bpaddr
);
7331 /* An adjusted breakpoint address can significantly alter
7332 a user's expectations. Print a warning if an adjustment
7334 if (adjusted_bpaddr
!= bpaddr
)
7335 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
7337 return adjusted_bpaddr
;
7342 init_bp_location (struct bp_location
*loc
, const struct bp_location_ops
*ops
,
7343 struct breakpoint
*owner
)
7345 memset (loc
, 0, sizeof (*loc
));
7347 gdb_assert (ops
!= NULL
);
7352 loc
->cond_bytecode
= NULL
;
7353 loc
->shlib_disabled
= 0;
7356 switch (owner
->type
)
7359 case bp_single_step
:
7363 case bp_longjmp_resume
:
7364 case bp_longjmp_call_dummy
:
7366 case bp_exception_resume
:
7367 case bp_step_resume
:
7368 case bp_hp_step_resume
:
7369 case bp_watchpoint_scope
:
7371 case bp_std_terminate
:
7372 case bp_shlib_event
:
7373 case bp_thread_event
:
7374 case bp_overlay_event
:
7376 case bp_longjmp_master
:
7377 case bp_std_terminate_master
:
7378 case bp_exception_master
:
7379 case bp_gnu_ifunc_resolver
:
7380 case bp_gnu_ifunc_resolver_return
:
7382 loc
->loc_type
= bp_loc_software_breakpoint
;
7383 mark_breakpoint_location_modified (loc
);
7385 case bp_hardware_breakpoint
:
7386 loc
->loc_type
= bp_loc_hardware_breakpoint
;
7387 mark_breakpoint_location_modified (loc
);
7389 case bp_hardware_watchpoint
:
7390 case bp_read_watchpoint
:
7391 case bp_access_watchpoint
:
7392 loc
->loc_type
= bp_loc_hardware_watchpoint
;
7397 case bp_fast_tracepoint
:
7398 case bp_static_tracepoint
:
7399 loc
->loc_type
= bp_loc_other
;
7402 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
7408 /* Allocate a struct bp_location. */
7410 static struct bp_location
*
7411 allocate_bp_location (struct breakpoint
*bpt
)
7413 return bpt
->ops
->allocate_location (bpt
);
7417 free_bp_location (struct bp_location
*loc
)
7419 loc
->ops
->dtor (loc
);
7423 /* Increment reference count. */
7426 incref_bp_location (struct bp_location
*bl
)
7431 /* Decrement reference count. If the reference count reaches 0,
7432 destroy the bp_location. Sets *BLP to NULL. */
7435 decref_bp_location (struct bp_location
**blp
)
7437 gdb_assert ((*blp
)->refc
> 0);
7439 if (--(*blp
)->refc
== 0)
7440 free_bp_location (*blp
);
7444 /* Add breakpoint B at the end of the global breakpoint chain. */
7447 add_to_breakpoint_chain (struct breakpoint
*b
)
7449 struct breakpoint
*b1
;
7451 /* Add this breakpoint to the end of the chain so that a list of
7452 breakpoints will come out in order of increasing numbers. */
7454 b1
= breakpoint_chain
;
7456 breakpoint_chain
= b
;
7465 /* Initializes breakpoint B with type BPTYPE and no locations yet. */
7468 init_raw_breakpoint_without_location (struct breakpoint
*b
,
7469 struct gdbarch
*gdbarch
,
7471 const struct breakpoint_ops
*ops
)
7473 memset (b
, 0, sizeof (*b
));
7475 gdb_assert (ops
!= NULL
);
7479 b
->gdbarch
= gdbarch
;
7480 b
->language
= current_language
->la_language
;
7481 b
->input_radix
= input_radix
;
7483 b
->enable_state
= bp_enabled
;
7486 b
->ignore_count
= 0;
7488 b
->frame_id
= null_frame_id
;
7489 b
->condition_not_parsed
= 0;
7490 b
->py_bp_object
= NULL
;
7491 b
->related_breakpoint
= b
;
7495 /* Helper to set_raw_breakpoint below. Creates a breakpoint
7496 that has type BPTYPE and has no locations as yet. */
7498 static struct breakpoint
*
7499 set_raw_breakpoint_without_location (struct gdbarch
*gdbarch
,
7501 const struct breakpoint_ops
*ops
)
7503 struct breakpoint
*b
= XNEW (struct breakpoint
);
7505 init_raw_breakpoint_without_location (b
, gdbarch
, bptype
, ops
);
7506 add_to_breakpoint_chain (b
);
7510 /* Initialize loc->function_name. EXPLICIT_LOC says no indirect function
7511 resolutions should be made as the user specified the location explicitly
7515 set_breakpoint_location_function (struct bp_location
*loc
, int explicit_loc
)
7517 gdb_assert (loc
->owner
!= NULL
);
7519 if (loc
->owner
->type
== bp_breakpoint
7520 || loc
->owner
->type
== bp_hardware_breakpoint
7521 || is_tracepoint (loc
->owner
))
7524 const char *function_name
;
7525 CORE_ADDR func_addr
;
7527 find_pc_partial_function_gnu_ifunc (loc
->address
, &function_name
,
7528 &func_addr
, NULL
, &is_gnu_ifunc
);
7530 if (is_gnu_ifunc
&& !explicit_loc
)
7532 struct breakpoint
*b
= loc
->owner
;
7534 gdb_assert (loc
->pspace
== current_program_space
);
7535 if (gnu_ifunc_resolve_name (function_name
,
7536 &loc
->requested_address
))
7538 /* Recalculate ADDRESS based on new REQUESTED_ADDRESS. */
7539 loc
->address
= adjust_breakpoint_address (loc
->gdbarch
,
7540 loc
->requested_address
,
7543 else if (b
->type
== bp_breakpoint
&& b
->loc
== loc
7544 && loc
->next
== NULL
&& b
->related_breakpoint
== b
)
7546 /* Create only the whole new breakpoint of this type but do not
7547 mess more complicated breakpoints with multiple locations. */
7548 b
->type
= bp_gnu_ifunc_resolver
;
7549 /* Remember the resolver's address for use by the return
7551 loc
->related_address
= func_addr
;
7556 loc
->function_name
= xstrdup (function_name
);
7560 /* Attempt to determine architecture of location identified by SAL. */
7562 get_sal_arch (struct symtab_and_line sal
)
7565 return get_objfile_arch (sal
.section
->objfile
);
7567 return get_objfile_arch (SYMTAB_OBJFILE (sal
.symtab
));
7572 /* Low level routine for partially initializing a breakpoint of type
7573 BPTYPE. The newly created breakpoint's address, section, source
7574 file name, and line number are provided by SAL.
7576 It is expected that the caller will complete the initialization of
7577 the newly created breakpoint struct as well as output any status
7578 information regarding the creation of a new breakpoint. */
7581 init_raw_breakpoint (struct breakpoint
*b
, struct gdbarch
*gdbarch
,
7582 struct symtab_and_line sal
, enum bptype bptype
,
7583 const struct breakpoint_ops
*ops
)
7585 init_raw_breakpoint_without_location (b
, gdbarch
, bptype
, ops
);
7587 add_location_to_breakpoint (b
, &sal
);
7589 if (bptype
!= bp_catchpoint
)
7590 gdb_assert (sal
.pspace
!= NULL
);
7592 /* Store the program space that was used to set the breakpoint,
7593 except for ordinary breakpoints, which are independent of the
7595 if (bptype
!= bp_breakpoint
&& bptype
!= bp_hardware_breakpoint
)
7596 b
->pspace
= sal
.pspace
;
7599 /* set_raw_breakpoint is a low level routine for allocating and
7600 partially initializing a breakpoint of type BPTYPE. The newly
7601 created breakpoint's address, section, source file name, and line
7602 number are provided by SAL. The newly created and partially
7603 initialized breakpoint is added to the breakpoint chain and
7604 is also returned as the value of this function.
7606 It is expected that the caller will complete the initialization of
7607 the newly created breakpoint struct as well as output any status
7608 information regarding the creation of a new breakpoint. In
7609 particular, set_raw_breakpoint does NOT set the breakpoint
7610 number! Care should be taken to not allow an error to occur
7611 prior to completing the initialization of the breakpoint. If this
7612 should happen, a bogus breakpoint will be left on the chain. */
7615 set_raw_breakpoint (struct gdbarch
*gdbarch
,
7616 struct symtab_and_line sal
, enum bptype bptype
,
7617 const struct breakpoint_ops
*ops
)
7619 struct breakpoint
*b
= XNEW (struct breakpoint
);
7621 init_raw_breakpoint (b
, gdbarch
, sal
, bptype
, ops
);
7622 add_to_breakpoint_chain (b
);
7626 /* Call this routine when stepping and nexting to enable a breakpoint
7627 if we do a longjmp() or 'throw' in TP. FRAME is the frame which
7628 initiated the operation. */
7631 set_longjmp_breakpoint (struct thread_info
*tp
, struct frame_id frame
)
7633 struct breakpoint
*b
, *b_tmp
;
7634 int thread
= tp
->global_num
;
7636 /* To avoid having to rescan all objfile symbols at every step,
7637 we maintain a list of continually-inserted but always disabled
7638 longjmp "master" breakpoints. Here, we simply create momentary
7639 clones of those and enable them for the requested thread. */
7640 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7641 if (b
->pspace
== current_program_space
7642 && (b
->type
== bp_longjmp_master
7643 || b
->type
== bp_exception_master
))
7645 enum bptype type
= b
->type
== bp_longjmp_master
? bp_longjmp
: bp_exception
;
7646 struct breakpoint
*clone
;
7648 /* longjmp_breakpoint_ops ensures INITIATING_FRAME is cleared again
7649 after their removal. */
7650 clone
= momentary_breakpoint_from_master (b
, type
,
7651 &longjmp_breakpoint_ops
, 1);
7652 clone
->thread
= thread
;
7655 tp
->initiating_frame
= frame
;
7658 /* Delete all longjmp breakpoints from THREAD. */
7660 delete_longjmp_breakpoint (int thread
)
7662 struct breakpoint
*b
, *b_tmp
;
7664 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7665 if (b
->type
== bp_longjmp
|| b
->type
== bp_exception
)
7667 if (b
->thread
== thread
)
7668 delete_breakpoint (b
);
7673 delete_longjmp_breakpoint_at_next_stop (int thread
)
7675 struct breakpoint
*b
, *b_tmp
;
7677 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7678 if (b
->type
== bp_longjmp
|| b
->type
== bp_exception
)
7680 if (b
->thread
== thread
)
7681 b
->disposition
= disp_del_at_next_stop
;
7685 /* Place breakpoints of type bp_longjmp_call_dummy to catch longjmp for
7686 INFERIOR_PTID thread. Chain them all by RELATED_BREAKPOINT and return
7687 pointer to any of them. Return NULL if this system cannot place longjmp
7691 set_longjmp_breakpoint_for_call_dummy (void)
7693 struct breakpoint
*b
, *retval
= NULL
;
7696 if (b
->pspace
== current_program_space
&& b
->type
== bp_longjmp_master
)
7698 struct breakpoint
*new_b
;
7700 new_b
= momentary_breakpoint_from_master (b
, bp_longjmp_call_dummy
,
7701 &momentary_breakpoint_ops
,
7703 new_b
->thread
= ptid_to_global_thread_id (inferior_ptid
);
7705 /* Link NEW_B into the chain of RETVAL breakpoints. */
7707 gdb_assert (new_b
->related_breakpoint
== new_b
);
7710 new_b
->related_breakpoint
= retval
;
7711 while (retval
->related_breakpoint
!= new_b
->related_breakpoint
)
7712 retval
= retval
->related_breakpoint
;
7713 retval
->related_breakpoint
= new_b
;
7719 /* Verify all existing dummy frames and their associated breakpoints for
7720 TP. Remove those which can no longer be found in the current frame
7723 You should call this function only at places where it is safe to currently
7724 unwind the whole stack. Failed stack unwind would discard live dummy
7728 check_longjmp_breakpoint_for_call_dummy (struct thread_info
*tp
)
7730 struct breakpoint
*b
, *b_tmp
;
7732 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7733 if (b
->type
== bp_longjmp_call_dummy
&& b
->thread
== tp
->global_num
)
7735 struct breakpoint
*dummy_b
= b
->related_breakpoint
;
7737 while (dummy_b
!= b
&& dummy_b
->type
!= bp_call_dummy
)
7738 dummy_b
= dummy_b
->related_breakpoint
;
7739 if (dummy_b
->type
!= bp_call_dummy
7740 || frame_find_by_id (dummy_b
->frame_id
) != NULL
)
7743 dummy_frame_discard (dummy_b
->frame_id
, tp
->ptid
);
7745 while (b
->related_breakpoint
!= b
)
7747 if (b_tmp
== b
->related_breakpoint
)
7748 b_tmp
= b
->related_breakpoint
->next
;
7749 delete_breakpoint (b
->related_breakpoint
);
7751 delete_breakpoint (b
);
7756 enable_overlay_breakpoints (void)
7758 struct breakpoint
*b
;
7761 if (b
->type
== bp_overlay_event
)
7763 b
->enable_state
= bp_enabled
;
7764 update_global_location_list (UGLL_MAY_INSERT
);
7765 overlay_events_enabled
= 1;
7770 disable_overlay_breakpoints (void)
7772 struct breakpoint
*b
;
7775 if (b
->type
== bp_overlay_event
)
7777 b
->enable_state
= bp_disabled
;
7778 update_global_location_list (UGLL_DONT_INSERT
);
7779 overlay_events_enabled
= 0;
7783 /* Set an active std::terminate breakpoint for each std::terminate
7784 master breakpoint. */
7786 set_std_terminate_breakpoint (void)
7788 struct breakpoint
*b
, *b_tmp
;
7790 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7791 if (b
->pspace
== current_program_space
7792 && b
->type
== bp_std_terminate_master
)
7794 momentary_breakpoint_from_master (b
, bp_std_terminate
,
7795 &momentary_breakpoint_ops
, 1);
7799 /* Delete all the std::terminate breakpoints. */
7801 delete_std_terminate_breakpoint (void)
7803 struct breakpoint
*b
, *b_tmp
;
7805 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7806 if (b
->type
== bp_std_terminate
)
7807 delete_breakpoint (b
);
7811 create_thread_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7813 struct breakpoint
*b
;
7815 b
= create_internal_breakpoint (gdbarch
, address
, bp_thread_event
,
7816 &internal_breakpoint_ops
);
7818 b
->enable_state
= bp_enabled
;
7819 /* location has to be used or breakpoint_re_set will delete me. */
7820 b
->location
= new_address_location (b
->loc
->address
, NULL
, 0);
7822 update_global_location_list_nothrow (UGLL_MAY_INSERT
);
7827 struct lang_and_radix
7833 /* Create a breakpoint for JIT code registration and unregistration. */
7836 create_jit_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7838 return create_internal_breakpoint (gdbarch
, address
, bp_jit_event
,
7839 &internal_breakpoint_ops
);
7842 /* Remove JIT code registration and unregistration breakpoint(s). */
7845 remove_jit_event_breakpoints (void)
7847 struct breakpoint
*b
, *b_tmp
;
7849 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7850 if (b
->type
== bp_jit_event
7851 && b
->loc
->pspace
== current_program_space
)
7852 delete_breakpoint (b
);
7856 remove_solib_event_breakpoints (void)
7858 struct breakpoint
*b
, *b_tmp
;
7860 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7861 if (b
->type
== bp_shlib_event
7862 && b
->loc
->pspace
== current_program_space
)
7863 delete_breakpoint (b
);
7866 /* See breakpoint.h. */
7869 remove_solib_event_breakpoints_at_next_stop (void)
7871 struct breakpoint
*b
, *b_tmp
;
7873 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7874 if (b
->type
== bp_shlib_event
7875 && b
->loc
->pspace
== current_program_space
)
7876 b
->disposition
= disp_del_at_next_stop
;
7879 /* Helper for create_solib_event_breakpoint /
7880 create_and_insert_solib_event_breakpoint. Allows specifying which
7881 INSERT_MODE to pass through to update_global_location_list. */
7883 static struct breakpoint
*
7884 create_solib_event_breakpoint_1 (struct gdbarch
*gdbarch
, CORE_ADDR address
,
7885 enum ugll_insert_mode insert_mode
)
7887 struct breakpoint
*b
;
7889 b
= create_internal_breakpoint (gdbarch
, address
, bp_shlib_event
,
7890 &internal_breakpoint_ops
);
7891 update_global_location_list_nothrow (insert_mode
);
7896 create_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7898 return create_solib_event_breakpoint_1 (gdbarch
, address
, UGLL_MAY_INSERT
);
7901 /* See breakpoint.h. */
7904 create_and_insert_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7906 struct breakpoint
*b
;
7908 /* Explicitly tell update_global_location_list to insert
7910 b
= create_solib_event_breakpoint_1 (gdbarch
, address
, UGLL_INSERT
);
7911 if (!b
->loc
->inserted
)
7913 delete_breakpoint (b
);
7919 /* Disable any breakpoints that are on code in shared libraries. Only
7920 apply to enabled breakpoints, disabled ones can just stay disabled. */
7923 disable_breakpoints_in_shlibs (void)
7925 struct bp_location
*loc
, **locp_tmp
;
7927 ALL_BP_LOCATIONS (loc
, locp_tmp
)
7929 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7930 struct breakpoint
*b
= loc
->owner
;
7932 /* We apply the check to all breakpoints, including disabled for
7933 those with loc->duplicate set. This is so that when breakpoint
7934 becomes enabled, or the duplicate is removed, gdb will try to
7935 insert all breakpoints. If we don't set shlib_disabled here,
7936 we'll try to insert those breakpoints and fail. */
7937 if (((b
->type
== bp_breakpoint
)
7938 || (b
->type
== bp_jit_event
)
7939 || (b
->type
== bp_hardware_breakpoint
)
7940 || (is_tracepoint (b
)))
7941 && loc
->pspace
== current_program_space
7942 && !loc
->shlib_disabled
7943 && solib_name_from_address (loc
->pspace
, loc
->address
)
7946 loc
->shlib_disabled
= 1;
7951 /* Disable any breakpoints and tracepoints that are in SOLIB upon
7952 notification of unloaded_shlib. Only apply to enabled breakpoints,
7953 disabled ones can just stay disabled. */
7956 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
7958 struct bp_location
*loc
, **locp_tmp
;
7959 int disabled_shlib_breaks
= 0;
7961 /* SunOS a.out shared libraries are always mapped, so do not
7962 disable breakpoints; they will only be reported as unloaded
7963 through clear_solib when GDB discards its shared library
7964 list. See clear_solib for more information. */
7965 if (exec_bfd
!= NULL
7966 && bfd_get_flavour (exec_bfd
) == bfd_target_aout_flavour
)
7969 ALL_BP_LOCATIONS (loc
, locp_tmp
)
7971 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7972 struct breakpoint
*b
= loc
->owner
;
7974 if (solib
->pspace
== loc
->pspace
7975 && !loc
->shlib_disabled
7976 && (((b
->type
== bp_breakpoint
7977 || b
->type
== bp_jit_event
7978 || b
->type
== bp_hardware_breakpoint
)
7979 && (loc
->loc_type
== bp_loc_hardware_breakpoint
7980 || loc
->loc_type
== bp_loc_software_breakpoint
))
7981 || is_tracepoint (b
))
7982 && solib_contains_address_p (solib
, loc
->address
))
7984 loc
->shlib_disabled
= 1;
7985 /* At this point, we cannot rely on remove_breakpoint
7986 succeeding so we must mark the breakpoint as not inserted
7987 to prevent future errors occurring in remove_breakpoints. */
7990 /* This may cause duplicate notifications for the same breakpoint. */
7991 observer_notify_breakpoint_modified (b
);
7993 if (!disabled_shlib_breaks
)
7995 target_terminal_ours_for_output ();
7996 warning (_("Temporarily disabling breakpoints "
7997 "for unloaded shared library \"%s\""),
8000 disabled_shlib_breaks
= 1;
8005 /* Disable any breakpoints and tracepoints in OBJFILE upon
8006 notification of free_objfile. Only apply to enabled breakpoints,
8007 disabled ones can just stay disabled. */
8010 disable_breakpoints_in_freed_objfile (struct objfile
*objfile
)
8012 struct breakpoint
*b
;
8014 if (objfile
== NULL
)
8017 /* OBJF_SHARED|OBJF_USERLOADED objfiles are dynamic modules manually
8018 managed by the user with add-symbol-file/remove-symbol-file.
8019 Similarly to how breakpoints in shared libraries are handled in
8020 response to "nosharedlibrary", mark breakpoints in such modules
8021 shlib_disabled so they end up uninserted on the next global
8022 location list update. Shared libraries not loaded by the user
8023 aren't handled here -- they're already handled in
8024 disable_breakpoints_in_unloaded_shlib, called by solib.c's
8025 solib_unloaded observer. We skip objfiles that are not
8026 OBJF_SHARED as those aren't considered dynamic objects (e.g. the
8028 if ((objfile
->flags
& OBJF_SHARED
) == 0
8029 || (objfile
->flags
& OBJF_USERLOADED
) == 0)
8034 struct bp_location
*loc
;
8035 int bp_modified
= 0;
8037 if (!is_breakpoint (b
) && !is_tracepoint (b
))
8040 for (loc
= b
->loc
; loc
!= NULL
; loc
= loc
->next
)
8042 CORE_ADDR loc_addr
= loc
->address
;
8044 if (loc
->loc_type
!= bp_loc_hardware_breakpoint
8045 && loc
->loc_type
!= bp_loc_software_breakpoint
)
8048 if (loc
->shlib_disabled
!= 0)
8051 if (objfile
->pspace
!= loc
->pspace
)
8054 if (loc
->loc_type
!= bp_loc_hardware_breakpoint
8055 && loc
->loc_type
!= bp_loc_software_breakpoint
)
8058 if (is_addr_in_objfile (loc_addr
, objfile
))
8060 loc
->shlib_disabled
= 1;
8061 /* At this point, we don't know whether the object was
8062 unmapped from the inferior or not, so leave the
8063 inserted flag alone. We'll handle failure to
8064 uninsert quietly, in case the object was indeed
8067 mark_breakpoint_location_modified (loc
);
8074 observer_notify_breakpoint_modified (b
);
8078 /* FORK & VFORK catchpoints. */
8080 /* An instance of this type is used to represent a fork or vfork
8081 catchpoint. It includes a "struct breakpoint" as a kind of base
8082 class; users downcast to "struct breakpoint *" when needed. A
8083 breakpoint is really of this type iff its ops pointer points to
8084 CATCH_FORK_BREAKPOINT_OPS. */
8086 struct fork_catchpoint
8088 /* The base class. */
8089 struct breakpoint base
;
8091 /* Process id of a child process whose forking triggered this
8092 catchpoint. This field is only valid immediately after this
8093 catchpoint has triggered. */
8094 ptid_t forked_inferior_pid
;
8097 /* Implement the "insert" breakpoint_ops method for fork
8101 insert_catch_fork (struct bp_location
*bl
)
8103 return target_insert_fork_catchpoint (ptid_get_pid (inferior_ptid
));
8106 /* Implement the "remove" breakpoint_ops method for fork
8110 remove_catch_fork (struct bp_location
*bl
)
8112 return target_remove_fork_catchpoint (ptid_get_pid (inferior_ptid
));
8115 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
8119 breakpoint_hit_catch_fork (const struct bp_location
*bl
,
8120 struct address_space
*aspace
, CORE_ADDR bp_addr
,
8121 const struct target_waitstatus
*ws
)
8123 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bl
->owner
;
8125 if (ws
->kind
!= TARGET_WAITKIND_FORKED
)
8128 c
->forked_inferior_pid
= ws
->value
.related_pid
;
8132 /* Implement the "print_it" breakpoint_ops method for fork
8135 static enum print_stop_action
8136 print_it_catch_fork (bpstat bs
)
8138 struct ui_out
*uiout
= current_uiout
;
8139 struct breakpoint
*b
= bs
->breakpoint_at
;
8140 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bs
->breakpoint_at
;
8142 annotate_catchpoint (b
->number
);
8143 maybe_print_thread_hit_breakpoint (uiout
);
8144 if (b
->disposition
== disp_del
)
8145 ui_out_text (uiout
, "Temporary catchpoint ");
8147 ui_out_text (uiout
, "Catchpoint ");
8148 if (ui_out_is_mi_like_p (uiout
))
8150 ui_out_field_string (uiout
, "reason",
8151 async_reason_lookup (EXEC_ASYNC_FORK
));
8152 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
8154 ui_out_field_int (uiout
, "bkptno", b
->number
);
8155 ui_out_text (uiout
, " (forked process ");
8156 ui_out_field_int (uiout
, "newpid", ptid_get_pid (c
->forked_inferior_pid
));
8157 ui_out_text (uiout
, "), ");
8158 return PRINT_SRC_AND_LOC
;
8161 /* Implement the "print_one" breakpoint_ops method for fork
8165 print_one_catch_fork (struct breakpoint
*b
, struct bp_location
**last_loc
)
8167 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
8168 struct value_print_options opts
;
8169 struct ui_out
*uiout
= current_uiout
;
8171 get_user_print_options (&opts
);
8173 /* Field 4, the address, is omitted (which makes the columns not
8174 line up too nicely with the headers, but the effect is relatively
8176 if (opts
.addressprint
)
8177 ui_out_field_skip (uiout
, "addr");
8179 ui_out_text (uiout
, "fork");
8180 if (!ptid_equal (c
->forked_inferior_pid
, null_ptid
))
8182 ui_out_text (uiout
, ", process ");
8183 ui_out_field_int (uiout
, "what",
8184 ptid_get_pid (c
->forked_inferior_pid
));
8185 ui_out_spaces (uiout
, 1);
8188 if (ui_out_is_mi_like_p (uiout
))
8189 ui_out_field_string (uiout
, "catch-type", "fork");
8192 /* Implement the "print_mention" breakpoint_ops method for fork
8196 print_mention_catch_fork (struct breakpoint
*b
)
8198 printf_filtered (_("Catchpoint %d (fork)"), b
->number
);
8201 /* Implement the "print_recreate" breakpoint_ops method for fork
8205 print_recreate_catch_fork (struct breakpoint
*b
, struct ui_file
*fp
)
8207 fprintf_unfiltered (fp
, "catch fork");
8208 print_recreate_thread (b
, fp
);
8211 /* The breakpoint_ops structure to be used in fork catchpoints. */
8213 static struct breakpoint_ops catch_fork_breakpoint_ops
;
8215 /* Implement the "insert" breakpoint_ops method for vfork
8219 insert_catch_vfork (struct bp_location
*bl
)
8221 return target_insert_vfork_catchpoint (ptid_get_pid (inferior_ptid
));
8224 /* Implement the "remove" breakpoint_ops method for vfork
8228 remove_catch_vfork (struct bp_location
*bl
)
8230 return target_remove_vfork_catchpoint (ptid_get_pid (inferior_ptid
));
8233 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
8237 breakpoint_hit_catch_vfork (const struct bp_location
*bl
,
8238 struct address_space
*aspace
, CORE_ADDR bp_addr
,
8239 const struct target_waitstatus
*ws
)
8241 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bl
->owner
;
8243 if (ws
->kind
!= TARGET_WAITKIND_VFORKED
)
8246 c
->forked_inferior_pid
= ws
->value
.related_pid
;
8250 /* Implement the "print_it" breakpoint_ops method for vfork
8253 static enum print_stop_action
8254 print_it_catch_vfork (bpstat bs
)
8256 struct ui_out
*uiout
= current_uiout
;
8257 struct breakpoint
*b
= bs
->breakpoint_at
;
8258 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
8260 annotate_catchpoint (b
->number
);
8261 maybe_print_thread_hit_breakpoint (uiout
);
8262 if (b
->disposition
== disp_del
)
8263 ui_out_text (uiout
, "Temporary catchpoint ");
8265 ui_out_text (uiout
, "Catchpoint ");
8266 if (ui_out_is_mi_like_p (uiout
))
8268 ui_out_field_string (uiout
, "reason",
8269 async_reason_lookup (EXEC_ASYNC_VFORK
));
8270 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
8272 ui_out_field_int (uiout
, "bkptno", b
->number
);
8273 ui_out_text (uiout
, " (vforked process ");
8274 ui_out_field_int (uiout
, "newpid", ptid_get_pid (c
->forked_inferior_pid
));
8275 ui_out_text (uiout
, "), ");
8276 return PRINT_SRC_AND_LOC
;
8279 /* Implement the "print_one" breakpoint_ops method for vfork
8283 print_one_catch_vfork (struct breakpoint
*b
, struct bp_location
**last_loc
)
8285 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
8286 struct value_print_options opts
;
8287 struct ui_out
*uiout
= current_uiout
;
8289 get_user_print_options (&opts
);
8290 /* Field 4, the address, is omitted (which makes the columns not
8291 line up too nicely with the headers, but the effect is relatively
8293 if (opts
.addressprint
)
8294 ui_out_field_skip (uiout
, "addr");
8296 ui_out_text (uiout
, "vfork");
8297 if (!ptid_equal (c
->forked_inferior_pid
, null_ptid
))
8299 ui_out_text (uiout
, ", process ");
8300 ui_out_field_int (uiout
, "what",
8301 ptid_get_pid (c
->forked_inferior_pid
));
8302 ui_out_spaces (uiout
, 1);
8305 if (ui_out_is_mi_like_p (uiout
))
8306 ui_out_field_string (uiout
, "catch-type", "vfork");
8309 /* Implement the "print_mention" breakpoint_ops method for vfork
8313 print_mention_catch_vfork (struct breakpoint
*b
)
8315 printf_filtered (_("Catchpoint %d (vfork)"), b
->number
);
8318 /* Implement the "print_recreate" breakpoint_ops method for vfork
8322 print_recreate_catch_vfork (struct breakpoint
*b
, struct ui_file
*fp
)
8324 fprintf_unfiltered (fp
, "catch vfork");
8325 print_recreate_thread (b
, fp
);
8328 /* The breakpoint_ops structure to be used in vfork catchpoints. */
8330 static struct breakpoint_ops catch_vfork_breakpoint_ops
;
8332 /* An instance of this type is used to represent an solib catchpoint.
8333 It includes a "struct breakpoint" as a kind of base class; users
8334 downcast to "struct breakpoint *" when needed. A breakpoint is
8335 really of this type iff its ops pointer points to
8336 CATCH_SOLIB_BREAKPOINT_OPS. */
8338 struct solib_catchpoint
8340 /* The base class. */
8341 struct breakpoint base
;
8343 /* True for "catch load", false for "catch unload". */
8344 unsigned char is_load
;
8346 /* Regular expression to match, if any. COMPILED is only valid when
8347 REGEX is non-NULL. */
8353 dtor_catch_solib (struct breakpoint
*b
)
8355 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8358 regfree (&self
->compiled
);
8359 xfree (self
->regex
);
8361 base_breakpoint_ops
.dtor (b
);
8365 insert_catch_solib (struct bp_location
*ignore
)
8371 remove_catch_solib (struct bp_location
*ignore
)
8377 breakpoint_hit_catch_solib (const struct bp_location
*bl
,
8378 struct address_space
*aspace
,
8380 const struct target_waitstatus
*ws
)
8382 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) bl
->owner
;
8383 struct breakpoint
*other
;
8385 if (ws
->kind
== TARGET_WAITKIND_LOADED
)
8388 ALL_BREAKPOINTS (other
)
8390 struct bp_location
*other_bl
;
8392 if (other
== bl
->owner
)
8395 if (other
->type
!= bp_shlib_event
)
8398 if (self
->base
.pspace
!= NULL
&& other
->pspace
!= self
->base
.pspace
)
8401 for (other_bl
= other
->loc
; other_bl
!= NULL
; other_bl
= other_bl
->next
)
8403 if (other
->ops
->breakpoint_hit (other_bl
, aspace
, bp_addr
, ws
))
8412 check_status_catch_solib (struct bpstats
*bs
)
8414 struct solib_catchpoint
*self
8415 = (struct solib_catchpoint
*) bs
->breakpoint_at
;
8420 struct so_list
*iter
;
8423 VEC_iterate (so_list_ptr
, current_program_space
->added_solibs
,
8428 || regexec (&self
->compiled
, iter
->so_name
, 0, NULL
, 0) == 0)
8437 VEC_iterate (char_ptr
, current_program_space
->deleted_solibs
,
8442 || regexec (&self
->compiled
, iter
, 0, NULL
, 0) == 0)
8448 bs
->print_it
= print_it_noop
;
8451 static enum print_stop_action
8452 print_it_catch_solib (bpstat bs
)
8454 struct breakpoint
*b
= bs
->breakpoint_at
;
8455 struct ui_out
*uiout
= current_uiout
;
8457 annotate_catchpoint (b
->number
);
8458 maybe_print_thread_hit_breakpoint (uiout
);
8459 if (b
->disposition
== disp_del
)
8460 ui_out_text (uiout
, "Temporary catchpoint ");
8462 ui_out_text (uiout
, "Catchpoint ");
8463 ui_out_field_int (uiout
, "bkptno", b
->number
);
8464 ui_out_text (uiout
, "\n");
8465 if (ui_out_is_mi_like_p (uiout
))
8466 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
8467 print_solib_event (1);
8468 return PRINT_SRC_AND_LOC
;
8472 print_one_catch_solib (struct breakpoint
*b
, struct bp_location
**locs
)
8474 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8475 struct value_print_options opts
;
8476 struct ui_out
*uiout
= current_uiout
;
8479 get_user_print_options (&opts
);
8480 /* Field 4, the address, is omitted (which makes the columns not
8481 line up too nicely with the headers, but the effect is relatively
8483 if (opts
.addressprint
)
8486 ui_out_field_skip (uiout
, "addr");
8493 msg
= xstrprintf (_("load of library matching %s"), self
->regex
);
8495 msg
= xstrdup (_("load of library"));
8500 msg
= xstrprintf (_("unload of library matching %s"), self
->regex
);
8502 msg
= xstrdup (_("unload of library"));
8504 ui_out_field_string (uiout
, "what", msg
);
8507 if (ui_out_is_mi_like_p (uiout
))
8508 ui_out_field_string (uiout
, "catch-type",
8509 self
->is_load
? "load" : "unload");
8513 print_mention_catch_solib (struct breakpoint
*b
)
8515 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8517 printf_filtered (_("Catchpoint %d (%s)"), b
->number
,
8518 self
->is_load
? "load" : "unload");
8522 print_recreate_catch_solib (struct breakpoint
*b
, struct ui_file
*fp
)
8524 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8526 fprintf_unfiltered (fp
, "%s %s",
8527 b
->disposition
== disp_del
? "tcatch" : "catch",
8528 self
->is_load
? "load" : "unload");
8530 fprintf_unfiltered (fp
, " %s", self
->regex
);
8531 fprintf_unfiltered (fp
, "\n");
8534 static struct breakpoint_ops catch_solib_breakpoint_ops
;
8536 /* Shared helper function (MI and CLI) for creating and installing
8537 a shared object event catchpoint. If IS_LOAD is non-zero then
8538 the events to be caught are load events, otherwise they are
8539 unload events. If IS_TEMP is non-zero the catchpoint is a
8540 temporary one. If ENABLED is non-zero the catchpoint is
8541 created in an enabled state. */
8544 add_solib_catchpoint (char *arg
, int is_load
, int is_temp
, int enabled
)
8546 struct solib_catchpoint
*c
;
8547 struct gdbarch
*gdbarch
= get_current_arch ();
8548 struct cleanup
*cleanup
;
8552 arg
= skip_spaces (arg
);
8554 c
= XCNEW (struct solib_catchpoint
);
8555 cleanup
= make_cleanup (xfree
, c
);
8561 errcode
= regcomp (&c
->compiled
, arg
, REG_NOSUB
);
8564 char *err
= get_regcomp_error (errcode
, &c
->compiled
);
8566 make_cleanup (xfree
, err
);
8567 error (_("Invalid regexp (%s): %s"), err
, arg
);
8569 c
->regex
= xstrdup (arg
);
8572 c
->is_load
= is_load
;
8573 init_catchpoint (&c
->base
, gdbarch
, is_temp
, NULL
,
8574 &catch_solib_breakpoint_ops
);
8576 c
->base
.enable_state
= enabled
? bp_enabled
: bp_disabled
;
8578 discard_cleanups (cleanup
);
8579 install_breakpoint (0, &c
->base
, 1);
8582 /* A helper function that does all the work for "catch load" and
8586 catch_load_or_unload (char *arg
, int from_tty
, int is_load
,
8587 struct cmd_list_element
*command
)
8590 const int enabled
= 1;
8592 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
8594 add_solib_catchpoint (arg
, is_load
, tempflag
, enabled
);
8598 catch_load_command_1 (char *arg
, int from_tty
,
8599 struct cmd_list_element
*command
)
8601 catch_load_or_unload (arg
, from_tty
, 1, command
);
8605 catch_unload_command_1 (char *arg
, int from_tty
,
8606 struct cmd_list_element
*command
)
8608 catch_load_or_unload (arg
, from_tty
, 0, command
);
8611 /* Initialize a new breakpoint of the bp_catchpoint kind. If TEMPFLAG
8612 is non-zero, then make the breakpoint temporary. If COND_STRING is
8613 not NULL, then store it in the breakpoint. OPS, if not NULL, is
8614 the breakpoint_ops structure associated to the catchpoint. */
8617 init_catchpoint (struct breakpoint
*b
,
8618 struct gdbarch
*gdbarch
, int tempflag
,
8620 const struct breakpoint_ops
*ops
)
8622 struct symtab_and_line sal
;
8625 sal
.pspace
= current_program_space
;
8627 init_raw_breakpoint (b
, gdbarch
, sal
, bp_catchpoint
, ops
);
8629 b
->cond_string
= (cond_string
== NULL
) ? NULL
: xstrdup (cond_string
);
8630 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
8634 install_breakpoint (int internal
, struct breakpoint
*b
, int update_gll
)
8636 add_to_breakpoint_chain (b
);
8637 set_breakpoint_number (internal
, b
);
8638 if (is_tracepoint (b
))
8639 set_tracepoint_count (breakpoint_count
);
8642 observer_notify_breakpoint_created (b
);
8645 update_global_location_list (UGLL_MAY_INSERT
);
8649 create_fork_vfork_event_catchpoint (struct gdbarch
*gdbarch
,
8650 int tempflag
, char *cond_string
,
8651 const struct breakpoint_ops
*ops
)
8653 struct fork_catchpoint
*c
= XNEW (struct fork_catchpoint
);
8655 init_catchpoint (&c
->base
, gdbarch
, tempflag
, cond_string
, ops
);
8657 c
->forked_inferior_pid
= null_ptid
;
8659 install_breakpoint (0, &c
->base
, 1);
8662 /* Exec catchpoints. */
8664 /* An instance of this type is used to represent an exec catchpoint.
8665 It includes a "struct breakpoint" as a kind of base class; users
8666 downcast to "struct breakpoint *" when needed. A breakpoint is
8667 really of this type iff its ops pointer points to
8668 CATCH_EXEC_BREAKPOINT_OPS. */
8670 struct exec_catchpoint
8672 /* The base class. */
8673 struct breakpoint base
;
8675 /* Filename of a program whose exec triggered this catchpoint.
8676 This field is only valid immediately after this catchpoint has
8678 char *exec_pathname
;
8681 /* Implement the "dtor" breakpoint_ops method for exec
8685 dtor_catch_exec (struct breakpoint
*b
)
8687 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
8689 xfree (c
->exec_pathname
);
8691 base_breakpoint_ops
.dtor (b
);
8695 insert_catch_exec (struct bp_location
*bl
)
8697 return target_insert_exec_catchpoint (ptid_get_pid (inferior_ptid
));
8701 remove_catch_exec (struct bp_location
*bl
)
8703 return target_remove_exec_catchpoint (ptid_get_pid (inferior_ptid
));
8707 breakpoint_hit_catch_exec (const struct bp_location
*bl
,
8708 struct address_space
*aspace
, CORE_ADDR bp_addr
,
8709 const struct target_waitstatus
*ws
)
8711 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) bl
->owner
;
8713 if (ws
->kind
!= TARGET_WAITKIND_EXECD
)
8716 c
->exec_pathname
= xstrdup (ws
->value
.execd_pathname
);
8720 static enum print_stop_action
8721 print_it_catch_exec (bpstat bs
)
8723 struct ui_out
*uiout
= current_uiout
;
8724 struct breakpoint
*b
= bs
->breakpoint_at
;
8725 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
8727 annotate_catchpoint (b
->number
);
8728 maybe_print_thread_hit_breakpoint (uiout
);
8729 if (b
->disposition
== disp_del
)
8730 ui_out_text (uiout
, "Temporary catchpoint ");
8732 ui_out_text (uiout
, "Catchpoint ");
8733 if (ui_out_is_mi_like_p (uiout
))
8735 ui_out_field_string (uiout
, "reason",
8736 async_reason_lookup (EXEC_ASYNC_EXEC
));
8737 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
8739 ui_out_field_int (uiout
, "bkptno", b
->number
);
8740 ui_out_text (uiout
, " (exec'd ");
8741 ui_out_field_string (uiout
, "new-exec", c
->exec_pathname
);
8742 ui_out_text (uiout
, "), ");
8744 return PRINT_SRC_AND_LOC
;
8748 print_one_catch_exec (struct breakpoint
*b
, struct bp_location
**last_loc
)
8750 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
8751 struct value_print_options opts
;
8752 struct ui_out
*uiout
= current_uiout
;
8754 get_user_print_options (&opts
);
8756 /* Field 4, the address, is omitted (which makes the columns
8757 not line up too nicely with the headers, but the effect
8758 is relatively readable). */
8759 if (opts
.addressprint
)
8760 ui_out_field_skip (uiout
, "addr");
8762 ui_out_text (uiout
, "exec");
8763 if (c
->exec_pathname
!= NULL
)
8765 ui_out_text (uiout
, ", program \"");
8766 ui_out_field_string (uiout
, "what", c
->exec_pathname
);
8767 ui_out_text (uiout
, "\" ");
8770 if (ui_out_is_mi_like_p (uiout
))
8771 ui_out_field_string (uiout
, "catch-type", "exec");
8775 print_mention_catch_exec (struct breakpoint
*b
)
8777 printf_filtered (_("Catchpoint %d (exec)"), b
->number
);
8780 /* Implement the "print_recreate" breakpoint_ops method for exec
8784 print_recreate_catch_exec (struct breakpoint
*b
, struct ui_file
*fp
)
8786 fprintf_unfiltered (fp
, "catch exec");
8787 print_recreate_thread (b
, fp
);
8790 static struct breakpoint_ops catch_exec_breakpoint_ops
;
8793 hw_breakpoint_used_count (void)
8796 struct breakpoint
*b
;
8797 struct bp_location
*bl
;
8801 if (b
->type
== bp_hardware_breakpoint
&& breakpoint_enabled (b
))
8802 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
8804 /* Special types of hardware breakpoints may use more than
8806 i
+= b
->ops
->resources_needed (bl
);
8813 /* Returns the resources B would use if it were a hardware
8817 hw_watchpoint_use_count (struct breakpoint
*b
)
8820 struct bp_location
*bl
;
8822 if (!breakpoint_enabled (b
))
8825 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
8827 /* Special types of hardware watchpoints may use more than
8829 i
+= b
->ops
->resources_needed (bl
);
8835 /* Returns the sum the used resources of all hardware watchpoints of
8836 type TYPE in the breakpoints list. Also returns in OTHER_TYPE_USED
8837 the sum of the used resources of all hardware watchpoints of other
8838 types _not_ TYPE. */
8841 hw_watchpoint_used_count_others (struct breakpoint
*except
,
8842 enum bptype type
, int *other_type_used
)
8845 struct breakpoint
*b
;
8847 *other_type_used
= 0;
8852 if (!breakpoint_enabled (b
))
8855 if (b
->type
== type
)
8856 i
+= hw_watchpoint_use_count (b
);
8857 else if (is_hardware_watchpoint (b
))
8858 *other_type_used
= 1;
8865 disable_watchpoints_before_interactive_call_start (void)
8867 struct breakpoint
*b
;
8871 if (is_watchpoint (b
) && breakpoint_enabled (b
))
8873 b
->enable_state
= bp_call_disabled
;
8874 update_global_location_list (UGLL_DONT_INSERT
);
8880 enable_watchpoints_after_interactive_call_stop (void)
8882 struct breakpoint
*b
;
8886 if (is_watchpoint (b
) && b
->enable_state
== bp_call_disabled
)
8888 b
->enable_state
= bp_enabled
;
8889 update_global_location_list (UGLL_MAY_INSERT
);
8895 disable_breakpoints_before_startup (void)
8897 current_program_space
->executing_startup
= 1;
8898 update_global_location_list (UGLL_DONT_INSERT
);
8902 enable_breakpoints_after_startup (void)
8904 current_program_space
->executing_startup
= 0;
8905 breakpoint_re_set ();
8908 /* Create a new single-step breakpoint for thread THREAD, with no
8911 static struct breakpoint
*
8912 new_single_step_breakpoint (int thread
, struct gdbarch
*gdbarch
)
8914 struct breakpoint
*b
= XNEW (struct breakpoint
);
8916 init_raw_breakpoint_without_location (b
, gdbarch
, bp_single_step
,
8917 &momentary_breakpoint_ops
);
8919 b
->disposition
= disp_donttouch
;
8920 b
->frame_id
= null_frame_id
;
8923 gdb_assert (b
->thread
!= 0);
8925 add_to_breakpoint_chain (b
);
8930 /* Set a momentary breakpoint of type TYPE at address specified by
8931 SAL. If FRAME_ID is valid, the breakpoint is restricted to that
8935 set_momentary_breakpoint (struct gdbarch
*gdbarch
, struct symtab_and_line sal
,
8936 struct frame_id frame_id
, enum bptype type
)
8938 struct breakpoint
*b
;
8940 /* If FRAME_ID is valid, it should be a real frame, not an inlined or
8942 gdb_assert (!frame_id_artificial_p (frame_id
));
8944 b
= set_raw_breakpoint (gdbarch
, sal
, type
, &momentary_breakpoint_ops
);
8945 b
->enable_state
= bp_enabled
;
8946 b
->disposition
= disp_donttouch
;
8947 b
->frame_id
= frame_id
;
8949 /* If we're debugging a multi-threaded program, then we want
8950 momentary breakpoints to be active in only a single thread of
8952 if (in_thread_list (inferior_ptid
))
8953 b
->thread
= ptid_to_global_thread_id (inferior_ptid
);
8955 update_global_location_list_nothrow (UGLL_MAY_INSERT
);
8960 /* Make a momentary breakpoint based on the master breakpoint ORIG.
8961 The new breakpoint will have type TYPE, use OPS as its
8962 breakpoint_ops, and will set enabled to LOC_ENABLED. */
8964 static struct breakpoint
*
8965 momentary_breakpoint_from_master (struct breakpoint
*orig
,
8967 const struct breakpoint_ops
*ops
,
8970 struct breakpoint
*copy
;
8972 copy
= set_raw_breakpoint_without_location (orig
->gdbarch
, type
, ops
);
8973 copy
->loc
= allocate_bp_location (copy
);
8974 set_breakpoint_location_function (copy
->loc
, 1);
8976 copy
->loc
->gdbarch
= orig
->loc
->gdbarch
;
8977 copy
->loc
->requested_address
= orig
->loc
->requested_address
;
8978 copy
->loc
->address
= orig
->loc
->address
;
8979 copy
->loc
->section
= orig
->loc
->section
;
8980 copy
->loc
->pspace
= orig
->loc
->pspace
;
8981 copy
->loc
->probe
= orig
->loc
->probe
;
8982 copy
->loc
->line_number
= orig
->loc
->line_number
;
8983 copy
->loc
->symtab
= orig
->loc
->symtab
;
8984 copy
->loc
->enabled
= loc_enabled
;
8985 copy
->frame_id
= orig
->frame_id
;
8986 copy
->thread
= orig
->thread
;
8987 copy
->pspace
= orig
->pspace
;
8989 copy
->enable_state
= bp_enabled
;
8990 copy
->disposition
= disp_donttouch
;
8991 copy
->number
= internal_breakpoint_number
--;
8993 update_global_location_list_nothrow (UGLL_DONT_INSERT
);
8997 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
9001 clone_momentary_breakpoint (struct breakpoint
*orig
)
9003 /* If there's nothing to clone, then return nothing. */
9007 return momentary_breakpoint_from_master (orig
, orig
->type
, orig
->ops
, 0);
9011 set_momentary_breakpoint_at_pc (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
9014 struct symtab_and_line sal
;
9016 sal
= find_pc_line (pc
, 0);
9018 sal
.section
= find_pc_overlay (pc
);
9019 sal
.explicit_pc
= 1;
9021 return set_momentary_breakpoint (gdbarch
, sal
, null_frame_id
, type
);
9025 /* Tell the user we have just set a breakpoint B. */
9028 mention (struct breakpoint
*b
)
9030 b
->ops
->print_mention (b
);
9031 if (ui_out_is_mi_like_p (current_uiout
))
9033 printf_filtered ("\n");
9037 static int bp_loc_is_permanent (struct bp_location
*loc
);
9039 static struct bp_location
*
9040 add_location_to_breakpoint (struct breakpoint
*b
,
9041 const struct symtab_and_line
*sal
)
9043 struct bp_location
*loc
, **tmp
;
9044 CORE_ADDR adjusted_address
;
9045 struct gdbarch
*loc_gdbarch
= get_sal_arch (*sal
);
9047 if (loc_gdbarch
== NULL
)
9048 loc_gdbarch
= b
->gdbarch
;
9050 /* Adjust the breakpoint's address prior to allocating a location.
9051 Once we call allocate_bp_location(), that mostly uninitialized
9052 location will be placed on the location chain. Adjustment of the
9053 breakpoint may cause target_read_memory() to be called and we do
9054 not want its scan of the location chain to find a breakpoint and
9055 location that's only been partially initialized. */
9056 adjusted_address
= adjust_breakpoint_address (loc_gdbarch
,
9059 /* Sort the locations by their ADDRESS. */
9060 loc
= allocate_bp_location (b
);
9061 for (tmp
= &(b
->loc
); *tmp
!= NULL
&& (*tmp
)->address
<= adjusted_address
;
9062 tmp
= &((*tmp
)->next
))
9067 loc
->requested_address
= sal
->pc
;
9068 loc
->address
= adjusted_address
;
9069 loc
->pspace
= sal
->pspace
;
9070 loc
->probe
.probe
= sal
->probe
;
9071 loc
->probe
.objfile
= sal
->objfile
;
9072 gdb_assert (loc
->pspace
!= NULL
);
9073 loc
->section
= sal
->section
;
9074 loc
->gdbarch
= loc_gdbarch
;
9075 loc
->line_number
= sal
->line
;
9076 loc
->symtab
= sal
->symtab
;
9078 set_breakpoint_location_function (loc
,
9079 sal
->explicit_pc
|| sal
->explicit_line
);
9081 /* While by definition, permanent breakpoints are already present in the
9082 code, we don't mark the location as inserted. Normally one would expect
9083 that GDB could rely on that breakpoint instruction to stop the program,
9084 thus removing the need to insert its own breakpoint, except that executing
9085 the breakpoint instruction can kill the target instead of reporting a
9086 SIGTRAP. E.g., on SPARC, when interrupts are disabled, executing the
9087 instruction resets the CPU, so QEMU 2.0.0 for SPARC correspondingly dies
9088 with "Trap 0x02 while interrupts disabled, Error state". Letting the
9089 breakpoint be inserted normally results in QEMU knowing about the GDB
9090 breakpoint, and thus trap before the breakpoint instruction is executed.
9091 (If GDB later needs to continue execution past the permanent breakpoint,
9092 it manually increments the PC, thus avoiding executing the breakpoint
9094 if (bp_loc_is_permanent (loc
))
9101 /* See breakpoint.h. */
9104 program_breakpoint_here_p (struct gdbarch
*gdbarch
, CORE_ADDR address
)
9108 const gdb_byte
*bpoint
;
9109 gdb_byte
*target_mem
;
9110 struct cleanup
*cleanup
;
9114 bpoint
= gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &len
);
9116 /* Software breakpoints unsupported? */
9120 target_mem
= (gdb_byte
*) alloca (len
);
9122 /* Enable the automatic memory restoration from breakpoints while
9123 we read the memory. Otherwise we could say about our temporary
9124 breakpoints they are permanent. */
9125 cleanup
= make_show_memory_breakpoints_cleanup (0);
9127 if (target_read_memory (address
, target_mem
, len
) == 0
9128 && memcmp (target_mem
, bpoint
, len
) == 0)
9131 do_cleanups (cleanup
);
9136 /* Return 1 if LOC is pointing to a permanent breakpoint,
9137 return 0 otherwise. */
9140 bp_loc_is_permanent (struct bp_location
*loc
)
9142 struct cleanup
*cleanup
;
9145 gdb_assert (loc
!= NULL
);
9147 /* If we have a catchpoint or a watchpoint, just return 0. We should not
9148 attempt to read from the addresses the locations of these breakpoint types
9149 point to. program_breakpoint_here_p, below, will attempt to read
9151 if (!breakpoint_address_is_meaningful (loc
->owner
))
9154 cleanup
= save_current_space_and_thread ();
9155 switch_to_program_space_and_thread (loc
->pspace
);
9157 retval
= program_breakpoint_here_p (loc
->gdbarch
, loc
->address
);
9159 do_cleanups (cleanup
);
9164 /* Build a command list for the dprintf corresponding to the current
9165 settings of the dprintf style options. */
9168 update_dprintf_command_list (struct breakpoint
*b
)
9170 char *dprintf_args
= b
->extra_string
;
9171 char *printf_line
= NULL
;
9176 dprintf_args
= skip_spaces (dprintf_args
);
9178 /* Allow a comma, as it may have terminated a location, but don't
9180 if (*dprintf_args
== ',')
9182 dprintf_args
= skip_spaces (dprintf_args
);
9184 if (*dprintf_args
!= '"')
9185 error (_("Bad format string, missing '\"'."));
9187 if (strcmp (dprintf_style
, dprintf_style_gdb
) == 0)
9188 printf_line
= xstrprintf ("printf %s", dprintf_args
);
9189 else if (strcmp (dprintf_style
, dprintf_style_call
) == 0)
9191 if (!dprintf_function
)
9192 error (_("No function supplied for dprintf call"));
9194 if (dprintf_channel
&& strlen (dprintf_channel
) > 0)
9195 printf_line
= xstrprintf ("call (void) %s (%s,%s)",
9200 printf_line
= xstrprintf ("call (void) %s (%s)",
9204 else if (strcmp (dprintf_style
, dprintf_style_agent
) == 0)
9206 if (target_can_run_breakpoint_commands ())
9207 printf_line
= xstrprintf ("agent-printf %s", dprintf_args
);
9210 warning (_("Target cannot run dprintf commands, falling back to GDB printf"));
9211 printf_line
= xstrprintf ("printf %s", dprintf_args
);
9215 internal_error (__FILE__
, __LINE__
,
9216 _("Invalid dprintf style."));
9218 gdb_assert (printf_line
!= NULL
);
9219 /* Manufacture a printf sequence. */
9221 struct command_line
*printf_cmd_line
= XNEW (struct command_line
);
9223 printf_cmd_line
->control_type
= simple_control
;
9224 printf_cmd_line
->body_count
= 0;
9225 printf_cmd_line
->body_list
= NULL
;
9226 printf_cmd_line
->next
= NULL
;
9227 printf_cmd_line
->line
= printf_line
;
9229 breakpoint_set_commands (b
, printf_cmd_line
);
9233 /* Update all dprintf commands, making their command lists reflect
9234 current style settings. */
9237 update_dprintf_commands (char *args
, int from_tty
,
9238 struct cmd_list_element
*c
)
9240 struct breakpoint
*b
;
9244 if (b
->type
== bp_dprintf
)
9245 update_dprintf_command_list (b
);
9249 /* Create a breakpoint with SAL as location. Use LOCATION
9250 as a description of the location, and COND_STRING
9251 as condition expression. If LOCATION is NULL then create an
9252 "address location" from the address in the SAL. */
9255 init_breakpoint_sal (struct breakpoint
*b
, struct gdbarch
*gdbarch
,
9256 struct symtabs_and_lines sals
,
9257 struct event_location
*location
,
9258 char *filter
, char *cond_string
,
9260 enum bptype type
, enum bpdisp disposition
,
9261 int thread
, int task
, int ignore_count
,
9262 const struct breakpoint_ops
*ops
, int from_tty
,
9263 int enabled
, int internal
, unsigned flags
,
9264 int display_canonical
)
9268 if (type
== bp_hardware_breakpoint
)
9270 int target_resources_ok
;
9272 i
= hw_breakpoint_used_count ();
9273 target_resources_ok
=
9274 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
9276 if (target_resources_ok
== 0)
9277 error (_("No hardware breakpoint support in the target."));
9278 else if (target_resources_ok
< 0)
9279 error (_("Hardware breakpoints used exceeds limit."));
9282 gdb_assert (sals
.nelts
> 0);
9284 for (i
= 0; i
< sals
.nelts
; ++i
)
9286 struct symtab_and_line sal
= sals
.sals
[i
];
9287 struct bp_location
*loc
;
9291 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
9293 loc_gdbarch
= gdbarch
;
9295 describe_other_breakpoints (loc_gdbarch
,
9296 sal
.pspace
, sal
.pc
, sal
.section
, thread
);
9301 init_raw_breakpoint (b
, gdbarch
, sal
, type
, ops
);
9305 b
->cond_string
= cond_string
;
9306 b
->extra_string
= extra_string
;
9307 b
->ignore_count
= ignore_count
;
9308 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
9309 b
->disposition
= disposition
;
9311 if ((flags
& CREATE_BREAKPOINT_FLAGS_INSERTED
) != 0)
9312 b
->loc
->inserted
= 1;
9314 if (type
== bp_static_tracepoint
)
9316 struct tracepoint
*t
= (struct tracepoint
*) b
;
9317 struct static_tracepoint_marker marker
;
9319 if (strace_marker_p (b
))
9321 /* We already know the marker exists, otherwise, we
9322 wouldn't see a sal for it. */
9323 const char *p
= &event_location_to_string (b
->location
)[3];
9327 p
= skip_spaces_const (p
);
9329 endp
= skip_to_space_const (p
);
9331 marker_str
= savestring (p
, endp
- p
);
9332 t
->static_trace_marker_id
= marker_str
;
9334 printf_filtered (_("Probed static tracepoint "
9336 t
->static_trace_marker_id
);
9338 else if (target_static_tracepoint_marker_at (sal
.pc
, &marker
))
9340 t
->static_trace_marker_id
= xstrdup (marker
.str_id
);
9341 release_static_tracepoint_marker (&marker
);
9343 printf_filtered (_("Probed static tracepoint "
9345 t
->static_trace_marker_id
);
9348 warning (_("Couldn't determine the static "
9349 "tracepoint marker to probe"));
9356 loc
= add_location_to_breakpoint (b
, &sal
);
9357 if ((flags
& CREATE_BREAKPOINT_FLAGS_INSERTED
) != 0)
9363 const char *arg
= b
->cond_string
;
9365 loc
->cond
= parse_exp_1 (&arg
, loc
->address
,
9366 block_for_pc (loc
->address
), 0);
9368 error (_("Garbage '%s' follows condition"), arg
);
9371 /* Dynamic printf requires and uses additional arguments on the
9372 command line, otherwise it's an error. */
9373 if (type
== bp_dprintf
)
9375 if (b
->extra_string
)
9376 update_dprintf_command_list (b
);
9378 error (_("Format string required"));
9380 else if (b
->extra_string
)
9381 error (_("Garbage '%s' at end of command"), b
->extra_string
);
9384 b
->display_canonical
= display_canonical
;
9385 if (location
!= NULL
)
9386 b
->location
= location
;
9389 const char *addr_string
= NULL
;
9390 int addr_string_len
= 0;
9392 if (location
!= NULL
)
9393 addr_string
= event_location_to_string (location
);
9394 if (addr_string
!= NULL
)
9395 addr_string_len
= strlen (addr_string
);
9397 b
->location
= new_address_location (b
->loc
->address
,
9398 addr_string
, addr_string_len
);
9404 create_breakpoint_sal (struct gdbarch
*gdbarch
,
9405 struct symtabs_and_lines sals
,
9406 struct event_location
*location
,
9407 char *filter
, char *cond_string
,
9409 enum bptype type
, enum bpdisp disposition
,
9410 int thread
, int task
, int ignore_count
,
9411 const struct breakpoint_ops
*ops
, int from_tty
,
9412 int enabled
, int internal
, unsigned flags
,
9413 int display_canonical
)
9415 struct breakpoint
*b
;
9416 struct cleanup
*old_chain
;
9418 if (is_tracepoint_type (type
))
9420 struct tracepoint
*t
;
9422 t
= XCNEW (struct tracepoint
);
9426 b
= XNEW (struct breakpoint
);
9428 old_chain
= make_cleanup (xfree
, b
);
9430 init_breakpoint_sal (b
, gdbarch
,
9432 filter
, cond_string
, extra_string
,
9434 thread
, task
, ignore_count
,
9436 enabled
, internal
, flags
,
9438 discard_cleanups (old_chain
);
9440 install_breakpoint (internal
, b
, 0);
9443 /* Add SALS.nelts breakpoints to the breakpoint table. For each
9444 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
9445 value. COND_STRING, if not NULL, specified the condition to be
9446 used for all breakpoints. Essentially the only case where
9447 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
9448 function. In that case, it's still not possible to specify
9449 separate conditions for different overloaded functions, so
9450 we take just a single condition string.
9452 NOTE: If the function succeeds, the caller is expected to cleanup
9453 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
9454 array contents). If the function fails (error() is called), the
9455 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
9456 COND and SALS arrays and each of those arrays contents. */
9459 create_breakpoints_sal (struct gdbarch
*gdbarch
,
9460 struct linespec_result
*canonical
,
9461 char *cond_string
, char *extra_string
,
9462 enum bptype type
, enum bpdisp disposition
,
9463 int thread
, int task
, int ignore_count
,
9464 const struct breakpoint_ops
*ops
, int from_tty
,
9465 int enabled
, int internal
, unsigned flags
)
9468 struct linespec_sals
*lsal
;
9470 if (canonical
->pre_expanded
)
9471 gdb_assert (VEC_length (linespec_sals
, canonical
->sals
) == 1);
9473 for (i
= 0; VEC_iterate (linespec_sals
, canonical
->sals
, i
, lsal
); ++i
)
9475 /* Note that 'location' can be NULL in the case of a plain
9476 'break', without arguments. */
9477 struct event_location
*location
9478 = (canonical
->location
!= NULL
9479 ? copy_event_location (canonical
->location
) : NULL
);
9480 char *filter_string
= lsal
->canonical
? xstrdup (lsal
->canonical
) : NULL
;
9481 struct cleanup
*inner
= make_cleanup_delete_event_location (location
);
9483 make_cleanup (xfree
, filter_string
);
9484 create_breakpoint_sal (gdbarch
, lsal
->sals
,
9487 cond_string
, extra_string
,
9489 thread
, task
, ignore_count
, ops
,
9490 from_tty
, enabled
, internal
, flags
,
9491 canonical
->special_display
);
9492 discard_cleanups (inner
);
9496 /* Parse LOCATION which is assumed to be a SAL specification possibly
9497 followed by conditionals. On return, SALS contains an array of SAL
9498 addresses found. LOCATION points to the end of the SAL (for
9499 linespec locations).
9501 The array and the line spec strings are allocated on the heap, it is
9502 the caller's responsibility to free them. */
9505 parse_breakpoint_sals (const struct event_location
*location
,
9506 struct linespec_result
*canonical
)
9508 struct symtab_and_line cursal
;
9510 if (event_location_type (location
) == LINESPEC_LOCATION
)
9512 const char *address
= get_linespec_location (location
);
9514 if (address
== NULL
)
9516 /* The last displayed codepoint, if it's valid, is our default
9517 breakpoint address. */
9518 if (last_displayed_sal_is_valid ())
9520 struct linespec_sals lsal
;
9521 struct symtab_and_line sal
;
9524 init_sal (&sal
); /* Initialize to zeroes. */
9525 lsal
.sals
.sals
= XNEW (struct symtab_and_line
);
9527 /* Set sal's pspace, pc, symtab, and line to the values
9528 corresponding to the last call to print_frame_info.
9529 Be sure to reinitialize LINE with NOTCURRENT == 0
9530 as the breakpoint line number is inappropriate otherwise.
9531 find_pc_line would adjust PC, re-set it back. */
9532 get_last_displayed_sal (&sal
);
9534 sal
= find_pc_line (pc
, 0);
9536 /* "break" without arguments is equivalent to "break *PC"
9537 where PC is the last displayed codepoint's address. So
9538 make sure to set sal.explicit_pc to prevent GDB from
9539 trying to expand the list of sals to include all other
9540 instances with the same symtab and line. */
9542 sal
.explicit_pc
= 1;
9544 lsal
.sals
.sals
[0] = sal
;
9545 lsal
.sals
.nelts
= 1;
9546 lsal
.canonical
= NULL
;
9548 VEC_safe_push (linespec_sals
, canonical
->sals
, &lsal
);
9552 error (_("No default breakpoint address now."));
9556 /* Force almost all breakpoints to be in terms of the
9557 current_source_symtab (which is decode_line_1's default).
9558 This should produce the results we want almost all of the
9559 time while leaving default_breakpoint_* alone.
9561 ObjC: However, don't match an Objective-C method name which
9562 may have a '+' or '-' succeeded by a '['. */
9563 cursal
= get_current_source_symtab_and_line ();
9564 if (last_displayed_sal_is_valid ())
9566 const char *address
= NULL
;
9568 if (event_location_type (location
) == LINESPEC_LOCATION
)
9569 address
= get_linespec_location (location
);
9573 && strchr ("+-", address
[0]) != NULL
9574 && address
[1] != '['))
9576 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, NULL
,
9577 get_last_displayed_symtab (),
9578 get_last_displayed_line (),
9579 canonical
, NULL
, NULL
);
9584 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, NULL
,
9585 cursal
.symtab
, cursal
.line
, canonical
, NULL
, NULL
);
9589 /* Convert each SAL into a real PC. Verify that the PC can be
9590 inserted as a breakpoint. If it can't throw an error. */
9593 breakpoint_sals_to_pc (struct symtabs_and_lines
*sals
)
9597 for (i
= 0; i
< sals
->nelts
; i
++)
9598 resolve_sal_pc (&sals
->sals
[i
]);
9601 /* Fast tracepoints may have restrictions on valid locations. For
9602 instance, a fast tracepoint using a jump instead of a trap will
9603 likely have to overwrite more bytes than a trap would, and so can
9604 only be placed where the instruction is longer than the jump, or a
9605 multi-instruction sequence does not have a jump into the middle of
9609 check_fast_tracepoint_sals (struct gdbarch
*gdbarch
,
9610 struct symtabs_and_lines
*sals
)
9613 struct symtab_and_line
*sal
;
9615 struct cleanup
*old_chain
;
9617 for (i
= 0; i
< sals
->nelts
; i
++)
9619 struct gdbarch
*sarch
;
9621 sal
= &sals
->sals
[i
];
9623 sarch
= get_sal_arch (*sal
);
9624 /* We fall back to GDBARCH if there is no architecture
9625 associated with SAL. */
9628 rslt
= gdbarch_fast_tracepoint_valid_at (sarch
, sal
->pc
, &msg
);
9629 old_chain
= make_cleanup (xfree
, msg
);
9632 error (_("May not have a fast tracepoint at 0x%s%s"),
9633 paddress (sarch
, sal
->pc
), (msg
? msg
: ""));
9635 do_cleanups (old_chain
);
9639 /* Given TOK, a string specification of condition and thread, as
9640 accepted by the 'break' command, extract the condition
9641 string and thread number and set *COND_STRING and *THREAD.
9642 PC identifies the context at which the condition should be parsed.
9643 If no condition is found, *COND_STRING is set to NULL.
9644 If no thread is found, *THREAD is set to -1. */
9647 find_condition_and_thread (const char *tok
, CORE_ADDR pc
,
9648 char **cond_string
, int *thread
, int *task
,
9651 *cond_string
= NULL
;
9658 const char *end_tok
;
9660 const char *cond_start
= NULL
;
9661 const char *cond_end
= NULL
;
9663 tok
= skip_spaces_const (tok
);
9665 if ((*tok
== '"' || *tok
== ',') && rest
)
9667 *rest
= savestring (tok
, strlen (tok
));
9671 end_tok
= skip_to_space_const (tok
);
9673 toklen
= end_tok
- tok
;
9675 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
9677 struct expression
*expr
;
9679 tok
= cond_start
= end_tok
+ 1;
9680 expr
= parse_exp_1 (&tok
, pc
, block_for_pc (pc
), 0);
9683 *cond_string
= savestring (cond_start
, cond_end
- cond_start
);
9685 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
9688 struct thread_info
*thr
;
9691 thr
= parse_thread_id (tok
, &tmptok
);
9693 error (_("Junk after thread keyword."));
9694 *thread
= thr
->global_num
;
9697 else if (toklen
>= 1 && strncmp (tok
, "task", toklen
) == 0)
9702 *task
= strtol (tok
, &tmptok
, 0);
9704 error (_("Junk after task keyword."));
9705 if (!valid_task_id (*task
))
9706 error (_("Unknown task %d."), *task
);
9711 *rest
= savestring (tok
, strlen (tok
));
9715 error (_("Junk at end of arguments."));
9719 /* Decode a static tracepoint marker spec. */
9721 static struct symtabs_and_lines
9722 decode_static_tracepoint_spec (const char **arg_p
)
9724 VEC(static_tracepoint_marker_p
) *markers
= NULL
;
9725 struct symtabs_and_lines sals
;
9726 struct cleanup
*old_chain
;
9727 const char *p
= &(*arg_p
)[3];
9732 p
= skip_spaces_const (p
);
9734 endp
= skip_to_space_const (p
);
9736 marker_str
= savestring (p
, endp
- p
);
9737 old_chain
= make_cleanup (xfree
, marker_str
);
9739 markers
= target_static_tracepoint_markers_by_strid (marker_str
);
9740 if (VEC_empty(static_tracepoint_marker_p
, markers
))
9741 error (_("No known static tracepoint marker named %s"), marker_str
);
9743 sals
.nelts
= VEC_length(static_tracepoint_marker_p
, markers
);
9744 sals
.sals
= XNEWVEC (struct symtab_and_line
, sals
.nelts
);
9746 for (i
= 0; i
< sals
.nelts
; i
++)
9748 struct static_tracepoint_marker
*marker
;
9750 marker
= VEC_index (static_tracepoint_marker_p
, markers
, i
);
9752 init_sal (&sals
.sals
[i
]);
9754 sals
.sals
[i
] = find_pc_line (marker
->address
, 0);
9755 sals
.sals
[i
].pc
= marker
->address
;
9757 release_static_tracepoint_marker (marker
);
9760 do_cleanups (old_chain
);
9766 /* See breakpoint.h. */
9769 create_breakpoint (struct gdbarch
*gdbarch
,
9770 const struct event_location
*location
, char *cond_string
,
9771 int thread
, char *extra_string
,
9773 int tempflag
, enum bptype type_wanted
,
9775 enum auto_boolean pending_break_support
,
9776 const struct breakpoint_ops
*ops
,
9777 int from_tty
, int enabled
, int internal
,
9780 struct linespec_result canonical
;
9781 struct cleanup
*old_chain
;
9782 struct cleanup
*bkpt_chain
= NULL
;
9785 int prev_bkpt_count
= breakpoint_count
;
9787 gdb_assert (ops
!= NULL
);
9789 /* If extra_string isn't useful, set it to NULL. */
9790 if (extra_string
!= NULL
&& *extra_string
== '\0')
9791 extra_string
= NULL
;
9793 init_linespec_result (&canonical
);
9797 ops
->create_sals_from_location (location
, &canonical
, type_wanted
);
9799 CATCH (e
, RETURN_MASK_ERROR
)
9801 /* If caller is interested in rc value from parse, set
9803 if (e
.error
== NOT_FOUND_ERROR
)
9805 /* If pending breakpoint support is turned off, throw
9808 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
9809 throw_exception (e
);
9811 exception_print (gdb_stderr
, e
);
9813 /* If pending breakpoint support is auto query and the user
9814 selects no, then simply return the error code. */
9815 if (pending_break_support
== AUTO_BOOLEAN_AUTO
9816 && !nquery (_("Make %s pending on future shared library load? "),
9817 bptype_string (type_wanted
)))
9820 /* At this point, either the user was queried about setting
9821 a pending breakpoint and selected yes, or pending
9822 breakpoint behavior is on and thus a pending breakpoint
9823 is defaulted on behalf of the user. */
9827 throw_exception (e
);
9831 if (!pending
&& VEC_empty (linespec_sals
, canonical
.sals
))
9834 /* Create a chain of things that always need to be cleaned up. */
9835 old_chain
= make_cleanup_destroy_linespec_result (&canonical
);
9837 /* ----------------------------- SNIP -----------------------------
9838 Anything added to the cleanup chain beyond this point is assumed
9839 to be part of a breakpoint. If the breakpoint create succeeds
9840 then the memory is not reclaimed. */
9841 bkpt_chain
= make_cleanup (null_cleanup
, 0);
9843 /* Resolve all line numbers to PC's and verify that the addresses
9844 are ok for the target. */
9848 struct linespec_sals
*iter
;
9850 for (ix
= 0; VEC_iterate (linespec_sals
, canonical
.sals
, ix
, iter
); ++ix
)
9851 breakpoint_sals_to_pc (&iter
->sals
);
9854 /* Fast tracepoints may have additional restrictions on location. */
9855 if (!pending
&& type_wanted
== bp_fast_tracepoint
)
9858 struct linespec_sals
*iter
;
9860 for (ix
= 0; VEC_iterate (linespec_sals
, canonical
.sals
, ix
, iter
); ++ix
)
9861 check_fast_tracepoint_sals (gdbarch
, &iter
->sals
);
9864 /* Verify that condition can be parsed, before setting any
9865 breakpoints. Allocate a separate condition expression for each
9872 struct linespec_sals
*lsal
;
9874 lsal
= VEC_index (linespec_sals
, canonical
.sals
, 0);
9876 /* Here we only parse 'arg' to separate condition
9877 from thread number, so parsing in context of first
9878 sal is OK. When setting the breakpoint we'll
9879 re-parse it in context of each sal. */
9881 find_condition_and_thread (extra_string
, lsal
->sals
.sals
[0].pc
,
9882 &cond_string
, &thread
, &task
, &rest
);
9884 make_cleanup (xfree
, cond_string
);
9886 make_cleanup (xfree
, rest
);
9888 extra_string
= rest
;
9890 extra_string
= NULL
;
9894 if (type_wanted
!= bp_dprintf
9895 && extra_string
!= NULL
&& *extra_string
!= '\0')
9896 error (_("Garbage '%s' at end of location"), extra_string
);
9898 /* Create a private copy of condition string. */
9901 cond_string
= xstrdup (cond_string
);
9902 make_cleanup (xfree
, cond_string
);
9904 /* Create a private copy of any extra string. */
9907 extra_string
= xstrdup (extra_string
);
9908 make_cleanup (xfree
, extra_string
);
9912 ops
->create_breakpoints_sal (gdbarch
, &canonical
,
9913 cond_string
, extra_string
, type_wanted
,
9914 tempflag
? disp_del
: disp_donttouch
,
9915 thread
, task
, ignore_count
, ops
,
9916 from_tty
, enabled
, internal
, flags
);
9920 struct breakpoint
*b
;
9922 if (is_tracepoint_type (type_wanted
))
9924 struct tracepoint
*t
;
9926 t
= XCNEW (struct tracepoint
);
9930 b
= XNEW (struct breakpoint
);
9932 init_raw_breakpoint_without_location (b
, gdbarch
, type_wanted
, ops
);
9933 b
->location
= copy_event_location (location
);
9936 b
->cond_string
= NULL
;
9939 /* Create a private copy of condition string. */
9942 cond_string
= xstrdup (cond_string
);
9943 make_cleanup (xfree
, cond_string
);
9945 b
->cond_string
= cond_string
;
9949 /* Create a private copy of any extra string. */
9950 if (extra_string
!= NULL
)
9952 extra_string
= xstrdup (extra_string
);
9953 make_cleanup (xfree
, extra_string
);
9955 b
->extra_string
= extra_string
;
9956 b
->ignore_count
= ignore_count
;
9957 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
9958 b
->condition_not_parsed
= 1;
9959 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
9960 if ((type_wanted
!= bp_breakpoint
9961 && type_wanted
!= bp_hardware_breakpoint
) || thread
!= -1)
9962 b
->pspace
= current_program_space
;
9964 install_breakpoint (internal
, b
, 0);
9967 if (VEC_length (linespec_sals
, canonical
.sals
) > 1)
9969 warning (_("Multiple breakpoints were set.\nUse the "
9970 "\"delete\" command to delete unwanted breakpoints."));
9971 prev_breakpoint_count
= prev_bkpt_count
;
9974 /* That's it. Discard the cleanups for data inserted into the
9976 discard_cleanups (bkpt_chain
);
9977 /* But cleanup everything else. */
9978 do_cleanups (old_chain
);
9980 /* error call may happen here - have BKPT_CHAIN already discarded. */
9981 update_global_location_list (UGLL_MAY_INSERT
);
9986 /* Set a breakpoint.
9987 ARG is a string describing breakpoint address,
9988 condition, and thread.
9989 FLAG specifies if a breakpoint is hardware on,
9990 and if breakpoint is temporary, using BP_HARDWARE_FLAG
9994 break_command_1 (char *arg
, int flag
, int from_tty
)
9996 int tempflag
= flag
& BP_TEMPFLAG
;
9997 enum bptype type_wanted
= (flag
& BP_HARDWAREFLAG
9998 ? bp_hardware_breakpoint
10000 struct breakpoint_ops
*ops
;
10001 struct event_location
*location
;
10002 struct cleanup
*cleanup
;
10004 location
= string_to_event_location (&arg
, current_language
);
10005 cleanup
= make_cleanup_delete_event_location (location
);
10007 /* Matching breakpoints on probes. */
10008 if (location
!= NULL
10009 && event_location_type (location
) == PROBE_LOCATION
)
10010 ops
= &bkpt_probe_breakpoint_ops
;
10012 ops
= &bkpt_breakpoint_ops
;
10014 create_breakpoint (get_current_arch (),
10016 NULL
, 0, arg
, 1 /* parse arg */,
10017 tempflag
, type_wanted
,
10018 0 /* Ignore count */,
10019 pending_break_support
,
10025 do_cleanups (cleanup
);
10028 /* Helper function for break_command_1 and disassemble_command. */
10031 resolve_sal_pc (struct symtab_and_line
*sal
)
10035 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
10037 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
10038 error (_("No line %d in file \"%s\"."),
10039 sal
->line
, symtab_to_filename_for_display (sal
->symtab
));
10042 /* If this SAL corresponds to a breakpoint inserted using a line
10043 number, then skip the function prologue if necessary. */
10044 if (sal
->explicit_line
)
10045 skip_prologue_sal (sal
);
10048 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
10050 const struct blockvector
*bv
;
10051 const struct block
*b
;
10052 struct symbol
*sym
;
10054 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
,
10055 SYMTAB_COMPUNIT (sal
->symtab
));
10058 sym
= block_linkage_function (b
);
10061 fixup_symbol_section (sym
, SYMTAB_OBJFILE (sal
->symtab
));
10062 sal
->section
= SYMBOL_OBJ_SECTION (SYMTAB_OBJFILE (sal
->symtab
),
10067 /* It really is worthwhile to have the section, so we'll
10068 just have to look harder. This case can be executed
10069 if we have line numbers but no functions (as can
10070 happen in assembly source). */
10072 struct bound_minimal_symbol msym
;
10073 struct cleanup
*old_chain
= save_current_space_and_thread ();
10075 switch_to_program_space_and_thread (sal
->pspace
);
10077 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
10079 sal
->section
= MSYMBOL_OBJ_SECTION (msym
.objfile
, msym
.minsym
);
10081 do_cleanups (old_chain
);
10088 break_command (char *arg
, int from_tty
)
10090 break_command_1 (arg
, 0, from_tty
);
10094 tbreak_command (char *arg
, int from_tty
)
10096 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
10100 hbreak_command (char *arg
, int from_tty
)
10102 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
10106 thbreak_command (char *arg
, int from_tty
)
10108 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
10112 stop_command (char *arg
, int from_tty
)
10114 printf_filtered (_("Specify the type of breakpoint to set.\n\
10115 Usage: stop in <function | address>\n\
10116 stop at <line>\n"));
10120 stopin_command (char *arg
, int from_tty
)
10124 if (arg
== (char *) NULL
)
10126 else if (*arg
!= '*')
10128 char *argptr
= arg
;
10131 /* Look for a ':'. If this is a line number specification, then
10132 say it is bad, otherwise, it should be an address or
10133 function/method name. */
10134 while (*argptr
&& !hasColon
)
10136 hasColon
= (*argptr
== ':');
10141 badInput
= (*argptr
!= ':'); /* Not a class::method */
10143 badInput
= isdigit (*arg
); /* a simple line number */
10147 printf_filtered (_("Usage: stop in <function | address>\n"));
10149 break_command_1 (arg
, 0, from_tty
);
10153 stopat_command (char *arg
, int from_tty
)
10157 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
10161 char *argptr
= arg
;
10164 /* Look for a ':'. If there is a '::' then get out, otherwise
10165 it is probably a line number. */
10166 while (*argptr
&& !hasColon
)
10168 hasColon
= (*argptr
== ':');
10173 badInput
= (*argptr
== ':'); /* we have class::method */
10175 badInput
= !isdigit (*arg
); /* not a line number */
10179 printf_filtered (_("Usage: stop at <line>\n"));
10181 break_command_1 (arg
, 0, from_tty
);
10184 /* The dynamic printf command is mostly like a regular breakpoint, but
10185 with a prewired command list consisting of a single output command,
10186 built from extra arguments supplied on the dprintf command
10190 dprintf_command (char *arg
, int from_tty
)
10192 struct event_location
*location
;
10193 struct cleanup
*cleanup
;
10195 location
= string_to_event_location (&arg
, current_language
);
10196 cleanup
= make_cleanup_delete_event_location (location
);
10198 /* If non-NULL, ARG should have been advanced past the location;
10199 the next character must be ','. */
10202 if (arg
[0] != ',' || arg
[1] == '\0')
10203 error (_("Format string required"));
10206 /* Skip the comma. */
10211 create_breakpoint (get_current_arch (),
10213 NULL
, 0, arg
, 1 /* parse arg */,
10215 0 /* Ignore count */,
10216 pending_break_support
,
10217 &dprintf_breakpoint_ops
,
10222 do_cleanups (cleanup
);
10226 agent_printf_command (char *arg
, int from_tty
)
10228 error (_("May only run agent-printf on the target"));
10231 /* Implement the "breakpoint_hit" breakpoint_ops method for
10232 ranged breakpoints. */
10235 breakpoint_hit_ranged_breakpoint (const struct bp_location
*bl
,
10236 struct address_space
*aspace
,
10238 const struct target_waitstatus
*ws
)
10240 if (ws
->kind
!= TARGET_WAITKIND_STOPPED
10241 || ws
->value
.sig
!= GDB_SIGNAL_TRAP
)
10244 return breakpoint_address_match_range (bl
->pspace
->aspace
, bl
->address
,
10245 bl
->length
, aspace
, bp_addr
);
10248 /* Implement the "resources_needed" breakpoint_ops method for
10249 ranged breakpoints. */
10252 resources_needed_ranged_breakpoint (const struct bp_location
*bl
)
10254 return target_ranged_break_num_registers ();
10257 /* Implement the "print_it" breakpoint_ops method for
10258 ranged breakpoints. */
10260 static enum print_stop_action
10261 print_it_ranged_breakpoint (bpstat bs
)
10263 struct breakpoint
*b
= bs
->breakpoint_at
;
10264 struct bp_location
*bl
= b
->loc
;
10265 struct ui_out
*uiout
= current_uiout
;
10267 gdb_assert (b
->type
== bp_hardware_breakpoint
);
10269 /* Ranged breakpoints have only one location. */
10270 gdb_assert (bl
&& bl
->next
== NULL
);
10272 annotate_breakpoint (b
->number
);
10274 maybe_print_thread_hit_breakpoint (uiout
);
10276 if (b
->disposition
== disp_del
)
10277 ui_out_text (uiout
, "Temporary ranged breakpoint ");
10279 ui_out_text (uiout
, "Ranged breakpoint ");
10280 if (ui_out_is_mi_like_p (uiout
))
10282 ui_out_field_string (uiout
, "reason",
10283 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
10284 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
10286 ui_out_field_int (uiout
, "bkptno", b
->number
);
10287 ui_out_text (uiout
, ", ");
10289 return PRINT_SRC_AND_LOC
;
10292 /* Implement the "print_one" breakpoint_ops method for
10293 ranged breakpoints. */
10296 print_one_ranged_breakpoint (struct breakpoint
*b
,
10297 struct bp_location
**last_loc
)
10299 struct bp_location
*bl
= b
->loc
;
10300 struct value_print_options opts
;
10301 struct ui_out
*uiout
= current_uiout
;
10303 /* Ranged breakpoints have only one location. */
10304 gdb_assert (bl
&& bl
->next
== NULL
);
10306 get_user_print_options (&opts
);
10308 if (opts
.addressprint
)
10309 /* We don't print the address range here, it will be printed later
10310 by print_one_detail_ranged_breakpoint. */
10311 ui_out_field_skip (uiout
, "addr");
10312 annotate_field (5);
10313 print_breakpoint_location (b
, bl
);
10317 /* Implement the "print_one_detail" breakpoint_ops method for
10318 ranged breakpoints. */
10321 print_one_detail_ranged_breakpoint (const struct breakpoint
*b
,
10322 struct ui_out
*uiout
)
10324 CORE_ADDR address_start
, address_end
;
10325 struct bp_location
*bl
= b
->loc
;
10326 struct ui_file
*stb
= mem_fileopen ();
10327 struct cleanup
*cleanup
= make_cleanup_ui_file_delete (stb
);
10331 address_start
= bl
->address
;
10332 address_end
= address_start
+ bl
->length
- 1;
10334 ui_out_text (uiout
, "\taddress range: ");
10335 fprintf_unfiltered (stb
, "[%s, %s]",
10336 print_core_address (bl
->gdbarch
, address_start
),
10337 print_core_address (bl
->gdbarch
, address_end
));
10338 ui_out_field_stream (uiout
, "addr", stb
);
10339 ui_out_text (uiout
, "\n");
10341 do_cleanups (cleanup
);
10344 /* Implement the "print_mention" breakpoint_ops method for
10345 ranged breakpoints. */
10348 print_mention_ranged_breakpoint (struct breakpoint
*b
)
10350 struct bp_location
*bl
= b
->loc
;
10351 struct ui_out
*uiout
= current_uiout
;
10354 gdb_assert (b
->type
== bp_hardware_breakpoint
);
10356 if (ui_out_is_mi_like_p (uiout
))
10359 printf_filtered (_("Hardware assisted ranged breakpoint %d from %s to %s."),
10360 b
->number
, paddress (bl
->gdbarch
, bl
->address
),
10361 paddress (bl
->gdbarch
, bl
->address
+ bl
->length
- 1));
10364 /* Implement the "print_recreate" breakpoint_ops method for
10365 ranged breakpoints. */
10368 print_recreate_ranged_breakpoint (struct breakpoint
*b
, struct ui_file
*fp
)
10370 fprintf_unfiltered (fp
, "break-range %s, %s",
10371 event_location_to_string (b
->location
),
10372 event_location_to_string (b
->location_range_end
));
10373 print_recreate_thread (b
, fp
);
10376 /* The breakpoint_ops structure to be used in ranged breakpoints. */
10378 static struct breakpoint_ops ranged_breakpoint_ops
;
10380 /* Find the address where the end of the breakpoint range should be
10381 placed, given the SAL of the end of the range. This is so that if
10382 the user provides a line number, the end of the range is set to the
10383 last instruction of the given line. */
10386 find_breakpoint_range_end (struct symtab_and_line sal
)
10390 /* If the user provided a PC value, use it. Otherwise,
10391 find the address of the end of the given location. */
10392 if (sal
.explicit_pc
)
10399 ret
= find_line_pc_range (sal
, &start
, &end
);
10401 error (_("Could not find location of the end of the range."));
10403 /* find_line_pc_range returns the start of the next line. */
10410 /* Implement the "break-range" CLI command. */
10413 break_range_command (char *arg
, int from_tty
)
10415 char *arg_start
, *addr_string_start
;
10416 struct linespec_result canonical_start
, canonical_end
;
10417 int bp_count
, can_use_bp
, length
;
10419 struct breakpoint
*b
;
10420 struct symtab_and_line sal_start
, sal_end
;
10421 struct cleanup
*cleanup_bkpt
;
10422 struct linespec_sals
*lsal_start
, *lsal_end
;
10423 struct event_location
*start_location
, *end_location
;
10425 /* We don't support software ranged breakpoints. */
10426 if (target_ranged_break_num_registers () < 0)
10427 error (_("This target does not support hardware ranged breakpoints."));
10429 bp_count
= hw_breakpoint_used_count ();
10430 bp_count
+= target_ranged_break_num_registers ();
10431 can_use_bp
= target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
10433 if (can_use_bp
< 0)
10434 error (_("Hardware breakpoints used exceeds limit."));
10436 arg
= skip_spaces (arg
);
10437 if (arg
== NULL
|| arg
[0] == '\0')
10438 error(_("No address range specified."));
10440 init_linespec_result (&canonical_start
);
10443 start_location
= string_to_event_location (&arg
, current_language
);
10444 cleanup_bkpt
= make_cleanup_delete_event_location (start_location
);
10445 parse_breakpoint_sals (start_location
, &canonical_start
);
10446 make_cleanup_destroy_linespec_result (&canonical_start
);
10449 error (_("Too few arguments."));
10450 else if (VEC_empty (linespec_sals
, canonical_start
.sals
))
10451 error (_("Could not find location of the beginning of the range."));
10453 lsal_start
= VEC_index (linespec_sals
, canonical_start
.sals
, 0);
10455 if (VEC_length (linespec_sals
, canonical_start
.sals
) > 1
10456 || lsal_start
->sals
.nelts
!= 1)
10457 error (_("Cannot create a ranged breakpoint with multiple locations."));
10459 sal_start
= lsal_start
->sals
.sals
[0];
10460 addr_string_start
= savestring (arg_start
, arg
- arg_start
);
10461 make_cleanup (xfree
, addr_string_start
);
10463 arg
++; /* Skip the comma. */
10464 arg
= skip_spaces (arg
);
10466 /* Parse the end location. */
10468 init_linespec_result (&canonical_end
);
10471 /* We call decode_line_full directly here instead of using
10472 parse_breakpoint_sals because we need to specify the start location's
10473 symtab and line as the default symtab and line for the end of the
10474 range. This makes it possible to have ranges like "foo.c:27, +14",
10475 where +14 means 14 lines from the start location. */
10476 end_location
= string_to_event_location (&arg
, current_language
);
10477 make_cleanup_delete_event_location (end_location
);
10478 decode_line_full (end_location
, DECODE_LINE_FUNFIRSTLINE
, NULL
,
10479 sal_start
.symtab
, sal_start
.line
,
10480 &canonical_end
, NULL
, NULL
);
10482 make_cleanup_destroy_linespec_result (&canonical_end
);
10484 if (VEC_empty (linespec_sals
, canonical_end
.sals
))
10485 error (_("Could not find location of the end of the range."));
10487 lsal_end
= VEC_index (linespec_sals
, canonical_end
.sals
, 0);
10488 if (VEC_length (linespec_sals
, canonical_end
.sals
) > 1
10489 || lsal_end
->sals
.nelts
!= 1)
10490 error (_("Cannot create a ranged breakpoint with multiple locations."));
10492 sal_end
= lsal_end
->sals
.sals
[0];
10494 end
= find_breakpoint_range_end (sal_end
);
10495 if (sal_start
.pc
> end
)
10496 error (_("Invalid address range, end precedes start."));
10498 length
= end
- sal_start
.pc
+ 1;
10500 /* Length overflowed. */
10501 error (_("Address range too large."));
10502 else if (length
== 1)
10504 /* This range is simple enough to be handled by
10505 the `hbreak' command. */
10506 hbreak_command (addr_string_start
, 1);
10508 do_cleanups (cleanup_bkpt
);
10513 /* Now set up the breakpoint. */
10514 b
= set_raw_breakpoint (get_current_arch (), sal_start
,
10515 bp_hardware_breakpoint
, &ranged_breakpoint_ops
);
10516 set_breakpoint_count (breakpoint_count
+ 1);
10517 b
->number
= breakpoint_count
;
10518 b
->disposition
= disp_donttouch
;
10519 b
->location
= copy_event_location (start_location
);
10520 b
->location_range_end
= copy_event_location (end_location
);
10521 b
->loc
->length
= length
;
10523 do_cleanups (cleanup_bkpt
);
10526 observer_notify_breakpoint_created (b
);
10527 update_global_location_list (UGLL_MAY_INSERT
);
10530 /* Return non-zero if EXP is verified as constant. Returned zero
10531 means EXP is variable. Also the constant detection may fail for
10532 some constant expressions and in such case still falsely return
10536 watchpoint_exp_is_const (const struct expression
*exp
)
10538 int i
= exp
->nelts
;
10544 /* We are only interested in the descriptor of each element. */
10545 operator_length (exp
, i
, &oplenp
, &argsp
);
10548 switch (exp
->elts
[i
].opcode
)
10558 case BINOP_LOGICAL_AND
:
10559 case BINOP_LOGICAL_OR
:
10560 case BINOP_BITWISE_AND
:
10561 case BINOP_BITWISE_IOR
:
10562 case BINOP_BITWISE_XOR
:
10564 case BINOP_NOTEQUAL
:
10591 case OP_OBJC_NSSTRING
:
10594 case UNOP_LOGICAL_NOT
:
10595 case UNOP_COMPLEMENT
:
10600 case UNOP_CAST_TYPE
:
10601 case UNOP_REINTERPRET_CAST
:
10602 case UNOP_DYNAMIC_CAST
:
10603 /* Unary, binary and ternary operators: We have to check
10604 their operands. If they are constant, then so is the
10605 result of that operation. For instance, if A and B are
10606 determined to be constants, then so is "A + B".
10608 UNOP_IND is one exception to the rule above, because the
10609 value of *ADDR is not necessarily a constant, even when
10614 /* Check whether the associated symbol is a constant.
10616 We use SYMBOL_CLASS rather than TYPE_CONST because it's
10617 possible that a buggy compiler could mark a variable as
10618 constant even when it is not, and TYPE_CONST would return
10619 true in this case, while SYMBOL_CLASS wouldn't.
10621 We also have to check for function symbols because they
10622 are always constant. */
10624 struct symbol
*s
= exp
->elts
[i
+ 2].symbol
;
10626 if (SYMBOL_CLASS (s
) != LOC_BLOCK
10627 && SYMBOL_CLASS (s
) != LOC_CONST
10628 && SYMBOL_CLASS (s
) != LOC_CONST_BYTES
)
10633 /* The default action is to return 0 because we are using
10634 the optimistic approach here: If we don't know something,
10635 then it is not a constant. */
10644 /* Implement the "dtor" breakpoint_ops method for watchpoints. */
10647 dtor_watchpoint (struct breakpoint
*self
)
10649 struct watchpoint
*w
= (struct watchpoint
*) self
;
10651 xfree (w
->cond_exp
);
10653 xfree (w
->exp_string
);
10654 xfree (w
->exp_string_reparse
);
10655 value_free (w
->val
);
10657 base_breakpoint_ops
.dtor (self
);
10660 /* Implement the "re_set" breakpoint_ops method for watchpoints. */
10663 re_set_watchpoint (struct breakpoint
*b
)
10665 struct watchpoint
*w
= (struct watchpoint
*) b
;
10667 /* Watchpoint can be either on expression using entirely global
10668 variables, or it can be on local variables.
10670 Watchpoints of the first kind are never auto-deleted, and even
10671 persist across program restarts. Since they can use variables
10672 from shared libraries, we need to reparse expression as libraries
10673 are loaded and unloaded.
10675 Watchpoints on local variables can also change meaning as result
10676 of solib event. For example, if a watchpoint uses both a local
10677 and a global variables in expression, it's a local watchpoint,
10678 but unloading of a shared library will make the expression
10679 invalid. This is not a very common use case, but we still
10680 re-evaluate expression, to avoid surprises to the user.
10682 Note that for local watchpoints, we re-evaluate it only if
10683 watchpoints frame id is still valid. If it's not, it means the
10684 watchpoint is out of scope and will be deleted soon. In fact,
10685 I'm not sure we'll ever be called in this case.
10687 If a local watchpoint's frame id is still valid, then
10688 w->exp_valid_block is likewise valid, and we can safely use it.
10690 Don't do anything about disabled watchpoints, since they will be
10691 reevaluated again when enabled. */
10692 update_watchpoint (w
, 1 /* reparse */);
10695 /* Implement the "insert" breakpoint_ops method for hardware watchpoints. */
10698 insert_watchpoint (struct bp_location
*bl
)
10700 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10701 int length
= w
->exact
? 1 : bl
->length
;
10703 return target_insert_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
10707 /* Implement the "remove" breakpoint_ops method for hardware watchpoints. */
10710 remove_watchpoint (struct bp_location
*bl
)
10712 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10713 int length
= w
->exact
? 1 : bl
->length
;
10715 return target_remove_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
10720 breakpoint_hit_watchpoint (const struct bp_location
*bl
,
10721 struct address_space
*aspace
, CORE_ADDR bp_addr
,
10722 const struct target_waitstatus
*ws
)
10724 struct breakpoint
*b
= bl
->owner
;
10725 struct watchpoint
*w
= (struct watchpoint
*) b
;
10727 /* Continuable hardware watchpoints are treated as non-existent if the
10728 reason we stopped wasn't a hardware watchpoint (we didn't stop on
10729 some data address). Otherwise gdb won't stop on a break instruction
10730 in the code (not from a breakpoint) when a hardware watchpoint has
10731 been defined. Also skip watchpoints which we know did not trigger
10732 (did not match the data address). */
10733 if (is_hardware_watchpoint (b
)
10734 && w
->watchpoint_triggered
== watch_triggered_no
)
10741 check_status_watchpoint (bpstat bs
)
10743 gdb_assert (is_watchpoint (bs
->breakpoint_at
));
10745 bpstat_check_watchpoint (bs
);
10748 /* Implement the "resources_needed" breakpoint_ops method for
10749 hardware watchpoints. */
10752 resources_needed_watchpoint (const struct bp_location
*bl
)
10754 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10755 int length
= w
->exact
? 1 : bl
->length
;
10757 return target_region_ok_for_hw_watchpoint (bl
->address
, length
);
10760 /* Implement the "works_in_software_mode" breakpoint_ops method for
10761 hardware watchpoints. */
10764 works_in_software_mode_watchpoint (const struct breakpoint
*b
)
10766 /* Read and access watchpoints only work with hardware support. */
10767 return b
->type
== bp_watchpoint
|| b
->type
== bp_hardware_watchpoint
;
10770 static enum print_stop_action
10771 print_it_watchpoint (bpstat bs
)
10773 struct cleanup
*old_chain
;
10774 struct breakpoint
*b
;
10775 struct ui_file
*stb
;
10776 enum print_stop_action result
;
10777 struct watchpoint
*w
;
10778 struct ui_out
*uiout
= current_uiout
;
10780 gdb_assert (bs
->bp_location_at
!= NULL
);
10782 b
= bs
->breakpoint_at
;
10783 w
= (struct watchpoint
*) b
;
10785 stb
= mem_fileopen ();
10786 old_chain
= make_cleanup_ui_file_delete (stb
);
10788 annotate_watchpoint (b
->number
);
10789 maybe_print_thread_hit_breakpoint (uiout
);
10793 case bp_watchpoint
:
10794 case bp_hardware_watchpoint
:
10795 if (ui_out_is_mi_like_p (uiout
))
10796 ui_out_field_string
10798 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
10800 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
10801 ui_out_text (uiout
, "\nOld value = ");
10802 watchpoint_value_print (bs
->old_val
, stb
);
10803 ui_out_field_stream (uiout
, "old", stb
);
10804 ui_out_text (uiout
, "\nNew value = ");
10805 watchpoint_value_print (w
->val
, stb
);
10806 ui_out_field_stream (uiout
, "new", stb
);
10807 ui_out_text (uiout
, "\n");
10808 /* More than one watchpoint may have been triggered. */
10809 result
= PRINT_UNKNOWN
;
10812 case bp_read_watchpoint
:
10813 if (ui_out_is_mi_like_p (uiout
))
10814 ui_out_field_string
10816 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
10818 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
10819 ui_out_text (uiout
, "\nValue = ");
10820 watchpoint_value_print (w
->val
, stb
);
10821 ui_out_field_stream (uiout
, "value", stb
);
10822 ui_out_text (uiout
, "\n");
10823 result
= PRINT_UNKNOWN
;
10826 case bp_access_watchpoint
:
10827 if (bs
->old_val
!= NULL
)
10829 if (ui_out_is_mi_like_p (uiout
))
10830 ui_out_field_string
10832 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
10834 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
10835 ui_out_text (uiout
, "\nOld value = ");
10836 watchpoint_value_print (bs
->old_val
, stb
);
10837 ui_out_field_stream (uiout
, "old", stb
);
10838 ui_out_text (uiout
, "\nNew value = ");
10843 if (ui_out_is_mi_like_p (uiout
))
10844 ui_out_field_string
10846 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
10847 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
10848 ui_out_text (uiout
, "\nValue = ");
10850 watchpoint_value_print (w
->val
, stb
);
10851 ui_out_field_stream (uiout
, "new", stb
);
10852 ui_out_text (uiout
, "\n");
10853 result
= PRINT_UNKNOWN
;
10856 result
= PRINT_UNKNOWN
;
10859 do_cleanups (old_chain
);
10863 /* Implement the "print_mention" breakpoint_ops method for hardware
10867 print_mention_watchpoint (struct breakpoint
*b
)
10869 struct cleanup
*ui_out_chain
;
10870 struct watchpoint
*w
= (struct watchpoint
*) b
;
10871 struct ui_out
*uiout
= current_uiout
;
10875 case bp_watchpoint
:
10876 ui_out_text (uiout
, "Watchpoint ");
10877 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
10879 case bp_hardware_watchpoint
:
10880 ui_out_text (uiout
, "Hardware watchpoint ");
10881 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
10883 case bp_read_watchpoint
:
10884 ui_out_text (uiout
, "Hardware read watchpoint ");
10885 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
10887 case bp_access_watchpoint
:
10888 ui_out_text (uiout
, "Hardware access (read/write) watchpoint ");
10889 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
10892 internal_error (__FILE__
, __LINE__
,
10893 _("Invalid hardware watchpoint type."));
10896 ui_out_field_int (uiout
, "number", b
->number
);
10897 ui_out_text (uiout
, ": ");
10898 ui_out_field_string (uiout
, "exp", w
->exp_string
);
10899 do_cleanups (ui_out_chain
);
10902 /* Implement the "print_recreate" breakpoint_ops method for
10906 print_recreate_watchpoint (struct breakpoint
*b
, struct ui_file
*fp
)
10908 struct watchpoint
*w
= (struct watchpoint
*) b
;
10912 case bp_watchpoint
:
10913 case bp_hardware_watchpoint
:
10914 fprintf_unfiltered (fp
, "watch");
10916 case bp_read_watchpoint
:
10917 fprintf_unfiltered (fp
, "rwatch");
10919 case bp_access_watchpoint
:
10920 fprintf_unfiltered (fp
, "awatch");
10923 internal_error (__FILE__
, __LINE__
,
10924 _("Invalid watchpoint type."));
10927 fprintf_unfiltered (fp
, " %s", w
->exp_string
);
10928 print_recreate_thread (b
, fp
);
10931 /* Implement the "explains_signal" breakpoint_ops method for
10935 explains_signal_watchpoint (struct breakpoint
*b
, enum gdb_signal sig
)
10937 /* A software watchpoint cannot cause a signal other than
10938 GDB_SIGNAL_TRAP. */
10939 if (b
->type
== bp_watchpoint
&& sig
!= GDB_SIGNAL_TRAP
)
10945 /* The breakpoint_ops structure to be used in hardware watchpoints. */
10947 static struct breakpoint_ops watchpoint_breakpoint_ops
;
10949 /* Implement the "insert" breakpoint_ops method for
10950 masked hardware watchpoints. */
10953 insert_masked_watchpoint (struct bp_location
*bl
)
10955 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10957 return target_insert_mask_watchpoint (bl
->address
, w
->hw_wp_mask
,
10958 bl
->watchpoint_type
);
10961 /* Implement the "remove" breakpoint_ops method for
10962 masked hardware watchpoints. */
10965 remove_masked_watchpoint (struct bp_location
*bl
)
10967 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10969 return target_remove_mask_watchpoint (bl
->address
, w
->hw_wp_mask
,
10970 bl
->watchpoint_type
);
10973 /* Implement the "resources_needed" breakpoint_ops method for
10974 masked hardware watchpoints. */
10977 resources_needed_masked_watchpoint (const struct bp_location
*bl
)
10979 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10981 return target_masked_watch_num_registers (bl
->address
, w
->hw_wp_mask
);
10984 /* Implement the "works_in_software_mode" breakpoint_ops method for
10985 masked hardware watchpoints. */
10988 works_in_software_mode_masked_watchpoint (const struct breakpoint
*b
)
10993 /* Implement the "print_it" breakpoint_ops method for
10994 masked hardware watchpoints. */
10996 static enum print_stop_action
10997 print_it_masked_watchpoint (bpstat bs
)
10999 struct breakpoint
*b
= bs
->breakpoint_at
;
11000 struct ui_out
*uiout
= current_uiout
;
11002 /* Masked watchpoints have only one location. */
11003 gdb_assert (b
->loc
&& b
->loc
->next
== NULL
);
11005 annotate_watchpoint (b
->number
);
11006 maybe_print_thread_hit_breakpoint (uiout
);
11010 case bp_hardware_watchpoint
:
11011 if (ui_out_is_mi_like_p (uiout
))
11012 ui_out_field_string
11014 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
11017 case bp_read_watchpoint
:
11018 if (ui_out_is_mi_like_p (uiout
))
11019 ui_out_field_string
11021 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
11024 case bp_access_watchpoint
:
11025 if (ui_out_is_mi_like_p (uiout
))
11026 ui_out_field_string
11028 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
11031 internal_error (__FILE__
, __LINE__
,
11032 _("Invalid hardware watchpoint type."));
11036 ui_out_text (uiout
, _("\n\
11037 Check the underlying instruction at PC for the memory\n\
11038 address and value which triggered this watchpoint.\n"));
11039 ui_out_text (uiout
, "\n");
11041 /* More than one watchpoint may have been triggered. */
11042 return PRINT_UNKNOWN
;
11045 /* Implement the "print_one_detail" breakpoint_ops method for
11046 masked hardware watchpoints. */
11049 print_one_detail_masked_watchpoint (const struct breakpoint
*b
,
11050 struct ui_out
*uiout
)
11052 struct watchpoint
*w
= (struct watchpoint
*) b
;
11054 /* Masked watchpoints have only one location. */
11055 gdb_assert (b
->loc
&& b
->loc
->next
== NULL
);
11057 ui_out_text (uiout
, "\tmask ");
11058 ui_out_field_core_addr (uiout
, "mask", b
->loc
->gdbarch
, w
->hw_wp_mask
);
11059 ui_out_text (uiout
, "\n");
11062 /* Implement the "print_mention" breakpoint_ops method for
11063 masked hardware watchpoints. */
11066 print_mention_masked_watchpoint (struct breakpoint
*b
)
11068 struct watchpoint
*w
= (struct watchpoint
*) b
;
11069 struct ui_out
*uiout
= current_uiout
;
11070 struct cleanup
*ui_out_chain
;
11074 case bp_hardware_watchpoint
:
11075 ui_out_text (uiout
, "Masked hardware watchpoint ");
11076 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
11078 case bp_read_watchpoint
:
11079 ui_out_text (uiout
, "Masked hardware read watchpoint ");
11080 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
11082 case bp_access_watchpoint
:
11083 ui_out_text (uiout
, "Masked hardware access (read/write) watchpoint ");
11084 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
11087 internal_error (__FILE__
, __LINE__
,
11088 _("Invalid hardware watchpoint type."));
11091 ui_out_field_int (uiout
, "number", b
->number
);
11092 ui_out_text (uiout
, ": ");
11093 ui_out_field_string (uiout
, "exp", w
->exp_string
);
11094 do_cleanups (ui_out_chain
);
11097 /* Implement the "print_recreate" breakpoint_ops method for
11098 masked hardware watchpoints. */
11101 print_recreate_masked_watchpoint (struct breakpoint
*b
, struct ui_file
*fp
)
11103 struct watchpoint
*w
= (struct watchpoint
*) b
;
11108 case bp_hardware_watchpoint
:
11109 fprintf_unfiltered (fp
, "watch");
11111 case bp_read_watchpoint
:
11112 fprintf_unfiltered (fp
, "rwatch");
11114 case bp_access_watchpoint
:
11115 fprintf_unfiltered (fp
, "awatch");
11118 internal_error (__FILE__
, __LINE__
,
11119 _("Invalid hardware watchpoint type."));
11122 sprintf_vma (tmp
, w
->hw_wp_mask
);
11123 fprintf_unfiltered (fp
, " %s mask 0x%s", w
->exp_string
, tmp
);
11124 print_recreate_thread (b
, fp
);
11127 /* The breakpoint_ops structure to be used in masked hardware watchpoints. */
11129 static struct breakpoint_ops masked_watchpoint_breakpoint_ops
;
11131 /* Tell whether the given watchpoint is a masked hardware watchpoint. */
11134 is_masked_watchpoint (const struct breakpoint
*b
)
11136 return b
->ops
== &masked_watchpoint_breakpoint_ops
;
11139 /* accessflag: hw_write: watch write,
11140 hw_read: watch read,
11141 hw_access: watch access (read or write) */
11143 watch_command_1 (const char *arg
, int accessflag
, int from_tty
,
11144 int just_location
, int internal
)
11146 struct breakpoint
*b
, *scope_breakpoint
= NULL
;
11147 struct expression
*exp
;
11148 const struct block
*exp_valid_block
= NULL
, *cond_exp_valid_block
= NULL
;
11149 struct value
*val
, *mark
, *result
;
11150 int saved_bitpos
= 0, saved_bitsize
= 0;
11151 struct frame_info
*frame
;
11152 const char *exp_start
= NULL
;
11153 const char *exp_end
= NULL
;
11154 const char *tok
, *end_tok
;
11156 const char *cond_start
= NULL
;
11157 const char *cond_end
= NULL
;
11158 enum bptype bp_type
;
11161 /* Flag to indicate whether we are going to use masks for
11162 the hardware watchpoint. */
11164 CORE_ADDR mask
= 0;
11165 struct watchpoint
*w
;
11167 struct cleanup
*back_to
;
11169 /* Make sure that we actually have parameters to parse. */
11170 if (arg
!= NULL
&& arg
[0] != '\0')
11172 const char *value_start
;
11174 exp_end
= arg
+ strlen (arg
);
11176 /* Look for "parameter value" pairs at the end
11177 of the arguments string. */
11178 for (tok
= exp_end
- 1; tok
> arg
; tok
--)
11180 /* Skip whitespace at the end of the argument list. */
11181 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
11184 /* Find the beginning of the last token.
11185 This is the value of the parameter. */
11186 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
11188 value_start
= tok
+ 1;
11190 /* Skip whitespace. */
11191 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
11196 /* Find the beginning of the second to last token.
11197 This is the parameter itself. */
11198 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
11201 toklen
= end_tok
- tok
+ 1;
11203 if (toklen
== 6 && startswith (tok
, "thread"))
11205 struct thread_info
*thr
;
11206 /* At this point we've found a "thread" token, which means
11207 the user is trying to set a watchpoint that triggers
11208 only in a specific thread. */
11212 error(_("You can specify only one thread."));
11214 /* Extract the thread ID from the next token. */
11215 thr
= parse_thread_id (value_start
, &endp
);
11217 /* Check if the user provided a valid thread ID. */
11218 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
11219 invalid_thread_id_error (value_start
);
11221 thread
= thr
->global_num
;
11223 else if (toklen
== 4 && startswith (tok
, "mask"))
11225 /* We've found a "mask" token, which means the user wants to
11226 create a hardware watchpoint that is going to have the mask
11228 struct value
*mask_value
, *mark
;
11231 error(_("You can specify only one mask."));
11233 use_mask
= just_location
= 1;
11235 mark
= value_mark ();
11236 mask_value
= parse_to_comma_and_eval (&value_start
);
11237 mask
= value_as_address (mask_value
);
11238 value_free_to_mark (mark
);
11241 /* We didn't recognize what we found. We should stop here. */
11244 /* Truncate the string and get rid of the "parameter value" pair before
11245 the arguments string is parsed by the parse_exp_1 function. */
11252 /* Parse the rest of the arguments. From here on out, everything
11253 is in terms of a newly allocated string instead of the original
11255 innermost_block
= NULL
;
11256 expression
= savestring (arg
, exp_end
- arg
);
11257 back_to
= make_cleanup (xfree
, expression
);
11258 exp_start
= arg
= expression
;
11259 exp
= parse_exp_1 (&arg
, 0, 0, 0);
11261 /* Remove trailing whitespace from the expression before saving it.
11262 This makes the eventual display of the expression string a bit
11264 while (exp_end
> exp_start
&& (exp_end
[-1] == ' ' || exp_end
[-1] == '\t'))
11267 /* Checking if the expression is not constant. */
11268 if (watchpoint_exp_is_const (exp
))
11272 len
= exp_end
- exp_start
;
11273 while (len
> 0 && isspace (exp_start
[len
- 1]))
11275 error (_("Cannot watch constant value `%.*s'."), len
, exp_start
);
11278 exp_valid_block
= innermost_block
;
11279 mark
= value_mark ();
11280 fetch_subexp_value (exp
, &pc
, &val
, &result
, NULL
, just_location
);
11282 if (val
!= NULL
&& just_location
)
11284 saved_bitpos
= value_bitpos (val
);
11285 saved_bitsize
= value_bitsize (val
);
11292 exp_valid_block
= NULL
;
11293 val
= value_addr (result
);
11294 release_value (val
);
11295 value_free_to_mark (mark
);
11299 ret
= target_masked_watch_num_registers (value_as_address (val
),
11302 error (_("This target does not support masked watchpoints."));
11303 else if (ret
== -2)
11304 error (_("Invalid mask or memory region."));
11307 else if (val
!= NULL
)
11308 release_value (val
);
11310 tok
= skip_spaces_const (arg
);
11311 end_tok
= skip_to_space_const (tok
);
11313 toklen
= end_tok
- tok
;
11314 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
11316 struct expression
*cond
;
11318 innermost_block
= NULL
;
11319 tok
= cond_start
= end_tok
+ 1;
11320 cond
= parse_exp_1 (&tok
, 0, 0, 0);
11322 /* The watchpoint expression may not be local, but the condition
11323 may still be. E.g.: `watch global if local > 0'. */
11324 cond_exp_valid_block
= innermost_block
;
11330 error (_("Junk at end of command."));
11332 frame
= block_innermost_frame (exp_valid_block
);
11334 /* If the expression is "local", then set up a "watchpoint scope"
11335 breakpoint at the point where we've left the scope of the watchpoint
11336 expression. Create the scope breakpoint before the watchpoint, so
11337 that we will encounter it first in bpstat_stop_status. */
11338 if (exp_valid_block
&& frame
)
11340 if (frame_id_p (frame_unwind_caller_id (frame
)))
11343 = create_internal_breakpoint (frame_unwind_caller_arch (frame
),
11344 frame_unwind_caller_pc (frame
),
11345 bp_watchpoint_scope
,
11346 &momentary_breakpoint_ops
);
11348 scope_breakpoint
->enable_state
= bp_enabled
;
11350 /* Automatically delete the breakpoint when it hits. */
11351 scope_breakpoint
->disposition
= disp_del
;
11353 /* Only break in the proper frame (help with recursion). */
11354 scope_breakpoint
->frame_id
= frame_unwind_caller_id (frame
);
11356 /* Set the address at which we will stop. */
11357 scope_breakpoint
->loc
->gdbarch
11358 = frame_unwind_caller_arch (frame
);
11359 scope_breakpoint
->loc
->requested_address
11360 = frame_unwind_caller_pc (frame
);
11361 scope_breakpoint
->loc
->address
11362 = adjust_breakpoint_address (scope_breakpoint
->loc
->gdbarch
,
11363 scope_breakpoint
->loc
->requested_address
,
11364 scope_breakpoint
->type
);
11368 /* Now set up the breakpoint. We create all watchpoints as hardware
11369 watchpoints here even if hardware watchpoints are turned off, a call
11370 to update_watchpoint later in this function will cause the type to
11371 drop back to bp_watchpoint (software watchpoint) if required. */
11373 if (accessflag
== hw_read
)
11374 bp_type
= bp_read_watchpoint
;
11375 else if (accessflag
== hw_access
)
11376 bp_type
= bp_access_watchpoint
;
11378 bp_type
= bp_hardware_watchpoint
;
11380 w
= XCNEW (struct watchpoint
);
11383 init_raw_breakpoint_without_location (b
, NULL
, bp_type
,
11384 &masked_watchpoint_breakpoint_ops
);
11386 init_raw_breakpoint_without_location (b
, NULL
, bp_type
,
11387 &watchpoint_breakpoint_ops
);
11388 b
->thread
= thread
;
11389 b
->disposition
= disp_donttouch
;
11390 b
->pspace
= current_program_space
;
11392 w
->exp_valid_block
= exp_valid_block
;
11393 w
->cond_exp_valid_block
= cond_exp_valid_block
;
11396 struct type
*t
= value_type (val
);
11397 CORE_ADDR addr
= value_as_address (val
);
11400 t
= check_typedef (TYPE_TARGET_TYPE (check_typedef (t
)));
11401 name
= type_to_string (t
);
11403 w
->exp_string_reparse
= xstrprintf ("* (%s *) %s", name
,
11404 core_addr_to_string (addr
));
11407 w
->exp_string
= xstrprintf ("-location %.*s",
11408 (int) (exp_end
- exp_start
), exp_start
);
11410 /* The above expression is in C. */
11411 b
->language
= language_c
;
11414 w
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
11418 w
->hw_wp_mask
= mask
;
11423 w
->val_bitpos
= saved_bitpos
;
11424 w
->val_bitsize
= saved_bitsize
;
11429 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
11431 b
->cond_string
= 0;
11435 w
->watchpoint_frame
= get_frame_id (frame
);
11436 w
->watchpoint_thread
= inferior_ptid
;
11440 w
->watchpoint_frame
= null_frame_id
;
11441 w
->watchpoint_thread
= null_ptid
;
11444 if (scope_breakpoint
!= NULL
)
11446 /* The scope breakpoint is related to the watchpoint. We will
11447 need to act on them together. */
11448 b
->related_breakpoint
= scope_breakpoint
;
11449 scope_breakpoint
->related_breakpoint
= b
;
11452 if (!just_location
)
11453 value_free_to_mark (mark
);
11457 /* Finally update the new watchpoint. This creates the locations
11458 that should be inserted. */
11459 update_watchpoint (w
, 1);
11461 CATCH (e
, RETURN_MASK_ALL
)
11463 delete_breakpoint (b
);
11464 throw_exception (e
);
11468 install_breakpoint (internal
, b
, 1);
11469 do_cleanups (back_to
);
11472 /* Return count of debug registers needed to watch the given expression.
11473 If the watchpoint cannot be handled in hardware return zero. */
11476 can_use_hardware_watchpoint (struct value
*v
)
11478 int found_memory_cnt
= 0;
11479 struct value
*head
= v
;
11481 /* Did the user specifically forbid us to use hardware watchpoints? */
11482 if (!can_use_hw_watchpoints
)
11485 /* Make sure that the value of the expression depends only upon
11486 memory contents, and values computed from them within GDB. If we
11487 find any register references or function calls, we can't use a
11488 hardware watchpoint.
11490 The idea here is that evaluating an expression generates a series
11491 of values, one holding the value of every subexpression. (The
11492 expression a*b+c has five subexpressions: a, b, a*b, c, and
11493 a*b+c.) GDB's values hold almost enough information to establish
11494 the criteria given above --- they identify memory lvalues,
11495 register lvalues, computed values, etcetera. So we can evaluate
11496 the expression, and then scan the chain of values that leaves
11497 behind to decide whether we can detect any possible change to the
11498 expression's final value using only hardware watchpoints.
11500 However, I don't think that the values returned by inferior
11501 function calls are special in any way. So this function may not
11502 notice that an expression involving an inferior function call
11503 can't be watched with hardware watchpoints. FIXME. */
11504 for (; v
; v
= value_next (v
))
11506 if (VALUE_LVAL (v
) == lval_memory
)
11508 if (v
!= head
&& value_lazy (v
))
11509 /* A lazy memory lvalue in the chain is one that GDB never
11510 needed to fetch; we either just used its address (e.g.,
11511 `a' in `a.b') or we never needed it at all (e.g., `a'
11512 in `a,b'). This doesn't apply to HEAD; if that is
11513 lazy then it was not readable, but watch it anyway. */
11517 /* Ahh, memory we actually used! Check if we can cover
11518 it with hardware watchpoints. */
11519 struct type
*vtype
= check_typedef (value_type (v
));
11521 /* We only watch structs and arrays if user asked for it
11522 explicitly, never if they just happen to appear in a
11523 middle of some value chain. */
11525 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
11526 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
11528 CORE_ADDR vaddr
= value_address (v
);
11532 len
= (target_exact_watchpoints
11533 && is_scalar_type_recursive (vtype
))?
11534 1 : TYPE_LENGTH (value_type (v
));
11536 num_regs
= target_region_ok_for_hw_watchpoint (vaddr
, len
);
11540 found_memory_cnt
+= num_regs
;
11544 else if (VALUE_LVAL (v
) != not_lval
11545 && deprecated_value_modifiable (v
) == 0)
11546 return 0; /* These are values from the history (e.g., $1). */
11547 else if (VALUE_LVAL (v
) == lval_register
)
11548 return 0; /* Cannot watch a register with a HW watchpoint. */
11551 /* The expression itself looks suitable for using a hardware
11552 watchpoint, but give the target machine a chance to reject it. */
11553 return found_memory_cnt
;
11557 watch_command_wrapper (char *arg
, int from_tty
, int internal
)
11559 watch_command_1 (arg
, hw_write
, from_tty
, 0, internal
);
11562 /* A helper function that looks for the "-location" argument and then
11563 calls watch_command_1. */
11566 watch_maybe_just_location (char *arg
, int accessflag
, int from_tty
)
11568 int just_location
= 0;
11571 && (check_for_argument (&arg
, "-location", sizeof ("-location") - 1)
11572 || check_for_argument (&arg
, "-l", sizeof ("-l") - 1)))
11574 arg
= skip_spaces (arg
);
11578 watch_command_1 (arg
, accessflag
, from_tty
, just_location
, 0);
11582 watch_command (char *arg
, int from_tty
)
11584 watch_maybe_just_location (arg
, hw_write
, from_tty
);
11588 rwatch_command_wrapper (char *arg
, int from_tty
, int internal
)
11590 watch_command_1 (arg
, hw_read
, from_tty
, 0, internal
);
11594 rwatch_command (char *arg
, int from_tty
)
11596 watch_maybe_just_location (arg
, hw_read
, from_tty
);
11600 awatch_command_wrapper (char *arg
, int from_tty
, int internal
)
11602 watch_command_1 (arg
, hw_access
, from_tty
, 0, internal
);
11606 awatch_command (char *arg
, int from_tty
)
11608 watch_maybe_just_location (arg
, hw_access
, from_tty
);
11612 /* Data for the FSM that manages the until(location)/advance commands
11613 in infcmd.c. Here because it uses the mechanisms of
11616 struct until_break_fsm
11618 /* The base class. */
11619 struct thread_fsm thread_fsm
;
11621 /* The thread that as current when the command was executed. */
11624 /* The breakpoint set at the destination location. */
11625 struct breakpoint
*location_breakpoint
;
11627 /* Breakpoint set at the return address in the caller frame. May be
11629 struct breakpoint
*caller_breakpoint
;
11632 static void until_break_fsm_clean_up (struct thread_fsm
*self
,
11633 struct thread_info
*thread
);
11634 static int until_break_fsm_should_stop (struct thread_fsm
*self
,
11635 struct thread_info
*thread
);
11636 static enum async_reply_reason
11637 until_break_fsm_async_reply_reason (struct thread_fsm
*self
);
11639 /* until_break_fsm's vtable. */
11641 static struct thread_fsm_ops until_break_fsm_ops
=
11644 until_break_fsm_clean_up
,
11645 until_break_fsm_should_stop
,
11646 NULL
, /* return_value */
11647 until_break_fsm_async_reply_reason
,
11650 /* Allocate a new until_break_command_fsm. */
11652 static struct until_break_fsm
*
11653 new_until_break_fsm (struct interp
*cmd_interp
, int thread
,
11654 struct breakpoint
*location_breakpoint
,
11655 struct breakpoint
*caller_breakpoint
)
11657 struct until_break_fsm
*sm
;
11659 sm
= XCNEW (struct until_break_fsm
);
11660 thread_fsm_ctor (&sm
->thread_fsm
, &until_break_fsm_ops
, cmd_interp
);
11662 sm
->thread
= thread
;
11663 sm
->location_breakpoint
= location_breakpoint
;
11664 sm
->caller_breakpoint
= caller_breakpoint
;
11669 /* Implementation of the 'should_stop' FSM method for the
11670 until(location)/advance commands. */
11673 until_break_fsm_should_stop (struct thread_fsm
*self
,
11674 struct thread_info
*tp
)
11676 struct until_break_fsm
*sm
= (struct until_break_fsm
*) self
;
11678 if (bpstat_find_breakpoint (tp
->control
.stop_bpstat
,
11679 sm
->location_breakpoint
) != NULL
11680 || (sm
->caller_breakpoint
!= NULL
11681 && bpstat_find_breakpoint (tp
->control
.stop_bpstat
,
11682 sm
->caller_breakpoint
) != NULL
))
11683 thread_fsm_set_finished (self
);
11688 /* Implementation of the 'clean_up' FSM method for the
11689 until(location)/advance commands. */
11692 until_break_fsm_clean_up (struct thread_fsm
*self
,
11693 struct thread_info
*thread
)
11695 struct until_break_fsm
*sm
= (struct until_break_fsm
*) self
;
11697 /* Clean up our temporary breakpoints. */
11698 if (sm
->location_breakpoint
!= NULL
)
11700 delete_breakpoint (sm
->location_breakpoint
);
11701 sm
->location_breakpoint
= NULL
;
11703 if (sm
->caller_breakpoint
!= NULL
)
11705 delete_breakpoint (sm
->caller_breakpoint
);
11706 sm
->caller_breakpoint
= NULL
;
11708 delete_longjmp_breakpoint (sm
->thread
);
11711 /* Implementation of the 'async_reply_reason' FSM method for the
11712 until(location)/advance commands. */
11714 static enum async_reply_reason
11715 until_break_fsm_async_reply_reason (struct thread_fsm
*self
)
11717 return EXEC_ASYNC_LOCATION_REACHED
;
11721 until_break_command (char *arg
, int from_tty
, int anywhere
)
11723 struct symtabs_and_lines sals
;
11724 struct symtab_and_line sal
;
11725 struct frame_info
*frame
;
11726 struct gdbarch
*frame_gdbarch
;
11727 struct frame_id stack_frame_id
;
11728 struct frame_id caller_frame_id
;
11729 struct breakpoint
*location_breakpoint
;
11730 struct breakpoint
*caller_breakpoint
= NULL
;
11731 struct cleanup
*old_chain
, *cleanup
;
11733 struct thread_info
*tp
;
11734 struct event_location
*location
;
11735 struct until_break_fsm
*sm
;
11737 clear_proceed_status (0);
11739 /* Set a breakpoint where the user wants it and at return from
11742 location
= string_to_event_location (&arg
, current_language
);
11743 cleanup
= make_cleanup_delete_event_location (location
);
11745 if (last_displayed_sal_is_valid ())
11746 sals
= decode_line_1 (location
, DECODE_LINE_FUNFIRSTLINE
, NULL
,
11747 get_last_displayed_symtab (),
11748 get_last_displayed_line ());
11750 sals
= decode_line_1 (location
, DECODE_LINE_FUNFIRSTLINE
,
11751 NULL
, (struct symtab
*) NULL
, 0);
11753 if (sals
.nelts
!= 1)
11754 error (_("Couldn't get information on specified line."));
11756 sal
= sals
.sals
[0];
11757 xfree (sals
.sals
); /* malloc'd, so freed. */
11760 error (_("Junk at end of arguments."));
11762 resolve_sal_pc (&sal
);
11764 tp
= inferior_thread ();
11765 thread
= tp
->global_num
;
11767 old_chain
= make_cleanup (null_cleanup
, NULL
);
11769 /* Note linespec handling above invalidates the frame chain.
11770 Installing a breakpoint also invalidates the frame chain (as it
11771 may need to switch threads), so do any frame handling before
11774 frame
= get_selected_frame (NULL
);
11775 frame_gdbarch
= get_frame_arch (frame
);
11776 stack_frame_id
= get_stack_frame_id (frame
);
11777 caller_frame_id
= frame_unwind_caller_id (frame
);
11779 /* Keep within the current frame, or in frames called by the current
11782 if (frame_id_p (caller_frame_id
))
11784 struct symtab_and_line sal2
;
11785 struct gdbarch
*caller_gdbarch
;
11787 sal2
= find_pc_line (frame_unwind_caller_pc (frame
), 0);
11788 sal2
.pc
= frame_unwind_caller_pc (frame
);
11789 caller_gdbarch
= frame_unwind_caller_arch (frame
);
11790 caller_breakpoint
= set_momentary_breakpoint (caller_gdbarch
,
11794 make_cleanup_delete_breakpoint (caller_breakpoint
);
11796 set_longjmp_breakpoint (tp
, caller_frame_id
);
11797 make_cleanup (delete_longjmp_breakpoint_cleanup
, &thread
);
11800 /* set_momentary_breakpoint could invalidate FRAME. */
11804 /* If the user told us to continue until a specified location,
11805 we don't specify a frame at which we need to stop. */
11806 location_breakpoint
= set_momentary_breakpoint (frame_gdbarch
, sal
,
11807 null_frame_id
, bp_until
);
11809 /* Otherwise, specify the selected frame, because we want to stop
11810 only at the very same frame. */
11811 location_breakpoint
= set_momentary_breakpoint (frame_gdbarch
, sal
,
11812 stack_frame_id
, bp_until
);
11813 make_cleanup_delete_breakpoint (location_breakpoint
);
11815 sm
= new_until_break_fsm (command_interp (), tp
->global_num
,
11816 location_breakpoint
, caller_breakpoint
);
11817 tp
->thread_fsm
= &sm
->thread_fsm
;
11819 discard_cleanups (old_chain
);
11821 proceed (-1, GDB_SIGNAL_DEFAULT
);
11823 do_cleanups (cleanup
);
11826 /* This function attempts to parse an optional "if <cond>" clause
11827 from the arg string. If one is not found, it returns NULL.
11829 Else, it returns a pointer to the condition string. (It does not
11830 attempt to evaluate the string against a particular block.) And,
11831 it updates arg to point to the first character following the parsed
11832 if clause in the arg string. */
11835 ep_parse_optional_if_clause (char **arg
)
11839 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
11842 /* Skip the "if" keyword. */
11845 /* Skip any extra leading whitespace, and record the start of the
11846 condition string. */
11847 *arg
= skip_spaces (*arg
);
11848 cond_string
= *arg
;
11850 /* Assume that the condition occupies the remainder of the arg
11852 (*arg
) += strlen (cond_string
);
11854 return cond_string
;
11857 /* Commands to deal with catching events, such as signals, exceptions,
11858 process start/exit, etc. */
11862 catch_fork_temporary
, catch_vfork_temporary
,
11863 catch_fork_permanent
, catch_vfork_permanent
11868 catch_fork_command_1 (char *arg
, int from_tty
,
11869 struct cmd_list_element
*command
)
11871 struct gdbarch
*gdbarch
= get_current_arch ();
11872 char *cond_string
= NULL
;
11873 catch_fork_kind fork_kind
;
11876 fork_kind
= (catch_fork_kind
) (uintptr_t) get_cmd_context (command
);
11877 tempflag
= (fork_kind
== catch_fork_temporary
11878 || fork_kind
== catch_vfork_temporary
);
11882 arg
= skip_spaces (arg
);
11884 /* The allowed syntax is:
11886 catch [v]fork if <cond>
11888 First, check if there's an if clause. */
11889 cond_string
= ep_parse_optional_if_clause (&arg
);
11891 if ((*arg
!= '\0') && !isspace (*arg
))
11892 error (_("Junk at end of arguments."));
11894 /* If this target supports it, create a fork or vfork catchpoint
11895 and enable reporting of such events. */
11898 case catch_fork_temporary
:
11899 case catch_fork_permanent
:
11900 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
11901 &catch_fork_breakpoint_ops
);
11903 case catch_vfork_temporary
:
11904 case catch_vfork_permanent
:
11905 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
11906 &catch_vfork_breakpoint_ops
);
11909 error (_("unsupported or unknown fork kind; cannot catch it"));
11915 catch_exec_command_1 (char *arg
, int from_tty
,
11916 struct cmd_list_element
*command
)
11918 struct exec_catchpoint
*c
;
11919 struct gdbarch
*gdbarch
= get_current_arch ();
11921 char *cond_string
= NULL
;
11923 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
11927 arg
= skip_spaces (arg
);
11929 /* The allowed syntax is:
11931 catch exec if <cond>
11933 First, check if there's an if clause. */
11934 cond_string
= ep_parse_optional_if_clause (&arg
);
11936 if ((*arg
!= '\0') && !isspace (*arg
))
11937 error (_("Junk at end of arguments."));
11939 c
= XNEW (struct exec_catchpoint
);
11940 init_catchpoint (&c
->base
, gdbarch
, tempflag
, cond_string
,
11941 &catch_exec_breakpoint_ops
);
11942 c
->exec_pathname
= NULL
;
11944 install_breakpoint (0, &c
->base
, 1);
11948 init_ada_exception_breakpoint (struct breakpoint
*b
,
11949 struct gdbarch
*gdbarch
,
11950 struct symtab_and_line sal
,
11952 const struct breakpoint_ops
*ops
,
11959 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
11961 loc_gdbarch
= gdbarch
;
11963 describe_other_breakpoints (loc_gdbarch
,
11964 sal
.pspace
, sal
.pc
, sal
.section
, -1);
11965 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
11966 version for exception catchpoints, because two catchpoints
11967 used for different exception names will use the same address.
11968 In this case, a "breakpoint ... also set at..." warning is
11969 unproductive. Besides, the warning phrasing is also a bit
11970 inappropriate, we should use the word catchpoint, and tell
11971 the user what type of catchpoint it is. The above is good
11972 enough for now, though. */
11975 init_raw_breakpoint (b
, gdbarch
, sal
, bp_breakpoint
, ops
);
11977 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
11978 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
11979 b
->location
= string_to_event_location (&addr_string
,
11980 language_def (language_ada
));
11981 b
->language
= language_ada
;
11985 catch_command (char *arg
, int from_tty
)
11987 error (_("Catch requires an event name."));
11992 tcatch_command (char *arg
, int from_tty
)
11994 error (_("Catch requires an event name."));
11997 /* A qsort comparison function that sorts breakpoints in order. */
12000 compare_breakpoints (const void *a
, const void *b
)
12002 const breakpoint_p
*ba
= (const breakpoint_p
*) a
;
12003 uintptr_t ua
= (uintptr_t) *ba
;
12004 const breakpoint_p
*bb
= (const breakpoint_p
*) b
;
12005 uintptr_t ub
= (uintptr_t) *bb
;
12007 if ((*ba
)->number
< (*bb
)->number
)
12009 else if ((*ba
)->number
> (*bb
)->number
)
12012 /* Now sort by address, in case we see, e..g, two breakpoints with
12016 return ua
> ub
? 1 : 0;
12019 /* Delete breakpoints by address or line. */
12022 clear_command (char *arg
, int from_tty
)
12024 struct breakpoint
*b
, *prev
;
12025 VEC(breakpoint_p
) *found
= 0;
12028 struct symtabs_and_lines sals
;
12029 struct symtab_and_line sal
;
12031 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
12035 sals
= decode_line_with_current_source (arg
,
12036 (DECODE_LINE_FUNFIRSTLINE
12037 | DECODE_LINE_LIST_MODE
));
12038 make_cleanup (xfree
, sals
.sals
);
12043 sals
.sals
= XNEW (struct symtab_and_line
);
12044 make_cleanup (xfree
, sals
.sals
);
12045 init_sal (&sal
); /* Initialize to zeroes. */
12047 /* Set sal's line, symtab, pc, and pspace to the values
12048 corresponding to the last call to print_frame_info. If the
12049 codepoint is not valid, this will set all the fields to 0. */
12050 get_last_displayed_sal (&sal
);
12051 if (sal
.symtab
== 0)
12052 error (_("No source file specified."));
12054 sals
.sals
[0] = sal
;
12060 /* We don't call resolve_sal_pc here. That's not as bad as it
12061 seems, because all existing breakpoints typically have both
12062 file/line and pc set. So, if clear is given file/line, we can
12063 match this to existing breakpoint without obtaining pc at all.
12065 We only support clearing given the address explicitly
12066 present in breakpoint table. Say, we've set breakpoint
12067 at file:line. There were several PC values for that file:line,
12068 due to optimization, all in one block.
12070 We've picked one PC value. If "clear" is issued with another
12071 PC corresponding to the same file:line, the breakpoint won't
12072 be cleared. We probably can still clear the breakpoint, but
12073 since the other PC value is never presented to user, user
12074 can only find it by guessing, and it does not seem important
12075 to support that. */
12077 /* For each line spec given, delete bps which correspond to it. Do
12078 it in two passes, solely to preserve the current behavior that
12079 from_tty is forced true if we delete more than one
12083 make_cleanup (VEC_cleanup (breakpoint_p
), &found
);
12084 for (i
= 0; i
< sals
.nelts
; i
++)
12086 const char *sal_fullname
;
12088 /* If exact pc given, clear bpts at that pc.
12089 If line given (pc == 0), clear all bpts on specified line.
12090 If defaulting, clear all bpts on default line
12093 defaulting sal.pc != 0 tests to do
12098 1 0 <can't happen> */
12100 sal
= sals
.sals
[i
];
12101 sal_fullname
= (sal
.symtab
== NULL
12102 ? NULL
: symtab_to_fullname (sal
.symtab
));
12104 /* Find all matching breakpoints and add them to 'found'. */
12105 ALL_BREAKPOINTS (b
)
12108 /* Are we going to delete b? */
12109 if (b
->type
!= bp_none
&& !is_watchpoint (b
))
12111 struct bp_location
*loc
= b
->loc
;
12112 for (; loc
; loc
= loc
->next
)
12114 /* If the user specified file:line, don't allow a PC
12115 match. This matches historical gdb behavior. */
12116 int pc_match
= (!sal
.explicit_line
12118 && (loc
->pspace
== sal
.pspace
)
12119 && (loc
->address
== sal
.pc
)
12120 && (!section_is_overlay (loc
->section
)
12121 || loc
->section
== sal
.section
));
12122 int line_match
= 0;
12124 if ((default_match
|| sal
.explicit_line
)
12125 && loc
->symtab
!= NULL
12126 && sal_fullname
!= NULL
12127 && sal
.pspace
== loc
->pspace
12128 && loc
->line_number
== sal
.line
12129 && filename_cmp (symtab_to_fullname (loc
->symtab
),
12130 sal_fullname
) == 0)
12133 if (pc_match
|| line_match
)
12142 VEC_safe_push(breakpoint_p
, found
, b
);
12146 /* Now go thru the 'found' chain and delete them. */
12147 if (VEC_empty(breakpoint_p
, found
))
12150 error (_("No breakpoint at %s."), arg
);
12152 error (_("No breakpoint at this line."));
12155 /* Remove duplicates from the vec. */
12156 qsort (VEC_address (breakpoint_p
, found
),
12157 VEC_length (breakpoint_p
, found
),
12158 sizeof (breakpoint_p
),
12159 compare_breakpoints
);
12160 prev
= VEC_index (breakpoint_p
, found
, 0);
12161 for (ix
= 1; VEC_iterate (breakpoint_p
, found
, ix
, b
); ++ix
)
12165 VEC_ordered_remove (breakpoint_p
, found
, ix
);
12170 if (VEC_length(breakpoint_p
, found
) > 1)
12171 from_tty
= 1; /* Always report if deleted more than one. */
12174 if (VEC_length(breakpoint_p
, found
) == 1)
12175 printf_unfiltered (_("Deleted breakpoint "));
12177 printf_unfiltered (_("Deleted breakpoints "));
12180 for (ix
= 0; VEC_iterate(breakpoint_p
, found
, ix
, b
); ix
++)
12183 printf_unfiltered ("%d ", b
->number
);
12184 delete_breakpoint (b
);
12187 putchar_unfiltered ('\n');
12189 do_cleanups (cleanups
);
12192 /* Delete breakpoint in BS if they are `delete' breakpoints and
12193 all breakpoints that are marked for deletion, whether hit or not.
12194 This is called after any breakpoint is hit, or after errors. */
12197 breakpoint_auto_delete (bpstat bs
)
12199 struct breakpoint
*b
, *b_tmp
;
12201 for (; bs
; bs
= bs
->next
)
12202 if (bs
->breakpoint_at
12203 && bs
->breakpoint_at
->disposition
== disp_del
12205 delete_breakpoint (bs
->breakpoint_at
);
12207 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
12209 if (b
->disposition
== disp_del_at_next_stop
)
12210 delete_breakpoint (b
);
12214 /* A comparison function for bp_location AP and BP being interfaced to
12215 qsort. Sort elements primarily by their ADDRESS (no matter what
12216 does breakpoint_address_is_meaningful say for its OWNER),
12217 secondarily by ordering first permanent elements and
12218 terciarily just ensuring the array is sorted stable way despite
12219 qsort being an unstable algorithm. */
12222 bp_location_compare (const void *ap
, const void *bp
)
12224 const struct bp_location
*a
= *(const struct bp_location
**) ap
;
12225 const struct bp_location
*b
= *(const struct bp_location
**) bp
;
12227 if (a
->address
!= b
->address
)
12228 return (a
->address
> b
->address
) - (a
->address
< b
->address
);
12230 /* Sort locations at the same address by their pspace number, keeping
12231 locations of the same inferior (in a multi-inferior environment)
12234 if (a
->pspace
->num
!= b
->pspace
->num
)
12235 return ((a
->pspace
->num
> b
->pspace
->num
)
12236 - (a
->pspace
->num
< b
->pspace
->num
));
12238 /* Sort permanent breakpoints first. */
12239 if (a
->permanent
!= b
->permanent
)
12240 return (a
->permanent
< b
->permanent
) - (a
->permanent
> b
->permanent
);
12242 /* Make the internal GDB representation stable across GDB runs
12243 where A and B memory inside GDB can differ. Breakpoint locations of
12244 the same type at the same address can be sorted in arbitrary order. */
12246 if (a
->owner
->number
!= b
->owner
->number
)
12247 return ((a
->owner
->number
> b
->owner
->number
)
12248 - (a
->owner
->number
< b
->owner
->number
));
12250 return (a
> b
) - (a
< b
);
12253 /* Set bp_location_placed_address_before_address_max and
12254 bp_location_shadow_len_after_address_max according to the current
12255 content of the bp_location array. */
12258 bp_location_target_extensions_update (void)
12260 struct bp_location
*bl
, **blp_tmp
;
12262 bp_location_placed_address_before_address_max
= 0;
12263 bp_location_shadow_len_after_address_max
= 0;
12265 ALL_BP_LOCATIONS (bl
, blp_tmp
)
12267 CORE_ADDR start
, end
, addr
;
12269 if (!bp_location_has_shadow (bl
))
12272 start
= bl
->target_info
.placed_address
;
12273 end
= start
+ bl
->target_info
.shadow_len
;
12275 gdb_assert (bl
->address
>= start
);
12276 addr
= bl
->address
- start
;
12277 if (addr
> bp_location_placed_address_before_address_max
)
12278 bp_location_placed_address_before_address_max
= addr
;
12280 /* Zero SHADOW_LEN would not pass bp_location_has_shadow. */
12282 gdb_assert (bl
->address
< end
);
12283 addr
= end
- bl
->address
;
12284 if (addr
> bp_location_shadow_len_after_address_max
)
12285 bp_location_shadow_len_after_address_max
= addr
;
12289 /* Download tracepoint locations if they haven't been. */
12292 download_tracepoint_locations (void)
12294 struct breakpoint
*b
;
12295 struct cleanup
*old_chain
;
12296 enum tribool can_download_tracepoint
= TRIBOOL_UNKNOWN
;
12298 old_chain
= save_current_space_and_thread ();
12300 ALL_TRACEPOINTS (b
)
12302 struct bp_location
*bl
;
12303 struct tracepoint
*t
;
12304 int bp_location_downloaded
= 0;
12306 if ((b
->type
== bp_fast_tracepoint
12307 ? !may_insert_fast_tracepoints
12308 : !may_insert_tracepoints
))
12311 if (can_download_tracepoint
== TRIBOOL_UNKNOWN
)
12313 if (target_can_download_tracepoint ())
12314 can_download_tracepoint
= TRIBOOL_TRUE
;
12316 can_download_tracepoint
= TRIBOOL_FALSE
;
12319 if (can_download_tracepoint
== TRIBOOL_FALSE
)
12322 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
12324 /* In tracepoint, locations are _never_ duplicated, so
12325 should_be_inserted is equivalent to
12326 unduplicated_should_be_inserted. */
12327 if (!should_be_inserted (bl
) || bl
->inserted
)
12330 switch_to_program_space_and_thread (bl
->pspace
);
12332 target_download_tracepoint (bl
);
12335 bp_location_downloaded
= 1;
12337 t
= (struct tracepoint
*) b
;
12338 t
->number_on_target
= b
->number
;
12339 if (bp_location_downloaded
)
12340 observer_notify_breakpoint_modified (b
);
12343 do_cleanups (old_chain
);
12346 /* Swap the insertion/duplication state between two locations. */
12349 swap_insertion (struct bp_location
*left
, struct bp_location
*right
)
12351 const int left_inserted
= left
->inserted
;
12352 const int left_duplicate
= left
->duplicate
;
12353 const int left_needs_update
= left
->needs_update
;
12354 const struct bp_target_info left_target_info
= left
->target_info
;
12356 /* Locations of tracepoints can never be duplicated. */
12357 if (is_tracepoint (left
->owner
))
12358 gdb_assert (!left
->duplicate
);
12359 if (is_tracepoint (right
->owner
))
12360 gdb_assert (!right
->duplicate
);
12362 left
->inserted
= right
->inserted
;
12363 left
->duplicate
= right
->duplicate
;
12364 left
->needs_update
= right
->needs_update
;
12365 left
->target_info
= right
->target_info
;
12366 right
->inserted
= left_inserted
;
12367 right
->duplicate
= left_duplicate
;
12368 right
->needs_update
= left_needs_update
;
12369 right
->target_info
= left_target_info
;
12372 /* Force the re-insertion of the locations at ADDRESS. This is called
12373 once a new/deleted/modified duplicate location is found and we are evaluating
12374 conditions on the target's side. Such conditions need to be updated on
12378 force_breakpoint_reinsertion (struct bp_location
*bl
)
12380 struct bp_location
**locp
= NULL
, **loc2p
;
12381 struct bp_location
*loc
;
12382 CORE_ADDR address
= 0;
12385 address
= bl
->address
;
12386 pspace_num
= bl
->pspace
->num
;
12388 /* This is only meaningful if the target is
12389 evaluating conditions and if the user has
12390 opted for condition evaluation on the target's
12392 if (gdb_evaluates_breakpoint_condition_p ()
12393 || !target_supports_evaluation_of_breakpoint_conditions ())
12396 /* Flag all breakpoint locations with this address and
12397 the same program space as the location
12398 as "its condition has changed". We need to
12399 update the conditions on the target's side. */
12400 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, address
)
12404 if (!is_breakpoint (loc
->owner
)
12405 || pspace_num
!= loc
->pspace
->num
)
12408 /* Flag the location appropriately. We use a different state to
12409 let everyone know that we already updated the set of locations
12410 with addr bl->address and program space bl->pspace. This is so
12411 we don't have to keep calling these functions just to mark locations
12412 that have already been marked. */
12413 loc
->condition_changed
= condition_updated
;
12415 /* Free the agent expression bytecode as well. We will compute
12417 if (loc
->cond_bytecode
)
12419 free_agent_expr (loc
->cond_bytecode
);
12420 loc
->cond_bytecode
= NULL
;
12424 /* Called whether new breakpoints are created, or existing breakpoints
12425 deleted, to update the global location list and recompute which
12426 locations are duplicate of which.
12428 The INSERT_MODE flag determines whether locations may not, may, or
12429 shall be inserted now. See 'enum ugll_insert_mode' for more
12433 update_global_location_list (enum ugll_insert_mode insert_mode
)
12435 struct breakpoint
*b
;
12436 struct bp_location
**locp
, *loc
;
12437 struct cleanup
*cleanups
;
12438 /* Last breakpoint location address that was marked for update. */
12439 CORE_ADDR last_addr
= 0;
12440 /* Last breakpoint location program space that was marked for update. */
12441 int last_pspace_num
= -1;
12443 /* Used in the duplicates detection below. When iterating over all
12444 bp_locations, points to the first bp_location of a given address.
12445 Breakpoints and watchpoints of different types are never
12446 duplicates of each other. Keep one pointer for each type of
12447 breakpoint/watchpoint, so we only need to loop over all locations
12449 struct bp_location
*bp_loc_first
; /* breakpoint */
12450 struct bp_location
*wp_loc_first
; /* hardware watchpoint */
12451 struct bp_location
*awp_loc_first
; /* access watchpoint */
12452 struct bp_location
*rwp_loc_first
; /* read watchpoint */
12454 /* Saved former bp_location array which we compare against the newly
12455 built bp_location from the current state of ALL_BREAKPOINTS. */
12456 struct bp_location
**old_location
, **old_locp
;
12457 unsigned old_location_count
;
12459 old_location
= bp_location
;
12460 old_location_count
= bp_location_count
;
12461 bp_location
= NULL
;
12462 bp_location_count
= 0;
12463 cleanups
= make_cleanup (xfree
, old_location
);
12465 ALL_BREAKPOINTS (b
)
12466 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
12467 bp_location_count
++;
12469 bp_location
= XNEWVEC (struct bp_location
*, bp_location_count
);
12470 locp
= bp_location
;
12471 ALL_BREAKPOINTS (b
)
12472 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
12474 qsort (bp_location
, bp_location_count
, sizeof (*bp_location
),
12475 bp_location_compare
);
12477 bp_location_target_extensions_update ();
12479 /* Identify bp_location instances that are no longer present in the
12480 new list, and therefore should be freed. Note that it's not
12481 necessary that those locations should be removed from inferior --
12482 if there's another location at the same address (previously
12483 marked as duplicate), we don't need to remove/insert the
12486 LOCP is kept in sync with OLD_LOCP, each pointing to the current
12487 and former bp_location array state respectively. */
12489 locp
= bp_location
;
12490 for (old_locp
= old_location
; old_locp
< old_location
+ old_location_count
;
12493 struct bp_location
*old_loc
= *old_locp
;
12494 struct bp_location
**loc2p
;
12496 /* Tells if 'old_loc' is found among the new locations. If
12497 not, we have to free it. */
12498 int found_object
= 0;
12499 /* Tells if the location should remain inserted in the target. */
12500 int keep_in_target
= 0;
12503 /* Skip LOCP entries which will definitely never be needed.
12504 Stop either at or being the one matching OLD_LOC. */
12505 while (locp
< bp_location
+ bp_location_count
12506 && (*locp
)->address
< old_loc
->address
)
12510 (loc2p
< bp_location
+ bp_location_count
12511 && (*loc2p
)->address
== old_loc
->address
);
12514 /* Check if this is a new/duplicated location or a duplicated
12515 location that had its condition modified. If so, we want to send
12516 its condition to the target if evaluation of conditions is taking
12518 if ((*loc2p
)->condition_changed
== condition_modified
12519 && (last_addr
!= old_loc
->address
12520 || last_pspace_num
!= old_loc
->pspace
->num
))
12522 force_breakpoint_reinsertion (*loc2p
);
12523 last_pspace_num
= old_loc
->pspace
->num
;
12526 if (*loc2p
== old_loc
)
12530 /* We have already handled this address, update it so that we don't
12531 have to go through updates again. */
12532 last_addr
= old_loc
->address
;
12534 /* Target-side condition evaluation: Handle deleted locations. */
12536 force_breakpoint_reinsertion (old_loc
);
12538 /* If this location is no longer present, and inserted, look if
12539 there's maybe a new location at the same address. If so,
12540 mark that one inserted, and don't remove this one. This is
12541 needed so that we don't have a time window where a breakpoint
12542 at certain location is not inserted. */
12544 if (old_loc
->inserted
)
12546 /* If the location is inserted now, we might have to remove
12549 if (found_object
&& should_be_inserted (old_loc
))
12551 /* The location is still present in the location list,
12552 and still should be inserted. Don't do anything. */
12553 keep_in_target
= 1;
12557 /* This location still exists, but it won't be kept in the
12558 target since it may have been disabled. We proceed to
12559 remove its target-side condition. */
12561 /* The location is either no longer present, or got
12562 disabled. See if there's another location at the
12563 same address, in which case we don't need to remove
12564 this one from the target. */
12566 /* OLD_LOC comes from existing struct breakpoint. */
12567 if (breakpoint_address_is_meaningful (old_loc
->owner
))
12570 (loc2p
< bp_location
+ bp_location_count
12571 && (*loc2p
)->address
== old_loc
->address
);
12574 struct bp_location
*loc2
= *loc2p
;
12576 if (breakpoint_locations_match (loc2
, old_loc
))
12578 /* Read watchpoint locations are switched to
12579 access watchpoints, if the former are not
12580 supported, but the latter are. */
12581 if (is_hardware_watchpoint (old_loc
->owner
))
12583 gdb_assert (is_hardware_watchpoint (loc2
->owner
));
12584 loc2
->watchpoint_type
= old_loc
->watchpoint_type
;
12587 /* loc2 is a duplicated location. We need to check
12588 if it should be inserted in case it will be
12590 if (loc2
!= old_loc
12591 && unduplicated_should_be_inserted (loc2
))
12593 swap_insertion (old_loc
, loc2
);
12594 keep_in_target
= 1;
12602 if (!keep_in_target
)
12604 if (remove_breakpoint (old_loc
, mark_uninserted
))
12606 /* This is just about all we can do. We could keep
12607 this location on the global list, and try to
12608 remove it next time, but there's no particular
12609 reason why we will succeed next time.
12611 Note that at this point, old_loc->owner is still
12612 valid, as delete_breakpoint frees the breakpoint
12613 only after calling us. */
12614 printf_filtered (_("warning: Error removing "
12615 "breakpoint %d\n"),
12616 old_loc
->owner
->number
);
12624 if (removed
&& target_is_non_stop_p ()
12625 && need_moribund_for_location_type (old_loc
))
12627 /* This location was removed from the target. In
12628 non-stop mode, a race condition is possible where
12629 we've removed a breakpoint, but stop events for that
12630 breakpoint are already queued and will arrive later.
12631 We apply an heuristic to be able to distinguish such
12632 SIGTRAPs from other random SIGTRAPs: we keep this
12633 breakpoint location for a bit, and will retire it
12634 after we see some number of events. The theory here
12635 is that reporting of events should, "on the average",
12636 be fair, so after a while we'll see events from all
12637 threads that have anything of interest, and no longer
12638 need to keep this breakpoint location around. We
12639 don't hold locations forever so to reduce chances of
12640 mistaking a non-breakpoint SIGTRAP for a breakpoint
12643 The heuristic failing can be disastrous on
12644 decr_pc_after_break targets.
12646 On decr_pc_after_break targets, like e.g., x86-linux,
12647 if we fail to recognize a late breakpoint SIGTRAP,
12648 because events_till_retirement has reached 0 too
12649 soon, we'll fail to do the PC adjustment, and report
12650 a random SIGTRAP to the user. When the user resumes
12651 the inferior, it will most likely immediately crash
12652 with SIGILL/SIGBUS/SIGSEGV, or worse, get silently
12653 corrupted, because of being resumed e.g., in the
12654 middle of a multi-byte instruction, or skipped a
12655 one-byte instruction. This was actually seen happen
12656 on native x86-linux, and should be less rare on
12657 targets that do not support new thread events, like
12658 remote, due to the heuristic depending on
12661 Mistaking a random SIGTRAP for a breakpoint trap
12662 causes similar symptoms (PC adjustment applied when
12663 it shouldn't), but then again, playing with SIGTRAPs
12664 behind the debugger's back is asking for trouble.
12666 Since hardware watchpoint traps are always
12667 distinguishable from other traps, so we don't need to
12668 apply keep hardware watchpoint moribund locations
12669 around. We simply always ignore hardware watchpoint
12670 traps we can no longer explain. */
12672 old_loc
->events_till_retirement
= 3 * (thread_count () + 1);
12673 old_loc
->owner
= NULL
;
12675 VEC_safe_push (bp_location_p
, moribund_locations
, old_loc
);
12679 old_loc
->owner
= NULL
;
12680 decref_bp_location (&old_loc
);
12685 /* Rescan breakpoints at the same address and section, marking the
12686 first one as "first" and any others as "duplicates". This is so
12687 that the bpt instruction is only inserted once. If we have a
12688 permanent breakpoint at the same place as BPT, make that one the
12689 official one, and the rest as duplicates. Permanent breakpoints
12690 are sorted first for the same address.
12692 Do the same for hardware watchpoints, but also considering the
12693 watchpoint's type (regular/access/read) and length. */
12695 bp_loc_first
= NULL
;
12696 wp_loc_first
= NULL
;
12697 awp_loc_first
= NULL
;
12698 rwp_loc_first
= NULL
;
12699 ALL_BP_LOCATIONS (loc
, locp
)
12701 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always
12703 struct bp_location
**loc_first_p
;
12706 if (!unduplicated_should_be_inserted (loc
)
12707 || !breakpoint_address_is_meaningful (b
)
12708 /* Don't detect duplicate for tracepoint locations because they are
12709 never duplicated. See the comments in field `duplicate' of
12710 `struct bp_location'. */
12711 || is_tracepoint (b
))
12713 /* Clear the condition modification flag. */
12714 loc
->condition_changed
= condition_unchanged
;
12718 if (b
->type
== bp_hardware_watchpoint
)
12719 loc_first_p
= &wp_loc_first
;
12720 else if (b
->type
== bp_read_watchpoint
)
12721 loc_first_p
= &rwp_loc_first
;
12722 else if (b
->type
== bp_access_watchpoint
)
12723 loc_first_p
= &awp_loc_first
;
12725 loc_first_p
= &bp_loc_first
;
12727 if (*loc_first_p
== NULL
12728 || (overlay_debugging
&& loc
->section
!= (*loc_first_p
)->section
)
12729 || !breakpoint_locations_match (loc
, *loc_first_p
))
12731 *loc_first_p
= loc
;
12732 loc
->duplicate
= 0;
12734 if (is_breakpoint (loc
->owner
) && loc
->condition_changed
)
12736 loc
->needs_update
= 1;
12737 /* Clear the condition modification flag. */
12738 loc
->condition_changed
= condition_unchanged
;
12744 /* This and the above ensure the invariant that the first location
12745 is not duplicated, and is the inserted one.
12746 All following are marked as duplicated, and are not inserted. */
12748 swap_insertion (loc
, *loc_first_p
);
12749 loc
->duplicate
= 1;
12751 /* Clear the condition modification flag. */
12752 loc
->condition_changed
= condition_unchanged
;
12755 if (insert_mode
== UGLL_INSERT
|| breakpoints_should_be_inserted_now ())
12757 if (insert_mode
!= UGLL_DONT_INSERT
)
12758 insert_breakpoint_locations ();
12761 /* Even though the caller told us to not insert new
12762 locations, we may still need to update conditions on the
12763 target's side of breakpoints that were already inserted
12764 if the target is evaluating breakpoint conditions. We
12765 only update conditions for locations that are marked
12767 update_inserted_breakpoint_locations ();
12771 if (insert_mode
!= UGLL_DONT_INSERT
)
12772 download_tracepoint_locations ();
12774 do_cleanups (cleanups
);
12778 breakpoint_retire_moribund (void)
12780 struct bp_location
*loc
;
12783 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
12784 if (--(loc
->events_till_retirement
) == 0)
12786 decref_bp_location (&loc
);
12787 VEC_unordered_remove (bp_location_p
, moribund_locations
, ix
);
12793 update_global_location_list_nothrow (enum ugll_insert_mode insert_mode
)
12798 update_global_location_list (insert_mode
);
12800 CATCH (e
, RETURN_MASK_ERROR
)
12806 /* Clear BKP from a BPS. */
12809 bpstat_remove_bp_location (bpstat bps
, struct breakpoint
*bpt
)
12813 for (bs
= bps
; bs
; bs
= bs
->next
)
12814 if (bs
->breakpoint_at
== bpt
)
12816 bs
->breakpoint_at
= NULL
;
12817 bs
->old_val
= NULL
;
12818 /* bs->commands will be freed later. */
12822 /* Callback for iterate_over_threads. */
12824 bpstat_remove_breakpoint_callback (struct thread_info
*th
, void *data
)
12826 struct breakpoint
*bpt
= (struct breakpoint
*) data
;
12828 bpstat_remove_bp_location (th
->control
.stop_bpstat
, bpt
);
12832 /* Helper for breakpoint and tracepoint breakpoint_ops->mention
12836 say_where (struct breakpoint
*b
)
12838 struct value_print_options opts
;
12840 get_user_print_options (&opts
);
12842 /* i18n: cagney/2005-02-11: Below needs to be merged into a
12844 if (b
->loc
== NULL
)
12846 /* For pending locations, the output differs slightly based
12847 on b->extra_string. If this is non-NULL, it contains either
12848 a condition or dprintf arguments. */
12849 if (b
->extra_string
== NULL
)
12851 printf_filtered (_(" (%s) pending."),
12852 event_location_to_string (b
->location
));
12854 else if (b
->type
== bp_dprintf
)
12856 printf_filtered (_(" (%s,%s) pending."),
12857 event_location_to_string (b
->location
),
12862 printf_filtered (_(" (%s %s) pending."),
12863 event_location_to_string (b
->location
),
12869 if (opts
.addressprint
|| b
->loc
->symtab
== NULL
)
12871 printf_filtered (" at ");
12872 fputs_filtered (paddress (b
->loc
->gdbarch
, b
->loc
->address
),
12875 if (b
->loc
->symtab
!= NULL
)
12877 /* If there is a single location, we can print the location
12879 if (b
->loc
->next
== NULL
)
12880 printf_filtered (": file %s, line %d.",
12881 symtab_to_filename_for_display (b
->loc
->symtab
),
12882 b
->loc
->line_number
);
12884 /* This is not ideal, but each location may have a
12885 different file name, and this at least reflects the
12886 real situation somewhat. */
12887 printf_filtered (": %s.",
12888 event_location_to_string (b
->location
));
12893 struct bp_location
*loc
= b
->loc
;
12895 for (; loc
; loc
= loc
->next
)
12897 printf_filtered (" (%d locations)", n
);
12902 /* Default bp_location_ops methods. */
12905 bp_location_dtor (struct bp_location
*self
)
12907 xfree (self
->cond
);
12908 if (self
->cond_bytecode
)
12909 free_agent_expr (self
->cond_bytecode
);
12910 xfree (self
->function_name
);
12912 VEC_free (agent_expr_p
, self
->target_info
.conditions
);
12913 VEC_free (agent_expr_p
, self
->target_info
.tcommands
);
12916 static const struct bp_location_ops bp_location_ops
=
12921 /* Default breakpoint_ops methods all breakpoint_ops ultimately
12925 base_breakpoint_dtor (struct breakpoint
*self
)
12927 decref_counted_command_line (&self
->commands
);
12928 xfree (self
->cond_string
);
12929 xfree (self
->extra_string
);
12930 xfree (self
->filter
);
12931 delete_event_location (self
->location
);
12932 delete_event_location (self
->location_range_end
);
12935 static struct bp_location
*
12936 base_breakpoint_allocate_location (struct breakpoint
*self
)
12938 struct bp_location
*loc
;
12940 loc
= XNEW (struct bp_location
);
12941 init_bp_location (loc
, &bp_location_ops
, self
);
12946 base_breakpoint_re_set (struct breakpoint
*b
)
12948 /* Nothing to re-set. */
12951 #define internal_error_pure_virtual_called() \
12952 gdb_assert_not_reached ("pure virtual function called")
12955 base_breakpoint_insert_location (struct bp_location
*bl
)
12957 internal_error_pure_virtual_called ();
12961 base_breakpoint_remove_location (struct bp_location
*bl
)
12963 internal_error_pure_virtual_called ();
12967 base_breakpoint_breakpoint_hit (const struct bp_location
*bl
,
12968 struct address_space
*aspace
,
12970 const struct target_waitstatus
*ws
)
12972 internal_error_pure_virtual_called ();
12976 base_breakpoint_check_status (bpstat bs
)
12981 /* A "works_in_software_mode" breakpoint_ops method that just internal
12985 base_breakpoint_works_in_software_mode (const struct breakpoint
*b
)
12987 internal_error_pure_virtual_called ();
12990 /* A "resources_needed" breakpoint_ops method that just internal
12994 base_breakpoint_resources_needed (const struct bp_location
*bl
)
12996 internal_error_pure_virtual_called ();
12999 static enum print_stop_action
13000 base_breakpoint_print_it (bpstat bs
)
13002 internal_error_pure_virtual_called ();
13006 base_breakpoint_print_one_detail (const struct breakpoint
*self
,
13007 struct ui_out
*uiout
)
13013 base_breakpoint_print_mention (struct breakpoint
*b
)
13015 internal_error_pure_virtual_called ();
13019 base_breakpoint_print_recreate (struct breakpoint
*b
, struct ui_file
*fp
)
13021 internal_error_pure_virtual_called ();
13025 base_breakpoint_create_sals_from_location
13026 (const struct event_location
*location
,
13027 struct linespec_result
*canonical
,
13028 enum bptype type_wanted
)
13030 internal_error_pure_virtual_called ();
13034 base_breakpoint_create_breakpoints_sal (struct gdbarch
*gdbarch
,
13035 struct linespec_result
*c
,
13037 char *extra_string
,
13038 enum bptype type_wanted
,
13039 enum bpdisp disposition
,
13041 int task
, int ignore_count
,
13042 const struct breakpoint_ops
*o
,
13043 int from_tty
, int enabled
,
13044 int internal
, unsigned flags
)
13046 internal_error_pure_virtual_called ();
13050 base_breakpoint_decode_location (struct breakpoint
*b
,
13051 const struct event_location
*location
,
13052 struct program_space
*search_pspace
,
13053 struct symtabs_and_lines
*sals
)
13055 internal_error_pure_virtual_called ();
13058 /* The default 'explains_signal' method. */
13061 base_breakpoint_explains_signal (struct breakpoint
*b
, enum gdb_signal sig
)
13066 /* The default "after_condition_true" method. */
13069 base_breakpoint_after_condition_true (struct bpstats
*bs
)
13071 /* Nothing to do. */
13074 struct breakpoint_ops base_breakpoint_ops
=
13076 base_breakpoint_dtor
,
13077 base_breakpoint_allocate_location
,
13078 base_breakpoint_re_set
,
13079 base_breakpoint_insert_location
,
13080 base_breakpoint_remove_location
,
13081 base_breakpoint_breakpoint_hit
,
13082 base_breakpoint_check_status
,
13083 base_breakpoint_resources_needed
,
13084 base_breakpoint_works_in_software_mode
,
13085 base_breakpoint_print_it
,
13087 base_breakpoint_print_one_detail
,
13088 base_breakpoint_print_mention
,
13089 base_breakpoint_print_recreate
,
13090 base_breakpoint_create_sals_from_location
,
13091 base_breakpoint_create_breakpoints_sal
,
13092 base_breakpoint_decode_location
,
13093 base_breakpoint_explains_signal
,
13094 base_breakpoint_after_condition_true
,
13097 /* Default breakpoint_ops methods. */
13100 bkpt_re_set (struct breakpoint
*b
)
13102 /* FIXME: is this still reachable? */
13103 if (breakpoint_event_location_empty_p (b
))
13105 /* Anything without a location can't be re-set. */
13106 delete_breakpoint (b
);
13110 breakpoint_re_set_default (b
);
13114 bkpt_insert_location (struct bp_location
*bl
)
13116 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
13117 return target_insert_hw_breakpoint (bl
->gdbarch
, &bl
->target_info
);
13119 return target_insert_breakpoint (bl
->gdbarch
, &bl
->target_info
);
13123 bkpt_remove_location (struct bp_location
*bl
)
13125 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
13126 return target_remove_hw_breakpoint (bl
->gdbarch
, &bl
->target_info
);
13128 return target_remove_breakpoint (bl
->gdbarch
, &bl
->target_info
);
13132 bkpt_breakpoint_hit (const struct bp_location
*bl
,
13133 struct address_space
*aspace
, CORE_ADDR bp_addr
,
13134 const struct target_waitstatus
*ws
)
13136 if (ws
->kind
!= TARGET_WAITKIND_STOPPED
13137 || ws
->value
.sig
!= GDB_SIGNAL_TRAP
)
13140 if (!breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
13144 if (overlay_debugging
/* unmapped overlay section */
13145 && section_is_overlay (bl
->section
)
13146 && !section_is_mapped (bl
->section
))
13153 dprintf_breakpoint_hit (const struct bp_location
*bl
,
13154 struct address_space
*aspace
, CORE_ADDR bp_addr
,
13155 const struct target_waitstatus
*ws
)
13157 if (dprintf_style
== dprintf_style_agent
13158 && target_can_run_breakpoint_commands ())
13160 /* An agent-style dprintf never causes a stop. If we see a trap
13161 for this address it must be for a breakpoint that happens to
13162 be set at the same address. */
13166 return bkpt_breakpoint_hit (bl
, aspace
, bp_addr
, ws
);
13170 bkpt_resources_needed (const struct bp_location
*bl
)
13172 gdb_assert (bl
->owner
->type
== bp_hardware_breakpoint
);
13177 static enum print_stop_action
13178 bkpt_print_it (bpstat bs
)
13180 struct breakpoint
*b
;
13181 const struct bp_location
*bl
;
13183 struct ui_out
*uiout
= current_uiout
;
13185 gdb_assert (bs
->bp_location_at
!= NULL
);
13187 bl
= bs
->bp_location_at
;
13188 b
= bs
->breakpoint_at
;
13190 bp_temp
= b
->disposition
== disp_del
;
13191 if (bl
->address
!= bl
->requested_address
)
13192 breakpoint_adjustment_warning (bl
->requested_address
,
13195 annotate_breakpoint (b
->number
);
13196 maybe_print_thread_hit_breakpoint (uiout
);
13199 ui_out_text (uiout
, "Temporary breakpoint ");
13201 ui_out_text (uiout
, "Breakpoint ");
13202 if (ui_out_is_mi_like_p (uiout
))
13204 ui_out_field_string (uiout
, "reason",
13205 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
13206 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
13208 ui_out_field_int (uiout
, "bkptno", b
->number
);
13209 ui_out_text (uiout
, ", ");
13211 return PRINT_SRC_AND_LOC
;
13215 bkpt_print_mention (struct breakpoint
*b
)
13217 if (ui_out_is_mi_like_p (current_uiout
))
13222 case bp_breakpoint
:
13223 case bp_gnu_ifunc_resolver
:
13224 if (b
->disposition
== disp_del
)
13225 printf_filtered (_("Temporary breakpoint"));
13227 printf_filtered (_("Breakpoint"));
13228 printf_filtered (_(" %d"), b
->number
);
13229 if (b
->type
== bp_gnu_ifunc_resolver
)
13230 printf_filtered (_(" at gnu-indirect-function resolver"));
13232 case bp_hardware_breakpoint
:
13233 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
13236 printf_filtered (_("Dprintf %d"), b
->number
);
13244 bkpt_print_recreate (struct breakpoint
*tp
, struct ui_file
*fp
)
13246 if (tp
->type
== bp_breakpoint
&& tp
->disposition
== disp_del
)
13247 fprintf_unfiltered (fp
, "tbreak");
13248 else if (tp
->type
== bp_breakpoint
)
13249 fprintf_unfiltered (fp
, "break");
13250 else if (tp
->type
== bp_hardware_breakpoint
13251 && tp
->disposition
== disp_del
)
13252 fprintf_unfiltered (fp
, "thbreak");
13253 else if (tp
->type
== bp_hardware_breakpoint
)
13254 fprintf_unfiltered (fp
, "hbreak");
13256 internal_error (__FILE__
, __LINE__
,
13257 _("unhandled breakpoint type %d"), (int) tp
->type
);
13259 fprintf_unfiltered (fp
, " %s",
13260 event_location_to_string (tp
->location
));
13262 /* Print out extra_string if this breakpoint is pending. It might
13263 contain, for example, conditions that were set by the user. */
13264 if (tp
->loc
== NULL
&& tp
->extra_string
!= NULL
)
13265 fprintf_unfiltered (fp
, " %s", tp
->extra_string
);
13267 print_recreate_thread (tp
, fp
);
13271 bkpt_create_sals_from_location (const struct event_location
*location
,
13272 struct linespec_result
*canonical
,
13273 enum bptype type_wanted
)
13275 create_sals_from_location_default (location
, canonical
, type_wanted
);
13279 bkpt_create_breakpoints_sal (struct gdbarch
*gdbarch
,
13280 struct linespec_result
*canonical
,
13282 char *extra_string
,
13283 enum bptype type_wanted
,
13284 enum bpdisp disposition
,
13286 int task
, int ignore_count
,
13287 const struct breakpoint_ops
*ops
,
13288 int from_tty
, int enabled
,
13289 int internal
, unsigned flags
)
13291 create_breakpoints_sal_default (gdbarch
, canonical
,
13292 cond_string
, extra_string
,
13294 disposition
, thread
, task
,
13295 ignore_count
, ops
, from_tty
,
13296 enabled
, internal
, flags
);
13300 bkpt_decode_location (struct breakpoint
*b
,
13301 const struct event_location
*location
,
13302 struct program_space
*search_pspace
,
13303 struct symtabs_and_lines
*sals
)
13305 decode_location_default (b
, location
, search_pspace
, sals
);
13308 /* Virtual table for internal breakpoints. */
13311 internal_bkpt_re_set (struct breakpoint
*b
)
13315 /* Delete overlay event and longjmp master breakpoints; they
13316 will be reset later by breakpoint_re_set. */
13317 case bp_overlay_event
:
13318 case bp_longjmp_master
:
13319 case bp_std_terminate_master
:
13320 case bp_exception_master
:
13321 delete_breakpoint (b
);
13324 /* This breakpoint is special, it's set up when the inferior
13325 starts and we really don't want to touch it. */
13326 case bp_shlib_event
:
13328 /* Like bp_shlib_event, this breakpoint type is special. Once
13329 it is set up, we do not want to touch it. */
13330 case bp_thread_event
:
13336 internal_bkpt_check_status (bpstat bs
)
13338 if (bs
->breakpoint_at
->type
== bp_shlib_event
)
13340 /* If requested, stop when the dynamic linker notifies GDB of
13341 events. This allows the user to get control and place
13342 breakpoints in initializer routines for dynamically loaded
13343 objects (among other things). */
13344 bs
->stop
= stop_on_solib_events
;
13345 bs
->print
= stop_on_solib_events
;
13351 static enum print_stop_action
13352 internal_bkpt_print_it (bpstat bs
)
13354 struct breakpoint
*b
;
13356 b
= bs
->breakpoint_at
;
13360 case bp_shlib_event
:
13361 /* Did we stop because the user set the stop_on_solib_events
13362 variable? (If so, we report this as a generic, "Stopped due
13363 to shlib event" message.) */
13364 print_solib_event (0);
13367 case bp_thread_event
:
13368 /* Not sure how we will get here.
13369 GDB should not stop for these breakpoints. */
13370 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
13373 case bp_overlay_event
:
13374 /* By analogy with the thread event, GDB should not stop for these. */
13375 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
13378 case bp_longjmp_master
:
13379 /* These should never be enabled. */
13380 printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
13383 case bp_std_terminate_master
:
13384 /* These should never be enabled. */
13385 printf_filtered (_("std::terminate Master Breakpoint: "
13386 "gdb should not stop!\n"));
13389 case bp_exception_master
:
13390 /* These should never be enabled. */
13391 printf_filtered (_("Exception Master Breakpoint: "
13392 "gdb should not stop!\n"));
13396 return PRINT_NOTHING
;
13400 internal_bkpt_print_mention (struct breakpoint
*b
)
13402 /* Nothing to mention. These breakpoints are internal. */
13405 /* Virtual table for momentary breakpoints */
13408 momentary_bkpt_re_set (struct breakpoint
*b
)
13410 /* Keep temporary breakpoints, which can be encountered when we step
13411 over a dlopen call and solib_add is resetting the breakpoints.
13412 Otherwise these should have been blown away via the cleanup chain
13413 or by breakpoint_init_inferior when we rerun the executable. */
13417 momentary_bkpt_check_status (bpstat bs
)
13419 /* Nothing. The point of these breakpoints is causing a stop. */
13422 static enum print_stop_action
13423 momentary_bkpt_print_it (bpstat bs
)
13425 return PRINT_UNKNOWN
;
13429 momentary_bkpt_print_mention (struct breakpoint
*b
)
13431 /* Nothing to mention. These breakpoints are internal. */
13434 /* Ensure INITIATING_FRAME is cleared when no such breakpoint exists.
13436 It gets cleared already on the removal of the first one of such placed
13437 breakpoints. This is OK as they get all removed altogether. */
13440 longjmp_bkpt_dtor (struct breakpoint
*self
)
13442 struct thread_info
*tp
= find_thread_global_id (self
->thread
);
13445 tp
->initiating_frame
= null_frame_id
;
13447 momentary_breakpoint_ops
.dtor (self
);
13450 /* Specific methods for probe breakpoints. */
13453 bkpt_probe_insert_location (struct bp_location
*bl
)
13455 int v
= bkpt_insert_location (bl
);
13459 /* The insertion was successful, now let's set the probe's semaphore
13461 if (bl
->probe
.probe
->pops
->set_semaphore
!= NULL
)
13462 bl
->probe
.probe
->pops
->set_semaphore (bl
->probe
.probe
,
13471 bkpt_probe_remove_location (struct bp_location
*bl
)
13473 /* Let's clear the semaphore before removing the location. */
13474 if (bl
->probe
.probe
->pops
->clear_semaphore
!= NULL
)
13475 bl
->probe
.probe
->pops
->clear_semaphore (bl
->probe
.probe
,
13479 return bkpt_remove_location (bl
);
13483 bkpt_probe_create_sals_from_location (const struct event_location
*location
,
13484 struct linespec_result
*canonical
,
13485 enum bptype type_wanted
)
13487 struct linespec_sals lsal
;
13489 lsal
.sals
= parse_probes (location
, NULL
, canonical
);
13490 lsal
.canonical
= xstrdup (event_location_to_string (canonical
->location
));
13491 VEC_safe_push (linespec_sals
, canonical
->sals
, &lsal
);
13495 bkpt_probe_decode_location (struct breakpoint
*b
,
13496 const struct event_location
*location
,
13497 struct program_space
*search_pspace
,
13498 struct symtabs_and_lines
*sals
)
13500 *sals
= parse_probes (location
, search_pspace
, NULL
);
13502 error (_("probe not found"));
13505 /* The breakpoint_ops structure to be used in tracepoints. */
13508 tracepoint_re_set (struct breakpoint
*b
)
13510 breakpoint_re_set_default (b
);
13514 tracepoint_breakpoint_hit (const struct bp_location
*bl
,
13515 struct address_space
*aspace
, CORE_ADDR bp_addr
,
13516 const struct target_waitstatus
*ws
)
13518 /* By definition, the inferior does not report stops at
13524 tracepoint_print_one_detail (const struct breakpoint
*self
,
13525 struct ui_out
*uiout
)
13527 struct tracepoint
*tp
= (struct tracepoint
*) self
;
13528 if (tp
->static_trace_marker_id
)
13530 gdb_assert (self
->type
== bp_static_tracepoint
);
13532 ui_out_text (uiout
, "\tmarker id is ");
13533 ui_out_field_string (uiout
, "static-tracepoint-marker-string-id",
13534 tp
->static_trace_marker_id
);
13535 ui_out_text (uiout
, "\n");
13540 tracepoint_print_mention (struct breakpoint
*b
)
13542 if (ui_out_is_mi_like_p (current_uiout
))
13547 case bp_tracepoint
:
13548 printf_filtered (_("Tracepoint"));
13549 printf_filtered (_(" %d"), b
->number
);
13551 case bp_fast_tracepoint
:
13552 printf_filtered (_("Fast tracepoint"));
13553 printf_filtered (_(" %d"), b
->number
);
13555 case bp_static_tracepoint
:
13556 printf_filtered (_("Static tracepoint"));
13557 printf_filtered (_(" %d"), b
->number
);
13560 internal_error (__FILE__
, __LINE__
,
13561 _("unhandled tracepoint type %d"), (int) b
->type
);
13568 tracepoint_print_recreate (struct breakpoint
*self
, struct ui_file
*fp
)
13570 struct tracepoint
*tp
= (struct tracepoint
*) self
;
13572 if (self
->type
== bp_fast_tracepoint
)
13573 fprintf_unfiltered (fp
, "ftrace");
13574 else if (self
->type
== bp_static_tracepoint
)
13575 fprintf_unfiltered (fp
, "strace");
13576 else if (self
->type
== bp_tracepoint
)
13577 fprintf_unfiltered (fp
, "trace");
13579 internal_error (__FILE__
, __LINE__
,
13580 _("unhandled tracepoint type %d"), (int) self
->type
);
13582 fprintf_unfiltered (fp
, " %s",
13583 event_location_to_string (self
->location
));
13584 print_recreate_thread (self
, fp
);
13586 if (tp
->pass_count
)
13587 fprintf_unfiltered (fp
, " passcount %d\n", tp
->pass_count
);
13591 tracepoint_create_sals_from_location (const struct event_location
*location
,
13592 struct linespec_result
*canonical
,
13593 enum bptype type_wanted
)
13595 create_sals_from_location_default (location
, canonical
, type_wanted
);
13599 tracepoint_create_breakpoints_sal (struct gdbarch
*gdbarch
,
13600 struct linespec_result
*canonical
,
13602 char *extra_string
,
13603 enum bptype type_wanted
,
13604 enum bpdisp disposition
,
13606 int task
, int ignore_count
,
13607 const struct breakpoint_ops
*ops
,
13608 int from_tty
, int enabled
,
13609 int internal
, unsigned flags
)
13611 create_breakpoints_sal_default (gdbarch
, canonical
,
13612 cond_string
, extra_string
,
13614 disposition
, thread
, task
,
13615 ignore_count
, ops
, from_tty
,
13616 enabled
, internal
, flags
);
13620 tracepoint_decode_location (struct breakpoint
*b
,
13621 const struct event_location
*location
,
13622 struct program_space
*search_pspace
,
13623 struct symtabs_and_lines
*sals
)
13625 decode_location_default (b
, location
, search_pspace
, sals
);
13628 struct breakpoint_ops tracepoint_breakpoint_ops
;
13630 /* The breakpoint_ops structure to be use on tracepoints placed in a
13634 tracepoint_probe_create_sals_from_location
13635 (const struct event_location
*location
,
13636 struct linespec_result
*canonical
,
13637 enum bptype type_wanted
)
13639 /* We use the same method for breakpoint on probes. */
13640 bkpt_probe_create_sals_from_location (location
, canonical
, type_wanted
);
13644 tracepoint_probe_decode_location (struct breakpoint
*b
,
13645 const struct event_location
*location
,
13646 struct program_space
*search_pspace
,
13647 struct symtabs_and_lines
*sals
)
13649 /* We use the same method for breakpoint on probes. */
13650 bkpt_probe_decode_location (b
, location
, search_pspace
, sals
);
13653 static struct breakpoint_ops tracepoint_probe_breakpoint_ops
;
13655 /* Dprintf breakpoint_ops methods. */
13658 dprintf_re_set (struct breakpoint
*b
)
13660 breakpoint_re_set_default (b
);
13662 /* extra_string should never be non-NULL for dprintf. */
13663 gdb_assert (b
->extra_string
!= NULL
);
13665 /* 1 - connect to target 1, that can run breakpoint commands.
13666 2 - create a dprintf, which resolves fine.
13667 3 - disconnect from target 1
13668 4 - connect to target 2, that can NOT run breakpoint commands.
13670 After steps #3/#4, you'll want the dprintf command list to
13671 be updated, because target 1 and 2 may well return different
13672 answers for target_can_run_breakpoint_commands().
13673 Given absence of finer grained resetting, we get to do
13674 it all the time. */
13675 if (b
->extra_string
!= NULL
)
13676 update_dprintf_command_list (b
);
13679 /* Implement the "print_recreate" breakpoint_ops method for dprintf. */
13682 dprintf_print_recreate (struct breakpoint
*tp
, struct ui_file
*fp
)
13684 fprintf_unfiltered (fp
, "dprintf %s,%s",
13685 event_location_to_string (tp
->location
),
13687 print_recreate_thread (tp
, fp
);
13690 /* Implement the "after_condition_true" breakpoint_ops method for
13693 dprintf's are implemented with regular commands in their command
13694 list, but we run the commands here instead of before presenting the
13695 stop to the user, as dprintf's don't actually cause a stop. This
13696 also makes it so that the commands of multiple dprintfs at the same
13697 address are all handled. */
13700 dprintf_after_condition_true (struct bpstats
*bs
)
13702 struct cleanup
*old_chain
;
13703 struct bpstats tmp_bs
= { NULL
};
13704 struct bpstats
*tmp_bs_p
= &tmp_bs
;
13706 /* dprintf's never cause a stop. This wasn't set in the
13707 check_status hook instead because that would make the dprintf's
13708 condition not be evaluated. */
13711 /* Run the command list here. Take ownership of it instead of
13712 copying. We never want these commands to run later in
13713 bpstat_do_actions, if a breakpoint that causes a stop happens to
13714 be set at same address as this dprintf, or even if running the
13715 commands here throws. */
13716 tmp_bs
.commands
= bs
->commands
;
13717 bs
->commands
= NULL
;
13718 old_chain
= make_cleanup_decref_counted_command_line (&tmp_bs
.commands
);
13720 bpstat_do_actions_1 (&tmp_bs_p
);
13722 /* 'tmp_bs.commands' will usually be NULL by now, but
13723 bpstat_do_actions_1 may return early without processing the whole
13725 do_cleanups (old_chain
);
13728 /* The breakpoint_ops structure to be used on static tracepoints with
13732 strace_marker_create_sals_from_location (const struct event_location
*location
,
13733 struct linespec_result
*canonical
,
13734 enum bptype type_wanted
)
13736 struct linespec_sals lsal
;
13737 const char *arg_start
, *arg
;
13739 struct cleanup
*cleanup
;
13741 arg
= arg_start
= get_linespec_location (location
);
13742 lsal
.sals
= decode_static_tracepoint_spec (&arg
);
13744 str
= savestring (arg_start
, arg
- arg_start
);
13745 cleanup
= make_cleanup (xfree
, str
);
13746 canonical
->location
= new_linespec_location (&str
);
13747 do_cleanups (cleanup
);
13749 lsal
.canonical
= xstrdup (event_location_to_string (canonical
->location
));
13750 VEC_safe_push (linespec_sals
, canonical
->sals
, &lsal
);
13754 strace_marker_create_breakpoints_sal (struct gdbarch
*gdbarch
,
13755 struct linespec_result
*canonical
,
13757 char *extra_string
,
13758 enum bptype type_wanted
,
13759 enum bpdisp disposition
,
13761 int task
, int ignore_count
,
13762 const struct breakpoint_ops
*ops
,
13763 int from_tty
, int enabled
,
13764 int internal
, unsigned flags
)
13767 struct linespec_sals
*lsal
= VEC_index (linespec_sals
,
13768 canonical
->sals
, 0);
13770 /* If the user is creating a static tracepoint by marker id
13771 (strace -m MARKER_ID), then store the sals index, so that
13772 breakpoint_re_set can try to match up which of the newly
13773 found markers corresponds to this one, and, don't try to
13774 expand multiple locations for each sal, given than SALS
13775 already should contain all sals for MARKER_ID. */
13777 for (i
= 0; i
< lsal
->sals
.nelts
; ++i
)
13779 struct symtabs_and_lines expanded
;
13780 struct tracepoint
*tp
;
13781 struct cleanup
*old_chain
;
13782 struct event_location
*location
;
13784 expanded
.nelts
= 1;
13785 expanded
.sals
= &lsal
->sals
.sals
[i
];
13787 location
= copy_event_location (canonical
->location
);
13788 old_chain
= make_cleanup_delete_event_location (location
);
13790 tp
= XCNEW (struct tracepoint
);
13791 init_breakpoint_sal (&tp
->base
, gdbarch
, expanded
,
13793 cond_string
, extra_string
,
13794 type_wanted
, disposition
,
13795 thread
, task
, ignore_count
, ops
,
13796 from_tty
, enabled
, internal
, flags
,
13797 canonical
->special_display
);
13798 /* Given that its possible to have multiple markers with
13799 the same string id, if the user is creating a static
13800 tracepoint by marker id ("strace -m MARKER_ID"), then
13801 store the sals index, so that breakpoint_re_set can
13802 try to match up which of the newly found markers
13803 corresponds to this one */
13804 tp
->static_trace_marker_id_idx
= i
;
13806 install_breakpoint (internal
, &tp
->base
, 0);
13808 discard_cleanups (old_chain
);
13813 strace_marker_decode_location (struct breakpoint
*b
,
13814 const struct event_location
*location
,
13815 struct program_space
*search_pspace
,
13816 struct symtabs_and_lines
*sals
)
13818 struct tracepoint
*tp
= (struct tracepoint
*) b
;
13819 const char *s
= get_linespec_location (location
);
13821 *sals
= decode_static_tracepoint_spec (&s
);
13822 if (sals
->nelts
> tp
->static_trace_marker_id_idx
)
13824 sals
->sals
[0] = sals
->sals
[tp
->static_trace_marker_id_idx
];
13828 error (_("marker %s not found"), tp
->static_trace_marker_id
);
13831 static struct breakpoint_ops strace_marker_breakpoint_ops
;
13834 strace_marker_p (struct breakpoint
*b
)
13836 return b
->ops
== &strace_marker_breakpoint_ops
;
13839 /* Delete a breakpoint and clean up all traces of it in the data
13843 delete_breakpoint (struct breakpoint
*bpt
)
13845 struct breakpoint
*b
;
13847 gdb_assert (bpt
!= NULL
);
13849 /* Has this bp already been deleted? This can happen because
13850 multiple lists can hold pointers to bp's. bpstat lists are
13853 One example of this happening is a watchpoint's scope bp. When
13854 the scope bp triggers, we notice that the watchpoint is out of
13855 scope, and delete it. We also delete its scope bp. But the
13856 scope bp is marked "auto-deleting", and is already on a bpstat.
13857 That bpstat is then checked for auto-deleting bp's, which are
13860 A real solution to this problem might involve reference counts in
13861 bp's, and/or giving them pointers back to their referencing
13862 bpstat's, and teaching delete_breakpoint to only free a bp's
13863 storage when no more references were extent. A cheaper bandaid
13865 if (bpt
->type
== bp_none
)
13868 /* At least avoid this stale reference until the reference counting
13869 of breakpoints gets resolved. */
13870 if (bpt
->related_breakpoint
!= bpt
)
13872 struct breakpoint
*related
;
13873 struct watchpoint
*w
;
13875 if (bpt
->type
== bp_watchpoint_scope
)
13876 w
= (struct watchpoint
*) bpt
->related_breakpoint
;
13877 else if (bpt
->related_breakpoint
->type
== bp_watchpoint_scope
)
13878 w
= (struct watchpoint
*) bpt
;
13882 watchpoint_del_at_next_stop (w
);
13884 /* Unlink bpt from the bpt->related_breakpoint ring. */
13885 for (related
= bpt
; related
->related_breakpoint
!= bpt
;
13886 related
= related
->related_breakpoint
);
13887 related
->related_breakpoint
= bpt
->related_breakpoint
;
13888 bpt
->related_breakpoint
= bpt
;
13891 /* watch_command_1 creates a watchpoint but only sets its number if
13892 update_watchpoint succeeds in creating its bp_locations. If there's
13893 a problem in that process, we'll be asked to delete the half-created
13894 watchpoint. In that case, don't announce the deletion. */
13896 observer_notify_breakpoint_deleted (bpt
);
13898 if (breakpoint_chain
== bpt
)
13899 breakpoint_chain
= bpt
->next
;
13901 ALL_BREAKPOINTS (b
)
13902 if (b
->next
== bpt
)
13904 b
->next
= bpt
->next
;
13908 /* Be sure no bpstat's are pointing at the breakpoint after it's
13910 /* FIXME, how can we find all bpstat's? We just check stop_bpstat
13911 in all threads for now. Note that we cannot just remove bpstats
13912 pointing at bpt from the stop_bpstat list entirely, as breakpoint
13913 commands are associated with the bpstat; if we remove it here,
13914 then the later call to bpstat_do_actions (&stop_bpstat); in
13915 event-top.c won't do anything, and temporary breakpoints with
13916 commands won't work. */
13918 iterate_over_threads (bpstat_remove_breakpoint_callback
, bpt
);
13920 /* Now that breakpoint is removed from breakpoint list, update the
13921 global location list. This will remove locations that used to
13922 belong to this breakpoint. Do this before freeing the breakpoint
13923 itself, since remove_breakpoint looks at location's owner. It
13924 might be better design to have location completely
13925 self-contained, but it's not the case now. */
13926 update_global_location_list (UGLL_DONT_INSERT
);
13928 bpt
->ops
->dtor (bpt
);
13929 /* On the chance that someone will soon try again to delete this
13930 same bp, we mark it as deleted before freeing its storage. */
13931 bpt
->type
= bp_none
;
13936 do_delete_breakpoint_cleanup (void *b
)
13938 delete_breakpoint ((struct breakpoint
*) b
);
13942 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
13944 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
13947 /* Iterator function to call a user-provided callback function once
13948 for each of B and its related breakpoints. */
13951 iterate_over_related_breakpoints (struct breakpoint
*b
,
13952 void (*function
) (struct breakpoint
*,
13956 struct breakpoint
*related
;
13961 struct breakpoint
*next
;
13963 /* FUNCTION may delete RELATED. */
13964 next
= related
->related_breakpoint
;
13966 if (next
== related
)
13968 /* RELATED is the last ring entry. */
13969 function (related
, data
);
13971 /* FUNCTION may have deleted it, so we'd never reach back to
13972 B. There's nothing left to do anyway, so just break
13977 function (related
, data
);
13981 while (related
!= b
);
13985 do_delete_breakpoint (struct breakpoint
*b
, void *ignore
)
13987 delete_breakpoint (b
);
13990 /* A callback for map_breakpoint_numbers that calls
13991 delete_breakpoint. */
13994 do_map_delete_breakpoint (struct breakpoint
*b
, void *ignore
)
13996 iterate_over_related_breakpoints (b
, do_delete_breakpoint
, NULL
);
14000 delete_command (char *arg
, int from_tty
)
14002 struct breakpoint
*b
, *b_tmp
;
14008 int breaks_to_delete
= 0;
14010 /* Delete all breakpoints if no argument. Do not delete
14011 internal breakpoints, these have to be deleted with an
14012 explicit breakpoint number argument. */
14013 ALL_BREAKPOINTS (b
)
14014 if (user_breakpoint_p (b
))
14016 breaks_to_delete
= 1;
14020 /* Ask user only if there are some breakpoints to delete. */
14022 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
14024 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
14025 if (user_breakpoint_p (b
))
14026 delete_breakpoint (b
);
14030 map_breakpoint_numbers (arg
, do_map_delete_breakpoint
, NULL
);
14033 /* Return true if all locations of B bound to PSPACE are pending. If
14034 PSPACE is NULL, all locations of all program spaces are
14038 all_locations_are_pending (struct breakpoint
*b
, struct program_space
*pspace
)
14040 struct bp_location
*loc
;
14042 for (loc
= b
->loc
; loc
!= NULL
; loc
= loc
->next
)
14043 if ((pspace
== NULL
14044 || loc
->pspace
== pspace
)
14045 && !loc
->shlib_disabled
14046 && !loc
->pspace
->executing_startup
)
14051 /* Subroutine of update_breakpoint_locations to simplify it.
14052 Return non-zero if multiple fns in list LOC have the same name.
14053 Null names are ignored. */
14056 ambiguous_names_p (struct bp_location
*loc
)
14058 struct bp_location
*l
;
14059 htab_t htab
= htab_create_alloc (13, htab_hash_string
,
14060 (int (*) (const void *,
14061 const void *)) streq
,
14062 NULL
, xcalloc
, xfree
);
14064 for (l
= loc
; l
!= NULL
; l
= l
->next
)
14067 const char *name
= l
->function_name
;
14069 /* Allow for some names to be NULL, ignore them. */
14073 slot
= (const char **) htab_find_slot (htab
, (const void *) name
,
14075 /* NOTE: We can assume slot != NULL here because xcalloc never
14079 htab_delete (htab
);
14085 htab_delete (htab
);
14089 /* When symbols change, it probably means the sources changed as well,
14090 and it might mean the static tracepoint markers are no longer at
14091 the same address or line numbers they used to be at last we
14092 checked. Losing your static tracepoints whenever you rebuild is
14093 undesirable. This function tries to resync/rematch gdb static
14094 tracepoints with the markers on the target, for static tracepoints
14095 that have not been set by marker id. Static tracepoint that have
14096 been set by marker id are reset by marker id in breakpoint_re_set.
14099 1) For a tracepoint set at a specific address, look for a marker at
14100 the old PC. If one is found there, assume to be the same marker.
14101 If the name / string id of the marker found is different from the
14102 previous known name, assume that means the user renamed the marker
14103 in the sources, and output a warning.
14105 2) For a tracepoint set at a given line number, look for a marker
14106 at the new address of the old line number. If one is found there,
14107 assume to be the same marker. If the name / string id of the
14108 marker found is different from the previous known name, assume that
14109 means the user renamed the marker in the sources, and output a
14112 3) If a marker is no longer found at the same address or line, it
14113 may mean the marker no longer exists. But it may also just mean
14114 the code changed a bit. Maybe the user added a few lines of code
14115 that made the marker move up or down (in line number terms). Ask
14116 the target for info about the marker with the string id as we knew
14117 it. If found, update line number and address in the matching
14118 static tracepoint. This will get confused if there's more than one
14119 marker with the same ID (possible in UST, although unadvised
14120 precisely because it confuses tools). */
14122 static struct symtab_and_line
14123 update_static_tracepoint (struct breakpoint
*b
, struct symtab_and_line sal
)
14125 struct tracepoint
*tp
= (struct tracepoint
*) b
;
14126 struct static_tracepoint_marker marker
;
14131 find_line_pc (sal
.symtab
, sal
.line
, &pc
);
14133 if (target_static_tracepoint_marker_at (pc
, &marker
))
14135 if (strcmp (tp
->static_trace_marker_id
, marker
.str_id
) != 0)
14136 warning (_("static tracepoint %d changed probed marker from %s to %s"),
14138 tp
->static_trace_marker_id
, marker
.str_id
);
14140 xfree (tp
->static_trace_marker_id
);
14141 tp
->static_trace_marker_id
= xstrdup (marker
.str_id
);
14142 release_static_tracepoint_marker (&marker
);
14147 /* Old marker wasn't found on target at lineno. Try looking it up
14149 if (!sal
.explicit_pc
14151 && sal
.symtab
!= NULL
14152 && tp
->static_trace_marker_id
!= NULL
)
14154 VEC(static_tracepoint_marker_p
) *markers
;
14157 = target_static_tracepoint_markers_by_strid (tp
->static_trace_marker_id
);
14159 if (!VEC_empty(static_tracepoint_marker_p
, markers
))
14161 struct symtab_and_line sal2
;
14162 struct symbol
*sym
;
14163 struct static_tracepoint_marker
*tpmarker
;
14164 struct ui_out
*uiout
= current_uiout
;
14165 struct explicit_location explicit_loc
;
14167 tpmarker
= VEC_index (static_tracepoint_marker_p
, markers
, 0);
14169 xfree (tp
->static_trace_marker_id
);
14170 tp
->static_trace_marker_id
= xstrdup (tpmarker
->str_id
);
14172 warning (_("marker for static tracepoint %d (%s) not "
14173 "found at previous line number"),
14174 b
->number
, tp
->static_trace_marker_id
);
14178 sal2
.pc
= tpmarker
->address
;
14180 sal2
= find_pc_line (tpmarker
->address
, 0);
14181 sym
= find_pc_sect_function (tpmarker
->address
, NULL
);
14182 ui_out_text (uiout
, "Now in ");
14185 ui_out_field_string (uiout
, "func",
14186 SYMBOL_PRINT_NAME (sym
));
14187 ui_out_text (uiout
, " at ");
14189 ui_out_field_string (uiout
, "file",
14190 symtab_to_filename_for_display (sal2
.symtab
));
14191 ui_out_text (uiout
, ":");
14193 if (ui_out_is_mi_like_p (uiout
))
14195 const char *fullname
= symtab_to_fullname (sal2
.symtab
);
14197 ui_out_field_string (uiout
, "fullname", fullname
);
14200 ui_out_field_int (uiout
, "line", sal2
.line
);
14201 ui_out_text (uiout
, "\n");
14203 b
->loc
->line_number
= sal2
.line
;
14204 b
->loc
->symtab
= sym
!= NULL
? sal2
.symtab
: NULL
;
14206 delete_event_location (b
->location
);
14207 initialize_explicit_location (&explicit_loc
);
14208 explicit_loc
.source_filename
14209 = ASTRDUP (symtab_to_filename_for_display (sal2
.symtab
));
14210 explicit_loc
.line_offset
.offset
= b
->loc
->line_number
;
14211 explicit_loc
.line_offset
.sign
= LINE_OFFSET_NONE
;
14212 b
->location
= new_explicit_location (&explicit_loc
);
14214 /* Might be nice to check if function changed, and warn if
14217 release_static_tracepoint_marker (tpmarker
);
14223 /* Returns 1 iff locations A and B are sufficiently same that
14224 we don't need to report breakpoint as changed. */
14227 locations_are_equal (struct bp_location
*a
, struct bp_location
*b
)
14231 if (a
->address
!= b
->address
)
14234 if (a
->shlib_disabled
!= b
->shlib_disabled
)
14237 if (a
->enabled
!= b
->enabled
)
14244 if ((a
== NULL
) != (b
== NULL
))
14250 /* Split all locations of B that are bound to PSPACE out of B's
14251 location list to a separate list and return that list's head. If
14252 PSPACE is NULL, hoist out all locations of B. */
14254 static struct bp_location
*
14255 hoist_existing_locations (struct breakpoint
*b
, struct program_space
*pspace
)
14257 struct bp_location head
;
14258 struct bp_location
*i
= b
->loc
;
14259 struct bp_location
**i_link
= &b
->loc
;
14260 struct bp_location
*hoisted
= &head
;
14262 if (pspace
== NULL
)
14273 if (i
->pspace
== pspace
)
14288 /* Create new breakpoint locations for B (a hardware or software
14289 breakpoint) based on SALS and SALS_END. If SALS_END.NELTS is not
14290 zero, then B is a ranged breakpoint. Only recreates locations for
14291 FILTER_PSPACE. Locations of other program spaces are left
14295 update_breakpoint_locations (struct breakpoint
*b
,
14296 struct program_space
*filter_pspace
,
14297 struct symtabs_and_lines sals
,
14298 struct symtabs_and_lines sals_end
)
14301 struct bp_location
*existing_locations
;
14303 if (sals_end
.nelts
!= 0 && (sals
.nelts
!= 1 || sals_end
.nelts
!= 1))
14305 /* Ranged breakpoints have only one start location and one end
14307 b
->enable_state
= bp_disabled
;
14308 printf_unfiltered (_("Could not reset ranged breakpoint %d: "
14309 "multiple locations found\n"),
14314 /* If there's no new locations, and all existing locations are
14315 pending, don't do anything. This optimizes the common case where
14316 all locations are in the same shared library, that was unloaded.
14317 We'd like to retain the location, so that when the library is
14318 loaded again, we don't loose the enabled/disabled status of the
14319 individual locations. */
14320 if (all_locations_are_pending (b
, filter_pspace
) && sals
.nelts
== 0)
14323 existing_locations
= hoist_existing_locations (b
, filter_pspace
);
14325 for (i
= 0; i
< sals
.nelts
; ++i
)
14327 struct bp_location
*new_loc
;
14329 switch_to_program_space_and_thread (sals
.sals
[i
].pspace
);
14331 new_loc
= add_location_to_breakpoint (b
, &(sals
.sals
[i
]));
14333 /* Reparse conditions, they might contain references to the
14335 if (b
->cond_string
!= NULL
)
14339 s
= b
->cond_string
;
14342 new_loc
->cond
= parse_exp_1 (&s
, sals
.sals
[i
].pc
,
14343 block_for_pc (sals
.sals
[i
].pc
),
14346 CATCH (e
, RETURN_MASK_ERROR
)
14348 warning (_("failed to reevaluate condition "
14349 "for breakpoint %d: %s"),
14350 b
->number
, e
.message
);
14351 new_loc
->enabled
= 0;
14356 if (sals_end
.nelts
)
14358 CORE_ADDR end
= find_breakpoint_range_end (sals_end
.sals
[0]);
14360 new_loc
->length
= end
- sals
.sals
[0].pc
+ 1;
14364 /* If possible, carry over 'disable' status from existing
14367 struct bp_location
*e
= existing_locations
;
14368 /* If there are multiple breakpoints with the same function name,
14369 e.g. for inline functions, comparing function names won't work.
14370 Instead compare pc addresses; this is just a heuristic as things
14371 may have moved, but in practice it gives the correct answer
14372 often enough until a better solution is found. */
14373 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
14375 for (; e
; e
= e
->next
)
14377 if (!e
->enabled
&& e
->function_name
)
14379 struct bp_location
*l
= b
->loc
;
14380 if (have_ambiguous_names
)
14382 for (; l
; l
= l
->next
)
14383 if (breakpoint_locations_match (e
, l
))
14391 for (; l
; l
= l
->next
)
14392 if (l
->function_name
14393 && strcmp (e
->function_name
, l
->function_name
) == 0)
14403 if (!locations_are_equal (existing_locations
, b
->loc
))
14404 observer_notify_breakpoint_modified (b
);
14407 /* Find the SaL locations corresponding to the given LOCATION.
14408 On return, FOUND will be 1 if any SaL was found, zero otherwise. */
14410 static struct symtabs_and_lines
14411 location_to_sals (struct breakpoint
*b
, struct event_location
*location
,
14412 struct program_space
*search_pspace
, int *found
)
14414 struct symtabs_and_lines sals
= {0};
14415 struct gdb_exception exception
= exception_none
;
14417 gdb_assert (b
->ops
!= NULL
);
14421 b
->ops
->decode_location (b
, location
, search_pspace
, &sals
);
14423 CATCH (e
, RETURN_MASK_ERROR
)
14425 int not_found_and_ok
= 0;
14429 /* For pending breakpoints, it's expected that parsing will
14430 fail until the right shared library is loaded. User has
14431 already told to create pending breakpoints and don't need
14432 extra messages. If breakpoint is in bp_shlib_disabled
14433 state, then user already saw the message about that
14434 breakpoint being disabled, and don't want to see more
14436 if (e
.error
== NOT_FOUND_ERROR
14437 && (b
->condition_not_parsed
14439 && search_pspace
!= NULL
14440 && b
->loc
->pspace
!= search_pspace
)
14441 || (b
->loc
&& b
->loc
->shlib_disabled
)
14442 || (b
->loc
&& b
->loc
->pspace
->executing_startup
)
14443 || b
->enable_state
== bp_disabled
))
14444 not_found_and_ok
= 1;
14446 if (!not_found_and_ok
)
14448 /* We surely don't want to warn about the same breakpoint
14449 10 times. One solution, implemented here, is disable
14450 the breakpoint on error. Another solution would be to
14451 have separate 'warning emitted' flag. Since this
14452 happens only when a binary has changed, I don't know
14453 which approach is better. */
14454 b
->enable_state
= bp_disabled
;
14455 throw_exception (e
);
14460 if (exception
.reason
== 0 || exception
.error
!= NOT_FOUND_ERROR
)
14464 for (i
= 0; i
< sals
.nelts
; ++i
)
14465 resolve_sal_pc (&sals
.sals
[i
]);
14466 if (b
->condition_not_parsed
&& b
->extra_string
!= NULL
)
14468 char *cond_string
, *extra_string
;
14471 find_condition_and_thread (b
->extra_string
, sals
.sals
[0].pc
,
14472 &cond_string
, &thread
, &task
,
14474 gdb_assert (b
->cond_string
== NULL
);
14476 b
->cond_string
= cond_string
;
14477 b
->thread
= thread
;
14481 xfree (b
->extra_string
);
14482 b
->extra_string
= extra_string
;
14484 b
->condition_not_parsed
= 0;
14487 if (b
->type
== bp_static_tracepoint
&& !strace_marker_p (b
))
14488 sals
.sals
[0] = update_static_tracepoint (b
, sals
.sals
[0]);
14498 /* The default re_set method, for typical hardware or software
14499 breakpoints. Reevaluate the breakpoint and recreate its
14503 breakpoint_re_set_default (struct breakpoint
*b
)
14506 struct symtabs_and_lines sals
, sals_end
;
14507 struct symtabs_and_lines expanded
= {0};
14508 struct symtabs_and_lines expanded_end
= {0};
14509 struct program_space
*filter_pspace
= current_program_space
;
14511 sals
= location_to_sals (b
, b
->location
, filter_pspace
, &found
);
14514 make_cleanup (xfree
, sals
.sals
);
14518 if (b
->location_range_end
!= NULL
)
14520 sals_end
= location_to_sals (b
, b
->location_range_end
,
14521 filter_pspace
, &found
);
14524 make_cleanup (xfree
, sals_end
.sals
);
14525 expanded_end
= sals_end
;
14529 update_breakpoint_locations (b
, filter_pspace
, expanded
, expanded_end
);
14532 /* Default method for creating SALs from an address string. It basically
14533 calls parse_breakpoint_sals. Return 1 for success, zero for failure. */
14536 create_sals_from_location_default (const struct event_location
*location
,
14537 struct linespec_result
*canonical
,
14538 enum bptype type_wanted
)
14540 parse_breakpoint_sals (location
, canonical
);
14543 /* Call create_breakpoints_sal for the given arguments. This is the default
14544 function for the `create_breakpoints_sal' method of
14548 create_breakpoints_sal_default (struct gdbarch
*gdbarch
,
14549 struct linespec_result
*canonical
,
14551 char *extra_string
,
14552 enum bptype type_wanted
,
14553 enum bpdisp disposition
,
14555 int task
, int ignore_count
,
14556 const struct breakpoint_ops
*ops
,
14557 int from_tty
, int enabled
,
14558 int internal
, unsigned flags
)
14560 create_breakpoints_sal (gdbarch
, canonical
, cond_string
,
14562 type_wanted
, disposition
,
14563 thread
, task
, ignore_count
, ops
, from_tty
,
14564 enabled
, internal
, flags
);
14567 /* Decode the line represented by S by calling decode_line_full. This is the
14568 default function for the `decode_location' method of breakpoint_ops. */
14571 decode_location_default (struct breakpoint
*b
,
14572 const struct event_location
*location
,
14573 struct program_space
*search_pspace
,
14574 struct symtabs_and_lines
*sals
)
14576 struct linespec_result canonical
;
14578 init_linespec_result (&canonical
);
14579 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, search_pspace
,
14580 (struct symtab
*) NULL
, 0,
14581 &canonical
, multiple_symbols_all
,
14584 /* We should get 0 or 1 resulting SALs. */
14585 gdb_assert (VEC_length (linespec_sals
, canonical
.sals
) < 2);
14587 if (VEC_length (linespec_sals
, canonical
.sals
) > 0)
14589 struct linespec_sals
*lsal
;
14591 lsal
= VEC_index (linespec_sals
, canonical
.sals
, 0);
14592 *sals
= lsal
->sals
;
14593 /* Arrange it so the destructor does not free the
14595 lsal
->sals
.sals
= NULL
;
14598 destroy_linespec_result (&canonical
);
14601 /* Prepare the global context for a re-set of breakpoint B. */
14603 static struct cleanup
*
14604 prepare_re_set_context (struct breakpoint
*b
)
14606 input_radix
= b
->input_radix
;
14607 set_language (b
->language
);
14609 return make_cleanup (null_cleanup
, NULL
);
14612 /* Reset a breakpoint given it's struct breakpoint * BINT.
14613 The value we return ends up being the return value from catch_errors.
14614 Unused in this case. */
14617 breakpoint_re_set_one (void *bint
)
14619 /* Get past catch_errs. */
14620 struct breakpoint
*b
= (struct breakpoint
*) bint
;
14621 struct cleanup
*cleanups
;
14623 cleanups
= prepare_re_set_context (b
);
14624 b
->ops
->re_set (b
);
14625 do_cleanups (cleanups
);
14629 /* Re-set breakpoint locations for the current program space.
14630 Locations bound to other program spaces are left untouched. */
14633 breakpoint_re_set (void)
14635 struct breakpoint
*b
, *b_tmp
;
14636 enum language save_language
;
14637 int save_input_radix
;
14638 struct cleanup
*old_chain
;
14640 save_language
= current_language
->la_language
;
14641 save_input_radix
= input_radix
;
14642 old_chain
= save_current_space_and_thread ();
14644 /* Note: we must not try to insert locations until after all
14645 breakpoints have been re-set. Otherwise, e.g., when re-setting
14646 breakpoint 1, we'd insert the locations of breakpoint 2, which
14647 hadn't been re-set yet, and thus may have stale locations. */
14649 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
14651 /* Format possible error msg. */
14652 char *message
= xstrprintf ("Error in re-setting breakpoint %d: ",
14654 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
14655 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
14656 do_cleanups (cleanups
);
14658 set_language (save_language
);
14659 input_radix
= save_input_radix
;
14661 jit_breakpoint_re_set ();
14663 do_cleanups (old_chain
);
14665 create_overlay_event_breakpoint ();
14666 create_longjmp_master_breakpoint ();
14667 create_std_terminate_master_breakpoint ();
14668 create_exception_master_breakpoint ();
14670 /* Now we can insert. */
14671 update_global_location_list (UGLL_MAY_INSERT
);
14674 /* Reset the thread number of this breakpoint:
14676 - If the breakpoint is for all threads, leave it as-is.
14677 - Else, reset it to the current thread for inferior_ptid. */
14679 breakpoint_re_set_thread (struct breakpoint
*b
)
14681 if (b
->thread
!= -1)
14683 if (in_thread_list (inferior_ptid
))
14684 b
->thread
= ptid_to_global_thread_id (inferior_ptid
);
14686 /* We're being called after following a fork. The new fork is
14687 selected as current, and unless this was a vfork will have a
14688 different program space from the original thread. Reset that
14690 b
->loc
->pspace
= current_program_space
;
14694 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14695 If from_tty is nonzero, it prints a message to that effect,
14696 which ends with a period (no newline). */
14699 set_ignore_count (int bptnum
, int count
, int from_tty
)
14701 struct breakpoint
*b
;
14706 ALL_BREAKPOINTS (b
)
14707 if (b
->number
== bptnum
)
14709 if (is_tracepoint (b
))
14711 if (from_tty
&& count
!= 0)
14712 printf_filtered (_("Ignore count ignored for tracepoint %d."),
14717 b
->ignore_count
= count
;
14721 printf_filtered (_("Will stop next time "
14722 "breakpoint %d is reached."),
14724 else if (count
== 1)
14725 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
14728 printf_filtered (_("Will ignore next %d "
14729 "crossings of breakpoint %d."),
14732 observer_notify_breakpoint_modified (b
);
14736 error (_("No breakpoint number %d."), bptnum
);
14739 /* Command to set ignore-count of breakpoint N to COUNT. */
14742 ignore_command (char *args
, int from_tty
)
14748 error_no_arg (_("a breakpoint number"));
14750 num
= get_number (&p
);
14752 error (_("bad breakpoint number: '%s'"), args
);
14754 error (_("Second argument (specified ignore-count) is missing."));
14756 set_ignore_count (num
,
14757 longest_to_int (value_as_long (parse_and_eval (p
))),
14760 printf_filtered ("\n");
14763 /* Call FUNCTION on each of the breakpoints
14764 whose numbers are given in ARGS. */
14767 map_breakpoint_numbers (char *args
, void (*function
) (struct breakpoint
*,
14772 struct breakpoint
*b
, *tmp
;
14774 struct get_number_or_range_state state
;
14776 if (args
== 0 || *args
== '\0')
14777 error_no_arg (_("one or more breakpoint numbers"));
14779 init_number_or_range (&state
, args
);
14781 while (!state
.finished
)
14783 const char *p
= state
.string
;
14787 num
= get_number_or_range (&state
);
14790 warning (_("bad breakpoint number at or near '%s'"), p
);
14794 ALL_BREAKPOINTS_SAFE (b
, tmp
)
14795 if (b
->number
== num
)
14798 function (b
, data
);
14802 printf_unfiltered (_("No breakpoint number %d.\n"), num
);
14807 static struct bp_location
*
14808 find_location_by_number (char *number
)
14810 char *dot
= strchr (number
, '.');
14814 struct breakpoint
*b
;
14815 struct bp_location
*loc
;
14820 bp_num
= get_number (&p1
);
14822 error (_("Bad breakpoint number '%s'"), number
);
14824 ALL_BREAKPOINTS (b
)
14825 if (b
->number
== bp_num
)
14830 if (!b
|| b
->number
!= bp_num
)
14831 error (_("Bad breakpoint number '%s'"), number
);
14834 loc_num
= get_number (&p1
);
14836 error (_("Bad breakpoint location number '%s'"), number
);
14840 for (;loc_num
&& loc
; --loc_num
, loc
= loc
->next
)
14843 error (_("Bad breakpoint location number '%s'"), dot
+1);
14849 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14850 If from_tty is nonzero, it prints a message to that effect,
14851 which ends with a period (no newline). */
14854 disable_breakpoint (struct breakpoint
*bpt
)
14856 /* Never disable a watchpoint scope breakpoint; we want to
14857 hit them when we leave scope so we can delete both the
14858 watchpoint and its scope breakpoint at that time. */
14859 if (bpt
->type
== bp_watchpoint_scope
)
14862 bpt
->enable_state
= bp_disabled
;
14864 /* Mark breakpoint locations modified. */
14865 mark_breakpoint_modified (bpt
);
14867 if (target_supports_enable_disable_tracepoint ()
14868 && current_trace_status ()->running
&& is_tracepoint (bpt
))
14870 struct bp_location
*location
;
14872 for (location
= bpt
->loc
; location
; location
= location
->next
)
14873 target_disable_tracepoint (location
);
14876 update_global_location_list (UGLL_DONT_INSERT
);
14878 observer_notify_breakpoint_modified (bpt
);
14881 /* A callback for iterate_over_related_breakpoints. */
14884 do_disable_breakpoint (struct breakpoint
*b
, void *ignore
)
14886 disable_breakpoint (b
);
14889 /* A callback for map_breakpoint_numbers that calls
14890 disable_breakpoint. */
14893 do_map_disable_breakpoint (struct breakpoint
*b
, void *ignore
)
14895 iterate_over_related_breakpoints (b
, do_disable_breakpoint
, NULL
);
14899 disable_command (char *args
, int from_tty
)
14903 struct breakpoint
*bpt
;
14905 ALL_BREAKPOINTS (bpt
)
14906 if (user_breakpoint_p (bpt
))
14907 disable_breakpoint (bpt
);
14911 char *num
= extract_arg (&args
);
14915 if (strchr (num
, '.'))
14917 struct bp_location
*loc
= find_location_by_number (num
);
14924 mark_breakpoint_location_modified (loc
);
14926 if (target_supports_enable_disable_tracepoint ()
14927 && current_trace_status ()->running
&& loc
->owner
14928 && is_tracepoint (loc
->owner
))
14929 target_disable_tracepoint (loc
);
14931 update_global_location_list (UGLL_DONT_INSERT
);
14934 map_breakpoint_numbers (num
, do_map_disable_breakpoint
, NULL
);
14935 num
= extract_arg (&args
);
14941 enable_breakpoint_disp (struct breakpoint
*bpt
, enum bpdisp disposition
,
14944 int target_resources_ok
;
14946 if (bpt
->type
== bp_hardware_breakpoint
)
14949 i
= hw_breakpoint_used_count ();
14950 target_resources_ok
=
14951 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
14953 if (target_resources_ok
== 0)
14954 error (_("No hardware breakpoint support in the target."));
14955 else if (target_resources_ok
< 0)
14956 error (_("Hardware breakpoints used exceeds limit."));
14959 if (is_watchpoint (bpt
))
14961 /* Initialize it just to avoid a GCC false warning. */
14962 enum enable_state orig_enable_state
= bp_disabled
;
14966 struct watchpoint
*w
= (struct watchpoint
*) bpt
;
14968 orig_enable_state
= bpt
->enable_state
;
14969 bpt
->enable_state
= bp_enabled
;
14970 update_watchpoint (w
, 1 /* reparse */);
14972 CATCH (e
, RETURN_MASK_ALL
)
14974 bpt
->enable_state
= orig_enable_state
;
14975 exception_fprintf (gdb_stderr
, e
, _("Cannot enable watchpoint %d: "),
14982 bpt
->enable_state
= bp_enabled
;
14984 /* Mark breakpoint locations modified. */
14985 mark_breakpoint_modified (bpt
);
14987 if (target_supports_enable_disable_tracepoint ()
14988 && current_trace_status ()->running
&& is_tracepoint (bpt
))
14990 struct bp_location
*location
;
14992 for (location
= bpt
->loc
; location
; location
= location
->next
)
14993 target_enable_tracepoint (location
);
14996 bpt
->disposition
= disposition
;
14997 bpt
->enable_count
= count
;
14998 update_global_location_list (UGLL_MAY_INSERT
);
15000 observer_notify_breakpoint_modified (bpt
);
15005 enable_breakpoint (struct breakpoint
*bpt
)
15007 enable_breakpoint_disp (bpt
, bpt
->disposition
, 0);
15011 do_enable_breakpoint (struct breakpoint
*bpt
, void *arg
)
15013 enable_breakpoint (bpt
);
15016 /* A callback for map_breakpoint_numbers that calls
15017 enable_breakpoint. */
15020 do_map_enable_breakpoint (struct breakpoint
*b
, void *ignore
)
15022 iterate_over_related_breakpoints (b
, do_enable_breakpoint
, NULL
);
15025 /* The enable command enables the specified breakpoints (or all defined
15026 breakpoints) so they once again become (or continue to be) effective
15027 in stopping the inferior. */
15030 enable_command (char *args
, int from_tty
)
15034 struct breakpoint
*bpt
;
15036 ALL_BREAKPOINTS (bpt
)
15037 if (user_breakpoint_p (bpt
))
15038 enable_breakpoint (bpt
);
15042 char *num
= extract_arg (&args
);
15046 if (strchr (num
, '.'))
15048 struct bp_location
*loc
= find_location_by_number (num
);
15055 mark_breakpoint_location_modified (loc
);
15057 if (target_supports_enable_disable_tracepoint ()
15058 && current_trace_status ()->running
&& loc
->owner
15059 && is_tracepoint (loc
->owner
))
15060 target_enable_tracepoint (loc
);
15062 update_global_location_list (UGLL_MAY_INSERT
);
15065 map_breakpoint_numbers (num
, do_map_enable_breakpoint
, NULL
);
15066 num
= extract_arg (&args
);
15071 /* This struct packages up disposition data for application to multiple
15081 do_enable_breakpoint_disp (struct breakpoint
*bpt
, void *arg
)
15083 struct disp_data disp_data
= *(struct disp_data
*) arg
;
15085 enable_breakpoint_disp (bpt
, disp_data
.disp
, disp_data
.count
);
15089 do_map_enable_once_breakpoint (struct breakpoint
*bpt
, void *ignore
)
15091 struct disp_data disp
= { disp_disable
, 1 };
15093 iterate_over_related_breakpoints (bpt
, do_enable_breakpoint_disp
, &disp
);
15097 enable_once_command (char *args
, int from_tty
)
15099 map_breakpoint_numbers (args
, do_map_enable_once_breakpoint
, NULL
);
15103 do_map_enable_count_breakpoint (struct breakpoint
*bpt
, void *countptr
)
15105 struct disp_data disp
= { disp_disable
, *(int *) countptr
};
15107 iterate_over_related_breakpoints (bpt
, do_enable_breakpoint_disp
, &disp
);
15111 enable_count_command (char *args
, int from_tty
)
15116 error_no_arg (_("hit count"));
15118 count
= get_number (&args
);
15120 map_breakpoint_numbers (args
, do_map_enable_count_breakpoint
, &count
);
15124 do_map_enable_delete_breakpoint (struct breakpoint
*bpt
, void *ignore
)
15126 struct disp_data disp
= { disp_del
, 1 };
15128 iterate_over_related_breakpoints (bpt
, do_enable_breakpoint_disp
, &disp
);
15132 enable_delete_command (char *args
, int from_tty
)
15134 map_breakpoint_numbers (args
, do_map_enable_delete_breakpoint
, NULL
);
15138 set_breakpoint_cmd (char *args
, int from_tty
)
15143 show_breakpoint_cmd (char *args
, int from_tty
)
15147 /* Invalidate last known value of any hardware watchpoint if
15148 the memory which that value represents has been written to by
15152 invalidate_bp_value_on_memory_change (struct inferior
*inferior
,
15153 CORE_ADDR addr
, ssize_t len
,
15154 const bfd_byte
*data
)
15156 struct breakpoint
*bp
;
15158 ALL_BREAKPOINTS (bp
)
15159 if (bp
->enable_state
== bp_enabled
15160 && bp
->type
== bp_hardware_watchpoint
)
15162 struct watchpoint
*wp
= (struct watchpoint
*) bp
;
15164 if (wp
->val_valid
&& wp
->val
)
15166 struct bp_location
*loc
;
15168 for (loc
= bp
->loc
; loc
!= NULL
; loc
= loc
->next
)
15169 if (loc
->loc_type
== bp_loc_hardware_watchpoint
15170 && loc
->address
+ loc
->length
> addr
15171 && addr
+ len
> loc
->address
)
15173 value_free (wp
->val
);
15181 /* Create and insert a breakpoint for software single step. */
15184 insert_single_step_breakpoint (struct gdbarch
*gdbarch
,
15185 struct address_space
*aspace
,
15188 struct thread_info
*tp
= inferior_thread ();
15189 struct symtab_and_line sal
;
15190 CORE_ADDR pc
= next_pc
;
15192 if (tp
->control
.single_step_breakpoints
== NULL
)
15194 tp
->control
.single_step_breakpoints
15195 = new_single_step_breakpoint (tp
->global_num
, gdbarch
);
15198 sal
= find_pc_line (pc
, 0);
15200 sal
.section
= find_pc_overlay (pc
);
15201 sal
.explicit_pc
= 1;
15202 add_location_to_breakpoint (tp
->control
.single_step_breakpoints
, &sal
);
15204 update_global_location_list (UGLL_INSERT
);
15207 /* See breakpoint.h. */
15210 breakpoint_has_location_inserted_here (struct breakpoint
*bp
,
15211 struct address_space
*aspace
,
15214 struct bp_location
*loc
;
15216 for (loc
= bp
->loc
; loc
!= NULL
; loc
= loc
->next
)
15218 && breakpoint_location_address_match (loc
, aspace
, pc
))
15224 /* Check whether a software single-step breakpoint is inserted at
15228 single_step_breakpoint_inserted_here_p (struct address_space
*aspace
,
15231 struct breakpoint
*bpt
;
15233 ALL_BREAKPOINTS (bpt
)
15235 if (bpt
->type
== bp_single_step
15236 && breakpoint_has_location_inserted_here (bpt
, aspace
, pc
))
15242 /* Tracepoint-specific operations. */
15244 /* Set tracepoint count to NUM. */
15246 set_tracepoint_count (int num
)
15248 tracepoint_count
= num
;
15249 set_internalvar_integer (lookup_internalvar ("tpnum"), num
);
15253 trace_command (char *arg
, int from_tty
)
15255 struct breakpoint_ops
*ops
;
15256 struct event_location
*location
;
15257 struct cleanup
*back_to
;
15259 location
= string_to_event_location (&arg
, current_language
);
15260 back_to
= make_cleanup_delete_event_location (location
);
15261 if (location
!= NULL
15262 && event_location_type (location
) == PROBE_LOCATION
)
15263 ops
= &tracepoint_probe_breakpoint_ops
;
15265 ops
= &tracepoint_breakpoint_ops
;
15267 create_breakpoint (get_current_arch (),
15269 NULL
, 0, arg
, 1 /* parse arg */,
15271 bp_tracepoint
/* type_wanted */,
15272 0 /* Ignore count */,
15273 pending_break_support
,
15277 0 /* internal */, 0);
15278 do_cleanups (back_to
);
15282 ftrace_command (char *arg
, int from_tty
)
15284 struct event_location
*location
;
15285 struct cleanup
*back_to
;
15287 location
= string_to_event_location (&arg
, current_language
);
15288 back_to
= make_cleanup_delete_event_location (location
);
15289 create_breakpoint (get_current_arch (),
15291 NULL
, 0, arg
, 1 /* parse arg */,
15293 bp_fast_tracepoint
/* type_wanted */,
15294 0 /* Ignore count */,
15295 pending_break_support
,
15296 &tracepoint_breakpoint_ops
,
15299 0 /* internal */, 0);
15300 do_cleanups (back_to
);
15303 /* strace command implementation. Creates a static tracepoint. */
15306 strace_command (char *arg
, int from_tty
)
15308 struct breakpoint_ops
*ops
;
15309 struct event_location
*location
;
15310 struct cleanup
*back_to
;
15312 /* Decide if we are dealing with a static tracepoint marker (`-m'),
15313 or with a normal static tracepoint. */
15314 if (arg
&& startswith (arg
, "-m") && isspace (arg
[2]))
15316 ops
= &strace_marker_breakpoint_ops
;
15317 location
= new_linespec_location (&arg
);
15321 ops
= &tracepoint_breakpoint_ops
;
15322 location
= string_to_event_location (&arg
, current_language
);
15325 back_to
= make_cleanup_delete_event_location (location
);
15326 create_breakpoint (get_current_arch (),
15328 NULL
, 0, arg
, 1 /* parse arg */,
15330 bp_static_tracepoint
/* type_wanted */,
15331 0 /* Ignore count */,
15332 pending_break_support
,
15336 0 /* internal */, 0);
15337 do_cleanups (back_to
);
15340 /* Set up a fake reader function that gets command lines from a linked
15341 list that was acquired during tracepoint uploading. */
15343 static struct uploaded_tp
*this_utp
;
15344 static int next_cmd
;
15347 read_uploaded_action (void)
15351 VEC_iterate (char_ptr
, this_utp
->cmd_strings
, next_cmd
, rslt
);
15358 /* Given information about a tracepoint as recorded on a target (which
15359 can be either a live system or a trace file), attempt to create an
15360 equivalent GDB tracepoint. This is not a reliable process, since
15361 the target does not necessarily have all the information used when
15362 the tracepoint was originally defined. */
15364 struct tracepoint
*
15365 create_tracepoint_from_upload (struct uploaded_tp
*utp
)
15367 char *addr_str
, small_buf
[100];
15368 struct tracepoint
*tp
;
15369 struct event_location
*location
;
15370 struct cleanup
*cleanup
;
15372 if (utp
->at_string
)
15373 addr_str
= utp
->at_string
;
15376 /* In the absence of a source location, fall back to raw
15377 address. Since there is no way to confirm that the address
15378 means the same thing as when the trace was started, warn the
15380 warning (_("Uploaded tracepoint %d has no "
15381 "source location, using raw address"),
15383 xsnprintf (small_buf
, sizeof (small_buf
), "*%s", hex_string (utp
->addr
));
15384 addr_str
= small_buf
;
15387 /* There's not much we can do with a sequence of bytecodes. */
15388 if (utp
->cond
&& !utp
->cond_string
)
15389 warning (_("Uploaded tracepoint %d condition "
15390 "has no source form, ignoring it"),
15393 location
= string_to_event_location (&addr_str
, current_language
);
15394 cleanup
= make_cleanup_delete_event_location (location
);
15395 if (!create_breakpoint (get_current_arch (),
15397 utp
->cond_string
, -1, addr_str
,
15398 0 /* parse cond/thread */,
15400 utp
->type
/* type_wanted */,
15401 0 /* Ignore count */,
15402 pending_break_support
,
15403 &tracepoint_breakpoint_ops
,
15405 utp
->enabled
/* enabled */,
15407 CREATE_BREAKPOINT_FLAGS_INSERTED
))
15409 do_cleanups (cleanup
);
15413 do_cleanups (cleanup
);
15415 /* Get the tracepoint we just created. */
15416 tp
= get_tracepoint (tracepoint_count
);
15417 gdb_assert (tp
!= NULL
);
15421 xsnprintf (small_buf
, sizeof (small_buf
), "%d %d", utp
->pass
,
15424 trace_pass_command (small_buf
, 0);
15427 /* If we have uploaded versions of the original commands, set up a
15428 special-purpose "reader" function and call the usual command line
15429 reader, then pass the result to the breakpoint command-setting
15431 if (!VEC_empty (char_ptr
, utp
->cmd_strings
))
15433 struct command_line
*cmd_list
;
15438 cmd_list
= read_command_lines_1 (read_uploaded_action
, 1, NULL
, NULL
);
15440 breakpoint_set_commands (&tp
->base
, cmd_list
);
15442 else if (!VEC_empty (char_ptr
, utp
->actions
)
15443 || !VEC_empty (char_ptr
, utp
->step_actions
))
15444 warning (_("Uploaded tracepoint %d actions "
15445 "have no source form, ignoring them"),
15448 /* Copy any status information that might be available. */
15449 tp
->base
.hit_count
= utp
->hit_count
;
15450 tp
->traceframe_usage
= utp
->traceframe_usage
;
15455 /* Print information on tracepoint number TPNUM_EXP, or all if
15459 tracepoints_info (char *args
, int from_tty
)
15461 struct ui_out
*uiout
= current_uiout
;
15464 num_printed
= breakpoint_1 (args
, 0, is_tracepoint
);
15466 if (num_printed
== 0)
15468 if (args
== NULL
|| *args
== '\0')
15469 ui_out_message (uiout
, 0, "No tracepoints.\n");
15471 ui_out_message (uiout
, 0, "No tracepoint matching '%s'.\n", args
);
15474 default_collect_info ();
15477 /* The 'enable trace' command enables tracepoints.
15478 Not supported by all targets. */
15480 enable_trace_command (char *args
, int from_tty
)
15482 enable_command (args
, from_tty
);
15485 /* The 'disable trace' command disables tracepoints.
15486 Not supported by all targets. */
15488 disable_trace_command (char *args
, int from_tty
)
15490 disable_command (args
, from_tty
);
15493 /* Remove a tracepoint (or all if no argument). */
15495 delete_trace_command (char *arg
, int from_tty
)
15497 struct breakpoint
*b
, *b_tmp
;
15503 int breaks_to_delete
= 0;
15505 /* Delete all breakpoints if no argument.
15506 Do not delete internal or call-dummy breakpoints, these
15507 have to be deleted with an explicit breakpoint number
15509 ALL_TRACEPOINTS (b
)
15510 if (is_tracepoint (b
) && user_breakpoint_p (b
))
15512 breaks_to_delete
= 1;
15516 /* Ask user only if there are some breakpoints to delete. */
15518 || (breaks_to_delete
&& query (_("Delete all tracepoints? "))))
15520 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
15521 if (is_tracepoint (b
) && user_breakpoint_p (b
))
15522 delete_breakpoint (b
);
15526 map_breakpoint_numbers (arg
, do_map_delete_breakpoint
, NULL
);
15529 /* Helper function for trace_pass_command. */
15532 trace_pass_set_count (struct tracepoint
*tp
, int count
, int from_tty
)
15534 tp
->pass_count
= count
;
15535 observer_notify_breakpoint_modified (&tp
->base
);
15537 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
15538 tp
->base
.number
, count
);
15541 /* Set passcount for tracepoint.
15543 First command argument is passcount, second is tracepoint number.
15544 If tracepoint number omitted, apply to most recently defined.
15545 Also accepts special argument "all". */
15548 trace_pass_command (char *args
, int from_tty
)
15550 struct tracepoint
*t1
;
15551 unsigned int count
;
15553 if (args
== 0 || *args
== 0)
15554 error (_("passcount command requires an "
15555 "argument (count + optional TP num)"));
15557 count
= strtoul (args
, &args
, 10); /* Count comes first, then TP num. */
15559 args
= skip_spaces (args
);
15560 if (*args
&& strncasecmp (args
, "all", 3) == 0)
15562 struct breakpoint
*b
;
15564 args
+= 3; /* Skip special argument "all". */
15566 error (_("Junk at end of arguments."));
15568 ALL_TRACEPOINTS (b
)
15570 t1
= (struct tracepoint
*) b
;
15571 trace_pass_set_count (t1
, count
, from_tty
);
15574 else if (*args
== '\0')
15576 t1
= get_tracepoint_by_number (&args
, NULL
);
15578 trace_pass_set_count (t1
, count
, from_tty
);
15582 struct get_number_or_range_state state
;
15584 init_number_or_range (&state
, args
);
15585 while (!state
.finished
)
15587 t1
= get_tracepoint_by_number (&args
, &state
);
15589 trace_pass_set_count (t1
, count
, from_tty
);
15594 struct tracepoint
*
15595 get_tracepoint (int num
)
15597 struct breakpoint
*t
;
15599 ALL_TRACEPOINTS (t
)
15600 if (t
->number
== num
)
15601 return (struct tracepoint
*) t
;
15606 /* Find the tracepoint with the given target-side number (which may be
15607 different from the tracepoint number after disconnecting and
15610 struct tracepoint
*
15611 get_tracepoint_by_number_on_target (int num
)
15613 struct breakpoint
*b
;
15615 ALL_TRACEPOINTS (b
)
15617 struct tracepoint
*t
= (struct tracepoint
*) b
;
15619 if (t
->number_on_target
== num
)
15626 /* Utility: parse a tracepoint number and look it up in the list.
15627 If STATE is not NULL, use, get_number_or_range_state and ignore ARG.
15628 If the argument is missing, the most recent tracepoint
15629 (tracepoint_count) is returned. */
15631 struct tracepoint
*
15632 get_tracepoint_by_number (char **arg
,
15633 struct get_number_or_range_state
*state
)
15635 struct breakpoint
*t
;
15637 char *instring
= arg
== NULL
? NULL
: *arg
;
15641 gdb_assert (!state
->finished
);
15642 tpnum
= get_number_or_range (state
);
15644 else if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
15645 tpnum
= tracepoint_count
;
15647 tpnum
= get_number (arg
);
15651 if (instring
&& *instring
)
15652 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
15655 printf_filtered (_("No previous tracepoint\n"));
15659 ALL_TRACEPOINTS (t
)
15660 if (t
->number
== tpnum
)
15662 return (struct tracepoint
*) t
;
15665 printf_unfiltered ("No tracepoint number %d.\n", tpnum
);
15670 print_recreate_thread (struct breakpoint
*b
, struct ui_file
*fp
)
15672 if (b
->thread
!= -1)
15673 fprintf_unfiltered (fp
, " thread %d", b
->thread
);
15676 fprintf_unfiltered (fp
, " task %d", b
->task
);
15678 fprintf_unfiltered (fp
, "\n");
15681 /* Save information on user settable breakpoints (watchpoints, etc) to
15682 a new script file named FILENAME. If FILTER is non-NULL, call it
15683 on each breakpoint and only include the ones for which it returns
15687 save_breakpoints (char *filename
, int from_tty
,
15688 int (*filter
) (const struct breakpoint
*))
15690 struct breakpoint
*tp
;
15692 struct cleanup
*cleanup
;
15693 struct ui_file
*fp
;
15694 int extra_trace_bits
= 0;
15696 if (filename
== 0 || *filename
== 0)
15697 error (_("Argument required (file name in which to save)"));
15699 /* See if we have anything to save. */
15700 ALL_BREAKPOINTS (tp
)
15702 /* Skip internal and momentary breakpoints. */
15703 if (!user_breakpoint_p (tp
))
15706 /* If we have a filter, only save the breakpoints it accepts. */
15707 if (filter
&& !filter (tp
))
15712 if (is_tracepoint (tp
))
15714 extra_trace_bits
= 1;
15716 /* We can stop searching. */
15723 warning (_("Nothing to save."));
15727 filename
= tilde_expand (filename
);
15728 cleanup
= make_cleanup (xfree
, filename
);
15729 fp
= gdb_fopen (filename
, "w");
15731 error (_("Unable to open file '%s' for saving (%s)"),
15732 filename
, safe_strerror (errno
));
15733 make_cleanup_ui_file_delete (fp
);
15735 if (extra_trace_bits
)
15736 save_trace_state_variables (fp
);
15738 ALL_BREAKPOINTS (tp
)
15740 /* Skip internal and momentary breakpoints. */
15741 if (!user_breakpoint_p (tp
))
15744 /* If we have a filter, only save the breakpoints it accepts. */
15745 if (filter
&& !filter (tp
))
15748 tp
->ops
->print_recreate (tp
, fp
);
15750 /* Note, we can't rely on tp->number for anything, as we can't
15751 assume the recreated breakpoint numbers will match. Use $bpnum
15754 if (tp
->cond_string
)
15755 fprintf_unfiltered (fp
, " condition $bpnum %s\n", tp
->cond_string
);
15757 if (tp
->ignore_count
)
15758 fprintf_unfiltered (fp
, " ignore $bpnum %d\n", tp
->ignore_count
);
15760 if (tp
->type
!= bp_dprintf
&& tp
->commands
)
15762 fprintf_unfiltered (fp
, " commands\n");
15764 ui_out_redirect (current_uiout
, fp
);
15767 print_command_lines (current_uiout
, tp
->commands
->commands
, 2);
15769 CATCH (ex
, RETURN_MASK_ALL
)
15771 ui_out_redirect (current_uiout
, NULL
);
15772 throw_exception (ex
);
15776 ui_out_redirect (current_uiout
, NULL
);
15777 fprintf_unfiltered (fp
, " end\n");
15780 if (tp
->enable_state
== bp_disabled
)
15781 fprintf_unfiltered (fp
, "disable $bpnum\n");
15783 /* If this is a multi-location breakpoint, check if the locations
15784 should be individually disabled. Watchpoint locations are
15785 special, and not user visible. */
15786 if (!is_watchpoint (tp
) && tp
->loc
&& tp
->loc
->next
)
15788 struct bp_location
*loc
;
15791 for (loc
= tp
->loc
; loc
!= NULL
; loc
= loc
->next
, n
++)
15793 fprintf_unfiltered (fp
, "disable $bpnum.%d\n", n
);
15797 if (extra_trace_bits
&& *default_collect
)
15798 fprintf_unfiltered (fp
, "set default-collect %s\n", default_collect
);
15801 printf_filtered (_("Saved to file '%s'.\n"), filename
);
15802 do_cleanups (cleanup
);
15805 /* The `save breakpoints' command. */
15808 save_breakpoints_command (char *args
, int from_tty
)
15810 save_breakpoints (args
, from_tty
, NULL
);
15813 /* The `save tracepoints' command. */
15816 save_tracepoints_command (char *args
, int from_tty
)
15818 save_breakpoints (args
, from_tty
, is_tracepoint
);
15821 /* Create a vector of all tracepoints. */
15823 VEC(breakpoint_p
) *
15824 all_tracepoints (void)
15826 VEC(breakpoint_p
) *tp_vec
= 0;
15827 struct breakpoint
*tp
;
15829 ALL_TRACEPOINTS (tp
)
15831 VEC_safe_push (breakpoint_p
, tp_vec
, tp
);
15838 /* This help string is used to consolidate all the help string for specifying
15839 locations used by several commands. */
15841 #define LOCATION_HELP_STRING \
15842 "Linespecs are colon-separated lists of location parameters, such as\n\
15843 source filename, function name, label name, and line number.\n\
15844 Example: To specify the start of a label named \"the_top\" in the\n\
15845 function \"fact\" in the file \"factorial.c\", use\n\
15846 \"factorial.c:fact:the_top\".\n\
15848 Address locations begin with \"*\" and specify an exact address in the\n\
15849 program. Example: To specify the fourth byte past the start function\n\
15850 \"main\", use \"*main + 4\".\n\
15852 Explicit locations are similar to linespecs but use an option/argument\n\
15853 syntax to specify location parameters.\n\
15854 Example: To specify the start of the label named \"the_top\" in the\n\
15855 function \"fact\" in the file \"factorial.c\", use \"-source factorial.c\n\
15856 -function fact -label the_top\".\n"
15858 /* This help string is used for the break, hbreak, tbreak and thbreak
15859 commands. It is defined as a macro to prevent duplication.
15860 COMMAND should be a string constant containing the name of the
15863 #define BREAK_ARGS_HELP(command) \
15864 command" [PROBE_MODIFIER] [LOCATION] [thread THREADNUM] [if CONDITION]\n\
15865 PROBE_MODIFIER shall be present if the command is to be placed in a\n\
15866 probe point. Accepted values are `-probe' (for a generic, automatically\n\
15867 guessed probe type), `-probe-stap' (for a SystemTap probe) or \n\
15868 `-probe-dtrace' (for a DTrace probe).\n\
15869 LOCATION may be a linespec, address, or explicit location as described\n\
15872 With no LOCATION, uses current execution address of the selected\n\
15873 stack frame. This is useful for breaking on return to a stack frame.\n\
15875 THREADNUM is the number from \"info threads\".\n\
15876 CONDITION is a boolean expression.\n\
15877 \n" LOCATION_HELP_STRING "\n\
15878 Multiple breakpoints at one place are permitted, and useful if their\n\
15879 conditions are different.\n\
15881 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
15883 /* List of subcommands for "catch". */
15884 static struct cmd_list_element
*catch_cmdlist
;
15886 /* List of subcommands for "tcatch". */
15887 static struct cmd_list_element
*tcatch_cmdlist
;
15890 add_catch_command (char *name
, char *docstring
,
15891 cmd_sfunc_ftype
*sfunc
,
15892 completer_ftype
*completer
,
15893 void *user_data_catch
,
15894 void *user_data_tcatch
)
15896 struct cmd_list_element
*command
;
15898 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
15900 set_cmd_sfunc (command
, sfunc
);
15901 set_cmd_context (command
, user_data_catch
);
15902 set_cmd_completer (command
, completer
);
15904 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
15906 set_cmd_sfunc (command
, sfunc
);
15907 set_cmd_context (command
, user_data_tcatch
);
15908 set_cmd_completer (command
, completer
);
15912 save_command (char *arg
, int from_tty
)
15914 printf_unfiltered (_("\"save\" must be followed by "
15915 "the name of a save subcommand.\n"));
15916 help_list (save_cmdlist
, "save ", all_commands
, gdb_stdout
);
15919 struct breakpoint
*
15920 iterate_over_breakpoints (int (*callback
) (struct breakpoint
*, void *),
15923 struct breakpoint
*b
, *b_tmp
;
15925 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
15927 if ((*callback
) (b
, data
))
15934 /* Zero if any of the breakpoint's locations could be a location where
15935 functions have been inlined, nonzero otherwise. */
15938 is_non_inline_function (struct breakpoint
*b
)
15940 /* The shared library event breakpoint is set on the address of a
15941 non-inline function. */
15942 if (b
->type
== bp_shlib_event
)
15948 /* Nonzero if the specified PC cannot be a location where functions
15949 have been inlined. */
15952 pc_at_non_inline_function (struct address_space
*aspace
, CORE_ADDR pc
,
15953 const struct target_waitstatus
*ws
)
15955 struct breakpoint
*b
;
15956 struct bp_location
*bl
;
15958 ALL_BREAKPOINTS (b
)
15960 if (!is_non_inline_function (b
))
15963 for (bl
= b
->loc
; bl
!= NULL
; bl
= bl
->next
)
15965 if (!bl
->shlib_disabled
15966 && bpstat_check_location (bl
, aspace
, pc
, ws
))
15974 /* Remove any references to OBJFILE which is going to be freed. */
15977 breakpoint_free_objfile (struct objfile
*objfile
)
15979 struct bp_location
**locp
, *loc
;
15981 ALL_BP_LOCATIONS (loc
, locp
)
15982 if (loc
->symtab
!= NULL
&& SYMTAB_OBJFILE (loc
->symtab
) == objfile
)
15983 loc
->symtab
= NULL
;
15987 initialize_breakpoint_ops (void)
15989 static int initialized
= 0;
15991 struct breakpoint_ops
*ops
;
15997 /* The breakpoint_ops structure to be inherit by all kinds of
15998 breakpoints (real breakpoints, i.e., user "break" breakpoints,
15999 internal and momentary breakpoints, etc.). */
16000 ops
= &bkpt_base_breakpoint_ops
;
16001 *ops
= base_breakpoint_ops
;
16002 ops
->re_set
= bkpt_re_set
;
16003 ops
->insert_location
= bkpt_insert_location
;
16004 ops
->remove_location
= bkpt_remove_location
;
16005 ops
->breakpoint_hit
= bkpt_breakpoint_hit
;
16006 ops
->create_sals_from_location
= bkpt_create_sals_from_location
;
16007 ops
->create_breakpoints_sal
= bkpt_create_breakpoints_sal
;
16008 ops
->decode_location
= bkpt_decode_location
;
16010 /* The breakpoint_ops structure to be used in regular breakpoints. */
16011 ops
= &bkpt_breakpoint_ops
;
16012 *ops
= bkpt_base_breakpoint_ops
;
16013 ops
->re_set
= bkpt_re_set
;
16014 ops
->resources_needed
= bkpt_resources_needed
;
16015 ops
->print_it
= bkpt_print_it
;
16016 ops
->print_mention
= bkpt_print_mention
;
16017 ops
->print_recreate
= bkpt_print_recreate
;
16019 /* Ranged breakpoints. */
16020 ops
= &ranged_breakpoint_ops
;
16021 *ops
= bkpt_breakpoint_ops
;
16022 ops
->breakpoint_hit
= breakpoint_hit_ranged_breakpoint
;
16023 ops
->resources_needed
= resources_needed_ranged_breakpoint
;
16024 ops
->print_it
= print_it_ranged_breakpoint
;
16025 ops
->print_one
= print_one_ranged_breakpoint
;
16026 ops
->print_one_detail
= print_one_detail_ranged_breakpoint
;
16027 ops
->print_mention
= print_mention_ranged_breakpoint
;
16028 ops
->print_recreate
= print_recreate_ranged_breakpoint
;
16030 /* Internal breakpoints. */
16031 ops
= &internal_breakpoint_ops
;
16032 *ops
= bkpt_base_breakpoint_ops
;
16033 ops
->re_set
= internal_bkpt_re_set
;
16034 ops
->check_status
= internal_bkpt_check_status
;
16035 ops
->print_it
= internal_bkpt_print_it
;
16036 ops
->print_mention
= internal_bkpt_print_mention
;
16038 /* Momentary breakpoints. */
16039 ops
= &momentary_breakpoint_ops
;
16040 *ops
= bkpt_base_breakpoint_ops
;
16041 ops
->re_set
= momentary_bkpt_re_set
;
16042 ops
->check_status
= momentary_bkpt_check_status
;
16043 ops
->print_it
= momentary_bkpt_print_it
;
16044 ops
->print_mention
= momentary_bkpt_print_mention
;
16046 /* Momentary breakpoints for bp_longjmp and bp_exception. */
16047 ops
= &longjmp_breakpoint_ops
;
16048 *ops
= momentary_breakpoint_ops
;
16049 ops
->dtor
= longjmp_bkpt_dtor
;
16051 /* Probe breakpoints. */
16052 ops
= &bkpt_probe_breakpoint_ops
;
16053 *ops
= bkpt_breakpoint_ops
;
16054 ops
->insert_location
= bkpt_probe_insert_location
;
16055 ops
->remove_location
= bkpt_probe_remove_location
;
16056 ops
->create_sals_from_location
= bkpt_probe_create_sals_from_location
;
16057 ops
->decode_location
= bkpt_probe_decode_location
;
16060 ops
= &watchpoint_breakpoint_ops
;
16061 *ops
= base_breakpoint_ops
;
16062 ops
->dtor
= dtor_watchpoint
;
16063 ops
->re_set
= re_set_watchpoint
;
16064 ops
->insert_location
= insert_watchpoint
;
16065 ops
->remove_location
= remove_watchpoint
;
16066 ops
->breakpoint_hit
= breakpoint_hit_watchpoint
;
16067 ops
->check_status
= check_status_watchpoint
;
16068 ops
->resources_needed
= resources_needed_watchpoint
;
16069 ops
->works_in_software_mode
= works_in_software_mode_watchpoint
;
16070 ops
->print_it
= print_it_watchpoint
;
16071 ops
->print_mention
= print_mention_watchpoint
;
16072 ops
->print_recreate
= print_recreate_watchpoint
;
16073 ops
->explains_signal
= explains_signal_watchpoint
;
16075 /* Masked watchpoints. */
16076 ops
= &masked_watchpoint_breakpoint_ops
;
16077 *ops
= watchpoint_breakpoint_ops
;
16078 ops
->insert_location
= insert_masked_watchpoint
;
16079 ops
->remove_location
= remove_masked_watchpoint
;
16080 ops
->resources_needed
= resources_needed_masked_watchpoint
;
16081 ops
->works_in_software_mode
= works_in_software_mode_masked_watchpoint
;
16082 ops
->print_it
= print_it_masked_watchpoint
;
16083 ops
->print_one_detail
= print_one_detail_masked_watchpoint
;
16084 ops
->print_mention
= print_mention_masked_watchpoint
;
16085 ops
->print_recreate
= print_recreate_masked_watchpoint
;
16088 ops
= &tracepoint_breakpoint_ops
;
16089 *ops
= base_breakpoint_ops
;
16090 ops
->re_set
= tracepoint_re_set
;
16091 ops
->breakpoint_hit
= tracepoint_breakpoint_hit
;
16092 ops
->print_one_detail
= tracepoint_print_one_detail
;
16093 ops
->print_mention
= tracepoint_print_mention
;
16094 ops
->print_recreate
= tracepoint_print_recreate
;
16095 ops
->create_sals_from_location
= tracepoint_create_sals_from_location
;
16096 ops
->create_breakpoints_sal
= tracepoint_create_breakpoints_sal
;
16097 ops
->decode_location
= tracepoint_decode_location
;
16099 /* Probe tracepoints. */
16100 ops
= &tracepoint_probe_breakpoint_ops
;
16101 *ops
= tracepoint_breakpoint_ops
;
16102 ops
->create_sals_from_location
= tracepoint_probe_create_sals_from_location
;
16103 ops
->decode_location
= tracepoint_probe_decode_location
;
16105 /* Static tracepoints with marker (`-m'). */
16106 ops
= &strace_marker_breakpoint_ops
;
16107 *ops
= tracepoint_breakpoint_ops
;
16108 ops
->create_sals_from_location
= strace_marker_create_sals_from_location
;
16109 ops
->create_breakpoints_sal
= strace_marker_create_breakpoints_sal
;
16110 ops
->decode_location
= strace_marker_decode_location
;
16112 /* Fork catchpoints. */
16113 ops
= &catch_fork_breakpoint_ops
;
16114 *ops
= base_breakpoint_ops
;
16115 ops
->insert_location
= insert_catch_fork
;
16116 ops
->remove_location
= remove_catch_fork
;
16117 ops
->breakpoint_hit
= breakpoint_hit_catch_fork
;
16118 ops
->print_it
= print_it_catch_fork
;
16119 ops
->print_one
= print_one_catch_fork
;
16120 ops
->print_mention
= print_mention_catch_fork
;
16121 ops
->print_recreate
= print_recreate_catch_fork
;
16123 /* Vfork catchpoints. */
16124 ops
= &catch_vfork_breakpoint_ops
;
16125 *ops
= base_breakpoint_ops
;
16126 ops
->insert_location
= insert_catch_vfork
;
16127 ops
->remove_location
= remove_catch_vfork
;
16128 ops
->breakpoint_hit
= breakpoint_hit_catch_vfork
;
16129 ops
->print_it
= print_it_catch_vfork
;
16130 ops
->print_one
= print_one_catch_vfork
;
16131 ops
->print_mention
= print_mention_catch_vfork
;
16132 ops
->print_recreate
= print_recreate_catch_vfork
;
16134 /* Exec catchpoints. */
16135 ops
= &catch_exec_breakpoint_ops
;
16136 *ops
= base_breakpoint_ops
;
16137 ops
->dtor
= dtor_catch_exec
;
16138 ops
->insert_location
= insert_catch_exec
;
16139 ops
->remove_location
= remove_catch_exec
;
16140 ops
->breakpoint_hit
= breakpoint_hit_catch_exec
;
16141 ops
->print_it
= print_it_catch_exec
;
16142 ops
->print_one
= print_one_catch_exec
;
16143 ops
->print_mention
= print_mention_catch_exec
;
16144 ops
->print_recreate
= print_recreate_catch_exec
;
16146 /* Solib-related catchpoints. */
16147 ops
= &catch_solib_breakpoint_ops
;
16148 *ops
= base_breakpoint_ops
;
16149 ops
->dtor
= dtor_catch_solib
;
16150 ops
->insert_location
= insert_catch_solib
;
16151 ops
->remove_location
= remove_catch_solib
;
16152 ops
->breakpoint_hit
= breakpoint_hit_catch_solib
;
16153 ops
->check_status
= check_status_catch_solib
;
16154 ops
->print_it
= print_it_catch_solib
;
16155 ops
->print_one
= print_one_catch_solib
;
16156 ops
->print_mention
= print_mention_catch_solib
;
16157 ops
->print_recreate
= print_recreate_catch_solib
;
16159 ops
= &dprintf_breakpoint_ops
;
16160 *ops
= bkpt_base_breakpoint_ops
;
16161 ops
->re_set
= dprintf_re_set
;
16162 ops
->resources_needed
= bkpt_resources_needed
;
16163 ops
->print_it
= bkpt_print_it
;
16164 ops
->print_mention
= bkpt_print_mention
;
16165 ops
->print_recreate
= dprintf_print_recreate
;
16166 ops
->after_condition_true
= dprintf_after_condition_true
;
16167 ops
->breakpoint_hit
= dprintf_breakpoint_hit
;
16170 /* Chain containing all defined "enable breakpoint" subcommands. */
16172 static struct cmd_list_element
*enablebreaklist
= NULL
;
16175 _initialize_breakpoint (void)
16177 struct cmd_list_element
*c
;
16179 initialize_breakpoint_ops ();
16181 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
16182 observer_attach_free_objfile (disable_breakpoints_in_freed_objfile
);
16183 observer_attach_memory_changed (invalidate_bp_value_on_memory_change
);
16185 breakpoint_objfile_key
16186 = register_objfile_data_with_cleanup (NULL
, free_breakpoint_probes
);
16188 breakpoint_chain
= 0;
16189 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
16190 before a breakpoint is set. */
16191 breakpoint_count
= 0;
16193 tracepoint_count
= 0;
16195 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
16196 Set ignore-count of breakpoint number N to COUNT.\n\
16197 Usage is `ignore N COUNT'."));
16199 add_com ("commands", class_breakpoint
, commands_command
, _("\
16200 Set commands to be executed when a breakpoint is hit.\n\
16201 Give breakpoint number as argument after \"commands\".\n\
16202 With no argument, the targeted breakpoint is the last one set.\n\
16203 The commands themselves follow starting on the next line.\n\
16204 Type a line containing \"end\" to indicate the end of them.\n\
16205 Give \"silent\" as the first line to make the breakpoint silent;\n\
16206 then no output is printed when it is hit, except what the commands print."));
16208 c
= add_com ("condition", class_breakpoint
, condition_command
, _("\
16209 Specify breakpoint number N to break only if COND is true.\n\
16210 Usage is `condition N COND', where N is an integer and COND is an\n\
16211 expression to be evaluated whenever breakpoint N is reached."));
16212 set_cmd_completer (c
, condition_completer
);
16214 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
16215 Set a temporary breakpoint.\n\
16216 Like \"break\" except the breakpoint is only temporary,\n\
16217 so it will be deleted when hit. Equivalent to \"break\" followed\n\
16218 by using \"enable delete\" on the breakpoint number.\n\
16220 BREAK_ARGS_HELP ("tbreak")));
16221 set_cmd_completer (c
, location_completer
);
16223 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
16224 Set a hardware assisted breakpoint.\n\
16225 Like \"break\" except the breakpoint requires hardware support,\n\
16226 some target hardware may not have this support.\n\
16228 BREAK_ARGS_HELP ("hbreak")));
16229 set_cmd_completer (c
, location_completer
);
16231 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
16232 Set a temporary hardware assisted breakpoint.\n\
16233 Like \"hbreak\" except the breakpoint is only temporary,\n\
16234 so it will be deleted when hit.\n\
16236 BREAK_ARGS_HELP ("thbreak")));
16237 set_cmd_completer (c
, location_completer
);
16239 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
16240 Enable some breakpoints.\n\
16241 Give breakpoint numbers (separated by spaces) as arguments.\n\
16242 With no subcommand, breakpoints are enabled until you command otherwise.\n\
16243 This is used to cancel the effect of the \"disable\" command.\n\
16244 With a subcommand you can enable temporarily."),
16245 &enablelist
, "enable ", 1, &cmdlist
);
16247 add_com_alias ("en", "enable", class_breakpoint
, 1);
16249 add_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
16250 Enable some breakpoints.\n\
16251 Give breakpoint numbers (separated by spaces) as arguments.\n\
16252 This is used to cancel the effect of the \"disable\" command.\n\
16253 May be abbreviated to simply \"enable\".\n"),
16254 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
16256 add_cmd ("once", no_class
, enable_once_command
, _("\
16257 Enable breakpoints for one hit. Give breakpoint numbers.\n\
16258 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
16261 add_cmd ("delete", no_class
, enable_delete_command
, _("\
16262 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
16263 If a breakpoint is hit while enabled in this fashion, it is deleted."),
16266 add_cmd ("count", no_class
, enable_count_command
, _("\
16267 Enable breakpoints for COUNT hits. Give count and then breakpoint numbers.\n\
16268 If a breakpoint is hit while enabled in this fashion,\n\
16269 the count is decremented; when it reaches zero, the breakpoint is disabled."),
16272 add_cmd ("delete", no_class
, enable_delete_command
, _("\
16273 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
16274 If a breakpoint is hit while enabled in this fashion, it is deleted."),
16277 add_cmd ("once", no_class
, enable_once_command
, _("\
16278 Enable breakpoints for one hit. Give breakpoint numbers.\n\
16279 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
16282 add_cmd ("count", no_class
, enable_count_command
, _("\
16283 Enable breakpoints for COUNT hits. Give count and then breakpoint numbers.\n\
16284 If a breakpoint is hit while enabled in this fashion,\n\
16285 the count is decremented; when it reaches zero, the breakpoint is disabled."),
16288 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
16289 Disable some breakpoints.\n\
16290 Arguments are breakpoint numbers with spaces in between.\n\
16291 To disable all breakpoints, give no argument.\n\
16292 A disabled breakpoint is not forgotten, but has no effect until re-enabled."),
16293 &disablelist
, "disable ", 1, &cmdlist
);
16294 add_com_alias ("dis", "disable", class_breakpoint
, 1);
16295 add_com_alias ("disa", "disable", class_breakpoint
, 1);
16297 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
16298 Disable some breakpoints.\n\
16299 Arguments are breakpoint numbers with spaces in between.\n\
16300 To disable all breakpoints, give no argument.\n\
16301 A disabled breakpoint is not forgotten, but has no effect until re-enabled.\n\
16302 This command may be abbreviated \"disable\"."),
16305 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
16306 Delete some breakpoints or auto-display expressions.\n\
16307 Arguments are breakpoint numbers with spaces in between.\n\
16308 To delete all breakpoints, give no argument.\n\
16310 Also a prefix command for deletion of other GDB objects.\n\
16311 The \"unset\" command is also an alias for \"delete\"."),
16312 &deletelist
, "delete ", 1, &cmdlist
);
16313 add_com_alias ("d", "delete", class_breakpoint
, 1);
16314 add_com_alias ("del", "delete", class_breakpoint
, 1);
16316 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
16317 Delete some breakpoints or auto-display expressions.\n\
16318 Arguments are breakpoint numbers with spaces in between.\n\
16319 To delete all breakpoints, give no argument.\n\
16320 This command may be abbreviated \"delete\"."),
16323 add_com ("clear", class_breakpoint
, clear_command
, _("\
16324 Clear breakpoint at specified location.\n\
16325 Argument may be a linespec, explicit, or address location as described below.\n\
16327 With no argument, clears all breakpoints in the line that the selected frame\n\
16328 is executing in.\n"
16329 "\n" LOCATION_HELP_STRING
"\n\
16330 See also the \"delete\" command which clears breakpoints by number."));
16331 add_com_alias ("cl", "clear", class_breakpoint
, 1);
16333 c
= add_com ("break", class_breakpoint
, break_command
, _("\
16334 Set breakpoint at specified location.\n"
16335 BREAK_ARGS_HELP ("break")));
16336 set_cmd_completer (c
, location_completer
);
16338 add_com_alias ("b", "break", class_run
, 1);
16339 add_com_alias ("br", "break", class_run
, 1);
16340 add_com_alias ("bre", "break", class_run
, 1);
16341 add_com_alias ("brea", "break", class_run
, 1);
16345 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
16346 Break in function/address or break at a line in the current file."),
16347 &stoplist
, "stop ", 1, &cmdlist
);
16348 add_cmd ("in", class_breakpoint
, stopin_command
,
16349 _("Break in function or address."), &stoplist
);
16350 add_cmd ("at", class_breakpoint
, stopat_command
,
16351 _("Break at a line in the current file."), &stoplist
);
16352 add_com ("status", class_info
, breakpoints_info
, _("\
16353 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
16354 The \"Type\" column indicates one of:\n\
16355 \tbreakpoint - normal breakpoint\n\
16356 \twatchpoint - watchpoint\n\
16357 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
16358 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
16359 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
16360 address and file/line number respectively.\n\
16362 Convenience variable \"$_\" and default examine address for \"x\"\n\
16363 are set to the address of the last breakpoint listed unless the command\n\
16364 is prefixed with \"server \".\n\n\
16365 Convenience variable \"$bpnum\" contains the number of the last\n\
16366 breakpoint set."));
16369 add_info ("breakpoints", breakpoints_info
, _("\
16370 Status of specified breakpoints (all user-settable breakpoints if no argument).\n\
16371 The \"Type\" column indicates one of:\n\
16372 \tbreakpoint - normal breakpoint\n\
16373 \twatchpoint - watchpoint\n\
16374 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
16375 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
16376 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
16377 address and file/line number respectively.\n\
16379 Convenience variable \"$_\" and default examine address for \"x\"\n\
16380 are set to the address of the last breakpoint listed unless the command\n\
16381 is prefixed with \"server \".\n\n\
16382 Convenience variable \"$bpnum\" contains the number of the last\n\
16383 breakpoint set."));
16385 add_info_alias ("b", "breakpoints", 1);
16387 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
16388 Status of all breakpoints, or breakpoint number NUMBER.\n\
16389 The \"Type\" column indicates one of:\n\
16390 \tbreakpoint - normal breakpoint\n\
16391 \twatchpoint - watchpoint\n\
16392 \tlongjmp - internal breakpoint used to step through longjmp()\n\
16393 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
16394 \tuntil - internal breakpoint used by the \"until\" command\n\
16395 \tfinish - internal breakpoint used by the \"finish\" command\n\
16396 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
16397 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
16398 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
16399 address and file/line number respectively.\n\
16401 Convenience variable \"$_\" and default examine address for \"x\"\n\
16402 are set to the address of the last breakpoint listed unless the command\n\
16403 is prefixed with \"server \".\n\n\
16404 Convenience variable \"$bpnum\" contains the number of the last\n\
16406 &maintenanceinfolist
);
16408 add_prefix_cmd ("catch", class_breakpoint
, catch_command
, _("\
16409 Set catchpoints to catch events."),
16410 &catch_cmdlist
, "catch ",
16411 0/*allow-unknown*/, &cmdlist
);
16413 add_prefix_cmd ("tcatch", class_breakpoint
, tcatch_command
, _("\
16414 Set temporary catchpoints to catch events."),
16415 &tcatch_cmdlist
, "tcatch ",
16416 0/*allow-unknown*/, &cmdlist
);
16418 add_catch_command ("fork", _("Catch calls to fork."),
16419 catch_fork_command_1
,
16421 (void *) (uintptr_t) catch_fork_permanent
,
16422 (void *) (uintptr_t) catch_fork_temporary
);
16423 add_catch_command ("vfork", _("Catch calls to vfork."),
16424 catch_fork_command_1
,
16426 (void *) (uintptr_t) catch_vfork_permanent
,
16427 (void *) (uintptr_t) catch_vfork_temporary
);
16428 add_catch_command ("exec", _("Catch calls to exec."),
16429 catch_exec_command_1
,
16433 add_catch_command ("load", _("Catch loads of shared libraries.\n\
16434 Usage: catch load [REGEX]\n\
16435 If REGEX is given, only stop for libraries matching the regular expression."),
16436 catch_load_command_1
,
16440 add_catch_command ("unload", _("Catch unloads of shared libraries.\n\
16441 Usage: catch unload [REGEX]\n\
16442 If REGEX is given, only stop for libraries matching the regular expression."),
16443 catch_unload_command_1
,
16448 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
16449 Set a watchpoint for an expression.\n\
16450 Usage: watch [-l|-location] EXPRESSION\n\
16451 A watchpoint stops execution of your program whenever the value of\n\
16452 an expression changes.\n\
16453 If -l or -location is given, this evaluates EXPRESSION and watches\n\
16454 the memory to which it refers."));
16455 set_cmd_completer (c
, expression_completer
);
16457 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
16458 Set a read watchpoint for an expression.\n\
16459 Usage: rwatch [-l|-location] EXPRESSION\n\
16460 A watchpoint stops execution of your program whenever the value of\n\
16461 an expression is read.\n\
16462 If -l or -location is given, this evaluates EXPRESSION and watches\n\
16463 the memory to which it refers."));
16464 set_cmd_completer (c
, expression_completer
);
16466 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
16467 Set a watchpoint for an expression.\n\
16468 Usage: awatch [-l|-location] EXPRESSION\n\
16469 A watchpoint stops execution of your program whenever the value of\n\
16470 an expression is either read or written.\n\
16471 If -l or -location is given, this evaluates EXPRESSION and watches\n\
16472 the memory to which it refers."));
16473 set_cmd_completer (c
, expression_completer
);
16475 add_info ("watchpoints", watchpoints_info
, _("\
16476 Status of specified watchpoints (all watchpoints if no argument)."));
16478 /* XXX: cagney/2005-02-23: This should be a boolean, and should
16479 respond to changes - contrary to the description. */
16480 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
16481 &can_use_hw_watchpoints
, _("\
16482 Set debugger's willingness to use watchpoint hardware."), _("\
16483 Show debugger's willingness to use watchpoint hardware."), _("\
16484 If zero, gdb will not use hardware for new watchpoints, even if\n\
16485 such is available. (However, any hardware watchpoints that were\n\
16486 created before setting this to nonzero, will continue to use watchpoint\n\
16489 show_can_use_hw_watchpoints
,
16490 &setlist
, &showlist
);
16492 can_use_hw_watchpoints
= 1;
16494 /* Tracepoint manipulation commands. */
16496 c
= add_com ("trace", class_breakpoint
, trace_command
, _("\
16497 Set a tracepoint at specified location.\n\
16499 BREAK_ARGS_HELP ("trace") "\n\
16500 Do \"help tracepoints\" for info on other tracepoint commands."));
16501 set_cmd_completer (c
, location_completer
);
16503 add_com_alias ("tp", "trace", class_alias
, 0);
16504 add_com_alias ("tr", "trace", class_alias
, 1);
16505 add_com_alias ("tra", "trace", class_alias
, 1);
16506 add_com_alias ("trac", "trace", class_alias
, 1);
16508 c
= add_com ("ftrace", class_breakpoint
, ftrace_command
, _("\
16509 Set a fast tracepoint at specified location.\n\
16511 BREAK_ARGS_HELP ("ftrace") "\n\
16512 Do \"help tracepoints\" for info on other tracepoint commands."));
16513 set_cmd_completer (c
, location_completer
);
16515 c
= add_com ("strace", class_breakpoint
, strace_command
, _("\
16516 Set a static tracepoint at location or marker.\n\
16518 strace [LOCATION] [if CONDITION]\n\
16519 LOCATION may be a linespec, explicit, or address location (described below) \n\
16520 or -m MARKER_ID.\n\n\
16521 If a marker id is specified, probe the marker with that name. With\n\
16522 no LOCATION, uses current execution address of the selected stack frame.\n\
16523 Static tracepoints accept an extra collect action -- ``collect $_sdata''.\n\
16524 This collects arbitrary user data passed in the probe point call to the\n\
16525 tracing library. You can inspect it when analyzing the trace buffer,\n\
16526 by printing the $_sdata variable like any other convenience variable.\n\
16528 CONDITION is a boolean expression.\n\
16529 \n" LOCATION_HELP_STRING
"\n\
16530 Multiple tracepoints at one place are permitted, and useful if their\n\
16531 conditions are different.\n\
16533 Do \"help breakpoints\" for info on other commands dealing with breakpoints.\n\
16534 Do \"help tracepoints\" for info on other tracepoint commands."));
16535 set_cmd_completer (c
, location_completer
);
16537 add_info ("tracepoints", tracepoints_info
, _("\
16538 Status of specified tracepoints (all tracepoints if no argument).\n\
16539 Convenience variable \"$tpnum\" contains the number of the\n\
16540 last tracepoint set."));
16542 add_info_alias ("tp", "tracepoints", 1);
16544 add_cmd ("tracepoints", class_trace
, delete_trace_command
, _("\
16545 Delete specified tracepoints.\n\
16546 Arguments are tracepoint numbers, separated by spaces.\n\
16547 No argument means delete all tracepoints."),
16549 add_alias_cmd ("tr", "tracepoints", class_trace
, 1, &deletelist
);
16551 c
= add_cmd ("tracepoints", class_trace
, disable_trace_command
, _("\
16552 Disable specified tracepoints.\n\
16553 Arguments are tracepoint numbers, separated by spaces.\n\
16554 No argument means disable all tracepoints."),
16556 deprecate_cmd (c
, "disable");
16558 c
= add_cmd ("tracepoints", class_trace
, enable_trace_command
, _("\
16559 Enable specified tracepoints.\n\
16560 Arguments are tracepoint numbers, separated by spaces.\n\
16561 No argument means enable all tracepoints."),
16563 deprecate_cmd (c
, "enable");
16565 add_com ("passcount", class_trace
, trace_pass_command
, _("\
16566 Set the passcount for a tracepoint.\n\
16567 The trace will end when the tracepoint has been passed 'count' times.\n\
16568 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
16569 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
16571 add_prefix_cmd ("save", class_breakpoint
, save_command
,
16572 _("Save breakpoint definitions as a script."),
16573 &save_cmdlist
, "save ",
16574 0/*allow-unknown*/, &cmdlist
);
16576 c
= add_cmd ("breakpoints", class_breakpoint
, save_breakpoints_command
, _("\
16577 Save current breakpoint definitions as a script.\n\
16578 This includes all types of breakpoints (breakpoints, watchpoints,\n\
16579 catchpoints, tracepoints). Use the 'source' command in another debug\n\
16580 session to restore them."),
16582 set_cmd_completer (c
, filename_completer
);
16584 c
= add_cmd ("tracepoints", class_trace
, save_tracepoints_command
, _("\
16585 Save current tracepoint definitions as a script.\n\
16586 Use the 'source' command in another debug session to restore them."),
16588 set_cmd_completer (c
, filename_completer
);
16590 c
= add_com_alias ("save-tracepoints", "save tracepoints", class_trace
, 0);
16591 deprecate_cmd (c
, "save tracepoints");
16593 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
16594 Breakpoint specific settings\n\
16595 Configure various breakpoint-specific variables such as\n\
16596 pending breakpoint behavior"),
16597 &breakpoint_set_cmdlist
, "set breakpoint ",
16598 0/*allow-unknown*/, &setlist
);
16599 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
16600 Breakpoint specific settings\n\
16601 Configure various breakpoint-specific variables such as\n\
16602 pending breakpoint behavior"),
16603 &breakpoint_show_cmdlist
, "show breakpoint ",
16604 0/*allow-unknown*/, &showlist
);
16606 add_setshow_auto_boolean_cmd ("pending", no_class
,
16607 &pending_break_support
, _("\
16608 Set debugger's behavior regarding pending breakpoints."), _("\
16609 Show debugger's behavior regarding pending breakpoints."), _("\
16610 If on, an unrecognized breakpoint location will cause gdb to create a\n\
16611 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
16612 an error. If auto, an unrecognized breakpoint location results in a\n\
16613 user-query to see if a pending breakpoint should be created."),
16615 show_pending_break_support
,
16616 &breakpoint_set_cmdlist
,
16617 &breakpoint_show_cmdlist
);
16619 pending_break_support
= AUTO_BOOLEAN_AUTO
;
16621 add_setshow_boolean_cmd ("auto-hw", no_class
,
16622 &automatic_hardware_breakpoints
, _("\
16623 Set automatic usage of hardware breakpoints."), _("\
16624 Show automatic usage of hardware breakpoints."), _("\
16625 If set, the debugger will automatically use hardware breakpoints for\n\
16626 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
16627 a warning will be emitted for such breakpoints."),
16629 show_automatic_hardware_breakpoints
,
16630 &breakpoint_set_cmdlist
,
16631 &breakpoint_show_cmdlist
);
16633 add_setshow_boolean_cmd ("always-inserted", class_support
,
16634 &always_inserted_mode
, _("\
16635 Set mode for inserting breakpoints."), _("\
16636 Show mode for inserting breakpoints."), _("\
16637 When this mode is on, breakpoints are inserted immediately as soon as\n\
16638 they're created, kept inserted even when execution stops, and removed\n\
16639 only when the user deletes them. When this mode is off (the default),\n\
16640 breakpoints are inserted only when execution continues, and removed\n\
16641 when execution stops."),
16643 &show_always_inserted_mode
,
16644 &breakpoint_set_cmdlist
,
16645 &breakpoint_show_cmdlist
);
16647 add_setshow_enum_cmd ("condition-evaluation", class_breakpoint
,
16648 condition_evaluation_enums
,
16649 &condition_evaluation_mode_1
, _("\
16650 Set mode of breakpoint condition evaluation."), _("\
16651 Show mode of breakpoint condition evaluation."), _("\
16652 When this is set to \"host\", breakpoint conditions will be\n\
16653 evaluated on the host's side by GDB. When it is set to \"target\",\n\
16654 breakpoint conditions will be downloaded to the target (if the target\n\
16655 supports such feature) and conditions will be evaluated on the target's side.\n\
16656 If this is set to \"auto\" (default), this will be automatically set to\n\
16657 \"target\" if it supports condition evaluation, otherwise it will\n\
16658 be set to \"gdb\""),
16659 &set_condition_evaluation_mode
,
16660 &show_condition_evaluation_mode
,
16661 &breakpoint_set_cmdlist
,
16662 &breakpoint_show_cmdlist
);
16664 add_com ("break-range", class_breakpoint
, break_range_command
, _("\
16665 Set a breakpoint for an address range.\n\
16666 break-range START-LOCATION, END-LOCATION\n\
16667 where START-LOCATION and END-LOCATION can be one of the following:\n\
16668 LINENUM, for that line in the current file,\n\
16669 FILE:LINENUM, for that line in that file,\n\
16670 +OFFSET, for that number of lines after the current line\n\
16671 or the start of the range\n\
16672 FUNCTION, for the first line in that function,\n\
16673 FILE:FUNCTION, to distinguish among like-named static functions.\n\
16674 *ADDRESS, for the instruction at that address.\n\
16676 The breakpoint will stop execution of the inferior whenever it executes\n\
16677 an instruction at any address within the [START-LOCATION, END-LOCATION]\n\
16678 range (including START-LOCATION and END-LOCATION)."));
16680 c
= add_com ("dprintf", class_breakpoint
, dprintf_command
, _("\
16681 Set a dynamic printf at specified location.\n\
16682 dprintf location,format string,arg1,arg2,...\n\
16683 location may be a linespec, explicit, or address location.\n"
16684 "\n" LOCATION_HELP_STRING
));
16685 set_cmd_completer (c
, location_completer
);
16687 add_setshow_enum_cmd ("dprintf-style", class_support
,
16688 dprintf_style_enums
, &dprintf_style
, _("\
16689 Set the style of usage for dynamic printf."), _("\
16690 Show the style of usage for dynamic printf."), _("\
16691 This setting chooses how GDB will do a dynamic printf.\n\
16692 If the value is \"gdb\", then the printing is done by GDB to its own\n\
16693 console, as with the \"printf\" command.\n\
16694 If the value is \"call\", the print is done by calling a function in your\n\
16695 program; by default printf(), but you can choose a different function or\n\
16696 output stream by setting dprintf-function and dprintf-channel."),
16697 update_dprintf_commands
, NULL
,
16698 &setlist
, &showlist
);
16700 dprintf_function
= xstrdup ("printf");
16701 add_setshow_string_cmd ("dprintf-function", class_support
,
16702 &dprintf_function
, _("\
16703 Set the function to use for dynamic printf"), _("\
16704 Show the function to use for dynamic printf"), NULL
,
16705 update_dprintf_commands
, NULL
,
16706 &setlist
, &showlist
);
16708 dprintf_channel
= xstrdup ("");
16709 add_setshow_string_cmd ("dprintf-channel", class_support
,
16710 &dprintf_channel
, _("\
16711 Set the channel to use for dynamic printf"), _("\
16712 Show the channel to use for dynamic printf"), NULL
,
16713 update_dprintf_commands
, NULL
,
16714 &setlist
, &showlist
);
16716 add_setshow_boolean_cmd ("disconnected-dprintf", no_class
,
16717 &disconnected_dprintf
, _("\
16718 Set whether dprintf continues after GDB disconnects."), _("\
16719 Show whether dprintf continues after GDB disconnects."), _("\
16720 Use this to let dprintf commands continue to hit and produce output\n\
16721 even if GDB disconnects or detaches from the target."),
16724 &setlist
, &showlist
);
16726 add_com ("agent-printf", class_vars
, agent_printf_command
, _("\
16727 agent-printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
16728 (target agent only) This is useful for formatted output in user-defined commands."));
16730 automatic_hardware_breakpoints
= 1;
16732 observer_attach_about_to_proceed (breakpoint_about_to_proceed
);
16733 observer_attach_thread_exit (remove_threaded_breakpoints
);