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 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"
66 /* readline include files */
67 #include "readline/readline.h"
68 #include "readline/history.h"
70 /* readline defines this. */
73 #include "mi/mi-common.h"
75 /* Arguments to pass as context to some catch command handlers. */
76 #define CATCH_PERMANENT ((void *) (uintptr_t) 0)
77 #define CATCH_TEMPORARY ((void *) (uintptr_t) 1)
79 /* Prototypes for local functions. */
81 static void enable_delete_command (char *, int);
83 static void enable_once_command (char *, int);
85 static void disable_command (char *, int);
87 static void enable_command (char *, int);
89 static void map_breakpoint_numbers (char *, void (*) (struct breakpoint
*,
93 static void ignore_command (char *, int);
95 static int breakpoint_re_set_one (void *);
97 static void clear_command (char *, int);
99 static void catch_command (char *, int);
101 static void watch_command (char *, int);
103 static int can_use_hardware_watchpoint (struct value
*);
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 static. */
110 struct breakpoint
*set_raw_breakpoint (struct gdbarch
*gdbarch
,
111 struct symtab_and_line
,
114 static void breakpoint_adjustment_warning (CORE_ADDR
, CORE_ADDR
, int, int);
116 static CORE_ADDR
adjust_breakpoint_address (struct gdbarch
*gdbarch
,
120 static void describe_other_breakpoints (struct gdbarch
*,
121 struct program_space
*, CORE_ADDR
,
122 struct obj_section
*, int);
124 static int breakpoint_address_match (struct address_space
*aspace1
,
126 struct address_space
*aspace2
,
129 static int watchpoint_locations_match (struct bp_location
*loc1
,
130 struct bp_location
*loc2
);
132 static void breakpoints_info (char *, int);
134 static void watchpoints_info (char *, int);
136 static int breakpoint_1 (int, int, int (*) (const struct breakpoint
*));
138 static bpstat
bpstat_alloc (const struct bp_location
*, bpstat
);
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);
148 static int get_number_trailer (char **, int);
157 static int remove_breakpoint (struct bp_location
*, insertion_state_t
);
158 static int remove_breakpoint_1 (struct bp_location
*, insertion_state_t
);
160 static enum print_stop_action
print_it_typical (bpstat
);
162 static enum print_stop_action
print_bp_stop_message (bpstat bs
);
164 static int watchpoint_check (void *);
166 static void maintenance_info_breakpoints (char *, int);
168 static int hw_breakpoint_used_count (void);
170 static int hw_watchpoint_used_count (enum bptype
, int *);
172 static void hbreak_command (char *, int);
174 static void thbreak_command (char *, int);
176 static void watch_command_1 (char *, int, int);
178 static void rwatch_command (char *, int);
180 static void awatch_command (char *, int);
182 static void do_enable_breakpoint (struct breakpoint
*, enum bpdisp
);
184 static void stop_command (char *arg
, int from_tty
);
186 static void stopin_command (char *arg
, int from_tty
);
188 static void stopat_command (char *arg
, int from_tty
);
190 static char *ep_parse_optional_if_clause (char **arg
);
192 static void catch_exception_command_1 (enum exception_event_kind ex_event
,
193 char *arg
, int tempflag
, int from_tty
);
195 static void tcatch_command (char *arg
, int from_tty
);
197 static void ep_skip_leading_whitespace (char **s
);
199 static void detach_single_step_breakpoints (void);
201 static int single_step_breakpoint_inserted_here_p (struct address_space
*,
204 static void free_bp_location (struct bp_location
*loc
);
206 static struct bp_location
*allocate_bp_location (struct breakpoint
*bpt
);
208 static void update_global_location_list (int);
210 static void update_global_location_list_nothrow (int);
212 static int bpstat_remove_bp_location_callback (struct thread_info
*th
,
215 static int is_hardware_watchpoint (const struct breakpoint
*bpt
);
217 static int is_watchpoint (const struct breakpoint
*bpt
);
219 static void insert_breakpoint_locations (void);
221 static int syscall_catchpoint_p (struct breakpoint
*b
);
223 static void tracepoints_info (char *, int);
225 static void delete_trace_command (char *, int);
227 static void enable_trace_command (char *, int);
229 static void disable_trace_command (char *, int);
231 static void trace_pass_command (char *, int);
233 /* A reference-counted struct command_line. This lets multiple
234 breakpoints share a single command list. */
235 struct counted_command_line
237 /* The reference count. */
240 /* The command list. */
241 struct command_line
*commands
;
244 struct command_line
*
245 breakpoint_commands (struct breakpoint
*b
)
247 return b
->commands
? b
->commands
->commands
: NULL
;
250 /* Flag indicating that a command has proceeded the inferior past the
251 current breakpoint. */
253 static int breakpoint_proceeded
;
256 bpdisp_text (enum bpdisp disp
)
258 /* NOTE: the following values are a part of MI protocol and represent
259 values of 'disp' field returned when inferior stops at a breakpoint. */
260 static char *bpdisps
[] = {"del", "dstp", "dis", "keep"};
262 return bpdisps
[(int) disp
];
265 /* Prototypes for exported functions. */
266 /* If FALSE, gdb will not use hardware support for watchpoints, even
267 if such is available. */
268 static int can_use_hw_watchpoints
;
271 show_can_use_hw_watchpoints (struct ui_file
*file
, int from_tty
,
272 struct cmd_list_element
*c
,
275 fprintf_filtered (file
, _("\
276 Debugger's willingness to use watchpoint hardware is %s.\n"),
280 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
281 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
282 for unrecognized breakpoint locations.
283 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
284 static enum auto_boolean pending_break_support
;
286 show_pending_break_support (struct ui_file
*file
, int from_tty
,
287 struct cmd_list_element
*c
,
290 fprintf_filtered (file
, _("\
291 Debugger's behavior regarding pending breakpoints is %s.\n"),
295 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
296 set with "break" but falling in read-only memory.
297 If 0, gdb will warn about such breakpoints, but won't automatically
298 use hardware breakpoints. */
299 static int automatic_hardware_breakpoints
;
301 show_automatic_hardware_breakpoints (struct ui_file
*file
, int from_tty
,
302 struct cmd_list_element
*c
,
305 fprintf_filtered (file
, _("\
306 Automatic usage of hardware breakpoints is %s.\n"),
310 /* If on, gdb will keep breakpoints inserted even as inferior is
311 stopped, and immediately insert any new breakpoints. If off, gdb
312 will insert breakpoints into inferior only when resuming it, and
313 will remove breakpoints upon stop. If auto, GDB will behave as ON
314 if in non-stop mode, and as OFF if all-stop mode.*/
316 static const char always_inserted_auto
[] = "auto";
317 static const char always_inserted_on
[] = "on";
318 static const char always_inserted_off
[] = "off";
319 static const char *always_inserted_enums
[] = {
320 always_inserted_auto
,
325 static const char *always_inserted_mode
= always_inserted_auto
;
327 show_always_inserted_mode (struct ui_file
*file
, int from_tty
,
328 struct cmd_list_element
*c
, const char *value
)
330 if (always_inserted_mode
== always_inserted_auto
)
331 fprintf_filtered (file
, _("\
332 Always inserted breakpoint mode is %s (currently %s).\n"),
334 breakpoints_always_inserted_mode () ? "on" : "off");
336 fprintf_filtered (file
, _("Always inserted breakpoint mode is %s.\n"), value
);
340 breakpoints_always_inserted_mode (void)
342 return (always_inserted_mode
== always_inserted_on
343 || (always_inserted_mode
== always_inserted_auto
&& non_stop
));
346 void _initialize_breakpoint (void);
348 /* Are we executing breakpoint commands? */
349 static int executing_breakpoint_commands
;
351 /* Are overlay event breakpoints enabled? */
352 static int overlay_events_enabled
;
354 /* Walk the following statement or block through all breakpoints.
355 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the current
358 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
360 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
361 for (B = breakpoint_chain; \
362 B ? (TMP=B->next, 1): 0; \
365 /* Similar iterator for the low-level breakpoints. SAFE variant is not
366 provided so update_global_location_list must not be called while executing
367 the block of ALL_BP_LOCATIONS. */
369 #define ALL_BP_LOCATIONS(B,BP_TMP) \
370 for (BP_TMP = bp_location; \
371 BP_TMP < bp_location + bp_location_count && (B = *BP_TMP); \
374 /* Iterator for tracepoints only. */
376 #define ALL_TRACEPOINTS(B) \
377 for (B = breakpoint_chain; B; B = B->next) \
378 if (is_tracepoint (B))
380 /* Chains of all breakpoints defined. */
382 struct breakpoint
*breakpoint_chain
;
384 /* Array is sorted by bp_location_compare - primarily by the ADDRESS. */
386 static struct bp_location
**bp_location
;
388 /* Number of elements of BP_LOCATION. */
390 static unsigned bp_location_count
;
392 /* Maximum alignment offset between bp_target_info.PLACED_ADDRESS and ADDRESS
393 for the current elements of BP_LOCATION which get a valid result from
394 bp_location_has_shadow. You can use it for roughly limiting the subrange of
395 BP_LOCATION to scan for shadow bytes for an address you need to read. */
397 static CORE_ADDR bp_location_placed_address_before_address_max
;
399 /* Maximum offset plus alignment between
400 bp_target_info.PLACED_ADDRESS + bp_target_info.SHADOW_LEN and ADDRESS for
401 the current elements of BP_LOCATION which get a valid result from
402 bp_location_has_shadow. You can use it for roughly limiting the subrange of
403 BP_LOCATION to scan for shadow bytes for an address you need to read. */
405 static CORE_ADDR bp_location_shadow_len_after_address_max
;
407 /* The locations that no longer correspond to any breakpoint,
408 unlinked from bp_location array, but for which a hit
409 may still be reported by a target. */
410 VEC(bp_location_p
) *moribund_locations
= NULL
;
412 /* Number of last breakpoint made. */
414 static int breakpoint_count
;
416 /* The value of `breakpoint_count' before the last command that
417 created breakpoints. If the last (break-like) command created more
418 than one breakpoint, then the difference between BREAKPOINT_COUNT
419 and PREV_BREAKPOINT_COUNT is more than one. */
420 static int prev_breakpoint_count
;
422 /* Number of last tracepoint made. */
424 static int tracepoint_count
;
426 static struct cmd_list_element
*breakpoint_set_cmdlist
;
427 static struct cmd_list_element
*breakpoint_show_cmdlist
;
428 static struct cmd_list_element
*save_cmdlist
;
430 /* Return whether a breakpoint is an active enabled breakpoint. */
432 breakpoint_enabled (struct breakpoint
*b
)
434 return (b
->enable_state
== bp_enabled
);
437 /* Set breakpoint count to NUM. */
440 set_breakpoint_count (int num
)
442 prev_breakpoint_count
= breakpoint_count
;
443 breakpoint_count
= num
;
444 set_internalvar_integer (lookup_internalvar ("bpnum"), num
);
447 /* Used by `start_rbreak_breakpoints' below, to record the current
448 breakpoint count before "rbreak" creates any breakpoint. */
449 static int rbreak_start_breakpoint_count
;
451 /* Called at the start an "rbreak" command to record the first
455 start_rbreak_breakpoints (void)
457 rbreak_start_breakpoint_count
= breakpoint_count
;
460 /* Called at the end of an "rbreak" command to record the last
464 end_rbreak_breakpoints (void)
466 prev_breakpoint_count
= rbreak_start_breakpoint_count
;
469 /* Used in run_command to zero the hit count when a new run starts. */
472 clear_breakpoint_hit_counts (void)
474 struct breakpoint
*b
;
480 /* Allocate a new counted_command_line with reference count of 1.
481 The new structure owns COMMANDS. */
483 static struct counted_command_line
*
484 alloc_counted_command_line (struct command_line
*commands
)
486 struct counted_command_line
*result
487 = xmalloc (sizeof (struct counted_command_line
));
490 result
->commands
= commands
;
494 /* Increment reference count. This does nothing if CMD is NULL. */
497 incref_counted_command_line (struct counted_command_line
*cmd
)
503 /* Decrement reference count. If the reference count reaches 0,
504 destroy the counted_command_line. Sets *CMDP to NULL. This does
505 nothing if *CMDP is NULL. */
508 decref_counted_command_line (struct counted_command_line
**cmdp
)
512 if (--(*cmdp
)->refc
== 0)
514 free_command_lines (&(*cmdp
)->commands
);
521 /* A cleanup function that calls decref_counted_command_line. */
524 do_cleanup_counted_command_line (void *arg
)
526 decref_counted_command_line (arg
);
529 /* Create a cleanup that calls decref_counted_command_line on the
532 static struct cleanup
*
533 make_cleanup_decref_counted_command_line (struct counted_command_line
**cmdp
)
535 return make_cleanup (do_cleanup_counted_command_line
, cmdp
);
538 /* Default address, symtab and line to put a breakpoint at
539 for "break" command with no arg.
540 if default_breakpoint_valid is zero, the other three are
541 not valid, and "break" with no arg is an error.
543 This set by print_stack_frame, which calls set_default_breakpoint. */
545 int default_breakpoint_valid
;
546 CORE_ADDR default_breakpoint_address
;
547 struct symtab
*default_breakpoint_symtab
;
548 int default_breakpoint_line
;
549 struct program_space
*default_breakpoint_pspace
;
552 /* *PP is a string denoting a breakpoint. Get the number of the breakpoint.
553 Advance *PP after the string and any trailing whitespace.
555 Currently the string can either be a number or "$" followed by the name
556 of a convenience variable. Making it an expression wouldn't work well
557 for map_breakpoint_numbers (e.g. "4 + 5 + 6").
559 If the string is a NULL pointer, that denotes the last breakpoint.
561 TRAILER is a character which can be found after the number; most
562 commonly this is `-'. If you don't want a trailer, use \0. */
564 get_number_trailer (char **pp
, int trailer
)
566 int retval
= 0; /* default */
570 /* Empty line means refer to the last breakpoint. */
571 return breakpoint_count
;
574 /* Make a copy of the name, so we can null-terminate it
575 to pass to lookup_internalvar(). */
580 while (isalnum (*p
) || *p
== '_')
582 varname
= (char *) alloca (p
- start
+ 1);
583 strncpy (varname
, start
, p
- start
);
584 varname
[p
- start
] = '\0';
585 if (get_internalvar_integer (lookup_internalvar (varname
), &val
))
589 printf_filtered (_("Convenience variable must have integer value.\n"));
597 while (*p
>= '0' && *p
<= '9')
600 /* There is no number here. (e.g. "cond a == b"). */
602 /* Skip non-numeric token */
603 while (*p
&& !isspace((int) *p
))
605 /* Return zero, which caller must interpret as error. */
611 if (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
613 /* Trailing junk: return 0 and let caller print error msg. */
614 while (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
625 /* Like get_number_trailer, but don't allow a trailer. */
627 get_number (char **pp
)
629 return get_number_trailer (pp
, '\0');
632 /* Parse a number or a range.
633 * A number will be of the form handled by get_number.
634 * A range will be of the form <number1> - <number2>, and
635 * will represent all the integers between number1 and number2,
638 * While processing a range, this fuction is called iteratively;
639 * At each call it will return the next value in the range.
641 * At the beginning of parsing a range, the char pointer PP will
642 * be advanced past <number1> and left pointing at the '-' token.
643 * Subsequent calls will not advance the pointer until the range
644 * is completed. The call that completes the range will advance
645 * pointer PP past <number2>.
649 get_number_or_range (char **pp
)
651 static int last_retval
, end_value
;
652 static char *end_ptr
;
653 static int in_range
= 0;
657 /* Default case: pp is pointing either to a solo number,
658 or to the first number of a range. */
659 last_retval
= get_number_trailer (pp
, '-');
664 /* This is the start of a range (<number1> - <number2>).
665 Skip the '-', parse and remember the second number,
666 and also remember the end of the final token. */
670 while (isspace ((int) *end_ptr
))
671 end_ptr
++; /* skip white space */
672 end_value
= get_number (temp
);
673 if (end_value
< last_retval
)
675 error (_("inverted range"));
677 else if (end_value
== last_retval
)
679 /* degenerate range (number1 == number2). Advance the
680 token pointer so that the range will be treated as a
689 error (_("negative value"));
692 /* pp points to the '-' that betokens a range. All
693 number-parsing has already been done. Return the next
694 integer value (one greater than the saved previous value).
695 Do not advance the token pointer 'pp' until the end of range
698 if (++last_retval
== end_value
)
700 /* End of range reached; advance token pointer. */
708 /* Return the breakpoint with the specified number, or NULL
709 if the number does not refer to an existing breakpoint. */
712 get_breakpoint (int num
)
714 struct breakpoint
*b
;
717 if (b
->number
== num
)
726 set_breakpoint_condition (struct breakpoint
*b
, char *exp
,
729 struct bp_location
*loc
= b
->loc
;
731 for (; loc
; loc
= loc
->next
)
736 xfree (b
->cond_string
);
737 b
->cond_string
= NULL
;
744 printf_filtered (_("Breakpoint %d now unconditional.\n"), b
->number
);
750 /* I don't know if it matters whether this is the string the user
751 typed in or the decompiled expression. */
752 b
->cond_string
= xstrdup (arg
);
753 b
->condition_not_parsed
= 0;
755 if (is_watchpoint (b
))
757 innermost_block
= NULL
;
759 b
->cond_exp
= parse_exp_1 (&arg
, 0, 0);
761 error (_("Junk at end of expression"));
762 b
->cond_exp_valid_block
= innermost_block
;
766 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
770 parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
772 error (_("Junk at end of expression"));
776 breakpoints_changed ();
777 observer_notify_breakpoint_modified (b
->number
);
780 /* condition N EXP -- set break condition of breakpoint N to EXP. */
783 condition_command (char *arg
, int from_tty
)
785 struct breakpoint
*b
;
790 error_no_arg (_("breakpoint number"));
793 bnum
= get_number (&p
);
795 error (_("Bad breakpoint argument: '%s'"), arg
);
798 if (b
->number
== bnum
)
800 set_breakpoint_condition (b
, p
, from_tty
);
804 error (_("No breakpoint number %d."), bnum
);
807 /* Check that COMMAND do not contain commands that are suitable
808 only for tracepoints and not suitable for ordinary breakpoints.
809 Throw if any such commands is found.
812 check_no_tracepoint_commands (struct command_line
*commands
)
814 struct command_line
*c
;
816 for (c
= commands
; c
; c
= c
->next
)
820 if (c
->control_type
== while_stepping_control
)
821 error (_("The 'while-stepping' command can only be used for tracepoints"));
823 for (i
= 0; i
< c
->body_count
; ++i
)
824 check_no_tracepoint_commands ((c
->body_list
)[i
]);
826 /* Not that command parsing removes leading whitespace and comment
827 lines and also empty lines. So, we only need to check for
829 if (strstr (c
->line
, "collect ") == c
->line
)
830 error (_("The 'collect' command can only be used for tracepoints"));
832 if (strstr (c
->line
, "teval ") == c
->line
)
833 error (_("The 'teval' command can only be used for tracepoints"));
837 /* Encapsulate tests for different types of tracepoints. */
840 is_tracepoint (const struct breakpoint
*b
)
842 return (b
->type
== bp_tracepoint
|| b
->type
== bp_fast_tracepoint
);
845 /* A helper function that validsates that COMMANDS are valid for a
846 breakpoint. This function will throw an exception if a problem is
850 validate_commands_for_breakpoint (struct breakpoint
*b
,
851 struct command_line
*commands
)
853 if (is_tracepoint (b
))
855 /* We need to verify that each top-level element of commands
856 is valid for tracepoints, that there's at most one while-stepping
857 element, and that while-stepping's body has valid tracing commands
858 excluding nested while-stepping. */
859 struct command_line
*c
;
860 struct command_line
*while_stepping
= 0;
861 for (c
= commands
; c
; c
= c
->next
)
863 if (c
->control_type
== while_stepping_control
)
865 if (b
->type
== bp_fast_tracepoint
)
866 error (_("The 'while-stepping' command cannot be used for fast tracepoint"));
869 error (_("The 'while-stepping' command can be used only once"));
876 struct command_line
*c2
;
878 gdb_assert (while_stepping
->body_count
== 1);
879 c2
= while_stepping
->body_list
[0];
880 for (; c2
; c2
= c2
->next
)
882 if (c2
->control_type
== while_stepping_control
)
883 error (_("The 'while-stepping' command cannot be nested"));
889 check_no_tracepoint_commands (commands
);
893 /* Set the command list of B to COMMANDS. If breakpoint is tracepoint,
894 validate that only allowed commands are included.
898 breakpoint_set_commands (struct breakpoint
*b
, struct command_line
*commands
)
900 validate_commands_for_breakpoint (b
, commands
);
902 decref_counted_command_line (&b
->commands
);
903 b
->commands
= alloc_counted_command_line (commands
);
904 breakpoints_changed ();
905 observer_notify_breakpoint_modified (b
->number
);
909 check_tracepoint_command (char *line
, void *closure
)
911 struct breakpoint
*b
= closure
;
913 validate_actionline (&line
, b
);
916 /* A structure used to pass information through
917 map_breakpoint_numbers. */
921 /* True if the command was typed at a tty. */
924 /* The breakpoint range spec. */
927 /* Non-NULL if the body of the commands are being read from this
928 already-parsed command. */
929 struct command_line
*control
;
931 /* The command lines read from the user, or NULL if they have not
933 struct counted_command_line
*cmd
;
936 /* A callback for map_breakpoint_numbers that sets the commands for
940 do_map_commands_command (struct breakpoint
*b
, void *data
)
942 struct commands_info
*info
= data
;
944 if (info
->cmd
== NULL
)
946 struct command_line
*l
;
948 if (info
->control
!= NULL
)
949 l
= copy_command_lines (info
->control
->body_list
[0]);
952 struct cleanup
*old_chain
;
955 str
= xstrprintf (_("Type commands for breakpoint(s) %s, one per line."),
958 old_chain
= make_cleanup (xfree
, str
);
960 l
= read_command_lines (str
,
963 ? check_tracepoint_command
: 0),
966 do_cleanups (old_chain
);
969 info
->cmd
= alloc_counted_command_line (l
);
972 /* If a breakpoint was on the list more than once, we don't need to
974 if (b
->commands
!= info
->cmd
)
976 validate_commands_for_breakpoint (b
, info
->cmd
->commands
);
977 incref_counted_command_line (info
->cmd
);
978 decref_counted_command_line (&b
->commands
);
979 b
->commands
= info
->cmd
;
980 breakpoints_changed ();
981 observer_notify_breakpoint_modified (b
->number
);
986 commands_command_1 (char *arg
, int from_tty
, struct command_line
*control
)
988 struct cleanup
*cleanups
;
989 struct commands_info info
;
991 info
.from_tty
= from_tty
;
992 info
.control
= control
;
994 /* If we read command lines from the user, then `info' will hold an
995 extra reference to the commands that we must clean up. */
996 cleanups
= make_cleanup_decref_counted_command_line (&info
.cmd
);
998 if (arg
== NULL
|| !*arg
)
1000 if (breakpoint_count
- prev_breakpoint_count
> 1)
1001 arg
= xstrprintf ("%d-%d", prev_breakpoint_count
+ 1, breakpoint_count
);
1002 else if (breakpoint_count
> 0)
1003 arg
= xstrprintf ("%d", breakpoint_count
);
1006 /* So that we don't try to free the incoming non-NULL
1007 argument in the cleanup below. Mapping breakpoint
1008 numbers will fail in this case. */
1013 /* The command loop has some static state, so we need to preserve
1015 arg
= xstrdup (arg
);
1018 make_cleanup (xfree
, arg
);
1022 map_breakpoint_numbers (arg
, do_map_commands_command
, &info
);
1024 if (info
.cmd
== NULL
)
1025 error (_("No breakpoints specified."));
1027 do_cleanups (cleanups
);
1031 commands_command (char *arg
, int from_tty
)
1033 commands_command_1 (arg
, from_tty
, NULL
);
1036 /* Like commands_command, but instead of reading the commands from
1037 input stream, takes them from an already parsed command structure.
1039 This is used by cli-script.c to DTRT with breakpoint commands
1040 that are part of if and while bodies. */
1041 enum command_control_type
1042 commands_from_control_command (char *arg
, struct command_line
*cmd
)
1044 commands_command_1 (arg
, 0, cmd
);
1045 return simple_control
;
1048 /* Return non-zero if BL->TARGET_INFO contains valid information. */
1051 bp_location_has_shadow (struct bp_location
*bl
)
1053 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
1057 if (bl
->target_info
.shadow_len
== 0)
1058 /* bp isn't valid, or doesn't shadow memory. */
1063 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
1064 by replacing any memory breakpoints with their shadowed contents.
1066 The range of shadowed area by each bp_location is:
1067 b->address - bp_location_placed_address_before_address_max
1068 up to b->address + bp_location_shadow_len_after_address_max
1069 The range we were requested to resolve shadows for is:
1070 memaddr ... memaddr + len
1071 Thus the safe cutoff boundaries for performance optimization are
1072 memaddr + len <= b->address - bp_location_placed_address_before_address_max
1074 b->address + bp_location_shadow_len_after_address_max <= memaddr */
1077 breakpoint_restore_shadows (gdb_byte
*buf
, ULONGEST memaddr
, LONGEST len
)
1079 /* Left boundary, right boundary and median element of our binary search. */
1080 unsigned bc_l
, bc_r
, bc
;
1082 /* Find BC_L which is a leftmost element which may affect BUF content. It is
1083 safe to report lower value but a failure to report higher one. */
1086 bc_r
= bp_location_count
;
1087 while (bc_l
+ 1 < bc_r
)
1089 struct bp_location
*b
;
1091 bc
= (bc_l
+ bc_r
) / 2;
1092 b
= bp_location
[bc
];
1094 /* Check first B->ADDRESS will not overflow due to the added constant.
1095 Then advance the left boundary only if we are sure the BC element can
1096 in no way affect the BUF content (MEMADDR to MEMADDR + LEN range).
1098 Use the BP_LOCATION_SHADOW_LEN_AFTER_ADDRESS_MAX safety offset so that
1099 we cannot miss a breakpoint with its shadow range tail still reaching
1102 if (b
->address
+ bp_location_shadow_len_after_address_max
>= b
->address
1103 && b
->address
+ bp_location_shadow_len_after_address_max
<= memaddr
)
1109 /* Now do full processing of the found relevant range of elements. */
1111 for (bc
= bc_l
; bc
< bp_location_count
; bc
++)
1113 struct bp_location
*b
= bp_location
[bc
];
1114 CORE_ADDR bp_addr
= 0;
1118 /* bp_location array has B->OWNER always non-NULL. */
1119 if (b
->owner
->type
== bp_none
)
1120 warning (_("reading through apparently deleted breakpoint #%d?"),
1123 /* Performance optimization: any futher element can no longer affect BUF
1126 if (b
->address
>= bp_location_placed_address_before_address_max
1127 && memaddr
+ len
<= b
->address
1128 - bp_location_placed_address_before_address_max
)
1131 if (!bp_location_has_shadow (b
))
1133 if (!breakpoint_address_match (b
->target_info
.placed_address_space
, 0,
1134 current_program_space
->aspace
, 0))
1137 /* Addresses and length of the part of the breakpoint that
1139 bp_addr
= b
->target_info
.placed_address
;
1140 bp_size
= b
->target_info
.shadow_len
;
1142 if (bp_addr
+ bp_size
<= memaddr
)
1143 /* The breakpoint is entirely before the chunk of memory we
1147 if (bp_addr
>= memaddr
+ len
)
1148 /* The breakpoint is entirely after the chunk of memory we are
1152 /* Offset within shadow_contents. */
1153 if (bp_addr
< memaddr
)
1155 /* Only copy the second part of the breakpoint. */
1156 bp_size
-= memaddr
- bp_addr
;
1157 bptoffset
= memaddr
- bp_addr
;
1161 if (bp_addr
+ bp_size
> memaddr
+ len
)
1163 /* Only copy the first part of the breakpoint. */
1164 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
1167 memcpy (buf
+ bp_addr
- memaddr
,
1168 b
->target_info
.shadow_contents
+ bptoffset
, bp_size
);
1173 /* A wrapper function for inserting catchpoints. */
1175 insert_catchpoint (struct ui_out
*uo
, void *args
)
1177 struct breakpoint
*b
= (struct breakpoint
*) args
;
1179 gdb_assert (b
->type
== bp_catchpoint
);
1180 gdb_assert (b
->ops
!= NULL
&& b
->ops
->insert
!= NULL
);
1185 /* Return true if BPT is of any hardware watchpoint kind. */
1188 is_hardware_watchpoint (const struct breakpoint
*bpt
)
1190 return (bpt
->type
== bp_hardware_watchpoint
1191 || bpt
->type
== bp_read_watchpoint
1192 || bpt
->type
== bp_access_watchpoint
);
1195 /* Return true if BPT is of any watchpoint kind, hardware or
1199 is_watchpoint (const struct breakpoint
*bpt
)
1201 return (is_hardware_watchpoint (bpt
)
1202 || bpt
->type
== bp_watchpoint
);
1205 /* Find the current value of a watchpoint on EXP. Return the value in
1206 *VALP and *RESULTP and the chain of intermediate and final values
1207 in *VAL_CHAIN. RESULTP and VAL_CHAIN may be NULL if the caller does
1210 If a memory error occurs while evaluating the expression, *RESULTP will
1211 be set to NULL. *RESULTP may be a lazy value, if the result could
1212 not be read from memory. It is used to determine whether a value
1213 is user-specified (we should watch the whole value) or intermediate
1214 (we should watch only the bit used to locate the final value).
1216 If the final value, or any intermediate value, could not be read
1217 from memory, *VALP will be set to NULL. *VAL_CHAIN will still be
1218 set to any referenced values. *VALP will never be a lazy value.
1219 This is the value which we store in struct breakpoint.
1221 If VAL_CHAIN is non-NULL, *VAL_CHAIN will be released from the
1222 value chain. The caller must free the values individually. If
1223 VAL_CHAIN is NULL, all generated values will be left on the value
1227 fetch_watchpoint_value (struct expression
*exp
, struct value
**valp
,
1228 struct value
**resultp
, struct value
**val_chain
)
1230 struct value
*mark
, *new_mark
, *result
;
1231 volatile struct gdb_exception ex
;
1239 /* Evaluate the expression. */
1240 mark
= value_mark ();
1243 TRY_CATCH (ex
, RETURN_MASK_ALL
)
1245 result
= evaluate_expression (exp
);
1249 /* Ignore memory errors, we want watchpoints pointing at
1250 inaccessible memory to still be created; otherwise, throw the
1251 error to some higher catcher. */
1257 throw_exception (ex
);
1262 new_mark
= value_mark ();
1263 if (mark
== new_mark
)
1268 /* Make sure it's not lazy, so that after the target stops again we
1269 have a non-lazy previous value to compare with. */
1271 && (!value_lazy (result
) || gdb_value_fetch_lazy (result
)))
1276 /* Return the chain of intermediate values. We use this to
1277 decide which addresses to watch. */
1278 *val_chain
= new_mark
;
1279 value_release_to_mark (mark
);
1283 /* Assuming that B is a watchpoint: returns true if the current thread
1284 and its running state are safe to evaluate or update watchpoint B.
1285 Watchpoints on local expressions need to be evaluated in the
1286 context of the thread that was current when the watchpoint was
1287 created, and, that thread needs to be stopped to be able to select
1288 the correct frame context. Watchpoints on global expressions can
1289 be evaluated on any thread, and in any state. It is presently left
1290 to the target allowing memory accesses when threads are
1294 watchpoint_in_thread_scope (struct breakpoint
*b
)
1296 return (ptid_equal (b
->watchpoint_thread
, null_ptid
)
1297 || (ptid_equal (inferior_ptid
, b
->watchpoint_thread
)
1298 && !is_executing (inferior_ptid
)));
1301 /* Assuming that B is a watchpoint:
1302 - Reparse watchpoint expression, if REPARSE is non-zero
1303 - Evaluate expression and store the result in B->val
1304 - Evaluate the condition if there is one, and store the result
1306 - Update the list of values that must be watched in B->loc.
1308 If the watchpoint disposition is disp_del_at_next_stop, then do nothing.
1309 If this is local watchpoint that is out of scope, delete it.
1311 Even with `set breakpoint always-inserted on' the watchpoints are removed
1312 + inserted on each stop here. Normal breakpoints must never be removed
1313 because they might be missed by a running thread when debugging in non-stop
1314 mode. On the other hand, hardware watchpoints (is_hardware_watchpoint;
1315 processed here) are specific to each LWP since they are stored in each LWP's
1316 hardware debug registers. Therefore, such LWP must be stopped first in
1317 order to be able to modify its hardware watchpoints.
1319 Hardware watchpoints must be reset exactly once after being presented to the
1320 user. It cannot be done sooner, because it would reset the data used to
1321 present the watchpoint hit to the user. And it must not be done later
1322 because it could display the same single watchpoint hit during multiple GDB
1323 stops. Note that the latter is relevant only to the hardware watchpoint
1324 types bp_read_watchpoint and bp_access_watchpoint. False hit by
1325 bp_hardware_watchpoint is not user-visible - its hit is suppressed if the
1326 memory content has not changed.
1328 The following constraints influence the location where we can reset hardware
1331 * target_stopped_by_watchpoint and target_stopped_data_address are called
1332 several times when GDB stops.
1335 * Multiple hardware watchpoints can be hit at the same time, causing GDB to
1336 stop. GDB only presents one hardware watchpoint hit at a time as the
1337 reason for stopping, and all the other hits are presented later, one after
1338 the other, each time the user requests the execution to be resumed.
1339 Execution is not resumed for the threads still having pending hit event
1340 stored in LWP_INFO->STATUS. While the watchpoint is already removed from
1341 the inferior on the first stop the thread hit event is kept being reported
1342 from its cached value by linux_nat_stopped_data_address until the real
1343 thread resume happens after the watchpoint gets presented and thus its
1344 LWP_INFO->STATUS gets reset.
1346 Therefore the hardware watchpoint hit can get safely reset on the watchpoint
1347 removal from inferior. */
1350 update_watchpoint (struct breakpoint
*b
, int reparse
)
1352 int within_current_scope
;
1353 struct frame_id saved_frame_id
;
1356 /* If this is a local watchpoint, we only want to check if the
1357 watchpoint frame is in scope if the current thread is the thread
1358 that was used to create the watchpoint. */
1359 if (!watchpoint_in_thread_scope (b
))
1362 /* We don't free locations. They are stored in bp_location array and
1363 update_global_locations will eventually delete them and remove
1364 breakpoints if needed. */
1367 if (b
->disposition
== disp_del_at_next_stop
)
1372 /* Determine if the watchpoint is within scope. */
1373 if (b
->exp_valid_block
== NULL
)
1374 within_current_scope
= 1;
1377 struct frame_info
*fi
;
1379 /* Save the current frame's ID so we can restore it after
1380 evaluating the watchpoint expression on its own frame. */
1381 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
1382 took a frame parameter, so that we didn't have to change the
1385 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
1387 fi
= frame_find_by_id (b
->watchpoint_frame
);
1388 within_current_scope
= (fi
!= NULL
);
1389 if (within_current_scope
)
1393 if (within_current_scope
&& reparse
)
1402 b
->exp
= parse_exp_1 (&s
, b
->exp_valid_block
, 0);
1403 /* If the meaning of expression itself changed, the old value is
1404 no longer relevant. We don't want to report a watchpoint hit
1405 to the user when the old value and the new value may actually
1406 be completely different objects. */
1407 value_free (b
->val
);
1411 /* Note that unlike with breakpoints, the watchpoint's condition
1412 expression is stored in the breakpoint object, not in the
1413 locations (re)created below. */
1414 if (b
->cond_string
!= NULL
)
1416 if (b
->cond_exp
!= NULL
)
1418 xfree (b
->cond_exp
);
1423 b
->cond_exp
= parse_exp_1 (&s
, b
->cond_exp_valid_block
, 0);
1427 /* If we failed to parse the expression, for example because
1428 it refers to a global variable in a not-yet-loaded shared library,
1429 don't try to insert watchpoint. We don't automatically delete
1430 such watchpoint, though, since failure to parse expression
1431 is different from out-of-scope watchpoint. */
1432 if ( !target_has_execution
)
1434 /* Without execution, memory can't change. No use to try and
1435 set watchpoint locations. The watchpoint will be reset when
1436 the target gains execution, through breakpoint_re_set. */
1438 else if (within_current_scope
&& b
->exp
)
1440 struct value
*val_chain
, *v
, *result
, *next
;
1441 struct program_space
*frame_pspace
;
1443 fetch_watchpoint_value (b
->exp
, &v
, &result
, &val_chain
);
1445 /* Avoid setting b->val if it's already set. The meaning of
1446 b->val is 'the last value' user saw, and we should update
1447 it only if we reported that last value to user. As it
1448 happens, the code that reports it updates b->val directly. */
1455 /* Change the type of breakpoint between hardware assisted or an
1456 ordinary watchpoint depending on the hardware support and free
1457 hardware slots. REPARSE is set when the inferior is started. */
1458 if ((b
->type
== bp_watchpoint
|| b
->type
== bp_hardware_watchpoint
)
1461 int i
, mem_cnt
, other_type_used
;
1463 /* We need to determine how many resources are already used
1464 for all other hardware watchpoints to see if we still have
1465 enough resources to also fit this watchpoint in as well.
1466 To avoid the hw_watchpoint_used_count call below from counting
1467 this watchpoint, make sure that it is marked as a software
1469 b
->type
= bp_watchpoint
;
1470 i
= hw_watchpoint_used_count (bp_hardware_watchpoint
,
1472 mem_cnt
= can_use_hardware_watchpoint (val_chain
);
1475 b
->type
= bp_watchpoint
;
1478 int target_resources_ok
= target_can_use_hardware_watchpoint
1479 (bp_hardware_watchpoint
, i
+ mem_cnt
, other_type_used
);
1480 if (target_resources_ok
<= 0)
1481 b
->type
= bp_watchpoint
;
1483 b
->type
= bp_hardware_watchpoint
;
1487 frame_pspace
= get_frame_program_space (get_selected_frame (NULL
));
1489 /* Look at each value on the value chain. */
1490 for (v
= val_chain
; v
; v
= next
)
1492 /* If it's a memory location, and GDB actually needed
1493 its contents to evaluate the expression, then we
1494 must watch it. If the first value returned is
1495 still lazy, that means an error occurred reading it;
1496 watch it anyway in case it becomes readable. */
1497 if (VALUE_LVAL (v
) == lval_memory
1498 && (v
== val_chain
|| ! value_lazy (v
)))
1500 struct type
*vtype
= check_typedef (value_type (v
));
1502 /* We only watch structs and arrays if user asked
1503 for it explicitly, never if they just happen to
1504 appear in the middle of some value chain. */
1506 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
1507 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
1511 struct bp_location
*loc
, **tmp
;
1513 addr
= value_address (v
);
1514 len
= TYPE_LENGTH (value_type (v
));
1516 if (b
->type
== bp_read_watchpoint
)
1518 else if (b
->type
== bp_access_watchpoint
)
1521 loc
= allocate_bp_location (b
);
1522 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
1525 loc
->gdbarch
= get_type_arch (value_type (v
));
1527 loc
->pspace
= frame_pspace
;
1528 loc
->address
= addr
;
1530 loc
->watchpoint_type
= type
;
1534 next
= value_next (v
);
1539 /* If a software watchpoint is not watching any memory, then the
1540 above left it without any location set up. But,
1541 bpstat_stop_status requires a location to be able to report
1542 stops, so make sure there's at least a dummy one. */
1543 if (b
->type
== bp_watchpoint
&& b
->loc
== NULL
)
1545 b
->loc
= allocate_bp_location (b
);
1546 b
->loc
->pspace
= frame_pspace
;
1547 b
->loc
->address
= -1;
1548 b
->loc
->length
= -1;
1549 b
->loc
->watchpoint_type
= -1;
1552 else if (!within_current_scope
)
1554 printf_filtered (_("\
1555 Watchpoint %d deleted because the program has left the block \n\
1556 in which its expression is valid.\n"),
1558 if (b
->related_breakpoint
)
1560 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
1561 b
->related_breakpoint
->related_breakpoint
= NULL
;
1562 b
->related_breakpoint
= NULL
;
1564 b
->disposition
= disp_del_at_next_stop
;
1567 /* Restore the selected frame. */
1569 select_frame (frame_find_by_id (saved_frame_id
));
1573 /* Returns 1 iff breakpoint location should be
1574 inserted in the inferior. */
1576 should_be_inserted (struct bp_location
*bpt
)
1578 if (bpt
->owner
== NULL
|| !breakpoint_enabled (bpt
->owner
))
1581 if (bpt
->owner
->disposition
== disp_del_at_next_stop
)
1584 if (!bpt
->enabled
|| bpt
->shlib_disabled
|| bpt
->duplicate
)
1587 /* This is set for example, when we're attached to the parent of a
1588 vfork, and have detached from the child. The child is running
1589 free, and we expect it to do an exec or exit, at which point the
1590 OS makes the parent schedulable again (and the target reports
1591 that the vfork is done). Until the child is done with the shared
1592 memory region, do not insert breakpoints in the parent, otherwise
1593 the child could still trip on the parent's breakpoints. Since
1594 the parent is blocked anyway, it won't miss any breakpoint. */
1595 if (bpt
->pspace
->breakpoints_not_allowed
)
1598 /* Tracepoints are inserted by the target at a time of its choosing,
1600 if (is_tracepoint (bpt
->owner
))
1606 /* Insert a low-level "breakpoint" of some type. BPT is the breakpoint.
1607 Any error messages are printed to TMP_ERROR_STREAM; and DISABLED_BREAKS,
1608 and HW_BREAKPOINT_ERROR are used to report problems.
1610 NOTE drow/2003-09-09: This routine could be broken down to an object-style
1611 method for each breakpoint or catchpoint type. */
1613 insert_bp_location (struct bp_location
*bpt
,
1614 struct ui_file
*tmp_error_stream
,
1615 int *disabled_breaks
,
1616 int *hw_breakpoint_error
)
1620 if (!should_be_inserted (bpt
) || bpt
->inserted
)
1623 /* Initialize the target-specific information. */
1624 memset (&bpt
->target_info
, 0, sizeof (bpt
->target_info
));
1625 bpt
->target_info
.placed_address
= bpt
->address
;
1626 bpt
->target_info
.placed_address_space
= bpt
->pspace
->aspace
;
1628 if (bpt
->loc_type
== bp_loc_software_breakpoint
1629 || bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1631 if (bpt
->owner
->type
!= bp_hardware_breakpoint
)
1633 /* If the explicitly specified breakpoint type
1634 is not hardware breakpoint, check the memory map to see
1635 if the breakpoint address is in read only memory or not.
1636 Two important cases are:
1637 - location type is not hardware breakpoint, memory
1638 is readonly. We change the type of the location to
1639 hardware breakpoint.
1640 - location type is hardware breakpoint, memory is read-write.
1641 This means we've previously made the location hardware one, but
1642 then the memory map changed, so we undo.
1644 When breakpoints are removed, remove_breakpoints will
1645 use location types we've just set here, the only possible
1646 problem is that memory map has changed during running program,
1647 but it's not going to work anyway with current gdb. */
1648 struct mem_region
*mr
1649 = lookup_mem_region (bpt
->target_info
.placed_address
);
1653 if (automatic_hardware_breakpoints
)
1655 enum bp_loc_type new_type
;
1657 if (mr
->attrib
.mode
!= MEM_RW
)
1658 new_type
= bp_loc_hardware_breakpoint
;
1660 new_type
= bp_loc_software_breakpoint
;
1662 if (new_type
!= bpt
->loc_type
)
1664 static int said
= 0;
1666 bpt
->loc_type
= new_type
;
1669 fprintf_filtered (gdb_stdout
, _("\
1670 Note: automatically using hardware breakpoints for read-only addresses.\n"));
1675 else if (bpt
->loc_type
== bp_loc_software_breakpoint
1676 && mr
->attrib
.mode
!= MEM_RW
)
1677 warning (_("cannot set software breakpoint at readonly address %s"),
1678 paddress (bpt
->gdbarch
, bpt
->address
));
1682 /* First check to see if we have to handle an overlay. */
1683 if (overlay_debugging
== ovly_off
1684 || bpt
->section
== NULL
1685 || !(section_is_overlay (bpt
->section
)))
1687 /* No overlay handling: just set the breakpoint. */
1689 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1690 val
= target_insert_hw_breakpoint (bpt
->gdbarch
,
1693 val
= target_insert_breakpoint (bpt
->gdbarch
,
1698 /* This breakpoint is in an overlay section.
1699 Shall we set a breakpoint at the LMA? */
1700 if (!overlay_events_enabled
)
1702 /* Yes -- overlay event support is not active,
1703 so we must try to set a breakpoint at the LMA.
1704 This will not work for a hardware breakpoint. */
1705 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1706 warning (_("hardware breakpoint %d not supported in overlay!"),
1707 bpt
->owner
->number
);
1710 CORE_ADDR addr
= overlay_unmapped_address (bpt
->address
,
1712 /* Set a software (trap) breakpoint at the LMA. */
1713 bpt
->overlay_target_info
= bpt
->target_info
;
1714 bpt
->overlay_target_info
.placed_address
= addr
;
1715 val
= target_insert_breakpoint (bpt
->gdbarch
,
1716 &bpt
->overlay_target_info
);
1718 fprintf_unfiltered (tmp_error_stream
,
1719 "Overlay breakpoint %d failed: in ROM?\n",
1720 bpt
->owner
->number
);
1723 /* Shall we set a breakpoint at the VMA? */
1724 if (section_is_mapped (bpt
->section
))
1726 /* Yes. This overlay section is mapped into memory. */
1727 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1728 val
= target_insert_hw_breakpoint (bpt
->gdbarch
,
1731 val
= target_insert_breakpoint (bpt
->gdbarch
,
1736 /* No. This breakpoint will not be inserted.
1737 No error, but do not mark the bp as 'inserted'. */
1744 /* Can't set the breakpoint. */
1745 if (solib_name_from_address (bpt
->pspace
, bpt
->address
))
1747 /* See also: disable_breakpoints_in_shlibs. */
1749 bpt
->shlib_disabled
= 1;
1750 if (!*disabled_breaks
)
1752 fprintf_unfiltered (tmp_error_stream
,
1753 "Cannot insert breakpoint %d.\n",
1754 bpt
->owner
->number
);
1755 fprintf_unfiltered (tmp_error_stream
,
1756 "Temporarily disabling shared library breakpoints:\n");
1758 *disabled_breaks
= 1;
1759 fprintf_unfiltered (tmp_error_stream
,
1760 "breakpoint #%d\n", bpt
->owner
->number
);
1764 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1766 *hw_breakpoint_error
= 1;
1767 fprintf_unfiltered (tmp_error_stream
,
1768 "Cannot insert hardware breakpoint %d.\n",
1769 bpt
->owner
->number
);
1773 fprintf_unfiltered (tmp_error_stream
,
1774 "Cannot insert breakpoint %d.\n",
1775 bpt
->owner
->number
);
1776 fprintf_filtered (tmp_error_stream
,
1777 "Error accessing memory address ");
1778 fputs_filtered (paddress (bpt
->gdbarch
, bpt
->address
),
1780 fprintf_filtered (tmp_error_stream
, ": %s.\n",
1781 safe_strerror (val
));
1792 else if (bpt
->loc_type
== bp_loc_hardware_watchpoint
1793 /* NOTE drow/2003-09-08: This state only exists for removing
1794 watchpoints. It's not clear that it's necessary... */
1795 && bpt
->owner
->disposition
!= disp_del_at_next_stop
)
1797 val
= target_insert_watchpoint (bpt
->address
,
1799 bpt
->watchpoint_type
);
1801 /* If trying to set a read-watchpoint, and it turns out it's not
1802 supported, try emulating one with an access watchpoint. */
1803 if (val
== 1 && bpt
->watchpoint_type
== hw_read
)
1805 struct bp_location
*loc
, **loc_temp
;
1807 /* But don't try to insert it, if there's already another
1808 hw_access location that would be considered a duplicate
1810 ALL_BP_LOCATIONS (loc
, loc_temp
)
1812 && loc
->watchpoint_type
== hw_access
1813 && watchpoint_locations_match (bpt
, loc
))
1817 bpt
->target_info
= loc
->target_info
;
1818 bpt
->watchpoint_type
= hw_access
;
1825 val
= target_insert_watchpoint (bpt
->address
,
1829 bpt
->watchpoint_type
= hw_access
;
1833 bpt
->inserted
= (val
== 0);
1836 else if (bpt
->owner
->type
== bp_catchpoint
)
1838 struct gdb_exception e
= catch_exception (uiout
, insert_catchpoint
,
1839 bpt
->owner
, RETURN_MASK_ERROR
);
1840 exception_fprintf (gdb_stderr
, e
, "warning: inserting catchpoint %d: ",
1841 bpt
->owner
->number
);
1843 bpt
->owner
->enable_state
= bp_disabled
;
1847 /* We've already printed an error message if there was a problem
1848 inserting this catchpoint, and we've disabled the catchpoint,
1849 so just return success. */
1856 /* This function is called when program space PSPACE is about to be
1857 deleted. It takes care of updating breakpoints to not reference
1861 breakpoint_program_space_exit (struct program_space
*pspace
)
1863 struct breakpoint
*b
, *b_temp
;
1864 struct bp_location
*loc
, **loc_temp
;
1866 /* Remove any breakpoint that was set through this program space. */
1867 ALL_BREAKPOINTS_SAFE (b
, b_temp
)
1869 if (b
->pspace
== pspace
)
1870 delete_breakpoint (b
);
1873 /* Breakpoints set through other program spaces could have locations
1874 bound to PSPACE as well. Remove those. */
1875 ALL_BP_LOCATIONS (loc
, loc_temp
)
1877 struct bp_location
*tmp
;
1879 if (loc
->pspace
== pspace
)
1881 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
1882 if (loc
->owner
->loc
== loc
)
1883 loc
->owner
->loc
= loc
->next
;
1885 for (tmp
= loc
->owner
->loc
; tmp
->next
!= NULL
; tmp
= tmp
->next
)
1886 if (tmp
->next
== loc
)
1888 tmp
->next
= loc
->next
;
1894 /* Now update the global location list to permanently delete the
1895 removed locations above. */
1896 update_global_location_list (0);
1899 /* Make sure all breakpoints are inserted in inferior.
1900 Throws exception on any error.
1901 A breakpoint that is already inserted won't be inserted
1902 again, so calling this function twice is safe. */
1904 insert_breakpoints (void)
1906 struct breakpoint
*bpt
;
1908 ALL_BREAKPOINTS (bpt
)
1909 if (is_hardware_watchpoint (bpt
))
1910 update_watchpoint (bpt
, 0 /* don't reparse. */);
1912 update_global_location_list (1);
1914 /* update_global_location_list does not insert breakpoints when
1915 always_inserted_mode is not enabled. Explicitly insert them
1917 if (!breakpoints_always_inserted_mode ())
1918 insert_breakpoint_locations ();
1921 /* insert_breakpoints is used when starting or continuing the program.
1922 remove_breakpoints is used when the program stops.
1923 Both return zero if successful,
1924 or an `errno' value if could not write the inferior. */
1927 insert_breakpoint_locations (void)
1929 struct breakpoint
*bpt
;
1930 struct bp_location
*b
, **bp_tmp
;
1933 int disabled_breaks
= 0;
1934 int hw_breakpoint_error
= 0;
1936 struct ui_file
*tmp_error_stream
= mem_fileopen ();
1937 struct cleanup
*cleanups
= make_cleanup_ui_file_delete (tmp_error_stream
);
1939 /* Explicitly mark the warning -- this will only be printed if
1940 there was an error. */
1941 fprintf_unfiltered (tmp_error_stream
, "Warning:\n");
1943 save_current_space_and_thread ();
1945 ALL_BP_LOCATIONS (b
, bp_tmp
)
1947 if (!should_be_inserted (b
) || b
->inserted
)
1950 /* There is no point inserting thread-specific breakpoints if the
1951 thread no longer exists. ALL_BP_LOCATIONS bp_location has B->OWNER
1953 if (b
->owner
->thread
!= -1
1954 && !valid_thread_id (b
->owner
->thread
))
1957 switch_to_program_space_and_thread (b
->pspace
);
1959 /* For targets that support global breakpoints, there's no need
1960 to select an inferior to insert breakpoint to. In fact, even
1961 if we aren't attached to any process yet, we should still
1962 insert breakpoints. */
1963 if (!gdbarch_has_global_breakpoints (target_gdbarch
)
1964 && ptid_equal (inferior_ptid
, null_ptid
))
1967 val
= insert_bp_location (b
, tmp_error_stream
,
1969 &hw_breakpoint_error
);
1974 /* If we failed to insert all locations of a watchpoint,
1975 remove them, as half-inserted watchpoint is of limited use. */
1976 ALL_BREAKPOINTS (bpt
)
1978 int some_failed
= 0;
1979 struct bp_location
*loc
;
1981 if (!is_hardware_watchpoint (bpt
))
1984 if (!breakpoint_enabled (bpt
))
1987 if (bpt
->disposition
== disp_del_at_next_stop
)
1990 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
1991 if (!loc
->inserted
&& should_be_inserted (loc
))
1998 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
2000 remove_breakpoint (loc
, mark_uninserted
);
2002 hw_breakpoint_error
= 1;
2003 fprintf_unfiltered (tmp_error_stream
,
2004 "Could not insert hardware watchpoint %d.\n",
2012 /* If a hardware breakpoint or watchpoint was inserted, add a
2013 message about possibly exhausted resources. */
2014 if (hw_breakpoint_error
)
2016 fprintf_unfiltered (tmp_error_stream
,
2017 "Could not insert hardware breakpoints:\n\
2018 You may have requested too many hardware breakpoints/watchpoints.\n");
2020 target_terminal_ours_for_output ();
2021 error_stream (tmp_error_stream
);
2024 do_cleanups (cleanups
);
2028 remove_breakpoints (void)
2030 struct bp_location
*b
, **bp_tmp
;
2033 ALL_BP_LOCATIONS (b
, bp_tmp
)
2036 val
|= remove_breakpoint (b
, mark_uninserted
);
2041 /* Remove breakpoints of process PID. */
2044 remove_breakpoints_pid (int pid
)
2046 struct bp_location
*b
, **b_tmp
;
2048 struct inferior
*inf
= find_inferior_pid (pid
);
2050 ALL_BP_LOCATIONS (b
, b_tmp
)
2052 if (b
->pspace
!= inf
->pspace
)
2057 val
= remove_breakpoint (b
, mark_uninserted
);
2066 remove_hw_watchpoints (void)
2068 struct bp_location
*b
, **bp_tmp
;
2071 ALL_BP_LOCATIONS (b
, bp_tmp
)
2073 if (b
->inserted
&& b
->loc_type
== bp_loc_hardware_watchpoint
)
2074 val
|= remove_breakpoint (b
, mark_uninserted
);
2080 reattach_breakpoints (int pid
)
2082 struct cleanup
*old_chain
;
2083 struct bp_location
*b
, **bp_tmp
;
2085 struct ui_file
*tmp_error_stream
= mem_fileopen ();
2086 int dummy1
= 0, dummy2
= 0;
2087 struct inferior
*inf
;
2088 struct thread_info
*tp
;
2090 tp
= any_live_thread_of_process (pid
);
2094 inf
= find_inferior_pid (pid
);
2095 old_chain
= save_inferior_ptid ();
2097 inferior_ptid
= tp
->ptid
;
2099 make_cleanup_ui_file_delete (tmp_error_stream
);
2101 ALL_BP_LOCATIONS (b
, bp_tmp
)
2103 if (b
->pspace
!= inf
->pspace
)
2109 val
= insert_bp_location (b
, tmp_error_stream
,
2113 do_cleanups (old_chain
);
2118 do_cleanups (old_chain
);
2122 static int internal_breakpoint_number
= -1;
2124 static struct breakpoint
*
2125 create_internal_breakpoint (struct gdbarch
*gdbarch
,
2126 CORE_ADDR address
, enum bptype type
)
2128 struct symtab_and_line sal
;
2129 struct breakpoint
*b
;
2131 init_sal (&sal
); /* initialize to zeroes */
2134 sal
.section
= find_pc_overlay (sal
.pc
);
2135 sal
.pspace
= current_program_space
;
2137 b
= set_raw_breakpoint (gdbarch
, sal
, type
);
2138 b
->number
= internal_breakpoint_number
--;
2139 b
->disposition
= disp_donttouch
;
2145 create_overlay_event_breakpoint (char *func_name
)
2147 struct objfile
*objfile
;
2149 ALL_OBJFILES (objfile
)
2151 struct breakpoint
*b
;
2152 struct minimal_symbol
*m
;
2154 m
= lookup_minimal_symbol_text (func_name
, objfile
);
2158 b
= create_internal_breakpoint (get_objfile_arch (objfile
),
2159 SYMBOL_VALUE_ADDRESS (m
),
2161 b
->addr_string
= xstrdup (func_name
);
2163 if (overlay_debugging
== ovly_auto
)
2165 b
->enable_state
= bp_enabled
;
2166 overlay_events_enabled
= 1;
2170 b
->enable_state
= bp_disabled
;
2171 overlay_events_enabled
= 0;
2174 update_global_location_list (1);
2178 create_longjmp_master_breakpoint (char *func_name
)
2180 struct program_space
*pspace
;
2181 struct objfile
*objfile
;
2182 struct cleanup
*old_chain
;
2184 old_chain
= save_current_program_space ();
2186 ALL_PSPACES (pspace
)
2187 ALL_OBJFILES (objfile
)
2189 struct breakpoint
*b
;
2190 struct minimal_symbol
*m
;
2192 if (!gdbarch_get_longjmp_target_p (get_objfile_arch (objfile
)))
2195 set_current_program_space (pspace
);
2197 m
= lookup_minimal_symbol_text (func_name
, objfile
);
2201 b
= create_internal_breakpoint (get_objfile_arch (objfile
),
2202 SYMBOL_VALUE_ADDRESS (m
),
2204 b
->addr_string
= xstrdup (func_name
);
2205 b
->enable_state
= bp_disabled
;
2207 update_global_location_list (1);
2209 do_cleanups (old_chain
);
2212 /* Create a master std::terminate breakpoint. The actual function
2213 looked for is named FUNC_NAME. */
2215 create_std_terminate_master_breakpoint (const char *func_name
)
2217 struct program_space
*pspace
;
2218 struct objfile
*objfile
;
2219 struct cleanup
*old_chain
;
2221 old_chain
= save_current_program_space ();
2223 ALL_PSPACES (pspace
)
2224 ALL_OBJFILES (objfile
)
2226 struct breakpoint
*b
;
2227 struct minimal_symbol
*m
;
2229 set_current_program_space (pspace
);
2231 m
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
2232 if (m
== NULL
|| (MSYMBOL_TYPE (m
) != mst_text
2233 && MSYMBOL_TYPE (m
) != mst_file_text
))
2236 b
= create_internal_breakpoint (get_objfile_arch (objfile
),
2237 SYMBOL_VALUE_ADDRESS (m
),
2238 bp_std_terminate_master
);
2239 b
->addr_string
= xstrdup (func_name
);
2240 b
->enable_state
= bp_disabled
;
2242 update_global_location_list (1);
2244 do_cleanups (old_chain
);
2248 update_breakpoints_after_exec (void)
2250 struct breakpoint
*b
;
2251 struct breakpoint
*temp
;
2252 struct bp_location
*bploc
, **bplocp_tmp
;
2254 /* We're about to delete breakpoints from GDB's lists. If the
2255 INSERTED flag is true, GDB will try to lift the breakpoints by
2256 writing the breakpoints' "shadow contents" back into memory. The
2257 "shadow contents" are NOT valid after an exec, so GDB should not
2258 do that. Instead, the target is responsible from marking
2259 breakpoints out as soon as it detects an exec. We don't do that
2260 here instead, because there may be other attempts to delete
2261 breakpoints after detecting an exec and before reaching here. */
2262 ALL_BP_LOCATIONS (bploc
, bplocp_tmp
)
2263 if (bploc
->pspace
== current_program_space
)
2264 gdb_assert (!bploc
->inserted
);
2266 ALL_BREAKPOINTS_SAFE (b
, temp
)
2268 if (b
->pspace
!= current_program_space
)
2271 /* Solib breakpoints must be explicitly reset after an exec(). */
2272 if (b
->type
== bp_shlib_event
)
2274 delete_breakpoint (b
);
2278 /* JIT breakpoints must be explicitly reset after an exec(). */
2279 if (b
->type
== bp_jit_event
)
2281 delete_breakpoint (b
);
2285 /* Thread event breakpoints must be set anew after an exec(),
2286 as must overlay event and longjmp master breakpoints. */
2287 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
2288 || b
->type
== bp_longjmp_master
|| b
->type
== bp_std_terminate_master
)
2290 delete_breakpoint (b
);
2294 /* Step-resume breakpoints are meaningless after an exec(). */
2295 if (b
->type
== bp_step_resume
)
2297 delete_breakpoint (b
);
2301 /* Longjmp and longjmp-resume breakpoints are also meaningless
2303 if (b
->type
== bp_longjmp
|| b
->type
== bp_longjmp_resume
)
2305 delete_breakpoint (b
);
2309 if (b
->type
== bp_catchpoint
)
2311 /* For now, none of the bp_catchpoint breakpoints need to
2312 do anything at this point. In the future, if some of
2313 the catchpoints need to something, we will need to add
2314 a new method, and call this method from here. */
2318 /* bp_finish is a special case. The only way we ought to be able
2319 to see one of these when an exec() has happened, is if the user
2320 caught a vfork, and then said "finish". Ordinarily a finish just
2321 carries them to the call-site of the current callee, by setting
2322 a temporary bp there and resuming. But in this case, the finish
2323 will carry them entirely through the vfork & exec.
2325 We don't want to allow a bp_finish to remain inserted now. But
2326 we can't safely delete it, 'cause finish_command has a handle to
2327 the bp on a bpstat, and will later want to delete it. There's a
2328 chance (and I've seen it happen) that if we delete the bp_finish
2329 here, that its storage will get reused by the time finish_command
2330 gets 'round to deleting the "use to be a bp_finish" breakpoint.
2331 We really must allow finish_command to delete a bp_finish.
2333 In the absense of a general solution for the "how do we know
2334 it's safe to delete something others may have handles to?"
2335 problem, what we'll do here is just uninsert the bp_finish, and
2336 let finish_command delete it.
2338 (We know the bp_finish is "doomed" in the sense that it's
2339 momentary, and will be deleted as soon as finish_command sees
2340 the inferior stopped. So it doesn't matter that the bp's
2341 address is probably bogus in the new a.out, unlike e.g., the
2342 solib breakpoints.) */
2344 if (b
->type
== bp_finish
)
2349 /* Without a symbolic address, we have little hope of the
2350 pre-exec() address meaning the same thing in the post-exec()
2352 if (b
->addr_string
== NULL
)
2354 delete_breakpoint (b
);
2358 /* FIXME what about longjmp breakpoints? Re-create them here? */
2359 create_overlay_event_breakpoint ("_ovly_debug_event");
2360 create_longjmp_master_breakpoint ("longjmp");
2361 create_longjmp_master_breakpoint ("_longjmp");
2362 create_longjmp_master_breakpoint ("siglongjmp");
2363 create_longjmp_master_breakpoint ("_siglongjmp");
2364 create_std_terminate_master_breakpoint ("std::terminate()");
2368 detach_breakpoints (int pid
)
2370 struct bp_location
*b
, **bp_tmp
;
2372 struct cleanup
*old_chain
= save_inferior_ptid ();
2373 struct inferior
*inf
= current_inferior ();
2375 if (pid
== PIDGET (inferior_ptid
))
2376 error (_("Cannot detach breakpoints of inferior_ptid"));
2378 /* Set inferior_ptid; remove_breakpoint_1 uses this global. */
2379 inferior_ptid
= pid_to_ptid (pid
);
2380 ALL_BP_LOCATIONS (b
, bp_tmp
)
2382 if (b
->pspace
!= inf
->pspace
)
2386 val
|= remove_breakpoint_1 (b
, mark_inserted
);
2389 /* Detach single-step breakpoints as well. */
2390 detach_single_step_breakpoints ();
2392 do_cleanups (old_chain
);
2396 /* Remove the breakpoint location B from the current address space.
2397 Note that this is used to detach breakpoints from a child fork.
2398 When we get here, the child isn't in the inferior list, and neither
2399 do we have objects to represent its address space --- we should
2400 *not* look at b->pspace->aspace here. */
2403 remove_breakpoint_1 (struct bp_location
*b
, insertion_state_t is
)
2407 /* B is never in moribund_locations by our callers. */
2408 gdb_assert (b
->owner
!= NULL
);
2410 if (b
->owner
->enable_state
== bp_permanent
)
2411 /* Permanent breakpoints cannot be inserted or removed. */
2414 /* The type of none suggests that owner is actually deleted.
2415 This should not ever happen. */
2416 gdb_assert (b
->owner
->type
!= bp_none
);
2418 if (b
->loc_type
== bp_loc_software_breakpoint
2419 || b
->loc_type
== bp_loc_hardware_breakpoint
)
2421 /* "Normal" instruction breakpoint: either the standard
2422 trap-instruction bp (bp_breakpoint), or a
2423 bp_hardware_breakpoint. */
2425 /* First check to see if we have to handle an overlay. */
2426 if (overlay_debugging
== ovly_off
2427 || b
->section
== NULL
2428 || !(section_is_overlay (b
->section
)))
2430 /* No overlay handling: just remove the breakpoint. */
2432 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
2433 val
= target_remove_hw_breakpoint (b
->gdbarch
, &b
->target_info
);
2435 val
= target_remove_breakpoint (b
->gdbarch
, &b
->target_info
);
2439 /* This breakpoint is in an overlay section.
2440 Did we set a breakpoint at the LMA? */
2441 if (!overlay_events_enabled
)
2443 /* Yes -- overlay event support is not active, so we
2444 should have set a breakpoint at the LMA. Remove it.
2446 /* Ignore any failures: if the LMA is in ROM, we will
2447 have already warned when we failed to insert it. */
2448 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
2449 target_remove_hw_breakpoint (b
->gdbarch
,
2450 &b
->overlay_target_info
);
2452 target_remove_breakpoint (b
->gdbarch
,
2453 &b
->overlay_target_info
);
2455 /* Did we set a breakpoint at the VMA?
2456 If so, we will have marked the breakpoint 'inserted'. */
2459 /* Yes -- remove it. Previously we did not bother to
2460 remove the breakpoint if the section had been
2461 unmapped, but let's not rely on that being safe. We
2462 don't know what the overlay manager might do. */
2463 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
2464 val
= target_remove_hw_breakpoint (b
->gdbarch
,
2467 /* However, we should remove *software* breakpoints only
2468 if the section is still mapped, or else we overwrite
2469 wrong code with the saved shadow contents. */
2470 else if (section_is_mapped (b
->section
))
2471 val
= target_remove_breakpoint (b
->gdbarch
,
2478 /* No -- not inserted, so no need to remove. No error. */
2483 /* In some cases, we might not be able to remove a breakpoint
2484 in a shared library that has already been removed, but we
2485 have not yet processed the shlib unload event. */
2486 if (val
&& solib_name_from_address (b
->pspace
, b
->address
))
2491 b
->inserted
= (is
== mark_inserted
);
2493 else if (b
->loc_type
== bp_loc_hardware_watchpoint
)
2495 b
->inserted
= (is
== mark_inserted
);
2496 val
= target_remove_watchpoint (b
->address
, b
->length
,
2497 b
->watchpoint_type
);
2499 /* Failure to remove any of the hardware watchpoints comes here. */
2500 if ((is
== mark_uninserted
) && (b
->inserted
))
2501 warning (_("Could not remove hardware watchpoint %d."),
2504 else if (b
->owner
->type
== bp_catchpoint
2505 && breakpoint_enabled (b
->owner
)
2508 gdb_assert (b
->owner
->ops
!= NULL
&& b
->owner
->ops
->remove
!= NULL
);
2510 val
= b
->owner
->ops
->remove (b
->owner
);
2513 b
->inserted
= (is
== mark_inserted
);
2520 remove_breakpoint (struct bp_location
*b
, insertion_state_t is
)
2523 struct cleanup
*old_chain
;
2525 /* B is never in moribund_locations by our callers. */
2526 gdb_assert (b
->owner
!= NULL
);
2528 if (b
->owner
->enable_state
== bp_permanent
)
2529 /* Permanent breakpoints cannot be inserted or removed. */
2532 /* The type of none suggests that owner is actually deleted.
2533 This should not ever happen. */
2534 gdb_assert (b
->owner
->type
!= bp_none
);
2536 old_chain
= save_current_space_and_thread ();
2538 switch_to_program_space_and_thread (b
->pspace
);
2540 ret
= remove_breakpoint_1 (b
, is
);
2542 do_cleanups (old_chain
);
2546 /* Clear the "inserted" flag in all breakpoints. */
2549 mark_breakpoints_out (void)
2551 struct bp_location
*bpt
, **bptp_tmp
;
2553 ALL_BP_LOCATIONS (bpt
, bptp_tmp
)
2554 if (bpt
->pspace
== current_program_space
)
2558 /* Clear the "inserted" flag in all breakpoints and delete any
2559 breakpoints which should go away between runs of the program.
2561 Plus other such housekeeping that has to be done for breakpoints
2564 Note: this function gets called at the end of a run (by
2565 generic_mourn_inferior) and when a run begins (by
2566 init_wait_for_inferior). */
2571 breakpoint_init_inferior (enum inf_context context
)
2573 struct breakpoint
*b
, *temp
;
2574 struct bp_location
*bpt
, **bptp_tmp
;
2576 struct program_space
*pspace
= current_program_space
;
2578 /* If breakpoint locations are shared across processes, then there's
2580 if (gdbarch_has_global_breakpoints (target_gdbarch
))
2583 ALL_BP_LOCATIONS (bpt
, bptp_tmp
)
2585 /* ALL_BP_LOCATIONS bp_location has BPT->OWNER always non-NULL. */
2586 if (bpt
->pspace
== pspace
2587 && bpt
->owner
->enable_state
!= bp_permanent
)
2591 ALL_BREAKPOINTS_SAFE (b
, temp
)
2593 if (b
->loc
&& b
->loc
->pspace
!= pspace
)
2600 /* If the call dummy breakpoint is at the entry point it will
2601 cause problems when the inferior is rerun, so we better get
2604 case bp_watchpoint_scope
:
2606 /* Also get rid of scope breakpoints. */
2608 case bp_shlib_event
:
2610 /* Also remove solib event breakpoints. Their addresses may
2611 have changed since the last time we ran the program.
2612 Actually we may now be debugging against different target;
2613 and so the solib backend that installed this breakpoint may
2614 not be used in by the target. E.g.,
2616 (gdb) file prog-linux
2617 (gdb) run # native linux target
2620 (gdb) file prog-win.exe
2621 (gdb) tar rem :9999 # remote Windows gdbserver.
2624 delete_breakpoint (b
);
2628 case bp_hardware_watchpoint
:
2629 case bp_read_watchpoint
:
2630 case bp_access_watchpoint
:
2632 /* Likewise for watchpoints on local expressions. */
2633 if (b
->exp_valid_block
!= NULL
)
2634 delete_breakpoint (b
);
2635 else if (context
== inf_starting
)
2637 /* Reset val field to force reread of starting value
2638 in insert_breakpoints. */
2640 value_free (b
->val
);
2650 /* Get rid of the moribund locations. */
2651 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, bpt
); ++ix
)
2652 free_bp_location (bpt
);
2653 VEC_free (bp_location_p
, moribund_locations
);
2656 /* These functions concern about actual breakpoints inserted in the
2657 target --- to e.g. check if we need to do decr_pc adjustment or if
2658 we need to hop over the bkpt --- so we check for address space
2659 match, not program space. */
2661 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
2662 exists at PC. It returns ordinary_breakpoint_here if it's an
2663 ordinary breakpoint, or permanent_breakpoint_here if it's a
2664 permanent breakpoint.
2665 - When continuing from a location with an ordinary breakpoint, we
2666 actually single step once before calling insert_breakpoints.
2667 - When continuing from a localion with a permanent breakpoint, we
2668 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
2669 the target, to advance the PC past the breakpoint. */
2671 enum breakpoint_here
2672 breakpoint_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2674 struct bp_location
*bpt
, **bptp_tmp
;
2675 int any_breakpoint_here
= 0;
2677 ALL_BP_LOCATIONS (bpt
, bptp_tmp
)
2679 if (bpt
->loc_type
!= bp_loc_software_breakpoint
2680 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
2683 /* ALL_BP_LOCATIONS bp_location has BPT->OWNER always non-NULL. */
2684 if ((breakpoint_enabled (bpt
->owner
)
2685 || bpt
->owner
->enable_state
== bp_permanent
)
2686 && breakpoint_address_match (bpt
->pspace
->aspace
, bpt
->address
,
2689 if (overlay_debugging
2690 && section_is_overlay (bpt
->section
)
2691 && !section_is_mapped (bpt
->section
))
2692 continue; /* unmapped overlay -- can't be a match */
2693 else if (bpt
->owner
->enable_state
== bp_permanent
)
2694 return permanent_breakpoint_here
;
2696 any_breakpoint_here
= 1;
2700 return any_breakpoint_here
? ordinary_breakpoint_here
: 0;
2703 /* Return true if there's a moribund breakpoint at PC. */
2706 moribund_breakpoint_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2708 struct bp_location
*loc
;
2711 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
2712 if (breakpoint_address_match (loc
->pspace
->aspace
, loc
->address
,
2719 /* Returns non-zero if there's a breakpoint inserted at PC, which is
2720 inserted using regular breakpoint_chain / bp_location array mechanism.
2721 This does not check for single-step breakpoints, which are
2722 inserted and removed using direct target manipulation. */
2725 regular_breakpoint_inserted_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2727 struct bp_location
*bpt
, **bptp_tmp
;
2729 ALL_BP_LOCATIONS (bpt
, bptp_tmp
)
2731 if (bpt
->loc_type
!= bp_loc_software_breakpoint
2732 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
2736 && breakpoint_address_match (bpt
->pspace
->aspace
, bpt
->address
,
2739 if (overlay_debugging
2740 && section_is_overlay (bpt
->section
)
2741 && !section_is_mapped (bpt
->section
))
2742 continue; /* unmapped overlay -- can't be a match */
2750 /* Returns non-zero iff there's either regular breakpoint
2751 or a single step breakpoint inserted at PC. */
2754 breakpoint_inserted_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2756 if (regular_breakpoint_inserted_here_p (aspace
, pc
))
2759 if (single_step_breakpoint_inserted_here_p (aspace
, pc
))
2765 /* This function returns non-zero iff there is a software breakpoint
2769 software_breakpoint_inserted_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2771 struct bp_location
*bpt
, **bptp_tmp
;
2773 ALL_BP_LOCATIONS (bpt
, bptp_tmp
)
2775 if (bpt
->loc_type
!= bp_loc_software_breakpoint
)
2779 && breakpoint_address_match (bpt
->pspace
->aspace
, bpt
->address
,
2782 if (overlay_debugging
2783 && section_is_overlay (bpt
->section
)
2784 && !section_is_mapped (bpt
->section
))
2785 continue; /* unmapped overlay -- can't be a match */
2791 /* Also check for software single-step breakpoints. */
2792 if (single_step_breakpoint_inserted_here_p (aspace
, pc
))
2799 hardware_watchpoint_inserted_in_range (struct address_space
*aspace
,
2800 CORE_ADDR addr
, ULONGEST len
)
2802 struct breakpoint
*bpt
;
2804 ALL_BREAKPOINTS (bpt
)
2806 struct bp_location
*loc
;
2808 if (bpt
->type
!= bp_hardware_watchpoint
2809 && bpt
->type
!= bp_access_watchpoint
)
2812 if (!breakpoint_enabled (bpt
))
2815 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
2816 if (loc
->pspace
->aspace
== aspace
&& loc
->inserted
)
2820 /* Check for intersection. */
2821 l
= max (loc
->address
, addr
);
2822 h
= min (loc
->address
+ loc
->length
, addr
+ len
);
2830 /* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
2831 PC is valid for process/thread PTID. */
2834 breakpoint_thread_match (struct address_space
*aspace
, CORE_ADDR pc
,
2837 struct bp_location
*bpt
, **bptp_tmp
;
2838 /* The thread and task IDs associated to PTID, computed lazily. */
2842 ALL_BP_LOCATIONS (bpt
, bptp_tmp
)
2844 if (bpt
->loc_type
!= bp_loc_software_breakpoint
2845 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
2848 /* ALL_BP_LOCATIONS bp_location has BPT->OWNER always non-NULL. */
2849 if (!breakpoint_enabled (bpt
->owner
)
2850 && bpt
->owner
->enable_state
!= bp_permanent
)
2853 if (!breakpoint_address_match (bpt
->pspace
->aspace
, bpt
->address
,
2857 if (bpt
->owner
->thread
!= -1)
2859 /* This is a thread-specific breakpoint. Check that ptid
2860 matches that thread. If thread hasn't been computed yet,
2861 it is now time to do so. */
2863 thread
= pid_to_thread_id (ptid
);
2864 if (bpt
->owner
->thread
!= thread
)
2868 if (bpt
->owner
->task
!= 0)
2870 /* This is a task-specific breakpoint. Check that ptid
2871 matches that task. If task hasn't been computed yet,
2872 it is now time to do so. */
2874 task
= ada_get_task_number (ptid
);
2875 if (bpt
->owner
->task
!= task
)
2879 if (overlay_debugging
2880 && section_is_overlay (bpt
->section
)
2881 && !section_is_mapped (bpt
->section
))
2882 continue; /* unmapped overlay -- can't be a match */
2891 /* bpstat stuff. External routines' interfaces are documented
2895 ep_is_catchpoint (struct breakpoint
*ep
)
2897 return (ep
->type
== bp_catchpoint
);
2901 bpstat_free (bpstat bs
)
2903 if (bs
->old_val
!= NULL
)
2904 value_free (bs
->old_val
);
2905 decref_counted_command_line (&bs
->commands
);
2909 /* Clear a bpstat so that it says we are not at any breakpoint.
2910 Also free any storage that is part of a bpstat. */
2913 bpstat_clear (bpstat
*bsp
)
2930 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
2931 is part of the bpstat is copied as well. */
2934 bpstat_copy (bpstat bs
)
2938 bpstat retval
= NULL
;
2943 for (; bs
!= NULL
; bs
= bs
->next
)
2945 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
2946 memcpy (tmp
, bs
, sizeof (*tmp
));
2947 incref_counted_command_line (tmp
->commands
);
2948 if (bs
->old_val
!= NULL
)
2950 tmp
->old_val
= value_copy (bs
->old_val
);
2951 release_value (tmp
->old_val
);
2955 /* This is the first thing in the chain. */
2965 /* Find the bpstat associated with this breakpoint */
2968 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
2973 for (; bsp
!= NULL
; bsp
= bsp
->next
)
2975 if (bsp
->breakpoint_at
&& bsp
->breakpoint_at
->owner
== breakpoint
)
2981 /* Put in *NUM the breakpoint number of the first breakpoint we are stopped
2982 at. *BSP upon return is a bpstat which points to the remaining
2983 breakpoints stopped at (but which is not guaranteed to be good for
2984 anything but further calls to bpstat_num).
2985 Return 0 if passed a bpstat which does not indicate any breakpoints.
2986 Return -1 if stopped at a breakpoint that has been deleted since
2988 Return 1 otherwise. */
2991 bpstat_num (bpstat
*bsp
, int *num
)
2993 struct breakpoint
*b
;
2996 return 0; /* No more breakpoint values */
2998 /* We assume we'll never have several bpstats that
2999 correspond to a single breakpoint -- otherwise,
3000 this function might return the same number more
3001 than once and this will look ugly. */
3002 b
= (*bsp
)->breakpoint_at
? (*bsp
)->breakpoint_at
->owner
: NULL
;
3003 *bsp
= (*bsp
)->next
;
3005 return -1; /* breakpoint that's been deleted since */
3007 *num
= b
->number
; /* We have its number */
3011 /* Modify BS so that the actions will not be performed. */
3014 bpstat_clear_actions (bpstat bs
)
3016 for (; bs
!= NULL
; bs
= bs
->next
)
3018 decref_counted_command_line (&bs
->commands
);
3019 bs
->commands_left
= NULL
;
3020 if (bs
->old_val
!= NULL
)
3022 value_free (bs
->old_val
);
3028 /* Called when a command is about to proceed the inferior. */
3031 breakpoint_about_to_proceed (void)
3033 if (!ptid_equal (inferior_ptid
, null_ptid
))
3035 struct thread_info
*tp
= inferior_thread ();
3037 /* Allow inferior function calls in breakpoint commands to not
3038 interrupt the command list. When the call finishes
3039 successfully, the inferior will be standing at the same
3040 breakpoint as if nothing happened. */
3045 breakpoint_proceeded
= 1;
3048 /* Stub for cleaning up our state if we error-out of a breakpoint command */
3050 cleanup_executing_breakpoints (void *ignore
)
3052 executing_breakpoint_commands
= 0;
3055 /* Execute all the commands associated with all the breakpoints at this
3056 location. Any of these commands could cause the process to proceed
3057 beyond this point, etc. We look out for such changes by checking
3058 the global "breakpoint_proceeded" after each command.
3060 Returns true if a breakpoint command resumed the inferior. In that
3061 case, it is the caller's responsibility to recall it again with the
3062 bpstat of the current thread. */
3065 bpstat_do_actions_1 (bpstat
*bsp
)
3068 struct cleanup
*old_chain
;
3071 /* Avoid endless recursion if a `source' command is contained
3073 if (executing_breakpoint_commands
)
3076 executing_breakpoint_commands
= 1;
3077 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
3079 /* This pointer will iterate over the list of bpstat's. */
3082 breakpoint_proceeded
= 0;
3083 for (; bs
!= NULL
; bs
= bs
->next
)
3085 struct counted_command_line
*ccmd
;
3086 struct command_line
*cmd
;
3087 struct cleanup
*this_cmd_tree_chain
;
3089 /* Take ownership of the BSP's command tree, if it has one.
3091 The command tree could legitimately contain commands like
3092 'step' and 'next', which call clear_proceed_status, which
3093 frees stop_bpstat's command tree. To make sure this doesn't
3094 free the tree we're executing out from under us, we need to
3095 take ownership of the tree ourselves. Since a given bpstat's
3096 commands are only executed once, we don't need to copy it; we
3097 can clear the pointer in the bpstat, and make sure we free
3098 the tree when we're done. */
3099 ccmd
= bs
->commands
;
3100 bs
->commands
= NULL
;
3102 = make_cleanup_decref_counted_command_line (&ccmd
);
3103 cmd
= bs
->commands_left
;
3104 bs
->commands_left
= NULL
;
3108 execute_control_command (cmd
);
3110 if (breakpoint_proceeded
)
3116 /* We can free this command tree now. */
3117 do_cleanups (this_cmd_tree_chain
);
3119 if (breakpoint_proceeded
)
3121 if (target_can_async_p ())
3122 /* If we are in async mode, then the target might be still
3123 running, not stopped at any breakpoint, so nothing for
3124 us to do here -- just return to the event loop. */
3127 /* In sync mode, when execute_control_command returns
3128 we're already standing on the next breakpoint.
3129 Breakpoint commands for that stop were not run, since
3130 execute_command does not run breakpoint commands --
3131 only command_line_handler does, but that one is not
3132 involved in execution of breakpoint commands. So, we
3133 can now execute breakpoint commands. It should be
3134 noted that making execute_command do bpstat actions is
3135 not an option -- in this case we'll have recursive
3136 invocation of bpstat for each breakpoint with a
3137 command, and can easily blow up GDB stack. Instead, we
3138 return true, which will trigger the caller to recall us
3139 with the new stop_bpstat. */
3144 do_cleanups (old_chain
);
3149 bpstat_do_actions (void)
3151 /* Do any commands attached to breakpoint we are stopped at. */
3152 while (!ptid_equal (inferior_ptid
, null_ptid
)
3153 && target_has_execution
3154 && !is_exited (inferior_ptid
)
3155 && !is_executing (inferior_ptid
))
3156 /* Since in sync mode, bpstat_do_actions may resume the inferior,
3157 and only return when it is stopped at the next breakpoint, we
3158 keep doing breakpoint actions until it returns false to
3159 indicate the inferior was not resumed. */
3160 if (!bpstat_do_actions_1 (&inferior_thread ()->stop_bpstat
))
3164 /* Print out the (old or new) value associated with a watchpoint. */
3167 watchpoint_value_print (struct value
*val
, struct ui_file
*stream
)
3170 fprintf_unfiltered (stream
, _("<unreadable>"));
3173 struct value_print_options opts
;
3174 get_user_print_options (&opts
);
3175 value_print (val
, stream
, &opts
);
3179 /* This is the normal print function for a bpstat. In the future,
3180 much of this logic could (should?) be moved to bpstat_stop_status,
3181 by having it set different print_it values.
3183 Current scheme: When we stop, bpstat_print() is called. It loops
3184 through the bpstat list of things causing this stop, calling the
3185 print_bp_stop_message function on each one. The behavior of the
3186 print_bp_stop_message function depends on the print_it field of
3187 bpstat. If such field so indicates, call this function here.
3189 Return values from this routine (ultimately used by bpstat_print()
3190 and normal_stop() to decide what to do):
3191 PRINT_NOTHING: Means we already printed all we needed to print,
3192 don't print anything else.
3193 PRINT_SRC_ONLY: Means we printed something, and we do *not* desire
3194 that something to be followed by a location.
3195 PRINT_SCR_AND_LOC: Means we printed something, and we *do* desire
3196 that something to be followed by a location.
3197 PRINT_UNKNOWN: Means we printed nothing or we need to do some more
3200 static enum print_stop_action
3201 print_it_typical (bpstat bs
)
3203 struct cleanup
*old_chain
;
3204 struct breakpoint
*b
;
3205 const struct bp_location
*bl
;
3206 struct ui_stream
*stb
;
3208 enum print_stop_action result
;
3210 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
3211 which has since been deleted. */
3212 if (bs
->breakpoint_at
== NULL
)
3213 return PRINT_UNKNOWN
;
3214 bl
= bs
->breakpoint_at
;
3216 /* bl->owner can be NULL if it was a momentary breakpoint
3217 which has since been placed into moribund_locations. */
3218 if (bl
->owner
== NULL
)
3219 return PRINT_UNKNOWN
;
3222 stb
= ui_out_stream_new (uiout
);
3223 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
3228 case bp_hardware_breakpoint
:
3229 bp_temp
= bs
->breakpoint_at
->owner
->disposition
== disp_del
;
3230 if (bl
->address
!= bl
->requested_address
)
3231 breakpoint_adjustment_warning (bl
->requested_address
,
3234 annotate_breakpoint (b
->number
);
3236 ui_out_text (uiout
, "\nTemporary breakpoint ");
3238 ui_out_text (uiout
, "\nBreakpoint ");
3239 if (ui_out_is_mi_like_p (uiout
))
3241 ui_out_field_string (uiout
, "reason",
3242 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
3243 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
3245 ui_out_field_int (uiout
, "bkptno", b
->number
);
3246 ui_out_text (uiout
, ", ");
3247 result
= PRINT_SRC_AND_LOC
;
3250 case bp_shlib_event
:
3251 /* Did we stop because the user set the stop_on_solib_events
3252 variable? (If so, we report this as a generic, "Stopped due
3253 to shlib event" message.) */
3254 printf_filtered (_("Stopped due to shared library event\n"));
3255 result
= PRINT_NOTHING
;
3258 case bp_thread_event
:
3259 /* Not sure how we will get here.
3260 GDB should not stop for these breakpoints. */
3261 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
3262 result
= PRINT_NOTHING
;
3265 case bp_overlay_event
:
3266 /* By analogy with the thread event, GDB should not stop for these. */
3267 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
3268 result
= PRINT_NOTHING
;
3271 case bp_longjmp_master
:
3272 /* These should never be enabled. */
3273 printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
3274 result
= PRINT_NOTHING
;
3277 case bp_std_terminate_master
:
3278 /* These should never be enabled. */
3279 printf_filtered (_("std::terminate Master Breakpoint: gdb should not stop!\n"));
3280 result
= PRINT_NOTHING
;
3284 case bp_hardware_watchpoint
:
3285 annotate_watchpoint (b
->number
);
3286 if (ui_out_is_mi_like_p (uiout
))
3289 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
3291 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
3292 ui_out_text (uiout
, "\nOld value = ");
3293 watchpoint_value_print (bs
->old_val
, stb
->stream
);
3294 ui_out_field_stream (uiout
, "old", stb
);
3295 ui_out_text (uiout
, "\nNew value = ");
3296 watchpoint_value_print (b
->val
, stb
->stream
);
3297 ui_out_field_stream (uiout
, "new", stb
);
3298 ui_out_text (uiout
, "\n");
3299 /* More than one watchpoint may have been triggered. */
3300 result
= PRINT_UNKNOWN
;
3303 case bp_read_watchpoint
:
3304 if (ui_out_is_mi_like_p (uiout
))
3307 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
3309 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
3310 ui_out_text (uiout
, "\nValue = ");
3311 watchpoint_value_print (b
->val
, stb
->stream
);
3312 ui_out_field_stream (uiout
, "value", stb
);
3313 ui_out_text (uiout
, "\n");
3314 result
= PRINT_UNKNOWN
;
3317 case bp_access_watchpoint
:
3318 if (bs
->old_val
!= NULL
)
3320 annotate_watchpoint (b
->number
);
3321 if (ui_out_is_mi_like_p (uiout
))
3324 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
3326 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
3327 ui_out_text (uiout
, "\nOld value = ");
3328 watchpoint_value_print (bs
->old_val
, stb
->stream
);
3329 ui_out_field_stream (uiout
, "old", stb
);
3330 ui_out_text (uiout
, "\nNew value = ");
3335 if (ui_out_is_mi_like_p (uiout
))
3338 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
3339 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
3340 ui_out_text (uiout
, "\nValue = ");
3342 watchpoint_value_print (b
->val
, stb
->stream
);
3343 ui_out_field_stream (uiout
, "new", stb
);
3344 ui_out_text (uiout
, "\n");
3345 result
= PRINT_UNKNOWN
;
3348 /* Fall through, we don't deal with these types of breakpoints
3352 if (ui_out_is_mi_like_p (uiout
))
3355 async_reason_lookup (EXEC_ASYNC_FUNCTION_FINISHED
));
3356 result
= PRINT_UNKNOWN
;
3360 if (ui_out_is_mi_like_p (uiout
))
3363 async_reason_lookup (EXEC_ASYNC_LOCATION_REACHED
));
3364 result
= PRINT_UNKNOWN
;
3369 case bp_longjmp_resume
:
3370 case bp_step_resume
:
3371 case bp_watchpoint_scope
:
3373 case bp_std_terminate
:
3375 case bp_fast_tracepoint
:
3378 result
= PRINT_UNKNOWN
;
3382 do_cleanups (old_chain
);
3386 /* Generic routine for printing messages indicating why we
3387 stopped. The behavior of this function depends on the value
3388 'print_it' in the bpstat structure. Under some circumstances we
3389 may decide not to print anything here and delegate the task to
3392 static enum print_stop_action
3393 print_bp_stop_message (bpstat bs
)
3395 switch (bs
->print_it
)
3398 /* Nothing should be printed for this bpstat entry. */
3399 return PRINT_UNKNOWN
;
3403 /* We still want to print the frame, but we already printed the
3404 relevant messages. */
3405 return PRINT_SRC_AND_LOC
;
3408 case print_it_normal
:
3410 const struct bp_location
*bl
= bs
->breakpoint_at
;
3411 struct breakpoint
*b
= bl
? bl
->owner
: NULL
;
3413 /* Normal case. Call the breakpoint's print_it method, or
3414 print_it_typical. */
3415 /* FIXME: how breakpoint can ever be NULL here? */
3416 if (b
!= NULL
&& b
->ops
!= NULL
&& b
->ops
->print_it
!= NULL
)
3417 return b
->ops
->print_it (b
);
3419 return print_it_typical (bs
);
3424 internal_error (__FILE__
, __LINE__
,
3425 _("print_bp_stop_message: unrecognized enum value"));
3430 /* Print a message indicating what happened. This is called from
3431 normal_stop(). The input to this routine is the head of the bpstat
3432 list - a list of the eventpoints that caused this stop. This
3433 routine calls the generic print routine for printing a message
3434 about reasons for stopping. This will print (for example) the
3435 "Breakpoint n," part of the output. The return value of this
3438 PRINT_UNKNOWN: Means we printed nothing
3439 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
3440 code to print the location. An example is
3441 "Breakpoint 1, " which should be followed by
3443 PRINT_SRC_ONLY: Means we printed something, but there is no need
3444 to also print the location part of the message.
3445 An example is the catch/throw messages, which
3446 don't require a location appended to the end.
3447 PRINT_NOTHING: We have done some printing and we don't need any
3448 further info to be printed.*/
3450 enum print_stop_action
3451 bpstat_print (bpstat bs
)
3455 /* Maybe another breakpoint in the chain caused us to stop.
3456 (Currently all watchpoints go on the bpstat whether hit or not.
3457 That probably could (should) be changed, provided care is taken
3458 with respect to bpstat_explains_signal). */
3459 for (; bs
; bs
= bs
->next
)
3461 val
= print_bp_stop_message (bs
);
3462 if (val
== PRINT_SRC_ONLY
3463 || val
== PRINT_SRC_AND_LOC
3464 || val
== PRINT_NOTHING
)
3468 /* We reached the end of the chain, or we got a null BS to start
3469 with and nothing was printed. */
3470 return PRINT_UNKNOWN
;
3473 /* Evaluate the expression EXP and return 1 if value is zero.
3474 This is used inside a catch_errors to evaluate the breakpoint condition.
3475 The argument is a "struct expression *" that has been cast to char * to
3476 make it pass through catch_errors. */
3479 breakpoint_cond_eval (void *exp
)
3481 struct value
*mark
= value_mark ();
3482 int i
= !value_true (evaluate_expression ((struct expression
*) exp
));
3484 value_free_to_mark (mark
);
3488 /* Allocate a new bpstat and chain it to the current one. */
3491 bpstat_alloc (const struct bp_location
*bl
, bpstat cbs
/* Current "bs" value */ )
3495 bs
= (bpstat
) xmalloc (sizeof (*bs
));
3497 bs
->breakpoint_at
= bl
;
3498 /* If the condition is false, etc., don't do the commands. */
3499 bs
->commands
= NULL
;
3500 bs
->commands_left
= NULL
;
3502 bs
->print_it
= print_it_normal
;
3506 /* The target has stopped with waitstatus WS. Check if any hardware
3507 watchpoints have triggered, according to the target. */
3510 watchpoints_triggered (struct target_waitstatus
*ws
)
3512 int stopped_by_watchpoint
= target_stopped_by_watchpoint ();
3514 struct breakpoint
*b
;
3516 if (!stopped_by_watchpoint
)
3518 /* We were not stopped by a watchpoint. Mark all watchpoints
3519 as not triggered. */
3521 if (is_hardware_watchpoint (b
))
3522 b
->watchpoint_triggered
= watch_triggered_no
;
3527 if (!target_stopped_data_address (¤t_target
, &addr
))
3529 /* We were stopped by a watchpoint, but we don't know where.
3530 Mark all watchpoints as unknown. */
3532 if (is_hardware_watchpoint (b
))
3533 b
->watchpoint_triggered
= watch_triggered_unknown
;
3535 return stopped_by_watchpoint
;
3538 /* The target could report the data address. Mark watchpoints
3539 affected by this data address as triggered, and all others as not
3543 if (is_hardware_watchpoint (b
))
3545 struct bp_location
*loc
;
3547 b
->watchpoint_triggered
= watch_triggered_no
;
3548 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
3549 /* Exact match not required. Within range is
3551 if (target_watchpoint_addr_within_range (¤t_target
,
3555 b
->watchpoint_triggered
= watch_triggered_yes
;
3563 /* Possible return values for watchpoint_check (this can't be an enum
3564 because of check_errors). */
3565 /* The watchpoint has been deleted. */
3566 #define WP_DELETED 1
3567 /* The value has changed. */
3568 #define WP_VALUE_CHANGED 2
3569 /* The value has not changed. */
3570 #define WP_VALUE_NOT_CHANGED 3
3571 /* Ignore this watchpoint, no matter if the value changed or not. */
3574 #define BP_TEMPFLAG 1
3575 #define BP_HARDWAREFLAG 2
3577 /* Evaluate watchpoint condition expression and check if its value changed.
3579 P should be a pointer to struct bpstat, but is defined as a void *
3580 in order for this function to be usable with catch_errors. */
3583 watchpoint_check (void *p
)
3585 bpstat bs
= (bpstat
) p
;
3586 struct breakpoint
*b
;
3587 struct frame_info
*fr
;
3588 int within_current_scope
;
3590 /* BS is built for existing struct breakpoint. */
3591 gdb_assert (bs
->breakpoint_at
!= NULL
);
3592 gdb_assert (bs
->breakpoint_at
->owner
!= NULL
);
3593 b
= bs
->breakpoint_at
->owner
;
3595 /* If this is a local watchpoint, we only want to check if the
3596 watchpoint frame is in scope if the current thread is the thread
3597 that was used to create the watchpoint. */
3598 if (!watchpoint_in_thread_scope (b
))
3601 if (b
->exp_valid_block
== NULL
)
3602 within_current_scope
= 1;
3605 struct frame_info
*frame
= get_current_frame ();
3606 struct gdbarch
*frame_arch
= get_frame_arch (frame
);
3607 CORE_ADDR frame_pc
= get_frame_pc (frame
);
3609 /* in_function_epilogue_p() returns a non-zero value if we're still
3610 in the function but the stack frame has already been invalidated.
3611 Since we can't rely on the values of local variables after the
3612 stack has been destroyed, we are treating the watchpoint in that
3613 state as `not changed' without further checking. Don't mark
3614 watchpoints as changed if the current frame is in an epilogue -
3615 even if they are in some other frame, our view of the stack
3616 is likely to be wrong and frame_find_by_id could error out. */
3617 if (gdbarch_in_function_epilogue_p (frame_arch
, frame_pc
))
3620 fr
= frame_find_by_id (b
->watchpoint_frame
);
3621 within_current_scope
= (fr
!= NULL
);
3623 /* If we've gotten confused in the unwinder, we might have
3624 returned a frame that can't describe this variable. */
3625 if (within_current_scope
)
3627 struct symbol
*function
;
3629 function
= get_frame_function (fr
);
3630 if (function
== NULL
3631 || !contained_in (b
->exp_valid_block
,
3632 SYMBOL_BLOCK_VALUE (function
)))
3633 within_current_scope
= 0;
3636 if (within_current_scope
)
3637 /* If we end up stopping, the current frame will get selected
3638 in normal_stop. So this call to select_frame won't affect
3643 if (within_current_scope
)
3645 /* We use value_{,free_to_}mark because it could be a
3646 *long* time before we return to the command level and
3647 call free_all_values. We can't call free_all_values because
3648 we might be in the middle of evaluating a function call. */
3650 struct value
*mark
= value_mark ();
3651 struct value
*new_val
;
3653 fetch_watchpoint_value (b
->exp
, &new_val
, NULL
, NULL
);
3655 /* We use value_equal_contents instead of value_equal because the latter
3656 coerces an array to a pointer, thus comparing just the address of the
3657 array instead of its contents. This is not what we want. */
3658 if ((b
->val
!= NULL
) != (new_val
!= NULL
)
3659 || (b
->val
!= NULL
&& !value_equal_contents (b
->val
, new_val
)))
3661 if (new_val
!= NULL
)
3663 release_value (new_val
);
3664 value_free_to_mark (mark
);
3666 bs
->old_val
= b
->val
;
3669 return WP_VALUE_CHANGED
;
3673 /* Nothing changed. */
3674 value_free_to_mark (mark
);
3675 return WP_VALUE_NOT_CHANGED
;
3680 /* This seems like the only logical thing to do because
3681 if we temporarily ignored the watchpoint, then when
3682 we reenter the block in which it is valid it contains
3683 garbage (in the case of a function, it may have two
3684 garbage values, one before and one after the prologue).
3685 So we can't even detect the first assignment to it and
3686 watch after that (since the garbage may or may not equal
3687 the first value assigned). */
3688 /* We print all the stop information in print_it_typical(), but
3689 in this case, by the time we call print_it_typical() this bp
3690 will be deleted already. So we have no choice but print the
3691 information here. */
3692 if (ui_out_is_mi_like_p (uiout
))
3694 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
3695 ui_out_text (uiout
, "\nWatchpoint ");
3696 ui_out_field_int (uiout
, "wpnum", b
->number
);
3697 ui_out_text (uiout
, " deleted because the program has left the block in\n\
3698 which its expression is valid.\n");
3700 if (b
->related_breakpoint
)
3702 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
3703 b
->related_breakpoint
->related_breakpoint
= NULL
;
3704 b
->related_breakpoint
= NULL
;
3706 b
->disposition
= disp_del_at_next_stop
;
3712 /* Return true if it looks like target has stopped due to hitting
3713 breakpoint location BL. This function does not check if we
3714 should stop, only if BL explains the stop. */
3716 bpstat_check_location (const struct bp_location
*bl
,
3717 struct address_space
*aspace
, CORE_ADDR bp_addr
)
3719 struct breakpoint
*b
= bl
->owner
;
3721 /* BL is from existing struct breakpoint. */
3722 gdb_assert (b
!= NULL
);
3724 /* By definition, the inferior does not report stops at
3726 if (is_tracepoint (b
))
3729 if (!is_watchpoint (b
)
3730 && b
->type
!= bp_hardware_breakpoint
3731 && b
->type
!= bp_catchpoint
) /* a non-watchpoint bp */
3733 if (!breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
3736 if (overlay_debugging
/* unmapped overlay section */
3737 && section_is_overlay (bl
->section
)
3738 && !section_is_mapped (bl
->section
))
3742 /* Continuable hardware watchpoints are treated as non-existent if the
3743 reason we stopped wasn't a hardware watchpoint (we didn't stop on
3744 some data address). Otherwise gdb won't stop on a break instruction
3745 in the code (not from a breakpoint) when a hardware watchpoint has
3746 been defined. Also skip watchpoints which we know did not trigger
3747 (did not match the data address). */
3749 if (is_hardware_watchpoint (b
)
3750 && b
->watchpoint_triggered
== watch_triggered_no
)
3753 if (b
->type
== bp_hardware_breakpoint
)
3755 if (bl
->address
!= bp_addr
)
3757 if (overlay_debugging
/* unmapped overlay section */
3758 && section_is_overlay (bl
->section
)
3759 && !section_is_mapped (bl
->section
))
3763 if (b
->type
== bp_catchpoint
)
3765 gdb_assert (b
->ops
!= NULL
&& b
->ops
->breakpoint_hit
!= NULL
);
3766 if (!b
->ops
->breakpoint_hit (b
))
3773 /* If BS refers to a watchpoint, determine if the watched values
3774 has actually changed, and we should stop. If not, set BS->stop
3777 bpstat_check_watchpoint (bpstat bs
)
3779 const struct bp_location
*bl
;
3780 struct breakpoint
*b
;
3782 /* BS is built for existing struct breakpoint. */
3783 bl
= bs
->breakpoint_at
;
3784 gdb_assert (bl
!= NULL
);
3786 gdb_assert (b
!= NULL
);
3788 if (is_watchpoint (b
))
3790 int must_check_value
= 0;
3792 if (b
->type
== bp_watchpoint
)
3793 /* For a software watchpoint, we must always check the
3795 must_check_value
= 1;
3796 else if (b
->watchpoint_triggered
== watch_triggered_yes
)
3797 /* We have a hardware watchpoint (read, write, or access)
3798 and the target earlier reported an address watched by
3800 must_check_value
= 1;
3801 else if (b
->watchpoint_triggered
== watch_triggered_unknown
3802 && b
->type
== bp_hardware_watchpoint
)
3803 /* We were stopped by a hardware watchpoint, but the target could
3804 not report the data address. We must check the watchpoint's
3805 value. Access and read watchpoints are out of luck; without
3806 a data address, we can't figure it out. */
3807 must_check_value
= 1;
3809 if (must_check_value
)
3811 char *message
= xstrprintf ("Error evaluating expression for watchpoint %d\n",
3813 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
3814 int e
= catch_errors (watchpoint_check
, bs
, message
,
3816 do_cleanups (cleanups
);
3820 /* We've already printed what needs to be printed. */
3821 bs
->print_it
= print_it_done
;
3825 bs
->print_it
= print_it_noop
;
3828 case WP_VALUE_CHANGED
:
3829 if (b
->type
== bp_read_watchpoint
)
3831 /* There are two cases to consider here:
3833 1. we're watching the triggered memory for reads.
3834 In that case, trust the target, and always report
3835 the watchpoint hit to the user. Even though
3836 reads don't cause value changes, the value may
3837 have changed since the last time it was read, and
3838 since we're not trapping writes, we will not see
3839 those, and as such we should ignore our notion of
3842 2. we're watching the triggered memory for both
3843 reads and writes. There are two ways this may
3846 2.1. this is a target that can't break on data
3847 reads only, but can break on accesses (reads or
3848 writes), such as e.g., x86. We detect this case
3849 at the time we try to insert read watchpoints.
3851 2.2. otherwise, the target supports read
3852 watchpoints, but, the user set an access or write
3853 watchpoint watching the same memory as this read
3856 If we're watching memory writes as well as reads,
3857 ignore watchpoint hits when we find that the
3858 value hasn't changed, as reads don't cause
3859 changes. This still gives false positives when
3860 the program writes the same value to memory as
3861 what there was already in memory (we will confuse
3862 it for a read), but it's much better than
3865 int other_write_watchpoint
= 0;
3867 if (bl
->watchpoint_type
== hw_read
)
3869 struct breakpoint
*other_b
;
3871 ALL_BREAKPOINTS (other_b
)
3872 if ((other_b
->type
== bp_hardware_watchpoint
3873 || other_b
->type
== bp_access_watchpoint
)
3874 && (other_b
->watchpoint_triggered
3875 == watch_triggered_yes
))
3877 other_write_watchpoint
= 1;
3882 if (other_write_watchpoint
3883 || bl
->watchpoint_type
== hw_access
)
3885 /* We're watching the same memory for writes,
3886 and the value changed since the last time we
3887 updated it, so this trap must be for a write.
3889 bs
->print_it
= print_it_noop
;
3894 case WP_VALUE_NOT_CHANGED
:
3895 if (b
->type
== bp_hardware_watchpoint
3896 || b
->type
== bp_watchpoint
)
3898 /* Don't stop: write watchpoints shouldn't fire if
3899 the value hasn't changed. */
3900 bs
->print_it
= print_it_noop
;
3908 /* Error from catch_errors. */
3909 printf_filtered (_("Watchpoint %d deleted.\n"), b
->number
);
3910 if (b
->related_breakpoint
)
3911 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
3912 b
->disposition
= disp_del_at_next_stop
;
3913 /* We've already printed what needs to be printed. */
3914 bs
->print_it
= print_it_done
;
3918 else /* must_check_value == 0 */
3920 /* This is a case where some watchpoint(s) triggered, but
3921 not at the address of this watchpoint, or else no
3922 watchpoint triggered after all. So don't print
3923 anything for this watchpoint. */
3924 bs
->print_it
= print_it_noop
;
3931 /* Check conditions (condition proper, frame, thread and ignore count)
3932 of breakpoint referred to by BS. If we should not stop for this
3933 breakpoint, set BS->stop to 0. */
3935 bpstat_check_breakpoint_conditions (bpstat bs
, ptid_t ptid
)
3937 int thread_id
= pid_to_thread_id (ptid
);
3938 const struct bp_location
*bl
;
3939 struct breakpoint
*b
;
3941 /* BS is built for existing struct breakpoint. */
3942 bl
= bs
->breakpoint_at
;
3943 gdb_assert (bl
!= NULL
);
3945 gdb_assert (b
!= NULL
);
3947 if (frame_id_p (b
->frame_id
)
3948 && !frame_id_eq (b
->frame_id
, get_stack_frame_id (get_current_frame ())))
3952 int value_is_zero
= 0;
3953 struct expression
*cond
;
3955 /* If this is a scope breakpoint, mark the associated
3956 watchpoint as triggered so that we will handle the
3957 out-of-scope event. We'll get to the watchpoint next
3959 if (b
->type
== bp_watchpoint_scope
)
3960 b
->related_breakpoint
->watchpoint_triggered
= watch_triggered_yes
;
3962 if (is_watchpoint (b
))
3967 if (cond
&& bl
->owner
->disposition
!= disp_del_at_next_stop
)
3969 int within_current_scope
= 1;
3971 /* We use value_mark and value_free_to_mark because it could
3972 be a long time before we return to the command level and
3973 call free_all_values. We can't call free_all_values
3974 because we might be in the middle of evaluating a
3976 struct value
*mark
= value_mark ();
3978 /* Need to select the frame, with all that implies so that
3979 the conditions will have the right context. Because we
3980 use the frame, we will not see an inlined function's
3981 variables when we arrive at a breakpoint at the start
3982 of the inlined function; the current frame will be the
3984 if (!is_watchpoint (b
) || b
->cond_exp_valid_block
== NULL
)
3985 select_frame (get_current_frame ());
3988 struct frame_info
*frame
;
3990 /* For local watchpoint expressions, which particular
3991 instance of a local is being watched matters, so we
3992 keep track of the frame to evaluate the expression
3993 in. To evaluate the condition however, it doesn't
3994 really matter which instantiation of the function
3995 where the condition makes sense triggers the
3996 watchpoint. This allows an expression like "watch
3997 global if q > 10" set in `func', catch writes to
3998 global on all threads that call `func', or catch
3999 writes on all recursive calls of `func' by a single
4000 thread. We simply always evaluate the condition in
4001 the innermost frame that's executing where it makes
4002 sense to evaluate the condition. It seems
4004 frame
= block_innermost_frame (b
->cond_exp_valid_block
);
4006 select_frame (frame
);
4008 within_current_scope
= 0;
4010 if (within_current_scope
)
4012 = catch_errors (breakpoint_cond_eval
, cond
,
4013 "Error in testing breakpoint condition:\n",
4017 warning (_("Watchpoint condition cannot be tested "
4018 "in the current scope"));
4019 /* If we failed to set the right context for this
4020 watchpoint, unconditionally report it. */
4023 /* FIXME-someday, should give breakpoint # */
4024 value_free_to_mark (mark
);
4027 if (cond
&& value_is_zero
)
4031 else if (b
->thread
!= -1 && b
->thread
!= thread_id
)
4035 else if (b
->ignore_count
> 0)
4038 annotate_ignore_count_change ();
4040 /* Increase the hit count even though we don't
4048 /* Get a bpstat associated with having just stopped at address
4049 BP_ADDR in thread PTID.
4051 Determine whether we stopped at a breakpoint, etc, or whether we
4052 don't understand this stop. Result is a chain of bpstat's such that:
4054 if we don't understand the stop, the result is a null pointer.
4056 if we understand why we stopped, the result is not null.
4058 Each element of the chain refers to a particular breakpoint or
4059 watchpoint at which we have stopped. (We may have stopped for
4060 several reasons concurrently.)
4062 Each element of the chain has valid next, breakpoint_at,
4063 commands, FIXME??? fields. */
4066 bpstat_stop_status (struct address_space
*aspace
,
4067 CORE_ADDR bp_addr
, ptid_t ptid
)
4069 struct breakpoint
*b
= NULL
;
4070 struct bp_location
*bl
;
4071 struct bp_location
*loc
;
4072 /* Root of the chain of bpstat's */
4073 struct bpstats root_bs
[1];
4074 /* Pointer to the last thing in the chain currently. */
4075 bpstat bs
= root_bs
;
4077 int need_remove_insert
;
4079 /* ALL_BP_LOCATIONS iteration would break across
4080 update_global_location_list possibly executed by
4081 bpstat_check_breakpoint_conditions's inferior call. */
4085 if (!breakpoint_enabled (b
) && b
->enable_state
!= bp_permanent
)
4088 for (bl
= b
->loc
; bl
!= NULL
; bl
= bl
->next
)
4090 /* For hardware watchpoints, we look only at the first location.
4091 The watchpoint_check function will work on the entire expression,
4092 not the individual locations. For read watchpoints, the
4093 watchpoints_triggered function has checked all locations
4095 if (b
->type
== bp_hardware_watchpoint
&& bl
!= b
->loc
)
4098 if (bl
->shlib_disabled
)
4101 if (!bpstat_check_location (bl
, aspace
, bp_addr
))
4104 /* Come here if it's a watchpoint, or if the break address matches */
4106 bs
= bpstat_alloc (bl
, bs
); /* Alloc a bpstat to explain stop */
4108 /* Assume we stop. Should we find watchpoint that is not actually
4109 triggered, or if condition of breakpoint is false, we'll reset
4114 bpstat_check_watchpoint (bs
);
4118 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
4119 || b
->type
== bp_longjmp_master
4120 || b
->type
== bp_std_terminate_master
)
4121 /* We do not stop for these. */
4124 bpstat_check_breakpoint_conditions (bs
, ptid
);
4130 /* We will stop here */
4131 if (b
->disposition
== disp_disable
)
4133 if (b
->enable_state
!= bp_permanent
)
4134 b
->enable_state
= bp_disabled
;
4135 update_global_location_list (0);
4139 bs
->commands
= b
->commands
;
4140 incref_counted_command_line (bs
->commands
);
4141 bs
->commands_left
= bs
->commands
? bs
->commands
->commands
: NULL
;
4142 if (bs
->commands_left
4143 && (strcmp ("silent", bs
->commands_left
->line
) == 0
4146 bs
->commands_left
->line
) == 0)))
4148 bs
->commands_left
= bs
->commands_left
->next
;
4153 /* Print nothing for this entry if we dont stop or dont print. */
4154 if (bs
->stop
== 0 || bs
->print
== 0)
4155 bs
->print_it
= print_it_noop
;
4159 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
4161 if (breakpoint_address_match (loc
->pspace
->aspace
, loc
->address
,
4164 bs
= bpstat_alloc (loc
, bs
);
4165 /* For hits of moribund locations, we should just proceed. */
4168 bs
->print_it
= print_it_noop
;
4172 bs
->next
= NULL
; /* Terminate the chain */
4174 /* If we aren't stopping, the value of some hardware watchpoint may
4175 not have changed, but the intermediate memory locations we are
4176 watching may have. Don't bother if we're stopping; this will get
4178 need_remove_insert
= 0;
4179 if (! bpstat_causes_stop (root_bs
->next
))
4180 for (bs
= root_bs
->next
; bs
!= NULL
; bs
= bs
->next
)
4182 && bs
->breakpoint_at
->owner
4183 && is_hardware_watchpoint (bs
->breakpoint_at
->owner
))
4185 update_watchpoint (bs
->breakpoint_at
->owner
, 0 /* don't reparse. */);
4186 /* Updating watchpoints invalidates bs->breakpoint_at.
4187 Prevent further code from trying to use it. */
4188 bs
->breakpoint_at
= NULL
;
4189 need_remove_insert
= 1;
4192 if (need_remove_insert
)
4193 update_global_location_list (1);
4195 return root_bs
->next
;
4198 /* Tell what to do about this bpstat. */
4200 bpstat_what (bpstat bs
)
4202 /* Classify each bpstat as one of the following. */
4205 /* This bpstat element has no effect on the main_action. */
4208 /* There was a watchpoint, stop but don't print. */
4211 /* There was a watchpoint, stop and print. */
4214 /* There was a breakpoint but we're not stopping. */
4217 /* There was a breakpoint, stop but don't print. */
4220 /* There was a breakpoint, stop and print. */
4223 /* We hit the longjmp breakpoint. */
4226 /* We hit the longjmp_resume breakpoint. */
4229 /* We hit the step_resume breakpoint. */
4232 /* We hit the shared library event breakpoint. */
4235 /* We hit the jit event breakpoint. */
4238 /* This is just used to count how many enums there are. */
4242 /* Here is the table which drives this routine. So that we can
4243 format it pretty, we define some abbreviations for the
4244 enum bpstat_what codes. */
4245 #define kc BPSTAT_WHAT_KEEP_CHECKING
4246 #define ss BPSTAT_WHAT_STOP_SILENT
4247 #define sn BPSTAT_WHAT_STOP_NOISY
4248 #define sgl BPSTAT_WHAT_SINGLE
4249 #define slr BPSTAT_WHAT_SET_LONGJMP_RESUME
4250 #define clr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
4251 #define sr BPSTAT_WHAT_STEP_RESUME
4252 #define shl BPSTAT_WHAT_CHECK_SHLIBS
4253 #define jit BPSTAT_WHAT_CHECK_JIT
4255 /* "Can't happen." Might want to print an error message.
4256 abort() is not out of the question, but chances are GDB is just
4257 a bit confused, not unusable. */
4258 #define err BPSTAT_WHAT_STOP_NOISY
4260 /* Given an old action and a class, come up with a new action. */
4261 /* One interesting property of this table is that wp_silent is the same
4262 as bp_silent and wp_noisy is the same as bp_noisy. That is because
4263 after stopping, the check for whether to step over a breakpoint
4264 (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
4265 reference to how we stopped. We retain separate wp_silent and
4266 bp_silent codes in case we want to change that someday.
4268 Another possibly interesting property of this table is that
4269 there's a partial ordering, priority-like, of the actions. Once
4270 you've decided that some action is appropriate, you'll never go
4271 back and decide something of a lower priority is better. The
4274 kc < jit clr sgl shl slr sn sr ss
4275 sgl < jit shl slr sn sr ss
4276 slr < jit err shl sn sr ss
4277 clr < jit err shl sn sr ss
4284 What I think this means is that we don't need a damned table
4285 here. If you just put the rows and columns in the right order,
4286 it'd look awfully regular. We could simply walk the bpstat list
4287 and choose the highest priority action we find, with a little
4288 logic to handle the 'err' cases. */
4290 /* step_resume entries: a step resume breakpoint overrides another
4291 breakpoint of signal handling (see comment in wait_for_inferior
4292 at where we set the step_resume breakpoint). */
4294 static const enum bpstat_what_main_action
4295 table
[(int) class_last
][(int) BPSTAT_WHAT_LAST
] =
4298 /* kc ss sn sgl slr clr sr shl jit */
4299 /* no_effect */ {kc
, ss
, sn
, sgl
, slr
, clr
, sr
, shl
, jit
},
4300 /* wp_silent */ {ss
, ss
, sn
, ss
, ss
, ss
, sr
, shl
, jit
},
4301 /* wp_noisy */ {sn
, sn
, sn
, sn
, sn
, sn
, sr
, shl
, jit
},
4302 /* bp_nostop */ {sgl
, ss
, sn
, sgl
, slr
, slr
, sr
, shl
, jit
},
4303 /* bp_silent */ {ss
, ss
, sn
, ss
, ss
, ss
, sr
, shl
, jit
},
4304 /* bp_noisy */ {sn
, sn
, sn
, sn
, sn
, sn
, sr
, shl
, jit
},
4305 /* long_jump */ {slr
, ss
, sn
, slr
, slr
, err
, sr
, shl
, jit
},
4306 /* long_resume */ {clr
, ss
, sn
, err
, err
, err
, sr
, shl
, jit
},
4307 /* step_resume */ {sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
},
4308 /* shlib */ {shl
, shl
, shl
, shl
, shl
, shl
, sr
, shl
, shl
},
4309 /* jit_event */ {jit
, jit
, jit
, jit
, jit
, jit
, sr
, jit
, jit
}
4323 enum bpstat_what_main_action current_action
= BPSTAT_WHAT_KEEP_CHECKING
;
4324 struct bpstat_what retval
;
4326 retval
.call_dummy
= STOP_NONE
;
4327 for (; bs
!= NULL
; bs
= bs
->next
)
4329 enum class bs_class
= no_effect
;
4330 if (bs
->breakpoint_at
== NULL
)
4331 /* I suspect this can happen if it was a momentary breakpoint
4332 which has since been deleted. */
4334 if (bs
->breakpoint_at
->owner
== NULL
)
4335 bs_class
= bp_nostop
;
4337 switch (bs
->breakpoint_at
->owner
->type
)
4343 case bp_hardware_breakpoint
:
4349 bs_class
= bp_noisy
;
4351 bs_class
= bp_silent
;
4354 bs_class
= bp_nostop
;
4357 case bp_hardware_watchpoint
:
4358 case bp_read_watchpoint
:
4359 case bp_access_watchpoint
:
4363 bs_class
= wp_noisy
;
4365 bs_class
= wp_silent
;
4368 /* There was a watchpoint, but we're not stopping.
4369 This requires no further action. */
4370 bs_class
= no_effect
;
4373 bs_class
= long_jump
;
4375 case bp_longjmp_resume
:
4376 bs_class
= long_resume
;
4378 case bp_step_resume
:
4381 bs_class
= step_resume
;
4384 /* It is for the wrong frame. */
4385 bs_class
= bp_nostop
;
4387 case bp_watchpoint_scope
:
4388 bs_class
= bp_nostop
;
4390 case bp_shlib_event
:
4391 bs_class
= shlib_event
;
4394 bs_class
= jit_event
;
4396 case bp_thread_event
:
4397 case bp_overlay_event
:
4398 case bp_longjmp_master
:
4399 case bp_std_terminate_master
:
4400 bs_class
= bp_nostop
;
4406 bs_class
= bp_noisy
;
4408 bs_class
= bp_silent
;
4411 /* There was a catchpoint, but we're not stopping.
4412 This requires no further action. */
4413 bs_class
= no_effect
;
4416 /* Make sure the action is stop (silent or noisy),
4417 so infrun.c pops the dummy frame. */
4418 bs_class
= bp_silent
;
4419 retval
.call_dummy
= STOP_STACK_DUMMY
;
4421 case bp_std_terminate
:
4422 /* Make sure the action is stop (silent or noisy),
4423 so infrun.c pops the dummy frame. */
4424 bs_class
= bp_silent
;
4425 retval
.call_dummy
= STOP_STD_TERMINATE
;
4428 case bp_fast_tracepoint
:
4429 /* Tracepoint hits should not be reported back to GDB, and
4430 if one got through somehow, it should have been filtered
4432 internal_error (__FILE__
, __LINE__
,
4433 _("bpstat_what: tracepoint encountered"));
4436 current_action
= table
[(int) bs_class
][(int) current_action
];
4438 retval
.main_action
= current_action
;
4442 /* Nonzero if we should step constantly (e.g. watchpoints on machines
4443 without hardware support). This isn't related to a specific bpstat,
4444 just to things like whether watchpoints are set. */
4447 bpstat_should_step (void)
4449 struct breakpoint
*b
;
4452 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
&& b
->loc
!= NULL
)
4458 bpstat_causes_stop (bpstat bs
)
4460 for (; bs
!= NULL
; bs
= bs
->next
)
4469 /* Print the LOC location out of the list of B->LOC locations. */
4471 static void print_breakpoint_location (struct breakpoint
*b
,
4472 struct bp_location
*loc
,
4474 struct ui_stream
*stb
)
4476 struct cleanup
*old_chain
= save_current_program_space ();
4478 if (loc
!= NULL
&& loc
->shlib_disabled
)
4482 set_current_program_space (loc
->pspace
);
4484 if (b
->source_file
&& loc
)
4487 = find_pc_sect_function (loc
->address
, loc
->section
);
4490 ui_out_text (uiout
, "in ");
4491 ui_out_field_string (uiout
, "func",
4492 SYMBOL_PRINT_NAME (sym
));
4493 ui_out_wrap_hint (uiout
, wrap_indent
);
4494 ui_out_text (uiout
, " at ");
4496 ui_out_field_string (uiout
, "file", b
->source_file
);
4497 ui_out_text (uiout
, ":");
4499 if (ui_out_is_mi_like_p (uiout
))
4501 struct symtab_and_line sal
= find_pc_line (loc
->address
, 0);
4502 char *fullname
= symtab_to_fullname (sal
.symtab
);
4505 ui_out_field_string (uiout
, "fullname", fullname
);
4508 ui_out_field_int (uiout
, "line", b
->line_number
);
4512 print_address_symbolic (loc
->gdbarch
, loc
->address
, stb
->stream
,
4514 ui_out_field_stream (uiout
, "at", stb
);
4517 ui_out_field_string (uiout
, "pending", b
->addr_string
);
4519 do_cleanups (old_chain
);
4522 /* Print B to gdb_stdout. */
4524 print_one_breakpoint_location (struct breakpoint
*b
,
4525 struct bp_location
*loc
,
4527 struct bp_location
**last_loc
,
4528 int print_address_bits
,
4531 struct command_line
*l
;
4532 struct ep_type_description
4537 static struct ep_type_description bptypes
[] =
4539 {bp_none
, "?deleted?"},
4540 {bp_breakpoint
, "breakpoint"},
4541 {bp_hardware_breakpoint
, "hw breakpoint"},
4542 {bp_until
, "until"},
4543 {bp_finish
, "finish"},
4544 {bp_watchpoint
, "watchpoint"},
4545 {bp_hardware_watchpoint
, "hw watchpoint"},
4546 {bp_read_watchpoint
, "read watchpoint"},
4547 {bp_access_watchpoint
, "acc watchpoint"},
4548 {bp_longjmp
, "longjmp"},
4549 {bp_longjmp_resume
, "longjmp resume"},
4550 {bp_step_resume
, "step resume"},
4551 {bp_watchpoint_scope
, "watchpoint scope"},
4552 {bp_call_dummy
, "call dummy"},
4553 {bp_std_terminate
, "std::terminate"},
4554 {bp_shlib_event
, "shlib events"},
4555 {bp_thread_event
, "thread events"},
4556 {bp_overlay_event
, "overlay events"},
4557 {bp_longjmp_master
, "longjmp master"},
4558 {bp_std_terminate_master
, "std::terminate master"},
4559 {bp_catchpoint
, "catchpoint"},
4560 {bp_tracepoint
, "tracepoint"},
4561 {bp_fast_tracepoint
, "fast tracepoint"},
4562 {bp_jit_event
, "jit events"},
4565 static char bpenables
[] = "nynny";
4566 char wrap_indent
[80];
4567 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
4568 struct cleanup
*old_chain
= make_cleanup_ui_out_stream_delete (stb
);
4569 struct cleanup
*bkpt_chain
;
4571 int header_of_multiple
= 0;
4572 int part_of_multiple
= (loc
!= NULL
);
4573 struct value_print_options opts
;
4575 get_user_print_options (&opts
);
4577 gdb_assert (!loc
|| loc_number
!= 0);
4578 /* See comment in print_one_breakpoint concerning
4579 treatment of breakpoints with single disabled
4583 && (b
->loc
->next
!= NULL
|| !b
->loc
->enabled
)))
4584 header_of_multiple
= 1;
4589 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "bkpt");
4593 if (part_of_multiple
)
4596 formatted
= xstrprintf ("%d.%d", b
->number
, loc_number
);
4597 ui_out_field_string (uiout
, "number", formatted
);
4602 ui_out_field_int (uiout
, "number", b
->number
);
4607 if (part_of_multiple
)
4608 ui_out_field_skip (uiout
, "type");
4611 if (((int) b
->type
>= (sizeof (bptypes
) / sizeof (bptypes
[0])))
4612 || ((int) b
->type
!= bptypes
[(int) b
->type
].type
))
4613 internal_error (__FILE__
, __LINE__
,
4614 _("bptypes table does not describe type #%d."),
4616 ui_out_field_string (uiout
, "type", bptypes
[(int) b
->type
].description
);
4621 if (part_of_multiple
)
4622 ui_out_field_skip (uiout
, "disp");
4624 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
4629 if (part_of_multiple
)
4630 ui_out_field_string (uiout
, "enabled", loc
->enabled
? "y" : "n");
4632 ui_out_field_fmt (uiout
, "enabled", "%c",
4633 bpenables
[(int) b
->enable_state
]);
4634 ui_out_spaces (uiout
, 2);
4638 strcpy (wrap_indent
, " ");
4639 if (opts
.addressprint
)
4641 if (print_address_bits
<= 32)
4642 strcat (wrap_indent
, " ");
4644 strcat (wrap_indent
, " ");
4647 if (b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
4649 /* Although the print_one can possibly print
4650 all locations, calling it here is not likely
4651 to get any nice result. So, make sure there's
4652 just one location. */
4653 gdb_assert (b
->loc
== NULL
|| b
->loc
->next
== NULL
);
4654 b
->ops
->print_one (b
, last_loc
);
4660 internal_error (__FILE__
, __LINE__
,
4661 _("print_one_breakpoint: bp_none encountered\n"));
4665 case bp_hardware_watchpoint
:
4666 case bp_read_watchpoint
:
4667 case bp_access_watchpoint
:
4668 /* Field 4, the address, is omitted (which makes the columns
4669 not line up too nicely with the headers, but the effect
4670 is relatively readable). */
4671 if (opts
.addressprint
)
4672 ui_out_field_skip (uiout
, "addr");
4674 ui_out_field_string (uiout
, "what", b
->exp_string
);
4678 case bp_hardware_breakpoint
:
4682 case bp_longjmp_resume
:
4683 case bp_step_resume
:
4684 case bp_watchpoint_scope
:
4686 case bp_std_terminate
:
4687 case bp_shlib_event
:
4688 case bp_thread_event
:
4689 case bp_overlay_event
:
4690 case bp_longjmp_master
:
4691 case bp_std_terminate_master
:
4693 case bp_fast_tracepoint
:
4695 if (opts
.addressprint
)
4698 if (header_of_multiple
)
4699 ui_out_field_string (uiout
, "addr", "<MULTIPLE>");
4700 else if (b
->loc
== NULL
|| loc
->shlib_disabled
)
4701 ui_out_field_string (uiout
, "addr", "<PENDING>");
4703 ui_out_field_core_addr (uiout
, "addr",
4704 loc
->gdbarch
, loc
->address
);
4707 if (!header_of_multiple
)
4708 print_breakpoint_location (b
, loc
, wrap_indent
, stb
);
4715 /* For backward compatibility, don't display inferiors unless there
4718 && !header_of_multiple
4720 || (!gdbarch_has_global_breakpoints (target_gdbarch
)
4721 && (number_of_program_spaces () > 1
4722 || number_of_inferiors () > 1)
4723 /* LOC is for existing B, it cannot be in moribund_locations and
4724 thus having NULL OWNER. */
4725 && loc
->owner
->type
!= bp_catchpoint
)))
4727 struct inferior
*inf
;
4730 for (inf
= inferior_list
; inf
!= NULL
; inf
= inf
->next
)
4732 if (inf
->pspace
== loc
->pspace
)
4737 ui_out_text (uiout
, " inf ");
4740 ui_out_text (uiout
, ", ");
4741 ui_out_text (uiout
, plongest (inf
->num
));
4746 if (!part_of_multiple
)
4748 if (b
->thread
!= -1)
4750 /* FIXME: This seems to be redundant and lost here; see the
4751 "stop only in" line a little further down. */
4752 ui_out_text (uiout
, " thread ");
4753 ui_out_field_int (uiout
, "thread", b
->thread
);
4755 else if (b
->task
!= 0)
4757 ui_out_text (uiout
, " task ");
4758 ui_out_field_int (uiout
, "task", b
->task
);
4762 ui_out_text (uiout
, "\n");
4764 if (part_of_multiple
&& frame_id_p (b
->frame_id
))
4767 ui_out_text (uiout
, "\tstop only in stack frame at ");
4768 /* FIXME: cagney/2002-12-01: Shouldn't be poeking around inside
4770 ui_out_field_core_addr (uiout
, "frame",
4771 b
->gdbarch
, b
->frame_id
.stack_addr
);
4772 ui_out_text (uiout
, "\n");
4775 if (!part_of_multiple
&& b
->cond_string
&& !ada_exception_catchpoint_p (b
))
4777 /* We do not print the condition for Ada exception catchpoints
4778 because the condition is an internal implementation detail
4779 that we do not want to expose to the user. */
4781 if (is_tracepoint (b
))
4782 ui_out_text (uiout
, "\ttrace only if ");
4784 ui_out_text (uiout
, "\tstop only if ");
4785 ui_out_field_string (uiout
, "cond", b
->cond_string
);
4786 ui_out_text (uiout
, "\n");
4789 if (!part_of_multiple
&& b
->thread
!= -1)
4791 /* FIXME should make an annotation for this */
4792 ui_out_text (uiout
, "\tstop only in thread ");
4793 ui_out_field_int (uiout
, "thread", b
->thread
);
4794 ui_out_text (uiout
, "\n");
4797 if (!part_of_multiple
&& b
->hit_count
)
4799 /* FIXME should make an annotation for this */
4800 if (ep_is_catchpoint (b
))
4801 ui_out_text (uiout
, "\tcatchpoint");
4803 ui_out_text (uiout
, "\tbreakpoint");
4804 ui_out_text (uiout
, " already hit ");
4805 ui_out_field_int (uiout
, "times", b
->hit_count
);
4806 if (b
->hit_count
== 1)
4807 ui_out_text (uiout
, " time\n");
4809 ui_out_text (uiout
, " times\n");
4812 /* Output the count also if it is zero, but only if this is
4813 mi. FIXME: Should have a better test for this. */
4814 if (ui_out_is_mi_like_p (uiout
))
4815 if (!part_of_multiple
&& b
->hit_count
== 0)
4816 ui_out_field_int (uiout
, "times", b
->hit_count
);
4818 if (!part_of_multiple
&& b
->ignore_count
)
4821 ui_out_text (uiout
, "\tignore next ");
4822 ui_out_field_int (uiout
, "ignore", b
->ignore_count
);
4823 ui_out_text (uiout
, " hits\n");
4826 l
= b
->commands
? b
->commands
->commands
: NULL
;
4827 if (!part_of_multiple
&& l
)
4829 struct cleanup
*script_chain
;
4832 script_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "script");
4833 print_command_lines (uiout
, l
, 4);
4834 do_cleanups (script_chain
);
4837 if (!part_of_multiple
&& b
->pass_count
)
4839 annotate_field (10);
4840 ui_out_text (uiout
, "\tpass count ");
4841 ui_out_field_int (uiout
, "pass", b
->pass_count
);
4842 ui_out_text (uiout
, " \n");
4845 if (ui_out_is_mi_like_p (uiout
) && !part_of_multiple
)
4848 ui_out_field_string (uiout
, "original-location", b
->addr_string
);
4849 else if (b
->exp_string
)
4850 ui_out_field_string (uiout
, "original-location", b
->exp_string
);
4853 do_cleanups (bkpt_chain
);
4854 do_cleanups (old_chain
);
4858 print_one_breakpoint (struct breakpoint
*b
,
4859 struct bp_location
**last_loc
, int print_address_bits
,
4862 print_one_breakpoint_location (b
, NULL
, 0, last_loc
,
4863 print_address_bits
, allflag
);
4865 /* If this breakpoint has custom print function,
4866 it's already printed. Otherwise, print individual
4867 locations, if any. */
4868 if (b
->ops
== NULL
|| b
->ops
->print_one
== NULL
)
4870 /* If breakpoint has a single location that is
4871 disabled, we print it as if it had
4872 several locations, since otherwise it's hard to
4873 represent "breakpoint enabled, location disabled"
4875 Note that while hardware watchpoints have
4876 several locations internally, that's no a property
4879 && !is_hardware_watchpoint (b
)
4880 && (b
->loc
->next
|| !b
->loc
->enabled
)
4881 && !ui_out_is_mi_like_p (uiout
))
4883 struct bp_location
*loc
;
4885 for (loc
= b
->loc
; loc
; loc
= loc
->next
, ++n
)
4886 print_one_breakpoint_location (b
, loc
, n
, last_loc
,
4887 print_address_bits
, allflag
);
4893 breakpoint_address_bits (struct breakpoint
*b
)
4895 int print_address_bits
= 0;
4896 struct bp_location
*loc
;
4898 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
4902 /* Software watchpoints that aren't watching memory don't have
4903 an address to print. */
4904 if (b
->type
== bp_watchpoint
&& loc
->watchpoint_type
== -1)
4907 addr_bit
= gdbarch_addr_bit (loc
->gdbarch
);
4908 if (addr_bit
> print_address_bits
)
4909 print_address_bits
= addr_bit
;
4912 return print_address_bits
;
4915 struct captured_breakpoint_query_args
4921 do_captured_breakpoint_query (struct ui_out
*uiout
, void *data
)
4923 struct captured_breakpoint_query_args
*args
= data
;
4924 struct breakpoint
*b
;
4925 struct bp_location
*dummy_loc
= NULL
;
4929 if (args
->bnum
== b
->number
)
4931 int print_address_bits
= breakpoint_address_bits (b
);
4933 print_one_breakpoint (b
, &dummy_loc
, print_address_bits
, 0);
4941 gdb_breakpoint_query (struct ui_out
*uiout
, int bnum
, char **error_message
)
4943 struct captured_breakpoint_query_args args
;
4946 /* For the moment we don't trust print_one_breakpoint() to not throw
4948 if (catch_exceptions_with_msg (uiout
, do_captured_breakpoint_query
, &args
,
4949 error_message
, RETURN_MASK_ALL
) < 0)
4955 /* Return non-zero if B is user settable (breakpoints, watchpoints,
4956 catchpoints, et.al.). */
4959 user_settable_breakpoint (const struct breakpoint
*b
)
4961 return (b
->type
== bp_breakpoint
4962 || b
->type
== bp_catchpoint
4963 || b
->type
== bp_hardware_breakpoint
4964 || is_tracepoint (b
)
4965 || is_watchpoint (b
));
4968 /* Print information on user settable breakpoint (watchpoint, etc)
4969 number BNUM. If BNUM is -1 print all user-settable breakpoints.
4970 If ALLFLAG is non-zero, include non-user-settable breakpoints. If
4971 FILTER is non-NULL, call it on each breakpoint and only include the
4972 ones for which it returns non-zero. Return the total number of
4973 breakpoints listed. */
4976 breakpoint_1 (int bnum
, int allflag
, int (*filter
) (const struct breakpoint
*))
4978 struct breakpoint
*b
;
4979 struct bp_location
*last_loc
= NULL
;
4980 int nr_printable_breakpoints
;
4981 struct cleanup
*bkpttbl_chain
;
4982 struct value_print_options opts
;
4983 int print_address_bits
= 0;
4985 get_user_print_options (&opts
);
4987 /* Compute the number of rows in the table, as well as the
4988 size required for address fields. */
4989 nr_printable_breakpoints
= 0;
4992 || bnum
== b
->number
)
4994 /* If we have a filter, only list the breakpoints it accepts. */
4995 if (filter
&& !filter (b
))
4998 if (allflag
|| user_settable_breakpoint (b
))
5000 int addr_bit
= breakpoint_address_bits (b
);
5001 if (addr_bit
> print_address_bits
)
5002 print_address_bits
= addr_bit
;
5004 nr_printable_breakpoints
++;
5008 if (opts
.addressprint
)
5010 = make_cleanup_ui_out_table_begin_end (uiout
, 6, nr_printable_breakpoints
,
5014 = make_cleanup_ui_out_table_begin_end (uiout
, 5, nr_printable_breakpoints
,
5017 if (nr_printable_breakpoints
> 0)
5018 annotate_breakpoints_headers ();
5019 if (nr_printable_breakpoints
> 0)
5021 ui_out_table_header (uiout
, 7, ui_left
, "number", "Num"); /* 1 */
5022 if (nr_printable_breakpoints
> 0)
5024 ui_out_table_header (uiout
, 14, ui_left
, "type", "Type"); /* 2 */
5025 if (nr_printable_breakpoints
> 0)
5027 ui_out_table_header (uiout
, 4, ui_left
, "disp", "Disp"); /* 3 */
5028 if (nr_printable_breakpoints
> 0)
5030 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb"); /* 4 */
5031 if (opts
.addressprint
)
5033 if (nr_printable_breakpoints
> 0)
5035 if (print_address_bits
<= 32)
5036 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");/* 5 */
5038 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");/* 5 */
5040 if (nr_printable_breakpoints
> 0)
5042 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What"); /* 6 */
5043 ui_out_table_body (uiout
);
5044 if (nr_printable_breakpoints
> 0)
5045 annotate_breakpoints_table ();
5051 || bnum
== b
->number
)
5053 /* If we have a filter, only list the breakpoints it accepts. */
5054 if (filter
&& !filter (b
))
5057 /* We only print out user settable breakpoints unless the
5059 if (allflag
|| user_settable_breakpoint (b
))
5060 print_one_breakpoint (b
, &last_loc
, print_address_bits
, allflag
);
5064 do_cleanups (bkpttbl_chain
);
5066 if (nr_printable_breakpoints
== 0)
5068 /* If there's a filter, let the caller decide how to report empty list. */
5072 ui_out_message (uiout
, 0, "No breakpoints or watchpoints.\n");
5074 ui_out_message (uiout
, 0, "No breakpoint or watchpoint number %d.\n",
5080 if (last_loc
&& !server_command
)
5081 set_next_address (last_loc
->gdbarch
, last_loc
->address
);
5084 /* FIXME? Should this be moved up so that it is only called when
5085 there have been breakpoints? */
5086 annotate_breakpoints_table_end ();
5088 return nr_printable_breakpoints
;
5091 /* Display the value of default-collect in a way that is generally
5092 compatible with the breakpoint list. */
5095 default_collect_info (void)
5097 /* If it has no value (which is frequently the case), say nothing; a
5098 message like "No default-collect." gets in user's face when it's
5100 if (!*default_collect
)
5103 /* The following phrase lines up nicely with per-tracepoint collect
5105 ui_out_text (uiout
, "default collect ");
5106 ui_out_field_string (uiout
, "default-collect", default_collect
);
5107 ui_out_text (uiout
, " \n");
5111 breakpoints_info (char *bnum_exp
, int from_tty
)
5116 bnum
= parse_and_eval_long (bnum_exp
);
5118 breakpoint_1 (bnum
, 0, NULL
);
5120 default_collect_info ();
5124 watchpoints_info (char *wpnum_exp
, int from_tty
)
5126 int wpnum
= -1, num_printed
;
5129 wpnum
= parse_and_eval_long (wpnum_exp
);
5131 num_printed
= breakpoint_1 (wpnum
, 0, is_watchpoint
);
5133 if (num_printed
== 0)
5136 ui_out_message (uiout
, 0, "No watchpoints.\n");
5138 ui_out_message (uiout
, 0, "No watchpoint number %d.\n", wpnum
);
5143 maintenance_info_breakpoints (char *bnum_exp
, int from_tty
)
5148 bnum
= parse_and_eval_long (bnum_exp
);
5150 breakpoint_1 (bnum
, 1, NULL
);
5152 default_collect_info ();
5156 breakpoint_has_pc (struct breakpoint
*b
,
5157 struct program_space
*pspace
,
5158 CORE_ADDR pc
, struct obj_section
*section
)
5160 struct bp_location
*bl
= b
->loc
;
5162 for (; bl
; bl
= bl
->next
)
5164 if (bl
->pspace
== pspace
5165 && bl
->address
== pc
5166 && (!overlay_debugging
|| bl
->section
== section
))
5172 /* Print a message describing any breakpoints set at PC. This
5173 concerns with logical breakpoints, so we match program spaces, not
5177 describe_other_breakpoints (struct gdbarch
*gdbarch
,
5178 struct program_space
*pspace
, CORE_ADDR pc
,
5179 struct obj_section
*section
, int thread
)
5182 struct breakpoint
*b
;
5185 others
+= breakpoint_has_pc (b
, pspace
, pc
, section
);
5189 printf_filtered (_("Note: breakpoint "));
5190 else /* if (others == ???) */
5191 printf_filtered (_("Note: breakpoints "));
5193 if (breakpoint_has_pc (b
, pspace
, pc
, section
))
5196 printf_filtered ("%d", b
->number
);
5197 if (b
->thread
== -1 && thread
!= -1)
5198 printf_filtered (" (all threads)");
5199 else if (b
->thread
!= -1)
5200 printf_filtered (" (thread %d)", b
->thread
);
5201 printf_filtered ("%s%s ",
5202 ((b
->enable_state
== bp_disabled
5203 || b
->enable_state
== bp_call_disabled
5204 || b
->enable_state
== bp_startup_disabled
)
5206 : b
->enable_state
== bp_permanent
5210 : ((others
== 1) ? " and" : ""));
5212 printf_filtered (_("also set at pc "));
5213 fputs_filtered (paddress (gdbarch
, pc
), gdb_stdout
);
5214 printf_filtered (".\n");
5218 /* Set the default place to put a breakpoint
5219 for the `break' command with no arguments. */
5222 set_default_breakpoint (int valid
, struct program_space
*pspace
,
5223 CORE_ADDR addr
, struct symtab
*symtab
,
5226 default_breakpoint_valid
= valid
;
5227 default_breakpoint_pspace
= pspace
;
5228 default_breakpoint_address
= addr
;
5229 default_breakpoint_symtab
= symtab
;
5230 default_breakpoint_line
= line
;
5233 /* Return true iff it is meaningful to use the address member of
5234 BPT. For some breakpoint types, the address member is irrelevant
5235 and it makes no sense to attempt to compare it to other addresses
5236 (or use it for any other purpose either).
5238 More specifically, each of the following breakpoint types will always
5239 have a zero valued address and we don't want to mark breakpoints of any of
5240 these types to be a duplicate of an actual breakpoint at address zero:
5248 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
5250 enum bptype type
= bpt
->type
;
5252 return (type
!= bp_watchpoint
&& type
!= bp_catchpoint
);
5255 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
5256 true if LOC1 and LOC2 represent the same watchpoint location. */
5259 watchpoint_locations_match (struct bp_location
*loc1
, struct bp_location
*loc2
)
5261 /* Both of them must not be in moribund_locations. */
5262 gdb_assert (loc1
->owner
!= NULL
);
5263 gdb_assert (loc2
->owner
!= NULL
);
5265 /* Note that this checks the owner's type, not the location's. In
5266 case the target does not support read watchpoints, but does
5267 support access watchpoints, we'll have bp_read_watchpoint
5268 watchpoints with hw_access locations. Those should be considered
5269 duplicates of hw_read locations. The hw_read locations will
5270 become hw_access locations later. */
5271 return (loc1
->owner
->type
== loc2
->owner
->type
5272 && loc1
->pspace
->aspace
== loc2
->pspace
->aspace
5273 && loc1
->address
== loc2
->address
5274 && loc1
->length
== loc2
->length
);
5277 /* Returns true if {ASPACE1,ADDR1} and {ASPACE2,ADDR2} represent the
5278 same breakpoint location. In most targets, this can only be true
5279 if ASPACE1 matches ASPACE2. On targets that have global
5280 breakpoints, the address space doesn't really matter. */
5283 breakpoint_address_match (struct address_space
*aspace1
, CORE_ADDR addr1
,
5284 struct address_space
*aspace2
, CORE_ADDR addr2
)
5286 return ((gdbarch_has_global_breakpoints (target_gdbarch
)
5287 || aspace1
== aspace2
)
5291 /* Assuming LOC1 and LOC2's types' have meaningful target addresses
5292 (breakpoint_address_is_meaningful), returns true if LOC1 and LOC2
5293 represent the same location. */
5296 breakpoint_locations_match (struct bp_location
*loc1
, struct bp_location
*loc2
)
5298 int hw_point1
, hw_point2
;
5300 /* Both of them must not be in moribund_locations. */
5301 gdb_assert (loc1
->owner
!= NULL
);
5302 gdb_assert (loc2
->owner
!= NULL
);
5304 hw_point1
= is_hardware_watchpoint (loc1
->owner
);
5305 hw_point2
= is_hardware_watchpoint (loc2
->owner
);
5307 if (hw_point1
!= hw_point2
)
5310 return watchpoint_locations_match (loc1
, loc2
);
5312 return breakpoint_address_match (loc1
->pspace
->aspace
, loc1
->address
,
5313 loc2
->pspace
->aspace
, loc2
->address
);
5317 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
5318 int bnum
, int have_bnum
)
5323 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
5324 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
5326 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
5327 bnum
, astr1
, astr2
);
5329 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
5332 /* Adjust a breakpoint's address to account for architectural constraints
5333 on breakpoint placement. Return the adjusted address. Note: Very
5334 few targets require this kind of adjustment. For most targets,
5335 this function is simply the identity function. */
5338 adjust_breakpoint_address (struct gdbarch
*gdbarch
,
5339 CORE_ADDR bpaddr
, enum bptype bptype
)
5341 if (!gdbarch_adjust_breakpoint_address_p (gdbarch
))
5343 /* Very few targets need any kind of breakpoint adjustment. */
5346 else if (bptype
== bp_watchpoint
5347 || bptype
== bp_hardware_watchpoint
5348 || bptype
== bp_read_watchpoint
5349 || bptype
== bp_access_watchpoint
5350 || bptype
== bp_catchpoint
)
5352 /* Watchpoints and the various bp_catch_* eventpoints should not
5353 have their addresses modified. */
5358 CORE_ADDR adjusted_bpaddr
;
5360 /* Some targets have architectural constraints on the placement
5361 of breakpoint instructions. Obtain the adjusted address. */
5362 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (gdbarch
, bpaddr
);
5364 /* An adjusted breakpoint address can significantly alter
5365 a user's expectations. Print a warning if an adjustment
5367 if (adjusted_bpaddr
!= bpaddr
)
5368 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
5370 return adjusted_bpaddr
;
5374 /* Allocate a struct bp_location. */
5376 static struct bp_location
*
5377 allocate_bp_location (struct breakpoint
*bpt
)
5379 struct bp_location
*loc
;
5381 loc
= xmalloc (sizeof (struct bp_location
));
5382 memset (loc
, 0, sizeof (*loc
));
5386 loc
->shlib_disabled
= 0;
5395 case bp_longjmp_resume
:
5396 case bp_step_resume
:
5397 case bp_watchpoint_scope
:
5399 case bp_std_terminate
:
5400 case bp_shlib_event
:
5401 case bp_thread_event
:
5402 case bp_overlay_event
:
5404 case bp_longjmp_master
:
5405 case bp_std_terminate_master
:
5406 loc
->loc_type
= bp_loc_software_breakpoint
;
5408 case bp_hardware_breakpoint
:
5409 loc
->loc_type
= bp_loc_hardware_breakpoint
;
5411 case bp_hardware_watchpoint
:
5412 case bp_read_watchpoint
:
5413 case bp_access_watchpoint
:
5414 loc
->loc_type
= bp_loc_hardware_watchpoint
;
5419 case bp_fast_tracepoint
:
5420 loc
->loc_type
= bp_loc_other
;
5423 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
5429 static void free_bp_location (struct bp_location
*loc
)
5431 /* Be sure no bpstat's are pointing at it after it's been freed. */
5432 /* FIXME, how can we find all bpstat's?
5433 We just check stop_bpstat for now. Note that we cannot just
5434 remove bpstats pointing at bpt from the stop_bpstat list
5435 entirely, as breakpoint commands are associated with the bpstat;
5436 if we remove it here, then the later call to
5437 bpstat_do_actions (&stop_bpstat);
5438 in event-top.c won't do anything, and temporary breakpoints
5439 with commands won't work. */
5441 iterate_over_threads (bpstat_remove_bp_location_callback
, loc
);
5446 if (loc
->function_name
)
5447 xfree (loc
->function_name
);
5452 /* Helper to set_raw_breakpoint below. Creates a breakpoint
5453 that has type BPTYPE and has no locations as yet. */
5454 /* This function is used in gdbtk sources and thus can not be made static. */
5456 static struct breakpoint
*
5457 set_raw_breakpoint_without_location (struct gdbarch
*gdbarch
,
5460 struct breakpoint
*b
, *b1
;
5462 b
= (struct breakpoint
*) xmalloc (sizeof (struct breakpoint
));
5463 memset (b
, 0, sizeof (*b
));
5466 b
->gdbarch
= gdbarch
;
5467 b
->language
= current_language
->la_language
;
5468 b
->input_radix
= input_radix
;
5470 b
->enable_state
= bp_enabled
;
5473 b
->ignore_count
= 0;
5475 b
->frame_id
= null_frame_id
;
5476 b
->forked_inferior_pid
= null_ptid
;
5477 b
->exec_pathname
= NULL
;
5478 b
->syscalls_to_be_caught
= NULL
;
5480 b
->condition_not_parsed
= 0;
5482 /* Add this breakpoint to the end of the chain
5483 so that a list of breakpoints will come out in order
5484 of increasing numbers. */
5486 b1
= breakpoint_chain
;
5488 breakpoint_chain
= b
;
5498 /* Initialize loc->function_name. */
5500 set_breakpoint_location_function (struct bp_location
*loc
)
5502 gdb_assert (loc
->owner
!= NULL
);
5504 if (loc
->owner
->type
== bp_breakpoint
5505 || loc
->owner
->type
== bp_hardware_breakpoint
5506 || is_tracepoint (loc
->owner
))
5508 find_pc_partial_function (loc
->address
, &(loc
->function_name
),
5510 if (loc
->function_name
)
5511 loc
->function_name
= xstrdup (loc
->function_name
);
5515 /* Attempt to determine architecture of location identified by SAL. */
5516 static struct gdbarch
*
5517 get_sal_arch (struct symtab_and_line sal
)
5520 return get_objfile_arch (sal
.section
->objfile
);
5522 return get_objfile_arch (sal
.symtab
->objfile
);
5527 /* set_raw_breakpoint is a low level routine for allocating and
5528 partially initializing a breakpoint of type BPTYPE. The newly
5529 created breakpoint's address, section, source file name, and line
5530 number are provided by SAL. The newly created and partially
5531 initialized breakpoint is added to the breakpoint chain and
5532 is also returned as the value of this function.
5534 It is expected that the caller will complete the initialization of
5535 the newly created breakpoint struct as well as output any status
5536 information regarding the creation of a new breakpoint. In
5537 particular, set_raw_breakpoint does NOT set the breakpoint
5538 number! Care should be taken to not allow an error to occur
5539 prior to completing the initialization of the breakpoint. If this
5540 should happen, a bogus breakpoint will be left on the chain. */
5543 set_raw_breakpoint (struct gdbarch
*gdbarch
,
5544 struct symtab_and_line sal
, enum bptype bptype
)
5546 struct breakpoint
*b
= set_raw_breakpoint_without_location (gdbarch
, bptype
);
5547 CORE_ADDR adjusted_address
;
5548 struct gdbarch
*loc_gdbarch
;
5550 loc_gdbarch
= get_sal_arch (sal
);
5552 loc_gdbarch
= b
->gdbarch
;
5554 if (bptype
!= bp_catchpoint
)
5555 gdb_assert (sal
.pspace
!= NULL
);
5557 /* Adjust the breakpoint's address prior to allocating a location.
5558 Once we call allocate_bp_location(), that mostly uninitialized
5559 location will be placed on the location chain. Adjustment of the
5560 breakpoint may cause target_read_memory() to be called and we do
5561 not want its scan of the location chain to find a breakpoint and
5562 location that's only been partially initialized. */
5563 adjusted_address
= adjust_breakpoint_address (loc_gdbarch
, sal
.pc
, b
->type
);
5565 b
->loc
= allocate_bp_location (b
);
5566 b
->loc
->gdbarch
= loc_gdbarch
;
5567 b
->loc
->requested_address
= sal
.pc
;
5568 b
->loc
->address
= adjusted_address
;
5569 b
->loc
->pspace
= sal
.pspace
;
5571 /* Store the program space that was used to set the breakpoint, for
5572 breakpoint resetting. */
5573 b
->pspace
= sal
.pspace
;
5575 if (sal
.symtab
== NULL
)
5576 b
->source_file
= NULL
;
5578 b
->source_file
= xstrdup (sal
.symtab
->filename
);
5579 b
->loc
->section
= sal
.section
;
5580 b
->line_number
= sal
.line
;
5582 set_breakpoint_location_function (b
->loc
);
5584 breakpoints_changed ();
5590 /* Note that the breakpoint object B describes a permanent breakpoint
5591 instruction, hard-wired into the inferior's code. */
5593 make_breakpoint_permanent (struct breakpoint
*b
)
5595 struct bp_location
*bl
;
5597 b
->enable_state
= bp_permanent
;
5599 /* By definition, permanent breakpoints are already present in the code.
5600 Mark all locations as inserted. For now, make_breakpoint_permanent
5601 is called in just one place, so it's hard to say if it's reasonable
5602 to have permanent breakpoint with multiple locations or not,
5603 but it's easy to implmement. */
5604 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
5608 /* Call this routine when stepping and nexting to enable a breakpoint
5609 if we do a longjmp() in THREAD. When we hit that breakpoint, call
5610 set_longjmp_resume_breakpoint() to figure out where we are going. */
5613 set_longjmp_breakpoint (int thread
)
5615 struct breakpoint
*b
, *temp
;
5617 /* To avoid having to rescan all objfile symbols at every step,
5618 we maintain a list of continually-inserted but always disabled
5619 longjmp "master" breakpoints. Here, we simply create momentary
5620 clones of those and enable them for the requested thread. */
5621 ALL_BREAKPOINTS_SAFE (b
, temp
)
5622 if (b
->pspace
== current_program_space
5623 && b
->type
== bp_longjmp_master
)
5625 struct breakpoint
*clone
= clone_momentary_breakpoint (b
);
5627 clone
->type
= bp_longjmp
;
5628 clone
->thread
= thread
;
5632 /* Delete all longjmp breakpoints from THREAD. */
5634 delete_longjmp_breakpoint (int thread
)
5636 struct breakpoint
*b
, *temp
;
5638 ALL_BREAKPOINTS_SAFE (b
, temp
)
5639 if (b
->type
== bp_longjmp
)
5641 if (b
->thread
== thread
)
5642 delete_breakpoint (b
);
5647 enable_overlay_breakpoints (void)
5649 struct breakpoint
*b
;
5652 if (b
->type
== bp_overlay_event
)
5654 b
->enable_state
= bp_enabled
;
5655 update_global_location_list (1);
5656 overlay_events_enabled
= 1;
5661 disable_overlay_breakpoints (void)
5663 struct breakpoint
*b
;
5666 if (b
->type
== bp_overlay_event
)
5668 b
->enable_state
= bp_disabled
;
5669 update_global_location_list (0);
5670 overlay_events_enabled
= 0;
5674 /* Set an active std::terminate breakpoint for each std::terminate
5675 master breakpoint. */
5677 set_std_terminate_breakpoint (void)
5679 struct breakpoint
*b
, *temp
;
5681 ALL_BREAKPOINTS_SAFE (b
, temp
)
5682 if (b
->pspace
== current_program_space
5683 && b
->type
== bp_std_terminate_master
)
5685 struct breakpoint
*clone
= clone_momentary_breakpoint (b
);
5686 clone
->type
= bp_std_terminate
;
5690 /* Delete all the std::terminate breakpoints. */
5692 delete_std_terminate_breakpoint (void)
5694 struct breakpoint
*b
, *temp
;
5696 ALL_BREAKPOINTS_SAFE (b
, temp
)
5697 if (b
->type
== bp_std_terminate
)
5698 delete_breakpoint (b
);
5702 create_thread_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
5704 struct breakpoint
*b
;
5706 b
= create_internal_breakpoint (gdbarch
, address
, bp_thread_event
);
5708 b
->enable_state
= bp_enabled
;
5709 /* addr_string has to be used or breakpoint_re_set will delete me. */
5711 = xstrprintf ("*%s", paddress (b
->loc
->gdbarch
, b
->loc
->address
));
5713 update_global_location_list_nothrow (1);
5719 remove_thread_event_breakpoints (void)
5721 struct breakpoint
*b
, *temp
;
5723 ALL_BREAKPOINTS_SAFE (b
, temp
)
5724 if (b
->type
== bp_thread_event
5725 && b
->loc
->pspace
== current_program_space
)
5726 delete_breakpoint (b
);
5729 struct captured_parse_breakpoint_args
5732 struct symtabs_and_lines
*sals_p
;
5733 char ***addr_string_p
;
5737 struct lang_and_radix
5743 /* Create a breakpoint for JIT code registration and unregistration. */
5746 create_jit_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
5748 struct breakpoint
*b
;
5750 b
= create_internal_breakpoint (gdbarch
, address
, bp_jit_event
);
5751 update_global_location_list_nothrow (1);
5756 remove_solib_event_breakpoints (void)
5758 struct breakpoint
*b
, *temp
;
5760 ALL_BREAKPOINTS_SAFE (b
, temp
)
5761 if (b
->type
== bp_shlib_event
5762 && b
->loc
->pspace
== current_program_space
)
5763 delete_breakpoint (b
);
5767 create_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
5769 struct breakpoint
*b
;
5771 b
= create_internal_breakpoint (gdbarch
, address
, bp_shlib_event
);
5772 update_global_location_list_nothrow (1);
5776 /* Disable any breakpoints that are on code in shared libraries. Only
5777 apply to enabled breakpoints, disabled ones can just stay disabled. */
5780 disable_breakpoints_in_shlibs (void)
5782 struct bp_location
*loc
, **locp_tmp
;
5784 ALL_BP_LOCATIONS (loc
, locp_tmp
)
5786 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
5787 struct breakpoint
*b
= loc
->owner
;
5789 /* We apply the check to all breakpoints, including disabled
5790 for those with loc->duplicate set. This is so that when breakpoint
5791 becomes enabled, or the duplicate is removed, gdb will try to insert
5792 all breakpoints. If we don't set shlib_disabled here, we'll try
5793 to insert those breakpoints and fail. */
5794 if (((b
->type
== bp_breakpoint
)
5795 || (b
->type
== bp_jit_event
)
5796 || (b
->type
== bp_hardware_breakpoint
)
5797 || (is_tracepoint (b
)))
5798 && loc
->pspace
== current_program_space
5799 && !loc
->shlib_disabled
5801 && PC_SOLIB (loc
->address
)
5803 && solib_name_from_address (loc
->pspace
, loc
->address
)
5807 loc
->shlib_disabled
= 1;
5812 /* Disable any breakpoints that are in in an unloaded shared library. Only
5813 apply to enabled breakpoints, disabled ones can just stay disabled. */
5816 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
5818 struct bp_location
*loc
, **locp_tmp
;
5819 int disabled_shlib_breaks
= 0;
5821 /* SunOS a.out shared libraries are always mapped, so do not
5822 disable breakpoints; they will only be reported as unloaded
5823 through clear_solib when GDB discards its shared library
5824 list. See clear_solib for more information. */
5825 if (exec_bfd
!= NULL
5826 && bfd_get_flavour (exec_bfd
) == bfd_target_aout_flavour
)
5829 ALL_BP_LOCATIONS (loc
, locp_tmp
)
5831 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
5832 struct breakpoint
*b
= loc
->owner
;
5834 if ((loc
->loc_type
== bp_loc_hardware_breakpoint
5835 || loc
->loc_type
== bp_loc_software_breakpoint
)
5836 && solib
->pspace
== loc
->pspace
5837 && !loc
->shlib_disabled
5838 && (b
->type
== bp_breakpoint
5839 || b
->type
== bp_jit_event
5840 || b
->type
== bp_hardware_breakpoint
)
5841 && solib_contains_address_p (solib
, loc
->address
))
5843 loc
->shlib_disabled
= 1;
5844 /* At this point, we cannot rely on remove_breakpoint
5845 succeeding so we must mark the breakpoint as not inserted
5846 to prevent future errors occurring in remove_breakpoints. */
5848 if (!disabled_shlib_breaks
)
5850 target_terminal_ours_for_output ();
5851 warning (_("Temporarily disabling breakpoints for unloaded shared library \"%s\""),
5854 disabled_shlib_breaks
= 1;
5859 /* FORK & VFORK catchpoints. */
5861 /* Implement the "insert" breakpoint_ops method for fork catchpoints. */
5864 insert_catch_fork (struct breakpoint
*b
)
5866 target_insert_fork_catchpoint (PIDGET (inferior_ptid
));
5869 /* Implement the "remove" breakpoint_ops method for fork catchpoints. */
5872 remove_catch_fork (struct breakpoint
*b
)
5874 return target_remove_fork_catchpoint (PIDGET (inferior_ptid
));
5877 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
5881 breakpoint_hit_catch_fork (struct breakpoint
*b
)
5883 return inferior_has_forked (inferior_ptid
, &b
->forked_inferior_pid
);
5886 /* Implement the "print_it" breakpoint_ops method for fork catchpoints. */
5888 static enum print_stop_action
5889 print_it_catch_fork (struct breakpoint
*b
)
5891 annotate_catchpoint (b
->number
);
5892 printf_filtered (_("\nCatchpoint %d (forked process %d), "),
5893 b
->number
, ptid_get_pid (b
->forked_inferior_pid
));
5894 return PRINT_SRC_AND_LOC
;
5897 /* Implement the "print_one" breakpoint_ops method for fork catchpoints. */
5900 print_one_catch_fork (struct breakpoint
*b
, struct bp_location
**last_loc
)
5902 struct value_print_options opts
;
5904 get_user_print_options (&opts
);
5906 /* Field 4, the address, is omitted (which makes the columns
5907 not line up too nicely with the headers, but the effect
5908 is relatively readable). */
5909 if (opts
.addressprint
)
5910 ui_out_field_skip (uiout
, "addr");
5912 ui_out_text (uiout
, "fork");
5913 if (!ptid_equal (b
->forked_inferior_pid
, null_ptid
))
5915 ui_out_text (uiout
, ", process ");
5916 ui_out_field_int (uiout
, "what",
5917 ptid_get_pid (b
->forked_inferior_pid
));
5918 ui_out_spaces (uiout
, 1);
5922 /* Implement the "print_mention" breakpoint_ops method for fork
5926 print_mention_catch_fork (struct breakpoint
*b
)
5928 printf_filtered (_("Catchpoint %d (fork)"), b
->number
);
5931 /* Implement the "print_recreate" breakpoint_ops method for fork
5935 print_recreate_catch_fork (struct breakpoint
*b
, struct ui_file
*fp
)
5937 fprintf_unfiltered (fp
, "catch fork");
5940 /* The breakpoint_ops structure to be used in fork catchpoints. */
5942 static struct breakpoint_ops catch_fork_breakpoint_ops
=
5946 breakpoint_hit_catch_fork
,
5947 print_it_catch_fork
,
5948 print_one_catch_fork
,
5949 print_mention_catch_fork
,
5950 print_recreate_catch_fork
5953 /* Implement the "insert" breakpoint_ops method for vfork catchpoints. */
5956 insert_catch_vfork (struct breakpoint
*b
)
5958 target_insert_vfork_catchpoint (PIDGET (inferior_ptid
));
5961 /* Implement the "remove" breakpoint_ops method for vfork catchpoints. */
5964 remove_catch_vfork (struct breakpoint
*b
)
5966 return target_remove_vfork_catchpoint (PIDGET (inferior_ptid
));
5969 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
5973 breakpoint_hit_catch_vfork (struct breakpoint
*b
)
5975 return inferior_has_vforked (inferior_ptid
, &b
->forked_inferior_pid
);
5978 /* Implement the "print_it" breakpoint_ops method for vfork catchpoints. */
5980 static enum print_stop_action
5981 print_it_catch_vfork (struct breakpoint
*b
)
5983 annotate_catchpoint (b
->number
);
5984 printf_filtered (_("\nCatchpoint %d (vforked process %d), "),
5985 b
->number
, ptid_get_pid (b
->forked_inferior_pid
));
5986 return PRINT_SRC_AND_LOC
;
5989 /* Implement the "print_one" breakpoint_ops method for vfork catchpoints. */
5992 print_one_catch_vfork (struct breakpoint
*b
, struct bp_location
**last_loc
)
5994 struct value_print_options opts
;
5996 get_user_print_options (&opts
);
5997 /* Field 4, the address, is omitted (which makes the columns
5998 not line up too nicely with the headers, but the effect
5999 is relatively readable). */
6000 if (opts
.addressprint
)
6001 ui_out_field_skip (uiout
, "addr");
6003 ui_out_text (uiout
, "vfork");
6004 if (!ptid_equal (b
->forked_inferior_pid
, null_ptid
))
6006 ui_out_text (uiout
, ", process ");
6007 ui_out_field_int (uiout
, "what",
6008 ptid_get_pid (b
->forked_inferior_pid
));
6009 ui_out_spaces (uiout
, 1);
6013 /* Implement the "print_mention" breakpoint_ops method for vfork
6017 print_mention_catch_vfork (struct breakpoint
*b
)
6019 printf_filtered (_("Catchpoint %d (vfork)"), b
->number
);
6022 /* Implement the "print_recreate" breakpoint_ops method for vfork
6026 print_recreate_catch_vfork (struct breakpoint
*b
, struct ui_file
*fp
)
6028 fprintf_unfiltered (fp
, "catch vfork");
6031 /* The breakpoint_ops structure to be used in vfork catchpoints. */
6033 static struct breakpoint_ops catch_vfork_breakpoint_ops
=
6037 breakpoint_hit_catch_vfork
,
6038 print_it_catch_vfork
,
6039 print_one_catch_vfork
,
6040 print_mention_catch_vfork
,
6041 print_recreate_catch_vfork
6044 /* Implement the "insert" breakpoint_ops method for syscall
6048 insert_catch_syscall (struct breakpoint
*b
)
6050 struct inferior
*inf
= current_inferior ();
6052 ++inf
->total_syscalls_count
;
6053 if (!b
->syscalls_to_be_caught
)
6054 ++inf
->any_syscall_count
;
6060 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
6065 if (iter
>= VEC_length (int, inf
->syscalls_counts
))
6067 int old_size
= VEC_length (int, inf
->syscalls_counts
);
6068 uintptr_t vec_addr_offset
= old_size
* ((uintptr_t) sizeof (int));
6070 VEC_safe_grow (int, inf
->syscalls_counts
, iter
+ 1);
6071 vec_addr
= (uintptr_t) VEC_address (int, inf
->syscalls_counts
) +
6073 memset ((void *) vec_addr
, 0,
6074 (iter
+ 1 - old_size
) * sizeof (int));
6076 elem
= VEC_index (int, inf
->syscalls_counts
, iter
);
6077 VEC_replace (int, inf
->syscalls_counts
, iter
, ++elem
);
6081 target_set_syscall_catchpoint (PIDGET (inferior_ptid
),
6082 inf
->total_syscalls_count
!= 0,
6083 inf
->any_syscall_count
,
6084 VEC_length (int, inf
->syscalls_counts
),
6085 VEC_address (int, inf
->syscalls_counts
));
6088 /* Implement the "remove" breakpoint_ops method for syscall
6092 remove_catch_syscall (struct breakpoint
*b
)
6094 struct inferior
*inf
= current_inferior ();
6096 --inf
->total_syscalls_count
;
6097 if (!b
->syscalls_to_be_caught
)
6098 --inf
->any_syscall_count
;
6104 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
6108 if (iter
>= VEC_length (int, inf
->syscalls_counts
))
6109 /* Shouldn't happen. */
6111 elem
= VEC_index (int, inf
->syscalls_counts
, iter
);
6112 VEC_replace (int, inf
->syscalls_counts
, iter
, --elem
);
6116 return target_set_syscall_catchpoint (PIDGET (inferior_ptid
),
6117 inf
->total_syscalls_count
!= 0,
6118 inf
->any_syscall_count
,
6119 VEC_length (int, inf
->syscalls_counts
),
6120 VEC_address (int, inf
->syscalls_counts
));
6123 /* Implement the "breakpoint_hit" breakpoint_ops method for syscall
6127 breakpoint_hit_catch_syscall (struct breakpoint
*b
)
6129 /* We must check if we are catching specific syscalls in this breakpoint.
6130 If we are, then we must guarantee that the called syscall is the same
6131 syscall we are catching. */
6132 int syscall_number
= 0;
6134 if (!inferior_has_called_syscall (inferior_ptid
, &syscall_number
))
6137 /* Now, checking if the syscall is the same. */
6138 if (b
->syscalls_to_be_caught
)
6143 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
6145 if (syscall_number
== iter
)
6155 /* Implement the "print_it" breakpoint_ops method for syscall
6158 static enum print_stop_action
6159 print_it_catch_syscall (struct breakpoint
*b
)
6161 /* These are needed because we want to know in which state a
6162 syscall is. It can be in the TARGET_WAITKIND_SYSCALL_ENTRY
6163 or TARGET_WAITKIND_SYSCALL_RETURN, and depending on it we
6164 must print "called syscall" or "returned from syscall". */
6166 struct target_waitstatus last
;
6168 struct cleanup
*old_chain
;
6171 get_last_target_status (&ptid
, &last
);
6173 get_syscall_by_number (last
.value
.syscall_number
, &s
);
6175 annotate_catchpoint (b
->number
);
6178 syscall_id
= xstrprintf ("%d", last
.value
.syscall_number
);
6180 syscall_id
= xstrprintf ("'%s'", s
.name
);
6182 old_chain
= make_cleanup (xfree
, syscall_id
);
6184 if (last
.kind
== TARGET_WAITKIND_SYSCALL_ENTRY
)
6185 printf_filtered (_("\nCatchpoint %d (call to syscall %s), "),
6186 b
->number
, syscall_id
);
6187 else if (last
.kind
== TARGET_WAITKIND_SYSCALL_RETURN
)
6188 printf_filtered (_("\nCatchpoint %d (returned from syscall %s), "),
6189 b
->number
, syscall_id
);
6191 do_cleanups (old_chain
);
6193 return PRINT_SRC_AND_LOC
;
6196 /* Implement the "print_one" breakpoint_ops method for syscall
6200 print_one_catch_syscall (struct breakpoint
*b
,
6201 struct bp_location
**last_loc
)
6203 struct value_print_options opts
;
6205 get_user_print_options (&opts
);
6206 /* Field 4, the address, is omitted (which makes the columns
6207 not line up too nicely with the headers, but the effect
6208 is relatively readable). */
6209 if (opts
.addressprint
)
6210 ui_out_field_skip (uiout
, "addr");
6213 if (b
->syscalls_to_be_caught
6214 && VEC_length (int, b
->syscalls_to_be_caught
) > 1)
6215 ui_out_text (uiout
, "syscalls \"");
6217 ui_out_text (uiout
, "syscall \"");
6219 if (b
->syscalls_to_be_caught
)
6222 char *text
= xstrprintf ("%s", "");
6225 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
6230 get_syscall_by_number (iter
, &s
);
6233 text
= xstrprintf ("%s%s, ", text
, s
.name
);
6235 text
= xstrprintf ("%s%d, ", text
, iter
);
6237 /* We have to xfree the last 'text' (now stored at 'x')
6238 because xstrprintf dinamically allocates new space for it
6242 /* Remove the last comma. */
6243 text
[strlen (text
) - 2] = '\0';
6244 ui_out_field_string (uiout
, "what", text
);
6247 ui_out_field_string (uiout
, "what", "<any syscall>");
6248 ui_out_text (uiout
, "\" ");
6251 /* Implement the "print_mention" breakpoint_ops method for syscall
6255 print_mention_catch_syscall (struct breakpoint
*b
)
6257 if (b
->syscalls_to_be_caught
)
6261 if (VEC_length (int, b
->syscalls_to_be_caught
) > 1)
6262 printf_filtered (_("Catchpoint %d (syscalls"), b
->number
);
6264 printf_filtered (_("Catchpoint %d (syscall"), b
->number
);
6267 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
6271 get_syscall_by_number (iter
, &s
);
6274 printf_filtered (" '%s' [%d]", s
.name
, s
.number
);
6276 printf_filtered (" %d", s
.number
);
6278 printf_filtered (")");
6281 printf_filtered (_("Catchpoint %d (any syscall)"),
6285 /* Implement the "print_recreate" breakpoint_ops method for syscall
6289 print_recreate_catch_syscall (struct breakpoint
*b
, struct ui_file
*fp
)
6291 fprintf_unfiltered (fp
, "catch syscall");
6293 if (b
->syscalls_to_be_caught
)
6298 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
6303 get_syscall_by_number (iter
, &s
);
6305 fprintf_unfiltered (fp
, " %s", s
.name
);
6307 fprintf_unfiltered (fp
, " %d", s
.number
);
6312 /* The breakpoint_ops structure to be used in syscall catchpoints. */
6314 static struct breakpoint_ops catch_syscall_breakpoint_ops
=
6316 insert_catch_syscall
,
6317 remove_catch_syscall
,
6318 breakpoint_hit_catch_syscall
,
6319 print_it_catch_syscall
,
6320 print_one_catch_syscall
,
6321 print_mention_catch_syscall
,
6322 print_recreate_catch_syscall
6325 /* Returns non-zero if 'b' is a syscall catchpoint. */
6328 syscall_catchpoint_p (struct breakpoint
*b
)
6330 return (b
->ops
== &catch_syscall_breakpoint_ops
);
6333 /* Create a new breakpoint of the bp_catchpoint kind and return it,
6334 but does NOT mention it nor update the global location list.
6335 This is useful if you need to fill more fields in the
6336 struct breakpoint before calling mention.
6338 If TEMPFLAG is non-zero, then make the breakpoint temporary.
6339 If COND_STRING is not NULL, then store it in the breakpoint.
6340 OPS, if not NULL, is the breakpoint_ops structure associated
6341 to the catchpoint. */
6343 static struct breakpoint
*
6344 create_catchpoint_without_mention (struct gdbarch
*gdbarch
, int tempflag
,
6346 struct breakpoint_ops
*ops
)
6348 struct symtab_and_line sal
;
6349 struct breakpoint
*b
;
6352 sal
.pspace
= current_program_space
;
6354 b
= set_raw_breakpoint (gdbarch
, sal
, bp_catchpoint
);
6355 set_breakpoint_count (breakpoint_count
+ 1);
6356 b
->number
= breakpoint_count
;
6358 b
->cond_string
= (cond_string
== NULL
) ? NULL
: xstrdup (cond_string
);
6360 b
->addr_string
= NULL
;
6361 b
->enable_state
= bp_enabled
;
6362 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6368 /* Create a new breakpoint of the bp_catchpoint kind and return it.
6370 If TEMPFLAG is non-zero, then make the breakpoint temporary.
6371 If COND_STRING is not NULL, then store it in the breakpoint.
6372 OPS, if not NULL, is the breakpoint_ops structure associated
6373 to the catchpoint. */
6375 static struct breakpoint
*
6376 create_catchpoint (struct gdbarch
*gdbarch
, int tempflag
,
6377 char *cond_string
, struct breakpoint_ops
*ops
)
6379 struct breakpoint
*b
=
6380 create_catchpoint_without_mention (gdbarch
, tempflag
, cond_string
, ops
);
6383 update_global_location_list (1);
6389 create_fork_vfork_event_catchpoint (struct gdbarch
*gdbarch
,
6390 int tempflag
, char *cond_string
,
6391 struct breakpoint_ops
*ops
)
6393 struct breakpoint
*b
6394 = create_catchpoint (gdbarch
, tempflag
, cond_string
, ops
);
6396 /* FIXME: We should put this information in a breakpoint private data
6398 b
->forked_inferior_pid
= null_ptid
;
6401 /* Exec catchpoints. */
6404 insert_catch_exec (struct breakpoint
*b
)
6406 target_insert_exec_catchpoint (PIDGET (inferior_ptid
));
6410 remove_catch_exec (struct breakpoint
*b
)
6412 return target_remove_exec_catchpoint (PIDGET (inferior_ptid
));
6416 breakpoint_hit_catch_exec (struct breakpoint
*b
)
6418 return inferior_has_execd (inferior_ptid
, &b
->exec_pathname
);
6421 static enum print_stop_action
6422 print_it_catch_exec (struct breakpoint
*b
)
6424 annotate_catchpoint (b
->number
);
6425 printf_filtered (_("\nCatchpoint %d (exec'd %s), "), b
->number
,
6427 return PRINT_SRC_AND_LOC
;
6431 print_one_catch_exec (struct breakpoint
*b
, struct bp_location
**last_loc
)
6433 struct value_print_options opts
;
6435 get_user_print_options (&opts
);
6437 /* Field 4, the address, is omitted (which makes the columns
6438 not line up too nicely with the headers, but the effect
6439 is relatively readable). */
6440 if (opts
.addressprint
)
6441 ui_out_field_skip (uiout
, "addr");
6443 ui_out_text (uiout
, "exec");
6444 if (b
->exec_pathname
!= NULL
)
6446 ui_out_text (uiout
, ", program \"");
6447 ui_out_field_string (uiout
, "what", b
->exec_pathname
);
6448 ui_out_text (uiout
, "\" ");
6453 print_mention_catch_exec (struct breakpoint
*b
)
6455 printf_filtered (_("Catchpoint %d (exec)"), b
->number
);
6458 /* Implement the "print_recreate" breakpoint_ops method for exec
6462 print_recreate_catch_exec (struct breakpoint
*b
, struct ui_file
*fp
)
6464 fprintf_unfiltered (fp
, "catch exec");
6467 static struct breakpoint_ops catch_exec_breakpoint_ops
=
6471 breakpoint_hit_catch_exec
,
6472 print_it_catch_exec
,
6473 print_one_catch_exec
,
6474 print_mention_catch_exec
,
6475 print_recreate_catch_exec
6479 create_syscall_event_catchpoint (int tempflag
, VEC(int) *filter
,
6480 struct breakpoint_ops
*ops
)
6482 struct gdbarch
*gdbarch
= get_current_arch ();
6483 struct breakpoint
*b
=
6484 create_catchpoint_without_mention (gdbarch
, tempflag
, NULL
, ops
);
6486 b
->syscalls_to_be_caught
= filter
;
6488 /* Now, we have to mention the breakpoint and update the global
6491 update_global_location_list (1);
6495 hw_breakpoint_used_count (void)
6497 struct breakpoint
*b
;
6502 if (b
->type
== bp_hardware_breakpoint
&& breakpoint_enabled (b
))
6510 hw_watchpoint_used_count (enum bptype type
, int *other_type_used
)
6512 struct breakpoint
*b
;
6515 *other_type_used
= 0;
6518 if (breakpoint_enabled (b
))
6520 if (b
->type
== type
)
6522 else if (is_hardware_watchpoint (b
))
6523 *other_type_used
= 1;
6530 disable_watchpoints_before_interactive_call_start (void)
6532 struct breakpoint
*b
;
6536 if (is_watchpoint (b
) && breakpoint_enabled (b
))
6538 b
->enable_state
= bp_call_disabled
;
6539 update_global_location_list (0);
6545 enable_watchpoints_after_interactive_call_stop (void)
6547 struct breakpoint
*b
;
6551 if (is_watchpoint (b
) && b
->enable_state
== bp_call_disabled
)
6553 b
->enable_state
= bp_enabled
;
6554 update_global_location_list (1);
6560 disable_breakpoints_before_startup (void)
6562 struct breakpoint
*b
;
6567 if (b
->pspace
!= current_program_space
)
6570 if ((b
->type
== bp_breakpoint
6571 || b
->type
== bp_hardware_breakpoint
)
6572 && breakpoint_enabled (b
))
6574 b
->enable_state
= bp_startup_disabled
;
6580 update_global_location_list (0);
6582 current_program_space
->executing_startup
= 1;
6586 enable_breakpoints_after_startup (void)
6588 struct breakpoint
*b
;
6591 current_program_space
->executing_startup
= 0;
6595 if (b
->pspace
!= current_program_space
)
6598 if ((b
->type
== bp_breakpoint
6599 || b
->type
== bp_hardware_breakpoint
)
6600 && b
->enable_state
== bp_startup_disabled
)
6602 b
->enable_state
= bp_enabled
;
6608 breakpoint_re_set ();
6612 /* Set a breakpoint that will evaporate an end of command
6613 at address specified by SAL.
6614 Restrict it to frame FRAME if FRAME is nonzero. */
6617 set_momentary_breakpoint (struct gdbarch
*gdbarch
, struct symtab_and_line sal
,
6618 struct frame_id frame_id
, enum bptype type
)
6620 struct breakpoint
*b
;
6622 /* If FRAME_ID is valid, it should be a real frame, not an inlined
6624 gdb_assert (!frame_id_inlined_p (frame_id
));
6626 b
= set_raw_breakpoint (gdbarch
, sal
, type
);
6627 b
->enable_state
= bp_enabled
;
6628 b
->disposition
= disp_donttouch
;
6629 b
->frame_id
= frame_id
;
6631 /* If we're debugging a multi-threaded program, then we
6632 want momentary breakpoints to be active in only a
6633 single thread of control. */
6634 if (in_thread_list (inferior_ptid
))
6635 b
->thread
= pid_to_thread_id (inferior_ptid
);
6637 update_global_location_list_nothrow (1);
6642 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
6646 clone_momentary_breakpoint (struct breakpoint
*orig
)
6648 struct breakpoint
*copy
;
6650 /* If there's nothing to clone, then return nothing. */
6654 copy
= set_raw_breakpoint_without_location (orig
->gdbarch
, orig
->type
);
6655 copy
->loc
= allocate_bp_location (copy
);
6656 set_breakpoint_location_function (copy
->loc
);
6658 copy
->loc
->gdbarch
= orig
->loc
->gdbarch
;
6659 copy
->loc
->requested_address
= orig
->loc
->requested_address
;
6660 copy
->loc
->address
= orig
->loc
->address
;
6661 copy
->loc
->section
= orig
->loc
->section
;
6662 copy
->loc
->pspace
= orig
->loc
->pspace
;
6664 if (orig
->source_file
== NULL
)
6665 copy
->source_file
= NULL
;
6667 copy
->source_file
= xstrdup (orig
->source_file
);
6669 copy
->line_number
= orig
->line_number
;
6670 copy
->frame_id
= orig
->frame_id
;
6671 copy
->thread
= orig
->thread
;
6672 copy
->pspace
= orig
->pspace
;
6674 copy
->enable_state
= bp_enabled
;
6675 copy
->disposition
= disp_donttouch
;
6676 copy
->number
= internal_breakpoint_number
--;
6678 update_global_location_list_nothrow (0);
6683 set_momentary_breakpoint_at_pc (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
6686 struct symtab_and_line sal
;
6688 sal
= find_pc_line (pc
, 0);
6690 sal
.section
= find_pc_overlay (pc
);
6691 sal
.explicit_pc
= 1;
6693 return set_momentary_breakpoint (gdbarch
, sal
, null_frame_id
, type
);
6697 /* Tell the user we have just set a breakpoint B. */
6700 mention (struct breakpoint
*b
)
6703 struct cleanup
*ui_out_chain
;
6704 struct value_print_options opts
;
6706 get_user_print_options (&opts
);
6708 /* FIXME: This is misplaced; mention() is called by things (like
6709 hitting a watchpoint) other than breakpoint creation. It should
6710 be possible to clean this up and at the same time replace the
6711 random calls to breakpoint_changed with this hook. */
6712 observer_notify_breakpoint_created (b
->number
);
6714 if (b
->ops
!= NULL
&& b
->ops
->print_mention
!= NULL
)
6715 b
->ops
->print_mention (b
);
6720 printf_filtered (_("(apparently deleted?) Eventpoint %d: "), b
->number
);
6723 ui_out_text (uiout
, "Watchpoint ");
6724 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
6725 ui_out_field_int (uiout
, "number", b
->number
);
6726 ui_out_text (uiout
, ": ");
6727 ui_out_field_string (uiout
, "exp", b
->exp_string
);
6728 do_cleanups (ui_out_chain
);
6730 case bp_hardware_watchpoint
:
6731 ui_out_text (uiout
, "Hardware watchpoint ");
6732 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
6733 ui_out_field_int (uiout
, "number", b
->number
);
6734 ui_out_text (uiout
, ": ");
6735 ui_out_field_string (uiout
, "exp", b
->exp_string
);
6736 do_cleanups (ui_out_chain
);
6738 case bp_read_watchpoint
:
6739 ui_out_text (uiout
, "Hardware read watchpoint ");
6740 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
6741 ui_out_field_int (uiout
, "number", b
->number
);
6742 ui_out_text (uiout
, ": ");
6743 ui_out_field_string (uiout
, "exp", b
->exp_string
);
6744 do_cleanups (ui_out_chain
);
6746 case bp_access_watchpoint
:
6747 ui_out_text (uiout
, "Hardware access (read/write) watchpoint ");
6748 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
6749 ui_out_field_int (uiout
, "number", b
->number
);
6750 ui_out_text (uiout
, ": ");
6751 ui_out_field_string (uiout
, "exp", b
->exp_string
);
6752 do_cleanups (ui_out_chain
);
6755 if (ui_out_is_mi_like_p (uiout
))
6760 if (b
->disposition
== disp_del
)
6761 printf_filtered (_("Temporary breakpoint"));
6763 printf_filtered (_("Breakpoint"));
6764 printf_filtered (_(" %d"), b
->number
);
6767 case bp_hardware_breakpoint
:
6768 if (ui_out_is_mi_like_p (uiout
))
6773 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
6777 if (ui_out_is_mi_like_p (uiout
))
6782 printf_filtered (_("Tracepoint"));
6783 printf_filtered (_(" %d"), b
->number
);
6786 case bp_fast_tracepoint
:
6787 if (ui_out_is_mi_like_p (uiout
))
6792 printf_filtered (_("Fast tracepoint"));
6793 printf_filtered (_(" %d"), b
->number
);
6800 case bp_longjmp_resume
:
6801 case bp_step_resume
:
6803 case bp_std_terminate
:
6804 case bp_watchpoint_scope
:
6805 case bp_shlib_event
:
6806 case bp_thread_event
:
6807 case bp_overlay_event
:
6809 case bp_longjmp_master
:
6810 case bp_std_terminate_master
:
6816 /* i18n: cagney/2005-02-11: Below needs to be merged into a
6820 printf_filtered (_(" (%s) pending."), b
->addr_string
);
6824 if (opts
.addressprint
|| b
->source_file
== NULL
)
6826 printf_filtered (" at ");
6827 fputs_filtered (paddress (b
->loc
->gdbarch
, b
->loc
->address
),
6831 printf_filtered (": file %s, line %d.",
6832 b
->source_file
, b
->line_number
);
6836 struct bp_location
*loc
= b
->loc
;
6838 for (; loc
; loc
= loc
->next
)
6840 printf_filtered (" (%d locations)", n
);
6845 if (ui_out_is_mi_like_p (uiout
))
6847 printf_filtered ("\n");
6851 static struct bp_location
*
6852 add_location_to_breakpoint (struct breakpoint
*b
,
6853 const struct symtab_and_line
*sal
)
6855 struct bp_location
*loc
, **tmp
;
6857 loc
= allocate_bp_location (b
);
6858 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
6861 loc
->gdbarch
= get_sal_arch (*sal
);
6863 loc
->gdbarch
= b
->gdbarch
;
6864 loc
->requested_address
= sal
->pc
;
6865 loc
->address
= adjust_breakpoint_address (loc
->gdbarch
,
6866 loc
->requested_address
, b
->type
);
6867 loc
->pspace
= sal
->pspace
;
6868 gdb_assert (loc
->pspace
!= NULL
);
6869 loc
->section
= sal
->section
;
6871 set_breakpoint_location_function (loc
);
6876 /* Return 1 if LOC is pointing to a permanent breakpoint,
6877 return 0 otherwise. */
6880 bp_loc_is_permanent (struct bp_location
*loc
)
6884 const gdb_byte
*brk
;
6885 gdb_byte
*target_mem
;
6886 struct cleanup
*cleanup
;
6889 gdb_assert (loc
!= NULL
);
6891 addr
= loc
->address
;
6892 brk
= gdbarch_breakpoint_from_pc (loc
->gdbarch
, &addr
, &len
);
6894 /* Software breakpoints unsupported? */
6898 target_mem
= alloca (len
);
6900 /* Enable the automatic memory restoration from breakpoints while
6901 we read the memory. Otherwise we could say about our temporary
6902 breakpoints they are permanent. */
6903 cleanup
= save_current_space_and_thread ();
6905 switch_to_program_space_and_thread (loc
->pspace
);
6906 make_show_memory_breakpoints_cleanup (0);
6908 if (target_read_memory (loc
->address
, target_mem
, len
) == 0
6909 && memcmp (target_mem
, brk
, len
) == 0)
6912 do_cleanups (cleanup
);
6919 /* Create a breakpoint with SAL as location. Use ADDR_STRING
6920 as textual description of the location, and COND_STRING
6921 as condition expression. */
6924 create_breakpoint_sal (struct gdbarch
*gdbarch
,
6925 struct symtabs_and_lines sals
, char *addr_string
,
6927 enum bptype type
, enum bpdisp disposition
,
6928 int thread
, int task
, int ignore_count
,
6929 struct breakpoint_ops
*ops
, int from_tty
, int enabled
)
6931 struct breakpoint
*b
= NULL
;
6934 if (type
== bp_hardware_breakpoint
)
6936 int i
= hw_breakpoint_used_count ();
6937 int target_resources_ok
=
6938 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
6940 if (target_resources_ok
== 0)
6941 error (_("No hardware breakpoint support in the target."));
6942 else if (target_resources_ok
< 0)
6943 error (_("Hardware breakpoints used exceeds limit."));
6946 gdb_assert (sals
.nelts
> 0);
6948 for (i
= 0; i
< sals
.nelts
; ++i
)
6950 struct symtab_and_line sal
= sals
.sals
[i
];
6951 struct bp_location
*loc
;
6955 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
6957 loc_gdbarch
= gdbarch
;
6959 describe_other_breakpoints (loc_gdbarch
,
6960 sal
.pspace
, sal
.pc
, sal
.section
, thread
);
6965 b
= set_raw_breakpoint (gdbarch
, sal
, type
);
6966 set_breakpoint_count (breakpoint_count
+ 1);
6967 b
->number
= breakpoint_count
;
6971 b
->cond_string
= cond_string
;
6972 b
->ignore_count
= ignore_count
;
6973 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
6974 b
->disposition
= disposition
;
6976 b
->pspace
= sals
.sals
[0].pspace
;
6978 if (enabled
&& b
->pspace
->executing_startup
6979 && (b
->type
== bp_breakpoint
6980 || b
->type
== bp_hardware_breakpoint
))
6981 b
->enable_state
= bp_startup_disabled
;
6987 loc
= add_location_to_breakpoint (b
, &sal
);
6990 if (bp_loc_is_permanent (loc
))
6991 make_breakpoint_permanent (b
);
6995 char *arg
= b
->cond_string
;
6996 loc
->cond
= parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
6998 error (_("Garbage %s follows condition"), arg
);
7003 b
->addr_string
= addr_string
;
7005 /* addr_string has to be used or breakpoint_re_set will delete
7008 = xstrprintf ("*%s", paddress (b
->loc
->gdbarch
, b
->loc
->address
));
7014 /* Remove element at INDEX_TO_REMOVE from SAL, shifting other
7015 elements to fill the void space. */
7017 remove_sal (struct symtabs_and_lines
*sal
, int index_to_remove
)
7019 int i
= index_to_remove
+1;
7020 int last_index
= sal
->nelts
-1;
7022 for (;i
<= last_index
; ++i
)
7023 sal
->sals
[i
-1] = sal
->sals
[i
];
7028 /* If appropriate, obtains all sals that correspond to the same file
7029 and line as SAL, in all program spaces. Users debugging with IDEs,
7030 will want to set a breakpoint at foo.c:line, and not really care
7031 about program spaces. This is done only if SAL does not have
7032 explicit PC and has line and file information. If we got just a
7033 single expanded sal, return the original.
7035 Otherwise, if SAL.explicit_line is not set, filter out all sals for
7036 which the name of enclosing function is different from SAL. This
7037 makes sure that if we have breakpoint originally set in template
7038 instantiation, say foo<int>(), we won't expand SAL to locations at
7039 the same line in all existing instantiations of 'foo'. */
7041 static struct symtabs_and_lines
7042 expand_line_sal_maybe (struct symtab_and_line sal
)
7044 struct symtabs_and_lines expanded
;
7045 CORE_ADDR original_pc
= sal
.pc
;
7046 char *original_function
= NULL
;
7049 struct cleanup
*old_chain
;
7051 /* If we have explicit pc, don't expand.
7052 If we have no line number, we can't expand. */
7053 if (sal
.explicit_pc
|| sal
.line
== 0 || sal
.symtab
== NULL
)
7056 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
7057 expanded
.sals
[0] = sal
;
7063 old_chain
= save_current_space_and_thread ();
7065 switch_to_program_space_and_thread (sal
.pspace
);
7067 find_pc_partial_function (original_pc
, &original_function
, NULL
, NULL
);
7069 /* Note that expand_line_sal visits *all* program spaces. */
7070 expanded
= expand_line_sal (sal
);
7072 if (expanded
.nelts
== 1)
7074 /* We had one sal, we got one sal. Return that sal, adjusting it
7075 past the function prologue if necessary. */
7076 xfree (expanded
.sals
);
7078 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
7079 sal
.pc
= original_pc
;
7080 expanded
.sals
[0] = sal
;
7081 skip_prologue_sal (&expanded
.sals
[0]);
7082 do_cleanups (old_chain
);
7086 if (!sal
.explicit_line
)
7088 CORE_ADDR func_addr
, func_end
;
7089 for (i
= 0; i
< expanded
.nelts
; ++i
)
7091 CORE_ADDR pc
= expanded
.sals
[i
].pc
;
7092 char *this_function
;
7094 /* We need to switch threads as well since we're about to
7096 switch_to_program_space_and_thread (expanded
.sals
[i
].pspace
);
7098 if (find_pc_partial_function (pc
, &this_function
,
7099 &func_addr
, &func_end
))
7102 && strcmp (this_function
, original_function
) != 0)
7104 remove_sal (&expanded
, i
);
7111 /* Skip the function prologue if necessary. */
7112 for (i
= 0; i
< expanded
.nelts
; ++i
)
7113 skip_prologue_sal (&expanded
.sals
[i
]);
7115 do_cleanups (old_chain
);
7117 if (expanded
.nelts
<= 1)
7119 /* This is un ugly workaround. If we get zero
7120 expanded sals then something is really wrong.
7121 Fix that by returnign the original sal. */
7122 xfree (expanded
.sals
);
7124 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
7125 sal
.pc
= original_pc
;
7126 expanded
.sals
[0] = sal
;
7133 for (i
= 0; i
< expanded
.nelts
; ++i
)
7134 if (expanded
.sals
[i
].pc
== original_pc
)
7145 /* Add SALS.nelts breakpoints to the breakpoint table. For each
7146 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
7147 value. COND_STRING, if not NULL, specified the condition to be
7148 used for all breakpoints. Essentially the only case where
7149 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
7150 function. In that case, it's still not possible to specify
7151 separate conditions for different overloaded functions, so
7152 we take just a single condition string.
7154 NOTE: If the function succeeds, the caller is expected to cleanup
7155 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
7156 array contents). If the function fails (error() is called), the
7157 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
7158 COND and SALS arrays and each of those arrays contents. */
7161 create_breakpoints_sal (struct gdbarch
*gdbarch
,
7162 struct symtabs_and_lines sals
, char **addr_string
,
7164 enum bptype type
, enum bpdisp disposition
,
7165 int thread
, int task
, int ignore_count
,
7166 struct breakpoint_ops
*ops
, int from_tty
,
7171 for (i
= 0; i
< sals
.nelts
; ++i
)
7173 struct symtabs_and_lines expanded
=
7174 expand_line_sal_maybe (sals
.sals
[i
]);
7176 create_breakpoint_sal (gdbarch
, expanded
, addr_string
[i
],
7177 cond_string
, type
, disposition
,
7178 thread
, task
, ignore_count
, ops
, from_tty
, enabled
);
7182 /* Parse ARG which is assumed to be a SAL specification possibly
7183 followed by conditionals. On return, SALS contains an array of SAL
7184 addresses found. ADDR_STRING contains a vector of (canonical)
7185 address strings. ARG points to the end of the SAL. */
7188 parse_breakpoint_sals (char **address
,
7189 struct symtabs_and_lines
*sals
,
7190 char ***addr_string
,
7193 char *addr_start
= *address
;
7195 *addr_string
= NULL
;
7196 /* If no arg given, or if first arg is 'if ', use the default
7198 if ((*address
) == NULL
7199 || (strncmp ((*address
), "if", 2) == 0 && isspace ((*address
)[2])))
7201 if (default_breakpoint_valid
)
7203 struct symtab_and_line sal
;
7205 init_sal (&sal
); /* initialize to zeroes */
7206 sals
->sals
= (struct symtab_and_line
*)
7207 xmalloc (sizeof (struct symtab_and_line
));
7208 sal
.pc
= default_breakpoint_address
;
7209 sal
.line
= default_breakpoint_line
;
7210 sal
.symtab
= default_breakpoint_symtab
;
7211 sal
.pspace
= default_breakpoint_pspace
;
7212 sal
.section
= find_pc_overlay (sal
.pc
);
7214 /* "break" without arguments is equivalent to "break *PC" where PC is
7215 the default_breakpoint_address. So make sure to set
7216 sal.explicit_pc to prevent GDB from trying to expand the list of
7217 sals to include all other instances with the same symtab and line.
7219 sal
.explicit_pc
= 1;
7221 sals
->sals
[0] = sal
;
7225 error (_("No default breakpoint address now."));
7229 /* Force almost all breakpoints to be in terms of the
7230 current_source_symtab (which is decode_line_1's default). This
7231 should produce the results we want almost all of the time while
7232 leaving default_breakpoint_* alone.
7233 ObjC: However, don't match an Objective-C method name which
7234 may have a '+' or '-' succeeded by a '[' */
7236 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
7238 if (default_breakpoint_valid
7240 || ((strchr ("+-", (*address
)[0]) != NULL
)
7241 && ((*address
)[1] != '['))))
7242 *sals
= decode_line_1 (address
, 1, default_breakpoint_symtab
,
7243 default_breakpoint_line
, addr_string
,
7246 *sals
= decode_line_1 (address
, 1, (struct symtab
*) NULL
, 0,
7247 addr_string
, not_found_ptr
);
7249 /* For any SAL that didn't have a canonical string, fill one in. */
7250 if (sals
->nelts
> 0 && *addr_string
== NULL
)
7251 *addr_string
= xcalloc (sals
->nelts
, sizeof (char **));
7252 if (addr_start
!= (*address
))
7256 for (i
= 0; i
< sals
->nelts
; i
++)
7258 /* Add the string if not present. */
7259 if ((*addr_string
)[i
] == NULL
)
7260 (*addr_string
)[i
] = savestring (addr_start
,
7261 (*address
) - addr_start
);
7267 /* Convert each SAL into a real PC. Verify that the PC can be
7268 inserted as a breakpoint. If it can't throw an error. */
7271 breakpoint_sals_to_pc (struct symtabs_and_lines
*sals
,
7276 for (i
= 0; i
< sals
->nelts
; i
++)
7277 resolve_sal_pc (&sals
->sals
[i
]);
7280 /* Fast tracepoints may have restrictions on valid locations. For
7281 instance, a fast tracepoint using a jump instead of a trap will
7282 likely have to overwrite more bytes than a trap would, and so can
7283 only be placed where the instruction is longer than the jump, or a
7284 multi-instruction sequence does not have a jump into the middle of
7288 check_fast_tracepoint_sals (struct gdbarch
*gdbarch
,
7289 struct symtabs_and_lines
*sals
)
7292 struct symtab_and_line
*sal
;
7294 struct cleanup
*old_chain
;
7296 for (i
= 0; i
< sals
->nelts
; i
++)
7298 sal
= &sals
->sals
[i
];
7300 rslt
= gdbarch_fast_tracepoint_valid_at (gdbarch
, sal
->pc
,
7302 old_chain
= make_cleanup (xfree
, msg
);
7305 error (_("May not have a fast tracepoint at 0x%s%s"),
7306 paddress (gdbarch
, sal
->pc
), (msg
? msg
: ""));
7308 do_cleanups (old_chain
);
7313 do_captured_parse_breakpoint (struct ui_out
*ui
, void *data
)
7315 struct captured_parse_breakpoint_args
*args
= data
;
7317 parse_breakpoint_sals (args
->arg_p
, args
->sals_p
, args
->addr_string_p
,
7318 args
->not_found_ptr
);
7321 /* Given TOK, a string specification of condition and thread, as
7322 accepted by the 'break' command, extract the condition
7323 string and thread number and set *COND_STRING and *THREAD.
7324 PC identifies the context at which the condition should be parsed.
7325 If no condition is found, *COND_STRING is set to NULL.
7326 If no thread is found, *THREAD is set to -1. */
7328 find_condition_and_thread (char *tok
, CORE_ADDR pc
,
7329 char **cond_string
, int *thread
, int *task
)
7331 *cond_string
= NULL
;
7337 char *cond_start
= NULL
;
7338 char *cond_end
= NULL
;
7340 while (*tok
== ' ' || *tok
== '\t')
7345 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
7348 toklen
= end_tok
- tok
;
7350 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
7352 struct expression
*expr
;
7354 tok
= cond_start
= end_tok
+ 1;
7355 expr
= parse_exp_1 (&tok
, block_for_pc (pc
), 0);
7358 *cond_string
= savestring (cond_start
,
7359 cond_end
- cond_start
);
7361 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
7367 *thread
= strtol (tok
, &tok
, 0);
7369 error (_("Junk after thread keyword."));
7370 if (!valid_thread_id (*thread
))
7371 error (_("Unknown thread %d."), *thread
);
7373 else if (toklen
>= 1 && strncmp (tok
, "task", toklen
) == 0)
7379 *task
= strtol (tok
, &tok
, 0);
7381 error (_("Junk after task keyword."));
7382 if (!valid_task_id (*task
))
7383 error (_("Unknown task %d."), *task
);
7386 error (_("Junk at end of arguments."));
7390 /* Set a breakpoint. This function is shared between CLI and MI
7391 functions for setting a breakpoint. This function has two major
7392 modes of operations, selected by the PARSE_CONDITION_AND_THREAD
7393 parameter. If non-zero, the function will parse arg, extracting
7394 breakpoint location, address and thread. Otherwise, ARG is just the
7395 location of breakpoint, with condition and thread specified by the
7396 COND_STRING and THREAD parameters. Returns true if any breakpoint
7397 was created; false otherwise. */
7400 create_breakpoint (struct gdbarch
*gdbarch
,
7401 char *arg
, char *cond_string
, int thread
,
7402 int parse_condition_and_thread
,
7403 int tempflag
, int hardwareflag
, int traceflag
,
7405 enum auto_boolean pending_break_support
,
7406 struct breakpoint_ops
*ops
,
7410 struct gdb_exception e
;
7411 struct symtabs_and_lines sals
;
7412 struct symtab_and_line pending_sal
;
7414 char *addr_start
= arg
;
7416 struct cleanup
*old_chain
;
7417 struct cleanup
*bkpt_chain
= NULL
;
7418 struct captured_parse_breakpoint_args parse_args
;
7422 enum bptype type_wanted
;
7424 int prev_bkpt_count
= breakpoint_count
;
7430 parse_args
.arg_p
= &arg
;
7431 parse_args
.sals_p
= &sals
;
7432 parse_args
.addr_string_p
= &addr_string
;
7433 parse_args
.not_found_ptr
= ¬_found
;
7435 e
= catch_exception (uiout
, do_captured_parse_breakpoint
,
7436 &parse_args
, RETURN_MASK_ALL
);
7438 /* If caller is interested in rc value from parse, set value. */
7442 throw_exception (e
);
7446 case NOT_FOUND_ERROR
:
7448 /* If pending breakpoint support is turned off, throw
7451 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
7452 throw_exception (e
);
7454 exception_print (gdb_stderr
, e
);
7456 /* If pending breakpoint support is auto query and the user
7457 selects no, then simply return the error code. */
7458 if (pending_break_support
== AUTO_BOOLEAN_AUTO
7459 && !nquery ("Make breakpoint pending on future shared library load? "))
7462 /* At this point, either the user was queried about setting
7463 a pending breakpoint and selected yes, or pending
7464 breakpoint behavior is on and thus a pending breakpoint
7465 is defaulted on behalf of the user. */
7466 copy_arg
= xstrdup (addr_start
);
7467 addr_string
= ©_arg
;
7469 sals
.sals
= &pending_sal
;
7474 throw_exception (e
);
7481 /* Create a chain of things that always need to be cleaned up. */
7482 old_chain
= make_cleanup (null_cleanup
, 0);
7486 /* Make sure that all storage allocated to SALS gets freed. */
7487 make_cleanup (xfree
, sals
.sals
);
7489 /* Cleanup the addr_string array but not its contents. */
7490 make_cleanup (xfree
, addr_string
);
7493 /* ----------------------------- SNIP -----------------------------
7494 Anything added to the cleanup chain beyond this point is assumed
7495 to be part of a breakpoint. If the breakpoint create succeeds
7496 then the memory is not reclaimed. */
7497 bkpt_chain
= make_cleanup (null_cleanup
, 0);
7499 /* Mark the contents of the addr_string for cleanup. These go on
7500 the bkpt_chain and only occur if the breakpoint create fails. */
7501 for (i
= 0; i
< sals
.nelts
; i
++)
7503 if (addr_string
[i
] != NULL
)
7504 make_cleanup (xfree
, addr_string
[i
]);
7507 /* Resolve all line numbers to PC's and verify that the addresses
7508 are ok for the target. */
7510 breakpoint_sals_to_pc (&sals
, addr_start
);
7512 type_wanted
= (traceflag
7513 ? (hardwareflag
? bp_fast_tracepoint
: bp_tracepoint
)
7514 : (hardwareflag
? bp_hardware_breakpoint
: bp_breakpoint
));
7516 /* Fast tracepoints may have additional restrictions on location. */
7517 if (type_wanted
== bp_fast_tracepoint
)
7518 check_fast_tracepoint_sals (gdbarch
, &sals
);
7520 /* Verify that condition can be parsed, before setting any
7521 breakpoints. Allocate a separate condition expression for each
7525 if (parse_condition_and_thread
)
7527 /* Here we only parse 'arg' to separate condition
7528 from thread number, so parsing in context of first
7529 sal is OK. When setting the breakpoint we'll
7530 re-parse it in context of each sal. */
7533 find_condition_and_thread (arg
, sals
.sals
[0].pc
, &cond_string
,
7536 make_cleanup (xfree
, cond_string
);
7540 /* Create a private copy of condition string. */
7543 cond_string
= xstrdup (cond_string
);
7544 make_cleanup (xfree
, cond_string
);
7547 create_breakpoints_sal (gdbarch
, sals
, addr_string
, cond_string
,
7548 type_wanted
, tempflag
? disp_del
: disp_donttouch
,
7549 thread
, task
, ignore_count
, ops
, from_tty
,
7554 struct breakpoint
*b
;
7556 make_cleanup (xfree
, copy_arg
);
7558 b
= set_raw_breakpoint_without_location (gdbarch
, type_wanted
);
7559 set_breakpoint_count (breakpoint_count
+ 1);
7560 b
->number
= breakpoint_count
;
7562 b
->addr_string
= addr_string
[0];
7563 b
->cond_string
= NULL
;
7564 b
->ignore_count
= ignore_count
;
7565 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
7566 b
->condition_not_parsed
= 1;
7568 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
7569 b
->pspace
= current_program_space
;
7571 if (enabled
&& b
->pspace
->executing_startup
7572 && (b
->type
== bp_breakpoint
7573 || b
->type
== bp_hardware_breakpoint
))
7574 b
->enable_state
= bp_startup_disabled
;
7581 warning (_("Multiple breakpoints were set.\n"
7582 "Use the \"delete\" command to delete unwanted breakpoints."));
7583 prev_breakpoint_count
= prev_bkpt_count
;
7586 /* That's it. Discard the cleanups for data inserted into the
7588 discard_cleanups (bkpt_chain
);
7589 /* But cleanup everything else. */
7590 do_cleanups (old_chain
);
7592 /* error call may happen here - have BKPT_CHAIN already discarded. */
7593 update_global_location_list (1);
7598 /* Set a breakpoint.
7599 ARG is a string describing breakpoint address,
7600 condition, and thread.
7601 FLAG specifies if a breakpoint is hardware on,
7602 and if breakpoint is temporary, using BP_HARDWARE_FLAG
7606 break_command_1 (char *arg
, int flag
, int from_tty
)
7608 int hardwareflag
= flag
& BP_HARDWAREFLAG
;
7609 int tempflag
= flag
& BP_TEMPFLAG
;
7611 create_breakpoint (get_current_arch (),
7613 NULL
, 0, 1 /* parse arg */,
7614 tempflag
, hardwareflag
, 0 /* traceflag */,
7615 0 /* Ignore count */,
7616 pending_break_support
,
7617 NULL
/* breakpoint_ops */,
7623 /* Helper function for break_command_1 and disassemble_command. */
7626 resolve_sal_pc (struct symtab_and_line
*sal
)
7630 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
7632 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
7633 error (_("No line %d in file \"%s\"."),
7634 sal
->line
, sal
->symtab
->filename
);
7637 /* If this SAL corresponds to a breakpoint inserted using
7638 a line number, then skip the function prologue if necessary. */
7639 if (sal
->explicit_line
)
7640 skip_prologue_sal (sal
);
7643 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
7645 struct blockvector
*bv
;
7649 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
, sal
->symtab
);
7652 sym
= block_linkage_function (b
);
7655 fixup_symbol_section (sym
, sal
->symtab
->objfile
);
7656 sal
->section
= SYMBOL_OBJ_SECTION (sym
);
7660 /* It really is worthwhile to have the section, so we'll just
7661 have to look harder. This case can be executed if we have
7662 line numbers but no functions (as can happen in assembly
7665 struct minimal_symbol
*msym
;
7666 struct cleanup
*old_chain
= save_current_space_and_thread ();
7668 switch_to_program_space_and_thread (sal
->pspace
);
7670 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
7672 sal
->section
= SYMBOL_OBJ_SECTION (msym
);
7674 do_cleanups (old_chain
);
7681 break_command (char *arg
, int from_tty
)
7683 break_command_1 (arg
, 0, from_tty
);
7687 tbreak_command (char *arg
, int from_tty
)
7689 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
7693 hbreak_command (char *arg
, int from_tty
)
7695 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
7699 thbreak_command (char *arg
, int from_tty
)
7701 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
7705 stop_command (char *arg
, int from_tty
)
7707 printf_filtered (_("Specify the type of breakpoint to set.\n\
7708 Usage: stop in <function | address>\n\
7709 stop at <line>\n"));
7713 stopin_command (char *arg
, int from_tty
)
7717 if (arg
== (char *) NULL
)
7719 else if (*arg
!= '*')
7724 /* look for a ':'. If this is a line number specification, then
7725 say it is bad, otherwise, it should be an address or
7726 function/method name */
7727 while (*argptr
&& !hasColon
)
7729 hasColon
= (*argptr
== ':');
7734 badInput
= (*argptr
!= ':'); /* Not a class::method */
7736 badInput
= isdigit (*arg
); /* a simple line number */
7740 printf_filtered (_("Usage: stop in <function | address>\n"));
7742 break_command_1 (arg
, 0, from_tty
);
7746 stopat_command (char *arg
, int from_tty
)
7750 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
7757 /* look for a ':'. If there is a '::' then get out, otherwise
7758 it is probably a line number. */
7759 while (*argptr
&& !hasColon
)
7761 hasColon
= (*argptr
== ':');
7766 badInput
= (*argptr
== ':'); /* we have class::method */
7768 badInput
= !isdigit (*arg
); /* not a line number */
7772 printf_filtered (_("Usage: stop at <line>\n"));
7774 break_command_1 (arg
, 0, from_tty
);
7777 /* Return non-zero if EXP is verified as constant. Returned zero means EXP is
7778 variable. Also the constant detection may fail for some constant
7779 expressions and in such case still falsely return zero. */
7781 watchpoint_exp_is_const (const struct expression
*exp
)
7789 /* We are only interested in the descriptor of each element. */
7790 operator_length (exp
, i
, &oplenp
, &argsp
);
7793 switch (exp
->elts
[i
].opcode
)
7803 case BINOP_LOGICAL_AND
:
7804 case BINOP_LOGICAL_OR
:
7805 case BINOP_BITWISE_AND
:
7806 case BINOP_BITWISE_IOR
:
7807 case BINOP_BITWISE_XOR
:
7809 case BINOP_NOTEQUAL
:
7825 case TERNOP_SLICE_COUNT
:
7837 case OP_OBJC_NSSTRING
:
7840 case UNOP_LOGICAL_NOT
:
7841 case UNOP_COMPLEMENT
:
7844 /* Unary, binary and ternary operators: We have to check their
7845 operands. If they are constant, then so is the result of
7846 that operation. For instance, if A and B are determined to be
7847 constants, then so is "A + B".
7849 UNOP_IND is one exception to the rule above, because the value
7850 of *ADDR is not necessarily a constant, even when ADDR is. */
7854 /* Check whether the associated symbol is a constant.
7855 We use SYMBOL_CLASS rather than TYPE_CONST because it's
7856 possible that a buggy compiler could mark a variable as constant
7857 even when it is not, and TYPE_CONST would return true in this
7858 case, while SYMBOL_CLASS wouldn't.
7859 We also have to check for function symbols because they are
7862 struct symbol
*s
= exp
->elts
[i
+ 2].symbol
;
7864 if (SYMBOL_CLASS (s
) != LOC_BLOCK
7865 && SYMBOL_CLASS (s
) != LOC_CONST
7866 && SYMBOL_CLASS (s
) != LOC_CONST_BYTES
)
7871 /* The default action is to return 0 because we are using
7872 the optimistic approach here: If we don't know something,
7873 then it is not a constant. */
7882 /* accessflag: hw_write: watch write,
7883 hw_read: watch read,
7884 hw_access: watch access (read or write) */
7886 watch_command_1 (char *arg
, int accessflag
, int from_tty
)
7888 struct breakpoint
*b
, *scope_breakpoint
= NULL
;
7889 struct expression
*exp
;
7890 struct block
*exp_valid_block
= NULL
, *cond_exp_valid_block
= NULL
;
7891 struct value
*val
, *mark
;
7892 struct frame_info
*frame
;
7893 char *exp_start
= NULL
;
7894 char *exp_end
= NULL
;
7895 char *tok
, *id_tok_start
, *end_tok
;
7897 char *cond_start
= NULL
;
7898 char *cond_end
= NULL
;
7899 int i
, other_type_used
, target_resources_ok
= 0;
7900 enum bptype bp_type
;
7904 /* Make sure that we actually have parameters to parse. */
7905 if (arg
!= NULL
&& arg
[0] != '\0')
7907 toklen
= strlen (arg
); /* Size of argument list. */
7909 /* Points tok to the end of the argument list. */
7910 tok
= arg
+ toklen
- 1;
7912 /* Go backwards in the parameters list. Skip the last parameter.
7913 If we're expecting a 'thread <thread_num>' parameter, this should
7914 be the thread identifier. */
7915 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
7917 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
7920 /* Points end_tok to the beginning of the last token. */
7921 id_tok_start
= tok
+ 1;
7923 /* Go backwards in the parameters list. Skip one more parameter.
7924 If we're expecting a 'thread <thread_num>' parameter, we should
7925 reach a "thread" token. */
7926 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
7931 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
7934 /* Move the pointer forward to skip the whitespace and
7935 calculate the length of the token. */
7937 toklen
= end_tok
- tok
;
7939 if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
7941 /* At this point we've found a "thread" token, which means
7942 the user is trying to set a watchpoint that triggers
7943 only in a specific thread. */
7946 /* Extract the thread ID from the next token. */
7947 thread
= strtol (id_tok_start
, &endp
, 0);
7949 /* Check if the user provided a valid numeric value for the
7951 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
7952 error (_("Invalid thread ID specification %s."), id_tok_start
);
7954 /* Check if the thread actually exists. */
7955 if (!valid_thread_id (thread
))
7956 error (_("Unknown thread %d."), thread
);
7958 /* Truncate the string and get rid of the thread <thread_num>
7959 parameter before the parameter list is parsed by the
7960 evaluate_expression() function. */
7965 /* Parse the rest of the arguments. */
7966 innermost_block
= NULL
;
7968 exp
= parse_exp_1 (&arg
, 0, 0);
7970 /* Remove trailing whitespace from the expression before saving it.
7971 This makes the eventual display of the expression string a bit
7973 while (exp_end
> exp_start
&& (exp_end
[-1] == ' ' || exp_end
[-1] == '\t'))
7976 /* Checking if the expression is not constant. */
7977 if (watchpoint_exp_is_const (exp
))
7981 len
= exp_end
- exp_start
;
7982 while (len
> 0 && isspace (exp_start
[len
- 1]))
7984 error (_("Cannot watch constant value `%.*s'."), len
, exp_start
);
7987 exp_valid_block
= innermost_block
;
7988 mark
= value_mark ();
7989 fetch_watchpoint_value (exp
, &val
, NULL
, NULL
);
7991 release_value (val
);
7994 while (*tok
== ' ' || *tok
== '\t')
7998 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
8001 toklen
= end_tok
- tok
;
8002 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
8004 struct expression
*cond
;
8006 innermost_block
= NULL
;
8007 tok
= cond_start
= end_tok
+ 1;
8008 cond
= parse_exp_1 (&tok
, 0, 0);
8010 /* The watchpoint expression may not be local, but the condition
8011 may still be. E.g.: `watch global if local > 0'. */
8012 cond_exp_valid_block
= innermost_block
;
8018 error (_("Junk at end of command."));
8020 if (accessflag
== hw_read
)
8021 bp_type
= bp_read_watchpoint
;
8022 else if (accessflag
== hw_access
)
8023 bp_type
= bp_access_watchpoint
;
8025 bp_type
= bp_hardware_watchpoint
;
8027 mem_cnt
= can_use_hardware_watchpoint (val
);
8028 if (mem_cnt
== 0 && bp_type
!= bp_hardware_watchpoint
)
8029 error (_("Expression cannot be implemented with read/access watchpoint."));
8032 i
= hw_watchpoint_used_count (bp_type
, &other_type_used
);
8033 target_resources_ok
=
8034 target_can_use_hardware_watchpoint (bp_type
, i
+ mem_cnt
,
8036 if (target_resources_ok
== 0 && bp_type
!= bp_hardware_watchpoint
)
8037 error (_("Target does not support this type of hardware watchpoint."));
8039 if (target_resources_ok
< 0 && bp_type
!= bp_hardware_watchpoint
)
8040 error (_("Target can only support one kind of HW watchpoint at a time."));
8043 /* Change the type of breakpoint to an ordinary watchpoint if a hardware
8044 watchpoint could not be set. */
8045 if (!mem_cnt
|| target_resources_ok
<= 0)
8046 bp_type
= bp_watchpoint
;
8048 frame
= block_innermost_frame (exp_valid_block
);
8050 /* If the expression is "local", then set up a "watchpoint scope"
8051 breakpoint at the point where we've left the scope of the watchpoint
8052 expression. Create the scope breakpoint before the watchpoint, so
8053 that we will encounter it first in bpstat_stop_status. */
8054 if (exp_valid_block
&& frame
)
8056 if (frame_id_p (frame_unwind_caller_id (frame
)))
8059 = create_internal_breakpoint (frame_unwind_caller_arch (frame
),
8060 frame_unwind_caller_pc (frame
),
8061 bp_watchpoint_scope
);
8063 scope_breakpoint
->enable_state
= bp_enabled
;
8065 /* Automatically delete the breakpoint when it hits. */
8066 scope_breakpoint
->disposition
= disp_del
;
8068 /* Only break in the proper frame (help with recursion). */
8069 scope_breakpoint
->frame_id
= frame_unwind_caller_id (frame
);
8071 /* Set the address at which we will stop. */
8072 scope_breakpoint
->loc
->gdbarch
8073 = frame_unwind_caller_arch (frame
);
8074 scope_breakpoint
->loc
->requested_address
8075 = frame_unwind_caller_pc (frame
);
8076 scope_breakpoint
->loc
->address
8077 = adjust_breakpoint_address (scope_breakpoint
->loc
->gdbarch
,
8078 scope_breakpoint
->loc
->requested_address
,
8079 scope_breakpoint
->type
);
8083 /* Now set up the breakpoint. */
8084 b
= set_raw_breakpoint_without_location (NULL
, bp_type
);
8085 set_breakpoint_count (breakpoint_count
+ 1);
8086 b
->number
= breakpoint_count
;
8088 b
->disposition
= disp_donttouch
;
8090 b
->exp_valid_block
= exp_valid_block
;
8091 b
->cond_exp_valid_block
= cond_exp_valid_block
;
8092 b
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
8096 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
8102 b
->watchpoint_frame
= get_frame_id (frame
);
8103 b
->watchpoint_thread
= inferior_ptid
;
8107 b
->watchpoint_frame
= null_frame_id
;
8108 b
->watchpoint_thread
= null_ptid
;
8111 if (scope_breakpoint
!= NULL
)
8113 /* The scope breakpoint is related to the watchpoint. We will
8114 need to act on them together. */
8115 b
->related_breakpoint
= scope_breakpoint
;
8116 scope_breakpoint
->related_breakpoint
= b
;
8119 value_free_to_mark (mark
);
8121 /* Finally update the new watchpoint. This creates the locations
8122 that should be inserted. */
8123 update_watchpoint (b
, 1);
8126 update_global_location_list (1);
8129 /* Return count of locations need to be watched and can be handled
8130 in hardware. If the watchpoint can not be handled
8131 in hardware return zero. */
8134 can_use_hardware_watchpoint (struct value
*v
)
8136 int found_memory_cnt
= 0;
8137 struct value
*head
= v
;
8139 /* Did the user specifically forbid us to use hardware watchpoints? */
8140 if (!can_use_hw_watchpoints
)
8143 /* Make sure that the value of the expression depends only upon
8144 memory contents, and values computed from them within GDB. If we
8145 find any register references or function calls, we can't use a
8146 hardware watchpoint.
8148 The idea here is that evaluating an expression generates a series
8149 of values, one holding the value of every subexpression. (The
8150 expression a*b+c has five subexpressions: a, b, a*b, c, and
8151 a*b+c.) GDB's values hold almost enough information to establish
8152 the criteria given above --- they identify memory lvalues,
8153 register lvalues, computed values, etcetera. So we can evaluate
8154 the expression, and then scan the chain of values that leaves
8155 behind to decide whether we can detect any possible change to the
8156 expression's final value using only hardware watchpoints.
8158 However, I don't think that the values returned by inferior
8159 function calls are special in any way. So this function may not
8160 notice that an expression involving an inferior function call
8161 can't be watched with hardware watchpoints. FIXME. */
8162 for (; v
; v
= value_next (v
))
8164 if (VALUE_LVAL (v
) == lval_memory
)
8167 /* A lazy memory lvalue is one that GDB never needed to fetch;
8168 we either just used its address (e.g., `a' in `a.b') or
8169 we never needed it at all (e.g., `a' in `a,b'). */
8173 /* Ahh, memory we actually used! Check if we can cover
8174 it with hardware watchpoints. */
8175 struct type
*vtype
= check_typedef (value_type (v
));
8177 /* We only watch structs and arrays if user asked for it
8178 explicitly, never if they just happen to appear in a
8179 middle of some value chain. */
8181 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
8182 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
8184 CORE_ADDR vaddr
= value_address (v
);
8185 int len
= TYPE_LENGTH (value_type (v
));
8187 if (!target_region_ok_for_hw_watchpoint (vaddr
, len
))
8194 else if (VALUE_LVAL (v
) != not_lval
8195 && deprecated_value_modifiable (v
) == 0)
8196 return 0; /* ??? What does this represent? */
8197 else if (VALUE_LVAL (v
) == lval_register
)
8198 return 0; /* cannot watch a register with a HW watchpoint */
8201 /* The expression itself looks suitable for using a hardware
8202 watchpoint, but give the target machine a chance to reject it. */
8203 return found_memory_cnt
;
8207 watch_command_wrapper (char *arg
, int from_tty
)
8209 watch_command (arg
, from_tty
);
8213 watch_command (char *arg
, int from_tty
)
8215 watch_command_1 (arg
, hw_write
, from_tty
);
8219 rwatch_command_wrapper (char *arg
, int from_tty
)
8221 rwatch_command (arg
, from_tty
);
8225 rwatch_command (char *arg
, int from_tty
)
8227 watch_command_1 (arg
, hw_read
, from_tty
);
8231 awatch_command_wrapper (char *arg
, int from_tty
)
8233 awatch_command (arg
, from_tty
);
8237 awatch_command (char *arg
, int from_tty
)
8239 watch_command_1 (arg
, hw_access
, from_tty
);
8243 /* Helper routines for the until_command routine in infcmd.c. Here
8244 because it uses the mechanisms of breakpoints. */
8246 struct until_break_command_continuation_args
8248 struct breakpoint
*breakpoint
;
8249 struct breakpoint
*breakpoint2
;
8252 /* This function is called by fetch_inferior_event via the
8253 cmd_continuation pointer, to complete the until command. It takes
8254 care of cleaning up the temporary breakpoints set up by the until
8257 until_break_command_continuation (void *arg
)
8259 struct until_break_command_continuation_args
*a
= arg
;
8261 delete_breakpoint (a
->breakpoint
);
8263 delete_breakpoint (a
->breakpoint2
);
8267 until_break_command (char *arg
, int from_tty
, int anywhere
)
8269 struct symtabs_and_lines sals
;
8270 struct symtab_and_line sal
;
8271 struct frame_info
*frame
= get_selected_frame (NULL
);
8272 struct breakpoint
*breakpoint
;
8273 struct breakpoint
*breakpoint2
= NULL
;
8274 struct cleanup
*old_chain
;
8276 clear_proceed_status ();
8278 /* Set a breakpoint where the user wants it and at return from
8281 if (default_breakpoint_valid
)
8282 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
8283 default_breakpoint_line
, (char ***) NULL
, NULL
);
8285 sals
= decode_line_1 (&arg
, 1, (struct symtab
*) NULL
,
8286 0, (char ***) NULL
, NULL
);
8288 if (sals
.nelts
!= 1)
8289 error (_("Couldn't get information on specified line."));
8292 xfree (sals
.sals
); /* malloc'd, so freed */
8295 error (_("Junk at end of arguments."));
8297 resolve_sal_pc (&sal
);
8300 /* If the user told us to continue until a specified location,
8301 we don't specify a frame at which we need to stop. */
8302 breakpoint
= set_momentary_breakpoint (get_frame_arch (frame
), sal
,
8303 null_frame_id
, bp_until
);
8305 /* Otherwise, specify the selected frame, because we want to stop only
8306 at the very same frame. */
8307 breakpoint
= set_momentary_breakpoint (get_frame_arch (frame
), sal
,
8308 get_stack_frame_id (frame
),
8311 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
8313 /* Keep within the current frame, or in frames called by the current
8316 if (frame_id_p (frame_unwind_caller_id (frame
)))
8318 sal
= find_pc_line (frame_unwind_caller_pc (frame
), 0);
8319 sal
.pc
= frame_unwind_caller_pc (frame
);
8320 breakpoint2
= set_momentary_breakpoint (frame_unwind_caller_arch (frame
),
8322 frame_unwind_caller_id (frame
),
8324 make_cleanup_delete_breakpoint (breakpoint2
);
8327 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
8329 /* If we are running asynchronously, and proceed call above has actually
8330 managed to start the target, arrange for breakpoints to be
8331 deleted when the target stops. Otherwise, we're already stopped and
8332 delete breakpoints via cleanup chain. */
8334 if (target_can_async_p () && is_running (inferior_ptid
))
8336 struct until_break_command_continuation_args
*args
;
8337 args
= xmalloc (sizeof (*args
));
8339 args
->breakpoint
= breakpoint
;
8340 args
->breakpoint2
= breakpoint2
;
8342 discard_cleanups (old_chain
);
8343 add_continuation (inferior_thread (),
8344 until_break_command_continuation
, args
,
8348 do_cleanups (old_chain
);
8352 ep_skip_leading_whitespace (char **s
)
8354 if ((s
== NULL
) || (*s
== NULL
))
8356 while (isspace (**s
))
8360 /* This function attempts to parse an optional "if <cond>" clause
8361 from the arg string. If one is not found, it returns NULL.
8363 Else, it returns a pointer to the condition string. (It does not
8364 attempt to evaluate the string against a particular block.) And,
8365 it updates arg to point to the first character following the parsed
8366 if clause in the arg string. */
8369 ep_parse_optional_if_clause (char **arg
)
8373 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
8376 /* Skip the "if" keyword. */
8379 /* Skip any extra leading whitespace, and record the start of the
8380 condition string. */
8381 ep_skip_leading_whitespace (arg
);
8384 /* Assume that the condition occupies the remainder of the arg string. */
8385 (*arg
) += strlen (cond_string
);
8390 /* Commands to deal with catching events, such as signals, exceptions,
8391 process start/exit, etc. */
8395 catch_fork_temporary
, catch_vfork_temporary
,
8396 catch_fork_permanent
, catch_vfork_permanent
8401 catch_fork_command_1 (char *arg
, int from_tty
,
8402 struct cmd_list_element
*command
)
8404 struct gdbarch
*gdbarch
= get_current_arch ();
8405 char *cond_string
= NULL
;
8406 catch_fork_kind fork_kind
;
8409 fork_kind
= (catch_fork_kind
) (uintptr_t) get_cmd_context (command
);
8410 tempflag
= (fork_kind
== catch_fork_temporary
8411 || fork_kind
== catch_vfork_temporary
);
8415 ep_skip_leading_whitespace (&arg
);
8417 /* The allowed syntax is:
8419 catch [v]fork if <cond>
8421 First, check if there's an if clause. */
8422 cond_string
= ep_parse_optional_if_clause (&arg
);
8424 if ((*arg
!= '\0') && !isspace (*arg
))
8425 error (_("Junk at end of arguments."));
8427 /* If this target supports it, create a fork or vfork catchpoint
8428 and enable reporting of such events. */
8431 case catch_fork_temporary
:
8432 case catch_fork_permanent
:
8433 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
8434 &catch_fork_breakpoint_ops
);
8436 case catch_vfork_temporary
:
8437 case catch_vfork_permanent
:
8438 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
8439 &catch_vfork_breakpoint_ops
);
8442 error (_("unsupported or unknown fork kind; cannot catch it"));
8448 catch_exec_command_1 (char *arg
, int from_tty
,
8449 struct cmd_list_element
*command
)
8451 struct gdbarch
*gdbarch
= get_current_arch ();
8453 char *cond_string
= NULL
;
8455 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
8459 ep_skip_leading_whitespace (&arg
);
8461 /* The allowed syntax is:
8463 catch exec if <cond>
8465 First, check if there's an if clause. */
8466 cond_string
= ep_parse_optional_if_clause (&arg
);
8468 if ((*arg
!= '\0') && !isspace (*arg
))
8469 error (_("Junk at end of arguments."));
8471 /* If this target supports it, create an exec catchpoint
8472 and enable reporting of such events. */
8473 create_catchpoint (gdbarch
, tempflag
, cond_string
,
8474 &catch_exec_breakpoint_ops
);
8477 static enum print_stop_action
8478 print_exception_catchpoint (struct breakpoint
*b
)
8480 int bp_temp
, bp_throw
;
8482 annotate_catchpoint (b
->number
);
8484 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
8485 if (b
->loc
->address
!= b
->loc
->requested_address
)
8486 breakpoint_adjustment_warning (b
->loc
->requested_address
,
8489 bp_temp
= b
->disposition
== disp_del
;
8491 bp_temp
? "Temporary catchpoint "
8493 if (!ui_out_is_mi_like_p (uiout
))
8494 ui_out_field_int (uiout
, "bkptno", b
->number
);
8496 bp_throw
? " (exception thrown), "
8497 : " (exception caught), ");
8498 if (ui_out_is_mi_like_p (uiout
))
8500 ui_out_field_string (uiout
, "reason",
8501 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
8502 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
8503 ui_out_field_int (uiout
, "bkptno", b
->number
);
8505 return PRINT_SRC_AND_LOC
;
8509 print_one_exception_catchpoint (struct breakpoint
*b
,
8510 struct bp_location
**last_loc
)
8512 struct value_print_options opts
;
8514 get_user_print_options (&opts
);
8515 if (opts
.addressprint
)
8518 if (b
->loc
== NULL
|| b
->loc
->shlib_disabled
)
8519 ui_out_field_string (uiout
, "addr", "<PENDING>");
8521 ui_out_field_core_addr (uiout
, "addr",
8522 b
->loc
->gdbarch
, b
->loc
->address
);
8527 if (strstr (b
->addr_string
, "throw") != NULL
)
8528 ui_out_field_string (uiout
, "what", "exception throw");
8530 ui_out_field_string (uiout
, "what", "exception catch");
8534 print_mention_exception_catchpoint (struct breakpoint
*b
)
8539 bp_temp
= b
->disposition
== disp_del
;
8540 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
8541 ui_out_text (uiout
, bp_temp
? _("Temporary catchpoint ")
8542 : _("Catchpoint "));
8543 ui_out_field_int (uiout
, "bkptno", b
->number
);
8544 ui_out_text (uiout
, bp_throw
? _(" (throw)")
8548 /* Implement the "print_recreate" breakpoint_ops method for throw and
8549 catch catchpoints. */
8552 print_recreate_exception_catchpoint (struct breakpoint
*b
, struct ui_file
*fp
)
8557 bp_temp
= b
->disposition
== disp_del
;
8558 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
8559 fprintf_unfiltered (fp
, bp_temp
? "tcatch " : "catch ");
8560 fprintf_unfiltered (fp
, bp_throw
? "throw" : "catch");
8563 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops
= {
8566 NULL
, /* breakpoint_hit */
8567 print_exception_catchpoint
,
8568 print_one_exception_catchpoint
,
8569 print_mention_exception_catchpoint
,
8570 print_recreate_exception_catchpoint
8574 handle_gnu_v3_exceptions (int tempflag
, char *cond_string
,
8575 enum exception_event_kind ex_event
, int from_tty
)
8577 char *trigger_func_name
;
8579 if (ex_event
== EX_EVENT_CATCH
)
8580 trigger_func_name
= "__cxa_begin_catch";
8582 trigger_func_name
= "__cxa_throw";
8584 create_breakpoint (get_current_arch (),
8585 trigger_func_name
, cond_string
, -1,
8586 0 /* condition and thread are valid. */,
8589 AUTO_BOOLEAN_TRUE
/* pending */,
8590 &gnu_v3_exception_catchpoint_ops
, from_tty
,
8596 /* Deal with "catch catch" and "catch throw" commands */
8599 catch_exception_command_1 (enum exception_event_kind ex_event
, char *arg
,
8600 int tempflag
, int from_tty
)
8602 char *cond_string
= NULL
;
8606 ep_skip_leading_whitespace (&arg
);
8608 cond_string
= ep_parse_optional_if_clause (&arg
);
8610 if ((*arg
!= '\0') && !isspace (*arg
))
8611 error (_("Junk at end of arguments."));
8613 if (ex_event
!= EX_EVENT_THROW
8614 && ex_event
!= EX_EVENT_CATCH
)
8615 error (_("Unsupported or unknown exception event; cannot catch it"));
8617 if (handle_gnu_v3_exceptions (tempflag
, cond_string
, ex_event
, from_tty
))
8620 warning (_("Unsupported with this platform/compiler combination."));
8623 /* Implementation of "catch catch" command. */
8626 catch_catch_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
8628 int tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
8630 catch_exception_command_1 (EX_EVENT_CATCH
, arg
, tempflag
, from_tty
);
8633 /* Implementation of "catch throw" command. */
8636 catch_throw_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
8638 int tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
8640 catch_exception_command_1 (EX_EVENT_THROW
, arg
, tempflag
, from_tty
);
8643 /* Create a breakpoint struct for Ada exception catchpoints. */
8646 create_ada_exception_breakpoint (struct gdbarch
*gdbarch
,
8647 struct symtab_and_line sal
,
8651 struct expression
*cond
,
8652 struct breakpoint_ops
*ops
,
8656 struct breakpoint
*b
;
8660 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
8662 loc_gdbarch
= gdbarch
;
8664 describe_other_breakpoints (loc_gdbarch
,
8665 sal
.pspace
, sal
.pc
, sal
.section
, -1);
8666 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
8667 version for exception catchpoints, because two catchpoints
8668 used for different exception names will use the same address.
8669 In this case, a "breakpoint ... also set at..." warning is
8670 unproductive. Besides. the warning phrasing is also a bit
8671 inapropriate, we should use the word catchpoint, and tell
8672 the user what type of catchpoint it is. The above is good
8673 enough for now, though. */
8676 b
= set_raw_breakpoint (gdbarch
, sal
, bp_breakpoint
);
8677 set_breakpoint_count (breakpoint_count
+ 1);
8679 b
->enable_state
= bp_enabled
;
8680 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
8681 b
->number
= breakpoint_count
;
8682 b
->ignore_count
= 0;
8683 b
->loc
->cond
= cond
;
8684 b
->addr_string
= addr_string
;
8685 b
->language
= language_ada
;
8686 b
->cond_string
= cond_string
;
8687 b
->exp_string
= exp_string
;
8692 update_global_location_list (1);
8695 /* Implement the "catch exception" command. */
8698 catch_ada_exception_command (char *arg
, int from_tty
,
8699 struct cmd_list_element
*command
)
8701 struct gdbarch
*gdbarch
= get_current_arch ();
8703 struct symtab_and_line sal
;
8704 char *addr_string
= NULL
;
8705 char *exp_string
= NULL
;
8706 char *cond_string
= NULL
;
8707 struct expression
*cond
= NULL
;
8708 struct breakpoint_ops
*ops
= NULL
;
8710 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
8714 sal
= ada_decode_exception_location (arg
, &addr_string
, &exp_string
,
8715 &cond_string
, &cond
, &ops
);
8716 create_ada_exception_breakpoint (gdbarch
, sal
, addr_string
, exp_string
,
8717 cond_string
, cond
, ops
, tempflag
,
8721 /* Cleanup function for a syscall filter list. */
8723 clean_up_filters (void *arg
)
8725 VEC(int) *iter
= *(VEC(int) **) arg
;
8726 VEC_free (int, iter
);
8729 /* Splits the argument using space as delimiter. Returns an xmalloc'd
8730 filter list, or NULL if no filtering is required. */
8732 catch_syscall_split_args (char *arg
)
8734 VEC(int) *result
= NULL
;
8735 struct cleanup
*cleanup
= make_cleanup (clean_up_filters
, &result
);
8737 while (*arg
!= '\0')
8739 int i
, syscall_number
;
8744 /* Skip whitespace. */
8745 while (isspace (*arg
))
8748 for (i
= 0; i
< 127 && arg
[i
] && !isspace (arg
[i
]); ++i
)
8749 cur_name
[i
] = arg
[i
];
8753 /* Check if the user provided a syscall name or a number. */
8754 syscall_number
= (int) strtol (cur_name
, &endptr
, 0);
8755 if (*endptr
== '\0')
8756 get_syscall_by_number (syscall_number
, &s
);
8759 /* We have a name. Let's check if it's valid and convert it
8761 get_syscall_by_name (cur_name
, &s
);
8763 if (s
.number
== UNKNOWN_SYSCALL
)
8764 /* Here we have to issue an error instead of a warning, because
8765 GDB cannot do anything useful if there's no syscall number to
8767 error (_("Unknown syscall name '%s'."), cur_name
);
8770 /* Ok, it's valid. */
8771 VEC_safe_push (int, result
, s
.number
);
8774 discard_cleanups (cleanup
);
8778 /* Implement the "catch syscall" command. */
8781 catch_syscall_command_1 (char *arg
, int from_tty
,
8782 struct cmd_list_element
*command
)
8787 struct gdbarch
*gdbarch
= get_current_arch ();
8789 /* Checking if the feature if supported. */
8790 if (gdbarch_get_syscall_number_p (gdbarch
) == 0)
8791 error (_("The feature 'catch syscall' is not supported on \
8792 this architeture yet."));
8794 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
8796 ep_skip_leading_whitespace (&arg
);
8798 /* We need to do this first "dummy" translation in order
8799 to get the syscall XML file loaded or, most important,
8800 to display a warning to the user if there's no XML file
8801 for his/her architecture. */
8802 get_syscall_by_number (0, &s
);
8804 /* The allowed syntax is:
8806 catch syscall <name | number> [<name | number> ... <name | number>]
8808 Let's check if there's a syscall name. */
8811 filter
= catch_syscall_split_args (arg
);
8815 create_syscall_event_catchpoint (tempflag
, filter
,
8816 &catch_syscall_breakpoint_ops
);
8819 /* Implement the "catch assert" command. */
8822 catch_assert_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
8824 struct gdbarch
*gdbarch
= get_current_arch ();
8826 struct symtab_and_line sal
;
8827 char *addr_string
= NULL
;
8828 struct breakpoint_ops
*ops
= NULL
;
8830 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
8834 sal
= ada_decode_assert_location (arg
, &addr_string
, &ops
);
8835 create_ada_exception_breakpoint (gdbarch
, sal
, addr_string
, NULL
, NULL
, NULL
,
8836 ops
, tempflag
, from_tty
);
8840 catch_command (char *arg
, int from_tty
)
8842 error (_("Catch requires an event name."));
8847 tcatch_command (char *arg
, int from_tty
)
8849 error (_("Catch requires an event name."));
8852 /* Delete breakpoints by address or line. */
8855 clear_command (char *arg
, int from_tty
)
8857 struct breakpoint
*b
;
8858 VEC(breakpoint_p
) *found
= 0;
8861 struct symtabs_and_lines sals
;
8862 struct symtab_and_line sal
;
8867 sals
= decode_line_spec (arg
, 1);
8872 sals
.sals
= (struct symtab_and_line
*)
8873 xmalloc (sizeof (struct symtab_and_line
));
8874 make_cleanup (xfree
, sals
.sals
);
8875 init_sal (&sal
); /* initialize to zeroes */
8876 sal
.line
= default_breakpoint_line
;
8877 sal
.symtab
= default_breakpoint_symtab
;
8878 sal
.pc
= default_breakpoint_address
;
8879 sal
.pspace
= default_breakpoint_pspace
;
8880 if (sal
.symtab
== 0)
8881 error (_("No source file specified."));
8889 /* We don't call resolve_sal_pc here. That's not
8890 as bad as it seems, because all existing breakpoints
8891 typically have both file/line and pc set. So, if
8892 clear is given file/line, we can match this to existing
8893 breakpoint without obtaining pc at all.
8895 We only support clearing given the address explicitly
8896 present in breakpoint table. Say, we've set breakpoint
8897 at file:line. There were several PC values for that file:line,
8898 due to optimization, all in one block.
8899 We've picked one PC value. If "clear" is issued with another
8900 PC corresponding to the same file:line, the breakpoint won't
8901 be cleared. We probably can still clear the breakpoint, but
8902 since the other PC value is never presented to user, user
8903 can only find it by guessing, and it does not seem important
8906 /* For each line spec given, delete bps which correspond
8907 to it. Do it in two passes, solely to preserve the current
8908 behavior that from_tty is forced true if we delete more than
8912 for (i
= 0; i
< sals
.nelts
; i
++)
8914 /* If exact pc given, clear bpts at that pc.
8915 If line given (pc == 0), clear all bpts on specified line.
8916 If defaulting, clear all bpts on default line
8919 defaulting sal.pc != 0 tests to do
8924 1 0 <can't happen> */
8928 /* Find all matching breakpoints and add them to
8933 /* Are we going to delete b? */
8934 if (b
->type
!= bp_none
&& !is_watchpoint (b
))
8936 struct bp_location
*loc
= b
->loc
;
8937 for (; loc
; loc
= loc
->next
)
8939 int pc_match
= sal
.pc
8940 && (loc
->pspace
== sal
.pspace
)
8941 && (loc
->address
== sal
.pc
)
8942 && (!section_is_overlay (loc
->section
)
8943 || loc
->section
== sal
.section
);
8944 int line_match
= ((default_match
|| (0 == sal
.pc
))
8945 && b
->source_file
!= NULL
8946 && sal
.symtab
!= NULL
8947 && sal
.pspace
== loc
->pspace
8948 && strcmp (b
->source_file
, sal
.symtab
->filename
) == 0
8949 && b
->line_number
== sal
.line
);
8950 if (pc_match
|| line_match
)
8959 VEC_safe_push(breakpoint_p
, found
, b
);
8962 /* Now go thru the 'found' chain and delete them. */
8963 if (VEC_empty(breakpoint_p
, found
))
8966 error (_("No breakpoint at %s."), arg
);
8968 error (_("No breakpoint at this line."));
8971 if (VEC_length(breakpoint_p
, found
) > 1)
8972 from_tty
= 1; /* Always report if deleted more than one */
8975 if (VEC_length(breakpoint_p
, found
) == 1)
8976 printf_unfiltered (_("Deleted breakpoint "));
8978 printf_unfiltered (_("Deleted breakpoints "));
8980 breakpoints_changed ();
8982 for (ix
= 0; VEC_iterate(breakpoint_p
, found
, ix
, b
); ix
++)
8985 printf_unfiltered ("%d ", b
->number
);
8986 delete_breakpoint (b
);
8989 putchar_unfiltered ('\n');
8992 /* Delete breakpoint in BS if they are `delete' breakpoints and
8993 all breakpoints that are marked for deletion, whether hit or not.
8994 This is called after any breakpoint is hit, or after errors. */
8997 breakpoint_auto_delete (bpstat bs
)
8999 struct breakpoint
*b
, *temp
;
9001 for (; bs
; bs
= bs
->next
)
9002 if (bs
->breakpoint_at
9003 && bs
->breakpoint_at
->owner
9004 && bs
->breakpoint_at
->owner
->disposition
== disp_del
9006 delete_breakpoint (bs
->breakpoint_at
->owner
);
9008 ALL_BREAKPOINTS_SAFE (b
, temp
)
9010 if (b
->disposition
== disp_del_at_next_stop
)
9011 delete_breakpoint (b
);
9015 /* A comparison function for bp_location AP and BP being interfaced to qsort.
9016 Sort elements primarily by their ADDRESS (no matter what does
9017 breakpoint_address_is_meaningful say for its OWNER), secondarily by ordering
9018 first bp_permanent OWNERed elements and terciarily just ensuring the array
9019 is sorted stable way despite qsort being an instable algorithm. */
9022 bp_location_compare (const void *ap
, const void *bp
)
9024 struct bp_location
*a
= *(void **) ap
;
9025 struct bp_location
*b
= *(void **) bp
;
9026 /* A and B come from existing breakpoints having non-NULL OWNER. */
9027 int a_perm
= a
->owner
->enable_state
== bp_permanent
;
9028 int b_perm
= b
->owner
->enable_state
== bp_permanent
;
9030 if (a
->address
!= b
->address
)
9031 return (a
->address
> b
->address
) - (a
->address
< b
->address
);
9033 /* Sort permanent breakpoints first. */
9034 if (a_perm
!= b_perm
)
9035 return (a_perm
< b_perm
) - (a_perm
> b_perm
);
9037 /* Make the user-visible order stable across GDB runs. Locations of the same
9038 breakpoint can be sorted in arbitrary order. */
9040 if (a
->owner
->number
!= b
->owner
->number
)
9041 return (a
->owner
->number
> b
->owner
->number
)
9042 - (a
->owner
->number
< b
->owner
->number
);
9044 return (a
> b
) - (a
< b
);
9047 /* Set bp_location_placed_address_before_address_max and
9048 bp_location_shadow_len_after_address_max according to the current content of
9049 the bp_location array. */
9052 bp_location_target_extensions_update (void)
9054 struct bp_location
*bl
, **blp_tmp
;
9056 bp_location_placed_address_before_address_max
= 0;
9057 bp_location_shadow_len_after_address_max
= 0;
9059 ALL_BP_LOCATIONS (bl
, blp_tmp
)
9061 CORE_ADDR start
, end
, addr
;
9063 if (!bp_location_has_shadow (bl
))
9066 start
= bl
->target_info
.placed_address
;
9067 end
= start
+ bl
->target_info
.shadow_len
;
9069 gdb_assert (bl
->address
>= start
);
9070 addr
= bl
->address
- start
;
9071 if (addr
> bp_location_placed_address_before_address_max
)
9072 bp_location_placed_address_before_address_max
= addr
;
9074 /* Zero SHADOW_LEN would not pass bp_location_has_shadow. */
9076 gdb_assert (bl
->address
< end
);
9077 addr
= end
- bl
->address
;
9078 if (addr
> bp_location_shadow_len_after_address_max
)
9079 bp_location_shadow_len_after_address_max
= addr
;
9083 /* If SHOULD_INSERT is false, do not insert any breakpoint locations
9084 into the inferior, only remove already-inserted locations that no
9085 longer should be inserted. Functions that delete a breakpoint or
9086 breakpoints should pass false, so that deleting a breakpoint
9087 doesn't have the side effect of inserting the locations of other
9088 breakpoints that are marked not-inserted, but should_be_inserted
9089 returns true on them.
9091 This behaviour is useful is situations close to tear-down -- e.g.,
9092 after an exec, while the target still has execution, but breakpoint
9093 shadows of the previous executable image should *NOT* be restored
9094 to the new image; or before detaching, where the target still has
9095 execution and wants to delete breakpoints from GDB's lists, and all
9096 breakpoints had already been removed from the inferior. */
9099 update_global_location_list (int should_insert
)
9101 struct breakpoint
*b
;
9102 struct bp_location
**locp
, *loc
;
9103 struct cleanup
*cleanups
;
9105 /* Used in the duplicates detection below. When iterating over all
9106 bp_locations, points to the first bp_location of a given address.
9107 Breakpoints and watchpoints of different types are never
9108 duplicates of each other. Keep one pointer for each type of
9109 breakpoint/watchpoint, so we only need to loop over all locations
9111 struct bp_location
*bp_loc_first
; /* breakpoint */
9112 struct bp_location
*wp_loc_first
; /* hardware watchpoint */
9113 struct bp_location
*awp_loc_first
; /* access watchpoint */
9114 struct bp_location
*rwp_loc_first
; /* read watchpoint */
9116 /* Saved former bp_location array which we compare against the newly built
9117 bp_location from the current state of ALL_BREAKPOINTS. */
9118 struct bp_location
**old_location
, **old_locp
;
9119 unsigned old_location_count
;
9121 old_location
= bp_location
;
9122 old_location_count
= bp_location_count
;
9124 bp_location_count
= 0;
9125 cleanups
= make_cleanup (xfree
, old_location
);
9128 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
9129 bp_location_count
++;
9131 bp_location
= xmalloc (sizeof (*bp_location
) * bp_location_count
);
9134 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
9136 qsort (bp_location
, bp_location_count
, sizeof (*bp_location
),
9137 bp_location_compare
);
9139 bp_location_target_extensions_update ();
9141 /* Identify bp_location instances that are no longer present in the new
9142 list, and therefore should be freed. Note that it's not necessary that
9143 those locations should be removed from inferior -- if there's another
9144 location at the same address (previously marked as duplicate),
9145 we don't need to remove/insert the location.
9147 LOCP is kept in sync with OLD_LOCP, each pointing to the current and
9148 former bp_location array state respectively. */
9151 for (old_locp
= old_location
; old_locp
< old_location
+ old_location_count
;
9154 struct bp_location
*old_loc
= *old_locp
;
9155 struct bp_location
**loc2p
;
9157 /* Tells if 'old_loc' is found amoung the new locations. If not, we
9159 int found_object
= 0;
9160 /* Tells if the location should remain inserted in the target. */
9161 int keep_in_target
= 0;
9164 /* Skip LOCP entries which will definitely never be needed. Stop either
9165 at or being the one matching OLD_LOC. */
9166 while (locp
< bp_location
+ bp_location_count
9167 && (*locp
)->address
< old_loc
->address
)
9171 (loc2p
< bp_location
+ bp_location_count
9172 && (*loc2p
)->address
== old_loc
->address
);
9175 if (*loc2p
== old_loc
)
9182 /* If this location is no longer present, and inserted, look if there's
9183 maybe a new location at the same address. If so, mark that one
9184 inserted, and don't remove this one. This is needed so that we
9185 don't have a time window where a breakpoint at certain location is not
9188 if (old_loc
->inserted
)
9190 /* If the location is inserted now, we might have to remove it. */
9192 if (found_object
&& should_be_inserted (old_loc
))
9194 /* The location is still present in the location list, and still
9195 should be inserted. Don't do anything. */
9200 /* The location is either no longer present, or got disabled.
9201 See if there's another location at the same address, in which
9202 case we don't need to remove this one from the target. */
9204 /* OLD_LOC comes from existing struct breakpoint. */
9205 if (breakpoint_address_is_meaningful (old_loc
->owner
))
9208 (loc2p
< bp_location
+ bp_location_count
9209 && (*loc2p
)->address
== old_loc
->address
);
9212 struct bp_location
*loc2
= *loc2p
;
9214 if (breakpoint_locations_match (loc2
, old_loc
))
9216 /* For the sake of should_be_inserted.
9217 Duplicates check below will fix up this later. */
9218 loc2
->duplicate
= 0;
9220 /* Read watchpoint locations are switched to
9221 access watchpoints, if the former are not
9222 supported, but the latter are. */
9223 if (is_hardware_watchpoint (old_loc
->owner
))
9225 gdb_assert (is_hardware_watchpoint (loc2
->owner
));
9226 loc2
->watchpoint_type
= old_loc
->watchpoint_type
;
9229 if (loc2
!= old_loc
&& should_be_inserted (loc2
))
9232 loc2
->target_info
= old_loc
->target_info
;
9241 if (!keep_in_target
)
9243 if (remove_breakpoint (old_loc
, mark_uninserted
))
9245 /* This is just about all we can do. We could keep this
9246 location on the global list, and try to remove it next
9247 time, but there's no particular reason why we will
9250 Note that at this point, old_loc->owner is still valid,
9251 as delete_breakpoint frees the breakpoint only
9252 after calling us. */
9253 printf_filtered (_("warning: Error removing breakpoint %d\n"),
9254 old_loc
->owner
->number
);
9262 if (removed
&& non_stop
9263 && breakpoint_address_is_meaningful (old_loc
->owner
)
9264 && !is_hardware_watchpoint (old_loc
->owner
))
9266 /* This location was removed from the target. In
9267 non-stop mode, a race condition is possible where
9268 we've removed a breakpoint, but stop events for that
9269 breakpoint are already queued and will arrive later.
9270 We apply an heuristic to be able to distinguish such
9271 SIGTRAPs from other random SIGTRAPs: we keep this
9272 breakpoint location for a bit, and will retire it
9273 after we see some number of events. The theory here
9274 is that reporting of events should, "on the average",
9275 be fair, so after a while we'll see events from all
9276 threads that have anything of interest, and no longer
9277 need to keep this breakpoint location around. We
9278 don't hold locations forever so to reduce chances of
9279 mistaking a non-breakpoint SIGTRAP for a breakpoint
9282 The heuristic failing can be disastrous on
9283 decr_pc_after_break targets.
9285 On decr_pc_after_break targets, like e.g., x86-linux,
9286 if we fail to recognize a late breakpoint SIGTRAP,
9287 because events_till_retirement has reached 0 too
9288 soon, we'll fail to do the PC adjustment, and report
9289 a random SIGTRAP to the user. When the user resumes
9290 the inferior, it will most likely immediately crash
9291 with SIGILL/SIGBUS/SIGSEGV, or worse, get silently
9292 corrupted, because of being resumed e.g., in the
9293 middle of a multi-byte instruction, or skipped a
9294 one-byte instruction. This was actually seen happen
9295 on native x86-linux, and should be less rare on
9296 targets that do not support new thread events, like
9297 remote, due to the heuristic depending on
9300 Mistaking a random SIGTRAP for a breakpoint trap
9301 causes similar symptoms (PC adjustment applied when
9302 it shouldn't), but then again, playing with SIGTRAPs
9303 behind the debugger's back is asking for trouble.
9305 Since hardware watchpoint traps are always
9306 distinguishable from other traps, so we don't need to
9307 apply keep hardware watchpoint moribund locations
9308 around. We simply always ignore hardware watchpoint
9309 traps we can no longer explain. */
9311 old_loc
->events_till_retirement
= 3 * (thread_count () + 1);
9312 old_loc
->owner
= NULL
;
9314 VEC_safe_push (bp_location_p
, moribund_locations
, old_loc
);
9317 free_bp_location (old_loc
);
9321 /* Rescan breakpoints at the same address and section, marking the
9322 first one as "first" and any others as "duplicates". This is so
9323 that the bpt instruction is only inserted once. If we have a
9324 permanent breakpoint at the same place as BPT, make that one the
9325 official one, and the rest as duplicates. Permanent breakpoints
9326 are sorted first for the same address.
9328 Do the same for hardware watchpoints, but also considering the
9329 watchpoint's type (regular/access/read) and length. */
9331 bp_loc_first
= NULL
;
9332 wp_loc_first
= NULL
;
9333 awp_loc_first
= NULL
;
9334 rwp_loc_first
= NULL
;
9335 ALL_BP_LOCATIONS (loc
, locp
)
9337 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
9338 struct breakpoint
*b
= loc
->owner
;
9339 struct bp_location
**loc_first_p
;
9341 if (b
->enable_state
== bp_disabled
9342 || b
->enable_state
== bp_call_disabled
9343 || b
->enable_state
== bp_startup_disabled
9345 || loc
->shlib_disabled
9346 || !breakpoint_address_is_meaningful (b
)
9347 || is_tracepoint (b
))
9350 /* Permanent breakpoint should always be inserted. */
9351 if (b
->enable_state
== bp_permanent
&& ! loc
->inserted
)
9352 internal_error (__FILE__
, __LINE__
,
9353 _("allegedly permanent breakpoint is not "
9354 "actually inserted"));
9356 if (b
->type
== bp_hardware_watchpoint
)
9357 loc_first_p
= &wp_loc_first
;
9358 else if (b
->type
== bp_read_watchpoint
)
9359 loc_first_p
= &rwp_loc_first
;
9360 else if (b
->type
== bp_access_watchpoint
)
9361 loc_first_p
= &awp_loc_first
;
9363 loc_first_p
= &bp_loc_first
;
9365 if (*loc_first_p
== NULL
9366 || (overlay_debugging
&& loc
->section
!= (*loc_first_p
)->section
)
9367 || !breakpoint_locations_match (loc
, *loc_first_p
))
9376 if ((*loc_first_p
)->owner
->enable_state
== bp_permanent
&& loc
->inserted
9377 && b
->enable_state
!= bp_permanent
)
9378 internal_error (__FILE__
, __LINE__
,
9379 _("another breakpoint was inserted on top of "
9380 "a permanent breakpoint"));
9383 if (breakpoints_always_inserted_mode () && should_insert
9384 && (have_live_inferiors ()
9385 || (gdbarch_has_global_breakpoints (target_gdbarch
))))
9386 insert_breakpoint_locations ();
9388 do_cleanups (cleanups
);
9392 breakpoint_retire_moribund (void)
9394 struct bp_location
*loc
;
9397 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
9398 if (--(loc
->events_till_retirement
) == 0)
9400 free_bp_location (loc
);
9401 VEC_unordered_remove (bp_location_p
, moribund_locations
, ix
);
9407 update_global_location_list_nothrow (int inserting
)
9409 struct gdb_exception e
;
9411 TRY_CATCH (e
, RETURN_MASK_ERROR
)
9412 update_global_location_list (inserting
);
9415 /* Clear LOC from a BPS. */
9417 bpstat_remove_bp_location (bpstat bps
, struct bp_location
*loc
)
9421 for (bs
= bps
; bs
; bs
= bs
->next
)
9422 if (bs
->breakpoint_at
== loc
)
9424 bs
->breakpoint_at
= NULL
;
9426 /* bs->commands will be freed later. */
9430 /* Callback for iterate_over_threads. */
9432 bpstat_remove_bp_location_callback (struct thread_info
*th
, void *data
)
9434 struct bp_location
*loc
= data
;
9436 bpstat_remove_bp_location (th
->stop_bpstat
, loc
);
9440 /* Delete a breakpoint and clean up all traces of it in the data
9444 delete_breakpoint (struct breakpoint
*bpt
)
9446 struct breakpoint
*b
;
9448 gdb_assert (bpt
!= NULL
);
9450 /* Has this bp already been deleted? This can happen because multiple
9451 lists can hold pointers to bp's. bpstat lists are especial culprits.
9453 One example of this happening is a watchpoint's scope bp. When the
9454 scope bp triggers, we notice that the watchpoint is out of scope, and
9455 delete it. We also delete its scope bp. But the scope bp is marked
9456 "auto-deleting", and is already on a bpstat. That bpstat is then
9457 checked for auto-deleting bp's, which are deleted.
9459 A real solution to this problem might involve reference counts in bp's,
9460 and/or giving them pointers back to their referencing bpstat's, and
9461 teaching delete_breakpoint to only free a bp's storage when no more
9462 references were extent. A cheaper bandaid was chosen. */
9463 if (bpt
->type
== bp_none
)
9466 /* At least avoid this stale reference until the reference counting of
9467 breakpoints gets resolved. */
9468 if (bpt
->related_breakpoint
!= NULL
)
9470 gdb_assert (bpt
->related_breakpoint
->related_breakpoint
== bpt
);
9471 bpt
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
9472 bpt
->related_breakpoint
->related_breakpoint
= NULL
;
9473 bpt
->related_breakpoint
= NULL
;
9476 observer_notify_breakpoint_deleted (bpt
->number
);
9478 if (breakpoint_chain
== bpt
)
9479 breakpoint_chain
= bpt
->next
;
9484 b
->next
= bpt
->next
;
9488 decref_counted_command_line (&bpt
->commands
);
9489 xfree (bpt
->cond_string
);
9490 xfree (bpt
->cond_exp
);
9491 xfree (bpt
->addr_string
);
9493 xfree (bpt
->exp_string
);
9494 value_free (bpt
->val
);
9495 xfree (bpt
->source_file
);
9496 xfree (bpt
->exec_pathname
);
9497 clean_up_filters (&bpt
->syscalls_to_be_caught
);
9499 /* Now that breakpoint is removed from breakpoint
9500 list, update the global location list. This
9501 will remove locations that used to belong to
9502 this breakpoint. Do this before freeing
9503 the breakpoint itself, since remove_breakpoint
9504 looks at location's owner. It might be better
9505 design to have location completely self-contained,
9506 but it's not the case now. */
9507 update_global_location_list (0);
9510 /* On the chance that someone will soon try again to delete this same
9511 bp, we mark it as deleted before freeing its storage. */
9512 bpt
->type
= bp_none
;
9518 do_delete_breakpoint_cleanup (void *b
)
9520 delete_breakpoint (b
);
9524 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
9526 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
9529 /* A callback for map_breakpoint_numbers that calls
9530 delete_breakpoint. */
9533 do_delete_breakpoint (struct breakpoint
*b
, void *ignore
)
9535 delete_breakpoint (b
);
9539 delete_command (char *arg
, int from_tty
)
9541 struct breakpoint
*b
, *temp
;
9547 int breaks_to_delete
= 0;
9549 /* Delete all breakpoints if no argument.
9550 Do not delete internal or call-dummy breakpoints, these
9551 have to be deleted with an explicit breakpoint number argument. */
9554 if (b
->type
!= bp_call_dummy
9555 && b
->type
!= bp_std_terminate
9556 && b
->type
!= bp_shlib_event
9557 && b
->type
!= bp_jit_event
9558 && b
->type
!= bp_thread_event
9559 && b
->type
!= bp_overlay_event
9560 && b
->type
!= bp_longjmp_master
9561 && b
->type
!= bp_std_terminate_master
9564 breaks_to_delete
= 1;
9569 /* Ask user only if there are some breakpoints to delete. */
9571 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
9573 ALL_BREAKPOINTS_SAFE (b
, temp
)
9575 if (b
->type
!= bp_call_dummy
9576 && b
->type
!= bp_std_terminate
9577 && b
->type
!= bp_shlib_event
9578 && b
->type
!= bp_thread_event
9579 && b
->type
!= bp_jit_event
9580 && b
->type
!= bp_overlay_event
9581 && b
->type
!= bp_longjmp_master
9582 && b
->type
!= bp_std_terminate_master
9584 delete_breakpoint (b
);
9589 map_breakpoint_numbers (arg
, do_delete_breakpoint
, NULL
);
9593 all_locations_are_pending (struct bp_location
*loc
)
9595 for (; loc
; loc
= loc
->next
)
9596 if (!loc
->shlib_disabled
)
9601 /* Subroutine of update_breakpoint_locations to simplify it.
9602 Return non-zero if multiple fns in list LOC have the same name.
9603 Null names are ignored. */
9606 ambiguous_names_p (struct bp_location
*loc
)
9608 struct bp_location
*l
;
9609 htab_t htab
= htab_create_alloc (13, htab_hash_string
,
9610 (int (*) (const void *,
9611 const void *)) streq
,
9612 NULL
, xcalloc
, xfree
);
9614 for (l
= loc
; l
!= NULL
; l
= l
->next
)
9617 const char *name
= l
->function_name
;
9619 /* Allow for some names to be NULL, ignore them. */
9623 slot
= (const char **) htab_find_slot (htab
, (const void *) name
,
9625 /* NOTE: We can assume slot != NULL here because xcalloc never returns
9640 update_breakpoint_locations (struct breakpoint
*b
,
9641 struct symtabs_and_lines sals
)
9645 struct bp_location
*existing_locations
= b
->loc
;
9647 /* If there's no new locations, and all existing locations
9648 are pending, don't do anything. This optimizes
9649 the common case where all locations are in the same
9650 shared library, that was unloaded. We'd like to
9651 retain the location, so that when the library
9652 is loaded again, we don't loose the enabled/disabled
9653 status of the individual locations. */
9654 if (all_locations_are_pending (existing_locations
) && sals
.nelts
== 0)
9659 for (i
= 0; i
< sals
.nelts
; ++i
)
9661 struct bp_location
*new_loc
=
9662 add_location_to_breakpoint (b
, &(sals
.sals
[i
]));
9664 /* Reparse conditions, they might contain references to the
9666 if (b
->cond_string
!= NULL
)
9668 struct gdb_exception e
;
9671 TRY_CATCH (e
, RETURN_MASK_ERROR
)
9673 new_loc
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
),
9678 warning (_("failed to reevaluate condition for breakpoint %d: %s"),
9679 b
->number
, e
.message
);
9680 new_loc
->enabled
= 0;
9684 if (b
->source_file
!= NULL
)
9685 xfree (b
->source_file
);
9686 if (sals
.sals
[i
].symtab
== NULL
)
9687 b
->source_file
= NULL
;
9689 b
->source_file
= xstrdup (sals
.sals
[i
].symtab
->filename
);
9691 if (b
->line_number
== 0)
9692 b
->line_number
= sals
.sals
[i
].line
;
9695 /* Update locations of permanent breakpoints. */
9696 if (b
->enable_state
== bp_permanent
)
9697 make_breakpoint_permanent (b
);
9699 /* If possible, carry over 'disable' status from existing breakpoints. */
9701 struct bp_location
*e
= existing_locations
;
9702 /* If there are multiple breakpoints with the same function name,
9703 e.g. for inline functions, comparing function names won't work.
9704 Instead compare pc addresses; this is just a heuristic as things
9705 may have moved, but in practice it gives the correct answer
9706 often enough until a better solution is found. */
9707 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
9709 for (; e
; e
= e
->next
)
9711 if (!e
->enabled
&& e
->function_name
)
9713 struct bp_location
*l
= b
->loc
;
9714 if (have_ambiguous_names
)
9716 for (; l
; l
= l
->next
)
9717 if (breakpoint_address_match (e
->pspace
->aspace
, e
->address
,
9718 l
->pspace
->aspace
, l
->address
))
9726 for (; l
; l
= l
->next
)
9727 if (l
->function_name
9728 && strcmp (e
->function_name
, l
->function_name
) == 0)
9738 update_global_location_list (1);
9742 /* Reset a breakpoint given it's struct breakpoint * BINT.
9743 The value we return ends up being the return value from catch_errors.
9744 Unused in this case. */
9747 breakpoint_re_set_one (void *bint
)
9749 /* get past catch_errs */
9750 struct breakpoint
*b
= (struct breakpoint
*) bint
;
9752 int *not_found_ptr
= ¬_found
;
9753 struct symtabs_and_lines sals
= {0};
9754 struct symtabs_and_lines expanded
= {0};
9756 struct gdb_exception e
;
9757 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
9762 warning (_("attempted to reset apparently deleted breakpoint #%d?"),
9766 case bp_hardware_breakpoint
:
9768 case bp_fast_tracepoint
:
9769 /* Do not attempt to re-set breakpoints disabled during startup. */
9770 if (b
->enable_state
== bp_startup_disabled
)
9773 if (b
->addr_string
== NULL
)
9775 /* Anything without a string can't be re-set. */
9776 delete_breakpoint (b
);
9780 set_language (b
->language
);
9781 input_radix
= b
->input_radix
;
9784 save_current_space_and_thread ();
9785 switch_to_program_space_and_thread (b
->pspace
);
9787 TRY_CATCH (e
, RETURN_MASK_ERROR
)
9789 sals
= decode_line_1 (&s
, 1, (struct symtab
*) NULL
, 0, (char ***) NULL
,
9794 int not_found_and_ok
= 0;
9795 /* For pending breakpoints, it's expected that parsing
9796 will fail until the right shared library is loaded.
9797 User has already told to create pending breakpoints and
9798 don't need extra messages. If breakpoint is in bp_shlib_disabled
9799 state, then user already saw the message about that breakpoint
9800 being disabled, and don't want to see more errors. */
9802 && (b
->condition_not_parsed
9803 || (b
->loc
&& b
->loc
->shlib_disabled
)
9804 || b
->enable_state
== bp_disabled
))
9805 not_found_and_ok
= 1;
9807 if (!not_found_and_ok
)
9809 /* We surely don't want to warn about the same breakpoint
9810 10 times. One solution, implemented here, is disable
9811 the breakpoint on error. Another solution would be to
9812 have separate 'warning emitted' flag. Since this
9813 happens only when a binary has changed, I don't know
9814 which approach is better. */
9815 b
->enable_state
= bp_disabled
;
9816 throw_exception (e
);
9822 gdb_assert (sals
.nelts
== 1);
9824 resolve_sal_pc (&sals
.sals
[0]);
9825 if (b
->condition_not_parsed
&& s
&& s
[0])
9827 char *cond_string
= 0;
9831 find_condition_and_thread (s
, sals
.sals
[0].pc
,
9832 &cond_string
, &thread
, &task
);
9834 b
->cond_string
= cond_string
;
9837 b
->condition_not_parsed
= 0;
9840 expanded
= expand_line_sal_maybe (sals
.sals
[0]);
9843 make_cleanup (xfree
, sals
.sals
);
9844 update_breakpoint_locations (b
, expanded
);
9848 case bp_hardware_watchpoint
:
9849 case bp_read_watchpoint
:
9850 case bp_access_watchpoint
:
9851 /* Watchpoint can be either on expression using entirely global variables,
9852 or it can be on local variables.
9854 Watchpoints of the first kind are never auto-deleted, and even persist
9855 across program restarts. Since they can use variables from shared
9856 libraries, we need to reparse expression as libraries are loaded
9859 Watchpoints on local variables can also change meaning as result
9860 of solib event. For example, if a watchpoint uses both a local and
9861 a global variables in expression, it's a local watchpoint, but
9862 unloading of a shared library will make the expression invalid.
9863 This is not a very common use case, but we still re-evaluate
9864 expression, to avoid surprises to the user.
9866 Note that for local watchpoints, we re-evaluate it only if
9867 watchpoints frame id is still valid. If it's not, it means
9868 the watchpoint is out of scope and will be deleted soon. In fact,
9869 I'm not sure we'll ever be called in this case.
9871 If a local watchpoint's frame id is still valid, then
9872 b->exp_valid_block is likewise valid, and we can safely use it.
9874 Don't do anything about disabled watchpoints, since they will
9875 be reevaluated again when enabled. */
9876 update_watchpoint (b
, 1 /* reparse */);
9878 /* We needn't really do anything to reset these, since the mask
9879 that requests them is unaffected by e.g., new libraries being
9885 printf_filtered (_("Deleting unknown breakpoint type %d\n"), b
->type
);
9887 /* Delete overlay event and longjmp master breakpoints; they will be
9888 reset later by breakpoint_re_set. */
9889 case bp_overlay_event
:
9890 case bp_longjmp_master
:
9891 case bp_std_terminate_master
:
9892 delete_breakpoint (b
);
9895 /* This breakpoint is special, it's set up when the inferior
9896 starts and we really don't want to touch it. */
9897 case bp_shlib_event
:
9899 /* Like bp_shlib_event, this breakpoint type is special.
9900 Once it is set up, we do not want to touch it. */
9901 case bp_thread_event
:
9903 /* Keep temporary breakpoints, which can be encountered when we step
9904 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
9905 Otherwise these should have been blown away via the cleanup chain
9906 or by breakpoint_init_inferior when we rerun the executable. */
9909 case bp_watchpoint_scope
:
9911 case bp_std_terminate
:
9912 case bp_step_resume
:
9914 case bp_longjmp_resume
:
9919 do_cleanups (cleanups
);
9923 /* Re-set all breakpoints after symbols have been re-loaded. */
9925 breakpoint_re_set (void)
9927 struct breakpoint
*b
, *temp
;
9928 enum language save_language
;
9929 int save_input_radix
;
9930 struct cleanup
*old_chain
;
9932 save_language
= current_language
->la_language
;
9933 save_input_radix
= input_radix
;
9934 old_chain
= save_current_program_space ();
9936 ALL_BREAKPOINTS_SAFE (b
, temp
)
9938 /* Format possible error msg */
9939 char *message
= xstrprintf ("Error in re-setting breakpoint %d: ",
9941 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
9942 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
9943 do_cleanups (cleanups
);
9945 set_language (save_language
);
9946 input_radix
= save_input_radix
;
9948 jit_breakpoint_re_set ();
9950 do_cleanups (old_chain
);
9952 create_overlay_event_breakpoint ("_ovly_debug_event");
9953 create_longjmp_master_breakpoint ("longjmp");
9954 create_longjmp_master_breakpoint ("_longjmp");
9955 create_longjmp_master_breakpoint ("siglongjmp");
9956 create_longjmp_master_breakpoint ("_siglongjmp");
9957 create_std_terminate_master_breakpoint ("std::terminate()");
9960 /* Reset the thread number of this breakpoint:
9962 - If the breakpoint is for all threads, leave it as-is.
9963 - Else, reset it to the current thread for inferior_ptid. */
9965 breakpoint_re_set_thread (struct breakpoint
*b
)
9967 if (b
->thread
!= -1)
9969 if (in_thread_list (inferior_ptid
))
9970 b
->thread
= pid_to_thread_id (inferior_ptid
);
9972 /* We're being called after following a fork. The new fork is
9973 selected as current, and unless this was a vfork will have a
9974 different program space from the original thread. Reset that
9976 b
->loc
->pspace
= current_program_space
;
9980 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
9981 If from_tty is nonzero, it prints a message to that effect,
9982 which ends with a period (no newline). */
9985 set_ignore_count (int bptnum
, int count
, int from_tty
)
9987 struct breakpoint
*b
;
9993 if (b
->number
== bptnum
)
9995 if (is_tracepoint (b
))
9997 if (from_tty
&& count
!= 0)
9998 printf_filtered (_("Ignore count ignored for tracepoint %d."),
10003 b
->ignore_count
= count
;
10007 printf_filtered (_("Will stop next time breakpoint %d is reached."),
10009 else if (count
== 1)
10010 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
10013 printf_filtered (_("Will ignore next %d crossings of breakpoint %d."),
10016 breakpoints_changed ();
10017 observer_notify_breakpoint_modified (b
->number
);
10021 error (_("No breakpoint number %d."), bptnum
);
10025 make_breakpoint_silent (struct breakpoint
*b
)
10027 /* Silence the breakpoint. */
10031 /* Command to set ignore-count of breakpoint N to COUNT. */
10034 ignore_command (char *args
, int from_tty
)
10040 error_no_arg (_("a breakpoint number"));
10042 num
= get_number (&p
);
10044 error (_("bad breakpoint number: '%s'"), args
);
10046 error (_("Second argument (specified ignore-count) is missing."));
10048 set_ignore_count (num
,
10049 longest_to_int (value_as_long (parse_and_eval (p
))),
10052 printf_filtered ("\n");
10055 /* Call FUNCTION on each of the breakpoints
10056 whose numbers are given in ARGS. */
10059 map_breakpoint_numbers (char *args
, void (*function
) (struct breakpoint
*,
10066 struct breakpoint
*b
, *tmp
;
10070 error_no_arg (_("one or more breakpoint numbers"));
10077 num
= get_number_or_range (&p1
);
10080 warning (_("bad breakpoint number at or near '%s'"), p
);
10084 ALL_BREAKPOINTS_SAFE (b
, tmp
)
10085 if (b
->number
== num
)
10087 struct breakpoint
*related_breakpoint
= b
->related_breakpoint
;
10089 function (b
, data
);
10090 if (related_breakpoint
)
10091 function (related_breakpoint
, data
);
10095 printf_unfiltered (_("No breakpoint number %d.\n"), num
);
10101 static struct bp_location
*
10102 find_location_by_number (char *number
)
10104 char *dot
= strchr (number
, '.');
10108 struct breakpoint
*b
;
10109 struct bp_location
*loc
;
10114 bp_num
= get_number_or_range (&p1
);
10116 error (_("Bad breakpoint number '%s'"), number
);
10118 ALL_BREAKPOINTS (b
)
10119 if (b
->number
== bp_num
)
10124 if (!b
|| b
->number
!= bp_num
)
10125 error (_("Bad breakpoint number '%s'"), number
);
10128 loc_num
= get_number_or_range (&p1
);
10130 error (_("Bad breakpoint location number '%s'"), number
);
10134 for (;loc_num
&& loc
; --loc_num
, loc
= loc
->next
)
10137 error (_("Bad breakpoint location number '%s'"), dot
+1);
10143 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
10144 If from_tty is nonzero, it prints a message to that effect,
10145 which ends with a period (no newline). */
10148 disable_breakpoint (struct breakpoint
*bpt
)
10150 /* Never disable a watchpoint scope breakpoint; we want to
10151 hit them when we leave scope so we can delete both the
10152 watchpoint and its scope breakpoint at that time. */
10153 if (bpt
->type
== bp_watchpoint_scope
)
10156 /* You can't disable permanent breakpoints. */
10157 if (bpt
->enable_state
== bp_permanent
)
10160 bpt
->enable_state
= bp_disabled
;
10162 update_global_location_list (0);
10164 observer_notify_breakpoint_modified (bpt
->number
);
10167 /* A callback for map_breakpoint_numbers that calls
10168 disable_breakpoint. */
10171 do_map_disable_breakpoint (struct breakpoint
*b
, void *ignore
)
10173 disable_breakpoint (b
);
10177 disable_command (char *args
, int from_tty
)
10179 struct breakpoint
*bpt
;
10182 ALL_BREAKPOINTS (bpt
)
10186 warning (_("attempted to disable apparently deleted breakpoint #%d?"),
10189 case bp_breakpoint
:
10190 case bp_tracepoint
:
10191 case bp_fast_tracepoint
:
10192 case bp_catchpoint
:
10193 case bp_hardware_breakpoint
:
10194 case bp_watchpoint
:
10195 case bp_hardware_watchpoint
:
10196 case bp_read_watchpoint
:
10197 case bp_access_watchpoint
:
10198 disable_breakpoint (bpt
);
10202 else if (strchr (args
, '.'))
10204 struct bp_location
*loc
= find_location_by_number (args
);
10207 update_global_location_list (0);
10210 map_breakpoint_numbers (args
, do_map_disable_breakpoint
, NULL
);
10214 do_enable_breakpoint (struct breakpoint
*bpt
, enum bpdisp disposition
)
10216 int target_resources_ok
;
10218 if (bpt
->type
== bp_hardware_breakpoint
)
10221 i
= hw_breakpoint_used_count ();
10222 target_resources_ok
=
10223 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
10225 if (target_resources_ok
== 0)
10226 error (_("No hardware breakpoint support in the target."));
10227 else if (target_resources_ok
< 0)
10228 error (_("Hardware breakpoints used exceeds limit."));
10231 if (is_watchpoint (bpt
))
10233 struct gdb_exception e
;
10235 TRY_CATCH (e
, RETURN_MASK_ALL
)
10237 update_watchpoint (bpt
, 1 /* reparse */);
10241 exception_fprintf (gdb_stderr
, e
, _("Cannot enable watchpoint %d: "),
10247 if (bpt
->enable_state
!= bp_permanent
)
10248 bpt
->enable_state
= bp_enabled
;
10249 bpt
->disposition
= disposition
;
10250 update_global_location_list (1);
10251 breakpoints_changed ();
10253 observer_notify_breakpoint_modified (bpt
->number
);
10258 enable_breakpoint (struct breakpoint
*bpt
)
10260 do_enable_breakpoint (bpt
, bpt
->disposition
);
10263 /* A callback for map_breakpoint_numbers that calls
10264 enable_breakpoint. */
10267 do_map_enable_breakpoint (struct breakpoint
*b
, void *ignore
)
10269 enable_breakpoint (b
);
10272 /* The enable command enables the specified breakpoints (or all defined
10273 breakpoints) so they once again become (or continue to be) effective
10274 in stopping the inferior. */
10277 enable_command (char *args
, int from_tty
)
10279 struct breakpoint
*bpt
;
10282 ALL_BREAKPOINTS (bpt
)
10286 warning (_("attempted to enable apparently deleted breakpoint #%d?"),
10289 case bp_breakpoint
:
10290 case bp_tracepoint
:
10291 case bp_fast_tracepoint
:
10292 case bp_catchpoint
:
10293 case bp_hardware_breakpoint
:
10294 case bp_watchpoint
:
10295 case bp_hardware_watchpoint
:
10296 case bp_read_watchpoint
:
10297 case bp_access_watchpoint
:
10298 enable_breakpoint (bpt
);
10302 else if (strchr (args
, '.'))
10304 struct bp_location
*loc
= find_location_by_number (args
);
10307 update_global_location_list (1);
10310 map_breakpoint_numbers (args
, do_map_enable_breakpoint
, NULL
);
10314 enable_once_breakpoint (struct breakpoint
*bpt
, void *ignore
)
10316 do_enable_breakpoint (bpt
, disp_disable
);
10320 enable_once_command (char *args
, int from_tty
)
10322 map_breakpoint_numbers (args
, enable_once_breakpoint
, NULL
);
10326 enable_delete_breakpoint (struct breakpoint
*bpt
, void *ignore
)
10328 do_enable_breakpoint (bpt
, disp_del
);
10332 enable_delete_command (char *args
, int from_tty
)
10334 map_breakpoint_numbers (args
, enable_delete_breakpoint
, NULL
);
10338 set_breakpoint_cmd (char *args
, int from_tty
)
10343 show_breakpoint_cmd (char *args
, int from_tty
)
10347 /* Invalidate last known value of any hardware watchpoint if
10348 the memory which that value represents has been written to by
10352 invalidate_bp_value_on_memory_change (CORE_ADDR addr
, int len
,
10353 const bfd_byte
*data
)
10355 struct breakpoint
*bp
;
10357 ALL_BREAKPOINTS (bp
)
10358 if (bp
->enable_state
== bp_enabled
10359 && bp
->type
== bp_hardware_watchpoint
10360 && bp
->val_valid
&& bp
->val
)
10362 struct bp_location
*loc
;
10364 for (loc
= bp
->loc
; loc
!= NULL
; loc
= loc
->next
)
10365 if (loc
->loc_type
== bp_loc_hardware_watchpoint
10366 && loc
->address
+ loc
->length
> addr
10367 && addr
+ len
> loc
->address
)
10369 value_free (bp
->val
);
10376 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
10378 struct symtabs_and_lines
10379 decode_line_spec_1 (char *string
, int funfirstline
)
10381 struct symtabs_and_lines sals
;
10384 error (_("Empty line specification."));
10385 if (default_breakpoint_valid
)
10386 sals
= decode_line_1 (&string
, funfirstline
,
10387 default_breakpoint_symtab
,
10388 default_breakpoint_line
,
10389 (char ***) NULL
, NULL
);
10391 sals
= decode_line_1 (&string
, funfirstline
,
10392 (struct symtab
*) NULL
, 0, (char ***) NULL
, NULL
);
10394 error (_("Junk at end of line specification: %s"), string
);
10398 /* Create and insert a raw software breakpoint at PC. Return an
10399 identifier, which should be used to remove the breakpoint later.
10400 In general, places which call this should be using something on the
10401 breakpoint chain instead; this function should be eliminated
10405 deprecated_insert_raw_breakpoint (struct gdbarch
*gdbarch
,
10406 struct address_space
*aspace
, CORE_ADDR pc
)
10408 struct bp_target_info
*bp_tgt
;
10410 bp_tgt
= XZALLOC (struct bp_target_info
);
10412 bp_tgt
->placed_address_space
= aspace
;
10413 bp_tgt
->placed_address
= pc
;
10415 if (target_insert_breakpoint (gdbarch
, bp_tgt
) != 0)
10417 /* Could not insert the breakpoint. */
10425 /* Remove a breakpoint BP inserted by deprecated_insert_raw_breakpoint. */
10428 deprecated_remove_raw_breakpoint (struct gdbarch
*gdbarch
, void *bp
)
10430 struct bp_target_info
*bp_tgt
= bp
;
10433 ret
= target_remove_breakpoint (gdbarch
, bp_tgt
);
10439 /* One (or perhaps two) breakpoints used for software single stepping. */
10441 static void *single_step_breakpoints
[2];
10442 static struct gdbarch
*single_step_gdbarch
[2];
10444 /* Create and insert a breakpoint for software single step. */
10447 insert_single_step_breakpoint (struct gdbarch
*gdbarch
,
10448 struct address_space
*aspace
, CORE_ADDR next_pc
)
10452 if (single_step_breakpoints
[0] == NULL
)
10454 bpt_p
= &single_step_breakpoints
[0];
10455 single_step_gdbarch
[0] = gdbarch
;
10459 gdb_assert (single_step_breakpoints
[1] == NULL
);
10460 bpt_p
= &single_step_breakpoints
[1];
10461 single_step_gdbarch
[1] = gdbarch
;
10464 /* NOTE drow/2006-04-11: A future improvement to this function would be
10465 to only create the breakpoints once, and actually put them on the
10466 breakpoint chain. That would let us use set_raw_breakpoint. We could
10467 adjust the addresses each time they were needed. Doing this requires
10468 corresponding changes elsewhere where single step breakpoints are
10469 handled, however. So, for now, we use this. */
10471 *bpt_p
= deprecated_insert_raw_breakpoint (gdbarch
, aspace
, next_pc
);
10472 if (*bpt_p
== NULL
)
10473 error (_("Could not insert single-step breakpoint at %s"),
10474 paddress (gdbarch
, next_pc
));
10477 /* Remove and delete any breakpoints used for software single step. */
10480 remove_single_step_breakpoints (void)
10482 gdb_assert (single_step_breakpoints
[0] != NULL
);
10484 /* See insert_single_step_breakpoint for more about this deprecated
10486 deprecated_remove_raw_breakpoint (single_step_gdbarch
[0],
10487 single_step_breakpoints
[0]);
10488 single_step_gdbarch
[0] = NULL
;
10489 single_step_breakpoints
[0] = NULL
;
10491 if (single_step_breakpoints
[1] != NULL
)
10493 deprecated_remove_raw_breakpoint (single_step_gdbarch
[1],
10494 single_step_breakpoints
[1]);
10495 single_step_gdbarch
[1] = NULL
;
10496 single_step_breakpoints
[1] = NULL
;
10500 /* Delete software single step breakpoints without removing them from
10501 the inferior. This is intended to be used if the inferior's address
10502 space where they were inserted is already gone, e.g. after exit or
10506 cancel_single_step_breakpoints (void)
10510 for (i
= 0; i
< 2; i
++)
10511 if (single_step_breakpoints
[i
])
10513 xfree (single_step_breakpoints
[i
]);
10514 single_step_breakpoints
[i
] = NULL
;
10515 single_step_gdbarch
[i
] = NULL
;
10519 /* Detach software single-step breakpoints from INFERIOR_PTID without
10523 detach_single_step_breakpoints (void)
10527 for (i
= 0; i
< 2; i
++)
10528 if (single_step_breakpoints
[i
])
10529 target_remove_breakpoint (single_step_gdbarch
[i
],
10530 single_step_breakpoints
[i
]);
10533 /* Check whether a software single-step breakpoint is inserted at PC. */
10536 single_step_breakpoint_inserted_here_p (struct address_space
*aspace
,
10541 for (i
= 0; i
< 2; i
++)
10543 struct bp_target_info
*bp_tgt
= single_step_breakpoints
[i
];
10545 && breakpoint_address_match (bp_tgt
->placed_address_space
,
10546 bp_tgt
->placed_address
,
10554 /* Returns 0 if 'bp' is NOT a syscall catchpoint,
10555 non-zero otherwise. */
10557 is_syscall_catchpoint_enabled (struct breakpoint
*bp
)
10559 if (syscall_catchpoint_p (bp
)
10560 && bp
->enable_state
!= bp_disabled
10561 && bp
->enable_state
!= bp_call_disabled
)
10568 catch_syscall_enabled (void)
10570 struct inferior
*inf
= current_inferior ();
10572 return inf
->total_syscalls_count
!= 0;
10576 catching_syscall_number (int syscall_number
)
10578 struct breakpoint
*bp
;
10580 ALL_BREAKPOINTS (bp
)
10581 if (is_syscall_catchpoint_enabled (bp
))
10583 if (bp
->syscalls_to_be_caught
)
10587 VEC_iterate (int, bp
->syscalls_to_be_caught
, i
, iter
);
10589 if (syscall_number
== iter
)
10599 /* Complete syscall names. Used by "catch syscall". */
10601 catch_syscall_completer (struct cmd_list_element
*cmd
,
10602 char *text
, char *word
)
10604 const char **list
= get_syscall_names ();
10606 return (list
== NULL
) ? NULL
: complete_on_enum (list
, text
, word
);
10609 /* Tracepoint-specific operations. */
10611 /* Set tracepoint count to NUM. */
10613 set_tracepoint_count (int num
)
10615 tracepoint_count
= num
;
10616 set_internalvar_integer (lookup_internalvar ("tpnum"), num
);
10620 trace_command (char *arg
, int from_tty
)
10622 if (create_breakpoint (get_current_arch (),
10624 NULL
, 0, 1 /* parse arg */,
10625 0 /* tempflag */, 0 /* hardwareflag */,
10627 0 /* Ignore count */,
10628 pending_break_support
,
10632 set_tracepoint_count (breakpoint_count
);
10636 ftrace_command (char *arg
, int from_tty
)
10638 if (create_breakpoint (get_current_arch (),
10640 NULL
, 0, 1 /* parse arg */,
10641 0 /* tempflag */, 1 /* hardwareflag */,
10643 0 /* Ignore count */,
10644 pending_break_support
,
10648 set_tracepoint_count (breakpoint_count
);
10651 /* Set up a fake reader function that gets command lines from a linked
10652 list that was acquired during tracepoint uploading. */
10654 static struct uploaded_tp
*this_utp
;
10655 static int next_cmd
;
10658 read_uploaded_action (void)
10662 VEC_iterate (char_ptr
, this_utp
->cmd_strings
, next_cmd
, rslt
);
10669 /* Given information about a tracepoint as recorded on a target (which
10670 can be either a live system or a trace file), attempt to create an
10671 equivalent GDB tracepoint. This is not a reliable process, since
10672 the target does not necessarily have all the information used when
10673 the tracepoint was originally defined. */
10675 struct breakpoint
*
10676 create_tracepoint_from_upload (struct uploaded_tp
*utp
)
10678 char *addr_str
, small_buf
[100];
10679 struct breakpoint
*tp
;
10681 if (utp
->at_string
)
10682 addr_str
= utp
->at_string
;
10685 /* In the absence of a source location, fall back to raw
10686 address. Since there is no way to confirm that the address
10687 means the same thing as when the trace was started, warn the
10689 warning (_("Uploaded tracepoint %d has no source location, using raw address"),
10691 sprintf (small_buf
, "*%s", hex_string (utp
->addr
));
10692 addr_str
= small_buf
;
10695 /* There's not much we can do with a sequence of bytecodes. */
10696 if (utp
->cond
&& !utp
->cond_string
)
10697 warning (_("Uploaded tracepoint %d condition has no source form, ignoring it"),
10700 if (!create_breakpoint (get_current_arch (),
10702 utp
->cond_string
, -1, 0 /* parse cond/thread */,
10704 (utp
->type
== bp_fast_tracepoint
) /* hardwareflag */,
10706 0 /* Ignore count */,
10707 pending_break_support
,
10710 utp
->enabled
/* enabled */))
10713 set_tracepoint_count (breakpoint_count
);
10715 /* Get the tracepoint we just created. */
10716 tp
= get_tracepoint (tracepoint_count
);
10717 gdb_assert (tp
!= NULL
);
10721 sprintf (small_buf
, "%d %d", utp
->pass
, tp
->number
);
10723 trace_pass_command (small_buf
, 0);
10726 /* If we have uploaded versions of the original commands, set up a
10727 special-purpose "reader" function and call the usual command line
10728 reader, then pass the result to the breakpoint command-setting
10730 if (!VEC_empty (char_ptr
, utp
->cmd_strings
))
10732 struct command_line
*cmd_list
;
10737 cmd_list
= read_command_lines_1 (read_uploaded_action
, 1, NULL
, NULL
);
10739 breakpoint_set_commands (tp
, cmd_list
);
10741 else if (!VEC_empty (char_ptr
, utp
->actions
)
10742 || !VEC_empty (char_ptr
, utp
->step_actions
))
10743 warning (_("Uploaded tracepoint %d actions have no source form, ignoring them"),
10749 /* Print information on tracepoint number TPNUM_EXP, or all if
10753 tracepoints_info (char *tpnum_exp
, int from_tty
)
10755 int tpnum
= -1, num_printed
;
10758 tpnum
= parse_and_eval_long (tpnum_exp
);
10760 num_printed
= breakpoint_1 (tpnum
, 0, is_tracepoint
);
10762 if (num_printed
== 0)
10765 ui_out_message (uiout
, 0, "No tracepoints.\n");
10767 ui_out_message (uiout
, 0, "No tracepoint number %d.\n", tpnum
);
10770 default_collect_info ();
10773 /* The 'enable trace' command enables tracepoints.
10774 Not supported by all targets. */
10776 enable_trace_command (char *args
, int from_tty
)
10778 enable_command (args
, from_tty
);
10781 /* The 'disable trace' command disables tracepoints.
10782 Not supported by all targets. */
10784 disable_trace_command (char *args
, int from_tty
)
10786 disable_command (args
, from_tty
);
10789 /* Remove a tracepoint (or all if no argument) */
10791 delete_trace_command (char *arg
, int from_tty
)
10793 struct breakpoint
*b
, *temp
;
10799 int breaks_to_delete
= 0;
10801 /* Delete all breakpoints if no argument.
10802 Do not delete internal or call-dummy breakpoints, these
10803 have to be deleted with an explicit breakpoint number argument. */
10804 ALL_TRACEPOINTS (b
)
10806 if (b
->number
>= 0)
10808 breaks_to_delete
= 1;
10813 /* Ask user only if there are some breakpoints to delete. */
10815 || (breaks_to_delete
&& query (_("Delete all tracepoints? "))))
10817 ALL_BREAKPOINTS_SAFE (b
, temp
)
10819 if (is_tracepoint (b
)
10821 delete_breakpoint (b
);
10826 map_breakpoint_numbers (arg
, do_delete_breakpoint
, NULL
);
10829 /* Set passcount for tracepoint.
10831 First command argument is passcount, second is tracepoint number.
10832 If tracepoint number omitted, apply to most recently defined.
10833 Also accepts special argument "all". */
10836 trace_pass_command (char *args
, int from_tty
)
10838 struct breakpoint
*t1
= (struct breakpoint
*) -1, *t2
;
10839 unsigned int count
;
10842 if (args
== 0 || *args
== 0)
10843 error (_("passcount command requires an argument (count + optional TP num)"));
10845 count
= strtoul (args
, &args
, 10); /* Count comes first, then TP num. */
10847 while (*args
&& isspace ((int) *args
))
10850 if (*args
&& strncasecmp (args
, "all", 3) == 0)
10852 args
+= 3; /* Skip special argument "all". */
10855 error (_("Junk at end of arguments."));
10858 t1
= get_tracepoint_by_number (&args
, 1, 1);
10864 ALL_TRACEPOINTS (t2
)
10865 if (t1
== (struct breakpoint
*) -1 || t1
== t2
)
10867 t2
->pass_count
= count
;
10868 observer_notify_tracepoint_modified (t2
->number
);
10870 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
10871 t2
->number
, count
);
10873 if (! all
&& *args
)
10874 t1
= get_tracepoint_by_number (&args
, 1, 0);
10880 struct breakpoint
*
10881 get_tracepoint (int num
)
10883 struct breakpoint
*t
;
10885 ALL_TRACEPOINTS (t
)
10886 if (t
->number
== num
)
10892 /* Find the tracepoint with the given target-side number (which may be
10893 different from the tracepoint number after disconnecting and
10896 struct breakpoint
*
10897 get_tracepoint_by_number_on_target (int num
)
10899 struct breakpoint
*t
;
10901 ALL_TRACEPOINTS (t
)
10902 if (t
->number_on_target
== num
)
10908 /* Utility: parse a tracepoint number and look it up in the list.
10909 If MULTI_P is true, there might be a range of tracepoints in ARG.
10910 if OPTIONAL_P is true, then if the argument is missing, the most
10911 recent tracepoint (tracepoint_count) is returned. */
10912 struct breakpoint
*
10913 get_tracepoint_by_number (char **arg
, int multi_p
, int optional_p
)
10915 extern int tracepoint_count
;
10916 struct breakpoint
*t
;
10918 char *instring
= arg
== NULL
? NULL
: *arg
;
10920 if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
10923 tpnum
= tracepoint_count
;
10925 error_no_arg (_("tracepoint number"));
10928 tpnum
= multi_p
? get_number_or_range (arg
) : get_number (arg
);
10932 if (instring
&& *instring
)
10933 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
10936 printf_filtered (_("Tracepoint argument missing and no previous tracepoint\n"));
10940 ALL_TRACEPOINTS (t
)
10941 if (t
->number
== tpnum
)
10946 /* FIXME: if we are in the middle of a range we don't want to give
10947 a message. The current interface to get_number_or_range doesn't
10948 allow us to discover this. */
10949 printf_unfiltered ("No tracepoint number %d.\n", tpnum
);
10953 /* Save information on user settable breakpoints (watchpoints, etc) to
10954 a new script file named FILENAME. If FILTER is non-NULL, call it
10955 on each breakpoint and only include the ones for which it returns
10959 save_breakpoints (char *filename
, int from_tty
,
10960 int (*filter
) (const struct breakpoint
*))
10962 struct breakpoint
*tp
;
10965 struct cleanup
*cleanup
;
10966 struct ui_file
*fp
;
10967 int extra_trace_bits
= 0;
10969 if (filename
== 0 || *filename
== 0)
10970 error (_("Argument required (file name in which to save)"));
10972 /* See if we have anything to save. */
10973 ALL_BREAKPOINTS (tp
)
10975 /* Skip internal and momentary breakpoints. */
10976 if (!user_settable_breakpoint (tp
))
10979 /* If we have a filter, only save the breakpoints it accepts. */
10980 if (filter
&& !filter (tp
))
10985 if (is_tracepoint (tp
))
10987 extra_trace_bits
= 1;
10989 /* We can stop searching. */
10996 warning (_("Nothing to save."));
11000 pathname
= tilde_expand (filename
);
11001 cleanup
= make_cleanup (xfree
, pathname
);
11002 fp
= gdb_fopen (pathname
, "w");
11004 error (_("Unable to open file '%s' for saving (%s)"),
11005 filename
, safe_strerror (errno
));
11006 make_cleanup_ui_file_delete (fp
);
11008 if (extra_trace_bits
)
11009 save_trace_state_variables (fp
);
11011 ALL_BREAKPOINTS (tp
)
11013 /* Skip internal and momentary breakpoints. */
11014 if (!user_settable_breakpoint (tp
))
11017 /* If we have a filter, only save the breakpoints it accepts. */
11018 if (filter
&& !filter (tp
))
11021 if (tp
->ops
!= NULL
)
11022 (tp
->ops
->print_recreate
) (tp
, fp
);
11025 if (tp
->type
== bp_fast_tracepoint
)
11026 fprintf_unfiltered (fp
, "ftrace");
11027 else if (tp
->type
== bp_tracepoint
)
11028 fprintf_unfiltered (fp
, "trace");
11029 else if (tp
->type
== bp_breakpoint
&& tp
->disposition
== disp_del
)
11030 fprintf_unfiltered (fp
, "tbreak");
11031 else if (tp
->type
== bp_breakpoint
)
11032 fprintf_unfiltered (fp
, "break");
11033 else if (tp
->type
== bp_hardware_breakpoint
11034 && tp
->disposition
== disp_del
)
11035 fprintf_unfiltered (fp
, "thbreak");
11036 else if (tp
->type
== bp_hardware_breakpoint
)
11037 fprintf_unfiltered (fp
, "hbreak");
11038 else if (tp
->type
== bp_watchpoint
)
11039 fprintf_unfiltered (fp
, "watch");
11040 else if (tp
->type
== bp_hardware_watchpoint
)
11041 fprintf_unfiltered (fp
, "watch");
11042 else if (tp
->type
== bp_read_watchpoint
)
11043 fprintf_unfiltered (fp
, "rwatch");
11044 else if (tp
->type
== bp_access_watchpoint
)
11045 fprintf_unfiltered (fp
, "awatch");
11047 internal_error (__FILE__
, __LINE__
,
11048 _("unhandled breakpoint type %d"), (int) tp
->type
);
11050 if (tp
->exp_string
)
11051 fprintf_unfiltered (fp
, " %s", tp
->exp_string
);
11052 else if (tp
->addr_string
)
11053 fprintf_unfiltered (fp
, " %s", tp
->addr_string
);
11058 sprintf_vma (tmp
, tp
->loc
->address
);
11059 fprintf_unfiltered (fp
, " *0x%s", tmp
);
11063 if (tp
->thread
!= -1)
11064 fprintf_unfiltered (fp
, " thread %d", tp
->thread
);
11067 fprintf_unfiltered (fp
, " task %d", tp
->task
);
11069 fprintf_unfiltered (fp
, "\n");
11071 /* Note, we can't rely on tp->number for anything, as we can't
11072 assume the recreated breakpoint numbers will match. Use $bpnum
11075 if (tp
->cond_string
)
11076 fprintf_unfiltered (fp
, " condition $bpnum %s\n", tp
->cond_string
);
11078 if (tp
->ignore_count
)
11079 fprintf_unfiltered (fp
, " ignore $bpnum %d\n", tp
->ignore_count
);
11081 if (tp
->pass_count
)
11082 fprintf_unfiltered (fp
, " passcount %d\n", tp
->pass_count
);
11086 volatile struct gdb_exception ex
;
11088 fprintf_unfiltered (fp
, " commands\n");
11090 ui_out_redirect (uiout
, fp
);
11091 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
11093 print_command_lines (uiout
, tp
->commands
->commands
, 2);
11095 ui_out_redirect (uiout
, NULL
);
11098 throw_exception (ex
);
11100 fprintf_unfiltered (fp
, " end\n");
11103 if (tp
->enable_state
== bp_disabled
)
11104 fprintf_unfiltered (fp
, "disable\n");
11106 /* If this is a multi-location breakpoint, check if the locations
11107 should be individually disabled. Watchpoint locations are
11108 special, and not user visible. */
11109 if (!is_watchpoint (tp
) && tp
->loc
&& tp
->loc
->next
)
11111 struct bp_location
*loc
;
11114 for (loc
= tp
->loc
; loc
!= NULL
; loc
= loc
->next
, n
++)
11116 fprintf_unfiltered (fp
, "disable $bpnum.%d\n", n
);
11120 if (extra_trace_bits
&& *default_collect
)
11121 fprintf_unfiltered (fp
, "set default-collect %s\n", default_collect
);
11123 do_cleanups (cleanup
);
11125 printf_filtered (_("Saved to file '%s'.\n"), filename
);
11128 /* The `save breakpoints' command. */
11131 save_breakpoints_command (char *args
, int from_tty
)
11133 save_breakpoints (args
, from_tty
, NULL
);
11136 /* The `save tracepoints' command. */
11139 save_tracepoints_command (char *args
, int from_tty
)
11141 save_breakpoints (args
, from_tty
, is_tracepoint
);
11144 /* Create a vector of all tracepoints. */
11146 VEC(breakpoint_p
) *
11149 VEC(breakpoint_p
) *tp_vec
= 0;
11150 struct breakpoint
*tp
;
11152 ALL_TRACEPOINTS (tp
)
11154 VEC_safe_push (breakpoint_p
, tp_vec
, tp
);
11161 /* This help string is used for the break, hbreak, tbreak and thbreak commands.
11162 It is defined as a macro to prevent duplication.
11163 COMMAND should be a string constant containing the name of the command. */
11164 #define BREAK_ARGS_HELP(command) \
11165 command" [LOCATION] [thread THREADNUM] [if CONDITION]\n\
11166 LOCATION may be a line number, function name, or \"*\" and an address.\n\
11167 If a line number is specified, break at start of code for that line.\n\
11168 If a function is specified, break at start of code for that function.\n\
11169 If an address is specified, break at that exact address.\n\
11170 With no LOCATION, uses current execution address of selected stack frame.\n\
11171 This is useful for breaking on return to a stack frame.\n\
11173 THREADNUM is the number from \"info threads\".\n\
11174 CONDITION is a boolean expression.\n\
11176 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
11178 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
11180 /* List of subcommands for "catch". */
11181 static struct cmd_list_element
*catch_cmdlist
;
11183 /* List of subcommands for "tcatch". */
11184 static struct cmd_list_element
*tcatch_cmdlist
;
11186 /* Like add_cmd, but add the command to both the "catch" and "tcatch"
11187 lists, and pass some additional user data to the command function. */
11189 add_catch_command (char *name
, char *docstring
,
11190 void (*sfunc
) (char *args
, int from_tty
,
11191 struct cmd_list_element
*command
),
11192 char **(*completer
) (struct cmd_list_element
*cmd
,
11193 char *text
, char *word
),
11194 void *user_data_catch
,
11195 void *user_data_tcatch
)
11197 struct cmd_list_element
*command
;
11199 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
11201 set_cmd_sfunc (command
, sfunc
);
11202 set_cmd_context (command
, user_data_catch
);
11203 set_cmd_completer (command
, completer
);
11205 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
11207 set_cmd_sfunc (command
, sfunc
);
11208 set_cmd_context (command
, user_data_tcatch
);
11209 set_cmd_completer (command
, completer
);
11213 clear_syscall_counts (struct inferior
*inf
)
11215 inf
->total_syscalls_count
= 0;
11216 inf
->any_syscall_count
= 0;
11217 VEC_free (int, inf
->syscalls_counts
);
11221 save_command (char *arg
, int from_tty
)
11223 printf_unfiltered (_("\
11224 \"save\" must be followed by the name of a save subcommand.\n"));
11225 help_list (save_cmdlist
, "save ", -1, gdb_stdout
);
11229 _initialize_breakpoint (void)
11231 struct cmd_list_element
*c
;
11233 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
11234 observer_attach_inferior_exit (clear_syscall_counts
);
11235 observer_attach_memory_changed (invalidate_bp_value_on_memory_change
);
11237 breakpoint_chain
= 0;
11238 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
11239 before a breakpoint is set. */
11240 breakpoint_count
= 0;
11242 tracepoint_count
= 0;
11244 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
11245 Set ignore-count of breakpoint number N to COUNT.\n\
11246 Usage is `ignore N COUNT'."));
11248 add_com_alias ("bc", "ignore", class_breakpoint
, 1);
11250 add_com ("commands", class_breakpoint
, commands_command
, _("\
11251 Set commands to be executed when a breakpoint is hit.\n\
11252 Give breakpoint number as argument after \"commands\".\n\
11253 With no argument, the targeted breakpoint is the last one set.\n\
11254 The commands themselves follow starting on the next line.\n\
11255 Type a line containing \"end\" to indicate the end of them.\n\
11256 Give \"silent\" as the first line to make the breakpoint silent;\n\
11257 then no output is printed when it is hit, except what the commands print."));
11259 add_com ("condition", class_breakpoint
, condition_command
, _("\
11260 Specify breakpoint number N to break only if COND is true.\n\
11261 Usage is `condition N COND', where N is an integer and COND is an\n\
11262 expression to be evaluated whenever breakpoint N is reached."));
11264 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
11265 Set a temporary breakpoint.\n\
11266 Like \"break\" except the breakpoint is only temporary,\n\
11267 so it will be deleted when hit. Equivalent to \"break\" followed\n\
11268 by using \"enable delete\" on the breakpoint number.\n\
11270 BREAK_ARGS_HELP ("tbreak")));
11271 set_cmd_completer (c
, location_completer
);
11273 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
11274 Set a hardware assisted breakpoint.\n\
11275 Like \"break\" except the breakpoint requires hardware support,\n\
11276 some target hardware may not have this support.\n\
11278 BREAK_ARGS_HELP ("hbreak")));
11279 set_cmd_completer (c
, location_completer
);
11281 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
11282 Set a temporary hardware assisted breakpoint.\n\
11283 Like \"hbreak\" except the breakpoint is only temporary,\n\
11284 so it will be deleted when hit.\n\
11286 BREAK_ARGS_HELP ("thbreak")));
11287 set_cmd_completer (c
, location_completer
);
11289 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
11290 Enable some breakpoints.\n\
11291 Give breakpoint numbers (separated by spaces) as arguments.\n\
11292 With no subcommand, breakpoints are enabled until you command otherwise.\n\
11293 This is used to cancel the effect of the \"disable\" command.\n\
11294 With a subcommand you can enable temporarily."),
11295 &enablelist
, "enable ", 1, &cmdlist
);
11297 add_com ("ab", class_breakpoint
, enable_command
, _("\
11298 Enable some breakpoints.\n\
11299 Give breakpoint numbers (separated by spaces) as arguments.\n\
11300 With no subcommand, breakpoints are enabled until you command otherwise.\n\
11301 This is used to cancel the effect of the \"disable\" command.\n\
11302 With a subcommand you can enable temporarily."));
11304 add_com_alias ("en", "enable", class_breakpoint
, 1);
11306 add_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
11307 Enable some breakpoints.\n\
11308 Give breakpoint numbers (separated by spaces) as arguments.\n\
11309 This is used to cancel the effect of the \"disable\" command.\n\
11310 May be abbreviated to simply \"enable\".\n"),
11311 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
11313 add_cmd ("once", no_class
, enable_once_command
, _("\
11314 Enable breakpoints for one hit. Give breakpoint numbers.\n\
11315 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
11318 add_cmd ("delete", no_class
, enable_delete_command
, _("\
11319 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
11320 If a breakpoint is hit while enabled in this fashion, it is deleted."),
11323 add_cmd ("delete", no_class
, enable_delete_command
, _("\
11324 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
11325 If a breakpoint is hit while enabled in this fashion, it is deleted."),
11328 add_cmd ("once", no_class
, enable_once_command
, _("\
11329 Enable breakpoints for one hit. Give breakpoint numbers.\n\
11330 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
11333 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
11334 Disable some breakpoints.\n\
11335 Arguments are breakpoint numbers with spaces in between.\n\
11336 To disable all breakpoints, give no argument.\n\
11337 A disabled breakpoint is not forgotten, but has no effect until reenabled."),
11338 &disablelist
, "disable ", 1, &cmdlist
);
11339 add_com_alias ("dis", "disable", class_breakpoint
, 1);
11340 add_com_alias ("disa", "disable", class_breakpoint
, 1);
11342 add_com ("sb", class_breakpoint
, disable_command
, _("\
11343 Disable some breakpoints.\n\
11344 Arguments are breakpoint numbers with spaces in between.\n\
11345 To disable all breakpoints, give no argument.\n\
11346 A disabled breakpoint is not forgotten, but has no effect until reenabled."));
11348 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
11349 Disable some breakpoints.\n\
11350 Arguments are breakpoint numbers with spaces in between.\n\
11351 To disable all breakpoints, give no argument.\n\
11352 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
11353 This command may be abbreviated \"disable\"."),
11356 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
11357 Delete some breakpoints or auto-display expressions.\n\
11358 Arguments are breakpoint numbers with spaces in between.\n\
11359 To delete all breakpoints, give no argument.\n\
11361 Also a prefix command for deletion of other GDB objects.\n\
11362 The \"unset\" command is also an alias for \"delete\"."),
11363 &deletelist
, "delete ", 1, &cmdlist
);
11364 add_com_alias ("d", "delete", class_breakpoint
, 1);
11365 add_com_alias ("del", "delete", class_breakpoint
, 1);
11367 add_com ("db", class_breakpoint
, delete_command
, _("\
11368 Delete some breakpoints.\n\
11369 Arguments are breakpoint numbers with spaces in between.\n\
11370 To delete all breakpoints, give no argument.\n"));
11372 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
11373 Delete some breakpoints or auto-display expressions.\n\
11374 Arguments are breakpoint numbers with spaces in between.\n\
11375 To delete all breakpoints, give no argument.\n\
11376 This command may be abbreviated \"delete\"."),
11379 add_com ("clear", class_breakpoint
, clear_command
, _("\
11380 Clear breakpoint at specified line or function.\n\
11381 Argument may be line number, function name, or \"*\" and an address.\n\
11382 If line number is specified, all breakpoints in that line are cleared.\n\
11383 If function is specified, breakpoints at beginning of function are cleared.\n\
11384 If an address is specified, breakpoints at that address are cleared.\n\
11386 With no argument, clears all breakpoints in the line that the selected frame\n\
11387 is executing in.\n\
11389 See also the \"delete\" command which clears breakpoints by number."));
11391 c
= add_com ("break", class_breakpoint
, break_command
, _("\
11392 Set breakpoint at specified line or function.\n"
11393 BREAK_ARGS_HELP ("break")));
11394 set_cmd_completer (c
, location_completer
);
11396 add_com_alias ("b", "break", class_run
, 1);
11397 add_com_alias ("br", "break", class_run
, 1);
11398 add_com_alias ("bre", "break", class_run
, 1);
11399 add_com_alias ("brea", "break", class_run
, 1);
11402 add_com_alias ("ba", "break", class_breakpoint
, 1);
11406 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
11407 Break in function/address or break at a line in the current file."),
11408 &stoplist
, "stop ", 1, &cmdlist
);
11409 add_cmd ("in", class_breakpoint
, stopin_command
,
11410 _("Break in function or address."), &stoplist
);
11411 add_cmd ("at", class_breakpoint
, stopat_command
,
11412 _("Break at a line in the current file."), &stoplist
);
11413 add_com ("status", class_info
, breakpoints_info
, _("\
11414 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
11415 The \"Type\" column indicates one of:\n\
11416 \tbreakpoint - normal breakpoint\n\
11417 \twatchpoint - watchpoint\n\
11418 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
11419 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
11420 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
11421 address and file/line number respectively.\n\
11423 Convenience variable \"$_\" and default examine address for \"x\"\n\
11424 are set to the address of the last breakpoint listed unless the command\n\
11425 is prefixed with \"server \".\n\n\
11426 Convenience variable \"$bpnum\" contains the number of the last\n\
11427 breakpoint set."));
11430 add_info ("breakpoints", breakpoints_info
, _("\
11431 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
11432 The \"Type\" column indicates one of:\n\
11433 \tbreakpoint - normal breakpoint\n\
11434 \twatchpoint - watchpoint\n\
11435 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
11436 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
11437 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
11438 address and file/line number respectively.\n\
11440 Convenience variable \"$_\" and default examine address for \"x\"\n\
11441 are set to the address of the last breakpoint listed unless the command\n\
11442 is prefixed with \"server \".\n\n\
11443 Convenience variable \"$bpnum\" contains the number of the last\n\
11444 breakpoint set."));
11446 add_info_alias ("b", "breakpoints", 1);
11449 add_com ("lb", class_breakpoint
, breakpoints_info
, _("\
11450 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
11451 The \"Type\" column indicates one of:\n\
11452 \tbreakpoint - normal breakpoint\n\
11453 \twatchpoint - watchpoint\n\
11454 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
11455 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
11456 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
11457 address and file/line number respectively.\n\
11459 Convenience variable \"$_\" and default examine address for \"x\"\n\
11460 are set to the address of the last breakpoint listed unless the command\n\
11461 is prefixed with \"server \".\n\n\
11462 Convenience variable \"$bpnum\" contains the number of the last\n\
11463 breakpoint set."));
11465 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
11466 Status of all breakpoints, or breakpoint number NUMBER.\n\
11467 The \"Type\" column indicates one of:\n\
11468 \tbreakpoint - normal breakpoint\n\
11469 \twatchpoint - watchpoint\n\
11470 \tlongjmp - internal breakpoint used to step through longjmp()\n\
11471 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
11472 \tuntil - internal breakpoint used by the \"until\" command\n\
11473 \tfinish - internal breakpoint used by the \"finish\" command\n\
11474 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
11475 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
11476 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
11477 address and file/line number respectively.\n\
11479 Convenience variable \"$_\" and default examine address for \"x\"\n\
11480 are set to the address of the last breakpoint listed unless the command\n\
11481 is prefixed with \"server \".\n\n\
11482 Convenience variable \"$bpnum\" contains the number of the last\n\
11484 &maintenanceinfolist
);
11486 add_prefix_cmd ("catch", class_breakpoint
, catch_command
, _("\
11487 Set catchpoints to catch events."),
11488 &catch_cmdlist
, "catch ",
11489 0/*allow-unknown*/, &cmdlist
);
11491 add_prefix_cmd ("tcatch", class_breakpoint
, tcatch_command
, _("\
11492 Set temporary catchpoints to catch events."),
11493 &tcatch_cmdlist
, "tcatch ",
11494 0/*allow-unknown*/, &cmdlist
);
11496 /* Add catch and tcatch sub-commands. */
11497 add_catch_command ("catch", _("\
11498 Catch an exception, when caught.\n\
11499 With an argument, catch only exceptions with the given name."),
11500 catch_catch_command
,
11504 add_catch_command ("throw", _("\
11505 Catch an exception, when thrown.\n\
11506 With an argument, catch only exceptions with the given name."),
11507 catch_throw_command
,
11511 add_catch_command ("fork", _("Catch calls to fork."),
11512 catch_fork_command_1
,
11514 (void *) (uintptr_t) catch_fork_permanent
,
11515 (void *) (uintptr_t) catch_fork_temporary
);
11516 add_catch_command ("vfork", _("Catch calls to vfork."),
11517 catch_fork_command_1
,
11519 (void *) (uintptr_t) catch_vfork_permanent
,
11520 (void *) (uintptr_t) catch_vfork_temporary
);
11521 add_catch_command ("exec", _("Catch calls to exec."),
11522 catch_exec_command_1
,
11526 add_catch_command ("syscall", _("\
11527 Catch system calls by their names and/or numbers.\n\
11528 Arguments say which system calls to catch. If no arguments\n\
11529 are given, every system call will be caught.\n\
11530 Arguments, if given, should be one or more system call names\n\
11531 (if your system supports that), or system call numbers."),
11532 catch_syscall_command_1
,
11533 catch_syscall_completer
,
11536 add_catch_command ("exception", _("\
11537 Catch Ada exceptions, when raised.\n\
11538 With an argument, catch only exceptions with the given name."),
11539 catch_ada_exception_command
,
11543 add_catch_command ("assert", _("\
11544 Catch failed Ada assertions, when raised.\n\
11545 With an argument, catch only exceptions with the given name."),
11546 catch_assert_command
,
11551 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
11552 Set a watchpoint for an expression.\n\
11553 A watchpoint stops execution of your program whenever the value of\n\
11554 an expression changes."));
11555 set_cmd_completer (c
, expression_completer
);
11557 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
11558 Set a read watchpoint for an expression.\n\
11559 A watchpoint stops execution of your program whenever the value of\n\
11560 an expression is read."));
11561 set_cmd_completer (c
, expression_completer
);
11563 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
11564 Set a watchpoint for an expression.\n\
11565 A watchpoint stops execution of your program whenever the value of\n\
11566 an expression is either read or written."));
11567 set_cmd_completer (c
, expression_completer
);
11569 add_info ("watchpoints", watchpoints_info
, _("\
11570 Status of watchpoints, or watchpoint number NUMBER."));
11574 /* XXX: cagney/2005-02-23: This should be a boolean, and should
11575 respond to changes - contrary to the description. */
11576 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
11577 &can_use_hw_watchpoints
, _("\
11578 Set debugger's willingness to use watchpoint hardware."), _("\
11579 Show debugger's willingness to use watchpoint hardware."), _("\
11580 If zero, gdb will not use hardware for new watchpoints, even if\n\
11581 such is available. (However, any hardware watchpoints that were\n\
11582 created before setting this to nonzero, will continue to use watchpoint\n\
11585 show_can_use_hw_watchpoints
,
11586 &setlist
, &showlist
);
11588 can_use_hw_watchpoints
= 1;
11590 /* Tracepoint manipulation commands. */
11592 c
= add_com ("trace", class_breakpoint
, trace_command
, _("\
11593 Set a tracepoint at specified line or function.\n\
11595 BREAK_ARGS_HELP ("trace") "\n\
11596 Do \"help tracepoints\" for info on other tracepoint commands."));
11597 set_cmd_completer (c
, location_completer
);
11599 add_com_alias ("tp", "trace", class_alias
, 0);
11600 add_com_alias ("tr", "trace", class_alias
, 1);
11601 add_com_alias ("tra", "trace", class_alias
, 1);
11602 add_com_alias ("trac", "trace", class_alias
, 1);
11604 c
= add_com ("ftrace", class_breakpoint
, ftrace_command
, _("\
11605 Set a fast tracepoint at specified line or function.\n\
11607 BREAK_ARGS_HELP ("ftrace") "\n\
11608 Do \"help tracepoints\" for info on other tracepoint commands."));
11609 set_cmd_completer (c
, location_completer
);
11611 add_info ("tracepoints", tracepoints_info
, _("\
11612 Status of tracepoints, or tracepoint number NUMBER.\n\
11613 Convenience variable \"$tpnum\" contains the number of the\n\
11614 last tracepoint set."));
11616 add_info_alias ("tp", "tracepoints", 1);
11618 add_cmd ("tracepoints", class_trace
, delete_trace_command
, _("\
11619 Delete specified tracepoints.\n\
11620 Arguments are tracepoint numbers, separated by spaces.\n\
11621 No argument means delete all tracepoints."),
11624 c
= add_cmd ("tracepoints", class_trace
, disable_trace_command
, _("\
11625 Disable specified tracepoints.\n\
11626 Arguments are tracepoint numbers, separated by spaces.\n\
11627 No argument means disable all tracepoints."),
11629 deprecate_cmd (c
, "disable");
11631 c
= add_cmd ("tracepoints", class_trace
, enable_trace_command
, _("\
11632 Enable specified tracepoints.\n\
11633 Arguments are tracepoint numbers, separated by spaces.\n\
11634 No argument means enable all tracepoints."),
11636 deprecate_cmd (c
, "enable");
11638 add_com ("passcount", class_trace
, trace_pass_command
, _("\
11639 Set the passcount for a tracepoint.\n\
11640 The trace will end when the tracepoint has been passed 'count' times.\n\
11641 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
11642 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
11644 add_prefix_cmd ("save", class_breakpoint
, save_command
,
11645 _("Save breakpoint definitions as a script."),
11646 &save_cmdlist
, "save ",
11647 0/*allow-unknown*/, &cmdlist
);
11649 c
= add_cmd ("breakpoints", class_breakpoint
, save_breakpoints_command
, _("\
11650 Save current breakpoint definitions as a script.\n\
11651 This includes all types of breakpoints (breakpoints, watchpoints, \n\
11652 catchpoints, tracepoints). Use the 'source' command in another debug\n\
11653 session to restore them."),
11655 set_cmd_completer (c
, filename_completer
);
11657 c
= add_cmd ("tracepoints", class_trace
, save_tracepoints_command
, _("\
11658 Save current tracepoint definitions as a script.\n\
11659 Use the 'source' command in another debug session to restore them."),
11661 set_cmd_completer (c
, filename_completer
);
11663 c
= add_com_alias ("save-tracepoints", "save tracepoints", class_trace
, 0);
11664 deprecate_cmd (c
, "save tracepoints");
11666 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
11667 Breakpoint specific settings\n\
11668 Configure various breakpoint-specific variables such as\n\
11669 pending breakpoint behavior"),
11670 &breakpoint_set_cmdlist
, "set breakpoint ",
11671 0/*allow-unknown*/, &setlist
);
11672 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
11673 Breakpoint specific settings\n\
11674 Configure various breakpoint-specific variables such as\n\
11675 pending breakpoint behavior"),
11676 &breakpoint_show_cmdlist
, "show breakpoint ",
11677 0/*allow-unknown*/, &showlist
);
11679 add_setshow_auto_boolean_cmd ("pending", no_class
,
11680 &pending_break_support
, _("\
11681 Set debugger's behavior regarding pending breakpoints."), _("\
11682 Show debugger's behavior regarding pending breakpoints."), _("\
11683 If on, an unrecognized breakpoint location will cause gdb to create a\n\
11684 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
11685 an error. If auto, an unrecognized breakpoint location results in a\n\
11686 user-query to see if a pending breakpoint should be created."),
11688 show_pending_break_support
,
11689 &breakpoint_set_cmdlist
,
11690 &breakpoint_show_cmdlist
);
11692 pending_break_support
= AUTO_BOOLEAN_AUTO
;
11694 add_setshow_boolean_cmd ("auto-hw", no_class
,
11695 &automatic_hardware_breakpoints
, _("\
11696 Set automatic usage of hardware breakpoints."), _("\
11697 Show automatic usage of hardware breakpoints."), _("\
11698 If set, the debugger will automatically use hardware breakpoints for\n\
11699 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
11700 a warning will be emitted for such breakpoints."),
11702 show_automatic_hardware_breakpoints
,
11703 &breakpoint_set_cmdlist
,
11704 &breakpoint_show_cmdlist
);
11706 add_setshow_enum_cmd ("always-inserted", class_support
,
11707 always_inserted_enums
, &always_inserted_mode
, _("\
11708 Set mode for inserting breakpoints."), _("\
11709 Show mode for inserting breakpoints."), _("\
11710 When this mode is off, breakpoints are inserted in inferior when it is\n\
11711 resumed, and removed when execution stops. When this mode is on,\n\
11712 breakpoints are inserted immediately and removed only when the user\n\
11713 deletes the breakpoint. When this mode is auto (which is the default),\n\
11714 the behaviour depends on the non-stop setting (see help set non-stop).\n\
11715 In this case, if gdb is controlling the inferior in non-stop mode, gdb\n\
11716 behaves as if always-inserted mode is on; if gdb is controlling the\n\
11717 inferior in all-stop mode, gdb behaves as if always-inserted mode is off."),
11719 &show_always_inserted_mode
,
11720 &breakpoint_set_cmdlist
,
11721 &breakpoint_show_cmdlist
);
11723 automatic_hardware_breakpoints
= 1;
11725 observer_attach_about_to_proceed (breakpoint_about_to_proceed
);