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 int breakpoint_location_address_match (struct bp_location
*bl
,
135 struct address_space
*aspace
,
138 static void breakpoints_info (char *, int);
140 static void watchpoints_info (char *, int);
142 static int breakpoint_1 (char *, int,
143 int (*) (const struct breakpoint
*));
145 static int breakpoint_cond_eval (void *);
147 static void cleanup_executing_breakpoints (void *);
149 static void commands_command (char *, int);
151 static void condition_command (char *, int);
160 static int remove_breakpoint (struct bp_location
*, insertion_state_t
);
161 static int remove_breakpoint_1 (struct bp_location
*, insertion_state_t
);
163 static enum print_stop_action
print_it_typical (bpstat
);
165 static enum print_stop_action
print_bp_stop_message (bpstat bs
);
167 static int watchpoint_check (void *);
169 static void maintenance_info_breakpoints (char *, int);
171 static int hw_breakpoint_used_count (void);
173 static int hw_watchpoint_used_count (enum bptype
, int *);
175 static void hbreak_command (char *, int);
177 static void thbreak_command (char *, int);
179 static void do_enable_breakpoint (struct breakpoint
*, enum bpdisp
);
181 static void stop_command (char *arg
, int from_tty
);
183 static void stopin_command (char *arg
, int from_tty
);
185 static void stopat_command (char *arg
, int from_tty
);
187 static char *ep_parse_optional_if_clause (char **arg
);
189 static void catch_exception_command_1 (enum exception_event_kind ex_event
,
190 char *arg
, int tempflag
, int from_tty
);
192 static void tcatch_command (char *arg
, int from_tty
);
194 static void detach_single_step_breakpoints (void);
196 static int single_step_breakpoint_inserted_here_p (struct address_space
*,
199 static void free_bp_location (struct bp_location
*loc
);
200 static void incref_bp_location (struct bp_location
*loc
);
201 static void decref_bp_location (struct bp_location
**loc
);
203 static struct bp_location
*allocate_bp_location (struct breakpoint
*bpt
);
205 static void update_global_location_list (int);
207 static void update_global_location_list_nothrow (int);
209 static int is_hardware_watchpoint (const struct breakpoint
*bpt
);
211 static int is_watchpoint (const struct breakpoint
*bpt
);
213 static void insert_breakpoint_locations (void);
215 static int syscall_catchpoint_p (struct breakpoint
*b
);
217 static void tracepoints_info (char *, int);
219 static void delete_trace_command (char *, int);
221 static void enable_trace_command (char *, int);
223 static void disable_trace_command (char *, int);
225 static void trace_pass_command (char *, int);
227 /* Assuming we're creating a static tracepoint, does S look like a
228 static tracepoint marker spec ("-m MARKER_ID")? */
229 #define is_marker_spec(s) \
230 (s != NULL && strncmp (s, "-m", 2) == 0 && ((s)[2] == ' ' || (s)[2] == '\t'))
232 /* A reference-counted struct command_line. This lets multiple
233 breakpoints share a single command list. */
234 struct counted_command_line
236 /* The reference count. */
239 /* The command list. */
240 struct command_line
*commands
;
243 struct command_line
*
244 breakpoint_commands (struct breakpoint
*b
)
246 return b
->commands
? b
->commands
->commands
: NULL
;
249 /* Flag indicating that a command has proceeded the inferior past the
250 current breakpoint. */
252 static int breakpoint_proceeded
;
255 bpdisp_text (enum bpdisp disp
)
257 /* NOTE: the following values are a part of MI protocol and
258 represent values of 'disp' field returned when inferior stops at
260 static const char * const bpdisps
[] = {"del", "dstp", "dis", "keep"};
262 return bpdisps
[(int) disp
];
265 /* Prototypes for exported functions. */
266 /* If FALSE, gdb will not use hardware support for watchpoints, even
267 if such is available. */
268 static int can_use_hw_watchpoints
;
271 show_can_use_hw_watchpoints (struct ui_file
*file
, int from_tty
,
272 struct cmd_list_element
*c
,
275 fprintf_filtered (file
,
276 _("Debugger's willingness to use "
277 "watchpoint hardware is %s.\n"),
281 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
282 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
283 for unrecognized breakpoint locations.
284 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
285 static enum auto_boolean pending_break_support
;
287 show_pending_break_support (struct ui_file
*file
, int from_tty
,
288 struct cmd_list_element
*c
,
291 fprintf_filtered (file
,
292 _("Debugger's behavior regarding "
293 "pending breakpoints is %s.\n"),
297 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
298 set with "break" but falling in read-only memory.
299 If 0, gdb will warn about such breakpoints, but won't automatically
300 use hardware breakpoints. */
301 static int automatic_hardware_breakpoints
;
303 show_automatic_hardware_breakpoints (struct ui_file
*file
, int from_tty
,
304 struct cmd_list_element
*c
,
307 fprintf_filtered (file
,
308 _("Automatic usage of hardware breakpoints is %s.\n"),
312 /* If on, gdb will keep breakpoints inserted even as inferior is
313 stopped, and immediately insert any new breakpoints. If off, gdb
314 will insert breakpoints into inferior only when resuming it, and
315 will remove breakpoints upon stop. If auto, GDB will behave as ON
316 if in non-stop mode, and as OFF if all-stop mode.*/
318 static const char always_inserted_auto
[] = "auto";
319 static const char always_inserted_on
[] = "on";
320 static const char always_inserted_off
[] = "off";
321 static const char *always_inserted_enums
[] = {
322 always_inserted_auto
,
327 static const char *always_inserted_mode
= always_inserted_auto
;
329 show_always_inserted_mode (struct ui_file
*file
, int from_tty
,
330 struct cmd_list_element
*c
, const char *value
)
332 if (always_inserted_mode
== always_inserted_auto
)
333 fprintf_filtered (file
,
334 _("Always inserted breakpoint "
335 "mode is %s (currently %s).\n"),
337 breakpoints_always_inserted_mode () ? "on" : "off");
339 fprintf_filtered (file
, _("Always inserted breakpoint mode is %s.\n"),
344 breakpoints_always_inserted_mode (void)
346 return (always_inserted_mode
== always_inserted_on
347 || (always_inserted_mode
== always_inserted_auto
&& non_stop
));
350 void _initialize_breakpoint (void);
352 /* Are we executing breakpoint commands? */
353 static int executing_breakpoint_commands
;
355 /* Are overlay event breakpoints enabled? */
356 static int overlay_events_enabled
;
358 /* See description in breakpoint.h. */
359 int target_exact_watchpoints
= 0;
361 /* Walk the following statement or block through all breakpoints.
362 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the
363 current breakpoint. */
365 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
367 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
368 for (B = breakpoint_chain; \
369 B ? (TMP=B->next, 1): 0; \
372 /* Similar iterator for the low-level breakpoints. SAFE variant is
373 not provided so update_global_location_list must not be called
374 while executing the block of ALL_BP_LOCATIONS. */
376 #define ALL_BP_LOCATIONS(B,BP_TMP) \
377 for (BP_TMP = bp_location; \
378 BP_TMP < bp_location + bp_location_count && (B = *BP_TMP); \
381 /* Iterator for tracepoints only. */
383 #define ALL_TRACEPOINTS(B) \
384 for (B = breakpoint_chain; B; B = B->next) \
385 if (is_tracepoint (B))
387 /* Chains of all breakpoints defined. */
389 struct breakpoint
*breakpoint_chain
;
391 /* Array is sorted by bp_location_compare - primarily by the ADDRESS. */
393 static struct bp_location
**bp_location
;
395 /* Number of elements of BP_LOCATION. */
397 static unsigned bp_location_count
;
399 /* Maximum alignment offset between bp_target_info.PLACED_ADDRESS and
400 ADDRESS for the current elements of BP_LOCATION which get a valid
401 result from bp_location_has_shadow. You can use it for roughly
402 limiting the subrange of BP_LOCATION to scan for shadow bytes for
403 an address you need to read. */
405 static CORE_ADDR bp_location_placed_address_before_address_max
;
407 /* Maximum offset plus alignment between bp_target_info.PLACED_ADDRESS
408 + bp_target_info.SHADOW_LEN and ADDRESS for the current elements of
409 BP_LOCATION which get a valid result from bp_location_has_shadow.
410 You can use it for roughly limiting the subrange of BP_LOCATION to
411 scan for shadow bytes for an address you need to read. */
413 static CORE_ADDR bp_location_shadow_len_after_address_max
;
415 /* The locations that no longer correspond to any breakpoint, unlinked
416 from bp_location array, but for which a hit may still be reported
418 VEC(bp_location_p
) *moribund_locations
= NULL
;
420 /* Number of last breakpoint made. */
422 static int breakpoint_count
;
424 /* The value of `breakpoint_count' before the last command that
425 created breakpoints. If the last (break-like) command created more
426 than one breakpoint, then the difference between BREAKPOINT_COUNT
427 and PREV_BREAKPOINT_COUNT is more than one. */
428 static int prev_breakpoint_count
;
430 /* Number of last tracepoint made. */
432 static int tracepoint_count
;
434 static struct cmd_list_element
*breakpoint_set_cmdlist
;
435 static struct cmd_list_element
*breakpoint_show_cmdlist
;
436 struct cmd_list_element
*save_cmdlist
;
438 /* Return whether a breakpoint is an active enabled breakpoint. */
440 breakpoint_enabled (struct breakpoint
*b
)
442 return (b
->enable_state
== bp_enabled
);
445 /* Set breakpoint count to NUM. */
448 set_breakpoint_count (int num
)
450 prev_breakpoint_count
= breakpoint_count
;
451 breakpoint_count
= num
;
452 set_internalvar_integer (lookup_internalvar ("bpnum"), num
);
455 /* Used by `start_rbreak_breakpoints' below, to record the current
456 breakpoint count before "rbreak" creates any breakpoint. */
457 static int rbreak_start_breakpoint_count
;
459 /* Called at the start an "rbreak" command to record the first
463 start_rbreak_breakpoints (void)
465 rbreak_start_breakpoint_count
= breakpoint_count
;
468 /* Called at the end of an "rbreak" command to record the last
472 end_rbreak_breakpoints (void)
474 prev_breakpoint_count
= rbreak_start_breakpoint_count
;
477 /* Used in run_command to zero the hit count when a new run starts. */
480 clear_breakpoint_hit_counts (void)
482 struct breakpoint
*b
;
488 /* Allocate a new counted_command_line with reference count of 1.
489 The new structure owns COMMANDS. */
491 static struct counted_command_line
*
492 alloc_counted_command_line (struct command_line
*commands
)
494 struct counted_command_line
*result
495 = xmalloc (sizeof (struct counted_command_line
));
498 result
->commands
= commands
;
502 /* Increment reference count. This does nothing if CMD is NULL. */
505 incref_counted_command_line (struct counted_command_line
*cmd
)
511 /* Decrement reference count. If the reference count reaches 0,
512 destroy the counted_command_line. Sets *CMDP to NULL. This does
513 nothing if *CMDP is NULL. */
516 decref_counted_command_line (struct counted_command_line
**cmdp
)
520 if (--(*cmdp
)->refc
== 0)
522 free_command_lines (&(*cmdp
)->commands
);
529 /* A cleanup function that calls decref_counted_command_line. */
532 do_cleanup_counted_command_line (void *arg
)
534 decref_counted_command_line (arg
);
537 /* Create a cleanup that calls decref_counted_command_line on the
540 static struct cleanup
*
541 make_cleanup_decref_counted_command_line (struct counted_command_line
**cmdp
)
543 return make_cleanup (do_cleanup_counted_command_line
, cmdp
);
546 /* Default address, symtab and line to put a breakpoint at
547 for "break" command with no arg.
548 If default_breakpoint_valid is zero, the other three are
549 not valid, and "break" with no arg is an error.
551 This set by print_stack_frame, which calls set_default_breakpoint. */
553 int default_breakpoint_valid
;
554 CORE_ADDR default_breakpoint_address
;
555 struct symtab
*default_breakpoint_symtab
;
556 int default_breakpoint_line
;
557 struct program_space
*default_breakpoint_pspace
;
560 /* Return the breakpoint with the specified number, or NULL
561 if the number does not refer to an existing breakpoint. */
564 get_breakpoint (int num
)
566 struct breakpoint
*b
;
569 if (b
->number
== num
)
578 set_breakpoint_condition (struct breakpoint
*b
, char *exp
,
581 struct bp_location
*loc
= b
->loc
;
583 for (; loc
; loc
= loc
->next
)
588 xfree (b
->cond_string
);
589 b
->cond_string
= NULL
;
596 printf_filtered (_("Breakpoint %d now unconditional.\n"), b
->number
);
602 /* I don't know if it matters whether this is the string the user
603 typed in or the decompiled expression. */
604 b
->cond_string
= xstrdup (arg
);
605 b
->condition_not_parsed
= 0;
607 if (is_watchpoint (b
))
609 innermost_block
= NULL
;
611 b
->cond_exp
= parse_exp_1 (&arg
, 0, 0);
613 error (_("Junk at end of expression"));
614 b
->cond_exp_valid_block
= innermost_block
;
618 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
622 parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
624 error (_("Junk at end of expression"));
628 breakpoints_changed ();
629 observer_notify_breakpoint_modified (b
->number
);
632 /* condition N EXP -- set break condition of breakpoint N to EXP. */
635 condition_command (char *arg
, int from_tty
)
637 struct breakpoint
*b
;
642 error_no_arg (_("breakpoint number"));
645 bnum
= get_number (&p
);
647 error (_("Bad breakpoint argument: '%s'"), arg
);
650 if (b
->number
== bnum
)
652 /* Check if this breakpoint has a Python object assigned to
653 it, and if it has a definition of the "stop"
654 method. This method and conditions entered into GDB from
655 the CLI are mutually exclusive. */
657 && gdbpy_breakpoint_has_py_cond (b
->py_bp_object
))
658 error (_("Cannot set a condition where a Python 'stop' "
659 "method has been defined in the breakpoint."));
660 set_breakpoint_condition (b
, p
, from_tty
);
664 error (_("No breakpoint number %d."), bnum
);
667 /* Check that COMMAND do not contain commands that are suitable
668 only for tracepoints and not suitable for ordinary breakpoints.
669 Throw if any such commands is found. */
672 check_no_tracepoint_commands (struct command_line
*commands
)
674 struct command_line
*c
;
676 for (c
= commands
; c
; c
= c
->next
)
680 if (c
->control_type
== while_stepping_control
)
681 error (_("The 'while-stepping' command can "
682 "only be used for tracepoints"));
684 for (i
= 0; i
< c
->body_count
; ++i
)
685 check_no_tracepoint_commands ((c
->body_list
)[i
]);
687 /* Not that command parsing removes leading whitespace and comment
688 lines and also empty lines. So, we only need to check for
690 if (strstr (c
->line
, "collect ") == c
->line
)
691 error (_("The 'collect' command can only be used for tracepoints"));
693 if (strstr (c
->line
, "teval ") == c
->line
)
694 error (_("The 'teval' command can only be used for tracepoints"));
698 /* Encapsulate tests for different types of tracepoints. */
701 is_tracepoint (const struct breakpoint
*b
)
703 return (b
->type
== bp_tracepoint
704 || b
->type
== bp_fast_tracepoint
705 || b
->type
== bp_static_tracepoint
);
708 /* A helper function that validsates that COMMANDS are valid for a
709 breakpoint. This function will throw an exception if a problem is
713 validate_commands_for_breakpoint (struct breakpoint
*b
,
714 struct command_line
*commands
)
716 if (is_tracepoint (b
))
718 /* We need to verify that each top-level element of commands is
719 valid for tracepoints, that there's at most one
720 while-stepping element, and that while-stepping's body has
721 valid tracing commands excluding nested while-stepping. */
722 struct command_line
*c
;
723 struct command_line
*while_stepping
= 0;
724 for (c
= commands
; c
; c
= c
->next
)
726 if (c
->control_type
== while_stepping_control
)
728 if (b
->type
== bp_fast_tracepoint
)
729 error (_("The 'while-stepping' command "
730 "cannot be used for fast tracepoint"));
731 else if (b
->type
== bp_static_tracepoint
)
732 error (_("The 'while-stepping' command "
733 "cannot be used for static tracepoint"));
736 error (_("The 'while-stepping' command "
737 "can be used only once"));
744 struct command_line
*c2
;
746 gdb_assert (while_stepping
->body_count
== 1);
747 c2
= while_stepping
->body_list
[0];
748 for (; c2
; c2
= c2
->next
)
750 if (c2
->control_type
== while_stepping_control
)
751 error (_("The 'while-stepping' command cannot be nested"));
757 check_no_tracepoint_commands (commands
);
761 /* Return a vector of all the static tracepoints set at ADDR. The
762 caller is responsible for releasing the vector. */
765 static_tracepoints_here (CORE_ADDR addr
)
767 struct breakpoint
*b
;
768 VEC(breakpoint_p
) *found
= 0;
769 struct bp_location
*loc
;
772 if (b
->type
== bp_static_tracepoint
)
774 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
775 if (loc
->address
== addr
)
776 VEC_safe_push(breakpoint_p
, found
, b
);
782 /* Set the command list of B to COMMANDS. If breakpoint is tracepoint,
783 validate that only allowed commands are included. */
786 breakpoint_set_commands (struct breakpoint
*b
,
787 struct command_line
*commands
)
789 validate_commands_for_breakpoint (b
, commands
);
791 decref_counted_command_line (&b
->commands
);
792 b
->commands
= alloc_counted_command_line (commands
);
793 breakpoints_changed ();
794 observer_notify_breakpoint_modified (b
->number
);
797 /* Set the internal `silent' flag on the breakpoint. Note that this
798 is not the same as the "silent" that may appear in the breakpoint's
802 breakpoint_set_silent (struct breakpoint
*b
, int silent
)
804 int old_silent
= b
->silent
;
807 if (old_silent
!= silent
)
808 observer_notify_breakpoint_modified (b
->number
);
811 /* Set the thread for this breakpoint. If THREAD is -1, make the
812 breakpoint work for any thread. */
815 breakpoint_set_thread (struct breakpoint
*b
, int thread
)
817 int old_thread
= b
->thread
;
820 if (old_thread
!= thread
)
821 observer_notify_breakpoint_modified (b
->number
);
824 /* Set the task for this breakpoint. If TASK is 0, make the
825 breakpoint work for any task. */
828 breakpoint_set_task (struct breakpoint
*b
, int task
)
830 int old_task
= b
->task
;
833 if (old_task
!= task
)
834 observer_notify_breakpoint_modified (b
->number
);
838 check_tracepoint_command (char *line
, void *closure
)
840 struct breakpoint
*b
= closure
;
842 validate_actionline (&line
, b
);
845 /* A structure used to pass information through
846 map_breakpoint_numbers. */
850 /* True if the command was typed at a tty. */
853 /* The breakpoint range spec. */
856 /* Non-NULL if the body of the commands are being read from this
857 already-parsed command. */
858 struct command_line
*control
;
860 /* The command lines read from the user, or NULL if they have not
862 struct counted_command_line
*cmd
;
865 /* A callback for map_breakpoint_numbers that sets the commands for
869 do_map_commands_command (struct breakpoint
*b
, void *data
)
871 struct commands_info
*info
= data
;
873 if (info
->cmd
== NULL
)
875 struct command_line
*l
;
877 if (info
->control
!= NULL
)
878 l
= copy_command_lines (info
->control
->body_list
[0]);
881 struct cleanup
*old_chain
;
884 str
= xstrprintf (_("Type commands for breakpoint(s) "
885 "%s, one per line."),
888 old_chain
= make_cleanup (xfree
, str
);
890 l
= read_command_lines (str
,
893 ? check_tracepoint_command
: 0),
896 do_cleanups (old_chain
);
899 info
->cmd
= alloc_counted_command_line (l
);
902 /* If a breakpoint was on the list more than once, we don't need to
904 if (b
->commands
!= info
->cmd
)
906 validate_commands_for_breakpoint (b
, info
->cmd
->commands
);
907 incref_counted_command_line (info
->cmd
);
908 decref_counted_command_line (&b
->commands
);
909 b
->commands
= info
->cmd
;
910 breakpoints_changed ();
911 observer_notify_breakpoint_modified (b
->number
);
916 commands_command_1 (char *arg
, int from_tty
,
917 struct command_line
*control
)
919 struct cleanup
*cleanups
;
920 struct commands_info info
;
922 info
.from_tty
= from_tty
;
923 info
.control
= control
;
925 /* If we read command lines from the user, then `info' will hold an
926 extra reference to the commands that we must clean up. */
927 cleanups
= make_cleanup_decref_counted_command_line (&info
.cmd
);
929 if (arg
== NULL
|| !*arg
)
931 if (breakpoint_count
- prev_breakpoint_count
> 1)
932 arg
= xstrprintf ("%d-%d", prev_breakpoint_count
+ 1,
934 else if (breakpoint_count
> 0)
935 arg
= xstrprintf ("%d", breakpoint_count
);
938 /* So that we don't try to free the incoming non-NULL
939 argument in the cleanup below. Mapping breakpoint
940 numbers will fail in this case. */
945 /* The command loop has some static state, so we need to preserve
950 make_cleanup (xfree
, arg
);
954 map_breakpoint_numbers (arg
, do_map_commands_command
, &info
);
956 if (info
.cmd
== NULL
)
957 error (_("No breakpoints specified."));
959 do_cleanups (cleanups
);
963 commands_command (char *arg
, int from_tty
)
965 commands_command_1 (arg
, from_tty
, NULL
);
968 /* Like commands_command, but instead of reading the commands from
969 input stream, takes them from an already parsed command structure.
971 This is used by cli-script.c to DTRT with breakpoint commands
972 that are part of if and while bodies. */
973 enum command_control_type
974 commands_from_control_command (char *arg
, struct command_line
*cmd
)
976 commands_command_1 (arg
, 0, cmd
);
977 return simple_control
;
980 /* Return non-zero if BL->TARGET_INFO contains valid information. */
983 bp_location_has_shadow (struct bp_location
*bl
)
985 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
989 if (bl
->target_info
.shadow_len
== 0)
990 /* bp isn't valid, or doesn't shadow memory. */
995 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
996 by replacing any memory breakpoints with their shadowed contents.
998 The range of shadowed area by each bp_location is:
999 bl->address - bp_location_placed_address_before_address_max
1000 up to bl->address + bp_location_shadow_len_after_address_max
1001 The range we were requested to resolve shadows for is:
1002 memaddr ... memaddr + len
1003 Thus the safe cutoff boundaries for performance optimization are
1004 memaddr + len <= (bl->address
1005 - bp_location_placed_address_before_address_max)
1007 bl->address + bp_location_shadow_len_after_address_max <= memaddr */
1010 breakpoint_restore_shadows (gdb_byte
*buf
, ULONGEST memaddr
, LONGEST len
)
1012 /* Left boundary, right boundary and median element of our binary
1014 unsigned bc_l
, bc_r
, bc
;
1016 /* Find BC_L which is a leftmost element which may affect BUF
1017 content. It is safe to report lower value but a failure to
1018 report higher one. */
1021 bc_r
= bp_location_count
;
1022 while (bc_l
+ 1 < bc_r
)
1024 struct bp_location
*bl
;
1026 bc
= (bc_l
+ bc_r
) / 2;
1027 bl
= bp_location
[bc
];
1029 /* Check first BL->ADDRESS will not overflow due to the added
1030 constant. Then advance the left boundary only if we are sure
1031 the BC element can in no way affect the BUF content (MEMADDR
1032 to MEMADDR + LEN range).
1034 Use the BP_LOCATION_SHADOW_LEN_AFTER_ADDRESS_MAX safety
1035 offset so that we cannot miss a breakpoint with its shadow
1036 range tail still reaching MEMADDR. */
1038 if ((bl
->address
+ bp_location_shadow_len_after_address_max
1040 && (bl
->address
+ bp_location_shadow_len_after_address_max
1047 /* Due to the binary search above, we need to make sure we pick the
1048 first location that's at BC_L's address. E.g., if there are
1049 multiple locations at the same address, BC_L may end up pointing
1050 at a duplicate location, and miss the "master"/"inserted"
1051 location. Say, given locations L1, L2 and L3 at addresses A and
1054 L1@A, L2@A, L3@B, ...
1056 BC_L could end up pointing at location L2, while the "master"
1057 location could be L1. Since the `loc->inserted' flag is only set
1058 on "master" locations, we'd forget to restore the shadow of L1
1061 && bp_location
[bc_l
]->address
== bp_location
[bc_l
- 1]->address
)
1064 /* Now do full processing of the found relevant range of elements. */
1066 for (bc
= bc_l
; bc
< bp_location_count
; bc
++)
1068 struct bp_location
*bl
= bp_location
[bc
];
1069 CORE_ADDR bp_addr
= 0;
1073 /* bp_location array has BL->OWNER always non-NULL. */
1074 if (bl
->owner
->type
== bp_none
)
1075 warning (_("reading through apparently deleted breakpoint #%d?"),
1078 /* Performance optimization: any futher element can no longer affect BUF
1081 if (bl
->address
>= bp_location_placed_address_before_address_max
1082 && memaddr
+ len
<= (bl
->address
1083 - bp_location_placed_address_before_address_max
))
1086 if (!bp_location_has_shadow (bl
))
1088 if (!breakpoint_address_match (bl
->target_info
.placed_address_space
, 0,
1089 current_program_space
->aspace
, 0))
1092 /* Addresses and length of the part of the breakpoint that
1094 bp_addr
= bl
->target_info
.placed_address
;
1095 bp_size
= bl
->target_info
.shadow_len
;
1097 if (bp_addr
+ bp_size
<= memaddr
)
1098 /* The breakpoint is entirely before the chunk of memory we
1102 if (bp_addr
>= memaddr
+ len
)
1103 /* The breakpoint is entirely after the chunk of memory we are
1107 /* Offset within shadow_contents. */
1108 if (bp_addr
< memaddr
)
1110 /* Only copy the second part of the breakpoint. */
1111 bp_size
-= memaddr
- bp_addr
;
1112 bptoffset
= memaddr
- bp_addr
;
1116 if (bp_addr
+ bp_size
> memaddr
+ len
)
1118 /* Only copy the first part of the breakpoint. */
1119 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
1122 memcpy (buf
+ bp_addr
- memaddr
,
1123 bl
->target_info
.shadow_contents
+ bptoffset
, bp_size
);
1128 /* Return true if BPT is of any hardware watchpoint kind. */
1131 is_hardware_watchpoint (const struct breakpoint
*bpt
)
1133 return (bpt
->type
== bp_hardware_watchpoint
1134 || bpt
->type
== bp_read_watchpoint
1135 || bpt
->type
== bp_access_watchpoint
);
1138 /* Return true if BPT is of any watchpoint kind, hardware or
1142 is_watchpoint (const struct breakpoint
*bpt
)
1144 return (is_hardware_watchpoint (bpt
)
1145 || bpt
->type
== bp_watchpoint
);
1148 /* Assuming that B is a watchpoint: returns true if the current thread
1149 and its running state are safe to evaluate or update watchpoint B.
1150 Watchpoints on local expressions need to be evaluated in the
1151 context of the thread that was current when the watchpoint was
1152 created, and, that thread needs to be stopped to be able to select
1153 the correct frame context. Watchpoints on global expressions can
1154 be evaluated on any thread, and in any state. It is presently left
1155 to the target allowing memory accesses when threads are
1159 watchpoint_in_thread_scope (struct breakpoint
*b
)
1161 return (ptid_equal (b
->watchpoint_thread
, null_ptid
)
1162 || (ptid_equal (inferior_ptid
, b
->watchpoint_thread
)
1163 && !is_executing (inferior_ptid
)));
1166 /* Set watchpoint B to disp_del_at_next_stop, even including its possible
1167 associated bp_watchpoint_scope breakpoint. */
1170 watchpoint_del_at_next_stop (struct breakpoint
*b
)
1172 gdb_assert (is_watchpoint (b
));
1174 if (b
->related_breakpoint
!= b
)
1176 gdb_assert (b
->related_breakpoint
->type
== bp_watchpoint_scope
);
1177 gdb_assert (b
->related_breakpoint
->related_breakpoint
== b
);
1178 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
1179 b
->related_breakpoint
->related_breakpoint
= b
->related_breakpoint
;
1180 b
->related_breakpoint
= b
;
1182 b
->disposition
= disp_del_at_next_stop
;
1185 /* Assuming that B is a watchpoint:
1186 - Reparse watchpoint expression, if REPARSE is non-zero
1187 - Evaluate expression and store the result in B->val
1188 - Evaluate the condition if there is one, and store the result
1190 - Update the list of values that must be watched in B->loc.
1192 If the watchpoint disposition is disp_del_at_next_stop, then do
1193 nothing. If this is local watchpoint that is out of scope, delete
1196 Even with `set breakpoint always-inserted on' the watchpoints are
1197 removed + inserted on each stop here. Normal breakpoints must
1198 never be removed because they might be missed by a running thread
1199 when debugging in non-stop mode. On the other hand, hardware
1200 watchpoints (is_hardware_watchpoint; processed here) are specific
1201 to each LWP since they are stored in each LWP's hardware debug
1202 registers. Therefore, such LWP must be stopped first in order to
1203 be able to modify its hardware watchpoints.
1205 Hardware watchpoints must be reset exactly once after being
1206 presented to the user. It cannot be done sooner, because it would
1207 reset the data used to present the watchpoint hit to the user. And
1208 it must not be done later because it could display the same single
1209 watchpoint hit during multiple GDB stops. Note that the latter is
1210 relevant only to the hardware watchpoint types bp_read_watchpoint
1211 and bp_access_watchpoint. False hit by bp_hardware_watchpoint is
1212 not user-visible - its hit is suppressed if the memory content has
1215 The following constraints influence the location where we can reset
1216 hardware watchpoints:
1218 * target_stopped_by_watchpoint and target_stopped_data_address are
1219 called several times when GDB stops.
1222 * Multiple hardware watchpoints can be hit at the same time,
1223 causing GDB to stop. GDB only presents one hardware watchpoint
1224 hit at a time as the reason for stopping, and all the other hits
1225 are presented later, one after the other, each time the user
1226 requests the execution to be resumed. Execution is not resumed
1227 for the threads still having pending hit event stored in
1228 LWP_INFO->STATUS. While the watchpoint is already removed from
1229 the inferior on the first stop the thread hit event is kept being
1230 reported from its cached value by linux_nat_stopped_data_address
1231 until the real thread resume happens after the watchpoint gets
1232 presented and thus its LWP_INFO->STATUS gets reset.
1234 Therefore the hardware watchpoint hit can get safely reset on the
1235 watchpoint removal from inferior. */
1238 update_watchpoint (struct breakpoint
*b
, int reparse
)
1240 int within_current_scope
;
1241 struct frame_id saved_frame_id
;
1244 gdb_assert (is_watchpoint (b
));
1246 /* If this is a local watchpoint, we only want to check if the
1247 watchpoint frame is in scope if the current thread is the thread
1248 that was used to create the watchpoint. */
1249 if (!watchpoint_in_thread_scope (b
))
1252 if (b
->disposition
== disp_del_at_next_stop
)
1257 /* Determine if the watchpoint is within scope. */
1258 if (b
->exp_valid_block
== NULL
)
1259 within_current_scope
= 1;
1262 struct frame_info
*fi
= get_current_frame ();
1263 struct gdbarch
*frame_arch
= get_frame_arch (fi
);
1264 CORE_ADDR frame_pc
= get_frame_pc (fi
);
1266 /* If we're in a function epilogue, unwinding may not work
1267 properly, so do not attempt to recreate locations at this
1268 point. See similar comments in watchpoint_check. */
1269 if (gdbarch_in_function_epilogue_p (frame_arch
, frame_pc
))
1272 /* Save the current frame's ID so we can restore it after
1273 evaluating the watchpoint expression on its own frame. */
1274 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
1275 took a frame parameter, so that we didn't have to change the
1278 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
1280 fi
= frame_find_by_id (b
->watchpoint_frame
);
1281 within_current_scope
= (fi
!= NULL
);
1282 if (within_current_scope
)
1286 /* We don't free locations. They are stored in the bp_location array
1287 and update_global_location_list will eventually delete them and
1288 remove breakpoints if needed. */
1291 if (within_current_scope
&& reparse
)
1300 s
= b
->exp_string_reparse
? b
->exp_string_reparse
: b
->exp_string
;
1301 b
->exp
= parse_exp_1 (&s
, b
->exp_valid_block
, 0);
1302 /* If the meaning of expression itself changed, the old value is
1303 no longer relevant. We don't want to report a watchpoint hit
1304 to the user when the old value and the new value may actually
1305 be completely different objects. */
1306 value_free (b
->val
);
1310 /* Note that unlike with breakpoints, the watchpoint's condition
1311 expression is stored in the breakpoint object, not in the
1312 locations (re)created below. */
1313 if (b
->cond_string
!= NULL
)
1315 if (b
->cond_exp
!= NULL
)
1317 xfree (b
->cond_exp
);
1322 b
->cond_exp
= parse_exp_1 (&s
, b
->cond_exp_valid_block
, 0);
1326 /* If we failed to parse the expression, for example because
1327 it refers to a global variable in a not-yet-loaded shared library,
1328 don't try to insert watchpoint. We don't automatically delete
1329 such watchpoint, though, since failure to parse expression
1330 is different from out-of-scope watchpoint. */
1331 if ( !target_has_execution
)
1333 /* Without execution, memory can't change. No use to try and
1334 set watchpoint locations. The watchpoint will be reset when
1335 the target gains execution, through breakpoint_re_set. */
1337 else if (within_current_scope
&& b
->exp
)
1340 struct value
*val_chain
, *v
, *result
, *next
;
1341 struct program_space
*frame_pspace
;
1343 fetch_subexp_value (b
->exp
, &pc
, &v
, &result
, &val_chain
);
1345 /* Avoid setting b->val if it's already set. The meaning of
1346 b->val is 'the last value' user saw, and we should update
1347 it only if we reported that last value to user. As it
1348 happens, the code that reports it updates b->val directly. */
1355 frame_pspace
= get_frame_program_space (get_selected_frame (NULL
));
1357 /* Look at each value on the value chain. */
1358 for (v
= val_chain
; v
; v
= value_next (v
))
1360 /* If it's a memory location, and GDB actually needed
1361 its contents to evaluate the expression, then we
1362 must watch it. If the first value returned is
1363 still lazy, that means an error occurred reading it;
1364 watch it anyway in case it becomes readable. */
1365 if (VALUE_LVAL (v
) == lval_memory
1366 && (v
== val_chain
|| ! value_lazy (v
)))
1368 struct type
*vtype
= check_typedef (value_type (v
));
1370 /* We only watch structs and arrays if user asked
1371 for it explicitly, never if they just happen to
1372 appear in the middle of some value chain. */
1374 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
1375 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
1379 struct bp_location
*loc
, **tmp
;
1381 addr
= value_address (v
);
1382 len
= TYPE_LENGTH (value_type (v
));
1384 if (b
->type
== bp_read_watchpoint
)
1386 else if (b
->type
== bp_access_watchpoint
)
1389 loc
= allocate_bp_location (b
);
1390 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
1393 loc
->gdbarch
= get_type_arch (value_type (v
));
1395 loc
->pspace
= frame_pspace
;
1396 loc
->address
= addr
;
1398 loc
->watchpoint_type
= type
;
1403 /* Change the type of breakpoint between hardware assisted or
1404 an ordinary watchpoint depending on the hardware support
1405 and free hardware slots. REPARSE is set when the inferior
1407 if ((b
->type
== bp_watchpoint
|| b
->type
== bp_hardware_watchpoint
)
1411 enum bp_loc_type loc_type
;
1412 struct bp_location
*bl
;
1414 reg_cnt
= can_use_hardware_watchpoint (val_chain
, b
->exact
);
1418 int i
, target_resources_ok
, other_type_used
;
1419 enum enable_state orig_enable_state
;
1421 /* We need to determine how many resources are already
1422 used for all other hardware watchpoints plus this one
1423 to see if we still have enough resources to also fit
1424 this watchpoint in as well. To guarantee the
1425 hw_watchpoint_used_count call below counts this
1426 watchpoint, make sure that it is marked as a hardware
1428 b
->type
= bp_hardware_watchpoint
;
1430 /* hw_watchpoint_used_count ignores disabled watchpoints,
1431 and b might be disabled if we're being called from
1432 do_enable_breakpoint. */
1433 orig_enable_state
= b
->enable_state
;
1434 b
->enable_state
= bp_enabled
;
1436 i
= hw_watchpoint_used_count (bp_hardware_watchpoint
,
1439 b
->enable_state
= orig_enable_state
;
1441 target_resources_ok
= target_can_use_hardware_watchpoint
1442 (bp_hardware_watchpoint
, i
, other_type_used
);
1443 if (target_resources_ok
<= 0)
1444 b
->type
= bp_watchpoint
;
1447 b
->type
= bp_watchpoint
;
1449 loc_type
= (b
->type
== bp_watchpoint
? bp_loc_other
1450 : bp_loc_hardware_watchpoint
);
1451 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
1452 bl
->loc_type
= loc_type
;
1455 for (v
= val_chain
; v
; v
= next
)
1457 next
= value_next (v
);
1462 /* If a software watchpoint is not watching any memory, then the
1463 above left it without any location set up. But,
1464 bpstat_stop_status requires a location to be able to report
1465 stops, so make sure there's at least a dummy one. */
1466 if (b
->type
== bp_watchpoint
&& b
->loc
== NULL
)
1468 b
->loc
= allocate_bp_location (b
);
1469 b
->loc
->pspace
= frame_pspace
;
1470 b
->loc
->address
= -1;
1471 b
->loc
->length
= -1;
1472 b
->loc
->watchpoint_type
= -1;
1475 else if (!within_current_scope
)
1477 printf_filtered (_("\
1478 Watchpoint %d deleted because the program has left the block\n\
1479 in which its expression is valid.\n"),
1481 watchpoint_del_at_next_stop (b
);
1484 /* Restore the selected frame. */
1486 select_frame (frame_find_by_id (saved_frame_id
));
1490 /* Returns 1 iff breakpoint location should be
1491 inserted in the inferior. */
1493 should_be_inserted (struct bp_location
*bl
)
1495 if (bl
->owner
== NULL
|| !breakpoint_enabled (bl
->owner
))
1498 if (bl
->owner
->disposition
== disp_del_at_next_stop
)
1501 if (!bl
->enabled
|| bl
->shlib_disabled
|| bl
->duplicate
)
1504 /* This is set for example, when we're attached to the parent of a
1505 vfork, and have detached from the child. The child is running
1506 free, and we expect it to do an exec or exit, at which point the
1507 OS makes the parent schedulable again (and the target reports
1508 that the vfork is done). Until the child is done with the shared
1509 memory region, do not insert breakpoints in the parent, otherwise
1510 the child could still trip on the parent's breakpoints. Since
1511 the parent is blocked anyway, it won't miss any breakpoint. */
1512 if (bl
->pspace
->breakpoints_not_allowed
)
1515 /* Tracepoints are inserted by the target at a time of its choosing,
1517 if (is_tracepoint (bl
->owner
))
1523 /* Insert a low-level "breakpoint" of some type. BL is the breakpoint
1524 location. Any error messages are printed to TMP_ERROR_STREAM; and
1525 DISABLED_BREAKS, and HW_BREAKPOINT_ERROR are used to report problems.
1527 NOTE drow/2003-09-09: This routine could be broken down to an
1528 object-style method for each breakpoint or catchpoint type. */
1530 insert_bp_location (struct bp_location
*bl
,
1531 struct ui_file
*tmp_error_stream
,
1532 int *disabled_breaks
,
1533 int *hw_breakpoint_error
)
1537 if (!should_be_inserted (bl
) || bl
->inserted
)
1540 /* Initialize the target-specific information. */
1541 memset (&bl
->target_info
, 0, sizeof (bl
->target_info
));
1542 bl
->target_info
.placed_address
= bl
->address
;
1543 bl
->target_info
.placed_address_space
= bl
->pspace
->aspace
;
1544 bl
->target_info
.length
= bl
->length
;
1546 if (bl
->loc_type
== bp_loc_software_breakpoint
1547 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
1549 if (bl
->owner
->type
!= bp_hardware_breakpoint
)
1551 /* If the explicitly specified breakpoint type
1552 is not hardware breakpoint, check the memory map to see
1553 if the breakpoint address is in read only memory or not.
1555 Two important cases are:
1556 - location type is not hardware breakpoint, memory
1557 is readonly. We change the type of the location to
1558 hardware breakpoint.
1559 - location type is hardware breakpoint, memory is
1560 read-write. This means we've previously made the
1561 location hardware one, but then the memory map changed,
1564 When breakpoints are removed, remove_breakpoints will use
1565 location types we've just set here, the only possible
1566 problem is that memory map has changed during running
1567 program, but it's not going to work anyway with current
1569 struct mem_region
*mr
1570 = lookup_mem_region (bl
->target_info
.placed_address
);
1574 if (automatic_hardware_breakpoints
)
1576 enum bp_loc_type new_type
;
1578 if (mr
->attrib
.mode
!= MEM_RW
)
1579 new_type
= bp_loc_hardware_breakpoint
;
1581 new_type
= bp_loc_software_breakpoint
;
1583 if (new_type
!= bl
->loc_type
)
1585 static int said
= 0;
1587 bl
->loc_type
= new_type
;
1590 fprintf_filtered (gdb_stdout
,
1591 _("Note: automatically using "
1592 "hardware breakpoints for "
1593 "read-only addresses.\n"));
1598 else if (bl
->loc_type
== bp_loc_software_breakpoint
1599 && mr
->attrib
.mode
!= MEM_RW
)
1600 warning (_("cannot set software breakpoint "
1601 "at readonly address %s"),
1602 paddress (bl
->gdbarch
, bl
->address
));
1606 /* First check to see if we have to handle an overlay. */
1607 if (overlay_debugging
== ovly_off
1608 || bl
->section
== NULL
1609 || !(section_is_overlay (bl
->section
)))
1611 /* No overlay handling: just set the breakpoint. */
1613 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
1614 val
= target_insert_hw_breakpoint (bl
->gdbarch
,
1617 val
= target_insert_breakpoint (bl
->gdbarch
,
1622 /* This breakpoint is in an overlay section.
1623 Shall we set a breakpoint at the LMA? */
1624 if (!overlay_events_enabled
)
1626 /* Yes -- overlay event support is not active,
1627 so we must try to set a breakpoint at the LMA.
1628 This will not work for a hardware breakpoint. */
1629 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
1630 warning (_("hardware breakpoint %d not supported in overlay!"),
1634 CORE_ADDR addr
= overlay_unmapped_address (bl
->address
,
1636 /* Set a software (trap) breakpoint at the LMA. */
1637 bl
->overlay_target_info
= bl
->target_info
;
1638 bl
->overlay_target_info
.placed_address
= addr
;
1639 val
= target_insert_breakpoint (bl
->gdbarch
,
1640 &bl
->overlay_target_info
);
1642 fprintf_unfiltered (tmp_error_stream
,
1643 "Overlay breakpoint %d "
1644 "failed: in ROM?\n",
1648 /* Shall we set a breakpoint at the VMA? */
1649 if (section_is_mapped (bl
->section
))
1651 /* Yes. This overlay section is mapped into memory. */
1652 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
1653 val
= target_insert_hw_breakpoint (bl
->gdbarch
,
1656 val
= target_insert_breakpoint (bl
->gdbarch
,
1661 /* No. This breakpoint will not be inserted.
1662 No error, but do not mark the bp as 'inserted'. */
1669 /* Can't set the breakpoint. */
1670 if (solib_name_from_address (bl
->pspace
, bl
->address
))
1672 /* See also: disable_breakpoints_in_shlibs. */
1674 bl
->shlib_disabled
= 1;
1675 if (!*disabled_breaks
)
1677 fprintf_unfiltered (tmp_error_stream
,
1678 "Cannot insert breakpoint %d.\n",
1680 fprintf_unfiltered (tmp_error_stream
,
1681 "Temporarily disabling shared "
1682 "library breakpoints:\n");
1684 *disabled_breaks
= 1;
1685 fprintf_unfiltered (tmp_error_stream
,
1686 "breakpoint #%d\n", bl
->owner
->number
);
1690 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
1692 *hw_breakpoint_error
= 1;
1693 fprintf_unfiltered (tmp_error_stream
,
1694 "Cannot insert hardware "
1700 fprintf_unfiltered (tmp_error_stream
,
1701 "Cannot insert breakpoint %d.\n",
1703 fprintf_filtered (tmp_error_stream
,
1704 "Error accessing memory address ");
1705 fputs_filtered (paddress (bl
->gdbarch
, bl
->address
),
1707 fprintf_filtered (tmp_error_stream
, ": %s.\n",
1708 safe_strerror (val
));
1719 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
1720 /* NOTE drow/2003-09-08: This state only exists for removing
1721 watchpoints. It's not clear that it's necessary... */
1722 && bl
->owner
->disposition
!= disp_del_at_next_stop
)
1724 gdb_assert (bl
->owner
->ops
!= NULL
1725 && bl
->owner
->ops
->insert_location
!= NULL
);
1727 val
= bl
->owner
->ops
->insert_location (bl
);
1729 /* If trying to set a read-watchpoint, and it turns out it's not
1730 supported, try emulating one with an access watchpoint. */
1731 if (val
== 1 && bl
->watchpoint_type
== hw_read
)
1733 struct bp_location
*loc
, **loc_temp
;
1735 /* But don't try to insert it, if there's already another
1736 hw_access location that would be considered a duplicate
1738 ALL_BP_LOCATIONS (loc
, loc_temp
)
1740 && loc
->watchpoint_type
== hw_access
1741 && watchpoint_locations_match (bl
, loc
))
1745 bl
->target_info
= loc
->target_info
;
1746 bl
->watchpoint_type
= hw_access
;
1753 bl
->watchpoint_type
= hw_access
;
1754 val
= bl
->owner
->ops
->insert_location (bl
);
1757 /* Back to the original value. */
1758 bl
->watchpoint_type
= hw_read
;
1762 bl
->inserted
= (val
== 0);
1765 else if (bl
->owner
->type
== bp_catchpoint
)
1767 gdb_assert (bl
->owner
->ops
!= NULL
1768 && bl
->owner
->ops
->insert_location
!= NULL
);
1770 val
= bl
->owner
->ops
->insert_location (bl
);
1773 bl
->owner
->enable_state
= bp_disabled
;
1777 Error inserting catchpoint %d: Your system does not support this type\n\
1778 of catchpoint."), bl
->owner
->number
);
1780 warning (_("Error inserting catchpoint %d."), bl
->owner
->number
);
1783 bl
->inserted
= (val
== 0);
1785 /* We've already printed an error message if there was a problem
1786 inserting this catchpoint, and we've disabled the catchpoint,
1787 so just return success. */
1794 /* This function is called when program space PSPACE is about to be
1795 deleted. It takes care of updating breakpoints to not reference
1799 breakpoint_program_space_exit (struct program_space
*pspace
)
1801 struct breakpoint
*b
, *b_temp
;
1802 struct bp_location
*loc
, **loc_temp
;
1804 /* Remove any breakpoint that was set through this program space. */
1805 ALL_BREAKPOINTS_SAFE (b
, b_temp
)
1807 if (b
->pspace
== pspace
)
1808 delete_breakpoint (b
);
1811 /* Breakpoints set through other program spaces could have locations
1812 bound to PSPACE as well. Remove those. */
1813 ALL_BP_LOCATIONS (loc
, loc_temp
)
1815 struct bp_location
*tmp
;
1817 if (loc
->pspace
== pspace
)
1819 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
1820 if (loc
->owner
->loc
== loc
)
1821 loc
->owner
->loc
= loc
->next
;
1823 for (tmp
= loc
->owner
->loc
; tmp
->next
!= NULL
; tmp
= tmp
->next
)
1824 if (tmp
->next
== loc
)
1826 tmp
->next
= loc
->next
;
1832 /* Now update the global location list to permanently delete the
1833 removed locations above. */
1834 update_global_location_list (0);
1837 /* Make sure all breakpoints are inserted in inferior.
1838 Throws exception on any error.
1839 A breakpoint that is already inserted won't be inserted
1840 again, so calling this function twice is safe. */
1842 insert_breakpoints (void)
1844 struct breakpoint
*bpt
;
1846 ALL_BREAKPOINTS (bpt
)
1847 if (is_hardware_watchpoint (bpt
))
1848 update_watchpoint (bpt
, 0 /* don't reparse. */);
1850 update_global_location_list (1);
1852 /* update_global_location_list does not insert breakpoints when
1853 always_inserted_mode is not enabled. Explicitly insert them
1855 if (!breakpoints_always_inserted_mode ())
1856 insert_breakpoint_locations ();
1859 /* insert_breakpoints is used when starting or continuing the program.
1860 remove_breakpoints is used when the program stops.
1861 Both return zero if successful,
1862 or an `errno' value if could not write the inferior. */
1865 insert_breakpoint_locations (void)
1867 struct breakpoint
*bpt
;
1868 struct bp_location
*bl
, **blp_tmp
;
1871 int disabled_breaks
= 0;
1872 int hw_breakpoint_error
= 0;
1874 struct ui_file
*tmp_error_stream
= mem_fileopen ();
1875 struct cleanup
*cleanups
= make_cleanup_ui_file_delete (tmp_error_stream
);
1877 /* Explicitly mark the warning -- this will only be printed if
1878 there was an error. */
1879 fprintf_unfiltered (tmp_error_stream
, "Warning:\n");
1881 save_current_space_and_thread ();
1883 ALL_BP_LOCATIONS (bl
, blp_tmp
)
1885 if (!should_be_inserted (bl
) || bl
->inserted
)
1888 /* There is no point inserting thread-specific breakpoints if
1889 the thread no longer exists. ALL_BP_LOCATIONS bp_location
1890 has BL->OWNER always non-NULL. */
1891 if (bl
->owner
->thread
!= -1
1892 && !valid_thread_id (bl
->owner
->thread
))
1895 switch_to_program_space_and_thread (bl
->pspace
);
1897 /* For targets that support global breakpoints, there's no need
1898 to select an inferior to insert breakpoint to. In fact, even
1899 if we aren't attached to any process yet, we should still
1900 insert breakpoints. */
1901 if (!gdbarch_has_global_breakpoints (target_gdbarch
)
1902 && ptid_equal (inferior_ptid
, null_ptid
))
1905 val
= insert_bp_location (bl
, tmp_error_stream
, &disabled_breaks
,
1906 &hw_breakpoint_error
);
1911 /* If we failed to insert all locations of a watchpoint, remove
1912 them, as half-inserted watchpoint is of limited use. */
1913 ALL_BREAKPOINTS (bpt
)
1915 int some_failed
= 0;
1916 struct bp_location
*loc
;
1918 if (!is_hardware_watchpoint (bpt
))
1921 if (!breakpoint_enabled (bpt
))
1924 if (bpt
->disposition
== disp_del_at_next_stop
)
1927 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
1928 if (!loc
->inserted
&& should_be_inserted (loc
))
1935 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
1937 remove_breakpoint (loc
, mark_uninserted
);
1939 hw_breakpoint_error
= 1;
1940 fprintf_unfiltered (tmp_error_stream
,
1941 "Could not insert hardware watchpoint %d.\n",
1949 /* If a hardware breakpoint or watchpoint was inserted, add a
1950 message about possibly exhausted resources. */
1951 if (hw_breakpoint_error
)
1953 fprintf_unfiltered (tmp_error_stream
,
1954 "Could not insert hardware breakpoints:\n\
1955 You may have requested too many hardware breakpoints/watchpoints.\n");
1957 target_terminal_ours_for_output ();
1958 error_stream (tmp_error_stream
);
1961 do_cleanups (cleanups
);
1965 remove_breakpoints (void)
1967 struct bp_location
*bl
, **blp_tmp
;
1970 ALL_BP_LOCATIONS (bl
, blp_tmp
)
1973 val
|= remove_breakpoint (bl
, mark_uninserted
);
1978 /* Remove breakpoints of process PID. */
1981 remove_breakpoints_pid (int pid
)
1983 struct bp_location
*bl
, **blp_tmp
;
1985 struct inferior
*inf
= find_inferior_pid (pid
);
1987 ALL_BP_LOCATIONS (bl
, blp_tmp
)
1989 if (bl
->pspace
!= inf
->pspace
)
1994 val
= remove_breakpoint (bl
, mark_uninserted
);
2003 remove_hw_watchpoints (void)
2005 struct bp_location
*bl
, **blp_tmp
;
2008 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2010 if (bl
->inserted
&& bl
->loc_type
== bp_loc_hardware_watchpoint
)
2011 val
|= remove_breakpoint (bl
, mark_uninserted
);
2017 reattach_breakpoints (int pid
)
2019 struct cleanup
*old_chain
;
2020 struct bp_location
*bl
, **blp_tmp
;
2022 struct ui_file
*tmp_error_stream
;
2023 int dummy1
= 0, dummy2
= 0;
2024 struct inferior
*inf
;
2025 struct thread_info
*tp
;
2027 tp
= any_live_thread_of_process (pid
);
2031 inf
= find_inferior_pid (pid
);
2032 old_chain
= save_inferior_ptid ();
2034 inferior_ptid
= tp
->ptid
;
2036 tmp_error_stream
= mem_fileopen ();
2037 make_cleanup_ui_file_delete (tmp_error_stream
);
2039 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2041 if (bl
->pspace
!= inf
->pspace
)
2047 val
= insert_bp_location (bl
, tmp_error_stream
, &dummy1
, &dummy2
);
2050 do_cleanups (old_chain
);
2055 do_cleanups (old_chain
);
2059 static int internal_breakpoint_number
= -1;
2061 /* Set the breakpoint number of B, depending on the value of INTERNAL.
2062 If INTERNAL is non-zero, the breakpoint number will be populated
2063 from internal_breakpoint_number and that variable decremented.
2064 Otherwis the breakpoint number will be populated from
2065 breakpoint_count and that value incremented. Internal breakpoints
2066 do not set the internal var bpnum. */
2068 set_breakpoint_number (int internal
, struct breakpoint
*b
)
2071 b
->number
= internal_breakpoint_number
--;
2074 set_breakpoint_count (breakpoint_count
+ 1);
2075 b
->number
= breakpoint_count
;
2079 static struct breakpoint
*
2080 create_internal_breakpoint (struct gdbarch
*gdbarch
,
2081 CORE_ADDR address
, enum bptype type
)
2083 struct symtab_and_line sal
;
2084 struct breakpoint
*b
;
2086 init_sal (&sal
); /* Initialize to zeroes. */
2089 sal
.section
= find_pc_overlay (sal
.pc
);
2090 sal
.pspace
= current_program_space
;
2092 b
= set_raw_breakpoint (gdbarch
, sal
, type
);
2093 b
->number
= internal_breakpoint_number
--;
2094 b
->disposition
= disp_donttouch
;
2099 static const char *const longjmp_names
[] =
2101 "longjmp", "_longjmp", "siglongjmp", "_siglongjmp"
2103 #define NUM_LONGJMP_NAMES ARRAY_SIZE(longjmp_names)
2105 /* Per-objfile data private to breakpoint.c. */
2106 struct breakpoint_objfile_data
2108 /* Minimal symbol for "_ovly_debug_event" (if any). */
2109 struct minimal_symbol
*overlay_msym
;
2111 /* Minimal symbol(s) for "longjmp", "siglongjmp", etc. (if any). */
2112 struct minimal_symbol
*longjmp_msym
[NUM_LONGJMP_NAMES
];
2114 /* Minimal symbol for "std::terminate()" (if any). */
2115 struct minimal_symbol
*terminate_msym
;
2117 /* Minimal symbol for "_Unwind_DebugHook" (if any). */
2118 struct minimal_symbol
*exception_msym
;
2121 static const struct objfile_data
*breakpoint_objfile_key
;
2123 /* Minimal symbol not found sentinel. */
2124 static struct minimal_symbol msym_not_found
;
2126 /* Returns TRUE if MSYM point to the "not found" sentinel. */
2129 msym_not_found_p (const struct minimal_symbol
*msym
)
2131 return msym
== &msym_not_found
;
2134 /* Return per-objfile data needed by breakpoint.c.
2135 Allocate the data if necessary. */
2137 static struct breakpoint_objfile_data
*
2138 get_breakpoint_objfile_data (struct objfile
*objfile
)
2140 struct breakpoint_objfile_data
*bp_objfile_data
;
2142 bp_objfile_data
= objfile_data (objfile
, breakpoint_objfile_key
);
2143 if (bp_objfile_data
== NULL
)
2145 bp_objfile_data
= obstack_alloc (&objfile
->objfile_obstack
,
2146 sizeof (*bp_objfile_data
));
2148 memset (bp_objfile_data
, 0, sizeof (*bp_objfile_data
));
2149 set_objfile_data (objfile
, breakpoint_objfile_key
, bp_objfile_data
);
2151 return bp_objfile_data
;
2155 create_overlay_event_breakpoint (void)
2157 struct objfile
*objfile
;
2158 const char *const func_name
= "_ovly_debug_event";
2160 ALL_OBJFILES (objfile
)
2162 struct breakpoint
*b
;
2163 struct breakpoint_objfile_data
*bp_objfile_data
;
2166 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
2168 if (msym_not_found_p (bp_objfile_data
->overlay_msym
))
2171 if (bp_objfile_data
->overlay_msym
== NULL
)
2173 struct minimal_symbol
*m
;
2175 m
= lookup_minimal_symbol_text (func_name
, objfile
);
2178 /* Avoid future lookups in this objfile. */
2179 bp_objfile_data
->overlay_msym
= &msym_not_found
;
2182 bp_objfile_data
->overlay_msym
= m
;
2185 addr
= SYMBOL_VALUE_ADDRESS (bp_objfile_data
->overlay_msym
);
2186 b
= create_internal_breakpoint (get_objfile_arch (objfile
), addr
,
2188 b
->addr_string
= xstrdup (func_name
);
2190 if (overlay_debugging
== ovly_auto
)
2192 b
->enable_state
= bp_enabled
;
2193 overlay_events_enabled
= 1;
2197 b
->enable_state
= bp_disabled
;
2198 overlay_events_enabled
= 0;
2201 update_global_location_list (1);
2205 create_longjmp_master_breakpoint (void)
2207 struct program_space
*pspace
;
2208 struct cleanup
*old_chain
;
2210 old_chain
= save_current_program_space ();
2212 ALL_PSPACES (pspace
)
2214 struct objfile
*objfile
;
2216 set_current_program_space (pspace
);
2218 ALL_OBJFILES (objfile
)
2221 struct gdbarch
*gdbarch
;
2222 struct breakpoint_objfile_data
*bp_objfile_data
;
2224 gdbarch
= get_objfile_arch (objfile
);
2225 if (!gdbarch_get_longjmp_target_p (gdbarch
))
2228 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
2230 for (i
= 0; i
< NUM_LONGJMP_NAMES
; i
++)
2232 struct breakpoint
*b
;
2233 const char *func_name
;
2236 if (msym_not_found_p (bp_objfile_data
->longjmp_msym
[i
]))
2239 func_name
= longjmp_names
[i
];
2240 if (bp_objfile_data
->longjmp_msym
[i
] == NULL
)
2242 struct minimal_symbol
*m
;
2244 m
= lookup_minimal_symbol_text (func_name
, objfile
);
2247 /* Prevent future lookups in this objfile. */
2248 bp_objfile_data
->longjmp_msym
[i
] = &msym_not_found
;
2251 bp_objfile_data
->longjmp_msym
[i
] = m
;
2254 addr
= SYMBOL_VALUE_ADDRESS (bp_objfile_data
->longjmp_msym
[i
]);
2255 b
= create_internal_breakpoint (gdbarch
, addr
, bp_longjmp_master
);
2256 b
->addr_string
= xstrdup (func_name
);
2257 b
->enable_state
= bp_disabled
;
2261 update_global_location_list (1);
2263 do_cleanups (old_chain
);
2266 /* Create a master std::terminate breakpoint. */
2268 create_std_terminate_master_breakpoint (void)
2270 struct program_space
*pspace
;
2271 struct cleanup
*old_chain
;
2272 const char *const func_name
= "std::terminate()";
2274 old_chain
= save_current_program_space ();
2276 ALL_PSPACES (pspace
)
2278 struct objfile
*objfile
;
2281 set_current_program_space (pspace
);
2283 ALL_OBJFILES (objfile
)
2285 struct breakpoint
*b
;
2286 struct breakpoint_objfile_data
*bp_objfile_data
;
2288 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
2290 if (msym_not_found_p (bp_objfile_data
->terminate_msym
))
2293 if (bp_objfile_data
->terminate_msym
== NULL
)
2295 struct minimal_symbol
*m
;
2297 m
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
2298 if (m
== NULL
|| (MSYMBOL_TYPE (m
) != mst_text
2299 && MSYMBOL_TYPE (m
) != mst_file_text
))
2301 /* Prevent future lookups in this objfile. */
2302 bp_objfile_data
->terminate_msym
= &msym_not_found
;
2305 bp_objfile_data
->terminate_msym
= m
;
2308 addr
= SYMBOL_VALUE_ADDRESS (bp_objfile_data
->terminate_msym
);
2309 b
= create_internal_breakpoint (get_objfile_arch (objfile
), addr
,
2310 bp_std_terminate_master
);
2311 b
->addr_string
= xstrdup (func_name
);
2312 b
->enable_state
= bp_disabled
;
2316 update_global_location_list (1);
2318 do_cleanups (old_chain
);
2321 /* Install a master breakpoint on the unwinder's debug hook. */
2324 create_exception_master_breakpoint (void)
2326 struct objfile
*objfile
;
2327 const char *const func_name
= "_Unwind_DebugHook";
2329 ALL_OBJFILES (objfile
)
2331 struct breakpoint
*b
;
2332 struct gdbarch
*gdbarch
;
2333 struct breakpoint_objfile_data
*bp_objfile_data
;
2336 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
2338 if (msym_not_found_p (bp_objfile_data
->exception_msym
))
2341 gdbarch
= get_objfile_arch (objfile
);
2343 if (bp_objfile_data
->exception_msym
== NULL
)
2345 struct minimal_symbol
*debug_hook
;
2347 debug_hook
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
2348 if (debug_hook
== NULL
)
2350 bp_objfile_data
->exception_msym
= &msym_not_found
;
2354 bp_objfile_data
->exception_msym
= debug_hook
;
2357 addr
= SYMBOL_VALUE_ADDRESS (bp_objfile_data
->exception_msym
);
2358 addr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, addr
,
2360 b
= create_internal_breakpoint (gdbarch
, addr
, bp_exception_master
);
2361 b
->addr_string
= xstrdup (func_name
);
2362 b
->enable_state
= bp_disabled
;
2365 update_global_location_list (1);
2369 update_breakpoints_after_exec (void)
2371 struct breakpoint
*b
, *b_tmp
;
2372 struct bp_location
*bploc
, **bplocp_tmp
;
2374 /* We're about to delete breakpoints from GDB's lists. If the
2375 INSERTED flag is true, GDB will try to lift the breakpoints by
2376 writing the breakpoints' "shadow contents" back into memory. The
2377 "shadow contents" are NOT valid after an exec, so GDB should not
2378 do that. Instead, the target is responsible from marking
2379 breakpoints out as soon as it detects an exec. We don't do that
2380 here instead, because there may be other attempts to delete
2381 breakpoints after detecting an exec and before reaching here. */
2382 ALL_BP_LOCATIONS (bploc
, bplocp_tmp
)
2383 if (bploc
->pspace
== current_program_space
)
2384 gdb_assert (!bploc
->inserted
);
2386 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
2388 if (b
->pspace
!= current_program_space
)
2391 /* Solib breakpoints must be explicitly reset after an exec(). */
2392 if (b
->type
== bp_shlib_event
)
2394 delete_breakpoint (b
);
2398 /* JIT breakpoints must be explicitly reset after an exec(). */
2399 if (b
->type
== bp_jit_event
)
2401 delete_breakpoint (b
);
2405 /* Thread event breakpoints must be set anew after an exec(),
2406 as must overlay event and longjmp master breakpoints. */
2407 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
2408 || b
->type
== bp_longjmp_master
|| b
->type
== bp_std_terminate_master
2409 || b
->type
== bp_exception_master
)
2411 delete_breakpoint (b
);
2415 /* Step-resume breakpoints are meaningless after an exec(). */
2416 if (b
->type
== bp_step_resume
)
2418 delete_breakpoint (b
);
2422 /* Longjmp and longjmp-resume breakpoints are also meaningless
2424 if (b
->type
== bp_longjmp
|| b
->type
== bp_longjmp_resume
2425 || b
->type
== bp_exception
|| b
->type
== bp_exception_resume
)
2427 delete_breakpoint (b
);
2431 if (b
->type
== bp_catchpoint
)
2433 /* For now, none of the bp_catchpoint breakpoints need to
2434 do anything at this point. In the future, if some of
2435 the catchpoints need to something, we will need to add
2436 a new method, and call this method from here. */
2440 /* bp_finish is a special case. The only way we ought to be able
2441 to see one of these when an exec() has happened, is if the user
2442 caught a vfork, and then said "finish". Ordinarily a finish just
2443 carries them to the call-site of the current callee, by setting
2444 a temporary bp there and resuming. But in this case, the finish
2445 will carry them entirely through the vfork & exec.
2447 We don't want to allow a bp_finish to remain inserted now. But
2448 we can't safely delete it, 'cause finish_command has a handle to
2449 the bp on a bpstat, and will later want to delete it. There's a
2450 chance (and I've seen it happen) that if we delete the bp_finish
2451 here, that its storage will get reused by the time finish_command
2452 gets 'round to deleting the "use to be a bp_finish" breakpoint.
2453 We really must allow finish_command to delete a bp_finish.
2455 In the absense of a general solution for the "how do we know
2456 it's safe to delete something others may have handles to?"
2457 problem, what we'll do here is just uninsert the bp_finish, and
2458 let finish_command delete it.
2460 (We know the bp_finish is "doomed" in the sense that it's
2461 momentary, and will be deleted as soon as finish_command sees
2462 the inferior stopped. So it doesn't matter that the bp's
2463 address is probably bogus in the new a.out, unlike e.g., the
2464 solib breakpoints.) */
2466 if (b
->type
== bp_finish
)
2471 /* Without a symbolic address, we have little hope of the
2472 pre-exec() address meaning the same thing in the post-exec()
2474 if (b
->addr_string
== NULL
)
2476 delete_breakpoint (b
);
2480 /* FIXME what about longjmp breakpoints? Re-create them here? */
2481 create_overlay_event_breakpoint ();
2482 create_longjmp_master_breakpoint ();
2483 create_std_terminate_master_breakpoint ();
2484 create_exception_master_breakpoint ();
2488 detach_breakpoints (int pid
)
2490 struct bp_location
*bl
, **blp_tmp
;
2492 struct cleanup
*old_chain
= save_inferior_ptid ();
2493 struct inferior
*inf
= current_inferior ();
2495 if (pid
== PIDGET (inferior_ptid
))
2496 error (_("Cannot detach breakpoints of inferior_ptid"));
2498 /* Set inferior_ptid; remove_breakpoint_1 uses this global. */
2499 inferior_ptid
= pid_to_ptid (pid
);
2500 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2502 if (bl
->pspace
!= inf
->pspace
)
2506 val
|= remove_breakpoint_1 (bl
, mark_inserted
);
2509 /* Detach single-step breakpoints as well. */
2510 detach_single_step_breakpoints ();
2512 do_cleanups (old_chain
);
2516 /* Remove the breakpoint location BL from the current address space.
2517 Note that this is used to detach breakpoints from a child fork.
2518 When we get here, the child isn't in the inferior list, and neither
2519 do we have objects to represent its address space --- we should
2520 *not* look at bl->pspace->aspace here. */
2523 remove_breakpoint_1 (struct bp_location
*bl
, insertion_state_t is
)
2527 /* BL is never in moribund_locations by our callers. */
2528 gdb_assert (bl
->owner
!= NULL
);
2530 if (bl
->owner
->enable_state
== bp_permanent
)
2531 /* Permanent breakpoints cannot be inserted or removed. */
2534 /* The type of none suggests that owner is actually deleted.
2535 This should not ever happen. */
2536 gdb_assert (bl
->owner
->type
!= bp_none
);
2538 if (bl
->loc_type
== bp_loc_software_breakpoint
2539 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
2541 /* "Normal" instruction breakpoint: either the standard
2542 trap-instruction bp (bp_breakpoint), or a
2543 bp_hardware_breakpoint. */
2545 /* First check to see if we have to handle an overlay. */
2546 if (overlay_debugging
== ovly_off
2547 || bl
->section
== NULL
2548 || !(section_is_overlay (bl
->section
)))
2550 /* No overlay handling: just remove the breakpoint. */
2552 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
2553 val
= target_remove_hw_breakpoint (bl
->gdbarch
, &bl
->target_info
);
2555 val
= target_remove_breakpoint (bl
->gdbarch
, &bl
->target_info
);
2559 /* This breakpoint is in an overlay section.
2560 Did we set a breakpoint at the LMA? */
2561 if (!overlay_events_enabled
)
2563 /* Yes -- overlay event support is not active, so we
2564 should have set a breakpoint at the LMA. Remove it.
2566 /* Ignore any failures: if the LMA is in ROM, we will
2567 have already warned when we failed to insert it. */
2568 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
2569 target_remove_hw_breakpoint (bl
->gdbarch
,
2570 &bl
->overlay_target_info
);
2572 target_remove_breakpoint (bl
->gdbarch
,
2573 &bl
->overlay_target_info
);
2575 /* Did we set a breakpoint at the VMA?
2576 If so, we will have marked the breakpoint 'inserted'. */
2579 /* Yes -- remove it. Previously we did not bother to
2580 remove the breakpoint if the section had been
2581 unmapped, but let's not rely on that being safe. We
2582 don't know what the overlay manager might do. */
2583 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
2584 val
= target_remove_hw_breakpoint (bl
->gdbarch
,
2587 /* However, we should remove *software* breakpoints only
2588 if the section is still mapped, or else we overwrite
2589 wrong code with the saved shadow contents. */
2590 else if (section_is_mapped (bl
->section
))
2591 val
= target_remove_breakpoint (bl
->gdbarch
,
2598 /* No -- not inserted, so no need to remove. No error. */
2603 /* In some cases, we might not be able to remove a breakpoint
2604 in a shared library that has already been removed, but we
2605 have not yet processed the shlib unload event. */
2606 if (val
&& solib_name_from_address (bl
->pspace
, bl
->address
))
2611 bl
->inserted
= (is
== mark_inserted
);
2613 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
)
2615 gdb_assert (bl
->owner
->ops
!= NULL
2616 && bl
->owner
->ops
->remove_location
!= NULL
);
2618 bl
->inserted
= (is
== mark_inserted
);
2619 bl
->owner
->ops
->remove_location (bl
);
2621 /* Failure to remove any of the hardware watchpoints comes here. */
2622 if ((is
== mark_uninserted
) && (bl
->inserted
))
2623 warning (_("Could not remove hardware watchpoint %d."),
2626 else if (bl
->owner
->type
== bp_catchpoint
2627 && breakpoint_enabled (bl
->owner
)
2630 gdb_assert (bl
->owner
->ops
!= NULL
2631 && bl
->owner
->ops
->remove_location
!= NULL
);
2633 val
= bl
->owner
->ops
->remove_location (bl
);
2637 bl
->inserted
= (is
== mark_inserted
);
2644 remove_breakpoint (struct bp_location
*bl
, insertion_state_t is
)
2647 struct cleanup
*old_chain
;
2649 /* BL is never in moribund_locations by our callers. */
2650 gdb_assert (bl
->owner
!= NULL
);
2652 if (bl
->owner
->enable_state
== bp_permanent
)
2653 /* Permanent breakpoints cannot be inserted or removed. */
2656 /* The type of none suggests that owner is actually deleted.
2657 This should not ever happen. */
2658 gdb_assert (bl
->owner
->type
!= bp_none
);
2660 old_chain
= save_current_space_and_thread ();
2662 switch_to_program_space_and_thread (bl
->pspace
);
2664 ret
= remove_breakpoint_1 (bl
, is
);
2666 do_cleanups (old_chain
);
2670 /* Clear the "inserted" flag in all breakpoints. */
2673 mark_breakpoints_out (void)
2675 struct bp_location
*bl
, **blp_tmp
;
2677 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2678 if (bl
->pspace
== current_program_space
)
2682 /* Clear the "inserted" flag in all breakpoints and delete any
2683 breakpoints which should go away between runs of the program.
2685 Plus other such housekeeping that has to be done for breakpoints
2688 Note: this function gets called at the end of a run (by
2689 generic_mourn_inferior) and when a run begins (by
2690 init_wait_for_inferior). */
2695 breakpoint_init_inferior (enum inf_context context
)
2697 struct breakpoint
*b
, *b_tmp
;
2698 struct bp_location
*bl
, **blp_tmp
;
2700 struct program_space
*pspace
= current_program_space
;
2702 /* If breakpoint locations are shared across processes, then there's
2704 if (gdbarch_has_global_breakpoints (target_gdbarch
))
2707 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2709 /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
2710 if (bl
->pspace
== pspace
2711 && bl
->owner
->enable_state
!= bp_permanent
)
2715 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
2717 if (b
->loc
&& b
->loc
->pspace
!= pspace
)
2724 /* If the call dummy breakpoint is at the entry point it will
2725 cause problems when the inferior is rerun, so we better get
2728 case bp_watchpoint_scope
:
2730 /* Also get rid of scope breakpoints. */
2732 case bp_shlib_event
:
2734 /* Also remove solib event breakpoints. Their addresses may
2735 have changed since the last time we ran the program.
2736 Actually we may now be debugging against different target;
2737 and so the solib backend that installed this breakpoint may
2738 not be used in by the target. E.g.,
2740 (gdb) file prog-linux
2741 (gdb) run # native linux target
2744 (gdb) file prog-win.exe
2745 (gdb) tar rem :9999 # remote Windows gdbserver.
2748 delete_breakpoint (b
);
2752 case bp_hardware_watchpoint
:
2753 case bp_read_watchpoint
:
2754 case bp_access_watchpoint
:
2756 /* Likewise for watchpoints on local expressions. */
2757 if (b
->exp_valid_block
!= NULL
)
2758 delete_breakpoint (b
);
2759 else if (context
== inf_starting
)
2761 /* Reset val field to force reread of starting value in
2762 insert_breakpoints. */
2764 value_free (b
->val
);
2774 /* Get rid of the moribund locations. */
2775 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, bl
); ++ix
)
2776 decref_bp_location (&bl
);
2777 VEC_free (bp_location_p
, moribund_locations
);
2780 /* These functions concern about actual breakpoints inserted in the
2781 target --- to e.g. check if we need to do decr_pc adjustment or if
2782 we need to hop over the bkpt --- so we check for address space
2783 match, not program space. */
2785 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
2786 exists at PC. It returns ordinary_breakpoint_here if it's an
2787 ordinary breakpoint, or permanent_breakpoint_here if it's a
2788 permanent breakpoint.
2789 - When continuing from a location with an ordinary breakpoint, we
2790 actually single step once before calling insert_breakpoints.
2791 - When continuing from a localion with a permanent breakpoint, we
2792 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
2793 the target, to advance the PC past the breakpoint. */
2795 enum breakpoint_here
2796 breakpoint_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2798 struct bp_location
*bl
, **blp_tmp
;
2799 int any_breakpoint_here
= 0;
2801 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2803 if (bl
->loc_type
!= bp_loc_software_breakpoint
2804 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
2807 /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
2808 if ((breakpoint_enabled (bl
->owner
)
2809 || bl
->owner
->enable_state
== bp_permanent
)
2810 && breakpoint_location_address_match (bl
, aspace
, pc
))
2812 if (overlay_debugging
2813 && section_is_overlay (bl
->section
)
2814 && !section_is_mapped (bl
->section
))
2815 continue; /* unmapped overlay -- can't be a match */
2816 else if (bl
->owner
->enable_state
== bp_permanent
)
2817 return permanent_breakpoint_here
;
2819 any_breakpoint_here
= 1;
2823 return any_breakpoint_here
? ordinary_breakpoint_here
: 0;
2826 /* Return true if there's a moribund breakpoint at PC. */
2829 moribund_breakpoint_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2831 struct bp_location
*loc
;
2834 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
2835 if (breakpoint_location_address_match (loc
, aspace
, pc
))
2841 /* Returns non-zero if there's a breakpoint inserted at PC, which is
2842 inserted using regular breakpoint_chain / bp_location array
2843 mechanism. This does not check for single-step breakpoints, which
2844 are inserted and removed using direct target manipulation. */
2847 regular_breakpoint_inserted_here_p (struct address_space
*aspace
,
2850 struct bp_location
*bl
, **blp_tmp
;
2852 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2854 if (bl
->loc_type
!= bp_loc_software_breakpoint
2855 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
2859 && breakpoint_location_address_match (bl
, aspace
, pc
))
2861 if (overlay_debugging
2862 && section_is_overlay (bl
->section
)
2863 && !section_is_mapped (bl
->section
))
2864 continue; /* unmapped overlay -- can't be a match */
2872 /* Returns non-zero iff there's either regular breakpoint
2873 or a single step breakpoint inserted at PC. */
2876 breakpoint_inserted_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2878 if (regular_breakpoint_inserted_here_p (aspace
, pc
))
2881 if (single_step_breakpoint_inserted_here_p (aspace
, pc
))
2887 /* This function returns non-zero iff there is a software breakpoint
2891 software_breakpoint_inserted_here_p (struct address_space
*aspace
,
2894 struct bp_location
*bl
, **blp_tmp
;
2896 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2898 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
2902 && breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
2905 if (overlay_debugging
2906 && section_is_overlay (bl
->section
)
2907 && !section_is_mapped (bl
->section
))
2908 continue; /* unmapped overlay -- can't be a match */
2914 /* Also check for software single-step breakpoints. */
2915 if (single_step_breakpoint_inserted_here_p (aspace
, pc
))
2922 hardware_watchpoint_inserted_in_range (struct address_space
*aspace
,
2923 CORE_ADDR addr
, ULONGEST len
)
2925 struct breakpoint
*bpt
;
2927 ALL_BREAKPOINTS (bpt
)
2929 struct bp_location
*loc
;
2931 if (bpt
->type
!= bp_hardware_watchpoint
2932 && bpt
->type
!= bp_access_watchpoint
)
2935 if (!breakpoint_enabled (bpt
))
2938 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
2939 if (loc
->pspace
->aspace
== aspace
&& loc
->inserted
)
2943 /* Check for intersection. */
2944 l
= max (loc
->address
, addr
);
2945 h
= min (loc
->address
+ loc
->length
, addr
+ len
);
2953 /* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
2954 PC is valid for process/thread PTID. */
2957 breakpoint_thread_match (struct address_space
*aspace
, CORE_ADDR pc
,
2960 struct bp_location
*bl
, **blp_tmp
;
2961 /* The thread and task IDs associated to PTID, computed lazily. */
2965 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2967 if (bl
->loc_type
!= bp_loc_software_breakpoint
2968 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
2971 /* ALL_BP_LOCATIONS bp_location has bl->OWNER always non-NULL. */
2972 if (!breakpoint_enabled (bl
->owner
)
2973 && bl
->owner
->enable_state
!= bp_permanent
)
2976 if (!breakpoint_location_address_match (bl
, aspace
, pc
))
2979 if (bl
->owner
->thread
!= -1)
2981 /* This is a thread-specific breakpoint. Check that ptid
2982 matches that thread. If thread hasn't been computed yet,
2983 it is now time to do so. */
2985 thread
= pid_to_thread_id (ptid
);
2986 if (bl
->owner
->thread
!= thread
)
2990 if (bl
->owner
->task
!= 0)
2992 /* This is a task-specific breakpoint. Check that ptid
2993 matches that task. If task hasn't been computed yet,
2994 it is now time to do so. */
2996 task
= ada_get_task_number (ptid
);
2997 if (bl
->owner
->task
!= task
)
3001 if (overlay_debugging
3002 && section_is_overlay (bl
->section
)
3003 && !section_is_mapped (bl
->section
))
3004 continue; /* unmapped overlay -- can't be a match */
3013 /* bpstat stuff. External routines' interfaces are documented
3017 ep_is_catchpoint (struct breakpoint
*ep
)
3019 return (ep
->type
== bp_catchpoint
);
3022 /* Frees any storage that is part of a bpstat. Does not walk the
3026 bpstat_free (bpstat bs
)
3028 if (bs
->old_val
!= NULL
)
3029 value_free (bs
->old_val
);
3030 decref_counted_command_line (&bs
->commands
);
3031 decref_bp_location (&bs
->bp_location_at
);
3035 /* Clear a bpstat so that it says we are not at any breakpoint.
3036 Also free any storage that is part of a bpstat. */
3039 bpstat_clear (bpstat
*bsp
)
3056 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
3057 is part of the bpstat is copied as well. */
3060 bpstat_copy (bpstat bs
)
3064 bpstat retval
= NULL
;
3069 for (; bs
!= NULL
; bs
= bs
->next
)
3071 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
3072 memcpy (tmp
, bs
, sizeof (*tmp
));
3073 incref_counted_command_line (tmp
->commands
);
3074 incref_bp_location (tmp
->bp_location_at
);
3075 if (bs
->old_val
!= NULL
)
3077 tmp
->old_val
= value_copy (bs
->old_val
);
3078 release_value (tmp
->old_val
);
3082 /* This is the first thing in the chain. */
3092 /* Find the bpstat associated with this breakpoint. */
3095 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
3100 for (; bsp
!= NULL
; bsp
= bsp
->next
)
3102 if (bsp
->breakpoint_at
== breakpoint
)
3108 /* Put in *NUM the breakpoint number of the first breakpoint we are
3109 stopped at. *BSP upon return is a bpstat which points to the
3110 remaining breakpoints stopped at (but which is not guaranteed to be
3111 good for anything but further calls to bpstat_num).
3113 Return 0 if passed a bpstat which does not indicate any breakpoints.
3114 Return -1 if stopped at a breakpoint that has been deleted since
3116 Return 1 otherwise. */
3119 bpstat_num (bpstat
*bsp
, int *num
)
3121 struct breakpoint
*b
;
3124 return 0; /* No more breakpoint values */
3126 /* We assume we'll never have several bpstats that correspond to a
3127 single breakpoint -- otherwise, this function might return the
3128 same number more than once and this will look ugly. */
3129 b
= (*bsp
)->breakpoint_at
;
3130 *bsp
= (*bsp
)->next
;
3132 return -1; /* breakpoint that's been deleted since */
3134 *num
= b
->number
; /* We have its number */
3138 /* Modify BS so that the actions will not be performed. */
3141 bpstat_clear_actions (bpstat bs
)
3143 for (; bs
!= NULL
; bs
= bs
->next
)
3145 decref_counted_command_line (&bs
->commands
);
3146 bs
->commands_left
= NULL
;
3147 if (bs
->old_val
!= NULL
)
3149 value_free (bs
->old_val
);
3155 /* Called when a command is about to proceed the inferior. */
3158 breakpoint_about_to_proceed (void)
3160 if (!ptid_equal (inferior_ptid
, null_ptid
))
3162 struct thread_info
*tp
= inferior_thread ();
3164 /* Allow inferior function calls in breakpoint commands to not
3165 interrupt the command list. When the call finishes
3166 successfully, the inferior will be standing at the same
3167 breakpoint as if nothing happened. */
3168 if (tp
->control
.in_infcall
)
3172 breakpoint_proceeded
= 1;
3175 /* Stub for cleaning up our state if we error-out of a breakpoint
3178 cleanup_executing_breakpoints (void *ignore
)
3180 executing_breakpoint_commands
= 0;
3183 /* Execute all the commands associated with all the breakpoints at
3184 this location. Any of these commands could cause the process to
3185 proceed beyond this point, etc. We look out for such changes by
3186 checking the global "breakpoint_proceeded" after each command.
3188 Returns true if a breakpoint command resumed the inferior. In that
3189 case, it is the caller's responsibility to recall it again with the
3190 bpstat of the current thread. */
3193 bpstat_do_actions_1 (bpstat
*bsp
)
3196 struct cleanup
*old_chain
;
3199 /* Avoid endless recursion if a `source' command is contained
3201 if (executing_breakpoint_commands
)
3204 executing_breakpoint_commands
= 1;
3205 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
3207 /* This pointer will iterate over the list of bpstat's. */
3210 breakpoint_proceeded
= 0;
3211 for (; bs
!= NULL
; bs
= bs
->next
)
3213 struct counted_command_line
*ccmd
;
3214 struct command_line
*cmd
;
3215 struct cleanup
*this_cmd_tree_chain
;
3217 /* Take ownership of the BSP's command tree, if it has one.
3219 The command tree could legitimately contain commands like
3220 'step' and 'next', which call clear_proceed_status, which
3221 frees stop_bpstat's command tree. To make sure this doesn't
3222 free the tree we're executing out from under us, we need to
3223 take ownership of the tree ourselves. Since a given bpstat's
3224 commands are only executed once, we don't need to copy it; we
3225 can clear the pointer in the bpstat, and make sure we free
3226 the tree when we're done. */
3227 ccmd
= bs
->commands
;
3228 bs
->commands
= NULL
;
3230 = make_cleanup_decref_counted_command_line (&ccmd
);
3231 cmd
= bs
->commands_left
;
3232 bs
->commands_left
= NULL
;
3236 execute_control_command (cmd
);
3238 if (breakpoint_proceeded
)
3244 /* We can free this command tree now. */
3245 do_cleanups (this_cmd_tree_chain
);
3247 if (breakpoint_proceeded
)
3249 if (target_can_async_p ())
3250 /* If we are in async mode, then the target might be still
3251 running, not stopped at any breakpoint, so nothing for
3252 us to do here -- just return to the event loop. */
3255 /* In sync mode, when execute_control_command returns
3256 we're already standing on the next breakpoint.
3257 Breakpoint commands for that stop were not run, since
3258 execute_command does not run breakpoint commands --
3259 only command_line_handler does, but that one is not
3260 involved in execution of breakpoint commands. So, we
3261 can now execute breakpoint commands. It should be
3262 noted that making execute_command do bpstat actions is
3263 not an option -- in this case we'll have recursive
3264 invocation of bpstat for each breakpoint with a
3265 command, and can easily blow up GDB stack. Instead, we
3266 return true, which will trigger the caller to recall us
3267 with the new stop_bpstat. */
3272 do_cleanups (old_chain
);
3277 bpstat_do_actions (void)
3279 /* Do any commands attached to breakpoint we are stopped at. */
3280 while (!ptid_equal (inferior_ptid
, null_ptid
)
3281 && target_has_execution
3282 && !is_exited (inferior_ptid
)
3283 && !is_executing (inferior_ptid
))
3284 /* Since in sync mode, bpstat_do_actions may resume the inferior,
3285 and only return when it is stopped at the next breakpoint, we
3286 keep doing breakpoint actions until it returns false to
3287 indicate the inferior was not resumed. */
3288 if (!bpstat_do_actions_1 (&inferior_thread ()->control
.stop_bpstat
))
3292 /* Print out the (old or new) value associated with a watchpoint. */
3295 watchpoint_value_print (struct value
*val
, struct ui_file
*stream
)
3298 fprintf_unfiltered (stream
, _("<unreadable>"));
3301 struct value_print_options opts
;
3302 get_user_print_options (&opts
);
3303 value_print (val
, stream
, &opts
);
3307 /* This is the normal print function for a bpstat. In the future,
3308 much of this logic could (should?) be moved to bpstat_stop_status,
3309 by having it set different print_it values.
3311 Current scheme: When we stop, bpstat_print() is called. It loops
3312 through the bpstat list of things causing this stop, calling the
3313 print_bp_stop_message function on each one. The behavior of the
3314 print_bp_stop_message function depends on the print_it field of
3315 bpstat. If such field so indicates, call this function here.
3317 Return values from this routine (ultimately used by bpstat_print()
3318 and normal_stop() to decide what to do):
3319 PRINT_NOTHING: Means we already printed all we needed to print,
3320 don't print anything else.
3321 PRINT_SRC_ONLY: Means we printed something, and we do *not* desire
3322 that something to be followed by a location.
3323 PRINT_SCR_AND_LOC: Means we printed something, and we *do* desire
3324 that something to be followed by a location.
3325 PRINT_UNKNOWN: Means we printed nothing or we need to do some more
3328 static enum print_stop_action
3329 print_it_typical (bpstat bs
)
3331 struct cleanup
*old_chain
;
3332 struct breakpoint
*b
;
3333 const struct bp_location
*bl
;
3334 struct ui_stream
*stb
;
3336 enum print_stop_action result
;
3338 gdb_assert (bs
->bp_location_at
!= NULL
);
3340 bl
= bs
->bp_location_at
;
3341 b
= bs
->breakpoint_at
;
3343 stb
= ui_out_stream_new (uiout
);
3344 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
3349 case bp_hardware_breakpoint
:
3350 bp_temp
= b
->disposition
== disp_del
;
3351 if (bl
->address
!= bl
->requested_address
)
3352 breakpoint_adjustment_warning (bl
->requested_address
,
3355 annotate_breakpoint (b
->number
);
3357 ui_out_text (uiout
, "\nTemporary breakpoint ");
3359 ui_out_text (uiout
, "\nBreakpoint ");
3360 if (ui_out_is_mi_like_p (uiout
))
3362 ui_out_field_string (uiout
, "reason",
3363 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
3364 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
3366 ui_out_field_int (uiout
, "bkptno", b
->number
);
3367 ui_out_text (uiout
, ", ");
3368 result
= PRINT_SRC_AND_LOC
;
3371 case bp_shlib_event
:
3372 /* Did we stop because the user set the stop_on_solib_events
3373 variable? (If so, we report this as a generic, "Stopped due
3374 to shlib event" message.) */
3375 printf_filtered (_("Stopped due to shared library event\n"));
3376 result
= PRINT_NOTHING
;
3379 case bp_thread_event
:
3380 /* Not sure how we will get here.
3381 GDB should not stop for these breakpoints. */
3382 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
3383 result
= PRINT_NOTHING
;
3386 case bp_overlay_event
:
3387 /* By analogy with the thread event, GDB should not stop for these. */
3388 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
3389 result
= PRINT_NOTHING
;
3392 case bp_longjmp_master
:
3393 /* These should never be enabled. */
3394 printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
3395 result
= PRINT_NOTHING
;
3398 case bp_std_terminate_master
:
3399 /* These should never be enabled. */
3400 printf_filtered (_("std::terminate Master Breakpoint: "
3401 "gdb should not stop!\n"));
3402 result
= PRINT_NOTHING
;
3405 case bp_exception_master
:
3406 /* These should never be enabled. */
3407 printf_filtered (_("Exception Master Breakpoint: "
3408 "gdb should not stop!\n"));
3409 result
= PRINT_NOTHING
;
3413 case bp_hardware_watchpoint
:
3414 annotate_watchpoint (b
->number
);
3415 if (ui_out_is_mi_like_p (uiout
))
3418 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
3420 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
3421 ui_out_text (uiout
, "\nOld value = ");
3422 watchpoint_value_print (bs
->old_val
, stb
->stream
);
3423 ui_out_field_stream (uiout
, "old", stb
);
3424 ui_out_text (uiout
, "\nNew value = ");
3425 watchpoint_value_print (b
->val
, stb
->stream
);
3426 ui_out_field_stream (uiout
, "new", stb
);
3427 ui_out_text (uiout
, "\n");
3428 /* More than one watchpoint may have been triggered. */
3429 result
= PRINT_UNKNOWN
;
3432 case bp_read_watchpoint
:
3433 if (ui_out_is_mi_like_p (uiout
))
3436 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
3438 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
3439 ui_out_text (uiout
, "\nValue = ");
3440 watchpoint_value_print (b
->val
, stb
->stream
);
3441 ui_out_field_stream (uiout
, "value", stb
);
3442 ui_out_text (uiout
, "\n");
3443 result
= PRINT_UNKNOWN
;
3446 case bp_access_watchpoint
:
3447 if (bs
->old_val
!= NULL
)
3449 annotate_watchpoint (b
->number
);
3450 if (ui_out_is_mi_like_p (uiout
))
3453 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
3455 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
3456 ui_out_text (uiout
, "\nOld value = ");
3457 watchpoint_value_print (bs
->old_val
, stb
->stream
);
3458 ui_out_field_stream (uiout
, "old", stb
);
3459 ui_out_text (uiout
, "\nNew value = ");
3464 if (ui_out_is_mi_like_p (uiout
))
3467 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
3468 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
3469 ui_out_text (uiout
, "\nValue = ");
3471 watchpoint_value_print (b
->val
, stb
->stream
);
3472 ui_out_field_stream (uiout
, "new", stb
);
3473 ui_out_text (uiout
, "\n");
3474 result
= PRINT_UNKNOWN
;
3477 /* Fall through, we don't deal with these types of breakpoints
3481 if (ui_out_is_mi_like_p (uiout
))
3484 async_reason_lookup (EXEC_ASYNC_FUNCTION_FINISHED
));
3485 result
= PRINT_UNKNOWN
;
3489 if (ui_out_is_mi_like_p (uiout
))
3492 async_reason_lookup (EXEC_ASYNC_LOCATION_REACHED
));
3493 result
= PRINT_UNKNOWN
;
3498 case bp_longjmp_resume
:
3500 case bp_exception_resume
:
3501 case bp_step_resume
:
3502 case bp_watchpoint_scope
:
3504 case bp_std_terminate
:
3506 case bp_fast_tracepoint
:
3508 case bp_gnu_ifunc_resolver
:
3509 case bp_gnu_ifunc_resolver_return
:
3511 result
= PRINT_UNKNOWN
;
3515 do_cleanups (old_chain
);
3519 /* Generic routine for printing messages indicating why we
3520 stopped. The behavior of this function depends on the value
3521 'print_it' in the bpstat structure. Under some circumstances we
3522 may decide not to print anything here and delegate the task to
3525 static enum print_stop_action
3526 print_bp_stop_message (bpstat bs
)
3528 switch (bs
->print_it
)
3531 /* Nothing should be printed for this bpstat entry. */
3532 return PRINT_UNKNOWN
;
3536 /* We still want to print the frame, but we already printed the
3537 relevant messages. */
3538 return PRINT_SRC_AND_LOC
;
3541 case print_it_normal
:
3543 struct breakpoint
*b
= bs
->breakpoint_at
;
3545 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
3546 which has since been deleted. */
3548 return PRINT_UNKNOWN
;
3550 /* Normal case. Call the breakpoint's print_it method, or
3551 print_it_typical. */
3552 if (b
->ops
!= NULL
&& b
->ops
->print_it
!= NULL
)
3553 return b
->ops
->print_it (b
);
3555 return print_it_typical (bs
);
3560 internal_error (__FILE__
, __LINE__
,
3561 _("print_bp_stop_message: unrecognized enum value"));
3566 /* Print a message indicating what happened. This is called from
3567 normal_stop(). The input to this routine is the head of the bpstat
3568 list - a list of the eventpoints that caused this stop. This
3569 routine calls the generic print routine for printing a message
3570 about reasons for stopping. This will print (for example) the
3571 "Breakpoint n," part of the output. The return value of this
3574 PRINT_UNKNOWN: Means we printed nothing.
3575 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
3576 code to print the location. An example is
3577 "Breakpoint 1, " which should be followed by
3579 PRINT_SRC_ONLY: Means we printed something, but there is no need
3580 to also print the location part of the message.
3581 An example is the catch/throw messages, which
3582 don't require a location appended to the end.
3583 PRINT_NOTHING: We have done some printing and we don't need any
3584 further info to be printed. */
3586 enum print_stop_action
3587 bpstat_print (bpstat bs
)
3591 /* Maybe another breakpoint in the chain caused us to stop.
3592 (Currently all watchpoints go on the bpstat whether hit or not.
3593 That probably could (should) be changed, provided care is taken
3594 with respect to bpstat_explains_signal). */
3595 for (; bs
; bs
= bs
->next
)
3597 val
= print_bp_stop_message (bs
);
3598 if (val
== PRINT_SRC_ONLY
3599 || val
== PRINT_SRC_AND_LOC
3600 || val
== PRINT_NOTHING
)
3604 /* We reached the end of the chain, or we got a null BS to start
3605 with and nothing was printed. */
3606 return PRINT_UNKNOWN
;
3609 /* Evaluate the expression EXP and return 1 if value is zero. This is
3610 used inside a catch_errors to evaluate the breakpoint condition.
3611 The argument is a "struct expression *" that has been cast to a
3612 "char *" to make it pass through catch_errors. */
3615 breakpoint_cond_eval (void *exp
)
3617 struct value
*mark
= value_mark ();
3618 int i
= !value_true (evaluate_expression ((struct expression
*) exp
));
3620 value_free_to_mark (mark
);
3624 /* Allocate a new bpstat. Link it to the FIFO list by BS_LINK_POINTER. */
3627 bpstat_alloc (struct bp_location
*bl
, bpstat
**bs_link_pointer
)
3631 bs
= (bpstat
) xmalloc (sizeof (*bs
));
3633 **bs_link_pointer
= bs
;
3634 *bs_link_pointer
= &bs
->next
;
3635 bs
->breakpoint_at
= bl
->owner
;
3636 bs
->bp_location_at
= bl
;
3637 incref_bp_location (bl
);
3638 /* If the condition is false, etc., don't do the commands. */
3639 bs
->commands
= NULL
;
3640 bs
->commands_left
= NULL
;
3642 bs
->print_it
= print_it_normal
;
3646 /* The target has stopped with waitstatus WS. Check if any hardware
3647 watchpoints have triggered, according to the target. */
3650 watchpoints_triggered (struct target_waitstatus
*ws
)
3652 int stopped_by_watchpoint
= target_stopped_by_watchpoint ();
3654 struct breakpoint
*b
;
3656 if (!stopped_by_watchpoint
)
3658 /* We were not stopped by a watchpoint. Mark all watchpoints
3659 as not triggered. */
3661 if (is_hardware_watchpoint (b
))
3662 b
->watchpoint_triggered
= watch_triggered_no
;
3667 if (!target_stopped_data_address (¤t_target
, &addr
))
3669 /* We were stopped by a watchpoint, but we don't know where.
3670 Mark all watchpoints as unknown. */
3672 if (is_hardware_watchpoint (b
))
3673 b
->watchpoint_triggered
= watch_triggered_unknown
;
3675 return stopped_by_watchpoint
;
3678 /* The target could report the data address. Mark watchpoints
3679 affected by this data address as triggered, and all others as not
3683 if (is_hardware_watchpoint (b
))
3685 struct bp_location
*loc
;
3687 b
->watchpoint_triggered
= watch_triggered_no
;
3688 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
3689 /* Exact match not required. Within range is
3691 if (target_watchpoint_addr_within_range (¤t_target
,
3695 b
->watchpoint_triggered
= watch_triggered_yes
;
3703 /* Possible return values for watchpoint_check (this can't be an enum
3704 because of check_errors). */
3705 /* The watchpoint has been deleted. */
3706 #define WP_DELETED 1
3707 /* The value has changed. */
3708 #define WP_VALUE_CHANGED 2
3709 /* The value has not changed. */
3710 #define WP_VALUE_NOT_CHANGED 3
3711 /* Ignore this watchpoint, no matter if the value changed or not. */
3714 #define BP_TEMPFLAG 1
3715 #define BP_HARDWAREFLAG 2
3717 /* Evaluate watchpoint condition expression and check if its value
3720 P should be a pointer to struct bpstat, but is defined as a void *
3721 in order for this function to be usable with catch_errors. */
3724 watchpoint_check (void *p
)
3726 bpstat bs
= (bpstat
) p
;
3727 struct breakpoint
*b
;
3728 struct frame_info
*fr
;
3729 int within_current_scope
;
3731 /* BS is built from an existing struct breakpoint. */
3732 gdb_assert (bs
->breakpoint_at
!= NULL
);
3733 b
= bs
->breakpoint_at
;
3735 gdb_assert (is_watchpoint (b
));
3737 /* If this is a local watchpoint, we only want to check if the
3738 watchpoint frame is in scope if the current thread is the thread
3739 that was used to create the watchpoint. */
3740 if (!watchpoint_in_thread_scope (b
))
3743 if (b
->exp_valid_block
== NULL
)
3744 within_current_scope
= 1;
3747 struct frame_info
*frame
= get_current_frame ();
3748 struct gdbarch
*frame_arch
= get_frame_arch (frame
);
3749 CORE_ADDR frame_pc
= get_frame_pc (frame
);
3751 /* in_function_epilogue_p() returns a non-zero value if we're
3752 still in the function but the stack frame has already been
3753 invalidated. Since we can't rely on the values of local
3754 variables after the stack has been destroyed, we are treating
3755 the watchpoint in that state as `not changed' without further
3756 checking. Don't mark watchpoints as changed if the current
3757 frame is in an epilogue - even if they are in some other
3758 frame, our view of the stack is likely to be wrong and
3759 frame_find_by_id could error out. */
3760 if (gdbarch_in_function_epilogue_p (frame_arch
, frame_pc
))
3763 fr
= frame_find_by_id (b
->watchpoint_frame
);
3764 within_current_scope
= (fr
!= NULL
);
3766 /* If we've gotten confused in the unwinder, we might have
3767 returned a frame that can't describe this variable. */
3768 if (within_current_scope
)
3770 struct symbol
*function
;
3772 function
= get_frame_function (fr
);
3773 if (function
== NULL
3774 || !contained_in (b
->exp_valid_block
,
3775 SYMBOL_BLOCK_VALUE (function
)))
3776 within_current_scope
= 0;
3779 if (within_current_scope
)
3780 /* If we end up stopping, the current frame will get selected
3781 in normal_stop. So this call to select_frame won't affect
3786 if (within_current_scope
)
3788 /* We use value_{,free_to_}mark because it could be a *long*
3789 time before we return to the command level and call
3790 free_all_values. We can't call free_all_values because we
3791 might be in the middle of evaluating a function call. */
3794 struct value
*mark
= value_mark ();
3795 struct value
*new_val
;
3797 fetch_subexp_value (b
->exp
, &pc
, &new_val
, NULL
, NULL
);
3799 /* We use value_equal_contents instead of value_equal because
3800 the latter coerces an array to a pointer, thus comparing just
3801 the address of the array instead of its contents. This is
3802 not what we want. */
3803 if ((b
->val
!= NULL
) != (new_val
!= NULL
)
3804 || (b
->val
!= NULL
&& !value_equal_contents (b
->val
, new_val
)))
3806 if (new_val
!= NULL
)
3808 release_value (new_val
);
3809 value_free_to_mark (mark
);
3811 bs
->old_val
= b
->val
;
3814 return WP_VALUE_CHANGED
;
3818 /* Nothing changed. */
3819 value_free_to_mark (mark
);
3820 return WP_VALUE_NOT_CHANGED
;
3825 /* This seems like the only logical thing to do because
3826 if we temporarily ignored the watchpoint, then when
3827 we reenter the block in which it is valid it contains
3828 garbage (in the case of a function, it may have two
3829 garbage values, one before and one after the prologue).
3830 So we can't even detect the first assignment to it and
3831 watch after that (since the garbage may or may not equal
3832 the first value assigned). */
3833 /* We print all the stop information in print_it_typical(), but
3834 in this case, by the time we call print_it_typical() this bp
3835 will be deleted already. So we have no choice but print the
3836 information here. */
3837 if (ui_out_is_mi_like_p (uiout
))
3839 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
3840 ui_out_text (uiout
, "\nWatchpoint ");
3841 ui_out_field_int (uiout
, "wpnum", b
->number
);
3843 " deleted because the program has left the block in\n\
3844 which its expression is valid.\n");
3846 watchpoint_del_at_next_stop (b
);
3852 /* Return true if it looks like target has stopped due to hitting
3853 breakpoint location BL. This function does not check if we
3854 should stop, only if BL explains the stop. */
3856 bpstat_check_location (const struct bp_location
*bl
,
3857 struct address_space
*aspace
, CORE_ADDR bp_addr
)
3859 struct breakpoint
*b
= bl
->owner
;
3861 /* BL is from existing struct breakpoint. */
3862 gdb_assert (b
!= NULL
);
3864 if (b
->ops
&& b
->ops
->breakpoint_hit
)
3865 return b
->ops
->breakpoint_hit (bl
, aspace
, bp_addr
);
3867 /* By definition, the inferior does not report stops at
3869 if (is_tracepoint (b
))
3872 if (!is_watchpoint (b
)
3873 && b
->type
!= bp_hardware_breakpoint
3874 && b
->type
!= bp_catchpoint
) /* a non-watchpoint bp */
3876 if (!breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
3879 if (overlay_debugging
/* unmapped overlay section */
3880 && section_is_overlay (bl
->section
)
3881 && !section_is_mapped (bl
->section
))
3885 /* Continuable hardware watchpoints are treated as non-existent if the
3886 reason we stopped wasn't a hardware watchpoint (we didn't stop on
3887 some data address). Otherwise gdb won't stop on a break instruction
3888 in the code (not from a breakpoint) when a hardware watchpoint has
3889 been defined. Also skip watchpoints which we know did not trigger
3890 (did not match the data address). */
3892 if (is_hardware_watchpoint (b
)
3893 && b
->watchpoint_triggered
== watch_triggered_no
)
3896 if (b
->type
== bp_hardware_breakpoint
)
3898 if (bl
->address
!= bp_addr
)
3900 if (overlay_debugging
/* unmapped overlay section */
3901 && section_is_overlay (bl
->section
)
3902 && !section_is_mapped (bl
->section
))
3909 /* If BS refers to a watchpoint, determine if the watched values
3910 has actually changed, and we should stop. If not, set BS->stop
3913 bpstat_check_watchpoint (bpstat bs
)
3915 const struct bp_location
*bl
;
3916 struct breakpoint
*b
;
3918 /* BS is built for existing struct breakpoint. */
3919 bl
= bs
->bp_location_at
;
3920 gdb_assert (bl
!= NULL
);
3921 b
= bs
->breakpoint_at
;
3922 gdb_assert (b
!= NULL
);
3924 if (is_watchpoint (b
))
3926 int must_check_value
= 0;
3928 if (b
->type
== bp_watchpoint
)
3929 /* For a software watchpoint, we must always check the
3931 must_check_value
= 1;
3932 else if (b
->watchpoint_triggered
== watch_triggered_yes
)
3933 /* We have a hardware watchpoint (read, write, or access)
3934 and the target earlier reported an address watched by
3936 must_check_value
= 1;
3937 else if (b
->watchpoint_triggered
== watch_triggered_unknown
3938 && b
->type
== bp_hardware_watchpoint
)
3939 /* We were stopped by a hardware watchpoint, but the target could
3940 not report the data address. We must check the watchpoint's
3941 value. Access and read watchpoints are out of luck; without
3942 a data address, we can't figure it out. */
3943 must_check_value
= 1;
3945 if (must_check_value
)
3948 = xstrprintf ("Error evaluating expression for watchpoint %d\n",
3950 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
3951 int e
= catch_errors (watchpoint_check
, bs
, message
,
3953 do_cleanups (cleanups
);
3957 /* We've already printed what needs to be printed. */
3958 bs
->print_it
= print_it_done
;
3962 bs
->print_it
= print_it_noop
;
3965 case WP_VALUE_CHANGED
:
3966 if (b
->type
== bp_read_watchpoint
)
3968 /* There are two cases to consider here:
3970 1. We're watching the triggered memory for reads.
3971 In that case, trust the target, and always report
3972 the watchpoint hit to the user. Even though
3973 reads don't cause value changes, the value may
3974 have changed since the last time it was read, and
3975 since we're not trapping writes, we will not see
3976 those, and as such we should ignore our notion of
3979 2. We're watching the triggered memory for both
3980 reads and writes. There are two ways this may
3983 2.1. This is a target that can't break on data
3984 reads only, but can break on accesses (reads or
3985 writes), such as e.g., x86. We detect this case
3986 at the time we try to insert read watchpoints.
3988 2.2. Otherwise, the target supports read
3989 watchpoints, but, the user set an access or write
3990 watchpoint watching the same memory as this read
3993 If we're watching memory writes as well as reads,
3994 ignore watchpoint hits when we find that the
3995 value hasn't changed, as reads don't cause
3996 changes. This still gives false positives when
3997 the program writes the same value to memory as
3998 what there was already in memory (we will confuse
3999 it for a read), but it's much better than
4002 int other_write_watchpoint
= 0;
4004 if (bl
->watchpoint_type
== hw_read
)
4006 struct breakpoint
*other_b
;
4008 ALL_BREAKPOINTS (other_b
)
4009 if ((other_b
->type
== bp_hardware_watchpoint
4010 || other_b
->type
== bp_access_watchpoint
)
4011 && (other_b
->watchpoint_triggered
4012 == watch_triggered_yes
))
4014 other_write_watchpoint
= 1;
4019 if (other_write_watchpoint
4020 || bl
->watchpoint_type
== hw_access
)
4022 /* We're watching the same memory for writes,
4023 and the value changed since the last time we
4024 updated it, so this trap must be for a write.
4026 bs
->print_it
= print_it_noop
;
4031 case WP_VALUE_NOT_CHANGED
:
4032 if (b
->type
== bp_hardware_watchpoint
4033 || b
->type
== bp_watchpoint
)
4035 /* Don't stop: write watchpoints shouldn't fire if
4036 the value hasn't changed. */
4037 bs
->print_it
= print_it_noop
;
4045 /* Error from catch_errors. */
4046 printf_filtered (_("Watchpoint %d deleted.\n"), b
->number
);
4047 watchpoint_del_at_next_stop (b
);
4048 /* We've already printed what needs to be printed. */
4049 bs
->print_it
= print_it_done
;
4053 else /* must_check_value == 0 */
4055 /* This is a case where some watchpoint(s) triggered, but
4056 not at the address of this watchpoint, or else no
4057 watchpoint triggered after all. So don't print
4058 anything for this watchpoint. */
4059 bs
->print_it
= print_it_noop
;
4066 /* Check conditions (condition proper, frame, thread and ignore count)
4067 of breakpoint referred to by BS. If we should not stop for this
4068 breakpoint, set BS->stop to 0. */
4071 bpstat_check_breakpoint_conditions (bpstat bs
, ptid_t ptid
)
4073 int thread_id
= pid_to_thread_id (ptid
);
4074 const struct bp_location
*bl
;
4075 struct breakpoint
*b
;
4077 /* BS is built for existing struct breakpoint. */
4078 bl
= bs
->bp_location_at
;
4079 gdb_assert (bl
!= NULL
);
4080 b
= bs
->breakpoint_at
;
4081 gdb_assert (b
!= NULL
);
4083 if (frame_id_p (b
->frame_id
)
4084 && !frame_id_eq (b
->frame_id
, get_stack_frame_id (get_current_frame ())))
4088 int value_is_zero
= 0;
4089 struct expression
*cond
;
4091 /* Evaluate Python breakpoints that have a "stop"
4092 method implemented. */
4093 if (b
->py_bp_object
)
4094 bs
->stop
= gdbpy_should_stop (b
->py_bp_object
);
4096 if (is_watchpoint (b
))
4101 if (cond
&& b
->disposition
!= disp_del_at_next_stop
)
4103 int within_current_scope
= 1;
4105 /* We use value_mark and value_free_to_mark because it could
4106 be a long time before we return to the command level and
4107 call free_all_values. We can't call free_all_values
4108 because we might be in the middle of evaluating a
4110 struct value
*mark
= value_mark ();
4112 /* Need to select the frame, with all that implies so that
4113 the conditions will have the right context. Because we
4114 use the frame, we will not see an inlined function's
4115 variables when we arrive at a breakpoint at the start
4116 of the inlined function; the current frame will be the
4118 if (!is_watchpoint (b
) || b
->cond_exp_valid_block
== NULL
)
4119 select_frame (get_current_frame ());
4122 struct frame_info
*frame
;
4124 /* For local watchpoint expressions, which particular
4125 instance of a local is being watched matters, so we
4126 keep track of the frame to evaluate the expression
4127 in. To evaluate the condition however, it doesn't
4128 really matter which instantiation of the function
4129 where the condition makes sense triggers the
4130 watchpoint. This allows an expression like "watch
4131 global if q > 10" set in `func', catch writes to
4132 global on all threads that call `func', or catch
4133 writes on all recursive calls of `func' by a single
4134 thread. We simply always evaluate the condition in
4135 the innermost frame that's executing where it makes
4136 sense to evaluate the condition. It seems
4138 frame
= block_innermost_frame (b
->cond_exp_valid_block
);
4140 select_frame (frame
);
4142 within_current_scope
= 0;
4144 if (within_current_scope
)
4146 = catch_errors (breakpoint_cond_eval
, cond
,
4147 "Error in testing breakpoint condition:\n",
4151 warning (_("Watchpoint condition cannot be tested "
4152 "in the current scope"));
4153 /* If we failed to set the right context for this
4154 watchpoint, unconditionally report it. */
4157 /* FIXME-someday, should give breakpoint #. */
4158 value_free_to_mark (mark
);
4161 if (cond
&& value_is_zero
)
4165 else if (b
->thread
!= -1 && b
->thread
!= thread_id
)
4169 else if (b
->ignore_count
> 0)
4172 annotate_ignore_count_change ();
4174 /* Increase the hit count even though we don't stop. */
4181 /* Get a bpstat associated with having just stopped at address
4182 BP_ADDR in thread PTID.
4184 Determine whether we stopped at a breakpoint, etc, or whether we
4185 don't understand this stop. Result is a chain of bpstat's such
4188 if we don't understand the stop, the result is a null pointer.
4190 if we understand why we stopped, the result is not null.
4192 Each element of the chain refers to a particular breakpoint or
4193 watchpoint at which we have stopped. (We may have stopped for
4194 several reasons concurrently.)
4196 Each element of the chain has valid next, breakpoint_at,
4197 commands, FIXME??? fields. */
4200 bpstat_stop_status (struct address_space
*aspace
,
4201 CORE_ADDR bp_addr
, ptid_t ptid
)
4203 struct breakpoint
*b
= NULL
;
4204 struct bp_location
*bl
;
4205 struct bp_location
*loc
;
4206 /* First item of allocated bpstat's. */
4207 bpstat bs_head
= NULL
, *bs_link
= &bs_head
;
4208 /* Pointer to the last thing in the chain currently. */
4211 int need_remove_insert
;
4214 /* First, build the bpstat chain with locations that explain a
4215 target stop, while being careful to not set the target running,
4216 as that may invalidate locations (in particular watchpoint
4217 locations are recreated). Resuming will happen here with
4218 breakpoint conditions or watchpoint expressions that include
4219 inferior function calls. */
4223 if (!breakpoint_enabled (b
) && b
->enable_state
!= bp_permanent
)
4226 for (bl
= b
->loc
; bl
!= NULL
; bl
= bl
->next
)
4228 /* For hardware watchpoints, we look only at the first
4229 location. The watchpoint_check function will work on the
4230 entire expression, not the individual locations. For
4231 read watchpoints, the watchpoints_triggered function has
4232 checked all locations already. */
4233 if (b
->type
== bp_hardware_watchpoint
&& bl
!= b
->loc
)
4236 if (bl
->shlib_disabled
)
4239 if (!bpstat_check_location (bl
, aspace
, bp_addr
))
4242 /* Come here if it's a watchpoint, or if the break address
4245 bs
= bpstat_alloc (bl
, &bs_link
); /* Alloc a bpstat to
4248 /* Assume we stop. Should we find a watchpoint that is not
4249 actually triggered, or if the condition of the breakpoint
4250 evaluates as false, we'll reset 'stop' to 0. */
4254 /* If this is a scope breakpoint, mark the associated
4255 watchpoint as triggered so that we will handle the
4256 out-of-scope event. We'll get to the watchpoint next
4258 if (b
->type
== bp_watchpoint_scope
&& b
->related_breakpoint
!= b
)
4259 b
->related_breakpoint
->watchpoint_triggered
= watch_triggered_yes
;
4263 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
4265 if (breakpoint_location_address_match (loc
, aspace
, bp_addr
))
4267 bs
= bpstat_alloc (loc
, &bs_link
);
4268 /* For hits of moribund locations, we should just proceed. */
4271 bs
->print_it
= print_it_noop
;
4275 /* Now go through the locations that caused the target to stop, and
4276 check whether we're interested in reporting this stop to higher
4277 layers, or whether we should resume the target transparently. */
4281 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
4286 bpstat_check_watchpoint (bs
);
4290 b
= bs
->breakpoint_at
;
4292 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
4293 || b
->type
== bp_longjmp_master
4294 || b
->type
== bp_std_terminate_master
4295 || b
->type
== bp_exception_master
)
4296 /* We do not stop for these. */
4299 bpstat_check_breakpoint_conditions (bs
, ptid
);
4305 /* We will stop here. */
4306 if (b
->disposition
== disp_disable
)
4308 if (b
->enable_state
!= bp_permanent
)
4309 b
->enable_state
= bp_disabled
;
4314 bs
->commands
= b
->commands
;
4315 incref_counted_command_line (bs
->commands
);
4316 bs
->commands_left
= bs
->commands
? bs
->commands
->commands
: NULL
;
4317 if (bs
->commands_left
4318 && (strcmp ("silent", bs
->commands_left
->line
) == 0
4321 bs
->commands_left
->line
) == 0)))
4323 bs
->commands_left
= bs
->commands_left
->next
;
4328 /* Print nothing for this entry if we dont stop or dont print. */
4329 if (bs
->stop
== 0 || bs
->print
== 0)
4330 bs
->print_it
= print_it_noop
;
4333 /* If we aren't stopping, the value of some hardware watchpoint may
4334 not have changed, but the intermediate memory locations we are
4335 watching may have. Don't bother if we're stopping; this will get
4337 need_remove_insert
= 0;
4338 if (! bpstat_causes_stop (bs_head
))
4339 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
4341 && bs
->breakpoint_at
4342 && is_hardware_watchpoint (bs
->breakpoint_at
))
4344 update_watchpoint (bs
->breakpoint_at
, 0 /* don't reparse. */);
4345 need_remove_insert
= 1;
4348 if (need_remove_insert
)
4349 update_global_location_list (1);
4350 else if (removed_any
)
4351 update_global_location_list (0);
4357 handle_jit_event (void)
4359 struct frame_info
*frame
;
4360 struct gdbarch
*gdbarch
;
4362 /* Switch terminal for any messages produced by
4363 breakpoint_re_set. */
4364 target_terminal_ours_for_output ();
4366 frame
= get_current_frame ();
4367 gdbarch
= get_frame_arch (frame
);
4369 jit_event_handler (gdbarch
);
4371 target_terminal_inferior ();
4374 /* Prepare WHAT final decision for infrun. */
4376 /* Decide what infrun needs to do with this bpstat. */
4379 bpstat_what (bpstat bs_head
)
4381 struct bpstat_what retval
;
4382 /* We need to defer calling `solib_add', as adding new symbols
4383 resets breakpoints, which in turn deletes breakpoint locations,
4384 and hence may clear unprocessed entries in the BS chain. */
4385 int shlib_event
= 0;
4389 retval
.main_action
= BPSTAT_WHAT_KEEP_CHECKING
;
4390 retval
.call_dummy
= STOP_NONE
;
4391 retval
.is_longjmp
= 0;
4393 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
4395 /* Extract this BS's action. After processing each BS, we check
4396 if its action overrides all we've seem so far. */
4397 enum bpstat_what_main_action this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
4400 if (bs
->breakpoint_at
== NULL
)
4402 /* I suspect this can happen if it was a momentary
4403 breakpoint which has since been deleted. */
4406 else if (bs
->breakpoint_at
== NULL
)
4409 bptype
= bs
->breakpoint_at
->type
;
4416 case bp_hardware_breakpoint
:
4422 this_action
= BPSTAT_WHAT_STOP_NOISY
;
4424 this_action
= BPSTAT_WHAT_STOP_SILENT
;
4427 this_action
= BPSTAT_WHAT_SINGLE
;
4430 case bp_hardware_watchpoint
:
4431 case bp_read_watchpoint
:
4432 case bp_access_watchpoint
:
4436 this_action
= BPSTAT_WHAT_STOP_NOISY
;
4438 this_action
= BPSTAT_WHAT_STOP_SILENT
;
4442 /* There was a watchpoint, but we're not stopping.
4443 This requires no further action. */
4448 this_action
= BPSTAT_WHAT_SET_LONGJMP_RESUME
;
4449 retval
.is_longjmp
= bptype
== bp_longjmp
;
4451 case bp_longjmp_resume
:
4452 case bp_exception_resume
:
4453 this_action
= BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
;
4454 retval
.is_longjmp
= bptype
== bp_longjmp_resume
;
4456 case bp_step_resume
:
4458 this_action
= BPSTAT_WHAT_STEP_RESUME
;
4461 /* It is for the wrong frame. */
4462 this_action
= BPSTAT_WHAT_SINGLE
;
4465 case bp_watchpoint_scope
:
4466 case bp_thread_event
:
4467 case bp_overlay_event
:
4468 case bp_longjmp_master
:
4469 case bp_std_terminate_master
:
4470 case bp_exception_master
:
4471 this_action
= BPSTAT_WHAT_SINGLE
;
4477 this_action
= BPSTAT_WHAT_STOP_NOISY
;
4479 this_action
= BPSTAT_WHAT_STOP_SILENT
;
4483 /* There was a catchpoint, but we're not stopping.
4484 This requires no further action. */
4487 case bp_shlib_event
:
4490 /* If requested, stop when the dynamic linker notifies GDB
4491 of events. This allows the user to get control and place
4492 breakpoints in initializer routines for dynamically
4493 loaded objects (among other things). */
4494 if (stop_on_solib_events
)
4495 this_action
= BPSTAT_WHAT_STOP_NOISY
;
4497 this_action
= BPSTAT_WHAT_SINGLE
;
4501 this_action
= BPSTAT_WHAT_SINGLE
;
4504 /* Make sure the action is stop (silent or noisy),
4505 so infrun.c pops the dummy frame. */
4506 retval
.call_dummy
= STOP_STACK_DUMMY
;
4507 this_action
= BPSTAT_WHAT_STOP_SILENT
;
4509 case bp_std_terminate
:
4510 /* Make sure the action is stop (silent or noisy),
4511 so infrun.c pops the dummy frame. */
4512 retval
.call_dummy
= STOP_STD_TERMINATE
;
4513 this_action
= BPSTAT_WHAT_STOP_SILENT
;
4516 case bp_fast_tracepoint
:
4517 case bp_static_tracepoint
:
4518 /* Tracepoint hits should not be reported back to GDB, and
4519 if one got through somehow, it should have been filtered
4521 internal_error (__FILE__
, __LINE__
,
4522 _("bpstat_what: tracepoint encountered"));
4524 case bp_gnu_ifunc_resolver
:
4525 /* Step over it (and insert bp_gnu_ifunc_resolver_return). */
4526 this_action
= BPSTAT_WHAT_SINGLE
;
4528 case bp_gnu_ifunc_resolver_return
:
4529 /* The breakpoint will be removed, execution will restart from the
4530 PC of the former breakpoint. */
4531 this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
4534 internal_error (__FILE__
, __LINE__
,
4535 _("bpstat_what: unhandled bptype %d"), (int) bptype
);
4538 retval
.main_action
= max (retval
.main_action
, this_action
);
4541 /* These operations may affect the bs->breakpoint_at state so they are
4542 delayed after MAIN_ACTION is decided above. */
4547 fprintf_unfiltered (gdb_stdlog
, "bpstat_what: bp_shlib_event\n");
4549 /* Check for any newly added shared libraries if we're supposed
4550 to be adding them automatically. */
4552 /* Switch terminal for any messages produced by
4553 breakpoint_re_set. */
4554 target_terminal_ours_for_output ();
4557 SOLIB_ADD (NULL
, 0, ¤t_target
, auto_solib_add
);
4559 solib_add (NULL
, 0, ¤t_target
, auto_solib_add
);
4562 target_terminal_inferior ();
4568 fprintf_unfiltered (gdb_stdlog
, "bpstat_what: bp_jit_event\n");
4570 handle_jit_event ();
4573 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
4575 struct breakpoint
*b
= bs
->breakpoint_at
;
4581 case bp_gnu_ifunc_resolver
:
4582 gnu_ifunc_resolver_stop (b
);
4584 case bp_gnu_ifunc_resolver_return
:
4585 gnu_ifunc_resolver_return_stop (b
);
4593 /* Nonzero if we should step constantly (e.g. watchpoints on machines
4594 without hardware support). This isn't related to a specific bpstat,
4595 just to things like whether watchpoints are set. */
4598 bpstat_should_step (void)
4600 struct breakpoint
*b
;
4603 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
&& b
->loc
!= NULL
)
4609 bpstat_causes_stop (bpstat bs
)
4611 for (; bs
!= NULL
; bs
= bs
->next
)
4620 /* Compute a string of spaces suitable to indent the next line
4621 so it starts at the position corresponding to the table column
4622 named COL_NAME in the currently active table of UIOUT. */
4625 wrap_indent_at_field (struct ui_out
*uiout
, const char *col_name
)
4627 static char wrap_indent
[80];
4628 int i
, total_width
, width
, align
;
4632 for (i
= 1; ui_out_query_field (uiout
, i
, &width
, &align
, &text
); i
++)
4634 if (strcmp (text
, col_name
) == 0)
4636 gdb_assert (total_width
< sizeof wrap_indent
);
4637 memset (wrap_indent
, ' ', total_width
);
4638 wrap_indent
[total_width
] = 0;
4643 total_width
+= width
+ 1;
4649 /* Print the LOC location out of the list of B->LOC locations. */
4652 print_breakpoint_location (struct breakpoint
*b
,
4653 struct bp_location
*loc
)
4655 struct cleanup
*old_chain
= save_current_program_space ();
4657 if (loc
!= NULL
&& loc
->shlib_disabled
)
4661 set_current_program_space (loc
->pspace
);
4663 if (b
->display_canonical
)
4664 ui_out_field_string (uiout
, "what", b
->addr_string
);
4665 else if (b
->source_file
&& loc
)
4668 = find_pc_sect_function (loc
->address
, loc
->section
);
4671 ui_out_text (uiout
, "in ");
4672 ui_out_field_string (uiout
, "func",
4673 SYMBOL_PRINT_NAME (sym
));
4674 ui_out_text (uiout
, " ");
4675 ui_out_wrap_hint (uiout
, wrap_indent_at_field (uiout
, "what"));
4676 ui_out_text (uiout
, "at ");
4678 ui_out_field_string (uiout
, "file", b
->source_file
);
4679 ui_out_text (uiout
, ":");
4681 if (ui_out_is_mi_like_p (uiout
))
4683 struct symtab_and_line sal
= find_pc_line (loc
->address
, 0);
4684 char *fullname
= symtab_to_fullname (sal
.symtab
);
4687 ui_out_field_string (uiout
, "fullname", fullname
);
4690 ui_out_field_int (uiout
, "line", b
->line_number
);
4694 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
4695 struct cleanup
*stb_chain
= make_cleanup_ui_out_stream_delete (stb
);
4697 print_address_symbolic (loc
->gdbarch
, loc
->address
, stb
->stream
,
4699 ui_out_field_stream (uiout
, "at", stb
);
4701 do_cleanups (stb_chain
);
4704 ui_out_field_string (uiout
, "pending", b
->addr_string
);
4706 do_cleanups (old_chain
);
4710 bptype_string (enum bptype type
)
4712 struct ep_type_description
4717 static struct ep_type_description bptypes
[] =
4719 {bp_none
, "?deleted?"},
4720 {bp_breakpoint
, "breakpoint"},
4721 {bp_hardware_breakpoint
, "hw breakpoint"},
4722 {bp_until
, "until"},
4723 {bp_finish
, "finish"},
4724 {bp_watchpoint
, "watchpoint"},
4725 {bp_hardware_watchpoint
, "hw watchpoint"},
4726 {bp_read_watchpoint
, "read watchpoint"},
4727 {bp_access_watchpoint
, "acc watchpoint"},
4728 {bp_longjmp
, "longjmp"},
4729 {bp_longjmp_resume
, "longjmp resume"},
4730 {bp_exception
, "exception"},
4731 {bp_exception_resume
, "exception resume"},
4732 {bp_step_resume
, "step resume"},
4733 {bp_watchpoint_scope
, "watchpoint scope"},
4734 {bp_call_dummy
, "call dummy"},
4735 {bp_std_terminate
, "std::terminate"},
4736 {bp_shlib_event
, "shlib events"},
4737 {bp_thread_event
, "thread events"},
4738 {bp_overlay_event
, "overlay events"},
4739 {bp_longjmp_master
, "longjmp master"},
4740 {bp_std_terminate_master
, "std::terminate master"},
4741 {bp_exception_master
, "exception master"},
4742 {bp_catchpoint
, "catchpoint"},
4743 {bp_tracepoint
, "tracepoint"},
4744 {bp_fast_tracepoint
, "fast tracepoint"},
4745 {bp_static_tracepoint
, "static tracepoint"},
4746 {bp_jit_event
, "jit events"},
4747 {bp_gnu_ifunc_resolver
, "STT_GNU_IFUNC resolver"},
4748 {bp_gnu_ifunc_resolver_return
, "STT_GNU_IFUNC resolver return"},
4751 if (((int) type
>= (sizeof (bptypes
) / sizeof (bptypes
[0])))
4752 || ((int) type
!= bptypes
[(int) type
].type
))
4753 internal_error (__FILE__
, __LINE__
,
4754 _("bptypes table does not describe type #%d."),
4757 return bptypes
[(int) type
].description
;
4760 /* Print B to gdb_stdout. */
4763 print_one_breakpoint_location (struct breakpoint
*b
,
4764 struct bp_location
*loc
,
4766 struct bp_location
**last_loc
,
4769 struct command_line
*l
;
4770 static char bpenables
[] = "nynny";
4771 struct cleanup
*bkpt_chain
;
4773 int header_of_multiple
= 0;
4774 int part_of_multiple
= (loc
!= NULL
);
4775 struct value_print_options opts
;
4777 get_user_print_options (&opts
);
4779 gdb_assert (!loc
|| loc_number
!= 0);
4780 /* See comment in print_one_breakpoint concerning treatment of
4781 breakpoints with single disabled location. */
4784 && (b
->loc
->next
!= NULL
|| !b
->loc
->enabled
)))
4785 header_of_multiple
= 1;
4790 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "bkpt");
4794 if (part_of_multiple
)
4797 formatted
= xstrprintf ("%d.%d", b
->number
, loc_number
);
4798 ui_out_field_string (uiout
, "number", formatted
);
4803 ui_out_field_int (uiout
, "number", b
->number
);
4808 if (part_of_multiple
)
4809 ui_out_field_skip (uiout
, "type");
4811 ui_out_field_string (uiout
, "type", bptype_string (b
->type
));
4815 if (part_of_multiple
)
4816 ui_out_field_skip (uiout
, "disp");
4818 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
4823 if (part_of_multiple
)
4824 ui_out_field_string (uiout
, "enabled", loc
->enabled
? "y" : "n");
4826 ui_out_field_fmt (uiout
, "enabled", "%c",
4827 bpenables
[(int) b
->enable_state
]);
4828 ui_out_spaces (uiout
, 2);
4832 if (b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
4834 /* Although the print_one can possibly print all locations,
4835 calling it here is not likely to get any nice result. So,
4836 make sure there's just one location. */
4837 gdb_assert (b
->loc
== NULL
|| b
->loc
->next
== NULL
);
4838 b
->ops
->print_one (b
, last_loc
);
4844 internal_error (__FILE__
, __LINE__
,
4845 _("print_one_breakpoint: bp_none encountered\n"));
4849 case bp_hardware_watchpoint
:
4850 case bp_read_watchpoint
:
4851 case bp_access_watchpoint
:
4852 /* Field 4, the address, is omitted (which makes the columns
4853 not line up too nicely with the headers, but the effect
4854 is relatively readable). */
4855 if (opts
.addressprint
)
4856 ui_out_field_skip (uiout
, "addr");
4858 ui_out_field_string (uiout
, "what", b
->exp_string
);
4862 case bp_hardware_breakpoint
:
4866 case bp_longjmp_resume
:
4868 case bp_exception_resume
:
4869 case bp_step_resume
:
4870 case bp_watchpoint_scope
:
4872 case bp_std_terminate
:
4873 case bp_shlib_event
:
4874 case bp_thread_event
:
4875 case bp_overlay_event
:
4876 case bp_longjmp_master
:
4877 case bp_std_terminate_master
:
4878 case bp_exception_master
:
4880 case bp_fast_tracepoint
:
4881 case bp_static_tracepoint
:
4883 case bp_gnu_ifunc_resolver
:
4884 case bp_gnu_ifunc_resolver_return
:
4885 if (opts
.addressprint
)
4888 if (header_of_multiple
)
4889 ui_out_field_string (uiout
, "addr", "<MULTIPLE>");
4890 else if (b
->loc
== NULL
|| loc
->shlib_disabled
)
4891 ui_out_field_string (uiout
, "addr", "<PENDING>");
4893 ui_out_field_core_addr (uiout
, "addr",
4894 loc
->gdbarch
, loc
->address
);
4897 if (!header_of_multiple
)
4898 print_breakpoint_location (b
, loc
);
4905 /* For backward compatibility, don't display inferiors unless there
4908 && !header_of_multiple
4910 || (!gdbarch_has_global_breakpoints (target_gdbarch
)
4911 && (number_of_program_spaces () > 1
4912 || number_of_inferiors () > 1)
4913 /* LOC is for existing B, it cannot be in
4914 moribund_locations and thus having NULL OWNER. */
4915 && loc
->owner
->type
!= bp_catchpoint
)))
4917 struct inferior
*inf
;
4920 for (inf
= inferior_list
; inf
!= NULL
; inf
= inf
->next
)
4922 if (inf
->pspace
== loc
->pspace
)
4927 ui_out_text (uiout
, " inf ");
4930 ui_out_text (uiout
, ", ");
4931 ui_out_text (uiout
, plongest (inf
->num
));
4936 if (!part_of_multiple
)
4938 if (b
->thread
!= -1)
4940 /* FIXME: This seems to be redundant and lost here; see the
4941 "stop only in" line a little further down. */
4942 ui_out_text (uiout
, " thread ");
4943 ui_out_field_int (uiout
, "thread", b
->thread
);
4945 else if (b
->task
!= 0)
4947 ui_out_text (uiout
, " task ");
4948 ui_out_field_int (uiout
, "task", b
->task
);
4952 ui_out_text (uiout
, "\n");
4954 if (!part_of_multiple
&& b
->ops
&& b
->ops
->print_one_detail
)
4955 b
->ops
->print_one_detail (b
, uiout
);
4957 if (!part_of_multiple
&& b
->static_trace_marker_id
)
4959 gdb_assert (b
->type
== bp_static_tracepoint
);
4961 ui_out_text (uiout
, "\tmarker id is ");
4962 ui_out_field_string (uiout
, "static-tracepoint-marker-string-id",
4963 b
->static_trace_marker_id
);
4964 ui_out_text (uiout
, "\n");
4967 if (part_of_multiple
&& frame_id_p (b
->frame_id
))
4970 ui_out_text (uiout
, "\tstop only in stack frame at ");
4971 /* FIXME: cagney/2002-12-01: Shouldn't be poeking around inside
4973 ui_out_field_core_addr (uiout
, "frame",
4974 b
->gdbarch
, b
->frame_id
.stack_addr
);
4975 ui_out_text (uiout
, "\n");
4978 if (!part_of_multiple
&& b
->cond_string
&& !ada_exception_catchpoint_p (b
))
4980 /* We do not print the condition for Ada exception catchpoints
4981 because the condition is an internal implementation detail
4982 that we do not want to expose to the user. */
4984 if (is_tracepoint (b
))
4985 ui_out_text (uiout
, "\ttrace only if ");
4987 ui_out_text (uiout
, "\tstop only if ");
4988 ui_out_field_string (uiout
, "cond", b
->cond_string
);
4989 ui_out_text (uiout
, "\n");
4992 if (!part_of_multiple
&& b
->thread
!= -1)
4994 /* FIXME should make an annotation for this. */
4995 ui_out_text (uiout
, "\tstop only in thread ");
4996 ui_out_field_int (uiout
, "thread", b
->thread
);
4997 ui_out_text (uiout
, "\n");
5000 if (!part_of_multiple
&& b
->hit_count
)
5002 /* FIXME should make an annotation for this. */
5003 if (ep_is_catchpoint (b
))
5004 ui_out_text (uiout
, "\tcatchpoint");
5006 ui_out_text (uiout
, "\tbreakpoint");
5007 ui_out_text (uiout
, " already hit ");
5008 ui_out_field_int (uiout
, "times", b
->hit_count
);
5009 if (b
->hit_count
== 1)
5010 ui_out_text (uiout
, " time\n");
5012 ui_out_text (uiout
, " times\n");
5015 /* Output the count also if it is zero, but only if this is mi.
5016 FIXME: Should have a better test for this. */
5017 if (ui_out_is_mi_like_p (uiout
))
5018 if (!part_of_multiple
&& b
->hit_count
== 0)
5019 ui_out_field_int (uiout
, "times", b
->hit_count
);
5021 if (!part_of_multiple
&& b
->ignore_count
)
5024 ui_out_text (uiout
, "\tignore next ");
5025 ui_out_field_int (uiout
, "ignore", b
->ignore_count
);
5026 ui_out_text (uiout
, " hits\n");
5029 l
= b
->commands
? b
->commands
->commands
: NULL
;
5030 if (!part_of_multiple
&& l
)
5032 struct cleanup
*script_chain
;
5035 script_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "script");
5036 print_command_lines (uiout
, l
, 4);
5037 do_cleanups (script_chain
);
5040 if (!part_of_multiple
&& b
->pass_count
)
5042 annotate_field (10);
5043 ui_out_text (uiout
, "\tpass count ");
5044 ui_out_field_int (uiout
, "pass", b
->pass_count
);
5045 ui_out_text (uiout
, " \n");
5048 if (ui_out_is_mi_like_p (uiout
) && !part_of_multiple
)
5051 ui_out_field_string (uiout
, "original-location", b
->addr_string
);
5052 else if (b
->exp_string
)
5053 ui_out_field_string (uiout
, "original-location", b
->exp_string
);
5056 do_cleanups (bkpt_chain
);
5060 print_one_breakpoint (struct breakpoint
*b
,
5061 struct bp_location
**last_loc
,
5064 print_one_breakpoint_location (b
, NULL
, 0, last_loc
, allflag
);
5066 /* If this breakpoint has custom print function,
5067 it's already printed. Otherwise, print individual
5068 locations, if any. */
5069 if (b
->ops
== NULL
|| b
->ops
->print_one
== NULL
)
5071 /* If breakpoint has a single location that is disabled, we
5072 print it as if it had several locations, since otherwise it's
5073 hard to represent "breakpoint enabled, location disabled"
5076 Note that while hardware watchpoints have several locations
5077 internally, that's not a property exposed to user. */
5079 && !is_hardware_watchpoint (b
)
5080 && (b
->loc
->next
|| !b
->loc
->enabled
)
5081 && !ui_out_is_mi_like_p (uiout
))
5083 struct bp_location
*loc
;
5085 for (loc
= b
->loc
; loc
; loc
= loc
->next
, ++n
)
5086 print_one_breakpoint_location (b
, loc
, n
, last_loc
, allflag
);
5092 breakpoint_address_bits (struct breakpoint
*b
)
5094 int print_address_bits
= 0;
5095 struct bp_location
*loc
;
5097 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
5101 /* Software watchpoints that aren't watching memory don't have
5102 an address to print. */
5103 if (b
->type
== bp_watchpoint
&& loc
->watchpoint_type
== -1)
5106 addr_bit
= gdbarch_addr_bit (loc
->gdbarch
);
5107 if (addr_bit
> print_address_bits
)
5108 print_address_bits
= addr_bit
;
5111 return print_address_bits
;
5114 struct captured_breakpoint_query_args
5120 do_captured_breakpoint_query (struct ui_out
*uiout
, void *data
)
5122 struct captured_breakpoint_query_args
*args
= data
;
5123 struct breakpoint
*b
;
5124 struct bp_location
*dummy_loc
= NULL
;
5128 if (args
->bnum
== b
->number
)
5130 print_one_breakpoint (b
, &dummy_loc
, 0);
5138 gdb_breakpoint_query (struct ui_out
*uiout
, int bnum
,
5139 char **error_message
)
5141 struct captured_breakpoint_query_args args
;
5144 /* For the moment we don't trust print_one_breakpoint() to not throw
5146 if (catch_exceptions_with_msg (uiout
, do_captured_breakpoint_query
, &args
,
5147 error_message
, RETURN_MASK_ALL
) < 0)
5153 /* Return non-zero if B is user settable (breakpoints, watchpoints,
5154 catchpoints, et.al.). */
5157 user_settable_breakpoint (const struct breakpoint
*b
)
5159 return (b
->type
== bp_breakpoint
5160 || b
->type
== bp_catchpoint
5161 || b
->type
== bp_hardware_breakpoint
5162 || is_tracepoint (b
)
5163 || is_watchpoint (b
)
5164 || b
->type
== bp_gnu_ifunc_resolver
);
5167 /* Return true if this breakpoint was set by the user, false if it is
5168 internal or momentary. */
5171 user_breakpoint_p (struct breakpoint
*b
)
5173 return user_settable_breakpoint (b
) && b
->number
> 0;
5176 /* Print information on user settable breakpoint (watchpoint, etc)
5177 number BNUM. If BNUM is -1 print all user-settable breakpoints.
5178 If ALLFLAG is non-zero, include non-user-settable breakpoints. If
5179 FILTER is non-NULL, call it on each breakpoint and only include the
5180 ones for which it returns non-zero. Return the total number of
5181 breakpoints listed. */
5184 breakpoint_1 (char *args
, int allflag
,
5185 int (*filter
) (const struct breakpoint
*))
5187 struct breakpoint
*b
;
5188 struct bp_location
*last_loc
= NULL
;
5189 int nr_printable_breakpoints
;
5190 struct cleanup
*bkpttbl_chain
;
5191 struct value_print_options opts
;
5192 int print_address_bits
= 0;
5193 int print_type_col_width
= 14;
5195 get_user_print_options (&opts
);
5197 /* Compute the number of rows in the table, as well as the size
5198 required for address fields. */
5199 nr_printable_breakpoints
= 0;
5202 /* If we have a filter, only list the breakpoints it accepts. */
5203 if (filter
&& !filter (b
))
5206 /* If we have an "args" string, it is a list of breakpoints to
5207 accept. Skip the others. */
5208 if (args
!= NULL
&& *args
!= '\0')
5210 if (allflag
&& parse_and_eval_long (args
) != b
->number
)
5212 if (!allflag
&& !number_is_in_list (args
, b
->number
))
5216 if (allflag
|| user_breakpoint_p (b
))
5218 int addr_bit
, type_len
;
5220 addr_bit
= breakpoint_address_bits (b
);
5221 if (addr_bit
> print_address_bits
)
5222 print_address_bits
= addr_bit
;
5224 type_len
= strlen (bptype_string (b
->type
));
5225 if (type_len
> print_type_col_width
)
5226 print_type_col_width
= type_len
;
5228 nr_printable_breakpoints
++;
5232 if (opts
.addressprint
)
5234 = make_cleanup_ui_out_table_begin_end (uiout
, 6,
5235 nr_printable_breakpoints
,
5239 = make_cleanup_ui_out_table_begin_end (uiout
, 5,
5240 nr_printable_breakpoints
,
5243 if (nr_printable_breakpoints
> 0)
5244 annotate_breakpoints_headers ();
5245 if (nr_printable_breakpoints
> 0)
5247 ui_out_table_header (uiout
, 7, ui_left
, "number", "Num"); /* 1 */
5248 if (nr_printable_breakpoints
> 0)
5250 ui_out_table_header (uiout
, print_type_col_width
, ui_left
,
5251 "type", "Type"); /* 2 */
5252 if (nr_printable_breakpoints
> 0)
5254 ui_out_table_header (uiout
, 4, ui_left
, "disp", "Disp"); /* 3 */
5255 if (nr_printable_breakpoints
> 0)
5257 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb"); /* 4 */
5258 if (opts
.addressprint
)
5260 if (nr_printable_breakpoints
> 0)
5262 if (print_address_bits
<= 32)
5263 ui_out_table_header (uiout
, 10, ui_left
,
5264 "addr", "Address"); /* 5 */
5266 ui_out_table_header (uiout
, 18, ui_left
,
5267 "addr", "Address"); /* 5 */
5269 if (nr_printable_breakpoints
> 0)
5271 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What"); /* 6 */
5272 ui_out_table_body (uiout
);
5273 if (nr_printable_breakpoints
> 0)
5274 annotate_breakpoints_table ();
5279 /* If we have a filter, only list the breakpoints it accepts. */
5280 if (filter
&& !filter (b
))
5283 /* If we have an "args" string, it is a list of breakpoints to
5284 accept. Skip the others. */
5286 if (args
!= NULL
&& *args
!= '\0')
5288 if (allflag
) /* maintenance info breakpoint */
5290 if (parse_and_eval_long (args
) != b
->number
)
5293 else /* all others */
5295 if (!number_is_in_list (args
, b
->number
))
5299 /* We only print out user settable breakpoints unless the
5301 if (allflag
|| user_breakpoint_p (b
))
5302 print_one_breakpoint (b
, &last_loc
, allflag
);
5305 do_cleanups (bkpttbl_chain
);
5307 if (nr_printable_breakpoints
== 0)
5309 /* If there's a filter, let the caller decide how to report
5313 if (args
== NULL
|| *args
== '\0')
5314 ui_out_message (uiout
, 0, "No breakpoints or watchpoints.\n");
5316 ui_out_message (uiout
, 0,
5317 "No breakpoint or watchpoint matching '%s'.\n",
5323 if (last_loc
&& !server_command
)
5324 set_next_address (last_loc
->gdbarch
, last_loc
->address
);
5327 /* FIXME? Should this be moved up so that it is only called when
5328 there have been breakpoints? */
5329 annotate_breakpoints_table_end ();
5331 return nr_printable_breakpoints
;
5334 /* Display the value of default-collect in a way that is generally
5335 compatible with the breakpoint list. */
5338 default_collect_info (void)
5340 /* If it has no value (which is frequently the case), say nothing; a
5341 message like "No default-collect." gets in user's face when it's
5343 if (!*default_collect
)
5346 /* The following phrase lines up nicely with per-tracepoint collect
5348 ui_out_text (uiout
, "default collect ");
5349 ui_out_field_string (uiout
, "default-collect", default_collect
);
5350 ui_out_text (uiout
, " \n");
5354 breakpoints_info (char *args
, int from_tty
)
5356 breakpoint_1 (args
, 0, NULL
);
5358 default_collect_info ();
5362 watchpoints_info (char *args
, int from_tty
)
5364 int num_printed
= breakpoint_1 (args
, 0, is_watchpoint
);
5366 if (num_printed
== 0)
5368 if (args
== NULL
|| *args
== '\0')
5369 ui_out_message (uiout
, 0, "No watchpoints.\n");
5371 ui_out_message (uiout
, 0, "No watchpoint matching '%s'.\n", args
);
5376 maintenance_info_breakpoints (char *args
, int from_tty
)
5378 breakpoint_1 (args
, 1, NULL
);
5380 default_collect_info ();
5384 breakpoint_has_pc (struct breakpoint
*b
,
5385 struct program_space
*pspace
,
5386 CORE_ADDR pc
, struct obj_section
*section
)
5388 struct bp_location
*bl
= b
->loc
;
5390 for (; bl
; bl
= bl
->next
)
5392 if (bl
->pspace
== pspace
5393 && bl
->address
== pc
5394 && (!overlay_debugging
|| bl
->section
== section
))
5400 /* Print a message describing any breakpoints set at PC. This
5401 concerns with logical breakpoints, so we match program spaces, not
5405 describe_other_breakpoints (struct gdbarch
*gdbarch
,
5406 struct program_space
*pspace
, CORE_ADDR pc
,
5407 struct obj_section
*section
, int thread
)
5410 struct breakpoint
*b
;
5413 others
+= breakpoint_has_pc (b
, pspace
, pc
, section
);
5417 printf_filtered (_("Note: breakpoint "));
5418 else /* if (others == ???) */
5419 printf_filtered (_("Note: breakpoints "));
5421 if (breakpoint_has_pc (b
, pspace
, pc
, section
))
5424 printf_filtered ("%d", b
->number
);
5425 if (b
->thread
== -1 && thread
!= -1)
5426 printf_filtered (" (all threads)");
5427 else if (b
->thread
!= -1)
5428 printf_filtered (" (thread %d)", b
->thread
);
5429 printf_filtered ("%s%s ",
5430 ((b
->enable_state
== bp_disabled
5431 || b
->enable_state
== bp_call_disabled
5432 || b
->enable_state
== bp_startup_disabled
)
5434 : b
->enable_state
== bp_permanent
5438 : ((others
== 1) ? " and" : ""));
5440 printf_filtered (_("also set at pc "));
5441 fputs_filtered (paddress (gdbarch
, pc
), gdb_stdout
);
5442 printf_filtered (".\n");
5446 /* Set the default place to put a breakpoint
5447 for the `break' command with no arguments. */
5450 set_default_breakpoint (int valid
, struct program_space
*pspace
,
5451 CORE_ADDR addr
, struct symtab
*symtab
,
5454 default_breakpoint_valid
= valid
;
5455 default_breakpoint_pspace
= pspace
;
5456 default_breakpoint_address
= addr
;
5457 default_breakpoint_symtab
= symtab
;
5458 default_breakpoint_line
= line
;
5461 /* Return true iff it is meaningful to use the address member of
5462 BPT. For some breakpoint types, the address member is irrelevant
5463 and it makes no sense to attempt to compare it to other addresses
5464 (or use it for any other purpose either).
5466 More specifically, each of the following breakpoint types will
5467 always have a zero valued address and we don't want to mark
5468 breakpoints of any of these types to be a duplicate of an actual
5469 breakpoint at address zero:
5477 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
5479 enum bptype type
= bpt
->type
;
5481 return (type
!= bp_watchpoint
&& type
!= bp_catchpoint
);
5484 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
5485 true if LOC1 and LOC2 represent the same watchpoint location. */
5488 watchpoint_locations_match (struct bp_location
*loc1
,
5489 struct bp_location
*loc2
)
5491 /* Both of them must not be in moribund_locations. */
5492 gdb_assert (loc1
->owner
!= NULL
);
5493 gdb_assert (loc2
->owner
!= NULL
);
5495 /* If the target can evaluate the condition expression in hardware,
5496 then we we need to insert both watchpoints even if they are at
5497 the same place. Otherwise the watchpoint will only trigger when
5498 the condition of whichever watchpoint was inserted evaluates to
5499 true, not giving a chance for GDB to check the condition of the
5500 other watchpoint. */
5501 if ((loc1
->owner
->cond_exp
5502 && target_can_accel_watchpoint_condition (loc1
->address
,
5504 loc1
->watchpoint_type
,
5505 loc1
->owner
->cond_exp
))
5506 || (loc2
->owner
->cond_exp
5507 && target_can_accel_watchpoint_condition (loc2
->address
,
5509 loc2
->watchpoint_type
,
5510 loc2
->owner
->cond_exp
)))
5513 /* Note that this checks the owner's type, not the location's. In
5514 case the target does not support read watchpoints, but does
5515 support access watchpoints, we'll have bp_read_watchpoint
5516 watchpoints with hw_access locations. Those should be considered
5517 duplicates of hw_read locations. The hw_read locations will
5518 become hw_access locations later. */
5519 return (loc1
->owner
->type
== loc2
->owner
->type
5520 && loc1
->pspace
->aspace
== loc2
->pspace
->aspace
5521 && loc1
->address
== loc2
->address
5522 && loc1
->length
== loc2
->length
);
5525 /* Returns true if {ASPACE1,ADDR1} and {ASPACE2,ADDR2} represent the
5526 same breakpoint location. In most targets, this can only be true
5527 if ASPACE1 matches ASPACE2. On targets that have global
5528 breakpoints, the address space doesn't really matter. */
5531 breakpoint_address_match (struct address_space
*aspace1
, CORE_ADDR addr1
,
5532 struct address_space
*aspace2
, CORE_ADDR addr2
)
5534 return ((gdbarch_has_global_breakpoints (target_gdbarch
)
5535 || aspace1
== aspace2
)
5539 /* Returns true if {ASPACE2,ADDR2} falls within the range determined by
5540 {ASPACE1,ADDR1,LEN1}. In most targets, this can only be true if ASPACE1
5541 matches ASPACE2. On targets that have global breakpoints, the address
5542 space doesn't really matter. */
5545 breakpoint_address_match_range (struct address_space
*aspace1
, CORE_ADDR addr1
,
5546 int len1
, struct address_space
*aspace2
,
5549 return ((gdbarch_has_global_breakpoints (target_gdbarch
)
5550 || aspace1
== aspace2
)
5551 && addr2
>= addr1
&& addr2
< addr1
+ len1
);
5554 /* Returns true if {ASPACE,ADDR} matches the breakpoint BL. BL may be
5555 a ranged breakpoint. In most targets, a match happens only if ASPACE
5556 matches the breakpoint's address space. On targets that have global
5557 breakpoints, the address space doesn't really matter. */
5560 breakpoint_location_address_match (struct bp_location
*bl
,
5561 struct address_space
*aspace
,
5564 return (breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
5567 && breakpoint_address_match_range (bl
->pspace
->aspace
,
5568 bl
->address
, bl
->length
,
5572 /* Assuming LOC1 and LOC2's types' have meaningful target addresses
5573 (breakpoint_address_is_meaningful), returns true if LOC1 and LOC2
5574 represent the same location. */
5577 breakpoint_locations_match (struct bp_location
*loc1
,
5578 struct bp_location
*loc2
)
5580 int hw_point1
, hw_point2
;
5582 /* Both of them must not be in moribund_locations. */
5583 gdb_assert (loc1
->owner
!= NULL
);
5584 gdb_assert (loc2
->owner
!= NULL
);
5586 hw_point1
= is_hardware_watchpoint (loc1
->owner
);
5587 hw_point2
= is_hardware_watchpoint (loc2
->owner
);
5589 if (hw_point1
!= hw_point2
)
5592 return watchpoint_locations_match (loc1
, loc2
);
5594 /* We compare bp_location.length in order to cover ranged breakpoints. */
5595 return (breakpoint_address_match (loc1
->pspace
->aspace
, loc1
->address
,
5596 loc2
->pspace
->aspace
, loc2
->address
)
5597 && loc1
->length
== loc2
->length
);
5601 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
5602 int bnum
, int have_bnum
)
5604 /* The longest string possibly returned by hex_string_custom
5605 is 50 chars. These must be at least that big for safety. */
5609 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
5610 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
5612 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
5613 bnum
, astr1
, astr2
);
5615 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
5618 /* Adjust a breakpoint's address to account for architectural
5619 constraints on breakpoint placement. Return the adjusted address.
5620 Note: Very few targets require this kind of adjustment. For most
5621 targets, this function is simply the identity function. */
5624 adjust_breakpoint_address (struct gdbarch
*gdbarch
,
5625 CORE_ADDR bpaddr
, enum bptype bptype
)
5627 if (!gdbarch_adjust_breakpoint_address_p (gdbarch
))
5629 /* Very few targets need any kind of breakpoint adjustment. */
5632 else if (bptype
== bp_watchpoint
5633 || bptype
== bp_hardware_watchpoint
5634 || bptype
== bp_read_watchpoint
5635 || bptype
== bp_access_watchpoint
5636 || bptype
== bp_catchpoint
)
5638 /* Watchpoints and the various bp_catch_* eventpoints should not
5639 have their addresses modified. */
5644 CORE_ADDR adjusted_bpaddr
;
5646 /* Some targets have architectural constraints on the placement
5647 of breakpoint instructions. Obtain the adjusted address. */
5648 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (gdbarch
, bpaddr
);
5650 /* An adjusted breakpoint address can significantly alter
5651 a user's expectations. Print a warning if an adjustment
5653 if (adjusted_bpaddr
!= bpaddr
)
5654 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
5656 return adjusted_bpaddr
;
5660 /* Allocate a struct bp_location. */
5662 static struct bp_location
*
5663 allocate_bp_location (struct breakpoint
*bpt
)
5665 struct bp_location
*loc
;
5667 loc
= xmalloc (sizeof (struct bp_location
));
5668 memset (loc
, 0, sizeof (*loc
));
5672 loc
->shlib_disabled
= 0;
5681 case bp_longjmp_resume
:
5683 case bp_exception_resume
:
5684 case bp_step_resume
:
5685 case bp_watchpoint_scope
:
5687 case bp_std_terminate
:
5688 case bp_shlib_event
:
5689 case bp_thread_event
:
5690 case bp_overlay_event
:
5692 case bp_longjmp_master
:
5693 case bp_std_terminate_master
:
5694 case bp_exception_master
:
5695 case bp_gnu_ifunc_resolver
:
5696 case bp_gnu_ifunc_resolver_return
:
5697 loc
->loc_type
= bp_loc_software_breakpoint
;
5699 case bp_hardware_breakpoint
:
5700 loc
->loc_type
= bp_loc_hardware_breakpoint
;
5702 case bp_hardware_watchpoint
:
5703 case bp_read_watchpoint
:
5704 case bp_access_watchpoint
:
5705 loc
->loc_type
= bp_loc_hardware_watchpoint
;
5710 case bp_fast_tracepoint
:
5711 case bp_static_tracepoint
:
5712 loc
->loc_type
= bp_loc_other
;
5715 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
5723 free_bp_location (struct bp_location
*loc
)
5728 if (loc
->function_name
)
5729 xfree (loc
->function_name
);
5734 /* Increment reference count. */
5737 incref_bp_location (struct bp_location
*bl
)
5742 /* Decrement reference count. If the reference count reaches 0,
5743 destroy the bp_location. Sets *BLP to NULL. */
5746 decref_bp_location (struct bp_location
**blp
)
5748 gdb_assert ((*blp
)->refc
> 0);
5750 if (--(*blp
)->refc
== 0)
5751 free_bp_location (*blp
);
5755 /* Helper to set_raw_breakpoint below. Creates a breakpoint that has
5756 type BPTYPE and has no locations as yet. */
5757 /* This function is used in gdbtk sources and thus can not be made
5760 static struct breakpoint
*
5761 set_raw_breakpoint_without_location (struct gdbarch
*gdbarch
,
5764 struct breakpoint
*b
, *b1
;
5766 b
= (struct breakpoint
*) xmalloc (sizeof (struct breakpoint
));
5767 memset (b
, 0, sizeof (*b
));
5770 b
->gdbarch
= gdbarch
;
5771 b
->language
= current_language
->la_language
;
5772 b
->input_radix
= input_radix
;
5774 b
->enable_state
= bp_enabled
;
5777 b
->ignore_count
= 0;
5779 b
->frame_id
= null_frame_id
;
5780 b
->forked_inferior_pid
= null_ptid
;
5781 b
->exec_pathname
= NULL
;
5782 b
->syscalls_to_be_caught
= NULL
;
5784 b
->condition_not_parsed
= 0;
5785 b
->py_bp_object
= NULL
;
5786 b
->related_breakpoint
= b
;
5788 /* Add this breakpoint to the end of the chain so that a list of
5789 breakpoints will come out in order of increasing numbers. */
5791 b1
= breakpoint_chain
;
5793 breakpoint_chain
= b
;
5803 /* Initialize loc->function_name. EXPLICIT_LOC says no indirect function
5804 resolutions should be made as the user specified the location explicitly
5808 set_breakpoint_location_function (struct bp_location
*loc
, int explicit_loc
)
5810 gdb_assert (loc
->owner
!= NULL
);
5812 if (loc
->owner
->type
== bp_breakpoint
5813 || loc
->owner
->type
== bp_hardware_breakpoint
5814 || is_tracepoint (loc
->owner
))
5818 find_pc_partial_function_gnu_ifunc (loc
->address
, &loc
->function_name
,
5819 NULL
, NULL
, &is_gnu_ifunc
);
5821 if (is_gnu_ifunc
&& !explicit_loc
)
5823 struct breakpoint
*b
= loc
->owner
;
5825 gdb_assert (loc
->pspace
== current_program_space
);
5826 if (gnu_ifunc_resolve_name (loc
->function_name
,
5827 &loc
->requested_address
))
5829 /* Recalculate ADDRESS based on new REQUESTED_ADDRESS. */
5830 loc
->address
= adjust_breakpoint_address (loc
->gdbarch
,
5831 loc
->requested_address
,
5834 else if (b
->type
== bp_breakpoint
&& b
->loc
== loc
5835 && loc
->next
== NULL
&& b
->related_breakpoint
== b
)
5837 /* Create only the whole new breakpoint of this type but do not
5838 mess more complicated breakpoints with multiple locations. */
5839 b
->type
= bp_gnu_ifunc_resolver
;
5843 if (loc
->function_name
)
5844 loc
->function_name
= xstrdup (loc
->function_name
);
5848 /* Attempt to determine architecture of location identified by SAL. */
5849 static struct gdbarch
*
5850 get_sal_arch (struct symtab_and_line sal
)
5853 return get_objfile_arch (sal
.section
->objfile
);
5855 return get_objfile_arch (sal
.symtab
->objfile
);
5860 /* set_raw_breakpoint is a low level routine for allocating and
5861 partially initializing a breakpoint of type BPTYPE. The newly
5862 created breakpoint's address, section, source file name, and line
5863 number are provided by SAL. The newly created and partially
5864 initialized breakpoint is added to the breakpoint chain and
5865 is also returned as the value of this function.
5867 It is expected that the caller will complete the initialization of
5868 the newly created breakpoint struct as well as output any status
5869 information regarding the creation of a new breakpoint. In
5870 particular, set_raw_breakpoint does NOT set the breakpoint
5871 number! Care should be taken to not allow an error to occur
5872 prior to completing the initialization of the breakpoint. If this
5873 should happen, a bogus breakpoint will be left on the chain. */
5876 set_raw_breakpoint (struct gdbarch
*gdbarch
,
5877 struct symtab_and_line sal
, enum bptype bptype
)
5879 struct breakpoint
*b
= set_raw_breakpoint_without_location (gdbarch
,
5881 CORE_ADDR adjusted_address
;
5882 struct gdbarch
*loc_gdbarch
;
5884 loc_gdbarch
= get_sal_arch (sal
);
5886 loc_gdbarch
= b
->gdbarch
;
5888 if (bptype
!= bp_catchpoint
)
5889 gdb_assert (sal
.pspace
!= NULL
);
5891 /* Adjust the breakpoint's address prior to allocating a location.
5892 Once we call allocate_bp_location(), that mostly uninitialized
5893 location will be placed on the location chain. Adjustment of the
5894 breakpoint may cause target_read_memory() to be called and we do
5895 not want its scan of the location chain to find a breakpoint and
5896 location that's only been partially initialized. */
5897 adjusted_address
= adjust_breakpoint_address (loc_gdbarch
,
5900 b
->loc
= allocate_bp_location (b
);
5901 b
->loc
->gdbarch
= loc_gdbarch
;
5902 b
->loc
->requested_address
= sal
.pc
;
5903 b
->loc
->address
= adjusted_address
;
5904 b
->loc
->pspace
= sal
.pspace
;
5906 /* Store the program space that was used to set the breakpoint, for
5907 breakpoint resetting. */
5908 b
->pspace
= sal
.pspace
;
5910 if (sal
.symtab
== NULL
)
5911 b
->source_file
= NULL
;
5913 b
->source_file
= xstrdup (sal
.symtab
->filename
);
5914 b
->loc
->section
= sal
.section
;
5915 b
->line_number
= sal
.line
;
5917 set_breakpoint_location_function (b
->loc
,
5918 sal
.explicit_pc
|| sal
.explicit_line
);
5920 breakpoints_changed ();
5926 /* Note that the breakpoint object B describes a permanent breakpoint
5927 instruction, hard-wired into the inferior's code. */
5929 make_breakpoint_permanent (struct breakpoint
*b
)
5931 struct bp_location
*bl
;
5933 b
->enable_state
= bp_permanent
;
5935 /* By definition, permanent breakpoints are already present in the
5936 code. Mark all locations as inserted. For now,
5937 make_breakpoint_permanent is called in just one place, so it's
5938 hard to say if it's reasonable to have permanent breakpoint with
5939 multiple locations or not, but it's easy to implmement. */
5940 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
5944 /* Call this routine when stepping and nexting to enable a breakpoint
5945 if we do a longjmp() or 'throw' in TP. FRAME is the frame which
5946 initiated the operation. */
5949 set_longjmp_breakpoint (struct thread_info
*tp
, struct frame_id frame
)
5951 struct breakpoint
*b
, *b_tmp
;
5952 int thread
= tp
->num
;
5954 /* To avoid having to rescan all objfile symbols at every step,
5955 we maintain a list of continually-inserted but always disabled
5956 longjmp "master" breakpoints. Here, we simply create momentary
5957 clones of those and enable them for the requested thread. */
5958 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
5959 if (b
->pspace
== current_program_space
5960 && (b
->type
== bp_longjmp_master
5961 || b
->type
== bp_exception_master
))
5963 struct breakpoint
*clone
= clone_momentary_breakpoint (b
);
5965 clone
->type
= b
->type
== bp_longjmp_master
? bp_longjmp
: bp_exception
;
5966 clone
->thread
= thread
;
5969 tp
->initiating_frame
= frame
;
5972 /* Delete all longjmp breakpoints from THREAD. */
5974 delete_longjmp_breakpoint (int thread
)
5976 struct breakpoint
*b
, *b_tmp
;
5978 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
5979 if (b
->type
== bp_longjmp
|| b
->type
== bp_exception
)
5981 if (b
->thread
== thread
)
5982 delete_breakpoint (b
);
5987 enable_overlay_breakpoints (void)
5989 struct breakpoint
*b
;
5992 if (b
->type
== bp_overlay_event
)
5994 b
->enable_state
= bp_enabled
;
5995 update_global_location_list (1);
5996 overlay_events_enabled
= 1;
6001 disable_overlay_breakpoints (void)
6003 struct breakpoint
*b
;
6006 if (b
->type
== bp_overlay_event
)
6008 b
->enable_state
= bp_disabled
;
6009 update_global_location_list (0);
6010 overlay_events_enabled
= 0;
6014 /* Set an active std::terminate breakpoint for each std::terminate
6015 master breakpoint. */
6017 set_std_terminate_breakpoint (void)
6019 struct breakpoint
*b
, *b_tmp
;
6021 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
6022 if (b
->pspace
== current_program_space
6023 && b
->type
== bp_std_terminate_master
)
6025 struct breakpoint
*clone
= clone_momentary_breakpoint (b
);
6026 clone
->type
= bp_std_terminate
;
6030 /* Delete all the std::terminate breakpoints. */
6032 delete_std_terminate_breakpoint (void)
6034 struct breakpoint
*b
, *b_tmp
;
6036 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
6037 if (b
->type
== bp_std_terminate
)
6038 delete_breakpoint (b
);
6042 create_thread_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
6044 struct breakpoint
*b
;
6046 b
= create_internal_breakpoint (gdbarch
, address
, bp_thread_event
);
6048 b
->enable_state
= bp_enabled
;
6049 /* addr_string has to be used or breakpoint_re_set will delete me. */
6051 = xstrprintf ("*%s", paddress (b
->loc
->gdbarch
, b
->loc
->address
));
6053 update_global_location_list_nothrow (1);
6059 remove_thread_event_breakpoints (void)
6061 struct breakpoint
*b
, *b_tmp
;
6063 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
6064 if (b
->type
== bp_thread_event
6065 && b
->loc
->pspace
== current_program_space
)
6066 delete_breakpoint (b
);
6069 struct lang_and_radix
6075 /* Create a breakpoint for JIT code registration and unregistration. */
6078 create_jit_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
6080 struct breakpoint
*b
;
6082 b
= create_internal_breakpoint (gdbarch
, address
, bp_jit_event
);
6083 update_global_location_list_nothrow (1);
6087 /* Remove JIT code registration and unregistration breakpoint(s). */
6090 remove_jit_event_breakpoints (void)
6092 struct breakpoint
*b
, *b_tmp
;
6094 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
6095 if (b
->type
== bp_jit_event
6096 && b
->loc
->pspace
== current_program_space
)
6097 delete_breakpoint (b
);
6101 remove_solib_event_breakpoints (void)
6103 struct breakpoint
*b
, *b_tmp
;
6105 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
6106 if (b
->type
== bp_shlib_event
6107 && b
->loc
->pspace
== current_program_space
)
6108 delete_breakpoint (b
);
6112 create_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
6114 struct breakpoint
*b
;
6116 b
= create_internal_breakpoint (gdbarch
, address
, bp_shlib_event
);
6117 update_global_location_list_nothrow (1);
6121 /* Disable any breakpoints that are on code in shared libraries. Only
6122 apply to enabled breakpoints, disabled ones can just stay disabled. */
6125 disable_breakpoints_in_shlibs (void)
6127 struct bp_location
*loc
, **locp_tmp
;
6129 ALL_BP_LOCATIONS (loc
, locp_tmp
)
6131 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
6132 struct breakpoint
*b
= loc
->owner
;
6134 /* We apply the check to all breakpoints, including disabled for
6135 those with loc->duplicate set. This is so that when breakpoint
6136 becomes enabled, or the duplicate is removed, gdb will try to
6137 insert all breakpoints. If we don't set shlib_disabled here,
6138 we'll try to insert those breakpoints and fail. */
6139 if (((b
->type
== bp_breakpoint
)
6140 || (b
->type
== bp_jit_event
)
6141 || (b
->type
== bp_hardware_breakpoint
)
6142 || (is_tracepoint (b
)))
6143 && loc
->pspace
== current_program_space
6144 && !loc
->shlib_disabled
6146 && PC_SOLIB (loc
->address
)
6148 && solib_name_from_address (loc
->pspace
, loc
->address
)
6152 loc
->shlib_disabled
= 1;
6157 /* Disable any breakpoints that are in in an unloaded shared library.
6158 Only apply to enabled breakpoints, disabled ones can just stay
6162 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
6164 struct bp_location
*loc
, **locp_tmp
;
6165 int disabled_shlib_breaks
= 0;
6167 /* SunOS a.out shared libraries are always mapped, so do not
6168 disable breakpoints; they will only be reported as unloaded
6169 through clear_solib when GDB discards its shared library
6170 list. See clear_solib for more information. */
6171 if (exec_bfd
!= NULL
6172 && bfd_get_flavour (exec_bfd
) == bfd_target_aout_flavour
)
6175 ALL_BP_LOCATIONS (loc
, locp_tmp
)
6177 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
6178 struct breakpoint
*b
= loc
->owner
;
6180 if ((loc
->loc_type
== bp_loc_hardware_breakpoint
6181 || loc
->loc_type
== bp_loc_software_breakpoint
)
6182 && solib
->pspace
== loc
->pspace
6183 && !loc
->shlib_disabled
6184 && (b
->type
== bp_breakpoint
6185 || b
->type
== bp_jit_event
6186 || b
->type
== bp_hardware_breakpoint
)
6187 && solib_contains_address_p (solib
, loc
->address
))
6189 loc
->shlib_disabled
= 1;
6190 /* At this point, we cannot rely on remove_breakpoint
6191 succeeding so we must mark the breakpoint as not inserted
6192 to prevent future errors occurring in remove_breakpoints. */
6194 if (!disabled_shlib_breaks
)
6196 target_terminal_ours_for_output ();
6197 warning (_("Temporarily disabling breakpoints "
6198 "for unloaded shared library \"%s\""),
6201 disabled_shlib_breaks
= 1;
6206 /* FORK & VFORK catchpoints. */
6208 /* Implement the "insert" breakpoint_ops method for fork
6212 insert_catch_fork (struct bp_location
*bl
)
6214 return target_insert_fork_catchpoint (PIDGET (inferior_ptid
));
6217 /* Implement the "remove" breakpoint_ops method for fork
6221 remove_catch_fork (struct bp_location
*bl
)
6223 return target_remove_fork_catchpoint (PIDGET (inferior_ptid
));
6226 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
6230 breakpoint_hit_catch_fork (const struct bp_location
*bl
,
6231 struct address_space
*aspace
, CORE_ADDR bp_addr
)
6233 return inferior_has_forked (inferior_ptid
, &bl
->owner
->forked_inferior_pid
);
6236 /* Implement the "print_it" breakpoint_ops method for fork
6239 static enum print_stop_action
6240 print_it_catch_fork (struct breakpoint
*b
)
6242 annotate_catchpoint (b
->number
);
6243 printf_filtered (_("\nCatchpoint %d (forked process %d), "),
6244 b
->number
, ptid_get_pid (b
->forked_inferior_pid
));
6245 return PRINT_SRC_AND_LOC
;
6248 /* Implement the "print_one" breakpoint_ops method for fork
6252 print_one_catch_fork (struct breakpoint
*b
, struct bp_location
**last_loc
)
6254 struct value_print_options opts
;
6256 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
, "fork");
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 fork
6278 print_mention_catch_fork (struct breakpoint
*b
)
6280 printf_filtered (_("Catchpoint %d (fork)"), b
->number
);
6283 /* Implement the "print_recreate" breakpoint_ops method for fork
6287 print_recreate_catch_fork (struct breakpoint
*b
, struct ui_file
*fp
)
6289 fprintf_unfiltered (fp
, "catch fork");
6292 /* The breakpoint_ops structure to be used in fork catchpoints. */
6294 static struct breakpoint_ops catch_fork_breakpoint_ops
=
6298 breakpoint_hit_catch_fork
,
6299 NULL
, /* resources_needed */
6300 print_it_catch_fork
,
6301 print_one_catch_fork
,
6302 NULL
, /* print_one_detail */
6303 print_mention_catch_fork
,
6304 print_recreate_catch_fork
6307 /* Implement the "insert" breakpoint_ops method for vfork
6311 insert_catch_vfork (struct bp_location
*bl
)
6313 return target_insert_vfork_catchpoint (PIDGET (inferior_ptid
));
6316 /* Implement the "remove" breakpoint_ops method for vfork
6320 remove_catch_vfork (struct bp_location
*bl
)
6322 return target_remove_vfork_catchpoint (PIDGET (inferior_ptid
));
6325 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
6329 breakpoint_hit_catch_vfork (const struct bp_location
*bl
,
6330 struct address_space
*aspace
, CORE_ADDR bp_addr
)
6332 return inferior_has_vforked (inferior_ptid
, &bl
->owner
->forked_inferior_pid
);
6335 /* Implement the "print_it" breakpoint_ops method for vfork
6338 static enum print_stop_action
6339 print_it_catch_vfork (struct breakpoint
*b
)
6341 annotate_catchpoint (b
->number
);
6342 printf_filtered (_("\nCatchpoint %d (vforked process %d), "),
6343 b
->number
, ptid_get_pid (b
->forked_inferior_pid
));
6344 return PRINT_SRC_AND_LOC
;
6347 /* Implement the "print_one" breakpoint_ops method for vfork
6351 print_one_catch_vfork (struct breakpoint
*b
, struct bp_location
**last_loc
)
6353 struct value_print_options opts
;
6355 get_user_print_options (&opts
);
6356 /* Field 4, the address, is omitted (which makes the columns not
6357 line up too nicely with the headers, but the effect is relatively
6359 if (opts
.addressprint
)
6360 ui_out_field_skip (uiout
, "addr");
6362 ui_out_text (uiout
, "vfork");
6363 if (!ptid_equal (b
->forked_inferior_pid
, null_ptid
))
6365 ui_out_text (uiout
, ", process ");
6366 ui_out_field_int (uiout
, "what",
6367 ptid_get_pid (b
->forked_inferior_pid
));
6368 ui_out_spaces (uiout
, 1);
6372 /* Implement the "print_mention" breakpoint_ops method for vfork
6376 print_mention_catch_vfork (struct breakpoint
*b
)
6378 printf_filtered (_("Catchpoint %d (vfork)"), b
->number
);
6381 /* Implement the "print_recreate" breakpoint_ops method for vfork
6385 print_recreate_catch_vfork (struct breakpoint
*b
, struct ui_file
*fp
)
6387 fprintf_unfiltered (fp
, "catch vfork");
6390 /* The breakpoint_ops structure to be used in vfork catchpoints. */
6392 static struct breakpoint_ops catch_vfork_breakpoint_ops
=
6396 breakpoint_hit_catch_vfork
,
6397 NULL
, /* resources_needed */
6398 print_it_catch_vfork
,
6399 print_one_catch_vfork
,
6400 NULL
, /* print_one_detail */
6401 print_mention_catch_vfork
,
6402 print_recreate_catch_vfork
6405 /* Implement the "insert" breakpoint_ops method for syscall
6409 insert_catch_syscall (struct bp_location
*bl
)
6411 struct inferior
*inf
= current_inferior ();
6413 ++inf
->total_syscalls_count
;
6414 if (!bl
->owner
->syscalls_to_be_caught
)
6415 ++inf
->any_syscall_count
;
6421 VEC_iterate (int, bl
->owner
->syscalls_to_be_caught
, i
, iter
);
6426 if (iter
>= VEC_length (int, inf
->syscalls_counts
))
6428 int old_size
= VEC_length (int, inf
->syscalls_counts
);
6429 uintptr_t vec_addr_offset
6430 = old_size
* ((uintptr_t) sizeof (int));
6432 VEC_safe_grow (int, inf
->syscalls_counts
, iter
+ 1);
6433 vec_addr
= (uintptr_t) VEC_address (int, inf
->syscalls_counts
) +
6435 memset ((void *) vec_addr
, 0,
6436 (iter
+ 1 - old_size
) * sizeof (int));
6438 elem
= VEC_index (int, inf
->syscalls_counts
, iter
);
6439 VEC_replace (int, inf
->syscalls_counts
, iter
, ++elem
);
6443 return target_set_syscall_catchpoint (PIDGET (inferior_ptid
),
6444 inf
->total_syscalls_count
!= 0,
6445 inf
->any_syscall_count
,
6446 VEC_length (int, inf
->syscalls_counts
),
6447 VEC_address (int, inf
->syscalls_counts
));
6450 /* Implement the "remove" breakpoint_ops method for syscall
6454 remove_catch_syscall (struct bp_location
*bl
)
6456 struct inferior
*inf
= current_inferior ();
6458 --inf
->total_syscalls_count
;
6459 if (!bl
->owner
->syscalls_to_be_caught
)
6460 --inf
->any_syscall_count
;
6466 VEC_iterate (int, bl
->owner
->syscalls_to_be_caught
, i
, iter
);
6470 if (iter
>= VEC_length (int, inf
->syscalls_counts
))
6471 /* Shouldn't happen. */
6473 elem
= VEC_index (int, inf
->syscalls_counts
, iter
);
6474 VEC_replace (int, inf
->syscalls_counts
, iter
, --elem
);
6478 return target_set_syscall_catchpoint (PIDGET (inferior_ptid
),
6479 inf
->total_syscalls_count
!= 0,
6480 inf
->any_syscall_count
,
6481 VEC_length (int, inf
->syscalls_counts
),
6483 inf
->syscalls_counts
));
6486 /* Implement the "breakpoint_hit" breakpoint_ops method for syscall
6490 breakpoint_hit_catch_syscall (const struct bp_location
*bl
,
6491 struct address_space
*aspace
, CORE_ADDR bp_addr
)
6493 /* We must check if we are catching specific syscalls in this
6494 breakpoint. If we are, then we must guarantee that the called
6495 syscall is the same syscall we are catching. */
6496 int syscall_number
= 0;
6497 const struct breakpoint
*b
= bl
->owner
;
6499 if (!inferior_has_called_syscall (inferior_ptid
, &syscall_number
))
6502 /* Now, checking if the syscall is the same. */
6503 if (b
->syscalls_to_be_caught
)
6508 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
6510 if (syscall_number
== iter
)
6520 /* Implement the "print_it" breakpoint_ops method for syscall
6523 static enum print_stop_action
6524 print_it_catch_syscall (struct breakpoint
*b
)
6526 /* These are needed because we want to know in which state a
6527 syscall is. It can be in the TARGET_WAITKIND_SYSCALL_ENTRY
6528 or TARGET_WAITKIND_SYSCALL_RETURN, and depending on it we
6529 must print "called syscall" or "returned from syscall". */
6531 struct target_waitstatus last
;
6533 struct cleanup
*old_chain
;
6536 get_last_target_status (&ptid
, &last
);
6538 get_syscall_by_number (last
.value
.syscall_number
, &s
);
6540 annotate_catchpoint (b
->number
);
6543 syscall_id
= xstrprintf ("%d", last
.value
.syscall_number
);
6545 syscall_id
= xstrprintf ("'%s'", s
.name
);
6547 old_chain
= make_cleanup (xfree
, syscall_id
);
6549 if (last
.kind
== TARGET_WAITKIND_SYSCALL_ENTRY
)
6550 printf_filtered (_("\nCatchpoint %d (call to syscall %s), "),
6551 b
->number
, syscall_id
);
6552 else if (last
.kind
== TARGET_WAITKIND_SYSCALL_RETURN
)
6553 printf_filtered (_("\nCatchpoint %d (returned from syscall %s), "),
6554 b
->number
, syscall_id
);
6556 do_cleanups (old_chain
);
6558 return PRINT_SRC_AND_LOC
;
6561 /* Implement the "print_one" breakpoint_ops method for syscall
6565 print_one_catch_syscall (struct breakpoint
*b
,
6566 struct bp_location
**last_loc
)
6568 struct value_print_options opts
;
6570 get_user_print_options (&opts
);
6571 /* Field 4, the address, is omitted (which makes the columns not
6572 line up too nicely with the headers, but the effect is relatively
6574 if (opts
.addressprint
)
6575 ui_out_field_skip (uiout
, "addr");
6578 if (b
->syscalls_to_be_caught
6579 && VEC_length (int, b
->syscalls_to_be_caught
) > 1)
6580 ui_out_text (uiout
, "syscalls \"");
6582 ui_out_text (uiout
, "syscall \"");
6584 if (b
->syscalls_to_be_caught
)
6587 char *text
= xstrprintf ("%s", "");
6590 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
6595 get_syscall_by_number (iter
, &s
);
6598 text
= xstrprintf ("%s%s, ", text
, s
.name
);
6600 text
= xstrprintf ("%s%d, ", text
, iter
);
6602 /* We have to xfree the last 'text' (now stored at 'x')
6603 because xstrprintf dinamically allocates new space for it
6607 /* Remove the last comma. */
6608 text
[strlen (text
) - 2] = '\0';
6609 ui_out_field_string (uiout
, "what", text
);
6612 ui_out_field_string (uiout
, "what", "<any syscall>");
6613 ui_out_text (uiout
, "\" ");
6616 /* Implement the "print_mention" breakpoint_ops method for syscall
6620 print_mention_catch_syscall (struct breakpoint
*b
)
6622 if (b
->syscalls_to_be_caught
)
6626 if (VEC_length (int, b
->syscalls_to_be_caught
) > 1)
6627 printf_filtered (_("Catchpoint %d (syscalls"), b
->number
);
6629 printf_filtered (_("Catchpoint %d (syscall"), b
->number
);
6632 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
6636 get_syscall_by_number (iter
, &s
);
6639 printf_filtered (" '%s' [%d]", s
.name
, s
.number
);
6641 printf_filtered (" %d", s
.number
);
6643 printf_filtered (")");
6646 printf_filtered (_("Catchpoint %d (any syscall)"),
6650 /* Implement the "print_recreate" breakpoint_ops method for syscall
6654 print_recreate_catch_syscall (struct breakpoint
*b
, struct ui_file
*fp
)
6656 fprintf_unfiltered (fp
, "catch syscall");
6658 if (b
->syscalls_to_be_caught
)
6663 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
6668 get_syscall_by_number (iter
, &s
);
6670 fprintf_unfiltered (fp
, " %s", s
.name
);
6672 fprintf_unfiltered (fp
, " %d", s
.number
);
6677 /* The breakpoint_ops structure to be used in syscall catchpoints. */
6679 static struct breakpoint_ops catch_syscall_breakpoint_ops
=
6681 insert_catch_syscall
,
6682 remove_catch_syscall
,
6683 breakpoint_hit_catch_syscall
,
6684 NULL
, /* resources_needed */
6685 print_it_catch_syscall
,
6686 print_one_catch_syscall
,
6687 NULL
, /* print_one_detail */
6688 print_mention_catch_syscall
,
6689 print_recreate_catch_syscall
6692 /* Returns non-zero if 'b' is a syscall catchpoint. */
6695 syscall_catchpoint_p (struct breakpoint
*b
)
6697 return (b
->ops
== &catch_syscall_breakpoint_ops
);
6700 /* Create a new breakpoint of the bp_catchpoint kind and return it,
6701 but does NOT mention it nor update the global location list.
6702 This is useful if you need to fill more fields in the
6703 struct breakpoint before calling mention.
6705 If TEMPFLAG is non-zero, then make the breakpoint temporary.
6706 If COND_STRING is not NULL, then store it in the breakpoint.
6707 OPS, if not NULL, is the breakpoint_ops structure associated
6708 to the catchpoint. */
6710 static struct breakpoint
*
6711 create_catchpoint_without_mention (struct gdbarch
*gdbarch
, int tempflag
,
6713 struct breakpoint_ops
*ops
)
6715 struct symtab_and_line sal
;
6716 struct breakpoint
*b
;
6719 sal
.pspace
= current_program_space
;
6721 b
= set_raw_breakpoint (gdbarch
, sal
, bp_catchpoint
);
6722 set_breakpoint_count (breakpoint_count
+ 1);
6723 b
->number
= breakpoint_count
;
6725 b
->cond_string
= (cond_string
== NULL
) ? NULL
: xstrdup (cond_string
);
6727 b
->addr_string
= NULL
;
6728 b
->enable_state
= bp_enabled
;
6729 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6735 /* Create a new breakpoint of the bp_catchpoint kind and return it.
6737 If TEMPFLAG is non-zero, then make the breakpoint temporary.
6738 If COND_STRING is not NULL, then store it in the breakpoint.
6739 OPS, if not NULL, is the breakpoint_ops structure associated
6740 to the catchpoint. */
6742 static struct breakpoint
*
6743 create_catchpoint (struct gdbarch
*gdbarch
, int tempflag
,
6744 char *cond_string
, struct breakpoint_ops
*ops
)
6746 struct breakpoint
*b
=
6747 create_catchpoint_without_mention (gdbarch
, tempflag
, cond_string
, ops
);
6750 update_global_location_list (1);
6756 create_fork_vfork_event_catchpoint (struct gdbarch
*gdbarch
,
6757 int tempflag
, char *cond_string
,
6758 struct breakpoint_ops
*ops
)
6760 struct breakpoint
*b
6761 = create_catchpoint (gdbarch
, tempflag
, cond_string
, ops
);
6763 /* FIXME: We should put this information in a breakpoint private data
6765 b
->forked_inferior_pid
= null_ptid
;
6768 /* Exec catchpoints. */
6771 insert_catch_exec (struct bp_location
*bl
)
6773 return target_insert_exec_catchpoint (PIDGET (inferior_ptid
));
6777 remove_catch_exec (struct bp_location
*bl
)
6779 return target_remove_exec_catchpoint (PIDGET (inferior_ptid
));
6783 breakpoint_hit_catch_exec (const struct bp_location
*bl
,
6784 struct address_space
*aspace
, CORE_ADDR bp_addr
)
6786 return inferior_has_execd (inferior_ptid
, &bl
->owner
->exec_pathname
);
6789 static enum print_stop_action
6790 print_it_catch_exec (struct breakpoint
*b
)
6792 annotate_catchpoint (b
->number
);
6793 printf_filtered (_("\nCatchpoint %d (exec'd %s), "), b
->number
,
6795 return PRINT_SRC_AND_LOC
;
6799 print_one_catch_exec (struct breakpoint
*b
, struct bp_location
**last_loc
)
6801 struct value_print_options opts
;
6803 get_user_print_options (&opts
);
6805 /* Field 4, the address, is omitted (which makes the columns
6806 not line up too nicely with the headers, but the effect
6807 is relatively readable). */
6808 if (opts
.addressprint
)
6809 ui_out_field_skip (uiout
, "addr");
6811 ui_out_text (uiout
, "exec");
6812 if (b
->exec_pathname
!= NULL
)
6814 ui_out_text (uiout
, ", program \"");
6815 ui_out_field_string (uiout
, "what", b
->exec_pathname
);
6816 ui_out_text (uiout
, "\" ");
6821 print_mention_catch_exec (struct breakpoint
*b
)
6823 printf_filtered (_("Catchpoint %d (exec)"), b
->number
);
6826 /* Implement the "print_recreate" breakpoint_ops method for exec
6830 print_recreate_catch_exec (struct breakpoint
*b
, struct ui_file
*fp
)
6832 fprintf_unfiltered (fp
, "catch exec");
6835 static struct breakpoint_ops catch_exec_breakpoint_ops
=
6839 breakpoint_hit_catch_exec
,
6840 NULL
, /* resources_needed */
6841 print_it_catch_exec
,
6842 print_one_catch_exec
,
6843 NULL
, /* print_one_detail */
6844 print_mention_catch_exec
,
6845 print_recreate_catch_exec
6849 create_syscall_event_catchpoint (int tempflag
, VEC(int) *filter
,
6850 struct breakpoint_ops
*ops
)
6852 struct gdbarch
*gdbarch
= get_current_arch ();
6853 struct breakpoint
*b
=
6854 create_catchpoint_without_mention (gdbarch
, tempflag
, NULL
, ops
);
6856 b
->syscalls_to_be_caught
= filter
;
6858 /* Now, we have to mention the breakpoint and update the global
6861 update_global_location_list (1);
6865 hw_breakpoint_used_count (void)
6868 struct breakpoint
*b
;
6869 struct bp_location
*bl
;
6873 if (b
->type
== bp_hardware_breakpoint
&& breakpoint_enabled (b
))
6874 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
6876 /* Special types of hardware breakpoints may use more than
6878 if (b
->ops
&& b
->ops
->resources_needed
)
6879 i
+= b
->ops
->resources_needed (bl
);
6889 hw_watchpoint_used_count (enum bptype type
, int *other_type_used
)
6892 struct breakpoint
*b
;
6893 struct bp_location
*bl
;
6895 *other_type_used
= 0;
6898 if (!breakpoint_enabled (b
))
6901 if (b
->type
== type
)
6902 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
6904 /* Special types of hardware watchpoints may use more than
6906 if (b
->ops
&& b
->ops
->resources_needed
)
6907 i
+= b
->ops
->resources_needed (bl
);
6911 else if (is_hardware_watchpoint (b
))
6912 *other_type_used
= 1;
6919 disable_watchpoints_before_interactive_call_start (void)
6921 struct breakpoint
*b
;
6925 if (is_watchpoint (b
) && breakpoint_enabled (b
))
6927 b
->enable_state
= bp_call_disabled
;
6928 update_global_location_list (0);
6934 enable_watchpoints_after_interactive_call_stop (void)
6936 struct breakpoint
*b
;
6940 if (is_watchpoint (b
) && b
->enable_state
== bp_call_disabled
)
6942 b
->enable_state
= bp_enabled
;
6943 update_global_location_list (1);
6949 disable_breakpoints_before_startup (void)
6951 struct breakpoint
*b
;
6956 if (b
->pspace
!= current_program_space
)
6959 if ((b
->type
== bp_breakpoint
6960 || b
->type
== bp_hardware_breakpoint
)
6961 && breakpoint_enabled (b
))
6963 b
->enable_state
= bp_startup_disabled
;
6969 update_global_location_list (0);
6971 current_program_space
->executing_startup
= 1;
6975 enable_breakpoints_after_startup (void)
6977 struct breakpoint
*b
;
6980 current_program_space
->executing_startup
= 0;
6984 if (b
->pspace
!= current_program_space
)
6987 if ((b
->type
== bp_breakpoint
6988 || b
->type
== bp_hardware_breakpoint
)
6989 && b
->enable_state
== bp_startup_disabled
)
6991 b
->enable_state
= bp_enabled
;
6997 breakpoint_re_set ();
7001 /* Set a breakpoint that will evaporate an end of command
7002 at address specified by SAL.
7003 Restrict it to frame FRAME if FRAME is nonzero. */
7006 set_momentary_breakpoint (struct gdbarch
*gdbarch
, struct symtab_and_line sal
,
7007 struct frame_id frame_id
, enum bptype type
)
7009 struct breakpoint
*b
;
7011 /* If FRAME_ID is valid, it should be a real frame, not an inlined
7013 gdb_assert (!frame_id_inlined_p (frame_id
));
7015 b
= set_raw_breakpoint (gdbarch
, sal
, type
);
7016 b
->enable_state
= bp_enabled
;
7017 b
->disposition
= disp_donttouch
;
7018 b
->frame_id
= frame_id
;
7020 /* If we're debugging a multi-threaded program, then we want
7021 momentary breakpoints to be active in only a single thread of
7023 if (in_thread_list (inferior_ptid
))
7024 b
->thread
= pid_to_thread_id (inferior_ptid
);
7026 update_global_location_list_nothrow (1);
7031 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
7035 clone_momentary_breakpoint (struct breakpoint
*orig
)
7037 struct breakpoint
*copy
;
7039 /* If there's nothing to clone, then return nothing. */
7043 copy
= set_raw_breakpoint_without_location (orig
->gdbarch
, orig
->type
);
7044 copy
->loc
= allocate_bp_location (copy
);
7045 set_breakpoint_location_function (copy
->loc
, 1);
7047 copy
->loc
->gdbarch
= orig
->loc
->gdbarch
;
7048 copy
->loc
->requested_address
= orig
->loc
->requested_address
;
7049 copy
->loc
->address
= orig
->loc
->address
;
7050 copy
->loc
->section
= orig
->loc
->section
;
7051 copy
->loc
->pspace
= orig
->loc
->pspace
;
7053 if (orig
->source_file
== NULL
)
7054 copy
->source_file
= NULL
;
7056 copy
->source_file
= xstrdup (orig
->source_file
);
7058 copy
->line_number
= orig
->line_number
;
7059 copy
->frame_id
= orig
->frame_id
;
7060 copy
->thread
= orig
->thread
;
7061 copy
->pspace
= orig
->pspace
;
7063 copy
->enable_state
= bp_enabled
;
7064 copy
->disposition
= disp_donttouch
;
7065 copy
->number
= internal_breakpoint_number
--;
7067 update_global_location_list_nothrow (0);
7072 set_momentary_breakpoint_at_pc (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
7075 struct symtab_and_line sal
;
7077 sal
= find_pc_line (pc
, 0);
7079 sal
.section
= find_pc_overlay (pc
);
7080 sal
.explicit_pc
= 1;
7082 return set_momentary_breakpoint (gdbarch
, sal
, null_frame_id
, type
);
7086 /* Tell the user we have just set a breakpoint B. */
7089 mention (struct breakpoint
*b
)
7092 struct cleanup
*ui_out_chain
;
7093 struct value_print_options opts
;
7095 get_user_print_options (&opts
);
7097 /* FIXME: This is misplaced; mention() is called by things (like
7098 hitting a watchpoint) other than breakpoint creation. It should
7099 be possible to clean this up and at the same time replace the
7100 random calls to breakpoint_changed with this hook. */
7101 observer_notify_breakpoint_created (b
->number
);
7103 if (b
->ops
!= NULL
&& b
->ops
->print_mention
!= NULL
)
7104 b
->ops
->print_mention (b
);
7109 printf_filtered (_("(apparently deleted?) Eventpoint %d: "),
7113 ui_out_text (uiout
, "Watchpoint ");
7114 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
7115 ui_out_field_int (uiout
, "number", b
->number
);
7116 ui_out_text (uiout
, ": ");
7117 ui_out_field_string (uiout
, "exp", b
->exp_string
);
7118 do_cleanups (ui_out_chain
);
7120 case bp_hardware_watchpoint
:
7121 ui_out_text (uiout
, "Hardware watchpoint ");
7122 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
7123 ui_out_field_int (uiout
, "number", b
->number
);
7124 ui_out_text (uiout
, ": ");
7125 ui_out_field_string (uiout
, "exp", b
->exp_string
);
7126 do_cleanups (ui_out_chain
);
7128 case bp_read_watchpoint
:
7129 ui_out_text (uiout
, "Hardware read watchpoint ");
7130 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
7131 ui_out_field_int (uiout
, "number", b
->number
);
7132 ui_out_text (uiout
, ": ");
7133 ui_out_field_string (uiout
, "exp", b
->exp_string
);
7134 do_cleanups (ui_out_chain
);
7136 case bp_access_watchpoint
:
7137 ui_out_text (uiout
, "Hardware access (read/write) watchpoint ");
7138 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
7139 ui_out_field_int (uiout
, "number", b
->number
);
7140 ui_out_text (uiout
, ": ");
7141 ui_out_field_string (uiout
, "exp", b
->exp_string
);
7142 do_cleanups (ui_out_chain
);
7145 case bp_gnu_ifunc_resolver
:
7146 if (ui_out_is_mi_like_p (uiout
))
7151 if (b
->disposition
== disp_del
)
7152 printf_filtered (_("Temporary breakpoint"));
7154 printf_filtered (_("Breakpoint"));
7155 printf_filtered (_(" %d"), b
->number
);
7156 if (b
->type
== bp_gnu_ifunc_resolver
)
7157 printf_filtered (_(" at gnu-indirect-function resolver"));
7160 case bp_hardware_breakpoint
:
7161 if (ui_out_is_mi_like_p (uiout
))
7166 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
7170 if (ui_out_is_mi_like_p (uiout
))
7175 printf_filtered (_("Tracepoint"));
7176 printf_filtered (_(" %d"), b
->number
);
7179 case bp_fast_tracepoint
:
7180 if (ui_out_is_mi_like_p (uiout
))
7185 printf_filtered (_("Fast tracepoint"));
7186 printf_filtered (_(" %d"), b
->number
);
7189 case bp_static_tracepoint
:
7190 if (ui_out_is_mi_like_p (uiout
))
7195 printf_filtered (_("Static tracepoint"));
7196 printf_filtered (_(" %d"), b
->number
);
7203 case bp_longjmp_resume
:
7205 case bp_exception_resume
:
7206 case bp_step_resume
:
7208 case bp_std_terminate
:
7209 case bp_watchpoint_scope
:
7210 case bp_shlib_event
:
7211 case bp_thread_event
:
7212 case bp_overlay_event
:
7214 case bp_longjmp_master
:
7215 case bp_std_terminate_master
:
7216 case bp_exception_master
:
7217 case bp_gnu_ifunc_resolver_return
:
7223 /* i18n: cagney/2005-02-11: Below needs to be merged into a
7227 printf_filtered (_(" (%s) pending."), b
->addr_string
);
7231 if (opts
.addressprint
|| b
->source_file
== NULL
)
7233 printf_filtered (" at ");
7234 fputs_filtered (paddress (b
->loc
->gdbarch
, b
->loc
->address
),
7238 printf_filtered (": file %s, line %d.",
7239 b
->source_file
, b
->line_number
);
7243 struct bp_location
*loc
= b
->loc
;
7245 for (; loc
; loc
= loc
->next
)
7247 printf_filtered (" (%d locations)", n
);
7252 if (ui_out_is_mi_like_p (uiout
))
7254 printf_filtered ("\n");
7258 static struct bp_location
*
7259 add_location_to_breakpoint (struct breakpoint
*b
,
7260 const struct symtab_and_line
*sal
)
7262 struct bp_location
*loc
, **tmp
;
7264 loc
= allocate_bp_location (b
);
7265 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
7268 loc
->gdbarch
= get_sal_arch (*sal
);
7270 loc
->gdbarch
= b
->gdbarch
;
7271 loc
->requested_address
= sal
->pc
;
7272 loc
->address
= adjust_breakpoint_address (loc
->gdbarch
,
7273 loc
->requested_address
, b
->type
);
7274 loc
->pspace
= sal
->pspace
;
7275 gdb_assert (loc
->pspace
!= NULL
);
7276 loc
->section
= sal
->section
;
7278 set_breakpoint_location_function (loc
,
7279 sal
->explicit_pc
|| sal
->explicit_line
);
7284 /* Return 1 if LOC is pointing to a permanent breakpoint,
7285 return 0 otherwise. */
7288 bp_loc_is_permanent (struct bp_location
*loc
)
7292 const gdb_byte
*brk
;
7293 gdb_byte
*target_mem
;
7294 struct cleanup
*cleanup
;
7297 gdb_assert (loc
!= NULL
);
7299 addr
= loc
->address
;
7300 brk
= gdbarch_breakpoint_from_pc (loc
->gdbarch
, &addr
, &len
);
7302 /* Software breakpoints unsupported? */
7306 target_mem
= alloca (len
);
7308 /* Enable the automatic memory restoration from breakpoints while
7309 we read the memory. Otherwise we could say about our temporary
7310 breakpoints they are permanent. */
7311 cleanup
= save_current_space_and_thread ();
7313 switch_to_program_space_and_thread (loc
->pspace
);
7314 make_show_memory_breakpoints_cleanup (0);
7316 if (target_read_memory (loc
->address
, target_mem
, len
) == 0
7317 && memcmp (target_mem
, brk
, len
) == 0)
7320 do_cleanups (cleanup
);
7327 /* Create a breakpoint with SAL as location. Use ADDR_STRING
7328 as textual description of the location, and COND_STRING
7329 as condition expression. */
7332 create_breakpoint_sal (struct gdbarch
*gdbarch
,
7333 struct symtabs_and_lines sals
, char *addr_string
,
7335 enum bptype type
, enum bpdisp disposition
,
7336 int thread
, int task
, int ignore_count
,
7337 struct breakpoint_ops
*ops
, int from_tty
,
7338 int enabled
, int internal
, int display_canonical
)
7340 struct breakpoint
*b
= NULL
;
7343 if (type
== bp_hardware_breakpoint
)
7345 int i
= hw_breakpoint_used_count ();
7346 int target_resources_ok
=
7347 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
7349 if (target_resources_ok
== 0)
7350 error (_("No hardware breakpoint support in the target."));
7351 else if (target_resources_ok
< 0)
7352 error (_("Hardware breakpoints used exceeds limit."));
7355 gdb_assert (sals
.nelts
> 0);
7357 for (i
= 0; i
< sals
.nelts
; ++i
)
7359 struct symtab_and_line sal
= sals
.sals
[i
];
7360 struct bp_location
*loc
;
7364 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
7366 loc_gdbarch
= gdbarch
;
7368 describe_other_breakpoints (loc_gdbarch
,
7369 sal
.pspace
, sal
.pc
, sal
.section
, thread
);
7374 b
= set_raw_breakpoint (gdbarch
, sal
, type
);
7375 set_breakpoint_number (internal
, b
);
7379 b
->cond_string
= cond_string
;
7380 b
->ignore_count
= ignore_count
;
7381 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
7382 b
->disposition
= disposition
;
7383 b
->pspace
= sals
.sals
[0].pspace
;
7385 if (type
== bp_static_tracepoint
)
7387 struct static_tracepoint_marker marker
;
7389 if (is_marker_spec (addr_string
))
7391 /* We already know the marker exists, otherwise, we
7392 wouldn't see a sal for it. */
7393 char *p
= &addr_string
[3];
7398 p
= skip_spaces (p
);
7400 endp
= skip_to_space (p
);
7402 marker_str
= savestring (p
, endp
- p
);
7403 b
->static_trace_marker_id
= marker_str
;
7405 printf_filtered (_("Probed static tracepoint "
7407 b
->static_trace_marker_id
);
7409 else if (target_static_tracepoint_marker_at (sal
.pc
, &marker
))
7411 b
->static_trace_marker_id
= xstrdup (marker
.str_id
);
7412 release_static_tracepoint_marker (&marker
);
7414 printf_filtered (_("Probed static tracepoint "
7416 b
->static_trace_marker_id
);
7419 warning (_("Couldn't determine the static "
7420 "tracepoint marker to probe"));
7423 if (enabled
&& b
->pspace
->executing_startup
7424 && (b
->type
== bp_breakpoint
7425 || b
->type
== bp_hardware_breakpoint
))
7426 b
->enable_state
= bp_startup_disabled
;
7432 loc
= add_location_to_breakpoint (b
, &sal
);
7435 if (bp_loc_is_permanent (loc
))
7436 make_breakpoint_permanent (b
);
7440 char *arg
= b
->cond_string
;
7441 loc
->cond
= parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
7443 error (_("Garbage %s follows condition"), arg
);
7447 b
->display_canonical
= display_canonical
;
7449 b
->addr_string
= addr_string
;
7451 /* addr_string has to be used or breakpoint_re_set will delete
7454 = xstrprintf ("*%s", paddress (b
->loc
->gdbarch
, b
->loc
->address
));
7458 /* Do not mention breakpoints with a negative number, but do
7459 notify observers. */
7460 observer_notify_breakpoint_created (b
->number
);
7465 /* Remove element at INDEX_TO_REMOVE from SAL, shifting other
7466 elements to fill the void space. */
7468 remove_sal (struct symtabs_and_lines
*sal
, int index_to_remove
)
7470 int i
= index_to_remove
+1;
7471 int last_index
= sal
->nelts
-1;
7473 for (;i
<= last_index
; ++i
)
7474 sal
->sals
[i
-1] = sal
->sals
[i
];
7479 /* If appropriate, obtains all sals that correspond to the same file
7480 and line as SAL, in all program spaces. Users debugging with IDEs,
7481 will want to set a breakpoint at foo.c:line, and not really care
7482 about program spaces. This is done only if SAL does not have
7483 explicit PC and has line and file information. If we got just a
7484 single expanded sal, return the original.
7486 Otherwise, if SAL.explicit_line is not set, filter out all sals for
7487 which the name of enclosing function is different from SAL. This
7488 makes sure that if we have breakpoint originally set in template
7489 instantiation, say foo<int>(), we won't expand SAL to locations at
7490 the same line in all existing instantiations of 'foo'. */
7492 static struct symtabs_and_lines
7493 expand_line_sal_maybe (struct symtab_and_line sal
)
7495 struct symtabs_and_lines expanded
;
7496 CORE_ADDR original_pc
= sal
.pc
;
7497 char *original_function
= NULL
;
7500 struct cleanup
*old_chain
;
7502 /* If we have explicit pc, don't expand.
7503 If we have no line number, we can't expand. */
7504 if (sal
.explicit_pc
|| sal
.line
== 0 || sal
.symtab
== NULL
)
7507 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
7508 expanded
.sals
[0] = sal
;
7514 old_chain
= save_current_space_and_thread ();
7516 switch_to_program_space_and_thread (sal
.pspace
);
7518 find_pc_partial_function (original_pc
, &original_function
, NULL
, NULL
);
7520 /* Note that expand_line_sal visits *all* program spaces. */
7521 expanded
= expand_line_sal (sal
);
7523 if (expanded
.nelts
== 1)
7525 /* We had one sal, we got one sal. Return that sal, adjusting it
7526 past the function prologue if necessary. */
7527 xfree (expanded
.sals
);
7529 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
7530 sal
.pc
= original_pc
;
7531 expanded
.sals
[0] = sal
;
7532 skip_prologue_sal (&expanded
.sals
[0]);
7533 do_cleanups (old_chain
);
7537 if (!sal
.explicit_line
)
7539 CORE_ADDR func_addr
, func_end
;
7540 for (i
= 0; i
< expanded
.nelts
; ++i
)
7542 CORE_ADDR pc
= expanded
.sals
[i
].pc
;
7543 char *this_function
;
7545 /* We need to switch threads as well since we're about to
7547 switch_to_program_space_and_thread (expanded
.sals
[i
].pspace
);
7549 if (find_pc_partial_function (pc
, &this_function
,
7550 &func_addr
, &func_end
))
7553 && strcmp (this_function
, original_function
) != 0)
7555 remove_sal (&expanded
, i
);
7562 /* Skip the function prologue if necessary. */
7563 for (i
= 0; i
< expanded
.nelts
; ++i
)
7564 skip_prologue_sal (&expanded
.sals
[i
]);
7566 do_cleanups (old_chain
);
7568 if (expanded
.nelts
<= 1)
7570 /* This is un ugly workaround. If we get zero expanded sals
7571 then something is really wrong. Fix that by returning the
7574 xfree (expanded
.sals
);
7576 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
7577 sal
.pc
= original_pc
;
7578 expanded
.sals
[0] = sal
;
7585 for (i
= 0; i
< expanded
.nelts
; ++i
)
7586 if (expanded
.sals
[i
].pc
== original_pc
)
7597 /* Add SALS.nelts breakpoints to the breakpoint table. For each
7598 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
7599 value. COND_STRING, if not NULL, specified the condition to be
7600 used for all breakpoints. Essentially the only case where
7601 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
7602 function. In that case, it's still not possible to specify
7603 separate conditions for different overloaded functions, so
7604 we take just a single condition string.
7606 NOTE: If the function succeeds, the caller is expected to cleanup
7607 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
7608 array contents). If the function fails (error() is called), the
7609 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
7610 COND and SALS arrays and each of those arrays contents. */
7613 create_breakpoints_sal (struct gdbarch
*gdbarch
,
7614 struct symtabs_and_lines sals
,
7615 struct linespec_result
*canonical
,
7617 enum bptype type
, enum bpdisp disposition
,
7618 int thread
, int task
, int ignore_count
,
7619 struct breakpoint_ops
*ops
, int from_tty
,
7620 int enabled
, int internal
)
7624 for (i
= 0; i
< sals
.nelts
; ++i
)
7626 struct symtabs_and_lines expanded
=
7627 expand_line_sal_maybe (sals
.sals
[i
]);
7629 create_breakpoint_sal (gdbarch
, expanded
, canonical
->canonical
[i
],
7630 cond_string
, type
, disposition
,
7631 thread
, task
, ignore_count
, ops
,
7632 from_tty
, enabled
, internal
,
7633 canonical
->special_display
);
7637 /* Parse ADDRESS which is assumed to be a SAL specification possibly
7638 followed by conditionals. On return, SALS contains an array of SAL
7639 addresses found. ADDR_STRING contains a vector of (canonical)
7640 address strings. ADDRESS points to the end of the SAL.
7642 The array and the line spec strings are allocated on the heap, it is
7643 the caller's responsibility to free them. */
7646 parse_breakpoint_sals (char **address
,
7647 struct symtabs_and_lines
*sals
,
7648 struct linespec_result
*canonical
)
7650 char *addr_start
= *address
;
7652 /* If no arg given, or if first arg is 'if ', use the default
7654 if ((*address
) == NULL
7655 || (strncmp ((*address
), "if", 2) == 0 && isspace ((*address
)[2])))
7657 if (default_breakpoint_valid
)
7659 struct symtab_and_line sal
;
7661 init_sal (&sal
); /* Initialize to zeroes. */
7662 sals
->sals
= (struct symtab_and_line
*)
7663 xmalloc (sizeof (struct symtab_and_line
));
7664 sal
.pc
= default_breakpoint_address
;
7665 sal
.line
= default_breakpoint_line
;
7666 sal
.symtab
= default_breakpoint_symtab
;
7667 sal
.pspace
= default_breakpoint_pspace
;
7668 sal
.section
= find_pc_overlay (sal
.pc
);
7670 /* "break" without arguments is equivalent to "break *PC"
7671 where PC is the default_breakpoint_address. So make sure
7672 to set sal.explicit_pc to prevent GDB from trying to
7673 expand the list of sals to include all other instances
7674 with the same symtab and line. */
7675 sal
.explicit_pc
= 1;
7677 sals
->sals
[0] = sal
;
7681 error (_("No default breakpoint address now."));
7685 /* Force almost all breakpoints to be in terms of the
7686 current_source_symtab (which is decode_line_1's default).
7687 This should produce the results we want almost all of the
7688 time while leaving default_breakpoint_* alone.
7690 ObjC: However, don't match an Objective-C method name which
7691 may have a '+' or '-' succeeded by a '[' */
7693 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
7695 if (default_breakpoint_valid
7697 || ((strchr ("+-", (*address
)[0]) != NULL
)
7698 && ((*address
)[1] != '['))))
7699 *sals
= decode_line_1 (address
, 1, default_breakpoint_symtab
,
7700 default_breakpoint_line
, canonical
);
7702 *sals
= decode_line_1 (address
, 1, (struct symtab
*) NULL
, 0,
7705 /* For any SAL that didn't have a canonical string, fill one in. */
7706 if (sals
->nelts
> 0 && canonical
->canonical
== NULL
)
7707 canonical
->canonical
= xcalloc (sals
->nelts
, sizeof (char **));
7708 if (addr_start
!= (*address
))
7712 for (i
= 0; i
< sals
->nelts
; i
++)
7714 /* Add the string if not present. */
7715 if (canonical
->canonical
[i
] == NULL
)
7716 canonical
->canonical
[i
] = savestring (addr_start
,
7717 (*address
) - addr_start
);
7723 /* Convert each SAL into a real PC. Verify that the PC can be
7724 inserted as a breakpoint. If it can't throw an error. */
7727 breakpoint_sals_to_pc (struct symtabs_and_lines
*sals
)
7731 for (i
= 0; i
< sals
->nelts
; i
++)
7732 resolve_sal_pc (&sals
->sals
[i
]);
7735 /* Fast tracepoints may have restrictions on valid locations. For
7736 instance, a fast tracepoint using a jump instead of a trap will
7737 likely have to overwrite more bytes than a trap would, and so can
7738 only be placed where the instruction is longer than the jump, or a
7739 multi-instruction sequence does not have a jump into the middle of
7743 check_fast_tracepoint_sals (struct gdbarch
*gdbarch
,
7744 struct symtabs_and_lines
*sals
)
7747 struct symtab_and_line
*sal
;
7749 struct cleanup
*old_chain
;
7751 for (i
= 0; i
< sals
->nelts
; i
++)
7753 sal
= &sals
->sals
[i
];
7755 rslt
= gdbarch_fast_tracepoint_valid_at (gdbarch
, sal
->pc
,
7757 old_chain
= make_cleanup (xfree
, msg
);
7760 error (_("May not have a fast tracepoint at 0x%s%s"),
7761 paddress (gdbarch
, sal
->pc
), (msg
? msg
: ""));
7763 do_cleanups (old_chain
);
7767 /* Given TOK, a string specification of condition and thread, as
7768 accepted by the 'break' command, extract the condition
7769 string and thread number and set *COND_STRING and *THREAD.
7770 PC identifies the context at which the condition should be parsed.
7771 If no condition is found, *COND_STRING is set to NULL.
7772 If no thread is found, *THREAD is set to -1. */
7774 find_condition_and_thread (char *tok
, CORE_ADDR pc
,
7775 char **cond_string
, int *thread
, int *task
)
7777 *cond_string
= NULL
;
7783 char *cond_start
= NULL
;
7784 char *cond_end
= NULL
;
7786 tok
= skip_spaces (tok
);
7788 end_tok
= skip_to_space (tok
);
7790 toklen
= end_tok
- tok
;
7792 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
7794 struct expression
*expr
;
7796 tok
= cond_start
= end_tok
+ 1;
7797 expr
= parse_exp_1 (&tok
, block_for_pc (pc
), 0);
7800 *cond_string
= savestring (cond_start
,
7801 cond_end
- cond_start
);
7803 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
7809 *thread
= strtol (tok
, &tok
, 0);
7811 error (_("Junk after thread keyword."));
7812 if (!valid_thread_id (*thread
))
7813 error (_("Unknown thread %d."), *thread
);
7815 else if (toklen
>= 1 && strncmp (tok
, "task", toklen
) == 0)
7821 *task
= strtol (tok
, &tok
, 0);
7823 error (_("Junk after task keyword."));
7824 if (!valid_task_id (*task
))
7825 error (_("Unknown task %d."), *task
);
7828 error (_("Junk at end of arguments."));
7832 /* Decode a static tracepoint marker spec. */
7834 static struct symtabs_and_lines
7835 decode_static_tracepoint_spec (char **arg_p
)
7837 VEC(static_tracepoint_marker_p
) *markers
= NULL
;
7838 struct symtabs_and_lines sals
;
7839 struct symtab_and_line sal
;
7841 struct cleanup
*old_chain
;
7842 char *p
= &(*arg_p
)[3];
7847 p
= skip_spaces (p
);
7849 endp
= skip_to_space (p
);
7851 marker_str
= savestring (p
, endp
- p
);
7852 old_chain
= make_cleanup (xfree
, marker_str
);
7854 markers
= target_static_tracepoint_markers_by_strid (marker_str
);
7855 if (VEC_empty(static_tracepoint_marker_p
, markers
))
7856 error (_("No known static tracepoint marker named %s"), marker_str
);
7858 sals
.nelts
= VEC_length(static_tracepoint_marker_p
, markers
);
7859 sals
.sals
= xmalloc (sizeof *sals
.sals
* sals
.nelts
);
7861 for (i
= 0; i
< sals
.nelts
; i
++)
7863 struct static_tracepoint_marker
*marker
;
7865 marker
= VEC_index (static_tracepoint_marker_p
, markers
, i
);
7867 init_sal (&sals
.sals
[i
]);
7869 sals
.sals
[i
] = find_pc_line (marker
->address
, 0);
7870 sals
.sals
[i
].pc
= marker
->address
;
7872 release_static_tracepoint_marker (marker
);
7875 do_cleanups (old_chain
);
7881 /* Set a breakpoint. This function is shared between CLI and MI
7882 functions for setting a breakpoint. This function has two major
7883 modes of operations, selected by the PARSE_CONDITION_AND_THREAD
7884 parameter. If non-zero, the function will parse arg, extracting
7885 breakpoint location, address and thread. Otherwise, ARG is just
7886 the location of breakpoint, with condition and thread specified by
7887 the COND_STRING and THREAD parameters. If INTERNAL is non-zero,
7888 the breakpoint number will be allocated from the internal
7889 breakpoint count. Returns true if any breakpoint was created;
7893 create_breakpoint (struct gdbarch
*gdbarch
,
7894 char *arg
, char *cond_string
, int thread
,
7895 int parse_condition_and_thread
,
7896 int tempflag
, enum bptype type_wanted
,
7898 enum auto_boolean pending_break_support
,
7899 struct breakpoint_ops
*ops
,
7900 int from_tty
, int enabled
, int internal
)
7902 volatile struct gdb_exception e
;
7903 struct symtabs_and_lines sals
;
7904 struct symtab_and_line pending_sal
;
7906 char *addr_start
= arg
;
7907 struct linespec_result canonical
;
7908 struct cleanup
*old_chain
;
7909 struct cleanup
*bkpt_chain
= NULL
;
7913 int prev_bkpt_count
= breakpoint_count
;
7917 init_linespec_result (&canonical
);
7919 if (type_wanted
== bp_static_tracepoint
&& is_marker_spec (arg
))
7923 sals
= decode_static_tracepoint_spec (&arg
);
7925 copy_arg
= savestring (addr_start
, arg
- addr_start
);
7926 canonical
.canonical
= xcalloc (sals
.nelts
, sizeof (char **));
7927 for (i
= 0; i
< sals
.nelts
; i
++)
7928 canonical
.canonical
[i
] = xstrdup (copy_arg
);
7932 TRY_CATCH (e
, RETURN_MASK_ALL
)
7934 parse_breakpoint_sals (&arg
, &sals
, &canonical
);
7937 /* If caller is interested in rc value from parse, set value. */
7941 throw_exception (e
);
7945 case NOT_FOUND_ERROR
:
7947 /* If pending breakpoint support is turned off, throw
7950 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
7951 throw_exception (e
);
7953 exception_print (gdb_stderr
, e
);
7955 /* If pending breakpoint support is auto query and the user
7956 selects no, then simply return the error code. */
7957 if (pending_break_support
== AUTO_BOOLEAN_AUTO
7958 && !nquery (_("Make breakpoint pending on "
7959 "future shared library load? ")))
7962 /* At this point, either the user was queried about setting
7963 a pending breakpoint and selected yes, or pending
7964 breakpoint behavior is on and thus a pending breakpoint
7965 is defaulted on behalf of the user. */
7966 copy_arg
= xstrdup (addr_start
);
7967 canonical
.canonical
= ©_arg
;
7969 sals
.sals
= &pending_sal
;
7974 throw_exception (e
);
7984 /* Create a chain of things that always need to be cleaned up. */
7985 old_chain
= make_cleanup (null_cleanup
, 0);
7989 /* Make sure that all storage allocated to SALS gets freed. */
7990 make_cleanup (xfree
, sals
.sals
);
7992 /* Cleanup the canonical array but not its contents. */
7993 make_cleanup (xfree
, canonical
.canonical
);
7996 /* ----------------------------- SNIP -----------------------------
7997 Anything added to the cleanup chain beyond this point is assumed
7998 to be part of a breakpoint. If the breakpoint create succeeds
7999 then the memory is not reclaimed. */
8000 bkpt_chain
= make_cleanup (null_cleanup
, 0);
8002 /* Mark the contents of the canonical for cleanup. These go on
8003 the bkpt_chain and only occur if the breakpoint create fails. */
8004 for (i
= 0; i
< sals
.nelts
; i
++)
8006 if (canonical
.canonical
[i
] != NULL
)
8007 make_cleanup (xfree
, canonical
.canonical
[i
]);
8010 /* Resolve all line numbers to PC's and verify that the addresses
8011 are ok for the target. */
8013 breakpoint_sals_to_pc (&sals
);
8015 /* Fast tracepoints may have additional restrictions on location. */
8016 if (type_wanted
== bp_fast_tracepoint
)
8017 check_fast_tracepoint_sals (gdbarch
, &sals
);
8019 /* Verify that condition can be parsed, before setting any
8020 breakpoints. Allocate a separate condition expression for each
8024 if (parse_condition_and_thread
)
8026 /* Here we only parse 'arg' to separate condition
8027 from thread number, so parsing in context of first
8028 sal is OK. When setting the breakpoint we'll
8029 re-parse it in context of each sal. */
8032 find_condition_and_thread (arg
, sals
.sals
[0].pc
, &cond_string
,
8035 make_cleanup (xfree
, cond_string
);
8039 /* Create a private copy of condition string. */
8042 cond_string
= xstrdup (cond_string
);
8043 make_cleanup (xfree
, cond_string
);
8047 /* If the user is creating a static tracepoint by marker id
8048 (strace -m MARKER_ID), then store the sals index, so that
8049 breakpoint_re_set can try to match up which of the newly
8050 found markers corresponds to this one, and, don't try to
8051 expand multiple locations for each sal, given than SALS
8052 already should contain all sals for MARKER_ID. */
8053 if (type_wanted
== bp_static_tracepoint
8054 && is_marker_spec (canonical
.canonical
[0]))
8058 for (i
= 0; i
< sals
.nelts
; ++i
)
8060 struct symtabs_and_lines expanded
;
8061 struct breakpoint
*tp
;
8062 struct cleanup
*old_chain
;
8065 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
8066 expanded
.sals
[0] = sals
.sals
[i
];
8067 old_chain
= make_cleanup (xfree
, expanded
.sals
);
8069 create_breakpoint_sal (gdbarch
, expanded
, canonical
.canonical
[i
],
8070 cond_string
, type_wanted
,
8071 tempflag
? disp_del
: disp_donttouch
,
8072 thread
, task
, ignore_count
, ops
,
8073 from_tty
, enabled
, internal
,
8074 canonical
.special_display
);
8076 do_cleanups (old_chain
);
8078 /* Get the tracepoint we just created. */
8080 tp
= get_breakpoint (internal_breakpoint_number
);
8082 tp
= get_breakpoint (breakpoint_count
);
8083 gdb_assert (tp
!= NULL
);
8085 /* Given that its possible to have multiple markers with
8086 the same string id, if the user is creating a static
8087 tracepoint by marker id ("strace -m MARKER_ID"), then
8088 store the sals index, so that breakpoint_re_set can
8089 try to match up which of the newly found markers
8090 corresponds to this one */
8091 tp
->static_trace_marker_id_idx
= i
;
8095 create_breakpoints_sal (gdbarch
, sals
, &canonical
, cond_string
,
8097 tempflag
? disp_del
: disp_donttouch
,
8098 thread
, task
, ignore_count
, ops
, from_tty
,
8103 struct breakpoint
*b
;
8105 make_cleanup (xfree
, copy_arg
);
8107 b
= set_raw_breakpoint_without_location (gdbarch
, type_wanted
);
8108 set_breakpoint_number (internal
, b
);
8110 b
->addr_string
= canonical
.canonical
[0];
8111 b
->cond_string
= NULL
;
8112 b
->ignore_count
= ignore_count
;
8113 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
8114 b
->condition_not_parsed
= 1;
8116 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
8117 b
->pspace
= current_program_space
;
8118 b
->py_bp_object
= NULL
;
8120 if (enabled
&& b
->pspace
->executing_startup
8121 && (b
->type
== bp_breakpoint
8122 || b
->type
== bp_hardware_breakpoint
))
8123 b
->enable_state
= bp_startup_disabled
;
8126 /* Do not mention breakpoints with a negative number,
8127 but do notify observers. */
8128 observer_notify_breakpoint_created (b
->number
);
8135 warning (_("Multiple breakpoints were set.\nUse the "
8136 "\"delete\" command to delete unwanted breakpoints."));
8137 prev_breakpoint_count
= prev_bkpt_count
;
8140 /* That's it. Discard the cleanups for data inserted into the
8142 discard_cleanups (bkpt_chain
);
8143 /* But cleanup everything else. */
8144 do_cleanups (old_chain
);
8146 /* error call may happen here - have BKPT_CHAIN already discarded. */
8147 update_global_location_list (1);
8152 /* Set a breakpoint.
8153 ARG is a string describing breakpoint address,
8154 condition, and thread.
8155 FLAG specifies if a breakpoint is hardware on,
8156 and if breakpoint is temporary, using BP_HARDWARE_FLAG
8160 break_command_1 (char *arg
, int flag
, int from_tty
)
8162 int tempflag
= flag
& BP_TEMPFLAG
;
8163 enum bptype type_wanted
= (flag
& BP_HARDWAREFLAG
8164 ? bp_hardware_breakpoint
8167 create_breakpoint (get_current_arch (),
8169 NULL
, 0, 1 /* parse arg */,
8170 tempflag
, type_wanted
,
8171 0 /* Ignore count */,
8172 pending_break_support
,
8173 NULL
/* breakpoint_ops */,
8180 /* Helper function for break_command_1 and disassemble_command. */
8183 resolve_sal_pc (struct symtab_and_line
*sal
)
8187 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
8189 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
8190 error (_("No line %d in file \"%s\"."),
8191 sal
->line
, sal
->symtab
->filename
);
8194 /* If this SAL corresponds to a breakpoint inserted using a line
8195 number, then skip the function prologue if necessary. */
8196 if (sal
->explicit_line
)
8197 skip_prologue_sal (sal
);
8200 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
8202 struct blockvector
*bv
;
8206 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
, sal
->symtab
);
8209 sym
= block_linkage_function (b
);
8212 fixup_symbol_section (sym
, sal
->symtab
->objfile
);
8213 sal
->section
= SYMBOL_OBJ_SECTION (sym
);
8217 /* It really is worthwhile to have the section, so we'll
8218 just have to look harder. This case can be executed
8219 if we have line numbers but no functions (as can
8220 happen in assembly source). */
8222 struct minimal_symbol
*msym
;
8223 struct cleanup
*old_chain
= save_current_space_and_thread ();
8225 switch_to_program_space_and_thread (sal
->pspace
);
8227 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
8229 sal
->section
= SYMBOL_OBJ_SECTION (msym
);
8231 do_cleanups (old_chain
);
8238 break_command (char *arg
, int from_tty
)
8240 break_command_1 (arg
, 0, from_tty
);
8244 tbreak_command (char *arg
, int from_tty
)
8246 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
8250 hbreak_command (char *arg
, int from_tty
)
8252 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
8256 thbreak_command (char *arg
, int from_tty
)
8258 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
8262 stop_command (char *arg
, int from_tty
)
8264 printf_filtered (_("Specify the type of breakpoint to set.\n\
8265 Usage: stop in <function | address>\n\
8266 stop at <line>\n"));
8270 stopin_command (char *arg
, int from_tty
)
8274 if (arg
== (char *) NULL
)
8276 else if (*arg
!= '*')
8281 /* Look for a ':'. If this is a line number specification, then
8282 say it is bad, otherwise, it should be an address or
8283 function/method name. */
8284 while (*argptr
&& !hasColon
)
8286 hasColon
= (*argptr
== ':');
8291 badInput
= (*argptr
!= ':'); /* Not a class::method */
8293 badInput
= isdigit (*arg
); /* a simple line number */
8297 printf_filtered (_("Usage: stop in <function | address>\n"));
8299 break_command_1 (arg
, 0, from_tty
);
8303 stopat_command (char *arg
, int from_tty
)
8307 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
8314 /* Look for a ':'. If there is a '::' then get out, otherwise
8315 it is probably a line number. */
8316 while (*argptr
&& !hasColon
)
8318 hasColon
= (*argptr
== ':');
8323 badInput
= (*argptr
== ':'); /* we have class::method */
8325 badInput
= !isdigit (*arg
); /* not a line number */
8329 printf_filtered (_("Usage: stop at <line>\n"));
8331 break_command_1 (arg
, 0, from_tty
);
8334 /* Implement the "breakpoint_hit" breakpoint_ops method for
8335 ranged breakpoints. */
8338 breakpoint_hit_ranged_breakpoint (const struct bp_location
*bl
,
8339 struct address_space
*aspace
,
8342 return breakpoint_address_match_range (bl
->pspace
->aspace
, bl
->address
,
8343 bl
->length
, aspace
, bp_addr
);
8346 /* Implement the "resources_needed" breakpoint_ops method for
8347 ranged breakpoints. */
8350 resources_needed_ranged_breakpoint (const struct bp_location
*bl
)
8352 return target_ranged_break_num_registers ();
8355 /* Implement the "print_it" breakpoint_ops method for
8356 ranged breakpoints. */
8358 static enum print_stop_action
8359 print_it_ranged_breakpoint (struct breakpoint
*b
)
8361 struct bp_location
*bl
= b
->loc
;
8363 gdb_assert (b
->type
== bp_hardware_breakpoint
);
8365 /* Ranged breakpoints have only one location. */
8366 gdb_assert (bl
&& bl
->next
== NULL
);
8368 annotate_breakpoint (b
->number
);
8369 if (b
->disposition
== disp_del
)
8370 ui_out_text (uiout
, "\nTemporary ranged breakpoint ");
8372 ui_out_text (uiout
, "\nRanged breakpoint ");
8373 if (ui_out_is_mi_like_p (uiout
))
8375 ui_out_field_string (uiout
, "reason",
8376 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
8377 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
8379 ui_out_field_int (uiout
, "bkptno", b
->number
);
8380 ui_out_text (uiout
, ", ");
8382 return PRINT_SRC_AND_LOC
;
8385 /* Implement the "print_one" breakpoint_ops method for
8386 ranged breakpoints. */
8389 print_one_ranged_breakpoint (struct breakpoint
*b
,
8390 struct bp_location
**last_loc
)
8392 struct bp_location
*bl
= b
->loc
;
8393 struct value_print_options opts
;
8395 /* Ranged breakpoints have only one location. */
8396 gdb_assert (bl
&& bl
->next
== NULL
);
8398 get_user_print_options (&opts
);
8400 if (opts
.addressprint
)
8401 /* We don't print the address range here, it will be printed later
8402 by print_one_detail_ranged_breakpoint. */
8403 ui_out_field_skip (uiout
, "addr");
8405 print_breakpoint_location (b
, bl
);
8409 /* Implement the "print_one_detail" breakpoint_ops method for
8410 ranged breakpoints. */
8413 print_one_detail_ranged_breakpoint (const struct breakpoint
*b
,
8414 struct ui_out
*uiout
)
8416 CORE_ADDR address_start
, address_end
;
8417 struct bp_location
*bl
= b
->loc
;
8418 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
8419 struct cleanup
*cleanup
= make_cleanup_ui_out_stream_delete (stb
);
8423 address_start
= bl
->address
;
8424 address_end
= address_start
+ bl
->length
- 1;
8426 ui_out_text (uiout
, "\taddress range: ");
8427 fprintf_unfiltered (stb
->stream
, "[%s, %s]",
8428 print_core_address (bl
->gdbarch
, address_start
),
8429 print_core_address (bl
->gdbarch
, address_end
));
8430 ui_out_field_stream (uiout
, "addr", stb
);
8431 ui_out_text (uiout
, "\n");
8433 do_cleanups (cleanup
);
8436 /* Implement the "print_mention" breakpoint_ops method for
8437 ranged breakpoints. */
8440 print_mention_ranged_breakpoint (struct breakpoint
*b
)
8442 struct bp_location
*bl
= b
->loc
;
8445 gdb_assert (b
->type
== bp_hardware_breakpoint
);
8447 if (ui_out_is_mi_like_p (uiout
))
8450 printf_filtered (_("Hardware assisted ranged breakpoint %d from %s to %s."),
8451 b
->number
, paddress (bl
->gdbarch
, bl
->address
),
8452 paddress (bl
->gdbarch
, bl
->address
+ bl
->length
- 1));
8455 /* Implement the "print_recreate" breakpoint_ops method for
8456 ranged breakpoints. */
8459 print_recreate_ranged_breakpoint (struct breakpoint
*b
, struct ui_file
*fp
)
8461 fprintf_unfiltered (fp
, "break-range %s, %s", b
->addr_string
,
8462 b
->addr_string_range_end
);
8465 /* The breakpoint_ops structure to be used in ranged breakpoints. */
8467 static struct breakpoint_ops ranged_breakpoint_ops
=
8471 breakpoint_hit_ranged_breakpoint
,
8472 resources_needed_ranged_breakpoint
,
8473 print_it_ranged_breakpoint
,
8474 print_one_ranged_breakpoint
,
8475 print_one_detail_ranged_breakpoint
,
8476 print_mention_ranged_breakpoint
,
8477 print_recreate_ranged_breakpoint
8480 /* Find the address where the end of the breakpoint range should be
8481 placed, given the SAL of the end of the range. This is so that if
8482 the user provides a line number, the end of the range is set to the
8483 last instruction of the given line. */
8486 find_breakpoint_range_end (struct symtab_and_line sal
)
8490 /* If the user provided a PC value, use it. Otherwise,
8491 find the address of the end of the given location. */
8492 if (sal
.explicit_pc
)
8499 ret
= find_line_pc_range (sal
, &start
, &end
);
8501 error (_("Could not find location of the end of the range."));
8503 /* find_line_pc_range returns the start of the next line. */
8510 /* Implement the "break-range" CLI command. */
8513 break_range_command (char *arg
, int from_tty
)
8515 char *arg_start
, *addr_string_start
, *addr_string_end
;
8516 struct linespec_result canonical_start
, canonical_end
;
8517 int bp_count
, can_use_bp
, length
;
8519 struct breakpoint
*b
;
8520 struct symtab_and_line sal_start
, sal_end
;
8521 struct symtabs_and_lines sals_start
, sals_end
;
8522 struct cleanup
*cleanup_bkpt
;
8524 /* We don't support software ranged breakpoints. */
8525 if (target_ranged_break_num_registers () < 0)
8526 error (_("This target does not support hardware ranged breakpoints."));
8528 bp_count
= hw_breakpoint_used_count ();
8529 bp_count
+= target_ranged_break_num_registers ();
8530 can_use_bp
= target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
8533 error (_("Hardware breakpoints used exceeds limit."));
8535 if (arg
== NULL
|| arg
[0] == '\0')
8536 error(_("No address range specified."));
8538 sals_start
.sals
= NULL
;
8539 sals_start
.nelts
= 0;
8540 init_linespec_result (&canonical_start
);
8542 while (*arg
== ' ' || *arg
== '\t')
8545 parse_breakpoint_sals (&arg
, &sals_start
, &canonical_start
);
8547 sal_start
= sals_start
.sals
[0];
8548 addr_string_start
= canonical_start
.canonical
[0];
8549 cleanup_bkpt
= make_cleanup (xfree
, addr_string_start
);
8550 xfree (sals_start
.sals
);
8551 xfree (canonical_start
.canonical
);
8554 error (_("Too few arguments."));
8555 else if (sals_start
.nelts
== 0)
8556 error (_("Could not find location of the beginning of the range."));
8557 else if (sals_start
.nelts
!= 1)
8558 error (_("Cannot create a ranged breakpoint with multiple locations."));
8560 resolve_sal_pc (&sal_start
);
8562 arg
++; /* Skip the comma. */
8563 while (*arg
== ' ' || *arg
== '\t')
8566 /* Parse the end location. */
8568 sals_end
.sals
= NULL
;
8570 init_linespec_result (&canonical_end
);
8573 /* We call decode_line_1 directly here instead of using
8574 parse_breakpoint_sals because we need to specify the start location's
8575 symtab and line as the default symtab and line for the end of the
8576 range. This makes it possible to have ranges like "foo.c:27, +14",
8577 where +14 means 14 lines from the start location. */
8578 sals_end
= decode_line_1 (&arg
, 1, sal_start
.symtab
, sal_start
.line
,
8581 /* canonical_end can be NULL if it was of the form "*0xdeadbeef". */
8582 if (canonical_end
.canonical
== NULL
)
8583 canonical_end
.canonical
= xcalloc (1, sizeof (char **));
8584 /* Add the string if not present. */
8585 if (arg_start
!= arg
&& canonical_end
.canonical
[0] == NULL
)
8586 canonical_end
.canonical
[0] = savestring (arg_start
, arg
- arg_start
);
8588 sal_end
= sals_end
.sals
[0];
8589 addr_string_end
= canonical_end
.canonical
[0];
8590 make_cleanup (xfree
, addr_string_end
);
8591 xfree (sals_end
.sals
);
8592 xfree (canonical_end
.canonical
);
8594 if (sals_end
.nelts
== 0)
8595 error (_("Could not find location of the end of the range."));
8596 else if (sals_end
.nelts
!= 1)
8597 error (_("Cannot create a ranged breakpoint with multiple locations."));
8599 resolve_sal_pc (&sal_end
);
8601 end
= find_breakpoint_range_end (sal_end
);
8602 if (sal_start
.pc
> end
)
8603 error (_("Invalid address range, end preceeds start."));
8605 length
= end
- sal_start
.pc
+ 1;
8607 /* Length overflowed. */
8608 error (_("Address range too large."));
8609 else if (length
== 1)
8611 /* This range is simple enough to be handled by
8612 the `hbreak' command. */
8613 hbreak_command (addr_string_start
, 1);
8615 do_cleanups (cleanup_bkpt
);
8620 /* Now set up the breakpoint. */
8621 b
= set_raw_breakpoint (get_current_arch (), sal_start
,
8622 bp_hardware_breakpoint
);
8623 set_breakpoint_count (breakpoint_count
+ 1);
8624 b
->number
= breakpoint_count
;
8625 b
->disposition
= disp_donttouch
;
8626 b
->addr_string
= addr_string_start
;
8627 b
->addr_string_range_end
= addr_string_end
;
8628 b
->ops
= &ranged_breakpoint_ops
;
8629 b
->loc
->length
= length
;
8631 discard_cleanups (cleanup_bkpt
);
8634 update_global_location_list (1);
8637 /* Return non-zero if EXP is verified as constant. Returned zero
8638 means EXP is variable. Also the constant detection may fail for
8639 some constant expressions and in such case still falsely return
8642 watchpoint_exp_is_const (const struct expression
*exp
)
8650 /* We are only interested in the descriptor of each element. */
8651 operator_length (exp
, i
, &oplenp
, &argsp
);
8654 switch (exp
->elts
[i
].opcode
)
8664 case BINOP_LOGICAL_AND
:
8665 case BINOP_LOGICAL_OR
:
8666 case BINOP_BITWISE_AND
:
8667 case BINOP_BITWISE_IOR
:
8668 case BINOP_BITWISE_XOR
:
8670 case BINOP_NOTEQUAL
:
8686 case TERNOP_SLICE_COUNT
:
8698 case OP_OBJC_NSSTRING
:
8701 case UNOP_LOGICAL_NOT
:
8702 case UNOP_COMPLEMENT
:
8705 /* Unary, binary and ternary operators: We have to check
8706 their operands. If they are constant, then so is the
8707 result of that operation. For instance, if A and B are
8708 determined to be constants, then so is "A + B".
8710 UNOP_IND is one exception to the rule above, because the
8711 value of *ADDR is not necessarily a constant, even when
8716 /* Check whether the associated symbol is a constant.
8718 We use SYMBOL_CLASS rather than TYPE_CONST because it's
8719 possible that a buggy compiler could mark a variable as
8720 constant even when it is not, and TYPE_CONST would return
8721 true in this case, while SYMBOL_CLASS wouldn't.
8723 We also have to check for function symbols because they
8724 are always constant. */
8726 struct symbol
*s
= exp
->elts
[i
+ 2].symbol
;
8728 if (SYMBOL_CLASS (s
) != LOC_BLOCK
8729 && SYMBOL_CLASS (s
) != LOC_CONST
8730 && SYMBOL_CLASS (s
) != LOC_CONST_BYTES
)
8735 /* The default action is to return 0 because we are using
8736 the optimistic approach here: If we don't know something,
8737 then it is not a constant. */
8746 /* Implement the "insert" breakpoint_ops method for hardware watchpoints. */
8749 insert_watchpoint (struct bp_location
*bl
)
8751 int length
= bl
->owner
->exact
? 1 : bl
->length
;
8753 return target_insert_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
8754 bl
->owner
->cond_exp
);
8757 /* Implement the "remove" breakpoint_ops method for hardware watchpoints. */
8760 remove_watchpoint (struct bp_location
*bl
)
8762 int length
= bl
->owner
->exact
? 1 : bl
->length
;
8764 return target_remove_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
8765 bl
->owner
->cond_exp
);
8768 /* Implement the "resources_needed" breakpoint_ops method for
8769 hardware watchpoints. */
8772 resources_needed_watchpoint (const struct bp_location
*bl
)
8774 int length
= bl
->owner
->exact
? 1 : bl
->length
;
8776 return target_region_ok_for_hw_watchpoint (bl
->address
, length
);
8779 /* The breakpoint_ops structure to be used in hardware watchpoints. */
8781 static struct breakpoint_ops watchpoint_breakpoint_ops
=
8785 NULL
, /* breakpoint_hit */
8786 resources_needed_watchpoint
,
8787 NULL
, /* print_it */
8788 NULL
, /* print_one */
8789 NULL
, /* print_one_detail */
8790 NULL
, /* print_mention */
8791 NULL
/* print_recreate */
8794 /* accessflag: hw_write: watch write,
8795 hw_read: watch read,
8796 hw_access: watch access (read or write) */
8798 watch_command_1 (char *arg
, int accessflag
, int from_tty
,
8799 int just_location
, int internal
)
8801 struct breakpoint
*b
, *scope_breakpoint
= NULL
;
8802 struct expression
*exp
;
8803 struct block
*exp_valid_block
= NULL
, *cond_exp_valid_block
= NULL
;
8804 struct value
*val
, *mark
, *result
;
8805 struct frame_info
*frame
;
8806 char *exp_start
= NULL
;
8807 char *exp_end
= NULL
;
8808 char *tok
, *id_tok_start
, *end_tok
;
8810 char *cond_start
= NULL
;
8811 char *cond_end
= NULL
;
8812 int i
, other_type_used
, target_resources_ok
= 0;
8813 enum bptype bp_type
;
8818 /* Make sure that we actually have parameters to parse. */
8819 if (arg
!= NULL
&& arg
[0] != '\0')
8821 toklen
= strlen (arg
); /* Size of argument list. */
8823 /* Points tok to the end of the argument list. */
8824 tok
= arg
+ toklen
- 1;
8826 /* Go backwards in the parameters list. Skip the last
8827 parameter. If we're expecting a 'thread <thread_num>'
8828 parameter, this should be the thread identifier. */
8829 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
8831 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
8834 /* Points end_tok to the beginning of the last token. */
8835 id_tok_start
= tok
+ 1;
8837 /* Go backwards in the parameters list. Skip one more
8838 parameter. If we're expecting a 'thread <thread_num>'
8839 parameter, we should reach a "thread" token. */
8840 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
8845 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
8848 /* Move the pointer forward to skip the whitespace and
8849 calculate the length of the token. */
8851 toklen
= end_tok
- tok
;
8853 if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
8855 /* At this point we've found a "thread" token, which means
8856 the user is trying to set a watchpoint that triggers
8857 only in a specific thread. */
8860 /* Extract the thread ID from the next token. */
8861 thread
= strtol (id_tok_start
, &endp
, 0);
8863 /* Check if the user provided a valid numeric value for the
8865 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
8866 error (_("Invalid thread ID specification %s."), id_tok_start
);
8868 /* Check if the thread actually exists. */
8869 if (!valid_thread_id (thread
))
8870 error (_("Unknown thread %d."), thread
);
8872 /* Truncate the string and get rid of the thread <thread_num>
8873 parameter before the parameter list is parsed by the
8874 evaluate_expression() function. */
8879 /* Parse the rest of the arguments. */
8880 innermost_block
= NULL
;
8882 exp
= parse_exp_1 (&arg
, 0, 0);
8884 /* Remove trailing whitespace from the expression before saving it.
8885 This makes the eventual display of the expression string a bit
8887 while (exp_end
> exp_start
&& (exp_end
[-1] == ' ' || exp_end
[-1] == '\t'))
8890 /* Checking if the expression is not constant. */
8891 if (watchpoint_exp_is_const (exp
))
8895 len
= exp_end
- exp_start
;
8896 while (len
> 0 && isspace (exp_start
[len
- 1]))
8898 error (_("Cannot watch constant value `%.*s'."), len
, exp_start
);
8901 exp_valid_block
= innermost_block
;
8902 mark
= value_mark ();
8903 fetch_subexp_value (exp
, &pc
, &val
, &result
, NULL
);
8907 exp_valid_block
= NULL
;
8908 val
= value_addr (result
);
8909 release_value (val
);
8910 value_free_to_mark (mark
);
8912 else if (val
!= NULL
)
8913 release_value (val
);
8915 tok
= skip_spaces (arg
);
8916 end_tok
= skip_to_space (tok
);
8918 toklen
= end_tok
- tok
;
8919 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
8921 struct expression
*cond
;
8923 innermost_block
= NULL
;
8924 tok
= cond_start
= end_tok
+ 1;
8925 cond
= parse_exp_1 (&tok
, 0, 0);
8927 /* The watchpoint expression may not be local, but the condition
8928 may still be. E.g.: `watch global if local > 0'. */
8929 cond_exp_valid_block
= innermost_block
;
8935 error (_("Junk at end of command."));
8937 if (accessflag
== hw_read
)
8938 bp_type
= bp_read_watchpoint
;
8939 else if (accessflag
== hw_access
)
8940 bp_type
= bp_access_watchpoint
;
8942 bp_type
= bp_hardware_watchpoint
;
8944 reg_cnt
= can_use_hardware_watchpoint (val
, target_exact_watchpoints
);
8945 if (reg_cnt
== 0 && bp_type
!= bp_hardware_watchpoint
)
8946 error (_("Expression cannot be implemented with read/access watchpoint."));
8949 i
= hw_watchpoint_used_count (bp_type
, &other_type_used
);
8950 target_resources_ok
=
8951 target_can_use_hardware_watchpoint (bp_type
, i
+ reg_cnt
,
8953 if (target_resources_ok
== 0 && bp_type
!= bp_hardware_watchpoint
)
8954 error (_("Target does not support this type of hardware watchpoint."));
8956 if (target_resources_ok
< 0 && bp_type
!= bp_hardware_watchpoint
)
8957 error (_("Target can only support one kind "
8958 "of HW watchpoint at a time."));
8961 /* Change the type of breakpoint to an ordinary watchpoint if a
8962 hardware watchpoint could not be set. */
8963 if (!reg_cnt
|| target_resources_ok
<= 0)
8964 bp_type
= bp_watchpoint
;
8966 frame
= block_innermost_frame (exp_valid_block
);
8968 /* If the expression is "local", then set up a "watchpoint scope"
8969 breakpoint at the point where we've left the scope of the watchpoint
8970 expression. Create the scope breakpoint before the watchpoint, so
8971 that we will encounter it first in bpstat_stop_status. */
8972 if (exp_valid_block
&& frame
)
8974 if (frame_id_p (frame_unwind_caller_id (frame
)))
8977 = create_internal_breakpoint (frame_unwind_caller_arch (frame
),
8978 frame_unwind_caller_pc (frame
),
8979 bp_watchpoint_scope
);
8981 scope_breakpoint
->enable_state
= bp_enabled
;
8983 /* Automatically delete the breakpoint when it hits. */
8984 scope_breakpoint
->disposition
= disp_del
;
8986 /* Only break in the proper frame (help with recursion). */
8987 scope_breakpoint
->frame_id
= frame_unwind_caller_id (frame
);
8989 /* Set the address at which we will stop. */
8990 scope_breakpoint
->loc
->gdbarch
8991 = frame_unwind_caller_arch (frame
);
8992 scope_breakpoint
->loc
->requested_address
8993 = frame_unwind_caller_pc (frame
);
8994 scope_breakpoint
->loc
->address
8995 = adjust_breakpoint_address (scope_breakpoint
->loc
->gdbarch
,
8996 scope_breakpoint
->loc
->requested_address
,
8997 scope_breakpoint
->type
);
9001 /* Now set up the breakpoint. */
9002 b
= set_raw_breakpoint_without_location (NULL
, bp_type
);
9003 set_breakpoint_number (internal
, b
);
9005 b
->disposition
= disp_donttouch
;
9007 b
->exp_valid_block
= exp_valid_block
;
9008 b
->cond_exp_valid_block
= cond_exp_valid_block
;
9011 struct type
*t
= value_type (val
);
9012 CORE_ADDR addr
= value_as_address (val
);
9015 t
= check_typedef (TYPE_TARGET_TYPE (check_typedef (t
)));
9016 name
= type_to_string (t
);
9018 b
->exp_string_reparse
= xstrprintf ("* (%s *) %s", name
,
9019 core_addr_to_string (addr
));
9022 b
->exp_string
= xstrprintf ("-location: %.*s",
9023 (int) (exp_end
- exp_start
), exp_start
);
9025 /* The above expression is in C. */
9026 b
->language
= language_c
;
9029 b
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
9032 b
->ops
= &watchpoint_breakpoint_ops
;
9034 /* Use an exact watchpoint when there's only one memory region to be
9035 watched, and only one debug register is needed to watch it. */
9036 b
->exact
= target_exact_watchpoints
&& reg_cnt
== 1;
9039 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
9045 b
->watchpoint_frame
= get_frame_id (frame
);
9046 b
->watchpoint_thread
= inferior_ptid
;
9050 b
->watchpoint_frame
= null_frame_id
;
9051 b
->watchpoint_thread
= null_ptid
;
9054 if (scope_breakpoint
!= NULL
)
9056 /* The scope breakpoint is related to the watchpoint. We will
9057 need to act on them together. */
9058 b
->related_breakpoint
= scope_breakpoint
;
9059 scope_breakpoint
->related_breakpoint
= b
;
9063 value_free_to_mark (mark
);
9065 /* Finally update the new watchpoint. This creates the locations
9066 that should be inserted. */
9067 update_watchpoint (b
, 1);
9069 /* Do not mention breakpoints with a negative number, but do
9070 notify observers. */
9071 observer_notify_breakpoint_created (b
->number
);
9074 update_global_location_list (1);
9077 /* Return count of debug registers needed to watch the given expression.
9078 If EXACT_WATCHPOINTS is 1, then consider that only the address of
9079 the start of the watched region will be monitored (i.e., all accesses
9080 will be aligned). This uses less debug registers on some targets.
9082 If the watchpoint cannot be handled in hardware return zero. */
9085 can_use_hardware_watchpoint (struct value
*v
, int exact_watchpoints
)
9087 int found_memory_cnt
= 0;
9088 struct value
*head
= v
;
9090 /* Did the user specifically forbid us to use hardware watchpoints? */
9091 if (!can_use_hw_watchpoints
)
9094 /* Make sure that the value of the expression depends only upon
9095 memory contents, and values computed from them within GDB. If we
9096 find any register references or function calls, we can't use a
9097 hardware watchpoint.
9099 The idea here is that evaluating an expression generates a series
9100 of values, one holding the value of every subexpression. (The
9101 expression a*b+c has five subexpressions: a, b, a*b, c, and
9102 a*b+c.) GDB's values hold almost enough information to establish
9103 the criteria given above --- they identify memory lvalues,
9104 register lvalues, computed values, etcetera. So we can evaluate
9105 the expression, and then scan the chain of values that leaves
9106 behind to decide whether we can detect any possible change to the
9107 expression's final value using only hardware watchpoints.
9109 However, I don't think that the values returned by inferior
9110 function calls are special in any way. So this function may not
9111 notice that an expression involving an inferior function call
9112 can't be watched with hardware watchpoints. FIXME. */
9113 for (; v
; v
= value_next (v
))
9115 if (VALUE_LVAL (v
) == lval_memory
)
9117 if (v
!= head
&& value_lazy (v
))
9118 /* A lazy memory lvalue in the chain is one that GDB never
9119 needed to fetch; we either just used its address (e.g.,
9120 `a' in `a.b') or we never needed it at all (e.g., `a'
9121 in `a,b'). This doesn't apply to HEAD; if that is
9122 lazy then it was not readable, but watch it anyway. */
9126 /* Ahh, memory we actually used! Check if we can cover
9127 it with hardware watchpoints. */
9128 struct type
*vtype
= check_typedef (value_type (v
));
9130 /* We only watch structs and arrays if user asked for it
9131 explicitly, never if they just happen to appear in a
9132 middle of some value chain. */
9134 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
9135 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
9137 CORE_ADDR vaddr
= value_address (v
);
9141 len
= (exact_watchpoints
9142 && is_scalar_type_recursive (vtype
))?
9143 1 : TYPE_LENGTH (value_type (v
));
9145 num_regs
= target_region_ok_for_hw_watchpoint (vaddr
, len
);
9149 found_memory_cnt
+= num_regs
;
9153 else if (VALUE_LVAL (v
) != not_lval
9154 && deprecated_value_modifiable (v
) == 0)
9155 return 0; /* These are values from the history (e.g., $1). */
9156 else if (VALUE_LVAL (v
) == lval_register
)
9157 return 0; /* Cannot watch a register with a HW watchpoint. */
9160 /* The expression itself looks suitable for using a hardware
9161 watchpoint, but give the target machine a chance to reject it. */
9162 return found_memory_cnt
;
9166 watch_command_wrapper (char *arg
, int from_tty
, int internal
)
9168 watch_command_1 (arg
, hw_write
, from_tty
, 0, internal
);
9171 /* A helper function that looks for an argument at the start of a
9172 string. The argument must also either be at the end of the string,
9173 or be followed by whitespace. Returns 1 if it finds the argument,
9174 0 otherwise. If the argument is found, it updates *STR. */
9177 check_for_argument (char **str
, char *arg
, int arg_len
)
9179 if (strncmp (*str
, arg
, arg_len
) == 0
9180 && ((*str
)[arg_len
] == '\0' || isspace ((*str
)[arg_len
])))
9188 /* A helper function that looks for the "-location" argument and then
9189 calls watch_command_1. */
9192 watch_maybe_just_location (char *arg
, int accessflag
, int from_tty
)
9194 int just_location
= 0;
9197 && (check_for_argument (&arg
, "-location", sizeof ("-location") - 1)
9198 || check_for_argument (&arg
, "-l", sizeof ("-l") - 1)))
9200 arg
= skip_spaces (arg
);
9204 watch_command_1 (arg
, accessflag
, from_tty
, just_location
, 0);
9208 watch_command (char *arg
, int from_tty
)
9210 watch_maybe_just_location (arg
, hw_write
, from_tty
);
9214 rwatch_command_wrapper (char *arg
, int from_tty
, int internal
)
9216 watch_command_1 (arg
, hw_read
, from_tty
, 0, internal
);
9220 rwatch_command (char *arg
, int from_tty
)
9222 watch_maybe_just_location (arg
, hw_read
, from_tty
);
9226 awatch_command_wrapper (char *arg
, int from_tty
, int internal
)
9228 watch_command_1 (arg
, hw_access
, from_tty
, 0, internal
);
9232 awatch_command (char *arg
, int from_tty
)
9234 watch_maybe_just_location (arg
, hw_access
, from_tty
);
9238 /* Helper routines for the until_command routine in infcmd.c. Here
9239 because it uses the mechanisms of breakpoints. */
9241 struct until_break_command_continuation_args
9243 struct breakpoint
*breakpoint
;
9244 struct breakpoint
*breakpoint2
;
9248 /* This function is called by fetch_inferior_event via the
9249 cmd_continuation pointer, to complete the until command. It takes
9250 care of cleaning up the temporary breakpoints set up by the until
9253 until_break_command_continuation (void *arg
)
9255 struct until_break_command_continuation_args
*a
= arg
;
9257 delete_breakpoint (a
->breakpoint
);
9259 delete_breakpoint (a
->breakpoint2
);
9260 delete_longjmp_breakpoint (a
->thread_num
);
9264 until_break_command (char *arg
, int from_tty
, int anywhere
)
9266 struct symtabs_and_lines sals
;
9267 struct symtab_and_line sal
;
9268 struct frame_info
*frame
= get_selected_frame (NULL
);
9269 struct breakpoint
*breakpoint
;
9270 struct breakpoint
*breakpoint2
= NULL
;
9271 struct cleanup
*old_chain
;
9273 struct thread_info
*tp
;
9275 clear_proceed_status ();
9277 /* Set a breakpoint where the user wants it and at return from
9280 if (default_breakpoint_valid
)
9281 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
9282 default_breakpoint_line
, NULL
);
9284 sals
= decode_line_1 (&arg
, 1, (struct symtab
*) NULL
, 0, NULL
);
9286 if (sals
.nelts
!= 1)
9287 error (_("Couldn't get information on specified line."));
9290 xfree (sals
.sals
); /* malloc'd, so freed. */
9293 error (_("Junk at end of arguments."));
9295 resolve_sal_pc (&sal
);
9298 /* If the user told us to continue until a specified location,
9299 we don't specify a frame at which we need to stop. */
9300 breakpoint
= set_momentary_breakpoint (get_frame_arch (frame
), sal
,
9301 null_frame_id
, bp_until
);
9303 /* Otherwise, specify the selected frame, because we want to stop
9304 only at the very same frame. */
9305 breakpoint
= set_momentary_breakpoint (get_frame_arch (frame
), sal
,
9306 get_stack_frame_id (frame
),
9309 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
9311 tp
= inferior_thread ();
9314 /* Keep within the current frame, or in frames called by the current
9317 if (frame_id_p (frame_unwind_caller_id (frame
)))
9319 sal
= find_pc_line (frame_unwind_caller_pc (frame
), 0);
9320 sal
.pc
= frame_unwind_caller_pc (frame
);
9321 breakpoint2
= set_momentary_breakpoint (frame_unwind_caller_arch (frame
),
9323 frame_unwind_caller_id (frame
),
9325 make_cleanup_delete_breakpoint (breakpoint2
);
9327 set_longjmp_breakpoint (tp
, frame_unwind_caller_id (frame
));
9328 make_cleanup (delete_longjmp_breakpoint_cleanup
, &thread
);
9331 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
9333 /* If we are running asynchronously, and proceed call above has
9334 actually managed to start the target, arrange for breakpoints to
9335 be deleted when the target stops. Otherwise, we're already
9336 stopped and delete breakpoints via cleanup chain. */
9338 if (target_can_async_p () && is_running (inferior_ptid
))
9340 struct until_break_command_continuation_args
*args
;
9341 args
= xmalloc (sizeof (*args
));
9343 args
->breakpoint
= breakpoint
;
9344 args
->breakpoint2
= breakpoint2
;
9345 args
->thread_num
= thread
;
9347 discard_cleanups (old_chain
);
9348 add_continuation (inferior_thread (),
9349 until_break_command_continuation
, args
,
9353 do_cleanups (old_chain
);
9356 /* This function attempts to parse an optional "if <cond>" clause
9357 from the arg string. If one is not found, it returns NULL.
9359 Else, it returns a pointer to the condition string. (It does not
9360 attempt to evaluate the string against a particular block.) And,
9361 it updates arg to point to the first character following the parsed
9362 if clause in the arg string. */
9365 ep_parse_optional_if_clause (char **arg
)
9369 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
9372 /* Skip the "if" keyword. */
9375 /* Skip any extra leading whitespace, and record the start of the
9376 condition string. */
9377 *arg
= skip_spaces (*arg
);
9380 /* Assume that the condition occupies the remainder of the arg
9382 (*arg
) += strlen (cond_string
);
9387 /* Commands to deal with catching events, such as signals, exceptions,
9388 process start/exit, etc. */
9392 catch_fork_temporary
, catch_vfork_temporary
,
9393 catch_fork_permanent
, catch_vfork_permanent
9398 catch_fork_command_1 (char *arg
, int from_tty
,
9399 struct cmd_list_element
*command
)
9401 struct gdbarch
*gdbarch
= get_current_arch ();
9402 char *cond_string
= NULL
;
9403 catch_fork_kind fork_kind
;
9406 fork_kind
= (catch_fork_kind
) (uintptr_t) get_cmd_context (command
);
9407 tempflag
= (fork_kind
== catch_fork_temporary
9408 || fork_kind
== catch_vfork_temporary
);
9412 arg
= skip_spaces (arg
);
9414 /* The allowed syntax is:
9416 catch [v]fork if <cond>
9418 First, check if there's an if clause. */
9419 cond_string
= ep_parse_optional_if_clause (&arg
);
9421 if ((*arg
!= '\0') && !isspace (*arg
))
9422 error (_("Junk at end of arguments."));
9424 /* If this target supports it, create a fork or vfork catchpoint
9425 and enable reporting of such events. */
9428 case catch_fork_temporary
:
9429 case catch_fork_permanent
:
9430 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
9431 &catch_fork_breakpoint_ops
);
9433 case catch_vfork_temporary
:
9434 case catch_vfork_permanent
:
9435 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
9436 &catch_vfork_breakpoint_ops
);
9439 error (_("unsupported or unknown fork kind; cannot catch it"));
9445 catch_exec_command_1 (char *arg
, int from_tty
,
9446 struct cmd_list_element
*command
)
9448 struct gdbarch
*gdbarch
= get_current_arch ();
9450 char *cond_string
= NULL
;
9452 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
9456 arg
= skip_spaces (arg
);
9458 /* The allowed syntax is:
9460 catch exec if <cond>
9462 First, check if there's an if clause. */
9463 cond_string
= ep_parse_optional_if_clause (&arg
);
9465 if ((*arg
!= '\0') && !isspace (*arg
))
9466 error (_("Junk at end of arguments."));
9468 /* If this target supports it, create an exec catchpoint
9469 and enable reporting of such events. */
9470 create_catchpoint (gdbarch
, tempflag
, cond_string
,
9471 &catch_exec_breakpoint_ops
);
9474 static enum print_stop_action
9475 print_exception_catchpoint (struct breakpoint
*b
)
9477 int bp_temp
, bp_throw
;
9479 annotate_catchpoint (b
->number
);
9481 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
9482 if (b
->loc
->address
!= b
->loc
->requested_address
)
9483 breakpoint_adjustment_warning (b
->loc
->requested_address
,
9486 bp_temp
= b
->disposition
== disp_del
;
9488 bp_temp
? "Temporary catchpoint "
9490 if (!ui_out_is_mi_like_p (uiout
))
9491 ui_out_field_int (uiout
, "bkptno", b
->number
);
9493 bp_throw
? " (exception thrown), "
9494 : " (exception caught), ");
9495 if (ui_out_is_mi_like_p (uiout
))
9497 ui_out_field_string (uiout
, "reason",
9498 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
9499 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
9500 ui_out_field_int (uiout
, "bkptno", b
->number
);
9502 return PRINT_SRC_AND_LOC
;
9506 print_one_exception_catchpoint (struct breakpoint
*b
,
9507 struct bp_location
**last_loc
)
9509 struct value_print_options opts
;
9511 get_user_print_options (&opts
);
9512 if (opts
.addressprint
)
9515 if (b
->loc
== NULL
|| b
->loc
->shlib_disabled
)
9516 ui_out_field_string (uiout
, "addr", "<PENDING>");
9518 ui_out_field_core_addr (uiout
, "addr",
9519 b
->loc
->gdbarch
, b
->loc
->address
);
9524 if (strstr (b
->addr_string
, "throw") != NULL
)
9525 ui_out_field_string (uiout
, "what", "exception throw");
9527 ui_out_field_string (uiout
, "what", "exception catch");
9531 print_mention_exception_catchpoint (struct breakpoint
*b
)
9536 bp_temp
= b
->disposition
== disp_del
;
9537 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
9538 ui_out_text (uiout
, bp_temp
? _("Temporary catchpoint ")
9539 : _("Catchpoint "));
9540 ui_out_field_int (uiout
, "bkptno", b
->number
);
9541 ui_out_text (uiout
, bp_throw
? _(" (throw)")
9545 /* Implement the "print_recreate" breakpoint_ops method for throw and
9546 catch catchpoints. */
9549 print_recreate_exception_catchpoint (struct breakpoint
*b
,
9555 bp_temp
= b
->disposition
== disp_del
;
9556 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
9557 fprintf_unfiltered (fp
, bp_temp
? "tcatch " : "catch ");
9558 fprintf_unfiltered (fp
, bp_throw
? "throw" : "catch");
9561 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops
= {
9564 NULL
, /* breakpoint_hit */
9565 NULL
, /* resources_needed */
9566 print_exception_catchpoint
,
9567 print_one_exception_catchpoint
,
9568 NULL
, /* print_one_detail */
9569 print_mention_exception_catchpoint
,
9570 print_recreate_exception_catchpoint
9574 handle_gnu_v3_exceptions (int tempflag
, char *cond_string
,
9575 enum exception_event_kind ex_event
, int from_tty
)
9577 char *trigger_func_name
;
9579 if (ex_event
== EX_EVENT_CATCH
)
9580 trigger_func_name
= "__cxa_begin_catch";
9582 trigger_func_name
= "__cxa_throw";
9584 create_breakpoint (get_current_arch (),
9585 trigger_func_name
, cond_string
, -1,
9586 0 /* condition and thread are valid. */,
9587 tempflag
, bp_breakpoint
,
9589 AUTO_BOOLEAN_TRUE
/* pending */,
9590 &gnu_v3_exception_catchpoint_ops
, from_tty
,
9597 /* Deal with "catch catch" and "catch throw" commands. */
9600 catch_exception_command_1 (enum exception_event_kind ex_event
, char *arg
,
9601 int tempflag
, int from_tty
)
9603 char *cond_string
= NULL
;
9607 arg
= skip_spaces (arg
);
9609 cond_string
= ep_parse_optional_if_clause (&arg
);
9611 if ((*arg
!= '\0') && !isspace (*arg
))
9612 error (_("Junk at end of arguments."));
9614 if (ex_event
!= EX_EVENT_THROW
9615 && ex_event
!= EX_EVENT_CATCH
)
9616 error (_("Unsupported or unknown exception event; cannot catch it"));
9618 if (handle_gnu_v3_exceptions (tempflag
, cond_string
, ex_event
, from_tty
))
9621 warning (_("Unsupported with this platform/compiler combination."));
9624 /* Implementation of "catch catch" command. */
9627 catch_catch_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
9629 int tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
9631 catch_exception_command_1 (EX_EVENT_CATCH
, arg
, tempflag
, from_tty
);
9634 /* Implementation of "catch throw" command. */
9637 catch_throw_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
9639 int tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
9641 catch_exception_command_1 (EX_EVENT_THROW
, arg
, tempflag
, from_tty
);
9644 /* Create a breakpoint struct for Ada exception catchpoints. */
9647 create_ada_exception_breakpoint (struct gdbarch
*gdbarch
,
9648 struct symtab_and_line sal
,
9652 struct expression
*cond
,
9653 struct breakpoint_ops
*ops
,
9657 struct breakpoint
*b
;
9661 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
9663 loc_gdbarch
= gdbarch
;
9665 describe_other_breakpoints (loc_gdbarch
,
9666 sal
.pspace
, sal
.pc
, sal
.section
, -1);
9667 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
9668 version for exception catchpoints, because two catchpoints
9669 used for different exception names will use the same address.
9670 In this case, a "breakpoint ... also set at..." warning is
9671 unproductive. Besides, the warning phrasing is also a bit
9672 inapropriate, we should use the word catchpoint, and tell
9673 the user what type of catchpoint it is. The above is good
9674 enough for now, though. */
9677 b
= set_raw_breakpoint (gdbarch
, sal
, bp_breakpoint
);
9678 set_breakpoint_count (breakpoint_count
+ 1);
9680 b
->enable_state
= bp_enabled
;
9681 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
9682 b
->number
= breakpoint_count
;
9683 b
->ignore_count
= 0;
9684 b
->loc
->cond
= cond
;
9685 b
->addr_string
= addr_string
;
9686 b
->language
= language_ada
;
9687 b
->cond_string
= cond_string
;
9688 b
->exp_string
= exp_string
;
9693 update_global_location_list (1);
9696 /* Implement the "catch exception" command. */
9699 catch_ada_exception_command (char *arg
, int from_tty
,
9700 struct cmd_list_element
*command
)
9702 struct gdbarch
*gdbarch
= get_current_arch ();
9704 struct symtab_and_line sal
;
9705 char *addr_string
= NULL
;
9706 char *exp_string
= NULL
;
9707 char *cond_string
= NULL
;
9708 struct expression
*cond
= NULL
;
9709 struct breakpoint_ops
*ops
= NULL
;
9711 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
9715 sal
= ada_decode_exception_location (arg
, &addr_string
, &exp_string
,
9716 &cond_string
, &cond
, &ops
);
9717 create_ada_exception_breakpoint (gdbarch
, sal
, addr_string
, exp_string
,
9718 cond_string
, cond
, ops
, tempflag
,
9722 /* Cleanup function for a syscall filter list. */
9724 clean_up_filters (void *arg
)
9726 VEC(int) *iter
= *(VEC(int) **) arg
;
9727 VEC_free (int, iter
);
9730 /* Splits the argument using space as delimiter. Returns an xmalloc'd
9731 filter list, or NULL if no filtering is required. */
9733 catch_syscall_split_args (char *arg
)
9735 VEC(int) *result
= NULL
;
9736 struct cleanup
*cleanup
= make_cleanup (clean_up_filters
, &result
);
9738 while (*arg
!= '\0')
9740 int i
, syscall_number
;
9745 /* Skip whitespace. */
9746 while (isspace (*arg
))
9749 for (i
= 0; i
< 127 && arg
[i
] && !isspace (arg
[i
]); ++i
)
9750 cur_name
[i
] = arg
[i
];
9754 /* Check if the user provided a syscall name or a number. */
9755 syscall_number
= (int) strtol (cur_name
, &endptr
, 0);
9756 if (*endptr
== '\0')
9757 get_syscall_by_number (syscall_number
, &s
);
9760 /* We have a name. Let's check if it's valid and convert it
9762 get_syscall_by_name (cur_name
, &s
);
9764 if (s
.number
== UNKNOWN_SYSCALL
)
9765 /* Here we have to issue an error instead of a warning,
9766 because GDB cannot do anything useful if there's no
9767 syscall number to be caught. */
9768 error (_("Unknown syscall name '%s'."), cur_name
);
9771 /* Ok, it's valid. */
9772 VEC_safe_push (int, result
, s
.number
);
9775 discard_cleanups (cleanup
);
9779 /* Implement the "catch syscall" command. */
9782 catch_syscall_command_1 (char *arg
, int from_tty
,
9783 struct cmd_list_element
*command
)
9788 struct gdbarch
*gdbarch
= get_current_arch ();
9790 /* Checking if the feature if supported. */
9791 if (gdbarch_get_syscall_number_p (gdbarch
) == 0)
9792 error (_("The feature 'catch syscall' is not supported on \
9793 this architecture yet."));
9795 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
9797 arg
= skip_spaces (arg
);
9799 /* We need to do this first "dummy" translation in order
9800 to get the syscall XML file loaded or, most important,
9801 to display a warning to the user if there's no XML file
9802 for his/her architecture. */
9803 get_syscall_by_number (0, &s
);
9805 /* The allowed syntax is:
9807 catch syscall <name | number> [<name | number> ... <name | number>]
9809 Let's check if there's a syscall name. */
9812 filter
= catch_syscall_split_args (arg
);
9816 create_syscall_event_catchpoint (tempflag
, filter
,
9817 &catch_syscall_breakpoint_ops
);
9820 /* Implement the "catch assert" command. */
9823 catch_assert_command (char *arg
, int from_tty
,
9824 struct cmd_list_element
*command
)
9826 struct gdbarch
*gdbarch
= get_current_arch ();
9828 struct symtab_and_line sal
;
9829 char *addr_string
= NULL
;
9830 struct breakpoint_ops
*ops
= NULL
;
9832 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
9836 sal
= ada_decode_assert_location (arg
, &addr_string
, &ops
);
9837 create_ada_exception_breakpoint (gdbarch
, sal
, addr_string
, NULL
, NULL
, NULL
,
9838 ops
, tempflag
, from_tty
);
9842 catch_command (char *arg
, int from_tty
)
9844 error (_("Catch requires an event name."));
9849 tcatch_command (char *arg
, int from_tty
)
9851 error (_("Catch requires an event name."));
9854 /* Delete breakpoints by address or line. */
9857 clear_command (char *arg
, int from_tty
)
9859 struct breakpoint
*b
;
9860 VEC(breakpoint_p
) *found
= 0;
9863 struct symtabs_and_lines sals
;
9864 struct symtab_and_line sal
;
9869 sals
= decode_line_spec (arg
, 1);
9874 sals
.sals
= (struct symtab_and_line
*)
9875 xmalloc (sizeof (struct symtab_and_line
));
9876 make_cleanup (xfree
, sals
.sals
);
9877 init_sal (&sal
); /* Initialize to zeroes. */
9878 sal
.line
= default_breakpoint_line
;
9879 sal
.symtab
= default_breakpoint_symtab
;
9880 sal
.pc
= default_breakpoint_address
;
9881 sal
.pspace
= default_breakpoint_pspace
;
9882 if (sal
.symtab
== 0)
9883 error (_("No source file specified."));
9891 /* We don't call resolve_sal_pc here. That's not as bad as it
9892 seems, because all existing breakpoints typically have both
9893 file/line and pc set. So, if clear is given file/line, we can
9894 match this to existing breakpoint without obtaining pc at all.
9896 We only support clearing given the address explicitly
9897 present in breakpoint table. Say, we've set breakpoint
9898 at file:line. There were several PC values for that file:line,
9899 due to optimization, all in one block.
9901 We've picked one PC value. If "clear" is issued with another
9902 PC corresponding to the same file:line, the breakpoint won't
9903 be cleared. We probably can still clear the breakpoint, but
9904 since the other PC value is never presented to user, user
9905 can only find it by guessing, and it does not seem important
9908 /* For each line spec given, delete bps which correspond to it. Do
9909 it in two passes, solely to preserve the current behavior that
9910 from_tty is forced true if we delete more than one
9914 for (i
= 0; i
< sals
.nelts
; i
++)
9916 /* If exact pc given, clear bpts at that pc.
9917 If line given (pc == 0), clear all bpts on specified line.
9918 If defaulting, clear all bpts on default line
9921 defaulting sal.pc != 0 tests to do
9926 1 0 <can't happen> */
9930 /* Find all matching breakpoints and add them to 'found'. */
9934 /* Are we going to delete b? */
9935 if (b
->type
!= bp_none
&& !is_watchpoint (b
))
9937 struct bp_location
*loc
= b
->loc
;
9938 for (; loc
; loc
= loc
->next
)
9940 int pc_match
= sal
.pc
9941 && (loc
->pspace
== sal
.pspace
)
9942 && (loc
->address
== sal
.pc
)
9943 && (!section_is_overlay (loc
->section
)
9944 || loc
->section
== sal
.section
);
9945 int line_match
= ((default_match
|| (0 == sal
.pc
))
9946 && b
->source_file
!= NULL
9947 && sal
.symtab
!= NULL
9948 && sal
.pspace
== loc
->pspace
9949 && filename_cmp (b
->source_file
,
9950 sal
.symtab
->filename
) == 0
9951 && b
->line_number
== sal
.line
);
9952 if (pc_match
|| line_match
)
9961 VEC_safe_push(breakpoint_p
, found
, b
);
9964 /* Now go thru the 'found' chain and delete them. */
9965 if (VEC_empty(breakpoint_p
, found
))
9968 error (_("No breakpoint at %s."), arg
);
9970 error (_("No breakpoint at this line."));
9973 if (VEC_length(breakpoint_p
, found
) > 1)
9974 from_tty
= 1; /* Always report if deleted more than one. */
9977 if (VEC_length(breakpoint_p
, found
) == 1)
9978 printf_unfiltered (_("Deleted breakpoint "));
9980 printf_unfiltered (_("Deleted breakpoints "));
9982 breakpoints_changed ();
9984 for (ix
= 0; VEC_iterate(breakpoint_p
, found
, ix
, b
); ix
++)
9987 printf_unfiltered ("%d ", b
->number
);
9988 delete_breakpoint (b
);
9991 putchar_unfiltered ('\n');
9994 /* Delete breakpoint in BS if they are `delete' breakpoints and
9995 all breakpoints that are marked for deletion, whether hit or not.
9996 This is called after any breakpoint is hit, or after errors. */
9999 breakpoint_auto_delete (bpstat bs
)
10001 struct breakpoint
*b
, *b_tmp
;
10003 for (; bs
; bs
= bs
->next
)
10004 if (bs
->breakpoint_at
10005 && bs
->breakpoint_at
->disposition
== disp_del
10007 delete_breakpoint (bs
->breakpoint_at
);
10009 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
10011 if (b
->disposition
== disp_del_at_next_stop
)
10012 delete_breakpoint (b
);
10016 /* A comparison function for bp_location AP and BP being interfaced to
10017 qsort. Sort elements primarily by their ADDRESS (no matter what
10018 does breakpoint_address_is_meaningful say for its OWNER),
10019 secondarily by ordering first bp_permanent OWNERed elements and
10020 terciarily just ensuring the array is sorted stable way despite
10021 qsort being an instable algorithm. */
10024 bp_location_compare (const void *ap
, const void *bp
)
10026 struct bp_location
*a
= *(void **) ap
;
10027 struct bp_location
*b
= *(void **) bp
;
10028 /* A and B come from existing breakpoints having non-NULL OWNER. */
10029 int a_perm
= a
->owner
->enable_state
== bp_permanent
;
10030 int b_perm
= b
->owner
->enable_state
== bp_permanent
;
10032 if (a
->address
!= b
->address
)
10033 return (a
->address
> b
->address
) - (a
->address
< b
->address
);
10035 /* Sort permanent breakpoints first. */
10036 if (a_perm
!= b_perm
)
10037 return (a_perm
< b_perm
) - (a_perm
> b_perm
);
10039 /* Make the user-visible order stable across GDB runs. Locations of
10040 the same breakpoint can be sorted in arbitrary order. */
10042 if (a
->owner
->number
!= b
->owner
->number
)
10043 return (a
->owner
->number
> b
->owner
->number
)
10044 - (a
->owner
->number
< b
->owner
->number
);
10046 return (a
> b
) - (a
< b
);
10049 /* Set bp_location_placed_address_before_address_max and
10050 bp_location_shadow_len_after_address_max according to the current
10051 content of the bp_location array. */
10054 bp_location_target_extensions_update (void)
10056 struct bp_location
*bl
, **blp_tmp
;
10058 bp_location_placed_address_before_address_max
= 0;
10059 bp_location_shadow_len_after_address_max
= 0;
10061 ALL_BP_LOCATIONS (bl
, blp_tmp
)
10063 CORE_ADDR start
, end
, addr
;
10065 if (!bp_location_has_shadow (bl
))
10068 start
= bl
->target_info
.placed_address
;
10069 end
= start
+ bl
->target_info
.shadow_len
;
10071 gdb_assert (bl
->address
>= start
);
10072 addr
= bl
->address
- start
;
10073 if (addr
> bp_location_placed_address_before_address_max
)
10074 bp_location_placed_address_before_address_max
= addr
;
10076 /* Zero SHADOW_LEN would not pass bp_location_has_shadow. */
10078 gdb_assert (bl
->address
< end
);
10079 addr
= end
- bl
->address
;
10080 if (addr
> bp_location_shadow_len_after_address_max
)
10081 bp_location_shadow_len_after_address_max
= addr
;
10085 /* If SHOULD_INSERT is false, do not insert any breakpoint locations
10086 into the inferior, only remove already-inserted locations that no
10087 longer should be inserted. Functions that delete a breakpoint or
10088 breakpoints should pass false, so that deleting a breakpoint
10089 doesn't have the side effect of inserting the locations of other
10090 breakpoints that are marked not-inserted, but should_be_inserted
10091 returns true on them.
10093 This behaviour is useful is situations close to tear-down -- e.g.,
10094 after an exec, while the target still has execution, but breakpoint
10095 shadows of the previous executable image should *NOT* be restored
10096 to the new image; or before detaching, where the target still has
10097 execution and wants to delete breakpoints from GDB's lists, and all
10098 breakpoints had already been removed from the inferior. */
10101 update_global_location_list (int should_insert
)
10103 struct breakpoint
*b
;
10104 struct bp_location
**locp
, *loc
;
10105 struct cleanup
*cleanups
;
10107 /* Used in the duplicates detection below. When iterating over all
10108 bp_locations, points to the first bp_location of a given address.
10109 Breakpoints and watchpoints of different types are never
10110 duplicates of each other. Keep one pointer for each type of
10111 breakpoint/watchpoint, so we only need to loop over all locations
10113 struct bp_location
*bp_loc_first
; /* breakpoint */
10114 struct bp_location
*wp_loc_first
; /* hardware watchpoint */
10115 struct bp_location
*awp_loc_first
; /* access watchpoint */
10116 struct bp_location
*rwp_loc_first
; /* read watchpoint */
10118 /* Saved former bp_location array which we compare against the newly
10119 built bp_location from the current state of ALL_BREAKPOINTS. */
10120 struct bp_location
**old_location
, **old_locp
;
10121 unsigned old_location_count
;
10123 old_location
= bp_location
;
10124 old_location_count
= bp_location_count
;
10125 bp_location
= NULL
;
10126 bp_location_count
= 0;
10127 cleanups
= make_cleanup (xfree
, old_location
);
10129 ALL_BREAKPOINTS (b
)
10130 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
10131 bp_location_count
++;
10133 bp_location
= xmalloc (sizeof (*bp_location
) * bp_location_count
);
10134 locp
= bp_location
;
10135 ALL_BREAKPOINTS (b
)
10136 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
10138 qsort (bp_location
, bp_location_count
, sizeof (*bp_location
),
10139 bp_location_compare
);
10141 bp_location_target_extensions_update ();
10143 /* Identify bp_location instances that are no longer present in the
10144 new list, and therefore should be freed. Note that it's not
10145 necessary that those locations should be removed from inferior --
10146 if there's another location at the same address (previously
10147 marked as duplicate), we don't need to remove/insert the
10150 LOCP is kept in sync with OLD_LOCP, each pointing to the current
10151 and former bp_location array state respectively. */
10153 locp
= bp_location
;
10154 for (old_locp
= old_location
; old_locp
< old_location
+ old_location_count
;
10157 struct bp_location
*old_loc
= *old_locp
;
10158 struct bp_location
**loc2p
;
10160 /* Tells if 'old_loc' is found amoung the new locations. If
10161 not, we have to free it. */
10162 int found_object
= 0;
10163 /* Tells if the location should remain inserted in the target. */
10164 int keep_in_target
= 0;
10167 /* Skip LOCP entries which will definitely never be needed.
10168 Stop either at or being the one matching OLD_LOC. */
10169 while (locp
< bp_location
+ bp_location_count
10170 && (*locp
)->address
< old_loc
->address
)
10174 (loc2p
< bp_location
+ bp_location_count
10175 && (*loc2p
)->address
== old_loc
->address
);
10178 if (*loc2p
== old_loc
)
10185 /* If this location is no longer present, and inserted, look if
10186 there's maybe a new location at the same address. If so,
10187 mark that one inserted, and don't remove this one. This is
10188 needed so that we don't have a time window where a breakpoint
10189 at certain location is not inserted. */
10191 if (old_loc
->inserted
)
10193 /* If the location is inserted now, we might have to remove
10196 if (found_object
&& should_be_inserted (old_loc
))
10198 /* The location is still present in the location list,
10199 and still should be inserted. Don't do anything. */
10200 keep_in_target
= 1;
10204 /* The location is either no longer present, or got
10205 disabled. See if there's another location at the
10206 same address, in which case we don't need to remove
10207 this one from the target. */
10209 /* OLD_LOC comes from existing struct breakpoint. */
10210 if (breakpoint_address_is_meaningful (old_loc
->owner
))
10213 (loc2p
< bp_location
+ bp_location_count
10214 && (*loc2p
)->address
== old_loc
->address
);
10217 struct bp_location
*loc2
= *loc2p
;
10219 if (breakpoint_locations_match (loc2
, old_loc
))
10221 /* For the sake of should_be_inserted.
10222 Duplicates check below will fix up this
10224 loc2
->duplicate
= 0;
10226 /* Read watchpoint locations are switched to
10227 access watchpoints, if the former are not
10228 supported, but the latter are. */
10229 if (is_hardware_watchpoint (old_loc
->owner
))
10231 gdb_assert (is_hardware_watchpoint (loc2
->owner
));
10232 loc2
->watchpoint_type
= old_loc
->watchpoint_type
;
10235 if (loc2
!= old_loc
&& should_be_inserted (loc2
))
10237 loc2
->inserted
= 1;
10238 loc2
->target_info
= old_loc
->target_info
;
10239 keep_in_target
= 1;
10247 if (!keep_in_target
)
10249 if (remove_breakpoint (old_loc
, mark_uninserted
))
10251 /* This is just about all we can do. We could keep
10252 this location on the global list, and try to
10253 remove it next time, but there's no particular
10254 reason why we will succeed next time.
10256 Note that at this point, old_loc->owner is still
10257 valid, as delete_breakpoint frees the breakpoint
10258 only after calling us. */
10259 printf_filtered (_("warning: Error removing "
10260 "breakpoint %d\n"),
10261 old_loc
->owner
->number
);
10269 if (removed
&& non_stop
10270 && breakpoint_address_is_meaningful (old_loc
->owner
)
10271 && !is_hardware_watchpoint (old_loc
->owner
))
10273 /* This location was removed from the target. In
10274 non-stop mode, a race condition is possible where
10275 we've removed a breakpoint, but stop events for that
10276 breakpoint are already queued and will arrive later.
10277 We apply an heuristic to be able to distinguish such
10278 SIGTRAPs from other random SIGTRAPs: we keep this
10279 breakpoint location for a bit, and will retire it
10280 after we see some number of events. The theory here
10281 is that reporting of events should, "on the average",
10282 be fair, so after a while we'll see events from all
10283 threads that have anything of interest, and no longer
10284 need to keep this breakpoint location around. We
10285 don't hold locations forever so to reduce chances of
10286 mistaking a non-breakpoint SIGTRAP for a breakpoint
10289 The heuristic failing can be disastrous on
10290 decr_pc_after_break targets.
10292 On decr_pc_after_break targets, like e.g., x86-linux,
10293 if we fail to recognize a late breakpoint SIGTRAP,
10294 because events_till_retirement has reached 0 too
10295 soon, we'll fail to do the PC adjustment, and report
10296 a random SIGTRAP to the user. When the user resumes
10297 the inferior, it will most likely immediately crash
10298 with SIGILL/SIGBUS/SIGSEGV, or worse, get silently
10299 corrupted, because of being resumed e.g., in the
10300 middle of a multi-byte instruction, or skipped a
10301 one-byte instruction. This was actually seen happen
10302 on native x86-linux, and should be less rare on
10303 targets that do not support new thread events, like
10304 remote, due to the heuristic depending on
10307 Mistaking a random SIGTRAP for a breakpoint trap
10308 causes similar symptoms (PC adjustment applied when
10309 it shouldn't), but then again, playing with SIGTRAPs
10310 behind the debugger's back is asking for trouble.
10312 Since hardware watchpoint traps are always
10313 distinguishable from other traps, so we don't need to
10314 apply keep hardware watchpoint moribund locations
10315 around. We simply always ignore hardware watchpoint
10316 traps we can no longer explain. */
10318 old_loc
->events_till_retirement
= 3 * (thread_count () + 1);
10319 old_loc
->owner
= NULL
;
10321 VEC_safe_push (bp_location_p
, moribund_locations
, old_loc
);
10325 old_loc
->owner
= NULL
;
10326 decref_bp_location (&old_loc
);
10331 /* Rescan breakpoints at the same address and section, marking the
10332 first one as "first" and any others as "duplicates". This is so
10333 that the bpt instruction is only inserted once. If we have a
10334 permanent breakpoint at the same place as BPT, make that one the
10335 official one, and the rest as duplicates. Permanent breakpoints
10336 are sorted first for the same address.
10338 Do the same for hardware watchpoints, but also considering the
10339 watchpoint's type (regular/access/read) and length. */
10341 bp_loc_first
= NULL
;
10342 wp_loc_first
= NULL
;
10343 awp_loc_first
= NULL
;
10344 rwp_loc_first
= NULL
;
10345 ALL_BP_LOCATIONS (loc
, locp
)
10347 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always
10349 struct breakpoint
*b
= loc
->owner
;
10350 struct bp_location
**loc_first_p
;
10352 if (b
->enable_state
== bp_disabled
10353 || b
->enable_state
== bp_call_disabled
10354 || b
->enable_state
== bp_startup_disabled
10356 || loc
->shlib_disabled
10357 || !breakpoint_address_is_meaningful (b
)
10358 || is_tracepoint (b
))
10361 /* Permanent breakpoint should always be inserted. */
10362 if (b
->enable_state
== bp_permanent
&& ! loc
->inserted
)
10363 internal_error (__FILE__
, __LINE__
,
10364 _("allegedly permanent breakpoint is not "
10365 "actually inserted"));
10367 if (b
->type
== bp_hardware_watchpoint
)
10368 loc_first_p
= &wp_loc_first
;
10369 else if (b
->type
== bp_read_watchpoint
)
10370 loc_first_p
= &rwp_loc_first
;
10371 else if (b
->type
== bp_access_watchpoint
)
10372 loc_first_p
= &awp_loc_first
;
10374 loc_first_p
= &bp_loc_first
;
10376 if (*loc_first_p
== NULL
10377 || (overlay_debugging
&& loc
->section
!= (*loc_first_p
)->section
)
10378 || !breakpoint_locations_match (loc
, *loc_first_p
))
10380 *loc_first_p
= loc
;
10381 loc
->duplicate
= 0;
10385 loc
->duplicate
= 1;
10387 if ((*loc_first_p
)->owner
->enable_state
== bp_permanent
&& loc
->inserted
10388 && b
->enable_state
!= bp_permanent
)
10389 internal_error (__FILE__
, __LINE__
,
10390 _("another breakpoint was inserted on top of "
10391 "a permanent breakpoint"));
10394 if (breakpoints_always_inserted_mode () && should_insert
10395 && (have_live_inferiors ()
10396 || (gdbarch_has_global_breakpoints (target_gdbarch
))))
10397 insert_breakpoint_locations ();
10399 do_cleanups (cleanups
);
10403 breakpoint_retire_moribund (void)
10405 struct bp_location
*loc
;
10408 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
10409 if (--(loc
->events_till_retirement
) == 0)
10411 decref_bp_location (&loc
);
10412 VEC_unordered_remove (bp_location_p
, moribund_locations
, ix
);
10418 update_global_location_list_nothrow (int inserting
)
10420 struct gdb_exception e
;
10422 TRY_CATCH (e
, RETURN_MASK_ERROR
)
10423 update_global_location_list (inserting
);
10426 /* Clear BKP from a BPS. */
10429 bpstat_remove_bp_location (bpstat bps
, struct breakpoint
*bpt
)
10433 for (bs
= bps
; bs
; bs
= bs
->next
)
10434 if (bs
->breakpoint_at
== bpt
)
10436 bs
->breakpoint_at
= NULL
;
10437 bs
->old_val
= NULL
;
10438 /* bs->commands will be freed later. */
10442 /* Callback for iterate_over_threads. */
10444 bpstat_remove_breakpoint_callback (struct thread_info
*th
, void *data
)
10446 struct breakpoint
*bpt
= data
;
10448 bpstat_remove_bp_location (th
->control
.stop_bpstat
, bpt
);
10452 /* Delete a breakpoint and clean up all traces of it in the data
10456 delete_breakpoint (struct breakpoint
*bpt
)
10458 struct breakpoint
*b
;
10460 gdb_assert (bpt
!= NULL
);
10462 /* Has this bp already been deleted? This can happen because
10463 multiple lists can hold pointers to bp's. bpstat lists are
10466 One example of this happening is a watchpoint's scope bp. When
10467 the scope bp triggers, we notice that the watchpoint is out of
10468 scope, and delete it. We also delete its scope bp. But the
10469 scope bp is marked "auto-deleting", and is already on a bpstat.
10470 That bpstat is then checked for auto-deleting bp's, which are
10473 A real solution to this problem might involve reference counts in
10474 bp's, and/or giving them pointers back to their referencing
10475 bpstat's, and teaching delete_breakpoint to only free a bp's
10476 storage when no more references were extent. A cheaper bandaid
10478 if (bpt
->type
== bp_none
)
10481 /* At least avoid this stale reference until the reference counting
10482 of breakpoints gets resolved. */
10483 if (bpt
->related_breakpoint
!= bpt
)
10485 struct breakpoint
*related
;
10487 if (bpt
->type
== bp_watchpoint_scope
)
10488 watchpoint_del_at_next_stop (bpt
->related_breakpoint
);
10489 else if (bpt
->related_breakpoint
->type
== bp_watchpoint_scope
)
10490 watchpoint_del_at_next_stop (bpt
);
10492 /* Unlink bpt from the bpt->related_breakpoint ring. */
10493 for (related
= bpt
; related
->related_breakpoint
!= bpt
;
10494 related
= related
->related_breakpoint
);
10495 related
->related_breakpoint
= bpt
->related_breakpoint
;
10496 bpt
->related_breakpoint
= bpt
;
10499 observer_notify_breakpoint_deleted (bpt
->number
);
10501 if (breakpoint_chain
== bpt
)
10502 breakpoint_chain
= bpt
->next
;
10504 ALL_BREAKPOINTS (b
)
10505 if (b
->next
== bpt
)
10507 b
->next
= bpt
->next
;
10511 decref_counted_command_line (&bpt
->commands
);
10512 xfree (bpt
->cond_string
);
10513 xfree (bpt
->cond_exp
);
10514 xfree (bpt
->addr_string
);
10515 xfree (bpt
->addr_string_range_end
);
10517 xfree (bpt
->exp_string
);
10518 xfree (bpt
->exp_string_reparse
);
10519 value_free (bpt
->val
);
10520 xfree (bpt
->source_file
);
10521 xfree (bpt
->exec_pathname
);
10522 clean_up_filters (&bpt
->syscalls_to_be_caught
);
10525 /* Be sure no bpstat's are pointing at the breakpoint after it's
10527 /* FIXME, how can we find all bpstat's? We just check stop_bpstat
10528 in all threeds for now. Note that we cannot just remove bpstats
10529 pointing at bpt from the stop_bpstat list entirely, as breakpoint
10530 commands are associated with the bpstat; if we remove it here,
10531 then the later call to bpstat_do_actions (&stop_bpstat); in
10532 event-top.c won't do anything, and temporary breakpoints with
10533 commands won't work. */
10535 iterate_over_threads (bpstat_remove_breakpoint_callback
, bpt
);
10537 /* Now that breakpoint is removed from breakpoint list, update the
10538 global location list. This will remove locations that used to
10539 belong to this breakpoint. Do this before freeing the breakpoint
10540 itself, since remove_breakpoint looks at location's owner. It
10541 might be better design to have location completely
10542 self-contained, but it's not the case now. */
10543 update_global_location_list (0);
10546 /* On the chance that someone will soon try again to delete this
10547 same bp, we mark it as deleted before freeing its storage. */
10548 bpt
->type
= bp_none
;
10554 do_delete_breakpoint_cleanup (void *b
)
10556 delete_breakpoint (b
);
10560 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
10562 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
10565 /* A callback for map_breakpoint_numbers that calls
10566 delete_breakpoint. */
10569 do_delete_breakpoint (struct breakpoint
*b
, void *ignore
)
10571 delete_breakpoint (b
);
10575 delete_command (char *arg
, int from_tty
)
10577 struct breakpoint
*b
, *b_tmp
;
10583 int breaks_to_delete
= 0;
10585 /* Delete all breakpoints if no argument.
10586 Do not delete internal or call-dummy breakpoints, these have
10587 to be deleted with an explicit breakpoint number argument. */
10588 ALL_BREAKPOINTS (b
)
10590 if (b
->type
!= bp_call_dummy
10591 && b
->type
!= bp_std_terminate
10592 && b
->type
!= bp_shlib_event
10593 && b
->type
!= bp_jit_event
10594 && b
->type
!= bp_thread_event
10595 && b
->type
!= bp_overlay_event
10596 && b
->type
!= bp_longjmp_master
10597 && b
->type
!= bp_std_terminate_master
10598 && b
->type
!= bp_exception_master
10601 breaks_to_delete
= 1;
10606 /* Ask user only if there are some breakpoints to delete. */
10608 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
10610 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
10612 if (b
->type
!= bp_call_dummy
10613 && b
->type
!= bp_std_terminate
10614 && b
->type
!= bp_shlib_event
10615 && b
->type
!= bp_thread_event
10616 && b
->type
!= bp_jit_event
10617 && b
->type
!= bp_overlay_event
10618 && b
->type
!= bp_longjmp_master
10619 && b
->type
!= bp_std_terminate_master
10620 && b
->type
!= bp_exception_master
10622 delete_breakpoint (b
);
10627 map_breakpoint_numbers (arg
, do_delete_breakpoint
, NULL
);
10631 all_locations_are_pending (struct bp_location
*loc
)
10633 for (; loc
; loc
= loc
->next
)
10634 if (!loc
->shlib_disabled
)
10639 /* Subroutine of update_breakpoint_locations to simplify it.
10640 Return non-zero if multiple fns in list LOC have the same name.
10641 Null names are ignored. */
10644 ambiguous_names_p (struct bp_location
*loc
)
10646 struct bp_location
*l
;
10647 htab_t htab
= htab_create_alloc (13, htab_hash_string
,
10648 (int (*) (const void *,
10649 const void *)) streq
,
10650 NULL
, xcalloc
, xfree
);
10652 for (l
= loc
; l
!= NULL
; l
= l
->next
)
10655 const char *name
= l
->function_name
;
10657 /* Allow for some names to be NULL, ignore them. */
10661 slot
= (const char **) htab_find_slot (htab
, (const void *) name
,
10663 /* NOTE: We can assume slot != NULL here because xcalloc never
10667 htab_delete (htab
);
10673 htab_delete (htab
);
10677 /* When symbols change, it probably means the sources changed as well,
10678 and it might mean the static tracepoint markers are no longer at
10679 the same address or line numbers they used to be at last we
10680 checked. Losing your static tracepoints whenever you rebuild is
10681 undesirable. This function tries to resync/rematch gdb static
10682 tracepoints with the markers on the target, for static tracepoints
10683 that have not been set by marker id. Static tracepoint that have
10684 been set by marker id are reset by marker id in breakpoint_re_set.
10687 1) For a tracepoint set at a specific address, look for a marker at
10688 the old PC. If one is found there, assume to be the same marker.
10689 If the name / string id of the marker found is different from the
10690 previous known name, assume that means the user renamed the marker
10691 in the sources, and output a warning.
10693 2) For a tracepoint set at a given line number, look for a marker
10694 at the new address of the old line number. If one is found there,
10695 assume to be the same marker. If the name / string id of the
10696 marker found is different from the previous known name, assume that
10697 means the user renamed the marker in the sources, and output a
10700 3) If a marker is no longer found at the same address or line, it
10701 may mean the marker no longer exists. But it may also just mean
10702 the code changed a bit. Maybe the user added a few lines of code
10703 that made the marker move up or down (in line number terms). Ask
10704 the target for info about the marker with the string id as we knew
10705 it. If found, update line number and address in the matching
10706 static tracepoint. This will get confused if there's more than one
10707 marker with the same ID (possible in UST, although unadvised
10708 precisely because it confuses tools). */
10710 static struct symtab_and_line
10711 update_static_tracepoint (struct breakpoint
*b
, struct symtab_and_line sal
)
10713 struct static_tracepoint_marker marker
;
10719 find_line_pc (sal
.symtab
, sal
.line
, &pc
);
10721 if (target_static_tracepoint_marker_at (pc
, &marker
))
10723 if (strcmp (b
->static_trace_marker_id
, marker
.str_id
) != 0)
10724 warning (_("static tracepoint %d changed probed marker from %s to %s"),
10726 b
->static_trace_marker_id
, marker
.str_id
);
10728 xfree (b
->static_trace_marker_id
);
10729 b
->static_trace_marker_id
= xstrdup (marker
.str_id
);
10730 release_static_tracepoint_marker (&marker
);
10735 /* Old marker wasn't found on target at lineno. Try looking it up
10737 if (!sal
.explicit_pc
10739 && sal
.symtab
!= NULL
10740 && b
->static_trace_marker_id
!= NULL
)
10742 VEC(static_tracepoint_marker_p
) *markers
;
10745 = target_static_tracepoint_markers_by_strid (b
->static_trace_marker_id
);
10747 if (!VEC_empty(static_tracepoint_marker_p
, markers
))
10749 struct symtab_and_line sal
;
10750 struct symbol
*sym
;
10751 struct static_tracepoint_marker
*marker
;
10753 marker
= VEC_index (static_tracepoint_marker_p
, markers
, 0);
10755 xfree (b
->static_trace_marker_id
);
10756 b
->static_trace_marker_id
= xstrdup (marker
->str_id
);
10758 warning (_("marker for static tracepoint %d (%s) not "
10759 "found at previous line number"),
10760 b
->number
, b
->static_trace_marker_id
);
10764 sal
.pc
= marker
->address
;
10766 sal
= find_pc_line (marker
->address
, 0);
10767 sym
= find_pc_sect_function (marker
->address
, NULL
);
10768 ui_out_text (uiout
, "Now in ");
10771 ui_out_field_string (uiout
, "func",
10772 SYMBOL_PRINT_NAME (sym
));
10773 ui_out_text (uiout
, " at ");
10775 ui_out_field_string (uiout
, "file", sal
.symtab
->filename
);
10776 ui_out_text (uiout
, ":");
10778 if (ui_out_is_mi_like_p (uiout
))
10780 char *fullname
= symtab_to_fullname (sal
.symtab
);
10783 ui_out_field_string (uiout
, "fullname", fullname
);
10786 ui_out_field_int (uiout
, "line", sal
.line
);
10787 ui_out_text (uiout
, "\n");
10789 b
->line_number
= sal
.line
;
10791 xfree (b
->source_file
);
10793 b
->source_file
= xstrdup (sal
.symtab
->filename
);
10795 b
->source_file
= NULL
;
10797 xfree (b
->addr_string
);
10798 b
->addr_string
= xstrprintf ("%s:%d",
10799 sal
.symtab
->filename
, b
->line_number
);
10801 /* Might be nice to check if function changed, and warn if
10804 release_static_tracepoint_marker (marker
);
10810 /* Create new breakpoint locations for B (a hardware or software breakpoint)
10811 based on SALS and SALS_END. If SALS_END.NELTS is not zero, then B is
10812 a ranged breakpoint. */
10815 update_breakpoint_locations (struct breakpoint
*b
,
10816 struct symtabs_and_lines sals
,
10817 struct symtabs_and_lines sals_end
)
10820 struct bp_location
*existing_locations
= b
->loc
;
10822 /* Ranged breakpoints have only one start location and one end location. */
10823 gdb_assert (sals_end
.nelts
== 0 || (sals
.nelts
== 1 && sals_end
.nelts
== 1));
10825 /* If there's no new locations, and all existing locations are
10826 pending, don't do anything. This optimizes the common case where
10827 all locations are in the same shared library, that was unloaded.
10828 We'd like to retain the location, so that when the library is
10829 loaded again, we don't loose the enabled/disabled status of the
10830 individual locations. */
10831 if (all_locations_are_pending (existing_locations
) && sals
.nelts
== 0)
10836 for (i
= 0; i
< sals
.nelts
; ++i
)
10838 struct bp_location
*new_loc
=
10839 add_location_to_breakpoint (b
, &(sals
.sals
[i
]));
10841 /* Reparse conditions, they might contain references to the
10843 if (b
->cond_string
!= NULL
)
10846 struct gdb_exception e
;
10848 s
= b
->cond_string
;
10849 TRY_CATCH (e
, RETURN_MASK_ERROR
)
10851 new_loc
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
),
10856 warning (_("failed to reevaluate condition "
10857 "for breakpoint %d: %s"),
10858 b
->number
, e
.message
);
10859 new_loc
->enabled
= 0;
10863 if (b
->source_file
!= NULL
)
10864 xfree (b
->source_file
);
10865 if (sals
.sals
[i
].symtab
== NULL
)
10866 b
->source_file
= NULL
;
10868 b
->source_file
= xstrdup (sals
.sals
[i
].symtab
->filename
);
10870 if (b
->line_number
== 0)
10871 b
->line_number
= sals
.sals
[i
].line
;
10873 if (sals_end
.nelts
)
10875 CORE_ADDR end
= find_breakpoint_range_end (sals_end
.sals
[0]);
10877 new_loc
->length
= end
- sals
.sals
[0].pc
+ 1;
10881 /* Update locations of permanent breakpoints. */
10882 if (b
->enable_state
== bp_permanent
)
10883 make_breakpoint_permanent (b
);
10885 /* If possible, carry over 'disable' status from existing
10888 struct bp_location
*e
= existing_locations
;
10889 /* If there are multiple breakpoints with the same function name,
10890 e.g. for inline functions, comparing function names won't work.
10891 Instead compare pc addresses; this is just a heuristic as things
10892 may have moved, but in practice it gives the correct answer
10893 often enough until a better solution is found. */
10894 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
10896 for (; e
; e
= e
->next
)
10898 if (!e
->enabled
&& e
->function_name
)
10900 struct bp_location
*l
= b
->loc
;
10901 if (have_ambiguous_names
)
10903 for (; l
; l
= l
->next
)
10904 if (breakpoint_locations_match (e
, l
))
10912 for (; l
; l
= l
->next
)
10913 if (l
->function_name
10914 && strcmp (e
->function_name
, l
->function_name
) == 0)
10924 update_global_location_list (1);
10927 /* Find the SaL locations corresponding to the given ADDR_STRING.
10928 On return, FOUND will be 1 if any SaL was found, zero otherwise. */
10930 static struct symtabs_and_lines
10931 addr_string_to_sals (struct breakpoint
*b
, char *addr_string
, int *found
)
10935 struct symtabs_and_lines sals
= {0};
10936 struct gdb_exception e
;
10939 marker_spec
= b
->type
== bp_static_tracepoint
&& is_marker_spec (s
);
10941 TRY_CATCH (e
, RETURN_MASK_ERROR
)
10945 sals
= decode_static_tracepoint_spec (&s
);
10946 if (sals
.nelts
> b
->static_trace_marker_id_idx
)
10948 sals
.sals
[0] = sals
.sals
[b
->static_trace_marker_id_idx
];
10952 error (_("marker %s not found"), b
->static_trace_marker_id
);
10955 sals
= decode_line_1 (&s
, 1, (struct symtab
*) NULL
, 0, NULL
);
10959 int not_found_and_ok
= 0;
10960 /* For pending breakpoints, it's expected that parsing will
10961 fail until the right shared library is loaded. User has
10962 already told to create pending breakpoints and don't need
10963 extra messages. If breakpoint is in bp_shlib_disabled
10964 state, then user already saw the message about that
10965 breakpoint being disabled, and don't want to see more
10967 if (e
.error
== NOT_FOUND_ERROR
10968 && (b
->condition_not_parsed
10969 || (b
->loc
&& b
->loc
->shlib_disabled
)
10970 || b
->enable_state
== bp_disabled
))
10971 not_found_and_ok
= 1;
10973 if (!not_found_and_ok
)
10975 /* We surely don't want to warn about the same breakpoint
10976 10 times. One solution, implemented here, is disable
10977 the breakpoint on error. Another solution would be to
10978 have separate 'warning emitted' flag. Since this
10979 happens only when a binary has changed, I don't know
10980 which approach is better. */
10981 b
->enable_state
= bp_disabled
;
10982 throw_exception (e
);
10986 if (e
.reason
== 0 || e
.error
!= NOT_FOUND_ERROR
)
10988 gdb_assert (sals
.nelts
== 1);
10990 resolve_sal_pc (&sals
.sals
[0]);
10991 if (b
->condition_not_parsed
&& s
&& s
[0])
10993 char *cond_string
= 0;
10997 find_condition_and_thread (s
, sals
.sals
[0].pc
,
10998 &cond_string
, &thread
, &task
);
11000 b
->cond_string
= cond_string
;
11001 b
->thread
= thread
;
11003 b
->condition_not_parsed
= 0;
11006 if (b
->type
== bp_static_tracepoint
&& !marker_spec
)
11007 sals
.sals
[0] = update_static_tracepoint (b
, sals
.sals
[0]);
11017 /* Reevaluate a hardware or software breakpoint and recreate its locations.
11018 This is necessary after symbols are read (e.g., an executable or DSO
11019 was loaded, or the inferior just started). */
11022 re_set_breakpoint (struct breakpoint
*b
)
11025 struct symtabs_and_lines sals
, sals_end
;
11026 struct symtabs_and_lines expanded
= {0};
11027 struct symtabs_and_lines expanded_end
= {0};
11028 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
11030 input_radix
= b
->input_radix
;
11031 save_current_space_and_thread ();
11032 switch_to_program_space_and_thread (b
->pspace
);
11033 set_language (b
->language
);
11035 sals
= addr_string_to_sals (b
, b
->addr_string
, &found
);
11038 make_cleanup (xfree
, sals
.sals
);
11039 expanded
= expand_line_sal_maybe (sals
.sals
[0]);
11042 if (b
->addr_string_range_end
)
11044 sals_end
= addr_string_to_sals (b
, b
->addr_string_range_end
, &found
);
11047 make_cleanup (xfree
, sals_end
.sals
);
11048 expanded_end
= expand_line_sal_maybe (sals_end
.sals
[0]);
11052 update_breakpoint_locations (b
, expanded
, expanded_end
);
11053 do_cleanups (cleanups
);
11056 /* Reset a breakpoint given it's struct breakpoint * BINT.
11057 The value we return ends up being the return value from catch_errors.
11058 Unused in this case. */
11061 breakpoint_re_set_one (void *bint
)
11063 /* Get past catch_errs. */
11064 struct breakpoint
*b
= (struct breakpoint
*) bint
;
11069 warning (_("attempted to reset apparently deleted breakpoint #%d?"),
11072 case bp_breakpoint
:
11073 case bp_hardware_breakpoint
:
11074 case bp_tracepoint
:
11075 case bp_fast_tracepoint
:
11076 case bp_static_tracepoint
:
11077 case bp_gnu_ifunc_resolver
:
11078 /* Do not attempt to re-set breakpoints disabled during startup. */
11079 if (b
->enable_state
== bp_startup_disabled
)
11082 if (b
->addr_string
== NULL
)
11084 /* Anything without a string can't be re-set. */
11085 delete_breakpoint (b
);
11089 re_set_breakpoint (b
);
11092 case bp_watchpoint
:
11093 case bp_hardware_watchpoint
:
11094 case bp_read_watchpoint
:
11095 case bp_access_watchpoint
:
11096 /* Watchpoint can be either on expression using entirely global
11097 variables, or it can be on local variables.
11099 Watchpoints of the first kind are never auto-deleted, and
11100 even persist across program restarts. Since they can use
11101 variables from shared libraries, we need to reparse
11102 expression as libraries are loaded and unloaded.
11104 Watchpoints on local variables can also change meaning as
11105 result of solib event. For example, if a watchpoint uses
11106 both a local and a global variables in expression, it's a
11107 local watchpoint, but unloading of a shared library will make
11108 the expression invalid. This is not a very common use case,
11109 but we still re-evaluate expression, to avoid surprises to
11112 Note that for local watchpoints, we re-evaluate it only if
11113 watchpoints frame id is still valid. If it's not, it means
11114 the watchpoint is out of scope and will be deleted soon. In
11115 fact, I'm not sure we'll ever be called in this case.
11117 If a local watchpoint's frame id is still valid, then
11118 b->exp_valid_block is likewise valid, and we can safely use it.
11120 Don't do anything about disabled watchpoints, since they will
11121 be reevaluated again when enabled. */
11122 update_watchpoint (b
, 1 /* reparse */);
11124 /* We needn't really do anything to reset these, since the mask
11125 that requests them is unaffected by e.g., new libraries being
11127 case bp_catchpoint
:
11131 printf_filtered (_("Deleting unknown breakpoint type %d\n"), b
->type
);
11133 /* Delete overlay event and longjmp master breakpoints; they will be
11134 reset later by breakpoint_re_set. */
11135 case bp_overlay_event
:
11136 case bp_longjmp_master
:
11137 case bp_std_terminate_master
:
11138 case bp_exception_master
:
11139 delete_breakpoint (b
);
11142 /* This breakpoint is special, it's set up when the inferior
11143 starts and we really don't want to touch it. */
11144 case bp_shlib_event
:
11146 /* Like bp_shlib_event, this breakpoint type is special.
11147 Once it is set up, we do not want to touch it. */
11148 case bp_thread_event
:
11150 /* Keep temporary breakpoints, which can be encountered when we
11151 step over a dlopen call and SOLIB_ADD is resetting the
11152 breakpoints. Otherwise these should have been blown away via
11153 the cleanup chain or by breakpoint_init_inferior when we
11154 rerun the executable. */
11157 case bp_watchpoint_scope
:
11158 case bp_call_dummy
:
11159 case bp_std_terminate
:
11160 case bp_step_resume
:
11162 case bp_longjmp_resume
:
11164 case bp_exception_resume
:
11166 case bp_gnu_ifunc_resolver_return
:
11173 /* Re-set all breakpoints after symbols have been re-loaded. */
11175 breakpoint_re_set (void)
11177 struct breakpoint
*b
, *b_tmp
;
11178 enum language save_language
;
11179 int save_input_radix
;
11180 struct cleanup
*old_chain
;
11182 save_language
= current_language
->la_language
;
11183 save_input_radix
= input_radix
;
11184 old_chain
= save_current_program_space ();
11186 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
11188 /* Format possible error msg. */
11189 char *message
= xstrprintf ("Error in re-setting breakpoint %d: ",
11191 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
11192 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
11193 do_cleanups (cleanups
);
11195 set_language (save_language
);
11196 input_radix
= save_input_radix
;
11198 jit_breakpoint_re_set ();
11200 do_cleanups (old_chain
);
11202 create_overlay_event_breakpoint ();
11203 create_longjmp_master_breakpoint ();
11204 create_std_terminate_master_breakpoint ();
11205 create_exception_master_breakpoint ();
11208 /* Reset the thread number of this breakpoint:
11210 - If the breakpoint is for all threads, leave it as-is.
11211 - Else, reset it to the current thread for inferior_ptid. */
11213 breakpoint_re_set_thread (struct breakpoint
*b
)
11215 if (b
->thread
!= -1)
11217 if (in_thread_list (inferior_ptid
))
11218 b
->thread
= pid_to_thread_id (inferior_ptid
);
11220 /* We're being called after following a fork. The new fork is
11221 selected as current, and unless this was a vfork will have a
11222 different program space from the original thread. Reset that
11224 b
->loc
->pspace
= current_program_space
;
11228 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
11229 If from_tty is nonzero, it prints a message to that effect,
11230 which ends with a period (no newline). */
11233 set_ignore_count (int bptnum
, int count
, int from_tty
)
11235 struct breakpoint
*b
;
11240 ALL_BREAKPOINTS (b
)
11241 if (b
->number
== bptnum
)
11243 if (is_tracepoint (b
))
11245 if (from_tty
&& count
!= 0)
11246 printf_filtered (_("Ignore count ignored for tracepoint %d."),
11251 b
->ignore_count
= count
;
11255 printf_filtered (_("Will stop next time "
11256 "breakpoint %d is reached."),
11258 else if (count
== 1)
11259 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
11262 printf_filtered (_("Will ignore next %d "
11263 "crossings of breakpoint %d."),
11266 breakpoints_changed ();
11267 observer_notify_breakpoint_modified (b
->number
);
11271 error (_("No breakpoint number %d."), bptnum
);
11274 /* Command to set ignore-count of breakpoint N to COUNT. */
11277 ignore_command (char *args
, int from_tty
)
11283 error_no_arg (_("a breakpoint number"));
11285 num
= get_number (&p
);
11287 error (_("bad breakpoint number: '%s'"), args
);
11289 error (_("Second argument (specified ignore-count) is missing."));
11291 set_ignore_count (num
,
11292 longest_to_int (value_as_long (parse_and_eval (p
))),
11295 printf_filtered ("\n");
11298 /* Call FUNCTION on each of the breakpoints
11299 whose numbers are given in ARGS. */
11302 map_breakpoint_numbers (char *args
, void (*function
) (struct breakpoint
*,
11307 struct breakpoint
*b
, *tmp
;
11309 struct get_number_or_range_state state
;
11312 error_no_arg (_("one or more breakpoint numbers"));
11314 init_number_or_range (&state
, args
);
11316 while (!state
.finished
)
11318 char *p
= state
.string
;
11322 num
= get_number_or_range (&state
);
11325 warning (_("bad breakpoint number at or near '%s'"), p
);
11329 ALL_BREAKPOINTS_SAFE (b
, tmp
)
11330 if (b
->number
== num
)
11332 struct breakpoint
*related_breakpoint
;
11335 related_breakpoint
= b
;
11338 struct breakpoint
*next_related_b
;
11340 /* FUNCTION can be also delete_breakpoint. */
11341 next_related_b
= related_breakpoint
->related_breakpoint
;
11342 function (related_breakpoint
, data
);
11344 /* For delete_breakpoint of the last entry of the ring we
11345 were traversing we would never get back to B. */
11346 if (next_related_b
== related_breakpoint
)
11348 related_breakpoint
= next_related_b
;
11350 while (related_breakpoint
!= b
);
11354 printf_unfiltered (_("No breakpoint number %d.\n"), num
);
11359 static struct bp_location
*
11360 find_location_by_number (char *number
)
11362 char *dot
= strchr (number
, '.');
11366 struct breakpoint
*b
;
11367 struct bp_location
*loc
;
11372 bp_num
= get_number (&p1
);
11374 error (_("Bad breakpoint number '%s'"), number
);
11376 ALL_BREAKPOINTS (b
)
11377 if (b
->number
== bp_num
)
11382 if (!b
|| b
->number
!= bp_num
)
11383 error (_("Bad breakpoint number '%s'"), number
);
11386 loc_num
= get_number (&p1
);
11388 error (_("Bad breakpoint location number '%s'"), number
);
11392 for (;loc_num
&& loc
; --loc_num
, loc
= loc
->next
)
11395 error (_("Bad breakpoint location number '%s'"), dot
+1);
11401 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
11402 If from_tty is nonzero, it prints a message to that effect,
11403 which ends with a period (no newline). */
11406 disable_breakpoint (struct breakpoint
*bpt
)
11408 /* Never disable a watchpoint scope breakpoint; we want to
11409 hit them when we leave scope so we can delete both the
11410 watchpoint and its scope breakpoint at that time. */
11411 if (bpt
->type
== bp_watchpoint_scope
)
11414 /* You can't disable permanent breakpoints. */
11415 if (bpt
->enable_state
== bp_permanent
)
11418 bpt
->enable_state
= bp_disabled
;
11420 update_global_location_list (0);
11422 observer_notify_breakpoint_modified (bpt
->number
);
11425 /* A callback for map_breakpoint_numbers that calls
11426 disable_breakpoint. */
11429 do_map_disable_breakpoint (struct breakpoint
*b
, void *ignore
)
11431 disable_breakpoint (b
);
11435 disable_command (char *args
, int from_tty
)
11437 struct breakpoint
*bpt
;
11440 ALL_BREAKPOINTS (bpt
)
11444 warning (_("attempted to disable apparently deleted breakpoint #%d?"),
11447 case bp_breakpoint
:
11448 case bp_tracepoint
:
11449 case bp_fast_tracepoint
:
11450 case bp_static_tracepoint
:
11451 case bp_catchpoint
:
11452 case bp_hardware_breakpoint
:
11453 case bp_watchpoint
:
11454 case bp_hardware_watchpoint
:
11455 case bp_read_watchpoint
:
11456 case bp_access_watchpoint
:
11457 disable_breakpoint (bpt
);
11462 else if (strchr (args
, '.'))
11464 struct bp_location
*loc
= find_location_by_number (args
);
11467 update_global_location_list (0);
11470 map_breakpoint_numbers (args
, do_map_disable_breakpoint
, NULL
);
11474 do_enable_breakpoint (struct breakpoint
*bpt
, enum bpdisp disposition
)
11476 int target_resources_ok
;
11478 if (bpt
->type
== bp_hardware_breakpoint
)
11481 i
= hw_breakpoint_used_count ();
11482 target_resources_ok
=
11483 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
11485 if (target_resources_ok
== 0)
11486 error (_("No hardware breakpoint support in the target."));
11487 else if (target_resources_ok
< 0)
11488 error (_("Hardware breakpoints used exceeds limit."));
11491 if (is_watchpoint (bpt
))
11493 struct gdb_exception e
;
11495 TRY_CATCH (e
, RETURN_MASK_ALL
)
11497 update_watchpoint (bpt
, 1 /* reparse */);
11501 exception_fprintf (gdb_stderr
, e
, _("Cannot enable watchpoint %d: "),
11507 if (bpt
->enable_state
!= bp_permanent
)
11508 bpt
->enable_state
= bp_enabled
;
11509 bpt
->disposition
= disposition
;
11510 update_global_location_list (1);
11511 breakpoints_changed ();
11513 observer_notify_breakpoint_modified (bpt
->number
);
11518 enable_breakpoint (struct breakpoint
*bpt
)
11520 do_enable_breakpoint (bpt
, bpt
->disposition
);
11523 /* A callback for map_breakpoint_numbers that calls
11524 enable_breakpoint. */
11527 do_map_enable_breakpoint (struct breakpoint
*b
, void *ignore
)
11529 enable_breakpoint (b
);
11532 /* The enable command enables the specified breakpoints (or all defined
11533 breakpoints) so they once again become (or continue to be) effective
11534 in stopping the inferior. */
11537 enable_command (char *args
, int from_tty
)
11539 struct breakpoint
*bpt
;
11542 ALL_BREAKPOINTS (bpt
)
11546 warning (_("attempted to enable apparently deleted breakpoint #%d?"),
11549 case bp_breakpoint
:
11550 case bp_tracepoint
:
11551 case bp_fast_tracepoint
:
11552 case bp_static_tracepoint
:
11553 case bp_catchpoint
:
11554 case bp_hardware_breakpoint
:
11555 case bp_watchpoint
:
11556 case bp_hardware_watchpoint
:
11557 case bp_read_watchpoint
:
11558 case bp_access_watchpoint
:
11559 enable_breakpoint (bpt
);
11564 else if (strchr (args
, '.'))
11566 struct bp_location
*loc
= find_location_by_number (args
);
11569 update_global_location_list (1);
11572 map_breakpoint_numbers (args
, do_map_enable_breakpoint
, NULL
);
11576 enable_once_breakpoint (struct breakpoint
*bpt
, void *ignore
)
11578 do_enable_breakpoint (bpt
, disp_disable
);
11582 enable_once_command (char *args
, int from_tty
)
11584 map_breakpoint_numbers (args
, enable_once_breakpoint
, NULL
);
11588 enable_delete_breakpoint (struct breakpoint
*bpt
, void *ignore
)
11590 do_enable_breakpoint (bpt
, disp_del
);
11594 enable_delete_command (char *args
, int from_tty
)
11596 map_breakpoint_numbers (args
, enable_delete_breakpoint
, NULL
);
11600 set_breakpoint_cmd (char *args
, int from_tty
)
11605 show_breakpoint_cmd (char *args
, int from_tty
)
11609 /* Invalidate last known value of any hardware watchpoint if
11610 the memory which that value represents has been written to by
11614 invalidate_bp_value_on_memory_change (CORE_ADDR addr
, int len
,
11615 const bfd_byte
*data
)
11617 struct breakpoint
*bp
;
11619 ALL_BREAKPOINTS (bp
)
11620 if (bp
->enable_state
== bp_enabled
11621 && bp
->type
== bp_hardware_watchpoint
11622 && bp
->val_valid
&& bp
->val
)
11624 struct bp_location
*loc
;
11626 for (loc
= bp
->loc
; loc
!= NULL
; loc
= loc
->next
)
11627 if (loc
->loc_type
== bp_loc_hardware_watchpoint
11628 && loc
->address
+ loc
->length
> addr
11629 && addr
+ len
> loc
->address
)
11631 value_free (bp
->val
);
11638 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
11640 struct symtabs_and_lines
11641 decode_line_spec_1 (char *string
, int funfirstline
)
11643 struct symtabs_and_lines sals
;
11646 error (_("Empty line specification."));
11647 if (default_breakpoint_valid
)
11648 sals
= decode_line_1 (&string
, funfirstline
,
11649 default_breakpoint_symtab
,
11650 default_breakpoint_line
,
11653 sals
= decode_line_1 (&string
, funfirstline
,
11654 (struct symtab
*) NULL
, 0, NULL
);
11656 error (_("Junk at end of line specification: %s"), string
);
11660 /* Create and insert a raw software breakpoint at PC. Return an
11661 identifier, which should be used to remove the breakpoint later.
11662 In general, places which call this should be using something on the
11663 breakpoint chain instead; this function should be eliminated
11667 deprecated_insert_raw_breakpoint (struct gdbarch
*gdbarch
,
11668 struct address_space
*aspace
, CORE_ADDR pc
)
11670 struct bp_target_info
*bp_tgt
;
11672 bp_tgt
= XZALLOC (struct bp_target_info
);
11674 bp_tgt
->placed_address_space
= aspace
;
11675 bp_tgt
->placed_address
= pc
;
11677 if (target_insert_breakpoint (gdbarch
, bp_tgt
) != 0)
11679 /* Could not insert the breakpoint. */
11687 /* Remove a breakpoint BP inserted by
11688 deprecated_insert_raw_breakpoint. */
11691 deprecated_remove_raw_breakpoint (struct gdbarch
*gdbarch
, void *bp
)
11693 struct bp_target_info
*bp_tgt
= bp
;
11696 ret
= target_remove_breakpoint (gdbarch
, bp_tgt
);
11702 /* One (or perhaps two) breakpoints used for software single
11705 static void *single_step_breakpoints
[2];
11706 static struct gdbarch
*single_step_gdbarch
[2];
11708 /* Create and insert a breakpoint for software single step. */
11711 insert_single_step_breakpoint (struct gdbarch
*gdbarch
,
11712 struct address_space
*aspace
,
11717 if (single_step_breakpoints
[0] == NULL
)
11719 bpt_p
= &single_step_breakpoints
[0];
11720 single_step_gdbarch
[0] = gdbarch
;
11724 gdb_assert (single_step_breakpoints
[1] == NULL
);
11725 bpt_p
= &single_step_breakpoints
[1];
11726 single_step_gdbarch
[1] = gdbarch
;
11729 /* NOTE drow/2006-04-11: A future improvement to this function would
11730 be to only create the breakpoints once, and actually put them on
11731 the breakpoint chain. That would let us use set_raw_breakpoint.
11732 We could adjust the addresses each time they were needed. Doing
11733 this requires corresponding changes elsewhere where single step
11734 breakpoints are handled, however. So, for now, we use this. */
11736 *bpt_p
= deprecated_insert_raw_breakpoint (gdbarch
, aspace
, next_pc
);
11737 if (*bpt_p
== NULL
)
11738 error (_("Could not insert single-step breakpoint at %s"),
11739 paddress (gdbarch
, next_pc
));
11742 /* Check if the breakpoints used for software single stepping
11743 were inserted or not. */
11746 single_step_breakpoints_inserted (void)
11748 return (single_step_breakpoints
[0] != NULL
11749 || single_step_breakpoints
[1] != NULL
);
11752 /* Remove and delete any breakpoints used for software single step. */
11755 remove_single_step_breakpoints (void)
11757 gdb_assert (single_step_breakpoints
[0] != NULL
);
11759 /* See insert_single_step_breakpoint for more about this deprecated
11761 deprecated_remove_raw_breakpoint (single_step_gdbarch
[0],
11762 single_step_breakpoints
[0]);
11763 single_step_gdbarch
[0] = NULL
;
11764 single_step_breakpoints
[0] = NULL
;
11766 if (single_step_breakpoints
[1] != NULL
)
11768 deprecated_remove_raw_breakpoint (single_step_gdbarch
[1],
11769 single_step_breakpoints
[1]);
11770 single_step_gdbarch
[1] = NULL
;
11771 single_step_breakpoints
[1] = NULL
;
11775 /* Delete software single step breakpoints without removing them from
11776 the inferior. This is intended to be used if the inferior's address
11777 space where they were inserted is already gone, e.g. after exit or
11781 cancel_single_step_breakpoints (void)
11785 for (i
= 0; i
< 2; i
++)
11786 if (single_step_breakpoints
[i
])
11788 xfree (single_step_breakpoints
[i
]);
11789 single_step_breakpoints
[i
] = NULL
;
11790 single_step_gdbarch
[i
] = NULL
;
11794 /* Detach software single-step breakpoints from INFERIOR_PTID without
11798 detach_single_step_breakpoints (void)
11802 for (i
= 0; i
< 2; i
++)
11803 if (single_step_breakpoints
[i
])
11804 target_remove_breakpoint (single_step_gdbarch
[i
],
11805 single_step_breakpoints
[i
]);
11808 /* Check whether a software single-step breakpoint is inserted at
11812 single_step_breakpoint_inserted_here_p (struct address_space
*aspace
,
11817 for (i
= 0; i
< 2; i
++)
11819 struct bp_target_info
*bp_tgt
= single_step_breakpoints
[i
];
11821 && breakpoint_address_match (bp_tgt
->placed_address_space
,
11822 bp_tgt
->placed_address
,
11830 /* Returns 0 if 'bp' is NOT a syscall catchpoint,
11831 non-zero otherwise. */
11833 is_syscall_catchpoint_enabled (struct breakpoint
*bp
)
11835 if (syscall_catchpoint_p (bp
)
11836 && bp
->enable_state
!= bp_disabled
11837 && bp
->enable_state
!= bp_call_disabled
)
11844 catch_syscall_enabled (void)
11846 struct inferior
*inf
= current_inferior ();
11848 return inf
->total_syscalls_count
!= 0;
11852 catching_syscall_number (int syscall_number
)
11854 struct breakpoint
*bp
;
11856 ALL_BREAKPOINTS (bp
)
11857 if (is_syscall_catchpoint_enabled (bp
))
11859 if (bp
->syscalls_to_be_caught
)
11863 VEC_iterate (int, bp
->syscalls_to_be_caught
, i
, iter
);
11865 if (syscall_number
== iter
)
11875 /* Complete syscall names. Used by "catch syscall". */
11877 catch_syscall_completer (struct cmd_list_element
*cmd
,
11878 char *text
, char *word
)
11880 const char **list
= get_syscall_names ();
11882 = (list
== NULL
) ? NULL
: complete_on_enum (list
, text
, word
);
11888 /* Tracepoint-specific operations. */
11890 /* Set tracepoint count to NUM. */
11892 set_tracepoint_count (int num
)
11894 tracepoint_count
= num
;
11895 set_internalvar_integer (lookup_internalvar ("tpnum"), num
);
11899 trace_command (char *arg
, int from_tty
)
11901 if (create_breakpoint (get_current_arch (),
11903 NULL
, 0, 1 /* parse arg */,
11905 bp_tracepoint
/* type_wanted */,
11906 0 /* Ignore count */,
11907 pending_break_support
,
11912 set_tracepoint_count (breakpoint_count
);
11916 ftrace_command (char *arg
, int from_tty
)
11918 if (create_breakpoint (get_current_arch (),
11920 NULL
, 0, 1 /* parse arg */,
11922 bp_fast_tracepoint
/* type_wanted */,
11923 0 /* Ignore count */,
11924 pending_break_support
,
11929 set_tracepoint_count (breakpoint_count
);
11932 /* strace command implementation. Creates a static tracepoint. */
11935 strace_command (char *arg
, int from_tty
)
11937 if (create_breakpoint (get_current_arch (),
11939 NULL
, 0, 1 /* parse arg */,
11941 bp_static_tracepoint
/* type_wanted */,
11942 0 /* Ignore count */,
11943 pending_break_support
,
11948 set_tracepoint_count (breakpoint_count
);
11951 /* Set up a fake reader function that gets command lines from a linked
11952 list that was acquired during tracepoint uploading. */
11954 static struct uploaded_tp
*this_utp
;
11955 static int next_cmd
;
11958 read_uploaded_action (void)
11962 VEC_iterate (char_ptr
, this_utp
->cmd_strings
, next_cmd
, rslt
);
11969 /* Given information about a tracepoint as recorded on a target (which
11970 can be either a live system or a trace file), attempt to create an
11971 equivalent GDB tracepoint. This is not a reliable process, since
11972 the target does not necessarily have all the information used when
11973 the tracepoint was originally defined. */
11975 struct breakpoint
*
11976 create_tracepoint_from_upload (struct uploaded_tp
*utp
)
11978 char *addr_str
, small_buf
[100];
11979 struct breakpoint
*tp
;
11981 if (utp
->at_string
)
11982 addr_str
= utp
->at_string
;
11985 /* In the absence of a source location, fall back to raw
11986 address. Since there is no way to confirm that the address
11987 means the same thing as when the trace was started, warn the
11989 warning (_("Uploaded tracepoint %d has no "
11990 "source location, using raw address"),
11992 sprintf (small_buf
, "*%s", hex_string (utp
->addr
));
11993 addr_str
= small_buf
;
11996 /* There's not much we can do with a sequence of bytecodes. */
11997 if (utp
->cond
&& !utp
->cond_string
)
11998 warning (_("Uploaded tracepoint %d condition "
11999 "has no source form, ignoring it"),
12002 if (!create_breakpoint (get_current_arch (),
12004 utp
->cond_string
, -1, 0 /* parse cond/thread */,
12006 utp
->type
/* type_wanted */,
12007 0 /* Ignore count */,
12008 pending_break_support
,
12011 utp
->enabled
/* enabled */,
12015 set_tracepoint_count (breakpoint_count
);
12017 /* Get the tracepoint we just created. */
12018 tp
= get_tracepoint (tracepoint_count
);
12019 gdb_assert (tp
!= NULL
);
12023 sprintf (small_buf
, "%d %d", utp
->pass
, tp
->number
);
12025 trace_pass_command (small_buf
, 0);
12028 /* If we have uploaded versions of the original commands, set up a
12029 special-purpose "reader" function and call the usual command line
12030 reader, then pass the result to the breakpoint command-setting
12032 if (!VEC_empty (char_ptr
, utp
->cmd_strings
))
12034 struct command_line
*cmd_list
;
12039 cmd_list
= read_command_lines_1 (read_uploaded_action
, 1, NULL
, NULL
);
12041 breakpoint_set_commands (tp
, cmd_list
);
12043 else if (!VEC_empty (char_ptr
, utp
->actions
)
12044 || !VEC_empty (char_ptr
, utp
->step_actions
))
12045 warning (_("Uploaded tracepoint %d actions "
12046 "have no source form, ignoring them"),
12052 /* Print information on tracepoint number TPNUM_EXP, or all if
12056 tracepoints_info (char *args
, int from_tty
)
12060 num_printed
= breakpoint_1 (args
, 0, is_tracepoint
);
12062 if (num_printed
== 0)
12064 if (args
== NULL
|| *args
== '\0')
12065 ui_out_message (uiout
, 0, "No tracepoints.\n");
12067 ui_out_message (uiout
, 0, "No tracepoint matching '%s'.\n", args
);
12070 default_collect_info ();
12073 /* The 'enable trace' command enables tracepoints.
12074 Not supported by all targets. */
12076 enable_trace_command (char *args
, int from_tty
)
12078 enable_command (args
, from_tty
);
12081 /* The 'disable trace' command disables tracepoints.
12082 Not supported by all targets. */
12084 disable_trace_command (char *args
, int from_tty
)
12086 disable_command (args
, from_tty
);
12089 /* Remove a tracepoint (or all if no argument). */
12091 delete_trace_command (char *arg
, int from_tty
)
12093 struct breakpoint
*b
, *b_tmp
;
12099 int breaks_to_delete
= 0;
12101 /* Delete all breakpoints if no argument.
12102 Do not delete internal or call-dummy breakpoints, these
12103 have to be deleted with an explicit breakpoint number
12105 ALL_TRACEPOINTS (b
)
12107 if (b
->number
>= 0)
12109 breaks_to_delete
= 1;
12114 /* Ask user only if there are some breakpoints to delete. */
12116 || (breaks_to_delete
&& query (_("Delete all tracepoints? "))))
12118 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
12120 if (is_tracepoint (b
)
12122 delete_breakpoint (b
);
12127 map_breakpoint_numbers (arg
, do_delete_breakpoint
, NULL
);
12130 /* Helper function for trace_pass_command. */
12133 trace_pass_set_count (struct breakpoint
*bp
, int count
, int from_tty
)
12135 bp
->pass_count
= count
;
12136 observer_notify_tracepoint_modified (bp
->number
);
12138 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
12139 bp
->number
, count
);
12142 /* Set passcount for tracepoint.
12144 First command argument is passcount, second is tracepoint number.
12145 If tracepoint number omitted, apply to most recently defined.
12146 Also accepts special argument "all". */
12149 trace_pass_command (char *args
, int from_tty
)
12151 struct breakpoint
*t1
;
12152 unsigned int count
;
12154 if (args
== 0 || *args
== 0)
12155 error (_("passcount command requires an "
12156 "argument (count + optional TP num)"));
12158 count
= strtoul (args
, &args
, 10); /* Count comes first, then TP num. */
12160 while (*args
&& isspace ((int) *args
))
12163 if (*args
&& strncasecmp (args
, "all", 3) == 0)
12165 args
+= 3; /* Skip special argument "all". */
12167 error (_("Junk at end of arguments."));
12169 ALL_TRACEPOINTS (t1
)
12171 trace_pass_set_count (t1
, count
, from_tty
);
12174 else if (*args
== '\0')
12176 t1
= get_tracepoint_by_number (&args
, NULL
, 1);
12178 trace_pass_set_count (t1
, count
, from_tty
);
12182 struct get_number_or_range_state state
;
12184 init_number_or_range (&state
, args
);
12185 while (!state
.finished
)
12187 t1
= get_tracepoint_by_number (&args
, &state
, 1);
12189 trace_pass_set_count (t1
, count
, from_tty
);
12194 struct breakpoint
*
12195 get_tracepoint (int num
)
12197 struct breakpoint
*t
;
12199 ALL_TRACEPOINTS (t
)
12200 if (t
->number
== num
)
12206 /* Find the tracepoint with the given target-side number (which may be
12207 different from the tracepoint number after disconnecting and
12210 struct breakpoint
*
12211 get_tracepoint_by_number_on_target (int num
)
12213 struct breakpoint
*t
;
12215 ALL_TRACEPOINTS (t
)
12216 if (t
->number_on_target
== num
)
12222 /* Utility: parse a tracepoint number and look it up in the list.
12223 If STATE is not NULL, use, get_number_or_range_state and ignore ARG.
12224 If OPTIONAL_P is true, then if the argument is missing, the most
12225 recent tracepoint (tracepoint_count) is returned. */
12226 struct breakpoint
*
12227 get_tracepoint_by_number (char **arg
,
12228 struct get_number_or_range_state
*state
,
12231 extern int tracepoint_count
;
12232 struct breakpoint
*t
;
12234 char *instring
= arg
== NULL
? NULL
: *arg
;
12238 gdb_assert (!state
->finished
);
12239 tpnum
= get_number_or_range (state
);
12241 else if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
12244 tpnum
= tracepoint_count
;
12246 error_no_arg (_("tracepoint number"));
12249 tpnum
= get_number (arg
);
12253 if (instring
&& *instring
)
12254 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
12257 printf_filtered (_("Tracepoint argument missing "
12258 "and no previous tracepoint\n"));
12262 ALL_TRACEPOINTS (t
)
12263 if (t
->number
== tpnum
)
12268 printf_unfiltered ("No tracepoint number %d.\n", tpnum
);
12272 /* Save information on user settable breakpoints (watchpoints, etc) to
12273 a new script file named FILENAME. If FILTER is non-NULL, call it
12274 on each breakpoint and only include the ones for which it returns
12278 save_breakpoints (char *filename
, int from_tty
,
12279 int (*filter
) (const struct breakpoint
*))
12281 struct breakpoint
*tp
;
12284 struct cleanup
*cleanup
;
12285 struct ui_file
*fp
;
12286 int extra_trace_bits
= 0;
12288 if (filename
== 0 || *filename
== 0)
12289 error (_("Argument required (file name in which to save)"));
12291 /* See if we have anything to save. */
12292 ALL_BREAKPOINTS (tp
)
12294 /* Skip internal and momentary breakpoints. */
12295 if (!user_breakpoint_p (tp
))
12298 /* If we have a filter, only save the breakpoints it accepts. */
12299 if (filter
&& !filter (tp
))
12304 if (is_tracepoint (tp
))
12306 extra_trace_bits
= 1;
12308 /* We can stop searching. */
12315 warning (_("Nothing to save."));
12319 pathname
= tilde_expand (filename
);
12320 cleanup
= make_cleanup (xfree
, pathname
);
12321 fp
= gdb_fopen (pathname
, "w");
12323 error (_("Unable to open file '%s' for saving (%s)"),
12324 filename
, safe_strerror (errno
));
12325 make_cleanup_ui_file_delete (fp
);
12327 if (extra_trace_bits
)
12328 save_trace_state_variables (fp
);
12330 ALL_BREAKPOINTS (tp
)
12332 /* Skip internal and momentary breakpoints. */
12333 if (!user_breakpoint_p (tp
))
12336 /* If we have a filter, only save the breakpoints it accepts. */
12337 if (filter
&& !filter (tp
))
12340 if (tp
->ops
!= NULL
)
12341 (tp
->ops
->print_recreate
) (tp
, fp
);
12344 if (tp
->type
== bp_fast_tracepoint
)
12345 fprintf_unfiltered (fp
, "ftrace");
12346 if (tp
->type
== bp_static_tracepoint
)
12347 fprintf_unfiltered (fp
, "strace");
12348 else if (tp
->type
== bp_tracepoint
)
12349 fprintf_unfiltered (fp
, "trace");
12350 else if (tp
->type
== bp_breakpoint
&& tp
->disposition
== disp_del
)
12351 fprintf_unfiltered (fp
, "tbreak");
12352 else if (tp
->type
== bp_breakpoint
)
12353 fprintf_unfiltered (fp
, "break");
12354 else if (tp
->type
== bp_hardware_breakpoint
12355 && tp
->disposition
== disp_del
)
12356 fprintf_unfiltered (fp
, "thbreak");
12357 else if (tp
->type
== bp_hardware_breakpoint
)
12358 fprintf_unfiltered (fp
, "hbreak");
12359 else if (tp
->type
== bp_watchpoint
)
12360 fprintf_unfiltered (fp
, "watch");
12361 else if (tp
->type
== bp_hardware_watchpoint
)
12362 fprintf_unfiltered (fp
, "watch");
12363 else if (tp
->type
== bp_read_watchpoint
)
12364 fprintf_unfiltered (fp
, "rwatch");
12365 else if (tp
->type
== bp_access_watchpoint
)
12366 fprintf_unfiltered (fp
, "awatch");
12368 internal_error (__FILE__
, __LINE__
,
12369 _("unhandled breakpoint type %d"), (int) tp
->type
);
12371 if (tp
->exp_string
)
12372 fprintf_unfiltered (fp
, " %s", tp
->exp_string
);
12373 else if (tp
->addr_string
)
12374 fprintf_unfiltered (fp
, " %s", tp
->addr_string
);
12379 sprintf_vma (tmp
, tp
->loc
->address
);
12380 fprintf_unfiltered (fp
, " *0x%s", tmp
);
12384 if (tp
->thread
!= -1)
12385 fprintf_unfiltered (fp
, " thread %d", tp
->thread
);
12388 fprintf_unfiltered (fp
, " task %d", tp
->task
);
12390 fprintf_unfiltered (fp
, "\n");
12392 /* Note, we can't rely on tp->number for anything, as we can't
12393 assume the recreated breakpoint numbers will match. Use $bpnum
12396 if (tp
->cond_string
)
12397 fprintf_unfiltered (fp
, " condition $bpnum %s\n", tp
->cond_string
);
12399 if (tp
->ignore_count
)
12400 fprintf_unfiltered (fp
, " ignore $bpnum %d\n", tp
->ignore_count
);
12402 if (tp
->pass_count
)
12403 fprintf_unfiltered (fp
, " passcount %d\n", tp
->pass_count
);
12407 volatile struct gdb_exception ex
;
12409 fprintf_unfiltered (fp
, " commands\n");
12411 ui_out_redirect (uiout
, fp
);
12412 TRY_CATCH (ex
, RETURN_MASK_ALL
)
12414 print_command_lines (uiout
, tp
->commands
->commands
, 2);
12416 ui_out_redirect (uiout
, NULL
);
12419 throw_exception (ex
);
12421 fprintf_unfiltered (fp
, " end\n");
12424 if (tp
->enable_state
== bp_disabled
)
12425 fprintf_unfiltered (fp
, "disable\n");
12427 /* If this is a multi-location breakpoint, check if the locations
12428 should be individually disabled. Watchpoint locations are
12429 special, and not user visible. */
12430 if (!is_watchpoint (tp
) && tp
->loc
&& tp
->loc
->next
)
12432 struct bp_location
*loc
;
12435 for (loc
= tp
->loc
; loc
!= NULL
; loc
= loc
->next
, n
++)
12437 fprintf_unfiltered (fp
, "disable $bpnum.%d\n", n
);
12441 if (extra_trace_bits
&& *default_collect
)
12442 fprintf_unfiltered (fp
, "set default-collect %s\n", default_collect
);
12444 do_cleanups (cleanup
);
12446 printf_filtered (_("Saved to file '%s'.\n"), filename
);
12449 /* The `save breakpoints' command. */
12452 save_breakpoints_command (char *args
, int from_tty
)
12454 save_breakpoints (args
, from_tty
, NULL
);
12457 /* The `save tracepoints' command. */
12460 save_tracepoints_command (char *args
, int from_tty
)
12462 save_breakpoints (args
, from_tty
, is_tracepoint
);
12465 /* Create a vector of all tracepoints. */
12467 VEC(breakpoint_p
) *
12468 all_tracepoints (void)
12470 VEC(breakpoint_p
) *tp_vec
= 0;
12471 struct breakpoint
*tp
;
12473 ALL_TRACEPOINTS (tp
)
12475 VEC_safe_push (breakpoint_p
, tp_vec
, tp
);
12482 /* This help string is used for the break, hbreak, tbreak and thbreak
12483 commands. It is defined as a macro to prevent duplication.
12484 COMMAND should be a string constant containing the name of the
12486 #define BREAK_ARGS_HELP(command) \
12487 command" [LOCATION] [thread THREADNUM] [if CONDITION]\n\
12488 LOCATION may be a line number, function name, or \"*\" and an address.\n\
12489 If a line number is specified, break at start of code for that line.\n\
12490 If a function is specified, break at start of code for that function.\n\
12491 If an address is specified, break at that exact address.\n\
12492 With no LOCATION, uses current execution address of the selected\n\
12493 stack frame. This is useful for breaking on return to a stack frame.\n\
12495 THREADNUM is the number from \"info threads\".\n\
12496 CONDITION is a boolean expression.\n\
12498 Multiple breakpoints at one place are permitted, and useful if their\n\
12499 conditions are different.\n\
12501 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
12503 /* List of subcommands for "catch". */
12504 static struct cmd_list_element
*catch_cmdlist
;
12506 /* List of subcommands for "tcatch". */
12507 static struct cmd_list_element
*tcatch_cmdlist
;
12509 /* Like add_cmd, but add the command to both the "catch" and "tcatch"
12510 lists, and pass some additional user data to the command function. */
12512 add_catch_command (char *name
, char *docstring
,
12513 void (*sfunc
) (char *args
, int from_tty
,
12514 struct cmd_list_element
*command
),
12515 char **(*completer
) (struct cmd_list_element
*cmd
,
12516 char *text
, char *word
),
12517 void *user_data_catch
,
12518 void *user_data_tcatch
)
12520 struct cmd_list_element
*command
;
12522 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
12524 set_cmd_sfunc (command
, sfunc
);
12525 set_cmd_context (command
, user_data_catch
);
12526 set_cmd_completer (command
, completer
);
12528 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
12530 set_cmd_sfunc (command
, sfunc
);
12531 set_cmd_context (command
, user_data_tcatch
);
12532 set_cmd_completer (command
, completer
);
12536 clear_syscall_counts (struct inferior
*inf
)
12538 inf
->total_syscalls_count
= 0;
12539 inf
->any_syscall_count
= 0;
12540 VEC_free (int, inf
->syscalls_counts
);
12544 save_command (char *arg
, int from_tty
)
12546 printf_unfiltered (_("\"save\" must be followed by "
12547 "the name of a save subcommand.\n"));
12548 help_list (save_cmdlist
, "save ", -1, gdb_stdout
);
12551 struct breakpoint
*
12552 iterate_over_breakpoints (int (*callback
) (struct breakpoint
*, void *),
12555 struct breakpoint
*b
, *b_tmp
;
12557 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
12559 if ((*callback
) (b
, data
))
12567 _initialize_breakpoint (void)
12569 struct cmd_list_element
*c
;
12571 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
12572 observer_attach_inferior_exit (clear_syscall_counts
);
12573 observer_attach_memory_changed (invalidate_bp_value_on_memory_change
);
12575 breakpoint_objfile_key
= register_objfile_data ();
12577 breakpoint_chain
= 0;
12578 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
12579 before a breakpoint is set. */
12580 breakpoint_count
= 0;
12582 tracepoint_count
= 0;
12584 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
12585 Set ignore-count of breakpoint number N to COUNT.\n\
12586 Usage is `ignore N COUNT'."));
12588 add_com_alias ("bc", "ignore", class_breakpoint
, 1);
12590 add_com ("commands", class_breakpoint
, commands_command
, _("\
12591 Set commands to be executed when a breakpoint is hit.\n\
12592 Give breakpoint number as argument after \"commands\".\n\
12593 With no argument, the targeted breakpoint is the last one set.\n\
12594 The commands themselves follow starting on the next line.\n\
12595 Type a line containing \"end\" to indicate the end of them.\n\
12596 Give \"silent\" as the first line to make the breakpoint silent;\n\
12597 then no output is printed when it is hit, except what the commands print."));
12599 add_com ("condition", class_breakpoint
, condition_command
, _("\
12600 Specify breakpoint number N to break only if COND is true.\n\
12601 Usage is `condition N COND', where N is an integer and COND is an\n\
12602 expression to be evaluated whenever breakpoint N is reached."));
12604 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
12605 Set a temporary breakpoint.\n\
12606 Like \"break\" except the breakpoint is only temporary,\n\
12607 so it will be deleted when hit. Equivalent to \"break\" followed\n\
12608 by using \"enable delete\" on the breakpoint number.\n\
12610 BREAK_ARGS_HELP ("tbreak")));
12611 set_cmd_completer (c
, location_completer
);
12613 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
12614 Set a hardware assisted breakpoint.\n\
12615 Like \"break\" except the breakpoint requires hardware support,\n\
12616 some target hardware may not have this support.\n\
12618 BREAK_ARGS_HELP ("hbreak")));
12619 set_cmd_completer (c
, location_completer
);
12621 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
12622 Set a temporary hardware assisted breakpoint.\n\
12623 Like \"hbreak\" except the breakpoint is only temporary,\n\
12624 so it will be deleted when hit.\n\
12626 BREAK_ARGS_HELP ("thbreak")));
12627 set_cmd_completer (c
, location_completer
);
12629 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
12630 Enable some breakpoints.\n\
12631 Give breakpoint numbers (separated by spaces) as arguments.\n\
12632 With no subcommand, breakpoints are enabled until you command otherwise.\n\
12633 This is used to cancel the effect of the \"disable\" command.\n\
12634 With a subcommand you can enable temporarily."),
12635 &enablelist
, "enable ", 1, &cmdlist
);
12637 add_com ("ab", class_breakpoint
, enable_command
, _("\
12638 Enable some breakpoints.\n\
12639 Give breakpoint numbers (separated by spaces) as arguments.\n\
12640 With no subcommand, breakpoints are enabled until you command otherwise.\n\
12641 This is used to cancel the effect of the \"disable\" command.\n\
12642 With a subcommand you can enable temporarily."));
12644 add_com_alias ("en", "enable", class_breakpoint
, 1);
12646 add_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
12647 Enable some breakpoints.\n\
12648 Give breakpoint numbers (separated by spaces) as arguments.\n\
12649 This is used to cancel the effect of the \"disable\" command.\n\
12650 May be abbreviated to simply \"enable\".\n"),
12651 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
12653 add_cmd ("once", no_class
, enable_once_command
, _("\
12654 Enable breakpoints for one hit. Give breakpoint numbers.\n\
12655 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
12658 add_cmd ("delete", no_class
, enable_delete_command
, _("\
12659 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
12660 If a breakpoint is hit while enabled in this fashion, it is deleted."),
12663 add_cmd ("delete", no_class
, enable_delete_command
, _("\
12664 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
12665 If a breakpoint is hit while enabled in this fashion, it is deleted."),
12668 add_cmd ("once", no_class
, enable_once_command
, _("\
12669 Enable breakpoints for one hit. Give breakpoint numbers.\n\
12670 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
12673 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
12674 Disable some breakpoints.\n\
12675 Arguments are breakpoint numbers with spaces in between.\n\
12676 To disable all breakpoints, give no argument.\n\
12677 A disabled breakpoint is not forgotten, but has no effect until reenabled."),
12678 &disablelist
, "disable ", 1, &cmdlist
);
12679 add_com_alias ("dis", "disable", class_breakpoint
, 1);
12680 add_com_alias ("disa", "disable", class_breakpoint
, 1);
12682 add_com ("sb", class_breakpoint
, disable_command
, _("\
12683 Disable some breakpoints.\n\
12684 Arguments are breakpoint numbers with spaces in between.\n\
12685 To disable all breakpoints, give no argument.\n\
12686 A disabled breakpoint is not forgotten, but has no effect until reenabled."));
12688 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
12689 Disable some breakpoints.\n\
12690 Arguments are breakpoint numbers with spaces in between.\n\
12691 To disable all breakpoints, give no argument.\n\
12692 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
12693 This command may be abbreviated \"disable\"."),
12696 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
12697 Delete some breakpoints or auto-display expressions.\n\
12698 Arguments are breakpoint numbers with spaces in between.\n\
12699 To delete all breakpoints, give no argument.\n\
12701 Also a prefix command for deletion of other GDB objects.\n\
12702 The \"unset\" command is also an alias for \"delete\"."),
12703 &deletelist
, "delete ", 1, &cmdlist
);
12704 add_com_alias ("d", "delete", class_breakpoint
, 1);
12705 add_com_alias ("del", "delete", class_breakpoint
, 1);
12707 add_com ("db", class_breakpoint
, delete_command
, _("\
12708 Delete some breakpoints.\n\
12709 Arguments are breakpoint numbers with spaces in between.\n\
12710 To delete all breakpoints, give no argument.\n"));
12712 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
12713 Delete some breakpoints or auto-display expressions.\n\
12714 Arguments are breakpoint numbers with spaces in between.\n\
12715 To delete all breakpoints, give no argument.\n\
12716 This command may be abbreviated \"delete\"."),
12719 add_com ("clear", class_breakpoint
, clear_command
, _("\
12720 Clear breakpoint at specified line or function.\n\
12721 Argument may be line number, function name, or \"*\" and an address.\n\
12722 If line number is specified, all breakpoints in that line are cleared.\n\
12723 If function is specified, breakpoints at beginning of function are cleared.\n\
12724 If an address is specified, breakpoints at that address are cleared.\n\
12726 With no argument, clears all breakpoints in the line that the selected frame\n\
12727 is executing in.\n\
12729 See also the \"delete\" command which clears breakpoints by number."));
12730 add_com_alias ("cl", "clear", class_breakpoint
, 1);
12732 c
= add_com ("break", class_breakpoint
, break_command
, _("\
12733 Set breakpoint at specified line or function.\n"
12734 BREAK_ARGS_HELP ("break")));
12735 set_cmd_completer (c
, location_completer
);
12737 add_com_alias ("b", "break", class_run
, 1);
12738 add_com_alias ("br", "break", class_run
, 1);
12739 add_com_alias ("bre", "break", class_run
, 1);
12740 add_com_alias ("brea", "break", class_run
, 1);
12743 add_com_alias ("ba", "break", class_breakpoint
, 1);
12747 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
12748 Break in function/address or break at a line in the current file."),
12749 &stoplist
, "stop ", 1, &cmdlist
);
12750 add_cmd ("in", class_breakpoint
, stopin_command
,
12751 _("Break in function or address."), &stoplist
);
12752 add_cmd ("at", class_breakpoint
, stopat_command
,
12753 _("Break at a line in the current file."), &stoplist
);
12754 add_com ("status", class_info
, breakpoints_info
, _("\
12755 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
12756 The \"Type\" column indicates one of:\n\
12757 \tbreakpoint - normal breakpoint\n\
12758 \twatchpoint - watchpoint\n\
12759 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
12760 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
12761 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
12762 address and file/line number respectively.\n\
12764 Convenience variable \"$_\" and default examine address for \"x\"\n\
12765 are set to the address of the last breakpoint listed unless the command\n\
12766 is prefixed with \"server \".\n\n\
12767 Convenience variable \"$bpnum\" contains the number of the last\n\
12768 breakpoint set."));
12771 add_info ("breakpoints", breakpoints_info
, _("\
12772 Status of specified breakpoints (all user-settable breakpoints if no argument).\n\
12773 The \"Type\" column indicates one of:\n\
12774 \tbreakpoint - normal breakpoint\n\
12775 \twatchpoint - watchpoint\n\
12776 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
12777 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
12778 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
12779 address and file/line number respectively.\n\
12781 Convenience variable \"$_\" and default examine address for \"x\"\n\
12782 are set to the address of the last breakpoint listed unless the command\n\
12783 is prefixed with \"server \".\n\n\
12784 Convenience variable \"$bpnum\" contains the number of the last\n\
12785 breakpoint set."));
12787 add_info_alias ("b", "breakpoints", 1);
12790 add_com ("lb", class_breakpoint
, breakpoints_info
, _("\
12791 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
12792 The \"Type\" column indicates one of:\n\
12793 \tbreakpoint - normal breakpoint\n\
12794 \twatchpoint - watchpoint\n\
12795 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
12796 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
12797 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
12798 address and file/line number respectively.\n\
12800 Convenience variable \"$_\" and default examine address for \"x\"\n\
12801 are set to the address of the last breakpoint listed unless the command\n\
12802 is prefixed with \"server \".\n\n\
12803 Convenience variable \"$bpnum\" contains the number of the last\n\
12804 breakpoint set."));
12806 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
12807 Status of all breakpoints, or breakpoint number NUMBER.\n\
12808 The \"Type\" column indicates one of:\n\
12809 \tbreakpoint - normal breakpoint\n\
12810 \twatchpoint - watchpoint\n\
12811 \tlongjmp - internal breakpoint used to step through longjmp()\n\
12812 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
12813 \tuntil - internal breakpoint used by the \"until\" command\n\
12814 \tfinish - internal breakpoint used by the \"finish\" command\n\
12815 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
12816 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
12817 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
12818 address and file/line number respectively.\n\
12820 Convenience variable \"$_\" and default examine address for \"x\"\n\
12821 are set to the address of the last breakpoint listed unless the command\n\
12822 is prefixed with \"server \".\n\n\
12823 Convenience variable \"$bpnum\" contains the number of the last\n\
12825 &maintenanceinfolist
);
12827 add_prefix_cmd ("catch", class_breakpoint
, catch_command
, _("\
12828 Set catchpoints to catch events."),
12829 &catch_cmdlist
, "catch ",
12830 0/*allow-unknown*/, &cmdlist
);
12832 add_prefix_cmd ("tcatch", class_breakpoint
, tcatch_command
, _("\
12833 Set temporary catchpoints to catch events."),
12834 &tcatch_cmdlist
, "tcatch ",
12835 0/*allow-unknown*/, &cmdlist
);
12837 /* Add catch and tcatch sub-commands. */
12838 add_catch_command ("catch", _("\
12839 Catch an exception, when caught.\n\
12840 With an argument, catch only exceptions with the given name."),
12841 catch_catch_command
,
12845 add_catch_command ("throw", _("\
12846 Catch an exception, when thrown.\n\
12847 With an argument, catch only exceptions with the given name."),
12848 catch_throw_command
,
12852 add_catch_command ("fork", _("Catch calls to fork."),
12853 catch_fork_command_1
,
12855 (void *) (uintptr_t) catch_fork_permanent
,
12856 (void *) (uintptr_t) catch_fork_temporary
);
12857 add_catch_command ("vfork", _("Catch calls to vfork."),
12858 catch_fork_command_1
,
12860 (void *) (uintptr_t) catch_vfork_permanent
,
12861 (void *) (uintptr_t) catch_vfork_temporary
);
12862 add_catch_command ("exec", _("Catch calls to exec."),
12863 catch_exec_command_1
,
12867 add_catch_command ("syscall", _("\
12868 Catch system calls by their names and/or numbers.\n\
12869 Arguments say which system calls to catch. If no arguments\n\
12870 are given, every system call will be caught.\n\
12871 Arguments, if given, should be one or more system call names\n\
12872 (if your system supports that), or system call numbers."),
12873 catch_syscall_command_1
,
12874 catch_syscall_completer
,
12877 add_catch_command ("exception", _("\
12878 Catch Ada exceptions, when raised.\n\
12879 With an argument, catch only exceptions with the given name."),
12880 catch_ada_exception_command
,
12884 add_catch_command ("assert", _("\
12885 Catch failed Ada assertions, when raised.\n\
12886 With an argument, catch only exceptions with the given name."),
12887 catch_assert_command
,
12892 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
12893 Set a watchpoint for an expression.\n\
12894 Usage: watch [-l|-location] EXPRESSION\n\
12895 A watchpoint stops execution of your program whenever the value of\n\
12896 an expression changes.\n\
12897 If -l or -location is given, this evaluates EXPRESSION and watches\n\
12898 the memory to which it refers."));
12899 set_cmd_completer (c
, expression_completer
);
12901 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
12902 Set a read watchpoint for an expression.\n\
12903 Usage: rwatch [-l|-location] EXPRESSION\n\
12904 A watchpoint stops execution of your program whenever the value of\n\
12905 an expression is read.\n\
12906 If -l or -location is given, this evaluates EXPRESSION and watches\n\
12907 the memory to which it refers."));
12908 set_cmd_completer (c
, expression_completer
);
12910 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
12911 Set a watchpoint for an expression.\n\
12912 Usage: awatch [-l|-location] EXPRESSION\n\
12913 A watchpoint stops execution of your program whenever the value of\n\
12914 an expression is either read or written.\n\
12915 If -l or -location is given, this evaluates EXPRESSION and watches\n\
12916 the memory to which it refers."));
12917 set_cmd_completer (c
, expression_completer
);
12919 add_info ("watchpoints", watchpoints_info
, _("\
12920 Status of specified watchpoints (all watchpoints if no argument)."));
12922 /* XXX: cagney/2005-02-23: This should be a boolean, and should
12923 respond to changes - contrary to the description. */
12924 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
12925 &can_use_hw_watchpoints
, _("\
12926 Set debugger's willingness to use watchpoint hardware."), _("\
12927 Show debugger's willingness to use watchpoint hardware."), _("\
12928 If zero, gdb will not use hardware for new watchpoints, even if\n\
12929 such is available. (However, any hardware watchpoints that were\n\
12930 created before setting this to nonzero, will continue to use watchpoint\n\
12933 show_can_use_hw_watchpoints
,
12934 &setlist
, &showlist
);
12936 can_use_hw_watchpoints
= 1;
12938 /* Tracepoint manipulation commands. */
12940 c
= add_com ("trace", class_breakpoint
, trace_command
, _("\
12941 Set a tracepoint at specified line or function.\n\
12943 BREAK_ARGS_HELP ("trace") "\n\
12944 Do \"help tracepoints\" for info on other tracepoint commands."));
12945 set_cmd_completer (c
, location_completer
);
12947 add_com_alias ("tp", "trace", class_alias
, 0);
12948 add_com_alias ("tr", "trace", class_alias
, 1);
12949 add_com_alias ("tra", "trace", class_alias
, 1);
12950 add_com_alias ("trac", "trace", class_alias
, 1);
12952 c
= add_com ("ftrace", class_breakpoint
, ftrace_command
, _("\
12953 Set a fast tracepoint at specified line or function.\n\
12955 BREAK_ARGS_HELP ("ftrace") "\n\
12956 Do \"help tracepoints\" for info on other tracepoint commands."));
12957 set_cmd_completer (c
, location_completer
);
12959 c
= add_com ("strace", class_breakpoint
, strace_command
, _("\
12960 Set a static tracepoint at specified line, function or marker.\n\
12962 strace [LOCATION] [if CONDITION]\n\
12963 LOCATION may be a line number, function name, \"*\" and an address,\n\
12964 or -m MARKER_ID.\n\
12965 If a line number is specified, probe the marker at start of code\n\
12966 for that line. If a function is specified, probe the marker at start\n\
12967 of code for that function. If an address is specified, probe the marker\n\
12968 at that exact address. If a marker id is specified, probe the marker\n\
12969 with that name. With no LOCATION, uses current execution address of\n\
12970 the selected stack frame.\n\
12971 Static tracepoints accept an extra collect action -- ``collect $_sdata''.\n\
12972 This collects arbitrary user data passed in the probe point call to the\n\
12973 tracing library. You can inspect it when analyzing the trace buffer,\n\
12974 by printing the $_sdata variable like any other convenience variable.\n\
12976 CONDITION is a boolean expression.\n\
12978 Multiple tracepoints at one place are permitted, and useful if their\n\
12979 conditions are different.\n\
12981 Do \"help breakpoints\" for info on other commands dealing with breakpoints.\n\
12982 Do \"help tracepoints\" for info on other tracepoint commands."));
12983 set_cmd_completer (c
, location_completer
);
12985 add_info ("tracepoints", tracepoints_info
, _("\
12986 Status of specified tracepoints (all tracepoints if no argument).\n\
12987 Convenience variable \"$tpnum\" contains the number of the\n\
12988 last tracepoint set."));
12990 add_info_alias ("tp", "tracepoints", 1);
12992 add_cmd ("tracepoints", class_trace
, delete_trace_command
, _("\
12993 Delete specified tracepoints.\n\
12994 Arguments are tracepoint numbers, separated by spaces.\n\
12995 No argument means delete all tracepoints."),
12998 c
= add_cmd ("tracepoints", class_trace
, disable_trace_command
, _("\
12999 Disable specified tracepoints.\n\
13000 Arguments are tracepoint numbers, separated by spaces.\n\
13001 No argument means disable all tracepoints."),
13003 deprecate_cmd (c
, "disable");
13005 c
= add_cmd ("tracepoints", class_trace
, enable_trace_command
, _("\
13006 Enable specified tracepoints.\n\
13007 Arguments are tracepoint numbers, separated by spaces.\n\
13008 No argument means enable all tracepoints."),
13010 deprecate_cmd (c
, "enable");
13012 add_com ("passcount", class_trace
, trace_pass_command
, _("\
13013 Set the passcount for a tracepoint.\n\
13014 The trace will end when the tracepoint has been passed 'count' times.\n\
13015 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
13016 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
13018 add_prefix_cmd ("save", class_breakpoint
, save_command
,
13019 _("Save breakpoint definitions as a script."),
13020 &save_cmdlist
, "save ",
13021 0/*allow-unknown*/, &cmdlist
);
13023 c
= add_cmd ("breakpoints", class_breakpoint
, save_breakpoints_command
, _("\
13024 Save current breakpoint definitions as a script.\n\
13025 This includes all types of breakpoints (breakpoints, watchpoints,\n\
13026 catchpoints, tracepoints). Use the 'source' command in another debug\n\
13027 session to restore them."),
13029 set_cmd_completer (c
, filename_completer
);
13031 c
= add_cmd ("tracepoints", class_trace
, save_tracepoints_command
, _("\
13032 Save current tracepoint definitions as a script.\n\
13033 Use the 'source' command in another debug session to restore them."),
13035 set_cmd_completer (c
, filename_completer
);
13037 c
= add_com_alias ("save-tracepoints", "save tracepoints", class_trace
, 0);
13038 deprecate_cmd (c
, "save tracepoints");
13040 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
13041 Breakpoint specific settings\n\
13042 Configure various breakpoint-specific variables such as\n\
13043 pending breakpoint behavior"),
13044 &breakpoint_set_cmdlist
, "set breakpoint ",
13045 0/*allow-unknown*/, &setlist
);
13046 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
13047 Breakpoint specific settings\n\
13048 Configure various breakpoint-specific variables such as\n\
13049 pending breakpoint behavior"),
13050 &breakpoint_show_cmdlist
, "show breakpoint ",
13051 0/*allow-unknown*/, &showlist
);
13053 add_setshow_auto_boolean_cmd ("pending", no_class
,
13054 &pending_break_support
, _("\
13055 Set debugger's behavior regarding pending breakpoints."), _("\
13056 Show debugger's behavior regarding pending breakpoints."), _("\
13057 If on, an unrecognized breakpoint location will cause gdb to create a\n\
13058 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
13059 an error. If auto, an unrecognized breakpoint location results in a\n\
13060 user-query to see if a pending breakpoint should be created."),
13062 show_pending_break_support
,
13063 &breakpoint_set_cmdlist
,
13064 &breakpoint_show_cmdlist
);
13066 pending_break_support
= AUTO_BOOLEAN_AUTO
;
13068 add_setshow_boolean_cmd ("auto-hw", no_class
,
13069 &automatic_hardware_breakpoints
, _("\
13070 Set automatic usage of hardware breakpoints."), _("\
13071 Show automatic usage of hardware breakpoints."), _("\
13072 If set, the debugger will automatically use hardware breakpoints for\n\
13073 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
13074 a warning will be emitted for such breakpoints."),
13076 show_automatic_hardware_breakpoints
,
13077 &breakpoint_set_cmdlist
,
13078 &breakpoint_show_cmdlist
);
13080 add_setshow_enum_cmd ("always-inserted", class_support
,
13081 always_inserted_enums
, &always_inserted_mode
, _("\
13082 Set mode for inserting breakpoints."), _("\
13083 Show mode for inserting breakpoints."), _("\
13084 When this mode is off, breakpoints are inserted in inferior when it is\n\
13085 resumed, and removed when execution stops. When this mode is on,\n\
13086 breakpoints are inserted immediately and removed only when the user\n\
13087 deletes the breakpoint. When this mode is auto (which is the default),\n\
13088 the behaviour depends on the non-stop setting (see help set non-stop).\n\
13089 In this case, if gdb is controlling the inferior in non-stop mode, gdb\n\
13090 behaves as if always-inserted mode is on; if gdb is controlling the\n\
13091 inferior in all-stop mode, gdb behaves as if always-inserted mode is off."),
13093 &show_always_inserted_mode
,
13094 &breakpoint_set_cmdlist
,
13095 &breakpoint_show_cmdlist
);
13097 add_com ("break-range", class_breakpoint
, break_range_command
, _("\
13098 Set a breakpoint for an address range.\n\
13099 break-range START-LOCATION, END-LOCATION\n\
13100 where START-LOCATION and END-LOCATION can be one of the following:\n\
13101 LINENUM, for that line in the current file,\n\
13102 FILE:LINENUM, for that line in that file,\n\
13103 +OFFSET, for that number of lines after the current line\n\
13104 or the start of the range\n\
13105 FUNCTION, for the first line in that function,\n\
13106 FILE:FUNCTION, to distinguish among like-named static functions.\n\
13107 *ADDRESS, for the instruction at that address.\n\
13109 The breakpoint will stop execution of the inferior whenever it executes\n\
13110 an instruction at any address within the [START-LOCATION, END-LOCATION]\n\
13111 range (including START-LOCATION and END-LOCATION)."));
13113 automatic_hardware_breakpoints
= 1;
13115 observer_attach_about_to_proceed (breakpoint_about_to_proceed
);