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"
47 #include "completer.h"
50 #include "cli/cli-script.h"
51 #include "gdb_assert.h"
56 #include "exceptions.h"
63 #include "xml-syscall.h"
64 #include "parser-defs.h"
65 #include "cli/cli-utils.h"
67 /* readline include files */
68 #include "readline/readline.h"
69 #include "readline/history.h"
71 /* readline defines this. */
74 #include "mi/mi-common.h"
75 #include "python/python.h"
77 /* Arguments to pass as context to some catch command handlers. */
78 #define CATCH_PERMANENT ((void *) (uintptr_t) 0)
79 #define CATCH_TEMPORARY ((void *) (uintptr_t) 1)
81 /* Prototypes for local functions. */
83 static void enable_delete_command (char *, int);
85 static void enable_once_command (char *, int);
87 static void disable_command (char *, int);
89 static void enable_command (char *, int);
91 static void map_breakpoint_numbers (char *, void (*) (struct breakpoint
*,
95 static void ignore_command (char *, int);
97 static int breakpoint_re_set_one (void *);
99 static void clear_command (char *, int);
101 static void catch_command (char *, int);
103 static int can_use_hardware_watchpoint (struct value
*, int);
105 static void break_command_1 (char *, int, int);
107 static void mention (struct breakpoint
*);
109 /* This function is used in gdbtk sources and thus can not be made
111 struct breakpoint
*set_raw_breakpoint (struct gdbarch
*gdbarch
,
112 struct symtab_and_line
,
115 static void breakpoint_adjustment_warning (CORE_ADDR
, CORE_ADDR
, int, int);
117 static CORE_ADDR
adjust_breakpoint_address (struct gdbarch
*gdbarch
,
121 static void describe_other_breakpoints (struct gdbarch
*,
122 struct program_space
*, CORE_ADDR
,
123 struct obj_section
*, int);
125 static int breakpoint_address_match (struct address_space
*aspace1
,
127 struct address_space
*aspace2
,
130 static int watchpoint_locations_match (struct bp_location
*loc1
,
131 struct bp_location
*loc2
);
133 static void breakpoints_info (char *, int);
135 static void watchpoints_info (char *, int);
137 static int breakpoint_1 (char *, int,
138 int (*) (const struct breakpoint
*));
140 static int breakpoint_cond_eval (void *);
142 static void cleanup_executing_breakpoints (void *);
144 static void commands_command (char *, int);
146 static void condition_command (char *, int);
155 static int remove_breakpoint (struct bp_location
*, insertion_state_t
);
156 static int remove_breakpoint_1 (struct bp_location
*, insertion_state_t
);
158 static enum print_stop_action
print_it_typical (bpstat
);
160 static enum print_stop_action
print_bp_stop_message (bpstat bs
);
162 static int watchpoint_check (void *);
164 static void maintenance_info_breakpoints (char *, int);
166 static int hw_breakpoint_used_count (void);
168 static int hw_watchpoint_used_count (enum bptype
, int *);
170 static void hbreak_command (char *, int);
172 static void thbreak_command (char *, int);
174 static void do_enable_breakpoint (struct breakpoint
*, enum bpdisp
);
176 static void stop_command (char *arg
, int from_tty
);
178 static void stopin_command (char *arg
, int from_tty
);
180 static void stopat_command (char *arg
, int from_tty
);
182 static char *ep_parse_optional_if_clause (char **arg
);
184 static void catch_exception_command_1 (enum exception_event_kind ex_event
,
185 char *arg
, int tempflag
, int from_tty
);
187 static void tcatch_command (char *arg
, int from_tty
);
189 static void detach_single_step_breakpoints (void);
191 static int single_step_breakpoint_inserted_here_p (struct address_space
*,
194 static void free_bp_location (struct bp_location
*loc
);
195 static void incref_bp_location (struct bp_location
*loc
);
196 static void decref_bp_location (struct bp_location
**loc
);
198 static struct bp_location
*allocate_bp_location (struct breakpoint
*bpt
);
200 static void update_global_location_list (int);
202 static void update_global_location_list_nothrow (int);
204 static int is_hardware_watchpoint (const struct breakpoint
*bpt
);
206 static int is_watchpoint (const struct breakpoint
*bpt
);
208 static void insert_breakpoint_locations (void);
210 static int syscall_catchpoint_p (struct breakpoint
*b
);
212 static void tracepoints_info (char *, int);
214 static void delete_trace_command (char *, int);
216 static void enable_trace_command (char *, int);
218 static void disable_trace_command (char *, int);
220 static void trace_pass_command (char *, int);
222 /* Assuming we're creating a static tracepoint, does S look like a
223 static tracepoint marker spec ("-m MARKER_ID")? */
224 #define is_marker_spec(s) \
225 (s != NULL && strncmp (s, "-m", 2) == 0 && ((s)[2] == ' ' || (s)[2] == '\t'))
227 /* A reference-counted struct command_line. This lets multiple
228 breakpoints share a single command list. */
229 struct counted_command_line
231 /* The reference count. */
234 /* The command list. */
235 struct command_line
*commands
;
238 struct command_line
*
239 breakpoint_commands (struct breakpoint
*b
)
241 return b
->commands
? b
->commands
->commands
: NULL
;
244 /* Flag indicating that a command has proceeded the inferior past the
245 current breakpoint. */
247 static int breakpoint_proceeded
;
250 bpdisp_text (enum bpdisp disp
)
252 /* NOTE: the following values are a part of MI protocol and
253 represent values of 'disp' field returned when inferior stops at
255 static const char * const bpdisps
[] = {"del", "dstp", "dis", "keep"};
257 return bpdisps
[(int) disp
];
260 /* Prototypes for exported functions. */
261 /* If FALSE, gdb will not use hardware support for watchpoints, even
262 if such is available. */
263 static int can_use_hw_watchpoints
;
266 show_can_use_hw_watchpoints (struct ui_file
*file
, int from_tty
,
267 struct cmd_list_element
*c
,
270 fprintf_filtered (file
,
271 _("Debugger's willingness to use "
272 "watchpoint hardware is %s.\n"),
276 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
277 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
278 for unrecognized breakpoint locations.
279 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
280 static enum auto_boolean pending_break_support
;
282 show_pending_break_support (struct ui_file
*file
, int from_tty
,
283 struct cmd_list_element
*c
,
286 fprintf_filtered (file
,
287 _("Debugger's behavior regarding "
288 "pending breakpoints is %s.\n"),
292 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
293 set with "break" but falling in read-only memory.
294 If 0, gdb will warn about such breakpoints, but won't automatically
295 use hardware breakpoints. */
296 static int automatic_hardware_breakpoints
;
298 show_automatic_hardware_breakpoints (struct ui_file
*file
, int from_tty
,
299 struct cmd_list_element
*c
,
302 fprintf_filtered (file
,
303 _("Automatic usage of hardware breakpoints is %s.\n"),
307 /* If on, gdb will keep breakpoints inserted even as inferior is
308 stopped, and immediately insert any new breakpoints. If off, gdb
309 will insert breakpoints into inferior only when resuming it, and
310 will remove breakpoints upon stop. If auto, GDB will behave as ON
311 if in non-stop mode, and as OFF if all-stop mode.*/
313 static const char always_inserted_auto
[] = "auto";
314 static const char always_inserted_on
[] = "on";
315 static const char always_inserted_off
[] = "off";
316 static const char *always_inserted_enums
[] = {
317 always_inserted_auto
,
322 static const char *always_inserted_mode
= always_inserted_auto
;
324 show_always_inserted_mode (struct ui_file
*file
, int from_tty
,
325 struct cmd_list_element
*c
, const char *value
)
327 if (always_inserted_mode
== always_inserted_auto
)
328 fprintf_filtered (file
,
329 _("Always inserted breakpoint "
330 "mode is %s (currently %s).\n"),
332 breakpoints_always_inserted_mode () ? "on" : "off");
334 fprintf_filtered (file
, _("Always inserted breakpoint mode is %s.\n"),
339 breakpoints_always_inserted_mode (void)
341 return (always_inserted_mode
== always_inserted_on
342 || (always_inserted_mode
== always_inserted_auto
&& non_stop
));
345 void _initialize_breakpoint (void);
347 /* Are we executing breakpoint commands? */
348 static int executing_breakpoint_commands
;
350 /* Are overlay event breakpoints enabled? */
351 static int overlay_events_enabled
;
353 /* See description in breakpoint.h. */
354 int target_exact_watchpoints
= 0;
356 /* Walk the following statement or block through all breakpoints.
357 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the
358 current breakpoint. */
360 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
362 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
363 for (B = breakpoint_chain; \
364 B ? (TMP=B->next, 1): 0; \
367 /* Similar iterator for the low-level breakpoints. SAFE variant is
368 not provided so update_global_location_list must not be called
369 while executing the block of ALL_BP_LOCATIONS. */
371 #define ALL_BP_LOCATIONS(B,BP_TMP) \
372 for (BP_TMP = bp_location; \
373 BP_TMP < bp_location + bp_location_count && (B = *BP_TMP); \
376 /* Iterator for tracepoints only. */
378 #define ALL_TRACEPOINTS(B) \
379 for (B = breakpoint_chain; B; B = B->next) \
380 if (is_tracepoint (B))
382 /* Chains of all breakpoints defined. */
384 struct breakpoint
*breakpoint_chain
;
386 /* Array is sorted by bp_location_compare - primarily by the ADDRESS. */
388 static struct bp_location
**bp_location
;
390 /* Number of elements of BP_LOCATION. */
392 static unsigned bp_location_count
;
394 /* Maximum alignment offset between bp_target_info.PLACED_ADDRESS and
395 ADDRESS for the current elements of BP_LOCATION which get a valid
396 result from bp_location_has_shadow. You can use it for roughly
397 limiting the subrange of BP_LOCATION to scan for shadow bytes for
398 an address you need to read. */
400 static CORE_ADDR bp_location_placed_address_before_address_max
;
402 /* Maximum offset plus alignment between bp_target_info.PLACED_ADDRESS
403 + bp_target_info.SHADOW_LEN and ADDRESS for the current elements of
404 BP_LOCATION which get a valid result from bp_location_has_shadow.
405 You can use it for roughly limiting the subrange of BP_LOCATION to
406 scan for shadow bytes for an address you need to read. */
408 static CORE_ADDR bp_location_shadow_len_after_address_max
;
410 /* The locations that no longer correspond to any breakpoint, unlinked
411 from bp_location array, but for which a hit may still be reported
413 VEC(bp_location_p
) *moribund_locations
= NULL
;
415 /* Number of last breakpoint made. */
417 static int breakpoint_count
;
419 /* The value of `breakpoint_count' before the last command that
420 created breakpoints. If the last (break-like) command created more
421 than one breakpoint, then the difference between BREAKPOINT_COUNT
422 and PREV_BREAKPOINT_COUNT is more than one. */
423 static int prev_breakpoint_count
;
425 /* Number of last tracepoint made. */
427 static int tracepoint_count
;
429 static struct cmd_list_element
*breakpoint_set_cmdlist
;
430 static struct cmd_list_element
*breakpoint_show_cmdlist
;
431 struct cmd_list_element
*save_cmdlist
;
433 /* Return whether a breakpoint is an active enabled breakpoint. */
435 breakpoint_enabled (struct breakpoint
*b
)
437 return (b
->enable_state
== bp_enabled
);
440 /* Set breakpoint count to NUM. */
443 set_breakpoint_count (int num
)
445 prev_breakpoint_count
= breakpoint_count
;
446 breakpoint_count
= num
;
447 set_internalvar_integer (lookup_internalvar ("bpnum"), num
);
450 /* Used by `start_rbreak_breakpoints' below, to record the current
451 breakpoint count before "rbreak" creates any breakpoint. */
452 static int rbreak_start_breakpoint_count
;
454 /* Called at the start an "rbreak" command to record the first
458 start_rbreak_breakpoints (void)
460 rbreak_start_breakpoint_count
= breakpoint_count
;
463 /* Called at the end of an "rbreak" command to record the last
467 end_rbreak_breakpoints (void)
469 prev_breakpoint_count
= rbreak_start_breakpoint_count
;
472 /* Used in run_command to zero the hit count when a new run starts. */
475 clear_breakpoint_hit_counts (void)
477 struct breakpoint
*b
;
483 /* Allocate a new counted_command_line with reference count of 1.
484 The new structure owns COMMANDS. */
486 static struct counted_command_line
*
487 alloc_counted_command_line (struct command_line
*commands
)
489 struct counted_command_line
*result
490 = xmalloc (sizeof (struct counted_command_line
));
493 result
->commands
= commands
;
497 /* Increment reference count. This does nothing if CMD is NULL. */
500 incref_counted_command_line (struct counted_command_line
*cmd
)
506 /* Decrement reference count. If the reference count reaches 0,
507 destroy the counted_command_line. Sets *CMDP to NULL. This does
508 nothing if *CMDP is NULL. */
511 decref_counted_command_line (struct counted_command_line
**cmdp
)
515 if (--(*cmdp
)->refc
== 0)
517 free_command_lines (&(*cmdp
)->commands
);
524 /* A cleanup function that calls decref_counted_command_line. */
527 do_cleanup_counted_command_line (void *arg
)
529 decref_counted_command_line (arg
);
532 /* Create a cleanup that calls decref_counted_command_line on the
535 static struct cleanup
*
536 make_cleanup_decref_counted_command_line (struct counted_command_line
**cmdp
)
538 return make_cleanup (do_cleanup_counted_command_line
, cmdp
);
541 /* Default address, symtab and line to put a breakpoint at
542 for "break" command with no arg.
543 If default_breakpoint_valid is zero, the other three are
544 not valid, and "break" with no arg is an error.
546 This set by print_stack_frame, which calls set_default_breakpoint. */
548 int default_breakpoint_valid
;
549 CORE_ADDR default_breakpoint_address
;
550 struct symtab
*default_breakpoint_symtab
;
551 int default_breakpoint_line
;
552 struct program_space
*default_breakpoint_pspace
;
555 /* Return the breakpoint with the specified number, or NULL
556 if the number does not refer to an existing breakpoint. */
559 get_breakpoint (int num
)
561 struct breakpoint
*b
;
564 if (b
->number
== num
)
573 set_breakpoint_condition (struct breakpoint
*b
, char *exp
,
576 struct bp_location
*loc
= b
->loc
;
578 for (; loc
; loc
= loc
->next
)
583 xfree (b
->cond_string
);
584 b
->cond_string
= NULL
;
591 printf_filtered (_("Breakpoint %d now unconditional.\n"), b
->number
);
597 /* I don't know if it matters whether this is the string the user
598 typed in or the decompiled expression. */
599 b
->cond_string
= xstrdup (arg
);
600 b
->condition_not_parsed
= 0;
602 if (is_watchpoint (b
))
604 innermost_block
= NULL
;
606 b
->cond_exp
= parse_exp_1 (&arg
, 0, 0);
608 error (_("Junk at end of expression"));
609 b
->cond_exp_valid_block
= innermost_block
;
613 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
617 parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
619 error (_("Junk at end of expression"));
623 breakpoints_changed ();
624 observer_notify_breakpoint_modified (b
->number
);
627 /* condition N EXP -- set break condition of breakpoint N to EXP. */
630 condition_command (char *arg
, int from_tty
)
632 struct breakpoint
*b
;
637 error_no_arg (_("breakpoint number"));
640 bnum
= get_number (&p
);
642 error (_("Bad breakpoint argument: '%s'"), arg
);
645 if (b
->number
== bnum
)
647 /* Check if this breakpoint has a Python object assigned to
648 it, and if it has a definition of the "stop"
649 method. This method and conditions entered into GDB from
650 the CLI are mutually exclusive. */
652 && gdbpy_breakpoint_has_py_cond (b
->py_bp_object
))
653 error (_("Cannot set a condition where a Python 'stop' "
654 "method has been defined in the breakpoint."));
655 set_breakpoint_condition (b
, p
, from_tty
);
659 error (_("No breakpoint number %d."), bnum
);
662 /* Check that COMMAND do not contain commands that are suitable
663 only for tracepoints and not suitable for ordinary breakpoints.
664 Throw if any such commands is found. */
667 check_no_tracepoint_commands (struct command_line
*commands
)
669 struct command_line
*c
;
671 for (c
= commands
; c
; c
= c
->next
)
675 if (c
->control_type
== while_stepping_control
)
676 error (_("The 'while-stepping' command can "
677 "only be used for tracepoints"));
679 for (i
= 0; i
< c
->body_count
; ++i
)
680 check_no_tracepoint_commands ((c
->body_list
)[i
]);
682 /* Not that command parsing removes leading whitespace and comment
683 lines and also empty lines. So, we only need to check for
685 if (strstr (c
->line
, "collect ") == c
->line
)
686 error (_("The 'collect' command can only be used for tracepoints"));
688 if (strstr (c
->line
, "teval ") == c
->line
)
689 error (_("The 'teval' command can only be used for tracepoints"));
693 /* Encapsulate tests for different types of tracepoints. */
696 is_tracepoint (const struct breakpoint
*b
)
698 return (b
->type
== bp_tracepoint
699 || b
->type
== bp_fast_tracepoint
700 || b
->type
== bp_static_tracepoint
);
703 /* A helper function that validsates that COMMANDS are valid for a
704 breakpoint. This function will throw an exception if a problem is
708 validate_commands_for_breakpoint (struct breakpoint
*b
,
709 struct command_line
*commands
)
711 if (is_tracepoint (b
))
713 /* We need to verify that each top-level element of commands is
714 valid for tracepoints, that there's at most one
715 while-stepping element, and that while-stepping's body has
716 valid tracing commands excluding nested while-stepping. */
717 struct command_line
*c
;
718 struct command_line
*while_stepping
= 0;
719 for (c
= commands
; c
; c
= c
->next
)
721 if (c
->control_type
== while_stepping_control
)
723 if (b
->type
== bp_fast_tracepoint
)
724 error (_("The 'while-stepping' command "
725 "cannot be used for fast tracepoint"));
726 else if (b
->type
== bp_static_tracepoint
)
727 error (_("The 'while-stepping' command "
728 "cannot be used for static tracepoint"));
731 error (_("The 'while-stepping' command "
732 "can be used only once"));
739 struct command_line
*c2
;
741 gdb_assert (while_stepping
->body_count
== 1);
742 c2
= while_stepping
->body_list
[0];
743 for (; c2
; c2
= c2
->next
)
745 if (c2
->control_type
== while_stepping_control
)
746 error (_("The 'while-stepping' command cannot be nested"));
752 check_no_tracepoint_commands (commands
);
756 /* Return a vector of all the static tracepoints set at ADDR. The
757 caller is responsible for releasing the vector. */
760 static_tracepoints_here (CORE_ADDR addr
)
762 struct breakpoint
*b
;
763 VEC(breakpoint_p
) *found
= 0;
764 struct bp_location
*loc
;
767 if (b
->type
== bp_static_tracepoint
)
769 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
770 if (loc
->address
== addr
)
771 VEC_safe_push(breakpoint_p
, found
, b
);
777 /* Set the command list of B to COMMANDS. If breakpoint is tracepoint,
778 validate that only allowed commands are included. */
781 breakpoint_set_commands (struct breakpoint
*b
,
782 struct command_line
*commands
)
784 validate_commands_for_breakpoint (b
, commands
);
786 decref_counted_command_line (&b
->commands
);
787 b
->commands
= alloc_counted_command_line (commands
);
788 breakpoints_changed ();
789 observer_notify_breakpoint_modified (b
->number
);
792 /* Set the internal `silent' flag on the breakpoint. Note that this
793 is not the same as the "silent" that may appear in the breakpoint's
797 breakpoint_set_silent (struct breakpoint
*b
, int silent
)
799 int old_silent
= b
->silent
;
802 if (old_silent
!= silent
)
803 observer_notify_breakpoint_modified (b
->number
);
806 /* Set the thread for this breakpoint. If THREAD is -1, make the
807 breakpoint work for any thread. */
810 breakpoint_set_thread (struct breakpoint
*b
, int thread
)
812 int old_thread
= b
->thread
;
815 if (old_thread
!= thread
)
816 observer_notify_breakpoint_modified (b
->number
);
819 /* Set the task for this breakpoint. If TASK is 0, make the
820 breakpoint work for any task. */
823 breakpoint_set_task (struct breakpoint
*b
, int task
)
825 int old_task
= b
->task
;
828 if (old_task
!= task
)
829 observer_notify_breakpoint_modified (b
->number
);
833 check_tracepoint_command (char *line
, void *closure
)
835 struct breakpoint
*b
= closure
;
837 validate_actionline (&line
, b
);
840 /* A structure used to pass information through
841 map_breakpoint_numbers. */
845 /* True if the command was typed at a tty. */
848 /* The breakpoint range spec. */
851 /* Non-NULL if the body of the commands are being read from this
852 already-parsed command. */
853 struct command_line
*control
;
855 /* The command lines read from the user, or NULL if they have not
857 struct counted_command_line
*cmd
;
860 /* A callback for map_breakpoint_numbers that sets the commands for
864 do_map_commands_command (struct breakpoint
*b
, void *data
)
866 struct commands_info
*info
= data
;
868 if (info
->cmd
== NULL
)
870 struct command_line
*l
;
872 if (info
->control
!= NULL
)
873 l
= copy_command_lines (info
->control
->body_list
[0]);
876 struct cleanup
*old_chain
;
879 str
= xstrprintf (_("Type commands for breakpoint(s) "
880 "%s, one per line."),
883 old_chain
= make_cleanup (xfree
, str
);
885 l
= read_command_lines (str
,
888 ? check_tracepoint_command
: 0),
891 do_cleanups (old_chain
);
894 info
->cmd
= alloc_counted_command_line (l
);
897 /* If a breakpoint was on the list more than once, we don't need to
899 if (b
->commands
!= info
->cmd
)
901 validate_commands_for_breakpoint (b
, info
->cmd
->commands
);
902 incref_counted_command_line (info
->cmd
);
903 decref_counted_command_line (&b
->commands
);
904 b
->commands
= info
->cmd
;
905 breakpoints_changed ();
906 observer_notify_breakpoint_modified (b
->number
);
911 commands_command_1 (char *arg
, int from_tty
,
912 struct command_line
*control
)
914 struct cleanup
*cleanups
;
915 struct commands_info info
;
917 info
.from_tty
= from_tty
;
918 info
.control
= control
;
920 /* If we read command lines from the user, then `info' will hold an
921 extra reference to the commands that we must clean up. */
922 cleanups
= make_cleanup_decref_counted_command_line (&info
.cmd
);
924 if (arg
== NULL
|| !*arg
)
926 if (breakpoint_count
- prev_breakpoint_count
> 1)
927 arg
= xstrprintf ("%d-%d", prev_breakpoint_count
+ 1,
929 else if (breakpoint_count
> 0)
930 arg
= xstrprintf ("%d", breakpoint_count
);
933 /* So that we don't try to free the incoming non-NULL
934 argument in the cleanup below. Mapping breakpoint
935 numbers will fail in this case. */
940 /* The command loop has some static state, so we need to preserve
945 make_cleanup (xfree
, arg
);
949 map_breakpoint_numbers (arg
, do_map_commands_command
, &info
);
951 if (info
.cmd
== NULL
)
952 error (_("No breakpoints specified."));
954 do_cleanups (cleanups
);
958 commands_command (char *arg
, int from_tty
)
960 commands_command_1 (arg
, from_tty
, NULL
);
963 /* Like commands_command, but instead of reading the commands from
964 input stream, takes them from an already parsed command structure.
966 This is used by cli-script.c to DTRT with breakpoint commands
967 that are part of if and while bodies. */
968 enum command_control_type
969 commands_from_control_command (char *arg
, struct command_line
*cmd
)
971 commands_command_1 (arg
, 0, cmd
);
972 return simple_control
;
975 /* Return non-zero if BL->TARGET_INFO contains valid information. */
978 bp_location_has_shadow (struct bp_location
*bl
)
980 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
984 if (bl
->target_info
.shadow_len
== 0)
985 /* bp isn't valid, or doesn't shadow memory. */
990 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
991 by replacing any memory breakpoints with their shadowed contents.
993 The range of shadowed area by each bp_location is:
994 bl->address - bp_location_placed_address_before_address_max
995 up to bl->address + bp_location_shadow_len_after_address_max
996 The range we were requested to resolve shadows for is:
997 memaddr ... memaddr + len
998 Thus the safe cutoff boundaries for performance optimization are
999 memaddr + len <= (bl->address
1000 - bp_location_placed_address_before_address_max)
1002 bl->address + bp_location_shadow_len_after_address_max <= memaddr */
1005 breakpoint_restore_shadows (gdb_byte
*buf
, ULONGEST memaddr
, LONGEST len
)
1007 /* Left boundary, right boundary and median element of our binary
1009 unsigned bc_l
, bc_r
, bc
;
1011 /* Find BC_L which is a leftmost element which may affect BUF
1012 content. It is safe to report lower value but a failure to
1013 report higher one. */
1016 bc_r
= bp_location_count
;
1017 while (bc_l
+ 1 < bc_r
)
1019 struct bp_location
*bl
;
1021 bc
= (bc_l
+ bc_r
) / 2;
1022 bl
= bp_location
[bc
];
1024 /* Check first BL->ADDRESS will not overflow due to the added
1025 constant. Then advance the left boundary only if we are sure
1026 the BC element can in no way affect the BUF content (MEMADDR
1027 to MEMADDR + LEN range).
1029 Use the BP_LOCATION_SHADOW_LEN_AFTER_ADDRESS_MAX safety
1030 offset so that we cannot miss a breakpoint with its shadow
1031 range tail still reaching MEMADDR. */
1033 if ((bl
->address
+ bp_location_shadow_len_after_address_max
1035 && (bl
->address
+ bp_location_shadow_len_after_address_max
1042 /* Due to the binary search above, we need to make sure we pick the
1043 first location that's at BC_L's address. E.g., if there are
1044 multiple locations at the same address, BC_L may end up pointing
1045 at a duplicate location, and miss the "master"/"inserted"
1046 location. Say, given locations L1, L2 and L3 at addresses A and
1049 L1@A, L2@A, L3@B, ...
1051 BC_L could end up pointing at location L2, while the "master"
1052 location could be L1. Since the `loc->inserted' flag is only set
1053 on "master" locations, we'd forget to restore the shadow of L1
1056 && bp_location
[bc_l
]->address
== bp_location
[bc_l
- 1]->address
)
1059 /* Now do full processing of the found relevant range of elements. */
1061 for (bc
= bc_l
; bc
< bp_location_count
; bc
++)
1063 struct bp_location
*bl
= bp_location
[bc
];
1064 CORE_ADDR bp_addr
= 0;
1068 /* bp_location array has BL->OWNER always non-NULL. */
1069 if (bl
->owner
->type
== bp_none
)
1070 warning (_("reading through apparently deleted breakpoint #%d?"),
1073 /* Performance optimization: any futher element can no longer affect BUF
1076 if (bl
->address
>= bp_location_placed_address_before_address_max
1077 && memaddr
+ len
<= (bl
->address
1078 - bp_location_placed_address_before_address_max
))
1081 if (!bp_location_has_shadow (bl
))
1083 if (!breakpoint_address_match (bl
->target_info
.placed_address_space
, 0,
1084 current_program_space
->aspace
, 0))
1087 /* Addresses and length of the part of the breakpoint that
1089 bp_addr
= bl
->target_info
.placed_address
;
1090 bp_size
= bl
->target_info
.shadow_len
;
1092 if (bp_addr
+ bp_size
<= memaddr
)
1093 /* The breakpoint is entirely before the chunk of memory we
1097 if (bp_addr
>= memaddr
+ len
)
1098 /* The breakpoint is entirely after the chunk of memory we are
1102 /* Offset within shadow_contents. */
1103 if (bp_addr
< memaddr
)
1105 /* Only copy the second part of the breakpoint. */
1106 bp_size
-= memaddr
- bp_addr
;
1107 bptoffset
= memaddr
- bp_addr
;
1111 if (bp_addr
+ bp_size
> memaddr
+ len
)
1113 /* Only copy the first part of the breakpoint. */
1114 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
1117 memcpy (buf
+ bp_addr
- memaddr
,
1118 bl
->target_info
.shadow_contents
+ bptoffset
, bp_size
);
1123 /* Return true if BPT is of any hardware watchpoint kind. */
1126 is_hardware_watchpoint (const struct breakpoint
*bpt
)
1128 return (bpt
->type
== bp_hardware_watchpoint
1129 || bpt
->type
== bp_read_watchpoint
1130 || bpt
->type
== bp_access_watchpoint
);
1133 /* Return true if BPT is of any watchpoint kind, hardware or
1137 is_watchpoint (const struct breakpoint
*bpt
)
1139 return (is_hardware_watchpoint (bpt
)
1140 || bpt
->type
== bp_watchpoint
);
1143 /* Assuming that B is a watchpoint: returns true if the current thread
1144 and its running state are safe to evaluate or update watchpoint B.
1145 Watchpoints on local expressions need to be evaluated in the
1146 context of the thread that was current when the watchpoint was
1147 created, and, that thread needs to be stopped to be able to select
1148 the correct frame context. Watchpoints on global expressions can
1149 be evaluated on any thread, and in any state. It is presently left
1150 to the target allowing memory accesses when threads are
1154 watchpoint_in_thread_scope (struct breakpoint
*b
)
1156 return (ptid_equal (b
->watchpoint_thread
, null_ptid
)
1157 || (ptid_equal (inferior_ptid
, b
->watchpoint_thread
)
1158 && !is_executing (inferior_ptid
)));
1161 /* Assuming that B is a watchpoint:
1162 - Reparse watchpoint expression, if REPARSE is non-zero
1163 - Evaluate expression and store the result in B->val
1164 - Evaluate the condition if there is one, and store the result
1166 - Update the list of values that must be watched in B->loc.
1168 If the watchpoint disposition is disp_del_at_next_stop, then do
1169 nothing. If this is local watchpoint that is out of scope, delete
1172 Even with `set breakpoint always-inserted on' the watchpoints are
1173 removed + inserted on each stop here. Normal breakpoints must
1174 never be removed because they might be missed by a running thread
1175 when debugging in non-stop mode. On the other hand, hardware
1176 watchpoints (is_hardware_watchpoint; processed here) are specific
1177 to each LWP since they are stored in each LWP's hardware debug
1178 registers. Therefore, such LWP must be stopped first in order to
1179 be able to modify its hardware watchpoints.
1181 Hardware watchpoints must be reset exactly once after being
1182 presented to the user. It cannot be done sooner, because it would
1183 reset the data used to present the watchpoint hit to the user. And
1184 it must not be done later because it could display the same single
1185 watchpoint hit during multiple GDB stops. Note that the latter is
1186 relevant only to the hardware watchpoint types bp_read_watchpoint
1187 and bp_access_watchpoint. False hit by bp_hardware_watchpoint is
1188 not user-visible - its hit is suppressed if the memory content has
1191 The following constraints influence the location where we can reset
1192 hardware watchpoints:
1194 * target_stopped_by_watchpoint and target_stopped_data_address are
1195 called several times when GDB stops.
1198 * Multiple hardware watchpoints can be hit at the same time,
1199 causing GDB to stop. GDB only presents one hardware watchpoint
1200 hit at a time as the reason for stopping, and all the other hits
1201 are presented later, one after the other, each time the user
1202 requests the execution to be resumed. Execution is not resumed
1203 for the threads still having pending hit event stored in
1204 LWP_INFO->STATUS. While the watchpoint is already removed from
1205 the inferior on the first stop the thread hit event is kept being
1206 reported from its cached value by linux_nat_stopped_data_address
1207 until the real thread resume happens after the watchpoint gets
1208 presented and thus its LWP_INFO->STATUS gets reset.
1210 Therefore the hardware watchpoint hit can get safely reset on the
1211 watchpoint removal from inferior. */
1214 update_watchpoint (struct breakpoint
*b
, int reparse
)
1216 int within_current_scope
;
1217 struct frame_id saved_frame_id
;
1220 /* If this is a local watchpoint, we only want to check if the
1221 watchpoint frame is in scope if the current thread is the thread
1222 that was used to create the watchpoint. */
1223 if (!watchpoint_in_thread_scope (b
))
1226 if (b
->disposition
== disp_del_at_next_stop
)
1231 /* Determine if the watchpoint is within scope. */
1232 if (b
->exp_valid_block
== NULL
)
1233 within_current_scope
= 1;
1236 struct frame_info
*fi
= get_current_frame ();
1237 struct gdbarch
*frame_arch
= get_frame_arch (fi
);
1238 CORE_ADDR frame_pc
= get_frame_pc (fi
);
1240 /* If we're in a function epilogue, unwinding may not work
1241 properly, so do not attempt to recreate locations at this
1242 point. See similar comments in watchpoint_check. */
1243 if (gdbarch_in_function_epilogue_p (frame_arch
, frame_pc
))
1246 /* Save the current frame's ID so we can restore it after
1247 evaluating the watchpoint expression on its own frame. */
1248 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
1249 took a frame parameter, so that we didn't have to change the
1252 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
1254 fi
= frame_find_by_id (b
->watchpoint_frame
);
1255 within_current_scope
= (fi
!= NULL
);
1256 if (within_current_scope
)
1260 /* We don't free locations. They are stored in the bp_location array
1261 and update_global_location_list will eventually delete them and
1262 remove breakpoints if needed. */
1265 if (within_current_scope
&& reparse
)
1274 s
= b
->exp_string_reparse
? b
->exp_string_reparse
: b
->exp_string
;
1275 b
->exp
= parse_exp_1 (&s
, b
->exp_valid_block
, 0);
1276 /* If the meaning of expression itself changed, the old value is
1277 no longer relevant. We don't want to report a watchpoint hit
1278 to the user when the old value and the new value may actually
1279 be completely different objects. */
1280 value_free (b
->val
);
1284 /* Note that unlike with breakpoints, the watchpoint's condition
1285 expression is stored in the breakpoint object, not in the
1286 locations (re)created below. */
1287 if (b
->cond_string
!= NULL
)
1289 if (b
->cond_exp
!= NULL
)
1291 xfree (b
->cond_exp
);
1296 b
->cond_exp
= parse_exp_1 (&s
, b
->cond_exp_valid_block
, 0);
1300 /* If we failed to parse the expression, for example because
1301 it refers to a global variable in a not-yet-loaded shared library,
1302 don't try to insert watchpoint. We don't automatically delete
1303 such watchpoint, though, since failure to parse expression
1304 is different from out-of-scope watchpoint. */
1305 if ( !target_has_execution
)
1307 /* Without execution, memory can't change. No use to try and
1308 set watchpoint locations. The watchpoint will be reset when
1309 the target gains execution, through breakpoint_re_set. */
1311 else if (within_current_scope
&& b
->exp
)
1314 struct value
*val_chain
, *v
, *result
, *next
;
1315 struct program_space
*frame_pspace
;
1317 fetch_subexp_value (b
->exp
, &pc
, &v
, &result
, &val_chain
);
1319 /* Avoid setting b->val if it's already set. The meaning of
1320 b->val is 'the last value' user saw, and we should update
1321 it only if we reported that last value to user. As it
1322 happens, the code that reports it updates b->val directly. */
1329 frame_pspace
= get_frame_program_space (get_selected_frame (NULL
));
1331 /* Look at each value on the value chain. */
1332 for (v
= val_chain
; v
; v
= value_next (v
))
1334 /* If it's a memory location, and GDB actually needed
1335 its contents to evaluate the expression, then we
1336 must watch it. If the first value returned is
1337 still lazy, that means an error occurred reading it;
1338 watch it anyway in case it becomes readable. */
1339 if (VALUE_LVAL (v
) == lval_memory
1340 && (v
== val_chain
|| ! value_lazy (v
)))
1342 struct type
*vtype
= check_typedef (value_type (v
));
1344 /* We only watch structs and arrays if user asked
1345 for it explicitly, never if they just happen to
1346 appear in the middle of some value chain. */
1348 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
1349 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
1353 struct bp_location
*loc
, **tmp
;
1355 addr
= value_address (v
);
1356 len
= TYPE_LENGTH (value_type (v
));
1358 if (b
->type
== bp_read_watchpoint
)
1360 else if (b
->type
== bp_access_watchpoint
)
1363 loc
= allocate_bp_location (b
);
1364 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
1367 loc
->gdbarch
= get_type_arch (value_type (v
));
1369 loc
->pspace
= frame_pspace
;
1370 loc
->address
= addr
;
1372 loc
->watchpoint_type
= type
;
1377 /* Change the type of breakpoint between hardware assisted or
1378 an ordinary watchpoint depending on the hardware support
1379 and free hardware slots. REPARSE is set when the inferior
1381 if ((b
->type
== bp_watchpoint
|| b
->type
== bp_hardware_watchpoint
)
1385 enum bp_loc_type loc_type
;
1386 struct bp_location
*bl
;
1388 reg_cnt
= can_use_hardware_watchpoint (val_chain
, b
->exact
);
1392 int i
, target_resources_ok
, other_type_used
;
1393 enum enable_state orig_enable_state
;
1395 /* We need to determine how many resources are already
1396 used for all other hardware watchpoints plus this one
1397 to see if we still have enough resources to also fit
1398 this watchpoint in as well. To guarantee the
1399 hw_watchpoint_used_count call below counts this
1400 watchpoint, make sure that it is marked as a hardware
1402 b
->type
= bp_hardware_watchpoint
;
1404 /* hw_watchpoint_used_count ignores disabled watchpoints,
1405 and b might be disabled if we're being called from
1406 do_enable_breakpoint. */
1407 orig_enable_state
= b
->enable_state
;
1408 b
->enable_state
= bp_enabled
;
1410 i
= hw_watchpoint_used_count (bp_hardware_watchpoint
,
1413 b
->enable_state
= orig_enable_state
;
1415 target_resources_ok
= target_can_use_hardware_watchpoint
1416 (bp_hardware_watchpoint
, i
, other_type_used
);
1417 if (target_resources_ok
<= 0)
1418 b
->type
= bp_watchpoint
;
1421 b
->type
= bp_watchpoint
;
1423 loc_type
= (b
->type
== bp_watchpoint
? bp_loc_other
1424 : bp_loc_hardware_watchpoint
);
1425 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
1426 bl
->loc_type
= loc_type
;
1429 for (v
= val_chain
; v
; v
= next
)
1431 next
= value_next (v
);
1436 /* If a software watchpoint is not watching any memory, then the
1437 above left it without any location set up. But,
1438 bpstat_stop_status requires a location to be able to report
1439 stops, so make sure there's at least a dummy one. */
1440 if (b
->type
== bp_watchpoint
&& b
->loc
== NULL
)
1442 b
->loc
= allocate_bp_location (b
);
1443 b
->loc
->pspace
= frame_pspace
;
1444 b
->loc
->address
= -1;
1445 b
->loc
->length
= -1;
1446 b
->loc
->watchpoint_type
= -1;
1449 else if (!within_current_scope
)
1451 printf_filtered (_("\
1452 Watchpoint %d deleted because the program has left the block\n\
1453 in which its expression is valid.\n"),
1455 if (b
->related_breakpoint
)
1457 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
1458 b
->related_breakpoint
->related_breakpoint
= NULL
;
1459 b
->related_breakpoint
= NULL
;
1461 b
->disposition
= disp_del_at_next_stop
;
1464 /* Restore the selected frame. */
1466 select_frame (frame_find_by_id (saved_frame_id
));
1470 /* Returns 1 iff breakpoint location should be
1471 inserted in the inferior. */
1473 should_be_inserted (struct bp_location
*bl
)
1475 if (bl
->owner
== NULL
|| !breakpoint_enabled (bl
->owner
))
1478 if (bl
->owner
->disposition
== disp_del_at_next_stop
)
1481 if (!bl
->enabled
|| bl
->shlib_disabled
|| bl
->duplicate
)
1484 /* This is set for example, when we're attached to the parent of a
1485 vfork, and have detached from the child. The child is running
1486 free, and we expect it to do an exec or exit, at which point the
1487 OS makes the parent schedulable again (and the target reports
1488 that the vfork is done). Until the child is done with the shared
1489 memory region, do not insert breakpoints in the parent, otherwise
1490 the child could still trip on the parent's breakpoints. Since
1491 the parent is blocked anyway, it won't miss any breakpoint. */
1492 if (bl
->pspace
->breakpoints_not_allowed
)
1495 /* Tracepoints are inserted by the target at a time of its choosing,
1497 if (is_tracepoint (bl
->owner
))
1503 /* Insert a low-level "breakpoint" of some type. BL is the breakpoint
1504 location. Any error messages are printed to TMP_ERROR_STREAM; and
1505 DISABLED_BREAKS, and HW_BREAKPOINT_ERROR are used to report problems.
1507 NOTE drow/2003-09-09: This routine could be broken down to an
1508 object-style method for each breakpoint or catchpoint type. */
1510 insert_bp_location (struct bp_location
*bl
,
1511 struct ui_file
*tmp_error_stream
,
1512 int *disabled_breaks
,
1513 int *hw_breakpoint_error
)
1517 if (!should_be_inserted (bl
) || bl
->inserted
)
1520 /* Initialize the target-specific information. */
1521 memset (&bl
->target_info
, 0, sizeof (bl
->target_info
));
1522 bl
->target_info
.placed_address
= bl
->address
;
1523 bl
->target_info
.placed_address_space
= bl
->pspace
->aspace
;
1525 if (bl
->loc_type
== bp_loc_software_breakpoint
1526 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
1528 if (bl
->owner
->type
!= bp_hardware_breakpoint
)
1530 /* If the explicitly specified breakpoint type
1531 is not hardware breakpoint, check the memory map to see
1532 if the breakpoint address is in read only memory or not.
1534 Two important cases are:
1535 - location type is not hardware breakpoint, memory
1536 is readonly. We change the type of the location to
1537 hardware breakpoint.
1538 - location type is hardware breakpoint, memory is
1539 read-write. This means we've previously made the
1540 location hardware one, but then the memory map changed,
1543 When breakpoints are removed, remove_breakpoints will use
1544 location types we've just set here, the only possible
1545 problem is that memory map has changed during running
1546 program, but it's not going to work anyway with current
1548 struct mem_region
*mr
1549 = lookup_mem_region (bl
->target_info
.placed_address
);
1553 if (automatic_hardware_breakpoints
)
1555 enum bp_loc_type new_type
;
1557 if (mr
->attrib
.mode
!= MEM_RW
)
1558 new_type
= bp_loc_hardware_breakpoint
;
1560 new_type
= bp_loc_software_breakpoint
;
1562 if (new_type
!= bl
->loc_type
)
1564 static int said
= 0;
1566 bl
->loc_type
= new_type
;
1569 fprintf_filtered (gdb_stdout
,
1570 _("Note: automatically using "
1571 "hardware breakpoints for "
1572 "read-only addresses.\n"));
1577 else if (bl
->loc_type
== bp_loc_software_breakpoint
1578 && mr
->attrib
.mode
!= MEM_RW
)
1579 warning (_("cannot set software breakpoint "
1580 "at readonly address %s"),
1581 paddress (bl
->gdbarch
, bl
->address
));
1585 /* First check to see if we have to handle an overlay. */
1586 if (overlay_debugging
== ovly_off
1587 || bl
->section
== NULL
1588 || !(section_is_overlay (bl
->section
)))
1590 /* No overlay handling: just set the breakpoint. */
1592 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
1593 val
= target_insert_hw_breakpoint (bl
->gdbarch
,
1596 val
= target_insert_breakpoint (bl
->gdbarch
,
1601 /* This breakpoint is in an overlay section.
1602 Shall we set a breakpoint at the LMA? */
1603 if (!overlay_events_enabled
)
1605 /* Yes -- overlay event support is not active,
1606 so we must try to set a breakpoint at the LMA.
1607 This will not work for a hardware breakpoint. */
1608 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
1609 warning (_("hardware breakpoint %d not supported in overlay!"),
1613 CORE_ADDR addr
= overlay_unmapped_address (bl
->address
,
1615 /* Set a software (trap) breakpoint at the LMA. */
1616 bl
->overlay_target_info
= bl
->target_info
;
1617 bl
->overlay_target_info
.placed_address
= addr
;
1618 val
= target_insert_breakpoint (bl
->gdbarch
,
1619 &bl
->overlay_target_info
);
1621 fprintf_unfiltered (tmp_error_stream
,
1622 "Overlay breakpoint %d "
1623 "failed: in ROM?\n",
1627 /* Shall we set a breakpoint at the VMA? */
1628 if (section_is_mapped (bl
->section
))
1630 /* Yes. This overlay section is mapped into memory. */
1631 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
1632 val
= target_insert_hw_breakpoint (bl
->gdbarch
,
1635 val
= target_insert_breakpoint (bl
->gdbarch
,
1640 /* No. This breakpoint will not be inserted.
1641 No error, but do not mark the bp as 'inserted'. */
1648 /* Can't set the breakpoint. */
1649 if (solib_name_from_address (bl
->pspace
, bl
->address
))
1651 /* See also: disable_breakpoints_in_shlibs. */
1653 bl
->shlib_disabled
= 1;
1654 if (!*disabled_breaks
)
1656 fprintf_unfiltered (tmp_error_stream
,
1657 "Cannot insert breakpoint %d.\n",
1659 fprintf_unfiltered (tmp_error_stream
,
1660 "Temporarily disabling shared "
1661 "library breakpoints:\n");
1663 *disabled_breaks
= 1;
1664 fprintf_unfiltered (tmp_error_stream
,
1665 "breakpoint #%d\n", bl
->owner
->number
);
1669 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
1671 *hw_breakpoint_error
= 1;
1672 fprintf_unfiltered (tmp_error_stream
,
1673 "Cannot insert hardware "
1679 fprintf_unfiltered (tmp_error_stream
,
1680 "Cannot insert breakpoint %d.\n",
1682 fprintf_filtered (tmp_error_stream
,
1683 "Error accessing memory address ");
1684 fputs_filtered (paddress (bl
->gdbarch
, bl
->address
),
1686 fprintf_filtered (tmp_error_stream
, ": %s.\n",
1687 safe_strerror (val
));
1698 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
1699 /* NOTE drow/2003-09-08: This state only exists for removing
1700 watchpoints. It's not clear that it's necessary... */
1701 && bl
->owner
->disposition
!= disp_del_at_next_stop
)
1703 gdb_assert (bl
->owner
->ops
!= NULL
1704 && bl
->owner
->ops
->insert_location
!= NULL
);
1706 val
= bl
->owner
->ops
->insert_location (bl
);
1708 /* If trying to set a read-watchpoint, and it turns out it's not
1709 supported, try emulating one with an access watchpoint. */
1710 if (val
== 1 && bl
->watchpoint_type
== hw_read
)
1712 struct bp_location
*loc
, **loc_temp
;
1714 /* But don't try to insert it, if there's already another
1715 hw_access location that would be considered a duplicate
1717 ALL_BP_LOCATIONS (loc
, loc_temp
)
1719 && loc
->watchpoint_type
== hw_access
1720 && watchpoint_locations_match (bl
, loc
))
1724 bl
->target_info
= loc
->target_info
;
1725 bl
->watchpoint_type
= hw_access
;
1732 bl
->watchpoint_type
= hw_access
;
1733 val
= bl
->owner
->ops
->insert_location (bl
);
1736 /* Back to the original value. */
1737 bl
->watchpoint_type
= hw_read
;
1741 bl
->inserted
= (val
== 0);
1744 else if (bl
->owner
->type
== bp_catchpoint
)
1746 gdb_assert (bl
->owner
->ops
!= NULL
1747 && bl
->owner
->ops
->insert_location
!= NULL
);
1749 val
= bl
->owner
->ops
->insert_location (bl
);
1752 bl
->owner
->enable_state
= bp_disabled
;
1756 Error inserting catchpoint %d: Your system does not support this type\n\
1757 of catchpoint."), bl
->owner
->number
);
1759 warning (_("Error inserting catchpoint %d."), bl
->owner
->number
);
1762 bl
->inserted
= (val
== 0);
1764 /* We've already printed an error message if there was a problem
1765 inserting this catchpoint, and we've disabled the catchpoint,
1766 so just return success. */
1773 /* This function is called when program space PSPACE is about to be
1774 deleted. It takes care of updating breakpoints to not reference
1778 breakpoint_program_space_exit (struct program_space
*pspace
)
1780 struct breakpoint
*b
, *b_temp
;
1781 struct bp_location
*loc
, **loc_temp
;
1783 /* Remove any breakpoint that was set through this program space. */
1784 ALL_BREAKPOINTS_SAFE (b
, b_temp
)
1786 if (b
->pspace
== pspace
)
1787 delete_breakpoint (b
);
1790 /* Breakpoints set through other program spaces could have locations
1791 bound to PSPACE as well. Remove those. */
1792 ALL_BP_LOCATIONS (loc
, loc_temp
)
1794 struct bp_location
*tmp
;
1796 if (loc
->pspace
== pspace
)
1798 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
1799 if (loc
->owner
->loc
== loc
)
1800 loc
->owner
->loc
= loc
->next
;
1802 for (tmp
= loc
->owner
->loc
; tmp
->next
!= NULL
; tmp
= tmp
->next
)
1803 if (tmp
->next
== loc
)
1805 tmp
->next
= loc
->next
;
1811 /* Now update the global location list to permanently delete the
1812 removed locations above. */
1813 update_global_location_list (0);
1816 /* Make sure all breakpoints are inserted in inferior.
1817 Throws exception on any error.
1818 A breakpoint that is already inserted won't be inserted
1819 again, so calling this function twice is safe. */
1821 insert_breakpoints (void)
1823 struct breakpoint
*bpt
;
1825 ALL_BREAKPOINTS (bpt
)
1826 if (is_hardware_watchpoint (bpt
))
1827 update_watchpoint (bpt
, 0 /* don't reparse. */);
1829 update_global_location_list (1);
1831 /* update_global_location_list does not insert breakpoints when
1832 always_inserted_mode is not enabled. Explicitly insert them
1834 if (!breakpoints_always_inserted_mode ())
1835 insert_breakpoint_locations ();
1838 /* insert_breakpoints is used when starting or continuing the program.
1839 remove_breakpoints is used when the program stops.
1840 Both return zero if successful,
1841 or an `errno' value if could not write the inferior. */
1844 insert_breakpoint_locations (void)
1846 struct breakpoint
*bpt
;
1847 struct bp_location
*bl
, **blp_tmp
;
1850 int disabled_breaks
= 0;
1851 int hw_breakpoint_error
= 0;
1853 struct ui_file
*tmp_error_stream
= mem_fileopen ();
1854 struct cleanup
*cleanups
= make_cleanup_ui_file_delete (tmp_error_stream
);
1856 /* Explicitly mark the warning -- this will only be printed if
1857 there was an error. */
1858 fprintf_unfiltered (tmp_error_stream
, "Warning:\n");
1860 save_current_space_and_thread ();
1862 ALL_BP_LOCATIONS (bl
, blp_tmp
)
1864 if (!should_be_inserted (bl
) || bl
->inserted
)
1867 /* There is no point inserting thread-specific breakpoints if
1868 the thread no longer exists. ALL_BP_LOCATIONS bp_location
1869 has BL->OWNER always non-NULL. */
1870 if (bl
->owner
->thread
!= -1
1871 && !valid_thread_id (bl
->owner
->thread
))
1874 switch_to_program_space_and_thread (bl
->pspace
);
1876 /* For targets that support global breakpoints, there's no need
1877 to select an inferior to insert breakpoint to. In fact, even
1878 if we aren't attached to any process yet, we should still
1879 insert breakpoints. */
1880 if (!gdbarch_has_global_breakpoints (target_gdbarch
)
1881 && ptid_equal (inferior_ptid
, null_ptid
))
1884 val
= insert_bp_location (bl
, tmp_error_stream
, &disabled_breaks
,
1885 &hw_breakpoint_error
);
1890 /* If we failed to insert all locations of a watchpoint, remove
1891 them, as half-inserted watchpoint is of limited use. */
1892 ALL_BREAKPOINTS (bpt
)
1894 int some_failed
= 0;
1895 struct bp_location
*loc
;
1897 if (!is_hardware_watchpoint (bpt
))
1900 if (!breakpoint_enabled (bpt
))
1903 if (bpt
->disposition
== disp_del_at_next_stop
)
1906 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
1907 if (!loc
->inserted
&& should_be_inserted (loc
))
1914 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
1916 remove_breakpoint (loc
, mark_uninserted
);
1918 hw_breakpoint_error
= 1;
1919 fprintf_unfiltered (tmp_error_stream
,
1920 "Could not insert hardware watchpoint %d.\n",
1928 /* If a hardware breakpoint or watchpoint was inserted, add a
1929 message about possibly exhausted resources. */
1930 if (hw_breakpoint_error
)
1932 fprintf_unfiltered (tmp_error_stream
,
1933 "Could not insert hardware breakpoints:\n\
1934 You may have requested too many hardware breakpoints/watchpoints.\n");
1936 target_terminal_ours_for_output ();
1937 error_stream (tmp_error_stream
);
1940 do_cleanups (cleanups
);
1944 remove_breakpoints (void)
1946 struct bp_location
*bl
, **blp_tmp
;
1949 ALL_BP_LOCATIONS (bl
, blp_tmp
)
1952 val
|= remove_breakpoint (bl
, mark_uninserted
);
1957 /* Remove breakpoints of process PID. */
1960 remove_breakpoints_pid (int pid
)
1962 struct bp_location
*bl
, **blp_tmp
;
1964 struct inferior
*inf
= find_inferior_pid (pid
);
1966 ALL_BP_LOCATIONS (bl
, blp_tmp
)
1968 if (bl
->pspace
!= inf
->pspace
)
1973 val
= remove_breakpoint (bl
, mark_uninserted
);
1982 remove_hw_watchpoints (void)
1984 struct bp_location
*bl
, **blp_tmp
;
1987 ALL_BP_LOCATIONS (bl
, blp_tmp
)
1989 if (bl
->inserted
&& bl
->loc_type
== bp_loc_hardware_watchpoint
)
1990 val
|= remove_breakpoint (bl
, mark_uninserted
);
1996 reattach_breakpoints (int pid
)
1998 struct cleanup
*old_chain
;
1999 struct bp_location
*bl
, **blp_tmp
;
2001 struct ui_file
*tmp_error_stream
;
2002 int dummy1
= 0, dummy2
= 0;
2003 struct inferior
*inf
;
2004 struct thread_info
*tp
;
2006 tp
= any_live_thread_of_process (pid
);
2010 inf
= find_inferior_pid (pid
);
2011 old_chain
= save_inferior_ptid ();
2013 inferior_ptid
= tp
->ptid
;
2015 tmp_error_stream
= mem_fileopen ();
2016 make_cleanup_ui_file_delete (tmp_error_stream
);
2018 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2020 if (bl
->pspace
!= inf
->pspace
)
2026 val
= insert_bp_location (bl
, tmp_error_stream
, &dummy1
, &dummy2
);
2029 do_cleanups (old_chain
);
2034 do_cleanups (old_chain
);
2038 static int internal_breakpoint_number
= -1;
2040 /* Set the breakpoint number of B, depending on the value of INTERNAL.
2041 If INTERNAL is non-zero, the breakpoint number will be populated
2042 from internal_breakpoint_number and that variable decremented.
2043 Otherwis the breakpoint number will be populated from
2044 breakpoint_count and that value incremented. Internal breakpoints
2045 do not set the internal var bpnum. */
2047 set_breakpoint_number (int internal
, struct breakpoint
*b
)
2050 b
->number
= internal_breakpoint_number
--;
2053 set_breakpoint_count (breakpoint_count
+ 1);
2054 b
->number
= breakpoint_count
;
2058 static struct breakpoint
*
2059 create_internal_breakpoint (struct gdbarch
*gdbarch
,
2060 CORE_ADDR address
, enum bptype type
)
2062 struct symtab_and_line sal
;
2063 struct breakpoint
*b
;
2065 init_sal (&sal
); /* Initialize to zeroes. */
2068 sal
.section
= find_pc_overlay (sal
.pc
);
2069 sal
.pspace
= current_program_space
;
2071 b
= set_raw_breakpoint (gdbarch
, sal
, type
);
2072 b
->number
= internal_breakpoint_number
--;
2073 b
->disposition
= disp_donttouch
;
2078 static const char *const longjmp_names
[] =
2080 "longjmp", "_longjmp", "siglongjmp", "_siglongjmp"
2082 #define NUM_LONGJMP_NAMES ARRAY_SIZE(longjmp_names)
2084 /* Per-objfile data private to breakpoint.c. */
2085 struct breakpoint_objfile_data
2087 /* Minimal symbol for "_ovly_debug_event" (if any). */
2088 struct minimal_symbol
*overlay_msym
;
2090 /* Minimal symbol(s) for "longjmp", "siglongjmp", etc. (if any). */
2091 struct minimal_symbol
*longjmp_msym
[NUM_LONGJMP_NAMES
];
2093 /* Minimal symbol for "std::terminate()" (if any). */
2094 struct minimal_symbol
*terminate_msym
;
2096 /* Minimal symbol for "_Unwind_DebugHook" (if any). */
2097 struct minimal_symbol
*exception_msym
;
2100 static const struct objfile_data
*breakpoint_objfile_key
;
2102 /* Minimal symbol not found sentinel. */
2103 static struct minimal_symbol msym_not_found
;
2105 /* Returns TRUE if MSYM point to the "not found" sentinel. */
2108 msym_not_found_p (const struct minimal_symbol
*msym
)
2110 return msym
== &msym_not_found
;
2113 /* Return per-objfile data needed by breakpoint.c.
2114 Allocate the data if necessary. */
2116 static struct breakpoint_objfile_data
*
2117 get_breakpoint_objfile_data (struct objfile
*objfile
)
2119 struct breakpoint_objfile_data
*bp_objfile_data
;
2121 bp_objfile_data
= objfile_data (objfile
, breakpoint_objfile_key
);
2122 if (bp_objfile_data
== NULL
)
2124 bp_objfile_data
= obstack_alloc (&objfile
->objfile_obstack
,
2125 sizeof (*bp_objfile_data
));
2127 memset (bp_objfile_data
, 0, sizeof (*bp_objfile_data
));
2128 set_objfile_data (objfile
, breakpoint_objfile_key
, bp_objfile_data
);
2130 return bp_objfile_data
;
2134 create_overlay_event_breakpoint (void)
2136 struct objfile
*objfile
;
2137 const char *const func_name
= "_ovly_debug_event";
2139 ALL_OBJFILES (objfile
)
2141 struct breakpoint
*b
;
2142 struct breakpoint_objfile_data
*bp_objfile_data
;
2145 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
2147 if (msym_not_found_p (bp_objfile_data
->overlay_msym
))
2150 if (bp_objfile_data
->overlay_msym
== NULL
)
2152 struct minimal_symbol
*m
;
2154 m
= lookup_minimal_symbol_text (func_name
, objfile
);
2157 /* Avoid future lookups in this objfile. */
2158 bp_objfile_data
->overlay_msym
= &msym_not_found
;
2161 bp_objfile_data
->overlay_msym
= m
;
2164 addr
= SYMBOL_VALUE_ADDRESS (bp_objfile_data
->overlay_msym
);
2165 b
= create_internal_breakpoint (get_objfile_arch (objfile
), addr
,
2167 b
->addr_string
= xstrdup (func_name
);
2169 if (overlay_debugging
== ovly_auto
)
2171 b
->enable_state
= bp_enabled
;
2172 overlay_events_enabled
= 1;
2176 b
->enable_state
= bp_disabled
;
2177 overlay_events_enabled
= 0;
2180 update_global_location_list (1);
2184 create_longjmp_master_breakpoint (void)
2186 struct program_space
*pspace
;
2187 struct cleanup
*old_chain
;
2189 old_chain
= save_current_program_space ();
2191 ALL_PSPACES (pspace
)
2193 struct objfile
*objfile
;
2195 set_current_program_space (pspace
);
2197 ALL_OBJFILES (objfile
)
2200 struct gdbarch
*gdbarch
;
2201 struct breakpoint_objfile_data
*bp_objfile_data
;
2203 gdbarch
= get_objfile_arch (objfile
);
2204 if (!gdbarch_get_longjmp_target_p (gdbarch
))
2207 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
2209 for (i
= 0; i
< NUM_LONGJMP_NAMES
; i
++)
2211 struct breakpoint
*b
;
2212 const char *func_name
;
2215 if (msym_not_found_p (bp_objfile_data
->longjmp_msym
[i
]))
2218 func_name
= longjmp_names
[i
];
2219 if (bp_objfile_data
->longjmp_msym
[i
] == NULL
)
2221 struct minimal_symbol
*m
;
2223 m
= lookup_minimal_symbol_text (func_name
, objfile
);
2226 /* Prevent future lookups in this objfile. */
2227 bp_objfile_data
->longjmp_msym
[i
] = &msym_not_found
;
2230 bp_objfile_data
->longjmp_msym
[i
] = m
;
2233 addr
= SYMBOL_VALUE_ADDRESS (bp_objfile_data
->longjmp_msym
[i
]);
2234 b
= create_internal_breakpoint (gdbarch
, addr
, bp_longjmp_master
);
2235 b
->addr_string
= xstrdup (func_name
);
2236 b
->enable_state
= bp_disabled
;
2240 update_global_location_list (1);
2242 do_cleanups (old_chain
);
2245 /* Create a master std::terminate breakpoint. */
2247 create_std_terminate_master_breakpoint (void)
2249 struct program_space
*pspace
;
2250 struct cleanup
*old_chain
;
2251 const char *const func_name
= "std::terminate()";
2253 old_chain
= save_current_program_space ();
2255 ALL_PSPACES (pspace
)
2257 struct objfile
*objfile
;
2260 set_current_program_space (pspace
);
2262 ALL_OBJFILES (objfile
)
2264 struct breakpoint
*b
;
2265 struct breakpoint_objfile_data
*bp_objfile_data
;
2267 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
2269 if (msym_not_found_p (bp_objfile_data
->terminate_msym
))
2272 if (bp_objfile_data
->terminate_msym
== NULL
)
2274 struct minimal_symbol
*m
;
2276 m
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
2277 if (m
== NULL
|| (MSYMBOL_TYPE (m
) != mst_text
2278 && MSYMBOL_TYPE (m
) != mst_file_text
))
2280 /* Prevent future lookups in this objfile. */
2281 bp_objfile_data
->terminate_msym
= &msym_not_found
;
2284 bp_objfile_data
->terminate_msym
= m
;
2287 addr
= SYMBOL_VALUE_ADDRESS (bp_objfile_data
->terminate_msym
);
2288 b
= create_internal_breakpoint (get_objfile_arch (objfile
), addr
,
2289 bp_std_terminate_master
);
2290 b
->addr_string
= xstrdup (func_name
);
2291 b
->enable_state
= bp_disabled
;
2295 update_global_location_list (1);
2297 do_cleanups (old_chain
);
2300 /* Install a master breakpoint on the unwinder's debug hook. */
2303 create_exception_master_breakpoint (void)
2305 struct objfile
*objfile
;
2306 const char *const func_name
= "_Unwind_DebugHook";
2308 ALL_OBJFILES (objfile
)
2310 struct breakpoint
*b
;
2311 struct gdbarch
*gdbarch
;
2312 struct breakpoint_objfile_data
*bp_objfile_data
;
2315 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
2317 if (msym_not_found_p (bp_objfile_data
->exception_msym
))
2320 gdbarch
= get_objfile_arch (objfile
);
2322 if (bp_objfile_data
->exception_msym
== NULL
)
2324 struct minimal_symbol
*debug_hook
;
2326 debug_hook
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
2327 if (debug_hook
== NULL
)
2329 bp_objfile_data
->exception_msym
= &msym_not_found
;
2333 bp_objfile_data
->exception_msym
= debug_hook
;
2336 addr
= SYMBOL_VALUE_ADDRESS (bp_objfile_data
->exception_msym
);
2337 addr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, addr
,
2339 b
= create_internal_breakpoint (gdbarch
, addr
, bp_exception_master
);
2340 b
->addr_string
= xstrdup (func_name
);
2341 b
->enable_state
= bp_disabled
;
2344 update_global_location_list (1);
2348 update_breakpoints_after_exec (void)
2350 struct breakpoint
*b
, *b_tmp
;
2351 struct bp_location
*bploc
, **bplocp_tmp
;
2353 /* We're about to delete breakpoints from GDB's lists. If the
2354 INSERTED flag is true, GDB will try to lift the breakpoints by
2355 writing the breakpoints' "shadow contents" back into memory. The
2356 "shadow contents" are NOT valid after an exec, so GDB should not
2357 do that. Instead, the target is responsible from marking
2358 breakpoints out as soon as it detects an exec. We don't do that
2359 here instead, because there may be other attempts to delete
2360 breakpoints after detecting an exec and before reaching here. */
2361 ALL_BP_LOCATIONS (bploc
, bplocp_tmp
)
2362 if (bploc
->pspace
== current_program_space
)
2363 gdb_assert (!bploc
->inserted
);
2365 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
2367 if (b
->pspace
!= current_program_space
)
2370 /* Solib breakpoints must be explicitly reset after an exec(). */
2371 if (b
->type
== bp_shlib_event
)
2373 delete_breakpoint (b
);
2377 /* JIT breakpoints must be explicitly reset after an exec(). */
2378 if (b
->type
== bp_jit_event
)
2380 delete_breakpoint (b
);
2384 /* Thread event breakpoints must be set anew after an exec(),
2385 as must overlay event and longjmp master breakpoints. */
2386 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
2387 || b
->type
== bp_longjmp_master
|| b
->type
== bp_std_terminate_master
2388 || b
->type
== bp_exception_master
)
2390 delete_breakpoint (b
);
2394 /* Step-resume breakpoints are meaningless after an exec(). */
2395 if (b
->type
== bp_step_resume
)
2397 delete_breakpoint (b
);
2401 /* Longjmp and longjmp-resume breakpoints are also meaningless
2403 if (b
->type
== bp_longjmp
|| b
->type
== bp_longjmp_resume
2404 || b
->type
== bp_exception
|| b
->type
== bp_exception_resume
)
2406 delete_breakpoint (b
);
2410 if (b
->type
== bp_catchpoint
)
2412 /* For now, none of the bp_catchpoint breakpoints need to
2413 do anything at this point. In the future, if some of
2414 the catchpoints need to something, we will need to add
2415 a new method, and call this method from here. */
2419 /* bp_finish is a special case. The only way we ought to be able
2420 to see one of these when an exec() has happened, is if the user
2421 caught a vfork, and then said "finish". Ordinarily a finish just
2422 carries them to the call-site of the current callee, by setting
2423 a temporary bp there and resuming. But in this case, the finish
2424 will carry them entirely through the vfork & exec.
2426 We don't want to allow a bp_finish to remain inserted now. But
2427 we can't safely delete it, 'cause finish_command has a handle to
2428 the bp on a bpstat, and will later want to delete it. There's a
2429 chance (and I've seen it happen) that if we delete the bp_finish
2430 here, that its storage will get reused by the time finish_command
2431 gets 'round to deleting the "use to be a bp_finish" breakpoint.
2432 We really must allow finish_command to delete a bp_finish.
2434 In the absense of a general solution for the "how do we know
2435 it's safe to delete something others may have handles to?"
2436 problem, what we'll do here is just uninsert the bp_finish, and
2437 let finish_command delete it.
2439 (We know the bp_finish is "doomed" in the sense that it's
2440 momentary, and will be deleted as soon as finish_command sees
2441 the inferior stopped. So it doesn't matter that the bp's
2442 address is probably bogus in the new a.out, unlike e.g., the
2443 solib breakpoints.) */
2445 if (b
->type
== bp_finish
)
2450 /* Without a symbolic address, we have little hope of the
2451 pre-exec() address meaning the same thing in the post-exec()
2453 if (b
->addr_string
== NULL
)
2455 delete_breakpoint (b
);
2459 /* FIXME what about longjmp breakpoints? Re-create them here? */
2460 create_overlay_event_breakpoint ();
2461 create_longjmp_master_breakpoint ();
2462 create_std_terminate_master_breakpoint ();
2463 create_exception_master_breakpoint ();
2467 detach_breakpoints (int pid
)
2469 struct bp_location
*bl
, **blp_tmp
;
2471 struct cleanup
*old_chain
= save_inferior_ptid ();
2472 struct inferior
*inf
= current_inferior ();
2474 if (pid
== PIDGET (inferior_ptid
))
2475 error (_("Cannot detach breakpoints of inferior_ptid"));
2477 /* Set inferior_ptid; remove_breakpoint_1 uses this global. */
2478 inferior_ptid
= pid_to_ptid (pid
);
2479 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2481 if (bl
->pspace
!= inf
->pspace
)
2485 val
|= remove_breakpoint_1 (bl
, mark_inserted
);
2488 /* Detach single-step breakpoints as well. */
2489 detach_single_step_breakpoints ();
2491 do_cleanups (old_chain
);
2495 /* Remove the breakpoint location BL from the current address space.
2496 Note that this is used to detach breakpoints from a child fork.
2497 When we get here, the child isn't in the inferior list, and neither
2498 do we have objects to represent its address space --- we should
2499 *not* look at bl->pspace->aspace here. */
2502 remove_breakpoint_1 (struct bp_location
*bl
, insertion_state_t is
)
2506 /* BL is never in moribund_locations by our callers. */
2507 gdb_assert (bl
->owner
!= NULL
);
2509 if (bl
->owner
->enable_state
== bp_permanent
)
2510 /* Permanent breakpoints cannot be inserted or removed. */
2513 /* The type of none suggests that owner is actually deleted.
2514 This should not ever happen. */
2515 gdb_assert (bl
->owner
->type
!= bp_none
);
2517 if (bl
->loc_type
== bp_loc_software_breakpoint
2518 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
2520 /* "Normal" instruction breakpoint: either the standard
2521 trap-instruction bp (bp_breakpoint), or a
2522 bp_hardware_breakpoint. */
2524 /* First check to see if we have to handle an overlay. */
2525 if (overlay_debugging
== ovly_off
2526 || bl
->section
== NULL
2527 || !(section_is_overlay (bl
->section
)))
2529 /* No overlay handling: just remove the breakpoint. */
2531 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
2532 val
= target_remove_hw_breakpoint (bl
->gdbarch
, &bl
->target_info
);
2534 val
= target_remove_breakpoint (bl
->gdbarch
, &bl
->target_info
);
2538 /* This breakpoint is in an overlay section.
2539 Did we set a breakpoint at the LMA? */
2540 if (!overlay_events_enabled
)
2542 /* Yes -- overlay event support is not active, so we
2543 should have set a breakpoint at the LMA. Remove it.
2545 /* Ignore any failures: if the LMA is in ROM, we will
2546 have already warned when we failed to insert it. */
2547 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
2548 target_remove_hw_breakpoint (bl
->gdbarch
,
2549 &bl
->overlay_target_info
);
2551 target_remove_breakpoint (bl
->gdbarch
,
2552 &bl
->overlay_target_info
);
2554 /* Did we set a breakpoint at the VMA?
2555 If so, we will have marked the breakpoint 'inserted'. */
2558 /* Yes -- remove it. Previously we did not bother to
2559 remove the breakpoint if the section had been
2560 unmapped, but let's not rely on that being safe. We
2561 don't know what the overlay manager might do. */
2562 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
2563 val
= target_remove_hw_breakpoint (bl
->gdbarch
,
2566 /* However, we should remove *software* breakpoints only
2567 if the section is still mapped, or else we overwrite
2568 wrong code with the saved shadow contents. */
2569 else if (section_is_mapped (bl
->section
))
2570 val
= target_remove_breakpoint (bl
->gdbarch
,
2577 /* No -- not inserted, so no need to remove. No error. */
2582 /* In some cases, we might not be able to remove a breakpoint
2583 in a shared library that has already been removed, but we
2584 have not yet processed the shlib unload event. */
2585 if (val
&& solib_name_from_address (bl
->pspace
, bl
->address
))
2590 bl
->inserted
= (is
== mark_inserted
);
2592 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
)
2594 gdb_assert (bl
->owner
->ops
!= NULL
2595 && bl
->owner
->ops
->remove_location
!= NULL
);
2597 bl
->inserted
= (is
== mark_inserted
);
2598 bl
->owner
->ops
->remove_location (bl
);
2600 /* Failure to remove any of the hardware watchpoints comes here. */
2601 if ((is
== mark_uninserted
) && (bl
->inserted
))
2602 warning (_("Could not remove hardware watchpoint %d."),
2605 else if (bl
->owner
->type
== bp_catchpoint
2606 && breakpoint_enabled (bl
->owner
)
2609 gdb_assert (bl
->owner
->ops
!= NULL
2610 && bl
->owner
->ops
->remove_location
!= NULL
);
2612 val
= bl
->owner
->ops
->remove_location (bl
);
2616 bl
->inserted
= (is
== mark_inserted
);
2623 remove_breakpoint (struct bp_location
*bl
, insertion_state_t is
)
2626 struct cleanup
*old_chain
;
2628 /* BL is never in moribund_locations by our callers. */
2629 gdb_assert (bl
->owner
!= NULL
);
2631 if (bl
->owner
->enable_state
== bp_permanent
)
2632 /* Permanent breakpoints cannot be inserted or removed. */
2635 /* The type of none suggests that owner is actually deleted.
2636 This should not ever happen. */
2637 gdb_assert (bl
->owner
->type
!= bp_none
);
2639 old_chain
= save_current_space_and_thread ();
2641 switch_to_program_space_and_thread (bl
->pspace
);
2643 ret
= remove_breakpoint_1 (bl
, is
);
2645 do_cleanups (old_chain
);
2649 /* Clear the "inserted" flag in all breakpoints. */
2652 mark_breakpoints_out (void)
2654 struct bp_location
*bl
, **blp_tmp
;
2656 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2657 if (bl
->pspace
== current_program_space
)
2661 /* Clear the "inserted" flag in all breakpoints and delete any
2662 breakpoints which should go away between runs of the program.
2664 Plus other such housekeeping that has to be done for breakpoints
2667 Note: this function gets called at the end of a run (by
2668 generic_mourn_inferior) and when a run begins (by
2669 init_wait_for_inferior). */
2674 breakpoint_init_inferior (enum inf_context context
)
2676 struct breakpoint
*b
, *b_tmp
;
2677 struct bp_location
*bl
, **blp_tmp
;
2679 struct program_space
*pspace
= current_program_space
;
2681 /* If breakpoint locations are shared across processes, then there's
2683 if (gdbarch_has_global_breakpoints (target_gdbarch
))
2686 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2688 /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
2689 if (bl
->pspace
== pspace
2690 && bl
->owner
->enable_state
!= bp_permanent
)
2694 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
2696 if (b
->loc
&& b
->loc
->pspace
!= pspace
)
2703 /* If the call dummy breakpoint is at the entry point it will
2704 cause problems when the inferior is rerun, so we better get
2707 case bp_watchpoint_scope
:
2709 /* Also get rid of scope breakpoints. */
2711 case bp_shlib_event
:
2713 /* Also remove solib event breakpoints. Their addresses may
2714 have changed since the last time we ran the program.
2715 Actually we may now be debugging against different target;
2716 and so the solib backend that installed this breakpoint may
2717 not be used in by the target. E.g.,
2719 (gdb) file prog-linux
2720 (gdb) run # native linux target
2723 (gdb) file prog-win.exe
2724 (gdb) tar rem :9999 # remote Windows gdbserver.
2727 delete_breakpoint (b
);
2731 case bp_hardware_watchpoint
:
2732 case bp_read_watchpoint
:
2733 case bp_access_watchpoint
:
2735 /* Likewise for watchpoints on local expressions. */
2736 if (b
->exp_valid_block
!= NULL
)
2737 delete_breakpoint (b
);
2738 else if (context
== inf_starting
)
2740 /* Reset val field to force reread of starting value in
2741 insert_breakpoints. */
2743 value_free (b
->val
);
2753 /* Get rid of the moribund locations. */
2754 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, bl
); ++ix
)
2755 decref_bp_location (&bl
);
2756 VEC_free (bp_location_p
, moribund_locations
);
2759 /* These functions concern about actual breakpoints inserted in the
2760 target --- to e.g. check if we need to do decr_pc adjustment or if
2761 we need to hop over the bkpt --- so we check for address space
2762 match, not program space. */
2764 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
2765 exists at PC. It returns ordinary_breakpoint_here if it's an
2766 ordinary breakpoint, or permanent_breakpoint_here if it's a
2767 permanent breakpoint.
2768 - When continuing from a location with an ordinary breakpoint, we
2769 actually single step once before calling insert_breakpoints.
2770 - When continuing from a localion with a permanent breakpoint, we
2771 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
2772 the target, to advance the PC past the breakpoint. */
2774 enum breakpoint_here
2775 breakpoint_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2777 struct bp_location
*bl
, **blp_tmp
;
2778 int any_breakpoint_here
= 0;
2780 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2782 if (bl
->loc_type
!= bp_loc_software_breakpoint
2783 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
2786 /* ALL_BP_LOCATIONS bp_location has bl->OWNER always non-NULL. */
2787 if ((breakpoint_enabled (bl
->owner
)
2788 || bl
->owner
->enable_state
== bp_permanent
)
2789 && breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
2792 if (overlay_debugging
2793 && section_is_overlay (bl
->section
)
2794 && !section_is_mapped (bl
->section
))
2795 continue; /* unmapped overlay -- can't be a match */
2796 else if (bl
->owner
->enable_state
== bp_permanent
)
2797 return permanent_breakpoint_here
;
2799 any_breakpoint_here
= 1;
2803 return any_breakpoint_here
? ordinary_breakpoint_here
: 0;
2806 /* Return true if there's a moribund breakpoint at PC. */
2809 moribund_breakpoint_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2811 struct bp_location
*loc
;
2814 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
2815 if (breakpoint_address_match (loc
->pspace
->aspace
, loc
->address
,
2822 /* Returns non-zero if there's a breakpoint inserted at PC, which is
2823 inserted using regular breakpoint_chain / bp_location array
2824 mechanism. This does not check for single-step breakpoints, which
2825 are inserted and removed using direct target manipulation. */
2828 regular_breakpoint_inserted_here_p (struct address_space
*aspace
,
2831 struct bp_location
*bl
, **blp_tmp
;
2833 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2835 if (bl
->loc_type
!= bp_loc_software_breakpoint
2836 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
2840 && breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
2843 if (overlay_debugging
2844 && section_is_overlay (bl
->section
)
2845 && !section_is_mapped (bl
->section
))
2846 continue; /* unmapped overlay -- can't be a match */
2854 /* Returns non-zero iff there's either regular breakpoint
2855 or a single step breakpoint inserted at PC. */
2858 breakpoint_inserted_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2860 if (regular_breakpoint_inserted_here_p (aspace
, pc
))
2863 if (single_step_breakpoint_inserted_here_p (aspace
, pc
))
2869 /* This function returns non-zero iff there is a software breakpoint
2873 software_breakpoint_inserted_here_p (struct address_space
*aspace
,
2876 struct bp_location
*bl
, **blp_tmp
;
2878 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2880 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
2884 && breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
2887 if (overlay_debugging
2888 && section_is_overlay (bl
->section
)
2889 && !section_is_mapped (bl
->section
))
2890 continue; /* unmapped overlay -- can't be a match */
2896 /* Also check for software single-step breakpoints. */
2897 if (single_step_breakpoint_inserted_here_p (aspace
, pc
))
2904 hardware_watchpoint_inserted_in_range (struct address_space
*aspace
,
2905 CORE_ADDR addr
, ULONGEST len
)
2907 struct breakpoint
*bpt
;
2909 ALL_BREAKPOINTS (bpt
)
2911 struct bp_location
*loc
;
2913 if (bpt
->type
!= bp_hardware_watchpoint
2914 && bpt
->type
!= bp_access_watchpoint
)
2917 if (!breakpoint_enabled (bpt
))
2920 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
2921 if (loc
->pspace
->aspace
== aspace
&& loc
->inserted
)
2925 /* Check for intersection. */
2926 l
= max (loc
->address
, addr
);
2927 h
= min (loc
->address
+ loc
->length
, addr
+ len
);
2935 /* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
2936 PC is valid for process/thread PTID. */
2939 breakpoint_thread_match (struct address_space
*aspace
, CORE_ADDR pc
,
2942 struct bp_location
*bl
, **blp_tmp
;
2943 /* The thread and task IDs associated to PTID, computed lazily. */
2947 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2949 if (bl
->loc_type
!= bp_loc_software_breakpoint
2950 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
2953 /* ALL_BP_LOCATIONS bp_location has bl->OWNER always non-NULL. */
2954 if (!breakpoint_enabled (bl
->owner
)
2955 && bl
->owner
->enable_state
!= bp_permanent
)
2958 if (!breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
2962 if (bl
->owner
->thread
!= -1)
2964 /* This is a thread-specific breakpoint. Check that ptid
2965 matches that thread. If thread hasn't been computed yet,
2966 it is now time to do so. */
2968 thread
= pid_to_thread_id (ptid
);
2969 if (bl
->owner
->thread
!= thread
)
2973 if (bl
->owner
->task
!= 0)
2975 /* This is a task-specific breakpoint. Check that ptid
2976 matches that task. If task hasn't been computed yet,
2977 it is now time to do so. */
2979 task
= ada_get_task_number (ptid
);
2980 if (bl
->owner
->task
!= task
)
2984 if (overlay_debugging
2985 && section_is_overlay (bl
->section
)
2986 && !section_is_mapped (bl
->section
))
2987 continue; /* unmapped overlay -- can't be a match */
2996 /* bpstat stuff. External routines' interfaces are documented
3000 ep_is_catchpoint (struct breakpoint
*ep
)
3002 return (ep
->type
== bp_catchpoint
);
3005 /* Frees any storage that is part of a bpstat. Does not walk the
3009 bpstat_free (bpstat bs
)
3011 if (bs
->old_val
!= NULL
)
3012 value_free (bs
->old_val
);
3013 decref_counted_command_line (&bs
->commands
);
3014 decref_bp_location (&bs
->bp_location_at
);
3018 /* Clear a bpstat so that it says we are not at any breakpoint.
3019 Also free any storage that is part of a bpstat. */
3022 bpstat_clear (bpstat
*bsp
)
3039 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
3040 is part of the bpstat is copied as well. */
3043 bpstat_copy (bpstat bs
)
3047 bpstat retval
= NULL
;
3052 for (; bs
!= NULL
; bs
= bs
->next
)
3054 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
3055 memcpy (tmp
, bs
, sizeof (*tmp
));
3056 incref_counted_command_line (tmp
->commands
);
3057 incref_bp_location (tmp
->bp_location_at
);
3058 if (bs
->old_val
!= NULL
)
3060 tmp
->old_val
= value_copy (bs
->old_val
);
3061 release_value (tmp
->old_val
);
3065 /* This is the first thing in the chain. */
3075 /* Find the bpstat associated with this breakpoint. */
3078 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
3083 for (; bsp
!= NULL
; bsp
= bsp
->next
)
3085 if (bsp
->breakpoint_at
== breakpoint
)
3091 /* Put in *NUM the breakpoint number of the first breakpoint we are
3092 stopped at. *BSP upon return is a bpstat which points to the
3093 remaining breakpoints stopped at (but which is not guaranteed to be
3094 good for anything but further calls to bpstat_num).
3096 Return 0 if passed a bpstat which does not indicate any breakpoints.
3097 Return -1 if stopped at a breakpoint that has been deleted since
3099 Return 1 otherwise. */
3102 bpstat_num (bpstat
*bsp
, int *num
)
3104 struct breakpoint
*b
;
3107 return 0; /* No more breakpoint values */
3109 /* We assume we'll never have several bpstats that correspond to a
3110 single breakpoint -- otherwise, this function might return the
3111 same number more than once and this will look ugly. */
3112 b
= (*bsp
)->breakpoint_at
;
3113 *bsp
= (*bsp
)->next
;
3115 return -1; /* breakpoint that's been deleted since */
3117 *num
= b
->number
; /* We have its number */
3121 /* Modify BS so that the actions will not be performed. */
3124 bpstat_clear_actions (bpstat bs
)
3126 for (; bs
!= NULL
; bs
= bs
->next
)
3128 decref_counted_command_line (&bs
->commands
);
3129 bs
->commands_left
= NULL
;
3130 if (bs
->old_val
!= NULL
)
3132 value_free (bs
->old_val
);
3138 /* Called when a command is about to proceed the inferior. */
3141 breakpoint_about_to_proceed (void)
3143 if (!ptid_equal (inferior_ptid
, null_ptid
))
3145 struct thread_info
*tp
= inferior_thread ();
3147 /* Allow inferior function calls in breakpoint commands to not
3148 interrupt the command list. When the call finishes
3149 successfully, the inferior will be standing at the same
3150 breakpoint as if nothing happened. */
3151 if (tp
->control
.in_infcall
)
3155 breakpoint_proceeded
= 1;
3158 /* Stub for cleaning up our state if we error-out of a breakpoint
3161 cleanup_executing_breakpoints (void *ignore
)
3163 executing_breakpoint_commands
= 0;
3166 /* Execute all the commands associated with all the breakpoints at
3167 this location. Any of these commands could cause the process to
3168 proceed beyond this point, etc. We look out for such changes by
3169 checking the global "breakpoint_proceeded" after each command.
3171 Returns true if a breakpoint command resumed the inferior. In that
3172 case, it is the caller's responsibility to recall it again with the
3173 bpstat of the current thread. */
3176 bpstat_do_actions_1 (bpstat
*bsp
)
3179 struct cleanup
*old_chain
;
3182 /* Avoid endless recursion if a `source' command is contained
3184 if (executing_breakpoint_commands
)
3187 executing_breakpoint_commands
= 1;
3188 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
3190 /* This pointer will iterate over the list of bpstat's. */
3193 breakpoint_proceeded
= 0;
3194 for (; bs
!= NULL
; bs
= bs
->next
)
3196 struct counted_command_line
*ccmd
;
3197 struct command_line
*cmd
;
3198 struct cleanup
*this_cmd_tree_chain
;
3200 /* Take ownership of the BSP's command tree, if it has one.
3202 The command tree could legitimately contain commands like
3203 'step' and 'next', which call clear_proceed_status, which
3204 frees stop_bpstat's command tree. To make sure this doesn't
3205 free the tree we're executing out from under us, we need to
3206 take ownership of the tree ourselves. Since a given bpstat's
3207 commands are only executed once, we don't need to copy it; we
3208 can clear the pointer in the bpstat, and make sure we free
3209 the tree when we're done. */
3210 ccmd
= bs
->commands
;
3211 bs
->commands
= NULL
;
3213 = make_cleanup_decref_counted_command_line (&ccmd
);
3214 cmd
= bs
->commands_left
;
3215 bs
->commands_left
= NULL
;
3219 execute_control_command (cmd
);
3221 if (breakpoint_proceeded
)
3227 /* We can free this command tree now. */
3228 do_cleanups (this_cmd_tree_chain
);
3230 if (breakpoint_proceeded
)
3232 if (target_can_async_p ())
3233 /* If we are in async mode, then the target might be still
3234 running, not stopped at any breakpoint, so nothing for
3235 us to do here -- just return to the event loop. */
3238 /* In sync mode, when execute_control_command returns
3239 we're already standing on the next breakpoint.
3240 Breakpoint commands for that stop were not run, since
3241 execute_command does not run breakpoint commands --
3242 only command_line_handler does, but that one is not
3243 involved in execution of breakpoint commands. So, we
3244 can now execute breakpoint commands. It should be
3245 noted that making execute_command do bpstat actions is
3246 not an option -- in this case we'll have recursive
3247 invocation of bpstat for each breakpoint with a
3248 command, and can easily blow up GDB stack. Instead, we
3249 return true, which will trigger the caller to recall us
3250 with the new stop_bpstat. */
3255 do_cleanups (old_chain
);
3260 bpstat_do_actions (void)
3262 /* Do any commands attached to breakpoint we are stopped at. */
3263 while (!ptid_equal (inferior_ptid
, null_ptid
)
3264 && target_has_execution
3265 && !is_exited (inferior_ptid
)
3266 && !is_executing (inferior_ptid
))
3267 /* Since in sync mode, bpstat_do_actions may resume the inferior,
3268 and only return when it is stopped at the next breakpoint, we
3269 keep doing breakpoint actions until it returns false to
3270 indicate the inferior was not resumed. */
3271 if (!bpstat_do_actions_1 (&inferior_thread ()->control
.stop_bpstat
))
3275 /* Print out the (old or new) value associated with a watchpoint. */
3278 watchpoint_value_print (struct value
*val
, struct ui_file
*stream
)
3281 fprintf_unfiltered (stream
, _("<unreadable>"));
3284 struct value_print_options opts
;
3285 get_user_print_options (&opts
);
3286 value_print (val
, stream
, &opts
);
3290 /* This is the normal print function for a bpstat. In the future,
3291 much of this logic could (should?) be moved to bpstat_stop_status,
3292 by having it set different print_it values.
3294 Current scheme: When we stop, bpstat_print() is called. It loops
3295 through the bpstat list of things causing this stop, calling the
3296 print_bp_stop_message function on each one. The behavior of the
3297 print_bp_stop_message function depends on the print_it field of
3298 bpstat. If such field so indicates, call this function here.
3300 Return values from this routine (ultimately used by bpstat_print()
3301 and normal_stop() to decide what to do):
3302 PRINT_NOTHING: Means we already printed all we needed to print,
3303 don't print anything else.
3304 PRINT_SRC_ONLY: Means we printed something, and we do *not* desire
3305 that something to be followed by a location.
3306 PRINT_SCR_AND_LOC: Means we printed something, and we *do* desire
3307 that something to be followed by a location.
3308 PRINT_UNKNOWN: Means we printed nothing or we need to do some more
3311 static enum print_stop_action
3312 print_it_typical (bpstat bs
)
3314 struct cleanup
*old_chain
;
3315 struct breakpoint
*b
;
3316 const struct bp_location
*bl
;
3317 struct ui_stream
*stb
;
3319 enum print_stop_action result
;
3321 gdb_assert (bs
->bp_location_at
!= NULL
);
3323 bl
= bs
->bp_location_at
;
3324 b
= bs
->breakpoint_at
;
3326 stb
= ui_out_stream_new (uiout
);
3327 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
3332 case bp_hardware_breakpoint
:
3333 bp_temp
= b
->disposition
== disp_del
;
3334 if (bl
->address
!= bl
->requested_address
)
3335 breakpoint_adjustment_warning (bl
->requested_address
,
3338 annotate_breakpoint (b
->number
);
3340 ui_out_text (uiout
, "\nTemporary breakpoint ");
3342 ui_out_text (uiout
, "\nBreakpoint ");
3343 if (ui_out_is_mi_like_p (uiout
))
3345 ui_out_field_string (uiout
, "reason",
3346 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
3347 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
3349 ui_out_field_int (uiout
, "bkptno", b
->number
);
3350 ui_out_text (uiout
, ", ");
3351 result
= PRINT_SRC_AND_LOC
;
3354 case bp_shlib_event
:
3355 /* Did we stop because the user set the stop_on_solib_events
3356 variable? (If so, we report this as a generic, "Stopped due
3357 to shlib event" message.) */
3358 printf_filtered (_("Stopped due to shared library event\n"));
3359 result
= PRINT_NOTHING
;
3362 case bp_thread_event
:
3363 /* Not sure how we will get here.
3364 GDB should not stop for these breakpoints. */
3365 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
3366 result
= PRINT_NOTHING
;
3369 case bp_overlay_event
:
3370 /* By analogy with the thread event, GDB should not stop for these. */
3371 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
3372 result
= PRINT_NOTHING
;
3375 case bp_longjmp_master
:
3376 /* These should never be enabled. */
3377 printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
3378 result
= PRINT_NOTHING
;
3381 case bp_std_terminate_master
:
3382 /* These should never be enabled. */
3383 printf_filtered (_("std::terminate Master Breakpoint: "
3384 "gdb should not stop!\n"));
3385 result
= PRINT_NOTHING
;
3388 case bp_exception_master
:
3389 /* These should never be enabled. */
3390 printf_filtered (_("Exception Master Breakpoint: "
3391 "gdb should not stop!\n"));
3392 result
= PRINT_NOTHING
;
3396 case bp_hardware_watchpoint
:
3397 annotate_watchpoint (b
->number
);
3398 if (ui_out_is_mi_like_p (uiout
))
3401 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
3403 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
3404 ui_out_text (uiout
, "\nOld value = ");
3405 watchpoint_value_print (bs
->old_val
, stb
->stream
);
3406 ui_out_field_stream (uiout
, "old", stb
);
3407 ui_out_text (uiout
, "\nNew value = ");
3408 watchpoint_value_print (b
->val
, stb
->stream
);
3409 ui_out_field_stream (uiout
, "new", stb
);
3410 ui_out_text (uiout
, "\n");
3411 /* More than one watchpoint may have been triggered. */
3412 result
= PRINT_UNKNOWN
;
3415 case bp_read_watchpoint
:
3416 if (ui_out_is_mi_like_p (uiout
))
3419 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
3421 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
3422 ui_out_text (uiout
, "\nValue = ");
3423 watchpoint_value_print (b
->val
, stb
->stream
);
3424 ui_out_field_stream (uiout
, "value", stb
);
3425 ui_out_text (uiout
, "\n");
3426 result
= PRINT_UNKNOWN
;
3429 case bp_access_watchpoint
:
3430 if (bs
->old_val
!= NULL
)
3432 annotate_watchpoint (b
->number
);
3433 if (ui_out_is_mi_like_p (uiout
))
3436 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
3438 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
3439 ui_out_text (uiout
, "\nOld value = ");
3440 watchpoint_value_print (bs
->old_val
, stb
->stream
);
3441 ui_out_field_stream (uiout
, "old", stb
);
3442 ui_out_text (uiout
, "\nNew value = ");
3447 if (ui_out_is_mi_like_p (uiout
))
3450 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
3451 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
3452 ui_out_text (uiout
, "\nValue = ");
3454 watchpoint_value_print (b
->val
, stb
->stream
);
3455 ui_out_field_stream (uiout
, "new", stb
);
3456 ui_out_text (uiout
, "\n");
3457 result
= PRINT_UNKNOWN
;
3460 /* Fall through, we don't deal with these types of breakpoints
3464 if (ui_out_is_mi_like_p (uiout
))
3467 async_reason_lookup (EXEC_ASYNC_FUNCTION_FINISHED
));
3468 result
= PRINT_UNKNOWN
;
3472 if (ui_out_is_mi_like_p (uiout
))
3475 async_reason_lookup (EXEC_ASYNC_LOCATION_REACHED
));
3476 result
= PRINT_UNKNOWN
;
3481 case bp_longjmp_resume
:
3483 case bp_exception_resume
:
3484 case bp_step_resume
:
3485 case bp_watchpoint_scope
:
3487 case bp_std_terminate
:
3489 case bp_fast_tracepoint
:
3492 result
= PRINT_UNKNOWN
;
3496 do_cleanups (old_chain
);
3500 /* Generic routine for printing messages indicating why we
3501 stopped. The behavior of this function depends on the value
3502 'print_it' in the bpstat structure. Under some circumstances we
3503 may decide not to print anything here and delegate the task to
3506 static enum print_stop_action
3507 print_bp_stop_message (bpstat bs
)
3509 switch (bs
->print_it
)
3512 /* Nothing should be printed for this bpstat entry. */
3513 return PRINT_UNKNOWN
;
3517 /* We still want to print the frame, but we already printed the
3518 relevant messages. */
3519 return PRINT_SRC_AND_LOC
;
3522 case print_it_normal
:
3524 struct breakpoint
*b
= bs
->breakpoint_at
;
3526 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
3527 which has since been deleted. */
3529 return PRINT_UNKNOWN
;
3531 /* Normal case. Call the breakpoint's print_it method, or
3532 print_it_typical. */
3533 if (b
->ops
!= NULL
&& b
->ops
->print_it
!= NULL
)
3534 return b
->ops
->print_it (b
);
3536 return print_it_typical (bs
);
3541 internal_error (__FILE__
, __LINE__
,
3542 _("print_bp_stop_message: unrecognized enum value"));
3547 /* Print a message indicating what happened. This is called from
3548 normal_stop(). The input to this routine is the head of the bpstat
3549 list - a list of the eventpoints that caused this stop. This
3550 routine calls the generic print routine for printing a message
3551 about reasons for stopping. This will print (for example) the
3552 "Breakpoint n," part of the output. The return value of this
3555 PRINT_UNKNOWN: Means we printed nothing.
3556 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
3557 code to print the location. An example is
3558 "Breakpoint 1, " which should be followed by
3560 PRINT_SRC_ONLY: Means we printed something, but there is no need
3561 to also print the location part of the message.
3562 An example is the catch/throw messages, which
3563 don't require a location appended to the end.
3564 PRINT_NOTHING: We have done some printing and we don't need any
3565 further info to be printed. */
3567 enum print_stop_action
3568 bpstat_print (bpstat bs
)
3572 /* Maybe another breakpoint in the chain caused us to stop.
3573 (Currently all watchpoints go on the bpstat whether hit or not.
3574 That probably could (should) be changed, provided care is taken
3575 with respect to bpstat_explains_signal). */
3576 for (; bs
; bs
= bs
->next
)
3578 val
= print_bp_stop_message (bs
);
3579 if (val
== PRINT_SRC_ONLY
3580 || val
== PRINT_SRC_AND_LOC
3581 || val
== PRINT_NOTHING
)
3585 /* We reached the end of the chain, or we got a null BS to start
3586 with and nothing was printed. */
3587 return PRINT_UNKNOWN
;
3590 /* Evaluate the expression EXP and return 1 if value is zero. This is
3591 used inside a catch_errors to evaluate the breakpoint condition.
3592 The argument is a "struct expression *" that has been cast to a
3593 "char *" to make it pass through catch_errors. */
3596 breakpoint_cond_eval (void *exp
)
3598 struct value
*mark
= value_mark ();
3599 int i
= !value_true (evaluate_expression ((struct expression
*) exp
));
3601 value_free_to_mark (mark
);
3605 /* Allocate a new bpstat. Link it to the FIFO list by BS_LINK_POINTER. */
3608 bpstat_alloc (struct bp_location
*bl
, bpstat
**bs_link_pointer
)
3612 bs
= (bpstat
) xmalloc (sizeof (*bs
));
3614 **bs_link_pointer
= bs
;
3615 *bs_link_pointer
= &bs
->next
;
3616 bs
->breakpoint_at
= bl
->owner
;
3617 bs
->bp_location_at
= bl
;
3618 incref_bp_location (bl
);
3619 /* If the condition is false, etc., don't do the commands. */
3620 bs
->commands
= NULL
;
3621 bs
->commands_left
= NULL
;
3623 bs
->print_it
= print_it_normal
;
3627 /* The target has stopped with waitstatus WS. Check if any hardware
3628 watchpoints have triggered, according to the target. */
3631 watchpoints_triggered (struct target_waitstatus
*ws
)
3633 int stopped_by_watchpoint
= target_stopped_by_watchpoint ();
3635 struct breakpoint
*b
;
3637 if (!stopped_by_watchpoint
)
3639 /* We were not stopped by a watchpoint. Mark all watchpoints
3640 as not triggered. */
3642 if (is_hardware_watchpoint (b
))
3643 b
->watchpoint_triggered
= watch_triggered_no
;
3648 if (!target_stopped_data_address (¤t_target
, &addr
))
3650 /* We were stopped by a watchpoint, but we don't know where.
3651 Mark all watchpoints as unknown. */
3653 if (is_hardware_watchpoint (b
))
3654 b
->watchpoint_triggered
= watch_triggered_unknown
;
3656 return stopped_by_watchpoint
;
3659 /* The target could report the data address. Mark watchpoints
3660 affected by this data address as triggered, and all others as not
3664 if (is_hardware_watchpoint (b
))
3666 struct bp_location
*loc
;
3668 b
->watchpoint_triggered
= watch_triggered_no
;
3669 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
3670 /* Exact match not required. Within range is
3672 if (target_watchpoint_addr_within_range (¤t_target
,
3676 b
->watchpoint_triggered
= watch_triggered_yes
;
3684 /* Possible return values for watchpoint_check (this can't be an enum
3685 because of check_errors). */
3686 /* The watchpoint has been deleted. */
3687 #define WP_DELETED 1
3688 /* The value has changed. */
3689 #define WP_VALUE_CHANGED 2
3690 /* The value has not changed. */
3691 #define WP_VALUE_NOT_CHANGED 3
3692 /* Ignore this watchpoint, no matter if the value changed or not. */
3695 #define BP_TEMPFLAG 1
3696 #define BP_HARDWAREFLAG 2
3698 /* Evaluate watchpoint condition expression and check if its value
3701 P should be a pointer to struct bpstat, but is defined as a void *
3702 in order for this function to be usable with catch_errors. */
3705 watchpoint_check (void *p
)
3707 bpstat bs
= (bpstat
) p
;
3708 struct breakpoint
*b
;
3709 struct frame_info
*fr
;
3710 int within_current_scope
;
3712 /* BS is built from an existing struct breakpoint. */
3713 gdb_assert (bs
->breakpoint_at
!= NULL
);
3714 b
= bs
->breakpoint_at
;
3716 /* If this is a local watchpoint, we only want to check if the
3717 watchpoint frame is in scope if the current thread is the thread
3718 that was used to create the watchpoint. */
3719 if (!watchpoint_in_thread_scope (b
))
3722 if (b
->exp_valid_block
== NULL
)
3723 within_current_scope
= 1;
3726 struct frame_info
*frame
= get_current_frame ();
3727 struct gdbarch
*frame_arch
= get_frame_arch (frame
);
3728 CORE_ADDR frame_pc
= get_frame_pc (frame
);
3730 /* in_function_epilogue_p() returns a non-zero value if we're
3731 still in the function but the stack frame has already been
3732 invalidated. Since we can't rely on the values of local
3733 variables after the stack has been destroyed, we are treating
3734 the watchpoint in that state as `not changed' without further
3735 checking. Don't mark watchpoints as changed if the current
3736 frame is in an epilogue - even if they are in some other
3737 frame, our view of the stack is likely to be wrong and
3738 frame_find_by_id could error out. */
3739 if (gdbarch_in_function_epilogue_p (frame_arch
, frame_pc
))
3742 fr
= frame_find_by_id (b
->watchpoint_frame
);
3743 within_current_scope
= (fr
!= NULL
);
3745 /* If we've gotten confused in the unwinder, we might have
3746 returned a frame that can't describe this variable. */
3747 if (within_current_scope
)
3749 struct symbol
*function
;
3751 function
= get_frame_function (fr
);
3752 if (function
== NULL
3753 || !contained_in (b
->exp_valid_block
,
3754 SYMBOL_BLOCK_VALUE (function
)))
3755 within_current_scope
= 0;
3758 if (within_current_scope
)
3759 /* If we end up stopping, the current frame will get selected
3760 in normal_stop. So this call to select_frame won't affect
3765 if (within_current_scope
)
3767 /* We use value_{,free_to_}mark because it could be a *long*
3768 time before we return to the command level and call
3769 free_all_values. We can't call free_all_values because we
3770 might be in the middle of evaluating a function call. */
3773 struct value
*mark
= value_mark ();
3774 struct value
*new_val
;
3776 fetch_subexp_value (b
->exp
, &pc
, &new_val
, NULL
, NULL
);
3778 /* We use value_equal_contents instead of value_equal because
3779 the latter coerces an array to a pointer, thus comparing just
3780 the address of the array instead of its contents. This is
3781 not what we want. */
3782 if ((b
->val
!= NULL
) != (new_val
!= NULL
)
3783 || (b
->val
!= NULL
&& !value_equal_contents (b
->val
, new_val
)))
3785 if (new_val
!= NULL
)
3787 release_value (new_val
);
3788 value_free_to_mark (mark
);
3790 bs
->old_val
= b
->val
;
3793 return WP_VALUE_CHANGED
;
3797 /* Nothing changed. */
3798 value_free_to_mark (mark
);
3799 return WP_VALUE_NOT_CHANGED
;
3804 /* This seems like the only logical thing to do because
3805 if we temporarily ignored the watchpoint, then when
3806 we reenter the block in which it is valid it contains
3807 garbage (in the case of a function, it may have two
3808 garbage values, one before and one after the prologue).
3809 So we can't even detect the first assignment to it and
3810 watch after that (since the garbage may or may not equal
3811 the first value assigned). */
3812 /* We print all the stop information in print_it_typical(), but
3813 in this case, by the time we call print_it_typical() this bp
3814 will be deleted already. So we have no choice but print the
3815 information here. */
3816 if (ui_out_is_mi_like_p (uiout
))
3818 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
3819 ui_out_text (uiout
, "\nWatchpoint ");
3820 ui_out_field_int (uiout
, "wpnum", b
->number
);
3822 " deleted because the program has left the block in\n\
3823 which its expression is valid.\n");
3825 if (b
->related_breakpoint
)
3827 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
3828 b
->related_breakpoint
->related_breakpoint
= NULL
;
3829 b
->related_breakpoint
= NULL
;
3831 b
->disposition
= disp_del_at_next_stop
;
3837 /* Return true if it looks like target has stopped due to hitting
3838 breakpoint location BL. This function does not check if we
3839 should stop, only if BL explains the stop. */
3841 bpstat_check_location (const struct bp_location
*bl
,
3842 struct address_space
*aspace
, CORE_ADDR bp_addr
)
3844 struct breakpoint
*b
= bl
->owner
;
3846 /* BL is from existing struct breakpoint. */
3847 gdb_assert (b
!= NULL
);
3849 /* By definition, the inferior does not report stops at
3851 if (is_tracepoint (b
))
3854 if (!is_watchpoint (b
)
3855 && b
->type
!= bp_hardware_breakpoint
3856 && b
->type
!= bp_catchpoint
) /* a non-watchpoint bp */
3858 if (!breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
3861 if (overlay_debugging
/* unmapped overlay section */
3862 && section_is_overlay (bl
->section
)
3863 && !section_is_mapped (bl
->section
))
3867 /* Continuable hardware watchpoints are treated as non-existent if the
3868 reason we stopped wasn't a hardware watchpoint (we didn't stop on
3869 some data address). Otherwise gdb won't stop on a break instruction
3870 in the code (not from a breakpoint) when a hardware watchpoint has
3871 been defined. Also skip watchpoints which we know did not trigger
3872 (did not match the data address). */
3874 if (is_hardware_watchpoint (b
)
3875 && b
->watchpoint_triggered
== watch_triggered_no
)
3878 if (b
->type
== bp_hardware_breakpoint
)
3880 if (bl
->address
!= bp_addr
)
3882 if (overlay_debugging
/* unmapped overlay section */
3883 && section_is_overlay (bl
->section
)
3884 && !section_is_mapped (bl
->section
))
3888 if (b
->type
== bp_catchpoint
)
3890 gdb_assert (b
->ops
!= NULL
&& b
->ops
->breakpoint_hit
!= NULL
);
3891 if (!b
->ops
->breakpoint_hit (b
))
3898 /* If BS refers to a watchpoint, determine if the watched values
3899 has actually changed, and we should stop. If not, set BS->stop
3902 bpstat_check_watchpoint (bpstat bs
)
3904 const struct bp_location
*bl
;
3905 struct breakpoint
*b
;
3907 /* BS is built for existing struct breakpoint. */
3908 bl
= bs
->bp_location_at
;
3909 gdb_assert (bl
!= NULL
);
3910 b
= bs
->breakpoint_at
;
3911 gdb_assert (b
!= NULL
);
3913 if (is_watchpoint (b
))
3915 int must_check_value
= 0;
3917 if (b
->type
== bp_watchpoint
)
3918 /* For a software watchpoint, we must always check the
3920 must_check_value
= 1;
3921 else if (b
->watchpoint_triggered
== watch_triggered_yes
)
3922 /* We have a hardware watchpoint (read, write, or access)
3923 and the target earlier reported an address watched by
3925 must_check_value
= 1;
3926 else if (b
->watchpoint_triggered
== watch_triggered_unknown
3927 && b
->type
== bp_hardware_watchpoint
)
3928 /* We were stopped by a hardware watchpoint, but the target could
3929 not report the data address. We must check the watchpoint's
3930 value. Access and read watchpoints are out of luck; without
3931 a data address, we can't figure it out. */
3932 must_check_value
= 1;
3934 if (must_check_value
)
3937 = xstrprintf ("Error evaluating expression for watchpoint %d\n",
3939 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
3940 int e
= catch_errors (watchpoint_check
, bs
, message
,
3942 do_cleanups (cleanups
);
3946 /* We've already printed what needs to be printed. */
3947 bs
->print_it
= print_it_done
;
3951 bs
->print_it
= print_it_noop
;
3954 case WP_VALUE_CHANGED
:
3955 if (b
->type
== bp_read_watchpoint
)
3957 /* There are two cases to consider here:
3959 1. We're watching the triggered memory for reads.
3960 In that case, trust the target, and always report
3961 the watchpoint hit to the user. Even though
3962 reads don't cause value changes, the value may
3963 have changed since the last time it was read, and
3964 since we're not trapping writes, we will not see
3965 those, and as such we should ignore our notion of
3968 2. We're watching the triggered memory for both
3969 reads and writes. There are two ways this may
3972 2.1. This is a target that can't break on data
3973 reads only, but can break on accesses (reads or
3974 writes), such as e.g., x86. We detect this case
3975 at the time we try to insert read watchpoints.
3977 2.2. Otherwise, the target supports read
3978 watchpoints, but, the user set an access or write
3979 watchpoint watching the same memory as this read
3982 If we're watching memory writes as well as reads,
3983 ignore watchpoint hits when we find that the
3984 value hasn't changed, as reads don't cause
3985 changes. This still gives false positives when
3986 the program writes the same value to memory as
3987 what there was already in memory (we will confuse
3988 it for a read), but it's much better than
3991 int other_write_watchpoint
= 0;
3993 if (bl
->watchpoint_type
== hw_read
)
3995 struct breakpoint
*other_b
;
3997 ALL_BREAKPOINTS (other_b
)
3998 if ((other_b
->type
== bp_hardware_watchpoint
3999 || other_b
->type
== bp_access_watchpoint
)
4000 && (other_b
->watchpoint_triggered
4001 == watch_triggered_yes
))
4003 other_write_watchpoint
= 1;
4008 if (other_write_watchpoint
4009 || bl
->watchpoint_type
== hw_access
)
4011 /* We're watching the same memory for writes,
4012 and the value changed since the last time we
4013 updated it, so this trap must be for a write.
4015 bs
->print_it
= print_it_noop
;
4020 case WP_VALUE_NOT_CHANGED
:
4021 if (b
->type
== bp_hardware_watchpoint
4022 || b
->type
== bp_watchpoint
)
4024 /* Don't stop: write watchpoints shouldn't fire if
4025 the value hasn't changed. */
4026 bs
->print_it
= print_it_noop
;
4034 /* Error from catch_errors. */
4035 printf_filtered (_("Watchpoint %d deleted.\n"), b
->number
);
4036 if (b
->related_breakpoint
)
4037 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
4038 b
->disposition
= disp_del_at_next_stop
;
4039 /* We've already printed what needs to be printed. */
4040 bs
->print_it
= print_it_done
;
4044 else /* must_check_value == 0 */
4046 /* This is a case where some watchpoint(s) triggered, but
4047 not at the address of this watchpoint, or else no
4048 watchpoint triggered after all. So don't print
4049 anything for this watchpoint. */
4050 bs
->print_it
= print_it_noop
;
4057 /* Check conditions (condition proper, frame, thread and ignore count)
4058 of breakpoint referred to by BS. If we should not stop for this
4059 breakpoint, set BS->stop to 0. */
4062 bpstat_check_breakpoint_conditions (bpstat bs
, ptid_t ptid
)
4064 int thread_id
= pid_to_thread_id (ptid
);
4065 const struct bp_location
*bl
;
4066 struct breakpoint
*b
;
4068 /* BS is built for existing struct breakpoint. */
4069 bl
= bs
->bp_location_at
;
4070 gdb_assert (bl
!= NULL
);
4071 b
= bs
->breakpoint_at
;
4072 gdb_assert (b
!= NULL
);
4074 if (frame_id_p (b
->frame_id
)
4075 && !frame_id_eq (b
->frame_id
, get_stack_frame_id (get_current_frame ())))
4079 int value_is_zero
= 0;
4080 struct expression
*cond
;
4082 /* Evaluate Python breakpoints that have a "stop"
4083 method implemented. */
4084 if (b
->py_bp_object
)
4085 bs
->stop
= gdbpy_should_stop (b
->py_bp_object
);
4087 if (is_watchpoint (b
))
4092 if (cond
&& b
->disposition
!= disp_del_at_next_stop
)
4094 int within_current_scope
= 1;
4096 /* We use value_mark and value_free_to_mark because it could
4097 be a long time before we return to the command level and
4098 call free_all_values. We can't call free_all_values
4099 because we might be in the middle of evaluating a
4101 struct value
*mark
= value_mark ();
4103 /* Need to select the frame, with all that implies so that
4104 the conditions will have the right context. Because we
4105 use the frame, we will not see an inlined function's
4106 variables when we arrive at a breakpoint at the start
4107 of the inlined function; the current frame will be the
4109 if (!is_watchpoint (b
) || b
->cond_exp_valid_block
== NULL
)
4110 select_frame (get_current_frame ());
4113 struct frame_info
*frame
;
4115 /* For local watchpoint expressions, which particular
4116 instance of a local is being watched matters, so we
4117 keep track of the frame to evaluate the expression
4118 in. To evaluate the condition however, it doesn't
4119 really matter which instantiation of the function
4120 where the condition makes sense triggers the
4121 watchpoint. This allows an expression like "watch
4122 global if q > 10" set in `func', catch writes to
4123 global on all threads that call `func', or catch
4124 writes on all recursive calls of `func' by a single
4125 thread. We simply always evaluate the condition in
4126 the innermost frame that's executing where it makes
4127 sense to evaluate the condition. It seems
4129 frame
= block_innermost_frame (b
->cond_exp_valid_block
);
4131 select_frame (frame
);
4133 within_current_scope
= 0;
4135 if (within_current_scope
)
4137 = catch_errors (breakpoint_cond_eval
, cond
,
4138 "Error in testing breakpoint condition:\n",
4142 warning (_("Watchpoint condition cannot be tested "
4143 "in the current scope"));
4144 /* If we failed to set the right context for this
4145 watchpoint, unconditionally report it. */
4148 /* FIXME-someday, should give breakpoint #. */
4149 value_free_to_mark (mark
);
4152 if (cond
&& value_is_zero
)
4156 else if (b
->thread
!= -1 && b
->thread
!= thread_id
)
4160 else if (b
->ignore_count
> 0)
4163 annotate_ignore_count_change ();
4165 /* Increase the hit count even though we don't stop. */
4172 /* Get a bpstat associated with having just stopped at address
4173 BP_ADDR in thread PTID.
4175 Determine whether we stopped at a breakpoint, etc, or whether we
4176 don't understand this stop. Result is a chain of bpstat's such
4179 if we don't understand the stop, the result is a null pointer.
4181 if we understand why we stopped, the result is not null.
4183 Each element of the chain refers to a particular breakpoint or
4184 watchpoint at which we have stopped. (We may have stopped for
4185 several reasons concurrently.)
4187 Each element of the chain has valid next, breakpoint_at,
4188 commands, FIXME??? fields. */
4191 bpstat_stop_status (struct address_space
*aspace
,
4192 CORE_ADDR bp_addr
, ptid_t ptid
)
4194 struct breakpoint
*b
= NULL
;
4195 struct bp_location
*bl
;
4196 struct bp_location
*loc
;
4197 /* First item of allocated bpstat's. */
4198 bpstat bs_head
= NULL
, *bs_link
= &bs_head
;
4199 /* Pointer to the last thing in the chain currently. */
4202 int need_remove_insert
;
4205 /* First, build the bpstat chain with locations that explain a
4206 target stop, while being careful to not set the target running,
4207 as that may invalidate locations (in particular watchpoint
4208 locations are recreated). Resuming will happen here with
4209 breakpoint conditions or watchpoint expressions that include
4210 inferior function calls. */
4214 if (!breakpoint_enabled (b
) && b
->enable_state
!= bp_permanent
)
4217 for (bl
= b
->loc
; bl
!= NULL
; bl
= bl
->next
)
4219 /* For hardware watchpoints, we look only at the first
4220 location. The watchpoint_check function will work on the
4221 entire expression, not the individual locations. For
4222 read watchpoints, the watchpoints_triggered function has
4223 checked all locations already. */
4224 if (b
->type
== bp_hardware_watchpoint
&& bl
!= b
->loc
)
4227 if (bl
->shlib_disabled
)
4230 if (!bpstat_check_location (bl
, aspace
, bp_addr
))
4233 /* Come here if it's a watchpoint, or if the break address
4236 bs
= bpstat_alloc (bl
, &bs_link
); /* Alloc a bpstat to
4239 /* Assume we stop. Should we find a watchpoint that is not
4240 actually triggered, or if the condition of the breakpoint
4241 evaluates as false, we'll reset 'stop' to 0. */
4245 /* If this is a scope breakpoint, mark the associated
4246 watchpoint as triggered so that we will handle the
4247 out-of-scope event. We'll get to the watchpoint next
4249 if (b
->type
== bp_watchpoint_scope
)
4250 b
->related_breakpoint
->watchpoint_triggered
= watch_triggered_yes
;
4254 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
4256 if (breakpoint_address_match (loc
->pspace
->aspace
, loc
->address
,
4259 bs
= bpstat_alloc (loc
, &bs_link
);
4260 /* For hits of moribund locations, we should just proceed. */
4263 bs
->print_it
= print_it_noop
;
4267 /* Now go through the locations that caused the target to stop, and
4268 check whether we're interested in reporting this stop to higher
4269 layers, or whether we should resume the target transparently. */
4273 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
4278 bpstat_check_watchpoint (bs
);
4282 b
= bs
->breakpoint_at
;
4284 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
4285 || b
->type
== bp_longjmp_master
4286 || b
->type
== bp_std_terminate_master
4287 || b
->type
== bp_exception_master
)
4288 /* We do not stop for these. */
4291 bpstat_check_breakpoint_conditions (bs
, ptid
);
4297 /* We will stop here. */
4298 if (b
->disposition
== disp_disable
)
4300 if (b
->enable_state
!= bp_permanent
)
4301 b
->enable_state
= bp_disabled
;
4306 bs
->commands
= b
->commands
;
4307 incref_counted_command_line (bs
->commands
);
4308 bs
->commands_left
= bs
->commands
? bs
->commands
->commands
: NULL
;
4309 if (bs
->commands_left
4310 && (strcmp ("silent", bs
->commands_left
->line
) == 0
4313 bs
->commands_left
->line
) == 0)))
4315 bs
->commands_left
= bs
->commands_left
->next
;
4320 /* Print nothing for this entry if we dont stop or dont print. */
4321 if (bs
->stop
== 0 || bs
->print
== 0)
4322 bs
->print_it
= print_it_noop
;
4325 /* If we aren't stopping, the value of some hardware watchpoint may
4326 not have changed, but the intermediate memory locations we are
4327 watching may have. Don't bother if we're stopping; this will get
4329 need_remove_insert
= 0;
4330 if (! bpstat_causes_stop (bs_head
))
4331 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
4333 && bs
->breakpoint_at
4334 && is_hardware_watchpoint (bs
->breakpoint_at
))
4336 update_watchpoint (bs
->breakpoint_at
, 0 /* don't reparse. */);
4337 need_remove_insert
= 1;
4340 if (need_remove_insert
)
4341 update_global_location_list (1);
4342 else if (removed_any
)
4343 update_global_location_list (0);
4349 handle_jit_event (void)
4351 struct frame_info
*frame
;
4352 struct gdbarch
*gdbarch
;
4354 /* Switch terminal for any messages produced by
4355 breakpoint_re_set. */
4356 target_terminal_ours_for_output ();
4358 frame
= get_current_frame ();
4359 gdbarch
= get_frame_arch (frame
);
4361 jit_event_handler (gdbarch
);
4363 target_terminal_inferior ();
4366 /* Prepare WHAT final decision for infrun. */
4368 /* Decide what infrun needs to do with this bpstat. */
4371 bpstat_what (bpstat bs
)
4373 struct bpstat_what retval
;
4374 /* We need to defer calling `solib_add', as adding new symbols
4375 resets breakpoints, which in turn deletes breakpoint locations,
4376 and hence may clear unprocessed entries in the BS chain. */
4377 int shlib_event
= 0;
4380 retval
.main_action
= BPSTAT_WHAT_KEEP_CHECKING
;
4381 retval
.call_dummy
= STOP_NONE
;
4382 retval
.is_longjmp
= 0;
4384 for (; bs
!= NULL
; bs
= bs
->next
)
4386 /* Extract this BS's action. After processing each BS, we check
4387 if its action overrides all we've seem so far. */
4388 enum bpstat_what_main_action this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
4391 if (bs
->breakpoint_at
== NULL
)
4393 /* I suspect this can happen if it was a momentary
4394 breakpoint which has since been deleted. */
4397 else if (bs
->breakpoint_at
== NULL
)
4400 bptype
= bs
->breakpoint_at
->type
;
4407 case bp_hardware_breakpoint
:
4413 this_action
= BPSTAT_WHAT_STOP_NOISY
;
4415 this_action
= BPSTAT_WHAT_STOP_SILENT
;
4418 this_action
= BPSTAT_WHAT_SINGLE
;
4421 case bp_hardware_watchpoint
:
4422 case bp_read_watchpoint
:
4423 case bp_access_watchpoint
:
4427 this_action
= BPSTAT_WHAT_STOP_NOISY
;
4429 this_action
= BPSTAT_WHAT_STOP_SILENT
;
4433 /* There was a watchpoint, but we're not stopping.
4434 This requires no further action. */
4439 this_action
= BPSTAT_WHAT_SET_LONGJMP_RESUME
;
4440 retval
.is_longjmp
= bptype
== bp_longjmp
;
4442 case bp_longjmp_resume
:
4443 case bp_exception_resume
:
4444 this_action
= BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
;
4445 retval
.is_longjmp
= bptype
== bp_longjmp_resume
;
4447 case bp_step_resume
:
4449 this_action
= BPSTAT_WHAT_STEP_RESUME
;
4452 /* It is for the wrong frame. */
4453 this_action
= BPSTAT_WHAT_SINGLE
;
4456 case bp_watchpoint_scope
:
4457 case bp_thread_event
:
4458 case bp_overlay_event
:
4459 case bp_longjmp_master
:
4460 case bp_std_terminate_master
:
4461 case bp_exception_master
:
4462 this_action
= BPSTAT_WHAT_SINGLE
;
4468 this_action
= BPSTAT_WHAT_STOP_NOISY
;
4470 this_action
= BPSTAT_WHAT_STOP_SILENT
;
4474 /* There was a catchpoint, but we're not stopping.
4475 This requires no further action. */
4478 case bp_shlib_event
:
4481 /* If requested, stop when the dynamic linker notifies GDB
4482 of events. This allows the user to get control and place
4483 breakpoints in initializer routines for dynamically
4484 loaded objects (among other things). */
4485 if (stop_on_solib_events
)
4486 this_action
= BPSTAT_WHAT_STOP_NOISY
;
4488 this_action
= BPSTAT_WHAT_SINGLE
;
4492 this_action
= BPSTAT_WHAT_SINGLE
;
4495 /* Make sure the action is stop (silent or noisy),
4496 so infrun.c pops the dummy frame. */
4497 retval
.call_dummy
= STOP_STACK_DUMMY
;
4498 this_action
= BPSTAT_WHAT_STOP_SILENT
;
4500 case bp_std_terminate
:
4501 /* Make sure the action is stop (silent or noisy),
4502 so infrun.c pops the dummy frame. */
4503 retval
.call_dummy
= STOP_STD_TERMINATE
;
4504 this_action
= BPSTAT_WHAT_STOP_SILENT
;
4507 case bp_fast_tracepoint
:
4508 case bp_static_tracepoint
:
4509 /* Tracepoint hits should not be reported back to GDB, and
4510 if one got through somehow, it should have been filtered
4512 internal_error (__FILE__
, __LINE__
,
4513 _("bpstat_what: tracepoint encountered"));
4515 internal_error (__FILE__
, __LINE__
,
4516 _("bpstat_what: unhandled bptype %d"), (int) bptype
);
4519 retval
.main_action
= max (retval
.main_action
, this_action
);
4525 fprintf_unfiltered (gdb_stdlog
, "bpstat_what: bp_shlib_event\n");
4527 /* Check for any newly added shared libraries if we're supposed
4528 to be adding them automatically. */
4530 /* Switch terminal for any messages produced by
4531 breakpoint_re_set. */
4532 target_terminal_ours_for_output ();
4535 SOLIB_ADD (NULL
, 0, ¤t_target
, auto_solib_add
);
4537 solib_add (NULL
, 0, ¤t_target
, auto_solib_add
);
4540 target_terminal_inferior ();
4546 fprintf_unfiltered (gdb_stdlog
, "bpstat_what: bp_jit_event\n");
4548 handle_jit_event ();
4554 /* Nonzero if we should step constantly (e.g. watchpoints on machines
4555 without hardware support). This isn't related to a specific bpstat,
4556 just to things like whether watchpoints are set. */
4559 bpstat_should_step (void)
4561 struct breakpoint
*b
;
4564 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
&& b
->loc
!= NULL
)
4570 bpstat_causes_stop (bpstat bs
)
4572 for (; bs
!= NULL
; bs
= bs
->next
)
4581 /* Compute a string of spaces suitable to indent the next line
4582 so it starts at the position corresponding to the table column
4583 named COL_NAME in the currently active table of UIOUT. */
4586 wrap_indent_at_field (struct ui_out
*uiout
, const char *col_name
)
4588 static char wrap_indent
[80];
4589 int i
, total_width
, width
, align
;
4593 for (i
= 1; ui_out_query_field (uiout
, i
, &width
, &align
, &text
); i
++)
4595 if (strcmp (text
, col_name
) == 0)
4597 gdb_assert (total_width
< sizeof wrap_indent
);
4598 memset (wrap_indent
, ' ', total_width
);
4599 wrap_indent
[total_width
] = 0;
4604 total_width
+= width
+ 1;
4610 /* Print the LOC location out of the list of B->LOC locations. */
4613 print_breakpoint_location (struct breakpoint
*b
,
4614 struct bp_location
*loc
)
4616 struct cleanup
*old_chain
= save_current_program_space ();
4618 if (loc
!= NULL
&& loc
->shlib_disabled
)
4622 set_current_program_space (loc
->pspace
);
4624 if (b
->source_file
&& loc
)
4627 = find_pc_sect_function (loc
->address
, loc
->section
);
4630 ui_out_text (uiout
, "in ");
4631 ui_out_field_string (uiout
, "func",
4632 SYMBOL_PRINT_NAME (sym
));
4633 ui_out_text (uiout
, " ");
4634 ui_out_wrap_hint (uiout
, wrap_indent_at_field (uiout
, "what"));
4635 ui_out_text (uiout
, "at ");
4637 ui_out_field_string (uiout
, "file", b
->source_file
);
4638 ui_out_text (uiout
, ":");
4640 if (ui_out_is_mi_like_p (uiout
))
4642 struct symtab_and_line sal
= find_pc_line (loc
->address
, 0);
4643 char *fullname
= symtab_to_fullname (sal
.symtab
);
4646 ui_out_field_string (uiout
, "fullname", fullname
);
4649 ui_out_field_int (uiout
, "line", b
->line_number
);
4653 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
4654 struct cleanup
*stb_chain
= make_cleanup_ui_out_stream_delete (stb
);
4656 print_address_symbolic (loc
->gdbarch
, loc
->address
, stb
->stream
,
4658 ui_out_field_stream (uiout
, "at", stb
);
4660 do_cleanups (stb_chain
);
4663 ui_out_field_string (uiout
, "pending", b
->addr_string
);
4665 do_cleanups (old_chain
);
4669 bptype_string (enum bptype type
)
4671 struct ep_type_description
4676 static struct ep_type_description bptypes
[] =
4678 {bp_none
, "?deleted?"},
4679 {bp_breakpoint
, "breakpoint"},
4680 {bp_hardware_breakpoint
, "hw breakpoint"},
4681 {bp_until
, "until"},
4682 {bp_finish
, "finish"},
4683 {bp_watchpoint
, "watchpoint"},
4684 {bp_hardware_watchpoint
, "hw watchpoint"},
4685 {bp_read_watchpoint
, "read watchpoint"},
4686 {bp_access_watchpoint
, "acc watchpoint"},
4687 {bp_longjmp
, "longjmp"},
4688 {bp_longjmp_resume
, "longjmp resume"},
4689 {bp_exception
, "exception"},
4690 {bp_exception_resume
, "exception resume"},
4691 {bp_step_resume
, "step resume"},
4692 {bp_watchpoint_scope
, "watchpoint scope"},
4693 {bp_call_dummy
, "call dummy"},
4694 {bp_std_terminate
, "std::terminate"},
4695 {bp_shlib_event
, "shlib events"},
4696 {bp_thread_event
, "thread events"},
4697 {bp_overlay_event
, "overlay events"},
4698 {bp_longjmp_master
, "longjmp master"},
4699 {bp_std_terminate_master
, "std::terminate master"},
4700 {bp_exception_master
, "exception master"},
4701 {bp_catchpoint
, "catchpoint"},
4702 {bp_tracepoint
, "tracepoint"},
4703 {bp_fast_tracepoint
, "fast tracepoint"},
4704 {bp_static_tracepoint
, "static tracepoint"},
4705 {bp_jit_event
, "jit events"},
4708 if (((int) type
>= (sizeof (bptypes
) / sizeof (bptypes
[0])))
4709 || ((int) type
!= bptypes
[(int) type
].type
))
4710 internal_error (__FILE__
, __LINE__
,
4711 _("bptypes table does not describe type #%d."),
4714 return bptypes
[(int) type
].description
;
4717 /* Print B to gdb_stdout. */
4720 print_one_breakpoint_location (struct breakpoint
*b
,
4721 struct bp_location
*loc
,
4723 struct bp_location
**last_loc
,
4726 struct command_line
*l
;
4727 static char bpenables
[] = "nynny";
4728 struct cleanup
*bkpt_chain
;
4730 int header_of_multiple
= 0;
4731 int part_of_multiple
= (loc
!= NULL
);
4732 struct value_print_options opts
;
4734 get_user_print_options (&opts
);
4736 gdb_assert (!loc
|| loc_number
!= 0);
4737 /* See comment in print_one_breakpoint concerning treatment of
4738 breakpoints with single disabled location. */
4741 && (b
->loc
->next
!= NULL
|| !b
->loc
->enabled
)))
4742 header_of_multiple
= 1;
4747 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "bkpt");
4751 if (part_of_multiple
)
4754 formatted
= xstrprintf ("%d.%d", b
->number
, loc_number
);
4755 ui_out_field_string (uiout
, "number", formatted
);
4760 ui_out_field_int (uiout
, "number", b
->number
);
4765 if (part_of_multiple
)
4766 ui_out_field_skip (uiout
, "type");
4768 ui_out_field_string (uiout
, "type", bptype_string (b
->type
));
4772 if (part_of_multiple
)
4773 ui_out_field_skip (uiout
, "disp");
4775 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
4780 if (part_of_multiple
)
4781 ui_out_field_string (uiout
, "enabled", loc
->enabled
? "y" : "n");
4783 ui_out_field_fmt (uiout
, "enabled", "%c",
4784 bpenables
[(int) b
->enable_state
]);
4785 ui_out_spaces (uiout
, 2);
4789 if (b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
4791 /* Although the print_one can possibly print all locations,
4792 calling it here is not likely to get any nice result. So,
4793 make sure there's just one location. */
4794 gdb_assert (b
->loc
== NULL
|| b
->loc
->next
== NULL
);
4795 b
->ops
->print_one (b
, last_loc
);
4801 internal_error (__FILE__
, __LINE__
,
4802 _("print_one_breakpoint: bp_none encountered\n"));
4806 case bp_hardware_watchpoint
:
4807 case bp_read_watchpoint
:
4808 case bp_access_watchpoint
:
4809 /* Field 4, the address, is omitted (which makes the columns
4810 not line up too nicely with the headers, but the effect
4811 is relatively readable). */
4812 if (opts
.addressprint
)
4813 ui_out_field_skip (uiout
, "addr");
4815 ui_out_field_string (uiout
, "what", b
->exp_string
);
4819 case bp_hardware_breakpoint
:
4823 case bp_longjmp_resume
:
4825 case bp_exception_resume
:
4826 case bp_step_resume
:
4827 case bp_watchpoint_scope
:
4829 case bp_std_terminate
:
4830 case bp_shlib_event
:
4831 case bp_thread_event
:
4832 case bp_overlay_event
:
4833 case bp_longjmp_master
:
4834 case bp_std_terminate_master
:
4835 case bp_exception_master
:
4837 case bp_fast_tracepoint
:
4838 case bp_static_tracepoint
:
4840 if (opts
.addressprint
)
4843 if (header_of_multiple
)
4844 ui_out_field_string (uiout
, "addr", "<MULTIPLE>");
4845 else if (b
->loc
== NULL
|| loc
->shlib_disabled
)
4846 ui_out_field_string (uiout
, "addr", "<PENDING>");
4848 ui_out_field_core_addr (uiout
, "addr",
4849 loc
->gdbarch
, loc
->address
);
4852 if (!header_of_multiple
)
4853 print_breakpoint_location (b
, loc
);
4860 /* For backward compatibility, don't display inferiors unless there
4863 && !header_of_multiple
4865 || (!gdbarch_has_global_breakpoints (target_gdbarch
)
4866 && (number_of_program_spaces () > 1
4867 || number_of_inferiors () > 1)
4868 /* LOC is for existing B, it cannot be in
4869 moribund_locations and thus having NULL OWNER. */
4870 && loc
->owner
->type
!= bp_catchpoint
)))
4872 struct inferior
*inf
;
4875 for (inf
= inferior_list
; inf
!= NULL
; inf
= inf
->next
)
4877 if (inf
->pspace
== loc
->pspace
)
4882 ui_out_text (uiout
, " inf ");
4885 ui_out_text (uiout
, ", ");
4886 ui_out_text (uiout
, plongest (inf
->num
));
4891 if (!part_of_multiple
)
4893 if (b
->thread
!= -1)
4895 /* FIXME: This seems to be redundant and lost here; see the
4896 "stop only in" line a little further down. */
4897 ui_out_text (uiout
, " thread ");
4898 ui_out_field_int (uiout
, "thread", b
->thread
);
4900 else if (b
->task
!= 0)
4902 ui_out_text (uiout
, " task ");
4903 ui_out_field_int (uiout
, "task", b
->task
);
4907 ui_out_text (uiout
, "\n");
4909 if (!part_of_multiple
&& b
->static_trace_marker_id
)
4911 gdb_assert (b
->type
== bp_static_tracepoint
);
4913 ui_out_text (uiout
, "\tmarker id is ");
4914 ui_out_field_string (uiout
, "static-tracepoint-marker-string-id",
4915 b
->static_trace_marker_id
);
4916 ui_out_text (uiout
, "\n");
4919 if (part_of_multiple
&& frame_id_p (b
->frame_id
))
4922 ui_out_text (uiout
, "\tstop only in stack frame at ");
4923 /* FIXME: cagney/2002-12-01: Shouldn't be poeking around inside
4925 ui_out_field_core_addr (uiout
, "frame",
4926 b
->gdbarch
, b
->frame_id
.stack_addr
);
4927 ui_out_text (uiout
, "\n");
4930 if (!part_of_multiple
&& b
->cond_string
&& !ada_exception_catchpoint_p (b
))
4932 /* We do not print the condition for Ada exception catchpoints
4933 because the condition is an internal implementation detail
4934 that we do not want to expose to the user. */
4936 if (is_tracepoint (b
))
4937 ui_out_text (uiout
, "\ttrace only if ");
4939 ui_out_text (uiout
, "\tstop only if ");
4940 ui_out_field_string (uiout
, "cond", b
->cond_string
);
4941 ui_out_text (uiout
, "\n");
4944 if (!part_of_multiple
&& b
->thread
!= -1)
4946 /* FIXME should make an annotation for this. */
4947 ui_out_text (uiout
, "\tstop only in thread ");
4948 ui_out_field_int (uiout
, "thread", b
->thread
);
4949 ui_out_text (uiout
, "\n");
4952 if (!part_of_multiple
&& b
->hit_count
)
4954 /* FIXME should make an annotation for this. */
4955 if (ep_is_catchpoint (b
))
4956 ui_out_text (uiout
, "\tcatchpoint");
4958 ui_out_text (uiout
, "\tbreakpoint");
4959 ui_out_text (uiout
, " already hit ");
4960 ui_out_field_int (uiout
, "times", b
->hit_count
);
4961 if (b
->hit_count
== 1)
4962 ui_out_text (uiout
, " time\n");
4964 ui_out_text (uiout
, " times\n");
4967 /* Output the count also if it is zero, but only if this is mi.
4968 FIXME: Should have a better test for this. */
4969 if (ui_out_is_mi_like_p (uiout
))
4970 if (!part_of_multiple
&& b
->hit_count
== 0)
4971 ui_out_field_int (uiout
, "times", b
->hit_count
);
4973 if (!part_of_multiple
&& b
->ignore_count
)
4976 ui_out_text (uiout
, "\tignore next ");
4977 ui_out_field_int (uiout
, "ignore", b
->ignore_count
);
4978 ui_out_text (uiout
, " hits\n");
4981 l
= b
->commands
? b
->commands
->commands
: NULL
;
4982 if (!part_of_multiple
&& l
)
4984 struct cleanup
*script_chain
;
4987 script_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "script");
4988 print_command_lines (uiout
, l
, 4);
4989 do_cleanups (script_chain
);
4992 if (!part_of_multiple
&& b
->pass_count
)
4994 annotate_field (10);
4995 ui_out_text (uiout
, "\tpass count ");
4996 ui_out_field_int (uiout
, "pass", b
->pass_count
);
4997 ui_out_text (uiout
, " \n");
5000 if (ui_out_is_mi_like_p (uiout
) && !part_of_multiple
)
5003 ui_out_field_string (uiout
, "original-location", b
->addr_string
);
5004 else if (b
->exp_string
)
5005 ui_out_field_string (uiout
, "original-location", b
->exp_string
);
5008 do_cleanups (bkpt_chain
);
5012 print_one_breakpoint (struct breakpoint
*b
,
5013 struct bp_location
**last_loc
,
5016 print_one_breakpoint_location (b
, NULL
, 0, last_loc
, allflag
);
5018 /* If this breakpoint has custom print function,
5019 it's already printed. Otherwise, print individual
5020 locations, if any. */
5021 if (b
->ops
== NULL
|| b
->ops
->print_one
== NULL
)
5023 /* If breakpoint has a single location that is disabled, we
5024 print it as if it had several locations, since otherwise it's
5025 hard to represent "breakpoint enabled, location disabled"
5028 Note that while hardware watchpoints have several locations
5029 internally, that's not a property exposed to user. */
5031 && !is_hardware_watchpoint (b
)
5032 && (b
->loc
->next
|| !b
->loc
->enabled
)
5033 && !ui_out_is_mi_like_p (uiout
))
5035 struct bp_location
*loc
;
5037 for (loc
= b
->loc
; loc
; loc
= loc
->next
, ++n
)
5038 print_one_breakpoint_location (b
, loc
, n
, last_loc
, allflag
);
5044 breakpoint_address_bits (struct breakpoint
*b
)
5046 int print_address_bits
= 0;
5047 struct bp_location
*loc
;
5049 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
5053 /* Software watchpoints that aren't watching memory don't have
5054 an address to print. */
5055 if (b
->type
== bp_watchpoint
&& loc
->watchpoint_type
== -1)
5058 addr_bit
= gdbarch_addr_bit (loc
->gdbarch
);
5059 if (addr_bit
> print_address_bits
)
5060 print_address_bits
= addr_bit
;
5063 return print_address_bits
;
5066 struct captured_breakpoint_query_args
5072 do_captured_breakpoint_query (struct ui_out
*uiout
, void *data
)
5074 struct captured_breakpoint_query_args
*args
= data
;
5075 struct breakpoint
*b
;
5076 struct bp_location
*dummy_loc
= NULL
;
5080 if (args
->bnum
== b
->number
)
5082 print_one_breakpoint (b
, &dummy_loc
, 0);
5090 gdb_breakpoint_query (struct ui_out
*uiout
, int bnum
,
5091 char **error_message
)
5093 struct captured_breakpoint_query_args args
;
5096 /* For the moment we don't trust print_one_breakpoint() to not throw
5098 if (catch_exceptions_with_msg (uiout
, do_captured_breakpoint_query
, &args
,
5099 error_message
, RETURN_MASK_ALL
) < 0)
5105 /* Return non-zero if B is user settable (breakpoints, watchpoints,
5106 catchpoints, et.al.). */
5109 user_settable_breakpoint (const struct breakpoint
*b
)
5111 return (b
->type
== bp_breakpoint
5112 || b
->type
== bp_catchpoint
5113 || b
->type
== bp_hardware_breakpoint
5114 || is_tracepoint (b
)
5115 || is_watchpoint (b
));
5118 /* Return true if this breakpoint was set by the user, false if it is
5119 internal or momentary. */
5122 user_breakpoint_p (struct breakpoint
*b
)
5124 return user_settable_breakpoint (b
) && b
->number
> 0;
5127 /* Print information on user settable breakpoint (watchpoint, etc)
5128 number BNUM. If BNUM is -1 print all user-settable breakpoints.
5129 If ALLFLAG is non-zero, include non-user-settable breakpoints. If
5130 FILTER is non-NULL, call it on each breakpoint and only include the
5131 ones for which it returns non-zero. Return the total number of
5132 breakpoints listed. */
5135 breakpoint_1 (char *args
, int allflag
,
5136 int (*filter
) (const struct breakpoint
*))
5138 struct breakpoint
*b
;
5139 struct bp_location
*last_loc
= NULL
;
5140 int nr_printable_breakpoints
;
5141 struct cleanup
*bkpttbl_chain
;
5142 struct value_print_options opts
;
5143 int print_address_bits
= 0;
5144 int print_type_col_width
= 14;
5146 get_user_print_options (&opts
);
5148 /* Compute the number of rows in the table, as well as the size
5149 required for address fields. */
5150 nr_printable_breakpoints
= 0;
5153 /* If we have a filter, only list the breakpoints it accepts. */
5154 if (filter
&& !filter (b
))
5157 /* If we have an "args" string, it is a list of breakpoints to
5158 accept. Skip the others. */
5159 if (args
!= NULL
&& *args
!= '\0')
5161 if (allflag
&& parse_and_eval_long (args
) != b
->number
)
5163 if (!allflag
&& !number_is_in_list (args
, b
->number
))
5167 if (allflag
|| user_breakpoint_p (b
))
5169 int addr_bit
, type_len
;
5171 addr_bit
= breakpoint_address_bits (b
);
5172 if (addr_bit
> print_address_bits
)
5173 print_address_bits
= addr_bit
;
5175 type_len
= strlen (bptype_string (b
->type
));
5176 if (type_len
> print_type_col_width
)
5177 print_type_col_width
= type_len
;
5179 nr_printable_breakpoints
++;
5183 if (opts
.addressprint
)
5185 = make_cleanup_ui_out_table_begin_end (uiout
, 6,
5186 nr_printable_breakpoints
,
5190 = make_cleanup_ui_out_table_begin_end (uiout
, 5,
5191 nr_printable_breakpoints
,
5194 if (nr_printable_breakpoints
> 0)
5195 annotate_breakpoints_headers ();
5196 if (nr_printable_breakpoints
> 0)
5198 ui_out_table_header (uiout
, 7, ui_left
, "number", "Num"); /* 1 */
5199 if (nr_printable_breakpoints
> 0)
5201 ui_out_table_header (uiout
, print_type_col_width
, ui_left
,
5202 "type", "Type"); /* 2 */
5203 if (nr_printable_breakpoints
> 0)
5205 ui_out_table_header (uiout
, 4, ui_left
, "disp", "Disp"); /* 3 */
5206 if (nr_printable_breakpoints
> 0)
5208 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb"); /* 4 */
5209 if (opts
.addressprint
)
5211 if (nr_printable_breakpoints
> 0)
5213 if (print_address_bits
<= 32)
5214 ui_out_table_header (uiout
, 10, ui_left
,
5215 "addr", "Address"); /* 5 */
5217 ui_out_table_header (uiout
, 18, ui_left
,
5218 "addr", "Address"); /* 5 */
5220 if (nr_printable_breakpoints
> 0)
5222 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What"); /* 6 */
5223 ui_out_table_body (uiout
);
5224 if (nr_printable_breakpoints
> 0)
5225 annotate_breakpoints_table ();
5230 /* If we have a filter, only list the breakpoints it accepts. */
5231 if (filter
&& !filter (b
))
5234 /* If we have an "args" string, it is a list of breakpoints to
5235 accept. Skip the others. */
5237 if (args
!= NULL
&& *args
!= '\0')
5239 if (allflag
) /* maintenance info breakpoint */
5241 if (parse_and_eval_long (args
) != b
->number
)
5244 else /* all others */
5246 if (!number_is_in_list (args
, b
->number
))
5250 /* We only print out user settable breakpoints unless the
5252 if (allflag
|| user_breakpoint_p (b
))
5253 print_one_breakpoint (b
, &last_loc
, allflag
);
5256 do_cleanups (bkpttbl_chain
);
5258 if (nr_printable_breakpoints
== 0)
5260 /* If there's a filter, let the caller decide how to report
5264 if (args
== NULL
|| *args
== '\0')
5265 ui_out_message (uiout
, 0, "No breakpoints or watchpoints.\n");
5267 ui_out_message (uiout
, 0,
5268 "No breakpoint or watchpoint matching '%s'.\n",
5274 if (last_loc
&& !server_command
)
5275 set_next_address (last_loc
->gdbarch
, last_loc
->address
);
5278 /* FIXME? Should this be moved up so that it is only called when
5279 there have been breakpoints? */
5280 annotate_breakpoints_table_end ();
5282 return nr_printable_breakpoints
;
5285 /* Display the value of default-collect in a way that is generally
5286 compatible with the breakpoint list. */
5289 default_collect_info (void)
5291 /* If it has no value (which is frequently the case), say nothing; a
5292 message like "No default-collect." gets in user's face when it's
5294 if (!*default_collect
)
5297 /* The following phrase lines up nicely with per-tracepoint collect
5299 ui_out_text (uiout
, "default collect ");
5300 ui_out_field_string (uiout
, "default-collect", default_collect
);
5301 ui_out_text (uiout
, " \n");
5305 breakpoints_info (char *args
, int from_tty
)
5307 breakpoint_1 (args
, 0, NULL
);
5309 default_collect_info ();
5313 watchpoints_info (char *args
, int from_tty
)
5315 int num_printed
= breakpoint_1 (args
, 0, is_watchpoint
);
5317 if (num_printed
== 0)
5319 if (args
== NULL
|| *args
== '\0')
5320 ui_out_message (uiout
, 0, "No watchpoints.\n");
5322 ui_out_message (uiout
, 0, "No watchpoint matching '%s'.\n", args
);
5327 maintenance_info_breakpoints (char *args
, int from_tty
)
5329 breakpoint_1 (args
, 1, NULL
);
5331 default_collect_info ();
5335 breakpoint_has_pc (struct breakpoint
*b
,
5336 struct program_space
*pspace
,
5337 CORE_ADDR pc
, struct obj_section
*section
)
5339 struct bp_location
*bl
= b
->loc
;
5341 for (; bl
; bl
= bl
->next
)
5343 if (bl
->pspace
== pspace
5344 && bl
->address
== pc
5345 && (!overlay_debugging
|| bl
->section
== section
))
5351 /* Print a message describing any breakpoints set at PC. This
5352 concerns with logical breakpoints, so we match program spaces, not
5356 describe_other_breakpoints (struct gdbarch
*gdbarch
,
5357 struct program_space
*pspace
, CORE_ADDR pc
,
5358 struct obj_section
*section
, int thread
)
5361 struct breakpoint
*b
;
5364 others
+= breakpoint_has_pc (b
, pspace
, pc
, section
);
5368 printf_filtered (_("Note: breakpoint "));
5369 else /* if (others == ???) */
5370 printf_filtered (_("Note: breakpoints "));
5372 if (breakpoint_has_pc (b
, pspace
, pc
, section
))
5375 printf_filtered ("%d", b
->number
);
5376 if (b
->thread
== -1 && thread
!= -1)
5377 printf_filtered (" (all threads)");
5378 else if (b
->thread
!= -1)
5379 printf_filtered (" (thread %d)", b
->thread
);
5380 printf_filtered ("%s%s ",
5381 ((b
->enable_state
== bp_disabled
5382 || b
->enable_state
== bp_call_disabled
5383 || b
->enable_state
== bp_startup_disabled
)
5385 : b
->enable_state
== bp_permanent
5389 : ((others
== 1) ? " and" : ""));
5391 printf_filtered (_("also set at pc "));
5392 fputs_filtered (paddress (gdbarch
, pc
), gdb_stdout
);
5393 printf_filtered (".\n");
5397 /* Set the default place to put a breakpoint
5398 for the `break' command with no arguments. */
5401 set_default_breakpoint (int valid
, struct program_space
*pspace
,
5402 CORE_ADDR addr
, struct symtab
*symtab
,
5405 default_breakpoint_valid
= valid
;
5406 default_breakpoint_pspace
= pspace
;
5407 default_breakpoint_address
= addr
;
5408 default_breakpoint_symtab
= symtab
;
5409 default_breakpoint_line
= line
;
5412 /* Return true iff it is meaningful to use the address member of
5413 BPT. For some breakpoint types, the address member is irrelevant
5414 and it makes no sense to attempt to compare it to other addresses
5415 (or use it for any other purpose either).
5417 More specifically, each of the following breakpoint types will
5418 always have a zero valued address and we don't want to mark
5419 breakpoints of any of these types to be a duplicate of an actual
5420 breakpoint at address zero:
5428 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
5430 enum bptype type
= bpt
->type
;
5432 return (type
!= bp_watchpoint
&& type
!= bp_catchpoint
);
5435 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
5436 true if LOC1 and LOC2 represent the same watchpoint location. */
5439 watchpoint_locations_match (struct bp_location
*loc1
,
5440 struct bp_location
*loc2
)
5442 /* Both of them must not be in moribund_locations. */
5443 gdb_assert (loc1
->owner
!= NULL
);
5444 gdb_assert (loc2
->owner
!= NULL
);
5446 /* If the target can evaluate the condition expression in hardware,
5447 then we we need to insert both watchpoints even if they are at
5448 the same place. Otherwise the watchpoint will only trigger when
5449 the condition of whichever watchpoint was inserted evaluates to
5450 true, not giving a chance for GDB to check the condition of the
5451 other watchpoint. */
5452 if ((loc1
->owner
->cond_exp
5453 && target_can_accel_watchpoint_condition (loc1
->address
,
5455 loc1
->watchpoint_type
,
5456 loc1
->owner
->cond_exp
))
5457 || (loc2
->owner
->cond_exp
5458 && target_can_accel_watchpoint_condition (loc2
->address
,
5460 loc2
->watchpoint_type
,
5461 loc2
->owner
->cond_exp
)))
5464 /* Note that this checks the owner's type, not the location's. In
5465 case the target does not support read watchpoints, but does
5466 support access watchpoints, we'll have bp_read_watchpoint
5467 watchpoints with hw_access locations. Those should be considered
5468 duplicates of hw_read locations. The hw_read locations will
5469 become hw_access locations later. */
5470 return (loc1
->owner
->type
== loc2
->owner
->type
5471 && loc1
->pspace
->aspace
== loc2
->pspace
->aspace
5472 && loc1
->address
== loc2
->address
5473 && loc1
->length
== loc2
->length
);
5476 /* Returns true if {ASPACE1,ADDR1} and {ASPACE2,ADDR2} represent the
5477 same breakpoint location. In most targets, this can only be true
5478 if ASPACE1 matches ASPACE2. On targets that have global
5479 breakpoints, the address space doesn't really matter. */
5482 breakpoint_address_match (struct address_space
*aspace1
, CORE_ADDR addr1
,
5483 struct address_space
*aspace2
, CORE_ADDR addr2
)
5485 return ((gdbarch_has_global_breakpoints (target_gdbarch
)
5486 || aspace1
== aspace2
)
5490 /* Assuming LOC1 and LOC2's types' have meaningful target addresses
5491 (breakpoint_address_is_meaningful), returns true if LOC1 and LOC2
5492 represent the same location. */
5495 breakpoint_locations_match (struct bp_location
*loc1
,
5496 struct bp_location
*loc2
)
5498 int hw_point1
, hw_point2
;
5500 /* Both of them must not be in moribund_locations. */
5501 gdb_assert (loc1
->owner
!= NULL
);
5502 gdb_assert (loc2
->owner
!= NULL
);
5504 hw_point1
= is_hardware_watchpoint (loc1
->owner
);
5505 hw_point2
= is_hardware_watchpoint (loc2
->owner
);
5507 if (hw_point1
!= hw_point2
)
5510 return watchpoint_locations_match (loc1
, loc2
);
5512 return breakpoint_address_match (loc1
->pspace
->aspace
, loc1
->address
,
5513 loc2
->pspace
->aspace
, loc2
->address
);
5517 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
5518 int bnum
, int have_bnum
)
5520 /* The longest string possibly returned by hex_string_custom
5521 is 50 chars. These must be at least that big for safety. */
5525 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
5526 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
5528 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
5529 bnum
, astr1
, astr2
);
5531 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
5534 /* Adjust a breakpoint's address to account for architectural
5535 constraints on breakpoint placement. Return the adjusted address.
5536 Note: Very few targets require this kind of adjustment. For most
5537 targets, this function is simply the identity function. */
5540 adjust_breakpoint_address (struct gdbarch
*gdbarch
,
5541 CORE_ADDR bpaddr
, enum bptype bptype
)
5543 if (!gdbarch_adjust_breakpoint_address_p (gdbarch
))
5545 /* Very few targets need any kind of breakpoint adjustment. */
5548 else if (bptype
== bp_watchpoint
5549 || bptype
== bp_hardware_watchpoint
5550 || bptype
== bp_read_watchpoint
5551 || bptype
== bp_access_watchpoint
5552 || bptype
== bp_catchpoint
)
5554 /* Watchpoints and the various bp_catch_* eventpoints should not
5555 have their addresses modified. */
5560 CORE_ADDR adjusted_bpaddr
;
5562 /* Some targets have architectural constraints on the placement
5563 of breakpoint instructions. Obtain the adjusted address. */
5564 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (gdbarch
, bpaddr
);
5566 /* An adjusted breakpoint address can significantly alter
5567 a user's expectations. Print a warning if an adjustment
5569 if (adjusted_bpaddr
!= bpaddr
)
5570 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
5572 return adjusted_bpaddr
;
5576 /* Allocate a struct bp_location. */
5578 static struct bp_location
*
5579 allocate_bp_location (struct breakpoint
*bpt
)
5581 struct bp_location
*loc
;
5583 loc
= xmalloc (sizeof (struct bp_location
));
5584 memset (loc
, 0, sizeof (*loc
));
5588 loc
->shlib_disabled
= 0;
5597 case bp_longjmp_resume
:
5599 case bp_exception_resume
:
5600 case bp_step_resume
:
5601 case bp_watchpoint_scope
:
5603 case bp_std_terminate
:
5604 case bp_shlib_event
:
5605 case bp_thread_event
:
5606 case bp_overlay_event
:
5608 case bp_longjmp_master
:
5609 case bp_std_terminate_master
:
5610 case bp_exception_master
:
5611 loc
->loc_type
= bp_loc_software_breakpoint
;
5613 case bp_hardware_breakpoint
:
5614 loc
->loc_type
= bp_loc_hardware_breakpoint
;
5616 case bp_hardware_watchpoint
:
5617 case bp_read_watchpoint
:
5618 case bp_access_watchpoint
:
5619 loc
->loc_type
= bp_loc_hardware_watchpoint
;
5624 case bp_fast_tracepoint
:
5625 case bp_static_tracepoint
:
5626 loc
->loc_type
= bp_loc_other
;
5629 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
5637 free_bp_location (struct bp_location
*loc
)
5642 if (loc
->function_name
)
5643 xfree (loc
->function_name
);
5648 /* Increment reference count. */
5651 incref_bp_location (struct bp_location
*bl
)
5656 /* Decrement reference count. If the reference count reaches 0,
5657 destroy the bp_location. Sets *BLP to NULL. */
5660 decref_bp_location (struct bp_location
**blp
)
5662 gdb_assert ((*blp
)->refc
> 0);
5664 if (--(*blp
)->refc
== 0)
5665 free_bp_location (*blp
);
5669 /* Helper to set_raw_breakpoint below. Creates a breakpoint that has
5670 type BPTYPE and has no locations as yet. */
5671 /* This function is used in gdbtk sources and thus can not be made
5674 static struct breakpoint
*
5675 set_raw_breakpoint_without_location (struct gdbarch
*gdbarch
,
5678 struct breakpoint
*b
, *b1
;
5680 b
= (struct breakpoint
*) xmalloc (sizeof (struct breakpoint
));
5681 memset (b
, 0, sizeof (*b
));
5684 b
->gdbarch
= gdbarch
;
5685 b
->language
= current_language
->la_language
;
5686 b
->input_radix
= input_radix
;
5688 b
->enable_state
= bp_enabled
;
5691 b
->ignore_count
= 0;
5693 b
->frame_id
= null_frame_id
;
5694 b
->forked_inferior_pid
= null_ptid
;
5695 b
->exec_pathname
= NULL
;
5696 b
->syscalls_to_be_caught
= NULL
;
5698 b
->condition_not_parsed
= 0;
5699 b
->py_bp_object
= NULL
;
5701 /* Add this breakpoint to the end of the chain so that a list of
5702 breakpoints will come out in order of increasing numbers. */
5704 b1
= breakpoint_chain
;
5706 breakpoint_chain
= b
;
5716 /* Initialize loc->function_name. */
5718 set_breakpoint_location_function (struct bp_location
*loc
)
5720 gdb_assert (loc
->owner
!= NULL
);
5722 if (loc
->owner
->type
== bp_breakpoint
5723 || loc
->owner
->type
== bp_hardware_breakpoint
5724 || is_tracepoint (loc
->owner
))
5726 find_pc_partial_function (loc
->address
, &(loc
->function_name
),
5728 if (loc
->function_name
)
5729 loc
->function_name
= xstrdup (loc
->function_name
);
5733 /* Attempt to determine architecture of location identified by SAL. */
5734 static struct gdbarch
*
5735 get_sal_arch (struct symtab_and_line sal
)
5738 return get_objfile_arch (sal
.section
->objfile
);
5740 return get_objfile_arch (sal
.symtab
->objfile
);
5745 /* set_raw_breakpoint is a low level routine for allocating and
5746 partially initializing a breakpoint of type BPTYPE. The newly
5747 created breakpoint's address, section, source file name, and line
5748 number are provided by SAL. The newly created and partially
5749 initialized breakpoint is added to the breakpoint chain and
5750 is also returned as the value of this function.
5752 It is expected that the caller will complete the initialization of
5753 the newly created breakpoint struct as well as output any status
5754 information regarding the creation of a new breakpoint. In
5755 particular, set_raw_breakpoint does NOT set the breakpoint
5756 number! Care should be taken to not allow an error to occur
5757 prior to completing the initialization of the breakpoint. If this
5758 should happen, a bogus breakpoint will be left on the chain. */
5761 set_raw_breakpoint (struct gdbarch
*gdbarch
,
5762 struct symtab_and_line sal
, enum bptype bptype
)
5764 struct breakpoint
*b
= set_raw_breakpoint_without_location (gdbarch
,
5766 CORE_ADDR adjusted_address
;
5767 struct gdbarch
*loc_gdbarch
;
5769 loc_gdbarch
= get_sal_arch (sal
);
5771 loc_gdbarch
= b
->gdbarch
;
5773 if (bptype
!= bp_catchpoint
)
5774 gdb_assert (sal
.pspace
!= NULL
);
5776 /* Adjust the breakpoint's address prior to allocating a location.
5777 Once we call allocate_bp_location(), that mostly uninitialized
5778 location will be placed on the location chain. Adjustment of the
5779 breakpoint may cause target_read_memory() to be called and we do
5780 not want its scan of the location chain to find a breakpoint and
5781 location that's only been partially initialized. */
5782 adjusted_address
= adjust_breakpoint_address (loc_gdbarch
,
5785 b
->loc
= allocate_bp_location (b
);
5786 b
->loc
->gdbarch
= loc_gdbarch
;
5787 b
->loc
->requested_address
= sal
.pc
;
5788 b
->loc
->address
= adjusted_address
;
5789 b
->loc
->pspace
= sal
.pspace
;
5791 /* Store the program space that was used to set the breakpoint, for
5792 breakpoint resetting. */
5793 b
->pspace
= sal
.pspace
;
5795 if (sal
.symtab
== NULL
)
5796 b
->source_file
= NULL
;
5798 b
->source_file
= xstrdup (sal
.symtab
->filename
);
5799 b
->loc
->section
= sal
.section
;
5800 b
->line_number
= sal
.line
;
5802 set_breakpoint_location_function (b
->loc
);
5804 breakpoints_changed ();
5810 /* Note that the breakpoint object B describes a permanent breakpoint
5811 instruction, hard-wired into the inferior's code. */
5813 make_breakpoint_permanent (struct breakpoint
*b
)
5815 struct bp_location
*bl
;
5817 b
->enable_state
= bp_permanent
;
5819 /* By definition, permanent breakpoints are already present in the
5820 code. Mark all locations as inserted. For now,
5821 make_breakpoint_permanent is called in just one place, so it's
5822 hard to say if it's reasonable to have permanent breakpoint with
5823 multiple locations or not, but it's easy to implmement. */
5824 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
5828 /* Call this routine when stepping and nexting to enable a breakpoint
5829 if we do a longjmp() or 'throw' in TP. FRAME is the frame which
5830 initiated the operation. */
5833 set_longjmp_breakpoint (struct thread_info
*tp
, struct frame_id frame
)
5835 struct breakpoint
*b
, *b_tmp
;
5836 int thread
= tp
->num
;
5838 /* To avoid having to rescan all objfile symbols at every step,
5839 we maintain a list of continually-inserted but always disabled
5840 longjmp "master" breakpoints. Here, we simply create momentary
5841 clones of those and enable them for the requested thread. */
5842 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
5843 if (b
->pspace
== current_program_space
5844 && (b
->type
== bp_longjmp_master
5845 || b
->type
== bp_exception_master
))
5847 struct breakpoint
*clone
= clone_momentary_breakpoint (b
);
5849 clone
->type
= b
->type
== bp_longjmp_master
? bp_longjmp
: bp_exception
;
5850 clone
->thread
= thread
;
5853 tp
->initiating_frame
= frame
;
5856 /* Delete all longjmp breakpoints from THREAD. */
5858 delete_longjmp_breakpoint (int thread
)
5860 struct breakpoint
*b
, *b_tmp
;
5862 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
5863 if (b
->type
== bp_longjmp
|| b
->type
== bp_exception
)
5865 if (b
->thread
== thread
)
5866 delete_breakpoint (b
);
5871 enable_overlay_breakpoints (void)
5873 struct breakpoint
*b
;
5876 if (b
->type
== bp_overlay_event
)
5878 b
->enable_state
= bp_enabled
;
5879 update_global_location_list (1);
5880 overlay_events_enabled
= 1;
5885 disable_overlay_breakpoints (void)
5887 struct breakpoint
*b
;
5890 if (b
->type
== bp_overlay_event
)
5892 b
->enable_state
= bp_disabled
;
5893 update_global_location_list (0);
5894 overlay_events_enabled
= 0;
5898 /* Set an active std::terminate breakpoint for each std::terminate
5899 master breakpoint. */
5901 set_std_terminate_breakpoint (void)
5903 struct breakpoint
*b
, *b_tmp
;
5905 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
5906 if (b
->pspace
== current_program_space
5907 && b
->type
== bp_std_terminate_master
)
5909 struct breakpoint
*clone
= clone_momentary_breakpoint (b
);
5910 clone
->type
= bp_std_terminate
;
5914 /* Delete all the std::terminate breakpoints. */
5916 delete_std_terminate_breakpoint (void)
5918 struct breakpoint
*b
, *b_tmp
;
5920 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
5921 if (b
->type
== bp_std_terminate
)
5922 delete_breakpoint (b
);
5926 create_thread_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
5928 struct breakpoint
*b
;
5930 b
= create_internal_breakpoint (gdbarch
, address
, bp_thread_event
);
5932 b
->enable_state
= bp_enabled
;
5933 /* addr_string has to be used or breakpoint_re_set will delete me. */
5935 = xstrprintf ("*%s", paddress (b
->loc
->gdbarch
, b
->loc
->address
));
5937 update_global_location_list_nothrow (1);
5943 remove_thread_event_breakpoints (void)
5945 struct breakpoint
*b
, *b_tmp
;
5947 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
5948 if (b
->type
== bp_thread_event
5949 && b
->loc
->pspace
== current_program_space
)
5950 delete_breakpoint (b
);
5953 struct captured_parse_breakpoint_args
5956 struct symtabs_and_lines
*sals_p
;
5957 char ***addr_string_p
;
5961 struct lang_and_radix
5967 /* Create a breakpoint for JIT code registration and unregistration. */
5970 create_jit_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
5972 struct breakpoint
*b
;
5974 b
= create_internal_breakpoint (gdbarch
, address
, bp_jit_event
);
5975 update_global_location_list_nothrow (1);
5979 /* Remove JIT code registration and unregistration breakpoint(s). */
5982 remove_jit_event_breakpoints (void)
5984 struct breakpoint
*b
, *b_tmp
;
5986 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
5987 if (b
->type
== bp_jit_event
5988 && b
->loc
->pspace
== current_program_space
)
5989 delete_breakpoint (b
);
5993 remove_solib_event_breakpoints (void)
5995 struct breakpoint
*b
, *b_tmp
;
5997 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
5998 if (b
->type
== bp_shlib_event
5999 && b
->loc
->pspace
== current_program_space
)
6000 delete_breakpoint (b
);
6004 create_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
6006 struct breakpoint
*b
;
6008 b
= create_internal_breakpoint (gdbarch
, address
, bp_shlib_event
);
6009 update_global_location_list_nothrow (1);
6013 /* Disable any breakpoints that are on code in shared libraries. Only
6014 apply to enabled breakpoints, disabled ones can just stay disabled. */
6017 disable_breakpoints_in_shlibs (void)
6019 struct bp_location
*loc
, **locp_tmp
;
6021 ALL_BP_LOCATIONS (loc
, locp_tmp
)
6023 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
6024 struct breakpoint
*b
= loc
->owner
;
6026 /* We apply the check to all breakpoints, including disabled for
6027 those with loc->duplicate set. This is so that when breakpoint
6028 becomes enabled, or the duplicate is removed, gdb will try to
6029 insert all breakpoints. If we don't set shlib_disabled here,
6030 we'll try to insert those breakpoints and fail. */
6031 if (((b
->type
== bp_breakpoint
)
6032 || (b
->type
== bp_jit_event
)
6033 || (b
->type
== bp_hardware_breakpoint
)
6034 || (is_tracepoint (b
)))
6035 && loc
->pspace
== current_program_space
6036 && !loc
->shlib_disabled
6038 && PC_SOLIB (loc
->address
)
6040 && solib_name_from_address (loc
->pspace
, loc
->address
)
6044 loc
->shlib_disabled
= 1;
6049 /* Disable any breakpoints that are in in an unloaded shared library.
6050 Only apply to enabled breakpoints, disabled ones can just stay
6054 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
6056 struct bp_location
*loc
, **locp_tmp
;
6057 int disabled_shlib_breaks
= 0;
6059 /* SunOS a.out shared libraries are always mapped, so do not
6060 disable breakpoints; they will only be reported as unloaded
6061 through clear_solib when GDB discards its shared library
6062 list. See clear_solib for more information. */
6063 if (exec_bfd
!= NULL
6064 && bfd_get_flavour (exec_bfd
) == bfd_target_aout_flavour
)
6067 ALL_BP_LOCATIONS (loc
, locp_tmp
)
6069 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
6070 struct breakpoint
*b
= loc
->owner
;
6072 if ((loc
->loc_type
== bp_loc_hardware_breakpoint
6073 || loc
->loc_type
== bp_loc_software_breakpoint
)
6074 && solib
->pspace
== loc
->pspace
6075 && !loc
->shlib_disabled
6076 && (b
->type
== bp_breakpoint
6077 || b
->type
== bp_jit_event
6078 || b
->type
== bp_hardware_breakpoint
)
6079 && solib_contains_address_p (solib
, loc
->address
))
6081 loc
->shlib_disabled
= 1;
6082 /* At this point, we cannot rely on remove_breakpoint
6083 succeeding so we must mark the breakpoint as not inserted
6084 to prevent future errors occurring in remove_breakpoints. */
6086 if (!disabled_shlib_breaks
)
6088 target_terminal_ours_for_output ();
6089 warning (_("Temporarily disabling breakpoints "
6090 "for unloaded shared library \"%s\""),
6093 disabled_shlib_breaks
= 1;
6098 /* FORK & VFORK catchpoints. */
6100 /* Implement the "insert" breakpoint_ops method for fork
6104 insert_catch_fork (struct bp_location
*bl
)
6106 return target_insert_fork_catchpoint (PIDGET (inferior_ptid
));
6109 /* Implement the "remove" breakpoint_ops method for fork
6113 remove_catch_fork (struct bp_location
*bl
)
6115 return target_remove_fork_catchpoint (PIDGET (inferior_ptid
));
6118 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
6122 breakpoint_hit_catch_fork (struct breakpoint
*b
)
6124 return inferior_has_forked (inferior_ptid
, &b
->forked_inferior_pid
);
6127 /* Implement the "print_it" breakpoint_ops method for fork
6130 static enum print_stop_action
6131 print_it_catch_fork (struct breakpoint
*b
)
6133 annotate_catchpoint (b
->number
);
6134 printf_filtered (_("\nCatchpoint %d (forked process %d), "),
6135 b
->number
, ptid_get_pid (b
->forked_inferior_pid
));
6136 return PRINT_SRC_AND_LOC
;
6139 /* Implement the "print_one" breakpoint_ops method for fork
6143 print_one_catch_fork (struct breakpoint
*b
, struct bp_location
**last_loc
)
6145 struct value_print_options opts
;
6147 get_user_print_options (&opts
);
6149 /* Field 4, the address, is omitted (which makes the columns not
6150 line up too nicely with the headers, but the effect is relatively
6152 if (opts
.addressprint
)
6153 ui_out_field_skip (uiout
, "addr");
6155 ui_out_text (uiout
, "fork");
6156 if (!ptid_equal (b
->forked_inferior_pid
, null_ptid
))
6158 ui_out_text (uiout
, ", process ");
6159 ui_out_field_int (uiout
, "what",
6160 ptid_get_pid (b
->forked_inferior_pid
));
6161 ui_out_spaces (uiout
, 1);
6165 /* Implement the "print_mention" breakpoint_ops method for fork
6169 print_mention_catch_fork (struct breakpoint
*b
)
6171 printf_filtered (_("Catchpoint %d (fork)"), b
->number
);
6174 /* Implement the "print_recreate" breakpoint_ops method for fork
6178 print_recreate_catch_fork (struct breakpoint
*b
, struct ui_file
*fp
)
6180 fprintf_unfiltered (fp
, "catch fork");
6183 /* The breakpoint_ops structure to be used in fork catchpoints. */
6185 static struct breakpoint_ops catch_fork_breakpoint_ops
=
6189 breakpoint_hit_catch_fork
,
6190 NULL
, /* resources_needed */
6191 print_it_catch_fork
,
6192 print_one_catch_fork
,
6193 print_mention_catch_fork
,
6194 print_recreate_catch_fork
6197 /* Implement the "insert" breakpoint_ops method for vfork
6201 insert_catch_vfork (struct bp_location
*bl
)
6203 return target_insert_vfork_catchpoint (PIDGET (inferior_ptid
));
6206 /* Implement the "remove" breakpoint_ops method for vfork
6210 remove_catch_vfork (struct bp_location
*bl
)
6212 return target_remove_vfork_catchpoint (PIDGET (inferior_ptid
));
6215 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
6219 breakpoint_hit_catch_vfork (struct breakpoint
*b
)
6221 return inferior_has_vforked (inferior_ptid
, &b
->forked_inferior_pid
);
6224 /* Implement the "print_it" breakpoint_ops method for vfork
6227 static enum print_stop_action
6228 print_it_catch_vfork (struct breakpoint
*b
)
6230 annotate_catchpoint (b
->number
);
6231 printf_filtered (_("\nCatchpoint %d (vforked process %d), "),
6232 b
->number
, ptid_get_pid (b
->forked_inferior_pid
));
6233 return PRINT_SRC_AND_LOC
;
6236 /* Implement the "print_one" breakpoint_ops method for vfork
6240 print_one_catch_vfork (struct breakpoint
*b
, struct bp_location
**last_loc
)
6242 struct value_print_options opts
;
6244 get_user_print_options (&opts
);
6245 /* Field 4, the address, is omitted (which makes the columns not
6246 line up too nicely with the headers, but the effect is relatively
6248 if (opts
.addressprint
)
6249 ui_out_field_skip (uiout
, "addr");
6251 ui_out_text (uiout
, "vfork");
6252 if (!ptid_equal (b
->forked_inferior_pid
, null_ptid
))
6254 ui_out_text (uiout
, ", process ");
6255 ui_out_field_int (uiout
, "what",
6256 ptid_get_pid (b
->forked_inferior_pid
));
6257 ui_out_spaces (uiout
, 1);
6261 /* Implement the "print_mention" breakpoint_ops method for vfork
6265 print_mention_catch_vfork (struct breakpoint
*b
)
6267 printf_filtered (_("Catchpoint %d (vfork)"), b
->number
);
6270 /* Implement the "print_recreate" breakpoint_ops method for vfork
6274 print_recreate_catch_vfork (struct breakpoint
*b
, struct ui_file
*fp
)
6276 fprintf_unfiltered (fp
, "catch vfork");
6279 /* The breakpoint_ops structure to be used in vfork catchpoints. */
6281 static struct breakpoint_ops catch_vfork_breakpoint_ops
=
6285 breakpoint_hit_catch_vfork
,
6286 NULL
, /* resources_needed */
6287 print_it_catch_vfork
,
6288 print_one_catch_vfork
,
6289 print_mention_catch_vfork
,
6290 print_recreate_catch_vfork
6293 /* Implement the "insert" breakpoint_ops method for syscall
6297 insert_catch_syscall (struct bp_location
*bl
)
6299 struct inferior
*inf
= current_inferior ();
6301 ++inf
->total_syscalls_count
;
6302 if (!bl
->owner
->syscalls_to_be_caught
)
6303 ++inf
->any_syscall_count
;
6309 VEC_iterate (int, bl
->owner
->syscalls_to_be_caught
, i
, iter
);
6314 if (iter
>= VEC_length (int, inf
->syscalls_counts
))
6316 int old_size
= VEC_length (int, inf
->syscalls_counts
);
6317 uintptr_t vec_addr_offset
6318 = old_size
* ((uintptr_t) sizeof (int));
6320 VEC_safe_grow (int, inf
->syscalls_counts
, iter
+ 1);
6321 vec_addr
= (uintptr_t) VEC_address (int, inf
->syscalls_counts
) +
6323 memset ((void *) vec_addr
, 0,
6324 (iter
+ 1 - old_size
) * sizeof (int));
6326 elem
= VEC_index (int, inf
->syscalls_counts
, iter
);
6327 VEC_replace (int, inf
->syscalls_counts
, iter
, ++elem
);
6331 return target_set_syscall_catchpoint (PIDGET (inferior_ptid
),
6332 inf
->total_syscalls_count
!= 0,
6333 inf
->any_syscall_count
,
6334 VEC_length (int, inf
->syscalls_counts
),
6335 VEC_address (int, inf
->syscalls_counts
));
6338 /* Implement the "remove" breakpoint_ops method for syscall
6342 remove_catch_syscall (struct bp_location
*bl
)
6344 struct inferior
*inf
= current_inferior ();
6346 --inf
->total_syscalls_count
;
6347 if (!bl
->owner
->syscalls_to_be_caught
)
6348 --inf
->any_syscall_count
;
6354 VEC_iterate (int, bl
->owner
->syscalls_to_be_caught
, i
, iter
);
6358 if (iter
>= VEC_length (int, inf
->syscalls_counts
))
6359 /* Shouldn't happen. */
6361 elem
= VEC_index (int, inf
->syscalls_counts
, iter
);
6362 VEC_replace (int, inf
->syscalls_counts
, iter
, --elem
);
6366 return target_set_syscall_catchpoint (PIDGET (inferior_ptid
),
6367 inf
->total_syscalls_count
!= 0,
6368 inf
->any_syscall_count
,
6369 VEC_length (int, inf
->syscalls_counts
),
6371 inf
->syscalls_counts
));
6374 /* Implement the "breakpoint_hit" breakpoint_ops method for syscall
6378 breakpoint_hit_catch_syscall (struct breakpoint
*b
)
6380 /* We must check if we are catching specific syscalls in this
6381 breakpoint. If we are, then we must guarantee that the called
6382 syscall is the same syscall we are catching. */
6383 int syscall_number
= 0;
6385 if (!inferior_has_called_syscall (inferior_ptid
, &syscall_number
))
6388 /* Now, checking if the syscall is the same. */
6389 if (b
->syscalls_to_be_caught
)
6394 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
6396 if (syscall_number
== iter
)
6406 /* Implement the "print_it" breakpoint_ops method for syscall
6409 static enum print_stop_action
6410 print_it_catch_syscall (struct breakpoint
*b
)
6412 /* These are needed because we want to know in which state a
6413 syscall is. It can be in the TARGET_WAITKIND_SYSCALL_ENTRY
6414 or TARGET_WAITKIND_SYSCALL_RETURN, and depending on it we
6415 must print "called syscall" or "returned from syscall". */
6417 struct target_waitstatus last
;
6419 struct cleanup
*old_chain
;
6422 get_last_target_status (&ptid
, &last
);
6424 get_syscall_by_number (last
.value
.syscall_number
, &s
);
6426 annotate_catchpoint (b
->number
);
6429 syscall_id
= xstrprintf ("%d", last
.value
.syscall_number
);
6431 syscall_id
= xstrprintf ("'%s'", s
.name
);
6433 old_chain
= make_cleanup (xfree
, syscall_id
);
6435 if (last
.kind
== TARGET_WAITKIND_SYSCALL_ENTRY
)
6436 printf_filtered (_("\nCatchpoint %d (call to syscall %s), "),
6437 b
->number
, syscall_id
);
6438 else if (last
.kind
== TARGET_WAITKIND_SYSCALL_RETURN
)
6439 printf_filtered (_("\nCatchpoint %d (returned from syscall %s), "),
6440 b
->number
, syscall_id
);
6442 do_cleanups (old_chain
);
6444 return PRINT_SRC_AND_LOC
;
6447 /* Implement the "print_one" breakpoint_ops method for syscall
6451 print_one_catch_syscall (struct breakpoint
*b
,
6452 struct bp_location
**last_loc
)
6454 struct value_print_options opts
;
6456 get_user_print_options (&opts
);
6457 /* Field 4, the address, is omitted (which makes the columns not
6458 line up too nicely with the headers, but the effect is relatively
6460 if (opts
.addressprint
)
6461 ui_out_field_skip (uiout
, "addr");
6464 if (b
->syscalls_to_be_caught
6465 && VEC_length (int, b
->syscalls_to_be_caught
) > 1)
6466 ui_out_text (uiout
, "syscalls \"");
6468 ui_out_text (uiout
, "syscall \"");
6470 if (b
->syscalls_to_be_caught
)
6473 char *text
= xstrprintf ("%s", "");
6476 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
6481 get_syscall_by_number (iter
, &s
);
6484 text
= xstrprintf ("%s%s, ", text
, s
.name
);
6486 text
= xstrprintf ("%s%d, ", text
, iter
);
6488 /* We have to xfree the last 'text' (now stored at 'x')
6489 because xstrprintf dinamically allocates new space for it
6493 /* Remove the last comma. */
6494 text
[strlen (text
) - 2] = '\0';
6495 ui_out_field_string (uiout
, "what", text
);
6498 ui_out_field_string (uiout
, "what", "<any syscall>");
6499 ui_out_text (uiout
, "\" ");
6502 /* Implement the "print_mention" breakpoint_ops method for syscall
6506 print_mention_catch_syscall (struct breakpoint
*b
)
6508 if (b
->syscalls_to_be_caught
)
6512 if (VEC_length (int, b
->syscalls_to_be_caught
) > 1)
6513 printf_filtered (_("Catchpoint %d (syscalls"), b
->number
);
6515 printf_filtered (_("Catchpoint %d (syscall"), b
->number
);
6518 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
6522 get_syscall_by_number (iter
, &s
);
6525 printf_filtered (" '%s' [%d]", s
.name
, s
.number
);
6527 printf_filtered (" %d", s
.number
);
6529 printf_filtered (")");
6532 printf_filtered (_("Catchpoint %d (any syscall)"),
6536 /* Implement the "print_recreate" breakpoint_ops method for syscall
6540 print_recreate_catch_syscall (struct breakpoint
*b
, struct ui_file
*fp
)
6542 fprintf_unfiltered (fp
, "catch syscall");
6544 if (b
->syscalls_to_be_caught
)
6549 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
6554 get_syscall_by_number (iter
, &s
);
6556 fprintf_unfiltered (fp
, " %s", s
.name
);
6558 fprintf_unfiltered (fp
, " %d", s
.number
);
6563 /* The breakpoint_ops structure to be used in syscall catchpoints. */
6565 static struct breakpoint_ops catch_syscall_breakpoint_ops
=
6567 insert_catch_syscall
,
6568 remove_catch_syscall
,
6569 breakpoint_hit_catch_syscall
,
6570 NULL
, /* resources_needed */
6571 print_it_catch_syscall
,
6572 print_one_catch_syscall
,
6573 print_mention_catch_syscall
,
6574 print_recreate_catch_syscall
6577 /* Returns non-zero if 'b' is a syscall catchpoint. */
6580 syscall_catchpoint_p (struct breakpoint
*b
)
6582 return (b
->ops
== &catch_syscall_breakpoint_ops
);
6585 /* Create a new breakpoint of the bp_catchpoint kind and return it,
6586 but does NOT mention it nor update the global location list.
6587 This is useful if you need to fill more fields in the
6588 struct breakpoint before calling mention.
6590 If TEMPFLAG is non-zero, then make the breakpoint temporary.
6591 If COND_STRING is not NULL, then store it in the breakpoint.
6592 OPS, if not NULL, is the breakpoint_ops structure associated
6593 to the catchpoint. */
6595 static struct breakpoint
*
6596 create_catchpoint_without_mention (struct gdbarch
*gdbarch
, int tempflag
,
6598 struct breakpoint_ops
*ops
)
6600 struct symtab_and_line sal
;
6601 struct breakpoint
*b
;
6604 sal
.pspace
= current_program_space
;
6606 b
= set_raw_breakpoint (gdbarch
, sal
, bp_catchpoint
);
6607 set_breakpoint_count (breakpoint_count
+ 1);
6608 b
->number
= breakpoint_count
;
6610 b
->cond_string
= (cond_string
== NULL
) ? NULL
: xstrdup (cond_string
);
6612 b
->addr_string
= NULL
;
6613 b
->enable_state
= bp_enabled
;
6614 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6620 /* Create a new breakpoint of the bp_catchpoint kind and return it.
6622 If TEMPFLAG is non-zero, then make the breakpoint temporary.
6623 If COND_STRING is not NULL, then store it in the breakpoint.
6624 OPS, if not NULL, is the breakpoint_ops structure associated
6625 to the catchpoint. */
6627 static struct breakpoint
*
6628 create_catchpoint (struct gdbarch
*gdbarch
, int tempflag
,
6629 char *cond_string
, struct breakpoint_ops
*ops
)
6631 struct breakpoint
*b
=
6632 create_catchpoint_without_mention (gdbarch
, tempflag
, cond_string
, ops
);
6635 update_global_location_list (1);
6641 create_fork_vfork_event_catchpoint (struct gdbarch
*gdbarch
,
6642 int tempflag
, char *cond_string
,
6643 struct breakpoint_ops
*ops
)
6645 struct breakpoint
*b
6646 = create_catchpoint (gdbarch
, tempflag
, cond_string
, ops
);
6648 /* FIXME: We should put this information in a breakpoint private data
6650 b
->forked_inferior_pid
= null_ptid
;
6653 /* Exec catchpoints. */
6656 insert_catch_exec (struct bp_location
*bl
)
6658 return target_insert_exec_catchpoint (PIDGET (inferior_ptid
));
6662 remove_catch_exec (struct bp_location
*bl
)
6664 return target_remove_exec_catchpoint (PIDGET (inferior_ptid
));
6668 breakpoint_hit_catch_exec (struct breakpoint
*b
)
6670 return inferior_has_execd (inferior_ptid
, &b
->exec_pathname
);
6673 static enum print_stop_action
6674 print_it_catch_exec (struct breakpoint
*b
)
6676 annotate_catchpoint (b
->number
);
6677 printf_filtered (_("\nCatchpoint %d (exec'd %s), "), b
->number
,
6679 return PRINT_SRC_AND_LOC
;
6683 print_one_catch_exec (struct breakpoint
*b
, struct bp_location
**last_loc
)
6685 struct value_print_options opts
;
6687 get_user_print_options (&opts
);
6689 /* Field 4, the address, is omitted (which makes the columns
6690 not line up too nicely with the headers, but the effect
6691 is relatively readable). */
6692 if (opts
.addressprint
)
6693 ui_out_field_skip (uiout
, "addr");
6695 ui_out_text (uiout
, "exec");
6696 if (b
->exec_pathname
!= NULL
)
6698 ui_out_text (uiout
, ", program \"");
6699 ui_out_field_string (uiout
, "what", b
->exec_pathname
);
6700 ui_out_text (uiout
, "\" ");
6705 print_mention_catch_exec (struct breakpoint
*b
)
6707 printf_filtered (_("Catchpoint %d (exec)"), b
->number
);
6710 /* Implement the "print_recreate" breakpoint_ops method for exec
6714 print_recreate_catch_exec (struct breakpoint
*b
, struct ui_file
*fp
)
6716 fprintf_unfiltered (fp
, "catch exec");
6719 static struct breakpoint_ops catch_exec_breakpoint_ops
=
6723 breakpoint_hit_catch_exec
,
6724 NULL
, /* resources_needed */
6725 print_it_catch_exec
,
6726 print_one_catch_exec
,
6727 print_mention_catch_exec
,
6728 print_recreate_catch_exec
6732 create_syscall_event_catchpoint (int tempflag
, VEC(int) *filter
,
6733 struct breakpoint_ops
*ops
)
6735 struct gdbarch
*gdbarch
= get_current_arch ();
6736 struct breakpoint
*b
=
6737 create_catchpoint_without_mention (gdbarch
, tempflag
, NULL
, ops
);
6739 b
->syscalls_to_be_caught
= filter
;
6741 /* Now, we have to mention the breakpoint and update the global
6744 update_global_location_list (1);
6748 hw_breakpoint_used_count (void)
6750 struct breakpoint
*b
;
6755 if (b
->type
== bp_hardware_breakpoint
&& breakpoint_enabled (b
))
6763 hw_watchpoint_used_count (enum bptype type
, int *other_type_used
)
6766 struct breakpoint
*b
;
6767 struct bp_location
*bl
;
6769 *other_type_used
= 0;
6772 if (!breakpoint_enabled (b
))
6775 if (b
->type
== type
)
6776 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
6778 /* Special types of hardware watchpoints may use more than
6780 if (b
->ops
&& b
->ops
->resources_needed
)
6781 i
+= b
->ops
->resources_needed (bl
);
6785 else if (is_hardware_watchpoint (b
))
6786 *other_type_used
= 1;
6793 disable_watchpoints_before_interactive_call_start (void)
6795 struct breakpoint
*b
;
6799 if (is_watchpoint (b
) && breakpoint_enabled (b
))
6801 b
->enable_state
= bp_call_disabled
;
6802 update_global_location_list (0);
6808 enable_watchpoints_after_interactive_call_stop (void)
6810 struct breakpoint
*b
;
6814 if (is_watchpoint (b
) && b
->enable_state
== bp_call_disabled
)
6816 b
->enable_state
= bp_enabled
;
6817 update_global_location_list (1);
6823 disable_breakpoints_before_startup (void)
6825 struct breakpoint
*b
;
6830 if (b
->pspace
!= current_program_space
)
6833 if ((b
->type
== bp_breakpoint
6834 || b
->type
== bp_hardware_breakpoint
)
6835 && breakpoint_enabled (b
))
6837 b
->enable_state
= bp_startup_disabled
;
6843 update_global_location_list (0);
6845 current_program_space
->executing_startup
= 1;
6849 enable_breakpoints_after_startup (void)
6851 struct breakpoint
*b
;
6854 current_program_space
->executing_startup
= 0;
6858 if (b
->pspace
!= current_program_space
)
6861 if ((b
->type
== bp_breakpoint
6862 || b
->type
== bp_hardware_breakpoint
)
6863 && b
->enable_state
== bp_startup_disabled
)
6865 b
->enable_state
= bp_enabled
;
6871 breakpoint_re_set ();
6875 /* Set a breakpoint that will evaporate an end of command
6876 at address specified by SAL.
6877 Restrict it to frame FRAME if FRAME is nonzero. */
6880 set_momentary_breakpoint (struct gdbarch
*gdbarch
, struct symtab_and_line sal
,
6881 struct frame_id frame_id
, enum bptype type
)
6883 struct breakpoint
*b
;
6885 /* If FRAME_ID is valid, it should be a real frame, not an inlined
6887 gdb_assert (!frame_id_inlined_p (frame_id
));
6889 b
= set_raw_breakpoint (gdbarch
, sal
, type
);
6890 b
->enable_state
= bp_enabled
;
6891 b
->disposition
= disp_donttouch
;
6892 b
->frame_id
= frame_id
;
6894 /* If we're debugging a multi-threaded program, then we want
6895 momentary breakpoints to be active in only a single thread of
6897 if (in_thread_list (inferior_ptid
))
6898 b
->thread
= pid_to_thread_id (inferior_ptid
);
6900 update_global_location_list_nothrow (1);
6905 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
6909 clone_momentary_breakpoint (struct breakpoint
*orig
)
6911 struct breakpoint
*copy
;
6913 /* If there's nothing to clone, then return nothing. */
6917 copy
= set_raw_breakpoint_without_location (orig
->gdbarch
, orig
->type
);
6918 copy
->loc
= allocate_bp_location (copy
);
6919 set_breakpoint_location_function (copy
->loc
);
6921 copy
->loc
->gdbarch
= orig
->loc
->gdbarch
;
6922 copy
->loc
->requested_address
= orig
->loc
->requested_address
;
6923 copy
->loc
->address
= orig
->loc
->address
;
6924 copy
->loc
->section
= orig
->loc
->section
;
6925 copy
->loc
->pspace
= orig
->loc
->pspace
;
6927 if (orig
->source_file
== NULL
)
6928 copy
->source_file
= NULL
;
6930 copy
->source_file
= xstrdup (orig
->source_file
);
6932 copy
->line_number
= orig
->line_number
;
6933 copy
->frame_id
= orig
->frame_id
;
6934 copy
->thread
= orig
->thread
;
6935 copy
->pspace
= orig
->pspace
;
6937 copy
->enable_state
= bp_enabled
;
6938 copy
->disposition
= disp_donttouch
;
6939 copy
->number
= internal_breakpoint_number
--;
6941 update_global_location_list_nothrow (0);
6946 set_momentary_breakpoint_at_pc (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
6949 struct symtab_and_line sal
;
6951 sal
= find_pc_line (pc
, 0);
6953 sal
.section
= find_pc_overlay (pc
);
6954 sal
.explicit_pc
= 1;
6956 return set_momentary_breakpoint (gdbarch
, sal
, null_frame_id
, type
);
6960 /* Tell the user we have just set a breakpoint B. */
6963 mention (struct breakpoint
*b
)
6966 struct cleanup
*ui_out_chain
;
6967 struct value_print_options opts
;
6969 get_user_print_options (&opts
);
6971 /* FIXME: This is misplaced; mention() is called by things (like
6972 hitting a watchpoint) other than breakpoint creation. It should
6973 be possible to clean this up and at the same time replace the
6974 random calls to breakpoint_changed with this hook. */
6975 observer_notify_breakpoint_created (b
->number
);
6977 if (b
->ops
!= NULL
&& b
->ops
->print_mention
!= NULL
)
6978 b
->ops
->print_mention (b
);
6983 printf_filtered (_("(apparently deleted?) Eventpoint %d: "),
6987 ui_out_text (uiout
, "Watchpoint ");
6988 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
6989 ui_out_field_int (uiout
, "number", b
->number
);
6990 ui_out_text (uiout
, ": ");
6991 ui_out_field_string (uiout
, "exp", b
->exp_string
);
6992 do_cleanups (ui_out_chain
);
6994 case bp_hardware_watchpoint
:
6995 ui_out_text (uiout
, "Hardware watchpoint ");
6996 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
6997 ui_out_field_int (uiout
, "number", b
->number
);
6998 ui_out_text (uiout
, ": ");
6999 ui_out_field_string (uiout
, "exp", b
->exp_string
);
7000 do_cleanups (ui_out_chain
);
7002 case bp_read_watchpoint
:
7003 ui_out_text (uiout
, "Hardware read watchpoint ");
7004 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
7005 ui_out_field_int (uiout
, "number", b
->number
);
7006 ui_out_text (uiout
, ": ");
7007 ui_out_field_string (uiout
, "exp", b
->exp_string
);
7008 do_cleanups (ui_out_chain
);
7010 case bp_access_watchpoint
:
7011 ui_out_text (uiout
, "Hardware access (read/write) watchpoint ");
7012 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
7013 ui_out_field_int (uiout
, "number", b
->number
);
7014 ui_out_text (uiout
, ": ");
7015 ui_out_field_string (uiout
, "exp", b
->exp_string
);
7016 do_cleanups (ui_out_chain
);
7019 if (ui_out_is_mi_like_p (uiout
))
7024 if (b
->disposition
== disp_del
)
7025 printf_filtered (_("Temporary breakpoint"));
7027 printf_filtered (_("Breakpoint"));
7028 printf_filtered (_(" %d"), b
->number
);
7031 case bp_hardware_breakpoint
:
7032 if (ui_out_is_mi_like_p (uiout
))
7037 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
7041 if (ui_out_is_mi_like_p (uiout
))
7046 printf_filtered (_("Tracepoint"));
7047 printf_filtered (_(" %d"), b
->number
);
7050 case bp_fast_tracepoint
:
7051 if (ui_out_is_mi_like_p (uiout
))
7056 printf_filtered (_("Fast tracepoint"));
7057 printf_filtered (_(" %d"), b
->number
);
7060 case bp_static_tracepoint
:
7061 if (ui_out_is_mi_like_p (uiout
))
7066 printf_filtered (_("Static tracepoint"));
7067 printf_filtered (_(" %d"), b
->number
);
7074 case bp_longjmp_resume
:
7076 case bp_exception_resume
:
7077 case bp_step_resume
:
7079 case bp_std_terminate
:
7080 case bp_watchpoint_scope
:
7081 case bp_shlib_event
:
7082 case bp_thread_event
:
7083 case bp_overlay_event
:
7085 case bp_longjmp_master
:
7086 case bp_std_terminate_master
:
7087 case bp_exception_master
:
7093 /* i18n: cagney/2005-02-11: Below needs to be merged into a
7097 printf_filtered (_(" (%s) pending."), b
->addr_string
);
7101 if (opts
.addressprint
|| b
->source_file
== NULL
)
7103 printf_filtered (" at ");
7104 fputs_filtered (paddress (b
->loc
->gdbarch
, b
->loc
->address
),
7108 printf_filtered (": file %s, line %d.",
7109 b
->source_file
, b
->line_number
);
7113 struct bp_location
*loc
= b
->loc
;
7115 for (; loc
; loc
= loc
->next
)
7117 printf_filtered (" (%d locations)", n
);
7122 if (ui_out_is_mi_like_p (uiout
))
7124 printf_filtered ("\n");
7128 static struct bp_location
*
7129 add_location_to_breakpoint (struct breakpoint
*b
,
7130 const struct symtab_and_line
*sal
)
7132 struct bp_location
*loc
, **tmp
;
7134 loc
= allocate_bp_location (b
);
7135 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
7138 loc
->gdbarch
= get_sal_arch (*sal
);
7140 loc
->gdbarch
= b
->gdbarch
;
7141 loc
->requested_address
= sal
->pc
;
7142 loc
->address
= adjust_breakpoint_address (loc
->gdbarch
,
7143 loc
->requested_address
, b
->type
);
7144 loc
->pspace
= sal
->pspace
;
7145 gdb_assert (loc
->pspace
!= NULL
);
7146 loc
->section
= sal
->section
;
7148 set_breakpoint_location_function (loc
);
7153 /* Return 1 if LOC is pointing to a permanent breakpoint,
7154 return 0 otherwise. */
7157 bp_loc_is_permanent (struct bp_location
*loc
)
7161 const gdb_byte
*brk
;
7162 gdb_byte
*target_mem
;
7163 struct cleanup
*cleanup
;
7166 gdb_assert (loc
!= NULL
);
7168 addr
= loc
->address
;
7169 brk
= gdbarch_breakpoint_from_pc (loc
->gdbarch
, &addr
, &len
);
7171 /* Software breakpoints unsupported? */
7175 target_mem
= alloca (len
);
7177 /* Enable the automatic memory restoration from breakpoints while
7178 we read the memory. Otherwise we could say about our temporary
7179 breakpoints they are permanent. */
7180 cleanup
= save_current_space_and_thread ();
7182 switch_to_program_space_and_thread (loc
->pspace
);
7183 make_show_memory_breakpoints_cleanup (0);
7185 if (target_read_memory (loc
->address
, target_mem
, len
) == 0
7186 && memcmp (target_mem
, brk
, len
) == 0)
7189 do_cleanups (cleanup
);
7196 /* Create a breakpoint with SAL as location. Use ADDR_STRING
7197 as textual description of the location, and COND_STRING
7198 as condition expression. */
7201 create_breakpoint_sal (struct gdbarch
*gdbarch
,
7202 struct symtabs_and_lines sals
, char *addr_string
,
7204 enum bptype type
, enum bpdisp disposition
,
7205 int thread
, int task
, int ignore_count
,
7206 struct breakpoint_ops
*ops
, int from_tty
,
7207 int enabled
, int internal
)
7209 struct breakpoint
*b
= NULL
;
7212 if (type
== bp_hardware_breakpoint
)
7214 int i
= hw_breakpoint_used_count ();
7215 int target_resources_ok
=
7216 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
7218 if (target_resources_ok
== 0)
7219 error (_("No hardware breakpoint support in the target."));
7220 else if (target_resources_ok
< 0)
7221 error (_("Hardware breakpoints used exceeds limit."));
7224 gdb_assert (sals
.nelts
> 0);
7226 for (i
= 0; i
< sals
.nelts
; ++i
)
7228 struct symtab_and_line sal
= sals
.sals
[i
];
7229 struct bp_location
*loc
;
7233 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
7235 loc_gdbarch
= gdbarch
;
7237 describe_other_breakpoints (loc_gdbarch
,
7238 sal
.pspace
, sal
.pc
, sal
.section
, thread
);
7243 b
= set_raw_breakpoint (gdbarch
, sal
, type
);
7244 set_breakpoint_number (internal
, b
);
7248 b
->cond_string
= cond_string
;
7249 b
->ignore_count
= ignore_count
;
7250 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
7251 b
->disposition
= disposition
;
7252 b
->pspace
= sals
.sals
[0].pspace
;
7254 if (type
== bp_static_tracepoint
)
7256 struct static_tracepoint_marker marker
;
7258 if (is_marker_spec (addr_string
))
7260 /* We already know the marker exists, otherwise, we
7261 wouldn't see a sal for it. */
7262 char *p
= &addr_string
[3];
7267 p
= skip_spaces (p
);
7269 endp
= skip_to_space (p
);
7271 marker_str
= savestring (p
, endp
- p
);
7272 b
->static_trace_marker_id
= marker_str
;
7274 printf_filtered (_("Probed static tracepoint "
7276 b
->static_trace_marker_id
);
7278 else if (target_static_tracepoint_marker_at (sal
.pc
, &marker
))
7280 b
->static_trace_marker_id
= xstrdup (marker
.str_id
);
7281 release_static_tracepoint_marker (&marker
);
7283 printf_filtered (_("Probed static tracepoint "
7285 b
->static_trace_marker_id
);
7288 warning (_("Couldn't determine the static "
7289 "tracepoint marker to probe"));
7292 if (enabled
&& b
->pspace
->executing_startup
7293 && (b
->type
== bp_breakpoint
7294 || b
->type
== bp_hardware_breakpoint
))
7295 b
->enable_state
= bp_startup_disabled
;
7301 loc
= add_location_to_breakpoint (b
, &sal
);
7304 if (bp_loc_is_permanent (loc
))
7305 make_breakpoint_permanent (b
);
7309 char *arg
= b
->cond_string
;
7310 loc
->cond
= parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
7312 error (_("Garbage %s follows condition"), arg
);
7317 b
->addr_string
= addr_string
;
7319 /* addr_string has to be used or breakpoint_re_set will delete
7322 = xstrprintf ("*%s", paddress (b
->loc
->gdbarch
, b
->loc
->address
));
7326 /* Do not mention breakpoints with a negative number, but do
7327 notify observers. */
7328 observer_notify_breakpoint_created (b
->number
);
7333 /* Remove element at INDEX_TO_REMOVE from SAL, shifting other
7334 elements to fill the void space. */
7336 remove_sal (struct symtabs_and_lines
*sal
, int index_to_remove
)
7338 int i
= index_to_remove
+1;
7339 int last_index
= sal
->nelts
-1;
7341 for (;i
<= last_index
; ++i
)
7342 sal
->sals
[i
-1] = sal
->sals
[i
];
7347 /* If appropriate, obtains all sals that correspond to the same file
7348 and line as SAL, in all program spaces. Users debugging with IDEs,
7349 will want to set a breakpoint at foo.c:line, and not really care
7350 about program spaces. This is done only if SAL does not have
7351 explicit PC and has line and file information. If we got just a
7352 single expanded sal, return the original.
7354 Otherwise, if SAL.explicit_line is not set, filter out all sals for
7355 which the name of enclosing function is different from SAL. This
7356 makes sure that if we have breakpoint originally set in template
7357 instantiation, say foo<int>(), we won't expand SAL to locations at
7358 the same line in all existing instantiations of 'foo'. */
7360 static struct symtabs_and_lines
7361 expand_line_sal_maybe (struct symtab_and_line sal
)
7363 struct symtabs_and_lines expanded
;
7364 CORE_ADDR original_pc
= sal
.pc
;
7365 char *original_function
= NULL
;
7368 struct cleanup
*old_chain
;
7370 /* If we have explicit pc, don't expand.
7371 If we have no line number, we can't expand. */
7372 if (sal
.explicit_pc
|| sal
.line
== 0 || sal
.symtab
== NULL
)
7375 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
7376 expanded
.sals
[0] = sal
;
7382 old_chain
= save_current_space_and_thread ();
7384 switch_to_program_space_and_thread (sal
.pspace
);
7386 find_pc_partial_function (original_pc
, &original_function
, NULL
, NULL
);
7388 /* Note that expand_line_sal visits *all* program spaces. */
7389 expanded
= expand_line_sal (sal
);
7391 if (expanded
.nelts
== 1)
7393 /* We had one sal, we got one sal. Return that sal, adjusting it
7394 past the function prologue if necessary. */
7395 xfree (expanded
.sals
);
7397 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
7398 sal
.pc
= original_pc
;
7399 expanded
.sals
[0] = sal
;
7400 skip_prologue_sal (&expanded
.sals
[0]);
7401 do_cleanups (old_chain
);
7405 if (!sal
.explicit_line
)
7407 CORE_ADDR func_addr
, func_end
;
7408 for (i
= 0; i
< expanded
.nelts
; ++i
)
7410 CORE_ADDR pc
= expanded
.sals
[i
].pc
;
7411 char *this_function
;
7413 /* We need to switch threads as well since we're about to
7415 switch_to_program_space_and_thread (expanded
.sals
[i
].pspace
);
7417 if (find_pc_partial_function (pc
, &this_function
,
7418 &func_addr
, &func_end
))
7421 && strcmp (this_function
, original_function
) != 0)
7423 remove_sal (&expanded
, i
);
7430 /* Skip the function prologue if necessary. */
7431 for (i
= 0; i
< expanded
.nelts
; ++i
)
7432 skip_prologue_sal (&expanded
.sals
[i
]);
7434 do_cleanups (old_chain
);
7436 if (expanded
.nelts
<= 1)
7438 /* This is un ugly workaround. If we get zero expanded sals
7439 then something is really wrong. Fix that by returning the
7442 xfree (expanded
.sals
);
7444 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
7445 sal
.pc
= original_pc
;
7446 expanded
.sals
[0] = sal
;
7453 for (i
= 0; i
< expanded
.nelts
; ++i
)
7454 if (expanded
.sals
[i
].pc
== original_pc
)
7465 /* Add SALS.nelts breakpoints to the breakpoint table. For each
7466 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
7467 value. COND_STRING, if not NULL, specified the condition to be
7468 used for all breakpoints. Essentially the only case where
7469 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
7470 function. In that case, it's still not possible to specify
7471 separate conditions for different overloaded functions, so
7472 we take just a single condition string.
7474 NOTE: If the function succeeds, the caller is expected to cleanup
7475 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
7476 array contents). If the function fails (error() is called), the
7477 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
7478 COND and SALS arrays and each of those arrays contents. */
7481 create_breakpoints_sal (struct gdbarch
*gdbarch
,
7482 struct symtabs_and_lines sals
, char **addr_string
,
7484 enum bptype type
, enum bpdisp disposition
,
7485 int thread
, int task
, int ignore_count
,
7486 struct breakpoint_ops
*ops
, int from_tty
,
7487 int enabled
, int internal
)
7491 for (i
= 0; i
< sals
.nelts
; ++i
)
7493 struct symtabs_and_lines expanded
=
7494 expand_line_sal_maybe (sals
.sals
[i
]);
7496 create_breakpoint_sal (gdbarch
, expanded
, addr_string
[i
],
7497 cond_string
, type
, disposition
,
7498 thread
, task
, ignore_count
, ops
,
7499 from_tty
, enabled
, internal
);
7503 /* Parse ADDRESS which is assumed to be a SAL specification possibly
7504 followed by conditionals. On return, SALS contains an array of SAL
7505 addresses found. ADDR_STRING contains a vector of (canonical)
7506 address strings. ADDRESS points to the end of the SAL.
7508 The array and the line spec strings are allocated on the heap, it is
7509 the caller's responsibility to free them. */
7512 parse_breakpoint_sals (char **address
,
7513 struct symtabs_and_lines
*sals
,
7514 char ***addr_string
,
7517 char *addr_start
= *address
;
7519 *addr_string
= NULL
;
7520 /* If no arg given, or if first arg is 'if ', use the default
7522 if ((*address
) == NULL
7523 || (strncmp ((*address
), "if", 2) == 0 && isspace ((*address
)[2])))
7525 if (default_breakpoint_valid
)
7527 struct symtab_and_line sal
;
7529 init_sal (&sal
); /* Initialize to zeroes. */
7530 sals
->sals
= (struct symtab_and_line
*)
7531 xmalloc (sizeof (struct symtab_and_line
));
7532 sal
.pc
= default_breakpoint_address
;
7533 sal
.line
= default_breakpoint_line
;
7534 sal
.symtab
= default_breakpoint_symtab
;
7535 sal
.pspace
= default_breakpoint_pspace
;
7536 sal
.section
= find_pc_overlay (sal
.pc
);
7538 /* "break" without arguments is equivalent to "break *PC"
7539 where PC is the default_breakpoint_address. So make sure
7540 to set sal.explicit_pc to prevent GDB from trying to
7541 expand the list of sals to include all other instances
7542 with the same symtab and line. */
7543 sal
.explicit_pc
= 1;
7545 sals
->sals
[0] = sal
;
7549 error (_("No default breakpoint address now."));
7553 /* Force almost all breakpoints to be in terms of the
7554 current_source_symtab (which is decode_line_1's default).
7555 This should produce the results we want almost all of the
7556 time while leaving default_breakpoint_* alone.
7558 ObjC: However, don't match an Objective-C method name which
7559 may have a '+' or '-' succeeded by a '[' */
7561 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
7563 if (default_breakpoint_valid
7565 || ((strchr ("+-", (*address
)[0]) != NULL
)
7566 && ((*address
)[1] != '['))))
7567 *sals
= decode_line_1 (address
, 1, default_breakpoint_symtab
,
7568 default_breakpoint_line
, addr_string
,
7571 *sals
= decode_line_1 (address
, 1, (struct symtab
*) NULL
, 0,
7572 addr_string
, not_found_ptr
);
7574 /* For any SAL that didn't have a canonical string, fill one in. */
7575 if (sals
->nelts
> 0 && *addr_string
== NULL
)
7576 *addr_string
= xcalloc (sals
->nelts
, sizeof (char **));
7577 if (addr_start
!= (*address
))
7581 for (i
= 0; i
< sals
->nelts
; i
++)
7583 /* Add the string if not present. */
7584 if ((*addr_string
)[i
] == NULL
)
7585 (*addr_string
)[i
] = savestring (addr_start
,
7586 (*address
) - addr_start
);
7592 /* Convert each SAL into a real PC. Verify that the PC can be
7593 inserted as a breakpoint. If it can't throw an error. */
7596 breakpoint_sals_to_pc (struct symtabs_and_lines
*sals
)
7600 for (i
= 0; i
< sals
->nelts
; i
++)
7601 resolve_sal_pc (&sals
->sals
[i
]);
7604 /* Fast tracepoints may have restrictions on valid locations. For
7605 instance, a fast tracepoint using a jump instead of a trap will
7606 likely have to overwrite more bytes than a trap would, and so can
7607 only be placed where the instruction is longer than the jump, or a
7608 multi-instruction sequence does not have a jump into the middle of
7612 check_fast_tracepoint_sals (struct gdbarch
*gdbarch
,
7613 struct symtabs_and_lines
*sals
)
7616 struct symtab_and_line
*sal
;
7618 struct cleanup
*old_chain
;
7620 for (i
= 0; i
< sals
->nelts
; i
++)
7622 sal
= &sals
->sals
[i
];
7624 rslt
= gdbarch_fast_tracepoint_valid_at (gdbarch
, sal
->pc
,
7626 old_chain
= make_cleanup (xfree
, msg
);
7629 error (_("May not have a fast tracepoint at 0x%s%s"),
7630 paddress (gdbarch
, sal
->pc
), (msg
? msg
: ""));
7632 do_cleanups (old_chain
);
7637 do_captured_parse_breakpoint (struct ui_out
*ui
, void *data
)
7639 struct captured_parse_breakpoint_args
*args
= data
;
7641 parse_breakpoint_sals (args
->arg_p
, args
->sals_p
, args
->addr_string_p
,
7642 args
->not_found_ptr
);
7645 /* Given TOK, a string specification of condition and thread, as
7646 accepted by the 'break' command, extract the condition
7647 string and thread number and set *COND_STRING and *THREAD.
7648 PC identifies the context at which the condition should be parsed.
7649 If no condition is found, *COND_STRING is set to NULL.
7650 If no thread is found, *THREAD is set to -1. */
7652 find_condition_and_thread (char *tok
, CORE_ADDR pc
,
7653 char **cond_string
, int *thread
, int *task
)
7655 *cond_string
= NULL
;
7661 char *cond_start
= NULL
;
7662 char *cond_end
= NULL
;
7664 tok
= skip_spaces (tok
);
7666 end_tok
= skip_to_space (tok
);
7668 toklen
= end_tok
- tok
;
7670 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
7672 struct expression
*expr
;
7674 tok
= cond_start
= end_tok
+ 1;
7675 expr
= parse_exp_1 (&tok
, block_for_pc (pc
), 0);
7678 *cond_string
= savestring (cond_start
,
7679 cond_end
- cond_start
);
7681 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
7687 *thread
= strtol (tok
, &tok
, 0);
7689 error (_("Junk after thread keyword."));
7690 if (!valid_thread_id (*thread
))
7691 error (_("Unknown thread %d."), *thread
);
7693 else if (toklen
>= 1 && strncmp (tok
, "task", toklen
) == 0)
7699 *task
= strtol (tok
, &tok
, 0);
7701 error (_("Junk after task keyword."));
7702 if (!valid_task_id (*task
))
7703 error (_("Unknown task %d."), *task
);
7706 error (_("Junk at end of arguments."));
7710 /* Decode a static tracepoint marker spec. */
7712 static struct symtabs_and_lines
7713 decode_static_tracepoint_spec (char **arg_p
)
7715 VEC(static_tracepoint_marker_p
) *markers
= NULL
;
7716 struct symtabs_and_lines sals
;
7717 struct symtab_and_line sal
;
7719 struct cleanup
*old_chain
;
7720 char *p
= &(*arg_p
)[3];
7725 p
= skip_spaces (p
);
7727 endp
= skip_to_space (p
);
7729 marker_str
= savestring (p
, endp
- p
);
7730 old_chain
= make_cleanup (xfree
, marker_str
);
7732 markers
= target_static_tracepoint_markers_by_strid (marker_str
);
7733 if (VEC_empty(static_tracepoint_marker_p
, markers
))
7734 error (_("No known static tracepoint marker named %s"), marker_str
);
7736 sals
.nelts
= VEC_length(static_tracepoint_marker_p
, markers
);
7737 sals
.sals
= xmalloc (sizeof *sals
.sals
* sals
.nelts
);
7739 for (i
= 0; i
< sals
.nelts
; i
++)
7741 struct static_tracepoint_marker
*marker
;
7743 marker
= VEC_index (static_tracepoint_marker_p
, markers
, i
);
7745 init_sal (&sals
.sals
[i
]);
7747 sals
.sals
[i
] = find_pc_line (marker
->address
, 0);
7748 sals
.sals
[i
].pc
= marker
->address
;
7750 release_static_tracepoint_marker (marker
);
7753 do_cleanups (old_chain
);
7759 /* Set a breakpoint. This function is shared between CLI and MI
7760 functions for setting a breakpoint. This function has two major
7761 modes of operations, selected by the PARSE_CONDITION_AND_THREAD
7762 parameter. If non-zero, the function will parse arg, extracting
7763 breakpoint location, address and thread. Otherwise, ARG is just
7764 the location of breakpoint, with condition and thread specified by
7765 the COND_STRING and THREAD parameters. If INTERNAL is non-zero,
7766 the breakpoint number will be allocated from the internal
7767 breakpoint count. Returns true if any breakpoint was created;
7771 create_breakpoint (struct gdbarch
*gdbarch
,
7772 char *arg
, char *cond_string
, int thread
,
7773 int parse_condition_and_thread
,
7774 int tempflag
, enum bptype type_wanted
,
7776 enum auto_boolean pending_break_support
,
7777 struct breakpoint_ops
*ops
,
7778 int from_tty
, int enabled
, int internal
)
7780 struct gdb_exception e
;
7781 struct symtabs_and_lines sals
;
7782 struct symtab_and_line pending_sal
;
7784 char *addr_start
= arg
;
7786 struct cleanup
*old_chain
;
7787 struct cleanup
*bkpt_chain
= NULL
;
7788 struct captured_parse_breakpoint_args parse_args
;
7793 int prev_bkpt_count
= breakpoint_count
;
7799 parse_args
.arg_p
= &arg
;
7800 parse_args
.sals_p
= &sals
;
7801 parse_args
.addr_string_p
= &addr_string
;
7802 parse_args
.not_found_ptr
= ¬_found
;
7804 if (type_wanted
== bp_static_tracepoint
&& is_marker_spec (arg
))
7808 sals
= decode_static_tracepoint_spec (&arg
);
7810 copy_arg
= savestring (addr_start
, arg
- addr_start
);
7811 addr_string
= xcalloc (sals
.nelts
, sizeof (char **));
7812 for (i
= 0; i
< sals
.nelts
; i
++)
7813 addr_string
[i
] = xstrdup (copy_arg
);
7817 e
= catch_exception (uiout
, do_captured_parse_breakpoint
,
7818 &parse_args
, RETURN_MASK_ALL
);
7820 /* If caller is interested in rc value from parse, set value. */
7824 throw_exception (e
);
7828 case NOT_FOUND_ERROR
:
7830 /* If pending breakpoint support is turned off, throw
7833 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
7834 throw_exception (e
);
7836 exception_print (gdb_stderr
, e
);
7838 /* If pending breakpoint support is auto query and the user
7839 selects no, then simply return the error code. */
7840 if (pending_break_support
== AUTO_BOOLEAN_AUTO
7841 && !nquery (_("Make breakpoint pending on "
7842 "future shared library load? ")))
7845 /* At this point, either the user was queried about setting
7846 a pending breakpoint and selected yes, or pending
7847 breakpoint behavior is on and thus a pending breakpoint
7848 is defaulted on behalf of the user. */
7849 copy_arg
= xstrdup (addr_start
);
7850 addr_string
= ©_arg
;
7852 sals
.sals
= &pending_sal
;
7857 throw_exception (e
);
7867 /* Create a chain of things that always need to be cleaned up. */
7868 old_chain
= make_cleanup (null_cleanup
, 0);
7872 /* Make sure that all storage allocated to SALS gets freed. */
7873 make_cleanup (xfree
, sals
.sals
);
7875 /* Cleanup the addr_string array but not its contents. */
7876 make_cleanup (xfree
, addr_string
);
7879 /* ----------------------------- SNIP -----------------------------
7880 Anything added to the cleanup chain beyond this point is assumed
7881 to be part of a breakpoint. If the breakpoint create succeeds
7882 then the memory is not reclaimed. */
7883 bkpt_chain
= make_cleanup (null_cleanup
, 0);
7885 /* Mark the contents of the addr_string for cleanup. These go on
7886 the bkpt_chain and only occur if the breakpoint create fails. */
7887 for (i
= 0; i
< sals
.nelts
; i
++)
7889 if (addr_string
[i
] != NULL
)
7890 make_cleanup (xfree
, addr_string
[i
]);
7893 /* Resolve all line numbers to PC's and verify that the addresses
7894 are ok for the target. */
7896 breakpoint_sals_to_pc (&sals
);
7898 /* Fast tracepoints may have additional restrictions on location. */
7899 if (type_wanted
== bp_fast_tracepoint
)
7900 check_fast_tracepoint_sals (gdbarch
, &sals
);
7902 /* Verify that condition can be parsed, before setting any
7903 breakpoints. Allocate a separate condition expression for each
7907 if (parse_condition_and_thread
)
7909 /* Here we only parse 'arg' to separate condition
7910 from thread number, so parsing in context of first
7911 sal is OK. When setting the breakpoint we'll
7912 re-parse it in context of each sal. */
7915 find_condition_and_thread (arg
, sals
.sals
[0].pc
, &cond_string
,
7918 make_cleanup (xfree
, cond_string
);
7922 /* Create a private copy of condition string. */
7925 cond_string
= xstrdup (cond_string
);
7926 make_cleanup (xfree
, cond_string
);
7930 /* If the user is creating a static tracepoint by marker id
7931 (strace -m MARKER_ID), then store the sals index, so that
7932 breakpoint_re_set can try to match up which of the newly
7933 found markers corresponds to this one, and, don't try to
7934 expand multiple locations for each sal, given than SALS
7935 already should contain all sals for MARKER_ID. */
7936 if (type_wanted
== bp_static_tracepoint
7937 && is_marker_spec (addr_string
[0]))
7941 for (i
= 0; i
< sals
.nelts
; ++i
)
7943 struct symtabs_and_lines expanded
;
7944 struct breakpoint
*tp
;
7945 struct cleanup
*old_chain
;
7948 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
7949 expanded
.sals
[0] = sals
.sals
[i
];
7950 old_chain
= make_cleanup (xfree
, expanded
.sals
);
7952 create_breakpoint_sal (gdbarch
, expanded
, addr_string
[i
],
7953 cond_string
, type_wanted
,
7954 tempflag
? disp_del
: disp_donttouch
,
7955 thread
, task
, ignore_count
, ops
,
7956 from_tty
, enabled
, internal
);
7958 do_cleanups (old_chain
);
7960 /* Get the tracepoint we just created. */
7962 tp
= get_breakpoint (internal_breakpoint_number
);
7964 tp
= get_breakpoint (breakpoint_count
);
7965 gdb_assert (tp
!= NULL
);
7967 /* Given that its possible to have multiple markers with
7968 the same string id, if the user is creating a static
7969 tracepoint by marker id ("strace -m MARKER_ID"), then
7970 store the sals index, so that breakpoint_re_set can
7971 try to match up which of the newly found markers
7972 corresponds to this one */
7973 tp
->static_trace_marker_id_idx
= i
;
7977 create_breakpoints_sal (gdbarch
, sals
, addr_string
, cond_string
,
7979 tempflag
? disp_del
: disp_donttouch
,
7980 thread
, task
, ignore_count
, ops
, from_tty
,
7985 struct breakpoint
*b
;
7987 make_cleanup (xfree
, copy_arg
);
7989 b
= set_raw_breakpoint_without_location (gdbarch
, type_wanted
);
7990 set_breakpoint_number (internal
, b
);
7992 b
->addr_string
= addr_string
[0];
7993 b
->cond_string
= NULL
;
7994 b
->ignore_count
= ignore_count
;
7995 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
7996 b
->condition_not_parsed
= 1;
7998 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
7999 b
->pspace
= current_program_space
;
8000 b
->py_bp_object
= NULL
;
8002 if (enabled
&& b
->pspace
->executing_startup
8003 && (b
->type
== bp_breakpoint
8004 || b
->type
== bp_hardware_breakpoint
))
8005 b
->enable_state
= bp_startup_disabled
;
8008 /* Do not mention breakpoints with a negative number,
8009 but do notify observers. */
8010 observer_notify_breakpoint_created (b
->number
);
8017 warning (_("Multiple breakpoints were set.\nUse the "
8018 "\"delete\" command to delete unwanted breakpoints."));
8019 prev_breakpoint_count
= prev_bkpt_count
;
8022 /* That's it. Discard the cleanups for data inserted into the
8024 discard_cleanups (bkpt_chain
);
8025 /* But cleanup everything else. */
8026 do_cleanups (old_chain
);
8028 /* error call may happen here - have BKPT_CHAIN already discarded. */
8029 update_global_location_list (1);
8034 /* Set a breakpoint.
8035 ARG is a string describing breakpoint address,
8036 condition, and thread.
8037 FLAG specifies if a breakpoint is hardware on,
8038 and if breakpoint is temporary, using BP_HARDWARE_FLAG
8042 break_command_1 (char *arg
, int flag
, int from_tty
)
8044 int tempflag
= flag
& BP_TEMPFLAG
;
8045 enum bptype type_wanted
= (flag
& BP_HARDWAREFLAG
8046 ? bp_hardware_breakpoint
8049 create_breakpoint (get_current_arch (),
8051 NULL
, 0, 1 /* parse arg */,
8052 tempflag
, type_wanted
,
8053 0 /* Ignore count */,
8054 pending_break_support
,
8055 NULL
/* breakpoint_ops */,
8062 /* Helper function for break_command_1 and disassemble_command. */
8065 resolve_sal_pc (struct symtab_and_line
*sal
)
8069 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
8071 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
8072 error (_("No line %d in file \"%s\"."),
8073 sal
->line
, sal
->symtab
->filename
);
8076 /* If this SAL corresponds to a breakpoint inserted using a line
8077 number, then skip the function prologue if necessary. */
8078 if (sal
->explicit_line
)
8079 skip_prologue_sal (sal
);
8082 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
8084 struct blockvector
*bv
;
8088 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
, sal
->symtab
);
8091 sym
= block_linkage_function (b
);
8094 fixup_symbol_section (sym
, sal
->symtab
->objfile
);
8095 sal
->section
= SYMBOL_OBJ_SECTION (sym
);
8099 /* It really is worthwhile to have the section, so we'll
8100 just have to look harder. This case can be executed
8101 if we have line numbers but no functions (as can
8102 happen in assembly source). */
8104 struct minimal_symbol
*msym
;
8105 struct cleanup
*old_chain
= save_current_space_and_thread ();
8107 switch_to_program_space_and_thread (sal
->pspace
);
8109 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
8111 sal
->section
= SYMBOL_OBJ_SECTION (msym
);
8113 do_cleanups (old_chain
);
8120 break_command (char *arg
, int from_tty
)
8122 break_command_1 (arg
, 0, from_tty
);
8126 tbreak_command (char *arg
, int from_tty
)
8128 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
8132 hbreak_command (char *arg
, int from_tty
)
8134 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
8138 thbreak_command (char *arg
, int from_tty
)
8140 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
8144 stop_command (char *arg
, int from_tty
)
8146 printf_filtered (_("Specify the type of breakpoint to set.\n\
8147 Usage: stop in <function | address>\n\
8148 stop at <line>\n"));
8152 stopin_command (char *arg
, int from_tty
)
8156 if (arg
== (char *) NULL
)
8158 else if (*arg
!= '*')
8163 /* Look for a ':'. If this is a line number specification, then
8164 say it is bad, otherwise, it should be an address or
8165 function/method name. */
8166 while (*argptr
&& !hasColon
)
8168 hasColon
= (*argptr
== ':');
8173 badInput
= (*argptr
!= ':'); /* Not a class::method */
8175 badInput
= isdigit (*arg
); /* a simple line number */
8179 printf_filtered (_("Usage: stop in <function | address>\n"));
8181 break_command_1 (arg
, 0, from_tty
);
8185 stopat_command (char *arg
, int from_tty
)
8189 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
8196 /* Look for a ':'. If there is a '::' then get out, otherwise
8197 it is probably a line number. */
8198 while (*argptr
&& !hasColon
)
8200 hasColon
= (*argptr
== ':');
8205 badInput
= (*argptr
== ':'); /* we have class::method */
8207 badInput
= !isdigit (*arg
); /* not a line number */
8211 printf_filtered (_("Usage: stop at <line>\n"));
8213 break_command_1 (arg
, 0, from_tty
);
8216 /* Return non-zero if EXP is verified as constant. Returned zero
8217 means EXP is variable. Also the constant detection may fail for
8218 some constant expressions and in such case still falsely return
8221 watchpoint_exp_is_const (const struct expression
*exp
)
8229 /* We are only interested in the descriptor of each element. */
8230 operator_length (exp
, i
, &oplenp
, &argsp
);
8233 switch (exp
->elts
[i
].opcode
)
8243 case BINOP_LOGICAL_AND
:
8244 case BINOP_LOGICAL_OR
:
8245 case BINOP_BITWISE_AND
:
8246 case BINOP_BITWISE_IOR
:
8247 case BINOP_BITWISE_XOR
:
8249 case BINOP_NOTEQUAL
:
8265 case TERNOP_SLICE_COUNT
:
8277 case OP_OBJC_NSSTRING
:
8280 case UNOP_LOGICAL_NOT
:
8281 case UNOP_COMPLEMENT
:
8284 /* Unary, binary and ternary operators: We have to check
8285 their operands. If they are constant, then so is the
8286 result of that operation. For instance, if A and B are
8287 determined to be constants, then so is "A + B".
8289 UNOP_IND is one exception to the rule above, because the
8290 value of *ADDR is not necessarily a constant, even when
8295 /* Check whether the associated symbol is a constant.
8297 We use SYMBOL_CLASS rather than TYPE_CONST because it's
8298 possible that a buggy compiler could mark a variable as
8299 constant even when it is not, and TYPE_CONST would return
8300 true in this case, while SYMBOL_CLASS wouldn't.
8302 We also have to check for function symbols because they
8303 are always constant. */
8305 struct symbol
*s
= exp
->elts
[i
+ 2].symbol
;
8307 if (SYMBOL_CLASS (s
) != LOC_BLOCK
8308 && SYMBOL_CLASS (s
) != LOC_CONST
8309 && SYMBOL_CLASS (s
) != LOC_CONST_BYTES
)
8314 /* The default action is to return 0 because we are using
8315 the optimistic approach here: If we don't know something,
8316 then it is not a constant. */
8325 /* Implement the "insert" breakpoint_ops method for hardware watchpoints. */
8328 insert_watchpoint (struct bp_location
*bl
)
8330 int length
= bl
->owner
->exact
? 1 : bl
->length
;
8332 return target_insert_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
8333 bl
->owner
->cond_exp
);
8336 /* Implement the "remove" breakpoint_ops method for hardware watchpoints. */
8339 remove_watchpoint (struct bp_location
*bl
)
8341 int length
= bl
->owner
->exact
? 1 : bl
->length
;
8343 return target_remove_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
8344 bl
->owner
->cond_exp
);
8347 /* Implement the "resources_needed" breakpoint_ops method for
8348 hardware watchpoints. */
8351 resources_needed_watchpoint (const struct bp_location
*bl
)
8353 int length
= bl
->owner
->exact
? 1 : bl
->length
;
8355 return target_region_ok_for_hw_watchpoint (bl
->address
, length
);
8358 /* The breakpoint_ops structure to be used in hardware watchpoints. */
8360 static struct breakpoint_ops watchpoint_breakpoint_ops
=
8364 NULL
, /* breakpoint_hit */
8365 resources_needed_watchpoint
,
8366 NULL
, /* print_it */
8367 NULL
, /* print_one */
8368 NULL
, /* print_mention */
8369 NULL
/* print_recreate */
8372 /* accessflag: hw_write: watch write,
8373 hw_read: watch read,
8374 hw_access: watch access (read or write) */
8376 watch_command_1 (char *arg
, int accessflag
, int from_tty
,
8377 int just_location
, int internal
)
8379 struct breakpoint
*b
, *scope_breakpoint
= NULL
;
8380 struct expression
*exp
;
8381 struct block
*exp_valid_block
= NULL
, *cond_exp_valid_block
= NULL
;
8382 struct value
*val
, *mark
, *result
;
8383 struct frame_info
*frame
;
8384 char *exp_start
= NULL
;
8385 char *exp_end
= NULL
;
8386 char *tok
, *id_tok_start
, *end_tok
;
8388 char *cond_start
= NULL
;
8389 char *cond_end
= NULL
;
8390 int i
, other_type_used
, target_resources_ok
= 0;
8391 enum bptype bp_type
;
8396 /* Make sure that we actually have parameters to parse. */
8397 if (arg
!= NULL
&& arg
[0] != '\0')
8399 toklen
= strlen (arg
); /* Size of argument list. */
8401 /* Points tok to the end of the argument list. */
8402 tok
= arg
+ toklen
- 1;
8404 /* Go backwards in the parameters list. Skip the last
8405 parameter. If we're expecting a 'thread <thread_num>'
8406 parameter, this should be the thread identifier. */
8407 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
8409 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
8412 /* Points end_tok to the beginning of the last token. */
8413 id_tok_start
= tok
+ 1;
8415 /* Go backwards in the parameters list. Skip one more
8416 parameter. If we're expecting a 'thread <thread_num>'
8417 parameter, we should reach a "thread" token. */
8418 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
8423 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
8426 /* Move the pointer forward to skip the whitespace and
8427 calculate the length of the token. */
8429 toklen
= end_tok
- tok
;
8431 if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
8433 /* At this point we've found a "thread" token, which means
8434 the user is trying to set a watchpoint that triggers
8435 only in a specific thread. */
8438 /* Extract the thread ID from the next token. */
8439 thread
= strtol (id_tok_start
, &endp
, 0);
8441 /* Check if the user provided a valid numeric value for the
8443 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
8444 error (_("Invalid thread ID specification %s."), id_tok_start
);
8446 /* Check if the thread actually exists. */
8447 if (!valid_thread_id (thread
))
8448 error (_("Unknown thread %d."), thread
);
8450 /* Truncate the string and get rid of the thread <thread_num>
8451 parameter before the parameter list is parsed by the
8452 evaluate_expression() function. */
8457 /* Parse the rest of the arguments. */
8458 innermost_block
= NULL
;
8460 exp
= parse_exp_1 (&arg
, 0, 0);
8462 /* Remove trailing whitespace from the expression before saving it.
8463 This makes the eventual display of the expression string a bit
8465 while (exp_end
> exp_start
&& (exp_end
[-1] == ' ' || exp_end
[-1] == '\t'))
8468 /* Checking if the expression is not constant. */
8469 if (watchpoint_exp_is_const (exp
))
8473 len
= exp_end
- exp_start
;
8474 while (len
> 0 && isspace (exp_start
[len
- 1]))
8476 error (_("Cannot watch constant value `%.*s'."), len
, exp_start
);
8479 exp_valid_block
= innermost_block
;
8480 mark
= value_mark ();
8481 fetch_subexp_value (exp
, &pc
, &val
, &result
, NULL
);
8485 exp_valid_block
= NULL
;
8486 val
= value_addr (result
);
8487 release_value (val
);
8488 value_free_to_mark (mark
);
8490 else if (val
!= NULL
)
8491 release_value (val
);
8493 tok
= skip_spaces (arg
);
8494 end_tok
= skip_to_space (tok
);
8496 toklen
= end_tok
- tok
;
8497 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
8499 struct expression
*cond
;
8501 innermost_block
= NULL
;
8502 tok
= cond_start
= end_tok
+ 1;
8503 cond
= parse_exp_1 (&tok
, 0, 0);
8505 /* The watchpoint expression may not be local, but the condition
8506 may still be. E.g.: `watch global if local > 0'. */
8507 cond_exp_valid_block
= innermost_block
;
8513 error (_("Junk at end of command."));
8515 if (accessflag
== hw_read
)
8516 bp_type
= bp_read_watchpoint
;
8517 else if (accessflag
== hw_access
)
8518 bp_type
= bp_access_watchpoint
;
8520 bp_type
= bp_hardware_watchpoint
;
8522 reg_cnt
= can_use_hardware_watchpoint (val
, target_exact_watchpoints
);
8523 if (reg_cnt
== 0 && bp_type
!= bp_hardware_watchpoint
)
8524 error (_("Expression cannot be implemented with read/access watchpoint."));
8527 i
= hw_watchpoint_used_count (bp_type
, &other_type_used
);
8528 target_resources_ok
=
8529 target_can_use_hardware_watchpoint (bp_type
, i
+ reg_cnt
,
8531 if (target_resources_ok
== 0 && bp_type
!= bp_hardware_watchpoint
)
8532 error (_("Target does not support this type of hardware watchpoint."));
8534 if (target_resources_ok
< 0 && bp_type
!= bp_hardware_watchpoint
)
8535 error (_("Target can only support one kind "
8536 "of HW watchpoint at a time."));
8539 /* Change the type of breakpoint to an ordinary watchpoint if a
8540 hardware watchpoint could not be set. */
8541 if (!reg_cnt
|| target_resources_ok
<= 0)
8542 bp_type
= bp_watchpoint
;
8544 frame
= block_innermost_frame (exp_valid_block
);
8546 /* If the expression is "local", then set up a "watchpoint scope"
8547 breakpoint at the point where we've left the scope of the watchpoint
8548 expression. Create the scope breakpoint before the watchpoint, so
8549 that we will encounter it first in bpstat_stop_status. */
8550 if (exp_valid_block
&& frame
)
8552 if (frame_id_p (frame_unwind_caller_id (frame
)))
8555 = create_internal_breakpoint (frame_unwind_caller_arch (frame
),
8556 frame_unwind_caller_pc (frame
),
8557 bp_watchpoint_scope
);
8559 scope_breakpoint
->enable_state
= bp_enabled
;
8561 /* Automatically delete the breakpoint when it hits. */
8562 scope_breakpoint
->disposition
= disp_del
;
8564 /* Only break in the proper frame (help with recursion). */
8565 scope_breakpoint
->frame_id
= frame_unwind_caller_id (frame
);
8567 /* Set the address at which we will stop. */
8568 scope_breakpoint
->loc
->gdbarch
8569 = frame_unwind_caller_arch (frame
);
8570 scope_breakpoint
->loc
->requested_address
8571 = frame_unwind_caller_pc (frame
);
8572 scope_breakpoint
->loc
->address
8573 = adjust_breakpoint_address (scope_breakpoint
->loc
->gdbarch
,
8574 scope_breakpoint
->loc
->requested_address
,
8575 scope_breakpoint
->type
);
8579 /* Now set up the breakpoint. */
8580 b
= set_raw_breakpoint_without_location (NULL
, bp_type
);
8581 set_breakpoint_number (internal
, b
);
8583 b
->disposition
= disp_donttouch
;
8585 b
->exp_valid_block
= exp_valid_block
;
8586 b
->cond_exp_valid_block
= cond_exp_valid_block
;
8589 struct type
*t
= value_type (val
);
8590 CORE_ADDR addr
= value_as_address (val
);
8593 t
= check_typedef (TYPE_TARGET_TYPE (check_typedef (t
)));
8594 name
= type_to_string (t
);
8596 b
->exp_string_reparse
= xstrprintf ("* (%s *) %s", name
,
8597 core_addr_to_string (addr
));
8600 b
->exp_string
= xstrprintf ("-location: %.*s",
8601 (int) (exp_end
- exp_start
), exp_start
);
8603 /* The above expression is in C. */
8604 b
->language
= language_c
;
8607 b
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
8610 b
->ops
= &watchpoint_breakpoint_ops
;
8612 /* Use an exact watchpoint when there's only one memory region to be
8613 watched, and only one debug register is needed to watch it. */
8614 b
->exact
= target_exact_watchpoints
&& reg_cnt
== 1;
8617 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
8623 b
->watchpoint_frame
= get_frame_id (frame
);
8624 b
->watchpoint_thread
= inferior_ptid
;
8628 b
->watchpoint_frame
= null_frame_id
;
8629 b
->watchpoint_thread
= null_ptid
;
8632 if (scope_breakpoint
!= NULL
)
8634 /* The scope breakpoint is related to the watchpoint. We will
8635 need to act on them together. */
8636 b
->related_breakpoint
= scope_breakpoint
;
8637 scope_breakpoint
->related_breakpoint
= b
;
8641 value_free_to_mark (mark
);
8643 /* Finally update the new watchpoint. This creates the locations
8644 that should be inserted. */
8645 update_watchpoint (b
, 1);
8647 /* Do not mention breakpoints with a negative number, but do
8648 notify observers. */
8649 observer_notify_breakpoint_created (b
->number
);
8652 update_global_location_list (1);
8655 /* Return count of debug registers needed to watch the given expression.
8656 If EXACT_WATCHPOINTS is 1, then consider that only the address of
8657 the start of the watched region will be monitored (i.e., all accesses
8658 will be aligned). This uses less debug registers on some targets.
8660 If the watchpoint cannot be handled in hardware return zero. */
8663 can_use_hardware_watchpoint (struct value
*v
, int exact_watchpoints
)
8665 int found_memory_cnt
= 0;
8666 struct value
*head
= v
;
8668 /* Did the user specifically forbid us to use hardware watchpoints? */
8669 if (!can_use_hw_watchpoints
)
8672 /* Make sure that the value of the expression depends only upon
8673 memory contents, and values computed from them within GDB. If we
8674 find any register references or function calls, we can't use a
8675 hardware watchpoint.
8677 The idea here is that evaluating an expression generates a series
8678 of values, one holding the value of every subexpression. (The
8679 expression a*b+c has five subexpressions: a, b, a*b, c, and
8680 a*b+c.) GDB's values hold almost enough information to establish
8681 the criteria given above --- they identify memory lvalues,
8682 register lvalues, computed values, etcetera. So we can evaluate
8683 the expression, and then scan the chain of values that leaves
8684 behind to decide whether we can detect any possible change to the
8685 expression's final value using only hardware watchpoints.
8687 However, I don't think that the values returned by inferior
8688 function calls are special in any way. So this function may not
8689 notice that an expression involving an inferior function call
8690 can't be watched with hardware watchpoints. FIXME. */
8691 for (; v
; v
= value_next (v
))
8693 if (VALUE_LVAL (v
) == lval_memory
)
8695 if (v
!= head
&& value_lazy (v
))
8696 /* A lazy memory lvalue in the chain is one that GDB never
8697 needed to fetch; we either just used its address (e.g.,
8698 `a' in `a.b') or we never needed it at all (e.g., `a'
8699 in `a,b'). This doesn't apply to HEAD; if that is
8700 lazy then it was not readable, but watch it anyway. */
8704 /* Ahh, memory we actually used! Check if we can cover
8705 it with hardware watchpoints. */
8706 struct type
*vtype
= check_typedef (value_type (v
));
8708 /* We only watch structs and arrays if user asked for it
8709 explicitly, never if they just happen to appear in a
8710 middle of some value chain. */
8712 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
8713 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
8715 CORE_ADDR vaddr
= value_address (v
);
8719 len
= (exact_watchpoints
8720 && is_scalar_type_recursive (vtype
))?
8721 1 : TYPE_LENGTH (value_type (v
));
8723 num_regs
= target_region_ok_for_hw_watchpoint (vaddr
, len
);
8727 found_memory_cnt
+= num_regs
;
8731 else if (VALUE_LVAL (v
) != not_lval
8732 && deprecated_value_modifiable (v
) == 0)
8733 return 0; /* These are values from the history (e.g., $1). */
8734 else if (VALUE_LVAL (v
) == lval_register
)
8735 return 0; /* Cannot watch a register with a HW watchpoint. */
8738 /* The expression itself looks suitable for using a hardware
8739 watchpoint, but give the target machine a chance to reject it. */
8740 return found_memory_cnt
;
8744 watch_command_wrapper (char *arg
, int from_tty
, int internal
)
8746 watch_command_1 (arg
, hw_write
, from_tty
, 0, internal
);
8749 /* A helper function that looks for an argument at the start of a
8750 string. The argument must also either be at the end of the string,
8751 or be followed by whitespace. Returns 1 if it finds the argument,
8752 0 otherwise. If the argument is found, it updates *STR. */
8755 check_for_argument (char **str
, char *arg
, int arg_len
)
8757 if (strncmp (*str
, arg
, arg_len
) == 0
8758 && ((*str
)[arg_len
] == '\0' || isspace ((*str
)[arg_len
])))
8766 /* A helper function that looks for the "-location" argument and then
8767 calls watch_command_1. */
8770 watch_maybe_just_location (char *arg
, int accessflag
, int from_tty
)
8772 int just_location
= 0;
8775 && (check_for_argument (&arg
, "-location", sizeof ("-location") - 1)
8776 || check_for_argument (&arg
, "-l", sizeof ("-l") - 1)))
8778 arg
= skip_spaces (arg
);
8782 watch_command_1 (arg
, accessflag
, from_tty
, just_location
, 0);
8786 watch_command (char *arg
, int from_tty
)
8788 watch_maybe_just_location (arg
, hw_write
, from_tty
);
8792 rwatch_command_wrapper (char *arg
, int from_tty
, int internal
)
8794 watch_command_1 (arg
, hw_read
, from_tty
, 0, internal
);
8798 rwatch_command (char *arg
, int from_tty
)
8800 watch_maybe_just_location (arg
, hw_read
, from_tty
);
8804 awatch_command_wrapper (char *arg
, int from_tty
, int internal
)
8806 watch_command_1 (arg
, hw_access
, from_tty
, 0, internal
);
8810 awatch_command (char *arg
, int from_tty
)
8812 watch_maybe_just_location (arg
, hw_access
, from_tty
);
8816 /* Helper routines for the until_command routine in infcmd.c. Here
8817 because it uses the mechanisms of breakpoints. */
8819 struct until_break_command_continuation_args
8821 struct breakpoint
*breakpoint
;
8822 struct breakpoint
*breakpoint2
;
8826 /* This function is called by fetch_inferior_event via the
8827 cmd_continuation pointer, to complete the until command. It takes
8828 care of cleaning up the temporary breakpoints set up by the until
8831 until_break_command_continuation (void *arg
)
8833 struct until_break_command_continuation_args
*a
= arg
;
8835 delete_breakpoint (a
->breakpoint
);
8837 delete_breakpoint (a
->breakpoint2
);
8838 delete_longjmp_breakpoint (a
->thread_num
);
8842 until_break_command (char *arg
, int from_tty
, int anywhere
)
8844 struct symtabs_and_lines sals
;
8845 struct symtab_and_line sal
;
8846 struct frame_info
*frame
= get_selected_frame (NULL
);
8847 struct breakpoint
*breakpoint
;
8848 struct breakpoint
*breakpoint2
= NULL
;
8849 struct cleanup
*old_chain
;
8851 struct thread_info
*tp
;
8853 clear_proceed_status ();
8855 /* Set a breakpoint where the user wants it and at return from
8858 if (default_breakpoint_valid
)
8859 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
8860 default_breakpoint_line
, (char ***) NULL
, NULL
);
8862 sals
= decode_line_1 (&arg
, 1, (struct symtab
*) NULL
,
8863 0, (char ***) NULL
, NULL
);
8865 if (sals
.nelts
!= 1)
8866 error (_("Couldn't get information on specified line."));
8869 xfree (sals
.sals
); /* malloc'd, so freed. */
8872 error (_("Junk at end of arguments."));
8874 resolve_sal_pc (&sal
);
8877 /* If the user told us to continue until a specified location,
8878 we don't specify a frame at which we need to stop. */
8879 breakpoint
= set_momentary_breakpoint (get_frame_arch (frame
), sal
,
8880 null_frame_id
, bp_until
);
8882 /* Otherwise, specify the selected frame, because we want to stop
8883 only at the very same frame. */
8884 breakpoint
= set_momentary_breakpoint (get_frame_arch (frame
), sal
,
8885 get_stack_frame_id (frame
),
8888 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
8890 tp
= inferior_thread ();
8893 /* Keep within the current frame, or in frames called by the current
8896 if (frame_id_p (frame_unwind_caller_id (frame
)))
8898 sal
= find_pc_line (frame_unwind_caller_pc (frame
), 0);
8899 sal
.pc
= frame_unwind_caller_pc (frame
);
8900 breakpoint2
= set_momentary_breakpoint (frame_unwind_caller_arch (frame
),
8902 frame_unwind_caller_id (frame
),
8904 make_cleanup_delete_breakpoint (breakpoint2
);
8906 set_longjmp_breakpoint (tp
, frame_unwind_caller_id (frame
));
8907 make_cleanup (delete_longjmp_breakpoint_cleanup
, &thread
);
8910 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
8912 /* If we are running asynchronously, and proceed call above has
8913 actually managed to start the target, arrange for breakpoints to
8914 be deleted when the target stops. Otherwise, we're already
8915 stopped and delete breakpoints via cleanup chain. */
8917 if (target_can_async_p () && is_running (inferior_ptid
))
8919 struct until_break_command_continuation_args
*args
;
8920 args
= xmalloc (sizeof (*args
));
8922 args
->breakpoint
= breakpoint
;
8923 args
->breakpoint2
= breakpoint2
;
8924 args
->thread_num
= thread
;
8926 discard_cleanups (old_chain
);
8927 add_continuation (inferior_thread (),
8928 until_break_command_continuation
, args
,
8932 do_cleanups (old_chain
);
8935 /* This function attempts to parse an optional "if <cond>" clause
8936 from the arg string. If one is not found, it returns NULL.
8938 Else, it returns a pointer to the condition string. (It does not
8939 attempt to evaluate the string against a particular block.) And,
8940 it updates arg to point to the first character following the parsed
8941 if clause in the arg string. */
8944 ep_parse_optional_if_clause (char **arg
)
8948 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
8951 /* Skip the "if" keyword. */
8954 /* Skip any extra leading whitespace, and record the start of the
8955 condition string. */
8956 *arg
= skip_spaces (*arg
);
8959 /* Assume that the condition occupies the remainder of the arg
8961 (*arg
) += strlen (cond_string
);
8966 /* Commands to deal with catching events, such as signals, exceptions,
8967 process start/exit, etc. */
8971 catch_fork_temporary
, catch_vfork_temporary
,
8972 catch_fork_permanent
, catch_vfork_permanent
8977 catch_fork_command_1 (char *arg
, int from_tty
,
8978 struct cmd_list_element
*command
)
8980 struct gdbarch
*gdbarch
= get_current_arch ();
8981 char *cond_string
= NULL
;
8982 catch_fork_kind fork_kind
;
8985 fork_kind
= (catch_fork_kind
) (uintptr_t) get_cmd_context (command
);
8986 tempflag
= (fork_kind
== catch_fork_temporary
8987 || fork_kind
== catch_vfork_temporary
);
8991 arg
= skip_spaces (arg
);
8993 /* The allowed syntax is:
8995 catch [v]fork if <cond>
8997 First, check if there's an if clause. */
8998 cond_string
= ep_parse_optional_if_clause (&arg
);
9000 if ((*arg
!= '\0') && !isspace (*arg
))
9001 error (_("Junk at end of arguments."));
9003 /* If this target supports it, create a fork or vfork catchpoint
9004 and enable reporting of such events. */
9007 case catch_fork_temporary
:
9008 case catch_fork_permanent
:
9009 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
9010 &catch_fork_breakpoint_ops
);
9012 case catch_vfork_temporary
:
9013 case catch_vfork_permanent
:
9014 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
9015 &catch_vfork_breakpoint_ops
);
9018 error (_("unsupported or unknown fork kind; cannot catch it"));
9024 catch_exec_command_1 (char *arg
, int from_tty
,
9025 struct cmd_list_element
*command
)
9027 struct gdbarch
*gdbarch
= get_current_arch ();
9029 char *cond_string
= NULL
;
9031 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
9035 arg
= skip_spaces (arg
);
9037 /* The allowed syntax is:
9039 catch exec if <cond>
9041 First, check if there's an if clause. */
9042 cond_string
= ep_parse_optional_if_clause (&arg
);
9044 if ((*arg
!= '\0') && !isspace (*arg
))
9045 error (_("Junk at end of arguments."));
9047 /* If this target supports it, create an exec catchpoint
9048 and enable reporting of such events. */
9049 create_catchpoint (gdbarch
, tempflag
, cond_string
,
9050 &catch_exec_breakpoint_ops
);
9053 static enum print_stop_action
9054 print_exception_catchpoint (struct breakpoint
*b
)
9056 int bp_temp
, bp_throw
;
9058 annotate_catchpoint (b
->number
);
9060 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
9061 if (b
->loc
->address
!= b
->loc
->requested_address
)
9062 breakpoint_adjustment_warning (b
->loc
->requested_address
,
9065 bp_temp
= b
->disposition
== disp_del
;
9067 bp_temp
? "Temporary catchpoint "
9069 if (!ui_out_is_mi_like_p (uiout
))
9070 ui_out_field_int (uiout
, "bkptno", b
->number
);
9072 bp_throw
? " (exception thrown), "
9073 : " (exception caught), ");
9074 if (ui_out_is_mi_like_p (uiout
))
9076 ui_out_field_string (uiout
, "reason",
9077 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
9078 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
9079 ui_out_field_int (uiout
, "bkptno", b
->number
);
9081 return PRINT_SRC_AND_LOC
;
9085 print_one_exception_catchpoint (struct breakpoint
*b
,
9086 struct bp_location
**last_loc
)
9088 struct value_print_options opts
;
9090 get_user_print_options (&opts
);
9091 if (opts
.addressprint
)
9094 if (b
->loc
== NULL
|| b
->loc
->shlib_disabled
)
9095 ui_out_field_string (uiout
, "addr", "<PENDING>");
9097 ui_out_field_core_addr (uiout
, "addr",
9098 b
->loc
->gdbarch
, b
->loc
->address
);
9103 if (strstr (b
->addr_string
, "throw") != NULL
)
9104 ui_out_field_string (uiout
, "what", "exception throw");
9106 ui_out_field_string (uiout
, "what", "exception catch");
9110 print_mention_exception_catchpoint (struct breakpoint
*b
)
9115 bp_temp
= b
->disposition
== disp_del
;
9116 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
9117 ui_out_text (uiout
, bp_temp
? _("Temporary catchpoint ")
9118 : _("Catchpoint "));
9119 ui_out_field_int (uiout
, "bkptno", b
->number
);
9120 ui_out_text (uiout
, bp_throw
? _(" (throw)")
9124 /* Implement the "print_recreate" breakpoint_ops method for throw and
9125 catch catchpoints. */
9128 print_recreate_exception_catchpoint (struct breakpoint
*b
,
9134 bp_temp
= b
->disposition
== disp_del
;
9135 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
9136 fprintf_unfiltered (fp
, bp_temp
? "tcatch " : "catch ");
9137 fprintf_unfiltered (fp
, bp_throw
? "throw" : "catch");
9140 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops
= {
9143 NULL
, /* breakpoint_hit */
9144 NULL
, /* resources_needed */
9145 print_exception_catchpoint
,
9146 print_one_exception_catchpoint
,
9147 print_mention_exception_catchpoint
,
9148 print_recreate_exception_catchpoint
9152 handle_gnu_v3_exceptions (int tempflag
, char *cond_string
,
9153 enum exception_event_kind ex_event
, int from_tty
)
9155 char *trigger_func_name
;
9157 if (ex_event
== EX_EVENT_CATCH
)
9158 trigger_func_name
= "__cxa_begin_catch";
9160 trigger_func_name
= "__cxa_throw";
9162 create_breakpoint (get_current_arch (),
9163 trigger_func_name
, cond_string
, -1,
9164 0 /* condition and thread are valid. */,
9165 tempflag
, bp_breakpoint
,
9167 AUTO_BOOLEAN_TRUE
/* pending */,
9168 &gnu_v3_exception_catchpoint_ops
, from_tty
,
9175 /* Deal with "catch catch" and "catch throw" commands. */
9178 catch_exception_command_1 (enum exception_event_kind ex_event
, char *arg
,
9179 int tempflag
, int from_tty
)
9181 char *cond_string
= NULL
;
9185 arg
= skip_spaces (arg
);
9187 cond_string
= ep_parse_optional_if_clause (&arg
);
9189 if ((*arg
!= '\0') && !isspace (*arg
))
9190 error (_("Junk at end of arguments."));
9192 if (ex_event
!= EX_EVENT_THROW
9193 && ex_event
!= EX_EVENT_CATCH
)
9194 error (_("Unsupported or unknown exception event; cannot catch it"));
9196 if (handle_gnu_v3_exceptions (tempflag
, cond_string
, ex_event
, from_tty
))
9199 warning (_("Unsupported with this platform/compiler combination."));
9202 /* Implementation of "catch catch" command. */
9205 catch_catch_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
9207 int tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
9209 catch_exception_command_1 (EX_EVENT_CATCH
, arg
, tempflag
, from_tty
);
9212 /* Implementation of "catch throw" command. */
9215 catch_throw_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
9217 int tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
9219 catch_exception_command_1 (EX_EVENT_THROW
, arg
, tempflag
, from_tty
);
9222 /* Create a breakpoint struct for Ada exception catchpoints. */
9225 create_ada_exception_breakpoint (struct gdbarch
*gdbarch
,
9226 struct symtab_and_line sal
,
9230 struct expression
*cond
,
9231 struct breakpoint_ops
*ops
,
9235 struct breakpoint
*b
;
9239 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
9241 loc_gdbarch
= gdbarch
;
9243 describe_other_breakpoints (loc_gdbarch
,
9244 sal
.pspace
, sal
.pc
, sal
.section
, -1);
9245 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
9246 version for exception catchpoints, because two catchpoints
9247 used for different exception names will use the same address.
9248 In this case, a "breakpoint ... also set at..." warning is
9249 unproductive. Besides, the warning phrasing is also a bit
9250 inapropriate, we should use the word catchpoint, and tell
9251 the user what type of catchpoint it is. The above is good
9252 enough for now, though. */
9255 b
= set_raw_breakpoint (gdbarch
, sal
, bp_breakpoint
);
9256 set_breakpoint_count (breakpoint_count
+ 1);
9258 b
->enable_state
= bp_enabled
;
9259 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
9260 b
->number
= breakpoint_count
;
9261 b
->ignore_count
= 0;
9262 b
->loc
->cond
= cond
;
9263 b
->addr_string
= addr_string
;
9264 b
->language
= language_ada
;
9265 b
->cond_string
= cond_string
;
9266 b
->exp_string
= exp_string
;
9271 update_global_location_list (1);
9274 /* Implement the "catch exception" command. */
9277 catch_ada_exception_command (char *arg
, int from_tty
,
9278 struct cmd_list_element
*command
)
9280 struct gdbarch
*gdbarch
= get_current_arch ();
9282 struct symtab_and_line sal
;
9283 char *addr_string
= NULL
;
9284 char *exp_string
= NULL
;
9285 char *cond_string
= NULL
;
9286 struct expression
*cond
= NULL
;
9287 struct breakpoint_ops
*ops
= NULL
;
9289 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
9293 sal
= ada_decode_exception_location (arg
, &addr_string
, &exp_string
,
9294 &cond_string
, &cond
, &ops
);
9295 create_ada_exception_breakpoint (gdbarch
, sal
, addr_string
, exp_string
,
9296 cond_string
, cond
, ops
, tempflag
,
9300 /* Cleanup function for a syscall filter list. */
9302 clean_up_filters (void *arg
)
9304 VEC(int) *iter
= *(VEC(int) **) arg
;
9305 VEC_free (int, iter
);
9308 /* Splits the argument using space as delimiter. Returns an xmalloc'd
9309 filter list, or NULL if no filtering is required. */
9311 catch_syscall_split_args (char *arg
)
9313 VEC(int) *result
= NULL
;
9314 struct cleanup
*cleanup
= make_cleanup (clean_up_filters
, &result
);
9316 while (*arg
!= '\0')
9318 int i
, syscall_number
;
9323 /* Skip whitespace. */
9324 while (isspace (*arg
))
9327 for (i
= 0; i
< 127 && arg
[i
] && !isspace (arg
[i
]); ++i
)
9328 cur_name
[i
] = arg
[i
];
9332 /* Check if the user provided a syscall name or a number. */
9333 syscall_number
= (int) strtol (cur_name
, &endptr
, 0);
9334 if (*endptr
== '\0')
9335 get_syscall_by_number (syscall_number
, &s
);
9338 /* We have a name. Let's check if it's valid and convert it
9340 get_syscall_by_name (cur_name
, &s
);
9342 if (s
.number
== UNKNOWN_SYSCALL
)
9343 /* Here we have to issue an error instead of a warning,
9344 because GDB cannot do anything useful if there's no
9345 syscall number to be caught. */
9346 error (_("Unknown syscall name '%s'."), cur_name
);
9349 /* Ok, it's valid. */
9350 VEC_safe_push (int, result
, s
.number
);
9353 discard_cleanups (cleanup
);
9357 /* Implement the "catch syscall" command. */
9360 catch_syscall_command_1 (char *arg
, int from_tty
,
9361 struct cmd_list_element
*command
)
9366 struct gdbarch
*gdbarch
= get_current_arch ();
9368 /* Checking if the feature if supported. */
9369 if (gdbarch_get_syscall_number_p (gdbarch
) == 0)
9370 error (_("The feature 'catch syscall' is not supported on \
9371 this architecture yet."));
9373 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
9375 arg
= skip_spaces (arg
);
9377 /* We need to do this first "dummy" translation in order
9378 to get the syscall XML file loaded or, most important,
9379 to display a warning to the user if there's no XML file
9380 for his/her architecture. */
9381 get_syscall_by_number (0, &s
);
9383 /* The allowed syntax is:
9385 catch syscall <name | number> [<name | number> ... <name | number>]
9387 Let's check if there's a syscall name. */
9390 filter
= catch_syscall_split_args (arg
);
9394 create_syscall_event_catchpoint (tempflag
, filter
,
9395 &catch_syscall_breakpoint_ops
);
9398 /* Implement the "catch assert" command. */
9401 catch_assert_command (char *arg
, int from_tty
,
9402 struct cmd_list_element
*command
)
9404 struct gdbarch
*gdbarch
= get_current_arch ();
9406 struct symtab_and_line sal
;
9407 char *addr_string
= NULL
;
9408 struct breakpoint_ops
*ops
= NULL
;
9410 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
9414 sal
= ada_decode_assert_location (arg
, &addr_string
, &ops
);
9415 create_ada_exception_breakpoint (gdbarch
, sal
, addr_string
, NULL
, NULL
, NULL
,
9416 ops
, tempflag
, from_tty
);
9420 catch_command (char *arg
, int from_tty
)
9422 error (_("Catch requires an event name."));
9427 tcatch_command (char *arg
, int from_tty
)
9429 error (_("Catch requires an event name."));
9432 /* Delete breakpoints by address or line. */
9435 clear_command (char *arg
, int from_tty
)
9437 struct breakpoint
*b
;
9438 VEC(breakpoint_p
) *found
= 0;
9441 struct symtabs_and_lines sals
;
9442 struct symtab_and_line sal
;
9447 sals
= decode_line_spec (arg
, 1);
9452 sals
.sals
= (struct symtab_and_line
*)
9453 xmalloc (sizeof (struct symtab_and_line
));
9454 make_cleanup (xfree
, sals
.sals
);
9455 init_sal (&sal
); /* Initialize to zeroes. */
9456 sal
.line
= default_breakpoint_line
;
9457 sal
.symtab
= default_breakpoint_symtab
;
9458 sal
.pc
= default_breakpoint_address
;
9459 sal
.pspace
= default_breakpoint_pspace
;
9460 if (sal
.symtab
== 0)
9461 error (_("No source file specified."));
9469 /* We don't call resolve_sal_pc here. That's not as bad as it
9470 seems, because all existing breakpoints typically have both
9471 file/line and pc set. So, if clear is given file/line, we can
9472 match this to existing breakpoint without obtaining pc at all.
9474 We only support clearing given the address explicitly
9475 present in breakpoint table. Say, we've set breakpoint
9476 at file:line. There were several PC values for that file:line,
9477 due to optimization, all in one block.
9479 We've picked one PC value. If "clear" is issued with another
9480 PC corresponding to the same file:line, the breakpoint won't
9481 be cleared. We probably can still clear the breakpoint, but
9482 since the other PC value is never presented to user, user
9483 can only find it by guessing, and it does not seem important
9486 /* For each line spec given, delete bps which correspond to it. Do
9487 it in two passes, solely to preserve the current behavior that
9488 from_tty is forced true if we delete more than one
9492 for (i
= 0; i
< sals
.nelts
; i
++)
9494 /* If exact pc given, clear bpts at that pc.
9495 If line given (pc == 0), clear all bpts on specified line.
9496 If defaulting, clear all bpts on default line
9499 defaulting sal.pc != 0 tests to do
9504 1 0 <can't happen> */
9508 /* Find all matching breakpoints and add them to 'found'. */
9512 /* Are we going to delete b? */
9513 if (b
->type
!= bp_none
&& !is_watchpoint (b
))
9515 struct bp_location
*loc
= b
->loc
;
9516 for (; loc
; loc
= loc
->next
)
9518 int pc_match
= sal
.pc
9519 && (loc
->pspace
== sal
.pspace
)
9520 && (loc
->address
== sal
.pc
)
9521 && (!section_is_overlay (loc
->section
)
9522 || loc
->section
== sal
.section
);
9523 int line_match
= ((default_match
|| (0 == sal
.pc
))
9524 && b
->source_file
!= NULL
9525 && sal
.symtab
!= NULL
9526 && sal
.pspace
== loc
->pspace
9527 && strcmp (b
->source_file
,
9528 sal
.symtab
->filename
) == 0
9529 && b
->line_number
== sal
.line
);
9530 if (pc_match
|| line_match
)
9539 VEC_safe_push(breakpoint_p
, found
, b
);
9542 /* Now go thru the 'found' chain and delete them. */
9543 if (VEC_empty(breakpoint_p
, found
))
9546 error (_("No breakpoint at %s."), arg
);
9548 error (_("No breakpoint at this line."));
9551 if (VEC_length(breakpoint_p
, found
) > 1)
9552 from_tty
= 1; /* Always report if deleted more than one. */
9555 if (VEC_length(breakpoint_p
, found
) == 1)
9556 printf_unfiltered (_("Deleted breakpoint "));
9558 printf_unfiltered (_("Deleted breakpoints "));
9560 breakpoints_changed ();
9562 for (ix
= 0; VEC_iterate(breakpoint_p
, found
, ix
, b
); ix
++)
9565 printf_unfiltered ("%d ", b
->number
);
9566 delete_breakpoint (b
);
9569 putchar_unfiltered ('\n');
9572 /* Delete breakpoint in BS if they are `delete' breakpoints and
9573 all breakpoints that are marked for deletion, whether hit or not.
9574 This is called after any breakpoint is hit, or after errors. */
9577 breakpoint_auto_delete (bpstat bs
)
9579 struct breakpoint
*b
, *b_tmp
;
9581 for (; bs
; bs
= bs
->next
)
9582 if (bs
->breakpoint_at
9583 && bs
->breakpoint_at
->disposition
== disp_del
9585 delete_breakpoint (bs
->breakpoint_at
);
9587 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
9589 if (b
->disposition
== disp_del_at_next_stop
)
9590 delete_breakpoint (b
);
9594 /* A comparison function for bp_location AP and BP being interfaced to
9595 qsort. Sort elements primarily by their ADDRESS (no matter what
9596 does breakpoint_address_is_meaningful say for its OWNER),
9597 secondarily by ordering first bp_permanent OWNERed elements and
9598 terciarily just ensuring the array is sorted stable way despite
9599 qsort being an instable algorithm. */
9602 bp_location_compare (const void *ap
, const void *bp
)
9604 struct bp_location
*a
= *(void **) ap
;
9605 struct bp_location
*b
= *(void **) bp
;
9606 /* A and B come from existing breakpoints having non-NULL OWNER. */
9607 int a_perm
= a
->owner
->enable_state
== bp_permanent
;
9608 int b_perm
= b
->owner
->enable_state
== bp_permanent
;
9610 if (a
->address
!= b
->address
)
9611 return (a
->address
> b
->address
) - (a
->address
< b
->address
);
9613 /* Sort permanent breakpoints first. */
9614 if (a_perm
!= b_perm
)
9615 return (a_perm
< b_perm
) - (a_perm
> b_perm
);
9617 /* Make the user-visible order stable across GDB runs. Locations of
9618 the same breakpoint can be sorted in arbitrary order. */
9620 if (a
->owner
->number
!= b
->owner
->number
)
9621 return (a
->owner
->number
> b
->owner
->number
)
9622 - (a
->owner
->number
< b
->owner
->number
);
9624 return (a
> b
) - (a
< b
);
9627 /* Set bp_location_placed_address_before_address_max and
9628 bp_location_shadow_len_after_address_max according to the current
9629 content of the bp_location array. */
9632 bp_location_target_extensions_update (void)
9634 struct bp_location
*bl
, **blp_tmp
;
9636 bp_location_placed_address_before_address_max
= 0;
9637 bp_location_shadow_len_after_address_max
= 0;
9639 ALL_BP_LOCATIONS (bl
, blp_tmp
)
9641 CORE_ADDR start
, end
, addr
;
9643 if (!bp_location_has_shadow (bl
))
9646 start
= bl
->target_info
.placed_address
;
9647 end
= start
+ bl
->target_info
.shadow_len
;
9649 gdb_assert (bl
->address
>= start
);
9650 addr
= bl
->address
- start
;
9651 if (addr
> bp_location_placed_address_before_address_max
)
9652 bp_location_placed_address_before_address_max
= addr
;
9654 /* Zero SHADOW_LEN would not pass bp_location_has_shadow. */
9656 gdb_assert (bl
->address
< end
);
9657 addr
= end
- bl
->address
;
9658 if (addr
> bp_location_shadow_len_after_address_max
)
9659 bp_location_shadow_len_after_address_max
= addr
;
9663 /* If SHOULD_INSERT is false, do not insert any breakpoint locations
9664 into the inferior, only remove already-inserted locations that no
9665 longer should be inserted. Functions that delete a breakpoint or
9666 breakpoints should pass false, so that deleting a breakpoint
9667 doesn't have the side effect of inserting the locations of other
9668 breakpoints that are marked not-inserted, but should_be_inserted
9669 returns true on them.
9671 This behaviour is useful is situations close to tear-down -- e.g.,
9672 after an exec, while the target still has execution, but breakpoint
9673 shadows of the previous executable image should *NOT* be restored
9674 to the new image; or before detaching, where the target still has
9675 execution and wants to delete breakpoints from GDB's lists, and all
9676 breakpoints had already been removed from the inferior. */
9679 update_global_location_list (int should_insert
)
9681 struct breakpoint
*b
;
9682 struct bp_location
**locp
, *loc
;
9683 struct cleanup
*cleanups
;
9685 /* Used in the duplicates detection below. When iterating over all
9686 bp_locations, points to the first bp_location of a given address.
9687 Breakpoints and watchpoints of different types are never
9688 duplicates of each other. Keep one pointer for each type of
9689 breakpoint/watchpoint, so we only need to loop over all locations
9691 struct bp_location
*bp_loc_first
; /* breakpoint */
9692 struct bp_location
*wp_loc_first
; /* hardware watchpoint */
9693 struct bp_location
*awp_loc_first
; /* access watchpoint */
9694 struct bp_location
*rwp_loc_first
; /* read watchpoint */
9696 /* Saved former bp_location array which we compare against the newly
9697 built bp_location from the current state of ALL_BREAKPOINTS. */
9698 struct bp_location
**old_location
, **old_locp
;
9699 unsigned old_location_count
;
9701 old_location
= bp_location
;
9702 old_location_count
= bp_location_count
;
9704 bp_location_count
= 0;
9705 cleanups
= make_cleanup (xfree
, old_location
);
9708 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
9709 bp_location_count
++;
9711 bp_location
= xmalloc (sizeof (*bp_location
) * bp_location_count
);
9714 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
9716 qsort (bp_location
, bp_location_count
, sizeof (*bp_location
),
9717 bp_location_compare
);
9719 bp_location_target_extensions_update ();
9721 /* Identify bp_location instances that are no longer present in the
9722 new list, and therefore should be freed. Note that it's not
9723 necessary that those locations should be removed from inferior --
9724 if there's another location at the same address (previously
9725 marked as duplicate), we don't need to remove/insert the
9728 LOCP is kept in sync with OLD_LOCP, each pointing to the current
9729 and former bp_location array state respectively. */
9732 for (old_locp
= old_location
; old_locp
< old_location
+ old_location_count
;
9735 struct bp_location
*old_loc
= *old_locp
;
9736 struct bp_location
**loc2p
;
9738 /* Tells if 'old_loc' is found amoung the new locations. If
9739 not, we have to free it. */
9740 int found_object
= 0;
9741 /* Tells if the location should remain inserted in the target. */
9742 int keep_in_target
= 0;
9745 /* Skip LOCP entries which will definitely never be needed.
9746 Stop either at or being the one matching OLD_LOC. */
9747 while (locp
< bp_location
+ bp_location_count
9748 && (*locp
)->address
< old_loc
->address
)
9752 (loc2p
< bp_location
+ bp_location_count
9753 && (*loc2p
)->address
== old_loc
->address
);
9756 if (*loc2p
== old_loc
)
9763 /* If this location is no longer present, and inserted, look if
9764 there's maybe a new location at the same address. If so,
9765 mark that one inserted, and don't remove this one. This is
9766 needed so that we don't have a time window where a breakpoint
9767 at certain location is not inserted. */
9769 if (old_loc
->inserted
)
9771 /* If the location is inserted now, we might have to remove
9774 if (found_object
&& should_be_inserted (old_loc
))
9776 /* The location is still present in the location list,
9777 and still should be inserted. Don't do anything. */
9782 /* The location is either no longer present, or got
9783 disabled. See if there's another location at the
9784 same address, in which case we don't need to remove
9785 this one from the target. */
9787 /* OLD_LOC comes from existing struct breakpoint. */
9788 if (breakpoint_address_is_meaningful (old_loc
->owner
))
9791 (loc2p
< bp_location
+ bp_location_count
9792 && (*loc2p
)->address
== old_loc
->address
);
9795 struct bp_location
*loc2
= *loc2p
;
9797 if (breakpoint_locations_match (loc2
, old_loc
))
9799 /* For the sake of should_be_inserted.
9800 Duplicates check below will fix up this
9802 loc2
->duplicate
= 0;
9804 /* Read watchpoint locations are switched to
9805 access watchpoints, if the former are not
9806 supported, but the latter are. */
9807 if (is_hardware_watchpoint (old_loc
->owner
))
9809 gdb_assert (is_hardware_watchpoint (loc2
->owner
));
9810 loc2
->watchpoint_type
= old_loc
->watchpoint_type
;
9813 if (loc2
!= old_loc
&& should_be_inserted (loc2
))
9816 loc2
->target_info
= old_loc
->target_info
;
9825 if (!keep_in_target
)
9827 if (remove_breakpoint (old_loc
, mark_uninserted
))
9829 /* This is just about all we can do. We could keep
9830 this location on the global list, and try to
9831 remove it next time, but there's no particular
9832 reason why we will succeed next time.
9834 Note that at this point, old_loc->owner is still
9835 valid, as delete_breakpoint frees the breakpoint
9836 only after calling us. */
9837 printf_filtered (_("warning: Error removing "
9839 old_loc
->owner
->number
);
9847 if (removed
&& non_stop
9848 && breakpoint_address_is_meaningful (old_loc
->owner
)
9849 && !is_hardware_watchpoint (old_loc
->owner
))
9851 /* This location was removed from the target. In
9852 non-stop mode, a race condition is possible where
9853 we've removed a breakpoint, but stop events for that
9854 breakpoint are already queued and will arrive later.
9855 We apply an heuristic to be able to distinguish such
9856 SIGTRAPs from other random SIGTRAPs: we keep this
9857 breakpoint location for a bit, and will retire it
9858 after we see some number of events. The theory here
9859 is that reporting of events should, "on the average",
9860 be fair, so after a while we'll see events from all
9861 threads that have anything of interest, and no longer
9862 need to keep this breakpoint location around. We
9863 don't hold locations forever so to reduce chances of
9864 mistaking a non-breakpoint SIGTRAP for a breakpoint
9867 The heuristic failing can be disastrous on
9868 decr_pc_after_break targets.
9870 On decr_pc_after_break targets, like e.g., x86-linux,
9871 if we fail to recognize a late breakpoint SIGTRAP,
9872 because events_till_retirement has reached 0 too
9873 soon, we'll fail to do the PC adjustment, and report
9874 a random SIGTRAP to the user. When the user resumes
9875 the inferior, it will most likely immediately crash
9876 with SIGILL/SIGBUS/SIGSEGV, or worse, get silently
9877 corrupted, because of being resumed e.g., in the
9878 middle of a multi-byte instruction, or skipped a
9879 one-byte instruction. This was actually seen happen
9880 on native x86-linux, and should be less rare on
9881 targets that do not support new thread events, like
9882 remote, due to the heuristic depending on
9885 Mistaking a random SIGTRAP for a breakpoint trap
9886 causes similar symptoms (PC adjustment applied when
9887 it shouldn't), but then again, playing with SIGTRAPs
9888 behind the debugger's back is asking for trouble.
9890 Since hardware watchpoint traps are always
9891 distinguishable from other traps, so we don't need to
9892 apply keep hardware watchpoint moribund locations
9893 around. We simply always ignore hardware watchpoint
9894 traps we can no longer explain. */
9896 old_loc
->events_till_retirement
= 3 * (thread_count () + 1);
9897 old_loc
->owner
= NULL
;
9899 VEC_safe_push (bp_location_p
, moribund_locations
, old_loc
);
9903 old_loc
->owner
= NULL
;
9904 decref_bp_location (&old_loc
);
9909 /* Rescan breakpoints at the same address and section, marking the
9910 first one as "first" and any others as "duplicates". This is so
9911 that the bpt instruction is only inserted once. If we have a
9912 permanent breakpoint at the same place as BPT, make that one the
9913 official one, and the rest as duplicates. Permanent breakpoints
9914 are sorted first for the same address.
9916 Do the same for hardware watchpoints, but also considering the
9917 watchpoint's type (regular/access/read) and length. */
9919 bp_loc_first
= NULL
;
9920 wp_loc_first
= NULL
;
9921 awp_loc_first
= NULL
;
9922 rwp_loc_first
= NULL
;
9923 ALL_BP_LOCATIONS (loc
, locp
)
9925 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always
9927 struct breakpoint
*b
= loc
->owner
;
9928 struct bp_location
**loc_first_p
;
9930 if (b
->enable_state
== bp_disabled
9931 || b
->enable_state
== bp_call_disabled
9932 || b
->enable_state
== bp_startup_disabled
9934 || loc
->shlib_disabled
9935 || !breakpoint_address_is_meaningful (b
)
9936 || is_tracepoint (b
))
9939 /* Permanent breakpoint should always be inserted. */
9940 if (b
->enable_state
== bp_permanent
&& ! loc
->inserted
)
9941 internal_error (__FILE__
, __LINE__
,
9942 _("allegedly permanent breakpoint is not "
9943 "actually inserted"));
9945 if (b
->type
== bp_hardware_watchpoint
)
9946 loc_first_p
= &wp_loc_first
;
9947 else if (b
->type
== bp_read_watchpoint
)
9948 loc_first_p
= &rwp_loc_first
;
9949 else if (b
->type
== bp_access_watchpoint
)
9950 loc_first_p
= &awp_loc_first
;
9952 loc_first_p
= &bp_loc_first
;
9954 if (*loc_first_p
== NULL
9955 || (overlay_debugging
&& loc
->section
!= (*loc_first_p
)->section
)
9956 || !breakpoint_locations_match (loc
, *loc_first_p
))
9965 if ((*loc_first_p
)->owner
->enable_state
== bp_permanent
&& loc
->inserted
9966 && b
->enable_state
!= bp_permanent
)
9967 internal_error (__FILE__
, __LINE__
,
9968 _("another breakpoint was inserted on top of "
9969 "a permanent breakpoint"));
9972 if (breakpoints_always_inserted_mode () && should_insert
9973 && (have_live_inferiors ()
9974 || (gdbarch_has_global_breakpoints (target_gdbarch
))))
9975 insert_breakpoint_locations ();
9977 do_cleanups (cleanups
);
9981 breakpoint_retire_moribund (void)
9983 struct bp_location
*loc
;
9986 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
9987 if (--(loc
->events_till_retirement
) == 0)
9989 decref_bp_location (&loc
);
9990 VEC_unordered_remove (bp_location_p
, moribund_locations
, ix
);
9996 update_global_location_list_nothrow (int inserting
)
9998 struct gdb_exception e
;
10000 TRY_CATCH (e
, RETURN_MASK_ERROR
)
10001 update_global_location_list (inserting
);
10004 /* Clear BKP from a BPS. */
10007 bpstat_remove_bp_location (bpstat bps
, struct breakpoint
*bpt
)
10011 for (bs
= bps
; bs
; bs
= bs
->next
)
10012 if (bs
->breakpoint_at
== bpt
)
10014 bs
->breakpoint_at
= NULL
;
10015 bs
->old_val
= NULL
;
10016 /* bs->commands will be freed later. */
10020 /* Callback for iterate_over_threads. */
10022 bpstat_remove_breakpoint_callback (struct thread_info
*th
, void *data
)
10024 struct breakpoint
*bpt
= data
;
10026 bpstat_remove_bp_location (th
->control
.stop_bpstat
, bpt
);
10030 /* Delete a breakpoint and clean up all traces of it in the data
10034 delete_breakpoint (struct breakpoint
*bpt
)
10036 struct breakpoint
*b
;
10038 gdb_assert (bpt
!= NULL
);
10040 /* Has this bp already been deleted? This can happen because
10041 multiple lists can hold pointers to bp's. bpstat lists are
10044 One example of this happening is a watchpoint's scope bp. When
10045 the scope bp triggers, we notice that the watchpoint is out of
10046 scope, and delete it. We also delete its scope bp. But the
10047 scope bp is marked "auto-deleting", and is already on a bpstat.
10048 That bpstat is then checked for auto-deleting bp's, which are
10051 A real solution to this problem might involve reference counts in
10052 bp's, and/or giving them pointers back to their referencing
10053 bpstat's, and teaching delete_breakpoint to only free a bp's
10054 storage when no more references were extent. A cheaper bandaid
10056 if (bpt
->type
== bp_none
)
10059 /* At least avoid this stale reference until the reference counting
10060 of breakpoints gets resolved. */
10061 if (bpt
->related_breakpoint
!= NULL
)
10063 gdb_assert (bpt
->related_breakpoint
->related_breakpoint
== bpt
);
10064 bpt
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
10065 bpt
->related_breakpoint
->related_breakpoint
= NULL
;
10066 bpt
->related_breakpoint
= NULL
;
10069 observer_notify_breakpoint_deleted (bpt
->number
);
10071 if (breakpoint_chain
== bpt
)
10072 breakpoint_chain
= bpt
->next
;
10074 ALL_BREAKPOINTS (b
)
10075 if (b
->next
== bpt
)
10077 b
->next
= bpt
->next
;
10081 decref_counted_command_line (&bpt
->commands
);
10082 xfree (bpt
->cond_string
);
10083 xfree (bpt
->cond_exp
);
10084 xfree (bpt
->addr_string
);
10086 xfree (bpt
->exp_string
);
10087 xfree (bpt
->exp_string_reparse
);
10088 value_free (bpt
->val
);
10089 xfree (bpt
->source_file
);
10090 xfree (bpt
->exec_pathname
);
10091 clean_up_filters (&bpt
->syscalls_to_be_caught
);
10094 /* Be sure no bpstat's are pointing at the breakpoint after it's
10096 /* FIXME, how can we find all bpstat's? We just check stop_bpstat
10097 in all threeds for now. Note that we cannot just remove bpstats
10098 pointing at bpt from the stop_bpstat list entirely, as breakpoint
10099 commands are associated with the bpstat; if we remove it here,
10100 then the later call to bpstat_do_actions (&stop_bpstat); in
10101 event-top.c won't do anything, and temporary breakpoints with
10102 commands won't work. */
10104 iterate_over_threads (bpstat_remove_breakpoint_callback
, bpt
);
10106 /* Now that breakpoint is removed from breakpoint list, update the
10107 global location list. This will remove locations that used to
10108 belong to this breakpoint. Do this before freeing the breakpoint
10109 itself, since remove_breakpoint looks at location's owner. It
10110 might be better design to have location completely
10111 self-contained, but it's not the case now. */
10112 update_global_location_list (0);
10115 /* On the chance that someone will soon try again to delete this
10116 same bp, we mark it as deleted before freeing its storage. */
10117 bpt
->type
= bp_none
;
10123 do_delete_breakpoint_cleanup (void *b
)
10125 delete_breakpoint (b
);
10129 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
10131 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
10134 /* A callback for map_breakpoint_numbers that calls
10135 delete_breakpoint. */
10138 do_delete_breakpoint (struct breakpoint
*b
, void *ignore
)
10140 delete_breakpoint (b
);
10144 delete_command (char *arg
, int from_tty
)
10146 struct breakpoint
*b
, *b_tmp
;
10152 int breaks_to_delete
= 0;
10154 /* Delete all breakpoints if no argument.
10155 Do not delete internal or call-dummy breakpoints, these have
10156 to be deleted with an explicit breakpoint number argument. */
10157 ALL_BREAKPOINTS (b
)
10159 if (b
->type
!= bp_call_dummy
10160 && b
->type
!= bp_std_terminate
10161 && b
->type
!= bp_shlib_event
10162 && b
->type
!= bp_jit_event
10163 && b
->type
!= bp_thread_event
10164 && b
->type
!= bp_overlay_event
10165 && b
->type
!= bp_longjmp_master
10166 && b
->type
!= bp_std_terminate_master
10167 && b
->type
!= bp_exception_master
10170 breaks_to_delete
= 1;
10175 /* Ask user only if there are some breakpoints to delete. */
10177 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
10179 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
10181 if (b
->type
!= bp_call_dummy
10182 && b
->type
!= bp_std_terminate
10183 && b
->type
!= bp_shlib_event
10184 && b
->type
!= bp_thread_event
10185 && b
->type
!= bp_jit_event
10186 && b
->type
!= bp_overlay_event
10187 && b
->type
!= bp_longjmp_master
10188 && b
->type
!= bp_std_terminate_master
10189 && b
->type
!= bp_exception_master
10191 delete_breakpoint (b
);
10196 map_breakpoint_numbers (arg
, do_delete_breakpoint
, NULL
);
10200 all_locations_are_pending (struct bp_location
*loc
)
10202 for (; loc
; loc
= loc
->next
)
10203 if (!loc
->shlib_disabled
)
10208 /* Subroutine of update_breakpoint_locations to simplify it.
10209 Return non-zero if multiple fns in list LOC have the same name.
10210 Null names are ignored. */
10213 ambiguous_names_p (struct bp_location
*loc
)
10215 struct bp_location
*l
;
10216 htab_t htab
= htab_create_alloc (13, htab_hash_string
,
10217 (int (*) (const void *,
10218 const void *)) streq
,
10219 NULL
, xcalloc
, xfree
);
10221 for (l
= loc
; l
!= NULL
; l
= l
->next
)
10224 const char *name
= l
->function_name
;
10226 /* Allow for some names to be NULL, ignore them. */
10230 slot
= (const char **) htab_find_slot (htab
, (const void *) name
,
10232 /* NOTE: We can assume slot != NULL here because xcalloc never
10236 htab_delete (htab
);
10242 htab_delete (htab
);
10246 /* When symbols change, it probably means the sources changed as well,
10247 and it might mean the static tracepoint markers are no longer at
10248 the same address or line numbers they used to be at last we
10249 checked. Losing your static tracepoints whenever you rebuild is
10250 undesirable. This function tries to resync/rematch gdb static
10251 tracepoints with the markers on the target, for static tracepoints
10252 that have not been set by marker id. Static tracepoint that have
10253 been set by marker id are reset by marker id in breakpoint_re_set.
10256 1) For a tracepoint set at a specific address, look for a marker at
10257 the old PC. If one is found there, assume to be the same marker.
10258 If the name / string id of the marker found is different from the
10259 previous known name, assume that means the user renamed the marker
10260 in the sources, and output a warning.
10262 2) For a tracepoint set at a given line number, look for a marker
10263 at the new address of the old line number. If one is found there,
10264 assume to be the same marker. If the name / string id of the
10265 marker found is different from the previous known name, assume that
10266 means the user renamed the marker in the sources, and output a
10269 3) If a marker is no longer found at the same address or line, it
10270 may mean the marker no longer exists. But it may also just mean
10271 the code changed a bit. Maybe the user added a few lines of code
10272 that made the marker move up or down (in line number terms). Ask
10273 the target for info about the marker with the string id as we knew
10274 it. If found, update line number and address in the matching
10275 static tracepoint. This will get confused if there's more than one
10276 marker with the same ID (possible in UST, although unadvised
10277 precisely because it confuses tools). */
10279 static struct symtab_and_line
10280 update_static_tracepoint (struct breakpoint
*b
, struct symtab_and_line sal
)
10282 struct static_tracepoint_marker marker
;
10288 find_line_pc (sal
.symtab
, sal
.line
, &pc
);
10290 if (target_static_tracepoint_marker_at (pc
, &marker
))
10292 if (strcmp (b
->static_trace_marker_id
, marker
.str_id
) != 0)
10293 warning (_("static tracepoint %d changed probed marker from %s to %s"),
10295 b
->static_trace_marker_id
, marker
.str_id
);
10297 xfree (b
->static_trace_marker_id
);
10298 b
->static_trace_marker_id
= xstrdup (marker
.str_id
);
10299 release_static_tracepoint_marker (&marker
);
10304 /* Old marker wasn't found on target at lineno. Try looking it up
10306 if (!sal
.explicit_pc
10308 && sal
.symtab
!= NULL
10309 && b
->static_trace_marker_id
!= NULL
)
10311 VEC(static_tracepoint_marker_p
) *markers
;
10314 = target_static_tracepoint_markers_by_strid (b
->static_trace_marker_id
);
10316 if (!VEC_empty(static_tracepoint_marker_p
, markers
))
10318 struct symtab_and_line sal
;
10319 struct symbol
*sym
;
10320 struct static_tracepoint_marker
*marker
;
10322 marker
= VEC_index (static_tracepoint_marker_p
, markers
, 0);
10324 xfree (b
->static_trace_marker_id
);
10325 b
->static_trace_marker_id
= xstrdup (marker
->str_id
);
10327 warning (_("marker for static tracepoint %d (%s) not "
10328 "found at previous line number"),
10329 b
->number
, b
->static_trace_marker_id
);
10333 sal
.pc
= marker
->address
;
10335 sal
= find_pc_line (marker
->address
, 0);
10336 sym
= find_pc_sect_function (marker
->address
, NULL
);
10337 ui_out_text (uiout
, "Now in ");
10340 ui_out_field_string (uiout
, "func",
10341 SYMBOL_PRINT_NAME (sym
));
10342 ui_out_text (uiout
, " at ");
10344 ui_out_field_string (uiout
, "file", sal
.symtab
->filename
);
10345 ui_out_text (uiout
, ":");
10347 if (ui_out_is_mi_like_p (uiout
))
10349 char *fullname
= symtab_to_fullname (sal
.symtab
);
10352 ui_out_field_string (uiout
, "fullname", fullname
);
10355 ui_out_field_int (uiout
, "line", sal
.line
);
10356 ui_out_text (uiout
, "\n");
10358 b
->line_number
= sal
.line
;
10360 xfree (b
->source_file
);
10362 b
->source_file
= xstrdup (sal
.symtab
->filename
);
10364 b
->source_file
= NULL
;
10366 xfree (b
->addr_string
);
10367 b
->addr_string
= xstrprintf ("%s:%d",
10368 sal
.symtab
->filename
, b
->line_number
);
10370 /* Might be nice to check if function changed, and warn if
10373 release_static_tracepoint_marker (marker
);
10380 update_breakpoint_locations (struct breakpoint
*b
,
10381 struct symtabs_and_lines sals
)
10385 struct bp_location
*existing_locations
= b
->loc
;
10387 /* If there's no new locations, and all existing locations are
10388 pending, don't do anything. This optimizes the common case where
10389 all locations are in the same shared library, that was unloaded.
10390 We'd like to retain the location, so that when the library is
10391 loaded again, we don't loose the enabled/disabled status of the
10392 individual locations. */
10393 if (all_locations_are_pending (existing_locations
) && sals
.nelts
== 0)
10398 for (i
= 0; i
< sals
.nelts
; ++i
)
10400 struct bp_location
*new_loc
=
10401 add_location_to_breakpoint (b
, &(sals
.sals
[i
]));
10403 /* Reparse conditions, they might contain references to the
10405 if (b
->cond_string
!= NULL
)
10407 struct gdb_exception e
;
10409 s
= b
->cond_string
;
10410 TRY_CATCH (e
, RETURN_MASK_ERROR
)
10412 new_loc
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
),
10417 warning (_("failed to reevaluate condition "
10418 "for breakpoint %d: %s"),
10419 b
->number
, e
.message
);
10420 new_loc
->enabled
= 0;
10424 if (b
->source_file
!= NULL
)
10425 xfree (b
->source_file
);
10426 if (sals
.sals
[i
].symtab
== NULL
)
10427 b
->source_file
= NULL
;
10429 b
->source_file
= xstrdup (sals
.sals
[i
].symtab
->filename
);
10431 if (b
->line_number
== 0)
10432 b
->line_number
= sals
.sals
[i
].line
;
10435 /* Update locations of permanent breakpoints. */
10436 if (b
->enable_state
== bp_permanent
)
10437 make_breakpoint_permanent (b
);
10439 /* If possible, carry over 'disable' status from existing
10442 struct bp_location
*e
= existing_locations
;
10443 /* If there are multiple breakpoints with the same function name,
10444 e.g. for inline functions, comparing function names won't work.
10445 Instead compare pc addresses; this is just a heuristic as things
10446 may have moved, but in practice it gives the correct answer
10447 often enough until a better solution is found. */
10448 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
10450 for (; e
; e
= e
->next
)
10452 if (!e
->enabled
&& e
->function_name
)
10454 struct bp_location
*l
= b
->loc
;
10455 if (have_ambiguous_names
)
10457 for (; l
; l
= l
->next
)
10458 if (breakpoint_address_match (e
->pspace
->aspace
, e
->address
,
10459 l
->pspace
->aspace
, l
->address
))
10467 for (; l
; l
= l
->next
)
10468 if (l
->function_name
10469 && strcmp (e
->function_name
, l
->function_name
) == 0)
10479 update_global_location_list (1);
10482 /* Reset a breakpoint given it's struct breakpoint * BINT.
10483 The value we return ends up being the return value from catch_errors.
10484 Unused in this case. */
10487 breakpoint_re_set_one (void *bint
)
10489 /* Get past catch_errs. */
10490 struct breakpoint
*b
= (struct breakpoint
*) bint
;
10492 int *not_found_ptr
= ¬_found
;
10493 struct symtabs_and_lines sals
= {0};
10494 struct symtabs_and_lines expanded
= {0};
10496 struct gdb_exception e
;
10497 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
10498 int marker_spec
= 0;
10503 warning (_("attempted to reset apparently deleted breakpoint #%d?"),
10506 case bp_breakpoint
:
10507 case bp_hardware_breakpoint
:
10508 case bp_tracepoint
:
10509 case bp_fast_tracepoint
:
10510 case bp_static_tracepoint
:
10511 /* Do not attempt to re-set breakpoints disabled during startup. */
10512 if (b
->enable_state
== bp_startup_disabled
)
10515 if (b
->addr_string
== NULL
)
10517 /* Anything without a string can't be re-set. */
10518 delete_breakpoint (b
);
10522 input_radix
= b
->input_radix
;
10523 s
= b
->addr_string
;
10525 save_current_space_and_thread ();
10526 switch_to_program_space_and_thread (b
->pspace
);
10528 marker_spec
= b
->type
== bp_static_tracepoint
&& is_marker_spec (s
);
10530 set_language (b
->language
);
10531 TRY_CATCH (e
, RETURN_MASK_ERROR
)
10535 sals
= decode_static_tracepoint_spec (&s
);
10536 if (sals
.nelts
> b
->static_trace_marker_id_idx
)
10538 sals
.sals
[0] = sals
.sals
[b
->static_trace_marker_id_idx
];
10542 error (_("marker %s not found"), b
->static_trace_marker_id
);
10545 sals
= decode_line_1 (&s
, 1, (struct symtab
*) NULL
, 0,
10546 (char ***) NULL
, not_found_ptr
);
10550 int not_found_and_ok
= 0;
10551 /* For pending breakpoints, it's expected that parsing will
10552 fail until the right shared library is loaded. User has
10553 already told to create pending breakpoints and don't need
10554 extra messages. If breakpoint is in bp_shlib_disabled
10555 state, then user already saw the message about that
10556 breakpoint being disabled, and don't want to see more
10559 && (b
->condition_not_parsed
10560 || (b
->loc
&& b
->loc
->shlib_disabled
)
10561 || b
->enable_state
== bp_disabled
))
10562 not_found_and_ok
= 1;
10564 if (!not_found_and_ok
)
10566 /* We surely don't want to warn about the same breakpoint
10567 10 times. One solution, implemented here, is disable
10568 the breakpoint on error. Another solution would be to
10569 have separate 'warning emitted' flag. Since this
10570 happens only when a binary has changed, I don't know
10571 which approach is better. */
10572 b
->enable_state
= bp_disabled
;
10573 throw_exception (e
);
10579 gdb_assert (sals
.nelts
== 1);
10581 resolve_sal_pc (&sals
.sals
[0]);
10582 if (b
->condition_not_parsed
&& s
&& s
[0])
10584 char *cond_string
= 0;
10588 find_condition_and_thread (s
, sals
.sals
[0].pc
,
10589 &cond_string
, &thread
, &task
);
10591 b
->cond_string
= cond_string
;
10592 b
->thread
= thread
;
10594 b
->condition_not_parsed
= 0;
10597 if (b
->type
== bp_static_tracepoint
&& !marker_spec
)
10598 sals
.sals
[0] = update_static_tracepoint (b
, sals
.sals
[0]);
10600 expanded
= expand_line_sal_maybe (sals
.sals
[0]);
10603 make_cleanup (xfree
, sals
.sals
);
10604 update_breakpoint_locations (b
, expanded
);
10607 case bp_watchpoint
:
10608 case bp_hardware_watchpoint
:
10609 case bp_read_watchpoint
:
10610 case bp_access_watchpoint
:
10611 /* Watchpoint can be either on expression using entirely global
10612 variables, or it can be on local variables.
10614 Watchpoints of the first kind are never auto-deleted, and
10615 even persist across program restarts. Since they can use
10616 variables from shared libraries, we need to reparse
10617 expression as libraries are loaded and unloaded.
10619 Watchpoints on local variables can also change meaning as
10620 result of solib event. For example, if a watchpoint uses
10621 both a local and a global variables in expression, it's a
10622 local watchpoint, but unloading of a shared library will make
10623 the expression invalid. This is not a very common use case,
10624 but we still re-evaluate expression, to avoid surprises to
10627 Note that for local watchpoints, we re-evaluate it only if
10628 watchpoints frame id is still valid. If it's not, it means
10629 the watchpoint is out of scope and will be deleted soon. In
10630 fact, I'm not sure we'll ever be called in this case.
10632 If a local watchpoint's frame id is still valid, then
10633 b->exp_valid_block is likewise valid, and we can safely use it.
10635 Don't do anything about disabled watchpoints, since they will
10636 be reevaluated again when enabled. */
10637 update_watchpoint (b
, 1 /* reparse */);
10639 /* We needn't really do anything to reset these, since the mask
10640 that requests them is unaffected by e.g., new libraries being
10642 case bp_catchpoint
:
10646 printf_filtered (_("Deleting unknown breakpoint type %d\n"), b
->type
);
10648 /* Delete overlay event and longjmp master breakpoints; they will be
10649 reset later by breakpoint_re_set. */
10650 case bp_overlay_event
:
10651 case bp_longjmp_master
:
10652 case bp_std_terminate_master
:
10653 case bp_exception_master
:
10654 delete_breakpoint (b
);
10657 /* This breakpoint is special, it's set up when the inferior
10658 starts and we really don't want to touch it. */
10659 case bp_shlib_event
:
10661 /* Like bp_shlib_event, this breakpoint type is special.
10662 Once it is set up, we do not want to touch it. */
10663 case bp_thread_event
:
10665 /* Keep temporary breakpoints, which can be encountered when we
10666 step over a dlopen call and SOLIB_ADD is resetting the
10667 breakpoints. Otherwise these should have been blown away via
10668 the cleanup chain or by breakpoint_init_inferior when we
10669 rerun the executable. */
10672 case bp_watchpoint_scope
:
10673 case bp_call_dummy
:
10674 case bp_std_terminate
:
10675 case bp_step_resume
:
10677 case bp_longjmp_resume
:
10679 case bp_exception_resume
:
10684 do_cleanups (cleanups
);
10688 /* Re-set all breakpoints after symbols have been re-loaded. */
10690 breakpoint_re_set (void)
10692 struct breakpoint
*b
, *b_tmp
;
10693 enum language save_language
;
10694 int save_input_radix
;
10695 struct cleanup
*old_chain
;
10697 save_language
= current_language
->la_language
;
10698 save_input_radix
= input_radix
;
10699 old_chain
= save_current_program_space ();
10701 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
10703 /* Format possible error msg. */
10704 char *message
= xstrprintf ("Error in re-setting breakpoint %d: ",
10706 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
10707 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
10708 do_cleanups (cleanups
);
10710 set_language (save_language
);
10711 input_radix
= save_input_radix
;
10713 jit_breakpoint_re_set ();
10715 do_cleanups (old_chain
);
10717 create_overlay_event_breakpoint ();
10718 create_longjmp_master_breakpoint ();
10719 create_std_terminate_master_breakpoint ();
10720 create_exception_master_breakpoint ();
10723 /* Reset the thread number of this breakpoint:
10725 - If the breakpoint is for all threads, leave it as-is.
10726 - Else, reset it to the current thread for inferior_ptid. */
10728 breakpoint_re_set_thread (struct breakpoint
*b
)
10730 if (b
->thread
!= -1)
10732 if (in_thread_list (inferior_ptid
))
10733 b
->thread
= pid_to_thread_id (inferior_ptid
);
10735 /* We're being called after following a fork. The new fork is
10736 selected as current, and unless this was a vfork will have a
10737 different program space from the original thread. Reset that
10739 b
->loc
->pspace
= current_program_space
;
10743 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
10744 If from_tty is nonzero, it prints a message to that effect,
10745 which ends with a period (no newline). */
10748 set_ignore_count (int bptnum
, int count
, int from_tty
)
10750 struct breakpoint
*b
;
10755 ALL_BREAKPOINTS (b
)
10756 if (b
->number
== bptnum
)
10758 if (is_tracepoint (b
))
10760 if (from_tty
&& count
!= 0)
10761 printf_filtered (_("Ignore count ignored for tracepoint %d."),
10766 b
->ignore_count
= count
;
10770 printf_filtered (_("Will stop next time "
10771 "breakpoint %d is reached."),
10773 else if (count
== 1)
10774 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
10777 printf_filtered (_("Will ignore next %d "
10778 "crossings of breakpoint %d."),
10781 breakpoints_changed ();
10782 observer_notify_breakpoint_modified (b
->number
);
10786 error (_("No breakpoint number %d."), bptnum
);
10789 /* Command to set ignore-count of breakpoint N to COUNT. */
10792 ignore_command (char *args
, int from_tty
)
10798 error_no_arg (_("a breakpoint number"));
10800 num
= get_number (&p
);
10802 error (_("bad breakpoint number: '%s'"), args
);
10804 error (_("Second argument (specified ignore-count) is missing."));
10806 set_ignore_count (num
,
10807 longest_to_int (value_as_long (parse_and_eval (p
))),
10810 printf_filtered ("\n");
10813 /* Call FUNCTION on each of the breakpoints
10814 whose numbers are given in ARGS. */
10817 map_breakpoint_numbers (char *args
, void (*function
) (struct breakpoint
*,
10822 struct breakpoint
*b
, *tmp
;
10824 struct get_number_or_range_state state
;
10827 error_no_arg (_("one or more breakpoint numbers"));
10829 init_number_or_range (&state
, args
);
10831 while (!state
.finished
)
10833 char *p
= state
.string
;
10837 num
= get_number_or_range (&state
);
10840 warning (_("bad breakpoint number at or near '%s'"), p
);
10844 ALL_BREAKPOINTS_SAFE (b
, tmp
)
10845 if (b
->number
== num
)
10847 struct breakpoint
*related_breakpoint
= b
->related_breakpoint
;
10849 function (b
, data
);
10850 if (related_breakpoint
)
10851 function (related_breakpoint
, data
);
10855 printf_unfiltered (_("No breakpoint number %d.\n"), num
);
10860 static struct bp_location
*
10861 find_location_by_number (char *number
)
10863 char *dot
= strchr (number
, '.');
10867 struct breakpoint
*b
;
10868 struct bp_location
*loc
;
10873 bp_num
= get_number (&p1
);
10875 error (_("Bad breakpoint number '%s'"), number
);
10877 ALL_BREAKPOINTS (b
)
10878 if (b
->number
== bp_num
)
10883 if (!b
|| b
->number
!= bp_num
)
10884 error (_("Bad breakpoint number '%s'"), number
);
10887 loc_num
= get_number (&p1
);
10889 error (_("Bad breakpoint location number '%s'"), number
);
10893 for (;loc_num
&& loc
; --loc_num
, loc
= loc
->next
)
10896 error (_("Bad breakpoint location number '%s'"), dot
+1);
10902 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
10903 If from_tty is nonzero, it prints a message to that effect,
10904 which ends with a period (no newline). */
10907 disable_breakpoint (struct breakpoint
*bpt
)
10909 /* Never disable a watchpoint scope breakpoint; we want to
10910 hit them when we leave scope so we can delete both the
10911 watchpoint and its scope breakpoint at that time. */
10912 if (bpt
->type
== bp_watchpoint_scope
)
10915 /* You can't disable permanent breakpoints. */
10916 if (bpt
->enable_state
== bp_permanent
)
10919 bpt
->enable_state
= bp_disabled
;
10921 update_global_location_list (0);
10923 observer_notify_breakpoint_modified (bpt
->number
);
10926 /* A callback for map_breakpoint_numbers that calls
10927 disable_breakpoint. */
10930 do_map_disable_breakpoint (struct breakpoint
*b
, void *ignore
)
10932 disable_breakpoint (b
);
10936 disable_command (char *args
, int from_tty
)
10938 struct breakpoint
*bpt
;
10941 ALL_BREAKPOINTS (bpt
)
10945 warning (_("attempted to disable apparently deleted breakpoint #%d?"),
10948 case bp_breakpoint
:
10949 case bp_tracepoint
:
10950 case bp_fast_tracepoint
:
10951 case bp_static_tracepoint
:
10952 case bp_catchpoint
:
10953 case bp_hardware_breakpoint
:
10954 case bp_watchpoint
:
10955 case bp_hardware_watchpoint
:
10956 case bp_read_watchpoint
:
10957 case bp_access_watchpoint
:
10958 disable_breakpoint (bpt
);
10963 else if (strchr (args
, '.'))
10965 struct bp_location
*loc
= find_location_by_number (args
);
10968 update_global_location_list (0);
10971 map_breakpoint_numbers (args
, do_map_disable_breakpoint
, NULL
);
10975 do_enable_breakpoint (struct breakpoint
*bpt
, enum bpdisp disposition
)
10977 int target_resources_ok
;
10979 if (bpt
->type
== bp_hardware_breakpoint
)
10982 i
= hw_breakpoint_used_count ();
10983 target_resources_ok
=
10984 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
10986 if (target_resources_ok
== 0)
10987 error (_("No hardware breakpoint support in the target."));
10988 else if (target_resources_ok
< 0)
10989 error (_("Hardware breakpoints used exceeds limit."));
10992 if (is_watchpoint (bpt
))
10994 struct gdb_exception e
;
10996 TRY_CATCH (e
, RETURN_MASK_ALL
)
10998 update_watchpoint (bpt
, 1 /* reparse */);
11002 exception_fprintf (gdb_stderr
, e
, _("Cannot enable watchpoint %d: "),
11008 if (bpt
->enable_state
!= bp_permanent
)
11009 bpt
->enable_state
= bp_enabled
;
11010 bpt
->disposition
= disposition
;
11011 update_global_location_list (1);
11012 breakpoints_changed ();
11014 observer_notify_breakpoint_modified (bpt
->number
);
11019 enable_breakpoint (struct breakpoint
*bpt
)
11021 do_enable_breakpoint (bpt
, bpt
->disposition
);
11024 /* A callback for map_breakpoint_numbers that calls
11025 enable_breakpoint. */
11028 do_map_enable_breakpoint (struct breakpoint
*b
, void *ignore
)
11030 enable_breakpoint (b
);
11033 /* The enable command enables the specified breakpoints (or all defined
11034 breakpoints) so they once again become (or continue to be) effective
11035 in stopping the inferior. */
11038 enable_command (char *args
, int from_tty
)
11040 struct breakpoint
*bpt
;
11043 ALL_BREAKPOINTS (bpt
)
11047 warning (_("attempted to enable apparently deleted breakpoint #%d?"),
11050 case bp_breakpoint
:
11051 case bp_tracepoint
:
11052 case bp_fast_tracepoint
:
11053 case bp_static_tracepoint
:
11054 case bp_catchpoint
:
11055 case bp_hardware_breakpoint
:
11056 case bp_watchpoint
:
11057 case bp_hardware_watchpoint
:
11058 case bp_read_watchpoint
:
11059 case bp_access_watchpoint
:
11060 enable_breakpoint (bpt
);
11065 else if (strchr (args
, '.'))
11067 struct bp_location
*loc
= find_location_by_number (args
);
11070 update_global_location_list (1);
11073 map_breakpoint_numbers (args
, do_map_enable_breakpoint
, NULL
);
11077 enable_once_breakpoint (struct breakpoint
*bpt
, void *ignore
)
11079 do_enable_breakpoint (bpt
, disp_disable
);
11083 enable_once_command (char *args
, int from_tty
)
11085 map_breakpoint_numbers (args
, enable_once_breakpoint
, NULL
);
11089 enable_delete_breakpoint (struct breakpoint
*bpt
, void *ignore
)
11091 do_enable_breakpoint (bpt
, disp_del
);
11095 enable_delete_command (char *args
, int from_tty
)
11097 map_breakpoint_numbers (args
, enable_delete_breakpoint
, NULL
);
11101 set_breakpoint_cmd (char *args
, int from_tty
)
11106 show_breakpoint_cmd (char *args
, int from_tty
)
11110 /* Invalidate last known value of any hardware watchpoint if
11111 the memory which that value represents has been written to by
11115 invalidate_bp_value_on_memory_change (CORE_ADDR addr
, int len
,
11116 const bfd_byte
*data
)
11118 struct breakpoint
*bp
;
11120 ALL_BREAKPOINTS (bp
)
11121 if (bp
->enable_state
== bp_enabled
11122 && bp
->type
== bp_hardware_watchpoint
11123 && bp
->val_valid
&& bp
->val
)
11125 struct bp_location
*loc
;
11127 for (loc
= bp
->loc
; loc
!= NULL
; loc
= loc
->next
)
11128 if (loc
->loc_type
== bp_loc_hardware_watchpoint
11129 && loc
->address
+ loc
->length
> addr
11130 && addr
+ len
> loc
->address
)
11132 value_free (bp
->val
);
11139 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
11141 struct symtabs_and_lines
11142 decode_line_spec_1 (char *string
, int funfirstline
)
11144 struct symtabs_and_lines sals
;
11147 error (_("Empty line specification."));
11148 if (default_breakpoint_valid
)
11149 sals
= decode_line_1 (&string
, funfirstline
,
11150 default_breakpoint_symtab
,
11151 default_breakpoint_line
,
11152 (char ***) NULL
, NULL
);
11154 sals
= decode_line_1 (&string
, funfirstline
,
11155 (struct symtab
*) NULL
, 0, (char ***) NULL
, NULL
);
11157 error (_("Junk at end of line specification: %s"), string
);
11161 /* Create and insert a raw software breakpoint at PC. Return an
11162 identifier, which should be used to remove the breakpoint later.
11163 In general, places which call this should be using something on the
11164 breakpoint chain instead; this function should be eliminated
11168 deprecated_insert_raw_breakpoint (struct gdbarch
*gdbarch
,
11169 struct address_space
*aspace
, CORE_ADDR pc
)
11171 struct bp_target_info
*bp_tgt
;
11173 bp_tgt
= XZALLOC (struct bp_target_info
);
11175 bp_tgt
->placed_address_space
= aspace
;
11176 bp_tgt
->placed_address
= pc
;
11178 if (target_insert_breakpoint (gdbarch
, bp_tgt
) != 0)
11180 /* Could not insert the breakpoint. */
11188 /* Remove a breakpoint BP inserted by
11189 deprecated_insert_raw_breakpoint. */
11192 deprecated_remove_raw_breakpoint (struct gdbarch
*gdbarch
, void *bp
)
11194 struct bp_target_info
*bp_tgt
= bp
;
11197 ret
= target_remove_breakpoint (gdbarch
, bp_tgt
);
11203 /* One (or perhaps two) breakpoints used for software single
11206 static void *single_step_breakpoints
[2];
11207 static struct gdbarch
*single_step_gdbarch
[2];
11209 /* Create and insert a breakpoint for software single step. */
11212 insert_single_step_breakpoint (struct gdbarch
*gdbarch
,
11213 struct address_space
*aspace
,
11218 if (single_step_breakpoints
[0] == NULL
)
11220 bpt_p
= &single_step_breakpoints
[0];
11221 single_step_gdbarch
[0] = gdbarch
;
11225 gdb_assert (single_step_breakpoints
[1] == NULL
);
11226 bpt_p
= &single_step_breakpoints
[1];
11227 single_step_gdbarch
[1] = gdbarch
;
11230 /* NOTE drow/2006-04-11: A future improvement to this function would
11231 be to only create the breakpoints once, and actually put them on
11232 the breakpoint chain. That would let us use set_raw_breakpoint.
11233 We could adjust the addresses each time they were needed. Doing
11234 this requires corresponding changes elsewhere where single step
11235 breakpoints are handled, however. So, for now, we use this. */
11237 *bpt_p
= deprecated_insert_raw_breakpoint (gdbarch
, aspace
, next_pc
);
11238 if (*bpt_p
== NULL
)
11239 error (_("Could not insert single-step breakpoint at %s"),
11240 paddress (gdbarch
, next_pc
));
11243 /* Check if the breakpoints used for software single stepping
11244 were inserted or not. */
11247 single_step_breakpoints_inserted (void)
11249 return (single_step_breakpoints
[0] != NULL
11250 || single_step_breakpoints
[1] != NULL
);
11253 /* Remove and delete any breakpoints used for software single step. */
11256 remove_single_step_breakpoints (void)
11258 gdb_assert (single_step_breakpoints
[0] != NULL
);
11260 /* See insert_single_step_breakpoint for more about this deprecated
11262 deprecated_remove_raw_breakpoint (single_step_gdbarch
[0],
11263 single_step_breakpoints
[0]);
11264 single_step_gdbarch
[0] = NULL
;
11265 single_step_breakpoints
[0] = NULL
;
11267 if (single_step_breakpoints
[1] != NULL
)
11269 deprecated_remove_raw_breakpoint (single_step_gdbarch
[1],
11270 single_step_breakpoints
[1]);
11271 single_step_gdbarch
[1] = NULL
;
11272 single_step_breakpoints
[1] = NULL
;
11276 /* Delete software single step breakpoints without removing them from
11277 the inferior. This is intended to be used if the inferior's address
11278 space where they were inserted is already gone, e.g. after exit or
11282 cancel_single_step_breakpoints (void)
11286 for (i
= 0; i
< 2; i
++)
11287 if (single_step_breakpoints
[i
])
11289 xfree (single_step_breakpoints
[i
]);
11290 single_step_breakpoints
[i
] = NULL
;
11291 single_step_gdbarch
[i
] = NULL
;
11295 /* Detach software single-step breakpoints from INFERIOR_PTID without
11299 detach_single_step_breakpoints (void)
11303 for (i
= 0; i
< 2; i
++)
11304 if (single_step_breakpoints
[i
])
11305 target_remove_breakpoint (single_step_gdbarch
[i
],
11306 single_step_breakpoints
[i
]);
11309 /* Check whether a software single-step breakpoint is inserted at
11313 single_step_breakpoint_inserted_here_p (struct address_space
*aspace
,
11318 for (i
= 0; i
< 2; i
++)
11320 struct bp_target_info
*bp_tgt
= single_step_breakpoints
[i
];
11322 && breakpoint_address_match (bp_tgt
->placed_address_space
,
11323 bp_tgt
->placed_address
,
11331 /* Returns 0 if 'bp' is NOT a syscall catchpoint,
11332 non-zero otherwise. */
11334 is_syscall_catchpoint_enabled (struct breakpoint
*bp
)
11336 if (syscall_catchpoint_p (bp
)
11337 && bp
->enable_state
!= bp_disabled
11338 && bp
->enable_state
!= bp_call_disabled
)
11345 catch_syscall_enabled (void)
11347 struct inferior
*inf
= current_inferior ();
11349 return inf
->total_syscalls_count
!= 0;
11353 catching_syscall_number (int syscall_number
)
11355 struct breakpoint
*bp
;
11357 ALL_BREAKPOINTS (bp
)
11358 if (is_syscall_catchpoint_enabled (bp
))
11360 if (bp
->syscalls_to_be_caught
)
11364 VEC_iterate (int, bp
->syscalls_to_be_caught
, i
, iter
);
11366 if (syscall_number
== iter
)
11376 /* Complete syscall names. Used by "catch syscall". */
11378 catch_syscall_completer (struct cmd_list_element
*cmd
,
11379 char *text
, char *word
)
11381 const char **list
= get_syscall_names ();
11383 = (list
== NULL
) ? NULL
: complete_on_enum (list
, text
, word
);
11389 /* Tracepoint-specific operations. */
11391 /* Set tracepoint count to NUM. */
11393 set_tracepoint_count (int num
)
11395 tracepoint_count
= num
;
11396 set_internalvar_integer (lookup_internalvar ("tpnum"), num
);
11400 trace_command (char *arg
, int from_tty
)
11402 if (create_breakpoint (get_current_arch (),
11404 NULL
, 0, 1 /* parse arg */,
11406 bp_tracepoint
/* type_wanted */,
11407 0 /* Ignore count */,
11408 pending_break_support
,
11413 set_tracepoint_count (breakpoint_count
);
11417 ftrace_command (char *arg
, int from_tty
)
11419 if (create_breakpoint (get_current_arch (),
11421 NULL
, 0, 1 /* parse arg */,
11423 bp_fast_tracepoint
/* type_wanted */,
11424 0 /* Ignore count */,
11425 pending_break_support
,
11430 set_tracepoint_count (breakpoint_count
);
11433 /* strace command implementation. Creates a static tracepoint. */
11436 strace_command (char *arg
, int from_tty
)
11438 if (create_breakpoint (get_current_arch (),
11440 NULL
, 0, 1 /* parse arg */,
11442 bp_static_tracepoint
/* type_wanted */,
11443 0 /* Ignore count */,
11444 pending_break_support
,
11449 set_tracepoint_count (breakpoint_count
);
11452 /* Set up a fake reader function that gets command lines from a linked
11453 list that was acquired during tracepoint uploading. */
11455 static struct uploaded_tp
*this_utp
;
11456 static int next_cmd
;
11459 read_uploaded_action (void)
11463 VEC_iterate (char_ptr
, this_utp
->cmd_strings
, next_cmd
, rslt
);
11470 /* Given information about a tracepoint as recorded on a target (which
11471 can be either a live system or a trace file), attempt to create an
11472 equivalent GDB tracepoint. This is not a reliable process, since
11473 the target does not necessarily have all the information used when
11474 the tracepoint was originally defined. */
11476 struct breakpoint
*
11477 create_tracepoint_from_upload (struct uploaded_tp
*utp
)
11479 char *addr_str
, small_buf
[100];
11480 struct breakpoint
*tp
;
11482 if (utp
->at_string
)
11483 addr_str
= utp
->at_string
;
11486 /* In the absence of a source location, fall back to raw
11487 address. Since there is no way to confirm that the address
11488 means the same thing as when the trace was started, warn the
11490 warning (_("Uploaded tracepoint %d has no "
11491 "source location, using raw address"),
11493 sprintf (small_buf
, "*%s", hex_string (utp
->addr
));
11494 addr_str
= small_buf
;
11497 /* There's not much we can do with a sequence of bytecodes. */
11498 if (utp
->cond
&& !utp
->cond_string
)
11499 warning (_("Uploaded tracepoint %d condition "
11500 "has no source form, ignoring it"),
11503 if (!create_breakpoint (get_current_arch (),
11505 utp
->cond_string
, -1, 0 /* parse cond/thread */,
11507 utp
->type
/* type_wanted */,
11508 0 /* Ignore count */,
11509 pending_break_support
,
11512 utp
->enabled
/* enabled */,
11516 set_tracepoint_count (breakpoint_count
);
11518 /* Get the tracepoint we just created. */
11519 tp
= get_tracepoint (tracepoint_count
);
11520 gdb_assert (tp
!= NULL
);
11524 sprintf (small_buf
, "%d %d", utp
->pass
, tp
->number
);
11526 trace_pass_command (small_buf
, 0);
11529 /* If we have uploaded versions of the original commands, set up a
11530 special-purpose "reader" function and call the usual command line
11531 reader, then pass the result to the breakpoint command-setting
11533 if (!VEC_empty (char_ptr
, utp
->cmd_strings
))
11535 struct command_line
*cmd_list
;
11540 cmd_list
= read_command_lines_1 (read_uploaded_action
, 1, NULL
, NULL
);
11542 breakpoint_set_commands (tp
, cmd_list
);
11544 else if (!VEC_empty (char_ptr
, utp
->actions
)
11545 || !VEC_empty (char_ptr
, utp
->step_actions
))
11546 warning (_("Uploaded tracepoint %d actions "
11547 "have no source form, ignoring them"),
11553 /* Print information on tracepoint number TPNUM_EXP, or all if
11557 tracepoints_info (char *args
, int from_tty
)
11561 num_printed
= breakpoint_1 (args
, 0, is_tracepoint
);
11563 if (num_printed
== 0)
11565 if (args
== NULL
|| *args
== '\0')
11566 ui_out_message (uiout
, 0, "No tracepoints.\n");
11568 ui_out_message (uiout
, 0, "No tracepoint matching '%s'.\n", args
);
11571 default_collect_info ();
11574 /* The 'enable trace' command enables tracepoints.
11575 Not supported by all targets. */
11577 enable_trace_command (char *args
, int from_tty
)
11579 enable_command (args
, from_tty
);
11582 /* The 'disable trace' command disables tracepoints.
11583 Not supported by all targets. */
11585 disable_trace_command (char *args
, int from_tty
)
11587 disable_command (args
, from_tty
);
11590 /* Remove a tracepoint (or all if no argument). */
11592 delete_trace_command (char *arg
, int from_tty
)
11594 struct breakpoint
*b
, *b_tmp
;
11600 int breaks_to_delete
= 0;
11602 /* Delete all breakpoints if no argument.
11603 Do not delete internal or call-dummy breakpoints, these
11604 have to be deleted with an explicit breakpoint number
11606 ALL_TRACEPOINTS (b
)
11608 if (b
->number
>= 0)
11610 breaks_to_delete
= 1;
11615 /* Ask user only if there are some breakpoints to delete. */
11617 || (breaks_to_delete
&& query (_("Delete all tracepoints? "))))
11619 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
11621 if (is_tracepoint (b
)
11623 delete_breakpoint (b
);
11628 map_breakpoint_numbers (arg
, do_delete_breakpoint
, NULL
);
11631 /* Helper function for trace_pass_command. */
11634 trace_pass_set_count (struct breakpoint
*bp
, int count
, int from_tty
)
11636 bp
->pass_count
= count
;
11637 observer_notify_tracepoint_modified (bp
->number
);
11639 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
11640 bp
->number
, count
);
11643 /* Set passcount for tracepoint.
11645 First command argument is passcount, second is tracepoint number.
11646 If tracepoint number omitted, apply to most recently defined.
11647 Also accepts special argument "all". */
11650 trace_pass_command (char *args
, int from_tty
)
11652 struct breakpoint
*t1
;
11653 unsigned int count
;
11655 if (args
== 0 || *args
== 0)
11656 error (_("passcount command requires an "
11657 "argument (count + optional TP num)"));
11659 count
= strtoul (args
, &args
, 10); /* Count comes first, then TP num. */
11661 while (*args
&& isspace ((int) *args
))
11664 if (*args
&& strncasecmp (args
, "all", 3) == 0)
11666 args
+= 3; /* Skip special argument "all". */
11668 error (_("Junk at end of arguments."));
11670 ALL_TRACEPOINTS (t1
)
11672 trace_pass_set_count (t1
, count
, from_tty
);
11675 else if (*args
== '\0')
11677 t1
= get_tracepoint_by_number (&args
, NULL
, 1);
11679 trace_pass_set_count (t1
, count
, from_tty
);
11683 struct get_number_or_range_state state
;
11685 init_number_or_range (&state
, args
);
11686 while (!state
.finished
)
11688 t1
= get_tracepoint_by_number (&args
, &state
, 1);
11690 trace_pass_set_count (t1
, count
, from_tty
);
11695 struct breakpoint
*
11696 get_tracepoint (int num
)
11698 struct breakpoint
*t
;
11700 ALL_TRACEPOINTS (t
)
11701 if (t
->number
== num
)
11707 /* Find the tracepoint with the given target-side number (which may be
11708 different from the tracepoint number after disconnecting and
11711 struct breakpoint
*
11712 get_tracepoint_by_number_on_target (int num
)
11714 struct breakpoint
*t
;
11716 ALL_TRACEPOINTS (t
)
11717 if (t
->number_on_target
== num
)
11723 /* Utility: parse a tracepoint number and look it up in the list.
11724 If STATE is not NULL, use, get_number_or_range_state and ignore ARG.
11725 If OPTIONAL_P is true, then if the argument is missing, the most
11726 recent tracepoint (tracepoint_count) is returned. */
11727 struct breakpoint
*
11728 get_tracepoint_by_number (char **arg
,
11729 struct get_number_or_range_state
*state
,
11732 extern int tracepoint_count
;
11733 struct breakpoint
*t
;
11735 char *instring
= arg
== NULL
? NULL
: *arg
;
11739 gdb_assert (!state
->finished
);
11740 tpnum
= get_number_or_range (state
);
11742 else if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
11745 tpnum
= tracepoint_count
;
11747 error_no_arg (_("tracepoint number"));
11750 tpnum
= get_number (arg
);
11754 if (instring
&& *instring
)
11755 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
11758 printf_filtered (_("Tracepoint argument missing "
11759 "and no previous tracepoint\n"));
11763 ALL_TRACEPOINTS (t
)
11764 if (t
->number
== tpnum
)
11769 printf_unfiltered ("No tracepoint number %d.\n", tpnum
);
11773 /* Save information on user settable breakpoints (watchpoints, etc) to
11774 a new script file named FILENAME. If FILTER is non-NULL, call it
11775 on each breakpoint and only include the ones for which it returns
11779 save_breakpoints (char *filename
, int from_tty
,
11780 int (*filter
) (const struct breakpoint
*))
11782 struct breakpoint
*tp
;
11785 struct cleanup
*cleanup
;
11786 struct ui_file
*fp
;
11787 int extra_trace_bits
= 0;
11789 if (filename
== 0 || *filename
== 0)
11790 error (_("Argument required (file name in which to save)"));
11792 /* See if we have anything to save. */
11793 ALL_BREAKPOINTS (tp
)
11795 /* Skip internal and momentary breakpoints. */
11796 if (!user_breakpoint_p (tp
))
11799 /* If we have a filter, only save the breakpoints it accepts. */
11800 if (filter
&& !filter (tp
))
11805 if (is_tracepoint (tp
))
11807 extra_trace_bits
= 1;
11809 /* We can stop searching. */
11816 warning (_("Nothing to save."));
11820 pathname
= tilde_expand (filename
);
11821 cleanup
= make_cleanup (xfree
, pathname
);
11822 fp
= gdb_fopen (pathname
, "w");
11824 error (_("Unable to open file '%s' for saving (%s)"),
11825 filename
, safe_strerror (errno
));
11826 make_cleanup_ui_file_delete (fp
);
11828 if (extra_trace_bits
)
11829 save_trace_state_variables (fp
);
11831 ALL_BREAKPOINTS (tp
)
11833 /* Skip internal and momentary breakpoints. */
11834 if (!user_breakpoint_p (tp
))
11837 /* If we have a filter, only save the breakpoints it accepts. */
11838 if (filter
&& !filter (tp
))
11841 if (tp
->ops
!= NULL
)
11842 (tp
->ops
->print_recreate
) (tp
, fp
);
11845 if (tp
->type
== bp_fast_tracepoint
)
11846 fprintf_unfiltered (fp
, "ftrace");
11847 if (tp
->type
== bp_static_tracepoint
)
11848 fprintf_unfiltered (fp
, "strace");
11849 else if (tp
->type
== bp_tracepoint
)
11850 fprintf_unfiltered (fp
, "trace");
11851 else if (tp
->type
== bp_breakpoint
&& tp
->disposition
== disp_del
)
11852 fprintf_unfiltered (fp
, "tbreak");
11853 else if (tp
->type
== bp_breakpoint
)
11854 fprintf_unfiltered (fp
, "break");
11855 else if (tp
->type
== bp_hardware_breakpoint
11856 && tp
->disposition
== disp_del
)
11857 fprintf_unfiltered (fp
, "thbreak");
11858 else if (tp
->type
== bp_hardware_breakpoint
)
11859 fprintf_unfiltered (fp
, "hbreak");
11860 else if (tp
->type
== bp_watchpoint
)
11861 fprintf_unfiltered (fp
, "watch");
11862 else if (tp
->type
== bp_hardware_watchpoint
)
11863 fprintf_unfiltered (fp
, "watch");
11864 else if (tp
->type
== bp_read_watchpoint
)
11865 fprintf_unfiltered (fp
, "rwatch");
11866 else if (tp
->type
== bp_access_watchpoint
)
11867 fprintf_unfiltered (fp
, "awatch");
11869 internal_error (__FILE__
, __LINE__
,
11870 _("unhandled breakpoint type %d"), (int) tp
->type
);
11872 if (tp
->exp_string
)
11873 fprintf_unfiltered (fp
, " %s", tp
->exp_string
);
11874 else if (tp
->addr_string
)
11875 fprintf_unfiltered (fp
, " %s", tp
->addr_string
);
11880 sprintf_vma (tmp
, tp
->loc
->address
);
11881 fprintf_unfiltered (fp
, " *0x%s", tmp
);
11885 if (tp
->thread
!= -1)
11886 fprintf_unfiltered (fp
, " thread %d", tp
->thread
);
11889 fprintf_unfiltered (fp
, " task %d", tp
->task
);
11891 fprintf_unfiltered (fp
, "\n");
11893 /* Note, we can't rely on tp->number for anything, as we can't
11894 assume the recreated breakpoint numbers will match. Use $bpnum
11897 if (tp
->cond_string
)
11898 fprintf_unfiltered (fp
, " condition $bpnum %s\n", tp
->cond_string
);
11900 if (tp
->ignore_count
)
11901 fprintf_unfiltered (fp
, " ignore $bpnum %d\n", tp
->ignore_count
);
11903 if (tp
->pass_count
)
11904 fprintf_unfiltered (fp
, " passcount %d\n", tp
->pass_count
);
11908 volatile struct gdb_exception ex
;
11910 fprintf_unfiltered (fp
, " commands\n");
11912 ui_out_redirect (uiout
, fp
);
11913 TRY_CATCH (ex
, RETURN_MASK_ALL
)
11915 print_command_lines (uiout
, tp
->commands
->commands
, 2);
11917 ui_out_redirect (uiout
, NULL
);
11920 throw_exception (ex
);
11922 fprintf_unfiltered (fp
, " end\n");
11925 if (tp
->enable_state
== bp_disabled
)
11926 fprintf_unfiltered (fp
, "disable\n");
11928 /* If this is a multi-location breakpoint, check if the locations
11929 should be individually disabled. Watchpoint locations are
11930 special, and not user visible. */
11931 if (!is_watchpoint (tp
) && tp
->loc
&& tp
->loc
->next
)
11933 struct bp_location
*loc
;
11936 for (loc
= tp
->loc
; loc
!= NULL
; loc
= loc
->next
, n
++)
11938 fprintf_unfiltered (fp
, "disable $bpnum.%d\n", n
);
11942 if (extra_trace_bits
&& *default_collect
)
11943 fprintf_unfiltered (fp
, "set default-collect %s\n", default_collect
);
11945 do_cleanups (cleanup
);
11947 printf_filtered (_("Saved to file '%s'.\n"), filename
);
11950 /* The `save breakpoints' command. */
11953 save_breakpoints_command (char *args
, int from_tty
)
11955 save_breakpoints (args
, from_tty
, NULL
);
11958 /* The `save tracepoints' command. */
11961 save_tracepoints_command (char *args
, int from_tty
)
11963 save_breakpoints (args
, from_tty
, is_tracepoint
);
11966 /* Create a vector of all tracepoints. */
11968 VEC(breakpoint_p
) *
11969 all_tracepoints (void)
11971 VEC(breakpoint_p
) *tp_vec
= 0;
11972 struct breakpoint
*tp
;
11974 ALL_TRACEPOINTS (tp
)
11976 VEC_safe_push (breakpoint_p
, tp_vec
, tp
);
11983 /* This help string is used for the break, hbreak, tbreak and thbreak
11984 commands. It is defined as a macro to prevent duplication.
11985 COMMAND should be a string constant containing the name of the
11987 #define BREAK_ARGS_HELP(command) \
11988 command" [LOCATION] [thread THREADNUM] [if CONDITION]\n\
11989 LOCATION may be a line number, function name, or \"*\" and an address.\n\
11990 If a line number is specified, break at start of code for that line.\n\
11991 If a function is specified, break at start of code for that function.\n\
11992 If an address is specified, break at that exact address.\n\
11993 With no LOCATION, uses current execution address of the selected\n\
11994 stack frame. This is useful for breaking on return to a stack frame.\n\
11996 THREADNUM is the number from \"info threads\".\n\
11997 CONDITION is a boolean expression.\n\
11999 Multiple breakpoints at one place are permitted, and useful if their\n\
12000 conditions are different.\n\
12002 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
12004 /* List of subcommands for "catch". */
12005 static struct cmd_list_element
*catch_cmdlist
;
12007 /* List of subcommands for "tcatch". */
12008 static struct cmd_list_element
*tcatch_cmdlist
;
12010 /* Like add_cmd, but add the command to both the "catch" and "tcatch"
12011 lists, and pass some additional user data to the command function. */
12013 add_catch_command (char *name
, char *docstring
,
12014 void (*sfunc
) (char *args
, int from_tty
,
12015 struct cmd_list_element
*command
),
12016 char **(*completer
) (struct cmd_list_element
*cmd
,
12017 char *text
, char *word
),
12018 void *user_data_catch
,
12019 void *user_data_tcatch
)
12021 struct cmd_list_element
*command
;
12023 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
12025 set_cmd_sfunc (command
, sfunc
);
12026 set_cmd_context (command
, user_data_catch
);
12027 set_cmd_completer (command
, completer
);
12029 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
12031 set_cmd_sfunc (command
, sfunc
);
12032 set_cmd_context (command
, user_data_tcatch
);
12033 set_cmd_completer (command
, completer
);
12037 clear_syscall_counts (struct inferior
*inf
)
12039 inf
->total_syscalls_count
= 0;
12040 inf
->any_syscall_count
= 0;
12041 VEC_free (int, inf
->syscalls_counts
);
12045 save_command (char *arg
, int from_tty
)
12047 printf_unfiltered (_("\"save\" must be followed by "
12048 "the name of a save subcommand.\n"));
12049 help_list (save_cmdlist
, "save ", -1, gdb_stdout
);
12052 struct breakpoint
*
12053 iterate_over_breakpoints (int (*callback
) (struct breakpoint
*, void *),
12056 struct breakpoint
*b
, *b_tmp
;
12058 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
12060 if ((*callback
) (b
, data
))
12068 _initialize_breakpoint (void)
12070 struct cmd_list_element
*c
;
12072 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
12073 observer_attach_inferior_exit (clear_syscall_counts
);
12074 observer_attach_memory_changed (invalidate_bp_value_on_memory_change
);
12076 breakpoint_objfile_key
= register_objfile_data ();
12078 breakpoint_chain
= 0;
12079 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
12080 before a breakpoint is set. */
12081 breakpoint_count
= 0;
12083 tracepoint_count
= 0;
12085 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
12086 Set ignore-count of breakpoint number N to COUNT.\n\
12087 Usage is `ignore N COUNT'."));
12089 add_com_alias ("bc", "ignore", class_breakpoint
, 1);
12091 add_com ("commands", class_breakpoint
, commands_command
, _("\
12092 Set commands to be executed when a breakpoint is hit.\n\
12093 Give breakpoint number as argument after \"commands\".\n\
12094 With no argument, the targeted breakpoint is the last one set.\n\
12095 The commands themselves follow starting on the next line.\n\
12096 Type a line containing \"end\" to indicate the end of them.\n\
12097 Give \"silent\" as the first line to make the breakpoint silent;\n\
12098 then no output is printed when it is hit, except what the commands print."));
12100 add_com ("condition", class_breakpoint
, condition_command
, _("\
12101 Specify breakpoint number N to break only if COND is true.\n\
12102 Usage is `condition N COND', where N is an integer and COND is an\n\
12103 expression to be evaluated whenever breakpoint N is reached."));
12105 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
12106 Set a temporary breakpoint.\n\
12107 Like \"break\" except the breakpoint is only temporary,\n\
12108 so it will be deleted when hit. Equivalent to \"break\" followed\n\
12109 by using \"enable delete\" on the breakpoint number.\n\
12111 BREAK_ARGS_HELP ("tbreak")));
12112 set_cmd_completer (c
, location_completer
);
12114 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
12115 Set a hardware assisted breakpoint.\n\
12116 Like \"break\" except the breakpoint requires hardware support,\n\
12117 some target hardware may not have this support.\n\
12119 BREAK_ARGS_HELP ("hbreak")));
12120 set_cmd_completer (c
, location_completer
);
12122 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
12123 Set a temporary hardware assisted breakpoint.\n\
12124 Like \"hbreak\" except the breakpoint is only temporary,\n\
12125 so it will be deleted when hit.\n\
12127 BREAK_ARGS_HELP ("thbreak")));
12128 set_cmd_completer (c
, location_completer
);
12130 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
12131 Enable some breakpoints.\n\
12132 Give breakpoint numbers (separated by spaces) as arguments.\n\
12133 With no subcommand, breakpoints are enabled until you command otherwise.\n\
12134 This is used to cancel the effect of the \"disable\" command.\n\
12135 With a subcommand you can enable temporarily."),
12136 &enablelist
, "enable ", 1, &cmdlist
);
12138 add_com ("ab", class_breakpoint
, enable_command
, _("\
12139 Enable some breakpoints.\n\
12140 Give breakpoint numbers (separated by spaces) as arguments.\n\
12141 With no subcommand, breakpoints are enabled until you command otherwise.\n\
12142 This is used to cancel the effect of the \"disable\" command.\n\
12143 With a subcommand you can enable temporarily."));
12145 add_com_alias ("en", "enable", class_breakpoint
, 1);
12147 add_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
12148 Enable some breakpoints.\n\
12149 Give breakpoint numbers (separated by spaces) as arguments.\n\
12150 This is used to cancel the effect of the \"disable\" command.\n\
12151 May be abbreviated to simply \"enable\".\n"),
12152 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
12154 add_cmd ("once", no_class
, enable_once_command
, _("\
12155 Enable breakpoints for one hit. Give breakpoint numbers.\n\
12156 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
12159 add_cmd ("delete", no_class
, enable_delete_command
, _("\
12160 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
12161 If a breakpoint is hit while enabled in this fashion, it is deleted."),
12164 add_cmd ("delete", no_class
, enable_delete_command
, _("\
12165 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
12166 If a breakpoint is hit while enabled in this fashion, it is deleted."),
12169 add_cmd ("once", no_class
, enable_once_command
, _("\
12170 Enable breakpoints for one hit. Give breakpoint numbers.\n\
12171 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
12174 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
12175 Disable some breakpoints.\n\
12176 Arguments are breakpoint numbers with spaces in between.\n\
12177 To disable all breakpoints, give no argument.\n\
12178 A disabled breakpoint is not forgotten, but has no effect until reenabled."),
12179 &disablelist
, "disable ", 1, &cmdlist
);
12180 add_com_alias ("dis", "disable", class_breakpoint
, 1);
12181 add_com_alias ("disa", "disable", class_breakpoint
, 1);
12183 add_com ("sb", class_breakpoint
, disable_command
, _("\
12184 Disable some breakpoints.\n\
12185 Arguments are breakpoint numbers with spaces in between.\n\
12186 To disable all breakpoints, give no argument.\n\
12187 A disabled breakpoint is not forgotten, but has no effect until reenabled."));
12189 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
12190 Disable some breakpoints.\n\
12191 Arguments are breakpoint numbers with spaces in between.\n\
12192 To disable all breakpoints, give no argument.\n\
12193 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
12194 This command may be abbreviated \"disable\"."),
12197 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
12198 Delete some breakpoints or auto-display expressions.\n\
12199 Arguments are breakpoint numbers with spaces in between.\n\
12200 To delete all breakpoints, give no argument.\n\
12202 Also a prefix command for deletion of other GDB objects.\n\
12203 The \"unset\" command is also an alias for \"delete\"."),
12204 &deletelist
, "delete ", 1, &cmdlist
);
12205 add_com_alias ("d", "delete", class_breakpoint
, 1);
12206 add_com_alias ("del", "delete", class_breakpoint
, 1);
12208 add_com ("db", class_breakpoint
, delete_command
, _("\
12209 Delete some breakpoints.\n\
12210 Arguments are breakpoint numbers with spaces in between.\n\
12211 To delete all breakpoints, give no argument.\n"));
12213 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
12214 Delete some breakpoints or auto-display expressions.\n\
12215 Arguments are breakpoint numbers with spaces in between.\n\
12216 To delete all breakpoints, give no argument.\n\
12217 This command may be abbreviated \"delete\"."),
12220 add_com ("clear", class_breakpoint
, clear_command
, _("\
12221 Clear breakpoint at specified line or function.\n\
12222 Argument may be line number, function name, or \"*\" and an address.\n\
12223 If line number is specified, all breakpoints in that line are cleared.\n\
12224 If function is specified, breakpoints at beginning of function are cleared.\n\
12225 If an address is specified, breakpoints at that address are cleared.\n\
12227 With no argument, clears all breakpoints in the line that the selected frame\n\
12228 is executing in.\n\
12230 See also the \"delete\" command which clears breakpoints by number."));
12231 add_com_alias ("cl", "clear", class_breakpoint
, 1);
12233 c
= add_com ("break", class_breakpoint
, break_command
, _("\
12234 Set breakpoint at specified line or function.\n"
12235 BREAK_ARGS_HELP ("break")));
12236 set_cmd_completer (c
, location_completer
);
12238 add_com_alias ("b", "break", class_run
, 1);
12239 add_com_alias ("br", "break", class_run
, 1);
12240 add_com_alias ("bre", "break", class_run
, 1);
12241 add_com_alias ("brea", "break", class_run
, 1);
12244 add_com_alias ("ba", "break", class_breakpoint
, 1);
12248 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
12249 Break in function/address or break at a line in the current file."),
12250 &stoplist
, "stop ", 1, &cmdlist
);
12251 add_cmd ("in", class_breakpoint
, stopin_command
,
12252 _("Break in function or address."), &stoplist
);
12253 add_cmd ("at", class_breakpoint
, stopat_command
,
12254 _("Break at a line in the current file."), &stoplist
);
12255 add_com ("status", class_info
, breakpoints_info
, _("\
12256 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
12257 The \"Type\" column indicates one of:\n\
12258 \tbreakpoint - normal breakpoint\n\
12259 \twatchpoint - watchpoint\n\
12260 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
12261 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
12262 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
12263 address and file/line number respectively.\n\
12265 Convenience variable \"$_\" and default examine address for \"x\"\n\
12266 are set to the address of the last breakpoint listed unless the command\n\
12267 is prefixed with \"server \".\n\n\
12268 Convenience variable \"$bpnum\" contains the number of the last\n\
12269 breakpoint set."));
12272 add_info ("breakpoints", breakpoints_info
, _("\
12273 Status of specified breakpoints (all user-settable breakpoints if no argument).\n\
12274 The \"Type\" column indicates one of:\n\
12275 \tbreakpoint - normal breakpoint\n\
12276 \twatchpoint - watchpoint\n\
12277 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
12278 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
12279 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
12280 address and file/line number respectively.\n\
12282 Convenience variable \"$_\" and default examine address for \"x\"\n\
12283 are set to the address of the last breakpoint listed unless the command\n\
12284 is prefixed with \"server \".\n\n\
12285 Convenience variable \"$bpnum\" contains the number of the last\n\
12286 breakpoint set."));
12288 add_info_alias ("b", "breakpoints", 1);
12291 add_com ("lb", class_breakpoint
, breakpoints_info
, _("\
12292 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
12293 The \"Type\" column indicates one of:\n\
12294 \tbreakpoint - normal breakpoint\n\
12295 \twatchpoint - watchpoint\n\
12296 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
12297 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
12298 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
12299 address and file/line number respectively.\n\
12301 Convenience variable \"$_\" and default examine address for \"x\"\n\
12302 are set to the address of the last breakpoint listed unless the command\n\
12303 is prefixed with \"server \".\n\n\
12304 Convenience variable \"$bpnum\" contains the number of the last\n\
12305 breakpoint set."));
12307 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
12308 Status of all breakpoints, or breakpoint number NUMBER.\n\
12309 The \"Type\" column indicates one of:\n\
12310 \tbreakpoint - normal breakpoint\n\
12311 \twatchpoint - watchpoint\n\
12312 \tlongjmp - internal breakpoint used to step through longjmp()\n\
12313 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
12314 \tuntil - internal breakpoint used by the \"until\" command\n\
12315 \tfinish - internal breakpoint used by the \"finish\" command\n\
12316 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
12317 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
12318 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
12319 address and file/line number respectively.\n\
12321 Convenience variable \"$_\" and default examine address for \"x\"\n\
12322 are set to the address of the last breakpoint listed unless the command\n\
12323 is prefixed with \"server \".\n\n\
12324 Convenience variable \"$bpnum\" contains the number of the last\n\
12326 &maintenanceinfolist
);
12328 add_prefix_cmd ("catch", class_breakpoint
, catch_command
, _("\
12329 Set catchpoints to catch events."),
12330 &catch_cmdlist
, "catch ",
12331 0/*allow-unknown*/, &cmdlist
);
12333 add_prefix_cmd ("tcatch", class_breakpoint
, tcatch_command
, _("\
12334 Set temporary catchpoints to catch events."),
12335 &tcatch_cmdlist
, "tcatch ",
12336 0/*allow-unknown*/, &cmdlist
);
12338 /* Add catch and tcatch sub-commands. */
12339 add_catch_command ("catch", _("\
12340 Catch an exception, when caught.\n\
12341 With an argument, catch only exceptions with the given name."),
12342 catch_catch_command
,
12346 add_catch_command ("throw", _("\
12347 Catch an exception, when thrown.\n\
12348 With an argument, catch only exceptions with the given name."),
12349 catch_throw_command
,
12353 add_catch_command ("fork", _("Catch calls to fork."),
12354 catch_fork_command_1
,
12356 (void *) (uintptr_t) catch_fork_permanent
,
12357 (void *) (uintptr_t) catch_fork_temporary
);
12358 add_catch_command ("vfork", _("Catch calls to vfork."),
12359 catch_fork_command_1
,
12361 (void *) (uintptr_t) catch_vfork_permanent
,
12362 (void *) (uintptr_t) catch_vfork_temporary
);
12363 add_catch_command ("exec", _("Catch calls to exec."),
12364 catch_exec_command_1
,
12368 add_catch_command ("syscall", _("\
12369 Catch system calls by their names and/or numbers.\n\
12370 Arguments say which system calls to catch. If no arguments\n\
12371 are given, every system call will be caught.\n\
12372 Arguments, if given, should be one or more system call names\n\
12373 (if your system supports that), or system call numbers."),
12374 catch_syscall_command_1
,
12375 catch_syscall_completer
,
12378 add_catch_command ("exception", _("\
12379 Catch Ada exceptions, when raised.\n\
12380 With an argument, catch only exceptions with the given name."),
12381 catch_ada_exception_command
,
12385 add_catch_command ("assert", _("\
12386 Catch failed Ada assertions, when raised.\n\
12387 With an argument, catch only exceptions with the given name."),
12388 catch_assert_command
,
12393 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
12394 Set a watchpoint for an expression.\n\
12395 Usage: watch [-l|-location] EXPRESSION\n\
12396 A watchpoint stops execution of your program whenever the value of\n\
12397 an expression changes.\n\
12398 If -l or -location is given, this evaluates EXPRESSION and watches\n\
12399 the memory to which it refers."));
12400 set_cmd_completer (c
, expression_completer
);
12402 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
12403 Set a read watchpoint for an expression.\n\
12404 Usage: rwatch [-l|-location] EXPRESSION\n\
12405 A watchpoint stops execution of your program whenever the value of\n\
12406 an expression is read.\n\
12407 If -l or -location is given, this evaluates EXPRESSION and watches\n\
12408 the memory to which it refers."));
12409 set_cmd_completer (c
, expression_completer
);
12411 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
12412 Set a watchpoint for an expression.\n\
12413 Usage: awatch [-l|-location] EXPRESSION\n\
12414 A watchpoint stops execution of your program whenever the value of\n\
12415 an expression is either read or written.\n\
12416 If -l or -location is given, this evaluates EXPRESSION and watches\n\
12417 the memory to which it refers."));
12418 set_cmd_completer (c
, expression_completer
);
12420 add_info ("watchpoints", watchpoints_info
, _("\
12421 Status of specified watchpoints (all watchpoints if no argument)."));
12423 /* XXX: cagney/2005-02-23: This should be a boolean, and should
12424 respond to changes - contrary to the description. */
12425 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
12426 &can_use_hw_watchpoints
, _("\
12427 Set debugger's willingness to use watchpoint hardware."), _("\
12428 Show debugger's willingness to use watchpoint hardware."), _("\
12429 If zero, gdb will not use hardware for new watchpoints, even if\n\
12430 such is available. (However, any hardware watchpoints that were\n\
12431 created before setting this to nonzero, will continue to use watchpoint\n\
12434 show_can_use_hw_watchpoints
,
12435 &setlist
, &showlist
);
12437 can_use_hw_watchpoints
= 1;
12439 /* Tracepoint manipulation commands. */
12441 c
= add_com ("trace", class_breakpoint
, trace_command
, _("\
12442 Set a tracepoint at specified line or function.\n\
12444 BREAK_ARGS_HELP ("trace") "\n\
12445 Do \"help tracepoints\" for info on other tracepoint commands."));
12446 set_cmd_completer (c
, location_completer
);
12448 add_com_alias ("tp", "trace", class_alias
, 0);
12449 add_com_alias ("tr", "trace", class_alias
, 1);
12450 add_com_alias ("tra", "trace", class_alias
, 1);
12451 add_com_alias ("trac", "trace", class_alias
, 1);
12453 c
= add_com ("ftrace", class_breakpoint
, ftrace_command
, _("\
12454 Set a fast tracepoint at specified line or function.\n\
12456 BREAK_ARGS_HELP ("ftrace") "\n\
12457 Do \"help tracepoints\" for info on other tracepoint commands."));
12458 set_cmd_completer (c
, location_completer
);
12460 c
= add_com ("strace", class_breakpoint
, strace_command
, _("\
12461 Set a static tracepoint at specified line, function or marker.\n\
12463 strace [LOCATION] [if CONDITION]\n\
12464 LOCATION may be a line number, function name, \"*\" and an address,\n\
12465 or -m MARKER_ID.\n\
12466 If a line number is specified, probe the marker at start of code\n\
12467 for that line. If a function is specified, probe the marker at start\n\
12468 of code for that function. If an address is specified, probe the marker\n\
12469 at that exact address. If a marker id is specified, probe the marker\n\
12470 with that name. With no LOCATION, uses current execution address of\n\
12471 the selected stack frame.\n\
12472 Static tracepoints accept an extra collect action -- ``collect $_sdata''.\n\
12473 This collects arbitrary user data passed in the probe point call to the\n\
12474 tracing library. You can inspect it when analyzing the trace buffer,\n\
12475 by printing the $_sdata variable like any other convenience variable.\n\
12477 CONDITION is a boolean expression.\n\
12479 Multiple tracepoints at one place are permitted, and useful if their\n\
12480 conditions are different.\n\
12482 Do \"help breakpoints\" for info on other commands dealing with breakpoints.\n\
12483 Do \"help tracepoints\" for info on other tracepoint commands."));
12484 set_cmd_completer (c
, location_completer
);
12486 add_info ("tracepoints", tracepoints_info
, _("\
12487 Status of specified tracepoints (all tracepoints if no argument).\n\
12488 Convenience variable \"$tpnum\" contains the number of the\n\
12489 last tracepoint set."));
12491 add_info_alias ("tp", "tracepoints", 1);
12493 add_cmd ("tracepoints", class_trace
, delete_trace_command
, _("\
12494 Delete specified tracepoints.\n\
12495 Arguments are tracepoint numbers, separated by spaces.\n\
12496 No argument means delete all tracepoints."),
12499 c
= add_cmd ("tracepoints", class_trace
, disable_trace_command
, _("\
12500 Disable specified tracepoints.\n\
12501 Arguments are tracepoint numbers, separated by spaces.\n\
12502 No argument means disable all tracepoints."),
12504 deprecate_cmd (c
, "disable");
12506 c
= add_cmd ("tracepoints", class_trace
, enable_trace_command
, _("\
12507 Enable specified tracepoints.\n\
12508 Arguments are tracepoint numbers, separated by spaces.\n\
12509 No argument means enable all tracepoints."),
12511 deprecate_cmd (c
, "enable");
12513 add_com ("passcount", class_trace
, trace_pass_command
, _("\
12514 Set the passcount for a tracepoint.\n\
12515 The trace will end when the tracepoint has been passed 'count' times.\n\
12516 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
12517 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
12519 add_prefix_cmd ("save", class_breakpoint
, save_command
,
12520 _("Save breakpoint definitions as a script."),
12521 &save_cmdlist
, "save ",
12522 0/*allow-unknown*/, &cmdlist
);
12524 c
= add_cmd ("breakpoints", class_breakpoint
, save_breakpoints_command
, _("\
12525 Save current breakpoint definitions as a script.\n\
12526 This includes all types of breakpoints (breakpoints, watchpoints,\n\
12527 catchpoints, tracepoints). Use the 'source' command in another debug\n\
12528 session to restore them."),
12530 set_cmd_completer (c
, filename_completer
);
12532 c
= add_cmd ("tracepoints", class_trace
, save_tracepoints_command
, _("\
12533 Save current tracepoint definitions as a script.\n\
12534 Use the 'source' command in another debug session to restore them."),
12536 set_cmd_completer (c
, filename_completer
);
12538 c
= add_com_alias ("save-tracepoints", "save tracepoints", class_trace
, 0);
12539 deprecate_cmd (c
, "save tracepoints");
12541 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
12542 Breakpoint specific settings\n\
12543 Configure various breakpoint-specific variables such as\n\
12544 pending breakpoint behavior"),
12545 &breakpoint_set_cmdlist
, "set breakpoint ",
12546 0/*allow-unknown*/, &setlist
);
12547 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
12548 Breakpoint specific settings\n\
12549 Configure various breakpoint-specific variables such as\n\
12550 pending breakpoint behavior"),
12551 &breakpoint_show_cmdlist
, "show breakpoint ",
12552 0/*allow-unknown*/, &showlist
);
12554 add_setshow_auto_boolean_cmd ("pending", no_class
,
12555 &pending_break_support
, _("\
12556 Set debugger's behavior regarding pending breakpoints."), _("\
12557 Show debugger's behavior regarding pending breakpoints."), _("\
12558 If on, an unrecognized breakpoint location will cause gdb to create a\n\
12559 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
12560 an error. If auto, an unrecognized breakpoint location results in a\n\
12561 user-query to see if a pending breakpoint should be created."),
12563 show_pending_break_support
,
12564 &breakpoint_set_cmdlist
,
12565 &breakpoint_show_cmdlist
);
12567 pending_break_support
= AUTO_BOOLEAN_AUTO
;
12569 add_setshow_boolean_cmd ("auto-hw", no_class
,
12570 &automatic_hardware_breakpoints
, _("\
12571 Set automatic usage of hardware breakpoints."), _("\
12572 Show automatic usage of hardware breakpoints."), _("\
12573 If set, the debugger will automatically use hardware breakpoints for\n\
12574 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
12575 a warning will be emitted for such breakpoints."),
12577 show_automatic_hardware_breakpoints
,
12578 &breakpoint_set_cmdlist
,
12579 &breakpoint_show_cmdlist
);
12581 add_setshow_enum_cmd ("always-inserted", class_support
,
12582 always_inserted_enums
, &always_inserted_mode
, _("\
12583 Set mode for inserting breakpoints."), _("\
12584 Show mode for inserting breakpoints."), _("\
12585 When this mode is off, breakpoints are inserted in inferior when it is\n\
12586 resumed, and removed when execution stops. When this mode is on,\n\
12587 breakpoints are inserted immediately and removed only when the user\n\
12588 deletes the breakpoint. When this mode is auto (which is the default),\n\
12589 the behaviour depends on the non-stop setting (see help set non-stop).\n\
12590 In this case, if gdb is controlling the inferior in non-stop mode, gdb\n\
12591 behaves as if always-inserted mode is on; if gdb is controlling the\n\
12592 inferior in all-stop mode, gdb behaves as if always-inserted mode is off."),
12594 &show_always_inserted_mode
,
12595 &breakpoint_set_cmdlist
,
12596 &breakpoint_show_cmdlist
);
12598 automatic_hardware_breakpoints
= 1;
12600 observer_attach_about_to_proceed (breakpoint_about_to_proceed
);