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"
85 /* Enums for exception-handling support. */
86 enum exception_event_kind
93 /* Prototypes for local functions. */
95 static void enable_delete_command (char *, int);
97 static void enable_once_command (char *, int);
99 static void enable_count_command (char *, int);
101 static void disable_command (char *, int);
103 static void enable_command (char *, int);
105 static void map_breakpoint_numbers (const char *,
106 void (*) (struct breakpoint
*,
110 static void ignore_command (char *, int);
112 static int breakpoint_re_set_one (void *);
114 static void breakpoint_re_set_default (struct breakpoint
*);
117 create_sals_from_location_default (const struct event_location
*location
,
118 struct linespec_result
*canonical
,
119 enum bptype type_wanted
);
121 static void create_breakpoints_sal_default (struct gdbarch
*,
122 struct linespec_result
*,
123 char *, char *, enum bptype
,
124 enum bpdisp
, int, int,
126 const struct breakpoint_ops
*,
127 int, int, int, unsigned);
129 static void decode_location_default (struct breakpoint
*b
,
130 const struct event_location
*location
,
131 struct program_space
*search_pspace
,
132 struct symtabs_and_lines
*sals
);
134 static void clear_command (char *, int);
136 static void catch_command (char *, int);
138 static int can_use_hardware_watchpoint (struct value
*);
140 static void break_command_1 (char *, int, int);
142 static void mention (struct breakpoint
*);
144 static struct breakpoint
*set_raw_breakpoint_without_location (struct gdbarch
*,
146 const struct breakpoint_ops
*);
147 static struct bp_location
*add_location_to_breakpoint (struct breakpoint
*,
148 const struct symtab_and_line
*);
150 /* This function is used in gdbtk sources and thus can not be made
152 struct breakpoint
*set_raw_breakpoint (struct gdbarch
*gdbarch
,
153 struct symtab_and_line
,
155 const struct breakpoint_ops
*);
157 static struct breakpoint
*
158 momentary_breakpoint_from_master (struct breakpoint
*orig
,
160 const struct breakpoint_ops
*ops
,
163 static void breakpoint_adjustment_warning (CORE_ADDR
, CORE_ADDR
, int, int);
165 static CORE_ADDR
adjust_breakpoint_address (struct gdbarch
*gdbarch
,
169 static void describe_other_breakpoints (struct gdbarch
*,
170 struct program_space
*, CORE_ADDR
,
171 struct obj_section
*, int);
173 static int watchpoint_locations_match (struct bp_location
*loc1
,
174 struct bp_location
*loc2
);
176 static int breakpoint_location_address_match (struct bp_location
*bl
,
177 struct address_space
*aspace
,
180 static int breakpoint_location_address_range_overlap (struct bp_location
*,
181 struct address_space
*,
184 static void breakpoints_info (char *, int);
186 static void watchpoints_info (char *, int);
188 static int breakpoint_1 (char *, int,
189 int (*) (const struct breakpoint
*));
191 static int breakpoint_cond_eval (void *);
193 static void cleanup_executing_breakpoints (void *);
195 static void commands_command (char *, int);
197 static void condition_command (char *, int);
199 static int remove_breakpoint (struct bp_location
*);
200 static int remove_breakpoint_1 (struct bp_location
*, enum remove_bp_reason
);
202 static enum print_stop_action
print_bp_stop_message (bpstat bs
);
204 static int watchpoint_check (void *);
206 static void maintenance_info_breakpoints (char *, int);
208 static int hw_breakpoint_used_count (void);
210 static int hw_watchpoint_use_count (struct breakpoint
*);
212 static int hw_watchpoint_used_count_others (struct breakpoint
*except
,
214 int *other_type_used
);
216 static void hbreak_command (char *, int);
218 static void thbreak_command (char *, int);
220 static void enable_breakpoint_disp (struct breakpoint
*, enum bpdisp
,
223 static void stop_command (char *arg
, int from_tty
);
225 static void stopin_command (char *arg
, int from_tty
);
227 static void stopat_command (char *arg
, int from_tty
);
229 static void tcatch_command (char *arg
, int from_tty
);
231 static void free_bp_location (struct bp_location
*loc
);
232 static void incref_bp_location (struct bp_location
*loc
);
233 static void decref_bp_location (struct bp_location
**loc
);
235 static struct bp_location
*allocate_bp_location (struct breakpoint
*bpt
);
237 /* update_global_location_list's modes of operation wrt to whether to
238 insert locations now. */
239 enum ugll_insert_mode
241 /* Don't insert any breakpoint locations into the inferior, only
242 remove already-inserted locations that no longer should be
243 inserted. Functions that delete a breakpoint or breakpoints
244 should specify this mode, so that deleting a breakpoint doesn't
245 have the side effect of inserting the locations of other
246 breakpoints that are marked not-inserted, but should_be_inserted
247 returns true on them.
249 This behavior is useful is situations close to tear-down -- e.g.,
250 after an exec, while the target still has execution, but
251 breakpoint shadows of the previous executable image should *NOT*
252 be restored to the new image; or before detaching, where the
253 target still has execution and wants to delete breakpoints from
254 GDB's lists, and all breakpoints had already been removed from
258 /* May insert breakpoints iff breakpoints_should_be_inserted_now
259 claims breakpoints should be inserted now. */
262 /* Insert locations now, irrespective of
263 breakpoints_should_be_inserted_now. E.g., say all threads are
264 stopped right now, and the user did "continue". We need to
265 insert breakpoints _before_ resuming the target, but
266 UGLL_MAY_INSERT wouldn't insert them, because
267 breakpoints_should_be_inserted_now returns false at that point,
268 as no thread is running yet. */
272 static void update_global_location_list (enum ugll_insert_mode
);
274 static void update_global_location_list_nothrow (enum ugll_insert_mode
);
276 static int is_hardware_watchpoint (const struct breakpoint
*bpt
);
278 static void insert_breakpoint_locations (void);
280 static void tracepoints_info (char *, int);
282 static void delete_trace_command (char *, int);
284 static void enable_trace_command (char *, int);
286 static void disable_trace_command (char *, int);
288 static void trace_pass_command (char *, int);
290 static void set_tracepoint_count (int num
);
292 static int is_masked_watchpoint (const struct breakpoint
*b
);
294 static struct bp_location
**get_first_locp_gte_addr (CORE_ADDR address
);
296 /* Return 1 if B refers to a static tracepoint set by marker ("-m"), zero
299 static int strace_marker_p (struct breakpoint
*b
);
301 /* The breakpoint_ops structure to be inherited by all breakpoint_ops
302 that are implemented on top of software or hardware breakpoints
303 (user breakpoints, internal and momentary breakpoints, etc.). */
304 static struct breakpoint_ops bkpt_base_breakpoint_ops
;
306 /* Internal breakpoints class type. */
307 static struct breakpoint_ops internal_breakpoint_ops
;
309 /* Momentary breakpoints class type. */
310 static struct breakpoint_ops momentary_breakpoint_ops
;
312 /* Momentary breakpoints for bp_longjmp and bp_exception class type. */
313 static struct breakpoint_ops longjmp_breakpoint_ops
;
315 /* The breakpoint_ops structure to be used in regular user created
317 struct breakpoint_ops bkpt_breakpoint_ops
;
319 /* Breakpoints set on probes. */
320 static struct breakpoint_ops bkpt_probe_breakpoint_ops
;
322 /* Dynamic printf class type. */
323 struct breakpoint_ops dprintf_breakpoint_ops
;
325 /* The style in which to perform a dynamic printf. This is a user
326 option because different output options have different tradeoffs;
327 if GDB does the printing, there is better error handling if there
328 is a problem with any of the arguments, but using an inferior
329 function lets you have special-purpose printers and sending of
330 output to the same place as compiled-in print functions. */
332 static const char dprintf_style_gdb
[] = "gdb";
333 static const char dprintf_style_call
[] = "call";
334 static const char dprintf_style_agent
[] = "agent";
335 static const char *const dprintf_style_enums
[] = {
341 static const char *dprintf_style
= dprintf_style_gdb
;
343 /* The function to use for dynamic printf if the preferred style is to
344 call into the inferior. The value is simply a string that is
345 copied into the command, so it can be anything that GDB can
346 evaluate to a callable address, not necessarily a function name. */
348 static char *dprintf_function
= "";
350 /* The channel to use for dynamic printf if the preferred style is to
351 call into the inferior; if a nonempty string, it will be passed to
352 the call as the first argument, with the format string as the
353 second. As with the dprintf function, this can be anything that
354 GDB knows how to evaluate, so in addition to common choices like
355 "stderr", this could be an app-specific expression like
356 "mystreams[curlogger]". */
358 static char *dprintf_channel
= "";
360 /* True if dprintf commands should continue to operate even if GDB
362 static int disconnected_dprintf
= 1;
364 /* A reference-counted struct command_line. This lets multiple
365 breakpoints share a single command list. */
366 struct counted_command_line
368 /* The reference count. */
371 /* The command list. */
372 struct command_line
*commands
;
375 struct command_line
*
376 breakpoint_commands (struct breakpoint
*b
)
378 return b
->commands
? b
->commands
->commands
: NULL
;
381 /* Flag indicating that a command has proceeded the inferior past the
382 current breakpoint. */
384 static int breakpoint_proceeded
;
387 bpdisp_text (enum bpdisp disp
)
389 /* NOTE: the following values are a part of MI protocol and
390 represent values of 'disp' field returned when inferior stops at
392 static const char * const bpdisps
[] = {"del", "dstp", "dis", "keep"};
394 return bpdisps
[(int) disp
];
397 /* Prototypes for exported functions. */
398 /* If FALSE, gdb will not use hardware support for watchpoints, even
399 if such is available. */
400 static int can_use_hw_watchpoints
;
403 show_can_use_hw_watchpoints (struct ui_file
*file
, int from_tty
,
404 struct cmd_list_element
*c
,
407 fprintf_filtered (file
,
408 _("Debugger's willingness to use "
409 "watchpoint hardware is %s.\n"),
413 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
414 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
415 for unrecognized breakpoint locations.
416 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
417 static enum auto_boolean pending_break_support
;
419 show_pending_break_support (struct ui_file
*file
, int from_tty
,
420 struct cmd_list_element
*c
,
423 fprintf_filtered (file
,
424 _("Debugger's behavior regarding "
425 "pending breakpoints is %s.\n"),
429 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
430 set with "break" but falling in read-only memory.
431 If 0, gdb will warn about such breakpoints, but won't automatically
432 use hardware breakpoints. */
433 static int automatic_hardware_breakpoints
;
435 show_automatic_hardware_breakpoints (struct ui_file
*file
, int from_tty
,
436 struct cmd_list_element
*c
,
439 fprintf_filtered (file
,
440 _("Automatic usage of hardware breakpoints is %s.\n"),
444 /* If on, GDB keeps breakpoints inserted even if the inferior is
445 stopped, and immediately inserts any new breakpoints as soon as
446 they're created. If off (default), GDB keeps breakpoints off of
447 the target as long as possible. That is, it delays inserting
448 breakpoints until the next resume, and removes them again when the
449 target fully stops. This is a bit safer in case GDB crashes while
450 processing user input. */
451 static int always_inserted_mode
= 0;
454 show_always_inserted_mode (struct ui_file
*file
, int from_tty
,
455 struct cmd_list_element
*c
, const char *value
)
457 fprintf_filtered (file
, _("Always inserted breakpoint mode is %s.\n"),
461 /* See breakpoint.h. */
464 breakpoints_should_be_inserted_now (void)
466 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
468 /* If breakpoints are global, they should be inserted even if no
469 thread under gdb's control is running, or even if there are
470 no threads under GDB's control yet. */
473 else if (target_has_execution
)
475 struct thread_info
*tp
;
477 if (always_inserted_mode
)
479 /* The user wants breakpoints inserted even if all threads
484 if (threads_are_executing ())
487 /* Don't remove breakpoints yet if, even though all threads are
488 stopped, we still have events to process. */
489 ALL_NON_EXITED_THREADS (tp
)
491 && tp
->suspend
.waitstatus_pending_p
)
497 static const char condition_evaluation_both
[] = "host or target";
499 /* Modes for breakpoint condition evaluation. */
500 static const char condition_evaluation_auto
[] = "auto";
501 static const char condition_evaluation_host
[] = "host";
502 static const char condition_evaluation_target
[] = "target";
503 static const char *const condition_evaluation_enums
[] = {
504 condition_evaluation_auto
,
505 condition_evaluation_host
,
506 condition_evaluation_target
,
510 /* Global that holds the current mode for breakpoint condition evaluation. */
511 static const char *condition_evaluation_mode_1
= condition_evaluation_auto
;
513 /* Global that we use to display information to the user (gets its value from
514 condition_evaluation_mode_1. */
515 static const char *condition_evaluation_mode
= condition_evaluation_auto
;
517 /* Translate a condition evaluation mode MODE into either "host"
518 or "target". This is used mostly to translate from "auto" to the
519 real setting that is being used. It returns the translated
523 translate_condition_evaluation_mode (const char *mode
)
525 if (mode
== condition_evaluation_auto
)
527 if (target_supports_evaluation_of_breakpoint_conditions ())
528 return condition_evaluation_target
;
530 return condition_evaluation_host
;
536 /* Discovers what condition_evaluation_auto translates to. */
539 breakpoint_condition_evaluation_mode (void)
541 return translate_condition_evaluation_mode (condition_evaluation_mode
);
544 /* Return true if GDB should evaluate breakpoint conditions or false
548 gdb_evaluates_breakpoint_condition_p (void)
550 const char *mode
= breakpoint_condition_evaluation_mode ();
552 return (mode
== condition_evaluation_host
);
555 void _initialize_breakpoint (void);
557 /* Are we executing breakpoint commands? */
558 static int executing_breakpoint_commands
;
560 /* Are overlay event breakpoints enabled? */
561 static int overlay_events_enabled
;
563 /* See description in breakpoint.h. */
564 int target_exact_watchpoints
= 0;
566 /* Walk the following statement or block through all breakpoints.
567 ALL_BREAKPOINTS_SAFE does so even if the statement deletes the
568 current breakpoint. */
570 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
572 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
573 for (B = breakpoint_chain; \
574 B ? (TMP=B->next, 1): 0; \
577 /* Similar iterator for the low-level breakpoints. SAFE variant is
578 not provided so update_global_location_list must not be called
579 while executing the block of ALL_BP_LOCATIONS. */
581 #define ALL_BP_LOCATIONS(B,BP_TMP) \
582 for (BP_TMP = bp_location; \
583 BP_TMP < bp_location + bp_location_count && (B = *BP_TMP); \
586 /* Iterates through locations with address ADDRESS for the currently selected
587 program space. BP_LOCP_TMP points to each object. BP_LOCP_START points
588 to where the loop should start from.
589 If BP_LOCP_START is a NULL pointer, the macro automatically seeks the
590 appropriate location to start with. */
592 #define ALL_BP_LOCATIONS_AT_ADDR(BP_LOCP_TMP, BP_LOCP_START, ADDRESS) \
593 for (BP_LOCP_START = BP_LOCP_START == NULL ? get_first_locp_gte_addr (ADDRESS) : BP_LOCP_START, \
594 BP_LOCP_TMP = BP_LOCP_START; \
596 && (BP_LOCP_TMP < bp_location + bp_location_count \
597 && (*BP_LOCP_TMP)->address == ADDRESS); \
600 /* Iterator for tracepoints only. */
602 #define ALL_TRACEPOINTS(B) \
603 for (B = breakpoint_chain; B; B = B->next) \
604 if (is_tracepoint (B))
606 /* Chains of all breakpoints defined. */
608 struct breakpoint
*breakpoint_chain
;
610 /* Array is sorted by bp_location_compare - primarily by the ADDRESS. */
612 static struct bp_location
**bp_location
;
614 /* Number of elements of BP_LOCATION. */
616 static unsigned bp_location_count
;
618 /* Maximum alignment offset between bp_target_info.PLACED_ADDRESS and
619 ADDRESS for the current elements of BP_LOCATION which get a valid
620 result from bp_location_has_shadow. You can use it for roughly
621 limiting the subrange of BP_LOCATION to scan for shadow bytes for
622 an address you need to read. */
624 static CORE_ADDR bp_location_placed_address_before_address_max
;
626 /* Maximum offset plus alignment between bp_target_info.PLACED_ADDRESS
627 + bp_target_info.SHADOW_LEN and ADDRESS for the current elements of
628 BP_LOCATION which get a valid result from bp_location_has_shadow.
629 You can use it for roughly limiting the subrange of BP_LOCATION to
630 scan for shadow bytes for an address you need to read. */
632 static CORE_ADDR bp_location_shadow_len_after_address_max
;
634 /* The locations that no longer correspond to any breakpoint, unlinked
635 from bp_location array, but for which a hit may still be reported
637 VEC(bp_location_p
) *moribund_locations
= NULL
;
639 /* Number of last breakpoint made. */
641 static int breakpoint_count
;
643 /* The value of `breakpoint_count' before the last command that
644 created breakpoints. If the last (break-like) command created more
645 than one breakpoint, then the difference between BREAKPOINT_COUNT
646 and PREV_BREAKPOINT_COUNT is more than one. */
647 static int prev_breakpoint_count
;
649 /* Number of last tracepoint made. */
651 static int tracepoint_count
;
653 static struct cmd_list_element
*breakpoint_set_cmdlist
;
654 static struct cmd_list_element
*breakpoint_show_cmdlist
;
655 struct cmd_list_element
*save_cmdlist
;
657 /* See declaration at breakpoint.h. */
660 breakpoint_find_if (int (*func
) (struct breakpoint
*b
, void *d
),
663 struct breakpoint
*b
= NULL
;
667 if (func (b
, user_data
) != 0)
674 /* Return whether a breakpoint is an active enabled breakpoint. */
676 breakpoint_enabled (struct breakpoint
*b
)
678 return (b
->enable_state
== bp_enabled
);
681 /* Set breakpoint count to NUM. */
684 set_breakpoint_count (int num
)
686 prev_breakpoint_count
= breakpoint_count
;
687 breakpoint_count
= num
;
688 set_internalvar_integer (lookup_internalvar ("bpnum"), num
);
691 /* Used by `start_rbreak_breakpoints' below, to record the current
692 breakpoint count before "rbreak" creates any breakpoint. */
693 static int rbreak_start_breakpoint_count
;
695 /* Called at the start an "rbreak" command to record the first
699 start_rbreak_breakpoints (void)
701 rbreak_start_breakpoint_count
= breakpoint_count
;
704 /* Called at the end of an "rbreak" command to record the last
708 end_rbreak_breakpoints (void)
710 prev_breakpoint_count
= rbreak_start_breakpoint_count
;
713 /* Used in run_command to zero the hit count when a new run starts. */
716 clear_breakpoint_hit_counts (void)
718 struct breakpoint
*b
;
724 /* Allocate a new counted_command_line with reference count of 1.
725 The new structure owns COMMANDS. */
727 static struct counted_command_line
*
728 alloc_counted_command_line (struct command_line
*commands
)
730 struct counted_command_line
*result
= XNEW (struct counted_command_line
);
733 result
->commands
= commands
;
738 /* Increment reference count. This does nothing if CMD is NULL. */
741 incref_counted_command_line (struct counted_command_line
*cmd
)
747 /* Decrement reference count. If the reference count reaches 0,
748 destroy the counted_command_line. Sets *CMDP to NULL. This does
749 nothing if *CMDP is NULL. */
752 decref_counted_command_line (struct counted_command_line
**cmdp
)
756 if (--(*cmdp
)->refc
== 0)
758 free_command_lines (&(*cmdp
)->commands
);
765 /* A cleanup function that calls decref_counted_command_line. */
768 do_cleanup_counted_command_line (void *arg
)
770 decref_counted_command_line ((struct counted_command_line
**) arg
);
773 /* Create a cleanup that calls decref_counted_command_line on the
776 static struct cleanup
*
777 make_cleanup_decref_counted_command_line (struct counted_command_line
**cmdp
)
779 return make_cleanup (do_cleanup_counted_command_line
, cmdp
);
783 /* Return the breakpoint with the specified number, or NULL
784 if the number does not refer to an existing breakpoint. */
787 get_breakpoint (int num
)
789 struct breakpoint
*b
;
792 if (b
->number
== num
)
800 /* Mark locations as "conditions have changed" in case the target supports
801 evaluating conditions on its side. */
804 mark_breakpoint_modified (struct breakpoint
*b
)
806 struct bp_location
*loc
;
808 /* This is only meaningful if the target is
809 evaluating conditions and if the user has
810 opted for condition evaluation on the target's
812 if (gdb_evaluates_breakpoint_condition_p ()
813 || !target_supports_evaluation_of_breakpoint_conditions ())
816 if (!is_breakpoint (b
))
819 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
820 loc
->condition_changed
= condition_modified
;
823 /* Mark location as "conditions have changed" in case the target supports
824 evaluating conditions on its side. */
827 mark_breakpoint_location_modified (struct bp_location
*loc
)
829 /* This is only meaningful if the target is
830 evaluating conditions and if the user has
831 opted for condition evaluation on the target's
833 if (gdb_evaluates_breakpoint_condition_p ()
834 || !target_supports_evaluation_of_breakpoint_conditions ())
838 if (!is_breakpoint (loc
->owner
))
841 loc
->condition_changed
= condition_modified
;
844 /* Sets the condition-evaluation mode using the static global
845 condition_evaluation_mode. */
848 set_condition_evaluation_mode (char *args
, int from_tty
,
849 struct cmd_list_element
*c
)
851 const char *old_mode
, *new_mode
;
853 if ((condition_evaluation_mode_1
== condition_evaluation_target
)
854 && !target_supports_evaluation_of_breakpoint_conditions ())
856 condition_evaluation_mode_1
= condition_evaluation_mode
;
857 warning (_("Target does not support breakpoint condition evaluation.\n"
858 "Using host evaluation mode instead."));
862 new_mode
= translate_condition_evaluation_mode (condition_evaluation_mode_1
);
863 old_mode
= translate_condition_evaluation_mode (condition_evaluation_mode
);
865 /* Flip the switch. Flip it even if OLD_MODE == NEW_MODE as one of the
866 settings was "auto". */
867 condition_evaluation_mode
= condition_evaluation_mode_1
;
869 /* Only update the mode if the user picked a different one. */
870 if (new_mode
!= old_mode
)
872 struct bp_location
*loc
, **loc_tmp
;
873 /* If the user switched to a different evaluation mode, we
874 need to synch the changes with the target as follows:
876 "host" -> "target": Send all (valid) conditions to the target.
877 "target" -> "host": Remove all the conditions from the target.
880 if (new_mode
== condition_evaluation_target
)
882 /* Mark everything modified and synch conditions with the
884 ALL_BP_LOCATIONS (loc
, loc_tmp
)
885 mark_breakpoint_location_modified (loc
);
889 /* Manually mark non-duplicate locations to synch conditions
890 with the target. We do this to remove all the conditions the
891 target knows about. */
892 ALL_BP_LOCATIONS (loc
, loc_tmp
)
893 if (is_breakpoint (loc
->owner
) && loc
->inserted
)
894 loc
->needs_update
= 1;
898 update_global_location_list (UGLL_MAY_INSERT
);
904 /* Shows the current mode of breakpoint condition evaluation. Explicitly shows
905 what "auto" is translating to. */
908 show_condition_evaluation_mode (struct ui_file
*file
, int from_tty
,
909 struct cmd_list_element
*c
, const char *value
)
911 if (condition_evaluation_mode
== condition_evaluation_auto
)
912 fprintf_filtered (file
,
913 _("Breakpoint condition evaluation "
914 "mode is %s (currently %s).\n"),
916 breakpoint_condition_evaluation_mode ());
918 fprintf_filtered (file
, _("Breakpoint condition evaluation mode is %s.\n"),
922 /* A comparison function for bp_location AP and BP that is used by
923 bsearch. This comparison function only cares about addresses, unlike
924 the more general bp_location_compare function. */
927 bp_location_compare_addrs (const void *ap
, const void *bp
)
929 const struct bp_location
*a
= *(const struct bp_location
**) ap
;
930 const struct bp_location
*b
= *(const struct bp_location
**) bp
;
932 if (a
->address
== b
->address
)
935 return ((a
->address
> b
->address
) - (a
->address
< b
->address
));
938 /* Helper function to skip all bp_locations with addresses
939 less than ADDRESS. It returns the first bp_location that
940 is greater than or equal to ADDRESS. If none is found, just
943 static struct bp_location
**
944 get_first_locp_gte_addr (CORE_ADDR address
)
946 struct bp_location dummy_loc
;
947 struct bp_location
*dummy_locp
= &dummy_loc
;
948 struct bp_location
**locp_found
= NULL
;
950 /* Initialize the dummy location's address field. */
951 memset (&dummy_loc
, 0, sizeof (struct bp_location
));
952 dummy_loc
.address
= address
;
954 /* Find a close match to the first location at ADDRESS. */
955 locp_found
= ((struct bp_location
**)
956 bsearch (&dummy_locp
, bp_location
, bp_location_count
,
957 sizeof (struct bp_location
**),
958 bp_location_compare_addrs
));
960 /* Nothing was found, nothing left to do. */
961 if (locp_found
== NULL
)
964 /* We may have found a location that is at ADDRESS but is not the first in the
965 location's list. Go backwards (if possible) and locate the first one. */
966 while ((locp_found
- 1) >= bp_location
967 && (*(locp_found
- 1))->address
== address
)
974 set_breakpoint_condition (struct breakpoint
*b
, const char *exp
,
977 xfree (b
->cond_string
);
978 b
->cond_string
= NULL
;
980 if (is_watchpoint (b
))
982 struct watchpoint
*w
= (struct watchpoint
*) b
;
984 w
->cond_exp
.reset ();
988 struct bp_location
*loc
;
990 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
994 /* No need to free the condition agent expression
995 bytecode (if we have one). We will handle this
996 when we go through update_global_location_list. */
1003 printf_filtered (_("Breakpoint %d now unconditional.\n"), b
->number
);
1007 const char *arg
= exp
;
1009 /* I don't know if it matters whether this is the string the user
1010 typed in or the decompiled expression. */
1011 b
->cond_string
= xstrdup (arg
);
1012 b
->condition_not_parsed
= 0;
1014 if (is_watchpoint (b
))
1016 struct watchpoint
*w
= (struct watchpoint
*) b
;
1018 innermost_block
= NULL
;
1020 w
->cond_exp
= parse_exp_1 (&arg
, 0, 0, 0);
1022 error (_("Junk at end of expression"));
1023 w
->cond_exp_valid_block
= innermost_block
;
1027 struct bp_location
*loc
;
1029 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1033 parse_exp_1 (&arg
, loc
->address
,
1034 block_for_pc (loc
->address
), 0);
1036 error (_("Junk at end of expression"));
1040 mark_breakpoint_modified (b
);
1042 observer_notify_breakpoint_modified (b
);
1045 /* Completion for the "condition" command. */
1047 static VEC (char_ptr
) *
1048 condition_completer (struct cmd_list_element
*cmd
,
1049 const char *text
, const char *word
)
1053 text
= skip_spaces_const (text
);
1054 space
= skip_to_space_const (text
);
1058 struct breakpoint
*b
;
1059 VEC (char_ptr
) *result
= NULL
;
1063 /* We don't support completion of history indices. */
1064 if (isdigit (text
[1]))
1066 return complete_internalvar (&text
[1]);
1069 /* We're completing the breakpoint number. */
1070 len
= strlen (text
);
1076 xsnprintf (number
, sizeof (number
), "%d", b
->number
);
1078 if (strncmp (number
, text
, len
) == 0)
1079 VEC_safe_push (char_ptr
, result
, xstrdup (number
));
1085 /* We're completing the expression part. */
1086 text
= skip_spaces_const (space
);
1087 return expression_completer (cmd
, text
, word
);
1090 /* condition N EXP -- set break condition of breakpoint N to EXP. */
1093 condition_command (char *arg
, int from_tty
)
1095 struct breakpoint
*b
;
1100 error_no_arg (_("breakpoint number"));
1103 bnum
= get_number (&p
);
1105 error (_("Bad breakpoint argument: '%s'"), arg
);
1108 if (b
->number
== bnum
)
1110 /* Check if this breakpoint has a "stop" method implemented in an
1111 extension language. This method and conditions entered into GDB
1112 from the CLI are mutually exclusive. */
1113 const struct extension_language_defn
*extlang
1114 = get_breakpoint_cond_ext_lang (b
, EXT_LANG_NONE
);
1116 if (extlang
!= NULL
)
1118 error (_("Only one stop condition allowed. There is currently"
1119 " a %s stop condition defined for this breakpoint."),
1120 ext_lang_capitalized_name (extlang
));
1122 set_breakpoint_condition (b
, p
, from_tty
);
1124 if (is_breakpoint (b
))
1125 update_global_location_list (UGLL_MAY_INSERT
);
1130 error (_("No breakpoint number %d."), bnum
);
1133 /* Check that COMMAND do not contain commands that are suitable
1134 only for tracepoints and not suitable for ordinary breakpoints.
1135 Throw if any such commands is found. */
1138 check_no_tracepoint_commands (struct command_line
*commands
)
1140 struct command_line
*c
;
1142 for (c
= commands
; c
; c
= c
->next
)
1146 if (c
->control_type
== while_stepping_control
)
1147 error (_("The 'while-stepping' command can "
1148 "only be used for tracepoints"));
1150 for (i
= 0; i
< c
->body_count
; ++i
)
1151 check_no_tracepoint_commands ((c
->body_list
)[i
]);
1153 /* Not that command parsing removes leading whitespace and comment
1154 lines and also empty lines. So, we only need to check for
1155 command directly. */
1156 if (strstr (c
->line
, "collect ") == c
->line
)
1157 error (_("The 'collect' command can only be used for tracepoints"));
1159 if (strstr (c
->line
, "teval ") == c
->line
)
1160 error (_("The 'teval' command can only be used for tracepoints"));
1164 /* Encapsulate tests for different types of tracepoints. */
1167 is_tracepoint_type (enum bptype type
)
1169 return (type
== bp_tracepoint
1170 || type
== bp_fast_tracepoint
1171 || type
== bp_static_tracepoint
);
1175 is_tracepoint (const struct breakpoint
*b
)
1177 return is_tracepoint_type (b
->type
);
1180 /* A helper function that validates that COMMANDS are valid for a
1181 breakpoint. This function will throw an exception if a problem is
1185 validate_commands_for_breakpoint (struct breakpoint
*b
,
1186 struct command_line
*commands
)
1188 if (is_tracepoint (b
))
1190 struct tracepoint
*t
= (struct tracepoint
*) b
;
1191 struct command_line
*c
;
1192 struct command_line
*while_stepping
= 0;
1194 /* Reset the while-stepping step count. The previous commands
1195 might have included a while-stepping action, while the new
1199 /* We need to verify that each top-level element of commands is
1200 valid for tracepoints, that there's at most one
1201 while-stepping element, and that the while-stepping's body
1202 has valid tracing commands excluding nested while-stepping.
1203 We also need to validate the tracepoint action line in the
1204 context of the tracepoint --- validate_actionline actually
1205 has side effects, like setting the tracepoint's
1206 while-stepping STEP_COUNT, in addition to checking if the
1207 collect/teval actions parse and make sense in the
1208 tracepoint's context. */
1209 for (c
= commands
; c
; c
= c
->next
)
1211 if (c
->control_type
== while_stepping_control
)
1213 if (b
->type
== bp_fast_tracepoint
)
1214 error (_("The 'while-stepping' command "
1215 "cannot be used for fast tracepoint"));
1216 else if (b
->type
== bp_static_tracepoint
)
1217 error (_("The 'while-stepping' command "
1218 "cannot be used for static tracepoint"));
1221 error (_("The 'while-stepping' command "
1222 "can be used only once"));
1227 validate_actionline (c
->line
, b
);
1231 struct command_line
*c2
;
1233 gdb_assert (while_stepping
->body_count
== 1);
1234 c2
= while_stepping
->body_list
[0];
1235 for (; c2
; c2
= c2
->next
)
1237 if (c2
->control_type
== while_stepping_control
)
1238 error (_("The 'while-stepping' command cannot be nested"));
1244 check_no_tracepoint_commands (commands
);
1248 /* Return a vector of all the static tracepoints set at ADDR. The
1249 caller is responsible for releasing the vector. */
1252 static_tracepoints_here (CORE_ADDR addr
)
1254 struct breakpoint
*b
;
1255 VEC(breakpoint_p
) *found
= 0;
1256 struct bp_location
*loc
;
1259 if (b
->type
== bp_static_tracepoint
)
1261 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1262 if (loc
->address
== addr
)
1263 VEC_safe_push(breakpoint_p
, found
, b
);
1269 /* Set the command list of B to COMMANDS. If breakpoint is tracepoint,
1270 validate that only allowed commands are included. */
1273 breakpoint_set_commands (struct breakpoint
*b
,
1274 struct command_line
*commands
)
1276 validate_commands_for_breakpoint (b
, commands
);
1278 decref_counted_command_line (&b
->commands
);
1279 b
->commands
= alloc_counted_command_line (commands
);
1280 observer_notify_breakpoint_modified (b
);
1283 /* Set the internal `silent' flag on the breakpoint. Note that this
1284 is not the same as the "silent" that may appear in the breakpoint's
1288 breakpoint_set_silent (struct breakpoint
*b
, int silent
)
1290 int old_silent
= b
->silent
;
1293 if (old_silent
!= silent
)
1294 observer_notify_breakpoint_modified (b
);
1297 /* Set the thread for this breakpoint. If THREAD is -1, make the
1298 breakpoint work for any thread. */
1301 breakpoint_set_thread (struct breakpoint
*b
, int thread
)
1303 int old_thread
= b
->thread
;
1306 if (old_thread
!= thread
)
1307 observer_notify_breakpoint_modified (b
);
1310 /* Set the task for this breakpoint. If TASK is 0, make the
1311 breakpoint work for any task. */
1314 breakpoint_set_task (struct breakpoint
*b
, int task
)
1316 int old_task
= b
->task
;
1319 if (old_task
!= task
)
1320 observer_notify_breakpoint_modified (b
);
1324 check_tracepoint_command (char *line
, void *closure
)
1326 struct breakpoint
*b
= (struct breakpoint
*) closure
;
1328 validate_actionline (line
, b
);
1331 /* A structure used to pass information through
1332 map_breakpoint_numbers. */
1334 struct commands_info
1336 /* True if the command was typed at a tty. */
1339 /* The breakpoint range spec. */
1342 /* Non-NULL if the body of the commands are being read from this
1343 already-parsed command. */
1344 struct command_line
*control
;
1346 /* The command lines read from the user, or NULL if they have not
1348 struct counted_command_line
*cmd
;
1351 /* A callback for map_breakpoint_numbers that sets the commands for
1352 commands_command. */
1355 do_map_commands_command (struct breakpoint
*b
, void *data
)
1357 struct commands_info
*info
= (struct commands_info
*) data
;
1359 if (info
->cmd
== NULL
)
1361 struct command_line
*l
;
1363 if (info
->control
!= NULL
)
1364 l
= copy_command_lines (info
->control
->body_list
[0]);
1367 struct cleanup
*old_chain
;
1370 str
= xstrprintf (_("Type commands for breakpoint(s) "
1371 "%s, one per line."),
1374 old_chain
= make_cleanup (xfree
, str
);
1376 l
= read_command_lines (str
,
1379 ? check_tracepoint_command
: 0),
1382 do_cleanups (old_chain
);
1385 info
->cmd
= alloc_counted_command_line (l
);
1388 /* If a breakpoint was on the list more than once, we don't need to
1390 if (b
->commands
!= info
->cmd
)
1392 validate_commands_for_breakpoint (b
, info
->cmd
->commands
);
1393 incref_counted_command_line (info
->cmd
);
1394 decref_counted_command_line (&b
->commands
);
1395 b
->commands
= info
->cmd
;
1396 observer_notify_breakpoint_modified (b
);
1401 commands_command_1 (const char *arg
, int from_tty
,
1402 struct command_line
*control
)
1404 struct cleanup
*cleanups
;
1405 struct commands_info info
;
1407 info
.from_tty
= from_tty
;
1408 info
.control
= control
;
1410 /* If we read command lines from the user, then `info' will hold an
1411 extra reference to the commands that we must clean up. */
1412 cleanups
= make_cleanup_decref_counted_command_line (&info
.cmd
);
1414 std::string new_arg
;
1416 if (arg
== NULL
|| !*arg
)
1418 if (breakpoint_count
- prev_breakpoint_count
> 1)
1419 new_arg
= string_printf ("%d-%d", prev_breakpoint_count
+ 1,
1421 else if (breakpoint_count
> 0)
1422 new_arg
= string_printf ("%d", breakpoint_count
);
1427 info
.arg
= new_arg
.c_str ();
1429 map_breakpoint_numbers (info
.arg
, do_map_commands_command
, &info
);
1431 if (info
.cmd
== NULL
)
1432 error (_("No breakpoints specified."));
1434 do_cleanups (cleanups
);
1438 commands_command (char *arg
, int from_tty
)
1440 commands_command_1 (arg
, from_tty
, NULL
);
1443 /* Like commands_command, but instead of reading the commands from
1444 input stream, takes them from an already parsed command structure.
1446 This is used by cli-script.c to DTRT with breakpoint commands
1447 that are part of if and while bodies. */
1448 enum command_control_type
1449 commands_from_control_command (const char *arg
, struct command_line
*cmd
)
1451 commands_command_1 (arg
, 0, cmd
);
1452 return simple_control
;
1455 /* Return non-zero if BL->TARGET_INFO contains valid information. */
1458 bp_location_has_shadow (struct bp_location
*bl
)
1460 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
1464 if (bl
->target_info
.shadow_len
== 0)
1465 /* BL isn't valid, or doesn't shadow memory. */
1470 /* Update BUF, which is LEN bytes read from the target address
1471 MEMADDR, by replacing a memory breakpoint with its shadowed
1474 If READBUF is not NULL, this buffer must not overlap with the of
1475 the breakpoint location's shadow_contents buffer. Otherwise, a
1476 failed assertion internal error will be raised. */
1479 one_breakpoint_xfer_memory (gdb_byte
*readbuf
, gdb_byte
*writebuf
,
1480 const gdb_byte
*writebuf_org
,
1481 ULONGEST memaddr
, LONGEST len
,
1482 struct bp_target_info
*target_info
,
1483 struct gdbarch
*gdbarch
)
1485 /* Now do full processing of the found relevant range of elements. */
1486 CORE_ADDR bp_addr
= 0;
1490 if (!breakpoint_address_match (target_info
->placed_address_space
, 0,
1491 current_program_space
->aspace
, 0))
1493 /* The breakpoint is inserted in a different address space. */
1497 /* Addresses and length of the part of the breakpoint that
1499 bp_addr
= target_info
->placed_address
;
1500 bp_size
= target_info
->shadow_len
;
1502 if (bp_addr
+ bp_size
<= memaddr
)
1504 /* The breakpoint is entirely before the chunk of memory we are
1509 if (bp_addr
>= memaddr
+ len
)
1511 /* The breakpoint is entirely after the chunk of memory we are
1516 /* Offset within shadow_contents. */
1517 if (bp_addr
< memaddr
)
1519 /* Only copy the second part of the breakpoint. */
1520 bp_size
-= memaddr
- bp_addr
;
1521 bptoffset
= memaddr
- bp_addr
;
1525 if (bp_addr
+ bp_size
> memaddr
+ len
)
1527 /* Only copy the first part of the breakpoint. */
1528 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
1531 if (readbuf
!= NULL
)
1533 /* Verify that the readbuf buffer does not overlap with the
1534 shadow_contents buffer. */
1535 gdb_assert (target_info
->shadow_contents
>= readbuf
+ len
1536 || readbuf
>= (target_info
->shadow_contents
1537 + target_info
->shadow_len
));
1539 /* Update the read buffer with this inserted breakpoint's
1541 memcpy (readbuf
+ bp_addr
- memaddr
,
1542 target_info
->shadow_contents
+ bptoffset
, bp_size
);
1546 const unsigned char *bp
;
1547 CORE_ADDR addr
= target_info
->reqstd_address
;
1550 /* Update the shadow with what we want to write to memory. */
1551 memcpy (target_info
->shadow_contents
+ bptoffset
,
1552 writebuf_org
+ bp_addr
- memaddr
, bp_size
);
1554 /* Determine appropriate breakpoint contents and size for this
1556 bp
= gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &placed_size
);
1558 /* Update the final write buffer with this inserted
1559 breakpoint's INSN. */
1560 memcpy (writebuf
+ bp_addr
- memaddr
, bp
+ bptoffset
, bp_size
);
1564 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
1565 by replacing any memory breakpoints with their shadowed contents.
1567 If READBUF is not NULL, this buffer must not overlap with any of
1568 the breakpoint location's shadow_contents buffers. Otherwise,
1569 a failed assertion internal error will be raised.
1571 The range of shadowed area by each bp_location is:
1572 bl->address - bp_location_placed_address_before_address_max
1573 up to bl->address + bp_location_shadow_len_after_address_max
1574 The range we were requested to resolve shadows for is:
1575 memaddr ... memaddr + len
1576 Thus the safe cutoff boundaries for performance optimization are
1577 memaddr + len <= (bl->address
1578 - bp_location_placed_address_before_address_max)
1580 bl->address + bp_location_shadow_len_after_address_max <= memaddr */
1583 breakpoint_xfer_memory (gdb_byte
*readbuf
, gdb_byte
*writebuf
,
1584 const gdb_byte
*writebuf_org
,
1585 ULONGEST memaddr
, LONGEST len
)
1587 /* Left boundary, right boundary and median element of our binary
1589 unsigned bc_l
, bc_r
, bc
;
1591 /* Find BC_L which is a leftmost element which may affect BUF
1592 content. It is safe to report lower value but a failure to
1593 report higher one. */
1596 bc_r
= bp_location_count
;
1597 while (bc_l
+ 1 < bc_r
)
1599 struct bp_location
*bl
;
1601 bc
= (bc_l
+ bc_r
) / 2;
1602 bl
= bp_location
[bc
];
1604 /* Check first BL->ADDRESS will not overflow due to the added
1605 constant. Then advance the left boundary only if we are sure
1606 the BC element can in no way affect the BUF content (MEMADDR
1607 to MEMADDR + LEN range).
1609 Use the BP_LOCATION_SHADOW_LEN_AFTER_ADDRESS_MAX safety
1610 offset so that we cannot miss a breakpoint with its shadow
1611 range tail still reaching MEMADDR. */
1613 if ((bl
->address
+ bp_location_shadow_len_after_address_max
1615 && (bl
->address
+ bp_location_shadow_len_after_address_max
1622 /* Due to the binary search above, we need to make sure we pick the
1623 first location that's at BC_L's address. E.g., if there are
1624 multiple locations at the same address, BC_L may end up pointing
1625 at a duplicate location, and miss the "master"/"inserted"
1626 location. Say, given locations L1, L2 and L3 at addresses A and
1629 L1@A, L2@A, L3@B, ...
1631 BC_L could end up pointing at location L2, while the "master"
1632 location could be L1. Since the `loc->inserted' flag is only set
1633 on "master" locations, we'd forget to restore the shadow of L1
1636 && bp_location
[bc_l
]->address
== bp_location
[bc_l
- 1]->address
)
1639 /* Now do full processing of the found relevant range of elements. */
1641 for (bc
= bc_l
; bc
< bp_location_count
; bc
++)
1643 struct bp_location
*bl
= bp_location
[bc
];
1645 /* bp_location array has BL->OWNER always non-NULL. */
1646 if (bl
->owner
->type
== bp_none
)
1647 warning (_("reading through apparently deleted breakpoint #%d?"),
1650 /* Performance optimization: any further element can no longer affect BUF
1653 if (bl
->address
>= bp_location_placed_address_before_address_max
1654 && memaddr
+ len
<= (bl
->address
1655 - bp_location_placed_address_before_address_max
))
1658 if (!bp_location_has_shadow (bl
))
1661 one_breakpoint_xfer_memory (readbuf
, writebuf
, writebuf_org
,
1662 memaddr
, len
, &bl
->target_info
, bl
->gdbarch
);
1668 /* Return true if BPT is either a software breakpoint or a hardware
1672 is_breakpoint (const struct breakpoint
*bpt
)
1674 return (bpt
->type
== bp_breakpoint
1675 || bpt
->type
== bp_hardware_breakpoint
1676 || bpt
->type
== bp_dprintf
);
1679 /* Return true if BPT is of any hardware watchpoint kind. */
1682 is_hardware_watchpoint (const struct breakpoint
*bpt
)
1684 return (bpt
->type
== bp_hardware_watchpoint
1685 || bpt
->type
== bp_read_watchpoint
1686 || bpt
->type
== bp_access_watchpoint
);
1689 /* Return true if BPT is of any watchpoint kind, hardware or
1693 is_watchpoint (const struct breakpoint
*bpt
)
1695 return (is_hardware_watchpoint (bpt
)
1696 || bpt
->type
== bp_watchpoint
);
1699 /* Returns true if the current thread and its running state are safe
1700 to evaluate or update watchpoint B. Watchpoints on local
1701 expressions need to be evaluated in the context of the thread that
1702 was current when the watchpoint was created, and, that thread needs
1703 to be stopped to be able to select the correct frame context.
1704 Watchpoints on global expressions can be evaluated on any thread,
1705 and in any state. It is presently left to the target allowing
1706 memory accesses when threads are running. */
1709 watchpoint_in_thread_scope (struct watchpoint
*b
)
1711 return (b
->base
.pspace
== current_program_space
1712 && (ptid_equal (b
->watchpoint_thread
, null_ptid
)
1713 || (ptid_equal (inferior_ptid
, b
->watchpoint_thread
)
1714 && !is_executing (inferior_ptid
))));
1717 /* Set watchpoint B to disp_del_at_next_stop, even including its possible
1718 associated bp_watchpoint_scope breakpoint. */
1721 watchpoint_del_at_next_stop (struct watchpoint
*w
)
1723 struct breakpoint
*b
= &w
->base
;
1725 if (b
->related_breakpoint
!= b
)
1727 gdb_assert (b
->related_breakpoint
->type
== bp_watchpoint_scope
);
1728 gdb_assert (b
->related_breakpoint
->related_breakpoint
== b
);
1729 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
1730 b
->related_breakpoint
->related_breakpoint
= b
->related_breakpoint
;
1731 b
->related_breakpoint
= b
;
1733 b
->disposition
= disp_del_at_next_stop
;
1736 /* Extract a bitfield value from value VAL using the bit parameters contained in
1739 static struct value
*
1740 extract_bitfield_from_watchpoint_value (struct watchpoint
*w
, struct value
*val
)
1742 struct value
*bit_val
;
1747 bit_val
= allocate_value (value_type (val
));
1749 unpack_value_bitfield (bit_val
,
1752 value_contents_for_printing (val
),
1759 /* Allocate a dummy location and add it to B, which must be a software
1760 watchpoint. This is required because even if a software watchpoint
1761 is not watching any memory, bpstat_stop_status requires a location
1762 to be able to report stops. */
1765 software_watchpoint_add_no_memory_location (struct breakpoint
*b
,
1766 struct program_space
*pspace
)
1768 gdb_assert (b
->type
== bp_watchpoint
&& b
->loc
== NULL
);
1770 b
->loc
= allocate_bp_location (b
);
1771 b
->loc
->pspace
= pspace
;
1772 b
->loc
->address
= -1;
1773 b
->loc
->length
= -1;
1776 /* Returns true if B is a software watchpoint that is not watching any
1777 memory (e.g., "watch $pc"). */
1780 is_no_memory_software_watchpoint (struct breakpoint
*b
)
1782 return (b
->type
== bp_watchpoint
1784 && b
->loc
->next
== NULL
1785 && b
->loc
->address
== -1
1786 && b
->loc
->length
== -1);
1789 /* Assuming that B is a watchpoint:
1790 - Reparse watchpoint expression, if REPARSE is non-zero
1791 - Evaluate expression and store the result in B->val
1792 - Evaluate the condition if there is one, and store the result
1794 - Update the list of values that must be watched in B->loc.
1796 If the watchpoint disposition is disp_del_at_next_stop, then do
1797 nothing. If this is local watchpoint that is out of scope, delete
1800 Even with `set breakpoint always-inserted on' the watchpoints are
1801 removed + inserted on each stop here. Normal breakpoints must
1802 never be removed because they might be missed by a running thread
1803 when debugging in non-stop mode. On the other hand, hardware
1804 watchpoints (is_hardware_watchpoint; processed here) are specific
1805 to each LWP since they are stored in each LWP's hardware debug
1806 registers. Therefore, such LWP must be stopped first in order to
1807 be able to modify its hardware watchpoints.
1809 Hardware watchpoints must be reset exactly once after being
1810 presented to the user. It cannot be done sooner, because it would
1811 reset the data used to present the watchpoint hit to the user. And
1812 it must not be done later because it could display the same single
1813 watchpoint hit during multiple GDB stops. Note that the latter is
1814 relevant only to the hardware watchpoint types bp_read_watchpoint
1815 and bp_access_watchpoint. False hit by bp_hardware_watchpoint is
1816 not user-visible - its hit is suppressed if the memory content has
1819 The following constraints influence the location where we can reset
1820 hardware watchpoints:
1822 * target_stopped_by_watchpoint and target_stopped_data_address are
1823 called several times when GDB stops.
1826 * Multiple hardware watchpoints can be hit at the same time,
1827 causing GDB to stop. GDB only presents one hardware watchpoint
1828 hit at a time as the reason for stopping, and all the other hits
1829 are presented later, one after the other, each time the user
1830 requests the execution to be resumed. Execution is not resumed
1831 for the threads still having pending hit event stored in
1832 LWP_INFO->STATUS. While the watchpoint is already removed from
1833 the inferior on the first stop the thread hit event is kept being
1834 reported from its cached value by linux_nat_stopped_data_address
1835 until the real thread resume happens after the watchpoint gets
1836 presented and thus its LWP_INFO->STATUS gets reset.
1838 Therefore the hardware watchpoint hit can get safely reset on the
1839 watchpoint removal from inferior. */
1842 update_watchpoint (struct watchpoint
*b
, int reparse
)
1844 int within_current_scope
;
1845 struct frame_id saved_frame_id
;
1848 /* If this is a local watchpoint, we only want to check if the
1849 watchpoint frame is in scope if the current thread is the thread
1850 that was used to create the watchpoint. */
1851 if (!watchpoint_in_thread_scope (b
))
1854 if (b
->base
.disposition
== disp_del_at_next_stop
)
1859 /* Determine if the watchpoint is within scope. */
1860 if (b
->exp_valid_block
== NULL
)
1861 within_current_scope
= 1;
1864 struct frame_info
*fi
= get_current_frame ();
1865 struct gdbarch
*frame_arch
= get_frame_arch (fi
);
1866 CORE_ADDR frame_pc
= get_frame_pc (fi
);
1868 /* If we're at a point where the stack has been destroyed
1869 (e.g. in a function epilogue), unwinding may not work
1870 properly. Do not attempt to recreate locations at this
1871 point. See similar comments in watchpoint_check. */
1872 if (gdbarch_stack_frame_destroyed_p (frame_arch
, frame_pc
))
1875 /* Save the current frame's ID so we can restore it after
1876 evaluating the watchpoint expression on its own frame. */
1877 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
1878 took a frame parameter, so that we didn't have to change the
1881 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
1883 fi
= frame_find_by_id (b
->watchpoint_frame
);
1884 within_current_scope
= (fi
!= NULL
);
1885 if (within_current_scope
)
1889 /* We don't free locations. They are stored in the bp_location array
1890 and update_global_location_list will eventually delete them and
1891 remove breakpoints if needed. */
1894 if (within_current_scope
&& reparse
)
1899 s
= b
->exp_string_reparse
? b
->exp_string_reparse
: b
->exp_string
;
1900 b
->exp
= parse_exp_1 (&s
, 0, b
->exp_valid_block
, 0);
1901 /* If the meaning of expression itself changed, the old value is
1902 no longer relevant. We don't want to report a watchpoint hit
1903 to the user when the old value and the new value may actually
1904 be completely different objects. */
1905 value_free (b
->val
);
1909 /* Note that unlike with breakpoints, the watchpoint's condition
1910 expression is stored in the breakpoint object, not in the
1911 locations (re)created below. */
1912 if (b
->base
.cond_string
!= NULL
)
1914 b
->cond_exp
.reset ();
1916 s
= b
->base
.cond_string
;
1917 b
->cond_exp
= parse_exp_1 (&s
, 0, b
->cond_exp_valid_block
, 0);
1921 /* If we failed to parse the expression, for example because
1922 it refers to a global variable in a not-yet-loaded shared library,
1923 don't try to insert watchpoint. We don't automatically delete
1924 such watchpoint, though, since failure to parse expression
1925 is different from out-of-scope watchpoint. */
1926 if (!target_has_execution
)
1928 /* Without execution, memory can't change. No use to try and
1929 set watchpoint locations. The watchpoint will be reset when
1930 the target gains execution, through breakpoint_re_set. */
1931 if (!can_use_hw_watchpoints
)
1933 if (b
->base
.ops
->works_in_software_mode (&b
->base
))
1934 b
->base
.type
= bp_watchpoint
;
1936 error (_("Can't set read/access watchpoint when "
1937 "hardware watchpoints are disabled."));
1940 else if (within_current_scope
&& b
->exp
)
1943 struct value
*val_chain
, *v
, *result
, *next
;
1944 struct program_space
*frame_pspace
;
1946 fetch_subexp_value (b
->exp
.get (), &pc
, &v
, &result
, &val_chain
, 0);
1948 /* Avoid setting b->val if it's already set. The meaning of
1949 b->val is 'the last value' user saw, and we should update
1950 it only if we reported that last value to user. As it
1951 happens, the code that reports it updates b->val directly.
1952 We don't keep track of the memory value for masked
1954 if (!b
->val_valid
&& !is_masked_watchpoint (&b
->base
))
1956 if (b
->val_bitsize
!= 0)
1958 v
= extract_bitfield_from_watchpoint_value (b
, v
);
1966 frame_pspace
= get_frame_program_space (get_selected_frame (NULL
));
1968 /* Look at each value on the value chain. */
1969 for (v
= val_chain
; v
; v
= value_next (v
))
1971 /* If it's a memory location, and GDB actually needed
1972 its contents to evaluate the expression, then we
1973 must watch it. If the first value returned is
1974 still lazy, that means an error occurred reading it;
1975 watch it anyway in case it becomes readable. */
1976 if (VALUE_LVAL (v
) == lval_memory
1977 && (v
== val_chain
|| ! value_lazy (v
)))
1979 struct type
*vtype
= check_typedef (value_type (v
));
1981 /* We only watch structs and arrays if user asked
1982 for it explicitly, never if they just happen to
1983 appear in the middle of some value chain. */
1985 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
1986 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
1989 enum target_hw_bp_type type
;
1990 struct bp_location
*loc
, **tmp
;
1991 int bitpos
= 0, bitsize
= 0;
1993 if (value_bitsize (v
) != 0)
1995 /* Extract the bit parameters out from the bitfield
1997 bitpos
= value_bitpos (v
);
1998 bitsize
= value_bitsize (v
);
2000 else if (v
== result
&& b
->val_bitsize
!= 0)
2002 /* If VAL_BITSIZE != 0 then RESULT is actually a bitfield
2003 lvalue whose bit parameters are saved in the fields
2004 VAL_BITPOS and VAL_BITSIZE. */
2005 bitpos
= b
->val_bitpos
;
2006 bitsize
= b
->val_bitsize
;
2009 addr
= value_address (v
);
2012 /* Skip the bytes that don't contain the bitfield. */
2017 if (b
->base
.type
== bp_read_watchpoint
)
2019 else if (b
->base
.type
== bp_access_watchpoint
)
2022 loc
= allocate_bp_location (&b
->base
);
2023 for (tmp
= &(b
->base
.loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
2026 loc
->gdbarch
= get_type_arch (value_type (v
));
2028 loc
->pspace
= frame_pspace
;
2029 loc
->address
= addr
;
2033 /* Just cover the bytes that make up the bitfield. */
2034 loc
->length
= ((bitpos
% 8) + bitsize
+ 7) / 8;
2037 loc
->length
= TYPE_LENGTH (value_type (v
));
2039 loc
->watchpoint_type
= type
;
2044 /* Change the type of breakpoint between hardware assisted or
2045 an ordinary watchpoint depending on the hardware support
2046 and free hardware slots. REPARSE is set when the inferior
2051 enum bp_loc_type loc_type
;
2052 struct bp_location
*bl
;
2054 reg_cnt
= can_use_hardware_watchpoint (val_chain
);
2058 int i
, target_resources_ok
, other_type_used
;
2061 /* Use an exact watchpoint when there's only one memory region to be
2062 watched, and only one debug register is needed to watch it. */
2063 b
->exact
= target_exact_watchpoints
&& reg_cnt
== 1;
2065 /* We need to determine how many resources are already
2066 used for all other hardware watchpoints plus this one
2067 to see if we still have enough resources to also fit
2068 this watchpoint in as well. */
2070 /* If this is a software watchpoint, we try to turn it
2071 to a hardware one -- count resources as if B was of
2072 hardware watchpoint type. */
2073 type
= b
->base
.type
;
2074 if (type
== bp_watchpoint
)
2075 type
= bp_hardware_watchpoint
;
2077 /* This watchpoint may or may not have been placed on
2078 the list yet at this point (it won't be in the list
2079 if we're trying to create it for the first time,
2080 through watch_command), so always account for it
2083 /* Count resources used by all watchpoints except B. */
2084 i
= hw_watchpoint_used_count_others (&b
->base
, type
, &other_type_used
);
2086 /* Add in the resources needed for B. */
2087 i
+= hw_watchpoint_use_count (&b
->base
);
2090 = target_can_use_hardware_watchpoint (type
, i
, other_type_used
);
2091 if (target_resources_ok
<= 0)
2093 int sw_mode
= b
->base
.ops
->works_in_software_mode (&b
->base
);
2095 if (target_resources_ok
== 0 && !sw_mode
)
2096 error (_("Target does not support this type of "
2097 "hardware watchpoint."));
2098 else if (target_resources_ok
< 0 && !sw_mode
)
2099 error (_("There are not enough available hardware "
2100 "resources for this watchpoint."));
2102 /* Downgrade to software watchpoint. */
2103 b
->base
.type
= bp_watchpoint
;
2107 /* If this was a software watchpoint, we've just
2108 found we have enough resources to turn it to a
2109 hardware watchpoint. Otherwise, this is a
2111 b
->base
.type
= type
;
2114 else if (!b
->base
.ops
->works_in_software_mode (&b
->base
))
2116 if (!can_use_hw_watchpoints
)
2117 error (_("Can't set read/access watchpoint when "
2118 "hardware watchpoints are disabled."));
2120 error (_("Expression cannot be implemented with "
2121 "read/access watchpoint."));
2124 b
->base
.type
= bp_watchpoint
;
2126 loc_type
= (b
->base
.type
== bp_watchpoint
? bp_loc_other
2127 : bp_loc_hardware_watchpoint
);
2128 for (bl
= b
->base
.loc
; bl
; bl
= bl
->next
)
2129 bl
->loc_type
= loc_type
;
2132 for (v
= val_chain
; v
; v
= next
)
2134 next
= value_next (v
);
2139 /* If a software watchpoint is not watching any memory, then the
2140 above left it without any location set up. But,
2141 bpstat_stop_status requires a location to be able to report
2142 stops, so make sure there's at least a dummy one. */
2143 if (b
->base
.type
== bp_watchpoint
&& b
->base
.loc
== NULL
)
2144 software_watchpoint_add_no_memory_location (&b
->base
, frame_pspace
);
2146 else if (!within_current_scope
)
2148 printf_filtered (_("\
2149 Watchpoint %d deleted because the program has left the block\n\
2150 in which its expression is valid.\n"),
2152 watchpoint_del_at_next_stop (b
);
2155 /* Restore the selected frame. */
2157 select_frame (frame_find_by_id (saved_frame_id
));
2161 /* Returns 1 iff breakpoint location should be
2162 inserted in the inferior. We don't differentiate the type of BL's owner
2163 (breakpoint vs. tracepoint), although insert_location in tracepoint's
2164 breakpoint_ops is not defined, because in insert_bp_location,
2165 tracepoint's insert_location will not be called. */
2167 should_be_inserted (struct bp_location
*bl
)
2169 if (bl
->owner
== NULL
|| !breakpoint_enabled (bl
->owner
))
2172 if (bl
->owner
->disposition
== disp_del_at_next_stop
)
2175 if (!bl
->enabled
|| bl
->shlib_disabled
|| bl
->duplicate
)
2178 if (user_breakpoint_p (bl
->owner
) && bl
->pspace
->executing_startup
)
2181 /* This is set for example, when we're attached to the parent of a
2182 vfork, and have detached from the child. The child is running
2183 free, and we expect it to do an exec or exit, at which point the
2184 OS makes the parent schedulable again (and the target reports
2185 that the vfork is done). Until the child is done with the shared
2186 memory region, do not insert breakpoints in the parent, otherwise
2187 the child could still trip on the parent's breakpoints. Since
2188 the parent is blocked anyway, it won't miss any breakpoint. */
2189 if (bl
->pspace
->breakpoints_not_allowed
)
2192 /* Don't insert a breakpoint if we're trying to step past its
2193 location, except if the breakpoint is a single-step breakpoint,
2194 and the breakpoint's thread is the thread which is stepping past
2196 if ((bl
->loc_type
== bp_loc_software_breakpoint
2197 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
2198 && stepping_past_instruction_at (bl
->pspace
->aspace
,
2200 /* The single-step breakpoint may be inserted at the location
2201 we're trying to step if the instruction branches to itself.
2202 However, the instruction won't be executed at all and it may
2203 break the semantics of the instruction, for example, the
2204 instruction is a conditional branch or updates some flags.
2205 We can't fix it unless GDB is able to emulate the instruction
2206 or switch to displaced stepping. */
2207 && !(bl
->owner
->type
== bp_single_step
2208 && thread_is_stepping_over_breakpoint (bl
->owner
->thread
)))
2212 fprintf_unfiltered (gdb_stdlog
,
2213 "infrun: skipping breakpoint: "
2214 "stepping past insn at: %s\n",
2215 paddress (bl
->gdbarch
, bl
->address
));
2220 /* Don't insert watchpoints if we're trying to step past the
2221 instruction that triggered one. */
2222 if ((bl
->loc_type
== bp_loc_hardware_watchpoint
)
2223 && stepping_past_nonsteppable_watchpoint ())
2227 fprintf_unfiltered (gdb_stdlog
,
2228 "infrun: stepping past non-steppable watchpoint. "
2229 "skipping watchpoint at %s:%d\n",
2230 paddress (bl
->gdbarch
, bl
->address
),
2239 /* Same as should_be_inserted but does the check assuming
2240 that the location is not duplicated. */
2243 unduplicated_should_be_inserted (struct bp_location
*bl
)
2246 const int save_duplicate
= bl
->duplicate
;
2249 result
= should_be_inserted (bl
);
2250 bl
->duplicate
= save_duplicate
;
2254 /* Parses a conditional described by an expression COND into an
2255 agent expression bytecode suitable for evaluation
2256 by the bytecode interpreter. Return NULL if there was
2257 any error during parsing. */
2259 static agent_expr_up
2260 parse_cond_to_aexpr (CORE_ADDR scope
, struct expression
*cond
)
2265 agent_expr_up aexpr
;
2267 /* We don't want to stop processing, so catch any errors
2268 that may show up. */
2271 aexpr
= gdb::move (gen_eval_for_expr (scope
, cond
));
2274 CATCH (ex
, RETURN_MASK_ERROR
)
2276 /* If we got here, it means the condition could not be parsed to a valid
2277 bytecode expression and thus can't be evaluated on the target's side.
2278 It's no use iterating through the conditions. */
2282 /* We have a valid agent expression. */
2286 /* Based on location BL, create a list of breakpoint conditions to be
2287 passed on to the target. If we have duplicated locations with different
2288 conditions, we will add such conditions to the list. The idea is that the
2289 target will evaluate the list of conditions and will only notify GDB when
2290 one of them is true. */
2293 build_target_condition_list (struct bp_location
*bl
)
2295 struct bp_location
**locp
= NULL
, **loc2p
;
2296 int null_condition_or_parse_error
= 0;
2297 int modified
= bl
->needs_update
;
2298 struct bp_location
*loc
;
2300 /* Release conditions left over from a previous insert. */
2301 VEC_free (agent_expr_p
, bl
->target_info
.conditions
);
2303 /* This is only meaningful if the target is
2304 evaluating conditions and if the user has
2305 opted for condition evaluation on the target's
2307 if (gdb_evaluates_breakpoint_condition_p ()
2308 || !target_supports_evaluation_of_breakpoint_conditions ())
2311 /* Do a first pass to check for locations with no assigned
2312 conditions or conditions that fail to parse to a valid agent expression
2313 bytecode. If any of these happen, then it's no use to send conditions
2314 to the target since this location will always trigger and generate a
2315 response back to GDB. */
2316 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2319 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2323 /* Re-parse the conditions since something changed. In that
2324 case we already freed the condition bytecodes (see
2325 force_breakpoint_reinsertion). We just
2326 need to parse the condition to bytecodes again. */
2327 loc
->cond_bytecode
= parse_cond_to_aexpr (bl
->address
,
2331 /* If we have a NULL bytecode expression, it means something
2332 went wrong or we have a null condition expression. */
2333 if (!loc
->cond_bytecode
)
2335 null_condition_or_parse_error
= 1;
2341 /* If any of these happened, it means we will have to evaluate the conditions
2342 for the location's address on gdb's side. It is no use keeping bytecodes
2343 for all the other duplicate locations, thus we free all of them here.
2345 This is so we have a finer control over which locations' conditions are
2346 being evaluated by GDB or the remote stub. */
2347 if (null_condition_or_parse_error
)
2349 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2352 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2354 /* Only go as far as the first NULL bytecode is
2356 if (!loc
->cond_bytecode
)
2359 loc
->cond_bytecode
.reset ();
2364 /* No NULL conditions or failed bytecode generation. Build a condition list
2365 for this location's address. */
2366 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2370 && is_breakpoint (loc
->owner
)
2371 && loc
->pspace
->num
== bl
->pspace
->num
2372 && loc
->owner
->enable_state
== bp_enabled
2374 /* Add the condition to the vector. This will be used later to send the
2375 conditions to the target. */
2376 VEC_safe_push (agent_expr_p
, bl
->target_info
.conditions
,
2377 loc
->cond_bytecode
.get ());
2383 /* Parses a command described by string CMD into an agent expression
2384 bytecode suitable for evaluation by the bytecode interpreter.
2385 Return NULL if there was any error during parsing. */
2387 static agent_expr_up
2388 parse_cmd_to_aexpr (CORE_ADDR scope
, char *cmd
)
2390 struct cleanup
*old_cleanups
= 0;
2391 struct expression
**argvec
;
2392 const char *cmdrest
;
2393 const char *format_start
, *format_end
;
2394 struct format_piece
*fpieces
;
2396 struct gdbarch
*gdbarch
= get_current_arch ();
2403 if (*cmdrest
== ',')
2405 cmdrest
= skip_spaces_const (cmdrest
);
2407 if (*cmdrest
++ != '"')
2408 error (_("No format string following the location"));
2410 format_start
= cmdrest
;
2412 fpieces
= parse_format_string (&cmdrest
);
2414 old_cleanups
= make_cleanup (free_format_pieces_cleanup
, &fpieces
);
2416 format_end
= cmdrest
;
2418 if (*cmdrest
++ != '"')
2419 error (_("Bad format string, non-terminated '\"'."));
2421 cmdrest
= skip_spaces_const (cmdrest
);
2423 if (!(*cmdrest
== ',' || *cmdrest
== '\0'))
2424 error (_("Invalid argument syntax"));
2426 if (*cmdrest
== ',')
2428 cmdrest
= skip_spaces_const (cmdrest
);
2430 /* For each argument, make an expression. */
2432 argvec
= (struct expression
**) alloca (strlen (cmd
)
2433 * sizeof (struct expression
*));
2436 while (*cmdrest
!= '\0')
2441 expression_up expr
= parse_exp_1 (&cmd1
, scope
, block_for_pc (scope
), 1);
2442 argvec
[nargs
++] = expr
.release ();
2444 if (*cmdrest
== ',')
2448 agent_expr_up aexpr
;
2450 /* We don't want to stop processing, so catch any errors
2451 that may show up. */
2454 aexpr
= gdb::move (gen_printf (scope
, gdbarch
, 0, 0,
2455 format_start
, format_end
- format_start
,
2456 fpieces
, nargs
, argvec
));
2458 CATCH (ex
, RETURN_MASK_ERROR
)
2460 /* If we got here, it means the command could not be parsed to a valid
2461 bytecode expression and thus can't be evaluated on the target's side.
2462 It's no use iterating through the other commands. */
2466 do_cleanups (old_cleanups
);
2468 /* We have a valid agent expression, return it. */
2472 /* Based on location BL, create a list of breakpoint commands to be
2473 passed on to the target. If we have duplicated locations with
2474 different commands, we will add any such to the list. */
2477 build_target_command_list (struct bp_location
*bl
)
2479 struct bp_location
**locp
= NULL
, **loc2p
;
2480 int null_command_or_parse_error
= 0;
2481 int modified
= bl
->needs_update
;
2482 struct bp_location
*loc
;
2484 /* Release commands left over from a previous insert. */
2485 VEC_free (agent_expr_p
, bl
->target_info
.tcommands
);
2487 if (!target_can_run_breakpoint_commands ())
2490 /* For now, limit to agent-style dprintf breakpoints. */
2491 if (dprintf_style
!= dprintf_style_agent
)
2494 /* For now, if we have any duplicate location that isn't a dprintf,
2495 don't install the target-side commands, as that would make the
2496 breakpoint not be reported to the core, and we'd lose
2498 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2501 if (is_breakpoint (loc
->owner
)
2502 && loc
->pspace
->num
== bl
->pspace
->num
2503 && loc
->owner
->type
!= bp_dprintf
)
2507 /* Do a first pass to check for locations with no assigned
2508 conditions or conditions that fail to parse to a valid agent expression
2509 bytecode. If any of these happen, then it's no use to send conditions
2510 to the target since this location will always trigger and generate a
2511 response back to GDB. */
2512 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2515 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2519 /* Re-parse the commands since something changed. In that
2520 case we already freed the command bytecodes (see
2521 force_breakpoint_reinsertion). We just
2522 need to parse the command to bytecodes again. */
2524 = parse_cmd_to_aexpr (bl
->address
,
2525 loc
->owner
->extra_string
);
2528 /* If we have a NULL bytecode expression, it means something
2529 went wrong or we have a null command expression. */
2530 if (!loc
->cmd_bytecode
)
2532 null_command_or_parse_error
= 1;
2538 /* If anything failed, then we're not doing target-side commands,
2540 if (null_command_or_parse_error
)
2542 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2545 if (is_breakpoint (loc
->owner
)
2546 && loc
->pspace
->num
== bl
->pspace
->num
)
2548 /* Only go as far as the first NULL bytecode is
2550 if (loc
->cmd_bytecode
== NULL
)
2553 loc
->cmd_bytecode
.reset ();
2558 /* No NULL commands or failed bytecode generation. Build a command list
2559 for this location's address. */
2560 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2563 if (loc
->owner
->extra_string
2564 && is_breakpoint (loc
->owner
)
2565 && loc
->pspace
->num
== bl
->pspace
->num
2566 && loc
->owner
->enable_state
== bp_enabled
2568 /* Add the command to the vector. This will be used later
2569 to send the commands to the target. */
2570 VEC_safe_push (agent_expr_p
, bl
->target_info
.tcommands
,
2571 loc
->cmd_bytecode
.get ());
2574 bl
->target_info
.persist
= 0;
2575 /* Maybe flag this location as persistent. */
2576 if (bl
->owner
->type
== bp_dprintf
&& disconnected_dprintf
)
2577 bl
->target_info
.persist
= 1;
2580 /* Return the kind of breakpoint on address *ADDR. Get the kind
2581 of breakpoint according to ADDR except single-step breakpoint.
2582 Get the kind of single-step breakpoint according to the current
2586 breakpoint_kind (struct bp_location
*bl
, CORE_ADDR
*addr
)
2588 if (bl
->owner
->type
== bp_single_step
)
2590 struct thread_info
*thr
= find_thread_global_id (bl
->owner
->thread
);
2591 struct regcache
*regcache
;
2593 regcache
= get_thread_regcache (thr
->ptid
);
2595 return gdbarch_breakpoint_kind_from_current_state (bl
->gdbarch
,
2599 return gdbarch_breakpoint_kind_from_pc (bl
->gdbarch
, addr
);
2602 /* Insert a low-level "breakpoint" of some type. BL is the breakpoint
2603 location. Any error messages are printed to TMP_ERROR_STREAM; and
2604 DISABLED_BREAKS, and HW_BREAKPOINT_ERROR are used to report problems.
2605 Returns 0 for success, 1 if the bp_location type is not supported or
2608 NOTE drow/2003-09-09: This routine could be broken down to an
2609 object-style method for each breakpoint or catchpoint type. */
2611 insert_bp_location (struct bp_location
*bl
,
2612 struct ui_file
*tmp_error_stream
,
2613 int *disabled_breaks
,
2614 int *hw_breakpoint_error
,
2615 int *hw_bp_error_explained_already
)
2617 enum errors bp_err
= GDB_NO_ERROR
;
2618 const char *bp_err_message
= NULL
;
2620 if (!should_be_inserted (bl
) || (bl
->inserted
&& !bl
->needs_update
))
2623 /* Note we don't initialize bl->target_info, as that wipes out
2624 the breakpoint location's shadow_contents if the breakpoint
2625 is still inserted at that location. This in turn breaks
2626 target_read_memory which depends on these buffers when
2627 a memory read is requested at the breakpoint location:
2628 Once the target_info has been wiped, we fail to see that
2629 we have a breakpoint inserted at that address and thus
2630 read the breakpoint instead of returning the data saved in
2631 the breakpoint location's shadow contents. */
2632 bl
->target_info
.reqstd_address
= bl
->address
;
2633 bl
->target_info
.placed_address_space
= bl
->pspace
->aspace
;
2634 bl
->target_info
.length
= bl
->length
;
2636 /* When working with target-side conditions, we must pass all the conditions
2637 for the same breakpoint address down to the target since GDB will not
2638 insert those locations. With a list of breakpoint conditions, the target
2639 can decide when to stop and notify GDB. */
2641 if (is_breakpoint (bl
->owner
))
2643 build_target_condition_list (bl
);
2644 build_target_command_list (bl
);
2645 /* Reset the modification marker. */
2646 bl
->needs_update
= 0;
2649 if (bl
->loc_type
== bp_loc_software_breakpoint
2650 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
2652 if (bl
->owner
->type
!= bp_hardware_breakpoint
)
2654 /* If the explicitly specified breakpoint type
2655 is not hardware breakpoint, check the memory map to see
2656 if the breakpoint address is in read only memory or not.
2658 Two important cases are:
2659 - location type is not hardware breakpoint, memory
2660 is readonly. We change the type of the location to
2661 hardware breakpoint.
2662 - location type is hardware breakpoint, memory is
2663 read-write. This means we've previously made the
2664 location hardware one, but then the memory map changed,
2667 When breakpoints are removed, remove_breakpoints will use
2668 location types we've just set here, the only possible
2669 problem is that memory map has changed during running
2670 program, but it's not going to work anyway with current
2672 struct mem_region
*mr
2673 = lookup_mem_region (bl
->target_info
.reqstd_address
);
2677 if (automatic_hardware_breakpoints
)
2679 enum bp_loc_type new_type
;
2681 if (mr
->attrib
.mode
!= MEM_RW
)
2682 new_type
= bp_loc_hardware_breakpoint
;
2684 new_type
= bp_loc_software_breakpoint
;
2686 if (new_type
!= bl
->loc_type
)
2688 static int said
= 0;
2690 bl
->loc_type
= new_type
;
2693 fprintf_filtered (gdb_stdout
,
2694 _("Note: automatically using "
2695 "hardware breakpoints for "
2696 "read-only addresses.\n"));
2701 else if (bl
->loc_type
== bp_loc_software_breakpoint
2702 && mr
->attrib
.mode
!= MEM_RW
)
2704 fprintf_unfiltered (tmp_error_stream
,
2705 _("Cannot insert breakpoint %d.\n"
2706 "Cannot set software breakpoint "
2707 "at read-only address %s\n"),
2709 paddress (bl
->gdbarch
, bl
->address
));
2715 /* First check to see if we have to handle an overlay. */
2716 if (overlay_debugging
== ovly_off
2717 || bl
->section
== NULL
2718 || !(section_is_overlay (bl
->section
)))
2720 /* No overlay handling: just set the breakpoint. */
2725 val
= bl
->owner
->ops
->insert_location (bl
);
2727 bp_err
= GENERIC_ERROR
;
2729 CATCH (e
, RETURN_MASK_ALL
)
2732 bp_err_message
= e
.message
;
2738 /* This breakpoint is in an overlay section.
2739 Shall we set a breakpoint at the LMA? */
2740 if (!overlay_events_enabled
)
2742 /* Yes -- overlay event support is not active,
2743 so we must try to set a breakpoint at the LMA.
2744 This will not work for a hardware breakpoint. */
2745 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
2746 warning (_("hardware breakpoint %d not supported in overlay!"),
2750 CORE_ADDR addr
= overlay_unmapped_address (bl
->address
,
2752 /* Set a software (trap) breakpoint at the LMA. */
2753 bl
->overlay_target_info
= bl
->target_info
;
2754 bl
->overlay_target_info
.reqstd_address
= addr
;
2756 /* No overlay handling: just set the breakpoint. */
2761 bl
->overlay_target_info
.kind
2762 = breakpoint_kind (bl
, &addr
);
2763 bl
->overlay_target_info
.placed_address
= addr
;
2764 val
= target_insert_breakpoint (bl
->gdbarch
,
2765 &bl
->overlay_target_info
);
2767 bp_err
= GENERIC_ERROR
;
2769 CATCH (e
, RETURN_MASK_ALL
)
2772 bp_err_message
= e
.message
;
2776 if (bp_err
!= GDB_NO_ERROR
)
2777 fprintf_unfiltered (tmp_error_stream
,
2778 "Overlay breakpoint %d "
2779 "failed: in ROM?\n",
2783 /* Shall we set a breakpoint at the VMA? */
2784 if (section_is_mapped (bl
->section
))
2786 /* Yes. This overlay section is mapped into memory. */
2791 val
= bl
->owner
->ops
->insert_location (bl
);
2793 bp_err
= GENERIC_ERROR
;
2795 CATCH (e
, RETURN_MASK_ALL
)
2798 bp_err_message
= e
.message
;
2804 /* No. This breakpoint will not be inserted.
2805 No error, but do not mark the bp as 'inserted'. */
2810 if (bp_err
!= GDB_NO_ERROR
)
2812 /* Can't set the breakpoint. */
2814 /* In some cases, we might not be able to insert a
2815 breakpoint in a shared library that has already been
2816 removed, but we have not yet processed the shlib unload
2817 event. Unfortunately, some targets that implement
2818 breakpoint insertion themselves can't tell why the
2819 breakpoint insertion failed (e.g., the remote target
2820 doesn't define error codes), so we must treat generic
2821 errors as memory errors. */
2822 if ((bp_err
== GENERIC_ERROR
|| bp_err
== MEMORY_ERROR
)
2823 && bl
->loc_type
== bp_loc_software_breakpoint
2824 && (solib_name_from_address (bl
->pspace
, bl
->address
)
2825 || shared_objfile_contains_address_p (bl
->pspace
,
2828 /* See also: disable_breakpoints_in_shlibs. */
2829 bl
->shlib_disabled
= 1;
2830 observer_notify_breakpoint_modified (bl
->owner
);
2831 if (!*disabled_breaks
)
2833 fprintf_unfiltered (tmp_error_stream
,
2834 "Cannot insert breakpoint %d.\n",
2836 fprintf_unfiltered (tmp_error_stream
,
2837 "Temporarily disabling shared "
2838 "library breakpoints:\n");
2840 *disabled_breaks
= 1;
2841 fprintf_unfiltered (tmp_error_stream
,
2842 "breakpoint #%d\n", bl
->owner
->number
);
2847 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
2849 *hw_breakpoint_error
= 1;
2850 *hw_bp_error_explained_already
= bp_err_message
!= NULL
;
2851 fprintf_unfiltered (tmp_error_stream
,
2852 "Cannot insert hardware breakpoint %d%s",
2853 bl
->owner
->number
, bp_err_message
? ":" : ".\n");
2854 if (bp_err_message
!= NULL
)
2855 fprintf_unfiltered (tmp_error_stream
, "%s.\n", bp_err_message
);
2859 if (bp_err_message
== NULL
)
2862 = memory_error_message (TARGET_XFER_E_IO
,
2863 bl
->gdbarch
, bl
->address
);
2864 struct cleanup
*old_chain
= make_cleanup (xfree
, message
);
2866 fprintf_unfiltered (tmp_error_stream
,
2867 "Cannot insert breakpoint %d.\n"
2869 bl
->owner
->number
, message
);
2870 do_cleanups (old_chain
);
2874 fprintf_unfiltered (tmp_error_stream
,
2875 "Cannot insert breakpoint %d: %s\n",
2890 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
2891 /* NOTE drow/2003-09-08: This state only exists for removing
2892 watchpoints. It's not clear that it's necessary... */
2893 && bl
->owner
->disposition
!= disp_del_at_next_stop
)
2897 gdb_assert (bl
->owner
->ops
!= NULL
2898 && bl
->owner
->ops
->insert_location
!= NULL
);
2900 val
= bl
->owner
->ops
->insert_location (bl
);
2902 /* If trying to set a read-watchpoint, and it turns out it's not
2903 supported, try emulating one with an access watchpoint. */
2904 if (val
== 1 && bl
->watchpoint_type
== hw_read
)
2906 struct bp_location
*loc
, **loc_temp
;
2908 /* But don't try to insert it, if there's already another
2909 hw_access location that would be considered a duplicate
2911 ALL_BP_LOCATIONS (loc
, loc_temp
)
2913 && loc
->watchpoint_type
== hw_access
2914 && watchpoint_locations_match (bl
, loc
))
2918 bl
->target_info
= loc
->target_info
;
2919 bl
->watchpoint_type
= hw_access
;
2926 bl
->watchpoint_type
= hw_access
;
2927 val
= bl
->owner
->ops
->insert_location (bl
);
2930 /* Back to the original value. */
2931 bl
->watchpoint_type
= hw_read
;
2935 bl
->inserted
= (val
== 0);
2938 else if (bl
->owner
->type
== bp_catchpoint
)
2942 gdb_assert (bl
->owner
->ops
!= NULL
2943 && bl
->owner
->ops
->insert_location
!= NULL
);
2945 val
= bl
->owner
->ops
->insert_location (bl
);
2948 bl
->owner
->enable_state
= bp_disabled
;
2952 Error inserting catchpoint %d: Your system does not support this type\n\
2953 of catchpoint."), bl
->owner
->number
);
2955 warning (_("Error inserting catchpoint %d."), bl
->owner
->number
);
2958 bl
->inserted
= (val
== 0);
2960 /* We've already printed an error message if there was a problem
2961 inserting this catchpoint, and we've disabled the catchpoint,
2962 so just return success. */
2969 /* This function is called when program space PSPACE is about to be
2970 deleted. It takes care of updating breakpoints to not reference
2974 breakpoint_program_space_exit (struct program_space
*pspace
)
2976 struct breakpoint
*b
, *b_temp
;
2977 struct bp_location
*loc
, **loc_temp
;
2979 /* Remove any breakpoint that was set through this program space. */
2980 ALL_BREAKPOINTS_SAFE (b
, b_temp
)
2982 if (b
->pspace
== pspace
)
2983 delete_breakpoint (b
);
2986 /* Breakpoints set through other program spaces could have locations
2987 bound to PSPACE as well. Remove those. */
2988 ALL_BP_LOCATIONS (loc
, loc_temp
)
2990 struct bp_location
*tmp
;
2992 if (loc
->pspace
== pspace
)
2994 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
2995 if (loc
->owner
->loc
== loc
)
2996 loc
->owner
->loc
= loc
->next
;
2998 for (tmp
= loc
->owner
->loc
; tmp
->next
!= NULL
; tmp
= tmp
->next
)
2999 if (tmp
->next
== loc
)
3001 tmp
->next
= loc
->next
;
3007 /* Now update the global location list to permanently delete the
3008 removed locations above. */
3009 update_global_location_list (UGLL_DONT_INSERT
);
3012 /* Make sure all breakpoints are inserted in inferior.
3013 Throws exception on any error.
3014 A breakpoint that is already inserted won't be inserted
3015 again, so calling this function twice is safe. */
3017 insert_breakpoints (void)
3019 struct breakpoint
*bpt
;
3021 ALL_BREAKPOINTS (bpt
)
3022 if (is_hardware_watchpoint (bpt
))
3024 struct watchpoint
*w
= (struct watchpoint
*) bpt
;
3026 update_watchpoint (w
, 0 /* don't reparse. */);
3029 /* Updating watchpoints creates new locations, so update the global
3030 location list. Explicitly tell ugll to insert locations and
3031 ignore breakpoints_always_inserted_mode. */
3032 update_global_location_list (UGLL_INSERT
);
3035 /* Invoke CALLBACK for each of bp_location. */
3038 iterate_over_bp_locations (walk_bp_location_callback callback
)
3040 struct bp_location
*loc
, **loc_tmp
;
3042 ALL_BP_LOCATIONS (loc
, loc_tmp
)
3044 callback (loc
, NULL
);
3048 /* This is used when we need to synch breakpoint conditions between GDB and the
3049 target. It is the case with deleting and disabling of breakpoints when using
3050 always-inserted mode. */
3053 update_inserted_breakpoint_locations (void)
3055 struct bp_location
*bl
, **blp_tmp
;
3058 int disabled_breaks
= 0;
3059 int hw_breakpoint_error
= 0;
3060 int hw_bp_details_reported
= 0;
3062 struct ui_file
*tmp_error_stream
= mem_fileopen ();
3063 struct cleanup
*cleanups
= make_cleanup_ui_file_delete (tmp_error_stream
);
3065 /* Explicitly mark the warning -- this will only be printed if
3066 there was an error. */
3067 fprintf_unfiltered (tmp_error_stream
, "Warning:\n");
3069 save_current_space_and_thread ();
3071 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3073 /* We only want to update software breakpoints and hardware
3075 if (!is_breakpoint (bl
->owner
))
3078 /* We only want to update locations that are already inserted
3079 and need updating. This is to avoid unwanted insertion during
3080 deletion of breakpoints. */
3081 if (!bl
->inserted
|| (bl
->inserted
&& !bl
->needs_update
))
3084 switch_to_program_space_and_thread (bl
->pspace
);
3086 /* For targets that support global breakpoints, there's no need
3087 to select an inferior to insert breakpoint to. In fact, even
3088 if we aren't attached to any process yet, we should still
3089 insert breakpoints. */
3090 if (!gdbarch_has_global_breakpoints (target_gdbarch ())
3091 && ptid_equal (inferior_ptid
, null_ptid
))
3094 val
= insert_bp_location (bl
, tmp_error_stream
, &disabled_breaks
,
3095 &hw_breakpoint_error
, &hw_bp_details_reported
);
3102 target_terminal_ours_for_output ();
3103 error_stream (tmp_error_stream
);
3106 do_cleanups (cleanups
);
3109 /* Used when starting or continuing the program. */
3112 insert_breakpoint_locations (void)
3114 struct breakpoint
*bpt
;
3115 struct bp_location
*bl
, **blp_tmp
;
3118 int disabled_breaks
= 0;
3119 int hw_breakpoint_error
= 0;
3120 int hw_bp_error_explained_already
= 0;
3122 struct ui_file
*tmp_error_stream
= mem_fileopen ();
3123 struct cleanup
*cleanups
= make_cleanup_ui_file_delete (tmp_error_stream
);
3125 /* Explicitly mark the warning -- this will only be printed if
3126 there was an error. */
3127 fprintf_unfiltered (tmp_error_stream
, "Warning:\n");
3129 save_current_space_and_thread ();
3131 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3133 if (!should_be_inserted (bl
) || (bl
->inserted
&& !bl
->needs_update
))
3136 /* There is no point inserting thread-specific breakpoints if
3137 the thread no longer exists. ALL_BP_LOCATIONS bp_location
3138 has BL->OWNER always non-NULL. */
3139 if (bl
->owner
->thread
!= -1
3140 && !valid_global_thread_id (bl
->owner
->thread
))
3143 switch_to_program_space_and_thread (bl
->pspace
);
3145 /* For targets that support global breakpoints, there's no need
3146 to select an inferior to insert breakpoint to. In fact, even
3147 if we aren't attached to any process yet, we should still
3148 insert breakpoints. */
3149 if (!gdbarch_has_global_breakpoints (target_gdbarch ())
3150 && ptid_equal (inferior_ptid
, null_ptid
))
3153 val
= insert_bp_location (bl
, tmp_error_stream
, &disabled_breaks
,
3154 &hw_breakpoint_error
, &hw_bp_error_explained_already
);
3159 /* If we failed to insert all locations of a watchpoint, remove
3160 them, as half-inserted watchpoint is of limited use. */
3161 ALL_BREAKPOINTS (bpt
)
3163 int some_failed
= 0;
3164 struct bp_location
*loc
;
3166 if (!is_hardware_watchpoint (bpt
))
3169 if (!breakpoint_enabled (bpt
))
3172 if (bpt
->disposition
== disp_del_at_next_stop
)
3175 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
3176 if (!loc
->inserted
&& should_be_inserted (loc
))
3183 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
3185 remove_breakpoint (loc
);
3187 hw_breakpoint_error
= 1;
3188 fprintf_unfiltered (tmp_error_stream
,
3189 "Could not insert hardware watchpoint %d.\n",
3197 /* If a hardware breakpoint or watchpoint was inserted, add a
3198 message about possibly exhausted resources. */
3199 if (hw_breakpoint_error
&& !hw_bp_error_explained_already
)
3201 fprintf_unfiltered (tmp_error_stream
,
3202 "Could not insert hardware breakpoints:\n\
3203 You may have requested too many hardware breakpoints/watchpoints.\n");
3205 target_terminal_ours_for_output ();
3206 error_stream (tmp_error_stream
);
3209 do_cleanups (cleanups
);
3212 /* Used when the program stops.
3213 Returns zero if successful, or non-zero if there was a problem
3214 removing a breakpoint location. */
3217 remove_breakpoints (void)
3219 struct bp_location
*bl
, **blp_tmp
;
3222 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3224 if (bl
->inserted
&& !is_tracepoint (bl
->owner
))
3225 val
|= remove_breakpoint (bl
);
3230 /* When a thread exits, remove breakpoints that are related to
3234 remove_threaded_breakpoints (struct thread_info
*tp
, int silent
)
3236 struct breakpoint
*b
, *b_tmp
;
3238 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
3240 if (b
->thread
== tp
->global_num
&& user_breakpoint_p (b
))
3242 b
->disposition
= disp_del_at_next_stop
;
3244 printf_filtered (_("\
3245 Thread-specific breakpoint %d deleted - thread %s no longer in the thread list.\n"),
3246 b
->number
, print_thread_id (tp
));
3248 /* Hide it from the user. */
3254 /* Remove breakpoints of process PID. */
3257 remove_breakpoints_pid (int pid
)
3259 struct bp_location
*bl
, **blp_tmp
;
3261 struct inferior
*inf
= find_inferior_pid (pid
);
3263 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3265 if (bl
->pspace
!= inf
->pspace
)
3268 if (bl
->inserted
&& !bl
->target_info
.persist
)
3270 val
= remove_breakpoint (bl
);
3279 reattach_breakpoints (int pid
)
3281 struct cleanup
*old_chain
;
3282 struct bp_location
*bl
, **blp_tmp
;
3284 struct ui_file
*tmp_error_stream
;
3285 int dummy1
= 0, dummy2
= 0, dummy3
= 0;
3286 struct inferior
*inf
;
3287 struct thread_info
*tp
;
3289 tp
= any_live_thread_of_process (pid
);
3293 inf
= find_inferior_pid (pid
);
3294 old_chain
= save_inferior_ptid ();
3296 inferior_ptid
= tp
->ptid
;
3298 tmp_error_stream
= mem_fileopen ();
3299 make_cleanup_ui_file_delete (tmp_error_stream
);
3301 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3303 if (bl
->pspace
!= inf
->pspace
)
3309 val
= insert_bp_location (bl
, tmp_error_stream
, &dummy1
, &dummy2
, &dummy3
);
3312 do_cleanups (old_chain
);
3317 do_cleanups (old_chain
);
3321 static int internal_breakpoint_number
= -1;
3323 /* Set the breakpoint number of B, depending on the value of INTERNAL.
3324 If INTERNAL is non-zero, the breakpoint number will be populated
3325 from internal_breakpoint_number and that variable decremented.
3326 Otherwise the breakpoint number will be populated from
3327 breakpoint_count and that value incremented. Internal breakpoints
3328 do not set the internal var bpnum. */
3330 set_breakpoint_number (int internal
, struct breakpoint
*b
)
3333 b
->number
= internal_breakpoint_number
--;
3336 set_breakpoint_count (breakpoint_count
+ 1);
3337 b
->number
= breakpoint_count
;
3341 static struct breakpoint
*
3342 create_internal_breakpoint (struct gdbarch
*gdbarch
,
3343 CORE_ADDR address
, enum bptype type
,
3344 const struct breakpoint_ops
*ops
)
3346 struct symtab_and_line sal
;
3347 struct breakpoint
*b
;
3349 init_sal (&sal
); /* Initialize to zeroes. */
3352 sal
.section
= find_pc_overlay (sal
.pc
);
3353 sal
.pspace
= current_program_space
;
3355 b
= set_raw_breakpoint (gdbarch
, sal
, type
, ops
);
3356 b
->number
= internal_breakpoint_number
--;
3357 b
->disposition
= disp_donttouch
;
3362 static const char *const longjmp_names
[] =
3364 "longjmp", "_longjmp", "siglongjmp", "_siglongjmp"
3366 #define NUM_LONGJMP_NAMES ARRAY_SIZE(longjmp_names)
3368 /* Per-objfile data private to breakpoint.c. */
3369 struct breakpoint_objfile_data
3371 /* Minimal symbol for "_ovly_debug_event" (if any). */
3372 struct bound_minimal_symbol overlay_msym
;
3374 /* Minimal symbol(s) for "longjmp", "siglongjmp", etc. (if any). */
3375 struct bound_minimal_symbol longjmp_msym
[NUM_LONGJMP_NAMES
];
3377 /* True if we have looked for longjmp probes. */
3378 int longjmp_searched
;
3380 /* SystemTap probe points for longjmp (if any). */
3381 VEC (probe_p
) *longjmp_probes
;
3383 /* Minimal symbol for "std::terminate()" (if any). */
3384 struct bound_minimal_symbol terminate_msym
;
3386 /* Minimal symbol for "_Unwind_DebugHook" (if any). */
3387 struct bound_minimal_symbol exception_msym
;
3389 /* True if we have looked for exception probes. */
3390 int exception_searched
;
3392 /* SystemTap probe points for unwinding (if any). */
3393 VEC (probe_p
) *exception_probes
;
3396 static const struct objfile_data
*breakpoint_objfile_key
;
3398 /* Minimal symbol not found sentinel. */
3399 static struct minimal_symbol msym_not_found
;
3401 /* Returns TRUE if MSYM point to the "not found" sentinel. */
3404 msym_not_found_p (const struct minimal_symbol
*msym
)
3406 return msym
== &msym_not_found
;
3409 /* Return per-objfile data needed by breakpoint.c.
3410 Allocate the data if necessary. */
3412 static struct breakpoint_objfile_data
*
3413 get_breakpoint_objfile_data (struct objfile
*objfile
)
3415 struct breakpoint_objfile_data
*bp_objfile_data
;
3417 bp_objfile_data
= ((struct breakpoint_objfile_data
*)
3418 objfile_data (objfile
, breakpoint_objfile_key
));
3419 if (bp_objfile_data
== NULL
)
3422 XOBNEW (&objfile
->objfile_obstack
, struct breakpoint_objfile_data
);
3424 memset (bp_objfile_data
, 0, sizeof (*bp_objfile_data
));
3425 set_objfile_data (objfile
, breakpoint_objfile_key
, bp_objfile_data
);
3427 return bp_objfile_data
;
3431 free_breakpoint_probes (struct objfile
*obj
, void *data
)
3433 struct breakpoint_objfile_data
*bp_objfile_data
3434 = (struct breakpoint_objfile_data
*) data
;
3436 VEC_free (probe_p
, bp_objfile_data
->longjmp_probes
);
3437 VEC_free (probe_p
, bp_objfile_data
->exception_probes
);
3441 create_overlay_event_breakpoint (void)
3443 struct objfile
*objfile
;
3444 const char *const func_name
= "_ovly_debug_event";
3446 ALL_OBJFILES (objfile
)
3448 struct breakpoint
*b
;
3449 struct breakpoint_objfile_data
*bp_objfile_data
;
3451 struct explicit_location explicit_loc
;
3453 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3455 if (msym_not_found_p (bp_objfile_data
->overlay_msym
.minsym
))
3458 if (bp_objfile_data
->overlay_msym
.minsym
== NULL
)
3460 struct bound_minimal_symbol m
;
3462 m
= lookup_minimal_symbol_text (func_name
, objfile
);
3463 if (m
.minsym
== NULL
)
3465 /* Avoid future lookups in this objfile. */
3466 bp_objfile_data
->overlay_msym
.minsym
= &msym_not_found
;
3469 bp_objfile_data
->overlay_msym
= m
;
3472 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->overlay_msym
);
3473 b
= create_internal_breakpoint (get_objfile_arch (objfile
), addr
,
3475 &internal_breakpoint_ops
);
3476 initialize_explicit_location (&explicit_loc
);
3477 explicit_loc
.function_name
= ASTRDUP (func_name
);
3478 b
->location
= new_explicit_location (&explicit_loc
);
3480 if (overlay_debugging
== ovly_auto
)
3482 b
->enable_state
= bp_enabled
;
3483 overlay_events_enabled
= 1;
3487 b
->enable_state
= bp_disabled
;
3488 overlay_events_enabled
= 0;
3494 create_longjmp_master_breakpoint (void)
3496 struct program_space
*pspace
;
3497 struct cleanup
*old_chain
;
3499 old_chain
= save_current_program_space ();
3501 ALL_PSPACES (pspace
)
3503 struct objfile
*objfile
;
3505 set_current_program_space (pspace
);
3507 ALL_OBJFILES (objfile
)
3510 struct gdbarch
*gdbarch
;
3511 struct breakpoint_objfile_data
*bp_objfile_data
;
3513 gdbarch
= get_objfile_arch (objfile
);
3515 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3517 if (!bp_objfile_data
->longjmp_searched
)
3521 ret
= find_probes_in_objfile (objfile
, "libc", "longjmp");
3524 /* We are only interested in checking one element. */
3525 struct probe
*p
= VEC_index (probe_p
, ret
, 0);
3527 if (!can_evaluate_probe_arguments (p
))
3529 /* We cannot use the probe interface here, because it does
3530 not know how to evaluate arguments. */
3531 VEC_free (probe_p
, ret
);
3535 bp_objfile_data
->longjmp_probes
= ret
;
3536 bp_objfile_data
->longjmp_searched
= 1;
3539 if (bp_objfile_data
->longjmp_probes
!= NULL
)
3542 struct probe
*probe
;
3543 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3546 VEC_iterate (probe_p
,
3547 bp_objfile_data
->longjmp_probes
,
3551 struct breakpoint
*b
;
3553 b
= create_internal_breakpoint (gdbarch
,
3554 get_probe_address (probe
,
3557 &internal_breakpoint_ops
);
3559 = new_probe_location ("-probe-stap libc:longjmp");
3560 b
->enable_state
= bp_disabled
;
3566 if (!gdbarch_get_longjmp_target_p (gdbarch
))
3569 for (i
= 0; i
< NUM_LONGJMP_NAMES
; i
++)
3571 struct breakpoint
*b
;
3572 const char *func_name
;
3574 struct explicit_location explicit_loc
;
3576 if (msym_not_found_p (bp_objfile_data
->longjmp_msym
[i
].minsym
))
3579 func_name
= longjmp_names
[i
];
3580 if (bp_objfile_data
->longjmp_msym
[i
].minsym
== NULL
)
3582 struct bound_minimal_symbol m
;
3584 m
= lookup_minimal_symbol_text (func_name
, objfile
);
3585 if (m
.minsym
== NULL
)
3587 /* Prevent future lookups in this objfile. */
3588 bp_objfile_data
->longjmp_msym
[i
].minsym
= &msym_not_found
;
3591 bp_objfile_data
->longjmp_msym
[i
] = m
;
3594 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->longjmp_msym
[i
]);
3595 b
= create_internal_breakpoint (gdbarch
, addr
, bp_longjmp_master
,
3596 &internal_breakpoint_ops
);
3597 initialize_explicit_location (&explicit_loc
);
3598 explicit_loc
.function_name
= ASTRDUP (func_name
);
3599 b
->location
= new_explicit_location (&explicit_loc
);
3600 b
->enable_state
= bp_disabled
;
3605 do_cleanups (old_chain
);
3608 /* Create a master std::terminate breakpoint. */
3610 create_std_terminate_master_breakpoint (void)
3612 struct program_space
*pspace
;
3613 struct cleanup
*old_chain
;
3614 const char *const func_name
= "std::terminate()";
3616 old_chain
= save_current_program_space ();
3618 ALL_PSPACES (pspace
)
3620 struct objfile
*objfile
;
3623 set_current_program_space (pspace
);
3625 ALL_OBJFILES (objfile
)
3627 struct breakpoint
*b
;
3628 struct breakpoint_objfile_data
*bp_objfile_data
;
3629 struct explicit_location explicit_loc
;
3631 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3633 if (msym_not_found_p (bp_objfile_data
->terminate_msym
.minsym
))
3636 if (bp_objfile_data
->terminate_msym
.minsym
== NULL
)
3638 struct bound_minimal_symbol m
;
3640 m
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
3641 if (m
.minsym
== NULL
|| (MSYMBOL_TYPE (m
.minsym
) != mst_text
3642 && MSYMBOL_TYPE (m
.minsym
) != mst_file_text
))
3644 /* Prevent future lookups in this objfile. */
3645 bp_objfile_data
->terminate_msym
.minsym
= &msym_not_found
;
3648 bp_objfile_data
->terminate_msym
= m
;
3651 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->terminate_msym
);
3652 b
= create_internal_breakpoint (get_objfile_arch (objfile
), addr
,
3653 bp_std_terminate_master
,
3654 &internal_breakpoint_ops
);
3655 initialize_explicit_location (&explicit_loc
);
3656 explicit_loc
.function_name
= ASTRDUP (func_name
);
3657 b
->location
= new_explicit_location (&explicit_loc
);
3658 b
->enable_state
= bp_disabled
;
3662 do_cleanups (old_chain
);
3665 /* Install a master breakpoint on the unwinder's debug hook. */
3668 create_exception_master_breakpoint (void)
3670 struct objfile
*objfile
;
3671 const char *const func_name
= "_Unwind_DebugHook";
3673 ALL_OBJFILES (objfile
)
3675 struct breakpoint
*b
;
3676 struct gdbarch
*gdbarch
;
3677 struct breakpoint_objfile_data
*bp_objfile_data
;
3679 struct explicit_location explicit_loc
;
3681 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3683 /* We prefer the SystemTap probe point if it exists. */
3684 if (!bp_objfile_data
->exception_searched
)
3688 ret
= find_probes_in_objfile (objfile
, "libgcc", "unwind");
3692 /* We are only interested in checking one element. */
3693 struct probe
*p
= VEC_index (probe_p
, ret
, 0);
3695 if (!can_evaluate_probe_arguments (p
))
3697 /* We cannot use the probe interface here, because it does
3698 not know how to evaluate arguments. */
3699 VEC_free (probe_p
, ret
);
3703 bp_objfile_data
->exception_probes
= ret
;
3704 bp_objfile_data
->exception_searched
= 1;
3707 if (bp_objfile_data
->exception_probes
!= NULL
)
3709 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3711 struct probe
*probe
;
3714 VEC_iterate (probe_p
,
3715 bp_objfile_data
->exception_probes
,
3719 struct breakpoint
*b
;
3721 b
= create_internal_breakpoint (gdbarch
,
3722 get_probe_address (probe
,
3724 bp_exception_master
,
3725 &internal_breakpoint_ops
);
3727 = new_probe_location ("-probe-stap libgcc:unwind");
3728 b
->enable_state
= bp_disabled
;
3734 /* Otherwise, try the hook function. */
3736 if (msym_not_found_p (bp_objfile_data
->exception_msym
.minsym
))
3739 gdbarch
= get_objfile_arch (objfile
);
3741 if (bp_objfile_data
->exception_msym
.minsym
== NULL
)
3743 struct bound_minimal_symbol debug_hook
;
3745 debug_hook
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
3746 if (debug_hook
.minsym
== NULL
)
3748 bp_objfile_data
->exception_msym
.minsym
= &msym_not_found
;
3752 bp_objfile_data
->exception_msym
= debug_hook
;
3755 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->exception_msym
);
3756 addr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, addr
,
3758 b
= create_internal_breakpoint (gdbarch
, addr
, bp_exception_master
,
3759 &internal_breakpoint_ops
);
3760 initialize_explicit_location (&explicit_loc
);
3761 explicit_loc
.function_name
= ASTRDUP (func_name
);
3762 b
->location
= new_explicit_location (&explicit_loc
);
3763 b
->enable_state
= bp_disabled
;
3767 /* Does B have a location spec? */
3770 breakpoint_event_location_empty_p (const struct breakpoint
*b
)
3772 return b
->location
!= NULL
&& event_location_empty_p (b
->location
);
3776 update_breakpoints_after_exec (void)
3778 struct breakpoint
*b
, *b_tmp
;
3779 struct bp_location
*bploc
, **bplocp_tmp
;
3781 /* We're about to delete breakpoints from GDB's lists. If the
3782 INSERTED flag is true, GDB will try to lift the breakpoints by
3783 writing the breakpoints' "shadow contents" back into memory. The
3784 "shadow contents" are NOT valid after an exec, so GDB should not
3785 do that. Instead, the target is responsible from marking
3786 breakpoints out as soon as it detects an exec. We don't do that
3787 here instead, because there may be other attempts to delete
3788 breakpoints after detecting an exec and before reaching here. */
3789 ALL_BP_LOCATIONS (bploc
, bplocp_tmp
)
3790 if (bploc
->pspace
== current_program_space
)
3791 gdb_assert (!bploc
->inserted
);
3793 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
3795 if (b
->pspace
!= current_program_space
)
3798 /* Solib breakpoints must be explicitly reset after an exec(). */
3799 if (b
->type
== bp_shlib_event
)
3801 delete_breakpoint (b
);
3805 /* JIT breakpoints must be explicitly reset after an exec(). */
3806 if (b
->type
== bp_jit_event
)
3808 delete_breakpoint (b
);
3812 /* Thread event breakpoints must be set anew after an exec(),
3813 as must overlay event and longjmp master breakpoints. */
3814 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
3815 || b
->type
== bp_longjmp_master
|| b
->type
== bp_std_terminate_master
3816 || b
->type
== bp_exception_master
)
3818 delete_breakpoint (b
);
3822 /* Step-resume breakpoints are meaningless after an exec(). */
3823 if (b
->type
== bp_step_resume
|| b
->type
== bp_hp_step_resume
)
3825 delete_breakpoint (b
);
3829 /* Just like single-step breakpoints. */
3830 if (b
->type
== bp_single_step
)
3832 delete_breakpoint (b
);
3836 /* Longjmp and longjmp-resume breakpoints are also meaningless
3838 if (b
->type
== bp_longjmp
|| b
->type
== bp_longjmp_resume
3839 || b
->type
== bp_longjmp_call_dummy
3840 || b
->type
== bp_exception
|| b
->type
== bp_exception_resume
)
3842 delete_breakpoint (b
);
3846 if (b
->type
== bp_catchpoint
)
3848 /* For now, none of the bp_catchpoint breakpoints need to
3849 do anything at this point. In the future, if some of
3850 the catchpoints need to something, we will need to add
3851 a new method, and call this method from here. */
3855 /* bp_finish is a special case. The only way we ought to be able
3856 to see one of these when an exec() has happened, is if the user
3857 caught a vfork, and then said "finish". Ordinarily a finish just
3858 carries them to the call-site of the current callee, by setting
3859 a temporary bp there and resuming. But in this case, the finish
3860 will carry them entirely through the vfork & exec.
3862 We don't want to allow a bp_finish to remain inserted now. But
3863 we can't safely delete it, 'cause finish_command has a handle to
3864 the bp on a bpstat, and will later want to delete it. There's a
3865 chance (and I've seen it happen) that if we delete the bp_finish
3866 here, that its storage will get reused by the time finish_command
3867 gets 'round to deleting the "use to be a bp_finish" breakpoint.
3868 We really must allow finish_command to delete a bp_finish.
3870 In the absence of a general solution for the "how do we know
3871 it's safe to delete something others may have handles to?"
3872 problem, what we'll do here is just uninsert the bp_finish, and
3873 let finish_command delete it.
3875 (We know the bp_finish is "doomed" in the sense that it's
3876 momentary, and will be deleted as soon as finish_command sees
3877 the inferior stopped. So it doesn't matter that the bp's
3878 address is probably bogus in the new a.out, unlike e.g., the
3879 solib breakpoints.) */
3881 if (b
->type
== bp_finish
)
3886 /* Without a symbolic address, we have little hope of the
3887 pre-exec() address meaning the same thing in the post-exec()
3889 if (breakpoint_event_location_empty_p (b
))
3891 delete_breakpoint (b
);
3898 detach_breakpoints (ptid_t ptid
)
3900 struct bp_location
*bl
, **blp_tmp
;
3902 struct cleanup
*old_chain
= save_inferior_ptid ();
3903 struct inferior
*inf
= current_inferior ();
3905 if (ptid_get_pid (ptid
) == ptid_get_pid (inferior_ptid
))
3906 error (_("Cannot detach breakpoints of inferior_ptid"));
3908 /* Set inferior_ptid; remove_breakpoint_1 uses this global. */
3909 inferior_ptid
= ptid
;
3910 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3912 if (bl
->pspace
!= inf
->pspace
)
3915 /* This function must physically remove breakpoints locations
3916 from the specified ptid, without modifying the breakpoint
3917 package's state. Locations of type bp_loc_other are only
3918 maintained at GDB side. So, there is no need to remove
3919 these bp_loc_other locations. Moreover, removing these
3920 would modify the breakpoint package's state. */
3921 if (bl
->loc_type
== bp_loc_other
)
3925 val
|= remove_breakpoint_1 (bl
, DETACH_BREAKPOINT
);
3928 do_cleanups (old_chain
);
3932 /* Remove the breakpoint location BL from the current address space.
3933 Note that this is used to detach breakpoints from a child fork.
3934 When we get here, the child isn't in the inferior list, and neither
3935 do we have objects to represent its address space --- we should
3936 *not* look at bl->pspace->aspace here. */
3939 remove_breakpoint_1 (struct bp_location
*bl
, enum remove_bp_reason reason
)
3943 /* BL is never in moribund_locations by our callers. */
3944 gdb_assert (bl
->owner
!= NULL
);
3946 /* The type of none suggests that owner is actually deleted.
3947 This should not ever happen. */
3948 gdb_assert (bl
->owner
->type
!= bp_none
);
3950 if (bl
->loc_type
== bp_loc_software_breakpoint
3951 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
3953 /* "Normal" instruction breakpoint: either the standard
3954 trap-instruction bp (bp_breakpoint), or a
3955 bp_hardware_breakpoint. */
3957 /* First check to see if we have to handle an overlay. */
3958 if (overlay_debugging
== ovly_off
3959 || bl
->section
== NULL
3960 || !(section_is_overlay (bl
->section
)))
3962 /* No overlay handling: just remove the breakpoint. */
3964 /* If we're trying to uninsert a memory breakpoint that we
3965 know is set in a dynamic object that is marked
3966 shlib_disabled, then either the dynamic object was
3967 removed with "remove-symbol-file" or with
3968 "nosharedlibrary". In the former case, we don't know
3969 whether another dynamic object might have loaded over the
3970 breakpoint's address -- the user might well let us know
3971 about it next with add-symbol-file (the whole point of
3972 add-symbol-file is letting the user manually maintain a
3973 list of dynamically loaded objects). If we have the
3974 breakpoint's shadow memory, that is, this is a software
3975 breakpoint managed by GDB, check whether the breakpoint
3976 is still inserted in memory, to avoid overwriting wrong
3977 code with stale saved shadow contents. Note that HW
3978 breakpoints don't have shadow memory, as they're
3979 implemented using a mechanism that is not dependent on
3980 being able to modify the target's memory, and as such
3981 they should always be removed. */
3982 if (bl
->shlib_disabled
3983 && bl
->target_info
.shadow_len
!= 0
3984 && !memory_validate_breakpoint (bl
->gdbarch
, &bl
->target_info
))
3987 val
= bl
->owner
->ops
->remove_location (bl
, reason
);
3991 /* This breakpoint is in an overlay section.
3992 Did we set a breakpoint at the LMA? */
3993 if (!overlay_events_enabled
)
3995 /* Yes -- overlay event support is not active, so we
3996 should have set a breakpoint at the LMA. Remove it.
3998 /* Ignore any failures: if the LMA is in ROM, we will
3999 have already warned when we failed to insert it. */
4000 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
4001 target_remove_hw_breakpoint (bl
->gdbarch
,
4002 &bl
->overlay_target_info
);
4004 target_remove_breakpoint (bl
->gdbarch
,
4005 &bl
->overlay_target_info
,
4008 /* Did we set a breakpoint at the VMA?
4009 If so, we will have marked the breakpoint 'inserted'. */
4012 /* Yes -- remove it. Previously we did not bother to
4013 remove the breakpoint if the section had been
4014 unmapped, but let's not rely on that being safe. We
4015 don't know what the overlay manager might do. */
4017 /* However, we should remove *software* breakpoints only
4018 if the section is still mapped, or else we overwrite
4019 wrong code with the saved shadow contents. */
4020 if (bl
->loc_type
== bp_loc_hardware_breakpoint
4021 || section_is_mapped (bl
->section
))
4022 val
= bl
->owner
->ops
->remove_location (bl
, reason
);
4028 /* No -- not inserted, so no need to remove. No error. */
4033 /* In some cases, we might not be able to remove a breakpoint in
4034 a shared library that has already been removed, but we have
4035 not yet processed the shlib unload event. Similarly for an
4036 unloaded add-symbol-file object - the user might not yet have
4037 had the chance to remove-symbol-file it. shlib_disabled will
4038 be set if the library/object has already been removed, but
4039 the breakpoint hasn't been uninserted yet, e.g., after
4040 "nosharedlibrary" or "remove-symbol-file" with breakpoints
4041 always-inserted mode. */
4043 && (bl
->loc_type
== bp_loc_software_breakpoint
4044 && (bl
->shlib_disabled
4045 || solib_name_from_address (bl
->pspace
, bl
->address
)
4046 || shared_objfile_contains_address_p (bl
->pspace
,
4052 bl
->inserted
= (reason
== DETACH_BREAKPOINT
);
4054 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
)
4056 gdb_assert (bl
->owner
->ops
!= NULL
4057 && bl
->owner
->ops
->remove_location
!= NULL
);
4059 bl
->inserted
= (reason
== DETACH_BREAKPOINT
);
4060 bl
->owner
->ops
->remove_location (bl
, reason
);
4062 /* Failure to remove any of the hardware watchpoints comes here. */
4063 if (reason
== REMOVE_BREAKPOINT
&& bl
->inserted
)
4064 warning (_("Could not remove hardware watchpoint %d."),
4067 else if (bl
->owner
->type
== bp_catchpoint
4068 && breakpoint_enabled (bl
->owner
)
4071 gdb_assert (bl
->owner
->ops
!= NULL
4072 && bl
->owner
->ops
->remove_location
!= NULL
);
4074 val
= bl
->owner
->ops
->remove_location (bl
, reason
);
4078 bl
->inserted
= (reason
== DETACH_BREAKPOINT
);
4085 remove_breakpoint (struct bp_location
*bl
)
4088 struct cleanup
*old_chain
;
4090 /* BL is never in moribund_locations by our callers. */
4091 gdb_assert (bl
->owner
!= NULL
);
4093 /* The type of none suggests that owner is actually deleted.
4094 This should not ever happen. */
4095 gdb_assert (bl
->owner
->type
!= bp_none
);
4097 old_chain
= save_current_space_and_thread ();
4099 switch_to_program_space_and_thread (bl
->pspace
);
4101 ret
= remove_breakpoint_1 (bl
, REMOVE_BREAKPOINT
);
4103 do_cleanups (old_chain
);
4107 /* Clear the "inserted" flag in all breakpoints. */
4110 mark_breakpoints_out (void)
4112 struct bp_location
*bl
, **blp_tmp
;
4114 ALL_BP_LOCATIONS (bl
, blp_tmp
)
4115 if (bl
->pspace
== current_program_space
)
4119 /* Clear the "inserted" flag in all breakpoints and delete any
4120 breakpoints which should go away between runs of the program.
4122 Plus other such housekeeping that has to be done for breakpoints
4125 Note: this function gets called at the end of a run (by
4126 generic_mourn_inferior) and when a run begins (by
4127 init_wait_for_inferior). */
4132 breakpoint_init_inferior (enum inf_context context
)
4134 struct breakpoint
*b
, *b_tmp
;
4135 struct bp_location
*bl
;
4137 struct program_space
*pspace
= current_program_space
;
4139 /* If breakpoint locations are shared across processes, then there's
4141 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
4144 mark_breakpoints_out ();
4146 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
4148 if (b
->loc
&& b
->loc
->pspace
!= pspace
)
4154 case bp_longjmp_call_dummy
:
4156 /* If the call dummy breakpoint is at the entry point it will
4157 cause problems when the inferior is rerun, so we better get
4160 case bp_watchpoint_scope
:
4162 /* Also get rid of scope breakpoints. */
4164 case bp_shlib_event
:
4166 /* Also remove solib event breakpoints. Their addresses may
4167 have changed since the last time we ran the program.
4168 Actually we may now be debugging against different target;
4169 and so the solib backend that installed this breakpoint may
4170 not be used in by the target. E.g.,
4172 (gdb) file prog-linux
4173 (gdb) run # native linux target
4176 (gdb) file prog-win.exe
4177 (gdb) tar rem :9999 # remote Windows gdbserver.
4180 case bp_step_resume
:
4182 /* Also remove step-resume breakpoints. */
4184 case bp_single_step
:
4186 /* Also remove single-step breakpoints. */
4188 delete_breakpoint (b
);
4192 case bp_hardware_watchpoint
:
4193 case bp_read_watchpoint
:
4194 case bp_access_watchpoint
:
4196 struct watchpoint
*w
= (struct watchpoint
*) b
;
4198 /* Likewise for watchpoints on local expressions. */
4199 if (w
->exp_valid_block
!= NULL
)
4200 delete_breakpoint (b
);
4203 /* Get rid of existing locations, which are no longer
4204 valid. New ones will be created in
4205 update_watchpoint, when the inferior is restarted.
4206 The next update_global_location_list call will
4207 garbage collect them. */
4210 if (context
== inf_starting
)
4212 /* Reset val field to force reread of starting value in
4213 insert_breakpoints. */
4215 value_free (w
->val
);
4227 /* Get rid of the moribund locations. */
4228 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, bl
); ++ix
)
4229 decref_bp_location (&bl
);
4230 VEC_free (bp_location_p
, moribund_locations
);
4233 /* These functions concern about actual breakpoints inserted in the
4234 target --- to e.g. check if we need to do decr_pc adjustment or if
4235 we need to hop over the bkpt --- so we check for address space
4236 match, not program space. */
4238 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
4239 exists at PC. It returns ordinary_breakpoint_here if it's an
4240 ordinary breakpoint, or permanent_breakpoint_here if it's a
4241 permanent breakpoint.
4242 - When continuing from a location with an ordinary breakpoint, we
4243 actually single step once before calling insert_breakpoints.
4244 - When continuing from a location with a permanent breakpoint, we
4245 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
4246 the target, to advance the PC past the breakpoint. */
4248 enum breakpoint_here
4249 breakpoint_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
4251 struct bp_location
*bl
, **blp_tmp
;
4252 int any_breakpoint_here
= 0;
4254 ALL_BP_LOCATIONS (bl
, blp_tmp
)
4256 if (bl
->loc_type
!= bp_loc_software_breakpoint
4257 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4260 /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
4261 if ((breakpoint_enabled (bl
->owner
)
4263 && breakpoint_location_address_match (bl
, aspace
, pc
))
4265 if (overlay_debugging
4266 && section_is_overlay (bl
->section
)
4267 && !section_is_mapped (bl
->section
))
4268 continue; /* unmapped overlay -- can't be a match */
4269 else if (bl
->permanent
)
4270 return permanent_breakpoint_here
;
4272 any_breakpoint_here
= 1;
4276 return any_breakpoint_here
? ordinary_breakpoint_here
: no_breakpoint_here
;
4279 /* See breakpoint.h. */
4282 breakpoint_in_range_p (struct address_space
*aspace
,
4283 CORE_ADDR addr
, ULONGEST len
)
4285 struct bp_location
*bl
, **blp_tmp
;
4287 ALL_BP_LOCATIONS (bl
, blp_tmp
)
4289 if (bl
->loc_type
!= bp_loc_software_breakpoint
4290 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4293 if ((breakpoint_enabled (bl
->owner
)
4295 && breakpoint_location_address_range_overlap (bl
, aspace
,
4298 if (overlay_debugging
4299 && section_is_overlay (bl
->section
)
4300 && !section_is_mapped (bl
->section
))
4302 /* Unmapped overlay -- can't be a match. */
4313 /* Return true if there's a moribund breakpoint at PC. */
4316 moribund_breakpoint_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
4318 struct bp_location
*loc
;
4321 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
4322 if (breakpoint_location_address_match (loc
, aspace
, pc
))
4328 /* Returns non-zero iff BL is inserted at PC, in address space
4332 bp_location_inserted_here_p (struct bp_location
*bl
,
4333 struct address_space
*aspace
, CORE_ADDR pc
)
4336 && breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
4339 if (overlay_debugging
4340 && section_is_overlay (bl
->section
)
4341 && !section_is_mapped (bl
->section
))
4342 return 0; /* unmapped overlay -- can't be a match */
4349 /* Returns non-zero iff there's a breakpoint inserted at PC. */
4352 breakpoint_inserted_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
4354 struct bp_location
**blp
, **blp_tmp
= NULL
;
4356 ALL_BP_LOCATIONS_AT_ADDR (blp
, blp_tmp
, pc
)
4358 struct bp_location
*bl
= *blp
;
4360 if (bl
->loc_type
!= bp_loc_software_breakpoint
4361 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4364 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4370 /* This function returns non-zero iff there is a software breakpoint
4374 software_breakpoint_inserted_here_p (struct address_space
*aspace
,
4377 struct bp_location
**blp
, **blp_tmp
= NULL
;
4379 ALL_BP_LOCATIONS_AT_ADDR (blp
, blp_tmp
, pc
)
4381 struct bp_location
*bl
= *blp
;
4383 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
4386 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4393 /* See breakpoint.h. */
4396 hardware_breakpoint_inserted_here_p (struct address_space
*aspace
,
4399 struct bp_location
**blp
, **blp_tmp
= NULL
;
4401 ALL_BP_LOCATIONS_AT_ADDR (blp
, blp_tmp
, pc
)
4403 struct bp_location
*bl
= *blp
;
4405 if (bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4408 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4416 hardware_watchpoint_inserted_in_range (struct address_space
*aspace
,
4417 CORE_ADDR addr
, ULONGEST len
)
4419 struct breakpoint
*bpt
;
4421 ALL_BREAKPOINTS (bpt
)
4423 struct bp_location
*loc
;
4425 if (bpt
->type
!= bp_hardware_watchpoint
4426 && bpt
->type
!= bp_access_watchpoint
)
4429 if (!breakpoint_enabled (bpt
))
4432 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
4433 if (loc
->pspace
->aspace
== aspace
&& loc
->inserted
)
4437 /* Check for intersection. */
4438 l
= std::max
<CORE_ADDR
> (loc
->address
, addr
);
4439 h
= std::min
<CORE_ADDR
> (loc
->address
+ loc
->length
, addr
+ len
);
4448 /* bpstat stuff. External routines' interfaces are documented
4452 is_catchpoint (struct breakpoint
*ep
)
4454 return (ep
->type
== bp_catchpoint
);
4457 /* Frees any storage that is part of a bpstat. Does not walk the
4461 bpstat_free (bpstat bs
)
4463 if (bs
->old_val
!= NULL
)
4464 value_free (bs
->old_val
);
4465 decref_counted_command_line (&bs
->commands
);
4466 decref_bp_location (&bs
->bp_location_at
);
4470 /* Clear a bpstat so that it says we are not at any breakpoint.
4471 Also free any storage that is part of a bpstat. */
4474 bpstat_clear (bpstat
*bsp
)
4491 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
4492 is part of the bpstat is copied as well. */
4495 bpstat_copy (bpstat bs
)
4499 bpstat retval
= NULL
;
4504 for (; bs
!= NULL
; bs
= bs
->next
)
4506 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
4507 memcpy (tmp
, bs
, sizeof (*tmp
));
4508 incref_counted_command_line (tmp
->commands
);
4509 incref_bp_location (tmp
->bp_location_at
);
4510 if (bs
->old_val
!= NULL
)
4512 tmp
->old_val
= value_copy (bs
->old_val
);
4513 release_value (tmp
->old_val
);
4517 /* This is the first thing in the chain. */
4527 /* Find the bpstat associated with this breakpoint. */
4530 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
4535 for (; bsp
!= NULL
; bsp
= bsp
->next
)
4537 if (bsp
->breakpoint_at
== breakpoint
)
4543 /* See breakpoint.h. */
4546 bpstat_explains_signal (bpstat bsp
, enum gdb_signal sig
)
4548 for (; bsp
!= NULL
; bsp
= bsp
->next
)
4550 if (bsp
->breakpoint_at
== NULL
)
4552 /* A moribund location can never explain a signal other than
4554 if (sig
== GDB_SIGNAL_TRAP
)
4559 if (bsp
->breakpoint_at
->ops
->explains_signal (bsp
->breakpoint_at
,
4568 /* Put in *NUM the breakpoint number of the first breakpoint we are
4569 stopped at. *BSP upon return is a bpstat which points to the
4570 remaining breakpoints stopped at (but which is not guaranteed to be
4571 good for anything but further calls to bpstat_num).
4573 Return 0 if passed a bpstat which does not indicate any breakpoints.
4574 Return -1 if stopped at a breakpoint that has been deleted since
4576 Return 1 otherwise. */
4579 bpstat_num (bpstat
*bsp
, int *num
)
4581 struct breakpoint
*b
;
4584 return 0; /* No more breakpoint values */
4586 /* We assume we'll never have several bpstats that correspond to a
4587 single breakpoint -- otherwise, this function might return the
4588 same number more than once and this will look ugly. */
4589 b
= (*bsp
)->breakpoint_at
;
4590 *bsp
= (*bsp
)->next
;
4592 return -1; /* breakpoint that's been deleted since */
4594 *num
= b
->number
; /* We have its number */
4598 /* See breakpoint.h. */
4601 bpstat_clear_actions (void)
4603 struct thread_info
*tp
;
4606 if (ptid_equal (inferior_ptid
, null_ptid
))
4609 tp
= find_thread_ptid (inferior_ptid
);
4613 for (bs
= tp
->control
.stop_bpstat
; bs
!= NULL
; bs
= bs
->next
)
4615 decref_counted_command_line (&bs
->commands
);
4617 if (bs
->old_val
!= NULL
)
4619 value_free (bs
->old_val
);
4625 /* Called when a command is about to proceed the inferior. */
4628 breakpoint_about_to_proceed (void)
4630 if (!ptid_equal (inferior_ptid
, null_ptid
))
4632 struct thread_info
*tp
= inferior_thread ();
4634 /* Allow inferior function calls in breakpoint commands to not
4635 interrupt the command list. When the call finishes
4636 successfully, the inferior will be standing at the same
4637 breakpoint as if nothing happened. */
4638 if (tp
->control
.in_infcall
)
4642 breakpoint_proceeded
= 1;
4645 /* Stub for cleaning up our state if we error-out of a breakpoint
4648 cleanup_executing_breakpoints (void *ignore
)
4650 executing_breakpoint_commands
= 0;
4653 /* Return non-zero iff CMD as the first line of a command sequence is `silent'
4654 or its equivalent. */
4657 command_line_is_silent (struct command_line
*cmd
)
4659 return cmd
&& (strcmp ("silent", cmd
->line
) == 0);
4662 /* Execute all the commands associated with all the breakpoints at
4663 this location. Any of these commands could cause the process to
4664 proceed beyond this point, etc. We look out for such changes by
4665 checking the global "breakpoint_proceeded" after each command.
4667 Returns true if a breakpoint command resumed the inferior. In that
4668 case, it is the caller's responsibility to recall it again with the
4669 bpstat of the current thread. */
4672 bpstat_do_actions_1 (bpstat
*bsp
)
4675 struct cleanup
*old_chain
;
4678 /* Avoid endless recursion if a `source' command is contained
4680 if (executing_breakpoint_commands
)
4683 executing_breakpoint_commands
= 1;
4684 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
4686 prevent_dont_repeat ();
4688 /* This pointer will iterate over the list of bpstat's. */
4691 breakpoint_proceeded
= 0;
4692 for (; bs
!= NULL
; bs
= bs
->next
)
4694 struct counted_command_line
*ccmd
;
4695 struct command_line
*cmd
;
4696 struct cleanup
*this_cmd_tree_chain
;
4698 /* Take ownership of the BSP's command tree, if it has one.
4700 The command tree could legitimately contain commands like
4701 'step' and 'next', which call clear_proceed_status, which
4702 frees stop_bpstat's command tree. To make sure this doesn't
4703 free the tree we're executing out from under us, we need to
4704 take ownership of the tree ourselves. Since a given bpstat's
4705 commands are only executed once, we don't need to copy it; we
4706 can clear the pointer in the bpstat, and make sure we free
4707 the tree when we're done. */
4708 ccmd
= bs
->commands
;
4709 bs
->commands
= NULL
;
4710 this_cmd_tree_chain
= make_cleanup_decref_counted_command_line (&ccmd
);
4711 cmd
= ccmd
? ccmd
->commands
: NULL
;
4712 if (command_line_is_silent (cmd
))
4714 /* The action has been already done by bpstat_stop_status. */
4720 execute_control_command (cmd
);
4722 if (breakpoint_proceeded
)
4728 /* We can free this command tree now. */
4729 do_cleanups (this_cmd_tree_chain
);
4731 if (breakpoint_proceeded
)
4733 if (current_ui
->async
)
4734 /* If we are in async mode, then the target might be still
4735 running, not stopped at any breakpoint, so nothing for
4736 us to do here -- just return to the event loop. */
4739 /* In sync mode, when execute_control_command returns
4740 we're already standing on the next breakpoint.
4741 Breakpoint commands for that stop were not run, since
4742 execute_command does not run breakpoint commands --
4743 only command_line_handler does, but that one is not
4744 involved in execution of breakpoint commands. So, we
4745 can now execute breakpoint commands. It should be
4746 noted that making execute_command do bpstat actions is
4747 not an option -- in this case we'll have recursive
4748 invocation of bpstat for each breakpoint with a
4749 command, and can easily blow up GDB stack. Instead, we
4750 return true, which will trigger the caller to recall us
4751 with the new stop_bpstat. */
4756 do_cleanups (old_chain
);
4761 bpstat_do_actions (void)
4763 struct cleanup
*cleanup_if_error
= make_bpstat_clear_actions_cleanup ();
4765 /* Do any commands attached to breakpoint we are stopped at. */
4766 while (!ptid_equal (inferior_ptid
, null_ptid
)
4767 && target_has_execution
4768 && !is_exited (inferior_ptid
)
4769 && !is_executing (inferior_ptid
))
4770 /* Since in sync mode, bpstat_do_actions may resume the inferior,
4771 and only return when it is stopped at the next breakpoint, we
4772 keep doing breakpoint actions until it returns false to
4773 indicate the inferior was not resumed. */
4774 if (!bpstat_do_actions_1 (&inferior_thread ()->control
.stop_bpstat
))
4777 discard_cleanups (cleanup_if_error
);
4780 /* Print out the (old or new) value associated with a watchpoint. */
4783 watchpoint_value_print (struct value
*val
, struct ui_file
*stream
)
4786 fprintf_unfiltered (stream
, _("<unreadable>"));
4789 struct value_print_options opts
;
4790 get_user_print_options (&opts
);
4791 value_print (val
, stream
, &opts
);
4795 /* Print the "Thread ID hit" part of "Thread ID hit Breakpoint N" if
4796 debugging multiple threads. */
4799 maybe_print_thread_hit_breakpoint (struct ui_out
*uiout
)
4801 if (ui_out_is_mi_like_p (uiout
))
4804 ui_out_text (uiout
, "\n");
4806 if (show_thread_that_caused_stop ())
4809 struct thread_info
*thr
= inferior_thread ();
4811 ui_out_text (uiout
, "Thread ");
4812 ui_out_field_fmt (uiout
, "thread-id", "%s", print_thread_id (thr
));
4814 name
= thr
->name
!= NULL
? thr
->name
: target_thread_name (thr
);
4817 ui_out_text (uiout
, " \"");
4818 ui_out_field_fmt (uiout
, "name", "%s", name
);
4819 ui_out_text (uiout
, "\"");
4822 ui_out_text (uiout
, " hit ");
4826 /* Generic routine for printing messages indicating why we
4827 stopped. The behavior of this function depends on the value
4828 'print_it' in the bpstat structure. Under some circumstances we
4829 may decide not to print anything here and delegate the task to
4832 static enum print_stop_action
4833 print_bp_stop_message (bpstat bs
)
4835 switch (bs
->print_it
)
4838 /* Nothing should be printed for this bpstat entry. */
4839 return PRINT_UNKNOWN
;
4843 /* We still want to print the frame, but we already printed the
4844 relevant messages. */
4845 return PRINT_SRC_AND_LOC
;
4848 case print_it_normal
:
4850 struct breakpoint
*b
= bs
->breakpoint_at
;
4852 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
4853 which has since been deleted. */
4855 return PRINT_UNKNOWN
;
4857 /* Normal case. Call the breakpoint's print_it method. */
4858 return b
->ops
->print_it (bs
);
4863 internal_error (__FILE__
, __LINE__
,
4864 _("print_bp_stop_message: unrecognized enum value"));
4869 /* A helper function that prints a shared library stopped event. */
4872 print_solib_event (int is_catchpoint
)
4875 = !VEC_empty (char_ptr
, current_program_space
->deleted_solibs
);
4877 = !VEC_empty (so_list_ptr
, current_program_space
->added_solibs
);
4881 if (any_added
|| any_deleted
)
4882 ui_out_text (current_uiout
,
4883 _("Stopped due to shared library event:\n"));
4885 ui_out_text (current_uiout
,
4886 _("Stopped due to shared library event (no "
4887 "libraries added or removed)\n"));
4890 if (ui_out_is_mi_like_p (current_uiout
))
4891 ui_out_field_string (current_uiout
, "reason",
4892 async_reason_lookup (EXEC_ASYNC_SOLIB_EVENT
));
4896 struct cleanup
*cleanup
;
4900 ui_out_text (current_uiout
, _(" Inferior unloaded "));
4901 cleanup
= make_cleanup_ui_out_list_begin_end (current_uiout
,
4904 VEC_iterate (char_ptr
, current_program_space
->deleted_solibs
,
4909 ui_out_text (current_uiout
, " ");
4910 ui_out_field_string (current_uiout
, "library", name
);
4911 ui_out_text (current_uiout
, "\n");
4914 do_cleanups (cleanup
);
4919 struct so_list
*iter
;
4921 struct cleanup
*cleanup
;
4923 ui_out_text (current_uiout
, _(" Inferior loaded "));
4924 cleanup
= make_cleanup_ui_out_list_begin_end (current_uiout
,
4927 VEC_iterate (so_list_ptr
, current_program_space
->added_solibs
,
4932 ui_out_text (current_uiout
, " ");
4933 ui_out_field_string (current_uiout
, "library", iter
->so_name
);
4934 ui_out_text (current_uiout
, "\n");
4937 do_cleanups (cleanup
);
4941 /* Print a message indicating what happened. This is called from
4942 normal_stop(). The input to this routine is the head of the bpstat
4943 list - a list of the eventpoints that caused this stop. KIND is
4944 the target_waitkind for the stopping event. This
4945 routine calls the generic print routine for printing a message
4946 about reasons for stopping. This will print (for example) the
4947 "Breakpoint n," part of the output. The return value of this
4950 PRINT_UNKNOWN: Means we printed nothing.
4951 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
4952 code to print the location. An example is
4953 "Breakpoint 1, " which should be followed by
4955 PRINT_SRC_ONLY: Means we printed something, but there is no need
4956 to also print the location part of the message.
4957 An example is the catch/throw messages, which
4958 don't require a location appended to the end.
4959 PRINT_NOTHING: We have done some printing and we don't need any
4960 further info to be printed. */
4962 enum print_stop_action
4963 bpstat_print (bpstat bs
, int kind
)
4965 enum print_stop_action val
;
4967 /* Maybe another breakpoint in the chain caused us to stop.
4968 (Currently all watchpoints go on the bpstat whether hit or not.
4969 That probably could (should) be changed, provided care is taken
4970 with respect to bpstat_explains_signal). */
4971 for (; bs
; bs
= bs
->next
)
4973 val
= print_bp_stop_message (bs
);
4974 if (val
== PRINT_SRC_ONLY
4975 || val
== PRINT_SRC_AND_LOC
4976 || val
== PRINT_NOTHING
)
4980 /* If we had hit a shared library event breakpoint,
4981 print_bp_stop_message would print out this message. If we hit an
4982 OS-level shared library event, do the same thing. */
4983 if (kind
== TARGET_WAITKIND_LOADED
)
4985 print_solib_event (0);
4986 return PRINT_NOTHING
;
4989 /* We reached the end of the chain, or we got a null BS to start
4990 with and nothing was printed. */
4991 return PRINT_UNKNOWN
;
4994 /* Evaluate the expression EXP and return 1 if value is zero.
4995 This returns the inverse of the condition because it is called
4996 from catch_errors which returns 0 if an exception happened, and if an
4997 exception happens we want execution to stop.
4998 The argument is a "struct expression *" that has been cast to a
4999 "void *" to make it pass through catch_errors. */
5002 breakpoint_cond_eval (void *exp
)
5004 struct value
*mark
= value_mark ();
5005 int i
= !value_true (evaluate_expression ((struct expression
*) exp
));
5007 value_free_to_mark (mark
);
5011 /* Allocate a new bpstat. Link it to the FIFO list by BS_LINK_POINTER. */
5014 bpstat_alloc (struct bp_location
*bl
, bpstat
**bs_link_pointer
)
5018 bs
= (bpstat
) xmalloc (sizeof (*bs
));
5020 **bs_link_pointer
= bs
;
5021 *bs_link_pointer
= &bs
->next
;
5022 bs
->breakpoint_at
= bl
->owner
;
5023 bs
->bp_location_at
= bl
;
5024 incref_bp_location (bl
);
5025 /* If the condition is false, etc., don't do the commands. */
5026 bs
->commands
= NULL
;
5028 bs
->print_it
= print_it_normal
;
5032 /* The target has stopped with waitstatus WS. Check if any hardware
5033 watchpoints have triggered, according to the target. */
5036 watchpoints_triggered (struct target_waitstatus
*ws
)
5038 int stopped_by_watchpoint
= target_stopped_by_watchpoint ();
5040 struct breakpoint
*b
;
5042 if (!stopped_by_watchpoint
)
5044 /* We were not stopped by a watchpoint. Mark all watchpoints
5045 as not triggered. */
5047 if (is_hardware_watchpoint (b
))
5049 struct watchpoint
*w
= (struct watchpoint
*) b
;
5051 w
->watchpoint_triggered
= watch_triggered_no
;
5057 if (!target_stopped_data_address (¤t_target
, &addr
))
5059 /* We were stopped by a watchpoint, but we don't know where.
5060 Mark all watchpoints as unknown. */
5062 if (is_hardware_watchpoint (b
))
5064 struct watchpoint
*w
= (struct watchpoint
*) b
;
5066 w
->watchpoint_triggered
= watch_triggered_unknown
;
5072 /* The target could report the data address. Mark watchpoints
5073 affected by this data address as triggered, and all others as not
5077 if (is_hardware_watchpoint (b
))
5079 struct watchpoint
*w
= (struct watchpoint
*) b
;
5080 struct bp_location
*loc
;
5082 w
->watchpoint_triggered
= watch_triggered_no
;
5083 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
5085 if (is_masked_watchpoint (b
))
5087 CORE_ADDR newaddr
= addr
& w
->hw_wp_mask
;
5088 CORE_ADDR start
= loc
->address
& w
->hw_wp_mask
;
5090 if (newaddr
== start
)
5092 w
->watchpoint_triggered
= watch_triggered_yes
;
5096 /* Exact match not required. Within range is sufficient. */
5097 else if (target_watchpoint_addr_within_range (¤t_target
,
5101 w
->watchpoint_triggered
= watch_triggered_yes
;
5110 /* Possible return values for watchpoint_check (this can't be an enum
5111 because of check_errors). */
5112 /* The watchpoint has been deleted. */
5113 #define WP_DELETED 1
5114 /* The value has changed. */
5115 #define WP_VALUE_CHANGED 2
5116 /* The value has not changed. */
5117 #define WP_VALUE_NOT_CHANGED 3
5118 /* Ignore this watchpoint, no matter if the value changed or not. */
5121 #define BP_TEMPFLAG 1
5122 #define BP_HARDWAREFLAG 2
5124 /* Evaluate watchpoint condition expression and check if its value
5127 P should be a pointer to struct bpstat, but is defined as a void *
5128 in order for this function to be usable with catch_errors. */
5131 watchpoint_check (void *p
)
5133 bpstat bs
= (bpstat
) p
;
5134 struct watchpoint
*b
;
5135 struct frame_info
*fr
;
5136 int within_current_scope
;
5138 /* BS is built from an existing struct breakpoint. */
5139 gdb_assert (bs
->breakpoint_at
!= NULL
);
5140 b
= (struct watchpoint
*) bs
->breakpoint_at
;
5142 /* If this is a local watchpoint, we only want to check if the
5143 watchpoint frame is in scope if the current thread is the thread
5144 that was used to create the watchpoint. */
5145 if (!watchpoint_in_thread_scope (b
))
5148 if (b
->exp_valid_block
== NULL
)
5149 within_current_scope
= 1;
5152 struct frame_info
*frame
= get_current_frame ();
5153 struct gdbarch
*frame_arch
= get_frame_arch (frame
);
5154 CORE_ADDR frame_pc
= get_frame_pc (frame
);
5156 /* stack_frame_destroyed_p() returns a non-zero value if we're
5157 still in the function but the stack frame has already been
5158 invalidated. Since we can't rely on the values of local
5159 variables after the stack has been destroyed, we are treating
5160 the watchpoint in that state as `not changed' without further
5161 checking. Don't mark watchpoints as changed if the current
5162 frame is in an epilogue - even if they are in some other
5163 frame, our view of the stack is likely to be wrong and
5164 frame_find_by_id could error out. */
5165 if (gdbarch_stack_frame_destroyed_p (frame_arch
, frame_pc
))
5168 fr
= frame_find_by_id (b
->watchpoint_frame
);
5169 within_current_scope
= (fr
!= NULL
);
5171 /* If we've gotten confused in the unwinder, we might have
5172 returned a frame that can't describe this variable. */
5173 if (within_current_scope
)
5175 struct symbol
*function
;
5177 function
= get_frame_function (fr
);
5178 if (function
== NULL
5179 || !contained_in (b
->exp_valid_block
,
5180 SYMBOL_BLOCK_VALUE (function
)))
5181 within_current_scope
= 0;
5184 if (within_current_scope
)
5185 /* If we end up stopping, the current frame will get selected
5186 in normal_stop. So this call to select_frame won't affect
5191 if (within_current_scope
)
5193 /* We use value_{,free_to_}mark because it could be a *long*
5194 time before we return to the command level and call
5195 free_all_values. We can't call free_all_values because we
5196 might be in the middle of evaluating a function call. */
5200 struct value
*new_val
;
5202 if (is_masked_watchpoint (&b
->base
))
5203 /* Since we don't know the exact trigger address (from
5204 stopped_data_address), just tell the user we've triggered
5205 a mask watchpoint. */
5206 return WP_VALUE_CHANGED
;
5208 mark
= value_mark ();
5209 fetch_subexp_value (b
->exp
.get (), &pc
, &new_val
, NULL
, NULL
, 0);
5211 if (b
->val_bitsize
!= 0)
5212 new_val
= extract_bitfield_from_watchpoint_value (b
, new_val
);
5214 /* We use value_equal_contents instead of value_equal because
5215 the latter coerces an array to a pointer, thus comparing just
5216 the address of the array instead of its contents. This is
5217 not what we want. */
5218 if ((b
->val
!= NULL
) != (new_val
!= NULL
)
5219 || (b
->val
!= NULL
&& !value_equal_contents (b
->val
, new_val
)))
5221 if (new_val
!= NULL
)
5223 release_value (new_val
);
5224 value_free_to_mark (mark
);
5226 bs
->old_val
= b
->val
;
5229 return WP_VALUE_CHANGED
;
5233 /* Nothing changed. */
5234 value_free_to_mark (mark
);
5235 return WP_VALUE_NOT_CHANGED
;
5240 /* This seems like the only logical thing to do because
5241 if we temporarily ignored the watchpoint, then when
5242 we reenter the block in which it is valid it contains
5243 garbage (in the case of a function, it may have two
5244 garbage values, one before and one after the prologue).
5245 So we can't even detect the first assignment to it and
5246 watch after that (since the garbage may or may not equal
5247 the first value assigned). */
5248 /* We print all the stop information in
5249 breakpoint_ops->print_it, but in this case, by the time we
5250 call breakpoint_ops->print_it this bp will be deleted
5251 already. So we have no choice but print the information
5254 SWITCH_THRU_ALL_UIS ()
5256 struct ui_out
*uiout
= current_uiout
;
5258 if (ui_out_is_mi_like_p (uiout
))
5260 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
5261 ui_out_text (uiout
, "\nWatchpoint ");
5262 ui_out_field_int (uiout
, "wpnum", b
->base
.number
);
5264 " deleted because the program has left the block in\n"
5265 "which its expression is valid.\n");
5268 /* Make sure the watchpoint's commands aren't executed. */
5269 decref_counted_command_line (&b
->base
.commands
);
5270 watchpoint_del_at_next_stop (b
);
5276 /* Return true if it looks like target has stopped due to hitting
5277 breakpoint location BL. This function does not check if we should
5278 stop, only if BL explains the stop. */
5281 bpstat_check_location (const struct bp_location
*bl
,
5282 struct address_space
*aspace
, CORE_ADDR bp_addr
,
5283 const struct target_waitstatus
*ws
)
5285 struct breakpoint
*b
= bl
->owner
;
5287 /* BL is from an existing breakpoint. */
5288 gdb_assert (b
!= NULL
);
5290 return b
->ops
->breakpoint_hit (bl
, aspace
, bp_addr
, ws
);
5293 /* Determine if the watched values have actually changed, and we
5294 should stop. If not, set BS->stop to 0. */
5297 bpstat_check_watchpoint (bpstat bs
)
5299 const struct bp_location
*bl
;
5300 struct watchpoint
*b
;
5302 /* BS is built for existing struct breakpoint. */
5303 bl
= bs
->bp_location_at
;
5304 gdb_assert (bl
!= NULL
);
5305 b
= (struct watchpoint
*) bs
->breakpoint_at
;
5306 gdb_assert (b
!= NULL
);
5309 int must_check_value
= 0;
5311 if (b
->base
.type
== bp_watchpoint
)
5312 /* For a software watchpoint, we must always check the
5314 must_check_value
= 1;
5315 else if (b
->watchpoint_triggered
== watch_triggered_yes
)
5316 /* We have a hardware watchpoint (read, write, or access)
5317 and the target earlier reported an address watched by
5319 must_check_value
= 1;
5320 else if (b
->watchpoint_triggered
== watch_triggered_unknown
5321 && b
->base
.type
== bp_hardware_watchpoint
)
5322 /* We were stopped by a hardware watchpoint, but the target could
5323 not report the data address. We must check the watchpoint's
5324 value. Access and read watchpoints are out of luck; without
5325 a data address, we can't figure it out. */
5326 must_check_value
= 1;
5328 if (must_check_value
)
5331 = xstrprintf ("Error evaluating expression for watchpoint %d\n",
5333 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
5334 int e
= catch_errors (watchpoint_check
, bs
, message
,
5336 do_cleanups (cleanups
);
5340 /* We've already printed what needs to be printed. */
5341 bs
->print_it
= print_it_done
;
5345 bs
->print_it
= print_it_noop
;
5348 case WP_VALUE_CHANGED
:
5349 if (b
->base
.type
== bp_read_watchpoint
)
5351 /* There are two cases to consider here:
5353 1. We're watching the triggered memory for reads.
5354 In that case, trust the target, and always report
5355 the watchpoint hit to the user. Even though
5356 reads don't cause value changes, the value may
5357 have changed since the last time it was read, and
5358 since we're not trapping writes, we will not see
5359 those, and as such we should ignore our notion of
5362 2. We're watching the triggered memory for both
5363 reads and writes. There are two ways this may
5366 2.1. This is a target that can't break on data
5367 reads only, but can break on accesses (reads or
5368 writes), such as e.g., x86. We detect this case
5369 at the time we try to insert read watchpoints.
5371 2.2. Otherwise, the target supports read
5372 watchpoints, but, the user set an access or write
5373 watchpoint watching the same memory as this read
5376 If we're watching memory writes as well as reads,
5377 ignore watchpoint hits when we find that the
5378 value hasn't changed, as reads don't cause
5379 changes. This still gives false positives when
5380 the program writes the same value to memory as
5381 what there was already in memory (we will confuse
5382 it for a read), but it's much better than
5385 int other_write_watchpoint
= 0;
5387 if (bl
->watchpoint_type
== hw_read
)
5389 struct breakpoint
*other_b
;
5391 ALL_BREAKPOINTS (other_b
)
5392 if (other_b
->type
== bp_hardware_watchpoint
5393 || other_b
->type
== bp_access_watchpoint
)
5395 struct watchpoint
*other_w
=
5396 (struct watchpoint
*) other_b
;
5398 if (other_w
->watchpoint_triggered
5399 == watch_triggered_yes
)
5401 other_write_watchpoint
= 1;
5407 if (other_write_watchpoint
5408 || bl
->watchpoint_type
== hw_access
)
5410 /* We're watching the same memory for writes,
5411 and the value changed since the last time we
5412 updated it, so this trap must be for a write.
5414 bs
->print_it
= print_it_noop
;
5419 case WP_VALUE_NOT_CHANGED
:
5420 if (b
->base
.type
== bp_hardware_watchpoint
5421 || b
->base
.type
== bp_watchpoint
)
5423 /* Don't stop: write watchpoints shouldn't fire if
5424 the value hasn't changed. */
5425 bs
->print_it
= print_it_noop
;
5433 /* Error from catch_errors. */
5435 SWITCH_THRU_ALL_UIS ()
5437 printf_filtered (_("Watchpoint %d deleted.\n"),
5440 watchpoint_del_at_next_stop (b
);
5441 /* We've already printed what needs to be printed. */
5442 bs
->print_it
= print_it_done
;
5447 else /* must_check_value == 0 */
5449 /* This is a case where some watchpoint(s) triggered, but
5450 not at the address of this watchpoint, or else no
5451 watchpoint triggered after all. So don't print
5452 anything for this watchpoint. */
5453 bs
->print_it
= print_it_noop
;
5459 /* For breakpoints that are currently marked as telling gdb to stop,
5460 check conditions (condition proper, frame, thread and ignore count)
5461 of breakpoint referred to by BS. If we should not stop for this
5462 breakpoint, set BS->stop to 0. */
5465 bpstat_check_breakpoint_conditions (bpstat bs
, ptid_t ptid
)
5467 const struct bp_location
*bl
;
5468 struct breakpoint
*b
;
5469 int value_is_zero
= 0;
5470 struct expression
*cond
;
5472 gdb_assert (bs
->stop
);
5474 /* BS is built for existing struct breakpoint. */
5475 bl
= bs
->bp_location_at
;
5476 gdb_assert (bl
!= NULL
);
5477 b
= bs
->breakpoint_at
;
5478 gdb_assert (b
!= NULL
);
5480 /* Even if the target evaluated the condition on its end and notified GDB, we
5481 need to do so again since GDB does not know if we stopped due to a
5482 breakpoint or a single step breakpoint. */
5484 if (frame_id_p (b
->frame_id
)
5485 && !frame_id_eq (b
->frame_id
, get_stack_frame_id (get_current_frame ())))
5491 /* If this is a thread/task-specific breakpoint, don't waste cpu
5492 evaluating the condition if this isn't the specified
5494 if ((b
->thread
!= -1 && b
->thread
!= ptid_to_global_thread_id (ptid
))
5495 || (b
->task
!= 0 && b
->task
!= ada_get_task_number (ptid
)))
5502 /* Evaluate extension language breakpoints that have a "stop" method
5504 bs
->stop
= breakpoint_ext_lang_cond_says_stop (b
);
5506 if (is_watchpoint (b
))
5508 struct watchpoint
*w
= (struct watchpoint
*) b
;
5510 cond
= w
->cond_exp
.get ();
5513 cond
= bl
->cond
.get ();
5515 if (cond
&& b
->disposition
!= disp_del_at_next_stop
)
5517 int within_current_scope
= 1;
5518 struct watchpoint
* w
;
5520 /* We use value_mark and value_free_to_mark because it could
5521 be a long time before we return to the command level and
5522 call free_all_values. We can't call free_all_values
5523 because we might be in the middle of evaluating a
5525 struct value
*mark
= value_mark ();
5527 if (is_watchpoint (b
))
5528 w
= (struct watchpoint
*) b
;
5532 /* Need to select the frame, with all that implies so that
5533 the conditions will have the right context. Because we
5534 use the frame, we will not see an inlined function's
5535 variables when we arrive at a breakpoint at the start
5536 of the inlined function; the current frame will be the
5538 if (w
== NULL
|| w
->cond_exp_valid_block
== NULL
)
5539 select_frame (get_current_frame ());
5542 struct frame_info
*frame
;
5544 /* For local watchpoint expressions, which particular
5545 instance of a local is being watched matters, so we
5546 keep track of the frame to evaluate the expression
5547 in. To evaluate the condition however, it doesn't
5548 really matter which instantiation of the function
5549 where the condition makes sense triggers the
5550 watchpoint. This allows an expression like "watch
5551 global if q > 10" set in `func', catch writes to
5552 global on all threads that call `func', or catch
5553 writes on all recursive calls of `func' by a single
5554 thread. We simply always evaluate the condition in
5555 the innermost frame that's executing where it makes
5556 sense to evaluate the condition. It seems
5558 frame
= block_innermost_frame (w
->cond_exp_valid_block
);
5560 select_frame (frame
);
5562 within_current_scope
= 0;
5564 if (within_current_scope
)
5566 = catch_errors (breakpoint_cond_eval
, cond
,
5567 "Error in testing breakpoint condition:\n",
5571 warning (_("Watchpoint condition cannot be tested "
5572 "in the current scope"));
5573 /* If we failed to set the right context for this
5574 watchpoint, unconditionally report it. */
5577 /* FIXME-someday, should give breakpoint #. */
5578 value_free_to_mark (mark
);
5581 if (cond
&& value_is_zero
)
5585 else if (b
->ignore_count
> 0)
5589 /* Increase the hit count even though we don't stop. */
5591 observer_notify_breakpoint_modified (b
);
5595 /* Returns true if we need to track moribund locations of LOC's type
5596 on the current target. */
5599 need_moribund_for_location_type (struct bp_location
*loc
)
5601 return ((loc
->loc_type
== bp_loc_software_breakpoint
5602 && !target_supports_stopped_by_sw_breakpoint ())
5603 || (loc
->loc_type
== bp_loc_hardware_breakpoint
5604 && !target_supports_stopped_by_hw_breakpoint ()));
5608 /* Get a bpstat associated with having just stopped at address
5609 BP_ADDR in thread PTID.
5611 Determine whether we stopped at a breakpoint, etc, or whether we
5612 don't understand this stop. Result is a chain of bpstat's such
5615 if we don't understand the stop, the result is a null pointer.
5617 if we understand why we stopped, the result is not null.
5619 Each element of the chain refers to a particular breakpoint or
5620 watchpoint at which we have stopped. (We may have stopped for
5621 several reasons concurrently.)
5623 Each element of the chain has valid next, breakpoint_at,
5624 commands, FIXME??? fields. */
5627 bpstat_stop_status (struct address_space
*aspace
,
5628 CORE_ADDR bp_addr
, ptid_t ptid
,
5629 const struct target_waitstatus
*ws
)
5631 struct breakpoint
*b
= NULL
;
5632 struct bp_location
*bl
;
5633 struct bp_location
*loc
;
5634 /* First item of allocated bpstat's. */
5635 bpstat bs_head
= NULL
, *bs_link
= &bs_head
;
5636 /* Pointer to the last thing in the chain currently. */
5639 int need_remove_insert
;
5642 /* First, build the bpstat chain with locations that explain a
5643 target stop, while being careful to not set the target running,
5644 as that may invalidate locations (in particular watchpoint
5645 locations are recreated). Resuming will happen here with
5646 breakpoint conditions or watchpoint expressions that include
5647 inferior function calls. */
5651 if (!breakpoint_enabled (b
))
5654 for (bl
= b
->loc
; bl
!= NULL
; bl
= bl
->next
)
5656 /* For hardware watchpoints, we look only at the first
5657 location. The watchpoint_check function will work on the
5658 entire expression, not the individual locations. For
5659 read watchpoints, the watchpoints_triggered function has
5660 checked all locations already. */
5661 if (b
->type
== bp_hardware_watchpoint
&& bl
!= b
->loc
)
5664 if (!bl
->enabled
|| bl
->shlib_disabled
)
5667 if (!bpstat_check_location (bl
, aspace
, bp_addr
, ws
))
5670 /* Come here if it's a watchpoint, or if the break address
5673 bs
= bpstat_alloc (bl
, &bs_link
); /* Alloc a bpstat to
5676 /* Assume we stop. Should we find a watchpoint that is not
5677 actually triggered, or if the condition of the breakpoint
5678 evaluates as false, we'll reset 'stop' to 0. */
5682 /* If this is a scope breakpoint, mark the associated
5683 watchpoint as triggered so that we will handle the
5684 out-of-scope event. We'll get to the watchpoint next
5686 if (b
->type
== bp_watchpoint_scope
&& b
->related_breakpoint
!= b
)
5688 struct watchpoint
*w
= (struct watchpoint
*) b
->related_breakpoint
;
5690 w
->watchpoint_triggered
= watch_triggered_yes
;
5695 /* Check if a moribund breakpoint explains the stop. */
5696 if (!target_supports_stopped_by_sw_breakpoint ()
5697 || !target_supports_stopped_by_hw_breakpoint ())
5699 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
5701 if (breakpoint_location_address_match (loc
, aspace
, bp_addr
)
5702 && need_moribund_for_location_type (loc
))
5704 bs
= bpstat_alloc (loc
, &bs_link
);
5705 /* For hits of moribund locations, we should just proceed. */
5708 bs
->print_it
= print_it_noop
;
5713 /* A bit of special processing for shlib breakpoints. We need to
5714 process solib loading here, so that the lists of loaded and
5715 unloaded libraries are correct before we handle "catch load" and
5717 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5719 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->type
== bp_shlib_event
)
5721 handle_solib_event ();
5726 /* Now go through the locations that caused the target to stop, and
5727 check whether we're interested in reporting this stop to higher
5728 layers, or whether we should resume the target transparently. */
5732 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5737 b
= bs
->breakpoint_at
;
5738 b
->ops
->check_status (bs
);
5741 bpstat_check_breakpoint_conditions (bs
, ptid
);
5746 observer_notify_breakpoint_modified (b
);
5748 /* We will stop here. */
5749 if (b
->disposition
== disp_disable
)
5751 --(b
->enable_count
);
5752 if (b
->enable_count
<= 0)
5753 b
->enable_state
= bp_disabled
;
5758 bs
->commands
= b
->commands
;
5759 incref_counted_command_line (bs
->commands
);
5760 if (command_line_is_silent (bs
->commands
5761 ? bs
->commands
->commands
: NULL
))
5764 b
->ops
->after_condition_true (bs
);
5769 /* Print nothing for this entry if we don't stop or don't
5771 if (!bs
->stop
|| !bs
->print
)
5772 bs
->print_it
= print_it_noop
;
5775 /* If we aren't stopping, the value of some hardware watchpoint may
5776 not have changed, but the intermediate memory locations we are
5777 watching may have. Don't bother if we're stopping; this will get
5779 need_remove_insert
= 0;
5780 if (! bpstat_causes_stop (bs_head
))
5781 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5783 && bs
->breakpoint_at
5784 && is_hardware_watchpoint (bs
->breakpoint_at
))
5786 struct watchpoint
*w
= (struct watchpoint
*) bs
->breakpoint_at
;
5788 update_watchpoint (w
, 0 /* don't reparse. */);
5789 need_remove_insert
= 1;
5792 if (need_remove_insert
)
5793 update_global_location_list (UGLL_MAY_INSERT
);
5794 else if (removed_any
)
5795 update_global_location_list (UGLL_DONT_INSERT
);
5801 handle_jit_event (void)
5803 struct frame_info
*frame
;
5804 struct gdbarch
*gdbarch
;
5807 fprintf_unfiltered (gdb_stdlog
, "handling bp_jit_event\n");
5809 /* Switch terminal for any messages produced by
5810 breakpoint_re_set. */
5811 target_terminal_ours_for_output ();
5813 frame
= get_current_frame ();
5814 gdbarch
= get_frame_arch (frame
);
5816 jit_event_handler (gdbarch
);
5818 target_terminal_inferior ();
5821 /* Prepare WHAT final decision for infrun. */
5823 /* Decide what infrun needs to do with this bpstat. */
5826 bpstat_what (bpstat bs_head
)
5828 struct bpstat_what retval
;
5831 retval
.main_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5832 retval
.call_dummy
= STOP_NONE
;
5833 retval
.is_longjmp
= 0;
5835 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5837 /* Extract this BS's action. After processing each BS, we check
5838 if its action overrides all we've seem so far. */
5839 enum bpstat_what_main_action this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5842 if (bs
->breakpoint_at
== NULL
)
5844 /* I suspect this can happen if it was a momentary
5845 breakpoint which has since been deleted. */
5849 bptype
= bs
->breakpoint_at
->type
;
5856 case bp_hardware_breakpoint
:
5857 case bp_single_step
:
5860 case bp_shlib_event
:
5864 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5866 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5869 this_action
= BPSTAT_WHAT_SINGLE
;
5872 case bp_hardware_watchpoint
:
5873 case bp_read_watchpoint
:
5874 case bp_access_watchpoint
:
5878 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5880 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5884 /* There was a watchpoint, but we're not stopping.
5885 This requires no further action. */
5889 case bp_longjmp_call_dummy
:
5893 this_action
= BPSTAT_WHAT_SET_LONGJMP_RESUME
;
5894 retval
.is_longjmp
= bptype
!= bp_exception
;
5897 this_action
= BPSTAT_WHAT_SINGLE
;
5899 case bp_longjmp_resume
:
5900 case bp_exception_resume
:
5903 this_action
= BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
;
5904 retval
.is_longjmp
= bptype
== bp_longjmp_resume
;
5907 this_action
= BPSTAT_WHAT_SINGLE
;
5909 case bp_step_resume
:
5911 this_action
= BPSTAT_WHAT_STEP_RESUME
;
5914 /* It is for the wrong frame. */
5915 this_action
= BPSTAT_WHAT_SINGLE
;
5918 case bp_hp_step_resume
:
5920 this_action
= BPSTAT_WHAT_HP_STEP_RESUME
;
5923 /* It is for the wrong frame. */
5924 this_action
= BPSTAT_WHAT_SINGLE
;
5927 case bp_watchpoint_scope
:
5928 case bp_thread_event
:
5929 case bp_overlay_event
:
5930 case bp_longjmp_master
:
5931 case bp_std_terminate_master
:
5932 case bp_exception_master
:
5933 this_action
= BPSTAT_WHAT_SINGLE
;
5939 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5941 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5945 /* There was a catchpoint, but we're not stopping.
5946 This requires no further action. */
5950 this_action
= BPSTAT_WHAT_SINGLE
;
5953 /* Make sure the action is stop (silent or noisy),
5954 so infrun.c pops the dummy frame. */
5955 retval
.call_dummy
= STOP_STACK_DUMMY
;
5956 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5958 case bp_std_terminate
:
5959 /* Make sure the action is stop (silent or noisy),
5960 so infrun.c pops the dummy frame. */
5961 retval
.call_dummy
= STOP_STD_TERMINATE
;
5962 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5965 case bp_fast_tracepoint
:
5966 case bp_static_tracepoint
:
5967 /* Tracepoint hits should not be reported back to GDB, and
5968 if one got through somehow, it should have been filtered
5970 internal_error (__FILE__
, __LINE__
,
5971 _("bpstat_what: tracepoint encountered"));
5973 case bp_gnu_ifunc_resolver
:
5974 /* Step over it (and insert bp_gnu_ifunc_resolver_return). */
5975 this_action
= BPSTAT_WHAT_SINGLE
;
5977 case bp_gnu_ifunc_resolver_return
:
5978 /* The breakpoint will be removed, execution will restart from the
5979 PC of the former breakpoint. */
5980 this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5985 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5987 this_action
= BPSTAT_WHAT_SINGLE
;
5991 internal_error (__FILE__
, __LINE__
,
5992 _("bpstat_what: unhandled bptype %d"), (int) bptype
);
5995 retval
.main_action
= std::max (retval
.main_action
, this_action
);
6002 bpstat_run_callbacks (bpstat bs_head
)
6006 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
6008 struct breakpoint
*b
= bs
->breakpoint_at
;
6015 handle_jit_event ();
6017 case bp_gnu_ifunc_resolver
:
6018 gnu_ifunc_resolver_stop (b
);
6020 case bp_gnu_ifunc_resolver_return
:
6021 gnu_ifunc_resolver_return_stop (b
);
6027 /* Nonzero if we should step constantly (e.g. watchpoints on machines
6028 without hardware support). This isn't related to a specific bpstat,
6029 just to things like whether watchpoints are set. */
6032 bpstat_should_step (void)
6034 struct breakpoint
*b
;
6037 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
&& b
->loc
!= NULL
)
6043 bpstat_causes_stop (bpstat bs
)
6045 for (; bs
!= NULL
; bs
= bs
->next
)
6054 /* Compute a string of spaces suitable to indent the next line
6055 so it starts at the position corresponding to the table column
6056 named COL_NAME in the currently active table of UIOUT. */
6059 wrap_indent_at_field (struct ui_out
*uiout
, const char *col_name
)
6061 static char wrap_indent
[80];
6062 int i
, total_width
, width
, align
;
6066 for (i
= 1; ui_out_query_field (uiout
, i
, &width
, &align
, &text
); i
++)
6068 if (strcmp (text
, col_name
) == 0)
6070 gdb_assert (total_width
< sizeof wrap_indent
);
6071 memset (wrap_indent
, ' ', total_width
);
6072 wrap_indent
[total_width
] = 0;
6077 total_width
+= width
+ 1;
6083 /* Determine if the locations of this breakpoint will have their conditions
6084 evaluated by the target, host or a mix of both. Returns the following:
6086 "host": Host evals condition.
6087 "host or target": Host or Target evals condition.
6088 "target": Target evals condition.
6092 bp_condition_evaluator (struct breakpoint
*b
)
6094 struct bp_location
*bl
;
6095 char host_evals
= 0;
6096 char target_evals
= 0;
6101 if (!is_breakpoint (b
))
6104 if (gdb_evaluates_breakpoint_condition_p ()
6105 || !target_supports_evaluation_of_breakpoint_conditions ())
6106 return condition_evaluation_host
;
6108 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
6110 if (bl
->cond_bytecode
)
6116 if (host_evals
&& target_evals
)
6117 return condition_evaluation_both
;
6118 else if (target_evals
)
6119 return condition_evaluation_target
;
6121 return condition_evaluation_host
;
6124 /* Determine the breakpoint location's condition evaluator. This is
6125 similar to bp_condition_evaluator, but for locations. */
6128 bp_location_condition_evaluator (struct bp_location
*bl
)
6130 if (bl
&& !is_breakpoint (bl
->owner
))
6133 if (gdb_evaluates_breakpoint_condition_p ()
6134 || !target_supports_evaluation_of_breakpoint_conditions ())
6135 return condition_evaluation_host
;
6137 if (bl
&& bl
->cond_bytecode
)
6138 return condition_evaluation_target
;
6140 return condition_evaluation_host
;
6143 /* Print the LOC location out of the list of B->LOC locations. */
6146 print_breakpoint_location (struct breakpoint
*b
,
6147 struct bp_location
*loc
)
6149 struct ui_out
*uiout
= current_uiout
;
6150 struct cleanup
*old_chain
= save_current_program_space ();
6152 if (loc
!= NULL
&& loc
->shlib_disabled
)
6156 set_current_program_space (loc
->pspace
);
6158 if (b
->display_canonical
)
6159 ui_out_field_string (uiout
, "what",
6160 event_location_to_string (b
->location
));
6161 else if (loc
&& loc
->symtab
)
6164 = find_pc_sect_function (loc
->address
, loc
->section
);
6167 ui_out_text (uiout
, "in ");
6168 ui_out_field_string (uiout
, "func",
6169 SYMBOL_PRINT_NAME (sym
));
6170 ui_out_text (uiout
, " ");
6171 ui_out_wrap_hint (uiout
, wrap_indent_at_field (uiout
, "what"));
6172 ui_out_text (uiout
, "at ");
6174 ui_out_field_string (uiout
, "file",
6175 symtab_to_filename_for_display (loc
->symtab
));
6176 ui_out_text (uiout
, ":");
6178 if (ui_out_is_mi_like_p (uiout
))
6179 ui_out_field_string (uiout
, "fullname",
6180 symtab_to_fullname (loc
->symtab
));
6182 ui_out_field_int (uiout
, "line", loc
->line_number
);
6186 struct ui_file
*stb
= mem_fileopen ();
6187 struct cleanup
*stb_chain
= make_cleanup_ui_file_delete (stb
);
6189 print_address_symbolic (loc
->gdbarch
, loc
->address
, stb
,
6191 ui_out_field_stream (uiout
, "at", stb
);
6193 do_cleanups (stb_chain
);
6197 ui_out_field_string (uiout
, "pending",
6198 event_location_to_string (b
->location
));
6199 /* If extra_string is available, it could be holding a condition
6200 or dprintf arguments. In either case, make sure it is printed,
6201 too, but only for non-MI streams. */
6202 if (!ui_out_is_mi_like_p (uiout
) && b
->extra_string
!= NULL
)
6204 if (b
->type
== bp_dprintf
)
6205 ui_out_text (uiout
, ",");
6207 ui_out_text (uiout
, " ");
6208 ui_out_text (uiout
, b
->extra_string
);
6212 if (loc
&& is_breakpoint (b
)
6213 && breakpoint_condition_evaluation_mode () == condition_evaluation_target
6214 && bp_condition_evaluator (b
) == condition_evaluation_both
)
6216 ui_out_text (uiout
, " (");
6217 ui_out_field_string (uiout
, "evaluated-by",
6218 bp_location_condition_evaluator (loc
));
6219 ui_out_text (uiout
, ")");
6222 do_cleanups (old_chain
);
6226 bptype_string (enum bptype type
)
6228 struct ep_type_description
6233 static struct ep_type_description bptypes
[] =
6235 {bp_none
, "?deleted?"},
6236 {bp_breakpoint
, "breakpoint"},
6237 {bp_hardware_breakpoint
, "hw breakpoint"},
6238 {bp_single_step
, "sw single-step"},
6239 {bp_until
, "until"},
6240 {bp_finish
, "finish"},
6241 {bp_watchpoint
, "watchpoint"},
6242 {bp_hardware_watchpoint
, "hw watchpoint"},
6243 {bp_read_watchpoint
, "read watchpoint"},
6244 {bp_access_watchpoint
, "acc watchpoint"},
6245 {bp_longjmp
, "longjmp"},
6246 {bp_longjmp_resume
, "longjmp resume"},
6247 {bp_longjmp_call_dummy
, "longjmp for call dummy"},
6248 {bp_exception
, "exception"},
6249 {bp_exception_resume
, "exception resume"},
6250 {bp_step_resume
, "step resume"},
6251 {bp_hp_step_resume
, "high-priority step resume"},
6252 {bp_watchpoint_scope
, "watchpoint scope"},
6253 {bp_call_dummy
, "call dummy"},
6254 {bp_std_terminate
, "std::terminate"},
6255 {bp_shlib_event
, "shlib events"},
6256 {bp_thread_event
, "thread events"},
6257 {bp_overlay_event
, "overlay events"},
6258 {bp_longjmp_master
, "longjmp master"},
6259 {bp_std_terminate_master
, "std::terminate master"},
6260 {bp_exception_master
, "exception master"},
6261 {bp_catchpoint
, "catchpoint"},
6262 {bp_tracepoint
, "tracepoint"},
6263 {bp_fast_tracepoint
, "fast tracepoint"},
6264 {bp_static_tracepoint
, "static tracepoint"},
6265 {bp_dprintf
, "dprintf"},
6266 {bp_jit_event
, "jit events"},
6267 {bp_gnu_ifunc_resolver
, "STT_GNU_IFUNC resolver"},
6268 {bp_gnu_ifunc_resolver_return
, "STT_GNU_IFUNC resolver return"},
6271 if (((int) type
>= (sizeof (bptypes
) / sizeof (bptypes
[0])))
6272 || ((int) type
!= bptypes
[(int) type
].type
))
6273 internal_error (__FILE__
, __LINE__
,
6274 _("bptypes table does not describe type #%d."),
6277 return bptypes
[(int) type
].description
;
6280 /* For MI, output a field named 'thread-groups' with a list as the value.
6281 For CLI, prefix the list with the string 'inf'. */
6284 output_thread_groups (struct ui_out
*uiout
,
6285 const char *field_name
,
6289 struct cleanup
*back_to
;
6290 int is_mi
= ui_out_is_mi_like_p (uiout
);
6294 /* For backward compatibility, don't display inferiors in CLI unless
6295 there are several. Always display them for MI. */
6296 if (!is_mi
&& mi_only
)
6299 back_to
= make_cleanup_ui_out_list_begin_end (uiout
, field_name
);
6301 for (i
= 0; VEC_iterate (int, inf_num
, i
, inf
); ++i
)
6307 xsnprintf (mi_group
, sizeof (mi_group
), "i%d", inf
);
6308 ui_out_field_string (uiout
, NULL
, mi_group
);
6313 ui_out_text (uiout
, " inf ");
6315 ui_out_text (uiout
, ", ");
6317 ui_out_text (uiout
, plongest (inf
));
6321 do_cleanups (back_to
);
6324 /* Print B to gdb_stdout. */
6327 print_one_breakpoint_location (struct breakpoint
*b
,
6328 struct bp_location
*loc
,
6330 struct bp_location
**last_loc
,
6333 struct command_line
*l
;
6334 static char bpenables
[] = "nynny";
6336 struct ui_out
*uiout
= current_uiout
;
6337 int header_of_multiple
= 0;
6338 int part_of_multiple
= (loc
!= NULL
);
6339 struct value_print_options opts
;
6341 get_user_print_options (&opts
);
6343 gdb_assert (!loc
|| loc_number
!= 0);
6344 /* See comment in print_one_breakpoint concerning treatment of
6345 breakpoints with single disabled location. */
6348 && (b
->loc
->next
!= NULL
|| !b
->loc
->enabled
)))
6349 header_of_multiple
= 1;
6357 if (part_of_multiple
)
6360 formatted
= xstrprintf ("%d.%d", b
->number
, loc_number
);
6361 ui_out_field_string (uiout
, "number", formatted
);
6366 ui_out_field_int (uiout
, "number", b
->number
);
6371 if (part_of_multiple
)
6372 ui_out_field_skip (uiout
, "type");
6374 ui_out_field_string (uiout
, "type", bptype_string (b
->type
));
6378 if (part_of_multiple
)
6379 ui_out_field_skip (uiout
, "disp");
6381 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
6386 if (part_of_multiple
)
6387 ui_out_field_string (uiout
, "enabled", loc
->enabled
? "y" : "n");
6389 ui_out_field_fmt (uiout
, "enabled", "%c",
6390 bpenables
[(int) b
->enable_state
]);
6391 ui_out_spaces (uiout
, 2);
6395 if (b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
6397 /* Although the print_one can possibly print all locations,
6398 calling it here is not likely to get any nice result. So,
6399 make sure there's just one location. */
6400 gdb_assert (b
->loc
== NULL
|| b
->loc
->next
== NULL
);
6401 b
->ops
->print_one (b
, last_loc
);
6407 internal_error (__FILE__
, __LINE__
,
6408 _("print_one_breakpoint: bp_none encountered\n"));
6412 case bp_hardware_watchpoint
:
6413 case bp_read_watchpoint
:
6414 case bp_access_watchpoint
:
6416 struct watchpoint
*w
= (struct watchpoint
*) b
;
6418 /* Field 4, the address, is omitted (which makes the columns
6419 not line up too nicely with the headers, but the effect
6420 is relatively readable). */
6421 if (opts
.addressprint
)
6422 ui_out_field_skip (uiout
, "addr");
6424 ui_out_field_string (uiout
, "what", w
->exp_string
);
6429 case bp_hardware_breakpoint
:
6430 case bp_single_step
:
6434 case bp_longjmp_resume
:
6435 case bp_longjmp_call_dummy
:
6437 case bp_exception_resume
:
6438 case bp_step_resume
:
6439 case bp_hp_step_resume
:
6440 case bp_watchpoint_scope
:
6442 case bp_std_terminate
:
6443 case bp_shlib_event
:
6444 case bp_thread_event
:
6445 case bp_overlay_event
:
6446 case bp_longjmp_master
:
6447 case bp_std_terminate_master
:
6448 case bp_exception_master
:
6450 case bp_fast_tracepoint
:
6451 case bp_static_tracepoint
:
6454 case bp_gnu_ifunc_resolver
:
6455 case bp_gnu_ifunc_resolver_return
:
6456 if (opts
.addressprint
)
6459 if (header_of_multiple
)
6460 ui_out_field_string (uiout
, "addr", "<MULTIPLE>");
6461 else if (b
->loc
== NULL
|| loc
->shlib_disabled
)
6462 ui_out_field_string (uiout
, "addr", "<PENDING>");
6464 ui_out_field_core_addr (uiout
, "addr",
6465 loc
->gdbarch
, loc
->address
);
6468 if (!header_of_multiple
)
6469 print_breakpoint_location (b
, loc
);
6476 if (loc
!= NULL
&& !header_of_multiple
)
6478 struct inferior
*inf
;
6479 VEC(int) *inf_num
= NULL
;
6484 if (inf
->pspace
== loc
->pspace
)
6485 VEC_safe_push (int, inf_num
, inf
->num
);
6488 /* For backward compatibility, don't display inferiors in CLI unless
6489 there are several. Always display for MI. */
6491 || (!gdbarch_has_global_breakpoints (target_gdbarch ())
6492 && (number_of_program_spaces () > 1
6493 || number_of_inferiors () > 1)
6494 /* LOC is for existing B, it cannot be in
6495 moribund_locations and thus having NULL OWNER. */
6496 && loc
->owner
->type
!= bp_catchpoint
))
6498 output_thread_groups (uiout
, "thread-groups", inf_num
, mi_only
);
6499 VEC_free (int, inf_num
);
6502 if (!part_of_multiple
)
6504 if (b
->thread
!= -1)
6506 /* FIXME: This seems to be redundant and lost here; see the
6507 "stop only in" line a little further down. */
6508 ui_out_text (uiout
, " thread ");
6509 ui_out_field_int (uiout
, "thread", b
->thread
);
6511 else if (b
->task
!= 0)
6513 ui_out_text (uiout
, " task ");
6514 ui_out_field_int (uiout
, "task", b
->task
);
6518 ui_out_text (uiout
, "\n");
6520 if (!part_of_multiple
)
6521 b
->ops
->print_one_detail (b
, uiout
);
6523 if (part_of_multiple
&& frame_id_p (b
->frame_id
))
6526 ui_out_text (uiout
, "\tstop only in stack frame at ");
6527 /* FIXME: cagney/2002-12-01: Shouldn't be poking around inside
6529 ui_out_field_core_addr (uiout
, "frame",
6530 b
->gdbarch
, b
->frame_id
.stack_addr
);
6531 ui_out_text (uiout
, "\n");
6534 if (!part_of_multiple
&& b
->cond_string
)
6537 if (is_tracepoint (b
))
6538 ui_out_text (uiout
, "\ttrace only if ");
6540 ui_out_text (uiout
, "\tstop only if ");
6541 ui_out_field_string (uiout
, "cond", b
->cond_string
);
6543 /* Print whether the target is doing the breakpoint's condition
6544 evaluation. If GDB is doing the evaluation, don't print anything. */
6545 if (is_breakpoint (b
)
6546 && breakpoint_condition_evaluation_mode ()
6547 == condition_evaluation_target
)
6549 ui_out_text (uiout
, " (");
6550 ui_out_field_string (uiout
, "evaluated-by",
6551 bp_condition_evaluator (b
));
6552 ui_out_text (uiout
, " evals)");
6554 ui_out_text (uiout
, "\n");
6557 if (!part_of_multiple
&& b
->thread
!= -1)
6559 /* FIXME should make an annotation for this. */
6560 ui_out_text (uiout
, "\tstop only in thread ");
6561 if (ui_out_is_mi_like_p (uiout
))
6562 ui_out_field_int (uiout
, "thread", b
->thread
);
6565 struct thread_info
*thr
= find_thread_global_id (b
->thread
);
6567 ui_out_field_string (uiout
, "thread", print_thread_id (thr
));
6569 ui_out_text (uiout
, "\n");
6572 if (!part_of_multiple
)
6576 /* FIXME should make an annotation for this. */
6577 if (is_catchpoint (b
))
6578 ui_out_text (uiout
, "\tcatchpoint");
6579 else if (is_tracepoint (b
))
6580 ui_out_text (uiout
, "\ttracepoint");
6582 ui_out_text (uiout
, "\tbreakpoint");
6583 ui_out_text (uiout
, " already hit ");
6584 ui_out_field_int (uiout
, "times", b
->hit_count
);
6585 if (b
->hit_count
== 1)
6586 ui_out_text (uiout
, " time\n");
6588 ui_out_text (uiout
, " times\n");
6592 /* Output the count also if it is zero, but only if this is mi. */
6593 if (ui_out_is_mi_like_p (uiout
))
6594 ui_out_field_int (uiout
, "times", b
->hit_count
);
6598 if (!part_of_multiple
&& b
->ignore_count
)
6601 ui_out_text (uiout
, "\tignore next ");
6602 ui_out_field_int (uiout
, "ignore", b
->ignore_count
);
6603 ui_out_text (uiout
, " hits\n");
6606 /* Note that an enable count of 1 corresponds to "enable once"
6607 behavior, which is reported by the combination of enablement and
6608 disposition, so we don't need to mention it here. */
6609 if (!part_of_multiple
&& b
->enable_count
> 1)
6612 ui_out_text (uiout
, "\tdisable after ");
6613 /* Tweak the wording to clarify that ignore and enable counts
6614 are distinct, and have additive effect. */
6615 if (b
->ignore_count
)
6616 ui_out_text (uiout
, "additional ");
6618 ui_out_text (uiout
, "next ");
6619 ui_out_field_int (uiout
, "enable", b
->enable_count
);
6620 ui_out_text (uiout
, " hits\n");
6623 if (!part_of_multiple
&& is_tracepoint (b
))
6625 struct tracepoint
*tp
= (struct tracepoint
*) b
;
6627 if (tp
->traceframe_usage
)
6629 ui_out_text (uiout
, "\ttrace buffer usage ");
6630 ui_out_field_int (uiout
, "traceframe-usage", tp
->traceframe_usage
);
6631 ui_out_text (uiout
, " bytes\n");
6635 l
= b
->commands
? b
->commands
->commands
: NULL
;
6636 if (!part_of_multiple
&& l
)
6638 struct cleanup
*script_chain
;
6641 script_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "script");
6642 print_command_lines (uiout
, l
, 4);
6643 do_cleanups (script_chain
);
6646 if (is_tracepoint (b
))
6648 struct tracepoint
*t
= (struct tracepoint
*) b
;
6650 if (!part_of_multiple
&& t
->pass_count
)
6652 annotate_field (10);
6653 ui_out_text (uiout
, "\tpass count ");
6654 ui_out_field_int (uiout
, "pass", t
->pass_count
);
6655 ui_out_text (uiout
, " \n");
6658 /* Don't display it when tracepoint or tracepoint location is
6660 if (!header_of_multiple
&& loc
!= NULL
&& !loc
->shlib_disabled
)
6662 annotate_field (11);
6664 if (ui_out_is_mi_like_p (uiout
))
6665 ui_out_field_string (uiout
, "installed",
6666 loc
->inserted
? "y" : "n");
6670 ui_out_text (uiout
, "\t");
6672 ui_out_text (uiout
, "\tnot ");
6673 ui_out_text (uiout
, "installed on target\n");
6678 if (ui_out_is_mi_like_p (uiout
) && !part_of_multiple
)
6680 if (is_watchpoint (b
))
6682 struct watchpoint
*w
= (struct watchpoint
*) b
;
6684 ui_out_field_string (uiout
, "original-location", w
->exp_string
);
6686 else if (b
->location
!= NULL
6687 && event_location_to_string (b
->location
) != NULL
)
6688 ui_out_field_string (uiout
, "original-location",
6689 event_location_to_string (b
->location
));
6694 print_one_breakpoint (struct breakpoint
*b
,
6695 struct bp_location
**last_loc
,
6698 struct cleanup
*bkpt_chain
;
6699 struct ui_out
*uiout
= current_uiout
;
6701 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "bkpt");
6703 print_one_breakpoint_location (b
, NULL
, 0, last_loc
, allflag
);
6704 do_cleanups (bkpt_chain
);
6706 /* If this breakpoint has custom print function,
6707 it's already printed. Otherwise, print individual
6708 locations, if any. */
6709 if (b
->ops
== NULL
|| b
->ops
->print_one
== NULL
)
6711 /* If breakpoint has a single location that is disabled, we
6712 print it as if it had several locations, since otherwise it's
6713 hard to represent "breakpoint enabled, location disabled"
6716 Note that while hardware watchpoints have several locations
6717 internally, that's not a property exposed to user. */
6719 && !is_hardware_watchpoint (b
)
6720 && (b
->loc
->next
|| !b
->loc
->enabled
))
6722 struct bp_location
*loc
;
6725 for (loc
= b
->loc
; loc
; loc
= loc
->next
, ++n
)
6727 struct cleanup
*inner2
=
6728 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
6729 print_one_breakpoint_location (b
, loc
, n
, last_loc
, allflag
);
6730 do_cleanups (inner2
);
6737 breakpoint_address_bits (struct breakpoint
*b
)
6739 int print_address_bits
= 0;
6740 struct bp_location
*loc
;
6742 /* Software watchpoints that aren't watching memory don't have an
6743 address to print. */
6744 if (is_no_memory_software_watchpoint (b
))
6747 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
6751 addr_bit
= gdbarch_addr_bit (loc
->gdbarch
);
6752 if (addr_bit
> print_address_bits
)
6753 print_address_bits
= addr_bit
;
6756 return print_address_bits
;
6759 struct captured_breakpoint_query_args
6765 do_captured_breakpoint_query (struct ui_out
*uiout
, void *data
)
6767 struct captured_breakpoint_query_args
*args
6768 = (struct captured_breakpoint_query_args
*) data
;
6769 struct breakpoint
*b
;
6770 struct bp_location
*dummy_loc
= NULL
;
6774 if (args
->bnum
== b
->number
)
6776 print_one_breakpoint (b
, &dummy_loc
, 0);
6784 gdb_breakpoint_query (struct ui_out
*uiout
, int bnum
,
6785 char **error_message
)
6787 struct captured_breakpoint_query_args args
;
6790 /* For the moment we don't trust print_one_breakpoint() to not throw
6792 if (catch_exceptions_with_msg (uiout
, do_captured_breakpoint_query
, &args
,
6793 error_message
, RETURN_MASK_ALL
) < 0)
6799 /* Return true if this breakpoint was set by the user, false if it is
6800 internal or momentary. */
6803 user_breakpoint_p (struct breakpoint
*b
)
6805 return b
->number
> 0;
6808 /* See breakpoint.h. */
6811 pending_breakpoint_p (struct breakpoint
*b
)
6813 return b
->loc
== NULL
;
6816 /* Print information on user settable breakpoint (watchpoint, etc)
6817 number BNUM. If BNUM is -1 print all user-settable breakpoints.
6818 If ALLFLAG is non-zero, include non-user-settable breakpoints. If
6819 FILTER is non-NULL, call it on each breakpoint and only include the
6820 ones for which it returns non-zero. Return the total number of
6821 breakpoints listed. */
6824 breakpoint_1 (char *args
, int allflag
,
6825 int (*filter
) (const struct breakpoint
*))
6827 struct breakpoint
*b
;
6828 struct bp_location
*last_loc
= NULL
;
6829 int nr_printable_breakpoints
;
6830 struct cleanup
*bkpttbl_chain
;
6831 struct value_print_options opts
;
6832 int print_address_bits
= 0;
6833 int print_type_col_width
= 14;
6834 struct ui_out
*uiout
= current_uiout
;
6836 get_user_print_options (&opts
);
6838 /* Compute the number of rows in the table, as well as the size
6839 required for address fields. */
6840 nr_printable_breakpoints
= 0;
6843 /* If we have a filter, only list the breakpoints it accepts. */
6844 if (filter
&& !filter (b
))
6847 /* If we have an "args" string, it is a list of breakpoints to
6848 accept. Skip the others. */
6849 if (args
!= NULL
&& *args
!= '\0')
6851 if (allflag
&& parse_and_eval_long (args
) != b
->number
)
6853 if (!allflag
&& !number_is_in_list (args
, b
->number
))
6857 if (allflag
|| user_breakpoint_p (b
))
6859 int addr_bit
, type_len
;
6861 addr_bit
= breakpoint_address_bits (b
);
6862 if (addr_bit
> print_address_bits
)
6863 print_address_bits
= addr_bit
;
6865 type_len
= strlen (bptype_string (b
->type
));
6866 if (type_len
> print_type_col_width
)
6867 print_type_col_width
= type_len
;
6869 nr_printable_breakpoints
++;
6873 if (opts
.addressprint
)
6875 = make_cleanup_ui_out_table_begin_end (uiout
, 6,
6876 nr_printable_breakpoints
,
6880 = make_cleanup_ui_out_table_begin_end (uiout
, 5,
6881 nr_printable_breakpoints
,
6884 if (nr_printable_breakpoints
> 0)
6885 annotate_breakpoints_headers ();
6886 if (nr_printable_breakpoints
> 0)
6888 ui_out_table_header (uiout
, 7, ui_left
, "number", "Num"); /* 1 */
6889 if (nr_printable_breakpoints
> 0)
6891 ui_out_table_header (uiout
, print_type_col_width
, ui_left
,
6892 "type", "Type"); /* 2 */
6893 if (nr_printable_breakpoints
> 0)
6895 ui_out_table_header (uiout
, 4, ui_left
, "disp", "Disp"); /* 3 */
6896 if (nr_printable_breakpoints
> 0)
6898 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb"); /* 4 */
6899 if (opts
.addressprint
)
6901 if (nr_printable_breakpoints
> 0)
6903 if (print_address_bits
<= 32)
6904 ui_out_table_header (uiout
, 10, ui_left
,
6905 "addr", "Address"); /* 5 */
6907 ui_out_table_header (uiout
, 18, ui_left
,
6908 "addr", "Address"); /* 5 */
6910 if (nr_printable_breakpoints
> 0)
6912 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What"); /* 6 */
6913 ui_out_table_body (uiout
);
6914 if (nr_printable_breakpoints
> 0)
6915 annotate_breakpoints_table ();
6920 /* If we have a filter, only list the breakpoints it accepts. */
6921 if (filter
&& !filter (b
))
6924 /* If we have an "args" string, it is a list of breakpoints to
6925 accept. Skip the others. */
6927 if (args
!= NULL
&& *args
!= '\0')
6929 if (allflag
) /* maintenance info breakpoint */
6931 if (parse_and_eval_long (args
) != b
->number
)
6934 else /* all others */
6936 if (!number_is_in_list (args
, b
->number
))
6940 /* We only print out user settable breakpoints unless the
6942 if (allflag
|| user_breakpoint_p (b
))
6943 print_one_breakpoint (b
, &last_loc
, allflag
);
6946 do_cleanups (bkpttbl_chain
);
6948 if (nr_printable_breakpoints
== 0)
6950 /* If there's a filter, let the caller decide how to report
6954 if (args
== NULL
|| *args
== '\0')
6955 ui_out_message (uiout
, 0, "No breakpoints or watchpoints.\n");
6957 ui_out_message (uiout
, 0,
6958 "No breakpoint or watchpoint matching '%s'.\n",
6964 if (last_loc
&& !server_command
)
6965 set_next_address (last_loc
->gdbarch
, last_loc
->address
);
6968 /* FIXME? Should this be moved up so that it is only called when
6969 there have been breakpoints? */
6970 annotate_breakpoints_table_end ();
6972 return nr_printable_breakpoints
;
6975 /* Display the value of default-collect in a way that is generally
6976 compatible with the breakpoint list. */
6979 default_collect_info (void)
6981 struct ui_out
*uiout
= current_uiout
;
6983 /* If it has no value (which is frequently the case), say nothing; a
6984 message like "No default-collect." gets in user's face when it's
6986 if (!*default_collect
)
6989 /* The following phrase lines up nicely with per-tracepoint collect
6991 ui_out_text (uiout
, "default collect ");
6992 ui_out_field_string (uiout
, "default-collect", default_collect
);
6993 ui_out_text (uiout
, " \n");
6997 breakpoints_info (char *args
, int from_tty
)
6999 breakpoint_1 (args
, 0, NULL
);
7001 default_collect_info ();
7005 watchpoints_info (char *args
, int from_tty
)
7007 int num_printed
= breakpoint_1 (args
, 0, is_watchpoint
);
7008 struct ui_out
*uiout
= current_uiout
;
7010 if (num_printed
== 0)
7012 if (args
== NULL
|| *args
== '\0')
7013 ui_out_message (uiout
, 0, "No watchpoints.\n");
7015 ui_out_message (uiout
, 0, "No watchpoint matching '%s'.\n", args
);
7020 maintenance_info_breakpoints (char *args
, int from_tty
)
7022 breakpoint_1 (args
, 1, NULL
);
7024 default_collect_info ();
7028 breakpoint_has_pc (struct breakpoint
*b
,
7029 struct program_space
*pspace
,
7030 CORE_ADDR pc
, struct obj_section
*section
)
7032 struct bp_location
*bl
= b
->loc
;
7034 for (; bl
; bl
= bl
->next
)
7036 if (bl
->pspace
== pspace
7037 && bl
->address
== pc
7038 && (!overlay_debugging
|| bl
->section
== section
))
7044 /* Print a message describing any user-breakpoints set at PC. This
7045 concerns with logical breakpoints, so we match program spaces, not
7049 describe_other_breakpoints (struct gdbarch
*gdbarch
,
7050 struct program_space
*pspace
, CORE_ADDR pc
,
7051 struct obj_section
*section
, int thread
)
7054 struct breakpoint
*b
;
7057 others
+= (user_breakpoint_p (b
)
7058 && breakpoint_has_pc (b
, pspace
, pc
, section
));
7062 printf_filtered (_("Note: breakpoint "));
7063 else /* if (others == ???) */
7064 printf_filtered (_("Note: breakpoints "));
7066 if (user_breakpoint_p (b
) && breakpoint_has_pc (b
, pspace
, pc
, section
))
7069 printf_filtered ("%d", b
->number
);
7070 if (b
->thread
== -1 && thread
!= -1)
7071 printf_filtered (" (all threads)");
7072 else if (b
->thread
!= -1)
7073 printf_filtered (" (thread %d)", b
->thread
);
7074 printf_filtered ("%s%s ",
7075 ((b
->enable_state
== bp_disabled
7076 || b
->enable_state
== bp_call_disabled
)
7080 : ((others
== 1) ? " and" : ""));
7082 printf_filtered (_("also set at pc "));
7083 fputs_filtered (paddress (gdbarch
, pc
), gdb_stdout
);
7084 printf_filtered (".\n");
7089 /* Return true iff it is meaningful to use the address member of
7090 BPT locations. For some breakpoint types, the locations' address members
7091 are irrelevant and it makes no sense to attempt to compare them to other
7092 addresses (or use them for any other purpose either).
7094 More specifically, each of the following breakpoint types will
7095 always have a zero valued location address and we don't want to mark
7096 breakpoints of any of these types to be a duplicate of an actual
7097 breakpoint location at address zero:
7105 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
7107 enum bptype type
= bpt
->type
;
7109 return (type
!= bp_watchpoint
&& type
!= bp_catchpoint
);
7112 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
7113 true if LOC1 and LOC2 represent the same watchpoint location. */
7116 watchpoint_locations_match (struct bp_location
*loc1
,
7117 struct bp_location
*loc2
)
7119 struct watchpoint
*w1
= (struct watchpoint
*) loc1
->owner
;
7120 struct watchpoint
*w2
= (struct watchpoint
*) loc2
->owner
;
7122 /* Both of them must exist. */
7123 gdb_assert (w1
!= NULL
);
7124 gdb_assert (w2
!= NULL
);
7126 /* If the target can evaluate the condition expression in hardware,
7127 then we we need to insert both watchpoints even if they are at
7128 the same place. Otherwise the watchpoint will only trigger when
7129 the condition of whichever watchpoint was inserted evaluates to
7130 true, not giving a chance for GDB to check the condition of the
7131 other watchpoint. */
7133 && target_can_accel_watchpoint_condition (loc1
->address
,
7135 loc1
->watchpoint_type
,
7136 w1
->cond_exp
.get ()))
7138 && target_can_accel_watchpoint_condition (loc2
->address
,
7140 loc2
->watchpoint_type
,
7141 w2
->cond_exp
.get ())))
7144 /* Note that this checks the owner's type, not the location's. In
7145 case the target does not support read watchpoints, but does
7146 support access watchpoints, we'll have bp_read_watchpoint
7147 watchpoints with hw_access locations. Those should be considered
7148 duplicates of hw_read locations. The hw_read locations will
7149 become hw_access locations later. */
7150 return (loc1
->owner
->type
== loc2
->owner
->type
7151 && loc1
->pspace
->aspace
== loc2
->pspace
->aspace
7152 && loc1
->address
== loc2
->address
7153 && loc1
->length
== loc2
->length
);
7156 /* See breakpoint.h. */
7159 breakpoint_address_match (struct address_space
*aspace1
, CORE_ADDR addr1
,
7160 struct address_space
*aspace2
, CORE_ADDR addr2
)
7162 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
7163 || aspace1
== aspace2
)
7167 /* Returns true if {ASPACE2,ADDR2} falls within the range determined by
7168 {ASPACE1,ADDR1,LEN1}. In most targets, this can only be true if ASPACE1
7169 matches ASPACE2. On targets that have global breakpoints, the address
7170 space doesn't really matter. */
7173 breakpoint_address_match_range (struct address_space
*aspace1
, CORE_ADDR addr1
,
7174 int len1
, struct address_space
*aspace2
,
7177 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
7178 || aspace1
== aspace2
)
7179 && addr2
>= addr1
&& addr2
< addr1
+ len1
);
7182 /* Returns true if {ASPACE,ADDR} matches the breakpoint BL. BL may be
7183 a ranged breakpoint. In most targets, a match happens only if ASPACE
7184 matches the breakpoint's address space. On targets that have global
7185 breakpoints, the address space doesn't really matter. */
7188 breakpoint_location_address_match (struct bp_location
*bl
,
7189 struct address_space
*aspace
,
7192 return (breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
7195 && breakpoint_address_match_range (bl
->pspace
->aspace
,
7196 bl
->address
, bl
->length
,
7200 /* Returns true if the [ADDR,ADDR+LEN) range in ASPACE overlaps
7201 breakpoint BL. BL may be a ranged breakpoint. In most targets, a
7202 match happens only if ASPACE matches the breakpoint's address
7203 space. On targets that have global breakpoints, the address space
7204 doesn't really matter. */
7207 breakpoint_location_address_range_overlap (struct bp_location
*bl
,
7208 struct address_space
*aspace
,
7209 CORE_ADDR addr
, int len
)
7211 if (gdbarch_has_global_breakpoints (target_gdbarch ())
7212 || bl
->pspace
->aspace
== aspace
)
7214 int bl_len
= bl
->length
!= 0 ? bl
->length
: 1;
7216 if (mem_ranges_overlap (addr
, len
, bl
->address
, bl_len
))
7222 /* If LOC1 and LOC2's owners are not tracepoints, returns false directly.
7223 Then, if LOC1 and LOC2 represent the same tracepoint location, returns
7224 true, otherwise returns false. */
7227 tracepoint_locations_match (struct bp_location
*loc1
,
7228 struct bp_location
*loc2
)
7230 if (is_tracepoint (loc1
->owner
) && is_tracepoint (loc2
->owner
))
7231 /* Since tracepoint locations are never duplicated with others', tracepoint
7232 locations at the same address of different tracepoints are regarded as
7233 different locations. */
7234 return (loc1
->address
== loc2
->address
&& loc1
->owner
== loc2
->owner
);
7239 /* Assuming LOC1 and LOC2's types' have meaningful target addresses
7240 (breakpoint_address_is_meaningful), returns true if LOC1 and LOC2
7241 represent the same location. */
7244 breakpoint_locations_match (struct bp_location
*loc1
,
7245 struct bp_location
*loc2
)
7247 int hw_point1
, hw_point2
;
7249 /* Both of them must not be in moribund_locations. */
7250 gdb_assert (loc1
->owner
!= NULL
);
7251 gdb_assert (loc2
->owner
!= NULL
);
7253 hw_point1
= is_hardware_watchpoint (loc1
->owner
);
7254 hw_point2
= is_hardware_watchpoint (loc2
->owner
);
7256 if (hw_point1
!= hw_point2
)
7259 return watchpoint_locations_match (loc1
, loc2
);
7260 else if (is_tracepoint (loc1
->owner
) || is_tracepoint (loc2
->owner
))
7261 return tracepoint_locations_match (loc1
, loc2
);
7263 /* We compare bp_location.length in order to cover ranged breakpoints. */
7264 return (breakpoint_address_match (loc1
->pspace
->aspace
, loc1
->address
,
7265 loc2
->pspace
->aspace
, loc2
->address
)
7266 && loc1
->length
== loc2
->length
);
7270 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
7271 int bnum
, int have_bnum
)
7273 /* The longest string possibly returned by hex_string_custom
7274 is 50 chars. These must be at least that big for safety. */
7278 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
7279 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
7281 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
7282 bnum
, astr1
, astr2
);
7284 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
7287 /* Adjust a breakpoint's address to account for architectural
7288 constraints on breakpoint placement. Return the adjusted address.
7289 Note: Very few targets require this kind of adjustment. For most
7290 targets, this function is simply the identity function. */
7293 adjust_breakpoint_address (struct gdbarch
*gdbarch
,
7294 CORE_ADDR bpaddr
, enum bptype bptype
)
7296 if (!gdbarch_adjust_breakpoint_address_p (gdbarch
))
7298 /* Very few targets need any kind of breakpoint adjustment. */
7301 else if (bptype
== bp_watchpoint
7302 || bptype
== bp_hardware_watchpoint
7303 || bptype
== bp_read_watchpoint
7304 || bptype
== bp_access_watchpoint
7305 || bptype
== bp_catchpoint
)
7307 /* Watchpoints and the various bp_catch_* eventpoints should not
7308 have their addresses modified. */
7311 else if (bptype
== bp_single_step
)
7313 /* Single-step breakpoints should not have their addresses
7314 modified. If there's any architectural constrain that
7315 applies to this address, then it should have already been
7316 taken into account when the breakpoint was created in the
7317 first place. If we didn't do this, stepping through e.g.,
7318 Thumb-2 IT blocks would break. */
7323 CORE_ADDR adjusted_bpaddr
;
7325 /* Some targets have architectural constraints on the placement
7326 of breakpoint instructions. Obtain the adjusted address. */
7327 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (gdbarch
, bpaddr
);
7329 /* An adjusted breakpoint address can significantly alter
7330 a user's expectations. Print a warning if an adjustment
7332 if (adjusted_bpaddr
!= bpaddr
)
7333 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
7335 return adjusted_bpaddr
;
7340 init_bp_location (struct bp_location
*loc
, const struct bp_location_ops
*ops
,
7341 struct breakpoint
*owner
)
7343 memset (loc
, 0, sizeof (*loc
));
7345 gdb_assert (ops
!= NULL
);
7349 loc
->cond_bytecode
= NULL
;
7350 loc
->shlib_disabled
= 0;
7353 switch (owner
->type
)
7356 case bp_single_step
:
7360 case bp_longjmp_resume
:
7361 case bp_longjmp_call_dummy
:
7363 case bp_exception_resume
:
7364 case bp_step_resume
:
7365 case bp_hp_step_resume
:
7366 case bp_watchpoint_scope
:
7368 case bp_std_terminate
:
7369 case bp_shlib_event
:
7370 case bp_thread_event
:
7371 case bp_overlay_event
:
7373 case bp_longjmp_master
:
7374 case bp_std_terminate_master
:
7375 case bp_exception_master
:
7376 case bp_gnu_ifunc_resolver
:
7377 case bp_gnu_ifunc_resolver_return
:
7379 loc
->loc_type
= bp_loc_software_breakpoint
;
7380 mark_breakpoint_location_modified (loc
);
7382 case bp_hardware_breakpoint
:
7383 loc
->loc_type
= bp_loc_hardware_breakpoint
;
7384 mark_breakpoint_location_modified (loc
);
7386 case bp_hardware_watchpoint
:
7387 case bp_read_watchpoint
:
7388 case bp_access_watchpoint
:
7389 loc
->loc_type
= bp_loc_hardware_watchpoint
;
7394 case bp_fast_tracepoint
:
7395 case bp_static_tracepoint
:
7396 loc
->loc_type
= bp_loc_other
;
7399 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
7405 /* Allocate a struct bp_location. */
7407 static struct bp_location
*
7408 allocate_bp_location (struct breakpoint
*bpt
)
7410 return bpt
->ops
->allocate_location (bpt
);
7414 free_bp_location (struct bp_location
*loc
)
7416 loc
->ops
->dtor (loc
);
7420 /* Increment reference count. */
7423 incref_bp_location (struct bp_location
*bl
)
7428 /* Decrement reference count. If the reference count reaches 0,
7429 destroy the bp_location. Sets *BLP to NULL. */
7432 decref_bp_location (struct bp_location
**blp
)
7434 gdb_assert ((*blp
)->refc
> 0);
7436 if (--(*blp
)->refc
== 0)
7437 free_bp_location (*blp
);
7441 /* Add breakpoint B at the end of the global breakpoint chain. */
7444 add_to_breakpoint_chain (struct breakpoint
*b
)
7446 struct breakpoint
*b1
;
7448 /* Add this breakpoint to the end of the chain so that a list of
7449 breakpoints will come out in order of increasing numbers. */
7451 b1
= breakpoint_chain
;
7453 breakpoint_chain
= b
;
7462 /* Initializes breakpoint B with type BPTYPE and no locations yet. */
7465 init_raw_breakpoint_without_location (struct breakpoint
*b
,
7466 struct gdbarch
*gdbarch
,
7468 const struct breakpoint_ops
*ops
)
7470 memset (b
, 0, sizeof (*b
));
7472 gdb_assert (ops
!= NULL
);
7476 b
->gdbarch
= gdbarch
;
7477 b
->language
= current_language
->la_language
;
7478 b
->input_radix
= input_radix
;
7480 b
->enable_state
= bp_enabled
;
7483 b
->ignore_count
= 0;
7485 b
->frame_id
= null_frame_id
;
7486 b
->condition_not_parsed
= 0;
7487 b
->py_bp_object
= NULL
;
7488 b
->related_breakpoint
= b
;
7492 /* Helper to set_raw_breakpoint below. Creates a breakpoint
7493 that has type BPTYPE and has no locations as yet. */
7495 static struct breakpoint
*
7496 set_raw_breakpoint_without_location (struct gdbarch
*gdbarch
,
7498 const struct breakpoint_ops
*ops
)
7500 struct breakpoint
*b
= new breakpoint ();
7502 init_raw_breakpoint_without_location (b
, gdbarch
, bptype
, ops
);
7503 add_to_breakpoint_chain (b
);
7507 /* Initialize loc->function_name. EXPLICIT_LOC says no indirect function
7508 resolutions should be made as the user specified the location explicitly
7512 set_breakpoint_location_function (struct bp_location
*loc
, int explicit_loc
)
7514 gdb_assert (loc
->owner
!= NULL
);
7516 if (loc
->owner
->type
== bp_breakpoint
7517 || loc
->owner
->type
== bp_hardware_breakpoint
7518 || is_tracepoint (loc
->owner
))
7521 const char *function_name
;
7522 CORE_ADDR func_addr
;
7524 find_pc_partial_function_gnu_ifunc (loc
->address
, &function_name
,
7525 &func_addr
, NULL
, &is_gnu_ifunc
);
7527 if (is_gnu_ifunc
&& !explicit_loc
)
7529 struct breakpoint
*b
= loc
->owner
;
7531 gdb_assert (loc
->pspace
== current_program_space
);
7532 if (gnu_ifunc_resolve_name (function_name
,
7533 &loc
->requested_address
))
7535 /* Recalculate ADDRESS based on new REQUESTED_ADDRESS. */
7536 loc
->address
= adjust_breakpoint_address (loc
->gdbarch
,
7537 loc
->requested_address
,
7540 else if (b
->type
== bp_breakpoint
&& b
->loc
== loc
7541 && loc
->next
== NULL
&& b
->related_breakpoint
== b
)
7543 /* Create only the whole new breakpoint of this type but do not
7544 mess more complicated breakpoints with multiple locations. */
7545 b
->type
= bp_gnu_ifunc_resolver
;
7546 /* Remember the resolver's address for use by the return
7548 loc
->related_address
= func_addr
;
7553 loc
->function_name
= xstrdup (function_name
);
7557 /* Attempt to determine architecture of location identified by SAL. */
7559 get_sal_arch (struct symtab_and_line sal
)
7562 return get_objfile_arch (sal
.section
->objfile
);
7564 return get_objfile_arch (SYMTAB_OBJFILE (sal
.symtab
));
7569 /* Low level routine for partially initializing a breakpoint of type
7570 BPTYPE. The newly created breakpoint's address, section, source
7571 file name, and line number are provided by SAL.
7573 It is expected that the caller will complete the initialization of
7574 the newly created breakpoint struct as well as output any status
7575 information regarding the creation of a new breakpoint. */
7578 init_raw_breakpoint (struct breakpoint
*b
, struct gdbarch
*gdbarch
,
7579 struct symtab_and_line sal
, enum bptype bptype
,
7580 const struct breakpoint_ops
*ops
)
7582 init_raw_breakpoint_without_location (b
, gdbarch
, bptype
, ops
);
7584 add_location_to_breakpoint (b
, &sal
);
7586 if (bptype
!= bp_catchpoint
)
7587 gdb_assert (sal
.pspace
!= NULL
);
7589 /* Store the program space that was used to set the breakpoint,
7590 except for ordinary breakpoints, which are independent of the
7592 if (bptype
!= bp_breakpoint
&& bptype
!= bp_hardware_breakpoint
)
7593 b
->pspace
= sal
.pspace
;
7596 /* set_raw_breakpoint is a low level routine for allocating and
7597 partially initializing a breakpoint of type BPTYPE. The newly
7598 created breakpoint's address, section, source file name, and line
7599 number are provided by SAL. The newly created and partially
7600 initialized breakpoint is added to the breakpoint chain and
7601 is also returned as the value of this function.
7603 It is expected that the caller will complete the initialization of
7604 the newly created breakpoint struct as well as output any status
7605 information regarding the creation of a new breakpoint. In
7606 particular, set_raw_breakpoint does NOT set the breakpoint
7607 number! Care should be taken to not allow an error to occur
7608 prior to completing the initialization of the breakpoint. If this
7609 should happen, a bogus breakpoint will be left on the chain. */
7612 set_raw_breakpoint (struct gdbarch
*gdbarch
,
7613 struct symtab_and_line sal
, enum bptype bptype
,
7614 const struct breakpoint_ops
*ops
)
7616 struct breakpoint
*b
= new breakpoint ();
7618 init_raw_breakpoint (b
, gdbarch
, sal
, bptype
, ops
);
7619 add_to_breakpoint_chain (b
);
7623 /* Call this routine when stepping and nexting to enable a breakpoint
7624 if we do a longjmp() or 'throw' in TP. FRAME is the frame which
7625 initiated the operation. */
7628 set_longjmp_breakpoint (struct thread_info
*tp
, struct frame_id frame
)
7630 struct breakpoint
*b
, *b_tmp
;
7631 int thread
= tp
->global_num
;
7633 /* To avoid having to rescan all objfile symbols at every step,
7634 we maintain a list of continually-inserted but always disabled
7635 longjmp "master" breakpoints. Here, we simply create momentary
7636 clones of those and enable them for the requested thread. */
7637 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7638 if (b
->pspace
== current_program_space
7639 && (b
->type
== bp_longjmp_master
7640 || b
->type
== bp_exception_master
))
7642 enum bptype type
= b
->type
== bp_longjmp_master
? bp_longjmp
: bp_exception
;
7643 struct breakpoint
*clone
;
7645 /* longjmp_breakpoint_ops ensures INITIATING_FRAME is cleared again
7646 after their removal. */
7647 clone
= momentary_breakpoint_from_master (b
, type
,
7648 &longjmp_breakpoint_ops
, 1);
7649 clone
->thread
= thread
;
7652 tp
->initiating_frame
= frame
;
7655 /* Delete all longjmp breakpoints from THREAD. */
7657 delete_longjmp_breakpoint (int thread
)
7659 struct breakpoint
*b
, *b_tmp
;
7661 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7662 if (b
->type
== bp_longjmp
|| b
->type
== bp_exception
)
7664 if (b
->thread
== thread
)
7665 delete_breakpoint (b
);
7670 delete_longjmp_breakpoint_at_next_stop (int thread
)
7672 struct breakpoint
*b
, *b_tmp
;
7674 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7675 if (b
->type
== bp_longjmp
|| b
->type
== bp_exception
)
7677 if (b
->thread
== thread
)
7678 b
->disposition
= disp_del_at_next_stop
;
7682 /* Place breakpoints of type bp_longjmp_call_dummy to catch longjmp for
7683 INFERIOR_PTID thread. Chain them all by RELATED_BREAKPOINT and return
7684 pointer to any of them. Return NULL if this system cannot place longjmp
7688 set_longjmp_breakpoint_for_call_dummy (void)
7690 struct breakpoint
*b
, *retval
= NULL
;
7693 if (b
->pspace
== current_program_space
&& b
->type
== bp_longjmp_master
)
7695 struct breakpoint
*new_b
;
7697 new_b
= momentary_breakpoint_from_master (b
, bp_longjmp_call_dummy
,
7698 &momentary_breakpoint_ops
,
7700 new_b
->thread
= ptid_to_global_thread_id (inferior_ptid
);
7702 /* Link NEW_B into the chain of RETVAL breakpoints. */
7704 gdb_assert (new_b
->related_breakpoint
== new_b
);
7707 new_b
->related_breakpoint
= retval
;
7708 while (retval
->related_breakpoint
!= new_b
->related_breakpoint
)
7709 retval
= retval
->related_breakpoint
;
7710 retval
->related_breakpoint
= new_b
;
7716 /* Verify all existing dummy frames and their associated breakpoints for
7717 TP. Remove those which can no longer be found in the current frame
7720 You should call this function only at places where it is safe to currently
7721 unwind the whole stack. Failed stack unwind would discard live dummy
7725 check_longjmp_breakpoint_for_call_dummy (struct thread_info
*tp
)
7727 struct breakpoint
*b
, *b_tmp
;
7729 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7730 if (b
->type
== bp_longjmp_call_dummy
&& b
->thread
== tp
->global_num
)
7732 struct breakpoint
*dummy_b
= b
->related_breakpoint
;
7734 while (dummy_b
!= b
&& dummy_b
->type
!= bp_call_dummy
)
7735 dummy_b
= dummy_b
->related_breakpoint
;
7736 if (dummy_b
->type
!= bp_call_dummy
7737 || frame_find_by_id (dummy_b
->frame_id
) != NULL
)
7740 dummy_frame_discard (dummy_b
->frame_id
, tp
->ptid
);
7742 while (b
->related_breakpoint
!= b
)
7744 if (b_tmp
== b
->related_breakpoint
)
7745 b_tmp
= b
->related_breakpoint
->next
;
7746 delete_breakpoint (b
->related_breakpoint
);
7748 delete_breakpoint (b
);
7753 enable_overlay_breakpoints (void)
7755 struct breakpoint
*b
;
7758 if (b
->type
== bp_overlay_event
)
7760 b
->enable_state
= bp_enabled
;
7761 update_global_location_list (UGLL_MAY_INSERT
);
7762 overlay_events_enabled
= 1;
7767 disable_overlay_breakpoints (void)
7769 struct breakpoint
*b
;
7772 if (b
->type
== bp_overlay_event
)
7774 b
->enable_state
= bp_disabled
;
7775 update_global_location_list (UGLL_DONT_INSERT
);
7776 overlay_events_enabled
= 0;
7780 /* Set an active std::terminate breakpoint for each std::terminate
7781 master breakpoint. */
7783 set_std_terminate_breakpoint (void)
7785 struct breakpoint
*b
, *b_tmp
;
7787 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7788 if (b
->pspace
== current_program_space
7789 && b
->type
== bp_std_terminate_master
)
7791 momentary_breakpoint_from_master (b
, bp_std_terminate
,
7792 &momentary_breakpoint_ops
, 1);
7796 /* Delete all the std::terminate breakpoints. */
7798 delete_std_terminate_breakpoint (void)
7800 struct breakpoint
*b
, *b_tmp
;
7802 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7803 if (b
->type
== bp_std_terminate
)
7804 delete_breakpoint (b
);
7808 create_thread_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7810 struct breakpoint
*b
;
7812 b
= create_internal_breakpoint (gdbarch
, address
, bp_thread_event
,
7813 &internal_breakpoint_ops
);
7815 b
->enable_state
= bp_enabled
;
7816 /* location has to be used or breakpoint_re_set will delete me. */
7817 b
->location
= new_address_location (b
->loc
->address
, NULL
, 0);
7819 update_global_location_list_nothrow (UGLL_MAY_INSERT
);
7824 struct lang_and_radix
7830 /* Create a breakpoint for JIT code registration and unregistration. */
7833 create_jit_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7835 return create_internal_breakpoint (gdbarch
, address
, bp_jit_event
,
7836 &internal_breakpoint_ops
);
7839 /* Remove JIT code registration and unregistration breakpoint(s). */
7842 remove_jit_event_breakpoints (void)
7844 struct breakpoint
*b
, *b_tmp
;
7846 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7847 if (b
->type
== bp_jit_event
7848 && b
->loc
->pspace
== current_program_space
)
7849 delete_breakpoint (b
);
7853 remove_solib_event_breakpoints (void)
7855 struct breakpoint
*b
, *b_tmp
;
7857 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7858 if (b
->type
== bp_shlib_event
7859 && b
->loc
->pspace
== current_program_space
)
7860 delete_breakpoint (b
);
7863 /* See breakpoint.h. */
7866 remove_solib_event_breakpoints_at_next_stop (void)
7868 struct breakpoint
*b
, *b_tmp
;
7870 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7871 if (b
->type
== bp_shlib_event
7872 && b
->loc
->pspace
== current_program_space
)
7873 b
->disposition
= disp_del_at_next_stop
;
7876 /* Helper for create_solib_event_breakpoint /
7877 create_and_insert_solib_event_breakpoint. Allows specifying which
7878 INSERT_MODE to pass through to update_global_location_list. */
7880 static struct breakpoint
*
7881 create_solib_event_breakpoint_1 (struct gdbarch
*gdbarch
, CORE_ADDR address
,
7882 enum ugll_insert_mode insert_mode
)
7884 struct breakpoint
*b
;
7886 b
= create_internal_breakpoint (gdbarch
, address
, bp_shlib_event
,
7887 &internal_breakpoint_ops
);
7888 update_global_location_list_nothrow (insert_mode
);
7893 create_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7895 return create_solib_event_breakpoint_1 (gdbarch
, address
, UGLL_MAY_INSERT
);
7898 /* See breakpoint.h. */
7901 create_and_insert_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7903 struct breakpoint
*b
;
7905 /* Explicitly tell update_global_location_list to insert
7907 b
= create_solib_event_breakpoint_1 (gdbarch
, address
, UGLL_INSERT
);
7908 if (!b
->loc
->inserted
)
7910 delete_breakpoint (b
);
7916 /* Disable any breakpoints that are on code in shared libraries. Only
7917 apply to enabled breakpoints, disabled ones can just stay disabled. */
7920 disable_breakpoints_in_shlibs (void)
7922 struct bp_location
*loc
, **locp_tmp
;
7924 ALL_BP_LOCATIONS (loc
, locp_tmp
)
7926 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7927 struct breakpoint
*b
= loc
->owner
;
7929 /* We apply the check to all breakpoints, including disabled for
7930 those with loc->duplicate set. This is so that when breakpoint
7931 becomes enabled, or the duplicate is removed, gdb will try to
7932 insert all breakpoints. If we don't set shlib_disabled here,
7933 we'll try to insert those breakpoints and fail. */
7934 if (((b
->type
== bp_breakpoint
)
7935 || (b
->type
== bp_jit_event
)
7936 || (b
->type
== bp_hardware_breakpoint
)
7937 || (is_tracepoint (b
)))
7938 && loc
->pspace
== current_program_space
7939 && !loc
->shlib_disabled
7940 && solib_name_from_address (loc
->pspace
, loc
->address
)
7943 loc
->shlib_disabled
= 1;
7948 /* Disable any breakpoints and tracepoints that are in SOLIB upon
7949 notification of unloaded_shlib. Only apply to enabled breakpoints,
7950 disabled ones can just stay disabled. */
7953 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
7955 struct bp_location
*loc
, **locp_tmp
;
7956 int disabled_shlib_breaks
= 0;
7958 /* SunOS a.out shared libraries are always mapped, so do not
7959 disable breakpoints; they will only be reported as unloaded
7960 through clear_solib when GDB discards its shared library
7961 list. See clear_solib for more information. */
7962 if (exec_bfd
!= NULL
7963 && bfd_get_flavour (exec_bfd
) == bfd_target_aout_flavour
)
7966 ALL_BP_LOCATIONS (loc
, locp_tmp
)
7968 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7969 struct breakpoint
*b
= loc
->owner
;
7971 if (solib
->pspace
== loc
->pspace
7972 && !loc
->shlib_disabled
7973 && (((b
->type
== bp_breakpoint
7974 || b
->type
== bp_jit_event
7975 || b
->type
== bp_hardware_breakpoint
)
7976 && (loc
->loc_type
== bp_loc_hardware_breakpoint
7977 || loc
->loc_type
== bp_loc_software_breakpoint
))
7978 || is_tracepoint (b
))
7979 && solib_contains_address_p (solib
, loc
->address
))
7981 loc
->shlib_disabled
= 1;
7982 /* At this point, we cannot rely on remove_breakpoint
7983 succeeding so we must mark the breakpoint as not inserted
7984 to prevent future errors occurring in remove_breakpoints. */
7987 /* This may cause duplicate notifications for the same breakpoint. */
7988 observer_notify_breakpoint_modified (b
);
7990 if (!disabled_shlib_breaks
)
7992 target_terminal_ours_for_output ();
7993 warning (_("Temporarily disabling breakpoints "
7994 "for unloaded shared library \"%s\""),
7997 disabled_shlib_breaks
= 1;
8002 /* Disable any breakpoints and tracepoints in OBJFILE upon
8003 notification of free_objfile. Only apply to enabled breakpoints,
8004 disabled ones can just stay disabled. */
8007 disable_breakpoints_in_freed_objfile (struct objfile
*objfile
)
8009 struct breakpoint
*b
;
8011 if (objfile
== NULL
)
8014 /* OBJF_SHARED|OBJF_USERLOADED objfiles are dynamic modules manually
8015 managed by the user with add-symbol-file/remove-symbol-file.
8016 Similarly to how breakpoints in shared libraries are handled in
8017 response to "nosharedlibrary", mark breakpoints in such modules
8018 shlib_disabled so they end up uninserted on the next global
8019 location list update. Shared libraries not loaded by the user
8020 aren't handled here -- they're already handled in
8021 disable_breakpoints_in_unloaded_shlib, called by solib.c's
8022 solib_unloaded observer. We skip objfiles that are not
8023 OBJF_SHARED as those aren't considered dynamic objects (e.g. the
8025 if ((objfile
->flags
& OBJF_SHARED
) == 0
8026 || (objfile
->flags
& OBJF_USERLOADED
) == 0)
8031 struct bp_location
*loc
;
8032 int bp_modified
= 0;
8034 if (!is_breakpoint (b
) && !is_tracepoint (b
))
8037 for (loc
= b
->loc
; loc
!= NULL
; loc
= loc
->next
)
8039 CORE_ADDR loc_addr
= loc
->address
;
8041 if (loc
->loc_type
!= bp_loc_hardware_breakpoint
8042 && loc
->loc_type
!= bp_loc_software_breakpoint
)
8045 if (loc
->shlib_disabled
!= 0)
8048 if (objfile
->pspace
!= loc
->pspace
)
8051 if (loc
->loc_type
!= bp_loc_hardware_breakpoint
8052 && loc
->loc_type
!= bp_loc_software_breakpoint
)
8055 if (is_addr_in_objfile (loc_addr
, objfile
))
8057 loc
->shlib_disabled
= 1;
8058 /* At this point, we don't know whether the object was
8059 unmapped from the inferior or not, so leave the
8060 inserted flag alone. We'll handle failure to
8061 uninsert quietly, in case the object was indeed
8064 mark_breakpoint_location_modified (loc
);
8071 observer_notify_breakpoint_modified (b
);
8075 /* FORK & VFORK catchpoints. */
8077 /* An instance of this type is used to represent a fork or vfork
8078 catchpoint. It includes a "struct breakpoint" as a kind of base
8079 class; users downcast to "struct breakpoint *" when needed. A
8080 breakpoint is really of this type iff its ops pointer points to
8081 CATCH_FORK_BREAKPOINT_OPS. */
8083 struct fork_catchpoint
8085 /* The base class. */
8086 struct breakpoint base
;
8088 /* Process id of a child process whose forking triggered this
8089 catchpoint. This field is only valid immediately after this
8090 catchpoint has triggered. */
8091 ptid_t forked_inferior_pid
;
8094 /* Implement the "insert" breakpoint_ops method for fork
8098 insert_catch_fork (struct bp_location
*bl
)
8100 return target_insert_fork_catchpoint (ptid_get_pid (inferior_ptid
));
8103 /* Implement the "remove" breakpoint_ops method for fork
8107 remove_catch_fork (struct bp_location
*bl
, enum remove_bp_reason reason
)
8109 return target_remove_fork_catchpoint (ptid_get_pid (inferior_ptid
));
8112 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
8116 breakpoint_hit_catch_fork (const struct bp_location
*bl
,
8117 struct address_space
*aspace
, CORE_ADDR bp_addr
,
8118 const struct target_waitstatus
*ws
)
8120 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bl
->owner
;
8122 if (ws
->kind
!= TARGET_WAITKIND_FORKED
)
8125 c
->forked_inferior_pid
= ws
->value
.related_pid
;
8129 /* Implement the "print_it" breakpoint_ops method for fork
8132 static enum print_stop_action
8133 print_it_catch_fork (bpstat bs
)
8135 struct ui_out
*uiout
= current_uiout
;
8136 struct breakpoint
*b
= bs
->breakpoint_at
;
8137 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bs
->breakpoint_at
;
8139 annotate_catchpoint (b
->number
);
8140 maybe_print_thread_hit_breakpoint (uiout
);
8141 if (b
->disposition
== disp_del
)
8142 ui_out_text (uiout
, "Temporary catchpoint ");
8144 ui_out_text (uiout
, "Catchpoint ");
8145 if (ui_out_is_mi_like_p (uiout
))
8147 ui_out_field_string (uiout
, "reason",
8148 async_reason_lookup (EXEC_ASYNC_FORK
));
8149 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
8151 ui_out_field_int (uiout
, "bkptno", b
->number
);
8152 ui_out_text (uiout
, " (forked process ");
8153 ui_out_field_int (uiout
, "newpid", ptid_get_pid (c
->forked_inferior_pid
));
8154 ui_out_text (uiout
, "), ");
8155 return PRINT_SRC_AND_LOC
;
8158 /* Implement the "print_one" breakpoint_ops method for fork
8162 print_one_catch_fork (struct breakpoint
*b
, struct bp_location
**last_loc
)
8164 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
8165 struct value_print_options opts
;
8166 struct ui_out
*uiout
= current_uiout
;
8168 get_user_print_options (&opts
);
8170 /* Field 4, the address, is omitted (which makes the columns not
8171 line up too nicely with the headers, but the effect is relatively
8173 if (opts
.addressprint
)
8174 ui_out_field_skip (uiout
, "addr");
8176 ui_out_text (uiout
, "fork");
8177 if (!ptid_equal (c
->forked_inferior_pid
, null_ptid
))
8179 ui_out_text (uiout
, ", process ");
8180 ui_out_field_int (uiout
, "what",
8181 ptid_get_pid (c
->forked_inferior_pid
));
8182 ui_out_spaces (uiout
, 1);
8185 if (ui_out_is_mi_like_p (uiout
))
8186 ui_out_field_string (uiout
, "catch-type", "fork");
8189 /* Implement the "print_mention" breakpoint_ops method for fork
8193 print_mention_catch_fork (struct breakpoint
*b
)
8195 printf_filtered (_("Catchpoint %d (fork)"), b
->number
);
8198 /* Implement the "print_recreate" breakpoint_ops method for fork
8202 print_recreate_catch_fork (struct breakpoint
*b
, struct ui_file
*fp
)
8204 fprintf_unfiltered (fp
, "catch fork");
8205 print_recreate_thread (b
, fp
);
8208 /* The breakpoint_ops structure to be used in fork catchpoints. */
8210 static struct breakpoint_ops catch_fork_breakpoint_ops
;
8212 /* Implement the "insert" breakpoint_ops method for vfork
8216 insert_catch_vfork (struct bp_location
*bl
)
8218 return target_insert_vfork_catchpoint (ptid_get_pid (inferior_ptid
));
8221 /* Implement the "remove" breakpoint_ops method for vfork
8225 remove_catch_vfork (struct bp_location
*bl
, enum remove_bp_reason reason
)
8227 return target_remove_vfork_catchpoint (ptid_get_pid (inferior_ptid
));
8230 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
8234 breakpoint_hit_catch_vfork (const struct bp_location
*bl
,
8235 struct address_space
*aspace
, CORE_ADDR bp_addr
,
8236 const struct target_waitstatus
*ws
)
8238 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bl
->owner
;
8240 if (ws
->kind
!= TARGET_WAITKIND_VFORKED
)
8243 c
->forked_inferior_pid
= ws
->value
.related_pid
;
8247 /* Implement the "print_it" breakpoint_ops method for vfork
8250 static enum print_stop_action
8251 print_it_catch_vfork (bpstat bs
)
8253 struct ui_out
*uiout
= current_uiout
;
8254 struct breakpoint
*b
= bs
->breakpoint_at
;
8255 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
8257 annotate_catchpoint (b
->number
);
8258 maybe_print_thread_hit_breakpoint (uiout
);
8259 if (b
->disposition
== disp_del
)
8260 ui_out_text (uiout
, "Temporary catchpoint ");
8262 ui_out_text (uiout
, "Catchpoint ");
8263 if (ui_out_is_mi_like_p (uiout
))
8265 ui_out_field_string (uiout
, "reason",
8266 async_reason_lookup (EXEC_ASYNC_VFORK
));
8267 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
8269 ui_out_field_int (uiout
, "bkptno", b
->number
);
8270 ui_out_text (uiout
, " (vforked process ");
8271 ui_out_field_int (uiout
, "newpid", ptid_get_pid (c
->forked_inferior_pid
));
8272 ui_out_text (uiout
, "), ");
8273 return PRINT_SRC_AND_LOC
;
8276 /* Implement the "print_one" breakpoint_ops method for vfork
8280 print_one_catch_vfork (struct breakpoint
*b
, struct bp_location
**last_loc
)
8282 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
8283 struct value_print_options opts
;
8284 struct ui_out
*uiout
= current_uiout
;
8286 get_user_print_options (&opts
);
8287 /* Field 4, the address, is omitted (which makes the columns not
8288 line up too nicely with the headers, but the effect is relatively
8290 if (opts
.addressprint
)
8291 ui_out_field_skip (uiout
, "addr");
8293 ui_out_text (uiout
, "vfork");
8294 if (!ptid_equal (c
->forked_inferior_pid
, null_ptid
))
8296 ui_out_text (uiout
, ", process ");
8297 ui_out_field_int (uiout
, "what",
8298 ptid_get_pid (c
->forked_inferior_pid
));
8299 ui_out_spaces (uiout
, 1);
8302 if (ui_out_is_mi_like_p (uiout
))
8303 ui_out_field_string (uiout
, "catch-type", "vfork");
8306 /* Implement the "print_mention" breakpoint_ops method for vfork
8310 print_mention_catch_vfork (struct breakpoint
*b
)
8312 printf_filtered (_("Catchpoint %d (vfork)"), b
->number
);
8315 /* Implement the "print_recreate" breakpoint_ops method for vfork
8319 print_recreate_catch_vfork (struct breakpoint
*b
, struct ui_file
*fp
)
8321 fprintf_unfiltered (fp
, "catch vfork");
8322 print_recreate_thread (b
, fp
);
8325 /* The breakpoint_ops structure to be used in vfork catchpoints. */
8327 static struct breakpoint_ops catch_vfork_breakpoint_ops
;
8329 /* An instance of this type is used to represent an solib catchpoint.
8330 It includes a "struct breakpoint" as a kind of base class; users
8331 downcast to "struct breakpoint *" when needed. A breakpoint is
8332 really of this type iff its ops pointer points to
8333 CATCH_SOLIB_BREAKPOINT_OPS. */
8335 struct solib_catchpoint
8337 /* The base class. */
8338 struct breakpoint base
;
8340 /* True for "catch load", false for "catch unload". */
8341 unsigned char is_load
;
8343 /* Regular expression to match, if any. COMPILED is only valid when
8344 REGEX is non-NULL. */
8350 dtor_catch_solib (struct breakpoint
*b
)
8352 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8355 regfree (&self
->compiled
);
8356 xfree (self
->regex
);
8358 base_breakpoint_ops
.dtor (b
);
8362 insert_catch_solib (struct bp_location
*ignore
)
8368 remove_catch_solib (struct bp_location
*ignore
, enum remove_bp_reason reason
)
8374 breakpoint_hit_catch_solib (const struct bp_location
*bl
,
8375 struct address_space
*aspace
,
8377 const struct target_waitstatus
*ws
)
8379 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) bl
->owner
;
8380 struct breakpoint
*other
;
8382 if (ws
->kind
== TARGET_WAITKIND_LOADED
)
8385 ALL_BREAKPOINTS (other
)
8387 struct bp_location
*other_bl
;
8389 if (other
== bl
->owner
)
8392 if (other
->type
!= bp_shlib_event
)
8395 if (self
->base
.pspace
!= NULL
&& other
->pspace
!= self
->base
.pspace
)
8398 for (other_bl
= other
->loc
; other_bl
!= NULL
; other_bl
= other_bl
->next
)
8400 if (other
->ops
->breakpoint_hit (other_bl
, aspace
, bp_addr
, ws
))
8409 check_status_catch_solib (struct bpstats
*bs
)
8411 struct solib_catchpoint
*self
8412 = (struct solib_catchpoint
*) bs
->breakpoint_at
;
8417 struct so_list
*iter
;
8420 VEC_iterate (so_list_ptr
, current_program_space
->added_solibs
,
8425 || regexec (&self
->compiled
, iter
->so_name
, 0, NULL
, 0) == 0)
8434 VEC_iterate (char_ptr
, current_program_space
->deleted_solibs
,
8439 || regexec (&self
->compiled
, iter
, 0, NULL
, 0) == 0)
8445 bs
->print_it
= print_it_noop
;
8448 static enum print_stop_action
8449 print_it_catch_solib (bpstat bs
)
8451 struct breakpoint
*b
= bs
->breakpoint_at
;
8452 struct ui_out
*uiout
= current_uiout
;
8454 annotate_catchpoint (b
->number
);
8455 maybe_print_thread_hit_breakpoint (uiout
);
8456 if (b
->disposition
== disp_del
)
8457 ui_out_text (uiout
, "Temporary catchpoint ");
8459 ui_out_text (uiout
, "Catchpoint ");
8460 ui_out_field_int (uiout
, "bkptno", b
->number
);
8461 ui_out_text (uiout
, "\n");
8462 if (ui_out_is_mi_like_p (uiout
))
8463 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
8464 print_solib_event (1);
8465 return PRINT_SRC_AND_LOC
;
8469 print_one_catch_solib (struct breakpoint
*b
, struct bp_location
**locs
)
8471 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8472 struct value_print_options opts
;
8473 struct ui_out
*uiout
= current_uiout
;
8476 get_user_print_options (&opts
);
8477 /* Field 4, the address, is omitted (which makes the columns not
8478 line up too nicely with the headers, but the effect is relatively
8480 if (opts
.addressprint
)
8483 ui_out_field_skip (uiout
, "addr");
8490 msg
= xstrprintf (_("load of library matching %s"), self
->regex
);
8492 msg
= xstrdup (_("load of library"));
8497 msg
= xstrprintf (_("unload of library matching %s"), self
->regex
);
8499 msg
= xstrdup (_("unload of library"));
8501 ui_out_field_string (uiout
, "what", msg
);
8504 if (ui_out_is_mi_like_p (uiout
))
8505 ui_out_field_string (uiout
, "catch-type",
8506 self
->is_load
? "load" : "unload");
8510 print_mention_catch_solib (struct breakpoint
*b
)
8512 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8514 printf_filtered (_("Catchpoint %d (%s)"), b
->number
,
8515 self
->is_load
? "load" : "unload");
8519 print_recreate_catch_solib (struct breakpoint
*b
, struct ui_file
*fp
)
8521 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8523 fprintf_unfiltered (fp
, "%s %s",
8524 b
->disposition
== disp_del
? "tcatch" : "catch",
8525 self
->is_load
? "load" : "unload");
8527 fprintf_unfiltered (fp
, " %s", self
->regex
);
8528 fprintf_unfiltered (fp
, "\n");
8531 static struct breakpoint_ops catch_solib_breakpoint_ops
;
8533 /* Shared helper function (MI and CLI) for creating and installing
8534 a shared object event catchpoint. If IS_LOAD is non-zero then
8535 the events to be caught are load events, otherwise they are
8536 unload events. If IS_TEMP is non-zero the catchpoint is a
8537 temporary one. If ENABLED is non-zero the catchpoint is
8538 created in an enabled state. */
8541 add_solib_catchpoint (char *arg
, int is_load
, int is_temp
, int enabled
)
8543 struct solib_catchpoint
*c
;
8544 struct gdbarch
*gdbarch
= get_current_arch ();
8545 struct cleanup
*cleanup
;
8549 arg
= skip_spaces (arg
);
8551 c
= new solib_catchpoint ();
8552 cleanup
= make_cleanup (xfree
, c
);
8558 errcode
= regcomp (&c
->compiled
, arg
, REG_NOSUB
);
8561 char *err
= get_regcomp_error (errcode
, &c
->compiled
);
8563 make_cleanup (xfree
, err
);
8564 error (_("Invalid regexp (%s): %s"), err
, arg
);
8566 c
->regex
= xstrdup (arg
);
8569 c
->is_load
= is_load
;
8570 init_catchpoint (&c
->base
, gdbarch
, is_temp
, NULL
,
8571 &catch_solib_breakpoint_ops
);
8573 c
->base
.enable_state
= enabled
? bp_enabled
: bp_disabled
;
8575 discard_cleanups (cleanup
);
8576 install_breakpoint (0, &c
->base
, 1);
8579 /* A helper function that does all the work for "catch load" and
8583 catch_load_or_unload (char *arg
, int from_tty
, int is_load
,
8584 struct cmd_list_element
*command
)
8587 const int enabled
= 1;
8589 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
8591 add_solib_catchpoint (arg
, is_load
, tempflag
, enabled
);
8595 catch_load_command_1 (char *arg
, int from_tty
,
8596 struct cmd_list_element
*command
)
8598 catch_load_or_unload (arg
, from_tty
, 1, command
);
8602 catch_unload_command_1 (char *arg
, int from_tty
,
8603 struct cmd_list_element
*command
)
8605 catch_load_or_unload (arg
, from_tty
, 0, command
);
8608 /* Initialize a new breakpoint of the bp_catchpoint kind. If TEMPFLAG
8609 is non-zero, then make the breakpoint temporary. If COND_STRING is
8610 not NULL, then store it in the breakpoint. OPS, if not NULL, is
8611 the breakpoint_ops structure associated to the catchpoint. */
8614 init_catchpoint (struct breakpoint
*b
,
8615 struct gdbarch
*gdbarch
, int tempflag
,
8617 const struct breakpoint_ops
*ops
)
8619 struct symtab_and_line sal
;
8622 sal
.pspace
= current_program_space
;
8624 init_raw_breakpoint (b
, gdbarch
, sal
, bp_catchpoint
, ops
);
8626 b
->cond_string
= (cond_string
== NULL
) ? NULL
: xstrdup (cond_string
);
8627 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
8631 install_breakpoint (int internal
, struct breakpoint
*b
, int update_gll
)
8633 add_to_breakpoint_chain (b
);
8634 set_breakpoint_number (internal
, b
);
8635 if (is_tracepoint (b
))
8636 set_tracepoint_count (breakpoint_count
);
8639 observer_notify_breakpoint_created (b
);
8642 update_global_location_list (UGLL_MAY_INSERT
);
8646 create_fork_vfork_event_catchpoint (struct gdbarch
*gdbarch
,
8647 int tempflag
, char *cond_string
,
8648 const struct breakpoint_ops
*ops
)
8650 struct fork_catchpoint
*c
= new fork_catchpoint ();
8652 init_catchpoint (&c
->base
, gdbarch
, tempflag
, cond_string
, ops
);
8654 c
->forked_inferior_pid
= null_ptid
;
8656 install_breakpoint (0, &c
->base
, 1);
8659 /* Exec catchpoints. */
8661 /* An instance of this type is used to represent an exec catchpoint.
8662 It includes a "struct breakpoint" as a kind of base class; users
8663 downcast to "struct breakpoint *" when needed. A breakpoint is
8664 really of this type iff its ops pointer points to
8665 CATCH_EXEC_BREAKPOINT_OPS. */
8667 struct exec_catchpoint
8669 /* The base class. */
8670 struct breakpoint base
;
8672 /* Filename of a program whose exec triggered this catchpoint.
8673 This field is only valid immediately after this catchpoint has
8675 char *exec_pathname
;
8678 /* Implement the "dtor" breakpoint_ops method for exec
8682 dtor_catch_exec (struct breakpoint
*b
)
8684 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
8686 xfree (c
->exec_pathname
);
8688 base_breakpoint_ops
.dtor (b
);
8692 insert_catch_exec (struct bp_location
*bl
)
8694 return target_insert_exec_catchpoint (ptid_get_pid (inferior_ptid
));
8698 remove_catch_exec (struct bp_location
*bl
, enum remove_bp_reason reason
)
8700 return target_remove_exec_catchpoint (ptid_get_pid (inferior_ptid
));
8704 breakpoint_hit_catch_exec (const struct bp_location
*bl
,
8705 struct address_space
*aspace
, CORE_ADDR bp_addr
,
8706 const struct target_waitstatus
*ws
)
8708 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) bl
->owner
;
8710 if (ws
->kind
!= TARGET_WAITKIND_EXECD
)
8713 c
->exec_pathname
= xstrdup (ws
->value
.execd_pathname
);
8717 static enum print_stop_action
8718 print_it_catch_exec (bpstat bs
)
8720 struct ui_out
*uiout
= current_uiout
;
8721 struct breakpoint
*b
= bs
->breakpoint_at
;
8722 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
8724 annotate_catchpoint (b
->number
);
8725 maybe_print_thread_hit_breakpoint (uiout
);
8726 if (b
->disposition
== disp_del
)
8727 ui_out_text (uiout
, "Temporary catchpoint ");
8729 ui_out_text (uiout
, "Catchpoint ");
8730 if (ui_out_is_mi_like_p (uiout
))
8732 ui_out_field_string (uiout
, "reason",
8733 async_reason_lookup (EXEC_ASYNC_EXEC
));
8734 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
8736 ui_out_field_int (uiout
, "bkptno", b
->number
);
8737 ui_out_text (uiout
, " (exec'd ");
8738 ui_out_field_string (uiout
, "new-exec", c
->exec_pathname
);
8739 ui_out_text (uiout
, "), ");
8741 return PRINT_SRC_AND_LOC
;
8745 print_one_catch_exec (struct breakpoint
*b
, struct bp_location
**last_loc
)
8747 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
8748 struct value_print_options opts
;
8749 struct ui_out
*uiout
= current_uiout
;
8751 get_user_print_options (&opts
);
8753 /* Field 4, the address, is omitted (which makes the columns
8754 not line up too nicely with the headers, but the effect
8755 is relatively readable). */
8756 if (opts
.addressprint
)
8757 ui_out_field_skip (uiout
, "addr");
8759 ui_out_text (uiout
, "exec");
8760 if (c
->exec_pathname
!= NULL
)
8762 ui_out_text (uiout
, ", program \"");
8763 ui_out_field_string (uiout
, "what", c
->exec_pathname
);
8764 ui_out_text (uiout
, "\" ");
8767 if (ui_out_is_mi_like_p (uiout
))
8768 ui_out_field_string (uiout
, "catch-type", "exec");
8772 print_mention_catch_exec (struct breakpoint
*b
)
8774 printf_filtered (_("Catchpoint %d (exec)"), b
->number
);
8777 /* Implement the "print_recreate" breakpoint_ops method for exec
8781 print_recreate_catch_exec (struct breakpoint
*b
, struct ui_file
*fp
)
8783 fprintf_unfiltered (fp
, "catch exec");
8784 print_recreate_thread (b
, fp
);
8787 static struct breakpoint_ops catch_exec_breakpoint_ops
;
8790 hw_breakpoint_used_count (void)
8793 struct breakpoint
*b
;
8794 struct bp_location
*bl
;
8798 if (b
->type
== bp_hardware_breakpoint
&& breakpoint_enabled (b
))
8799 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
8801 /* Special types of hardware breakpoints may use more than
8803 i
+= b
->ops
->resources_needed (bl
);
8810 /* Returns the resources B would use if it were a hardware
8814 hw_watchpoint_use_count (struct breakpoint
*b
)
8817 struct bp_location
*bl
;
8819 if (!breakpoint_enabled (b
))
8822 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
8824 /* Special types of hardware watchpoints may use more than
8826 i
+= b
->ops
->resources_needed (bl
);
8832 /* Returns the sum the used resources of all hardware watchpoints of
8833 type TYPE in the breakpoints list. Also returns in OTHER_TYPE_USED
8834 the sum of the used resources of all hardware watchpoints of other
8835 types _not_ TYPE. */
8838 hw_watchpoint_used_count_others (struct breakpoint
*except
,
8839 enum bptype type
, int *other_type_used
)
8842 struct breakpoint
*b
;
8844 *other_type_used
= 0;
8849 if (!breakpoint_enabled (b
))
8852 if (b
->type
== type
)
8853 i
+= hw_watchpoint_use_count (b
);
8854 else if (is_hardware_watchpoint (b
))
8855 *other_type_used
= 1;
8862 disable_watchpoints_before_interactive_call_start (void)
8864 struct breakpoint
*b
;
8868 if (is_watchpoint (b
) && breakpoint_enabled (b
))
8870 b
->enable_state
= bp_call_disabled
;
8871 update_global_location_list (UGLL_DONT_INSERT
);
8877 enable_watchpoints_after_interactive_call_stop (void)
8879 struct breakpoint
*b
;
8883 if (is_watchpoint (b
) && b
->enable_state
== bp_call_disabled
)
8885 b
->enable_state
= bp_enabled
;
8886 update_global_location_list (UGLL_MAY_INSERT
);
8892 disable_breakpoints_before_startup (void)
8894 current_program_space
->executing_startup
= 1;
8895 update_global_location_list (UGLL_DONT_INSERT
);
8899 enable_breakpoints_after_startup (void)
8901 current_program_space
->executing_startup
= 0;
8902 breakpoint_re_set ();
8905 /* Create a new single-step breakpoint for thread THREAD, with no
8908 static struct breakpoint
*
8909 new_single_step_breakpoint (int thread
, struct gdbarch
*gdbarch
)
8911 struct breakpoint
*b
= new breakpoint ();
8913 init_raw_breakpoint_without_location (b
, gdbarch
, bp_single_step
,
8914 &momentary_breakpoint_ops
);
8916 b
->disposition
= disp_donttouch
;
8917 b
->frame_id
= null_frame_id
;
8920 gdb_assert (b
->thread
!= 0);
8922 add_to_breakpoint_chain (b
);
8927 /* Set a momentary breakpoint of type TYPE at address specified by
8928 SAL. If FRAME_ID is valid, the breakpoint is restricted to that
8932 set_momentary_breakpoint (struct gdbarch
*gdbarch
, struct symtab_and_line sal
,
8933 struct frame_id frame_id
, enum bptype type
)
8935 struct breakpoint
*b
;
8937 /* If FRAME_ID is valid, it should be a real frame, not an inlined or
8939 gdb_assert (!frame_id_artificial_p (frame_id
));
8941 b
= set_raw_breakpoint (gdbarch
, sal
, type
, &momentary_breakpoint_ops
);
8942 b
->enable_state
= bp_enabled
;
8943 b
->disposition
= disp_donttouch
;
8944 b
->frame_id
= frame_id
;
8946 /* If we're debugging a multi-threaded program, then we want
8947 momentary breakpoints to be active in only a single thread of
8949 if (in_thread_list (inferior_ptid
))
8950 b
->thread
= ptid_to_global_thread_id (inferior_ptid
);
8952 update_global_location_list_nothrow (UGLL_MAY_INSERT
);
8957 /* Make a momentary breakpoint based on the master breakpoint ORIG.
8958 The new breakpoint will have type TYPE, use OPS as its
8959 breakpoint_ops, and will set enabled to LOC_ENABLED. */
8961 static struct breakpoint
*
8962 momentary_breakpoint_from_master (struct breakpoint
*orig
,
8964 const struct breakpoint_ops
*ops
,
8967 struct breakpoint
*copy
;
8969 copy
= set_raw_breakpoint_without_location (orig
->gdbarch
, type
, ops
);
8970 copy
->loc
= allocate_bp_location (copy
);
8971 set_breakpoint_location_function (copy
->loc
, 1);
8973 copy
->loc
->gdbarch
= orig
->loc
->gdbarch
;
8974 copy
->loc
->requested_address
= orig
->loc
->requested_address
;
8975 copy
->loc
->address
= orig
->loc
->address
;
8976 copy
->loc
->section
= orig
->loc
->section
;
8977 copy
->loc
->pspace
= orig
->loc
->pspace
;
8978 copy
->loc
->probe
= orig
->loc
->probe
;
8979 copy
->loc
->line_number
= orig
->loc
->line_number
;
8980 copy
->loc
->symtab
= orig
->loc
->symtab
;
8981 copy
->loc
->enabled
= loc_enabled
;
8982 copy
->frame_id
= orig
->frame_id
;
8983 copy
->thread
= orig
->thread
;
8984 copy
->pspace
= orig
->pspace
;
8986 copy
->enable_state
= bp_enabled
;
8987 copy
->disposition
= disp_donttouch
;
8988 copy
->number
= internal_breakpoint_number
--;
8990 update_global_location_list_nothrow (UGLL_DONT_INSERT
);
8994 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
8998 clone_momentary_breakpoint (struct breakpoint
*orig
)
9000 /* If there's nothing to clone, then return nothing. */
9004 return momentary_breakpoint_from_master (orig
, orig
->type
, orig
->ops
, 0);
9008 set_momentary_breakpoint_at_pc (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
9011 struct symtab_and_line sal
;
9013 sal
= find_pc_line (pc
, 0);
9015 sal
.section
= find_pc_overlay (pc
);
9016 sal
.explicit_pc
= 1;
9018 return set_momentary_breakpoint (gdbarch
, sal
, null_frame_id
, type
);
9022 /* Tell the user we have just set a breakpoint B. */
9025 mention (struct breakpoint
*b
)
9027 b
->ops
->print_mention (b
);
9028 if (ui_out_is_mi_like_p (current_uiout
))
9030 printf_filtered ("\n");
9034 static int bp_loc_is_permanent (struct bp_location
*loc
);
9036 static struct bp_location
*
9037 add_location_to_breakpoint (struct breakpoint
*b
,
9038 const struct symtab_and_line
*sal
)
9040 struct bp_location
*loc
, **tmp
;
9041 CORE_ADDR adjusted_address
;
9042 struct gdbarch
*loc_gdbarch
= get_sal_arch (*sal
);
9044 if (loc_gdbarch
== NULL
)
9045 loc_gdbarch
= b
->gdbarch
;
9047 /* Adjust the breakpoint's address prior to allocating a location.
9048 Once we call allocate_bp_location(), that mostly uninitialized
9049 location will be placed on the location chain. Adjustment of the
9050 breakpoint may cause target_read_memory() to be called and we do
9051 not want its scan of the location chain to find a breakpoint and
9052 location that's only been partially initialized. */
9053 adjusted_address
= adjust_breakpoint_address (loc_gdbarch
,
9056 /* Sort the locations by their ADDRESS. */
9057 loc
= allocate_bp_location (b
);
9058 for (tmp
= &(b
->loc
); *tmp
!= NULL
&& (*tmp
)->address
<= adjusted_address
;
9059 tmp
= &((*tmp
)->next
))
9064 loc
->requested_address
= sal
->pc
;
9065 loc
->address
= adjusted_address
;
9066 loc
->pspace
= sal
->pspace
;
9067 loc
->probe
.probe
= sal
->probe
;
9068 loc
->probe
.objfile
= sal
->objfile
;
9069 gdb_assert (loc
->pspace
!= NULL
);
9070 loc
->section
= sal
->section
;
9071 loc
->gdbarch
= loc_gdbarch
;
9072 loc
->line_number
= sal
->line
;
9073 loc
->symtab
= sal
->symtab
;
9075 set_breakpoint_location_function (loc
,
9076 sal
->explicit_pc
|| sal
->explicit_line
);
9078 /* While by definition, permanent breakpoints are already present in the
9079 code, we don't mark the location as inserted. Normally one would expect
9080 that GDB could rely on that breakpoint instruction to stop the program,
9081 thus removing the need to insert its own breakpoint, except that executing
9082 the breakpoint instruction can kill the target instead of reporting a
9083 SIGTRAP. E.g., on SPARC, when interrupts are disabled, executing the
9084 instruction resets the CPU, so QEMU 2.0.0 for SPARC correspondingly dies
9085 with "Trap 0x02 while interrupts disabled, Error state". Letting the
9086 breakpoint be inserted normally results in QEMU knowing about the GDB
9087 breakpoint, and thus trap before the breakpoint instruction is executed.
9088 (If GDB later needs to continue execution past the permanent breakpoint,
9089 it manually increments the PC, thus avoiding executing the breakpoint
9091 if (bp_loc_is_permanent (loc
))
9098 /* See breakpoint.h. */
9101 program_breakpoint_here_p (struct gdbarch
*gdbarch
, CORE_ADDR address
)
9105 const gdb_byte
*bpoint
;
9106 gdb_byte
*target_mem
;
9107 struct cleanup
*cleanup
;
9111 bpoint
= gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &len
);
9113 /* Software breakpoints unsupported? */
9117 target_mem
= (gdb_byte
*) alloca (len
);
9119 /* Enable the automatic memory restoration from breakpoints while
9120 we read the memory. Otherwise we could say about our temporary
9121 breakpoints they are permanent. */
9122 cleanup
= make_show_memory_breakpoints_cleanup (0);
9124 if (target_read_memory (address
, target_mem
, len
) == 0
9125 && memcmp (target_mem
, bpoint
, len
) == 0)
9128 do_cleanups (cleanup
);
9133 /* Return 1 if LOC is pointing to a permanent breakpoint,
9134 return 0 otherwise. */
9137 bp_loc_is_permanent (struct bp_location
*loc
)
9139 struct cleanup
*cleanup
;
9142 gdb_assert (loc
!= NULL
);
9144 /* If we have a catchpoint or a watchpoint, just return 0. We should not
9145 attempt to read from the addresses the locations of these breakpoint types
9146 point to. program_breakpoint_here_p, below, will attempt to read
9148 if (!breakpoint_address_is_meaningful (loc
->owner
))
9151 cleanup
= save_current_space_and_thread ();
9152 switch_to_program_space_and_thread (loc
->pspace
);
9154 retval
= program_breakpoint_here_p (loc
->gdbarch
, loc
->address
);
9156 do_cleanups (cleanup
);
9161 /* Build a command list for the dprintf corresponding to the current
9162 settings of the dprintf style options. */
9165 update_dprintf_command_list (struct breakpoint
*b
)
9167 char *dprintf_args
= b
->extra_string
;
9168 char *printf_line
= NULL
;
9173 dprintf_args
= skip_spaces (dprintf_args
);
9175 /* Allow a comma, as it may have terminated a location, but don't
9177 if (*dprintf_args
== ',')
9179 dprintf_args
= skip_spaces (dprintf_args
);
9181 if (*dprintf_args
!= '"')
9182 error (_("Bad format string, missing '\"'."));
9184 if (strcmp (dprintf_style
, dprintf_style_gdb
) == 0)
9185 printf_line
= xstrprintf ("printf %s", dprintf_args
);
9186 else if (strcmp (dprintf_style
, dprintf_style_call
) == 0)
9188 if (!dprintf_function
)
9189 error (_("No function supplied for dprintf call"));
9191 if (dprintf_channel
&& strlen (dprintf_channel
) > 0)
9192 printf_line
= xstrprintf ("call (void) %s (%s,%s)",
9197 printf_line
= xstrprintf ("call (void) %s (%s)",
9201 else if (strcmp (dprintf_style
, dprintf_style_agent
) == 0)
9203 if (target_can_run_breakpoint_commands ())
9204 printf_line
= xstrprintf ("agent-printf %s", dprintf_args
);
9207 warning (_("Target cannot run dprintf commands, falling back to GDB printf"));
9208 printf_line
= xstrprintf ("printf %s", dprintf_args
);
9212 internal_error (__FILE__
, __LINE__
,
9213 _("Invalid dprintf style."));
9215 gdb_assert (printf_line
!= NULL
);
9216 /* Manufacture a printf sequence. */
9218 struct command_line
*printf_cmd_line
= XNEW (struct command_line
);
9220 printf_cmd_line
->control_type
= simple_control
;
9221 printf_cmd_line
->body_count
= 0;
9222 printf_cmd_line
->body_list
= NULL
;
9223 printf_cmd_line
->next
= NULL
;
9224 printf_cmd_line
->line
= printf_line
;
9226 breakpoint_set_commands (b
, printf_cmd_line
);
9230 /* Update all dprintf commands, making their command lists reflect
9231 current style settings. */
9234 update_dprintf_commands (char *args
, int from_tty
,
9235 struct cmd_list_element
*c
)
9237 struct breakpoint
*b
;
9241 if (b
->type
== bp_dprintf
)
9242 update_dprintf_command_list (b
);
9246 /* Create a breakpoint with SAL as location. Use LOCATION
9247 as a description of the location, and COND_STRING
9248 as condition expression. If LOCATION is NULL then create an
9249 "address location" from the address in the SAL. */
9252 init_breakpoint_sal (struct breakpoint
*b
, struct gdbarch
*gdbarch
,
9253 struct symtabs_and_lines sals
,
9254 struct event_location
*location
,
9255 char *filter
, char *cond_string
,
9257 enum bptype type
, enum bpdisp disposition
,
9258 int thread
, int task
, int ignore_count
,
9259 const struct breakpoint_ops
*ops
, int from_tty
,
9260 int enabled
, int internal
, unsigned flags
,
9261 int display_canonical
)
9265 if (type
== bp_hardware_breakpoint
)
9267 int target_resources_ok
;
9269 i
= hw_breakpoint_used_count ();
9270 target_resources_ok
=
9271 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
9273 if (target_resources_ok
== 0)
9274 error (_("No hardware breakpoint support in the target."));
9275 else if (target_resources_ok
< 0)
9276 error (_("Hardware breakpoints used exceeds limit."));
9279 gdb_assert (sals
.nelts
> 0);
9281 for (i
= 0; i
< sals
.nelts
; ++i
)
9283 struct symtab_and_line sal
= sals
.sals
[i
];
9284 struct bp_location
*loc
;
9288 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
9290 loc_gdbarch
= gdbarch
;
9292 describe_other_breakpoints (loc_gdbarch
,
9293 sal
.pspace
, sal
.pc
, sal
.section
, thread
);
9298 init_raw_breakpoint (b
, gdbarch
, sal
, type
, ops
);
9302 b
->cond_string
= cond_string
;
9303 b
->extra_string
= extra_string
;
9304 b
->ignore_count
= ignore_count
;
9305 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
9306 b
->disposition
= disposition
;
9308 if ((flags
& CREATE_BREAKPOINT_FLAGS_INSERTED
) != 0)
9309 b
->loc
->inserted
= 1;
9311 if (type
== bp_static_tracepoint
)
9313 struct tracepoint
*t
= (struct tracepoint
*) b
;
9314 struct static_tracepoint_marker marker
;
9316 if (strace_marker_p (b
))
9318 /* We already know the marker exists, otherwise, we
9319 wouldn't see a sal for it. */
9320 const char *p
= &event_location_to_string (b
->location
)[3];
9324 p
= skip_spaces_const (p
);
9326 endp
= skip_to_space_const (p
);
9328 marker_str
= savestring (p
, endp
- p
);
9329 t
->static_trace_marker_id
= marker_str
;
9331 printf_filtered (_("Probed static tracepoint "
9333 t
->static_trace_marker_id
);
9335 else if (target_static_tracepoint_marker_at (sal
.pc
, &marker
))
9337 t
->static_trace_marker_id
= xstrdup (marker
.str_id
);
9338 release_static_tracepoint_marker (&marker
);
9340 printf_filtered (_("Probed static tracepoint "
9342 t
->static_trace_marker_id
);
9345 warning (_("Couldn't determine the static "
9346 "tracepoint marker to probe"));
9353 loc
= add_location_to_breakpoint (b
, &sal
);
9354 if ((flags
& CREATE_BREAKPOINT_FLAGS_INSERTED
) != 0)
9360 const char *arg
= b
->cond_string
;
9362 loc
->cond
= parse_exp_1 (&arg
, loc
->address
,
9363 block_for_pc (loc
->address
), 0);
9365 error (_("Garbage '%s' follows condition"), arg
);
9368 /* Dynamic printf requires and uses additional arguments on the
9369 command line, otherwise it's an error. */
9370 if (type
== bp_dprintf
)
9372 if (b
->extra_string
)
9373 update_dprintf_command_list (b
);
9375 error (_("Format string required"));
9377 else if (b
->extra_string
)
9378 error (_("Garbage '%s' at end of command"), b
->extra_string
);
9381 b
->display_canonical
= display_canonical
;
9382 if (location
!= NULL
)
9383 b
->location
= location
;
9386 const char *addr_string
= NULL
;
9387 int addr_string_len
= 0;
9389 if (location
!= NULL
)
9390 addr_string
= event_location_to_string (location
);
9391 if (addr_string
!= NULL
)
9392 addr_string_len
= strlen (addr_string
);
9394 b
->location
= new_address_location (b
->loc
->address
,
9395 addr_string
, addr_string_len
);
9401 create_breakpoint_sal (struct gdbarch
*gdbarch
,
9402 struct symtabs_and_lines sals
,
9403 struct event_location
*location
,
9404 char *filter
, char *cond_string
,
9406 enum bptype type
, enum bpdisp disposition
,
9407 int thread
, int task
, int ignore_count
,
9408 const struct breakpoint_ops
*ops
, int from_tty
,
9409 int enabled
, int internal
, unsigned flags
,
9410 int display_canonical
)
9412 struct breakpoint
*b
;
9413 struct cleanup
*old_chain
;
9415 if (is_tracepoint_type (type
))
9417 struct tracepoint
*t
;
9419 t
= new tracepoint ();
9423 b
= new breakpoint ();
9425 old_chain
= make_cleanup (xfree
, b
);
9427 init_breakpoint_sal (b
, gdbarch
,
9429 filter
, cond_string
, extra_string
,
9431 thread
, task
, ignore_count
,
9433 enabled
, internal
, flags
,
9435 discard_cleanups (old_chain
);
9437 install_breakpoint (internal
, b
, 0);
9440 /* Add SALS.nelts breakpoints to the breakpoint table. For each
9441 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
9442 value. COND_STRING, if not NULL, specified the condition to be
9443 used for all breakpoints. Essentially the only case where
9444 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
9445 function. In that case, it's still not possible to specify
9446 separate conditions for different overloaded functions, so
9447 we take just a single condition string.
9449 NOTE: If the function succeeds, the caller is expected to cleanup
9450 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
9451 array contents). If the function fails (error() is called), the
9452 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
9453 COND and SALS arrays and each of those arrays contents. */
9456 create_breakpoints_sal (struct gdbarch
*gdbarch
,
9457 struct linespec_result
*canonical
,
9458 char *cond_string
, char *extra_string
,
9459 enum bptype type
, enum bpdisp disposition
,
9460 int thread
, int task
, int ignore_count
,
9461 const struct breakpoint_ops
*ops
, int from_tty
,
9462 int enabled
, int internal
, unsigned flags
)
9465 struct linespec_sals
*lsal
;
9467 if (canonical
->pre_expanded
)
9468 gdb_assert (VEC_length (linespec_sals
, canonical
->sals
) == 1);
9470 for (i
= 0; VEC_iterate (linespec_sals
, canonical
->sals
, i
, lsal
); ++i
)
9472 /* Note that 'location' can be NULL in the case of a plain
9473 'break', without arguments. */
9474 struct event_location
*location
9475 = (canonical
->location
!= NULL
9476 ? copy_event_location (canonical
->location
) : NULL
);
9477 char *filter_string
= lsal
->canonical
? xstrdup (lsal
->canonical
) : NULL
;
9478 struct cleanup
*inner
= make_cleanup_delete_event_location (location
);
9480 make_cleanup (xfree
, filter_string
);
9481 create_breakpoint_sal (gdbarch
, lsal
->sals
,
9484 cond_string
, extra_string
,
9486 thread
, task
, ignore_count
, ops
,
9487 from_tty
, enabled
, internal
, flags
,
9488 canonical
->special_display
);
9489 discard_cleanups (inner
);
9493 /* Parse LOCATION which is assumed to be a SAL specification possibly
9494 followed by conditionals. On return, SALS contains an array of SAL
9495 addresses found. LOCATION points to the end of the SAL (for
9496 linespec locations).
9498 The array and the line spec strings are allocated on the heap, it is
9499 the caller's responsibility to free them. */
9502 parse_breakpoint_sals (const struct event_location
*location
,
9503 struct linespec_result
*canonical
)
9505 struct symtab_and_line cursal
;
9507 if (event_location_type (location
) == LINESPEC_LOCATION
)
9509 const char *address
= get_linespec_location (location
);
9511 if (address
== NULL
)
9513 /* The last displayed codepoint, if it's valid, is our default
9514 breakpoint address. */
9515 if (last_displayed_sal_is_valid ())
9517 struct linespec_sals lsal
;
9518 struct symtab_and_line sal
;
9521 init_sal (&sal
); /* Initialize to zeroes. */
9522 lsal
.sals
.sals
= XNEW (struct symtab_and_line
);
9524 /* Set sal's pspace, pc, symtab, and line to the values
9525 corresponding to the last call to print_frame_info.
9526 Be sure to reinitialize LINE with NOTCURRENT == 0
9527 as the breakpoint line number is inappropriate otherwise.
9528 find_pc_line would adjust PC, re-set it back. */
9529 get_last_displayed_sal (&sal
);
9531 sal
= find_pc_line (pc
, 0);
9533 /* "break" without arguments is equivalent to "break *PC"
9534 where PC is the last displayed codepoint's address. So
9535 make sure to set sal.explicit_pc to prevent GDB from
9536 trying to expand the list of sals to include all other
9537 instances with the same symtab and line. */
9539 sal
.explicit_pc
= 1;
9541 lsal
.sals
.sals
[0] = sal
;
9542 lsal
.sals
.nelts
= 1;
9543 lsal
.canonical
= NULL
;
9545 VEC_safe_push (linespec_sals
, canonical
->sals
, &lsal
);
9549 error (_("No default breakpoint address now."));
9553 /* Force almost all breakpoints to be in terms of the
9554 current_source_symtab (which is decode_line_1's default).
9555 This should produce the results we want almost all of the
9556 time while leaving default_breakpoint_* alone.
9558 ObjC: However, don't match an Objective-C method name which
9559 may have a '+' or '-' succeeded by a '['. */
9560 cursal
= get_current_source_symtab_and_line ();
9561 if (last_displayed_sal_is_valid ())
9563 const char *address
= NULL
;
9565 if (event_location_type (location
) == LINESPEC_LOCATION
)
9566 address
= get_linespec_location (location
);
9570 && strchr ("+-", address
[0]) != NULL
9571 && address
[1] != '['))
9573 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, NULL
,
9574 get_last_displayed_symtab (),
9575 get_last_displayed_line (),
9576 canonical
, NULL
, NULL
);
9581 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, NULL
,
9582 cursal
.symtab
, cursal
.line
, canonical
, NULL
, NULL
);
9586 /* Convert each SAL into a real PC. Verify that the PC can be
9587 inserted as a breakpoint. If it can't throw an error. */
9590 breakpoint_sals_to_pc (struct symtabs_and_lines
*sals
)
9594 for (i
= 0; i
< sals
->nelts
; i
++)
9595 resolve_sal_pc (&sals
->sals
[i
]);
9598 /* Fast tracepoints may have restrictions on valid locations. For
9599 instance, a fast tracepoint using a jump instead of a trap will
9600 likely have to overwrite more bytes than a trap would, and so can
9601 only be placed where the instruction is longer than the jump, or a
9602 multi-instruction sequence does not have a jump into the middle of
9606 check_fast_tracepoint_sals (struct gdbarch
*gdbarch
,
9607 struct symtabs_and_lines
*sals
)
9610 struct symtab_and_line
*sal
;
9612 struct cleanup
*old_chain
;
9614 for (i
= 0; i
< sals
->nelts
; i
++)
9616 struct gdbarch
*sarch
;
9618 sal
= &sals
->sals
[i
];
9620 sarch
= get_sal_arch (*sal
);
9621 /* We fall back to GDBARCH if there is no architecture
9622 associated with SAL. */
9625 rslt
= gdbarch_fast_tracepoint_valid_at (sarch
, sal
->pc
, &msg
);
9626 old_chain
= make_cleanup (xfree
, msg
);
9629 error (_("May not have a fast tracepoint at %s%s"),
9630 paddress (sarch
, sal
->pc
), (msg
? msg
: ""));
9632 do_cleanups (old_chain
);
9636 /* Given TOK, a string specification of condition and thread, as
9637 accepted by the 'break' command, extract the condition
9638 string and thread number and set *COND_STRING and *THREAD.
9639 PC identifies the context at which the condition should be parsed.
9640 If no condition is found, *COND_STRING is set to NULL.
9641 If no thread is found, *THREAD is set to -1. */
9644 find_condition_and_thread (const char *tok
, CORE_ADDR pc
,
9645 char **cond_string
, int *thread
, int *task
,
9648 *cond_string
= NULL
;
9655 const char *end_tok
;
9657 const char *cond_start
= NULL
;
9658 const char *cond_end
= NULL
;
9660 tok
= skip_spaces_const (tok
);
9662 if ((*tok
== '"' || *tok
== ',') && rest
)
9664 *rest
= savestring (tok
, strlen (tok
));
9668 end_tok
= skip_to_space_const (tok
);
9670 toklen
= end_tok
- tok
;
9672 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
9674 tok
= cond_start
= end_tok
+ 1;
9675 parse_exp_1 (&tok
, pc
, block_for_pc (pc
), 0);
9677 *cond_string
= savestring (cond_start
, cond_end
- cond_start
);
9679 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
9682 struct thread_info
*thr
;
9685 thr
= parse_thread_id (tok
, &tmptok
);
9687 error (_("Junk after thread keyword."));
9688 *thread
= thr
->global_num
;
9691 else if (toklen
>= 1 && strncmp (tok
, "task", toklen
) == 0)
9696 *task
= strtol (tok
, &tmptok
, 0);
9698 error (_("Junk after task keyword."));
9699 if (!valid_task_id (*task
))
9700 error (_("Unknown task %d."), *task
);
9705 *rest
= savestring (tok
, strlen (tok
));
9709 error (_("Junk at end of arguments."));
9713 /* Decode a static tracepoint marker spec. */
9715 static struct symtabs_and_lines
9716 decode_static_tracepoint_spec (const char **arg_p
)
9718 VEC(static_tracepoint_marker_p
) *markers
= NULL
;
9719 struct symtabs_and_lines sals
;
9720 struct cleanup
*old_chain
;
9721 const char *p
= &(*arg_p
)[3];
9726 p
= skip_spaces_const (p
);
9728 endp
= skip_to_space_const (p
);
9730 marker_str
= savestring (p
, endp
- p
);
9731 old_chain
= make_cleanup (xfree
, marker_str
);
9733 markers
= target_static_tracepoint_markers_by_strid (marker_str
);
9734 if (VEC_empty(static_tracepoint_marker_p
, markers
))
9735 error (_("No known static tracepoint marker named %s"), marker_str
);
9737 sals
.nelts
= VEC_length(static_tracepoint_marker_p
, markers
);
9738 sals
.sals
= XNEWVEC (struct symtab_and_line
, sals
.nelts
);
9740 for (i
= 0; i
< sals
.nelts
; i
++)
9742 struct static_tracepoint_marker
*marker
;
9744 marker
= VEC_index (static_tracepoint_marker_p
, markers
, i
);
9746 init_sal (&sals
.sals
[i
]);
9748 sals
.sals
[i
] = find_pc_line (marker
->address
, 0);
9749 sals
.sals
[i
].pc
= marker
->address
;
9751 release_static_tracepoint_marker (marker
);
9754 do_cleanups (old_chain
);
9760 /* See breakpoint.h. */
9763 create_breakpoint (struct gdbarch
*gdbarch
,
9764 const struct event_location
*location
, char *cond_string
,
9765 int thread
, char *extra_string
,
9767 int tempflag
, enum bptype type_wanted
,
9769 enum auto_boolean pending_break_support
,
9770 const struct breakpoint_ops
*ops
,
9771 int from_tty
, int enabled
, int internal
,
9774 struct linespec_result canonical
;
9775 struct cleanup
*old_chain
;
9776 struct cleanup
*bkpt_chain
= NULL
;
9779 int prev_bkpt_count
= breakpoint_count
;
9781 gdb_assert (ops
!= NULL
);
9783 /* If extra_string isn't useful, set it to NULL. */
9784 if (extra_string
!= NULL
&& *extra_string
== '\0')
9785 extra_string
= NULL
;
9787 init_linespec_result (&canonical
);
9791 ops
->create_sals_from_location (location
, &canonical
, type_wanted
);
9793 CATCH (e
, RETURN_MASK_ERROR
)
9795 /* If caller is interested in rc value from parse, set
9797 if (e
.error
== NOT_FOUND_ERROR
)
9799 /* If pending breakpoint support is turned off, throw
9802 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
9803 throw_exception (e
);
9805 exception_print (gdb_stderr
, e
);
9807 /* If pending breakpoint support is auto query and the user
9808 selects no, then simply return the error code. */
9809 if (pending_break_support
== AUTO_BOOLEAN_AUTO
9810 && !nquery (_("Make %s pending on future shared library load? "),
9811 bptype_string (type_wanted
)))
9814 /* At this point, either the user was queried about setting
9815 a pending breakpoint and selected yes, or pending
9816 breakpoint behavior is on and thus a pending breakpoint
9817 is defaulted on behalf of the user. */
9821 throw_exception (e
);
9825 if (!pending
&& VEC_empty (linespec_sals
, canonical
.sals
))
9828 /* Create a chain of things that always need to be cleaned up. */
9829 old_chain
= make_cleanup_destroy_linespec_result (&canonical
);
9831 /* ----------------------------- SNIP -----------------------------
9832 Anything added to the cleanup chain beyond this point is assumed
9833 to be part of a breakpoint. If the breakpoint create succeeds
9834 then the memory is not reclaimed. */
9835 bkpt_chain
= make_cleanup (null_cleanup
, 0);
9837 /* Resolve all line numbers to PC's and verify that the addresses
9838 are ok for the target. */
9842 struct linespec_sals
*iter
;
9844 for (ix
= 0; VEC_iterate (linespec_sals
, canonical
.sals
, ix
, iter
); ++ix
)
9845 breakpoint_sals_to_pc (&iter
->sals
);
9848 /* Fast tracepoints may have additional restrictions on location. */
9849 if (!pending
&& type_wanted
== bp_fast_tracepoint
)
9852 struct linespec_sals
*iter
;
9854 for (ix
= 0; VEC_iterate (linespec_sals
, canonical
.sals
, ix
, iter
); ++ix
)
9855 check_fast_tracepoint_sals (gdbarch
, &iter
->sals
);
9858 /* Verify that condition can be parsed, before setting any
9859 breakpoints. Allocate a separate condition expression for each
9866 struct linespec_sals
*lsal
;
9868 lsal
= VEC_index (linespec_sals
, canonical
.sals
, 0);
9870 /* Here we only parse 'arg' to separate condition
9871 from thread number, so parsing in context of first
9872 sal is OK. When setting the breakpoint we'll
9873 re-parse it in context of each sal. */
9875 find_condition_and_thread (extra_string
, lsal
->sals
.sals
[0].pc
,
9876 &cond_string
, &thread
, &task
, &rest
);
9878 make_cleanup (xfree
, cond_string
);
9880 make_cleanup (xfree
, rest
);
9882 extra_string
= rest
;
9884 extra_string
= NULL
;
9888 if (type_wanted
!= bp_dprintf
9889 && extra_string
!= NULL
&& *extra_string
!= '\0')
9890 error (_("Garbage '%s' at end of location"), extra_string
);
9892 /* Create a private copy of condition string. */
9895 cond_string
= xstrdup (cond_string
);
9896 make_cleanup (xfree
, cond_string
);
9898 /* Create a private copy of any extra string. */
9901 extra_string
= xstrdup (extra_string
);
9902 make_cleanup (xfree
, extra_string
);
9906 ops
->create_breakpoints_sal (gdbarch
, &canonical
,
9907 cond_string
, extra_string
, type_wanted
,
9908 tempflag
? disp_del
: disp_donttouch
,
9909 thread
, task
, ignore_count
, ops
,
9910 from_tty
, enabled
, internal
, flags
);
9914 struct breakpoint
*b
;
9916 if (is_tracepoint_type (type_wanted
))
9918 struct tracepoint
*t
;
9920 t
= new tracepoint ();
9924 b
= new breakpoint ();
9926 init_raw_breakpoint_without_location (b
, gdbarch
, type_wanted
, ops
);
9927 b
->location
= copy_event_location (location
);
9930 b
->cond_string
= NULL
;
9933 /* Create a private copy of condition string. */
9936 cond_string
= xstrdup (cond_string
);
9937 make_cleanup (xfree
, cond_string
);
9939 b
->cond_string
= cond_string
;
9943 /* Create a private copy of any extra string. */
9944 if (extra_string
!= NULL
)
9946 extra_string
= xstrdup (extra_string
);
9947 make_cleanup (xfree
, extra_string
);
9949 b
->extra_string
= extra_string
;
9950 b
->ignore_count
= ignore_count
;
9951 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
9952 b
->condition_not_parsed
= 1;
9953 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
9954 if ((type_wanted
!= bp_breakpoint
9955 && type_wanted
!= bp_hardware_breakpoint
) || thread
!= -1)
9956 b
->pspace
= current_program_space
;
9958 install_breakpoint (internal
, b
, 0);
9961 if (VEC_length (linespec_sals
, canonical
.sals
) > 1)
9963 warning (_("Multiple breakpoints were set.\nUse the "
9964 "\"delete\" command to delete unwanted breakpoints."));
9965 prev_breakpoint_count
= prev_bkpt_count
;
9968 /* That's it. Discard the cleanups for data inserted into the
9970 discard_cleanups (bkpt_chain
);
9971 /* But cleanup everything else. */
9972 do_cleanups (old_chain
);
9974 /* error call may happen here - have BKPT_CHAIN already discarded. */
9975 update_global_location_list (UGLL_MAY_INSERT
);
9980 /* Set a breakpoint.
9981 ARG is a string describing breakpoint address,
9982 condition, and thread.
9983 FLAG specifies if a breakpoint is hardware on,
9984 and if breakpoint is temporary, using BP_HARDWARE_FLAG
9988 break_command_1 (char *arg
, int flag
, int from_tty
)
9990 int tempflag
= flag
& BP_TEMPFLAG
;
9991 enum bptype type_wanted
= (flag
& BP_HARDWAREFLAG
9992 ? bp_hardware_breakpoint
9994 struct breakpoint_ops
*ops
;
9995 struct event_location
*location
;
9996 struct cleanup
*cleanup
;
9998 location
= string_to_event_location (&arg
, current_language
);
9999 cleanup
= make_cleanup_delete_event_location (location
);
10001 /* Matching breakpoints on probes. */
10002 if (location
!= NULL
10003 && event_location_type (location
) == PROBE_LOCATION
)
10004 ops
= &bkpt_probe_breakpoint_ops
;
10006 ops
= &bkpt_breakpoint_ops
;
10008 create_breakpoint (get_current_arch (),
10010 NULL
, 0, arg
, 1 /* parse arg */,
10011 tempflag
, type_wanted
,
10012 0 /* Ignore count */,
10013 pending_break_support
,
10019 do_cleanups (cleanup
);
10022 /* Helper function for break_command_1 and disassemble_command. */
10025 resolve_sal_pc (struct symtab_and_line
*sal
)
10029 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
10031 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
10032 error (_("No line %d in file \"%s\"."),
10033 sal
->line
, symtab_to_filename_for_display (sal
->symtab
));
10036 /* If this SAL corresponds to a breakpoint inserted using a line
10037 number, then skip the function prologue if necessary. */
10038 if (sal
->explicit_line
)
10039 skip_prologue_sal (sal
);
10042 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
10044 const struct blockvector
*bv
;
10045 const struct block
*b
;
10046 struct symbol
*sym
;
10048 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
,
10049 SYMTAB_COMPUNIT (sal
->symtab
));
10052 sym
= block_linkage_function (b
);
10055 fixup_symbol_section (sym
, SYMTAB_OBJFILE (sal
->symtab
));
10056 sal
->section
= SYMBOL_OBJ_SECTION (SYMTAB_OBJFILE (sal
->symtab
),
10061 /* It really is worthwhile to have the section, so we'll
10062 just have to look harder. This case can be executed
10063 if we have line numbers but no functions (as can
10064 happen in assembly source). */
10066 struct bound_minimal_symbol msym
;
10067 struct cleanup
*old_chain
= save_current_space_and_thread ();
10069 switch_to_program_space_and_thread (sal
->pspace
);
10071 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
10073 sal
->section
= MSYMBOL_OBJ_SECTION (msym
.objfile
, msym
.minsym
);
10075 do_cleanups (old_chain
);
10082 break_command (char *arg
, int from_tty
)
10084 break_command_1 (arg
, 0, from_tty
);
10088 tbreak_command (char *arg
, int from_tty
)
10090 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
10094 hbreak_command (char *arg
, int from_tty
)
10096 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
10100 thbreak_command (char *arg
, int from_tty
)
10102 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
10106 stop_command (char *arg
, int from_tty
)
10108 printf_filtered (_("Specify the type of breakpoint to set.\n\
10109 Usage: stop in <function | address>\n\
10110 stop at <line>\n"));
10114 stopin_command (char *arg
, int from_tty
)
10118 if (arg
== (char *) NULL
)
10120 else if (*arg
!= '*')
10122 char *argptr
= arg
;
10125 /* Look for a ':'. If this is a line number specification, then
10126 say it is bad, otherwise, it should be an address or
10127 function/method name. */
10128 while (*argptr
&& !hasColon
)
10130 hasColon
= (*argptr
== ':');
10135 badInput
= (*argptr
!= ':'); /* Not a class::method */
10137 badInput
= isdigit (*arg
); /* a simple line number */
10141 printf_filtered (_("Usage: stop in <function | address>\n"));
10143 break_command_1 (arg
, 0, from_tty
);
10147 stopat_command (char *arg
, int from_tty
)
10151 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
10155 char *argptr
= arg
;
10158 /* Look for a ':'. If there is a '::' then get out, otherwise
10159 it is probably a line number. */
10160 while (*argptr
&& !hasColon
)
10162 hasColon
= (*argptr
== ':');
10167 badInput
= (*argptr
== ':'); /* we have class::method */
10169 badInput
= !isdigit (*arg
); /* not a line number */
10173 printf_filtered (_("Usage: stop at <line>\n"));
10175 break_command_1 (arg
, 0, from_tty
);
10178 /* The dynamic printf command is mostly like a regular breakpoint, but
10179 with a prewired command list consisting of a single output command,
10180 built from extra arguments supplied on the dprintf command
10184 dprintf_command (char *arg
, int from_tty
)
10186 struct event_location
*location
;
10187 struct cleanup
*cleanup
;
10189 location
= string_to_event_location (&arg
, current_language
);
10190 cleanup
= make_cleanup_delete_event_location (location
);
10192 /* If non-NULL, ARG should have been advanced past the location;
10193 the next character must be ','. */
10196 if (arg
[0] != ',' || arg
[1] == '\0')
10197 error (_("Format string required"));
10200 /* Skip the comma. */
10205 create_breakpoint (get_current_arch (),
10207 NULL
, 0, arg
, 1 /* parse arg */,
10209 0 /* Ignore count */,
10210 pending_break_support
,
10211 &dprintf_breakpoint_ops
,
10216 do_cleanups (cleanup
);
10220 agent_printf_command (char *arg
, int from_tty
)
10222 error (_("May only run agent-printf on the target"));
10225 /* Implement the "breakpoint_hit" breakpoint_ops method for
10226 ranged breakpoints. */
10229 breakpoint_hit_ranged_breakpoint (const struct bp_location
*bl
,
10230 struct address_space
*aspace
,
10232 const struct target_waitstatus
*ws
)
10234 if (ws
->kind
!= TARGET_WAITKIND_STOPPED
10235 || ws
->value
.sig
!= GDB_SIGNAL_TRAP
)
10238 return breakpoint_address_match_range (bl
->pspace
->aspace
, bl
->address
,
10239 bl
->length
, aspace
, bp_addr
);
10242 /* Implement the "resources_needed" breakpoint_ops method for
10243 ranged breakpoints. */
10246 resources_needed_ranged_breakpoint (const struct bp_location
*bl
)
10248 return target_ranged_break_num_registers ();
10251 /* Implement the "print_it" breakpoint_ops method for
10252 ranged breakpoints. */
10254 static enum print_stop_action
10255 print_it_ranged_breakpoint (bpstat bs
)
10257 struct breakpoint
*b
= bs
->breakpoint_at
;
10258 struct bp_location
*bl
= b
->loc
;
10259 struct ui_out
*uiout
= current_uiout
;
10261 gdb_assert (b
->type
== bp_hardware_breakpoint
);
10263 /* Ranged breakpoints have only one location. */
10264 gdb_assert (bl
&& bl
->next
== NULL
);
10266 annotate_breakpoint (b
->number
);
10268 maybe_print_thread_hit_breakpoint (uiout
);
10270 if (b
->disposition
== disp_del
)
10271 ui_out_text (uiout
, "Temporary ranged breakpoint ");
10273 ui_out_text (uiout
, "Ranged breakpoint ");
10274 if (ui_out_is_mi_like_p (uiout
))
10276 ui_out_field_string (uiout
, "reason",
10277 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
10278 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
10280 ui_out_field_int (uiout
, "bkptno", b
->number
);
10281 ui_out_text (uiout
, ", ");
10283 return PRINT_SRC_AND_LOC
;
10286 /* Implement the "print_one" breakpoint_ops method for
10287 ranged breakpoints. */
10290 print_one_ranged_breakpoint (struct breakpoint
*b
,
10291 struct bp_location
**last_loc
)
10293 struct bp_location
*bl
= b
->loc
;
10294 struct value_print_options opts
;
10295 struct ui_out
*uiout
= current_uiout
;
10297 /* Ranged breakpoints have only one location. */
10298 gdb_assert (bl
&& bl
->next
== NULL
);
10300 get_user_print_options (&opts
);
10302 if (opts
.addressprint
)
10303 /* We don't print the address range here, it will be printed later
10304 by print_one_detail_ranged_breakpoint. */
10305 ui_out_field_skip (uiout
, "addr");
10306 annotate_field (5);
10307 print_breakpoint_location (b
, bl
);
10311 /* Implement the "print_one_detail" breakpoint_ops method for
10312 ranged breakpoints. */
10315 print_one_detail_ranged_breakpoint (const struct breakpoint
*b
,
10316 struct ui_out
*uiout
)
10318 CORE_ADDR address_start
, address_end
;
10319 struct bp_location
*bl
= b
->loc
;
10320 struct ui_file
*stb
= mem_fileopen ();
10321 struct cleanup
*cleanup
= make_cleanup_ui_file_delete (stb
);
10325 address_start
= bl
->address
;
10326 address_end
= address_start
+ bl
->length
- 1;
10328 ui_out_text (uiout
, "\taddress range: ");
10329 fprintf_unfiltered (stb
, "[%s, %s]",
10330 print_core_address (bl
->gdbarch
, address_start
),
10331 print_core_address (bl
->gdbarch
, address_end
));
10332 ui_out_field_stream (uiout
, "addr", stb
);
10333 ui_out_text (uiout
, "\n");
10335 do_cleanups (cleanup
);
10338 /* Implement the "print_mention" breakpoint_ops method for
10339 ranged breakpoints. */
10342 print_mention_ranged_breakpoint (struct breakpoint
*b
)
10344 struct bp_location
*bl
= b
->loc
;
10345 struct ui_out
*uiout
= current_uiout
;
10348 gdb_assert (b
->type
== bp_hardware_breakpoint
);
10350 if (ui_out_is_mi_like_p (uiout
))
10353 printf_filtered (_("Hardware assisted ranged breakpoint %d from %s to %s."),
10354 b
->number
, paddress (bl
->gdbarch
, bl
->address
),
10355 paddress (bl
->gdbarch
, bl
->address
+ bl
->length
- 1));
10358 /* Implement the "print_recreate" breakpoint_ops method for
10359 ranged breakpoints. */
10362 print_recreate_ranged_breakpoint (struct breakpoint
*b
, struct ui_file
*fp
)
10364 fprintf_unfiltered (fp
, "break-range %s, %s",
10365 event_location_to_string (b
->location
),
10366 event_location_to_string (b
->location_range_end
));
10367 print_recreate_thread (b
, fp
);
10370 /* The breakpoint_ops structure to be used in ranged breakpoints. */
10372 static struct breakpoint_ops ranged_breakpoint_ops
;
10374 /* Find the address where the end of the breakpoint range should be
10375 placed, given the SAL of the end of the range. This is so that if
10376 the user provides a line number, the end of the range is set to the
10377 last instruction of the given line. */
10380 find_breakpoint_range_end (struct symtab_and_line sal
)
10384 /* If the user provided a PC value, use it. Otherwise,
10385 find the address of the end of the given location. */
10386 if (sal
.explicit_pc
)
10393 ret
= find_line_pc_range (sal
, &start
, &end
);
10395 error (_("Could not find location of the end of the range."));
10397 /* find_line_pc_range returns the start of the next line. */
10404 /* Implement the "break-range" CLI command. */
10407 break_range_command (char *arg
, int from_tty
)
10409 char *arg_start
, *addr_string_start
;
10410 struct linespec_result canonical_start
, canonical_end
;
10411 int bp_count
, can_use_bp
, length
;
10413 struct breakpoint
*b
;
10414 struct symtab_and_line sal_start
, sal_end
;
10415 struct cleanup
*cleanup_bkpt
;
10416 struct linespec_sals
*lsal_start
, *lsal_end
;
10417 struct event_location
*start_location
, *end_location
;
10419 /* We don't support software ranged breakpoints. */
10420 if (target_ranged_break_num_registers () < 0)
10421 error (_("This target does not support hardware ranged breakpoints."));
10423 bp_count
= hw_breakpoint_used_count ();
10424 bp_count
+= target_ranged_break_num_registers ();
10425 can_use_bp
= target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
10427 if (can_use_bp
< 0)
10428 error (_("Hardware breakpoints used exceeds limit."));
10430 arg
= skip_spaces (arg
);
10431 if (arg
== NULL
|| arg
[0] == '\0')
10432 error(_("No address range specified."));
10434 init_linespec_result (&canonical_start
);
10437 start_location
= string_to_event_location (&arg
, current_language
);
10438 cleanup_bkpt
= make_cleanup_delete_event_location (start_location
);
10439 parse_breakpoint_sals (start_location
, &canonical_start
);
10440 make_cleanup_destroy_linespec_result (&canonical_start
);
10443 error (_("Too few arguments."));
10444 else if (VEC_empty (linespec_sals
, canonical_start
.sals
))
10445 error (_("Could not find location of the beginning of the range."));
10447 lsal_start
= VEC_index (linespec_sals
, canonical_start
.sals
, 0);
10449 if (VEC_length (linespec_sals
, canonical_start
.sals
) > 1
10450 || lsal_start
->sals
.nelts
!= 1)
10451 error (_("Cannot create a ranged breakpoint with multiple locations."));
10453 sal_start
= lsal_start
->sals
.sals
[0];
10454 addr_string_start
= savestring (arg_start
, arg
- arg_start
);
10455 make_cleanup (xfree
, addr_string_start
);
10457 arg
++; /* Skip the comma. */
10458 arg
= skip_spaces (arg
);
10460 /* Parse the end location. */
10462 init_linespec_result (&canonical_end
);
10465 /* We call decode_line_full directly here instead of using
10466 parse_breakpoint_sals because we need to specify the start location's
10467 symtab and line as the default symtab and line for the end of the
10468 range. This makes it possible to have ranges like "foo.c:27, +14",
10469 where +14 means 14 lines from the start location. */
10470 end_location
= string_to_event_location (&arg
, current_language
);
10471 make_cleanup_delete_event_location (end_location
);
10472 decode_line_full (end_location
, DECODE_LINE_FUNFIRSTLINE
, NULL
,
10473 sal_start
.symtab
, sal_start
.line
,
10474 &canonical_end
, NULL
, NULL
);
10476 make_cleanup_destroy_linespec_result (&canonical_end
);
10478 if (VEC_empty (linespec_sals
, canonical_end
.sals
))
10479 error (_("Could not find location of the end of the range."));
10481 lsal_end
= VEC_index (linespec_sals
, canonical_end
.sals
, 0);
10482 if (VEC_length (linespec_sals
, canonical_end
.sals
) > 1
10483 || lsal_end
->sals
.nelts
!= 1)
10484 error (_("Cannot create a ranged breakpoint with multiple locations."));
10486 sal_end
= lsal_end
->sals
.sals
[0];
10488 end
= find_breakpoint_range_end (sal_end
);
10489 if (sal_start
.pc
> end
)
10490 error (_("Invalid address range, end precedes start."));
10492 length
= end
- sal_start
.pc
+ 1;
10494 /* Length overflowed. */
10495 error (_("Address range too large."));
10496 else if (length
== 1)
10498 /* This range is simple enough to be handled by
10499 the `hbreak' command. */
10500 hbreak_command (addr_string_start
, 1);
10502 do_cleanups (cleanup_bkpt
);
10507 /* Now set up the breakpoint. */
10508 b
= set_raw_breakpoint (get_current_arch (), sal_start
,
10509 bp_hardware_breakpoint
, &ranged_breakpoint_ops
);
10510 set_breakpoint_count (breakpoint_count
+ 1);
10511 b
->number
= breakpoint_count
;
10512 b
->disposition
= disp_donttouch
;
10513 b
->location
= copy_event_location (start_location
);
10514 b
->location_range_end
= copy_event_location (end_location
);
10515 b
->loc
->length
= length
;
10517 do_cleanups (cleanup_bkpt
);
10520 observer_notify_breakpoint_created (b
);
10521 update_global_location_list (UGLL_MAY_INSERT
);
10524 /* Return non-zero if EXP is verified as constant. Returned zero
10525 means EXP is variable. Also the constant detection may fail for
10526 some constant expressions and in such case still falsely return
10530 watchpoint_exp_is_const (const struct expression
*exp
)
10532 int i
= exp
->nelts
;
10538 /* We are only interested in the descriptor of each element. */
10539 operator_length (exp
, i
, &oplenp
, &argsp
);
10542 switch (exp
->elts
[i
].opcode
)
10552 case BINOP_LOGICAL_AND
:
10553 case BINOP_LOGICAL_OR
:
10554 case BINOP_BITWISE_AND
:
10555 case BINOP_BITWISE_IOR
:
10556 case BINOP_BITWISE_XOR
:
10558 case BINOP_NOTEQUAL
:
10585 case OP_OBJC_NSSTRING
:
10588 case UNOP_LOGICAL_NOT
:
10589 case UNOP_COMPLEMENT
:
10594 case UNOP_CAST_TYPE
:
10595 case UNOP_REINTERPRET_CAST
:
10596 case UNOP_DYNAMIC_CAST
:
10597 /* Unary, binary and ternary operators: We have to check
10598 their operands. If they are constant, then so is the
10599 result of that operation. For instance, if A and B are
10600 determined to be constants, then so is "A + B".
10602 UNOP_IND is one exception to the rule above, because the
10603 value of *ADDR is not necessarily a constant, even when
10608 /* Check whether the associated symbol is a constant.
10610 We use SYMBOL_CLASS rather than TYPE_CONST because it's
10611 possible that a buggy compiler could mark a variable as
10612 constant even when it is not, and TYPE_CONST would return
10613 true in this case, while SYMBOL_CLASS wouldn't.
10615 We also have to check for function symbols because they
10616 are always constant. */
10618 struct symbol
*s
= exp
->elts
[i
+ 2].symbol
;
10620 if (SYMBOL_CLASS (s
) != LOC_BLOCK
10621 && SYMBOL_CLASS (s
) != LOC_CONST
10622 && SYMBOL_CLASS (s
) != LOC_CONST_BYTES
)
10627 /* The default action is to return 0 because we are using
10628 the optimistic approach here: If we don't know something,
10629 then it is not a constant. */
10638 /* Implement the "dtor" breakpoint_ops method for watchpoints. */
10641 dtor_watchpoint (struct breakpoint
*self
)
10643 struct watchpoint
*w
= (struct watchpoint
*) self
;
10645 xfree (w
->exp_string
);
10646 xfree (w
->exp_string_reparse
);
10647 value_free (w
->val
);
10649 base_breakpoint_ops
.dtor (self
);
10652 /* Implement the "re_set" breakpoint_ops method for watchpoints. */
10655 re_set_watchpoint (struct breakpoint
*b
)
10657 struct watchpoint
*w
= (struct watchpoint
*) b
;
10659 /* Watchpoint can be either on expression using entirely global
10660 variables, or it can be on local variables.
10662 Watchpoints of the first kind are never auto-deleted, and even
10663 persist across program restarts. Since they can use variables
10664 from shared libraries, we need to reparse expression as libraries
10665 are loaded and unloaded.
10667 Watchpoints on local variables can also change meaning as result
10668 of solib event. For example, if a watchpoint uses both a local
10669 and a global variables in expression, it's a local watchpoint,
10670 but unloading of a shared library will make the expression
10671 invalid. This is not a very common use case, but we still
10672 re-evaluate expression, to avoid surprises to the user.
10674 Note that for local watchpoints, we re-evaluate it only if
10675 watchpoints frame id is still valid. If it's not, it means the
10676 watchpoint is out of scope and will be deleted soon. In fact,
10677 I'm not sure we'll ever be called in this case.
10679 If a local watchpoint's frame id is still valid, then
10680 w->exp_valid_block is likewise valid, and we can safely use it.
10682 Don't do anything about disabled watchpoints, since they will be
10683 reevaluated again when enabled. */
10684 update_watchpoint (w
, 1 /* reparse */);
10687 /* Implement the "insert" breakpoint_ops method for hardware watchpoints. */
10690 insert_watchpoint (struct bp_location
*bl
)
10692 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10693 int length
= w
->exact
? 1 : bl
->length
;
10695 return target_insert_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
10696 w
->cond_exp
.get ());
10699 /* Implement the "remove" breakpoint_ops method for hardware watchpoints. */
10702 remove_watchpoint (struct bp_location
*bl
, enum remove_bp_reason reason
)
10704 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10705 int length
= w
->exact
? 1 : bl
->length
;
10707 return target_remove_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
10708 w
->cond_exp
.get ());
10712 breakpoint_hit_watchpoint (const struct bp_location
*bl
,
10713 struct address_space
*aspace
, CORE_ADDR bp_addr
,
10714 const struct target_waitstatus
*ws
)
10716 struct breakpoint
*b
= bl
->owner
;
10717 struct watchpoint
*w
= (struct watchpoint
*) b
;
10719 /* Continuable hardware watchpoints are treated as non-existent if the
10720 reason we stopped wasn't a hardware watchpoint (we didn't stop on
10721 some data address). Otherwise gdb won't stop on a break instruction
10722 in the code (not from a breakpoint) when a hardware watchpoint has
10723 been defined. Also skip watchpoints which we know did not trigger
10724 (did not match the data address). */
10725 if (is_hardware_watchpoint (b
)
10726 && w
->watchpoint_triggered
== watch_triggered_no
)
10733 check_status_watchpoint (bpstat bs
)
10735 gdb_assert (is_watchpoint (bs
->breakpoint_at
));
10737 bpstat_check_watchpoint (bs
);
10740 /* Implement the "resources_needed" breakpoint_ops method for
10741 hardware watchpoints. */
10744 resources_needed_watchpoint (const struct bp_location
*bl
)
10746 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10747 int length
= w
->exact
? 1 : bl
->length
;
10749 return target_region_ok_for_hw_watchpoint (bl
->address
, length
);
10752 /* Implement the "works_in_software_mode" breakpoint_ops method for
10753 hardware watchpoints. */
10756 works_in_software_mode_watchpoint (const struct breakpoint
*b
)
10758 /* Read and access watchpoints only work with hardware support. */
10759 return b
->type
== bp_watchpoint
|| b
->type
== bp_hardware_watchpoint
;
10762 static enum print_stop_action
10763 print_it_watchpoint (bpstat bs
)
10765 struct cleanup
*old_chain
;
10766 struct breakpoint
*b
;
10767 struct ui_file
*stb
;
10768 enum print_stop_action result
;
10769 struct watchpoint
*w
;
10770 struct ui_out
*uiout
= current_uiout
;
10772 gdb_assert (bs
->bp_location_at
!= NULL
);
10774 b
= bs
->breakpoint_at
;
10775 w
= (struct watchpoint
*) b
;
10777 stb
= mem_fileopen ();
10778 old_chain
= make_cleanup_ui_file_delete (stb
);
10780 annotate_watchpoint (b
->number
);
10781 maybe_print_thread_hit_breakpoint (uiout
);
10785 case bp_watchpoint
:
10786 case bp_hardware_watchpoint
:
10787 if (ui_out_is_mi_like_p (uiout
))
10788 ui_out_field_string
10790 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
10792 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
10793 ui_out_text (uiout
, "\nOld value = ");
10794 watchpoint_value_print (bs
->old_val
, stb
);
10795 ui_out_field_stream (uiout
, "old", stb
);
10796 ui_out_text (uiout
, "\nNew value = ");
10797 watchpoint_value_print (w
->val
, stb
);
10798 ui_out_field_stream (uiout
, "new", stb
);
10799 ui_out_text (uiout
, "\n");
10800 /* More than one watchpoint may have been triggered. */
10801 result
= PRINT_UNKNOWN
;
10804 case bp_read_watchpoint
:
10805 if (ui_out_is_mi_like_p (uiout
))
10806 ui_out_field_string
10808 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
10810 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
10811 ui_out_text (uiout
, "\nValue = ");
10812 watchpoint_value_print (w
->val
, stb
);
10813 ui_out_field_stream (uiout
, "value", stb
);
10814 ui_out_text (uiout
, "\n");
10815 result
= PRINT_UNKNOWN
;
10818 case bp_access_watchpoint
:
10819 if (bs
->old_val
!= NULL
)
10821 if (ui_out_is_mi_like_p (uiout
))
10822 ui_out_field_string
10824 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
10826 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
10827 ui_out_text (uiout
, "\nOld value = ");
10828 watchpoint_value_print (bs
->old_val
, stb
);
10829 ui_out_field_stream (uiout
, "old", stb
);
10830 ui_out_text (uiout
, "\nNew value = ");
10835 if (ui_out_is_mi_like_p (uiout
))
10836 ui_out_field_string
10838 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
10839 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
10840 ui_out_text (uiout
, "\nValue = ");
10842 watchpoint_value_print (w
->val
, stb
);
10843 ui_out_field_stream (uiout
, "new", stb
);
10844 ui_out_text (uiout
, "\n");
10845 result
= PRINT_UNKNOWN
;
10848 result
= PRINT_UNKNOWN
;
10851 do_cleanups (old_chain
);
10855 /* Implement the "print_mention" breakpoint_ops method for hardware
10859 print_mention_watchpoint (struct breakpoint
*b
)
10861 struct cleanup
*ui_out_chain
;
10862 struct watchpoint
*w
= (struct watchpoint
*) b
;
10863 struct ui_out
*uiout
= current_uiout
;
10867 case bp_watchpoint
:
10868 ui_out_text (uiout
, "Watchpoint ");
10869 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
10871 case bp_hardware_watchpoint
:
10872 ui_out_text (uiout
, "Hardware watchpoint ");
10873 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
10875 case bp_read_watchpoint
:
10876 ui_out_text (uiout
, "Hardware read watchpoint ");
10877 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
10879 case bp_access_watchpoint
:
10880 ui_out_text (uiout
, "Hardware access (read/write) watchpoint ");
10881 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
10884 internal_error (__FILE__
, __LINE__
,
10885 _("Invalid hardware watchpoint type."));
10888 ui_out_field_int (uiout
, "number", b
->number
);
10889 ui_out_text (uiout
, ": ");
10890 ui_out_field_string (uiout
, "exp", w
->exp_string
);
10891 do_cleanups (ui_out_chain
);
10894 /* Implement the "print_recreate" breakpoint_ops method for
10898 print_recreate_watchpoint (struct breakpoint
*b
, struct ui_file
*fp
)
10900 struct watchpoint
*w
= (struct watchpoint
*) b
;
10904 case bp_watchpoint
:
10905 case bp_hardware_watchpoint
:
10906 fprintf_unfiltered (fp
, "watch");
10908 case bp_read_watchpoint
:
10909 fprintf_unfiltered (fp
, "rwatch");
10911 case bp_access_watchpoint
:
10912 fprintf_unfiltered (fp
, "awatch");
10915 internal_error (__FILE__
, __LINE__
,
10916 _("Invalid watchpoint type."));
10919 fprintf_unfiltered (fp
, " %s", w
->exp_string
);
10920 print_recreate_thread (b
, fp
);
10923 /* Implement the "explains_signal" breakpoint_ops method for
10927 explains_signal_watchpoint (struct breakpoint
*b
, enum gdb_signal sig
)
10929 /* A software watchpoint cannot cause a signal other than
10930 GDB_SIGNAL_TRAP. */
10931 if (b
->type
== bp_watchpoint
&& sig
!= GDB_SIGNAL_TRAP
)
10937 /* The breakpoint_ops structure to be used in hardware watchpoints. */
10939 static struct breakpoint_ops watchpoint_breakpoint_ops
;
10941 /* Implement the "insert" breakpoint_ops method for
10942 masked hardware watchpoints. */
10945 insert_masked_watchpoint (struct bp_location
*bl
)
10947 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10949 return target_insert_mask_watchpoint (bl
->address
, w
->hw_wp_mask
,
10950 bl
->watchpoint_type
);
10953 /* Implement the "remove" breakpoint_ops method for
10954 masked hardware watchpoints. */
10957 remove_masked_watchpoint (struct bp_location
*bl
, enum remove_bp_reason reason
)
10959 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10961 return target_remove_mask_watchpoint (bl
->address
, w
->hw_wp_mask
,
10962 bl
->watchpoint_type
);
10965 /* Implement the "resources_needed" breakpoint_ops method for
10966 masked hardware watchpoints. */
10969 resources_needed_masked_watchpoint (const struct bp_location
*bl
)
10971 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10973 return target_masked_watch_num_registers (bl
->address
, w
->hw_wp_mask
);
10976 /* Implement the "works_in_software_mode" breakpoint_ops method for
10977 masked hardware watchpoints. */
10980 works_in_software_mode_masked_watchpoint (const struct breakpoint
*b
)
10985 /* Implement the "print_it" breakpoint_ops method for
10986 masked hardware watchpoints. */
10988 static enum print_stop_action
10989 print_it_masked_watchpoint (bpstat bs
)
10991 struct breakpoint
*b
= bs
->breakpoint_at
;
10992 struct ui_out
*uiout
= current_uiout
;
10994 /* Masked watchpoints have only one location. */
10995 gdb_assert (b
->loc
&& b
->loc
->next
== NULL
);
10997 annotate_watchpoint (b
->number
);
10998 maybe_print_thread_hit_breakpoint (uiout
);
11002 case bp_hardware_watchpoint
:
11003 if (ui_out_is_mi_like_p (uiout
))
11004 ui_out_field_string
11006 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
11009 case bp_read_watchpoint
:
11010 if (ui_out_is_mi_like_p (uiout
))
11011 ui_out_field_string
11013 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
11016 case bp_access_watchpoint
:
11017 if (ui_out_is_mi_like_p (uiout
))
11018 ui_out_field_string
11020 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
11023 internal_error (__FILE__
, __LINE__
,
11024 _("Invalid hardware watchpoint type."));
11028 ui_out_text (uiout
, _("\n\
11029 Check the underlying instruction at PC for the memory\n\
11030 address and value which triggered this watchpoint.\n"));
11031 ui_out_text (uiout
, "\n");
11033 /* More than one watchpoint may have been triggered. */
11034 return PRINT_UNKNOWN
;
11037 /* Implement the "print_one_detail" breakpoint_ops method for
11038 masked hardware watchpoints. */
11041 print_one_detail_masked_watchpoint (const struct breakpoint
*b
,
11042 struct ui_out
*uiout
)
11044 struct watchpoint
*w
= (struct watchpoint
*) b
;
11046 /* Masked watchpoints have only one location. */
11047 gdb_assert (b
->loc
&& b
->loc
->next
== NULL
);
11049 ui_out_text (uiout
, "\tmask ");
11050 ui_out_field_core_addr (uiout
, "mask", b
->loc
->gdbarch
, w
->hw_wp_mask
);
11051 ui_out_text (uiout
, "\n");
11054 /* Implement the "print_mention" breakpoint_ops method for
11055 masked hardware watchpoints. */
11058 print_mention_masked_watchpoint (struct breakpoint
*b
)
11060 struct watchpoint
*w
= (struct watchpoint
*) b
;
11061 struct ui_out
*uiout
= current_uiout
;
11062 struct cleanup
*ui_out_chain
;
11066 case bp_hardware_watchpoint
:
11067 ui_out_text (uiout
, "Masked hardware watchpoint ");
11068 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
11070 case bp_read_watchpoint
:
11071 ui_out_text (uiout
, "Masked hardware read watchpoint ");
11072 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
11074 case bp_access_watchpoint
:
11075 ui_out_text (uiout
, "Masked hardware access (read/write) watchpoint ");
11076 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
11079 internal_error (__FILE__
, __LINE__
,
11080 _("Invalid hardware watchpoint type."));
11083 ui_out_field_int (uiout
, "number", b
->number
);
11084 ui_out_text (uiout
, ": ");
11085 ui_out_field_string (uiout
, "exp", w
->exp_string
);
11086 do_cleanups (ui_out_chain
);
11089 /* Implement the "print_recreate" breakpoint_ops method for
11090 masked hardware watchpoints. */
11093 print_recreate_masked_watchpoint (struct breakpoint
*b
, struct ui_file
*fp
)
11095 struct watchpoint
*w
= (struct watchpoint
*) b
;
11100 case bp_hardware_watchpoint
:
11101 fprintf_unfiltered (fp
, "watch");
11103 case bp_read_watchpoint
:
11104 fprintf_unfiltered (fp
, "rwatch");
11106 case bp_access_watchpoint
:
11107 fprintf_unfiltered (fp
, "awatch");
11110 internal_error (__FILE__
, __LINE__
,
11111 _("Invalid hardware watchpoint type."));
11114 sprintf_vma (tmp
, w
->hw_wp_mask
);
11115 fprintf_unfiltered (fp
, " %s mask 0x%s", w
->exp_string
, tmp
);
11116 print_recreate_thread (b
, fp
);
11119 /* The breakpoint_ops structure to be used in masked hardware watchpoints. */
11121 static struct breakpoint_ops masked_watchpoint_breakpoint_ops
;
11123 /* Tell whether the given watchpoint is a masked hardware watchpoint. */
11126 is_masked_watchpoint (const struct breakpoint
*b
)
11128 return b
->ops
== &masked_watchpoint_breakpoint_ops
;
11131 /* accessflag: hw_write: watch write,
11132 hw_read: watch read,
11133 hw_access: watch access (read or write) */
11135 watch_command_1 (const char *arg
, int accessflag
, int from_tty
,
11136 int just_location
, int internal
)
11138 struct breakpoint
*b
, *scope_breakpoint
= NULL
;
11139 const struct block
*exp_valid_block
= NULL
, *cond_exp_valid_block
= NULL
;
11140 struct value
*val
, *mark
, *result
;
11141 int saved_bitpos
= 0, saved_bitsize
= 0;
11142 struct frame_info
*frame
;
11143 const char *exp_start
= NULL
;
11144 const char *exp_end
= NULL
;
11145 const char *tok
, *end_tok
;
11147 const char *cond_start
= NULL
;
11148 const char *cond_end
= NULL
;
11149 enum bptype bp_type
;
11152 /* Flag to indicate whether we are going to use masks for
11153 the hardware watchpoint. */
11155 CORE_ADDR mask
= 0;
11156 struct watchpoint
*w
;
11158 struct cleanup
*back_to
;
11160 /* Make sure that we actually have parameters to parse. */
11161 if (arg
!= NULL
&& arg
[0] != '\0')
11163 const char *value_start
;
11165 exp_end
= arg
+ strlen (arg
);
11167 /* Look for "parameter value" pairs at the end
11168 of the arguments string. */
11169 for (tok
= exp_end
- 1; tok
> arg
; tok
--)
11171 /* Skip whitespace at the end of the argument list. */
11172 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
11175 /* Find the beginning of the last token.
11176 This is the value of the parameter. */
11177 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
11179 value_start
= tok
+ 1;
11181 /* Skip whitespace. */
11182 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
11187 /* Find the beginning of the second to last token.
11188 This is the parameter itself. */
11189 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
11192 toklen
= end_tok
- tok
+ 1;
11194 if (toklen
== 6 && startswith (tok
, "thread"))
11196 struct thread_info
*thr
;
11197 /* At this point we've found a "thread" token, which means
11198 the user is trying to set a watchpoint that triggers
11199 only in a specific thread. */
11203 error(_("You can specify only one thread."));
11205 /* Extract the thread ID from the next token. */
11206 thr
= parse_thread_id (value_start
, &endp
);
11208 /* Check if the user provided a valid thread ID. */
11209 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
11210 invalid_thread_id_error (value_start
);
11212 thread
= thr
->global_num
;
11214 else if (toklen
== 4 && startswith (tok
, "mask"))
11216 /* We've found a "mask" token, which means the user wants to
11217 create a hardware watchpoint that is going to have the mask
11219 struct value
*mask_value
, *mark
;
11222 error(_("You can specify only one mask."));
11224 use_mask
= just_location
= 1;
11226 mark
= value_mark ();
11227 mask_value
= parse_to_comma_and_eval (&value_start
);
11228 mask
= value_as_address (mask_value
);
11229 value_free_to_mark (mark
);
11232 /* We didn't recognize what we found. We should stop here. */
11235 /* Truncate the string and get rid of the "parameter value" pair before
11236 the arguments string is parsed by the parse_exp_1 function. */
11243 /* Parse the rest of the arguments. From here on out, everything
11244 is in terms of a newly allocated string instead of the original
11246 innermost_block
= NULL
;
11247 expression
= savestring (arg
, exp_end
- arg
);
11248 back_to
= make_cleanup (xfree
, expression
);
11249 exp_start
= arg
= expression
;
11250 expression_up exp
= parse_exp_1 (&arg
, 0, 0, 0);
11252 /* Remove trailing whitespace from the expression before saving it.
11253 This makes the eventual display of the expression string a bit
11255 while (exp_end
> exp_start
&& (exp_end
[-1] == ' ' || exp_end
[-1] == '\t'))
11258 /* Checking if the expression is not constant. */
11259 if (watchpoint_exp_is_const (exp
.get ()))
11263 len
= exp_end
- exp_start
;
11264 while (len
> 0 && isspace (exp_start
[len
- 1]))
11266 error (_("Cannot watch constant value `%.*s'."), len
, exp_start
);
11269 exp_valid_block
= innermost_block
;
11270 mark
= value_mark ();
11271 fetch_subexp_value (exp
.get (), &pc
, &val
, &result
, NULL
, just_location
);
11273 if (val
!= NULL
&& just_location
)
11275 saved_bitpos
= value_bitpos (val
);
11276 saved_bitsize
= value_bitsize (val
);
11283 exp_valid_block
= NULL
;
11284 val
= value_addr (result
);
11285 release_value (val
);
11286 value_free_to_mark (mark
);
11290 ret
= target_masked_watch_num_registers (value_as_address (val
),
11293 error (_("This target does not support masked watchpoints."));
11294 else if (ret
== -2)
11295 error (_("Invalid mask or memory region."));
11298 else if (val
!= NULL
)
11299 release_value (val
);
11301 tok
= skip_spaces_const (arg
);
11302 end_tok
= skip_to_space_const (tok
);
11304 toklen
= end_tok
- tok
;
11305 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
11307 innermost_block
= NULL
;
11308 tok
= cond_start
= end_tok
+ 1;
11309 parse_exp_1 (&tok
, 0, 0, 0);
11311 /* The watchpoint expression may not be local, but the condition
11312 may still be. E.g.: `watch global if local > 0'. */
11313 cond_exp_valid_block
= innermost_block
;
11318 error (_("Junk at end of command."));
11320 frame
= block_innermost_frame (exp_valid_block
);
11322 /* If the expression is "local", then set up a "watchpoint scope"
11323 breakpoint at the point where we've left the scope of the watchpoint
11324 expression. Create the scope breakpoint before the watchpoint, so
11325 that we will encounter it first in bpstat_stop_status. */
11326 if (exp_valid_block
&& frame
)
11328 if (frame_id_p (frame_unwind_caller_id (frame
)))
11331 = create_internal_breakpoint (frame_unwind_caller_arch (frame
),
11332 frame_unwind_caller_pc (frame
),
11333 bp_watchpoint_scope
,
11334 &momentary_breakpoint_ops
);
11336 scope_breakpoint
->enable_state
= bp_enabled
;
11338 /* Automatically delete the breakpoint when it hits. */
11339 scope_breakpoint
->disposition
= disp_del
;
11341 /* Only break in the proper frame (help with recursion). */
11342 scope_breakpoint
->frame_id
= frame_unwind_caller_id (frame
);
11344 /* Set the address at which we will stop. */
11345 scope_breakpoint
->loc
->gdbarch
11346 = frame_unwind_caller_arch (frame
);
11347 scope_breakpoint
->loc
->requested_address
11348 = frame_unwind_caller_pc (frame
);
11349 scope_breakpoint
->loc
->address
11350 = adjust_breakpoint_address (scope_breakpoint
->loc
->gdbarch
,
11351 scope_breakpoint
->loc
->requested_address
,
11352 scope_breakpoint
->type
);
11356 /* Now set up the breakpoint. We create all watchpoints as hardware
11357 watchpoints here even if hardware watchpoints are turned off, a call
11358 to update_watchpoint later in this function will cause the type to
11359 drop back to bp_watchpoint (software watchpoint) if required. */
11361 if (accessflag
== hw_read
)
11362 bp_type
= bp_read_watchpoint
;
11363 else if (accessflag
== hw_access
)
11364 bp_type
= bp_access_watchpoint
;
11366 bp_type
= bp_hardware_watchpoint
;
11368 w
= new watchpoint ();
11371 init_raw_breakpoint_without_location (b
, NULL
, bp_type
,
11372 &masked_watchpoint_breakpoint_ops
);
11374 init_raw_breakpoint_without_location (b
, NULL
, bp_type
,
11375 &watchpoint_breakpoint_ops
);
11376 b
->thread
= thread
;
11377 b
->disposition
= disp_donttouch
;
11378 b
->pspace
= current_program_space
;
11379 w
->exp
= gdb::move (exp
);
11380 w
->exp_valid_block
= exp_valid_block
;
11381 w
->cond_exp_valid_block
= cond_exp_valid_block
;
11384 struct type
*t
= value_type (val
);
11385 CORE_ADDR addr
= value_as_address (val
);
11387 t
= check_typedef (TYPE_TARGET_TYPE (check_typedef (t
)));
11389 std::string name
= type_to_string (t
);
11391 w
->exp_string_reparse
= xstrprintf ("* (%s *) %s", name
.c_str (),
11392 core_addr_to_string (addr
));
11394 w
->exp_string
= xstrprintf ("-location %.*s",
11395 (int) (exp_end
- exp_start
), exp_start
);
11397 /* The above expression is in C. */
11398 b
->language
= language_c
;
11401 w
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
11405 w
->hw_wp_mask
= mask
;
11410 w
->val_bitpos
= saved_bitpos
;
11411 w
->val_bitsize
= saved_bitsize
;
11416 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
11418 b
->cond_string
= 0;
11422 w
->watchpoint_frame
= get_frame_id (frame
);
11423 w
->watchpoint_thread
= inferior_ptid
;
11427 w
->watchpoint_frame
= null_frame_id
;
11428 w
->watchpoint_thread
= null_ptid
;
11431 if (scope_breakpoint
!= NULL
)
11433 /* The scope breakpoint is related to the watchpoint. We will
11434 need to act on them together. */
11435 b
->related_breakpoint
= scope_breakpoint
;
11436 scope_breakpoint
->related_breakpoint
= b
;
11439 if (!just_location
)
11440 value_free_to_mark (mark
);
11444 /* Finally update the new watchpoint. This creates the locations
11445 that should be inserted. */
11446 update_watchpoint (w
, 1);
11448 CATCH (e
, RETURN_MASK_ALL
)
11450 delete_breakpoint (b
);
11451 throw_exception (e
);
11455 install_breakpoint (internal
, b
, 1);
11456 do_cleanups (back_to
);
11459 /* Return count of debug registers needed to watch the given expression.
11460 If the watchpoint cannot be handled in hardware return zero. */
11463 can_use_hardware_watchpoint (struct value
*v
)
11465 int found_memory_cnt
= 0;
11466 struct value
*head
= v
;
11468 /* Did the user specifically forbid us to use hardware watchpoints? */
11469 if (!can_use_hw_watchpoints
)
11472 /* Make sure that the value of the expression depends only upon
11473 memory contents, and values computed from them within GDB. If we
11474 find any register references or function calls, we can't use a
11475 hardware watchpoint.
11477 The idea here is that evaluating an expression generates a series
11478 of values, one holding the value of every subexpression. (The
11479 expression a*b+c has five subexpressions: a, b, a*b, c, and
11480 a*b+c.) GDB's values hold almost enough information to establish
11481 the criteria given above --- they identify memory lvalues,
11482 register lvalues, computed values, etcetera. So we can evaluate
11483 the expression, and then scan the chain of values that leaves
11484 behind to decide whether we can detect any possible change to the
11485 expression's final value using only hardware watchpoints.
11487 However, I don't think that the values returned by inferior
11488 function calls are special in any way. So this function may not
11489 notice that an expression involving an inferior function call
11490 can't be watched with hardware watchpoints. FIXME. */
11491 for (; v
; v
= value_next (v
))
11493 if (VALUE_LVAL (v
) == lval_memory
)
11495 if (v
!= head
&& value_lazy (v
))
11496 /* A lazy memory lvalue in the chain is one that GDB never
11497 needed to fetch; we either just used its address (e.g.,
11498 `a' in `a.b') or we never needed it at all (e.g., `a'
11499 in `a,b'). This doesn't apply to HEAD; if that is
11500 lazy then it was not readable, but watch it anyway. */
11504 /* Ahh, memory we actually used! Check if we can cover
11505 it with hardware watchpoints. */
11506 struct type
*vtype
= check_typedef (value_type (v
));
11508 /* We only watch structs and arrays if user asked for it
11509 explicitly, never if they just happen to appear in a
11510 middle of some value chain. */
11512 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
11513 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
11515 CORE_ADDR vaddr
= value_address (v
);
11519 len
= (target_exact_watchpoints
11520 && is_scalar_type_recursive (vtype
))?
11521 1 : TYPE_LENGTH (value_type (v
));
11523 num_regs
= target_region_ok_for_hw_watchpoint (vaddr
, len
);
11527 found_memory_cnt
+= num_regs
;
11531 else if (VALUE_LVAL (v
) != not_lval
11532 && deprecated_value_modifiable (v
) == 0)
11533 return 0; /* These are values from the history (e.g., $1). */
11534 else if (VALUE_LVAL (v
) == lval_register
)
11535 return 0; /* Cannot watch a register with a HW watchpoint. */
11538 /* The expression itself looks suitable for using a hardware
11539 watchpoint, but give the target machine a chance to reject it. */
11540 return found_memory_cnt
;
11544 watch_command_wrapper (char *arg
, int from_tty
, int internal
)
11546 watch_command_1 (arg
, hw_write
, from_tty
, 0, internal
);
11549 /* A helper function that looks for the "-location" argument and then
11550 calls watch_command_1. */
11553 watch_maybe_just_location (char *arg
, int accessflag
, int from_tty
)
11555 int just_location
= 0;
11558 && (check_for_argument (&arg
, "-location", sizeof ("-location") - 1)
11559 || check_for_argument (&arg
, "-l", sizeof ("-l") - 1)))
11561 arg
= skip_spaces (arg
);
11565 watch_command_1 (arg
, accessflag
, from_tty
, just_location
, 0);
11569 watch_command (char *arg
, int from_tty
)
11571 watch_maybe_just_location (arg
, hw_write
, from_tty
);
11575 rwatch_command_wrapper (char *arg
, int from_tty
, int internal
)
11577 watch_command_1 (arg
, hw_read
, from_tty
, 0, internal
);
11581 rwatch_command (char *arg
, int from_tty
)
11583 watch_maybe_just_location (arg
, hw_read
, from_tty
);
11587 awatch_command_wrapper (char *arg
, int from_tty
, int internal
)
11589 watch_command_1 (arg
, hw_access
, from_tty
, 0, internal
);
11593 awatch_command (char *arg
, int from_tty
)
11595 watch_maybe_just_location (arg
, hw_access
, from_tty
);
11599 /* Data for the FSM that manages the until(location)/advance commands
11600 in infcmd.c. Here because it uses the mechanisms of
11603 struct until_break_fsm
11605 /* The base class. */
11606 struct thread_fsm thread_fsm
;
11608 /* The thread that as current when the command was executed. */
11611 /* The breakpoint set at the destination location. */
11612 struct breakpoint
*location_breakpoint
;
11614 /* Breakpoint set at the return address in the caller frame. May be
11616 struct breakpoint
*caller_breakpoint
;
11619 static void until_break_fsm_clean_up (struct thread_fsm
*self
,
11620 struct thread_info
*thread
);
11621 static int until_break_fsm_should_stop (struct thread_fsm
*self
,
11622 struct thread_info
*thread
);
11623 static enum async_reply_reason
11624 until_break_fsm_async_reply_reason (struct thread_fsm
*self
);
11626 /* until_break_fsm's vtable. */
11628 static struct thread_fsm_ops until_break_fsm_ops
=
11631 until_break_fsm_clean_up
,
11632 until_break_fsm_should_stop
,
11633 NULL
, /* return_value */
11634 until_break_fsm_async_reply_reason
,
11637 /* Allocate a new until_break_command_fsm. */
11639 static struct until_break_fsm
*
11640 new_until_break_fsm (struct interp
*cmd_interp
, int thread
,
11641 struct breakpoint
*location_breakpoint
,
11642 struct breakpoint
*caller_breakpoint
)
11644 struct until_break_fsm
*sm
;
11646 sm
= XCNEW (struct until_break_fsm
);
11647 thread_fsm_ctor (&sm
->thread_fsm
, &until_break_fsm_ops
, cmd_interp
);
11649 sm
->thread
= thread
;
11650 sm
->location_breakpoint
= location_breakpoint
;
11651 sm
->caller_breakpoint
= caller_breakpoint
;
11656 /* Implementation of the 'should_stop' FSM method for the
11657 until(location)/advance commands. */
11660 until_break_fsm_should_stop (struct thread_fsm
*self
,
11661 struct thread_info
*tp
)
11663 struct until_break_fsm
*sm
= (struct until_break_fsm
*) self
;
11665 if (bpstat_find_breakpoint (tp
->control
.stop_bpstat
,
11666 sm
->location_breakpoint
) != NULL
11667 || (sm
->caller_breakpoint
!= NULL
11668 && bpstat_find_breakpoint (tp
->control
.stop_bpstat
,
11669 sm
->caller_breakpoint
) != NULL
))
11670 thread_fsm_set_finished (self
);
11675 /* Implementation of the 'clean_up' FSM method for the
11676 until(location)/advance commands. */
11679 until_break_fsm_clean_up (struct thread_fsm
*self
,
11680 struct thread_info
*thread
)
11682 struct until_break_fsm
*sm
= (struct until_break_fsm
*) self
;
11684 /* Clean up our temporary breakpoints. */
11685 if (sm
->location_breakpoint
!= NULL
)
11687 delete_breakpoint (sm
->location_breakpoint
);
11688 sm
->location_breakpoint
= NULL
;
11690 if (sm
->caller_breakpoint
!= NULL
)
11692 delete_breakpoint (sm
->caller_breakpoint
);
11693 sm
->caller_breakpoint
= NULL
;
11695 delete_longjmp_breakpoint (sm
->thread
);
11698 /* Implementation of the 'async_reply_reason' FSM method for the
11699 until(location)/advance commands. */
11701 static enum async_reply_reason
11702 until_break_fsm_async_reply_reason (struct thread_fsm
*self
)
11704 return EXEC_ASYNC_LOCATION_REACHED
;
11708 until_break_command (char *arg
, int from_tty
, int anywhere
)
11710 struct symtabs_and_lines sals
;
11711 struct symtab_and_line sal
;
11712 struct frame_info
*frame
;
11713 struct gdbarch
*frame_gdbarch
;
11714 struct frame_id stack_frame_id
;
11715 struct frame_id caller_frame_id
;
11716 struct breakpoint
*location_breakpoint
;
11717 struct breakpoint
*caller_breakpoint
= NULL
;
11718 struct cleanup
*old_chain
, *cleanup
;
11720 struct thread_info
*tp
;
11721 struct event_location
*location
;
11722 struct until_break_fsm
*sm
;
11724 clear_proceed_status (0);
11726 /* Set a breakpoint where the user wants it and at return from
11729 location
= string_to_event_location (&arg
, current_language
);
11730 cleanup
= make_cleanup_delete_event_location (location
);
11732 if (last_displayed_sal_is_valid ())
11733 sals
= decode_line_1 (location
, DECODE_LINE_FUNFIRSTLINE
, NULL
,
11734 get_last_displayed_symtab (),
11735 get_last_displayed_line ());
11737 sals
= decode_line_1 (location
, DECODE_LINE_FUNFIRSTLINE
,
11738 NULL
, (struct symtab
*) NULL
, 0);
11740 if (sals
.nelts
!= 1)
11741 error (_("Couldn't get information on specified line."));
11743 sal
= sals
.sals
[0];
11744 xfree (sals
.sals
); /* malloc'd, so freed. */
11747 error (_("Junk at end of arguments."));
11749 resolve_sal_pc (&sal
);
11751 tp
= inferior_thread ();
11752 thread
= tp
->global_num
;
11754 old_chain
= make_cleanup (null_cleanup
, NULL
);
11756 /* Note linespec handling above invalidates the frame chain.
11757 Installing a breakpoint also invalidates the frame chain (as it
11758 may need to switch threads), so do any frame handling before
11761 frame
= get_selected_frame (NULL
);
11762 frame_gdbarch
= get_frame_arch (frame
);
11763 stack_frame_id
= get_stack_frame_id (frame
);
11764 caller_frame_id
= frame_unwind_caller_id (frame
);
11766 /* Keep within the current frame, or in frames called by the current
11769 if (frame_id_p (caller_frame_id
))
11771 struct symtab_and_line sal2
;
11772 struct gdbarch
*caller_gdbarch
;
11774 sal2
= find_pc_line (frame_unwind_caller_pc (frame
), 0);
11775 sal2
.pc
= frame_unwind_caller_pc (frame
);
11776 caller_gdbarch
= frame_unwind_caller_arch (frame
);
11777 caller_breakpoint
= set_momentary_breakpoint (caller_gdbarch
,
11781 make_cleanup_delete_breakpoint (caller_breakpoint
);
11783 set_longjmp_breakpoint (tp
, caller_frame_id
);
11784 make_cleanup (delete_longjmp_breakpoint_cleanup
, &thread
);
11787 /* set_momentary_breakpoint could invalidate FRAME. */
11791 /* If the user told us to continue until a specified location,
11792 we don't specify a frame at which we need to stop. */
11793 location_breakpoint
= set_momentary_breakpoint (frame_gdbarch
, sal
,
11794 null_frame_id
, bp_until
);
11796 /* Otherwise, specify the selected frame, because we want to stop
11797 only at the very same frame. */
11798 location_breakpoint
= set_momentary_breakpoint (frame_gdbarch
, sal
,
11799 stack_frame_id
, bp_until
);
11800 make_cleanup_delete_breakpoint (location_breakpoint
);
11802 sm
= new_until_break_fsm (command_interp (), tp
->global_num
,
11803 location_breakpoint
, caller_breakpoint
);
11804 tp
->thread_fsm
= &sm
->thread_fsm
;
11806 discard_cleanups (old_chain
);
11808 proceed (-1, GDB_SIGNAL_DEFAULT
);
11810 do_cleanups (cleanup
);
11813 /* This function attempts to parse an optional "if <cond>" clause
11814 from the arg string. If one is not found, it returns NULL.
11816 Else, it returns a pointer to the condition string. (It does not
11817 attempt to evaluate the string against a particular block.) And,
11818 it updates arg to point to the first character following the parsed
11819 if clause in the arg string. */
11822 ep_parse_optional_if_clause (char **arg
)
11826 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
11829 /* Skip the "if" keyword. */
11832 /* Skip any extra leading whitespace, and record the start of the
11833 condition string. */
11834 *arg
= skip_spaces (*arg
);
11835 cond_string
= *arg
;
11837 /* Assume that the condition occupies the remainder of the arg
11839 (*arg
) += strlen (cond_string
);
11841 return cond_string
;
11844 /* Commands to deal with catching events, such as signals, exceptions,
11845 process start/exit, etc. */
11849 catch_fork_temporary
, catch_vfork_temporary
,
11850 catch_fork_permanent
, catch_vfork_permanent
11855 catch_fork_command_1 (char *arg
, int from_tty
,
11856 struct cmd_list_element
*command
)
11858 struct gdbarch
*gdbarch
= get_current_arch ();
11859 char *cond_string
= NULL
;
11860 catch_fork_kind fork_kind
;
11863 fork_kind
= (catch_fork_kind
) (uintptr_t) get_cmd_context (command
);
11864 tempflag
= (fork_kind
== catch_fork_temporary
11865 || fork_kind
== catch_vfork_temporary
);
11869 arg
= skip_spaces (arg
);
11871 /* The allowed syntax is:
11873 catch [v]fork if <cond>
11875 First, check if there's an if clause. */
11876 cond_string
= ep_parse_optional_if_clause (&arg
);
11878 if ((*arg
!= '\0') && !isspace (*arg
))
11879 error (_("Junk at end of arguments."));
11881 /* If this target supports it, create a fork or vfork catchpoint
11882 and enable reporting of such events. */
11885 case catch_fork_temporary
:
11886 case catch_fork_permanent
:
11887 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
11888 &catch_fork_breakpoint_ops
);
11890 case catch_vfork_temporary
:
11891 case catch_vfork_permanent
:
11892 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
11893 &catch_vfork_breakpoint_ops
);
11896 error (_("unsupported or unknown fork kind; cannot catch it"));
11902 catch_exec_command_1 (char *arg
, int from_tty
,
11903 struct cmd_list_element
*command
)
11905 struct exec_catchpoint
*c
;
11906 struct gdbarch
*gdbarch
= get_current_arch ();
11908 char *cond_string
= NULL
;
11910 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
11914 arg
= skip_spaces (arg
);
11916 /* The allowed syntax is:
11918 catch exec if <cond>
11920 First, check if there's an if clause. */
11921 cond_string
= ep_parse_optional_if_clause (&arg
);
11923 if ((*arg
!= '\0') && !isspace (*arg
))
11924 error (_("Junk at end of arguments."));
11926 c
= new exec_catchpoint ();
11927 init_catchpoint (&c
->base
, gdbarch
, tempflag
, cond_string
,
11928 &catch_exec_breakpoint_ops
);
11929 c
->exec_pathname
= NULL
;
11931 install_breakpoint (0, &c
->base
, 1);
11935 init_ada_exception_breakpoint (struct breakpoint
*b
,
11936 struct gdbarch
*gdbarch
,
11937 struct symtab_and_line sal
,
11939 const struct breakpoint_ops
*ops
,
11946 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
11948 loc_gdbarch
= gdbarch
;
11950 describe_other_breakpoints (loc_gdbarch
,
11951 sal
.pspace
, sal
.pc
, sal
.section
, -1);
11952 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
11953 version for exception catchpoints, because two catchpoints
11954 used for different exception names will use the same address.
11955 In this case, a "breakpoint ... also set at..." warning is
11956 unproductive. Besides, the warning phrasing is also a bit
11957 inappropriate, we should use the word catchpoint, and tell
11958 the user what type of catchpoint it is. The above is good
11959 enough for now, though. */
11962 init_raw_breakpoint (b
, gdbarch
, sal
, bp_breakpoint
, ops
);
11964 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
11965 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
11966 b
->location
= string_to_event_location (&addr_string
,
11967 language_def (language_ada
));
11968 b
->language
= language_ada
;
11972 catch_command (char *arg
, int from_tty
)
11974 error (_("Catch requires an event name."));
11979 tcatch_command (char *arg
, int from_tty
)
11981 error (_("Catch requires an event name."));
11984 /* A qsort comparison function that sorts breakpoints in order. */
11987 compare_breakpoints (const void *a
, const void *b
)
11989 const breakpoint_p
*ba
= (const breakpoint_p
*) a
;
11990 uintptr_t ua
= (uintptr_t) *ba
;
11991 const breakpoint_p
*bb
= (const breakpoint_p
*) b
;
11992 uintptr_t ub
= (uintptr_t) *bb
;
11994 if ((*ba
)->number
< (*bb
)->number
)
11996 else if ((*ba
)->number
> (*bb
)->number
)
11999 /* Now sort by address, in case we see, e..g, two breakpoints with
12003 return ua
> ub
? 1 : 0;
12006 /* Delete breakpoints by address or line. */
12009 clear_command (char *arg
, int from_tty
)
12011 struct breakpoint
*b
, *prev
;
12012 VEC(breakpoint_p
) *found
= 0;
12015 struct symtabs_and_lines sals
;
12016 struct symtab_and_line sal
;
12018 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
12022 sals
= decode_line_with_current_source (arg
,
12023 (DECODE_LINE_FUNFIRSTLINE
12024 | DECODE_LINE_LIST_MODE
));
12025 make_cleanup (xfree
, sals
.sals
);
12030 sals
.sals
= XNEW (struct symtab_and_line
);
12031 make_cleanup (xfree
, sals
.sals
);
12032 init_sal (&sal
); /* Initialize to zeroes. */
12034 /* Set sal's line, symtab, pc, and pspace to the values
12035 corresponding to the last call to print_frame_info. If the
12036 codepoint is not valid, this will set all the fields to 0. */
12037 get_last_displayed_sal (&sal
);
12038 if (sal
.symtab
== 0)
12039 error (_("No source file specified."));
12041 sals
.sals
[0] = sal
;
12047 /* We don't call resolve_sal_pc here. That's not as bad as it
12048 seems, because all existing breakpoints typically have both
12049 file/line and pc set. So, if clear is given file/line, we can
12050 match this to existing breakpoint without obtaining pc at all.
12052 We only support clearing given the address explicitly
12053 present in breakpoint table. Say, we've set breakpoint
12054 at file:line. There were several PC values for that file:line,
12055 due to optimization, all in one block.
12057 We've picked one PC value. If "clear" is issued with another
12058 PC corresponding to the same file:line, the breakpoint won't
12059 be cleared. We probably can still clear the breakpoint, but
12060 since the other PC value is never presented to user, user
12061 can only find it by guessing, and it does not seem important
12062 to support that. */
12064 /* For each line spec given, delete bps which correspond to it. Do
12065 it in two passes, solely to preserve the current behavior that
12066 from_tty is forced true if we delete more than one
12070 make_cleanup (VEC_cleanup (breakpoint_p
), &found
);
12071 for (i
= 0; i
< sals
.nelts
; i
++)
12073 const char *sal_fullname
;
12075 /* If exact pc given, clear bpts at that pc.
12076 If line given (pc == 0), clear all bpts on specified line.
12077 If defaulting, clear all bpts on default line
12080 defaulting sal.pc != 0 tests to do
12085 1 0 <can't happen> */
12087 sal
= sals
.sals
[i
];
12088 sal_fullname
= (sal
.symtab
== NULL
12089 ? NULL
: symtab_to_fullname (sal
.symtab
));
12091 /* Find all matching breakpoints and add them to 'found'. */
12092 ALL_BREAKPOINTS (b
)
12095 /* Are we going to delete b? */
12096 if (b
->type
!= bp_none
&& !is_watchpoint (b
))
12098 struct bp_location
*loc
= b
->loc
;
12099 for (; loc
; loc
= loc
->next
)
12101 /* If the user specified file:line, don't allow a PC
12102 match. This matches historical gdb behavior. */
12103 int pc_match
= (!sal
.explicit_line
12105 && (loc
->pspace
== sal
.pspace
)
12106 && (loc
->address
== sal
.pc
)
12107 && (!section_is_overlay (loc
->section
)
12108 || loc
->section
== sal
.section
));
12109 int line_match
= 0;
12111 if ((default_match
|| sal
.explicit_line
)
12112 && loc
->symtab
!= NULL
12113 && sal_fullname
!= NULL
12114 && sal
.pspace
== loc
->pspace
12115 && loc
->line_number
== sal
.line
12116 && filename_cmp (symtab_to_fullname (loc
->symtab
),
12117 sal_fullname
) == 0)
12120 if (pc_match
|| line_match
)
12129 VEC_safe_push(breakpoint_p
, found
, b
);
12133 /* Now go thru the 'found' chain and delete them. */
12134 if (VEC_empty(breakpoint_p
, found
))
12137 error (_("No breakpoint at %s."), arg
);
12139 error (_("No breakpoint at this line."));
12142 /* Remove duplicates from the vec. */
12143 qsort (VEC_address (breakpoint_p
, found
),
12144 VEC_length (breakpoint_p
, found
),
12145 sizeof (breakpoint_p
),
12146 compare_breakpoints
);
12147 prev
= VEC_index (breakpoint_p
, found
, 0);
12148 for (ix
= 1; VEC_iterate (breakpoint_p
, found
, ix
, b
); ++ix
)
12152 VEC_ordered_remove (breakpoint_p
, found
, ix
);
12157 if (VEC_length(breakpoint_p
, found
) > 1)
12158 from_tty
= 1; /* Always report if deleted more than one. */
12161 if (VEC_length(breakpoint_p
, found
) == 1)
12162 printf_unfiltered (_("Deleted breakpoint "));
12164 printf_unfiltered (_("Deleted breakpoints "));
12167 for (ix
= 0; VEC_iterate(breakpoint_p
, found
, ix
, b
); ix
++)
12170 printf_unfiltered ("%d ", b
->number
);
12171 delete_breakpoint (b
);
12174 putchar_unfiltered ('\n');
12176 do_cleanups (cleanups
);
12179 /* Delete breakpoint in BS if they are `delete' breakpoints and
12180 all breakpoints that are marked for deletion, whether hit or not.
12181 This is called after any breakpoint is hit, or after errors. */
12184 breakpoint_auto_delete (bpstat bs
)
12186 struct breakpoint
*b
, *b_tmp
;
12188 for (; bs
; bs
= bs
->next
)
12189 if (bs
->breakpoint_at
12190 && bs
->breakpoint_at
->disposition
== disp_del
12192 delete_breakpoint (bs
->breakpoint_at
);
12194 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
12196 if (b
->disposition
== disp_del_at_next_stop
)
12197 delete_breakpoint (b
);
12201 /* A comparison function for bp_location AP and BP being interfaced to
12202 qsort. Sort elements primarily by their ADDRESS (no matter what
12203 does breakpoint_address_is_meaningful say for its OWNER),
12204 secondarily by ordering first permanent elements and
12205 terciarily just ensuring the array is sorted stable way despite
12206 qsort being an unstable algorithm. */
12209 bp_location_compare (const void *ap
, const void *bp
)
12211 const struct bp_location
*a
= *(const struct bp_location
**) ap
;
12212 const struct bp_location
*b
= *(const struct bp_location
**) bp
;
12214 if (a
->address
!= b
->address
)
12215 return (a
->address
> b
->address
) - (a
->address
< b
->address
);
12217 /* Sort locations at the same address by their pspace number, keeping
12218 locations of the same inferior (in a multi-inferior environment)
12221 if (a
->pspace
->num
!= b
->pspace
->num
)
12222 return ((a
->pspace
->num
> b
->pspace
->num
)
12223 - (a
->pspace
->num
< b
->pspace
->num
));
12225 /* Sort permanent breakpoints first. */
12226 if (a
->permanent
!= b
->permanent
)
12227 return (a
->permanent
< b
->permanent
) - (a
->permanent
> b
->permanent
);
12229 /* Make the internal GDB representation stable across GDB runs
12230 where A and B memory inside GDB can differ. Breakpoint locations of
12231 the same type at the same address can be sorted in arbitrary order. */
12233 if (a
->owner
->number
!= b
->owner
->number
)
12234 return ((a
->owner
->number
> b
->owner
->number
)
12235 - (a
->owner
->number
< b
->owner
->number
));
12237 return (a
> b
) - (a
< b
);
12240 /* Set bp_location_placed_address_before_address_max and
12241 bp_location_shadow_len_after_address_max according to the current
12242 content of the bp_location array. */
12245 bp_location_target_extensions_update (void)
12247 struct bp_location
*bl
, **blp_tmp
;
12249 bp_location_placed_address_before_address_max
= 0;
12250 bp_location_shadow_len_after_address_max
= 0;
12252 ALL_BP_LOCATIONS (bl
, blp_tmp
)
12254 CORE_ADDR start
, end
, addr
;
12256 if (!bp_location_has_shadow (bl
))
12259 start
= bl
->target_info
.placed_address
;
12260 end
= start
+ bl
->target_info
.shadow_len
;
12262 gdb_assert (bl
->address
>= start
);
12263 addr
= bl
->address
- start
;
12264 if (addr
> bp_location_placed_address_before_address_max
)
12265 bp_location_placed_address_before_address_max
= addr
;
12267 /* Zero SHADOW_LEN would not pass bp_location_has_shadow. */
12269 gdb_assert (bl
->address
< end
);
12270 addr
= end
- bl
->address
;
12271 if (addr
> bp_location_shadow_len_after_address_max
)
12272 bp_location_shadow_len_after_address_max
= addr
;
12276 /* Download tracepoint locations if they haven't been. */
12279 download_tracepoint_locations (void)
12281 struct breakpoint
*b
;
12282 struct cleanup
*old_chain
;
12283 enum tribool can_download_tracepoint
= TRIBOOL_UNKNOWN
;
12285 old_chain
= save_current_space_and_thread ();
12287 ALL_TRACEPOINTS (b
)
12289 struct bp_location
*bl
;
12290 struct tracepoint
*t
;
12291 int bp_location_downloaded
= 0;
12293 if ((b
->type
== bp_fast_tracepoint
12294 ? !may_insert_fast_tracepoints
12295 : !may_insert_tracepoints
))
12298 if (can_download_tracepoint
== TRIBOOL_UNKNOWN
)
12300 if (target_can_download_tracepoint ())
12301 can_download_tracepoint
= TRIBOOL_TRUE
;
12303 can_download_tracepoint
= TRIBOOL_FALSE
;
12306 if (can_download_tracepoint
== TRIBOOL_FALSE
)
12309 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
12311 /* In tracepoint, locations are _never_ duplicated, so
12312 should_be_inserted is equivalent to
12313 unduplicated_should_be_inserted. */
12314 if (!should_be_inserted (bl
) || bl
->inserted
)
12317 switch_to_program_space_and_thread (bl
->pspace
);
12319 target_download_tracepoint (bl
);
12322 bp_location_downloaded
= 1;
12324 t
= (struct tracepoint
*) b
;
12325 t
->number_on_target
= b
->number
;
12326 if (bp_location_downloaded
)
12327 observer_notify_breakpoint_modified (b
);
12330 do_cleanups (old_chain
);
12333 /* Swap the insertion/duplication state between two locations. */
12336 swap_insertion (struct bp_location
*left
, struct bp_location
*right
)
12338 const int left_inserted
= left
->inserted
;
12339 const int left_duplicate
= left
->duplicate
;
12340 const int left_needs_update
= left
->needs_update
;
12341 const struct bp_target_info left_target_info
= left
->target_info
;
12343 /* Locations of tracepoints can never be duplicated. */
12344 if (is_tracepoint (left
->owner
))
12345 gdb_assert (!left
->duplicate
);
12346 if (is_tracepoint (right
->owner
))
12347 gdb_assert (!right
->duplicate
);
12349 left
->inserted
= right
->inserted
;
12350 left
->duplicate
= right
->duplicate
;
12351 left
->needs_update
= right
->needs_update
;
12352 left
->target_info
= right
->target_info
;
12353 right
->inserted
= left_inserted
;
12354 right
->duplicate
= left_duplicate
;
12355 right
->needs_update
= left_needs_update
;
12356 right
->target_info
= left_target_info
;
12359 /* Force the re-insertion of the locations at ADDRESS. This is called
12360 once a new/deleted/modified duplicate location is found and we are evaluating
12361 conditions on the target's side. Such conditions need to be updated on
12365 force_breakpoint_reinsertion (struct bp_location
*bl
)
12367 struct bp_location
**locp
= NULL
, **loc2p
;
12368 struct bp_location
*loc
;
12369 CORE_ADDR address
= 0;
12372 address
= bl
->address
;
12373 pspace_num
= bl
->pspace
->num
;
12375 /* This is only meaningful if the target is
12376 evaluating conditions and if the user has
12377 opted for condition evaluation on the target's
12379 if (gdb_evaluates_breakpoint_condition_p ()
12380 || !target_supports_evaluation_of_breakpoint_conditions ())
12383 /* Flag all breakpoint locations with this address and
12384 the same program space as the location
12385 as "its condition has changed". We need to
12386 update the conditions on the target's side. */
12387 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, address
)
12391 if (!is_breakpoint (loc
->owner
)
12392 || pspace_num
!= loc
->pspace
->num
)
12395 /* Flag the location appropriately. We use a different state to
12396 let everyone know that we already updated the set of locations
12397 with addr bl->address and program space bl->pspace. This is so
12398 we don't have to keep calling these functions just to mark locations
12399 that have already been marked. */
12400 loc
->condition_changed
= condition_updated
;
12402 /* Free the agent expression bytecode as well. We will compute
12404 loc
->cond_bytecode
.reset ();
12407 /* Called whether new breakpoints are created, or existing breakpoints
12408 deleted, to update the global location list and recompute which
12409 locations are duplicate of which.
12411 The INSERT_MODE flag determines whether locations may not, may, or
12412 shall be inserted now. See 'enum ugll_insert_mode' for more
12416 update_global_location_list (enum ugll_insert_mode insert_mode
)
12418 struct breakpoint
*b
;
12419 struct bp_location
**locp
, *loc
;
12420 struct cleanup
*cleanups
;
12421 /* Last breakpoint location address that was marked for update. */
12422 CORE_ADDR last_addr
= 0;
12423 /* Last breakpoint location program space that was marked for update. */
12424 int last_pspace_num
= -1;
12426 /* Used in the duplicates detection below. When iterating over all
12427 bp_locations, points to the first bp_location of a given address.
12428 Breakpoints and watchpoints of different types are never
12429 duplicates of each other. Keep one pointer for each type of
12430 breakpoint/watchpoint, so we only need to loop over all locations
12432 struct bp_location
*bp_loc_first
; /* breakpoint */
12433 struct bp_location
*wp_loc_first
; /* hardware watchpoint */
12434 struct bp_location
*awp_loc_first
; /* access watchpoint */
12435 struct bp_location
*rwp_loc_first
; /* read watchpoint */
12437 /* Saved former bp_location array which we compare against the newly
12438 built bp_location from the current state of ALL_BREAKPOINTS. */
12439 struct bp_location
**old_location
, **old_locp
;
12440 unsigned old_location_count
;
12442 old_location
= bp_location
;
12443 old_location_count
= bp_location_count
;
12444 bp_location
= NULL
;
12445 bp_location_count
= 0;
12446 cleanups
= make_cleanup (xfree
, old_location
);
12448 ALL_BREAKPOINTS (b
)
12449 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
12450 bp_location_count
++;
12452 bp_location
= XNEWVEC (struct bp_location
*, bp_location_count
);
12453 locp
= bp_location
;
12454 ALL_BREAKPOINTS (b
)
12455 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
12457 qsort (bp_location
, bp_location_count
, sizeof (*bp_location
),
12458 bp_location_compare
);
12460 bp_location_target_extensions_update ();
12462 /* Identify bp_location instances that are no longer present in the
12463 new list, and therefore should be freed. Note that it's not
12464 necessary that those locations should be removed from inferior --
12465 if there's another location at the same address (previously
12466 marked as duplicate), we don't need to remove/insert the
12469 LOCP is kept in sync with OLD_LOCP, each pointing to the current
12470 and former bp_location array state respectively. */
12472 locp
= bp_location
;
12473 for (old_locp
= old_location
; old_locp
< old_location
+ old_location_count
;
12476 struct bp_location
*old_loc
= *old_locp
;
12477 struct bp_location
**loc2p
;
12479 /* Tells if 'old_loc' is found among the new locations. If
12480 not, we have to free it. */
12481 int found_object
= 0;
12482 /* Tells if the location should remain inserted in the target. */
12483 int keep_in_target
= 0;
12486 /* Skip LOCP entries which will definitely never be needed.
12487 Stop either at or being the one matching OLD_LOC. */
12488 while (locp
< bp_location
+ bp_location_count
12489 && (*locp
)->address
< old_loc
->address
)
12493 (loc2p
< bp_location
+ bp_location_count
12494 && (*loc2p
)->address
== old_loc
->address
);
12497 /* Check if this is a new/duplicated location or a duplicated
12498 location that had its condition modified. If so, we want to send
12499 its condition to the target if evaluation of conditions is taking
12501 if ((*loc2p
)->condition_changed
== condition_modified
12502 && (last_addr
!= old_loc
->address
12503 || last_pspace_num
!= old_loc
->pspace
->num
))
12505 force_breakpoint_reinsertion (*loc2p
);
12506 last_pspace_num
= old_loc
->pspace
->num
;
12509 if (*loc2p
== old_loc
)
12513 /* We have already handled this address, update it so that we don't
12514 have to go through updates again. */
12515 last_addr
= old_loc
->address
;
12517 /* Target-side condition evaluation: Handle deleted locations. */
12519 force_breakpoint_reinsertion (old_loc
);
12521 /* If this location is no longer present, and inserted, look if
12522 there's maybe a new location at the same address. If so,
12523 mark that one inserted, and don't remove this one. This is
12524 needed so that we don't have a time window where a breakpoint
12525 at certain location is not inserted. */
12527 if (old_loc
->inserted
)
12529 /* If the location is inserted now, we might have to remove
12532 if (found_object
&& should_be_inserted (old_loc
))
12534 /* The location is still present in the location list,
12535 and still should be inserted. Don't do anything. */
12536 keep_in_target
= 1;
12540 /* This location still exists, but it won't be kept in the
12541 target since it may have been disabled. We proceed to
12542 remove its target-side condition. */
12544 /* The location is either no longer present, or got
12545 disabled. See if there's another location at the
12546 same address, in which case we don't need to remove
12547 this one from the target. */
12549 /* OLD_LOC comes from existing struct breakpoint. */
12550 if (breakpoint_address_is_meaningful (old_loc
->owner
))
12553 (loc2p
< bp_location
+ bp_location_count
12554 && (*loc2p
)->address
== old_loc
->address
);
12557 struct bp_location
*loc2
= *loc2p
;
12559 if (breakpoint_locations_match (loc2
, old_loc
))
12561 /* Read watchpoint locations are switched to
12562 access watchpoints, if the former are not
12563 supported, but the latter are. */
12564 if (is_hardware_watchpoint (old_loc
->owner
))
12566 gdb_assert (is_hardware_watchpoint (loc2
->owner
));
12567 loc2
->watchpoint_type
= old_loc
->watchpoint_type
;
12570 /* loc2 is a duplicated location. We need to check
12571 if it should be inserted in case it will be
12573 if (loc2
!= old_loc
12574 && unduplicated_should_be_inserted (loc2
))
12576 swap_insertion (old_loc
, loc2
);
12577 keep_in_target
= 1;
12585 if (!keep_in_target
)
12587 if (remove_breakpoint (old_loc
))
12589 /* This is just about all we can do. We could keep
12590 this location on the global list, and try to
12591 remove it next time, but there's no particular
12592 reason why we will succeed next time.
12594 Note that at this point, old_loc->owner is still
12595 valid, as delete_breakpoint frees the breakpoint
12596 only after calling us. */
12597 printf_filtered (_("warning: Error removing "
12598 "breakpoint %d\n"),
12599 old_loc
->owner
->number
);
12607 if (removed
&& target_is_non_stop_p ()
12608 && need_moribund_for_location_type (old_loc
))
12610 /* This location was removed from the target. In
12611 non-stop mode, a race condition is possible where
12612 we've removed a breakpoint, but stop events for that
12613 breakpoint are already queued and will arrive later.
12614 We apply an heuristic to be able to distinguish such
12615 SIGTRAPs from other random SIGTRAPs: we keep this
12616 breakpoint location for a bit, and will retire it
12617 after we see some number of events. The theory here
12618 is that reporting of events should, "on the average",
12619 be fair, so after a while we'll see events from all
12620 threads that have anything of interest, and no longer
12621 need to keep this breakpoint location around. We
12622 don't hold locations forever so to reduce chances of
12623 mistaking a non-breakpoint SIGTRAP for a breakpoint
12626 The heuristic failing can be disastrous on
12627 decr_pc_after_break targets.
12629 On decr_pc_after_break targets, like e.g., x86-linux,
12630 if we fail to recognize a late breakpoint SIGTRAP,
12631 because events_till_retirement has reached 0 too
12632 soon, we'll fail to do the PC adjustment, and report
12633 a random SIGTRAP to the user. When the user resumes
12634 the inferior, it will most likely immediately crash
12635 with SIGILL/SIGBUS/SIGSEGV, or worse, get silently
12636 corrupted, because of being resumed e.g., in the
12637 middle of a multi-byte instruction, or skipped a
12638 one-byte instruction. This was actually seen happen
12639 on native x86-linux, and should be less rare on
12640 targets that do not support new thread events, like
12641 remote, due to the heuristic depending on
12644 Mistaking a random SIGTRAP for a breakpoint trap
12645 causes similar symptoms (PC adjustment applied when
12646 it shouldn't), but then again, playing with SIGTRAPs
12647 behind the debugger's back is asking for trouble.
12649 Since hardware watchpoint traps are always
12650 distinguishable from other traps, so we don't need to
12651 apply keep hardware watchpoint moribund locations
12652 around. We simply always ignore hardware watchpoint
12653 traps we can no longer explain. */
12655 old_loc
->events_till_retirement
= 3 * (thread_count () + 1);
12656 old_loc
->owner
= NULL
;
12658 VEC_safe_push (bp_location_p
, moribund_locations
, old_loc
);
12662 old_loc
->owner
= NULL
;
12663 decref_bp_location (&old_loc
);
12668 /* Rescan breakpoints at the same address and section, marking the
12669 first one as "first" and any others as "duplicates". This is so
12670 that the bpt instruction is only inserted once. If we have a
12671 permanent breakpoint at the same place as BPT, make that one the
12672 official one, and the rest as duplicates. Permanent breakpoints
12673 are sorted first for the same address.
12675 Do the same for hardware watchpoints, but also considering the
12676 watchpoint's type (regular/access/read) and length. */
12678 bp_loc_first
= NULL
;
12679 wp_loc_first
= NULL
;
12680 awp_loc_first
= NULL
;
12681 rwp_loc_first
= NULL
;
12682 ALL_BP_LOCATIONS (loc
, locp
)
12684 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always
12686 struct bp_location
**loc_first_p
;
12689 if (!unduplicated_should_be_inserted (loc
)
12690 || !breakpoint_address_is_meaningful (b
)
12691 /* Don't detect duplicate for tracepoint locations because they are
12692 never duplicated. See the comments in field `duplicate' of
12693 `struct bp_location'. */
12694 || is_tracepoint (b
))
12696 /* Clear the condition modification flag. */
12697 loc
->condition_changed
= condition_unchanged
;
12701 if (b
->type
== bp_hardware_watchpoint
)
12702 loc_first_p
= &wp_loc_first
;
12703 else if (b
->type
== bp_read_watchpoint
)
12704 loc_first_p
= &rwp_loc_first
;
12705 else if (b
->type
== bp_access_watchpoint
)
12706 loc_first_p
= &awp_loc_first
;
12708 loc_first_p
= &bp_loc_first
;
12710 if (*loc_first_p
== NULL
12711 || (overlay_debugging
&& loc
->section
!= (*loc_first_p
)->section
)
12712 || !breakpoint_locations_match (loc
, *loc_first_p
))
12714 *loc_first_p
= loc
;
12715 loc
->duplicate
= 0;
12717 if (is_breakpoint (loc
->owner
) && loc
->condition_changed
)
12719 loc
->needs_update
= 1;
12720 /* Clear the condition modification flag. */
12721 loc
->condition_changed
= condition_unchanged
;
12727 /* This and the above ensure the invariant that the first location
12728 is not duplicated, and is the inserted one.
12729 All following are marked as duplicated, and are not inserted. */
12731 swap_insertion (loc
, *loc_first_p
);
12732 loc
->duplicate
= 1;
12734 /* Clear the condition modification flag. */
12735 loc
->condition_changed
= condition_unchanged
;
12738 if (insert_mode
== UGLL_INSERT
|| breakpoints_should_be_inserted_now ())
12740 if (insert_mode
!= UGLL_DONT_INSERT
)
12741 insert_breakpoint_locations ();
12744 /* Even though the caller told us to not insert new
12745 locations, we may still need to update conditions on the
12746 target's side of breakpoints that were already inserted
12747 if the target is evaluating breakpoint conditions. We
12748 only update conditions for locations that are marked
12750 update_inserted_breakpoint_locations ();
12754 if (insert_mode
!= UGLL_DONT_INSERT
)
12755 download_tracepoint_locations ();
12757 do_cleanups (cleanups
);
12761 breakpoint_retire_moribund (void)
12763 struct bp_location
*loc
;
12766 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
12767 if (--(loc
->events_till_retirement
) == 0)
12769 decref_bp_location (&loc
);
12770 VEC_unordered_remove (bp_location_p
, moribund_locations
, ix
);
12776 update_global_location_list_nothrow (enum ugll_insert_mode insert_mode
)
12781 update_global_location_list (insert_mode
);
12783 CATCH (e
, RETURN_MASK_ERROR
)
12789 /* Clear BKP from a BPS. */
12792 bpstat_remove_bp_location (bpstat bps
, struct breakpoint
*bpt
)
12796 for (bs
= bps
; bs
; bs
= bs
->next
)
12797 if (bs
->breakpoint_at
== bpt
)
12799 bs
->breakpoint_at
= NULL
;
12800 bs
->old_val
= NULL
;
12801 /* bs->commands will be freed later. */
12805 /* Callback for iterate_over_threads. */
12807 bpstat_remove_breakpoint_callback (struct thread_info
*th
, void *data
)
12809 struct breakpoint
*bpt
= (struct breakpoint
*) data
;
12811 bpstat_remove_bp_location (th
->control
.stop_bpstat
, bpt
);
12815 /* Helper for breakpoint and tracepoint breakpoint_ops->mention
12819 say_where (struct breakpoint
*b
)
12821 struct value_print_options opts
;
12823 get_user_print_options (&opts
);
12825 /* i18n: cagney/2005-02-11: Below needs to be merged into a
12827 if (b
->loc
== NULL
)
12829 /* For pending locations, the output differs slightly based
12830 on b->extra_string. If this is non-NULL, it contains either
12831 a condition or dprintf arguments. */
12832 if (b
->extra_string
== NULL
)
12834 printf_filtered (_(" (%s) pending."),
12835 event_location_to_string (b
->location
));
12837 else if (b
->type
== bp_dprintf
)
12839 printf_filtered (_(" (%s,%s) pending."),
12840 event_location_to_string (b
->location
),
12845 printf_filtered (_(" (%s %s) pending."),
12846 event_location_to_string (b
->location
),
12852 if (opts
.addressprint
|| b
->loc
->symtab
== NULL
)
12854 printf_filtered (" at ");
12855 fputs_filtered (paddress (b
->loc
->gdbarch
, b
->loc
->address
),
12858 if (b
->loc
->symtab
!= NULL
)
12860 /* If there is a single location, we can print the location
12862 if (b
->loc
->next
== NULL
)
12863 printf_filtered (": file %s, line %d.",
12864 symtab_to_filename_for_display (b
->loc
->symtab
),
12865 b
->loc
->line_number
);
12867 /* This is not ideal, but each location may have a
12868 different file name, and this at least reflects the
12869 real situation somewhat. */
12870 printf_filtered (": %s.",
12871 event_location_to_string (b
->location
));
12876 struct bp_location
*loc
= b
->loc
;
12878 for (; loc
; loc
= loc
->next
)
12880 printf_filtered (" (%d locations)", n
);
12885 /* Default bp_location_ops methods. */
12888 bp_location_dtor (struct bp_location
*self
)
12890 xfree (self
->function_name
);
12892 VEC_free (agent_expr_p
, self
->target_info
.conditions
);
12893 VEC_free (agent_expr_p
, self
->target_info
.tcommands
);
12896 static const struct bp_location_ops bp_location_ops
=
12901 /* Default breakpoint_ops methods all breakpoint_ops ultimately
12905 base_breakpoint_dtor (struct breakpoint
*self
)
12907 decref_counted_command_line (&self
->commands
);
12908 xfree (self
->cond_string
);
12909 xfree (self
->extra_string
);
12910 xfree (self
->filter
);
12911 delete_event_location (self
->location
);
12912 delete_event_location (self
->location_range_end
);
12915 static struct bp_location
*
12916 base_breakpoint_allocate_location (struct breakpoint
*self
)
12918 struct bp_location
*loc
;
12920 loc
= new struct bp_location ();
12921 init_bp_location (loc
, &bp_location_ops
, self
);
12926 base_breakpoint_re_set (struct breakpoint
*b
)
12928 /* Nothing to re-set. */
12931 #define internal_error_pure_virtual_called() \
12932 gdb_assert_not_reached ("pure virtual function called")
12935 base_breakpoint_insert_location (struct bp_location
*bl
)
12937 internal_error_pure_virtual_called ();
12941 base_breakpoint_remove_location (struct bp_location
*bl
,
12942 enum remove_bp_reason reason
)
12944 internal_error_pure_virtual_called ();
12948 base_breakpoint_breakpoint_hit (const struct bp_location
*bl
,
12949 struct address_space
*aspace
,
12951 const struct target_waitstatus
*ws
)
12953 internal_error_pure_virtual_called ();
12957 base_breakpoint_check_status (bpstat bs
)
12962 /* A "works_in_software_mode" breakpoint_ops method that just internal
12966 base_breakpoint_works_in_software_mode (const struct breakpoint
*b
)
12968 internal_error_pure_virtual_called ();
12971 /* A "resources_needed" breakpoint_ops method that just internal
12975 base_breakpoint_resources_needed (const struct bp_location
*bl
)
12977 internal_error_pure_virtual_called ();
12980 static enum print_stop_action
12981 base_breakpoint_print_it (bpstat bs
)
12983 internal_error_pure_virtual_called ();
12987 base_breakpoint_print_one_detail (const struct breakpoint
*self
,
12988 struct ui_out
*uiout
)
12994 base_breakpoint_print_mention (struct breakpoint
*b
)
12996 internal_error_pure_virtual_called ();
13000 base_breakpoint_print_recreate (struct breakpoint
*b
, struct ui_file
*fp
)
13002 internal_error_pure_virtual_called ();
13006 base_breakpoint_create_sals_from_location
13007 (const struct event_location
*location
,
13008 struct linespec_result
*canonical
,
13009 enum bptype type_wanted
)
13011 internal_error_pure_virtual_called ();
13015 base_breakpoint_create_breakpoints_sal (struct gdbarch
*gdbarch
,
13016 struct linespec_result
*c
,
13018 char *extra_string
,
13019 enum bptype type_wanted
,
13020 enum bpdisp disposition
,
13022 int task
, int ignore_count
,
13023 const struct breakpoint_ops
*o
,
13024 int from_tty
, int enabled
,
13025 int internal
, unsigned flags
)
13027 internal_error_pure_virtual_called ();
13031 base_breakpoint_decode_location (struct breakpoint
*b
,
13032 const struct event_location
*location
,
13033 struct program_space
*search_pspace
,
13034 struct symtabs_and_lines
*sals
)
13036 internal_error_pure_virtual_called ();
13039 /* The default 'explains_signal' method. */
13042 base_breakpoint_explains_signal (struct breakpoint
*b
, enum gdb_signal sig
)
13047 /* The default "after_condition_true" method. */
13050 base_breakpoint_after_condition_true (struct bpstats
*bs
)
13052 /* Nothing to do. */
13055 struct breakpoint_ops base_breakpoint_ops
=
13057 base_breakpoint_dtor
,
13058 base_breakpoint_allocate_location
,
13059 base_breakpoint_re_set
,
13060 base_breakpoint_insert_location
,
13061 base_breakpoint_remove_location
,
13062 base_breakpoint_breakpoint_hit
,
13063 base_breakpoint_check_status
,
13064 base_breakpoint_resources_needed
,
13065 base_breakpoint_works_in_software_mode
,
13066 base_breakpoint_print_it
,
13068 base_breakpoint_print_one_detail
,
13069 base_breakpoint_print_mention
,
13070 base_breakpoint_print_recreate
,
13071 base_breakpoint_create_sals_from_location
,
13072 base_breakpoint_create_breakpoints_sal
,
13073 base_breakpoint_decode_location
,
13074 base_breakpoint_explains_signal
,
13075 base_breakpoint_after_condition_true
,
13078 /* Default breakpoint_ops methods. */
13081 bkpt_re_set (struct breakpoint
*b
)
13083 /* FIXME: is this still reachable? */
13084 if (breakpoint_event_location_empty_p (b
))
13086 /* Anything without a location can't be re-set. */
13087 delete_breakpoint (b
);
13091 breakpoint_re_set_default (b
);
13095 bkpt_insert_location (struct bp_location
*bl
)
13097 CORE_ADDR addr
= bl
->target_info
.reqstd_address
;
13099 bl
->target_info
.kind
= breakpoint_kind (bl
, &addr
);
13100 bl
->target_info
.placed_address
= addr
;
13102 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
13103 return target_insert_hw_breakpoint (bl
->gdbarch
, &bl
->target_info
);
13105 return target_insert_breakpoint (bl
->gdbarch
, &bl
->target_info
);
13109 bkpt_remove_location (struct bp_location
*bl
, enum remove_bp_reason reason
)
13111 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
13112 return target_remove_hw_breakpoint (bl
->gdbarch
, &bl
->target_info
);
13114 return target_remove_breakpoint (bl
->gdbarch
, &bl
->target_info
, reason
);
13118 bkpt_breakpoint_hit (const struct bp_location
*bl
,
13119 struct address_space
*aspace
, CORE_ADDR bp_addr
,
13120 const struct target_waitstatus
*ws
)
13122 if (ws
->kind
!= TARGET_WAITKIND_STOPPED
13123 || ws
->value
.sig
!= GDB_SIGNAL_TRAP
)
13126 if (!breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
13130 if (overlay_debugging
/* unmapped overlay section */
13131 && section_is_overlay (bl
->section
)
13132 && !section_is_mapped (bl
->section
))
13139 dprintf_breakpoint_hit (const struct bp_location
*bl
,
13140 struct address_space
*aspace
, CORE_ADDR bp_addr
,
13141 const struct target_waitstatus
*ws
)
13143 if (dprintf_style
== dprintf_style_agent
13144 && target_can_run_breakpoint_commands ())
13146 /* An agent-style dprintf never causes a stop. If we see a trap
13147 for this address it must be for a breakpoint that happens to
13148 be set at the same address. */
13152 return bkpt_breakpoint_hit (bl
, aspace
, bp_addr
, ws
);
13156 bkpt_resources_needed (const struct bp_location
*bl
)
13158 gdb_assert (bl
->owner
->type
== bp_hardware_breakpoint
);
13163 static enum print_stop_action
13164 bkpt_print_it (bpstat bs
)
13166 struct breakpoint
*b
;
13167 const struct bp_location
*bl
;
13169 struct ui_out
*uiout
= current_uiout
;
13171 gdb_assert (bs
->bp_location_at
!= NULL
);
13173 bl
= bs
->bp_location_at
;
13174 b
= bs
->breakpoint_at
;
13176 bp_temp
= b
->disposition
== disp_del
;
13177 if (bl
->address
!= bl
->requested_address
)
13178 breakpoint_adjustment_warning (bl
->requested_address
,
13181 annotate_breakpoint (b
->number
);
13182 maybe_print_thread_hit_breakpoint (uiout
);
13185 ui_out_text (uiout
, "Temporary breakpoint ");
13187 ui_out_text (uiout
, "Breakpoint ");
13188 if (ui_out_is_mi_like_p (uiout
))
13190 ui_out_field_string (uiout
, "reason",
13191 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
13192 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
13194 ui_out_field_int (uiout
, "bkptno", b
->number
);
13195 ui_out_text (uiout
, ", ");
13197 return PRINT_SRC_AND_LOC
;
13201 bkpt_print_mention (struct breakpoint
*b
)
13203 if (ui_out_is_mi_like_p (current_uiout
))
13208 case bp_breakpoint
:
13209 case bp_gnu_ifunc_resolver
:
13210 if (b
->disposition
== disp_del
)
13211 printf_filtered (_("Temporary breakpoint"));
13213 printf_filtered (_("Breakpoint"));
13214 printf_filtered (_(" %d"), b
->number
);
13215 if (b
->type
== bp_gnu_ifunc_resolver
)
13216 printf_filtered (_(" at gnu-indirect-function resolver"));
13218 case bp_hardware_breakpoint
:
13219 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
13222 printf_filtered (_("Dprintf %d"), b
->number
);
13230 bkpt_print_recreate (struct breakpoint
*tp
, struct ui_file
*fp
)
13232 if (tp
->type
== bp_breakpoint
&& tp
->disposition
== disp_del
)
13233 fprintf_unfiltered (fp
, "tbreak");
13234 else if (tp
->type
== bp_breakpoint
)
13235 fprintf_unfiltered (fp
, "break");
13236 else if (tp
->type
== bp_hardware_breakpoint
13237 && tp
->disposition
== disp_del
)
13238 fprintf_unfiltered (fp
, "thbreak");
13239 else if (tp
->type
== bp_hardware_breakpoint
)
13240 fprintf_unfiltered (fp
, "hbreak");
13242 internal_error (__FILE__
, __LINE__
,
13243 _("unhandled breakpoint type %d"), (int) tp
->type
);
13245 fprintf_unfiltered (fp
, " %s",
13246 event_location_to_string (tp
->location
));
13248 /* Print out extra_string if this breakpoint is pending. It might
13249 contain, for example, conditions that were set by the user. */
13250 if (tp
->loc
== NULL
&& tp
->extra_string
!= NULL
)
13251 fprintf_unfiltered (fp
, " %s", tp
->extra_string
);
13253 print_recreate_thread (tp
, fp
);
13257 bkpt_create_sals_from_location (const struct event_location
*location
,
13258 struct linespec_result
*canonical
,
13259 enum bptype type_wanted
)
13261 create_sals_from_location_default (location
, canonical
, type_wanted
);
13265 bkpt_create_breakpoints_sal (struct gdbarch
*gdbarch
,
13266 struct linespec_result
*canonical
,
13268 char *extra_string
,
13269 enum bptype type_wanted
,
13270 enum bpdisp disposition
,
13272 int task
, int ignore_count
,
13273 const struct breakpoint_ops
*ops
,
13274 int from_tty
, int enabled
,
13275 int internal
, unsigned flags
)
13277 create_breakpoints_sal_default (gdbarch
, canonical
,
13278 cond_string
, extra_string
,
13280 disposition
, thread
, task
,
13281 ignore_count
, ops
, from_tty
,
13282 enabled
, internal
, flags
);
13286 bkpt_decode_location (struct breakpoint
*b
,
13287 const struct event_location
*location
,
13288 struct program_space
*search_pspace
,
13289 struct symtabs_and_lines
*sals
)
13291 decode_location_default (b
, location
, search_pspace
, sals
);
13294 /* Virtual table for internal breakpoints. */
13297 internal_bkpt_re_set (struct breakpoint
*b
)
13301 /* Delete overlay event and longjmp master breakpoints; they
13302 will be reset later by breakpoint_re_set. */
13303 case bp_overlay_event
:
13304 case bp_longjmp_master
:
13305 case bp_std_terminate_master
:
13306 case bp_exception_master
:
13307 delete_breakpoint (b
);
13310 /* This breakpoint is special, it's set up when the inferior
13311 starts and we really don't want to touch it. */
13312 case bp_shlib_event
:
13314 /* Like bp_shlib_event, this breakpoint type is special. Once
13315 it is set up, we do not want to touch it. */
13316 case bp_thread_event
:
13322 internal_bkpt_check_status (bpstat bs
)
13324 if (bs
->breakpoint_at
->type
== bp_shlib_event
)
13326 /* If requested, stop when the dynamic linker notifies GDB of
13327 events. This allows the user to get control and place
13328 breakpoints in initializer routines for dynamically loaded
13329 objects (among other things). */
13330 bs
->stop
= stop_on_solib_events
;
13331 bs
->print
= stop_on_solib_events
;
13337 static enum print_stop_action
13338 internal_bkpt_print_it (bpstat bs
)
13340 struct breakpoint
*b
;
13342 b
= bs
->breakpoint_at
;
13346 case bp_shlib_event
:
13347 /* Did we stop because the user set the stop_on_solib_events
13348 variable? (If so, we report this as a generic, "Stopped due
13349 to shlib event" message.) */
13350 print_solib_event (0);
13353 case bp_thread_event
:
13354 /* Not sure how we will get here.
13355 GDB should not stop for these breakpoints. */
13356 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
13359 case bp_overlay_event
:
13360 /* By analogy with the thread event, GDB should not stop for these. */
13361 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
13364 case bp_longjmp_master
:
13365 /* These should never be enabled. */
13366 printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
13369 case bp_std_terminate_master
:
13370 /* These should never be enabled. */
13371 printf_filtered (_("std::terminate Master Breakpoint: "
13372 "gdb should not stop!\n"));
13375 case bp_exception_master
:
13376 /* These should never be enabled. */
13377 printf_filtered (_("Exception Master Breakpoint: "
13378 "gdb should not stop!\n"));
13382 return PRINT_NOTHING
;
13386 internal_bkpt_print_mention (struct breakpoint
*b
)
13388 /* Nothing to mention. These breakpoints are internal. */
13391 /* Virtual table for momentary breakpoints */
13394 momentary_bkpt_re_set (struct breakpoint
*b
)
13396 /* Keep temporary breakpoints, which can be encountered when we step
13397 over a dlopen call and solib_add is resetting the breakpoints.
13398 Otherwise these should have been blown away via the cleanup chain
13399 or by breakpoint_init_inferior when we rerun the executable. */
13403 momentary_bkpt_check_status (bpstat bs
)
13405 /* Nothing. The point of these breakpoints is causing a stop. */
13408 static enum print_stop_action
13409 momentary_bkpt_print_it (bpstat bs
)
13411 return PRINT_UNKNOWN
;
13415 momentary_bkpt_print_mention (struct breakpoint
*b
)
13417 /* Nothing to mention. These breakpoints are internal. */
13420 /* Ensure INITIATING_FRAME is cleared when no such breakpoint exists.
13422 It gets cleared already on the removal of the first one of such placed
13423 breakpoints. This is OK as they get all removed altogether. */
13426 longjmp_bkpt_dtor (struct breakpoint
*self
)
13428 struct thread_info
*tp
= find_thread_global_id (self
->thread
);
13431 tp
->initiating_frame
= null_frame_id
;
13433 momentary_breakpoint_ops
.dtor (self
);
13436 /* Specific methods for probe breakpoints. */
13439 bkpt_probe_insert_location (struct bp_location
*bl
)
13441 int v
= bkpt_insert_location (bl
);
13445 /* The insertion was successful, now let's set the probe's semaphore
13447 if (bl
->probe
.probe
->pops
->set_semaphore
!= NULL
)
13448 bl
->probe
.probe
->pops
->set_semaphore (bl
->probe
.probe
,
13457 bkpt_probe_remove_location (struct bp_location
*bl
,
13458 enum remove_bp_reason reason
)
13460 /* Let's clear the semaphore before removing the location. */
13461 if (bl
->probe
.probe
->pops
->clear_semaphore
!= NULL
)
13462 bl
->probe
.probe
->pops
->clear_semaphore (bl
->probe
.probe
,
13466 return bkpt_remove_location (bl
, reason
);
13470 bkpt_probe_create_sals_from_location (const struct event_location
*location
,
13471 struct linespec_result
*canonical
,
13472 enum bptype type_wanted
)
13474 struct linespec_sals lsal
;
13476 lsal
.sals
= parse_probes (location
, NULL
, canonical
);
13477 lsal
.canonical
= xstrdup (event_location_to_string (canonical
->location
));
13478 VEC_safe_push (linespec_sals
, canonical
->sals
, &lsal
);
13482 bkpt_probe_decode_location (struct breakpoint
*b
,
13483 const struct event_location
*location
,
13484 struct program_space
*search_pspace
,
13485 struct symtabs_and_lines
*sals
)
13487 *sals
= parse_probes (location
, search_pspace
, NULL
);
13489 error (_("probe not found"));
13492 /* The breakpoint_ops structure to be used in tracepoints. */
13495 tracepoint_re_set (struct breakpoint
*b
)
13497 breakpoint_re_set_default (b
);
13501 tracepoint_breakpoint_hit (const struct bp_location
*bl
,
13502 struct address_space
*aspace
, CORE_ADDR bp_addr
,
13503 const struct target_waitstatus
*ws
)
13505 /* By definition, the inferior does not report stops at
13511 tracepoint_print_one_detail (const struct breakpoint
*self
,
13512 struct ui_out
*uiout
)
13514 struct tracepoint
*tp
= (struct tracepoint
*) self
;
13515 if (tp
->static_trace_marker_id
)
13517 gdb_assert (self
->type
== bp_static_tracepoint
);
13519 ui_out_text (uiout
, "\tmarker id is ");
13520 ui_out_field_string (uiout
, "static-tracepoint-marker-string-id",
13521 tp
->static_trace_marker_id
);
13522 ui_out_text (uiout
, "\n");
13527 tracepoint_print_mention (struct breakpoint
*b
)
13529 if (ui_out_is_mi_like_p (current_uiout
))
13534 case bp_tracepoint
:
13535 printf_filtered (_("Tracepoint"));
13536 printf_filtered (_(" %d"), b
->number
);
13538 case bp_fast_tracepoint
:
13539 printf_filtered (_("Fast tracepoint"));
13540 printf_filtered (_(" %d"), b
->number
);
13542 case bp_static_tracepoint
:
13543 printf_filtered (_("Static tracepoint"));
13544 printf_filtered (_(" %d"), b
->number
);
13547 internal_error (__FILE__
, __LINE__
,
13548 _("unhandled tracepoint type %d"), (int) b
->type
);
13555 tracepoint_print_recreate (struct breakpoint
*self
, struct ui_file
*fp
)
13557 struct tracepoint
*tp
= (struct tracepoint
*) self
;
13559 if (self
->type
== bp_fast_tracepoint
)
13560 fprintf_unfiltered (fp
, "ftrace");
13561 else if (self
->type
== bp_static_tracepoint
)
13562 fprintf_unfiltered (fp
, "strace");
13563 else if (self
->type
== bp_tracepoint
)
13564 fprintf_unfiltered (fp
, "trace");
13566 internal_error (__FILE__
, __LINE__
,
13567 _("unhandled tracepoint type %d"), (int) self
->type
);
13569 fprintf_unfiltered (fp
, " %s",
13570 event_location_to_string (self
->location
));
13571 print_recreate_thread (self
, fp
);
13573 if (tp
->pass_count
)
13574 fprintf_unfiltered (fp
, " passcount %d\n", tp
->pass_count
);
13578 tracepoint_create_sals_from_location (const struct event_location
*location
,
13579 struct linespec_result
*canonical
,
13580 enum bptype type_wanted
)
13582 create_sals_from_location_default (location
, canonical
, type_wanted
);
13586 tracepoint_create_breakpoints_sal (struct gdbarch
*gdbarch
,
13587 struct linespec_result
*canonical
,
13589 char *extra_string
,
13590 enum bptype type_wanted
,
13591 enum bpdisp disposition
,
13593 int task
, int ignore_count
,
13594 const struct breakpoint_ops
*ops
,
13595 int from_tty
, int enabled
,
13596 int internal
, unsigned flags
)
13598 create_breakpoints_sal_default (gdbarch
, canonical
,
13599 cond_string
, extra_string
,
13601 disposition
, thread
, task
,
13602 ignore_count
, ops
, from_tty
,
13603 enabled
, internal
, flags
);
13607 tracepoint_decode_location (struct breakpoint
*b
,
13608 const struct event_location
*location
,
13609 struct program_space
*search_pspace
,
13610 struct symtabs_and_lines
*sals
)
13612 decode_location_default (b
, location
, search_pspace
, sals
);
13615 struct breakpoint_ops tracepoint_breakpoint_ops
;
13617 /* The breakpoint_ops structure to be use on tracepoints placed in a
13621 tracepoint_probe_create_sals_from_location
13622 (const struct event_location
*location
,
13623 struct linespec_result
*canonical
,
13624 enum bptype type_wanted
)
13626 /* We use the same method for breakpoint on probes. */
13627 bkpt_probe_create_sals_from_location (location
, canonical
, type_wanted
);
13631 tracepoint_probe_decode_location (struct breakpoint
*b
,
13632 const struct event_location
*location
,
13633 struct program_space
*search_pspace
,
13634 struct symtabs_and_lines
*sals
)
13636 /* We use the same method for breakpoint on probes. */
13637 bkpt_probe_decode_location (b
, location
, search_pspace
, sals
);
13640 static struct breakpoint_ops tracepoint_probe_breakpoint_ops
;
13642 /* Dprintf breakpoint_ops methods. */
13645 dprintf_re_set (struct breakpoint
*b
)
13647 breakpoint_re_set_default (b
);
13649 /* extra_string should never be non-NULL for dprintf. */
13650 gdb_assert (b
->extra_string
!= NULL
);
13652 /* 1 - connect to target 1, that can run breakpoint commands.
13653 2 - create a dprintf, which resolves fine.
13654 3 - disconnect from target 1
13655 4 - connect to target 2, that can NOT run breakpoint commands.
13657 After steps #3/#4, you'll want the dprintf command list to
13658 be updated, because target 1 and 2 may well return different
13659 answers for target_can_run_breakpoint_commands().
13660 Given absence of finer grained resetting, we get to do
13661 it all the time. */
13662 if (b
->extra_string
!= NULL
)
13663 update_dprintf_command_list (b
);
13666 /* Implement the "print_recreate" breakpoint_ops method for dprintf. */
13669 dprintf_print_recreate (struct breakpoint
*tp
, struct ui_file
*fp
)
13671 fprintf_unfiltered (fp
, "dprintf %s,%s",
13672 event_location_to_string (tp
->location
),
13674 print_recreate_thread (tp
, fp
);
13677 /* Implement the "after_condition_true" breakpoint_ops method for
13680 dprintf's are implemented with regular commands in their command
13681 list, but we run the commands here instead of before presenting the
13682 stop to the user, as dprintf's don't actually cause a stop. This
13683 also makes it so that the commands of multiple dprintfs at the same
13684 address are all handled. */
13687 dprintf_after_condition_true (struct bpstats
*bs
)
13689 struct cleanup
*old_chain
;
13690 struct bpstats tmp_bs
= { NULL
};
13691 struct bpstats
*tmp_bs_p
= &tmp_bs
;
13693 /* dprintf's never cause a stop. This wasn't set in the
13694 check_status hook instead because that would make the dprintf's
13695 condition not be evaluated. */
13698 /* Run the command list here. Take ownership of it instead of
13699 copying. We never want these commands to run later in
13700 bpstat_do_actions, if a breakpoint that causes a stop happens to
13701 be set at same address as this dprintf, or even if running the
13702 commands here throws. */
13703 tmp_bs
.commands
= bs
->commands
;
13704 bs
->commands
= NULL
;
13705 old_chain
= make_cleanup_decref_counted_command_line (&tmp_bs
.commands
);
13707 bpstat_do_actions_1 (&tmp_bs_p
);
13709 /* 'tmp_bs.commands' will usually be NULL by now, but
13710 bpstat_do_actions_1 may return early without processing the whole
13712 do_cleanups (old_chain
);
13715 /* The breakpoint_ops structure to be used on static tracepoints with
13719 strace_marker_create_sals_from_location (const struct event_location
*location
,
13720 struct linespec_result
*canonical
,
13721 enum bptype type_wanted
)
13723 struct linespec_sals lsal
;
13724 const char *arg_start
, *arg
;
13726 struct cleanup
*cleanup
;
13728 arg
= arg_start
= get_linespec_location (location
);
13729 lsal
.sals
= decode_static_tracepoint_spec (&arg
);
13731 str
= savestring (arg_start
, arg
- arg_start
);
13732 cleanup
= make_cleanup (xfree
, str
);
13733 canonical
->location
= new_linespec_location (&str
);
13734 do_cleanups (cleanup
);
13736 lsal
.canonical
= xstrdup (event_location_to_string (canonical
->location
));
13737 VEC_safe_push (linespec_sals
, canonical
->sals
, &lsal
);
13741 strace_marker_create_breakpoints_sal (struct gdbarch
*gdbarch
,
13742 struct linespec_result
*canonical
,
13744 char *extra_string
,
13745 enum bptype type_wanted
,
13746 enum bpdisp disposition
,
13748 int task
, int ignore_count
,
13749 const struct breakpoint_ops
*ops
,
13750 int from_tty
, int enabled
,
13751 int internal
, unsigned flags
)
13754 struct linespec_sals
*lsal
= VEC_index (linespec_sals
,
13755 canonical
->sals
, 0);
13757 /* If the user is creating a static tracepoint by marker id
13758 (strace -m MARKER_ID), then store the sals index, so that
13759 breakpoint_re_set can try to match up which of the newly
13760 found markers corresponds to this one, and, don't try to
13761 expand multiple locations for each sal, given than SALS
13762 already should contain all sals for MARKER_ID. */
13764 for (i
= 0; i
< lsal
->sals
.nelts
; ++i
)
13766 struct symtabs_and_lines expanded
;
13767 struct tracepoint
*tp
;
13768 struct cleanup
*old_chain
;
13769 struct event_location
*location
;
13771 expanded
.nelts
= 1;
13772 expanded
.sals
= &lsal
->sals
.sals
[i
];
13774 location
= copy_event_location (canonical
->location
);
13775 old_chain
= make_cleanup_delete_event_location (location
);
13777 tp
= new tracepoint ();
13778 init_breakpoint_sal (&tp
->base
, gdbarch
, expanded
,
13780 cond_string
, extra_string
,
13781 type_wanted
, disposition
,
13782 thread
, task
, ignore_count
, ops
,
13783 from_tty
, enabled
, internal
, flags
,
13784 canonical
->special_display
);
13785 /* Given that its possible to have multiple markers with
13786 the same string id, if the user is creating a static
13787 tracepoint by marker id ("strace -m MARKER_ID"), then
13788 store the sals index, so that breakpoint_re_set can
13789 try to match up which of the newly found markers
13790 corresponds to this one */
13791 tp
->static_trace_marker_id_idx
= i
;
13793 install_breakpoint (internal
, &tp
->base
, 0);
13795 discard_cleanups (old_chain
);
13800 strace_marker_decode_location (struct breakpoint
*b
,
13801 const struct event_location
*location
,
13802 struct program_space
*search_pspace
,
13803 struct symtabs_and_lines
*sals
)
13805 struct tracepoint
*tp
= (struct tracepoint
*) b
;
13806 const char *s
= get_linespec_location (location
);
13808 *sals
= decode_static_tracepoint_spec (&s
);
13809 if (sals
->nelts
> tp
->static_trace_marker_id_idx
)
13811 sals
->sals
[0] = sals
->sals
[tp
->static_trace_marker_id_idx
];
13815 error (_("marker %s not found"), tp
->static_trace_marker_id
);
13818 static struct breakpoint_ops strace_marker_breakpoint_ops
;
13821 strace_marker_p (struct breakpoint
*b
)
13823 return b
->ops
== &strace_marker_breakpoint_ops
;
13826 /* Delete a breakpoint and clean up all traces of it in the data
13830 delete_breakpoint (struct breakpoint
*bpt
)
13832 struct breakpoint
*b
;
13834 gdb_assert (bpt
!= NULL
);
13836 /* Has this bp already been deleted? This can happen because
13837 multiple lists can hold pointers to bp's. bpstat lists are
13840 One example of this happening is a watchpoint's scope bp. When
13841 the scope bp triggers, we notice that the watchpoint is out of
13842 scope, and delete it. We also delete its scope bp. But the
13843 scope bp is marked "auto-deleting", and is already on a bpstat.
13844 That bpstat is then checked for auto-deleting bp's, which are
13847 A real solution to this problem might involve reference counts in
13848 bp's, and/or giving them pointers back to their referencing
13849 bpstat's, and teaching delete_breakpoint to only free a bp's
13850 storage when no more references were extent. A cheaper bandaid
13852 if (bpt
->type
== bp_none
)
13855 /* At least avoid this stale reference until the reference counting
13856 of breakpoints gets resolved. */
13857 if (bpt
->related_breakpoint
!= bpt
)
13859 struct breakpoint
*related
;
13860 struct watchpoint
*w
;
13862 if (bpt
->type
== bp_watchpoint_scope
)
13863 w
= (struct watchpoint
*) bpt
->related_breakpoint
;
13864 else if (bpt
->related_breakpoint
->type
== bp_watchpoint_scope
)
13865 w
= (struct watchpoint
*) bpt
;
13869 watchpoint_del_at_next_stop (w
);
13871 /* Unlink bpt from the bpt->related_breakpoint ring. */
13872 for (related
= bpt
; related
->related_breakpoint
!= bpt
;
13873 related
= related
->related_breakpoint
);
13874 related
->related_breakpoint
= bpt
->related_breakpoint
;
13875 bpt
->related_breakpoint
= bpt
;
13878 /* watch_command_1 creates a watchpoint but only sets its number if
13879 update_watchpoint succeeds in creating its bp_locations. If there's
13880 a problem in that process, we'll be asked to delete the half-created
13881 watchpoint. In that case, don't announce the deletion. */
13883 observer_notify_breakpoint_deleted (bpt
);
13885 if (breakpoint_chain
== bpt
)
13886 breakpoint_chain
= bpt
->next
;
13888 ALL_BREAKPOINTS (b
)
13889 if (b
->next
== bpt
)
13891 b
->next
= bpt
->next
;
13895 /* Be sure no bpstat's are pointing at the breakpoint after it's
13897 /* FIXME, how can we find all bpstat's? We just check stop_bpstat
13898 in all threads for now. Note that we cannot just remove bpstats
13899 pointing at bpt from the stop_bpstat list entirely, as breakpoint
13900 commands are associated with the bpstat; if we remove it here,
13901 then the later call to bpstat_do_actions (&stop_bpstat); in
13902 event-top.c won't do anything, and temporary breakpoints with
13903 commands won't work. */
13905 iterate_over_threads (bpstat_remove_breakpoint_callback
, bpt
);
13907 /* Now that breakpoint is removed from breakpoint list, update the
13908 global location list. This will remove locations that used to
13909 belong to this breakpoint. Do this before freeing the breakpoint
13910 itself, since remove_breakpoint looks at location's owner. It
13911 might be better design to have location completely
13912 self-contained, but it's not the case now. */
13913 update_global_location_list (UGLL_DONT_INSERT
);
13915 bpt
->ops
->dtor (bpt
);
13916 /* On the chance that someone will soon try again to delete this
13917 same bp, we mark it as deleted before freeing its storage. */
13918 bpt
->type
= bp_none
;
13923 do_delete_breakpoint_cleanup (void *b
)
13925 delete_breakpoint ((struct breakpoint
*) b
);
13929 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
13931 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
13934 /* Iterator function to call a user-provided callback function once
13935 for each of B and its related breakpoints. */
13938 iterate_over_related_breakpoints (struct breakpoint
*b
,
13939 void (*function
) (struct breakpoint
*,
13943 struct breakpoint
*related
;
13948 struct breakpoint
*next
;
13950 /* FUNCTION may delete RELATED. */
13951 next
= related
->related_breakpoint
;
13953 if (next
== related
)
13955 /* RELATED is the last ring entry. */
13956 function (related
, data
);
13958 /* FUNCTION may have deleted it, so we'd never reach back to
13959 B. There's nothing left to do anyway, so just break
13964 function (related
, data
);
13968 while (related
!= b
);
13972 do_delete_breakpoint (struct breakpoint
*b
, void *ignore
)
13974 delete_breakpoint (b
);
13977 /* A callback for map_breakpoint_numbers that calls
13978 delete_breakpoint. */
13981 do_map_delete_breakpoint (struct breakpoint
*b
, void *ignore
)
13983 iterate_over_related_breakpoints (b
, do_delete_breakpoint
, NULL
);
13987 delete_command (char *arg
, int from_tty
)
13989 struct breakpoint
*b
, *b_tmp
;
13995 int breaks_to_delete
= 0;
13997 /* Delete all breakpoints if no argument. Do not delete
13998 internal breakpoints, these have to be deleted with an
13999 explicit breakpoint number argument. */
14000 ALL_BREAKPOINTS (b
)
14001 if (user_breakpoint_p (b
))
14003 breaks_to_delete
= 1;
14007 /* Ask user only if there are some breakpoints to delete. */
14009 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
14011 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
14012 if (user_breakpoint_p (b
))
14013 delete_breakpoint (b
);
14017 map_breakpoint_numbers (arg
, do_map_delete_breakpoint
, NULL
);
14020 /* Return true if all locations of B bound to PSPACE are pending. If
14021 PSPACE is NULL, all locations of all program spaces are
14025 all_locations_are_pending (struct breakpoint
*b
, struct program_space
*pspace
)
14027 struct bp_location
*loc
;
14029 for (loc
= b
->loc
; loc
!= NULL
; loc
= loc
->next
)
14030 if ((pspace
== NULL
14031 || loc
->pspace
== pspace
)
14032 && !loc
->shlib_disabled
14033 && !loc
->pspace
->executing_startup
)
14038 /* Subroutine of update_breakpoint_locations to simplify it.
14039 Return non-zero if multiple fns in list LOC have the same name.
14040 Null names are ignored. */
14043 ambiguous_names_p (struct bp_location
*loc
)
14045 struct bp_location
*l
;
14046 htab_t htab
= htab_create_alloc (13, htab_hash_string
,
14047 (int (*) (const void *,
14048 const void *)) streq
,
14049 NULL
, xcalloc
, xfree
);
14051 for (l
= loc
; l
!= NULL
; l
= l
->next
)
14054 const char *name
= l
->function_name
;
14056 /* Allow for some names to be NULL, ignore them. */
14060 slot
= (const char **) htab_find_slot (htab
, (const void *) name
,
14062 /* NOTE: We can assume slot != NULL here because xcalloc never
14066 htab_delete (htab
);
14072 htab_delete (htab
);
14076 /* When symbols change, it probably means the sources changed as well,
14077 and it might mean the static tracepoint markers are no longer at
14078 the same address or line numbers they used to be at last we
14079 checked. Losing your static tracepoints whenever you rebuild is
14080 undesirable. This function tries to resync/rematch gdb static
14081 tracepoints with the markers on the target, for static tracepoints
14082 that have not been set by marker id. Static tracepoint that have
14083 been set by marker id are reset by marker id in breakpoint_re_set.
14086 1) For a tracepoint set at a specific address, look for a marker at
14087 the old PC. If one is found there, assume to be the same marker.
14088 If the name / string id of the marker found is different from the
14089 previous known name, assume that means the user renamed the marker
14090 in the sources, and output a warning.
14092 2) For a tracepoint set at a given line number, look for a marker
14093 at the new address of the old line number. If one is found there,
14094 assume to be the same marker. If the name / string id of the
14095 marker found is different from the previous known name, assume that
14096 means the user renamed the marker in the sources, and output a
14099 3) If a marker is no longer found at the same address or line, it
14100 may mean the marker no longer exists. But it may also just mean
14101 the code changed a bit. Maybe the user added a few lines of code
14102 that made the marker move up or down (in line number terms). Ask
14103 the target for info about the marker with the string id as we knew
14104 it. If found, update line number and address in the matching
14105 static tracepoint. This will get confused if there's more than one
14106 marker with the same ID (possible in UST, although unadvised
14107 precisely because it confuses tools). */
14109 static struct symtab_and_line
14110 update_static_tracepoint (struct breakpoint
*b
, struct symtab_and_line sal
)
14112 struct tracepoint
*tp
= (struct tracepoint
*) b
;
14113 struct static_tracepoint_marker marker
;
14118 find_line_pc (sal
.symtab
, sal
.line
, &pc
);
14120 if (target_static_tracepoint_marker_at (pc
, &marker
))
14122 if (strcmp (tp
->static_trace_marker_id
, marker
.str_id
) != 0)
14123 warning (_("static tracepoint %d changed probed marker from %s to %s"),
14125 tp
->static_trace_marker_id
, marker
.str_id
);
14127 xfree (tp
->static_trace_marker_id
);
14128 tp
->static_trace_marker_id
= xstrdup (marker
.str_id
);
14129 release_static_tracepoint_marker (&marker
);
14134 /* Old marker wasn't found on target at lineno. Try looking it up
14136 if (!sal
.explicit_pc
14138 && sal
.symtab
!= NULL
14139 && tp
->static_trace_marker_id
!= NULL
)
14141 VEC(static_tracepoint_marker_p
) *markers
;
14144 = target_static_tracepoint_markers_by_strid (tp
->static_trace_marker_id
);
14146 if (!VEC_empty(static_tracepoint_marker_p
, markers
))
14148 struct symtab_and_line sal2
;
14149 struct symbol
*sym
;
14150 struct static_tracepoint_marker
*tpmarker
;
14151 struct ui_out
*uiout
= current_uiout
;
14152 struct explicit_location explicit_loc
;
14154 tpmarker
= VEC_index (static_tracepoint_marker_p
, markers
, 0);
14156 xfree (tp
->static_trace_marker_id
);
14157 tp
->static_trace_marker_id
= xstrdup (tpmarker
->str_id
);
14159 warning (_("marker for static tracepoint %d (%s) not "
14160 "found at previous line number"),
14161 b
->number
, tp
->static_trace_marker_id
);
14165 sal2
.pc
= tpmarker
->address
;
14167 sal2
= find_pc_line (tpmarker
->address
, 0);
14168 sym
= find_pc_sect_function (tpmarker
->address
, NULL
);
14169 ui_out_text (uiout
, "Now in ");
14172 ui_out_field_string (uiout
, "func",
14173 SYMBOL_PRINT_NAME (sym
));
14174 ui_out_text (uiout
, " at ");
14176 ui_out_field_string (uiout
, "file",
14177 symtab_to_filename_for_display (sal2
.symtab
));
14178 ui_out_text (uiout
, ":");
14180 if (ui_out_is_mi_like_p (uiout
))
14182 const char *fullname
= symtab_to_fullname (sal2
.symtab
);
14184 ui_out_field_string (uiout
, "fullname", fullname
);
14187 ui_out_field_int (uiout
, "line", sal2
.line
);
14188 ui_out_text (uiout
, "\n");
14190 b
->loc
->line_number
= sal2
.line
;
14191 b
->loc
->symtab
= sym
!= NULL
? sal2
.symtab
: NULL
;
14193 delete_event_location (b
->location
);
14194 initialize_explicit_location (&explicit_loc
);
14195 explicit_loc
.source_filename
14196 = ASTRDUP (symtab_to_filename_for_display (sal2
.symtab
));
14197 explicit_loc
.line_offset
.offset
= b
->loc
->line_number
;
14198 explicit_loc
.line_offset
.sign
= LINE_OFFSET_NONE
;
14199 b
->location
= new_explicit_location (&explicit_loc
);
14201 /* Might be nice to check if function changed, and warn if
14204 release_static_tracepoint_marker (tpmarker
);
14210 /* Returns 1 iff locations A and B are sufficiently same that
14211 we don't need to report breakpoint as changed. */
14214 locations_are_equal (struct bp_location
*a
, struct bp_location
*b
)
14218 if (a
->address
!= b
->address
)
14221 if (a
->shlib_disabled
!= b
->shlib_disabled
)
14224 if (a
->enabled
!= b
->enabled
)
14231 if ((a
== NULL
) != (b
== NULL
))
14237 /* Split all locations of B that are bound to PSPACE out of B's
14238 location list to a separate list and return that list's head. If
14239 PSPACE is NULL, hoist out all locations of B. */
14241 static struct bp_location
*
14242 hoist_existing_locations (struct breakpoint
*b
, struct program_space
*pspace
)
14244 struct bp_location head
;
14245 struct bp_location
*i
= b
->loc
;
14246 struct bp_location
**i_link
= &b
->loc
;
14247 struct bp_location
*hoisted
= &head
;
14249 if (pspace
== NULL
)
14260 if (i
->pspace
== pspace
)
14275 /* Create new breakpoint locations for B (a hardware or software
14276 breakpoint) based on SALS and SALS_END. If SALS_END.NELTS is not
14277 zero, then B is a ranged breakpoint. Only recreates locations for
14278 FILTER_PSPACE. Locations of other program spaces are left
14282 update_breakpoint_locations (struct breakpoint
*b
,
14283 struct program_space
*filter_pspace
,
14284 struct symtabs_and_lines sals
,
14285 struct symtabs_and_lines sals_end
)
14288 struct bp_location
*existing_locations
;
14290 if (sals_end
.nelts
!= 0 && (sals
.nelts
!= 1 || sals_end
.nelts
!= 1))
14292 /* Ranged breakpoints have only one start location and one end
14294 b
->enable_state
= bp_disabled
;
14295 printf_unfiltered (_("Could not reset ranged breakpoint %d: "
14296 "multiple locations found\n"),
14301 /* If there's no new locations, and all existing locations are
14302 pending, don't do anything. This optimizes the common case where
14303 all locations are in the same shared library, that was unloaded.
14304 We'd like to retain the location, so that when the library is
14305 loaded again, we don't loose the enabled/disabled status of the
14306 individual locations. */
14307 if (all_locations_are_pending (b
, filter_pspace
) && sals
.nelts
== 0)
14310 existing_locations
= hoist_existing_locations (b
, filter_pspace
);
14312 for (i
= 0; i
< sals
.nelts
; ++i
)
14314 struct bp_location
*new_loc
;
14316 switch_to_program_space_and_thread (sals
.sals
[i
].pspace
);
14318 new_loc
= add_location_to_breakpoint (b
, &(sals
.sals
[i
]));
14320 /* Reparse conditions, they might contain references to the
14322 if (b
->cond_string
!= NULL
)
14326 s
= b
->cond_string
;
14329 new_loc
->cond
= parse_exp_1 (&s
, sals
.sals
[i
].pc
,
14330 block_for_pc (sals
.sals
[i
].pc
),
14333 CATCH (e
, RETURN_MASK_ERROR
)
14335 warning (_("failed to reevaluate condition "
14336 "for breakpoint %d: %s"),
14337 b
->number
, e
.message
);
14338 new_loc
->enabled
= 0;
14343 if (sals_end
.nelts
)
14345 CORE_ADDR end
= find_breakpoint_range_end (sals_end
.sals
[0]);
14347 new_loc
->length
= end
- sals
.sals
[0].pc
+ 1;
14351 /* If possible, carry over 'disable' status from existing
14354 struct bp_location
*e
= existing_locations
;
14355 /* If there are multiple breakpoints with the same function name,
14356 e.g. for inline functions, comparing function names won't work.
14357 Instead compare pc addresses; this is just a heuristic as things
14358 may have moved, but in practice it gives the correct answer
14359 often enough until a better solution is found. */
14360 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
14362 for (; e
; e
= e
->next
)
14364 if (!e
->enabled
&& e
->function_name
)
14366 struct bp_location
*l
= b
->loc
;
14367 if (have_ambiguous_names
)
14369 for (; l
; l
= l
->next
)
14370 if (breakpoint_locations_match (e
, l
))
14378 for (; l
; l
= l
->next
)
14379 if (l
->function_name
14380 && strcmp (e
->function_name
, l
->function_name
) == 0)
14390 if (!locations_are_equal (existing_locations
, b
->loc
))
14391 observer_notify_breakpoint_modified (b
);
14394 /* Find the SaL locations corresponding to the given LOCATION.
14395 On return, FOUND will be 1 if any SaL was found, zero otherwise. */
14397 static struct symtabs_and_lines
14398 location_to_sals (struct breakpoint
*b
, struct event_location
*location
,
14399 struct program_space
*search_pspace
, int *found
)
14401 struct symtabs_and_lines sals
= {0};
14402 struct gdb_exception exception
= exception_none
;
14404 gdb_assert (b
->ops
!= NULL
);
14408 b
->ops
->decode_location (b
, location
, search_pspace
, &sals
);
14410 CATCH (e
, RETURN_MASK_ERROR
)
14412 int not_found_and_ok
= 0;
14416 /* For pending breakpoints, it's expected that parsing will
14417 fail until the right shared library is loaded. User has
14418 already told to create pending breakpoints and don't need
14419 extra messages. If breakpoint is in bp_shlib_disabled
14420 state, then user already saw the message about that
14421 breakpoint being disabled, and don't want to see more
14423 if (e
.error
== NOT_FOUND_ERROR
14424 && (b
->condition_not_parsed
14426 && search_pspace
!= NULL
14427 && b
->loc
->pspace
!= search_pspace
)
14428 || (b
->loc
&& b
->loc
->shlib_disabled
)
14429 || (b
->loc
&& b
->loc
->pspace
->executing_startup
)
14430 || b
->enable_state
== bp_disabled
))
14431 not_found_and_ok
= 1;
14433 if (!not_found_and_ok
)
14435 /* We surely don't want to warn about the same breakpoint
14436 10 times. One solution, implemented here, is disable
14437 the breakpoint on error. Another solution would be to
14438 have separate 'warning emitted' flag. Since this
14439 happens only when a binary has changed, I don't know
14440 which approach is better. */
14441 b
->enable_state
= bp_disabled
;
14442 throw_exception (e
);
14447 if (exception
.reason
== 0 || exception
.error
!= NOT_FOUND_ERROR
)
14451 for (i
= 0; i
< sals
.nelts
; ++i
)
14452 resolve_sal_pc (&sals
.sals
[i
]);
14453 if (b
->condition_not_parsed
&& b
->extra_string
!= NULL
)
14455 char *cond_string
, *extra_string
;
14458 find_condition_and_thread (b
->extra_string
, sals
.sals
[0].pc
,
14459 &cond_string
, &thread
, &task
,
14461 gdb_assert (b
->cond_string
== NULL
);
14463 b
->cond_string
= cond_string
;
14464 b
->thread
= thread
;
14468 xfree (b
->extra_string
);
14469 b
->extra_string
= extra_string
;
14471 b
->condition_not_parsed
= 0;
14474 if (b
->type
== bp_static_tracepoint
&& !strace_marker_p (b
))
14475 sals
.sals
[0] = update_static_tracepoint (b
, sals
.sals
[0]);
14485 /* The default re_set method, for typical hardware or software
14486 breakpoints. Reevaluate the breakpoint and recreate its
14490 breakpoint_re_set_default (struct breakpoint
*b
)
14493 struct symtabs_and_lines sals
, sals_end
;
14494 struct symtabs_and_lines expanded
= {0};
14495 struct symtabs_and_lines expanded_end
= {0};
14496 struct program_space
*filter_pspace
= current_program_space
;
14498 sals
= location_to_sals (b
, b
->location
, filter_pspace
, &found
);
14501 make_cleanup (xfree
, sals
.sals
);
14505 if (b
->location_range_end
!= NULL
)
14507 sals_end
= location_to_sals (b
, b
->location_range_end
,
14508 filter_pspace
, &found
);
14511 make_cleanup (xfree
, sals_end
.sals
);
14512 expanded_end
= sals_end
;
14516 update_breakpoint_locations (b
, filter_pspace
, expanded
, expanded_end
);
14519 /* Default method for creating SALs from an address string. It basically
14520 calls parse_breakpoint_sals. Return 1 for success, zero for failure. */
14523 create_sals_from_location_default (const struct event_location
*location
,
14524 struct linespec_result
*canonical
,
14525 enum bptype type_wanted
)
14527 parse_breakpoint_sals (location
, canonical
);
14530 /* Call create_breakpoints_sal for the given arguments. This is the default
14531 function for the `create_breakpoints_sal' method of
14535 create_breakpoints_sal_default (struct gdbarch
*gdbarch
,
14536 struct linespec_result
*canonical
,
14538 char *extra_string
,
14539 enum bptype type_wanted
,
14540 enum bpdisp disposition
,
14542 int task
, int ignore_count
,
14543 const struct breakpoint_ops
*ops
,
14544 int from_tty
, int enabled
,
14545 int internal
, unsigned flags
)
14547 create_breakpoints_sal (gdbarch
, canonical
, cond_string
,
14549 type_wanted
, disposition
,
14550 thread
, task
, ignore_count
, ops
, from_tty
,
14551 enabled
, internal
, flags
);
14554 /* Decode the line represented by S by calling decode_line_full. This is the
14555 default function for the `decode_location' method of breakpoint_ops. */
14558 decode_location_default (struct breakpoint
*b
,
14559 const struct event_location
*location
,
14560 struct program_space
*search_pspace
,
14561 struct symtabs_and_lines
*sals
)
14563 struct linespec_result canonical
;
14565 init_linespec_result (&canonical
);
14566 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, search_pspace
,
14567 (struct symtab
*) NULL
, 0,
14568 &canonical
, multiple_symbols_all
,
14571 /* We should get 0 or 1 resulting SALs. */
14572 gdb_assert (VEC_length (linespec_sals
, canonical
.sals
) < 2);
14574 if (VEC_length (linespec_sals
, canonical
.sals
) > 0)
14576 struct linespec_sals
*lsal
;
14578 lsal
= VEC_index (linespec_sals
, canonical
.sals
, 0);
14579 *sals
= lsal
->sals
;
14580 /* Arrange it so the destructor does not free the
14582 lsal
->sals
.sals
= NULL
;
14585 destroy_linespec_result (&canonical
);
14588 /* Prepare the global context for a re-set of breakpoint B. */
14590 static struct cleanup
*
14591 prepare_re_set_context (struct breakpoint
*b
)
14593 input_radix
= b
->input_radix
;
14594 set_language (b
->language
);
14596 return make_cleanup (null_cleanup
, NULL
);
14599 /* Reset a breakpoint given it's struct breakpoint * BINT.
14600 The value we return ends up being the return value from catch_errors.
14601 Unused in this case. */
14604 breakpoint_re_set_one (void *bint
)
14606 /* Get past catch_errs. */
14607 struct breakpoint
*b
= (struct breakpoint
*) bint
;
14608 struct cleanup
*cleanups
;
14610 cleanups
= prepare_re_set_context (b
);
14611 b
->ops
->re_set (b
);
14612 do_cleanups (cleanups
);
14616 /* Re-set breakpoint locations for the current program space.
14617 Locations bound to other program spaces are left untouched. */
14620 breakpoint_re_set (void)
14622 struct breakpoint
*b
, *b_tmp
;
14623 enum language save_language
;
14624 int save_input_radix
;
14625 struct cleanup
*old_chain
;
14627 save_language
= current_language
->la_language
;
14628 save_input_radix
= input_radix
;
14629 old_chain
= save_current_space_and_thread ();
14631 /* Note: we must not try to insert locations until after all
14632 breakpoints have been re-set. Otherwise, e.g., when re-setting
14633 breakpoint 1, we'd insert the locations of breakpoint 2, which
14634 hadn't been re-set yet, and thus may have stale locations. */
14636 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
14638 /* Format possible error msg. */
14639 char *message
= xstrprintf ("Error in re-setting breakpoint %d: ",
14641 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
14642 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
14643 do_cleanups (cleanups
);
14645 set_language (save_language
);
14646 input_radix
= save_input_radix
;
14648 jit_breakpoint_re_set ();
14650 do_cleanups (old_chain
);
14652 create_overlay_event_breakpoint ();
14653 create_longjmp_master_breakpoint ();
14654 create_std_terminate_master_breakpoint ();
14655 create_exception_master_breakpoint ();
14657 /* Now we can insert. */
14658 update_global_location_list (UGLL_MAY_INSERT
);
14661 /* Reset the thread number of this breakpoint:
14663 - If the breakpoint is for all threads, leave it as-is.
14664 - Else, reset it to the current thread for inferior_ptid. */
14666 breakpoint_re_set_thread (struct breakpoint
*b
)
14668 if (b
->thread
!= -1)
14670 if (in_thread_list (inferior_ptid
))
14671 b
->thread
= ptid_to_global_thread_id (inferior_ptid
);
14673 /* We're being called after following a fork. The new fork is
14674 selected as current, and unless this was a vfork will have a
14675 different program space from the original thread. Reset that
14677 b
->loc
->pspace
= current_program_space
;
14681 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14682 If from_tty is nonzero, it prints a message to that effect,
14683 which ends with a period (no newline). */
14686 set_ignore_count (int bptnum
, int count
, int from_tty
)
14688 struct breakpoint
*b
;
14693 ALL_BREAKPOINTS (b
)
14694 if (b
->number
== bptnum
)
14696 if (is_tracepoint (b
))
14698 if (from_tty
&& count
!= 0)
14699 printf_filtered (_("Ignore count ignored for tracepoint %d."),
14704 b
->ignore_count
= count
;
14708 printf_filtered (_("Will stop next time "
14709 "breakpoint %d is reached."),
14711 else if (count
== 1)
14712 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
14715 printf_filtered (_("Will ignore next %d "
14716 "crossings of breakpoint %d."),
14719 observer_notify_breakpoint_modified (b
);
14723 error (_("No breakpoint number %d."), bptnum
);
14726 /* Command to set ignore-count of breakpoint N to COUNT. */
14729 ignore_command (char *args
, int from_tty
)
14735 error_no_arg (_("a breakpoint number"));
14737 num
= get_number (&p
);
14739 error (_("bad breakpoint number: '%s'"), args
);
14741 error (_("Second argument (specified ignore-count) is missing."));
14743 set_ignore_count (num
,
14744 longest_to_int (value_as_long (parse_and_eval (p
))),
14747 printf_filtered ("\n");
14750 /* Call FUNCTION on each of the breakpoints
14751 whose numbers are given in ARGS. */
14754 map_breakpoint_numbers (const char *args
,
14755 void (*function
) (struct breakpoint
*,
14760 struct breakpoint
*b
, *tmp
;
14762 if (args
== 0 || *args
== '\0')
14763 error_no_arg (_("one or more breakpoint numbers"));
14765 number_or_range_parser
parser (args
);
14767 while (!parser
.finished ())
14769 const char *p
= parser
.cur_tok ();
14770 bool match
= false;
14772 num
= parser
.get_number ();
14775 warning (_("bad breakpoint number at or near '%s'"), p
);
14779 ALL_BREAKPOINTS_SAFE (b
, tmp
)
14780 if (b
->number
== num
)
14783 function (b
, data
);
14787 printf_unfiltered (_("No breakpoint number %d.\n"), num
);
14792 static struct bp_location
*
14793 find_location_by_number (char *number
)
14795 char *dot
= strchr (number
, '.');
14799 struct breakpoint
*b
;
14800 struct bp_location
*loc
;
14805 bp_num
= get_number (&p1
);
14807 error (_("Bad breakpoint number '%s'"), number
);
14809 ALL_BREAKPOINTS (b
)
14810 if (b
->number
== bp_num
)
14815 if (!b
|| b
->number
!= bp_num
)
14816 error (_("Bad breakpoint number '%s'"), number
);
14819 loc_num
= get_number (&p1
);
14821 error (_("Bad breakpoint location number '%s'"), number
);
14825 for (;loc_num
&& loc
; --loc_num
, loc
= loc
->next
)
14828 error (_("Bad breakpoint location number '%s'"), dot
+1);
14834 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14835 If from_tty is nonzero, it prints a message to that effect,
14836 which ends with a period (no newline). */
14839 disable_breakpoint (struct breakpoint
*bpt
)
14841 /* Never disable a watchpoint scope breakpoint; we want to
14842 hit them when we leave scope so we can delete both the
14843 watchpoint and its scope breakpoint at that time. */
14844 if (bpt
->type
== bp_watchpoint_scope
)
14847 bpt
->enable_state
= bp_disabled
;
14849 /* Mark breakpoint locations modified. */
14850 mark_breakpoint_modified (bpt
);
14852 if (target_supports_enable_disable_tracepoint ()
14853 && current_trace_status ()->running
&& is_tracepoint (bpt
))
14855 struct bp_location
*location
;
14857 for (location
= bpt
->loc
; location
; location
= location
->next
)
14858 target_disable_tracepoint (location
);
14861 update_global_location_list (UGLL_DONT_INSERT
);
14863 observer_notify_breakpoint_modified (bpt
);
14866 /* A callback for iterate_over_related_breakpoints. */
14869 do_disable_breakpoint (struct breakpoint
*b
, void *ignore
)
14871 disable_breakpoint (b
);
14874 /* A callback for map_breakpoint_numbers that calls
14875 disable_breakpoint. */
14878 do_map_disable_breakpoint (struct breakpoint
*b
, void *ignore
)
14880 iterate_over_related_breakpoints (b
, do_disable_breakpoint
, NULL
);
14884 disable_command (char *args
, int from_tty
)
14888 struct breakpoint
*bpt
;
14890 ALL_BREAKPOINTS (bpt
)
14891 if (user_breakpoint_p (bpt
))
14892 disable_breakpoint (bpt
);
14896 char *num
= extract_arg (&args
);
14900 if (strchr (num
, '.'))
14902 struct bp_location
*loc
= find_location_by_number (num
);
14909 mark_breakpoint_location_modified (loc
);
14911 if (target_supports_enable_disable_tracepoint ()
14912 && current_trace_status ()->running
&& loc
->owner
14913 && is_tracepoint (loc
->owner
))
14914 target_disable_tracepoint (loc
);
14916 update_global_location_list (UGLL_DONT_INSERT
);
14919 map_breakpoint_numbers (num
, do_map_disable_breakpoint
, NULL
);
14920 num
= extract_arg (&args
);
14926 enable_breakpoint_disp (struct breakpoint
*bpt
, enum bpdisp disposition
,
14929 int target_resources_ok
;
14931 if (bpt
->type
== bp_hardware_breakpoint
)
14934 i
= hw_breakpoint_used_count ();
14935 target_resources_ok
=
14936 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
14938 if (target_resources_ok
== 0)
14939 error (_("No hardware breakpoint support in the target."));
14940 else if (target_resources_ok
< 0)
14941 error (_("Hardware breakpoints used exceeds limit."));
14944 if (is_watchpoint (bpt
))
14946 /* Initialize it just to avoid a GCC false warning. */
14947 enum enable_state orig_enable_state
= bp_disabled
;
14951 struct watchpoint
*w
= (struct watchpoint
*) bpt
;
14953 orig_enable_state
= bpt
->enable_state
;
14954 bpt
->enable_state
= bp_enabled
;
14955 update_watchpoint (w
, 1 /* reparse */);
14957 CATCH (e
, RETURN_MASK_ALL
)
14959 bpt
->enable_state
= orig_enable_state
;
14960 exception_fprintf (gdb_stderr
, e
, _("Cannot enable watchpoint %d: "),
14967 bpt
->enable_state
= bp_enabled
;
14969 /* Mark breakpoint locations modified. */
14970 mark_breakpoint_modified (bpt
);
14972 if (target_supports_enable_disable_tracepoint ()
14973 && current_trace_status ()->running
&& is_tracepoint (bpt
))
14975 struct bp_location
*location
;
14977 for (location
= bpt
->loc
; location
; location
= location
->next
)
14978 target_enable_tracepoint (location
);
14981 bpt
->disposition
= disposition
;
14982 bpt
->enable_count
= count
;
14983 update_global_location_list (UGLL_MAY_INSERT
);
14985 observer_notify_breakpoint_modified (bpt
);
14990 enable_breakpoint (struct breakpoint
*bpt
)
14992 enable_breakpoint_disp (bpt
, bpt
->disposition
, 0);
14996 do_enable_breakpoint (struct breakpoint
*bpt
, void *arg
)
14998 enable_breakpoint (bpt
);
15001 /* A callback for map_breakpoint_numbers that calls
15002 enable_breakpoint. */
15005 do_map_enable_breakpoint (struct breakpoint
*b
, void *ignore
)
15007 iterate_over_related_breakpoints (b
, do_enable_breakpoint
, NULL
);
15010 /* The enable command enables the specified breakpoints (or all defined
15011 breakpoints) so they once again become (or continue to be) effective
15012 in stopping the inferior. */
15015 enable_command (char *args
, int from_tty
)
15019 struct breakpoint
*bpt
;
15021 ALL_BREAKPOINTS (bpt
)
15022 if (user_breakpoint_p (bpt
))
15023 enable_breakpoint (bpt
);
15027 char *num
= extract_arg (&args
);
15031 if (strchr (num
, '.'))
15033 struct bp_location
*loc
= find_location_by_number (num
);
15040 mark_breakpoint_location_modified (loc
);
15042 if (target_supports_enable_disable_tracepoint ()
15043 && current_trace_status ()->running
&& loc
->owner
15044 && is_tracepoint (loc
->owner
))
15045 target_enable_tracepoint (loc
);
15047 update_global_location_list (UGLL_MAY_INSERT
);
15050 map_breakpoint_numbers (num
, do_map_enable_breakpoint
, NULL
);
15051 num
= extract_arg (&args
);
15056 /* This struct packages up disposition data for application to multiple
15066 do_enable_breakpoint_disp (struct breakpoint
*bpt
, void *arg
)
15068 struct disp_data disp_data
= *(struct disp_data
*) arg
;
15070 enable_breakpoint_disp (bpt
, disp_data
.disp
, disp_data
.count
);
15074 do_map_enable_once_breakpoint (struct breakpoint
*bpt
, void *ignore
)
15076 struct disp_data disp
= { disp_disable
, 1 };
15078 iterate_over_related_breakpoints (bpt
, do_enable_breakpoint_disp
, &disp
);
15082 enable_once_command (char *args
, int from_tty
)
15084 map_breakpoint_numbers (args
, do_map_enable_once_breakpoint
, NULL
);
15088 do_map_enable_count_breakpoint (struct breakpoint
*bpt
, void *countptr
)
15090 struct disp_data disp
= { disp_disable
, *(int *) countptr
};
15092 iterate_over_related_breakpoints (bpt
, do_enable_breakpoint_disp
, &disp
);
15096 enable_count_command (char *args
, int from_tty
)
15101 error_no_arg (_("hit count"));
15103 count
= get_number (&args
);
15105 map_breakpoint_numbers (args
, do_map_enable_count_breakpoint
, &count
);
15109 do_map_enable_delete_breakpoint (struct breakpoint
*bpt
, void *ignore
)
15111 struct disp_data disp
= { disp_del
, 1 };
15113 iterate_over_related_breakpoints (bpt
, do_enable_breakpoint_disp
, &disp
);
15117 enable_delete_command (char *args
, int from_tty
)
15119 map_breakpoint_numbers (args
, do_map_enable_delete_breakpoint
, NULL
);
15123 set_breakpoint_cmd (char *args
, int from_tty
)
15128 show_breakpoint_cmd (char *args
, int from_tty
)
15132 /* Invalidate last known value of any hardware watchpoint if
15133 the memory which that value represents has been written to by
15137 invalidate_bp_value_on_memory_change (struct inferior
*inferior
,
15138 CORE_ADDR addr
, ssize_t len
,
15139 const bfd_byte
*data
)
15141 struct breakpoint
*bp
;
15143 ALL_BREAKPOINTS (bp
)
15144 if (bp
->enable_state
== bp_enabled
15145 && bp
->type
== bp_hardware_watchpoint
)
15147 struct watchpoint
*wp
= (struct watchpoint
*) bp
;
15149 if (wp
->val_valid
&& wp
->val
)
15151 struct bp_location
*loc
;
15153 for (loc
= bp
->loc
; loc
!= NULL
; loc
= loc
->next
)
15154 if (loc
->loc_type
== bp_loc_hardware_watchpoint
15155 && loc
->address
+ loc
->length
> addr
15156 && addr
+ len
> loc
->address
)
15158 value_free (wp
->val
);
15166 /* Create and insert a breakpoint for software single step. */
15169 insert_single_step_breakpoint (struct gdbarch
*gdbarch
,
15170 struct address_space
*aspace
,
15173 struct thread_info
*tp
= inferior_thread ();
15174 struct symtab_and_line sal
;
15175 CORE_ADDR pc
= next_pc
;
15177 if (tp
->control
.single_step_breakpoints
== NULL
)
15179 tp
->control
.single_step_breakpoints
15180 = new_single_step_breakpoint (tp
->global_num
, gdbarch
);
15183 sal
= find_pc_line (pc
, 0);
15185 sal
.section
= find_pc_overlay (pc
);
15186 sal
.explicit_pc
= 1;
15187 add_location_to_breakpoint (tp
->control
.single_step_breakpoints
, &sal
);
15189 update_global_location_list (UGLL_INSERT
);
15192 /* Insert single step breakpoints according to the current state. */
15195 insert_single_step_breakpoints (struct gdbarch
*gdbarch
)
15197 struct frame_info
*frame
= get_current_frame ();
15198 VEC (CORE_ADDR
) * next_pcs
;
15200 next_pcs
= gdbarch_software_single_step (gdbarch
, frame
);
15202 if (next_pcs
!= NULL
)
15206 struct address_space
*aspace
= get_frame_address_space (frame
);
15208 for (i
= 0; VEC_iterate (CORE_ADDR
, next_pcs
, i
, pc
); i
++)
15209 insert_single_step_breakpoint (gdbarch
, aspace
, pc
);
15211 VEC_free (CORE_ADDR
, next_pcs
);
15219 /* See breakpoint.h. */
15222 breakpoint_has_location_inserted_here (struct breakpoint
*bp
,
15223 struct address_space
*aspace
,
15226 struct bp_location
*loc
;
15228 for (loc
= bp
->loc
; loc
!= NULL
; loc
= loc
->next
)
15230 && breakpoint_location_address_match (loc
, aspace
, pc
))
15236 /* Check whether a software single-step breakpoint is inserted at
15240 single_step_breakpoint_inserted_here_p (struct address_space
*aspace
,
15243 struct breakpoint
*bpt
;
15245 ALL_BREAKPOINTS (bpt
)
15247 if (bpt
->type
== bp_single_step
15248 && breakpoint_has_location_inserted_here (bpt
, aspace
, pc
))
15254 /* Tracepoint-specific operations. */
15256 /* Set tracepoint count to NUM. */
15258 set_tracepoint_count (int num
)
15260 tracepoint_count
= num
;
15261 set_internalvar_integer (lookup_internalvar ("tpnum"), num
);
15265 trace_command (char *arg
, int from_tty
)
15267 struct breakpoint_ops
*ops
;
15268 struct event_location
*location
;
15269 struct cleanup
*back_to
;
15271 location
= string_to_event_location (&arg
, current_language
);
15272 back_to
= make_cleanup_delete_event_location (location
);
15273 if (location
!= NULL
15274 && event_location_type (location
) == PROBE_LOCATION
)
15275 ops
= &tracepoint_probe_breakpoint_ops
;
15277 ops
= &tracepoint_breakpoint_ops
;
15279 create_breakpoint (get_current_arch (),
15281 NULL
, 0, arg
, 1 /* parse arg */,
15283 bp_tracepoint
/* type_wanted */,
15284 0 /* Ignore count */,
15285 pending_break_support
,
15289 0 /* internal */, 0);
15290 do_cleanups (back_to
);
15294 ftrace_command (char *arg
, int from_tty
)
15296 struct event_location
*location
;
15297 struct cleanup
*back_to
;
15299 location
= string_to_event_location (&arg
, current_language
);
15300 back_to
= make_cleanup_delete_event_location (location
);
15301 create_breakpoint (get_current_arch (),
15303 NULL
, 0, arg
, 1 /* parse arg */,
15305 bp_fast_tracepoint
/* type_wanted */,
15306 0 /* Ignore count */,
15307 pending_break_support
,
15308 &tracepoint_breakpoint_ops
,
15311 0 /* internal */, 0);
15312 do_cleanups (back_to
);
15315 /* strace command implementation. Creates a static tracepoint. */
15318 strace_command (char *arg
, int from_tty
)
15320 struct breakpoint_ops
*ops
;
15321 struct event_location
*location
;
15322 struct cleanup
*back_to
;
15324 /* Decide if we are dealing with a static tracepoint marker (`-m'),
15325 or with a normal static tracepoint. */
15326 if (arg
&& startswith (arg
, "-m") && isspace (arg
[2]))
15328 ops
= &strace_marker_breakpoint_ops
;
15329 location
= new_linespec_location (&arg
);
15333 ops
= &tracepoint_breakpoint_ops
;
15334 location
= string_to_event_location (&arg
, current_language
);
15337 back_to
= make_cleanup_delete_event_location (location
);
15338 create_breakpoint (get_current_arch (),
15340 NULL
, 0, arg
, 1 /* parse arg */,
15342 bp_static_tracepoint
/* type_wanted */,
15343 0 /* Ignore count */,
15344 pending_break_support
,
15348 0 /* internal */, 0);
15349 do_cleanups (back_to
);
15352 /* Set up a fake reader function that gets command lines from a linked
15353 list that was acquired during tracepoint uploading. */
15355 static struct uploaded_tp
*this_utp
;
15356 static int next_cmd
;
15359 read_uploaded_action (void)
15363 VEC_iterate (char_ptr
, this_utp
->cmd_strings
, next_cmd
, rslt
);
15370 /* Given information about a tracepoint as recorded on a target (which
15371 can be either a live system or a trace file), attempt to create an
15372 equivalent GDB tracepoint. This is not a reliable process, since
15373 the target does not necessarily have all the information used when
15374 the tracepoint was originally defined. */
15376 struct tracepoint
*
15377 create_tracepoint_from_upload (struct uploaded_tp
*utp
)
15379 char *addr_str
, small_buf
[100];
15380 struct tracepoint
*tp
;
15381 struct event_location
*location
;
15382 struct cleanup
*cleanup
;
15384 if (utp
->at_string
)
15385 addr_str
= utp
->at_string
;
15388 /* In the absence of a source location, fall back to raw
15389 address. Since there is no way to confirm that the address
15390 means the same thing as when the trace was started, warn the
15392 warning (_("Uploaded tracepoint %d has no "
15393 "source location, using raw address"),
15395 xsnprintf (small_buf
, sizeof (small_buf
), "*%s", hex_string (utp
->addr
));
15396 addr_str
= small_buf
;
15399 /* There's not much we can do with a sequence of bytecodes. */
15400 if (utp
->cond
&& !utp
->cond_string
)
15401 warning (_("Uploaded tracepoint %d condition "
15402 "has no source form, ignoring it"),
15405 location
= string_to_event_location (&addr_str
, current_language
);
15406 cleanup
= make_cleanup_delete_event_location (location
);
15407 if (!create_breakpoint (get_current_arch (),
15409 utp
->cond_string
, -1, addr_str
,
15410 0 /* parse cond/thread */,
15412 utp
->type
/* type_wanted */,
15413 0 /* Ignore count */,
15414 pending_break_support
,
15415 &tracepoint_breakpoint_ops
,
15417 utp
->enabled
/* enabled */,
15419 CREATE_BREAKPOINT_FLAGS_INSERTED
))
15421 do_cleanups (cleanup
);
15425 do_cleanups (cleanup
);
15427 /* Get the tracepoint we just created. */
15428 tp
= get_tracepoint (tracepoint_count
);
15429 gdb_assert (tp
!= NULL
);
15433 xsnprintf (small_buf
, sizeof (small_buf
), "%d %d", utp
->pass
,
15436 trace_pass_command (small_buf
, 0);
15439 /* If we have uploaded versions of the original commands, set up a
15440 special-purpose "reader" function and call the usual command line
15441 reader, then pass the result to the breakpoint command-setting
15443 if (!VEC_empty (char_ptr
, utp
->cmd_strings
))
15445 struct command_line
*cmd_list
;
15450 cmd_list
= read_command_lines_1 (read_uploaded_action
, 1, NULL
, NULL
);
15452 breakpoint_set_commands (&tp
->base
, cmd_list
);
15454 else if (!VEC_empty (char_ptr
, utp
->actions
)
15455 || !VEC_empty (char_ptr
, utp
->step_actions
))
15456 warning (_("Uploaded tracepoint %d actions "
15457 "have no source form, ignoring them"),
15460 /* Copy any status information that might be available. */
15461 tp
->base
.hit_count
= utp
->hit_count
;
15462 tp
->traceframe_usage
= utp
->traceframe_usage
;
15467 /* Print information on tracepoint number TPNUM_EXP, or all if
15471 tracepoints_info (char *args
, int from_tty
)
15473 struct ui_out
*uiout
= current_uiout
;
15476 num_printed
= breakpoint_1 (args
, 0, is_tracepoint
);
15478 if (num_printed
== 0)
15480 if (args
== NULL
|| *args
== '\0')
15481 ui_out_message (uiout
, 0, "No tracepoints.\n");
15483 ui_out_message (uiout
, 0, "No tracepoint matching '%s'.\n", args
);
15486 default_collect_info ();
15489 /* The 'enable trace' command enables tracepoints.
15490 Not supported by all targets. */
15492 enable_trace_command (char *args
, int from_tty
)
15494 enable_command (args
, from_tty
);
15497 /* The 'disable trace' command disables tracepoints.
15498 Not supported by all targets. */
15500 disable_trace_command (char *args
, int from_tty
)
15502 disable_command (args
, from_tty
);
15505 /* Remove a tracepoint (or all if no argument). */
15507 delete_trace_command (char *arg
, int from_tty
)
15509 struct breakpoint
*b
, *b_tmp
;
15515 int breaks_to_delete
= 0;
15517 /* Delete all breakpoints if no argument.
15518 Do not delete internal or call-dummy breakpoints, these
15519 have to be deleted with an explicit breakpoint number
15521 ALL_TRACEPOINTS (b
)
15522 if (is_tracepoint (b
) && user_breakpoint_p (b
))
15524 breaks_to_delete
= 1;
15528 /* Ask user only if there are some breakpoints to delete. */
15530 || (breaks_to_delete
&& query (_("Delete all tracepoints? "))))
15532 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
15533 if (is_tracepoint (b
) && user_breakpoint_p (b
))
15534 delete_breakpoint (b
);
15538 map_breakpoint_numbers (arg
, do_map_delete_breakpoint
, NULL
);
15541 /* Helper function for trace_pass_command. */
15544 trace_pass_set_count (struct tracepoint
*tp
, int count
, int from_tty
)
15546 tp
->pass_count
= count
;
15547 observer_notify_breakpoint_modified (&tp
->base
);
15549 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
15550 tp
->base
.number
, count
);
15553 /* Set passcount for tracepoint.
15555 First command argument is passcount, second is tracepoint number.
15556 If tracepoint number omitted, apply to most recently defined.
15557 Also accepts special argument "all". */
15560 trace_pass_command (char *args
, int from_tty
)
15562 struct tracepoint
*t1
;
15563 unsigned int count
;
15565 if (args
== 0 || *args
== 0)
15566 error (_("passcount command requires an "
15567 "argument (count + optional TP num)"));
15569 count
= strtoul (args
, &args
, 10); /* Count comes first, then TP num. */
15571 args
= skip_spaces (args
);
15572 if (*args
&& strncasecmp (args
, "all", 3) == 0)
15574 struct breakpoint
*b
;
15576 args
+= 3; /* Skip special argument "all". */
15578 error (_("Junk at end of arguments."));
15580 ALL_TRACEPOINTS (b
)
15582 t1
= (struct tracepoint
*) b
;
15583 trace_pass_set_count (t1
, count
, from_tty
);
15586 else if (*args
== '\0')
15588 t1
= get_tracepoint_by_number (&args
, NULL
);
15590 trace_pass_set_count (t1
, count
, from_tty
);
15594 number_or_range_parser
parser (args
);
15595 while (!parser
.finished ())
15597 t1
= get_tracepoint_by_number (&args
, &parser
);
15599 trace_pass_set_count (t1
, count
, from_tty
);
15604 struct tracepoint
*
15605 get_tracepoint (int num
)
15607 struct breakpoint
*t
;
15609 ALL_TRACEPOINTS (t
)
15610 if (t
->number
== num
)
15611 return (struct tracepoint
*) t
;
15616 /* Find the tracepoint with the given target-side number (which may be
15617 different from the tracepoint number after disconnecting and
15620 struct tracepoint
*
15621 get_tracepoint_by_number_on_target (int num
)
15623 struct breakpoint
*b
;
15625 ALL_TRACEPOINTS (b
)
15627 struct tracepoint
*t
= (struct tracepoint
*) b
;
15629 if (t
->number_on_target
== num
)
15636 /* Utility: parse a tracepoint number and look it up in the list.
15637 If STATE is not NULL, use, get_number_or_range_state and ignore ARG.
15638 If the argument is missing, the most recent tracepoint
15639 (tracepoint_count) is returned. */
15641 struct tracepoint
*
15642 get_tracepoint_by_number (char **arg
,
15643 number_or_range_parser
*parser
)
15645 struct breakpoint
*t
;
15647 char *instring
= arg
== NULL
? NULL
: *arg
;
15649 if (parser
!= NULL
)
15651 gdb_assert (!parser
->finished ());
15652 tpnum
= parser
->get_number ();
15654 else if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
15655 tpnum
= tracepoint_count
;
15657 tpnum
= get_number (arg
);
15661 if (instring
&& *instring
)
15662 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
15665 printf_filtered (_("No previous tracepoint\n"));
15669 ALL_TRACEPOINTS (t
)
15670 if (t
->number
== tpnum
)
15672 return (struct tracepoint
*) t
;
15675 printf_unfiltered ("No tracepoint number %d.\n", tpnum
);
15680 print_recreate_thread (struct breakpoint
*b
, struct ui_file
*fp
)
15682 if (b
->thread
!= -1)
15683 fprintf_unfiltered (fp
, " thread %d", b
->thread
);
15686 fprintf_unfiltered (fp
, " task %d", b
->task
);
15688 fprintf_unfiltered (fp
, "\n");
15691 /* Save information on user settable breakpoints (watchpoints, etc) to
15692 a new script file named FILENAME. If FILTER is non-NULL, call it
15693 on each breakpoint and only include the ones for which it returns
15697 save_breakpoints (char *filename
, int from_tty
,
15698 int (*filter
) (const struct breakpoint
*))
15700 struct breakpoint
*tp
;
15702 struct cleanup
*cleanup
;
15703 struct ui_file
*fp
;
15704 int extra_trace_bits
= 0;
15706 if (filename
== 0 || *filename
== 0)
15707 error (_("Argument required (file name in which to save)"));
15709 /* See if we have anything to save. */
15710 ALL_BREAKPOINTS (tp
)
15712 /* Skip internal and momentary breakpoints. */
15713 if (!user_breakpoint_p (tp
))
15716 /* If we have a filter, only save the breakpoints it accepts. */
15717 if (filter
&& !filter (tp
))
15722 if (is_tracepoint (tp
))
15724 extra_trace_bits
= 1;
15726 /* We can stop searching. */
15733 warning (_("Nothing to save."));
15737 filename
= tilde_expand (filename
);
15738 cleanup
= make_cleanup (xfree
, filename
);
15739 fp
= gdb_fopen (filename
, "w");
15741 error (_("Unable to open file '%s' for saving (%s)"),
15742 filename
, safe_strerror (errno
));
15743 make_cleanup_ui_file_delete (fp
);
15745 if (extra_trace_bits
)
15746 save_trace_state_variables (fp
);
15748 ALL_BREAKPOINTS (tp
)
15750 /* Skip internal and momentary breakpoints. */
15751 if (!user_breakpoint_p (tp
))
15754 /* If we have a filter, only save the breakpoints it accepts. */
15755 if (filter
&& !filter (tp
))
15758 tp
->ops
->print_recreate (tp
, fp
);
15760 /* Note, we can't rely on tp->number for anything, as we can't
15761 assume the recreated breakpoint numbers will match. Use $bpnum
15764 if (tp
->cond_string
)
15765 fprintf_unfiltered (fp
, " condition $bpnum %s\n", tp
->cond_string
);
15767 if (tp
->ignore_count
)
15768 fprintf_unfiltered (fp
, " ignore $bpnum %d\n", tp
->ignore_count
);
15770 if (tp
->type
!= bp_dprintf
&& tp
->commands
)
15772 fprintf_unfiltered (fp
, " commands\n");
15774 ui_out_redirect (current_uiout
, fp
);
15777 print_command_lines (current_uiout
, tp
->commands
->commands
, 2);
15779 CATCH (ex
, RETURN_MASK_ALL
)
15781 ui_out_redirect (current_uiout
, NULL
);
15782 throw_exception (ex
);
15786 ui_out_redirect (current_uiout
, NULL
);
15787 fprintf_unfiltered (fp
, " end\n");
15790 if (tp
->enable_state
== bp_disabled
)
15791 fprintf_unfiltered (fp
, "disable $bpnum\n");
15793 /* If this is a multi-location breakpoint, check if the locations
15794 should be individually disabled. Watchpoint locations are
15795 special, and not user visible. */
15796 if (!is_watchpoint (tp
) && tp
->loc
&& tp
->loc
->next
)
15798 struct bp_location
*loc
;
15801 for (loc
= tp
->loc
; loc
!= NULL
; loc
= loc
->next
, n
++)
15803 fprintf_unfiltered (fp
, "disable $bpnum.%d\n", n
);
15807 if (extra_trace_bits
&& *default_collect
)
15808 fprintf_unfiltered (fp
, "set default-collect %s\n", default_collect
);
15811 printf_filtered (_("Saved to file '%s'.\n"), filename
);
15812 do_cleanups (cleanup
);
15815 /* The `save breakpoints' command. */
15818 save_breakpoints_command (char *args
, int from_tty
)
15820 save_breakpoints (args
, from_tty
, NULL
);
15823 /* The `save tracepoints' command. */
15826 save_tracepoints_command (char *args
, int from_tty
)
15828 save_breakpoints (args
, from_tty
, is_tracepoint
);
15831 /* Create a vector of all tracepoints. */
15833 VEC(breakpoint_p
) *
15834 all_tracepoints (void)
15836 VEC(breakpoint_p
) *tp_vec
= 0;
15837 struct breakpoint
*tp
;
15839 ALL_TRACEPOINTS (tp
)
15841 VEC_safe_push (breakpoint_p
, tp_vec
, tp
);
15848 /* This help string is used to consolidate all the help string for specifying
15849 locations used by several commands. */
15851 #define LOCATION_HELP_STRING \
15852 "Linespecs are colon-separated lists of location parameters, such as\n\
15853 source filename, function name, label name, and line number.\n\
15854 Example: To specify the start of a label named \"the_top\" in the\n\
15855 function \"fact\" in the file \"factorial.c\", use\n\
15856 \"factorial.c:fact:the_top\".\n\
15858 Address locations begin with \"*\" and specify an exact address in the\n\
15859 program. Example: To specify the fourth byte past the start function\n\
15860 \"main\", use \"*main + 4\".\n\
15862 Explicit locations are similar to linespecs but use an option/argument\n\
15863 syntax to specify location parameters.\n\
15864 Example: To specify the start of the label named \"the_top\" in the\n\
15865 function \"fact\" in the file \"factorial.c\", use \"-source factorial.c\n\
15866 -function fact -label the_top\".\n"
15868 /* This help string is used for the break, hbreak, tbreak and thbreak
15869 commands. It is defined as a macro to prevent duplication.
15870 COMMAND should be a string constant containing the name of the
15873 #define BREAK_ARGS_HELP(command) \
15874 command" [PROBE_MODIFIER] [LOCATION] [thread THREADNUM] [if CONDITION]\n\
15875 PROBE_MODIFIER shall be present if the command is to be placed in a\n\
15876 probe point. Accepted values are `-probe' (for a generic, automatically\n\
15877 guessed probe type), `-probe-stap' (for a SystemTap probe) or \n\
15878 `-probe-dtrace' (for a DTrace probe).\n\
15879 LOCATION may be a linespec, address, or explicit location as described\n\
15882 With no LOCATION, uses current execution address of the selected\n\
15883 stack frame. This is useful for breaking on return to a stack frame.\n\
15885 THREADNUM is the number from \"info threads\".\n\
15886 CONDITION is a boolean expression.\n\
15887 \n" LOCATION_HELP_STRING "\n\
15888 Multiple breakpoints at one place are permitted, and useful if their\n\
15889 conditions are different.\n\
15891 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
15893 /* List of subcommands for "catch". */
15894 static struct cmd_list_element
*catch_cmdlist
;
15896 /* List of subcommands for "tcatch". */
15897 static struct cmd_list_element
*tcatch_cmdlist
;
15900 add_catch_command (char *name
, char *docstring
,
15901 cmd_sfunc_ftype
*sfunc
,
15902 completer_ftype
*completer
,
15903 void *user_data_catch
,
15904 void *user_data_tcatch
)
15906 struct cmd_list_element
*command
;
15908 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
15910 set_cmd_sfunc (command
, sfunc
);
15911 set_cmd_context (command
, user_data_catch
);
15912 set_cmd_completer (command
, completer
);
15914 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
15916 set_cmd_sfunc (command
, sfunc
);
15917 set_cmd_context (command
, user_data_tcatch
);
15918 set_cmd_completer (command
, completer
);
15922 save_command (char *arg
, int from_tty
)
15924 printf_unfiltered (_("\"save\" must be followed by "
15925 "the name of a save subcommand.\n"));
15926 help_list (save_cmdlist
, "save ", all_commands
, gdb_stdout
);
15929 struct breakpoint
*
15930 iterate_over_breakpoints (int (*callback
) (struct breakpoint
*, void *),
15933 struct breakpoint
*b
, *b_tmp
;
15935 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
15937 if ((*callback
) (b
, data
))
15944 /* Zero if any of the breakpoint's locations could be a location where
15945 functions have been inlined, nonzero otherwise. */
15948 is_non_inline_function (struct breakpoint
*b
)
15950 /* The shared library event breakpoint is set on the address of a
15951 non-inline function. */
15952 if (b
->type
== bp_shlib_event
)
15958 /* Nonzero if the specified PC cannot be a location where functions
15959 have been inlined. */
15962 pc_at_non_inline_function (struct address_space
*aspace
, CORE_ADDR pc
,
15963 const struct target_waitstatus
*ws
)
15965 struct breakpoint
*b
;
15966 struct bp_location
*bl
;
15968 ALL_BREAKPOINTS (b
)
15970 if (!is_non_inline_function (b
))
15973 for (bl
= b
->loc
; bl
!= NULL
; bl
= bl
->next
)
15975 if (!bl
->shlib_disabled
15976 && bpstat_check_location (bl
, aspace
, pc
, ws
))
15984 /* Remove any references to OBJFILE which is going to be freed. */
15987 breakpoint_free_objfile (struct objfile
*objfile
)
15989 struct bp_location
**locp
, *loc
;
15991 ALL_BP_LOCATIONS (loc
, locp
)
15992 if (loc
->symtab
!= NULL
&& SYMTAB_OBJFILE (loc
->symtab
) == objfile
)
15993 loc
->symtab
= NULL
;
15997 initialize_breakpoint_ops (void)
15999 static int initialized
= 0;
16001 struct breakpoint_ops
*ops
;
16007 /* The breakpoint_ops structure to be inherit by all kinds of
16008 breakpoints (real breakpoints, i.e., user "break" breakpoints,
16009 internal and momentary breakpoints, etc.). */
16010 ops
= &bkpt_base_breakpoint_ops
;
16011 *ops
= base_breakpoint_ops
;
16012 ops
->re_set
= bkpt_re_set
;
16013 ops
->insert_location
= bkpt_insert_location
;
16014 ops
->remove_location
= bkpt_remove_location
;
16015 ops
->breakpoint_hit
= bkpt_breakpoint_hit
;
16016 ops
->create_sals_from_location
= bkpt_create_sals_from_location
;
16017 ops
->create_breakpoints_sal
= bkpt_create_breakpoints_sal
;
16018 ops
->decode_location
= bkpt_decode_location
;
16020 /* The breakpoint_ops structure to be used in regular breakpoints. */
16021 ops
= &bkpt_breakpoint_ops
;
16022 *ops
= bkpt_base_breakpoint_ops
;
16023 ops
->re_set
= bkpt_re_set
;
16024 ops
->resources_needed
= bkpt_resources_needed
;
16025 ops
->print_it
= bkpt_print_it
;
16026 ops
->print_mention
= bkpt_print_mention
;
16027 ops
->print_recreate
= bkpt_print_recreate
;
16029 /* Ranged breakpoints. */
16030 ops
= &ranged_breakpoint_ops
;
16031 *ops
= bkpt_breakpoint_ops
;
16032 ops
->breakpoint_hit
= breakpoint_hit_ranged_breakpoint
;
16033 ops
->resources_needed
= resources_needed_ranged_breakpoint
;
16034 ops
->print_it
= print_it_ranged_breakpoint
;
16035 ops
->print_one
= print_one_ranged_breakpoint
;
16036 ops
->print_one_detail
= print_one_detail_ranged_breakpoint
;
16037 ops
->print_mention
= print_mention_ranged_breakpoint
;
16038 ops
->print_recreate
= print_recreate_ranged_breakpoint
;
16040 /* Internal breakpoints. */
16041 ops
= &internal_breakpoint_ops
;
16042 *ops
= bkpt_base_breakpoint_ops
;
16043 ops
->re_set
= internal_bkpt_re_set
;
16044 ops
->check_status
= internal_bkpt_check_status
;
16045 ops
->print_it
= internal_bkpt_print_it
;
16046 ops
->print_mention
= internal_bkpt_print_mention
;
16048 /* Momentary breakpoints. */
16049 ops
= &momentary_breakpoint_ops
;
16050 *ops
= bkpt_base_breakpoint_ops
;
16051 ops
->re_set
= momentary_bkpt_re_set
;
16052 ops
->check_status
= momentary_bkpt_check_status
;
16053 ops
->print_it
= momentary_bkpt_print_it
;
16054 ops
->print_mention
= momentary_bkpt_print_mention
;
16056 /* Momentary breakpoints for bp_longjmp and bp_exception. */
16057 ops
= &longjmp_breakpoint_ops
;
16058 *ops
= momentary_breakpoint_ops
;
16059 ops
->dtor
= longjmp_bkpt_dtor
;
16061 /* Probe breakpoints. */
16062 ops
= &bkpt_probe_breakpoint_ops
;
16063 *ops
= bkpt_breakpoint_ops
;
16064 ops
->insert_location
= bkpt_probe_insert_location
;
16065 ops
->remove_location
= bkpt_probe_remove_location
;
16066 ops
->create_sals_from_location
= bkpt_probe_create_sals_from_location
;
16067 ops
->decode_location
= bkpt_probe_decode_location
;
16070 ops
= &watchpoint_breakpoint_ops
;
16071 *ops
= base_breakpoint_ops
;
16072 ops
->dtor
= dtor_watchpoint
;
16073 ops
->re_set
= re_set_watchpoint
;
16074 ops
->insert_location
= insert_watchpoint
;
16075 ops
->remove_location
= remove_watchpoint
;
16076 ops
->breakpoint_hit
= breakpoint_hit_watchpoint
;
16077 ops
->check_status
= check_status_watchpoint
;
16078 ops
->resources_needed
= resources_needed_watchpoint
;
16079 ops
->works_in_software_mode
= works_in_software_mode_watchpoint
;
16080 ops
->print_it
= print_it_watchpoint
;
16081 ops
->print_mention
= print_mention_watchpoint
;
16082 ops
->print_recreate
= print_recreate_watchpoint
;
16083 ops
->explains_signal
= explains_signal_watchpoint
;
16085 /* Masked watchpoints. */
16086 ops
= &masked_watchpoint_breakpoint_ops
;
16087 *ops
= watchpoint_breakpoint_ops
;
16088 ops
->insert_location
= insert_masked_watchpoint
;
16089 ops
->remove_location
= remove_masked_watchpoint
;
16090 ops
->resources_needed
= resources_needed_masked_watchpoint
;
16091 ops
->works_in_software_mode
= works_in_software_mode_masked_watchpoint
;
16092 ops
->print_it
= print_it_masked_watchpoint
;
16093 ops
->print_one_detail
= print_one_detail_masked_watchpoint
;
16094 ops
->print_mention
= print_mention_masked_watchpoint
;
16095 ops
->print_recreate
= print_recreate_masked_watchpoint
;
16098 ops
= &tracepoint_breakpoint_ops
;
16099 *ops
= base_breakpoint_ops
;
16100 ops
->re_set
= tracepoint_re_set
;
16101 ops
->breakpoint_hit
= tracepoint_breakpoint_hit
;
16102 ops
->print_one_detail
= tracepoint_print_one_detail
;
16103 ops
->print_mention
= tracepoint_print_mention
;
16104 ops
->print_recreate
= tracepoint_print_recreate
;
16105 ops
->create_sals_from_location
= tracepoint_create_sals_from_location
;
16106 ops
->create_breakpoints_sal
= tracepoint_create_breakpoints_sal
;
16107 ops
->decode_location
= tracepoint_decode_location
;
16109 /* Probe tracepoints. */
16110 ops
= &tracepoint_probe_breakpoint_ops
;
16111 *ops
= tracepoint_breakpoint_ops
;
16112 ops
->create_sals_from_location
= tracepoint_probe_create_sals_from_location
;
16113 ops
->decode_location
= tracepoint_probe_decode_location
;
16115 /* Static tracepoints with marker (`-m'). */
16116 ops
= &strace_marker_breakpoint_ops
;
16117 *ops
= tracepoint_breakpoint_ops
;
16118 ops
->create_sals_from_location
= strace_marker_create_sals_from_location
;
16119 ops
->create_breakpoints_sal
= strace_marker_create_breakpoints_sal
;
16120 ops
->decode_location
= strace_marker_decode_location
;
16122 /* Fork catchpoints. */
16123 ops
= &catch_fork_breakpoint_ops
;
16124 *ops
= base_breakpoint_ops
;
16125 ops
->insert_location
= insert_catch_fork
;
16126 ops
->remove_location
= remove_catch_fork
;
16127 ops
->breakpoint_hit
= breakpoint_hit_catch_fork
;
16128 ops
->print_it
= print_it_catch_fork
;
16129 ops
->print_one
= print_one_catch_fork
;
16130 ops
->print_mention
= print_mention_catch_fork
;
16131 ops
->print_recreate
= print_recreate_catch_fork
;
16133 /* Vfork catchpoints. */
16134 ops
= &catch_vfork_breakpoint_ops
;
16135 *ops
= base_breakpoint_ops
;
16136 ops
->insert_location
= insert_catch_vfork
;
16137 ops
->remove_location
= remove_catch_vfork
;
16138 ops
->breakpoint_hit
= breakpoint_hit_catch_vfork
;
16139 ops
->print_it
= print_it_catch_vfork
;
16140 ops
->print_one
= print_one_catch_vfork
;
16141 ops
->print_mention
= print_mention_catch_vfork
;
16142 ops
->print_recreate
= print_recreate_catch_vfork
;
16144 /* Exec catchpoints. */
16145 ops
= &catch_exec_breakpoint_ops
;
16146 *ops
= base_breakpoint_ops
;
16147 ops
->dtor
= dtor_catch_exec
;
16148 ops
->insert_location
= insert_catch_exec
;
16149 ops
->remove_location
= remove_catch_exec
;
16150 ops
->breakpoint_hit
= breakpoint_hit_catch_exec
;
16151 ops
->print_it
= print_it_catch_exec
;
16152 ops
->print_one
= print_one_catch_exec
;
16153 ops
->print_mention
= print_mention_catch_exec
;
16154 ops
->print_recreate
= print_recreate_catch_exec
;
16156 /* Solib-related catchpoints. */
16157 ops
= &catch_solib_breakpoint_ops
;
16158 *ops
= base_breakpoint_ops
;
16159 ops
->dtor
= dtor_catch_solib
;
16160 ops
->insert_location
= insert_catch_solib
;
16161 ops
->remove_location
= remove_catch_solib
;
16162 ops
->breakpoint_hit
= breakpoint_hit_catch_solib
;
16163 ops
->check_status
= check_status_catch_solib
;
16164 ops
->print_it
= print_it_catch_solib
;
16165 ops
->print_one
= print_one_catch_solib
;
16166 ops
->print_mention
= print_mention_catch_solib
;
16167 ops
->print_recreate
= print_recreate_catch_solib
;
16169 ops
= &dprintf_breakpoint_ops
;
16170 *ops
= bkpt_base_breakpoint_ops
;
16171 ops
->re_set
= dprintf_re_set
;
16172 ops
->resources_needed
= bkpt_resources_needed
;
16173 ops
->print_it
= bkpt_print_it
;
16174 ops
->print_mention
= bkpt_print_mention
;
16175 ops
->print_recreate
= dprintf_print_recreate
;
16176 ops
->after_condition_true
= dprintf_after_condition_true
;
16177 ops
->breakpoint_hit
= dprintf_breakpoint_hit
;
16180 /* Chain containing all defined "enable breakpoint" subcommands. */
16182 static struct cmd_list_element
*enablebreaklist
= NULL
;
16185 _initialize_breakpoint (void)
16187 struct cmd_list_element
*c
;
16189 initialize_breakpoint_ops ();
16191 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
16192 observer_attach_free_objfile (disable_breakpoints_in_freed_objfile
);
16193 observer_attach_memory_changed (invalidate_bp_value_on_memory_change
);
16195 breakpoint_objfile_key
16196 = register_objfile_data_with_cleanup (NULL
, free_breakpoint_probes
);
16198 breakpoint_chain
= 0;
16199 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
16200 before a breakpoint is set. */
16201 breakpoint_count
= 0;
16203 tracepoint_count
= 0;
16205 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
16206 Set ignore-count of breakpoint number N to COUNT.\n\
16207 Usage is `ignore N COUNT'."));
16209 add_com ("commands", class_breakpoint
, commands_command
, _("\
16210 Set commands to be executed when a breakpoint is hit.\n\
16211 Give breakpoint number as argument after \"commands\".\n\
16212 With no argument, the targeted breakpoint is the last one set.\n\
16213 The commands themselves follow starting on the next line.\n\
16214 Type a line containing \"end\" to indicate the end of them.\n\
16215 Give \"silent\" as the first line to make the breakpoint silent;\n\
16216 then no output is printed when it is hit, except what the commands print."));
16218 c
= add_com ("condition", class_breakpoint
, condition_command
, _("\
16219 Specify breakpoint number N to break only if COND is true.\n\
16220 Usage is `condition N COND', where N is an integer and COND is an\n\
16221 expression to be evaluated whenever breakpoint N is reached."));
16222 set_cmd_completer (c
, condition_completer
);
16224 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
16225 Set a temporary breakpoint.\n\
16226 Like \"break\" except the breakpoint is only temporary,\n\
16227 so it will be deleted when hit. Equivalent to \"break\" followed\n\
16228 by using \"enable delete\" on the breakpoint number.\n\
16230 BREAK_ARGS_HELP ("tbreak")));
16231 set_cmd_completer (c
, location_completer
);
16233 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
16234 Set a hardware assisted breakpoint.\n\
16235 Like \"break\" except the breakpoint requires hardware support,\n\
16236 some target hardware may not have this support.\n\
16238 BREAK_ARGS_HELP ("hbreak")));
16239 set_cmd_completer (c
, location_completer
);
16241 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
16242 Set a temporary hardware assisted breakpoint.\n\
16243 Like \"hbreak\" except the breakpoint is only temporary,\n\
16244 so it will be deleted when hit.\n\
16246 BREAK_ARGS_HELP ("thbreak")));
16247 set_cmd_completer (c
, location_completer
);
16249 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
16250 Enable some breakpoints.\n\
16251 Give breakpoint numbers (separated by spaces) as arguments.\n\
16252 With no subcommand, breakpoints are enabled until you command otherwise.\n\
16253 This is used to cancel the effect of the \"disable\" command.\n\
16254 With a subcommand you can enable temporarily."),
16255 &enablelist
, "enable ", 1, &cmdlist
);
16257 add_com_alias ("en", "enable", class_breakpoint
, 1);
16259 add_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
16260 Enable some breakpoints.\n\
16261 Give breakpoint numbers (separated by spaces) as arguments.\n\
16262 This is used to cancel the effect of the \"disable\" command.\n\
16263 May be abbreviated to simply \"enable\".\n"),
16264 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
16266 add_cmd ("once", no_class
, enable_once_command
, _("\
16267 Enable breakpoints for one hit. Give breakpoint numbers.\n\
16268 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
16271 add_cmd ("delete", no_class
, enable_delete_command
, _("\
16272 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
16273 If a breakpoint is hit while enabled in this fashion, it is deleted."),
16276 add_cmd ("count", no_class
, enable_count_command
, _("\
16277 Enable breakpoints for COUNT hits. Give count and then breakpoint numbers.\n\
16278 If a breakpoint is hit while enabled in this fashion,\n\
16279 the count is decremented; when it reaches zero, the breakpoint is disabled."),
16282 add_cmd ("delete", no_class
, enable_delete_command
, _("\
16283 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
16284 If a breakpoint is hit while enabled in this fashion, it is deleted."),
16287 add_cmd ("once", no_class
, enable_once_command
, _("\
16288 Enable breakpoints for one hit. Give breakpoint numbers.\n\
16289 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
16292 add_cmd ("count", no_class
, enable_count_command
, _("\
16293 Enable breakpoints for COUNT hits. Give count and then breakpoint numbers.\n\
16294 If a breakpoint is hit while enabled in this fashion,\n\
16295 the count is decremented; when it reaches zero, the breakpoint is disabled."),
16298 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
16299 Disable some breakpoints.\n\
16300 Arguments are breakpoint numbers with spaces in between.\n\
16301 To disable all breakpoints, give no argument.\n\
16302 A disabled breakpoint is not forgotten, but has no effect until re-enabled."),
16303 &disablelist
, "disable ", 1, &cmdlist
);
16304 add_com_alias ("dis", "disable", class_breakpoint
, 1);
16305 add_com_alias ("disa", "disable", class_breakpoint
, 1);
16307 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
16308 Disable some breakpoints.\n\
16309 Arguments are breakpoint numbers with spaces in between.\n\
16310 To disable all breakpoints, give no argument.\n\
16311 A disabled breakpoint is not forgotten, but has no effect until re-enabled.\n\
16312 This command may be abbreviated \"disable\"."),
16315 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
16316 Delete some breakpoints or auto-display expressions.\n\
16317 Arguments are breakpoint numbers with spaces in between.\n\
16318 To delete all breakpoints, give no argument.\n\
16320 Also a prefix command for deletion of other GDB objects.\n\
16321 The \"unset\" command is also an alias for \"delete\"."),
16322 &deletelist
, "delete ", 1, &cmdlist
);
16323 add_com_alias ("d", "delete", class_breakpoint
, 1);
16324 add_com_alias ("del", "delete", class_breakpoint
, 1);
16326 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
16327 Delete some breakpoints or auto-display expressions.\n\
16328 Arguments are breakpoint numbers with spaces in between.\n\
16329 To delete all breakpoints, give no argument.\n\
16330 This command may be abbreviated \"delete\"."),
16333 add_com ("clear", class_breakpoint
, clear_command
, _("\
16334 Clear breakpoint at specified location.\n\
16335 Argument may be a linespec, explicit, or address location as described below.\n\
16337 With no argument, clears all breakpoints in the line that the selected frame\n\
16338 is executing in.\n"
16339 "\n" LOCATION_HELP_STRING
"\n\
16340 See also the \"delete\" command which clears breakpoints by number."));
16341 add_com_alias ("cl", "clear", class_breakpoint
, 1);
16343 c
= add_com ("break", class_breakpoint
, break_command
, _("\
16344 Set breakpoint at specified location.\n"
16345 BREAK_ARGS_HELP ("break")));
16346 set_cmd_completer (c
, location_completer
);
16348 add_com_alias ("b", "break", class_run
, 1);
16349 add_com_alias ("br", "break", class_run
, 1);
16350 add_com_alias ("bre", "break", class_run
, 1);
16351 add_com_alias ("brea", "break", class_run
, 1);
16355 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
16356 Break in function/address or break at a line in the current file."),
16357 &stoplist
, "stop ", 1, &cmdlist
);
16358 add_cmd ("in", class_breakpoint
, stopin_command
,
16359 _("Break in function or address."), &stoplist
);
16360 add_cmd ("at", class_breakpoint
, stopat_command
,
16361 _("Break at a line in the current file."), &stoplist
);
16362 add_com ("status", class_info
, breakpoints_info
, _("\
16363 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
16364 The \"Type\" column indicates one of:\n\
16365 \tbreakpoint - normal breakpoint\n\
16366 \twatchpoint - watchpoint\n\
16367 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
16368 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
16369 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
16370 address and file/line number respectively.\n\
16372 Convenience variable \"$_\" and default examine address for \"x\"\n\
16373 are set to the address of the last breakpoint listed unless the command\n\
16374 is prefixed with \"server \".\n\n\
16375 Convenience variable \"$bpnum\" contains the number of the last\n\
16376 breakpoint set."));
16379 add_info ("breakpoints", breakpoints_info
, _("\
16380 Status of specified breakpoints (all user-settable breakpoints if no argument).\n\
16381 The \"Type\" column indicates one of:\n\
16382 \tbreakpoint - normal breakpoint\n\
16383 \twatchpoint - watchpoint\n\
16384 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
16385 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
16386 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
16387 address and file/line number respectively.\n\
16389 Convenience variable \"$_\" and default examine address for \"x\"\n\
16390 are set to the address of the last breakpoint listed unless the command\n\
16391 is prefixed with \"server \".\n\n\
16392 Convenience variable \"$bpnum\" contains the number of the last\n\
16393 breakpoint set."));
16395 add_info_alias ("b", "breakpoints", 1);
16397 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
16398 Status of all breakpoints, or breakpoint number NUMBER.\n\
16399 The \"Type\" column indicates one of:\n\
16400 \tbreakpoint - normal breakpoint\n\
16401 \twatchpoint - watchpoint\n\
16402 \tlongjmp - internal breakpoint used to step through longjmp()\n\
16403 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
16404 \tuntil - internal breakpoint used by the \"until\" command\n\
16405 \tfinish - internal breakpoint used by the \"finish\" command\n\
16406 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
16407 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
16408 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
16409 address and file/line number respectively.\n\
16411 Convenience variable \"$_\" and default examine address for \"x\"\n\
16412 are set to the address of the last breakpoint listed unless the command\n\
16413 is prefixed with \"server \".\n\n\
16414 Convenience variable \"$bpnum\" contains the number of the last\n\
16416 &maintenanceinfolist
);
16418 add_prefix_cmd ("catch", class_breakpoint
, catch_command
, _("\
16419 Set catchpoints to catch events."),
16420 &catch_cmdlist
, "catch ",
16421 0/*allow-unknown*/, &cmdlist
);
16423 add_prefix_cmd ("tcatch", class_breakpoint
, tcatch_command
, _("\
16424 Set temporary catchpoints to catch events."),
16425 &tcatch_cmdlist
, "tcatch ",
16426 0/*allow-unknown*/, &cmdlist
);
16428 add_catch_command ("fork", _("Catch calls to fork."),
16429 catch_fork_command_1
,
16431 (void *) (uintptr_t) catch_fork_permanent
,
16432 (void *) (uintptr_t) catch_fork_temporary
);
16433 add_catch_command ("vfork", _("Catch calls to vfork."),
16434 catch_fork_command_1
,
16436 (void *) (uintptr_t) catch_vfork_permanent
,
16437 (void *) (uintptr_t) catch_vfork_temporary
);
16438 add_catch_command ("exec", _("Catch calls to exec."),
16439 catch_exec_command_1
,
16443 add_catch_command ("load", _("Catch loads of shared libraries.\n\
16444 Usage: catch load [REGEX]\n\
16445 If REGEX is given, only stop for libraries matching the regular expression."),
16446 catch_load_command_1
,
16450 add_catch_command ("unload", _("Catch unloads of shared libraries.\n\
16451 Usage: catch unload [REGEX]\n\
16452 If REGEX is given, only stop for libraries matching the regular expression."),
16453 catch_unload_command_1
,
16458 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
16459 Set a watchpoint for an expression.\n\
16460 Usage: watch [-l|-location] EXPRESSION\n\
16461 A watchpoint stops execution of your program whenever the value of\n\
16462 an expression changes.\n\
16463 If -l or -location is given, this evaluates EXPRESSION and watches\n\
16464 the memory to which it refers."));
16465 set_cmd_completer (c
, expression_completer
);
16467 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
16468 Set a read watchpoint for an expression.\n\
16469 Usage: rwatch [-l|-location] EXPRESSION\n\
16470 A watchpoint stops execution of your program whenever the value of\n\
16471 an expression is read.\n\
16472 If -l or -location is given, this evaluates EXPRESSION and watches\n\
16473 the memory to which it refers."));
16474 set_cmd_completer (c
, expression_completer
);
16476 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
16477 Set a watchpoint for an expression.\n\
16478 Usage: awatch [-l|-location] EXPRESSION\n\
16479 A watchpoint stops execution of your program whenever the value of\n\
16480 an expression is either read or written.\n\
16481 If -l or -location is given, this evaluates EXPRESSION and watches\n\
16482 the memory to which it refers."));
16483 set_cmd_completer (c
, expression_completer
);
16485 add_info ("watchpoints", watchpoints_info
, _("\
16486 Status of specified watchpoints (all watchpoints if no argument)."));
16488 /* XXX: cagney/2005-02-23: This should be a boolean, and should
16489 respond to changes - contrary to the description. */
16490 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
16491 &can_use_hw_watchpoints
, _("\
16492 Set debugger's willingness to use watchpoint hardware."), _("\
16493 Show debugger's willingness to use watchpoint hardware."), _("\
16494 If zero, gdb will not use hardware for new watchpoints, even if\n\
16495 such is available. (However, any hardware watchpoints that were\n\
16496 created before setting this to nonzero, will continue to use watchpoint\n\
16499 show_can_use_hw_watchpoints
,
16500 &setlist
, &showlist
);
16502 can_use_hw_watchpoints
= 1;
16504 /* Tracepoint manipulation commands. */
16506 c
= add_com ("trace", class_breakpoint
, trace_command
, _("\
16507 Set a tracepoint at specified location.\n\
16509 BREAK_ARGS_HELP ("trace") "\n\
16510 Do \"help tracepoints\" for info on other tracepoint commands."));
16511 set_cmd_completer (c
, location_completer
);
16513 add_com_alias ("tp", "trace", class_alias
, 0);
16514 add_com_alias ("tr", "trace", class_alias
, 1);
16515 add_com_alias ("tra", "trace", class_alias
, 1);
16516 add_com_alias ("trac", "trace", class_alias
, 1);
16518 c
= add_com ("ftrace", class_breakpoint
, ftrace_command
, _("\
16519 Set a fast tracepoint at specified location.\n\
16521 BREAK_ARGS_HELP ("ftrace") "\n\
16522 Do \"help tracepoints\" for info on other tracepoint commands."));
16523 set_cmd_completer (c
, location_completer
);
16525 c
= add_com ("strace", class_breakpoint
, strace_command
, _("\
16526 Set a static tracepoint at location or marker.\n\
16528 strace [LOCATION] [if CONDITION]\n\
16529 LOCATION may be a linespec, explicit, or address location (described below) \n\
16530 or -m MARKER_ID.\n\n\
16531 If a marker id is specified, probe the marker with that name. With\n\
16532 no LOCATION, uses current execution address of the selected stack frame.\n\
16533 Static tracepoints accept an extra collect action -- ``collect $_sdata''.\n\
16534 This collects arbitrary user data passed in the probe point call to the\n\
16535 tracing library. You can inspect it when analyzing the trace buffer,\n\
16536 by printing the $_sdata variable like any other convenience variable.\n\
16538 CONDITION is a boolean expression.\n\
16539 \n" LOCATION_HELP_STRING
"\n\
16540 Multiple tracepoints at one place are permitted, and useful if their\n\
16541 conditions are different.\n\
16543 Do \"help breakpoints\" for info on other commands dealing with breakpoints.\n\
16544 Do \"help tracepoints\" for info on other tracepoint commands."));
16545 set_cmd_completer (c
, location_completer
);
16547 add_info ("tracepoints", tracepoints_info
, _("\
16548 Status of specified tracepoints (all tracepoints if no argument).\n\
16549 Convenience variable \"$tpnum\" contains the number of the\n\
16550 last tracepoint set."));
16552 add_info_alias ("tp", "tracepoints", 1);
16554 add_cmd ("tracepoints", class_trace
, delete_trace_command
, _("\
16555 Delete specified tracepoints.\n\
16556 Arguments are tracepoint numbers, separated by spaces.\n\
16557 No argument means delete all tracepoints."),
16559 add_alias_cmd ("tr", "tracepoints", class_trace
, 1, &deletelist
);
16561 c
= add_cmd ("tracepoints", class_trace
, disable_trace_command
, _("\
16562 Disable specified tracepoints.\n\
16563 Arguments are tracepoint numbers, separated by spaces.\n\
16564 No argument means disable all tracepoints."),
16566 deprecate_cmd (c
, "disable");
16568 c
= add_cmd ("tracepoints", class_trace
, enable_trace_command
, _("\
16569 Enable specified tracepoints.\n\
16570 Arguments are tracepoint numbers, separated by spaces.\n\
16571 No argument means enable all tracepoints."),
16573 deprecate_cmd (c
, "enable");
16575 add_com ("passcount", class_trace
, trace_pass_command
, _("\
16576 Set the passcount for a tracepoint.\n\
16577 The trace will end when the tracepoint has been passed 'count' times.\n\
16578 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
16579 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
16581 add_prefix_cmd ("save", class_breakpoint
, save_command
,
16582 _("Save breakpoint definitions as a script."),
16583 &save_cmdlist
, "save ",
16584 0/*allow-unknown*/, &cmdlist
);
16586 c
= add_cmd ("breakpoints", class_breakpoint
, save_breakpoints_command
, _("\
16587 Save current breakpoint definitions as a script.\n\
16588 This includes all types of breakpoints (breakpoints, watchpoints,\n\
16589 catchpoints, tracepoints). Use the 'source' command in another debug\n\
16590 session to restore them."),
16592 set_cmd_completer (c
, filename_completer
);
16594 c
= add_cmd ("tracepoints", class_trace
, save_tracepoints_command
, _("\
16595 Save current tracepoint definitions as a script.\n\
16596 Use the 'source' command in another debug session to restore them."),
16598 set_cmd_completer (c
, filename_completer
);
16600 c
= add_com_alias ("save-tracepoints", "save tracepoints", class_trace
, 0);
16601 deprecate_cmd (c
, "save tracepoints");
16603 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
16604 Breakpoint specific settings\n\
16605 Configure various breakpoint-specific variables such as\n\
16606 pending breakpoint behavior"),
16607 &breakpoint_set_cmdlist
, "set breakpoint ",
16608 0/*allow-unknown*/, &setlist
);
16609 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
16610 Breakpoint specific settings\n\
16611 Configure various breakpoint-specific variables such as\n\
16612 pending breakpoint behavior"),
16613 &breakpoint_show_cmdlist
, "show breakpoint ",
16614 0/*allow-unknown*/, &showlist
);
16616 add_setshow_auto_boolean_cmd ("pending", no_class
,
16617 &pending_break_support
, _("\
16618 Set debugger's behavior regarding pending breakpoints."), _("\
16619 Show debugger's behavior regarding pending breakpoints."), _("\
16620 If on, an unrecognized breakpoint location will cause gdb to create a\n\
16621 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
16622 an error. If auto, an unrecognized breakpoint location results in a\n\
16623 user-query to see if a pending breakpoint should be created."),
16625 show_pending_break_support
,
16626 &breakpoint_set_cmdlist
,
16627 &breakpoint_show_cmdlist
);
16629 pending_break_support
= AUTO_BOOLEAN_AUTO
;
16631 add_setshow_boolean_cmd ("auto-hw", no_class
,
16632 &automatic_hardware_breakpoints
, _("\
16633 Set automatic usage of hardware breakpoints."), _("\
16634 Show automatic usage of hardware breakpoints."), _("\
16635 If set, the debugger will automatically use hardware breakpoints for\n\
16636 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
16637 a warning will be emitted for such breakpoints."),
16639 show_automatic_hardware_breakpoints
,
16640 &breakpoint_set_cmdlist
,
16641 &breakpoint_show_cmdlist
);
16643 add_setshow_boolean_cmd ("always-inserted", class_support
,
16644 &always_inserted_mode
, _("\
16645 Set mode for inserting breakpoints."), _("\
16646 Show mode for inserting breakpoints."), _("\
16647 When this mode is on, breakpoints are inserted immediately as soon as\n\
16648 they're created, kept inserted even when execution stops, and removed\n\
16649 only when the user deletes them. When this mode is off (the default),\n\
16650 breakpoints are inserted only when execution continues, and removed\n\
16651 when execution stops."),
16653 &show_always_inserted_mode
,
16654 &breakpoint_set_cmdlist
,
16655 &breakpoint_show_cmdlist
);
16657 add_setshow_enum_cmd ("condition-evaluation", class_breakpoint
,
16658 condition_evaluation_enums
,
16659 &condition_evaluation_mode_1
, _("\
16660 Set mode of breakpoint condition evaluation."), _("\
16661 Show mode of breakpoint condition evaluation."), _("\
16662 When this is set to \"host\", breakpoint conditions will be\n\
16663 evaluated on the host's side by GDB. When it is set to \"target\",\n\
16664 breakpoint conditions will be downloaded to the target (if the target\n\
16665 supports such feature) and conditions will be evaluated on the target's side.\n\
16666 If this is set to \"auto\" (default), this will be automatically set to\n\
16667 \"target\" if it supports condition evaluation, otherwise it will\n\
16668 be set to \"gdb\""),
16669 &set_condition_evaluation_mode
,
16670 &show_condition_evaluation_mode
,
16671 &breakpoint_set_cmdlist
,
16672 &breakpoint_show_cmdlist
);
16674 add_com ("break-range", class_breakpoint
, break_range_command
, _("\
16675 Set a breakpoint for an address range.\n\
16676 break-range START-LOCATION, END-LOCATION\n\
16677 where START-LOCATION and END-LOCATION can be one of the following:\n\
16678 LINENUM, for that line in the current file,\n\
16679 FILE:LINENUM, for that line in that file,\n\
16680 +OFFSET, for that number of lines after the current line\n\
16681 or the start of the range\n\
16682 FUNCTION, for the first line in that function,\n\
16683 FILE:FUNCTION, to distinguish among like-named static functions.\n\
16684 *ADDRESS, for the instruction at that address.\n\
16686 The breakpoint will stop execution of the inferior whenever it executes\n\
16687 an instruction at any address within the [START-LOCATION, END-LOCATION]\n\
16688 range (including START-LOCATION and END-LOCATION)."));
16690 c
= add_com ("dprintf", class_breakpoint
, dprintf_command
, _("\
16691 Set a dynamic printf at specified location.\n\
16692 dprintf location,format string,arg1,arg2,...\n\
16693 location may be a linespec, explicit, or address location.\n"
16694 "\n" LOCATION_HELP_STRING
));
16695 set_cmd_completer (c
, location_completer
);
16697 add_setshow_enum_cmd ("dprintf-style", class_support
,
16698 dprintf_style_enums
, &dprintf_style
, _("\
16699 Set the style of usage for dynamic printf."), _("\
16700 Show the style of usage for dynamic printf."), _("\
16701 This setting chooses how GDB will do a dynamic printf.\n\
16702 If the value is \"gdb\", then the printing is done by GDB to its own\n\
16703 console, as with the \"printf\" command.\n\
16704 If the value is \"call\", the print is done by calling a function in your\n\
16705 program; by default printf(), but you can choose a different function or\n\
16706 output stream by setting dprintf-function and dprintf-channel."),
16707 update_dprintf_commands
, NULL
,
16708 &setlist
, &showlist
);
16710 dprintf_function
= xstrdup ("printf");
16711 add_setshow_string_cmd ("dprintf-function", class_support
,
16712 &dprintf_function
, _("\
16713 Set the function to use for dynamic printf"), _("\
16714 Show the function to use for dynamic printf"), NULL
,
16715 update_dprintf_commands
, NULL
,
16716 &setlist
, &showlist
);
16718 dprintf_channel
= xstrdup ("");
16719 add_setshow_string_cmd ("dprintf-channel", class_support
,
16720 &dprintf_channel
, _("\
16721 Set the channel to use for dynamic printf"), _("\
16722 Show the channel to use for dynamic printf"), NULL
,
16723 update_dprintf_commands
, NULL
,
16724 &setlist
, &showlist
);
16726 add_setshow_boolean_cmd ("disconnected-dprintf", no_class
,
16727 &disconnected_dprintf
, _("\
16728 Set whether dprintf continues after GDB disconnects."), _("\
16729 Show whether dprintf continues after GDB disconnects."), _("\
16730 Use this to let dprintf commands continue to hit and produce output\n\
16731 even if GDB disconnects or detaches from the target."),
16734 &setlist
, &showlist
);
16736 add_com ("agent-printf", class_vars
, agent_printf_command
, _("\
16737 agent-printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
16738 (target agent only) This is useful for formatted output in user-defined commands."));
16740 automatic_hardware_breakpoints
= 1;
16742 observer_attach_about_to_proceed (breakpoint_about_to_proceed
);
16743 observer_attach_thread_exit (remove_threaded_breakpoints
);