1 /* Everything about breakpoints, for GDB.
3 Copyright (C) 1986-2014 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 "xml-syscall.h"
60 #include "parser-defs.h"
61 #include "gdb_regex.h"
63 #include "cli/cli-utils.h"
64 #include "continuations.h"
68 #include "dummy-frame.h"
72 /* readline include files */
73 #include "readline/readline.h"
74 #include "readline/history.h"
76 /* readline defines this. */
79 #include "mi/mi-common.h"
80 #include "extension.h"
82 /* Enums for exception-handling support. */
83 enum exception_event_kind
90 /* Prototypes for local functions. */
92 static void enable_delete_command (char *, int);
94 static void enable_once_command (char *, int);
96 static void enable_count_command (char *, int);
98 static void disable_command (char *, int);
100 static void enable_command (char *, int);
102 static void map_breakpoint_numbers (char *, void (*) (struct breakpoint
*,
106 static void ignore_command (char *, int);
108 static int breakpoint_re_set_one (void *);
110 static void breakpoint_re_set_default (struct breakpoint
*);
112 static void create_sals_from_address_default (char **,
113 struct linespec_result
*,
117 static void create_breakpoints_sal_default (struct gdbarch
*,
118 struct linespec_result
*,
119 char *, char *, enum bptype
,
120 enum bpdisp
, int, int,
122 const struct breakpoint_ops
*,
123 int, int, int, unsigned);
125 static void decode_linespec_default (struct breakpoint
*, char **,
126 struct symtabs_and_lines
*);
128 static void clear_command (char *, int);
130 static void catch_command (char *, int);
132 static int can_use_hardware_watchpoint (struct value
*);
134 static void break_command_1 (char *, int, int);
136 static void mention (struct breakpoint
*);
138 static struct breakpoint
*set_raw_breakpoint_without_location (struct gdbarch
*,
140 const struct breakpoint_ops
*);
141 static struct bp_location
*add_location_to_breakpoint (struct breakpoint
*,
142 const struct symtab_and_line
*);
144 /* This function is used in gdbtk sources and thus can not be made
146 struct breakpoint
*set_raw_breakpoint (struct gdbarch
*gdbarch
,
147 struct symtab_and_line
,
149 const struct breakpoint_ops
*);
151 static struct breakpoint
*
152 momentary_breakpoint_from_master (struct breakpoint
*orig
,
154 const struct breakpoint_ops
*ops
,
157 static void breakpoint_adjustment_warning (CORE_ADDR
, CORE_ADDR
, int, int);
159 static CORE_ADDR
adjust_breakpoint_address (struct gdbarch
*gdbarch
,
163 static void describe_other_breakpoints (struct gdbarch
*,
164 struct program_space
*, CORE_ADDR
,
165 struct obj_section
*, int);
167 static int watchpoint_locations_match (struct bp_location
*loc1
,
168 struct bp_location
*loc2
);
170 static int breakpoint_location_address_match (struct bp_location
*bl
,
171 struct address_space
*aspace
,
174 static void breakpoints_info (char *, int);
176 static void watchpoints_info (char *, int);
178 static int breakpoint_1 (char *, int,
179 int (*) (const struct breakpoint
*));
181 static int breakpoint_cond_eval (void *);
183 static void cleanup_executing_breakpoints (void *);
185 static void commands_command (char *, int);
187 static void condition_command (char *, int);
196 static int remove_breakpoint (struct bp_location
*, insertion_state_t
);
197 static int remove_breakpoint_1 (struct bp_location
*, insertion_state_t
);
199 static enum print_stop_action
print_bp_stop_message (bpstat bs
);
201 static int watchpoint_check (void *);
203 static void maintenance_info_breakpoints (char *, int);
205 static int hw_breakpoint_used_count (void);
207 static int hw_watchpoint_use_count (struct breakpoint
*);
209 static int hw_watchpoint_used_count_others (struct breakpoint
*except
,
211 int *other_type_used
);
213 static void hbreak_command (char *, int);
215 static void thbreak_command (char *, int);
217 static void enable_breakpoint_disp (struct breakpoint
*, enum bpdisp
,
220 static void stop_command (char *arg
, int from_tty
);
222 static void stopin_command (char *arg
, int from_tty
);
224 static void stopat_command (char *arg
, int from_tty
);
226 static void tcatch_command (char *arg
, int from_tty
);
228 static void free_bp_location (struct bp_location
*loc
);
229 static void incref_bp_location (struct bp_location
*loc
);
230 static void decref_bp_location (struct bp_location
**loc
);
232 static struct bp_location
*allocate_bp_location (struct breakpoint
*bpt
);
234 /* update_global_location_list's modes of operation wrt to whether to
235 insert locations now. */
236 enum ugll_insert_mode
238 /* Don't insert any breakpoint locations into the inferior, only
239 remove already-inserted locations that no longer should be
240 inserted. Functions that delete a breakpoint or breakpoints
241 should specify this mode, so that deleting a breakpoint doesn't
242 have the side effect of inserting the locations of other
243 breakpoints that are marked not-inserted, but should_be_inserted
244 returns true on them.
246 This behavior is useful is situations close to tear-down -- e.g.,
247 after an exec, while the target still has execution, but
248 breakpoint shadows of the previous executable image should *NOT*
249 be restored to the new image; or before detaching, where the
250 target still has execution and wants to delete breakpoints from
251 GDB's lists, and all breakpoints had already been removed from
255 /* May insert breakpoints iff breakpoints_should_be_inserted_now
256 claims breakpoints should be inserted now. */
259 /* Insert locations now, irrespective of
260 breakpoints_should_be_inserted_now. E.g., say all threads are
261 stopped right now, and the user did "continue". We need to
262 insert breakpoints _before_ resuming the target, but
263 UGLL_MAY_INSERT wouldn't insert them, because
264 breakpoints_should_be_inserted_now returns false at that point,
265 as no thread is running yet. */
269 static void update_global_location_list (enum ugll_insert_mode
);
271 static void update_global_location_list_nothrow (enum ugll_insert_mode
);
273 static int is_hardware_watchpoint (const struct breakpoint
*bpt
);
275 static void insert_breakpoint_locations (void);
277 static int syscall_catchpoint_p (struct breakpoint
*b
);
279 static void tracepoints_info (char *, int);
281 static void delete_trace_command (char *, int);
283 static void enable_trace_command (char *, int);
285 static void disable_trace_command (char *, int);
287 static void trace_pass_command (char *, int);
289 static void set_tracepoint_count (int num
);
291 static int is_masked_watchpoint (const struct breakpoint
*b
);
293 static struct bp_location
**get_first_locp_gte_addr (CORE_ADDR address
);
295 /* Return 1 if B refers to a static tracepoint set by marker ("-m"), zero
298 static int strace_marker_p (struct breakpoint
*b
);
300 /* The abstract base class all breakpoint_ops structures inherit
302 struct breakpoint_ops base_breakpoint_ops
;
304 /* The breakpoint_ops structure to be inherited by all breakpoint_ops
305 that are implemented on top of software or hardware breakpoints
306 (user breakpoints, internal and momentary breakpoints, etc.). */
307 static struct breakpoint_ops bkpt_base_breakpoint_ops
;
309 /* Internal breakpoints class type. */
310 static struct breakpoint_ops internal_breakpoint_ops
;
312 /* Momentary breakpoints class type. */
313 static struct breakpoint_ops momentary_breakpoint_ops
;
315 /* Momentary breakpoints for bp_longjmp and bp_exception class type. */
316 static struct breakpoint_ops longjmp_breakpoint_ops
;
318 /* The breakpoint_ops structure to be used in regular user created
320 struct breakpoint_ops bkpt_breakpoint_ops
;
322 /* Breakpoints set on probes. */
323 static struct breakpoint_ops bkpt_probe_breakpoint_ops
;
325 /* Dynamic printf class type. */
326 struct breakpoint_ops dprintf_breakpoint_ops
;
328 /* One (or perhaps two) breakpoints used for software single
331 static struct breakpoint
*single_step_breakpoints
;
333 /* The style in which to perform a dynamic printf. This is a user
334 option because different output options have different tradeoffs;
335 if GDB does the printing, there is better error handling if there
336 is a problem with any of the arguments, but using an inferior
337 function lets you have special-purpose printers and sending of
338 output to the same place as compiled-in print functions. */
340 static const char dprintf_style_gdb
[] = "gdb";
341 static const char dprintf_style_call
[] = "call";
342 static const char dprintf_style_agent
[] = "agent";
343 static const char *const dprintf_style_enums
[] = {
349 static const char *dprintf_style
= dprintf_style_gdb
;
351 /* The function to use for dynamic printf if the preferred style is to
352 call into the inferior. The value is simply a string that is
353 copied into the command, so it can be anything that GDB can
354 evaluate to a callable address, not necessarily a function name. */
356 static char *dprintf_function
= "";
358 /* The channel to use for dynamic printf if the preferred style is to
359 call into the inferior; if a nonempty string, it will be passed to
360 the call as the first argument, with the format string as the
361 second. As with the dprintf function, this can be anything that
362 GDB knows how to evaluate, so in addition to common choices like
363 "stderr", this could be an app-specific expression like
364 "mystreams[curlogger]". */
366 static char *dprintf_channel
= "";
368 /* True if dprintf commands should continue to operate even if GDB
370 static int disconnected_dprintf
= 1;
372 /* A reference-counted struct command_line. This lets multiple
373 breakpoints share a single command list. */
374 struct counted_command_line
376 /* The reference count. */
379 /* The command list. */
380 struct command_line
*commands
;
383 struct command_line
*
384 breakpoint_commands (struct breakpoint
*b
)
386 return b
->commands
? b
->commands
->commands
: NULL
;
389 /* Flag indicating that a command has proceeded the inferior past the
390 current breakpoint. */
392 static int breakpoint_proceeded
;
395 bpdisp_text (enum bpdisp disp
)
397 /* NOTE: the following values are a part of MI protocol and
398 represent values of 'disp' field returned when inferior stops at
400 static const char * const bpdisps
[] = {"del", "dstp", "dis", "keep"};
402 return bpdisps
[(int) disp
];
405 /* Prototypes for exported functions. */
406 /* If FALSE, gdb will not use hardware support for watchpoints, even
407 if such is available. */
408 static int can_use_hw_watchpoints
;
411 show_can_use_hw_watchpoints (struct ui_file
*file
, int from_tty
,
412 struct cmd_list_element
*c
,
415 fprintf_filtered (file
,
416 _("Debugger's willingness to use "
417 "watchpoint hardware is %s.\n"),
421 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
422 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
423 for unrecognized breakpoint locations.
424 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
425 static enum auto_boolean pending_break_support
;
427 show_pending_break_support (struct ui_file
*file
, int from_tty
,
428 struct cmd_list_element
*c
,
431 fprintf_filtered (file
,
432 _("Debugger's behavior regarding "
433 "pending breakpoints is %s.\n"),
437 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
438 set with "break" but falling in read-only memory.
439 If 0, gdb will warn about such breakpoints, but won't automatically
440 use hardware breakpoints. */
441 static int automatic_hardware_breakpoints
;
443 show_automatic_hardware_breakpoints (struct ui_file
*file
, int from_tty
,
444 struct cmd_list_element
*c
,
447 fprintf_filtered (file
,
448 _("Automatic usage of hardware breakpoints is %s.\n"),
452 /* If on, GDB keeps breakpoints inserted even if the inferior is
453 stopped, and immediately inserts any new breakpoints as soon as
454 they're created. If off (default), GDB keeps breakpoints off of
455 the target as long as possible. That is, it delays inserting
456 breakpoints until the next resume, and removes them again when the
457 target fully stops. This is a bit safer in case GDB crashes while
458 processing user input. */
459 static int always_inserted_mode
= 0;
462 show_always_inserted_mode (struct ui_file
*file
, int from_tty
,
463 struct cmd_list_element
*c
, const char *value
)
465 fprintf_filtered (file
, _("Always inserted breakpoint mode is %s.\n"),
469 /* See breakpoint.h. */
472 breakpoints_should_be_inserted_now (void)
474 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
476 /* If breakpoints are global, they should be inserted even if no
477 thread under gdb's control is running, or even if there are
478 no threads under GDB's control yet. */
481 else if (target_has_execution
)
483 if (always_inserted_mode
)
485 /* The user wants breakpoints inserted even if all threads
490 if (threads_are_executing ())
496 static const char condition_evaluation_both
[] = "host or target";
498 /* Modes for breakpoint condition evaluation. */
499 static const char condition_evaluation_auto
[] = "auto";
500 static const char condition_evaluation_host
[] = "host";
501 static const char condition_evaluation_target
[] = "target";
502 static const char *const condition_evaluation_enums
[] = {
503 condition_evaluation_auto
,
504 condition_evaluation_host
,
505 condition_evaluation_target
,
509 /* Global that holds the current mode for breakpoint condition evaluation. */
510 static const char *condition_evaluation_mode_1
= condition_evaluation_auto
;
512 /* Global that we use to display information to the user (gets its value from
513 condition_evaluation_mode_1. */
514 static const char *condition_evaluation_mode
= condition_evaluation_auto
;
516 /* Translate a condition evaluation mode MODE into either "host"
517 or "target". This is used mostly to translate from "auto" to the
518 real setting that is being used. It returns the translated
522 translate_condition_evaluation_mode (const char *mode
)
524 if (mode
== condition_evaluation_auto
)
526 if (target_supports_evaluation_of_breakpoint_conditions ())
527 return condition_evaluation_target
;
529 return condition_evaluation_host
;
535 /* Discovers what condition_evaluation_auto translates to. */
538 breakpoint_condition_evaluation_mode (void)
540 return translate_condition_evaluation_mode (condition_evaluation_mode
);
543 /* Return true if GDB should evaluate breakpoint conditions or false
547 gdb_evaluates_breakpoint_condition_p (void)
549 const char *mode
= breakpoint_condition_evaluation_mode ();
551 return (mode
== condition_evaluation_host
);
554 void _initialize_breakpoint (void);
556 /* Are we executing breakpoint commands? */
557 static int executing_breakpoint_commands
;
559 /* Are overlay event breakpoints enabled? */
560 static int overlay_events_enabled
;
562 /* See description in breakpoint.h. */
563 int target_exact_watchpoints
= 0;
565 /* Walk the following statement or block through all breakpoints.
566 ALL_BREAKPOINTS_SAFE does so even if the statement deletes the
567 current breakpoint. */
569 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
571 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
572 for (B = breakpoint_chain; \
573 B ? (TMP=B->next, 1): 0; \
576 /* Similar iterator for the low-level breakpoints. SAFE variant is
577 not provided so update_global_location_list must not be called
578 while executing the block of ALL_BP_LOCATIONS. */
580 #define ALL_BP_LOCATIONS(B,BP_TMP) \
581 for (BP_TMP = bp_location; \
582 BP_TMP < bp_location + bp_location_count && (B = *BP_TMP); \
585 /* Iterates through locations with address ADDRESS for the currently selected
586 program space. BP_LOCP_TMP points to each object. BP_LOCP_START points
587 to where the loop should start from.
588 If BP_LOCP_START is a NULL pointer, the macro automatically seeks the
589 appropriate location to start with. */
591 #define ALL_BP_LOCATIONS_AT_ADDR(BP_LOCP_TMP, BP_LOCP_START, ADDRESS) \
592 for (BP_LOCP_START = BP_LOCP_START == NULL ? get_first_locp_gte_addr (ADDRESS) : BP_LOCP_START, \
593 BP_LOCP_TMP = BP_LOCP_START; \
595 && (BP_LOCP_TMP < bp_location + bp_location_count \
596 && (*BP_LOCP_TMP)->address == ADDRESS); \
599 /* Iterator for tracepoints only. */
601 #define ALL_TRACEPOINTS(B) \
602 for (B = breakpoint_chain; B; B = B->next) \
603 if (is_tracepoint (B))
605 /* Chains of all breakpoints defined. */
607 struct breakpoint
*breakpoint_chain
;
609 /* Array is sorted by bp_location_compare - primarily by the ADDRESS. */
611 static struct bp_location
**bp_location
;
613 /* Number of elements of BP_LOCATION. */
615 static unsigned bp_location_count
;
617 /* Maximum alignment offset between bp_target_info.PLACED_ADDRESS and
618 ADDRESS for the current elements of BP_LOCATION which get a valid
619 result from bp_location_has_shadow. You can use it for roughly
620 limiting the subrange of BP_LOCATION to scan for shadow bytes for
621 an address you need to read. */
623 static CORE_ADDR bp_location_placed_address_before_address_max
;
625 /* Maximum offset plus alignment between bp_target_info.PLACED_ADDRESS
626 + bp_target_info.SHADOW_LEN and ADDRESS for the current elements of
627 BP_LOCATION which get a valid result from bp_location_has_shadow.
628 You can use it for roughly limiting the subrange of BP_LOCATION to
629 scan for shadow bytes for an address you need to read. */
631 static CORE_ADDR bp_location_shadow_len_after_address_max
;
633 /* The locations that no longer correspond to any breakpoint, unlinked
634 from bp_location array, but for which a hit may still be reported
636 VEC(bp_location_p
) *moribund_locations
= NULL
;
638 /* Number of last breakpoint made. */
640 static int breakpoint_count
;
642 /* The value of `breakpoint_count' before the last command that
643 created breakpoints. If the last (break-like) command created more
644 than one breakpoint, then the difference between BREAKPOINT_COUNT
645 and PREV_BREAKPOINT_COUNT is more than one. */
646 static int prev_breakpoint_count
;
648 /* Number of last tracepoint made. */
650 static int tracepoint_count
;
652 static struct cmd_list_element
*breakpoint_set_cmdlist
;
653 static struct cmd_list_element
*breakpoint_show_cmdlist
;
654 struct cmd_list_element
*save_cmdlist
;
656 /* Return whether a breakpoint is an active enabled breakpoint. */
658 breakpoint_enabled (struct breakpoint
*b
)
660 return (b
->enable_state
== bp_enabled
);
663 /* Set breakpoint count to NUM. */
666 set_breakpoint_count (int num
)
668 prev_breakpoint_count
= breakpoint_count
;
669 breakpoint_count
= num
;
670 set_internalvar_integer (lookup_internalvar ("bpnum"), num
);
673 /* Used by `start_rbreak_breakpoints' below, to record the current
674 breakpoint count before "rbreak" creates any breakpoint. */
675 static int rbreak_start_breakpoint_count
;
677 /* Called at the start an "rbreak" command to record the first
681 start_rbreak_breakpoints (void)
683 rbreak_start_breakpoint_count
= breakpoint_count
;
686 /* Called at the end of an "rbreak" command to record the last
690 end_rbreak_breakpoints (void)
692 prev_breakpoint_count
= rbreak_start_breakpoint_count
;
695 /* Used in run_command to zero the hit count when a new run starts. */
698 clear_breakpoint_hit_counts (void)
700 struct breakpoint
*b
;
706 /* Allocate a new counted_command_line with reference count of 1.
707 The new structure owns COMMANDS. */
709 static struct counted_command_line
*
710 alloc_counted_command_line (struct command_line
*commands
)
712 struct counted_command_line
*result
713 = xmalloc (sizeof (struct counted_command_line
));
716 result
->commands
= commands
;
720 /* Increment reference count. This does nothing if CMD is NULL. */
723 incref_counted_command_line (struct counted_command_line
*cmd
)
729 /* Decrement reference count. If the reference count reaches 0,
730 destroy the counted_command_line. Sets *CMDP to NULL. This does
731 nothing if *CMDP is NULL. */
734 decref_counted_command_line (struct counted_command_line
**cmdp
)
738 if (--(*cmdp
)->refc
== 0)
740 free_command_lines (&(*cmdp
)->commands
);
747 /* A cleanup function that calls decref_counted_command_line. */
750 do_cleanup_counted_command_line (void *arg
)
752 decref_counted_command_line (arg
);
755 /* Create a cleanup that calls decref_counted_command_line on the
758 static struct cleanup
*
759 make_cleanup_decref_counted_command_line (struct counted_command_line
**cmdp
)
761 return make_cleanup (do_cleanup_counted_command_line
, cmdp
);
765 /* Return the breakpoint with the specified number, or NULL
766 if the number does not refer to an existing breakpoint. */
769 get_breakpoint (int num
)
771 struct breakpoint
*b
;
774 if (b
->number
== num
)
782 /* Mark locations as "conditions have changed" in case the target supports
783 evaluating conditions on its side. */
786 mark_breakpoint_modified (struct breakpoint
*b
)
788 struct bp_location
*loc
;
790 /* This is only meaningful if the target is
791 evaluating conditions and if the user has
792 opted for condition evaluation on the target's
794 if (gdb_evaluates_breakpoint_condition_p ()
795 || !target_supports_evaluation_of_breakpoint_conditions ())
798 if (!is_breakpoint (b
))
801 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
802 loc
->condition_changed
= condition_modified
;
805 /* Mark location as "conditions have changed" in case the target supports
806 evaluating conditions on its side. */
809 mark_breakpoint_location_modified (struct bp_location
*loc
)
811 /* This is only meaningful if the target is
812 evaluating conditions and if the user has
813 opted for condition evaluation on the target's
815 if (gdb_evaluates_breakpoint_condition_p ()
816 || !target_supports_evaluation_of_breakpoint_conditions ())
820 if (!is_breakpoint (loc
->owner
))
823 loc
->condition_changed
= condition_modified
;
826 /* Sets the condition-evaluation mode using the static global
827 condition_evaluation_mode. */
830 set_condition_evaluation_mode (char *args
, int from_tty
,
831 struct cmd_list_element
*c
)
833 const char *old_mode
, *new_mode
;
835 if ((condition_evaluation_mode_1
== condition_evaluation_target
)
836 && !target_supports_evaluation_of_breakpoint_conditions ())
838 condition_evaluation_mode_1
= condition_evaluation_mode
;
839 warning (_("Target does not support breakpoint condition evaluation.\n"
840 "Using host evaluation mode instead."));
844 new_mode
= translate_condition_evaluation_mode (condition_evaluation_mode_1
);
845 old_mode
= translate_condition_evaluation_mode (condition_evaluation_mode
);
847 /* Flip the switch. Flip it even if OLD_MODE == NEW_MODE as one of the
848 settings was "auto". */
849 condition_evaluation_mode
= condition_evaluation_mode_1
;
851 /* Only update the mode if the user picked a different one. */
852 if (new_mode
!= old_mode
)
854 struct bp_location
*loc
, **loc_tmp
;
855 /* If the user switched to a different evaluation mode, we
856 need to synch the changes with the target as follows:
858 "host" -> "target": Send all (valid) conditions to the target.
859 "target" -> "host": Remove all the conditions from the target.
862 if (new_mode
== condition_evaluation_target
)
864 /* Mark everything modified and synch conditions with the
866 ALL_BP_LOCATIONS (loc
, loc_tmp
)
867 mark_breakpoint_location_modified (loc
);
871 /* Manually mark non-duplicate locations to synch conditions
872 with the target. We do this to remove all the conditions the
873 target knows about. */
874 ALL_BP_LOCATIONS (loc
, loc_tmp
)
875 if (is_breakpoint (loc
->owner
) && loc
->inserted
)
876 loc
->needs_update
= 1;
880 update_global_location_list (UGLL_MAY_INSERT
);
886 /* Shows the current mode of breakpoint condition evaluation. Explicitly shows
887 what "auto" is translating to. */
890 show_condition_evaluation_mode (struct ui_file
*file
, int from_tty
,
891 struct cmd_list_element
*c
, const char *value
)
893 if (condition_evaluation_mode
== condition_evaluation_auto
)
894 fprintf_filtered (file
,
895 _("Breakpoint condition evaluation "
896 "mode is %s (currently %s).\n"),
898 breakpoint_condition_evaluation_mode ());
900 fprintf_filtered (file
, _("Breakpoint condition evaluation mode is %s.\n"),
904 /* A comparison function for bp_location AP and BP that is used by
905 bsearch. This comparison function only cares about addresses, unlike
906 the more general bp_location_compare function. */
909 bp_location_compare_addrs (const void *ap
, const void *bp
)
911 struct bp_location
*a
= *(void **) ap
;
912 struct bp_location
*b
= *(void **) bp
;
914 if (a
->address
== b
->address
)
917 return ((a
->address
> b
->address
) - (a
->address
< b
->address
));
920 /* Helper function to skip all bp_locations with addresses
921 less than ADDRESS. It returns the first bp_location that
922 is greater than or equal to ADDRESS. If none is found, just
925 static struct bp_location
**
926 get_first_locp_gte_addr (CORE_ADDR address
)
928 struct bp_location dummy_loc
;
929 struct bp_location
*dummy_locp
= &dummy_loc
;
930 struct bp_location
**locp_found
= NULL
;
932 /* Initialize the dummy location's address field. */
933 memset (&dummy_loc
, 0, sizeof (struct bp_location
));
934 dummy_loc
.address
= address
;
936 /* Find a close match to the first location at ADDRESS. */
937 locp_found
= bsearch (&dummy_locp
, bp_location
, bp_location_count
,
938 sizeof (struct bp_location
**),
939 bp_location_compare_addrs
);
941 /* Nothing was found, nothing left to do. */
942 if (locp_found
== NULL
)
945 /* We may have found a location that is at ADDRESS but is not the first in the
946 location's list. Go backwards (if possible) and locate the first one. */
947 while ((locp_found
- 1) >= bp_location
948 && (*(locp_found
- 1))->address
== address
)
955 set_breakpoint_condition (struct breakpoint
*b
, char *exp
,
958 xfree (b
->cond_string
);
959 b
->cond_string
= NULL
;
961 if (is_watchpoint (b
))
963 struct watchpoint
*w
= (struct watchpoint
*) b
;
970 struct bp_location
*loc
;
972 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
977 /* No need to free the condition agent expression
978 bytecode (if we have one). We will handle this
979 when we go through update_global_location_list. */
986 printf_filtered (_("Breakpoint %d now unconditional.\n"), b
->number
);
990 const char *arg
= exp
;
992 /* I don't know if it matters whether this is the string the user
993 typed in or the decompiled expression. */
994 b
->cond_string
= xstrdup (arg
);
995 b
->condition_not_parsed
= 0;
997 if (is_watchpoint (b
))
999 struct watchpoint
*w
= (struct watchpoint
*) b
;
1001 innermost_block
= NULL
;
1003 w
->cond_exp
= parse_exp_1 (&arg
, 0, 0, 0);
1005 error (_("Junk at end of expression"));
1006 w
->cond_exp_valid_block
= innermost_block
;
1010 struct bp_location
*loc
;
1012 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1016 parse_exp_1 (&arg
, loc
->address
,
1017 block_for_pc (loc
->address
), 0);
1019 error (_("Junk at end of expression"));
1023 mark_breakpoint_modified (b
);
1025 observer_notify_breakpoint_modified (b
);
1028 /* Completion for the "condition" command. */
1030 static VEC (char_ptr
) *
1031 condition_completer (struct cmd_list_element
*cmd
,
1032 const char *text
, const char *word
)
1036 text
= skip_spaces_const (text
);
1037 space
= skip_to_space_const (text
);
1041 struct breakpoint
*b
;
1042 VEC (char_ptr
) *result
= NULL
;
1046 /* We don't support completion of history indices. */
1047 if (isdigit (text
[1]))
1049 return complete_internalvar (&text
[1]);
1052 /* We're completing the breakpoint number. */
1053 len
= strlen (text
);
1059 xsnprintf (number
, sizeof (number
), "%d", b
->number
);
1061 if (strncmp (number
, text
, len
) == 0)
1062 VEC_safe_push (char_ptr
, result
, xstrdup (number
));
1068 /* We're completing the expression part. */
1069 text
= skip_spaces_const (space
);
1070 return expression_completer (cmd
, text
, word
);
1073 /* condition N EXP -- set break condition of breakpoint N to EXP. */
1076 condition_command (char *arg
, int from_tty
)
1078 struct breakpoint
*b
;
1083 error_no_arg (_("breakpoint number"));
1086 bnum
= get_number (&p
);
1088 error (_("Bad breakpoint argument: '%s'"), arg
);
1091 if (b
->number
== bnum
)
1093 /* Check if this breakpoint has a "stop" method implemented in an
1094 extension language. This method and conditions entered into GDB
1095 from the CLI are mutually exclusive. */
1096 const struct extension_language_defn
*extlang
1097 = get_breakpoint_cond_ext_lang (b
, EXT_LANG_NONE
);
1099 if (extlang
!= NULL
)
1101 error (_("Only one stop condition allowed. There is currently"
1102 " a %s stop condition defined for this breakpoint."),
1103 ext_lang_capitalized_name (extlang
));
1105 set_breakpoint_condition (b
, p
, from_tty
);
1107 if (is_breakpoint (b
))
1108 update_global_location_list (UGLL_MAY_INSERT
);
1113 error (_("No breakpoint number %d."), bnum
);
1116 /* Check that COMMAND do not contain commands that are suitable
1117 only for tracepoints and not suitable for ordinary breakpoints.
1118 Throw if any such commands is found. */
1121 check_no_tracepoint_commands (struct command_line
*commands
)
1123 struct command_line
*c
;
1125 for (c
= commands
; c
; c
= c
->next
)
1129 if (c
->control_type
== while_stepping_control
)
1130 error (_("The 'while-stepping' command can "
1131 "only be used for tracepoints"));
1133 for (i
= 0; i
< c
->body_count
; ++i
)
1134 check_no_tracepoint_commands ((c
->body_list
)[i
]);
1136 /* Not that command parsing removes leading whitespace and comment
1137 lines and also empty lines. So, we only need to check for
1138 command directly. */
1139 if (strstr (c
->line
, "collect ") == c
->line
)
1140 error (_("The 'collect' command can only be used for tracepoints"));
1142 if (strstr (c
->line
, "teval ") == c
->line
)
1143 error (_("The 'teval' command can only be used for tracepoints"));
1147 /* Encapsulate tests for different types of tracepoints. */
1150 is_tracepoint_type (enum bptype type
)
1152 return (type
== bp_tracepoint
1153 || type
== bp_fast_tracepoint
1154 || type
== bp_static_tracepoint
);
1158 is_tracepoint (const struct breakpoint
*b
)
1160 return is_tracepoint_type (b
->type
);
1163 /* A helper function that validates that COMMANDS are valid for a
1164 breakpoint. This function will throw an exception if a problem is
1168 validate_commands_for_breakpoint (struct breakpoint
*b
,
1169 struct command_line
*commands
)
1171 if (is_tracepoint (b
))
1173 struct tracepoint
*t
= (struct tracepoint
*) b
;
1174 struct command_line
*c
;
1175 struct command_line
*while_stepping
= 0;
1177 /* Reset the while-stepping step count. The previous commands
1178 might have included a while-stepping action, while the new
1182 /* We need to verify that each top-level element of commands is
1183 valid for tracepoints, that there's at most one
1184 while-stepping element, and that the while-stepping's body
1185 has valid tracing commands excluding nested while-stepping.
1186 We also need to validate the tracepoint action line in the
1187 context of the tracepoint --- validate_actionline actually
1188 has side effects, like setting the tracepoint's
1189 while-stepping STEP_COUNT, in addition to checking if the
1190 collect/teval actions parse and make sense in the
1191 tracepoint's context. */
1192 for (c
= commands
; c
; c
= c
->next
)
1194 if (c
->control_type
== while_stepping_control
)
1196 if (b
->type
== bp_fast_tracepoint
)
1197 error (_("The 'while-stepping' command "
1198 "cannot be used for fast tracepoint"));
1199 else if (b
->type
== bp_static_tracepoint
)
1200 error (_("The 'while-stepping' command "
1201 "cannot be used for static tracepoint"));
1204 error (_("The 'while-stepping' command "
1205 "can be used only once"));
1210 validate_actionline (c
->line
, b
);
1214 struct command_line
*c2
;
1216 gdb_assert (while_stepping
->body_count
== 1);
1217 c2
= while_stepping
->body_list
[0];
1218 for (; c2
; c2
= c2
->next
)
1220 if (c2
->control_type
== while_stepping_control
)
1221 error (_("The 'while-stepping' command cannot be nested"));
1227 check_no_tracepoint_commands (commands
);
1231 /* Return a vector of all the static tracepoints set at ADDR. The
1232 caller is responsible for releasing the vector. */
1235 static_tracepoints_here (CORE_ADDR addr
)
1237 struct breakpoint
*b
;
1238 VEC(breakpoint_p
) *found
= 0;
1239 struct bp_location
*loc
;
1242 if (b
->type
== bp_static_tracepoint
)
1244 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1245 if (loc
->address
== addr
)
1246 VEC_safe_push(breakpoint_p
, found
, b
);
1252 /* Set the command list of B to COMMANDS. If breakpoint is tracepoint,
1253 validate that only allowed commands are included. */
1256 breakpoint_set_commands (struct breakpoint
*b
,
1257 struct command_line
*commands
)
1259 validate_commands_for_breakpoint (b
, commands
);
1261 decref_counted_command_line (&b
->commands
);
1262 b
->commands
= alloc_counted_command_line (commands
);
1263 observer_notify_breakpoint_modified (b
);
1266 /* Set the internal `silent' flag on the breakpoint. Note that this
1267 is not the same as the "silent" that may appear in the breakpoint's
1271 breakpoint_set_silent (struct breakpoint
*b
, int silent
)
1273 int old_silent
= b
->silent
;
1276 if (old_silent
!= silent
)
1277 observer_notify_breakpoint_modified (b
);
1280 /* Set the thread for this breakpoint. If THREAD is -1, make the
1281 breakpoint work for any thread. */
1284 breakpoint_set_thread (struct breakpoint
*b
, int thread
)
1286 int old_thread
= b
->thread
;
1289 if (old_thread
!= thread
)
1290 observer_notify_breakpoint_modified (b
);
1293 /* Set the task for this breakpoint. If TASK is 0, make the
1294 breakpoint work for any task. */
1297 breakpoint_set_task (struct breakpoint
*b
, int task
)
1299 int old_task
= b
->task
;
1302 if (old_task
!= task
)
1303 observer_notify_breakpoint_modified (b
);
1307 check_tracepoint_command (char *line
, void *closure
)
1309 struct breakpoint
*b
= closure
;
1311 validate_actionline (line
, b
);
1314 /* A structure used to pass information through
1315 map_breakpoint_numbers. */
1317 struct commands_info
1319 /* True if the command was typed at a tty. */
1322 /* The breakpoint range spec. */
1325 /* Non-NULL if the body of the commands are being read from this
1326 already-parsed command. */
1327 struct command_line
*control
;
1329 /* The command lines read from the user, or NULL if they have not
1331 struct counted_command_line
*cmd
;
1334 /* A callback for map_breakpoint_numbers that sets the commands for
1335 commands_command. */
1338 do_map_commands_command (struct breakpoint
*b
, void *data
)
1340 struct commands_info
*info
= data
;
1342 if (info
->cmd
== NULL
)
1344 struct command_line
*l
;
1346 if (info
->control
!= NULL
)
1347 l
= copy_command_lines (info
->control
->body_list
[0]);
1350 struct cleanup
*old_chain
;
1353 str
= xstrprintf (_("Type commands for breakpoint(s) "
1354 "%s, one per line."),
1357 old_chain
= make_cleanup (xfree
, str
);
1359 l
= read_command_lines (str
,
1362 ? check_tracepoint_command
: 0),
1365 do_cleanups (old_chain
);
1368 info
->cmd
= alloc_counted_command_line (l
);
1371 /* If a breakpoint was on the list more than once, we don't need to
1373 if (b
->commands
!= info
->cmd
)
1375 validate_commands_for_breakpoint (b
, info
->cmd
->commands
);
1376 incref_counted_command_line (info
->cmd
);
1377 decref_counted_command_line (&b
->commands
);
1378 b
->commands
= info
->cmd
;
1379 observer_notify_breakpoint_modified (b
);
1384 commands_command_1 (char *arg
, int from_tty
,
1385 struct command_line
*control
)
1387 struct cleanup
*cleanups
;
1388 struct commands_info info
;
1390 info
.from_tty
= from_tty
;
1391 info
.control
= control
;
1393 /* If we read command lines from the user, then `info' will hold an
1394 extra reference to the commands that we must clean up. */
1395 cleanups
= make_cleanup_decref_counted_command_line (&info
.cmd
);
1397 if (arg
== NULL
|| !*arg
)
1399 if (breakpoint_count
- prev_breakpoint_count
> 1)
1400 arg
= xstrprintf ("%d-%d", prev_breakpoint_count
+ 1,
1402 else if (breakpoint_count
> 0)
1403 arg
= xstrprintf ("%d", breakpoint_count
);
1406 /* So that we don't try to free the incoming non-NULL
1407 argument in the cleanup below. Mapping breakpoint
1408 numbers will fail in this case. */
1413 /* The command loop has some static state, so we need to preserve
1415 arg
= xstrdup (arg
);
1418 make_cleanup (xfree
, arg
);
1422 map_breakpoint_numbers (arg
, do_map_commands_command
, &info
);
1424 if (info
.cmd
== NULL
)
1425 error (_("No breakpoints specified."));
1427 do_cleanups (cleanups
);
1431 commands_command (char *arg
, int from_tty
)
1433 commands_command_1 (arg
, from_tty
, NULL
);
1436 /* Like commands_command, but instead of reading the commands from
1437 input stream, takes them from an already parsed command structure.
1439 This is used by cli-script.c to DTRT with breakpoint commands
1440 that are part of if and while bodies. */
1441 enum command_control_type
1442 commands_from_control_command (char *arg
, struct command_line
*cmd
)
1444 commands_command_1 (arg
, 0, cmd
);
1445 return simple_control
;
1448 /* Return non-zero if BL->TARGET_INFO contains valid information. */
1451 bp_location_has_shadow (struct bp_location
*bl
)
1453 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
1457 if (bl
->target_info
.shadow_len
== 0)
1458 /* BL isn't valid, or doesn't shadow memory. */
1463 /* Update BUF, which is LEN bytes read from the target address
1464 MEMADDR, by replacing a memory breakpoint with its shadowed
1467 If READBUF is not NULL, this buffer must not overlap with the of
1468 the breakpoint location's shadow_contents buffer. Otherwise, a
1469 failed assertion internal error will be raised. */
1472 one_breakpoint_xfer_memory (gdb_byte
*readbuf
, gdb_byte
*writebuf
,
1473 const gdb_byte
*writebuf_org
,
1474 ULONGEST memaddr
, LONGEST len
,
1475 struct bp_target_info
*target_info
,
1476 struct gdbarch
*gdbarch
)
1478 /* Now do full processing of the found relevant range of elements. */
1479 CORE_ADDR bp_addr
= 0;
1483 if (!breakpoint_address_match (target_info
->placed_address_space
, 0,
1484 current_program_space
->aspace
, 0))
1486 /* The breakpoint is inserted in a different address space. */
1490 /* Addresses and length of the part of the breakpoint that
1492 bp_addr
= target_info
->placed_address
;
1493 bp_size
= target_info
->shadow_len
;
1495 if (bp_addr
+ bp_size
<= memaddr
)
1497 /* The breakpoint is entirely before the chunk of memory we are
1502 if (bp_addr
>= memaddr
+ len
)
1504 /* The breakpoint is entirely after the chunk of memory we are
1509 /* Offset within shadow_contents. */
1510 if (bp_addr
< memaddr
)
1512 /* Only copy the second part of the breakpoint. */
1513 bp_size
-= memaddr
- bp_addr
;
1514 bptoffset
= memaddr
- bp_addr
;
1518 if (bp_addr
+ bp_size
> memaddr
+ len
)
1520 /* Only copy the first part of the breakpoint. */
1521 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
1524 if (readbuf
!= NULL
)
1526 /* Verify that the readbuf buffer does not overlap with the
1527 shadow_contents buffer. */
1528 gdb_assert (target_info
->shadow_contents
>= readbuf
+ len
1529 || readbuf
>= (target_info
->shadow_contents
1530 + target_info
->shadow_len
));
1532 /* Update the read buffer with this inserted breakpoint's
1534 memcpy (readbuf
+ bp_addr
- memaddr
,
1535 target_info
->shadow_contents
+ bptoffset
, bp_size
);
1539 const unsigned char *bp
;
1540 CORE_ADDR addr
= target_info
->reqstd_address
;
1543 /* Update the shadow with what we want to write to memory. */
1544 memcpy (target_info
->shadow_contents
+ bptoffset
,
1545 writebuf_org
+ bp_addr
- memaddr
, bp_size
);
1547 /* Determine appropriate breakpoint contents and size for this
1549 bp
= gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &placed_size
);
1551 /* Update the final write buffer with this inserted
1552 breakpoint's INSN. */
1553 memcpy (writebuf
+ bp_addr
- memaddr
, bp
+ bptoffset
, bp_size
);
1557 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
1558 by replacing any memory breakpoints with their shadowed contents.
1560 If READBUF is not NULL, this buffer must not overlap with any of
1561 the breakpoint location's shadow_contents buffers. Otherwise,
1562 a failed assertion internal error will be raised.
1564 The range of shadowed area by each bp_location is:
1565 bl->address - bp_location_placed_address_before_address_max
1566 up to bl->address + bp_location_shadow_len_after_address_max
1567 The range we were requested to resolve shadows for is:
1568 memaddr ... memaddr + len
1569 Thus the safe cutoff boundaries for performance optimization are
1570 memaddr + len <= (bl->address
1571 - bp_location_placed_address_before_address_max)
1573 bl->address + bp_location_shadow_len_after_address_max <= memaddr */
1576 breakpoint_xfer_memory (gdb_byte
*readbuf
, gdb_byte
*writebuf
,
1577 const gdb_byte
*writebuf_org
,
1578 ULONGEST memaddr
, LONGEST len
)
1580 /* Left boundary, right boundary and median element of our binary
1582 unsigned bc_l
, bc_r
, bc
;
1585 /* Find BC_L which is a leftmost element which may affect BUF
1586 content. It is safe to report lower value but a failure to
1587 report higher one. */
1590 bc_r
= bp_location_count
;
1591 while (bc_l
+ 1 < bc_r
)
1593 struct bp_location
*bl
;
1595 bc
= (bc_l
+ bc_r
) / 2;
1596 bl
= bp_location
[bc
];
1598 /* Check first BL->ADDRESS will not overflow due to the added
1599 constant. Then advance the left boundary only if we are sure
1600 the BC element can in no way affect the BUF content (MEMADDR
1601 to MEMADDR + LEN range).
1603 Use the BP_LOCATION_SHADOW_LEN_AFTER_ADDRESS_MAX safety
1604 offset so that we cannot miss a breakpoint with its shadow
1605 range tail still reaching MEMADDR. */
1607 if ((bl
->address
+ bp_location_shadow_len_after_address_max
1609 && (bl
->address
+ bp_location_shadow_len_after_address_max
1616 /* Due to the binary search above, we need to make sure we pick the
1617 first location that's at BC_L's address. E.g., if there are
1618 multiple locations at the same address, BC_L may end up pointing
1619 at a duplicate location, and miss the "master"/"inserted"
1620 location. Say, given locations L1, L2 and L3 at addresses A and
1623 L1@A, L2@A, L3@B, ...
1625 BC_L could end up pointing at location L2, while the "master"
1626 location could be L1. Since the `loc->inserted' flag is only set
1627 on "master" locations, we'd forget to restore the shadow of L1
1630 && bp_location
[bc_l
]->address
== bp_location
[bc_l
- 1]->address
)
1633 /* Now do full processing of the found relevant range of elements. */
1635 for (bc
= bc_l
; bc
< bp_location_count
; bc
++)
1637 struct bp_location
*bl
= bp_location
[bc
];
1638 CORE_ADDR bp_addr
= 0;
1642 /* bp_location array has BL->OWNER always non-NULL. */
1643 if (bl
->owner
->type
== bp_none
)
1644 warning (_("reading through apparently deleted breakpoint #%d?"),
1647 /* Performance optimization: any further element can no longer affect BUF
1650 if (bl
->address
>= bp_location_placed_address_before_address_max
1651 && memaddr
+ len
<= (bl
->address
1652 - bp_location_placed_address_before_address_max
))
1655 if (!bp_location_has_shadow (bl
))
1658 one_breakpoint_xfer_memory (readbuf
, writebuf
, writebuf_org
,
1659 memaddr
, len
, &bl
->target_info
, bl
->gdbarch
);
1665 /* Return true if BPT is either a software breakpoint or a hardware
1669 is_breakpoint (const struct breakpoint
*bpt
)
1671 return (bpt
->type
== bp_breakpoint
1672 || bpt
->type
== bp_hardware_breakpoint
1673 || bpt
->type
== bp_dprintf
);
1676 /* Return true if BPT is of any hardware watchpoint kind. */
1679 is_hardware_watchpoint (const struct breakpoint
*bpt
)
1681 return (bpt
->type
== bp_hardware_watchpoint
1682 || bpt
->type
== bp_read_watchpoint
1683 || bpt
->type
== bp_access_watchpoint
);
1686 /* Return true if BPT is of any watchpoint kind, hardware or
1690 is_watchpoint (const struct breakpoint
*bpt
)
1692 return (is_hardware_watchpoint (bpt
)
1693 || bpt
->type
== bp_watchpoint
);
1696 /* Returns true if the current thread and its running state are safe
1697 to evaluate or update watchpoint B. Watchpoints on local
1698 expressions need to be evaluated in the context of the thread that
1699 was current when the watchpoint was created, and, that thread needs
1700 to be stopped to be able to select the correct frame context.
1701 Watchpoints on global expressions can be evaluated on any thread,
1702 and in any state. It is presently left to the target allowing
1703 memory accesses when threads are running. */
1706 watchpoint_in_thread_scope (struct watchpoint
*b
)
1708 return (b
->base
.pspace
== current_program_space
1709 && (ptid_equal (b
->watchpoint_thread
, null_ptid
)
1710 || (ptid_equal (inferior_ptid
, b
->watchpoint_thread
)
1711 && !is_executing (inferior_ptid
))));
1714 /* Set watchpoint B to disp_del_at_next_stop, even including its possible
1715 associated bp_watchpoint_scope breakpoint. */
1718 watchpoint_del_at_next_stop (struct watchpoint
*w
)
1720 struct breakpoint
*b
= &w
->base
;
1722 if (b
->related_breakpoint
!= b
)
1724 gdb_assert (b
->related_breakpoint
->type
== bp_watchpoint_scope
);
1725 gdb_assert (b
->related_breakpoint
->related_breakpoint
== b
);
1726 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
1727 b
->related_breakpoint
->related_breakpoint
= b
->related_breakpoint
;
1728 b
->related_breakpoint
= b
;
1730 b
->disposition
= disp_del_at_next_stop
;
1733 /* Extract a bitfield value from value VAL using the bit parameters contained in
1736 static struct value
*
1737 extract_bitfield_from_watchpoint_value (struct watchpoint
*w
, struct value
*val
)
1739 struct value
*bit_val
;
1744 bit_val
= allocate_value (value_type (val
));
1746 unpack_value_bitfield (bit_val
,
1749 value_contents_for_printing (val
),
1756 /* Assuming that B is a watchpoint:
1757 - Reparse watchpoint expression, if REPARSE is non-zero
1758 - Evaluate expression and store the result in B->val
1759 - Evaluate the condition if there is one, and store the result
1761 - Update the list of values that must be watched in B->loc.
1763 If the watchpoint disposition is disp_del_at_next_stop, then do
1764 nothing. If this is local watchpoint that is out of scope, delete
1767 Even with `set breakpoint always-inserted on' the watchpoints are
1768 removed + inserted on each stop here. Normal breakpoints must
1769 never be removed because they might be missed by a running thread
1770 when debugging in non-stop mode. On the other hand, hardware
1771 watchpoints (is_hardware_watchpoint; processed here) are specific
1772 to each LWP since they are stored in each LWP's hardware debug
1773 registers. Therefore, such LWP must be stopped first in order to
1774 be able to modify its hardware watchpoints.
1776 Hardware watchpoints must be reset exactly once after being
1777 presented to the user. It cannot be done sooner, because it would
1778 reset the data used to present the watchpoint hit to the user. And
1779 it must not be done later because it could display the same single
1780 watchpoint hit during multiple GDB stops. Note that the latter is
1781 relevant only to the hardware watchpoint types bp_read_watchpoint
1782 and bp_access_watchpoint. False hit by bp_hardware_watchpoint is
1783 not user-visible - its hit is suppressed if the memory content has
1786 The following constraints influence the location where we can reset
1787 hardware watchpoints:
1789 * target_stopped_by_watchpoint and target_stopped_data_address are
1790 called several times when GDB stops.
1793 * Multiple hardware watchpoints can be hit at the same time,
1794 causing GDB to stop. GDB only presents one hardware watchpoint
1795 hit at a time as the reason for stopping, and all the other hits
1796 are presented later, one after the other, each time the user
1797 requests the execution to be resumed. Execution is not resumed
1798 for the threads still having pending hit event stored in
1799 LWP_INFO->STATUS. While the watchpoint is already removed from
1800 the inferior on the first stop the thread hit event is kept being
1801 reported from its cached value by linux_nat_stopped_data_address
1802 until the real thread resume happens after the watchpoint gets
1803 presented and thus its LWP_INFO->STATUS gets reset.
1805 Therefore the hardware watchpoint hit can get safely reset on the
1806 watchpoint removal from inferior. */
1809 update_watchpoint (struct watchpoint
*b
, int reparse
)
1811 int within_current_scope
;
1812 struct frame_id saved_frame_id
;
1815 /* If this is a local watchpoint, we only want to check if the
1816 watchpoint frame is in scope if the current thread is the thread
1817 that was used to create the watchpoint. */
1818 if (!watchpoint_in_thread_scope (b
))
1821 if (b
->base
.disposition
== disp_del_at_next_stop
)
1826 /* Determine if the watchpoint is within scope. */
1827 if (b
->exp_valid_block
== NULL
)
1828 within_current_scope
= 1;
1831 struct frame_info
*fi
= get_current_frame ();
1832 struct gdbarch
*frame_arch
= get_frame_arch (fi
);
1833 CORE_ADDR frame_pc
= get_frame_pc (fi
);
1835 /* If we're in a function epilogue, unwinding may not work
1836 properly, so do not attempt to recreate locations at this
1837 point. See similar comments in watchpoint_check. */
1838 if (gdbarch_in_function_epilogue_p (frame_arch
, frame_pc
))
1841 /* Save the current frame's ID so we can restore it after
1842 evaluating the watchpoint expression on its own frame. */
1843 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
1844 took a frame parameter, so that we didn't have to change the
1847 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
1849 fi
= frame_find_by_id (b
->watchpoint_frame
);
1850 within_current_scope
= (fi
!= NULL
);
1851 if (within_current_scope
)
1855 /* We don't free locations. They are stored in the bp_location array
1856 and update_global_location_list will eventually delete them and
1857 remove breakpoints if needed. */
1860 if (within_current_scope
&& reparse
)
1869 s
= b
->exp_string_reparse
? b
->exp_string_reparse
: b
->exp_string
;
1870 b
->exp
= parse_exp_1 (&s
, 0, b
->exp_valid_block
, 0);
1871 /* If the meaning of expression itself changed, the old value is
1872 no longer relevant. We don't want to report a watchpoint hit
1873 to the user when the old value and the new value may actually
1874 be completely different objects. */
1875 value_free (b
->val
);
1879 /* Note that unlike with breakpoints, the watchpoint's condition
1880 expression is stored in the breakpoint object, not in the
1881 locations (re)created below. */
1882 if (b
->base
.cond_string
!= NULL
)
1884 if (b
->cond_exp
!= NULL
)
1886 xfree (b
->cond_exp
);
1890 s
= b
->base
.cond_string
;
1891 b
->cond_exp
= parse_exp_1 (&s
, 0, b
->cond_exp_valid_block
, 0);
1895 /* If we failed to parse the expression, for example because
1896 it refers to a global variable in a not-yet-loaded shared library,
1897 don't try to insert watchpoint. We don't automatically delete
1898 such watchpoint, though, since failure to parse expression
1899 is different from out-of-scope watchpoint. */
1900 if (!target_has_execution
)
1902 /* Without execution, memory can't change. No use to try and
1903 set watchpoint locations. The watchpoint will be reset when
1904 the target gains execution, through breakpoint_re_set. */
1905 if (!can_use_hw_watchpoints
)
1907 if (b
->base
.ops
->works_in_software_mode (&b
->base
))
1908 b
->base
.type
= bp_watchpoint
;
1910 error (_("Can't set read/access watchpoint when "
1911 "hardware watchpoints are disabled."));
1914 else if (within_current_scope
&& b
->exp
)
1917 struct value
*val_chain
, *v
, *result
, *next
;
1918 struct program_space
*frame_pspace
;
1920 fetch_subexp_value (b
->exp
, &pc
, &v
, &result
, &val_chain
, 0);
1922 /* Avoid setting b->val if it's already set. The meaning of
1923 b->val is 'the last value' user saw, and we should update
1924 it only if we reported that last value to user. As it
1925 happens, the code that reports it updates b->val directly.
1926 We don't keep track of the memory value for masked
1928 if (!b
->val_valid
&& !is_masked_watchpoint (&b
->base
))
1930 if (b
->val_bitsize
!= 0)
1932 v
= extract_bitfield_from_watchpoint_value (b
, v
);
1940 frame_pspace
= get_frame_program_space (get_selected_frame (NULL
));
1942 /* Look at each value on the value chain. */
1943 for (v
= val_chain
; v
; v
= value_next (v
))
1945 /* If it's a memory location, and GDB actually needed
1946 its contents to evaluate the expression, then we
1947 must watch it. If the first value returned is
1948 still lazy, that means an error occurred reading it;
1949 watch it anyway in case it becomes readable. */
1950 if (VALUE_LVAL (v
) == lval_memory
1951 && (v
== val_chain
|| ! value_lazy (v
)))
1953 struct type
*vtype
= check_typedef (value_type (v
));
1955 /* We only watch structs and arrays if user asked
1956 for it explicitly, never if they just happen to
1957 appear in the middle of some value chain. */
1959 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
1960 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
1964 struct bp_location
*loc
, **tmp
;
1965 int bitpos
= 0, bitsize
= 0;
1967 if (value_bitsize (v
) != 0)
1969 /* Extract the bit parameters out from the bitfield
1971 bitpos
= value_bitpos (v
);
1972 bitsize
= value_bitsize (v
);
1974 else if (v
== result
&& b
->val_bitsize
!= 0)
1976 /* If VAL_BITSIZE != 0 then RESULT is actually a bitfield
1977 lvalue whose bit parameters are saved in the fields
1978 VAL_BITPOS and VAL_BITSIZE. */
1979 bitpos
= b
->val_bitpos
;
1980 bitsize
= b
->val_bitsize
;
1983 addr
= value_address (v
);
1986 /* Skip the bytes that don't contain the bitfield. */
1991 if (b
->base
.type
== bp_read_watchpoint
)
1993 else if (b
->base
.type
== bp_access_watchpoint
)
1996 loc
= allocate_bp_location (&b
->base
);
1997 for (tmp
= &(b
->base
.loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
2000 loc
->gdbarch
= get_type_arch (value_type (v
));
2002 loc
->pspace
= frame_pspace
;
2003 loc
->address
= addr
;
2007 /* Just cover the bytes that make up the bitfield. */
2008 loc
->length
= ((bitpos
% 8) + bitsize
+ 7) / 8;
2011 loc
->length
= TYPE_LENGTH (value_type (v
));
2013 loc
->watchpoint_type
= type
;
2018 /* Change the type of breakpoint between hardware assisted or
2019 an ordinary watchpoint depending on the hardware support
2020 and free hardware slots. REPARSE is set when the inferior
2025 enum bp_loc_type loc_type
;
2026 struct bp_location
*bl
;
2028 reg_cnt
= can_use_hardware_watchpoint (val_chain
);
2032 int i
, target_resources_ok
, other_type_used
;
2035 /* Use an exact watchpoint when there's only one memory region to be
2036 watched, and only one debug register is needed to watch it. */
2037 b
->exact
= target_exact_watchpoints
&& reg_cnt
== 1;
2039 /* We need to determine how many resources are already
2040 used for all other hardware watchpoints plus this one
2041 to see if we still have enough resources to also fit
2042 this watchpoint in as well. */
2044 /* If this is a software watchpoint, we try to turn it
2045 to a hardware one -- count resources as if B was of
2046 hardware watchpoint type. */
2047 type
= b
->base
.type
;
2048 if (type
== bp_watchpoint
)
2049 type
= bp_hardware_watchpoint
;
2051 /* This watchpoint may or may not have been placed on
2052 the list yet at this point (it won't be in the list
2053 if we're trying to create it for the first time,
2054 through watch_command), so always account for it
2057 /* Count resources used by all watchpoints except B. */
2058 i
= hw_watchpoint_used_count_others (&b
->base
, type
, &other_type_used
);
2060 /* Add in the resources needed for B. */
2061 i
+= hw_watchpoint_use_count (&b
->base
);
2064 = target_can_use_hardware_watchpoint (type
, i
, other_type_used
);
2065 if (target_resources_ok
<= 0)
2067 int sw_mode
= b
->base
.ops
->works_in_software_mode (&b
->base
);
2069 if (target_resources_ok
== 0 && !sw_mode
)
2070 error (_("Target does not support this type of "
2071 "hardware watchpoint."));
2072 else if (target_resources_ok
< 0 && !sw_mode
)
2073 error (_("There are not enough available hardware "
2074 "resources for this watchpoint."));
2076 /* Downgrade to software watchpoint. */
2077 b
->base
.type
= bp_watchpoint
;
2081 /* If this was a software watchpoint, we've just
2082 found we have enough resources to turn it to a
2083 hardware watchpoint. Otherwise, this is a
2085 b
->base
.type
= type
;
2088 else if (!b
->base
.ops
->works_in_software_mode (&b
->base
))
2090 if (!can_use_hw_watchpoints
)
2091 error (_("Can't set read/access watchpoint when "
2092 "hardware watchpoints are disabled."));
2094 error (_("Expression cannot be implemented with "
2095 "read/access watchpoint."));
2098 b
->base
.type
= bp_watchpoint
;
2100 loc_type
= (b
->base
.type
== bp_watchpoint
? bp_loc_other
2101 : bp_loc_hardware_watchpoint
);
2102 for (bl
= b
->base
.loc
; bl
; bl
= bl
->next
)
2103 bl
->loc_type
= loc_type
;
2106 for (v
= val_chain
; v
; v
= next
)
2108 next
= value_next (v
);
2113 /* If a software watchpoint is not watching any memory, then the
2114 above left it without any location set up. But,
2115 bpstat_stop_status requires a location to be able to report
2116 stops, so make sure there's at least a dummy one. */
2117 if (b
->base
.type
== bp_watchpoint
&& b
->base
.loc
== NULL
)
2119 struct breakpoint
*base
= &b
->base
;
2120 base
->loc
= allocate_bp_location (base
);
2121 base
->loc
->pspace
= frame_pspace
;
2122 base
->loc
->address
= -1;
2123 base
->loc
->length
= -1;
2124 base
->loc
->watchpoint_type
= -1;
2127 else if (!within_current_scope
)
2129 printf_filtered (_("\
2130 Watchpoint %d deleted because the program has left the block\n\
2131 in which its expression is valid.\n"),
2133 watchpoint_del_at_next_stop (b
);
2136 /* Restore the selected frame. */
2138 select_frame (frame_find_by_id (saved_frame_id
));
2142 /* Returns 1 iff breakpoint location should be
2143 inserted in the inferior. We don't differentiate the type of BL's owner
2144 (breakpoint vs. tracepoint), although insert_location in tracepoint's
2145 breakpoint_ops is not defined, because in insert_bp_location,
2146 tracepoint's insert_location will not be called. */
2148 should_be_inserted (struct bp_location
*bl
)
2150 if (bl
->owner
== NULL
|| !breakpoint_enabled (bl
->owner
))
2153 if (bl
->owner
->disposition
== disp_del_at_next_stop
)
2156 if (!bl
->enabled
|| bl
->shlib_disabled
|| bl
->duplicate
)
2159 if (user_breakpoint_p (bl
->owner
) && bl
->pspace
->executing_startup
)
2162 /* This is set for example, when we're attached to the parent of a
2163 vfork, and have detached from the child. The child is running
2164 free, and we expect it to do an exec or exit, at which point the
2165 OS makes the parent schedulable again (and the target reports
2166 that the vfork is done). Until the child is done with the shared
2167 memory region, do not insert breakpoints in the parent, otherwise
2168 the child could still trip on the parent's breakpoints. Since
2169 the parent is blocked anyway, it won't miss any breakpoint. */
2170 if (bl
->pspace
->breakpoints_not_allowed
)
2173 /* Don't insert a breakpoint if we're trying to step past its
2175 if ((bl
->loc_type
== bp_loc_software_breakpoint
2176 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
2177 && stepping_past_instruction_at (bl
->pspace
->aspace
,
2182 fprintf_unfiltered (gdb_stdlog
,
2183 "infrun: skipping breakpoint: "
2184 "stepping past insn at: %s\n",
2185 paddress (bl
->gdbarch
, bl
->address
));
2190 /* Don't insert watchpoints if we're trying to step past the
2191 instruction that triggered one. */
2192 if ((bl
->loc_type
== bp_loc_hardware_watchpoint
)
2193 && stepping_past_nonsteppable_watchpoint ())
2197 fprintf_unfiltered (gdb_stdlog
,
2198 "infrun: stepping past non-steppable watchpoint. "
2199 "skipping watchpoint at %s:%d\n",
2200 paddress (bl
->gdbarch
, bl
->address
),
2209 /* Same as should_be_inserted but does the check assuming
2210 that the location is not duplicated. */
2213 unduplicated_should_be_inserted (struct bp_location
*bl
)
2216 const int save_duplicate
= bl
->duplicate
;
2219 result
= should_be_inserted (bl
);
2220 bl
->duplicate
= save_duplicate
;
2224 /* Parses a conditional described by an expression COND into an
2225 agent expression bytecode suitable for evaluation
2226 by the bytecode interpreter. Return NULL if there was
2227 any error during parsing. */
2229 static struct agent_expr
*
2230 parse_cond_to_aexpr (CORE_ADDR scope
, struct expression
*cond
)
2232 struct agent_expr
*aexpr
= NULL
;
2233 volatile struct gdb_exception ex
;
2238 /* We don't want to stop processing, so catch any errors
2239 that may show up. */
2240 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
2242 aexpr
= gen_eval_for_expr (scope
, cond
);
2247 /* If we got here, it means the condition could not be parsed to a valid
2248 bytecode expression and thus can't be evaluated on the target's side.
2249 It's no use iterating through the conditions. */
2253 /* We have a valid agent expression. */
2257 /* Based on location BL, create a list of breakpoint conditions to be
2258 passed on to the target. If we have duplicated locations with different
2259 conditions, we will add such conditions to the list. The idea is that the
2260 target will evaluate the list of conditions and will only notify GDB when
2261 one of them is true. */
2264 build_target_condition_list (struct bp_location
*bl
)
2266 struct bp_location
**locp
= NULL
, **loc2p
;
2267 int null_condition_or_parse_error
= 0;
2268 int modified
= bl
->needs_update
;
2269 struct bp_location
*loc
;
2271 /* Release conditions left over from a previous insert. */
2272 VEC_free (agent_expr_p
, bl
->target_info
.conditions
);
2274 /* This is only meaningful if the target is
2275 evaluating conditions and if the user has
2276 opted for condition evaluation on the target's
2278 if (gdb_evaluates_breakpoint_condition_p ()
2279 || !target_supports_evaluation_of_breakpoint_conditions ())
2282 /* Do a first pass to check for locations with no assigned
2283 conditions or conditions that fail to parse to a valid agent expression
2284 bytecode. If any of these happen, then it's no use to send conditions
2285 to the target since this location will always trigger and generate a
2286 response back to GDB. */
2287 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2290 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2294 struct agent_expr
*aexpr
;
2296 /* Re-parse the conditions since something changed. In that
2297 case we already freed the condition bytecodes (see
2298 force_breakpoint_reinsertion). We just
2299 need to parse the condition to bytecodes again. */
2300 aexpr
= parse_cond_to_aexpr (bl
->address
, loc
->cond
);
2301 loc
->cond_bytecode
= aexpr
;
2303 /* Check if we managed to parse the conditional expression
2304 correctly. If not, we will not send this condition
2310 /* If we have a NULL bytecode expression, it means something
2311 went wrong or we have a null condition expression. */
2312 if (!loc
->cond_bytecode
)
2314 null_condition_or_parse_error
= 1;
2320 /* If any of these happened, it means we will have to evaluate the conditions
2321 for the location's address on gdb's side. It is no use keeping bytecodes
2322 for all the other duplicate locations, thus we free all of them here.
2324 This is so we have a finer control over which locations' conditions are
2325 being evaluated by GDB or the remote stub. */
2326 if (null_condition_or_parse_error
)
2328 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2331 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2333 /* Only go as far as the first NULL bytecode is
2335 if (!loc
->cond_bytecode
)
2338 free_agent_expr (loc
->cond_bytecode
);
2339 loc
->cond_bytecode
= NULL
;
2344 /* No NULL conditions or failed bytecode generation. Build a condition list
2345 for this location's address. */
2346 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2350 && is_breakpoint (loc
->owner
)
2351 && loc
->pspace
->num
== bl
->pspace
->num
2352 && loc
->owner
->enable_state
== bp_enabled
2354 /* Add the condition to the vector. This will be used later to send the
2355 conditions to the target. */
2356 VEC_safe_push (agent_expr_p
, bl
->target_info
.conditions
,
2357 loc
->cond_bytecode
);
2363 /* Parses a command described by string CMD into an agent expression
2364 bytecode suitable for evaluation by the bytecode interpreter.
2365 Return NULL if there was any error during parsing. */
2367 static struct agent_expr
*
2368 parse_cmd_to_aexpr (CORE_ADDR scope
, char *cmd
)
2370 struct cleanup
*old_cleanups
= 0;
2371 struct expression
*expr
, **argvec
;
2372 struct agent_expr
*aexpr
= NULL
;
2373 volatile struct gdb_exception ex
;
2374 const char *cmdrest
;
2375 const char *format_start
, *format_end
;
2376 struct format_piece
*fpieces
;
2378 struct gdbarch
*gdbarch
= get_current_arch ();
2385 if (*cmdrest
== ',')
2387 cmdrest
= skip_spaces_const (cmdrest
);
2389 if (*cmdrest
++ != '"')
2390 error (_("No format string following the location"));
2392 format_start
= cmdrest
;
2394 fpieces
= parse_format_string (&cmdrest
);
2396 old_cleanups
= make_cleanup (free_format_pieces_cleanup
, &fpieces
);
2398 format_end
= cmdrest
;
2400 if (*cmdrest
++ != '"')
2401 error (_("Bad format string, non-terminated '\"'."));
2403 cmdrest
= skip_spaces_const (cmdrest
);
2405 if (!(*cmdrest
== ',' || *cmdrest
== '\0'))
2406 error (_("Invalid argument syntax"));
2408 if (*cmdrest
== ',')
2410 cmdrest
= skip_spaces_const (cmdrest
);
2412 /* For each argument, make an expression. */
2414 argvec
= (struct expression
**) alloca (strlen (cmd
)
2415 * sizeof (struct expression
*));
2418 while (*cmdrest
!= '\0')
2423 expr
= parse_exp_1 (&cmd1
, scope
, block_for_pc (scope
), 1);
2424 argvec
[nargs
++] = expr
;
2426 if (*cmdrest
== ',')
2430 /* We don't want to stop processing, so catch any errors
2431 that may show up. */
2432 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
2434 aexpr
= gen_printf (scope
, gdbarch
, 0, 0,
2435 format_start
, format_end
- format_start
,
2436 fpieces
, nargs
, argvec
);
2439 do_cleanups (old_cleanups
);
2443 /* If we got here, it means the command could not be parsed to a valid
2444 bytecode expression and thus can't be evaluated on the target's side.
2445 It's no use iterating through the other commands. */
2449 /* We have a valid agent expression, return it. */
2453 /* Based on location BL, create a list of breakpoint commands to be
2454 passed on to the target. If we have duplicated locations with
2455 different commands, we will add any such to the list. */
2458 build_target_command_list (struct bp_location
*bl
)
2460 struct bp_location
**locp
= NULL
, **loc2p
;
2461 int null_command_or_parse_error
= 0;
2462 int modified
= bl
->needs_update
;
2463 struct bp_location
*loc
;
2465 /* Release commands left over from a previous insert. */
2466 VEC_free (agent_expr_p
, bl
->target_info
.tcommands
);
2468 if (!target_can_run_breakpoint_commands ())
2471 /* For now, limit to agent-style dprintf breakpoints. */
2472 if (dprintf_style
!= dprintf_style_agent
)
2475 /* For now, if we have any duplicate location that isn't a dprintf,
2476 don't install the target-side commands, as that would make the
2477 breakpoint not be reported to the core, and we'd lose
2479 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2482 if (is_breakpoint (loc
->owner
)
2483 && loc
->pspace
->num
== bl
->pspace
->num
2484 && loc
->owner
->type
!= bp_dprintf
)
2488 /* Do a first pass to check for locations with no assigned
2489 conditions or conditions that fail to parse to a valid agent expression
2490 bytecode. If any of these happen, then it's no use to send conditions
2491 to the target since this location will always trigger and generate a
2492 response back to GDB. */
2493 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2496 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2500 struct agent_expr
*aexpr
;
2502 /* Re-parse the commands since something changed. In that
2503 case we already freed the command bytecodes (see
2504 force_breakpoint_reinsertion). We just
2505 need to parse the command to bytecodes again. */
2506 aexpr
= parse_cmd_to_aexpr (bl
->address
,
2507 loc
->owner
->extra_string
);
2508 loc
->cmd_bytecode
= aexpr
;
2514 /* If we have a NULL bytecode expression, it means something
2515 went wrong or we have a null command expression. */
2516 if (!loc
->cmd_bytecode
)
2518 null_command_or_parse_error
= 1;
2524 /* If anything failed, then we're not doing target-side commands,
2526 if (null_command_or_parse_error
)
2528 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2531 if (is_breakpoint (loc
->owner
)
2532 && loc
->pspace
->num
== bl
->pspace
->num
)
2534 /* Only go as far as the first NULL bytecode is
2536 if (loc
->cmd_bytecode
== NULL
)
2539 free_agent_expr (loc
->cmd_bytecode
);
2540 loc
->cmd_bytecode
= NULL
;
2545 /* No NULL commands or failed bytecode generation. Build a command list
2546 for this location's address. */
2547 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2550 if (loc
->owner
->extra_string
2551 && is_breakpoint (loc
->owner
)
2552 && loc
->pspace
->num
== bl
->pspace
->num
2553 && loc
->owner
->enable_state
== bp_enabled
2555 /* Add the command to the vector. This will be used later
2556 to send the commands to the target. */
2557 VEC_safe_push (agent_expr_p
, bl
->target_info
.tcommands
,
2561 bl
->target_info
.persist
= 0;
2562 /* Maybe flag this location as persistent. */
2563 if (bl
->owner
->type
== bp_dprintf
&& disconnected_dprintf
)
2564 bl
->target_info
.persist
= 1;
2567 /* Insert a low-level "breakpoint" of some type. BL is the breakpoint
2568 location. Any error messages are printed to TMP_ERROR_STREAM; and
2569 DISABLED_BREAKS, and HW_BREAKPOINT_ERROR are used to report problems.
2570 Returns 0 for success, 1 if the bp_location type is not supported or
2573 NOTE drow/2003-09-09: This routine could be broken down to an
2574 object-style method for each breakpoint or catchpoint type. */
2576 insert_bp_location (struct bp_location
*bl
,
2577 struct ui_file
*tmp_error_stream
,
2578 int *disabled_breaks
,
2579 int *hw_breakpoint_error
,
2580 int *hw_bp_error_explained_already
)
2582 enum errors bp_err
= GDB_NO_ERROR
;
2583 const char *bp_err_message
= NULL
;
2584 volatile struct gdb_exception e
;
2586 if (!should_be_inserted (bl
) || (bl
->inserted
&& !bl
->needs_update
))
2589 /* Note we don't initialize bl->target_info, as that wipes out
2590 the breakpoint location's shadow_contents if the breakpoint
2591 is still inserted at that location. This in turn breaks
2592 target_read_memory which depends on these buffers when
2593 a memory read is requested at the breakpoint location:
2594 Once the target_info has been wiped, we fail to see that
2595 we have a breakpoint inserted at that address and thus
2596 read the breakpoint instead of returning the data saved in
2597 the breakpoint location's shadow contents. */
2598 bl
->target_info
.reqstd_address
= bl
->address
;
2599 bl
->target_info
.placed_address_space
= bl
->pspace
->aspace
;
2600 bl
->target_info
.length
= bl
->length
;
2602 /* When working with target-side conditions, we must pass all the conditions
2603 for the same breakpoint address down to the target since GDB will not
2604 insert those locations. With a list of breakpoint conditions, the target
2605 can decide when to stop and notify GDB. */
2607 if (is_breakpoint (bl
->owner
))
2609 build_target_condition_list (bl
);
2610 build_target_command_list (bl
);
2611 /* Reset the modification marker. */
2612 bl
->needs_update
= 0;
2615 if (bl
->loc_type
== bp_loc_software_breakpoint
2616 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
2618 if (bl
->owner
->type
!= bp_hardware_breakpoint
)
2620 /* If the explicitly specified breakpoint type
2621 is not hardware breakpoint, check the memory map to see
2622 if the breakpoint address is in read only memory or not.
2624 Two important cases are:
2625 - location type is not hardware breakpoint, memory
2626 is readonly. We change the type of the location to
2627 hardware breakpoint.
2628 - location type is hardware breakpoint, memory is
2629 read-write. This means we've previously made the
2630 location hardware one, but then the memory map changed,
2633 When breakpoints are removed, remove_breakpoints will use
2634 location types we've just set here, the only possible
2635 problem is that memory map has changed during running
2636 program, but it's not going to work anyway with current
2638 struct mem_region
*mr
2639 = lookup_mem_region (bl
->target_info
.reqstd_address
);
2643 if (automatic_hardware_breakpoints
)
2645 enum bp_loc_type new_type
;
2647 if (mr
->attrib
.mode
!= MEM_RW
)
2648 new_type
= bp_loc_hardware_breakpoint
;
2650 new_type
= bp_loc_software_breakpoint
;
2652 if (new_type
!= bl
->loc_type
)
2654 static int said
= 0;
2656 bl
->loc_type
= new_type
;
2659 fprintf_filtered (gdb_stdout
,
2660 _("Note: automatically using "
2661 "hardware breakpoints for "
2662 "read-only addresses.\n"));
2667 else if (bl
->loc_type
== bp_loc_software_breakpoint
2668 && mr
->attrib
.mode
!= MEM_RW
)
2670 fprintf_unfiltered (tmp_error_stream
,
2671 _("Cannot insert breakpoint %d.\n"
2672 "Cannot set software breakpoint "
2673 "at read-only address %s\n"),
2675 paddress (bl
->gdbarch
, bl
->address
));
2681 /* First check to see if we have to handle an overlay. */
2682 if (overlay_debugging
== ovly_off
2683 || bl
->section
== NULL
2684 || !(section_is_overlay (bl
->section
)))
2686 /* No overlay handling: just set the breakpoint. */
2687 TRY_CATCH (e
, RETURN_MASK_ALL
)
2691 val
= bl
->owner
->ops
->insert_location (bl
);
2693 bp_err
= GENERIC_ERROR
;
2698 bp_err_message
= e
.message
;
2703 /* This breakpoint is in an overlay section.
2704 Shall we set a breakpoint at the LMA? */
2705 if (!overlay_events_enabled
)
2707 /* Yes -- overlay event support is not active,
2708 so we must try to set a breakpoint at the LMA.
2709 This will not work for a hardware breakpoint. */
2710 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
2711 warning (_("hardware breakpoint %d not supported in overlay!"),
2715 CORE_ADDR addr
= overlay_unmapped_address (bl
->address
,
2717 /* Set a software (trap) breakpoint at the LMA. */
2718 bl
->overlay_target_info
= bl
->target_info
;
2719 bl
->overlay_target_info
.reqstd_address
= addr
;
2721 /* No overlay handling: just set the breakpoint. */
2722 TRY_CATCH (e
, RETURN_MASK_ALL
)
2726 val
= target_insert_breakpoint (bl
->gdbarch
,
2727 &bl
->overlay_target_info
);
2729 bp_err
= GENERIC_ERROR
;
2734 bp_err_message
= e
.message
;
2737 if (bp_err
!= GDB_NO_ERROR
)
2738 fprintf_unfiltered (tmp_error_stream
,
2739 "Overlay breakpoint %d "
2740 "failed: in ROM?\n",
2744 /* Shall we set a breakpoint at the VMA? */
2745 if (section_is_mapped (bl
->section
))
2747 /* Yes. This overlay section is mapped into memory. */
2748 TRY_CATCH (e
, RETURN_MASK_ALL
)
2752 val
= bl
->owner
->ops
->insert_location (bl
);
2754 bp_err
= GENERIC_ERROR
;
2759 bp_err_message
= e
.message
;
2764 /* No. This breakpoint will not be inserted.
2765 No error, but do not mark the bp as 'inserted'. */
2770 if (bp_err
!= GDB_NO_ERROR
)
2772 /* Can't set the breakpoint. */
2774 /* In some cases, we might not be able to insert a
2775 breakpoint in a shared library that has already been
2776 removed, but we have not yet processed the shlib unload
2777 event. Unfortunately, some targets that implement
2778 breakpoint insertion themselves can't tell why the
2779 breakpoint insertion failed (e.g., the remote target
2780 doesn't define error codes), so we must treat generic
2781 errors as memory errors. */
2782 if ((bp_err
== GENERIC_ERROR
|| bp_err
== MEMORY_ERROR
)
2783 && bl
->loc_type
== bp_loc_software_breakpoint
2784 && (solib_name_from_address (bl
->pspace
, bl
->address
)
2785 || shared_objfile_contains_address_p (bl
->pspace
,
2788 /* See also: disable_breakpoints_in_shlibs. */
2789 bl
->shlib_disabled
= 1;
2790 observer_notify_breakpoint_modified (bl
->owner
);
2791 if (!*disabled_breaks
)
2793 fprintf_unfiltered (tmp_error_stream
,
2794 "Cannot insert breakpoint %d.\n",
2796 fprintf_unfiltered (tmp_error_stream
,
2797 "Temporarily disabling shared "
2798 "library breakpoints:\n");
2800 *disabled_breaks
= 1;
2801 fprintf_unfiltered (tmp_error_stream
,
2802 "breakpoint #%d\n", bl
->owner
->number
);
2807 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
2809 *hw_breakpoint_error
= 1;
2810 *hw_bp_error_explained_already
= bp_err_message
!= NULL
;
2811 fprintf_unfiltered (tmp_error_stream
,
2812 "Cannot insert hardware breakpoint %d%s",
2813 bl
->owner
->number
, bp_err_message
? ":" : ".\n");
2814 if (bp_err_message
!= NULL
)
2815 fprintf_unfiltered (tmp_error_stream
, "%s.\n", bp_err_message
);
2819 if (bp_err_message
== NULL
)
2822 = memory_error_message (TARGET_XFER_E_IO
,
2823 bl
->gdbarch
, bl
->address
);
2824 struct cleanup
*old_chain
= make_cleanup (xfree
, message
);
2826 fprintf_unfiltered (tmp_error_stream
,
2827 "Cannot insert breakpoint %d.\n"
2829 bl
->owner
->number
, message
);
2830 do_cleanups (old_chain
);
2834 fprintf_unfiltered (tmp_error_stream
,
2835 "Cannot insert breakpoint %d: %s\n",
2850 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
2851 /* NOTE drow/2003-09-08: This state only exists for removing
2852 watchpoints. It's not clear that it's necessary... */
2853 && bl
->owner
->disposition
!= disp_del_at_next_stop
)
2857 gdb_assert (bl
->owner
->ops
!= NULL
2858 && bl
->owner
->ops
->insert_location
!= NULL
);
2860 val
= bl
->owner
->ops
->insert_location (bl
);
2862 /* If trying to set a read-watchpoint, and it turns out it's not
2863 supported, try emulating one with an access watchpoint. */
2864 if (val
== 1 && bl
->watchpoint_type
== hw_read
)
2866 struct bp_location
*loc
, **loc_temp
;
2868 /* But don't try to insert it, if there's already another
2869 hw_access location that would be considered a duplicate
2871 ALL_BP_LOCATIONS (loc
, loc_temp
)
2873 && loc
->watchpoint_type
== hw_access
2874 && watchpoint_locations_match (bl
, loc
))
2878 bl
->target_info
= loc
->target_info
;
2879 bl
->watchpoint_type
= hw_access
;
2886 bl
->watchpoint_type
= hw_access
;
2887 val
= bl
->owner
->ops
->insert_location (bl
);
2890 /* Back to the original value. */
2891 bl
->watchpoint_type
= hw_read
;
2895 bl
->inserted
= (val
== 0);
2898 else if (bl
->owner
->type
== bp_catchpoint
)
2902 gdb_assert (bl
->owner
->ops
!= NULL
2903 && bl
->owner
->ops
->insert_location
!= NULL
);
2905 val
= bl
->owner
->ops
->insert_location (bl
);
2908 bl
->owner
->enable_state
= bp_disabled
;
2912 Error inserting catchpoint %d: Your system does not support this type\n\
2913 of catchpoint."), bl
->owner
->number
);
2915 warning (_("Error inserting catchpoint %d."), bl
->owner
->number
);
2918 bl
->inserted
= (val
== 0);
2920 /* We've already printed an error message if there was a problem
2921 inserting this catchpoint, and we've disabled the catchpoint,
2922 so just return success. */
2929 /* This function is called when program space PSPACE is about to be
2930 deleted. It takes care of updating breakpoints to not reference
2934 breakpoint_program_space_exit (struct program_space
*pspace
)
2936 struct breakpoint
*b
, *b_temp
;
2937 struct bp_location
*loc
, **loc_temp
;
2939 /* Remove any breakpoint that was set through this program space. */
2940 ALL_BREAKPOINTS_SAFE (b
, b_temp
)
2942 if (b
->pspace
== pspace
)
2943 delete_breakpoint (b
);
2946 /* Breakpoints set through other program spaces could have locations
2947 bound to PSPACE as well. Remove those. */
2948 ALL_BP_LOCATIONS (loc
, loc_temp
)
2950 struct bp_location
*tmp
;
2952 if (loc
->pspace
== pspace
)
2954 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
2955 if (loc
->owner
->loc
== loc
)
2956 loc
->owner
->loc
= loc
->next
;
2958 for (tmp
= loc
->owner
->loc
; tmp
->next
!= NULL
; tmp
= tmp
->next
)
2959 if (tmp
->next
== loc
)
2961 tmp
->next
= loc
->next
;
2967 /* Now update the global location list to permanently delete the
2968 removed locations above. */
2969 update_global_location_list (UGLL_DONT_INSERT
);
2972 /* Make sure all breakpoints are inserted in inferior.
2973 Throws exception on any error.
2974 A breakpoint that is already inserted won't be inserted
2975 again, so calling this function twice is safe. */
2977 insert_breakpoints (void)
2979 struct breakpoint
*bpt
;
2981 ALL_BREAKPOINTS (bpt
)
2982 if (is_hardware_watchpoint (bpt
))
2984 struct watchpoint
*w
= (struct watchpoint
*) bpt
;
2986 update_watchpoint (w
, 0 /* don't reparse. */);
2989 /* Updating watchpoints creates new locations, so update the global
2990 location list. Explicitly tell ugll to insert locations and
2991 ignore breakpoints_always_inserted_mode. */
2992 update_global_location_list (UGLL_INSERT
);
2995 /* Invoke CALLBACK for each of bp_location. */
2998 iterate_over_bp_locations (walk_bp_location_callback callback
)
3000 struct bp_location
*loc
, **loc_tmp
;
3002 ALL_BP_LOCATIONS (loc
, loc_tmp
)
3004 callback (loc
, NULL
);
3008 /* This is used when we need to synch breakpoint conditions between GDB and the
3009 target. It is the case with deleting and disabling of breakpoints when using
3010 always-inserted mode. */
3013 update_inserted_breakpoint_locations (void)
3015 struct bp_location
*bl
, **blp_tmp
;
3018 int disabled_breaks
= 0;
3019 int hw_breakpoint_error
= 0;
3020 int hw_bp_details_reported
= 0;
3022 struct ui_file
*tmp_error_stream
= mem_fileopen ();
3023 struct cleanup
*cleanups
= make_cleanup_ui_file_delete (tmp_error_stream
);
3025 /* Explicitly mark the warning -- this will only be printed if
3026 there was an error. */
3027 fprintf_unfiltered (tmp_error_stream
, "Warning:\n");
3029 save_current_space_and_thread ();
3031 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3033 /* We only want to update software breakpoints and hardware
3035 if (!is_breakpoint (bl
->owner
))
3038 /* We only want to update locations that are already inserted
3039 and need updating. This is to avoid unwanted insertion during
3040 deletion of breakpoints. */
3041 if (!bl
->inserted
|| (bl
->inserted
&& !bl
->needs_update
))
3044 switch_to_program_space_and_thread (bl
->pspace
);
3046 /* For targets that support global breakpoints, there's no need
3047 to select an inferior to insert breakpoint to. In fact, even
3048 if we aren't attached to any process yet, we should still
3049 insert breakpoints. */
3050 if (!gdbarch_has_global_breakpoints (target_gdbarch ())
3051 && ptid_equal (inferior_ptid
, null_ptid
))
3054 val
= insert_bp_location (bl
, tmp_error_stream
, &disabled_breaks
,
3055 &hw_breakpoint_error
, &hw_bp_details_reported
);
3062 target_terminal_ours_for_output ();
3063 error_stream (tmp_error_stream
);
3066 do_cleanups (cleanups
);
3069 /* Used when starting or continuing the program. */
3072 insert_breakpoint_locations (void)
3074 struct breakpoint
*bpt
;
3075 struct bp_location
*bl
, **blp_tmp
;
3078 int disabled_breaks
= 0;
3079 int hw_breakpoint_error
= 0;
3080 int hw_bp_error_explained_already
= 0;
3082 struct ui_file
*tmp_error_stream
= mem_fileopen ();
3083 struct cleanup
*cleanups
= make_cleanup_ui_file_delete (tmp_error_stream
);
3085 /* Explicitly mark the warning -- this will only be printed if
3086 there was an error. */
3087 fprintf_unfiltered (tmp_error_stream
, "Warning:\n");
3089 save_current_space_and_thread ();
3091 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3093 if (!should_be_inserted (bl
) || (bl
->inserted
&& !bl
->needs_update
))
3096 /* There is no point inserting thread-specific breakpoints if
3097 the thread no longer exists. ALL_BP_LOCATIONS bp_location
3098 has BL->OWNER always non-NULL. */
3099 if (bl
->owner
->thread
!= -1
3100 && !valid_thread_id (bl
->owner
->thread
))
3103 switch_to_program_space_and_thread (bl
->pspace
);
3105 /* For targets that support global breakpoints, there's no need
3106 to select an inferior to insert breakpoint to. In fact, even
3107 if we aren't attached to any process yet, we should still
3108 insert breakpoints. */
3109 if (!gdbarch_has_global_breakpoints (target_gdbarch ())
3110 && ptid_equal (inferior_ptid
, null_ptid
))
3113 val
= insert_bp_location (bl
, tmp_error_stream
, &disabled_breaks
,
3114 &hw_breakpoint_error
, &hw_bp_error_explained_already
);
3119 /* If we failed to insert all locations of a watchpoint, remove
3120 them, as half-inserted watchpoint is of limited use. */
3121 ALL_BREAKPOINTS (bpt
)
3123 int some_failed
= 0;
3124 struct bp_location
*loc
;
3126 if (!is_hardware_watchpoint (bpt
))
3129 if (!breakpoint_enabled (bpt
))
3132 if (bpt
->disposition
== disp_del_at_next_stop
)
3135 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
3136 if (!loc
->inserted
&& should_be_inserted (loc
))
3143 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
3145 remove_breakpoint (loc
, mark_uninserted
);
3147 hw_breakpoint_error
= 1;
3148 fprintf_unfiltered (tmp_error_stream
,
3149 "Could not insert hardware watchpoint %d.\n",
3157 /* If a hardware breakpoint or watchpoint was inserted, add a
3158 message about possibly exhausted resources. */
3159 if (hw_breakpoint_error
&& !hw_bp_error_explained_already
)
3161 fprintf_unfiltered (tmp_error_stream
,
3162 "Could not insert hardware breakpoints:\n\
3163 You may have requested too many hardware breakpoints/watchpoints.\n");
3165 target_terminal_ours_for_output ();
3166 error_stream (tmp_error_stream
);
3169 do_cleanups (cleanups
);
3172 /* Used when the program stops.
3173 Returns zero if successful, or non-zero if there was a problem
3174 removing a breakpoint location. */
3177 remove_breakpoints (void)
3179 struct bp_location
*bl
, **blp_tmp
;
3182 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3184 if (bl
->inserted
&& !is_tracepoint (bl
->owner
))
3185 val
|= remove_breakpoint (bl
, mark_uninserted
);
3190 /* When a thread exits, remove breakpoints that are related to
3194 remove_threaded_breakpoints (struct thread_info
*tp
, int silent
)
3196 struct breakpoint
*b
, *b_tmp
;
3198 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
3200 if (b
->thread
== tp
->num
&& user_breakpoint_p (b
))
3202 b
->disposition
= disp_del_at_next_stop
;
3204 printf_filtered (_("\
3205 Thread-specific breakpoint %d deleted - thread %d no longer in the thread list.\n"),
3206 b
->number
, tp
->num
);
3208 /* Hide it from the user. */
3214 /* Remove breakpoints of process PID. */
3217 remove_breakpoints_pid (int pid
)
3219 struct bp_location
*bl
, **blp_tmp
;
3221 struct inferior
*inf
= find_inferior_pid (pid
);
3223 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3225 if (bl
->pspace
!= inf
->pspace
)
3228 if (bl
->owner
->type
== bp_dprintf
)
3233 val
= remove_breakpoint (bl
, mark_uninserted
);
3242 reattach_breakpoints (int pid
)
3244 struct cleanup
*old_chain
;
3245 struct bp_location
*bl
, **blp_tmp
;
3247 struct ui_file
*tmp_error_stream
;
3248 int dummy1
= 0, dummy2
= 0, dummy3
= 0;
3249 struct inferior
*inf
;
3250 struct thread_info
*tp
;
3252 tp
= any_live_thread_of_process (pid
);
3256 inf
= find_inferior_pid (pid
);
3257 old_chain
= save_inferior_ptid ();
3259 inferior_ptid
= tp
->ptid
;
3261 tmp_error_stream
= mem_fileopen ();
3262 make_cleanup_ui_file_delete (tmp_error_stream
);
3264 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3266 if (bl
->pspace
!= inf
->pspace
)
3272 val
= insert_bp_location (bl
, tmp_error_stream
, &dummy1
, &dummy2
, &dummy3
);
3275 do_cleanups (old_chain
);
3280 do_cleanups (old_chain
);
3284 static int internal_breakpoint_number
= -1;
3286 /* Set the breakpoint number of B, depending on the value of INTERNAL.
3287 If INTERNAL is non-zero, the breakpoint number will be populated
3288 from internal_breakpoint_number and that variable decremented.
3289 Otherwise the breakpoint number will be populated from
3290 breakpoint_count and that value incremented. Internal breakpoints
3291 do not set the internal var bpnum. */
3293 set_breakpoint_number (int internal
, struct breakpoint
*b
)
3296 b
->number
= internal_breakpoint_number
--;
3299 set_breakpoint_count (breakpoint_count
+ 1);
3300 b
->number
= breakpoint_count
;
3304 static struct breakpoint
*
3305 create_internal_breakpoint (struct gdbarch
*gdbarch
,
3306 CORE_ADDR address
, enum bptype type
,
3307 const struct breakpoint_ops
*ops
)
3309 struct symtab_and_line sal
;
3310 struct breakpoint
*b
;
3312 init_sal (&sal
); /* Initialize to zeroes. */
3315 sal
.section
= find_pc_overlay (sal
.pc
);
3316 sal
.pspace
= current_program_space
;
3318 b
= set_raw_breakpoint (gdbarch
, sal
, type
, ops
);
3319 b
->number
= internal_breakpoint_number
--;
3320 b
->disposition
= disp_donttouch
;
3325 static const char *const longjmp_names
[] =
3327 "longjmp", "_longjmp", "siglongjmp", "_siglongjmp"
3329 #define NUM_LONGJMP_NAMES ARRAY_SIZE(longjmp_names)
3331 /* Per-objfile data private to breakpoint.c. */
3332 struct breakpoint_objfile_data
3334 /* Minimal symbol for "_ovly_debug_event" (if any). */
3335 struct bound_minimal_symbol overlay_msym
;
3337 /* Minimal symbol(s) for "longjmp", "siglongjmp", etc. (if any). */
3338 struct bound_minimal_symbol longjmp_msym
[NUM_LONGJMP_NAMES
];
3340 /* True if we have looked for longjmp probes. */
3341 int longjmp_searched
;
3343 /* SystemTap probe points for longjmp (if any). */
3344 VEC (probe_p
) *longjmp_probes
;
3346 /* Minimal symbol for "std::terminate()" (if any). */
3347 struct bound_minimal_symbol terminate_msym
;
3349 /* Minimal symbol for "_Unwind_DebugHook" (if any). */
3350 struct bound_minimal_symbol exception_msym
;
3352 /* True if we have looked for exception probes. */
3353 int exception_searched
;
3355 /* SystemTap probe points for unwinding (if any). */
3356 VEC (probe_p
) *exception_probes
;
3359 static const struct objfile_data
*breakpoint_objfile_key
;
3361 /* Minimal symbol not found sentinel. */
3362 static struct minimal_symbol msym_not_found
;
3364 /* Returns TRUE if MSYM point to the "not found" sentinel. */
3367 msym_not_found_p (const struct minimal_symbol
*msym
)
3369 return msym
== &msym_not_found
;
3372 /* Return per-objfile data needed by breakpoint.c.
3373 Allocate the data if necessary. */
3375 static struct breakpoint_objfile_data
*
3376 get_breakpoint_objfile_data (struct objfile
*objfile
)
3378 struct breakpoint_objfile_data
*bp_objfile_data
;
3380 bp_objfile_data
= objfile_data (objfile
, breakpoint_objfile_key
);
3381 if (bp_objfile_data
== NULL
)
3383 bp_objfile_data
= obstack_alloc (&objfile
->objfile_obstack
,
3384 sizeof (*bp_objfile_data
));
3386 memset (bp_objfile_data
, 0, sizeof (*bp_objfile_data
));
3387 set_objfile_data (objfile
, breakpoint_objfile_key
, bp_objfile_data
);
3389 return bp_objfile_data
;
3393 free_breakpoint_probes (struct objfile
*obj
, void *data
)
3395 struct breakpoint_objfile_data
*bp_objfile_data
= data
;
3397 VEC_free (probe_p
, bp_objfile_data
->longjmp_probes
);
3398 VEC_free (probe_p
, bp_objfile_data
->exception_probes
);
3402 create_overlay_event_breakpoint (void)
3404 struct objfile
*objfile
;
3405 const char *const func_name
= "_ovly_debug_event";
3407 ALL_OBJFILES (objfile
)
3409 struct breakpoint
*b
;
3410 struct breakpoint_objfile_data
*bp_objfile_data
;
3413 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3415 if (msym_not_found_p (bp_objfile_data
->overlay_msym
.minsym
))
3418 if (bp_objfile_data
->overlay_msym
.minsym
== NULL
)
3420 struct bound_minimal_symbol m
;
3422 m
= lookup_minimal_symbol_text (func_name
, objfile
);
3423 if (m
.minsym
== NULL
)
3425 /* Avoid future lookups in this objfile. */
3426 bp_objfile_data
->overlay_msym
.minsym
= &msym_not_found
;
3429 bp_objfile_data
->overlay_msym
= m
;
3432 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->overlay_msym
);
3433 b
= create_internal_breakpoint (get_objfile_arch (objfile
), addr
,
3435 &internal_breakpoint_ops
);
3436 b
->addr_string
= xstrdup (func_name
);
3438 if (overlay_debugging
== ovly_auto
)
3440 b
->enable_state
= bp_enabled
;
3441 overlay_events_enabled
= 1;
3445 b
->enable_state
= bp_disabled
;
3446 overlay_events_enabled
= 0;
3449 update_global_location_list (UGLL_MAY_INSERT
);
3453 create_longjmp_master_breakpoint (void)
3455 struct program_space
*pspace
;
3456 struct cleanup
*old_chain
;
3458 old_chain
= save_current_program_space ();
3460 ALL_PSPACES (pspace
)
3462 struct objfile
*objfile
;
3464 set_current_program_space (pspace
);
3466 ALL_OBJFILES (objfile
)
3469 struct gdbarch
*gdbarch
;
3470 struct breakpoint_objfile_data
*bp_objfile_data
;
3472 gdbarch
= get_objfile_arch (objfile
);
3474 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3476 if (!bp_objfile_data
->longjmp_searched
)
3480 ret
= find_probes_in_objfile (objfile
, "libc", "longjmp");
3483 /* We are only interested in checking one element. */
3484 struct probe
*p
= VEC_index (probe_p
, ret
, 0);
3486 if (!can_evaluate_probe_arguments (p
))
3488 /* We cannot use the probe interface here, because it does
3489 not know how to evaluate arguments. */
3490 VEC_free (probe_p
, ret
);
3494 bp_objfile_data
->longjmp_probes
= ret
;
3495 bp_objfile_data
->longjmp_searched
= 1;
3498 if (bp_objfile_data
->longjmp_probes
!= NULL
)
3501 struct probe
*probe
;
3502 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3505 VEC_iterate (probe_p
,
3506 bp_objfile_data
->longjmp_probes
,
3510 struct breakpoint
*b
;
3512 b
= create_internal_breakpoint (gdbarch
,
3513 get_probe_address (probe
,
3516 &internal_breakpoint_ops
);
3517 b
->addr_string
= xstrdup ("-probe-stap libc:longjmp");
3518 b
->enable_state
= bp_disabled
;
3524 if (!gdbarch_get_longjmp_target_p (gdbarch
))
3527 for (i
= 0; i
< NUM_LONGJMP_NAMES
; i
++)
3529 struct breakpoint
*b
;
3530 const char *func_name
;
3533 if (msym_not_found_p (bp_objfile_data
->longjmp_msym
[i
].minsym
))
3536 func_name
= longjmp_names
[i
];
3537 if (bp_objfile_data
->longjmp_msym
[i
].minsym
== NULL
)
3539 struct bound_minimal_symbol m
;
3541 m
= lookup_minimal_symbol_text (func_name
, objfile
);
3542 if (m
.minsym
== NULL
)
3544 /* Prevent future lookups in this objfile. */
3545 bp_objfile_data
->longjmp_msym
[i
].minsym
= &msym_not_found
;
3548 bp_objfile_data
->longjmp_msym
[i
] = m
;
3551 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->longjmp_msym
[i
]);
3552 b
= create_internal_breakpoint (gdbarch
, addr
, bp_longjmp_master
,
3553 &internal_breakpoint_ops
);
3554 b
->addr_string
= xstrdup (func_name
);
3555 b
->enable_state
= bp_disabled
;
3559 update_global_location_list (UGLL_MAY_INSERT
);
3561 do_cleanups (old_chain
);
3564 /* Create a master std::terminate breakpoint. */
3566 create_std_terminate_master_breakpoint (void)
3568 struct program_space
*pspace
;
3569 struct cleanup
*old_chain
;
3570 const char *const func_name
= "std::terminate()";
3572 old_chain
= save_current_program_space ();
3574 ALL_PSPACES (pspace
)
3576 struct objfile
*objfile
;
3579 set_current_program_space (pspace
);
3581 ALL_OBJFILES (objfile
)
3583 struct breakpoint
*b
;
3584 struct breakpoint_objfile_data
*bp_objfile_data
;
3586 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3588 if (msym_not_found_p (bp_objfile_data
->terminate_msym
.minsym
))
3591 if (bp_objfile_data
->terminate_msym
.minsym
== NULL
)
3593 struct bound_minimal_symbol m
;
3595 m
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
3596 if (m
.minsym
== NULL
|| (MSYMBOL_TYPE (m
.minsym
) != mst_text
3597 && MSYMBOL_TYPE (m
.minsym
) != mst_file_text
))
3599 /* Prevent future lookups in this objfile. */
3600 bp_objfile_data
->terminate_msym
.minsym
= &msym_not_found
;
3603 bp_objfile_data
->terminate_msym
= m
;
3606 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->terminate_msym
);
3607 b
= create_internal_breakpoint (get_objfile_arch (objfile
), addr
,
3608 bp_std_terminate_master
,
3609 &internal_breakpoint_ops
);
3610 b
->addr_string
= xstrdup (func_name
);
3611 b
->enable_state
= bp_disabled
;
3615 update_global_location_list (UGLL_MAY_INSERT
);
3617 do_cleanups (old_chain
);
3620 /* Install a master breakpoint on the unwinder's debug hook. */
3623 create_exception_master_breakpoint (void)
3625 struct objfile
*objfile
;
3626 const char *const func_name
= "_Unwind_DebugHook";
3628 ALL_OBJFILES (objfile
)
3630 struct breakpoint
*b
;
3631 struct gdbarch
*gdbarch
;
3632 struct breakpoint_objfile_data
*bp_objfile_data
;
3635 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3637 /* We prefer the SystemTap probe point if it exists. */
3638 if (!bp_objfile_data
->exception_searched
)
3642 ret
= find_probes_in_objfile (objfile
, "libgcc", "unwind");
3646 /* We are only interested in checking one element. */
3647 struct probe
*p
= VEC_index (probe_p
, ret
, 0);
3649 if (!can_evaluate_probe_arguments (p
))
3651 /* We cannot use the probe interface here, because it does
3652 not know how to evaluate arguments. */
3653 VEC_free (probe_p
, ret
);
3657 bp_objfile_data
->exception_probes
= ret
;
3658 bp_objfile_data
->exception_searched
= 1;
3661 if (bp_objfile_data
->exception_probes
!= NULL
)
3663 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3665 struct probe
*probe
;
3668 VEC_iterate (probe_p
,
3669 bp_objfile_data
->exception_probes
,
3673 struct breakpoint
*b
;
3675 b
= create_internal_breakpoint (gdbarch
,
3676 get_probe_address (probe
,
3678 bp_exception_master
,
3679 &internal_breakpoint_ops
);
3680 b
->addr_string
= xstrdup ("-probe-stap libgcc:unwind");
3681 b
->enable_state
= bp_disabled
;
3687 /* Otherwise, try the hook function. */
3689 if (msym_not_found_p (bp_objfile_data
->exception_msym
.minsym
))
3692 gdbarch
= get_objfile_arch (objfile
);
3694 if (bp_objfile_data
->exception_msym
.minsym
== NULL
)
3696 struct bound_minimal_symbol debug_hook
;
3698 debug_hook
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
3699 if (debug_hook
.minsym
== NULL
)
3701 bp_objfile_data
->exception_msym
.minsym
= &msym_not_found
;
3705 bp_objfile_data
->exception_msym
= debug_hook
;
3708 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->exception_msym
);
3709 addr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, addr
,
3711 b
= create_internal_breakpoint (gdbarch
, addr
, bp_exception_master
,
3712 &internal_breakpoint_ops
);
3713 b
->addr_string
= xstrdup (func_name
);
3714 b
->enable_state
= bp_disabled
;
3717 update_global_location_list (UGLL_MAY_INSERT
);
3721 update_breakpoints_after_exec (void)
3723 struct breakpoint
*b
, *b_tmp
;
3724 struct bp_location
*bploc
, **bplocp_tmp
;
3726 /* We're about to delete breakpoints from GDB's lists. If the
3727 INSERTED flag is true, GDB will try to lift the breakpoints by
3728 writing the breakpoints' "shadow contents" back into memory. The
3729 "shadow contents" are NOT valid after an exec, so GDB should not
3730 do that. Instead, the target is responsible from marking
3731 breakpoints out as soon as it detects an exec. We don't do that
3732 here instead, because there may be other attempts to delete
3733 breakpoints after detecting an exec and before reaching here. */
3734 ALL_BP_LOCATIONS (bploc
, bplocp_tmp
)
3735 if (bploc
->pspace
== current_program_space
)
3736 gdb_assert (!bploc
->inserted
);
3738 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
3740 if (b
->pspace
!= current_program_space
)
3743 /* Solib breakpoints must be explicitly reset after an exec(). */
3744 if (b
->type
== bp_shlib_event
)
3746 delete_breakpoint (b
);
3750 /* JIT breakpoints must be explicitly reset after an exec(). */
3751 if (b
->type
== bp_jit_event
)
3753 delete_breakpoint (b
);
3757 /* Thread event breakpoints must be set anew after an exec(),
3758 as must overlay event and longjmp master breakpoints. */
3759 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
3760 || b
->type
== bp_longjmp_master
|| b
->type
== bp_std_terminate_master
3761 || b
->type
== bp_exception_master
)
3763 delete_breakpoint (b
);
3767 /* Step-resume breakpoints are meaningless after an exec(). */
3768 if (b
->type
== bp_step_resume
|| b
->type
== bp_hp_step_resume
)
3770 delete_breakpoint (b
);
3774 /* Just like single-step breakpoints. */
3775 if (b
->type
== bp_single_step
)
3777 delete_breakpoint (b
);
3781 /* Longjmp and longjmp-resume breakpoints are also meaningless
3783 if (b
->type
== bp_longjmp
|| b
->type
== bp_longjmp_resume
3784 || b
->type
== bp_longjmp_call_dummy
3785 || b
->type
== bp_exception
|| b
->type
== bp_exception_resume
)
3787 delete_breakpoint (b
);
3791 if (b
->type
== bp_catchpoint
)
3793 /* For now, none of the bp_catchpoint breakpoints need to
3794 do anything at this point. In the future, if some of
3795 the catchpoints need to something, we will need to add
3796 a new method, and call this method from here. */
3800 /* bp_finish is a special case. The only way we ought to be able
3801 to see one of these when an exec() has happened, is if the user
3802 caught a vfork, and then said "finish". Ordinarily a finish just
3803 carries them to the call-site of the current callee, by setting
3804 a temporary bp there and resuming. But in this case, the finish
3805 will carry them entirely through the vfork & exec.
3807 We don't want to allow a bp_finish to remain inserted now. But
3808 we can't safely delete it, 'cause finish_command has a handle to
3809 the bp on a bpstat, and will later want to delete it. There's a
3810 chance (and I've seen it happen) that if we delete the bp_finish
3811 here, that its storage will get reused by the time finish_command
3812 gets 'round to deleting the "use to be a bp_finish" breakpoint.
3813 We really must allow finish_command to delete a bp_finish.
3815 In the absence of a general solution for the "how do we know
3816 it's safe to delete something others may have handles to?"
3817 problem, what we'll do here is just uninsert the bp_finish, and
3818 let finish_command delete it.
3820 (We know the bp_finish is "doomed" in the sense that it's
3821 momentary, and will be deleted as soon as finish_command sees
3822 the inferior stopped. So it doesn't matter that the bp's
3823 address is probably bogus in the new a.out, unlike e.g., the
3824 solib breakpoints.) */
3826 if (b
->type
== bp_finish
)
3831 /* Without a symbolic address, we have little hope of the
3832 pre-exec() address meaning the same thing in the post-exec()
3834 if (b
->addr_string
== NULL
)
3836 delete_breakpoint (b
);
3843 detach_breakpoints (ptid_t ptid
)
3845 struct bp_location
*bl
, **blp_tmp
;
3847 struct cleanup
*old_chain
= save_inferior_ptid ();
3848 struct inferior
*inf
= current_inferior ();
3850 if (ptid_get_pid (ptid
) == ptid_get_pid (inferior_ptid
))
3851 error (_("Cannot detach breakpoints of inferior_ptid"));
3853 /* Set inferior_ptid; remove_breakpoint_1 uses this global. */
3854 inferior_ptid
= ptid
;
3855 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3857 if (bl
->pspace
!= inf
->pspace
)
3860 /* This function must physically remove breakpoints locations
3861 from the specified ptid, without modifying the breakpoint
3862 package's state. Locations of type bp_loc_other are only
3863 maintained at GDB side. So, there is no need to remove
3864 these bp_loc_other locations. Moreover, removing these
3865 would modify the breakpoint package's state. */
3866 if (bl
->loc_type
== bp_loc_other
)
3870 val
|= remove_breakpoint_1 (bl
, mark_inserted
);
3873 do_cleanups (old_chain
);
3877 /* Remove the breakpoint location BL from the current address space.
3878 Note that this is used to detach breakpoints from a child fork.
3879 When we get here, the child isn't in the inferior list, and neither
3880 do we have objects to represent its address space --- we should
3881 *not* look at bl->pspace->aspace here. */
3884 remove_breakpoint_1 (struct bp_location
*bl
, insertion_state_t is
)
3888 /* BL is never in moribund_locations by our callers. */
3889 gdb_assert (bl
->owner
!= NULL
);
3891 if (bl
->owner
->enable_state
== bp_permanent
)
3892 /* Permanent breakpoints cannot be inserted or removed. */
3895 /* The type of none suggests that owner is actually deleted.
3896 This should not ever happen. */
3897 gdb_assert (bl
->owner
->type
!= bp_none
);
3899 if (bl
->loc_type
== bp_loc_software_breakpoint
3900 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
3902 /* "Normal" instruction breakpoint: either the standard
3903 trap-instruction bp (bp_breakpoint), or a
3904 bp_hardware_breakpoint. */
3906 /* First check to see if we have to handle an overlay. */
3907 if (overlay_debugging
== ovly_off
3908 || bl
->section
== NULL
3909 || !(section_is_overlay (bl
->section
)))
3911 /* No overlay handling: just remove the breakpoint. */
3913 /* If we're trying to uninsert a memory breakpoint that we
3914 know is set in a dynamic object that is marked
3915 shlib_disabled, then either the dynamic object was
3916 removed with "remove-symbol-file" or with
3917 "nosharedlibrary". In the former case, we don't know
3918 whether another dynamic object might have loaded over the
3919 breakpoint's address -- the user might well let us know
3920 about it next with add-symbol-file (the whole point of
3921 add-symbol-file is letting the user manually maintain a
3922 list of dynamically loaded objects). If we have the
3923 breakpoint's shadow memory, that is, this is a software
3924 breakpoint managed by GDB, check whether the breakpoint
3925 is still inserted in memory, to avoid overwriting wrong
3926 code with stale saved shadow contents. Note that HW
3927 breakpoints don't have shadow memory, as they're
3928 implemented using a mechanism that is not dependent on
3929 being able to modify the target's memory, and as such
3930 they should always be removed. */
3931 if (bl
->shlib_disabled
3932 && bl
->target_info
.shadow_len
!= 0
3933 && !memory_validate_breakpoint (bl
->gdbarch
, &bl
->target_info
))
3936 val
= bl
->owner
->ops
->remove_location (bl
);
3940 /* This breakpoint is in an overlay section.
3941 Did we set a breakpoint at the LMA? */
3942 if (!overlay_events_enabled
)
3944 /* Yes -- overlay event support is not active, so we
3945 should have set a breakpoint at the LMA. Remove it.
3947 /* Ignore any failures: if the LMA is in ROM, we will
3948 have already warned when we failed to insert it. */
3949 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
3950 target_remove_hw_breakpoint (bl
->gdbarch
,
3951 &bl
->overlay_target_info
);
3953 target_remove_breakpoint (bl
->gdbarch
,
3954 &bl
->overlay_target_info
);
3956 /* Did we set a breakpoint at the VMA?
3957 If so, we will have marked the breakpoint 'inserted'. */
3960 /* Yes -- remove it. Previously we did not bother to
3961 remove the breakpoint if the section had been
3962 unmapped, but let's not rely on that being safe. We
3963 don't know what the overlay manager might do. */
3965 /* However, we should remove *software* breakpoints only
3966 if the section is still mapped, or else we overwrite
3967 wrong code with the saved shadow contents. */
3968 if (bl
->loc_type
== bp_loc_hardware_breakpoint
3969 || section_is_mapped (bl
->section
))
3970 val
= bl
->owner
->ops
->remove_location (bl
);
3976 /* No -- not inserted, so no need to remove. No error. */
3981 /* In some cases, we might not be able to remove a breakpoint in
3982 a shared library that has already been removed, but we have
3983 not yet processed the shlib unload event. Similarly for an
3984 unloaded add-symbol-file object - the user might not yet have
3985 had the chance to remove-symbol-file it. shlib_disabled will
3986 be set if the library/object has already been removed, but
3987 the breakpoint hasn't been uninserted yet, e.g., after
3988 "nosharedlibrary" or "remove-symbol-file" with breakpoints
3989 always-inserted mode. */
3991 && (bl
->loc_type
== bp_loc_software_breakpoint
3992 && (bl
->shlib_disabled
3993 || solib_name_from_address (bl
->pspace
, bl
->address
)
3994 || shared_objfile_contains_address_p (bl
->pspace
,
4000 bl
->inserted
= (is
== mark_inserted
);
4002 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
)
4004 gdb_assert (bl
->owner
->ops
!= NULL
4005 && bl
->owner
->ops
->remove_location
!= NULL
);
4007 bl
->inserted
= (is
== mark_inserted
);
4008 bl
->owner
->ops
->remove_location (bl
);
4010 /* Failure to remove any of the hardware watchpoints comes here. */
4011 if ((is
== mark_uninserted
) && (bl
->inserted
))
4012 warning (_("Could not remove hardware watchpoint %d."),
4015 else if (bl
->owner
->type
== bp_catchpoint
4016 && breakpoint_enabled (bl
->owner
)
4019 gdb_assert (bl
->owner
->ops
!= NULL
4020 && bl
->owner
->ops
->remove_location
!= NULL
);
4022 val
= bl
->owner
->ops
->remove_location (bl
);
4026 bl
->inserted
= (is
== mark_inserted
);
4033 remove_breakpoint (struct bp_location
*bl
, insertion_state_t is
)
4036 struct cleanup
*old_chain
;
4038 /* BL is never in moribund_locations by our callers. */
4039 gdb_assert (bl
->owner
!= NULL
);
4041 if (bl
->owner
->enable_state
== bp_permanent
)
4042 /* Permanent breakpoints cannot be inserted or removed. */
4045 /* The type of none suggests that owner is actually deleted.
4046 This should not ever happen. */
4047 gdb_assert (bl
->owner
->type
!= bp_none
);
4049 old_chain
= save_current_space_and_thread ();
4051 switch_to_program_space_and_thread (bl
->pspace
);
4053 ret
= remove_breakpoint_1 (bl
, is
);
4055 do_cleanups (old_chain
);
4059 /* Clear the "inserted" flag in all breakpoints. */
4062 mark_breakpoints_out (void)
4064 struct bp_location
*bl
, **blp_tmp
;
4066 ALL_BP_LOCATIONS (bl
, blp_tmp
)
4067 if (bl
->pspace
== current_program_space
)
4071 /* Clear the "inserted" flag in all breakpoints and delete any
4072 breakpoints which should go away between runs of the program.
4074 Plus other such housekeeping that has to be done for breakpoints
4077 Note: this function gets called at the end of a run (by
4078 generic_mourn_inferior) and when a run begins (by
4079 init_wait_for_inferior). */
4084 breakpoint_init_inferior (enum inf_context context
)
4086 struct breakpoint
*b
, *b_tmp
;
4087 struct bp_location
*bl
, **blp_tmp
;
4089 struct program_space
*pspace
= current_program_space
;
4091 /* If breakpoint locations are shared across processes, then there's
4093 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
4096 ALL_BP_LOCATIONS (bl
, blp_tmp
)
4098 /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
4099 if (bl
->pspace
== pspace
4100 && bl
->owner
->enable_state
!= bp_permanent
)
4104 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
4106 if (b
->loc
&& b
->loc
->pspace
!= pspace
)
4112 case bp_longjmp_call_dummy
:
4114 /* If the call dummy breakpoint is at the entry point it will
4115 cause problems when the inferior is rerun, so we better get
4118 case bp_watchpoint_scope
:
4120 /* Also get rid of scope breakpoints. */
4122 case bp_shlib_event
:
4124 /* Also remove solib event breakpoints. Their addresses may
4125 have changed since the last time we ran the program.
4126 Actually we may now be debugging against different target;
4127 and so the solib backend that installed this breakpoint may
4128 not be used in by the target. E.g.,
4130 (gdb) file prog-linux
4131 (gdb) run # native linux target
4134 (gdb) file prog-win.exe
4135 (gdb) tar rem :9999 # remote Windows gdbserver.
4138 case bp_step_resume
:
4140 /* Also remove step-resume breakpoints. */
4142 case bp_single_step
:
4144 /* Also remove single-step breakpoints. */
4146 delete_breakpoint (b
);
4150 case bp_hardware_watchpoint
:
4151 case bp_read_watchpoint
:
4152 case bp_access_watchpoint
:
4154 struct watchpoint
*w
= (struct watchpoint
*) b
;
4156 /* Likewise for watchpoints on local expressions. */
4157 if (w
->exp_valid_block
!= NULL
)
4158 delete_breakpoint (b
);
4159 else if (context
== inf_starting
)
4161 /* Reset val field to force reread of starting value in
4162 insert_breakpoints. */
4164 value_free (w
->val
);
4175 /* Get rid of the moribund locations. */
4176 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, bl
); ++ix
)
4177 decref_bp_location (&bl
);
4178 VEC_free (bp_location_p
, moribund_locations
);
4181 /* These functions concern about actual breakpoints inserted in the
4182 target --- to e.g. check if we need to do decr_pc adjustment or if
4183 we need to hop over the bkpt --- so we check for address space
4184 match, not program space. */
4186 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
4187 exists at PC. It returns ordinary_breakpoint_here if it's an
4188 ordinary breakpoint, or permanent_breakpoint_here if it's a
4189 permanent breakpoint.
4190 - When continuing from a location with an ordinary breakpoint, we
4191 actually single step once before calling insert_breakpoints.
4192 - When continuing from a location with a permanent breakpoint, we
4193 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
4194 the target, to advance the PC past the breakpoint. */
4196 enum breakpoint_here
4197 breakpoint_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
4199 struct bp_location
*bl
, **blp_tmp
;
4200 int any_breakpoint_here
= 0;
4202 ALL_BP_LOCATIONS (bl
, blp_tmp
)
4204 if (bl
->loc_type
!= bp_loc_software_breakpoint
4205 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4208 /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
4209 if ((breakpoint_enabled (bl
->owner
)
4210 || bl
->owner
->enable_state
== bp_permanent
)
4211 && breakpoint_location_address_match (bl
, aspace
, pc
))
4213 if (overlay_debugging
4214 && section_is_overlay (bl
->section
)
4215 && !section_is_mapped (bl
->section
))
4216 continue; /* unmapped overlay -- can't be a match */
4217 else if (bl
->owner
->enable_state
== bp_permanent
)
4218 return permanent_breakpoint_here
;
4220 any_breakpoint_here
= 1;
4224 return any_breakpoint_here
? ordinary_breakpoint_here
: 0;
4227 /* Return true if there's a moribund breakpoint at PC. */
4230 moribund_breakpoint_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
4232 struct bp_location
*loc
;
4235 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
4236 if (breakpoint_location_address_match (loc
, aspace
, pc
))
4242 /* Returns non-zero iff there's a breakpoint inserted at PC. */
4245 breakpoint_inserted_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
4247 struct bp_location
*bl
, **blp_tmp
;
4249 ALL_BP_LOCATIONS (bl
, blp_tmp
)
4251 if (bl
->loc_type
!= bp_loc_software_breakpoint
4252 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4256 && breakpoint_location_address_match (bl
, aspace
, pc
))
4258 if (overlay_debugging
4259 && section_is_overlay (bl
->section
)
4260 && !section_is_mapped (bl
->section
))
4261 continue; /* unmapped overlay -- can't be a match */
4269 /* This function returns non-zero iff there is a software breakpoint
4273 software_breakpoint_inserted_here_p (struct address_space
*aspace
,
4276 struct bp_location
*bl
, **blp_tmp
;
4278 ALL_BP_LOCATIONS (bl
, blp_tmp
)
4280 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
4284 && breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
4287 if (overlay_debugging
4288 && section_is_overlay (bl
->section
)
4289 && !section_is_mapped (bl
->section
))
4290 continue; /* unmapped overlay -- can't be a match */
4300 hardware_watchpoint_inserted_in_range (struct address_space
*aspace
,
4301 CORE_ADDR addr
, ULONGEST len
)
4303 struct breakpoint
*bpt
;
4305 ALL_BREAKPOINTS (bpt
)
4307 struct bp_location
*loc
;
4309 if (bpt
->type
!= bp_hardware_watchpoint
4310 && bpt
->type
!= bp_access_watchpoint
)
4313 if (!breakpoint_enabled (bpt
))
4316 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
4317 if (loc
->pspace
->aspace
== aspace
&& loc
->inserted
)
4321 /* Check for intersection. */
4322 l
= max (loc
->address
, addr
);
4323 h
= min (loc
->address
+ loc
->length
, addr
+ len
);
4331 /* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
4332 PC is valid for process/thread PTID. */
4335 breakpoint_thread_match (struct address_space
*aspace
, CORE_ADDR pc
,
4338 struct bp_location
*bl
, **blp_tmp
;
4339 /* The thread and task IDs associated to PTID, computed lazily. */
4343 ALL_BP_LOCATIONS (bl
, blp_tmp
)
4345 if (bl
->loc_type
!= bp_loc_software_breakpoint
4346 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4349 /* ALL_BP_LOCATIONS bp_location has bl->OWNER always non-NULL. */
4350 if (!breakpoint_enabled (bl
->owner
)
4351 && bl
->owner
->enable_state
!= bp_permanent
)
4354 if (!breakpoint_location_address_match (bl
, aspace
, pc
))
4357 if (bl
->owner
->thread
!= -1)
4359 /* This is a thread-specific breakpoint. Check that ptid
4360 matches that thread. If thread hasn't been computed yet,
4361 it is now time to do so. */
4363 thread
= pid_to_thread_id (ptid
);
4364 if (bl
->owner
->thread
!= thread
)
4368 if (bl
->owner
->task
!= 0)
4370 /* This is a task-specific breakpoint. Check that ptid
4371 matches that task. If task hasn't been computed yet,
4372 it is now time to do so. */
4374 task
= ada_get_task_number (ptid
);
4375 if (bl
->owner
->task
!= task
)
4379 if (overlay_debugging
4380 && section_is_overlay (bl
->section
)
4381 && !section_is_mapped (bl
->section
))
4382 continue; /* unmapped overlay -- can't be a match */
4391 /* bpstat stuff. External routines' interfaces are documented
4395 is_catchpoint (struct breakpoint
*ep
)
4397 return (ep
->type
== bp_catchpoint
);
4400 /* Frees any storage that is part of a bpstat. Does not walk the
4404 bpstat_free (bpstat bs
)
4406 if (bs
->old_val
!= NULL
)
4407 value_free (bs
->old_val
);
4408 decref_counted_command_line (&bs
->commands
);
4409 decref_bp_location (&bs
->bp_location_at
);
4413 /* Clear a bpstat so that it says we are not at any breakpoint.
4414 Also free any storage that is part of a bpstat. */
4417 bpstat_clear (bpstat
*bsp
)
4434 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
4435 is part of the bpstat is copied as well. */
4438 bpstat_copy (bpstat bs
)
4442 bpstat retval
= NULL
;
4447 for (; bs
!= NULL
; bs
= bs
->next
)
4449 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
4450 memcpy (tmp
, bs
, sizeof (*tmp
));
4451 incref_counted_command_line (tmp
->commands
);
4452 incref_bp_location (tmp
->bp_location_at
);
4453 if (bs
->old_val
!= NULL
)
4455 tmp
->old_val
= value_copy (bs
->old_val
);
4456 release_value (tmp
->old_val
);
4460 /* This is the first thing in the chain. */
4470 /* Find the bpstat associated with this breakpoint. */
4473 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
4478 for (; bsp
!= NULL
; bsp
= bsp
->next
)
4480 if (bsp
->breakpoint_at
== breakpoint
)
4486 /* See breakpoint.h. */
4489 bpstat_explains_signal (bpstat bsp
, enum gdb_signal sig
)
4491 for (; bsp
!= NULL
; bsp
= bsp
->next
)
4493 if (bsp
->breakpoint_at
== NULL
)
4495 /* A moribund location can never explain a signal other than
4497 if (sig
== GDB_SIGNAL_TRAP
)
4502 if (bsp
->breakpoint_at
->ops
->explains_signal (bsp
->breakpoint_at
,
4511 /* Put in *NUM the breakpoint number of the first breakpoint we are
4512 stopped at. *BSP upon return is a bpstat which points to the
4513 remaining breakpoints stopped at (but which is not guaranteed to be
4514 good for anything but further calls to bpstat_num).
4516 Return 0 if passed a bpstat which does not indicate any breakpoints.
4517 Return -1 if stopped at a breakpoint that has been deleted since
4519 Return 1 otherwise. */
4522 bpstat_num (bpstat
*bsp
, int *num
)
4524 struct breakpoint
*b
;
4527 return 0; /* No more breakpoint values */
4529 /* We assume we'll never have several bpstats that correspond to a
4530 single breakpoint -- otherwise, this function might return the
4531 same number more than once and this will look ugly. */
4532 b
= (*bsp
)->breakpoint_at
;
4533 *bsp
= (*bsp
)->next
;
4535 return -1; /* breakpoint that's been deleted since */
4537 *num
= b
->number
; /* We have its number */
4541 /* See breakpoint.h. */
4544 bpstat_clear_actions (void)
4546 struct thread_info
*tp
;
4549 if (ptid_equal (inferior_ptid
, null_ptid
))
4552 tp
= find_thread_ptid (inferior_ptid
);
4556 for (bs
= tp
->control
.stop_bpstat
; bs
!= NULL
; bs
= bs
->next
)
4558 decref_counted_command_line (&bs
->commands
);
4560 if (bs
->old_val
!= NULL
)
4562 value_free (bs
->old_val
);
4568 /* Called when a command is about to proceed the inferior. */
4571 breakpoint_about_to_proceed (void)
4573 if (!ptid_equal (inferior_ptid
, null_ptid
))
4575 struct thread_info
*tp
= inferior_thread ();
4577 /* Allow inferior function calls in breakpoint commands to not
4578 interrupt the command list. When the call finishes
4579 successfully, the inferior will be standing at the same
4580 breakpoint as if nothing happened. */
4581 if (tp
->control
.in_infcall
)
4585 breakpoint_proceeded
= 1;
4588 /* Stub for cleaning up our state if we error-out of a breakpoint
4591 cleanup_executing_breakpoints (void *ignore
)
4593 executing_breakpoint_commands
= 0;
4596 /* Return non-zero iff CMD as the first line of a command sequence is `silent'
4597 or its equivalent. */
4600 command_line_is_silent (struct command_line
*cmd
)
4602 return cmd
&& (strcmp ("silent", cmd
->line
) == 0
4603 || (xdb_commands
&& strcmp ("Q", cmd
->line
) == 0));
4606 /* Execute all the commands associated with all the breakpoints at
4607 this location. Any of these commands could cause the process to
4608 proceed beyond this point, etc. We look out for such changes by
4609 checking the global "breakpoint_proceeded" after each command.
4611 Returns true if a breakpoint command resumed the inferior. In that
4612 case, it is the caller's responsibility to recall it again with the
4613 bpstat of the current thread. */
4616 bpstat_do_actions_1 (bpstat
*bsp
)
4619 struct cleanup
*old_chain
;
4622 /* Avoid endless recursion if a `source' command is contained
4624 if (executing_breakpoint_commands
)
4627 executing_breakpoint_commands
= 1;
4628 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
4630 prevent_dont_repeat ();
4632 /* This pointer will iterate over the list of bpstat's. */
4635 breakpoint_proceeded
= 0;
4636 for (; bs
!= NULL
; bs
= bs
->next
)
4638 struct counted_command_line
*ccmd
;
4639 struct command_line
*cmd
;
4640 struct cleanup
*this_cmd_tree_chain
;
4642 /* Take ownership of the BSP's command tree, if it has one.
4644 The command tree could legitimately contain commands like
4645 'step' and 'next', which call clear_proceed_status, which
4646 frees stop_bpstat's command tree. To make sure this doesn't
4647 free the tree we're executing out from under us, we need to
4648 take ownership of the tree ourselves. Since a given bpstat's
4649 commands are only executed once, we don't need to copy it; we
4650 can clear the pointer in the bpstat, and make sure we free
4651 the tree when we're done. */
4652 ccmd
= bs
->commands
;
4653 bs
->commands
= NULL
;
4654 this_cmd_tree_chain
= make_cleanup_decref_counted_command_line (&ccmd
);
4655 cmd
= ccmd
? ccmd
->commands
: NULL
;
4656 if (command_line_is_silent (cmd
))
4658 /* The action has been already done by bpstat_stop_status. */
4664 execute_control_command (cmd
);
4666 if (breakpoint_proceeded
)
4672 /* We can free this command tree now. */
4673 do_cleanups (this_cmd_tree_chain
);
4675 if (breakpoint_proceeded
)
4677 if (target_can_async_p ())
4678 /* If we are in async mode, then the target might be still
4679 running, not stopped at any breakpoint, so nothing for
4680 us to do here -- just return to the event loop. */
4683 /* In sync mode, when execute_control_command returns
4684 we're already standing on the next breakpoint.
4685 Breakpoint commands for that stop were not run, since
4686 execute_command does not run breakpoint commands --
4687 only command_line_handler does, but that one is not
4688 involved in execution of breakpoint commands. So, we
4689 can now execute breakpoint commands. It should be
4690 noted that making execute_command do bpstat actions is
4691 not an option -- in this case we'll have recursive
4692 invocation of bpstat for each breakpoint with a
4693 command, and can easily blow up GDB stack. Instead, we
4694 return true, which will trigger the caller to recall us
4695 with the new stop_bpstat. */
4700 do_cleanups (old_chain
);
4705 bpstat_do_actions (void)
4707 struct cleanup
*cleanup_if_error
= make_bpstat_clear_actions_cleanup ();
4709 /* Do any commands attached to breakpoint we are stopped at. */
4710 while (!ptid_equal (inferior_ptid
, null_ptid
)
4711 && target_has_execution
4712 && !is_exited (inferior_ptid
)
4713 && !is_executing (inferior_ptid
))
4714 /* Since in sync mode, bpstat_do_actions may resume the inferior,
4715 and only return when it is stopped at the next breakpoint, we
4716 keep doing breakpoint actions until it returns false to
4717 indicate the inferior was not resumed. */
4718 if (!bpstat_do_actions_1 (&inferior_thread ()->control
.stop_bpstat
))
4721 discard_cleanups (cleanup_if_error
);
4724 /* Print out the (old or new) value associated with a watchpoint. */
4727 watchpoint_value_print (struct value
*val
, struct ui_file
*stream
)
4730 fprintf_unfiltered (stream
, _("<unreadable>"));
4733 struct value_print_options opts
;
4734 get_user_print_options (&opts
);
4735 value_print (val
, stream
, &opts
);
4739 /* Generic routine for printing messages indicating why we
4740 stopped. The behavior of this function depends on the value
4741 'print_it' in the bpstat structure. Under some circumstances we
4742 may decide not to print anything here and delegate the task to
4745 static enum print_stop_action
4746 print_bp_stop_message (bpstat bs
)
4748 switch (bs
->print_it
)
4751 /* Nothing should be printed for this bpstat entry. */
4752 return PRINT_UNKNOWN
;
4756 /* We still want to print the frame, but we already printed the
4757 relevant messages. */
4758 return PRINT_SRC_AND_LOC
;
4761 case print_it_normal
:
4763 struct breakpoint
*b
= bs
->breakpoint_at
;
4765 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
4766 which has since been deleted. */
4768 return PRINT_UNKNOWN
;
4770 /* Normal case. Call the breakpoint's print_it method. */
4771 return b
->ops
->print_it (bs
);
4776 internal_error (__FILE__
, __LINE__
,
4777 _("print_bp_stop_message: unrecognized enum value"));
4782 /* A helper function that prints a shared library stopped event. */
4785 print_solib_event (int is_catchpoint
)
4788 = !VEC_empty (char_ptr
, current_program_space
->deleted_solibs
);
4790 = !VEC_empty (so_list_ptr
, current_program_space
->added_solibs
);
4794 if (any_added
|| any_deleted
)
4795 ui_out_text (current_uiout
,
4796 _("Stopped due to shared library event:\n"));
4798 ui_out_text (current_uiout
,
4799 _("Stopped due to shared library event (no "
4800 "libraries added or removed)\n"));
4803 if (ui_out_is_mi_like_p (current_uiout
))
4804 ui_out_field_string (current_uiout
, "reason",
4805 async_reason_lookup (EXEC_ASYNC_SOLIB_EVENT
));
4809 struct cleanup
*cleanup
;
4813 ui_out_text (current_uiout
, _(" Inferior unloaded "));
4814 cleanup
= make_cleanup_ui_out_list_begin_end (current_uiout
,
4817 VEC_iterate (char_ptr
, current_program_space
->deleted_solibs
,
4822 ui_out_text (current_uiout
, " ");
4823 ui_out_field_string (current_uiout
, "library", name
);
4824 ui_out_text (current_uiout
, "\n");
4827 do_cleanups (cleanup
);
4832 struct so_list
*iter
;
4834 struct cleanup
*cleanup
;
4836 ui_out_text (current_uiout
, _(" Inferior loaded "));
4837 cleanup
= make_cleanup_ui_out_list_begin_end (current_uiout
,
4840 VEC_iterate (so_list_ptr
, current_program_space
->added_solibs
,
4845 ui_out_text (current_uiout
, " ");
4846 ui_out_field_string (current_uiout
, "library", iter
->so_name
);
4847 ui_out_text (current_uiout
, "\n");
4850 do_cleanups (cleanup
);
4854 /* Print a message indicating what happened. This is called from
4855 normal_stop(). The input to this routine is the head of the bpstat
4856 list - a list of the eventpoints that caused this stop. KIND is
4857 the target_waitkind for the stopping event. This
4858 routine calls the generic print routine for printing a message
4859 about reasons for stopping. This will print (for example) the
4860 "Breakpoint n," part of the output. The return value of this
4863 PRINT_UNKNOWN: Means we printed nothing.
4864 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
4865 code to print the location. An example is
4866 "Breakpoint 1, " which should be followed by
4868 PRINT_SRC_ONLY: Means we printed something, but there is no need
4869 to also print the location part of the message.
4870 An example is the catch/throw messages, which
4871 don't require a location appended to the end.
4872 PRINT_NOTHING: We have done some printing and we don't need any
4873 further info to be printed. */
4875 enum print_stop_action
4876 bpstat_print (bpstat bs
, int kind
)
4880 /* Maybe another breakpoint in the chain caused us to stop.
4881 (Currently all watchpoints go on the bpstat whether hit or not.
4882 That probably could (should) be changed, provided care is taken
4883 with respect to bpstat_explains_signal). */
4884 for (; bs
; bs
= bs
->next
)
4886 val
= print_bp_stop_message (bs
);
4887 if (val
== PRINT_SRC_ONLY
4888 || val
== PRINT_SRC_AND_LOC
4889 || val
== PRINT_NOTHING
)
4893 /* If we had hit a shared library event breakpoint,
4894 print_bp_stop_message would print out this message. If we hit an
4895 OS-level shared library event, do the same thing. */
4896 if (kind
== TARGET_WAITKIND_LOADED
)
4898 print_solib_event (0);
4899 return PRINT_NOTHING
;
4902 /* We reached the end of the chain, or we got a null BS to start
4903 with and nothing was printed. */
4904 return PRINT_UNKNOWN
;
4907 /* Evaluate the expression EXP and return 1 if value is zero.
4908 This returns the inverse of the condition because it is called
4909 from catch_errors which returns 0 if an exception happened, and if an
4910 exception happens we want execution to stop.
4911 The argument is a "struct expression *" that has been cast to a
4912 "void *" to make it pass through catch_errors. */
4915 breakpoint_cond_eval (void *exp
)
4917 struct value
*mark
= value_mark ();
4918 int i
= !value_true (evaluate_expression ((struct expression
*) exp
));
4920 value_free_to_mark (mark
);
4924 /* Allocate a new bpstat. Link it to the FIFO list by BS_LINK_POINTER. */
4927 bpstat_alloc (struct bp_location
*bl
, bpstat
**bs_link_pointer
)
4931 bs
= (bpstat
) xmalloc (sizeof (*bs
));
4933 **bs_link_pointer
= bs
;
4934 *bs_link_pointer
= &bs
->next
;
4935 bs
->breakpoint_at
= bl
->owner
;
4936 bs
->bp_location_at
= bl
;
4937 incref_bp_location (bl
);
4938 /* If the condition is false, etc., don't do the commands. */
4939 bs
->commands
= NULL
;
4941 bs
->print_it
= print_it_normal
;
4945 /* The target has stopped with waitstatus WS. Check if any hardware
4946 watchpoints have triggered, according to the target. */
4949 watchpoints_triggered (struct target_waitstatus
*ws
)
4951 int stopped_by_watchpoint
= target_stopped_by_watchpoint ();
4953 struct breakpoint
*b
;
4955 if (!stopped_by_watchpoint
)
4957 /* We were not stopped by a watchpoint. Mark all watchpoints
4958 as not triggered. */
4960 if (is_hardware_watchpoint (b
))
4962 struct watchpoint
*w
= (struct watchpoint
*) b
;
4964 w
->watchpoint_triggered
= watch_triggered_no
;
4970 if (!target_stopped_data_address (¤t_target
, &addr
))
4972 /* We were stopped by a watchpoint, but we don't know where.
4973 Mark all watchpoints as unknown. */
4975 if (is_hardware_watchpoint (b
))
4977 struct watchpoint
*w
= (struct watchpoint
*) b
;
4979 w
->watchpoint_triggered
= watch_triggered_unknown
;
4985 /* The target could report the data address. Mark watchpoints
4986 affected by this data address as triggered, and all others as not
4990 if (is_hardware_watchpoint (b
))
4992 struct watchpoint
*w
= (struct watchpoint
*) b
;
4993 struct bp_location
*loc
;
4995 w
->watchpoint_triggered
= watch_triggered_no
;
4996 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
4998 if (is_masked_watchpoint (b
))
5000 CORE_ADDR newaddr
= addr
& w
->hw_wp_mask
;
5001 CORE_ADDR start
= loc
->address
& w
->hw_wp_mask
;
5003 if (newaddr
== start
)
5005 w
->watchpoint_triggered
= watch_triggered_yes
;
5009 /* Exact match not required. Within range is sufficient. */
5010 else if (target_watchpoint_addr_within_range (¤t_target
,
5014 w
->watchpoint_triggered
= watch_triggered_yes
;
5023 /* Possible return values for watchpoint_check (this can't be an enum
5024 because of check_errors). */
5025 /* The watchpoint has been deleted. */
5026 #define WP_DELETED 1
5027 /* The value has changed. */
5028 #define WP_VALUE_CHANGED 2
5029 /* The value has not changed. */
5030 #define WP_VALUE_NOT_CHANGED 3
5031 /* Ignore this watchpoint, no matter if the value changed or not. */
5034 #define BP_TEMPFLAG 1
5035 #define BP_HARDWAREFLAG 2
5037 /* Evaluate watchpoint condition expression and check if its value
5040 P should be a pointer to struct bpstat, but is defined as a void *
5041 in order for this function to be usable with catch_errors. */
5044 watchpoint_check (void *p
)
5046 bpstat bs
= (bpstat
) p
;
5047 struct watchpoint
*b
;
5048 struct frame_info
*fr
;
5049 int within_current_scope
;
5051 /* BS is built from an existing struct breakpoint. */
5052 gdb_assert (bs
->breakpoint_at
!= NULL
);
5053 b
= (struct watchpoint
*) bs
->breakpoint_at
;
5055 /* If this is a local watchpoint, we only want to check if the
5056 watchpoint frame is in scope if the current thread is the thread
5057 that was used to create the watchpoint. */
5058 if (!watchpoint_in_thread_scope (b
))
5061 if (b
->exp_valid_block
== NULL
)
5062 within_current_scope
= 1;
5065 struct frame_info
*frame
= get_current_frame ();
5066 struct gdbarch
*frame_arch
= get_frame_arch (frame
);
5067 CORE_ADDR frame_pc
= get_frame_pc (frame
);
5069 /* in_function_epilogue_p() returns a non-zero value if we're
5070 still in the function but the stack frame has already been
5071 invalidated. Since we can't rely on the values of local
5072 variables after the stack has been destroyed, we are treating
5073 the watchpoint in that state as `not changed' without further
5074 checking. Don't mark watchpoints as changed if the current
5075 frame is in an epilogue - even if they are in some other
5076 frame, our view of the stack is likely to be wrong and
5077 frame_find_by_id could error out. */
5078 if (gdbarch_in_function_epilogue_p (frame_arch
, frame_pc
))
5081 fr
= frame_find_by_id (b
->watchpoint_frame
);
5082 within_current_scope
= (fr
!= NULL
);
5084 /* If we've gotten confused in the unwinder, we might have
5085 returned a frame that can't describe this variable. */
5086 if (within_current_scope
)
5088 struct symbol
*function
;
5090 function
= get_frame_function (fr
);
5091 if (function
== NULL
5092 || !contained_in (b
->exp_valid_block
,
5093 SYMBOL_BLOCK_VALUE (function
)))
5094 within_current_scope
= 0;
5097 if (within_current_scope
)
5098 /* If we end up stopping, the current frame will get selected
5099 in normal_stop. So this call to select_frame won't affect
5104 if (within_current_scope
)
5106 /* We use value_{,free_to_}mark because it could be a *long*
5107 time before we return to the command level and call
5108 free_all_values. We can't call free_all_values because we
5109 might be in the middle of evaluating a function call. */
5113 struct value
*new_val
;
5115 if (is_masked_watchpoint (&b
->base
))
5116 /* Since we don't know the exact trigger address (from
5117 stopped_data_address), just tell the user we've triggered
5118 a mask watchpoint. */
5119 return WP_VALUE_CHANGED
;
5121 mark
= value_mark ();
5122 fetch_subexp_value (b
->exp
, &pc
, &new_val
, NULL
, NULL
, 0);
5124 if (b
->val_bitsize
!= 0)
5125 new_val
= extract_bitfield_from_watchpoint_value (b
, new_val
);
5127 /* We use value_equal_contents instead of value_equal because
5128 the latter coerces an array to a pointer, thus comparing just
5129 the address of the array instead of its contents. This is
5130 not what we want. */
5131 if ((b
->val
!= NULL
) != (new_val
!= NULL
)
5132 || (b
->val
!= NULL
&& !value_equal_contents (b
->val
, new_val
)))
5134 if (new_val
!= NULL
)
5136 release_value (new_val
);
5137 value_free_to_mark (mark
);
5139 bs
->old_val
= b
->val
;
5142 return WP_VALUE_CHANGED
;
5146 /* Nothing changed. */
5147 value_free_to_mark (mark
);
5148 return WP_VALUE_NOT_CHANGED
;
5153 struct ui_out
*uiout
= current_uiout
;
5155 /* This seems like the only logical thing to do because
5156 if we temporarily ignored the watchpoint, then when
5157 we reenter the block in which it is valid it contains
5158 garbage (in the case of a function, it may have two
5159 garbage values, one before and one after the prologue).
5160 So we can't even detect the first assignment to it and
5161 watch after that (since the garbage may or may not equal
5162 the first value assigned). */
5163 /* We print all the stop information in
5164 breakpoint_ops->print_it, but in this case, by the time we
5165 call breakpoint_ops->print_it this bp will be deleted
5166 already. So we have no choice but print the information
5168 if (ui_out_is_mi_like_p (uiout
))
5170 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
5171 ui_out_text (uiout
, "\nWatchpoint ");
5172 ui_out_field_int (uiout
, "wpnum", b
->base
.number
);
5174 " deleted because the program has left the block in\n\
5175 which its expression is valid.\n");
5177 /* Make sure the watchpoint's commands aren't executed. */
5178 decref_counted_command_line (&b
->base
.commands
);
5179 watchpoint_del_at_next_stop (b
);
5185 /* Return true if it looks like target has stopped due to hitting
5186 breakpoint location BL. This function does not check if we should
5187 stop, only if BL explains the stop. */
5190 bpstat_check_location (const struct bp_location
*bl
,
5191 struct address_space
*aspace
, CORE_ADDR bp_addr
,
5192 const struct target_waitstatus
*ws
)
5194 struct breakpoint
*b
= bl
->owner
;
5196 /* BL is from an existing breakpoint. */
5197 gdb_assert (b
!= NULL
);
5199 return b
->ops
->breakpoint_hit (bl
, aspace
, bp_addr
, ws
);
5202 /* Determine if the watched values have actually changed, and we
5203 should stop. If not, set BS->stop to 0. */
5206 bpstat_check_watchpoint (bpstat bs
)
5208 const struct bp_location
*bl
;
5209 struct watchpoint
*b
;
5211 /* BS is built for existing struct breakpoint. */
5212 bl
= bs
->bp_location_at
;
5213 gdb_assert (bl
!= NULL
);
5214 b
= (struct watchpoint
*) bs
->breakpoint_at
;
5215 gdb_assert (b
!= NULL
);
5218 int must_check_value
= 0;
5220 if (b
->base
.type
== bp_watchpoint
)
5221 /* For a software watchpoint, we must always check the
5223 must_check_value
= 1;
5224 else if (b
->watchpoint_triggered
== watch_triggered_yes
)
5225 /* We have a hardware watchpoint (read, write, or access)
5226 and the target earlier reported an address watched by
5228 must_check_value
= 1;
5229 else if (b
->watchpoint_triggered
== watch_triggered_unknown
5230 && b
->base
.type
== bp_hardware_watchpoint
)
5231 /* We were stopped by a hardware watchpoint, but the target could
5232 not report the data address. We must check the watchpoint's
5233 value. Access and read watchpoints are out of luck; without
5234 a data address, we can't figure it out. */
5235 must_check_value
= 1;
5237 if (must_check_value
)
5240 = xstrprintf ("Error evaluating expression for watchpoint %d\n",
5242 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
5243 int e
= catch_errors (watchpoint_check
, bs
, message
,
5245 do_cleanups (cleanups
);
5249 /* We've already printed what needs to be printed. */
5250 bs
->print_it
= print_it_done
;
5254 bs
->print_it
= print_it_noop
;
5257 case WP_VALUE_CHANGED
:
5258 if (b
->base
.type
== bp_read_watchpoint
)
5260 /* There are two cases to consider here:
5262 1. We're watching the triggered memory for reads.
5263 In that case, trust the target, and always report
5264 the watchpoint hit to the user. Even though
5265 reads don't cause value changes, the value may
5266 have changed since the last time it was read, and
5267 since we're not trapping writes, we will not see
5268 those, and as such we should ignore our notion of
5271 2. We're watching the triggered memory for both
5272 reads and writes. There are two ways this may
5275 2.1. This is a target that can't break on data
5276 reads only, but can break on accesses (reads or
5277 writes), such as e.g., x86. We detect this case
5278 at the time we try to insert read watchpoints.
5280 2.2. Otherwise, the target supports read
5281 watchpoints, but, the user set an access or write
5282 watchpoint watching the same memory as this read
5285 If we're watching memory writes as well as reads,
5286 ignore watchpoint hits when we find that the
5287 value hasn't changed, as reads don't cause
5288 changes. This still gives false positives when
5289 the program writes the same value to memory as
5290 what there was already in memory (we will confuse
5291 it for a read), but it's much better than
5294 int other_write_watchpoint
= 0;
5296 if (bl
->watchpoint_type
== hw_read
)
5298 struct breakpoint
*other_b
;
5300 ALL_BREAKPOINTS (other_b
)
5301 if (other_b
->type
== bp_hardware_watchpoint
5302 || other_b
->type
== bp_access_watchpoint
)
5304 struct watchpoint
*other_w
=
5305 (struct watchpoint
*) other_b
;
5307 if (other_w
->watchpoint_triggered
5308 == watch_triggered_yes
)
5310 other_write_watchpoint
= 1;
5316 if (other_write_watchpoint
5317 || bl
->watchpoint_type
== hw_access
)
5319 /* We're watching the same memory for writes,
5320 and the value changed since the last time we
5321 updated it, so this trap must be for a write.
5323 bs
->print_it
= print_it_noop
;
5328 case WP_VALUE_NOT_CHANGED
:
5329 if (b
->base
.type
== bp_hardware_watchpoint
5330 || b
->base
.type
== bp_watchpoint
)
5332 /* Don't stop: write watchpoints shouldn't fire if
5333 the value hasn't changed. */
5334 bs
->print_it
= print_it_noop
;
5342 /* Error from catch_errors. */
5343 printf_filtered (_("Watchpoint %d deleted.\n"), b
->base
.number
);
5344 watchpoint_del_at_next_stop (b
);
5345 /* We've already printed what needs to be printed. */
5346 bs
->print_it
= print_it_done
;
5350 else /* must_check_value == 0 */
5352 /* This is a case where some watchpoint(s) triggered, but
5353 not at the address of this watchpoint, or else no
5354 watchpoint triggered after all. So don't print
5355 anything for this watchpoint. */
5356 bs
->print_it
= print_it_noop
;
5362 /* For breakpoints that are currently marked as telling gdb to stop,
5363 check conditions (condition proper, frame, thread and ignore count)
5364 of breakpoint referred to by BS. If we should not stop for this
5365 breakpoint, set BS->stop to 0. */
5368 bpstat_check_breakpoint_conditions (bpstat bs
, ptid_t ptid
)
5370 const struct bp_location
*bl
;
5371 struct breakpoint
*b
;
5372 int value_is_zero
= 0;
5373 struct expression
*cond
;
5375 gdb_assert (bs
->stop
);
5377 /* BS is built for existing struct breakpoint. */
5378 bl
= bs
->bp_location_at
;
5379 gdb_assert (bl
!= NULL
);
5380 b
= bs
->breakpoint_at
;
5381 gdb_assert (b
!= NULL
);
5383 /* Even if the target evaluated the condition on its end and notified GDB, we
5384 need to do so again since GDB does not know if we stopped due to a
5385 breakpoint or a single step breakpoint. */
5387 if (frame_id_p (b
->frame_id
)
5388 && !frame_id_eq (b
->frame_id
, get_stack_frame_id (get_current_frame ())))
5394 /* If this is a thread/task-specific breakpoint, don't waste cpu
5395 evaluating the condition if this isn't the specified
5397 if ((b
->thread
!= -1 && b
->thread
!= pid_to_thread_id (ptid
))
5398 || (b
->task
!= 0 && b
->task
!= ada_get_task_number (ptid
)))
5405 /* Evaluate extension language breakpoints that have a "stop" method
5407 bs
->stop
= breakpoint_ext_lang_cond_says_stop (b
);
5409 if (is_watchpoint (b
))
5411 struct watchpoint
*w
= (struct watchpoint
*) b
;
5418 if (cond
&& b
->disposition
!= disp_del_at_next_stop
)
5420 int within_current_scope
= 1;
5421 struct watchpoint
* w
;
5423 /* We use value_mark and value_free_to_mark because it could
5424 be a long time before we return to the command level and
5425 call free_all_values. We can't call free_all_values
5426 because we might be in the middle of evaluating a
5428 struct value
*mark
= value_mark ();
5430 if (is_watchpoint (b
))
5431 w
= (struct watchpoint
*) b
;
5435 /* Need to select the frame, with all that implies so that
5436 the conditions will have the right context. Because we
5437 use the frame, we will not see an inlined function's
5438 variables when we arrive at a breakpoint at the start
5439 of the inlined function; the current frame will be the
5441 if (w
== NULL
|| w
->cond_exp_valid_block
== NULL
)
5442 select_frame (get_current_frame ());
5445 struct frame_info
*frame
;
5447 /* For local watchpoint expressions, which particular
5448 instance of a local is being watched matters, so we
5449 keep track of the frame to evaluate the expression
5450 in. To evaluate the condition however, it doesn't
5451 really matter which instantiation of the function
5452 where the condition makes sense triggers the
5453 watchpoint. This allows an expression like "watch
5454 global if q > 10" set in `func', catch writes to
5455 global on all threads that call `func', or catch
5456 writes on all recursive calls of `func' by a single
5457 thread. We simply always evaluate the condition in
5458 the innermost frame that's executing where it makes
5459 sense to evaluate the condition. It seems
5461 frame
= block_innermost_frame (w
->cond_exp_valid_block
);
5463 select_frame (frame
);
5465 within_current_scope
= 0;
5467 if (within_current_scope
)
5469 = catch_errors (breakpoint_cond_eval
, cond
,
5470 "Error in testing breakpoint condition:\n",
5474 warning (_("Watchpoint condition cannot be tested "
5475 "in the current scope"));
5476 /* If we failed to set the right context for this
5477 watchpoint, unconditionally report it. */
5480 /* FIXME-someday, should give breakpoint #. */
5481 value_free_to_mark (mark
);
5484 if (cond
&& value_is_zero
)
5488 else if (b
->ignore_count
> 0)
5492 /* Increase the hit count even though we don't stop. */
5494 observer_notify_breakpoint_modified (b
);
5499 /* Get a bpstat associated with having just stopped at address
5500 BP_ADDR in thread PTID.
5502 Determine whether we stopped at a breakpoint, etc, or whether we
5503 don't understand this stop. Result is a chain of bpstat's such
5506 if we don't understand the stop, the result is a null pointer.
5508 if we understand why we stopped, the result is not null.
5510 Each element of the chain refers to a particular breakpoint or
5511 watchpoint at which we have stopped. (We may have stopped for
5512 several reasons concurrently.)
5514 Each element of the chain has valid next, breakpoint_at,
5515 commands, FIXME??? fields. */
5518 bpstat_stop_status (struct address_space
*aspace
,
5519 CORE_ADDR bp_addr
, ptid_t ptid
,
5520 const struct target_waitstatus
*ws
)
5522 struct breakpoint
*b
= NULL
;
5523 struct bp_location
*bl
;
5524 struct bp_location
*loc
;
5525 /* First item of allocated bpstat's. */
5526 bpstat bs_head
= NULL
, *bs_link
= &bs_head
;
5527 /* Pointer to the last thing in the chain currently. */
5530 int need_remove_insert
;
5533 /* First, build the bpstat chain with locations that explain a
5534 target stop, while being careful to not set the target running,
5535 as that may invalidate locations (in particular watchpoint
5536 locations are recreated). Resuming will happen here with
5537 breakpoint conditions or watchpoint expressions that include
5538 inferior function calls. */
5542 if (!breakpoint_enabled (b
) && b
->enable_state
!= bp_permanent
)
5545 for (bl
= b
->loc
; bl
!= NULL
; bl
= bl
->next
)
5547 /* For hardware watchpoints, we look only at the first
5548 location. The watchpoint_check function will work on the
5549 entire expression, not the individual locations. For
5550 read watchpoints, the watchpoints_triggered function has
5551 checked all locations already. */
5552 if (b
->type
== bp_hardware_watchpoint
&& bl
!= b
->loc
)
5555 if (!bl
->enabled
|| bl
->shlib_disabled
)
5558 if (!bpstat_check_location (bl
, aspace
, bp_addr
, ws
))
5561 /* Come here if it's a watchpoint, or if the break address
5564 bs
= bpstat_alloc (bl
, &bs_link
); /* Alloc a bpstat to
5567 /* Assume we stop. Should we find a watchpoint that is not
5568 actually triggered, or if the condition of the breakpoint
5569 evaluates as false, we'll reset 'stop' to 0. */
5573 /* If this is a scope breakpoint, mark the associated
5574 watchpoint as triggered so that we will handle the
5575 out-of-scope event. We'll get to the watchpoint next
5577 if (b
->type
== bp_watchpoint_scope
&& b
->related_breakpoint
!= b
)
5579 struct watchpoint
*w
= (struct watchpoint
*) b
->related_breakpoint
;
5581 w
->watchpoint_triggered
= watch_triggered_yes
;
5586 /* Check if a moribund breakpoint explains the stop. */
5587 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
5589 if (breakpoint_location_address_match (loc
, aspace
, bp_addr
))
5591 bs
= bpstat_alloc (loc
, &bs_link
);
5592 /* For hits of moribund locations, we should just proceed. */
5595 bs
->print_it
= print_it_noop
;
5599 /* A bit of special processing for shlib breakpoints. We need to
5600 process solib loading here, so that the lists of loaded and
5601 unloaded libraries are correct before we handle "catch load" and
5603 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5605 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->type
== bp_shlib_event
)
5607 handle_solib_event ();
5612 /* Now go through the locations that caused the target to stop, and
5613 check whether we're interested in reporting this stop to higher
5614 layers, or whether we should resume the target transparently. */
5618 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5623 b
= bs
->breakpoint_at
;
5624 b
->ops
->check_status (bs
);
5627 bpstat_check_breakpoint_conditions (bs
, ptid
);
5632 observer_notify_breakpoint_modified (b
);
5634 /* We will stop here. */
5635 if (b
->disposition
== disp_disable
)
5637 --(b
->enable_count
);
5638 if (b
->enable_count
<= 0
5639 && b
->enable_state
!= bp_permanent
)
5640 b
->enable_state
= bp_disabled
;
5645 bs
->commands
= b
->commands
;
5646 incref_counted_command_line (bs
->commands
);
5647 if (command_line_is_silent (bs
->commands
5648 ? bs
->commands
->commands
: NULL
))
5651 b
->ops
->after_condition_true (bs
);
5656 /* Print nothing for this entry if we don't stop or don't
5658 if (!bs
->stop
|| !bs
->print
)
5659 bs
->print_it
= print_it_noop
;
5662 /* If we aren't stopping, the value of some hardware watchpoint may
5663 not have changed, but the intermediate memory locations we are
5664 watching may have. Don't bother if we're stopping; this will get
5666 need_remove_insert
= 0;
5667 if (! bpstat_causes_stop (bs_head
))
5668 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5670 && bs
->breakpoint_at
5671 && is_hardware_watchpoint (bs
->breakpoint_at
))
5673 struct watchpoint
*w
= (struct watchpoint
*) bs
->breakpoint_at
;
5675 update_watchpoint (w
, 0 /* don't reparse. */);
5676 need_remove_insert
= 1;
5679 if (need_remove_insert
)
5680 update_global_location_list (UGLL_MAY_INSERT
);
5681 else if (removed_any
)
5682 update_global_location_list (UGLL_DONT_INSERT
);
5688 handle_jit_event (void)
5690 struct frame_info
*frame
;
5691 struct gdbarch
*gdbarch
;
5693 /* Switch terminal for any messages produced by
5694 breakpoint_re_set. */
5695 target_terminal_ours_for_output ();
5697 frame
= get_current_frame ();
5698 gdbarch
= get_frame_arch (frame
);
5700 jit_event_handler (gdbarch
);
5702 target_terminal_inferior ();
5705 /* Prepare WHAT final decision for infrun. */
5707 /* Decide what infrun needs to do with this bpstat. */
5710 bpstat_what (bpstat bs_head
)
5712 struct bpstat_what retval
;
5716 retval
.main_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5717 retval
.call_dummy
= STOP_NONE
;
5718 retval
.is_longjmp
= 0;
5720 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5722 /* Extract this BS's action. After processing each BS, we check
5723 if its action overrides all we've seem so far. */
5724 enum bpstat_what_main_action this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5727 if (bs
->breakpoint_at
== NULL
)
5729 /* I suspect this can happen if it was a momentary
5730 breakpoint which has since been deleted. */
5734 bptype
= bs
->breakpoint_at
->type
;
5741 case bp_hardware_breakpoint
:
5742 case bp_single_step
:
5745 case bp_shlib_event
:
5749 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5751 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5754 this_action
= BPSTAT_WHAT_SINGLE
;
5757 case bp_hardware_watchpoint
:
5758 case bp_read_watchpoint
:
5759 case bp_access_watchpoint
:
5763 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5765 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5769 /* There was a watchpoint, but we're not stopping.
5770 This requires no further action. */
5774 case bp_longjmp_call_dummy
:
5776 this_action
= BPSTAT_WHAT_SET_LONGJMP_RESUME
;
5777 retval
.is_longjmp
= bptype
!= bp_exception
;
5779 case bp_longjmp_resume
:
5780 case bp_exception_resume
:
5781 this_action
= BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
;
5782 retval
.is_longjmp
= bptype
== bp_longjmp_resume
;
5784 case bp_step_resume
:
5786 this_action
= BPSTAT_WHAT_STEP_RESUME
;
5789 /* It is for the wrong frame. */
5790 this_action
= BPSTAT_WHAT_SINGLE
;
5793 case bp_hp_step_resume
:
5795 this_action
= BPSTAT_WHAT_HP_STEP_RESUME
;
5798 /* It is for the wrong frame. */
5799 this_action
= BPSTAT_WHAT_SINGLE
;
5802 case bp_watchpoint_scope
:
5803 case bp_thread_event
:
5804 case bp_overlay_event
:
5805 case bp_longjmp_master
:
5806 case bp_std_terminate_master
:
5807 case bp_exception_master
:
5808 this_action
= BPSTAT_WHAT_SINGLE
;
5814 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5816 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5820 /* There was a catchpoint, but we're not stopping.
5821 This requires no further action. */
5826 this_action
= BPSTAT_WHAT_SINGLE
;
5829 /* Make sure the action is stop (silent or noisy),
5830 so infrun.c pops the dummy frame. */
5831 retval
.call_dummy
= STOP_STACK_DUMMY
;
5832 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5834 case bp_std_terminate
:
5835 /* Make sure the action is stop (silent or noisy),
5836 so infrun.c pops the dummy frame. */
5837 retval
.call_dummy
= STOP_STD_TERMINATE
;
5838 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5841 case bp_fast_tracepoint
:
5842 case bp_static_tracepoint
:
5843 /* Tracepoint hits should not be reported back to GDB, and
5844 if one got through somehow, it should have been filtered
5846 internal_error (__FILE__
, __LINE__
,
5847 _("bpstat_what: tracepoint encountered"));
5849 case bp_gnu_ifunc_resolver
:
5850 /* Step over it (and insert bp_gnu_ifunc_resolver_return). */
5851 this_action
= BPSTAT_WHAT_SINGLE
;
5853 case bp_gnu_ifunc_resolver_return
:
5854 /* The breakpoint will be removed, execution will restart from the
5855 PC of the former breakpoint. */
5856 this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5861 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5863 this_action
= BPSTAT_WHAT_SINGLE
;
5867 internal_error (__FILE__
, __LINE__
,
5868 _("bpstat_what: unhandled bptype %d"), (int) bptype
);
5871 retval
.main_action
= max (retval
.main_action
, this_action
);
5874 /* These operations may affect the bs->breakpoint_at state so they are
5875 delayed after MAIN_ACTION is decided above. */
5880 fprintf_unfiltered (gdb_stdlog
, "bpstat_what: bp_jit_event\n");
5882 handle_jit_event ();
5885 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5887 struct breakpoint
*b
= bs
->breakpoint_at
;
5893 case bp_gnu_ifunc_resolver
:
5894 gnu_ifunc_resolver_stop (b
);
5896 case bp_gnu_ifunc_resolver_return
:
5897 gnu_ifunc_resolver_return_stop (b
);
5905 /* Nonzero if we should step constantly (e.g. watchpoints on machines
5906 without hardware support). This isn't related to a specific bpstat,
5907 just to things like whether watchpoints are set. */
5910 bpstat_should_step (void)
5912 struct breakpoint
*b
;
5915 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
&& b
->loc
!= NULL
)
5921 bpstat_causes_stop (bpstat bs
)
5923 for (; bs
!= NULL
; bs
= bs
->next
)
5932 /* Compute a string of spaces suitable to indent the next line
5933 so it starts at the position corresponding to the table column
5934 named COL_NAME in the currently active table of UIOUT. */
5937 wrap_indent_at_field (struct ui_out
*uiout
, const char *col_name
)
5939 static char wrap_indent
[80];
5940 int i
, total_width
, width
, align
;
5944 for (i
= 1; ui_out_query_field (uiout
, i
, &width
, &align
, &text
); i
++)
5946 if (strcmp (text
, col_name
) == 0)
5948 gdb_assert (total_width
< sizeof wrap_indent
);
5949 memset (wrap_indent
, ' ', total_width
);
5950 wrap_indent
[total_width
] = 0;
5955 total_width
+= width
+ 1;
5961 /* Determine if the locations of this breakpoint will have their conditions
5962 evaluated by the target, host or a mix of both. Returns the following:
5964 "host": Host evals condition.
5965 "host or target": Host or Target evals condition.
5966 "target": Target evals condition.
5970 bp_condition_evaluator (struct breakpoint
*b
)
5972 struct bp_location
*bl
;
5973 char host_evals
= 0;
5974 char target_evals
= 0;
5979 if (!is_breakpoint (b
))
5982 if (gdb_evaluates_breakpoint_condition_p ()
5983 || !target_supports_evaluation_of_breakpoint_conditions ())
5984 return condition_evaluation_host
;
5986 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
5988 if (bl
->cond_bytecode
)
5994 if (host_evals
&& target_evals
)
5995 return condition_evaluation_both
;
5996 else if (target_evals
)
5997 return condition_evaluation_target
;
5999 return condition_evaluation_host
;
6002 /* Determine the breakpoint location's condition evaluator. This is
6003 similar to bp_condition_evaluator, but for locations. */
6006 bp_location_condition_evaluator (struct bp_location
*bl
)
6008 if (bl
&& !is_breakpoint (bl
->owner
))
6011 if (gdb_evaluates_breakpoint_condition_p ()
6012 || !target_supports_evaluation_of_breakpoint_conditions ())
6013 return condition_evaluation_host
;
6015 if (bl
&& bl
->cond_bytecode
)
6016 return condition_evaluation_target
;
6018 return condition_evaluation_host
;
6021 /* Print the LOC location out of the list of B->LOC locations. */
6024 print_breakpoint_location (struct breakpoint
*b
,
6025 struct bp_location
*loc
)
6027 struct ui_out
*uiout
= current_uiout
;
6028 struct cleanup
*old_chain
= save_current_program_space ();
6030 if (loc
!= NULL
&& loc
->shlib_disabled
)
6034 set_current_program_space (loc
->pspace
);
6036 if (b
->display_canonical
)
6037 ui_out_field_string (uiout
, "what", b
->addr_string
);
6038 else if (loc
&& loc
->symtab
)
6041 = find_pc_sect_function (loc
->address
, loc
->section
);
6044 ui_out_text (uiout
, "in ");
6045 ui_out_field_string (uiout
, "func",
6046 SYMBOL_PRINT_NAME (sym
));
6047 ui_out_text (uiout
, " ");
6048 ui_out_wrap_hint (uiout
, wrap_indent_at_field (uiout
, "what"));
6049 ui_out_text (uiout
, "at ");
6051 ui_out_field_string (uiout
, "file",
6052 symtab_to_filename_for_display (loc
->symtab
));
6053 ui_out_text (uiout
, ":");
6055 if (ui_out_is_mi_like_p (uiout
))
6056 ui_out_field_string (uiout
, "fullname",
6057 symtab_to_fullname (loc
->symtab
));
6059 ui_out_field_int (uiout
, "line", loc
->line_number
);
6063 struct ui_file
*stb
= mem_fileopen ();
6064 struct cleanup
*stb_chain
= make_cleanup_ui_file_delete (stb
);
6066 print_address_symbolic (loc
->gdbarch
, loc
->address
, stb
,
6068 ui_out_field_stream (uiout
, "at", stb
);
6070 do_cleanups (stb_chain
);
6073 ui_out_field_string (uiout
, "pending", b
->addr_string
);
6075 if (loc
&& is_breakpoint (b
)
6076 && breakpoint_condition_evaluation_mode () == condition_evaluation_target
6077 && bp_condition_evaluator (b
) == condition_evaluation_both
)
6079 ui_out_text (uiout
, " (");
6080 ui_out_field_string (uiout
, "evaluated-by",
6081 bp_location_condition_evaluator (loc
));
6082 ui_out_text (uiout
, ")");
6085 do_cleanups (old_chain
);
6089 bptype_string (enum bptype type
)
6091 struct ep_type_description
6096 static struct ep_type_description bptypes
[] =
6098 {bp_none
, "?deleted?"},
6099 {bp_breakpoint
, "breakpoint"},
6100 {bp_hardware_breakpoint
, "hw breakpoint"},
6101 {bp_single_step
, "sw single-step"},
6102 {bp_until
, "until"},
6103 {bp_finish
, "finish"},
6104 {bp_watchpoint
, "watchpoint"},
6105 {bp_hardware_watchpoint
, "hw watchpoint"},
6106 {bp_read_watchpoint
, "read watchpoint"},
6107 {bp_access_watchpoint
, "acc watchpoint"},
6108 {bp_longjmp
, "longjmp"},
6109 {bp_longjmp_resume
, "longjmp resume"},
6110 {bp_longjmp_call_dummy
, "longjmp for call dummy"},
6111 {bp_exception
, "exception"},
6112 {bp_exception_resume
, "exception resume"},
6113 {bp_step_resume
, "step resume"},
6114 {bp_hp_step_resume
, "high-priority step resume"},
6115 {bp_watchpoint_scope
, "watchpoint scope"},
6116 {bp_call_dummy
, "call dummy"},
6117 {bp_std_terminate
, "std::terminate"},
6118 {bp_shlib_event
, "shlib events"},
6119 {bp_thread_event
, "thread events"},
6120 {bp_overlay_event
, "overlay events"},
6121 {bp_longjmp_master
, "longjmp master"},
6122 {bp_std_terminate_master
, "std::terminate master"},
6123 {bp_exception_master
, "exception master"},
6124 {bp_catchpoint
, "catchpoint"},
6125 {bp_tracepoint
, "tracepoint"},
6126 {bp_fast_tracepoint
, "fast tracepoint"},
6127 {bp_static_tracepoint
, "static tracepoint"},
6128 {bp_dprintf
, "dprintf"},
6129 {bp_jit_event
, "jit events"},
6130 {bp_gnu_ifunc_resolver
, "STT_GNU_IFUNC resolver"},
6131 {bp_gnu_ifunc_resolver_return
, "STT_GNU_IFUNC resolver return"},
6134 if (((int) type
>= (sizeof (bptypes
) / sizeof (bptypes
[0])))
6135 || ((int) type
!= bptypes
[(int) type
].type
))
6136 internal_error (__FILE__
, __LINE__
,
6137 _("bptypes table does not describe type #%d."),
6140 return bptypes
[(int) type
].description
;
6143 /* For MI, output a field named 'thread-groups' with a list as the value.
6144 For CLI, prefix the list with the string 'inf'. */
6147 output_thread_groups (struct ui_out
*uiout
,
6148 const char *field_name
,
6152 struct cleanup
*back_to
;
6153 int is_mi
= ui_out_is_mi_like_p (uiout
);
6157 /* For backward compatibility, don't display inferiors in CLI unless
6158 there are several. Always display them for MI. */
6159 if (!is_mi
&& mi_only
)
6162 back_to
= make_cleanup_ui_out_list_begin_end (uiout
, field_name
);
6164 for (i
= 0; VEC_iterate (int, inf_num
, i
, inf
); ++i
)
6170 xsnprintf (mi_group
, sizeof (mi_group
), "i%d", inf
);
6171 ui_out_field_string (uiout
, NULL
, mi_group
);
6176 ui_out_text (uiout
, " inf ");
6178 ui_out_text (uiout
, ", ");
6180 ui_out_text (uiout
, plongest (inf
));
6184 do_cleanups (back_to
);
6187 /* Print B to gdb_stdout. */
6190 print_one_breakpoint_location (struct breakpoint
*b
,
6191 struct bp_location
*loc
,
6193 struct bp_location
**last_loc
,
6196 struct command_line
*l
;
6197 static char bpenables
[] = "nynny";
6199 struct ui_out
*uiout
= current_uiout
;
6200 int header_of_multiple
= 0;
6201 int part_of_multiple
= (loc
!= NULL
);
6202 struct value_print_options opts
;
6204 get_user_print_options (&opts
);
6206 gdb_assert (!loc
|| loc_number
!= 0);
6207 /* See comment in print_one_breakpoint concerning treatment of
6208 breakpoints with single disabled location. */
6211 && (b
->loc
->next
!= NULL
|| !b
->loc
->enabled
)))
6212 header_of_multiple
= 1;
6220 if (part_of_multiple
)
6223 formatted
= xstrprintf ("%d.%d", b
->number
, loc_number
);
6224 ui_out_field_string (uiout
, "number", formatted
);
6229 ui_out_field_int (uiout
, "number", b
->number
);
6234 if (part_of_multiple
)
6235 ui_out_field_skip (uiout
, "type");
6237 ui_out_field_string (uiout
, "type", bptype_string (b
->type
));
6241 if (part_of_multiple
)
6242 ui_out_field_skip (uiout
, "disp");
6244 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
6249 if (part_of_multiple
)
6250 ui_out_field_string (uiout
, "enabled", loc
->enabled
? "y" : "n");
6252 ui_out_field_fmt (uiout
, "enabled", "%c",
6253 bpenables
[(int) b
->enable_state
]);
6254 ui_out_spaces (uiout
, 2);
6258 if (b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
6260 /* Although the print_one can possibly print all locations,
6261 calling it here is not likely to get any nice result. So,
6262 make sure there's just one location. */
6263 gdb_assert (b
->loc
== NULL
|| b
->loc
->next
== NULL
);
6264 b
->ops
->print_one (b
, last_loc
);
6270 internal_error (__FILE__
, __LINE__
,
6271 _("print_one_breakpoint: bp_none encountered\n"));
6275 case bp_hardware_watchpoint
:
6276 case bp_read_watchpoint
:
6277 case bp_access_watchpoint
:
6279 struct watchpoint
*w
= (struct watchpoint
*) b
;
6281 /* Field 4, the address, is omitted (which makes the columns
6282 not line up too nicely with the headers, but the effect
6283 is relatively readable). */
6284 if (opts
.addressprint
)
6285 ui_out_field_skip (uiout
, "addr");
6287 ui_out_field_string (uiout
, "what", w
->exp_string
);
6292 case bp_hardware_breakpoint
:
6293 case bp_single_step
:
6297 case bp_longjmp_resume
:
6298 case bp_longjmp_call_dummy
:
6300 case bp_exception_resume
:
6301 case bp_step_resume
:
6302 case bp_hp_step_resume
:
6303 case bp_watchpoint_scope
:
6305 case bp_std_terminate
:
6306 case bp_shlib_event
:
6307 case bp_thread_event
:
6308 case bp_overlay_event
:
6309 case bp_longjmp_master
:
6310 case bp_std_terminate_master
:
6311 case bp_exception_master
:
6313 case bp_fast_tracepoint
:
6314 case bp_static_tracepoint
:
6317 case bp_gnu_ifunc_resolver
:
6318 case bp_gnu_ifunc_resolver_return
:
6319 if (opts
.addressprint
)
6322 if (header_of_multiple
)
6323 ui_out_field_string (uiout
, "addr", "<MULTIPLE>");
6324 else if (b
->loc
== NULL
|| loc
->shlib_disabled
)
6325 ui_out_field_string (uiout
, "addr", "<PENDING>");
6327 ui_out_field_core_addr (uiout
, "addr",
6328 loc
->gdbarch
, loc
->address
);
6331 if (!header_of_multiple
)
6332 print_breakpoint_location (b
, loc
);
6339 if (loc
!= NULL
&& !header_of_multiple
)
6341 struct inferior
*inf
;
6342 VEC(int) *inf_num
= NULL
;
6347 if (inf
->pspace
== loc
->pspace
)
6348 VEC_safe_push (int, inf_num
, inf
->num
);
6351 /* For backward compatibility, don't display inferiors in CLI unless
6352 there are several. Always display for MI. */
6354 || (!gdbarch_has_global_breakpoints (target_gdbarch ())
6355 && (number_of_program_spaces () > 1
6356 || number_of_inferiors () > 1)
6357 /* LOC is for existing B, it cannot be in
6358 moribund_locations and thus having NULL OWNER. */
6359 && loc
->owner
->type
!= bp_catchpoint
))
6361 output_thread_groups (uiout
, "thread-groups", inf_num
, mi_only
);
6362 VEC_free (int, inf_num
);
6365 if (!part_of_multiple
)
6367 if (b
->thread
!= -1)
6369 /* FIXME: This seems to be redundant and lost here; see the
6370 "stop only in" line a little further down. */
6371 ui_out_text (uiout
, " thread ");
6372 ui_out_field_int (uiout
, "thread", b
->thread
);
6374 else if (b
->task
!= 0)
6376 ui_out_text (uiout
, " task ");
6377 ui_out_field_int (uiout
, "task", b
->task
);
6381 ui_out_text (uiout
, "\n");
6383 if (!part_of_multiple
)
6384 b
->ops
->print_one_detail (b
, uiout
);
6386 if (part_of_multiple
&& frame_id_p (b
->frame_id
))
6389 ui_out_text (uiout
, "\tstop only in stack frame at ");
6390 /* FIXME: cagney/2002-12-01: Shouldn't be poking around inside
6392 ui_out_field_core_addr (uiout
, "frame",
6393 b
->gdbarch
, b
->frame_id
.stack_addr
);
6394 ui_out_text (uiout
, "\n");
6397 if (!part_of_multiple
&& b
->cond_string
)
6400 if (is_tracepoint (b
))
6401 ui_out_text (uiout
, "\ttrace only if ");
6403 ui_out_text (uiout
, "\tstop only if ");
6404 ui_out_field_string (uiout
, "cond", b
->cond_string
);
6406 /* Print whether the target is doing the breakpoint's condition
6407 evaluation. If GDB is doing the evaluation, don't print anything. */
6408 if (is_breakpoint (b
)
6409 && breakpoint_condition_evaluation_mode ()
6410 == condition_evaluation_target
)
6412 ui_out_text (uiout
, " (");
6413 ui_out_field_string (uiout
, "evaluated-by",
6414 bp_condition_evaluator (b
));
6415 ui_out_text (uiout
, " evals)");
6417 ui_out_text (uiout
, "\n");
6420 if (!part_of_multiple
&& b
->thread
!= -1)
6422 /* FIXME should make an annotation for this. */
6423 ui_out_text (uiout
, "\tstop only in thread ");
6424 ui_out_field_int (uiout
, "thread", b
->thread
);
6425 ui_out_text (uiout
, "\n");
6428 if (!part_of_multiple
)
6432 /* FIXME should make an annotation for this. */
6433 if (is_catchpoint (b
))
6434 ui_out_text (uiout
, "\tcatchpoint");
6435 else if (is_tracepoint (b
))
6436 ui_out_text (uiout
, "\ttracepoint");
6438 ui_out_text (uiout
, "\tbreakpoint");
6439 ui_out_text (uiout
, " already hit ");
6440 ui_out_field_int (uiout
, "times", b
->hit_count
);
6441 if (b
->hit_count
== 1)
6442 ui_out_text (uiout
, " time\n");
6444 ui_out_text (uiout
, " times\n");
6448 /* Output the count also if it is zero, but only if this is mi. */
6449 if (ui_out_is_mi_like_p (uiout
))
6450 ui_out_field_int (uiout
, "times", b
->hit_count
);
6454 if (!part_of_multiple
&& b
->ignore_count
)
6457 ui_out_text (uiout
, "\tignore next ");
6458 ui_out_field_int (uiout
, "ignore", b
->ignore_count
);
6459 ui_out_text (uiout
, " hits\n");
6462 /* Note that an enable count of 1 corresponds to "enable once"
6463 behavior, which is reported by the combination of enablement and
6464 disposition, so we don't need to mention it here. */
6465 if (!part_of_multiple
&& b
->enable_count
> 1)
6468 ui_out_text (uiout
, "\tdisable after ");
6469 /* Tweak the wording to clarify that ignore and enable counts
6470 are distinct, and have additive effect. */
6471 if (b
->ignore_count
)
6472 ui_out_text (uiout
, "additional ");
6474 ui_out_text (uiout
, "next ");
6475 ui_out_field_int (uiout
, "enable", b
->enable_count
);
6476 ui_out_text (uiout
, " hits\n");
6479 if (!part_of_multiple
&& is_tracepoint (b
))
6481 struct tracepoint
*tp
= (struct tracepoint
*) b
;
6483 if (tp
->traceframe_usage
)
6485 ui_out_text (uiout
, "\ttrace buffer usage ");
6486 ui_out_field_int (uiout
, "traceframe-usage", tp
->traceframe_usage
);
6487 ui_out_text (uiout
, " bytes\n");
6491 l
= b
->commands
? b
->commands
->commands
: NULL
;
6492 if (!part_of_multiple
&& l
)
6494 struct cleanup
*script_chain
;
6497 script_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "script");
6498 print_command_lines (uiout
, l
, 4);
6499 do_cleanups (script_chain
);
6502 if (is_tracepoint (b
))
6504 struct tracepoint
*t
= (struct tracepoint
*) b
;
6506 if (!part_of_multiple
&& t
->pass_count
)
6508 annotate_field (10);
6509 ui_out_text (uiout
, "\tpass count ");
6510 ui_out_field_int (uiout
, "pass", t
->pass_count
);
6511 ui_out_text (uiout
, " \n");
6514 /* Don't display it when tracepoint or tracepoint location is
6516 if (!header_of_multiple
&& loc
!= NULL
&& !loc
->shlib_disabled
)
6518 annotate_field (11);
6520 if (ui_out_is_mi_like_p (uiout
))
6521 ui_out_field_string (uiout
, "installed",
6522 loc
->inserted
? "y" : "n");
6526 ui_out_text (uiout
, "\t");
6528 ui_out_text (uiout
, "\tnot ");
6529 ui_out_text (uiout
, "installed on target\n");
6534 if (ui_out_is_mi_like_p (uiout
) && !part_of_multiple
)
6536 if (is_watchpoint (b
))
6538 struct watchpoint
*w
= (struct watchpoint
*) b
;
6540 ui_out_field_string (uiout
, "original-location", w
->exp_string
);
6542 else if (b
->addr_string
)
6543 ui_out_field_string (uiout
, "original-location", b
->addr_string
);
6548 print_one_breakpoint (struct breakpoint
*b
,
6549 struct bp_location
**last_loc
,
6552 struct cleanup
*bkpt_chain
;
6553 struct ui_out
*uiout
= current_uiout
;
6555 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "bkpt");
6557 print_one_breakpoint_location (b
, NULL
, 0, last_loc
, allflag
);
6558 do_cleanups (bkpt_chain
);
6560 /* If this breakpoint has custom print function,
6561 it's already printed. Otherwise, print individual
6562 locations, if any. */
6563 if (b
->ops
== NULL
|| b
->ops
->print_one
== NULL
)
6565 /* If breakpoint has a single location that is disabled, we
6566 print it as if it had several locations, since otherwise it's
6567 hard to represent "breakpoint enabled, location disabled"
6570 Note that while hardware watchpoints have several locations
6571 internally, that's not a property exposed to user. */
6573 && !is_hardware_watchpoint (b
)
6574 && (b
->loc
->next
|| !b
->loc
->enabled
))
6576 struct bp_location
*loc
;
6579 for (loc
= b
->loc
; loc
; loc
= loc
->next
, ++n
)
6581 struct cleanup
*inner2
=
6582 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
6583 print_one_breakpoint_location (b
, loc
, n
, last_loc
, allflag
);
6584 do_cleanups (inner2
);
6591 breakpoint_address_bits (struct breakpoint
*b
)
6593 int print_address_bits
= 0;
6594 struct bp_location
*loc
;
6596 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
6600 /* Software watchpoints that aren't watching memory don't have
6601 an address to print. */
6602 if (b
->type
== bp_watchpoint
&& loc
->watchpoint_type
== -1)
6605 addr_bit
= gdbarch_addr_bit (loc
->gdbarch
);
6606 if (addr_bit
> print_address_bits
)
6607 print_address_bits
= addr_bit
;
6610 return print_address_bits
;
6613 struct captured_breakpoint_query_args
6619 do_captured_breakpoint_query (struct ui_out
*uiout
, void *data
)
6621 struct captured_breakpoint_query_args
*args
= data
;
6622 struct breakpoint
*b
;
6623 struct bp_location
*dummy_loc
= NULL
;
6627 if (args
->bnum
== b
->number
)
6629 print_one_breakpoint (b
, &dummy_loc
, 0);
6637 gdb_breakpoint_query (struct ui_out
*uiout
, int bnum
,
6638 char **error_message
)
6640 struct captured_breakpoint_query_args args
;
6643 /* For the moment we don't trust print_one_breakpoint() to not throw
6645 if (catch_exceptions_with_msg (uiout
, do_captured_breakpoint_query
, &args
,
6646 error_message
, RETURN_MASK_ALL
) < 0)
6652 /* Return true if this breakpoint was set by the user, false if it is
6653 internal or momentary. */
6656 user_breakpoint_p (struct breakpoint
*b
)
6658 return b
->number
> 0;
6661 /* Print information on user settable breakpoint (watchpoint, etc)
6662 number BNUM. If BNUM is -1 print all user-settable breakpoints.
6663 If ALLFLAG is non-zero, include non-user-settable breakpoints. If
6664 FILTER is non-NULL, call it on each breakpoint and only include the
6665 ones for which it returns non-zero. Return the total number of
6666 breakpoints listed. */
6669 breakpoint_1 (char *args
, int allflag
,
6670 int (*filter
) (const struct breakpoint
*))
6672 struct breakpoint
*b
;
6673 struct bp_location
*last_loc
= NULL
;
6674 int nr_printable_breakpoints
;
6675 struct cleanup
*bkpttbl_chain
;
6676 struct value_print_options opts
;
6677 int print_address_bits
= 0;
6678 int print_type_col_width
= 14;
6679 struct ui_out
*uiout
= current_uiout
;
6681 get_user_print_options (&opts
);
6683 /* Compute the number of rows in the table, as well as the size
6684 required for address fields. */
6685 nr_printable_breakpoints
= 0;
6688 /* If we have a filter, only list the breakpoints it accepts. */
6689 if (filter
&& !filter (b
))
6692 /* If we have an "args" string, it is a list of breakpoints to
6693 accept. Skip the others. */
6694 if (args
!= NULL
&& *args
!= '\0')
6696 if (allflag
&& parse_and_eval_long (args
) != b
->number
)
6698 if (!allflag
&& !number_is_in_list (args
, b
->number
))
6702 if (allflag
|| user_breakpoint_p (b
))
6704 int addr_bit
, type_len
;
6706 addr_bit
= breakpoint_address_bits (b
);
6707 if (addr_bit
> print_address_bits
)
6708 print_address_bits
= addr_bit
;
6710 type_len
= strlen (bptype_string (b
->type
));
6711 if (type_len
> print_type_col_width
)
6712 print_type_col_width
= type_len
;
6714 nr_printable_breakpoints
++;
6718 if (opts
.addressprint
)
6720 = make_cleanup_ui_out_table_begin_end (uiout
, 6,
6721 nr_printable_breakpoints
,
6725 = make_cleanup_ui_out_table_begin_end (uiout
, 5,
6726 nr_printable_breakpoints
,
6729 if (nr_printable_breakpoints
> 0)
6730 annotate_breakpoints_headers ();
6731 if (nr_printable_breakpoints
> 0)
6733 ui_out_table_header (uiout
, 7, ui_left
, "number", "Num"); /* 1 */
6734 if (nr_printable_breakpoints
> 0)
6736 ui_out_table_header (uiout
, print_type_col_width
, ui_left
,
6737 "type", "Type"); /* 2 */
6738 if (nr_printable_breakpoints
> 0)
6740 ui_out_table_header (uiout
, 4, ui_left
, "disp", "Disp"); /* 3 */
6741 if (nr_printable_breakpoints
> 0)
6743 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb"); /* 4 */
6744 if (opts
.addressprint
)
6746 if (nr_printable_breakpoints
> 0)
6748 if (print_address_bits
<= 32)
6749 ui_out_table_header (uiout
, 10, ui_left
,
6750 "addr", "Address"); /* 5 */
6752 ui_out_table_header (uiout
, 18, ui_left
,
6753 "addr", "Address"); /* 5 */
6755 if (nr_printable_breakpoints
> 0)
6757 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What"); /* 6 */
6758 ui_out_table_body (uiout
);
6759 if (nr_printable_breakpoints
> 0)
6760 annotate_breakpoints_table ();
6765 /* If we have a filter, only list the breakpoints it accepts. */
6766 if (filter
&& !filter (b
))
6769 /* If we have an "args" string, it is a list of breakpoints to
6770 accept. Skip the others. */
6772 if (args
!= NULL
&& *args
!= '\0')
6774 if (allflag
) /* maintenance info breakpoint */
6776 if (parse_and_eval_long (args
) != b
->number
)
6779 else /* all others */
6781 if (!number_is_in_list (args
, b
->number
))
6785 /* We only print out user settable breakpoints unless the
6787 if (allflag
|| user_breakpoint_p (b
))
6788 print_one_breakpoint (b
, &last_loc
, allflag
);
6791 do_cleanups (bkpttbl_chain
);
6793 if (nr_printable_breakpoints
== 0)
6795 /* If there's a filter, let the caller decide how to report
6799 if (args
== NULL
|| *args
== '\0')
6800 ui_out_message (uiout
, 0, "No breakpoints or watchpoints.\n");
6802 ui_out_message (uiout
, 0,
6803 "No breakpoint or watchpoint matching '%s'.\n",
6809 if (last_loc
&& !server_command
)
6810 set_next_address (last_loc
->gdbarch
, last_loc
->address
);
6813 /* FIXME? Should this be moved up so that it is only called when
6814 there have been breakpoints? */
6815 annotate_breakpoints_table_end ();
6817 return nr_printable_breakpoints
;
6820 /* Display the value of default-collect in a way that is generally
6821 compatible with the breakpoint list. */
6824 default_collect_info (void)
6826 struct ui_out
*uiout
= current_uiout
;
6828 /* If it has no value (which is frequently the case), say nothing; a
6829 message like "No default-collect." gets in user's face when it's
6831 if (!*default_collect
)
6834 /* The following phrase lines up nicely with per-tracepoint collect
6836 ui_out_text (uiout
, "default collect ");
6837 ui_out_field_string (uiout
, "default-collect", default_collect
);
6838 ui_out_text (uiout
, " \n");
6842 breakpoints_info (char *args
, int from_tty
)
6844 breakpoint_1 (args
, 0, NULL
);
6846 default_collect_info ();
6850 watchpoints_info (char *args
, int from_tty
)
6852 int num_printed
= breakpoint_1 (args
, 0, is_watchpoint
);
6853 struct ui_out
*uiout
= current_uiout
;
6855 if (num_printed
== 0)
6857 if (args
== NULL
|| *args
== '\0')
6858 ui_out_message (uiout
, 0, "No watchpoints.\n");
6860 ui_out_message (uiout
, 0, "No watchpoint matching '%s'.\n", args
);
6865 maintenance_info_breakpoints (char *args
, int from_tty
)
6867 breakpoint_1 (args
, 1, NULL
);
6869 default_collect_info ();
6873 breakpoint_has_pc (struct breakpoint
*b
,
6874 struct program_space
*pspace
,
6875 CORE_ADDR pc
, struct obj_section
*section
)
6877 struct bp_location
*bl
= b
->loc
;
6879 for (; bl
; bl
= bl
->next
)
6881 if (bl
->pspace
== pspace
6882 && bl
->address
== pc
6883 && (!overlay_debugging
|| bl
->section
== section
))
6889 /* Print a message describing any user-breakpoints set at PC. This
6890 concerns with logical breakpoints, so we match program spaces, not
6894 describe_other_breakpoints (struct gdbarch
*gdbarch
,
6895 struct program_space
*pspace
, CORE_ADDR pc
,
6896 struct obj_section
*section
, int thread
)
6899 struct breakpoint
*b
;
6902 others
+= (user_breakpoint_p (b
)
6903 && breakpoint_has_pc (b
, pspace
, pc
, section
));
6907 printf_filtered (_("Note: breakpoint "));
6908 else /* if (others == ???) */
6909 printf_filtered (_("Note: breakpoints "));
6911 if (user_breakpoint_p (b
) && breakpoint_has_pc (b
, pspace
, pc
, section
))
6914 printf_filtered ("%d", b
->number
);
6915 if (b
->thread
== -1 && thread
!= -1)
6916 printf_filtered (" (all threads)");
6917 else if (b
->thread
!= -1)
6918 printf_filtered (" (thread %d)", b
->thread
);
6919 printf_filtered ("%s%s ",
6920 ((b
->enable_state
== bp_disabled
6921 || b
->enable_state
== bp_call_disabled
)
6923 : b
->enable_state
== bp_permanent
6927 : ((others
== 1) ? " and" : ""));
6929 printf_filtered (_("also set at pc "));
6930 fputs_filtered (paddress (gdbarch
, pc
), gdb_stdout
);
6931 printf_filtered (".\n");
6936 /* Return true iff it is meaningful to use the address member of
6937 BPT. For some breakpoint types, the address member is irrelevant
6938 and it makes no sense to attempt to compare it to other addresses
6939 (or use it for any other purpose either).
6941 More specifically, each of the following breakpoint types will
6942 always have a zero valued address and we don't want to mark
6943 breakpoints of any of these types to be a duplicate of an actual
6944 breakpoint at address zero:
6952 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
6954 enum bptype type
= bpt
->type
;
6956 return (type
!= bp_watchpoint
&& type
!= bp_catchpoint
);
6959 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
6960 true if LOC1 and LOC2 represent the same watchpoint location. */
6963 watchpoint_locations_match (struct bp_location
*loc1
,
6964 struct bp_location
*loc2
)
6966 struct watchpoint
*w1
= (struct watchpoint
*) loc1
->owner
;
6967 struct watchpoint
*w2
= (struct watchpoint
*) loc2
->owner
;
6969 /* Both of them must exist. */
6970 gdb_assert (w1
!= NULL
);
6971 gdb_assert (w2
!= NULL
);
6973 /* If the target can evaluate the condition expression in hardware,
6974 then we we need to insert both watchpoints even if they are at
6975 the same place. Otherwise the watchpoint will only trigger when
6976 the condition of whichever watchpoint was inserted evaluates to
6977 true, not giving a chance for GDB to check the condition of the
6978 other watchpoint. */
6980 && target_can_accel_watchpoint_condition (loc1
->address
,
6982 loc1
->watchpoint_type
,
6985 && target_can_accel_watchpoint_condition (loc2
->address
,
6987 loc2
->watchpoint_type
,
6991 /* Note that this checks the owner's type, not the location's. In
6992 case the target does not support read watchpoints, but does
6993 support access watchpoints, we'll have bp_read_watchpoint
6994 watchpoints with hw_access locations. Those should be considered
6995 duplicates of hw_read locations. The hw_read locations will
6996 become hw_access locations later. */
6997 return (loc1
->owner
->type
== loc2
->owner
->type
6998 && loc1
->pspace
->aspace
== loc2
->pspace
->aspace
6999 && loc1
->address
== loc2
->address
7000 && loc1
->length
== loc2
->length
);
7003 /* See breakpoint.h. */
7006 breakpoint_address_match (struct address_space
*aspace1
, CORE_ADDR addr1
,
7007 struct address_space
*aspace2
, CORE_ADDR addr2
)
7009 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
7010 || aspace1
== aspace2
)
7014 /* Returns true if {ASPACE2,ADDR2} falls within the range determined by
7015 {ASPACE1,ADDR1,LEN1}. In most targets, this can only be true if ASPACE1
7016 matches ASPACE2. On targets that have global breakpoints, the address
7017 space doesn't really matter. */
7020 breakpoint_address_match_range (struct address_space
*aspace1
, CORE_ADDR addr1
,
7021 int len1
, struct address_space
*aspace2
,
7024 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
7025 || aspace1
== aspace2
)
7026 && addr2
>= addr1
&& addr2
< addr1
+ len1
);
7029 /* Returns true if {ASPACE,ADDR} matches the breakpoint BL. BL may be
7030 a ranged breakpoint. In most targets, a match happens only if ASPACE
7031 matches the breakpoint's address space. On targets that have global
7032 breakpoints, the address space doesn't really matter. */
7035 breakpoint_location_address_match (struct bp_location
*bl
,
7036 struct address_space
*aspace
,
7039 return (breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
7042 && breakpoint_address_match_range (bl
->pspace
->aspace
,
7043 bl
->address
, bl
->length
,
7047 /* If LOC1 and LOC2's owners are not tracepoints, returns false directly.
7048 Then, if LOC1 and LOC2 represent the same tracepoint location, returns
7049 true, otherwise returns false. */
7052 tracepoint_locations_match (struct bp_location
*loc1
,
7053 struct bp_location
*loc2
)
7055 if (is_tracepoint (loc1
->owner
) && is_tracepoint (loc2
->owner
))
7056 /* Since tracepoint locations are never duplicated with others', tracepoint
7057 locations at the same address of different tracepoints are regarded as
7058 different locations. */
7059 return (loc1
->address
== loc2
->address
&& loc1
->owner
== loc2
->owner
);
7064 /* Assuming LOC1 and LOC2's types' have meaningful target addresses
7065 (breakpoint_address_is_meaningful), returns true if LOC1 and LOC2
7066 represent the same location. */
7069 breakpoint_locations_match (struct bp_location
*loc1
,
7070 struct bp_location
*loc2
)
7072 int hw_point1
, hw_point2
;
7074 /* Both of them must not be in moribund_locations. */
7075 gdb_assert (loc1
->owner
!= NULL
);
7076 gdb_assert (loc2
->owner
!= NULL
);
7078 hw_point1
= is_hardware_watchpoint (loc1
->owner
);
7079 hw_point2
= is_hardware_watchpoint (loc2
->owner
);
7081 if (hw_point1
!= hw_point2
)
7084 return watchpoint_locations_match (loc1
, loc2
);
7085 else if (is_tracepoint (loc1
->owner
) || is_tracepoint (loc2
->owner
))
7086 return tracepoint_locations_match (loc1
, loc2
);
7088 /* We compare bp_location.length in order to cover ranged breakpoints. */
7089 return (breakpoint_address_match (loc1
->pspace
->aspace
, loc1
->address
,
7090 loc2
->pspace
->aspace
, loc2
->address
)
7091 && loc1
->length
== loc2
->length
);
7095 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
7096 int bnum
, int have_bnum
)
7098 /* The longest string possibly returned by hex_string_custom
7099 is 50 chars. These must be at least that big for safety. */
7103 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
7104 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
7106 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
7107 bnum
, astr1
, astr2
);
7109 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
7112 /* Adjust a breakpoint's address to account for architectural
7113 constraints on breakpoint placement. Return the adjusted address.
7114 Note: Very few targets require this kind of adjustment. For most
7115 targets, this function is simply the identity function. */
7118 adjust_breakpoint_address (struct gdbarch
*gdbarch
,
7119 CORE_ADDR bpaddr
, enum bptype bptype
)
7121 if (!gdbarch_adjust_breakpoint_address_p (gdbarch
))
7123 /* Very few targets need any kind of breakpoint adjustment. */
7126 else if (bptype
== bp_watchpoint
7127 || bptype
== bp_hardware_watchpoint
7128 || bptype
== bp_read_watchpoint
7129 || bptype
== bp_access_watchpoint
7130 || bptype
== bp_catchpoint
)
7132 /* Watchpoints and the various bp_catch_* eventpoints should not
7133 have their addresses modified. */
7136 else if (bptype
== bp_single_step
)
7138 /* Single-step breakpoints should not have their addresses
7139 modified. If there's any architectural constrain that
7140 applies to this address, then it should have already been
7141 taken into account when the breakpoint was created in the
7142 first place. If we didn't do this, stepping through e.g.,
7143 Thumb-2 IT blocks would break. */
7148 CORE_ADDR adjusted_bpaddr
;
7150 /* Some targets have architectural constraints on the placement
7151 of breakpoint instructions. Obtain the adjusted address. */
7152 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (gdbarch
, bpaddr
);
7154 /* An adjusted breakpoint address can significantly alter
7155 a user's expectations. Print a warning if an adjustment
7157 if (adjusted_bpaddr
!= bpaddr
)
7158 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
7160 return adjusted_bpaddr
;
7165 init_bp_location (struct bp_location
*loc
, const struct bp_location_ops
*ops
,
7166 struct breakpoint
*owner
)
7168 memset (loc
, 0, sizeof (*loc
));
7170 gdb_assert (ops
!= NULL
);
7175 loc
->cond_bytecode
= NULL
;
7176 loc
->shlib_disabled
= 0;
7179 switch (owner
->type
)
7182 case bp_single_step
:
7186 case bp_longjmp_resume
:
7187 case bp_longjmp_call_dummy
:
7189 case bp_exception_resume
:
7190 case bp_step_resume
:
7191 case bp_hp_step_resume
:
7192 case bp_watchpoint_scope
:
7194 case bp_std_terminate
:
7195 case bp_shlib_event
:
7196 case bp_thread_event
:
7197 case bp_overlay_event
:
7199 case bp_longjmp_master
:
7200 case bp_std_terminate_master
:
7201 case bp_exception_master
:
7202 case bp_gnu_ifunc_resolver
:
7203 case bp_gnu_ifunc_resolver_return
:
7205 loc
->loc_type
= bp_loc_software_breakpoint
;
7206 mark_breakpoint_location_modified (loc
);
7208 case bp_hardware_breakpoint
:
7209 loc
->loc_type
= bp_loc_hardware_breakpoint
;
7210 mark_breakpoint_location_modified (loc
);
7212 case bp_hardware_watchpoint
:
7213 case bp_read_watchpoint
:
7214 case bp_access_watchpoint
:
7215 loc
->loc_type
= bp_loc_hardware_watchpoint
;
7220 case bp_fast_tracepoint
:
7221 case bp_static_tracepoint
:
7222 loc
->loc_type
= bp_loc_other
;
7225 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
7231 /* Allocate a struct bp_location. */
7233 static struct bp_location
*
7234 allocate_bp_location (struct breakpoint
*bpt
)
7236 return bpt
->ops
->allocate_location (bpt
);
7240 free_bp_location (struct bp_location
*loc
)
7242 loc
->ops
->dtor (loc
);
7246 /* Increment reference count. */
7249 incref_bp_location (struct bp_location
*bl
)
7254 /* Decrement reference count. If the reference count reaches 0,
7255 destroy the bp_location. Sets *BLP to NULL. */
7258 decref_bp_location (struct bp_location
**blp
)
7260 gdb_assert ((*blp
)->refc
> 0);
7262 if (--(*blp
)->refc
== 0)
7263 free_bp_location (*blp
);
7267 /* Add breakpoint B at the end of the global breakpoint chain. */
7270 add_to_breakpoint_chain (struct breakpoint
*b
)
7272 struct breakpoint
*b1
;
7274 /* Add this breakpoint to the end of the chain so that a list of
7275 breakpoints will come out in order of increasing numbers. */
7277 b1
= breakpoint_chain
;
7279 breakpoint_chain
= b
;
7288 /* Initializes breakpoint B with type BPTYPE and no locations yet. */
7291 init_raw_breakpoint_without_location (struct breakpoint
*b
,
7292 struct gdbarch
*gdbarch
,
7294 const struct breakpoint_ops
*ops
)
7296 memset (b
, 0, sizeof (*b
));
7298 gdb_assert (ops
!= NULL
);
7302 b
->gdbarch
= gdbarch
;
7303 b
->language
= current_language
->la_language
;
7304 b
->input_radix
= input_radix
;
7306 b
->enable_state
= bp_enabled
;
7309 b
->ignore_count
= 0;
7311 b
->frame_id
= null_frame_id
;
7312 b
->condition_not_parsed
= 0;
7313 b
->py_bp_object
= NULL
;
7314 b
->related_breakpoint
= b
;
7317 /* Helper to set_raw_breakpoint below. Creates a breakpoint
7318 that has type BPTYPE and has no locations as yet. */
7320 static struct breakpoint
*
7321 set_raw_breakpoint_without_location (struct gdbarch
*gdbarch
,
7323 const struct breakpoint_ops
*ops
)
7325 struct breakpoint
*b
= XNEW (struct breakpoint
);
7327 init_raw_breakpoint_without_location (b
, gdbarch
, bptype
, ops
);
7328 add_to_breakpoint_chain (b
);
7332 /* Initialize loc->function_name. EXPLICIT_LOC says no indirect function
7333 resolutions should be made as the user specified the location explicitly
7337 set_breakpoint_location_function (struct bp_location
*loc
, int explicit_loc
)
7339 gdb_assert (loc
->owner
!= NULL
);
7341 if (loc
->owner
->type
== bp_breakpoint
7342 || loc
->owner
->type
== bp_hardware_breakpoint
7343 || is_tracepoint (loc
->owner
))
7346 const char *function_name
;
7347 CORE_ADDR func_addr
;
7349 find_pc_partial_function_gnu_ifunc (loc
->address
, &function_name
,
7350 &func_addr
, NULL
, &is_gnu_ifunc
);
7352 if (is_gnu_ifunc
&& !explicit_loc
)
7354 struct breakpoint
*b
= loc
->owner
;
7356 gdb_assert (loc
->pspace
== current_program_space
);
7357 if (gnu_ifunc_resolve_name (function_name
,
7358 &loc
->requested_address
))
7360 /* Recalculate ADDRESS based on new REQUESTED_ADDRESS. */
7361 loc
->address
= adjust_breakpoint_address (loc
->gdbarch
,
7362 loc
->requested_address
,
7365 else if (b
->type
== bp_breakpoint
&& b
->loc
== loc
7366 && loc
->next
== NULL
&& b
->related_breakpoint
== b
)
7368 /* Create only the whole new breakpoint of this type but do not
7369 mess more complicated breakpoints with multiple locations. */
7370 b
->type
= bp_gnu_ifunc_resolver
;
7371 /* Remember the resolver's address for use by the return
7373 loc
->related_address
= func_addr
;
7378 loc
->function_name
= xstrdup (function_name
);
7382 /* Attempt to determine architecture of location identified by SAL. */
7384 get_sal_arch (struct symtab_and_line sal
)
7387 return get_objfile_arch (sal
.section
->objfile
);
7389 return get_objfile_arch (sal
.symtab
->objfile
);
7394 /* Low level routine for partially initializing a breakpoint of type
7395 BPTYPE. The newly created breakpoint's address, section, source
7396 file name, and line number are provided by SAL.
7398 It is expected that the caller will complete the initialization of
7399 the newly created breakpoint struct as well as output any status
7400 information regarding the creation of a new breakpoint. */
7403 init_raw_breakpoint (struct breakpoint
*b
, struct gdbarch
*gdbarch
,
7404 struct symtab_and_line sal
, enum bptype bptype
,
7405 const struct breakpoint_ops
*ops
)
7407 init_raw_breakpoint_without_location (b
, gdbarch
, bptype
, ops
);
7409 add_location_to_breakpoint (b
, &sal
);
7411 if (bptype
!= bp_catchpoint
)
7412 gdb_assert (sal
.pspace
!= NULL
);
7414 /* Store the program space that was used to set the breakpoint,
7415 except for ordinary breakpoints, which are independent of the
7417 if (bptype
!= bp_breakpoint
&& bptype
!= bp_hardware_breakpoint
)
7418 b
->pspace
= sal
.pspace
;
7421 /* set_raw_breakpoint is a low level routine for allocating and
7422 partially initializing a breakpoint of type BPTYPE. The newly
7423 created breakpoint's address, section, source file name, and line
7424 number are provided by SAL. The newly created and partially
7425 initialized breakpoint is added to the breakpoint chain and
7426 is also returned as the value of this function.
7428 It is expected that the caller will complete the initialization of
7429 the newly created breakpoint struct as well as output any status
7430 information regarding the creation of a new breakpoint. In
7431 particular, set_raw_breakpoint does NOT set the breakpoint
7432 number! Care should be taken to not allow an error to occur
7433 prior to completing the initialization of the breakpoint. If this
7434 should happen, a bogus breakpoint will be left on the chain. */
7437 set_raw_breakpoint (struct gdbarch
*gdbarch
,
7438 struct symtab_and_line sal
, enum bptype bptype
,
7439 const struct breakpoint_ops
*ops
)
7441 struct breakpoint
*b
= XNEW (struct breakpoint
);
7443 init_raw_breakpoint (b
, gdbarch
, sal
, bptype
, ops
);
7444 add_to_breakpoint_chain (b
);
7449 /* Note that the breakpoint object B describes a permanent breakpoint
7450 instruction, hard-wired into the inferior's code. */
7452 make_breakpoint_permanent (struct breakpoint
*b
)
7454 struct bp_location
*bl
;
7456 b
->enable_state
= bp_permanent
;
7458 /* By definition, permanent breakpoints are already present in the
7459 code. Mark all locations as inserted. For now,
7460 make_breakpoint_permanent is called in just one place, so it's
7461 hard to say if it's reasonable to have permanent breakpoint with
7462 multiple locations or not, but it's easy to implement. */
7463 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
7467 /* Call this routine when stepping and nexting to enable a breakpoint
7468 if we do a longjmp() or 'throw' in TP. FRAME is the frame which
7469 initiated the operation. */
7472 set_longjmp_breakpoint (struct thread_info
*tp
, struct frame_id frame
)
7474 struct breakpoint
*b
, *b_tmp
;
7475 int thread
= tp
->num
;
7477 /* To avoid having to rescan all objfile symbols at every step,
7478 we maintain a list of continually-inserted but always disabled
7479 longjmp "master" breakpoints. Here, we simply create momentary
7480 clones of those and enable them for the requested thread. */
7481 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7482 if (b
->pspace
== current_program_space
7483 && (b
->type
== bp_longjmp_master
7484 || b
->type
== bp_exception_master
))
7486 enum bptype type
= b
->type
== bp_longjmp_master
? bp_longjmp
: bp_exception
;
7487 struct breakpoint
*clone
;
7489 /* longjmp_breakpoint_ops ensures INITIATING_FRAME is cleared again
7490 after their removal. */
7491 clone
= momentary_breakpoint_from_master (b
, type
,
7492 &longjmp_breakpoint_ops
, 1);
7493 clone
->thread
= thread
;
7496 tp
->initiating_frame
= frame
;
7499 /* Delete all longjmp breakpoints from THREAD. */
7501 delete_longjmp_breakpoint (int thread
)
7503 struct breakpoint
*b
, *b_tmp
;
7505 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7506 if (b
->type
== bp_longjmp
|| b
->type
== bp_exception
)
7508 if (b
->thread
== thread
)
7509 delete_breakpoint (b
);
7514 delete_longjmp_breakpoint_at_next_stop (int thread
)
7516 struct breakpoint
*b
, *b_tmp
;
7518 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7519 if (b
->type
== bp_longjmp
|| b
->type
== bp_exception
)
7521 if (b
->thread
== thread
)
7522 b
->disposition
= disp_del_at_next_stop
;
7526 /* Place breakpoints of type bp_longjmp_call_dummy to catch longjmp for
7527 INFERIOR_PTID thread. Chain them all by RELATED_BREAKPOINT and return
7528 pointer to any of them. Return NULL if this system cannot place longjmp
7532 set_longjmp_breakpoint_for_call_dummy (void)
7534 struct breakpoint
*b
, *retval
= NULL
;
7537 if (b
->pspace
== current_program_space
&& b
->type
== bp_longjmp_master
)
7539 struct breakpoint
*new_b
;
7541 new_b
= momentary_breakpoint_from_master (b
, bp_longjmp_call_dummy
,
7542 &momentary_breakpoint_ops
,
7544 new_b
->thread
= pid_to_thread_id (inferior_ptid
);
7546 /* Link NEW_B into the chain of RETVAL breakpoints. */
7548 gdb_assert (new_b
->related_breakpoint
== new_b
);
7551 new_b
->related_breakpoint
= retval
;
7552 while (retval
->related_breakpoint
!= new_b
->related_breakpoint
)
7553 retval
= retval
->related_breakpoint
;
7554 retval
->related_breakpoint
= new_b
;
7560 /* Verify all existing dummy frames and their associated breakpoints for
7561 TP. Remove those which can no longer be found in the current frame
7564 You should call this function only at places where it is safe to currently
7565 unwind the whole stack. Failed stack unwind would discard live dummy
7569 check_longjmp_breakpoint_for_call_dummy (struct thread_info
*tp
)
7571 struct breakpoint
*b
, *b_tmp
;
7573 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7574 if (b
->type
== bp_longjmp_call_dummy
&& b
->thread
== tp
->num
)
7576 struct breakpoint
*dummy_b
= b
->related_breakpoint
;
7578 while (dummy_b
!= b
&& dummy_b
->type
!= bp_call_dummy
)
7579 dummy_b
= dummy_b
->related_breakpoint
;
7580 if (dummy_b
->type
!= bp_call_dummy
7581 || frame_find_by_id (dummy_b
->frame_id
) != NULL
)
7584 dummy_frame_discard (dummy_b
->frame_id
, tp
->ptid
);
7586 while (b
->related_breakpoint
!= b
)
7588 if (b_tmp
== b
->related_breakpoint
)
7589 b_tmp
= b
->related_breakpoint
->next
;
7590 delete_breakpoint (b
->related_breakpoint
);
7592 delete_breakpoint (b
);
7597 enable_overlay_breakpoints (void)
7599 struct breakpoint
*b
;
7602 if (b
->type
== bp_overlay_event
)
7604 b
->enable_state
= bp_enabled
;
7605 update_global_location_list (UGLL_MAY_INSERT
);
7606 overlay_events_enabled
= 1;
7611 disable_overlay_breakpoints (void)
7613 struct breakpoint
*b
;
7616 if (b
->type
== bp_overlay_event
)
7618 b
->enable_state
= bp_disabled
;
7619 update_global_location_list (UGLL_DONT_INSERT
);
7620 overlay_events_enabled
= 0;
7624 /* Set an active std::terminate breakpoint for each std::terminate
7625 master breakpoint. */
7627 set_std_terminate_breakpoint (void)
7629 struct breakpoint
*b
, *b_tmp
;
7631 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7632 if (b
->pspace
== current_program_space
7633 && b
->type
== bp_std_terminate_master
)
7635 momentary_breakpoint_from_master (b
, bp_std_terminate
,
7636 &momentary_breakpoint_ops
, 1);
7640 /* Delete all the std::terminate breakpoints. */
7642 delete_std_terminate_breakpoint (void)
7644 struct breakpoint
*b
, *b_tmp
;
7646 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7647 if (b
->type
== bp_std_terminate
)
7648 delete_breakpoint (b
);
7652 create_thread_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7654 struct breakpoint
*b
;
7656 b
= create_internal_breakpoint (gdbarch
, address
, bp_thread_event
,
7657 &internal_breakpoint_ops
);
7659 b
->enable_state
= bp_enabled
;
7660 /* addr_string has to be used or breakpoint_re_set will delete me. */
7662 = xstrprintf ("*%s", paddress (b
->loc
->gdbarch
, b
->loc
->address
));
7664 update_global_location_list_nothrow (UGLL_MAY_INSERT
);
7670 remove_thread_event_breakpoints (void)
7672 struct breakpoint
*b
, *b_tmp
;
7674 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7675 if (b
->type
== bp_thread_event
7676 && b
->loc
->pspace
== current_program_space
)
7677 delete_breakpoint (b
);
7680 struct lang_and_radix
7686 /* Create a breakpoint for JIT code registration and unregistration. */
7689 create_jit_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7691 struct breakpoint
*b
;
7693 b
= create_internal_breakpoint (gdbarch
, address
, bp_jit_event
,
7694 &internal_breakpoint_ops
);
7695 update_global_location_list_nothrow (UGLL_MAY_INSERT
);
7699 /* Remove JIT code registration and unregistration breakpoint(s). */
7702 remove_jit_event_breakpoints (void)
7704 struct breakpoint
*b
, *b_tmp
;
7706 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7707 if (b
->type
== bp_jit_event
7708 && b
->loc
->pspace
== current_program_space
)
7709 delete_breakpoint (b
);
7713 remove_solib_event_breakpoints (void)
7715 struct breakpoint
*b
, *b_tmp
;
7717 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7718 if (b
->type
== bp_shlib_event
7719 && b
->loc
->pspace
== current_program_space
)
7720 delete_breakpoint (b
);
7723 /* See breakpoint.h. */
7726 remove_solib_event_breakpoints_at_next_stop (void)
7728 struct breakpoint
*b
, *b_tmp
;
7730 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7731 if (b
->type
== bp_shlib_event
7732 && b
->loc
->pspace
== current_program_space
)
7733 b
->disposition
= disp_del_at_next_stop
;
7736 /* Helper for create_solib_event_breakpoint /
7737 create_and_insert_solib_event_breakpoint. Allows specifying which
7738 INSERT_MODE to pass through to update_global_location_list. */
7740 static struct breakpoint
*
7741 create_solib_event_breakpoint_1 (struct gdbarch
*gdbarch
, CORE_ADDR address
,
7742 enum ugll_insert_mode insert_mode
)
7744 struct breakpoint
*b
;
7746 b
= create_internal_breakpoint (gdbarch
, address
, bp_shlib_event
,
7747 &internal_breakpoint_ops
);
7748 update_global_location_list_nothrow (insert_mode
);
7753 create_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7755 return create_solib_event_breakpoint_1 (gdbarch
, address
, UGLL_MAY_INSERT
);
7758 /* See breakpoint.h. */
7761 create_and_insert_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7763 struct breakpoint
*b
;
7765 /* Explicitly tell update_global_location_list to insert
7767 b
= create_solib_event_breakpoint_1 (gdbarch
, address
, UGLL_INSERT
);
7768 if (!b
->loc
->inserted
)
7770 delete_breakpoint (b
);
7776 /* Disable any breakpoints that are on code in shared libraries. Only
7777 apply to enabled breakpoints, disabled ones can just stay disabled. */
7780 disable_breakpoints_in_shlibs (void)
7782 struct bp_location
*loc
, **locp_tmp
;
7784 ALL_BP_LOCATIONS (loc
, locp_tmp
)
7786 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7787 struct breakpoint
*b
= loc
->owner
;
7789 /* We apply the check to all breakpoints, including disabled for
7790 those with loc->duplicate set. This is so that when breakpoint
7791 becomes enabled, or the duplicate is removed, gdb will try to
7792 insert all breakpoints. If we don't set shlib_disabled here,
7793 we'll try to insert those breakpoints and fail. */
7794 if (((b
->type
== bp_breakpoint
)
7795 || (b
->type
== bp_jit_event
)
7796 || (b
->type
== bp_hardware_breakpoint
)
7797 || (is_tracepoint (b
)))
7798 && loc
->pspace
== current_program_space
7799 && !loc
->shlib_disabled
7800 && solib_name_from_address (loc
->pspace
, loc
->address
)
7803 loc
->shlib_disabled
= 1;
7808 /* Disable any breakpoints and tracepoints that are in SOLIB upon
7809 notification of unloaded_shlib. Only apply to enabled breakpoints,
7810 disabled ones can just stay disabled. */
7813 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
7815 struct bp_location
*loc
, **locp_tmp
;
7816 int disabled_shlib_breaks
= 0;
7818 /* SunOS a.out shared libraries are always mapped, so do not
7819 disable breakpoints; they will only be reported as unloaded
7820 through clear_solib when GDB discards its shared library
7821 list. See clear_solib for more information. */
7822 if (exec_bfd
!= NULL
7823 && bfd_get_flavour (exec_bfd
) == bfd_target_aout_flavour
)
7826 ALL_BP_LOCATIONS (loc
, locp_tmp
)
7828 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7829 struct breakpoint
*b
= loc
->owner
;
7831 if (solib
->pspace
== loc
->pspace
7832 && !loc
->shlib_disabled
7833 && (((b
->type
== bp_breakpoint
7834 || b
->type
== bp_jit_event
7835 || b
->type
== bp_hardware_breakpoint
)
7836 && (loc
->loc_type
== bp_loc_hardware_breakpoint
7837 || loc
->loc_type
== bp_loc_software_breakpoint
))
7838 || is_tracepoint (b
))
7839 && solib_contains_address_p (solib
, loc
->address
))
7841 loc
->shlib_disabled
= 1;
7842 /* At this point, we cannot rely on remove_breakpoint
7843 succeeding so we must mark the breakpoint as not inserted
7844 to prevent future errors occurring in remove_breakpoints. */
7847 /* This may cause duplicate notifications for the same breakpoint. */
7848 observer_notify_breakpoint_modified (b
);
7850 if (!disabled_shlib_breaks
)
7852 target_terminal_ours_for_output ();
7853 warning (_("Temporarily disabling breakpoints "
7854 "for unloaded shared library \"%s\""),
7857 disabled_shlib_breaks
= 1;
7862 /* Disable any breakpoints and tracepoints in OBJFILE upon
7863 notification of free_objfile. Only apply to enabled breakpoints,
7864 disabled ones can just stay disabled. */
7867 disable_breakpoints_in_freed_objfile (struct objfile
*objfile
)
7869 struct breakpoint
*b
;
7871 if (objfile
== NULL
)
7874 /* OBJF_SHARED|OBJF_USERLOADED objfiles are dynamic modules manually
7875 managed by the user with add-symbol-file/remove-symbol-file.
7876 Similarly to how breakpoints in shared libraries are handled in
7877 response to "nosharedlibrary", mark breakpoints in such modules
7878 shlib_disabled so they end up uninserted on the next global
7879 location list update. Shared libraries not loaded by the user
7880 aren't handled here -- they're already handled in
7881 disable_breakpoints_in_unloaded_shlib, called by solib.c's
7882 solib_unloaded observer. We skip objfiles that are not
7883 OBJF_SHARED as those aren't considered dynamic objects (e.g. the
7885 if ((objfile
->flags
& OBJF_SHARED
) == 0
7886 || (objfile
->flags
& OBJF_USERLOADED
) == 0)
7891 struct bp_location
*loc
;
7892 int bp_modified
= 0;
7894 if (!is_breakpoint (b
) && !is_tracepoint (b
))
7897 for (loc
= b
->loc
; loc
!= NULL
; loc
= loc
->next
)
7899 CORE_ADDR loc_addr
= loc
->address
;
7901 if (loc
->loc_type
!= bp_loc_hardware_breakpoint
7902 && loc
->loc_type
!= bp_loc_software_breakpoint
)
7905 if (loc
->shlib_disabled
!= 0)
7908 if (objfile
->pspace
!= loc
->pspace
)
7911 if (loc
->loc_type
!= bp_loc_hardware_breakpoint
7912 && loc
->loc_type
!= bp_loc_software_breakpoint
)
7915 if (is_addr_in_objfile (loc_addr
, objfile
))
7917 loc
->shlib_disabled
= 1;
7918 /* At this point, we don't know whether the object was
7919 unmapped from the inferior or not, so leave the
7920 inserted flag alone. We'll handle failure to
7921 uninsert quietly, in case the object was indeed
7924 mark_breakpoint_location_modified (loc
);
7931 observer_notify_breakpoint_modified (b
);
7935 /* FORK & VFORK catchpoints. */
7937 /* An instance of this type is used to represent a fork or vfork
7938 catchpoint. It includes a "struct breakpoint" as a kind of base
7939 class; users downcast to "struct breakpoint *" when needed. A
7940 breakpoint is really of this type iff its ops pointer points to
7941 CATCH_FORK_BREAKPOINT_OPS. */
7943 struct fork_catchpoint
7945 /* The base class. */
7946 struct breakpoint base
;
7948 /* Process id of a child process whose forking triggered this
7949 catchpoint. This field is only valid immediately after this
7950 catchpoint has triggered. */
7951 ptid_t forked_inferior_pid
;
7954 /* Implement the "insert" breakpoint_ops method for fork
7958 insert_catch_fork (struct bp_location
*bl
)
7960 return target_insert_fork_catchpoint (ptid_get_pid (inferior_ptid
));
7963 /* Implement the "remove" breakpoint_ops method for fork
7967 remove_catch_fork (struct bp_location
*bl
)
7969 return target_remove_fork_catchpoint (ptid_get_pid (inferior_ptid
));
7972 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
7976 breakpoint_hit_catch_fork (const struct bp_location
*bl
,
7977 struct address_space
*aspace
, CORE_ADDR bp_addr
,
7978 const struct target_waitstatus
*ws
)
7980 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bl
->owner
;
7982 if (ws
->kind
!= TARGET_WAITKIND_FORKED
)
7985 c
->forked_inferior_pid
= ws
->value
.related_pid
;
7989 /* Implement the "print_it" breakpoint_ops method for fork
7992 static enum print_stop_action
7993 print_it_catch_fork (bpstat bs
)
7995 struct ui_out
*uiout
= current_uiout
;
7996 struct breakpoint
*b
= bs
->breakpoint_at
;
7997 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bs
->breakpoint_at
;
7999 annotate_catchpoint (b
->number
);
8000 if (b
->disposition
== disp_del
)
8001 ui_out_text (uiout
, "\nTemporary catchpoint ");
8003 ui_out_text (uiout
, "\nCatchpoint ");
8004 if (ui_out_is_mi_like_p (uiout
))
8006 ui_out_field_string (uiout
, "reason",
8007 async_reason_lookup (EXEC_ASYNC_FORK
));
8008 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
8010 ui_out_field_int (uiout
, "bkptno", b
->number
);
8011 ui_out_text (uiout
, " (forked process ");
8012 ui_out_field_int (uiout
, "newpid", ptid_get_pid (c
->forked_inferior_pid
));
8013 ui_out_text (uiout
, "), ");
8014 return PRINT_SRC_AND_LOC
;
8017 /* Implement the "print_one" breakpoint_ops method for fork
8021 print_one_catch_fork (struct breakpoint
*b
, struct bp_location
**last_loc
)
8023 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
8024 struct value_print_options opts
;
8025 struct ui_out
*uiout
= current_uiout
;
8027 get_user_print_options (&opts
);
8029 /* Field 4, the address, is omitted (which makes the columns not
8030 line up too nicely with the headers, but the effect is relatively
8032 if (opts
.addressprint
)
8033 ui_out_field_skip (uiout
, "addr");
8035 ui_out_text (uiout
, "fork");
8036 if (!ptid_equal (c
->forked_inferior_pid
, null_ptid
))
8038 ui_out_text (uiout
, ", process ");
8039 ui_out_field_int (uiout
, "what",
8040 ptid_get_pid (c
->forked_inferior_pid
));
8041 ui_out_spaces (uiout
, 1);
8044 if (ui_out_is_mi_like_p (uiout
))
8045 ui_out_field_string (uiout
, "catch-type", "fork");
8048 /* Implement the "print_mention" breakpoint_ops method for fork
8052 print_mention_catch_fork (struct breakpoint
*b
)
8054 printf_filtered (_("Catchpoint %d (fork)"), b
->number
);
8057 /* Implement the "print_recreate" breakpoint_ops method for fork
8061 print_recreate_catch_fork (struct breakpoint
*b
, struct ui_file
*fp
)
8063 fprintf_unfiltered (fp
, "catch fork");
8064 print_recreate_thread (b
, fp
);
8067 /* The breakpoint_ops structure to be used in fork catchpoints. */
8069 static struct breakpoint_ops catch_fork_breakpoint_ops
;
8071 /* Implement the "insert" breakpoint_ops method for vfork
8075 insert_catch_vfork (struct bp_location
*bl
)
8077 return target_insert_vfork_catchpoint (ptid_get_pid (inferior_ptid
));
8080 /* Implement the "remove" breakpoint_ops method for vfork
8084 remove_catch_vfork (struct bp_location
*bl
)
8086 return target_remove_vfork_catchpoint (ptid_get_pid (inferior_ptid
));
8089 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
8093 breakpoint_hit_catch_vfork (const struct bp_location
*bl
,
8094 struct address_space
*aspace
, CORE_ADDR bp_addr
,
8095 const struct target_waitstatus
*ws
)
8097 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bl
->owner
;
8099 if (ws
->kind
!= TARGET_WAITKIND_VFORKED
)
8102 c
->forked_inferior_pid
= ws
->value
.related_pid
;
8106 /* Implement the "print_it" breakpoint_ops method for vfork
8109 static enum print_stop_action
8110 print_it_catch_vfork (bpstat bs
)
8112 struct ui_out
*uiout
= current_uiout
;
8113 struct breakpoint
*b
= bs
->breakpoint_at
;
8114 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
8116 annotate_catchpoint (b
->number
);
8117 if (b
->disposition
== disp_del
)
8118 ui_out_text (uiout
, "\nTemporary catchpoint ");
8120 ui_out_text (uiout
, "\nCatchpoint ");
8121 if (ui_out_is_mi_like_p (uiout
))
8123 ui_out_field_string (uiout
, "reason",
8124 async_reason_lookup (EXEC_ASYNC_VFORK
));
8125 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
8127 ui_out_field_int (uiout
, "bkptno", b
->number
);
8128 ui_out_text (uiout
, " (vforked process ");
8129 ui_out_field_int (uiout
, "newpid", ptid_get_pid (c
->forked_inferior_pid
));
8130 ui_out_text (uiout
, "), ");
8131 return PRINT_SRC_AND_LOC
;
8134 /* Implement the "print_one" breakpoint_ops method for vfork
8138 print_one_catch_vfork (struct breakpoint
*b
, struct bp_location
**last_loc
)
8140 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
8141 struct value_print_options opts
;
8142 struct ui_out
*uiout
= current_uiout
;
8144 get_user_print_options (&opts
);
8145 /* Field 4, the address, is omitted (which makes the columns not
8146 line up too nicely with the headers, but the effect is relatively
8148 if (opts
.addressprint
)
8149 ui_out_field_skip (uiout
, "addr");
8151 ui_out_text (uiout
, "vfork");
8152 if (!ptid_equal (c
->forked_inferior_pid
, null_ptid
))
8154 ui_out_text (uiout
, ", process ");
8155 ui_out_field_int (uiout
, "what",
8156 ptid_get_pid (c
->forked_inferior_pid
));
8157 ui_out_spaces (uiout
, 1);
8160 if (ui_out_is_mi_like_p (uiout
))
8161 ui_out_field_string (uiout
, "catch-type", "vfork");
8164 /* Implement the "print_mention" breakpoint_ops method for vfork
8168 print_mention_catch_vfork (struct breakpoint
*b
)
8170 printf_filtered (_("Catchpoint %d (vfork)"), b
->number
);
8173 /* Implement the "print_recreate" breakpoint_ops method for vfork
8177 print_recreate_catch_vfork (struct breakpoint
*b
, struct ui_file
*fp
)
8179 fprintf_unfiltered (fp
, "catch vfork");
8180 print_recreate_thread (b
, fp
);
8183 /* The breakpoint_ops structure to be used in vfork catchpoints. */
8185 static struct breakpoint_ops catch_vfork_breakpoint_ops
;
8187 /* An instance of this type is used to represent an solib catchpoint.
8188 It includes a "struct breakpoint" as a kind of base class; users
8189 downcast to "struct breakpoint *" when needed. A breakpoint is
8190 really of this type iff its ops pointer points to
8191 CATCH_SOLIB_BREAKPOINT_OPS. */
8193 struct solib_catchpoint
8195 /* The base class. */
8196 struct breakpoint base
;
8198 /* True for "catch load", false for "catch unload". */
8199 unsigned char is_load
;
8201 /* Regular expression to match, if any. COMPILED is only valid when
8202 REGEX is non-NULL. */
8208 dtor_catch_solib (struct breakpoint
*b
)
8210 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8213 regfree (&self
->compiled
);
8214 xfree (self
->regex
);
8216 base_breakpoint_ops
.dtor (b
);
8220 insert_catch_solib (struct bp_location
*ignore
)
8226 remove_catch_solib (struct bp_location
*ignore
)
8232 breakpoint_hit_catch_solib (const struct bp_location
*bl
,
8233 struct address_space
*aspace
,
8235 const struct target_waitstatus
*ws
)
8237 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) bl
->owner
;
8238 struct breakpoint
*other
;
8240 if (ws
->kind
== TARGET_WAITKIND_LOADED
)
8243 ALL_BREAKPOINTS (other
)
8245 struct bp_location
*other_bl
;
8247 if (other
== bl
->owner
)
8250 if (other
->type
!= bp_shlib_event
)
8253 if (self
->base
.pspace
!= NULL
&& other
->pspace
!= self
->base
.pspace
)
8256 for (other_bl
= other
->loc
; other_bl
!= NULL
; other_bl
= other_bl
->next
)
8258 if (other
->ops
->breakpoint_hit (other_bl
, aspace
, bp_addr
, ws
))
8267 check_status_catch_solib (struct bpstats
*bs
)
8269 struct solib_catchpoint
*self
8270 = (struct solib_catchpoint
*) bs
->breakpoint_at
;
8275 struct so_list
*iter
;
8278 VEC_iterate (so_list_ptr
, current_program_space
->added_solibs
,
8283 || regexec (&self
->compiled
, iter
->so_name
, 0, NULL
, 0) == 0)
8292 VEC_iterate (char_ptr
, current_program_space
->deleted_solibs
,
8297 || regexec (&self
->compiled
, iter
, 0, NULL
, 0) == 0)
8303 bs
->print_it
= print_it_noop
;
8306 static enum print_stop_action
8307 print_it_catch_solib (bpstat bs
)
8309 struct breakpoint
*b
= bs
->breakpoint_at
;
8310 struct ui_out
*uiout
= current_uiout
;
8312 annotate_catchpoint (b
->number
);
8313 if (b
->disposition
== disp_del
)
8314 ui_out_text (uiout
, "\nTemporary catchpoint ");
8316 ui_out_text (uiout
, "\nCatchpoint ");
8317 ui_out_field_int (uiout
, "bkptno", b
->number
);
8318 ui_out_text (uiout
, "\n");
8319 if (ui_out_is_mi_like_p (uiout
))
8320 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
8321 print_solib_event (1);
8322 return PRINT_SRC_AND_LOC
;
8326 print_one_catch_solib (struct breakpoint
*b
, struct bp_location
**locs
)
8328 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8329 struct value_print_options opts
;
8330 struct ui_out
*uiout
= current_uiout
;
8333 get_user_print_options (&opts
);
8334 /* Field 4, the address, is omitted (which makes the columns not
8335 line up too nicely with the headers, but the effect is relatively
8337 if (opts
.addressprint
)
8340 ui_out_field_skip (uiout
, "addr");
8347 msg
= xstrprintf (_("load of library matching %s"), self
->regex
);
8349 msg
= xstrdup (_("load of library"));
8354 msg
= xstrprintf (_("unload of library matching %s"), self
->regex
);
8356 msg
= xstrdup (_("unload of library"));
8358 ui_out_field_string (uiout
, "what", msg
);
8361 if (ui_out_is_mi_like_p (uiout
))
8362 ui_out_field_string (uiout
, "catch-type",
8363 self
->is_load
? "load" : "unload");
8367 print_mention_catch_solib (struct breakpoint
*b
)
8369 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8371 printf_filtered (_("Catchpoint %d (%s)"), b
->number
,
8372 self
->is_load
? "load" : "unload");
8376 print_recreate_catch_solib (struct breakpoint
*b
, struct ui_file
*fp
)
8378 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8380 fprintf_unfiltered (fp
, "%s %s",
8381 b
->disposition
== disp_del
? "tcatch" : "catch",
8382 self
->is_load
? "load" : "unload");
8384 fprintf_unfiltered (fp
, " %s", self
->regex
);
8385 fprintf_unfiltered (fp
, "\n");
8388 static struct breakpoint_ops catch_solib_breakpoint_ops
;
8390 /* Shared helper function (MI and CLI) for creating and installing
8391 a shared object event catchpoint. If IS_LOAD is non-zero then
8392 the events to be caught are load events, otherwise they are
8393 unload events. If IS_TEMP is non-zero the catchpoint is a
8394 temporary one. If ENABLED is non-zero the catchpoint is
8395 created in an enabled state. */
8398 add_solib_catchpoint (char *arg
, int is_load
, int is_temp
, int enabled
)
8400 struct solib_catchpoint
*c
;
8401 struct gdbarch
*gdbarch
= get_current_arch ();
8402 struct cleanup
*cleanup
;
8406 arg
= skip_spaces (arg
);
8408 c
= XCNEW (struct solib_catchpoint
);
8409 cleanup
= make_cleanup (xfree
, c
);
8415 errcode
= regcomp (&c
->compiled
, arg
, REG_NOSUB
);
8418 char *err
= get_regcomp_error (errcode
, &c
->compiled
);
8420 make_cleanup (xfree
, err
);
8421 error (_("Invalid regexp (%s): %s"), err
, arg
);
8423 c
->regex
= xstrdup (arg
);
8426 c
->is_load
= is_load
;
8427 init_catchpoint (&c
->base
, gdbarch
, is_temp
, NULL
,
8428 &catch_solib_breakpoint_ops
);
8430 c
->base
.enable_state
= enabled
? bp_enabled
: bp_disabled
;
8432 discard_cleanups (cleanup
);
8433 install_breakpoint (0, &c
->base
, 1);
8436 /* A helper function that does all the work for "catch load" and
8440 catch_load_or_unload (char *arg
, int from_tty
, int is_load
,
8441 struct cmd_list_element
*command
)
8444 const int enabled
= 1;
8446 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
8448 add_solib_catchpoint (arg
, is_load
, tempflag
, enabled
);
8452 catch_load_command_1 (char *arg
, int from_tty
,
8453 struct cmd_list_element
*command
)
8455 catch_load_or_unload (arg
, from_tty
, 1, command
);
8459 catch_unload_command_1 (char *arg
, int from_tty
,
8460 struct cmd_list_element
*command
)
8462 catch_load_or_unload (arg
, from_tty
, 0, command
);
8465 /* An instance of this type is used to represent a syscall catchpoint.
8466 It includes a "struct breakpoint" as a kind of base class; users
8467 downcast to "struct breakpoint *" when needed. A breakpoint is
8468 really of this type iff its ops pointer points to
8469 CATCH_SYSCALL_BREAKPOINT_OPS. */
8471 struct syscall_catchpoint
8473 /* The base class. */
8474 struct breakpoint base
;
8476 /* Syscall numbers used for the 'catch syscall' feature. If no
8477 syscall has been specified for filtering, its value is NULL.
8478 Otherwise, it holds a list of all syscalls to be caught. The
8479 list elements are allocated with xmalloc. */
8480 VEC(int) *syscalls_to_be_caught
;
8483 /* Implement the "dtor" breakpoint_ops method for syscall
8487 dtor_catch_syscall (struct breakpoint
*b
)
8489 struct syscall_catchpoint
*c
= (struct syscall_catchpoint
*) b
;
8491 VEC_free (int, c
->syscalls_to_be_caught
);
8493 base_breakpoint_ops
.dtor (b
);
8496 static const struct inferior_data
*catch_syscall_inferior_data
= NULL
;
8498 struct catch_syscall_inferior_data
8500 /* We keep a count of the number of times the user has requested a
8501 particular syscall to be tracked, and pass this information to the
8502 target. This lets capable targets implement filtering directly. */
8504 /* Number of times that "any" syscall is requested. */
8505 int any_syscall_count
;
8507 /* Count of each system call. */
8508 VEC(int) *syscalls_counts
;
8510 /* This counts all syscall catch requests, so we can readily determine
8511 if any catching is necessary. */
8512 int total_syscalls_count
;
8515 static struct catch_syscall_inferior_data
*
8516 get_catch_syscall_inferior_data (struct inferior
*inf
)
8518 struct catch_syscall_inferior_data
*inf_data
;
8520 inf_data
= inferior_data (inf
, catch_syscall_inferior_data
);
8521 if (inf_data
== NULL
)
8523 inf_data
= XCNEW (struct catch_syscall_inferior_data
);
8524 set_inferior_data (inf
, catch_syscall_inferior_data
, inf_data
);
8531 catch_syscall_inferior_data_cleanup (struct inferior
*inf
, void *arg
)
8537 /* Implement the "insert" breakpoint_ops method for syscall
8541 insert_catch_syscall (struct bp_location
*bl
)
8543 struct syscall_catchpoint
*c
= (struct syscall_catchpoint
*) bl
->owner
;
8544 struct inferior
*inf
= current_inferior ();
8545 struct catch_syscall_inferior_data
*inf_data
8546 = get_catch_syscall_inferior_data (inf
);
8548 ++inf_data
->total_syscalls_count
;
8549 if (!c
->syscalls_to_be_caught
)
8550 ++inf_data
->any_syscall_count
;
8556 VEC_iterate (int, c
->syscalls_to_be_caught
, i
, iter
);
8561 if (iter
>= VEC_length (int, inf_data
->syscalls_counts
))
8563 int old_size
= VEC_length (int, inf_data
->syscalls_counts
);
8564 uintptr_t vec_addr_offset
8565 = old_size
* ((uintptr_t) sizeof (int));
8567 VEC_safe_grow (int, inf_data
->syscalls_counts
, iter
+ 1);
8568 vec_addr
= ((uintptr_t) VEC_address (int,
8569 inf_data
->syscalls_counts
)
8571 memset ((void *) vec_addr
, 0,
8572 (iter
+ 1 - old_size
) * sizeof (int));
8574 elem
= VEC_index (int, inf_data
->syscalls_counts
, iter
);
8575 VEC_replace (int, inf_data
->syscalls_counts
, iter
, ++elem
);
8579 return target_set_syscall_catchpoint (ptid_get_pid (inferior_ptid
),
8580 inf_data
->total_syscalls_count
!= 0,
8581 inf_data
->any_syscall_count
,
8583 inf_data
->syscalls_counts
),
8585 inf_data
->syscalls_counts
));
8588 /* Implement the "remove" breakpoint_ops method for syscall
8592 remove_catch_syscall (struct bp_location
*bl
)
8594 struct syscall_catchpoint
*c
= (struct syscall_catchpoint
*) bl
->owner
;
8595 struct inferior
*inf
= current_inferior ();
8596 struct catch_syscall_inferior_data
*inf_data
8597 = get_catch_syscall_inferior_data (inf
);
8599 --inf_data
->total_syscalls_count
;
8600 if (!c
->syscalls_to_be_caught
)
8601 --inf_data
->any_syscall_count
;
8607 VEC_iterate (int, c
->syscalls_to_be_caught
, i
, iter
);
8611 if (iter
>= VEC_length (int, inf_data
->syscalls_counts
))
8612 /* Shouldn't happen. */
8614 elem
= VEC_index (int, inf_data
->syscalls_counts
, iter
);
8615 VEC_replace (int, inf_data
->syscalls_counts
, iter
, --elem
);
8619 return target_set_syscall_catchpoint (ptid_get_pid (inferior_ptid
),
8620 inf_data
->total_syscalls_count
!= 0,
8621 inf_data
->any_syscall_count
,
8623 inf_data
->syscalls_counts
),
8625 inf_data
->syscalls_counts
));
8628 /* Implement the "breakpoint_hit" breakpoint_ops method for syscall
8632 breakpoint_hit_catch_syscall (const struct bp_location
*bl
,
8633 struct address_space
*aspace
, CORE_ADDR bp_addr
,
8634 const struct target_waitstatus
*ws
)
8636 /* We must check if we are catching specific syscalls in this
8637 breakpoint. If we are, then we must guarantee that the called
8638 syscall is the same syscall we are catching. */
8639 int syscall_number
= 0;
8640 const struct syscall_catchpoint
*c
8641 = (const struct syscall_catchpoint
*) bl
->owner
;
8643 if (ws
->kind
!= TARGET_WAITKIND_SYSCALL_ENTRY
8644 && ws
->kind
!= TARGET_WAITKIND_SYSCALL_RETURN
)
8647 syscall_number
= ws
->value
.syscall_number
;
8649 /* Now, checking if the syscall is the same. */
8650 if (c
->syscalls_to_be_caught
)
8655 VEC_iterate (int, c
->syscalls_to_be_caught
, i
, iter
);
8657 if (syscall_number
== iter
)
8666 /* Implement the "print_it" breakpoint_ops method for syscall
8669 static enum print_stop_action
8670 print_it_catch_syscall (bpstat bs
)
8672 struct ui_out
*uiout
= current_uiout
;
8673 struct breakpoint
*b
= bs
->breakpoint_at
;
8674 /* These are needed because we want to know in which state a
8675 syscall is. It can be in the TARGET_WAITKIND_SYSCALL_ENTRY
8676 or TARGET_WAITKIND_SYSCALL_RETURN, and depending on it we
8677 must print "called syscall" or "returned from syscall". */
8679 struct target_waitstatus last
;
8682 get_last_target_status (&ptid
, &last
);
8684 get_syscall_by_number (last
.value
.syscall_number
, &s
);
8686 annotate_catchpoint (b
->number
);
8688 if (b
->disposition
== disp_del
)
8689 ui_out_text (uiout
, "\nTemporary catchpoint ");
8691 ui_out_text (uiout
, "\nCatchpoint ");
8692 if (ui_out_is_mi_like_p (uiout
))
8694 ui_out_field_string (uiout
, "reason",
8695 async_reason_lookup (last
.kind
== TARGET_WAITKIND_SYSCALL_ENTRY
8696 ? EXEC_ASYNC_SYSCALL_ENTRY
8697 : EXEC_ASYNC_SYSCALL_RETURN
));
8698 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
8700 ui_out_field_int (uiout
, "bkptno", b
->number
);
8702 if (last
.kind
== TARGET_WAITKIND_SYSCALL_ENTRY
)
8703 ui_out_text (uiout
, " (call to syscall ");
8705 ui_out_text (uiout
, " (returned from syscall ");
8707 if (s
.name
== NULL
|| ui_out_is_mi_like_p (uiout
))
8708 ui_out_field_int (uiout
, "syscall-number", last
.value
.syscall_number
);
8710 ui_out_field_string (uiout
, "syscall-name", s
.name
);
8712 ui_out_text (uiout
, "), ");
8714 return PRINT_SRC_AND_LOC
;
8717 /* Implement the "print_one" breakpoint_ops method for syscall
8721 print_one_catch_syscall (struct breakpoint
*b
,
8722 struct bp_location
**last_loc
)
8724 struct syscall_catchpoint
*c
= (struct syscall_catchpoint
*) b
;
8725 struct value_print_options opts
;
8726 struct ui_out
*uiout
= current_uiout
;
8728 get_user_print_options (&opts
);
8729 /* Field 4, the address, is omitted (which makes the columns not
8730 line up too nicely with the headers, but the effect is relatively
8732 if (opts
.addressprint
)
8733 ui_out_field_skip (uiout
, "addr");
8736 if (c
->syscalls_to_be_caught
8737 && VEC_length (int, c
->syscalls_to_be_caught
) > 1)
8738 ui_out_text (uiout
, "syscalls \"");
8740 ui_out_text (uiout
, "syscall \"");
8742 if (c
->syscalls_to_be_caught
)
8745 char *text
= xstrprintf ("%s", "");
8748 VEC_iterate (int, c
->syscalls_to_be_caught
, i
, iter
);
8753 get_syscall_by_number (iter
, &s
);
8756 text
= xstrprintf ("%s%s, ", text
, s
.name
);
8758 text
= xstrprintf ("%s%d, ", text
, iter
);
8760 /* We have to xfree the last 'text' (now stored at 'x')
8761 because xstrprintf dynamically allocates new space for it
8765 /* Remove the last comma. */
8766 text
[strlen (text
) - 2] = '\0';
8767 ui_out_field_string (uiout
, "what", text
);
8770 ui_out_field_string (uiout
, "what", "<any syscall>");
8771 ui_out_text (uiout
, "\" ");
8773 if (ui_out_is_mi_like_p (uiout
))
8774 ui_out_field_string (uiout
, "catch-type", "syscall");
8777 /* Implement the "print_mention" breakpoint_ops method for syscall
8781 print_mention_catch_syscall (struct breakpoint
*b
)
8783 struct syscall_catchpoint
*c
= (struct syscall_catchpoint
*) b
;
8785 if (c
->syscalls_to_be_caught
)
8789 if (VEC_length (int, c
->syscalls_to_be_caught
) > 1)
8790 printf_filtered (_("Catchpoint %d (syscalls"), b
->number
);
8792 printf_filtered (_("Catchpoint %d (syscall"), b
->number
);
8795 VEC_iterate (int, c
->syscalls_to_be_caught
, i
, iter
);
8799 get_syscall_by_number (iter
, &s
);
8802 printf_filtered (" '%s' [%d]", s
.name
, s
.number
);
8804 printf_filtered (" %d", s
.number
);
8806 printf_filtered (")");
8809 printf_filtered (_("Catchpoint %d (any syscall)"),
8813 /* Implement the "print_recreate" breakpoint_ops method for syscall
8817 print_recreate_catch_syscall (struct breakpoint
*b
, struct ui_file
*fp
)
8819 struct syscall_catchpoint
*c
= (struct syscall_catchpoint
*) b
;
8821 fprintf_unfiltered (fp
, "catch syscall");
8823 if (c
->syscalls_to_be_caught
)
8828 VEC_iterate (int, c
->syscalls_to_be_caught
, i
, iter
);
8833 get_syscall_by_number (iter
, &s
);
8835 fprintf_unfiltered (fp
, " %s", s
.name
);
8837 fprintf_unfiltered (fp
, " %d", s
.number
);
8840 print_recreate_thread (b
, fp
);
8843 /* The breakpoint_ops structure to be used in syscall catchpoints. */
8845 static struct breakpoint_ops catch_syscall_breakpoint_ops
;
8847 /* Returns non-zero if 'b' is a syscall catchpoint. */
8850 syscall_catchpoint_p (struct breakpoint
*b
)
8852 return (b
->ops
== &catch_syscall_breakpoint_ops
);
8855 /* Initialize a new breakpoint of the bp_catchpoint kind. If TEMPFLAG
8856 is non-zero, then make the breakpoint temporary. If COND_STRING is
8857 not NULL, then store it in the breakpoint. OPS, if not NULL, is
8858 the breakpoint_ops structure associated to the catchpoint. */
8861 init_catchpoint (struct breakpoint
*b
,
8862 struct gdbarch
*gdbarch
, int tempflag
,
8864 const struct breakpoint_ops
*ops
)
8866 struct symtab_and_line sal
;
8869 sal
.pspace
= current_program_space
;
8871 init_raw_breakpoint (b
, gdbarch
, sal
, bp_catchpoint
, ops
);
8873 b
->cond_string
= (cond_string
== NULL
) ? NULL
: xstrdup (cond_string
);
8874 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
8878 install_breakpoint (int internal
, struct breakpoint
*b
, int update_gll
)
8880 add_to_breakpoint_chain (b
);
8881 set_breakpoint_number (internal
, b
);
8882 if (is_tracepoint (b
))
8883 set_tracepoint_count (breakpoint_count
);
8886 observer_notify_breakpoint_created (b
);
8889 update_global_location_list (UGLL_MAY_INSERT
);
8893 create_fork_vfork_event_catchpoint (struct gdbarch
*gdbarch
,
8894 int tempflag
, char *cond_string
,
8895 const struct breakpoint_ops
*ops
)
8897 struct fork_catchpoint
*c
= XNEW (struct fork_catchpoint
);
8899 init_catchpoint (&c
->base
, gdbarch
, tempflag
, cond_string
, ops
);
8901 c
->forked_inferior_pid
= null_ptid
;
8903 install_breakpoint (0, &c
->base
, 1);
8906 /* Exec catchpoints. */
8908 /* An instance of this type is used to represent an exec catchpoint.
8909 It includes a "struct breakpoint" as a kind of base class; users
8910 downcast to "struct breakpoint *" when needed. A breakpoint is
8911 really of this type iff its ops pointer points to
8912 CATCH_EXEC_BREAKPOINT_OPS. */
8914 struct exec_catchpoint
8916 /* The base class. */
8917 struct breakpoint base
;
8919 /* Filename of a program whose exec triggered this catchpoint.
8920 This field is only valid immediately after this catchpoint has
8922 char *exec_pathname
;
8925 /* Implement the "dtor" breakpoint_ops method for exec
8929 dtor_catch_exec (struct breakpoint
*b
)
8931 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
8933 xfree (c
->exec_pathname
);
8935 base_breakpoint_ops
.dtor (b
);
8939 insert_catch_exec (struct bp_location
*bl
)
8941 return target_insert_exec_catchpoint (ptid_get_pid (inferior_ptid
));
8945 remove_catch_exec (struct bp_location
*bl
)
8947 return target_remove_exec_catchpoint (ptid_get_pid (inferior_ptid
));
8951 breakpoint_hit_catch_exec (const struct bp_location
*bl
,
8952 struct address_space
*aspace
, CORE_ADDR bp_addr
,
8953 const struct target_waitstatus
*ws
)
8955 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) bl
->owner
;
8957 if (ws
->kind
!= TARGET_WAITKIND_EXECD
)
8960 c
->exec_pathname
= xstrdup (ws
->value
.execd_pathname
);
8964 static enum print_stop_action
8965 print_it_catch_exec (bpstat bs
)
8967 struct ui_out
*uiout
= current_uiout
;
8968 struct breakpoint
*b
= bs
->breakpoint_at
;
8969 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
8971 annotate_catchpoint (b
->number
);
8972 if (b
->disposition
== disp_del
)
8973 ui_out_text (uiout
, "\nTemporary catchpoint ");
8975 ui_out_text (uiout
, "\nCatchpoint ");
8976 if (ui_out_is_mi_like_p (uiout
))
8978 ui_out_field_string (uiout
, "reason",
8979 async_reason_lookup (EXEC_ASYNC_EXEC
));
8980 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
8982 ui_out_field_int (uiout
, "bkptno", b
->number
);
8983 ui_out_text (uiout
, " (exec'd ");
8984 ui_out_field_string (uiout
, "new-exec", c
->exec_pathname
);
8985 ui_out_text (uiout
, "), ");
8987 return PRINT_SRC_AND_LOC
;
8991 print_one_catch_exec (struct breakpoint
*b
, struct bp_location
**last_loc
)
8993 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
8994 struct value_print_options opts
;
8995 struct ui_out
*uiout
= current_uiout
;
8997 get_user_print_options (&opts
);
8999 /* Field 4, the address, is omitted (which makes the columns
9000 not line up too nicely with the headers, but the effect
9001 is relatively readable). */
9002 if (opts
.addressprint
)
9003 ui_out_field_skip (uiout
, "addr");
9005 ui_out_text (uiout
, "exec");
9006 if (c
->exec_pathname
!= NULL
)
9008 ui_out_text (uiout
, ", program \"");
9009 ui_out_field_string (uiout
, "what", c
->exec_pathname
);
9010 ui_out_text (uiout
, "\" ");
9013 if (ui_out_is_mi_like_p (uiout
))
9014 ui_out_field_string (uiout
, "catch-type", "exec");
9018 print_mention_catch_exec (struct breakpoint
*b
)
9020 printf_filtered (_("Catchpoint %d (exec)"), b
->number
);
9023 /* Implement the "print_recreate" breakpoint_ops method for exec
9027 print_recreate_catch_exec (struct breakpoint
*b
, struct ui_file
*fp
)
9029 fprintf_unfiltered (fp
, "catch exec");
9030 print_recreate_thread (b
, fp
);
9033 static struct breakpoint_ops catch_exec_breakpoint_ops
;
9036 create_syscall_event_catchpoint (int tempflag
, VEC(int) *filter
,
9037 const struct breakpoint_ops
*ops
)
9039 struct syscall_catchpoint
*c
;
9040 struct gdbarch
*gdbarch
= get_current_arch ();
9042 c
= XNEW (struct syscall_catchpoint
);
9043 init_catchpoint (&c
->base
, gdbarch
, tempflag
, NULL
, ops
);
9044 c
->syscalls_to_be_caught
= filter
;
9046 install_breakpoint (0, &c
->base
, 1);
9050 hw_breakpoint_used_count (void)
9053 struct breakpoint
*b
;
9054 struct bp_location
*bl
;
9058 if (b
->type
== bp_hardware_breakpoint
&& breakpoint_enabled (b
))
9059 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
9061 /* Special types of hardware breakpoints may use more than
9063 i
+= b
->ops
->resources_needed (bl
);
9070 /* Returns the resources B would use if it were a hardware
9074 hw_watchpoint_use_count (struct breakpoint
*b
)
9077 struct bp_location
*bl
;
9079 if (!breakpoint_enabled (b
))
9082 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
9084 /* Special types of hardware watchpoints may use more than
9086 i
+= b
->ops
->resources_needed (bl
);
9092 /* Returns the sum the used resources of all hardware watchpoints of
9093 type TYPE in the breakpoints list. Also returns in OTHER_TYPE_USED
9094 the sum of the used resources of all hardware watchpoints of other
9095 types _not_ TYPE. */
9098 hw_watchpoint_used_count_others (struct breakpoint
*except
,
9099 enum bptype type
, int *other_type_used
)
9102 struct breakpoint
*b
;
9104 *other_type_used
= 0;
9109 if (!breakpoint_enabled (b
))
9112 if (b
->type
== type
)
9113 i
+= hw_watchpoint_use_count (b
);
9114 else if (is_hardware_watchpoint (b
))
9115 *other_type_used
= 1;
9122 disable_watchpoints_before_interactive_call_start (void)
9124 struct breakpoint
*b
;
9128 if (is_watchpoint (b
) && breakpoint_enabled (b
))
9130 b
->enable_state
= bp_call_disabled
;
9131 update_global_location_list (UGLL_DONT_INSERT
);
9137 enable_watchpoints_after_interactive_call_stop (void)
9139 struct breakpoint
*b
;
9143 if (is_watchpoint (b
) && b
->enable_state
== bp_call_disabled
)
9145 b
->enable_state
= bp_enabled
;
9146 update_global_location_list (UGLL_MAY_INSERT
);
9152 disable_breakpoints_before_startup (void)
9154 current_program_space
->executing_startup
= 1;
9155 update_global_location_list (UGLL_DONT_INSERT
);
9159 enable_breakpoints_after_startup (void)
9161 current_program_space
->executing_startup
= 0;
9162 breakpoint_re_set ();
9165 /* Create a new single-step breakpoint for thread THREAD, with no
9168 static struct breakpoint
*
9169 new_single_step_breakpoint (int thread
, struct gdbarch
*gdbarch
)
9171 struct breakpoint
*b
= XNEW (struct breakpoint
);
9173 init_raw_breakpoint_without_location (b
, gdbarch
, bp_single_step
,
9174 &momentary_breakpoint_ops
);
9176 b
->disposition
= disp_donttouch
;
9177 b
->frame_id
= null_frame_id
;
9180 gdb_assert (b
->thread
!= 0);
9182 add_to_breakpoint_chain (b
);
9187 /* Set a momentary breakpoint of type TYPE at address specified by
9188 SAL. If FRAME_ID is valid, the breakpoint is restricted to that
9192 set_momentary_breakpoint (struct gdbarch
*gdbarch
, struct symtab_and_line sal
,
9193 struct frame_id frame_id
, enum bptype type
)
9195 struct breakpoint
*b
;
9197 /* If FRAME_ID is valid, it should be a real frame, not an inlined or
9199 gdb_assert (!frame_id_artificial_p (frame_id
));
9201 b
= set_raw_breakpoint (gdbarch
, sal
, type
, &momentary_breakpoint_ops
);
9202 b
->enable_state
= bp_enabled
;
9203 b
->disposition
= disp_donttouch
;
9204 b
->frame_id
= frame_id
;
9206 /* If we're debugging a multi-threaded program, then we want
9207 momentary breakpoints to be active in only a single thread of
9209 if (in_thread_list (inferior_ptid
))
9210 b
->thread
= pid_to_thread_id (inferior_ptid
);
9212 update_global_location_list_nothrow (UGLL_MAY_INSERT
);
9217 /* Make a momentary breakpoint based on the master breakpoint ORIG.
9218 The new breakpoint will have type TYPE, use OPS as its
9219 breakpoint_ops, and will set enabled to LOC_ENABLED. */
9221 static struct breakpoint
*
9222 momentary_breakpoint_from_master (struct breakpoint
*orig
,
9224 const struct breakpoint_ops
*ops
,
9227 struct breakpoint
*copy
;
9229 copy
= set_raw_breakpoint_without_location (orig
->gdbarch
, type
, ops
);
9230 copy
->loc
= allocate_bp_location (copy
);
9231 set_breakpoint_location_function (copy
->loc
, 1);
9233 copy
->loc
->gdbarch
= orig
->loc
->gdbarch
;
9234 copy
->loc
->requested_address
= orig
->loc
->requested_address
;
9235 copy
->loc
->address
= orig
->loc
->address
;
9236 copy
->loc
->section
= orig
->loc
->section
;
9237 copy
->loc
->pspace
= orig
->loc
->pspace
;
9238 copy
->loc
->probe
= orig
->loc
->probe
;
9239 copy
->loc
->line_number
= orig
->loc
->line_number
;
9240 copy
->loc
->symtab
= orig
->loc
->symtab
;
9241 copy
->loc
->enabled
= loc_enabled
;
9242 copy
->frame_id
= orig
->frame_id
;
9243 copy
->thread
= orig
->thread
;
9244 copy
->pspace
= orig
->pspace
;
9246 copy
->enable_state
= bp_enabled
;
9247 copy
->disposition
= disp_donttouch
;
9248 copy
->number
= internal_breakpoint_number
--;
9250 update_global_location_list_nothrow (UGLL_DONT_INSERT
);
9254 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
9258 clone_momentary_breakpoint (struct breakpoint
*orig
)
9260 /* If there's nothing to clone, then return nothing. */
9264 return momentary_breakpoint_from_master (orig
, orig
->type
, orig
->ops
, 0);
9268 set_momentary_breakpoint_at_pc (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
9271 struct symtab_and_line sal
;
9273 sal
= find_pc_line (pc
, 0);
9275 sal
.section
= find_pc_overlay (pc
);
9276 sal
.explicit_pc
= 1;
9278 return set_momentary_breakpoint (gdbarch
, sal
, null_frame_id
, type
);
9282 /* Tell the user we have just set a breakpoint B. */
9285 mention (struct breakpoint
*b
)
9287 b
->ops
->print_mention (b
);
9288 if (ui_out_is_mi_like_p (current_uiout
))
9290 printf_filtered ("\n");
9294 static struct bp_location
*
9295 add_location_to_breakpoint (struct breakpoint
*b
,
9296 const struct symtab_and_line
*sal
)
9298 struct bp_location
*loc
, **tmp
;
9299 CORE_ADDR adjusted_address
;
9300 struct gdbarch
*loc_gdbarch
= get_sal_arch (*sal
);
9302 if (loc_gdbarch
== NULL
)
9303 loc_gdbarch
= b
->gdbarch
;
9305 /* Adjust the breakpoint's address prior to allocating a location.
9306 Once we call allocate_bp_location(), that mostly uninitialized
9307 location will be placed on the location chain. Adjustment of the
9308 breakpoint may cause target_read_memory() to be called and we do
9309 not want its scan of the location chain to find a breakpoint and
9310 location that's only been partially initialized. */
9311 adjusted_address
= adjust_breakpoint_address (loc_gdbarch
,
9314 /* Sort the locations by their ADDRESS. */
9315 loc
= allocate_bp_location (b
);
9316 for (tmp
= &(b
->loc
); *tmp
!= NULL
&& (*tmp
)->address
<= adjusted_address
;
9317 tmp
= &((*tmp
)->next
))
9322 loc
->requested_address
= sal
->pc
;
9323 loc
->address
= adjusted_address
;
9324 loc
->pspace
= sal
->pspace
;
9325 loc
->probe
.probe
= sal
->probe
;
9326 loc
->probe
.objfile
= sal
->objfile
;
9327 gdb_assert (loc
->pspace
!= NULL
);
9328 loc
->section
= sal
->section
;
9329 loc
->gdbarch
= loc_gdbarch
;
9330 loc
->line_number
= sal
->line
;
9331 loc
->symtab
= sal
->symtab
;
9333 set_breakpoint_location_function (loc
,
9334 sal
->explicit_pc
|| sal
->explicit_line
);
9339 /* Return 1 if LOC is pointing to a permanent breakpoint,
9340 return 0 otherwise. */
9343 bp_loc_is_permanent (struct bp_location
*loc
)
9347 const gdb_byte
*bpoint
;
9348 gdb_byte
*target_mem
;
9349 struct cleanup
*cleanup
;
9352 gdb_assert (loc
!= NULL
);
9354 addr
= loc
->address
;
9355 bpoint
= gdbarch_breakpoint_from_pc (loc
->gdbarch
, &addr
, &len
);
9357 /* Software breakpoints unsupported? */
9361 target_mem
= alloca (len
);
9363 /* Enable the automatic memory restoration from breakpoints while
9364 we read the memory. Otherwise we could say about our temporary
9365 breakpoints they are permanent. */
9366 cleanup
= save_current_space_and_thread ();
9368 switch_to_program_space_and_thread (loc
->pspace
);
9369 make_show_memory_breakpoints_cleanup (0);
9371 if (target_read_memory (loc
->address
, target_mem
, len
) == 0
9372 && memcmp (target_mem
, bpoint
, len
) == 0)
9375 do_cleanups (cleanup
);
9380 /* Build a command list for the dprintf corresponding to the current
9381 settings of the dprintf style options. */
9384 update_dprintf_command_list (struct breakpoint
*b
)
9386 char *dprintf_args
= b
->extra_string
;
9387 char *printf_line
= NULL
;
9392 dprintf_args
= skip_spaces (dprintf_args
);
9394 /* Allow a comma, as it may have terminated a location, but don't
9396 if (*dprintf_args
== ',')
9398 dprintf_args
= skip_spaces (dprintf_args
);
9400 if (*dprintf_args
!= '"')
9401 error (_("Bad format string, missing '\"'."));
9403 if (strcmp (dprintf_style
, dprintf_style_gdb
) == 0)
9404 printf_line
= xstrprintf ("printf %s", dprintf_args
);
9405 else if (strcmp (dprintf_style
, dprintf_style_call
) == 0)
9407 if (!dprintf_function
)
9408 error (_("No function supplied for dprintf call"));
9410 if (dprintf_channel
&& strlen (dprintf_channel
) > 0)
9411 printf_line
= xstrprintf ("call (void) %s (%s,%s)",
9416 printf_line
= xstrprintf ("call (void) %s (%s)",
9420 else if (strcmp (dprintf_style
, dprintf_style_agent
) == 0)
9422 if (target_can_run_breakpoint_commands ())
9423 printf_line
= xstrprintf ("agent-printf %s", dprintf_args
);
9426 warning (_("Target cannot run dprintf commands, falling back to GDB printf"));
9427 printf_line
= xstrprintf ("printf %s", dprintf_args
);
9431 internal_error (__FILE__
, __LINE__
,
9432 _("Invalid dprintf style."));
9434 gdb_assert (printf_line
!= NULL
);
9435 /* Manufacture a printf sequence. */
9437 struct command_line
*printf_cmd_line
9438 = xmalloc (sizeof (struct command_line
));
9440 printf_cmd_line
= xmalloc (sizeof (struct command_line
));
9441 printf_cmd_line
->control_type
= simple_control
;
9442 printf_cmd_line
->body_count
= 0;
9443 printf_cmd_line
->body_list
= NULL
;
9444 printf_cmd_line
->next
= NULL
;
9445 printf_cmd_line
->line
= printf_line
;
9447 breakpoint_set_commands (b
, printf_cmd_line
);
9451 /* Update all dprintf commands, making their command lists reflect
9452 current style settings. */
9455 update_dprintf_commands (char *args
, int from_tty
,
9456 struct cmd_list_element
*c
)
9458 struct breakpoint
*b
;
9462 if (b
->type
== bp_dprintf
)
9463 update_dprintf_command_list (b
);
9467 /* Create a breakpoint with SAL as location. Use ADDR_STRING
9468 as textual description of the location, and COND_STRING
9469 as condition expression. */
9472 init_breakpoint_sal (struct breakpoint
*b
, struct gdbarch
*gdbarch
,
9473 struct symtabs_and_lines sals
, char *addr_string
,
9474 char *filter
, char *cond_string
,
9476 enum bptype type
, enum bpdisp disposition
,
9477 int thread
, int task
, int ignore_count
,
9478 const struct breakpoint_ops
*ops
, int from_tty
,
9479 int enabled
, int internal
, unsigned flags
,
9480 int display_canonical
)
9484 if (type
== bp_hardware_breakpoint
)
9486 int target_resources_ok
;
9488 i
= hw_breakpoint_used_count ();
9489 target_resources_ok
=
9490 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
9492 if (target_resources_ok
== 0)
9493 error (_("No hardware breakpoint support in the target."));
9494 else if (target_resources_ok
< 0)
9495 error (_("Hardware breakpoints used exceeds limit."));
9498 gdb_assert (sals
.nelts
> 0);
9500 for (i
= 0; i
< sals
.nelts
; ++i
)
9502 struct symtab_and_line sal
= sals
.sals
[i
];
9503 struct bp_location
*loc
;
9507 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
9509 loc_gdbarch
= gdbarch
;
9511 describe_other_breakpoints (loc_gdbarch
,
9512 sal
.pspace
, sal
.pc
, sal
.section
, thread
);
9517 init_raw_breakpoint (b
, gdbarch
, sal
, type
, ops
);
9521 b
->cond_string
= cond_string
;
9522 b
->extra_string
= extra_string
;
9523 b
->ignore_count
= ignore_count
;
9524 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
9525 b
->disposition
= disposition
;
9527 if ((flags
& CREATE_BREAKPOINT_FLAGS_INSERTED
) != 0)
9528 b
->loc
->inserted
= 1;
9530 if (type
== bp_static_tracepoint
)
9532 struct tracepoint
*t
= (struct tracepoint
*) b
;
9533 struct static_tracepoint_marker marker
;
9535 if (strace_marker_p (b
))
9537 /* We already know the marker exists, otherwise, we
9538 wouldn't see a sal for it. */
9539 char *p
= &addr_string
[3];
9543 p
= skip_spaces (p
);
9545 endp
= skip_to_space (p
);
9547 marker_str
= savestring (p
, endp
- p
);
9548 t
->static_trace_marker_id
= marker_str
;
9550 printf_filtered (_("Probed static tracepoint "
9552 t
->static_trace_marker_id
);
9554 else if (target_static_tracepoint_marker_at (sal
.pc
, &marker
))
9556 t
->static_trace_marker_id
= xstrdup (marker
.str_id
);
9557 release_static_tracepoint_marker (&marker
);
9559 printf_filtered (_("Probed static tracepoint "
9561 t
->static_trace_marker_id
);
9564 warning (_("Couldn't determine the static "
9565 "tracepoint marker to probe"));
9572 loc
= add_location_to_breakpoint (b
, &sal
);
9573 if ((flags
& CREATE_BREAKPOINT_FLAGS_INSERTED
) != 0)
9577 if (bp_loc_is_permanent (loc
))
9578 make_breakpoint_permanent (b
);
9582 const char *arg
= b
->cond_string
;
9584 loc
->cond
= parse_exp_1 (&arg
, loc
->address
,
9585 block_for_pc (loc
->address
), 0);
9587 error (_("Garbage '%s' follows condition"), arg
);
9590 /* Dynamic printf requires and uses additional arguments on the
9591 command line, otherwise it's an error. */
9592 if (type
== bp_dprintf
)
9594 if (b
->extra_string
)
9595 update_dprintf_command_list (b
);
9597 error (_("Format string required"));
9599 else if (b
->extra_string
)
9600 error (_("Garbage '%s' at end of command"), b
->extra_string
);
9603 b
->display_canonical
= display_canonical
;
9605 b
->addr_string
= addr_string
;
9607 /* addr_string has to be used or breakpoint_re_set will delete
9610 = xstrprintf ("*%s", paddress (b
->loc
->gdbarch
, b
->loc
->address
));
9615 create_breakpoint_sal (struct gdbarch
*gdbarch
,
9616 struct symtabs_and_lines sals
, char *addr_string
,
9617 char *filter
, char *cond_string
,
9619 enum bptype type
, enum bpdisp disposition
,
9620 int thread
, int task
, int ignore_count
,
9621 const struct breakpoint_ops
*ops
, int from_tty
,
9622 int enabled
, int internal
, unsigned flags
,
9623 int display_canonical
)
9625 struct breakpoint
*b
;
9626 struct cleanup
*old_chain
;
9628 if (is_tracepoint_type (type
))
9630 struct tracepoint
*t
;
9632 t
= XCNEW (struct tracepoint
);
9636 b
= XNEW (struct breakpoint
);
9638 old_chain
= make_cleanup (xfree
, b
);
9640 init_breakpoint_sal (b
, gdbarch
,
9642 filter
, cond_string
, extra_string
,
9644 thread
, task
, ignore_count
,
9646 enabled
, internal
, flags
,
9648 discard_cleanups (old_chain
);
9650 install_breakpoint (internal
, b
, 0);
9653 /* Add SALS.nelts breakpoints to the breakpoint table. For each
9654 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
9655 value. COND_STRING, if not NULL, specified the condition to be
9656 used for all breakpoints. Essentially the only case where
9657 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
9658 function. In that case, it's still not possible to specify
9659 separate conditions for different overloaded functions, so
9660 we take just a single condition string.
9662 NOTE: If the function succeeds, the caller is expected to cleanup
9663 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
9664 array contents). If the function fails (error() is called), the
9665 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
9666 COND and SALS arrays and each of those arrays contents. */
9669 create_breakpoints_sal (struct gdbarch
*gdbarch
,
9670 struct linespec_result
*canonical
,
9671 char *cond_string
, char *extra_string
,
9672 enum bptype type
, enum bpdisp disposition
,
9673 int thread
, int task
, int ignore_count
,
9674 const struct breakpoint_ops
*ops
, int from_tty
,
9675 int enabled
, int internal
, unsigned flags
)
9678 struct linespec_sals
*lsal
;
9680 if (canonical
->pre_expanded
)
9681 gdb_assert (VEC_length (linespec_sals
, canonical
->sals
) == 1);
9683 for (i
= 0; VEC_iterate (linespec_sals
, canonical
->sals
, i
, lsal
); ++i
)
9685 /* Note that 'addr_string' can be NULL in the case of a plain
9686 'break', without arguments. */
9687 char *addr_string
= (canonical
->addr_string
9688 ? xstrdup (canonical
->addr_string
)
9690 char *filter_string
= lsal
->canonical
? xstrdup (lsal
->canonical
) : NULL
;
9691 struct cleanup
*inner
= make_cleanup (xfree
, addr_string
);
9693 make_cleanup (xfree
, filter_string
);
9694 create_breakpoint_sal (gdbarch
, lsal
->sals
,
9697 cond_string
, extra_string
,
9699 thread
, task
, ignore_count
, ops
,
9700 from_tty
, enabled
, internal
, flags
,
9701 canonical
->special_display
);
9702 discard_cleanups (inner
);
9706 /* Parse ADDRESS which is assumed to be a SAL specification possibly
9707 followed by conditionals. On return, SALS contains an array of SAL
9708 addresses found. ADDR_STRING contains a vector of (canonical)
9709 address strings. ADDRESS points to the end of the SAL.
9711 The array and the line spec strings are allocated on the heap, it is
9712 the caller's responsibility to free them. */
9715 parse_breakpoint_sals (char **address
,
9716 struct linespec_result
*canonical
)
9718 /* If no arg given, or if first arg is 'if ', use the default
9720 if ((*address
) == NULL
9721 || (strncmp ((*address
), "if", 2) == 0 && isspace ((*address
)[2])))
9723 /* The last displayed codepoint, if it's valid, is our default breakpoint
9725 if (last_displayed_sal_is_valid ())
9727 struct linespec_sals lsal
;
9728 struct symtab_and_line sal
;
9731 init_sal (&sal
); /* Initialize to zeroes. */
9732 lsal
.sals
.sals
= (struct symtab_and_line
*)
9733 xmalloc (sizeof (struct symtab_and_line
));
9735 /* Set sal's pspace, pc, symtab, and line to the values
9736 corresponding to the last call to print_frame_info.
9737 Be sure to reinitialize LINE with NOTCURRENT == 0
9738 as the breakpoint line number is inappropriate otherwise.
9739 find_pc_line would adjust PC, re-set it back. */
9740 get_last_displayed_sal (&sal
);
9742 sal
= find_pc_line (pc
, 0);
9744 /* "break" without arguments is equivalent to "break *PC"
9745 where PC is the last displayed codepoint's address. So
9746 make sure to set sal.explicit_pc to prevent GDB from
9747 trying to expand the list of sals to include all other
9748 instances with the same symtab and line. */
9750 sal
.explicit_pc
= 1;
9752 lsal
.sals
.sals
[0] = sal
;
9753 lsal
.sals
.nelts
= 1;
9754 lsal
.canonical
= NULL
;
9756 VEC_safe_push (linespec_sals
, canonical
->sals
, &lsal
);
9759 error (_("No default breakpoint address now."));
9763 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
9765 /* Force almost all breakpoints to be in terms of the
9766 current_source_symtab (which is decode_line_1's default).
9767 This should produce the results we want almost all of the
9768 time while leaving default_breakpoint_* alone.
9770 ObjC: However, don't match an Objective-C method name which
9771 may have a '+' or '-' succeeded by a '['. */
9772 if (last_displayed_sal_is_valid ()
9774 || ((strchr ("+-", (*address
)[0]) != NULL
)
9775 && ((*address
)[1] != '['))))
9776 decode_line_full (address
, DECODE_LINE_FUNFIRSTLINE
,
9777 get_last_displayed_symtab (),
9778 get_last_displayed_line (),
9779 canonical
, NULL
, NULL
);
9781 decode_line_full (address
, DECODE_LINE_FUNFIRSTLINE
,
9782 cursal
.symtab
, cursal
.line
, canonical
, NULL
, NULL
);
9787 /* Convert each SAL into a real PC. Verify that the PC can be
9788 inserted as a breakpoint. If it can't throw an error. */
9791 breakpoint_sals_to_pc (struct symtabs_and_lines
*sals
)
9795 for (i
= 0; i
< sals
->nelts
; i
++)
9796 resolve_sal_pc (&sals
->sals
[i
]);
9799 /* Fast tracepoints may have restrictions on valid locations. For
9800 instance, a fast tracepoint using a jump instead of a trap will
9801 likely have to overwrite more bytes than a trap would, and so can
9802 only be placed where the instruction is longer than the jump, or a
9803 multi-instruction sequence does not have a jump into the middle of
9807 check_fast_tracepoint_sals (struct gdbarch
*gdbarch
,
9808 struct symtabs_and_lines
*sals
)
9811 struct symtab_and_line
*sal
;
9813 struct cleanup
*old_chain
;
9815 for (i
= 0; i
< sals
->nelts
; i
++)
9817 struct gdbarch
*sarch
;
9819 sal
= &sals
->sals
[i
];
9821 sarch
= get_sal_arch (*sal
);
9822 /* We fall back to GDBARCH if there is no architecture
9823 associated with SAL. */
9826 rslt
= gdbarch_fast_tracepoint_valid_at (sarch
, sal
->pc
,
9828 old_chain
= make_cleanup (xfree
, msg
);
9831 error (_("May not have a fast tracepoint at 0x%s%s"),
9832 paddress (sarch
, sal
->pc
), (msg
? msg
: ""));
9834 do_cleanups (old_chain
);
9838 /* Issue an invalid thread ID error. */
9840 static void ATTRIBUTE_NORETURN
9841 invalid_thread_id_error (int id
)
9843 error (_("Unknown thread %d."), id
);
9846 /* Given TOK, a string specification of condition and thread, as
9847 accepted by the 'break' command, extract the condition
9848 string and thread number and set *COND_STRING and *THREAD.
9849 PC identifies the context at which the condition should be parsed.
9850 If no condition is found, *COND_STRING is set to NULL.
9851 If no thread is found, *THREAD is set to -1. */
9854 find_condition_and_thread (const char *tok
, CORE_ADDR pc
,
9855 char **cond_string
, int *thread
, int *task
,
9858 *cond_string
= NULL
;
9865 const char *end_tok
;
9867 const char *cond_start
= NULL
;
9868 const char *cond_end
= NULL
;
9870 tok
= skip_spaces_const (tok
);
9872 if ((*tok
== '"' || *tok
== ',') && rest
)
9874 *rest
= savestring (tok
, strlen (tok
));
9878 end_tok
= skip_to_space_const (tok
);
9880 toklen
= end_tok
- tok
;
9882 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
9884 struct expression
*expr
;
9886 tok
= cond_start
= end_tok
+ 1;
9887 expr
= parse_exp_1 (&tok
, pc
, block_for_pc (pc
), 0);
9890 *cond_string
= savestring (cond_start
, cond_end
- cond_start
);
9892 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
9897 *thread
= strtol (tok
, &tmptok
, 0);
9899 error (_("Junk after thread keyword."));
9900 if (!valid_thread_id (*thread
))
9901 invalid_thread_id_error (*thread
);
9904 else if (toklen
>= 1 && strncmp (tok
, "task", toklen
) == 0)
9909 *task
= strtol (tok
, &tmptok
, 0);
9911 error (_("Junk after task keyword."));
9912 if (!valid_task_id (*task
))
9913 error (_("Unknown task %d."), *task
);
9918 *rest
= savestring (tok
, strlen (tok
));
9922 error (_("Junk at end of arguments."));
9926 /* Decode a static tracepoint marker spec. */
9928 static struct symtabs_and_lines
9929 decode_static_tracepoint_spec (char **arg_p
)
9931 VEC(static_tracepoint_marker_p
) *markers
= NULL
;
9932 struct symtabs_and_lines sals
;
9933 struct cleanup
*old_chain
;
9934 char *p
= &(*arg_p
)[3];
9939 p
= skip_spaces (p
);
9941 endp
= skip_to_space (p
);
9943 marker_str
= savestring (p
, endp
- p
);
9944 old_chain
= make_cleanup (xfree
, marker_str
);
9946 markers
= target_static_tracepoint_markers_by_strid (marker_str
);
9947 if (VEC_empty(static_tracepoint_marker_p
, markers
))
9948 error (_("No known static tracepoint marker named %s"), marker_str
);
9950 sals
.nelts
= VEC_length(static_tracepoint_marker_p
, markers
);
9951 sals
.sals
= xmalloc (sizeof *sals
.sals
* sals
.nelts
);
9953 for (i
= 0; i
< sals
.nelts
; i
++)
9955 struct static_tracepoint_marker
*marker
;
9957 marker
= VEC_index (static_tracepoint_marker_p
, markers
, i
);
9959 init_sal (&sals
.sals
[i
]);
9961 sals
.sals
[i
] = find_pc_line (marker
->address
, 0);
9962 sals
.sals
[i
].pc
= marker
->address
;
9964 release_static_tracepoint_marker (marker
);
9967 do_cleanups (old_chain
);
9973 /* Set a breakpoint. This function is shared between CLI and MI
9974 functions for setting a breakpoint. This function has two major
9975 modes of operations, selected by the PARSE_ARG parameter. If
9976 non-zero, the function will parse ARG, extracting location,
9977 condition, thread and extra string. Otherwise, ARG is just the
9978 breakpoint's location, with condition, thread, and extra string
9979 specified by the COND_STRING, THREAD and EXTRA_STRING parameters.
9980 If INTERNAL is non-zero, the breakpoint number will be allocated
9981 from the internal breakpoint count. Returns true if any breakpoint
9982 was created; false otherwise. */
9985 create_breakpoint (struct gdbarch
*gdbarch
,
9986 char *arg
, char *cond_string
,
9987 int thread
, char *extra_string
,
9989 int tempflag
, enum bptype type_wanted
,
9991 enum auto_boolean pending_break_support
,
9992 const struct breakpoint_ops
*ops
,
9993 int from_tty
, int enabled
, int internal
,
9996 volatile struct gdb_exception e
;
9997 char *copy_arg
= NULL
;
9998 char *addr_start
= arg
;
9999 struct linespec_result canonical
;
10000 struct cleanup
*old_chain
;
10001 struct cleanup
*bkpt_chain
= NULL
;
10004 int prev_bkpt_count
= breakpoint_count
;
10006 gdb_assert (ops
!= NULL
);
10008 init_linespec_result (&canonical
);
10010 TRY_CATCH (e
, RETURN_MASK_ALL
)
10012 ops
->create_sals_from_address (&arg
, &canonical
, type_wanted
,
10013 addr_start
, ©_arg
);
10016 /* If caller is interested in rc value from parse, set value. */
10020 if (VEC_empty (linespec_sals
, canonical
.sals
))
10026 case NOT_FOUND_ERROR
:
10028 /* If pending breakpoint support is turned off, throw
10031 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
10032 throw_exception (e
);
10034 exception_print (gdb_stderr
, e
);
10036 /* If pending breakpoint support is auto query and the user
10037 selects no, then simply return the error code. */
10038 if (pending_break_support
== AUTO_BOOLEAN_AUTO
10039 && !nquery (_("Make %s pending on future shared library load? "),
10040 bptype_string (type_wanted
)))
10043 /* At this point, either the user was queried about setting
10044 a pending breakpoint and selected yes, or pending
10045 breakpoint behavior is on and thus a pending breakpoint
10046 is defaulted on behalf of the user. */
10048 struct linespec_sals lsal
;
10050 copy_arg
= xstrdup (addr_start
);
10051 lsal
.canonical
= xstrdup (copy_arg
);
10052 lsal
.sals
.nelts
= 1;
10053 lsal
.sals
.sals
= XNEW (struct symtab_and_line
);
10054 init_sal (&lsal
.sals
.sals
[0]);
10056 VEC_safe_push (linespec_sals
, canonical
.sals
, &lsal
);
10060 throw_exception (e
);
10064 throw_exception (e
);
10067 /* Create a chain of things that always need to be cleaned up. */
10068 old_chain
= make_cleanup_destroy_linespec_result (&canonical
);
10070 /* ----------------------------- SNIP -----------------------------
10071 Anything added to the cleanup chain beyond this point is assumed
10072 to be part of a breakpoint. If the breakpoint create succeeds
10073 then the memory is not reclaimed. */
10074 bkpt_chain
= make_cleanup (null_cleanup
, 0);
10076 /* Resolve all line numbers to PC's and verify that the addresses
10077 are ok for the target. */
10081 struct linespec_sals
*iter
;
10083 for (ix
= 0; VEC_iterate (linespec_sals
, canonical
.sals
, ix
, iter
); ++ix
)
10084 breakpoint_sals_to_pc (&iter
->sals
);
10087 /* Fast tracepoints may have additional restrictions on location. */
10088 if (!pending
&& type_wanted
== bp_fast_tracepoint
)
10091 struct linespec_sals
*iter
;
10093 for (ix
= 0; VEC_iterate (linespec_sals
, canonical
.sals
, ix
, iter
); ++ix
)
10094 check_fast_tracepoint_sals (gdbarch
, &iter
->sals
);
10097 /* Verify that condition can be parsed, before setting any
10098 breakpoints. Allocate a separate condition expression for each
10105 struct linespec_sals
*lsal
;
10107 lsal
= VEC_index (linespec_sals
, canonical
.sals
, 0);
10109 /* Here we only parse 'arg' to separate condition
10110 from thread number, so parsing in context of first
10111 sal is OK. When setting the breakpoint we'll
10112 re-parse it in context of each sal. */
10114 find_condition_and_thread (arg
, lsal
->sals
.sals
[0].pc
, &cond_string
,
10115 &thread
, &task
, &rest
);
10117 make_cleanup (xfree
, cond_string
);
10119 make_cleanup (xfree
, rest
);
10121 extra_string
= rest
;
10126 error (_("Garbage '%s' at end of location"), arg
);
10128 /* Create a private copy of condition string. */
10131 cond_string
= xstrdup (cond_string
);
10132 make_cleanup (xfree
, cond_string
);
10134 /* Create a private copy of any extra string. */
10137 extra_string
= xstrdup (extra_string
);
10138 make_cleanup (xfree
, extra_string
);
10142 ops
->create_breakpoints_sal (gdbarch
, &canonical
,
10143 cond_string
, extra_string
, type_wanted
,
10144 tempflag
? disp_del
: disp_donttouch
,
10145 thread
, task
, ignore_count
, ops
,
10146 from_tty
, enabled
, internal
, flags
);
10150 struct breakpoint
*b
;
10152 make_cleanup (xfree
, copy_arg
);
10154 if (is_tracepoint_type (type_wanted
))
10156 struct tracepoint
*t
;
10158 t
= XCNEW (struct tracepoint
);
10162 b
= XNEW (struct breakpoint
);
10164 init_raw_breakpoint_without_location (b
, gdbarch
, type_wanted
, ops
);
10166 b
->addr_string
= copy_arg
;
10168 b
->cond_string
= NULL
;
10171 /* Create a private copy of condition string. */
10174 cond_string
= xstrdup (cond_string
);
10175 make_cleanup (xfree
, cond_string
);
10177 b
->cond_string
= cond_string
;
10179 b
->extra_string
= NULL
;
10180 b
->ignore_count
= ignore_count
;
10181 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
10182 b
->condition_not_parsed
= 1;
10183 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
10184 if ((type_wanted
!= bp_breakpoint
10185 && type_wanted
!= bp_hardware_breakpoint
) || thread
!= -1)
10186 b
->pspace
= current_program_space
;
10188 install_breakpoint (internal
, b
, 0);
10191 if (VEC_length (linespec_sals
, canonical
.sals
) > 1)
10193 warning (_("Multiple breakpoints were set.\nUse the "
10194 "\"delete\" command to delete unwanted breakpoints."));
10195 prev_breakpoint_count
= prev_bkpt_count
;
10198 /* That's it. Discard the cleanups for data inserted into the
10200 discard_cleanups (bkpt_chain
);
10201 /* But cleanup everything else. */
10202 do_cleanups (old_chain
);
10204 /* error call may happen here - have BKPT_CHAIN already discarded. */
10205 update_global_location_list (UGLL_MAY_INSERT
);
10210 /* Set a breakpoint.
10211 ARG is a string describing breakpoint address,
10212 condition, and thread.
10213 FLAG specifies if a breakpoint is hardware on,
10214 and if breakpoint is temporary, using BP_HARDWARE_FLAG
10215 and BP_TEMPFLAG. */
10218 break_command_1 (char *arg
, int flag
, int from_tty
)
10220 int tempflag
= flag
& BP_TEMPFLAG
;
10221 enum bptype type_wanted
= (flag
& BP_HARDWAREFLAG
10222 ? bp_hardware_breakpoint
10224 struct breakpoint_ops
*ops
;
10225 const char *arg_cp
= arg
;
10227 /* Matching breakpoints on probes. */
10228 if (arg
&& probe_linespec_to_ops (&arg_cp
) != NULL
)
10229 ops
= &bkpt_probe_breakpoint_ops
;
10231 ops
= &bkpt_breakpoint_ops
;
10233 create_breakpoint (get_current_arch (),
10235 NULL
, 0, NULL
, 1 /* parse arg */,
10236 tempflag
, type_wanted
,
10237 0 /* Ignore count */,
10238 pending_break_support
,
10246 /* Helper function for break_command_1 and disassemble_command. */
10249 resolve_sal_pc (struct symtab_and_line
*sal
)
10253 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
10255 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
10256 error (_("No line %d in file \"%s\"."),
10257 sal
->line
, symtab_to_filename_for_display (sal
->symtab
));
10260 /* If this SAL corresponds to a breakpoint inserted using a line
10261 number, then skip the function prologue if necessary. */
10262 if (sal
->explicit_line
)
10263 skip_prologue_sal (sal
);
10266 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
10268 const struct blockvector
*bv
;
10269 const struct block
*b
;
10270 struct symbol
*sym
;
10272 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
, sal
->symtab
);
10275 sym
= block_linkage_function (b
);
10278 fixup_symbol_section (sym
, sal
->symtab
->objfile
);
10279 sal
->section
= SYMBOL_OBJ_SECTION (sal
->symtab
->objfile
, sym
);
10283 /* It really is worthwhile to have the section, so we'll
10284 just have to look harder. This case can be executed
10285 if we have line numbers but no functions (as can
10286 happen in assembly source). */
10288 struct bound_minimal_symbol msym
;
10289 struct cleanup
*old_chain
= save_current_space_and_thread ();
10291 switch_to_program_space_and_thread (sal
->pspace
);
10293 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
10295 sal
->section
= MSYMBOL_OBJ_SECTION (msym
.objfile
, msym
.minsym
);
10297 do_cleanups (old_chain
);
10304 break_command (char *arg
, int from_tty
)
10306 break_command_1 (arg
, 0, from_tty
);
10310 tbreak_command (char *arg
, int from_tty
)
10312 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
10316 hbreak_command (char *arg
, int from_tty
)
10318 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
10322 thbreak_command (char *arg
, int from_tty
)
10324 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
10328 stop_command (char *arg
, int from_tty
)
10330 printf_filtered (_("Specify the type of breakpoint to set.\n\
10331 Usage: stop in <function | address>\n\
10332 stop at <line>\n"));
10336 stopin_command (char *arg
, int from_tty
)
10340 if (arg
== (char *) NULL
)
10342 else if (*arg
!= '*')
10344 char *argptr
= arg
;
10347 /* Look for a ':'. If this is a line number specification, then
10348 say it is bad, otherwise, it should be an address or
10349 function/method name. */
10350 while (*argptr
&& !hasColon
)
10352 hasColon
= (*argptr
== ':');
10357 badInput
= (*argptr
!= ':'); /* Not a class::method */
10359 badInput
= isdigit (*arg
); /* a simple line number */
10363 printf_filtered (_("Usage: stop in <function | address>\n"));
10365 break_command_1 (arg
, 0, from_tty
);
10369 stopat_command (char *arg
, int from_tty
)
10373 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
10377 char *argptr
= arg
;
10380 /* Look for a ':'. If there is a '::' then get out, otherwise
10381 it is probably a line number. */
10382 while (*argptr
&& !hasColon
)
10384 hasColon
= (*argptr
== ':');
10389 badInput
= (*argptr
== ':'); /* we have class::method */
10391 badInput
= !isdigit (*arg
); /* not a line number */
10395 printf_filtered (_("Usage: stop at <line>\n"));
10397 break_command_1 (arg
, 0, from_tty
);
10400 /* The dynamic printf command is mostly like a regular breakpoint, but
10401 with a prewired command list consisting of a single output command,
10402 built from extra arguments supplied on the dprintf command
10406 dprintf_command (char *arg
, int from_tty
)
10408 create_breakpoint (get_current_arch (),
10410 NULL
, 0, NULL
, 1 /* parse arg */,
10412 0 /* Ignore count */,
10413 pending_break_support
,
10414 &dprintf_breakpoint_ops
,
10422 agent_printf_command (char *arg
, int from_tty
)
10424 error (_("May only run agent-printf on the target"));
10427 /* Implement the "breakpoint_hit" breakpoint_ops method for
10428 ranged breakpoints. */
10431 breakpoint_hit_ranged_breakpoint (const struct bp_location
*bl
,
10432 struct address_space
*aspace
,
10434 const struct target_waitstatus
*ws
)
10436 if (ws
->kind
!= TARGET_WAITKIND_STOPPED
10437 || ws
->value
.sig
!= GDB_SIGNAL_TRAP
)
10440 return breakpoint_address_match_range (bl
->pspace
->aspace
, bl
->address
,
10441 bl
->length
, aspace
, bp_addr
);
10444 /* Implement the "resources_needed" breakpoint_ops method for
10445 ranged breakpoints. */
10448 resources_needed_ranged_breakpoint (const struct bp_location
*bl
)
10450 return target_ranged_break_num_registers ();
10453 /* Implement the "print_it" breakpoint_ops method for
10454 ranged breakpoints. */
10456 static enum print_stop_action
10457 print_it_ranged_breakpoint (bpstat bs
)
10459 struct breakpoint
*b
= bs
->breakpoint_at
;
10460 struct bp_location
*bl
= b
->loc
;
10461 struct ui_out
*uiout
= current_uiout
;
10463 gdb_assert (b
->type
== bp_hardware_breakpoint
);
10465 /* Ranged breakpoints have only one location. */
10466 gdb_assert (bl
&& bl
->next
== NULL
);
10468 annotate_breakpoint (b
->number
);
10469 if (b
->disposition
== disp_del
)
10470 ui_out_text (uiout
, "\nTemporary ranged breakpoint ");
10472 ui_out_text (uiout
, "\nRanged breakpoint ");
10473 if (ui_out_is_mi_like_p (uiout
))
10475 ui_out_field_string (uiout
, "reason",
10476 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
10477 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
10479 ui_out_field_int (uiout
, "bkptno", b
->number
);
10480 ui_out_text (uiout
, ", ");
10482 return PRINT_SRC_AND_LOC
;
10485 /* Implement the "print_one" breakpoint_ops method for
10486 ranged breakpoints. */
10489 print_one_ranged_breakpoint (struct breakpoint
*b
,
10490 struct bp_location
**last_loc
)
10492 struct bp_location
*bl
= b
->loc
;
10493 struct value_print_options opts
;
10494 struct ui_out
*uiout
= current_uiout
;
10496 /* Ranged breakpoints have only one location. */
10497 gdb_assert (bl
&& bl
->next
== NULL
);
10499 get_user_print_options (&opts
);
10501 if (opts
.addressprint
)
10502 /* We don't print the address range here, it will be printed later
10503 by print_one_detail_ranged_breakpoint. */
10504 ui_out_field_skip (uiout
, "addr");
10505 annotate_field (5);
10506 print_breakpoint_location (b
, bl
);
10510 /* Implement the "print_one_detail" breakpoint_ops method for
10511 ranged breakpoints. */
10514 print_one_detail_ranged_breakpoint (const struct breakpoint
*b
,
10515 struct ui_out
*uiout
)
10517 CORE_ADDR address_start
, address_end
;
10518 struct bp_location
*bl
= b
->loc
;
10519 struct ui_file
*stb
= mem_fileopen ();
10520 struct cleanup
*cleanup
= make_cleanup_ui_file_delete (stb
);
10524 address_start
= bl
->address
;
10525 address_end
= address_start
+ bl
->length
- 1;
10527 ui_out_text (uiout
, "\taddress range: ");
10528 fprintf_unfiltered (stb
, "[%s, %s]",
10529 print_core_address (bl
->gdbarch
, address_start
),
10530 print_core_address (bl
->gdbarch
, address_end
));
10531 ui_out_field_stream (uiout
, "addr", stb
);
10532 ui_out_text (uiout
, "\n");
10534 do_cleanups (cleanup
);
10537 /* Implement the "print_mention" breakpoint_ops method for
10538 ranged breakpoints. */
10541 print_mention_ranged_breakpoint (struct breakpoint
*b
)
10543 struct bp_location
*bl
= b
->loc
;
10544 struct ui_out
*uiout
= current_uiout
;
10547 gdb_assert (b
->type
== bp_hardware_breakpoint
);
10549 if (ui_out_is_mi_like_p (uiout
))
10552 printf_filtered (_("Hardware assisted ranged breakpoint %d from %s to %s."),
10553 b
->number
, paddress (bl
->gdbarch
, bl
->address
),
10554 paddress (bl
->gdbarch
, bl
->address
+ bl
->length
- 1));
10557 /* Implement the "print_recreate" breakpoint_ops method for
10558 ranged breakpoints. */
10561 print_recreate_ranged_breakpoint (struct breakpoint
*b
, struct ui_file
*fp
)
10563 fprintf_unfiltered (fp
, "break-range %s, %s", b
->addr_string
,
10564 b
->addr_string_range_end
);
10565 print_recreate_thread (b
, fp
);
10568 /* The breakpoint_ops structure to be used in ranged breakpoints. */
10570 static struct breakpoint_ops ranged_breakpoint_ops
;
10572 /* Find the address where the end of the breakpoint range should be
10573 placed, given the SAL of the end of the range. This is so that if
10574 the user provides a line number, the end of the range is set to the
10575 last instruction of the given line. */
10578 find_breakpoint_range_end (struct symtab_and_line sal
)
10582 /* If the user provided a PC value, use it. Otherwise,
10583 find the address of the end of the given location. */
10584 if (sal
.explicit_pc
)
10591 ret
= find_line_pc_range (sal
, &start
, &end
);
10593 error (_("Could not find location of the end of the range."));
10595 /* find_line_pc_range returns the start of the next line. */
10602 /* Implement the "break-range" CLI command. */
10605 break_range_command (char *arg
, int from_tty
)
10607 char *arg_start
, *addr_string_start
, *addr_string_end
;
10608 struct linespec_result canonical_start
, canonical_end
;
10609 int bp_count
, can_use_bp
, length
;
10611 struct breakpoint
*b
;
10612 struct symtab_and_line sal_start
, sal_end
;
10613 struct cleanup
*cleanup_bkpt
;
10614 struct linespec_sals
*lsal_start
, *lsal_end
;
10616 /* We don't support software ranged breakpoints. */
10617 if (target_ranged_break_num_registers () < 0)
10618 error (_("This target does not support hardware ranged breakpoints."));
10620 bp_count
= hw_breakpoint_used_count ();
10621 bp_count
+= target_ranged_break_num_registers ();
10622 can_use_bp
= target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
10624 if (can_use_bp
< 0)
10625 error (_("Hardware breakpoints used exceeds limit."));
10627 arg
= skip_spaces (arg
);
10628 if (arg
== NULL
|| arg
[0] == '\0')
10629 error(_("No address range specified."));
10631 init_linespec_result (&canonical_start
);
10634 parse_breakpoint_sals (&arg
, &canonical_start
);
10636 cleanup_bkpt
= make_cleanup_destroy_linespec_result (&canonical_start
);
10639 error (_("Too few arguments."));
10640 else if (VEC_empty (linespec_sals
, canonical_start
.sals
))
10641 error (_("Could not find location of the beginning of the range."));
10643 lsal_start
= VEC_index (linespec_sals
, canonical_start
.sals
, 0);
10645 if (VEC_length (linespec_sals
, canonical_start
.sals
) > 1
10646 || lsal_start
->sals
.nelts
!= 1)
10647 error (_("Cannot create a ranged breakpoint with multiple locations."));
10649 sal_start
= lsal_start
->sals
.sals
[0];
10650 addr_string_start
= savestring (arg_start
, arg
- arg_start
);
10651 make_cleanup (xfree
, addr_string_start
);
10653 arg
++; /* Skip the comma. */
10654 arg
= skip_spaces (arg
);
10656 /* Parse the end location. */
10658 init_linespec_result (&canonical_end
);
10661 /* We call decode_line_full directly here instead of using
10662 parse_breakpoint_sals because we need to specify the start location's
10663 symtab and line as the default symtab and line for the end of the
10664 range. This makes it possible to have ranges like "foo.c:27, +14",
10665 where +14 means 14 lines from the start location. */
10666 decode_line_full (&arg
, DECODE_LINE_FUNFIRSTLINE
,
10667 sal_start
.symtab
, sal_start
.line
,
10668 &canonical_end
, NULL
, NULL
);
10670 make_cleanup_destroy_linespec_result (&canonical_end
);
10672 if (VEC_empty (linespec_sals
, canonical_end
.sals
))
10673 error (_("Could not find location of the end of the range."));
10675 lsal_end
= VEC_index (linespec_sals
, canonical_end
.sals
, 0);
10676 if (VEC_length (linespec_sals
, canonical_end
.sals
) > 1
10677 || lsal_end
->sals
.nelts
!= 1)
10678 error (_("Cannot create a ranged breakpoint with multiple locations."));
10680 sal_end
= lsal_end
->sals
.sals
[0];
10681 addr_string_end
= savestring (arg_start
, arg
- arg_start
);
10682 make_cleanup (xfree
, addr_string_end
);
10684 end
= find_breakpoint_range_end (sal_end
);
10685 if (sal_start
.pc
> end
)
10686 error (_("Invalid address range, end precedes start."));
10688 length
= end
- sal_start
.pc
+ 1;
10690 /* Length overflowed. */
10691 error (_("Address range too large."));
10692 else if (length
== 1)
10694 /* This range is simple enough to be handled by
10695 the `hbreak' command. */
10696 hbreak_command (addr_string_start
, 1);
10698 do_cleanups (cleanup_bkpt
);
10703 /* Now set up the breakpoint. */
10704 b
= set_raw_breakpoint (get_current_arch (), sal_start
,
10705 bp_hardware_breakpoint
, &ranged_breakpoint_ops
);
10706 set_breakpoint_count (breakpoint_count
+ 1);
10707 b
->number
= breakpoint_count
;
10708 b
->disposition
= disp_donttouch
;
10709 b
->addr_string
= xstrdup (addr_string_start
);
10710 b
->addr_string_range_end
= xstrdup (addr_string_end
);
10711 b
->loc
->length
= length
;
10713 do_cleanups (cleanup_bkpt
);
10716 observer_notify_breakpoint_created (b
);
10717 update_global_location_list (UGLL_MAY_INSERT
);
10720 /* Return non-zero if EXP is verified as constant. Returned zero
10721 means EXP is variable. Also the constant detection may fail for
10722 some constant expressions and in such case still falsely return
10726 watchpoint_exp_is_const (const struct expression
*exp
)
10728 int i
= exp
->nelts
;
10734 /* We are only interested in the descriptor of each element. */
10735 operator_length (exp
, i
, &oplenp
, &argsp
);
10738 switch (exp
->elts
[i
].opcode
)
10748 case BINOP_LOGICAL_AND
:
10749 case BINOP_LOGICAL_OR
:
10750 case BINOP_BITWISE_AND
:
10751 case BINOP_BITWISE_IOR
:
10752 case BINOP_BITWISE_XOR
:
10754 case BINOP_NOTEQUAL
:
10781 case OP_OBJC_NSSTRING
:
10784 case UNOP_LOGICAL_NOT
:
10785 case UNOP_COMPLEMENT
:
10790 case UNOP_CAST_TYPE
:
10791 case UNOP_REINTERPRET_CAST
:
10792 case UNOP_DYNAMIC_CAST
:
10793 /* Unary, binary and ternary operators: We have to check
10794 their operands. If they are constant, then so is the
10795 result of that operation. For instance, if A and B are
10796 determined to be constants, then so is "A + B".
10798 UNOP_IND is one exception to the rule above, because the
10799 value of *ADDR is not necessarily a constant, even when
10804 /* Check whether the associated symbol is a constant.
10806 We use SYMBOL_CLASS rather than TYPE_CONST because it's
10807 possible that a buggy compiler could mark a variable as
10808 constant even when it is not, and TYPE_CONST would return
10809 true in this case, while SYMBOL_CLASS wouldn't.
10811 We also have to check for function symbols because they
10812 are always constant. */
10814 struct symbol
*s
= exp
->elts
[i
+ 2].symbol
;
10816 if (SYMBOL_CLASS (s
) != LOC_BLOCK
10817 && SYMBOL_CLASS (s
) != LOC_CONST
10818 && SYMBOL_CLASS (s
) != LOC_CONST_BYTES
)
10823 /* The default action is to return 0 because we are using
10824 the optimistic approach here: If we don't know something,
10825 then it is not a constant. */
10834 /* Implement the "dtor" breakpoint_ops method for watchpoints. */
10837 dtor_watchpoint (struct breakpoint
*self
)
10839 struct watchpoint
*w
= (struct watchpoint
*) self
;
10841 xfree (w
->cond_exp
);
10843 xfree (w
->exp_string
);
10844 xfree (w
->exp_string_reparse
);
10845 value_free (w
->val
);
10847 base_breakpoint_ops
.dtor (self
);
10850 /* Implement the "re_set" breakpoint_ops method for watchpoints. */
10853 re_set_watchpoint (struct breakpoint
*b
)
10855 struct watchpoint
*w
= (struct watchpoint
*) b
;
10857 /* Watchpoint can be either on expression using entirely global
10858 variables, or it can be on local variables.
10860 Watchpoints of the first kind are never auto-deleted, and even
10861 persist across program restarts. Since they can use variables
10862 from shared libraries, we need to reparse expression as libraries
10863 are loaded and unloaded.
10865 Watchpoints on local variables can also change meaning as result
10866 of solib event. For example, if a watchpoint uses both a local
10867 and a global variables in expression, it's a local watchpoint,
10868 but unloading of a shared library will make the expression
10869 invalid. This is not a very common use case, but we still
10870 re-evaluate expression, to avoid surprises to the user.
10872 Note that for local watchpoints, we re-evaluate it only if
10873 watchpoints frame id is still valid. If it's not, it means the
10874 watchpoint is out of scope and will be deleted soon. In fact,
10875 I'm not sure we'll ever be called in this case.
10877 If a local watchpoint's frame id is still valid, then
10878 w->exp_valid_block is likewise valid, and we can safely use it.
10880 Don't do anything about disabled watchpoints, since they will be
10881 reevaluated again when enabled. */
10882 update_watchpoint (w
, 1 /* reparse */);
10885 /* Implement the "insert" breakpoint_ops method for hardware watchpoints. */
10888 insert_watchpoint (struct bp_location
*bl
)
10890 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10891 int length
= w
->exact
? 1 : bl
->length
;
10893 return target_insert_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
10897 /* Implement the "remove" breakpoint_ops method for hardware watchpoints. */
10900 remove_watchpoint (struct bp_location
*bl
)
10902 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10903 int length
= w
->exact
? 1 : bl
->length
;
10905 return target_remove_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
10910 breakpoint_hit_watchpoint (const struct bp_location
*bl
,
10911 struct address_space
*aspace
, CORE_ADDR bp_addr
,
10912 const struct target_waitstatus
*ws
)
10914 struct breakpoint
*b
= bl
->owner
;
10915 struct watchpoint
*w
= (struct watchpoint
*) b
;
10917 /* Continuable hardware watchpoints are treated as non-existent if the
10918 reason we stopped wasn't a hardware watchpoint (we didn't stop on
10919 some data address). Otherwise gdb won't stop on a break instruction
10920 in the code (not from a breakpoint) when a hardware watchpoint has
10921 been defined. Also skip watchpoints which we know did not trigger
10922 (did not match the data address). */
10923 if (is_hardware_watchpoint (b
)
10924 && w
->watchpoint_triggered
== watch_triggered_no
)
10931 check_status_watchpoint (bpstat bs
)
10933 gdb_assert (is_watchpoint (bs
->breakpoint_at
));
10935 bpstat_check_watchpoint (bs
);
10938 /* Implement the "resources_needed" breakpoint_ops method for
10939 hardware watchpoints. */
10942 resources_needed_watchpoint (const struct bp_location
*bl
)
10944 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10945 int length
= w
->exact
? 1 : bl
->length
;
10947 return target_region_ok_for_hw_watchpoint (bl
->address
, length
);
10950 /* Implement the "works_in_software_mode" breakpoint_ops method for
10951 hardware watchpoints. */
10954 works_in_software_mode_watchpoint (const struct breakpoint
*b
)
10956 /* Read and access watchpoints only work with hardware support. */
10957 return b
->type
== bp_watchpoint
|| b
->type
== bp_hardware_watchpoint
;
10960 static enum print_stop_action
10961 print_it_watchpoint (bpstat bs
)
10963 struct cleanup
*old_chain
;
10964 struct breakpoint
*b
;
10965 struct ui_file
*stb
;
10966 enum print_stop_action result
;
10967 struct watchpoint
*w
;
10968 struct ui_out
*uiout
= current_uiout
;
10970 gdb_assert (bs
->bp_location_at
!= NULL
);
10972 b
= bs
->breakpoint_at
;
10973 w
= (struct watchpoint
*) b
;
10975 stb
= mem_fileopen ();
10976 old_chain
= make_cleanup_ui_file_delete (stb
);
10980 case bp_watchpoint
:
10981 case bp_hardware_watchpoint
:
10982 annotate_watchpoint (b
->number
);
10983 if (ui_out_is_mi_like_p (uiout
))
10984 ui_out_field_string
10986 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
10988 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
10989 ui_out_text (uiout
, "\nOld value = ");
10990 watchpoint_value_print (bs
->old_val
, stb
);
10991 ui_out_field_stream (uiout
, "old", stb
);
10992 ui_out_text (uiout
, "\nNew value = ");
10993 watchpoint_value_print (w
->val
, stb
);
10994 ui_out_field_stream (uiout
, "new", stb
);
10995 ui_out_text (uiout
, "\n");
10996 /* More than one watchpoint may have been triggered. */
10997 result
= PRINT_UNKNOWN
;
11000 case bp_read_watchpoint
:
11001 if (ui_out_is_mi_like_p (uiout
))
11002 ui_out_field_string
11004 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
11006 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
11007 ui_out_text (uiout
, "\nValue = ");
11008 watchpoint_value_print (w
->val
, stb
);
11009 ui_out_field_stream (uiout
, "value", stb
);
11010 ui_out_text (uiout
, "\n");
11011 result
= PRINT_UNKNOWN
;
11014 case bp_access_watchpoint
:
11015 if (bs
->old_val
!= NULL
)
11017 annotate_watchpoint (b
->number
);
11018 if (ui_out_is_mi_like_p (uiout
))
11019 ui_out_field_string
11021 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
11023 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
11024 ui_out_text (uiout
, "\nOld value = ");
11025 watchpoint_value_print (bs
->old_val
, stb
);
11026 ui_out_field_stream (uiout
, "old", stb
);
11027 ui_out_text (uiout
, "\nNew value = ");
11032 if (ui_out_is_mi_like_p (uiout
))
11033 ui_out_field_string
11035 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
11036 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
11037 ui_out_text (uiout
, "\nValue = ");
11039 watchpoint_value_print (w
->val
, stb
);
11040 ui_out_field_stream (uiout
, "new", stb
);
11041 ui_out_text (uiout
, "\n");
11042 result
= PRINT_UNKNOWN
;
11045 result
= PRINT_UNKNOWN
;
11048 do_cleanups (old_chain
);
11052 /* Implement the "print_mention" breakpoint_ops method for hardware
11056 print_mention_watchpoint (struct breakpoint
*b
)
11058 struct cleanup
*ui_out_chain
;
11059 struct watchpoint
*w
= (struct watchpoint
*) b
;
11060 struct ui_out
*uiout
= current_uiout
;
11064 case bp_watchpoint
:
11065 ui_out_text (uiout
, "Watchpoint ");
11066 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
11068 case bp_hardware_watchpoint
:
11069 ui_out_text (uiout
, "Hardware watchpoint ");
11070 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
11072 case bp_read_watchpoint
:
11073 ui_out_text (uiout
, "Hardware read watchpoint ");
11074 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
11076 case bp_access_watchpoint
:
11077 ui_out_text (uiout
, "Hardware access (read/write) watchpoint ");
11078 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
11081 internal_error (__FILE__
, __LINE__
,
11082 _("Invalid hardware watchpoint type."));
11085 ui_out_field_int (uiout
, "number", b
->number
);
11086 ui_out_text (uiout
, ": ");
11087 ui_out_field_string (uiout
, "exp", w
->exp_string
);
11088 do_cleanups (ui_out_chain
);
11091 /* Implement the "print_recreate" breakpoint_ops method for
11095 print_recreate_watchpoint (struct breakpoint
*b
, struct ui_file
*fp
)
11097 struct watchpoint
*w
= (struct watchpoint
*) b
;
11101 case bp_watchpoint
:
11102 case bp_hardware_watchpoint
:
11103 fprintf_unfiltered (fp
, "watch");
11105 case bp_read_watchpoint
:
11106 fprintf_unfiltered (fp
, "rwatch");
11108 case bp_access_watchpoint
:
11109 fprintf_unfiltered (fp
, "awatch");
11112 internal_error (__FILE__
, __LINE__
,
11113 _("Invalid watchpoint type."));
11116 fprintf_unfiltered (fp
, " %s", w
->exp_string
);
11117 print_recreate_thread (b
, fp
);
11120 /* Implement the "explains_signal" breakpoint_ops method for
11124 explains_signal_watchpoint (struct breakpoint
*b
, enum gdb_signal sig
)
11126 /* A software watchpoint cannot cause a signal other than
11127 GDB_SIGNAL_TRAP. */
11128 if (b
->type
== bp_watchpoint
&& sig
!= GDB_SIGNAL_TRAP
)
11134 /* The breakpoint_ops structure to be used in hardware watchpoints. */
11136 static struct breakpoint_ops watchpoint_breakpoint_ops
;
11138 /* Implement the "insert" breakpoint_ops method for
11139 masked hardware watchpoints. */
11142 insert_masked_watchpoint (struct bp_location
*bl
)
11144 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
11146 return target_insert_mask_watchpoint (bl
->address
, w
->hw_wp_mask
,
11147 bl
->watchpoint_type
);
11150 /* Implement the "remove" breakpoint_ops method for
11151 masked hardware watchpoints. */
11154 remove_masked_watchpoint (struct bp_location
*bl
)
11156 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
11158 return target_remove_mask_watchpoint (bl
->address
, w
->hw_wp_mask
,
11159 bl
->watchpoint_type
);
11162 /* Implement the "resources_needed" breakpoint_ops method for
11163 masked hardware watchpoints. */
11166 resources_needed_masked_watchpoint (const struct bp_location
*bl
)
11168 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
11170 return target_masked_watch_num_registers (bl
->address
, w
->hw_wp_mask
);
11173 /* Implement the "works_in_software_mode" breakpoint_ops method for
11174 masked hardware watchpoints. */
11177 works_in_software_mode_masked_watchpoint (const struct breakpoint
*b
)
11182 /* Implement the "print_it" breakpoint_ops method for
11183 masked hardware watchpoints. */
11185 static enum print_stop_action
11186 print_it_masked_watchpoint (bpstat bs
)
11188 struct breakpoint
*b
= bs
->breakpoint_at
;
11189 struct ui_out
*uiout
= current_uiout
;
11191 /* Masked watchpoints have only one location. */
11192 gdb_assert (b
->loc
&& b
->loc
->next
== NULL
);
11196 case bp_hardware_watchpoint
:
11197 annotate_watchpoint (b
->number
);
11198 if (ui_out_is_mi_like_p (uiout
))
11199 ui_out_field_string
11201 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
11204 case bp_read_watchpoint
:
11205 if (ui_out_is_mi_like_p (uiout
))
11206 ui_out_field_string
11208 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
11211 case bp_access_watchpoint
:
11212 if (ui_out_is_mi_like_p (uiout
))
11213 ui_out_field_string
11215 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
11218 internal_error (__FILE__
, __LINE__
,
11219 _("Invalid hardware watchpoint type."));
11223 ui_out_text (uiout
, _("\n\
11224 Check the underlying instruction at PC for the memory\n\
11225 address and value which triggered this watchpoint.\n"));
11226 ui_out_text (uiout
, "\n");
11228 /* More than one watchpoint may have been triggered. */
11229 return PRINT_UNKNOWN
;
11232 /* Implement the "print_one_detail" breakpoint_ops method for
11233 masked hardware watchpoints. */
11236 print_one_detail_masked_watchpoint (const struct breakpoint
*b
,
11237 struct ui_out
*uiout
)
11239 struct watchpoint
*w
= (struct watchpoint
*) b
;
11241 /* Masked watchpoints have only one location. */
11242 gdb_assert (b
->loc
&& b
->loc
->next
== NULL
);
11244 ui_out_text (uiout
, "\tmask ");
11245 ui_out_field_core_addr (uiout
, "mask", b
->loc
->gdbarch
, w
->hw_wp_mask
);
11246 ui_out_text (uiout
, "\n");
11249 /* Implement the "print_mention" breakpoint_ops method for
11250 masked hardware watchpoints. */
11253 print_mention_masked_watchpoint (struct breakpoint
*b
)
11255 struct watchpoint
*w
= (struct watchpoint
*) b
;
11256 struct ui_out
*uiout
= current_uiout
;
11257 struct cleanup
*ui_out_chain
;
11261 case bp_hardware_watchpoint
:
11262 ui_out_text (uiout
, "Masked hardware watchpoint ");
11263 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
11265 case bp_read_watchpoint
:
11266 ui_out_text (uiout
, "Masked hardware read watchpoint ");
11267 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
11269 case bp_access_watchpoint
:
11270 ui_out_text (uiout
, "Masked hardware access (read/write) watchpoint ");
11271 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
11274 internal_error (__FILE__
, __LINE__
,
11275 _("Invalid hardware watchpoint type."));
11278 ui_out_field_int (uiout
, "number", b
->number
);
11279 ui_out_text (uiout
, ": ");
11280 ui_out_field_string (uiout
, "exp", w
->exp_string
);
11281 do_cleanups (ui_out_chain
);
11284 /* Implement the "print_recreate" breakpoint_ops method for
11285 masked hardware watchpoints. */
11288 print_recreate_masked_watchpoint (struct breakpoint
*b
, struct ui_file
*fp
)
11290 struct watchpoint
*w
= (struct watchpoint
*) b
;
11295 case bp_hardware_watchpoint
:
11296 fprintf_unfiltered (fp
, "watch");
11298 case bp_read_watchpoint
:
11299 fprintf_unfiltered (fp
, "rwatch");
11301 case bp_access_watchpoint
:
11302 fprintf_unfiltered (fp
, "awatch");
11305 internal_error (__FILE__
, __LINE__
,
11306 _("Invalid hardware watchpoint type."));
11309 sprintf_vma (tmp
, w
->hw_wp_mask
);
11310 fprintf_unfiltered (fp
, " %s mask 0x%s", w
->exp_string
, tmp
);
11311 print_recreate_thread (b
, fp
);
11314 /* The breakpoint_ops structure to be used in masked hardware watchpoints. */
11316 static struct breakpoint_ops masked_watchpoint_breakpoint_ops
;
11318 /* Tell whether the given watchpoint is a masked hardware watchpoint. */
11321 is_masked_watchpoint (const struct breakpoint
*b
)
11323 return b
->ops
== &masked_watchpoint_breakpoint_ops
;
11326 /* accessflag: hw_write: watch write,
11327 hw_read: watch read,
11328 hw_access: watch access (read or write) */
11330 watch_command_1 (const char *arg
, int accessflag
, int from_tty
,
11331 int just_location
, int internal
)
11333 volatile struct gdb_exception e
;
11334 struct breakpoint
*b
, *scope_breakpoint
= NULL
;
11335 struct expression
*exp
;
11336 const struct block
*exp_valid_block
= NULL
, *cond_exp_valid_block
= NULL
;
11337 struct value
*val
, *mark
, *result
;
11338 int saved_bitpos
= 0, saved_bitsize
= 0;
11339 struct frame_info
*frame
;
11340 const char *exp_start
= NULL
;
11341 const char *exp_end
= NULL
;
11342 const char *tok
, *end_tok
;
11344 const char *cond_start
= NULL
;
11345 const char *cond_end
= NULL
;
11346 enum bptype bp_type
;
11349 /* Flag to indicate whether we are going to use masks for
11350 the hardware watchpoint. */
11352 CORE_ADDR mask
= 0;
11353 struct watchpoint
*w
;
11355 struct cleanup
*back_to
;
11357 /* Make sure that we actually have parameters to parse. */
11358 if (arg
!= NULL
&& arg
[0] != '\0')
11360 const char *value_start
;
11362 exp_end
= arg
+ strlen (arg
);
11364 /* Look for "parameter value" pairs at the end
11365 of the arguments string. */
11366 for (tok
= exp_end
- 1; tok
> arg
; tok
--)
11368 /* Skip whitespace at the end of the argument list. */
11369 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
11372 /* Find the beginning of the last token.
11373 This is the value of the parameter. */
11374 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
11376 value_start
= tok
+ 1;
11378 /* Skip whitespace. */
11379 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
11384 /* Find the beginning of the second to last token.
11385 This is the parameter itself. */
11386 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
11389 toklen
= end_tok
- tok
+ 1;
11391 if (toklen
== 6 && !strncmp (tok
, "thread", 6))
11393 /* At this point we've found a "thread" token, which means
11394 the user is trying to set a watchpoint that triggers
11395 only in a specific thread. */
11399 error(_("You can specify only one thread."));
11401 /* Extract the thread ID from the next token. */
11402 thread
= strtol (value_start
, &endp
, 0);
11404 /* Check if the user provided a valid numeric value for the
11406 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
11407 error (_("Invalid thread ID specification %s."), value_start
);
11409 /* Check if the thread actually exists. */
11410 if (!valid_thread_id (thread
))
11411 invalid_thread_id_error (thread
);
11413 else if (toklen
== 4 && !strncmp (tok
, "mask", 4))
11415 /* We've found a "mask" token, which means the user wants to
11416 create a hardware watchpoint that is going to have the mask
11418 struct value
*mask_value
, *mark
;
11421 error(_("You can specify only one mask."));
11423 use_mask
= just_location
= 1;
11425 mark
= value_mark ();
11426 mask_value
= parse_to_comma_and_eval (&value_start
);
11427 mask
= value_as_address (mask_value
);
11428 value_free_to_mark (mark
);
11431 /* We didn't recognize what we found. We should stop here. */
11434 /* Truncate the string and get rid of the "parameter value" pair before
11435 the arguments string is parsed by the parse_exp_1 function. */
11442 /* Parse the rest of the arguments. From here on out, everything
11443 is in terms of a newly allocated string instead of the original
11445 innermost_block
= NULL
;
11446 expression
= savestring (arg
, exp_end
- arg
);
11447 back_to
= make_cleanup (xfree
, expression
);
11448 exp_start
= arg
= expression
;
11449 exp
= parse_exp_1 (&arg
, 0, 0, 0);
11451 /* Remove trailing whitespace from the expression before saving it.
11452 This makes the eventual display of the expression string a bit
11454 while (exp_end
> exp_start
&& (exp_end
[-1] == ' ' || exp_end
[-1] == '\t'))
11457 /* Checking if the expression is not constant. */
11458 if (watchpoint_exp_is_const (exp
))
11462 len
= exp_end
- exp_start
;
11463 while (len
> 0 && isspace (exp_start
[len
- 1]))
11465 error (_("Cannot watch constant value `%.*s'."), len
, exp_start
);
11468 exp_valid_block
= innermost_block
;
11469 mark
= value_mark ();
11470 fetch_subexp_value (exp
, &pc
, &val
, &result
, NULL
, just_location
);
11472 if (val
!= NULL
&& just_location
)
11474 saved_bitpos
= value_bitpos (val
);
11475 saved_bitsize
= value_bitsize (val
);
11482 exp_valid_block
= NULL
;
11483 val
= value_addr (result
);
11484 release_value (val
);
11485 value_free_to_mark (mark
);
11489 ret
= target_masked_watch_num_registers (value_as_address (val
),
11492 error (_("This target does not support masked watchpoints."));
11493 else if (ret
== -2)
11494 error (_("Invalid mask or memory region."));
11497 else if (val
!= NULL
)
11498 release_value (val
);
11500 tok
= skip_spaces_const (arg
);
11501 end_tok
= skip_to_space_const (tok
);
11503 toklen
= end_tok
- tok
;
11504 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
11506 struct expression
*cond
;
11508 innermost_block
= NULL
;
11509 tok
= cond_start
= end_tok
+ 1;
11510 cond
= parse_exp_1 (&tok
, 0, 0, 0);
11512 /* The watchpoint expression may not be local, but the condition
11513 may still be. E.g.: `watch global if local > 0'. */
11514 cond_exp_valid_block
= innermost_block
;
11520 error (_("Junk at end of command."));
11522 frame
= block_innermost_frame (exp_valid_block
);
11524 /* If the expression is "local", then set up a "watchpoint scope"
11525 breakpoint at the point where we've left the scope of the watchpoint
11526 expression. Create the scope breakpoint before the watchpoint, so
11527 that we will encounter it first in bpstat_stop_status. */
11528 if (exp_valid_block
&& frame
)
11530 if (frame_id_p (frame_unwind_caller_id (frame
)))
11533 = create_internal_breakpoint (frame_unwind_caller_arch (frame
),
11534 frame_unwind_caller_pc (frame
),
11535 bp_watchpoint_scope
,
11536 &momentary_breakpoint_ops
);
11538 scope_breakpoint
->enable_state
= bp_enabled
;
11540 /* Automatically delete the breakpoint when it hits. */
11541 scope_breakpoint
->disposition
= disp_del
;
11543 /* Only break in the proper frame (help with recursion). */
11544 scope_breakpoint
->frame_id
= frame_unwind_caller_id (frame
);
11546 /* Set the address at which we will stop. */
11547 scope_breakpoint
->loc
->gdbarch
11548 = frame_unwind_caller_arch (frame
);
11549 scope_breakpoint
->loc
->requested_address
11550 = frame_unwind_caller_pc (frame
);
11551 scope_breakpoint
->loc
->address
11552 = adjust_breakpoint_address (scope_breakpoint
->loc
->gdbarch
,
11553 scope_breakpoint
->loc
->requested_address
,
11554 scope_breakpoint
->type
);
11558 /* Now set up the breakpoint. We create all watchpoints as hardware
11559 watchpoints here even if hardware watchpoints are turned off, a call
11560 to update_watchpoint later in this function will cause the type to
11561 drop back to bp_watchpoint (software watchpoint) if required. */
11563 if (accessflag
== hw_read
)
11564 bp_type
= bp_read_watchpoint
;
11565 else if (accessflag
== hw_access
)
11566 bp_type
= bp_access_watchpoint
;
11568 bp_type
= bp_hardware_watchpoint
;
11570 w
= XCNEW (struct watchpoint
);
11573 init_raw_breakpoint_without_location (b
, NULL
, bp_type
,
11574 &masked_watchpoint_breakpoint_ops
);
11576 init_raw_breakpoint_without_location (b
, NULL
, bp_type
,
11577 &watchpoint_breakpoint_ops
);
11578 b
->thread
= thread
;
11579 b
->disposition
= disp_donttouch
;
11580 b
->pspace
= current_program_space
;
11582 w
->exp_valid_block
= exp_valid_block
;
11583 w
->cond_exp_valid_block
= cond_exp_valid_block
;
11586 struct type
*t
= value_type (val
);
11587 CORE_ADDR addr
= value_as_address (val
);
11590 t
= check_typedef (TYPE_TARGET_TYPE (check_typedef (t
)));
11591 name
= type_to_string (t
);
11593 w
->exp_string_reparse
= xstrprintf ("* (%s *) %s", name
,
11594 core_addr_to_string (addr
));
11597 w
->exp_string
= xstrprintf ("-location %.*s",
11598 (int) (exp_end
- exp_start
), exp_start
);
11600 /* The above expression is in C. */
11601 b
->language
= language_c
;
11604 w
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
11608 w
->hw_wp_mask
= mask
;
11613 w
->val_bitpos
= saved_bitpos
;
11614 w
->val_bitsize
= saved_bitsize
;
11619 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
11621 b
->cond_string
= 0;
11625 w
->watchpoint_frame
= get_frame_id (frame
);
11626 w
->watchpoint_thread
= inferior_ptid
;
11630 w
->watchpoint_frame
= null_frame_id
;
11631 w
->watchpoint_thread
= null_ptid
;
11634 if (scope_breakpoint
!= NULL
)
11636 /* The scope breakpoint is related to the watchpoint. We will
11637 need to act on them together. */
11638 b
->related_breakpoint
= scope_breakpoint
;
11639 scope_breakpoint
->related_breakpoint
= b
;
11642 if (!just_location
)
11643 value_free_to_mark (mark
);
11645 TRY_CATCH (e
, RETURN_MASK_ALL
)
11647 /* Finally update the new watchpoint. This creates the locations
11648 that should be inserted. */
11649 update_watchpoint (w
, 1);
11653 delete_breakpoint (b
);
11654 throw_exception (e
);
11657 install_breakpoint (internal
, b
, 1);
11658 do_cleanups (back_to
);
11661 /* Return count of debug registers needed to watch the given expression.
11662 If the watchpoint cannot be handled in hardware return zero. */
11665 can_use_hardware_watchpoint (struct value
*v
)
11667 int found_memory_cnt
= 0;
11668 struct value
*head
= v
;
11670 /* Did the user specifically forbid us to use hardware watchpoints? */
11671 if (!can_use_hw_watchpoints
)
11674 /* Make sure that the value of the expression depends only upon
11675 memory contents, and values computed from them within GDB. If we
11676 find any register references or function calls, we can't use a
11677 hardware watchpoint.
11679 The idea here is that evaluating an expression generates a series
11680 of values, one holding the value of every subexpression. (The
11681 expression a*b+c has five subexpressions: a, b, a*b, c, and
11682 a*b+c.) GDB's values hold almost enough information to establish
11683 the criteria given above --- they identify memory lvalues,
11684 register lvalues, computed values, etcetera. So we can evaluate
11685 the expression, and then scan the chain of values that leaves
11686 behind to decide whether we can detect any possible change to the
11687 expression's final value using only hardware watchpoints.
11689 However, I don't think that the values returned by inferior
11690 function calls are special in any way. So this function may not
11691 notice that an expression involving an inferior function call
11692 can't be watched with hardware watchpoints. FIXME. */
11693 for (; v
; v
= value_next (v
))
11695 if (VALUE_LVAL (v
) == lval_memory
)
11697 if (v
!= head
&& value_lazy (v
))
11698 /* A lazy memory lvalue in the chain is one that GDB never
11699 needed to fetch; we either just used its address (e.g.,
11700 `a' in `a.b') or we never needed it at all (e.g., `a'
11701 in `a,b'). This doesn't apply to HEAD; if that is
11702 lazy then it was not readable, but watch it anyway. */
11706 /* Ahh, memory we actually used! Check if we can cover
11707 it with hardware watchpoints. */
11708 struct type
*vtype
= check_typedef (value_type (v
));
11710 /* We only watch structs and arrays if user asked for it
11711 explicitly, never if they just happen to appear in a
11712 middle of some value chain. */
11714 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
11715 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
11717 CORE_ADDR vaddr
= value_address (v
);
11721 len
= (target_exact_watchpoints
11722 && is_scalar_type_recursive (vtype
))?
11723 1 : TYPE_LENGTH (value_type (v
));
11725 num_regs
= target_region_ok_for_hw_watchpoint (vaddr
, len
);
11729 found_memory_cnt
+= num_regs
;
11733 else if (VALUE_LVAL (v
) != not_lval
11734 && deprecated_value_modifiable (v
) == 0)
11735 return 0; /* These are values from the history (e.g., $1). */
11736 else if (VALUE_LVAL (v
) == lval_register
)
11737 return 0; /* Cannot watch a register with a HW watchpoint. */
11740 /* The expression itself looks suitable for using a hardware
11741 watchpoint, but give the target machine a chance to reject it. */
11742 return found_memory_cnt
;
11746 watch_command_wrapper (char *arg
, int from_tty
, int internal
)
11748 watch_command_1 (arg
, hw_write
, from_tty
, 0, internal
);
11751 /* A helper function that looks for the "-location" argument and then
11752 calls watch_command_1. */
11755 watch_maybe_just_location (char *arg
, int accessflag
, int from_tty
)
11757 int just_location
= 0;
11760 && (check_for_argument (&arg
, "-location", sizeof ("-location") - 1)
11761 || check_for_argument (&arg
, "-l", sizeof ("-l") - 1)))
11763 arg
= skip_spaces (arg
);
11767 watch_command_1 (arg
, accessflag
, from_tty
, just_location
, 0);
11771 watch_command (char *arg
, int from_tty
)
11773 watch_maybe_just_location (arg
, hw_write
, from_tty
);
11777 rwatch_command_wrapper (char *arg
, int from_tty
, int internal
)
11779 watch_command_1 (arg
, hw_read
, from_tty
, 0, internal
);
11783 rwatch_command (char *arg
, int from_tty
)
11785 watch_maybe_just_location (arg
, hw_read
, from_tty
);
11789 awatch_command_wrapper (char *arg
, int from_tty
, int internal
)
11791 watch_command_1 (arg
, hw_access
, from_tty
, 0, internal
);
11795 awatch_command (char *arg
, int from_tty
)
11797 watch_maybe_just_location (arg
, hw_access
, from_tty
);
11801 /* Helper routines for the until_command routine in infcmd.c. Here
11802 because it uses the mechanisms of breakpoints. */
11804 struct until_break_command_continuation_args
11806 struct breakpoint
*breakpoint
;
11807 struct breakpoint
*breakpoint2
;
11811 /* This function is called by fetch_inferior_event via the
11812 cmd_continuation pointer, to complete the until command. It takes
11813 care of cleaning up the temporary breakpoints set up by the until
11816 until_break_command_continuation (void *arg
, int err
)
11818 struct until_break_command_continuation_args
*a
= arg
;
11820 delete_breakpoint (a
->breakpoint
);
11821 if (a
->breakpoint2
)
11822 delete_breakpoint (a
->breakpoint2
);
11823 delete_longjmp_breakpoint (a
->thread_num
);
11827 until_break_command (char *arg
, int from_tty
, int anywhere
)
11829 struct symtabs_and_lines sals
;
11830 struct symtab_and_line sal
;
11831 struct frame_info
*frame
;
11832 struct gdbarch
*frame_gdbarch
;
11833 struct frame_id stack_frame_id
;
11834 struct frame_id caller_frame_id
;
11835 struct breakpoint
*breakpoint
;
11836 struct breakpoint
*breakpoint2
= NULL
;
11837 struct cleanup
*old_chain
;
11839 struct thread_info
*tp
;
11841 clear_proceed_status (0);
11843 /* Set a breakpoint where the user wants it and at return from
11846 if (last_displayed_sal_is_valid ())
11847 sals
= decode_line_1 (&arg
, DECODE_LINE_FUNFIRSTLINE
,
11848 get_last_displayed_symtab (),
11849 get_last_displayed_line ());
11851 sals
= decode_line_1 (&arg
, DECODE_LINE_FUNFIRSTLINE
,
11852 (struct symtab
*) NULL
, 0);
11854 if (sals
.nelts
!= 1)
11855 error (_("Couldn't get information on specified line."));
11857 sal
= sals
.sals
[0];
11858 xfree (sals
.sals
); /* malloc'd, so freed. */
11861 error (_("Junk at end of arguments."));
11863 resolve_sal_pc (&sal
);
11865 tp
= inferior_thread ();
11868 old_chain
= make_cleanup (null_cleanup
, NULL
);
11870 /* Note linespec handling above invalidates the frame chain.
11871 Installing a breakpoint also invalidates the frame chain (as it
11872 may need to switch threads), so do any frame handling before
11875 frame
= get_selected_frame (NULL
);
11876 frame_gdbarch
= get_frame_arch (frame
);
11877 stack_frame_id
= get_stack_frame_id (frame
);
11878 caller_frame_id
= frame_unwind_caller_id (frame
);
11880 /* Keep within the current frame, or in frames called by the current
11883 if (frame_id_p (caller_frame_id
))
11885 struct symtab_and_line sal2
;
11887 sal2
= find_pc_line (frame_unwind_caller_pc (frame
), 0);
11888 sal2
.pc
= frame_unwind_caller_pc (frame
);
11889 breakpoint2
= set_momentary_breakpoint (frame_unwind_caller_arch (frame
),
11893 make_cleanup_delete_breakpoint (breakpoint2
);
11895 set_longjmp_breakpoint (tp
, caller_frame_id
);
11896 make_cleanup (delete_longjmp_breakpoint_cleanup
, &thread
);
11899 /* set_momentary_breakpoint could invalidate FRAME. */
11903 /* If the user told us to continue until a specified location,
11904 we don't specify a frame at which we need to stop. */
11905 breakpoint
= set_momentary_breakpoint (frame_gdbarch
, sal
,
11906 null_frame_id
, bp_until
);
11908 /* Otherwise, specify the selected frame, because we want to stop
11909 only at the very same frame. */
11910 breakpoint
= set_momentary_breakpoint (frame_gdbarch
, sal
,
11911 stack_frame_id
, bp_until
);
11912 make_cleanup_delete_breakpoint (breakpoint
);
11914 proceed (-1, GDB_SIGNAL_DEFAULT
, 0);
11916 /* If we are running asynchronously, and proceed call above has
11917 actually managed to start the target, arrange for breakpoints to
11918 be deleted when the target stops. Otherwise, we're already
11919 stopped and delete breakpoints via cleanup chain. */
11921 if (target_can_async_p () && is_running (inferior_ptid
))
11923 struct until_break_command_continuation_args
*args
;
11924 args
= xmalloc (sizeof (*args
));
11926 args
->breakpoint
= breakpoint
;
11927 args
->breakpoint2
= breakpoint2
;
11928 args
->thread_num
= thread
;
11930 discard_cleanups (old_chain
);
11931 add_continuation (inferior_thread (),
11932 until_break_command_continuation
, args
,
11936 do_cleanups (old_chain
);
11939 /* This function attempts to parse an optional "if <cond>" clause
11940 from the arg string. If one is not found, it returns NULL.
11942 Else, it returns a pointer to the condition string. (It does not
11943 attempt to evaluate the string against a particular block.) And,
11944 it updates arg to point to the first character following the parsed
11945 if clause in the arg string. */
11948 ep_parse_optional_if_clause (char **arg
)
11952 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
11955 /* Skip the "if" keyword. */
11958 /* Skip any extra leading whitespace, and record the start of the
11959 condition string. */
11960 *arg
= skip_spaces (*arg
);
11961 cond_string
= *arg
;
11963 /* Assume that the condition occupies the remainder of the arg
11965 (*arg
) += strlen (cond_string
);
11967 return cond_string
;
11970 /* Commands to deal with catching events, such as signals, exceptions,
11971 process start/exit, etc. */
11975 catch_fork_temporary
, catch_vfork_temporary
,
11976 catch_fork_permanent
, catch_vfork_permanent
11981 catch_fork_command_1 (char *arg
, int from_tty
,
11982 struct cmd_list_element
*command
)
11984 struct gdbarch
*gdbarch
= get_current_arch ();
11985 char *cond_string
= NULL
;
11986 catch_fork_kind fork_kind
;
11989 fork_kind
= (catch_fork_kind
) (uintptr_t) get_cmd_context (command
);
11990 tempflag
= (fork_kind
== catch_fork_temporary
11991 || fork_kind
== catch_vfork_temporary
);
11995 arg
= skip_spaces (arg
);
11997 /* The allowed syntax is:
11999 catch [v]fork if <cond>
12001 First, check if there's an if clause. */
12002 cond_string
= ep_parse_optional_if_clause (&arg
);
12004 if ((*arg
!= '\0') && !isspace (*arg
))
12005 error (_("Junk at end of arguments."));
12007 /* If this target supports it, create a fork or vfork catchpoint
12008 and enable reporting of such events. */
12011 case catch_fork_temporary
:
12012 case catch_fork_permanent
:
12013 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
12014 &catch_fork_breakpoint_ops
);
12016 case catch_vfork_temporary
:
12017 case catch_vfork_permanent
:
12018 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
12019 &catch_vfork_breakpoint_ops
);
12022 error (_("unsupported or unknown fork kind; cannot catch it"));
12028 catch_exec_command_1 (char *arg
, int from_tty
,
12029 struct cmd_list_element
*command
)
12031 struct exec_catchpoint
*c
;
12032 struct gdbarch
*gdbarch
= get_current_arch ();
12034 char *cond_string
= NULL
;
12036 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
12040 arg
= skip_spaces (arg
);
12042 /* The allowed syntax is:
12044 catch exec if <cond>
12046 First, check if there's an if clause. */
12047 cond_string
= ep_parse_optional_if_clause (&arg
);
12049 if ((*arg
!= '\0') && !isspace (*arg
))
12050 error (_("Junk at end of arguments."));
12052 c
= XNEW (struct exec_catchpoint
);
12053 init_catchpoint (&c
->base
, gdbarch
, tempflag
, cond_string
,
12054 &catch_exec_breakpoint_ops
);
12055 c
->exec_pathname
= NULL
;
12057 install_breakpoint (0, &c
->base
, 1);
12061 init_ada_exception_breakpoint (struct breakpoint
*b
,
12062 struct gdbarch
*gdbarch
,
12063 struct symtab_and_line sal
,
12065 const struct breakpoint_ops
*ops
,
12072 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
12074 loc_gdbarch
= gdbarch
;
12076 describe_other_breakpoints (loc_gdbarch
,
12077 sal
.pspace
, sal
.pc
, sal
.section
, -1);
12078 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
12079 version for exception catchpoints, because two catchpoints
12080 used for different exception names will use the same address.
12081 In this case, a "breakpoint ... also set at..." warning is
12082 unproductive. Besides, the warning phrasing is also a bit
12083 inappropriate, we should use the word catchpoint, and tell
12084 the user what type of catchpoint it is. The above is good
12085 enough for now, though. */
12088 init_raw_breakpoint (b
, gdbarch
, sal
, bp_breakpoint
, ops
);
12090 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
12091 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
12092 b
->addr_string
= addr_string
;
12093 b
->language
= language_ada
;
12096 /* Splits the argument using space as delimiter. Returns an xmalloc'd
12097 filter list, or NULL if no filtering is required. */
12099 catch_syscall_split_args (char *arg
)
12101 VEC(int) *result
= NULL
;
12102 struct cleanup
*cleanup
= make_cleanup (VEC_cleanup (int), &result
);
12104 while (*arg
!= '\0')
12106 int i
, syscall_number
;
12108 char cur_name
[128];
12111 /* Skip whitespace. */
12112 arg
= skip_spaces (arg
);
12114 for (i
= 0; i
< 127 && arg
[i
] && !isspace (arg
[i
]); ++i
)
12115 cur_name
[i
] = arg
[i
];
12116 cur_name
[i
] = '\0';
12119 /* Check if the user provided a syscall name or a number. */
12120 syscall_number
= (int) strtol (cur_name
, &endptr
, 0);
12121 if (*endptr
== '\0')
12122 get_syscall_by_number (syscall_number
, &s
);
12125 /* We have a name. Let's check if it's valid and convert it
12127 get_syscall_by_name (cur_name
, &s
);
12129 if (s
.number
== UNKNOWN_SYSCALL
)
12130 /* Here we have to issue an error instead of a warning,
12131 because GDB cannot do anything useful if there's no
12132 syscall number to be caught. */
12133 error (_("Unknown syscall name '%s'."), cur_name
);
12136 /* Ok, it's valid. */
12137 VEC_safe_push (int, result
, s
.number
);
12140 discard_cleanups (cleanup
);
12144 /* Implement the "catch syscall" command. */
12147 catch_syscall_command_1 (char *arg
, int from_tty
,
12148 struct cmd_list_element
*command
)
12153 struct gdbarch
*gdbarch
= get_current_arch ();
12155 /* Checking if the feature if supported. */
12156 if (gdbarch_get_syscall_number_p (gdbarch
) == 0)
12157 error (_("The feature 'catch syscall' is not supported on \
12158 this architecture yet."));
12160 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
12162 arg
= skip_spaces (arg
);
12164 /* We need to do this first "dummy" translation in order
12165 to get the syscall XML file loaded or, most important,
12166 to display a warning to the user if there's no XML file
12167 for his/her architecture. */
12168 get_syscall_by_number (0, &s
);
12170 /* The allowed syntax is:
12172 catch syscall <name | number> [<name | number> ... <name | number>]
12174 Let's check if there's a syscall name. */
12177 filter
= catch_syscall_split_args (arg
);
12181 create_syscall_event_catchpoint (tempflag
, filter
,
12182 &catch_syscall_breakpoint_ops
);
12186 catch_command (char *arg
, int from_tty
)
12188 error (_("Catch requires an event name."));
12193 tcatch_command (char *arg
, int from_tty
)
12195 error (_("Catch requires an event name."));
12198 /* A qsort comparison function that sorts breakpoints in order. */
12201 compare_breakpoints (const void *a
, const void *b
)
12203 const breakpoint_p
*ba
= a
;
12204 uintptr_t ua
= (uintptr_t) *ba
;
12205 const breakpoint_p
*bb
= b
;
12206 uintptr_t ub
= (uintptr_t) *bb
;
12208 if ((*ba
)->number
< (*bb
)->number
)
12210 else if ((*ba
)->number
> (*bb
)->number
)
12213 /* Now sort by address, in case we see, e..g, two breakpoints with
12217 return ua
> ub
? 1 : 0;
12220 /* Delete breakpoints by address or line. */
12223 clear_command (char *arg
, int from_tty
)
12225 struct breakpoint
*b
, *prev
;
12226 VEC(breakpoint_p
) *found
= 0;
12229 struct symtabs_and_lines sals
;
12230 struct symtab_and_line sal
;
12232 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
12236 sals
= decode_line_with_current_source (arg
,
12237 (DECODE_LINE_FUNFIRSTLINE
12238 | DECODE_LINE_LIST_MODE
));
12239 make_cleanup (xfree
, sals
.sals
);
12244 sals
.sals
= (struct symtab_and_line
*)
12245 xmalloc (sizeof (struct symtab_and_line
));
12246 make_cleanup (xfree
, sals
.sals
);
12247 init_sal (&sal
); /* Initialize to zeroes. */
12249 /* Set sal's line, symtab, pc, and pspace to the values
12250 corresponding to the last call to print_frame_info. If the
12251 codepoint is not valid, this will set all the fields to 0. */
12252 get_last_displayed_sal (&sal
);
12253 if (sal
.symtab
== 0)
12254 error (_("No source file specified."));
12256 sals
.sals
[0] = sal
;
12262 /* We don't call resolve_sal_pc here. That's not as bad as it
12263 seems, because all existing breakpoints typically have both
12264 file/line and pc set. So, if clear is given file/line, we can
12265 match this to existing breakpoint without obtaining pc at all.
12267 We only support clearing given the address explicitly
12268 present in breakpoint table. Say, we've set breakpoint
12269 at file:line. There were several PC values for that file:line,
12270 due to optimization, all in one block.
12272 We've picked one PC value. If "clear" is issued with another
12273 PC corresponding to the same file:line, the breakpoint won't
12274 be cleared. We probably can still clear the breakpoint, but
12275 since the other PC value is never presented to user, user
12276 can only find it by guessing, and it does not seem important
12277 to support that. */
12279 /* For each line spec given, delete bps which correspond to it. Do
12280 it in two passes, solely to preserve the current behavior that
12281 from_tty is forced true if we delete more than one
12285 make_cleanup (VEC_cleanup (breakpoint_p
), &found
);
12286 for (i
= 0; i
< sals
.nelts
; i
++)
12288 const char *sal_fullname
;
12290 /* If exact pc given, clear bpts at that pc.
12291 If line given (pc == 0), clear all bpts on specified line.
12292 If defaulting, clear all bpts on default line
12295 defaulting sal.pc != 0 tests to do
12300 1 0 <can't happen> */
12302 sal
= sals
.sals
[i
];
12303 sal_fullname
= (sal
.symtab
== NULL
12304 ? NULL
: symtab_to_fullname (sal
.symtab
));
12306 /* Find all matching breakpoints and add them to 'found'. */
12307 ALL_BREAKPOINTS (b
)
12310 /* Are we going to delete b? */
12311 if (b
->type
!= bp_none
&& !is_watchpoint (b
))
12313 struct bp_location
*loc
= b
->loc
;
12314 for (; loc
; loc
= loc
->next
)
12316 /* If the user specified file:line, don't allow a PC
12317 match. This matches historical gdb behavior. */
12318 int pc_match
= (!sal
.explicit_line
12320 && (loc
->pspace
== sal
.pspace
)
12321 && (loc
->address
== sal
.pc
)
12322 && (!section_is_overlay (loc
->section
)
12323 || loc
->section
== sal
.section
));
12324 int line_match
= 0;
12326 if ((default_match
|| sal
.explicit_line
)
12327 && loc
->symtab
!= NULL
12328 && sal_fullname
!= NULL
12329 && sal
.pspace
== loc
->pspace
12330 && loc
->line_number
== sal
.line
12331 && filename_cmp (symtab_to_fullname (loc
->symtab
),
12332 sal_fullname
) == 0)
12335 if (pc_match
|| line_match
)
12344 VEC_safe_push(breakpoint_p
, found
, b
);
12348 /* Now go thru the 'found' chain and delete them. */
12349 if (VEC_empty(breakpoint_p
, found
))
12352 error (_("No breakpoint at %s."), arg
);
12354 error (_("No breakpoint at this line."));
12357 /* Remove duplicates from the vec. */
12358 qsort (VEC_address (breakpoint_p
, found
),
12359 VEC_length (breakpoint_p
, found
),
12360 sizeof (breakpoint_p
),
12361 compare_breakpoints
);
12362 prev
= VEC_index (breakpoint_p
, found
, 0);
12363 for (ix
= 1; VEC_iterate (breakpoint_p
, found
, ix
, b
); ++ix
)
12367 VEC_ordered_remove (breakpoint_p
, found
, ix
);
12372 if (VEC_length(breakpoint_p
, found
) > 1)
12373 from_tty
= 1; /* Always report if deleted more than one. */
12376 if (VEC_length(breakpoint_p
, found
) == 1)
12377 printf_unfiltered (_("Deleted breakpoint "));
12379 printf_unfiltered (_("Deleted breakpoints "));
12382 for (ix
= 0; VEC_iterate(breakpoint_p
, found
, ix
, b
); ix
++)
12385 printf_unfiltered ("%d ", b
->number
);
12386 delete_breakpoint (b
);
12389 putchar_unfiltered ('\n');
12391 do_cleanups (cleanups
);
12394 /* Delete breakpoint in BS if they are `delete' breakpoints and
12395 all breakpoints that are marked for deletion, whether hit or not.
12396 This is called after any breakpoint is hit, or after errors. */
12399 breakpoint_auto_delete (bpstat bs
)
12401 struct breakpoint
*b
, *b_tmp
;
12403 for (; bs
; bs
= bs
->next
)
12404 if (bs
->breakpoint_at
12405 && bs
->breakpoint_at
->disposition
== disp_del
12407 delete_breakpoint (bs
->breakpoint_at
);
12409 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
12411 if (b
->disposition
== disp_del_at_next_stop
)
12412 delete_breakpoint (b
);
12416 /* A comparison function for bp_location AP and BP being interfaced to
12417 qsort. Sort elements primarily by their ADDRESS (no matter what
12418 does breakpoint_address_is_meaningful say for its OWNER),
12419 secondarily by ordering first bp_permanent OWNERed elements and
12420 terciarily just ensuring the array is sorted stable way despite
12421 qsort being an unstable algorithm. */
12424 bp_location_compare (const void *ap
, const void *bp
)
12426 struct bp_location
*a
= *(void **) ap
;
12427 struct bp_location
*b
= *(void **) bp
;
12428 /* A and B come from existing breakpoints having non-NULL OWNER. */
12429 int a_perm
= a
->owner
->enable_state
== bp_permanent
;
12430 int b_perm
= b
->owner
->enable_state
== bp_permanent
;
12432 if (a
->address
!= b
->address
)
12433 return (a
->address
> b
->address
) - (a
->address
< b
->address
);
12435 /* Sort locations at the same address by their pspace number, keeping
12436 locations of the same inferior (in a multi-inferior environment)
12439 if (a
->pspace
->num
!= b
->pspace
->num
)
12440 return ((a
->pspace
->num
> b
->pspace
->num
)
12441 - (a
->pspace
->num
< b
->pspace
->num
));
12443 /* Sort permanent breakpoints first. */
12444 if (a_perm
!= b_perm
)
12445 return (a_perm
< b_perm
) - (a_perm
> b_perm
);
12447 /* Make the internal GDB representation stable across GDB runs
12448 where A and B memory inside GDB can differ. Breakpoint locations of
12449 the same type at the same address can be sorted in arbitrary order. */
12451 if (a
->owner
->number
!= b
->owner
->number
)
12452 return ((a
->owner
->number
> b
->owner
->number
)
12453 - (a
->owner
->number
< b
->owner
->number
));
12455 return (a
> b
) - (a
< b
);
12458 /* Set bp_location_placed_address_before_address_max and
12459 bp_location_shadow_len_after_address_max according to the current
12460 content of the bp_location array. */
12463 bp_location_target_extensions_update (void)
12465 struct bp_location
*bl
, **blp_tmp
;
12467 bp_location_placed_address_before_address_max
= 0;
12468 bp_location_shadow_len_after_address_max
= 0;
12470 ALL_BP_LOCATIONS (bl
, blp_tmp
)
12472 CORE_ADDR start
, end
, addr
;
12474 if (!bp_location_has_shadow (bl
))
12477 start
= bl
->target_info
.placed_address
;
12478 end
= start
+ bl
->target_info
.shadow_len
;
12480 gdb_assert (bl
->address
>= start
);
12481 addr
= bl
->address
- start
;
12482 if (addr
> bp_location_placed_address_before_address_max
)
12483 bp_location_placed_address_before_address_max
= addr
;
12485 /* Zero SHADOW_LEN would not pass bp_location_has_shadow. */
12487 gdb_assert (bl
->address
< end
);
12488 addr
= end
- bl
->address
;
12489 if (addr
> bp_location_shadow_len_after_address_max
)
12490 bp_location_shadow_len_after_address_max
= addr
;
12494 /* Download tracepoint locations if they haven't been. */
12497 download_tracepoint_locations (void)
12499 struct breakpoint
*b
;
12500 struct cleanup
*old_chain
;
12502 if (!target_can_download_tracepoint ())
12505 old_chain
= save_current_space_and_thread ();
12507 ALL_TRACEPOINTS (b
)
12509 struct bp_location
*bl
;
12510 struct tracepoint
*t
;
12511 int bp_location_downloaded
= 0;
12513 if ((b
->type
== bp_fast_tracepoint
12514 ? !may_insert_fast_tracepoints
12515 : !may_insert_tracepoints
))
12518 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
12520 /* In tracepoint, locations are _never_ duplicated, so
12521 should_be_inserted is equivalent to
12522 unduplicated_should_be_inserted. */
12523 if (!should_be_inserted (bl
) || bl
->inserted
)
12526 switch_to_program_space_and_thread (bl
->pspace
);
12528 target_download_tracepoint (bl
);
12531 bp_location_downloaded
= 1;
12533 t
= (struct tracepoint
*) b
;
12534 t
->number_on_target
= b
->number
;
12535 if (bp_location_downloaded
)
12536 observer_notify_breakpoint_modified (b
);
12539 do_cleanups (old_chain
);
12542 /* Swap the insertion/duplication state between two locations. */
12545 swap_insertion (struct bp_location
*left
, struct bp_location
*right
)
12547 const int left_inserted
= left
->inserted
;
12548 const int left_duplicate
= left
->duplicate
;
12549 const int left_needs_update
= left
->needs_update
;
12550 const struct bp_target_info left_target_info
= left
->target_info
;
12552 /* Locations of tracepoints can never be duplicated. */
12553 if (is_tracepoint (left
->owner
))
12554 gdb_assert (!left
->duplicate
);
12555 if (is_tracepoint (right
->owner
))
12556 gdb_assert (!right
->duplicate
);
12558 left
->inserted
= right
->inserted
;
12559 left
->duplicate
= right
->duplicate
;
12560 left
->needs_update
= right
->needs_update
;
12561 left
->target_info
= right
->target_info
;
12562 right
->inserted
= left_inserted
;
12563 right
->duplicate
= left_duplicate
;
12564 right
->needs_update
= left_needs_update
;
12565 right
->target_info
= left_target_info
;
12568 /* Force the re-insertion of the locations at ADDRESS. This is called
12569 once a new/deleted/modified duplicate location is found and we are evaluating
12570 conditions on the target's side. Such conditions need to be updated on
12574 force_breakpoint_reinsertion (struct bp_location
*bl
)
12576 struct bp_location
**locp
= NULL
, **loc2p
;
12577 struct bp_location
*loc
;
12578 CORE_ADDR address
= 0;
12581 address
= bl
->address
;
12582 pspace_num
= bl
->pspace
->num
;
12584 /* This is only meaningful if the target is
12585 evaluating conditions and if the user has
12586 opted for condition evaluation on the target's
12588 if (gdb_evaluates_breakpoint_condition_p ()
12589 || !target_supports_evaluation_of_breakpoint_conditions ())
12592 /* Flag all breakpoint locations with this address and
12593 the same program space as the location
12594 as "its condition has changed". We need to
12595 update the conditions on the target's side. */
12596 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, address
)
12600 if (!is_breakpoint (loc
->owner
)
12601 || pspace_num
!= loc
->pspace
->num
)
12604 /* Flag the location appropriately. We use a different state to
12605 let everyone know that we already updated the set of locations
12606 with addr bl->address and program space bl->pspace. This is so
12607 we don't have to keep calling these functions just to mark locations
12608 that have already been marked. */
12609 loc
->condition_changed
= condition_updated
;
12611 /* Free the agent expression bytecode as well. We will compute
12613 if (loc
->cond_bytecode
)
12615 free_agent_expr (loc
->cond_bytecode
);
12616 loc
->cond_bytecode
= NULL
;
12620 /* Called whether new breakpoints are created, or existing breakpoints
12621 deleted, to update the global location list and recompute which
12622 locations are duplicate of which.
12624 The INSERT_MODE flag determines whether locations may not, may, or
12625 shall be inserted now. See 'enum ugll_insert_mode' for more
12629 update_global_location_list (enum ugll_insert_mode insert_mode
)
12631 struct breakpoint
*b
;
12632 struct bp_location
**locp
, *loc
;
12633 struct cleanup
*cleanups
;
12634 /* Last breakpoint location address that was marked for update. */
12635 CORE_ADDR last_addr
= 0;
12636 /* Last breakpoint location program space that was marked for update. */
12637 int last_pspace_num
= -1;
12639 /* Used in the duplicates detection below. When iterating over all
12640 bp_locations, points to the first bp_location of a given address.
12641 Breakpoints and watchpoints of different types are never
12642 duplicates of each other. Keep one pointer for each type of
12643 breakpoint/watchpoint, so we only need to loop over all locations
12645 struct bp_location
*bp_loc_first
; /* breakpoint */
12646 struct bp_location
*wp_loc_first
; /* hardware watchpoint */
12647 struct bp_location
*awp_loc_first
; /* access watchpoint */
12648 struct bp_location
*rwp_loc_first
; /* read watchpoint */
12650 /* Saved former bp_location array which we compare against the newly
12651 built bp_location from the current state of ALL_BREAKPOINTS. */
12652 struct bp_location
**old_location
, **old_locp
;
12653 unsigned old_location_count
;
12655 old_location
= bp_location
;
12656 old_location_count
= bp_location_count
;
12657 bp_location
= NULL
;
12658 bp_location_count
= 0;
12659 cleanups
= make_cleanup (xfree
, old_location
);
12661 ALL_BREAKPOINTS (b
)
12662 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
12663 bp_location_count
++;
12665 bp_location
= xmalloc (sizeof (*bp_location
) * bp_location_count
);
12666 locp
= bp_location
;
12667 ALL_BREAKPOINTS (b
)
12668 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
12670 qsort (bp_location
, bp_location_count
, sizeof (*bp_location
),
12671 bp_location_compare
);
12673 bp_location_target_extensions_update ();
12675 /* Identify bp_location instances that are no longer present in the
12676 new list, and therefore should be freed. Note that it's not
12677 necessary that those locations should be removed from inferior --
12678 if there's another location at the same address (previously
12679 marked as duplicate), we don't need to remove/insert the
12682 LOCP is kept in sync with OLD_LOCP, each pointing to the current
12683 and former bp_location array state respectively. */
12685 locp
= bp_location
;
12686 for (old_locp
= old_location
; old_locp
< old_location
+ old_location_count
;
12689 struct bp_location
*old_loc
= *old_locp
;
12690 struct bp_location
**loc2p
;
12692 /* Tells if 'old_loc' is found among the new locations. If
12693 not, we have to free it. */
12694 int found_object
= 0;
12695 /* Tells if the location should remain inserted in the target. */
12696 int keep_in_target
= 0;
12699 /* Skip LOCP entries which will definitely never be needed.
12700 Stop either at or being the one matching OLD_LOC. */
12701 while (locp
< bp_location
+ bp_location_count
12702 && (*locp
)->address
< old_loc
->address
)
12706 (loc2p
< bp_location
+ bp_location_count
12707 && (*loc2p
)->address
== old_loc
->address
);
12710 /* Check if this is a new/duplicated location or a duplicated
12711 location that had its condition modified. If so, we want to send
12712 its condition to the target if evaluation of conditions is taking
12714 if ((*loc2p
)->condition_changed
== condition_modified
12715 && (last_addr
!= old_loc
->address
12716 || last_pspace_num
!= old_loc
->pspace
->num
))
12718 force_breakpoint_reinsertion (*loc2p
);
12719 last_pspace_num
= old_loc
->pspace
->num
;
12722 if (*loc2p
== old_loc
)
12726 /* We have already handled this address, update it so that we don't
12727 have to go through updates again. */
12728 last_addr
= old_loc
->address
;
12730 /* Target-side condition evaluation: Handle deleted locations. */
12732 force_breakpoint_reinsertion (old_loc
);
12734 /* If this location is no longer present, and inserted, look if
12735 there's maybe a new location at the same address. If so,
12736 mark that one inserted, and don't remove this one. This is
12737 needed so that we don't have a time window where a breakpoint
12738 at certain location is not inserted. */
12740 if (old_loc
->inserted
)
12742 /* If the location is inserted now, we might have to remove
12745 if (found_object
&& should_be_inserted (old_loc
))
12747 /* The location is still present in the location list,
12748 and still should be inserted. Don't do anything. */
12749 keep_in_target
= 1;
12753 /* This location still exists, but it won't be kept in the
12754 target since it may have been disabled. We proceed to
12755 remove its target-side condition. */
12757 /* The location is either no longer present, or got
12758 disabled. See if there's another location at the
12759 same address, in which case we don't need to remove
12760 this one from the target. */
12762 /* OLD_LOC comes from existing struct breakpoint. */
12763 if (breakpoint_address_is_meaningful (old_loc
->owner
))
12766 (loc2p
< bp_location
+ bp_location_count
12767 && (*loc2p
)->address
== old_loc
->address
);
12770 struct bp_location
*loc2
= *loc2p
;
12772 if (breakpoint_locations_match (loc2
, old_loc
))
12774 /* Read watchpoint locations are switched to
12775 access watchpoints, if the former are not
12776 supported, but the latter are. */
12777 if (is_hardware_watchpoint (old_loc
->owner
))
12779 gdb_assert (is_hardware_watchpoint (loc2
->owner
));
12780 loc2
->watchpoint_type
= old_loc
->watchpoint_type
;
12783 /* loc2 is a duplicated location. We need to check
12784 if it should be inserted in case it will be
12786 if (loc2
!= old_loc
12787 && unduplicated_should_be_inserted (loc2
))
12789 swap_insertion (old_loc
, loc2
);
12790 keep_in_target
= 1;
12798 if (!keep_in_target
)
12800 if (remove_breakpoint (old_loc
, mark_uninserted
))
12802 /* This is just about all we can do. We could keep
12803 this location on the global list, and try to
12804 remove it next time, but there's no particular
12805 reason why we will succeed next time.
12807 Note that at this point, old_loc->owner is still
12808 valid, as delete_breakpoint frees the breakpoint
12809 only after calling us. */
12810 printf_filtered (_("warning: Error removing "
12811 "breakpoint %d\n"),
12812 old_loc
->owner
->number
);
12820 if (removed
&& non_stop
12821 && breakpoint_address_is_meaningful (old_loc
->owner
)
12822 && !is_hardware_watchpoint (old_loc
->owner
))
12824 /* This location was removed from the target. In
12825 non-stop mode, a race condition is possible where
12826 we've removed a breakpoint, but stop events for that
12827 breakpoint are already queued and will arrive later.
12828 We apply an heuristic to be able to distinguish such
12829 SIGTRAPs from other random SIGTRAPs: we keep this
12830 breakpoint location for a bit, and will retire it
12831 after we see some number of events. The theory here
12832 is that reporting of events should, "on the average",
12833 be fair, so after a while we'll see events from all
12834 threads that have anything of interest, and no longer
12835 need to keep this breakpoint location around. We
12836 don't hold locations forever so to reduce chances of
12837 mistaking a non-breakpoint SIGTRAP for a breakpoint
12840 The heuristic failing can be disastrous on
12841 decr_pc_after_break targets.
12843 On decr_pc_after_break targets, like e.g., x86-linux,
12844 if we fail to recognize a late breakpoint SIGTRAP,
12845 because events_till_retirement has reached 0 too
12846 soon, we'll fail to do the PC adjustment, and report
12847 a random SIGTRAP to the user. When the user resumes
12848 the inferior, it will most likely immediately crash
12849 with SIGILL/SIGBUS/SIGSEGV, or worse, get silently
12850 corrupted, because of being resumed e.g., in the
12851 middle of a multi-byte instruction, or skipped a
12852 one-byte instruction. This was actually seen happen
12853 on native x86-linux, and should be less rare on
12854 targets that do not support new thread events, like
12855 remote, due to the heuristic depending on
12858 Mistaking a random SIGTRAP for a breakpoint trap
12859 causes similar symptoms (PC adjustment applied when
12860 it shouldn't), but then again, playing with SIGTRAPs
12861 behind the debugger's back is asking for trouble.
12863 Since hardware watchpoint traps are always
12864 distinguishable from other traps, so we don't need to
12865 apply keep hardware watchpoint moribund locations
12866 around. We simply always ignore hardware watchpoint
12867 traps we can no longer explain. */
12869 old_loc
->events_till_retirement
= 3 * (thread_count () + 1);
12870 old_loc
->owner
= NULL
;
12872 VEC_safe_push (bp_location_p
, moribund_locations
, old_loc
);
12876 old_loc
->owner
= NULL
;
12877 decref_bp_location (&old_loc
);
12882 /* Rescan breakpoints at the same address and section, marking the
12883 first one as "first" and any others as "duplicates". This is so
12884 that the bpt instruction is only inserted once. If we have a
12885 permanent breakpoint at the same place as BPT, make that one the
12886 official one, and the rest as duplicates. Permanent breakpoints
12887 are sorted first for the same address.
12889 Do the same for hardware watchpoints, but also considering the
12890 watchpoint's type (regular/access/read) and length. */
12892 bp_loc_first
= NULL
;
12893 wp_loc_first
= NULL
;
12894 awp_loc_first
= NULL
;
12895 rwp_loc_first
= NULL
;
12896 ALL_BP_LOCATIONS (loc
, locp
)
12898 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always
12900 struct bp_location
**loc_first_p
;
12903 if (!unduplicated_should_be_inserted (loc
)
12904 || !breakpoint_address_is_meaningful (b
)
12905 /* Don't detect duplicate for tracepoint locations because they are
12906 never duplicated. See the comments in field `duplicate' of
12907 `struct bp_location'. */
12908 || is_tracepoint (b
))
12910 /* Clear the condition modification flag. */
12911 loc
->condition_changed
= condition_unchanged
;
12915 /* Permanent breakpoint should always be inserted. */
12916 if (b
->enable_state
== bp_permanent
&& ! loc
->inserted
)
12917 internal_error (__FILE__
, __LINE__
,
12918 _("allegedly permanent breakpoint is not "
12919 "actually inserted"));
12921 if (b
->type
== bp_hardware_watchpoint
)
12922 loc_first_p
= &wp_loc_first
;
12923 else if (b
->type
== bp_read_watchpoint
)
12924 loc_first_p
= &rwp_loc_first
;
12925 else if (b
->type
== bp_access_watchpoint
)
12926 loc_first_p
= &awp_loc_first
;
12928 loc_first_p
= &bp_loc_first
;
12930 if (*loc_first_p
== NULL
12931 || (overlay_debugging
&& loc
->section
!= (*loc_first_p
)->section
)
12932 || !breakpoint_locations_match (loc
, *loc_first_p
))
12934 *loc_first_p
= loc
;
12935 loc
->duplicate
= 0;
12937 if (is_breakpoint (loc
->owner
) && loc
->condition_changed
)
12939 loc
->needs_update
= 1;
12940 /* Clear the condition modification flag. */
12941 loc
->condition_changed
= condition_unchanged
;
12947 /* This and the above ensure the invariant that the first location
12948 is not duplicated, and is the inserted one.
12949 All following are marked as duplicated, and are not inserted. */
12951 swap_insertion (loc
, *loc_first_p
);
12952 loc
->duplicate
= 1;
12954 /* Clear the condition modification flag. */
12955 loc
->condition_changed
= condition_unchanged
;
12957 if ((*loc_first_p
)->owner
->enable_state
== bp_permanent
&& loc
->inserted
12958 && b
->enable_state
!= bp_permanent
)
12959 internal_error (__FILE__
, __LINE__
,
12960 _("another breakpoint was inserted on top of "
12961 "a permanent breakpoint"));
12964 if (insert_mode
== UGLL_INSERT
|| breakpoints_should_be_inserted_now ())
12966 if (insert_mode
!= UGLL_DONT_INSERT
)
12967 insert_breakpoint_locations ();
12970 /* Even though the caller told us to not insert new
12971 locations, we may still need to update conditions on the
12972 target's side of breakpoints that were already inserted
12973 if the target is evaluating breakpoint conditions. We
12974 only update conditions for locations that are marked
12976 update_inserted_breakpoint_locations ();
12980 if (insert_mode
!= UGLL_DONT_INSERT
)
12981 download_tracepoint_locations ();
12983 do_cleanups (cleanups
);
12987 breakpoint_retire_moribund (void)
12989 struct bp_location
*loc
;
12992 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
12993 if (--(loc
->events_till_retirement
) == 0)
12995 decref_bp_location (&loc
);
12996 VEC_unordered_remove (bp_location_p
, moribund_locations
, ix
);
13002 update_global_location_list_nothrow (enum ugll_insert_mode insert_mode
)
13004 volatile struct gdb_exception e
;
13006 TRY_CATCH (e
, RETURN_MASK_ERROR
)
13007 update_global_location_list (insert_mode
);
13010 /* Clear BKP from a BPS. */
13013 bpstat_remove_bp_location (bpstat bps
, struct breakpoint
*bpt
)
13017 for (bs
= bps
; bs
; bs
= bs
->next
)
13018 if (bs
->breakpoint_at
== bpt
)
13020 bs
->breakpoint_at
= NULL
;
13021 bs
->old_val
= NULL
;
13022 /* bs->commands will be freed later. */
13026 /* Callback for iterate_over_threads. */
13028 bpstat_remove_breakpoint_callback (struct thread_info
*th
, void *data
)
13030 struct breakpoint
*bpt
= data
;
13032 bpstat_remove_bp_location (th
->control
.stop_bpstat
, bpt
);
13036 /* Helper for breakpoint and tracepoint breakpoint_ops->mention
13040 say_where (struct breakpoint
*b
)
13042 struct value_print_options opts
;
13044 get_user_print_options (&opts
);
13046 /* i18n: cagney/2005-02-11: Below needs to be merged into a
13048 if (b
->loc
== NULL
)
13050 printf_filtered (_(" (%s) pending."), b
->addr_string
);
13054 if (opts
.addressprint
|| b
->loc
->symtab
== NULL
)
13056 printf_filtered (" at ");
13057 fputs_filtered (paddress (b
->loc
->gdbarch
, b
->loc
->address
),
13060 if (b
->loc
->symtab
!= NULL
)
13062 /* If there is a single location, we can print the location
13064 if (b
->loc
->next
== NULL
)
13065 printf_filtered (": file %s, line %d.",
13066 symtab_to_filename_for_display (b
->loc
->symtab
),
13067 b
->loc
->line_number
);
13069 /* This is not ideal, but each location may have a
13070 different file name, and this at least reflects the
13071 real situation somewhat. */
13072 printf_filtered (": %s.", b
->addr_string
);
13077 struct bp_location
*loc
= b
->loc
;
13079 for (; loc
; loc
= loc
->next
)
13081 printf_filtered (" (%d locations)", n
);
13086 /* Default bp_location_ops methods. */
13089 bp_location_dtor (struct bp_location
*self
)
13091 xfree (self
->cond
);
13092 if (self
->cond_bytecode
)
13093 free_agent_expr (self
->cond_bytecode
);
13094 xfree (self
->function_name
);
13096 VEC_free (agent_expr_p
, self
->target_info
.conditions
);
13097 VEC_free (agent_expr_p
, self
->target_info
.tcommands
);
13100 static const struct bp_location_ops bp_location_ops
=
13105 /* Default breakpoint_ops methods all breakpoint_ops ultimately
13109 base_breakpoint_dtor (struct breakpoint
*self
)
13111 decref_counted_command_line (&self
->commands
);
13112 xfree (self
->cond_string
);
13113 xfree (self
->extra_string
);
13114 xfree (self
->addr_string
);
13115 xfree (self
->filter
);
13116 xfree (self
->addr_string_range_end
);
13119 static struct bp_location
*
13120 base_breakpoint_allocate_location (struct breakpoint
*self
)
13122 struct bp_location
*loc
;
13124 loc
= XNEW (struct bp_location
);
13125 init_bp_location (loc
, &bp_location_ops
, self
);
13130 base_breakpoint_re_set (struct breakpoint
*b
)
13132 /* Nothing to re-set. */
13135 #define internal_error_pure_virtual_called() \
13136 gdb_assert_not_reached ("pure virtual function called")
13139 base_breakpoint_insert_location (struct bp_location
*bl
)
13141 internal_error_pure_virtual_called ();
13145 base_breakpoint_remove_location (struct bp_location
*bl
)
13147 internal_error_pure_virtual_called ();
13151 base_breakpoint_breakpoint_hit (const struct bp_location
*bl
,
13152 struct address_space
*aspace
,
13154 const struct target_waitstatus
*ws
)
13156 internal_error_pure_virtual_called ();
13160 base_breakpoint_check_status (bpstat bs
)
13165 /* A "works_in_software_mode" breakpoint_ops method that just internal
13169 base_breakpoint_works_in_software_mode (const struct breakpoint
*b
)
13171 internal_error_pure_virtual_called ();
13174 /* A "resources_needed" breakpoint_ops method that just internal
13178 base_breakpoint_resources_needed (const struct bp_location
*bl
)
13180 internal_error_pure_virtual_called ();
13183 static enum print_stop_action
13184 base_breakpoint_print_it (bpstat bs
)
13186 internal_error_pure_virtual_called ();
13190 base_breakpoint_print_one_detail (const struct breakpoint
*self
,
13191 struct ui_out
*uiout
)
13197 base_breakpoint_print_mention (struct breakpoint
*b
)
13199 internal_error_pure_virtual_called ();
13203 base_breakpoint_print_recreate (struct breakpoint
*b
, struct ui_file
*fp
)
13205 internal_error_pure_virtual_called ();
13209 base_breakpoint_create_sals_from_address (char **arg
,
13210 struct linespec_result
*canonical
,
13211 enum bptype type_wanted
,
13215 internal_error_pure_virtual_called ();
13219 base_breakpoint_create_breakpoints_sal (struct gdbarch
*gdbarch
,
13220 struct linespec_result
*c
,
13222 char *extra_string
,
13223 enum bptype type_wanted
,
13224 enum bpdisp disposition
,
13226 int task
, int ignore_count
,
13227 const struct breakpoint_ops
*o
,
13228 int from_tty
, int enabled
,
13229 int internal
, unsigned flags
)
13231 internal_error_pure_virtual_called ();
13235 base_breakpoint_decode_linespec (struct breakpoint
*b
, char **s
,
13236 struct symtabs_and_lines
*sals
)
13238 internal_error_pure_virtual_called ();
13241 /* The default 'explains_signal' method. */
13244 base_breakpoint_explains_signal (struct breakpoint
*b
, enum gdb_signal sig
)
13249 /* The default "after_condition_true" method. */
13252 base_breakpoint_after_condition_true (struct bpstats
*bs
)
13254 /* Nothing to do. */
13257 struct breakpoint_ops base_breakpoint_ops
=
13259 base_breakpoint_dtor
,
13260 base_breakpoint_allocate_location
,
13261 base_breakpoint_re_set
,
13262 base_breakpoint_insert_location
,
13263 base_breakpoint_remove_location
,
13264 base_breakpoint_breakpoint_hit
,
13265 base_breakpoint_check_status
,
13266 base_breakpoint_resources_needed
,
13267 base_breakpoint_works_in_software_mode
,
13268 base_breakpoint_print_it
,
13270 base_breakpoint_print_one_detail
,
13271 base_breakpoint_print_mention
,
13272 base_breakpoint_print_recreate
,
13273 base_breakpoint_create_sals_from_address
,
13274 base_breakpoint_create_breakpoints_sal
,
13275 base_breakpoint_decode_linespec
,
13276 base_breakpoint_explains_signal
,
13277 base_breakpoint_after_condition_true
,
13280 /* Default breakpoint_ops methods. */
13283 bkpt_re_set (struct breakpoint
*b
)
13285 /* FIXME: is this still reachable? */
13286 if (b
->addr_string
== NULL
)
13288 /* Anything without a string can't be re-set. */
13289 delete_breakpoint (b
);
13293 breakpoint_re_set_default (b
);
13297 bkpt_insert_location (struct bp_location
*bl
)
13299 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
13300 return target_insert_hw_breakpoint (bl
->gdbarch
, &bl
->target_info
);
13302 return target_insert_breakpoint (bl
->gdbarch
, &bl
->target_info
);
13306 bkpt_remove_location (struct bp_location
*bl
)
13308 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
13309 return target_remove_hw_breakpoint (bl
->gdbarch
, &bl
->target_info
);
13311 return target_remove_breakpoint (bl
->gdbarch
, &bl
->target_info
);
13315 bkpt_breakpoint_hit (const struct bp_location
*bl
,
13316 struct address_space
*aspace
, CORE_ADDR bp_addr
,
13317 const struct target_waitstatus
*ws
)
13319 if (ws
->kind
!= TARGET_WAITKIND_STOPPED
13320 || ws
->value
.sig
!= GDB_SIGNAL_TRAP
)
13323 if (!breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
13327 if (overlay_debugging
/* unmapped overlay section */
13328 && section_is_overlay (bl
->section
)
13329 && !section_is_mapped (bl
->section
))
13336 dprintf_breakpoint_hit (const struct bp_location
*bl
,
13337 struct address_space
*aspace
, CORE_ADDR bp_addr
,
13338 const struct target_waitstatus
*ws
)
13340 if (dprintf_style
== dprintf_style_agent
13341 && target_can_run_breakpoint_commands ())
13343 /* An agent-style dprintf never causes a stop. If we see a trap
13344 for this address it must be for a breakpoint that happens to
13345 be set at the same address. */
13349 return bkpt_breakpoint_hit (bl
, aspace
, bp_addr
, ws
);
13353 bkpt_resources_needed (const struct bp_location
*bl
)
13355 gdb_assert (bl
->owner
->type
== bp_hardware_breakpoint
);
13360 static enum print_stop_action
13361 bkpt_print_it (bpstat bs
)
13363 struct breakpoint
*b
;
13364 const struct bp_location
*bl
;
13366 struct ui_out
*uiout
= current_uiout
;
13368 gdb_assert (bs
->bp_location_at
!= NULL
);
13370 bl
= bs
->bp_location_at
;
13371 b
= bs
->breakpoint_at
;
13373 bp_temp
= b
->disposition
== disp_del
;
13374 if (bl
->address
!= bl
->requested_address
)
13375 breakpoint_adjustment_warning (bl
->requested_address
,
13378 annotate_breakpoint (b
->number
);
13380 ui_out_text (uiout
, "\nTemporary breakpoint ");
13382 ui_out_text (uiout
, "\nBreakpoint ");
13383 if (ui_out_is_mi_like_p (uiout
))
13385 ui_out_field_string (uiout
, "reason",
13386 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
13387 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
13389 ui_out_field_int (uiout
, "bkptno", b
->number
);
13390 ui_out_text (uiout
, ", ");
13392 return PRINT_SRC_AND_LOC
;
13396 bkpt_print_mention (struct breakpoint
*b
)
13398 if (ui_out_is_mi_like_p (current_uiout
))
13403 case bp_breakpoint
:
13404 case bp_gnu_ifunc_resolver
:
13405 if (b
->disposition
== disp_del
)
13406 printf_filtered (_("Temporary breakpoint"));
13408 printf_filtered (_("Breakpoint"));
13409 printf_filtered (_(" %d"), b
->number
);
13410 if (b
->type
== bp_gnu_ifunc_resolver
)
13411 printf_filtered (_(" at gnu-indirect-function resolver"));
13413 case bp_hardware_breakpoint
:
13414 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
13417 printf_filtered (_("Dprintf %d"), b
->number
);
13425 bkpt_print_recreate (struct breakpoint
*tp
, struct ui_file
*fp
)
13427 if (tp
->type
== bp_breakpoint
&& tp
->disposition
== disp_del
)
13428 fprintf_unfiltered (fp
, "tbreak");
13429 else if (tp
->type
== bp_breakpoint
)
13430 fprintf_unfiltered (fp
, "break");
13431 else if (tp
->type
== bp_hardware_breakpoint
13432 && tp
->disposition
== disp_del
)
13433 fprintf_unfiltered (fp
, "thbreak");
13434 else if (tp
->type
== bp_hardware_breakpoint
)
13435 fprintf_unfiltered (fp
, "hbreak");
13437 internal_error (__FILE__
, __LINE__
,
13438 _("unhandled breakpoint type %d"), (int) tp
->type
);
13440 fprintf_unfiltered (fp
, " %s", tp
->addr_string
);
13441 print_recreate_thread (tp
, fp
);
13445 bkpt_create_sals_from_address (char **arg
,
13446 struct linespec_result
*canonical
,
13447 enum bptype type_wanted
,
13448 char *addr_start
, char **copy_arg
)
13450 create_sals_from_address_default (arg
, canonical
, type_wanted
,
13451 addr_start
, copy_arg
);
13455 bkpt_create_breakpoints_sal (struct gdbarch
*gdbarch
,
13456 struct linespec_result
*canonical
,
13458 char *extra_string
,
13459 enum bptype type_wanted
,
13460 enum bpdisp disposition
,
13462 int task
, int ignore_count
,
13463 const struct breakpoint_ops
*ops
,
13464 int from_tty
, int enabled
,
13465 int internal
, unsigned flags
)
13467 create_breakpoints_sal_default (gdbarch
, canonical
,
13468 cond_string
, extra_string
,
13470 disposition
, thread
, task
,
13471 ignore_count
, ops
, from_tty
,
13472 enabled
, internal
, flags
);
13476 bkpt_decode_linespec (struct breakpoint
*b
, char **s
,
13477 struct symtabs_and_lines
*sals
)
13479 decode_linespec_default (b
, s
, sals
);
13482 /* Virtual table for internal breakpoints. */
13485 internal_bkpt_re_set (struct breakpoint
*b
)
13489 /* Delete overlay event and longjmp master breakpoints; they
13490 will be reset later by breakpoint_re_set. */
13491 case bp_overlay_event
:
13492 case bp_longjmp_master
:
13493 case bp_std_terminate_master
:
13494 case bp_exception_master
:
13495 delete_breakpoint (b
);
13498 /* This breakpoint is special, it's set up when the inferior
13499 starts and we really don't want to touch it. */
13500 case bp_shlib_event
:
13502 /* Like bp_shlib_event, this breakpoint type is special. Once
13503 it is set up, we do not want to touch it. */
13504 case bp_thread_event
:
13510 internal_bkpt_check_status (bpstat bs
)
13512 if (bs
->breakpoint_at
->type
== bp_shlib_event
)
13514 /* If requested, stop when the dynamic linker notifies GDB of
13515 events. This allows the user to get control and place
13516 breakpoints in initializer routines for dynamically loaded
13517 objects (among other things). */
13518 bs
->stop
= stop_on_solib_events
;
13519 bs
->print
= stop_on_solib_events
;
13525 static enum print_stop_action
13526 internal_bkpt_print_it (bpstat bs
)
13528 struct breakpoint
*b
;
13530 b
= bs
->breakpoint_at
;
13534 case bp_shlib_event
:
13535 /* Did we stop because the user set the stop_on_solib_events
13536 variable? (If so, we report this as a generic, "Stopped due
13537 to shlib event" message.) */
13538 print_solib_event (0);
13541 case bp_thread_event
:
13542 /* Not sure how we will get here.
13543 GDB should not stop for these breakpoints. */
13544 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
13547 case bp_overlay_event
:
13548 /* By analogy with the thread event, GDB should not stop for these. */
13549 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
13552 case bp_longjmp_master
:
13553 /* These should never be enabled. */
13554 printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
13557 case bp_std_terminate_master
:
13558 /* These should never be enabled. */
13559 printf_filtered (_("std::terminate Master Breakpoint: "
13560 "gdb should not stop!\n"));
13563 case bp_exception_master
:
13564 /* These should never be enabled. */
13565 printf_filtered (_("Exception Master Breakpoint: "
13566 "gdb should not stop!\n"));
13570 return PRINT_NOTHING
;
13574 internal_bkpt_print_mention (struct breakpoint
*b
)
13576 /* Nothing to mention. These breakpoints are internal. */
13579 /* Virtual table for momentary breakpoints */
13582 momentary_bkpt_re_set (struct breakpoint
*b
)
13584 /* Keep temporary breakpoints, which can be encountered when we step
13585 over a dlopen call and solib_add is resetting the breakpoints.
13586 Otherwise these should have been blown away via the cleanup chain
13587 or by breakpoint_init_inferior when we rerun the executable. */
13591 momentary_bkpt_check_status (bpstat bs
)
13593 /* Nothing. The point of these breakpoints is causing a stop. */
13596 static enum print_stop_action
13597 momentary_bkpt_print_it (bpstat bs
)
13599 struct ui_out
*uiout
= current_uiout
;
13601 if (ui_out_is_mi_like_p (uiout
))
13603 struct breakpoint
*b
= bs
->breakpoint_at
;
13608 ui_out_field_string
13610 async_reason_lookup (EXEC_ASYNC_FUNCTION_FINISHED
));
13614 ui_out_field_string
13616 async_reason_lookup (EXEC_ASYNC_LOCATION_REACHED
));
13621 return PRINT_UNKNOWN
;
13625 momentary_bkpt_print_mention (struct breakpoint
*b
)
13627 /* Nothing to mention. These breakpoints are internal. */
13630 /* Ensure INITIATING_FRAME is cleared when no such breakpoint exists.
13632 It gets cleared already on the removal of the first one of such placed
13633 breakpoints. This is OK as they get all removed altogether. */
13636 longjmp_bkpt_dtor (struct breakpoint
*self
)
13638 struct thread_info
*tp
= find_thread_id (self
->thread
);
13641 tp
->initiating_frame
= null_frame_id
;
13643 momentary_breakpoint_ops
.dtor (self
);
13646 /* Specific methods for probe breakpoints. */
13649 bkpt_probe_insert_location (struct bp_location
*bl
)
13651 int v
= bkpt_insert_location (bl
);
13655 /* The insertion was successful, now let's set the probe's semaphore
13657 if (bl
->probe
.probe
->pops
->set_semaphore
!= NULL
)
13658 bl
->probe
.probe
->pops
->set_semaphore (bl
->probe
.probe
,
13667 bkpt_probe_remove_location (struct bp_location
*bl
)
13669 /* Let's clear the semaphore before removing the location. */
13670 if (bl
->probe
.probe
->pops
->clear_semaphore
!= NULL
)
13671 bl
->probe
.probe
->pops
->clear_semaphore (bl
->probe
.probe
,
13675 return bkpt_remove_location (bl
);
13679 bkpt_probe_create_sals_from_address (char **arg
,
13680 struct linespec_result
*canonical
,
13681 enum bptype type_wanted
,
13682 char *addr_start
, char **copy_arg
)
13684 struct linespec_sals lsal
;
13686 lsal
.sals
= parse_probes (arg
, canonical
);
13688 *copy_arg
= xstrdup (canonical
->addr_string
);
13689 lsal
.canonical
= xstrdup (*copy_arg
);
13691 VEC_safe_push (linespec_sals
, canonical
->sals
, &lsal
);
13695 bkpt_probe_decode_linespec (struct breakpoint
*b
, char **s
,
13696 struct symtabs_and_lines
*sals
)
13698 *sals
= parse_probes (s
, NULL
);
13700 error (_("probe not found"));
13703 /* The breakpoint_ops structure to be used in tracepoints. */
13706 tracepoint_re_set (struct breakpoint
*b
)
13708 breakpoint_re_set_default (b
);
13712 tracepoint_breakpoint_hit (const struct bp_location
*bl
,
13713 struct address_space
*aspace
, CORE_ADDR bp_addr
,
13714 const struct target_waitstatus
*ws
)
13716 /* By definition, the inferior does not report stops at
13722 tracepoint_print_one_detail (const struct breakpoint
*self
,
13723 struct ui_out
*uiout
)
13725 struct tracepoint
*tp
= (struct tracepoint
*) self
;
13726 if (tp
->static_trace_marker_id
)
13728 gdb_assert (self
->type
== bp_static_tracepoint
);
13730 ui_out_text (uiout
, "\tmarker id is ");
13731 ui_out_field_string (uiout
, "static-tracepoint-marker-string-id",
13732 tp
->static_trace_marker_id
);
13733 ui_out_text (uiout
, "\n");
13738 tracepoint_print_mention (struct breakpoint
*b
)
13740 if (ui_out_is_mi_like_p (current_uiout
))
13745 case bp_tracepoint
:
13746 printf_filtered (_("Tracepoint"));
13747 printf_filtered (_(" %d"), b
->number
);
13749 case bp_fast_tracepoint
:
13750 printf_filtered (_("Fast tracepoint"));
13751 printf_filtered (_(" %d"), b
->number
);
13753 case bp_static_tracepoint
:
13754 printf_filtered (_("Static tracepoint"));
13755 printf_filtered (_(" %d"), b
->number
);
13758 internal_error (__FILE__
, __LINE__
,
13759 _("unhandled tracepoint type %d"), (int) b
->type
);
13766 tracepoint_print_recreate (struct breakpoint
*self
, struct ui_file
*fp
)
13768 struct tracepoint
*tp
= (struct tracepoint
*) self
;
13770 if (self
->type
== bp_fast_tracepoint
)
13771 fprintf_unfiltered (fp
, "ftrace");
13772 if (self
->type
== bp_static_tracepoint
)
13773 fprintf_unfiltered (fp
, "strace");
13774 else if (self
->type
== bp_tracepoint
)
13775 fprintf_unfiltered (fp
, "trace");
13777 internal_error (__FILE__
, __LINE__
,
13778 _("unhandled tracepoint type %d"), (int) self
->type
);
13780 fprintf_unfiltered (fp
, " %s", self
->addr_string
);
13781 print_recreate_thread (self
, fp
);
13783 if (tp
->pass_count
)
13784 fprintf_unfiltered (fp
, " passcount %d\n", tp
->pass_count
);
13788 tracepoint_create_sals_from_address (char **arg
,
13789 struct linespec_result
*canonical
,
13790 enum bptype type_wanted
,
13791 char *addr_start
, char **copy_arg
)
13793 create_sals_from_address_default (arg
, canonical
, type_wanted
,
13794 addr_start
, copy_arg
);
13798 tracepoint_create_breakpoints_sal (struct gdbarch
*gdbarch
,
13799 struct linespec_result
*canonical
,
13801 char *extra_string
,
13802 enum bptype type_wanted
,
13803 enum bpdisp disposition
,
13805 int task
, int ignore_count
,
13806 const struct breakpoint_ops
*ops
,
13807 int from_tty
, int enabled
,
13808 int internal
, unsigned flags
)
13810 create_breakpoints_sal_default (gdbarch
, canonical
,
13811 cond_string
, extra_string
,
13813 disposition
, thread
, task
,
13814 ignore_count
, ops
, from_tty
,
13815 enabled
, internal
, flags
);
13819 tracepoint_decode_linespec (struct breakpoint
*b
, char **s
,
13820 struct symtabs_and_lines
*sals
)
13822 decode_linespec_default (b
, s
, sals
);
13825 struct breakpoint_ops tracepoint_breakpoint_ops
;
13827 /* The breakpoint_ops structure to be use on tracepoints placed in a
13831 tracepoint_probe_create_sals_from_address (char **arg
,
13832 struct linespec_result
*canonical
,
13833 enum bptype type_wanted
,
13834 char *addr_start
, char **copy_arg
)
13836 /* We use the same method for breakpoint on probes. */
13837 bkpt_probe_create_sals_from_address (arg
, canonical
, type_wanted
,
13838 addr_start
, copy_arg
);
13842 tracepoint_probe_decode_linespec (struct breakpoint
*b
, char **s
,
13843 struct symtabs_and_lines
*sals
)
13845 /* We use the same method for breakpoint on probes. */
13846 bkpt_probe_decode_linespec (b
, s
, sals
);
13849 static struct breakpoint_ops tracepoint_probe_breakpoint_ops
;
13851 /* Dprintf breakpoint_ops methods. */
13854 dprintf_re_set (struct breakpoint
*b
)
13856 breakpoint_re_set_default (b
);
13858 /* This breakpoint could have been pending, and be resolved now, and
13859 if so, we should now have the extra string. If we don't, the
13860 dprintf was malformed when created, but we couldn't tell because
13861 we can't extract the extra string until the location is
13863 if (b
->loc
!= NULL
&& b
->extra_string
== NULL
)
13864 error (_("Format string required"));
13866 /* 1 - connect to target 1, that can run breakpoint commands.
13867 2 - create a dprintf, which resolves fine.
13868 3 - disconnect from target 1
13869 4 - connect to target 2, that can NOT run breakpoint commands.
13871 After steps #3/#4, you'll want the dprintf command list to
13872 be updated, because target 1 and 2 may well return different
13873 answers for target_can_run_breakpoint_commands().
13874 Given absence of finer grained resetting, we get to do
13875 it all the time. */
13876 if (b
->extra_string
!= NULL
)
13877 update_dprintf_command_list (b
);
13880 /* Implement the "print_recreate" breakpoint_ops method for dprintf. */
13883 dprintf_print_recreate (struct breakpoint
*tp
, struct ui_file
*fp
)
13885 fprintf_unfiltered (fp
, "dprintf %s%s", tp
->addr_string
,
13887 print_recreate_thread (tp
, fp
);
13890 /* Implement the "after_condition_true" breakpoint_ops method for
13893 dprintf's are implemented with regular commands in their command
13894 list, but we run the commands here instead of before presenting the
13895 stop to the user, as dprintf's don't actually cause a stop. This
13896 also makes it so that the commands of multiple dprintfs at the same
13897 address are all handled. */
13900 dprintf_after_condition_true (struct bpstats
*bs
)
13902 struct cleanup
*old_chain
;
13903 struct bpstats tmp_bs
= { NULL
};
13904 struct bpstats
*tmp_bs_p
= &tmp_bs
;
13906 /* dprintf's never cause a stop. This wasn't set in the
13907 check_status hook instead because that would make the dprintf's
13908 condition not be evaluated. */
13911 /* Run the command list here. Take ownership of it instead of
13912 copying. We never want these commands to run later in
13913 bpstat_do_actions, if a breakpoint that causes a stop happens to
13914 be set at same address as this dprintf, or even if running the
13915 commands here throws. */
13916 tmp_bs
.commands
= bs
->commands
;
13917 bs
->commands
= NULL
;
13918 old_chain
= make_cleanup_decref_counted_command_line (&tmp_bs
.commands
);
13920 bpstat_do_actions_1 (&tmp_bs_p
);
13922 /* 'tmp_bs.commands' will usually be NULL by now, but
13923 bpstat_do_actions_1 may return early without processing the whole
13925 do_cleanups (old_chain
);
13928 /* The breakpoint_ops structure to be used on static tracepoints with
13932 strace_marker_create_sals_from_address (char **arg
,
13933 struct linespec_result
*canonical
,
13934 enum bptype type_wanted
,
13935 char *addr_start
, char **copy_arg
)
13937 struct linespec_sals lsal
;
13939 lsal
.sals
= decode_static_tracepoint_spec (arg
);
13941 *copy_arg
= savestring (addr_start
, *arg
- addr_start
);
13943 canonical
->addr_string
= xstrdup (*copy_arg
);
13944 lsal
.canonical
= xstrdup (*copy_arg
);
13945 VEC_safe_push (linespec_sals
, canonical
->sals
, &lsal
);
13949 strace_marker_create_breakpoints_sal (struct gdbarch
*gdbarch
,
13950 struct linespec_result
*canonical
,
13952 char *extra_string
,
13953 enum bptype type_wanted
,
13954 enum bpdisp disposition
,
13956 int task
, int ignore_count
,
13957 const struct breakpoint_ops
*ops
,
13958 int from_tty
, int enabled
,
13959 int internal
, unsigned flags
)
13962 struct linespec_sals
*lsal
= VEC_index (linespec_sals
,
13963 canonical
->sals
, 0);
13965 /* If the user is creating a static tracepoint by marker id
13966 (strace -m MARKER_ID), then store the sals index, so that
13967 breakpoint_re_set can try to match up which of the newly
13968 found markers corresponds to this one, and, don't try to
13969 expand multiple locations for each sal, given than SALS
13970 already should contain all sals for MARKER_ID. */
13972 for (i
= 0; i
< lsal
->sals
.nelts
; ++i
)
13974 struct symtabs_and_lines expanded
;
13975 struct tracepoint
*tp
;
13976 struct cleanup
*old_chain
;
13979 expanded
.nelts
= 1;
13980 expanded
.sals
= &lsal
->sals
.sals
[i
];
13982 addr_string
= xstrdup (canonical
->addr_string
);
13983 old_chain
= make_cleanup (xfree
, addr_string
);
13985 tp
= XCNEW (struct tracepoint
);
13986 init_breakpoint_sal (&tp
->base
, gdbarch
, expanded
,
13988 cond_string
, extra_string
,
13989 type_wanted
, disposition
,
13990 thread
, task
, ignore_count
, ops
,
13991 from_tty
, enabled
, internal
, flags
,
13992 canonical
->special_display
);
13993 /* Given that its possible to have multiple markers with
13994 the same string id, if the user is creating a static
13995 tracepoint by marker id ("strace -m MARKER_ID"), then
13996 store the sals index, so that breakpoint_re_set can
13997 try to match up which of the newly found markers
13998 corresponds to this one */
13999 tp
->static_trace_marker_id_idx
= i
;
14001 install_breakpoint (internal
, &tp
->base
, 0);
14003 discard_cleanups (old_chain
);
14008 strace_marker_decode_linespec (struct breakpoint
*b
, char **s
,
14009 struct symtabs_and_lines
*sals
)
14011 struct tracepoint
*tp
= (struct tracepoint
*) b
;
14013 *sals
= decode_static_tracepoint_spec (s
);
14014 if (sals
->nelts
> tp
->static_trace_marker_id_idx
)
14016 sals
->sals
[0] = sals
->sals
[tp
->static_trace_marker_id_idx
];
14020 error (_("marker %s not found"), tp
->static_trace_marker_id
);
14023 static struct breakpoint_ops strace_marker_breakpoint_ops
;
14026 strace_marker_p (struct breakpoint
*b
)
14028 return b
->ops
== &strace_marker_breakpoint_ops
;
14031 /* Delete a breakpoint and clean up all traces of it in the data
14035 delete_breakpoint (struct breakpoint
*bpt
)
14037 struct breakpoint
*b
;
14039 gdb_assert (bpt
!= NULL
);
14041 /* Has this bp already been deleted? This can happen because
14042 multiple lists can hold pointers to bp's. bpstat lists are
14045 One example of this happening is a watchpoint's scope bp. When
14046 the scope bp triggers, we notice that the watchpoint is out of
14047 scope, and delete it. We also delete its scope bp. But the
14048 scope bp is marked "auto-deleting", and is already on a bpstat.
14049 That bpstat is then checked for auto-deleting bp's, which are
14052 A real solution to this problem might involve reference counts in
14053 bp's, and/or giving them pointers back to their referencing
14054 bpstat's, and teaching delete_breakpoint to only free a bp's
14055 storage when no more references were extent. A cheaper bandaid
14057 if (bpt
->type
== bp_none
)
14060 /* At least avoid this stale reference until the reference counting
14061 of breakpoints gets resolved. */
14062 if (bpt
->related_breakpoint
!= bpt
)
14064 struct breakpoint
*related
;
14065 struct watchpoint
*w
;
14067 if (bpt
->type
== bp_watchpoint_scope
)
14068 w
= (struct watchpoint
*) bpt
->related_breakpoint
;
14069 else if (bpt
->related_breakpoint
->type
== bp_watchpoint_scope
)
14070 w
= (struct watchpoint
*) bpt
;
14074 watchpoint_del_at_next_stop (w
);
14076 /* Unlink bpt from the bpt->related_breakpoint ring. */
14077 for (related
= bpt
; related
->related_breakpoint
!= bpt
;
14078 related
= related
->related_breakpoint
);
14079 related
->related_breakpoint
= bpt
->related_breakpoint
;
14080 bpt
->related_breakpoint
= bpt
;
14083 /* watch_command_1 creates a watchpoint but only sets its number if
14084 update_watchpoint succeeds in creating its bp_locations. If there's
14085 a problem in that process, we'll be asked to delete the half-created
14086 watchpoint. In that case, don't announce the deletion. */
14088 observer_notify_breakpoint_deleted (bpt
);
14090 if (breakpoint_chain
== bpt
)
14091 breakpoint_chain
= bpt
->next
;
14093 ALL_BREAKPOINTS (b
)
14094 if (b
->next
== bpt
)
14096 b
->next
= bpt
->next
;
14100 /* Be sure no bpstat's are pointing at the breakpoint after it's
14102 /* FIXME, how can we find all bpstat's? We just check stop_bpstat
14103 in all threads for now. Note that we cannot just remove bpstats
14104 pointing at bpt from the stop_bpstat list entirely, as breakpoint
14105 commands are associated with the bpstat; if we remove it here,
14106 then the later call to bpstat_do_actions (&stop_bpstat); in
14107 event-top.c won't do anything, and temporary breakpoints with
14108 commands won't work. */
14110 iterate_over_threads (bpstat_remove_breakpoint_callback
, bpt
);
14112 /* Now that breakpoint is removed from breakpoint list, update the
14113 global location list. This will remove locations that used to
14114 belong to this breakpoint. Do this before freeing the breakpoint
14115 itself, since remove_breakpoint looks at location's owner. It
14116 might be better design to have location completely
14117 self-contained, but it's not the case now. */
14118 update_global_location_list (UGLL_DONT_INSERT
);
14120 bpt
->ops
->dtor (bpt
);
14121 /* On the chance that someone will soon try again to delete this
14122 same bp, we mark it as deleted before freeing its storage. */
14123 bpt
->type
= bp_none
;
14128 do_delete_breakpoint_cleanup (void *b
)
14130 delete_breakpoint (b
);
14134 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
14136 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
14139 /* Iterator function to call a user-provided callback function once
14140 for each of B and its related breakpoints. */
14143 iterate_over_related_breakpoints (struct breakpoint
*b
,
14144 void (*function
) (struct breakpoint
*,
14148 struct breakpoint
*related
;
14153 struct breakpoint
*next
;
14155 /* FUNCTION may delete RELATED. */
14156 next
= related
->related_breakpoint
;
14158 if (next
== related
)
14160 /* RELATED is the last ring entry. */
14161 function (related
, data
);
14163 /* FUNCTION may have deleted it, so we'd never reach back to
14164 B. There's nothing left to do anyway, so just break
14169 function (related
, data
);
14173 while (related
!= b
);
14177 do_delete_breakpoint (struct breakpoint
*b
, void *ignore
)
14179 delete_breakpoint (b
);
14182 /* A callback for map_breakpoint_numbers that calls
14183 delete_breakpoint. */
14186 do_map_delete_breakpoint (struct breakpoint
*b
, void *ignore
)
14188 iterate_over_related_breakpoints (b
, do_delete_breakpoint
, NULL
);
14192 delete_command (char *arg
, int from_tty
)
14194 struct breakpoint
*b
, *b_tmp
;
14200 int breaks_to_delete
= 0;
14202 /* Delete all breakpoints if no argument. Do not delete
14203 internal breakpoints, these have to be deleted with an
14204 explicit breakpoint number argument. */
14205 ALL_BREAKPOINTS (b
)
14206 if (user_breakpoint_p (b
))
14208 breaks_to_delete
= 1;
14212 /* Ask user only if there are some breakpoints to delete. */
14214 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
14216 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
14217 if (user_breakpoint_p (b
))
14218 delete_breakpoint (b
);
14222 map_breakpoint_numbers (arg
, do_map_delete_breakpoint
, NULL
);
14226 all_locations_are_pending (struct bp_location
*loc
)
14228 for (; loc
; loc
= loc
->next
)
14229 if (!loc
->shlib_disabled
14230 && !loc
->pspace
->executing_startup
)
14235 /* Subroutine of update_breakpoint_locations to simplify it.
14236 Return non-zero if multiple fns in list LOC have the same name.
14237 Null names are ignored. */
14240 ambiguous_names_p (struct bp_location
*loc
)
14242 struct bp_location
*l
;
14243 htab_t htab
= htab_create_alloc (13, htab_hash_string
,
14244 (int (*) (const void *,
14245 const void *)) streq
,
14246 NULL
, xcalloc
, xfree
);
14248 for (l
= loc
; l
!= NULL
; l
= l
->next
)
14251 const char *name
= l
->function_name
;
14253 /* Allow for some names to be NULL, ignore them. */
14257 slot
= (const char **) htab_find_slot (htab
, (const void *) name
,
14259 /* NOTE: We can assume slot != NULL here because xcalloc never
14263 htab_delete (htab
);
14269 htab_delete (htab
);
14273 /* When symbols change, it probably means the sources changed as well,
14274 and it might mean the static tracepoint markers are no longer at
14275 the same address or line numbers they used to be at last we
14276 checked. Losing your static tracepoints whenever you rebuild is
14277 undesirable. This function tries to resync/rematch gdb static
14278 tracepoints with the markers on the target, for static tracepoints
14279 that have not been set by marker id. Static tracepoint that have
14280 been set by marker id are reset by marker id in breakpoint_re_set.
14283 1) For a tracepoint set at a specific address, look for a marker at
14284 the old PC. If one is found there, assume to be the same marker.
14285 If the name / string id of the marker found is different from the
14286 previous known name, assume that means the user renamed the marker
14287 in the sources, and output a warning.
14289 2) For a tracepoint set at a given line number, look for a marker
14290 at the new address of the old line number. If one is found there,
14291 assume to be the same marker. If the name / string id of the
14292 marker found is different from the previous known name, assume that
14293 means the user renamed the marker in the sources, and output a
14296 3) If a marker is no longer found at the same address or line, it
14297 may mean the marker no longer exists. But it may also just mean
14298 the code changed a bit. Maybe the user added a few lines of code
14299 that made the marker move up or down (in line number terms). Ask
14300 the target for info about the marker with the string id as we knew
14301 it. If found, update line number and address in the matching
14302 static tracepoint. This will get confused if there's more than one
14303 marker with the same ID (possible in UST, although unadvised
14304 precisely because it confuses tools). */
14306 static struct symtab_and_line
14307 update_static_tracepoint (struct breakpoint
*b
, struct symtab_and_line sal
)
14309 struct tracepoint
*tp
= (struct tracepoint
*) b
;
14310 struct static_tracepoint_marker marker
;
14315 find_line_pc (sal
.symtab
, sal
.line
, &pc
);
14317 if (target_static_tracepoint_marker_at (pc
, &marker
))
14319 if (strcmp (tp
->static_trace_marker_id
, marker
.str_id
) != 0)
14320 warning (_("static tracepoint %d changed probed marker from %s to %s"),
14322 tp
->static_trace_marker_id
, marker
.str_id
);
14324 xfree (tp
->static_trace_marker_id
);
14325 tp
->static_trace_marker_id
= xstrdup (marker
.str_id
);
14326 release_static_tracepoint_marker (&marker
);
14331 /* Old marker wasn't found on target at lineno. Try looking it up
14333 if (!sal
.explicit_pc
14335 && sal
.symtab
!= NULL
14336 && tp
->static_trace_marker_id
!= NULL
)
14338 VEC(static_tracepoint_marker_p
) *markers
;
14341 = target_static_tracepoint_markers_by_strid (tp
->static_trace_marker_id
);
14343 if (!VEC_empty(static_tracepoint_marker_p
, markers
))
14345 struct symtab_and_line sal2
;
14346 struct symbol
*sym
;
14347 struct static_tracepoint_marker
*tpmarker
;
14348 struct ui_out
*uiout
= current_uiout
;
14350 tpmarker
= VEC_index (static_tracepoint_marker_p
, markers
, 0);
14352 xfree (tp
->static_trace_marker_id
);
14353 tp
->static_trace_marker_id
= xstrdup (tpmarker
->str_id
);
14355 warning (_("marker for static tracepoint %d (%s) not "
14356 "found at previous line number"),
14357 b
->number
, tp
->static_trace_marker_id
);
14361 sal2
.pc
= tpmarker
->address
;
14363 sal2
= find_pc_line (tpmarker
->address
, 0);
14364 sym
= find_pc_sect_function (tpmarker
->address
, NULL
);
14365 ui_out_text (uiout
, "Now in ");
14368 ui_out_field_string (uiout
, "func",
14369 SYMBOL_PRINT_NAME (sym
));
14370 ui_out_text (uiout
, " at ");
14372 ui_out_field_string (uiout
, "file",
14373 symtab_to_filename_for_display (sal2
.symtab
));
14374 ui_out_text (uiout
, ":");
14376 if (ui_out_is_mi_like_p (uiout
))
14378 const char *fullname
= symtab_to_fullname (sal2
.symtab
);
14380 ui_out_field_string (uiout
, "fullname", fullname
);
14383 ui_out_field_int (uiout
, "line", sal2
.line
);
14384 ui_out_text (uiout
, "\n");
14386 b
->loc
->line_number
= sal2
.line
;
14387 b
->loc
->symtab
= sym
!= NULL
? sal2
.symtab
: NULL
;
14389 xfree (b
->addr_string
);
14390 b
->addr_string
= xstrprintf ("%s:%d",
14391 symtab_to_filename_for_display (sal2
.symtab
),
14392 b
->loc
->line_number
);
14394 /* Might be nice to check if function changed, and warn if
14397 release_static_tracepoint_marker (tpmarker
);
14403 /* Returns 1 iff locations A and B are sufficiently same that
14404 we don't need to report breakpoint as changed. */
14407 locations_are_equal (struct bp_location
*a
, struct bp_location
*b
)
14411 if (a
->address
!= b
->address
)
14414 if (a
->shlib_disabled
!= b
->shlib_disabled
)
14417 if (a
->enabled
!= b
->enabled
)
14424 if ((a
== NULL
) != (b
== NULL
))
14430 /* Create new breakpoint locations for B (a hardware or software breakpoint)
14431 based on SALS and SALS_END. If SALS_END.NELTS is not zero, then B is
14432 a ranged breakpoint. */
14435 update_breakpoint_locations (struct breakpoint
*b
,
14436 struct symtabs_and_lines sals
,
14437 struct symtabs_and_lines sals_end
)
14440 struct bp_location
*existing_locations
= b
->loc
;
14442 if (sals_end
.nelts
!= 0 && (sals
.nelts
!= 1 || sals_end
.nelts
!= 1))
14444 /* Ranged breakpoints have only one start location and one end
14446 b
->enable_state
= bp_disabled
;
14447 update_global_location_list (UGLL_MAY_INSERT
);
14448 printf_unfiltered (_("Could not reset ranged breakpoint %d: "
14449 "multiple locations found\n"),
14454 /* If there's no new locations, and all existing locations are
14455 pending, don't do anything. This optimizes the common case where
14456 all locations are in the same shared library, that was unloaded.
14457 We'd like to retain the location, so that when the library is
14458 loaded again, we don't loose the enabled/disabled status of the
14459 individual locations. */
14460 if (all_locations_are_pending (existing_locations
) && sals
.nelts
== 0)
14465 for (i
= 0; i
< sals
.nelts
; ++i
)
14467 struct bp_location
*new_loc
;
14469 switch_to_program_space_and_thread (sals
.sals
[i
].pspace
);
14471 new_loc
= add_location_to_breakpoint (b
, &(sals
.sals
[i
]));
14473 /* Reparse conditions, they might contain references to the
14475 if (b
->cond_string
!= NULL
)
14478 volatile struct gdb_exception e
;
14480 s
= b
->cond_string
;
14481 TRY_CATCH (e
, RETURN_MASK_ERROR
)
14483 new_loc
->cond
= parse_exp_1 (&s
, sals
.sals
[i
].pc
,
14484 block_for_pc (sals
.sals
[i
].pc
),
14489 warning (_("failed to reevaluate condition "
14490 "for breakpoint %d: %s"),
14491 b
->number
, e
.message
);
14492 new_loc
->enabled
= 0;
14496 if (sals_end
.nelts
)
14498 CORE_ADDR end
= find_breakpoint_range_end (sals_end
.sals
[0]);
14500 new_loc
->length
= end
- sals
.sals
[0].pc
+ 1;
14504 /* Update locations of permanent breakpoints. */
14505 if (b
->enable_state
== bp_permanent
)
14506 make_breakpoint_permanent (b
);
14508 /* If possible, carry over 'disable' status from existing
14511 struct bp_location
*e
= existing_locations
;
14512 /* If there are multiple breakpoints with the same function name,
14513 e.g. for inline functions, comparing function names won't work.
14514 Instead compare pc addresses; this is just a heuristic as things
14515 may have moved, but in practice it gives the correct answer
14516 often enough until a better solution is found. */
14517 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
14519 for (; e
; e
= e
->next
)
14521 if (!e
->enabled
&& e
->function_name
)
14523 struct bp_location
*l
= b
->loc
;
14524 if (have_ambiguous_names
)
14526 for (; l
; l
= l
->next
)
14527 if (breakpoint_locations_match (e
, l
))
14535 for (; l
; l
= l
->next
)
14536 if (l
->function_name
14537 && strcmp (e
->function_name
, l
->function_name
) == 0)
14547 if (!locations_are_equal (existing_locations
, b
->loc
))
14548 observer_notify_breakpoint_modified (b
);
14550 update_global_location_list (UGLL_MAY_INSERT
);
14553 /* Find the SaL locations corresponding to the given ADDR_STRING.
14554 On return, FOUND will be 1 if any SaL was found, zero otherwise. */
14556 static struct symtabs_and_lines
14557 addr_string_to_sals (struct breakpoint
*b
, char *addr_string
, int *found
)
14560 struct symtabs_and_lines sals
= {0};
14561 volatile struct gdb_exception e
;
14563 gdb_assert (b
->ops
!= NULL
);
14566 TRY_CATCH (e
, RETURN_MASK_ERROR
)
14568 b
->ops
->decode_linespec (b
, &s
, &sals
);
14572 int not_found_and_ok
= 0;
14573 /* For pending breakpoints, it's expected that parsing will
14574 fail until the right shared library is loaded. User has
14575 already told to create pending breakpoints and don't need
14576 extra messages. If breakpoint is in bp_shlib_disabled
14577 state, then user already saw the message about that
14578 breakpoint being disabled, and don't want to see more
14580 if (e
.error
== NOT_FOUND_ERROR
14581 && (b
->condition_not_parsed
14582 || (b
->loc
&& b
->loc
->shlib_disabled
)
14583 || (b
->loc
&& b
->loc
->pspace
->executing_startup
)
14584 || b
->enable_state
== bp_disabled
))
14585 not_found_and_ok
= 1;
14587 if (!not_found_and_ok
)
14589 /* We surely don't want to warn about the same breakpoint
14590 10 times. One solution, implemented here, is disable
14591 the breakpoint on error. Another solution would be to
14592 have separate 'warning emitted' flag. Since this
14593 happens only when a binary has changed, I don't know
14594 which approach is better. */
14595 b
->enable_state
= bp_disabled
;
14596 throw_exception (e
);
14600 if (e
.reason
== 0 || e
.error
!= NOT_FOUND_ERROR
)
14604 for (i
= 0; i
< sals
.nelts
; ++i
)
14605 resolve_sal_pc (&sals
.sals
[i
]);
14606 if (b
->condition_not_parsed
&& s
&& s
[0])
14608 char *cond_string
, *extra_string
;
14611 find_condition_and_thread (s
, sals
.sals
[0].pc
,
14612 &cond_string
, &thread
, &task
,
14615 b
->cond_string
= cond_string
;
14616 b
->thread
= thread
;
14619 b
->extra_string
= extra_string
;
14620 b
->condition_not_parsed
= 0;
14623 if (b
->type
== bp_static_tracepoint
&& !strace_marker_p (b
))
14624 sals
.sals
[0] = update_static_tracepoint (b
, sals
.sals
[0]);
14634 /* The default re_set method, for typical hardware or software
14635 breakpoints. Reevaluate the breakpoint and recreate its
14639 breakpoint_re_set_default (struct breakpoint
*b
)
14642 struct symtabs_and_lines sals
, sals_end
;
14643 struct symtabs_and_lines expanded
= {0};
14644 struct symtabs_and_lines expanded_end
= {0};
14646 sals
= addr_string_to_sals (b
, b
->addr_string
, &found
);
14649 make_cleanup (xfree
, sals
.sals
);
14653 if (b
->addr_string_range_end
)
14655 sals_end
= addr_string_to_sals (b
, b
->addr_string_range_end
, &found
);
14658 make_cleanup (xfree
, sals_end
.sals
);
14659 expanded_end
= sals_end
;
14663 update_breakpoint_locations (b
, expanded
, expanded_end
);
14666 /* Default method for creating SALs from an address string. It basically
14667 calls parse_breakpoint_sals. Return 1 for success, zero for failure. */
14670 create_sals_from_address_default (char **arg
,
14671 struct linespec_result
*canonical
,
14672 enum bptype type_wanted
,
14673 char *addr_start
, char **copy_arg
)
14675 parse_breakpoint_sals (arg
, canonical
);
14678 /* Call create_breakpoints_sal for the given arguments. This is the default
14679 function for the `create_breakpoints_sal' method of
14683 create_breakpoints_sal_default (struct gdbarch
*gdbarch
,
14684 struct linespec_result
*canonical
,
14686 char *extra_string
,
14687 enum bptype type_wanted
,
14688 enum bpdisp disposition
,
14690 int task
, int ignore_count
,
14691 const struct breakpoint_ops
*ops
,
14692 int from_tty
, int enabled
,
14693 int internal
, unsigned flags
)
14695 create_breakpoints_sal (gdbarch
, canonical
, cond_string
,
14697 type_wanted
, disposition
,
14698 thread
, task
, ignore_count
, ops
, from_tty
,
14699 enabled
, internal
, flags
);
14702 /* Decode the line represented by S by calling decode_line_full. This is the
14703 default function for the `decode_linespec' method of breakpoint_ops. */
14706 decode_linespec_default (struct breakpoint
*b
, char **s
,
14707 struct symtabs_and_lines
*sals
)
14709 struct linespec_result canonical
;
14711 init_linespec_result (&canonical
);
14712 decode_line_full (s
, DECODE_LINE_FUNFIRSTLINE
,
14713 (struct symtab
*) NULL
, 0,
14714 &canonical
, multiple_symbols_all
,
14717 /* We should get 0 or 1 resulting SALs. */
14718 gdb_assert (VEC_length (linespec_sals
, canonical
.sals
) < 2);
14720 if (VEC_length (linespec_sals
, canonical
.sals
) > 0)
14722 struct linespec_sals
*lsal
;
14724 lsal
= VEC_index (linespec_sals
, canonical
.sals
, 0);
14725 *sals
= lsal
->sals
;
14726 /* Arrange it so the destructor does not free the
14728 lsal
->sals
.sals
= NULL
;
14731 destroy_linespec_result (&canonical
);
14734 /* Prepare the global context for a re-set of breakpoint B. */
14736 static struct cleanup
*
14737 prepare_re_set_context (struct breakpoint
*b
)
14739 struct cleanup
*cleanups
;
14741 input_radix
= b
->input_radix
;
14742 cleanups
= save_current_space_and_thread ();
14743 if (b
->pspace
!= NULL
)
14744 switch_to_program_space_and_thread (b
->pspace
);
14745 set_language (b
->language
);
14750 /* Reset a breakpoint given it's struct breakpoint * BINT.
14751 The value we return ends up being the return value from catch_errors.
14752 Unused in this case. */
14755 breakpoint_re_set_one (void *bint
)
14757 /* Get past catch_errs. */
14758 struct breakpoint
*b
= (struct breakpoint
*) bint
;
14759 struct cleanup
*cleanups
;
14761 cleanups
= prepare_re_set_context (b
);
14762 b
->ops
->re_set (b
);
14763 do_cleanups (cleanups
);
14767 /* Re-set all breakpoints after symbols have been re-loaded. */
14769 breakpoint_re_set (void)
14771 struct breakpoint
*b
, *b_tmp
;
14772 enum language save_language
;
14773 int save_input_radix
;
14774 struct cleanup
*old_chain
;
14776 save_language
= current_language
->la_language
;
14777 save_input_radix
= input_radix
;
14778 old_chain
= save_current_program_space ();
14780 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
14782 /* Format possible error msg. */
14783 char *message
= xstrprintf ("Error in re-setting breakpoint %d: ",
14785 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
14786 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
14787 do_cleanups (cleanups
);
14789 set_language (save_language
);
14790 input_radix
= save_input_radix
;
14792 jit_breakpoint_re_set ();
14794 do_cleanups (old_chain
);
14796 create_overlay_event_breakpoint ();
14797 create_longjmp_master_breakpoint ();
14798 create_std_terminate_master_breakpoint ();
14799 create_exception_master_breakpoint ();
14802 /* Reset the thread number of this breakpoint:
14804 - If the breakpoint is for all threads, leave it as-is.
14805 - Else, reset it to the current thread for inferior_ptid. */
14807 breakpoint_re_set_thread (struct breakpoint
*b
)
14809 if (b
->thread
!= -1)
14811 if (in_thread_list (inferior_ptid
))
14812 b
->thread
= pid_to_thread_id (inferior_ptid
);
14814 /* We're being called after following a fork. The new fork is
14815 selected as current, and unless this was a vfork will have a
14816 different program space from the original thread. Reset that
14818 b
->loc
->pspace
= current_program_space
;
14822 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14823 If from_tty is nonzero, it prints a message to that effect,
14824 which ends with a period (no newline). */
14827 set_ignore_count (int bptnum
, int count
, int from_tty
)
14829 struct breakpoint
*b
;
14834 ALL_BREAKPOINTS (b
)
14835 if (b
->number
== bptnum
)
14837 if (is_tracepoint (b
))
14839 if (from_tty
&& count
!= 0)
14840 printf_filtered (_("Ignore count ignored for tracepoint %d."),
14845 b
->ignore_count
= count
;
14849 printf_filtered (_("Will stop next time "
14850 "breakpoint %d is reached."),
14852 else if (count
== 1)
14853 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
14856 printf_filtered (_("Will ignore next %d "
14857 "crossings of breakpoint %d."),
14860 observer_notify_breakpoint_modified (b
);
14864 error (_("No breakpoint number %d."), bptnum
);
14867 /* Command to set ignore-count of breakpoint N to COUNT. */
14870 ignore_command (char *args
, int from_tty
)
14876 error_no_arg (_("a breakpoint number"));
14878 num
= get_number (&p
);
14880 error (_("bad breakpoint number: '%s'"), args
);
14882 error (_("Second argument (specified ignore-count) is missing."));
14884 set_ignore_count (num
,
14885 longest_to_int (value_as_long (parse_and_eval (p
))),
14888 printf_filtered ("\n");
14891 /* Call FUNCTION on each of the breakpoints
14892 whose numbers are given in ARGS. */
14895 map_breakpoint_numbers (char *args
, void (*function
) (struct breakpoint
*,
14900 struct breakpoint
*b
, *tmp
;
14902 struct get_number_or_range_state state
;
14905 error_no_arg (_("one or more breakpoint numbers"));
14907 init_number_or_range (&state
, args
);
14909 while (!state
.finished
)
14911 const char *p
= state
.string
;
14915 num
= get_number_or_range (&state
);
14918 warning (_("bad breakpoint number at or near '%s'"), p
);
14922 ALL_BREAKPOINTS_SAFE (b
, tmp
)
14923 if (b
->number
== num
)
14926 function (b
, data
);
14930 printf_unfiltered (_("No breakpoint number %d.\n"), num
);
14935 static struct bp_location
*
14936 find_location_by_number (char *number
)
14938 char *dot
= strchr (number
, '.');
14942 struct breakpoint
*b
;
14943 struct bp_location
*loc
;
14948 bp_num
= get_number (&p1
);
14950 error (_("Bad breakpoint number '%s'"), number
);
14952 ALL_BREAKPOINTS (b
)
14953 if (b
->number
== bp_num
)
14958 if (!b
|| b
->number
!= bp_num
)
14959 error (_("Bad breakpoint number '%s'"), number
);
14962 loc_num
= get_number (&p1
);
14964 error (_("Bad breakpoint location number '%s'"), number
);
14968 for (;loc_num
&& loc
; --loc_num
, loc
= loc
->next
)
14971 error (_("Bad breakpoint location number '%s'"), dot
+1);
14977 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14978 If from_tty is nonzero, it prints a message to that effect,
14979 which ends with a period (no newline). */
14982 disable_breakpoint (struct breakpoint
*bpt
)
14984 /* Never disable a watchpoint scope breakpoint; we want to
14985 hit them when we leave scope so we can delete both the
14986 watchpoint and its scope breakpoint at that time. */
14987 if (bpt
->type
== bp_watchpoint_scope
)
14990 /* You can't disable permanent breakpoints. */
14991 if (bpt
->enable_state
== bp_permanent
)
14994 bpt
->enable_state
= bp_disabled
;
14996 /* Mark breakpoint locations modified. */
14997 mark_breakpoint_modified (bpt
);
14999 if (target_supports_enable_disable_tracepoint ()
15000 && current_trace_status ()->running
&& is_tracepoint (bpt
))
15002 struct bp_location
*location
;
15004 for (location
= bpt
->loc
; location
; location
= location
->next
)
15005 target_disable_tracepoint (location
);
15008 update_global_location_list (UGLL_DONT_INSERT
);
15010 observer_notify_breakpoint_modified (bpt
);
15013 /* A callback for iterate_over_related_breakpoints. */
15016 do_disable_breakpoint (struct breakpoint
*b
, void *ignore
)
15018 disable_breakpoint (b
);
15021 /* A callback for map_breakpoint_numbers that calls
15022 disable_breakpoint. */
15025 do_map_disable_breakpoint (struct breakpoint
*b
, void *ignore
)
15027 iterate_over_related_breakpoints (b
, do_disable_breakpoint
, NULL
);
15031 disable_command (char *args
, int from_tty
)
15035 struct breakpoint
*bpt
;
15037 ALL_BREAKPOINTS (bpt
)
15038 if (user_breakpoint_p (bpt
))
15039 disable_breakpoint (bpt
);
15043 char *num
= extract_arg (&args
);
15047 if (strchr (num
, '.'))
15049 struct bp_location
*loc
= find_location_by_number (num
);
15056 mark_breakpoint_location_modified (loc
);
15058 if (target_supports_enable_disable_tracepoint ()
15059 && current_trace_status ()->running
&& loc
->owner
15060 && is_tracepoint (loc
->owner
))
15061 target_disable_tracepoint (loc
);
15063 update_global_location_list (UGLL_DONT_INSERT
);
15066 map_breakpoint_numbers (num
, do_map_disable_breakpoint
, NULL
);
15067 num
= extract_arg (&args
);
15073 enable_breakpoint_disp (struct breakpoint
*bpt
, enum bpdisp disposition
,
15076 int target_resources_ok
;
15078 if (bpt
->type
== bp_hardware_breakpoint
)
15081 i
= hw_breakpoint_used_count ();
15082 target_resources_ok
=
15083 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
15085 if (target_resources_ok
== 0)
15086 error (_("No hardware breakpoint support in the target."));
15087 else if (target_resources_ok
< 0)
15088 error (_("Hardware breakpoints used exceeds limit."));
15091 if (is_watchpoint (bpt
))
15093 /* Initialize it just to avoid a GCC false warning. */
15094 enum enable_state orig_enable_state
= 0;
15095 volatile struct gdb_exception e
;
15097 TRY_CATCH (e
, RETURN_MASK_ALL
)
15099 struct watchpoint
*w
= (struct watchpoint
*) bpt
;
15101 orig_enable_state
= bpt
->enable_state
;
15102 bpt
->enable_state
= bp_enabled
;
15103 update_watchpoint (w
, 1 /* reparse */);
15107 bpt
->enable_state
= orig_enable_state
;
15108 exception_fprintf (gdb_stderr
, e
, _("Cannot enable watchpoint %d: "),
15114 if (bpt
->enable_state
!= bp_permanent
)
15115 bpt
->enable_state
= bp_enabled
;
15117 bpt
->enable_state
= bp_enabled
;
15119 /* Mark breakpoint locations modified. */
15120 mark_breakpoint_modified (bpt
);
15122 if (target_supports_enable_disable_tracepoint ()
15123 && current_trace_status ()->running
&& is_tracepoint (bpt
))
15125 struct bp_location
*location
;
15127 for (location
= bpt
->loc
; location
; location
= location
->next
)
15128 target_enable_tracepoint (location
);
15131 bpt
->disposition
= disposition
;
15132 bpt
->enable_count
= count
;
15133 update_global_location_list (UGLL_MAY_INSERT
);
15135 observer_notify_breakpoint_modified (bpt
);
15140 enable_breakpoint (struct breakpoint
*bpt
)
15142 enable_breakpoint_disp (bpt
, bpt
->disposition
, 0);
15146 do_enable_breakpoint (struct breakpoint
*bpt
, void *arg
)
15148 enable_breakpoint (bpt
);
15151 /* A callback for map_breakpoint_numbers that calls
15152 enable_breakpoint. */
15155 do_map_enable_breakpoint (struct breakpoint
*b
, void *ignore
)
15157 iterate_over_related_breakpoints (b
, do_enable_breakpoint
, NULL
);
15160 /* The enable command enables the specified breakpoints (or all defined
15161 breakpoints) so they once again become (or continue to be) effective
15162 in stopping the inferior. */
15165 enable_command (char *args
, int from_tty
)
15169 struct breakpoint
*bpt
;
15171 ALL_BREAKPOINTS (bpt
)
15172 if (user_breakpoint_p (bpt
))
15173 enable_breakpoint (bpt
);
15177 char *num
= extract_arg (&args
);
15181 if (strchr (num
, '.'))
15183 struct bp_location
*loc
= find_location_by_number (num
);
15190 mark_breakpoint_location_modified (loc
);
15192 if (target_supports_enable_disable_tracepoint ()
15193 && current_trace_status ()->running
&& loc
->owner
15194 && is_tracepoint (loc
->owner
))
15195 target_enable_tracepoint (loc
);
15197 update_global_location_list (UGLL_MAY_INSERT
);
15200 map_breakpoint_numbers (num
, do_map_enable_breakpoint
, NULL
);
15201 num
= extract_arg (&args
);
15206 /* This struct packages up disposition data for application to multiple
15216 do_enable_breakpoint_disp (struct breakpoint
*bpt
, void *arg
)
15218 struct disp_data disp_data
= *(struct disp_data
*) arg
;
15220 enable_breakpoint_disp (bpt
, disp_data
.disp
, disp_data
.count
);
15224 do_map_enable_once_breakpoint (struct breakpoint
*bpt
, void *ignore
)
15226 struct disp_data disp
= { disp_disable
, 1 };
15228 iterate_over_related_breakpoints (bpt
, do_enable_breakpoint_disp
, &disp
);
15232 enable_once_command (char *args
, int from_tty
)
15234 map_breakpoint_numbers (args
, do_map_enable_once_breakpoint
, NULL
);
15238 do_map_enable_count_breakpoint (struct breakpoint
*bpt
, void *countptr
)
15240 struct disp_data disp
= { disp_disable
, *(int *) countptr
};
15242 iterate_over_related_breakpoints (bpt
, do_enable_breakpoint_disp
, &disp
);
15246 enable_count_command (char *args
, int from_tty
)
15248 int count
= get_number (&args
);
15250 map_breakpoint_numbers (args
, do_map_enable_count_breakpoint
, &count
);
15254 do_map_enable_delete_breakpoint (struct breakpoint
*bpt
, void *ignore
)
15256 struct disp_data disp
= { disp_del
, 1 };
15258 iterate_over_related_breakpoints (bpt
, do_enable_breakpoint_disp
, &disp
);
15262 enable_delete_command (char *args
, int from_tty
)
15264 map_breakpoint_numbers (args
, do_map_enable_delete_breakpoint
, NULL
);
15268 set_breakpoint_cmd (char *args
, int from_tty
)
15273 show_breakpoint_cmd (char *args
, int from_tty
)
15277 /* Invalidate last known value of any hardware watchpoint if
15278 the memory which that value represents has been written to by
15282 invalidate_bp_value_on_memory_change (struct inferior
*inferior
,
15283 CORE_ADDR addr
, ssize_t len
,
15284 const bfd_byte
*data
)
15286 struct breakpoint
*bp
;
15288 ALL_BREAKPOINTS (bp
)
15289 if (bp
->enable_state
== bp_enabled
15290 && bp
->type
== bp_hardware_watchpoint
)
15292 struct watchpoint
*wp
= (struct watchpoint
*) bp
;
15294 if (wp
->val_valid
&& wp
->val
)
15296 struct bp_location
*loc
;
15298 for (loc
= bp
->loc
; loc
!= NULL
; loc
= loc
->next
)
15299 if (loc
->loc_type
== bp_loc_hardware_watchpoint
15300 && loc
->address
+ loc
->length
> addr
15301 && addr
+ len
> loc
->address
)
15303 value_free (wp
->val
);
15311 /* Create and insert a breakpoint for software single step. */
15314 insert_single_step_breakpoint (struct gdbarch
*gdbarch
,
15315 struct address_space
*aspace
,
15318 struct thread_info
*tp
= inferior_thread ();
15319 struct symtab_and_line sal
;
15320 CORE_ADDR pc
= next_pc
;
15322 if (single_step_breakpoints
== NULL
)
15323 single_step_breakpoints
= new_single_step_breakpoint (tp
->num
, gdbarch
);
15325 sal
= find_pc_line (pc
, 0);
15327 sal
.section
= find_pc_overlay (pc
);
15328 sal
.explicit_pc
= 1;
15329 add_location_to_breakpoint (single_step_breakpoints
, &sal
);
15331 update_global_location_list (UGLL_INSERT
);
15334 /* Check if the breakpoints used for software single stepping
15335 were inserted or not. */
15338 single_step_breakpoints_inserted (void)
15340 return (single_step_breakpoints
!= NULL
);
15343 /* Remove and delete any breakpoints used for software single step. */
15346 remove_single_step_breakpoints (void)
15348 gdb_assert (single_step_breakpoints
!= NULL
);
15350 delete_breakpoint (single_step_breakpoints
);
15352 single_step_breakpoints
= NULL
;
15355 /* Delete software single step breakpoints without removing them from
15356 the inferior. This is intended to be used if the inferior's address
15357 space where they were inserted is already gone, e.g. after exit or
15361 cancel_single_step_breakpoints (void)
15363 /* We don't really need to (or should) delete them here. After an
15364 exit, breakpoint_init_inferior deletes it. After an exec,
15365 update_breakpoints_after_exec does it. Just clear our
15367 single_step_breakpoints
= NULL
;
15370 /* Check whether any location of BP is inserted at PC. */
15373 breakpoint_has_location_inserted_here (struct breakpoint
*bp
,
15374 struct address_space
*aspace
,
15377 struct bp_location
*loc
;
15379 for (loc
= bp
->loc
; loc
!= NULL
; loc
= loc
->next
)
15381 && breakpoint_location_address_match (loc
, aspace
, pc
))
15387 /* Check whether a software single-step breakpoint is inserted at
15391 single_step_breakpoint_inserted_here_p (struct address_space
*aspace
,
15394 return (single_step_breakpoints
!= NULL
15395 && breakpoint_has_location_inserted_here (single_step_breakpoints
,
15399 /* Returns 0 if 'bp' is NOT a syscall catchpoint,
15400 non-zero otherwise. */
15402 is_syscall_catchpoint_enabled (struct breakpoint
*bp
)
15404 if (syscall_catchpoint_p (bp
)
15405 && bp
->enable_state
!= bp_disabled
15406 && bp
->enable_state
!= bp_call_disabled
)
15413 catch_syscall_enabled (void)
15415 struct catch_syscall_inferior_data
*inf_data
15416 = get_catch_syscall_inferior_data (current_inferior ());
15418 return inf_data
->total_syscalls_count
!= 0;
15422 catching_syscall_number (int syscall_number
)
15424 struct breakpoint
*bp
;
15426 ALL_BREAKPOINTS (bp
)
15427 if (is_syscall_catchpoint_enabled (bp
))
15429 struct syscall_catchpoint
*c
= (struct syscall_catchpoint
*) bp
;
15431 if (c
->syscalls_to_be_caught
)
15435 VEC_iterate (int, c
->syscalls_to_be_caught
, i
, iter
);
15437 if (syscall_number
== iter
)
15447 /* Complete syscall names. Used by "catch syscall". */
15448 static VEC (char_ptr
) *
15449 catch_syscall_completer (struct cmd_list_element
*cmd
,
15450 const char *text
, const char *word
)
15452 const char **list
= get_syscall_names ();
15453 VEC (char_ptr
) *retlist
15454 = (list
== NULL
) ? NULL
: complete_on_enum (list
, word
, word
);
15460 /* Tracepoint-specific operations. */
15462 /* Set tracepoint count to NUM. */
15464 set_tracepoint_count (int num
)
15466 tracepoint_count
= num
;
15467 set_internalvar_integer (lookup_internalvar ("tpnum"), num
);
15471 trace_command (char *arg
, int from_tty
)
15473 struct breakpoint_ops
*ops
;
15474 const char *arg_cp
= arg
;
15476 if (arg
&& probe_linespec_to_ops (&arg_cp
))
15477 ops
= &tracepoint_probe_breakpoint_ops
;
15479 ops
= &tracepoint_breakpoint_ops
;
15481 create_breakpoint (get_current_arch (),
15483 NULL
, 0, NULL
, 1 /* parse arg */,
15485 bp_tracepoint
/* type_wanted */,
15486 0 /* Ignore count */,
15487 pending_break_support
,
15491 0 /* internal */, 0);
15495 ftrace_command (char *arg
, int from_tty
)
15497 create_breakpoint (get_current_arch (),
15499 NULL
, 0, NULL
, 1 /* parse arg */,
15501 bp_fast_tracepoint
/* type_wanted */,
15502 0 /* Ignore count */,
15503 pending_break_support
,
15504 &tracepoint_breakpoint_ops
,
15507 0 /* internal */, 0);
15510 /* strace command implementation. Creates a static tracepoint. */
15513 strace_command (char *arg
, int from_tty
)
15515 struct breakpoint_ops
*ops
;
15517 /* Decide if we are dealing with a static tracepoint marker (`-m'),
15518 or with a normal static tracepoint. */
15519 if (arg
&& strncmp (arg
, "-m", 2) == 0 && isspace (arg
[2]))
15520 ops
= &strace_marker_breakpoint_ops
;
15522 ops
= &tracepoint_breakpoint_ops
;
15524 create_breakpoint (get_current_arch (),
15526 NULL
, 0, NULL
, 1 /* parse arg */,
15528 bp_static_tracepoint
/* type_wanted */,
15529 0 /* Ignore count */,
15530 pending_break_support
,
15534 0 /* internal */, 0);
15537 /* Set up a fake reader function that gets command lines from a linked
15538 list that was acquired during tracepoint uploading. */
15540 static struct uploaded_tp
*this_utp
;
15541 static int next_cmd
;
15544 read_uploaded_action (void)
15548 VEC_iterate (char_ptr
, this_utp
->cmd_strings
, next_cmd
, rslt
);
15555 /* Given information about a tracepoint as recorded on a target (which
15556 can be either a live system or a trace file), attempt to create an
15557 equivalent GDB tracepoint. This is not a reliable process, since
15558 the target does not necessarily have all the information used when
15559 the tracepoint was originally defined. */
15561 struct tracepoint
*
15562 create_tracepoint_from_upload (struct uploaded_tp
*utp
)
15564 char *addr_str
, small_buf
[100];
15565 struct tracepoint
*tp
;
15567 if (utp
->at_string
)
15568 addr_str
= utp
->at_string
;
15571 /* In the absence of a source location, fall back to raw
15572 address. Since there is no way to confirm that the address
15573 means the same thing as when the trace was started, warn the
15575 warning (_("Uploaded tracepoint %d has no "
15576 "source location, using raw address"),
15578 xsnprintf (small_buf
, sizeof (small_buf
), "*%s", hex_string (utp
->addr
));
15579 addr_str
= small_buf
;
15582 /* There's not much we can do with a sequence of bytecodes. */
15583 if (utp
->cond
&& !utp
->cond_string
)
15584 warning (_("Uploaded tracepoint %d condition "
15585 "has no source form, ignoring it"),
15588 if (!create_breakpoint (get_current_arch (),
15590 utp
->cond_string
, -1, NULL
,
15591 0 /* parse cond/thread */,
15593 utp
->type
/* type_wanted */,
15594 0 /* Ignore count */,
15595 pending_break_support
,
15596 &tracepoint_breakpoint_ops
,
15598 utp
->enabled
/* enabled */,
15600 CREATE_BREAKPOINT_FLAGS_INSERTED
))
15603 /* Get the tracepoint we just created. */
15604 tp
= get_tracepoint (tracepoint_count
);
15605 gdb_assert (tp
!= NULL
);
15609 xsnprintf (small_buf
, sizeof (small_buf
), "%d %d", utp
->pass
,
15612 trace_pass_command (small_buf
, 0);
15615 /* If we have uploaded versions of the original commands, set up a
15616 special-purpose "reader" function and call the usual command line
15617 reader, then pass the result to the breakpoint command-setting
15619 if (!VEC_empty (char_ptr
, utp
->cmd_strings
))
15621 struct command_line
*cmd_list
;
15626 cmd_list
= read_command_lines_1 (read_uploaded_action
, 1, NULL
, NULL
);
15628 breakpoint_set_commands (&tp
->base
, cmd_list
);
15630 else if (!VEC_empty (char_ptr
, utp
->actions
)
15631 || !VEC_empty (char_ptr
, utp
->step_actions
))
15632 warning (_("Uploaded tracepoint %d actions "
15633 "have no source form, ignoring them"),
15636 /* Copy any status information that might be available. */
15637 tp
->base
.hit_count
= utp
->hit_count
;
15638 tp
->traceframe_usage
= utp
->traceframe_usage
;
15643 /* Print information on tracepoint number TPNUM_EXP, or all if
15647 tracepoints_info (char *args
, int from_tty
)
15649 struct ui_out
*uiout
= current_uiout
;
15652 num_printed
= breakpoint_1 (args
, 0, is_tracepoint
);
15654 if (num_printed
== 0)
15656 if (args
== NULL
|| *args
== '\0')
15657 ui_out_message (uiout
, 0, "No tracepoints.\n");
15659 ui_out_message (uiout
, 0, "No tracepoint matching '%s'.\n", args
);
15662 default_collect_info ();
15665 /* The 'enable trace' command enables tracepoints.
15666 Not supported by all targets. */
15668 enable_trace_command (char *args
, int from_tty
)
15670 enable_command (args
, from_tty
);
15673 /* The 'disable trace' command disables tracepoints.
15674 Not supported by all targets. */
15676 disable_trace_command (char *args
, int from_tty
)
15678 disable_command (args
, from_tty
);
15681 /* Remove a tracepoint (or all if no argument). */
15683 delete_trace_command (char *arg
, int from_tty
)
15685 struct breakpoint
*b
, *b_tmp
;
15691 int breaks_to_delete
= 0;
15693 /* Delete all breakpoints if no argument.
15694 Do not delete internal or call-dummy breakpoints, these
15695 have to be deleted with an explicit breakpoint number
15697 ALL_TRACEPOINTS (b
)
15698 if (is_tracepoint (b
) && user_breakpoint_p (b
))
15700 breaks_to_delete
= 1;
15704 /* Ask user only if there are some breakpoints to delete. */
15706 || (breaks_to_delete
&& query (_("Delete all tracepoints? "))))
15708 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
15709 if (is_tracepoint (b
) && user_breakpoint_p (b
))
15710 delete_breakpoint (b
);
15714 map_breakpoint_numbers (arg
, do_map_delete_breakpoint
, NULL
);
15717 /* Helper function for trace_pass_command. */
15720 trace_pass_set_count (struct tracepoint
*tp
, int count
, int from_tty
)
15722 tp
->pass_count
= count
;
15723 observer_notify_breakpoint_modified (&tp
->base
);
15725 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
15726 tp
->base
.number
, count
);
15729 /* Set passcount for tracepoint.
15731 First command argument is passcount, second is tracepoint number.
15732 If tracepoint number omitted, apply to most recently defined.
15733 Also accepts special argument "all". */
15736 trace_pass_command (char *args
, int from_tty
)
15738 struct tracepoint
*t1
;
15739 unsigned int count
;
15741 if (args
== 0 || *args
== 0)
15742 error (_("passcount command requires an "
15743 "argument (count + optional TP num)"));
15745 count
= strtoul (args
, &args
, 10); /* Count comes first, then TP num. */
15747 args
= skip_spaces (args
);
15748 if (*args
&& strncasecmp (args
, "all", 3) == 0)
15750 struct breakpoint
*b
;
15752 args
+= 3; /* Skip special argument "all". */
15754 error (_("Junk at end of arguments."));
15756 ALL_TRACEPOINTS (b
)
15758 t1
= (struct tracepoint
*) b
;
15759 trace_pass_set_count (t1
, count
, from_tty
);
15762 else if (*args
== '\0')
15764 t1
= get_tracepoint_by_number (&args
, NULL
);
15766 trace_pass_set_count (t1
, count
, from_tty
);
15770 struct get_number_or_range_state state
;
15772 init_number_or_range (&state
, args
);
15773 while (!state
.finished
)
15775 t1
= get_tracepoint_by_number (&args
, &state
);
15777 trace_pass_set_count (t1
, count
, from_tty
);
15782 struct tracepoint
*
15783 get_tracepoint (int num
)
15785 struct breakpoint
*t
;
15787 ALL_TRACEPOINTS (t
)
15788 if (t
->number
== num
)
15789 return (struct tracepoint
*) t
;
15794 /* Find the tracepoint with the given target-side number (which may be
15795 different from the tracepoint number after disconnecting and
15798 struct tracepoint
*
15799 get_tracepoint_by_number_on_target (int num
)
15801 struct breakpoint
*b
;
15803 ALL_TRACEPOINTS (b
)
15805 struct tracepoint
*t
= (struct tracepoint
*) b
;
15807 if (t
->number_on_target
== num
)
15814 /* Utility: parse a tracepoint number and look it up in the list.
15815 If STATE is not NULL, use, get_number_or_range_state and ignore ARG.
15816 If the argument is missing, the most recent tracepoint
15817 (tracepoint_count) is returned. */
15819 struct tracepoint
*
15820 get_tracepoint_by_number (char **arg
,
15821 struct get_number_or_range_state
*state
)
15823 struct breakpoint
*t
;
15825 char *instring
= arg
== NULL
? NULL
: *arg
;
15829 gdb_assert (!state
->finished
);
15830 tpnum
= get_number_or_range (state
);
15832 else if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
15833 tpnum
= tracepoint_count
;
15835 tpnum
= get_number (arg
);
15839 if (instring
&& *instring
)
15840 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
15843 printf_filtered (_("No previous tracepoint\n"));
15847 ALL_TRACEPOINTS (t
)
15848 if (t
->number
== tpnum
)
15850 return (struct tracepoint
*) t
;
15853 printf_unfiltered ("No tracepoint number %d.\n", tpnum
);
15858 print_recreate_thread (struct breakpoint
*b
, struct ui_file
*fp
)
15860 if (b
->thread
!= -1)
15861 fprintf_unfiltered (fp
, " thread %d", b
->thread
);
15864 fprintf_unfiltered (fp
, " task %d", b
->task
);
15866 fprintf_unfiltered (fp
, "\n");
15869 /* Save information on user settable breakpoints (watchpoints, etc) to
15870 a new script file named FILENAME. If FILTER is non-NULL, call it
15871 on each breakpoint and only include the ones for which it returns
15875 save_breakpoints (char *filename
, int from_tty
,
15876 int (*filter
) (const struct breakpoint
*))
15878 struct breakpoint
*tp
;
15880 struct cleanup
*cleanup
;
15881 struct ui_file
*fp
;
15882 int extra_trace_bits
= 0;
15884 if (filename
== 0 || *filename
== 0)
15885 error (_("Argument required (file name in which to save)"));
15887 /* See if we have anything to save. */
15888 ALL_BREAKPOINTS (tp
)
15890 /* Skip internal and momentary breakpoints. */
15891 if (!user_breakpoint_p (tp
))
15894 /* If we have a filter, only save the breakpoints it accepts. */
15895 if (filter
&& !filter (tp
))
15900 if (is_tracepoint (tp
))
15902 extra_trace_bits
= 1;
15904 /* We can stop searching. */
15911 warning (_("Nothing to save."));
15915 filename
= tilde_expand (filename
);
15916 cleanup
= make_cleanup (xfree
, filename
);
15917 fp
= gdb_fopen (filename
, "w");
15919 error (_("Unable to open file '%s' for saving (%s)"),
15920 filename
, safe_strerror (errno
));
15921 make_cleanup_ui_file_delete (fp
);
15923 if (extra_trace_bits
)
15924 save_trace_state_variables (fp
);
15926 ALL_BREAKPOINTS (tp
)
15928 /* Skip internal and momentary breakpoints. */
15929 if (!user_breakpoint_p (tp
))
15932 /* If we have a filter, only save the breakpoints it accepts. */
15933 if (filter
&& !filter (tp
))
15936 tp
->ops
->print_recreate (tp
, fp
);
15938 /* Note, we can't rely on tp->number for anything, as we can't
15939 assume the recreated breakpoint numbers will match. Use $bpnum
15942 if (tp
->cond_string
)
15943 fprintf_unfiltered (fp
, " condition $bpnum %s\n", tp
->cond_string
);
15945 if (tp
->ignore_count
)
15946 fprintf_unfiltered (fp
, " ignore $bpnum %d\n", tp
->ignore_count
);
15948 if (tp
->type
!= bp_dprintf
&& tp
->commands
)
15950 volatile struct gdb_exception ex
;
15952 fprintf_unfiltered (fp
, " commands\n");
15954 ui_out_redirect (current_uiout
, fp
);
15955 TRY_CATCH (ex
, RETURN_MASK_ALL
)
15957 print_command_lines (current_uiout
, tp
->commands
->commands
, 2);
15959 ui_out_redirect (current_uiout
, NULL
);
15962 throw_exception (ex
);
15964 fprintf_unfiltered (fp
, " end\n");
15967 if (tp
->enable_state
== bp_disabled
)
15968 fprintf_unfiltered (fp
, "disable $bpnum\n");
15970 /* If this is a multi-location breakpoint, check if the locations
15971 should be individually disabled. Watchpoint locations are
15972 special, and not user visible. */
15973 if (!is_watchpoint (tp
) && tp
->loc
&& tp
->loc
->next
)
15975 struct bp_location
*loc
;
15978 for (loc
= tp
->loc
; loc
!= NULL
; loc
= loc
->next
, n
++)
15980 fprintf_unfiltered (fp
, "disable $bpnum.%d\n", n
);
15984 if (extra_trace_bits
&& *default_collect
)
15985 fprintf_unfiltered (fp
, "set default-collect %s\n", default_collect
);
15988 printf_filtered (_("Saved to file '%s'.\n"), filename
);
15989 do_cleanups (cleanup
);
15992 /* The `save breakpoints' command. */
15995 save_breakpoints_command (char *args
, int from_tty
)
15997 save_breakpoints (args
, from_tty
, NULL
);
16000 /* The `save tracepoints' command. */
16003 save_tracepoints_command (char *args
, int from_tty
)
16005 save_breakpoints (args
, from_tty
, is_tracepoint
);
16008 /* Create a vector of all tracepoints. */
16010 VEC(breakpoint_p
) *
16011 all_tracepoints (void)
16013 VEC(breakpoint_p
) *tp_vec
= 0;
16014 struct breakpoint
*tp
;
16016 ALL_TRACEPOINTS (tp
)
16018 VEC_safe_push (breakpoint_p
, tp_vec
, tp
);
16025 /* This help string is used for the break, hbreak, tbreak and thbreak
16026 commands. It is defined as a macro to prevent duplication.
16027 COMMAND should be a string constant containing the name of the
16029 #define BREAK_ARGS_HELP(command) \
16030 command" [PROBE_MODIFIER] [LOCATION] [thread THREADNUM] [if CONDITION]\n\
16031 PROBE_MODIFIER shall be present if the command is to be placed in a\n\
16032 probe point. Accepted values are `-probe' (for a generic, automatically\n\
16033 guessed probe type) or `-probe-stap' (for a SystemTap probe).\n\
16034 LOCATION may be a line number, function name, or \"*\" and an address.\n\
16035 If a line number is specified, break at start of code for that line.\n\
16036 If a function is specified, break at start of code for that function.\n\
16037 If an address is specified, break at that exact address.\n\
16038 With no LOCATION, uses current execution address of the selected\n\
16039 stack frame. This is useful for breaking on return to a stack frame.\n\
16041 THREADNUM is the number from \"info threads\".\n\
16042 CONDITION is a boolean expression.\n\
16044 Multiple breakpoints at one place are permitted, and useful if their\n\
16045 conditions are different.\n\
16047 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
16049 /* List of subcommands for "catch". */
16050 static struct cmd_list_element
*catch_cmdlist
;
16052 /* List of subcommands for "tcatch". */
16053 static struct cmd_list_element
*tcatch_cmdlist
;
16056 add_catch_command (char *name
, char *docstring
,
16057 cmd_sfunc_ftype
*sfunc
,
16058 completer_ftype
*completer
,
16059 void *user_data_catch
,
16060 void *user_data_tcatch
)
16062 struct cmd_list_element
*command
;
16064 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
16066 set_cmd_sfunc (command
, sfunc
);
16067 set_cmd_context (command
, user_data_catch
);
16068 set_cmd_completer (command
, completer
);
16070 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
16072 set_cmd_sfunc (command
, sfunc
);
16073 set_cmd_context (command
, user_data_tcatch
);
16074 set_cmd_completer (command
, completer
);
16078 clear_syscall_counts (struct inferior
*inf
)
16080 struct catch_syscall_inferior_data
*inf_data
16081 = get_catch_syscall_inferior_data (inf
);
16083 inf_data
->total_syscalls_count
= 0;
16084 inf_data
->any_syscall_count
= 0;
16085 VEC_free (int, inf_data
->syscalls_counts
);
16089 save_command (char *arg
, int from_tty
)
16091 printf_unfiltered (_("\"save\" must be followed by "
16092 "the name of a save subcommand.\n"));
16093 help_list (save_cmdlist
, "save ", all_commands
, gdb_stdout
);
16096 struct breakpoint
*
16097 iterate_over_breakpoints (int (*callback
) (struct breakpoint
*, void *),
16100 struct breakpoint
*b
, *b_tmp
;
16102 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
16104 if ((*callback
) (b
, data
))
16111 /* Zero if any of the breakpoint's locations could be a location where
16112 functions have been inlined, nonzero otherwise. */
16115 is_non_inline_function (struct breakpoint
*b
)
16117 /* The shared library event breakpoint is set on the address of a
16118 non-inline function. */
16119 if (b
->type
== bp_shlib_event
)
16125 /* Nonzero if the specified PC cannot be a location where functions
16126 have been inlined. */
16129 pc_at_non_inline_function (struct address_space
*aspace
, CORE_ADDR pc
,
16130 const struct target_waitstatus
*ws
)
16132 struct breakpoint
*b
;
16133 struct bp_location
*bl
;
16135 ALL_BREAKPOINTS (b
)
16137 if (!is_non_inline_function (b
))
16140 for (bl
= b
->loc
; bl
!= NULL
; bl
= bl
->next
)
16142 if (!bl
->shlib_disabled
16143 && bpstat_check_location (bl
, aspace
, pc
, ws
))
16151 /* Remove any references to OBJFILE which is going to be freed. */
16154 breakpoint_free_objfile (struct objfile
*objfile
)
16156 struct bp_location
**locp
, *loc
;
16158 ALL_BP_LOCATIONS (loc
, locp
)
16159 if (loc
->symtab
!= NULL
&& loc
->symtab
->objfile
== objfile
)
16160 loc
->symtab
= NULL
;
16164 initialize_breakpoint_ops (void)
16166 static int initialized
= 0;
16168 struct breakpoint_ops
*ops
;
16174 /* The breakpoint_ops structure to be inherit by all kinds of
16175 breakpoints (real breakpoints, i.e., user "break" breakpoints,
16176 internal and momentary breakpoints, etc.). */
16177 ops
= &bkpt_base_breakpoint_ops
;
16178 *ops
= base_breakpoint_ops
;
16179 ops
->re_set
= bkpt_re_set
;
16180 ops
->insert_location
= bkpt_insert_location
;
16181 ops
->remove_location
= bkpt_remove_location
;
16182 ops
->breakpoint_hit
= bkpt_breakpoint_hit
;
16183 ops
->create_sals_from_address
= bkpt_create_sals_from_address
;
16184 ops
->create_breakpoints_sal
= bkpt_create_breakpoints_sal
;
16185 ops
->decode_linespec
= bkpt_decode_linespec
;
16187 /* The breakpoint_ops structure to be used in regular breakpoints. */
16188 ops
= &bkpt_breakpoint_ops
;
16189 *ops
= bkpt_base_breakpoint_ops
;
16190 ops
->re_set
= bkpt_re_set
;
16191 ops
->resources_needed
= bkpt_resources_needed
;
16192 ops
->print_it
= bkpt_print_it
;
16193 ops
->print_mention
= bkpt_print_mention
;
16194 ops
->print_recreate
= bkpt_print_recreate
;
16196 /* Ranged breakpoints. */
16197 ops
= &ranged_breakpoint_ops
;
16198 *ops
= bkpt_breakpoint_ops
;
16199 ops
->breakpoint_hit
= breakpoint_hit_ranged_breakpoint
;
16200 ops
->resources_needed
= resources_needed_ranged_breakpoint
;
16201 ops
->print_it
= print_it_ranged_breakpoint
;
16202 ops
->print_one
= print_one_ranged_breakpoint
;
16203 ops
->print_one_detail
= print_one_detail_ranged_breakpoint
;
16204 ops
->print_mention
= print_mention_ranged_breakpoint
;
16205 ops
->print_recreate
= print_recreate_ranged_breakpoint
;
16207 /* Internal breakpoints. */
16208 ops
= &internal_breakpoint_ops
;
16209 *ops
= bkpt_base_breakpoint_ops
;
16210 ops
->re_set
= internal_bkpt_re_set
;
16211 ops
->check_status
= internal_bkpt_check_status
;
16212 ops
->print_it
= internal_bkpt_print_it
;
16213 ops
->print_mention
= internal_bkpt_print_mention
;
16215 /* Momentary breakpoints. */
16216 ops
= &momentary_breakpoint_ops
;
16217 *ops
= bkpt_base_breakpoint_ops
;
16218 ops
->re_set
= momentary_bkpt_re_set
;
16219 ops
->check_status
= momentary_bkpt_check_status
;
16220 ops
->print_it
= momentary_bkpt_print_it
;
16221 ops
->print_mention
= momentary_bkpt_print_mention
;
16223 /* Momentary breakpoints for bp_longjmp and bp_exception. */
16224 ops
= &longjmp_breakpoint_ops
;
16225 *ops
= momentary_breakpoint_ops
;
16226 ops
->dtor
= longjmp_bkpt_dtor
;
16228 /* Probe breakpoints. */
16229 ops
= &bkpt_probe_breakpoint_ops
;
16230 *ops
= bkpt_breakpoint_ops
;
16231 ops
->insert_location
= bkpt_probe_insert_location
;
16232 ops
->remove_location
= bkpt_probe_remove_location
;
16233 ops
->create_sals_from_address
= bkpt_probe_create_sals_from_address
;
16234 ops
->decode_linespec
= bkpt_probe_decode_linespec
;
16237 ops
= &watchpoint_breakpoint_ops
;
16238 *ops
= base_breakpoint_ops
;
16239 ops
->dtor
= dtor_watchpoint
;
16240 ops
->re_set
= re_set_watchpoint
;
16241 ops
->insert_location
= insert_watchpoint
;
16242 ops
->remove_location
= remove_watchpoint
;
16243 ops
->breakpoint_hit
= breakpoint_hit_watchpoint
;
16244 ops
->check_status
= check_status_watchpoint
;
16245 ops
->resources_needed
= resources_needed_watchpoint
;
16246 ops
->works_in_software_mode
= works_in_software_mode_watchpoint
;
16247 ops
->print_it
= print_it_watchpoint
;
16248 ops
->print_mention
= print_mention_watchpoint
;
16249 ops
->print_recreate
= print_recreate_watchpoint
;
16250 ops
->explains_signal
= explains_signal_watchpoint
;
16252 /* Masked watchpoints. */
16253 ops
= &masked_watchpoint_breakpoint_ops
;
16254 *ops
= watchpoint_breakpoint_ops
;
16255 ops
->insert_location
= insert_masked_watchpoint
;
16256 ops
->remove_location
= remove_masked_watchpoint
;
16257 ops
->resources_needed
= resources_needed_masked_watchpoint
;
16258 ops
->works_in_software_mode
= works_in_software_mode_masked_watchpoint
;
16259 ops
->print_it
= print_it_masked_watchpoint
;
16260 ops
->print_one_detail
= print_one_detail_masked_watchpoint
;
16261 ops
->print_mention
= print_mention_masked_watchpoint
;
16262 ops
->print_recreate
= print_recreate_masked_watchpoint
;
16265 ops
= &tracepoint_breakpoint_ops
;
16266 *ops
= base_breakpoint_ops
;
16267 ops
->re_set
= tracepoint_re_set
;
16268 ops
->breakpoint_hit
= tracepoint_breakpoint_hit
;
16269 ops
->print_one_detail
= tracepoint_print_one_detail
;
16270 ops
->print_mention
= tracepoint_print_mention
;
16271 ops
->print_recreate
= tracepoint_print_recreate
;
16272 ops
->create_sals_from_address
= tracepoint_create_sals_from_address
;
16273 ops
->create_breakpoints_sal
= tracepoint_create_breakpoints_sal
;
16274 ops
->decode_linespec
= tracepoint_decode_linespec
;
16276 /* Probe tracepoints. */
16277 ops
= &tracepoint_probe_breakpoint_ops
;
16278 *ops
= tracepoint_breakpoint_ops
;
16279 ops
->create_sals_from_address
= tracepoint_probe_create_sals_from_address
;
16280 ops
->decode_linespec
= tracepoint_probe_decode_linespec
;
16282 /* Static tracepoints with marker (`-m'). */
16283 ops
= &strace_marker_breakpoint_ops
;
16284 *ops
= tracepoint_breakpoint_ops
;
16285 ops
->create_sals_from_address
= strace_marker_create_sals_from_address
;
16286 ops
->create_breakpoints_sal
= strace_marker_create_breakpoints_sal
;
16287 ops
->decode_linespec
= strace_marker_decode_linespec
;
16289 /* Fork catchpoints. */
16290 ops
= &catch_fork_breakpoint_ops
;
16291 *ops
= base_breakpoint_ops
;
16292 ops
->insert_location
= insert_catch_fork
;
16293 ops
->remove_location
= remove_catch_fork
;
16294 ops
->breakpoint_hit
= breakpoint_hit_catch_fork
;
16295 ops
->print_it
= print_it_catch_fork
;
16296 ops
->print_one
= print_one_catch_fork
;
16297 ops
->print_mention
= print_mention_catch_fork
;
16298 ops
->print_recreate
= print_recreate_catch_fork
;
16300 /* Vfork catchpoints. */
16301 ops
= &catch_vfork_breakpoint_ops
;
16302 *ops
= base_breakpoint_ops
;
16303 ops
->insert_location
= insert_catch_vfork
;
16304 ops
->remove_location
= remove_catch_vfork
;
16305 ops
->breakpoint_hit
= breakpoint_hit_catch_vfork
;
16306 ops
->print_it
= print_it_catch_vfork
;
16307 ops
->print_one
= print_one_catch_vfork
;
16308 ops
->print_mention
= print_mention_catch_vfork
;
16309 ops
->print_recreate
= print_recreate_catch_vfork
;
16311 /* Exec catchpoints. */
16312 ops
= &catch_exec_breakpoint_ops
;
16313 *ops
= base_breakpoint_ops
;
16314 ops
->dtor
= dtor_catch_exec
;
16315 ops
->insert_location
= insert_catch_exec
;
16316 ops
->remove_location
= remove_catch_exec
;
16317 ops
->breakpoint_hit
= breakpoint_hit_catch_exec
;
16318 ops
->print_it
= print_it_catch_exec
;
16319 ops
->print_one
= print_one_catch_exec
;
16320 ops
->print_mention
= print_mention_catch_exec
;
16321 ops
->print_recreate
= print_recreate_catch_exec
;
16323 /* Syscall catchpoints. */
16324 ops
= &catch_syscall_breakpoint_ops
;
16325 *ops
= base_breakpoint_ops
;
16326 ops
->dtor
= dtor_catch_syscall
;
16327 ops
->insert_location
= insert_catch_syscall
;
16328 ops
->remove_location
= remove_catch_syscall
;
16329 ops
->breakpoint_hit
= breakpoint_hit_catch_syscall
;
16330 ops
->print_it
= print_it_catch_syscall
;
16331 ops
->print_one
= print_one_catch_syscall
;
16332 ops
->print_mention
= print_mention_catch_syscall
;
16333 ops
->print_recreate
= print_recreate_catch_syscall
;
16335 /* Solib-related catchpoints. */
16336 ops
= &catch_solib_breakpoint_ops
;
16337 *ops
= base_breakpoint_ops
;
16338 ops
->dtor
= dtor_catch_solib
;
16339 ops
->insert_location
= insert_catch_solib
;
16340 ops
->remove_location
= remove_catch_solib
;
16341 ops
->breakpoint_hit
= breakpoint_hit_catch_solib
;
16342 ops
->check_status
= check_status_catch_solib
;
16343 ops
->print_it
= print_it_catch_solib
;
16344 ops
->print_one
= print_one_catch_solib
;
16345 ops
->print_mention
= print_mention_catch_solib
;
16346 ops
->print_recreate
= print_recreate_catch_solib
;
16348 ops
= &dprintf_breakpoint_ops
;
16349 *ops
= bkpt_base_breakpoint_ops
;
16350 ops
->re_set
= dprintf_re_set
;
16351 ops
->resources_needed
= bkpt_resources_needed
;
16352 ops
->print_it
= bkpt_print_it
;
16353 ops
->print_mention
= bkpt_print_mention
;
16354 ops
->print_recreate
= dprintf_print_recreate
;
16355 ops
->after_condition_true
= dprintf_after_condition_true
;
16356 ops
->breakpoint_hit
= dprintf_breakpoint_hit
;
16359 /* Chain containing all defined "enable breakpoint" subcommands. */
16361 static struct cmd_list_element
*enablebreaklist
= NULL
;
16364 _initialize_breakpoint (void)
16366 struct cmd_list_element
*c
;
16368 initialize_breakpoint_ops ();
16370 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
16371 observer_attach_free_objfile (disable_breakpoints_in_freed_objfile
);
16372 observer_attach_inferior_exit (clear_syscall_counts
);
16373 observer_attach_memory_changed (invalidate_bp_value_on_memory_change
);
16375 breakpoint_objfile_key
16376 = register_objfile_data_with_cleanup (NULL
, free_breakpoint_probes
);
16378 catch_syscall_inferior_data
16379 = register_inferior_data_with_cleanup (NULL
,
16380 catch_syscall_inferior_data_cleanup
);
16382 breakpoint_chain
= 0;
16383 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
16384 before a breakpoint is set. */
16385 breakpoint_count
= 0;
16387 tracepoint_count
= 0;
16389 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
16390 Set ignore-count of breakpoint number N to COUNT.\n\
16391 Usage is `ignore N COUNT'."));
16393 add_com_alias ("bc", "ignore", class_breakpoint
, 1);
16395 add_com ("commands", class_breakpoint
, commands_command
, _("\
16396 Set commands to be executed when a breakpoint is hit.\n\
16397 Give breakpoint number as argument after \"commands\".\n\
16398 With no argument, the targeted breakpoint is the last one set.\n\
16399 The commands themselves follow starting on the next line.\n\
16400 Type a line containing \"end\" to indicate the end of them.\n\
16401 Give \"silent\" as the first line to make the breakpoint silent;\n\
16402 then no output is printed when it is hit, except what the commands print."));
16404 c
= add_com ("condition", class_breakpoint
, condition_command
, _("\
16405 Specify breakpoint number N to break only if COND is true.\n\
16406 Usage is `condition N COND', where N is an integer and COND is an\n\
16407 expression to be evaluated whenever breakpoint N is reached."));
16408 set_cmd_completer (c
, condition_completer
);
16410 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
16411 Set a temporary breakpoint.\n\
16412 Like \"break\" except the breakpoint is only temporary,\n\
16413 so it will be deleted when hit. Equivalent to \"break\" followed\n\
16414 by using \"enable delete\" on the breakpoint number.\n\
16416 BREAK_ARGS_HELP ("tbreak")));
16417 set_cmd_completer (c
, location_completer
);
16419 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
16420 Set a hardware assisted breakpoint.\n\
16421 Like \"break\" except the breakpoint requires hardware support,\n\
16422 some target hardware may not have this support.\n\
16424 BREAK_ARGS_HELP ("hbreak")));
16425 set_cmd_completer (c
, location_completer
);
16427 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
16428 Set a temporary hardware assisted breakpoint.\n\
16429 Like \"hbreak\" except the breakpoint is only temporary,\n\
16430 so it will be deleted when hit.\n\
16432 BREAK_ARGS_HELP ("thbreak")));
16433 set_cmd_completer (c
, location_completer
);
16435 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
16436 Enable some breakpoints.\n\
16437 Give breakpoint numbers (separated by spaces) as arguments.\n\
16438 With no subcommand, breakpoints are enabled until you command otherwise.\n\
16439 This is used to cancel the effect of the \"disable\" command.\n\
16440 With a subcommand you can enable temporarily."),
16441 &enablelist
, "enable ", 1, &cmdlist
);
16443 add_com ("ab", class_breakpoint
, enable_command
, _("\
16444 Enable some breakpoints.\n\
16445 Give breakpoint numbers (separated by spaces) as arguments.\n\
16446 With no subcommand, breakpoints are enabled until you command otherwise.\n\
16447 This is used to cancel the effect of the \"disable\" command.\n\
16448 With a subcommand you can enable temporarily."));
16450 add_com_alias ("en", "enable", class_breakpoint
, 1);
16452 add_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
16453 Enable some breakpoints.\n\
16454 Give breakpoint numbers (separated by spaces) as arguments.\n\
16455 This is used to cancel the effect of the \"disable\" command.\n\
16456 May be abbreviated to simply \"enable\".\n"),
16457 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
16459 add_cmd ("once", no_class
, enable_once_command
, _("\
16460 Enable breakpoints for one hit. Give breakpoint numbers.\n\
16461 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
16464 add_cmd ("delete", no_class
, enable_delete_command
, _("\
16465 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
16466 If a breakpoint is hit while enabled in this fashion, it is deleted."),
16469 add_cmd ("count", no_class
, enable_count_command
, _("\
16470 Enable breakpoints for COUNT hits. Give count and then breakpoint numbers.\n\
16471 If a breakpoint is hit while enabled in this fashion,\n\
16472 the count is decremented; when it reaches zero, the breakpoint is disabled."),
16475 add_cmd ("delete", no_class
, enable_delete_command
, _("\
16476 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
16477 If a breakpoint is hit while enabled in this fashion, it is deleted."),
16480 add_cmd ("once", no_class
, enable_once_command
, _("\
16481 Enable breakpoints for one hit. Give breakpoint numbers.\n\
16482 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
16485 add_cmd ("count", no_class
, enable_count_command
, _("\
16486 Enable breakpoints for COUNT hits. Give count and then breakpoint numbers.\n\
16487 If a breakpoint is hit while enabled in this fashion,\n\
16488 the count is decremented; when it reaches zero, the breakpoint is disabled."),
16491 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
16492 Disable some breakpoints.\n\
16493 Arguments are breakpoint numbers with spaces in between.\n\
16494 To disable all breakpoints, give no argument.\n\
16495 A disabled breakpoint is not forgotten, but has no effect until re-enabled."),
16496 &disablelist
, "disable ", 1, &cmdlist
);
16497 add_com_alias ("dis", "disable", class_breakpoint
, 1);
16498 add_com_alias ("disa", "disable", class_breakpoint
, 1);
16500 add_com ("sb", class_breakpoint
, disable_command
, _("\
16501 Disable some breakpoints.\n\
16502 Arguments are breakpoint numbers with spaces in between.\n\
16503 To disable all breakpoints, give no argument.\n\
16504 A disabled breakpoint is not forgotten, but has no effect until re-enabled."));
16506 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
16507 Disable some breakpoints.\n\
16508 Arguments are breakpoint numbers with spaces in between.\n\
16509 To disable all breakpoints, give no argument.\n\
16510 A disabled breakpoint is not forgotten, but has no effect until re-enabled.\n\
16511 This command may be abbreviated \"disable\"."),
16514 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
16515 Delete some breakpoints or auto-display expressions.\n\
16516 Arguments are breakpoint numbers with spaces in between.\n\
16517 To delete all breakpoints, give no argument.\n\
16519 Also a prefix command for deletion of other GDB objects.\n\
16520 The \"unset\" command is also an alias for \"delete\"."),
16521 &deletelist
, "delete ", 1, &cmdlist
);
16522 add_com_alias ("d", "delete", class_breakpoint
, 1);
16523 add_com_alias ("del", "delete", class_breakpoint
, 1);
16525 add_com ("db", class_breakpoint
, delete_command
, _("\
16526 Delete some breakpoints.\n\
16527 Arguments are breakpoint numbers with spaces in between.\n\
16528 To delete all breakpoints, give no argument.\n"));
16530 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
16531 Delete some breakpoints or auto-display expressions.\n\
16532 Arguments are breakpoint numbers with spaces in between.\n\
16533 To delete all breakpoints, give no argument.\n\
16534 This command may be abbreviated \"delete\"."),
16537 add_com ("clear", class_breakpoint
, clear_command
, _("\
16538 Clear breakpoint at specified line or function.\n\
16539 Argument may be line number, function name, or \"*\" and an address.\n\
16540 If line number is specified, all breakpoints in that line are cleared.\n\
16541 If function is specified, breakpoints at beginning of function are cleared.\n\
16542 If an address is specified, breakpoints at that address are cleared.\n\
16544 With no argument, clears all breakpoints in the line that the selected frame\n\
16545 is executing in.\n\
16547 See also the \"delete\" command which clears breakpoints by number."));
16548 add_com_alias ("cl", "clear", class_breakpoint
, 1);
16550 c
= add_com ("break", class_breakpoint
, break_command
, _("\
16551 Set breakpoint at specified line or function.\n"
16552 BREAK_ARGS_HELP ("break")));
16553 set_cmd_completer (c
, location_completer
);
16555 add_com_alias ("b", "break", class_run
, 1);
16556 add_com_alias ("br", "break", class_run
, 1);
16557 add_com_alias ("bre", "break", class_run
, 1);
16558 add_com_alias ("brea", "break", class_run
, 1);
16561 add_com_alias ("ba", "break", class_breakpoint
, 1);
16565 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
16566 Break in function/address or break at a line in the current file."),
16567 &stoplist
, "stop ", 1, &cmdlist
);
16568 add_cmd ("in", class_breakpoint
, stopin_command
,
16569 _("Break in function or address."), &stoplist
);
16570 add_cmd ("at", class_breakpoint
, stopat_command
,
16571 _("Break at a line in the current file."), &stoplist
);
16572 add_com ("status", class_info
, breakpoints_info
, _("\
16573 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
16574 The \"Type\" column indicates one of:\n\
16575 \tbreakpoint - normal breakpoint\n\
16576 \twatchpoint - watchpoint\n\
16577 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
16578 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
16579 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
16580 address and file/line number respectively.\n\
16582 Convenience variable \"$_\" and default examine address for \"x\"\n\
16583 are set to the address of the last breakpoint listed unless the command\n\
16584 is prefixed with \"server \".\n\n\
16585 Convenience variable \"$bpnum\" contains the number of the last\n\
16586 breakpoint set."));
16589 add_info ("breakpoints", breakpoints_info
, _("\
16590 Status of specified breakpoints (all user-settable breakpoints if no argument).\n\
16591 The \"Type\" column indicates one of:\n\
16592 \tbreakpoint - normal breakpoint\n\
16593 \twatchpoint - watchpoint\n\
16594 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
16595 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
16596 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
16597 address and file/line number respectively.\n\
16599 Convenience variable \"$_\" and default examine address for \"x\"\n\
16600 are set to the address of the last breakpoint listed unless the command\n\
16601 is prefixed with \"server \".\n\n\
16602 Convenience variable \"$bpnum\" contains the number of the last\n\
16603 breakpoint set."));
16605 add_info_alias ("b", "breakpoints", 1);
16608 add_com ("lb", class_breakpoint
, breakpoints_info
, _("\
16609 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
16610 The \"Type\" column indicates one of:\n\
16611 \tbreakpoint - normal breakpoint\n\
16612 \twatchpoint - watchpoint\n\
16613 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
16614 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
16615 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
16616 address and file/line number respectively.\n\
16618 Convenience variable \"$_\" and default examine address for \"x\"\n\
16619 are set to the address of the last breakpoint listed unless the command\n\
16620 is prefixed with \"server \".\n\n\
16621 Convenience variable \"$bpnum\" contains the number of the last\n\
16622 breakpoint set."));
16624 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
16625 Status of all breakpoints, or breakpoint number NUMBER.\n\
16626 The \"Type\" column indicates one of:\n\
16627 \tbreakpoint - normal breakpoint\n\
16628 \twatchpoint - watchpoint\n\
16629 \tlongjmp - internal breakpoint used to step through longjmp()\n\
16630 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
16631 \tuntil - internal breakpoint used by the \"until\" command\n\
16632 \tfinish - internal breakpoint used by the \"finish\" command\n\
16633 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
16634 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
16635 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
16636 address and file/line number respectively.\n\
16638 Convenience variable \"$_\" and default examine address for \"x\"\n\
16639 are set to the address of the last breakpoint listed unless the command\n\
16640 is prefixed with \"server \".\n\n\
16641 Convenience variable \"$bpnum\" contains the number of the last\n\
16643 &maintenanceinfolist
);
16645 add_prefix_cmd ("catch", class_breakpoint
, catch_command
, _("\
16646 Set catchpoints to catch events."),
16647 &catch_cmdlist
, "catch ",
16648 0/*allow-unknown*/, &cmdlist
);
16650 add_prefix_cmd ("tcatch", class_breakpoint
, tcatch_command
, _("\
16651 Set temporary catchpoints to catch events."),
16652 &tcatch_cmdlist
, "tcatch ",
16653 0/*allow-unknown*/, &cmdlist
);
16655 add_catch_command ("fork", _("Catch calls to fork."),
16656 catch_fork_command_1
,
16658 (void *) (uintptr_t) catch_fork_permanent
,
16659 (void *) (uintptr_t) catch_fork_temporary
);
16660 add_catch_command ("vfork", _("Catch calls to vfork."),
16661 catch_fork_command_1
,
16663 (void *) (uintptr_t) catch_vfork_permanent
,
16664 (void *) (uintptr_t) catch_vfork_temporary
);
16665 add_catch_command ("exec", _("Catch calls to exec."),
16666 catch_exec_command_1
,
16670 add_catch_command ("load", _("Catch loads of shared libraries.\n\
16671 Usage: catch load [REGEX]\n\
16672 If REGEX is given, only stop for libraries matching the regular expression."),
16673 catch_load_command_1
,
16677 add_catch_command ("unload", _("Catch unloads of shared libraries.\n\
16678 Usage: catch unload [REGEX]\n\
16679 If REGEX is given, only stop for libraries matching the regular expression."),
16680 catch_unload_command_1
,
16684 add_catch_command ("syscall", _("\
16685 Catch system calls by their names and/or numbers.\n\
16686 Arguments say which system calls to catch. If no arguments\n\
16687 are given, every system call will be caught.\n\
16688 Arguments, if given, should be one or more system call names\n\
16689 (if your system supports that), or system call numbers."),
16690 catch_syscall_command_1
,
16691 catch_syscall_completer
,
16695 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
16696 Set a watchpoint for an expression.\n\
16697 Usage: watch [-l|-location] EXPRESSION\n\
16698 A watchpoint stops execution of your program whenever the value of\n\
16699 an expression changes.\n\
16700 If -l or -location is given, this evaluates EXPRESSION and watches\n\
16701 the memory to which it refers."));
16702 set_cmd_completer (c
, expression_completer
);
16704 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
16705 Set a read watchpoint for an expression.\n\
16706 Usage: rwatch [-l|-location] EXPRESSION\n\
16707 A watchpoint stops execution of your program whenever the value of\n\
16708 an expression is read.\n\
16709 If -l or -location is given, this evaluates EXPRESSION and watches\n\
16710 the memory to which it refers."));
16711 set_cmd_completer (c
, expression_completer
);
16713 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
16714 Set a watchpoint for an expression.\n\
16715 Usage: awatch [-l|-location] EXPRESSION\n\
16716 A watchpoint stops execution of your program whenever the value of\n\
16717 an expression is either read or written.\n\
16718 If -l or -location is given, this evaluates EXPRESSION and watches\n\
16719 the memory to which it refers."));
16720 set_cmd_completer (c
, expression_completer
);
16722 add_info ("watchpoints", watchpoints_info
, _("\
16723 Status of specified watchpoints (all watchpoints if no argument)."));
16725 /* XXX: cagney/2005-02-23: This should be a boolean, and should
16726 respond to changes - contrary to the description. */
16727 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
16728 &can_use_hw_watchpoints
, _("\
16729 Set debugger's willingness to use watchpoint hardware."), _("\
16730 Show debugger's willingness to use watchpoint hardware."), _("\
16731 If zero, gdb will not use hardware for new watchpoints, even if\n\
16732 such is available. (However, any hardware watchpoints that were\n\
16733 created before setting this to nonzero, will continue to use watchpoint\n\
16736 show_can_use_hw_watchpoints
,
16737 &setlist
, &showlist
);
16739 can_use_hw_watchpoints
= 1;
16741 /* Tracepoint manipulation commands. */
16743 c
= add_com ("trace", class_breakpoint
, trace_command
, _("\
16744 Set a tracepoint at specified line or function.\n\
16746 BREAK_ARGS_HELP ("trace") "\n\
16747 Do \"help tracepoints\" for info on other tracepoint commands."));
16748 set_cmd_completer (c
, location_completer
);
16750 add_com_alias ("tp", "trace", class_alias
, 0);
16751 add_com_alias ("tr", "trace", class_alias
, 1);
16752 add_com_alias ("tra", "trace", class_alias
, 1);
16753 add_com_alias ("trac", "trace", class_alias
, 1);
16755 c
= add_com ("ftrace", class_breakpoint
, ftrace_command
, _("\
16756 Set a fast tracepoint at specified line or function.\n\
16758 BREAK_ARGS_HELP ("ftrace") "\n\
16759 Do \"help tracepoints\" for info on other tracepoint commands."));
16760 set_cmd_completer (c
, location_completer
);
16762 c
= add_com ("strace", class_breakpoint
, strace_command
, _("\
16763 Set a static tracepoint at specified line, function or marker.\n\
16765 strace [LOCATION] [if CONDITION]\n\
16766 LOCATION may be a line number, function name, \"*\" and an address,\n\
16767 or -m MARKER_ID.\n\
16768 If a line number is specified, probe the marker at start of code\n\
16769 for that line. If a function is specified, probe the marker at start\n\
16770 of code for that function. If an address is specified, probe the marker\n\
16771 at that exact address. If a marker id is specified, probe the marker\n\
16772 with that name. With no LOCATION, uses current execution address of\n\
16773 the selected stack frame.\n\
16774 Static tracepoints accept an extra collect action -- ``collect $_sdata''.\n\
16775 This collects arbitrary user data passed in the probe point call to the\n\
16776 tracing library. You can inspect it when analyzing the trace buffer,\n\
16777 by printing the $_sdata variable like any other convenience variable.\n\
16779 CONDITION is a boolean expression.\n\
16781 Multiple tracepoints at one place are permitted, and useful if their\n\
16782 conditions are different.\n\
16784 Do \"help breakpoints\" for info on other commands dealing with breakpoints.\n\
16785 Do \"help tracepoints\" for info on other tracepoint commands."));
16786 set_cmd_completer (c
, location_completer
);
16788 add_info ("tracepoints", tracepoints_info
, _("\
16789 Status of specified tracepoints (all tracepoints if no argument).\n\
16790 Convenience variable \"$tpnum\" contains the number of the\n\
16791 last tracepoint set."));
16793 add_info_alias ("tp", "tracepoints", 1);
16795 add_cmd ("tracepoints", class_trace
, delete_trace_command
, _("\
16796 Delete specified tracepoints.\n\
16797 Arguments are tracepoint numbers, separated by spaces.\n\
16798 No argument means delete all tracepoints."),
16800 add_alias_cmd ("tr", "tracepoints", class_trace
, 1, &deletelist
);
16802 c
= add_cmd ("tracepoints", class_trace
, disable_trace_command
, _("\
16803 Disable specified tracepoints.\n\
16804 Arguments are tracepoint numbers, separated by spaces.\n\
16805 No argument means disable all tracepoints."),
16807 deprecate_cmd (c
, "disable");
16809 c
= add_cmd ("tracepoints", class_trace
, enable_trace_command
, _("\
16810 Enable specified tracepoints.\n\
16811 Arguments are tracepoint numbers, separated by spaces.\n\
16812 No argument means enable all tracepoints."),
16814 deprecate_cmd (c
, "enable");
16816 add_com ("passcount", class_trace
, trace_pass_command
, _("\
16817 Set the passcount for a tracepoint.\n\
16818 The trace will end when the tracepoint has been passed 'count' times.\n\
16819 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
16820 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
16822 add_prefix_cmd ("save", class_breakpoint
, save_command
,
16823 _("Save breakpoint definitions as a script."),
16824 &save_cmdlist
, "save ",
16825 0/*allow-unknown*/, &cmdlist
);
16827 c
= add_cmd ("breakpoints", class_breakpoint
, save_breakpoints_command
, _("\
16828 Save current breakpoint definitions as a script.\n\
16829 This includes all types of breakpoints (breakpoints, watchpoints,\n\
16830 catchpoints, tracepoints). Use the 'source' command in another debug\n\
16831 session to restore them."),
16833 set_cmd_completer (c
, filename_completer
);
16835 c
= add_cmd ("tracepoints", class_trace
, save_tracepoints_command
, _("\
16836 Save current tracepoint definitions as a script.\n\
16837 Use the 'source' command in another debug session to restore them."),
16839 set_cmd_completer (c
, filename_completer
);
16841 c
= add_com_alias ("save-tracepoints", "save tracepoints", class_trace
, 0);
16842 deprecate_cmd (c
, "save tracepoints");
16844 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
16845 Breakpoint specific settings\n\
16846 Configure various breakpoint-specific variables such as\n\
16847 pending breakpoint behavior"),
16848 &breakpoint_set_cmdlist
, "set breakpoint ",
16849 0/*allow-unknown*/, &setlist
);
16850 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
16851 Breakpoint specific settings\n\
16852 Configure various breakpoint-specific variables such as\n\
16853 pending breakpoint behavior"),
16854 &breakpoint_show_cmdlist
, "show breakpoint ",
16855 0/*allow-unknown*/, &showlist
);
16857 add_setshow_auto_boolean_cmd ("pending", no_class
,
16858 &pending_break_support
, _("\
16859 Set debugger's behavior regarding pending breakpoints."), _("\
16860 Show debugger's behavior regarding pending breakpoints."), _("\
16861 If on, an unrecognized breakpoint location will cause gdb to create a\n\
16862 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
16863 an error. If auto, an unrecognized breakpoint location results in a\n\
16864 user-query to see if a pending breakpoint should be created."),
16866 show_pending_break_support
,
16867 &breakpoint_set_cmdlist
,
16868 &breakpoint_show_cmdlist
);
16870 pending_break_support
= AUTO_BOOLEAN_AUTO
;
16872 add_setshow_boolean_cmd ("auto-hw", no_class
,
16873 &automatic_hardware_breakpoints
, _("\
16874 Set automatic usage of hardware breakpoints."), _("\
16875 Show automatic usage of hardware breakpoints."), _("\
16876 If set, the debugger will automatically use hardware breakpoints for\n\
16877 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
16878 a warning will be emitted for such breakpoints."),
16880 show_automatic_hardware_breakpoints
,
16881 &breakpoint_set_cmdlist
,
16882 &breakpoint_show_cmdlist
);
16884 add_setshow_boolean_cmd ("always-inserted", class_support
,
16885 &always_inserted_mode
, _("\
16886 Set mode for inserting breakpoints."), _("\
16887 Show mode for inserting breakpoints."), _("\
16888 When this mode is on, breakpoints are inserted immediately as soon as\n\
16889 they're created, kept inserted even when execution stops, and removed\n\
16890 only when the user deletes them. When this mode is off (the default),\n\
16891 breakpoints are inserted only when execution continues, and removed\n\
16892 when execution stops."),
16894 &show_always_inserted_mode
,
16895 &breakpoint_set_cmdlist
,
16896 &breakpoint_show_cmdlist
);
16898 add_setshow_enum_cmd ("condition-evaluation", class_breakpoint
,
16899 condition_evaluation_enums
,
16900 &condition_evaluation_mode_1
, _("\
16901 Set mode of breakpoint condition evaluation."), _("\
16902 Show mode of breakpoint condition evaluation."), _("\
16903 When this is set to \"host\", breakpoint conditions will be\n\
16904 evaluated on the host's side by GDB. When it is set to \"target\",\n\
16905 breakpoint conditions will be downloaded to the target (if the target\n\
16906 supports such feature) and conditions will be evaluated on the target's side.\n\
16907 If this is set to \"auto\" (default), this will be automatically set to\n\
16908 \"target\" if it supports condition evaluation, otherwise it will\n\
16909 be set to \"gdb\""),
16910 &set_condition_evaluation_mode
,
16911 &show_condition_evaluation_mode
,
16912 &breakpoint_set_cmdlist
,
16913 &breakpoint_show_cmdlist
);
16915 add_com ("break-range", class_breakpoint
, break_range_command
, _("\
16916 Set a breakpoint for an address range.\n\
16917 break-range START-LOCATION, END-LOCATION\n\
16918 where START-LOCATION and END-LOCATION can be one of the following:\n\
16919 LINENUM, for that line in the current file,\n\
16920 FILE:LINENUM, for that line in that file,\n\
16921 +OFFSET, for that number of lines after the current line\n\
16922 or the start of the range\n\
16923 FUNCTION, for the first line in that function,\n\
16924 FILE:FUNCTION, to distinguish among like-named static functions.\n\
16925 *ADDRESS, for the instruction at that address.\n\
16927 The breakpoint will stop execution of the inferior whenever it executes\n\
16928 an instruction at any address within the [START-LOCATION, END-LOCATION]\n\
16929 range (including START-LOCATION and END-LOCATION)."));
16931 c
= add_com ("dprintf", class_breakpoint
, dprintf_command
, _("\
16932 Set a dynamic printf at specified line or function.\n\
16933 dprintf location,format string,arg1,arg2,...\n\
16934 location may be a line number, function name, or \"*\" and an address.\n\
16935 If a line number is specified, break at start of code for that line.\n\
16936 If a function is specified, break at start of code for that function."));
16937 set_cmd_completer (c
, location_completer
);
16939 add_setshow_enum_cmd ("dprintf-style", class_support
,
16940 dprintf_style_enums
, &dprintf_style
, _("\
16941 Set the style of usage for dynamic printf."), _("\
16942 Show the style of usage for dynamic printf."), _("\
16943 This setting chooses how GDB will do a dynamic printf.\n\
16944 If the value is \"gdb\", then the printing is done by GDB to its own\n\
16945 console, as with the \"printf\" command.\n\
16946 If the value is \"call\", the print is done by calling a function in your\n\
16947 program; by default printf(), but you can choose a different function or\n\
16948 output stream by setting dprintf-function and dprintf-channel."),
16949 update_dprintf_commands
, NULL
,
16950 &setlist
, &showlist
);
16952 dprintf_function
= xstrdup ("printf");
16953 add_setshow_string_cmd ("dprintf-function", class_support
,
16954 &dprintf_function
, _("\
16955 Set the function to use for dynamic printf"), _("\
16956 Show the function to use for dynamic printf"), NULL
,
16957 update_dprintf_commands
, NULL
,
16958 &setlist
, &showlist
);
16960 dprintf_channel
= xstrdup ("");
16961 add_setshow_string_cmd ("dprintf-channel", class_support
,
16962 &dprintf_channel
, _("\
16963 Set the channel to use for dynamic printf"), _("\
16964 Show the channel to use for dynamic printf"), NULL
,
16965 update_dprintf_commands
, NULL
,
16966 &setlist
, &showlist
);
16968 add_setshow_boolean_cmd ("disconnected-dprintf", no_class
,
16969 &disconnected_dprintf
, _("\
16970 Set whether dprintf continues after GDB disconnects."), _("\
16971 Show whether dprintf continues after GDB disconnects."), _("\
16972 Use this to let dprintf commands continue to hit and produce output\n\
16973 even if GDB disconnects or detaches from the target."),
16976 &setlist
, &showlist
);
16978 add_com ("agent-printf", class_vars
, agent_printf_command
, _("\
16979 agent-printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
16980 (target agent only) This is useful for formatted output in user-defined commands."));
16982 automatic_hardware_breakpoints
= 1;
16984 observer_attach_about_to_proceed (breakpoint_about_to_proceed
);
16985 observer_attach_thread_exit (remove_threaded_breakpoints
);