1 /* Everything about breakpoints, for GDB.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
5 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "arch-utils.h"
28 #include "breakpoint.h"
29 #include "tracepoint.h"
31 #include "expression.h"
37 #include "gdbthread.h"
40 #include "gdb_string.h"
42 #include "filenames.h"
48 #include "completer.h"
51 #include "cli/cli-script.h"
52 #include "gdb_assert.h"
57 #include "exceptions.h"
64 #include "xml-syscall.h"
65 #include "parser-defs.h"
66 #include "cli/cli-utils.h"
68 /* readline include files */
69 #include "readline/readline.h"
70 #include "readline/history.h"
72 /* readline defines this. */
75 #include "mi/mi-common.h"
76 #include "python/python.h"
78 /* Arguments to pass as context to some catch command handlers. */
79 #define CATCH_PERMANENT ((void *) (uintptr_t) 0)
80 #define CATCH_TEMPORARY ((void *) (uintptr_t) 1)
82 /* Prototypes for local functions. */
84 static void enable_delete_command (char *, int);
86 static void enable_once_command (char *, int);
88 static void disable_command (char *, int);
90 static void enable_command (char *, int);
92 static void map_breakpoint_numbers (char *, void (*) (struct breakpoint
*,
96 static void ignore_command (char *, int);
98 static int breakpoint_re_set_one (void *);
100 static void clear_command (char *, int);
102 static void catch_command (char *, int);
104 static int can_use_hardware_watchpoint (struct value
*, int);
106 static void break_command_1 (char *, int, int);
108 static void mention (struct breakpoint
*);
110 /* This function is used in gdbtk sources and thus can not be made
112 struct breakpoint
*set_raw_breakpoint (struct gdbarch
*gdbarch
,
113 struct symtab_and_line
,
116 static void breakpoint_adjustment_warning (CORE_ADDR
, CORE_ADDR
, int, int);
118 static CORE_ADDR
adjust_breakpoint_address (struct gdbarch
*gdbarch
,
122 static void describe_other_breakpoints (struct gdbarch
*,
123 struct program_space
*, CORE_ADDR
,
124 struct obj_section
*, int);
126 static int breakpoint_address_match (struct address_space
*aspace1
,
128 struct address_space
*aspace2
,
131 static int watchpoint_locations_match (struct bp_location
*loc1
,
132 struct bp_location
*loc2
);
134 static void breakpoints_info (char *, int);
136 static void watchpoints_info (char *, int);
138 static int breakpoint_1 (char *, int,
139 int (*) (const struct breakpoint
*));
141 static int breakpoint_cond_eval (void *);
143 static void cleanup_executing_breakpoints (void *);
145 static void commands_command (char *, int);
147 static void condition_command (char *, int);
156 static int remove_breakpoint (struct bp_location
*, insertion_state_t
);
157 static int remove_breakpoint_1 (struct bp_location
*, insertion_state_t
);
159 static enum print_stop_action
print_it_typical (bpstat
);
161 static enum print_stop_action
print_bp_stop_message (bpstat bs
);
163 static int watchpoint_check (void *);
165 static void maintenance_info_breakpoints (char *, int);
167 static int hw_breakpoint_used_count (void);
169 static int hw_watchpoint_used_count (enum bptype
, int *);
171 static void hbreak_command (char *, int);
173 static void thbreak_command (char *, int);
175 static void do_enable_breakpoint (struct breakpoint
*, enum bpdisp
);
177 static void stop_command (char *arg
, int from_tty
);
179 static void stopin_command (char *arg
, int from_tty
);
181 static void stopat_command (char *arg
, int from_tty
);
183 static char *ep_parse_optional_if_clause (char **arg
);
185 static void catch_exception_command_1 (enum exception_event_kind ex_event
,
186 char *arg
, int tempflag
, int from_tty
);
188 static void tcatch_command (char *arg
, int from_tty
);
190 static void detach_single_step_breakpoints (void);
192 static int single_step_breakpoint_inserted_here_p (struct address_space
*,
195 static void free_bp_location (struct bp_location
*loc
);
196 static void incref_bp_location (struct bp_location
*loc
);
197 static void decref_bp_location (struct bp_location
**loc
);
199 static struct bp_location
*allocate_bp_location (struct breakpoint
*bpt
);
201 static void update_global_location_list (int);
203 static void update_global_location_list_nothrow (int);
205 static int is_hardware_watchpoint (const struct breakpoint
*bpt
);
207 static int is_watchpoint (const struct breakpoint
*bpt
);
209 static void insert_breakpoint_locations (void);
211 static int syscall_catchpoint_p (struct breakpoint
*b
);
213 static void tracepoints_info (char *, int);
215 static void delete_trace_command (char *, int);
217 static void enable_trace_command (char *, int);
219 static void disable_trace_command (char *, int);
221 static void trace_pass_command (char *, int);
223 /* Assuming we're creating a static tracepoint, does S look like a
224 static tracepoint marker spec ("-m MARKER_ID")? */
225 #define is_marker_spec(s) \
226 (s != NULL && strncmp (s, "-m", 2) == 0 && ((s)[2] == ' ' || (s)[2] == '\t'))
228 /* A reference-counted struct command_line. This lets multiple
229 breakpoints share a single command list. */
230 struct counted_command_line
232 /* The reference count. */
235 /* The command list. */
236 struct command_line
*commands
;
239 struct command_line
*
240 breakpoint_commands (struct breakpoint
*b
)
242 return b
->commands
? b
->commands
->commands
: NULL
;
245 /* Flag indicating that a command has proceeded the inferior past the
246 current breakpoint. */
248 static int breakpoint_proceeded
;
251 bpdisp_text (enum bpdisp disp
)
253 /* NOTE: the following values are a part of MI protocol and
254 represent values of 'disp' field returned when inferior stops at
256 static const char * const bpdisps
[] = {"del", "dstp", "dis", "keep"};
258 return bpdisps
[(int) disp
];
261 /* Prototypes for exported functions. */
262 /* If FALSE, gdb will not use hardware support for watchpoints, even
263 if such is available. */
264 static int can_use_hw_watchpoints
;
267 show_can_use_hw_watchpoints (struct ui_file
*file
, int from_tty
,
268 struct cmd_list_element
*c
,
271 fprintf_filtered (file
,
272 _("Debugger's willingness to use "
273 "watchpoint hardware is %s.\n"),
277 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
278 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
279 for unrecognized breakpoint locations.
280 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
281 static enum auto_boolean pending_break_support
;
283 show_pending_break_support (struct ui_file
*file
, int from_tty
,
284 struct cmd_list_element
*c
,
287 fprintf_filtered (file
,
288 _("Debugger's behavior regarding "
289 "pending breakpoints is %s.\n"),
293 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
294 set with "break" but falling in read-only memory.
295 If 0, gdb will warn about such breakpoints, but won't automatically
296 use hardware breakpoints. */
297 static int automatic_hardware_breakpoints
;
299 show_automatic_hardware_breakpoints (struct ui_file
*file
, int from_tty
,
300 struct cmd_list_element
*c
,
303 fprintf_filtered (file
,
304 _("Automatic usage of hardware breakpoints is %s.\n"),
308 /* If on, gdb will keep breakpoints inserted even as inferior is
309 stopped, and immediately insert any new breakpoints. If off, gdb
310 will insert breakpoints into inferior only when resuming it, and
311 will remove breakpoints upon stop. If auto, GDB will behave as ON
312 if in non-stop mode, and as OFF if all-stop mode.*/
314 static const char always_inserted_auto
[] = "auto";
315 static const char always_inserted_on
[] = "on";
316 static const char always_inserted_off
[] = "off";
317 static const char *always_inserted_enums
[] = {
318 always_inserted_auto
,
323 static const char *always_inserted_mode
= always_inserted_auto
;
325 show_always_inserted_mode (struct ui_file
*file
, int from_tty
,
326 struct cmd_list_element
*c
, const char *value
)
328 if (always_inserted_mode
== always_inserted_auto
)
329 fprintf_filtered (file
,
330 _("Always inserted breakpoint "
331 "mode is %s (currently %s).\n"),
333 breakpoints_always_inserted_mode () ? "on" : "off");
335 fprintf_filtered (file
, _("Always inserted breakpoint mode is %s.\n"),
340 breakpoints_always_inserted_mode (void)
342 return (always_inserted_mode
== always_inserted_on
343 || (always_inserted_mode
== always_inserted_auto
&& non_stop
));
346 void _initialize_breakpoint (void);
348 /* Are we executing breakpoint commands? */
349 static int executing_breakpoint_commands
;
351 /* Are overlay event breakpoints enabled? */
352 static int overlay_events_enabled
;
354 /* See description in breakpoint.h. */
355 int target_exact_watchpoints
= 0;
357 /* Walk the following statement or block through all breakpoints.
358 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the
359 current breakpoint. */
361 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
363 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
364 for (B = breakpoint_chain; \
365 B ? (TMP=B->next, 1): 0; \
368 /* Similar iterator for the low-level breakpoints. SAFE variant is
369 not provided so update_global_location_list must not be called
370 while executing the block of ALL_BP_LOCATIONS. */
372 #define ALL_BP_LOCATIONS(B,BP_TMP) \
373 for (BP_TMP = bp_location; \
374 BP_TMP < bp_location + bp_location_count && (B = *BP_TMP); \
377 /* Iterator for tracepoints only. */
379 #define ALL_TRACEPOINTS(B) \
380 for (B = breakpoint_chain; B; B = B->next) \
381 if (is_tracepoint (B))
383 /* Chains of all breakpoints defined. */
385 struct breakpoint
*breakpoint_chain
;
387 /* Array is sorted by bp_location_compare - primarily by the ADDRESS. */
389 static struct bp_location
**bp_location
;
391 /* Number of elements of BP_LOCATION. */
393 static unsigned bp_location_count
;
395 /* Maximum alignment offset between bp_target_info.PLACED_ADDRESS and
396 ADDRESS for the current elements of BP_LOCATION which get a valid
397 result from bp_location_has_shadow. You can use it for roughly
398 limiting the subrange of BP_LOCATION to scan for shadow bytes for
399 an address you need to read. */
401 static CORE_ADDR bp_location_placed_address_before_address_max
;
403 /* Maximum offset plus alignment between bp_target_info.PLACED_ADDRESS
404 + bp_target_info.SHADOW_LEN and ADDRESS for the current elements of
405 BP_LOCATION which get a valid result from bp_location_has_shadow.
406 You can use it for roughly limiting the subrange of BP_LOCATION to
407 scan for shadow bytes for an address you need to read. */
409 static CORE_ADDR bp_location_shadow_len_after_address_max
;
411 /* The locations that no longer correspond to any breakpoint, unlinked
412 from bp_location array, but for which a hit may still be reported
414 VEC(bp_location_p
) *moribund_locations
= NULL
;
416 /* Number of last breakpoint made. */
418 static int breakpoint_count
;
420 /* The value of `breakpoint_count' before the last command that
421 created breakpoints. If the last (break-like) command created more
422 than one breakpoint, then the difference between BREAKPOINT_COUNT
423 and PREV_BREAKPOINT_COUNT is more than one. */
424 static int prev_breakpoint_count
;
426 /* Number of last tracepoint made. */
428 static int tracepoint_count
;
430 static struct cmd_list_element
*breakpoint_set_cmdlist
;
431 static struct cmd_list_element
*breakpoint_show_cmdlist
;
432 struct cmd_list_element
*save_cmdlist
;
434 /* Return whether a breakpoint is an active enabled breakpoint. */
436 breakpoint_enabled (struct breakpoint
*b
)
438 return (b
->enable_state
== bp_enabled
);
441 /* Set breakpoint count to NUM. */
444 set_breakpoint_count (int num
)
446 prev_breakpoint_count
= breakpoint_count
;
447 breakpoint_count
= num
;
448 set_internalvar_integer (lookup_internalvar ("bpnum"), num
);
451 /* Used by `start_rbreak_breakpoints' below, to record the current
452 breakpoint count before "rbreak" creates any breakpoint. */
453 static int rbreak_start_breakpoint_count
;
455 /* Called at the start an "rbreak" command to record the first
459 start_rbreak_breakpoints (void)
461 rbreak_start_breakpoint_count
= breakpoint_count
;
464 /* Called at the end of an "rbreak" command to record the last
468 end_rbreak_breakpoints (void)
470 prev_breakpoint_count
= rbreak_start_breakpoint_count
;
473 /* Used in run_command to zero the hit count when a new run starts. */
476 clear_breakpoint_hit_counts (void)
478 struct breakpoint
*b
;
484 /* Allocate a new counted_command_line with reference count of 1.
485 The new structure owns COMMANDS. */
487 static struct counted_command_line
*
488 alloc_counted_command_line (struct command_line
*commands
)
490 struct counted_command_line
*result
491 = xmalloc (sizeof (struct counted_command_line
));
494 result
->commands
= commands
;
498 /* Increment reference count. This does nothing if CMD is NULL. */
501 incref_counted_command_line (struct counted_command_line
*cmd
)
507 /* Decrement reference count. If the reference count reaches 0,
508 destroy the counted_command_line. Sets *CMDP to NULL. This does
509 nothing if *CMDP is NULL. */
512 decref_counted_command_line (struct counted_command_line
**cmdp
)
516 if (--(*cmdp
)->refc
== 0)
518 free_command_lines (&(*cmdp
)->commands
);
525 /* A cleanup function that calls decref_counted_command_line. */
528 do_cleanup_counted_command_line (void *arg
)
530 decref_counted_command_line (arg
);
533 /* Create a cleanup that calls decref_counted_command_line on the
536 static struct cleanup
*
537 make_cleanup_decref_counted_command_line (struct counted_command_line
**cmdp
)
539 return make_cleanup (do_cleanup_counted_command_line
, cmdp
);
542 /* Default address, symtab and line to put a breakpoint at
543 for "break" command with no arg.
544 If default_breakpoint_valid is zero, the other three are
545 not valid, and "break" with no arg is an error.
547 This set by print_stack_frame, which calls set_default_breakpoint. */
549 int default_breakpoint_valid
;
550 CORE_ADDR default_breakpoint_address
;
551 struct symtab
*default_breakpoint_symtab
;
552 int default_breakpoint_line
;
553 struct program_space
*default_breakpoint_pspace
;
556 /* Return the breakpoint with the specified number, or NULL
557 if the number does not refer to an existing breakpoint. */
560 get_breakpoint (int num
)
562 struct breakpoint
*b
;
565 if (b
->number
== num
)
574 set_breakpoint_condition (struct breakpoint
*b
, char *exp
,
577 struct bp_location
*loc
= b
->loc
;
579 for (; loc
; loc
= loc
->next
)
584 xfree (b
->cond_string
);
585 b
->cond_string
= NULL
;
592 printf_filtered (_("Breakpoint %d now unconditional.\n"), b
->number
);
598 /* I don't know if it matters whether this is the string the user
599 typed in or the decompiled expression. */
600 b
->cond_string
= xstrdup (arg
);
601 b
->condition_not_parsed
= 0;
603 if (is_watchpoint (b
))
605 innermost_block
= NULL
;
607 b
->cond_exp
= parse_exp_1 (&arg
, 0, 0);
609 error (_("Junk at end of expression"));
610 b
->cond_exp_valid_block
= innermost_block
;
614 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
618 parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
620 error (_("Junk at end of expression"));
624 breakpoints_changed ();
625 observer_notify_breakpoint_modified (b
->number
);
628 /* condition N EXP -- set break condition of breakpoint N to EXP. */
631 condition_command (char *arg
, int from_tty
)
633 struct breakpoint
*b
;
638 error_no_arg (_("breakpoint number"));
641 bnum
= get_number (&p
);
643 error (_("Bad breakpoint argument: '%s'"), arg
);
646 if (b
->number
== bnum
)
648 /* Check if this breakpoint has a Python object assigned to
649 it, and if it has a definition of the "stop"
650 method. This method and conditions entered into GDB from
651 the CLI are mutually exclusive. */
653 && gdbpy_breakpoint_has_py_cond (b
->py_bp_object
))
654 error (_("Cannot set a condition where a Python 'stop' "
655 "method has been defined in the breakpoint."));
656 set_breakpoint_condition (b
, p
, from_tty
);
660 error (_("No breakpoint number %d."), bnum
);
663 /* Check that COMMAND do not contain commands that are suitable
664 only for tracepoints and not suitable for ordinary breakpoints.
665 Throw if any such commands is found. */
668 check_no_tracepoint_commands (struct command_line
*commands
)
670 struct command_line
*c
;
672 for (c
= commands
; c
; c
= c
->next
)
676 if (c
->control_type
== while_stepping_control
)
677 error (_("The 'while-stepping' command can "
678 "only be used for tracepoints"));
680 for (i
= 0; i
< c
->body_count
; ++i
)
681 check_no_tracepoint_commands ((c
->body_list
)[i
]);
683 /* Not that command parsing removes leading whitespace and comment
684 lines and also empty lines. So, we only need to check for
686 if (strstr (c
->line
, "collect ") == c
->line
)
687 error (_("The 'collect' command can only be used for tracepoints"));
689 if (strstr (c
->line
, "teval ") == c
->line
)
690 error (_("The 'teval' command can only be used for tracepoints"));
694 /* Encapsulate tests for different types of tracepoints. */
697 is_tracepoint (const struct breakpoint
*b
)
699 return (b
->type
== bp_tracepoint
700 || b
->type
== bp_fast_tracepoint
701 || b
->type
== bp_static_tracepoint
);
704 /* A helper function that validsates that COMMANDS are valid for a
705 breakpoint. This function will throw an exception if a problem is
709 validate_commands_for_breakpoint (struct breakpoint
*b
,
710 struct command_line
*commands
)
712 if (is_tracepoint (b
))
714 /* We need to verify that each top-level element of commands is
715 valid for tracepoints, that there's at most one
716 while-stepping element, and that while-stepping's body has
717 valid tracing commands excluding nested while-stepping. */
718 struct command_line
*c
;
719 struct command_line
*while_stepping
= 0;
720 for (c
= commands
; c
; c
= c
->next
)
722 if (c
->control_type
== while_stepping_control
)
724 if (b
->type
== bp_fast_tracepoint
)
725 error (_("The 'while-stepping' command "
726 "cannot be used for fast tracepoint"));
727 else if (b
->type
== bp_static_tracepoint
)
728 error (_("The 'while-stepping' command "
729 "cannot be used for static tracepoint"));
732 error (_("The 'while-stepping' command "
733 "can be used only once"));
740 struct command_line
*c2
;
742 gdb_assert (while_stepping
->body_count
== 1);
743 c2
= while_stepping
->body_list
[0];
744 for (; c2
; c2
= c2
->next
)
746 if (c2
->control_type
== while_stepping_control
)
747 error (_("The 'while-stepping' command cannot be nested"));
753 check_no_tracepoint_commands (commands
);
757 /* Return a vector of all the static tracepoints set at ADDR. The
758 caller is responsible for releasing the vector. */
761 static_tracepoints_here (CORE_ADDR addr
)
763 struct breakpoint
*b
;
764 VEC(breakpoint_p
) *found
= 0;
765 struct bp_location
*loc
;
768 if (b
->type
== bp_static_tracepoint
)
770 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
771 if (loc
->address
== addr
)
772 VEC_safe_push(breakpoint_p
, found
, b
);
778 /* Set the command list of B to COMMANDS. If breakpoint is tracepoint,
779 validate that only allowed commands are included. */
782 breakpoint_set_commands (struct breakpoint
*b
,
783 struct command_line
*commands
)
785 validate_commands_for_breakpoint (b
, commands
);
787 decref_counted_command_line (&b
->commands
);
788 b
->commands
= alloc_counted_command_line (commands
);
789 breakpoints_changed ();
790 observer_notify_breakpoint_modified (b
->number
);
793 /* Set the internal `silent' flag on the breakpoint. Note that this
794 is not the same as the "silent" that may appear in the breakpoint's
798 breakpoint_set_silent (struct breakpoint
*b
, int silent
)
800 int old_silent
= b
->silent
;
803 if (old_silent
!= silent
)
804 observer_notify_breakpoint_modified (b
->number
);
807 /* Set the thread for this breakpoint. If THREAD is -1, make the
808 breakpoint work for any thread. */
811 breakpoint_set_thread (struct breakpoint
*b
, int thread
)
813 int old_thread
= b
->thread
;
816 if (old_thread
!= thread
)
817 observer_notify_breakpoint_modified (b
->number
);
820 /* Set the task for this breakpoint. If TASK is 0, make the
821 breakpoint work for any task. */
824 breakpoint_set_task (struct breakpoint
*b
, int task
)
826 int old_task
= b
->task
;
829 if (old_task
!= task
)
830 observer_notify_breakpoint_modified (b
->number
);
834 check_tracepoint_command (char *line
, void *closure
)
836 struct breakpoint
*b
= closure
;
838 validate_actionline (&line
, b
);
841 /* A structure used to pass information through
842 map_breakpoint_numbers. */
846 /* True if the command was typed at a tty. */
849 /* The breakpoint range spec. */
852 /* Non-NULL if the body of the commands are being read from this
853 already-parsed command. */
854 struct command_line
*control
;
856 /* The command lines read from the user, or NULL if they have not
858 struct counted_command_line
*cmd
;
861 /* A callback for map_breakpoint_numbers that sets the commands for
865 do_map_commands_command (struct breakpoint
*b
, void *data
)
867 struct commands_info
*info
= data
;
869 if (info
->cmd
== NULL
)
871 struct command_line
*l
;
873 if (info
->control
!= NULL
)
874 l
= copy_command_lines (info
->control
->body_list
[0]);
877 struct cleanup
*old_chain
;
880 str
= xstrprintf (_("Type commands for breakpoint(s) "
881 "%s, one per line."),
884 old_chain
= make_cleanup (xfree
, str
);
886 l
= read_command_lines (str
,
889 ? check_tracepoint_command
: 0),
892 do_cleanups (old_chain
);
895 info
->cmd
= alloc_counted_command_line (l
);
898 /* If a breakpoint was on the list more than once, we don't need to
900 if (b
->commands
!= info
->cmd
)
902 validate_commands_for_breakpoint (b
, info
->cmd
->commands
);
903 incref_counted_command_line (info
->cmd
);
904 decref_counted_command_line (&b
->commands
);
905 b
->commands
= info
->cmd
;
906 breakpoints_changed ();
907 observer_notify_breakpoint_modified (b
->number
);
912 commands_command_1 (char *arg
, int from_tty
,
913 struct command_line
*control
)
915 struct cleanup
*cleanups
;
916 struct commands_info info
;
918 info
.from_tty
= from_tty
;
919 info
.control
= control
;
921 /* If we read command lines from the user, then `info' will hold an
922 extra reference to the commands that we must clean up. */
923 cleanups
= make_cleanup_decref_counted_command_line (&info
.cmd
);
925 if (arg
== NULL
|| !*arg
)
927 if (breakpoint_count
- prev_breakpoint_count
> 1)
928 arg
= xstrprintf ("%d-%d", prev_breakpoint_count
+ 1,
930 else if (breakpoint_count
> 0)
931 arg
= xstrprintf ("%d", breakpoint_count
);
934 /* So that we don't try to free the incoming non-NULL
935 argument in the cleanup below. Mapping breakpoint
936 numbers will fail in this case. */
941 /* The command loop has some static state, so we need to preserve
946 make_cleanup (xfree
, arg
);
950 map_breakpoint_numbers (arg
, do_map_commands_command
, &info
);
952 if (info
.cmd
== NULL
)
953 error (_("No breakpoints specified."));
955 do_cleanups (cleanups
);
959 commands_command (char *arg
, int from_tty
)
961 commands_command_1 (arg
, from_tty
, NULL
);
964 /* Like commands_command, but instead of reading the commands from
965 input stream, takes them from an already parsed command structure.
967 This is used by cli-script.c to DTRT with breakpoint commands
968 that are part of if and while bodies. */
969 enum command_control_type
970 commands_from_control_command (char *arg
, struct command_line
*cmd
)
972 commands_command_1 (arg
, 0, cmd
);
973 return simple_control
;
976 /* Return non-zero if BL->TARGET_INFO contains valid information. */
979 bp_location_has_shadow (struct bp_location
*bl
)
981 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
985 if (bl
->target_info
.shadow_len
== 0)
986 /* bp isn't valid, or doesn't shadow memory. */
991 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
992 by replacing any memory breakpoints with their shadowed contents.
994 The range of shadowed area by each bp_location is:
995 bl->address - bp_location_placed_address_before_address_max
996 up to bl->address + bp_location_shadow_len_after_address_max
997 The range we were requested to resolve shadows for is:
998 memaddr ... memaddr + len
999 Thus the safe cutoff boundaries for performance optimization are
1000 memaddr + len <= (bl->address
1001 - bp_location_placed_address_before_address_max)
1003 bl->address + bp_location_shadow_len_after_address_max <= memaddr */
1006 breakpoint_restore_shadows (gdb_byte
*buf
, ULONGEST memaddr
, LONGEST len
)
1008 /* Left boundary, right boundary and median element of our binary
1010 unsigned bc_l
, bc_r
, bc
;
1012 /* Find BC_L which is a leftmost element which may affect BUF
1013 content. It is safe to report lower value but a failure to
1014 report higher one. */
1017 bc_r
= bp_location_count
;
1018 while (bc_l
+ 1 < bc_r
)
1020 struct bp_location
*bl
;
1022 bc
= (bc_l
+ bc_r
) / 2;
1023 bl
= bp_location
[bc
];
1025 /* Check first BL->ADDRESS will not overflow due to the added
1026 constant. Then advance the left boundary only if we are sure
1027 the BC element can in no way affect the BUF content (MEMADDR
1028 to MEMADDR + LEN range).
1030 Use the BP_LOCATION_SHADOW_LEN_AFTER_ADDRESS_MAX safety
1031 offset so that we cannot miss a breakpoint with its shadow
1032 range tail still reaching MEMADDR. */
1034 if ((bl
->address
+ bp_location_shadow_len_after_address_max
1036 && (bl
->address
+ bp_location_shadow_len_after_address_max
1043 /* Due to the binary search above, we need to make sure we pick the
1044 first location that's at BC_L's address. E.g., if there are
1045 multiple locations at the same address, BC_L may end up pointing
1046 at a duplicate location, and miss the "master"/"inserted"
1047 location. Say, given locations L1, L2 and L3 at addresses A and
1050 L1@A, L2@A, L3@B, ...
1052 BC_L could end up pointing at location L2, while the "master"
1053 location could be L1. Since the `loc->inserted' flag is only set
1054 on "master" locations, we'd forget to restore the shadow of L1
1057 && bp_location
[bc_l
]->address
== bp_location
[bc_l
- 1]->address
)
1060 /* Now do full processing of the found relevant range of elements. */
1062 for (bc
= bc_l
; bc
< bp_location_count
; bc
++)
1064 struct bp_location
*bl
= bp_location
[bc
];
1065 CORE_ADDR bp_addr
= 0;
1069 /* bp_location array has BL->OWNER always non-NULL. */
1070 if (bl
->owner
->type
== bp_none
)
1071 warning (_("reading through apparently deleted breakpoint #%d?"),
1074 /* Performance optimization: any futher element can no longer affect BUF
1077 if (bl
->address
>= bp_location_placed_address_before_address_max
1078 && memaddr
+ len
<= (bl
->address
1079 - bp_location_placed_address_before_address_max
))
1082 if (!bp_location_has_shadow (bl
))
1084 if (!breakpoint_address_match (bl
->target_info
.placed_address_space
, 0,
1085 current_program_space
->aspace
, 0))
1088 /* Addresses and length of the part of the breakpoint that
1090 bp_addr
= bl
->target_info
.placed_address
;
1091 bp_size
= bl
->target_info
.shadow_len
;
1093 if (bp_addr
+ bp_size
<= memaddr
)
1094 /* The breakpoint is entirely before the chunk of memory we
1098 if (bp_addr
>= memaddr
+ len
)
1099 /* The breakpoint is entirely after the chunk of memory we are
1103 /* Offset within shadow_contents. */
1104 if (bp_addr
< memaddr
)
1106 /* Only copy the second part of the breakpoint. */
1107 bp_size
-= memaddr
- bp_addr
;
1108 bptoffset
= memaddr
- bp_addr
;
1112 if (bp_addr
+ bp_size
> memaddr
+ len
)
1114 /* Only copy the first part of the breakpoint. */
1115 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
1118 memcpy (buf
+ bp_addr
- memaddr
,
1119 bl
->target_info
.shadow_contents
+ bptoffset
, bp_size
);
1124 /* Return true if BPT is of any hardware watchpoint kind. */
1127 is_hardware_watchpoint (const struct breakpoint
*bpt
)
1129 return (bpt
->type
== bp_hardware_watchpoint
1130 || bpt
->type
== bp_read_watchpoint
1131 || bpt
->type
== bp_access_watchpoint
);
1134 /* Return true if BPT is of any watchpoint kind, hardware or
1138 is_watchpoint (const struct breakpoint
*bpt
)
1140 return (is_hardware_watchpoint (bpt
)
1141 || bpt
->type
== bp_watchpoint
);
1144 /* Assuming that B is a watchpoint: returns true if the current thread
1145 and its running state are safe to evaluate or update watchpoint B.
1146 Watchpoints on local expressions need to be evaluated in the
1147 context of the thread that was current when the watchpoint was
1148 created, and, that thread needs to be stopped to be able to select
1149 the correct frame context. Watchpoints on global expressions can
1150 be evaluated on any thread, and in any state. It is presently left
1151 to the target allowing memory accesses when threads are
1155 watchpoint_in_thread_scope (struct breakpoint
*b
)
1157 return (ptid_equal (b
->watchpoint_thread
, null_ptid
)
1158 || (ptid_equal (inferior_ptid
, b
->watchpoint_thread
)
1159 && !is_executing (inferior_ptid
)));
1162 /* Set watchpoint B to disp_del_at_next_stop, even including its possible
1163 associated bp_watchpoint_scope breakpoint. */
1166 watchpoint_del_at_next_stop (struct breakpoint
*b
)
1168 gdb_assert (is_watchpoint (b
));
1170 if (b
->related_breakpoint
!= b
)
1172 gdb_assert (b
->related_breakpoint
->type
== bp_watchpoint_scope
);
1173 gdb_assert (b
->related_breakpoint
->related_breakpoint
== b
);
1174 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
1175 b
->related_breakpoint
->related_breakpoint
= b
->related_breakpoint
;
1176 b
->related_breakpoint
= b
;
1178 b
->disposition
= disp_del_at_next_stop
;
1181 /* Assuming that B is a watchpoint:
1182 - Reparse watchpoint expression, if REPARSE is non-zero
1183 - Evaluate expression and store the result in B->val
1184 - Evaluate the condition if there is one, and store the result
1186 - Update the list of values that must be watched in B->loc.
1188 If the watchpoint disposition is disp_del_at_next_stop, then do
1189 nothing. If this is local watchpoint that is out of scope, delete
1192 Even with `set breakpoint always-inserted on' the watchpoints are
1193 removed + inserted on each stop here. Normal breakpoints must
1194 never be removed because they might be missed by a running thread
1195 when debugging in non-stop mode. On the other hand, hardware
1196 watchpoints (is_hardware_watchpoint; processed here) are specific
1197 to each LWP since they are stored in each LWP's hardware debug
1198 registers. Therefore, such LWP must be stopped first in order to
1199 be able to modify its hardware watchpoints.
1201 Hardware watchpoints must be reset exactly once after being
1202 presented to the user. It cannot be done sooner, because it would
1203 reset the data used to present the watchpoint hit to the user. And
1204 it must not be done later because it could display the same single
1205 watchpoint hit during multiple GDB stops. Note that the latter is
1206 relevant only to the hardware watchpoint types bp_read_watchpoint
1207 and bp_access_watchpoint. False hit by bp_hardware_watchpoint is
1208 not user-visible - its hit is suppressed if the memory content has
1211 The following constraints influence the location where we can reset
1212 hardware watchpoints:
1214 * target_stopped_by_watchpoint and target_stopped_data_address are
1215 called several times when GDB stops.
1218 * Multiple hardware watchpoints can be hit at the same time,
1219 causing GDB to stop. GDB only presents one hardware watchpoint
1220 hit at a time as the reason for stopping, and all the other hits
1221 are presented later, one after the other, each time the user
1222 requests the execution to be resumed. Execution is not resumed
1223 for the threads still having pending hit event stored in
1224 LWP_INFO->STATUS. While the watchpoint is already removed from
1225 the inferior on the first stop the thread hit event is kept being
1226 reported from its cached value by linux_nat_stopped_data_address
1227 until the real thread resume happens after the watchpoint gets
1228 presented and thus its LWP_INFO->STATUS gets reset.
1230 Therefore the hardware watchpoint hit can get safely reset on the
1231 watchpoint removal from inferior. */
1234 update_watchpoint (struct breakpoint
*b
, int reparse
)
1236 int within_current_scope
;
1237 struct frame_id saved_frame_id
;
1240 gdb_assert (is_watchpoint (b
));
1242 /* If this is a local watchpoint, we only want to check if the
1243 watchpoint frame is in scope if the current thread is the thread
1244 that was used to create the watchpoint. */
1245 if (!watchpoint_in_thread_scope (b
))
1248 if (b
->disposition
== disp_del_at_next_stop
)
1253 /* Determine if the watchpoint is within scope. */
1254 if (b
->exp_valid_block
== NULL
)
1255 within_current_scope
= 1;
1258 struct frame_info
*fi
= get_current_frame ();
1259 struct gdbarch
*frame_arch
= get_frame_arch (fi
);
1260 CORE_ADDR frame_pc
= get_frame_pc (fi
);
1262 /* If we're in a function epilogue, unwinding may not work
1263 properly, so do not attempt to recreate locations at this
1264 point. See similar comments in watchpoint_check. */
1265 if (gdbarch_in_function_epilogue_p (frame_arch
, frame_pc
))
1268 /* Save the current frame's ID so we can restore it after
1269 evaluating the watchpoint expression on its own frame. */
1270 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
1271 took a frame parameter, so that we didn't have to change the
1274 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
1276 fi
= frame_find_by_id (b
->watchpoint_frame
);
1277 within_current_scope
= (fi
!= NULL
);
1278 if (within_current_scope
)
1282 /* We don't free locations. They are stored in the bp_location array
1283 and update_global_location_list will eventually delete them and
1284 remove breakpoints if needed. */
1287 if (within_current_scope
&& reparse
)
1296 s
= b
->exp_string_reparse
? b
->exp_string_reparse
: b
->exp_string
;
1297 b
->exp
= parse_exp_1 (&s
, b
->exp_valid_block
, 0);
1298 /* If the meaning of expression itself changed, the old value is
1299 no longer relevant. We don't want to report a watchpoint hit
1300 to the user when the old value and the new value may actually
1301 be completely different objects. */
1302 value_free (b
->val
);
1306 /* Note that unlike with breakpoints, the watchpoint's condition
1307 expression is stored in the breakpoint object, not in the
1308 locations (re)created below. */
1309 if (b
->cond_string
!= NULL
)
1311 if (b
->cond_exp
!= NULL
)
1313 xfree (b
->cond_exp
);
1318 b
->cond_exp
= parse_exp_1 (&s
, b
->cond_exp_valid_block
, 0);
1322 /* If we failed to parse the expression, for example because
1323 it refers to a global variable in a not-yet-loaded shared library,
1324 don't try to insert watchpoint. We don't automatically delete
1325 such watchpoint, though, since failure to parse expression
1326 is different from out-of-scope watchpoint. */
1327 if ( !target_has_execution
)
1329 /* Without execution, memory can't change. No use to try and
1330 set watchpoint locations. The watchpoint will be reset when
1331 the target gains execution, through breakpoint_re_set. */
1333 else if (within_current_scope
&& b
->exp
)
1336 struct value
*val_chain
, *v
, *result
, *next
;
1337 struct program_space
*frame_pspace
;
1339 fetch_subexp_value (b
->exp
, &pc
, &v
, &result
, &val_chain
);
1341 /* Avoid setting b->val if it's already set. The meaning of
1342 b->val is 'the last value' user saw, and we should update
1343 it only if we reported that last value to user. As it
1344 happens, the code that reports it updates b->val directly. */
1351 frame_pspace
= get_frame_program_space (get_selected_frame (NULL
));
1353 /* Look at each value on the value chain. */
1354 for (v
= val_chain
; v
; v
= value_next (v
))
1356 /* If it's a memory location, and GDB actually needed
1357 its contents to evaluate the expression, then we
1358 must watch it. If the first value returned is
1359 still lazy, that means an error occurred reading it;
1360 watch it anyway in case it becomes readable. */
1361 if (VALUE_LVAL (v
) == lval_memory
1362 && (v
== val_chain
|| ! value_lazy (v
)))
1364 struct type
*vtype
= check_typedef (value_type (v
));
1366 /* We only watch structs and arrays if user asked
1367 for it explicitly, never if they just happen to
1368 appear in the middle of some value chain. */
1370 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
1371 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
1375 struct bp_location
*loc
, **tmp
;
1377 addr
= value_address (v
);
1378 len
= TYPE_LENGTH (value_type (v
));
1380 if (b
->type
== bp_read_watchpoint
)
1382 else if (b
->type
== bp_access_watchpoint
)
1385 loc
= allocate_bp_location (b
);
1386 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
1389 loc
->gdbarch
= get_type_arch (value_type (v
));
1391 loc
->pspace
= frame_pspace
;
1392 loc
->address
= addr
;
1394 loc
->watchpoint_type
= type
;
1399 /* Change the type of breakpoint between hardware assisted or
1400 an ordinary watchpoint depending on the hardware support
1401 and free hardware slots. REPARSE is set when the inferior
1403 if ((b
->type
== bp_watchpoint
|| b
->type
== bp_hardware_watchpoint
)
1407 enum bp_loc_type loc_type
;
1408 struct bp_location
*bl
;
1410 reg_cnt
= can_use_hardware_watchpoint (val_chain
, b
->exact
);
1414 int i
, target_resources_ok
, other_type_used
;
1415 enum enable_state orig_enable_state
;
1417 /* We need to determine how many resources are already
1418 used for all other hardware watchpoints plus this one
1419 to see if we still have enough resources to also fit
1420 this watchpoint in as well. To guarantee the
1421 hw_watchpoint_used_count call below counts this
1422 watchpoint, make sure that it is marked as a hardware
1424 b
->type
= bp_hardware_watchpoint
;
1426 /* hw_watchpoint_used_count ignores disabled watchpoints,
1427 and b might be disabled if we're being called from
1428 do_enable_breakpoint. */
1429 orig_enable_state
= b
->enable_state
;
1430 b
->enable_state
= bp_enabled
;
1432 i
= hw_watchpoint_used_count (bp_hardware_watchpoint
,
1435 b
->enable_state
= orig_enable_state
;
1437 target_resources_ok
= target_can_use_hardware_watchpoint
1438 (bp_hardware_watchpoint
, i
, other_type_used
);
1439 if (target_resources_ok
<= 0)
1440 b
->type
= bp_watchpoint
;
1443 b
->type
= bp_watchpoint
;
1445 loc_type
= (b
->type
== bp_watchpoint
? bp_loc_other
1446 : bp_loc_hardware_watchpoint
);
1447 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
1448 bl
->loc_type
= loc_type
;
1451 for (v
= val_chain
; v
; v
= next
)
1453 next
= value_next (v
);
1458 /* If a software watchpoint is not watching any memory, then the
1459 above left it without any location set up. But,
1460 bpstat_stop_status requires a location to be able to report
1461 stops, so make sure there's at least a dummy one. */
1462 if (b
->type
== bp_watchpoint
&& b
->loc
== NULL
)
1464 b
->loc
= allocate_bp_location (b
);
1465 b
->loc
->pspace
= frame_pspace
;
1466 b
->loc
->address
= -1;
1467 b
->loc
->length
= -1;
1468 b
->loc
->watchpoint_type
= -1;
1471 else if (!within_current_scope
)
1473 printf_filtered (_("\
1474 Watchpoint %d deleted because the program has left the block\n\
1475 in which its expression is valid.\n"),
1477 watchpoint_del_at_next_stop (b
);
1480 /* Restore the selected frame. */
1482 select_frame (frame_find_by_id (saved_frame_id
));
1486 /* Returns 1 iff breakpoint location should be
1487 inserted in the inferior. */
1489 should_be_inserted (struct bp_location
*bl
)
1491 if (bl
->owner
== NULL
|| !breakpoint_enabled (bl
->owner
))
1494 if (bl
->owner
->disposition
== disp_del_at_next_stop
)
1497 if (!bl
->enabled
|| bl
->shlib_disabled
|| bl
->duplicate
)
1500 /* This is set for example, when we're attached to the parent of a
1501 vfork, and have detached from the child. The child is running
1502 free, and we expect it to do an exec or exit, at which point the
1503 OS makes the parent schedulable again (and the target reports
1504 that the vfork is done). Until the child is done with the shared
1505 memory region, do not insert breakpoints in the parent, otherwise
1506 the child could still trip on the parent's breakpoints. Since
1507 the parent is blocked anyway, it won't miss any breakpoint. */
1508 if (bl
->pspace
->breakpoints_not_allowed
)
1511 /* Tracepoints are inserted by the target at a time of its choosing,
1513 if (is_tracepoint (bl
->owner
))
1519 /* Insert a low-level "breakpoint" of some type. BL is the breakpoint
1520 location. Any error messages are printed to TMP_ERROR_STREAM; and
1521 DISABLED_BREAKS, and HW_BREAKPOINT_ERROR are used to report problems.
1523 NOTE drow/2003-09-09: This routine could be broken down to an
1524 object-style method for each breakpoint or catchpoint type. */
1526 insert_bp_location (struct bp_location
*bl
,
1527 struct ui_file
*tmp_error_stream
,
1528 int *disabled_breaks
,
1529 int *hw_breakpoint_error
)
1533 if (!should_be_inserted (bl
) || bl
->inserted
)
1536 /* Initialize the target-specific information. */
1537 memset (&bl
->target_info
, 0, sizeof (bl
->target_info
));
1538 bl
->target_info
.placed_address
= bl
->address
;
1539 bl
->target_info
.placed_address_space
= bl
->pspace
->aspace
;
1541 if (bl
->loc_type
== bp_loc_software_breakpoint
1542 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
1544 if (bl
->owner
->type
!= bp_hardware_breakpoint
)
1546 /* If the explicitly specified breakpoint type
1547 is not hardware breakpoint, check the memory map to see
1548 if the breakpoint address is in read only memory or not.
1550 Two important cases are:
1551 - location type is not hardware breakpoint, memory
1552 is readonly. We change the type of the location to
1553 hardware breakpoint.
1554 - location type is hardware breakpoint, memory is
1555 read-write. This means we've previously made the
1556 location hardware one, but then the memory map changed,
1559 When breakpoints are removed, remove_breakpoints will use
1560 location types we've just set here, the only possible
1561 problem is that memory map has changed during running
1562 program, but it's not going to work anyway with current
1564 struct mem_region
*mr
1565 = lookup_mem_region (bl
->target_info
.placed_address
);
1569 if (automatic_hardware_breakpoints
)
1571 enum bp_loc_type new_type
;
1573 if (mr
->attrib
.mode
!= MEM_RW
)
1574 new_type
= bp_loc_hardware_breakpoint
;
1576 new_type
= bp_loc_software_breakpoint
;
1578 if (new_type
!= bl
->loc_type
)
1580 static int said
= 0;
1582 bl
->loc_type
= new_type
;
1585 fprintf_filtered (gdb_stdout
,
1586 _("Note: automatically using "
1587 "hardware breakpoints for "
1588 "read-only addresses.\n"));
1593 else if (bl
->loc_type
== bp_loc_software_breakpoint
1594 && mr
->attrib
.mode
!= MEM_RW
)
1595 warning (_("cannot set software breakpoint "
1596 "at readonly address %s"),
1597 paddress (bl
->gdbarch
, bl
->address
));
1601 /* First check to see if we have to handle an overlay. */
1602 if (overlay_debugging
== ovly_off
1603 || bl
->section
== NULL
1604 || !(section_is_overlay (bl
->section
)))
1606 /* No overlay handling: just set the breakpoint. */
1608 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
1609 val
= target_insert_hw_breakpoint (bl
->gdbarch
,
1612 val
= target_insert_breakpoint (bl
->gdbarch
,
1617 /* This breakpoint is in an overlay section.
1618 Shall we set a breakpoint at the LMA? */
1619 if (!overlay_events_enabled
)
1621 /* Yes -- overlay event support is not active,
1622 so we must try to set a breakpoint at the LMA.
1623 This will not work for a hardware breakpoint. */
1624 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
1625 warning (_("hardware breakpoint %d not supported in overlay!"),
1629 CORE_ADDR addr
= overlay_unmapped_address (bl
->address
,
1631 /* Set a software (trap) breakpoint at the LMA. */
1632 bl
->overlay_target_info
= bl
->target_info
;
1633 bl
->overlay_target_info
.placed_address
= addr
;
1634 val
= target_insert_breakpoint (bl
->gdbarch
,
1635 &bl
->overlay_target_info
);
1637 fprintf_unfiltered (tmp_error_stream
,
1638 "Overlay breakpoint %d "
1639 "failed: in ROM?\n",
1643 /* Shall we set a breakpoint at the VMA? */
1644 if (section_is_mapped (bl
->section
))
1646 /* Yes. This overlay section is mapped into memory. */
1647 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
1648 val
= target_insert_hw_breakpoint (bl
->gdbarch
,
1651 val
= target_insert_breakpoint (bl
->gdbarch
,
1656 /* No. This breakpoint will not be inserted.
1657 No error, but do not mark the bp as 'inserted'. */
1664 /* Can't set the breakpoint. */
1665 if (solib_name_from_address (bl
->pspace
, bl
->address
))
1667 /* See also: disable_breakpoints_in_shlibs. */
1669 bl
->shlib_disabled
= 1;
1670 if (!*disabled_breaks
)
1672 fprintf_unfiltered (tmp_error_stream
,
1673 "Cannot insert breakpoint %d.\n",
1675 fprintf_unfiltered (tmp_error_stream
,
1676 "Temporarily disabling shared "
1677 "library breakpoints:\n");
1679 *disabled_breaks
= 1;
1680 fprintf_unfiltered (tmp_error_stream
,
1681 "breakpoint #%d\n", bl
->owner
->number
);
1685 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
1687 *hw_breakpoint_error
= 1;
1688 fprintf_unfiltered (tmp_error_stream
,
1689 "Cannot insert hardware "
1695 fprintf_unfiltered (tmp_error_stream
,
1696 "Cannot insert breakpoint %d.\n",
1698 fprintf_filtered (tmp_error_stream
,
1699 "Error accessing memory address ");
1700 fputs_filtered (paddress (bl
->gdbarch
, bl
->address
),
1702 fprintf_filtered (tmp_error_stream
, ": %s.\n",
1703 safe_strerror (val
));
1714 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
1715 /* NOTE drow/2003-09-08: This state only exists for removing
1716 watchpoints. It's not clear that it's necessary... */
1717 && bl
->owner
->disposition
!= disp_del_at_next_stop
)
1719 gdb_assert (bl
->owner
->ops
!= NULL
1720 && bl
->owner
->ops
->insert_location
!= NULL
);
1722 val
= bl
->owner
->ops
->insert_location (bl
);
1724 /* If trying to set a read-watchpoint, and it turns out it's not
1725 supported, try emulating one with an access watchpoint. */
1726 if (val
== 1 && bl
->watchpoint_type
== hw_read
)
1728 struct bp_location
*loc
, **loc_temp
;
1730 /* But don't try to insert it, if there's already another
1731 hw_access location that would be considered a duplicate
1733 ALL_BP_LOCATIONS (loc
, loc_temp
)
1735 && loc
->watchpoint_type
== hw_access
1736 && watchpoint_locations_match (bl
, loc
))
1740 bl
->target_info
= loc
->target_info
;
1741 bl
->watchpoint_type
= hw_access
;
1748 bl
->watchpoint_type
= hw_access
;
1749 val
= bl
->owner
->ops
->insert_location (bl
);
1752 /* Back to the original value. */
1753 bl
->watchpoint_type
= hw_read
;
1757 bl
->inserted
= (val
== 0);
1760 else if (bl
->owner
->type
== bp_catchpoint
)
1762 gdb_assert (bl
->owner
->ops
!= NULL
1763 && bl
->owner
->ops
->insert_location
!= NULL
);
1765 val
= bl
->owner
->ops
->insert_location (bl
);
1768 bl
->owner
->enable_state
= bp_disabled
;
1772 Error inserting catchpoint %d: Your system does not support this type\n\
1773 of catchpoint."), bl
->owner
->number
);
1775 warning (_("Error inserting catchpoint %d."), bl
->owner
->number
);
1778 bl
->inserted
= (val
== 0);
1780 /* We've already printed an error message if there was a problem
1781 inserting this catchpoint, and we've disabled the catchpoint,
1782 so just return success. */
1789 /* This function is called when program space PSPACE is about to be
1790 deleted. It takes care of updating breakpoints to not reference
1794 breakpoint_program_space_exit (struct program_space
*pspace
)
1796 struct breakpoint
*b
, *b_temp
;
1797 struct bp_location
*loc
, **loc_temp
;
1799 /* Remove any breakpoint that was set through this program space. */
1800 ALL_BREAKPOINTS_SAFE (b
, b_temp
)
1802 if (b
->pspace
== pspace
)
1803 delete_breakpoint (b
);
1806 /* Breakpoints set through other program spaces could have locations
1807 bound to PSPACE as well. Remove those. */
1808 ALL_BP_LOCATIONS (loc
, loc_temp
)
1810 struct bp_location
*tmp
;
1812 if (loc
->pspace
== pspace
)
1814 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
1815 if (loc
->owner
->loc
== loc
)
1816 loc
->owner
->loc
= loc
->next
;
1818 for (tmp
= loc
->owner
->loc
; tmp
->next
!= NULL
; tmp
= tmp
->next
)
1819 if (tmp
->next
== loc
)
1821 tmp
->next
= loc
->next
;
1827 /* Now update the global location list to permanently delete the
1828 removed locations above. */
1829 update_global_location_list (0);
1832 /* Make sure all breakpoints are inserted in inferior.
1833 Throws exception on any error.
1834 A breakpoint that is already inserted won't be inserted
1835 again, so calling this function twice is safe. */
1837 insert_breakpoints (void)
1839 struct breakpoint
*bpt
;
1841 ALL_BREAKPOINTS (bpt
)
1842 if (is_hardware_watchpoint (bpt
))
1843 update_watchpoint (bpt
, 0 /* don't reparse. */);
1845 update_global_location_list (1);
1847 /* update_global_location_list does not insert breakpoints when
1848 always_inserted_mode is not enabled. Explicitly insert them
1850 if (!breakpoints_always_inserted_mode ())
1851 insert_breakpoint_locations ();
1854 /* insert_breakpoints is used when starting or continuing the program.
1855 remove_breakpoints is used when the program stops.
1856 Both return zero if successful,
1857 or an `errno' value if could not write the inferior. */
1860 insert_breakpoint_locations (void)
1862 struct breakpoint
*bpt
;
1863 struct bp_location
*bl
, **blp_tmp
;
1866 int disabled_breaks
= 0;
1867 int hw_breakpoint_error
= 0;
1869 struct ui_file
*tmp_error_stream
= mem_fileopen ();
1870 struct cleanup
*cleanups
= make_cleanup_ui_file_delete (tmp_error_stream
);
1872 /* Explicitly mark the warning -- this will only be printed if
1873 there was an error. */
1874 fprintf_unfiltered (tmp_error_stream
, "Warning:\n");
1876 save_current_space_and_thread ();
1878 ALL_BP_LOCATIONS (bl
, blp_tmp
)
1880 if (!should_be_inserted (bl
) || bl
->inserted
)
1883 /* There is no point inserting thread-specific breakpoints if
1884 the thread no longer exists. ALL_BP_LOCATIONS bp_location
1885 has BL->OWNER always non-NULL. */
1886 if (bl
->owner
->thread
!= -1
1887 && !valid_thread_id (bl
->owner
->thread
))
1890 switch_to_program_space_and_thread (bl
->pspace
);
1892 /* For targets that support global breakpoints, there's no need
1893 to select an inferior to insert breakpoint to. In fact, even
1894 if we aren't attached to any process yet, we should still
1895 insert breakpoints. */
1896 if (!gdbarch_has_global_breakpoints (target_gdbarch
)
1897 && ptid_equal (inferior_ptid
, null_ptid
))
1900 val
= insert_bp_location (bl
, tmp_error_stream
, &disabled_breaks
,
1901 &hw_breakpoint_error
);
1906 /* If we failed to insert all locations of a watchpoint, remove
1907 them, as half-inserted watchpoint is of limited use. */
1908 ALL_BREAKPOINTS (bpt
)
1910 int some_failed
= 0;
1911 struct bp_location
*loc
;
1913 if (!is_hardware_watchpoint (bpt
))
1916 if (!breakpoint_enabled (bpt
))
1919 if (bpt
->disposition
== disp_del_at_next_stop
)
1922 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
1923 if (!loc
->inserted
&& should_be_inserted (loc
))
1930 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
1932 remove_breakpoint (loc
, mark_uninserted
);
1934 hw_breakpoint_error
= 1;
1935 fprintf_unfiltered (tmp_error_stream
,
1936 "Could not insert hardware watchpoint %d.\n",
1944 /* If a hardware breakpoint or watchpoint was inserted, add a
1945 message about possibly exhausted resources. */
1946 if (hw_breakpoint_error
)
1948 fprintf_unfiltered (tmp_error_stream
,
1949 "Could not insert hardware breakpoints:\n\
1950 You may have requested too many hardware breakpoints/watchpoints.\n");
1952 target_terminal_ours_for_output ();
1953 error_stream (tmp_error_stream
);
1956 do_cleanups (cleanups
);
1960 remove_breakpoints (void)
1962 struct bp_location
*bl
, **blp_tmp
;
1965 ALL_BP_LOCATIONS (bl
, blp_tmp
)
1968 val
|= remove_breakpoint (bl
, mark_uninserted
);
1973 /* Remove breakpoints of process PID. */
1976 remove_breakpoints_pid (int pid
)
1978 struct bp_location
*bl
, **blp_tmp
;
1980 struct inferior
*inf
= find_inferior_pid (pid
);
1982 ALL_BP_LOCATIONS (bl
, blp_tmp
)
1984 if (bl
->pspace
!= inf
->pspace
)
1989 val
= remove_breakpoint (bl
, mark_uninserted
);
1998 remove_hw_watchpoints (void)
2000 struct bp_location
*bl
, **blp_tmp
;
2003 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2005 if (bl
->inserted
&& bl
->loc_type
== bp_loc_hardware_watchpoint
)
2006 val
|= remove_breakpoint (bl
, mark_uninserted
);
2012 reattach_breakpoints (int pid
)
2014 struct cleanup
*old_chain
;
2015 struct bp_location
*bl
, **blp_tmp
;
2017 struct ui_file
*tmp_error_stream
;
2018 int dummy1
= 0, dummy2
= 0;
2019 struct inferior
*inf
;
2020 struct thread_info
*tp
;
2022 tp
= any_live_thread_of_process (pid
);
2026 inf
= find_inferior_pid (pid
);
2027 old_chain
= save_inferior_ptid ();
2029 inferior_ptid
= tp
->ptid
;
2031 tmp_error_stream
= mem_fileopen ();
2032 make_cleanup_ui_file_delete (tmp_error_stream
);
2034 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2036 if (bl
->pspace
!= inf
->pspace
)
2042 val
= insert_bp_location (bl
, tmp_error_stream
, &dummy1
, &dummy2
);
2045 do_cleanups (old_chain
);
2050 do_cleanups (old_chain
);
2054 static int internal_breakpoint_number
= -1;
2056 /* Set the breakpoint number of B, depending on the value of INTERNAL.
2057 If INTERNAL is non-zero, the breakpoint number will be populated
2058 from internal_breakpoint_number and that variable decremented.
2059 Otherwis the breakpoint number will be populated from
2060 breakpoint_count and that value incremented. Internal breakpoints
2061 do not set the internal var bpnum. */
2063 set_breakpoint_number (int internal
, struct breakpoint
*b
)
2066 b
->number
= internal_breakpoint_number
--;
2069 set_breakpoint_count (breakpoint_count
+ 1);
2070 b
->number
= breakpoint_count
;
2074 static struct breakpoint
*
2075 create_internal_breakpoint (struct gdbarch
*gdbarch
,
2076 CORE_ADDR address
, enum bptype type
)
2078 struct symtab_and_line sal
;
2079 struct breakpoint
*b
;
2081 init_sal (&sal
); /* Initialize to zeroes. */
2084 sal
.section
= find_pc_overlay (sal
.pc
);
2085 sal
.pspace
= current_program_space
;
2087 b
= set_raw_breakpoint (gdbarch
, sal
, type
);
2088 b
->number
= internal_breakpoint_number
--;
2089 b
->disposition
= disp_donttouch
;
2094 static const char *const longjmp_names
[] =
2096 "longjmp", "_longjmp", "siglongjmp", "_siglongjmp"
2098 #define NUM_LONGJMP_NAMES ARRAY_SIZE(longjmp_names)
2100 /* Per-objfile data private to breakpoint.c. */
2101 struct breakpoint_objfile_data
2103 /* Minimal symbol for "_ovly_debug_event" (if any). */
2104 struct minimal_symbol
*overlay_msym
;
2106 /* Minimal symbol(s) for "longjmp", "siglongjmp", etc. (if any). */
2107 struct minimal_symbol
*longjmp_msym
[NUM_LONGJMP_NAMES
];
2109 /* Minimal symbol for "std::terminate()" (if any). */
2110 struct minimal_symbol
*terminate_msym
;
2112 /* Minimal symbol for "_Unwind_DebugHook" (if any). */
2113 struct minimal_symbol
*exception_msym
;
2116 static const struct objfile_data
*breakpoint_objfile_key
;
2118 /* Minimal symbol not found sentinel. */
2119 static struct minimal_symbol msym_not_found
;
2121 /* Returns TRUE if MSYM point to the "not found" sentinel. */
2124 msym_not_found_p (const struct minimal_symbol
*msym
)
2126 return msym
== &msym_not_found
;
2129 /* Return per-objfile data needed by breakpoint.c.
2130 Allocate the data if necessary. */
2132 static struct breakpoint_objfile_data
*
2133 get_breakpoint_objfile_data (struct objfile
*objfile
)
2135 struct breakpoint_objfile_data
*bp_objfile_data
;
2137 bp_objfile_data
= objfile_data (objfile
, breakpoint_objfile_key
);
2138 if (bp_objfile_data
== NULL
)
2140 bp_objfile_data
= obstack_alloc (&objfile
->objfile_obstack
,
2141 sizeof (*bp_objfile_data
));
2143 memset (bp_objfile_data
, 0, sizeof (*bp_objfile_data
));
2144 set_objfile_data (objfile
, breakpoint_objfile_key
, bp_objfile_data
);
2146 return bp_objfile_data
;
2150 create_overlay_event_breakpoint (void)
2152 struct objfile
*objfile
;
2153 const char *const func_name
= "_ovly_debug_event";
2155 ALL_OBJFILES (objfile
)
2157 struct breakpoint
*b
;
2158 struct breakpoint_objfile_data
*bp_objfile_data
;
2161 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
2163 if (msym_not_found_p (bp_objfile_data
->overlay_msym
))
2166 if (bp_objfile_data
->overlay_msym
== NULL
)
2168 struct minimal_symbol
*m
;
2170 m
= lookup_minimal_symbol_text (func_name
, objfile
);
2173 /* Avoid future lookups in this objfile. */
2174 bp_objfile_data
->overlay_msym
= &msym_not_found
;
2177 bp_objfile_data
->overlay_msym
= m
;
2180 addr
= SYMBOL_VALUE_ADDRESS (bp_objfile_data
->overlay_msym
);
2181 b
= create_internal_breakpoint (get_objfile_arch (objfile
), addr
,
2183 b
->addr_string
= xstrdup (func_name
);
2185 if (overlay_debugging
== ovly_auto
)
2187 b
->enable_state
= bp_enabled
;
2188 overlay_events_enabled
= 1;
2192 b
->enable_state
= bp_disabled
;
2193 overlay_events_enabled
= 0;
2196 update_global_location_list (1);
2200 create_longjmp_master_breakpoint (void)
2202 struct program_space
*pspace
;
2203 struct cleanup
*old_chain
;
2205 old_chain
= save_current_program_space ();
2207 ALL_PSPACES (pspace
)
2209 struct objfile
*objfile
;
2211 set_current_program_space (pspace
);
2213 ALL_OBJFILES (objfile
)
2216 struct gdbarch
*gdbarch
;
2217 struct breakpoint_objfile_data
*bp_objfile_data
;
2219 gdbarch
= get_objfile_arch (objfile
);
2220 if (!gdbarch_get_longjmp_target_p (gdbarch
))
2223 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
2225 for (i
= 0; i
< NUM_LONGJMP_NAMES
; i
++)
2227 struct breakpoint
*b
;
2228 const char *func_name
;
2231 if (msym_not_found_p (bp_objfile_data
->longjmp_msym
[i
]))
2234 func_name
= longjmp_names
[i
];
2235 if (bp_objfile_data
->longjmp_msym
[i
] == NULL
)
2237 struct minimal_symbol
*m
;
2239 m
= lookup_minimal_symbol_text (func_name
, objfile
);
2242 /* Prevent future lookups in this objfile. */
2243 bp_objfile_data
->longjmp_msym
[i
] = &msym_not_found
;
2246 bp_objfile_data
->longjmp_msym
[i
] = m
;
2249 addr
= SYMBOL_VALUE_ADDRESS (bp_objfile_data
->longjmp_msym
[i
]);
2250 b
= create_internal_breakpoint (gdbarch
, addr
, bp_longjmp_master
);
2251 b
->addr_string
= xstrdup (func_name
);
2252 b
->enable_state
= bp_disabled
;
2256 update_global_location_list (1);
2258 do_cleanups (old_chain
);
2261 /* Create a master std::terminate breakpoint. */
2263 create_std_terminate_master_breakpoint (void)
2265 struct program_space
*pspace
;
2266 struct cleanup
*old_chain
;
2267 const char *const func_name
= "std::terminate()";
2269 old_chain
= save_current_program_space ();
2271 ALL_PSPACES (pspace
)
2273 struct objfile
*objfile
;
2276 set_current_program_space (pspace
);
2278 ALL_OBJFILES (objfile
)
2280 struct breakpoint
*b
;
2281 struct breakpoint_objfile_data
*bp_objfile_data
;
2283 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
2285 if (msym_not_found_p (bp_objfile_data
->terminate_msym
))
2288 if (bp_objfile_data
->terminate_msym
== NULL
)
2290 struct minimal_symbol
*m
;
2292 m
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
2293 if (m
== NULL
|| (MSYMBOL_TYPE (m
) != mst_text
2294 && MSYMBOL_TYPE (m
) != mst_file_text
))
2296 /* Prevent future lookups in this objfile. */
2297 bp_objfile_data
->terminate_msym
= &msym_not_found
;
2300 bp_objfile_data
->terminate_msym
= m
;
2303 addr
= SYMBOL_VALUE_ADDRESS (bp_objfile_data
->terminate_msym
);
2304 b
= create_internal_breakpoint (get_objfile_arch (objfile
), addr
,
2305 bp_std_terminate_master
);
2306 b
->addr_string
= xstrdup (func_name
);
2307 b
->enable_state
= bp_disabled
;
2311 update_global_location_list (1);
2313 do_cleanups (old_chain
);
2316 /* Install a master breakpoint on the unwinder's debug hook. */
2319 create_exception_master_breakpoint (void)
2321 struct objfile
*objfile
;
2322 const char *const func_name
= "_Unwind_DebugHook";
2324 ALL_OBJFILES (objfile
)
2326 struct breakpoint
*b
;
2327 struct gdbarch
*gdbarch
;
2328 struct breakpoint_objfile_data
*bp_objfile_data
;
2331 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
2333 if (msym_not_found_p (bp_objfile_data
->exception_msym
))
2336 gdbarch
= get_objfile_arch (objfile
);
2338 if (bp_objfile_data
->exception_msym
== NULL
)
2340 struct minimal_symbol
*debug_hook
;
2342 debug_hook
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
2343 if (debug_hook
== NULL
)
2345 bp_objfile_data
->exception_msym
= &msym_not_found
;
2349 bp_objfile_data
->exception_msym
= debug_hook
;
2352 addr
= SYMBOL_VALUE_ADDRESS (bp_objfile_data
->exception_msym
);
2353 addr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, addr
,
2355 b
= create_internal_breakpoint (gdbarch
, addr
, bp_exception_master
);
2356 b
->addr_string
= xstrdup (func_name
);
2357 b
->enable_state
= bp_disabled
;
2360 update_global_location_list (1);
2364 update_breakpoints_after_exec (void)
2366 struct breakpoint
*b
, *b_tmp
;
2367 struct bp_location
*bploc
, **bplocp_tmp
;
2369 /* We're about to delete breakpoints from GDB's lists. If the
2370 INSERTED flag is true, GDB will try to lift the breakpoints by
2371 writing the breakpoints' "shadow contents" back into memory. The
2372 "shadow contents" are NOT valid after an exec, so GDB should not
2373 do that. Instead, the target is responsible from marking
2374 breakpoints out as soon as it detects an exec. We don't do that
2375 here instead, because there may be other attempts to delete
2376 breakpoints after detecting an exec and before reaching here. */
2377 ALL_BP_LOCATIONS (bploc
, bplocp_tmp
)
2378 if (bploc
->pspace
== current_program_space
)
2379 gdb_assert (!bploc
->inserted
);
2381 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
2383 if (b
->pspace
!= current_program_space
)
2386 /* Solib breakpoints must be explicitly reset after an exec(). */
2387 if (b
->type
== bp_shlib_event
)
2389 delete_breakpoint (b
);
2393 /* JIT breakpoints must be explicitly reset after an exec(). */
2394 if (b
->type
== bp_jit_event
)
2396 delete_breakpoint (b
);
2400 /* Thread event breakpoints must be set anew after an exec(),
2401 as must overlay event and longjmp master breakpoints. */
2402 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
2403 || b
->type
== bp_longjmp_master
|| b
->type
== bp_std_terminate_master
2404 || b
->type
== bp_exception_master
)
2406 delete_breakpoint (b
);
2410 /* Step-resume breakpoints are meaningless after an exec(). */
2411 if (b
->type
== bp_step_resume
)
2413 delete_breakpoint (b
);
2417 /* Longjmp and longjmp-resume breakpoints are also meaningless
2419 if (b
->type
== bp_longjmp
|| b
->type
== bp_longjmp_resume
2420 || b
->type
== bp_exception
|| b
->type
== bp_exception_resume
)
2422 delete_breakpoint (b
);
2426 if (b
->type
== bp_catchpoint
)
2428 /* For now, none of the bp_catchpoint breakpoints need to
2429 do anything at this point. In the future, if some of
2430 the catchpoints need to something, we will need to add
2431 a new method, and call this method from here. */
2435 /* bp_finish is a special case. The only way we ought to be able
2436 to see one of these when an exec() has happened, is if the user
2437 caught a vfork, and then said "finish". Ordinarily a finish just
2438 carries them to the call-site of the current callee, by setting
2439 a temporary bp there and resuming. But in this case, the finish
2440 will carry them entirely through the vfork & exec.
2442 We don't want to allow a bp_finish to remain inserted now. But
2443 we can't safely delete it, 'cause finish_command has a handle to
2444 the bp on a bpstat, and will later want to delete it. There's a
2445 chance (and I've seen it happen) that if we delete the bp_finish
2446 here, that its storage will get reused by the time finish_command
2447 gets 'round to deleting the "use to be a bp_finish" breakpoint.
2448 We really must allow finish_command to delete a bp_finish.
2450 In the absense of a general solution for the "how do we know
2451 it's safe to delete something others may have handles to?"
2452 problem, what we'll do here is just uninsert the bp_finish, and
2453 let finish_command delete it.
2455 (We know the bp_finish is "doomed" in the sense that it's
2456 momentary, and will be deleted as soon as finish_command sees
2457 the inferior stopped. So it doesn't matter that the bp's
2458 address is probably bogus in the new a.out, unlike e.g., the
2459 solib breakpoints.) */
2461 if (b
->type
== bp_finish
)
2466 /* Without a symbolic address, we have little hope of the
2467 pre-exec() address meaning the same thing in the post-exec()
2469 if (b
->addr_string
== NULL
)
2471 delete_breakpoint (b
);
2475 /* FIXME what about longjmp breakpoints? Re-create them here? */
2476 create_overlay_event_breakpoint ();
2477 create_longjmp_master_breakpoint ();
2478 create_std_terminate_master_breakpoint ();
2479 create_exception_master_breakpoint ();
2483 detach_breakpoints (int pid
)
2485 struct bp_location
*bl
, **blp_tmp
;
2487 struct cleanup
*old_chain
= save_inferior_ptid ();
2488 struct inferior
*inf
= current_inferior ();
2490 if (pid
== PIDGET (inferior_ptid
))
2491 error (_("Cannot detach breakpoints of inferior_ptid"));
2493 /* Set inferior_ptid; remove_breakpoint_1 uses this global. */
2494 inferior_ptid
= pid_to_ptid (pid
);
2495 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2497 if (bl
->pspace
!= inf
->pspace
)
2501 val
|= remove_breakpoint_1 (bl
, mark_inserted
);
2504 /* Detach single-step breakpoints as well. */
2505 detach_single_step_breakpoints ();
2507 do_cleanups (old_chain
);
2511 /* Remove the breakpoint location BL from the current address space.
2512 Note that this is used to detach breakpoints from a child fork.
2513 When we get here, the child isn't in the inferior list, and neither
2514 do we have objects to represent its address space --- we should
2515 *not* look at bl->pspace->aspace here. */
2518 remove_breakpoint_1 (struct bp_location
*bl
, insertion_state_t is
)
2522 /* BL is never in moribund_locations by our callers. */
2523 gdb_assert (bl
->owner
!= NULL
);
2525 if (bl
->owner
->enable_state
== bp_permanent
)
2526 /* Permanent breakpoints cannot be inserted or removed. */
2529 /* The type of none suggests that owner is actually deleted.
2530 This should not ever happen. */
2531 gdb_assert (bl
->owner
->type
!= bp_none
);
2533 if (bl
->loc_type
== bp_loc_software_breakpoint
2534 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
2536 /* "Normal" instruction breakpoint: either the standard
2537 trap-instruction bp (bp_breakpoint), or a
2538 bp_hardware_breakpoint. */
2540 /* First check to see if we have to handle an overlay. */
2541 if (overlay_debugging
== ovly_off
2542 || bl
->section
== NULL
2543 || !(section_is_overlay (bl
->section
)))
2545 /* No overlay handling: just remove the breakpoint. */
2547 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
2548 val
= target_remove_hw_breakpoint (bl
->gdbarch
, &bl
->target_info
);
2550 val
= target_remove_breakpoint (bl
->gdbarch
, &bl
->target_info
);
2554 /* This breakpoint is in an overlay section.
2555 Did we set a breakpoint at the LMA? */
2556 if (!overlay_events_enabled
)
2558 /* Yes -- overlay event support is not active, so we
2559 should have set a breakpoint at the LMA. Remove it.
2561 /* Ignore any failures: if the LMA is in ROM, we will
2562 have already warned when we failed to insert it. */
2563 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
2564 target_remove_hw_breakpoint (bl
->gdbarch
,
2565 &bl
->overlay_target_info
);
2567 target_remove_breakpoint (bl
->gdbarch
,
2568 &bl
->overlay_target_info
);
2570 /* Did we set a breakpoint at the VMA?
2571 If so, we will have marked the breakpoint 'inserted'. */
2574 /* Yes -- remove it. Previously we did not bother to
2575 remove the breakpoint if the section had been
2576 unmapped, but let's not rely on that being safe. We
2577 don't know what the overlay manager might do. */
2578 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
2579 val
= target_remove_hw_breakpoint (bl
->gdbarch
,
2582 /* However, we should remove *software* breakpoints only
2583 if the section is still mapped, or else we overwrite
2584 wrong code with the saved shadow contents. */
2585 else if (section_is_mapped (bl
->section
))
2586 val
= target_remove_breakpoint (bl
->gdbarch
,
2593 /* No -- not inserted, so no need to remove. No error. */
2598 /* In some cases, we might not be able to remove a breakpoint
2599 in a shared library that has already been removed, but we
2600 have not yet processed the shlib unload event. */
2601 if (val
&& solib_name_from_address (bl
->pspace
, bl
->address
))
2606 bl
->inserted
= (is
== mark_inserted
);
2608 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
)
2610 gdb_assert (bl
->owner
->ops
!= NULL
2611 && bl
->owner
->ops
->remove_location
!= NULL
);
2613 bl
->inserted
= (is
== mark_inserted
);
2614 bl
->owner
->ops
->remove_location (bl
);
2616 /* Failure to remove any of the hardware watchpoints comes here. */
2617 if ((is
== mark_uninserted
) && (bl
->inserted
))
2618 warning (_("Could not remove hardware watchpoint %d."),
2621 else if (bl
->owner
->type
== bp_catchpoint
2622 && breakpoint_enabled (bl
->owner
)
2625 gdb_assert (bl
->owner
->ops
!= NULL
2626 && bl
->owner
->ops
->remove_location
!= NULL
);
2628 val
= bl
->owner
->ops
->remove_location (bl
);
2632 bl
->inserted
= (is
== mark_inserted
);
2639 remove_breakpoint (struct bp_location
*bl
, insertion_state_t is
)
2642 struct cleanup
*old_chain
;
2644 /* BL is never in moribund_locations by our callers. */
2645 gdb_assert (bl
->owner
!= NULL
);
2647 if (bl
->owner
->enable_state
== bp_permanent
)
2648 /* Permanent breakpoints cannot be inserted or removed. */
2651 /* The type of none suggests that owner is actually deleted.
2652 This should not ever happen. */
2653 gdb_assert (bl
->owner
->type
!= bp_none
);
2655 old_chain
= save_current_space_and_thread ();
2657 switch_to_program_space_and_thread (bl
->pspace
);
2659 ret
= remove_breakpoint_1 (bl
, is
);
2661 do_cleanups (old_chain
);
2665 /* Clear the "inserted" flag in all breakpoints. */
2668 mark_breakpoints_out (void)
2670 struct bp_location
*bl
, **blp_tmp
;
2672 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2673 if (bl
->pspace
== current_program_space
)
2677 /* Clear the "inserted" flag in all breakpoints and delete any
2678 breakpoints which should go away between runs of the program.
2680 Plus other such housekeeping that has to be done for breakpoints
2683 Note: this function gets called at the end of a run (by
2684 generic_mourn_inferior) and when a run begins (by
2685 init_wait_for_inferior). */
2690 breakpoint_init_inferior (enum inf_context context
)
2692 struct breakpoint
*b
, *b_tmp
;
2693 struct bp_location
*bl
, **blp_tmp
;
2695 struct program_space
*pspace
= current_program_space
;
2697 /* If breakpoint locations are shared across processes, then there's
2699 if (gdbarch_has_global_breakpoints (target_gdbarch
))
2702 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2704 /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
2705 if (bl
->pspace
== pspace
2706 && bl
->owner
->enable_state
!= bp_permanent
)
2710 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
2712 if (b
->loc
&& b
->loc
->pspace
!= pspace
)
2719 /* If the call dummy breakpoint is at the entry point it will
2720 cause problems when the inferior is rerun, so we better get
2723 case bp_watchpoint_scope
:
2725 /* Also get rid of scope breakpoints. */
2727 case bp_shlib_event
:
2729 /* Also remove solib event breakpoints. Their addresses may
2730 have changed since the last time we ran the program.
2731 Actually we may now be debugging against different target;
2732 and so the solib backend that installed this breakpoint may
2733 not be used in by the target. E.g.,
2735 (gdb) file prog-linux
2736 (gdb) run # native linux target
2739 (gdb) file prog-win.exe
2740 (gdb) tar rem :9999 # remote Windows gdbserver.
2743 delete_breakpoint (b
);
2747 case bp_hardware_watchpoint
:
2748 case bp_read_watchpoint
:
2749 case bp_access_watchpoint
:
2751 /* Likewise for watchpoints on local expressions. */
2752 if (b
->exp_valid_block
!= NULL
)
2753 delete_breakpoint (b
);
2754 else if (context
== inf_starting
)
2756 /* Reset val field to force reread of starting value in
2757 insert_breakpoints. */
2759 value_free (b
->val
);
2769 /* Get rid of the moribund locations. */
2770 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, bl
); ++ix
)
2771 decref_bp_location (&bl
);
2772 VEC_free (bp_location_p
, moribund_locations
);
2775 /* These functions concern about actual breakpoints inserted in the
2776 target --- to e.g. check if we need to do decr_pc adjustment or if
2777 we need to hop over the bkpt --- so we check for address space
2778 match, not program space. */
2780 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
2781 exists at PC. It returns ordinary_breakpoint_here if it's an
2782 ordinary breakpoint, or permanent_breakpoint_here if it's a
2783 permanent breakpoint.
2784 - When continuing from a location with an ordinary breakpoint, we
2785 actually single step once before calling insert_breakpoints.
2786 - When continuing from a localion with a permanent breakpoint, we
2787 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
2788 the target, to advance the PC past the breakpoint. */
2790 enum breakpoint_here
2791 breakpoint_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2793 struct bp_location
*bl
, **blp_tmp
;
2794 int any_breakpoint_here
= 0;
2796 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2798 if (bl
->loc_type
!= bp_loc_software_breakpoint
2799 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
2802 /* ALL_BP_LOCATIONS bp_location has bl->OWNER always non-NULL. */
2803 if ((breakpoint_enabled (bl
->owner
)
2804 || bl
->owner
->enable_state
== bp_permanent
)
2805 && breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
2808 if (overlay_debugging
2809 && section_is_overlay (bl
->section
)
2810 && !section_is_mapped (bl
->section
))
2811 continue; /* unmapped overlay -- can't be a match */
2812 else if (bl
->owner
->enable_state
== bp_permanent
)
2813 return permanent_breakpoint_here
;
2815 any_breakpoint_here
= 1;
2819 return any_breakpoint_here
? ordinary_breakpoint_here
: 0;
2822 /* Return true if there's a moribund breakpoint at PC. */
2825 moribund_breakpoint_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2827 struct bp_location
*loc
;
2830 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
2831 if (breakpoint_address_match (loc
->pspace
->aspace
, loc
->address
,
2838 /* Returns non-zero if there's a breakpoint inserted at PC, which is
2839 inserted using regular breakpoint_chain / bp_location array
2840 mechanism. This does not check for single-step breakpoints, which
2841 are inserted and removed using direct target manipulation. */
2844 regular_breakpoint_inserted_here_p (struct address_space
*aspace
,
2847 struct bp_location
*bl
, **blp_tmp
;
2849 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2851 if (bl
->loc_type
!= bp_loc_software_breakpoint
2852 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
2856 && breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
2859 if (overlay_debugging
2860 && section_is_overlay (bl
->section
)
2861 && !section_is_mapped (bl
->section
))
2862 continue; /* unmapped overlay -- can't be a match */
2870 /* Returns non-zero iff there's either regular breakpoint
2871 or a single step breakpoint inserted at PC. */
2874 breakpoint_inserted_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2876 if (regular_breakpoint_inserted_here_p (aspace
, pc
))
2879 if (single_step_breakpoint_inserted_here_p (aspace
, pc
))
2885 /* This function returns non-zero iff there is a software breakpoint
2889 software_breakpoint_inserted_here_p (struct address_space
*aspace
,
2892 struct bp_location
*bl
, **blp_tmp
;
2894 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2896 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
2900 && breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
2903 if (overlay_debugging
2904 && section_is_overlay (bl
->section
)
2905 && !section_is_mapped (bl
->section
))
2906 continue; /* unmapped overlay -- can't be a match */
2912 /* Also check for software single-step breakpoints. */
2913 if (single_step_breakpoint_inserted_here_p (aspace
, pc
))
2920 hardware_watchpoint_inserted_in_range (struct address_space
*aspace
,
2921 CORE_ADDR addr
, ULONGEST len
)
2923 struct breakpoint
*bpt
;
2925 ALL_BREAKPOINTS (bpt
)
2927 struct bp_location
*loc
;
2929 if (bpt
->type
!= bp_hardware_watchpoint
2930 && bpt
->type
!= bp_access_watchpoint
)
2933 if (!breakpoint_enabled (bpt
))
2936 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
2937 if (loc
->pspace
->aspace
== aspace
&& loc
->inserted
)
2941 /* Check for intersection. */
2942 l
= max (loc
->address
, addr
);
2943 h
= min (loc
->address
+ loc
->length
, addr
+ len
);
2951 /* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
2952 PC is valid for process/thread PTID. */
2955 breakpoint_thread_match (struct address_space
*aspace
, CORE_ADDR pc
,
2958 struct bp_location
*bl
, **blp_tmp
;
2959 /* The thread and task IDs associated to PTID, computed lazily. */
2963 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2965 if (bl
->loc_type
!= bp_loc_software_breakpoint
2966 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
2969 /* ALL_BP_LOCATIONS bp_location has bl->OWNER always non-NULL. */
2970 if (!breakpoint_enabled (bl
->owner
)
2971 && bl
->owner
->enable_state
!= bp_permanent
)
2974 if (!breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
2978 if (bl
->owner
->thread
!= -1)
2980 /* This is a thread-specific breakpoint. Check that ptid
2981 matches that thread. If thread hasn't been computed yet,
2982 it is now time to do so. */
2984 thread
= pid_to_thread_id (ptid
);
2985 if (bl
->owner
->thread
!= thread
)
2989 if (bl
->owner
->task
!= 0)
2991 /* This is a task-specific breakpoint. Check that ptid
2992 matches that task. If task hasn't been computed yet,
2993 it is now time to do so. */
2995 task
= ada_get_task_number (ptid
);
2996 if (bl
->owner
->task
!= task
)
3000 if (overlay_debugging
3001 && section_is_overlay (bl
->section
)
3002 && !section_is_mapped (bl
->section
))
3003 continue; /* unmapped overlay -- can't be a match */
3012 /* bpstat stuff. External routines' interfaces are documented
3016 ep_is_catchpoint (struct breakpoint
*ep
)
3018 return (ep
->type
== bp_catchpoint
);
3021 /* Frees any storage that is part of a bpstat. Does not walk the
3025 bpstat_free (bpstat bs
)
3027 if (bs
->old_val
!= NULL
)
3028 value_free (bs
->old_val
);
3029 decref_counted_command_line (&bs
->commands
);
3030 decref_bp_location (&bs
->bp_location_at
);
3034 /* Clear a bpstat so that it says we are not at any breakpoint.
3035 Also free any storage that is part of a bpstat. */
3038 bpstat_clear (bpstat
*bsp
)
3055 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
3056 is part of the bpstat is copied as well. */
3059 bpstat_copy (bpstat bs
)
3063 bpstat retval
= NULL
;
3068 for (; bs
!= NULL
; bs
= bs
->next
)
3070 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
3071 memcpy (tmp
, bs
, sizeof (*tmp
));
3072 incref_counted_command_line (tmp
->commands
);
3073 incref_bp_location (tmp
->bp_location_at
);
3074 if (bs
->old_val
!= NULL
)
3076 tmp
->old_val
= value_copy (bs
->old_val
);
3077 release_value (tmp
->old_val
);
3081 /* This is the first thing in the chain. */
3091 /* Find the bpstat associated with this breakpoint. */
3094 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
3099 for (; bsp
!= NULL
; bsp
= bsp
->next
)
3101 if (bsp
->breakpoint_at
== breakpoint
)
3107 /* Put in *NUM the breakpoint number of the first breakpoint we are
3108 stopped at. *BSP upon return is a bpstat which points to the
3109 remaining breakpoints stopped at (but which is not guaranteed to be
3110 good for anything but further calls to bpstat_num).
3112 Return 0 if passed a bpstat which does not indicate any breakpoints.
3113 Return -1 if stopped at a breakpoint that has been deleted since
3115 Return 1 otherwise. */
3118 bpstat_num (bpstat
*bsp
, int *num
)
3120 struct breakpoint
*b
;
3123 return 0; /* No more breakpoint values */
3125 /* We assume we'll never have several bpstats that correspond to a
3126 single breakpoint -- otherwise, this function might return the
3127 same number more than once and this will look ugly. */
3128 b
= (*bsp
)->breakpoint_at
;
3129 *bsp
= (*bsp
)->next
;
3131 return -1; /* breakpoint that's been deleted since */
3133 *num
= b
->number
; /* We have its number */
3137 /* Modify BS so that the actions will not be performed. */
3140 bpstat_clear_actions (bpstat bs
)
3142 for (; bs
!= NULL
; bs
= bs
->next
)
3144 decref_counted_command_line (&bs
->commands
);
3145 bs
->commands_left
= NULL
;
3146 if (bs
->old_val
!= NULL
)
3148 value_free (bs
->old_val
);
3154 /* Called when a command is about to proceed the inferior. */
3157 breakpoint_about_to_proceed (void)
3159 if (!ptid_equal (inferior_ptid
, null_ptid
))
3161 struct thread_info
*tp
= inferior_thread ();
3163 /* Allow inferior function calls in breakpoint commands to not
3164 interrupt the command list. When the call finishes
3165 successfully, the inferior will be standing at the same
3166 breakpoint as if nothing happened. */
3167 if (tp
->control
.in_infcall
)
3171 breakpoint_proceeded
= 1;
3174 /* Stub for cleaning up our state if we error-out of a breakpoint
3177 cleanup_executing_breakpoints (void *ignore
)
3179 executing_breakpoint_commands
= 0;
3182 /* Execute all the commands associated with all the breakpoints at
3183 this location. Any of these commands could cause the process to
3184 proceed beyond this point, etc. We look out for such changes by
3185 checking the global "breakpoint_proceeded" after each command.
3187 Returns true if a breakpoint command resumed the inferior. In that
3188 case, it is the caller's responsibility to recall it again with the
3189 bpstat of the current thread. */
3192 bpstat_do_actions_1 (bpstat
*bsp
)
3195 struct cleanup
*old_chain
;
3198 /* Avoid endless recursion if a `source' command is contained
3200 if (executing_breakpoint_commands
)
3203 executing_breakpoint_commands
= 1;
3204 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
3206 /* This pointer will iterate over the list of bpstat's. */
3209 breakpoint_proceeded
= 0;
3210 for (; bs
!= NULL
; bs
= bs
->next
)
3212 struct counted_command_line
*ccmd
;
3213 struct command_line
*cmd
;
3214 struct cleanup
*this_cmd_tree_chain
;
3216 /* Take ownership of the BSP's command tree, if it has one.
3218 The command tree could legitimately contain commands like
3219 'step' and 'next', which call clear_proceed_status, which
3220 frees stop_bpstat's command tree. To make sure this doesn't
3221 free the tree we're executing out from under us, we need to
3222 take ownership of the tree ourselves. Since a given bpstat's
3223 commands are only executed once, we don't need to copy it; we
3224 can clear the pointer in the bpstat, and make sure we free
3225 the tree when we're done. */
3226 ccmd
= bs
->commands
;
3227 bs
->commands
= NULL
;
3229 = make_cleanup_decref_counted_command_line (&ccmd
);
3230 cmd
= bs
->commands_left
;
3231 bs
->commands_left
= NULL
;
3235 execute_control_command (cmd
);
3237 if (breakpoint_proceeded
)
3243 /* We can free this command tree now. */
3244 do_cleanups (this_cmd_tree_chain
);
3246 if (breakpoint_proceeded
)
3248 if (target_can_async_p ())
3249 /* If we are in async mode, then the target might be still
3250 running, not stopped at any breakpoint, so nothing for
3251 us to do here -- just return to the event loop. */
3254 /* In sync mode, when execute_control_command returns
3255 we're already standing on the next breakpoint.
3256 Breakpoint commands for that stop were not run, since
3257 execute_command does not run breakpoint commands --
3258 only command_line_handler does, but that one is not
3259 involved in execution of breakpoint commands. So, we
3260 can now execute breakpoint commands. It should be
3261 noted that making execute_command do bpstat actions is
3262 not an option -- in this case we'll have recursive
3263 invocation of bpstat for each breakpoint with a
3264 command, and can easily blow up GDB stack. Instead, we
3265 return true, which will trigger the caller to recall us
3266 with the new stop_bpstat. */
3271 do_cleanups (old_chain
);
3276 bpstat_do_actions (void)
3278 /* Do any commands attached to breakpoint we are stopped at. */
3279 while (!ptid_equal (inferior_ptid
, null_ptid
)
3280 && target_has_execution
3281 && !is_exited (inferior_ptid
)
3282 && !is_executing (inferior_ptid
))
3283 /* Since in sync mode, bpstat_do_actions may resume the inferior,
3284 and only return when it is stopped at the next breakpoint, we
3285 keep doing breakpoint actions until it returns false to
3286 indicate the inferior was not resumed. */
3287 if (!bpstat_do_actions_1 (&inferior_thread ()->control
.stop_bpstat
))
3291 /* Print out the (old or new) value associated with a watchpoint. */
3294 watchpoint_value_print (struct value
*val
, struct ui_file
*stream
)
3297 fprintf_unfiltered (stream
, _("<unreadable>"));
3300 struct value_print_options opts
;
3301 get_user_print_options (&opts
);
3302 value_print (val
, stream
, &opts
);
3306 /* This is the normal print function for a bpstat. In the future,
3307 much of this logic could (should?) be moved to bpstat_stop_status,
3308 by having it set different print_it values.
3310 Current scheme: When we stop, bpstat_print() is called. It loops
3311 through the bpstat list of things causing this stop, calling the
3312 print_bp_stop_message function on each one. The behavior of the
3313 print_bp_stop_message function depends on the print_it field of
3314 bpstat. If such field so indicates, call this function here.
3316 Return values from this routine (ultimately used by bpstat_print()
3317 and normal_stop() to decide what to do):
3318 PRINT_NOTHING: Means we already printed all we needed to print,
3319 don't print anything else.
3320 PRINT_SRC_ONLY: Means we printed something, and we do *not* desire
3321 that something to be followed by a location.
3322 PRINT_SCR_AND_LOC: Means we printed something, and we *do* desire
3323 that something to be followed by a location.
3324 PRINT_UNKNOWN: Means we printed nothing or we need to do some more
3327 static enum print_stop_action
3328 print_it_typical (bpstat bs
)
3330 struct cleanup
*old_chain
;
3331 struct breakpoint
*b
;
3332 const struct bp_location
*bl
;
3333 struct ui_stream
*stb
;
3335 enum print_stop_action result
;
3337 gdb_assert (bs
->bp_location_at
!= NULL
);
3339 bl
= bs
->bp_location_at
;
3340 b
= bs
->breakpoint_at
;
3342 stb
= ui_out_stream_new (uiout
);
3343 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
3348 case bp_hardware_breakpoint
:
3349 bp_temp
= b
->disposition
== disp_del
;
3350 if (bl
->address
!= bl
->requested_address
)
3351 breakpoint_adjustment_warning (bl
->requested_address
,
3354 annotate_breakpoint (b
->number
);
3356 ui_out_text (uiout
, "\nTemporary breakpoint ");
3358 ui_out_text (uiout
, "\nBreakpoint ");
3359 if (ui_out_is_mi_like_p (uiout
))
3361 ui_out_field_string (uiout
, "reason",
3362 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
3363 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
3365 ui_out_field_int (uiout
, "bkptno", b
->number
);
3366 ui_out_text (uiout
, ", ");
3367 result
= PRINT_SRC_AND_LOC
;
3370 case bp_shlib_event
:
3371 /* Did we stop because the user set the stop_on_solib_events
3372 variable? (If so, we report this as a generic, "Stopped due
3373 to shlib event" message.) */
3374 printf_filtered (_("Stopped due to shared library event\n"));
3375 result
= PRINT_NOTHING
;
3378 case bp_thread_event
:
3379 /* Not sure how we will get here.
3380 GDB should not stop for these breakpoints. */
3381 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
3382 result
= PRINT_NOTHING
;
3385 case bp_overlay_event
:
3386 /* By analogy with the thread event, GDB should not stop for these. */
3387 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
3388 result
= PRINT_NOTHING
;
3391 case bp_longjmp_master
:
3392 /* These should never be enabled. */
3393 printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
3394 result
= PRINT_NOTHING
;
3397 case bp_std_terminate_master
:
3398 /* These should never be enabled. */
3399 printf_filtered (_("std::terminate Master Breakpoint: "
3400 "gdb should not stop!\n"));
3401 result
= PRINT_NOTHING
;
3404 case bp_exception_master
:
3405 /* These should never be enabled. */
3406 printf_filtered (_("Exception Master Breakpoint: "
3407 "gdb should not stop!\n"));
3408 result
= PRINT_NOTHING
;
3412 case bp_hardware_watchpoint
:
3413 annotate_watchpoint (b
->number
);
3414 if (ui_out_is_mi_like_p (uiout
))
3417 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
3419 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
3420 ui_out_text (uiout
, "\nOld value = ");
3421 watchpoint_value_print (bs
->old_val
, stb
->stream
);
3422 ui_out_field_stream (uiout
, "old", stb
);
3423 ui_out_text (uiout
, "\nNew value = ");
3424 watchpoint_value_print (b
->val
, stb
->stream
);
3425 ui_out_field_stream (uiout
, "new", stb
);
3426 ui_out_text (uiout
, "\n");
3427 /* More than one watchpoint may have been triggered. */
3428 result
= PRINT_UNKNOWN
;
3431 case bp_read_watchpoint
:
3432 if (ui_out_is_mi_like_p (uiout
))
3435 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
3437 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
3438 ui_out_text (uiout
, "\nValue = ");
3439 watchpoint_value_print (b
->val
, stb
->stream
);
3440 ui_out_field_stream (uiout
, "value", stb
);
3441 ui_out_text (uiout
, "\n");
3442 result
= PRINT_UNKNOWN
;
3445 case bp_access_watchpoint
:
3446 if (bs
->old_val
!= NULL
)
3448 annotate_watchpoint (b
->number
);
3449 if (ui_out_is_mi_like_p (uiout
))
3452 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
3454 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
3455 ui_out_text (uiout
, "\nOld value = ");
3456 watchpoint_value_print (bs
->old_val
, stb
->stream
);
3457 ui_out_field_stream (uiout
, "old", stb
);
3458 ui_out_text (uiout
, "\nNew value = ");
3463 if (ui_out_is_mi_like_p (uiout
))
3466 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
3467 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
3468 ui_out_text (uiout
, "\nValue = ");
3470 watchpoint_value_print (b
->val
, stb
->stream
);
3471 ui_out_field_stream (uiout
, "new", stb
);
3472 ui_out_text (uiout
, "\n");
3473 result
= PRINT_UNKNOWN
;
3476 /* Fall through, we don't deal with these types of breakpoints
3480 if (ui_out_is_mi_like_p (uiout
))
3483 async_reason_lookup (EXEC_ASYNC_FUNCTION_FINISHED
));
3484 result
= PRINT_UNKNOWN
;
3488 if (ui_out_is_mi_like_p (uiout
))
3491 async_reason_lookup (EXEC_ASYNC_LOCATION_REACHED
));
3492 result
= PRINT_UNKNOWN
;
3497 case bp_longjmp_resume
:
3499 case bp_exception_resume
:
3500 case bp_step_resume
:
3501 case bp_watchpoint_scope
:
3503 case bp_std_terminate
:
3505 case bp_fast_tracepoint
:
3508 result
= PRINT_UNKNOWN
;
3512 do_cleanups (old_chain
);
3516 /* Generic routine for printing messages indicating why we
3517 stopped. The behavior of this function depends on the value
3518 'print_it' in the bpstat structure. Under some circumstances we
3519 may decide not to print anything here and delegate the task to
3522 static enum print_stop_action
3523 print_bp_stop_message (bpstat bs
)
3525 switch (bs
->print_it
)
3528 /* Nothing should be printed for this bpstat entry. */
3529 return PRINT_UNKNOWN
;
3533 /* We still want to print the frame, but we already printed the
3534 relevant messages. */
3535 return PRINT_SRC_AND_LOC
;
3538 case print_it_normal
:
3540 struct breakpoint
*b
= bs
->breakpoint_at
;
3542 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
3543 which has since been deleted. */
3545 return PRINT_UNKNOWN
;
3547 /* Normal case. Call the breakpoint's print_it method, or
3548 print_it_typical. */
3549 if (b
->ops
!= NULL
&& b
->ops
->print_it
!= NULL
)
3550 return b
->ops
->print_it (b
);
3552 return print_it_typical (bs
);
3557 internal_error (__FILE__
, __LINE__
,
3558 _("print_bp_stop_message: unrecognized enum value"));
3563 /* Print a message indicating what happened. This is called from
3564 normal_stop(). The input to this routine is the head of the bpstat
3565 list - a list of the eventpoints that caused this stop. This
3566 routine calls the generic print routine for printing a message
3567 about reasons for stopping. This will print (for example) the
3568 "Breakpoint n," part of the output. The return value of this
3571 PRINT_UNKNOWN: Means we printed nothing.
3572 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
3573 code to print the location. An example is
3574 "Breakpoint 1, " which should be followed by
3576 PRINT_SRC_ONLY: Means we printed something, but there is no need
3577 to also print the location part of the message.
3578 An example is the catch/throw messages, which
3579 don't require a location appended to the end.
3580 PRINT_NOTHING: We have done some printing and we don't need any
3581 further info to be printed. */
3583 enum print_stop_action
3584 bpstat_print (bpstat bs
)
3588 /* Maybe another breakpoint in the chain caused us to stop.
3589 (Currently all watchpoints go on the bpstat whether hit or not.
3590 That probably could (should) be changed, provided care is taken
3591 with respect to bpstat_explains_signal). */
3592 for (; bs
; bs
= bs
->next
)
3594 val
= print_bp_stop_message (bs
);
3595 if (val
== PRINT_SRC_ONLY
3596 || val
== PRINT_SRC_AND_LOC
3597 || val
== PRINT_NOTHING
)
3601 /* We reached the end of the chain, or we got a null BS to start
3602 with and nothing was printed. */
3603 return PRINT_UNKNOWN
;
3606 /* Evaluate the expression EXP and return 1 if value is zero. This is
3607 used inside a catch_errors to evaluate the breakpoint condition.
3608 The argument is a "struct expression *" that has been cast to a
3609 "char *" to make it pass through catch_errors. */
3612 breakpoint_cond_eval (void *exp
)
3614 struct value
*mark
= value_mark ();
3615 int i
= !value_true (evaluate_expression ((struct expression
*) exp
));
3617 value_free_to_mark (mark
);
3621 /* Allocate a new bpstat. Link it to the FIFO list by BS_LINK_POINTER. */
3624 bpstat_alloc (struct bp_location
*bl
, bpstat
**bs_link_pointer
)
3628 bs
= (bpstat
) xmalloc (sizeof (*bs
));
3630 **bs_link_pointer
= bs
;
3631 *bs_link_pointer
= &bs
->next
;
3632 bs
->breakpoint_at
= bl
->owner
;
3633 bs
->bp_location_at
= bl
;
3634 incref_bp_location (bl
);
3635 /* If the condition is false, etc., don't do the commands. */
3636 bs
->commands
= NULL
;
3637 bs
->commands_left
= NULL
;
3639 bs
->print_it
= print_it_normal
;
3643 /* The target has stopped with waitstatus WS. Check if any hardware
3644 watchpoints have triggered, according to the target. */
3647 watchpoints_triggered (struct target_waitstatus
*ws
)
3649 int stopped_by_watchpoint
= target_stopped_by_watchpoint ();
3651 struct breakpoint
*b
;
3653 if (!stopped_by_watchpoint
)
3655 /* We were not stopped by a watchpoint. Mark all watchpoints
3656 as not triggered. */
3658 if (is_hardware_watchpoint (b
))
3659 b
->watchpoint_triggered
= watch_triggered_no
;
3664 if (!target_stopped_data_address (¤t_target
, &addr
))
3666 /* We were stopped by a watchpoint, but we don't know where.
3667 Mark all watchpoints as unknown. */
3669 if (is_hardware_watchpoint (b
))
3670 b
->watchpoint_triggered
= watch_triggered_unknown
;
3672 return stopped_by_watchpoint
;
3675 /* The target could report the data address. Mark watchpoints
3676 affected by this data address as triggered, and all others as not
3680 if (is_hardware_watchpoint (b
))
3682 struct bp_location
*loc
;
3684 b
->watchpoint_triggered
= watch_triggered_no
;
3685 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
3686 /* Exact match not required. Within range is
3688 if (target_watchpoint_addr_within_range (¤t_target
,
3692 b
->watchpoint_triggered
= watch_triggered_yes
;
3700 /* Possible return values for watchpoint_check (this can't be an enum
3701 because of check_errors). */
3702 /* The watchpoint has been deleted. */
3703 #define WP_DELETED 1
3704 /* The value has changed. */
3705 #define WP_VALUE_CHANGED 2
3706 /* The value has not changed. */
3707 #define WP_VALUE_NOT_CHANGED 3
3708 /* Ignore this watchpoint, no matter if the value changed or not. */
3711 #define BP_TEMPFLAG 1
3712 #define BP_HARDWAREFLAG 2
3714 /* Evaluate watchpoint condition expression and check if its value
3717 P should be a pointer to struct bpstat, but is defined as a void *
3718 in order for this function to be usable with catch_errors. */
3721 watchpoint_check (void *p
)
3723 bpstat bs
= (bpstat
) p
;
3724 struct breakpoint
*b
;
3725 struct frame_info
*fr
;
3726 int within_current_scope
;
3728 /* BS is built from an existing struct breakpoint. */
3729 gdb_assert (bs
->breakpoint_at
!= NULL
);
3730 b
= bs
->breakpoint_at
;
3732 gdb_assert (is_watchpoint (b
));
3734 /* If this is a local watchpoint, we only want to check if the
3735 watchpoint frame is in scope if the current thread is the thread
3736 that was used to create the watchpoint. */
3737 if (!watchpoint_in_thread_scope (b
))
3740 if (b
->exp_valid_block
== NULL
)
3741 within_current_scope
= 1;
3744 struct frame_info
*frame
= get_current_frame ();
3745 struct gdbarch
*frame_arch
= get_frame_arch (frame
);
3746 CORE_ADDR frame_pc
= get_frame_pc (frame
);
3748 /* in_function_epilogue_p() returns a non-zero value if we're
3749 still in the function but the stack frame has already been
3750 invalidated. Since we can't rely on the values of local
3751 variables after the stack has been destroyed, we are treating
3752 the watchpoint in that state as `not changed' without further
3753 checking. Don't mark watchpoints as changed if the current
3754 frame is in an epilogue - even if they are in some other
3755 frame, our view of the stack is likely to be wrong and
3756 frame_find_by_id could error out. */
3757 if (gdbarch_in_function_epilogue_p (frame_arch
, frame_pc
))
3760 fr
= frame_find_by_id (b
->watchpoint_frame
);
3761 within_current_scope
= (fr
!= NULL
);
3763 /* If we've gotten confused in the unwinder, we might have
3764 returned a frame that can't describe this variable. */
3765 if (within_current_scope
)
3767 struct symbol
*function
;
3769 function
= get_frame_function (fr
);
3770 if (function
== NULL
3771 || !contained_in (b
->exp_valid_block
,
3772 SYMBOL_BLOCK_VALUE (function
)))
3773 within_current_scope
= 0;
3776 if (within_current_scope
)
3777 /* If we end up stopping, the current frame will get selected
3778 in normal_stop. So this call to select_frame won't affect
3783 if (within_current_scope
)
3785 /* We use value_{,free_to_}mark because it could be a *long*
3786 time before we return to the command level and call
3787 free_all_values. We can't call free_all_values because we
3788 might be in the middle of evaluating a function call. */
3791 struct value
*mark
= value_mark ();
3792 struct value
*new_val
;
3794 fetch_subexp_value (b
->exp
, &pc
, &new_val
, NULL
, NULL
);
3796 /* We use value_equal_contents instead of value_equal because
3797 the latter coerces an array to a pointer, thus comparing just
3798 the address of the array instead of its contents. This is
3799 not what we want. */
3800 if ((b
->val
!= NULL
) != (new_val
!= NULL
)
3801 || (b
->val
!= NULL
&& !value_equal_contents (b
->val
, new_val
)))
3803 if (new_val
!= NULL
)
3805 release_value (new_val
);
3806 value_free_to_mark (mark
);
3808 bs
->old_val
= b
->val
;
3811 return WP_VALUE_CHANGED
;
3815 /* Nothing changed. */
3816 value_free_to_mark (mark
);
3817 return WP_VALUE_NOT_CHANGED
;
3822 /* This seems like the only logical thing to do because
3823 if we temporarily ignored the watchpoint, then when
3824 we reenter the block in which it is valid it contains
3825 garbage (in the case of a function, it may have two
3826 garbage values, one before and one after the prologue).
3827 So we can't even detect the first assignment to it and
3828 watch after that (since the garbage may or may not equal
3829 the first value assigned). */
3830 /* We print all the stop information in print_it_typical(), but
3831 in this case, by the time we call print_it_typical() this bp
3832 will be deleted already. So we have no choice but print the
3833 information here. */
3834 if (ui_out_is_mi_like_p (uiout
))
3836 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
3837 ui_out_text (uiout
, "\nWatchpoint ");
3838 ui_out_field_int (uiout
, "wpnum", b
->number
);
3840 " deleted because the program has left the block in\n\
3841 which its expression is valid.\n");
3843 watchpoint_del_at_next_stop (b
);
3849 /* Return true if it looks like target has stopped due to hitting
3850 breakpoint location BL. This function does not check if we
3851 should stop, only if BL explains the stop. */
3853 bpstat_check_location (const struct bp_location
*bl
,
3854 struct address_space
*aspace
, CORE_ADDR bp_addr
)
3856 struct breakpoint
*b
= bl
->owner
;
3858 /* BL is from existing struct breakpoint. */
3859 gdb_assert (b
!= NULL
);
3861 /* By definition, the inferior does not report stops at
3863 if (is_tracepoint (b
))
3866 if (!is_watchpoint (b
)
3867 && b
->type
!= bp_hardware_breakpoint
3868 && b
->type
!= bp_catchpoint
) /* a non-watchpoint bp */
3870 if (!breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
3873 if (overlay_debugging
/* unmapped overlay section */
3874 && section_is_overlay (bl
->section
)
3875 && !section_is_mapped (bl
->section
))
3879 /* Continuable hardware watchpoints are treated as non-existent if the
3880 reason we stopped wasn't a hardware watchpoint (we didn't stop on
3881 some data address). Otherwise gdb won't stop on a break instruction
3882 in the code (not from a breakpoint) when a hardware watchpoint has
3883 been defined. Also skip watchpoints which we know did not trigger
3884 (did not match the data address). */
3886 if (is_hardware_watchpoint (b
)
3887 && b
->watchpoint_triggered
== watch_triggered_no
)
3890 if (b
->type
== bp_hardware_breakpoint
)
3892 if (bl
->address
!= bp_addr
)
3894 if (overlay_debugging
/* unmapped overlay section */
3895 && section_is_overlay (bl
->section
)
3896 && !section_is_mapped (bl
->section
))
3900 if (b
->type
== bp_catchpoint
)
3902 gdb_assert (b
->ops
!= NULL
&& b
->ops
->breakpoint_hit
!= NULL
);
3903 if (!b
->ops
->breakpoint_hit (b
))
3910 /* If BS refers to a watchpoint, determine if the watched values
3911 has actually changed, and we should stop. If not, set BS->stop
3914 bpstat_check_watchpoint (bpstat bs
)
3916 const struct bp_location
*bl
;
3917 struct breakpoint
*b
;
3919 /* BS is built for existing struct breakpoint. */
3920 bl
= bs
->bp_location_at
;
3921 gdb_assert (bl
!= NULL
);
3922 b
= bs
->breakpoint_at
;
3923 gdb_assert (b
!= NULL
);
3925 if (is_watchpoint (b
))
3927 int must_check_value
= 0;
3929 if (b
->type
== bp_watchpoint
)
3930 /* For a software watchpoint, we must always check the
3932 must_check_value
= 1;
3933 else if (b
->watchpoint_triggered
== watch_triggered_yes
)
3934 /* We have a hardware watchpoint (read, write, or access)
3935 and the target earlier reported an address watched by
3937 must_check_value
= 1;
3938 else if (b
->watchpoint_triggered
== watch_triggered_unknown
3939 && b
->type
== bp_hardware_watchpoint
)
3940 /* We were stopped by a hardware watchpoint, but the target could
3941 not report the data address. We must check the watchpoint's
3942 value. Access and read watchpoints are out of luck; without
3943 a data address, we can't figure it out. */
3944 must_check_value
= 1;
3946 if (must_check_value
)
3949 = xstrprintf ("Error evaluating expression for watchpoint %d\n",
3951 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
3952 int e
= catch_errors (watchpoint_check
, bs
, message
,
3954 do_cleanups (cleanups
);
3958 /* We've already printed what needs to be printed. */
3959 bs
->print_it
= print_it_done
;
3963 bs
->print_it
= print_it_noop
;
3966 case WP_VALUE_CHANGED
:
3967 if (b
->type
== bp_read_watchpoint
)
3969 /* There are two cases to consider here:
3971 1. We're watching the triggered memory for reads.
3972 In that case, trust the target, and always report
3973 the watchpoint hit to the user. Even though
3974 reads don't cause value changes, the value may
3975 have changed since the last time it was read, and
3976 since we're not trapping writes, we will not see
3977 those, and as such we should ignore our notion of
3980 2. We're watching the triggered memory for both
3981 reads and writes. There are two ways this may
3984 2.1. This is a target that can't break on data
3985 reads only, but can break on accesses (reads or
3986 writes), such as e.g., x86. We detect this case
3987 at the time we try to insert read watchpoints.
3989 2.2. Otherwise, the target supports read
3990 watchpoints, but, the user set an access or write
3991 watchpoint watching the same memory as this read
3994 If we're watching memory writes as well as reads,
3995 ignore watchpoint hits when we find that the
3996 value hasn't changed, as reads don't cause
3997 changes. This still gives false positives when
3998 the program writes the same value to memory as
3999 what there was already in memory (we will confuse
4000 it for a read), but it's much better than
4003 int other_write_watchpoint
= 0;
4005 if (bl
->watchpoint_type
== hw_read
)
4007 struct breakpoint
*other_b
;
4009 ALL_BREAKPOINTS (other_b
)
4010 if ((other_b
->type
== bp_hardware_watchpoint
4011 || other_b
->type
== bp_access_watchpoint
)
4012 && (other_b
->watchpoint_triggered
4013 == watch_triggered_yes
))
4015 other_write_watchpoint
= 1;
4020 if (other_write_watchpoint
4021 || bl
->watchpoint_type
== hw_access
)
4023 /* We're watching the same memory for writes,
4024 and the value changed since the last time we
4025 updated it, so this trap must be for a write.
4027 bs
->print_it
= print_it_noop
;
4032 case WP_VALUE_NOT_CHANGED
:
4033 if (b
->type
== bp_hardware_watchpoint
4034 || b
->type
== bp_watchpoint
)
4036 /* Don't stop: write watchpoints shouldn't fire if
4037 the value hasn't changed. */
4038 bs
->print_it
= print_it_noop
;
4046 /* Error from catch_errors. */
4047 printf_filtered (_("Watchpoint %d deleted.\n"), b
->number
);
4048 watchpoint_del_at_next_stop (b
);
4049 /* We've already printed what needs to be printed. */
4050 bs
->print_it
= print_it_done
;
4054 else /* must_check_value == 0 */
4056 /* This is a case where some watchpoint(s) triggered, but
4057 not at the address of this watchpoint, or else no
4058 watchpoint triggered after all. So don't print
4059 anything for this watchpoint. */
4060 bs
->print_it
= print_it_noop
;
4067 /* Check conditions (condition proper, frame, thread and ignore count)
4068 of breakpoint referred to by BS. If we should not stop for this
4069 breakpoint, set BS->stop to 0. */
4072 bpstat_check_breakpoint_conditions (bpstat bs
, ptid_t ptid
)
4074 int thread_id
= pid_to_thread_id (ptid
);
4075 const struct bp_location
*bl
;
4076 struct breakpoint
*b
;
4078 /* BS is built for existing struct breakpoint. */
4079 bl
= bs
->bp_location_at
;
4080 gdb_assert (bl
!= NULL
);
4081 b
= bs
->breakpoint_at
;
4082 gdb_assert (b
!= NULL
);
4084 if (frame_id_p (b
->frame_id
)
4085 && !frame_id_eq (b
->frame_id
, get_stack_frame_id (get_current_frame ())))
4089 int value_is_zero
= 0;
4090 struct expression
*cond
;
4092 /* Evaluate Python breakpoints that have a "stop"
4093 method implemented. */
4094 if (b
->py_bp_object
)
4095 bs
->stop
= gdbpy_should_stop (b
->py_bp_object
);
4097 if (is_watchpoint (b
))
4102 if (cond
&& b
->disposition
!= disp_del_at_next_stop
)
4104 int within_current_scope
= 1;
4106 /* We use value_mark and value_free_to_mark because it could
4107 be a long time before we return to the command level and
4108 call free_all_values. We can't call free_all_values
4109 because we might be in the middle of evaluating a
4111 struct value
*mark
= value_mark ();
4113 /* Need to select the frame, with all that implies so that
4114 the conditions will have the right context. Because we
4115 use the frame, we will not see an inlined function's
4116 variables when we arrive at a breakpoint at the start
4117 of the inlined function; the current frame will be the
4119 if (!is_watchpoint (b
) || b
->cond_exp_valid_block
== NULL
)
4120 select_frame (get_current_frame ());
4123 struct frame_info
*frame
;
4125 /* For local watchpoint expressions, which particular
4126 instance of a local is being watched matters, so we
4127 keep track of the frame to evaluate the expression
4128 in. To evaluate the condition however, it doesn't
4129 really matter which instantiation of the function
4130 where the condition makes sense triggers the
4131 watchpoint. This allows an expression like "watch
4132 global if q > 10" set in `func', catch writes to
4133 global on all threads that call `func', or catch
4134 writes on all recursive calls of `func' by a single
4135 thread. We simply always evaluate the condition in
4136 the innermost frame that's executing where it makes
4137 sense to evaluate the condition. It seems
4139 frame
= block_innermost_frame (b
->cond_exp_valid_block
);
4141 select_frame (frame
);
4143 within_current_scope
= 0;
4145 if (within_current_scope
)
4147 = catch_errors (breakpoint_cond_eval
, cond
,
4148 "Error in testing breakpoint condition:\n",
4152 warning (_("Watchpoint condition cannot be tested "
4153 "in the current scope"));
4154 /* If we failed to set the right context for this
4155 watchpoint, unconditionally report it. */
4158 /* FIXME-someday, should give breakpoint #. */
4159 value_free_to_mark (mark
);
4162 if (cond
&& value_is_zero
)
4166 else if (b
->thread
!= -1 && b
->thread
!= thread_id
)
4170 else if (b
->ignore_count
> 0)
4173 annotate_ignore_count_change ();
4175 /* Increase the hit count even though we don't stop. */
4182 /* Get a bpstat associated with having just stopped at address
4183 BP_ADDR in thread PTID.
4185 Determine whether we stopped at a breakpoint, etc, or whether we
4186 don't understand this stop. Result is a chain of bpstat's such
4189 if we don't understand the stop, the result is a null pointer.
4191 if we understand why we stopped, the result is not null.
4193 Each element of the chain refers to a particular breakpoint or
4194 watchpoint at which we have stopped. (We may have stopped for
4195 several reasons concurrently.)
4197 Each element of the chain has valid next, breakpoint_at,
4198 commands, FIXME??? fields. */
4201 bpstat_stop_status (struct address_space
*aspace
,
4202 CORE_ADDR bp_addr
, ptid_t ptid
)
4204 struct breakpoint
*b
= NULL
;
4205 struct bp_location
*bl
;
4206 struct bp_location
*loc
;
4207 /* First item of allocated bpstat's. */
4208 bpstat bs_head
= NULL
, *bs_link
= &bs_head
;
4209 /* Pointer to the last thing in the chain currently. */
4212 int need_remove_insert
;
4215 /* First, build the bpstat chain with locations that explain a
4216 target stop, while being careful to not set the target running,
4217 as that may invalidate locations (in particular watchpoint
4218 locations are recreated). Resuming will happen here with
4219 breakpoint conditions or watchpoint expressions that include
4220 inferior function calls. */
4224 if (!breakpoint_enabled (b
) && b
->enable_state
!= bp_permanent
)
4227 for (bl
= b
->loc
; bl
!= NULL
; bl
= bl
->next
)
4229 /* For hardware watchpoints, we look only at the first
4230 location. The watchpoint_check function will work on the
4231 entire expression, not the individual locations. For
4232 read watchpoints, the watchpoints_triggered function has
4233 checked all locations already. */
4234 if (b
->type
== bp_hardware_watchpoint
&& bl
!= b
->loc
)
4237 if (bl
->shlib_disabled
)
4240 if (!bpstat_check_location (bl
, aspace
, bp_addr
))
4243 /* Come here if it's a watchpoint, or if the break address
4246 bs
= bpstat_alloc (bl
, &bs_link
); /* Alloc a bpstat to
4249 /* Assume we stop. Should we find a watchpoint that is not
4250 actually triggered, or if the condition of the breakpoint
4251 evaluates as false, we'll reset 'stop' to 0. */
4255 /* If this is a scope breakpoint, mark the associated
4256 watchpoint as triggered so that we will handle the
4257 out-of-scope event. We'll get to the watchpoint next
4259 if (b
->type
== bp_watchpoint_scope
&& b
->related_breakpoint
!= b
)
4260 b
->related_breakpoint
->watchpoint_triggered
= watch_triggered_yes
;
4264 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
4266 if (breakpoint_address_match (loc
->pspace
->aspace
, loc
->address
,
4269 bs
= bpstat_alloc (loc
, &bs_link
);
4270 /* For hits of moribund locations, we should just proceed. */
4273 bs
->print_it
= print_it_noop
;
4277 /* Now go through the locations that caused the target to stop, and
4278 check whether we're interested in reporting this stop to higher
4279 layers, or whether we should resume the target transparently. */
4283 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
4288 bpstat_check_watchpoint (bs
);
4292 b
= bs
->breakpoint_at
;
4294 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
4295 || b
->type
== bp_longjmp_master
4296 || b
->type
== bp_std_terminate_master
4297 || b
->type
== bp_exception_master
)
4298 /* We do not stop for these. */
4301 bpstat_check_breakpoint_conditions (bs
, ptid
);
4307 /* We will stop here. */
4308 if (b
->disposition
== disp_disable
)
4310 if (b
->enable_state
!= bp_permanent
)
4311 b
->enable_state
= bp_disabled
;
4316 bs
->commands
= b
->commands
;
4317 incref_counted_command_line (bs
->commands
);
4318 bs
->commands_left
= bs
->commands
? bs
->commands
->commands
: NULL
;
4319 if (bs
->commands_left
4320 && (strcmp ("silent", bs
->commands_left
->line
) == 0
4323 bs
->commands_left
->line
) == 0)))
4325 bs
->commands_left
= bs
->commands_left
->next
;
4330 /* Print nothing for this entry if we dont stop or dont print. */
4331 if (bs
->stop
== 0 || bs
->print
== 0)
4332 bs
->print_it
= print_it_noop
;
4335 /* If we aren't stopping, the value of some hardware watchpoint may
4336 not have changed, but the intermediate memory locations we are
4337 watching may have. Don't bother if we're stopping; this will get
4339 need_remove_insert
= 0;
4340 if (! bpstat_causes_stop (bs_head
))
4341 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
4343 && bs
->breakpoint_at
4344 && is_hardware_watchpoint (bs
->breakpoint_at
))
4346 update_watchpoint (bs
->breakpoint_at
, 0 /* don't reparse. */);
4347 need_remove_insert
= 1;
4350 if (need_remove_insert
)
4351 update_global_location_list (1);
4352 else if (removed_any
)
4353 update_global_location_list (0);
4359 handle_jit_event (void)
4361 struct frame_info
*frame
;
4362 struct gdbarch
*gdbarch
;
4364 /* Switch terminal for any messages produced by
4365 breakpoint_re_set. */
4366 target_terminal_ours_for_output ();
4368 frame
= get_current_frame ();
4369 gdbarch
= get_frame_arch (frame
);
4371 jit_event_handler (gdbarch
);
4373 target_terminal_inferior ();
4376 /* Prepare WHAT final decision for infrun. */
4378 /* Decide what infrun needs to do with this bpstat. */
4381 bpstat_what (bpstat bs
)
4383 struct bpstat_what retval
;
4384 /* We need to defer calling `solib_add', as adding new symbols
4385 resets breakpoints, which in turn deletes breakpoint locations,
4386 and hence may clear unprocessed entries in the BS chain. */
4387 int shlib_event
= 0;
4390 retval
.main_action
= BPSTAT_WHAT_KEEP_CHECKING
;
4391 retval
.call_dummy
= STOP_NONE
;
4392 retval
.is_longjmp
= 0;
4394 for (; bs
!= NULL
; bs
= bs
->next
)
4396 /* Extract this BS's action. After processing each BS, we check
4397 if its action overrides all we've seem so far. */
4398 enum bpstat_what_main_action this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
4401 if (bs
->breakpoint_at
== NULL
)
4403 /* I suspect this can happen if it was a momentary
4404 breakpoint which has since been deleted. */
4407 else if (bs
->breakpoint_at
== NULL
)
4410 bptype
= bs
->breakpoint_at
->type
;
4417 case bp_hardware_breakpoint
:
4423 this_action
= BPSTAT_WHAT_STOP_NOISY
;
4425 this_action
= BPSTAT_WHAT_STOP_SILENT
;
4428 this_action
= BPSTAT_WHAT_SINGLE
;
4431 case bp_hardware_watchpoint
:
4432 case bp_read_watchpoint
:
4433 case bp_access_watchpoint
:
4437 this_action
= BPSTAT_WHAT_STOP_NOISY
;
4439 this_action
= BPSTAT_WHAT_STOP_SILENT
;
4443 /* There was a watchpoint, but we're not stopping.
4444 This requires no further action. */
4449 this_action
= BPSTAT_WHAT_SET_LONGJMP_RESUME
;
4450 retval
.is_longjmp
= bptype
== bp_longjmp
;
4452 case bp_longjmp_resume
:
4453 case bp_exception_resume
:
4454 this_action
= BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
;
4455 retval
.is_longjmp
= bptype
== bp_longjmp_resume
;
4457 case bp_step_resume
:
4459 this_action
= BPSTAT_WHAT_STEP_RESUME
;
4462 /* It is for the wrong frame. */
4463 this_action
= BPSTAT_WHAT_SINGLE
;
4466 case bp_watchpoint_scope
:
4467 case bp_thread_event
:
4468 case bp_overlay_event
:
4469 case bp_longjmp_master
:
4470 case bp_std_terminate_master
:
4471 case bp_exception_master
:
4472 this_action
= BPSTAT_WHAT_SINGLE
;
4478 this_action
= BPSTAT_WHAT_STOP_NOISY
;
4480 this_action
= BPSTAT_WHAT_STOP_SILENT
;
4484 /* There was a catchpoint, but we're not stopping.
4485 This requires no further action. */
4488 case bp_shlib_event
:
4491 /* If requested, stop when the dynamic linker notifies GDB
4492 of events. This allows the user to get control and place
4493 breakpoints in initializer routines for dynamically
4494 loaded objects (among other things). */
4495 if (stop_on_solib_events
)
4496 this_action
= BPSTAT_WHAT_STOP_NOISY
;
4498 this_action
= BPSTAT_WHAT_SINGLE
;
4502 this_action
= BPSTAT_WHAT_SINGLE
;
4505 /* Make sure the action is stop (silent or noisy),
4506 so infrun.c pops the dummy frame. */
4507 retval
.call_dummy
= STOP_STACK_DUMMY
;
4508 this_action
= BPSTAT_WHAT_STOP_SILENT
;
4510 case bp_std_terminate
:
4511 /* Make sure the action is stop (silent or noisy),
4512 so infrun.c pops the dummy frame. */
4513 retval
.call_dummy
= STOP_STD_TERMINATE
;
4514 this_action
= BPSTAT_WHAT_STOP_SILENT
;
4517 case bp_fast_tracepoint
:
4518 case bp_static_tracepoint
:
4519 /* Tracepoint hits should not be reported back to GDB, and
4520 if one got through somehow, it should have been filtered
4522 internal_error (__FILE__
, __LINE__
,
4523 _("bpstat_what: tracepoint encountered"));
4525 internal_error (__FILE__
, __LINE__
,
4526 _("bpstat_what: unhandled bptype %d"), (int) bptype
);
4529 retval
.main_action
= max (retval
.main_action
, this_action
);
4535 fprintf_unfiltered (gdb_stdlog
, "bpstat_what: bp_shlib_event\n");
4537 /* Check for any newly added shared libraries if we're supposed
4538 to be adding them automatically. */
4540 /* Switch terminal for any messages produced by
4541 breakpoint_re_set. */
4542 target_terminal_ours_for_output ();
4545 SOLIB_ADD (NULL
, 0, ¤t_target
, auto_solib_add
);
4547 solib_add (NULL
, 0, ¤t_target
, auto_solib_add
);
4550 target_terminal_inferior ();
4556 fprintf_unfiltered (gdb_stdlog
, "bpstat_what: bp_jit_event\n");
4558 handle_jit_event ();
4564 /* Nonzero if we should step constantly (e.g. watchpoints on machines
4565 without hardware support). This isn't related to a specific bpstat,
4566 just to things like whether watchpoints are set. */
4569 bpstat_should_step (void)
4571 struct breakpoint
*b
;
4574 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
&& b
->loc
!= NULL
)
4580 bpstat_causes_stop (bpstat bs
)
4582 for (; bs
!= NULL
; bs
= bs
->next
)
4591 /* Compute a string of spaces suitable to indent the next line
4592 so it starts at the position corresponding to the table column
4593 named COL_NAME in the currently active table of UIOUT. */
4596 wrap_indent_at_field (struct ui_out
*uiout
, const char *col_name
)
4598 static char wrap_indent
[80];
4599 int i
, total_width
, width
, align
;
4603 for (i
= 1; ui_out_query_field (uiout
, i
, &width
, &align
, &text
); i
++)
4605 if (strcmp (text
, col_name
) == 0)
4607 gdb_assert (total_width
< sizeof wrap_indent
);
4608 memset (wrap_indent
, ' ', total_width
);
4609 wrap_indent
[total_width
] = 0;
4614 total_width
+= width
+ 1;
4620 /* Print the LOC location out of the list of B->LOC locations. */
4623 print_breakpoint_location (struct breakpoint
*b
,
4624 struct bp_location
*loc
)
4626 struct cleanup
*old_chain
= save_current_program_space ();
4628 if (loc
!= NULL
&& loc
->shlib_disabled
)
4632 set_current_program_space (loc
->pspace
);
4634 if (b
->display_canonical
)
4635 ui_out_field_string (uiout
, "what", b
->addr_string
);
4636 else if (b
->source_file
&& loc
)
4639 = find_pc_sect_function (loc
->address
, loc
->section
);
4642 ui_out_text (uiout
, "in ");
4643 ui_out_field_string (uiout
, "func",
4644 SYMBOL_PRINT_NAME (sym
));
4645 ui_out_text (uiout
, " ");
4646 ui_out_wrap_hint (uiout
, wrap_indent_at_field (uiout
, "what"));
4647 ui_out_text (uiout
, "at ");
4649 ui_out_field_string (uiout
, "file", b
->source_file
);
4650 ui_out_text (uiout
, ":");
4652 if (ui_out_is_mi_like_p (uiout
))
4654 struct symtab_and_line sal
= find_pc_line (loc
->address
, 0);
4655 char *fullname
= symtab_to_fullname (sal
.symtab
);
4658 ui_out_field_string (uiout
, "fullname", fullname
);
4661 ui_out_field_int (uiout
, "line", b
->line_number
);
4665 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
4666 struct cleanup
*stb_chain
= make_cleanup_ui_out_stream_delete (stb
);
4668 print_address_symbolic (loc
->gdbarch
, loc
->address
, stb
->stream
,
4670 ui_out_field_stream (uiout
, "at", stb
);
4672 do_cleanups (stb_chain
);
4675 ui_out_field_string (uiout
, "pending", b
->addr_string
);
4677 do_cleanups (old_chain
);
4681 bptype_string (enum bptype type
)
4683 struct ep_type_description
4688 static struct ep_type_description bptypes
[] =
4690 {bp_none
, "?deleted?"},
4691 {bp_breakpoint
, "breakpoint"},
4692 {bp_hardware_breakpoint
, "hw breakpoint"},
4693 {bp_until
, "until"},
4694 {bp_finish
, "finish"},
4695 {bp_watchpoint
, "watchpoint"},
4696 {bp_hardware_watchpoint
, "hw watchpoint"},
4697 {bp_read_watchpoint
, "read watchpoint"},
4698 {bp_access_watchpoint
, "acc watchpoint"},
4699 {bp_longjmp
, "longjmp"},
4700 {bp_longjmp_resume
, "longjmp resume"},
4701 {bp_exception
, "exception"},
4702 {bp_exception_resume
, "exception resume"},
4703 {bp_step_resume
, "step resume"},
4704 {bp_watchpoint_scope
, "watchpoint scope"},
4705 {bp_call_dummy
, "call dummy"},
4706 {bp_std_terminate
, "std::terminate"},
4707 {bp_shlib_event
, "shlib events"},
4708 {bp_thread_event
, "thread events"},
4709 {bp_overlay_event
, "overlay events"},
4710 {bp_longjmp_master
, "longjmp master"},
4711 {bp_std_terminate_master
, "std::terminate master"},
4712 {bp_exception_master
, "exception master"},
4713 {bp_catchpoint
, "catchpoint"},
4714 {bp_tracepoint
, "tracepoint"},
4715 {bp_fast_tracepoint
, "fast tracepoint"},
4716 {bp_static_tracepoint
, "static tracepoint"},
4717 {bp_jit_event
, "jit events"},
4720 if (((int) type
>= (sizeof (bptypes
) / sizeof (bptypes
[0])))
4721 || ((int) type
!= bptypes
[(int) type
].type
))
4722 internal_error (__FILE__
, __LINE__
,
4723 _("bptypes table does not describe type #%d."),
4726 return bptypes
[(int) type
].description
;
4729 /* Print B to gdb_stdout. */
4732 print_one_breakpoint_location (struct breakpoint
*b
,
4733 struct bp_location
*loc
,
4735 struct bp_location
**last_loc
,
4738 struct command_line
*l
;
4739 static char bpenables
[] = "nynny";
4740 struct cleanup
*bkpt_chain
;
4742 int header_of_multiple
= 0;
4743 int part_of_multiple
= (loc
!= NULL
);
4744 struct value_print_options opts
;
4746 get_user_print_options (&opts
);
4748 gdb_assert (!loc
|| loc_number
!= 0);
4749 /* See comment in print_one_breakpoint concerning treatment of
4750 breakpoints with single disabled location. */
4753 && (b
->loc
->next
!= NULL
|| !b
->loc
->enabled
)))
4754 header_of_multiple
= 1;
4759 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "bkpt");
4763 if (part_of_multiple
)
4766 formatted
= xstrprintf ("%d.%d", b
->number
, loc_number
);
4767 ui_out_field_string (uiout
, "number", formatted
);
4772 ui_out_field_int (uiout
, "number", b
->number
);
4777 if (part_of_multiple
)
4778 ui_out_field_skip (uiout
, "type");
4780 ui_out_field_string (uiout
, "type", bptype_string (b
->type
));
4784 if (part_of_multiple
)
4785 ui_out_field_skip (uiout
, "disp");
4787 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
4792 if (part_of_multiple
)
4793 ui_out_field_string (uiout
, "enabled", loc
->enabled
? "y" : "n");
4795 ui_out_field_fmt (uiout
, "enabled", "%c",
4796 bpenables
[(int) b
->enable_state
]);
4797 ui_out_spaces (uiout
, 2);
4801 if (b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
4803 /* Although the print_one can possibly print all locations,
4804 calling it here is not likely to get any nice result. So,
4805 make sure there's just one location. */
4806 gdb_assert (b
->loc
== NULL
|| b
->loc
->next
== NULL
);
4807 b
->ops
->print_one (b
, last_loc
);
4813 internal_error (__FILE__
, __LINE__
,
4814 _("print_one_breakpoint: bp_none encountered\n"));
4818 case bp_hardware_watchpoint
:
4819 case bp_read_watchpoint
:
4820 case bp_access_watchpoint
:
4821 /* Field 4, the address, is omitted (which makes the columns
4822 not line up too nicely with the headers, but the effect
4823 is relatively readable). */
4824 if (opts
.addressprint
)
4825 ui_out_field_skip (uiout
, "addr");
4827 ui_out_field_string (uiout
, "what", b
->exp_string
);
4831 case bp_hardware_breakpoint
:
4835 case bp_longjmp_resume
:
4837 case bp_exception_resume
:
4838 case bp_step_resume
:
4839 case bp_watchpoint_scope
:
4841 case bp_std_terminate
:
4842 case bp_shlib_event
:
4843 case bp_thread_event
:
4844 case bp_overlay_event
:
4845 case bp_longjmp_master
:
4846 case bp_std_terminate_master
:
4847 case bp_exception_master
:
4849 case bp_fast_tracepoint
:
4850 case bp_static_tracepoint
:
4852 if (opts
.addressprint
)
4855 if (header_of_multiple
)
4856 ui_out_field_string (uiout
, "addr", "<MULTIPLE>");
4857 else if (b
->loc
== NULL
|| loc
->shlib_disabled
)
4858 ui_out_field_string (uiout
, "addr", "<PENDING>");
4860 ui_out_field_core_addr (uiout
, "addr",
4861 loc
->gdbarch
, loc
->address
);
4864 if (!header_of_multiple
)
4865 print_breakpoint_location (b
, loc
);
4872 /* For backward compatibility, don't display inferiors unless there
4875 && !header_of_multiple
4877 || (!gdbarch_has_global_breakpoints (target_gdbarch
)
4878 && (number_of_program_spaces () > 1
4879 || number_of_inferiors () > 1)
4880 /* LOC is for existing B, it cannot be in
4881 moribund_locations and thus having NULL OWNER. */
4882 && loc
->owner
->type
!= bp_catchpoint
)))
4884 struct inferior
*inf
;
4887 for (inf
= inferior_list
; inf
!= NULL
; inf
= inf
->next
)
4889 if (inf
->pspace
== loc
->pspace
)
4894 ui_out_text (uiout
, " inf ");
4897 ui_out_text (uiout
, ", ");
4898 ui_out_text (uiout
, plongest (inf
->num
));
4903 if (!part_of_multiple
)
4905 if (b
->thread
!= -1)
4907 /* FIXME: This seems to be redundant and lost here; see the
4908 "stop only in" line a little further down. */
4909 ui_out_text (uiout
, " thread ");
4910 ui_out_field_int (uiout
, "thread", b
->thread
);
4912 else if (b
->task
!= 0)
4914 ui_out_text (uiout
, " task ");
4915 ui_out_field_int (uiout
, "task", b
->task
);
4919 ui_out_text (uiout
, "\n");
4921 if (!part_of_multiple
&& b
->static_trace_marker_id
)
4923 gdb_assert (b
->type
== bp_static_tracepoint
);
4925 ui_out_text (uiout
, "\tmarker id is ");
4926 ui_out_field_string (uiout
, "static-tracepoint-marker-string-id",
4927 b
->static_trace_marker_id
);
4928 ui_out_text (uiout
, "\n");
4931 if (part_of_multiple
&& frame_id_p (b
->frame_id
))
4934 ui_out_text (uiout
, "\tstop only in stack frame at ");
4935 /* FIXME: cagney/2002-12-01: Shouldn't be poeking around inside
4937 ui_out_field_core_addr (uiout
, "frame",
4938 b
->gdbarch
, b
->frame_id
.stack_addr
);
4939 ui_out_text (uiout
, "\n");
4942 if (!part_of_multiple
&& b
->cond_string
&& !ada_exception_catchpoint_p (b
))
4944 /* We do not print the condition for Ada exception catchpoints
4945 because the condition is an internal implementation detail
4946 that we do not want to expose to the user. */
4948 if (is_tracepoint (b
))
4949 ui_out_text (uiout
, "\ttrace only if ");
4951 ui_out_text (uiout
, "\tstop only if ");
4952 ui_out_field_string (uiout
, "cond", b
->cond_string
);
4953 ui_out_text (uiout
, "\n");
4956 if (!part_of_multiple
&& b
->thread
!= -1)
4958 /* FIXME should make an annotation for this. */
4959 ui_out_text (uiout
, "\tstop only in thread ");
4960 ui_out_field_int (uiout
, "thread", b
->thread
);
4961 ui_out_text (uiout
, "\n");
4964 if (!part_of_multiple
&& b
->hit_count
)
4966 /* FIXME should make an annotation for this. */
4967 if (ep_is_catchpoint (b
))
4968 ui_out_text (uiout
, "\tcatchpoint");
4970 ui_out_text (uiout
, "\tbreakpoint");
4971 ui_out_text (uiout
, " already hit ");
4972 ui_out_field_int (uiout
, "times", b
->hit_count
);
4973 if (b
->hit_count
== 1)
4974 ui_out_text (uiout
, " time\n");
4976 ui_out_text (uiout
, " times\n");
4979 /* Output the count also if it is zero, but only if this is mi.
4980 FIXME: Should have a better test for this. */
4981 if (ui_out_is_mi_like_p (uiout
))
4982 if (!part_of_multiple
&& b
->hit_count
== 0)
4983 ui_out_field_int (uiout
, "times", b
->hit_count
);
4985 if (!part_of_multiple
&& b
->ignore_count
)
4988 ui_out_text (uiout
, "\tignore next ");
4989 ui_out_field_int (uiout
, "ignore", b
->ignore_count
);
4990 ui_out_text (uiout
, " hits\n");
4993 l
= b
->commands
? b
->commands
->commands
: NULL
;
4994 if (!part_of_multiple
&& l
)
4996 struct cleanup
*script_chain
;
4999 script_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "script");
5000 print_command_lines (uiout
, l
, 4);
5001 do_cleanups (script_chain
);
5004 if (!part_of_multiple
&& b
->pass_count
)
5006 annotate_field (10);
5007 ui_out_text (uiout
, "\tpass count ");
5008 ui_out_field_int (uiout
, "pass", b
->pass_count
);
5009 ui_out_text (uiout
, " \n");
5012 if (ui_out_is_mi_like_p (uiout
) && !part_of_multiple
)
5015 ui_out_field_string (uiout
, "original-location", b
->addr_string
);
5016 else if (b
->exp_string
)
5017 ui_out_field_string (uiout
, "original-location", b
->exp_string
);
5020 do_cleanups (bkpt_chain
);
5024 print_one_breakpoint (struct breakpoint
*b
,
5025 struct bp_location
**last_loc
,
5028 print_one_breakpoint_location (b
, NULL
, 0, last_loc
, allflag
);
5030 /* If this breakpoint has custom print function,
5031 it's already printed. Otherwise, print individual
5032 locations, if any. */
5033 if (b
->ops
== NULL
|| b
->ops
->print_one
== NULL
)
5035 /* If breakpoint has a single location that is disabled, we
5036 print it as if it had several locations, since otherwise it's
5037 hard to represent "breakpoint enabled, location disabled"
5040 Note that while hardware watchpoints have several locations
5041 internally, that's not a property exposed to user. */
5043 && !is_hardware_watchpoint (b
)
5044 && (b
->loc
->next
|| !b
->loc
->enabled
)
5045 && !ui_out_is_mi_like_p (uiout
))
5047 struct bp_location
*loc
;
5049 for (loc
= b
->loc
; loc
; loc
= loc
->next
, ++n
)
5050 print_one_breakpoint_location (b
, loc
, n
, last_loc
, allflag
);
5056 breakpoint_address_bits (struct breakpoint
*b
)
5058 int print_address_bits
= 0;
5059 struct bp_location
*loc
;
5061 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
5065 /* Software watchpoints that aren't watching memory don't have
5066 an address to print. */
5067 if (b
->type
== bp_watchpoint
&& loc
->watchpoint_type
== -1)
5070 addr_bit
= gdbarch_addr_bit (loc
->gdbarch
);
5071 if (addr_bit
> print_address_bits
)
5072 print_address_bits
= addr_bit
;
5075 return print_address_bits
;
5078 struct captured_breakpoint_query_args
5084 do_captured_breakpoint_query (struct ui_out
*uiout
, void *data
)
5086 struct captured_breakpoint_query_args
*args
= data
;
5087 struct breakpoint
*b
;
5088 struct bp_location
*dummy_loc
= NULL
;
5092 if (args
->bnum
== b
->number
)
5094 print_one_breakpoint (b
, &dummy_loc
, 0);
5102 gdb_breakpoint_query (struct ui_out
*uiout
, int bnum
,
5103 char **error_message
)
5105 struct captured_breakpoint_query_args args
;
5108 /* For the moment we don't trust print_one_breakpoint() to not throw
5110 if (catch_exceptions_with_msg (uiout
, do_captured_breakpoint_query
, &args
,
5111 error_message
, RETURN_MASK_ALL
) < 0)
5117 /* Return non-zero if B is user settable (breakpoints, watchpoints,
5118 catchpoints, et.al.). */
5121 user_settable_breakpoint (const struct breakpoint
*b
)
5123 return (b
->type
== bp_breakpoint
5124 || b
->type
== bp_catchpoint
5125 || b
->type
== bp_hardware_breakpoint
5126 || is_tracepoint (b
)
5127 || is_watchpoint (b
));
5130 /* Return true if this breakpoint was set by the user, false if it is
5131 internal or momentary. */
5134 user_breakpoint_p (struct breakpoint
*b
)
5136 return user_settable_breakpoint (b
) && b
->number
> 0;
5139 /* Print information on user settable breakpoint (watchpoint, etc)
5140 number BNUM. If BNUM is -1 print all user-settable breakpoints.
5141 If ALLFLAG is non-zero, include non-user-settable breakpoints. If
5142 FILTER is non-NULL, call it on each breakpoint and only include the
5143 ones for which it returns non-zero. Return the total number of
5144 breakpoints listed. */
5147 breakpoint_1 (char *args
, int allflag
,
5148 int (*filter
) (const struct breakpoint
*))
5150 struct breakpoint
*b
;
5151 struct bp_location
*last_loc
= NULL
;
5152 int nr_printable_breakpoints
;
5153 struct cleanup
*bkpttbl_chain
;
5154 struct value_print_options opts
;
5155 int print_address_bits
= 0;
5156 int print_type_col_width
= 14;
5158 get_user_print_options (&opts
);
5160 /* Compute the number of rows in the table, as well as the size
5161 required for address fields. */
5162 nr_printable_breakpoints
= 0;
5165 /* If we have a filter, only list the breakpoints it accepts. */
5166 if (filter
&& !filter (b
))
5169 /* If we have an "args" string, it is a list of breakpoints to
5170 accept. Skip the others. */
5171 if (args
!= NULL
&& *args
!= '\0')
5173 if (allflag
&& parse_and_eval_long (args
) != b
->number
)
5175 if (!allflag
&& !number_is_in_list (args
, b
->number
))
5179 if (allflag
|| user_breakpoint_p (b
))
5181 int addr_bit
, type_len
;
5183 addr_bit
= breakpoint_address_bits (b
);
5184 if (addr_bit
> print_address_bits
)
5185 print_address_bits
= addr_bit
;
5187 type_len
= strlen (bptype_string (b
->type
));
5188 if (type_len
> print_type_col_width
)
5189 print_type_col_width
= type_len
;
5191 nr_printable_breakpoints
++;
5195 if (opts
.addressprint
)
5197 = make_cleanup_ui_out_table_begin_end (uiout
, 6,
5198 nr_printable_breakpoints
,
5202 = make_cleanup_ui_out_table_begin_end (uiout
, 5,
5203 nr_printable_breakpoints
,
5206 if (nr_printable_breakpoints
> 0)
5207 annotate_breakpoints_headers ();
5208 if (nr_printable_breakpoints
> 0)
5210 ui_out_table_header (uiout
, 7, ui_left
, "number", "Num"); /* 1 */
5211 if (nr_printable_breakpoints
> 0)
5213 ui_out_table_header (uiout
, print_type_col_width
, ui_left
,
5214 "type", "Type"); /* 2 */
5215 if (nr_printable_breakpoints
> 0)
5217 ui_out_table_header (uiout
, 4, ui_left
, "disp", "Disp"); /* 3 */
5218 if (nr_printable_breakpoints
> 0)
5220 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb"); /* 4 */
5221 if (opts
.addressprint
)
5223 if (nr_printable_breakpoints
> 0)
5225 if (print_address_bits
<= 32)
5226 ui_out_table_header (uiout
, 10, ui_left
,
5227 "addr", "Address"); /* 5 */
5229 ui_out_table_header (uiout
, 18, ui_left
,
5230 "addr", "Address"); /* 5 */
5232 if (nr_printable_breakpoints
> 0)
5234 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What"); /* 6 */
5235 ui_out_table_body (uiout
);
5236 if (nr_printable_breakpoints
> 0)
5237 annotate_breakpoints_table ();
5242 /* If we have a filter, only list the breakpoints it accepts. */
5243 if (filter
&& !filter (b
))
5246 /* If we have an "args" string, it is a list of breakpoints to
5247 accept. Skip the others. */
5249 if (args
!= NULL
&& *args
!= '\0')
5251 if (allflag
) /* maintenance info breakpoint */
5253 if (parse_and_eval_long (args
) != b
->number
)
5256 else /* all others */
5258 if (!number_is_in_list (args
, b
->number
))
5262 /* We only print out user settable breakpoints unless the
5264 if (allflag
|| user_breakpoint_p (b
))
5265 print_one_breakpoint (b
, &last_loc
, allflag
);
5268 do_cleanups (bkpttbl_chain
);
5270 if (nr_printable_breakpoints
== 0)
5272 /* If there's a filter, let the caller decide how to report
5276 if (args
== NULL
|| *args
== '\0')
5277 ui_out_message (uiout
, 0, "No breakpoints or watchpoints.\n");
5279 ui_out_message (uiout
, 0,
5280 "No breakpoint or watchpoint matching '%s'.\n",
5286 if (last_loc
&& !server_command
)
5287 set_next_address (last_loc
->gdbarch
, last_loc
->address
);
5290 /* FIXME? Should this be moved up so that it is only called when
5291 there have been breakpoints? */
5292 annotate_breakpoints_table_end ();
5294 return nr_printable_breakpoints
;
5297 /* Display the value of default-collect in a way that is generally
5298 compatible with the breakpoint list. */
5301 default_collect_info (void)
5303 /* If it has no value (which is frequently the case), say nothing; a
5304 message like "No default-collect." gets in user's face when it's
5306 if (!*default_collect
)
5309 /* The following phrase lines up nicely with per-tracepoint collect
5311 ui_out_text (uiout
, "default collect ");
5312 ui_out_field_string (uiout
, "default-collect", default_collect
);
5313 ui_out_text (uiout
, " \n");
5317 breakpoints_info (char *args
, int from_tty
)
5319 breakpoint_1 (args
, 0, NULL
);
5321 default_collect_info ();
5325 watchpoints_info (char *args
, int from_tty
)
5327 int num_printed
= breakpoint_1 (args
, 0, is_watchpoint
);
5329 if (num_printed
== 0)
5331 if (args
== NULL
|| *args
== '\0')
5332 ui_out_message (uiout
, 0, "No watchpoints.\n");
5334 ui_out_message (uiout
, 0, "No watchpoint matching '%s'.\n", args
);
5339 maintenance_info_breakpoints (char *args
, int from_tty
)
5341 breakpoint_1 (args
, 1, NULL
);
5343 default_collect_info ();
5347 breakpoint_has_pc (struct breakpoint
*b
,
5348 struct program_space
*pspace
,
5349 CORE_ADDR pc
, struct obj_section
*section
)
5351 struct bp_location
*bl
= b
->loc
;
5353 for (; bl
; bl
= bl
->next
)
5355 if (bl
->pspace
== pspace
5356 && bl
->address
== pc
5357 && (!overlay_debugging
|| bl
->section
== section
))
5363 /* Print a message describing any breakpoints set at PC. This
5364 concerns with logical breakpoints, so we match program spaces, not
5368 describe_other_breakpoints (struct gdbarch
*gdbarch
,
5369 struct program_space
*pspace
, CORE_ADDR pc
,
5370 struct obj_section
*section
, int thread
)
5373 struct breakpoint
*b
;
5376 others
+= breakpoint_has_pc (b
, pspace
, pc
, section
);
5380 printf_filtered (_("Note: breakpoint "));
5381 else /* if (others == ???) */
5382 printf_filtered (_("Note: breakpoints "));
5384 if (breakpoint_has_pc (b
, pspace
, pc
, section
))
5387 printf_filtered ("%d", b
->number
);
5388 if (b
->thread
== -1 && thread
!= -1)
5389 printf_filtered (" (all threads)");
5390 else if (b
->thread
!= -1)
5391 printf_filtered (" (thread %d)", b
->thread
);
5392 printf_filtered ("%s%s ",
5393 ((b
->enable_state
== bp_disabled
5394 || b
->enable_state
== bp_call_disabled
5395 || b
->enable_state
== bp_startup_disabled
)
5397 : b
->enable_state
== bp_permanent
5401 : ((others
== 1) ? " and" : ""));
5403 printf_filtered (_("also set at pc "));
5404 fputs_filtered (paddress (gdbarch
, pc
), gdb_stdout
);
5405 printf_filtered (".\n");
5409 /* Set the default place to put a breakpoint
5410 for the `break' command with no arguments. */
5413 set_default_breakpoint (int valid
, struct program_space
*pspace
,
5414 CORE_ADDR addr
, struct symtab
*symtab
,
5417 default_breakpoint_valid
= valid
;
5418 default_breakpoint_pspace
= pspace
;
5419 default_breakpoint_address
= addr
;
5420 default_breakpoint_symtab
= symtab
;
5421 default_breakpoint_line
= line
;
5424 /* Return true iff it is meaningful to use the address member of
5425 BPT. For some breakpoint types, the address member is irrelevant
5426 and it makes no sense to attempt to compare it to other addresses
5427 (or use it for any other purpose either).
5429 More specifically, each of the following breakpoint types will
5430 always have a zero valued address and we don't want to mark
5431 breakpoints of any of these types to be a duplicate of an actual
5432 breakpoint at address zero:
5440 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
5442 enum bptype type
= bpt
->type
;
5444 return (type
!= bp_watchpoint
&& type
!= bp_catchpoint
);
5447 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
5448 true if LOC1 and LOC2 represent the same watchpoint location. */
5451 watchpoint_locations_match (struct bp_location
*loc1
,
5452 struct bp_location
*loc2
)
5454 /* Both of them must not be in moribund_locations. */
5455 gdb_assert (loc1
->owner
!= NULL
);
5456 gdb_assert (loc2
->owner
!= NULL
);
5458 /* If the target can evaluate the condition expression in hardware,
5459 then we we need to insert both watchpoints even if they are at
5460 the same place. Otherwise the watchpoint will only trigger when
5461 the condition of whichever watchpoint was inserted evaluates to
5462 true, not giving a chance for GDB to check the condition of the
5463 other watchpoint. */
5464 if ((loc1
->owner
->cond_exp
5465 && target_can_accel_watchpoint_condition (loc1
->address
,
5467 loc1
->watchpoint_type
,
5468 loc1
->owner
->cond_exp
))
5469 || (loc2
->owner
->cond_exp
5470 && target_can_accel_watchpoint_condition (loc2
->address
,
5472 loc2
->watchpoint_type
,
5473 loc2
->owner
->cond_exp
)))
5476 /* Note that this checks the owner's type, not the location's. In
5477 case the target does not support read watchpoints, but does
5478 support access watchpoints, we'll have bp_read_watchpoint
5479 watchpoints with hw_access locations. Those should be considered
5480 duplicates of hw_read locations. The hw_read locations will
5481 become hw_access locations later. */
5482 return (loc1
->owner
->type
== loc2
->owner
->type
5483 && loc1
->pspace
->aspace
== loc2
->pspace
->aspace
5484 && loc1
->address
== loc2
->address
5485 && loc1
->length
== loc2
->length
);
5488 /* Returns true if {ASPACE1,ADDR1} and {ASPACE2,ADDR2} represent the
5489 same breakpoint location. In most targets, this can only be true
5490 if ASPACE1 matches ASPACE2. On targets that have global
5491 breakpoints, the address space doesn't really matter. */
5494 breakpoint_address_match (struct address_space
*aspace1
, CORE_ADDR addr1
,
5495 struct address_space
*aspace2
, CORE_ADDR addr2
)
5497 return ((gdbarch_has_global_breakpoints (target_gdbarch
)
5498 || aspace1
== aspace2
)
5502 /* Assuming LOC1 and LOC2's types' have meaningful target addresses
5503 (breakpoint_address_is_meaningful), returns true if LOC1 and LOC2
5504 represent the same location. */
5507 breakpoint_locations_match (struct bp_location
*loc1
,
5508 struct bp_location
*loc2
)
5510 int hw_point1
, hw_point2
;
5512 /* Both of them must not be in moribund_locations. */
5513 gdb_assert (loc1
->owner
!= NULL
);
5514 gdb_assert (loc2
->owner
!= NULL
);
5516 hw_point1
= is_hardware_watchpoint (loc1
->owner
);
5517 hw_point2
= is_hardware_watchpoint (loc2
->owner
);
5519 if (hw_point1
!= hw_point2
)
5522 return watchpoint_locations_match (loc1
, loc2
);
5524 return breakpoint_address_match (loc1
->pspace
->aspace
, loc1
->address
,
5525 loc2
->pspace
->aspace
, loc2
->address
);
5529 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
5530 int bnum
, int have_bnum
)
5532 /* The longest string possibly returned by hex_string_custom
5533 is 50 chars. These must be at least that big for safety. */
5537 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
5538 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
5540 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
5541 bnum
, astr1
, astr2
);
5543 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
5546 /* Adjust a breakpoint's address to account for architectural
5547 constraints on breakpoint placement. Return the adjusted address.
5548 Note: Very few targets require this kind of adjustment. For most
5549 targets, this function is simply the identity function. */
5552 adjust_breakpoint_address (struct gdbarch
*gdbarch
,
5553 CORE_ADDR bpaddr
, enum bptype bptype
)
5555 if (!gdbarch_adjust_breakpoint_address_p (gdbarch
))
5557 /* Very few targets need any kind of breakpoint adjustment. */
5560 else if (bptype
== bp_watchpoint
5561 || bptype
== bp_hardware_watchpoint
5562 || bptype
== bp_read_watchpoint
5563 || bptype
== bp_access_watchpoint
5564 || bptype
== bp_catchpoint
)
5566 /* Watchpoints and the various bp_catch_* eventpoints should not
5567 have their addresses modified. */
5572 CORE_ADDR adjusted_bpaddr
;
5574 /* Some targets have architectural constraints on the placement
5575 of breakpoint instructions. Obtain the adjusted address. */
5576 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (gdbarch
, bpaddr
);
5578 /* An adjusted breakpoint address can significantly alter
5579 a user's expectations. Print a warning if an adjustment
5581 if (adjusted_bpaddr
!= bpaddr
)
5582 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
5584 return adjusted_bpaddr
;
5588 /* Allocate a struct bp_location. */
5590 static struct bp_location
*
5591 allocate_bp_location (struct breakpoint
*bpt
)
5593 struct bp_location
*loc
;
5595 loc
= xmalloc (sizeof (struct bp_location
));
5596 memset (loc
, 0, sizeof (*loc
));
5600 loc
->shlib_disabled
= 0;
5609 case bp_longjmp_resume
:
5611 case bp_exception_resume
:
5612 case bp_step_resume
:
5613 case bp_watchpoint_scope
:
5615 case bp_std_terminate
:
5616 case bp_shlib_event
:
5617 case bp_thread_event
:
5618 case bp_overlay_event
:
5620 case bp_longjmp_master
:
5621 case bp_std_terminate_master
:
5622 case bp_exception_master
:
5623 loc
->loc_type
= bp_loc_software_breakpoint
;
5625 case bp_hardware_breakpoint
:
5626 loc
->loc_type
= bp_loc_hardware_breakpoint
;
5628 case bp_hardware_watchpoint
:
5629 case bp_read_watchpoint
:
5630 case bp_access_watchpoint
:
5631 loc
->loc_type
= bp_loc_hardware_watchpoint
;
5636 case bp_fast_tracepoint
:
5637 case bp_static_tracepoint
:
5638 loc
->loc_type
= bp_loc_other
;
5641 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
5649 free_bp_location (struct bp_location
*loc
)
5654 if (loc
->function_name
)
5655 xfree (loc
->function_name
);
5660 /* Increment reference count. */
5663 incref_bp_location (struct bp_location
*bl
)
5668 /* Decrement reference count. If the reference count reaches 0,
5669 destroy the bp_location. Sets *BLP to NULL. */
5672 decref_bp_location (struct bp_location
**blp
)
5674 gdb_assert ((*blp
)->refc
> 0);
5676 if (--(*blp
)->refc
== 0)
5677 free_bp_location (*blp
);
5681 /* Helper to set_raw_breakpoint below. Creates a breakpoint that has
5682 type BPTYPE and has no locations as yet. */
5683 /* This function is used in gdbtk sources and thus can not be made
5686 static struct breakpoint
*
5687 set_raw_breakpoint_without_location (struct gdbarch
*gdbarch
,
5690 struct breakpoint
*b
, *b1
;
5692 b
= (struct breakpoint
*) xmalloc (sizeof (struct breakpoint
));
5693 memset (b
, 0, sizeof (*b
));
5696 b
->gdbarch
= gdbarch
;
5697 b
->language
= current_language
->la_language
;
5698 b
->input_radix
= input_radix
;
5700 b
->enable_state
= bp_enabled
;
5703 b
->ignore_count
= 0;
5705 b
->frame_id
= null_frame_id
;
5706 b
->forked_inferior_pid
= null_ptid
;
5707 b
->exec_pathname
= NULL
;
5708 b
->syscalls_to_be_caught
= NULL
;
5710 b
->condition_not_parsed
= 0;
5711 b
->py_bp_object
= NULL
;
5712 b
->related_breakpoint
= b
;
5714 /* Add this breakpoint to the end of the chain so that a list of
5715 breakpoints will come out in order of increasing numbers. */
5717 b1
= breakpoint_chain
;
5719 breakpoint_chain
= b
;
5729 /* Initialize loc->function_name. */
5731 set_breakpoint_location_function (struct bp_location
*loc
)
5733 gdb_assert (loc
->owner
!= NULL
);
5735 if (loc
->owner
->type
== bp_breakpoint
5736 || loc
->owner
->type
== bp_hardware_breakpoint
5737 || is_tracepoint (loc
->owner
))
5739 find_pc_partial_function (loc
->address
, &(loc
->function_name
),
5741 if (loc
->function_name
)
5742 loc
->function_name
= xstrdup (loc
->function_name
);
5746 /* Attempt to determine architecture of location identified by SAL. */
5747 static struct gdbarch
*
5748 get_sal_arch (struct symtab_and_line sal
)
5751 return get_objfile_arch (sal
.section
->objfile
);
5753 return get_objfile_arch (sal
.symtab
->objfile
);
5758 /* set_raw_breakpoint is a low level routine for allocating and
5759 partially initializing a breakpoint of type BPTYPE. The newly
5760 created breakpoint's address, section, source file name, and line
5761 number are provided by SAL. The newly created and partially
5762 initialized breakpoint is added to the breakpoint chain and
5763 is also returned as the value of this function.
5765 It is expected that the caller will complete the initialization of
5766 the newly created breakpoint struct as well as output any status
5767 information regarding the creation of a new breakpoint. In
5768 particular, set_raw_breakpoint does NOT set the breakpoint
5769 number! Care should be taken to not allow an error to occur
5770 prior to completing the initialization of the breakpoint. If this
5771 should happen, a bogus breakpoint will be left on the chain. */
5774 set_raw_breakpoint (struct gdbarch
*gdbarch
,
5775 struct symtab_and_line sal
, enum bptype bptype
)
5777 struct breakpoint
*b
= set_raw_breakpoint_without_location (gdbarch
,
5779 CORE_ADDR adjusted_address
;
5780 struct gdbarch
*loc_gdbarch
;
5782 loc_gdbarch
= get_sal_arch (sal
);
5784 loc_gdbarch
= b
->gdbarch
;
5786 if (bptype
!= bp_catchpoint
)
5787 gdb_assert (sal
.pspace
!= NULL
);
5789 /* Adjust the breakpoint's address prior to allocating a location.
5790 Once we call allocate_bp_location(), that mostly uninitialized
5791 location will be placed on the location chain. Adjustment of the
5792 breakpoint may cause target_read_memory() to be called and we do
5793 not want its scan of the location chain to find a breakpoint and
5794 location that's only been partially initialized. */
5795 adjusted_address
= adjust_breakpoint_address (loc_gdbarch
,
5798 b
->loc
= allocate_bp_location (b
);
5799 b
->loc
->gdbarch
= loc_gdbarch
;
5800 b
->loc
->requested_address
= sal
.pc
;
5801 b
->loc
->address
= adjusted_address
;
5802 b
->loc
->pspace
= sal
.pspace
;
5804 /* Store the program space that was used to set the breakpoint, for
5805 breakpoint resetting. */
5806 b
->pspace
= sal
.pspace
;
5808 if (sal
.symtab
== NULL
)
5809 b
->source_file
= NULL
;
5811 b
->source_file
= xstrdup (sal
.symtab
->filename
);
5812 b
->loc
->section
= sal
.section
;
5813 b
->line_number
= sal
.line
;
5815 set_breakpoint_location_function (b
->loc
);
5817 breakpoints_changed ();
5823 /* Note that the breakpoint object B describes a permanent breakpoint
5824 instruction, hard-wired into the inferior's code. */
5826 make_breakpoint_permanent (struct breakpoint
*b
)
5828 struct bp_location
*bl
;
5830 b
->enable_state
= bp_permanent
;
5832 /* By definition, permanent breakpoints are already present in the
5833 code. Mark all locations as inserted. For now,
5834 make_breakpoint_permanent is called in just one place, so it's
5835 hard to say if it's reasonable to have permanent breakpoint with
5836 multiple locations or not, but it's easy to implmement. */
5837 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
5841 /* Call this routine when stepping and nexting to enable a breakpoint
5842 if we do a longjmp() or 'throw' in TP. FRAME is the frame which
5843 initiated the operation. */
5846 set_longjmp_breakpoint (struct thread_info
*tp
, struct frame_id frame
)
5848 struct breakpoint
*b
, *b_tmp
;
5849 int thread
= tp
->num
;
5851 /* To avoid having to rescan all objfile symbols at every step,
5852 we maintain a list of continually-inserted but always disabled
5853 longjmp "master" breakpoints. Here, we simply create momentary
5854 clones of those and enable them for the requested thread. */
5855 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
5856 if (b
->pspace
== current_program_space
5857 && (b
->type
== bp_longjmp_master
5858 || b
->type
== bp_exception_master
))
5860 struct breakpoint
*clone
= clone_momentary_breakpoint (b
);
5862 clone
->type
= b
->type
== bp_longjmp_master
? bp_longjmp
: bp_exception
;
5863 clone
->thread
= thread
;
5866 tp
->initiating_frame
= frame
;
5869 /* Delete all longjmp breakpoints from THREAD. */
5871 delete_longjmp_breakpoint (int thread
)
5873 struct breakpoint
*b
, *b_tmp
;
5875 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
5876 if (b
->type
== bp_longjmp
|| b
->type
== bp_exception
)
5878 if (b
->thread
== thread
)
5879 delete_breakpoint (b
);
5884 enable_overlay_breakpoints (void)
5886 struct breakpoint
*b
;
5889 if (b
->type
== bp_overlay_event
)
5891 b
->enable_state
= bp_enabled
;
5892 update_global_location_list (1);
5893 overlay_events_enabled
= 1;
5898 disable_overlay_breakpoints (void)
5900 struct breakpoint
*b
;
5903 if (b
->type
== bp_overlay_event
)
5905 b
->enable_state
= bp_disabled
;
5906 update_global_location_list (0);
5907 overlay_events_enabled
= 0;
5911 /* Set an active std::terminate breakpoint for each std::terminate
5912 master breakpoint. */
5914 set_std_terminate_breakpoint (void)
5916 struct breakpoint
*b
, *b_tmp
;
5918 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
5919 if (b
->pspace
== current_program_space
5920 && b
->type
== bp_std_terminate_master
)
5922 struct breakpoint
*clone
= clone_momentary_breakpoint (b
);
5923 clone
->type
= bp_std_terminate
;
5927 /* Delete all the std::terminate breakpoints. */
5929 delete_std_terminate_breakpoint (void)
5931 struct breakpoint
*b
, *b_tmp
;
5933 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
5934 if (b
->type
== bp_std_terminate
)
5935 delete_breakpoint (b
);
5939 create_thread_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
5941 struct breakpoint
*b
;
5943 b
= create_internal_breakpoint (gdbarch
, address
, bp_thread_event
);
5945 b
->enable_state
= bp_enabled
;
5946 /* addr_string has to be used or breakpoint_re_set will delete me. */
5948 = xstrprintf ("*%s", paddress (b
->loc
->gdbarch
, b
->loc
->address
));
5950 update_global_location_list_nothrow (1);
5956 remove_thread_event_breakpoints (void)
5958 struct breakpoint
*b
, *b_tmp
;
5960 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
5961 if (b
->type
== bp_thread_event
5962 && b
->loc
->pspace
== current_program_space
)
5963 delete_breakpoint (b
);
5966 struct captured_parse_breakpoint_args
5969 struct symtabs_and_lines
*sals_p
;
5970 struct linespec_result
*canonical_p
;
5974 struct lang_and_radix
5980 /* Create a breakpoint for JIT code registration and unregistration. */
5983 create_jit_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
5985 struct breakpoint
*b
;
5987 b
= create_internal_breakpoint (gdbarch
, address
, bp_jit_event
);
5988 update_global_location_list_nothrow (1);
5992 /* Remove JIT code registration and unregistration breakpoint(s). */
5995 remove_jit_event_breakpoints (void)
5997 struct breakpoint
*b
, *b_tmp
;
5999 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
6000 if (b
->type
== bp_jit_event
6001 && b
->loc
->pspace
== current_program_space
)
6002 delete_breakpoint (b
);
6006 remove_solib_event_breakpoints (void)
6008 struct breakpoint
*b
, *b_tmp
;
6010 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
6011 if (b
->type
== bp_shlib_event
6012 && b
->loc
->pspace
== current_program_space
)
6013 delete_breakpoint (b
);
6017 create_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
6019 struct breakpoint
*b
;
6021 b
= create_internal_breakpoint (gdbarch
, address
, bp_shlib_event
);
6022 update_global_location_list_nothrow (1);
6026 /* Disable any breakpoints that are on code in shared libraries. Only
6027 apply to enabled breakpoints, disabled ones can just stay disabled. */
6030 disable_breakpoints_in_shlibs (void)
6032 struct bp_location
*loc
, **locp_tmp
;
6034 ALL_BP_LOCATIONS (loc
, locp_tmp
)
6036 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
6037 struct breakpoint
*b
= loc
->owner
;
6039 /* We apply the check to all breakpoints, including disabled for
6040 those with loc->duplicate set. This is so that when breakpoint
6041 becomes enabled, or the duplicate is removed, gdb will try to
6042 insert all breakpoints. If we don't set shlib_disabled here,
6043 we'll try to insert those breakpoints and fail. */
6044 if (((b
->type
== bp_breakpoint
)
6045 || (b
->type
== bp_jit_event
)
6046 || (b
->type
== bp_hardware_breakpoint
)
6047 || (is_tracepoint (b
)))
6048 && loc
->pspace
== current_program_space
6049 && !loc
->shlib_disabled
6051 && PC_SOLIB (loc
->address
)
6053 && solib_name_from_address (loc
->pspace
, loc
->address
)
6057 loc
->shlib_disabled
= 1;
6062 /* Disable any breakpoints that are in in an unloaded shared library.
6063 Only apply to enabled breakpoints, disabled ones can just stay
6067 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
6069 struct bp_location
*loc
, **locp_tmp
;
6070 int disabled_shlib_breaks
= 0;
6072 /* SunOS a.out shared libraries are always mapped, so do not
6073 disable breakpoints; they will only be reported as unloaded
6074 through clear_solib when GDB discards its shared library
6075 list. See clear_solib for more information. */
6076 if (exec_bfd
!= NULL
6077 && bfd_get_flavour (exec_bfd
) == bfd_target_aout_flavour
)
6080 ALL_BP_LOCATIONS (loc
, locp_tmp
)
6082 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
6083 struct breakpoint
*b
= loc
->owner
;
6085 if ((loc
->loc_type
== bp_loc_hardware_breakpoint
6086 || loc
->loc_type
== bp_loc_software_breakpoint
)
6087 && solib
->pspace
== loc
->pspace
6088 && !loc
->shlib_disabled
6089 && (b
->type
== bp_breakpoint
6090 || b
->type
== bp_jit_event
6091 || b
->type
== bp_hardware_breakpoint
)
6092 && solib_contains_address_p (solib
, loc
->address
))
6094 loc
->shlib_disabled
= 1;
6095 /* At this point, we cannot rely on remove_breakpoint
6096 succeeding so we must mark the breakpoint as not inserted
6097 to prevent future errors occurring in remove_breakpoints. */
6099 if (!disabled_shlib_breaks
)
6101 target_terminal_ours_for_output ();
6102 warning (_("Temporarily disabling breakpoints "
6103 "for unloaded shared library \"%s\""),
6106 disabled_shlib_breaks
= 1;
6111 /* FORK & VFORK catchpoints. */
6113 /* Implement the "insert" breakpoint_ops method for fork
6117 insert_catch_fork (struct bp_location
*bl
)
6119 return target_insert_fork_catchpoint (PIDGET (inferior_ptid
));
6122 /* Implement the "remove" breakpoint_ops method for fork
6126 remove_catch_fork (struct bp_location
*bl
)
6128 return target_remove_fork_catchpoint (PIDGET (inferior_ptid
));
6131 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
6135 breakpoint_hit_catch_fork (struct breakpoint
*b
)
6137 return inferior_has_forked (inferior_ptid
, &b
->forked_inferior_pid
);
6140 /* Implement the "print_it" breakpoint_ops method for fork
6143 static enum print_stop_action
6144 print_it_catch_fork (struct breakpoint
*b
)
6146 annotate_catchpoint (b
->number
);
6147 printf_filtered (_("\nCatchpoint %d (forked process %d), "),
6148 b
->number
, ptid_get_pid (b
->forked_inferior_pid
));
6149 return PRINT_SRC_AND_LOC
;
6152 /* Implement the "print_one" breakpoint_ops method for fork
6156 print_one_catch_fork (struct breakpoint
*b
, struct bp_location
**last_loc
)
6158 struct value_print_options opts
;
6160 get_user_print_options (&opts
);
6162 /* Field 4, the address, is omitted (which makes the columns not
6163 line up too nicely with the headers, but the effect is relatively
6165 if (opts
.addressprint
)
6166 ui_out_field_skip (uiout
, "addr");
6168 ui_out_text (uiout
, "fork");
6169 if (!ptid_equal (b
->forked_inferior_pid
, null_ptid
))
6171 ui_out_text (uiout
, ", process ");
6172 ui_out_field_int (uiout
, "what",
6173 ptid_get_pid (b
->forked_inferior_pid
));
6174 ui_out_spaces (uiout
, 1);
6178 /* Implement the "print_mention" breakpoint_ops method for fork
6182 print_mention_catch_fork (struct breakpoint
*b
)
6184 printf_filtered (_("Catchpoint %d (fork)"), b
->number
);
6187 /* Implement the "print_recreate" breakpoint_ops method for fork
6191 print_recreate_catch_fork (struct breakpoint
*b
, struct ui_file
*fp
)
6193 fprintf_unfiltered (fp
, "catch fork");
6196 /* The breakpoint_ops structure to be used in fork catchpoints. */
6198 static struct breakpoint_ops catch_fork_breakpoint_ops
=
6202 breakpoint_hit_catch_fork
,
6203 NULL
, /* resources_needed */
6204 print_it_catch_fork
,
6205 print_one_catch_fork
,
6206 print_mention_catch_fork
,
6207 print_recreate_catch_fork
6210 /* Implement the "insert" breakpoint_ops method for vfork
6214 insert_catch_vfork (struct bp_location
*bl
)
6216 return target_insert_vfork_catchpoint (PIDGET (inferior_ptid
));
6219 /* Implement the "remove" breakpoint_ops method for vfork
6223 remove_catch_vfork (struct bp_location
*bl
)
6225 return target_remove_vfork_catchpoint (PIDGET (inferior_ptid
));
6228 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
6232 breakpoint_hit_catch_vfork (struct breakpoint
*b
)
6234 return inferior_has_vforked (inferior_ptid
, &b
->forked_inferior_pid
);
6237 /* Implement the "print_it" breakpoint_ops method for vfork
6240 static enum print_stop_action
6241 print_it_catch_vfork (struct breakpoint
*b
)
6243 annotate_catchpoint (b
->number
);
6244 printf_filtered (_("\nCatchpoint %d (vforked process %d), "),
6245 b
->number
, ptid_get_pid (b
->forked_inferior_pid
));
6246 return PRINT_SRC_AND_LOC
;
6249 /* Implement the "print_one" breakpoint_ops method for vfork
6253 print_one_catch_vfork (struct breakpoint
*b
, struct bp_location
**last_loc
)
6255 struct value_print_options opts
;
6257 get_user_print_options (&opts
);
6258 /* Field 4, the address, is omitted (which makes the columns not
6259 line up too nicely with the headers, but the effect is relatively
6261 if (opts
.addressprint
)
6262 ui_out_field_skip (uiout
, "addr");
6264 ui_out_text (uiout
, "vfork");
6265 if (!ptid_equal (b
->forked_inferior_pid
, null_ptid
))
6267 ui_out_text (uiout
, ", process ");
6268 ui_out_field_int (uiout
, "what",
6269 ptid_get_pid (b
->forked_inferior_pid
));
6270 ui_out_spaces (uiout
, 1);
6274 /* Implement the "print_mention" breakpoint_ops method for vfork
6278 print_mention_catch_vfork (struct breakpoint
*b
)
6280 printf_filtered (_("Catchpoint %d (vfork)"), b
->number
);
6283 /* Implement the "print_recreate" breakpoint_ops method for vfork
6287 print_recreate_catch_vfork (struct breakpoint
*b
, struct ui_file
*fp
)
6289 fprintf_unfiltered (fp
, "catch vfork");
6292 /* The breakpoint_ops structure to be used in vfork catchpoints. */
6294 static struct breakpoint_ops catch_vfork_breakpoint_ops
=
6298 breakpoint_hit_catch_vfork
,
6299 NULL
, /* resources_needed */
6300 print_it_catch_vfork
,
6301 print_one_catch_vfork
,
6302 print_mention_catch_vfork
,
6303 print_recreate_catch_vfork
6306 /* Implement the "insert" breakpoint_ops method for syscall
6310 insert_catch_syscall (struct bp_location
*bl
)
6312 struct inferior
*inf
= current_inferior ();
6314 ++inf
->total_syscalls_count
;
6315 if (!bl
->owner
->syscalls_to_be_caught
)
6316 ++inf
->any_syscall_count
;
6322 VEC_iterate (int, bl
->owner
->syscalls_to_be_caught
, i
, iter
);
6327 if (iter
>= VEC_length (int, inf
->syscalls_counts
))
6329 int old_size
= VEC_length (int, inf
->syscalls_counts
);
6330 uintptr_t vec_addr_offset
6331 = old_size
* ((uintptr_t) sizeof (int));
6333 VEC_safe_grow (int, inf
->syscalls_counts
, iter
+ 1);
6334 vec_addr
= (uintptr_t) VEC_address (int, inf
->syscalls_counts
) +
6336 memset ((void *) vec_addr
, 0,
6337 (iter
+ 1 - old_size
) * sizeof (int));
6339 elem
= VEC_index (int, inf
->syscalls_counts
, iter
);
6340 VEC_replace (int, inf
->syscalls_counts
, iter
, ++elem
);
6344 return target_set_syscall_catchpoint (PIDGET (inferior_ptid
),
6345 inf
->total_syscalls_count
!= 0,
6346 inf
->any_syscall_count
,
6347 VEC_length (int, inf
->syscalls_counts
),
6348 VEC_address (int, inf
->syscalls_counts
));
6351 /* Implement the "remove" breakpoint_ops method for syscall
6355 remove_catch_syscall (struct bp_location
*bl
)
6357 struct inferior
*inf
= current_inferior ();
6359 --inf
->total_syscalls_count
;
6360 if (!bl
->owner
->syscalls_to_be_caught
)
6361 --inf
->any_syscall_count
;
6367 VEC_iterate (int, bl
->owner
->syscalls_to_be_caught
, i
, iter
);
6371 if (iter
>= VEC_length (int, inf
->syscalls_counts
))
6372 /* Shouldn't happen. */
6374 elem
= VEC_index (int, inf
->syscalls_counts
, iter
);
6375 VEC_replace (int, inf
->syscalls_counts
, iter
, --elem
);
6379 return target_set_syscall_catchpoint (PIDGET (inferior_ptid
),
6380 inf
->total_syscalls_count
!= 0,
6381 inf
->any_syscall_count
,
6382 VEC_length (int, inf
->syscalls_counts
),
6384 inf
->syscalls_counts
));
6387 /* Implement the "breakpoint_hit" breakpoint_ops method for syscall
6391 breakpoint_hit_catch_syscall (struct breakpoint
*b
)
6393 /* We must check if we are catching specific syscalls in this
6394 breakpoint. If we are, then we must guarantee that the called
6395 syscall is the same syscall we are catching. */
6396 int syscall_number
= 0;
6398 if (!inferior_has_called_syscall (inferior_ptid
, &syscall_number
))
6401 /* Now, checking if the syscall is the same. */
6402 if (b
->syscalls_to_be_caught
)
6407 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
6409 if (syscall_number
== iter
)
6419 /* Implement the "print_it" breakpoint_ops method for syscall
6422 static enum print_stop_action
6423 print_it_catch_syscall (struct breakpoint
*b
)
6425 /* These are needed because we want to know in which state a
6426 syscall is. It can be in the TARGET_WAITKIND_SYSCALL_ENTRY
6427 or TARGET_WAITKIND_SYSCALL_RETURN, and depending on it we
6428 must print "called syscall" or "returned from syscall". */
6430 struct target_waitstatus last
;
6432 struct cleanup
*old_chain
;
6435 get_last_target_status (&ptid
, &last
);
6437 get_syscall_by_number (last
.value
.syscall_number
, &s
);
6439 annotate_catchpoint (b
->number
);
6442 syscall_id
= xstrprintf ("%d", last
.value
.syscall_number
);
6444 syscall_id
= xstrprintf ("'%s'", s
.name
);
6446 old_chain
= make_cleanup (xfree
, syscall_id
);
6448 if (last
.kind
== TARGET_WAITKIND_SYSCALL_ENTRY
)
6449 printf_filtered (_("\nCatchpoint %d (call to syscall %s), "),
6450 b
->number
, syscall_id
);
6451 else if (last
.kind
== TARGET_WAITKIND_SYSCALL_RETURN
)
6452 printf_filtered (_("\nCatchpoint %d (returned from syscall %s), "),
6453 b
->number
, syscall_id
);
6455 do_cleanups (old_chain
);
6457 return PRINT_SRC_AND_LOC
;
6460 /* Implement the "print_one" breakpoint_ops method for syscall
6464 print_one_catch_syscall (struct breakpoint
*b
,
6465 struct bp_location
**last_loc
)
6467 struct value_print_options opts
;
6469 get_user_print_options (&opts
);
6470 /* Field 4, the address, is omitted (which makes the columns not
6471 line up too nicely with the headers, but the effect is relatively
6473 if (opts
.addressprint
)
6474 ui_out_field_skip (uiout
, "addr");
6477 if (b
->syscalls_to_be_caught
6478 && VEC_length (int, b
->syscalls_to_be_caught
) > 1)
6479 ui_out_text (uiout
, "syscalls \"");
6481 ui_out_text (uiout
, "syscall \"");
6483 if (b
->syscalls_to_be_caught
)
6486 char *text
= xstrprintf ("%s", "");
6489 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
6494 get_syscall_by_number (iter
, &s
);
6497 text
= xstrprintf ("%s%s, ", text
, s
.name
);
6499 text
= xstrprintf ("%s%d, ", text
, iter
);
6501 /* We have to xfree the last 'text' (now stored at 'x')
6502 because xstrprintf dinamically allocates new space for it
6506 /* Remove the last comma. */
6507 text
[strlen (text
) - 2] = '\0';
6508 ui_out_field_string (uiout
, "what", text
);
6511 ui_out_field_string (uiout
, "what", "<any syscall>");
6512 ui_out_text (uiout
, "\" ");
6515 /* Implement the "print_mention" breakpoint_ops method for syscall
6519 print_mention_catch_syscall (struct breakpoint
*b
)
6521 if (b
->syscalls_to_be_caught
)
6525 if (VEC_length (int, b
->syscalls_to_be_caught
) > 1)
6526 printf_filtered (_("Catchpoint %d (syscalls"), b
->number
);
6528 printf_filtered (_("Catchpoint %d (syscall"), b
->number
);
6531 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
6535 get_syscall_by_number (iter
, &s
);
6538 printf_filtered (" '%s' [%d]", s
.name
, s
.number
);
6540 printf_filtered (" %d", s
.number
);
6542 printf_filtered (")");
6545 printf_filtered (_("Catchpoint %d (any syscall)"),
6549 /* Implement the "print_recreate" breakpoint_ops method for syscall
6553 print_recreate_catch_syscall (struct breakpoint
*b
, struct ui_file
*fp
)
6555 fprintf_unfiltered (fp
, "catch syscall");
6557 if (b
->syscalls_to_be_caught
)
6562 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
6567 get_syscall_by_number (iter
, &s
);
6569 fprintf_unfiltered (fp
, " %s", s
.name
);
6571 fprintf_unfiltered (fp
, " %d", s
.number
);
6576 /* The breakpoint_ops structure to be used in syscall catchpoints. */
6578 static struct breakpoint_ops catch_syscall_breakpoint_ops
=
6580 insert_catch_syscall
,
6581 remove_catch_syscall
,
6582 breakpoint_hit_catch_syscall
,
6583 NULL
, /* resources_needed */
6584 print_it_catch_syscall
,
6585 print_one_catch_syscall
,
6586 print_mention_catch_syscall
,
6587 print_recreate_catch_syscall
6590 /* Returns non-zero if 'b' is a syscall catchpoint. */
6593 syscall_catchpoint_p (struct breakpoint
*b
)
6595 return (b
->ops
== &catch_syscall_breakpoint_ops
);
6598 /* Create a new breakpoint of the bp_catchpoint kind and return it,
6599 but does NOT mention it nor update the global location list.
6600 This is useful if you need to fill more fields in the
6601 struct breakpoint before calling mention.
6603 If TEMPFLAG is non-zero, then make the breakpoint temporary.
6604 If COND_STRING is not NULL, then store it in the breakpoint.
6605 OPS, if not NULL, is the breakpoint_ops structure associated
6606 to the catchpoint. */
6608 static struct breakpoint
*
6609 create_catchpoint_without_mention (struct gdbarch
*gdbarch
, int tempflag
,
6611 struct breakpoint_ops
*ops
)
6613 struct symtab_and_line sal
;
6614 struct breakpoint
*b
;
6617 sal
.pspace
= current_program_space
;
6619 b
= set_raw_breakpoint (gdbarch
, sal
, bp_catchpoint
);
6620 set_breakpoint_count (breakpoint_count
+ 1);
6621 b
->number
= breakpoint_count
;
6623 b
->cond_string
= (cond_string
== NULL
) ? NULL
: xstrdup (cond_string
);
6625 b
->addr_string
= NULL
;
6626 b
->enable_state
= bp_enabled
;
6627 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6633 /* Create a new breakpoint of the bp_catchpoint kind and return it.
6635 If TEMPFLAG is non-zero, then make the breakpoint temporary.
6636 If COND_STRING is not NULL, then store it in the breakpoint.
6637 OPS, if not NULL, is the breakpoint_ops structure associated
6638 to the catchpoint. */
6640 static struct breakpoint
*
6641 create_catchpoint (struct gdbarch
*gdbarch
, int tempflag
,
6642 char *cond_string
, struct breakpoint_ops
*ops
)
6644 struct breakpoint
*b
=
6645 create_catchpoint_without_mention (gdbarch
, tempflag
, cond_string
, ops
);
6648 update_global_location_list (1);
6654 create_fork_vfork_event_catchpoint (struct gdbarch
*gdbarch
,
6655 int tempflag
, char *cond_string
,
6656 struct breakpoint_ops
*ops
)
6658 struct breakpoint
*b
6659 = create_catchpoint (gdbarch
, tempflag
, cond_string
, ops
);
6661 /* FIXME: We should put this information in a breakpoint private data
6663 b
->forked_inferior_pid
= null_ptid
;
6666 /* Exec catchpoints. */
6669 insert_catch_exec (struct bp_location
*bl
)
6671 return target_insert_exec_catchpoint (PIDGET (inferior_ptid
));
6675 remove_catch_exec (struct bp_location
*bl
)
6677 return target_remove_exec_catchpoint (PIDGET (inferior_ptid
));
6681 breakpoint_hit_catch_exec (struct breakpoint
*b
)
6683 return inferior_has_execd (inferior_ptid
, &b
->exec_pathname
);
6686 static enum print_stop_action
6687 print_it_catch_exec (struct breakpoint
*b
)
6689 annotate_catchpoint (b
->number
);
6690 printf_filtered (_("\nCatchpoint %d (exec'd %s), "), b
->number
,
6692 return PRINT_SRC_AND_LOC
;
6696 print_one_catch_exec (struct breakpoint
*b
, struct bp_location
**last_loc
)
6698 struct value_print_options opts
;
6700 get_user_print_options (&opts
);
6702 /* Field 4, the address, is omitted (which makes the columns
6703 not line up too nicely with the headers, but the effect
6704 is relatively readable). */
6705 if (opts
.addressprint
)
6706 ui_out_field_skip (uiout
, "addr");
6708 ui_out_text (uiout
, "exec");
6709 if (b
->exec_pathname
!= NULL
)
6711 ui_out_text (uiout
, ", program \"");
6712 ui_out_field_string (uiout
, "what", b
->exec_pathname
);
6713 ui_out_text (uiout
, "\" ");
6718 print_mention_catch_exec (struct breakpoint
*b
)
6720 printf_filtered (_("Catchpoint %d (exec)"), b
->number
);
6723 /* Implement the "print_recreate" breakpoint_ops method for exec
6727 print_recreate_catch_exec (struct breakpoint
*b
, struct ui_file
*fp
)
6729 fprintf_unfiltered (fp
, "catch exec");
6732 static struct breakpoint_ops catch_exec_breakpoint_ops
=
6736 breakpoint_hit_catch_exec
,
6737 NULL
, /* resources_needed */
6738 print_it_catch_exec
,
6739 print_one_catch_exec
,
6740 print_mention_catch_exec
,
6741 print_recreate_catch_exec
6745 create_syscall_event_catchpoint (int tempflag
, VEC(int) *filter
,
6746 struct breakpoint_ops
*ops
)
6748 struct gdbarch
*gdbarch
= get_current_arch ();
6749 struct breakpoint
*b
=
6750 create_catchpoint_without_mention (gdbarch
, tempflag
, NULL
, ops
);
6752 b
->syscalls_to_be_caught
= filter
;
6754 /* Now, we have to mention the breakpoint and update the global
6757 update_global_location_list (1);
6761 hw_breakpoint_used_count (void)
6763 struct breakpoint
*b
;
6768 if (b
->type
== bp_hardware_breakpoint
&& breakpoint_enabled (b
))
6776 hw_watchpoint_used_count (enum bptype type
, int *other_type_used
)
6779 struct breakpoint
*b
;
6780 struct bp_location
*bl
;
6782 *other_type_used
= 0;
6785 if (!breakpoint_enabled (b
))
6788 if (b
->type
== type
)
6789 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
6791 /* Special types of hardware watchpoints may use more than
6793 if (b
->ops
&& b
->ops
->resources_needed
)
6794 i
+= b
->ops
->resources_needed (bl
);
6798 else if (is_hardware_watchpoint (b
))
6799 *other_type_used
= 1;
6806 disable_watchpoints_before_interactive_call_start (void)
6808 struct breakpoint
*b
;
6812 if (is_watchpoint (b
) && breakpoint_enabled (b
))
6814 b
->enable_state
= bp_call_disabled
;
6815 update_global_location_list (0);
6821 enable_watchpoints_after_interactive_call_stop (void)
6823 struct breakpoint
*b
;
6827 if (is_watchpoint (b
) && b
->enable_state
== bp_call_disabled
)
6829 b
->enable_state
= bp_enabled
;
6830 update_global_location_list (1);
6836 disable_breakpoints_before_startup (void)
6838 struct breakpoint
*b
;
6843 if (b
->pspace
!= current_program_space
)
6846 if ((b
->type
== bp_breakpoint
6847 || b
->type
== bp_hardware_breakpoint
)
6848 && breakpoint_enabled (b
))
6850 b
->enable_state
= bp_startup_disabled
;
6856 update_global_location_list (0);
6858 current_program_space
->executing_startup
= 1;
6862 enable_breakpoints_after_startup (void)
6864 struct breakpoint
*b
;
6867 current_program_space
->executing_startup
= 0;
6871 if (b
->pspace
!= current_program_space
)
6874 if ((b
->type
== bp_breakpoint
6875 || b
->type
== bp_hardware_breakpoint
)
6876 && b
->enable_state
== bp_startup_disabled
)
6878 b
->enable_state
= bp_enabled
;
6884 breakpoint_re_set ();
6888 /* Set a breakpoint that will evaporate an end of command
6889 at address specified by SAL.
6890 Restrict it to frame FRAME if FRAME is nonzero. */
6893 set_momentary_breakpoint (struct gdbarch
*gdbarch
, struct symtab_and_line sal
,
6894 struct frame_id frame_id
, enum bptype type
)
6896 struct breakpoint
*b
;
6898 /* If FRAME_ID is valid, it should be a real frame, not an inlined
6900 gdb_assert (!frame_id_inlined_p (frame_id
));
6902 b
= set_raw_breakpoint (gdbarch
, sal
, type
);
6903 b
->enable_state
= bp_enabled
;
6904 b
->disposition
= disp_donttouch
;
6905 b
->frame_id
= frame_id
;
6907 /* If we're debugging a multi-threaded program, then we want
6908 momentary breakpoints to be active in only a single thread of
6910 if (in_thread_list (inferior_ptid
))
6911 b
->thread
= pid_to_thread_id (inferior_ptid
);
6913 update_global_location_list_nothrow (1);
6918 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
6922 clone_momentary_breakpoint (struct breakpoint
*orig
)
6924 struct breakpoint
*copy
;
6926 /* If there's nothing to clone, then return nothing. */
6930 copy
= set_raw_breakpoint_without_location (orig
->gdbarch
, orig
->type
);
6931 copy
->loc
= allocate_bp_location (copy
);
6932 set_breakpoint_location_function (copy
->loc
);
6934 copy
->loc
->gdbarch
= orig
->loc
->gdbarch
;
6935 copy
->loc
->requested_address
= orig
->loc
->requested_address
;
6936 copy
->loc
->address
= orig
->loc
->address
;
6937 copy
->loc
->section
= orig
->loc
->section
;
6938 copy
->loc
->pspace
= orig
->loc
->pspace
;
6940 if (orig
->source_file
== NULL
)
6941 copy
->source_file
= NULL
;
6943 copy
->source_file
= xstrdup (orig
->source_file
);
6945 copy
->line_number
= orig
->line_number
;
6946 copy
->frame_id
= orig
->frame_id
;
6947 copy
->thread
= orig
->thread
;
6948 copy
->pspace
= orig
->pspace
;
6950 copy
->enable_state
= bp_enabled
;
6951 copy
->disposition
= disp_donttouch
;
6952 copy
->number
= internal_breakpoint_number
--;
6954 update_global_location_list_nothrow (0);
6959 set_momentary_breakpoint_at_pc (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
6962 struct symtab_and_line sal
;
6964 sal
= find_pc_line (pc
, 0);
6966 sal
.section
= find_pc_overlay (pc
);
6967 sal
.explicit_pc
= 1;
6969 return set_momentary_breakpoint (gdbarch
, sal
, null_frame_id
, type
);
6973 /* Tell the user we have just set a breakpoint B. */
6976 mention (struct breakpoint
*b
)
6979 struct cleanup
*ui_out_chain
;
6980 struct value_print_options opts
;
6982 get_user_print_options (&opts
);
6984 /* FIXME: This is misplaced; mention() is called by things (like
6985 hitting a watchpoint) other than breakpoint creation. It should
6986 be possible to clean this up and at the same time replace the
6987 random calls to breakpoint_changed with this hook. */
6988 observer_notify_breakpoint_created (b
->number
);
6990 if (b
->ops
!= NULL
&& b
->ops
->print_mention
!= NULL
)
6991 b
->ops
->print_mention (b
);
6996 printf_filtered (_("(apparently deleted?) Eventpoint %d: "),
7000 ui_out_text (uiout
, "Watchpoint ");
7001 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
7002 ui_out_field_int (uiout
, "number", b
->number
);
7003 ui_out_text (uiout
, ": ");
7004 ui_out_field_string (uiout
, "exp", b
->exp_string
);
7005 do_cleanups (ui_out_chain
);
7007 case bp_hardware_watchpoint
:
7008 ui_out_text (uiout
, "Hardware watchpoint ");
7009 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
7010 ui_out_field_int (uiout
, "number", b
->number
);
7011 ui_out_text (uiout
, ": ");
7012 ui_out_field_string (uiout
, "exp", b
->exp_string
);
7013 do_cleanups (ui_out_chain
);
7015 case bp_read_watchpoint
:
7016 ui_out_text (uiout
, "Hardware read watchpoint ");
7017 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
7018 ui_out_field_int (uiout
, "number", b
->number
);
7019 ui_out_text (uiout
, ": ");
7020 ui_out_field_string (uiout
, "exp", b
->exp_string
);
7021 do_cleanups (ui_out_chain
);
7023 case bp_access_watchpoint
:
7024 ui_out_text (uiout
, "Hardware access (read/write) watchpoint ");
7025 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
7026 ui_out_field_int (uiout
, "number", b
->number
);
7027 ui_out_text (uiout
, ": ");
7028 ui_out_field_string (uiout
, "exp", b
->exp_string
);
7029 do_cleanups (ui_out_chain
);
7032 if (ui_out_is_mi_like_p (uiout
))
7037 if (b
->disposition
== disp_del
)
7038 printf_filtered (_("Temporary breakpoint"));
7040 printf_filtered (_("Breakpoint"));
7041 printf_filtered (_(" %d"), b
->number
);
7044 case bp_hardware_breakpoint
:
7045 if (ui_out_is_mi_like_p (uiout
))
7050 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
7054 if (ui_out_is_mi_like_p (uiout
))
7059 printf_filtered (_("Tracepoint"));
7060 printf_filtered (_(" %d"), b
->number
);
7063 case bp_fast_tracepoint
:
7064 if (ui_out_is_mi_like_p (uiout
))
7069 printf_filtered (_("Fast tracepoint"));
7070 printf_filtered (_(" %d"), b
->number
);
7073 case bp_static_tracepoint
:
7074 if (ui_out_is_mi_like_p (uiout
))
7079 printf_filtered (_("Static tracepoint"));
7080 printf_filtered (_(" %d"), b
->number
);
7087 case bp_longjmp_resume
:
7089 case bp_exception_resume
:
7090 case bp_step_resume
:
7092 case bp_std_terminate
:
7093 case bp_watchpoint_scope
:
7094 case bp_shlib_event
:
7095 case bp_thread_event
:
7096 case bp_overlay_event
:
7098 case bp_longjmp_master
:
7099 case bp_std_terminate_master
:
7100 case bp_exception_master
:
7106 /* i18n: cagney/2005-02-11: Below needs to be merged into a
7110 printf_filtered (_(" (%s) pending."), b
->addr_string
);
7114 if (opts
.addressprint
|| b
->source_file
== NULL
)
7116 printf_filtered (" at ");
7117 fputs_filtered (paddress (b
->loc
->gdbarch
, b
->loc
->address
),
7121 printf_filtered (": file %s, line %d.",
7122 b
->source_file
, b
->line_number
);
7126 struct bp_location
*loc
= b
->loc
;
7128 for (; loc
; loc
= loc
->next
)
7130 printf_filtered (" (%d locations)", n
);
7135 if (ui_out_is_mi_like_p (uiout
))
7137 printf_filtered ("\n");
7141 static struct bp_location
*
7142 add_location_to_breakpoint (struct breakpoint
*b
,
7143 const struct symtab_and_line
*sal
)
7145 struct bp_location
*loc
, **tmp
;
7147 loc
= allocate_bp_location (b
);
7148 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
7151 loc
->gdbarch
= get_sal_arch (*sal
);
7153 loc
->gdbarch
= b
->gdbarch
;
7154 loc
->requested_address
= sal
->pc
;
7155 loc
->address
= adjust_breakpoint_address (loc
->gdbarch
,
7156 loc
->requested_address
, b
->type
);
7157 loc
->pspace
= sal
->pspace
;
7158 gdb_assert (loc
->pspace
!= NULL
);
7159 loc
->section
= sal
->section
;
7161 set_breakpoint_location_function (loc
);
7166 /* Return 1 if LOC is pointing to a permanent breakpoint,
7167 return 0 otherwise. */
7170 bp_loc_is_permanent (struct bp_location
*loc
)
7174 const gdb_byte
*brk
;
7175 gdb_byte
*target_mem
;
7176 struct cleanup
*cleanup
;
7179 gdb_assert (loc
!= NULL
);
7181 addr
= loc
->address
;
7182 brk
= gdbarch_breakpoint_from_pc (loc
->gdbarch
, &addr
, &len
);
7184 /* Software breakpoints unsupported? */
7188 target_mem
= alloca (len
);
7190 /* Enable the automatic memory restoration from breakpoints while
7191 we read the memory. Otherwise we could say about our temporary
7192 breakpoints they are permanent. */
7193 cleanup
= save_current_space_and_thread ();
7195 switch_to_program_space_and_thread (loc
->pspace
);
7196 make_show_memory_breakpoints_cleanup (0);
7198 if (target_read_memory (loc
->address
, target_mem
, len
) == 0
7199 && memcmp (target_mem
, brk
, len
) == 0)
7202 do_cleanups (cleanup
);
7209 /* Create a breakpoint with SAL as location. Use ADDR_STRING
7210 as textual description of the location, and COND_STRING
7211 as condition expression. */
7214 create_breakpoint_sal (struct gdbarch
*gdbarch
,
7215 struct symtabs_and_lines sals
, char *addr_string
,
7217 enum bptype type
, enum bpdisp disposition
,
7218 int thread
, int task
, int ignore_count
,
7219 struct breakpoint_ops
*ops
, int from_tty
,
7220 int enabled
, int internal
, int display_canonical
)
7222 struct breakpoint
*b
= NULL
;
7225 if (type
== bp_hardware_breakpoint
)
7227 int i
= hw_breakpoint_used_count ();
7228 int target_resources_ok
=
7229 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
7231 if (target_resources_ok
== 0)
7232 error (_("No hardware breakpoint support in the target."));
7233 else if (target_resources_ok
< 0)
7234 error (_("Hardware breakpoints used exceeds limit."));
7237 gdb_assert (sals
.nelts
> 0);
7239 for (i
= 0; i
< sals
.nelts
; ++i
)
7241 struct symtab_and_line sal
= sals
.sals
[i
];
7242 struct bp_location
*loc
;
7246 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
7248 loc_gdbarch
= gdbarch
;
7250 describe_other_breakpoints (loc_gdbarch
,
7251 sal
.pspace
, sal
.pc
, sal
.section
, thread
);
7256 b
= set_raw_breakpoint (gdbarch
, sal
, type
);
7257 set_breakpoint_number (internal
, b
);
7261 b
->cond_string
= cond_string
;
7262 b
->ignore_count
= ignore_count
;
7263 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
7264 b
->disposition
= disposition
;
7265 b
->pspace
= sals
.sals
[0].pspace
;
7267 if (type
== bp_static_tracepoint
)
7269 struct static_tracepoint_marker marker
;
7271 if (is_marker_spec (addr_string
))
7273 /* We already know the marker exists, otherwise, we
7274 wouldn't see a sal for it. */
7275 char *p
= &addr_string
[3];
7280 p
= skip_spaces (p
);
7282 endp
= skip_to_space (p
);
7284 marker_str
= savestring (p
, endp
- p
);
7285 b
->static_trace_marker_id
= marker_str
;
7287 printf_filtered (_("Probed static tracepoint "
7289 b
->static_trace_marker_id
);
7291 else if (target_static_tracepoint_marker_at (sal
.pc
, &marker
))
7293 b
->static_trace_marker_id
= xstrdup (marker
.str_id
);
7294 release_static_tracepoint_marker (&marker
);
7296 printf_filtered (_("Probed static tracepoint "
7298 b
->static_trace_marker_id
);
7301 warning (_("Couldn't determine the static "
7302 "tracepoint marker to probe"));
7305 if (enabled
&& b
->pspace
->executing_startup
7306 && (b
->type
== bp_breakpoint
7307 || b
->type
== bp_hardware_breakpoint
))
7308 b
->enable_state
= bp_startup_disabled
;
7314 loc
= add_location_to_breakpoint (b
, &sal
);
7317 if (bp_loc_is_permanent (loc
))
7318 make_breakpoint_permanent (b
);
7322 char *arg
= b
->cond_string
;
7323 loc
->cond
= parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
7325 error (_("Garbage %s follows condition"), arg
);
7329 b
->display_canonical
= display_canonical
;
7331 b
->addr_string
= addr_string
;
7333 /* addr_string has to be used or breakpoint_re_set will delete
7336 = xstrprintf ("*%s", paddress (b
->loc
->gdbarch
, b
->loc
->address
));
7340 /* Do not mention breakpoints with a negative number, but do
7341 notify observers. */
7342 observer_notify_breakpoint_created (b
->number
);
7347 /* Remove element at INDEX_TO_REMOVE from SAL, shifting other
7348 elements to fill the void space. */
7350 remove_sal (struct symtabs_and_lines
*sal
, int index_to_remove
)
7352 int i
= index_to_remove
+1;
7353 int last_index
= sal
->nelts
-1;
7355 for (;i
<= last_index
; ++i
)
7356 sal
->sals
[i
-1] = sal
->sals
[i
];
7361 /* If appropriate, obtains all sals that correspond to the same file
7362 and line as SAL, in all program spaces. Users debugging with IDEs,
7363 will want to set a breakpoint at foo.c:line, and not really care
7364 about program spaces. This is done only if SAL does not have
7365 explicit PC and has line and file information. If we got just a
7366 single expanded sal, return the original.
7368 Otherwise, if SAL.explicit_line is not set, filter out all sals for
7369 which the name of enclosing function is different from SAL. This
7370 makes sure that if we have breakpoint originally set in template
7371 instantiation, say foo<int>(), we won't expand SAL to locations at
7372 the same line in all existing instantiations of 'foo'. */
7374 static struct symtabs_and_lines
7375 expand_line_sal_maybe (struct symtab_and_line sal
)
7377 struct symtabs_and_lines expanded
;
7378 CORE_ADDR original_pc
= sal
.pc
;
7379 char *original_function
= NULL
;
7382 struct cleanup
*old_chain
;
7384 /* If we have explicit pc, don't expand.
7385 If we have no line number, we can't expand. */
7386 if (sal
.explicit_pc
|| sal
.line
== 0 || sal
.symtab
== NULL
)
7389 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
7390 expanded
.sals
[0] = sal
;
7396 old_chain
= save_current_space_and_thread ();
7398 switch_to_program_space_and_thread (sal
.pspace
);
7400 find_pc_partial_function (original_pc
, &original_function
, NULL
, NULL
);
7402 /* Note that expand_line_sal visits *all* program spaces. */
7403 expanded
= expand_line_sal (sal
);
7405 if (expanded
.nelts
== 1)
7407 /* We had one sal, we got one sal. Return that sal, adjusting it
7408 past the function prologue if necessary. */
7409 xfree (expanded
.sals
);
7411 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
7412 sal
.pc
= original_pc
;
7413 expanded
.sals
[0] = sal
;
7414 skip_prologue_sal (&expanded
.sals
[0]);
7415 do_cleanups (old_chain
);
7419 if (!sal
.explicit_line
)
7421 CORE_ADDR func_addr
, func_end
;
7422 for (i
= 0; i
< expanded
.nelts
; ++i
)
7424 CORE_ADDR pc
= expanded
.sals
[i
].pc
;
7425 char *this_function
;
7427 /* We need to switch threads as well since we're about to
7429 switch_to_program_space_and_thread (expanded
.sals
[i
].pspace
);
7431 if (find_pc_partial_function (pc
, &this_function
,
7432 &func_addr
, &func_end
))
7435 && strcmp (this_function
, original_function
) != 0)
7437 remove_sal (&expanded
, i
);
7444 /* Skip the function prologue if necessary. */
7445 for (i
= 0; i
< expanded
.nelts
; ++i
)
7446 skip_prologue_sal (&expanded
.sals
[i
]);
7448 do_cleanups (old_chain
);
7450 if (expanded
.nelts
<= 1)
7452 /* This is un ugly workaround. If we get zero expanded sals
7453 then something is really wrong. Fix that by returning the
7456 xfree (expanded
.sals
);
7458 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
7459 sal
.pc
= original_pc
;
7460 expanded
.sals
[0] = sal
;
7467 for (i
= 0; i
< expanded
.nelts
; ++i
)
7468 if (expanded
.sals
[i
].pc
== original_pc
)
7479 /* Add SALS.nelts breakpoints to the breakpoint table. For each
7480 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
7481 value. COND_STRING, if not NULL, specified the condition to be
7482 used for all breakpoints. Essentially the only case where
7483 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
7484 function. In that case, it's still not possible to specify
7485 separate conditions for different overloaded functions, so
7486 we take just a single condition string.
7488 NOTE: If the function succeeds, the caller is expected to cleanup
7489 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
7490 array contents). If the function fails (error() is called), the
7491 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
7492 COND and SALS arrays and each of those arrays contents. */
7495 create_breakpoints_sal (struct gdbarch
*gdbarch
,
7496 struct symtabs_and_lines sals
,
7497 struct linespec_result
*canonical
,
7499 enum bptype type
, enum bpdisp disposition
,
7500 int thread
, int task
, int ignore_count
,
7501 struct breakpoint_ops
*ops
, int from_tty
,
7502 int enabled
, int internal
)
7506 for (i
= 0; i
< sals
.nelts
; ++i
)
7508 struct symtabs_and_lines expanded
=
7509 expand_line_sal_maybe (sals
.sals
[i
]);
7511 create_breakpoint_sal (gdbarch
, expanded
, canonical
->canonical
[i
],
7512 cond_string
, type
, disposition
,
7513 thread
, task
, ignore_count
, ops
,
7514 from_tty
, enabled
, internal
,
7515 canonical
->special_display
);
7519 /* Parse ADDRESS which is assumed to be a SAL specification possibly
7520 followed by conditionals. On return, SALS contains an array of SAL
7521 addresses found. ADDR_STRING contains a vector of (canonical)
7522 address strings. ADDRESS points to the end of the SAL.
7524 The array and the line spec strings are allocated on the heap, it is
7525 the caller's responsibility to free them. */
7528 parse_breakpoint_sals (char **address
,
7529 struct symtabs_and_lines
*sals
,
7530 struct linespec_result
*canonical
,
7533 char *addr_start
= *address
;
7535 /* If no arg given, or if first arg is 'if ', use the default
7537 if ((*address
) == NULL
7538 || (strncmp ((*address
), "if", 2) == 0 && isspace ((*address
)[2])))
7540 if (default_breakpoint_valid
)
7542 struct symtab_and_line sal
;
7544 init_sal (&sal
); /* Initialize to zeroes. */
7545 sals
->sals
= (struct symtab_and_line
*)
7546 xmalloc (sizeof (struct symtab_and_line
));
7547 sal
.pc
= default_breakpoint_address
;
7548 sal
.line
= default_breakpoint_line
;
7549 sal
.symtab
= default_breakpoint_symtab
;
7550 sal
.pspace
= default_breakpoint_pspace
;
7551 sal
.section
= find_pc_overlay (sal
.pc
);
7553 /* "break" without arguments is equivalent to "break *PC"
7554 where PC is the default_breakpoint_address. So make sure
7555 to set sal.explicit_pc to prevent GDB from trying to
7556 expand the list of sals to include all other instances
7557 with the same symtab and line. */
7558 sal
.explicit_pc
= 1;
7560 sals
->sals
[0] = sal
;
7564 error (_("No default breakpoint address now."));
7568 /* Force almost all breakpoints to be in terms of the
7569 current_source_symtab (which is decode_line_1's default).
7570 This should produce the results we want almost all of the
7571 time while leaving default_breakpoint_* alone.
7573 ObjC: However, don't match an Objective-C method name which
7574 may have a '+' or '-' succeeded by a '[' */
7576 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
7578 if (default_breakpoint_valid
7580 || ((strchr ("+-", (*address
)[0]) != NULL
)
7581 && ((*address
)[1] != '['))))
7582 *sals
= decode_line_1 (address
, 1, default_breakpoint_symtab
,
7583 default_breakpoint_line
, canonical
,
7586 *sals
= decode_line_1 (address
, 1, (struct symtab
*) NULL
, 0,
7587 canonical
, not_found_ptr
);
7589 /* For any SAL that didn't have a canonical string, fill one in. */
7590 if (sals
->nelts
> 0 && canonical
->canonical
== NULL
)
7591 canonical
->canonical
= xcalloc (sals
->nelts
, sizeof (char **));
7592 if (addr_start
!= (*address
))
7596 for (i
= 0; i
< sals
->nelts
; i
++)
7598 /* Add the string if not present. */
7599 if (canonical
->canonical
[i
] == NULL
)
7600 canonical
->canonical
[i
] = savestring (addr_start
,
7601 (*address
) - addr_start
);
7607 /* Convert each SAL into a real PC. Verify that the PC can be
7608 inserted as a breakpoint. If it can't throw an error. */
7611 breakpoint_sals_to_pc (struct symtabs_and_lines
*sals
)
7615 for (i
= 0; i
< sals
->nelts
; i
++)
7616 resolve_sal_pc (&sals
->sals
[i
]);
7619 /* Fast tracepoints may have restrictions on valid locations. For
7620 instance, a fast tracepoint using a jump instead of a trap will
7621 likely have to overwrite more bytes than a trap would, and so can
7622 only be placed where the instruction is longer than the jump, or a
7623 multi-instruction sequence does not have a jump into the middle of
7627 check_fast_tracepoint_sals (struct gdbarch
*gdbarch
,
7628 struct symtabs_and_lines
*sals
)
7631 struct symtab_and_line
*sal
;
7633 struct cleanup
*old_chain
;
7635 for (i
= 0; i
< sals
->nelts
; i
++)
7637 sal
= &sals
->sals
[i
];
7639 rslt
= gdbarch_fast_tracepoint_valid_at (gdbarch
, sal
->pc
,
7641 old_chain
= make_cleanup (xfree
, msg
);
7644 error (_("May not have a fast tracepoint at 0x%s%s"),
7645 paddress (gdbarch
, sal
->pc
), (msg
? msg
: ""));
7647 do_cleanups (old_chain
);
7652 do_captured_parse_breakpoint (struct ui_out
*ui
, void *data
)
7654 struct captured_parse_breakpoint_args
*args
= data
;
7656 parse_breakpoint_sals (args
->arg_p
, args
->sals_p
, args
->canonical_p
,
7657 args
->not_found_ptr
);
7660 /* Given TOK, a string specification of condition and thread, as
7661 accepted by the 'break' command, extract the condition
7662 string and thread number and set *COND_STRING and *THREAD.
7663 PC identifies the context at which the condition should be parsed.
7664 If no condition is found, *COND_STRING is set to NULL.
7665 If no thread is found, *THREAD is set to -1. */
7667 find_condition_and_thread (char *tok
, CORE_ADDR pc
,
7668 char **cond_string
, int *thread
, int *task
)
7670 *cond_string
= NULL
;
7676 char *cond_start
= NULL
;
7677 char *cond_end
= NULL
;
7679 tok
= skip_spaces (tok
);
7681 end_tok
= skip_to_space (tok
);
7683 toklen
= end_tok
- tok
;
7685 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
7687 struct expression
*expr
;
7689 tok
= cond_start
= end_tok
+ 1;
7690 expr
= parse_exp_1 (&tok
, block_for_pc (pc
), 0);
7693 *cond_string
= savestring (cond_start
,
7694 cond_end
- cond_start
);
7696 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
7702 *thread
= strtol (tok
, &tok
, 0);
7704 error (_("Junk after thread keyword."));
7705 if (!valid_thread_id (*thread
))
7706 error (_("Unknown thread %d."), *thread
);
7708 else if (toklen
>= 1 && strncmp (tok
, "task", toklen
) == 0)
7714 *task
= strtol (tok
, &tok
, 0);
7716 error (_("Junk after task keyword."));
7717 if (!valid_task_id (*task
))
7718 error (_("Unknown task %d."), *task
);
7721 error (_("Junk at end of arguments."));
7725 /* Decode a static tracepoint marker spec. */
7727 static struct symtabs_and_lines
7728 decode_static_tracepoint_spec (char **arg_p
)
7730 VEC(static_tracepoint_marker_p
) *markers
= NULL
;
7731 struct symtabs_and_lines sals
;
7732 struct symtab_and_line sal
;
7734 struct cleanup
*old_chain
;
7735 char *p
= &(*arg_p
)[3];
7740 p
= skip_spaces (p
);
7742 endp
= skip_to_space (p
);
7744 marker_str
= savestring (p
, endp
- p
);
7745 old_chain
= make_cleanup (xfree
, marker_str
);
7747 markers
= target_static_tracepoint_markers_by_strid (marker_str
);
7748 if (VEC_empty(static_tracepoint_marker_p
, markers
))
7749 error (_("No known static tracepoint marker named %s"), marker_str
);
7751 sals
.nelts
= VEC_length(static_tracepoint_marker_p
, markers
);
7752 sals
.sals
= xmalloc (sizeof *sals
.sals
* sals
.nelts
);
7754 for (i
= 0; i
< sals
.nelts
; i
++)
7756 struct static_tracepoint_marker
*marker
;
7758 marker
= VEC_index (static_tracepoint_marker_p
, markers
, i
);
7760 init_sal (&sals
.sals
[i
]);
7762 sals
.sals
[i
] = find_pc_line (marker
->address
, 0);
7763 sals
.sals
[i
].pc
= marker
->address
;
7765 release_static_tracepoint_marker (marker
);
7768 do_cleanups (old_chain
);
7774 /* Set a breakpoint. This function is shared between CLI and MI
7775 functions for setting a breakpoint. This function has two major
7776 modes of operations, selected by the PARSE_CONDITION_AND_THREAD
7777 parameter. If non-zero, the function will parse arg, extracting
7778 breakpoint location, address and thread. Otherwise, ARG is just
7779 the location of breakpoint, with condition and thread specified by
7780 the COND_STRING and THREAD parameters. If INTERNAL is non-zero,
7781 the breakpoint number will be allocated from the internal
7782 breakpoint count. Returns true if any breakpoint was created;
7786 create_breakpoint (struct gdbarch
*gdbarch
,
7787 char *arg
, char *cond_string
, int thread
,
7788 int parse_condition_and_thread
,
7789 int tempflag
, enum bptype type_wanted
,
7791 enum auto_boolean pending_break_support
,
7792 struct breakpoint_ops
*ops
,
7793 int from_tty
, int enabled
, int internal
)
7795 struct gdb_exception e
;
7796 struct symtabs_and_lines sals
;
7797 struct symtab_and_line pending_sal
;
7799 char *addr_start
= arg
;
7800 struct linespec_result canonical
;
7801 struct cleanup
*old_chain
;
7802 struct cleanup
*bkpt_chain
= NULL
;
7803 struct captured_parse_breakpoint_args parse_args
;
7808 int prev_bkpt_count
= breakpoint_count
;
7812 init_linespec_result (&canonical
);
7814 parse_args
.arg_p
= &arg
;
7815 parse_args
.sals_p
= &sals
;
7816 parse_args
.canonical_p
= &canonical
;
7817 parse_args
.not_found_ptr
= ¬_found
;
7819 if (type_wanted
== bp_static_tracepoint
&& is_marker_spec (arg
))
7823 sals
= decode_static_tracepoint_spec (&arg
);
7825 copy_arg
= savestring (addr_start
, arg
- addr_start
);
7826 canonical
.canonical
= xcalloc (sals
.nelts
, sizeof (char **));
7827 for (i
= 0; i
< sals
.nelts
; i
++)
7828 canonical
.canonical
[i
] = xstrdup (copy_arg
);
7832 e
= catch_exception (uiout
, do_captured_parse_breakpoint
,
7833 &parse_args
, RETURN_MASK_ALL
);
7835 /* If caller is interested in rc value from parse, set value. */
7839 throw_exception (e
);
7843 case NOT_FOUND_ERROR
:
7845 /* If pending breakpoint support is turned off, throw
7848 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
7849 throw_exception (e
);
7851 exception_print (gdb_stderr
, e
);
7853 /* If pending breakpoint support is auto query and the user
7854 selects no, then simply return the error code. */
7855 if (pending_break_support
== AUTO_BOOLEAN_AUTO
7856 && !nquery (_("Make breakpoint pending on "
7857 "future shared library load? ")))
7860 /* At this point, either the user was queried about setting
7861 a pending breakpoint and selected yes, or pending
7862 breakpoint behavior is on and thus a pending breakpoint
7863 is defaulted on behalf of the user. */
7864 copy_arg
= xstrdup (addr_start
);
7865 canonical
.canonical
= ©_arg
;
7867 sals
.sals
= &pending_sal
;
7872 throw_exception (e
);
7882 /* Create a chain of things that always need to be cleaned up. */
7883 old_chain
= make_cleanup (null_cleanup
, 0);
7887 /* Make sure that all storage allocated to SALS gets freed. */
7888 make_cleanup (xfree
, sals
.sals
);
7890 /* Cleanup the canonical array but not its contents. */
7891 make_cleanup (xfree
, canonical
.canonical
);
7894 /* ----------------------------- SNIP -----------------------------
7895 Anything added to the cleanup chain beyond this point is assumed
7896 to be part of a breakpoint. If the breakpoint create succeeds
7897 then the memory is not reclaimed. */
7898 bkpt_chain
= make_cleanup (null_cleanup
, 0);
7900 /* Mark the contents of the canonical for cleanup. These go on
7901 the bkpt_chain and only occur if the breakpoint create fails. */
7902 for (i
= 0; i
< sals
.nelts
; i
++)
7904 if (canonical
.canonical
[i
] != NULL
)
7905 make_cleanup (xfree
, canonical
.canonical
[i
]);
7908 /* Resolve all line numbers to PC's and verify that the addresses
7909 are ok for the target. */
7911 breakpoint_sals_to_pc (&sals
);
7913 /* Fast tracepoints may have additional restrictions on location. */
7914 if (type_wanted
== bp_fast_tracepoint
)
7915 check_fast_tracepoint_sals (gdbarch
, &sals
);
7917 /* Verify that condition can be parsed, before setting any
7918 breakpoints. Allocate a separate condition expression for each
7922 if (parse_condition_and_thread
)
7924 /* Here we only parse 'arg' to separate condition
7925 from thread number, so parsing in context of first
7926 sal is OK. When setting the breakpoint we'll
7927 re-parse it in context of each sal. */
7930 find_condition_and_thread (arg
, sals
.sals
[0].pc
, &cond_string
,
7933 make_cleanup (xfree
, cond_string
);
7937 /* Create a private copy of condition string. */
7940 cond_string
= xstrdup (cond_string
);
7941 make_cleanup (xfree
, cond_string
);
7945 /* If the user is creating a static tracepoint by marker id
7946 (strace -m MARKER_ID), then store the sals index, so that
7947 breakpoint_re_set can try to match up which of the newly
7948 found markers corresponds to this one, and, don't try to
7949 expand multiple locations for each sal, given than SALS
7950 already should contain all sals for MARKER_ID. */
7951 if (type_wanted
== bp_static_tracepoint
7952 && is_marker_spec (canonical
.canonical
[0]))
7956 for (i
= 0; i
< sals
.nelts
; ++i
)
7958 struct symtabs_and_lines expanded
;
7959 struct breakpoint
*tp
;
7960 struct cleanup
*old_chain
;
7963 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
7964 expanded
.sals
[0] = sals
.sals
[i
];
7965 old_chain
= make_cleanup (xfree
, expanded
.sals
);
7967 create_breakpoint_sal (gdbarch
, expanded
, canonical
.canonical
[i
],
7968 cond_string
, type_wanted
,
7969 tempflag
? disp_del
: disp_donttouch
,
7970 thread
, task
, ignore_count
, ops
,
7971 from_tty
, enabled
, internal
,
7972 canonical
.special_display
);
7974 do_cleanups (old_chain
);
7976 /* Get the tracepoint we just created. */
7978 tp
= get_breakpoint (internal_breakpoint_number
);
7980 tp
= get_breakpoint (breakpoint_count
);
7981 gdb_assert (tp
!= NULL
);
7983 /* Given that its possible to have multiple markers with
7984 the same string id, if the user is creating a static
7985 tracepoint by marker id ("strace -m MARKER_ID"), then
7986 store the sals index, so that breakpoint_re_set can
7987 try to match up which of the newly found markers
7988 corresponds to this one */
7989 tp
->static_trace_marker_id_idx
= i
;
7993 create_breakpoints_sal (gdbarch
, sals
, &canonical
, cond_string
,
7995 tempflag
? disp_del
: disp_donttouch
,
7996 thread
, task
, ignore_count
, ops
, from_tty
,
8001 struct breakpoint
*b
;
8003 make_cleanup (xfree
, copy_arg
);
8005 b
= set_raw_breakpoint_without_location (gdbarch
, type_wanted
);
8006 set_breakpoint_number (internal
, b
);
8008 b
->addr_string
= canonical
.canonical
[0];
8009 b
->cond_string
= NULL
;
8010 b
->ignore_count
= ignore_count
;
8011 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
8012 b
->condition_not_parsed
= 1;
8014 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
8015 b
->pspace
= current_program_space
;
8016 b
->py_bp_object
= NULL
;
8018 if (enabled
&& b
->pspace
->executing_startup
8019 && (b
->type
== bp_breakpoint
8020 || b
->type
== bp_hardware_breakpoint
))
8021 b
->enable_state
= bp_startup_disabled
;
8024 /* Do not mention breakpoints with a negative number,
8025 but do notify observers. */
8026 observer_notify_breakpoint_created (b
->number
);
8033 warning (_("Multiple breakpoints were set.\nUse the "
8034 "\"delete\" command to delete unwanted breakpoints."));
8035 prev_breakpoint_count
= prev_bkpt_count
;
8038 /* That's it. Discard the cleanups for data inserted into the
8040 discard_cleanups (bkpt_chain
);
8041 /* But cleanup everything else. */
8042 do_cleanups (old_chain
);
8044 /* error call may happen here - have BKPT_CHAIN already discarded. */
8045 update_global_location_list (1);
8050 /* Set a breakpoint.
8051 ARG is a string describing breakpoint address,
8052 condition, and thread.
8053 FLAG specifies if a breakpoint is hardware on,
8054 and if breakpoint is temporary, using BP_HARDWARE_FLAG
8058 break_command_1 (char *arg
, int flag
, int from_tty
)
8060 int tempflag
= flag
& BP_TEMPFLAG
;
8061 enum bptype type_wanted
= (flag
& BP_HARDWAREFLAG
8062 ? bp_hardware_breakpoint
8065 create_breakpoint (get_current_arch (),
8067 NULL
, 0, 1 /* parse arg */,
8068 tempflag
, type_wanted
,
8069 0 /* Ignore count */,
8070 pending_break_support
,
8071 NULL
/* breakpoint_ops */,
8078 /* Helper function for break_command_1 and disassemble_command. */
8081 resolve_sal_pc (struct symtab_and_line
*sal
)
8085 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
8087 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
8088 error (_("No line %d in file \"%s\"."),
8089 sal
->line
, sal
->symtab
->filename
);
8092 /* If this SAL corresponds to a breakpoint inserted using a line
8093 number, then skip the function prologue if necessary. */
8094 if (sal
->explicit_line
)
8095 skip_prologue_sal (sal
);
8098 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
8100 struct blockvector
*bv
;
8104 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
, sal
->symtab
);
8107 sym
= block_linkage_function (b
);
8110 fixup_symbol_section (sym
, sal
->symtab
->objfile
);
8111 sal
->section
= SYMBOL_OBJ_SECTION (sym
);
8115 /* It really is worthwhile to have the section, so we'll
8116 just have to look harder. This case can be executed
8117 if we have line numbers but no functions (as can
8118 happen in assembly source). */
8120 struct minimal_symbol
*msym
;
8121 struct cleanup
*old_chain
= save_current_space_and_thread ();
8123 switch_to_program_space_and_thread (sal
->pspace
);
8125 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
8127 sal
->section
= SYMBOL_OBJ_SECTION (msym
);
8129 do_cleanups (old_chain
);
8136 break_command (char *arg
, int from_tty
)
8138 break_command_1 (arg
, 0, from_tty
);
8142 tbreak_command (char *arg
, int from_tty
)
8144 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
8148 hbreak_command (char *arg
, int from_tty
)
8150 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
8154 thbreak_command (char *arg
, int from_tty
)
8156 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
8160 stop_command (char *arg
, int from_tty
)
8162 printf_filtered (_("Specify the type of breakpoint to set.\n\
8163 Usage: stop in <function | address>\n\
8164 stop at <line>\n"));
8168 stopin_command (char *arg
, int from_tty
)
8172 if (arg
== (char *) NULL
)
8174 else if (*arg
!= '*')
8179 /* Look for a ':'. If this is a line number specification, then
8180 say it is bad, otherwise, it should be an address or
8181 function/method name. */
8182 while (*argptr
&& !hasColon
)
8184 hasColon
= (*argptr
== ':');
8189 badInput
= (*argptr
!= ':'); /* Not a class::method */
8191 badInput
= isdigit (*arg
); /* a simple line number */
8195 printf_filtered (_("Usage: stop in <function | address>\n"));
8197 break_command_1 (arg
, 0, from_tty
);
8201 stopat_command (char *arg
, int from_tty
)
8205 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
8212 /* Look for a ':'. If there is a '::' then get out, otherwise
8213 it is probably a line number. */
8214 while (*argptr
&& !hasColon
)
8216 hasColon
= (*argptr
== ':');
8221 badInput
= (*argptr
== ':'); /* we have class::method */
8223 badInput
= !isdigit (*arg
); /* not a line number */
8227 printf_filtered (_("Usage: stop at <line>\n"));
8229 break_command_1 (arg
, 0, from_tty
);
8232 /* Return non-zero if EXP is verified as constant. Returned zero
8233 means EXP is variable. Also the constant detection may fail for
8234 some constant expressions and in such case still falsely return
8237 watchpoint_exp_is_const (const struct expression
*exp
)
8245 /* We are only interested in the descriptor of each element. */
8246 operator_length (exp
, i
, &oplenp
, &argsp
);
8249 switch (exp
->elts
[i
].opcode
)
8259 case BINOP_LOGICAL_AND
:
8260 case BINOP_LOGICAL_OR
:
8261 case BINOP_BITWISE_AND
:
8262 case BINOP_BITWISE_IOR
:
8263 case BINOP_BITWISE_XOR
:
8265 case BINOP_NOTEQUAL
:
8281 case TERNOP_SLICE_COUNT
:
8293 case OP_OBJC_NSSTRING
:
8296 case UNOP_LOGICAL_NOT
:
8297 case UNOP_COMPLEMENT
:
8300 /* Unary, binary and ternary operators: We have to check
8301 their operands. If they are constant, then so is the
8302 result of that operation. For instance, if A and B are
8303 determined to be constants, then so is "A + B".
8305 UNOP_IND is one exception to the rule above, because the
8306 value of *ADDR is not necessarily a constant, even when
8311 /* Check whether the associated symbol is a constant.
8313 We use SYMBOL_CLASS rather than TYPE_CONST because it's
8314 possible that a buggy compiler could mark a variable as
8315 constant even when it is not, and TYPE_CONST would return
8316 true in this case, while SYMBOL_CLASS wouldn't.
8318 We also have to check for function symbols because they
8319 are always constant. */
8321 struct symbol
*s
= exp
->elts
[i
+ 2].symbol
;
8323 if (SYMBOL_CLASS (s
) != LOC_BLOCK
8324 && SYMBOL_CLASS (s
) != LOC_CONST
8325 && SYMBOL_CLASS (s
) != LOC_CONST_BYTES
)
8330 /* The default action is to return 0 because we are using
8331 the optimistic approach here: If we don't know something,
8332 then it is not a constant. */
8341 /* Implement the "insert" breakpoint_ops method for hardware watchpoints. */
8344 insert_watchpoint (struct bp_location
*bl
)
8346 int length
= bl
->owner
->exact
? 1 : bl
->length
;
8348 return target_insert_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
8349 bl
->owner
->cond_exp
);
8352 /* Implement the "remove" breakpoint_ops method for hardware watchpoints. */
8355 remove_watchpoint (struct bp_location
*bl
)
8357 int length
= bl
->owner
->exact
? 1 : bl
->length
;
8359 return target_remove_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
8360 bl
->owner
->cond_exp
);
8363 /* Implement the "resources_needed" breakpoint_ops method for
8364 hardware watchpoints. */
8367 resources_needed_watchpoint (const struct bp_location
*bl
)
8369 int length
= bl
->owner
->exact
? 1 : bl
->length
;
8371 return target_region_ok_for_hw_watchpoint (bl
->address
, length
);
8374 /* The breakpoint_ops structure to be used in hardware watchpoints. */
8376 static struct breakpoint_ops watchpoint_breakpoint_ops
=
8380 NULL
, /* breakpoint_hit */
8381 resources_needed_watchpoint
,
8382 NULL
, /* print_it */
8383 NULL
, /* print_one */
8384 NULL
, /* print_mention */
8385 NULL
/* print_recreate */
8388 /* accessflag: hw_write: watch write,
8389 hw_read: watch read,
8390 hw_access: watch access (read or write) */
8392 watch_command_1 (char *arg
, int accessflag
, int from_tty
,
8393 int just_location
, int internal
)
8395 struct breakpoint
*b
, *scope_breakpoint
= NULL
;
8396 struct expression
*exp
;
8397 struct block
*exp_valid_block
= NULL
, *cond_exp_valid_block
= NULL
;
8398 struct value
*val
, *mark
, *result
;
8399 struct frame_info
*frame
;
8400 char *exp_start
= NULL
;
8401 char *exp_end
= NULL
;
8402 char *tok
, *id_tok_start
, *end_tok
;
8404 char *cond_start
= NULL
;
8405 char *cond_end
= NULL
;
8406 int i
, other_type_used
, target_resources_ok
= 0;
8407 enum bptype bp_type
;
8412 /* Make sure that we actually have parameters to parse. */
8413 if (arg
!= NULL
&& arg
[0] != '\0')
8415 toklen
= strlen (arg
); /* Size of argument list. */
8417 /* Points tok to the end of the argument list. */
8418 tok
= arg
+ toklen
- 1;
8420 /* Go backwards in the parameters list. Skip the last
8421 parameter. If we're expecting a 'thread <thread_num>'
8422 parameter, this should be the thread identifier. */
8423 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
8425 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
8428 /* Points end_tok to the beginning of the last token. */
8429 id_tok_start
= tok
+ 1;
8431 /* Go backwards in the parameters list. Skip one more
8432 parameter. If we're expecting a 'thread <thread_num>'
8433 parameter, we should reach a "thread" token. */
8434 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
8439 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
8442 /* Move the pointer forward to skip the whitespace and
8443 calculate the length of the token. */
8445 toklen
= end_tok
- tok
;
8447 if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
8449 /* At this point we've found a "thread" token, which means
8450 the user is trying to set a watchpoint that triggers
8451 only in a specific thread. */
8454 /* Extract the thread ID from the next token. */
8455 thread
= strtol (id_tok_start
, &endp
, 0);
8457 /* Check if the user provided a valid numeric value for the
8459 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
8460 error (_("Invalid thread ID specification %s."), id_tok_start
);
8462 /* Check if the thread actually exists. */
8463 if (!valid_thread_id (thread
))
8464 error (_("Unknown thread %d."), thread
);
8466 /* Truncate the string and get rid of the thread <thread_num>
8467 parameter before the parameter list is parsed by the
8468 evaluate_expression() function. */
8473 /* Parse the rest of the arguments. */
8474 innermost_block
= NULL
;
8476 exp
= parse_exp_1 (&arg
, 0, 0);
8478 /* Remove trailing whitespace from the expression before saving it.
8479 This makes the eventual display of the expression string a bit
8481 while (exp_end
> exp_start
&& (exp_end
[-1] == ' ' || exp_end
[-1] == '\t'))
8484 /* Checking if the expression is not constant. */
8485 if (watchpoint_exp_is_const (exp
))
8489 len
= exp_end
- exp_start
;
8490 while (len
> 0 && isspace (exp_start
[len
- 1]))
8492 error (_("Cannot watch constant value `%.*s'."), len
, exp_start
);
8495 exp_valid_block
= innermost_block
;
8496 mark
= value_mark ();
8497 fetch_subexp_value (exp
, &pc
, &val
, &result
, NULL
);
8501 exp_valid_block
= NULL
;
8502 val
= value_addr (result
);
8503 release_value (val
);
8504 value_free_to_mark (mark
);
8506 else if (val
!= NULL
)
8507 release_value (val
);
8509 tok
= skip_spaces (arg
);
8510 end_tok
= skip_to_space (tok
);
8512 toklen
= end_tok
- tok
;
8513 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
8515 struct expression
*cond
;
8517 innermost_block
= NULL
;
8518 tok
= cond_start
= end_tok
+ 1;
8519 cond
= parse_exp_1 (&tok
, 0, 0);
8521 /* The watchpoint expression may not be local, but the condition
8522 may still be. E.g.: `watch global if local > 0'. */
8523 cond_exp_valid_block
= innermost_block
;
8529 error (_("Junk at end of command."));
8531 if (accessflag
== hw_read
)
8532 bp_type
= bp_read_watchpoint
;
8533 else if (accessflag
== hw_access
)
8534 bp_type
= bp_access_watchpoint
;
8536 bp_type
= bp_hardware_watchpoint
;
8538 reg_cnt
= can_use_hardware_watchpoint (val
, target_exact_watchpoints
);
8539 if (reg_cnt
== 0 && bp_type
!= bp_hardware_watchpoint
)
8540 error (_("Expression cannot be implemented with read/access watchpoint."));
8543 i
= hw_watchpoint_used_count (bp_type
, &other_type_used
);
8544 target_resources_ok
=
8545 target_can_use_hardware_watchpoint (bp_type
, i
+ reg_cnt
,
8547 if (target_resources_ok
== 0 && bp_type
!= bp_hardware_watchpoint
)
8548 error (_("Target does not support this type of hardware watchpoint."));
8550 if (target_resources_ok
< 0 && bp_type
!= bp_hardware_watchpoint
)
8551 error (_("Target can only support one kind "
8552 "of HW watchpoint at a time."));
8555 /* Change the type of breakpoint to an ordinary watchpoint if a
8556 hardware watchpoint could not be set. */
8557 if (!reg_cnt
|| target_resources_ok
<= 0)
8558 bp_type
= bp_watchpoint
;
8560 frame
= block_innermost_frame (exp_valid_block
);
8562 /* If the expression is "local", then set up a "watchpoint scope"
8563 breakpoint at the point where we've left the scope of the watchpoint
8564 expression. Create the scope breakpoint before the watchpoint, so
8565 that we will encounter it first in bpstat_stop_status. */
8566 if (exp_valid_block
&& frame
)
8568 if (frame_id_p (frame_unwind_caller_id (frame
)))
8571 = create_internal_breakpoint (frame_unwind_caller_arch (frame
),
8572 frame_unwind_caller_pc (frame
),
8573 bp_watchpoint_scope
);
8575 scope_breakpoint
->enable_state
= bp_enabled
;
8577 /* Automatically delete the breakpoint when it hits. */
8578 scope_breakpoint
->disposition
= disp_del
;
8580 /* Only break in the proper frame (help with recursion). */
8581 scope_breakpoint
->frame_id
= frame_unwind_caller_id (frame
);
8583 /* Set the address at which we will stop. */
8584 scope_breakpoint
->loc
->gdbarch
8585 = frame_unwind_caller_arch (frame
);
8586 scope_breakpoint
->loc
->requested_address
8587 = frame_unwind_caller_pc (frame
);
8588 scope_breakpoint
->loc
->address
8589 = adjust_breakpoint_address (scope_breakpoint
->loc
->gdbarch
,
8590 scope_breakpoint
->loc
->requested_address
,
8591 scope_breakpoint
->type
);
8595 /* Now set up the breakpoint. */
8596 b
= set_raw_breakpoint_without_location (NULL
, bp_type
);
8597 set_breakpoint_number (internal
, b
);
8599 b
->disposition
= disp_donttouch
;
8601 b
->exp_valid_block
= exp_valid_block
;
8602 b
->cond_exp_valid_block
= cond_exp_valid_block
;
8605 struct type
*t
= value_type (val
);
8606 CORE_ADDR addr
= value_as_address (val
);
8609 t
= check_typedef (TYPE_TARGET_TYPE (check_typedef (t
)));
8610 name
= type_to_string (t
);
8612 b
->exp_string_reparse
= xstrprintf ("* (%s *) %s", name
,
8613 core_addr_to_string (addr
));
8616 b
->exp_string
= xstrprintf ("-location: %.*s",
8617 (int) (exp_end
- exp_start
), exp_start
);
8619 /* The above expression is in C. */
8620 b
->language
= language_c
;
8623 b
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
8626 b
->ops
= &watchpoint_breakpoint_ops
;
8628 /* Use an exact watchpoint when there's only one memory region to be
8629 watched, and only one debug register is needed to watch it. */
8630 b
->exact
= target_exact_watchpoints
&& reg_cnt
== 1;
8633 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
8639 b
->watchpoint_frame
= get_frame_id (frame
);
8640 b
->watchpoint_thread
= inferior_ptid
;
8644 b
->watchpoint_frame
= null_frame_id
;
8645 b
->watchpoint_thread
= null_ptid
;
8648 if (scope_breakpoint
!= NULL
)
8650 /* The scope breakpoint is related to the watchpoint. We will
8651 need to act on them together. */
8652 b
->related_breakpoint
= scope_breakpoint
;
8653 scope_breakpoint
->related_breakpoint
= b
;
8657 value_free_to_mark (mark
);
8659 /* Finally update the new watchpoint. This creates the locations
8660 that should be inserted. */
8661 update_watchpoint (b
, 1);
8663 /* Do not mention breakpoints with a negative number, but do
8664 notify observers. */
8665 observer_notify_breakpoint_created (b
->number
);
8668 update_global_location_list (1);
8671 /* Return count of debug registers needed to watch the given expression.
8672 If EXACT_WATCHPOINTS is 1, then consider that only the address of
8673 the start of the watched region will be monitored (i.e., all accesses
8674 will be aligned). This uses less debug registers on some targets.
8676 If the watchpoint cannot be handled in hardware return zero. */
8679 can_use_hardware_watchpoint (struct value
*v
, int exact_watchpoints
)
8681 int found_memory_cnt
= 0;
8682 struct value
*head
= v
;
8684 /* Did the user specifically forbid us to use hardware watchpoints? */
8685 if (!can_use_hw_watchpoints
)
8688 /* Make sure that the value of the expression depends only upon
8689 memory contents, and values computed from them within GDB. If we
8690 find any register references or function calls, we can't use a
8691 hardware watchpoint.
8693 The idea here is that evaluating an expression generates a series
8694 of values, one holding the value of every subexpression. (The
8695 expression a*b+c has five subexpressions: a, b, a*b, c, and
8696 a*b+c.) GDB's values hold almost enough information to establish
8697 the criteria given above --- they identify memory lvalues,
8698 register lvalues, computed values, etcetera. So we can evaluate
8699 the expression, and then scan the chain of values that leaves
8700 behind to decide whether we can detect any possible change to the
8701 expression's final value using only hardware watchpoints.
8703 However, I don't think that the values returned by inferior
8704 function calls are special in any way. So this function may not
8705 notice that an expression involving an inferior function call
8706 can't be watched with hardware watchpoints. FIXME. */
8707 for (; v
; v
= value_next (v
))
8709 if (VALUE_LVAL (v
) == lval_memory
)
8711 if (v
!= head
&& value_lazy (v
))
8712 /* A lazy memory lvalue in the chain is one that GDB never
8713 needed to fetch; we either just used its address (e.g.,
8714 `a' in `a.b') or we never needed it at all (e.g., `a'
8715 in `a,b'). This doesn't apply to HEAD; if that is
8716 lazy then it was not readable, but watch it anyway. */
8720 /* Ahh, memory we actually used! Check if we can cover
8721 it with hardware watchpoints. */
8722 struct type
*vtype
= check_typedef (value_type (v
));
8724 /* We only watch structs and arrays if user asked for it
8725 explicitly, never if they just happen to appear in a
8726 middle of some value chain. */
8728 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
8729 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
8731 CORE_ADDR vaddr
= value_address (v
);
8735 len
= (exact_watchpoints
8736 && is_scalar_type_recursive (vtype
))?
8737 1 : TYPE_LENGTH (value_type (v
));
8739 num_regs
= target_region_ok_for_hw_watchpoint (vaddr
, len
);
8743 found_memory_cnt
+= num_regs
;
8747 else if (VALUE_LVAL (v
) != not_lval
8748 && deprecated_value_modifiable (v
) == 0)
8749 return 0; /* These are values from the history (e.g., $1). */
8750 else if (VALUE_LVAL (v
) == lval_register
)
8751 return 0; /* Cannot watch a register with a HW watchpoint. */
8754 /* The expression itself looks suitable for using a hardware
8755 watchpoint, but give the target machine a chance to reject it. */
8756 return found_memory_cnt
;
8760 watch_command_wrapper (char *arg
, int from_tty
, int internal
)
8762 watch_command_1 (arg
, hw_write
, from_tty
, 0, internal
);
8765 /* A helper function that looks for an argument at the start of a
8766 string. The argument must also either be at the end of the string,
8767 or be followed by whitespace. Returns 1 if it finds the argument,
8768 0 otherwise. If the argument is found, it updates *STR. */
8771 check_for_argument (char **str
, char *arg
, int arg_len
)
8773 if (strncmp (*str
, arg
, arg_len
) == 0
8774 && ((*str
)[arg_len
] == '\0' || isspace ((*str
)[arg_len
])))
8782 /* A helper function that looks for the "-location" argument and then
8783 calls watch_command_1. */
8786 watch_maybe_just_location (char *arg
, int accessflag
, int from_tty
)
8788 int just_location
= 0;
8791 && (check_for_argument (&arg
, "-location", sizeof ("-location") - 1)
8792 || check_for_argument (&arg
, "-l", sizeof ("-l") - 1)))
8794 arg
= skip_spaces (arg
);
8798 watch_command_1 (arg
, accessflag
, from_tty
, just_location
, 0);
8802 watch_command (char *arg
, int from_tty
)
8804 watch_maybe_just_location (arg
, hw_write
, from_tty
);
8808 rwatch_command_wrapper (char *arg
, int from_tty
, int internal
)
8810 watch_command_1 (arg
, hw_read
, from_tty
, 0, internal
);
8814 rwatch_command (char *arg
, int from_tty
)
8816 watch_maybe_just_location (arg
, hw_read
, from_tty
);
8820 awatch_command_wrapper (char *arg
, int from_tty
, int internal
)
8822 watch_command_1 (arg
, hw_access
, from_tty
, 0, internal
);
8826 awatch_command (char *arg
, int from_tty
)
8828 watch_maybe_just_location (arg
, hw_access
, from_tty
);
8832 /* Helper routines for the until_command routine in infcmd.c. Here
8833 because it uses the mechanisms of breakpoints. */
8835 struct until_break_command_continuation_args
8837 struct breakpoint
*breakpoint
;
8838 struct breakpoint
*breakpoint2
;
8842 /* This function is called by fetch_inferior_event via the
8843 cmd_continuation pointer, to complete the until command. It takes
8844 care of cleaning up the temporary breakpoints set up by the until
8847 until_break_command_continuation (void *arg
)
8849 struct until_break_command_continuation_args
*a
= arg
;
8851 delete_breakpoint (a
->breakpoint
);
8853 delete_breakpoint (a
->breakpoint2
);
8854 delete_longjmp_breakpoint (a
->thread_num
);
8858 until_break_command (char *arg
, int from_tty
, int anywhere
)
8860 struct symtabs_and_lines sals
;
8861 struct symtab_and_line sal
;
8862 struct frame_info
*frame
= get_selected_frame (NULL
);
8863 struct breakpoint
*breakpoint
;
8864 struct breakpoint
*breakpoint2
= NULL
;
8865 struct cleanup
*old_chain
;
8867 struct thread_info
*tp
;
8869 clear_proceed_status ();
8871 /* Set a breakpoint where the user wants it and at return from
8874 if (default_breakpoint_valid
)
8875 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
8876 default_breakpoint_line
, NULL
, NULL
);
8878 sals
= decode_line_1 (&arg
, 1, (struct symtab
*) NULL
, 0, NULL
, NULL
);
8880 if (sals
.nelts
!= 1)
8881 error (_("Couldn't get information on specified line."));
8884 xfree (sals
.sals
); /* malloc'd, so freed. */
8887 error (_("Junk at end of arguments."));
8889 resolve_sal_pc (&sal
);
8892 /* If the user told us to continue until a specified location,
8893 we don't specify a frame at which we need to stop. */
8894 breakpoint
= set_momentary_breakpoint (get_frame_arch (frame
), sal
,
8895 null_frame_id
, bp_until
);
8897 /* Otherwise, specify the selected frame, because we want to stop
8898 only at the very same frame. */
8899 breakpoint
= set_momentary_breakpoint (get_frame_arch (frame
), sal
,
8900 get_stack_frame_id (frame
),
8903 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
8905 tp
= inferior_thread ();
8908 /* Keep within the current frame, or in frames called by the current
8911 if (frame_id_p (frame_unwind_caller_id (frame
)))
8913 sal
= find_pc_line (frame_unwind_caller_pc (frame
), 0);
8914 sal
.pc
= frame_unwind_caller_pc (frame
);
8915 breakpoint2
= set_momentary_breakpoint (frame_unwind_caller_arch (frame
),
8917 frame_unwind_caller_id (frame
),
8919 make_cleanup_delete_breakpoint (breakpoint2
);
8921 set_longjmp_breakpoint (tp
, frame_unwind_caller_id (frame
));
8922 make_cleanup (delete_longjmp_breakpoint_cleanup
, &thread
);
8925 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
8927 /* If we are running asynchronously, and proceed call above has
8928 actually managed to start the target, arrange for breakpoints to
8929 be deleted when the target stops. Otherwise, we're already
8930 stopped and delete breakpoints via cleanup chain. */
8932 if (target_can_async_p () && is_running (inferior_ptid
))
8934 struct until_break_command_continuation_args
*args
;
8935 args
= xmalloc (sizeof (*args
));
8937 args
->breakpoint
= breakpoint
;
8938 args
->breakpoint2
= breakpoint2
;
8939 args
->thread_num
= thread
;
8941 discard_cleanups (old_chain
);
8942 add_continuation (inferior_thread (),
8943 until_break_command_continuation
, args
,
8947 do_cleanups (old_chain
);
8950 /* This function attempts to parse an optional "if <cond>" clause
8951 from the arg string. If one is not found, it returns NULL.
8953 Else, it returns a pointer to the condition string. (It does not
8954 attempt to evaluate the string against a particular block.) And,
8955 it updates arg to point to the first character following the parsed
8956 if clause in the arg string. */
8959 ep_parse_optional_if_clause (char **arg
)
8963 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
8966 /* Skip the "if" keyword. */
8969 /* Skip any extra leading whitespace, and record the start of the
8970 condition string. */
8971 *arg
= skip_spaces (*arg
);
8974 /* Assume that the condition occupies the remainder of the arg
8976 (*arg
) += strlen (cond_string
);
8981 /* Commands to deal with catching events, such as signals, exceptions,
8982 process start/exit, etc. */
8986 catch_fork_temporary
, catch_vfork_temporary
,
8987 catch_fork_permanent
, catch_vfork_permanent
8992 catch_fork_command_1 (char *arg
, int from_tty
,
8993 struct cmd_list_element
*command
)
8995 struct gdbarch
*gdbarch
= get_current_arch ();
8996 char *cond_string
= NULL
;
8997 catch_fork_kind fork_kind
;
9000 fork_kind
= (catch_fork_kind
) (uintptr_t) get_cmd_context (command
);
9001 tempflag
= (fork_kind
== catch_fork_temporary
9002 || fork_kind
== catch_vfork_temporary
);
9006 arg
= skip_spaces (arg
);
9008 /* The allowed syntax is:
9010 catch [v]fork if <cond>
9012 First, check if there's an if clause. */
9013 cond_string
= ep_parse_optional_if_clause (&arg
);
9015 if ((*arg
!= '\0') && !isspace (*arg
))
9016 error (_("Junk at end of arguments."));
9018 /* If this target supports it, create a fork or vfork catchpoint
9019 and enable reporting of such events. */
9022 case catch_fork_temporary
:
9023 case catch_fork_permanent
:
9024 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
9025 &catch_fork_breakpoint_ops
);
9027 case catch_vfork_temporary
:
9028 case catch_vfork_permanent
:
9029 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
9030 &catch_vfork_breakpoint_ops
);
9033 error (_("unsupported or unknown fork kind; cannot catch it"));
9039 catch_exec_command_1 (char *arg
, int from_tty
,
9040 struct cmd_list_element
*command
)
9042 struct gdbarch
*gdbarch
= get_current_arch ();
9044 char *cond_string
= NULL
;
9046 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
9050 arg
= skip_spaces (arg
);
9052 /* The allowed syntax is:
9054 catch exec if <cond>
9056 First, check if there's an if clause. */
9057 cond_string
= ep_parse_optional_if_clause (&arg
);
9059 if ((*arg
!= '\0') && !isspace (*arg
))
9060 error (_("Junk at end of arguments."));
9062 /* If this target supports it, create an exec catchpoint
9063 and enable reporting of such events. */
9064 create_catchpoint (gdbarch
, tempflag
, cond_string
,
9065 &catch_exec_breakpoint_ops
);
9068 static enum print_stop_action
9069 print_exception_catchpoint (struct breakpoint
*b
)
9071 int bp_temp
, bp_throw
;
9073 annotate_catchpoint (b
->number
);
9075 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
9076 if (b
->loc
->address
!= b
->loc
->requested_address
)
9077 breakpoint_adjustment_warning (b
->loc
->requested_address
,
9080 bp_temp
= b
->disposition
== disp_del
;
9082 bp_temp
? "Temporary catchpoint "
9084 if (!ui_out_is_mi_like_p (uiout
))
9085 ui_out_field_int (uiout
, "bkptno", b
->number
);
9087 bp_throw
? " (exception thrown), "
9088 : " (exception caught), ");
9089 if (ui_out_is_mi_like_p (uiout
))
9091 ui_out_field_string (uiout
, "reason",
9092 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
9093 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
9094 ui_out_field_int (uiout
, "bkptno", b
->number
);
9096 return PRINT_SRC_AND_LOC
;
9100 print_one_exception_catchpoint (struct breakpoint
*b
,
9101 struct bp_location
**last_loc
)
9103 struct value_print_options opts
;
9105 get_user_print_options (&opts
);
9106 if (opts
.addressprint
)
9109 if (b
->loc
== NULL
|| b
->loc
->shlib_disabled
)
9110 ui_out_field_string (uiout
, "addr", "<PENDING>");
9112 ui_out_field_core_addr (uiout
, "addr",
9113 b
->loc
->gdbarch
, b
->loc
->address
);
9118 if (strstr (b
->addr_string
, "throw") != NULL
)
9119 ui_out_field_string (uiout
, "what", "exception throw");
9121 ui_out_field_string (uiout
, "what", "exception catch");
9125 print_mention_exception_catchpoint (struct breakpoint
*b
)
9130 bp_temp
= b
->disposition
== disp_del
;
9131 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
9132 ui_out_text (uiout
, bp_temp
? _("Temporary catchpoint ")
9133 : _("Catchpoint "));
9134 ui_out_field_int (uiout
, "bkptno", b
->number
);
9135 ui_out_text (uiout
, bp_throw
? _(" (throw)")
9139 /* Implement the "print_recreate" breakpoint_ops method for throw and
9140 catch catchpoints. */
9143 print_recreate_exception_catchpoint (struct breakpoint
*b
,
9149 bp_temp
= b
->disposition
== disp_del
;
9150 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
9151 fprintf_unfiltered (fp
, bp_temp
? "tcatch " : "catch ");
9152 fprintf_unfiltered (fp
, bp_throw
? "throw" : "catch");
9155 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops
= {
9158 NULL
, /* breakpoint_hit */
9159 NULL
, /* resources_needed */
9160 print_exception_catchpoint
,
9161 print_one_exception_catchpoint
,
9162 print_mention_exception_catchpoint
,
9163 print_recreate_exception_catchpoint
9167 handle_gnu_v3_exceptions (int tempflag
, char *cond_string
,
9168 enum exception_event_kind ex_event
, int from_tty
)
9170 char *trigger_func_name
;
9172 if (ex_event
== EX_EVENT_CATCH
)
9173 trigger_func_name
= "__cxa_begin_catch";
9175 trigger_func_name
= "__cxa_throw";
9177 create_breakpoint (get_current_arch (),
9178 trigger_func_name
, cond_string
, -1,
9179 0 /* condition and thread are valid. */,
9180 tempflag
, bp_breakpoint
,
9182 AUTO_BOOLEAN_TRUE
/* pending */,
9183 &gnu_v3_exception_catchpoint_ops
, from_tty
,
9190 /* Deal with "catch catch" and "catch throw" commands. */
9193 catch_exception_command_1 (enum exception_event_kind ex_event
, char *arg
,
9194 int tempflag
, int from_tty
)
9196 char *cond_string
= NULL
;
9200 arg
= skip_spaces (arg
);
9202 cond_string
= ep_parse_optional_if_clause (&arg
);
9204 if ((*arg
!= '\0') && !isspace (*arg
))
9205 error (_("Junk at end of arguments."));
9207 if (ex_event
!= EX_EVENT_THROW
9208 && ex_event
!= EX_EVENT_CATCH
)
9209 error (_("Unsupported or unknown exception event; cannot catch it"));
9211 if (handle_gnu_v3_exceptions (tempflag
, cond_string
, ex_event
, from_tty
))
9214 warning (_("Unsupported with this platform/compiler combination."));
9217 /* Implementation of "catch catch" command. */
9220 catch_catch_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
9222 int tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
9224 catch_exception_command_1 (EX_EVENT_CATCH
, arg
, tempflag
, from_tty
);
9227 /* Implementation of "catch throw" command. */
9230 catch_throw_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
9232 int tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
9234 catch_exception_command_1 (EX_EVENT_THROW
, arg
, tempflag
, from_tty
);
9237 /* Create a breakpoint struct for Ada exception catchpoints. */
9240 create_ada_exception_breakpoint (struct gdbarch
*gdbarch
,
9241 struct symtab_and_line sal
,
9245 struct expression
*cond
,
9246 struct breakpoint_ops
*ops
,
9250 struct breakpoint
*b
;
9254 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
9256 loc_gdbarch
= gdbarch
;
9258 describe_other_breakpoints (loc_gdbarch
,
9259 sal
.pspace
, sal
.pc
, sal
.section
, -1);
9260 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
9261 version for exception catchpoints, because two catchpoints
9262 used for different exception names will use the same address.
9263 In this case, a "breakpoint ... also set at..." warning is
9264 unproductive. Besides, the warning phrasing is also a bit
9265 inapropriate, we should use the word catchpoint, and tell
9266 the user what type of catchpoint it is. The above is good
9267 enough for now, though. */
9270 b
= set_raw_breakpoint (gdbarch
, sal
, bp_breakpoint
);
9271 set_breakpoint_count (breakpoint_count
+ 1);
9273 b
->enable_state
= bp_enabled
;
9274 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
9275 b
->number
= breakpoint_count
;
9276 b
->ignore_count
= 0;
9277 b
->loc
->cond
= cond
;
9278 b
->addr_string
= addr_string
;
9279 b
->language
= language_ada
;
9280 b
->cond_string
= cond_string
;
9281 b
->exp_string
= exp_string
;
9286 update_global_location_list (1);
9289 /* Implement the "catch exception" command. */
9292 catch_ada_exception_command (char *arg
, int from_tty
,
9293 struct cmd_list_element
*command
)
9295 struct gdbarch
*gdbarch
= get_current_arch ();
9297 struct symtab_and_line sal
;
9298 char *addr_string
= NULL
;
9299 char *exp_string
= NULL
;
9300 char *cond_string
= NULL
;
9301 struct expression
*cond
= NULL
;
9302 struct breakpoint_ops
*ops
= NULL
;
9304 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
9308 sal
= ada_decode_exception_location (arg
, &addr_string
, &exp_string
,
9309 &cond_string
, &cond
, &ops
);
9310 create_ada_exception_breakpoint (gdbarch
, sal
, addr_string
, exp_string
,
9311 cond_string
, cond
, ops
, tempflag
,
9315 /* Cleanup function for a syscall filter list. */
9317 clean_up_filters (void *arg
)
9319 VEC(int) *iter
= *(VEC(int) **) arg
;
9320 VEC_free (int, iter
);
9323 /* Splits the argument using space as delimiter. Returns an xmalloc'd
9324 filter list, or NULL if no filtering is required. */
9326 catch_syscall_split_args (char *arg
)
9328 VEC(int) *result
= NULL
;
9329 struct cleanup
*cleanup
= make_cleanup (clean_up_filters
, &result
);
9331 while (*arg
!= '\0')
9333 int i
, syscall_number
;
9338 /* Skip whitespace. */
9339 while (isspace (*arg
))
9342 for (i
= 0; i
< 127 && arg
[i
] && !isspace (arg
[i
]); ++i
)
9343 cur_name
[i
] = arg
[i
];
9347 /* Check if the user provided a syscall name or a number. */
9348 syscall_number
= (int) strtol (cur_name
, &endptr
, 0);
9349 if (*endptr
== '\0')
9350 get_syscall_by_number (syscall_number
, &s
);
9353 /* We have a name. Let's check if it's valid and convert it
9355 get_syscall_by_name (cur_name
, &s
);
9357 if (s
.number
== UNKNOWN_SYSCALL
)
9358 /* Here we have to issue an error instead of a warning,
9359 because GDB cannot do anything useful if there's no
9360 syscall number to be caught. */
9361 error (_("Unknown syscall name '%s'."), cur_name
);
9364 /* Ok, it's valid. */
9365 VEC_safe_push (int, result
, s
.number
);
9368 discard_cleanups (cleanup
);
9372 /* Implement the "catch syscall" command. */
9375 catch_syscall_command_1 (char *arg
, int from_tty
,
9376 struct cmd_list_element
*command
)
9381 struct gdbarch
*gdbarch
= get_current_arch ();
9383 /* Checking if the feature if supported. */
9384 if (gdbarch_get_syscall_number_p (gdbarch
) == 0)
9385 error (_("The feature 'catch syscall' is not supported on \
9386 this architecture yet."));
9388 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
9390 arg
= skip_spaces (arg
);
9392 /* We need to do this first "dummy" translation in order
9393 to get the syscall XML file loaded or, most important,
9394 to display a warning to the user if there's no XML file
9395 for his/her architecture. */
9396 get_syscall_by_number (0, &s
);
9398 /* The allowed syntax is:
9400 catch syscall <name | number> [<name | number> ... <name | number>]
9402 Let's check if there's a syscall name. */
9405 filter
= catch_syscall_split_args (arg
);
9409 create_syscall_event_catchpoint (tempflag
, filter
,
9410 &catch_syscall_breakpoint_ops
);
9413 /* Implement the "catch assert" command. */
9416 catch_assert_command (char *arg
, int from_tty
,
9417 struct cmd_list_element
*command
)
9419 struct gdbarch
*gdbarch
= get_current_arch ();
9421 struct symtab_and_line sal
;
9422 char *addr_string
= NULL
;
9423 struct breakpoint_ops
*ops
= NULL
;
9425 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
9429 sal
= ada_decode_assert_location (arg
, &addr_string
, &ops
);
9430 create_ada_exception_breakpoint (gdbarch
, sal
, addr_string
, NULL
, NULL
, NULL
,
9431 ops
, tempflag
, from_tty
);
9435 catch_command (char *arg
, int from_tty
)
9437 error (_("Catch requires an event name."));
9442 tcatch_command (char *arg
, int from_tty
)
9444 error (_("Catch requires an event name."));
9447 /* Delete breakpoints by address or line. */
9450 clear_command (char *arg
, int from_tty
)
9452 struct breakpoint
*b
;
9453 VEC(breakpoint_p
) *found
= 0;
9456 struct symtabs_and_lines sals
;
9457 struct symtab_and_line sal
;
9462 sals
= decode_line_spec (arg
, 1);
9467 sals
.sals
= (struct symtab_and_line
*)
9468 xmalloc (sizeof (struct symtab_and_line
));
9469 make_cleanup (xfree
, sals
.sals
);
9470 init_sal (&sal
); /* Initialize to zeroes. */
9471 sal
.line
= default_breakpoint_line
;
9472 sal
.symtab
= default_breakpoint_symtab
;
9473 sal
.pc
= default_breakpoint_address
;
9474 sal
.pspace
= default_breakpoint_pspace
;
9475 if (sal
.symtab
== 0)
9476 error (_("No source file specified."));
9484 /* We don't call resolve_sal_pc here. That's not as bad as it
9485 seems, because all existing breakpoints typically have both
9486 file/line and pc set. So, if clear is given file/line, we can
9487 match this to existing breakpoint without obtaining pc at all.
9489 We only support clearing given the address explicitly
9490 present in breakpoint table. Say, we've set breakpoint
9491 at file:line. There were several PC values for that file:line,
9492 due to optimization, all in one block.
9494 We've picked one PC value. If "clear" is issued with another
9495 PC corresponding to the same file:line, the breakpoint won't
9496 be cleared. We probably can still clear the breakpoint, but
9497 since the other PC value is never presented to user, user
9498 can only find it by guessing, and it does not seem important
9501 /* For each line spec given, delete bps which correspond to it. Do
9502 it in two passes, solely to preserve the current behavior that
9503 from_tty is forced true if we delete more than one
9507 for (i
= 0; i
< sals
.nelts
; i
++)
9509 /* If exact pc given, clear bpts at that pc.
9510 If line given (pc == 0), clear all bpts on specified line.
9511 If defaulting, clear all bpts on default line
9514 defaulting sal.pc != 0 tests to do
9519 1 0 <can't happen> */
9523 /* Find all matching breakpoints and add them to 'found'. */
9527 /* Are we going to delete b? */
9528 if (b
->type
!= bp_none
&& !is_watchpoint (b
))
9530 struct bp_location
*loc
= b
->loc
;
9531 for (; loc
; loc
= loc
->next
)
9533 int pc_match
= sal
.pc
9534 && (loc
->pspace
== sal
.pspace
)
9535 && (loc
->address
== sal
.pc
)
9536 && (!section_is_overlay (loc
->section
)
9537 || loc
->section
== sal
.section
);
9538 int line_match
= ((default_match
|| (0 == sal
.pc
))
9539 && b
->source_file
!= NULL
9540 && sal
.symtab
!= NULL
9541 && sal
.pspace
== loc
->pspace
9542 && filename_cmp (b
->source_file
,
9543 sal
.symtab
->filename
) == 0
9544 && b
->line_number
== sal
.line
);
9545 if (pc_match
|| line_match
)
9554 VEC_safe_push(breakpoint_p
, found
, b
);
9557 /* Now go thru the 'found' chain and delete them. */
9558 if (VEC_empty(breakpoint_p
, found
))
9561 error (_("No breakpoint at %s."), arg
);
9563 error (_("No breakpoint at this line."));
9566 if (VEC_length(breakpoint_p
, found
) > 1)
9567 from_tty
= 1; /* Always report if deleted more than one. */
9570 if (VEC_length(breakpoint_p
, found
) == 1)
9571 printf_unfiltered (_("Deleted breakpoint "));
9573 printf_unfiltered (_("Deleted breakpoints "));
9575 breakpoints_changed ();
9577 for (ix
= 0; VEC_iterate(breakpoint_p
, found
, ix
, b
); ix
++)
9580 printf_unfiltered ("%d ", b
->number
);
9581 delete_breakpoint (b
);
9584 putchar_unfiltered ('\n');
9587 /* Delete breakpoint in BS if they are `delete' breakpoints and
9588 all breakpoints that are marked for deletion, whether hit or not.
9589 This is called after any breakpoint is hit, or after errors. */
9592 breakpoint_auto_delete (bpstat bs
)
9594 struct breakpoint
*b
, *b_tmp
;
9596 for (; bs
; bs
= bs
->next
)
9597 if (bs
->breakpoint_at
9598 && bs
->breakpoint_at
->disposition
== disp_del
9600 delete_breakpoint (bs
->breakpoint_at
);
9602 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
9604 if (b
->disposition
== disp_del_at_next_stop
)
9605 delete_breakpoint (b
);
9609 /* A comparison function for bp_location AP and BP being interfaced to
9610 qsort. Sort elements primarily by their ADDRESS (no matter what
9611 does breakpoint_address_is_meaningful say for its OWNER),
9612 secondarily by ordering first bp_permanent OWNERed elements and
9613 terciarily just ensuring the array is sorted stable way despite
9614 qsort being an instable algorithm. */
9617 bp_location_compare (const void *ap
, const void *bp
)
9619 struct bp_location
*a
= *(void **) ap
;
9620 struct bp_location
*b
= *(void **) bp
;
9621 /* A and B come from existing breakpoints having non-NULL OWNER. */
9622 int a_perm
= a
->owner
->enable_state
== bp_permanent
;
9623 int b_perm
= b
->owner
->enable_state
== bp_permanent
;
9625 if (a
->address
!= b
->address
)
9626 return (a
->address
> b
->address
) - (a
->address
< b
->address
);
9628 /* Sort permanent breakpoints first. */
9629 if (a_perm
!= b_perm
)
9630 return (a_perm
< b_perm
) - (a_perm
> b_perm
);
9632 /* Make the user-visible order stable across GDB runs. Locations of
9633 the same breakpoint can be sorted in arbitrary order. */
9635 if (a
->owner
->number
!= b
->owner
->number
)
9636 return (a
->owner
->number
> b
->owner
->number
)
9637 - (a
->owner
->number
< b
->owner
->number
);
9639 return (a
> b
) - (a
< b
);
9642 /* Set bp_location_placed_address_before_address_max and
9643 bp_location_shadow_len_after_address_max according to the current
9644 content of the bp_location array. */
9647 bp_location_target_extensions_update (void)
9649 struct bp_location
*bl
, **blp_tmp
;
9651 bp_location_placed_address_before_address_max
= 0;
9652 bp_location_shadow_len_after_address_max
= 0;
9654 ALL_BP_LOCATIONS (bl
, blp_tmp
)
9656 CORE_ADDR start
, end
, addr
;
9658 if (!bp_location_has_shadow (bl
))
9661 start
= bl
->target_info
.placed_address
;
9662 end
= start
+ bl
->target_info
.shadow_len
;
9664 gdb_assert (bl
->address
>= start
);
9665 addr
= bl
->address
- start
;
9666 if (addr
> bp_location_placed_address_before_address_max
)
9667 bp_location_placed_address_before_address_max
= addr
;
9669 /* Zero SHADOW_LEN would not pass bp_location_has_shadow. */
9671 gdb_assert (bl
->address
< end
);
9672 addr
= end
- bl
->address
;
9673 if (addr
> bp_location_shadow_len_after_address_max
)
9674 bp_location_shadow_len_after_address_max
= addr
;
9678 /* If SHOULD_INSERT is false, do not insert any breakpoint locations
9679 into the inferior, only remove already-inserted locations that no
9680 longer should be inserted. Functions that delete a breakpoint or
9681 breakpoints should pass false, so that deleting a breakpoint
9682 doesn't have the side effect of inserting the locations of other
9683 breakpoints that are marked not-inserted, but should_be_inserted
9684 returns true on them.
9686 This behaviour is useful is situations close to tear-down -- e.g.,
9687 after an exec, while the target still has execution, but breakpoint
9688 shadows of the previous executable image should *NOT* be restored
9689 to the new image; or before detaching, where the target still has
9690 execution and wants to delete breakpoints from GDB's lists, and all
9691 breakpoints had already been removed from the inferior. */
9694 update_global_location_list (int should_insert
)
9696 struct breakpoint
*b
;
9697 struct bp_location
**locp
, *loc
;
9698 struct cleanup
*cleanups
;
9700 /* Used in the duplicates detection below. When iterating over all
9701 bp_locations, points to the first bp_location of a given address.
9702 Breakpoints and watchpoints of different types are never
9703 duplicates of each other. Keep one pointer for each type of
9704 breakpoint/watchpoint, so we only need to loop over all locations
9706 struct bp_location
*bp_loc_first
; /* breakpoint */
9707 struct bp_location
*wp_loc_first
; /* hardware watchpoint */
9708 struct bp_location
*awp_loc_first
; /* access watchpoint */
9709 struct bp_location
*rwp_loc_first
; /* read watchpoint */
9711 /* Saved former bp_location array which we compare against the newly
9712 built bp_location from the current state of ALL_BREAKPOINTS. */
9713 struct bp_location
**old_location
, **old_locp
;
9714 unsigned old_location_count
;
9716 old_location
= bp_location
;
9717 old_location_count
= bp_location_count
;
9719 bp_location_count
= 0;
9720 cleanups
= make_cleanup (xfree
, old_location
);
9723 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
9724 bp_location_count
++;
9726 bp_location
= xmalloc (sizeof (*bp_location
) * bp_location_count
);
9729 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
9731 qsort (bp_location
, bp_location_count
, sizeof (*bp_location
),
9732 bp_location_compare
);
9734 bp_location_target_extensions_update ();
9736 /* Identify bp_location instances that are no longer present in the
9737 new list, and therefore should be freed. Note that it's not
9738 necessary that those locations should be removed from inferior --
9739 if there's another location at the same address (previously
9740 marked as duplicate), we don't need to remove/insert the
9743 LOCP is kept in sync with OLD_LOCP, each pointing to the current
9744 and former bp_location array state respectively. */
9747 for (old_locp
= old_location
; old_locp
< old_location
+ old_location_count
;
9750 struct bp_location
*old_loc
= *old_locp
;
9751 struct bp_location
**loc2p
;
9753 /* Tells if 'old_loc' is found amoung the new locations. If
9754 not, we have to free it. */
9755 int found_object
= 0;
9756 /* Tells if the location should remain inserted in the target. */
9757 int keep_in_target
= 0;
9760 /* Skip LOCP entries which will definitely never be needed.
9761 Stop either at or being the one matching OLD_LOC. */
9762 while (locp
< bp_location
+ bp_location_count
9763 && (*locp
)->address
< old_loc
->address
)
9767 (loc2p
< bp_location
+ bp_location_count
9768 && (*loc2p
)->address
== old_loc
->address
);
9771 if (*loc2p
== old_loc
)
9778 /* If this location is no longer present, and inserted, look if
9779 there's maybe a new location at the same address. If so,
9780 mark that one inserted, and don't remove this one. This is
9781 needed so that we don't have a time window where a breakpoint
9782 at certain location is not inserted. */
9784 if (old_loc
->inserted
)
9786 /* If the location is inserted now, we might have to remove
9789 if (found_object
&& should_be_inserted (old_loc
))
9791 /* The location is still present in the location list,
9792 and still should be inserted. Don't do anything. */
9797 /* The location is either no longer present, or got
9798 disabled. See if there's another location at the
9799 same address, in which case we don't need to remove
9800 this one from the target. */
9802 /* OLD_LOC comes from existing struct breakpoint. */
9803 if (breakpoint_address_is_meaningful (old_loc
->owner
))
9806 (loc2p
< bp_location
+ bp_location_count
9807 && (*loc2p
)->address
== old_loc
->address
);
9810 struct bp_location
*loc2
= *loc2p
;
9812 if (breakpoint_locations_match (loc2
, old_loc
))
9814 /* For the sake of should_be_inserted.
9815 Duplicates check below will fix up this
9817 loc2
->duplicate
= 0;
9819 /* Read watchpoint locations are switched to
9820 access watchpoints, if the former are not
9821 supported, but the latter are. */
9822 if (is_hardware_watchpoint (old_loc
->owner
))
9824 gdb_assert (is_hardware_watchpoint (loc2
->owner
));
9825 loc2
->watchpoint_type
= old_loc
->watchpoint_type
;
9828 if (loc2
!= old_loc
&& should_be_inserted (loc2
))
9831 loc2
->target_info
= old_loc
->target_info
;
9840 if (!keep_in_target
)
9842 if (remove_breakpoint (old_loc
, mark_uninserted
))
9844 /* This is just about all we can do. We could keep
9845 this location on the global list, and try to
9846 remove it next time, but there's no particular
9847 reason why we will succeed next time.
9849 Note that at this point, old_loc->owner is still
9850 valid, as delete_breakpoint frees the breakpoint
9851 only after calling us. */
9852 printf_filtered (_("warning: Error removing "
9854 old_loc
->owner
->number
);
9862 if (removed
&& non_stop
9863 && breakpoint_address_is_meaningful (old_loc
->owner
)
9864 && !is_hardware_watchpoint (old_loc
->owner
))
9866 /* This location was removed from the target. In
9867 non-stop mode, a race condition is possible where
9868 we've removed a breakpoint, but stop events for that
9869 breakpoint are already queued and will arrive later.
9870 We apply an heuristic to be able to distinguish such
9871 SIGTRAPs from other random SIGTRAPs: we keep this
9872 breakpoint location for a bit, and will retire it
9873 after we see some number of events. The theory here
9874 is that reporting of events should, "on the average",
9875 be fair, so after a while we'll see events from all
9876 threads that have anything of interest, and no longer
9877 need to keep this breakpoint location around. We
9878 don't hold locations forever so to reduce chances of
9879 mistaking a non-breakpoint SIGTRAP for a breakpoint
9882 The heuristic failing can be disastrous on
9883 decr_pc_after_break targets.
9885 On decr_pc_after_break targets, like e.g., x86-linux,
9886 if we fail to recognize a late breakpoint SIGTRAP,
9887 because events_till_retirement has reached 0 too
9888 soon, we'll fail to do the PC adjustment, and report
9889 a random SIGTRAP to the user. When the user resumes
9890 the inferior, it will most likely immediately crash
9891 with SIGILL/SIGBUS/SIGSEGV, or worse, get silently
9892 corrupted, because of being resumed e.g., in the
9893 middle of a multi-byte instruction, or skipped a
9894 one-byte instruction. This was actually seen happen
9895 on native x86-linux, and should be less rare on
9896 targets that do not support new thread events, like
9897 remote, due to the heuristic depending on
9900 Mistaking a random SIGTRAP for a breakpoint trap
9901 causes similar symptoms (PC adjustment applied when
9902 it shouldn't), but then again, playing with SIGTRAPs
9903 behind the debugger's back is asking for trouble.
9905 Since hardware watchpoint traps are always
9906 distinguishable from other traps, so we don't need to
9907 apply keep hardware watchpoint moribund locations
9908 around. We simply always ignore hardware watchpoint
9909 traps we can no longer explain. */
9911 old_loc
->events_till_retirement
= 3 * (thread_count () + 1);
9912 old_loc
->owner
= NULL
;
9914 VEC_safe_push (bp_location_p
, moribund_locations
, old_loc
);
9918 old_loc
->owner
= NULL
;
9919 decref_bp_location (&old_loc
);
9924 /* Rescan breakpoints at the same address and section, marking the
9925 first one as "first" and any others as "duplicates". This is so
9926 that the bpt instruction is only inserted once. If we have a
9927 permanent breakpoint at the same place as BPT, make that one the
9928 official one, and the rest as duplicates. Permanent breakpoints
9929 are sorted first for the same address.
9931 Do the same for hardware watchpoints, but also considering the
9932 watchpoint's type (regular/access/read) and length. */
9934 bp_loc_first
= NULL
;
9935 wp_loc_first
= NULL
;
9936 awp_loc_first
= NULL
;
9937 rwp_loc_first
= NULL
;
9938 ALL_BP_LOCATIONS (loc
, locp
)
9940 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always
9942 struct breakpoint
*b
= loc
->owner
;
9943 struct bp_location
**loc_first_p
;
9945 if (b
->enable_state
== bp_disabled
9946 || b
->enable_state
== bp_call_disabled
9947 || b
->enable_state
== bp_startup_disabled
9949 || loc
->shlib_disabled
9950 || !breakpoint_address_is_meaningful (b
)
9951 || is_tracepoint (b
))
9954 /* Permanent breakpoint should always be inserted. */
9955 if (b
->enable_state
== bp_permanent
&& ! loc
->inserted
)
9956 internal_error (__FILE__
, __LINE__
,
9957 _("allegedly permanent breakpoint is not "
9958 "actually inserted"));
9960 if (b
->type
== bp_hardware_watchpoint
)
9961 loc_first_p
= &wp_loc_first
;
9962 else if (b
->type
== bp_read_watchpoint
)
9963 loc_first_p
= &rwp_loc_first
;
9964 else if (b
->type
== bp_access_watchpoint
)
9965 loc_first_p
= &awp_loc_first
;
9967 loc_first_p
= &bp_loc_first
;
9969 if (*loc_first_p
== NULL
9970 || (overlay_debugging
&& loc
->section
!= (*loc_first_p
)->section
)
9971 || !breakpoint_locations_match (loc
, *loc_first_p
))
9980 if ((*loc_first_p
)->owner
->enable_state
== bp_permanent
&& loc
->inserted
9981 && b
->enable_state
!= bp_permanent
)
9982 internal_error (__FILE__
, __LINE__
,
9983 _("another breakpoint was inserted on top of "
9984 "a permanent breakpoint"));
9987 if (breakpoints_always_inserted_mode () && should_insert
9988 && (have_live_inferiors ()
9989 || (gdbarch_has_global_breakpoints (target_gdbarch
))))
9990 insert_breakpoint_locations ();
9992 do_cleanups (cleanups
);
9996 breakpoint_retire_moribund (void)
9998 struct bp_location
*loc
;
10001 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
10002 if (--(loc
->events_till_retirement
) == 0)
10004 decref_bp_location (&loc
);
10005 VEC_unordered_remove (bp_location_p
, moribund_locations
, ix
);
10011 update_global_location_list_nothrow (int inserting
)
10013 struct gdb_exception e
;
10015 TRY_CATCH (e
, RETURN_MASK_ERROR
)
10016 update_global_location_list (inserting
);
10019 /* Clear BKP from a BPS. */
10022 bpstat_remove_bp_location (bpstat bps
, struct breakpoint
*bpt
)
10026 for (bs
= bps
; bs
; bs
= bs
->next
)
10027 if (bs
->breakpoint_at
== bpt
)
10029 bs
->breakpoint_at
= NULL
;
10030 bs
->old_val
= NULL
;
10031 /* bs->commands will be freed later. */
10035 /* Callback for iterate_over_threads. */
10037 bpstat_remove_breakpoint_callback (struct thread_info
*th
, void *data
)
10039 struct breakpoint
*bpt
= data
;
10041 bpstat_remove_bp_location (th
->control
.stop_bpstat
, bpt
);
10045 /* Delete a breakpoint and clean up all traces of it in the data
10049 delete_breakpoint (struct breakpoint
*bpt
)
10051 struct breakpoint
*b
;
10053 gdb_assert (bpt
!= NULL
);
10055 /* Has this bp already been deleted? This can happen because
10056 multiple lists can hold pointers to bp's. bpstat lists are
10059 One example of this happening is a watchpoint's scope bp. When
10060 the scope bp triggers, we notice that the watchpoint is out of
10061 scope, and delete it. We also delete its scope bp. But the
10062 scope bp is marked "auto-deleting", and is already on a bpstat.
10063 That bpstat is then checked for auto-deleting bp's, which are
10066 A real solution to this problem might involve reference counts in
10067 bp's, and/or giving them pointers back to their referencing
10068 bpstat's, and teaching delete_breakpoint to only free a bp's
10069 storage when no more references were extent. A cheaper bandaid
10071 if (bpt
->type
== bp_none
)
10074 /* At least avoid this stale reference until the reference counting
10075 of breakpoints gets resolved. */
10076 if (bpt
->related_breakpoint
!= bpt
)
10078 struct breakpoint
*related
;
10080 if (bpt
->type
== bp_watchpoint_scope
)
10081 watchpoint_del_at_next_stop (bpt
->related_breakpoint
);
10082 else if (bpt
->related_breakpoint
->type
== bp_watchpoint_scope
)
10083 watchpoint_del_at_next_stop (bpt
);
10085 /* Unlink bpt from the bpt->related_breakpoint ring. */
10086 for (related
= bpt
; related
->related_breakpoint
!= bpt
;
10087 related
= related
->related_breakpoint
);
10088 related
->related_breakpoint
= bpt
->related_breakpoint
;
10089 bpt
->related_breakpoint
= bpt
;
10092 observer_notify_breakpoint_deleted (bpt
->number
);
10094 if (breakpoint_chain
== bpt
)
10095 breakpoint_chain
= bpt
->next
;
10097 ALL_BREAKPOINTS (b
)
10098 if (b
->next
== bpt
)
10100 b
->next
= bpt
->next
;
10104 decref_counted_command_line (&bpt
->commands
);
10105 xfree (bpt
->cond_string
);
10106 xfree (bpt
->cond_exp
);
10107 xfree (bpt
->addr_string
);
10109 xfree (bpt
->exp_string
);
10110 xfree (bpt
->exp_string_reparse
);
10111 value_free (bpt
->val
);
10112 xfree (bpt
->source_file
);
10113 xfree (bpt
->exec_pathname
);
10114 clean_up_filters (&bpt
->syscalls_to_be_caught
);
10117 /* Be sure no bpstat's are pointing at the breakpoint after it's
10119 /* FIXME, how can we find all bpstat's? We just check stop_bpstat
10120 in all threeds for now. Note that we cannot just remove bpstats
10121 pointing at bpt from the stop_bpstat list entirely, as breakpoint
10122 commands are associated with the bpstat; if we remove it here,
10123 then the later call to bpstat_do_actions (&stop_bpstat); in
10124 event-top.c won't do anything, and temporary breakpoints with
10125 commands won't work. */
10127 iterate_over_threads (bpstat_remove_breakpoint_callback
, bpt
);
10129 /* Now that breakpoint is removed from breakpoint list, update the
10130 global location list. This will remove locations that used to
10131 belong to this breakpoint. Do this before freeing the breakpoint
10132 itself, since remove_breakpoint looks at location's owner. It
10133 might be better design to have location completely
10134 self-contained, but it's not the case now. */
10135 update_global_location_list (0);
10138 /* On the chance that someone will soon try again to delete this
10139 same bp, we mark it as deleted before freeing its storage. */
10140 bpt
->type
= bp_none
;
10146 do_delete_breakpoint_cleanup (void *b
)
10148 delete_breakpoint (b
);
10152 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
10154 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
10157 /* A callback for map_breakpoint_numbers that calls
10158 delete_breakpoint. */
10161 do_delete_breakpoint (struct breakpoint
*b
, void *ignore
)
10163 delete_breakpoint (b
);
10167 delete_command (char *arg
, int from_tty
)
10169 struct breakpoint
*b
, *b_tmp
;
10175 int breaks_to_delete
= 0;
10177 /* Delete all breakpoints if no argument.
10178 Do not delete internal or call-dummy breakpoints, these have
10179 to be deleted with an explicit breakpoint number argument. */
10180 ALL_BREAKPOINTS (b
)
10182 if (b
->type
!= bp_call_dummy
10183 && b
->type
!= bp_std_terminate
10184 && b
->type
!= bp_shlib_event
10185 && b
->type
!= bp_jit_event
10186 && b
->type
!= bp_thread_event
10187 && b
->type
!= bp_overlay_event
10188 && b
->type
!= bp_longjmp_master
10189 && b
->type
!= bp_std_terminate_master
10190 && b
->type
!= bp_exception_master
10193 breaks_to_delete
= 1;
10198 /* Ask user only if there are some breakpoints to delete. */
10200 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
10202 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
10204 if (b
->type
!= bp_call_dummy
10205 && b
->type
!= bp_std_terminate
10206 && b
->type
!= bp_shlib_event
10207 && b
->type
!= bp_thread_event
10208 && b
->type
!= bp_jit_event
10209 && b
->type
!= bp_overlay_event
10210 && b
->type
!= bp_longjmp_master
10211 && b
->type
!= bp_std_terminate_master
10212 && b
->type
!= bp_exception_master
10214 delete_breakpoint (b
);
10219 map_breakpoint_numbers (arg
, do_delete_breakpoint
, NULL
);
10223 all_locations_are_pending (struct bp_location
*loc
)
10225 for (; loc
; loc
= loc
->next
)
10226 if (!loc
->shlib_disabled
)
10231 /* Subroutine of update_breakpoint_locations to simplify it.
10232 Return non-zero if multiple fns in list LOC have the same name.
10233 Null names are ignored. */
10236 ambiguous_names_p (struct bp_location
*loc
)
10238 struct bp_location
*l
;
10239 htab_t htab
= htab_create_alloc (13, htab_hash_string
,
10240 (int (*) (const void *,
10241 const void *)) streq
,
10242 NULL
, xcalloc
, xfree
);
10244 for (l
= loc
; l
!= NULL
; l
= l
->next
)
10247 const char *name
= l
->function_name
;
10249 /* Allow for some names to be NULL, ignore them. */
10253 slot
= (const char **) htab_find_slot (htab
, (const void *) name
,
10255 /* NOTE: We can assume slot != NULL here because xcalloc never
10259 htab_delete (htab
);
10265 htab_delete (htab
);
10269 /* When symbols change, it probably means the sources changed as well,
10270 and it might mean the static tracepoint markers are no longer at
10271 the same address or line numbers they used to be at last we
10272 checked. Losing your static tracepoints whenever you rebuild is
10273 undesirable. This function tries to resync/rematch gdb static
10274 tracepoints with the markers on the target, for static tracepoints
10275 that have not been set by marker id. Static tracepoint that have
10276 been set by marker id are reset by marker id in breakpoint_re_set.
10279 1) For a tracepoint set at a specific address, look for a marker at
10280 the old PC. If one is found there, assume to be the same marker.
10281 If the name / string id of the marker found is different from the
10282 previous known name, assume that means the user renamed the marker
10283 in the sources, and output a warning.
10285 2) For a tracepoint set at a given line number, look for a marker
10286 at the new address of the old line number. If one is found there,
10287 assume to be the same marker. If the name / string id of the
10288 marker found is different from the previous known name, assume that
10289 means the user renamed the marker in the sources, and output a
10292 3) If a marker is no longer found at the same address or line, it
10293 may mean the marker no longer exists. But it may also just mean
10294 the code changed a bit. Maybe the user added a few lines of code
10295 that made the marker move up or down (in line number terms). Ask
10296 the target for info about the marker with the string id as we knew
10297 it. If found, update line number and address in the matching
10298 static tracepoint. This will get confused if there's more than one
10299 marker with the same ID (possible in UST, although unadvised
10300 precisely because it confuses tools). */
10302 static struct symtab_and_line
10303 update_static_tracepoint (struct breakpoint
*b
, struct symtab_and_line sal
)
10305 struct static_tracepoint_marker marker
;
10311 find_line_pc (sal
.symtab
, sal
.line
, &pc
);
10313 if (target_static_tracepoint_marker_at (pc
, &marker
))
10315 if (strcmp (b
->static_trace_marker_id
, marker
.str_id
) != 0)
10316 warning (_("static tracepoint %d changed probed marker from %s to %s"),
10318 b
->static_trace_marker_id
, marker
.str_id
);
10320 xfree (b
->static_trace_marker_id
);
10321 b
->static_trace_marker_id
= xstrdup (marker
.str_id
);
10322 release_static_tracepoint_marker (&marker
);
10327 /* Old marker wasn't found on target at lineno. Try looking it up
10329 if (!sal
.explicit_pc
10331 && sal
.symtab
!= NULL
10332 && b
->static_trace_marker_id
!= NULL
)
10334 VEC(static_tracepoint_marker_p
) *markers
;
10337 = target_static_tracepoint_markers_by_strid (b
->static_trace_marker_id
);
10339 if (!VEC_empty(static_tracepoint_marker_p
, markers
))
10341 struct symtab_and_line sal
;
10342 struct symbol
*sym
;
10343 struct static_tracepoint_marker
*marker
;
10345 marker
= VEC_index (static_tracepoint_marker_p
, markers
, 0);
10347 xfree (b
->static_trace_marker_id
);
10348 b
->static_trace_marker_id
= xstrdup (marker
->str_id
);
10350 warning (_("marker for static tracepoint %d (%s) not "
10351 "found at previous line number"),
10352 b
->number
, b
->static_trace_marker_id
);
10356 sal
.pc
= marker
->address
;
10358 sal
= find_pc_line (marker
->address
, 0);
10359 sym
= find_pc_sect_function (marker
->address
, NULL
);
10360 ui_out_text (uiout
, "Now in ");
10363 ui_out_field_string (uiout
, "func",
10364 SYMBOL_PRINT_NAME (sym
));
10365 ui_out_text (uiout
, " at ");
10367 ui_out_field_string (uiout
, "file", sal
.symtab
->filename
);
10368 ui_out_text (uiout
, ":");
10370 if (ui_out_is_mi_like_p (uiout
))
10372 char *fullname
= symtab_to_fullname (sal
.symtab
);
10375 ui_out_field_string (uiout
, "fullname", fullname
);
10378 ui_out_field_int (uiout
, "line", sal
.line
);
10379 ui_out_text (uiout
, "\n");
10381 b
->line_number
= sal
.line
;
10383 xfree (b
->source_file
);
10385 b
->source_file
= xstrdup (sal
.symtab
->filename
);
10387 b
->source_file
= NULL
;
10389 xfree (b
->addr_string
);
10390 b
->addr_string
= xstrprintf ("%s:%d",
10391 sal
.symtab
->filename
, b
->line_number
);
10393 /* Might be nice to check if function changed, and warn if
10396 release_static_tracepoint_marker (marker
);
10403 update_breakpoint_locations (struct breakpoint
*b
,
10404 struct symtabs_and_lines sals
)
10408 struct bp_location
*existing_locations
= b
->loc
;
10410 /* If there's no new locations, and all existing locations are
10411 pending, don't do anything. This optimizes the common case where
10412 all locations are in the same shared library, that was unloaded.
10413 We'd like to retain the location, so that when the library is
10414 loaded again, we don't loose the enabled/disabled status of the
10415 individual locations. */
10416 if (all_locations_are_pending (existing_locations
) && sals
.nelts
== 0)
10421 for (i
= 0; i
< sals
.nelts
; ++i
)
10423 struct bp_location
*new_loc
=
10424 add_location_to_breakpoint (b
, &(sals
.sals
[i
]));
10426 /* Reparse conditions, they might contain references to the
10428 if (b
->cond_string
!= NULL
)
10430 struct gdb_exception e
;
10432 s
= b
->cond_string
;
10433 TRY_CATCH (e
, RETURN_MASK_ERROR
)
10435 new_loc
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
),
10440 warning (_("failed to reevaluate condition "
10441 "for breakpoint %d: %s"),
10442 b
->number
, e
.message
);
10443 new_loc
->enabled
= 0;
10447 if (b
->source_file
!= NULL
)
10448 xfree (b
->source_file
);
10449 if (sals
.sals
[i
].symtab
== NULL
)
10450 b
->source_file
= NULL
;
10452 b
->source_file
= xstrdup (sals
.sals
[i
].symtab
->filename
);
10454 if (b
->line_number
== 0)
10455 b
->line_number
= sals
.sals
[i
].line
;
10458 /* Update locations of permanent breakpoints. */
10459 if (b
->enable_state
== bp_permanent
)
10460 make_breakpoint_permanent (b
);
10462 /* If possible, carry over 'disable' status from existing
10465 struct bp_location
*e
= existing_locations
;
10466 /* If there are multiple breakpoints with the same function name,
10467 e.g. for inline functions, comparing function names won't work.
10468 Instead compare pc addresses; this is just a heuristic as things
10469 may have moved, but in practice it gives the correct answer
10470 often enough until a better solution is found. */
10471 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
10473 for (; e
; e
= e
->next
)
10475 if (!e
->enabled
&& e
->function_name
)
10477 struct bp_location
*l
= b
->loc
;
10478 if (have_ambiguous_names
)
10480 for (; l
; l
= l
->next
)
10481 if (breakpoint_address_match (e
->pspace
->aspace
, e
->address
,
10482 l
->pspace
->aspace
, l
->address
))
10490 for (; l
; l
= l
->next
)
10491 if (l
->function_name
10492 && strcmp (e
->function_name
, l
->function_name
) == 0)
10502 update_global_location_list (1);
10505 /* Reset a breakpoint given it's struct breakpoint * BINT.
10506 The value we return ends up being the return value from catch_errors.
10507 Unused in this case. */
10510 breakpoint_re_set_one (void *bint
)
10512 /* Get past catch_errs. */
10513 struct breakpoint
*b
= (struct breakpoint
*) bint
;
10515 int *not_found_ptr
= ¬_found
;
10516 struct symtabs_and_lines sals
= {0};
10517 struct symtabs_and_lines expanded
= {0};
10519 struct gdb_exception e
;
10520 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
10521 int marker_spec
= 0;
10526 warning (_("attempted to reset apparently deleted breakpoint #%d?"),
10529 case bp_breakpoint
:
10530 case bp_hardware_breakpoint
:
10531 case bp_tracepoint
:
10532 case bp_fast_tracepoint
:
10533 case bp_static_tracepoint
:
10534 /* Do not attempt to re-set breakpoints disabled during startup. */
10535 if (b
->enable_state
== bp_startup_disabled
)
10538 if (b
->addr_string
== NULL
)
10540 /* Anything without a string can't be re-set. */
10541 delete_breakpoint (b
);
10545 input_radix
= b
->input_radix
;
10546 s
= b
->addr_string
;
10548 save_current_space_and_thread ();
10549 switch_to_program_space_and_thread (b
->pspace
);
10551 marker_spec
= b
->type
== bp_static_tracepoint
&& is_marker_spec (s
);
10553 set_language (b
->language
);
10554 TRY_CATCH (e
, RETURN_MASK_ERROR
)
10558 sals
= decode_static_tracepoint_spec (&s
);
10559 if (sals
.nelts
> b
->static_trace_marker_id_idx
)
10561 sals
.sals
[0] = sals
.sals
[b
->static_trace_marker_id_idx
];
10565 error (_("marker %s not found"), b
->static_trace_marker_id
);
10568 sals
= decode_line_1 (&s
, 1, (struct symtab
*) NULL
, 0,
10569 NULL
, not_found_ptr
);
10573 int not_found_and_ok
= 0;
10574 /* For pending breakpoints, it's expected that parsing will
10575 fail until the right shared library is loaded. User has
10576 already told to create pending breakpoints and don't need
10577 extra messages. If breakpoint is in bp_shlib_disabled
10578 state, then user already saw the message about that
10579 breakpoint being disabled, and don't want to see more
10582 && (b
->condition_not_parsed
10583 || (b
->loc
&& b
->loc
->shlib_disabled
)
10584 || b
->enable_state
== bp_disabled
))
10585 not_found_and_ok
= 1;
10587 if (!not_found_and_ok
)
10589 /* We surely don't want to warn about the same breakpoint
10590 10 times. One solution, implemented here, is disable
10591 the breakpoint on error. Another solution would be to
10592 have separate 'warning emitted' flag. Since this
10593 happens only when a binary has changed, I don't know
10594 which approach is better. */
10595 b
->enable_state
= bp_disabled
;
10596 throw_exception (e
);
10602 gdb_assert (sals
.nelts
== 1);
10604 resolve_sal_pc (&sals
.sals
[0]);
10605 if (b
->condition_not_parsed
&& s
&& s
[0])
10607 char *cond_string
= 0;
10611 find_condition_and_thread (s
, sals
.sals
[0].pc
,
10612 &cond_string
, &thread
, &task
);
10614 b
->cond_string
= cond_string
;
10615 b
->thread
= thread
;
10617 b
->condition_not_parsed
= 0;
10620 if (b
->type
== bp_static_tracepoint
&& !marker_spec
)
10621 sals
.sals
[0] = update_static_tracepoint (b
, sals
.sals
[0]);
10623 expanded
= expand_line_sal_maybe (sals
.sals
[0]);
10626 make_cleanup (xfree
, sals
.sals
);
10627 update_breakpoint_locations (b
, expanded
);
10630 case bp_watchpoint
:
10631 case bp_hardware_watchpoint
:
10632 case bp_read_watchpoint
:
10633 case bp_access_watchpoint
:
10634 /* Watchpoint can be either on expression using entirely global
10635 variables, or it can be on local variables.
10637 Watchpoints of the first kind are never auto-deleted, and
10638 even persist across program restarts. Since they can use
10639 variables from shared libraries, we need to reparse
10640 expression as libraries are loaded and unloaded.
10642 Watchpoints on local variables can also change meaning as
10643 result of solib event. For example, if a watchpoint uses
10644 both a local and a global variables in expression, it's a
10645 local watchpoint, but unloading of a shared library will make
10646 the expression invalid. This is not a very common use case,
10647 but we still re-evaluate expression, to avoid surprises to
10650 Note that for local watchpoints, we re-evaluate it only if
10651 watchpoints frame id is still valid. If it's not, it means
10652 the watchpoint is out of scope and will be deleted soon. In
10653 fact, I'm not sure we'll ever be called in this case.
10655 If a local watchpoint's frame id is still valid, then
10656 b->exp_valid_block is likewise valid, and we can safely use it.
10658 Don't do anything about disabled watchpoints, since they will
10659 be reevaluated again when enabled. */
10660 update_watchpoint (b
, 1 /* reparse */);
10662 /* We needn't really do anything to reset these, since the mask
10663 that requests them is unaffected by e.g., new libraries being
10665 case bp_catchpoint
:
10669 printf_filtered (_("Deleting unknown breakpoint type %d\n"), b
->type
);
10671 /* Delete overlay event and longjmp master breakpoints; they will be
10672 reset later by breakpoint_re_set. */
10673 case bp_overlay_event
:
10674 case bp_longjmp_master
:
10675 case bp_std_terminate_master
:
10676 case bp_exception_master
:
10677 delete_breakpoint (b
);
10680 /* This breakpoint is special, it's set up when the inferior
10681 starts and we really don't want to touch it. */
10682 case bp_shlib_event
:
10684 /* Like bp_shlib_event, this breakpoint type is special.
10685 Once it is set up, we do not want to touch it. */
10686 case bp_thread_event
:
10688 /* Keep temporary breakpoints, which can be encountered when we
10689 step over a dlopen call and SOLIB_ADD is resetting the
10690 breakpoints. Otherwise these should have been blown away via
10691 the cleanup chain or by breakpoint_init_inferior when we
10692 rerun the executable. */
10695 case bp_watchpoint_scope
:
10696 case bp_call_dummy
:
10697 case bp_std_terminate
:
10698 case bp_step_resume
:
10700 case bp_longjmp_resume
:
10702 case bp_exception_resume
:
10707 do_cleanups (cleanups
);
10711 /* Re-set all breakpoints after symbols have been re-loaded. */
10713 breakpoint_re_set (void)
10715 struct breakpoint
*b
, *b_tmp
;
10716 enum language save_language
;
10717 int save_input_radix
;
10718 struct cleanup
*old_chain
;
10720 save_language
= current_language
->la_language
;
10721 save_input_radix
= input_radix
;
10722 old_chain
= save_current_program_space ();
10724 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
10726 /* Format possible error msg. */
10727 char *message
= xstrprintf ("Error in re-setting breakpoint %d: ",
10729 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
10730 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
10731 do_cleanups (cleanups
);
10733 set_language (save_language
);
10734 input_radix
= save_input_radix
;
10736 jit_breakpoint_re_set ();
10738 do_cleanups (old_chain
);
10740 create_overlay_event_breakpoint ();
10741 create_longjmp_master_breakpoint ();
10742 create_std_terminate_master_breakpoint ();
10743 create_exception_master_breakpoint ();
10746 /* Reset the thread number of this breakpoint:
10748 - If the breakpoint is for all threads, leave it as-is.
10749 - Else, reset it to the current thread for inferior_ptid. */
10751 breakpoint_re_set_thread (struct breakpoint
*b
)
10753 if (b
->thread
!= -1)
10755 if (in_thread_list (inferior_ptid
))
10756 b
->thread
= pid_to_thread_id (inferior_ptid
);
10758 /* We're being called after following a fork. The new fork is
10759 selected as current, and unless this was a vfork will have a
10760 different program space from the original thread. Reset that
10762 b
->loc
->pspace
= current_program_space
;
10766 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
10767 If from_tty is nonzero, it prints a message to that effect,
10768 which ends with a period (no newline). */
10771 set_ignore_count (int bptnum
, int count
, int from_tty
)
10773 struct breakpoint
*b
;
10778 ALL_BREAKPOINTS (b
)
10779 if (b
->number
== bptnum
)
10781 if (is_tracepoint (b
))
10783 if (from_tty
&& count
!= 0)
10784 printf_filtered (_("Ignore count ignored for tracepoint %d."),
10789 b
->ignore_count
= count
;
10793 printf_filtered (_("Will stop next time "
10794 "breakpoint %d is reached."),
10796 else if (count
== 1)
10797 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
10800 printf_filtered (_("Will ignore next %d "
10801 "crossings of breakpoint %d."),
10804 breakpoints_changed ();
10805 observer_notify_breakpoint_modified (b
->number
);
10809 error (_("No breakpoint number %d."), bptnum
);
10812 /* Command to set ignore-count of breakpoint N to COUNT. */
10815 ignore_command (char *args
, int from_tty
)
10821 error_no_arg (_("a breakpoint number"));
10823 num
= get_number (&p
);
10825 error (_("bad breakpoint number: '%s'"), args
);
10827 error (_("Second argument (specified ignore-count) is missing."));
10829 set_ignore_count (num
,
10830 longest_to_int (value_as_long (parse_and_eval (p
))),
10833 printf_filtered ("\n");
10836 /* Call FUNCTION on each of the breakpoints
10837 whose numbers are given in ARGS. */
10840 map_breakpoint_numbers (char *args
, void (*function
) (struct breakpoint
*,
10845 struct breakpoint
*b
, *tmp
;
10847 struct get_number_or_range_state state
;
10850 error_no_arg (_("one or more breakpoint numbers"));
10852 init_number_or_range (&state
, args
);
10854 while (!state
.finished
)
10856 char *p
= state
.string
;
10860 num
= get_number_or_range (&state
);
10863 warning (_("bad breakpoint number at or near '%s'"), p
);
10867 ALL_BREAKPOINTS_SAFE (b
, tmp
)
10868 if (b
->number
== num
)
10870 struct breakpoint
*related_breakpoint
;
10873 related_breakpoint
= b
;
10876 struct breakpoint
*next_related_b
;
10878 /* FUNCTION can be also delete_breakpoint. */
10879 next_related_b
= related_breakpoint
->related_breakpoint
;
10880 function (related_breakpoint
, data
);
10882 /* For delete_breakpoint of the last entry of the ring we
10883 were traversing we would never get back to B. */
10884 if (next_related_b
== related_breakpoint
)
10886 related_breakpoint
= next_related_b
;
10888 while (related_breakpoint
!= b
);
10892 printf_unfiltered (_("No breakpoint number %d.\n"), num
);
10897 static struct bp_location
*
10898 find_location_by_number (char *number
)
10900 char *dot
= strchr (number
, '.');
10904 struct breakpoint
*b
;
10905 struct bp_location
*loc
;
10910 bp_num
= get_number (&p1
);
10912 error (_("Bad breakpoint number '%s'"), number
);
10914 ALL_BREAKPOINTS (b
)
10915 if (b
->number
== bp_num
)
10920 if (!b
|| b
->number
!= bp_num
)
10921 error (_("Bad breakpoint number '%s'"), number
);
10924 loc_num
= get_number (&p1
);
10926 error (_("Bad breakpoint location number '%s'"), number
);
10930 for (;loc_num
&& loc
; --loc_num
, loc
= loc
->next
)
10933 error (_("Bad breakpoint location number '%s'"), dot
+1);
10939 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
10940 If from_tty is nonzero, it prints a message to that effect,
10941 which ends with a period (no newline). */
10944 disable_breakpoint (struct breakpoint
*bpt
)
10946 /* Never disable a watchpoint scope breakpoint; we want to
10947 hit them when we leave scope so we can delete both the
10948 watchpoint and its scope breakpoint at that time. */
10949 if (bpt
->type
== bp_watchpoint_scope
)
10952 /* You can't disable permanent breakpoints. */
10953 if (bpt
->enable_state
== bp_permanent
)
10956 bpt
->enable_state
= bp_disabled
;
10958 update_global_location_list (0);
10960 observer_notify_breakpoint_modified (bpt
->number
);
10963 /* A callback for map_breakpoint_numbers that calls
10964 disable_breakpoint. */
10967 do_map_disable_breakpoint (struct breakpoint
*b
, void *ignore
)
10969 disable_breakpoint (b
);
10973 disable_command (char *args
, int from_tty
)
10975 struct breakpoint
*bpt
;
10978 ALL_BREAKPOINTS (bpt
)
10982 warning (_("attempted to disable apparently deleted breakpoint #%d?"),
10985 case bp_breakpoint
:
10986 case bp_tracepoint
:
10987 case bp_fast_tracepoint
:
10988 case bp_static_tracepoint
:
10989 case bp_catchpoint
:
10990 case bp_hardware_breakpoint
:
10991 case bp_watchpoint
:
10992 case bp_hardware_watchpoint
:
10993 case bp_read_watchpoint
:
10994 case bp_access_watchpoint
:
10995 disable_breakpoint (bpt
);
11000 else if (strchr (args
, '.'))
11002 struct bp_location
*loc
= find_location_by_number (args
);
11005 update_global_location_list (0);
11008 map_breakpoint_numbers (args
, do_map_disable_breakpoint
, NULL
);
11012 do_enable_breakpoint (struct breakpoint
*bpt
, enum bpdisp disposition
)
11014 int target_resources_ok
;
11016 if (bpt
->type
== bp_hardware_breakpoint
)
11019 i
= hw_breakpoint_used_count ();
11020 target_resources_ok
=
11021 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
11023 if (target_resources_ok
== 0)
11024 error (_("No hardware breakpoint support in the target."));
11025 else if (target_resources_ok
< 0)
11026 error (_("Hardware breakpoints used exceeds limit."));
11029 if (is_watchpoint (bpt
))
11031 struct gdb_exception e
;
11033 TRY_CATCH (e
, RETURN_MASK_ALL
)
11035 update_watchpoint (bpt
, 1 /* reparse */);
11039 exception_fprintf (gdb_stderr
, e
, _("Cannot enable watchpoint %d: "),
11045 if (bpt
->enable_state
!= bp_permanent
)
11046 bpt
->enable_state
= bp_enabled
;
11047 bpt
->disposition
= disposition
;
11048 update_global_location_list (1);
11049 breakpoints_changed ();
11051 observer_notify_breakpoint_modified (bpt
->number
);
11056 enable_breakpoint (struct breakpoint
*bpt
)
11058 do_enable_breakpoint (bpt
, bpt
->disposition
);
11061 /* A callback for map_breakpoint_numbers that calls
11062 enable_breakpoint. */
11065 do_map_enable_breakpoint (struct breakpoint
*b
, void *ignore
)
11067 enable_breakpoint (b
);
11070 /* The enable command enables the specified breakpoints (or all defined
11071 breakpoints) so they once again become (or continue to be) effective
11072 in stopping the inferior. */
11075 enable_command (char *args
, int from_tty
)
11077 struct breakpoint
*bpt
;
11080 ALL_BREAKPOINTS (bpt
)
11084 warning (_("attempted to enable apparently deleted breakpoint #%d?"),
11087 case bp_breakpoint
:
11088 case bp_tracepoint
:
11089 case bp_fast_tracepoint
:
11090 case bp_static_tracepoint
:
11091 case bp_catchpoint
:
11092 case bp_hardware_breakpoint
:
11093 case bp_watchpoint
:
11094 case bp_hardware_watchpoint
:
11095 case bp_read_watchpoint
:
11096 case bp_access_watchpoint
:
11097 enable_breakpoint (bpt
);
11102 else if (strchr (args
, '.'))
11104 struct bp_location
*loc
= find_location_by_number (args
);
11107 update_global_location_list (1);
11110 map_breakpoint_numbers (args
, do_map_enable_breakpoint
, NULL
);
11114 enable_once_breakpoint (struct breakpoint
*bpt
, void *ignore
)
11116 do_enable_breakpoint (bpt
, disp_disable
);
11120 enable_once_command (char *args
, int from_tty
)
11122 map_breakpoint_numbers (args
, enable_once_breakpoint
, NULL
);
11126 enable_delete_breakpoint (struct breakpoint
*bpt
, void *ignore
)
11128 do_enable_breakpoint (bpt
, disp_del
);
11132 enable_delete_command (char *args
, int from_tty
)
11134 map_breakpoint_numbers (args
, enable_delete_breakpoint
, NULL
);
11138 set_breakpoint_cmd (char *args
, int from_tty
)
11143 show_breakpoint_cmd (char *args
, int from_tty
)
11147 /* Invalidate last known value of any hardware watchpoint if
11148 the memory which that value represents has been written to by
11152 invalidate_bp_value_on_memory_change (CORE_ADDR addr
, int len
,
11153 const bfd_byte
*data
)
11155 struct breakpoint
*bp
;
11157 ALL_BREAKPOINTS (bp
)
11158 if (bp
->enable_state
== bp_enabled
11159 && bp
->type
== bp_hardware_watchpoint
11160 && bp
->val_valid
&& bp
->val
)
11162 struct bp_location
*loc
;
11164 for (loc
= bp
->loc
; loc
!= NULL
; loc
= loc
->next
)
11165 if (loc
->loc_type
== bp_loc_hardware_watchpoint
11166 && loc
->address
+ loc
->length
> addr
11167 && addr
+ len
> loc
->address
)
11169 value_free (bp
->val
);
11176 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
11178 struct symtabs_and_lines
11179 decode_line_spec_1 (char *string
, int funfirstline
)
11181 struct symtabs_and_lines sals
;
11184 error (_("Empty line specification."));
11185 if (default_breakpoint_valid
)
11186 sals
= decode_line_1 (&string
, funfirstline
,
11187 default_breakpoint_symtab
,
11188 default_breakpoint_line
,
11191 sals
= decode_line_1 (&string
, funfirstline
,
11192 (struct symtab
*) NULL
, 0, NULL
, NULL
);
11194 error (_("Junk at end of line specification: %s"), string
);
11198 /* Create and insert a raw software breakpoint at PC. Return an
11199 identifier, which should be used to remove the breakpoint later.
11200 In general, places which call this should be using something on the
11201 breakpoint chain instead; this function should be eliminated
11205 deprecated_insert_raw_breakpoint (struct gdbarch
*gdbarch
,
11206 struct address_space
*aspace
, CORE_ADDR pc
)
11208 struct bp_target_info
*bp_tgt
;
11210 bp_tgt
= XZALLOC (struct bp_target_info
);
11212 bp_tgt
->placed_address_space
= aspace
;
11213 bp_tgt
->placed_address
= pc
;
11215 if (target_insert_breakpoint (gdbarch
, bp_tgt
) != 0)
11217 /* Could not insert the breakpoint. */
11225 /* Remove a breakpoint BP inserted by
11226 deprecated_insert_raw_breakpoint. */
11229 deprecated_remove_raw_breakpoint (struct gdbarch
*gdbarch
, void *bp
)
11231 struct bp_target_info
*bp_tgt
= bp
;
11234 ret
= target_remove_breakpoint (gdbarch
, bp_tgt
);
11240 /* One (or perhaps two) breakpoints used for software single
11243 static void *single_step_breakpoints
[2];
11244 static struct gdbarch
*single_step_gdbarch
[2];
11246 /* Create and insert a breakpoint for software single step. */
11249 insert_single_step_breakpoint (struct gdbarch
*gdbarch
,
11250 struct address_space
*aspace
,
11255 if (single_step_breakpoints
[0] == NULL
)
11257 bpt_p
= &single_step_breakpoints
[0];
11258 single_step_gdbarch
[0] = gdbarch
;
11262 gdb_assert (single_step_breakpoints
[1] == NULL
);
11263 bpt_p
= &single_step_breakpoints
[1];
11264 single_step_gdbarch
[1] = gdbarch
;
11267 /* NOTE drow/2006-04-11: A future improvement to this function would
11268 be to only create the breakpoints once, and actually put them on
11269 the breakpoint chain. That would let us use set_raw_breakpoint.
11270 We could adjust the addresses each time they were needed. Doing
11271 this requires corresponding changes elsewhere where single step
11272 breakpoints are handled, however. So, for now, we use this. */
11274 *bpt_p
= deprecated_insert_raw_breakpoint (gdbarch
, aspace
, next_pc
);
11275 if (*bpt_p
== NULL
)
11276 error (_("Could not insert single-step breakpoint at %s"),
11277 paddress (gdbarch
, next_pc
));
11280 /* Check if the breakpoints used for software single stepping
11281 were inserted or not. */
11284 single_step_breakpoints_inserted (void)
11286 return (single_step_breakpoints
[0] != NULL
11287 || single_step_breakpoints
[1] != NULL
);
11290 /* Remove and delete any breakpoints used for software single step. */
11293 remove_single_step_breakpoints (void)
11295 gdb_assert (single_step_breakpoints
[0] != NULL
);
11297 /* See insert_single_step_breakpoint for more about this deprecated
11299 deprecated_remove_raw_breakpoint (single_step_gdbarch
[0],
11300 single_step_breakpoints
[0]);
11301 single_step_gdbarch
[0] = NULL
;
11302 single_step_breakpoints
[0] = NULL
;
11304 if (single_step_breakpoints
[1] != NULL
)
11306 deprecated_remove_raw_breakpoint (single_step_gdbarch
[1],
11307 single_step_breakpoints
[1]);
11308 single_step_gdbarch
[1] = NULL
;
11309 single_step_breakpoints
[1] = NULL
;
11313 /* Delete software single step breakpoints without removing them from
11314 the inferior. This is intended to be used if the inferior's address
11315 space where they were inserted is already gone, e.g. after exit or
11319 cancel_single_step_breakpoints (void)
11323 for (i
= 0; i
< 2; i
++)
11324 if (single_step_breakpoints
[i
])
11326 xfree (single_step_breakpoints
[i
]);
11327 single_step_breakpoints
[i
] = NULL
;
11328 single_step_gdbarch
[i
] = NULL
;
11332 /* Detach software single-step breakpoints from INFERIOR_PTID without
11336 detach_single_step_breakpoints (void)
11340 for (i
= 0; i
< 2; i
++)
11341 if (single_step_breakpoints
[i
])
11342 target_remove_breakpoint (single_step_gdbarch
[i
],
11343 single_step_breakpoints
[i
]);
11346 /* Check whether a software single-step breakpoint is inserted at
11350 single_step_breakpoint_inserted_here_p (struct address_space
*aspace
,
11355 for (i
= 0; i
< 2; i
++)
11357 struct bp_target_info
*bp_tgt
= single_step_breakpoints
[i
];
11359 && breakpoint_address_match (bp_tgt
->placed_address_space
,
11360 bp_tgt
->placed_address
,
11368 /* Returns 0 if 'bp' is NOT a syscall catchpoint,
11369 non-zero otherwise. */
11371 is_syscall_catchpoint_enabled (struct breakpoint
*bp
)
11373 if (syscall_catchpoint_p (bp
)
11374 && bp
->enable_state
!= bp_disabled
11375 && bp
->enable_state
!= bp_call_disabled
)
11382 catch_syscall_enabled (void)
11384 struct inferior
*inf
= current_inferior ();
11386 return inf
->total_syscalls_count
!= 0;
11390 catching_syscall_number (int syscall_number
)
11392 struct breakpoint
*bp
;
11394 ALL_BREAKPOINTS (bp
)
11395 if (is_syscall_catchpoint_enabled (bp
))
11397 if (bp
->syscalls_to_be_caught
)
11401 VEC_iterate (int, bp
->syscalls_to_be_caught
, i
, iter
);
11403 if (syscall_number
== iter
)
11413 /* Complete syscall names. Used by "catch syscall". */
11415 catch_syscall_completer (struct cmd_list_element
*cmd
,
11416 char *text
, char *word
)
11418 const char **list
= get_syscall_names ();
11420 = (list
== NULL
) ? NULL
: complete_on_enum (list
, text
, word
);
11426 /* Tracepoint-specific operations. */
11428 /* Set tracepoint count to NUM. */
11430 set_tracepoint_count (int num
)
11432 tracepoint_count
= num
;
11433 set_internalvar_integer (lookup_internalvar ("tpnum"), num
);
11437 trace_command (char *arg
, int from_tty
)
11439 if (create_breakpoint (get_current_arch (),
11441 NULL
, 0, 1 /* parse arg */,
11443 bp_tracepoint
/* type_wanted */,
11444 0 /* Ignore count */,
11445 pending_break_support
,
11450 set_tracepoint_count (breakpoint_count
);
11454 ftrace_command (char *arg
, int from_tty
)
11456 if (create_breakpoint (get_current_arch (),
11458 NULL
, 0, 1 /* parse arg */,
11460 bp_fast_tracepoint
/* type_wanted */,
11461 0 /* Ignore count */,
11462 pending_break_support
,
11467 set_tracepoint_count (breakpoint_count
);
11470 /* strace command implementation. Creates a static tracepoint. */
11473 strace_command (char *arg
, int from_tty
)
11475 if (create_breakpoint (get_current_arch (),
11477 NULL
, 0, 1 /* parse arg */,
11479 bp_static_tracepoint
/* type_wanted */,
11480 0 /* Ignore count */,
11481 pending_break_support
,
11486 set_tracepoint_count (breakpoint_count
);
11489 /* Set up a fake reader function that gets command lines from a linked
11490 list that was acquired during tracepoint uploading. */
11492 static struct uploaded_tp
*this_utp
;
11493 static int next_cmd
;
11496 read_uploaded_action (void)
11500 VEC_iterate (char_ptr
, this_utp
->cmd_strings
, next_cmd
, rslt
);
11507 /* Given information about a tracepoint as recorded on a target (which
11508 can be either a live system or a trace file), attempt to create an
11509 equivalent GDB tracepoint. This is not a reliable process, since
11510 the target does not necessarily have all the information used when
11511 the tracepoint was originally defined. */
11513 struct breakpoint
*
11514 create_tracepoint_from_upload (struct uploaded_tp
*utp
)
11516 char *addr_str
, small_buf
[100];
11517 struct breakpoint
*tp
;
11519 if (utp
->at_string
)
11520 addr_str
= utp
->at_string
;
11523 /* In the absence of a source location, fall back to raw
11524 address. Since there is no way to confirm that the address
11525 means the same thing as when the trace was started, warn the
11527 warning (_("Uploaded tracepoint %d has no "
11528 "source location, using raw address"),
11530 sprintf (small_buf
, "*%s", hex_string (utp
->addr
));
11531 addr_str
= small_buf
;
11534 /* There's not much we can do with a sequence of bytecodes. */
11535 if (utp
->cond
&& !utp
->cond_string
)
11536 warning (_("Uploaded tracepoint %d condition "
11537 "has no source form, ignoring it"),
11540 if (!create_breakpoint (get_current_arch (),
11542 utp
->cond_string
, -1, 0 /* parse cond/thread */,
11544 utp
->type
/* type_wanted */,
11545 0 /* Ignore count */,
11546 pending_break_support
,
11549 utp
->enabled
/* enabled */,
11553 set_tracepoint_count (breakpoint_count
);
11555 /* Get the tracepoint we just created. */
11556 tp
= get_tracepoint (tracepoint_count
);
11557 gdb_assert (tp
!= NULL
);
11561 sprintf (small_buf
, "%d %d", utp
->pass
, tp
->number
);
11563 trace_pass_command (small_buf
, 0);
11566 /* If we have uploaded versions of the original commands, set up a
11567 special-purpose "reader" function and call the usual command line
11568 reader, then pass the result to the breakpoint command-setting
11570 if (!VEC_empty (char_ptr
, utp
->cmd_strings
))
11572 struct command_line
*cmd_list
;
11577 cmd_list
= read_command_lines_1 (read_uploaded_action
, 1, NULL
, NULL
);
11579 breakpoint_set_commands (tp
, cmd_list
);
11581 else if (!VEC_empty (char_ptr
, utp
->actions
)
11582 || !VEC_empty (char_ptr
, utp
->step_actions
))
11583 warning (_("Uploaded tracepoint %d actions "
11584 "have no source form, ignoring them"),
11590 /* Print information on tracepoint number TPNUM_EXP, or all if
11594 tracepoints_info (char *args
, int from_tty
)
11598 num_printed
= breakpoint_1 (args
, 0, is_tracepoint
);
11600 if (num_printed
== 0)
11602 if (args
== NULL
|| *args
== '\0')
11603 ui_out_message (uiout
, 0, "No tracepoints.\n");
11605 ui_out_message (uiout
, 0, "No tracepoint matching '%s'.\n", args
);
11608 default_collect_info ();
11611 /* The 'enable trace' command enables tracepoints.
11612 Not supported by all targets. */
11614 enable_trace_command (char *args
, int from_tty
)
11616 enable_command (args
, from_tty
);
11619 /* The 'disable trace' command disables tracepoints.
11620 Not supported by all targets. */
11622 disable_trace_command (char *args
, int from_tty
)
11624 disable_command (args
, from_tty
);
11627 /* Remove a tracepoint (or all if no argument). */
11629 delete_trace_command (char *arg
, int from_tty
)
11631 struct breakpoint
*b
, *b_tmp
;
11637 int breaks_to_delete
= 0;
11639 /* Delete all breakpoints if no argument.
11640 Do not delete internal or call-dummy breakpoints, these
11641 have to be deleted with an explicit breakpoint number
11643 ALL_TRACEPOINTS (b
)
11645 if (b
->number
>= 0)
11647 breaks_to_delete
= 1;
11652 /* Ask user only if there are some breakpoints to delete. */
11654 || (breaks_to_delete
&& query (_("Delete all tracepoints? "))))
11656 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
11658 if (is_tracepoint (b
)
11660 delete_breakpoint (b
);
11665 map_breakpoint_numbers (arg
, do_delete_breakpoint
, NULL
);
11668 /* Helper function for trace_pass_command. */
11671 trace_pass_set_count (struct breakpoint
*bp
, int count
, int from_tty
)
11673 bp
->pass_count
= count
;
11674 observer_notify_tracepoint_modified (bp
->number
);
11676 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
11677 bp
->number
, count
);
11680 /* Set passcount for tracepoint.
11682 First command argument is passcount, second is tracepoint number.
11683 If tracepoint number omitted, apply to most recently defined.
11684 Also accepts special argument "all". */
11687 trace_pass_command (char *args
, int from_tty
)
11689 struct breakpoint
*t1
;
11690 unsigned int count
;
11692 if (args
== 0 || *args
== 0)
11693 error (_("passcount command requires an "
11694 "argument (count + optional TP num)"));
11696 count
= strtoul (args
, &args
, 10); /* Count comes first, then TP num. */
11698 while (*args
&& isspace ((int) *args
))
11701 if (*args
&& strncasecmp (args
, "all", 3) == 0)
11703 args
+= 3; /* Skip special argument "all". */
11705 error (_("Junk at end of arguments."));
11707 ALL_TRACEPOINTS (t1
)
11709 trace_pass_set_count (t1
, count
, from_tty
);
11712 else if (*args
== '\0')
11714 t1
= get_tracepoint_by_number (&args
, NULL
, 1);
11716 trace_pass_set_count (t1
, count
, from_tty
);
11720 struct get_number_or_range_state state
;
11722 init_number_or_range (&state
, args
);
11723 while (!state
.finished
)
11725 t1
= get_tracepoint_by_number (&args
, &state
, 1);
11727 trace_pass_set_count (t1
, count
, from_tty
);
11732 struct breakpoint
*
11733 get_tracepoint (int num
)
11735 struct breakpoint
*t
;
11737 ALL_TRACEPOINTS (t
)
11738 if (t
->number
== num
)
11744 /* Find the tracepoint with the given target-side number (which may be
11745 different from the tracepoint number after disconnecting and
11748 struct breakpoint
*
11749 get_tracepoint_by_number_on_target (int num
)
11751 struct breakpoint
*t
;
11753 ALL_TRACEPOINTS (t
)
11754 if (t
->number_on_target
== num
)
11760 /* Utility: parse a tracepoint number and look it up in the list.
11761 If STATE is not NULL, use, get_number_or_range_state and ignore ARG.
11762 If OPTIONAL_P is true, then if the argument is missing, the most
11763 recent tracepoint (tracepoint_count) is returned. */
11764 struct breakpoint
*
11765 get_tracepoint_by_number (char **arg
,
11766 struct get_number_or_range_state
*state
,
11769 extern int tracepoint_count
;
11770 struct breakpoint
*t
;
11772 char *instring
= arg
== NULL
? NULL
: *arg
;
11776 gdb_assert (!state
->finished
);
11777 tpnum
= get_number_or_range (state
);
11779 else if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
11782 tpnum
= tracepoint_count
;
11784 error_no_arg (_("tracepoint number"));
11787 tpnum
= get_number (arg
);
11791 if (instring
&& *instring
)
11792 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
11795 printf_filtered (_("Tracepoint argument missing "
11796 "and no previous tracepoint\n"));
11800 ALL_TRACEPOINTS (t
)
11801 if (t
->number
== tpnum
)
11806 printf_unfiltered ("No tracepoint number %d.\n", tpnum
);
11810 /* Save information on user settable breakpoints (watchpoints, etc) to
11811 a new script file named FILENAME. If FILTER is non-NULL, call it
11812 on each breakpoint and only include the ones for which it returns
11816 save_breakpoints (char *filename
, int from_tty
,
11817 int (*filter
) (const struct breakpoint
*))
11819 struct breakpoint
*tp
;
11822 struct cleanup
*cleanup
;
11823 struct ui_file
*fp
;
11824 int extra_trace_bits
= 0;
11826 if (filename
== 0 || *filename
== 0)
11827 error (_("Argument required (file name in which to save)"));
11829 /* See if we have anything to save. */
11830 ALL_BREAKPOINTS (tp
)
11832 /* Skip internal and momentary breakpoints. */
11833 if (!user_breakpoint_p (tp
))
11836 /* If we have a filter, only save the breakpoints it accepts. */
11837 if (filter
&& !filter (tp
))
11842 if (is_tracepoint (tp
))
11844 extra_trace_bits
= 1;
11846 /* We can stop searching. */
11853 warning (_("Nothing to save."));
11857 pathname
= tilde_expand (filename
);
11858 cleanup
= make_cleanup (xfree
, pathname
);
11859 fp
= gdb_fopen (pathname
, "w");
11861 error (_("Unable to open file '%s' for saving (%s)"),
11862 filename
, safe_strerror (errno
));
11863 make_cleanup_ui_file_delete (fp
);
11865 if (extra_trace_bits
)
11866 save_trace_state_variables (fp
);
11868 ALL_BREAKPOINTS (tp
)
11870 /* Skip internal and momentary breakpoints. */
11871 if (!user_breakpoint_p (tp
))
11874 /* If we have a filter, only save the breakpoints it accepts. */
11875 if (filter
&& !filter (tp
))
11878 if (tp
->ops
!= NULL
)
11879 (tp
->ops
->print_recreate
) (tp
, fp
);
11882 if (tp
->type
== bp_fast_tracepoint
)
11883 fprintf_unfiltered (fp
, "ftrace");
11884 if (tp
->type
== bp_static_tracepoint
)
11885 fprintf_unfiltered (fp
, "strace");
11886 else if (tp
->type
== bp_tracepoint
)
11887 fprintf_unfiltered (fp
, "trace");
11888 else if (tp
->type
== bp_breakpoint
&& tp
->disposition
== disp_del
)
11889 fprintf_unfiltered (fp
, "tbreak");
11890 else if (tp
->type
== bp_breakpoint
)
11891 fprintf_unfiltered (fp
, "break");
11892 else if (tp
->type
== bp_hardware_breakpoint
11893 && tp
->disposition
== disp_del
)
11894 fprintf_unfiltered (fp
, "thbreak");
11895 else if (tp
->type
== bp_hardware_breakpoint
)
11896 fprintf_unfiltered (fp
, "hbreak");
11897 else if (tp
->type
== bp_watchpoint
)
11898 fprintf_unfiltered (fp
, "watch");
11899 else if (tp
->type
== bp_hardware_watchpoint
)
11900 fprintf_unfiltered (fp
, "watch");
11901 else if (tp
->type
== bp_read_watchpoint
)
11902 fprintf_unfiltered (fp
, "rwatch");
11903 else if (tp
->type
== bp_access_watchpoint
)
11904 fprintf_unfiltered (fp
, "awatch");
11906 internal_error (__FILE__
, __LINE__
,
11907 _("unhandled breakpoint type %d"), (int) tp
->type
);
11909 if (tp
->exp_string
)
11910 fprintf_unfiltered (fp
, " %s", tp
->exp_string
);
11911 else if (tp
->addr_string
)
11912 fprintf_unfiltered (fp
, " %s", tp
->addr_string
);
11917 sprintf_vma (tmp
, tp
->loc
->address
);
11918 fprintf_unfiltered (fp
, " *0x%s", tmp
);
11922 if (tp
->thread
!= -1)
11923 fprintf_unfiltered (fp
, " thread %d", tp
->thread
);
11926 fprintf_unfiltered (fp
, " task %d", tp
->task
);
11928 fprintf_unfiltered (fp
, "\n");
11930 /* Note, we can't rely on tp->number for anything, as we can't
11931 assume the recreated breakpoint numbers will match. Use $bpnum
11934 if (tp
->cond_string
)
11935 fprintf_unfiltered (fp
, " condition $bpnum %s\n", tp
->cond_string
);
11937 if (tp
->ignore_count
)
11938 fprintf_unfiltered (fp
, " ignore $bpnum %d\n", tp
->ignore_count
);
11940 if (tp
->pass_count
)
11941 fprintf_unfiltered (fp
, " passcount %d\n", tp
->pass_count
);
11945 volatile struct gdb_exception ex
;
11947 fprintf_unfiltered (fp
, " commands\n");
11949 ui_out_redirect (uiout
, fp
);
11950 TRY_CATCH (ex
, RETURN_MASK_ALL
)
11952 print_command_lines (uiout
, tp
->commands
->commands
, 2);
11954 ui_out_redirect (uiout
, NULL
);
11957 throw_exception (ex
);
11959 fprintf_unfiltered (fp
, " end\n");
11962 if (tp
->enable_state
== bp_disabled
)
11963 fprintf_unfiltered (fp
, "disable\n");
11965 /* If this is a multi-location breakpoint, check if the locations
11966 should be individually disabled. Watchpoint locations are
11967 special, and not user visible. */
11968 if (!is_watchpoint (tp
) && tp
->loc
&& tp
->loc
->next
)
11970 struct bp_location
*loc
;
11973 for (loc
= tp
->loc
; loc
!= NULL
; loc
= loc
->next
, n
++)
11975 fprintf_unfiltered (fp
, "disable $bpnum.%d\n", n
);
11979 if (extra_trace_bits
&& *default_collect
)
11980 fprintf_unfiltered (fp
, "set default-collect %s\n", default_collect
);
11982 do_cleanups (cleanup
);
11984 printf_filtered (_("Saved to file '%s'.\n"), filename
);
11987 /* The `save breakpoints' command. */
11990 save_breakpoints_command (char *args
, int from_tty
)
11992 save_breakpoints (args
, from_tty
, NULL
);
11995 /* The `save tracepoints' command. */
11998 save_tracepoints_command (char *args
, int from_tty
)
12000 save_breakpoints (args
, from_tty
, is_tracepoint
);
12003 /* Create a vector of all tracepoints. */
12005 VEC(breakpoint_p
) *
12006 all_tracepoints (void)
12008 VEC(breakpoint_p
) *tp_vec
= 0;
12009 struct breakpoint
*tp
;
12011 ALL_TRACEPOINTS (tp
)
12013 VEC_safe_push (breakpoint_p
, tp_vec
, tp
);
12020 /* This help string is used for the break, hbreak, tbreak and thbreak
12021 commands. It is defined as a macro to prevent duplication.
12022 COMMAND should be a string constant containing the name of the
12024 #define BREAK_ARGS_HELP(command) \
12025 command" [LOCATION] [thread THREADNUM] [if CONDITION]\n\
12026 LOCATION may be a line number, function name, or \"*\" and an address.\n\
12027 If a line number is specified, break at start of code for that line.\n\
12028 If a function is specified, break at start of code for that function.\n\
12029 If an address is specified, break at that exact address.\n\
12030 With no LOCATION, uses current execution address of the selected\n\
12031 stack frame. This is useful for breaking on return to a stack frame.\n\
12033 THREADNUM is the number from \"info threads\".\n\
12034 CONDITION is a boolean expression.\n\
12036 Multiple breakpoints at one place are permitted, and useful if their\n\
12037 conditions are different.\n\
12039 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
12041 /* List of subcommands for "catch". */
12042 static struct cmd_list_element
*catch_cmdlist
;
12044 /* List of subcommands for "tcatch". */
12045 static struct cmd_list_element
*tcatch_cmdlist
;
12047 /* Like add_cmd, but add the command to both the "catch" and "tcatch"
12048 lists, and pass some additional user data to the command function. */
12050 add_catch_command (char *name
, char *docstring
,
12051 void (*sfunc
) (char *args
, int from_tty
,
12052 struct cmd_list_element
*command
),
12053 char **(*completer
) (struct cmd_list_element
*cmd
,
12054 char *text
, char *word
),
12055 void *user_data_catch
,
12056 void *user_data_tcatch
)
12058 struct cmd_list_element
*command
;
12060 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
12062 set_cmd_sfunc (command
, sfunc
);
12063 set_cmd_context (command
, user_data_catch
);
12064 set_cmd_completer (command
, completer
);
12066 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
12068 set_cmd_sfunc (command
, sfunc
);
12069 set_cmd_context (command
, user_data_tcatch
);
12070 set_cmd_completer (command
, completer
);
12074 clear_syscall_counts (struct inferior
*inf
)
12076 inf
->total_syscalls_count
= 0;
12077 inf
->any_syscall_count
= 0;
12078 VEC_free (int, inf
->syscalls_counts
);
12082 save_command (char *arg
, int from_tty
)
12084 printf_unfiltered (_("\"save\" must be followed by "
12085 "the name of a save subcommand.\n"));
12086 help_list (save_cmdlist
, "save ", -1, gdb_stdout
);
12089 struct breakpoint
*
12090 iterate_over_breakpoints (int (*callback
) (struct breakpoint
*, void *),
12093 struct breakpoint
*b
, *b_tmp
;
12095 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
12097 if ((*callback
) (b
, data
))
12105 _initialize_breakpoint (void)
12107 struct cmd_list_element
*c
;
12109 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
12110 observer_attach_inferior_exit (clear_syscall_counts
);
12111 observer_attach_memory_changed (invalidate_bp_value_on_memory_change
);
12113 breakpoint_objfile_key
= register_objfile_data ();
12115 breakpoint_chain
= 0;
12116 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
12117 before a breakpoint is set. */
12118 breakpoint_count
= 0;
12120 tracepoint_count
= 0;
12122 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
12123 Set ignore-count of breakpoint number N to COUNT.\n\
12124 Usage is `ignore N COUNT'."));
12126 add_com_alias ("bc", "ignore", class_breakpoint
, 1);
12128 add_com ("commands", class_breakpoint
, commands_command
, _("\
12129 Set commands to be executed when a breakpoint is hit.\n\
12130 Give breakpoint number as argument after \"commands\".\n\
12131 With no argument, the targeted breakpoint is the last one set.\n\
12132 The commands themselves follow starting on the next line.\n\
12133 Type a line containing \"end\" to indicate the end of them.\n\
12134 Give \"silent\" as the first line to make the breakpoint silent;\n\
12135 then no output is printed when it is hit, except what the commands print."));
12137 add_com ("condition", class_breakpoint
, condition_command
, _("\
12138 Specify breakpoint number N to break only if COND is true.\n\
12139 Usage is `condition N COND', where N is an integer and COND is an\n\
12140 expression to be evaluated whenever breakpoint N is reached."));
12142 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
12143 Set a temporary breakpoint.\n\
12144 Like \"break\" except the breakpoint is only temporary,\n\
12145 so it will be deleted when hit. Equivalent to \"break\" followed\n\
12146 by using \"enable delete\" on the breakpoint number.\n\
12148 BREAK_ARGS_HELP ("tbreak")));
12149 set_cmd_completer (c
, location_completer
);
12151 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
12152 Set a hardware assisted breakpoint.\n\
12153 Like \"break\" except the breakpoint requires hardware support,\n\
12154 some target hardware may not have this support.\n\
12156 BREAK_ARGS_HELP ("hbreak")));
12157 set_cmd_completer (c
, location_completer
);
12159 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
12160 Set a temporary hardware assisted breakpoint.\n\
12161 Like \"hbreak\" except the breakpoint is only temporary,\n\
12162 so it will be deleted when hit.\n\
12164 BREAK_ARGS_HELP ("thbreak")));
12165 set_cmd_completer (c
, location_completer
);
12167 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
12168 Enable some breakpoints.\n\
12169 Give breakpoint numbers (separated by spaces) as arguments.\n\
12170 With no subcommand, breakpoints are enabled until you command otherwise.\n\
12171 This is used to cancel the effect of the \"disable\" command.\n\
12172 With a subcommand you can enable temporarily."),
12173 &enablelist
, "enable ", 1, &cmdlist
);
12175 add_com ("ab", class_breakpoint
, enable_command
, _("\
12176 Enable some breakpoints.\n\
12177 Give breakpoint numbers (separated by spaces) as arguments.\n\
12178 With no subcommand, breakpoints are enabled until you command otherwise.\n\
12179 This is used to cancel the effect of the \"disable\" command.\n\
12180 With a subcommand you can enable temporarily."));
12182 add_com_alias ("en", "enable", class_breakpoint
, 1);
12184 add_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
12185 Enable some breakpoints.\n\
12186 Give breakpoint numbers (separated by spaces) as arguments.\n\
12187 This is used to cancel the effect of the \"disable\" command.\n\
12188 May be abbreviated to simply \"enable\".\n"),
12189 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
12191 add_cmd ("once", no_class
, enable_once_command
, _("\
12192 Enable breakpoints for one hit. Give breakpoint numbers.\n\
12193 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
12196 add_cmd ("delete", no_class
, enable_delete_command
, _("\
12197 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
12198 If a breakpoint is hit while enabled in this fashion, it is deleted."),
12201 add_cmd ("delete", no_class
, enable_delete_command
, _("\
12202 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
12203 If a breakpoint is hit while enabled in this fashion, it is deleted."),
12206 add_cmd ("once", no_class
, enable_once_command
, _("\
12207 Enable breakpoints for one hit. Give breakpoint numbers.\n\
12208 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
12211 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
12212 Disable some breakpoints.\n\
12213 Arguments are breakpoint numbers with spaces in between.\n\
12214 To disable all breakpoints, give no argument.\n\
12215 A disabled breakpoint is not forgotten, but has no effect until reenabled."),
12216 &disablelist
, "disable ", 1, &cmdlist
);
12217 add_com_alias ("dis", "disable", class_breakpoint
, 1);
12218 add_com_alias ("disa", "disable", class_breakpoint
, 1);
12220 add_com ("sb", class_breakpoint
, disable_command
, _("\
12221 Disable some breakpoints.\n\
12222 Arguments are breakpoint numbers with spaces in between.\n\
12223 To disable all breakpoints, give no argument.\n\
12224 A disabled breakpoint is not forgotten, but has no effect until reenabled."));
12226 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
12227 Disable some breakpoints.\n\
12228 Arguments are breakpoint numbers with spaces in between.\n\
12229 To disable all breakpoints, give no argument.\n\
12230 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
12231 This command may be abbreviated \"disable\"."),
12234 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
12235 Delete some breakpoints or auto-display expressions.\n\
12236 Arguments are breakpoint numbers with spaces in between.\n\
12237 To delete all breakpoints, give no argument.\n\
12239 Also a prefix command for deletion of other GDB objects.\n\
12240 The \"unset\" command is also an alias for \"delete\"."),
12241 &deletelist
, "delete ", 1, &cmdlist
);
12242 add_com_alias ("d", "delete", class_breakpoint
, 1);
12243 add_com_alias ("del", "delete", class_breakpoint
, 1);
12245 add_com ("db", class_breakpoint
, delete_command
, _("\
12246 Delete some breakpoints.\n\
12247 Arguments are breakpoint numbers with spaces in between.\n\
12248 To delete all breakpoints, give no argument.\n"));
12250 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
12251 Delete some breakpoints or auto-display expressions.\n\
12252 Arguments are breakpoint numbers with spaces in between.\n\
12253 To delete all breakpoints, give no argument.\n\
12254 This command may be abbreviated \"delete\"."),
12257 add_com ("clear", class_breakpoint
, clear_command
, _("\
12258 Clear breakpoint at specified line or function.\n\
12259 Argument may be line number, function name, or \"*\" and an address.\n\
12260 If line number is specified, all breakpoints in that line are cleared.\n\
12261 If function is specified, breakpoints at beginning of function are cleared.\n\
12262 If an address is specified, breakpoints at that address are cleared.\n\
12264 With no argument, clears all breakpoints in the line that the selected frame\n\
12265 is executing in.\n\
12267 See also the \"delete\" command which clears breakpoints by number."));
12268 add_com_alias ("cl", "clear", class_breakpoint
, 1);
12270 c
= add_com ("break", class_breakpoint
, break_command
, _("\
12271 Set breakpoint at specified line or function.\n"
12272 BREAK_ARGS_HELP ("break")));
12273 set_cmd_completer (c
, location_completer
);
12275 add_com_alias ("b", "break", class_run
, 1);
12276 add_com_alias ("br", "break", class_run
, 1);
12277 add_com_alias ("bre", "break", class_run
, 1);
12278 add_com_alias ("brea", "break", class_run
, 1);
12281 add_com_alias ("ba", "break", class_breakpoint
, 1);
12285 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
12286 Break in function/address or break at a line in the current file."),
12287 &stoplist
, "stop ", 1, &cmdlist
);
12288 add_cmd ("in", class_breakpoint
, stopin_command
,
12289 _("Break in function or address."), &stoplist
);
12290 add_cmd ("at", class_breakpoint
, stopat_command
,
12291 _("Break at a line in the current file."), &stoplist
);
12292 add_com ("status", class_info
, breakpoints_info
, _("\
12293 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
12294 The \"Type\" column indicates one of:\n\
12295 \tbreakpoint - normal breakpoint\n\
12296 \twatchpoint - watchpoint\n\
12297 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
12298 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
12299 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
12300 address and file/line number respectively.\n\
12302 Convenience variable \"$_\" and default examine address for \"x\"\n\
12303 are set to the address of the last breakpoint listed unless the command\n\
12304 is prefixed with \"server \".\n\n\
12305 Convenience variable \"$bpnum\" contains the number of the last\n\
12306 breakpoint set."));
12309 add_info ("breakpoints", breakpoints_info
, _("\
12310 Status of specified breakpoints (all user-settable breakpoints if no argument).\n\
12311 The \"Type\" column indicates one of:\n\
12312 \tbreakpoint - normal breakpoint\n\
12313 \twatchpoint - watchpoint\n\
12314 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
12315 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
12316 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
12317 address and file/line number respectively.\n\
12319 Convenience variable \"$_\" and default examine address for \"x\"\n\
12320 are set to the address of the last breakpoint listed unless the command\n\
12321 is prefixed with \"server \".\n\n\
12322 Convenience variable \"$bpnum\" contains the number of the last\n\
12323 breakpoint set."));
12325 add_info_alias ("b", "breakpoints", 1);
12328 add_com ("lb", class_breakpoint
, breakpoints_info
, _("\
12329 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
12330 The \"Type\" column indicates one of:\n\
12331 \tbreakpoint - normal breakpoint\n\
12332 \twatchpoint - watchpoint\n\
12333 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
12334 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
12335 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
12336 address and file/line number respectively.\n\
12338 Convenience variable \"$_\" and default examine address for \"x\"\n\
12339 are set to the address of the last breakpoint listed unless the command\n\
12340 is prefixed with \"server \".\n\n\
12341 Convenience variable \"$bpnum\" contains the number of the last\n\
12342 breakpoint set."));
12344 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
12345 Status of all breakpoints, or breakpoint number NUMBER.\n\
12346 The \"Type\" column indicates one of:\n\
12347 \tbreakpoint - normal breakpoint\n\
12348 \twatchpoint - watchpoint\n\
12349 \tlongjmp - internal breakpoint used to step through longjmp()\n\
12350 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
12351 \tuntil - internal breakpoint used by the \"until\" command\n\
12352 \tfinish - internal breakpoint used by the \"finish\" command\n\
12353 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
12354 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
12355 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
12356 address and file/line number respectively.\n\
12358 Convenience variable \"$_\" and default examine address for \"x\"\n\
12359 are set to the address of the last breakpoint listed unless the command\n\
12360 is prefixed with \"server \".\n\n\
12361 Convenience variable \"$bpnum\" contains the number of the last\n\
12363 &maintenanceinfolist
);
12365 add_prefix_cmd ("catch", class_breakpoint
, catch_command
, _("\
12366 Set catchpoints to catch events."),
12367 &catch_cmdlist
, "catch ",
12368 0/*allow-unknown*/, &cmdlist
);
12370 add_prefix_cmd ("tcatch", class_breakpoint
, tcatch_command
, _("\
12371 Set temporary catchpoints to catch events."),
12372 &tcatch_cmdlist
, "tcatch ",
12373 0/*allow-unknown*/, &cmdlist
);
12375 /* Add catch and tcatch sub-commands. */
12376 add_catch_command ("catch", _("\
12377 Catch an exception, when caught.\n\
12378 With an argument, catch only exceptions with the given name."),
12379 catch_catch_command
,
12383 add_catch_command ("throw", _("\
12384 Catch an exception, when thrown.\n\
12385 With an argument, catch only exceptions with the given name."),
12386 catch_throw_command
,
12390 add_catch_command ("fork", _("Catch calls to fork."),
12391 catch_fork_command_1
,
12393 (void *) (uintptr_t) catch_fork_permanent
,
12394 (void *) (uintptr_t) catch_fork_temporary
);
12395 add_catch_command ("vfork", _("Catch calls to vfork."),
12396 catch_fork_command_1
,
12398 (void *) (uintptr_t) catch_vfork_permanent
,
12399 (void *) (uintptr_t) catch_vfork_temporary
);
12400 add_catch_command ("exec", _("Catch calls to exec."),
12401 catch_exec_command_1
,
12405 add_catch_command ("syscall", _("\
12406 Catch system calls by their names and/or numbers.\n\
12407 Arguments say which system calls to catch. If no arguments\n\
12408 are given, every system call will be caught.\n\
12409 Arguments, if given, should be one or more system call names\n\
12410 (if your system supports that), or system call numbers."),
12411 catch_syscall_command_1
,
12412 catch_syscall_completer
,
12415 add_catch_command ("exception", _("\
12416 Catch Ada exceptions, when raised.\n\
12417 With an argument, catch only exceptions with the given name."),
12418 catch_ada_exception_command
,
12422 add_catch_command ("assert", _("\
12423 Catch failed Ada assertions, when raised.\n\
12424 With an argument, catch only exceptions with the given name."),
12425 catch_assert_command
,
12430 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
12431 Set a watchpoint for an expression.\n\
12432 Usage: watch [-l|-location] EXPRESSION\n\
12433 A watchpoint stops execution of your program whenever the value of\n\
12434 an expression changes.\n\
12435 If -l or -location is given, this evaluates EXPRESSION and watches\n\
12436 the memory to which it refers."));
12437 set_cmd_completer (c
, expression_completer
);
12439 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
12440 Set a read watchpoint for an expression.\n\
12441 Usage: rwatch [-l|-location] EXPRESSION\n\
12442 A watchpoint stops execution of your program whenever the value of\n\
12443 an expression is read.\n\
12444 If -l or -location is given, this evaluates EXPRESSION and watches\n\
12445 the memory to which it refers."));
12446 set_cmd_completer (c
, expression_completer
);
12448 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
12449 Set a watchpoint for an expression.\n\
12450 Usage: awatch [-l|-location] EXPRESSION\n\
12451 A watchpoint stops execution of your program whenever the value of\n\
12452 an expression is either read or written.\n\
12453 If -l or -location is given, this evaluates EXPRESSION and watches\n\
12454 the memory to which it refers."));
12455 set_cmd_completer (c
, expression_completer
);
12457 add_info ("watchpoints", watchpoints_info
, _("\
12458 Status of specified watchpoints (all watchpoints if no argument)."));
12460 /* XXX: cagney/2005-02-23: This should be a boolean, and should
12461 respond to changes - contrary to the description. */
12462 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
12463 &can_use_hw_watchpoints
, _("\
12464 Set debugger's willingness to use watchpoint hardware."), _("\
12465 Show debugger's willingness to use watchpoint hardware."), _("\
12466 If zero, gdb will not use hardware for new watchpoints, even if\n\
12467 such is available. (However, any hardware watchpoints that were\n\
12468 created before setting this to nonzero, will continue to use watchpoint\n\
12471 show_can_use_hw_watchpoints
,
12472 &setlist
, &showlist
);
12474 can_use_hw_watchpoints
= 1;
12476 /* Tracepoint manipulation commands. */
12478 c
= add_com ("trace", class_breakpoint
, trace_command
, _("\
12479 Set a tracepoint at specified line or function.\n\
12481 BREAK_ARGS_HELP ("trace") "\n\
12482 Do \"help tracepoints\" for info on other tracepoint commands."));
12483 set_cmd_completer (c
, location_completer
);
12485 add_com_alias ("tp", "trace", class_alias
, 0);
12486 add_com_alias ("tr", "trace", class_alias
, 1);
12487 add_com_alias ("tra", "trace", class_alias
, 1);
12488 add_com_alias ("trac", "trace", class_alias
, 1);
12490 c
= add_com ("ftrace", class_breakpoint
, ftrace_command
, _("\
12491 Set a fast tracepoint at specified line or function.\n\
12493 BREAK_ARGS_HELP ("ftrace") "\n\
12494 Do \"help tracepoints\" for info on other tracepoint commands."));
12495 set_cmd_completer (c
, location_completer
);
12497 c
= add_com ("strace", class_breakpoint
, strace_command
, _("\
12498 Set a static tracepoint at specified line, function or marker.\n\
12500 strace [LOCATION] [if CONDITION]\n\
12501 LOCATION may be a line number, function name, \"*\" and an address,\n\
12502 or -m MARKER_ID.\n\
12503 If a line number is specified, probe the marker at start of code\n\
12504 for that line. If a function is specified, probe the marker at start\n\
12505 of code for that function. If an address is specified, probe the marker\n\
12506 at that exact address. If a marker id is specified, probe the marker\n\
12507 with that name. With no LOCATION, uses current execution address of\n\
12508 the selected stack frame.\n\
12509 Static tracepoints accept an extra collect action -- ``collect $_sdata''.\n\
12510 This collects arbitrary user data passed in the probe point call to the\n\
12511 tracing library. You can inspect it when analyzing the trace buffer,\n\
12512 by printing the $_sdata variable like any other convenience variable.\n\
12514 CONDITION is a boolean expression.\n\
12516 Multiple tracepoints at one place are permitted, and useful if their\n\
12517 conditions are different.\n\
12519 Do \"help breakpoints\" for info on other commands dealing with breakpoints.\n\
12520 Do \"help tracepoints\" for info on other tracepoint commands."));
12521 set_cmd_completer (c
, location_completer
);
12523 add_info ("tracepoints", tracepoints_info
, _("\
12524 Status of specified tracepoints (all tracepoints if no argument).\n\
12525 Convenience variable \"$tpnum\" contains the number of the\n\
12526 last tracepoint set."));
12528 add_info_alias ("tp", "tracepoints", 1);
12530 add_cmd ("tracepoints", class_trace
, delete_trace_command
, _("\
12531 Delete specified tracepoints.\n\
12532 Arguments are tracepoint numbers, separated by spaces.\n\
12533 No argument means delete all tracepoints."),
12536 c
= add_cmd ("tracepoints", class_trace
, disable_trace_command
, _("\
12537 Disable specified tracepoints.\n\
12538 Arguments are tracepoint numbers, separated by spaces.\n\
12539 No argument means disable all tracepoints."),
12541 deprecate_cmd (c
, "disable");
12543 c
= add_cmd ("tracepoints", class_trace
, enable_trace_command
, _("\
12544 Enable specified tracepoints.\n\
12545 Arguments are tracepoint numbers, separated by spaces.\n\
12546 No argument means enable all tracepoints."),
12548 deprecate_cmd (c
, "enable");
12550 add_com ("passcount", class_trace
, trace_pass_command
, _("\
12551 Set the passcount for a tracepoint.\n\
12552 The trace will end when the tracepoint has been passed 'count' times.\n\
12553 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
12554 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
12556 add_prefix_cmd ("save", class_breakpoint
, save_command
,
12557 _("Save breakpoint definitions as a script."),
12558 &save_cmdlist
, "save ",
12559 0/*allow-unknown*/, &cmdlist
);
12561 c
= add_cmd ("breakpoints", class_breakpoint
, save_breakpoints_command
, _("\
12562 Save current breakpoint definitions as a script.\n\
12563 This includes all types of breakpoints (breakpoints, watchpoints,\n\
12564 catchpoints, tracepoints). Use the 'source' command in another debug\n\
12565 session to restore them."),
12567 set_cmd_completer (c
, filename_completer
);
12569 c
= add_cmd ("tracepoints", class_trace
, save_tracepoints_command
, _("\
12570 Save current tracepoint definitions as a script.\n\
12571 Use the 'source' command in another debug session to restore them."),
12573 set_cmd_completer (c
, filename_completer
);
12575 c
= add_com_alias ("save-tracepoints", "save tracepoints", class_trace
, 0);
12576 deprecate_cmd (c
, "save tracepoints");
12578 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
12579 Breakpoint specific settings\n\
12580 Configure various breakpoint-specific variables such as\n\
12581 pending breakpoint behavior"),
12582 &breakpoint_set_cmdlist
, "set breakpoint ",
12583 0/*allow-unknown*/, &setlist
);
12584 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
12585 Breakpoint specific settings\n\
12586 Configure various breakpoint-specific variables such as\n\
12587 pending breakpoint behavior"),
12588 &breakpoint_show_cmdlist
, "show breakpoint ",
12589 0/*allow-unknown*/, &showlist
);
12591 add_setshow_auto_boolean_cmd ("pending", no_class
,
12592 &pending_break_support
, _("\
12593 Set debugger's behavior regarding pending breakpoints."), _("\
12594 Show debugger's behavior regarding pending breakpoints."), _("\
12595 If on, an unrecognized breakpoint location will cause gdb to create a\n\
12596 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
12597 an error. If auto, an unrecognized breakpoint location results in a\n\
12598 user-query to see if a pending breakpoint should be created."),
12600 show_pending_break_support
,
12601 &breakpoint_set_cmdlist
,
12602 &breakpoint_show_cmdlist
);
12604 pending_break_support
= AUTO_BOOLEAN_AUTO
;
12606 add_setshow_boolean_cmd ("auto-hw", no_class
,
12607 &automatic_hardware_breakpoints
, _("\
12608 Set automatic usage of hardware breakpoints."), _("\
12609 Show automatic usage of hardware breakpoints."), _("\
12610 If set, the debugger will automatically use hardware breakpoints for\n\
12611 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
12612 a warning will be emitted for such breakpoints."),
12614 show_automatic_hardware_breakpoints
,
12615 &breakpoint_set_cmdlist
,
12616 &breakpoint_show_cmdlist
);
12618 add_setshow_enum_cmd ("always-inserted", class_support
,
12619 always_inserted_enums
, &always_inserted_mode
, _("\
12620 Set mode for inserting breakpoints."), _("\
12621 Show mode for inserting breakpoints."), _("\
12622 When this mode is off, breakpoints are inserted in inferior when it is\n\
12623 resumed, and removed when execution stops. When this mode is on,\n\
12624 breakpoints are inserted immediately and removed only when the user\n\
12625 deletes the breakpoint. When this mode is auto (which is the default),\n\
12626 the behaviour depends on the non-stop setting (see help set non-stop).\n\
12627 In this case, if gdb is controlling the inferior in non-stop mode, gdb\n\
12628 behaves as if always-inserted mode is on; if gdb is controlling the\n\
12629 inferior in all-stop mode, gdb behaves as if always-inserted mode is off."),
12631 &show_always_inserted_mode
,
12632 &breakpoint_set_cmdlist
,
12633 &breakpoint_show_cmdlist
);
12635 automatic_hardware_breakpoints
= 1;
12637 observer_attach_about_to_proceed (breakpoint_about_to_proceed
);