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 captured_parse_breakpoint_args
6072 struct symtabs_and_lines
*sals_p
;
6073 struct linespec_result
*canonical_p
;
6077 struct lang_and_radix
6083 /* Create a breakpoint for JIT code registration and unregistration. */
6086 create_jit_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
6088 struct breakpoint
*b
;
6090 b
= create_internal_breakpoint (gdbarch
, address
, bp_jit_event
);
6091 update_global_location_list_nothrow (1);
6095 /* Remove JIT code registration and unregistration breakpoint(s). */
6098 remove_jit_event_breakpoints (void)
6100 struct breakpoint
*b
, *b_tmp
;
6102 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
6103 if (b
->type
== bp_jit_event
6104 && b
->loc
->pspace
== current_program_space
)
6105 delete_breakpoint (b
);
6109 remove_solib_event_breakpoints (void)
6111 struct breakpoint
*b
, *b_tmp
;
6113 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
6114 if (b
->type
== bp_shlib_event
6115 && b
->loc
->pspace
== current_program_space
)
6116 delete_breakpoint (b
);
6120 create_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
6122 struct breakpoint
*b
;
6124 b
= create_internal_breakpoint (gdbarch
, address
, bp_shlib_event
);
6125 update_global_location_list_nothrow (1);
6129 /* Disable any breakpoints that are on code in shared libraries. Only
6130 apply to enabled breakpoints, disabled ones can just stay disabled. */
6133 disable_breakpoints_in_shlibs (void)
6135 struct bp_location
*loc
, **locp_tmp
;
6137 ALL_BP_LOCATIONS (loc
, locp_tmp
)
6139 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
6140 struct breakpoint
*b
= loc
->owner
;
6142 /* We apply the check to all breakpoints, including disabled for
6143 those with loc->duplicate set. This is so that when breakpoint
6144 becomes enabled, or the duplicate is removed, gdb will try to
6145 insert all breakpoints. If we don't set shlib_disabled here,
6146 we'll try to insert those breakpoints and fail. */
6147 if (((b
->type
== bp_breakpoint
)
6148 || (b
->type
== bp_jit_event
)
6149 || (b
->type
== bp_hardware_breakpoint
)
6150 || (is_tracepoint (b
)))
6151 && loc
->pspace
== current_program_space
6152 && !loc
->shlib_disabled
6154 && PC_SOLIB (loc
->address
)
6156 && solib_name_from_address (loc
->pspace
, loc
->address
)
6160 loc
->shlib_disabled
= 1;
6165 /* Disable any breakpoints that are in in an unloaded shared library.
6166 Only apply to enabled breakpoints, disabled ones can just stay
6170 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
6172 struct bp_location
*loc
, **locp_tmp
;
6173 int disabled_shlib_breaks
= 0;
6175 /* SunOS a.out shared libraries are always mapped, so do not
6176 disable breakpoints; they will only be reported as unloaded
6177 through clear_solib when GDB discards its shared library
6178 list. See clear_solib for more information. */
6179 if (exec_bfd
!= NULL
6180 && bfd_get_flavour (exec_bfd
) == bfd_target_aout_flavour
)
6183 ALL_BP_LOCATIONS (loc
, locp_tmp
)
6185 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
6186 struct breakpoint
*b
= loc
->owner
;
6188 if ((loc
->loc_type
== bp_loc_hardware_breakpoint
6189 || loc
->loc_type
== bp_loc_software_breakpoint
)
6190 && solib
->pspace
== loc
->pspace
6191 && !loc
->shlib_disabled
6192 && (b
->type
== bp_breakpoint
6193 || b
->type
== bp_jit_event
6194 || b
->type
== bp_hardware_breakpoint
)
6195 && solib_contains_address_p (solib
, loc
->address
))
6197 loc
->shlib_disabled
= 1;
6198 /* At this point, we cannot rely on remove_breakpoint
6199 succeeding so we must mark the breakpoint as not inserted
6200 to prevent future errors occurring in remove_breakpoints. */
6202 if (!disabled_shlib_breaks
)
6204 target_terminal_ours_for_output ();
6205 warning (_("Temporarily disabling breakpoints "
6206 "for unloaded shared library \"%s\""),
6209 disabled_shlib_breaks
= 1;
6214 /* FORK & VFORK catchpoints. */
6216 /* Implement the "insert" breakpoint_ops method for fork
6220 insert_catch_fork (struct bp_location
*bl
)
6222 return target_insert_fork_catchpoint (PIDGET (inferior_ptid
));
6225 /* Implement the "remove" breakpoint_ops method for fork
6229 remove_catch_fork (struct bp_location
*bl
)
6231 return target_remove_fork_catchpoint (PIDGET (inferior_ptid
));
6234 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
6238 breakpoint_hit_catch_fork (const struct bp_location
*bl
,
6239 struct address_space
*aspace
, CORE_ADDR bp_addr
)
6241 return inferior_has_forked (inferior_ptid
, &bl
->owner
->forked_inferior_pid
);
6244 /* Implement the "print_it" breakpoint_ops method for fork
6247 static enum print_stop_action
6248 print_it_catch_fork (struct breakpoint
*b
)
6250 annotate_catchpoint (b
->number
);
6251 printf_filtered (_("\nCatchpoint %d (forked process %d), "),
6252 b
->number
, ptid_get_pid (b
->forked_inferior_pid
));
6253 return PRINT_SRC_AND_LOC
;
6256 /* Implement the "print_one" breakpoint_ops method for fork
6260 print_one_catch_fork (struct breakpoint
*b
, struct bp_location
**last_loc
)
6262 struct value_print_options opts
;
6264 get_user_print_options (&opts
);
6266 /* Field 4, the address, is omitted (which makes the columns not
6267 line up too nicely with the headers, but the effect is relatively
6269 if (opts
.addressprint
)
6270 ui_out_field_skip (uiout
, "addr");
6272 ui_out_text (uiout
, "fork");
6273 if (!ptid_equal (b
->forked_inferior_pid
, null_ptid
))
6275 ui_out_text (uiout
, ", process ");
6276 ui_out_field_int (uiout
, "what",
6277 ptid_get_pid (b
->forked_inferior_pid
));
6278 ui_out_spaces (uiout
, 1);
6282 /* Implement the "print_mention" breakpoint_ops method for fork
6286 print_mention_catch_fork (struct breakpoint
*b
)
6288 printf_filtered (_("Catchpoint %d (fork)"), b
->number
);
6291 /* Implement the "print_recreate" breakpoint_ops method for fork
6295 print_recreate_catch_fork (struct breakpoint
*b
, struct ui_file
*fp
)
6297 fprintf_unfiltered (fp
, "catch fork");
6300 /* The breakpoint_ops structure to be used in fork catchpoints. */
6302 static struct breakpoint_ops catch_fork_breakpoint_ops
=
6306 breakpoint_hit_catch_fork
,
6307 NULL
, /* resources_needed */
6308 print_it_catch_fork
,
6309 print_one_catch_fork
,
6310 NULL
, /* print_one_detail */
6311 print_mention_catch_fork
,
6312 print_recreate_catch_fork
6315 /* Implement the "insert" breakpoint_ops method for vfork
6319 insert_catch_vfork (struct bp_location
*bl
)
6321 return target_insert_vfork_catchpoint (PIDGET (inferior_ptid
));
6324 /* Implement the "remove" breakpoint_ops method for vfork
6328 remove_catch_vfork (struct bp_location
*bl
)
6330 return target_remove_vfork_catchpoint (PIDGET (inferior_ptid
));
6333 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
6337 breakpoint_hit_catch_vfork (const struct bp_location
*bl
,
6338 struct address_space
*aspace
, CORE_ADDR bp_addr
)
6340 return inferior_has_vforked (inferior_ptid
, &bl
->owner
->forked_inferior_pid
);
6343 /* Implement the "print_it" breakpoint_ops method for vfork
6346 static enum print_stop_action
6347 print_it_catch_vfork (struct breakpoint
*b
)
6349 annotate_catchpoint (b
->number
);
6350 printf_filtered (_("\nCatchpoint %d (vforked process %d), "),
6351 b
->number
, ptid_get_pid (b
->forked_inferior_pid
));
6352 return PRINT_SRC_AND_LOC
;
6355 /* Implement the "print_one" breakpoint_ops method for vfork
6359 print_one_catch_vfork (struct breakpoint
*b
, struct bp_location
**last_loc
)
6361 struct value_print_options opts
;
6363 get_user_print_options (&opts
);
6364 /* Field 4, the address, is omitted (which makes the columns not
6365 line up too nicely with the headers, but the effect is relatively
6367 if (opts
.addressprint
)
6368 ui_out_field_skip (uiout
, "addr");
6370 ui_out_text (uiout
, "vfork");
6371 if (!ptid_equal (b
->forked_inferior_pid
, null_ptid
))
6373 ui_out_text (uiout
, ", process ");
6374 ui_out_field_int (uiout
, "what",
6375 ptid_get_pid (b
->forked_inferior_pid
));
6376 ui_out_spaces (uiout
, 1);
6380 /* Implement the "print_mention" breakpoint_ops method for vfork
6384 print_mention_catch_vfork (struct breakpoint
*b
)
6386 printf_filtered (_("Catchpoint %d (vfork)"), b
->number
);
6389 /* Implement the "print_recreate" breakpoint_ops method for vfork
6393 print_recreate_catch_vfork (struct breakpoint
*b
, struct ui_file
*fp
)
6395 fprintf_unfiltered (fp
, "catch vfork");
6398 /* The breakpoint_ops structure to be used in vfork catchpoints. */
6400 static struct breakpoint_ops catch_vfork_breakpoint_ops
=
6404 breakpoint_hit_catch_vfork
,
6405 NULL
, /* resources_needed */
6406 print_it_catch_vfork
,
6407 print_one_catch_vfork
,
6408 NULL
, /* print_one_detail */
6409 print_mention_catch_vfork
,
6410 print_recreate_catch_vfork
6413 /* Implement the "insert" breakpoint_ops method for syscall
6417 insert_catch_syscall (struct bp_location
*bl
)
6419 struct inferior
*inf
= current_inferior ();
6421 ++inf
->total_syscalls_count
;
6422 if (!bl
->owner
->syscalls_to_be_caught
)
6423 ++inf
->any_syscall_count
;
6429 VEC_iterate (int, bl
->owner
->syscalls_to_be_caught
, i
, iter
);
6434 if (iter
>= VEC_length (int, inf
->syscalls_counts
))
6436 int old_size
= VEC_length (int, inf
->syscalls_counts
);
6437 uintptr_t vec_addr_offset
6438 = old_size
* ((uintptr_t) sizeof (int));
6440 VEC_safe_grow (int, inf
->syscalls_counts
, iter
+ 1);
6441 vec_addr
= (uintptr_t) VEC_address (int, inf
->syscalls_counts
) +
6443 memset ((void *) vec_addr
, 0,
6444 (iter
+ 1 - old_size
) * sizeof (int));
6446 elem
= VEC_index (int, inf
->syscalls_counts
, iter
);
6447 VEC_replace (int, inf
->syscalls_counts
, iter
, ++elem
);
6451 return target_set_syscall_catchpoint (PIDGET (inferior_ptid
),
6452 inf
->total_syscalls_count
!= 0,
6453 inf
->any_syscall_count
,
6454 VEC_length (int, inf
->syscalls_counts
),
6455 VEC_address (int, inf
->syscalls_counts
));
6458 /* Implement the "remove" breakpoint_ops method for syscall
6462 remove_catch_syscall (struct bp_location
*bl
)
6464 struct inferior
*inf
= current_inferior ();
6466 --inf
->total_syscalls_count
;
6467 if (!bl
->owner
->syscalls_to_be_caught
)
6468 --inf
->any_syscall_count
;
6474 VEC_iterate (int, bl
->owner
->syscalls_to_be_caught
, i
, iter
);
6478 if (iter
>= VEC_length (int, inf
->syscalls_counts
))
6479 /* Shouldn't happen. */
6481 elem
= VEC_index (int, inf
->syscalls_counts
, iter
);
6482 VEC_replace (int, inf
->syscalls_counts
, iter
, --elem
);
6486 return target_set_syscall_catchpoint (PIDGET (inferior_ptid
),
6487 inf
->total_syscalls_count
!= 0,
6488 inf
->any_syscall_count
,
6489 VEC_length (int, inf
->syscalls_counts
),
6491 inf
->syscalls_counts
));
6494 /* Implement the "breakpoint_hit" breakpoint_ops method for syscall
6498 breakpoint_hit_catch_syscall (const struct bp_location
*bl
,
6499 struct address_space
*aspace
, CORE_ADDR bp_addr
)
6501 /* We must check if we are catching specific syscalls in this
6502 breakpoint. If we are, then we must guarantee that the called
6503 syscall is the same syscall we are catching. */
6504 int syscall_number
= 0;
6505 const struct breakpoint
*b
= bl
->owner
;
6507 if (!inferior_has_called_syscall (inferior_ptid
, &syscall_number
))
6510 /* Now, checking if the syscall is the same. */
6511 if (b
->syscalls_to_be_caught
)
6516 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
6518 if (syscall_number
== iter
)
6528 /* Implement the "print_it" breakpoint_ops method for syscall
6531 static enum print_stop_action
6532 print_it_catch_syscall (struct breakpoint
*b
)
6534 /* These are needed because we want to know in which state a
6535 syscall is. It can be in the TARGET_WAITKIND_SYSCALL_ENTRY
6536 or TARGET_WAITKIND_SYSCALL_RETURN, and depending on it we
6537 must print "called syscall" or "returned from syscall". */
6539 struct target_waitstatus last
;
6541 struct cleanup
*old_chain
;
6544 get_last_target_status (&ptid
, &last
);
6546 get_syscall_by_number (last
.value
.syscall_number
, &s
);
6548 annotate_catchpoint (b
->number
);
6551 syscall_id
= xstrprintf ("%d", last
.value
.syscall_number
);
6553 syscall_id
= xstrprintf ("'%s'", s
.name
);
6555 old_chain
= make_cleanup (xfree
, syscall_id
);
6557 if (last
.kind
== TARGET_WAITKIND_SYSCALL_ENTRY
)
6558 printf_filtered (_("\nCatchpoint %d (call to syscall %s), "),
6559 b
->number
, syscall_id
);
6560 else if (last
.kind
== TARGET_WAITKIND_SYSCALL_RETURN
)
6561 printf_filtered (_("\nCatchpoint %d (returned from syscall %s), "),
6562 b
->number
, syscall_id
);
6564 do_cleanups (old_chain
);
6566 return PRINT_SRC_AND_LOC
;
6569 /* Implement the "print_one" breakpoint_ops method for syscall
6573 print_one_catch_syscall (struct breakpoint
*b
,
6574 struct bp_location
**last_loc
)
6576 struct value_print_options opts
;
6578 get_user_print_options (&opts
);
6579 /* Field 4, the address, is omitted (which makes the columns not
6580 line up too nicely with the headers, but the effect is relatively
6582 if (opts
.addressprint
)
6583 ui_out_field_skip (uiout
, "addr");
6586 if (b
->syscalls_to_be_caught
6587 && VEC_length (int, b
->syscalls_to_be_caught
) > 1)
6588 ui_out_text (uiout
, "syscalls \"");
6590 ui_out_text (uiout
, "syscall \"");
6592 if (b
->syscalls_to_be_caught
)
6595 char *text
= xstrprintf ("%s", "");
6598 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
6603 get_syscall_by_number (iter
, &s
);
6606 text
= xstrprintf ("%s%s, ", text
, s
.name
);
6608 text
= xstrprintf ("%s%d, ", text
, iter
);
6610 /* We have to xfree the last 'text' (now stored at 'x')
6611 because xstrprintf dinamically allocates new space for it
6615 /* Remove the last comma. */
6616 text
[strlen (text
) - 2] = '\0';
6617 ui_out_field_string (uiout
, "what", text
);
6620 ui_out_field_string (uiout
, "what", "<any syscall>");
6621 ui_out_text (uiout
, "\" ");
6624 /* Implement the "print_mention" breakpoint_ops method for syscall
6628 print_mention_catch_syscall (struct breakpoint
*b
)
6630 if (b
->syscalls_to_be_caught
)
6634 if (VEC_length (int, b
->syscalls_to_be_caught
) > 1)
6635 printf_filtered (_("Catchpoint %d (syscalls"), b
->number
);
6637 printf_filtered (_("Catchpoint %d (syscall"), b
->number
);
6640 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
6644 get_syscall_by_number (iter
, &s
);
6647 printf_filtered (" '%s' [%d]", s
.name
, s
.number
);
6649 printf_filtered (" %d", s
.number
);
6651 printf_filtered (")");
6654 printf_filtered (_("Catchpoint %d (any syscall)"),
6658 /* Implement the "print_recreate" breakpoint_ops method for syscall
6662 print_recreate_catch_syscall (struct breakpoint
*b
, struct ui_file
*fp
)
6664 fprintf_unfiltered (fp
, "catch syscall");
6666 if (b
->syscalls_to_be_caught
)
6671 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
6676 get_syscall_by_number (iter
, &s
);
6678 fprintf_unfiltered (fp
, " %s", s
.name
);
6680 fprintf_unfiltered (fp
, " %d", s
.number
);
6685 /* The breakpoint_ops structure to be used in syscall catchpoints. */
6687 static struct breakpoint_ops catch_syscall_breakpoint_ops
=
6689 insert_catch_syscall
,
6690 remove_catch_syscall
,
6691 breakpoint_hit_catch_syscall
,
6692 NULL
, /* resources_needed */
6693 print_it_catch_syscall
,
6694 print_one_catch_syscall
,
6695 NULL
, /* print_one_detail */
6696 print_mention_catch_syscall
,
6697 print_recreate_catch_syscall
6700 /* Returns non-zero if 'b' is a syscall catchpoint. */
6703 syscall_catchpoint_p (struct breakpoint
*b
)
6705 return (b
->ops
== &catch_syscall_breakpoint_ops
);
6708 /* Create a new breakpoint of the bp_catchpoint kind and return it,
6709 but does NOT mention it nor update the global location list.
6710 This is useful if you need to fill more fields in the
6711 struct breakpoint before calling mention.
6713 If TEMPFLAG is non-zero, then make the breakpoint temporary.
6714 If COND_STRING is not NULL, then store it in the breakpoint.
6715 OPS, if not NULL, is the breakpoint_ops structure associated
6716 to the catchpoint. */
6718 static struct breakpoint
*
6719 create_catchpoint_without_mention (struct gdbarch
*gdbarch
, int tempflag
,
6721 struct breakpoint_ops
*ops
)
6723 struct symtab_and_line sal
;
6724 struct breakpoint
*b
;
6727 sal
.pspace
= current_program_space
;
6729 b
= set_raw_breakpoint (gdbarch
, sal
, bp_catchpoint
);
6730 set_breakpoint_count (breakpoint_count
+ 1);
6731 b
->number
= breakpoint_count
;
6733 b
->cond_string
= (cond_string
== NULL
) ? NULL
: xstrdup (cond_string
);
6735 b
->addr_string
= NULL
;
6736 b
->enable_state
= bp_enabled
;
6737 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6743 /* Create a new breakpoint of the bp_catchpoint kind and return it.
6745 If TEMPFLAG is non-zero, then make the breakpoint temporary.
6746 If COND_STRING is not NULL, then store it in the breakpoint.
6747 OPS, if not NULL, is the breakpoint_ops structure associated
6748 to the catchpoint. */
6750 static struct breakpoint
*
6751 create_catchpoint (struct gdbarch
*gdbarch
, int tempflag
,
6752 char *cond_string
, struct breakpoint_ops
*ops
)
6754 struct breakpoint
*b
=
6755 create_catchpoint_without_mention (gdbarch
, tempflag
, cond_string
, ops
);
6758 update_global_location_list (1);
6764 create_fork_vfork_event_catchpoint (struct gdbarch
*gdbarch
,
6765 int tempflag
, char *cond_string
,
6766 struct breakpoint_ops
*ops
)
6768 struct breakpoint
*b
6769 = create_catchpoint (gdbarch
, tempflag
, cond_string
, ops
);
6771 /* FIXME: We should put this information in a breakpoint private data
6773 b
->forked_inferior_pid
= null_ptid
;
6776 /* Exec catchpoints. */
6779 insert_catch_exec (struct bp_location
*bl
)
6781 return target_insert_exec_catchpoint (PIDGET (inferior_ptid
));
6785 remove_catch_exec (struct bp_location
*bl
)
6787 return target_remove_exec_catchpoint (PIDGET (inferior_ptid
));
6791 breakpoint_hit_catch_exec (const struct bp_location
*bl
,
6792 struct address_space
*aspace
, CORE_ADDR bp_addr
)
6794 return inferior_has_execd (inferior_ptid
, &bl
->owner
->exec_pathname
);
6797 static enum print_stop_action
6798 print_it_catch_exec (struct breakpoint
*b
)
6800 annotate_catchpoint (b
->number
);
6801 printf_filtered (_("\nCatchpoint %d (exec'd %s), "), b
->number
,
6803 return PRINT_SRC_AND_LOC
;
6807 print_one_catch_exec (struct breakpoint
*b
, struct bp_location
**last_loc
)
6809 struct value_print_options opts
;
6811 get_user_print_options (&opts
);
6813 /* Field 4, the address, is omitted (which makes the columns
6814 not line up too nicely with the headers, but the effect
6815 is relatively readable). */
6816 if (opts
.addressprint
)
6817 ui_out_field_skip (uiout
, "addr");
6819 ui_out_text (uiout
, "exec");
6820 if (b
->exec_pathname
!= NULL
)
6822 ui_out_text (uiout
, ", program \"");
6823 ui_out_field_string (uiout
, "what", b
->exec_pathname
);
6824 ui_out_text (uiout
, "\" ");
6829 print_mention_catch_exec (struct breakpoint
*b
)
6831 printf_filtered (_("Catchpoint %d (exec)"), b
->number
);
6834 /* Implement the "print_recreate" breakpoint_ops method for exec
6838 print_recreate_catch_exec (struct breakpoint
*b
, struct ui_file
*fp
)
6840 fprintf_unfiltered (fp
, "catch exec");
6843 static struct breakpoint_ops catch_exec_breakpoint_ops
=
6847 breakpoint_hit_catch_exec
,
6848 NULL
, /* resources_needed */
6849 print_it_catch_exec
,
6850 print_one_catch_exec
,
6851 NULL
, /* print_one_detail */
6852 print_mention_catch_exec
,
6853 print_recreate_catch_exec
6857 create_syscall_event_catchpoint (int tempflag
, VEC(int) *filter
,
6858 struct breakpoint_ops
*ops
)
6860 struct gdbarch
*gdbarch
= get_current_arch ();
6861 struct breakpoint
*b
=
6862 create_catchpoint_without_mention (gdbarch
, tempflag
, NULL
, ops
);
6864 b
->syscalls_to_be_caught
= filter
;
6866 /* Now, we have to mention the breakpoint and update the global
6869 update_global_location_list (1);
6873 hw_breakpoint_used_count (void)
6876 struct breakpoint
*b
;
6877 struct bp_location
*bl
;
6881 if (b
->type
== bp_hardware_breakpoint
&& breakpoint_enabled (b
))
6882 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
6884 /* Special types of hardware breakpoints may use more than
6886 if (b
->ops
&& b
->ops
->resources_needed
)
6887 i
+= b
->ops
->resources_needed (bl
);
6897 hw_watchpoint_used_count (enum bptype type
, int *other_type_used
)
6900 struct breakpoint
*b
;
6901 struct bp_location
*bl
;
6903 *other_type_used
= 0;
6906 if (!breakpoint_enabled (b
))
6909 if (b
->type
== type
)
6910 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
6912 /* Special types of hardware watchpoints may use more than
6914 if (b
->ops
&& b
->ops
->resources_needed
)
6915 i
+= b
->ops
->resources_needed (bl
);
6919 else if (is_hardware_watchpoint (b
))
6920 *other_type_used
= 1;
6927 disable_watchpoints_before_interactive_call_start (void)
6929 struct breakpoint
*b
;
6933 if (is_watchpoint (b
) && breakpoint_enabled (b
))
6935 b
->enable_state
= bp_call_disabled
;
6936 update_global_location_list (0);
6942 enable_watchpoints_after_interactive_call_stop (void)
6944 struct breakpoint
*b
;
6948 if (is_watchpoint (b
) && b
->enable_state
== bp_call_disabled
)
6950 b
->enable_state
= bp_enabled
;
6951 update_global_location_list (1);
6957 disable_breakpoints_before_startup (void)
6959 struct breakpoint
*b
;
6964 if (b
->pspace
!= current_program_space
)
6967 if ((b
->type
== bp_breakpoint
6968 || b
->type
== bp_hardware_breakpoint
)
6969 && breakpoint_enabled (b
))
6971 b
->enable_state
= bp_startup_disabled
;
6977 update_global_location_list (0);
6979 current_program_space
->executing_startup
= 1;
6983 enable_breakpoints_after_startup (void)
6985 struct breakpoint
*b
;
6988 current_program_space
->executing_startup
= 0;
6992 if (b
->pspace
!= current_program_space
)
6995 if ((b
->type
== bp_breakpoint
6996 || b
->type
== bp_hardware_breakpoint
)
6997 && b
->enable_state
== bp_startup_disabled
)
6999 b
->enable_state
= bp_enabled
;
7005 breakpoint_re_set ();
7009 /* Set a breakpoint that will evaporate an end of command
7010 at address specified by SAL.
7011 Restrict it to frame FRAME if FRAME is nonzero. */
7014 set_momentary_breakpoint (struct gdbarch
*gdbarch
, struct symtab_and_line sal
,
7015 struct frame_id frame_id
, enum bptype type
)
7017 struct breakpoint
*b
;
7019 /* If FRAME_ID is valid, it should be a real frame, not an inlined
7021 gdb_assert (!frame_id_inlined_p (frame_id
));
7023 b
= set_raw_breakpoint (gdbarch
, sal
, type
);
7024 b
->enable_state
= bp_enabled
;
7025 b
->disposition
= disp_donttouch
;
7026 b
->frame_id
= frame_id
;
7028 /* If we're debugging a multi-threaded program, then we want
7029 momentary breakpoints to be active in only a single thread of
7031 if (in_thread_list (inferior_ptid
))
7032 b
->thread
= pid_to_thread_id (inferior_ptid
);
7034 update_global_location_list_nothrow (1);
7039 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
7043 clone_momentary_breakpoint (struct breakpoint
*orig
)
7045 struct breakpoint
*copy
;
7047 /* If there's nothing to clone, then return nothing. */
7051 copy
= set_raw_breakpoint_without_location (orig
->gdbarch
, orig
->type
);
7052 copy
->loc
= allocate_bp_location (copy
);
7053 set_breakpoint_location_function (copy
->loc
, 1);
7055 copy
->loc
->gdbarch
= orig
->loc
->gdbarch
;
7056 copy
->loc
->requested_address
= orig
->loc
->requested_address
;
7057 copy
->loc
->address
= orig
->loc
->address
;
7058 copy
->loc
->section
= orig
->loc
->section
;
7059 copy
->loc
->pspace
= orig
->loc
->pspace
;
7061 if (orig
->source_file
== NULL
)
7062 copy
->source_file
= NULL
;
7064 copy
->source_file
= xstrdup (orig
->source_file
);
7066 copy
->line_number
= orig
->line_number
;
7067 copy
->frame_id
= orig
->frame_id
;
7068 copy
->thread
= orig
->thread
;
7069 copy
->pspace
= orig
->pspace
;
7071 copy
->enable_state
= bp_enabled
;
7072 copy
->disposition
= disp_donttouch
;
7073 copy
->number
= internal_breakpoint_number
--;
7075 update_global_location_list_nothrow (0);
7080 set_momentary_breakpoint_at_pc (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
7083 struct symtab_and_line sal
;
7085 sal
= find_pc_line (pc
, 0);
7087 sal
.section
= find_pc_overlay (pc
);
7088 sal
.explicit_pc
= 1;
7090 return set_momentary_breakpoint (gdbarch
, sal
, null_frame_id
, type
);
7094 /* Tell the user we have just set a breakpoint B. */
7097 mention (struct breakpoint
*b
)
7100 struct cleanup
*ui_out_chain
;
7101 struct value_print_options opts
;
7103 get_user_print_options (&opts
);
7105 /* FIXME: This is misplaced; mention() is called by things (like
7106 hitting a watchpoint) other than breakpoint creation. It should
7107 be possible to clean this up and at the same time replace the
7108 random calls to breakpoint_changed with this hook. */
7109 observer_notify_breakpoint_created (b
->number
);
7111 if (b
->ops
!= NULL
&& b
->ops
->print_mention
!= NULL
)
7112 b
->ops
->print_mention (b
);
7117 printf_filtered (_("(apparently deleted?) Eventpoint %d: "),
7121 ui_out_text (uiout
, "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_hardware_watchpoint
:
7129 ui_out_text (uiout
, "Hardware watchpoint ");
7130 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
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_read_watchpoint
:
7137 ui_out_text (uiout
, "Hardware read watchpoint ");
7138 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
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
);
7144 case bp_access_watchpoint
:
7145 ui_out_text (uiout
, "Hardware access (read/write) watchpoint ");
7146 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
7147 ui_out_field_int (uiout
, "number", b
->number
);
7148 ui_out_text (uiout
, ": ");
7149 ui_out_field_string (uiout
, "exp", b
->exp_string
);
7150 do_cleanups (ui_out_chain
);
7153 case bp_gnu_ifunc_resolver
:
7154 if (ui_out_is_mi_like_p (uiout
))
7159 if (b
->disposition
== disp_del
)
7160 printf_filtered (_("Temporary breakpoint"));
7162 printf_filtered (_("Breakpoint"));
7163 printf_filtered (_(" %d"), b
->number
);
7164 if (b
->type
== bp_gnu_ifunc_resolver
)
7165 printf_filtered (_(" at gnu-indirect-function resolver"));
7168 case bp_hardware_breakpoint
:
7169 if (ui_out_is_mi_like_p (uiout
))
7174 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
7178 if (ui_out_is_mi_like_p (uiout
))
7183 printf_filtered (_("Tracepoint"));
7184 printf_filtered (_(" %d"), b
->number
);
7187 case bp_fast_tracepoint
:
7188 if (ui_out_is_mi_like_p (uiout
))
7193 printf_filtered (_("Fast tracepoint"));
7194 printf_filtered (_(" %d"), b
->number
);
7197 case bp_static_tracepoint
:
7198 if (ui_out_is_mi_like_p (uiout
))
7203 printf_filtered (_("Static tracepoint"));
7204 printf_filtered (_(" %d"), b
->number
);
7211 case bp_longjmp_resume
:
7213 case bp_exception_resume
:
7214 case bp_step_resume
:
7216 case bp_std_terminate
:
7217 case bp_watchpoint_scope
:
7218 case bp_shlib_event
:
7219 case bp_thread_event
:
7220 case bp_overlay_event
:
7222 case bp_longjmp_master
:
7223 case bp_std_terminate_master
:
7224 case bp_exception_master
:
7225 case bp_gnu_ifunc_resolver_return
:
7231 /* i18n: cagney/2005-02-11: Below needs to be merged into a
7235 printf_filtered (_(" (%s) pending."), b
->addr_string
);
7239 if (opts
.addressprint
|| b
->source_file
== NULL
)
7241 printf_filtered (" at ");
7242 fputs_filtered (paddress (b
->loc
->gdbarch
, b
->loc
->address
),
7246 printf_filtered (": file %s, line %d.",
7247 b
->source_file
, b
->line_number
);
7251 struct bp_location
*loc
= b
->loc
;
7253 for (; loc
; loc
= loc
->next
)
7255 printf_filtered (" (%d locations)", n
);
7260 if (ui_out_is_mi_like_p (uiout
))
7262 printf_filtered ("\n");
7266 static struct bp_location
*
7267 add_location_to_breakpoint (struct breakpoint
*b
,
7268 const struct symtab_and_line
*sal
)
7270 struct bp_location
*loc
, **tmp
;
7272 loc
= allocate_bp_location (b
);
7273 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
7276 loc
->gdbarch
= get_sal_arch (*sal
);
7278 loc
->gdbarch
= b
->gdbarch
;
7279 loc
->requested_address
= sal
->pc
;
7280 loc
->address
= adjust_breakpoint_address (loc
->gdbarch
,
7281 loc
->requested_address
, b
->type
);
7282 loc
->pspace
= sal
->pspace
;
7283 gdb_assert (loc
->pspace
!= NULL
);
7284 loc
->section
= sal
->section
;
7286 set_breakpoint_location_function (loc
,
7287 sal
->explicit_pc
|| sal
->explicit_line
);
7292 /* Return 1 if LOC is pointing to a permanent breakpoint,
7293 return 0 otherwise. */
7296 bp_loc_is_permanent (struct bp_location
*loc
)
7300 const gdb_byte
*brk
;
7301 gdb_byte
*target_mem
;
7302 struct cleanup
*cleanup
;
7305 gdb_assert (loc
!= NULL
);
7307 addr
= loc
->address
;
7308 brk
= gdbarch_breakpoint_from_pc (loc
->gdbarch
, &addr
, &len
);
7310 /* Software breakpoints unsupported? */
7314 target_mem
= alloca (len
);
7316 /* Enable the automatic memory restoration from breakpoints while
7317 we read the memory. Otherwise we could say about our temporary
7318 breakpoints they are permanent. */
7319 cleanup
= save_current_space_and_thread ();
7321 switch_to_program_space_and_thread (loc
->pspace
);
7322 make_show_memory_breakpoints_cleanup (0);
7324 if (target_read_memory (loc
->address
, target_mem
, len
) == 0
7325 && memcmp (target_mem
, brk
, len
) == 0)
7328 do_cleanups (cleanup
);
7335 /* Create a breakpoint with SAL as location. Use ADDR_STRING
7336 as textual description of the location, and COND_STRING
7337 as condition expression. */
7340 create_breakpoint_sal (struct gdbarch
*gdbarch
,
7341 struct symtabs_and_lines sals
, char *addr_string
,
7343 enum bptype type
, enum bpdisp disposition
,
7344 int thread
, int task
, int ignore_count
,
7345 struct breakpoint_ops
*ops
, int from_tty
,
7346 int enabled
, int internal
, int display_canonical
)
7348 struct breakpoint
*b
= NULL
;
7351 if (type
== bp_hardware_breakpoint
)
7353 int i
= hw_breakpoint_used_count ();
7354 int target_resources_ok
=
7355 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
7357 if (target_resources_ok
== 0)
7358 error (_("No hardware breakpoint support in the target."));
7359 else if (target_resources_ok
< 0)
7360 error (_("Hardware breakpoints used exceeds limit."));
7363 gdb_assert (sals
.nelts
> 0);
7365 for (i
= 0; i
< sals
.nelts
; ++i
)
7367 struct symtab_and_line sal
= sals
.sals
[i
];
7368 struct bp_location
*loc
;
7372 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
7374 loc_gdbarch
= gdbarch
;
7376 describe_other_breakpoints (loc_gdbarch
,
7377 sal
.pspace
, sal
.pc
, sal
.section
, thread
);
7382 b
= set_raw_breakpoint (gdbarch
, sal
, type
);
7383 set_breakpoint_number (internal
, b
);
7387 b
->cond_string
= cond_string
;
7388 b
->ignore_count
= ignore_count
;
7389 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
7390 b
->disposition
= disposition
;
7391 b
->pspace
= sals
.sals
[0].pspace
;
7393 if (type
== bp_static_tracepoint
)
7395 struct static_tracepoint_marker marker
;
7397 if (is_marker_spec (addr_string
))
7399 /* We already know the marker exists, otherwise, we
7400 wouldn't see a sal for it. */
7401 char *p
= &addr_string
[3];
7406 p
= skip_spaces (p
);
7408 endp
= skip_to_space (p
);
7410 marker_str
= savestring (p
, endp
- p
);
7411 b
->static_trace_marker_id
= marker_str
;
7413 printf_filtered (_("Probed static tracepoint "
7415 b
->static_trace_marker_id
);
7417 else if (target_static_tracepoint_marker_at (sal
.pc
, &marker
))
7419 b
->static_trace_marker_id
= xstrdup (marker
.str_id
);
7420 release_static_tracepoint_marker (&marker
);
7422 printf_filtered (_("Probed static tracepoint "
7424 b
->static_trace_marker_id
);
7427 warning (_("Couldn't determine the static "
7428 "tracepoint marker to probe"));
7431 if (enabled
&& b
->pspace
->executing_startup
7432 && (b
->type
== bp_breakpoint
7433 || b
->type
== bp_hardware_breakpoint
))
7434 b
->enable_state
= bp_startup_disabled
;
7440 loc
= add_location_to_breakpoint (b
, &sal
);
7443 if (bp_loc_is_permanent (loc
))
7444 make_breakpoint_permanent (b
);
7448 char *arg
= b
->cond_string
;
7449 loc
->cond
= parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
7451 error (_("Garbage %s follows condition"), arg
);
7455 b
->display_canonical
= display_canonical
;
7457 b
->addr_string
= addr_string
;
7459 /* addr_string has to be used or breakpoint_re_set will delete
7462 = xstrprintf ("*%s", paddress (b
->loc
->gdbarch
, b
->loc
->address
));
7466 /* Do not mention breakpoints with a negative number, but do
7467 notify observers. */
7468 observer_notify_breakpoint_created (b
->number
);
7473 /* Remove element at INDEX_TO_REMOVE from SAL, shifting other
7474 elements to fill the void space. */
7476 remove_sal (struct symtabs_and_lines
*sal
, int index_to_remove
)
7478 int i
= index_to_remove
+1;
7479 int last_index
= sal
->nelts
-1;
7481 for (;i
<= last_index
; ++i
)
7482 sal
->sals
[i
-1] = sal
->sals
[i
];
7487 /* If appropriate, obtains all sals that correspond to the same file
7488 and line as SAL, in all program spaces. Users debugging with IDEs,
7489 will want to set a breakpoint at foo.c:line, and not really care
7490 about program spaces. This is done only if SAL does not have
7491 explicit PC and has line and file information. If we got just a
7492 single expanded sal, return the original.
7494 Otherwise, if SAL.explicit_line is not set, filter out all sals for
7495 which the name of enclosing function is different from SAL. This
7496 makes sure that if we have breakpoint originally set in template
7497 instantiation, say foo<int>(), we won't expand SAL to locations at
7498 the same line in all existing instantiations of 'foo'. */
7500 static struct symtabs_and_lines
7501 expand_line_sal_maybe (struct symtab_and_line sal
)
7503 struct symtabs_and_lines expanded
;
7504 CORE_ADDR original_pc
= sal
.pc
;
7505 char *original_function
= NULL
;
7508 struct cleanup
*old_chain
;
7510 /* If we have explicit pc, don't expand.
7511 If we have no line number, we can't expand. */
7512 if (sal
.explicit_pc
|| sal
.line
== 0 || sal
.symtab
== NULL
)
7515 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
7516 expanded
.sals
[0] = sal
;
7522 old_chain
= save_current_space_and_thread ();
7524 switch_to_program_space_and_thread (sal
.pspace
);
7526 find_pc_partial_function (original_pc
, &original_function
, NULL
, NULL
);
7528 /* Note that expand_line_sal visits *all* program spaces. */
7529 expanded
= expand_line_sal (sal
);
7531 if (expanded
.nelts
== 1)
7533 /* We had one sal, we got one sal. Return that sal, adjusting it
7534 past the function prologue if necessary. */
7535 xfree (expanded
.sals
);
7537 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
7538 sal
.pc
= original_pc
;
7539 expanded
.sals
[0] = sal
;
7540 skip_prologue_sal (&expanded
.sals
[0]);
7541 do_cleanups (old_chain
);
7545 if (!sal
.explicit_line
)
7547 CORE_ADDR func_addr
, func_end
;
7548 for (i
= 0; i
< expanded
.nelts
; ++i
)
7550 CORE_ADDR pc
= expanded
.sals
[i
].pc
;
7551 char *this_function
;
7553 /* We need to switch threads as well since we're about to
7555 switch_to_program_space_and_thread (expanded
.sals
[i
].pspace
);
7557 if (find_pc_partial_function (pc
, &this_function
,
7558 &func_addr
, &func_end
))
7561 && strcmp (this_function
, original_function
) != 0)
7563 remove_sal (&expanded
, i
);
7570 /* Skip the function prologue if necessary. */
7571 for (i
= 0; i
< expanded
.nelts
; ++i
)
7572 skip_prologue_sal (&expanded
.sals
[i
]);
7574 do_cleanups (old_chain
);
7576 if (expanded
.nelts
<= 1)
7578 /* This is un ugly workaround. If we get zero expanded sals
7579 then something is really wrong. Fix that by returning the
7582 xfree (expanded
.sals
);
7584 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
7585 sal
.pc
= original_pc
;
7586 expanded
.sals
[0] = sal
;
7593 for (i
= 0; i
< expanded
.nelts
; ++i
)
7594 if (expanded
.sals
[i
].pc
== original_pc
)
7605 /* Add SALS.nelts breakpoints to the breakpoint table. For each
7606 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
7607 value. COND_STRING, if not NULL, specified the condition to be
7608 used for all breakpoints. Essentially the only case where
7609 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
7610 function. In that case, it's still not possible to specify
7611 separate conditions for different overloaded functions, so
7612 we take just a single condition string.
7614 NOTE: If the function succeeds, the caller is expected to cleanup
7615 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
7616 array contents). If the function fails (error() is called), the
7617 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
7618 COND and SALS arrays and each of those arrays contents. */
7621 create_breakpoints_sal (struct gdbarch
*gdbarch
,
7622 struct symtabs_and_lines sals
,
7623 struct linespec_result
*canonical
,
7625 enum bptype type
, enum bpdisp disposition
,
7626 int thread
, int task
, int ignore_count
,
7627 struct breakpoint_ops
*ops
, int from_tty
,
7628 int enabled
, int internal
)
7632 for (i
= 0; i
< sals
.nelts
; ++i
)
7634 struct symtabs_and_lines expanded
=
7635 expand_line_sal_maybe (sals
.sals
[i
]);
7637 create_breakpoint_sal (gdbarch
, expanded
, canonical
->canonical
[i
],
7638 cond_string
, type
, disposition
,
7639 thread
, task
, ignore_count
, ops
,
7640 from_tty
, enabled
, internal
,
7641 canonical
->special_display
);
7645 /* Parse ADDRESS which is assumed to be a SAL specification possibly
7646 followed by conditionals. On return, SALS contains an array of SAL
7647 addresses found. ADDR_STRING contains a vector of (canonical)
7648 address strings. ADDRESS points to the end of the SAL.
7650 The array and the line spec strings are allocated on the heap, it is
7651 the caller's responsibility to free them. */
7654 parse_breakpoint_sals (char **address
,
7655 struct symtabs_and_lines
*sals
,
7656 struct linespec_result
*canonical
,
7659 char *addr_start
= *address
;
7661 /* If no arg given, or if first arg is 'if ', use the default
7663 if ((*address
) == NULL
7664 || (strncmp ((*address
), "if", 2) == 0 && isspace ((*address
)[2])))
7666 if (default_breakpoint_valid
)
7668 struct symtab_and_line sal
;
7670 init_sal (&sal
); /* Initialize to zeroes. */
7671 sals
->sals
= (struct symtab_and_line
*)
7672 xmalloc (sizeof (struct symtab_and_line
));
7673 sal
.pc
= default_breakpoint_address
;
7674 sal
.line
= default_breakpoint_line
;
7675 sal
.symtab
= default_breakpoint_symtab
;
7676 sal
.pspace
= default_breakpoint_pspace
;
7677 sal
.section
= find_pc_overlay (sal
.pc
);
7679 /* "break" without arguments is equivalent to "break *PC"
7680 where PC is the default_breakpoint_address. So make sure
7681 to set sal.explicit_pc to prevent GDB from trying to
7682 expand the list of sals to include all other instances
7683 with the same symtab and line. */
7684 sal
.explicit_pc
= 1;
7686 sals
->sals
[0] = sal
;
7690 error (_("No default breakpoint address now."));
7694 /* Force almost all breakpoints to be in terms of the
7695 current_source_symtab (which is decode_line_1's default).
7696 This should produce the results we want almost all of the
7697 time while leaving default_breakpoint_* alone.
7699 ObjC: However, don't match an Objective-C method name which
7700 may have a '+' or '-' succeeded by a '[' */
7702 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
7704 if (default_breakpoint_valid
7706 || ((strchr ("+-", (*address
)[0]) != NULL
)
7707 && ((*address
)[1] != '['))))
7708 *sals
= decode_line_1 (address
, 1, default_breakpoint_symtab
,
7709 default_breakpoint_line
, canonical
,
7712 *sals
= decode_line_1 (address
, 1, (struct symtab
*) NULL
, 0,
7713 canonical
, not_found_ptr
);
7715 /* For any SAL that didn't have a canonical string, fill one in. */
7716 if (sals
->nelts
> 0 && canonical
->canonical
== NULL
)
7717 canonical
->canonical
= xcalloc (sals
->nelts
, sizeof (char **));
7718 if (addr_start
!= (*address
))
7722 for (i
= 0; i
< sals
->nelts
; i
++)
7724 /* Add the string if not present. */
7725 if (canonical
->canonical
[i
] == NULL
)
7726 canonical
->canonical
[i
] = savestring (addr_start
,
7727 (*address
) - addr_start
);
7733 /* Convert each SAL into a real PC. Verify that the PC can be
7734 inserted as a breakpoint. If it can't throw an error. */
7737 breakpoint_sals_to_pc (struct symtabs_and_lines
*sals
)
7741 for (i
= 0; i
< sals
->nelts
; i
++)
7742 resolve_sal_pc (&sals
->sals
[i
]);
7745 /* Fast tracepoints may have restrictions on valid locations. For
7746 instance, a fast tracepoint using a jump instead of a trap will
7747 likely have to overwrite more bytes than a trap would, and so can
7748 only be placed where the instruction is longer than the jump, or a
7749 multi-instruction sequence does not have a jump into the middle of
7753 check_fast_tracepoint_sals (struct gdbarch
*gdbarch
,
7754 struct symtabs_and_lines
*sals
)
7757 struct symtab_and_line
*sal
;
7759 struct cleanup
*old_chain
;
7761 for (i
= 0; i
< sals
->nelts
; i
++)
7763 sal
= &sals
->sals
[i
];
7765 rslt
= gdbarch_fast_tracepoint_valid_at (gdbarch
, sal
->pc
,
7767 old_chain
= make_cleanup (xfree
, msg
);
7770 error (_("May not have a fast tracepoint at 0x%s%s"),
7771 paddress (gdbarch
, sal
->pc
), (msg
? msg
: ""));
7773 do_cleanups (old_chain
);
7778 do_captured_parse_breakpoint (struct ui_out
*ui
, void *data
)
7780 struct captured_parse_breakpoint_args
*args
= data
;
7782 parse_breakpoint_sals (args
->arg_p
, args
->sals_p
, args
->canonical_p
,
7783 args
->not_found_ptr
);
7786 /* Given TOK, a string specification of condition and thread, as
7787 accepted by the 'break' command, extract the condition
7788 string and thread number and set *COND_STRING and *THREAD.
7789 PC identifies the context at which the condition should be parsed.
7790 If no condition is found, *COND_STRING is set to NULL.
7791 If no thread is found, *THREAD is set to -1. */
7793 find_condition_and_thread (char *tok
, CORE_ADDR pc
,
7794 char **cond_string
, int *thread
, int *task
)
7796 *cond_string
= NULL
;
7802 char *cond_start
= NULL
;
7803 char *cond_end
= NULL
;
7805 tok
= skip_spaces (tok
);
7807 end_tok
= skip_to_space (tok
);
7809 toklen
= end_tok
- tok
;
7811 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
7813 struct expression
*expr
;
7815 tok
= cond_start
= end_tok
+ 1;
7816 expr
= parse_exp_1 (&tok
, block_for_pc (pc
), 0);
7819 *cond_string
= savestring (cond_start
,
7820 cond_end
- cond_start
);
7822 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
7828 *thread
= strtol (tok
, &tok
, 0);
7830 error (_("Junk after thread keyword."));
7831 if (!valid_thread_id (*thread
))
7832 error (_("Unknown thread %d."), *thread
);
7834 else if (toklen
>= 1 && strncmp (tok
, "task", toklen
) == 0)
7840 *task
= strtol (tok
, &tok
, 0);
7842 error (_("Junk after task keyword."));
7843 if (!valid_task_id (*task
))
7844 error (_("Unknown task %d."), *task
);
7847 error (_("Junk at end of arguments."));
7851 /* Decode a static tracepoint marker spec. */
7853 static struct symtabs_and_lines
7854 decode_static_tracepoint_spec (char **arg_p
)
7856 VEC(static_tracepoint_marker_p
) *markers
= NULL
;
7857 struct symtabs_and_lines sals
;
7858 struct symtab_and_line sal
;
7860 struct cleanup
*old_chain
;
7861 char *p
= &(*arg_p
)[3];
7866 p
= skip_spaces (p
);
7868 endp
= skip_to_space (p
);
7870 marker_str
= savestring (p
, endp
- p
);
7871 old_chain
= make_cleanup (xfree
, marker_str
);
7873 markers
= target_static_tracepoint_markers_by_strid (marker_str
);
7874 if (VEC_empty(static_tracepoint_marker_p
, markers
))
7875 error (_("No known static tracepoint marker named %s"), marker_str
);
7877 sals
.nelts
= VEC_length(static_tracepoint_marker_p
, markers
);
7878 sals
.sals
= xmalloc (sizeof *sals
.sals
* sals
.nelts
);
7880 for (i
= 0; i
< sals
.nelts
; i
++)
7882 struct static_tracepoint_marker
*marker
;
7884 marker
= VEC_index (static_tracepoint_marker_p
, markers
, i
);
7886 init_sal (&sals
.sals
[i
]);
7888 sals
.sals
[i
] = find_pc_line (marker
->address
, 0);
7889 sals
.sals
[i
].pc
= marker
->address
;
7891 release_static_tracepoint_marker (marker
);
7894 do_cleanups (old_chain
);
7900 /* Set a breakpoint. This function is shared between CLI and MI
7901 functions for setting a breakpoint. This function has two major
7902 modes of operations, selected by the PARSE_CONDITION_AND_THREAD
7903 parameter. If non-zero, the function will parse arg, extracting
7904 breakpoint location, address and thread. Otherwise, ARG is just
7905 the location of breakpoint, with condition and thread specified by
7906 the COND_STRING and THREAD parameters. If INTERNAL is non-zero,
7907 the breakpoint number will be allocated from the internal
7908 breakpoint count. Returns true if any breakpoint was created;
7912 create_breakpoint (struct gdbarch
*gdbarch
,
7913 char *arg
, char *cond_string
, int thread
,
7914 int parse_condition_and_thread
,
7915 int tempflag
, enum bptype type_wanted
,
7917 enum auto_boolean pending_break_support
,
7918 struct breakpoint_ops
*ops
,
7919 int from_tty
, int enabled
, int internal
)
7921 struct gdb_exception e
;
7922 struct symtabs_and_lines sals
;
7923 struct symtab_and_line pending_sal
;
7925 char *addr_start
= arg
;
7926 struct linespec_result canonical
;
7927 struct cleanup
*old_chain
;
7928 struct cleanup
*bkpt_chain
= NULL
;
7929 struct captured_parse_breakpoint_args parse_args
;
7934 int prev_bkpt_count
= breakpoint_count
;
7938 init_linespec_result (&canonical
);
7940 parse_args
.arg_p
= &arg
;
7941 parse_args
.sals_p
= &sals
;
7942 parse_args
.canonical_p
= &canonical
;
7943 parse_args
.not_found_ptr
= ¬_found
;
7945 if (type_wanted
== bp_static_tracepoint
&& is_marker_spec (arg
))
7949 sals
= decode_static_tracepoint_spec (&arg
);
7951 copy_arg
= savestring (addr_start
, arg
- addr_start
);
7952 canonical
.canonical
= xcalloc (sals
.nelts
, sizeof (char **));
7953 for (i
= 0; i
< sals
.nelts
; i
++)
7954 canonical
.canonical
[i
] = xstrdup (copy_arg
);
7958 e
= catch_exception (uiout
, do_captured_parse_breakpoint
,
7959 &parse_args
, RETURN_MASK_ALL
);
7961 /* If caller is interested in rc value from parse, set value. */
7965 throw_exception (e
);
7969 case NOT_FOUND_ERROR
:
7971 /* If pending breakpoint support is turned off, throw
7974 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
7975 throw_exception (e
);
7977 exception_print (gdb_stderr
, e
);
7979 /* If pending breakpoint support is auto query and the user
7980 selects no, then simply return the error code. */
7981 if (pending_break_support
== AUTO_BOOLEAN_AUTO
7982 && !nquery (_("Make breakpoint pending on "
7983 "future shared library load? ")))
7986 /* At this point, either the user was queried about setting
7987 a pending breakpoint and selected yes, or pending
7988 breakpoint behavior is on and thus a pending breakpoint
7989 is defaulted on behalf of the user. */
7990 copy_arg
= xstrdup (addr_start
);
7991 canonical
.canonical
= ©_arg
;
7993 sals
.sals
= &pending_sal
;
7998 throw_exception (e
);
8008 /* Create a chain of things that always need to be cleaned up. */
8009 old_chain
= make_cleanup (null_cleanup
, 0);
8013 /* Make sure that all storage allocated to SALS gets freed. */
8014 make_cleanup (xfree
, sals
.sals
);
8016 /* Cleanup the canonical array but not its contents. */
8017 make_cleanup (xfree
, canonical
.canonical
);
8020 /* ----------------------------- SNIP -----------------------------
8021 Anything added to the cleanup chain beyond this point is assumed
8022 to be part of a breakpoint. If the breakpoint create succeeds
8023 then the memory is not reclaimed. */
8024 bkpt_chain
= make_cleanup (null_cleanup
, 0);
8026 /* Mark the contents of the canonical for cleanup. These go on
8027 the bkpt_chain and only occur if the breakpoint create fails. */
8028 for (i
= 0; i
< sals
.nelts
; i
++)
8030 if (canonical
.canonical
[i
] != NULL
)
8031 make_cleanup (xfree
, canonical
.canonical
[i
]);
8034 /* Resolve all line numbers to PC's and verify that the addresses
8035 are ok for the target. */
8037 breakpoint_sals_to_pc (&sals
);
8039 /* Fast tracepoints may have additional restrictions on location. */
8040 if (type_wanted
== bp_fast_tracepoint
)
8041 check_fast_tracepoint_sals (gdbarch
, &sals
);
8043 /* Verify that condition can be parsed, before setting any
8044 breakpoints. Allocate a separate condition expression for each
8048 if (parse_condition_and_thread
)
8050 /* Here we only parse 'arg' to separate condition
8051 from thread number, so parsing in context of first
8052 sal is OK. When setting the breakpoint we'll
8053 re-parse it in context of each sal. */
8056 find_condition_and_thread (arg
, sals
.sals
[0].pc
, &cond_string
,
8059 make_cleanup (xfree
, cond_string
);
8063 /* Create a private copy of condition string. */
8066 cond_string
= xstrdup (cond_string
);
8067 make_cleanup (xfree
, cond_string
);
8071 /* If the user is creating a static tracepoint by marker id
8072 (strace -m MARKER_ID), then store the sals index, so that
8073 breakpoint_re_set can try to match up which of the newly
8074 found markers corresponds to this one, and, don't try to
8075 expand multiple locations for each sal, given than SALS
8076 already should contain all sals for MARKER_ID. */
8077 if (type_wanted
== bp_static_tracepoint
8078 && is_marker_spec (canonical
.canonical
[0]))
8082 for (i
= 0; i
< sals
.nelts
; ++i
)
8084 struct symtabs_and_lines expanded
;
8085 struct breakpoint
*tp
;
8086 struct cleanup
*old_chain
;
8089 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
8090 expanded
.sals
[0] = sals
.sals
[i
];
8091 old_chain
= make_cleanup (xfree
, expanded
.sals
);
8093 create_breakpoint_sal (gdbarch
, expanded
, canonical
.canonical
[i
],
8094 cond_string
, type_wanted
,
8095 tempflag
? disp_del
: disp_donttouch
,
8096 thread
, task
, ignore_count
, ops
,
8097 from_tty
, enabled
, internal
,
8098 canonical
.special_display
);
8100 do_cleanups (old_chain
);
8102 /* Get the tracepoint we just created. */
8104 tp
= get_breakpoint (internal_breakpoint_number
);
8106 tp
= get_breakpoint (breakpoint_count
);
8107 gdb_assert (tp
!= NULL
);
8109 /* Given that its possible to have multiple markers with
8110 the same string id, if the user is creating a static
8111 tracepoint by marker id ("strace -m MARKER_ID"), then
8112 store the sals index, so that breakpoint_re_set can
8113 try to match up which of the newly found markers
8114 corresponds to this one */
8115 tp
->static_trace_marker_id_idx
= i
;
8119 create_breakpoints_sal (gdbarch
, sals
, &canonical
, cond_string
,
8121 tempflag
? disp_del
: disp_donttouch
,
8122 thread
, task
, ignore_count
, ops
, from_tty
,
8127 struct breakpoint
*b
;
8129 make_cleanup (xfree
, copy_arg
);
8131 b
= set_raw_breakpoint_without_location (gdbarch
, type_wanted
);
8132 set_breakpoint_number (internal
, b
);
8134 b
->addr_string
= canonical
.canonical
[0];
8135 b
->cond_string
= NULL
;
8136 b
->ignore_count
= ignore_count
;
8137 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
8138 b
->condition_not_parsed
= 1;
8140 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
8141 b
->pspace
= current_program_space
;
8142 b
->py_bp_object
= NULL
;
8144 if (enabled
&& b
->pspace
->executing_startup
8145 && (b
->type
== bp_breakpoint
8146 || b
->type
== bp_hardware_breakpoint
))
8147 b
->enable_state
= bp_startup_disabled
;
8150 /* Do not mention breakpoints with a negative number,
8151 but do notify observers. */
8152 observer_notify_breakpoint_created (b
->number
);
8159 warning (_("Multiple breakpoints were set.\nUse the "
8160 "\"delete\" command to delete unwanted breakpoints."));
8161 prev_breakpoint_count
= prev_bkpt_count
;
8164 /* That's it. Discard the cleanups for data inserted into the
8166 discard_cleanups (bkpt_chain
);
8167 /* But cleanup everything else. */
8168 do_cleanups (old_chain
);
8170 /* error call may happen here - have BKPT_CHAIN already discarded. */
8171 update_global_location_list (1);
8176 /* Set a breakpoint.
8177 ARG is a string describing breakpoint address,
8178 condition, and thread.
8179 FLAG specifies if a breakpoint is hardware on,
8180 and if breakpoint is temporary, using BP_HARDWARE_FLAG
8184 break_command_1 (char *arg
, int flag
, int from_tty
)
8186 int tempflag
= flag
& BP_TEMPFLAG
;
8187 enum bptype type_wanted
= (flag
& BP_HARDWAREFLAG
8188 ? bp_hardware_breakpoint
8191 create_breakpoint (get_current_arch (),
8193 NULL
, 0, 1 /* parse arg */,
8194 tempflag
, type_wanted
,
8195 0 /* Ignore count */,
8196 pending_break_support
,
8197 NULL
/* breakpoint_ops */,
8204 /* Helper function for break_command_1 and disassemble_command. */
8207 resolve_sal_pc (struct symtab_and_line
*sal
)
8211 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
8213 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
8214 error (_("No line %d in file \"%s\"."),
8215 sal
->line
, sal
->symtab
->filename
);
8218 /* If this SAL corresponds to a breakpoint inserted using a line
8219 number, then skip the function prologue if necessary. */
8220 if (sal
->explicit_line
)
8221 skip_prologue_sal (sal
);
8224 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
8226 struct blockvector
*bv
;
8230 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
, sal
->symtab
);
8233 sym
= block_linkage_function (b
);
8236 fixup_symbol_section (sym
, sal
->symtab
->objfile
);
8237 sal
->section
= SYMBOL_OBJ_SECTION (sym
);
8241 /* It really is worthwhile to have the section, so we'll
8242 just have to look harder. This case can be executed
8243 if we have line numbers but no functions (as can
8244 happen in assembly source). */
8246 struct minimal_symbol
*msym
;
8247 struct cleanup
*old_chain
= save_current_space_and_thread ();
8249 switch_to_program_space_and_thread (sal
->pspace
);
8251 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
8253 sal
->section
= SYMBOL_OBJ_SECTION (msym
);
8255 do_cleanups (old_chain
);
8262 break_command (char *arg
, int from_tty
)
8264 break_command_1 (arg
, 0, from_tty
);
8268 tbreak_command (char *arg
, int from_tty
)
8270 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
8274 hbreak_command (char *arg
, int from_tty
)
8276 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
8280 thbreak_command (char *arg
, int from_tty
)
8282 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
8286 stop_command (char *arg
, int from_tty
)
8288 printf_filtered (_("Specify the type of breakpoint to set.\n\
8289 Usage: stop in <function | address>\n\
8290 stop at <line>\n"));
8294 stopin_command (char *arg
, int from_tty
)
8298 if (arg
== (char *) NULL
)
8300 else if (*arg
!= '*')
8305 /* Look for a ':'. If this is a line number specification, then
8306 say it is bad, otherwise, it should be an address or
8307 function/method name. */
8308 while (*argptr
&& !hasColon
)
8310 hasColon
= (*argptr
== ':');
8315 badInput
= (*argptr
!= ':'); /* Not a class::method */
8317 badInput
= isdigit (*arg
); /* a simple line number */
8321 printf_filtered (_("Usage: stop in <function | address>\n"));
8323 break_command_1 (arg
, 0, from_tty
);
8327 stopat_command (char *arg
, int from_tty
)
8331 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
8338 /* Look for a ':'. If there is a '::' then get out, otherwise
8339 it is probably a line number. */
8340 while (*argptr
&& !hasColon
)
8342 hasColon
= (*argptr
== ':');
8347 badInput
= (*argptr
== ':'); /* we have class::method */
8349 badInput
= !isdigit (*arg
); /* not a line number */
8353 printf_filtered (_("Usage: stop at <line>\n"));
8355 break_command_1 (arg
, 0, from_tty
);
8358 /* Implement the "breakpoint_hit" breakpoint_ops method for
8359 ranged breakpoints. */
8362 breakpoint_hit_ranged_breakpoint (const struct bp_location
*bl
,
8363 struct address_space
*aspace
,
8366 return breakpoint_address_match_range (bl
->pspace
->aspace
, bl
->address
,
8367 bl
->length
, aspace
, bp_addr
);
8370 /* Implement the "resources_needed" breakpoint_ops method for
8371 ranged breakpoints. */
8374 resources_needed_ranged_breakpoint (const struct bp_location
*bl
)
8376 return target_ranged_break_num_registers ();
8379 /* Implement the "print_it" breakpoint_ops method for
8380 ranged breakpoints. */
8382 static enum print_stop_action
8383 print_it_ranged_breakpoint (struct breakpoint
*b
)
8385 struct bp_location
*bl
= b
->loc
;
8387 gdb_assert (b
->type
== bp_hardware_breakpoint
);
8389 /* Ranged breakpoints have only one location. */
8390 gdb_assert (bl
&& bl
->next
== NULL
);
8392 annotate_breakpoint (b
->number
);
8393 if (b
->disposition
== disp_del
)
8394 ui_out_text (uiout
, "\nTemporary ranged breakpoint ");
8396 ui_out_text (uiout
, "\nRanged breakpoint ");
8397 if (ui_out_is_mi_like_p (uiout
))
8399 ui_out_field_string (uiout
, "reason",
8400 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
8401 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
8403 ui_out_field_int (uiout
, "bkptno", b
->number
);
8404 ui_out_text (uiout
, ", ");
8406 return PRINT_SRC_AND_LOC
;
8409 /* Implement the "print_one" breakpoint_ops method for
8410 ranged breakpoints. */
8413 print_one_ranged_breakpoint (struct breakpoint
*b
,
8414 struct bp_location
**last_loc
)
8416 struct bp_location
*bl
= b
->loc
;
8417 struct value_print_options opts
;
8419 /* Ranged breakpoints have only one location. */
8420 gdb_assert (bl
&& bl
->next
== NULL
);
8422 get_user_print_options (&opts
);
8424 if (opts
.addressprint
)
8425 /* We don't print the address range here, it will be printed later
8426 by print_one_detail_ranged_breakpoint. */
8427 ui_out_field_skip (uiout
, "addr");
8429 print_breakpoint_location (b
, bl
);
8433 /* Implement the "print_one_detail" breakpoint_ops method for
8434 ranged breakpoints. */
8437 print_one_detail_ranged_breakpoint (const struct breakpoint
*b
,
8438 struct ui_out
*uiout
)
8440 CORE_ADDR address_start
, address_end
;
8441 struct bp_location
*bl
= b
->loc
;
8442 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
8443 struct cleanup
*cleanup
= make_cleanup_ui_out_stream_delete (stb
);
8447 address_start
= bl
->address
;
8448 address_end
= address_start
+ bl
->length
- 1;
8450 ui_out_text (uiout
, "\taddress range: ");
8451 fprintf_unfiltered (stb
->stream
, "[%s, %s]",
8452 print_core_address (bl
->gdbarch
, address_start
),
8453 print_core_address (bl
->gdbarch
, address_end
));
8454 ui_out_field_stream (uiout
, "addr", stb
);
8455 ui_out_text (uiout
, "\n");
8457 do_cleanups (cleanup
);
8460 /* Implement the "print_mention" breakpoint_ops method for
8461 ranged breakpoints. */
8464 print_mention_ranged_breakpoint (struct breakpoint
*b
)
8466 struct bp_location
*bl
= b
->loc
;
8469 gdb_assert (b
->type
== bp_hardware_breakpoint
);
8471 if (ui_out_is_mi_like_p (uiout
))
8474 printf_filtered (_("Hardware assisted ranged breakpoint %d from %s to %s."),
8475 b
->number
, paddress (bl
->gdbarch
, bl
->address
),
8476 paddress (bl
->gdbarch
, bl
->address
+ bl
->length
- 1));
8479 /* Implement the "print_recreate" breakpoint_ops method for
8480 ranged breakpoints. */
8483 print_recreate_ranged_breakpoint (struct breakpoint
*b
, struct ui_file
*fp
)
8485 fprintf_unfiltered (fp
, "break-range %s, %s", b
->addr_string
,
8486 b
->addr_string_range_end
);
8489 /* The breakpoint_ops structure to be used in ranged breakpoints. */
8491 static struct breakpoint_ops ranged_breakpoint_ops
=
8495 breakpoint_hit_ranged_breakpoint
,
8496 resources_needed_ranged_breakpoint
,
8497 print_it_ranged_breakpoint
,
8498 print_one_ranged_breakpoint
,
8499 print_one_detail_ranged_breakpoint
,
8500 print_mention_ranged_breakpoint
,
8501 print_recreate_ranged_breakpoint
8504 /* Find the address where the end of the breakpoint range should be
8505 placed, given the SAL of the end of the range. This is so that if
8506 the user provides a line number, the end of the range is set to the
8507 last instruction of the given line. */
8510 find_breakpoint_range_end (struct symtab_and_line sal
)
8514 /* If the user provided a PC value, use it. Otherwise,
8515 find the address of the end of the given location. */
8516 if (sal
.explicit_pc
)
8523 ret
= find_line_pc_range (sal
, &start
, &end
);
8525 error (_("Could not find location of the end of the range."));
8527 /* find_line_pc_range returns the start of the next line. */
8534 /* Implement the "break-range" CLI command. */
8537 break_range_command (char *arg
, int from_tty
)
8539 char *arg_start
, *addr_string_start
, *addr_string_end
;
8540 struct linespec_result canonical_start
, canonical_end
;
8541 int bp_count
, can_use_bp
, length
;
8543 struct breakpoint
*b
;
8544 struct symtab_and_line sal_start
, sal_end
;
8545 struct symtabs_and_lines sals_start
, sals_end
;
8546 struct cleanup
*cleanup_bkpt
;
8548 /* We don't support software ranged breakpoints. */
8549 if (target_ranged_break_num_registers () < 0)
8550 error (_("This target does not support hardware ranged breakpoints."));
8552 bp_count
= hw_breakpoint_used_count ();
8553 bp_count
+= target_ranged_break_num_registers ();
8554 can_use_bp
= target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
8557 error (_("Hardware breakpoints used exceeds limit."));
8559 if (arg
== NULL
|| arg
[0] == '\0')
8560 error(_("No address range specified."));
8562 sals_start
.sals
= NULL
;
8563 sals_start
.nelts
= 0;
8564 init_linespec_result (&canonical_start
);
8566 while (*arg
== ' ' || *arg
== '\t')
8569 parse_breakpoint_sals (&arg
, &sals_start
, &canonical_start
, NULL
);
8571 sal_start
= sals_start
.sals
[0];
8572 addr_string_start
= canonical_start
.canonical
[0];
8573 cleanup_bkpt
= make_cleanup (xfree
, addr_string_start
);
8574 xfree (sals_start
.sals
);
8575 xfree (canonical_start
.canonical
);
8578 error (_("Too few arguments."));
8579 else if (sals_start
.nelts
== 0)
8580 error (_("Could not find location of the beginning of the range."));
8581 else if (sals_start
.nelts
!= 1)
8582 error (_("Cannot create a ranged breakpoint with multiple locations."));
8584 resolve_sal_pc (&sal_start
);
8586 arg
++; /* Skip the comma. */
8587 while (*arg
== ' ' || *arg
== '\t')
8590 /* Parse the end location. */
8592 sals_end
.sals
= NULL
;
8594 init_linespec_result (&canonical_end
);
8597 /* We call decode_line_1 directly here instead of using
8598 parse_breakpoint_sals because we need to specify the start location's
8599 symtab and line as the default symtab and line for the end of the
8600 range. This makes it possible to have ranges like "foo.c:27, +14",
8601 where +14 means 14 lines from the start location. */
8602 sals_end
= decode_line_1 (&arg
, 1, sal_start
.symtab
, sal_start
.line
,
8603 &canonical_end
, NULL
);
8605 /* canonical_end can be NULL if it was of the form "*0xdeadbeef". */
8606 if (canonical_end
.canonical
== NULL
)
8607 canonical_end
.canonical
= xcalloc (1, sizeof (char **));
8608 /* Add the string if not present. */
8609 if (arg_start
!= arg
&& canonical_end
.canonical
[0] == NULL
)
8610 canonical_end
.canonical
[0] = savestring (arg_start
, arg
- arg_start
);
8612 sal_end
= sals_end
.sals
[0];
8613 addr_string_end
= canonical_end
.canonical
[0];
8614 make_cleanup (xfree
, addr_string_end
);
8615 xfree (sals_end
.sals
);
8616 xfree (canonical_end
.canonical
);
8618 if (sals_end
.nelts
== 0)
8619 error (_("Could not find location of the end of the range."));
8620 else if (sals_end
.nelts
!= 1)
8621 error (_("Cannot create a ranged breakpoint with multiple locations."));
8623 resolve_sal_pc (&sal_end
);
8625 end
= find_breakpoint_range_end (sal_end
);
8626 if (sal_start
.pc
> end
)
8627 error (_("Invalid address range, end preceeds start."));
8629 length
= end
- sal_start
.pc
+ 1;
8631 /* Length overflowed. */
8632 error (_("Address range too large."));
8633 else if (length
== 1)
8635 /* This range is simple enough to be handled by
8636 the `hbreak' command. */
8637 hbreak_command (addr_string_start
, 1);
8639 do_cleanups (cleanup_bkpt
);
8644 /* Now set up the breakpoint. */
8645 b
= set_raw_breakpoint (get_current_arch (), sal_start
,
8646 bp_hardware_breakpoint
);
8647 set_breakpoint_count (breakpoint_count
+ 1);
8648 b
->number
= breakpoint_count
;
8649 b
->disposition
= disp_donttouch
;
8650 b
->addr_string
= addr_string_start
;
8651 b
->addr_string_range_end
= addr_string_end
;
8652 b
->ops
= &ranged_breakpoint_ops
;
8653 b
->loc
->length
= length
;
8655 discard_cleanups (cleanup_bkpt
);
8658 update_global_location_list (1);
8661 /* Return non-zero if EXP is verified as constant. Returned zero
8662 means EXP is variable. Also the constant detection may fail for
8663 some constant expressions and in such case still falsely return
8666 watchpoint_exp_is_const (const struct expression
*exp
)
8674 /* We are only interested in the descriptor of each element. */
8675 operator_length (exp
, i
, &oplenp
, &argsp
);
8678 switch (exp
->elts
[i
].opcode
)
8688 case BINOP_LOGICAL_AND
:
8689 case BINOP_LOGICAL_OR
:
8690 case BINOP_BITWISE_AND
:
8691 case BINOP_BITWISE_IOR
:
8692 case BINOP_BITWISE_XOR
:
8694 case BINOP_NOTEQUAL
:
8710 case TERNOP_SLICE_COUNT
:
8722 case OP_OBJC_NSSTRING
:
8725 case UNOP_LOGICAL_NOT
:
8726 case UNOP_COMPLEMENT
:
8729 /* Unary, binary and ternary operators: We have to check
8730 their operands. If they are constant, then so is the
8731 result of that operation. For instance, if A and B are
8732 determined to be constants, then so is "A + B".
8734 UNOP_IND is one exception to the rule above, because the
8735 value of *ADDR is not necessarily a constant, even when
8740 /* Check whether the associated symbol is a constant.
8742 We use SYMBOL_CLASS rather than TYPE_CONST because it's
8743 possible that a buggy compiler could mark a variable as
8744 constant even when it is not, and TYPE_CONST would return
8745 true in this case, while SYMBOL_CLASS wouldn't.
8747 We also have to check for function symbols because they
8748 are always constant. */
8750 struct symbol
*s
= exp
->elts
[i
+ 2].symbol
;
8752 if (SYMBOL_CLASS (s
) != LOC_BLOCK
8753 && SYMBOL_CLASS (s
) != LOC_CONST
8754 && SYMBOL_CLASS (s
) != LOC_CONST_BYTES
)
8759 /* The default action is to return 0 because we are using
8760 the optimistic approach here: If we don't know something,
8761 then it is not a constant. */
8770 /* Implement the "insert" breakpoint_ops method for hardware watchpoints. */
8773 insert_watchpoint (struct bp_location
*bl
)
8775 int length
= bl
->owner
->exact
? 1 : bl
->length
;
8777 return target_insert_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
8778 bl
->owner
->cond_exp
);
8781 /* Implement the "remove" breakpoint_ops method for hardware watchpoints. */
8784 remove_watchpoint (struct bp_location
*bl
)
8786 int length
= bl
->owner
->exact
? 1 : bl
->length
;
8788 return target_remove_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
8789 bl
->owner
->cond_exp
);
8792 /* Implement the "resources_needed" breakpoint_ops method for
8793 hardware watchpoints. */
8796 resources_needed_watchpoint (const struct bp_location
*bl
)
8798 int length
= bl
->owner
->exact
? 1 : bl
->length
;
8800 return target_region_ok_for_hw_watchpoint (bl
->address
, length
);
8803 /* The breakpoint_ops structure to be used in hardware watchpoints. */
8805 static struct breakpoint_ops watchpoint_breakpoint_ops
=
8809 NULL
, /* breakpoint_hit */
8810 resources_needed_watchpoint
,
8811 NULL
, /* print_it */
8812 NULL
, /* print_one */
8813 NULL
, /* print_one_detail */
8814 NULL
, /* print_mention */
8815 NULL
/* print_recreate */
8818 /* accessflag: hw_write: watch write,
8819 hw_read: watch read,
8820 hw_access: watch access (read or write) */
8822 watch_command_1 (char *arg
, int accessflag
, int from_tty
,
8823 int just_location
, int internal
)
8825 struct breakpoint
*b
, *scope_breakpoint
= NULL
;
8826 struct expression
*exp
;
8827 struct block
*exp_valid_block
= NULL
, *cond_exp_valid_block
= NULL
;
8828 struct value
*val
, *mark
, *result
;
8829 struct frame_info
*frame
;
8830 char *exp_start
= NULL
;
8831 char *exp_end
= NULL
;
8832 char *tok
, *id_tok_start
, *end_tok
;
8834 char *cond_start
= NULL
;
8835 char *cond_end
= NULL
;
8836 int i
, other_type_used
, target_resources_ok
= 0;
8837 enum bptype bp_type
;
8842 /* Make sure that we actually have parameters to parse. */
8843 if (arg
!= NULL
&& arg
[0] != '\0')
8845 toklen
= strlen (arg
); /* Size of argument list. */
8847 /* Points tok to the end of the argument list. */
8848 tok
= arg
+ toklen
- 1;
8850 /* Go backwards in the parameters list. Skip the last
8851 parameter. If we're expecting a 'thread <thread_num>'
8852 parameter, this should be the thread identifier. */
8853 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
8855 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
8858 /* Points end_tok to the beginning of the last token. */
8859 id_tok_start
= tok
+ 1;
8861 /* Go backwards in the parameters list. Skip one more
8862 parameter. If we're expecting a 'thread <thread_num>'
8863 parameter, we should reach a "thread" token. */
8864 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
8869 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
8872 /* Move the pointer forward to skip the whitespace and
8873 calculate the length of the token. */
8875 toklen
= end_tok
- tok
;
8877 if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
8879 /* At this point we've found a "thread" token, which means
8880 the user is trying to set a watchpoint that triggers
8881 only in a specific thread. */
8884 /* Extract the thread ID from the next token. */
8885 thread
= strtol (id_tok_start
, &endp
, 0);
8887 /* Check if the user provided a valid numeric value for the
8889 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
8890 error (_("Invalid thread ID specification %s."), id_tok_start
);
8892 /* Check if the thread actually exists. */
8893 if (!valid_thread_id (thread
))
8894 error (_("Unknown thread %d."), thread
);
8896 /* Truncate the string and get rid of the thread <thread_num>
8897 parameter before the parameter list is parsed by the
8898 evaluate_expression() function. */
8903 /* Parse the rest of the arguments. */
8904 innermost_block
= NULL
;
8906 exp
= parse_exp_1 (&arg
, 0, 0);
8908 /* Remove trailing whitespace from the expression before saving it.
8909 This makes the eventual display of the expression string a bit
8911 while (exp_end
> exp_start
&& (exp_end
[-1] == ' ' || exp_end
[-1] == '\t'))
8914 /* Checking if the expression is not constant. */
8915 if (watchpoint_exp_is_const (exp
))
8919 len
= exp_end
- exp_start
;
8920 while (len
> 0 && isspace (exp_start
[len
- 1]))
8922 error (_("Cannot watch constant value `%.*s'."), len
, exp_start
);
8925 exp_valid_block
= innermost_block
;
8926 mark
= value_mark ();
8927 fetch_subexp_value (exp
, &pc
, &val
, &result
, NULL
);
8931 exp_valid_block
= NULL
;
8932 val
= value_addr (result
);
8933 release_value (val
);
8934 value_free_to_mark (mark
);
8936 else if (val
!= NULL
)
8937 release_value (val
);
8939 tok
= skip_spaces (arg
);
8940 end_tok
= skip_to_space (tok
);
8942 toklen
= end_tok
- tok
;
8943 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
8945 struct expression
*cond
;
8947 innermost_block
= NULL
;
8948 tok
= cond_start
= end_tok
+ 1;
8949 cond
= parse_exp_1 (&tok
, 0, 0);
8951 /* The watchpoint expression may not be local, but the condition
8952 may still be. E.g.: `watch global if local > 0'. */
8953 cond_exp_valid_block
= innermost_block
;
8959 error (_("Junk at end of command."));
8961 if (accessflag
== hw_read
)
8962 bp_type
= bp_read_watchpoint
;
8963 else if (accessflag
== hw_access
)
8964 bp_type
= bp_access_watchpoint
;
8966 bp_type
= bp_hardware_watchpoint
;
8968 reg_cnt
= can_use_hardware_watchpoint (val
, target_exact_watchpoints
);
8969 if (reg_cnt
== 0 && bp_type
!= bp_hardware_watchpoint
)
8970 error (_("Expression cannot be implemented with read/access watchpoint."));
8973 i
= hw_watchpoint_used_count (bp_type
, &other_type_used
);
8974 target_resources_ok
=
8975 target_can_use_hardware_watchpoint (bp_type
, i
+ reg_cnt
,
8977 if (target_resources_ok
== 0 && bp_type
!= bp_hardware_watchpoint
)
8978 error (_("Target does not support this type of hardware watchpoint."));
8980 if (target_resources_ok
< 0 && bp_type
!= bp_hardware_watchpoint
)
8981 error (_("Target can only support one kind "
8982 "of HW watchpoint at a time."));
8985 /* Change the type of breakpoint to an ordinary watchpoint if a
8986 hardware watchpoint could not be set. */
8987 if (!reg_cnt
|| target_resources_ok
<= 0)
8988 bp_type
= bp_watchpoint
;
8990 frame
= block_innermost_frame (exp_valid_block
);
8992 /* If the expression is "local", then set up a "watchpoint scope"
8993 breakpoint at the point where we've left the scope of the watchpoint
8994 expression. Create the scope breakpoint before the watchpoint, so
8995 that we will encounter it first in bpstat_stop_status. */
8996 if (exp_valid_block
&& frame
)
8998 if (frame_id_p (frame_unwind_caller_id (frame
)))
9001 = create_internal_breakpoint (frame_unwind_caller_arch (frame
),
9002 frame_unwind_caller_pc (frame
),
9003 bp_watchpoint_scope
);
9005 scope_breakpoint
->enable_state
= bp_enabled
;
9007 /* Automatically delete the breakpoint when it hits. */
9008 scope_breakpoint
->disposition
= disp_del
;
9010 /* Only break in the proper frame (help with recursion). */
9011 scope_breakpoint
->frame_id
= frame_unwind_caller_id (frame
);
9013 /* Set the address at which we will stop. */
9014 scope_breakpoint
->loc
->gdbarch
9015 = frame_unwind_caller_arch (frame
);
9016 scope_breakpoint
->loc
->requested_address
9017 = frame_unwind_caller_pc (frame
);
9018 scope_breakpoint
->loc
->address
9019 = adjust_breakpoint_address (scope_breakpoint
->loc
->gdbarch
,
9020 scope_breakpoint
->loc
->requested_address
,
9021 scope_breakpoint
->type
);
9025 /* Now set up the breakpoint. */
9026 b
= set_raw_breakpoint_without_location (NULL
, bp_type
);
9027 set_breakpoint_number (internal
, b
);
9029 b
->disposition
= disp_donttouch
;
9031 b
->exp_valid_block
= exp_valid_block
;
9032 b
->cond_exp_valid_block
= cond_exp_valid_block
;
9035 struct type
*t
= value_type (val
);
9036 CORE_ADDR addr
= value_as_address (val
);
9039 t
= check_typedef (TYPE_TARGET_TYPE (check_typedef (t
)));
9040 name
= type_to_string (t
);
9042 b
->exp_string_reparse
= xstrprintf ("* (%s *) %s", name
,
9043 core_addr_to_string (addr
));
9046 b
->exp_string
= xstrprintf ("-location: %.*s",
9047 (int) (exp_end
- exp_start
), exp_start
);
9049 /* The above expression is in C. */
9050 b
->language
= language_c
;
9053 b
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
9056 b
->ops
= &watchpoint_breakpoint_ops
;
9058 /* Use an exact watchpoint when there's only one memory region to be
9059 watched, and only one debug register is needed to watch it. */
9060 b
->exact
= target_exact_watchpoints
&& reg_cnt
== 1;
9063 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
9069 b
->watchpoint_frame
= get_frame_id (frame
);
9070 b
->watchpoint_thread
= inferior_ptid
;
9074 b
->watchpoint_frame
= null_frame_id
;
9075 b
->watchpoint_thread
= null_ptid
;
9078 if (scope_breakpoint
!= NULL
)
9080 /* The scope breakpoint is related to the watchpoint. We will
9081 need to act on them together. */
9082 b
->related_breakpoint
= scope_breakpoint
;
9083 scope_breakpoint
->related_breakpoint
= b
;
9087 value_free_to_mark (mark
);
9089 /* Finally update the new watchpoint. This creates the locations
9090 that should be inserted. */
9091 update_watchpoint (b
, 1);
9093 /* Do not mention breakpoints with a negative number, but do
9094 notify observers. */
9095 observer_notify_breakpoint_created (b
->number
);
9098 update_global_location_list (1);
9101 /* Return count of debug registers needed to watch the given expression.
9102 If EXACT_WATCHPOINTS is 1, then consider that only the address of
9103 the start of the watched region will be monitored (i.e., all accesses
9104 will be aligned). This uses less debug registers on some targets.
9106 If the watchpoint cannot be handled in hardware return zero. */
9109 can_use_hardware_watchpoint (struct value
*v
, int exact_watchpoints
)
9111 int found_memory_cnt
= 0;
9112 struct value
*head
= v
;
9114 /* Did the user specifically forbid us to use hardware watchpoints? */
9115 if (!can_use_hw_watchpoints
)
9118 /* Make sure that the value of the expression depends only upon
9119 memory contents, and values computed from them within GDB. If we
9120 find any register references or function calls, we can't use a
9121 hardware watchpoint.
9123 The idea here is that evaluating an expression generates a series
9124 of values, one holding the value of every subexpression. (The
9125 expression a*b+c has five subexpressions: a, b, a*b, c, and
9126 a*b+c.) GDB's values hold almost enough information to establish
9127 the criteria given above --- they identify memory lvalues,
9128 register lvalues, computed values, etcetera. So we can evaluate
9129 the expression, and then scan the chain of values that leaves
9130 behind to decide whether we can detect any possible change to the
9131 expression's final value using only hardware watchpoints.
9133 However, I don't think that the values returned by inferior
9134 function calls are special in any way. So this function may not
9135 notice that an expression involving an inferior function call
9136 can't be watched with hardware watchpoints. FIXME. */
9137 for (; v
; v
= value_next (v
))
9139 if (VALUE_LVAL (v
) == lval_memory
)
9141 if (v
!= head
&& value_lazy (v
))
9142 /* A lazy memory lvalue in the chain is one that GDB never
9143 needed to fetch; we either just used its address (e.g.,
9144 `a' in `a.b') or we never needed it at all (e.g., `a'
9145 in `a,b'). This doesn't apply to HEAD; if that is
9146 lazy then it was not readable, but watch it anyway. */
9150 /* Ahh, memory we actually used! Check if we can cover
9151 it with hardware watchpoints. */
9152 struct type
*vtype
= check_typedef (value_type (v
));
9154 /* We only watch structs and arrays if user asked for it
9155 explicitly, never if they just happen to appear in a
9156 middle of some value chain. */
9158 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
9159 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
9161 CORE_ADDR vaddr
= value_address (v
);
9165 len
= (exact_watchpoints
9166 && is_scalar_type_recursive (vtype
))?
9167 1 : TYPE_LENGTH (value_type (v
));
9169 num_regs
= target_region_ok_for_hw_watchpoint (vaddr
, len
);
9173 found_memory_cnt
+= num_regs
;
9177 else if (VALUE_LVAL (v
) != not_lval
9178 && deprecated_value_modifiable (v
) == 0)
9179 return 0; /* These are values from the history (e.g., $1). */
9180 else if (VALUE_LVAL (v
) == lval_register
)
9181 return 0; /* Cannot watch a register with a HW watchpoint. */
9184 /* The expression itself looks suitable for using a hardware
9185 watchpoint, but give the target machine a chance to reject it. */
9186 return found_memory_cnt
;
9190 watch_command_wrapper (char *arg
, int from_tty
, int internal
)
9192 watch_command_1 (arg
, hw_write
, from_tty
, 0, internal
);
9195 /* A helper function that looks for an argument at the start of a
9196 string. The argument must also either be at the end of the string,
9197 or be followed by whitespace. Returns 1 if it finds the argument,
9198 0 otherwise. If the argument is found, it updates *STR. */
9201 check_for_argument (char **str
, char *arg
, int arg_len
)
9203 if (strncmp (*str
, arg
, arg_len
) == 0
9204 && ((*str
)[arg_len
] == '\0' || isspace ((*str
)[arg_len
])))
9212 /* A helper function that looks for the "-location" argument and then
9213 calls watch_command_1. */
9216 watch_maybe_just_location (char *arg
, int accessflag
, int from_tty
)
9218 int just_location
= 0;
9221 && (check_for_argument (&arg
, "-location", sizeof ("-location") - 1)
9222 || check_for_argument (&arg
, "-l", sizeof ("-l") - 1)))
9224 arg
= skip_spaces (arg
);
9228 watch_command_1 (arg
, accessflag
, from_tty
, just_location
, 0);
9232 watch_command (char *arg
, int from_tty
)
9234 watch_maybe_just_location (arg
, hw_write
, from_tty
);
9238 rwatch_command_wrapper (char *arg
, int from_tty
, int internal
)
9240 watch_command_1 (arg
, hw_read
, from_tty
, 0, internal
);
9244 rwatch_command (char *arg
, int from_tty
)
9246 watch_maybe_just_location (arg
, hw_read
, from_tty
);
9250 awatch_command_wrapper (char *arg
, int from_tty
, int internal
)
9252 watch_command_1 (arg
, hw_access
, from_tty
, 0, internal
);
9256 awatch_command (char *arg
, int from_tty
)
9258 watch_maybe_just_location (arg
, hw_access
, from_tty
);
9262 /* Helper routines for the until_command routine in infcmd.c. Here
9263 because it uses the mechanisms of breakpoints. */
9265 struct until_break_command_continuation_args
9267 struct breakpoint
*breakpoint
;
9268 struct breakpoint
*breakpoint2
;
9272 /* This function is called by fetch_inferior_event via the
9273 cmd_continuation pointer, to complete the until command. It takes
9274 care of cleaning up the temporary breakpoints set up by the until
9277 until_break_command_continuation (void *arg
)
9279 struct until_break_command_continuation_args
*a
= arg
;
9281 delete_breakpoint (a
->breakpoint
);
9283 delete_breakpoint (a
->breakpoint2
);
9284 delete_longjmp_breakpoint (a
->thread_num
);
9288 until_break_command (char *arg
, int from_tty
, int anywhere
)
9290 struct symtabs_and_lines sals
;
9291 struct symtab_and_line sal
;
9292 struct frame_info
*frame
= get_selected_frame (NULL
);
9293 struct breakpoint
*breakpoint
;
9294 struct breakpoint
*breakpoint2
= NULL
;
9295 struct cleanup
*old_chain
;
9297 struct thread_info
*tp
;
9299 clear_proceed_status ();
9301 /* Set a breakpoint where the user wants it and at return from
9304 if (default_breakpoint_valid
)
9305 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
9306 default_breakpoint_line
, NULL
, NULL
);
9308 sals
= decode_line_1 (&arg
, 1, (struct symtab
*) NULL
, 0, NULL
, NULL
);
9310 if (sals
.nelts
!= 1)
9311 error (_("Couldn't get information on specified line."));
9314 xfree (sals
.sals
); /* malloc'd, so freed. */
9317 error (_("Junk at end of arguments."));
9319 resolve_sal_pc (&sal
);
9322 /* If the user told us to continue until a specified location,
9323 we don't specify a frame at which we need to stop. */
9324 breakpoint
= set_momentary_breakpoint (get_frame_arch (frame
), sal
,
9325 null_frame_id
, bp_until
);
9327 /* Otherwise, specify the selected frame, because we want to stop
9328 only at the very same frame. */
9329 breakpoint
= set_momentary_breakpoint (get_frame_arch (frame
), sal
,
9330 get_stack_frame_id (frame
),
9333 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
9335 tp
= inferior_thread ();
9338 /* Keep within the current frame, or in frames called by the current
9341 if (frame_id_p (frame_unwind_caller_id (frame
)))
9343 sal
= find_pc_line (frame_unwind_caller_pc (frame
), 0);
9344 sal
.pc
= frame_unwind_caller_pc (frame
);
9345 breakpoint2
= set_momentary_breakpoint (frame_unwind_caller_arch (frame
),
9347 frame_unwind_caller_id (frame
),
9349 make_cleanup_delete_breakpoint (breakpoint2
);
9351 set_longjmp_breakpoint (tp
, frame_unwind_caller_id (frame
));
9352 make_cleanup (delete_longjmp_breakpoint_cleanup
, &thread
);
9355 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
9357 /* If we are running asynchronously, and proceed call above has
9358 actually managed to start the target, arrange for breakpoints to
9359 be deleted when the target stops. Otherwise, we're already
9360 stopped and delete breakpoints via cleanup chain. */
9362 if (target_can_async_p () && is_running (inferior_ptid
))
9364 struct until_break_command_continuation_args
*args
;
9365 args
= xmalloc (sizeof (*args
));
9367 args
->breakpoint
= breakpoint
;
9368 args
->breakpoint2
= breakpoint2
;
9369 args
->thread_num
= thread
;
9371 discard_cleanups (old_chain
);
9372 add_continuation (inferior_thread (),
9373 until_break_command_continuation
, args
,
9377 do_cleanups (old_chain
);
9380 /* This function attempts to parse an optional "if <cond>" clause
9381 from the arg string. If one is not found, it returns NULL.
9383 Else, it returns a pointer to the condition string. (It does not
9384 attempt to evaluate the string against a particular block.) And,
9385 it updates arg to point to the first character following the parsed
9386 if clause in the arg string. */
9389 ep_parse_optional_if_clause (char **arg
)
9393 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
9396 /* Skip the "if" keyword. */
9399 /* Skip any extra leading whitespace, and record the start of the
9400 condition string. */
9401 *arg
= skip_spaces (*arg
);
9404 /* Assume that the condition occupies the remainder of the arg
9406 (*arg
) += strlen (cond_string
);
9411 /* Commands to deal with catching events, such as signals, exceptions,
9412 process start/exit, etc. */
9416 catch_fork_temporary
, catch_vfork_temporary
,
9417 catch_fork_permanent
, catch_vfork_permanent
9422 catch_fork_command_1 (char *arg
, int from_tty
,
9423 struct cmd_list_element
*command
)
9425 struct gdbarch
*gdbarch
= get_current_arch ();
9426 char *cond_string
= NULL
;
9427 catch_fork_kind fork_kind
;
9430 fork_kind
= (catch_fork_kind
) (uintptr_t) get_cmd_context (command
);
9431 tempflag
= (fork_kind
== catch_fork_temporary
9432 || fork_kind
== catch_vfork_temporary
);
9436 arg
= skip_spaces (arg
);
9438 /* The allowed syntax is:
9440 catch [v]fork if <cond>
9442 First, check if there's an if clause. */
9443 cond_string
= ep_parse_optional_if_clause (&arg
);
9445 if ((*arg
!= '\0') && !isspace (*arg
))
9446 error (_("Junk at end of arguments."));
9448 /* If this target supports it, create a fork or vfork catchpoint
9449 and enable reporting of such events. */
9452 case catch_fork_temporary
:
9453 case catch_fork_permanent
:
9454 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
9455 &catch_fork_breakpoint_ops
);
9457 case catch_vfork_temporary
:
9458 case catch_vfork_permanent
:
9459 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
9460 &catch_vfork_breakpoint_ops
);
9463 error (_("unsupported or unknown fork kind; cannot catch it"));
9469 catch_exec_command_1 (char *arg
, int from_tty
,
9470 struct cmd_list_element
*command
)
9472 struct gdbarch
*gdbarch
= get_current_arch ();
9474 char *cond_string
= NULL
;
9476 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
9480 arg
= skip_spaces (arg
);
9482 /* The allowed syntax is:
9484 catch exec if <cond>
9486 First, check if there's an if clause. */
9487 cond_string
= ep_parse_optional_if_clause (&arg
);
9489 if ((*arg
!= '\0') && !isspace (*arg
))
9490 error (_("Junk at end of arguments."));
9492 /* If this target supports it, create an exec catchpoint
9493 and enable reporting of such events. */
9494 create_catchpoint (gdbarch
, tempflag
, cond_string
,
9495 &catch_exec_breakpoint_ops
);
9498 static enum print_stop_action
9499 print_exception_catchpoint (struct breakpoint
*b
)
9501 int bp_temp
, bp_throw
;
9503 annotate_catchpoint (b
->number
);
9505 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
9506 if (b
->loc
->address
!= b
->loc
->requested_address
)
9507 breakpoint_adjustment_warning (b
->loc
->requested_address
,
9510 bp_temp
= b
->disposition
== disp_del
;
9512 bp_temp
? "Temporary catchpoint "
9514 if (!ui_out_is_mi_like_p (uiout
))
9515 ui_out_field_int (uiout
, "bkptno", b
->number
);
9517 bp_throw
? " (exception thrown), "
9518 : " (exception caught), ");
9519 if (ui_out_is_mi_like_p (uiout
))
9521 ui_out_field_string (uiout
, "reason",
9522 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
9523 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
9524 ui_out_field_int (uiout
, "bkptno", b
->number
);
9526 return PRINT_SRC_AND_LOC
;
9530 print_one_exception_catchpoint (struct breakpoint
*b
,
9531 struct bp_location
**last_loc
)
9533 struct value_print_options opts
;
9535 get_user_print_options (&opts
);
9536 if (opts
.addressprint
)
9539 if (b
->loc
== NULL
|| b
->loc
->shlib_disabled
)
9540 ui_out_field_string (uiout
, "addr", "<PENDING>");
9542 ui_out_field_core_addr (uiout
, "addr",
9543 b
->loc
->gdbarch
, b
->loc
->address
);
9548 if (strstr (b
->addr_string
, "throw") != NULL
)
9549 ui_out_field_string (uiout
, "what", "exception throw");
9551 ui_out_field_string (uiout
, "what", "exception catch");
9555 print_mention_exception_catchpoint (struct breakpoint
*b
)
9560 bp_temp
= b
->disposition
== disp_del
;
9561 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
9562 ui_out_text (uiout
, bp_temp
? _("Temporary catchpoint ")
9563 : _("Catchpoint "));
9564 ui_out_field_int (uiout
, "bkptno", b
->number
);
9565 ui_out_text (uiout
, bp_throw
? _(" (throw)")
9569 /* Implement the "print_recreate" breakpoint_ops method for throw and
9570 catch catchpoints. */
9573 print_recreate_exception_catchpoint (struct breakpoint
*b
,
9579 bp_temp
= b
->disposition
== disp_del
;
9580 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
9581 fprintf_unfiltered (fp
, bp_temp
? "tcatch " : "catch ");
9582 fprintf_unfiltered (fp
, bp_throw
? "throw" : "catch");
9585 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops
= {
9588 NULL
, /* breakpoint_hit */
9589 NULL
, /* resources_needed */
9590 print_exception_catchpoint
,
9591 print_one_exception_catchpoint
,
9592 NULL
, /* print_one_detail */
9593 print_mention_exception_catchpoint
,
9594 print_recreate_exception_catchpoint
9598 handle_gnu_v3_exceptions (int tempflag
, char *cond_string
,
9599 enum exception_event_kind ex_event
, int from_tty
)
9601 char *trigger_func_name
;
9603 if (ex_event
== EX_EVENT_CATCH
)
9604 trigger_func_name
= "__cxa_begin_catch";
9606 trigger_func_name
= "__cxa_throw";
9608 create_breakpoint (get_current_arch (),
9609 trigger_func_name
, cond_string
, -1,
9610 0 /* condition and thread are valid. */,
9611 tempflag
, bp_breakpoint
,
9613 AUTO_BOOLEAN_TRUE
/* pending */,
9614 &gnu_v3_exception_catchpoint_ops
, from_tty
,
9621 /* Deal with "catch catch" and "catch throw" commands. */
9624 catch_exception_command_1 (enum exception_event_kind ex_event
, char *arg
,
9625 int tempflag
, int from_tty
)
9627 char *cond_string
= NULL
;
9631 arg
= skip_spaces (arg
);
9633 cond_string
= ep_parse_optional_if_clause (&arg
);
9635 if ((*arg
!= '\0') && !isspace (*arg
))
9636 error (_("Junk at end of arguments."));
9638 if (ex_event
!= EX_EVENT_THROW
9639 && ex_event
!= EX_EVENT_CATCH
)
9640 error (_("Unsupported or unknown exception event; cannot catch it"));
9642 if (handle_gnu_v3_exceptions (tempflag
, cond_string
, ex_event
, from_tty
))
9645 warning (_("Unsupported with this platform/compiler combination."));
9648 /* Implementation of "catch catch" command. */
9651 catch_catch_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
9653 int tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
9655 catch_exception_command_1 (EX_EVENT_CATCH
, arg
, tempflag
, from_tty
);
9658 /* Implementation of "catch throw" command. */
9661 catch_throw_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
9663 int tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
9665 catch_exception_command_1 (EX_EVENT_THROW
, arg
, tempflag
, from_tty
);
9668 /* Create a breakpoint struct for Ada exception catchpoints. */
9671 create_ada_exception_breakpoint (struct gdbarch
*gdbarch
,
9672 struct symtab_and_line sal
,
9676 struct expression
*cond
,
9677 struct breakpoint_ops
*ops
,
9681 struct breakpoint
*b
;
9685 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
9687 loc_gdbarch
= gdbarch
;
9689 describe_other_breakpoints (loc_gdbarch
,
9690 sal
.pspace
, sal
.pc
, sal
.section
, -1);
9691 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
9692 version for exception catchpoints, because two catchpoints
9693 used for different exception names will use the same address.
9694 In this case, a "breakpoint ... also set at..." warning is
9695 unproductive. Besides, the warning phrasing is also a bit
9696 inapropriate, we should use the word catchpoint, and tell
9697 the user what type of catchpoint it is. The above is good
9698 enough for now, though. */
9701 b
= set_raw_breakpoint (gdbarch
, sal
, bp_breakpoint
);
9702 set_breakpoint_count (breakpoint_count
+ 1);
9704 b
->enable_state
= bp_enabled
;
9705 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
9706 b
->number
= breakpoint_count
;
9707 b
->ignore_count
= 0;
9708 b
->loc
->cond
= cond
;
9709 b
->addr_string
= addr_string
;
9710 b
->language
= language_ada
;
9711 b
->cond_string
= cond_string
;
9712 b
->exp_string
= exp_string
;
9717 update_global_location_list (1);
9720 /* Implement the "catch exception" command. */
9723 catch_ada_exception_command (char *arg
, int from_tty
,
9724 struct cmd_list_element
*command
)
9726 struct gdbarch
*gdbarch
= get_current_arch ();
9728 struct symtab_and_line sal
;
9729 char *addr_string
= NULL
;
9730 char *exp_string
= NULL
;
9731 char *cond_string
= NULL
;
9732 struct expression
*cond
= NULL
;
9733 struct breakpoint_ops
*ops
= NULL
;
9735 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
9739 sal
= ada_decode_exception_location (arg
, &addr_string
, &exp_string
,
9740 &cond_string
, &cond
, &ops
);
9741 create_ada_exception_breakpoint (gdbarch
, sal
, addr_string
, exp_string
,
9742 cond_string
, cond
, ops
, tempflag
,
9746 /* Cleanup function for a syscall filter list. */
9748 clean_up_filters (void *arg
)
9750 VEC(int) *iter
= *(VEC(int) **) arg
;
9751 VEC_free (int, iter
);
9754 /* Splits the argument using space as delimiter. Returns an xmalloc'd
9755 filter list, or NULL if no filtering is required. */
9757 catch_syscall_split_args (char *arg
)
9759 VEC(int) *result
= NULL
;
9760 struct cleanup
*cleanup
= make_cleanup (clean_up_filters
, &result
);
9762 while (*arg
!= '\0')
9764 int i
, syscall_number
;
9769 /* Skip whitespace. */
9770 while (isspace (*arg
))
9773 for (i
= 0; i
< 127 && arg
[i
] && !isspace (arg
[i
]); ++i
)
9774 cur_name
[i
] = arg
[i
];
9778 /* Check if the user provided a syscall name or a number. */
9779 syscall_number
= (int) strtol (cur_name
, &endptr
, 0);
9780 if (*endptr
== '\0')
9781 get_syscall_by_number (syscall_number
, &s
);
9784 /* We have a name. Let's check if it's valid and convert it
9786 get_syscall_by_name (cur_name
, &s
);
9788 if (s
.number
== UNKNOWN_SYSCALL
)
9789 /* Here we have to issue an error instead of a warning,
9790 because GDB cannot do anything useful if there's no
9791 syscall number to be caught. */
9792 error (_("Unknown syscall name '%s'."), cur_name
);
9795 /* Ok, it's valid. */
9796 VEC_safe_push (int, result
, s
.number
);
9799 discard_cleanups (cleanup
);
9803 /* Implement the "catch syscall" command. */
9806 catch_syscall_command_1 (char *arg
, int from_tty
,
9807 struct cmd_list_element
*command
)
9812 struct gdbarch
*gdbarch
= get_current_arch ();
9814 /* Checking if the feature if supported. */
9815 if (gdbarch_get_syscall_number_p (gdbarch
) == 0)
9816 error (_("The feature 'catch syscall' is not supported on \
9817 this architecture yet."));
9819 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
9821 arg
= skip_spaces (arg
);
9823 /* We need to do this first "dummy" translation in order
9824 to get the syscall XML file loaded or, most important,
9825 to display a warning to the user if there's no XML file
9826 for his/her architecture. */
9827 get_syscall_by_number (0, &s
);
9829 /* The allowed syntax is:
9831 catch syscall <name | number> [<name | number> ... <name | number>]
9833 Let's check if there's a syscall name. */
9836 filter
= catch_syscall_split_args (arg
);
9840 create_syscall_event_catchpoint (tempflag
, filter
,
9841 &catch_syscall_breakpoint_ops
);
9844 /* Implement the "catch assert" command. */
9847 catch_assert_command (char *arg
, int from_tty
,
9848 struct cmd_list_element
*command
)
9850 struct gdbarch
*gdbarch
= get_current_arch ();
9852 struct symtab_and_line sal
;
9853 char *addr_string
= NULL
;
9854 struct breakpoint_ops
*ops
= NULL
;
9856 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
9860 sal
= ada_decode_assert_location (arg
, &addr_string
, &ops
);
9861 create_ada_exception_breakpoint (gdbarch
, sal
, addr_string
, NULL
, NULL
, NULL
,
9862 ops
, tempflag
, from_tty
);
9866 catch_command (char *arg
, int from_tty
)
9868 error (_("Catch requires an event name."));
9873 tcatch_command (char *arg
, int from_tty
)
9875 error (_("Catch requires an event name."));
9878 /* Delete breakpoints by address or line. */
9881 clear_command (char *arg
, int from_tty
)
9883 struct breakpoint
*b
;
9884 VEC(breakpoint_p
) *found
= 0;
9887 struct symtabs_and_lines sals
;
9888 struct symtab_and_line sal
;
9893 sals
= decode_line_spec (arg
, 1);
9898 sals
.sals
= (struct symtab_and_line
*)
9899 xmalloc (sizeof (struct symtab_and_line
));
9900 make_cleanup (xfree
, sals
.sals
);
9901 init_sal (&sal
); /* Initialize to zeroes. */
9902 sal
.line
= default_breakpoint_line
;
9903 sal
.symtab
= default_breakpoint_symtab
;
9904 sal
.pc
= default_breakpoint_address
;
9905 sal
.pspace
= default_breakpoint_pspace
;
9906 if (sal
.symtab
== 0)
9907 error (_("No source file specified."));
9915 /* We don't call resolve_sal_pc here. That's not as bad as it
9916 seems, because all existing breakpoints typically have both
9917 file/line and pc set. So, if clear is given file/line, we can
9918 match this to existing breakpoint without obtaining pc at all.
9920 We only support clearing given the address explicitly
9921 present in breakpoint table. Say, we've set breakpoint
9922 at file:line. There were several PC values for that file:line,
9923 due to optimization, all in one block.
9925 We've picked one PC value. If "clear" is issued with another
9926 PC corresponding to the same file:line, the breakpoint won't
9927 be cleared. We probably can still clear the breakpoint, but
9928 since the other PC value is never presented to user, user
9929 can only find it by guessing, and it does not seem important
9932 /* For each line spec given, delete bps which correspond to it. Do
9933 it in two passes, solely to preserve the current behavior that
9934 from_tty is forced true if we delete more than one
9938 for (i
= 0; i
< sals
.nelts
; i
++)
9940 /* If exact pc given, clear bpts at that pc.
9941 If line given (pc == 0), clear all bpts on specified line.
9942 If defaulting, clear all bpts on default line
9945 defaulting sal.pc != 0 tests to do
9950 1 0 <can't happen> */
9954 /* Find all matching breakpoints and add them to 'found'. */
9958 /* Are we going to delete b? */
9959 if (b
->type
!= bp_none
&& !is_watchpoint (b
))
9961 struct bp_location
*loc
= b
->loc
;
9962 for (; loc
; loc
= loc
->next
)
9964 int pc_match
= sal
.pc
9965 && (loc
->pspace
== sal
.pspace
)
9966 && (loc
->address
== sal
.pc
)
9967 && (!section_is_overlay (loc
->section
)
9968 || loc
->section
== sal
.section
);
9969 int line_match
= ((default_match
|| (0 == sal
.pc
))
9970 && b
->source_file
!= NULL
9971 && sal
.symtab
!= NULL
9972 && sal
.pspace
== loc
->pspace
9973 && filename_cmp (b
->source_file
,
9974 sal
.symtab
->filename
) == 0
9975 && b
->line_number
== sal
.line
);
9976 if (pc_match
|| line_match
)
9985 VEC_safe_push(breakpoint_p
, found
, b
);
9988 /* Now go thru the 'found' chain and delete them. */
9989 if (VEC_empty(breakpoint_p
, found
))
9992 error (_("No breakpoint at %s."), arg
);
9994 error (_("No breakpoint at this line."));
9997 if (VEC_length(breakpoint_p
, found
) > 1)
9998 from_tty
= 1; /* Always report if deleted more than one. */
10001 if (VEC_length(breakpoint_p
, found
) == 1)
10002 printf_unfiltered (_("Deleted breakpoint "));
10004 printf_unfiltered (_("Deleted breakpoints "));
10006 breakpoints_changed ();
10008 for (ix
= 0; VEC_iterate(breakpoint_p
, found
, ix
, b
); ix
++)
10011 printf_unfiltered ("%d ", b
->number
);
10012 delete_breakpoint (b
);
10015 putchar_unfiltered ('\n');
10018 /* Delete breakpoint in BS if they are `delete' breakpoints and
10019 all breakpoints that are marked for deletion, whether hit or not.
10020 This is called after any breakpoint is hit, or after errors. */
10023 breakpoint_auto_delete (bpstat bs
)
10025 struct breakpoint
*b
, *b_tmp
;
10027 for (; bs
; bs
= bs
->next
)
10028 if (bs
->breakpoint_at
10029 && bs
->breakpoint_at
->disposition
== disp_del
10031 delete_breakpoint (bs
->breakpoint_at
);
10033 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
10035 if (b
->disposition
== disp_del_at_next_stop
)
10036 delete_breakpoint (b
);
10040 /* A comparison function for bp_location AP and BP being interfaced to
10041 qsort. Sort elements primarily by their ADDRESS (no matter what
10042 does breakpoint_address_is_meaningful say for its OWNER),
10043 secondarily by ordering first bp_permanent OWNERed elements and
10044 terciarily just ensuring the array is sorted stable way despite
10045 qsort being an instable algorithm. */
10048 bp_location_compare (const void *ap
, const void *bp
)
10050 struct bp_location
*a
= *(void **) ap
;
10051 struct bp_location
*b
= *(void **) bp
;
10052 /* A and B come from existing breakpoints having non-NULL OWNER. */
10053 int a_perm
= a
->owner
->enable_state
== bp_permanent
;
10054 int b_perm
= b
->owner
->enable_state
== bp_permanent
;
10056 if (a
->address
!= b
->address
)
10057 return (a
->address
> b
->address
) - (a
->address
< b
->address
);
10059 /* Sort permanent breakpoints first. */
10060 if (a_perm
!= b_perm
)
10061 return (a_perm
< b_perm
) - (a_perm
> b_perm
);
10063 /* Make the user-visible order stable across GDB runs. Locations of
10064 the same breakpoint can be sorted in arbitrary order. */
10066 if (a
->owner
->number
!= b
->owner
->number
)
10067 return (a
->owner
->number
> b
->owner
->number
)
10068 - (a
->owner
->number
< b
->owner
->number
);
10070 return (a
> b
) - (a
< b
);
10073 /* Set bp_location_placed_address_before_address_max and
10074 bp_location_shadow_len_after_address_max according to the current
10075 content of the bp_location array. */
10078 bp_location_target_extensions_update (void)
10080 struct bp_location
*bl
, **blp_tmp
;
10082 bp_location_placed_address_before_address_max
= 0;
10083 bp_location_shadow_len_after_address_max
= 0;
10085 ALL_BP_LOCATIONS (bl
, blp_tmp
)
10087 CORE_ADDR start
, end
, addr
;
10089 if (!bp_location_has_shadow (bl
))
10092 start
= bl
->target_info
.placed_address
;
10093 end
= start
+ bl
->target_info
.shadow_len
;
10095 gdb_assert (bl
->address
>= start
);
10096 addr
= bl
->address
- start
;
10097 if (addr
> bp_location_placed_address_before_address_max
)
10098 bp_location_placed_address_before_address_max
= addr
;
10100 /* Zero SHADOW_LEN would not pass bp_location_has_shadow. */
10102 gdb_assert (bl
->address
< end
);
10103 addr
= end
- bl
->address
;
10104 if (addr
> bp_location_shadow_len_after_address_max
)
10105 bp_location_shadow_len_after_address_max
= addr
;
10109 /* If SHOULD_INSERT is false, do not insert any breakpoint locations
10110 into the inferior, only remove already-inserted locations that no
10111 longer should be inserted. Functions that delete a breakpoint or
10112 breakpoints should pass false, so that deleting a breakpoint
10113 doesn't have the side effect of inserting the locations of other
10114 breakpoints that are marked not-inserted, but should_be_inserted
10115 returns true on them.
10117 This behaviour is useful is situations close to tear-down -- e.g.,
10118 after an exec, while the target still has execution, but breakpoint
10119 shadows of the previous executable image should *NOT* be restored
10120 to the new image; or before detaching, where the target still has
10121 execution and wants to delete breakpoints from GDB's lists, and all
10122 breakpoints had already been removed from the inferior. */
10125 update_global_location_list (int should_insert
)
10127 struct breakpoint
*b
;
10128 struct bp_location
**locp
, *loc
;
10129 struct cleanup
*cleanups
;
10131 /* Used in the duplicates detection below. When iterating over all
10132 bp_locations, points to the first bp_location of a given address.
10133 Breakpoints and watchpoints of different types are never
10134 duplicates of each other. Keep one pointer for each type of
10135 breakpoint/watchpoint, so we only need to loop over all locations
10137 struct bp_location
*bp_loc_first
; /* breakpoint */
10138 struct bp_location
*wp_loc_first
; /* hardware watchpoint */
10139 struct bp_location
*awp_loc_first
; /* access watchpoint */
10140 struct bp_location
*rwp_loc_first
; /* read watchpoint */
10142 /* Saved former bp_location array which we compare against the newly
10143 built bp_location from the current state of ALL_BREAKPOINTS. */
10144 struct bp_location
**old_location
, **old_locp
;
10145 unsigned old_location_count
;
10147 old_location
= bp_location
;
10148 old_location_count
= bp_location_count
;
10149 bp_location
= NULL
;
10150 bp_location_count
= 0;
10151 cleanups
= make_cleanup (xfree
, old_location
);
10153 ALL_BREAKPOINTS (b
)
10154 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
10155 bp_location_count
++;
10157 bp_location
= xmalloc (sizeof (*bp_location
) * bp_location_count
);
10158 locp
= bp_location
;
10159 ALL_BREAKPOINTS (b
)
10160 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
10162 qsort (bp_location
, bp_location_count
, sizeof (*bp_location
),
10163 bp_location_compare
);
10165 bp_location_target_extensions_update ();
10167 /* Identify bp_location instances that are no longer present in the
10168 new list, and therefore should be freed. Note that it's not
10169 necessary that those locations should be removed from inferior --
10170 if there's another location at the same address (previously
10171 marked as duplicate), we don't need to remove/insert the
10174 LOCP is kept in sync with OLD_LOCP, each pointing to the current
10175 and former bp_location array state respectively. */
10177 locp
= bp_location
;
10178 for (old_locp
= old_location
; old_locp
< old_location
+ old_location_count
;
10181 struct bp_location
*old_loc
= *old_locp
;
10182 struct bp_location
**loc2p
;
10184 /* Tells if 'old_loc' is found amoung the new locations. If
10185 not, we have to free it. */
10186 int found_object
= 0;
10187 /* Tells if the location should remain inserted in the target. */
10188 int keep_in_target
= 0;
10191 /* Skip LOCP entries which will definitely never be needed.
10192 Stop either at or being the one matching OLD_LOC. */
10193 while (locp
< bp_location
+ bp_location_count
10194 && (*locp
)->address
< old_loc
->address
)
10198 (loc2p
< bp_location
+ bp_location_count
10199 && (*loc2p
)->address
== old_loc
->address
);
10202 if (*loc2p
== old_loc
)
10209 /* If this location is no longer present, and inserted, look if
10210 there's maybe a new location at the same address. If so,
10211 mark that one inserted, and don't remove this one. This is
10212 needed so that we don't have a time window where a breakpoint
10213 at certain location is not inserted. */
10215 if (old_loc
->inserted
)
10217 /* If the location is inserted now, we might have to remove
10220 if (found_object
&& should_be_inserted (old_loc
))
10222 /* The location is still present in the location list,
10223 and still should be inserted. Don't do anything. */
10224 keep_in_target
= 1;
10228 /* The location is either no longer present, or got
10229 disabled. See if there's another location at the
10230 same address, in which case we don't need to remove
10231 this one from the target. */
10233 /* OLD_LOC comes from existing struct breakpoint. */
10234 if (breakpoint_address_is_meaningful (old_loc
->owner
))
10237 (loc2p
< bp_location
+ bp_location_count
10238 && (*loc2p
)->address
== old_loc
->address
);
10241 struct bp_location
*loc2
= *loc2p
;
10243 if (breakpoint_locations_match (loc2
, old_loc
))
10245 /* For the sake of should_be_inserted.
10246 Duplicates check below will fix up this
10248 loc2
->duplicate
= 0;
10250 /* Read watchpoint locations are switched to
10251 access watchpoints, if the former are not
10252 supported, but the latter are. */
10253 if (is_hardware_watchpoint (old_loc
->owner
))
10255 gdb_assert (is_hardware_watchpoint (loc2
->owner
));
10256 loc2
->watchpoint_type
= old_loc
->watchpoint_type
;
10259 if (loc2
!= old_loc
&& should_be_inserted (loc2
))
10261 loc2
->inserted
= 1;
10262 loc2
->target_info
= old_loc
->target_info
;
10263 keep_in_target
= 1;
10271 if (!keep_in_target
)
10273 if (remove_breakpoint (old_loc
, mark_uninserted
))
10275 /* This is just about all we can do. We could keep
10276 this location on the global list, and try to
10277 remove it next time, but there's no particular
10278 reason why we will succeed next time.
10280 Note that at this point, old_loc->owner is still
10281 valid, as delete_breakpoint frees the breakpoint
10282 only after calling us. */
10283 printf_filtered (_("warning: Error removing "
10284 "breakpoint %d\n"),
10285 old_loc
->owner
->number
);
10293 if (removed
&& non_stop
10294 && breakpoint_address_is_meaningful (old_loc
->owner
)
10295 && !is_hardware_watchpoint (old_loc
->owner
))
10297 /* This location was removed from the target. In
10298 non-stop mode, a race condition is possible where
10299 we've removed a breakpoint, but stop events for that
10300 breakpoint are already queued and will arrive later.
10301 We apply an heuristic to be able to distinguish such
10302 SIGTRAPs from other random SIGTRAPs: we keep this
10303 breakpoint location for a bit, and will retire it
10304 after we see some number of events. The theory here
10305 is that reporting of events should, "on the average",
10306 be fair, so after a while we'll see events from all
10307 threads that have anything of interest, and no longer
10308 need to keep this breakpoint location around. We
10309 don't hold locations forever so to reduce chances of
10310 mistaking a non-breakpoint SIGTRAP for a breakpoint
10313 The heuristic failing can be disastrous on
10314 decr_pc_after_break targets.
10316 On decr_pc_after_break targets, like e.g., x86-linux,
10317 if we fail to recognize a late breakpoint SIGTRAP,
10318 because events_till_retirement has reached 0 too
10319 soon, we'll fail to do the PC adjustment, and report
10320 a random SIGTRAP to the user. When the user resumes
10321 the inferior, it will most likely immediately crash
10322 with SIGILL/SIGBUS/SIGSEGV, or worse, get silently
10323 corrupted, because of being resumed e.g., in the
10324 middle of a multi-byte instruction, or skipped a
10325 one-byte instruction. This was actually seen happen
10326 on native x86-linux, and should be less rare on
10327 targets that do not support new thread events, like
10328 remote, due to the heuristic depending on
10331 Mistaking a random SIGTRAP for a breakpoint trap
10332 causes similar symptoms (PC adjustment applied when
10333 it shouldn't), but then again, playing with SIGTRAPs
10334 behind the debugger's back is asking for trouble.
10336 Since hardware watchpoint traps are always
10337 distinguishable from other traps, so we don't need to
10338 apply keep hardware watchpoint moribund locations
10339 around. We simply always ignore hardware watchpoint
10340 traps we can no longer explain. */
10342 old_loc
->events_till_retirement
= 3 * (thread_count () + 1);
10343 old_loc
->owner
= NULL
;
10345 VEC_safe_push (bp_location_p
, moribund_locations
, old_loc
);
10349 old_loc
->owner
= NULL
;
10350 decref_bp_location (&old_loc
);
10355 /* Rescan breakpoints at the same address and section, marking the
10356 first one as "first" and any others as "duplicates". This is so
10357 that the bpt instruction is only inserted once. If we have a
10358 permanent breakpoint at the same place as BPT, make that one the
10359 official one, and the rest as duplicates. Permanent breakpoints
10360 are sorted first for the same address.
10362 Do the same for hardware watchpoints, but also considering the
10363 watchpoint's type (regular/access/read) and length. */
10365 bp_loc_first
= NULL
;
10366 wp_loc_first
= NULL
;
10367 awp_loc_first
= NULL
;
10368 rwp_loc_first
= NULL
;
10369 ALL_BP_LOCATIONS (loc
, locp
)
10371 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always
10373 struct breakpoint
*b
= loc
->owner
;
10374 struct bp_location
**loc_first_p
;
10376 if (b
->enable_state
== bp_disabled
10377 || b
->enable_state
== bp_call_disabled
10378 || b
->enable_state
== bp_startup_disabled
10380 || loc
->shlib_disabled
10381 || !breakpoint_address_is_meaningful (b
)
10382 || is_tracepoint (b
))
10385 /* Permanent breakpoint should always be inserted. */
10386 if (b
->enable_state
== bp_permanent
&& ! loc
->inserted
)
10387 internal_error (__FILE__
, __LINE__
,
10388 _("allegedly permanent breakpoint is not "
10389 "actually inserted"));
10391 if (b
->type
== bp_hardware_watchpoint
)
10392 loc_first_p
= &wp_loc_first
;
10393 else if (b
->type
== bp_read_watchpoint
)
10394 loc_first_p
= &rwp_loc_first
;
10395 else if (b
->type
== bp_access_watchpoint
)
10396 loc_first_p
= &awp_loc_first
;
10398 loc_first_p
= &bp_loc_first
;
10400 if (*loc_first_p
== NULL
10401 || (overlay_debugging
&& loc
->section
!= (*loc_first_p
)->section
)
10402 || !breakpoint_locations_match (loc
, *loc_first_p
))
10404 *loc_first_p
= loc
;
10405 loc
->duplicate
= 0;
10409 loc
->duplicate
= 1;
10411 if ((*loc_first_p
)->owner
->enable_state
== bp_permanent
&& loc
->inserted
10412 && b
->enable_state
!= bp_permanent
)
10413 internal_error (__FILE__
, __LINE__
,
10414 _("another breakpoint was inserted on top of "
10415 "a permanent breakpoint"));
10418 if (breakpoints_always_inserted_mode () && should_insert
10419 && (have_live_inferiors ()
10420 || (gdbarch_has_global_breakpoints (target_gdbarch
))))
10421 insert_breakpoint_locations ();
10423 do_cleanups (cleanups
);
10427 breakpoint_retire_moribund (void)
10429 struct bp_location
*loc
;
10432 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
10433 if (--(loc
->events_till_retirement
) == 0)
10435 decref_bp_location (&loc
);
10436 VEC_unordered_remove (bp_location_p
, moribund_locations
, ix
);
10442 update_global_location_list_nothrow (int inserting
)
10444 struct gdb_exception e
;
10446 TRY_CATCH (e
, RETURN_MASK_ERROR
)
10447 update_global_location_list (inserting
);
10450 /* Clear BKP from a BPS. */
10453 bpstat_remove_bp_location (bpstat bps
, struct breakpoint
*bpt
)
10457 for (bs
= bps
; bs
; bs
= bs
->next
)
10458 if (bs
->breakpoint_at
== bpt
)
10460 bs
->breakpoint_at
= NULL
;
10461 bs
->old_val
= NULL
;
10462 /* bs->commands will be freed later. */
10466 /* Callback for iterate_over_threads. */
10468 bpstat_remove_breakpoint_callback (struct thread_info
*th
, void *data
)
10470 struct breakpoint
*bpt
= data
;
10472 bpstat_remove_bp_location (th
->control
.stop_bpstat
, bpt
);
10476 /* Delete a breakpoint and clean up all traces of it in the data
10480 delete_breakpoint (struct breakpoint
*bpt
)
10482 struct breakpoint
*b
;
10484 gdb_assert (bpt
!= NULL
);
10486 /* Has this bp already been deleted? This can happen because
10487 multiple lists can hold pointers to bp's. bpstat lists are
10490 One example of this happening is a watchpoint's scope bp. When
10491 the scope bp triggers, we notice that the watchpoint is out of
10492 scope, and delete it. We also delete its scope bp. But the
10493 scope bp is marked "auto-deleting", and is already on a bpstat.
10494 That bpstat is then checked for auto-deleting bp's, which are
10497 A real solution to this problem might involve reference counts in
10498 bp's, and/or giving them pointers back to their referencing
10499 bpstat's, and teaching delete_breakpoint to only free a bp's
10500 storage when no more references were extent. A cheaper bandaid
10502 if (bpt
->type
== bp_none
)
10505 /* At least avoid this stale reference until the reference counting
10506 of breakpoints gets resolved. */
10507 if (bpt
->related_breakpoint
!= bpt
)
10509 struct breakpoint
*related
;
10511 if (bpt
->type
== bp_watchpoint_scope
)
10512 watchpoint_del_at_next_stop (bpt
->related_breakpoint
);
10513 else if (bpt
->related_breakpoint
->type
== bp_watchpoint_scope
)
10514 watchpoint_del_at_next_stop (bpt
);
10516 /* Unlink bpt from the bpt->related_breakpoint ring. */
10517 for (related
= bpt
; related
->related_breakpoint
!= bpt
;
10518 related
= related
->related_breakpoint
);
10519 related
->related_breakpoint
= bpt
->related_breakpoint
;
10520 bpt
->related_breakpoint
= bpt
;
10523 observer_notify_breakpoint_deleted (bpt
->number
);
10525 if (breakpoint_chain
== bpt
)
10526 breakpoint_chain
= bpt
->next
;
10528 ALL_BREAKPOINTS (b
)
10529 if (b
->next
== bpt
)
10531 b
->next
= bpt
->next
;
10535 decref_counted_command_line (&bpt
->commands
);
10536 xfree (bpt
->cond_string
);
10537 xfree (bpt
->cond_exp
);
10538 xfree (bpt
->addr_string
);
10539 xfree (bpt
->addr_string_range_end
);
10541 xfree (bpt
->exp_string
);
10542 xfree (bpt
->exp_string_reparse
);
10543 value_free (bpt
->val
);
10544 xfree (bpt
->source_file
);
10545 xfree (bpt
->exec_pathname
);
10546 clean_up_filters (&bpt
->syscalls_to_be_caught
);
10549 /* Be sure no bpstat's are pointing at the breakpoint after it's
10551 /* FIXME, how can we find all bpstat's? We just check stop_bpstat
10552 in all threeds for now. Note that we cannot just remove bpstats
10553 pointing at bpt from the stop_bpstat list entirely, as breakpoint
10554 commands are associated with the bpstat; if we remove it here,
10555 then the later call to bpstat_do_actions (&stop_bpstat); in
10556 event-top.c won't do anything, and temporary breakpoints with
10557 commands won't work. */
10559 iterate_over_threads (bpstat_remove_breakpoint_callback
, bpt
);
10561 /* Now that breakpoint is removed from breakpoint list, update the
10562 global location list. This will remove locations that used to
10563 belong to this breakpoint. Do this before freeing the breakpoint
10564 itself, since remove_breakpoint looks at location's owner. It
10565 might be better design to have location completely
10566 self-contained, but it's not the case now. */
10567 update_global_location_list (0);
10570 /* On the chance that someone will soon try again to delete this
10571 same bp, we mark it as deleted before freeing its storage. */
10572 bpt
->type
= bp_none
;
10578 do_delete_breakpoint_cleanup (void *b
)
10580 delete_breakpoint (b
);
10584 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
10586 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
10589 /* A callback for map_breakpoint_numbers that calls
10590 delete_breakpoint. */
10593 do_delete_breakpoint (struct breakpoint
*b
, void *ignore
)
10595 delete_breakpoint (b
);
10599 delete_command (char *arg
, int from_tty
)
10601 struct breakpoint
*b
, *b_tmp
;
10607 int breaks_to_delete
= 0;
10609 /* Delete all breakpoints if no argument.
10610 Do not delete internal or call-dummy breakpoints, these have
10611 to be deleted with an explicit breakpoint number argument. */
10612 ALL_BREAKPOINTS (b
)
10614 if (b
->type
!= bp_call_dummy
10615 && b
->type
!= bp_std_terminate
10616 && b
->type
!= bp_shlib_event
10617 && b
->type
!= bp_jit_event
10618 && b
->type
!= bp_thread_event
10619 && b
->type
!= bp_overlay_event
10620 && b
->type
!= bp_longjmp_master
10621 && b
->type
!= bp_std_terminate_master
10622 && b
->type
!= bp_exception_master
10625 breaks_to_delete
= 1;
10630 /* Ask user only if there are some breakpoints to delete. */
10632 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
10634 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
10636 if (b
->type
!= bp_call_dummy
10637 && b
->type
!= bp_std_terminate
10638 && b
->type
!= bp_shlib_event
10639 && b
->type
!= bp_thread_event
10640 && b
->type
!= bp_jit_event
10641 && b
->type
!= bp_overlay_event
10642 && b
->type
!= bp_longjmp_master
10643 && b
->type
!= bp_std_terminate_master
10644 && b
->type
!= bp_exception_master
10646 delete_breakpoint (b
);
10651 map_breakpoint_numbers (arg
, do_delete_breakpoint
, NULL
);
10655 all_locations_are_pending (struct bp_location
*loc
)
10657 for (; loc
; loc
= loc
->next
)
10658 if (!loc
->shlib_disabled
)
10663 /* Subroutine of update_breakpoint_locations to simplify it.
10664 Return non-zero if multiple fns in list LOC have the same name.
10665 Null names are ignored. */
10668 ambiguous_names_p (struct bp_location
*loc
)
10670 struct bp_location
*l
;
10671 htab_t htab
= htab_create_alloc (13, htab_hash_string
,
10672 (int (*) (const void *,
10673 const void *)) streq
,
10674 NULL
, xcalloc
, xfree
);
10676 for (l
= loc
; l
!= NULL
; l
= l
->next
)
10679 const char *name
= l
->function_name
;
10681 /* Allow for some names to be NULL, ignore them. */
10685 slot
= (const char **) htab_find_slot (htab
, (const void *) name
,
10687 /* NOTE: We can assume slot != NULL here because xcalloc never
10691 htab_delete (htab
);
10697 htab_delete (htab
);
10701 /* When symbols change, it probably means the sources changed as well,
10702 and it might mean the static tracepoint markers are no longer at
10703 the same address or line numbers they used to be at last we
10704 checked. Losing your static tracepoints whenever you rebuild is
10705 undesirable. This function tries to resync/rematch gdb static
10706 tracepoints with the markers on the target, for static tracepoints
10707 that have not been set by marker id. Static tracepoint that have
10708 been set by marker id are reset by marker id in breakpoint_re_set.
10711 1) For a tracepoint set at a specific address, look for a marker at
10712 the old PC. If one is found there, assume to be the same marker.
10713 If the name / string id of the marker found is different from the
10714 previous known name, assume that means the user renamed the marker
10715 in the sources, and output a warning.
10717 2) For a tracepoint set at a given line number, look for a marker
10718 at the new address of the old line number. If one is found there,
10719 assume to be the same marker. If the name / string id of the
10720 marker found is different from the previous known name, assume that
10721 means the user renamed the marker in the sources, and output a
10724 3) If a marker is no longer found at the same address or line, it
10725 may mean the marker no longer exists. But it may also just mean
10726 the code changed a bit. Maybe the user added a few lines of code
10727 that made the marker move up or down (in line number terms). Ask
10728 the target for info about the marker with the string id as we knew
10729 it. If found, update line number and address in the matching
10730 static tracepoint. This will get confused if there's more than one
10731 marker with the same ID (possible in UST, although unadvised
10732 precisely because it confuses tools). */
10734 static struct symtab_and_line
10735 update_static_tracepoint (struct breakpoint
*b
, struct symtab_and_line sal
)
10737 struct static_tracepoint_marker marker
;
10743 find_line_pc (sal
.symtab
, sal
.line
, &pc
);
10745 if (target_static_tracepoint_marker_at (pc
, &marker
))
10747 if (strcmp (b
->static_trace_marker_id
, marker
.str_id
) != 0)
10748 warning (_("static tracepoint %d changed probed marker from %s to %s"),
10750 b
->static_trace_marker_id
, marker
.str_id
);
10752 xfree (b
->static_trace_marker_id
);
10753 b
->static_trace_marker_id
= xstrdup (marker
.str_id
);
10754 release_static_tracepoint_marker (&marker
);
10759 /* Old marker wasn't found on target at lineno. Try looking it up
10761 if (!sal
.explicit_pc
10763 && sal
.symtab
!= NULL
10764 && b
->static_trace_marker_id
!= NULL
)
10766 VEC(static_tracepoint_marker_p
) *markers
;
10769 = target_static_tracepoint_markers_by_strid (b
->static_trace_marker_id
);
10771 if (!VEC_empty(static_tracepoint_marker_p
, markers
))
10773 struct symtab_and_line sal
;
10774 struct symbol
*sym
;
10775 struct static_tracepoint_marker
*marker
;
10777 marker
= VEC_index (static_tracepoint_marker_p
, markers
, 0);
10779 xfree (b
->static_trace_marker_id
);
10780 b
->static_trace_marker_id
= xstrdup (marker
->str_id
);
10782 warning (_("marker for static tracepoint %d (%s) not "
10783 "found at previous line number"),
10784 b
->number
, b
->static_trace_marker_id
);
10788 sal
.pc
= marker
->address
;
10790 sal
= find_pc_line (marker
->address
, 0);
10791 sym
= find_pc_sect_function (marker
->address
, NULL
);
10792 ui_out_text (uiout
, "Now in ");
10795 ui_out_field_string (uiout
, "func",
10796 SYMBOL_PRINT_NAME (sym
));
10797 ui_out_text (uiout
, " at ");
10799 ui_out_field_string (uiout
, "file", sal
.symtab
->filename
);
10800 ui_out_text (uiout
, ":");
10802 if (ui_out_is_mi_like_p (uiout
))
10804 char *fullname
= symtab_to_fullname (sal
.symtab
);
10807 ui_out_field_string (uiout
, "fullname", fullname
);
10810 ui_out_field_int (uiout
, "line", sal
.line
);
10811 ui_out_text (uiout
, "\n");
10813 b
->line_number
= sal
.line
;
10815 xfree (b
->source_file
);
10817 b
->source_file
= xstrdup (sal
.symtab
->filename
);
10819 b
->source_file
= NULL
;
10821 xfree (b
->addr_string
);
10822 b
->addr_string
= xstrprintf ("%s:%d",
10823 sal
.symtab
->filename
, b
->line_number
);
10825 /* Might be nice to check if function changed, and warn if
10828 release_static_tracepoint_marker (marker
);
10834 /* Create new breakpoint locations for B (a hardware or software breakpoint)
10835 based on SALS and SALS_END. If SALS_END.NELTS is not zero, then B is
10836 a ranged breakpoint. */
10839 update_breakpoint_locations (struct breakpoint
*b
,
10840 struct symtabs_and_lines sals
,
10841 struct symtabs_and_lines sals_end
)
10844 struct bp_location
*existing_locations
= b
->loc
;
10846 /* Ranged breakpoints have only one start location and one end location. */
10847 gdb_assert (sals_end
.nelts
== 0 || (sals
.nelts
== 1 && sals_end
.nelts
== 1));
10849 /* If there's no new locations, and all existing locations are
10850 pending, don't do anything. This optimizes the common case where
10851 all locations are in the same shared library, that was unloaded.
10852 We'd like to retain the location, so that when the library is
10853 loaded again, we don't loose the enabled/disabled status of the
10854 individual locations. */
10855 if (all_locations_are_pending (existing_locations
) && sals
.nelts
== 0)
10860 for (i
= 0; i
< sals
.nelts
; ++i
)
10862 struct bp_location
*new_loc
=
10863 add_location_to_breakpoint (b
, &(sals
.sals
[i
]));
10865 /* Reparse conditions, they might contain references to the
10867 if (b
->cond_string
!= NULL
)
10870 struct gdb_exception e
;
10872 s
= b
->cond_string
;
10873 TRY_CATCH (e
, RETURN_MASK_ERROR
)
10875 new_loc
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
),
10880 warning (_("failed to reevaluate condition "
10881 "for breakpoint %d: %s"),
10882 b
->number
, e
.message
);
10883 new_loc
->enabled
= 0;
10887 if (b
->source_file
!= NULL
)
10888 xfree (b
->source_file
);
10889 if (sals
.sals
[i
].symtab
== NULL
)
10890 b
->source_file
= NULL
;
10892 b
->source_file
= xstrdup (sals
.sals
[i
].symtab
->filename
);
10894 if (b
->line_number
== 0)
10895 b
->line_number
= sals
.sals
[i
].line
;
10897 if (sals_end
.nelts
)
10899 CORE_ADDR end
= find_breakpoint_range_end (sals_end
.sals
[0]);
10901 new_loc
->length
= end
- sals
.sals
[0].pc
+ 1;
10905 /* Update locations of permanent breakpoints. */
10906 if (b
->enable_state
== bp_permanent
)
10907 make_breakpoint_permanent (b
);
10909 /* If possible, carry over 'disable' status from existing
10912 struct bp_location
*e
= existing_locations
;
10913 /* If there are multiple breakpoints with the same function name,
10914 e.g. for inline functions, comparing function names won't work.
10915 Instead compare pc addresses; this is just a heuristic as things
10916 may have moved, but in practice it gives the correct answer
10917 often enough until a better solution is found. */
10918 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
10920 for (; e
; e
= e
->next
)
10922 if (!e
->enabled
&& e
->function_name
)
10924 struct bp_location
*l
= b
->loc
;
10925 if (have_ambiguous_names
)
10927 for (; l
; l
= l
->next
)
10928 if (breakpoint_locations_match (e
, l
))
10936 for (; l
; l
= l
->next
)
10937 if (l
->function_name
10938 && strcmp (e
->function_name
, l
->function_name
) == 0)
10948 update_global_location_list (1);
10951 /* Find the SaL locations corresponding to the given ADDR_STRING.
10952 On return, FOUND will be 1 if any SaL was found, zero otherwise. */
10954 static struct symtabs_and_lines
10955 addr_string_to_sals (struct breakpoint
*b
, char *addr_string
, int *found
)
10958 int marker_spec
, not_found
;
10959 struct symtabs_and_lines sals
= {0};
10960 struct gdb_exception e
;
10963 marker_spec
= b
->type
== bp_static_tracepoint
&& is_marker_spec (s
);
10965 TRY_CATCH (e
, RETURN_MASK_ERROR
)
10969 sals
= decode_static_tracepoint_spec (&s
);
10970 if (sals
.nelts
> b
->static_trace_marker_id_idx
)
10972 sals
.sals
[0] = sals
.sals
[b
->static_trace_marker_id_idx
];
10976 error (_("marker %s not found"), b
->static_trace_marker_id
);
10979 sals
= decode_line_1 (&s
, 1, (struct symtab
*) NULL
, 0,
10984 int not_found_and_ok
= 0;
10985 /* For pending breakpoints, it's expected that parsing will
10986 fail until the right shared library is loaded. User has
10987 already told to create pending breakpoints and don't need
10988 extra messages. If breakpoint is in bp_shlib_disabled
10989 state, then user already saw the message about that
10990 breakpoint being disabled, and don't want to see more
10993 && (b
->condition_not_parsed
10994 || (b
->loc
&& b
->loc
->shlib_disabled
)
10995 || b
->enable_state
== bp_disabled
))
10996 not_found_and_ok
= 1;
10998 if (!not_found_and_ok
)
11000 /* We surely don't want to warn about the same breakpoint
11001 10 times. One solution, implemented here, is disable
11002 the breakpoint on error. Another solution would be to
11003 have separate 'warning emitted' flag. Since this
11004 happens only when a binary has changed, I don't know
11005 which approach is better. */
11006 b
->enable_state
= bp_disabled
;
11007 throw_exception (e
);
11013 gdb_assert (sals
.nelts
== 1);
11015 resolve_sal_pc (&sals
.sals
[0]);
11016 if (b
->condition_not_parsed
&& s
&& s
[0])
11018 char *cond_string
= 0;
11022 find_condition_and_thread (s
, sals
.sals
[0].pc
,
11023 &cond_string
, &thread
, &task
);
11025 b
->cond_string
= cond_string
;
11026 b
->thread
= thread
;
11028 b
->condition_not_parsed
= 0;
11031 if (b
->type
== bp_static_tracepoint
&& !marker_spec
)
11032 sals
.sals
[0] = update_static_tracepoint (b
, sals
.sals
[0]);
11035 *found
= !not_found
;
11040 /* Reevaluate a hardware or software breakpoint and recreate its locations.
11041 This is necessary after symbols are read (e.g., an executable or DSO
11042 was loaded, or the inferior just started). */
11045 re_set_breakpoint (struct breakpoint
*b
)
11048 struct symtabs_and_lines sals
, sals_end
;
11049 struct symtabs_and_lines expanded
= {0};
11050 struct symtabs_and_lines expanded_end
= {0};
11051 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
11053 input_radix
= b
->input_radix
;
11054 save_current_space_and_thread ();
11055 switch_to_program_space_and_thread (b
->pspace
);
11056 set_language (b
->language
);
11058 sals
= addr_string_to_sals (b
, b
->addr_string
, &found
);
11061 make_cleanup (xfree
, sals
.sals
);
11062 expanded
= expand_line_sal_maybe (sals
.sals
[0]);
11065 if (b
->addr_string_range_end
)
11067 sals_end
= addr_string_to_sals (b
, b
->addr_string_range_end
, &found
);
11070 make_cleanup (xfree
, sals_end
.sals
);
11071 expanded_end
= expand_line_sal_maybe (sals_end
.sals
[0]);
11075 update_breakpoint_locations (b
, expanded
, expanded_end
);
11076 do_cleanups (cleanups
);
11079 /* Reset a breakpoint given it's struct breakpoint * BINT.
11080 The value we return ends up being the return value from catch_errors.
11081 Unused in this case. */
11084 breakpoint_re_set_one (void *bint
)
11086 /* Get past catch_errs. */
11087 struct breakpoint
*b
= (struct breakpoint
*) bint
;
11092 warning (_("attempted to reset apparently deleted breakpoint #%d?"),
11095 case bp_breakpoint
:
11096 case bp_hardware_breakpoint
:
11097 case bp_tracepoint
:
11098 case bp_fast_tracepoint
:
11099 case bp_static_tracepoint
:
11100 case bp_gnu_ifunc_resolver
:
11101 /* Do not attempt to re-set breakpoints disabled during startup. */
11102 if (b
->enable_state
== bp_startup_disabled
)
11105 if (b
->addr_string
== NULL
)
11107 /* Anything without a string can't be re-set. */
11108 delete_breakpoint (b
);
11112 re_set_breakpoint (b
);
11115 case bp_watchpoint
:
11116 case bp_hardware_watchpoint
:
11117 case bp_read_watchpoint
:
11118 case bp_access_watchpoint
:
11119 /* Watchpoint can be either on expression using entirely global
11120 variables, or it can be on local variables.
11122 Watchpoints of the first kind are never auto-deleted, and
11123 even persist across program restarts. Since they can use
11124 variables from shared libraries, we need to reparse
11125 expression as libraries are loaded and unloaded.
11127 Watchpoints on local variables can also change meaning as
11128 result of solib event. For example, if a watchpoint uses
11129 both a local and a global variables in expression, it's a
11130 local watchpoint, but unloading of a shared library will make
11131 the expression invalid. This is not a very common use case,
11132 but we still re-evaluate expression, to avoid surprises to
11135 Note that for local watchpoints, we re-evaluate it only if
11136 watchpoints frame id is still valid. If it's not, it means
11137 the watchpoint is out of scope and will be deleted soon. In
11138 fact, I'm not sure we'll ever be called in this case.
11140 If a local watchpoint's frame id is still valid, then
11141 b->exp_valid_block is likewise valid, and we can safely use it.
11143 Don't do anything about disabled watchpoints, since they will
11144 be reevaluated again when enabled. */
11145 update_watchpoint (b
, 1 /* reparse */);
11147 /* We needn't really do anything to reset these, since the mask
11148 that requests them is unaffected by e.g., new libraries being
11150 case bp_catchpoint
:
11154 printf_filtered (_("Deleting unknown breakpoint type %d\n"), b
->type
);
11156 /* Delete overlay event and longjmp master breakpoints; they will be
11157 reset later by breakpoint_re_set. */
11158 case bp_overlay_event
:
11159 case bp_longjmp_master
:
11160 case bp_std_terminate_master
:
11161 case bp_exception_master
:
11162 delete_breakpoint (b
);
11165 /* This breakpoint is special, it's set up when the inferior
11166 starts and we really don't want to touch it. */
11167 case bp_shlib_event
:
11169 /* Like bp_shlib_event, this breakpoint type is special.
11170 Once it is set up, we do not want to touch it. */
11171 case bp_thread_event
:
11173 /* Keep temporary breakpoints, which can be encountered when we
11174 step over a dlopen call and SOLIB_ADD is resetting the
11175 breakpoints. Otherwise these should have been blown away via
11176 the cleanup chain or by breakpoint_init_inferior when we
11177 rerun the executable. */
11180 case bp_watchpoint_scope
:
11181 case bp_call_dummy
:
11182 case bp_std_terminate
:
11183 case bp_step_resume
:
11185 case bp_longjmp_resume
:
11187 case bp_exception_resume
:
11189 case bp_gnu_ifunc_resolver_return
:
11196 /* Re-set all breakpoints after symbols have been re-loaded. */
11198 breakpoint_re_set (void)
11200 struct breakpoint
*b
, *b_tmp
;
11201 enum language save_language
;
11202 int save_input_radix
;
11203 struct cleanup
*old_chain
;
11205 save_language
= current_language
->la_language
;
11206 save_input_radix
= input_radix
;
11207 old_chain
= save_current_program_space ();
11209 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
11211 /* Format possible error msg. */
11212 char *message
= xstrprintf ("Error in re-setting breakpoint %d: ",
11214 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
11215 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
11216 do_cleanups (cleanups
);
11218 set_language (save_language
);
11219 input_radix
= save_input_radix
;
11221 jit_breakpoint_re_set ();
11223 do_cleanups (old_chain
);
11225 create_overlay_event_breakpoint ();
11226 create_longjmp_master_breakpoint ();
11227 create_std_terminate_master_breakpoint ();
11228 create_exception_master_breakpoint ();
11231 /* Reset the thread number of this breakpoint:
11233 - If the breakpoint is for all threads, leave it as-is.
11234 - Else, reset it to the current thread for inferior_ptid. */
11236 breakpoint_re_set_thread (struct breakpoint
*b
)
11238 if (b
->thread
!= -1)
11240 if (in_thread_list (inferior_ptid
))
11241 b
->thread
= pid_to_thread_id (inferior_ptid
);
11243 /* We're being called after following a fork. The new fork is
11244 selected as current, and unless this was a vfork will have a
11245 different program space from the original thread. Reset that
11247 b
->loc
->pspace
= current_program_space
;
11251 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
11252 If from_tty is nonzero, it prints a message to that effect,
11253 which ends with a period (no newline). */
11256 set_ignore_count (int bptnum
, int count
, int from_tty
)
11258 struct breakpoint
*b
;
11263 ALL_BREAKPOINTS (b
)
11264 if (b
->number
== bptnum
)
11266 if (is_tracepoint (b
))
11268 if (from_tty
&& count
!= 0)
11269 printf_filtered (_("Ignore count ignored for tracepoint %d."),
11274 b
->ignore_count
= count
;
11278 printf_filtered (_("Will stop next time "
11279 "breakpoint %d is reached."),
11281 else if (count
== 1)
11282 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
11285 printf_filtered (_("Will ignore next %d "
11286 "crossings of breakpoint %d."),
11289 breakpoints_changed ();
11290 observer_notify_breakpoint_modified (b
->number
);
11294 error (_("No breakpoint number %d."), bptnum
);
11297 /* Command to set ignore-count of breakpoint N to COUNT. */
11300 ignore_command (char *args
, int from_tty
)
11306 error_no_arg (_("a breakpoint number"));
11308 num
= get_number (&p
);
11310 error (_("bad breakpoint number: '%s'"), args
);
11312 error (_("Second argument (specified ignore-count) is missing."));
11314 set_ignore_count (num
,
11315 longest_to_int (value_as_long (parse_and_eval (p
))),
11318 printf_filtered ("\n");
11321 /* Call FUNCTION on each of the breakpoints
11322 whose numbers are given in ARGS. */
11325 map_breakpoint_numbers (char *args
, void (*function
) (struct breakpoint
*,
11330 struct breakpoint
*b
, *tmp
;
11332 struct get_number_or_range_state state
;
11335 error_no_arg (_("one or more breakpoint numbers"));
11337 init_number_or_range (&state
, args
);
11339 while (!state
.finished
)
11341 char *p
= state
.string
;
11345 num
= get_number_or_range (&state
);
11348 warning (_("bad breakpoint number at or near '%s'"), p
);
11352 ALL_BREAKPOINTS_SAFE (b
, tmp
)
11353 if (b
->number
== num
)
11355 struct breakpoint
*related_breakpoint
;
11358 related_breakpoint
= b
;
11361 struct breakpoint
*next_related_b
;
11363 /* FUNCTION can be also delete_breakpoint. */
11364 next_related_b
= related_breakpoint
->related_breakpoint
;
11365 function (related_breakpoint
, data
);
11367 /* For delete_breakpoint of the last entry of the ring we
11368 were traversing we would never get back to B. */
11369 if (next_related_b
== related_breakpoint
)
11371 related_breakpoint
= next_related_b
;
11373 while (related_breakpoint
!= b
);
11377 printf_unfiltered (_("No breakpoint number %d.\n"), num
);
11382 static struct bp_location
*
11383 find_location_by_number (char *number
)
11385 char *dot
= strchr (number
, '.');
11389 struct breakpoint
*b
;
11390 struct bp_location
*loc
;
11395 bp_num
= get_number (&p1
);
11397 error (_("Bad breakpoint number '%s'"), number
);
11399 ALL_BREAKPOINTS (b
)
11400 if (b
->number
== bp_num
)
11405 if (!b
|| b
->number
!= bp_num
)
11406 error (_("Bad breakpoint number '%s'"), number
);
11409 loc_num
= get_number (&p1
);
11411 error (_("Bad breakpoint location number '%s'"), number
);
11415 for (;loc_num
&& loc
; --loc_num
, loc
= loc
->next
)
11418 error (_("Bad breakpoint location number '%s'"), dot
+1);
11424 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
11425 If from_tty is nonzero, it prints a message to that effect,
11426 which ends with a period (no newline). */
11429 disable_breakpoint (struct breakpoint
*bpt
)
11431 /* Never disable a watchpoint scope breakpoint; we want to
11432 hit them when we leave scope so we can delete both the
11433 watchpoint and its scope breakpoint at that time. */
11434 if (bpt
->type
== bp_watchpoint_scope
)
11437 /* You can't disable permanent breakpoints. */
11438 if (bpt
->enable_state
== bp_permanent
)
11441 bpt
->enable_state
= bp_disabled
;
11443 update_global_location_list (0);
11445 observer_notify_breakpoint_modified (bpt
->number
);
11448 /* A callback for map_breakpoint_numbers that calls
11449 disable_breakpoint. */
11452 do_map_disable_breakpoint (struct breakpoint
*b
, void *ignore
)
11454 disable_breakpoint (b
);
11458 disable_command (char *args
, int from_tty
)
11460 struct breakpoint
*bpt
;
11463 ALL_BREAKPOINTS (bpt
)
11467 warning (_("attempted to disable apparently deleted breakpoint #%d?"),
11470 case bp_breakpoint
:
11471 case bp_tracepoint
:
11472 case bp_fast_tracepoint
:
11473 case bp_static_tracepoint
:
11474 case bp_catchpoint
:
11475 case bp_hardware_breakpoint
:
11476 case bp_watchpoint
:
11477 case bp_hardware_watchpoint
:
11478 case bp_read_watchpoint
:
11479 case bp_access_watchpoint
:
11480 disable_breakpoint (bpt
);
11485 else if (strchr (args
, '.'))
11487 struct bp_location
*loc
= find_location_by_number (args
);
11490 update_global_location_list (0);
11493 map_breakpoint_numbers (args
, do_map_disable_breakpoint
, NULL
);
11497 do_enable_breakpoint (struct breakpoint
*bpt
, enum bpdisp disposition
)
11499 int target_resources_ok
;
11501 if (bpt
->type
== bp_hardware_breakpoint
)
11504 i
= hw_breakpoint_used_count ();
11505 target_resources_ok
=
11506 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
11508 if (target_resources_ok
== 0)
11509 error (_("No hardware breakpoint support in the target."));
11510 else if (target_resources_ok
< 0)
11511 error (_("Hardware breakpoints used exceeds limit."));
11514 if (is_watchpoint (bpt
))
11516 struct gdb_exception e
;
11518 TRY_CATCH (e
, RETURN_MASK_ALL
)
11520 update_watchpoint (bpt
, 1 /* reparse */);
11524 exception_fprintf (gdb_stderr
, e
, _("Cannot enable watchpoint %d: "),
11530 if (bpt
->enable_state
!= bp_permanent
)
11531 bpt
->enable_state
= bp_enabled
;
11532 bpt
->disposition
= disposition
;
11533 update_global_location_list (1);
11534 breakpoints_changed ();
11536 observer_notify_breakpoint_modified (bpt
->number
);
11541 enable_breakpoint (struct breakpoint
*bpt
)
11543 do_enable_breakpoint (bpt
, bpt
->disposition
);
11546 /* A callback for map_breakpoint_numbers that calls
11547 enable_breakpoint. */
11550 do_map_enable_breakpoint (struct breakpoint
*b
, void *ignore
)
11552 enable_breakpoint (b
);
11555 /* The enable command enables the specified breakpoints (or all defined
11556 breakpoints) so they once again become (or continue to be) effective
11557 in stopping the inferior. */
11560 enable_command (char *args
, int from_tty
)
11562 struct breakpoint
*bpt
;
11565 ALL_BREAKPOINTS (bpt
)
11569 warning (_("attempted to enable apparently deleted breakpoint #%d?"),
11572 case bp_breakpoint
:
11573 case bp_tracepoint
:
11574 case bp_fast_tracepoint
:
11575 case bp_static_tracepoint
:
11576 case bp_catchpoint
:
11577 case bp_hardware_breakpoint
:
11578 case bp_watchpoint
:
11579 case bp_hardware_watchpoint
:
11580 case bp_read_watchpoint
:
11581 case bp_access_watchpoint
:
11582 enable_breakpoint (bpt
);
11587 else if (strchr (args
, '.'))
11589 struct bp_location
*loc
= find_location_by_number (args
);
11592 update_global_location_list (1);
11595 map_breakpoint_numbers (args
, do_map_enable_breakpoint
, NULL
);
11599 enable_once_breakpoint (struct breakpoint
*bpt
, void *ignore
)
11601 do_enable_breakpoint (bpt
, disp_disable
);
11605 enable_once_command (char *args
, int from_tty
)
11607 map_breakpoint_numbers (args
, enable_once_breakpoint
, NULL
);
11611 enable_delete_breakpoint (struct breakpoint
*bpt
, void *ignore
)
11613 do_enable_breakpoint (bpt
, disp_del
);
11617 enable_delete_command (char *args
, int from_tty
)
11619 map_breakpoint_numbers (args
, enable_delete_breakpoint
, NULL
);
11623 set_breakpoint_cmd (char *args
, int from_tty
)
11628 show_breakpoint_cmd (char *args
, int from_tty
)
11632 /* Invalidate last known value of any hardware watchpoint if
11633 the memory which that value represents has been written to by
11637 invalidate_bp_value_on_memory_change (CORE_ADDR addr
, int len
,
11638 const bfd_byte
*data
)
11640 struct breakpoint
*bp
;
11642 ALL_BREAKPOINTS (bp
)
11643 if (bp
->enable_state
== bp_enabled
11644 && bp
->type
== bp_hardware_watchpoint
11645 && bp
->val_valid
&& bp
->val
)
11647 struct bp_location
*loc
;
11649 for (loc
= bp
->loc
; loc
!= NULL
; loc
= loc
->next
)
11650 if (loc
->loc_type
== bp_loc_hardware_watchpoint
11651 && loc
->address
+ loc
->length
> addr
11652 && addr
+ len
> loc
->address
)
11654 value_free (bp
->val
);
11661 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
11663 struct symtabs_and_lines
11664 decode_line_spec_1 (char *string
, int funfirstline
)
11666 struct symtabs_and_lines sals
;
11669 error (_("Empty line specification."));
11670 if (default_breakpoint_valid
)
11671 sals
= decode_line_1 (&string
, funfirstline
,
11672 default_breakpoint_symtab
,
11673 default_breakpoint_line
,
11676 sals
= decode_line_1 (&string
, funfirstline
,
11677 (struct symtab
*) NULL
, 0, NULL
, NULL
);
11679 error (_("Junk at end of line specification: %s"), string
);
11683 /* Create and insert a raw software breakpoint at PC. Return an
11684 identifier, which should be used to remove the breakpoint later.
11685 In general, places which call this should be using something on the
11686 breakpoint chain instead; this function should be eliminated
11690 deprecated_insert_raw_breakpoint (struct gdbarch
*gdbarch
,
11691 struct address_space
*aspace
, CORE_ADDR pc
)
11693 struct bp_target_info
*bp_tgt
;
11695 bp_tgt
= XZALLOC (struct bp_target_info
);
11697 bp_tgt
->placed_address_space
= aspace
;
11698 bp_tgt
->placed_address
= pc
;
11700 if (target_insert_breakpoint (gdbarch
, bp_tgt
) != 0)
11702 /* Could not insert the breakpoint. */
11710 /* Remove a breakpoint BP inserted by
11711 deprecated_insert_raw_breakpoint. */
11714 deprecated_remove_raw_breakpoint (struct gdbarch
*gdbarch
, void *bp
)
11716 struct bp_target_info
*bp_tgt
= bp
;
11719 ret
= target_remove_breakpoint (gdbarch
, bp_tgt
);
11725 /* One (or perhaps two) breakpoints used for software single
11728 static void *single_step_breakpoints
[2];
11729 static struct gdbarch
*single_step_gdbarch
[2];
11731 /* Create and insert a breakpoint for software single step. */
11734 insert_single_step_breakpoint (struct gdbarch
*gdbarch
,
11735 struct address_space
*aspace
,
11740 if (single_step_breakpoints
[0] == NULL
)
11742 bpt_p
= &single_step_breakpoints
[0];
11743 single_step_gdbarch
[0] = gdbarch
;
11747 gdb_assert (single_step_breakpoints
[1] == NULL
);
11748 bpt_p
= &single_step_breakpoints
[1];
11749 single_step_gdbarch
[1] = gdbarch
;
11752 /* NOTE drow/2006-04-11: A future improvement to this function would
11753 be to only create the breakpoints once, and actually put them on
11754 the breakpoint chain. That would let us use set_raw_breakpoint.
11755 We could adjust the addresses each time they were needed. Doing
11756 this requires corresponding changes elsewhere where single step
11757 breakpoints are handled, however. So, for now, we use this. */
11759 *bpt_p
= deprecated_insert_raw_breakpoint (gdbarch
, aspace
, next_pc
);
11760 if (*bpt_p
== NULL
)
11761 error (_("Could not insert single-step breakpoint at %s"),
11762 paddress (gdbarch
, next_pc
));
11765 /* Check if the breakpoints used for software single stepping
11766 were inserted or not. */
11769 single_step_breakpoints_inserted (void)
11771 return (single_step_breakpoints
[0] != NULL
11772 || single_step_breakpoints
[1] != NULL
);
11775 /* Remove and delete any breakpoints used for software single step. */
11778 remove_single_step_breakpoints (void)
11780 gdb_assert (single_step_breakpoints
[0] != NULL
);
11782 /* See insert_single_step_breakpoint for more about this deprecated
11784 deprecated_remove_raw_breakpoint (single_step_gdbarch
[0],
11785 single_step_breakpoints
[0]);
11786 single_step_gdbarch
[0] = NULL
;
11787 single_step_breakpoints
[0] = NULL
;
11789 if (single_step_breakpoints
[1] != NULL
)
11791 deprecated_remove_raw_breakpoint (single_step_gdbarch
[1],
11792 single_step_breakpoints
[1]);
11793 single_step_gdbarch
[1] = NULL
;
11794 single_step_breakpoints
[1] = NULL
;
11798 /* Delete software single step breakpoints without removing them from
11799 the inferior. This is intended to be used if the inferior's address
11800 space where they were inserted is already gone, e.g. after exit or
11804 cancel_single_step_breakpoints (void)
11808 for (i
= 0; i
< 2; i
++)
11809 if (single_step_breakpoints
[i
])
11811 xfree (single_step_breakpoints
[i
]);
11812 single_step_breakpoints
[i
] = NULL
;
11813 single_step_gdbarch
[i
] = NULL
;
11817 /* Detach software single-step breakpoints from INFERIOR_PTID without
11821 detach_single_step_breakpoints (void)
11825 for (i
= 0; i
< 2; i
++)
11826 if (single_step_breakpoints
[i
])
11827 target_remove_breakpoint (single_step_gdbarch
[i
],
11828 single_step_breakpoints
[i
]);
11831 /* Check whether a software single-step breakpoint is inserted at
11835 single_step_breakpoint_inserted_here_p (struct address_space
*aspace
,
11840 for (i
= 0; i
< 2; i
++)
11842 struct bp_target_info
*bp_tgt
= single_step_breakpoints
[i
];
11844 && breakpoint_address_match (bp_tgt
->placed_address_space
,
11845 bp_tgt
->placed_address
,
11853 /* Returns 0 if 'bp' is NOT a syscall catchpoint,
11854 non-zero otherwise. */
11856 is_syscall_catchpoint_enabled (struct breakpoint
*bp
)
11858 if (syscall_catchpoint_p (bp
)
11859 && bp
->enable_state
!= bp_disabled
11860 && bp
->enable_state
!= bp_call_disabled
)
11867 catch_syscall_enabled (void)
11869 struct inferior
*inf
= current_inferior ();
11871 return inf
->total_syscalls_count
!= 0;
11875 catching_syscall_number (int syscall_number
)
11877 struct breakpoint
*bp
;
11879 ALL_BREAKPOINTS (bp
)
11880 if (is_syscall_catchpoint_enabled (bp
))
11882 if (bp
->syscalls_to_be_caught
)
11886 VEC_iterate (int, bp
->syscalls_to_be_caught
, i
, iter
);
11888 if (syscall_number
== iter
)
11898 /* Complete syscall names. Used by "catch syscall". */
11900 catch_syscall_completer (struct cmd_list_element
*cmd
,
11901 char *text
, char *word
)
11903 const char **list
= get_syscall_names ();
11905 = (list
== NULL
) ? NULL
: complete_on_enum (list
, text
, word
);
11911 /* Tracepoint-specific operations. */
11913 /* Set tracepoint count to NUM. */
11915 set_tracepoint_count (int num
)
11917 tracepoint_count
= num
;
11918 set_internalvar_integer (lookup_internalvar ("tpnum"), num
);
11922 trace_command (char *arg
, int from_tty
)
11924 if (create_breakpoint (get_current_arch (),
11926 NULL
, 0, 1 /* parse arg */,
11928 bp_tracepoint
/* type_wanted */,
11929 0 /* Ignore count */,
11930 pending_break_support
,
11935 set_tracepoint_count (breakpoint_count
);
11939 ftrace_command (char *arg
, int from_tty
)
11941 if (create_breakpoint (get_current_arch (),
11943 NULL
, 0, 1 /* parse arg */,
11945 bp_fast_tracepoint
/* type_wanted */,
11946 0 /* Ignore count */,
11947 pending_break_support
,
11952 set_tracepoint_count (breakpoint_count
);
11955 /* strace command implementation. Creates a static tracepoint. */
11958 strace_command (char *arg
, int from_tty
)
11960 if (create_breakpoint (get_current_arch (),
11962 NULL
, 0, 1 /* parse arg */,
11964 bp_static_tracepoint
/* type_wanted */,
11965 0 /* Ignore count */,
11966 pending_break_support
,
11971 set_tracepoint_count (breakpoint_count
);
11974 /* Set up a fake reader function that gets command lines from a linked
11975 list that was acquired during tracepoint uploading. */
11977 static struct uploaded_tp
*this_utp
;
11978 static int next_cmd
;
11981 read_uploaded_action (void)
11985 VEC_iterate (char_ptr
, this_utp
->cmd_strings
, next_cmd
, rslt
);
11992 /* Given information about a tracepoint as recorded on a target (which
11993 can be either a live system or a trace file), attempt to create an
11994 equivalent GDB tracepoint. This is not a reliable process, since
11995 the target does not necessarily have all the information used when
11996 the tracepoint was originally defined. */
11998 struct breakpoint
*
11999 create_tracepoint_from_upload (struct uploaded_tp
*utp
)
12001 char *addr_str
, small_buf
[100];
12002 struct breakpoint
*tp
;
12004 if (utp
->at_string
)
12005 addr_str
= utp
->at_string
;
12008 /* In the absence of a source location, fall back to raw
12009 address. Since there is no way to confirm that the address
12010 means the same thing as when the trace was started, warn the
12012 warning (_("Uploaded tracepoint %d has no "
12013 "source location, using raw address"),
12015 sprintf (small_buf
, "*%s", hex_string (utp
->addr
));
12016 addr_str
= small_buf
;
12019 /* There's not much we can do with a sequence of bytecodes. */
12020 if (utp
->cond
&& !utp
->cond_string
)
12021 warning (_("Uploaded tracepoint %d condition "
12022 "has no source form, ignoring it"),
12025 if (!create_breakpoint (get_current_arch (),
12027 utp
->cond_string
, -1, 0 /* parse cond/thread */,
12029 utp
->type
/* type_wanted */,
12030 0 /* Ignore count */,
12031 pending_break_support
,
12034 utp
->enabled
/* enabled */,
12038 set_tracepoint_count (breakpoint_count
);
12040 /* Get the tracepoint we just created. */
12041 tp
= get_tracepoint (tracepoint_count
);
12042 gdb_assert (tp
!= NULL
);
12046 sprintf (small_buf
, "%d %d", utp
->pass
, tp
->number
);
12048 trace_pass_command (small_buf
, 0);
12051 /* If we have uploaded versions of the original commands, set up a
12052 special-purpose "reader" function and call the usual command line
12053 reader, then pass the result to the breakpoint command-setting
12055 if (!VEC_empty (char_ptr
, utp
->cmd_strings
))
12057 struct command_line
*cmd_list
;
12062 cmd_list
= read_command_lines_1 (read_uploaded_action
, 1, NULL
, NULL
);
12064 breakpoint_set_commands (tp
, cmd_list
);
12066 else if (!VEC_empty (char_ptr
, utp
->actions
)
12067 || !VEC_empty (char_ptr
, utp
->step_actions
))
12068 warning (_("Uploaded tracepoint %d actions "
12069 "have no source form, ignoring them"),
12075 /* Print information on tracepoint number TPNUM_EXP, or all if
12079 tracepoints_info (char *args
, int from_tty
)
12083 num_printed
= breakpoint_1 (args
, 0, is_tracepoint
);
12085 if (num_printed
== 0)
12087 if (args
== NULL
|| *args
== '\0')
12088 ui_out_message (uiout
, 0, "No tracepoints.\n");
12090 ui_out_message (uiout
, 0, "No tracepoint matching '%s'.\n", args
);
12093 default_collect_info ();
12096 /* The 'enable trace' command enables tracepoints.
12097 Not supported by all targets. */
12099 enable_trace_command (char *args
, int from_tty
)
12101 enable_command (args
, from_tty
);
12104 /* The 'disable trace' command disables tracepoints.
12105 Not supported by all targets. */
12107 disable_trace_command (char *args
, int from_tty
)
12109 disable_command (args
, from_tty
);
12112 /* Remove a tracepoint (or all if no argument). */
12114 delete_trace_command (char *arg
, int from_tty
)
12116 struct breakpoint
*b
, *b_tmp
;
12122 int breaks_to_delete
= 0;
12124 /* Delete all breakpoints if no argument.
12125 Do not delete internal or call-dummy breakpoints, these
12126 have to be deleted with an explicit breakpoint number
12128 ALL_TRACEPOINTS (b
)
12130 if (b
->number
>= 0)
12132 breaks_to_delete
= 1;
12137 /* Ask user only if there are some breakpoints to delete. */
12139 || (breaks_to_delete
&& query (_("Delete all tracepoints? "))))
12141 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
12143 if (is_tracepoint (b
)
12145 delete_breakpoint (b
);
12150 map_breakpoint_numbers (arg
, do_delete_breakpoint
, NULL
);
12153 /* Helper function for trace_pass_command. */
12156 trace_pass_set_count (struct breakpoint
*bp
, int count
, int from_tty
)
12158 bp
->pass_count
= count
;
12159 observer_notify_tracepoint_modified (bp
->number
);
12161 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
12162 bp
->number
, count
);
12165 /* Set passcount for tracepoint.
12167 First command argument is passcount, second is tracepoint number.
12168 If tracepoint number omitted, apply to most recently defined.
12169 Also accepts special argument "all". */
12172 trace_pass_command (char *args
, int from_tty
)
12174 struct breakpoint
*t1
;
12175 unsigned int count
;
12177 if (args
== 0 || *args
== 0)
12178 error (_("passcount command requires an "
12179 "argument (count + optional TP num)"));
12181 count
= strtoul (args
, &args
, 10); /* Count comes first, then TP num. */
12183 while (*args
&& isspace ((int) *args
))
12186 if (*args
&& strncasecmp (args
, "all", 3) == 0)
12188 args
+= 3; /* Skip special argument "all". */
12190 error (_("Junk at end of arguments."));
12192 ALL_TRACEPOINTS (t1
)
12194 trace_pass_set_count (t1
, count
, from_tty
);
12197 else if (*args
== '\0')
12199 t1
= get_tracepoint_by_number (&args
, NULL
, 1);
12201 trace_pass_set_count (t1
, count
, from_tty
);
12205 struct get_number_or_range_state state
;
12207 init_number_or_range (&state
, args
);
12208 while (!state
.finished
)
12210 t1
= get_tracepoint_by_number (&args
, &state
, 1);
12212 trace_pass_set_count (t1
, count
, from_tty
);
12217 struct breakpoint
*
12218 get_tracepoint (int num
)
12220 struct breakpoint
*t
;
12222 ALL_TRACEPOINTS (t
)
12223 if (t
->number
== num
)
12229 /* Find the tracepoint with the given target-side number (which may be
12230 different from the tracepoint number after disconnecting and
12233 struct breakpoint
*
12234 get_tracepoint_by_number_on_target (int num
)
12236 struct breakpoint
*t
;
12238 ALL_TRACEPOINTS (t
)
12239 if (t
->number_on_target
== num
)
12245 /* Utility: parse a tracepoint number and look it up in the list.
12246 If STATE is not NULL, use, get_number_or_range_state and ignore ARG.
12247 If OPTIONAL_P is true, then if the argument is missing, the most
12248 recent tracepoint (tracepoint_count) is returned. */
12249 struct breakpoint
*
12250 get_tracepoint_by_number (char **arg
,
12251 struct get_number_or_range_state
*state
,
12254 extern int tracepoint_count
;
12255 struct breakpoint
*t
;
12257 char *instring
= arg
== NULL
? NULL
: *arg
;
12261 gdb_assert (!state
->finished
);
12262 tpnum
= get_number_or_range (state
);
12264 else if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
12267 tpnum
= tracepoint_count
;
12269 error_no_arg (_("tracepoint number"));
12272 tpnum
= get_number (arg
);
12276 if (instring
&& *instring
)
12277 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
12280 printf_filtered (_("Tracepoint argument missing "
12281 "and no previous tracepoint\n"));
12285 ALL_TRACEPOINTS (t
)
12286 if (t
->number
== tpnum
)
12291 printf_unfiltered ("No tracepoint number %d.\n", tpnum
);
12295 /* Save information on user settable breakpoints (watchpoints, etc) to
12296 a new script file named FILENAME. If FILTER is non-NULL, call it
12297 on each breakpoint and only include the ones for which it returns
12301 save_breakpoints (char *filename
, int from_tty
,
12302 int (*filter
) (const struct breakpoint
*))
12304 struct breakpoint
*tp
;
12307 struct cleanup
*cleanup
;
12308 struct ui_file
*fp
;
12309 int extra_trace_bits
= 0;
12311 if (filename
== 0 || *filename
== 0)
12312 error (_("Argument required (file name in which to save)"));
12314 /* See if we have anything to save. */
12315 ALL_BREAKPOINTS (tp
)
12317 /* Skip internal and momentary breakpoints. */
12318 if (!user_breakpoint_p (tp
))
12321 /* If we have a filter, only save the breakpoints it accepts. */
12322 if (filter
&& !filter (tp
))
12327 if (is_tracepoint (tp
))
12329 extra_trace_bits
= 1;
12331 /* We can stop searching. */
12338 warning (_("Nothing to save."));
12342 pathname
= tilde_expand (filename
);
12343 cleanup
= make_cleanup (xfree
, pathname
);
12344 fp
= gdb_fopen (pathname
, "w");
12346 error (_("Unable to open file '%s' for saving (%s)"),
12347 filename
, safe_strerror (errno
));
12348 make_cleanup_ui_file_delete (fp
);
12350 if (extra_trace_bits
)
12351 save_trace_state_variables (fp
);
12353 ALL_BREAKPOINTS (tp
)
12355 /* Skip internal and momentary breakpoints. */
12356 if (!user_breakpoint_p (tp
))
12359 /* If we have a filter, only save the breakpoints it accepts. */
12360 if (filter
&& !filter (tp
))
12363 if (tp
->ops
!= NULL
)
12364 (tp
->ops
->print_recreate
) (tp
, fp
);
12367 if (tp
->type
== bp_fast_tracepoint
)
12368 fprintf_unfiltered (fp
, "ftrace");
12369 if (tp
->type
== bp_static_tracepoint
)
12370 fprintf_unfiltered (fp
, "strace");
12371 else if (tp
->type
== bp_tracepoint
)
12372 fprintf_unfiltered (fp
, "trace");
12373 else if (tp
->type
== bp_breakpoint
&& tp
->disposition
== disp_del
)
12374 fprintf_unfiltered (fp
, "tbreak");
12375 else if (tp
->type
== bp_breakpoint
)
12376 fprintf_unfiltered (fp
, "break");
12377 else if (tp
->type
== bp_hardware_breakpoint
12378 && tp
->disposition
== disp_del
)
12379 fprintf_unfiltered (fp
, "thbreak");
12380 else if (tp
->type
== bp_hardware_breakpoint
)
12381 fprintf_unfiltered (fp
, "hbreak");
12382 else if (tp
->type
== bp_watchpoint
)
12383 fprintf_unfiltered (fp
, "watch");
12384 else if (tp
->type
== bp_hardware_watchpoint
)
12385 fprintf_unfiltered (fp
, "watch");
12386 else if (tp
->type
== bp_read_watchpoint
)
12387 fprintf_unfiltered (fp
, "rwatch");
12388 else if (tp
->type
== bp_access_watchpoint
)
12389 fprintf_unfiltered (fp
, "awatch");
12391 internal_error (__FILE__
, __LINE__
,
12392 _("unhandled breakpoint type %d"), (int) tp
->type
);
12394 if (tp
->exp_string
)
12395 fprintf_unfiltered (fp
, " %s", tp
->exp_string
);
12396 else if (tp
->addr_string
)
12397 fprintf_unfiltered (fp
, " %s", tp
->addr_string
);
12402 sprintf_vma (tmp
, tp
->loc
->address
);
12403 fprintf_unfiltered (fp
, " *0x%s", tmp
);
12407 if (tp
->thread
!= -1)
12408 fprintf_unfiltered (fp
, " thread %d", tp
->thread
);
12411 fprintf_unfiltered (fp
, " task %d", tp
->task
);
12413 fprintf_unfiltered (fp
, "\n");
12415 /* Note, we can't rely on tp->number for anything, as we can't
12416 assume the recreated breakpoint numbers will match. Use $bpnum
12419 if (tp
->cond_string
)
12420 fprintf_unfiltered (fp
, " condition $bpnum %s\n", tp
->cond_string
);
12422 if (tp
->ignore_count
)
12423 fprintf_unfiltered (fp
, " ignore $bpnum %d\n", tp
->ignore_count
);
12425 if (tp
->pass_count
)
12426 fprintf_unfiltered (fp
, " passcount %d\n", tp
->pass_count
);
12430 volatile struct gdb_exception ex
;
12432 fprintf_unfiltered (fp
, " commands\n");
12434 ui_out_redirect (uiout
, fp
);
12435 TRY_CATCH (ex
, RETURN_MASK_ALL
)
12437 print_command_lines (uiout
, tp
->commands
->commands
, 2);
12439 ui_out_redirect (uiout
, NULL
);
12442 throw_exception (ex
);
12444 fprintf_unfiltered (fp
, " end\n");
12447 if (tp
->enable_state
== bp_disabled
)
12448 fprintf_unfiltered (fp
, "disable\n");
12450 /* If this is a multi-location breakpoint, check if the locations
12451 should be individually disabled. Watchpoint locations are
12452 special, and not user visible. */
12453 if (!is_watchpoint (tp
) && tp
->loc
&& tp
->loc
->next
)
12455 struct bp_location
*loc
;
12458 for (loc
= tp
->loc
; loc
!= NULL
; loc
= loc
->next
, n
++)
12460 fprintf_unfiltered (fp
, "disable $bpnum.%d\n", n
);
12464 if (extra_trace_bits
&& *default_collect
)
12465 fprintf_unfiltered (fp
, "set default-collect %s\n", default_collect
);
12467 do_cleanups (cleanup
);
12469 printf_filtered (_("Saved to file '%s'.\n"), filename
);
12472 /* The `save breakpoints' command. */
12475 save_breakpoints_command (char *args
, int from_tty
)
12477 save_breakpoints (args
, from_tty
, NULL
);
12480 /* The `save tracepoints' command. */
12483 save_tracepoints_command (char *args
, int from_tty
)
12485 save_breakpoints (args
, from_tty
, is_tracepoint
);
12488 /* Create a vector of all tracepoints. */
12490 VEC(breakpoint_p
) *
12491 all_tracepoints (void)
12493 VEC(breakpoint_p
) *tp_vec
= 0;
12494 struct breakpoint
*tp
;
12496 ALL_TRACEPOINTS (tp
)
12498 VEC_safe_push (breakpoint_p
, tp_vec
, tp
);
12505 /* This help string is used for the break, hbreak, tbreak and thbreak
12506 commands. It is defined as a macro to prevent duplication.
12507 COMMAND should be a string constant containing the name of the
12509 #define BREAK_ARGS_HELP(command) \
12510 command" [LOCATION] [thread THREADNUM] [if CONDITION]\n\
12511 LOCATION may be a line number, function name, or \"*\" and an address.\n\
12512 If a line number is specified, break at start of code for that line.\n\
12513 If a function is specified, break at start of code for that function.\n\
12514 If an address is specified, break at that exact address.\n\
12515 With no LOCATION, uses current execution address of the selected\n\
12516 stack frame. This is useful for breaking on return to a stack frame.\n\
12518 THREADNUM is the number from \"info threads\".\n\
12519 CONDITION is a boolean expression.\n\
12521 Multiple breakpoints at one place are permitted, and useful if their\n\
12522 conditions are different.\n\
12524 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
12526 /* List of subcommands for "catch". */
12527 static struct cmd_list_element
*catch_cmdlist
;
12529 /* List of subcommands for "tcatch". */
12530 static struct cmd_list_element
*tcatch_cmdlist
;
12532 /* Like add_cmd, but add the command to both the "catch" and "tcatch"
12533 lists, and pass some additional user data to the command function. */
12535 add_catch_command (char *name
, char *docstring
,
12536 void (*sfunc
) (char *args
, int from_tty
,
12537 struct cmd_list_element
*command
),
12538 char **(*completer
) (struct cmd_list_element
*cmd
,
12539 char *text
, char *word
),
12540 void *user_data_catch
,
12541 void *user_data_tcatch
)
12543 struct cmd_list_element
*command
;
12545 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
12547 set_cmd_sfunc (command
, sfunc
);
12548 set_cmd_context (command
, user_data_catch
);
12549 set_cmd_completer (command
, completer
);
12551 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
12553 set_cmd_sfunc (command
, sfunc
);
12554 set_cmd_context (command
, user_data_tcatch
);
12555 set_cmd_completer (command
, completer
);
12559 clear_syscall_counts (struct inferior
*inf
)
12561 inf
->total_syscalls_count
= 0;
12562 inf
->any_syscall_count
= 0;
12563 VEC_free (int, inf
->syscalls_counts
);
12567 save_command (char *arg
, int from_tty
)
12569 printf_unfiltered (_("\"save\" must be followed by "
12570 "the name of a save subcommand.\n"));
12571 help_list (save_cmdlist
, "save ", -1, gdb_stdout
);
12574 struct breakpoint
*
12575 iterate_over_breakpoints (int (*callback
) (struct breakpoint
*, void *),
12578 struct breakpoint
*b
, *b_tmp
;
12580 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
12582 if ((*callback
) (b
, data
))
12590 _initialize_breakpoint (void)
12592 struct cmd_list_element
*c
;
12594 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
12595 observer_attach_inferior_exit (clear_syscall_counts
);
12596 observer_attach_memory_changed (invalidate_bp_value_on_memory_change
);
12598 breakpoint_objfile_key
= register_objfile_data ();
12600 breakpoint_chain
= 0;
12601 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
12602 before a breakpoint is set. */
12603 breakpoint_count
= 0;
12605 tracepoint_count
= 0;
12607 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
12608 Set ignore-count of breakpoint number N to COUNT.\n\
12609 Usage is `ignore N COUNT'."));
12611 add_com_alias ("bc", "ignore", class_breakpoint
, 1);
12613 add_com ("commands", class_breakpoint
, commands_command
, _("\
12614 Set commands to be executed when a breakpoint is hit.\n\
12615 Give breakpoint number as argument after \"commands\".\n\
12616 With no argument, the targeted breakpoint is the last one set.\n\
12617 The commands themselves follow starting on the next line.\n\
12618 Type a line containing \"end\" to indicate the end of them.\n\
12619 Give \"silent\" as the first line to make the breakpoint silent;\n\
12620 then no output is printed when it is hit, except what the commands print."));
12622 add_com ("condition", class_breakpoint
, condition_command
, _("\
12623 Specify breakpoint number N to break only if COND is true.\n\
12624 Usage is `condition N COND', where N is an integer and COND is an\n\
12625 expression to be evaluated whenever breakpoint N is reached."));
12627 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
12628 Set a temporary breakpoint.\n\
12629 Like \"break\" except the breakpoint is only temporary,\n\
12630 so it will be deleted when hit. Equivalent to \"break\" followed\n\
12631 by using \"enable delete\" on the breakpoint number.\n\
12633 BREAK_ARGS_HELP ("tbreak")));
12634 set_cmd_completer (c
, location_completer
);
12636 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
12637 Set a hardware assisted breakpoint.\n\
12638 Like \"break\" except the breakpoint requires hardware support,\n\
12639 some target hardware may not have this support.\n\
12641 BREAK_ARGS_HELP ("hbreak")));
12642 set_cmd_completer (c
, location_completer
);
12644 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
12645 Set a temporary hardware assisted breakpoint.\n\
12646 Like \"hbreak\" except the breakpoint is only temporary,\n\
12647 so it will be deleted when hit.\n\
12649 BREAK_ARGS_HELP ("thbreak")));
12650 set_cmd_completer (c
, location_completer
);
12652 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
12653 Enable some breakpoints.\n\
12654 Give breakpoint numbers (separated by spaces) as arguments.\n\
12655 With no subcommand, breakpoints are enabled until you command otherwise.\n\
12656 This is used to cancel the effect of the \"disable\" command.\n\
12657 With a subcommand you can enable temporarily."),
12658 &enablelist
, "enable ", 1, &cmdlist
);
12660 add_com ("ab", class_breakpoint
, enable_command
, _("\
12661 Enable some breakpoints.\n\
12662 Give breakpoint numbers (separated by spaces) as arguments.\n\
12663 With no subcommand, breakpoints are enabled until you command otherwise.\n\
12664 This is used to cancel the effect of the \"disable\" command.\n\
12665 With a subcommand you can enable temporarily."));
12667 add_com_alias ("en", "enable", class_breakpoint
, 1);
12669 add_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
12670 Enable some breakpoints.\n\
12671 Give breakpoint numbers (separated by spaces) as arguments.\n\
12672 This is used to cancel the effect of the \"disable\" command.\n\
12673 May be abbreviated to simply \"enable\".\n"),
12674 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
12676 add_cmd ("once", no_class
, enable_once_command
, _("\
12677 Enable breakpoints for one hit. Give breakpoint numbers.\n\
12678 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
12681 add_cmd ("delete", no_class
, enable_delete_command
, _("\
12682 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
12683 If a breakpoint is hit while enabled in this fashion, it is deleted."),
12686 add_cmd ("delete", no_class
, enable_delete_command
, _("\
12687 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
12688 If a breakpoint is hit while enabled in this fashion, it is deleted."),
12691 add_cmd ("once", no_class
, enable_once_command
, _("\
12692 Enable breakpoints for one hit. Give breakpoint numbers.\n\
12693 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
12696 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
12697 Disable some breakpoints.\n\
12698 Arguments are breakpoint numbers with spaces in between.\n\
12699 To disable all breakpoints, give no argument.\n\
12700 A disabled breakpoint is not forgotten, but has no effect until reenabled."),
12701 &disablelist
, "disable ", 1, &cmdlist
);
12702 add_com_alias ("dis", "disable", class_breakpoint
, 1);
12703 add_com_alias ("disa", "disable", class_breakpoint
, 1);
12705 add_com ("sb", class_breakpoint
, disable_command
, _("\
12706 Disable some breakpoints.\n\
12707 Arguments are breakpoint numbers with spaces in between.\n\
12708 To disable all breakpoints, give no argument.\n\
12709 A disabled breakpoint is not forgotten, but has no effect until reenabled."));
12711 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
12712 Disable some breakpoints.\n\
12713 Arguments are breakpoint numbers with spaces in between.\n\
12714 To disable all breakpoints, give no argument.\n\
12715 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
12716 This command may be abbreviated \"disable\"."),
12719 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
12720 Delete some breakpoints or auto-display expressions.\n\
12721 Arguments are breakpoint numbers with spaces in between.\n\
12722 To delete all breakpoints, give no argument.\n\
12724 Also a prefix command for deletion of other GDB objects.\n\
12725 The \"unset\" command is also an alias for \"delete\"."),
12726 &deletelist
, "delete ", 1, &cmdlist
);
12727 add_com_alias ("d", "delete", class_breakpoint
, 1);
12728 add_com_alias ("del", "delete", class_breakpoint
, 1);
12730 add_com ("db", class_breakpoint
, delete_command
, _("\
12731 Delete some breakpoints.\n\
12732 Arguments are breakpoint numbers with spaces in between.\n\
12733 To delete all breakpoints, give no argument.\n"));
12735 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
12736 Delete some breakpoints or auto-display expressions.\n\
12737 Arguments are breakpoint numbers with spaces in between.\n\
12738 To delete all breakpoints, give no argument.\n\
12739 This command may be abbreviated \"delete\"."),
12742 add_com ("clear", class_breakpoint
, clear_command
, _("\
12743 Clear breakpoint at specified line or function.\n\
12744 Argument may be line number, function name, or \"*\" and an address.\n\
12745 If line number is specified, all breakpoints in that line are cleared.\n\
12746 If function is specified, breakpoints at beginning of function are cleared.\n\
12747 If an address is specified, breakpoints at that address are cleared.\n\
12749 With no argument, clears all breakpoints in the line that the selected frame\n\
12750 is executing in.\n\
12752 See also the \"delete\" command which clears breakpoints by number."));
12753 add_com_alias ("cl", "clear", class_breakpoint
, 1);
12755 c
= add_com ("break", class_breakpoint
, break_command
, _("\
12756 Set breakpoint at specified line or function.\n"
12757 BREAK_ARGS_HELP ("break")));
12758 set_cmd_completer (c
, location_completer
);
12760 add_com_alias ("b", "break", class_run
, 1);
12761 add_com_alias ("br", "break", class_run
, 1);
12762 add_com_alias ("bre", "break", class_run
, 1);
12763 add_com_alias ("brea", "break", class_run
, 1);
12766 add_com_alias ("ba", "break", class_breakpoint
, 1);
12770 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
12771 Break in function/address or break at a line in the current file."),
12772 &stoplist
, "stop ", 1, &cmdlist
);
12773 add_cmd ("in", class_breakpoint
, stopin_command
,
12774 _("Break in function or address."), &stoplist
);
12775 add_cmd ("at", class_breakpoint
, stopat_command
,
12776 _("Break at a line in the current file."), &stoplist
);
12777 add_com ("status", class_info
, breakpoints_info
, _("\
12778 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
12779 The \"Type\" column indicates one of:\n\
12780 \tbreakpoint - normal breakpoint\n\
12781 \twatchpoint - watchpoint\n\
12782 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
12783 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
12784 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
12785 address and file/line number respectively.\n\
12787 Convenience variable \"$_\" and default examine address for \"x\"\n\
12788 are set to the address of the last breakpoint listed unless the command\n\
12789 is prefixed with \"server \".\n\n\
12790 Convenience variable \"$bpnum\" contains the number of the last\n\
12791 breakpoint set."));
12794 add_info ("breakpoints", breakpoints_info
, _("\
12795 Status of specified breakpoints (all user-settable breakpoints if no argument).\n\
12796 The \"Type\" column indicates one of:\n\
12797 \tbreakpoint - normal breakpoint\n\
12798 \twatchpoint - watchpoint\n\
12799 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
12800 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
12801 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
12802 address and file/line number respectively.\n\
12804 Convenience variable \"$_\" and default examine address for \"x\"\n\
12805 are set to the address of the last breakpoint listed unless the command\n\
12806 is prefixed with \"server \".\n\n\
12807 Convenience variable \"$bpnum\" contains the number of the last\n\
12808 breakpoint set."));
12810 add_info_alias ("b", "breakpoints", 1);
12813 add_com ("lb", class_breakpoint
, breakpoints_info
, _("\
12814 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
12815 The \"Type\" column indicates one of:\n\
12816 \tbreakpoint - normal breakpoint\n\
12817 \twatchpoint - watchpoint\n\
12818 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
12819 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
12820 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
12821 address and file/line number respectively.\n\
12823 Convenience variable \"$_\" and default examine address for \"x\"\n\
12824 are set to the address of the last breakpoint listed unless the command\n\
12825 is prefixed with \"server \".\n\n\
12826 Convenience variable \"$bpnum\" contains the number of the last\n\
12827 breakpoint set."));
12829 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
12830 Status of all breakpoints, or breakpoint number NUMBER.\n\
12831 The \"Type\" column indicates one of:\n\
12832 \tbreakpoint - normal breakpoint\n\
12833 \twatchpoint - watchpoint\n\
12834 \tlongjmp - internal breakpoint used to step through longjmp()\n\
12835 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
12836 \tuntil - internal breakpoint used by the \"until\" command\n\
12837 \tfinish - internal breakpoint used by the \"finish\" command\n\
12838 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
12839 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
12840 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
12841 address and file/line number respectively.\n\
12843 Convenience variable \"$_\" and default examine address for \"x\"\n\
12844 are set to the address of the last breakpoint listed unless the command\n\
12845 is prefixed with \"server \".\n\n\
12846 Convenience variable \"$bpnum\" contains the number of the last\n\
12848 &maintenanceinfolist
);
12850 add_prefix_cmd ("catch", class_breakpoint
, catch_command
, _("\
12851 Set catchpoints to catch events."),
12852 &catch_cmdlist
, "catch ",
12853 0/*allow-unknown*/, &cmdlist
);
12855 add_prefix_cmd ("tcatch", class_breakpoint
, tcatch_command
, _("\
12856 Set temporary catchpoints to catch events."),
12857 &tcatch_cmdlist
, "tcatch ",
12858 0/*allow-unknown*/, &cmdlist
);
12860 /* Add catch and tcatch sub-commands. */
12861 add_catch_command ("catch", _("\
12862 Catch an exception, when caught.\n\
12863 With an argument, catch only exceptions with the given name."),
12864 catch_catch_command
,
12868 add_catch_command ("throw", _("\
12869 Catch an exception, when thrown.\n\
12870 With an argument, catch only exceptions with the given name."),
12871 catch_throw_command
,
12875 add_catch_command ("fork", _("Catch calls to fork."),
12876 catch_fork_command_1
,
12878 (void *) (uintptr_t) catch_fork_permanent
,
12879 (void *) (uintptr_t) catch_fork_temporary
);
12880 add_catch_command ("vfork", _("Catch calls to vfork."),
12881 catch_fork_command_1
,
12883 (void *) (uintptr_t) catch_vfork_permanent
,
12884 (void *) (uintptr_t) catch_vfork_temporary
);
12885 add_catch_command ("exec", _("Catch calls to exec."),
12886 catch_exec_command_1
,
12890 add_catch_command ("syscall", _("\
12891 Catch system calls by their names and/or numbers.\n\
12892 Arguments say which system calls to catch. If no arguments\n\
12893 are given, every system call will be caught.\n\
12894 Arguments, if given, should be one or more system call names\n\
12895 (if your system supports that), or system call numbers."),
12896 catch_syscall_command_1
,
12897 catch_syscall_completer
,
12900 add_catch_command ("exception", _("\
12901 Catch Ada exceptions, when raised.\n\
12902 With an argument, catch only exceptions with the given name."),
12903 catch_ada_exception_command
,
12907 add_catch_command ("assert", _("\
12908 Catch failed Ada assertions, when raised.\n\
12909 With an argument, catch only exceptions with the given name."),
12910 catch_assert_command
,
12915 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
12916 Set a watchpoint for an expression.\n\
12917 Usage: watch [-l|-location] EXPRESSION\n\
12918 A watchpoint stops execution of your program whenever the value of\n\
12919 an expression changes.\n\
12920 If -l or -location is given, this evaluates EXPRESSION and watches\n\
12921 the memory to which it refers."));
12922 set_cmd_completer (c
, expression_completer
);
12924 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
12925 Set a read watchpoint for an expression.\n\
12926 Usage: rwatch [-l|-location] EXPRESSION\n\
12927 A watchpoint stops execution of your program whenever the value of\n\
12928 an expression is read.\n\
12929 If -l or -location is given, this evaluates EXPRESSION and watches\n\
12930 the memory to which it refers."));
12931 set_cmd_completer (c
, expression_completer
);
12933 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
12934 Set a watchpoint for an expression.\n\
12935 Usage: awatch [-l|-location] EXPRESSION\n\
12936 A watchpoint stops execution of your program whenever the value of\n\
12937 an expression is either read or written.\n\
12938 If -l or -location is given, this evaluates EXPRESSION and watches\n\
12939 the memory to which it refers."));
12940 set_cmd_completer (c
, expression_completer
);
12942 add_info ("watchpoints", watchpoints_info
, _("\
12943 Status of specified watchpoints (all watchpoints if no argument)."));
12945 /* XXX: cagney/2005-02-23: This should be a boolean, and should
12946 respond to changes - contrary to the description. */
12947 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
12948 &can_use_hw_watchpoints
, _("\
12949 Set debugger's willingness to use watchpoint hardware."), _("\
12950 Show debugger's willingness to use watchpoint hardware."), _("\
12951 If zero, gdb will not use hardware for new watchpoints, even if\n\
12952 such is available. (However, any hardware watchpoints that were\n\
12953 created before setting this to nonzero, will continue to use watchpoint\n\
12956 show_can_use_hw_watchpoints
,
12957 &setlist
, &showlist
);
12959 can_use_hw_watchpoints
= 1;
12961 /* Tracepoint manipulation commands. */
12963 c
= add_com ("trace", class_breakpoint
, trace_command
, _("\
12964 Set a tracepoint at specified line or function.\n\
12966 BREAK_ARGS_HELP ("trace") "\n\
12967 Do \"help tracepoints\" for info on other tracepoint commands."));
12968 set_cmd_completer (c
, location_completer
);
12970 add_com_alias ("tp", "trace", class_alias
, 0);
12971 add_com_alias ("tr", "trace", class_alias
, 1);
12972 add_com_alias ("tra", "trace", class_alias
, 1);
12973 add_com_alias ("trac", "trace", class_alias
, 1);
12975 c
= add_com ("ftrace", class_breakpoint
, ftrace_command
, _("\
12976 Set a fast tracepoint at specified line or function.\n\
12978 BREAK_ARGS_HELP ("ftrace") "\n\
12979 Do \"help tracepoints\" for info on other tracepoint commands."));
12980 set_cmd_completer (c
, location_completer
);
12982 c
= add_com ("strace", class_breakpoint
, strace_command
, _("\
12983 Set a static tracepoint at specified line, function or marker.\n\
12985 strace [LOCATION] [if CONDITION]\n\
12986 LOCATION may be a line number, function name, \"*\" and an address,\n\
12987 or -m MARKER_ID.\n\
12988 If a line number is specified, probe the marker at start of code\n\
12989 for that line. If a function is specified, probe the marker at start\n\
12990 of code for that function. If an address is specified, probe the marker\n\
12991 at that exact address. If a marker id is specified, probe the marker\n\
12992 with that name. With no LOCATION, uses current execution address of\n\
12993 the selected stack frame.\n\
12994 Static tracepoints accept an extra collect action -- ``collect $_sdata''.\n\
12995 This collects arbitrary user data passed in the probe point call to the\n\
12996 tracing library. You can inspect it when analyzing the trace buffer,\n\
12997 by printing the $_sdata variable like any other convenience variable.\n\
12999 CONDITION is a boolean expression.\n\
13001 Multiple tracepoints at one place are permitted, and useful if their\n\
13002 conditions are different.\n\
13004 Do \"help breakpoints\" for info on other commands dealing with breakpoints.\n\
13005 Do \"help tracepoints\" for info on other tracepoint commands."));
13006 set_cmd_completer (c
, location_completer
);
13008 add_info ("tracepoints", tracepoints_info
, _("\
13009 Status of specified tracepoints (all tracepoints if no argument).\n\
13010 Convenience variable \"$tpnum\" contains the number of the\n\
13011 last tracepoint set."));
13013 add_info_alias ("tp", "tracepoints", 1);
13015 add_cmd ("tracepoints", class_trace
, delete_trace_command
, _("\
13016 Delete specified tracepoints.\n\
13017 Arguments are tracepoint numbers, separated by spaces.\n\
13018 No argument means delete all tracepoints."),
13021 c
= add_cmd ("tracepoints", class_trace
, disable_trace_command
, _("\
13022 Disable specified tracepoints.\n\
13023 Arguments are tracepoint numbers, separated by spaces.\n\
13024 No argument means disable all tracepoints."),
13026 deprecate_cmd (c
, "disable");
13028 c
= add_cmd ("tracepoints", class_trace
, enable_trace_command
, _("\
13029 Enable specified tracepoints.\n\
13030 Arguments are tracepoint numbers, separated by spaces.\n\
13031 No argument means enable all tracepoints."),
13033 deprecate_cmd (c
, "enable");
13035 add_com ("passcount", class_trace
, trace_pass_command
, _("\
13036 Set the passcount for a tracepoint.\n\
13037 The trace will end when the tracepoint has been passed 'count' times.\n\
13038 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
13039 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
13041 add_prefix_cmd ("save", class_breakpoint
, save_command
,
13042 _("Save breakpoint definitions as a script."),
13043 &save_cmdlist
, "save ",
13044 0/*allow-unknown*/, &cmdlist
);
13046 c
= add_cmd ("breakpoints", class_breakpoint
, save_breakpoints_command
, _("\
13047 Save current breakpoint definitions as a script.\n\
13048 This includes all types of breakpoints (breakpoints, watchpoints,\n\
13049 catchpoints, tracepoints). Use the 'source' command in another debug\n\
13050 session to restore them."),
13052 set_cmd_completer (c
, filename_completer
);
13054 c
= add_cmd ("tracepoints", class_trace
, save_tracepoints_command
, _("\
13055 Save current tracepoint definitions as a script.\n\
13056 Use the 'source' command in another debug session to restore them."),
13058 set_cmd_completer (c
, filename_completer
);
13060 c
= add_com_alias ("save-tracepoints", "save tracepoints", class_trace
, 0);
13061 deprecate_cmd (c
, "save tracepoints");
13063 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
13064 Breakpoint specific settings\n\
13065 Configure various breakpoint-specific variables such as\n\
13066 pending breakpoint behavior"),
13067 &breakpoint_set_cmdlist
, "set breakpoint ",
13068 0/*allow-unknown*/, &setlist
);
13069 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
13070 Breakpoint specific settings\n\
13071 Configure various breakpoint-specific variables such as\n\
13072 pending breakpoint behavior"),
13073 &breakpoint_show_cmdlist
, "show breakpoint ",
13074 0/*allow-unknown*/, &showlist
);
13076 add_setshow_auto_boolean_cmd ("pending", no_class
,
13077 &pending_break_support
, _("\
13078 Set debugger's behavior regarding pending breakpoints."), _("\
13079 Show debugger's behavior regarding pending breakpoints."), _("\
13080 If on, an unrecognized breakpoint location will cause gdb to create a\n\
13081 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
13082 an error. If auto, an unrecognized breakpoint location results in a\n\
13083 user-query to see if a pending breakpoint should be created."),
13085 show_pending_break_support
,
13086 &breakpoint_set_cmdlist
,
13087 &breakpoint_show_cmdlist
);
13089 pending_break_support
= AUTO_BOOLEAN_AUTO
;
13091 add_setshow_boolean_cmd ("auto-hw", no_class
,
13092 &automatic_hardware_breakpoints
, _("\
13093 Set automatic usage of hardware breakpoints."), _("\
13094 Show automatic usage of hardware breakpoints."), _("\
13095 If set, the debugger will automatically use hardware breakpoints for\n\
13096 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
13097 a warning will be emitted for such breakpoints."),
13099 show_automatic_hardware_breakpoints
,
13100 &breakpoint_set_cmdlist
,
13101 &breakpoint_show_cmdlist
);
13103 add_setshow_enum_cmd ("always-inserted", class_support
,
13104 always_inserted_enums
, &always_inserted_mode
, _("\
13105 Set mode for inserting breakpoints."), _("\
13106 Show mode for inserting breakpoints."), _("\
13107 When this mode is off, breakpoints are inserted in inferior when it is\n\
13108 resumed, and removed when execution stops. When this mode is on,\n\
13109 breakpoints are inserted immediately and removed only when the user\n\
13110 deletes the breakpoint. When this mode is auto (which is the default),\n\
13111 the behaviour depends on the non-stop setting (see help set non-stop).\n\
13112 In this case, if gdb is controlling the inferior in non-stop mode, gdb\n\
13113 behaves as if always-inserted mode is on; if gdb is controlling the\n\
13114 inferior in all-stop mode, gdb behaves as if always-inserted mode is off."),
13116 &show_always_inserted_mode
,
13117 &breakpoint_set_cmdlist
,
13118 &breakpoint_show_cmdlist
);
13120 add_com ("break-range", class_breakpoint
, break_range_command
, _("\
13121 Set a breakpoint for an address range.\n\
13122 break-range START-LOCATION, END-LOCATION\n\
13123 where START-LOCATION and END-LOCATION can be one of the following:\n\
13124 LINENUM, for that line in the current file,\n\
13125 FILE:LINENUM, for that line in that file,\n\
13126 +OFFSET, for that number of lines after the current line\n\
13127 or the start of the range\n\
13128 FUNCTION, for the first line in that function,\n\
13129 FILE:FUNCTION, to distinguish among like-named static functions.\n\
13130 *ADDRESS, for the instruction at that address.\n\
13132 The breakpoint will stop execution of the inferior whenever it executes\n\
13133 an instruction at any address within the [START-LOCATION, END-LOCATION]\n\
13134 range (including START-LOCATION and END-LOCATION)."));
13136 automatic_hardware_breakpoints
= 1;
13138 observer_attach_about_to_proceed (breakpoint_about_to_proceed
);