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 int can_use_hardware_watchpoint (struct value
*);
103 static void break_command_1 (char *, int, int);
105 static void mention (struct breakpoint
*);
107 /* This function is used in gdbtk sources and thus can not be made static. */
108 struct breakpoint
*set_raw_breakpoint (struct gdbarch
*gdbarch
,
109 struct symtab_and_line
,
112 static void breakpoint_adjustment_warning (CORE_ADDR
, CORE_ADDR
, int, int);
114 static CORE_ADDR
adjust_breakpoint_address (struct gdbarch
*gdbarch
,
118 static void describe_other_breakpoints (struct gdbarch
*,
119 struct program_space
*, CORE_ADDR
,
120 struct obj_section
*, int);
122 static int breakpoint_address_match (struct address_space
*aspace1
,
124 struct address_space
*aspace2
,
127 static int watchpoint_locations_match (struct bp_location
*loc1
,
128 struct bp_location
*loc2
);
130 static void breakpoints_info (char *, int);
132 static void watchpoints_info (char *, int);
134 static int breakpoint_1 (int, int, int (*) (const struct breakpoint
*));
136 static bpstat
bpstat_alloc (const struct bp_location
*, bpstat
);
138 static int breakpoint_cond_eval (void *);
140 static void cleanup_executing_breakpoints (void *);
142 static void commands_command (char *, int);
144 static void condition_command (char *, int);
146 static int get_number_trailer (char **, int);
155 static int remove_breakpoint (struct bp_location
*, insertion_state_t
);
156 static int remove_breakpoint_1 (struct bp_location
*, insertion_state_t
);
158 static enum print_stop_action
print_it_typical (bpstat
);
160 static enum print_stop_action
print_bp_stop_message (bpstat bs
);
162 static int watchpoint_check (void *);
164 static void maintenance_info_breakpoints (char *, int);
166 static int hw_breakpoint_used_count (void);
168 static int hw_watchpoint_used_count (enum bptype
, int *);
170 static void hbreak_command (char *, int);
172 static void thbreak_command (char *, int);
174 static void do_enable_breakpoint (struct breakpoint
*, enum bpdisp
);
176 static void stop_command (char *arg
, int from_tty
);
178 static void stopin_command (char *arg
, int from_tty
);
180 static void stopat_command (char *arg
, int from_tty
);
182 static char *ep_parse_optional_if_clause (char **arg
);
184 static void catch_exception_command_1 (enum exception_event_kind ex_event
,
185 char *arg
, int tempflag
, int from_tty
);
187 static void tcatch_command (char *arg
, int from_tty
);
189 static void ep_skip_leading_whitespace (char **s
);
191 static void detach_single_step_breakpoints (void);
193 static int single_step_breakpoint_inserted_here_p (struct address_space
*,
196 static void free_bp_location (struct bp_location
*loc
);
198 static struct bp_location
*allocate_bp_location (struct breakpoint
*bpt
);
200 static void update_global_location_list (int);
202 static void update_global_location_list_nothrow (int);
204 static int bpstat_remove_bp_location_callback (struct thread_info
*th
,
207 static int is_hardware_watchpoint (const struct breakpoint
*bpt
);
209 static int is_watchpoint (const struct breakpoint
*bpt
);
211 static void insert_breakpoint_locations (void);
213 static int syscall_catchpoint_p (struct breakpoint
*b
);
215 static void tracepoints_info (char *, int);
217 static void delete_trace_command (char *, int);
219 static void enable_trace_command (char *, int);
221 static void disable_trace_command (char *, int);
223 static void trace_pass_command (char *, int);
225 /* Assuming we're creating a static tracepoint, does S look like a
226 static tracepoint marker spec ("-m MARKER_ID")? */
227 #define is_marker_spec(s) \
228 (strncmp (s, "-m", 2) == 0 && ((s)[2] == ' ' || (s)[2] == '\t'))
230 /* A reference-counted struct command_line. This lets multiple
231 breakpoints share a single command list. */
232 struct counted_command_line
234 /* The reference count. */
237 /* The command list. */
238 struct command_line
*commands
;
241 struct command_line
*
242 breakpoint_commands (struct breakpoint
*b
)
244 return b
->commands
? b
->commands
->commands
: NULL
;
247 /* Flag indicating that a command has proceeded the inferior past the
248 current breakpoint. */
250 static int breakpoint_proceeded
;
253 bpdisp_text (enum bpdisp disp
)
255 /* NOTE: the following values are a part of MI protocol and represent
256 values of 'disp' field returned when inferior stops at a breakpoint. */
257 static const char * const bpdisps
[] = {"del", "dstp", "dis", "keep"};
259 return bpdisps
[(int) disp
];
262 /* Prototypes for exported functions. */
263 /* If FALSE, gdb will not use hardware support for watchpoints, even
264 if such is available. */
265 static int can_use_hw_watchpoints
;
268 show_can_use_hw_watchpoints (struct ui_file
*file
, int from_tty
,
269 struct cmd_list_element
*c
,
272 fprintf_filtered (file
, _("\
273 Debugger's willingness to use watchpoint hardware is %s.\n"),
277 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
278 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
279 for unrecognized breakpoint locations.
280 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
281 static enum auto_boolean pending_break_support
;
283 show_pending_break_support (struct ui_file
*file
, int from_tty
,
284 struct cmd_list_element
*c
,
287 fprintf_filtered (file
, _("\
288 Debugger's behavior regarding pending breakpoints is %s.\n"),
292 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
293 set with "break" but falling in read-only memory.
294 If 0, gdb will warn about such breakpoints, but won't automatically
295 use hardware breakpoints. */
296 static int automatic_hardware_breakpoints
;
298 show_automatic_hardware_breakpoints (struct ui_file
*file
, int from_tty
,
299 struct cmd_list_element
*c
,
302 fprintf_filtered (file
, _("\
303 Automatic usage of hardware breakpoints is %s.\n"),
307 /* If on, gdb will keep breakpoints inserted even as inferior is
308 stopped, and immediately insert any new breakpoints. If off, gdb
309 will insert breakpoints into inferior only when resuming it, and
310 will remove breakpoints upon stop. If auto, GDB will behave as ON
311 if in non-stop mode, and as OFF if all-stop mode.*/
313 static const char always_inserted_auto
[] = "auto";
314 static const char always_inserted_on
[] = "on";
315 static const char always_inserted_off
[] = "off";
316 static const char *always_inserted_enums
[] = {
317 always_inserted_auto
,
322 static const char *always_inserted_mode
= always_inserted_auto
;
324 show_always_inserted_mode (struct ui_file
*file
, int from_tty
,
325 struct cmd_list_element
*c
, const char *value
)
327 if (always_inserted_mode
== always_inserted_auto
)
328 fprintf_filtered (file
, _("\
329 Always inserted breakpoint mode is %s (currently %s).\n"),
331 breakpoints_always_inserted_mode () ? "on" : "off");
333 fprintf_filtered (file
, _("Always inserted breakpoint mode is %s.\n"), value
);
337 breakpoints_always_inserted_mode (void)
339 return (always_inserted_mode
== always_inserted_on
340 || (always_inserted_mode
== always_inserted_auto
&& non_stop
));
343 void _initialize_breakpoint (void);
345 /* Are we executing breakpoint commands? */
346 static int executing_breakpoint_commands
;
348 /* Are overlay event breakpoints enabled? */
349 static int overlay_events_enabled
;
351 /* Walk the following statement or block through all breakpoints.
352 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the current
355 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
357 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
358 for (B = breakpoint_chain; \
359 B ? (TMP=B->next, 1): 0; \
362 /* Similar iterator for the low-level breakpoints. SAFE variant is not
363 provided so update_global_location_list must not be called while executing
364 the block of ALL_BP_LOCATIONS. */
366 #define ALL_BP_LOCATIONS(B,BP_TMP) \
367 for (BP_TMP = bp_location; \
368 BP_TMP < bp_location + bp_location_count && (B = *BP_TMP); \
371 /* Iterator for tracepoints only. */
373 #define ALL_TRACEPOINTS(B) \
374 for (B = breakpoint_chain; B; B = B->next) \
375 if (is_tracepoint (B))
377 /* Chains of all breakpoints defined. */
379 struct breakpoint
*breakpoint_chain
;
381 /* Array is sorted by bp_location_compare - primarily by the ADDRESS. */
383 static struct bp_location
**bp_location
;
385 /* Number of elements of BP_LOCATION. */
387 static unsigned bp_location_count
;
389 /* Maximum alignment offset between bp_target_info.PLACED_ADDRESS and ADDRESS
390 for the current elements of BP_LOCATION which get a valid result from
391 bp_location_has_shadow. You can use it for roughly limiting the subrange of
392 BP_LOCATION to scan for shadow bytes for an address you need to read. */
394 static CORE_ADDR bp_location_placed_address_before_address_max
;
396 /* Maximum offset plus alignment between
397 bp_target_info.PLACED_ADDRESS + bp_target_info.SHADOW_LEN and ADDRESS for
398 the current elements of BP_LOCATION which get a valid result from
399 bp_location_has_shadow. You can use it for roughly limiting the subrange of
400 BP_LOCATION to scan for shadow bytes for an address you need to read. */
402 static CORE_ADDR bp_location_shadow_len_after_address_max
;
404 /* The locations that no longer correspond to any breakpoint,
405 unlinked from bp_location array, but for which a hit
406 may still be reported by a target. */
407 VEC(bp_location_p
) *moribund_locations
= NULL
;
409 /* Number of last breakpoint made. */
411 static int breakpoint_count
;
413 /* The value of `breakpoint_count' before the last command that
414 created breakpoints. If the last (break-like) command created more
415 than one breakpoint, then the difference between BREAKPOINT_COUNT
416 and PREV_BREAKPOINT_COUNT is more than one. */
417 static int prev_breakpoint_count
;
419 /* Number of last tracepoint made. */
421 static int tracepoint_count
;
423 static struct cmd_list_element
*breakpoint_set_cmdlist
;
424 static struct cmd_list_element
*breakpoint_show_cmdlist
;
425 struct cmd_list_element
*save_cmdlist
;
427 /* Return whether a breakpoint is an active enabled breakpoint. */
429 breakpoint_enabled (struct breakpoint
*b
)
431 return (b
->enable_state
== bp_enabled
);
434 /* Set breakpoint count to NUM. */
437 set_breakpoint_count (int num
)
439 prev_breakpoint_count
= breakpoint_count
;
440 breakpoint_count
= num
;
441 set_internalvar_integer (lookup_internalvar ("bpnum"), num
);
444 /* Used by `start_rbreak_breakpoints' below, to record the current
445 breakpoint count before "rbreak" creates any breakpoint. */
446 static int rbreak_start_breakpoint_count
;
448 /* Called at the start an "rbreak" command to record the first
452 start_rbreak_breakpoints (void)
454 rbreak_start_breakpoint_count
= breakpoint_count
;
457 /* Called at the end of an "rbreak" command to record the last
461 end_rbreak_breakpoints (void)
463 prev_breakpoint_count
= rbreak_start_breakpoint_count
;
466 /* Used in run_command to zero the hit count when a new run starts. */
469 clear_breakpoint_hit_counts (void)
471 struct breakpoint
*b
;
477 /* Allocate a new counted_command_line with reference count of 1.
478 The new structure owns COMMANDS. */
480 static struct counted_command_line
*
481 alloc_counted_command_line (struct command_line
*commands
)
483 struct counted_command_line
*result
484 = xmalloc (sizeof (struct counted_command_line
));
487 result
->commands
= commands
;
491 /* Increment reference count. This does nothing if CMD is NULL. */
494 incref_counted_command_line (struct counted_command_line
*cmd
)
500 /* Decrement reference count. If the reference count reaches 0,
501 destroy the counted_command_line. Sets *CMDP to NULL. This does
502 nothing if *CMDP is NULL. */
505 decref_counted_command_line (struct counted_command_line
**cmdp
)
509 if (--(*cmdp
)->refc
== 0)
511 free_command_lines (&(*cmdp
)->commands
);
518 /* A cleanup function that calls decref_counted_command_line. */
521 do_cleanup_counted_command_line (void *arg
)
523 decref_counted_command_line (arg
);
526 /* Create a cleanup that calls decref_counted_command_line on the
529 static struct cleanup
*
530 make_cleanup_decref_counted_command_line (struct counted_command_line
**cmdp
)
532 return make_cleanup (do_cleanup_counted_command_line
, cmdp
);
535 /* Default address, symtab and line to put a breakpoint at
536 for "break" command with no arg.
537 if default_breakpoint_valid is zero, the other three are
538 not valid, and "break" with no arg is an error.
540 This set by print_stack_frame, which calls set_default_breakpoint. */
542 int default_breakpoint_valid
;
543 CORE_ADDR default_breakpoint_address
;
544 struct symtab
*default_breakpoint_symtab
;
545 int default_breakpoint_line
;
546 struct program_space
*default_breakpoint_pspace
;
549 /* *PP is a string denoting a breakpoint. Get the number of the breakpoint.
550 Advance *PP after the string and any trailing whitespace.
552 Currently the string can either be a number or "$" followed by the name
553 of a convenience variable. Making it an expression wouldn't work well
554 for map_breakpoint_numbers (e.g. "4 + 5 + 6").
556 If the string is a NULL pointer, that denotes the last breakpoint.
558 TRAILER is a character which can be found after the number; most
559 commonly this is `-'. If you don't want a trailer, use \0. */
561 get_number_trailer (char **pp
, int trailer
)
563 int retval
= 0; /* default */
567 /* Empty line means refer to the last breakpoint. */
568 return breakpoint_count
;
571 /* Make a copy of the name, so we can null-terminate it
572 to pass to lookup_internalvar(). */
577 while (isalnum (*p
) || *p
== '_')
579 varname
= (char *) alloca (p
- start
+ 1);
580 strncpy (varname
, start
, p
- start
);
581 varname
[p
- start
] = '\0';
582 if (get_internalvar_integer (lookup_internalvar (varname
), &val
))
586 printf_filtered (_("Convenience variable must have integer value.\n"));
594 while (*p
>= '0' && *p
<= '9')
597 /* There is no number here. (e.g. "cond a == b"). */
599 /* Skip non-numeric token */
600 while (*p
&& !isspace((int) *p
))
602 /* Return zero, which caller must interpret as error. */
608 if (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
610 /* Trailing junk: return 0 and let caller print error msg. */
611 while (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
622 /* Like get_number_trailer, but don't allow a trailer. */
624 get_number (char **pp
)
626 return get_number_trailer (pp
, '\0');
629 /* Parse a number or a range.
630 * A number will be of the form handled by get_number.
631 * A range will be of the form <number1> - <number2>, and
632 * will represent all the integers between number1 and number2,
635 * While processing a range, this fuction is called iteratively;
636 * At each call it will return the next value in the range.
638 * At the beginning of parsing a range, the char pointer PP will
639 * be advanced past <number1> and left pointing at the '-' token.
640 * Subsequent calls will not advance the pointer until the range
641 * is completed. The call that completes the range will advance
642 * pointer PP past <number2>.
646 get_number_or_range (char **pp
)
648 static int last_retval
, end_value
;
649 static char *end_ptr
;
650 static int in_range
= 0;
654 /* Default case: pp is pointing either to a solo number,
655 or to the first number of a range. */
656 last_retval
= get_number_trailer (pp
, '-');
661 /* This is the start of a range (<number1> - <number2>).
662 Skip the '-', parse and remember the second number,
663 and also remember the end of the final token. */
667 while (isspace ((int) *end_ptr
))
668 end_ptr
++; /* skip white space */
669 end_value
= get_number (temp
);
670 if (end_value
< last_retval
)
672 error (_("inverted range"));
674 else if (end_value
== last_retval
)
676 /* degenerate range (number1 == number2). Advance the
677 token pointer so that the range will be treated as a
686 error (_("negative value"));
689 /* pp points to the '-' that betokens a range. All
690 number-parsing has already been done. Return the next
691 integer value (one greater than the saved previous value).
692 Do not advance the token pointer 'pp' until the end of range
695 if (++last_retval
== end_value
)
697 /* End of range reached; advance token pointer. */
705 /* Return the breakpoint with the specified number, or NULL
706 if the number does not refer to an existing breakpoint. */
709 get_breakpoint (int num
)
711 struct breakpoint
*b
;
714 if (b
->number
== num
)
723 set_breakpoint_condition (struct breakpoint
*b
, char *exp
,
726 struct bp_location
*loc
= b
->loc
;
728 for (; loc
; loc
= loc
->next
)
733 xfree (b
->cond_string
);
734 b
->cond_string
= NULL
;
741 printf_filtered (_("Breakpoint %d now unconditional.\n"), b
->number
);
747 /* I don't know if it matters whether this is the string the user
748 typed in or the decompiled expression. */
749 b
->cond_string
= xstrdup (arg
);
750 b
->condition_not_parsed
= 0;
752 if (is_watchpoint (b
))
754 innermost_block
= NULL
;
756 b
->cond_exp
= parse_exp_1 (&arg
, 0, 0);
758 error (_("Junk at end of expression"));
759 b
->cond_exp_valid_block
= innermost_block
;
763 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
767 parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
769 error (_("Junk at end of expression"));
773 breakpoints_changed ();
774 observer_notify_breakpoint_modified (b
->number
);
777 /* condition N EXP -- set break condition of breakpoint N to EXP. */
780 condition_command (char *arg
, int from_tty
)
782 struct breakpoint
*b
;
787 error_no_arg (_("breakpoint number"));
790 bnum
= get_number (&p
);
792 error (_("Bad breakpoint argument: '%s'"), arg
);
795 if (b
->number
== bnum
)
797 set_breakpoint_condition (b
, p
, from_tty
);
801 error (_("No breakpoint number %d."), bnum
);
804 /* Check that COMMAND do not contain commands that are suitable
805 only for tracepoints and not suitable for ordinary breakpoints.
806 Throw if any such commands is found.
809 check_no_tracepoint_commands (struct command_line
*commands
)
811 struct command_line
*c
;
813 for (c
= commands
; c
; c
= c
->next
)
817 if (c
->control_type
== while_stepping_control
)
818 error (_("The 'while-stepping' command can only be used for tracepoints"));
820 for (i
= 0; i
< c
->body_count
; ++i
)
821 check_no_tracepoint_commands ((c
->body_list
)[i
]);
823 /* Not that command parsing removes leading whitespace and comment
824 lines and also empty lines. So, we only need to check for
826 if (strstr (c
->line
, "collect ") == c
->line
)
827 error (_("The 'collect' command can only be used for tracepoints"));
829 if (strstr (c
->line
, "teval ") == c
->line
)
830 error (_("The 'teval' command can only be used for tracepoints"));
834 /* Encapsulate tests for different types of tracepoints. */
837 is_tracepoint (const struct breakpoint
*b
)
839 return (b
->type
== bp_tracepoint
840 || b
->type
== bp_fast_tracepoint
841 || b
->type
== bp_static_tracepoint
);
844 /* A helper function that validsates that COMMANDS are valid for a
845 breakpoint. This function will throw an exception if a problem is
849 validate_commands_for_breakpoint (struct breakpoint
*b
,
850 struct command_line
*commands
)
852 if (is_tracepoint (b
))
854 /* We need to verify that each top-level element of commands
855 is valid for tracepoints, that there's at most one while-stepping
856 element, and that while-stepping's body has valid tracing commands
857 excluding nested while-stepping. */
858 struct command_line
*c
;
859 struct command_line
*while_stepping
= 0;
860 for (c
= commands
; c
; c
= c
->next
)
862 if (c
->control_type
== while_stepping_control
)
864 if (b
->type
== bp_fast_tracepoint
)
866 The 'while-stepping' command cannot be used for fast tracepoint"));
867 else if (b
->type
== bp_static_tracepoint
)
869 The 'while-stepping' command cannot be used for static tracepoint"));
872 error (_("The 'while-stepping' command can be used only once"));
879 struct command_line
*c2
;
881 gdb_assert (while_stepping
->body_count
== 1);
882 c2
= while_stepping
->body_list
[0];
883 for (; c2
; c2
= c2
->next
)
885 if (c2
->control_type
== while_stepping_control
)
886 error (_("The 'while-stepping' command cannot be nested"));
892 check_no_tracepoint_commands (commands
);
896 /* Return a vector of all the static tracepoints set at ADDR. The
897 caller is responsible for releasing the vector. */
900 static_tracepoints_here (CORE_ADDR addr
)
902 struct breakpoint
*b
;
903 VEC(breakpoint_p
) *found
= 0;
904 struct bp_location
*loc
;
907 if (b
->type
== bp_static_tracepoint
)
909 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
910 if (loc
->address
== addr
)
911 VEC_safe_push(breakpoint_p
, found
, b
);
917 /* Set the command list of B to COMMANDS. If breakpoint is tracepoint,
918 validate that only allowed commands are included.
922 breakpoint_set_commands (struct breakpoint
*b
, struct command_line
*commands
)
924 validate_commands_for_breakpoint (b
, commands
);
926 decref_counted_command_line (&b
->commands
);
927 b
->commands
= alloc_counted_command_line (commands
);
928 breakpoints_changed ();
929 observer_notify_breakpoint_modified (b
->number
);
933 check_tracepoint_command (char *line
, void *closure
)
935 struct breakpoint
*b
= closure
;
937 validate_actionline (&line
, b
);
940 /* A structure used to pass information through
941 map_breakpoint_numbers. */
945 /* True if the command was typed at a tty. */
948 /* The breakpoint range spec. */
951 /* Non-NULL if the body of the commands are being read from this
952 already-parsed command. */
953 struct command_line
*control
;
955 /* The command lines read from the user, or NULL if they have not
957 struct counted_command_line
*cmd
;
960 /* A callback for map_breakpoint_numbers that sets the commands for
964 do_map_commands_command (struct breakpoint
*b
, void *data
)
966 struct commands_info
*info
= data
;
968 if (info
->cmd
== NULL
)
970 struct command_line
*l
;
972 if (info
->control
!= NULL
)
973 l
= copy_command_lines (info
->control
->body_list
[0]);
976 struct cleanup
*old_chain
;
979 str
= xstrprintf (_("Type commands for breakpoint(s) %s, one per line."),
982 old_chain
= make_cleanup (xfree
, str
);
984 l
= read_command_lines (str
,
987 ? check_tracepoint_command
: 0),
990 do_cleanups (old_chain
);
993 info
->cmd
= alloc_counted_command_line (l
);
996 /* If a breakpoint was on the list more than once, we don't need to
998 if (b
->commands
!= info
->cmd
)
1000 validate_commands_for_breakpoint (b
, info
->cmd
->commands
);
1001 incref_counted_command_line (info
->cmd
);
1002 decref_counted_command_line (&b
->commands
);
1003 b
->commands
= info
->cmd
;
1004 breakpoints_changed ();
1005 observer_notify_breakpoint_modified (b
->number
);
1010 commands_command_1 (char *arg
, int from_tty
, struct command_line
*control
)
1012 struct cleanup
*cleanups
;
1013 struct commands_info info
;
1015 info
.from_tty
= from_tty
;
1016 info
.control
= control
;
1018 /* If we read command lines from the user, then `info' will hold an
1019 extra reference to the commands that we must clean up. */
1020 cleanups
= make_cleanup_decref_counted_command_line (&info
.cmd
);
1022 if (arg
== NULL
|| !*arg
)
1024 if (breakpoint_count
- prev_breakpoint_count
> 1)
1025 arg
= xstrprintf ("%d-%d", prev_breakpoint_count
+ 1, breakpoint_count
);
1026 else if (breakpoint_count
> 0)
1027 arg
= xstrprintf ("%d", breakpoint_count
);
1030 /* So that we don't try to free the incoming non-NULL
1031 argument in the cleanup below. Mapping breakpoint
1032 numbers will fail in this case. */
1037 /* The command loop has some static state, so we need to preserve
1039 arg
= xstrdup (arg
);
1042 make_cleanup (xfree
, arg
);
1046 map_breakpoint_numbers (arg
, do_map_commands_command
, &info
);
1048 if (info
.cmd
== NULL
)
1049 error (_("No breakpoints specified."));
1051 do_cleanups (cleanups
);
1055 commands_command (char *arg
, int from_tty
)
1057 commands_command_1 (arg
, from_tty
, NULL
);
1060 /* Like commands_command, but instead of reading the commands from
1061 input stream, takes them from an already parsed command structure.
1063 This is used by cli-script.c to DTRT with breakpoint commands
1064 that are part of if and while bodies. */
1065 enum command_control_type
1066 commands_from_control_command (char *arg
, struct command_line
*cmd
)
1068 commands_command_1 (arg
, 0, cmd
);
1069 return simple_control
;
1072 /* Return non-zero if BL->TARGET_INFO contains valid information. */
1075 bp_location_has_shadow (struct bp_location
*bl
)
1077 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
1081 if (bl
->target_info
.shadow_len
== 0)
1082 /* bp isn't valid, or doesn't shadow memory. */
1087 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
1088 by replacing any memory breakpoints with their shadowed contents.
1090 The range of shadowed area by each bp_location is:
1091 b->address - bp_location_placed_address_before_address_max
1092 up to b->address + bp_location_shadow_len_after_address_max
1093 The range we were requested to resolve shadows for is:
1094 memaddr ... memaddr + len
1095 Thus the safe cutoff boundaries for performance optimization are
1096 memaddr + len <= b->address - bp_location_placed_address_before_address_max
1098 b->address + bp_location_shadow_len_after_address_max <= memaddr */
1101 breakpoint_restore_shadows (gdb_byte
*buf
, ULONGEST memaddr
, LONGEST len
)
1103 /* Left boundary, right boundary and median element of our binary search. */
1104 unsigned bc_l
, bc_r
, bc
;
1106 /* Find BC_L which is a leftmost element which may affect BUF content. It is
1107 safe to report lower value but a failure to report higher one. */
1110 bc_r
= bp_location_count
;
1111 while (bc_l
+ 1 < bc_r
)
1113 struct bp_location
*b
;
1115 bc
= (bc_l
+ bc_r
) / 2;
1116 b
= bp_location
[bc
];
1118 /* Check first B->ADDRESS will not overflow due to the added constant.
1119 Then advance the left boundary only if we are sure the BC element can
1120 in no way affect the BUF content (MEMADDR to MEMADDR + LEN range).
1122 Use the BP_LOCATION_SHADOW_LEN_AFTER_ADDRESS_MAX safety offset so that
1123 we cannot miss a breakpoint with its shadow range tail still reaching
1126 if (b
->address
+ bp_location_shadow_len_after_address_max
>= b
->address
1127 && b
->address
+ bp_location_shadow_len_after_address_max
<= memaddr
)
1133 /* Now do full processing of the found relevant range of elements. */
1135 for (bc
= bc_l
; bc
< bp_location_count
; bc
++)
1137 struct bp_location
*b
= bp_location
[bc
];
1138 CORE_ADDR bp_addr
= 0;
1142 /* bp_location array has B->OWNER always non-NULL. */
1143 if (b
->owner
->type
== bp_none
)
1144 warning (_("reading through apparently deleted breakpoint #%d?"),
1147 /* Performance optimization: any futher element can no longer affect BUF
1150 if (b
->address
>= bp_location_placed_address_before_address_max
1151 && memaddr
+ len
<= b
->address
1152 - bp_location_placed_address_before_address_max
)
1155 if (!bp_location_has_shadow (b
))
1157 if (!breakpoint_address_match (b
->target_info
.placed_address_space
, 0,
1158 current_program_space
->aspace
, 0))
1161 /* Addresses and length of the part of the breakpoint that
1163 bp_addr
= b
->target_info
.placed_address
;
1164 bp_size
= b
->target_info
.shadow_len
;
1166 if (bp_addr
+ bp_size
<= memaddr
)
1167 /* The breakpoint is entirely before the chunk of memory we
1171 if (bp_addr
>= memaddr
+ len
)
1172 /* The breakpoint is entirely after the chunk of memory we are
1176 /* Offset within shadow_contents. */
1177 if (bp_addr
< memaddr
)
1179 /* Only copy the second part of the breakpoint. */
1180 bp_size
-= memaddr
- bp_addr
;
1181 bptoffset
= memaddr
- bp_addr
;
1185 if (bp_addr
+ bp_size
> memaddr
+ len
)
1187 /* Only copy the first part of the breakpoint. */
1188 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
1191 memcpy (buf
+ bp_addr
- memaddr
,
1192 b
->target_info
.shadow_contents
+ bptoffset
, bp_size
);
1197 /* A wrapper function for inserting catchpoints. */
1199 insert_catchpoint (struct ui_out
*uo
, void *args
)
1201 struct breakpoint
*b
= (struct breakpoint
*) args
;
1203 gdb_assert (b
->type
== bp_catchpoint
);
1204 gdb_assert (b
->ops
!= NULL
&& b
->ops
->insert
!= NULL
);
1209 /* Return true if BPT is of any hardware watchpoint kind. */
1212 is_hardware_watchpoint (const struct breakpoint
*bpt
)
1214 return (bpt
->type
== bp_hardware_watchpoint
1215 || bpt
->type
== bp_read_watchpoint
1216 || bpt
->type
== bp_access_watchpoint
);
1219 /* Return true if BPT is of any watchpoint kind, hardware or
1223 is_watchpoint (const struct breakpoint
*bpt
)
1225 return (is_hardware_watchpoint (bpt
)
1226 || bpt
->type
== bp_watchpoint
);
1229 /* Assuming that B is a watchpoint: returns true if the current thread
1230 and its running state are safe to evaluate or update watchpoint B.
1231 Watchpoints on local expressions need to be evaluated in the
1232 context of the thread that was current when the watchpoint was
1233 created, and, that thread needs to be stopped to be able to select
1234 the correct frame context. Watchpoints on global expressions can
1235 be evaluated on any thread, and in any state. It is presently left
1236 to the target allowing memory accesses when threads are
1240 watchpoint_in_thread_scope (struct breakpoint
*b
)
1242 return (ptid_equal (b
->watchpoint_thread
, null_ptid
)
1243 || (ptid_equal (inferior_ptid
, b
->watchpoint_thread
)
1244 && !is_executing (inferior_ptid
)));
1247 /* Assuming that B is a watchpoint:
1248 - Reparse watchpoint expression, if REPARSE is non-zero
1249 - Evaluate expression and store the result in B->val
1250 - Evaluate the condition if there is one, and store the result
1252 - Update the list of values that must be watched in B->loc.
1254 If the watchpoint disposition is disp_del_at_next_stop, then do nothing.
1255 If this is local watchpoint that is out of scope, delete it.
1257 Even with `set breakpoint always-inserted on' the watchpoints are removed
1258 + inserted on each stop here. Normal breakpoints must never be removed
1259 because they might be missed by a running thread when debugging in non-stop
1260 mode. On the other hand, hardware watchpoints (is_hardware_watchpoint;
1261 processed here) are specific to each LWP since they are stored in each LWP's
1262 hardware debug registers. Therefore, such LWP must be stopped first in
1263 order to be able to modify its hardware watchpoints.
1265 Hardware watchpoints must be reset exactly once after being presented to the
1266 user. It cannot be done sooner, because it would reset the data used to
1267 present the watchpoint hit to the user. And it must not be done later
1268 because it could display the same single watchpoint hit during multiple GDB
1269 stops. Note that the latter is relevant only to the hardware watchpoint
1270 types bp_read_watchpoint and bp_access_watchpoint. False hit by
1271 bp_hardware_watchpoint is not user-visible - its hit is suppressed if the
1272 memory content has not changed.
1274 The following constraints influence the location where we can reset hardware
1277 * target_stopped_by_watchpoint and target_stopped_data_address are called
1278 several times when GDB stops.
1281 * Multiple hardware watchpoints can be hit at the same time, causing GDB to
1282 stop. GDB only presents one hardware watchpoint hit at a time as the
1283 reason for stopping, and all the other hits are presented later, one after
1284 the other, each time the user requests the execution to be resumed.
1285 Execution is not resumed for the threads still having pending hit event
1286 stored in LWP_INFO->STATUS. While the watchpoint is already removed from
1287 the inferior on the first stop the thread hit event is kept being reported
1288 from its cached value by linux_nat_stopped_data_address until the real
1289 thread resume happens after the watchpoint gets presented and thus its
1290 LWP_INFO->STATUS gets reset.
1292 Therefore the hardware watchpoint hit can get safely reset on the watchpoint
1293 removal from inferior. */
1296 update_watchpoint (struct breakpoint
*b
, int reparse
)
1298 int within_current_scope
;
1299 struct frame_id saved_frame_id
;
1302 /* If this is a local watchpoint, we only want to check if the
1303 watchpoint frame is in scope if the current thread is the thread
1304 that was used to create the watchpoint. */
1305 if (!watchpoint_in_thread_scope (b
))
1308 /* We don't free locations. They are stored in bp_location array and
1309 update_global_locations will eventually delete them and remove
1310 breakpoints if needed. */
1313 if (b
->disposition
== disp_del_at_next_stop
)
1318 /* Determine if the watchpoint is within scope. */
1319 if (b
->exp_valid_block
== NULL
)
1320 within_current_scope
= 1;
1323 struct frame_info
*fi
;
1325 /* Save the current frame's ID so we can restore it after
1326 evaluating the watchpoint expression on its own frame. */
1327 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
1328 took a frame parameter, so that we didn't have to change the
1331 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
1333 fi
= frame_find_by_id (b
->watchpoint_frame
);
1334 within_current_scope
= (fi
!= NULL
);
1335 if (within_current_scope
)
1339 if (within_current_scope
&& reparse
)
1348 b
->exp
= parse_exp_1 (&s
, b
->exp_valid_block
, 0);
1349 /* If the meaning of expression itself changed, the old value is
1350 no longer relevant. We don't want to report a watchpoint hit
1351 to the user when the old value and the new value may actually
1352 be completely different objects. */
1353 value_free (b
->val
);
1357 /* Note that unlike with breakpoints, the watchpoint's condition
1358 expression is stored in the breakpoint object, not in the
1359 locations (re)created below. */
1360 if (b
->cond_string
!= NULL
)
1362 if (b
->cond_exp
!= NULL
)
1364 xfree (b
->cond_exp
);
1369 b
->cond_exp
= parse_exp_1 (&s
, b
->cond_exp_valid_block
, 0);
1373 /* If we failed to parse the expression, for example because
1374 it refers to a global variable in a not-yet-loaded shared library,
1375 don't try to insert watchpoint. We don't automatically delete
1376 such watchpoint, though, since failure to parse expression
1377 is different from out-of-scope watchpoint. */
1378 if ( !target_has_execution
)
1380 /* Without execution, memory can't change. No use to try and
1381 set watchpoint locations. The watchpoint will be reset when
1382 the target gains execution, through breakpoint_re_set. */
1384 else if (within_current_scope
&& b
->exp
)
1387 struct value
*val_chain
, *v
, *result
, *next
;
1388 struct program_space
*frame_pspace
;
1390 fetch_subexp_value (b
->exp
, &pc
, &v
, &result
, &val_chain
);
1392 /* Avoid setting b->val if it's already set. The meaning of
1393 b->val is 'the last value' user saw, and we should update
1394 it only if we reported that last value to user. As it
1395 happens, the code that reports it updates b->val directly. */
1402 /* Change the type of breakpoint between hardware assisted or an
1403 ordinary watchpoint depending on the hardware support and free
1404 hardware slots. REPARSE is set when the inferior is started. */
1405 if ((b
->type
== bp_watchpoint
|| b
->type
== bp_hardware_watchpoint
)
1408 int i
, mem_cnt
, other_type_used
;
1410 /* We need to determine how many resources are already used
1411 for all other hardware watchpoints to see if we still have
1412 enough resources to also fit this watchpoint in as well.
1413 To avoid the hw_watchpoint_used_count call below from counting
1414 this watchpoint, make sure that it is marked as a software
1416 b
->type
= bp_watchpoint
;
1417 i
= hw_watchpoint_used_count (bp_hardware_watchpoint
,
1419 mem_cnt
= can_use_hardware_watchpoint (val_chain
);
1422 b
->type
= bp_watchpoint
;
1425 int target_resources_ok
= target_can_use_hardware_watchpoint
1426 (bp_hardware_watchpoint
, i
+ mem_cnt
, other_type_used
);
1427 if (target_resources_ok
<= 0)
1428 b
->type
= bp_watchpoint
;
1430 b
->type
= bp_hardware_watchpoint
;
1434 frame_pspace
= get_frame_program_space (get_selected_frame (NULL
));
1436 /* Look at each value on the value chain. */
1437 for (v
= val_chain
; v
; v
= next
)
1439 /* If it's a memory location, and GDB actually needed
1440 its contents to evaluate the expression, then we
1441 must watch it. If the first value returned is
1442 still lazy, that means an error occurred reading it;
1443 watch it anyway in case it becomes readable. */
1444 if (VALUE_LVAL (v
) == lval_memory
1445 && (v
== val_chain
|| ! value_lazy (v
)))
1447 struct type
*vtype
= check_typedef (value_type (v
));
1449 /* We only watch structs and arrays if user asked
1450 for it explicitly, never if they just happen to
1451 appear in the middle of some value chain. */
1453 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
1454 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
1458 struct bp_location
*loc
, **tmp
;
1460 addr
= value_address (v
);
1461 len
= TYPE_LENGTH (value_type (v
));
1463 if (b
->type
== bp_read_watchpoint
)
1465 else if (b
->type
== bp_access_watchpoint
)
1468 loc
= allocate_bp_location (b
);
1469 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
1472 loc
->gdbarch
= get_type_arch (value_type (v
));
1474 loc
->pspace
= frame_pspace
;
1475 loc
->address
= addr
;
1477 loc
->watchpoint_type
= type
;
1481 next
= value_next (v
);
1486 /* If a software watchpoint is not watching any memory, then the
1487 above left it without any location set up. But,
1488 bpstat_stop_status requires a location to be able to report
1489 stops, so make sure there's at least a dummy one. */
1490 if (b
->type
== bp_watchpoint
&& b
->loc
== NULL
)
1492 b
->loc
= allocate_bp_location (b
);
1493 b
->loc
->pspace
= frame_pspace
;
1494 b
->loc
->address
= -1;
1495 b
->loc
->length
= -1;
1496 b
->loc
->watchpoint_type
= -1;
1499 else if (!within_current_scope
)
1501 printf_filtered (_("\
1502 Watchpoint %d deleted because the program has left the block\n\
1503 in which its expression is valid.\n"),
1505 if (b
->related_breakpoint
)
1507 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
1508 b
->related_breakpoint
->related_breakpoint
= NULL
;
1509 b
->related_breakpoint
= NULL
;
1511 b
->disposition
= disp_del_at_next_stop
;
1514 /* Restore the selected frame. */
1516 select_frame (frame_find_by_id (saved_frame_id
));
1520 /* Returns 1 iff breakpoint location should be
1521 inserted in the inferior. */
1523 should_be_inserted (struct bp_location
*bpt
)
1525 if (bpt
->owner
== NULL
|| !breakpoint_enabled (bpt
->owner
))
1528 if (bpt
->owner
->disposition
== disp_del_at_next_stop
)
1531 if (!bpt
->enabled
|| bpt
->shlib_disabled
|| bpt
->duplicate
)
1534 /* This is set for example, when we're attached to the parent of a
1535 vfork, and have detached from the child. The child is running
1536 free, and we expect it to do an exec or exit, at which point the
1537 OS makes the parent schedulable again (and the target reports
1538 that the vfork is done). Until the child is done with the shared
1539 memory region, do not insert breakpoints in the parent, otherwise
1540 the child could still trip on the parent's breakpoints. Since
1541 the parent is blocked anyway, it won't miss any breakpoint. */
1542 if (bpt
->pspace
->breakpoints_not_allowed
)
1545 /* Tracepoints are inserted by the target at a time of its choosing,
1547 if (is_tracepoint (bpt
->owner
))
1553 /* Insert a low-level "breakpoint" of some type. BPT is the breakpoint.
1554 Any error messages are printed to TMP_ERROR_STREAM; and DISABLED_BREAKS,
1555 and HW_BREAKPOINT_ERROR are used to report problems.
1557 NOTE drow/2003-09-09: This routine could be broken down to an object-style
1558 method for each breakpoint or catchpoint type. */
1560 insert_bp_location (struct bp_location
*bpt
,
1561 struct ui_file
*tmp_error_stream
,
1562 int *disabled_breaks
,
1563 int *hw_breakpoint_error
)
1567 if (!should_be_inserted (bpt
) || bpt
->inserted
)
1570 /* Initialize the target-specific information. */
1571 memset (&bpt
->target_info
, 0, sizeof (bpt
->target_info
));
1572 bpt
->target_info
.placed_address
= bpt
->address
;
1573 bpt
->target_info
.placed_address_space
= bpt
->pspace
->aspace
;
1575 if (bpt
->loc_type
== bp_loc_software_breakpoint
1576 || bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1578 if (bpt
->owner
->type
!= bp_hardware_breakpoint
)
1580 /* If the explicitly specified breakpoint type
1581 is not hardware breakpoint, check the memory map to see
1582 if the breakpoint address is in read only memory or not.
1583 Two important cases are:
1584 - location type is not hardware breakpoint, memory
1585 is readonly. We change the type of the location to
1586 hardware breakpoint.
1587 - location type is hardware breakpoint, memory is read-write.
1588 This means we've previously made the location hardware one, but
1589 then the memory map changed, so we undo.
1591 When breakpoints are removed, remove_breakpoints will
1592 use location types we've just set here, the only possible
1593 problem is that memory map has changed during running program,
1594 but it's not going to work anyway with current gdb. */
1595 struct mem_region
*mr
1596 = lookup_mem_region (bpt
->target_info
.placed_address
);
1600 if (automatic_hardware_breakpoints
)
1602 enum bp_loc_type new_type
;
1604 if (mr
->attrib
.mode
!= MEM_RW
)
1605 new_type
= bp_loc_hardware_breakpoint
;
1607 new_type
= bp_loc_software_breakpoint
;
1609 if (new_type
!= bpt
->loc_type
)
1611 static int said
= 0;
1613 bpt
->loc_type
= new_type
;
1616 fprintf_filtered (gdb_stdout
, _("\
1617 Note: automatically using hardware breakpoints for read-only addresses.\n"));
1622 else if (bpt
->loc_type
== bp_loc_software_breakpoint
1623 && mr
->attrib
.mode
!= MEM_RW
)
1624 warning (_("cannot set software breakpoint at readonly address %s"),
1625 paddress (bpt
->gdbarch
, bpt
->address
));
1629 /* First check to see if we have to handle an overlay. */
1630 if (overlay_debugging
== ovly_off
1631 || bpt
->section
== NULL
1632 || !(section_is_overlay (bpt
->section
)))
1634 /* No overlay handling: just set the breakpoint. */
1636 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1637 val
= target_insert_hw_breakpoint (bpt
->gdbarch
,
1640 val
= target_insert_breakpoint (bpt
->gdbarch
,
1645 /* This breakpoint is in an overlay section.
1646 Shall we set a breakpoint at the LMA? */
1647 if (!overlay_events_enabled
)
1649 /* Yes -- overlay event support is not active,
1650 so we must try to set a breakpoint at the LMA.
1651 This will not work for a hardware breakpoint. */
1652 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1653 warning (_("hardware breakpoint %d not supported in overlay!"),
1654 bpt
->owner
->number
);
1657 CORE_ADDR addr
= overlay_unmapped_address (bpt
->address
,
1659 /* Set a software (trap) breakpoint at the LMA. */
1660 bpt
->overlay_target_info
= bpt
->target_info
;
1661 bpt
->overlay_target_info
.placed_address
= addr
;
1662 val
= target_insert_breakpoint (bpt
->gdbarch
,
1663 &bpt
->overlay_target_info
);
1665 fprintf_unfiltered (tmp_error_stream
,
1666 "Overlay breakpoint %d failed: in ROM?\n",
1667 bpt
->owner
->number
);
1670 /* Shall we set a breakpoint at the VMA? */
1671 if (section_is_mapped (bpt
->section
))
1673 /* Yes. This overlay section is mapped into memory. */
1674 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1675 val
= target_insert_hw_breakpoint (bpt
->gdbarch
,
1678 val
= target_insert_breakpoint (bpt
->gdbarch
,
1683 /* No. This breakpoint will not be inserted.
1684 No error, but do not mark the bp as 'inserted'. */
1691 /* Can't set the breakpoint. */
1692 if (solib_name_from_address (bpt
->pspace
, bpt
->address
))
1694 /* See also: disable_breakpoints_in_shlibs. */
1696 bpt
->shlib_disabled
= 1;
1697 if (!*disabled_breaks
)
1699 fprintf_unfiltered (tmp_error_stream
,
1700 "Cannot insert breakpoint %d.\n",
1701 bpt
->owner
->number
);
1702 fprintf_unfiltered (tmp_error_stream
,
1703 "Temporarily disabling shared library breakpoints:\n");
1705 *disabled_breaks
= 1;
1706 fprintf_unfiltered (tmp_error_stream
,
1707 "breakpoint #%d\n", bpt
->owner
->number
);
1711 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1713 *hw_breakpoint_error
= 1;
1714 fprintf_unfiltered (tmp_error_stream
,
1715 "Cannot insert hardware breakpoint %d.\n",
1716 bpt
->owner
->number
);
1720 fprintf_unfiltered (tmp_error_stream
,
1721 "Cannot insert breakpoint %d.\n",
1722 bpt
->owner
->number
);
1723 fprintf_filtered (tmp_error_stream
,
1724 "Error accessing memory address ");
1725 fputs_filtered (paddress (bpt
->gdbarch
, bpt
->address
),
1727 fprintf_filtered (tmp_error_stream
, ": %s.\n",
1728 safe_strerror (val
));
1739 else if (bpt
->loc_type
== bp_loc_hardware_watchpoint
1740 /* NOTE drow/2003-09-08: This state only exists for removing
1741 watchpoints. It's not clear that it's necessary... */
1742 && bpt
->owner
->disposition
!= disp_del_at_next_stop
)
1744 val
= target_insert_watchpoint (bpt
->address
,
1746 bpt
->watchpoint_type
,
1747 bpt
->owner
->cond_exp
);
1749 /* If trying to set a read-watchpoint, and it turns out it's not
1750 supported, try emulating one with an access watchpoint. */
1751 if (val
== 1 && bpt
->watchpoint_type
== hw_read
)
1753 struct bp_location
*loc
, **loc_temp
;
1755 /* But don't try to insert it, if there's already another
1756 hw_access location that would be considered a duplicate
1758 ALL_BP_LOCATIONS (loc
, loc_temp
)
1760 && loc
->watchpoint_type
== hw_access
1761 && watchpoint_locations_match (bpt
, loc
))
1765 bpt
->target_info
= loc
->target_info
;
1766 bpt
->watchpoint_type
= hw_access
;
1773 val
= target_insert_watchpoint (bpt
->address
,
1776 bpt
->owner
->cond_exp
);
1778 bpt
->watchpoint_type
= hw_access
;
1782 bpt
->inserted
= (val
== 0);
1785 else if (bpt
->owner
->type
== bp_catchpoint
)
1787 struct gdb_exception e
= catch_exception (uiout
, insert_catchpoint
,
1788 bpt
->owner
, RETURN_MASK_ERROR
);
1789 exception_fprintf (gdb_stderr
, e
, "warning: inserting catchpoint %d: ",
1790 bpt
->owner
->number
);
1792 bpt
->owner
->enable_state
= bp_disabled
;
1796 /* We've already printed an error message if there was a problem
1797 inserting this catchpoint, and we've disabled the catchpoint,
1798 so just return success. */
1805 /* This function is called when program space PSPACE is about to be
1806 deleted. It takes care of updating breakpoints to not reference
1810 breakpoint_program_space_exit (struct program_space
*pspace
)
1812 struct breakpoint
*b
, *b_temp
;
1813 struct bp_location
*loc
, **loc_temp
;
1815 /* Remove any breakpoint that was set through this program space. */
1816 ALL_BREAKPOINTS_SAFE (b
, b_temp
)
1818 if (b
->pspace
== pspace
)
1819 delete_breakpoint (b
);
1822 /* Breakpoints set through other program spaces could have locations
1823 bound to PSPACE as well. Remove those. */
1824 ALL_BP_LOCATIONS (loc
, loc_temp
)
1826 struct bp_location
*tmp
;
1828 if (loc
->pspace
== pspace
)
1830 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
1831 if (loc
->owner
->loc
== loc
)
1832 loc
->owner
->loc
= loc
->next
;
1834 for (tmp
= loc
->owner
->loc
; tmp
->next
!= NULL
; tmp
= tmp
->next
)
1835 if (tmp
->next
== loc
)
1837 tmp
->next
= loc
->next
;
1843 /* Now update the global location list to permanently delete the
1844 removed locations above. */
1845 update_global_location_list (0);
1848 /* Make sure all breakpoints are inserted in inferior.
1849 Throws exception on any error.
1850 A breakpoint that is already inserted won't be inserted
1851 again, so calling this function twice is safe. */
1853 insert_breakpoints (void)
1855 struct breakpoint
*bpt
;
1857 ALL_BREAKPOINTS (bpt
)
1858 if (is_hardware_watchpoint (bpt
))
1859 update_watchpoint (bpt
, 0 /* don't reparse. */);
1861 update_global_location_list (1);
1863 /* update_global_location_list does not insert breakpoints when
1864 always_inserted_mode is not enabled. Explicitly insert them
1866 if (!breakpoints_always_inserted_mode ())
1867 insert_breakpoint_locations ();
1870 /* insert_breakpoints is used when starting or continuing the program.
1871 remove_breakpoints is used when the program stops.
1872 Both return zero if successful,
1873 or an `errno' value if could not write the inferior. */
1876 insert_breakpoint_locations (void)
1878 struct breakpoint
*bpt
;
1879 struct bp_location
*b
, **bp_tmp
;
1882 int disabled_breaks
= 0;
1883 int hw_breakpoint_error
= 0;
1885 struct ui_file
*tmp_error_stream
= mem_fileopen ();
1886 struct cleanup
*cleanups
= make_cleanup_ui_file_delete (tmp_error_stream
);
1888 /* Explicitly mark the warning -- this will only be printed if
1889 there was an error. */
1890 fprintf_unfiltered (tmp_error_stream
, "Warning:\n");
1892 save_current_space_and_thread ();
1894 ALL_BP_LOCATIONS (b
, bp_tmp
)
1896 if (!should_be_inserted (b
) || b
->inserted
)
1899 /* There is no point inserting thread-specific breakpoints if the
1900 thread no longer exists. ALL_BP_LOCATIONS bp_location has B->OWNER
1902 if (b
->owner
->thread
!= -1
1903 && !valid_thread_id (b
->owner
->thread
))
1906 switch_to_program_space_and_thread (b
->pspace
);
1908 /* For targets that support global breakpoints, there's no need
1909 to select an inferior to insert breakpoint to. In fact, even
1910 if we aren't attached to any process yet, we should still
1911 insert breakpoints. */
1912 if (!gdbarch_has_global_breakpoints (target_gdbarch
)
1913 && ptid_equal (inferior_ptid
, null_ptid
))
1916 val
= insert_bp_location (b
, tmp_error_stream
,
1918 &hw_breakpoint_error
);
1923 /* If we failed to insert all locations of a watchpoint,
1924 remove them, as half-inserted watchpoint is of limited use. */
1925 ALL_BREAKPOINTS (bpt
)
1927 int some_failed
= 0;
1928 struct bp_location
*loc
;
1930 if (!is_hardware_watchpoint (bpt
))
1933 if (!breakpoint_enabled (bpt
))
1936 if (bpt
->disposition
== disp_del_at_next_stop
)
1939 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
1940 if (!loc
->inserted
&& should_be_inserted (loc
))
1947 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
1949 remove_breakpoint (loc
, mark_uninserted
);
1951 hw_breakpoint_error
= 1;
1952 fprintf_unfiltered (tmp_error_stream
,
1953 "Could not insert hardware watchpoint %d.\n",
1961 /* If a hardware breakpoint or watchpoint was inserted, add a
1962 message about possibly exhausted resources. */
1963 if (hw_breakpoint_error
)
1965 fprintf_unfiltered (tmp_error_stream
,
1966 "Could not insert hardware breakpoints:\n\
1967 You may have requested too many hardware breakpoints/watchpoints.\n");
1969 target_terminal_ours_for_output ();
1970 error_stream (tmp_error_stream
);
1973 do_cleanups (cleanups
);
1977 remove_breakpoints (void)
1979 struct bp_location
*b
, **bp_tmp
;
1982 ALL_BP_LOCATIONS (b
, bp_tmp
)
1985 val
|= remove_breakpoint (b
, mark_uninserted
);
1990 /* Remove breakpoints of process PID. */
1993 remove_breakpoints_pid (int pid
)
1995 struct bp_location
*b
, **b_tmp
;
1997 struct inferior
*inf
= find_inferior_pid (pid
);
1999 ALL_BP_LOCATIONS (b
, b_tmp
)
2001 if (b
->pspace
!= inf
->pspace
)
2006 val
= remove_breakpoint (b
, mark_uninserted
);
2015 remove_hw_watchpoints (void)
2017 struct bp_location
*b
, **bp_tmp
;
2020 ALL_BP_LOCATIONS (b
, bp_tmp
)
2022 if (b
->inserted
&& b
->loc_type
== bp_loc_hardware_watchpoint
)
2023 val
|= remove_breakpoint (b
, mark_uninserted
);
2029 reattach_breakpoints (int pid
)
2031 struct cleanup
*old_chain
;
2032 struct bp_location
*b
, **bp_tmp
;
2034 struct ui_file
*tmp_error_stream
= mem_fileopen ();
2035 int dummy1
= 0, dummy2
= 0;
2036 struct inferior
*inf
;
2037 struct thread_info
*tp
;
2039 tp
= any_live_thread_of_process (pid
);
2043 inf
= find_inferior_pid (pid
);
2044 old_chain
= save_inferior_ptid ();
2046 inferior_ptid
= tp
->ptid
;
2048 make_cleanup_ui_file_delete (tmp_error_stream
);
2050 ALL_BP_LOCATIONS (b
, bp_tmp
)
2052 if (b
->pspace
!= inf
->pspace
)
2058 val
= insert_bp_location (b
, tmp_error_stream
,
2062 do_cleanups (old_chain
);
2067 do_cleanups (old_chain
);
2071 static int internal_breakpoint_number
= -1;
2073 static struct breakpoint
*
2074 create_internal_breakpoint (struct gdbarch
*gdbarch
,
2075 CORE_ADDR address
, enum bptype type
)
2077 struct symtab_and_line sal
;
2078 struct breakpoint
*b
;
2080 init_sal (&sal
); /* initialize to zeroes */
2083 sal
.section
= find_pc_overlay (sal
.pc
);
2084 sal
.pspace
= current_program_space
;
2086 b
= set_raw_breakpoint (gdbarch
, sal
, type
);
2087 b
->number
= internal_breakpoint_number
--;
2088 b
->disposition
= disp_donttouch
;
2094 create_overlay_event_breakpoint (char *func_name
)
2096 struct objfile
*objfile
;
2098 ALL_OBJFILES (objfile
)
2100 struct breakpoint
*b
;
2101 struct minimal_symbol
*m
;
2103 m
= lookup_minimal_symbol_text (func_name
, objfile
);
2107 b
= create_internal_breakpoint (get_objfile_arch (objfile
),
2108 SYMBOL_VALUE_ADDRESS (m
),
2110 b
->addr_string
= xstrdup (func_name
);
2112 if (overlay_debugging
== ovly_auto
)
2114 b
->enable_state
= bp_enabled
;
2115 overlay_events_enabled
= 1;
2119 b
->enable_state
= bp_disabled
;
2120 overlay_events_enabled
= 0;
2123 update_global_location_list (1);
2127 create_longjmp_master_breakpoint (char *func_name
)
2129 struct program_space
*pspace
;
2130 struct objfile
*objfile
;
2131 struct cleanup
*old_chain
;
2133 old_chain
= save_current_program_space ();
2135 ALL_PSPACES (pspace
)
2136 ALL_OBJFILES (objfile
)
2138 struct breakpoint
*b
;
2139 struct minimal_symbol
*m
;
2141 if (!gdbarch_get_longjmp_target_p (get_objfile_arch (objfile
)))
2144 set_current_program_space (pspace
);
2146 m
= lookup_minimal_symbol_text (func_name
, objfile
);
2150 b
= create_internal_breakpoint (get_objfile_arch (objfile
),
2151 SYMBOL_VALUE_ADDRESS (m
),
2153 b
->addr_string
= xstrdup (func_name
);
2154 b
->enable_state
= bp_disabled
;
2156 update_global_location_list (1);
2158 do_cleanups (old_chain
);
2161 /* Create a master std::terminate breakpoint. The actual function
2162 looked for is named FUNC_NAME. */
2164 create_std_terminate_master_breakpoint (const char *func_name
)
2166 struct program_space
*pspace
;
2167 struct objfile
*objfile
;
2168 struct cleanup
*old_chain
;
2170 old_chain
= save_current_program_space ();
2172 ALL_PSPACES (pspace
)
2173 ALL_OBJFILES (objfile
)
2175 struct breakpoint
*b
;
2176 struct minimal_symbol
*m
;
2178 set_current_program_space (pspace
);
2180 m
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
2181 if (m
== NULL
|| (MSYMBOL_TYPE (m
) != mst_text
2182 && MSYMBOL_TYPE (m
) != mst_file_text
))
2185 b
= create_internal_breakpoint (get_objfile_arch (objfile
),
2186 SYMBOL_VALUE_ADDRESS (m
),
2187 bp_std_terminate_master
);
2188 b
->addr_string
= xstrdup (func_name
);
2189 b
->enable_state
= bp_disabled
;
2191 update_global_location_list (1);
2193 do_cleanups (old_chain
);
2197 update_breakpoints_after_exec (void)
2199 struct breakpoint
*b
;
2200 struct breakpoint
*temp
;
2201 struct bp_location
*bploc
, **bplocp_tmp
;
2203 /* We're about to delete breakpoints from GDB's lists. If the
2204 INSERTED flag is true, GDB will try to lift the breakpoints by
2205 writing the breakpoints' "shadow contents" back into memory. The
2206 "shadow contents" are NOT valid after an exec, so GDB should not
2207 do that. Instead, the target is responsible from marking
2208 breakpoints out as soon as it detects an exec. We don't do that
2209 here instead, because there may be other attempts to delete
2210 breakpoints after detecting an exec and before reaching here. */
2211 ALL_BP_LOCATIONS (bploc
, bplocp_tmp
)
2212 if (bploc
->pspace
== current_program_space
)
2213 gdb_assert (!bploc
->inserted
);
2215 ALL_BREAKPOINTS_SAFE (b
, temp
)
2217 if (b
->pspace
!= current_program_space
)
2220 /* Solib breakpoints must be explicitly reset after an exec(). */
2221 if (b
->type
== bp_shlib_event
)
2223 delete_breakpoint (b
);
2227 /* JIT breakpoints must be explicitly reset after an exec(). */
2228 if (b
->type
== bp_jit_event
)
2230 delete_breakpoint (b
);
2234 /* Thread event breakpoints must be set anew after an exec(),
2235 as must overlay event and longjmp master breakpoints. */
2236 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
2237 || b
->type
== bp_longjmp_master
|| b
->type
== bp_std_terminate_master
)
2239 delete_breakpoint (b
);
2243 /* Step-resume breakpoints are meaningless after an exec(). */
2244 if (b
->type
== bp_step_resume
)
2246 delete_breakpoint (b
);
2250 /* Longjmp and longjmp-resume breakpoints are also meaningless
2252 if (b
->type
== bp_longjmp
|| b
->type
== bp_longjmp_resume
)
2254 delete_breakpoint (b
);
2258 if (b
->type
== bp_catchpoint
)
2260 /* For now, none of the bp_catchpoint breakpoints need to
2261 do anything at this point. In the future, if some of
2262 the catchpoints need to something, we will need to add
2263 a new method, and call this method from here. */
2267 /* bp_finish is a special case. The only way we ought to be able
2268 to see one of these when an exec() has happened, is if the user
2269 caught a vfork, and then said "finish". Ordinarily a finish just
2270 carries them to the call-site of the current callee, by setting
2271 a temporary bp there and resuming. But in this case, the finish
2272 will carry them entirely through the vfork & exec.
2274 We don't want to allow a bp_finish to remain inserted now. But
2275 we can't safely delete it, 'cause finish_command has a handle to
2276 the bp on a bpstat, and will later want to delete it. There's a
2277 chance (and I've seen it happen) that if we delete the bp_finish
2278 here, that its storage will get reused by the time finish_command
2279 gets 'round to deleting the "use to be a bp_finish" breakpoint.
2280 We really must allow finish_command to delete a bp_finish.
2282 In the absense of a general solution for the "how do we know
2283 it's safe to delete something others may have handles to?"
2284 problem, what we'll do here is just uninsert the bp_finish, and
2285 let finish_command delete it.
2287 (We know the bp_finish is "doomed" in the sense that it's
2288 momentary, and will be deleted as soon as finish_command sees
2289 the inferior stopped. So it doesn't matter that the bp's
2290 address is probably bogus in the new a.out, unlike e.g., the
2291 solib breakpoints.) */
2293 if (b
->type
== bp_finish
)
2298 /* Without a symbolic address, we have little hope of the
2299 pre-exec() address meaning the same thing in the post-exec()
2301 if (b
->addr_string
== NULL
)
2303 delete_breakpoint (b
);
2307 /* FIXME what about longjmp breakpoints? Re-create them here? */
2308 create_overlay_event_breakpoint ("_ovly_debug_event");
2309 create_longjmp_master_breakpoint ("longjmp");
2310 create_longjmp_master_breakpoint ("_longjmp");
2311 create_longjmp_master_breakpoint ("siglongjmp");
2312 create_longjmp_master_breakpoint ("_siglongjmp");
2313 create_std_terminate_master_breakpoint ("std::terminate()");
2317 detach_breakpoints (int pid
)
2319 struct bp_location
*b
, **bp_tmp
;
2321 struct cleanup
*old_chain
= save_inferior_ptid ();
2322 struct inferior
*inf
= current_inferior ();
2324 if (pid
== PIDGET (inferior_ptid
))
2325 error (_("Cannot detach breakpoints of inferior_ptid"));
2327 /* Set inferior_ptid; remove_breakpoint_1 uses this global. */
2328 inferior_ptid
= pid_to_ptid (pid
);
2329 ALL_BP_LOCATIONS (b
, bp_tmp
)
2331 if (b
->pspace
!= inf
->pspace
)
2335 val
|= remove_breakpoint_1 (b
, mark_inserted
);
2338 /* Detach single-step breakpoints as well. */
2339 detach_single_step_breakpoints ();
2341 do_cleanups (old_chain
);
2345 /* Remove the breakpoint location B from the current address space.
2346 Note that this is used to detach breakpoints from a child fork.
2347 When we get here, the child isn't in the inferior list, and neither
2348 do we have objects to represent its address space --- we should
2349 *not* look at b->pspace->aspace here. */
2352 remove_breakpoint_1 (struct bp_location
*b
, insertion_state_t is
)
2356 /* B is never in moribund_locations by our callers. */
2357 gdb_assert (b
->owner
!= NULL
);
2359 if (b
->owner
->enable_state
== bp_permanent
)
2360 /* Permanent breakpoints cannot be inserted or removed. */
2363 /* The type of none suggests that owner is actually deleted.
2364 This should not ever happen. */
2365 gdb_assert (b
->owner
->type
!= bp_none
);
2367 if (b
->loc_type
== bp_loc_software_breakpoint
2368 || b
->loc_type
== bp_loc_hardware_breakpoint
)
2370 /* "Normal" instruction breakpoint: either the standard
2371 trap-instruction bp (bp_breakpoint), or a
2372 bp_hardware_breakpoint. */
2374 /* First check to see if we have to handle an overlay. */
2375 if (overlay_debugging
== ovly_off
2376 || b
->section
== NULL
2377 || !(section_is_overlay (b
->section
)))
2379 /* No overlay handling: just remove the breakpoint. */
2381 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
2382 val
= target_remove_hw_breakpoint (b
->gdbarch
, &b
->target_info
);
2384 val
= target_remove_breakpoint (b
->gdbarch
, &b
->target_info
);
2388 /* This breakpoint is in an overlay section.
2389 Did we set a breakpoint at the LMA? */
2390 if (!overlay_events_enabled
)
2392 /* Yes -- overlay event support is not active, so we
2393 should have set a breakpoint at the LMA. Remove it.
2395 /* Ignore any failures: if the LMA is in ROM, we will
2396 have already warned when we failed to insert it. */
2397 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
2398 target_remove_hw_breakpoint (b
->gdbarch
,
2399 &b
->overlay_target_info
);
2401 target_remove_breakpoint (b
->gdbarch
,
2402 &b
->overlay_target_info
);
2404 /* Did we set a breakpoint at the VMA?
2405 If so, we will have marked the breakpoint 'inserted'. */
2408 /* Yes -- remove it. Previously we did not bother to
2409 remove the breakpoint if the section had been
2410 unmapped, but let's not rely on that being safe. We
2411 don't know what the overlay manager might do. */
2412 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
2413 val
= target_remove_hw_breakpoint (b
->gdbarch
,
2416 /* However, we should remove *software* breakpoints only
2417 if the section is still mapped, or else we overwrite
2418 wrong code with the saved shadow contents. */
2419 else if (section_is_mapped (b
->section
))
2420 val
= target_remove_breakpoint (b
->gdbarch
,
2427 /* No -- not inserted, so no need to remove. No error. */
2432 /* In some cases, we might not be able to remove a breakpoint
2433 in a shared library that has already been removed, but we
2434 have not yet processed the shlib unload event. */
2435 if (val
&& solib_name_from_address (b
->pspace
, b
->address
))
2440 b
->inserted
= (is
== mark_inserted
);
2442 else if (b
->loc_type
== bp_loc_hardware_watchpoint
)
2444 b
->inserted
= (is
== mark_inserted
);
2445 val
= target_remove_watchpoint (b
->address
, b
->length
,
2446 b
->watchpoint_type
, b
->owner
->cond_exp
);
2448 /* Failure to remove any of the hardware watchpoints comes here. */
2449 if ((is
== mark_uninserted
) && (b
->inserted
))
2450 warning (_("Could not remove hardware watchpoint %d."),
2453 else if (b
->owner
->type
== bp_catchpoint
2454 && breakpoint_enabled (b
->owner
)
2457 gdb_assert (b
->owner
->ops
!= NULL
&& b
->owner
->ops
->remove
!= NULL
);
2459 val
= b
->owner
->ops
->remove (b
->owner
);
2462 b
->inserted
= (is
== mark_inserted
);
2469 remove_breakpoint (struct bp_location
*b
, insertion_state_t is
)
2472 struct cleanup
*old_chain
;
2474 /* B is never in moribund_locations by our callers. */
2475 gdb_assert (b
->owner
!= NULL
);
2477 if (b
->owner
->enable_state
== bp_permanent
)
2478 /* Permanent breakpoints cannot be inserted or removed. */
2481 /* The type of none suggests that owner is actually deleted.
2482 This should not ever happen. */
2483 gdb_assert (b
->owner
->type
!= bp_none
);
2485 old_chain
= save_current_space_and_thread ();
2487 switch_to_program_space_and_thread (b
->pspace
);
2489 ret
= remove_breakpoint_1 (b
, is
);
2491 do_cleanups (old_chain
);
2495 /* Clear the "inserted" flag in all breakpoints. */
2498 mark_breakpoints_out (void)
2500 struct bp_location
*bpt
, **bptp_tmp
;
2502 ALL_BP_LOCATIONS (bpt
, bptp_tmp
)
2503 if (bpt
->pspace
== current_program_space
)
2507 /* Clear the "inserted" flag in all breakpoints and delete any
2508 breakpoints which should go away between runs of the program.
2510 Plus other such housekeeping that has to be done for breakpoints
2513 Note: this function gets called at the end of a run (by
2514 generic_mourn_inferior) and when a run begins (by
2515 init_wait_for_inferior). */
2520 breakpoint_init_inferior (enum inf_context context
)
2522 struct breakpoint
*b
, *temp
;
2523 struct bp_location
*bpt
, **bptp_tmp
;
2525 struct program_space
*pspace
= current_program_space
;
2527 /* If breakpoint locations are shared across processes, then there's
2529 if (gdbarch_has_global_breakpoints (target_gdbarch
))
2532 ALL_BP_LOCATIONS (bpt
, bptp_tmp
)
2534 /* ALL_BP_LOCATIONS bp_location has BPT->OWNER always non-NULL. */
2535 if (bpt
->pspace
== pspace
2536 && bpt
->owner
->enable_state
!= bp_permanent
)
2540 ALL_BREAKPOINTS_SAFE (b
, temp
)
2542 if (b
->loc
&& b
->loc
->pspace
!= pspace
)
2549 /* If the call dummy breakpoint is at the entry point it will
2550 cause problems when the inferior is rerun, so we better get
2553 case bp_watchpoint_scope
:
2555 /* Also get rid of scope breakpoints. */
2557 case bp_shlib_event
:
2559 /* Also remove solib event breakpoints. Their addresses may
2560 have changed since the last time we ran the program.
2561 Actually we may now be debugging against different target;
2562 and so the solib backend that installed this breakpoint may
2563 not be used in by the target. E.g.,
2565 (gdb) file prog-linux
2566 (gdb) run # native linux target
2569 (gdb) file prog-win.exe
2570 (gdb) tar rem :9999 # remote Windows gdbserver.
2573 delete_breakpoint (b
);
2577 case bp_hardware_watchpoint
:
2578 case bp_read_watchpoint
:
2579 case bp_access_watchpoint
:
2581 /* Likewise for watchpoints on local expressions. */
2582 if (b
->exp_valid_block
!= NULL
)
2583 delete_breakpoint (b
);
2584 else if (context
== inf_starting
)
2586 /* Reset val field to force reread of starting value
2587 in insert_breakpoints. */
2589 value_free (b
->val
);
2599 /* Get rid of the moribund locations. */
2600 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, bpt
); ++ix
)
2601 free_bp_location (bpt
);
2602 VEC_free (bp_location_p
, moribund_locations
);
2605 /* These functions concern about actual breakpoints inserted in the
2606 target --- to e.g. check if we need to do decr_pc adjustment or if
2607 we need to hop over the bkpt --- so we check for address space
2608 match, not program space. */
2610 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
2611 exists at PC. It returns ordinary_breakpoint_here if it's an
2612 ordinary breakpoint, or permanent_breakpoint_here if it's a
2613 permanent breakpoint.
2614 - When continuing from a location with an ordinary breakpoint, we
2615 actually single step once before calling insert_breakpoints.
2616 - When continuing from a localion with a permanent breakpoint, we
2617 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
2618 the target, to advance the PC past the breakpoint. */
2620 enum breakpoint_here
2621 breakpoint_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2623 struct bp_location
*bpt
, **bptp_tmp
;
2624 int any_breakpoint_here
= 0;
2626 ALL_BP_LOCATIONS (bpt
, bptp_tmp
)
2628 if (bpt
->loc_type
!= bp_loc_software_breakpoint
2629 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
2632 /* ALL_BP_LOCATIONS bp_location has BPT->OWNER always non-NULL. */
2633 if ((breakpoint_enabled (bpt
->owner
)
2634 || bpt
->owner
->enable_state
== bp_permanent
)
2635 && breakpoint_address_match (bpt
->pspace
->aspace
, bpt
->address
,
2638 if (overlay_debugging
2639 && section_is_overlay (bpt
->section
)
2640 && !section_is_mapped (bpt
->section
))
2641 continue; /* unmapped overlay -- can't be a match */
2642 else if (bpt
->owner
->enable_state
== bp_permanent
)
2643 return permanent_breakpoint_here
;
2645 any_breakpoint_here
= 1;
2649 return any_breakpoint_here
? ordinary_breakpoint_here
: 0;
2652 /* Return true if there's a moribund breakpoint at PC. */
2655 moribund_breakpoint_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2657 struct bp_location
*loc
;
2660 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
2661 if (breakpoint_address_match (loc
->pspace
->aspace
, loc
->address
,
2668 /* Returns non-zero if there's a breakpoint inserted at PC, which is
2669 inserted using regular breakpoint_chain / bp_location array mechanism.
2670 This does not check for single-step breakpoints, which are
2671 inserted and removed using direct target manipulation. */
2674 regular_breakpoint_inserted_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2676 struct bp_location
*bpt
, **bptp_tmp
;
2678 ALL_BP_LOCATIONS (bpt
, bptp_tmp
)
2680 if (bpt
->loc_type
!= bp_loc_software_breakpoint
2681 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
2685 && breakpoint_address_match (bpt
->pspace
->aspace
, bpt
->address
,
2688 if (overlay_debugging
2689 && section_is_overlay (bpt
->section
)
2690 && !section_is_mapped (bpt
->section
))
2691 continue; /* unmapped overlay -- can't be a match */
2699 /* Returns non-zero iff there's either regular breakpoint
2700 or a single step breakpoint inserted at PC. */
2703 breakpoint_inserted_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2705 if (regular_breakpoint_inserted_here_p (aspace
, pc
))
2708 if (single_step_breakpoint_inserted_here_p (aspace
, pc
))
2714 /* This function returns non-zero iff there is a software breakpoint
2718 software_breakpoint_inserted_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2720 struct bp_location
*bpt
, **bptp_tmp
;
2722 ALL_BP_LOCATIONS (bpt
, bptp_tmp
)
2724 if (bpt
->loc_type
!= bp_loc_software_breakpoint
)
2728 && breakpoint_address_match (bpt
->pspace
->aspace
, bpt
->address
,
2731 if (overlay_debugging
2732 && section_is_overlay (bpt
->section
)
2733 && !section_is_mapped (bpt
->section
))
2734 continue; /* unmapped overlay -- can't be a match */
2740 /* Also check for software single-step breakpoints. */
2741 if (single_step_breakpoint_inserted_here_p (aspace
, pc
))
2748 hardware_watchpoint_inserted_in_range (struct address_space
*aspace
,
2749 CORE_ADDR addr
, ULONGEST len
)
2751 struct breakpoint
*bpt
;
2753 ALL_BREAKPOINTS (bpt
)
2755 struct bp_location
*loc
;
2757 if (bpt
->type
!= bp_hardware_watchpoint
2758 && bpt
->type
!= bp_access_watchpoint
)
2761 if (!breakpoint_enabled (bpt
))
2764 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
2765 if (loc
->pspace
->aspace
== aspace
&& loc
->inserted
)
2769 /* Check for intersection. */
2770 l
= max (loc
->address
, addr
);
2771 h
= min (loc
->address
+ loc
->length
, addr
+ len
);
2779 /* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
2780 PC is valid for process/thread PTID. */
2783 breakpoint_thread_match (struct address_space
*aspace
, CORE_ADDR pc
,
2786 struct bp_location
*bpt
, **bptp_tmp
;
2787 /* The thread and task IDs associated to PTID, computed lazily. */
2791 ALL_BP_LOCATIONS (bpt
, bptp_tmp
)
2793 if (bpt
->loc_type
!= bp_loc_software_breakpoint
2794 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
2797 /* ALL_BP_LOCATIONS bp_location has BPT->OWNER always non-NULL. */
2798 if (!breakpoint_enabled (bpt
->owner
)
2799 && bpt
->owner
->enable_state
!= bp_permanent
)
2802 if (!breakpoint_address_match (bpt
->pspace
->aspace
, bpt
->address
,
2806 if (bpt
->owner
->thread
!= -1)
2808 /* This is a thread-specific breakpoint. Check that ptid
2809 matches that thread. If thread hasn't been computed yet,
2810 it is now time to do so. */
2812 thread
= pid_to_thread_id (ptid
);
2813 if (bpt
->owner
->thread
!= thread
)
2817 if (bpt
->owner
->task
!= 0)
2819 /* This is a task-specific breakpoint. Check that ptid
2820 matches that task. If task hasn't been computed yet,
2821 it is now time to do so. */
2823 task
= ada_get_task_number (ptid
);
2824 if (bpt
->owner
->task
!= task
)
2828 if (overlay_debugging
2829 && section_is_overlay (bpt
->section
)
2830 && !section_is_mapped (bpt
->section
))
2831 continue; /* unmapped overlay -- can't be a match */
2840 /* bpstat stuff. External routines' interfaces are documented
2844 ep_is_catchpoint (struct breakpoint
*ep
)
2846 return (ep
->type
== bp_catchpoint
);
2850 bpstat_free (bpstat bs
)
2852 if (bs
->old_val
!= NULL
)
2853 value_free (bs
->old_val
);
2854 decref_counted_command_line (&bs
->commands
);
2858 /* Clear a bpstat so that it says we are not at any breakpoint.
2859 Also free any storage that is part of a bpstat. */
2862 bpstat_clear (bpstat
*bsp
)
2879 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
2880 is part of the bpstat is copied as well. */
2883 bpstat_copy (bpstat bs
)
2887 bpstat retval
= NULL
;
2892 for (; bs
!= NULL
; bs
= bs
->next
)
2894 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
2895 memcpy (tmp
, bs
, sizeof (*tmp
));
2896 incref_counted_command_line (tmp
->commands
);
2897 if (bs
->old_val
!= NULL
)
2899 tmp
->old_val
= value_copy (bs
->old_val
);
2900 release_value (tmp
->old_val
);
2904 /* This is the first thing in the chain. */
2914 /* Find the bpstat associated with this breakpoint */
2917 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
2922 for (; bsp
!= NULL
; bsp
= bsp
->next
)
2924 if (bsp
->breakpoint_at
&& bsp
->breakpoint_at
->owner
== breakpoint
)
2930 /* Put in *NUM the breakpoint number of the first breakpoint we are stopped
2931 at. *BSP upon return is a bpstat which points to the remaining
2932 breakpoints stopped at (but which is not guaranteed to be good for
2933 anything but further calls to bpstat_num).
2934 Return 0 if passed a bpstat which does not indicate any breakpoints.
2935 Return -1 if stopped at a breakpoint that has been deleted since
2937 Return 1 otherwise. */
2940 bpstat_num (bpstat
*bsp
, int *num
)
2942 struct breakpoint
*b
;
2945 return 0; /* No more breakpoint values */
2947 /* We assume we'll never have several bpstats that
2948 correspond to a single breakpoint -- otherwise,
2949 this function might return the same number more
2950 than once and this will look ugly. */
2951 b
= (*bsp
)->breakpoint_at
? (*bsp
)->breakpoint_at
->owner
: NULL
;
2952 *bsp
= (*bsp
)->next
;
2954 return -1; /* breakpoint that's been deleted since */
2956 *num
= b
->number
; /* We have its number */
2960 /* Modify BS so that the actions will not be performed. */
2963 bpstat_clear_actions (bpstat bs
)
2965 for (; bs
!= NULL
; bs
= bs
->next
)
2967 decref_counted_command_line (&bs
->commands
);
2968 bs
->commands_left
= NULL
;
2969 if (bs
->old_val
!= NULL
)
2971 value_free (bs
->old_val
);
2977 /* Called when a command is about to proceed the inferior. */
2980 breakpoint_about_to_proceed (void)
2982 if (!ptid_equal (inferior_ptid
, null_ptid
))
2984 struct thread_info
*tp
= inferior_thread ();
2986 /* Allow inferior function calls in breakpoint commands to not
2987 interrupt the command list. When the call finishes
2988 successfully, the inferior will be standing at the same
2989 breakpoint as if nothing happened. */
2994 breakpoint_proceeded
= 1;
2997 /* Stub for cleaning up our state if we error-out of a breakpoint command */
2999 cleanup_executing_breakpoints (void *ignore
)
3001 executing_breakpoint_commands
= 0;
3004 /* Execute all the commands associated with all the breakpoints at this
3005 location. Any of these commands could cause the process to proceed
3006 beyond this point, etc. We look out for such changes by checking
3007 the global "breakpoint_proceeded" after each command.
3009 Returns true if a breakpoint command resumed the inferior. In that
3010 case, it is the caller's responsibility to recall it again with the
3011 bpstat of the current thread. */
3014 bpstat_do_actions_1 (bpstat
*bsp
)
3017 struct cleanup
*old_chain
;
3020 /* Avoid endless recursion if a `source' command is contained
3022 if (executing_breakpoint_commands
)
3025 executing_breakpoint_commands
= 1;
3026 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
3028 /* This pointer will iterate over the list of bpstat's. */
3031 breakpoint_proceeded
= 0;
3032 for (; bs
!= NULL
; bs
= bs
->next
)
3034 struct counted_command_line
*ccmd
;
3035 struct command_line
*cmd
;
3036 struct cleanup
*this_cmd_tree_chain
;
3038 /* Take ownership of the BSP's command tree, if it has one.
3040 The command tree could legitimately contain commands like
3041 'step' and 'next', which call clear_proceed_status, which
3042 frees stop_bpstat's command tree. To make sure this doesn't
3043 free the tree we're executing out from under us, we need to
3044 take ownership of the tree ourselves. Since a given bpstat's
3045 commands are only executed once, we don't need to copy it; we
3046 can clear the pointer in the bpstat, and make sure we free
3047 the tree when we're done. */
3048 ccmd
= bs
->commands
;
3049 bs
->commands
= NULL
;
3051 = make_cleanup_decref_counted_command_line (&ccmd
);
3052 cmd
= bs
->commands_left
;
3053 bs
->commands_left
= NULL
;
3057 execute_control_command (cmd
);
3059 if (breakpoint_proceeded
)
3065 /* We can free this command tree now. */
3066 do_cleanups (this_cmd_tree_chain
);
3068 if (breakpoint_proceeded
)
3070 if (target_can_async_p ())
3071 /* If we are in async mode, then the target might be still
3072 running, not stopped at any breakpoint, so nothing for
3073 us to do here -- just return to the event loop. */
3076 /* In sync mode, when execute_control_command returns
3077 we're already standing on the next breakpoint.
3078 Breakpoint commands for that stop were not run, since
3079 execute_command does not run breakpoint commands --
3080 only command_line_handler does, but that one is not
3081 involved in execution of breakpoint commands. So, we
3082 can now execute breakpoint commands. It should be
3083 noted that making execute_command do bpstat actions is
3084 not an option -- in this case we'll have recursive
3085 invocation of bpstat for each breakpoint with a
3086 command, and can easily blow up GDB stack. Instead, we
3087 return true, which will trigger the caller to recall us
3088 with the new stop_bpstat. */
3093 do_cleanups (old_chain
);
3098 bpstat_do_actions (void)
3100 /* Do any commands attached to breakpoint we are stopped at. */
3101 while (!ptid_equal (inferior_ptid
, null_ptid
)
3102 && target_has_execution
3103 && !is_exited (inferior_ptid
)
3104 && !is_executing (inferior_ptid
))
3105 /* Since in sync mode, bpstat_do_actions may resume the inferior,
3106 and only return when it is stopped at the next breakpoint, we
3107 keep doing breakpoint actions until it returns false to
3108 indicate the inferior was not resumed. */
3109 if (!bpstat_do_actions_1 (&inferior_thread ()->stop_bpstat
))
3113 /* Print out the (old or new) value associated with a watchpoint. */
3116 watchpoint_value_print (struct value
*val
, struct ui_file
*stream
)
3119 fprintf_unfiltered (stream
, _("<unreadable>"));
3122 struct value_print_options opts
;
3123 get_user_print_options (&opts
);
3124 value_print (val
, stream
, &opts
);
3128 /* This is the normal print function for a bpstat. In the future,
3129 much of this logic could (should?) be moved to bpstat_stop_status,
3130 by having it set different print_it values.
3132 Current scheme: When we stop, bpstat_print() is called. It loops
3133 through the bpstat list of things causing this stop, calling the
3134 print_bp_stop_message function on each one. The behavior of the
3135 print_bp_stop_message function depends on the print_it field of
3136 bpstat. If such field so indicates, call this function here.
3138 Return values from this routine (ultimately used by bpstat_print()
3139 and normal_stop() to decide what to do):
3140 PRINT_NOTHING: Means we already printed all we needed to print,
3141 don't print anything else.
3142 PRINT_SRC_ONLY: Means we printed something, and we do *not* desire
3143 that something to be followed by a location.
3144 PRINT_SCR_AND_LOC: Means we printed something, and we *do* desire
3145 that something to be followed by a location.
3146 PRINT_UNKNOWN: Means we printed nothing or we need to do some more
3149 static enum print_stop_action
3150 print_it_typical (bpstat bs
)
3152 struct cleanup
*old_chain
;
3153 struct breakpoint
*b
;
3154 const struct bp_location
*bl
;
3155 struct ui_stream
*stb
;
3157 enum print_stop_action result
;
3159 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
3160 which has since been deleted. */
3161 if (bs
->breakpoint_at
== NULL
)
3162 return PRINT_UNKNOWN
;
3163 bl
= bs
->breakpoint_at
;
3165 /* bl->owner can be NULL if it was a momentary breakpoint
3166 which has since been placed into moribund_locations. */
3167 if (bl
->owner
== NULL
)
3168 return PRINT_UNKNOWN
;
3171 stb
= ui_out_stream_new (uiout
);
3172 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
3177 case bp_hardware_breakpoint
:
3178 bp_temp
= bs
->breakpoint_at
->owner
->disposition
== disp_del
;
3179 if (bl
->address
!= bl
->requested_address
)
3180 breakpoint_adjustment_warning (bl
->requested_address
,
3183 annotate_breakpoint (b
->number
);
3185 ui_out_text (uiout
, "\nTemporary breakpoint ");
3187 ui_out_text (uiout
, "\nBreakpoint ");
3188 if (ui_out_is_mi_like_p (uiout
))
3190 ui_out_field_string (uiout
, "reason",
3191 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
3192 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
3194 ui_out_field_int (uiout
, "bkptno", b
->number
);
3195 ui_out_text (uiout
, ", ");
3196 result
= PRINT_SRC_AND_LOC
;
3199 case bp_shlib_event
:
3200 /* Did we stop because the user set the stop_on_solib_events
3201 variable? (If so, we report this as a generic, "Stopped due
3202 to shlib event" message.) */
3203 printf_filtered (_("Stopped due to shared library event\n"));
3204 result
= PRINT_NOTHING
;
3207 case bp_thread_event
:
3208 /* Not sure how we will get here.
3209 GDB should not stop for these breakpoints. */
3210 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
3211 result
= PRINT_NOTHING
;
3214 case bp_overlay_event
:
3215 /* By analogy with the thread event, GDB should not stop for these. */
3216 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
3217 result
= PRINT_NOTHING
;
3220 case bp_longjmp_master
:
3221 /* These should never be enabled. */
3222 printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
3223 result
= PRINT_NOTHING
;
3226 case bp_std_terminate_master
:
3227 /* These should never be enabled. */
3228 printf_filtered (_("std::terminate Master Breakpoint: gdb should not stop!\n"));
3229 result
= PRINT_NOTHING
;
3233 case bp_hardware_watchpoint
:
3234 annotate_watchpoint (b
->number
);
3235 if (ui_out_is_mi_like_p (uiout
))
3238 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
3240 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
3241 ui_out_text (uiout
, "\nOld value = ");
3242 watchpoint_value_print (bs
->old_val
, stb
->stream
);
3243 ui_out_field_stream (uiout
, "old", stb
);
3244 ui_out_text (uiout
, "\nNew value = ");
3245 watchpoint_value_print (b
->val
, stb
->stream
);
3246 ui_out_field_stream (uiout
, "new", stb
);
3247 ui_out_text (uiout
, "\n");
3248 /* More than one watchpoint may have been triggered. */
3249 result
= PRINT_UNKNOWN
;
3252 case bp_read_watchpoint
:
3253 if (ui_out_is_mi_like_p (uiout
))
3256 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
3258 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
3259 ui_out_text (uiout
, "\nValue = ");
3260 watchpoint_value_print (b
->val
, stb
->stream
);
3261 ui_out_field_stream (uiout
, "value", stb
);
3262 ui_out_text (uiout
, "\n");
3263 result
= PRINT_UNKNOWN
;
3266 case bp_access_watchpoint
:
3267 if (bs
->old_val
!= NULL
)
3269 annotate_watchpoint (b
->number
);
3270 if (ui_out_is_mi_like_p (uiout
))
3273 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
3275 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
3276 ui_out_text (uiout
, "\nOld value = ");
3277 watchpoint_value_print (bs
->old_val
, stb
->stream
);
3278 ui_out_field_stream (uiout
, "old", stb
);
3279 ui_out_text (uiout
, "\nNew value = ");
3284 if (ui_out_is_mi_like_p (uiout
))
3287 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
3288 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
3289 ui_out_text (uiout
, "\nValue = ");
3291 watchpoint_value_print (b
->val
, stb
->stream
);
3292 ui_out_field_stream (uiout
, "new", stb
);
3293 ui_out_text (uiout
, "\n");
3294 result
= PRINT_UNKNOWN
;
3297 /* Fall through, we don't deal with these types of breakpoints
3301 if (ui_out_is_mi_like_p (uiout
))
3304 async_reason_lookup (EXEC_ASYNC_FUNCTION_FINISHED
));
3305 result
= PRINT_UNKNOWN
;
3309 if (ui_out_is_mi_like_p (uiout
))
3312 async_reason_lookup (EXEC_ASYNC_LOCATION_REACHED
));
3313 result
= PRINT_UNKNOWN
;
3318 case bp_longjmp_resume
:
3319 case bp_step_resume
:
3320 case bp_watchpoint_scope
:
3322 case bp_std_terminate
:
3324 case bp_fast_tracepoint
:
3327 result
= PRINT_UNKNOWN
;
3331 do_cleanups (old_chain
);
3335 /* Generic routine for printing messages indicating why we
3336 stopped. The behavior of this function depends on the value
3337 'print_it' in the bpstat structure. Under some circumstances we
3338 may decide not to print anything here and delegate the task to
3341 static enum print_stop_action
3342 print_bp_stop_message (bpstat bs
)
3344 switch (bs
->print_it
)
3347 /* Nothing should be printed for this bpstat entry. */
3348 return PRINT_UNKNOWN
;
3352 /* We still want to print the frame, but we already printed the
3353 relevant messages. */
3354 return PRINT_SRC_AND_LOC
;
3357 case print_it_normal
:
3359 const struct bp_location
*bl
= bs
->breakpoint_at
;
3360 struct breakpoint
*b
= bl
? bl
->owner
: NULL
;
3362 /* Normal case. Call the breakpoint's print_it method, or
3363 print_it_typical. */
3364 /* FIXME: how breakpoint can ever be NULL here? */
3365 if (b
!= NULL
&& b
->ops
!= NULL
&& b
->ops
->print_it
!= NULL
)
3366 return b
->ops
->print_it (b
);
3368 return print_it_typical (bs
);
3373 internal_error (__FILE__
, __LINE__
,
3374 _("print_bp_stop_message: unrecognized enum value"));
3379 /* Print a message indicating what happened. This is called from
3380 normal_stop(). The input to this routine is the head of the bpstat
3381 list - a list of the eventpoints that caused this stop. This
3382 routine calls the generic print routine for printing a message
3383 about reasons for stopping. This will print (for example) the
3384 "Breakpoint n," part of the output. The return value of this
3387 PRINT_UNKNOWN: Means we printed nothing
3388 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
3389 code to print the location. An example is
3390 "Breakpoint 1, " which should be followed by
3392 PRINT_SRC_ONLY: Means we printed something, but there is no need
3393 to also print the location part of the message.
3394 An example is the catch/throw messages, which
3395 don't require a location appended to the end.
3396 PRINT_NOTHING: We have done some printing and we don't need any
3397 further info to be printed.*/
3399 enum print_stop_action
3400 bpstat_print (bpstat bs
)
3404 /* Maybe another breakpoint in the chain caused us to stop.
3405 (Currently all watchpoints go on the bpstat whether hit or not.
3406 That probably could (should) be changed, provided care is taken
3407 with respect to bpstat_explains_signal). */
3408 for (; bs
; bs
= bs
->next
)
3410 val
= print_bp_stop_message (bs
);
3411 if (val
== PRINT_SRC_ONLY
3412 || val
== PRINT_SRC_AND_LOC
3413 || val
== PRINT_NOTHING
)
3417 /* We reached the end of the chain, or we got a null BS to start
3418 with and nothing was printed. */
3419 return PRINT_UNKNOWN
;
3422 /* Evaluate the expression EXP and return 1 if value is zero.
3423 This is used inside a catch_errors to evaluate the breakpoint condition.
3424 The argument is a "struct expression *" that has been cast to char * to
3425 make it pass through catch_errors. */
3428 breakpoint_cond_eval (void *exp
)
3430 struct value
*mark
= value_mark ();
3431 int i
= !value_true (evaluate_expression ((struct expression
*) exp
));
3433 value_free_to_mark (mark
);
3437 /* Allocate a new bpstat and chain it to the current one. */
3440 bpstat_alloc (const struct bp_location
*bl
, bpstat cbs
/* Current "bs" value */ )
3444 bs
= (bpstat
) xmalloc (sizeof (*bs
));
3446 bs
->breakpoint_at
= bl
;
3447 /* If the condition is false, etc., don't do the commands. */
3448 bs
->commands
= NULL
;
3449 bs
->commands_left
= NULL
;
3451 bs
->print_it
= print_it_normal
;
3455 /* The target has stopped with waitstatus WS. Check if any hardware
3456 watchpoints have triggered, according to the target. */
3459 watchpoints_triggered (struct target_waitstatus
*ws
)
3461 int stopped_by_watchpoint
= target_stopped_by_watchpoint ();
3463 struct breakpoint
*b
;
3465 if (!stopped_by_watchpoint
)
3467 /* We were not stopped by a watchpoint. Mark all watchpoints
3468 as not triggered. */
3470 if (is_hardware_watchpoint (b
))
3471 b
->watchpoint_triggered
= watch_triggered_no
;
3476 if (!target_stopped_data_address (¤t_target
, &addr
))
3478 /* We were stopped by a watchpoint, but we don't know where.
3479 Mark all watchpoints as unknown. */
3481 if (is_hardware_watchpoint (b
))
3482 b
->watchpoint_triggered
= watch_triggered_unknown
;
3484 return stopped_by_watchpoint
;
3487 /* The target could report the data address. Mark watchpoints
3488 affected by this data address as triggered, and all others as not
3492 if (is_hardware_watchpoint (b
))
3494 struct bp_location
*loc
;
3496 b
->watchpoint_triggered
= watch_triggered_no
;
3497 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
3498 /* Exact match not required. Within range is
3500 if (target_watchpoint_addr_within_range (¤t_target
,
3504 b
->watchpoint_triggered
= watch_triggered_yes
;
3512 /* Possible return values for watchpoint_check (this can't be an enum
3513 because of check_errors). */
3514 /* The watchpoint has been deleted. */
3515 #define WP_DELETED 1
3516 /* The value has changed. */
3517 #define WP_VALUE_CHANGED 2
3518 /* The value has not changed. */
3519 #define WP_VALUE_NOT_CHANGED 3
3520 /* Ignore this watchpoint, no matter if the value changed or not. */
3523 #define BP_TEMPFLAG 1
3524 #define BP_HARDWAREFLAG 2
3526 /* Evaluate watchpoint condition expression and check if its value changed.
3528 P should be a pointer to struct bpstat, but is defined as a void *
3529 in order for this function to be usable with catch_errors. */
3532 watchpoint_check (void *p
)
3534 bpstat bs
= (bpstat
) p
;
3535 struct breakpoint
*b
;
3536 struct frame_info
*fr
;
3537 int within_current_scope
;
3539 /* BS is built for existing struct breakpoint. */
3540 gdb_assert (bs
->breakpoint_at
!= NULL
);
3541 gdb_assert (bs
->breakpoint_at
->owner
!= NULL
);
3542 b
= bs
->breakpoint_at
->owner
;
3544 /* If this is a local watchpoint, we only want to check if the
3545 watchpoint frame is in scope if the current thread is the thread
3546 that was used to create the watchpoint. */
3547 if (!watchpoint_in_thread_scope (b
))
3550 if (b
->exp_valid_block
== NULL
)
3551 within_current_scope
= 1;
3554 struct frame_info
*frame
= get_current_frame ();
3555 struct gdbarch
*frame_arch
= get_frame_arch (frame
);
3556 CORE_ADDR frame_pc
= get_frame_pc (frame
);
3558 /* in_function_epilogue_p() returns a non-zero value if we're still
3559 in the function but the stack frame has already been invalidated.
3560 Since we can't rely on the values of local variables after the
3561 stack has been destroyed, we are treating the watchpoint in that
3562 state as `not changed' without further checking. Don't mark
3563 watchpoints as changed if the current frame is in an epilogue -
3564 even if they are in some other frame, our view of the stack
3565 is likely to be wrong and frame_find_by_id could error out. */
3566 if (gdbarch_in_function_epilogue_p (frame_arch
, frame_pc
))
3569 fr
= frame_find_by_id (b
->watchpoint_frame
);
3570 within_current_scope
= (fr
!= NULL
);
3572 /* If we've gotten confused in the unwinder, we might have
3573 returned a frame that can't describe this variable. */
3574 if (within_current_scope
)
3576 struct symbol
*function
;
3578 function
= get_frame_function (fr
);
3579 if (function
== NULL
3580 || !contained_in (b
->exp_valid_block
,
3581 SYMBOL_BLOCK_VALUE (function
)))
3582 within_current_scope
= 0;
3585 if (within_current_scope
)
3586 /* If we end up stopping, the current frame will get selected
3587 in normal_stop. So this call to select_frame won't affect
3592 if (within_current_scope
)
3594 /* We use value_{,free_to_}mark because it could be a
3595 *long* time before we return to the command level and
3596 call free_all_values. We can't call free_all_values because
3597 we might be in the middle of evaluating a function call. */
3600 struct value
*mark
= value_mark ();
3601 struct value
*new_val
;
3603 fetch_subexp_value (b
->exp
, &pc
, &new_val
, NULL
, NULL
);
3605 /* We use value_equal_contents instead of value_equal because the latter
3606 coerces an array to a pointer, thus comparing just the address of the
3607 array instead of its contents. This is not what we want. */
3608 if ((b
->val
!= NULL
) != (new_val
!= NULL
)
3609 || (b
->val
!= NULL
&& !value_equal_contents (b
->val
, new_val
)))
3611 if (new_val
!= NULL
)
3613 release_value (new_val
);
3614 value_free_to_mark (mark
);
3616 bs
->old_val
= b
->val
;
3619 return WP_VALUE_CHANGED
;
3623 /* Nothing changed. */
3624 value_free_to_mark (mark
);
3625 return WP_VALUE_NOT_CHANGED
;
3630 /* This seems like the only logical thing to do because
3631 if we temporarily ignored the watchpoint, then when
3632 we reenter the block in which it is valid it contains
3633 garbage (in the case of a function, it may have two
3634 garbage values, one before and one after the prologue).
3635 So we can't even detect the first assignment to it and
3636 watch after that (since the garbage may or may not equal
3637 the first value assigned). */
3638 /* We print all the stop information in print_it_typical(), but
3639 in this case, by the time we call print_it_typical() this bp
3640 will be deleted already. So we have no choice but print the
3641 information here. */
3642 if (ui_out_is_mi_like_p (uiout
))
3644 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
3645 ui_out_text (uiout
, "\nWatchpoint ");
3646 ui_out_field_int (uiout
, "wpnum", b
->number
);
3647 ui_out_text (uiout
, " deleted because the program has left the block in\n\
3648 which its expression is valid.\n");
3650 if (b
->related_breakpoint
)
3652 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
3653 b
->related_breakpoint
->related_breakpoint
= NULL
;
3654 b
->related_breakpoint
= NULL
;
3656 b
->disposition
= disp_del_at_next_stop
;
3662 /* Return true if it looks like target has stopped due to hitting
3663 breakpoint location BL. This function does not check if we
3664 should stop, only if BL explains the stop. */
3666 bpstat_check_location (const struct bp_location
*bl
,
3667 struct address_space
*aspace
, CORE_ADDR bp_addr
)
3669 struct breakpoint
*b
= bl
->owner
;
3671 /* BL is from existing struct breakpoint. */
3672 gdb_assert (b
!= NULL
);
3674 /* By definition, the inferior does not report stops at
3676 if (is_tracepoint (b
))
3679 if (!is_watchpoint (b
)
3680 && b
->type
!= bp_hardware_breakpoint
3681 && b
->type
!= bp_catchpoint
) /* a non-watchpoint bp */
3683 if (!breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
3686 if (overlay_debugging
/* unmapped overlay section */
3687 && section_is_overlay (bl
->section
)
3688 && !section_is_mapped (bl
->section
))
3692 /* Continuable hardware watchpoints are treated as non-existent if the
3693 reason we stopped wasn't a hardware watchpoint (we didn't stop on
3694 some data address). Otherwise gdb won't stop on a break instruction
3695 in the code (not from a breakpoint) when a hardware watchpoint has
3696 been defined. Also skip watchpoints which we know did not trigger
3697 (did not match the data address). */
3699 if (is_hardware_watchpoint (b
)
3700 && b
->watchpoint_triggered
== watch_triggered_no
)
3703 if (b
->type
== bp_hardware_breakpoint
)
3705 if (bl
->address
!= bp_addr
)
3707 if (overlay_debugging
/* unmapped overlay section */
3708 && section_is_overlay (bl
->section
)
3709 && !section_is_mapped (bl
->section
))
3713 if (b
->type
== bp_catchpoint
)
3715 gdb_assert (b
->ops
!= NULL
&& b
->ops
->breakpoint_hit
!= NULL
);
3716 if (!b
->ops
->breakpoint_hit (b
))
3723 /* If BS refers to a watchpoint, determine if the watched values
3724 has actually changed, and we should stop. If not, set BS->stop
3727 bpstat_check_watchpoint (bpstat bs
)
3729 const struct bp_location
*bl
;
3730 struct breakpoint
*b
;
3732 /* BS is built for existing struct breakpoint. */
3733 bl
= bs
->breakpoint_at
;
3734 gdb_assert (bl
!= NULL
);
3736 gdb_assert (b
!= NULL
);
3738 if (is_watchpoint (b
))
3740 int must_check_value
= 0;
3742 if (b
->type
== bp_watchpoint
)
3743 /* For a software watchpoint, we must always check the
3745 must_check_value
= 1;
3746 else if (b
->watchpoint_triggered
== watch_triggered_yes
)
3747 /* We have a hardware watchpoint (read, write, or access)
3748 and the target earlier reported an address watched by
3750 must_check_value
= 1;
3751 else if (b
->watchpoint_triggered
== watch_triggered_unknown
3752 && b
->type
== bp_hardware_watchpoint
)
3753 /* We were stopped by a hardware watchpoint, but the target could
3754 not report the data address. We must check the watchpoint's
3755 value. Access and read watchpoints are out of luck; without
3756 a data address, we can't figure it out. */
3757 must_check_value
= 1;
3759 if (must_check_value
)
3761 char *message
= xstrprintf ("Error evaluating expression for watchpoint %d\n",
3763 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
3764 int e
= catch_errors (watchpoint_check
, bs
, message
,
3766 do_cleanups (cleanups
);
3770 /* We've already printed what needs to be printed. */
3771 bs
->print_it
= print_it_done
;
3775 bs
->print_it
= print_it_noop
;
3778 case WP_VALUE_CHANGED
:
3779 if (b
->type
== bp_read_watchpoint
)
3781 /* There are two cases to consider here:
3783 1. we're watching the triggered memory for reads.
3784 In that case, trust the target, and always report
3785 the watchpoint hit to the user. Even though
3786 reads don't cause value changes, the value may
3787 have changed since the last time it was read, and
3788 since we're not trapping writes, we will not see
3789 those, and as such we should ignore our notion of
3792 2. we're watching the triggered memory for both
3793 reads and writes. There are two ways this may
3796 2.1. this is a target that can't break on data
3797 reads only, but can break on accesses (reads or
3798 writes), such as e.g., x86. We detect this case
3799 at the time we try to insert read watchpoints.
3801 2.2. otherwise, the target supports read
3802 watchpoints, but, the user set an access or write
3803 watchpoint watching the same memory as this read
3806 If we're watching memory writes as well as reads,
3807 ignore watchpoint hits when we find that the
3808 value hasn't changed, as reads don't cause
3809 changes. This still gives false positives when
3810 the program writes the same value to memory as
3811 what there was already in memory (we will confuse
3812 it for a read), but it's much better than
3815 int other_write_watchpoint
= 0;
3817 if (bl
->watchpoint_type
== hw_read
)
3819 struct breakpoint
*other_b
;
3821 ALL_BREAKPOINTS (other_b
)
3822 if ((other_b
->type
== bp_hardware_watchpoint
3823 || other_b
->type
== bp_access_watchpoint
)
3824 && (other_b
->watchpoint_triggered
3825 == watch_triggered_yes
))
3827 other_write_watchpoint
= 1;
3832 if (other_write_watchpoint
3833 || bl
->watchpoint_type
== hw_access
)
3835 /* We're watching the same memory for writes,
3836 and the value changed since the last time we
3837 updated it, so this trap must be for a write.
3839 bs
->print_it
= print_it_noop
;
3844 case WP_VALUE_NOT_CHANGED
:
3845 if (b
->type
== bp_hardware_watchpoint
3846 || b
->type
== bp_watchpoint
)
3848 /* Don't stop: write watchpoints shouldn't fire if
3849 the value hasn't changed. */
3850 bs
->print_it
= print_it_noop
;
3858 /* Error from catch_errors. */
3859 printf_filtered (_("Watchpoint %d deleted.\n"), b
->number
);
3860 if (b
->related_breakpoint
)
3861 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
3862 b
->disposition
= disp_del_at_next_stop
;
3863 /* We've already printed what needs to be printed. */
3864 bs
->print_it
= print_it_done
;
3868 else /* must_check_value == 0 */
3870 /* This is a case where some watchpoint(s) triggered, but
3871 not at the address of this watchpoint, or else no
3872 watchpoint triggered after all. So don't print
3873 anything for this watchpoint. */
3874 bs
->print_it
= print_it_noop
;
3881 /* Check conditions (condition proper, frame, thread and ignore count)
3882 of breakpoint referred to by BS. If we should not stop for this
3883 breakpoint, set BS->stop to 0. */
3885 bpstat_check_breakpoint_conditions (bpstat bs
, ptid_t ptid
)
3887 int thread_id
= pid_to_thread_id (ptid
);
3888 const struct bp_location
*bl
;
3889 struct breakpoint
*b
;
3891 /* BS is built for existing struct breakpoint. */
3892 bl
= bs
->breakpoint_at
;
3893 gdb_assert (bl
!= NULL
);
3895 gdb_assert (b
!= NULL
);
3897 if (frame_id_p (b
->frame_id
)
3898 && !frame_id_eq (b
->frame_id
, get_stack_frame_id (get_current_frame ())))
3902 int value_is_zero
= 0;
3903 struct expression
*cond
;
3905 /* If this is a scope breakpoint, mark the associated
3906 watchpoint as triggered so that we will handle the
3907 out-of-scope event. We'll get to the watchpoint next
3909 if (b
->type
== bp_watchpoint_scope
)
3910 b
->related_breakpoint
->watchpoint_triggered
= watch_triggered_yes
;
3912 if (is_watchpoint (b
))
3917 if (cond
&& bl
->owner
->disposition
!= disp_del_at_next_stop
)
3919 int within_current_scope
= 1;
3921 /* We use value_mark and value_free_to_mark because it could
3922 be a long time before we return to the command level and
3923 call free_all_values. We can't call free_all_values
3924 because we might be in the middle of evaluating a
3926 struct value
*mark
= value_mark ();
3928 /* Need to select the frame, with all that implies so that
3929 the conditions will have the right context. Because we
3930 use the frame, we will not see an inlined function's
3931 variables when we arrive at a breakpoint at the start
3932 of the inlined function; the current frame will be the
3934 if (!is_watchpoint (b
) || b
->cond_exp_valid_block
== NULL
)
3935 select_frame (get_current_frame ());
3938 struct frame_info
*frame
;
3940 /* For local watchpoint expressions, which particular
3941 instance of a local is being watched matters, so we
3942 keep track of the frame to evaluate the expression
3943 in. To evaluate the condition however, it doesn't
3944 really matter which instantiation of the function
3945 where the condition makes sense triggers the
3946 watchpoint. This allows an expression like "watch
3947 global if q > 10" set in `func', catch writes to
3948 global on all threads that call `func', or catch
3949 writes on all recursive calls of `func' by a single
3950 thread. We simply always evaluate the condition in
3951 the innermost frame that's executing where it makes
3952 sense to evaluate the condition. It seems
3954 frame
= block_innermost_frame (b
->cond_exp_valid_block
);
3956 select_frame (frame
);
3958 within_current_scope
= 0;
3960 if (within_current_scope
)
3962 = catch_errors (breakpoint_cond_eval
, cond
,
3963 "Error in testing breakpoint condition:\n",
3967 warning (_("Watchpoint condition cannot be tested "
3968 "in the current scope"));
3969 /* If we failed to set the right context for this
3970 watchpoint, unconditionally report it. */
3973 /* FIXME-someday, should give breakpoint # */
3974 value_free_to_mark (mark
);
3977 if (cond
&& value_is_zero
)
3981 else if (b
->thread
!= -1 && b
->thread
!= thread_id
)
3985 else if (b
->ignore_count
> 0)
3988 annotate_ignore_count_change ();
3990 /* Increase the hit count even though we don't
3998 /* Get a bpstat associated with having just stopped at address
3999 BP_ADDR in thread PTID.
4001 Determine whether we stopped at a breakpoint, etc, or whether we
4002 don't understand this stop. Result is a chain of bpstat's such that:
4004 if we don't understand the stop, the result is a null pointer.
4006 if we understand why we stopped, the result is not null.
4008 Each element of the chain refers to a particular breakpoint or
4009 watchpoint at which we have stopped. (We may have stopped for
4010 several reasons concurrently.)
4012 Each element of the chain has valid next, breakpoint_at,
4013 commands, FIXME??? fields. */
4016 bpstat_stop_status (struct address_space
*aspace
,
4017 CORE_ADDR bp_addr
, ptid_t ptid
)
4019 struct breakpoint
*b
= NULL
;
4020 struct bp_location
*bl
;
4021 struct bp_location
*loc
;
4022 /* Root of the chain of bpstat's */
4023 struct bpstats root_bs
[1];
4024 /* Pointer to the last thing in the chain currently. */
4025 bpstat bs
= root_bs
;
4027 int need_remove_insert
;
4029 /* ALL_BP_LOCATIONS iteration would break across
4030 update_global_location_list possibly executed by
4031 bpstat_check_breakpoint_conditions's inferior call. */
4035 if (!breakpoint_enabled (b
) && b
->enable_state
!= bp_permanent
)
4038 for (bl
= b
->loc
; bl
!= NULL
; bl
= bl
->next
)
4040 /* For hardware watchpoints, we look only at the first location.
4041 The watchpoint_check function will work on the entire expression,
4042 not the individual locations. For read watchpoints, the
4043 watchpoints_triggered function has checked all locations
4045 if (b
->type
== bp_hardware_watchpoint
&& bl
!= b
->loc
)
4048 if (bl
->shlib_disabled
)
4051 if (!bpstat_check_location (bl
, aspace
, bp_addr
))
4054 /* Come here if it's a watchpoint, or if the break address matches */
4056 bs
= bpstat_alloc (bl
, bs
); /* Alloc a bpstat to explain stop */
4058 /* Assume we stop. Should we find watchpoint that is not actually
4059 triggered, or if condition of breakpoint is false, we'll reset
4064 bpstat_check_watchpoint (bs
);
4068 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
4069 || b
->type
== bp_longjmp_master
4070 || b
->type
== bp_std_terminate_master
)
4071 /* We do not stop for these. */
4074 bpstat_check_breakpoint_conditions (bs
, ptid
);
4080 /* We will stop here */
4081 if (b
->disposition
== disp_disable
)
4083 if (b
->enable_state
!= bp_permanent
)
4084 b
->enable_state
= bp_disabled
;
4085 update_global_location_list (0);
4089 bs
->commands
= b
->commands
;
4090 incref_counted_command_line (bs
->commands
);
4091 bs
->commands_left
= bs
->commands
? bs
->commands
->commands
: NULL
;
4092 if (bs
->commands_left
4093 && (strcmp ("silent", bs
->commands_left
->line
) == 0
4096 bs
->commands_left
->line
) == 0)))
4098 bs
->commands_left
= bs
->commands_left
->next
;
4103 /* Print nothing for this entry if we dont stop or dont print. */
4104 if (bs
->stop
== 0 || bs
->print
== 0)
4105 bs
->print_it
= print_it_noop
;
4109 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
4111 if (breakpoint_address_match (loc
->pspace
->aspace
, loc
->address
,
4114 bs
= bpstat_alloc (loc
, bs
);
4115 /* For hits of moribund locations, we should just proceed. */
4118 bs
->print_it
= print_it_noop
;
4122 bs
->next
= NULL
; /* Terminate the chain */
4124 /* If we aren't stopping, the value of some hardware watchpoint may
4125 not have changed, but the intermediate memory locations we are
4126 watching may have. Don't bother if we're stopping; this will get
4128 need_remove_insert
= 0;
4129 if (! bpstat_causes_stop (root_bs
->next
))
4130 for (bs
= root_bs
->next
; bs
!= NULL
; bs
= bs
->next
)
4132 && bs
->breakpoint_at
->owner
4133 && is_hardware_watchpoint (bs
->breakpoint_at
->owner
))
4135 update_watchpoint (bs
->breakpoint_at
->owner
, 0 /* don't reparse. */);
4136 /* Updating watchpoints invalidates bs->breakpoint_at.
4137 Prevent further code from trying to use it. */
4138 bs
->breakpoint_at
= NULL
;
4139 need_remove_insert
= 1;
4142 if (need_remove_insert
)
4143 update_global_location_list (1);
4145 return root_bs
->next
;
4149 handle_jit_event (void)
4151 struct frame_info
*frame
;
4152 struct gdbarch
*gdbarch
;
4154 /* Switch terminal for any messages produced by
4155 breakpoint_re_set. */
4156 target_terminal_ours_for_output ();
4158 frame
= get_current_frame ();
4159 gdbarch
= get_frame_arch (frame
);
4161 jit_event_handler (gdbarch
);
4163 target_terminal_inferior ();
4166 /* Prepare WHAT final decision for infrun. */
4168 /* Decide what infrun needs to do with this bpstat. */
4171 bpstat_what (bpstat bs
)
4173 struct bpstat_what retval
;
4174 /* We need to defer calling `solib_add', as adding new symbols
4175 resets breakpoints, which in turn deletes breakpoint locations,
4176 and hence may clear unprocessed entries in the BS chain. */
4177 int shlib_event
= 0;
4180 retval
.main_action
= BPSTAT_WHAT_KEEP_CHECKING
;
4181 retval
.call_dummy
= STOP_NONE
;
4183 for (; bs
!= NULL
; bs
= bs
->next
)
4185 /* Extract this BS's action. After processing each BS, we check
4186 if its action overrides all we've seem so far. */
4187 enum bpstat_what_main_action this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
4190 if (bs
->breakpoint_at
== NULL
)
4192 /* I suspect this can happen if it was a momentary
4193 breakpoint which has since been deleted. */
4196 else if (bs
->breakpoint_at
->owner
== NULL
)
4199 bptype
= bs
->breakpoint_at
->owner
->type
;
4206 case bp_hardware_breakpoint
:
4212 this_action
= BPSTAT_WHAT_STOP_NOISY
;
4214 this_action
= BPSTAT_WHAT_STOP_SILENT
;
4217 this_action
= BPSTAT_WHAT_SINGLE
;
4220 case bp_hardware_watchpoint
:
4221 case bp_read_watchpoint
:
4222 case bp_access_watchpoint
:
4226 this_action
= BPSTAT_WHAT_STOP_NOISY
;
4228 this_action
= BPSTAT_WHAT_STOP_SILENT
;
4232 /* There was a watchpoint, but we're not stopping.
4233 This requires no further action. */
4237 this_action
= BPSTAT_WHAT_SET_LONGJMP_RESUME
;
4239 case bp_longjmp_resume
:
4240 this_action
= BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
;
4242 case bp_step_resume
:
4244 this_action
= BPSTAT_WHAT_STEP_RESUME
;
4247 /* It is for the wrong frame. */
4248 this_action
= BPSTAT_WHAT_SINGLE
;
4251 case bp_watchpoint_scope
:
4252 case bp_thread_event
:
4253 case bp_overlay_event
:
4254 case bp_longjmp_master
:
4255 case bp_std_terminate_master
:
4256 this_action
= BPSTAT_WHAT_SINGLE
;
4262 this_action
= BPSTAT_WHAT_STOP_NOISY
;
4264 this_action
= BPSTAT_WHAT_STOP_SILENT
;
4268 /* There was a catchpoint, but we're not stopping.
4269 This requires no further action. */
4272 case bp_shlib_event
:
4275 /* If requested, stop when the dynamic linker notifies GDB
4276 of events. This allows the user to get control and place
4277 breakpoints in initializer routines for dynamically
4278 loaded objects (among other things). */
4279 if (stop_on_solib_events
)
4280 this_action
= BPSTAT_WHAT_STOP_NOISY
;
4282 this_action
= BPSTAT_WHAT_SINGLE
;
4286 this_action
= BPSTAT_WHAT_SINGLE
;
4289 /* Make sure the action is stop (silent or noisy),
4290 so infrun.c pops the dummy frame. */
4291 retval
.call_dummy
= STOP_STACK_DUMMY
;
4292 this_action
= BPSTAT_WHAT_STOP_SILENT
;
4294 case bp_std_terminate
:
4295 /* Make sure the action is stop (silent or noisy),
4296 so infrun.c pops the dummy frame. */
4297 retval
.call_dummy
= STOP_STD_TERMINATE
;
4298 this_action
= BPSTAT_WHAT_STOP_SILENT
;
4301 case bp_fast_tracepoint
:
4302 case bp_static_tracepoint
:
4303 /* Tracepoint hits should not be reported back to GDB, and
4304 if one got through somehow, it should have been filtered
4306 internal_error (__FILE__
, __LINE__
,
4307 _("bpstat_what: tracepoint encountered"));
4309 internal_error (__FILE__
, __LINE__
,
4310 _("bpstat_what: unhandled bptype %d"), (int) bptype
);
4313 retval
.main_action
= max (retval
.main_action
, this_action
);
4319 fprintf_unfiltered (gdb_stdlog
, "bpstat_what: bp_shlib_event\n");
4321 /* Check for any newly added shared libraries if we're supposed
4322 to be adding them automatically. */
4324 /* Switch terminal for any messages produced by
4325 breakpoint_re_set. */
4326 target_terminal_ours_for_output ();
4329 SOLIB_ADD (NULL
, 0, ¤t_target
, auto_solib_add
);
4331 solib_add (NULL
, 0, ¤t_target
, auto_solib_add
);
4334 target_terminal_inferior ();
4340 fprintf_unfiltered (gdb_stdlog
, "bpstat_what: bp_jit_event\n");
4342 handle_jit_event ();
4348 /* Nonzero if we should step constantly (e.g. watchpoints on machines
4349 without hardware support). This isn't related to a specific bpstat,
4350 just to things like whether watchpoints are set. */
4353 bpstat_should_step (void)
4355 struct breakpoint
*b
;
4358 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
&& b
->loc
!= NULL
)
4364 bpstat_causes_stop (bpstat bs
)
4366 for (; bs
!= NULL
; bs
= bs
->next
)
4375 /* Print the LOC location out of the list of B->LOC locations. */
4377 static void print_breakpoint_location (struct breakpoint
*b
,
4378 struct bp_location
*loc
,
4380 struct ui_stream
*stb
)
4382 struct cleanup
*old_chain
= save_current_program_space ();
4384 if (loc
!= NULL
&& loc
->shlib_disabled
)
4388 set_current_program_space (loc
->pspace
);
4390 if (b
->source_file
&& loc
)
4393 = find_pc_sect_function (loc
->address
, loc
->section
);
4396 ui_out_text (uiout
, "in ");
4397 ui_out_field_string (uiout
, "func",
4398 SYMBOL_PRINT_NAME (sym
));
4399 ui_out_wrap_hint (uiout
, wrap_indent
);
4400 ui_out_text (uiout
, " at ");
4402 ui_out_field_string (uiout
, "file", b
->source_file
);
4403 ui_out_text (uiout
, ":");
4405 if (ui_out_is_mi_like_p (uiout
))
4407 struct symtab_and_line sal
= find_pc_line (loc
->address
, 0);
4408 char *fullname
= symtab_to_fullname (sal
.symtab
);
4411 ui_out_field_string (uiout
, "fullname", fullname
);
4414 ui_out_field_int (uiout
, "line", b
->line_number
);
4418 print_address_symbolic (loc
->gdbarch
, loc
->address
, stb
->stream
,
4420 ui_out_field_stream (uiout
, "at", stb
);
4423 ui_out_field_string (uiout
, "pending", b
->addr_string
);
4425 do_cleanups (old_chain
);
4429 bptype_string (enum bptype type
)
4431 struct ep_type_description
4436 static struct ep_type_description bptypes
[] =
4438 {bp_none
, "?deleted?"},
4439 {bp_breakpoint
, "breakpoint"},
4440 {bp_hardware_breakpoint
, "hw breakpoint"},
4441 {bp_until
, "until"},
4442 {bp_finish
, "finish"},
4443 {bp_watchpoint
, "watchpoint"},
4444 {bp_hardware_watchpoint
, "hw watchpoint"},
4445 {bp_read_watchpoint
, "read watchpoint"},
4446 {bp_access_watchpoint
, "acc watchpoint"},
4447 {bp_longjmp
, "longjmp"},
4448 {bp_longjmp_resume
, "longjmp resume"},
4449 {bp_step_resume
, "step resume"},
4450 {bp_watchpoint_scope
, "watchpoint scope"},
4451 {bp_call_dummy
, "call dummy"},
4452 {bp_std_terminate
, "std::terminate"},
4453 {bp_shlib_event
, "shlib events"},
4454 {bp_thread_event
, "thread events"},
4455 {bp_overlay_event
, "overlay events"},
4456 {bp_longjmp_master
, "longjmp master"},
4457 {bp_std_terminate_master
, "std::terminate master"},
4458 {bp_catchpoint
, "catchpoint"},
4459 {bp_tracepoint
, "tracepoint"},
4460 {bp_fast_tracepoint
, "fast tracepoint"},
4461 {bp_static_tracepoint
, "static tracepoint"},
4462 {bp_jit_event
, "jit events"},
4465 if (((int) type
>= (sizeof (bptypes
) / sizeof (bptypes
[0])))
4466 || ((int) type
!= bptypes
[(int) type
].type
))
4467 internal_error (__FILE__
, __LINE__
,
4468 _("bptypes table does not describe type #%d."),
4471 return bptypes
[(int) type
].description
;
4474 /* Print B to gdb_stdout. */
4477 print_one_breakpoint_location (struct breakpoint
*b
,
4478 struct bp_location
*loc
,
4480 struct bp_location
**last_loc
,
4481 int print_address_bits
,
4484 struct command_line
*l
;
4485 static char bpenables
[] = "nynny";
4486 char wrap_indent
[80];
4487 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
4488 struct cleanup
*old_chain
= make_cleanup_ui_out_stream_delete (stb
);
4489 struct cleanup
*bkpt_chain
;
4491 int header_of_multiple
= 0;
4492 int part_of_multiple
= (loc
!= NULL
);
4493 struct value_print_options opts
;
4495 get_user_print_options (&opts
);
4497 gdb_assert (!loc
|| loc_number
!= 0);
4498 /* See comment in print_one_breakpoint concerning
4499 treatment of breakpoints with single disabled
4503 && (b
->loc
->next
!= NULL
|| !b
->loc
->enabled
)))
4504 header_of_multiple
= 1;
4509 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "bkpt");
4513 if (part_of_multiple
)
4516 formatted
= xstrprintf ("%d.%d", b
->number
, loc_number
);
4517 ui_out_field_string (uiout
, "number", formatted
);
4522 ui_out_field_int (uiout
, "number", b
->number
);
4527 if (part_of_multiple
)
4528 ui_out_field_skip (uiout
, "type");
4530 ui_out_field_string (uiout
, "type", bptype_string (b
->type
));
4534 if (part_of_multiple
)
4535 ui_out_field_skip (uiout
, "disp");
4537 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
4542 if (part_of_multiple
)
4543 ui_out_field_string (uiout
, "enabled", loc
->enabled
? "y" : "n");
4545 ui_out_field_fmt (uiout
, "enabled", "%c",
4546 bpenables
[(int) b
->enable_state
]);
4547 ui_out_spaces (uiout
, 2);
4551 strcpy (wrap_indent
, " ");
4552 if (opts
.addressprint
)
4554 if (print_address_bits
<= 32)
4555 strcat (wrap_indent
, " ");
4557 strcat (wrap_indent
, " ");
4560 if (b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
4562 /* Although the print_one can possibly print
4563 all locations, calling it here is not likely
4564 to get any nice result. So, make sure there's
4565 just one location. */
4566 gdb_assert (b
->loc
== NULL
|| b
->loc
->next
== NULL
);
4567 b
->ops
->print_one (b
, last_loc
);
4573 internal_error (__FILE__
, __LINE__
,
4574 _("print_one_breakpoint: bp_none encountered\n"));
4578 case bp_hardware_watchpoint
:
4579 case bp_read_watchpoint
:
4580 case bp_access_watchpoint
:
4581 /* Field 4, the address, is omitted (which makes the columns
4582 not line up too nicely with the headers, but the effect
4583 is relatively readable). */
4584 if (opts
.addressprint
)
4585 ui_out_field_skip (uiout
, "addr");
4587 ui_out_field_string (uiout
, "what", b
->exp_string
);
4591 case bp_hardware_breakpoint
:
4595 case bp_longjmp_resume
:
4596 case bp_step_resume
:
4597 case bp_watchpoint_scope
:
4599 case bp_std_terminate
:
4600 case bp_shlib_event
:
4601 case bp_thread_event
:
4602 case bp_overlay_event
:
4603 case bp_longjmp_master
:
4604 case bp_std_terminate_master
:
4606 case bp_fast_tracepoint
:
4607 case bp_static_tracepoint
:
4609 if (opts
.addressprint
)
4612 if (header_of_multiple
)
4613 ui_out_field_string (uiout
, "addr", "<MULTIPLE>");
4614 else if (b
->loc
== NULL
|| loc
->shlib_disabled
)
4615 ui_out_field_string (uiout
, "addr", "<PENDING>");
4617 ui_out_field_core_addr (uiout
, "addr",
4618 loc
->gdbarch
, loc
->address
);
4621 if (!header_of_multiple
)
4622 print_breakpoint_location (b
, loc
, wrap_indent
, stb
);
4629 /* For backward compatibility, don't display inferiors unless there
4632 && !header_of_multiple
4634 || (!gdbarch_has_global_breakpoints (target_gdbarch
)
4635 && (number_of_program_spaces () > 1
4636 || number_of_inferiors () > 1)
4637 /* LOC is for existing B, it cannot be in moribund_locations and
4638 thus having NULL OWNER. */
4639 && loc
->owner
->type
!= bp_catchpoint
)))
4641 struct inferior
*inf
;
4644 for (inf
= inferior_list
; inf
!= NULL
; inf
= inf
->next
)
4646 if (inf
->pspace
== loc
->pspace
)
4651 ui_out_text (uiout
, " inf ");
4654 ui_out_text (uiout
, ", ");
4655 ui_out_text (uiout
, plongest (inf
->num
));
4660 if (!part_of_multiple
)
4662 if (b
->thread
!= -1)
4664 /* FIXME: This seems to be redundant and lost here; see the
4665 "stop only in" line a little further down. */
4666 ui_out_text (uiout
, " thread ");
4667 ui_out_field_int (uiout
, "thread", b
->thread
);
4669 else if (b
->task
!= 0)
4671 ui_out_text (uiout
, " task ");
4672 ui_out_field_int (uiout
, "task", b
->task
);
4676 ui_out_text (uiout
, "\n");
4678 if (!part_of_multiple
&& b
->static_trace_marker_id
)
4680 gdb_assert (b
->type
== bp_static_tracepoint
);
4682 ui_out_text (uiout
, "\tmarker id is ");
4683 ui_out_field_string (uiout
, "static-tracepoint-marker-string-id",
4684 b
->static_trace_marker_id
);
4685 ui_out_text (uiout
, "\n");
4688 if (part_of_multiple
&& frame_id_p (b
->frame_id
))
4691 ui_out_text (uiout
, "\tstop only in stack frame at ");
4692 /* FIXME: cagney/2002-12-01: Shouldn't be poeking around inside
4694 ui_out_field_core_addr (uiout
, "frame",
4695 b
->gdbarch
, b
->frame_id
.stack_addr
);
4696 ui_out_text (uiout
, "\n");
4699 if (!part_of_multiple
&& b
->cond_string
&& !ada_exception_catchpoint_p (b
))
4701 /* We do not print the condition for Ada exception catchpoints
4702 because the condition is an internal implementation detail
4703 that we do not want to expose to the user. */
4705 if (is_tracepoint (b
))
4706 ui_out_text (uiout
, "\ttrace only if ");
4708 ui_out_text (uiout
, "\tstop only if ");
4709 ui_out_field_string (uiout
, "cond", b
->cond_string
);
4710 ui_out_text (uiout
, "\n");
4713 if (!part_of_multiple
&& b
->thread
!= -1)
4715 /* FIXME should make an annotation for this */
4716 ui_out_text (uiout
, "\tstop only in thread ");
4717 ui_out_field_int (uiout
, "thread", b
->thread
);
4718 ui_out_text (uiout
, "\n");
4721 if (!part_of_multiple
&& b
->hit_count
)
4723 /* FIXME should make an annotation for this */
4724 if (ep_is_catchpoint (b
))
4725 ui_out_text (uiout
, "\tcatchpoint");
4727 ui_out_text (uiout
, "\tbreakpoint");
4728 ui_out_text (uiout
, " already hit ");
4729 ui_out_field_int (uiout
, "times", b
->hit_count
);
4730 if (b
->hit_count
== 1)
4731 ui_out_text (uiout
, " time\n");
4733 ui_out_text (uiout
, " times\n");
4736 /* Output the count also if it is zero, but only if this is
4737 mi. FIXME: Should have a better test for this. */
4738 if (ui_out_is_mi_like_p (uiout
))
4739 if (!part_of_multiple
&& b
->hit_count
== 0)
4740 ui_out_field_int (uiout
, "times", b
->hit_count
);
4742 if (!part_of_multiple
&& b
->ignore_count
)
4745 ui_out_text (uiout
, "\tignore next ");
4746 ui_out_field_int (uiout
, "ignore", b
->ignore_count
);
4747 ui_out_text (uiout
, " hits\n");
4750 l
= b
->commands
? b
->commands
->commands
: NULL
;
4751 if (!part_of_multiple
&& l
)
4753 struct cleanup
*script_chain
;
4756 script_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "script");
4757 print_command_lines (uiout
, l
, 4);
4758 do_cleanups (script_chain
);
4761 if (!part_of_multiple
&& b
->pass_count
)
4763 annotate_field (10);
4764 ui_out_text (uiout
, "\tpass count ");
4765 ui_out_field_int (uiout
, "pass", b
->pass_count
);
4766 ui_out_text (uiout
, " \n");
4769 if (ui_out_is_mi_like_p (uiout
) && !part_of_multiple
)
4772 ui_out_field_string (uiout
, "original-location", b
->addr_string
);
4773 else if (b
->exp_string
)
4774 ui_out_field_string (uiout
, "original-location", b
->exp_string
);
4777 do_cleanups (bkpt_chain
);
4778 do_cleanups (old_chain
);
4782 print_one_breakpoint (struct breakpoint
*b
,
4783 struct bp_location
**last_loc
, int print_address_bits
,
4786 print_one_breakpoint_location (b
, NULL
, 0, last_loc
,
4787 print_address_bits
, allflag
);
4789 /* If this breakpoint has custom print function,
4790 it's already printed. Otherwise, print individual
4791 locations, if any. */
4792 if (b
->ops
== NULL
|| b
->ops
->print_one
== NULL
)
4794 /* If breakpoint has a single location that is
4795 disabled, we print it as if it had
4796 several locations, since otherwise it's hard to
4797 represent "breakpoint enabled, location disabled"
4799 Note that while hardware watchpoints have
4800 several locations internally, that's no a property
4803 && !is_hardware_watchpoint (b
)
4804 && (b
->loc
->next
|| !b
->loc
->enabled
)
4805 && !ui_out_is_mi_like_p (uiout
))
4807 struct bp_location
*loc
;
4809 for (loc
= b
->loc
; loc
; loc
= loc
->next
, ++n
)
4810 print_one_breakpoint_location (b
, loc
, n
, last_loc
,
4811 print_address_bits
, allflag
);
4817 breakpoint_address_bits (struct breakpoint
*b
)
4819 int print_address_bits
= 0;
4820 struct bp_location
*loc
;
4822 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
4826 /* Software watchpoints that aren't watching memory don't have
4827 an address to print. */
4828 if (b
->type
== bp_watchpoint
&& loc
->watchpoint_type
== -1)
4831 addr_bit
= gdbarch_addr_bit (loc
->gdbarch
);
4832 if (addr_bit
> print_address_bits
)
4833 print_address_bits
= addr_bit
;
4836 return print_address_bits
;
4839 struct captured_breakpoint_query_args
4845 do_captured_breakpoint_query (struct ui_out
*uiout
, void *data
)
4847 struct captured_breakpoint_query_args
*args
= data
;
4848 struct breakpoint
*b
;
4849 struct bp_location
*dummy_loc
= NULL
;
4853 if (args
->bnum
== b
->number
)
4855 int print_address_bits
= breakpoint_address_bits (b
);
4857 print_one_breakpoint (b
, &dummy_loc
, print_address_bits
, 0);
4865 gdb_breakpoint_query (struct ui_out
*uiout
, int bnum
, char **error_message
)
4867 struct captured_breakpoint_query_args args
;
4870 /* For the moment we don't trust print_one_breakpoint() to not throw
4872 if (catch_exceptions_with_msg (uiout
, do_captured_breakpoint_query
, &args
,
4873 error_message
, RETURN_MASK_ALL
) < 0)
4879 /* Return non-zero if B is user settable (breakpoints, watchpoints,
4880 catchpoints, et.al.). */
4883 user_settable_breakpoint (const struct breakpoint
*b
)
4885 return (b
->type
== bp_breakpoint
4886 || b
->type
== bp_catchpoint
4887 || b
->type
== bp_hardware_breakpoint
4888 || is_tracepoint (b
)
4889 || is_watchpoint (b
));
4892 /* Print information on user settable breakpoint (watchpoint, etc)
4893 number BNUM. If BNUM is -1 print all user-settable breakpoints.
4894 If ALLFLAG is non-zero, include non-user-settable breakpoints. If
4895 FILTER is non-NULL, call it on each breakpoint and only include the
4896 ones for which it returns non-zero. Return the total number of
4897 breakpoints listed. */
4900 breakpoint_1 (int bnum
, int allflag
, int (*filter
) (const struct breakpoint
*))
4902 struct breakpoint
*b
;
4903 struct bp_location
*last_loc
= NULL
;
4904 int nr_printable_breakpoints
;
4905 struct cleanup
*bkpttbl_chain
;
4906 struct value_print_options opts
;
4907 int print_address_bits
= 0;
4908 int print_type_col_width
= 14;
4910 get_user_print_options (&opts
);
4912 /* Compute the number of rows in the table, as well as the
4913 size required for address fields. */
4914 nr_printable_breakpoints
= 0;
4917 || bnum
== b
->number
)
4919 /* If we have a filter, only list the breakpoints it accepts. */
4920 if (filter
&& !filter (b
))
4923 if (allflag
|| user_settable_breakpoint (b
))
4925 int addr_bit
, type_len
;
4927 addr_bit
= breakpoint_address_bits (b
);
4928 if (addr_bit
> print_address_bits
)
4929 print_address_bits
= addr_bit
;
4931 type_len
= strlen (bptype_string (b
->type
));
4932 if (type_len
> print_type_col_width
)
4933 print_type_col_width
= type_len
;
4935 nr_printable_breakpoints
++;
4939 if (opts
.addressprint
)
4941 = make_cleanup_ui_out_table_begin_end (uiout
, 6, nr_printable_breakpoints
,
4945 = make_cleanup_ui_out_table_begin_end (uiout
, 5, nr_printable_breakpoints
,
4948 if (nr_printable_breakpoints
> 0)
4949 annotate_breakpoints_headers ();
4950 if (nr_printable_breakpoints
> 0)
4952 ui_out_table_header (uiout
, 7, ui_left
, "number", "Num"); /* 1 */
4953 if (nr_printable_breakpoints
> 0)
4955 ui_out_table_header (uiout
, print_type_col_width
, ui_left
,
4956 "type", "Type"); /* 2 */
4957 if (nr_printable_breakpoints
> 0)
4959 ui_out_table_header (uiout
, 4, ui_left
, "disp", "Disp"); /* 3 */
4960 if (nr_printable_breakpoints
> 0)
4962 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb"); /* 4 */
4963 if (opts
.addressprint
)
4965 if (nr_printable_breakpoints
> 0)
4967 if (print_address_bits
<= 32)
4968 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");/* 5 */
4970 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");/* 5 */
4972 if (nr_printable_breakpoints
> 0)
4974 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What"); /* 6 */
4975 ui_out_table_body (uiout
);
4976 if (nr_printable_breakpoints
> 0)
4977 annotate_breakpoints_table ();
4983 || bnum
== b
->number
)
4985 /* If we have a filter, only list the breakpoints it accepts. */
4986 if (filter
&& !filter (b
))
4989 /* We only print out user settable breakpoints unless the
4991 if (allflag
|| user_settable_breakpoint (b
))
4992 print_one_breakpoint (b
, &last_loc
, print_address_bits
, allflag
);
4996 do_cleanups (bkpttbl_chain
);
4998 if (nr_printable_breakpoints
== 0)
5000 /* If there's a filter, let the caller decide how to report empty list. */
5004 ui_out_message (uiout
, 0, "No breakpoints or watchpoints.\n");
5006 ui_out_message (uiout
, 0, "No breakpoint or watchpoint number %d.\n",
5012 if (last_loc
&& !server_command
)
5013 set_next_address (last_loc
->gdbarch
, last_loc
->address
);
5016 /* FIXME? Should this be moved up so that it is only called when
5017 there have been breakpoints? */
5018 annotate_breakpoints_table_end ();
5020 return nr_printable_breakpoints
;
5023 /* Display the value of default-collect in a way that is generally
5024 compatible with the breakpoint list. */
5027 default_collect_info (void)
5029 /* If it has no value (which is frequently the case), say nothing; a
5030 message like "No default-collect." gets in user's face when it's
5032 if (!*default_collect
)
5035 /* The following phrase lines up nicely with per-tracepoint collect
5037 ui_out_text (uiout
, "default collect ");
5038 ui_out_field_string (uiout
, "default-collect", default_collect
);
5039 ui_out_text (uiout
, " \n");
5043 breakpoints_info (char *bnum_exp
, int from_tty
)
5048 bnum
= parse_and_eval_long (bnum_exp
);
5050 breakpoint_1 (bnum
, 0, NULL
);
5052 default_collect_info ();
5056 watchpoints_info (char *wpnum_exp
, int from_tty
)
5058 int wpnum
= -1, num_printed
;
5061 wpnum
= parse_and_eval_long (wpnum_exp
);
5063 num_printed
= breakpoint_1 (wpnum
, 0, is_watchpoint
);
5065 if (num_printed
== 0)
5068 ui_out_message (uiout
, 0, "No watchpoints.\n");
5070 ui_out_message (uiout
, 0, "No watchpoint number %d.\n", wpnum
);
5075 maintenance_info_breakpoints (char *bnum_exp
, int from_tty
)
5080 bnum
= parse_and_eval_long (bnum_exp
);
5082 breakpoint_1 (bnum
, 1, NULL
);
5084 default_collect_info ();
5088 breakpoint_has_pc (struct breakpoint
*b
,
5089 struct program_space
*pspace
,
5090 CORE_ADDR pc
, struct obj_section
*section
)
5092 struct bp_location
*bl
= b
->loc
;
5094 for (; bl
; bl
= bl
->next
)
5096 if (bl
->pspace
== pspace
5097 && bl
->address
== pc
5098 && (!overlay_debugging
|| bl
->section
== section
))
5104 /* Print a message describing any breakpoints set at PC. This
5105 concerns with logical breakpoints, so we match program spaces, not
5109 describe_other_breakpoints (struct gdbarch
*gdbarch
,
5110 struct program_space
*pspace
, CORE_ADDR pc
,
5111 struct obj_section
*section
, int thread
)
5114 struct breakpoint
*b
;
5117 others
+= breakpoint_has_pc (b
, pspace
, pc
, section
);
5121 printf_filtered (_("Note: breakpoint "));
5122 else /* if (others == ???) */
5123 printf_filtered (_("Note: breakpoints "));
5125 if (breakpoint_has_pc (b
, pspace
, pc
, section
))
5128 printf_filtered ("%d", b
->number
);
5129 if (b
->thread
== -1 && thread
!= -1)
5130 printf_filtered (" (all threads)");
5131 else if (b
->thread
!= -1)
5132 printf_filtered (" (thread %d)", b
->thread
);
5133 printf_filtered ("%s%s ",
5134 ((b
->enable_state
== bp_disabled
5135 || b
->enable_state
== bp_call_disabled
5136 || b
->enable_state
== bp_startup_disabled
)
5138 : b
->enable_state
== bp_permanent
5142 : ((others
== 1) ? " and" : ""));
5144 printf_filtered (_("also set at pc "));
5145 fputs_filtered (paddress (gdbarch
, pc
), gdb_stdout
);
5146 printf_filtered (".\n");
5150 /* Set the default place to put a breakpoint
5151 for the `break' command with no arguments. */
5154 set_default_breakpoint (int valid
, struct program_space
*pspace
,
5155 CORE_ADDR addr
, struct symtab
*symtab
,
5158 default_breakpoint_valid
= valid
;
5159 default_breakpoint_pspace
= pspace
;
5160 default_breakpoint_address
= addr
;
5161 default_breakpoint_symtab
= symtab
;
5162 default_breakpoint_line
= line
;
5165 /* Return true iff it is meaningful to use the address member of
5166 BPT. For some breakpoint types, the address member is irrelevant
5167 and it makes no sense to attempt to compare it to other addresses
5168 (or use it for any other purpose either).
5170 More specifically, each of the following breakpoint types will always
5171 have a zero valued address and we don't want to mark breakpoints of any of
5172 these types to be a duplicate of an actual breakpoint at address zero:
5180 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
5182 enum bptype type
= bpt
->type
;
5184 return (type
!= bp_watchpoint
&& type
!= bp_catchpoint
);
5187 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
5188 true if LOC1 and LOC2 represent the same watchpoint location. */
5191 watchpoint_locations_match (struct bp_location
*loc1
, struct bp_location
*loc2
)
5193 /* Both of them must not be in moribund_locations. */
5194 gdb_assert (loc1
->owner
!= NULL
);
5195 gdb_assert (loc2
->owner
!= NULL
);
5197 /* If the target can evaluate the condition expression in hardware, then we
5198 we need to insert both watchpoints even if they are at the same place.
5199 Otherwise the watchpoint will only trigger when the condition of whichever
5200 watchpoint was inserted evaluates to true, not giving a chance for GDB to
5201 check the condition of the other watchpoint. */
5202 if ((loc1
->owner
->cond_exp
5203 && target_can_accel_watchpoint_condition (loc1
->address
, loc1
->length
,
5204 loc1
->watchpoint_type
,
5205 loc1
->owner
->cond_exp
))
5206 || (loc2
->owner
->cond_exp
5207 && target_can_accel_watchpoint_condition (loc2
->address
, loc2
->length
,
5208 loc2
->watchpoint_type
,
5209 loc2
->owner
->cond_exp
)))
5212 /* Note that this checks the owner's type, not the location's. In
5213 case the target does not support read watchpoints, but does
5214 support access watchpoints, we'll have bp_read_watchpoint
5215 watchpoints with hw_access locations. Those should be considered
5216 duplicates of hw_read locations. The hw_read locations will
5217 become hw_access locations later. */
5218 return (loc1
->owner
->type
== loc2
->owner
->type
5219 && loc1
->pspace
->aspace
== loc2
->pspace
->aspace
5220 && loc1
->address
== loc2
->address
5221 && loc1
->length
== loc2
->length
);
5224 /* Returns true if {ASPACE1,ADDR1} and {ASPACE2,ADDR2} represent the
5225 same breakpoint location. In most targets, this can only be true
5226 if ASPACE1 matches ASPACE2. On targets that have global
5227 breakpoints, the address space doesn't really matter. */
5230 breakpoint_address_match (struct address_space
*aspace1
, CORE_ADDR addr1
,
5231 struct address_space
*aspace2
, CORE_ADDR addr2
)
5233 return ((gdbarch_has_global_breakpoints (target_gdbarch
)
5234 || aspace1
== aspace2
)
5238 /* Assuming LOC1 and LOC2's types' have meaningful target addresses
5239 (breakpoint_address_is_meaningful), returns true if LOC1 and LOC2
5240 represent the same location. */
5243 breakpoint_locations_match (struct bp_location
*loc1
, struct bp_location
*loc2
)
5245 int hw_point1
, hw_point2
;
5247 /* Both of them must not be in moribund_locations. */
5248 gdb_assert (loc1
->owner
!= NULL
);
5249 gdb_assert (loc2
->owner
!= NULL
);
5251 hw_point1
= is_hardware_watchpoint (loc1
->owner
);
5252 hw_point2
= is_hardware_watchpoint (loc2
->owner
);
5254 if (hw_point1
!= hw_point2
)
5257 return watchpoint_locations_match (loc1
, loc2
);
5259 return breakpoint_address_match (loc1
->pspace
->aspace
, loc1
->address
,
5260 loc2
->pspace
->aspace
, loc2
->address
);
5264 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
5265 int bnum
, int have_bnum
)
5270 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
5271 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
5273 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
5274 bnum
, astr1
, astr2
);
5276 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
5279 /* Adjust a breakpoint's address to account for architectural constraints
5280 on breakpoint placement. Return the adjusted address. Note: Very
5281 few targets require this kind of adjustment. For most targets,
5282 this function is simply the identity function. */
5285 adjust_breakpoint_address (struct gdbarch
*gdbarch
,
5286 CORE_ADDR bpaddr
, enum bptype bptype
)
5288 if (!gdbarch_adjust_breakpoint_address_p (gdbarch
))
5290 /* Very few targets need any kind of breakpoint adjustment. */
5293 else if (bptype
== bp_watchpoint
5294 || bptype
== bp_hardware_watchpoint
5295 || bptype
== bp_read_watchpoint
5296 || bptype
== bp_access_watchpoint
5297 || bptype
== bp_catchpoint
)
5299 /* Watchpoints and the various bp_catch_* eventpoints should not
5300 have their addresses modified. */
5305 CORE_ADDR adjusted_bpaddr
;
5307 /* Some targets have architectural constraints on the placement
5308 of breakpoint instructions. Obtain the adjusted address. */
5309 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (gdbarch
, bpaddr
);
5311 /* An adjusted breakpoint address can significantly alter
5312 a user's expectations. Print a warning if an adjustment
5314 if (adjusted_bpaddr
!= bpaddr
)
5315 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
5317 return adjusted_bpaddr
;
5321 /* Allocate a struct bp_location. */
5323 static struct bp_location
*
5324 allocate_bp_location (struct breakpoint
*bpt
)
5326 struct bp_location
*loc
;
5328 loc
= xmalloc (sizeof (struct bp_location
));
5329 memset (loc
, 0, sizeof (*loc
));
5333 loc
->shlib_disabled
= 0;
5342 case bp_longjmp_resume
:
5343 case bp_step_resume
:
5344 case bp_watchpoint_scope
:
5346 case bp_std_terminate
:
5347 case bp_shlib_event
:
5348 case bp_thread_event
:
5349 case bp_overlay_event
:
5351 case bp_longjmp_master
:
5352 case bp_std_terminate_master
:
5353 loc
->loc_type
= bp_loc_software_breakpoint
;
5355 case bp_hardware_breakpoint
:
5356 loc
->loc_type
= bp_loc_hardware_breakpoint
;
5358 case bp_hardware_watchpoint
:
5359 case bp_read_watchpoint
:
5360 case bp_access_watchpoint
:
5361 loc
->loc_type
= bp_loc_hardware_watchpoint
;
5366 case bp_fast_tracepoint
:
5367 case bp_static_tracepoint
:
5368 loc
->loc_type
= bp_loc_other
;
5371 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
5377 static void free_bp_location (struct bp_location
*loc
)
5379 /* Be sure no bpstat's are pointing at it after it's been freed. */
5380 /* FIXME, how can we find all bpstat's?
5381 We just check stop_bpstat for now. Note that we cannot just
5382 remove bpstats pointing at bpt from the stop_bpstat list
5383 entirely, as breakpoint commands are associated with the bpstat;
5384 if we remove it here, then the later call to
5385 bpstat_do_actions (&stop_bpstat);
5386 in event-top.c won't do anything, and temporary breakpoints
5387 with commands won't work. */
5389 iterate_over_threads (bpstat_remove_bp_location_callback
, loc
);
5394 if (loc
->function_name
)
5395 xfree (loc
->function_name
);
5400 /* Helper to set_raw_breakpoint below. Creates a breakpoint
5401 that has type BPTYPE and has no locations as yet. */
5402 /* This function is used in gdbtk sources and thus can not be made static. */
5404 static struct breakpoint
*
5405 set_raw_breakpoint_without_location (struct gdbarch
*gdbarch
,
5408 struct breakpoint
*b
, *b1
;
5410 b
= (struct breakpoint
*) xmalloc (sizeof (struct breakpoint
));
5411 memset (b
, 0, sizeof (*b
));
5414 b
->gdbarch
= gdbarch
;
5415 b
->language
= current_language
->la_language
;
5416 b
->input_radix
= input_radix
;
5418 b
->enable_state
= bp_enabled
;
5421 b
->ignore_count
= 0;
5423 b
->frame_id
= null_frame_id
;
5424 b
->forked_inferior_pid
= null_ptid
;
5425 b
->exec_pathname
= NULL
;
5426 b
->syscalls_to_be_caught
= NULL
;
5428 b
->condition_not_parsed
= 0;
5430 /* Add this breakpoint to the end of the chain
5431 so that a list of breakpoints will come out in order
5432 of increasing numbers. */
5434 b1
= breakpoint_chain
;
5436 breakpoint_chain
= b
;
5446 /* Initialize loc->function_name. */
5448 set_breakpoint_location_function (struct bp_location
*loc
)
5450 gdb_assert (loc
->owner
!= NULL
);
5452 if (loc
->owner
->type
== bp_breakpoint
5453 || loc
->owner
->type
== bp_hardware_breakpoint
5454 || is_tracepoint (loc
->owner
))
5456 find_pc_partial_function (loc
->address
, &(loc
->function_name
),
5458 if (loc
->function_name
)
5459 loc
->function_name
= xstrdup (loc
->function_name
);
5463 /* Attempt to determine architecture of location identified by SAL. */
5464 static struct gdbarch
*
5465 get_sal_arch (struct symtab_and_line sal
)
5468 return get_objfile_arch (sal
.section
->objfile
);
5470 return get_objfile_arch (sal
.symtab
->objfile
);
5475 /* set_raw_breakpoint is a low level routine for allocating and
5476 partially initializing a breakpoint of type BPTYPE. The newly
5477 created breakpoint's address, section, source file name, and line
5478 number are provided by SAL. The newly created and partially
5479 initialized breakpoint is added to the breakpoint chain and
5480 is also returned as the value of this function.
5482 It is expected that the caller will complete the initialization of
5483 the newly created breakpoint struct as well as output any status
5484 information regarding the creation of a new breakpoint. In
5485 particular, set_raw_breakpoint does NOT set the breakpoint
5486 number! Care should be taken to not allow an error to occur
5487 prior to completing the initialization of the breakpoint. If this
5488 should happen, a bogus breakpoint will be left on the chain. */
5491 set_raw_breakpoint (struct gdbarch
*gdbarch
,
5492 struct symtab_and_line sal
, enum bptype bptype
)
5494 struct breakpoint
*b
= set_raw_breakpoint_without_location (gdbarch
, bptype
);
5495 CORE_ADDR adjusted_address
;
5496 struct gdbarch
*loc_gdbarch
;
5498 loc_gdbarch
= get_sal_arch (sal
);
5500 loc_gdbarch
= b
->gdbarch
;
5502 if (bptype
!= bp_catchpoint
)
5503 gdb_assert (sal
.pspace
!= NULL
);
5505 /* Adjust the breakpoint's address prior to allocating a location.
5506 Once we call allocate_bp_location(), that mostly uninitialized
5507 location will be placed on the location chain. Adjustment of the
5508 breakpoint may cause target_read_memory() to be called and we do
5509 not want its scan of the location chain to find a breakpoint and
5510 location that's only been partially initialized. */
5511 adjusted_address
= adjust_breakpoint_address (loc_gdbarch
, sal
.pc
, b
->type
);
5513 b
->loc
= allocate_bp_location (b
);
5514 b
->loc
->gdbarch
= loc_gdbarch
;
5515 b
->loc
->requested_address
= sal
.pc
;
5516 b
->loc
->address
= adjusted_address
;
5517 b
->loc
->pspace
= sal
.pspace
;
5519 /* Store the program space that was used to set the breakpoint, for
5520 breakpoint resetting. */
5521 b
->pspace
= sal
.pspace
;
5523 if (sal
.symtab
== NULL
)
5524 b
->source_file
= NULL
;
5526 b
->source_file
= xstrdup (sal
.symtab
->filename
);
5527 b
->loc
->section
= sal
.section
;
5528 b
->line_number
= sal
.line
;
5530 set_breakpoint_location_function (b
->loc
);
5532 breakpoints_changed ();
5538 /* Note that the breakpoint object B describes a permanent breakpoint
5539 instruction, hard-wired into the inferior's code. */
5541 make_breakpoint_permanent (struct breakpoint
*b
)
5543 struct bp_location
*bl
;
5545 b
->enable_state
= bp_permanent
;
5547 /* By definition, permanent breakpoints are already present in the code.
5548 Mark all locations as inserted. For now, make_breakpoint_permanent
5549 is called in just one place, so it's hard to say if it's reasonable
5550 to have permanent breakpoint with multiple locations or not,
5551 but it's easy to implmement. */
5552 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
5556 /* Call this routine when stepping and nexting to enable a breakpoint
5557 if we do a longjmp() in THREAD. When we hit that breakpoint, call
5558 set_longjmp_resume_breakpoint() to figure out where we are going. */
5561 set_longjmp_breakpoint (int thread
)
5563 struct breakpoint
*b
, *temp
;
5565 /* To avoid having to rescan all objfile symbols at every step,
5566 we maintain a list of continually-inserted but always disabled
5567 longjmp "master" breakpoints. Here, we simply create momentary
5568 clones of those and enable them for the requested thread. */
5569 ALL_BREAKPOINTS_SAFE (b
, temp
)
5570 if (b
->pspace
== current_program_space
5571 && b
->type
== bp_longjmp_master
)
5573 struct breakpoint
*clone
= clone_momentary_breakpoint (b
);
5575 clone
->type
= bp_longjmp
;
5576 clone
->thread
= thread
;
5580 /* Delete all longjmp breakpoints from THREAD. */
5582 delete_longjmp_breakpoint (int thread
)
5584 struct breakpoint
*b
, *temp
;
5586 ALL_BREAKPOINTS_SAFE (b
, temp
)
5587 if (b
->type
== bp_longjmp
)
5589 if (b
->thread
== thread
)
5590 delete_breakpoint (b
);
5595 enable_overlay_breakpoints (void)
5597 struct breakpoint
*b
;
5600 if (b
->type
== bp_overlay_event
)
5602 b
->enable_state
= bp_enabled
;
5603 update_global_location_list (1);
5604 overlay_events_enabled
= 1;
5609 disable_overlay_breakpoints (void)
5611 struct breakpoint
*b
;
5614 if (b
->type
== bp_overlay_event
)
5616 b
->enable_state
= bp_disabled
;
5617 update_global_location_list (0);
5618 overlay_events_enabled
= 0;
5622 /* Set an active std::terminate breakpoint for each std::terminate
5623 master breakpoint. */
5625 set_std_terminate_breakpoint (void)
5627 struct breakpoint
*b
, *temp
;
5629 ALL_BREAKPOINTS_SAFE (b
, temp
)
5630 if (b
->pspace
== current_program_space
5631 && b
->type
== bp_std_terminate_master
)
5633 struct breakpoint
*clone
= clone_momentary_breakpoint (b
);
5634 clone
->type
= bp_std_terminate
;
5638 /* Delete all the std::terminate breakpoints. */
5640 delete_std_terminate_breakpoint (void)
5642 struct breakpoint
*b
, *temp
;
5644 ALL_BREAKPOINTS_SAFE (b
, temp
)
5645 if (b
->type
== bp_std_terminate
)
5646 delete_breakpoint (b
);
5650 create_thread_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
5652 struct breakpoint
*b
;
5654 b
= create_internal_breakpoint (gdbarch
, address
, bp_thread_event
);
5656 b
->enable_state
= bp_enabled
;
5657 /* addr_string has to be used or breakpoint_re_set will delete me. */
5659 = xstrprintf ("*%s", paddress (b
->loc
->gdbarch
, b
->loc
->address
));
5661 update_global_location_list_nothrow (1);
5667 remove_thread_event_breakpoints (void)
5669 struct breakpoint
*b
, *temp
;
5671 ALL_BREAKPOINTS_SAFE (b
, temp
)
5672 if (b
->type
== bp_thread_event
5673 && b
->loc
->pspace
== current_program_space
)
5674 delete_breakpoint (b
);
5677 struct captured_parse_breakpoint_args
5680 struct symtabs_and_lines
*sals_p
;
5681 char ***addr_string_p
;
5685 struct lang_and_radix
5691 /* Create a breakpoint for JIT code registration and unregistration. */
5694 create_jit_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
5696 struct breakpoint
*b
;
5698 b
= create_internal_breakpoint (gdbarch
, address
, bp_jit_event
);
5699 update_global_location_list_nothrow (1);
5704 remove_solib_event_breakpoints (void)
5706 struct breakpoint
*b
, *temp
;
5708 ALL_BREAKPOINTS_SAFE (b
, temp
)
5709 if (b
->type
== bp_shlib_event
5710 && b
->loc
->pspace
== current_program_space
)
5711 delete_breakpoint (b
);
5715 create_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
5717 struct breakpoint
*b
;
5719 b
= create_internal_breakpoint (gdbarch
, address
, bp_shlib_event
);
5720 update_global_location_list_nothrow (1);
5724 /* Disable any breakpoints that are on code in shared libraries. Only
5725 apply to enabled breakpoints, disabled ones can just stay disabled. */
5728 disable_breakpoints_in_shlibs (void)
5730 struct bp_location
*loc
, **locp_tmp
;
5732 ALL_BP_LOCATIONS (loc
, locp_tmp
)
5734 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
5735 struct breakpoint
*b
= loc
->owner
;
5737 /* We apply the check to all breakpoints, including disabled
5738 for those with loc->duplicate set. This is so that when breakpoint
5739 becomes enabled, or the duplicate is removed, gdb will try to insert
5740 all breakpoints. If we don't set shlib_disabled here, we'll try
5741 to insert those breakpoints and fail. */
5742 if (((b
->type
== bp_breakpoint
)
5743 || (b
->type
== bp_jit_event
)
5744 || (b
->type
== bp_hardware_breakpoint
)
5745 || (is_tracepoint (b
)))
5746 && loc
->pspace
== current_program_space
5747 && !loc
->shlib_disabled
5749 && PC_SOLIB (loc
->address
)
5751 && solib_name_from_address (loc
->pspace
, loc
->address
)
5755 loc
->shlib_disabled
= 1;
5760 /* Disable any breakpoints that are in in an unloaded shared library. Only
5761 apply to enabled breakpoints, disabled ones can just stay disabled. */
5764 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
5766 struct bp_location
*loc
, **locp_tmp
;
5767 int disabled_shlib_breaks
= 0;
5769 /* SunOS a.out shared libraries are always mapped, so do not
5770 disable breakpoints; they will only be reported as unloaded
5771 through clear_solib when GDB discards its shared library
5772 list. See clear_solib for more information. */
5773 if (exec_bfd
!= NULL
5774 && bfd_get_flavour (exec_bfd
) == bfd_target_aout_flavour
)
5777 ALL_BP_LOCATIONS (loc
, locp_tmp
)
5779 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
5780 struct breakpoint
*b
= loc
->owner
;
5782 if ((loc
->loc_type
== bp_loc_hardware_breakpoint
5783 || loc
->loc_type
== bp_loc_software_breakpoint
)
5784 && solib
->pspace
== loc
->pspace
5785 && !loc
->shlib_disabled
5786 && (b
->type
== bp_breakpoint
5787 || b
->type
== bp_jit_event
5788 || b
->type
== bp_hardware_breakpoint
)
5789 && solib_contains_address_p (solib
, loc
->address
))
5791 loc
->shlib_disabled
= 1;
5792 /* At this point, we cannot rely on remove_breakpoint
5793 succeeding so we must mark the breakpoint as not inserted
5794 to prevent future errors occurring in remove_breakpoints. */
5796 if (!disabled_shlib_breaks
)
5798 target_terminal_ours_for_output ();
5799 warning (_("Temporarily disabling breakpoints for unloaded shared library \"%s\""),
5802 disabled_shlib_breaks
= 1;
5807 /* FORK & VFORK catchpoints. */
5809 /* Implement the "insert" breakpoint_ops method for fork catchpoints. */
5812 insert_catch_fork (struct breakpoint
*b
)
5814 target_insert_fork_catchpoint (PIDGET (inferior_ptid
));
5817 /* Implement the "remove" breakpoint_ops method for fork catchpoints. */
5820 remove_catch_fork (struct breakpoint
*b
)
5822 return target_remove_fork_catchpoint (PIDGET (inferior_ptid
));
5825 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
5829 breakpoint_hit_catch_fork (struct breakpoint
*b
)
5831 return inferior_has_forked (inferior_ptid
, &b
->forked_inferior_pid
);
5834 /* Implement the "print_it" breakpoint_ops method for fork catchpoints. */
5836 static enum print_stop_action
5837 print_it_catch_fork (struct breakpoint
*b
)
5839 annotate_catchpoint (b
->number
);
5840 printf_filtered (_("\nCatchpoint %d (forked process %d), "),
5841 b
->number
, ptid_get_pid (b
->forked_inferior_pid
));
5842 return PRINT_SRC_AND_LOC
;
5845 /* Implement the "print_one" breakpoint_ops method for fork catchpoints. */
5848 print_one_catch_fork (struct breakpoint
*b
, struct bp_location
**last_loc
)
5850 struct value_print_options opts
;
5852 get_user_print_options (&opts
);
5854 /* Field 4, the address, is omitted (which makes the columns
5855 not line up too nicely with the headers, but the effect
5856 is relatively readable). */
5857 if (opts
.addressprint
)
5858 ui_out_field_skip (uiout
, "addr");
5860 ui_out_text (uiout
, "fork");
5861 if (!ptid_equal (b
->forked_inferior_pid
, null_ptid
))
5863 ui_out_text (uiout
, ", process ");
5864 ui_out_field_int (uiout
, "what",
5865 ptid_get_pid (b
->forked_inferior_pid
));
5866 ui_out_spaces (uiout
, 1);
5870 /* Implement the "print_mention" breakpoint_ops method for fork
5874 print_mention_catch_fork (struct breakpoint
*b
)
5876 printf_filtered (_("Catchpoint %d (fork)"), b
->number
);
5879 /* Implement the "print_recreate" breakpoint_ops method for fork
5883 print_recreate_catch_fork (struct breakpoint
*b
, struct ui_file
*fp
)
5885 fprintf_unfiltered (fp
, "catch fork");
5888 /* The breakpoint_ops structure to be used in fork catchpoints. */
5890 static struct breakpoint_ops catch_fork_breakpoint_ops
=
5894 breakpoint_hit_catch_fork
,
5895 print_it_catch_fork
,
5896 print_one_catch_fork
,
5897 print_mention_catch_fork
,
5898 print_recreate_catch_fork
5901 /* Implement the "insert" breakpoint_ops method for vfork catchpoints. */
5904 insert_catch_vfork (struct breakpoint
*b
)
5906 target_insert_vfork_catchpoint (PIDGET (inferior_ptid
));
5909 /* Implement the "remove" breakpoint_ops method for vfork catchpoints. */
5912 remove_catch_vfork (struct breakpoint
*b
)
5914 return target_remove_vfork_catchpoint (PIDGET (inferior_ptid
));
5917 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
5921 breakpoint_hit_catch_vfork (struct breakpoint
*b
)
5923 return inferior_has_vforked (inferior_ptid
, &b
->forked_inferior_pid
);
5926 /* Implement the "print_it" breakpoint_ops method for vfork catchpoints. */
5928 static enum print_stop_action
5929 print_it_catch_vfork (struct breakpoint
*b
)
5931 annotate_catchpoint (b
->number
);
5932 printf_filtered (_("\nCatchpoint %d (vforked process %d), "),
5933 b
->number
, ptid_get_pid (b
->forked_inferior_pid
));
5934 return PRINT_SRC_AND_LOC
;
5937 /* Implement the "print_one" breakpoint_ops method for vfork catchpoints. */
5940 print_one_catch_vfork (struct breakpoint
*b
, struct bp_location
**last_loc
)
5942 struct value_print_options opts
;
5944 get_user_print_options (&opts
);
5945 /* Field 4, the address, is omitted (which makes the columns
5946 not line up too nicely with the headers, but the effect
5947 is relatively readable). */
5948 if (opts
.addressprint
)
5949 ui_out_field_skip (uiout
, "addr");
5951 ui_out_text (uiout
, "vfork");
5952 if (!ptid_equal (b
->forked_inferior_pid
, null_ptid
))
5954 ui_out_text (uiout
, ", process ");
5955 ui_out_field_int (uiout
, "what",
5956 ptid_get_pid (b
->forked_inferior_pid
));
5957 ui_out_spaces (uiout
, 1);
5961 /* Implement the "print_mention" breakpoint_ops method for vfork
5965 print_mention_catch_vfork (struct breakpoint
*b
)
5967 printf_filtered (_("Catchpoint %d (vfork)"), b
->number
);
5970 /* Implement the "print_recreate" breakpoint_ops method for vfork
5974 print_recreate_catch_vfork (struct breakpoint
*b
, struct ui_file
*fp
)
5976 fprintf_unfiltered (fp
, "catch vfork");
5979 /* The breakpoint_ops structure to be used in vfork catchpoints. */
5981 static struct breakpoint_ops catch_vfork_breakpoint_ops
=
5985 breakpoint_hit_catch_vfork
,
5986 print_it_catch_vfork
,
5987 print_one_catch_vfork
,
5988 print_mention_catch_vfork
,
5989 print_recreate_catch_vfork
5992 /* Implement the "insert" breakpoint_ops method for syscall
5996 insert_catch_syscall (struct breakpoint
*b
)
5998 struct inferior
*inf
= current_inferior ();
6000 ++inf
->total_syscalls_count
;
6001 if (!b
->syscalls_to_be_caught
)
6002 ++inf
->any_syscall_count
;
6008 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
6013 if (iter
>= VEC_length (int, inf
->syscalls_counts
))
6015 int old_size
= VEC_length (int, inf
->syscalls_counts
);
6016 uintptr_t vec_addr_offset
= old_size
* ((uintptr_t) sizeof (int));
6018 VEC_safe_grow (int, inf
->syscalls_counts
, iter
+ 1);
6019 vec_addr
= (uintptr_t) VEC_address (int, inf
->syscalls_counts
) +
6021 memset ((void *) vec_addr
, 0,
6022 (iter
+ 1 - old_size
) * sizeof (int));
6024 elem
= VEC_index (int, inf
->syscalls_counts
, iter
);
6025 VEC_replace (int, inf
->syscalls_counts
, iter
, ++elem
);
6029 target_set_syscall_catchpoint (PIDGET (inferior_ptid
),
6030 inf
->total_syscalls_count
!= 0,
6031 inf
->any_syscall_count
,
6032 VEC_length (int, inf
->syscalls_counts
),
6033 VEC_address (int, inf
->syscalls_counts
));
6036 /* Implement the "remove" breakpoint_ops method for syscall
6040 remove_catch_syscall (struct breakpoint
*b
)
6042 struct inferior
*inf
= current_inferior ();
6044 --inf
->total_syscalls_count
;
6045 if (!b
->syscalls_to_be_caught
)
6046 --inf
->any_syscall_count
;
6052 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
6056 if (iter
>= VEC_length (int, inf
->syscalls_counts
))
6057 /* Shouldn't happen. */
6059 elem
= VEC_index (int, inf
->syscalls_counts
, iter
);
6060 VEC_replace (int, inf
->syscalls_counts
, iter
, --elem
);
6064 return target_set_syscall_catchpoint (PIDGET (inferior_ptid
),
6065 inf
->total_syscalls_count
!= 0,
6066 inf
->any_syscall_count
,
6067 VEC_length (int, inf
->syscalls_counts
),
6068 VEC_address (int, inf
->syscalls_counts
));
6071 /* Implement the "breakpoint_hit" breakpoint_ops method for syscall
6075 breakpoint_hit_catch_syscall (struct breakpoint
*b
)
6077 /* We must check if we are catching specific syscalls in this breakpoint.
6078 If we are, then we must guarantee that the called syscall is the same
6079 syscall we are catching. */
6080 int syscall_number
= 0;
6082 if (!inferior_has_called_syscall (inferior_ptid
, &syscall_number
))
6085 /* Now, checking if the syscall is the same. */
6086 if (b
->syscalls_to_be_caught
)
6091 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
6093 if (syscall_number
== iter
)
6103 /* Implement the "print_it" breakpoint_ops method for syscall
6106 static enum print_stop_action
6107 print_it_catch_syscall (struct breakpoint
*b
)
6109 /* These are needed because we want to know in which state a
6110 syscall is. It can be in the TARGET_WAITKIND_SYSCALL_ENTRY
6111 or TARGET_WAITKIND_SYSCALL_RETURN, and depending on it we
6112 must print "called syscall" or "returned from syscall". */
6114 struct target_waitstatus last
;
6116 struct cleanup
*old_chain
;
6119 get_last_target_status (&ptid
, &last
);
6121 get_syscall_by_number (last
.value
.syscall_number
, &s
);
6123 annotate_catchpoint (b
->number
);
6126 syscall_id
= xstrprintf ("%d", last
.value
.syscall_number
);
6128 syscall_id
= xstrprintf ("'%s'", s
.name
);
6130 old_chain
= make_cleanup (xfree
, syscall_id
);
6132 if (last
.kind
== TARGET_WAITKIND_SYSCALL_ENTRY
)
6133 printf_filtered (_("\nCatchpoint %d (call to syscall %s), "),
6134 b
->number
, syscall_id
);
6135 else if (last
.kind
== TARGET_WAITKIND_SYSCALL_RETURN
)
6136 printf_filtered (_("\nCatchpoint %d (returned from syscall %s), "),
6137 b
->number
, syscall_id
);
6139 do_cleanups (old_chain
);
6141 return PRINT_SRC_AND_LOC
;
6144 /* Implement the "print_one" breakpoint_ops method for syscall
6148 print_one_catch_syscall (struct breakpoint
*b
,
6149 struct bp_location
**last_loc
)
6151 struct value_print_options opts
;
6153 get_user_print_options (&opts
);
6154 /* Field 4, the address, is omitted (which makes the columns
6155 not line up too nicely with the headers, but the effect
6156 is relatively readable). */
6157 if (opts
.addressprint
)
6158 ui_out_field_skip (uiout
, "addr");
6161 if (b
->syscalls_to_be_caught
6162 && VEC_length (int, b
->syscalls_to_be_caught
) > 1)
6163 ui_out_text (uiout
, "syscalls \"");
6165 ui_out_text (uiout
, "syscall \"");
6167 if (b
->syscalls_to_be_caught
)
6170 char *text
= xstrprintf ("%s", "");
6173 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
6178 get_syscall_by_number (iter
, &s
);
6181 text
= xstrprintf ("%s%s, ", text
, s
.name
);
6183 text
= xstrprintf ("%s%d, ", text
, iter
);
6185 /* We have to xfree the last 'text' (now stored at 'x')
6186 because xstrprintf dinamically allocates new space for it
6190 /* Remove the last comma. */
6191 text
[strlen (text
) - 2] = '\0';
6192 ui_out_field_string (uiout
, "what", text
);
6195 ui_out_field_string (uiout
, "what", "<any syscall>");
6196 ui_out_text (uiout
, "\" ");
6199 /* Implement the "print_mention" breakpoint_ops method for syscall
6203 print_mention_catch_syscall (struct breakpoint
*b
)
6205 if (b
->syscalls_to_be_caught
)
6209 if (VEC_length (int, b
->syscalls_to_be_caught
) > 1)
6210 printf_filtered (_("Catchpoint %d (syscalls"), b
->number
);
6212 printf_filtered (_("Catchpoint %d (syscall"), b
->number
);
6215 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
6219 get_syscall_by_number (iter
, &s
);
6222 printf_filtered (" '%s' [%d]", s
.name
, s
.number
);
6224 printf_filtered (" %d", s
.number
);
6226 printf_filtered (")");
6229 printf_filtered (_("Catchpoint %d (any syscall)"),
6233 /* Implement the "print_recreate" breakpoint_ops method for syscall
6237 print_recreate_catch_syscall (struct breakpoint
*b
, struct ui_file
*fp
)
6239 fprintf_unfiltered (fp
, "catch syscall");
6241 if (b
->syscalls_to_be_caught
)
6246 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
6251 get_syscall_by_number (iter
, &s
);
6253 fprintf_unfiltered (fp
, " %s", s
.name
);
6255 fprintf_unfiltered (fp
, " %d", s
.number
);
6260 /* The breakpoint_ops structure to be used in syscall catchpoints. */
6262 static struct breakpoint_ops catch_syscall_breakpoint_ops
=
6264 insert_catch_syscall
,
6265 remove_catch_syscall
,
6266 breakpoint_hit_catch_syscall
,
6267 print_it_catch_syscall
,
6268 print_one_catch_syscall
,
6269 print_mention_catch_syscall
,
6270 print_recreate_catch_syscall
6273 /* Returns non-zero if 'b' is a syscall catchpoint. */
6276 syscall_catchpoint_p (struct breakpoint
*b
)
6278 return (b
->ops
== &catch_syscall_breakpoint_ops
);
6281 /* Create a new breakpoint of the bp_catchpoint kind and return it,
6282 but does NOT mention it nor update the global location list.
6283 This is useful if you need to fill more fields in the
6284 struct breakpoint before calling mention.
6286 If TEMPFLAG is non-zero, then make the breakpoint temporary.
6287 If COND_STRING is not NULL, then store it in the breakpoint.
6288 OPS, if not NULL, is the breakpoint_ops structure associated
6289 to the catchpoint. */
6291 static struct breakpoint
*
6292 create_catchpoint_without_mention (struct gdbarch
*gdbarch
, int tempflag
,
6294 struct breakpoint_ops
*ops
)
6296 struct symtab_and_line sal
;
6297 struct breakpoint
*b
;
6300 sal
.pspace
= current_program_space
;
6302 b
= set_raw_breakpoint (gdbarch
, sal
, bp_catchpoint
);
6303 set_breakpoint_count (breakpoint_count
+ 1);
6304 b
->number
= breakpoint_count
;
6306 b
->cond_string
= (cond_string
== NULL
) ? NULL
: xstrdup (cond_string
);
6308 b
->addr_string
= NULL
;
6309 b
->enable_state
= bp_enabled
;
6310 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6316 /* Create a new breakpoint of the bp_catchpoint kind and return it.
6318 If TEMPFLAG is non-zero, then make the breakpoint temporary.
6319 If COND_STRING is not NULL, then store it in the breakpoint.
6320 OPS, if not NULL, is the breakpoint_ops structure associated
6321 to the catchpoint. */
6323 static struct breakpoint
*
6324 create_catchpoint (struct gdbarch
*gdbarch
, int tempflag
,
6325 char *cond_string
, struct breakpoint_ops
*ops
)
6327 struct breakpoint
*b
=
6328 create_catchpoint_without_mention (gdbarch
, tempflag
, cond_string
, ops
);
6331 update_global_location_list (1);
6337 create_fork_vfork_event_catchpoint (struct gdbarch
*gdbarch
,
6338 int tempflag
, char *cond_string
,
6339 struct breakpoint_ops
*ops
)
6341 struct breakpoint
*b
6342 = create_catchpoint (gdbarch
, tempflag
, cond_string
, ops
);
6344 /* FIXME: We should put this information in a breakpoint private data
6346 b
->forked_inferior_pid
= null_ptid
;
6349 /* Exec catchpoints. */
6352 insert_catch_exec (struct breakpoint
*b
)
6354 target_insert_exec_catchpoint (PIDGET (inferior_ptid
));
6358 remove_catch_exec (struct breakpoint
*b
)
6360 return target_remove_exec_catchpoint (PIDGET (inferior_ptid
));
6364 breakpoint_hit_catch_exec (struct breakpoint
*b
)
6366 return inferior_has_execd (inferior_ptid
, &b
->exec_pathname
);
6369 static enum print_stop_action
6370 print_it_catch_exec (struct breakpoint
*b
)
6372 annotate_catchpoint (b
->number
);
6373 printf_filtered (_("\nCatchpoint %d (exec'd %s), "), b
->number
,
6375 return PRINT_SRC_AND_LOC
;
6379 print_one_catch_exec (struct breakpoint
*b
, struct bp_location
**last_loc
)
6381 struct value_print_options opts
;
6383 get_user_print_options (&opts
);
6385 /* Field 4, the address, is omitted (which makes the columns
6386 not line up too nicely with the headers, but the effect
6387 is relatively readable). */
6388 if (opts
.addressprint
)
6389 ui_out_field_skip (uiout
, "addr");
6391 ui_out_text (uiout
, "exec");
6392 if (b
->exec_pathname
!= NULL
)
6394 ui_out_text (uiout
, ", program \"");
6395 ui_out_field_string (uiout
, "what", b
->exec_pathname
);
6396 ui_out_text (uiout
, "\" ");
6401 print_mention_catch_exec (struct breakpoint
*b
)
6403 printf_filtered (_("Catchpoint %d (exec)"), b
->number
);
6406 /* Implement the "print_recreate" breakpoint_ops method for exec
6410 print_recreate_catch_exec (struct breakpoint
*b
, struct ui_file
*fp
)
6412 fprintf_unfiltered (fp
, "catch exec");
6415 static struct breakpoint_ops catch_exec_breakpoint_ops
=
6419 breakpoint_hit_catch_exec
,
6420 print_it_catch_exec
,
6421 print_one_catch_exec
,
6422 print_mention_catch_exec
,
6423 print_recreate_catch_exec
6427 create_syscall_event_catchpoint (int tempflag
, VEC(int) *filter
,
6428 struct breakpoint_ops
*ops
)
6430 struct gdbarch
*gdbarch
= get_current_arch ();
6431 struct breakpoint
*b
=
6432 create_catchpoint_without_mention (gdbarch
, tempflag
, NULL
, ops
);
6434 b
->syscalls_to_be_caught
= filter
;
6436 /* Now, we have to mention the breakpoint and update the global
6439 update_global_location_list (1);
6443 hw_breakpoint_used_count (void)
6445 struct breakpoint
*b
;
6450 if (b
->type
== bp_hardware_breakpoint
&& breakpoint_enabled (b
))
6458 hw_watchpoint_used_count (enum bptype type
, int *other_type_used
)
6460 struct breakpoint
*b
;
6463 *other_type_used
= 0;
6466 if (breakpoint_enabled (b
))
6468 if (b
->type
== type
)
6470 else if (is_hardware_watchpoint (b
))
6471 *other_type_used
= 1;
6478 disable_watchpoints_before_interactive_call_start (void)
6480 struct breakpoint
*b
;
6484 if (is_watchpoint (b
) && breakpoint_enabled (b
))
6486 b
->enable_state
= bp_call_disabled
;
6487 update_global_location_list (0);
6493 enable_watchpoints_after_interactive_call_stop (void)
6495 struct breakpoint
*b
;
6499 if (is_watchpoint (b
) && b
->enable_state
== bp_call_disabled
)
6501 b
->enable_state
= bp_enabled
;
6502 update_global_location_list (1);
6508 disable_breakpoints_before_startup (void)
6510 struct breakpoint
*b
;
6515 if (b
->pspace
!= current_program_space
)
6518 if ((b
->type
== bp_breakpoint
6519 || b
->type
== bp_hardware_breakpoint
)
6520 && breakpoint_enabled (b
))
6522 b
->enable_state
= bp_startup_disabled
;
6528 update_global_location_list (0);
6530 current_program_space
->executing_startup
= 1;
6534 enable_breakpoints_after_startup (void)
6536 struct breakpoint
*b
;
6539 current_program_space
->executing_startup
= 0;
6543 if (b
->pspace
!= current_program_space
)
6546 if ((b
->type
== bp_breakpoint
6547 || b
->type
== bp_hardware_breakpoint
)
6548 && b
->enable_state
== bp_startup_disabled
)
6550 b
->enable_state
= bp_enabled
;
6556 breakpoint_re_set ();
6560 /* Set a breakpoint that will evaporate an end of command
6561 at address specified by SAL.
6562 Restrict it to frame FRAME if FRAME is nonzero. */
6565 set_momentary_breakpoint (struct gdbarch
*gdbarch
, struct symtab_and_line sal
,
6566 struct frame_id frame_id
, enum bptype type
)
6568 struct breakpoint
*b
;
6570 /* If FRAME_ID is valid, it should be a real frame, not an inlined
6572 gdb_assert (!frame_id_inlined_p (frame_id
));
6574 b
= set_raw_breakpoint (gdbarch
, sal
, type
);
6575 b
->enable_state
= bp_enabled
;
6576 b
->disposition
= disp_donttouch
;
6577 b
->frame_id
= frame_id
;
6579 /* If we're debugging a multi-threaded program, then we
6580 want momentary breakpoints to be active in only a
6581 single thread of control. */
6582 if (in_thread_list (inferior_ptid
))
6583 b
->thread
= pid_to_thread_id (inferior_ptid
);
6585 update_global_location_list_nothrow (1);
6590 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
6594 clone_momentary_breakpoint (struct breakpoint
*orig
)
6596 struct breakpoint
*copy
;
6598 /* If there's nothing to clone, then return nothing. */
6602 copy
= set_raw_breakpoint_without_location (orig
->gdbarch
, orig
->type
);
6603 copy
->loc
= allocate_bp_location (copy
);
6604 set_breakpoint_location_function (copy
->loc
);
6606 copy
->loc
->gdbarch
= orig
->loc
->gdbarch
;
6607 copy
->loc
->requested_address
= orig
->loc
->requested_address
;
6608 copy
->loc
->address
= orig
->loc
->address
;
6609 copy
->loc
->section
= orig
->loc
->section
;
6610 copy
->loc
->pspace
= orig
->loc
->pspace
;
6612 if (orig
->source_file
== NULL
)
6613 copy
->source_file
= NULL
;
6615 copy
->source_file
= xstrdup (orig
->source_file
);
6617 copy
->line_number
= orig
->line_number
;
6618 copy
->frame_id
= orig
->frame_id
;
6619 copy
->thread
= orig
->thread
;
6620 copy
->pspace
= orig
->pspace
;
6622 copy
->enable_state
= bp_enabled
;
6623 copy
->disposition
= disp_donttouch
;
6624 copy
->number
= internal_breakpoint_number
--;
6626 update_global_location_list_nothrow (0);
6631 set_momentary_breakpoint_at_pc (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
6634 struct symtab_and_line sal
;
6636 sal
= find_pc_line (pc
, 0);
6638 sal
.section
= find_pc_overlay (pc
);
6639 sal
.explicit_pc
= 1;
6641 return set_momentary_breakpoint (gdbarch
, sal
, null_frame_id
, type
);
6645 /* Tell the user we have just set a breakpoint B. */
6648 mention (struct breakpoint
*b
)
6651 struct cleanup
*ui_out_chain
;
6652 struct value_print_options opts
;
6654 get_user_print_options (&opts
);
6656 /* FIXME: This is misplaced; mention() is called by things (like
6657 hitting a watchpoint) other than breakpoint creation. It should
6658 be possible to clean this up and at the same time replace the
6659 random calls to breakpoint_changed with this hook. */
6660 observer_notify_breakpoint_created (b
->number
);
6662 if (b
->ops
!= NULL
&& b
->ops
->print_mention
!= NULL
)
6663 b
->ops
->print_mention (b
);
6668 printf_filtered (_("(apparently deleted?) Eventpoint %d: "), b
->number
);
6671 ui_out_text (uiout
, "Watchpoint ");
6672 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
6673 ui_out_field_int (uiout
, "number", b
->number
);
6674 ui_out_text (uiout
, ": ");
6675 ui_out_field_string (uiout
, "exp", b
->exp_string
);
6676 do_cleanups (ui_out_chain
);
6678 case bp_hardware_watchpoint
:
6679 ui_out_text (uiout
, "Hardware watchpoint ");
6680 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
6681 ui_out_field_int (uiout
, "number", b
->number
);
6682 ui_out_text (uiout
, ": ");
6683 ui_out_field_string (uiout
, "exp", b
->exp_string
);
6684 do_cleanups (ui_out_chain
);
6686 case bp_read_watchpoint
:
6687 ui_out_text (uiout
, "Hardware read watchpoint ");
6688 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
6689 ui_out_field_int (uiout
, "number", b
->number
);
6690 ui_out_text (uiout
, ": ");
6691 ui_out_field_string (uiout
, "exp", b
->exp_string
);
6692 do_cleanups (ui_out_chain
);
6694 case bp_access_watchpoint
:
6695 ui_out_text (uiout
, "Hardware access (read/write) watchpoint ");
6696 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
6697 ui_out_field_int (uiout
, "number", b
->number
);
6698 ui_out_text (uiout
, ": ");
6699 ui_out_field_string (uiout
, "exp", b
->exp_string
);
6700 do_cleanups (ui_out_chain
);
6703 if (ui_out_is_mi_like_p (uiout
))
6708 if (b
->disposition
== disp_del
)
6709 printf_filtered (_("Temporary breakpoint"));
6711 printf_filtered (_("Breakpoint"));
6712 printf_filtered (_(" %d"), b
->number
);
6715 case bp_hardware_breakpoint
:
6716 if (ui_out_is_mi_like_p (uiout
))
6721 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
6725 if (ui_out_is_mi_like_p (uiout
))
6730 printf_filtered (_("Tracepoint"));
6731 printf_filtered (_(" %d"), b
->number
);
6734 case bp_fast_tracepoint
:
6735 if (ui_out_is_mi_like_p (uiout
))
6740 printf_filtered (_("Fast tracepoint"));
6741 printf_filtered (_(" %d"), b
->number
);
6744 case bp_static_tracepoint
:
6745 if (ui_out_is_mi_like_p (uiout
))
6750 printf_filtered (_("Static tracepoint"));
6751 printf_filtered (_(" %d"), b
->number
);
6758 case bp_longjmp_resume
:
6759 case bp_step_resume
:
6761 case bp_std_terminate
:
6762 case bp_watchpoint_scope
:
6763 case bp_shlib_event
:
6764 case bp_thread_event
:
6765 case bp_overlay_event
:
6767 case bp_longjmp_master
:
6768 case bp_std_terminate_master
:
6774 /* i18n: cagney/2005-02-11: Below needs to be merged into a
6778 printf_filtered (_(" (%s) pending."), b
->addr_string
);
6782 if (opts
.addressprint
|| b
->source_file
== NULL
)
6784 printf_filtered (" at ");
6785 fputs_filtered (paddress (b
->loc
->gdbarch
, b
->loc
->address
),
6789 printf_filtered (": file %s, line %d.",
6790 b
->source_file
, b
->line_number
);
6794 struct bp_location
*loc
= b
->loc
;
6796 for (; loc
; loc
= loc
->next
)
6798 printf_filtered (" (%d locations)", n
);
6803 if (ui_out_is_mi_like_p (uiout
))
6805 printf_filtered ("\n");
6809 static struct bp_location
*
6810 add_location_to_breakpoint (struct breakpoint
*b
,
6811 const struct symtab_and_line
*sal
)
6813 struct bp_location
*loc
, **tmp
;
6815 loc
= allocate_bp_location (b
);
6816 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
6819 loc
->gdbarch
= get_sal_arch (*sal
);
6821 loc
->gdbarch
= b
->gdbarch
;
6822 loc
->requested_address
= sal
->pc
;
6823 loc
->address
= adjust_breakpoint_address (loc
->gdbarch
,
6824 loc
->requested_address
, b
->type
);
6825 loc
->pspace
= sal
->pspace
;
6826 gdb_assert (loc
->pspace
!= NULL
);
6827 loc
->section
= sal
->section
;
6829 set_breakpoint_location_function (loc
);
6834 /* Return 1 if LOC is pointing to a permanent breakpoint,
6835 return 0 otherwise. */
6838 bp_loc_is_permanent (struct bp_location
*loc
)
6842 const gdb_byte
*brk
;
6843 gdb_byte
*target_mem
;
6844 struct cleanup
*cleanup
;
6847 gdb_assert (loc
!= NULL
);
6849 addr
= loc
->address
;
6850 brk
= gdbarch_breakpoint_from_pc (loc
->gdbarch
, &addr
, &len
);
6852 /* Software breakpoints unsupported? */
6856 target_mem
= alloca (len
);
6858 /* Enable the automatic memory restoration from breakpoints while
6859 we read the memory. Otherwise we could say about our temporary
6860 breakpoints they are permanent. */
6861 cleanup
= save_current_space_and_thread ();
6863 switch_to_program_space_and_thread (loc
->pspace
);
6864 make_show_memory_breakpoints_cleanup (0);
6866 if (target_read_memory (loc
->address
, target_mem
, len
) == 0
6867 && memcmp (target_mem
, brk
, len
) == 0)
6870 do_cleanups (cleanup
);
6877 /* Create a breakpoint with SAL as location. Use ADDR_STRING
6878 as textual description of the location, and COND_STRING
6879 as condition expression. */
6882 create_breakpoint_sal (struct gdbarch
*gdbarch
,
6883 struct symtabs_and_lines sals
, char *addr_string
,
6885 enum bptype type
, enum bpdisp disposition
,
6886 int thread
, int task
, int ignore_count
,
6887 struct breakpoint_ops
*ops
, int from_tty
, int enabled
)
6889 struct breakpoint
*b
= NULL
;
6892 if (type
== bp_hardware_breakpoint
)
6894 int i
= hw_breakpoint_used_count ();
6895 int target_resources_ok
=
6896 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
6898 if (target_resources_ok
== 0)
6899 error (_("No hardware breakpoint support in the target."));
6900 else if (target_resources_ok
< 0)
6901 error (_("Hardware breakpoints used exceeds limit."));
6904 gdb_assert (sals
.nelts
> 0);
6906 for (i
= 0; i
< sals
.nelts
; ++i
)
6908 struct symtab_and_line sal
= sals
.sals
[i
];
6909 struct bp_location
*loc
;
6913 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
6915 loc_gdbarch
= gdbarch
;
6917 describe_other_breakpoints (loc_gdbarch
,
6918 sal
.pspace
, sal
.pc
, sal
.section
, thread
);
6923 b
= set_raw_breakpoint (gdbarch
, sal
, type
);
6924 set_breakpoint_count (breakpoint_count
+ 1);
6925 b
->number
= breakpoint_count
;
6929 b
->cond_string
= cond_string
;
6930 b
->ignore_count
= ignore_count
;
6931 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
6932 b
->disposition
= disposition
;
6933 b
->pspace
= sals
.sals
[0].pspace
;
6935 if (type
== bp_static_tracepoint
)
6937 struct static_tracepoint_marker marker
;
6939 if (is_marker_spec (addr_string
))
6941 /* We already know the marker exists, otherwise, we
6942 wouldn't see a sal for it. */
6943 char *p
= &addr_string
[3];
6948 while (*p
== ' ' || *p
== '\t')
6952 while (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
6955 marker_str
= savestring (p
, endp
- p
);
6956 b
->static_trace_marker_id
= marker_str
;
6958 printf_filtered (_("Probed static tracepoint marker \"%s\"\n"),
6959 b
->static_trace_marker_id
);
6961 else if (target_static_tracepoint_marker_at (sal
.pc
, &marker
))
6963 b
->static_trace_marker_id
= xstrdup (marker
.str_id
);
6964 release_static_tracepoint_marker (&marker
);
6966 printf_filtered (_("Probed static tracepoint marker \"%s\"\n"),
6967 b
->static_trace_marker_id
);
6971 Couldn't determine the static tracepoint marker to probe"));
6974 if (enabled
&& b
->pspace
->executing_startup
6975 && (b
->type
== bp_breakpoint
6976 || b
->type
== bp_hardware_breakpoint
))
6977 b
->enable_state
= bp_startup_disabled
;
6983 loc
= add_location_to_breakpoint (b
, &sal
);
6986 if (bp_loc_is_permanent (loc
))
6987 make_breakpoint_permanent (b
);
6991 char *arg
= b
->cond_string
;
6992 loc
->cond
= parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
6994 error (_("Garbage %s follows condition"), arg
);
6999 b
->addr_string
= addr_string
;
7001 /* addr_string has to be used or breakpoint_re_set will delete
7004 = xstrprintf ("*%s", paddress (b
->loc
->gdbarch
, b
->loc
->address
));
7010 /* Remove element at INDEX_TO_REMOVE from SAL, shifting other
7011 elements to fill the void space. */
7013 remove_sal (struct symtabs_and_lines
*sal
, int index_to_remove
)
7015 int i
= index_to_remove
+1;
7016 int last_index
= sal
->nelts
-1;
7018 for (;i
<= last_index
; ++i
)
7019 sal
->sals
[i
-1] = sal
->sals
[i
];
7024 /* If appropriate, obtains all sals that correspond to the same file
7025 and line as SAL, in all program spaces. Users debugging with IDEs,
7026 will want to set a breakpoint at foo.c:line, and not really care
7027 about program spaces. This is done only if SAL does not have
7028 explicit PC and has line and file information. If we got just a
7029 single expanded sal, return the original.
7031 Otherwise, if SAL.explicit_line is not set, filter out all sals for
7032 which the name of enclosing function is different from SAL. This
7033 makes sure that if we have breakpoint originally set in template
7034 instantiation, say foo<int>(), we won't expand SAL to locations at
7035 the same line in all existing instantiations of 'foo'. */
7037 static struct symtabs_and_lines
7038 expand_line_sal_maybe (struct symtab_and_line sal
)
7040 struct symtabs_and_lines expanded
;
7041 CORE_ADDR original_pc
= sal
.pc
;
7042 char *original_function
= NULL
;
7045 struct cleanup
*old_chain
;
7047 /* If we have explicit pc, don't expand.
7048 If we have no line number, we can't expand. */
7049 if (sal
.explicit_pc
|| sal
.line
== 0 || sal
.symtab
== NULL
)
7052 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
7053 expanded
.sals
[0] = sal
;
7059 old_chain
= save_current_space_and_thread ();
7061 switch_to_program_space_and_thread (sal
.pspace
);
7063 find_pc_partial_function (original_pc
, &original_function
, NULL
, NULL
);
7065 /* Note that expand_line_sal visits *all* program spaces. */
7066 expanded
= expand_line_sal (sal
);
7068 if (expanded
.nelts
== 1)
7070 /* We had one sal, we got one sal. Return that sal, adjusting it
7071 past the function prologue if necessary. */
7072 xfree (expanded
.sals
);
7074 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
7075 sal
.pc
= original_pc
;
7076 expanded
.sals
[0] = sal
;
7077 skip_prologue_sal (&expanded
.sals
[0]);
7078 do_cleanups (old_chain
);
7082 if (!sal
.explicit_line
)
7084 CORE_ADDR func_addr
, func_end
;
7085 for (i
= 0; i
< expanded
.nelts
; ++i
)
7087 CORE_ADDR pc
= expanded
.sals
[i
].pc
;
7088 char *this_function
;
7090 /* We need to switch threads as well since we're about to
7092 switch_to_program_space_and_thread (expanded
.sals
[i
].pspace
);
7094 if (find_pc_partial_function (pc
, &this_function
,
7095 &func_addr
, &func_end
))
7098 && strcmp (this_function
, original_function
) != 0)
7100 remove_sal (&expanded
, i
);
7107 /* Skip the function prologue if necessary. */
7108 for (i
= 0; i
< expanded
.nelts
; ++i
)
7109 skip_prologue_sal (&expanded
.sals
[i
]);
7111 do_cleanups (old_chain
);
7113 if (expanded
.nelts
<= 1)
7115 /* This is un ugly workaround. If we get zero
7116 expanded sals then something is really wrong.
7117 Fix that by returnign the original sal. */
7118 xfree (expanded
.sals
);
7120 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
7121 sal
.pc
= original_pc
;
7122 expanded
.sals
[0] = sal
;
7129 for (i
= 0; i
< expanded
.nelts
; ++i
)
7130 if (expanded
.sals
[i
].pc
== original_pc
)
7141 /* Add SALS.nelts breakpoints to the breakpoint table. For each
7142 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
7143 value. COND_STRING, if not NULL, specified the condition to be
7144 used for all breakpoints. Essentially the only case where
7145 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
7146 function. In that case, it's still not possible to specify
7147 separate conditions for different overloaded functions, so
7148 we take just a single condition string.
7150 NOTE: If the function succeeds, the caller is expected to cleanup
7151 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
7152 array contents). If the function fails (error() is called), the
7153 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
7154 COND and SALS arrays and each of those arrays contents. */
7157 create_breakpoints_sal (struct gdbarch
*gdbarch
,
7158 struct symtabs_and_lines sals
, char **addr_string
,
7160 enum bptype type
, enum bpdisp disposition
,
7161 int thread
, int task
, int ignore_count
,
7162 struct breakpoint_ops
*ops
, int from_tty
,
7167 for (i
= 0; i
< sals
.nelts
; ++i
)
7169 struct symtabs_and_lines expanded
=
7170 expand_line_sal_maybe (sals
.sals
[i
]);
7172 create_breakpoint_sal (gdbarch
, expanded
, addr_string
[i
],
7173 cond_string
, type
, disposition
,
7174 thread
, task
, ignore_count
, ops
, from_tty
, enabled
);
7178 /* Parse ARG which is assumed to be a SAL specification possibly
7179 followed by conditionals. On return, SALS contains an array of SAL
7180 addresses found. ADDR_STRING contains a vector of (canonical)
7181 address strings. ARG points to the end of the SAL. */
7184 parse_breakpoint_sals (char **address
,
7185 struct symtabs_and_lines
*sals
,
7186 char ***addr_string
,
7189 char *addr_start
= *address
;
7191 *addr_string
= NULL
;
7192 /* If no arg given, or if first arg is 'if ', use the default
7194 if ((*address
) == NULL
7195 || (strncmp ((*address
), "if", 2) == 0 && isspace ((*address
)[2])))
7197 if (default_breakpoint_valid
)
7199 struct symtab_and_line sal
;
7201 init_sal (&sal
); /* initialize to zeroes */
7202 sals
->sals
= (struct symtab_and_line
*)
7203 xmalloc (sizeof (struct symtab_and_line
));
7204 sal
.pc
= default_breakpoint_address
;
7205 sal
.line
= default_breakpoint_line
;
7206 sal
.symtab
= default_breakpoint_symtab
;
7207 sal
.pspace
= default_breakpoint_pspace
;
7208 sal
.section
= find_pc_overlay (sal
.pc
);
7210 /* "break" without arguments is equivalent to "break *PC" where PC is
7211 the default_breakpoint_address. So make sure to set
7212 sal.explicit_pc to prevent GDB from trying to expand the list of
7213 sals to include all other instances with the same symtab and line.
7215 sal
.explicit_pc
= 1;
7217 sals
->sals
[0] = sal
;
7221 error (_("No default breakpoint address now."));
7225 /* Force almost all breakpoints to be in terms of the
7226 current_source_symtab (which is decode_line_1's default). This
7227 should produce the results we want almost all of the time while
7228 leaving default_breakpoint_* alone.
7229 ObjC: However, don't match an Objective-C method name which
7230 may have a '+' or '-' succeeded by a '[' */
7232 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
7234 if (default_breakpoint_valid
7236 || ((strchr ("+-", (*address
)[0]) != NULL
)
7237 && ((*address
)[1] != '['))))
7238 *sals
= decode_line_1 (address
, 1, default_breakpoint_symtab
,
7239 default_breakpoint_line
, addr_string
,
7242 *sals
= decode_line_1 (address
, 1, (struct symtab
*) NULL
, 0,
7243 addr_string
, not_found_ptr
);
7245 /* For any SAL that didn't have a canonical string, fill one in. */
7246 if (sals
->nelts
> 0 && *addr_string
== NULL
)
7247 *addr_string
= xcalloc (sals
->nelts
, sizeof (char **));
7248 if (addr_start
!= (*address
))
7252 for (i
= 0; i
< sals
->nelts
; i
++)
7254 /* Add the string if not present. */
7255 if ((*addr_string
)[i
] == NULL
)
7256 (*addr_string
)[i
] = savestring (addr_start
,
7257 (*address
) - addr_start
);
7263 /* Convert each SAL into a real PC. Verify that the PC can be
7264 inserted as a breakpoint. If it can't throw an error. */
7267 breakpoint_sals_to_pc (struct symtabs_and_lines
*sals
)
7271 for (i
= 0; i
< sals
->nelts
; i
++)
7272 resolve_sal_pc (&sals
->sals
[i
]);
7275 /* Fast tracepoints may have restrictions on valid locations. For
7276 instance, a fast tracepoint using a jump instead of a trap will
7277 likely have to overwrite more bytes than a trap would, and so can
7278 only be placed where the instruction is longer than the jump, or a
7279 multi-instruction sequence does not have a jump into the middle of
7283 check_fast_tracepoint_sals (struct gdbarch
*gdbarch
,
7284 struct symtabs_and_lines
*sals
)
7287 struct symtab_and_line
*sal
;
7289 struct cleanup
*old_chain
;
7291 for (i
= 0; i
< sals
->nelts
; i
++)
7293 sal
= &sals
->sals
[i
];
7295 rslt
= gdbarch_fast_tracepoint_valid_at (gdbarch
, sal
->pc
,
7297 old_chain
= make_cleanup (xfree
, msg
);
7300 error (_("May not have a fast tracepoint at 0x%s%s"),
7301 paddress (gdbarch
, sal
->pc
), (msg
? msg
: ""));
7303 do_cleanups (old_chain
);
7308 do_captured_parse_breakpoint (struct ui_out
*ui
, void *data
)
7310 struct captured_parse_breakpoint_args
*args
= data
;
7312 parse_breakpoint_sals (args
->arg_p
, args
->sals_p
, args
->addr_string_p
,
7313 args
->not_found_ptr
);
7316 /* Given TOK, a string specification of condition and thread, as
7317 accepted by the 'break' command, extract the condition
7318 string and thread number and set *COND_STRING and *THREAD.
7319 PC identifies the context at which the condition should be parsed.
7320 If no condition is found, *COND_STRING is set to NULL.
7321 If no thread is found, *THREAD is set to -1. */
7323 find_condition_and_thread (char *tok
, CORE_ADDR pc
,
7324 char **cond_string
, int *thread
, int *task
)
7326 *cond_string
= NULL
;
7332 char *cond_start
= NULL
;
7333 char *cond_end
= NULL
;
7335 while (*tok
== ' ' || *tok
== '\t')
7340 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
7343 toklen
= end_tok
- tok
;
7345 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
7347 struct expression
*expr
;
7349 tok
= cond_start
= end_tok
+ 1;
7350 expr
= parse_exp_1 (&tok
, block_for_pc (pc
), 0);
7353 *cond_string
= savestring (cond_start
,
7354 cond_end
- cond_start
);
7356 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
7362 *thread
= strtol (tok
, &tok
, 0);
7364 error (_("Junk after thread keyword."));
7365 if (!valid_thread_id (*thread
))
7366 error (_("Unknown thread %d."), *thread
);
7368 else if (toklen
>= 1 && strncmp (tok
, "task", toklen
) == 0)
7374 *task
= strtol (tok
, &tok
, 0);
7376 error (_("Junk after task keyword."));
7377 if (!valid_task_id (*task
))
7378 error (_("Unknown task %d."), *task
);
7381 error (_("Junk at end of arguments."));
7385 /* Decode a static tracepoint marker spec. */
7387 static struct symtabs_and_lines
7388 decode_static_tracepoint_spec (char **arg_p
)
7390 VEC(static_tracepoint_marker_p
) *markers
= NULL
;
7391 struct symtabs_and_lines sals
;
7392 struct symtab_and_line sal
;
7394 struct cleanup
*old_chain
;
7395 char *p
= &(*arg_p
)[3];
7400 while (*p
== ' ' || *p
== '\t')
7404 while (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
7407 marker_str
= savestring (p
, endp
- p
);
7408 old_chain
= make_cleanup (xfree
, marker_str
);
7410 markers
= target_static_tracepoint_markers_by_strid (marker_str
);
7411 if (VEC_empty(static_tracepoint_marker_p
, markers
))
7412 error (_("No known static tracepoint marker named %s"), marker_str
);
7414 sals
.nelts
= VEC_length(static_tracepoint_marker_p
, markers
);
7415 sals
.sals
= xmalloc (sizeof *sals
.sals
* sals
.nelts
);
7417 for (i
= 0; i
< sals
.nelts
; i
++)
7419 struct static_tracepoint_marker
*marker
;
7421 marker
= VEC_index (static_tracepoint_marker_p
, markers
, i
);
7423 init_sal (&sals
.sals
[i
]);
7425 sals
.sals
[i
] = find_pc_line (marker
->address
, 0);
7426 sals
.sals
[i
].pc
= marker
->address
;
7428 release_static_tracepoint_marker (marker
);
7431 do_cleanups (old_chain
);
7437 /* Set a breakpoint. This function is shared between CLI and MI
7438 functions for setting a breakpoint. This function has two major
7439 modes of operations, selected by the PARSE_CONDITION_AND_THREAD
7440 parameter. If non-zero, the function will parse arg, extracting
7441 breakpoint location, address and thread. Otherwise, ARG is just the
7442 location of breakpoint, with condition and thread specified by the
7443 COND_STRING and THREAD parameters. Returns true if any breakpoint
7444 was created; false otherwise. */
7447 create_breakpoint (struct gdbarch
*gdbarch
,
7448 char *arg
, char *cond_string
, int thread
,
7449 int parse_condition_and_thread
,
7450 int tempflag
, enum bptype type_wanted
,
7452 enum auto_boolean pending_break_support
,
7453 struct breakpoint_ops
*ops
,
7457 struct gdb_exception e
;
7458 struct symtabs_and_lines sals
;
7459 struct symtab_and_line pending_sal
;
7461 char *addr_start
= arg
;
7463 struct cleanup
*old_chain
;
7464 struct cleanup
*bkpt_chain
= NULL
;
7465 struct captured_parse_breakpoint_args parse_args
;
7470 int prev_bkpt_count
= breakpoint_count
;
7476 parse_args
.arg_p
= &arg
;
7477 parse_args
.sals_p
= &sals
;
7478 parse_args
.addr_string_p
= &addr_string
;
7479 parse_args
.not_found_ptr
= ¬_found
;
7481 if (type_wanted
== bp_static_tracepoint
&& is_marker_spec (arg
))
7485 sals
= decode_static_tracepoint_spec (&arg
);
7487 copy_arg
= savestring (addr_start
, arg
- addr_start
);
7488 addr_string
= xcalloc (sals
.nelts
, sizeof (char **));
7489 for (i
= 0; i
< sals
.nelts
; i
++)
7490 addr_string
[i
] = xstrdup (copy_arg
);
7494 e
= catch_exception (uiout
, do_captured_parse_breakpoint
,
7495 &parse_args
, RETURN_MASK_ALL
);
7497 /* If caller is interested in rc value from parse, set value. */
7501 throw_exception (e
);
7505 case NOT_FOUND_ERROR
:
7507 /* If pending breakpoint support is turned off, throw
7510 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
7511 throw_exception (e
);
7513 exception_print (gdb_stderr
, e
);
7515 /* If pending breakpoint support is auto query and the user
7516 selects no, then simply return the error code. */
7517 if (pending_break_support
== AUTO_BOOLEAN_AUTO
7518 && !nquery ("Make breakpoint pending on future shared library load? "))
7521 /* At this point, either the user was queried about setting
7522 a pending breakpoint and selected yes, or pending
7523 breakpoint behavior is on and thus a pending breakpoint
7524 is defaulted on behalf of the user. */
7525 copy_arg
= xstrdup (addr_start
);
7526 addr_string
= ©_arg
;
7528 sals
.sals
= &pending_sal
;
7533 throw_exception (e
);
7542 /* Create a chain of things that always need to be cleaned up. */
7543 old_chain
= make_cleanup (null_cleanup
, 0);
7547 /* Make sure that all storage allocated to SALS gets freed. */
7548 make_cleanup (xfree
, sals
.sals
);
7550 /* Cleanup the addr_string array but not its contents. */
7551 make_cleanup (xfree
, addr_string
);
7554 /* ----------------------------- SNIP -----------------------------
7555 Anything added to the cleanup chain beyond this point is assumed
7556 to be part of a breakpoint. If the breakpoint create succeeds
7557 then the memory is not reclaimed. */
7558 bkpt_chain
= make_cleanup (null_cleanup
, 0);
7560 /* Mark the contents of the addr_string for cleanup. These go on
7561 the bkpt_chain and only occur if the breakpoint create fails. */
7562 for (i
= 0; i
< sals
.nelts
; i
++)
7564 if (addr_string
[i
] != NULL
)
7565 make_cleanup (xfree
, addr_string
[i
]);
7568 /* Resolve all line numbers to PC's and verify that the addresses
7569 are ok for the target. */
7571 breakpoint_sals_to_pc (&sals
);
7573 /* Fast tracepoints may have additional restrictions on location. */
7574 if (type_wanted
== bp_fast_tracepoint
)
7575 check_fast_tracepoint_sals (gdbarch
, &sals
);
7577 /* Verify that condition can be parsed, before setting any
7578 breakpoints. Allocate a separate condition expression for each
7582 if (parse_condition_and_thread
)
7584 /* Here we only parse 'arg' to separate condition
7585 from thread number, so parsing in context of first
7586 sal is OK. When setting the breakpoint we'll
7587 re-parse it in context of each sal. */
7590 find_condition_and_thread (arg
, sals
.sals
[0].pc
, &cond_string
,
7593 make_cleanup (xfree
, cond_string
);
7597 /* Create a private copy of condition string. */
7600 cond_string
= xstrdup (cond_string
);
7601 make_cleanup (xfree
, cond_string
);
7605 /* If the user is creating a static tracepoint by marker id
7606 (strace -m MARKER_ID), then store the sals index, so that
7607 breakpoint_re_set can try to match up which of the newly
7608 found markers corresponds to this one, and, don't try to
7609 expand multiple locations for each sal, given than SALS
7610 already should contain all sals for MARKER_ID. */
7611 if (type_wanted
== bp_static_tracepoint
7612 && is_marker_spec (addr_string
[0]))
7616 for (i
= 0; i
< sals
.nelts
; ++i
)
7618 struct symtabs_and_lines expanded
;
7619 struct breakpoint
*tp
;
7620 struct cleanup
*old_chain
;
7623 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
7624 expanded
.sals
[0] = sals
.sals
[i
];
7625 old_chain
= make_cleanup (xfree
, expanded
.sals
);
7627 create_breakpoint_sal (gdbarch
, expanded
, addr_string
[i
],
7628 cond_string
, type_wanted
,
7629 tempflag
? disp_del
: disp_donttouch
,
7630 thread
, task
, ignore_count
, ops
,
7633 do_cleanups (old_chain
);
7635 /* Get the tracepoint we just created. */
7636 tp
= get_breakpoint (breakpoint_count
);
7637 gdb_assert (tp
!= NULL
);
7639 /* Given that its possible to have multiple markers with
7640 the same string id, if the user is creating a static
7641 tracepoint by marker id ("strace -m MARKER_ID"), then
7642 store the sals index, so that breakpoint_re_set can
7643 try to match up which of the newly found markers
7644 corresponds to this one */
7645 tp
->static_trace_marker_id_idx
= i
;
7649 create_breakpoints_sal (gdbarch
, sals
, addr_string
, cond_string
,
7650 type_wanted
, tempflag
? disp_del
: disp_donttouch
,
7651 thread
, task
, ignore_count
, ops
, from_tty
,
7656 struct breakpoint
*b
;
7658 make_cleanup (xfree
, copy_arg
);
7660 b
= set_raw_breakpoint_without_location (gdbarch
, type_wanted
);
7661 set_breakpoint_count (breakpoint_count
+ 1);
7662 b
->number
= breakpoint_count
;
7664 b
->addr_string
= addr_string
[0];
7665 b
->cond_string
= NULL
;
7666 b
->ignore_count
= ignore_count
;
7667 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
7668 b
->condition_not_parsed
= 1;
7670 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
7671 b
->pspace
= current_program_space
;
7673 if (enabled
&& b
->pspace
->executing_startup
7674 && (b
->type
== bp_breakpoint
7675 || b
->type
== bp_hardware_breakpoint
))
7676 b
->enable_state
= bp_startup_disabled
;
7683 warning (_("Multiple breakpoints were set.\n"
7684 "Use the \"delete\" command to delete unwanted breakpoints."));
7685 prev_breakpoint_count
= prev_bkpt_count
;
7688 /* That's it. Discard the cleanups for data inserted into the
7690 discard_cleanups (bkpt_chain
);
7691 /* But cleanup everything else. */
7692 do_cleanups (old_chain
);
7694 /* error call may happen here - have BKPT_CHAIN already discarded. */
7695 update_global_location_list (1);
7700 /* Set a breakpoint.
7701 ARG is a string describing breakpoint address,
7702 condition, and thread.
7703 FLAG specifies if a breakpoint is hardware on,
7704 and if breakpoint is temporary, using BP_HARDWARE_FLAG
7708 break_command_1 (char *arg
, int flag
, int from_tty
)
7710 int tempflag
= flag
& BP_TEMPFLAG
;
7711 enum bptype type_wanted
= (flag
& BP_HARDWAREFLAG
7712 ? bp_hardware_breakpoint
7715 create_breakpoint (get_current_arch (),
7717 NULL
, 0, 1 /* parse arg */,
7718 tempflag
, type_wanted
,
7719 0 /* Ignore count */,
7720 pending_break_support
,
7721 NULL
/* breakpoint_ops */,
7727 /* Helper function for break_command_1 and disassemble_command. */
7730 resolve_sal_pc (struct symtab_and_line
*sal
)
7734 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
7736 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
7737 error (_("No line %d in file \"%s\"."),
7738 sal
->line
, sal
->symtab
->filename
);
7741 /* If this SAL corresponds to a breakpoint inserted using
7742 a line number, then skip the function prologue if necessary. */
7743 if (sal
->explicit_line
)
7744 skip_prologue_sal (sal
);
7747 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
7749 struct blockvector
*bv
;
7753 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
, sal
->symtab
);
7756 sym
= block_linkage_function (b
);
7759 fixup_symbol_section (sym
, sal
->symtab
->objfile
);
7760 sal
->section
= SYMBOL_OBJ_SECTION (sym
);
7764 /* It really is worthwhile to have the section, so we'll just
7765 have to look harder. This case can be executed if we have
7766 line numbers but no functions (as can happen in assembly
7769 struct minimal_symbol
*msym
;
7770 struct cleanup
*old_chain
= save_current_space_and_thread ();
7772 switch_to_program_space_and_thread (sal
->pspace
);
7774 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
7776 sal
->section
= SYMBOL_OBJ_SECTION (msym
);
7778 do_cleanups (old_chain
);
7785 break_command (char *arg
, int from_tty
)
7787 break_command_1 (arg
, 0, from_tty
);
7791 tbreak_command (char *arg
, int from_tty
)
7793 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
7797 hbreak_command (char *arg
, int from_tty
)
7799 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
7803 thbreak_command (char *arg
, int from_tty
)
7805 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
7809 stop_command (char *arg
, int from_tty
)
7811 printf_filtered (_("Specify the type of breakpoint to set.\n\
7812 Usage: stop in <function | address>\n\
7813 stop at <line>\n"));
7817 stopin_command (char *arg
, int from_tty
)
7821 if (arg
== (char *) NULL
)
7823 else if (*arg
!= '*')
7828 /* look for a ':'. If this is a line number specification, then
7829 say it is bad, otherwise, it should be an address or
7830 function/method name */
7831 while (*argptr
&& !hasColon
)
7833 hasColon
= (*argptr
== ':');
7838 badInput
= (*argptr
!= ':'); /* Not a class::method */
7840 badInput
= isdigit (*arg
); /* a simple line number */
7844 printf_filtered (_("Usage: stop in <function | address>\n"));
7846 break_command_1 (arg
, 0, from_tty
);
7850 stopat_command (char *arg
, int from_tty
)
7854 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
7861 /* look for a ':'. If there is a '::' then get out, otherwise
7862 it is probably a line number. */
7863 while (*argptr
&& !hasColon
)
7865 hasColon
= (*argptr
== ':');
7870 badInput
= (*argptr
== ':'); /* we have class::method */
7872 badInput
= !isdigit (*arg
); /* not a line number */
7876 printf_filtered (_("Usage: stop at <line>\n"));
7878 break_command_1 (arg
, 0, from_tty
);
7881 /* Return non-zero if EXP is verified as constant. Returned zero means EXP is
7882 variable. Also the constant detection may fail for some constant
7883 expressions and in such case still falsely return zero. */
7885 watchpoint_exp_is_const (const struct expression
*exp
)
7893 /* We are only interested in the descriptor of each element. */
7894 operator_length (exp
, i
, &oplenp
, &argsp
);
7897 switch (exp
->elts
[i
].opcode
)
7907 case BINOP_LOGICAL_AND
:
7908 case BINOP_LOGICAL_OR
:
7909 case BINOP_BITWISE_AND
:
7910 case BINOP_BITWISE_IOR
:
7911 case BINOP_BITWISE_XOR
:
7913 case BINOP_NOTEQUAL
:
7929 case TERNOP_SLICE_COUNT
:
7941 case OP_OBJC_NSSTRING
:
7944 case UNOP_LOGICAL_NOT
:
7945 case UNOP_COMPLEMENT
:
7948 /* Unary, binary and ternary operators: We have to check their
7949 operands. If they are constant, then so is the result of
7950 that operation. For instance, if A and B are determined to be
7951 constants, then so is "A + B".
7953 UNOP_IND is one exception to the rule above, because the value
7954 of *ADDR is not necessarily a constant, even when ADDR is. */
7958 /* Check whether the associated symbol is a constant.
7959 We use SYMBOL_CLASS rather than TYPE_CONST because it's
7960 possible that a buggy compiler could mark a variable as constant
7961 even when it is not, and TYPE_CONST would return true in this
7962 case, while SYMBOL_CLASS wouldn't.
7963 We also have to check for function symbols because they are
7966 struct symbol
*s
= exp
->elts
[i
+ 2].symbol
;
7968 if (SYMBOL_CLASS (s
) != LOC_BLOCK
7969 && SYMBOL_CLASS (s
) != LOC_CONST
7970 && SYMBOL_CLASS (s
) != LOC_CONST_BYTES
)
7975 /* The default action is to return 0 because we are using
7976 the optimistic approach here: If we don't know something,
7977 then it is not a constant. */
7986 /* accessflag: hw_write: watch write,
7987 hw_read: watch read,
7988 hw_access: watch access (read or write) */
7990 watch_command_1 (char *arg
, int accessflag
, int from_tty
, int just_location
)
7992 struct breakpoint
*b
, *scope_breakpoint
= NULL
;
7993 struct expression
*exp
;
7994 struct block
*exp_valid_block
= NULL
, *cond_exp_valid_block
= NULL
;
7995 struct value
*val
, *mark
;
7996 struct frame_info
*frame
;
7997 char *exp_start
= NULL
;
7998 char *exp_end
= NULL
;
7999 char *tok
, *id_tok_start
, *end_tok
;
8001 char *cond_start
= NULL
;
8002 char *cond_end
= NULL
;
8003 int i
, other_type_used
, target_resources_ok
= 0;
8004 enum bptype bp_type
;
8009 /* Make sure that we actually have parameters to parse. */
8010 if (arg
!= NULL
&& arg
[0] != '\0')
8012 toklen
= strlen (arg
); /* Size of argument list. */
8014 /* Points tok to the end of the argument list. */
8015 tok
= arg
+ toklen
- 1;
8017 /* Go backwards in the parameters list. Skip the last parameter.
8018 If we're expecting a 'thread <thread_num>' parameter, this should
8019 be the thread identifier. */
8020 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
8022 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
8025 /* Points end_tok to the beginning of the last token. */
8026 id_tok_start
= tok
+ 1;
8028 /* Go backwards in the parameters list. Skip one more parameter.
8029 If we're expecting a 'thread <thread_num>' parameter, we should
8030 reach a "thread" token. */
8031 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
8036 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
8039 /* Move the pointer forward to skip the whitespace and
8040 calculate the length of the token. */
8042 toklen
= end_tok
- tok
;
8044 if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
8046 /* At this point we've found a "thread" token, which means
8047 the user is trying to set a watchpoint that triggers
8048 only in a specific thread. */
8051 /* Extract the thread ID from the next token. */
8052 thread
= strtol (id_tok_start
, &endp
, 0);
8054 /* Check if the user provided a valid numeric value for the
8056 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
8057 error (_("Invalid thread ID specification %s."), id_tok_start
);
8059 /* Check if the thread actually exists. */
8060 if (!valid_thread_id (thread
))
8061 error (_("Unknown thread %d."), thread
);
8063 /* Truncate the string and get rid of the thread <thread_num>
8064 parameter before the parameter list is parsed by the
8065 evaluate_expression() function. */
8070 /* Parse the rest of the arguments. */
8071 innermost_block
= NULL
;
8073 exp
= parse_exp_1 (&arg
, 0, 0);
8075 /* Remove trailing whitespace from the expression before saving it.
8076 This makes the eventual display of the expression string a bit
8078 while (exp_end
> exp_start
&& (exp_end
[-1] == ' ' || exp_end
[-1] == '\t'))
8081 /* Checking if the expression is not constant. */
8082 if (watchpoint_exp_is_const (exp
))
8086 len
= exp_end
- exp_start
;
8087 while (len
> 0 && isspace (exp_start
[len
- 1]))
8089 error (_("Cannot watch constant value `%.*s'."), len
, exp_start
);
8092 exp_valid_block
= innermost_block
;
8093 mark
= value_mark ();
8094 fetch_subexp_value (exp
, &pc
, &val
, NULL
, NULL
);
8098 exp_valid_block
= NULL
;
8099 val
= value_addr (val
);
8100 release_value (val
);
8101 value_free_to_mark (mark
);
8103 else if (val
!= NULL
)
8104 release_value (val
);
8107 while (*tok
== ' ' || *tok
== '\t')
8111 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
8114 toklen
= end_tok
- tok
;
8115 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
8117 struct expression
*cond
;
8119 innermost_block
= NULL
;
8120 tok
= cond_start
= end_tok
+ 1;
8121 cond
= parse_exp_1 (&tok
, 0, 0);
8123 /* The watchpoint expression may not be local, but the condition
8124 may still be. E.g.: `watch global if local > 0'. */
8125 cond_exp_valid_block
= innermost_block
;
8131 error (_("Junk at end of command."));
8133 if (accessflag
== hw_read
)
8134 bp_type
= bp_read_watchpoint
;
8135 else if (accessflag
== hw_access
)
8136 bp_type
= bp_access_watchpoint
;
8138 bp_type
= bp_hardware_watchpoint
;
8140 mem_cnt
= can_use_hardware_watchpoint (val
);
8141 if (mem_cnt
== 0 && bp_type
!= bp_hardware_watchpoint
)
8142 error (_("Expression cannot be implemented with read/access watchpoint."));
8145 i
= hw_watchpoint_used_count (bp_type
, &other_type_used
);
8146 target_resources_ok
=
8147 target_can_use_hardware_watchpoint (bp_type
, i
+ mem_cnt
,
8149 if (target_resources_ok
== 0 && bp_type
!= bp_hardware_watchpoint
)
8150 error (_("Target does not support this type of hardware watchpoint."));
8152 if (target_resources_ok
< 0 && bp_type
!= bp_hardware_watchpoint
)
8153 error (_("Target can only support one kind of HW watchpoint at a time."));
8156 /* Change the type of breakpoint to an ordinary watchpoint if a hardware
8157 watchpoint could not be set. */
8158 if (!mem_cnt
|| target_resources_ok
<= 0)
8159 bp_type
= bp_watchpoint
;
8161 frame
= block_innermost_frame (exp_valid_block
);
8163 /* If the expression is "local", then set up a "watchpoint scope"
8164 breakpoint at the point where we've left the scope of the watchpoint
8165 expression. Create the scope breakpoint before the watchpoint, so
8166 that we will encounter it first in bpstat_stop_status. */
8167 if (exp_valid_block
&& frame
)
8169 if (frame_id_p (frame_unwind_caller_id (frame
)))
8172 = create_internal_breakpoint (frame_unwind_caller_arch (frame
),
8173 frame_unwind_caller_pc (frame
),
8174 bp_watchpoint_scope
);
8176 scope_breakpoint
->enable_state
= bp_enabled
;
8178 /* Automatically delete the breakpoint when it hits. */
8179 scope_breakpoint
->disposition
= disp_del
;
8181 /* Only break in the proper frame (help with recursion). */
8182 scope_breakpoint
->frame_id
= frame_unwind_caller_id (frame
);
8184 /* Set the address at which we will stop. */
8185 scope_breakpoint
->loc
->gdbarch
8186 = frame_unwind_caller_arch (frame
);
8187 scope_breakpoint
->loc
->requested_address
8188 = frame_unwind_caller_pc (frame
);
8189 scope_breakpoint
->loc
->address
8190 = adjust_breakpoint_address (scope_breakpoint
->loc
->gdbarch
,
8191 scope_breakpoint
->loc
->requested_address
,
8192 scope_breakpoint
->type
);
8196 /* Now set up the breakpoint. */
8197 b
= set_raw_breakpoint_without_location (NULL
, bp_type
);
8198 set_breakpoint_count (breakpoint_count
+ 1);
8199 b
->number
= breakpoint_count
;
8201 b
->disposition
= disp_donttouch
;
8203 b
->exp_valid_block
= exp_valid_block
;
8204 b
->cond_exp_valid_block
= cond_exp_valid_block
;
8207 struct type
*t
= value_type (val
);
8208 CORE_ADDR addr
= value_as_address (val
);
8211 t
= check_typedef (TYPE_TARGET_TYPE (check_typedef (t
)));
8212 name
= type_to_string (t
);
8214 b
->exp_string
= xstrprintf ("* (%s *) %s", name
,
8215 core_addr_to_string (addr
));
8218 /* The above expression is in C. */
8219 b
->language
= language_c
;
8222 b
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
8226 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
8232 b
->watchpoint_frame
= get_frame_id (frame
);
8233 b
->watchpoint_thread
= inferior_ptid
;
8237 b
->watchpoint_frame
= null_frame_id
;
8238 b
->watchpoint_thread
= null_ptid
;
8241 if (scope_breakpoint
!= NULL
)
8243 /* The scope breakpoint is related to the watchpoint. We will
8244 need to act on them together. */
8245 b
->related_breakpoint
= scope_breakpoint
;
8246 scope_breakpoint
->related_breakpoint
= b
;
8250 value_free_to_mark (mark
);
8252 /* Finally update the new watchpoint. This creates the locations
8253 that should be inserted. */
8254 update_watchpoint (b
, 1);
8257 update_global_location_list (1);
8260 /* Return count of locations need to be watched and can be handled
8261 in hardware. If the watchpoint can not be handled
8262 in hardware return zero. */
8265 can_use_hardware_watchpoint (struct value
*v
)
8267 int found_memory_cnt
= 0;
8268 struct value
*head
= v
;
8270 /* Did the user specifically forbid us to use hardware watchpoints? */
8271 if (!can_use_hw_watchpoints
)
8274 /* Make sure that the value of the expression depends only upon
8275 memory contents, and values computed from them within GDB. If we
8276 find any register references or function calls, we can't use a
8277 hardware watchpoint.
8279 The idea here is that evaluating an expression generates a series
8280 of values, one holding the value of every subexpression. (The
8281 expression a*b+c has five subexpressions: a, b, a*b, c, and
8282 a*b+c.) GDB's values hold almost enough information to establish
8283 the criteria given above --- they identify memory lvalues,
8284 register lvalues, computed values, etcetera. So we can evaluate
8285 the expression, and then scan the chain of values that leaves
8286 behind to decide whether we can detect any possible change to the
8287 expression's final value using only hardware watchpoints.
8289 However, I don't think that the values returned by inferior
8290 function calls are special in any way. So this function may not
8291 notice that an expression involving an inferior function call
8292 can't be watched with hardware watchpoints. FIXME. */
8293 for (; v
; v
= value_next (v
))
8295 if (VALUE_LVAL (v
) == lval_memory
)
8298 /* A lazy memory lvalue is one that GDB never needed to fetch;
8299 we either just used its address (e.g., `a' in `a.b') or
8300 we never needed it at all (e.g., `a' in `a,b'). */
8304 /* Ahh, memory we actually used! Check if we can cover
8305 it with hardware watchpoints. */
8306 struct type
*vtype
= check_typedef (value_type (v
));
8308 /* We only watch structs and arrays if user asked for it
8309 explicitly, never if they just happen to appear in a
8310 middle of some value chain. */
8312 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
8313 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
8315 CORE_ADDR vaddr
= value_address (v
);
8316 int len
= TYPE_LENGTH (value_type (v
));
8318 if (!target_region_ok_for_hw_watchpoint (vaddr
, len
))
8325 else if (VALUE_LVAL (v
) != not_lval
8326 && deprecated_value_modifiable (v
) == 0)
8327 return 0; /* These are values from the history (e.g., $1). */
8328 else if (VALUE_LVAL (v
) == lval_register
)
8329 return 0; /* Cannot watch a register with a HW watchpoint. */
8332 /* The expression itself looks suitable for using a hardware
8333 watchpoint, but give the target machine a chance to reject it. */
8334 return found_memory_cnt
;
8338 watch_command_wrapper (char *arg
, int from_tty
)
8340 watch_command_1 (arg
, hw_write
, from_tty
, 0);
8343 /* A helper function that looks for an argument at the start of a
8344 string. The argument must also either be at the end of the string,
8345 or be followed by whitespace. Returns 1 if it finds the argument,
8346 0 otherwise. If the argument is found, it updates *STR. */
8349 check_for_argument (char **str
, char *arg
, int arg_len
)
8351 if (strncmp (*str
, arg
, arg_len
) == 0
8352 && ((*str
)[arg_len
] == '\0' || isspace ((*str
)[arg_len
])))
8360 /* A helper function that looks for the "-location" argument and then
8361 calls watch_command_1. */
8364 watch_maybe_just_location (char *arg
, int accessflag
, int from_tty
)
8366 int just_location
= 0;
8369 && (check_for_argument (&arg
, "-location", sizeof ("-location") - 1)
8370 || check_for_argument (&arg
, "-l", sizeof ("-l") - 1)))
8372 ep_skip_leading_whitespace (&arg
);
8376 watch_command_1 (arg
, accessflag
, from_tty
, just_location
);
8380 watch_command (char *arg
, int from_tty
)
8382 watch_maybe_just_location (arg
, hw_write
, from_tty
);
8386 rwatch_command_wrapper (char *arg
, int from_tty
)
8388 watch_command_1 (arg
, hw_read
, from_tty
, 0);
8392 rwatch_command (char *arg
, int from_tty
)
8394 watch_maybe_just_location (arg
, hw_read
, from_tty
);
8398 awatch_command_wrapper (char *arg
, int from_tty
)
8400 watch_command_1 (arg
, hw_access
, from_tty
, 0);
8404 awatch_command (char *arg
, int from_tty
)
8406 watch_maybe_just_location (arg
, hw_access
, from_tty
);
8410 /* Helper routines for the until_command routine in infcmd.c. Here
8411 because it uses the mechanisms of breakpoints. */
8413 struct until_break_command_continuation_args
8415 struct breakpoint
*breakpoint
;
8416 struct breakpoint
*breakpoint2
;
8419 /* This function is called by fetch_inferior_event via the
8420 cmd_continuation pointer, to complete the until command. It takes
8421 care of cleaning up the temporary breakpoints set up by the until
8424 until_break_command_continuation (void *arg
)
8426 struct until_break_command_continuation_args
*a
= arg
;
8428 delete_breakpoint (a
->breakpoint
);
8430 delete_breakpoint (a
->breakpoint2
);
8434 until_break_command (char *arg
, int from_tty
, int anywhere
)
8436 struct symtabs_and_lines sals
;
8437 struct symtab_and_line sal
;
8438 struct frame_info
*frame
= get_selected_frame (NULL
);
8439 struct breakpoint
*breakpoint
;
8440 struct breakpoint
*breakpoint2
= NULL
;
8441 struct cleanup
*old_chain
;
8443 clear_proceed_status ();
8445 /* Set a breakpoint where the user wants it and at return from
8448 if (default_breakpoint_valid
)
8449 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
8450 default_breakpoint_line
, (char ***) NULL
, NULL
);
8452 sals
= decode_line_1 (&arg
, 1, (struct symtab
*) NULL
,
8453 0, (char ***) NULL
, NULL
);
8455 if (sals
.nelts
!= 1)
8456 error (_("Couldn't get information on specified line."));
8459 xfree (sals
.sals
); /* malloc'd, so freed */
8462 error (_("Junk at end of arguments."));
8464 resolve_sal_pc (&sal
);
8467 /* If the user told us to continue until a specified location,
8468 we don't specify a frame at which we need to stop. */
8469 breakpoint
= set_momentary_breakpoint (get_frame_arch (frame
), sal
,
8470 null_frame_id
, bp_until
);
8472 /* Otherwise, specify the selected frame, because we want to stop only
8473 at the very same frame. */
8474 breakpoint
= set_momentary_breakpoint (get_frame_arch (frame
), sal
,
8475 get_stack_frame_id (frame
),
8478 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
8480 /* Keep within the current frame, or in frames called by the current
8483 if (frame_id_p (frame_unwind_caller_id (frame
)))
8485 sal
= find_pc_line (frame_unwind_caller_pc (frame
), 0);
8486 sal
.pc
= frame_unwind_caller_pc (frame
);
8487 breakpoint2
= set_momentary_breakpoint (frame_unwind_caller_arch (frame
),
8489 frame_unwind_caller_id (frame
),
8491 make_cleanup_delete_breakpoint (breakpoint2
);
8494 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
8496 /* If we are running asynchronously, and proceed call above has actually
8497 managed to start the target, arrange for breakpoints to be
8498 deleted when the target stops. Otherwise, we're already stopped and
8499 delete breakpoints via cleanup chain. */
8501 if (target_can_async_p () && is_running (inferior_ptid
))
8503 struct until_break_command_continuation_args
*args
;
8504 args
= xmalloc (sizeof (*args
));
8506 args
->breakpoint
= breakpoint
;
8507 args
->breakpoint2
= breakpoint2
;
8509 discard_cleanups (old_chain
);
8510 add_continuation (inferior_thread (),
8511 until_break_command_continuation
, args
,
8515 do_cleanups (old_chain
);
8519 ep_skip_leading_whitespace (char **s
)
8521 if ((s
== NULL
) || (*s
== NULL
))
8523 while (isspace (**s
))
8527 /* This function attempts to parse an optional "if <cond>" clause
8528 from the arg string. If one is not found, it returns NULL.
8530 Else, it returns a pointer to the condition string. (It does not
8531 attempt to evaluate the string against a particular block.) And,
8532 it updates arg to point to the first character following the parsed
8533 if clause in the arg string. */
8536 ep_parse_optional_if_clause (char **arg
)
8540 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
8543 /* Skip the "if" keyword. */
8546 /* Skip any extra leading whitespace, and record the start of the
8547 condition string. */
8548 ep_skip_leading_whitespace (arg
);
8551 /* Assume that the condition occupies the remainder of the arg string. */
8552 (*arg
) += strlen (cond_string
);
8557 /* Commands to deal with catching events, such as signals, exceptions,
8558 process start/exit, etc. */
8562 catch_fork_temporary
, catch_vfork_temporary
,
8563 catch_fork_permanent
, catch_vfork_permanent
8568 catch_fork_command_1 (char *arg
, int from_tty
,
8569 struct cmd_list_element
*command
)
8571 struct gdbarch
*gdbarch
= get_current_arch ();
8572 char *cond_string
= NULL
;
8573 catch_fork_kind fork_kind
;
8576 fork_kind
= (catch_fork_kind
) (uintptr_t) get_cmd_context (command
);
8577 tempflag
= (fork_kind
== catch_fork_temporary
8578 || fork_kind
== catch_vfork_temporary
);
8582 ep_skip_leading_whitespace (&arg
);
8584 /* The allowed syntax is:
8586 catch [v]fork if <cond>
8588 First, check if there's an if clause. */
8589 cond_string
= ep_parse_optional_if_clause (&arg
);
8591 if ((*arg
!= '\0') && !isspace (*arg
))
8592 error (_("Junk at end of arguments."));
8594 /* If this target supports it, create a fork or vfork catchpoint
8595 and enable reporting of such events. */
8598 case catch_fork_temporary
:
8599 case catch_fork_permanent
:
8600 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
8601 &catch_fork_breakpoint_ops
);
8603 case catch_vfork_temporary
:
8604 case catch_vfork_permanent
:
8605 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
8606 &catch_vfork_breakpoint_ops
);
8609 error (_("unsupported or unknown fork kind; cannot catch it"));
8615 catch_exec_command_1 (char *arg
, int from_tty
,
8616 struct cmd_list_element
*command
)
8618 struct gdbarch
*gdbarch
= get_current_arch ();
8620 char *cond_string
= NULL
;
8622 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
8626 ep_skip_leading_whitespace (&arg
);
8628 /* The allowed syntax is:
8630 catch exec if <cond>
8632 First, check if there's an if clause. */
8633 cond_string
= ep_parse_optional_if_clause (&arg
);
8635 if ((*arg
!= '\0') && !isspace (*arg
))
8636 error (_("Junk at end of arguments."));
8638 /* If this target supports it, create an exec catchpoint
8639 and enable reporting of such events. */
8640 create_catchpoint (gdbarch
, tempflag
, cond_string
,
8641 &catch_exec_breakpoint_ops
);
8644 static enum print_stop_action
8645 print_exception_catchpoint (struct breakpoint
*b
)
8647 int bp_temp
, bp_throw
;
8649 annotate_catchpoint (b
->number
);
8651 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
8652 if (b
->loc
->address
!= b
->loc
->requested_address
)
8653 breakpoint_adjustment_warning (b
->loc
->requested_address
,
8656 bp_temp
= b
->disposition
== disp_del
;
8658 bp_temp
? "Temporary catchpoint "
8660 if (!ui_out_is_mi_like_p (uiout
))
8661 ui_out_field_int (uiout
, "bkptno", b
->number
);
8663 bp_throw
? " (exception thrown), "
8664 : " (exception caught), ");
8665 if (ui_out_is_mi_like_p (uiout
))
8667 ui_out_field_string (uiout
, "reason",
8668 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
8669 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
8670 ui_out_field_int (uiout
, "bkptno", b
->number
);
8672 return PRINT_SRC_AND_LOC
;
8676 print_one_exception_catchpoint (struct breakpoint
*b
,
8677 struct bp_location
**last_loc
)
8679 struct value_print_options opts
;
8681 get_user_print_options (&opts
);
8682 if (opts
.addressprint
)
8685 if (b
->loc
== NULL
|| b
->loc
->shlib_disabled
)
8686 ui_out_field_string (uiout
, "addr", "<PENDING>");
8688 ui_out_field_core_addr (uiout
, "addr",
8689 b
->loc
->gdbarch
, b
->loc
->address
);
8694 if (strstr (b
->addr_string
, "throw") != NULL
)
8695 ui_out_field_string (uiout
, "what", "exception throw");
8697 ui_out_field_string (uiout
, "what", "exception catch");
8701 print_mention_exception_catchpoint (struct breakpoint
*b
)
8706 bp_temp
= b
->disposition
== disp_del
;
8707 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
8708 ui_out_text (uiout
, bp_temp
? _("Temporary catchpoint ")
8709 : _("Catchpoint "));
8710 ui_out_field_int (uiout
, "bkptno", b
->number
);
8711 ui_out_text (uiout
, bp_throw
? _(" (throw)")
8715 /* Implement the "print_recreate" breakpoint_ops method for throw and
8716 catch catchpoints. */
8719 print_recreate_exception_catchpoint (struct breakpoint
*b
, struct ui_file
*fp
)
8724 bp_temp
= b
->disposition
== disp_del
;
8725 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
8726 fprintf_unfiltered (fp
, bp_temp
? "tcatch " : "catch ");
8727 fprintf_unfiltered (fp
, bp_throw
? "throw" : "catch");
8730 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops
= {
8733 NULL
, /* breakpoint_hit */
8734 print_exception_catchpoint
,
8735 print_one_exception_catchpoint
,
8736 print_mention_exception_catchpoint
,
8737 print_recreate_exception_catchpoint
8741 handle_gnu_v3_exceptions (int tempflag
, char *cond_string
,
8742 enum exception_event_kind ex_event
, int from_tty
)
8744 char *trigger_func_name
;
8746 if (ex_event
== EX_EVENT_CATCH
)
8747 trigger_func_name
= "__cxa_begin_catch";
8749 trigger_func_name
= "__cxa_throw";
8751 create_breakpoint (get_current_arch (),
8752 trigger_func_name
, cond_string
, -1,
8753 0 /* condition and thread are valid. */,
8754 tempflag
, bp_breakpoint
,
8756 AUTO_BOOLEAN_TRUE
/* pending */,
8757 &gnu_v3_exception_catchpoint_ops
, from_tty
,
8763 /* Deal with "catch catch" and "catch throw" commands */
8766 catch_exception_command_1 (enum exception_event_kind ex_event
, char *arg
,
8767 int tempflag
, int from_tty
)
8769 char *cond_string
= NULL
;
8773 ep_skip_leading_whitespace (&arg
);
8775 cond_string
= ep_parse_optional_if_clause (&arg
);
8777 if ((*arg
!= '\0') && !isspace (*arg
))
8778 error (_("Junk at end of arguments."));
8780 if (ex_event
!= EX_EVENT_THROW
8781 && ex_event
!= EX_EVENT_CATCH
)
8782 error (_("Unsupported or unknown exception event; cannot catch it"));
8784 if (handle_gnu_v3_exceptions (tempflag
, cond_string
, ex_event
, from_tty
))
8787 warning (_("Unsupported with this platform/compiler combination."));
8790 /* Implementation of "catch catch" command. */
8793 catch_catch_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
8795 int tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
8797 catch_exception_command_1 (EX_EVENT_CATCH
, arg
, tempflag
, from_tty
);
8800 /* Implementation of "catch throw" command. */
8803 catch_throw_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
8805 int tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
8807 catch_exception_command_1 (EX_EVENT_THROW
, arg
, tempflag
, from_tty
);
8810 /* Create a breakpoint struct for Ada exception catchpoints. */
8813 create_ada_exception_breakpoint (struct gdbarch
*gdbarch
,
8814 struct symtab_and_line sal
,
8818 struct expression
*cond
,
8819 struct breakpoint_ops
*ops
,
8823 struct breakpoint
*b
;
8827 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
8829 loc_gdbarch
= gdbarch
;
8831 describe_other_breakpoints (loc_gdbarch
,
8832 sal
.pspace
, sal
.pc
, sal
.section
, -1);
8833 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
8834 version for exception catchpoints, because two catchpoints
8835 used for different exception names will use the same address.
8836 In this case, a "breakpoint ... also set at..." warning is
8837 unproductive. Besides. the warning phrasing is also a bit
8838 inapropriate, we should use the word catchpoint, and tell
8839 the user what type of catchpoint it is. The above is good
8840 enough for now, though. */
8843 b
= set_raw_breakpoint (gdbarch
, sal
, bp_breakpoint
);
8844 set_breakpoint_count (breakpoint_count
+ 1);
8846 b
->enable_state
= bp_enabled
;
8847 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
8848 b
->number
= breakpoint_count
;
8849 b
->ignore_count
= 0;
8850 b
->loc
->cond
= cond
;
8851 b
->addr_string
= addr_string
;
8852 b
->language
= language_ada
;
8853 b
->cond_string
= cond_string
;
8854 b
->exp_string
= exp_string
;
8859 update_global_location_list (1);
8862 /* Implement the "catch exception" command. */
8865 catch_ada_exception_command (char *arg
, int from_tty
,
8866 struct cmd_list_element
*command
)
8868 struct gdbarch
*gdbarch
= get_current_arch ();
8870 struct symtab_and_line sal
;
8871 char *addr_string
= NULL
;
8872 char *exp_string
= NULL
;
8873 char *cond_string
= NULL
;
8874 struct expression
*cond
= NULL
;
8875 struct breakpoint_ops
*ops
= NULL
;
8877 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
8881 sal
= ada_decode_exception_location (arg
, &addr_string
, &exp_string
,
8882 &cond_string
, &cond
, &ops
);
8883 create_ada_exception_breakpoint (gdbarch
, sal
, addr_string
, exp_string
,
8884 cond_string
, cond
, ops
, tempflag
,
8888 /* Cleanup function for a syscall filter list. */
8890 clean_up_filters (void *arg
)
8892 VEC(int) *iter
= *(VEC(int) **) arg
;
8893 VEC_free (int, iter
);
8896 /* Splits the argument using space as delimiter. Returns an xmalloc'd
8897 filter list, or NULL if no filtering is required. */
8899 catch_syscall_split_args (char *arg
)
8901 VEC(int) *result
= NULL
;
8902 struct cleanup
*cleanup
= make_cleanup (clean_up_filters
, &result
);
8904 while (*arg
!= '\0')
8906 int i
, syscall_number
;
8911 /* Skip whitespace. */
8912 while (isspace (*arg
))
8915 for (i
= 0; i
< 127 && arg
[i
] && !isspace (arg
[i
]); ++i
)
8916 cur_name
[i
] = arg
[i
];
8920 /* Check if the user provided a syscall name or a number. */
8921 syscall_number
= (int) strtol (cur_name
, &endptr
, 0);
8922 if (*endptr
== '\0')
8923 get_syscall_by_number (syscall_number
, &s
);
8926 /* We have a name. Let's check if it's valid and convert it
8928 get_syscall_by_name (cur_name
, &s
);
8930 if (s
.number
== UNKNOWN_SYSCALL
)
8931 /* Here we have to issue an error instead of a warning, because
8932 GDB cannot do anything useful if there's no syscall number to
8934 error (_("Unknown syscall name '%s'."), cur_name
);
8937 /* Ok, it's valid. */
8938 VEC_safe_push (int, result
, s
.number
);
8941 discard_cleanups (cleanup
);
8945 /* Implement the "catch syscall" command. */
8948 catch_syscall_command_1 (char *arg
, int from_tty
,
8949 struct cmd_list_element
*command
)
8954 struct gdbarch
*gdbarch
= get_current_arch ();
8956 /* Checking if the feature if supported. */
8957 if (gdbarch_get_syscall_number_p (gdbarch
) == 0)
8958 error (_("The feature 'catch syscall' is not supported on \
8959 this architeture yet."));
8961 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
8963 ep_skip_leading_whitespace (&arg
);
8965 /* We need to do this first "dummy" translation in order
8966 to get the syscall XML file loaded or, most important,
8967 to display a warning to the user if there's no XML file
8968 for his/her architecture. */
8969 get_syscall_by_number (0, &s
);
8971 /* The allowed syntax is:
8973 catch syscall <name | number> [<name | number> ... <name | number>]
8975 Let's check if there's a syscall name. */
8978 filter
= catch_syscall_split_args (arg
);
8982 create_syscall_event_catchpoint (tempflag
, filter
,
8983 &catch_syscall_breakpoint_ops
);
8986 /* Implement the "catch assert" command. */
8989 catch_assert_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
8991 struct gdbarch
*gdbarch
= get_current_arch ();
8993 struct symtab_and_line sal
;
8994 char *addr_string
= NULL
;
8995 struct breakpoint_ops
*ops
= NULL
;
8997 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
9001 sal
= ada_decode_assert_location (arg
, &addr_string
, &ops
);
9002 create_ada_exception_breakpoint (gdbarch
, sal
, addr_string
, NULL
, NULL
, NULL
,
9003 ops
, tempflag
, from_tty
);
9007 catch_command (char *arg
, int from_tty
)
9009 error (_("Catch requires an event name."));
9014 tcatch_command (char *arg
, int from_tty
)
9016 error (_("Catch requires an event name."));
9019 /* Delete breakpoints by address or line. */
9022 clear_command (char *arg
, int from_tty
)
9024 struct breakpoint
*b
;
9025 VEC(breakpoint_p
) *found
= 0;
9028 struct symtabs_and_lines sals
;
9029 struct symtab_and_line sal
;
9034 sals
= decode_line_spec (arg
, 1);
9039 sals
.sals
= (struct symtab_and_line
*)
9040 xmalloc (sizeof (struct symtab_and_line
));
9041 make_cleanup (xfree
, sals
.sals
);
9042 init_sal (&sal
); /* initialize to zeroes */
9043 sal
.line
= default_breakpoint_line
;
9044 sal
.symtab
= default_breakpoint_symtab
;
9045 sal
.pc
= default_breakpoint_address
;
9046 sal
.pspace
= default_breakpoint_pspace
;
9047 if (sal
.symtab
== 0)
9048 error (_("No source file specified."));
9056 /* We don't call resolve_sal_pc here. That's not
9057 as bad as it seems, because all existing breakpoints
9058 typically have both file/line and pc set. So, if
9059 clear is given file/line, we can match this to existing
9060 breakpoint without obtaining pc at all.
9062 We only support clearing given the address explicitly
9063 present in breakpoint table. Say, we've set breakpoint
9064 at file:line. There were several PC values for that file:line,
9065 due to optimization, all in one block.
9066 We've picked one PC value. If "clear" is issued with another
9067 PC corresponding to the same file:line, the breakpoint won't
9068 be cleared. We probably can still clear the breakpoint, but
9069 since the other PC value is never presented to user, user
9070 can only find it by guessing, and it does not seem important
9073 /* For each line spec given, delete bps which correspond
9074 to it. Do it in two passes, solely to preserve the current
9075 behavior that from_tty is forced true if we delete more than
9079 for (i
= 0; i
< sals
.nelts
; i
++)
9081 /* If exact pc given, clear bpts at that pc.
9082 If line given (pc == 0), clear all bpts on specified line.
9083 If defaulting, clear all bpts on default line
9086 defaulting sal.pc != 0 tests to do
9091 1 0 <can't happen> */
9095 /* Find all matching breakpoints and add them to
9100 /* Are we going to delete b? */
9101 if (b
->type
!= bp_none
&& !is_watchpoint (b
))
9103 struct bp_location
*loc
= b
->loc
;
9104 for (; loc
; loc
= loc
->next
)
9106 int pc_match
= sal
.pc
9107 && (loc
->pspace
== sal
.pspace
)
9108 && (loc
->address
== sal
.pc
)
9109 && (!section_is_overlay (loc
->section
)
9110 || loc
->section
== sal
.section
);
9111 int line_match
= ((default_match
|| (0 == sal
.pc
))
9112 && b
->source_file
!= NULL
9113 && sal
.symtab
!= NULL
9114 && sal
.pspace
== loc
->pspace
9115 && strcmp (b
->source_file
, sal
.symtab
->filename
) == 0
9116 && b
->line_number
== sal
.line
);
9117 if (pc_match
|| line_match
)
9126 VEC_safe_push(breakpoint_p
, found
, b
);
9129 /* Now go thru the 'found' chain and delete them. */
9130 if (VEC_empty(breakpoint_p
, found
))
9133 error (_("No breakpoint at %s."), arg
);
9135 error (_("No breakpoint at this line."));
9138 if (VEC_length(breakpoint_p
, found
) > 1)
9139 from_tty
= 1; /* Always report if deleted more than one */
9142 if (VEC_length(breakpoint_p
, found
) == 1)
9143 printf_unfiltered (_("Deleted breakpoint "));
9145 printf_unfiltered (_("Deleted breakpoints "));
9147 breakpoints_changed ();
9149 for (ix
= 0; VEC_iterate(breakpoint_p
, found
, ix
, b
); ix
++)
9152 printf_unfiltered ("%d ", b
->number
);
9153 delete_breakpoint (b
);
9156 putchar_unfiltered ('\n');
9159 /* Delete breakpoint in BS if they are `delete' breakpoints and
9160 all breakpoints that are marked for deletion, whether hit or not.
9161 This is called after any breakpoint is hit, or after errors. */
9164 breakpoint_auto_delete (bpstat bs
)
9166 struct breakpoint
*b
, *temp
;
9168 for (; bs
; bs
= bs
->next
)
9169 if (bs
->breakpoint_at
9170 && bs
->breakpoint_at
->owner
9171 && bs
->breakpoint_at
->owner
->disposition
== disp_del
9173 delete_breakpoint (bs
->breakpoint_at
->owner
);
9175 ALL_BREAKPOINTS_SAFE (b
, temp
)
9177 if (b
->disposition
== disp_del_at_next_stop
)
9178 delete_breakpoint (b
);
9182 /* A comparison function for bp_location AP and BP being interfaced to qsort.
9183 Sort elements primarily by their ADDRESS (no matter what does
9184 breakpoint_address_is_meaningful say for its OWNER), secondarily by ordering
9185 first bp_permanent OWNERed elements and terciarily just ensuring the array
9186 is sorted stable way despite qsort being an instable algorithm. */
9189 bp_location_compare (const void *ap
, const void *bp
)
9191 struct bp_location
*a
= *(void **) ap
;
9192 struct bp_location
*b
= *(void **) bp
;
9193 /* A and B come from existing breakpoints having non-NULL OWNER. */
9194 int a_perm
= a
->owner
->enable_state
== bp_permanent
;
9195 int b_perm
= b
->owner
->enable_state
== bp_permanent
;
9197 if (a
->address
!= b
->address
)
9198 return (a
->address
> b
->address
) - (a
->address
< b
->address
);
9200 /* Sort permanent breakpoints first. */
9201 if (a_perm
!= b_perm
)
9202 return (a_perm
< b_perm
) - (a_perm
> b_perm
);
9204 /* Make the user-visible order stable across GDB runs. Locations of the same
9205 breakpoint can be sorted in arbitrary order. */
9207 if (a
->owner
->number
!= b
->owner
->number
)
9208 return (a
->owner
->number
> b
->owner
->number
)
9209 - (a
->owner
->number
< b
->owner
->number
);
9211 return (a
> b
) - (a
< b
);
9214 /* Set bp_location_placed_address_before_address_max and
9215 bp_location_shadow_len_after_address_max according to the current content of
9216 the bp_location array. */
9219 bp_location_target_extensions_update (void)
9221 struct bp_location
*bl
, **blp_tmp
;
9223 bp_location_placed_address_before_address_max
= 0;
9224 bp_location_shadow_len_after_address_max
= 0;
9226 ALL_BP_LOCATIONS (bl
, blp_tmp
)
9228 CORE_ADDR start
, end
, addr
;
9230 if (!bp_location_has_shadow (bl
))
9233 start
= bl
->target_info
.placed_address
;
9234 end
= start
+ bl
->target_info
.shadow_len
;
9236 gdb_assert (bl
->address
>= start
);
9237 addr
= bl
->address
- start
;
9238 if (addr
> bp_location_placed_address_before_address_max
)
9239 bp_location_placed_address_before_address_max
= addr
;
9241 /* Zero SHADOW_LEN would not pass bp_location_has_shadow. */
9243 gdb_assert (bl
->address
< end
);
9244 addr
= end
- bl
->address
;
9245 if (addr
> bp_location_shadow_len_after_address_max
)
9246 bp_location_shadow_len_after_address_max
= addr
;
9250 /* If SHOULD_INSERT is false, do not insert any breakpoint locations
9251 into the inferior, only remove already-inserted locations that no
9252 longer should be inserted. Functions that delete a breakpoint or
9253 breakpoints should pass false, so that deleting a breakpoint
9254 doesn't have the side effect of inserting the locations of other
9255 breakpoints that are marked not-inserted, but should_be_inserted
9256 returns true on them.
9258 This behaviour is useful is situations close to tear-down -- e.g.,
9259 after an exec, while the target still has execution, but breakpoint
9260 shadows of the previous executable image should *NOT* be restored
9261 to the new image; or before detaching, where the target still has
9262 execution and wants to delete breakpoints from GDB's lists, and all
9263 breakpoints had already been removed from the inferior. */
9266 update_global_location_list (int should_insert
)
9268 struct breakpoint
*b
;
9269 struct bp_location
**locp
, *loc
;
9270 struct cleanup
*cleanups
;
9272 /* Used in the duplicates detection below. When iterating over all
9273 bp_locations, points to the first bp_location of a given address.
9274 Breakpoints and watchpoints of different types are never
9275 duplicates of each other. Keep one pointer for each type of
9276 breakpoint/watchpoint, so we only need to loop over all locations
9278 struct bp_location
*bp_loc_first
; /* breakpoint */
9279 struct bp_location
*wp_loc_first
; /* hardware watchpoint */
9280 struct bp_location
*awp_loc_first
; /* access watchpoint */
9281 struct bp_location
*rwp_loc_first
; /* read watchpoint */
9283 /* Saved former bp_location array which we compare against the newly built
9284 bp_location from the current state of ALL_BREAKPOINTS. */
9285 struct bp_location
**old_location
, **old_locp
;
9286 unsigned old_location_count
;
9288 old_location
= bp_location
;
9289 old_location_count
= bp_location_count
;
9291 bp_location_count
= 0;
9292 cleanups
= make_cleanup (xfree
, old_location
);
9295 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
9296 bp_location_count
++;
9298 bp_location
= xmalloc (sizeof (*bp_location
) * bp_location_count
);
9301 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
9303 qsort (bp_location
, bp_location_count
, sizeof (*bp_location
),
9304 bp_location_compare
);
9306 bp_location_target_extensions_update ();
9308 /* Identify bp_location instances that are no longer present in the new
9309 list, and therefore should be freed. Note that it's not necessary that
9310 those locations should be removed from inferior -- if there's another
9311 location at the same address (previously marked as duplicate),
9312 we don't need to remove/insert the location.
9314 LOCP is kept in sync with OLD_LOCP, each pointing to the current and
9315 former bp_location array state respectively. */
9318 for (old_locp
= old_location
; old_locp
< old_location
+ old_location_count
;
9321 struct bp_location
*old_loc
= *old_locp
;
9322 struct bp_location
**loc2p
;
9324 /* Tells if 'old_loc' is found amoung the new locations. If not, we
9326 int found_object
= 0;
9327 /* Tells if the location should remain inserted in the target. */
9328 int keep_in_target
= 0;
9331 /* Skip LOCP entries which will definitely never be needed. Stop either
9332 at or being the one matching OLD_LOC. */
9333 while (locp
< bp_location
+ bp_location_count
9334 && (*locp
)->address
< old_loc
->address
)
9338 (loc2p
< bp_location
+ bp_location_count
9339 && (*loc2p
)->address
== old_loc
->address
);
9342 if (*loc2p
== old_loc
)
9349 /* If this location is no longer present, and inserted, look if there's
9350 maybe a new location at the same address. If so, mark that one
9351 inserted, and don't remove this one. This is needed so that we
9352 don't have a time window where a breakpoint at certain location is not
9355 if (old_loc
->inserted
)
9357 /* If the location is inserted now, we might have to remove it. */
9359 if (found_object
&& should_be_inserted (old_loc
))
9361 /* The location is still present in the location list, and still
9362 should be inserted. Don't do anything. */
9367 /* The location is either no longer present, or got disabled.
9368 See if there's another location at the same address, in which
9369 case we don't need to remove this one from the target. */
9371 /* OLD_LOC comes from existing struct breakpoint. */
9372 if (breakpoint_address_is_meaningful (old_loc
->owner
))
9375 (loc2p
< bp_location
+ bp_location_count
9376 && (*loc2p
)->address
== old_loc
->address
);
9379 struct bp_location
*loc2
= *loc2p
;
9381 if (breakpoint_locations_match (loc2
, old_loc
))
9383 /* For the sake of should_be_inserted.
9384 Duplicates check below will fix up this later. */
9385 loc2
->duplicate
= 0;
9387 /* Read watchpoint locations are switched to
9388 access watchpoints, if the former are not
9389 supported, but the latter are. */
9390 if (is_hardware_watchpoint (old_loc
->owner
))
9392 gdb_assert (is_hardware_watchpoint (loc2
->owner
));
9393 loc2
->watchpoint_type
= old_loc
->watchpoint_type
;
9396 if (loc2
!= old_loc
&& should_be_inserted (loc2
))
9399 loc2
->target_info
= old_loc
->target_info
;
9408 if (!keep_in_target
)
9410 if (remove_breakpoint (old_loc
, mark_uninserted
))
9412 /* This is just about all we can do. We could keep this
9413 location on the global list, and try to remove it next
9414 time, but there's no particular reason why we will
9417 Note that at this point, old_loc->owner is still valid,
9418 as delete_breakpoint frees the breakpoint only
9419 after calling us. */
9420 printf_filtered (_("warning: Error removing breakpoint %d\n"),
9421 old_loc
->owner
->number
);
9429 if (removed
&& non_stop
9430 && breakpoint_address_is_meaningful (old_loc
->owner
)
9431 && !is_hardware_watchpoint (old_loc
->owner
))
9433 /* This location was removed from the target. In
9434 non-stop mode, a race condition is possible where
9435 we've removed a breakpoint, but stop events for that
9436 breakpoint are already queued and will arrive later.
9437 We apply an heuristic to be able to distinguish such
9438 SIGTRAPs from other random SIGTRAPs: we keep this
9439 breakpoint location for a bit, and will retire it
9440 after we see some number of events. The theory here
9441 is that reporting of events should, "on the average",
9442 be fair, so after a while we'll see events from all
9443 threads that have anything of interest, and no longer
9444 need to keep this breakpoint location around. We
9445 don't hold locations forever so to reduce chances of
9446 mistaking a non-breakpoint SIGTRAP for a breakpoint
9449 The heuristic failing can be disastrous on
9450 decr_pc_after_break targets.
9452 On decr_pc_after_break targets, like e.g., x86-linux,
9453 if we fail to recognize a late breakpoint SIGTRAP,
9454 because events_till_retirement has reached 0 too
9455 soon, we'll fail to do the PC adjustment, and report
9456 a random SIGTRAP to the user. When the user resumes
9457 the inferior, it will most likely immediately crash
9458 with SIGILL/SIGBUS/SIGSEGV, or worse, get silently
9459 corrupted, because of being resumed e.g., in the
9460 middle of a multi-byte instruction, or skipped a
9461 one-byte instruction. This was actually seen happen
9462 on native x86-linux, and should be less rare on
9463 targets that do not support new thread events, like
9464 remote, due to the heuristic depending on
9467 Mistaking a random SIGTRAP for a breakpoint trap
9468 causes similar symptoms (PC adjustment applied when
9469 it shouldn't), but then again, playing with SIGTRAPs
9470 behind the debugger's back is asking for trouble.
9472 Since hardware watchpoint traps are always
9473 distinguishable from other traps, so we don't need to
9474 apply keep hardware watchpoint moribund locations
9475 around. We simply always ignore hardware watchpoint
9476 traps we can no longer explain. */
9478 old_loc
->events_till_retirement
= 3 * (thread_count () + 1);
9479 old_loc
->owner
= NULL
;
9481 VEC_safe_push (bp_location_p
, moribund_locations
, old_loc
);
9484 free_bp_location (old_loc
);
9488 /* Rescan breakpoints at the same address and section, marking the
9489 first one as "first" and any others as "duplicates". This is so
9490 that the bpt instruction is only inserted once. If we have a
9491 permanent breakpoint at the same place as BPT, make that one the
9492 official one, and the rest as duplicates. Permanent breakpoints
9493 are sorted first for the same address.
9495 Do the same for hardware watchpoints, but also considering the
9496 watchpoint's type (regular/access/read) and length. */
9498 bp_loc_first
= NULL
;
9499 wp_loc_first
= NULL
;
9500 awp_loc_first
= NULL
;
9501 rwp_loc_first
= NULL
;
9502 ALL_BP_LOCATIONS (loc
, locp
)
9504 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
9505 struct breakpoint
*b
= loc
->owner
;
9506 struct bp_location
**loc_first_p
;
9508 if (b
->enable_state
== bp_disabled
9509 || b
->enable_state
== bp_call_disabled
9510 || b
->enable_state
== bp_startup_disabled
9512 || loc
->shlib_disabled
9513 || !breakpoint_address_is_meaningful (b
)
9514 || is_tracepoint (b
))
9517 /* Permanent breakpoint should always be inserted. */
9518 if (b
->enable_state
== bp_permanent
&& ! loc
->inserted
)
9519 internal_error (__FILE__
, __LINE__
,
9520 _("allegedly permanent breakpoint is not "
9521 "actually inserted"));
9523 if (b
->type
== bp_hardware_watchpoint
)
9524 loc_first_p
= &wp_loc_first
;
9525 else if (b
->type
== bp_read_watchpoint
)
9526 loc_first_p
= &rwp_loc_first
;
9527 else if (b
->type
== bp_access_watchpoint
)
9528 loc_first_p
= &awp_loc_first
;
9530 loc_first_p
= &bp_loc_first
;
9532 if (*loc_first_p
== NULL
9533 || (overlay_debugging
&& loc
->section
!= (*loc_first_p
)->section
)
9534 || !breakpoint_locations_match (loc
, *loc_first_p
))
9543 if ((*loc_first_p
)->owner
->enable_state
== bp_permanent
&& loc
->inserted
9544 && b
->enable_state
!= bp_permanent
)
9545 internal_error (__FILE__
, __LINE__
,
9546 _("another breakpoint was inserted on top of "
9547 "a permanent breakpoint"));
9550 if (breakpoints_always_inserted_mode () && should_insert
9551 && (have_live_inferiors ()
9552 || (gdbarch_has_global_breakpoints (target_gdbarch
))))
9553 insert_breakpoint_locations ();
9555 do_cleanups (cleanups
);
9559 breakpoint_retire_moribund (void)
9561 struct bp_location
*loc
;
9564 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
9565 if (--(loc
->events_till_retirement
) == 0)
9567 free_bp_location (loc
);
9568 VEC_unordered_remove (bp_location_p
, moribund_locations
, ix
);
9574 update_global_location_list_nothrow (int inserting
)
9576 struct gdb_exception e
;
9578 TRY_CATCH (e
, RETURN_MASK_ERROR
)
9579 update_global_location_list (inserting
);
9582 /* Clear LOC from a BPS. */
9584 bpstat_remove_bp_location (bpstat bps
, struct bp_location
*loc
)
9588 for (bs
= bps
; bs
; bs
= bs
->next
)
9589 if (bs
->breakpoint_at
== loc
)
9591 bs
->breakpoint_at
= NULL
;
9593 /* bs->commands will be freed later. */
9597 /* Callback for iterate_over_threads. */
9599 bpstat_remove_bp_location_callback (struct thread_info
*th
, void *data
)
9601 struct bp_location
*loc
= data
;
9603 bpstat_remove_bp_location (th
->stop_bpstat
, loc
);
9607 /* Delete a breakpoint and clean up all traces of it in the data
9611 delete_breakpoint (struct breakpoint
*bpt
)
9613 struct breakpoint
*b
;
9615 gdb_assert (bpt
!= NULL
);
9617 /* Has this bp already been deleted? This can happen because multiple
9618 lists can hold pointers to bp's. bpstat lists are especial culprits.
9620 One example of this happening is a watchpoint's scope bp. When the
9621 scope bp triggers, we notice that the watchpoint is out of scope, and
9622 delete it. We also delete its scope bp. But the scope bp is marked
9623 "auto-deleting", and is already on a bpstat. That bpstat is then
9624 checked for auto-deleting bp's, which are deleted.
9626 A real solution to this problem might involve reference counts in bp's,
9627 and/or giving them pointers back to their referencing bpstat's, and
9628 teaching delete_breakpoint to only free a bp's storage when no more
9629 references were extent. A cheaper bandaid was chosen. */
9630 if (bpt
->type
== bp_none
)
9633 /* At least avoid this stale reference until the reference counting of
9634 breakpoints gets resolved. */
9635 if (bpt
->related_breakpoint
!= NULL
)
9637 gdb_assert (bpt
->related_breakpoint
->related_breakpoint
== bpt
);
9638 bpt
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
9639 bpt
->related_breakpoint
->related_breakpoint
= NULL
;
9640 bpt
->related_breakpoint
= NULL
;
9643 observer_notify_breakpoint_deleted (bpt
->number
);
9645 if (breakpoint_chain
== bpt
)
9646 breakpoint_chain
= bpt
->next
;
9651 b
->next
= bpt
->next
;
9655 decref_counted_command_line (&bpt
->commands
);
9656 xfree (bpt
->cond_string
);
9657 xfree (bpt
->cond_exp
);
9658 xfree (bpt
->addr_string
);
9660 xfree (bpt
->exp_string
);
9661 value_free (bpt
->val
);
9662 xfree (bpt
->source_file
);
9663 xfree (bpt
->exec_pathname
);
9664 clean_up_filters (&bpt
->syscalls_to_be_caught
);
9666 /* Now that breakpoint is removed from breakpoint
9667 list, update the global location list. This
9668 will remove locations that used to belong to
9669 this breakpoint. Do this before freeing
9670 the breakpoint itself, since remove_breakpoint
9671 looks at location's owner. It might be better
9672 design to have location completely self-contained,
9673 but it's not the case now. */
9674 update_global_location_list (0);
9677 /* On the chance that someone will soon try again to delete this same
9678 bp, we mark it as deleted before freeing its storage. */
9679 bpt
->type
= bp_none
;
9685 do_delete_breakpoint_cleanup (void *b
)
9687 delete_breakpoint (b
);
9691 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
9693 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
9696 /* A callback for map_breakpoint_numbers that calls
9697 delete_breakpoint. */
9700 do_delete_breakpoint (struct breakpoint
*b
, void *ignore
)
9702 delete_breakpoint (b
);
9706 delete_command (char *arg
, int from_tty
)
9708 struct breakpoint
*b
, *temp
;
9714 int breaks_to_delete
= 0;
9716 /* Delete all breakpoints if no argument.
9717 Do not delete internal or call-dummy breakpoints, these
9718 have to be deleted with an explicit breakpoint number argument. */
9721 if (b
->type
!= bp_call_dummy
9722 && b
->type
!= bp_std_terminate
9723 && b
->type
!= bp_shlib_event
9724 && b
->type
!= bp_jit_event
9725 && b
->type
!= bp_thread_event
9726 && b
->type
!= bp_overlay_event
9727 && b
->type
!= bp_longjmp_master
9728 && b
->type
!= bp_std_terminate_master
9731 breaks_to_delete
= 1;
9736 /* Ask user only if there are some breakpoints to delete. */
9738 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
9740 ALL_BREAKPOINTS_SAFE (b
, temp
)
9742 if (b
->type
!= bp_call_dummy
9743 && b
->type
!= bp_std_terminate
9744 && b
->type
!= bp_shlib_event
9745 && b
->type
!= bp_thread_event
9746 && b
->type
!= bp_jit_event
9747 && b
->type
!= bp_overlay_event
9748 && b
->type
!= bp_longjmp_master
9749 && b
->type
!= bp_std_terminate_master
9751 delete_breakpoint (b
);
9756 map_breakpoint_numbers (arg
, do_delete_breakpoint
, NULL
);
9760 all_locations_are_pending (struct bp_location
*loc
)
9762 for (; loc
; loc
= loc
->next
)
9763 if (!loc
->shlib_disabled
)
9768 /* Subroutine of update_breakpoint_locations to simplify it.
9769 Return non-zero if multiple fns in list LOC have the same name.
9770 Null names are ignored. */
9773 ambiguous_names_p (struct bp_location
*loc
)
9775 struct bp_location
*l
;
9776 htab_t htab
= htab_create_alloc (13, htab_hash_string
,
9777 (int (*) (const void *,
9778 const void *)) streq
,
9779 NULL
, xcalloc
, xfree
);
9781 for (l
= loc
; l
!= NULL
; l
= l
->next
)
9784 const char *name
= l
->function_name
;
9786 /* Allow for some names to be NULL, ignore them. */
9790 slot
= (const char **) htab_find_slot (htab
, (const void *) name
,
9792 /* NOTE: We can assume slot != NULL here because xcalloc never returns
9806 /* When symbols change, it probably means the sources changed as well,
9807 and it might mean the static tracepoint markers are no longer at
9808 the same address or line numbers they used to be at last we
9809 checked. Losing your static tracepoints whenever you rebuild is
9810 undesirable. This function tries to resync/rematch gdb static
9811 tracepoints with the markers on the target, for static tracepoints
9812 that have not been set by marker id. Static tracepoint that have
9813 been set by marker id are reset by marker id in breakpoint_re_set.
9816 1) For a tracepoint set at a specific address, look for a marker at
9817 the old PC. If one is found there, assume to be the same marker.
9818 If the name / string id of the marker found is different from the
9819 previous known name, assume that means the user renamed the marker
9820 in the sources, and output a warning.
9822 2) For a tracepoint set at a given line number, look for a marker
9823 at the new address of the old line number. If one is found there,
9824 assume to be the same marker. If the name / string id of the
9825 marker found is different from the previous known name, assume that
9826 means the user renamed the marker in the sources, and output a
9829 3) If a marker is no longer found at the same address or line, it
9830 may mean the marker no longer exists. But it may also just mean
9831 the code changed a bit. Maybe the user added a few lines of code
9832 that made the marker move up or down (in line number terms). Ask
9833 the target for info about the marker with the string id as we knew
9834 it. If found, update line number and address in the matching
9835 static tracepoint. This will get confused if there's more than one
9836 marker with the same ID (possible in UST, although unadvised
9837 precisely because it confuses tools). */
9839 static struct symtab_and_line
9840 update_static_tracepoint (struct breakpoint
*b
, struct symtab_and_line sal
)
9842 struct static_tracepoint_marker marker
;
9848 find_line_pc (sal
.symtab
, sal
.line
, &pc
);
9850 if (target_static_tracepoint_marker_at (pc
, &marker
))
9852 if (strcmp (b
->static_trace_marker_id
, marker
.str_id
) != 0)
9853 warning (_("static tracepoint %d changed probed marker from %s to %s"),
9855 b
->static_trace_marker_id
, marker
.str_id
);
9857 xfree (b
->static_trace_marker_id
);
9858 b
->static_trace_marker_id
= xstrdup (marker
.str_id
);
9859 release_static_tracepoint_marker (&marker
);
9864 /* Old marker wasn't found on target at lineno. Try looking it up
9866 if (!sal
.explicit_pc
9868 && sal
.symtab
!= NULL
9869 && b
->static_trace_marker_id
!= NULL
)
9871 VEC(static_tracepoint_marker_p
) *markers
;
9874 = target_static_tracepoint_markers_by_strid (b
->static_trace_marker_id
);
9876 if (!VEC_empty(static_tracepoint_marker_p
, markers
))
9878 struct symtab_and_line sal
;
9880 struct static_tracepoint_marker
*marker
;
9882 marker
= VEC_index (static_tracepoint_marker_p
, markers
, 0);
9884 xfree (b
->static_trace_marker_id
);
9885 b
->static_trace_marker_id
= xstrdup (marker
->str_id
);
9887 warning (_("marker for static tracepoint %d (%s) not "
9888 "found at previous line number"),
9889 b
->number
, b
->static_trace_marker_id
);
9893 sal
.pc
= marker
->address
;
9895 sal
= find_pc_line (marker
->address
, 0);
9896 sym
= find_pc_sect_function (marker
->address
, NULL
);
9897 ui_out_text (uiout
, "Now in ");
9900 ui_out_field_string (uiout
, "func",
9901 SYMBOL_PRINT_NAME (sym
));
9902 ui_out_text (uiout
, " at ");
9904 ui_out_field_string (uiout
, "file", sal
.symtab
->filename
);
9905 ui_out_text (uiout
, ":");
9907 if (ui_out_is_mi_like_p (uiout
))
9909 char *fullname
= symtab_to_fullname (sal
.symtab
);
9912 ui_out_field_string (uiout
, "fullname", fullname
);
9915 ui_out_field_int (uiout
, "line", sal
.line
);
9916 ui_out_text (uiout
, "\n");
9918 b
->line_number
= sal
.line
;
9920 xfree (b
->source_file
);
9922 b
->source_file
= xstrdup (sal
.symtab
->filename
);
9924 b
->source_file
= NULL
;
9926 xfree (b
->addr_string
);
9927 b
->addr_string
= xstrprintf ("%s:%d",
9928 sal
.symtab
->filename
, b
->line_number
);
9930 /* Might be nice to check if function changed, and warn if
9933 release_static_tracepoint_marker (marker
);
9940 update_breakpoint_locations (struct breakpoint
*b
,
9941 struct symtabs_and_lines sals
)
9945 struct bp_location
*existing_locations
= b
->loc
;
9947 /* If there's no new locations, and all existing locations
9948 are pending, don't do anything. This optimizes
9949 the common case where all locations are in the same
9950 shared library, that was unloaded. We'd like to
9951 retain the location, so that when the library
9952 is loaded again, we don't loose the enabled/disabled
9953 status of the individual locations. */
9954 if (all_locations_are_pending (existing_locations
) && sals
.nelts
== 0)
9959 for (i
= 0; i
< sals
.nelts
; ++i
)
9961 struct bp_location
*new_loc
=
9962 add_location_to_breakpoint (b
, &(sals
.sals
[i
]));
9964 /* Reparse conditions, they might contain references to the
9966 if (b
->cond_string
!= NULL
)
9968 struct gdb_exception e
;
9971 TRY_CATCH (e
, RETURN_MASK_ERROR
)
9973 new_loc
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
),
9978 warning (_("failed to reevaluate condition for breakpoint %d: %s"),
9979 b
->number
, e
.message
);
9980 new_loc
->enabled
= 0;
9984 if (b
->source_file
!= NULL
)
9985 xfree (b
->source_file
);
9986 if (sals
.sals
[i
].symtab
== NULL
)
9987 b
->source_file
= NULL
;
9989 b
->source_file
= xstrdup (sals
.sals
[i
].symtab
->filename
);
9991 if (b
->line_number
== 0)
9992 b
->line_number
= sals
.sals
[i
].line
;
9995 /* Update locations of permanent breakpoints. */
9996 if (b
->enable_state
== bp_permanent
)
9997 make_breakpoint_permanent (b
);
9999 /* If possible, carry over 'disable' status from existing breakpoints. */
10001 struct bp_location
*e
= existing_locations
;
10002 /* If there are multiple breakpoints with the same function name,
10003 e.g. for inline functions, comparing function names won't work.
10004 Instead compare pc addresses; this is just a heuristic as things
10005 may have moved, but in practice it gives the correct answer
10006 often enough until a better solution is found. */
10007 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
10009 for (; e
; e
= e
->next
)
10011 if (!e
->enabled
&& e
->function_name
)
10013 struct bp_location
*l
= b
->loc
;
10014 if (have_ambiguous_names
)
10016 for (; l
; l
= l
->next
)
10017 if (breakpoint_address_match (e
->pspace
->aspace
, e
->address
,
10018 l
->pspace
->aspace
, l
->address
))
10026 for (; l
; l
= l
->next
)
10027 if (l
->function_name
10028 && strcmp (e
->function_name
, l
->function_name
) == 0)
10038 update_global_location_list (1);
10041 /* Reset a breakpoint given it's struct breakpoint * BINT.
10042 The value we return ends up being the return value from catch_errors.
10043 Unused in this case. */
10046 breakpoint_re_set_one (void *bint
)
10048 /* get past catch_errs */
10049 struct breakpoint
*b
= (struct breakpoint
*) bint
;
10051 int *not_found_ptr
= ¬_found
;
10052 struct symtabs_and_lines sals
= {0};
10053 struct symtabs_and_lines expanded
= {0};
10055 struct gdb_exception e
;
10056 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
10057 int marker_spec
= 0;
10062 warning (_("attempted to reset apparently deleted breakpoint #%d?"),
10065 case bp_breakpoint
:
10066 case bp_hardware_breakpoint
:
10067 case bp_tracepoint
:
10068 case bp_fast_tracepoint
:
10069 case bp_static_tracepoint
:
10070 /* Do not attempt to re-set breakpoints disabled during startup. */
10071 if (b
->enable_state
== bp_startup_disabled
)
10074 if (b
->addr_string
== NULL
)
10076 /* Anything without a string can't be re-set. */
10077 delete_breakpoint (b
);
10081 input_radix
= b
->input_radix
;
10082 s
= b
->addr_string
;
10084 save_current_space_and_thread ();
10085 switch_to_program_space_and_thread (b
->pspace
);
10087 marker_spec
= b
->type
== bp_static_tracepoint
&& is_marker_spec (s
);
10089 set_language (b
->language
);
10090 TRY_CATCH (e
, RETURN_MASK_ERROR
)
10094 sals
= decode_static_tracepoint_spec (&s
);
10095 if (sals
.nelts
> b
->static_trace_marker_id_idx
)
10097 sals
.sals
[0] = sals
.sals
[b
->static_trace_marker_id_idx
];
10101 error (_("marker %s not found"), b
->static_trace_marker_id
);
10104 sals
= decode_line_1 (&s
, 1, (struct symtab
*) NULL
, 0, (char ***) NULL
,
10109 int not_found_and_ok
= 0;
10110 /* For pending breakpoints, it's expected that parsing
10111 will fail until the right shared library is loaded.
10112 User has already told to create pending breakpoints and
10113 don't need extra messages. If breakpoint is in bp_shlib_disabled
10114 state, then user already saw the message about that breakpoint
10115 being disabled, and don't want to see more errors. */
10117 && (b
->condition_not_parsed
10118 || (b
->loc
&& b
->loc
->shlib_disabled
)
10119 || b
->enable_state
== bp_disabled
))
10120 not_found_and_ok
= 1;
10122 if (!not_found_and_ok
)
10124 /* We surely don't want to warn about the same breakpoint
10125 10 times. One solution, implemented here, is disable
10126 the breakpoint on error. Another solution would be to
10127 have separate 'warning emitted' flag. Since this
10128 happens only when a binary has changed, I don't know
10129 which approach is better. */
10130 b
->enable_state
= bp_disabled
;
10131 throw_exception (e
);
10137 gdb_assert (sals
.nelts
== 1);
10139 resolve_sal_pc (&sals
.sals
[0]);
10140 if (b
->condition_not_parsed
&& s
&& s
[0])
10142 char *cond_string
= 0;
10146 find_condition_and_thread (s
, sals
.sals
[0].pc
,
10147 &cond_string
, &thread
, &task
);
10149 b
->cond_string
= cond_string
;
10150 b
->thread
= thread
;
10152 b
->condition_not_parsed
= 0;
10155 if (b
->type
== bp_static_tracepoint
&& !marker_spec
)
10156 sals
.sals
[0] = update_static_tracepoint (b
, sals
.sals
[0]);
10158 expanded
= expand_line_sal_maybe (sals
.sals
[0]);
10161 make_cleanup (xfree
, sals
.sals
);
10162 update_breakpoint_locations (b
, expanded
);
10165 case bp_watchpoint
:
10166 case bp_hardware_watchpoint
:
10167 case bp_read_watchpoint
:
10168 case bp_access_watchpoint
:
10169 /* Watchpoint can be either on expression using entirely global variables,
10170 or it can be on local variables.
10172 Watchpoints of the first kind are never auto-deleted, and even persist
10173 across program restarts. Since they can use variables from shared
10174 libraries, we need to reparse expression as libraries are loaded
10177 Watchpoints on local variables can also change meaning as result
10178 of solib event. For example, if a watchpoint uses both a local and
10179 a global variables in expression, it's a local watchpoint, but
10180 unloading of a shared library will make the expression invalid.
10181 This is not a very common use case, but we still re-evaluate
10182 expression, to avoid surprises to the user.
10184 Note that for local watchpoints, we re-evaluate it only if
10185 watchpoints frame id is still valid. If it's not, it means
10186 the watchpoint is out of scope and will be deleted soon. In fact,
10187 I'm not sure we'll ever be called in this case.
10189 If a local watchpoint's frame id is still valid, then
10190 b->exp_valid_block is likewise valid, and we can safely use it.
10192 Don't do anything about disabled watchpoints, since they will
10193 be reevaluated again when enabled. */
10194 update_watchpoint (b
, 1 /* reparse */);
10196 /* We needn't really do anything to reset these, since the mask
10197 that requests them is unaffected by e.g., new libraries being
10199 case bp_catchpoint
:
10203 printf_filtered (_("Deleting unknown breakpoint type %d\n"), b
->type
);
10205 /* Delete overlay event and longjmp master breakpoints; they will be
10206 reset later by breakpoint_re_set. */
10207 case bp_overlay_event
:
10208 case bp_longjmp_master
:
10209 case bp_std_terminate_master
:
10210 delete_breakpoint (b
);
10213 /* This breakpoint is special, it's set up when the inferior
10214 starts and we really don't want to touch it. */
10215 case bp_shlib_event
:
10217 /* Like bp_shlib_event, this breakpoint type is special.
10218 Once it is set up, we do not want to touch it. */
10219 case bp_thread_event
:
10221 /* Keep temporary breakpoints, which can be encountered when we step
10222 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
10223 Otherwise these should have been blown away via the cleanup chain
10224 or by breakpoint_init_inferior when we rerun the executable. */
10227 case bp_watchpoint_scope
:
10228 case bp_call_dummy
:
10229 case bp_std_terminate
:
10230 case bp_step_resume
:
10232 case bp_longjmp_resume
:
10237 do_cleanups (cleanups
);
10241 /* Re-set all breakpoints after symbols have been re-loaded. */
10243 breakpoint_re_set (void)
10245 struct breakpoint
*b
, *temp
;
10246 enum language save_language
;
10247 int save_input_radix
;
10248 struct cleanup
*old_chain
;
10250 save_language
= current_language
->la_language
;
10251 save_input_radix
= input_radix
;
10252 old_chain
= save_current_program_space ();
10254 ALL_BREAKPOINTS_SAFE (b
, temp
)
10256 /* Format possible error msg */
10257 char *message
= xstrprintf ("Error in re-setting breakpoint %d: ",
10259 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
10260 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
10261 do_cleanups (cleanups
);
10263 set_language (save_language
);
10264 input_radix
= save_input_radix
;
10266 jit_breakpoint_re_set ();
10268 do_cleanups (old_chain
);
10270 create_overlay_event_breakpoint ("_ovly_debug_event");
10271 create_longjmp_master_breakpoint ("longjmp");
10272 create_longjmp_master_breakpoint ("_longjmp");
10273 create_longjmp_master_breakpoint ("siglongjmp");
10274 create_longjmp_master_breakpoint ("_siglongjmp");
10275 create_std_terminate_master_breakpoint ("std::terminate()");
10278 /* Reset the thread number of this breakpoint:
10280 - If the breakpoint is for all threads, leave it as-is.
10281 - Else, reset it to the current thread for inferior_ptid. */
10283 breakpoint_re_set_thread (struct breakpoint
*b
)
10285 if (b
->thread
!= -1)
10287 if (in_thread_list (inferior_ptid
))
10288 b
->thread
= pid_to_thread_id (inferior_ptid
);
10290 /* We're being called after following a fork. The new fork is
10291 selected as current, and unless this was a vfork will have a
10292 different program space from the original thread. Reset that
10294 b
->loc
->pspace
= current_program_space
;
10298 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
10299 If from_tty is nonzero, it prints a message to that effect,
10300 which ends with a period (no newline). */
10303 set_ignore_count (int bptnum
, int count
, int from_tty
)
10305 struct breakpoint
*b
;
10310 ALL_BREAKPOINTS (b
)
10311 if (b
->number
== bptnum
)
10313 if (is_tracepoint (b
))
10315 if (from_tty
&& count
!= 0)
10316 printf_filtered (_("Ignore count ignored for tracepoint %d."),
10321 b
->ignore_count
= count
;
10325 printf_filtered (_("Will stop next time breakpoint %d is reached."),
10327 else if (count
== 1)
10328 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
10331 printf_filtered (_("Will ignore next %d crossings of breakpoint %d."),
10334 breakpoints_changed ();
10335 observer_notify_breakpoint_modified (b
->number
);
10339 error (_("No breakpoint number %d."), bptnum
);
10343 make_breakpoint_silent (struct breakpoint
*b
)
10345 /* Silence the breakpoint. */
10349 /* Command to set ignore-count of breakpoint N to COUNT. */
10352 ignore_command (char *args
, int from_tty
)
10358 error_no_arg (_("a breakpoint number"));
10360 num
= get_number (&p
);
10362 error (_("bad breakpoint number: '%s'"), args
);
10364 error (_("Second argument (specified ignore-count) is missing."));
10366 set_ignore_count (num
,
10367 longest_to_int (value_as_long (parse_and_eval (p
))),
10370 printf_filtered ("\n");
10373 /* Call FUNCTION on each of the breakpoints
10374 whose numbers are given in ARGS. */
10377 map_breakpoint_numbers (char *args
, void (*function
) (struct breakpoint
*,
10384 struct breakpoint
*b
, *tmp
;
10388 error_no_arg (_("one or more breakpoint numbers"));
10395 num
= get_number_or_range (&p1
);
10398 warning (_("bad breakpoint number at or near '%s'"), p
);
10402 ALL_BREAKPOINTS_SAFE (b
, tmp
)
10403 if (b
->number
== num
)
10405 struct breakpoint
*related_breakpoint
= b
->related_breakpoint
;
10407 function (b
, data
);
10408 if (related_breakpoint
)
10409 function (related_breakpoint
, data
);
10413 printf_unfiltered (_("No breakpoint number %d.\n"), num
);
10419 static struct bp_location
*
10420 find_location_by_number (char *number
)
10422 char *dot
= strchr (number
, '.');
10426 struct breakpoint
*b
;
10427 struct bp_location
*loc
;
10432 bp_num
= get_number_or_range (&p1
);
10434 error (_("Bad breakpoint number '%s'"), number
);
10436 ALL_BREAKPOINTS (b
)
10437 if (b
->number
== bp_num
)
10442 if (!b
|| b
->number
!= bp_num
)
10443 error (_("Bad breakpoint number '%s'"), number
);
10446 loc_num
= get_number_or_range (&p1
);
10448 error (_("Bad breakpoint location number '%s'"), number
);
10452 for (;loc_num
&& loc
; --loc_num
, loc
= loc
->next
)
10455 error (_("Bad breakpoint location number '%s'"), dot
+1);
10461 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
10462 If from_tty is nonzero, it prints a message to that effect,
10463 which ends with a period (no newline). */
10466 disable_breakpoint (struct breakpoint
*bpt
)
10468 /* Never disable a watchpoint scope breakpoint; we want to
10469 hit them when we leave scope so we can delete both the
10470 watchpoint and its scope breakpoint at that time. */
10471 if (bpt
->type
== bp_watchpoint_scope
)
10474 /* You can't disable permanent breakpoints. */
10475 if (bpt
->enable_state
== bp_permanent
)
10478 bpt
->enable_state
= bp_disabled
;
10480 update_global_location_list (0);
10482 observer_notify_breakpoint_modified (bpt
->number
);
10485 /* A callback for map_breakpoint_numbers that calls
10486 disable_breakpoint. */
10489 do_map_disable_breakpoint (struct breakpoint
*b
, void *ignore
)
10491 disable_breakpoint (b
);
10495 disable_command (char *args
, int from_tty
)
10497 struct breakpoint
*bpt
;
10500 ALL_BREAKPOINTS (bpt
)
10504 warning (_("attempted to disable apparently deleted breakpoint #%d?"),
10507 case bp_breakpoint
:
10508 case bp_tracepoint
:
10509 case bp_fast_tracepoint
:
10510 case bp_static_tracepoint
:
10511 case bp_catchpoint
:
10512 case bp_hardware_breakpoint
:
10513 case bp_watchpoint
:
10514 case bp_hardware_watchpoint
:
10515 case bp_read_watchpoint
:
10516 case bp_access_watchpoint
:
10517 disable_breakpoint (bpt
);
10521 else if (strchr (args
, '.'))
10523 struct bp_location
*loc
= find_location_by_number (args
);
10526 update_global_location_list (0);
10529 map_breakpoint_numbers (args
, do_map_disable_breakpoint
, NULL
);
10533 do_enable_breakpoint (struct breakpoint
*bpt
, enum bpdisp disposition
)
10535 int target_resources_ok
;
10537 if (bpt
->type
== bp_hardware_breakpoint
)
10540 i
= hw_breakpoint_used_count ();
10541 target_resources_ok
=
10542 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
10544 if (target_resources_ok
== 0)
10545 error (_("No hardware breakpoint support in the target."));
10546 else if (target_resources_ok
< 0)
10547 error (_("Hardware breakpoints used exceeds limit."));
10550 if (is_watchpoint (bpt
))
10552 struct gdb_exception e
;
10554 TRY_CATCH (e
, RETURN_MASK_ALL
)
10556 update_watchpoint (bpt
, 1 /* reparse */);
10560 exception_fprintf (gdb_stderr
, e
, _("Cannot enable watchpoint %d: "),
10566 if (bpt
->enable_state
!= bp_permanent
)
10567 bpt
->enable_state
= bp_enabled
;
10568 bpt
->disposition
= disposition
;
10569 update_global_location_list (1);
10570 breakpoints_changed ();
10572 observer_notify_breakpoint_modified (bpt
->number
);
10577 enable_breakpoint (struct breakpoint
*bpt
)
10579 do_enable_breakpoint (bpt
, bpt
->disposition
);
10582 /* A callback for map_breakpoint_numbers that calls
10583 enable_breakpoint. */
10586 do_map_enable_breakpoint (struct breakpoint
*b
, void *ignore
)
10588 enable_breakpoint (b
);
10591 /* The enable command enables the specified breakpoints (or all defined
10592 breakpoints) so they once again become (or continue to be) effective
10593 in stopping the inferior. */
10596 enable_command (char *args
, int from_tty
)
10598 struct breakpoint
*bpt
;
10601 ALL_BREAKPOINTS (bpt
)
10605 warning (_("attempted to enable apparently deleted breakpoint #%d?"),
10608 case bp_breakpoint
:
10609 case bp_tracepoint
:
10610 case bp_fast_tracepoint
:
10611 case bp_static_tracepoint
:
10612 case bp_catchpoint
:
10613 case bp_hardware_breakpoint
:
10614 case bp_watchpoint
:
10615 case bp_hardware_watchpoint
:
10616 case bp_read_watchpoint
:
10617 case bp_access_watchpoint
:
10618 enable_breakpoint (bpt
);
10622 else if (strchr (args
, '.'))
10624 struct bp_location
*loc
= find_location_by_number (args
);
10627 update_global_location_list (1);
10630 map_breakpoint_numbers (args
, do_map_enable_breakpoint
, NULL
);
10634 enable_once_breakpoint (struct breakpoint
*bpt
, void *ignore
)
10636 do_enable_breakpoint (bpt
, disp_disable
);
10640 enable_once_command (char *args
, int from_tty
)
10642 map_breakpoint_numbers (args
, enable_once_breakpoint
, NULL
);
10646 enable_delete_breakpoint (struct breakpoint
*bpt
, void *ignore
)
10648 do_enable_breakpoint (bpt
, disp_del
);
10652 enable_delete_command (char *args
, int from_tty
)
10654 map_breakpoint_numbers (args
, enable_delete_breakpoint
, NULL
);
10658 set_breakpoint_cmd (char *args
, int from_tty
)
10663 show_breakpoint_cmd (char *args
, int from_tty
)
10667 /* Invalidate last known value of any hardware watchpoint if
10668 the memory which that value represents has been written to by
10672 invalidate_bp_value_on_memory_change (CORE_ADDR addr
, int len
,
10673 const bfd_byte
*data
)
10675 struct breakpoint
*bp
;
10677 ALL_BREAKPOINTS (bp
)
10678 if (bp
->enable_state
== bp_enabled
10679 && bp
->type
== bp_hardware_watchpoint
10680 && bp
->val_valid
&& bp
->val
)
10682 struct bp_location
*loc
;
10684 for (loc
= bp
->loc
; loc
!= NULL
; loc
= loc
->next
)
10685 if (loc
->loc_type
== bp_loc_hardware_watchpoint
10686 && loc
->address
+ loc
->length
> addr
10687 && addr
+ len
> loc
->address
)
10689 value_free (bp
->val
);
10696 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
10698 struct symtabs_and_lines
10699 decode_line_spec_1 (char *string
, int funfirstline
)
10701 struct symtabs_and_lines sals
;
10704 error (_("Empty line specification."));
10705 if (default_breakpoint_valid
)
10706 sals
= decode_line_1 (&string
, funfirstline
,
10707 default_breakpoint_symtab
,
10708 default_breakpoint_line
,
10709 (char ***) NULL
, NULL
);
10711 sals
= decode_line_1 (&string
, funfirstline
,
10712 (struct symtab
*) NULL
, 0, (char ***) NULL
, NULL
);
10714 error (_("Junk at end of line specification: %s"), string
);
10718 /* Create and insert a raw software breakpoint at PC. Return an
10719 identifier, which should be used to remove the breakpoint later.
10720 In general, places which call this should be using something on the
10721 breakpoint chain instead; this function should be eliminated
10725 deprecated_insert_raw_breakpoint (struct gdbarch
*gdbarch
,
10726 struct address_space
*aspace
, CORE_ADDR pc
)
10728 struct bp_target_info
*bp_tgt
;
10730 bp_tgt
= XZALLOC (struct bp_target_info
);
10732 bp_tgt
->placed_address_space
= aspace
;
10733 bp_tgt
->placed_address
= pc
;
10735 if (target_insert_breakpoint (gdbarch
, bp_tgt
) != 0)
10737 /* Could not insert the breakpoint. */
10745 /* Remove a breakpoint BP inserted by deprecated_insert_raw_breakpoint. */
10748 deprecated_remove_raw_breakpoint (struct gdbarch
*gdbarch
, void *bp
)
10750 struct bp_target_info
*bp_tgt
= bp
;
10753 ret
= target_remove_breakpoint (gdbarch
, bp_tgt
);
10759 /* One (or perhaps two) breakpoints used for software single stepping. */
10761 static void *single_step_breakpoints
[2];
10762 static struct gdbarch
*single_step_gdbarch
[2];
10764 /* Create and insert a breakpoint for software single step. */
10767 insert_single_step_breakpoint (struct gdbarch
*gdbarch
,
10768 struct address_space
*aspace
, CORE_ADDR next_pc
)
10772 if (single_step_breakpoints
[0] == NULL
)
10774 bpt_p
= &single_step_breakpoints
[0];
10775 single_step_gdbarch
[0] = gdbarch
;
10779 gdb_assert (single_step_breakpoints
[1] == NULL
);
10780 bpt_p
= &single_step_breakpoints
[1];
10781 single_step_gdbarch
[1] = gdbarch
;
10784 /* NOTE drow/2006-04-11: A future improvement to this function would be
10785 to only create the breakpoints once, and actually put them on the
10786 breakpoint chain. That would let us use set_raw_breakpoint. We could
10787 adjust the addresses each time they were needed. Doing this requires
10788 corresponding changes elsewhere where single step breakpoints are
10789 handled, however. So, for now, we use this. */
10791 *bpt_p
= deprecated_insert_raw_breakpoint (gdbarch
, aspace
, next_pc
);
10792 if (*bpt_p
== NULL
)
10793 error (_("Could not insert single-step breakpoint at %s"),
10794 paddress (gdbarch
, next_pc
));
10797 /* Check if the breakpoints used for software single stepping
10798 were inserted or not. */
10801 single_step_breakpoints_inserted (void)
10803 return (single_step_breakpoints
[0] != NULL
10804 || single_step_breakpoints
[1] != NULL
);
10807 /* Remove and delete any breakpoints used for software single step. */
10810 remove_single_step_breakpoints (void)
10812 gdb_assert (single_step_breakpoints
[0] != NULL
);
10814 /* See insert_single_step_breakpoint for more about this deprecated
10816 deprecated_remove_raw_breakpoint (single_step_gdbarch
[0],
10817 single_step_breakpoints
[0]);
10818 single_step_gdbarch
[0] = NULL
;
10819 single_step_breakpoints
[0] = NULL
;
10821 if (single_step_breakpoints
[1] != NULL
)
10823 deprecated_remove_raw_breakpoint (single_step_gdbarch
[1],
10824 single_step_breakpoints
[1]);
10825 single_step_gdbarch
[1] = NULL
;
10826 single_step_breakpoints
[1] = NULL
;
10830 /* Delete software single step breakpoints without removing them from
10831 the inferior. This is intended to be used if the inferior's address
10832 space where they were inserted is already gone, e.g. after exit or
10836 cancel_single_step_breakpoints (void)
10840 for (i
= 0; i
< 2; i
++)
10841 if (single_step_breakpoints
[i
])
10843 xfree (single_step_breakpoints
[i
]);
10844 single_step_breakpoints
[i
] = NULL
;
10845 single_step_gdbarch
[i
] = NULL
;
10849 /* Detach software single-step breakpoints from INFERIOR_PTID without
10853 detach_single_step_breakpoints (void)
10857 for (i
= 0; i
< 2; i
++)
10858 if (single_step_breakpoints
[i
])
10859 target_remove_breakpoint (single_step_gdbarch
[i
],
10860 single_step_breakpoints
[i
]);
10863 /* Check whether a software single-step breakpoint is inserted at PC. */
10866 single_step_breakpoint_inserted_here_p (struct address_space
*aspace
,
10871 for (i
= 0; i
< 2; i
++)
10873 struct bp_target_info
*bp_tgt
= single_step_breakpoints
[i
];
10875 && breakpoint_address_match (bp_tgt
->placed_address_space
,
10876 bp_tgt
->placed_address
,
10884 /* Returns 0 if 'bp' is NOT a syscall catchpoint,
10885 non-zero otherwise. */
10887 is_syscall_catchpoint_enabled (struct breakpoint
*bp
)
10889 if (syscall_catchpoint_p (bp
)
10890 && bp
->enable_state
!= bp_disabled
10891 && bp
->enable_state
!= bp_call_disabled
)
10898 catch_syscall_enabled (void)
10900 struct inferior
*inf
= current_inferior ();
10902 return inf
->total_syscalls_count
!= 0;
10906 catching_syscall_number (int syscall_number
)
10908 struct breakpoint
*bp
;
10910 ALL_BREAKPOINTS (bp
)
10911 if (is_syscall_catchpoint_enabled (bp
))
10913 if (bp
->syscalls_to_be_caught
)
10917 VEC_iterate (int, bp
->syscalls_to_be_caught
, i
, iter
);
10919 if (syscall_number
== iter
)
10929 /* Complete syscall names. Used by "catch syscall". */
10931 catch_syscall_completer (struct cmd_list_element
*cmd
,
10932 char *text
, char *word
)
10934 const char **list
= get_syscall_names ();
10936 return (list
== NULL
) ? NULL
: complete_on_enum (list
, text
, word
);
10939 /* Tracepoint-specific operations. */
10941 /* Set tracepoint count to NUM. */
10943 set_tracepoint_count (int num
)
10945 tracepoint_count
= num
;
10946 set_internalvar_integer (lookup_internalvar ("tpnum"), num
);
10950 trace_command (char *arg
, int from_tty
)
10952 if (create_breakpoint (get_current_arch (),
10954 NULL
, 0, 1 /* parse arg */,
10956 bp_tracepoint
/* type_wanted */,
10957 0 /* Ignore count */,
10958 pending_break_support
,
10962 set_tracepoint_count (breakpoint_count
);
10966 ftrace_command (char *arg
, int from_tty
)
10968 if (create_breakpoint (get_current_arch (),
10970 NULL
, 0, 1 /* parse arg */,
10972 bp_fast_tracepoint
/* type_wanted */,
10973 0 /* Ignore count */,
10974 pending_break_support
,
10978 set_tracepoint_count (breakpoint_count
);
10981 /* strace command implementation. Creates a static tracepoint. */
10984 strace_command (char *arg
, int from_tty
)
10986 if (create_breakpoint (get_current_arch (),
10988 NULL
, 0, 1 /* parse arg */,
10990 bp_static_tracepoint
/* type_wanted */,
10991 0 /* Ignore count */,
10992 pending_break_support
,
10996 set_tracepoint_count (breakpoint_count
);
10999 /* Set up a fake reader function that gets command lines from a linked
11000 list that was acquired during tracepoint uploading. */
11002 static struct uploaded_tp
*this_utp
;
11003 static int next_cmd
;
11006 read_uploaded_action (void)
11010 VEC_iterate (char_ptr
, this_utp
->cmd_strings
, next_cmd
, rslt
);
11017 /* Given information about a tracepoint as recorded on a target (which
11018 can be either a live system or a trace file), attempt to create an
11019 equivalent GDB tracepoint. This is not a reliable process, since
11020 the target does not necessarily have all the information used when
11021 the tracepoint was originally defined. */
11023 struct breakpoint
*
11024 create_tracepoint_from_upload (struct uploaded_tp
*utp
)
11026 char *addr_str
, small_buf
[100];
11027 struct breakpoint
*tp
;
11029 if (utp
->at_string
)
11030 addr_str
= utp
->at_string
;
11033 /* In the absence of a source location, fall back to raw
11034 address. Since there is no way to confirm that the address
11035 means the same thing as when the trace was started, warn the
11037 warning (_("Uploaded tracepoint %d has no source location, using raw address"),
11039 sprintf (small_buf
, "*%s", hex_string (utp
->addr
));
11040 addr_str
= small_buf
;
11043 /* There's not much we can do with a sequence of bytecodes. */
11044 if (utp
->cond
&& !utp
->cond_string
)
11045 warning (_("Uploaded tracepoint %d condition has no source form, ignoring it"),
11048 if (!create_breakpoint (get_current_arch (),
11050 utp
->cond_string
, -1, 0 /* parse cond/thread */,
11052 utp
->type
/* type_wanted */,
11053 0 /* Ignore count */,
11054 pending_break_support
,
11057 utp
->enabled
/* enabled */))
11060 set_tracepoint_count (breakpoint_count
);
11062 /* Get the tracepoint we just created. */
11063 tp
= get_tracepoint (tracepoint_count
);
11064 gdb_assert (tp
!= NULL
);
11068 sprintf (small_buf
, "%d %d", utp
->pass
, tp
->number
);
11070 trace_pass_command (small_buf
, 0);
11073 /* If we have uploaded versions of the original commands, set up a
11074 special-purpose "reader" function and call the usual command line
11075 reader, then pass the result to the breakpoint command-setting
11077 if (!VEC_empty (char_ptr
, utp
->cmd_strings
))
11079 struct command_line
*cmd_list
;
11084 cmd_list
= read_command_lines_1 (read_uploaded_action
, 1, NULL
, NULL
);
11086 breakpoint_set_commands (tp
, cmd_list
);
11088 else if (!VEC_empty (char_ptr
, utp
->actions
)
11089 || !VEC_empty (char_ptr
, utp
->step_actions
))
11090 warning (_("Uploaded tracepoint %d actions have no source form, ignoring them"),
11096 /* Print information on tracepoint number TPNUM_EXP, or all if
11100 tracepoints_info (char *tpnum_exp
, int from_tty
)
11102 int tpnum
= -1, num_printed
;
11105 tpnum
= parse_and_eval_long (tpnum_exp
);
11107 num_printed
= breakpoint_1 (tpnum
, 0, is_tracepoint
);
11109 if (num_printed
== 0)
11112 ui_out_message (uiout
, 0, "No tracepoints.\n");
11114 ui_out_message (uiout
, 0, "No tracepoint number %d.\n", tpnum
);
11117 default_collect_info ();
11120 /* The 'enable trace' command enables tracepoints.
11121 Not supported by all targets. */
11123 enable_trace_command (char *args
, int from_tty
)
11125 enable_command (args
, from_tty
);
11128 /* The 'disable trace' command disables tracepoints.
11129 Not supported by all targets. */
11131 disable_trace_command (char *args
, int from_tty
)
11133 disable_command (args
, from_tty
);
11136 /* Remove a tracepoint (or all if no argument) */
11138 delete_trace_command (char *arg
, int from_tty
)
11140 struct breakpoint
*b
, *temp
;
11146 int breaks_to_delete
= 0;
11148 /* Delete all breakpoints if no argument.
11149 Do not delete internal or call-dummy breakpoints, these
11150 have to be deleted with an explicit breakpoint number argument. */
11151 ALL_TRACEPOINTS (b
)
11153 if (b
->number
>= 0)
11155 breaks_to_delete
= 1;
11160 /* Ask user only if there are some breakpoints to delete. */
11162 || (breaks_to_delete
&& query (_("Delete all tracepoints? "))))
11164 ALL_BREAKPOINTS_SAFE (b
, temp
)
11166 if (is_tracepoint (b
)
11168 delete_breakpoint (b
);
11173 map_breakpoint_numbers (arg
, do_delete_breakpoint
, NULL
);
11176 /* Set passcount for tracepoint.
11178 First command argument is passcount, second is tracepoint number.
11179 If tracepoint number omitted, apply to most recently defined.
11180 Also accepts special argument "all". */
11183 trace_pass_command (char *args
, int from_tty
)
11185 struct breakpoint
*t1
= (struct breakpoint
*) -1, *t2
;
11186 unsigned int count
;
11189 if (args
== 0 || *args
== 0)
11190 error (_("passcount command requires an argument (count + optional TP num)"));
11192 count
= strtoul (args
, &args
, 10); /* Count comes first, then TP num. */
11194 while (*args
&& isspace ((int) *args
))
11197 if (*args
&& strncasecmp (args
, "all", 3) == 0)
11199 args
+= 3; /* Skip special argument "all". */
11202 error (_("Junk at end of arguments."));
11205 t1
= get_tracepoint_by_number (&args
, 1, 1);
11211 ALL_TRACEPOINTS (t2
)
11212 if (t1
== (struct breakpoint
*) -1 || t1
== t2
)
11214 t2
->pass_count
= count
;
11215 observer_notify_tracepoint_modified (t2
->number
);
11217 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
11218 t2
->number
, count
);
11220 if (! all
&& *args
)
11221 t1
= get_tracepoint_by_number (&args
, 1, 0);
11227 struct breakpoint
*
11228 get_tracepoint (int num
)
11230 struct breakpoint
*t
;
11232 ALL_TRACEPOINTS (t
)
11233 if (t
->number
== num
)
11239 /* Find the tracepoint with the given target-side number (which may be
11240 different from the tracepoint number after disconnecting and
11243 struct breakpoint
*
11244 get_tracepoint_by_number_on_target (int num
)
11246 struct breakpoint
*t
;
11248 ALL_TRACEPOINTS (t
)
11249 if (t
->number_on_target
== num
)
11255 /* Utility: parse a tracepoint number and look it up in the list.
11256 If MULTI_P is true, there might be a range of tracepoints in ARG.
11257 if OPTIONAL_P is true, then if the argument is missing, the most
11258 recent tracepoint (tracepoint_count) is returned. */
11259 struct breakpoint
*
11260 get_tracepoint_by_number (char **arg
, int multi_p
, int optional_p
)
11262 extern int tracepoint_count
;
11263 struct breakpoint
*t
;
11265 char *instring
= arg
== NULL
? NULL
: *arg
;
11267 if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
11270 tpnum
= tracepoint_count
;
11272 error_no_arg (_("tracepoint number"));
11275 tpnum
= multi_p
? get_number_or_range (arg
) : get_number (arg
);
11279 if (instring
&& *instring
)
11280 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
11283 printf_filtered (_("Tracepoint argument missing and no previous tracepoint\n"));
11287 ALL_TRACEPOINTS (t
)
11288 if (t
->number
== tpnum
)
11293 /* FIXME: if we are in the middle of a range we don't want to give
11294 a message. The current interface to get_number_or_range doesn't
11295 allow us to discover this. */
11296 printf_unfiltered ("No tracepoint number %d.\n", tpnum
);
11300 /* Save information on user settable breakpoints (watchpoints, etc) to
11301 a new script file named FILENAME. If FILTER is non-NULL, call it
11302 on each breakpoint and only include the ones for which it returns
11306 save_breakpoints (char *filename
, int from_tty
,
11307 int (*filter
) (const struct breakpoint
*))
11309 struct breakpoint
*tp
;
11312 struct cleanup
*cleanup
;
11313 struct ui_file
*fp
;
11314 int extra_trace_bits
= 0;
11316 if (filename
== 0 || *filename
== 0)
11317 error (_("Argument required (file name in which to save)"));
11319 /* See if we have anything to save. */
11320 ALL_BREAKPOINTS (tp
)
11322 /* Skip internal and momentary breakpoints. */
11323 if (!user_settable_breakpoint (tp
))
11326 /* If we have a filter, only save the breakpoints it accepts. */
11327 if (filter
&& !filter (tp
))
11332 if (is_tracepoint (tp
))
11334 extra_trace_bits
= 1;
11336 /* We can stop searching. */
11343 warning (_("Nothing to save."));
11347 pathname
= tilde_expand (filename
);
11348 cleanup
= make_cleanup (xfree
, pathname
);
11349 fp
= gdb_fopen (pathname
, "w");
11351 error (_("Unable to open file '%s' for saving (%s)"),
11352 filename
, safe_strerror (errno
));
11353 make_cleanup_ui_file_delete (fp
);
11355 if (extra_trace_bits
)
11356 save_trace_state_variables (fp
);
11358 ALL_BREAKPOINTS (tp
)
11360 /* Skip internal and momentary breakpoints. */
11361 if (!user_settable_breakpoint (tp
))
11364 /* If we have a filter, only save the breakpoints it accepts. */
11365 if (filter
&& !filter (tp
))
11368 if (tp
->ops
!= NULL
)
11369 (tp
->ops
->print_recreate
) (tp
, fp
);
11372 if (tp
->type
== bp_fast_tracepoint
)
11373 fprintf_unfiltered (fp
, "ftrace");
11374 if (tp
->type
== bp_static_tracepoint
)
11375 fprintf_unfiltered (fp
, "strace");
11376 else if (tp
->type
== bp_tracepoint
)
11377 fprintf_unfiltered (fp
, "trace");
11378 else if (tp
->type
== bp_breakpoint
&& tp
->disposition
== disp_del
)
11379 fprintf_unfiltered (fp
, "tbreak");
11380 else if (tp
->type
== bp_breakpoint
)
11381 fprintf_unfiltered (fp
, "break");
11382 else if (tp
->type
== bp_hardware_breakpoint
11383 && tp
->disposition
== disp_del
)
11384 fprintf_unfiltered (fp
, "thbreak");
11385 else if (tp
->type
== bp_hardware_breakpoint
)
11386 fprintf_unfiltered (fp
, "hbreak");
11387 else if (tp
->type
== bp_watchpoint
)
11388 fprintf_unfiltered (fp
, "watch");
11389 else if (tp
->type
== bp_hardware_watchpoint
)
11390 fprintf_unfiltered (fp
, "watch");
11391 else if (tp
->type
== bp_read_watchpoint
)
11392 fprintf_unfiltered (fp
, "rwatch");
11393 else if (tp
->type
== bp_access_watchpoint
)
11394 fprintf_unfiltered (fp
, "awatch");
11396 internal_error (__FILE__
, __LINE__
,
11397 _("unhandled breakpoint type %d"), (int) tp
->type
);
11399 if (tp
->exp_string
)
11400 fprintf_unfiltered (fp
, " %s", tp
->exp_string
);
11401 else if (tp
->addr_string
)
11402 fprintf_unfiltered (fp
, " %s", tp
->addr_string
);
11407 sprintf_vma (tmp
, tp
->loc
->address
);
11408 fprintf_unfiltered (fp
, " *0x%s", tmp
);
11412 if (tp
->thread
!= -1)
11413 fprintf_unfiltered (fp
, " thread %d", tp
->thread
);
11416 fprintf_unfiltered (fp
, " task %d", tp
->task
);
11418 fprintf_unfiltered (fp
, "\n");
11420 /* Note, we can't rely on tp->number for anything, as we can't
11421 assume the recreated breakpoint numbers will match. Use $bpnum
11424 if (tp
->cond_string
)
11425 fprintf_unfiltered (fp
, " condition $bpnum %s\n", tp
->cond_string
);
11427 if (tp
->ignore_count
)
11428 fprintf_unfiltered (fp
, " ignore $bpnum %d\n", tp
->ignore_count
);
11430 if (tp
->pass_count
)
11431 fprintf_unfiltered (fp
, " passcount %d\n", tp
->pass_count
);
11435 volatile struct gdb_exception ex
;
11437 fprintf_unfiltered (fp
, " commands\n");
11439 ui_out_redirect (uiout
, fp
);
11440 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
11442 print_command_lines (uiout
, tp
->commands
->commands
, 2);
11444 ui_out_redirect (uiout
, NULL
);
11447 throw_exception (ex
);
11449 fprintf_unfiltered (fp
, " end\n");
11452 if (tp
->enable_state
== bp_disabled
)
11453 fprintf_unfiltered (fp
, "disable\n");
11455 /* If this is a multi-location breakpoint, check if the locations
11456 should be individually disabled. Watchpoint locations are
11457 special, and not user visible. */
11458 if (!is_watchpoint (tp
) && tp
->loc
&& tp
->loc
->next
)
11460 struct bp_location
*loc
;
11463 for (loc
= tp
->loc
; loc
!= NULL
; loc
= loc
->next
, n
++)
11465 fprintf_unfiltered (fp
, "disable $bpnum.%d\n", n
);
11469 if (extra_trace_bits
&& *default_collect
)
11470 fprintf_unfiltered (fp
, "set default-collect %s\n", default_collect
);
11472 do_cleanups (cleanup
);
11474 printf_filtered (_("Saved to file '%s'.\n"), filename
);
11477 /* The `save breakpoints' command. */
11480 save_breakpoints_command (char *args
, int from_tty
)
11482 save_breakpoints (args
, from_tty
, NULL
);
11485 /* The `save tracepoints' command. */
11488 save_tracepoints_command (char *args
, int from_tty
)
11490 save_breakpoints (args
, from_tty
, is_tracepoint
);
11493 /* Create a vector of all tracepoints. */
11495 VEC(breakpoint_p
) *
11498 VEC(breakpoint_p
) *tp_vec
= 0;
11499 struct breakpoint
*tp
;
11501 ALL_TRACEPOINTS (tp
)
11503 VEC_safe_push (breakpoint_p
, tp_vec
, tp
);
11510 /* This help string is used for the break, hbreak, tbreak and thbreak commands.
11511 It is defined as a macro to prevent duplication.
11512 COMMAND should be a string constant containing the name of the command. */
11513 #define BREAK_ARGS_HELP(command) \
11514 command" [LOCATION] [thread THREADNUM] [if CONDITION]\n\
11515 LOCATION may be a line number, function name, or \"*\" and an address.\n\
11516 If a line number is specified, break at start of code for that line.\n\
11517 If a function is specified, break at start of code for that function.\n\
11518 If an address is specified, break at that exact address.\n\
11519 With no LOCATION, uses current execution address of the selected\n\
11520 stack frame. This is useful for breaking on return to a stack frame.\n\
11522 THREADNUM is the number from \"info threads\".\n\
11523 CONDITION is a boolean expression.\n\
11525 Multiple breakpoints at one place are permitted, and useful if their\n\
11526 conditions are different.\n\
11528 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
11530 /* List of subcommands for "catch". */
11531 static struct cmd_list_element
*catch_cmdlist
;
11533 /* List of subcommands for "tcatch". */
11534 static struct cmd_list_element
*tcatch_cmdlist
;
11536 /* Like add_cmd, but add the command to both the "catch" and "tcatch"
11537 lists, and pass some additional user data to the command function. */
11539 add_catch_command (char *name
, char *docstring
,
11540 void (*sfunc
) (char *args
, int from_tty
,
11541 struct cmd_list_element
*command
),
11542 char **(*completer
) (struct cmd_list_element
*cmd
,
11543 char *text
, char *word
),
11544 void *user_data_catch
,
11545 void *user_data_tcatch
)
11547 struct cmd_list_element
*command
;
11549 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
11551 set_cmd_sfunc (command
, sfunc
);
11552 set_cmd_context (command
, user_data_catch
);
11553 set_cmd_completer (command
, completer
);
11555 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
11557 set_cmd_sfunc (command
, sfunc
);
11558 set_cmd_context (command
, user_data_tcatch
);
11559 set_cmd_completer (command
, completer
);
11563 clear_syscall_counts (struct inferior
*inf
)
11565 inf
->total_syscalls_count
= 0;
11566 inf
->any_syscall_count
= 0;
11567 VEC_free (int, inf
->syscalls_counts
);
11571 save_command (char *arg
, int from_tty
)
11573 printf_unfiltered (_("\
11574 \"save\" must be followed by the name of a save subcommand.\n"));
11575 help_list (save_cmdlist
, "save ", -1, gdb_stdout
);
11579 _initialize_breakpoint (void)
11581 struct cmd_list_element
*c
;
11583 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
11584 observer_attach_inferior_exit (clear_syscall_counts
);
11585 observer_attach_memory_changed (invalidate_bp_value_on_memory_change
);
11587 breakpoint_chain
= 0;
11588 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
11589 before a breakpoint is set. */
11590 breakpoint_count
= 0;
11592 tracepoint_count
= 0;
11594 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
11595 Set ignore-count of breakpoint number N to COUNT.\n\
11596 Usage is `ignore N COUNT'."));
11598 add_com_alias ("bc", "ignore", class_breakpoint
, 1);
11600 add_com ("commands", class_breakpoint
, commands_command
, _("\
11601 Set commands to be executed when a breakpoint is hit.\n\
11602 Give breakpoint number as argument after \"commands\".\n\
11603 With no argument, the targeted breakpoint is the last one set.\n\
11604 The commands themselves follow starting on the next line.\n\
11605 Type a line containing \"end\" to indicate the end of them.\n\
11606 Give \"silent\" as the first line to make the breakpoint silent;\n\
11607 then no output is printed when it is hit, except what the commands print."));
11609 add_com ("condition", class_breakpoint
, condition_command
, _("\
11610 Specify breakpoint number N to break only if COND is true.\n\
11611 Usage is `condition N COND', where N is an integer and COND is an\n\
11612 expression to be evaluated whenever breakpoint N is reached."));
11614 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
11615 Set a temporary breakpoint.\n\
11616 Like \"break\" except the breakpoint is only temporary,\n\
11617 so it will be deleted when hit. Equivalent to \"break\" followed\n\
11618 by using \"enable delete\" on the breakpoint number.\n\
11620 BREAK_ARGS_HELP ("tbreak")));
11621 set_cmd_completer (c
, location_completer
);
11623 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
11624 Set a hardware assisted breakpoint.\n\
11625 Like \"break\" except the breakpoint requires hardware support,\n\
11626 some target hardware may not have this support.\n\
11628 BREAK_ARGS_HELP ("hbreak")));
11629 set_cmd_completer (c
, location_completer
);
11631 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
11632 Set a temporary hardware assisted breakpoint.\n\
11633 Like \"hbreak\" except the breakpoint is only temporary,\n\
11634 so it will be deleted when hit.\n\
11636 BREAK_ARGS_HELP ("thbreak")));
11637 set_cmd_completer (c
, location_completer
);
11639 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
11640 Enable some breakpoints.\n\
11641 Give breakpoint numbers (separated by spaces) as arguments.\n\
11642 With no subcommand, breakpoints are enabled until you command otherwise.\n\
11643 This is used to cancel the effect of the \"disable\" command.\n\
11644 With a subcommand you can enable temporarily."),
11645 &enablelist
, "enable ", 1, &cmdlist
);
11647 add_com ("ab", class_breakpoint
, enable_command
, _("\
11648 Enable some breakpoints.\n\
11649 Give breakpoint numbers (separated by spaces) as arguments.\n\
11650 With no subcommand, breakpoints are enabled until you command otherwise.\n\
11651 This is used to cancel the effect of the \"disable\" command.\n\
11652 With a subcommand you can enable temporarily."));
11654 add_com_alias ("en", "enable", class_breakpoint
, 1);
11656 add_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
11657 Enable some breakpoints.\n\
11658 Give breakpoint numbers (separated by spaces) as arguments.\n\
11659 This is used to cancel the effect of the \"disable\" command.\n\
11660 May be abbreviated to simply \"enable\".\n"),
11661 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
11663 add_cmd ("once", no_class
, enable_once_command
, _("\
11664 Enable breakpoints for one hit. Give breakpoint numbers.\n\
11665 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
11668 add_cmd ("delete", no_class
, enable_delete_command
, _("\
11669 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
11670 If a breakpoint is hit while enabled in this fashion, it is deleted."),
11673 add_cmd ("delete", no_class
, enable_delete_command
, _("\
11674 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
11675 If a breakpoint is hit while enabled in this fashion, it is deleted."),
11678 add_cmd ("once", no_class
, enable_once_command
, _("\
11679 Enable breakpoints for one hit. Give breakpoint numbers.\n\
11680 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
11683 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
11684 Disable some breakpoints.\n\
11685 Arguments are breakpoint numbers with spaces in between.\n\
11686 To disable all breakpoints, give no argument.\n\
11687 A disabled breakpoint is not forgotten, but has no effect until reenabled."),
11688 &disablelist
, "disable ", 1, &cmdlist
);
11689 add_com_alias ("dis", "disable", class_breakpoint
, 1);
11690 add_com_alias ("disa", "disable", class_breakpoint
, 1);
11692 add_com ("sb", class_breakpoint
, disable_command
, _("\
11693 Disable some breakpoints.\n\
11694 Arguments are breakpoint numbers with spaces in between.\n\
11695 To disable all breakpoints, give no argument.\n\
11696 A disabled breakpoint is not forgotten, but has no effect until reenabled."));
11698 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
11699 Disable some breakpoints.\n\
11700 Arguments are breakpoint numbers with spaces in between.\n\
11701 To disable all breakpoints, give no argument.\n\
11702 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
11703 This command may be abbreviated \"disable\"."),
11706 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
11707 Delete some breakpoints or auto-display expressions.\n\
11708 Arguments are breakpoint numbers with spaces in between.\n\
11709 To delete all breakpoints, give no argument.\n\
11711 Also a prefix command for deletion of other GDB objects.\n\
11712 The \"unset\" command is also an alias for \"delete\"."),
11713 &deletelist
, "delete ", 1, &cmdlist
);
11714 add_com_alias ("d", "delete", class_breakpoint
, 1);
11715 add_com_alias ("del", "delete", class_breakpoint
, 1);
11717 add_com ("db", class_breakpoint
, delete_command
, _("\
11718 Delete some breakpoints.\n\
11719 Arguments are breakpoint numbers with spaces in between.\n\
11720 To delete all breakpoints, give no argument.\n"));
11722 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
11723 Delete some breakpoints or auto-display expressions.\n\
11724 Arguments are breakpoint numbers with spaces in between.\n\
11725 To delete all breakpoints, give no argument.\n\
11726 This command may be abbreviated \"delete\"."),
11729 add_com ("clear", class_breakpoint
, clear_command
, _("\
11730 Clear breakpoint at specified line or function.\n\
11731 Argument may be line number, function name, or \"*\" and an address.\n\
11732 If line number is specified, all breakpoints in that line are cleared.\n\
11733 If function is specified, breakpoints at beginning of function are cleared.\n\
11734 If an address is specified, breakpoints at that address are cleared.\n\
11736 With no argument, clears all breakpoints in the line that the selected frame\n\
11737 is executing in.\n\
11739 See also the \"delete\" command which clears breakpoints by number."));
11740 add_com_alias ("cl", "clear", class_breakpoint
, 1);
11742 c
= add_com ("break", class_breakpoint
, break_command
, _("\
11743 Set breakpoint at specified line or function.\n"
11744 BREAK_ARGS_HELP ("break")));
11745 set_cmd_completer (c
, location_completer
);
11747 add_com_alias ("b", "break", class_run
, 1);
11748 add_com_alias ("br", "break", class_run
, 1);
11749 add_com_alias ("bre", "break", class_run
, 1);
11750 add_com_alias ("brea", "break", class_run
, 1);
11753 add_com_alias ("ba", "break", class_breakpoint
, 1);
11757 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
11758 Break in function/address or break at a line in the current file."),
11759 &stoplist
, "stop ", 1, &cmdlist
);
11760 add_cmd ("in", class_breakpoint
, stopin_command
,
11761 _("Break in function or address."), &stoplist
);
11762 add_cmd ("at", class_breakpoint
, stopat_command
,
11763 _("Break at a line in the current file."), &stoplist
);
11764 add_com ("status", class_info
, breakpoints_info
, _("\
11765 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
11766 The \"Type\" column indicates one of:\n\
11767 \tbreakpoint - normal breakpoint\n\
11768 \twatchpoint - watchpoint\n\
11769 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
11770 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
11771 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
11772 address and file/line number respectively.\n\
11774 Convenience variable \"$_\" and default examine address for \"x\"\n\
11775 are set to the address of the last breakpoint listed unless the command\n\
11776 is prefixed with \"server \".\n\n\
11777 Convenience variable \"$bpnum\" contains the number of the last\n\
11778 breakpoint set."));
11781 add_info ("breakpoints", breakpoints_info
, _("\
11782 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
11783 The \"Type\" column indicates one of:\n\
11784 \tbreakpoint - normal breakpoint\n\
11785 \twatchpoint - watchpoint\n\
11786 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
11787 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
11788 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
11789 address and file/line number respectively.\n\
11791 Convenience variable \"$_\" and default examine address for \"x\"\n\
11792 are set to the address of the last breakpoint listed unless the command\n\
11793 is prefixed with \"server \".\n\n\
11794 Convenience variable \"$bpnum\" contains the number of the last\n\
11795 breakpoint set."));
11797 add_info_alias ("b", "breakpoints", 1);
11800 add_com ("lb", class_breakpoint
, breakpoints_info
, _("\
11801 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
11802 The \"Type\" column indicates one of:\n\
11803 \tbreakpoint - normal breakpoint\n\
11804 \twatchpoint - watchpoint\n\
11805 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
11806 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
11807 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
11808 address and file/line number respectively.\n\
11810 Convenience variable \"$_\" and default examine address for \"x\"\n\
11811 are set to the address of the last breakpoint listed unless the command\n\
11812 is prefixed with \"server \".\n\n\
11813 Convenience variable \"$bpnum\" contains the number of the last\n\
11814 breakpoint set."));
11816 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
11817 Status of all breakpoints, or breakpoint number NUMBER.\n\
11818 The \"Type\" column indicates one of:\n\
11819 \tbreakpoint - normal breakpoint\n\
11820 \twatchpoint - watchpoint\n\
11821 \tlongjmp - internal breakpoint used to step through longjmp()\n\
11822 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
11823 \tuntil - internal breakpoint used by the \"until\" command\n\
11824 \tfinish - internal breakpoint used by the \"finish\" command\n\
11825 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
11826 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
11827 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
11828 address and file/line number respectively.\n\
11830 Convenience variable \"$_\" and default examine address for \"x\"\n\
11831 are set to the address of the last breakpoint listed unless the command\n\
11832 is prefixed with \"server \".\n\n\
11833 Convenience variable \"$bpnum\" contains the number of the last\n\
11835 &maintenanceinfolist
);
11837 add_prefix_cmd ("catch", class_breakpoint
, catch_command
, _("\
11838 Set catchpoints to catch events."),
11839 &catch_cmdlist
, "catch ",
11840 0/*allow-unknown*/, &cmdlist
);
11842 add_prefix_cmd ("tcatch", class_breakpoint
, tcatch_command
, _("\
11843 Set temporary catchpoints to catch events."),
11844 &tcatch_cmdlist
, "tcatch ",
11845 0/*allow-unknown*/, &cmdlist
);
11847 /* Add catch and tcatch sub-commands. */
11848 add_catch_command ("catch", _("\
11849 Catch an exception, when caught.\n\
11850 With an argument, catch only exceptions with the given name."),
11851 catch_catch_command
,
11855 add_catch_command ("throw", _("\
11856 Catch an exception, when thrown.\n\
11857 With an argument, catch only exceptions with the given name."),
11858 catch_throw_command
,
11862 add_catch_command ("fork", _("Catch calls to fork."),
11863 catch_fork_command_1
,
11865 (void *) (uintptr_t) catch_fork_permanent
,
11866 (void *) (uintptr_t) catch_fork_temporary
);
11867 add_catch_command ("vfork", _("Catch calls to vfork."),
11868 catch_fork_command_1
,
11870 (void *) (uintptr_t) catch_vfork_permanent
,
11871 (void *) (uintptr_t) catch_vfork_temporary
);
11872 add_catch_command ("exec", _("Catch calls to exec."),
11873 catch_exec_command_1
,
11877 add_catch_command ("syscall", _("\
11878 Catch system calls by their names and/or numbers.\n\
11879 Arguments say which system calls to catch. If no arguments\n\
11880 are given, every system call will be caught.\n\
11881 Arguments, if given, should be one or more system call names\n\
11882 (if your system supports that), or system call numbers."),
11883 catch_syscall_command_1
,
11884 catch_syscall_completer
,
11887 add_catch_command ("exception", _("\
11888 Catch Ada exceptions, when raised.\n\
11889 With an argument, catch only exceptions with the given name."),
11890 catch_ada_exception_command
,
11894 add_catch_command ("assert", _("\
11895 Catch failed Ada assertions, when raised.\n\
11896 With an argument, catch only exceptions with the given name."),
11897 catch_assert_command
,
11902 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
11903 Set a watchpoint for an expression.\n\
11904 Usage: watch [-l|-location] EXPRESSION\n\
11905 A watchpoint stops execution of your program whenever the value of\n\
11906 an expression changes.\n\
11907 If -l or -location is given, this evaluates EXPRESSION and watches\n\
11908 the memory to which it refers."));
11909 set_cmd_completer (c
, expression_completer
);
11911 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
11912 Set a read watchpoint for an expression.\n\
11913 Usage: rwatch [-l|-location] EXPRESSION\n\
11914 A watchpoint stops execution of your program whenever the value of\n\
11915 an expression is read.\n\
11916 If -l or -location is given, this evaluates EXPRESSION and watches\n\
11917 the memory to which it refers."));
11918 set_cmd_completer (c
, expression_completer
);
11920 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
11921 Set a watchpoint for an expression.\n\
11922 Usage: awatch [-l|-location] EXPRESSION\n\
11923 A watchpoint stops execution of your program whenever the value of\n\
11924 an expression is either read or written.\n\
11925 If -l or -location is given, this evaluates EXPRESSION and watches\n\
11926 the memory to which it refers."));
11927 set_cmd_completer (c
, expression_completer
);
11929 add_info ("watchpoints", watchpoints_info
, _("\
11930 Status of watchpoints, or watchpoint number NUMBER."));
11934 /* XXX: cagney/2005-02-23: This should be a boolean, and should
11935 respond to changes - contrary to the description. */
11936 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
11937 &can_use_hw_watchpoints
, _("\
11938 Set debugger's willingness to use watchpoint hardware."), _("\
11939 Show debugger's willingness to use watchpoint hardware."), _("\
11940 If zero, gdb will not use hardware for new watchpoints, even if\n\
11941 such is available. (However, any hardware watchpoints that were\n\
11942 created before setting this to nonzero, will continue to use watchpoint\n\
11945 show_can_use_hw_watchpoints
,
11946 &setlist
, &showlist
);
11948 can_use_hw_watchpoints
= 1;
11950 /* Tracepoint manipulation commands. */
11952 c
= add_com ("trace", class_breakpoint
, trace_command
, _("\
11953 Set a tracepoint at specified line or function.\n\
11955 BREAK_ARGS_HELP ("trace") "\n\
11956 Do \"help tracepoints\" for info on other tracepoint commands."));
11957 set_cmd_completer (c
, location_completer
);
11959 add_com_alias ("tp", "trace", class_alias
, 0);
11960 add_com_alias ("tr", "trace", class_alias
, 1);
11961 add_com_alias ("tra", "trace", class_alias
, 1);
11962 add_com_alias ("trac", "trace", class_alias
, 1);
11964 c
= add_com ("ftrace", class_breakpoint
, ftrace_command
, _("\
11965 Set a fast tracepoint at specified line or function.\n\
11967 BREAK_ARGS_HELP ("ftrace") "\n\
11968 Do \"help tracepoints\" for info on other tracepoint commands."));
11969 set_cmd_completer (c
, location_completer
);
11971 c
= add_com ("strace", class_breakpoint
, strace_command
, _("\
11972 Set a static tracepoint at specified line, function or marker.\n\
11974 strace [LOCATION] [if CONDITION]\n\
11975 LOCATION may be a line number, function name, \"*\" and an address,\n\
11976 or -m MARKER_ID.\n\
11977 If a line number is specified, probe the marker at start of code\n\
11978 for that line. If a function is specified, probe the marker at start\n\
11979 of code for that function. If an address is specified, probe the marker\n\
11980 at that exact address. If a marker id is specified, probe the marker\n\
11981 with that name. With no LOCATION, uses current execution address of\n\
11982 the selected stack frame.\n\
11983 Static tracepoints accept an extra collect action -- ``collect $_sdata''.\n\
11984 This collects arbitrary user data passed in the probe point call to the\n\
11985 tracing library. You can inspect it when analyzing the trace buffer,\n\
11986 by printing the $_sdata variable like any other convenience variable.\n\
11988 CONDITION is a boolean expression.\n\
11990 Multiple tracepoints at one place are permitted, and useful if their\n\
11991 conditions are different.\n\
11993 Do \"help breakpoints\" for info on other commands dealing with breakpoints.\n\
11994 Do \"help tracepoints\" for info on other tracepoint commands."));
11995 set_cmd_completer (c
, location_completer
);
11997 add_info ("tracepoints", tracepoints_info
, _("\
11998 Status of tracepoints, or tracepoint number NUMBER.\n\
11999 Convenience variable \"$tpnum\" contains the number of the\n\
12000 last tracepoint set."));
12002 add_info_alias ("tp", "tracepoints", 1);
12004 add_cmd ("tracepoints", class_trace
, delete_trace_command
, _("\
12005 Delete specified tracepoints.\n\
12006 Arguments are tracepoint numbers, separated by spaces.\n\
12007 No argument means delete all tracepoints."),
12010 c
= add_cmd ("tracepoints", class_trace
, disable_trace_command
, _("\
12011 Disable specified tracepoints.\n\
12012 Arguments are tracepoint numbers, separated by spaces.\n\
12013 No argument means disable all tracepoints."),
12015 deprecate_cmd (c
, "disable");
12017 c
= add_cmd ("tracepoints", class_trace
, enable_trace_command
, _("\
12018 Enable specified tracepoints.\n\
12019 Arguments are tracepoint numbers, separated by spaces.\n\
12020 No argument means enable all tracepoints."),
12022 deprecate_cmd (c
, "enable");
12024 add_com ("passcount", class_trace
, trace_pass_command
, _("\
12025 Set the passcount for a tracepoint.\n\
12026 The trace will end when the tracepoint has been passed 'count' times.\n\
12027 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
12028 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
12030 add_prefix_cmd ("save", class_breakpoint
, save_command
,
12031 _("Save breakpoint definitions as a script."),
12032 &save_cmdlist
, "save ",
12033 0/*allow-unknown*/, &cmdlist
);
12035 c
= add_cmd ("breakpoints", class_breakpoint
, save_breakpoints_command
, _("\
12036 Save current breakpoint definitions as a script.\n\
12037 This includes all types of breakpoints (breakpoints, watchpoints,\n\
12038 catchpoints, tracepoints). Use the 'source' command in another debug\n\
12039 session to restore them."),
12041 set_cmd_completer (c
, filename_completer
);
12043 c
= add_cmd ("tracepoints", class_trace
, save_tracepoints_command
, _("\
12044 Save current tracepoint definitions as a script.\n\
12045 Use the 'source' command in another debug session to restore them."),
12047 set_cmd_completer (c
, filename_completer
);
12049 c
= add_com_alias ("save-tracepoints", "save tracepoints", class_trace
, 0);
12050 deprecate_cmd (c
, "save tracepoints");
12052 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
12053 Breakpoint specific settings\n\
12054 Configure various breakpoint-specific variables such as\n\
12055 pending breakpoint behavior"),
12056 &breakpoint_set_cmdlist
, "set breakpoint ",
12057 0/*allow-unknown*/, &setlist
);
12058 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
12059 Breakpoint specific settings\n\
12060 Configure various breakpoint-specific variables such as\n\
12061 pending breakpoint behavior"),
12062 &breakpoint_show_cmdlist
, "show breakpoint ",
12063 0/*allow-unknown*/, &showlist
);
12065 add_setshow_auto_boolean_cmd ("pending", no_class
,
12066 &pending_break_support
, _("\
12067 Set debugger's behavior regarding pending breakpoints."), _("\
12068 Show debugger's behavior regarding pending breakpoints."), _("\
12069 If on, an unrecognized breakpoint location will cause gdb to create a\n\
12070 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
12071 an error. If auto, an unrecognized breakpoint location results in a\n\
12072 user-query to see if a pending breakpoint should be created."),
12074 show_pending_break_support
,
12075 &breakpoint_set_cmdlist
,
12076 &breakpoint_show_cmdlist
);
12078 pending_break_support
= AUTO_BOOLEAN_AUTO
;
12080 add_setshow_boolean_cmd ("auto-hw", no_class
,
12081 &automatic_hardware_breakpoints
, _("\
12082 Set automatic usage of hardware breakpoints."), _("\
12083 Show automatic usage of hardware breakpoints."), _("\
12084 If set, the debugger will automatically use hardware breakpoints for\n\
12085 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
12086 a warning will be emitted for such breakpoints."),
12088 show_automatic_hardware_breakpoints
,
12089 &breakpoint_set_cmdlist
,
12090 &breakpoint_show_cmdlist
);
12092 add_setshow_enum_cmd ("always-inserted", class_support
,
12093 always_inserted_enums
, &always_inserted_mode
, _("\
12094 Set mode for inserting breakpoints."), _("\
12095 Show mode for inserting breakpoints."), _("\
12096 When this mode is off, breakpoints are inserted in inferior when it is\n\
12097 resumed, and removed when execution stops. When this mode is on,\n\
12098 breakpoints are inserted immediately and removed only when the user\n\
12099 deletes the breakpoint. When this mode is auto (which is the default),\n\
12100 the behaviour depends on the non-stop setting (see help set non-stop).\n\
12101 In this case, if gdb is controlling the inferior in non-stop mode, gdb\n\
12102 behaves as if always-inserted mode is on; if gdb is controlling the\n\
12103 inferior in all-stop mode, gdb behaves as if always-inserted mode is off."),
12105 &show_always_inserted_mode
,
12106 &breakpoint_set_cmdlist
,
12107 &breakpoint_show_cmdlist
);
12109 automatic_hardware_breakpoints
= 1;
12111 observer_attach_about_to_proceed (breakpoint_about_to_proceed
);