1 /* Everything about breakpoints, for GDB.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
5 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "arch-utils.h"
28 #include "breakpoint.h"
29 #include "tracepoint.h"
31 #include "expression.h"
37 #include "gdbthread.h"
40 #include "gdb_string.h"
42 #include "filenames.h"
48 #include "completer.h"
51 #include "cli/cli-script.h"
52 #include "gdb_assert.h"
57 #include "exceptions.h"
64 #include "xml-syscall.h"
65 #include "parser-defs.h"
66 #include "cli/cli-utils.h"
68 /* readline include files */
69 #include "readline/readline.h"
70 #include "readline/history.h"
72 /* readline defines this. */
75 #include "mi/mi-common.h"
76 #include "python/python.h"
78 /* Arguments to pass as context to some catch command handlers. */
79 #define CATCH_PERMANENT ((void *) (uintptr_t) 0)
80 #define CATCH_TEMPORARY ((void *) (uintptr_t) 1)
82 /* Prototypes for local functions. */
84 static void enable_delete_command (char *, int);
86 static void enable_once_command (char *, int);
88 static void disable_command (char *, int);
90 static void enable_command (char *, int);
92 static void map_breakpoint_numbers (char *, void (*) (struct breakpoint *,
96 static void ignore_command (char *, int);
98 static int breakpoint_re_set_one (void *);
100 static void clear_command (char *, int);
102 static void catch_command (char *, int);
104 static int can_use_hardware_watchpoint (struct value *, int);
106 static void break_command_1 (char *, int, int);
108 static void mention (struct breakpoint *);
110 /* This function is used in gdbtk sources and thus can not be made
112 struct breakpoint *set_raw_breakpoint (struct gdbarch *gdbarch,
113 struct symtab_and_line,
116 static void breakpoint_adjustment_warning (CORE_ADDR, CORE_ADDR, int, int);
118 static CORE_ADDR adjust_breakpoint_address (struct gdbarch *gdbarch,
122 static void describe_other_breakpoints (struct gdbarch *,
123 struct program_space *, CORE_ADDR,
124 struct obj_section *, int);
126 static int breakpoint_address_match (struct address_space *aspace1,
128 struct address_space *aspace2,
131 static int watchpoint_locations_match (struct bp_location *loc1,
132 struct bp_location *loc2);
134 static int breakpoint_location_address_match (struct bp_location *bl,
135 struct address_space *aspace,
138 static void breakpoints_info (char *, int);
140 static void watchpoints_info (char *, int);
142 static int breakpoint_1 (char *, int,
143 int (*) (const struct breakpoint *));
145 static int breakpoint_cond_eval (void *);
147 static void cleanup_executing_breakpoints (void *);
149 static void commands_command (char *, int);
151 static void condition_command (char *, int);
160 static int remove_breakpoint (struct bp_location *, insertion_state_t);
161 static int remove_breakpoint_1 (struct bp_location *, insertion_state_t);
163 static enum print_stop_action print_it_typical (bpstat);
165 static enum print_stop_action print_bp_stop_message (bpstat bs);
167 static int watchpoint_check (void *);
169 static void maintenance_info_breakpoints (char *, int);
171 static int hw_breakpoint_used_count (void);
173 static int hw_watchpoint_used_count (enum bptype, int *);
175 static void hbreak_command (char *, int);
177 static void thbreak_command (char *, int);
179 static void do_enable_breakpoint (struct breakpoint *, enum bpdisp);
181 static void stop_command (char *arg, int from_tty);
183 static void stopin_command (char *arg, int from_tty);
185 static void stopat_command (char *arg, int from_tty);
187 static char *ep_parse_optional_if_clause (char **arg);
189 static void catch_exception_command_1 (enum exception_event_kind ex_event,
190 char *arg, int tempflag, int from_tty);
192 static void tcatch_command (char *arg, int from_tty);
194 static void detach_single_step_breakpoints (void);
196 static int single_step_breakpoint_inserted_here_p (struct address_space *,
199 static void free_bp_location (struct bp_location *loc);
200 static void incref_bp_location (struct bp_location *loc);
201 static void decref_bp_location (struct bp_location **loc);
203 static struct bp_location *allocate_bp_location (struct breakpoint *bpt);
205 static void update_global_location_list (int);
207 static void update_global_location_list_nothrow (int);
209 static int is_hardware_watchpoint (const struct breakpoint *bpt);
211 static int is_watchpoint (const struct breakpoint *bpt);
213 static void insert_breakpoint_locations (void);
215 static int syscall_catchpoint_p (struct breakpoint *b);
217 static void tracepoints_info (char *, int);
219 static void delete_trace_command (char *, int);
221 static void enable_trace_command (char *, int);
223 static void disable_trace_command (char *, int);
225 static void trace_pass_command (char *, int);
227 /* Assuming we're creating a static tracepoint, does S look like a
228 static tracepoint marker spec ("-m MARKER_ID")? */
229 #define is_marker_spec(s) \
230 (s != NULL && strncmp (s, "-m", 2) == 0 && ((s)[2] == ' ' || (s)[2] == '\t'))
232 /* A reference-counted struct command_line. This lets multiple
233 breakpoints share a single command list. */
234 struct counted_command_line
236 /* The reference count. */
239 /* The command list. */
240 struct command_line *commands;
243 struct command_line *
244 breakpoint_commands (struct breakpoint *b)
246 return b->commands ? b->commands->commands : NULL;
249 /* Flag indicating that a command has proceeded the inferior past the
250 current breakpoint. */
252 static int breakpoint_proceeded;
255 bpdisp_text (enum bpdisp disp)
257 /* NOTE: the following values are a part of MI protocol and
258 represent values of 'disp' field returned when inferior stops at
260 static const char * const bpdisps[] = {"del", "dstp", "dis", "keep"};
262 return bpdisps[(int) disp];
265 /* Prototypes for exported functions. */
266 /* If FALSE, gdb will not use hardware support for watchpoints, even
267 if such is available. */
268 static int can_use_hw_watchpoints;
271 show_can_use_hw_watchpoints (struct ui_file *file, int from_tty,
272 struct cmd_list_element *c,
275 fprintf_filtered (file,
276 _("Debugger's willingness to use "
277 "watchpoint hardware is %s.\n"),
281 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
282 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
283 for unrecognized breakpoint locations.
284 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
285 static enum auto_boolean pending_break_support;
287 show_pending_break_support (struct ui_file *file, int from_tty,
288 struct cmd_list_element *c,
291 fprintf_filtered (file,
292 _("Debugger's behavior regarding "
293 "pending breakpoints is %s.\n"),
297 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
298 set with "break" but falling in read-only memory.
299 If 0, gdb will warn about such breakpoints, but won't automatically
300 use hardware breakpoints. */
301 static int automatic_hardware_breakpoints;
303 show_automatic_hardware_breakpoints (struct ui_file *file, int from_tty,
304 struct cmd_list_element *c,
307 fprintf_filtered (file,
308 _("Automatic usage of hardware breakpoints is %s.\n"),
312 /* If on, gdb will keep breakpoints inserted even as inferior is
313 stopped, and immediately insert any new breakpoints. If off, gdb
314 will insert breakpoints into inferior only when resuming it, and
315 will remove breakpoints upon stop. If auto, GDB will behave as ON
316 if in non-stop mode, and as OFF if all-stop mode.*/
318 static const char always_inserted_auto[] = "auto";
319 static const char always_inserted_on[] = "on";
320 static const char always_inserted_off[] = "off";
321 static const char *always_inserted_enums[] = {
322 always_inserted_auto,
327 static const char *always_inserted_mode = always_inserted_auto;
329 show_always_inserted_mode (struct ui_file *file, int from_tty,
330 struct cmd_list_element *c, const char *value)
332 if (always_inserted_mode == always_inserted_auto)
333 fprintf_filtered (file,
334 _("Always inserted breakpoint "
335 "mode is %s (currently %s).\n"),
337 breakpoints_always_inserted_mode () ? "on" : "off");
339 fprintf_filtered (file, _("Always inserted breakpoint mode is %s.\n"),
344 breakpoints_always_inserted_mode (void)
346 return (always_inserted_mode == always_inserted_on
347 || (always_inserted_mode == always_inserted_auto && non_stop));
350 void _initialize_breakpoint (void);
352 /* Are we executing breakpoint commands? */
353 static int executing_breakpoint_commands;
355 /* Are overlay event breakpoints enabled? */
356 static int overlay_events_enabled;
358 /* See description in breakpoint.h. */
359 int target_exact_watchpoints = 0;
361 /* Walk the following statement or block through all breakpoints.
362 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the
363 current breakpoint. */
365 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
367 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
368 for (B = breakpoint_chain; \
369 B ? (TMP=B->next, 1): 0; \
372 /* Similar iterator for the low-level breakpoints. SAFE variant is
373 not provided so update_global_location_list must not be called
374 while executing the block of ALL_BP_LOCATIONS. */
376 #define ALL_BP_LOCATIONS(B,BP_TMP) \
377 for (BP_TMP = bp_location; \
378 BP_TMP < bp_location + bp_location_count && (B = *BP_TMP); \
381 /* Iterator for tracepoints only. */
383 #define ALL_TRACEPOINTS(B) \
384 for (B = breakpoint_chain; B; B = B->next) \
385 if (is_tracepoint (B))
387 /* Chains of all breakpoints defined. */
389 struct breakpoint *breakpoint_chain;
391 /* Array is sorted by bp_location_compare - primarily by the ADDRESS. */
393 static struct bp_location **bp_location;
395 /* Number of elements of BP_LOCATION. */
397 static unsigned bp_location_count;
399 /* Maximum alignment offset between bp_target_info.PLACED_ADDRESS and
400 ADDRESS for the current elements of BP_LOCATION which get a valid
401 result from bp_location_has_shadow. You can use it for roughly
402 limiting the subrange of BP_LOCATION to scan for shadow bytes for
403 an address you need to read. */
405 static CORE_ADDR bp_location_placed_address_before_address_max;
407 /* Maximum offset plus alignment between bp_target_info.PLACED_ADDRESS
408 + bp_target_info.SHADOW_LEN and ADDRESS for the current elements of
409 BP_LOCATION which get a valid result from bp_location_has_shadow.
410 You can use it for roughly limiting the subrange of BP_LOCATION to
411 scan for shadow bytes for an address you need to read. */
413 static CORE_ADDR bp_location_shadow_len_after_address_max;
415 /* The locations that no longer correspond to any breakpoint, unlinked
416 from bp_location array, but for which a hit may still be reported
418 VEC(bp_location_p) *moribund_locations = NULL;
420 /* Number of last breakpoint made. */
422 static int breakpoint_count;
424 /* The value of `breakpoint_count' before the last command that
425 created breakpoints. If the last (break-like) command created more
426 than one breakpoint, then the difference between BREAKPOINT_COUNT
427 and PREV_BREAKPOINT_COUNT is more than one. */
428 static int prev_breakpoint_count;
430 /* Number of last tracepoint made. */
432 static int tracepoint_count;
434 static struct cmd_list_element *breakpoint_set_cmdlist;
435 static struct cmd_list_element *breakpoint_show_cmdlist;
436 struct cmd_list_element *save_cmdlist;
438 /* Return whether a breakpoint is an active enabled breakpoint. */
440 breakpoint_enabled (struct breakpoint *b)
442 return (b->enable_state == bp_enabled);
445 /* Set breakpoint count to NUM. */
448 set_breakpoint_count (int num)
450 prev_breakpoint_count = breakpoint_count;
451 breakpoint_count = num;
452 set_internalvar_integer (lookup_internalvar ("bpnum"), num);
455 /* Used by `start_rbreak_breakpoints' below, to record the current
456 breakpoint count before "rbreak" creates any breakpoint. */
457 static int rbreak_start_breakpoint_count;
459 /* Called at the start an "rbreak" command to record the first
463 start_rbreak_breakpoints (void)
465 rbreak_start_breakpoint_count = breakpoint_count;
468 /* Called at the end of an "rbreak" command to record the last
472 end_rbreak_breakpoints (void)
474 prev_breakpoint_count = rbreak_start_breakpoint_count;
477 /* Used in run_command to zero the hit count when a new run starts. */
480 clear_breakpoint_hit_counts (void)
482 struct breakpoint *b;
488 /* Allocate a new counted_command_line with reference count of 1.
489 The new structure owns COMMANDS. */
491 static struct counted_command_line *
492 alloc_counted_command_line (struct command_line *commands)
494 struct counted_command_line *result
495 = xmalloc (sizeof (struct counted_command_line));
498 result->commands = commands;
502 /* Increment reference count. This does nothing if CMD is NULL. */
505 incref_counted_command_line (struct counted_command_line *cmd)
511 /* Decrement reference count. If the reference count reaches 0,
512 destroy the counted_command_line. Sets *CMDP to NULL. This does
513 nothing if *CMDP is NULL. */
516 decref_counted_command_line (struct counted_command_line **cmdp)
520 if (--(*cmdp)->refc == 0)
522 free_command_lines (&(*cmdp)->commands);
529 /* A cleanup function that calls decref_counted_command_line. */
532 do_cleanup_counted_command_line (void *arg)
534 decref_counted_command_line (arg);
537 /* Create a cleanup that calls decref_counted_command_line on the
540 static struct cleanup *
541 make_cleanup_decref_counted_command_line (struct counted_command_line **cmdp)
543 return make_cleanup (do_cleanup_counted_command_line, cmdp);
546 /* Default address, symtab and line to put a breakpoint at
547 for "break" command with no arg.
548 If default_breakpoint_valid is zero, the other three are
549 not valid, and "break" with no arg is an error.
551 This set by print_stack_frame, which calls set_default_breakpoint. */
553 int default_breakpoint_valid;
554 CORE_ADDR default_breakpoint_address;
555 struct symtab *default_breakpoint_symtab;
556 int default_breakpoint_line;
557 struct program_space *default_breakpoint_pspace;
560 /* Return the breakpoint with the specified number, or NULL
561 if the number does not refer to an existing breakpoint. */
564 get_breakpoint (int num)
566 struct breakpoint *b;
569 if (b->number == num)
578 set_breakpoint_condition (struct breakpoint *b, char *exp,
581 struct bp_location *loc = b->loc;
583 for (; loc; loc = loc->next)
588 xfree (b->cond_string);
589 b->cond_string = NULL;
596 printf_filtered (_("Breakpoint %d now unconditional.\n"), b->number);
602 /* I don't know if it matters whether this is the string the user
603 typed in or the decompiled expression. */
604 b->cond_string = xstrdup (arg);
605 b->condition_not_parsed = 0;
607 if (is_watchpoint (b))
609 innermost_block = NULL;
611 b->cond_exp = parse_exp_1 (&arg, 0, 0);
613 error (_("Junk at end of expression"));
614 b->cond_exp_valid_block = innermost_block;
618 for (loc = b->loc; loc; loc = loc->next)
622 parse_exp_1 (&arg, block_for_pc (loc->address), 0);
624 error (_("Junk at end of expression"));
628 breakpoints_changed ();
629 observer_notify_breakpoint_modified (b);
632 /* condition N EXP -- set break condition of breakpoint N to EXP. */
635 condition_command (char *arg, int from_tty)
637 struct breakpoint *b;
642 error_no_arg (_("breakpoint number"));
645 bnum = get_number (&p);
647 error (_("Bad breakpoint argument: '%s'"), arg);
650 if (b->number == bnum)
652 /* Check if this breakpoint has a Python object assigned to
653 it, and if it has a definition of the "stop"
654 method. This method and conditions entered into GDB from
655 the CLI are mutually exclusive. */
657 && gdbpy_breakpoint_has_py_cond (b->py_bp_object))
658 error (_("Cannot set a condition where a Python 'stop' "
659 "method has been defined in the breakpoint."));
660 set_breakpoint_condition (b, p, from_tty);
664 error (_("No breakpoint number %d."), bnum);
667 /* Check that COMMAND do not contain commands that are suitable
668 only for tracepoints and not suitable for ordinary breakpoints.
669 Throw if any such commands is found. */
672 check_no_tracepoint_commands (struct command_line *commands)
674 struct command_line *c;
676 for (c = commands; c; c = c->next)
680 if (c->control_type == while_stepping_control)
681 error (_("The 'while-stepping' command can "
682 "only be used for tracepoints"));
684 for (i = 0; i < c->body_count; ++i)
685 check_no_tracepoint_commands ((c->body_list)[i]);
687 /* Not that command parsing removes leading whitespace and comment
688 lines and also empty lines. So, we only need to check for
690 if (strstr (c->line, "collect ") == c->line)
691 error (_("The 'collect' command can only be used for tracepoints"));
693 if (strstr (c->line, "teval ") == c->line)
694 error (_("The 'teval' command can only be used for tracepoints"));
698 /* Encapsulate tests for different types of tracepoints. */
701 is_tracepoint (const struct breakpoint *b)
703 return (b->type == bp_tracepoint
704 || b->type == bp_fast_tracepoint
705 || b->type == bp_static_tracepoint);
708 /* A helper function that validsates that COMMANDS are valid for a
709 breakpoint. This function will throw an exception if a problem is
713 validate_commands_for_breakpoint (struct breakpoint *b,
714 struct command_line *commands)
716 if (is_tracepoint (b))
718 /* We need to verify that each top-level element of commands is
719 valid for tracepoints, that there's at most one
720 while-stepping element, and that while-stepping's body has
721 valid tracing commands excluding nested while-stepping. */
722 struct command_line *c;
723 struct command_line *while_stepping = 0;
724 for (c = commands; c; c = c->next)
726 if (c->control_type == while_stepping_control)
728 if (b->type == bp_fast_tracepoint)
729 error (_("The 'while-stepping' command "
730 "cannot be used for fast tracepoint"));
731 else if (b->type == bp_static_tracepoint)
732 error (_("The 'while-stepping' command "
733 "cannot be used for static tracepoint"));
736 error (_("The 'while-stepping' command "
737 "can be used only once"));
744 struct command_line *c2;
746 gdb_assert (while_stepping->body_count == 1);
747 c2 = while_stepping->body_list[0];
748 for (; c2; c2 = c2->next)
750 if (c2->control_type == while_stepping_control)
751 error (_("The 'while-stepping' command cannot be nested"));
757 check_no_tracepoint_commands (commands);
761 /* Return a vector of all the static tracepoints set at ADDR. The
762 caller is responsible for releasing the vector. */
765 static_tracepoints_here (CORE_ADDR addr)
767 struct breakpoint *b;
768 VEC(breakpoint_p) *found = 0;
769 struct bp_location *loc;
772 if (b->type == bp_static_tracepoint)
774 for (loc = b->loc; loc; loc = loc->next)
775 if (loc->address == addr)
776 VEC_safe_push(breakpoint_p, found, b);
782 /* Set the command list of B to COMMANDS. If breakpoint is tracepoint,
783 validate that only allowed commands are included. */
786 breakpoint_set_commands (struct breakpoint *b,
787 struct command_line *commands)
789 validate_commands_for_breakpoint (b, commands);
791 decref_counted_command_line (&b->commands);
792 b->commands = alloc_counted_command_line (commands);
793 breakpoints_changed ();
794 observer_notify_breakpoint_modified (b);
797 /* Set the internal `silent' flag on the breakpoint. Note that this
798 is not the same as the "silent" that may appear in the breakpoint's
802 breakpoint_set_silent (struct breakpoint *b, int silent)
804 int old_silent = b->silent;
807 if (old_silent != silent)
808 observer_notify_breakpoint_modified (b);
811 /* Set the thread for this breakpoint. If THREAD is -1, make the
812 breakpoint work for any thread. */
815 breakpoint_set_thread (struct breakpoint *b, int thread)
817 int old_thread = b->thread;
820 if (old_thread != thread)
821 observer_notify_breakpoint_modified (b);
824 /* Set the task for this breakpoint. If TASK is 0, make the
825 breakpoint work for any task. */
828 breakpoint_set_task (struct breakpoint *b, int task)
830 int old_task = b->task;
833 if (old_task != task)
834 observer_notify_breakpoint_modified (b);
838 check_tracepoint_command (char *line, void *closure)
840 struct breakpoint *b = closure;
842 validate_actionline (&line, b);
845 /* A structure used to pass information through
846 map_breakpoint_numbers. */
850 /* True if the command was typed at a tty. */
853 /* The breakpoint range spec. */
856 /* Non-NULL if the body of the commands are being read from this
857 already-parsed command. */
858 struct command_line *control;
860 /* The command lines read from the user, or NULL if they have not
862 struct counted_command_line *cmd;
865 /* A callback for map_breakpoint_numbers that sets the commands for
869 do_map_commands_command (struct breakpoint *b, void *data)
871 struct commands_info *info = data;
873 if (info->cmd == NULL)
875 struct command_line *l;
877 if (info->control != NULL)
878 l = copy_command_lines (info->control->body_list[0]);
881 struct cleanup *old_chain;
884 str = xstrprintf (_("Type commands for breakpoint(s) "
885 "%s, one per line."),
888 old_chain = make_cleanup (xfree, str);
890 l = read_command_lines (str,
893 ? check_tracepoint_command : 0),
896 do_cleanups (old_chain);
899 info->cmd = alloc_counted_command_line (l);
902 /* If a breakpoint was on the list more than once, we don't need to
904 if (b->commands != info->cmd)
906 validate_commands_for_breakpoint (b, info->cmd->commands);
907 incref_counted_command_line (info->cmd);
908 decref_counted_command_line (&b->commands);
909 b->commands = info->cmd;
910 breakpoints_changed ();
911 observer_notify_breakpoint_modified (b);
916 commands_command_1 (char *arg, int from_tty,
917 struct command_line *control)
919 struct cleanup *cleanups;
920 struct commands_info info;
922 info.from_tty = from_tty;
923 info.control = control;
925 /* If we read command lines from the user, then `info' will hold an
926 extra reference to the commands that we must clean up. */
927 cleanups = make_cleanup_decref_counted_command_line (&info.cmd);
929 if (arg == NULL || !*arg)
931 if (breakpoint_count - prev_breakpoint_count > 1)
932 arg = xstrprintf ("%d-%d", prev_breakpoint_count + 1,
934 else if (breakpoint_count > 0)
935 arg = xstrprintf ("%d", breakpoint_count);
938 /* So that we don't try to free the incoming non-NULL
939 argument in the cleanup below. Mapping breakpoint
940 numbers will fail in this case. */
945 /* The command loop has some static state, so we need to preserve
950 make_cleanup (xfree, arg);
954 map_breakpoint_numbers (arg, do_map_commands_command, &info);
956 if (info.cmd == NULL)
957 error (_("No breakpoints specified."));
959 do_cleanups (cleanups);
963 commands_command (char *arg, int from_tty)
965 commands_command_1 (arg, from_tty, NULL);
968 /* Like commands_command, but instead of reading the commands from
969 input stream, takes them from an already parsed command structure.
971 This is used by cli-script.c to DTRT with breakpoint commands
972 that are part of if and while bodies. */
973 enum command_control_type
974 commands_from_control_command (char *arg, struct command_line *cmd)
976 commands_command_1 (arg, 0, cmd);
977 return simple_control;
980 /* Return non-zero if BL->TARGET_INFO contains valid information. */
983 bp_location_has_shadow (struct bp_location *bl)
985 if (bl->loc_type != bp_loc_software_breakpoint)
989 if (bl->target_info.shadow_len == 0)
990 /* bp isn't valid, or doesn't shadow memory. */
995 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
996 by replacing any memory breakpoints with their shadowed contents.
998 The range of shadowed area by each bp_location is:
999 bl->address - bp_location_placed_address_before_address_max
1000 up to bl->address + bp_location_shadow_len_after_address_max
1001 The range we were requested to resolve shadows for is:
1002 memaddr ... memaddr + len
1003 Thus the safe cutoff boundaries for performance optimization are
1004 memaddr + len <= (bl->address
1005 - bp_location_placed_address_before_address_max)
1007 bl->address + bp_location_shadow_len_after_address_max <= memaddr */
1010 breakpoint_restore_shadows (gdb_byte *buf, ULONGEST memaddr, LONGEST len)
1012 /* Left boundary, right boundary and median element of our binary
1014 unsigned bc_l, bc_r, bc;
1016 /* Find BC_L which is a leftmost element which may affect BUF
1017 content. It is safe to report lower value but a failure to
1018 report higher one. */
1021 bc_r = bp_location_count;
1022 while (bc_l + 1 < bc_r)
1024 struct bp_location *bl;
1026 bc = (bc_l + bc_r) / 2;
1027 bl = bp_location[bc];
1029 /* Check first BL->ADDRESS will not overflow due to the added
1030 constant. Then advance the left boundary only if we are sure
1031 the BC element can in no way affect the BUF content (MEMADDR
1032 to MEMADDR + LEN range).
1034 Use the BP_LOCATION_SHADOW_LEN_AFTER_ADDRESS_MAX safety
1035 offset so that we cannot miss a breakpoint with its shadow
1036 range tail still reaching MEMADDR. */
1038 if ((bl->address + bp_location_shadow_len_after_address_max
1040 && (bl->address + bp_location_shadow_len_after_address_max
1047 /* Due to the binary search above, we need to make sure we pick the
1048 first location that's at BC_L's address. E.g., if there are
1049 multiple locations at the same address, BC_L may end up pointing
1050 at a duplicate location, and miss the "master"/"inserted"
1051 location. Say, given locations L1, L2 and L3 at addresses A and
1054 L1@A, L2@A, L3@B, ...
1056 BC_L could end up pointing at location L2, while the "master"
1057 location could be L1. Since the `loc->inserted' flag is only set
1058 on "master" locations, we'd forget to restore the shadow of L1
1061 && bp_location[bc_l]->address == bp_location[bc_l - 1]->address)
1064 /* Now do full processing of the found relevant range of elements. */
1066 for (bc = bc_l; bc < bp_location_count; bc++)
1068 struct bp_location *bl = bp_location[bc];
1069 CORE_ADDR bp_addr = 0;
1073 /* bp_location array has BL->OWNER always non-NULL. */
1074 if (bl->owner->type == bp_none)
1075 warning (_("reading through apparently deleted breakpoint #%d?"),
1078 /* Performance optimization: any futher element can no longer affect BUF
1081 if (bl->address >= bp_location_placed_address_before_address_max
1082 && memaddr + len <= (bl->address
1083 - bp_location_placed_address_before_address_max))
1086 if (!bp_location_has_shadow (bl))
1088 if (!breakpoint_address_match (bl->target_info.placed_address_space, 0,
1089 current_program_space->aspace, 0))
1092 /* Addresses and length of the part of the breakpoint that
1094 bp_addr = bl->target_info.placed_address;
1095 bp_size = bl->target_info.shadow_len;
1097 if (bp_addr + bp_size <= memaddr)
1098 /* The breakpoint is entirely before the chunk of memory we
1102 if (bp_addr >= memaddr + len)
1103 /* The breakpoint is entirely after the chunk of memory we are
1107 /* Offset within shadow_contents. */
1108 if (bp_addr < memaddr)
1110 /* Only copy the second part of the breakpoint. */
1111 bp_size -= memaddr - bp_addr;
1112 bptoffset = memaddr - bp_addr;
1116 if (bp_addr + bp_size > memaddr + len)
1118 /* Only copy the first part of the breakpoint. */
1119 bp_size -= (bp_addr + bp_size) - (memaddr + len);
1122 memcpy (buf + bp_addr - memaddr,
1123 bl->target_info.shadow_contents + bptoffset, bp_size);
1128 /* Return true if BPT is of any hardware watchpoint kind. */
1131 is_hardware_watchpoint (const struct breakpoint *bpt)
1133 return (bpt->type == bp_hardware_watchpoint
1134 || bpt->type == bp_read_watchpoint
1135 || bpt->type == bp_access_watchpoint);
1138 /* Return true if BPT is of any watchpoint kind, hardware or
1142 is_watchpoint (const struct breakpoint *bpt)
1144 return (is_hardware_watchpoint (bpt)
1145 || bpt->type == bp_watchpoint);
1148 /* Assuming that B is a watchpoint: returns true if the current thread
1149 and its running state are safe to evaluate or update watchpoint B.
1150 Watchpoints on local expressions need to be evaluated in the
1151 context of the thread that was current when the watchpoint was
1152 created, and, that thread needs to be stopped to be able to select
1153 the correct frame context. Watchpoints on global expressions can
1154 be evaluated on any thread, and in any state. It is presently left
1155 to the target allowing memory accesses when threads are
1159 watchpoint_in_thread_scope (struct breakpoint *b)
1161 return (ptid_equal (b->watchpoint_thread, null_ptid)
1162 || (ptid_equal (inferior_ptid, b->watchpoint_thread)
1163 && !is_executing (inferior_ptid)));
1166 /* Set watchpoint B to disp_del_at_next_stop, even including its possible
1167 associated bp_watchpoint_scope breakpoint. */
1170 watchpoint_del_at_next_stop (struct breakpoint *b)
1172 gdb_assert (is_watchpoint (b));
1174 if (b->related_breakpoint != b)
1176 gdb_assert (b->related_breakpoint->type == bp_watchpoint_scope);
1177 gdb_assert (b->related_breakpoint->related_breakpoint == b);
1178 b->related_breakpoint->disposition = disp_del_at_next_stop;
1179 b->related_breakpoint->related_breakpoint = b->related_breakpoint;
1180 b->related_breakpoint = b;
1182 b->disposition = disp_del_at_next_stop;
1185 /* Assuming that B is a watchpoint:
1186 - Reparse watchpoint expression, if REPARSE is non-zero
1187 - Evaluate expression and store the result in B->val
1188 - Evaluate the condition if there is one, and store the result
1190 - Update the list of values that must be watched in B->loc.
1192 If the watchpoint disposition is disp_del_at_next_stop, then do
1193 nothing. If this is local watchpoint that is out of scope, delete
1196 Even with `set breakpoint always-inserted on' the watchpoints are
1197 removed + inserted on each stop here. Normal breakpoints must
1198 never be removed because they might be missed by a running thread
1199 when debugging in non-stop mode. On the other hand, hardware
1200 watchpoints (is_hardware_watchpoint; processed here) are specific
1201 to each LWP since they are stored in each LWP's hardware debug
1202 registers. Therefore, such LWP must be stopped first in order to
1203 be able to modify its hardware watchpoints.
1205 Hardware watchpoints must be reset exactly once after being
1206 presented to the user. It cannot be done sooner, because it would
1207 reset the data used to present the watchpoint hit to the user. And
1208 it must not be done later because it could display the same single
1209 watchpoint hit during multiple GDB stops. Note that the latter is
1210 relevant only to the hardware watchpoint types bp_read_watchpoint
1211 and bp_access_watchpoint. False hit by bp_hardware_watchpoint is
1212 not user-visible - its hit is suppressed if the memory content has
1215 The following constraints influence the location where we can reset
1216 hardware watchpoints:
1218 * target_stopped_by_watchpoint and target_stopped_data_address are
1219 called several times when GDB stops.
1222 * Multiple hardware watchpoints can be hit at the same time,
1223 causing GDB to stop. GDB only presents one hardware watchpoint
1224 hit at a time as the reason for stopping, and all the other hits
1225 are presented later, one after the other, each time the user
1226 requests the execution to be resumed. Execution is not resumed
1227 for the threads still having pending hit event stored in
1228 LWP_INFO->STATUS. While the watchpoint is already removed from
1229 the inferior on the first stop the thread hit event is kept being
1230 reported from its cached value by linux_nat_stopped_data_address
1231 until the real thread resume happens after the watchpoint gets
1232 presented and thus its LWP_INFO->STATUS gets reset.
1234 Therefore the hardware watchpoint hit can get safely reset on the
1235 watchpoint removal from inferior. */
1238 update_watchpoint (struct breakpoint *b, int reparse)
1240 int within_current_scope;
1241 struct frame_id saved_frame_id;
1244 gdb_assert (is_watchpoint (b));
1246 /* If this is a local watchpoint, we only want to check if the
1247 watchpoint frame is in scope if the current thread is the thread
1248 that was used to create the watchpoint. */
1249 if (!watchpoint_in_thread_scope (b))
1252 if (b->disposition == disp_del_at_next_stop)
1257 /* Determine if the watchpoint is within scope. */
1258 if (b->exp_valid_block == NULL)
1259 within_current_scope = 1;
1262 struct frame_info *fi = get_current_frame ();
1263 struct gdbarch *frame_arch = get_frame_arch (fi);
1264 CORE_ADDR frame_pc = get_frame_pc (fi);
1266 /* If we're in a function epilogue, unwinding may not work
1267 properly, so do not attempt to recreate locations at this
1268 point. See similar comments in watchpoint_check. */
1269 if (gdbarch_in_function_epilogue_p (frame_arch, frame_pc))
1272 /* Save the current frame's ID so we can restore it after
1273 evaluating the watchpoint expression on its own frame. */
1274 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
1275 took a frame parameter, so that we didn't have to change the
1278 saved_frame_id = get_frame_id (get_selected_frame (NULL));
1280 fi = frame_find_by_id (b->watchpoint_frame);
1281 within_current_scope = (fi != NULL);
1282 if (within_current_scope)
1286 /* We don't free locations. They are stored in the bp_location array
1287 and update_global_location_list will eventually delete them and
1288 remove breakpoints if needed. */
1291 if (within_current_scope && reparse)
1300 s = b->exp_string_reparse ? b->exp_string_reparse : b->exp_string;
1301 b->exp = parse_exp_1 (&s, b->exp_valid_block, 0);
1302 /* If the meaning of expression itself changed, the old value is
1303 no longer relevant. We don't want to report a watchpoint hit
1304 to the user when the old value and the new value may actually
1305 be completely different objects. */
1306 value_free (b->val);
1310 /* Note that unlike with breakpoints, the watchpoint's condition
1311 expression is stored in the breakpoint object, not in the
1312 locations (re)created below. */
1313 if (b->cond_string != NULL)
1315 if (b->cond_exp != NULL)
1317 xfree (b->cond_exp);
1322 b->cond_exp = parse_exp_1 (&s, b->cond_exp_valid_block, 0);
1326 /* If we failed to parse the expression, for example because
1327 it refers to a global variable in a not-yet-loaded shared library,
1328 don't try to insert watchpoint. We don't automatically delete
1329 such watchpoint, though, since failure to parse expression
1330 is different from out-of-scope watchpoint. */
1331 if ( !target_has_execution)
1333 /* Without execution, memory can't change. No use to try and
1334 set watchpoint locations. The watchpoint will be reset when
1335 the target gains execution, through breakpoint_re_set. */
1337 else if (within_current_scope && b->exp)
1340 struct value *val_chain, *v, *result, *next;
1341 struct program_space *frame_pspace;
1343 fetch_subexp_value (b->exp, &pc, &v, &result, &val_chain);
1345 /* Avoid setting b->val if it's already set. The meaning of
1346 b->val is 'the last value' user saw, and we should update
1347 it only if we reported that last value to user. As it
1348 happens, the code that reports it updates b->val directly. */
1355 frame_pspace = get_frame_program_space (get_selected_frame (NULL));
1357 /* Look at each value on the value chain. */
1358 for (v = val_chain; v; v = value_next (v))
1360 /* If it's a memory location, and GDB actually needed
1361 its contents to evaluate the expression, then we
1362 must watch it. If the first value returned is
1363 still lazy, that means an error occurred reading it;
1364 watch it anyway in case it becomes readable. */
1365 if (VALUE_LVAL (v) == lval_memory
1366 && (v == val_chain || ! value_lazy (v)))
1368 struct type *vtype = check_typedef (value_type (v));
1370 /* We only watch structs and arrays if user asked
1371 for it explicitly, never if they just happen to
1372 appear in the middle of some value chain. */
1374 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
1375 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
1379 struct bp_location *loc, **tmp;
1381 addr = value_address (v);
1382 len = TYPE_LENGTH (value_type (v));
1384 if (b->type == bp_read_watchpoint)
1386 else if (b->type == bp_access_watchpoint)
1389 loc = allocate_bp_location (b);
1390 for (tmp = &(b->loc); *tmp != NULL; tmp = &((*tmp)->next))
1393 loc->gdbarch = get_type_arch (value_type (v));
1395 loc->pspace = frame_pspace;
1396 loc->address = addr;
1398 loc->watchpoint_type = type;
1403 /* Change the type of breakpoint between hardware assisted or
1404 an ordinary watchpoint depending on the hardware support
1405 and free hardware slots. REPARSE is set when the inferior
1407 if ((b->type == bp_watchpoint || b->type == bp_hardware_watchpoint)
1411 enum bp_loc_type loc_type;
1412 struct bp_location *bl;
1414 reg_cnt = can_use_hardware_watchpoint (val_chain, b->exact);
1418 int i, target_resources_ok, other_type_used;
1420 /* We need to determine how many resources are already
1421 used for all other hardware watchpoints plus this one
1422 to see if we still have enough resources to also fit
1423 this watchpoint in as well. To guarantee the
1424 hw_watchpoint_used_count call below counts this
1425 watchpoint, make sure that it is marked as a hardware
1427 b->type = bp_hardware_watchpoint;
1429 i = hw_watchpoint_used_count (bp_hardware_watchpoint,
1432 target_resources_ok = target_can_use_hardware_watchpoint
1433 (bp_hardware_watchpoint, i, other_type_used);
1434 if (target_resources_ok <= 0)
1435 b->type = bp_watchpoint;
1438 b->type = bp_watchpoint;
1440 loc_type = (b->type == bp_watchpoint? bp_loc_other
1441 : bp_loc_hardware_watchpoint);
1442 for (bl = b->loc; bl; bl = bl->next)
1443 bl->loc_type = loc_type;
1446 for (v = val_chain; v; v = next)
1448 next = value_next (v);
1453 /* If a software watchpoint is not watching any memory, then the
1454 above left it without any location set up. But,
1455 bpstat_stop_status requires a location to be able to report
1456 stops, so make sure there's at least a dummy one. */
1457 if (b->type == bp_watchpoint && b->loc == NULL)
1459 b->loc = allocate_bp_location (b);
1460 b->loc->pspace = frame_pspace;
1461 b->loc->address = -1;
1462 b->loc->length = -1;
1463 b->loc->watchpoint_type = -1;
1466 else if (!within_current_scope)
1468 printf_filtered (_("\
1469 Watchpoint %d deleted because the program has left the block\n\
1470 in which its expression is valid.\n"),
1472 watchpoint_del_at_next_stop (b);
1475 /* Restore the selected frame. */
1477 select_frame (frame_find_by_id (saved_frame_id));
1481 /* Returns 1 iff breakpoint location should be
1482 inserted in the inferior. */
1484 should_be_inserted (struct bp_location *bl)
1486 if (bl->owner == NULL || !breakpoint_enabled (bl->owner))
1489 if (bl->owner->disposition == disp_del_at_next_stop)
1492 if (!bl->enabled || bl->shlib_disabled || bl->duplicate)
1495 /* This is set for example, when we're attached to the parent of a
1496 vfork, and have detached from the child. The child is running
1497 free, and we expect it to do an exec or exit, at which point the
1498 OS makes the parent schedulable again (and the target reports
1499 that the vfork is done). Until the child is done with the shared
1500 memory region, do not insert breakpoints in the parent, otherwise
1501 the child could still trip on the parent's breakpoints. Since
1502 the parent is blocked anyway, it won't miss any breakpoint. */
1503 if (bl->pspace->breakpoints_not_allowed)
1506 /* Tracepoints are inserted by the target at a time of its choosing,
1508 if (is_tracepoint (bl->owner))
1514 /* Insert a low-level "breakpoint" of some type. BL is the breakpoint
1515 location. Any error messages are printed to TMP_ERROR_STREAM; and
1516 DISABLED_BREAKS, and HW_BREAKPOINT_ERROR are used to report problems.
1518 NOTE drow/2003-09-09: This routine could be broken down to an
1519 object-style method for each breakpoint or catchpoint type. */
1521 insert_bp_location (struct bp_location *bl,
1522 struct ui_file *tmp_error_stream,
1523 int *disabled_breaks,
1524 int *hw_breakpoint_error)
1528 if (!should_be_inserted (bl) || bl->inserted)
1531 /* Initialize the target-specific information. */
1532 memset (&bl->target_info, 0, sizeof (bl->target_info));
1533 bl->target_info.placed_address = bl->address;
1534 bl->target_info.placed_address_space = bl->pspace->aspace;
1535 bl->target_info.length = bl->length;
1537 if (bl->loc_type == bp_loc_software_breakpoint
1538 || bl->loc_type == bp_loc_hardware_breakpoint)
1540 if (bl->owner->type != bp_hardware_breakpoint)
1542 /* If the explicitly specified breakpoint type
1543 is not hardware breakpoint, check the memory map to see
1544 if the breakpoint address is in read only memory or not.
1546 Two important cases are:
1547 - location type is not hardware breakpoint, memory
1548 is readonly. We change the type of the location to
1549 hardware breakpoint.
1550 - location type is hardware breakpoint, memory is
1551 read-write. This means we've previously made the
1552 location hardware one, but then the memory map changed,
1555 When breakpoints are removed, remove_breakpoints will use
1556 location types we've just set here, the only possible
1557 problem is that memory map has changed during running
1558 program, but it's not going to work anyway with current
1560 struct mem_region *mr
1561 = lookup_mem_region (bl->target_info.placed_address);
1565 if (automatic_hardware_breakpoints)
1567 enum bp_loc_type new_type;
1569 if (mr->attrib.mode != MEM_RW)
1570 new_type = bp_loc_hardware_breakpoint;
1572 new_type = bp_loc_software_breakpoint;
1574 if (new_type != bl->loc_type)
1576 static int said = 0;
1578 bl->loc_type = new_type;
1581 fprintf_filtered (gdb_stdout,
1582 _("Note: automatically using "
1583 "hardware breakpoints for "
1584 "read-only addresses.\n"));
1589 else if (bl->loc_type == bp_loc_software_breakpoint
1590 && mr->attrib.mode != MEM_RW)
1591 warning (_("cannot set software breakpoint "
1592 "at readonly address %s"),
1593 paddress (bl->gdbarch, bl->address));
1597 /* First check to see if we have to handle an overlay. */
1598 if (overlay_debugging == ovly_off
1599 || bl->section == NULL
1600 || !(section_is_overlay (bl->section)))
1602 /* No overlay handling: just set the breakpoint. */
1604 if (bl->loc_type == bp_loc_hardware_breakpoint)
1605 val = target_insert_hw_breakpoint (bl->gdbarch,
1608 val = target_insert_breakpoint (bl->gdbarch,
1613 /* This breakpoint is in an overlay section.
1614 Shall we set a breakpoint at the LMA? */
1615 if (!overlay_events_enabled)
1617 /* Yes -- overlay event support is not active,
1618 so we must try to set a breakpoint at the LMA.
1619 This will not work for a hardware breakpoint. */
1620 if (bl->loc_type == bp_loc_hardware_breakpoint)
1621 warning (_("hardware breakpoint %d not supported in overlay!"),
1625 CORE_ADDR addr = overlay_unmapped_address (bl->address,
1627 /* Set a software (trap) breakpoint at the LMA. */
1628 bl->overlay_target_info = bl->target_info;
1629 bl->overlay_target_info.placed_address = addr;
1630 val = target_insert_breakpoint (bl->gdbarch,
1631 &bl->overlay_target_info);
1633 fprintf_unfiltered (tmp_error_stream,
1634 "Overlay breakpoint %d "
1635 "failed: in ROM?\n",
1639 /* Shall we set a breakpoint at the VMA? */
1640 if (section_is_mapped (bl->section))
1642 /* Yes. This overlay section is mapped into memory. */
1643 if (bl->loc_type == bp_loc_hardware_breakpoint)
1644 val = target_insert_hw_breakpoint (bl->gdbarch,
1647 val = target_insert_breakpoint (bl->gdbarch,
1652 /* No. This breakpoint will not be inserted.
1653 No error, but do not mark the bp as 'inserted'. */
1660 /* Can't set the breakpoint. */
1661 if (solib_name_from_address (bl->pspace, bl->address))
1663 /* See also: disable_breakpoints_in_shlibs. */
1665 bl->shlib_disabled = 1;
1666 observer_notify_breakpoint_modified (bl->owner);
1667 if (!*disabled_breaks)
1669 fprintf_unfiltered (tmp_error_stream,
1670 "Cannot insert breakpoint %d.\n",
1672 fprintf_unfiltered (tmp_error_stream,
1673 "Temporarily disabling shared "
1674 "library breakpoints:\n");
1676 *disabled_breaks = 1;
1677 fprintf_unfiltered (tmp_error_stream,
1678 "breakpoint #%d\n", bl->owner->number);
1682 if (bl->loc_type == bp_loc_hardware_breakpoint)
1684 *hw_breakpoint_error = 1;
1685 fprintf_unfiltered (tmp_error_stream,
1686 "Cannot insert hardware "
1692 fprintf_unfiltered (tmp_error_stream,
1693 "Cannot insert breakpoint %d.\n",
1695 fprintf_filtered (tmp_error_stream,
1696 "Error accessing memory address ");
1697 fputs_filtered (paddress (bl->gdbarch, bl->address),
1699 fprintf_filtered (tmp_error_stream, ": %s.\n",
1700 safe_strerror (val));
1711 else if (bl->loc_type == bp_loc_hardware_watchpoint
1712 /* NOTE drow/2003-09-08: This state only exists for removing
1713 watchpoints. It's not clear that it's necessary... */
1714 && bl->owner->disposition != disp_del_at_next_stop)
1716 gdb_assert (bl->owner->ops != NULL
1717 && bl->owner->ops->insert_location != NULL);
1719 val = bl->owner->ops->insert_location (bl);
1721 /* If trying to set a read-watchpoint, and it turns out it's not
1722 supported, try emulating one with an access watchpoint. */
1723 if (val == 1 && bl->watchpoint_type == hw_read)
1725 struct bp_location *loc, **loc_temp;
1727 /* But don't try to insert it, if there's already another
1728 hw_access location that would be considered a duplicate
1730 ALL_BP_LOCATIONS (loc, loc_temp)
1732 && loc->watchpoint_type == hw_access
1733 && watchpoint_locations_match (bl, loc))
1737 bl->target_info = loc->target_info;
1738 bl->watchpoint_type = hw_access;
1745 bl->watchpoint_type = hw_access;
1746 val = bl->owner->ops->insert_location (bl);
1749 /* Back to the original value. */
1750 bl->watchpoint_type = hw_read;
1754 bl->inserted = (val == 0);
1757 else if (bl->owner->type == bp_catchpoint)
1759 gdb_assert (bl->owner->ops != NULL
1760 && bl->owner->ops->insert_location != NULL);
1762 val = bl->owner->ops->insert_location (bl);
1765 bl->owner->enable_state = bp_disabled;
1769 Error inserting catchpoint %d: Your system does not support this type\n\
1770 of catchpoint."), bl->owner->number);
1772 warning (_("Error inserting catchpoint %d."), bl->owner->number);
1775 bl->inserted = (val == 0);
1777 /* We've already printed an error message if there was a problem
1778 inserting this catchpoint, and we've disabled the catchpoint,
1779 so just return success. */
1786 /* This function is called when program space PSPACE is about to be
1787 deleted. It takes care of updating breakpoints to not reference
1791 breakpoint_program_space_exit (struct program_space *pspace)
1793 struct breakpoint *b, *b_temp;
1794 struct bp_location *loc, **loc_temp;
1796 /* Remove any breakpoint that was set through this program space. */
1797 ALL_BREAKPOINTS_SAFE (b, b_temp)
1799 if (b->pspace == pspace)
1800 delete_breakpoint (b);
1803 /* Breakpoints set through other program spaces could have locations
1804 bound to PSPACE as well. Remove those. */
1805 ALL_BP_LOCATIONS (loc, loc_temp)
1807 struct bp_location *tmp;
1809 if (loc->pspace == pspace)
1811 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
1812 if (loc->owner->loc == loc)
1813 loc->owner->loc = loc->next;
1815 for (tmp = loc->owner->loc; tmp->next != NULL; tmp = tmp->next)
1816 if (tmp->next == loc)
1818 tmp->next = loc->next;
1824 /* Now update the global location list to permanently delete the
1825 removed locations above. */
1826 update_global_location_list (0);
1829 /* Make sure all breakpoints are inserted in inferior.
1830 Throws exception on any error.
1831 A breakpoint that is already inserted won't be inserted
1832 again, so calling this function twice is safe. */
1834 insert_breakpoints (void)
1836 struct breakpoint *bpt;
1838 ALL_BREAKPOINTS (bpt)
1839 if (is_hardware_watchpoint (bpt))
1840 update_watchpoint (bpt, 0 /* don't reparse. */);
1842 update_global_location_list (1);
1844 /* update_global_location_list does not insert breakpoints when
1845 always_inserted_mode is not enabled. Explicitly insert them
1847 if (!breakpoints_always_inserted_mode ())
1848 insert_breakpoint_locations ();
1851 /* insert_breakpoints is used when starting or continuing the program.
1852 remove_breakpoints is used when the program stops.
1853 Both return zero if successful,
1854 or an `errno' value if could not write the inferior. */
1857 insert_breakpoint_locations (void)
1859 struct breakpoint *bpt;
1860 struct bp_location *bl, **blp_tmp;
1863 int disabled_breaks = 0;
1864 int hw_breakpoint_error = 0;
1866 struct ui_file *tmp_error_stream = mem_fileopen ();
1867 struct cleanup *cleanups = make_cleanup_ui_file_delete (tmp_error_stream);
1869 /* Explicitly mark the warning -- this will only be printed if
1870 there was an error. */
1871 fprintf_unfiltered (tmp_error_stream, "Warning:\n");
1873 save_current_space_and_thread ();
1875 ALL_BP_LOCATIONS (bl, blp_tmp)
1877 if (!should_be_inserted (bl) || bl->inserted)
1880 /* There is no point inserting thread-specific breakpoints if
1881 the thread no longer exists. ALL_BP_LOCATIONS bp_location
1882 has BL->OWNER always non-NULL. */
1883 if (bl->owner->thread != -1
1884 && !valid_thread_id (bl->owner->thread))
1887 switch_to_program_space_and_thread (bl->pspace);
1889 /* For targets that support global breakpoints, there's no need
1890 to select an inferior to insert breakpoint to. In fact, even
1891 if we aren't attached to any process yet, we should still
1892 insert breakpoints. */
1893 if (!gdbarch_has_global_breakpoints (target_gdbarch)
1894 && ptid_equal (inferior_ptid, null_ptid))
1897 val = insert_bp_location (bl, tmp_error_stream, &disabled_breaks,
1898 &hw_breakpoint_error);
1903 /* If we failed to insert all locations of a watchpoint, remove
1904 them, as half-inserted watchpoint is of limited use. */
1905 ALL_BREAKPOINTS (bpt)
1907 int some_failed = 0;
1908 struct bp_location *loc;
1910 if (!is_hardware_watchpoint (bpt))
1913 if (!breakpoint_enabled (bpt))
1916 if (bpt->disposition == disp_del_at_next_stop)
1919 for (loc = bpt->loc; loc; loc = loc->next)
1920 if (!loc->inserted && should_be_inserted (loc))
1927 for (loc = bpt->loc; loc; loc = loc->next)
1929 remove_breakpoint (loc, mark_uninserted);
1931 hw_breakpoint_error = 1;
1932 fprintf_unfiltered (tmp_error_stream,
1933 "Could not insert hardware watchpoint %d.\n",
1941 /* If a hardware breakpoint or watchpoint was inserted, add a
1942 message about possibly exhausted resources. */
1943 if (hw_breakpoint_error)
1945 fprintf_unfiltered (tmp_error_stream,
1946 "Could not insert hardware breakpoints:\n\
1947 You may have requested too many hardware breakpoints/watchpoints.\n");
1949 target_terminal_ours_for_output ();
1950 error_stream (tmp_error_stream);
1953 do_cleanups (cleanups);
1957 remove_breakpoints (void)
1959 struct bp_location *bl, **blp_tmp;
1962 ALL_BP_LOCATIONS (bl, blp_tmp)
1965 val |= remove_breakpoint (bl, mark_uninserted);
1970 /* Remove breakpoints of process PID. */
1973 remove_breakpoints_pid (int pid)
1975 struct bp_location *bl, **blp_tmp;
1977 struct inferior *inf = find_inferior_pid (pid);
1979 ALL_BP_LOCATIONS (bl, blp_tmp)
1981 if (bl->pspace != inf->pspace)
1986 val = remove_breakpoint (bl, mark_uninserted);
1995 remove_hw_watchpoints (void)
1997 struct bp_location *bl, **blp_tmp;
2000 ALL_BP_LOCATIONS (bl, blp_tmp)
2002 if (bl->inserted && bl->loc_type == bp_loc_hardware_watchpoint)
2003 val |= remove_breakpoint (bl, mark_uninserted);
2009 reattach_breakpoints (int pid)
2011 struct cleanup *old_chain;
2012 struct bp_location *bl, **blp_tmp;
2014 struct ui_file *tmp_error_stream;
2015 int dummy1 = 0, dummy2 = 0;
2016 struct inferior *inf;
2017 struct thread_info *tp;
2019 tp = any_live_thread_of_process (pid);
2023 inf = find_inferior_pid (pid);
2024 old_chain = save_inferior_ptid ();
2026 inferior_ptid = tp->ptid;
2028 tmp_error_stream = mem_fileopen ();
2029 make_cleanup_ui_file_delete (tmp_error_stream);
2031 ALL_BP_LOCATIONS (bl, blp_tmp)
2033 if (bl->pspace != inf->pspace)
2039 val = insert_bp_location (bl, tmp_error_stream, &dummy1, &dummy2);
2042 do_cleanups (old_chain);
2047 do_cleanups (old_chain);
2051 static int internal_breakpoint_number = -1;
2053 /* Set the breakpoint number of B, depending on the value of INTERNAL.
2054 If INTERNAL is non-zero, the breakpoint number will be populated
2055 from internal_breakpoint_number and that variable decremented.
2056 Otherwis the breakpoint number will be populated from
2057 breakpoint_count and that value incremented. Internal breakpoints
2058 do not set the internal var bpnum. */
2060 set_breakpoint_number (int internal, struct breakpoint *b)
2063 b->number = internal_breakpoint_number--;
2066 set_breakpoint_count (breakpoint_count + 1);
2067 b->number = breakpoint_count;
2071 static struct breakpoint *
2072 create_internal_breakpoint (struct gdbarch *gdbarch,
2073 CORE_ADDR address, enum bptype type)
2075 struct symtab_and_line sal;
2076 struct breakpoint *b;
2078 init_sal (&sal); /* Initialize to zeroes. */
2081 sal.section = find_pc_overlay (sal.pc);
2082 sal.pspace = current_program_space;
2084 b = set_raw_breakpoint (gdbarch, sal, type);
2085 b->number = internal_breakpoint_number--;
2086 b->disposition = disp_donttouch;
2091 static const char *const longjmp_names[] =
2093 "longjmp", "_longjmp", "siglongjmp", "_siglongjmp"
2095 #define NUM_LONGJMP_NAMES ARRAY_SIZE(longjmp_names)
2097 /* Per-objfile data private to breakpoint.c. */
2098 struct breakpoint_objfile_data
2100 /* Minimal symbol for "_ovly_debug_event" (if any). */
2101 struct minimal_symbol *overlay_msym;
2103 /* Minimal symbol(s) for "longjmp", "siglongjmp", etc. (if any). */
2104 struct minimal_symbol *longjmp_msym[NUM_LONGJMP_NAMES];
2106 /* Minimal symbol for "std::terminate()" (if any). */
2107 struct minimal_symbol *terminate_msym;
2109 /* Minimal symbol for "_Unwind_DebugHook" (if any). */
2110 struct minimal_symbol *exception_msym;
2113 static const struct objfile_data *breakpoint_objfile_key;
2115 /* Minimal symbol not found sentinel. */
2116 static struct minimal_symbol msym_not_found;
2118 /* Returns TRUE if MSYM point to the "not found" sentinel. */
2121 msym_not_found_p (const struct minimal_symbol *msym)
2123 return msym == &msym_not_found;
2126 /* Return per-objfile data needed by breakpoint.c.
2127 Allocate the data if necessary. */
2129 static struct breakpoint_objfile_data *
2130 get_breakpoint_objfile_data (struct objfile *objfile)
2132 struct breakpoint_objfile_data *bp_objfile_data;
2134 bp_objfile_data = objfile_data (objfile, breakpoint_objfile_key);
2135 if (bp_objfile_data == NULL)
2137 bp_objfile_data = obstack_alloc (&objfile->objfile_obstack,
2138 sizeof (*bp_objfile_data));
2140 memset (bp_objfile_data, 0, sizeof (*bp_objfile_data));
2141 set_objfile_data (objfile, breakpoint_objfile_key, bp_objfile_data);
2143 return bp_objfile_data;
2147 create_overlay_event_breakpoint (void)
2149 struct objfile *objfile;
2150 const char *const func_name = "_ovly_debug_event";
2152 ALL_OBJFILES (objfile)
2154 struct breakpoint *b;
2155 struct breakpoint_objfile_data *bp_objfile_data;
2158 bp_objfile_data = get_breakpoint_objfile_data (objfile);
2160 if (msym_not_found_p (bp_objfile_data->overlay_msym))
2163 if (bp_objfile_data->overlay_msym == NULL)
2165 struct minimal_symbol *m;
2167 m = lookup_minimal_symbol_text (func_name, objfile);
2170 /* Avoid future lookups in this objfile. */
2171 bp_objfile_data->overlay_msym = &msym_not_found;
2174 bp_objfile_data->overlay_msym = m;
2177 addr = SYMBOL_VALUE_ADDRESS (bp_objfile_data->overlay_msym);
2178 b = create_internal_breakpoint (get_objfile_arch (objfile), addr,
2180 b->addr_string = xstrdup (func_name);
2182 if (overlay_debugging == ovly_auto)
2184 b->enable_state = bp_enabled;
2185 overlay_events_enabled = 1;
2189 b->enable_state = bp_disabled;
2190 overlay_events_enabled = 0;
2193 update_global_location_list (1);
2197 create_longjmp_master_breakpoint (void)
2199 struct program_space *pspace;
2200 struct cleanup *old_chain;
2202 old_chain = save_current_program_space ();
2204 ALL_PSPACES (pspace)
2206 struct objfile *objfile;
2208 set_current_program_space (pspace);
2210 ALL_OBJFILES (objfile)
2213 struct gdbarch *gdbarch;
2214 struct breakpoint_objfile_data *bp_objfile_data;
2216 gdbarch = get_objfile_arch (objfile);
2217 if (!gdbarch_get_longjmp_target_p (gdbarch))
2220 bp_objfile_data = get_breakpoint_objfile_data (objfile);
2222 for (i = 0; i < NUM_LONGJMP_NAMES; i++)
2224 struct breakpoint *b;
2225 const char *func_name;
2228 if (msym_not_found_p (bp_objfile_data->longjmp_msym[i]))
2231 func_name = longjmp_names[i];
2232 if (bp_objfile_data->longjmp_msym[i] == NULL)
2234 struct minimal_symbol *m;
2236 m = lookup_minimal_symbol_text (func_name, objfile);
2239 /* Prevent future lookups in this objfile. */
2240 bp_objfile_data->longjmp_msym[i] = &msym_not_found;
2243 bp_objfile_data->longjmp_msym[i] = m;
2246 addr = SYMBOL_VALUE_ADDRESS (bp_objfile_data->longjmp_msym[i]);
2247 b = create_internal_breakpoint (gdbarch, addr, bp_longjmp_master);
2248 b->addr_string = xstrdup (func_name);
2249 b->enable_state = bp_disabled;
2253 update_global_location_list (1);
2255 do_cleanups (old_chain);
2258 /* Create a master std::terminate breakpoint. */
2260 create_std_terminate_master_breakpoint (void)
2262 struct program_space *pspace;
2263 struct cleanup *old_chain;
2264 const char *const func_name = "std::terminate()";
2266 old_chain = save_current_program_space ();
2268 ALL_PSPACES (pspace)
2270 struct objfile *objfile;
2273 set_current_program_space (pspace);
2275 ALL_OBJFILES (objfile)
2277 struct breakpoint *b;
2278 struct breakpoint_objfile_data *bp_objfile_data;
2280 bp_objfile_data = get_breakpoint_objfile_data (objfile);
2282 if (msym_not_found_p (bp_objfile_data->terminate_msym))
2285 if (bp_objfile_data->terminate_msym == NULL)
2287 struct minimal_symbol *m;
2289 m = lookup_minimal_symbol (func_name, NULL, objfile);
2290 if (m == NULL || (MSYMBOL_TYPE (m) != mst_text
2291 && MSYMBOL_TYPE (m) != mst_file_text))
2293 /* Prevent future lookups in this objfile. */
2294 bp_objfile_data->terminate_msym = &msym_not_found;
2297 bp_objfile_data->terminate_msym = m;
2300 addr = SYMBOL_VALUE_ADDRESS (bp_objfile_data->terminate_msym);
2301 b = create_internal_breakpoint (get_objfile_arch (objfile), addr,
2302 bp_std_terminate_master);
2303 b->addr_string = xstrdup (func_name);
2304 b->enable_state = bp_disabled;
2308 update_global_location_list (1);
2310 do_cleanups (old_chain);
2313 /* Install a master breakpoint on the unwinder's debug hook. */
2316 create_exception_master_breakpoint (void)
2318 struct objfile *objfile;
2319 const char *const func_name = "_Unwind_DebugHook";
2321 ALL_OBJFILES (objfile)
2323 struct breakpoint *b;
2324 struct gdbarch *gdbarch;
2325 struct breakpoint_objfile_data *bp_objfile_data;
2328 bp_objfile_data = get_breakpoint_objfile_data (objfile);
2330 if (msym_not_found_p (bp_objfile_data->exception_msym))
2333 gdbarch = get_objfile_arch (objfile);
2335 if (bp_objfile_data->exception_msym == NULL)
2337 struct minimal_symbol *debug_hook;
2339 debug_hook = lookup_minimal_symbol (func_name, NULL, objfile);
2340 if (debug_hook == NULL)
2342 bp_objfile_data->exception_msym = &msym_not_found;
2346 bp_objfile_data->exception_msym = debug_hook;
2349 addr = SYMBOL_VALUE_ADDRESS (bp_objfile_data->exception_msym);
2350 addr = gdbarch_convert_from_func_ptr_addr (gdbarch, addr,
2352 b = create_internal_breakpoint (gdbarch, addr, bp_exception_master);
2353 b->addr_string = xstrdup (func_name);
2354 b->enable_state = bp_disabled;
2357 update_global_location_list (1);
2361 update_breakpoints_after_exec (void)
2363 struct breakpoint *b, *b_tmp;
2364 struct bp_location *bploc, **bplocp_tmp;
2366 /* We're about to delete breakpoints from GDB's lists. If the
2367 INSERTED flag is true, GDB will try to lift the breakpoints by
2368 writing the breakpoints' "shadow contents" back into memory. The
2369 "shadow contents" are NOT valid after an exec, so GDB should not
2370 do that. Instead, the target is responsible from marking
2371 breakpoints out as soon as it detects an exec. We don't do that
2372 here instead, because there may be other attempts to delete
2373 breakpoints after detecting an exec and before reaching here. */
2374 ALL_BP_LOCATIONS (bploc, bplocp_tmp)
2375 if (bploc->pspace == current_program_space)
2376 gdb_assert (!bploc->inserted);
2378 ALL_BREAKPOINTS_SAFE (b, b_tmp)
2380 if (b->pspace != current_program_space)
2383 /* Solib breakpoints must be explicitly reset after an exec(). */
2384 if (b->type == bp_shlib_event)
2386 delete_breakpoint (b);
2390 /* JIT breakpoints must be explicitly reset after an exec(). */
2391 if (b->type == bp_jit_event)
2393 delete_breakpoint (b);
2397 /* Thread event breakpoints must be set anew after an exec(),
2398 as must overlay event and longjmp master breakpoints. */
2399 if (b->type == bp_thread_event || b->type == bp_overlay_event
2400 || b->type == bp_longjmp_master || b->type == bp_std_terminate_master
2401 || b->type == bp_exception_master)
2403 delete_breakpoint (b);
2407 /* Step-resume breakpoints are meaningless after an exec(). */
2408 if (b->type == bp_step_resume)
2410 delete_breakpoint (b);
2414 /* Longjmp and longjmp-resume breakpoints are also meaningless
2416 if (b->type == bp_longjmp || b->type == bp_longjmp_resume
2417 || b->type == bp_exception || b->type == bp_exception_resume)
2419 delete_breakpoint (b);
2423 if (b->type == bp_catchpoint)
2425 /* For now, none of the bp_catchpoint breakpoints need to
2426 do anything at this point. In the future, if some of
2427 the catchpoints need to something, we will need to add
2428 a new method, and call this method from here. */
2432 /* bp_finish is a special case. The only way we ought to be able
2433 to see one of these when an exec() has happened, is if the user
2434 caught a vfork, and then said "finish". Ordinarily a finish just
2435 carries them to the call-site of the current callee, by setting
2436 a temporary bp there and resuming. But in this case, the finish
2437 will carry them entirely through the vfork & exec.
2439 We don't want to allow a bp_finish to remain inserted now. But
2440 we can't safely delete it, 'cause finish_command has a handle to
2441 the bp on a bpstat, and will later want to delete it. There's a
2442 chance (and I've seen it happen) that if we delete the bp_finish
2443 here, that its storage will get reused by the time finish_command
2444 gets 'round to deleting the "use to be a bp_finish" breakpoint.
2445 We really must allow finish_command to delete a bp_finish.
2447 In the absense of a general solution for the "how do we know
2448 it's safe to delete something others may have handles to?"
2449 problem, what we'll do here is just uninsert the bp_finish, and
2450 let finish_command delete it.
2452 (We know the bp_finish is "doomed" in the sense that it's
2453 momentary, and will be deleted as soon as finish_command sees
2454 the inferior stopped. So it doesn't matter that the bp's
2455 address is probably bogus in the new a.out, unlike e.g., the
2456 solib breakpoints.) */
2458 if (b->type == bp_finish)
2463 /* Without a symbolic address, we have little hope of the
2464 pre-exec() address meaning the same thing in the post-exec()
2466 if (b->addr_string == NULL)
2468 delete_breakpoint (b);
2472 /* FIXME what about longjmp breakpoints? Re-create them here? */
2473 create_overlay_event_breakpoint ();
2474 create_longjmp_master_breakpoint ();
2475 create_std_terminate_master_breakpoint ();
2476 create_exception_master_breakpoint ();
2480 detach_breakpoints (int pid)
2482 struct bp_location *bl, **blp_tmp;
2484 struct cleanup *old_chain = save_inferior_ptid ();
2485 struct inferior *inf = current_inferior ();
2487 if (pid == PIDGET (inferior_ptid))
2488 error (_("Cannot detach breakpoints of inferior_ptid"));
2490 /* Set inferior_ptid; remove_breakpoint_1 uses this global. */
2491 inferior_ptid = pid_to_ptid (pid);
2492 ALL_BP_LOCATIONS (bl, blp_tmp)
2494 if (bl->pspace != inf->pspace)
2498 val |= remove_breakpoint_1 (bl, mark_inserted);
2501 /* Detach single-step breakpoints as well. */
2502 detach_single_step_breakpoints ();
2504 do_cleanups (old_chain);
2508 /* Remove the breakpoint location BL from the current address space.
2509 Note that this is used to detach breakpoints from a child fork.
2510 When we get here, the child isn't in the inferior list, and neither
2511 do we have objects to represent its address space --- we should
2512 *not* look at bl->pspace->aspace here. */
2515 remove_breakpoint_1 (struct bp_location *bl, insertion_state_t is)
2519 /* BL is never in moribund_locations by our callers. */
2520 gdb_assert (bl->owner != NULL);
2522 if (bl->owner->enable_state == bp_permanent)
2523 /* Permanent breakpoints cannot be inserted or removed. */
2526 /* The type of none suggests that owner is actually deleted.
2527 This should not ever happen. */
2528 gdb_assert (bl->owner->type != bp_none);
2530 if (bl->loc_type == bp_loc_software_breakpoint
2531 || bl->loc_type == bp_loc_hardware_breakpoint)
2533 /* "Normal" instruction breakpoint: either the standard
2534 trap-instruction bp (bp_breakpoint), or a
2535 bp_hardware_breakpoint. */
2537 /* First check to see if we have to handle an overlay. */
2538 if (overlay_debugging == ovly_off
2539 || bl->section == NULL
2540 || !(section_is_overlay (bl->section)))
2542 /* No overlay handling: just remove the breakpoint. */
2544 if (bl->loc_type == bp_loc_hardware_breakpoint)
2545 val = target_remove_hw_breakpoint (bl->gdbarch, &bl->target_info);
2547 val = target_remove_breakpoint (bl->gdbarch, &bl->target_info);
2551 /* This breakpoint is in an overlay section.
2552 Did we set a breakpoint at the LMA? */
2553 if (!overlay_events_enabled)
2555 /* Yes -- overlay event support is not active, so we
2556 should have set a breakpoint at the LMA. Remove it.
2558 /* Ignore any failures: if the LMA is in ROM, we will
2559 have already warned when we failed to insert it. */
2560 if (bl->loc_type == bp_loc_hardware_breakpoint)
2561 target_remove_hw_breakpoint (bl->gdbarch,
2562 &bl->overlay_target_info);
2564 target_remove_breakpoint (bl->gdbarch,
2565 &bl->overlay_target_info);
2567 /* Did we set a breakpoint at the VMA?
2568 If so, we will have marked the breakpoint 'inserted'. */
2571 /* Yes -- remove it. Previously we did not bother to
2572 remove the breakpoint if the section had been
2573 unmapped, but let's not rely on that being safe. We
2574 don't know what the overlay manager might do. */
2575 if (bl->loc_type == bp_loc_hardware_breakpoint)
2576 val = target_remove_hw_breakpoint (bl->gdbarch,
2579 /* However, we should remove *software* breakpoints only
2580 if the section is still mapped, or else we overwrite
2581 wrong code with the saved shadow contents. */
2582 else if (section_is_mapped (bl->section))
2583 val = target_remove_breakpoint (bl->gdbarch,
2590 /* No -- not inserted, so no need to remove. No error. */
2595 /* In some cases, we might not be able to remove a breakpoint
2596 in a shared library that has already been removed, but we
2597 have not yet processed the shlib unload event. */
2598 if (val && solib_name_from_address (bl->pspace, bl->address))
2603 bl->inserted = (is == mark_inserted);
2605 else if (bl->loc_type == bp_loc_hardware_watchpoint)
2607 gdb_assert (bl->owner->ops != NULL
2608 && bl->owner->ops->remove_location != NULL);
2610 bl->inserted = (is == mark_inserted);
2611 bl->owner->ops->remove_location (bl);
2613 /* Failure to remove any of the hardware watchpoints comes here. */
2614 if ((is == mark_uninserted) && (bl->inserted))
2615 warning (_("Could not remove hardware watchpoint %d."),
2618 else if (bl->owner->type == bp_catchpoint
2619 && breakpoint_enabled (bl->owner)
2622 gdb_assert (bl->owner->ops != NULL
2623 && bl->owner->ops->remove_location != NULL);
2625 val = bl->owner->ops->remove_location (bl);
2629 bl->inserted = (is == mark_inserted);
2636 remove_breakpoint (struct bp_location *bl, insertion_state_t is)
2639 struct cleanup *old_chain;
2641 /* BL is never in moribund_locations by our callers. */
2642 gdb_assert (bl->owner != NULL);
2644 if (bl->owner->enable_state == bp_permanent)
2645 /* Permanent breakpoints cannot be inserted or removed. */
2648 /* The type of none suggests that owner is actually deleted.
2649 This should not ever happen. */
2650 gdb_assert (bl->owner->type != bp_none);
2652 old_chain = save_current_space_and_thread ();
2654 switch_to_program_space_and_thread (bl->pspace);
2656 ret = remove_breakpoint_1 (bl, is);
2658 do_cleanups (old_chain);
2662 /* Clear the "inserted" flag in all breakpoints. */
2665 mark_breakpoints_out (void)
2667 struct bp_location *bl, **blp_tmp;
2669 ALL_BP_LOCATIONS (bl, blp_tmp)
2670 if (bl->pspace == current_program_space)
2674 /* Clear the "inserted" flag in all breakpoints and delete any
2675 breakpoints which should go away between runs of the program.
2677 Plus other such housekeeping that has to be done for breakpoints
2680 Note: this function gets called at the end of a run (by
2681 generic_mourn_inferior) and when a run begins (by
2682 init_wait_for_inferior). */
2687 breakpoint_init_inferior (enum inf_context context)
2689 struct breakpoint *b, *b_tmp;
2690 struct bp_location *bl, **blp_tmp;
2692 struct program_space *pspace = current_program_space;
2694 /* If breakpoint locations are shared across processes, then there's
2696 if (gdbarch_has_global_breakpoints (target_gdbarch))
2699 ALL_BP_LOCATIONS (bl, blp_tmp)
2701 /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
2702 if (bl->pspace == pspace
2703 && bl->owner->enable_state != bp_permanent)
2707 ALL_BREAKPOINTS_SAFE (b, b_tmp)
2709 if (b->loc && b->loc->pspace != pspace)
2716 /* If the call dummy breakpoint is at the entry point it will
2717 cause problems when the inferior is rerun, so we better get
2720 case bp_watchpoint_scope:
2722 /* Also get rid of scope breakpoints. */
2724 case bp_shlib_event:
2726 /* Also remove solib event breakpoints. Their addresses may
2727 have changed since the last time we ran the program.
2728 Actually we may now be debugging against different target;
2729 and so the solib backend that installed this breakpoint may
2730 not be used in by the target. E.g.,
2732 (gdb) file prog-linux
2733 (gdb) run # native linux target
2736 (gdb) file prog-win.exe
2737 (gdb) tar rem :9999 # remote Windows gdbserver.
2740 delete_breakpoint (b);
2744 case bp_hardware_watchpoint:
2745 case bp_read_watchpoint:
2746 case bp_access_watchpoint:
2748 /* Likewise for watchpoints on local expressions. */
2749 if (b->exp_valid_block != NULL)
2750 delete_breakpoint (b);
2751 else if (context == inf_starting)
2753 /* Reset val field to force reread of starting value in
2754 insert_breakpoints. */
2756 value_free (b->val);
2766 /* Get rid of the moribund locations. */
2767 for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, bl); ++ix)
2768 decref_bp_location (&bl);
2769 VEC_free (bp_location_p, moribund_locations);
2772 /* These functions concern about actual breakpoints inserted in the
2773 target --- to e.g. check if we need to do decr_pc adjustment or if
2774 we need to hop over the bkpt --- so we check for address space
2775 match, not program space. */
2777 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
2778 exists at PC. It returns ordinary_breakpoint_here if it's an
2779 ordinary breakpoint, or permanent_breakpoint_here if it's a
2780 permanent breakpoint.
2781 - When continuing from a location with an ordinary breakpoint, we
2782 actually single step once before calling insert_breakpoints.
2783 - When continuing from a localion with a permanent breakpoint, we
2784 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
2785 the target, to advance the PC past the breakpoint. */
2787 enum breakpoint_here
2788 breakpoint_here_p (struct address_space *aspace, CORE_ADDR pc)
2790 struct bp_location *bl, **blp_tmp;
2791 int any_breakpoint_here = 0;
2793 ALL_BP_LOCATIONS (bl, blp_tmp)
2795 if (bl->loc_type != bp_loc_software_breakpoint
2796 && bl->loc_type != bp_loc_hardware_breakpoint)
2799 /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
2800 if ((breakpoint_enabled (bl->owner)
2801 || bl->owner->enable_state == bp_permanent)
2802 && breakpoint_location_address_match (bl, aspace, pc))
2804 if (overlay_debugging
2805 && section_is_overlay (bl->section)
2806 && !section_is_mapped (bl->section))
2807 continue; /* unmapped overlay -- can't be a match */
2808 else if (bl->owner->enable_state == bp_permanent)
2809 return permanent_breakpoint_here;
2811 any_breakpoint_here = 1;
2815 return any_breakpoint_here ? ordinary_breakpoint_here : 0;
2818 /* Return true if there's a moribund breakpoint at PC. */
2821 moribund_breakpoint_here_p (struct address_space *aspace, CORE_ADDR pc)
2823 struct bp_location *loc;
2826 for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
2827 if (breakpoint_location_address_match (loc, aspace, pc))
2833 /* Returns non-zero if there's a breakpoint inserted at PC, which is
2834 inserted using regular breakpoint_chain / bp_location array
2835 mechanism. This does not check for single-step breakpoints, which
2836 are inserted and removed using direct target manipulation. */
2839 regular_breakpoint_inserted_here_p (struct address_space *aspace,
2842 struct bp_location *bl, **blp_tmp;
2844 ALL_BP_LOCATIONS (bl, blp_tmp)
2846 if (bl->loc_type != bp_loc_software_breakpoint
2847 && bl->loc_type != bp_loc_hardware_breakpoint)
2851 && breakpoint_location_address_match (bl, aspace, pc))
2853 if (overlay_debugging
2854 && section_is_overlay (bl->section)
2855 && !section_is_mapped (bl->section))
2856 continue; /* unmapped overlay -- can't be a match */
2864 /* Returns non-zero iff there's either regular breakpoint
2865 or a single step breakpoint inserted at PC. */
2868 breakpoint_inserted_here_p (struct address_space *aspace, CORE_ADDR pc)
2870 if (regular_breakpoint_inserted_here_p (aspace, pc))
2873 if (single_step_breakpoint_inserted_here_p (aspace, pc))
2879 /* This function returns non-zero iff there is a software breakpoint
2883 software_breakpoint_inserted_here_p (struct address_space *aspace,
2886 struct bp_location *bl, **blp_tmp;
2888 ALL_BP_LOCATIONS (bl, blp_tmp)
2890 if (bl->loc_type != bp_loc_software_breakpoint)
2894 && breakpoint_address_match (bl->pspace->aspace, bl->address,
2897 if (overlay_debugging
2898 && section_is_overlay (bl->section)
2899 && !section_is_mapped (bl->section))
2900 continue; /* unmapped overlay -- can't be a match */
2906 /* Also check for software single-step breakpoints. */
2907 if (single_step_breakpoint_inserted_here_p (aspace, pc))
2914 hardware_watchpoint_inserted_in_range (struct address_space *aspace,
2915 CORE_ADDR addr, ULONGEST len)
2917 struct breakpoint *bpt;
2919 ALL_BREAKPOINTS (bpt)
2921 struct bp_location *loc;
2923 if (bpt->type != bp_hardware_watchpoint
2924 && bpt->type != bp_access_watchpoint)
2927 if (!breakpoint_enabled (bpt))
2930 for (loc = bpt->loc; loc; loc = loc->next)
2931 if (loc->pspace->aspace == aspace && loc->inserted)
2935 /* Check for intersection. */
2936 l = max (loc->address, addr);
2937 h = min (loc->address + loc->length, addr + len);
2945 /* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
2946 PC is valid for process/thread PTID. */
2949 breakpoint_thread_match (struct address_space *aspace, CORE_ADDR pc,
2952 struct bp_location *bl, **blp_tmp;
2953 /* The thread and task IDs associated to PTID, computed lazily. */
2957 ALL_BP_LOCATIONS (bl, blp_tmp)
2959 if (bl->loc_type != bp_loc_software_breakpoint
2960 && bl->loc_type != bp_loc_hardware_breakpoint)
2963 /* ALL_BP_LOCATIONS bp_location has bl->OWNER always non-NULL. */
2964 if (!breakpoint_enabled (bl->owner)
2965 && bl->owner->enable_state != bp_permanent)
2968 if (!breakpoint_location_address_match (bl, aspace, pc))
2971 if (bl->owner->thread != -1)
2973 /* This is a thread-specific breakpoint. Check that ptid
2974 matches that thread. If thread hasn't been computed yet,
2975 it is now time to do so. */
2977 thread = pid_to_thread_id (ptid);
2978 if (bl->owner->thread != thread)
2982 if (bl->owner->task != 0)
2984 /* This is a task-specific breakpoint. Check that ptid
2985 matches that task. If task hasn't been computed yet,
2986 it is now time to do so. */
2988 task = ada_get_task_number (ptid);
2989 if (bl->owner->task != task)
2993 if (overlay_debugging
2994 && section_is_overlay (bl->section)
2995 && !section_is_mapped (bl->section))
2996 continue; /* unmapped overlay -- can't be a match */
3005 /* bpstat stuff. External routines' interfaces are documented
3009 ep_is_catchpoint (struct breakpoint *ep)
3011 return (ep->type == bp_catchpoint);
3014 /* Frees any storage that is part of a bpstat. Does not walk the
3018 bpstat_free (bpstat bs)
3020 if (bs->old_val != NULL)
3021 value_free (bs->old_val);
3022 decref_counted_command_line (&bs->commands);
3023 decref_bp_location (&bs->bp_location_at);
3027 /* Clear a bpstat so that it says we are not at any breakpoint.
3028 Also free any storage that is part of a bpstat. */
3031 bpstat_clear (bpstat *bsp)
3048 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
3049 is part of the bpstat is copied as well. */
3052 bpstat_copy (bpstat bs)
3056 bpstat retval = NULL;
3061 for (; bs != NULL; bs = bs->next)
3063 tmp = (bpstat) xmalloc (sizeof (*tmp));
3064 memcpy (tmp, bs, sizeof (*tmp));
3065 incref_counted_command_line (tmp->commands);
3066 incref_bp_location (tmp->bp_location_at);
3067 if (bs->old_val != NULL)
3069 tmp->old_val = value_copy (bs->old_val);
3070 release_value (tmp->old_val);
3074 /* This is the first thing in the chain. */
3084 /* Find the bpstat associated with this breakpoint. */
3087 bpstat_find_breakpoint (bpstat bsp, struct breakpoint *breakpoint)
3092 for (; bsp != NULL; bsp = bsp->next)
3094 if (bsp->breakpoint_at == breakpoint)
3100 /* Put in *NUM the breakpoint number of the first breakpoint we are
3101 stopped at. *BSP upon return is a bpstat which points to the
3102 remaining breakpoints stopped at (but which is not guaranteed to be
3103 good for anything but further calls to bpstat_num).
3105 Return 0 if passed a bpstat which does not indicate any breakpoints.
3106 Return -1 if stopped at a breakpoint that has been deleted since
3108 Return 1 otherwise. */
3111 bpstat_num (bpstat *bsp, int *num)
3113 struct breakpoint *b;
3116 return 0; /* No more breakpoint values */
3118 /* We assume we'll never have several bpstats that correspond to a
3119 single breakpoint -- otherwise, this function might return the
3120 same number more than once and this will look ugly. */
3121 b = (*bsp)->breakpoint_at;
3122 *bsp = (*bsp)->next;
3124 return -1; /* breakpoint that's been deleted since */
3126 *num = b->number; /* We have its number */
3130 /* Modify BS so that the actions will not be performed. */
3133 bpstat_clear_actions (bpstat bs)
3135 for (; bs != NULL; bs = bs->next)
3137 decref_counted_command_line (&bs->commands);
3138 bs->commands_left = NULL;
3139 if (bs->old_val != NULL)
3141 value_free (bs->old_val);
3147 /* Called when a command is about to proceed the inferior. */
3150 breakpoint_about_to_proceed (void)
3152 if (!ptid_equal (inferior_ptid, null_ptid))
3154 struct thread_info *tp = inferior_thread ();
3156 /* Allow inferior function calls in breakpoint commands to not
3157 interrupt the command list. When the call finishes
3158 successfully, the inferior will be standing at the same
3159 breakpoint as if nothing happened. */
3160 if (tp->control.in_infcall)
3164 breakpoint_proceeded = 1;
3167 /* Stub for cleaning up our state if we error-out of a breakpoint
3170 cleanup_executing_breakpoints (void *ignore)
3172 executing_breakpoint_commands = 0;
3175 /* Execute all the commands associated with all the breakpoints at
3176 this location. Any of these commands could cause the process to
3177 proceed beyond this point, etc. We look out for such changes by
3178 checking the global "breakpoint_proceeded" after each command.
3180 Returns true if a breakpoint command resumed the inferior. In that
3181 case, it is the caller's responsibility to recall it again with the
3182 bpstat of the current thread. */
3185 bpstat_do_actions_1 (bpstat *bsp)
3188 struct cleanup *old_chain;
3191 /* Avoid endless recursion if a `source' command is contained
3193 if (executing_breakpoint_commands)
3196 executing_breakpoint_commands = 1;
3197 old_chain = make_cleanup (cleanup_executing_breakpoints, 0);
3199 /* This pointer will iterate over the list of bpstat's. */
3202 breakpoint_proceeded = 0;
3203 for (; bs != NULL; bs = bs->next)
3205 struct counted_command_line *ccmd;
3206 struct command_line *cmd;
3207 struct cleanup *this_cmd_tree_chain;
3209 /* Take ownership of the BSP's command tree, if it has one.
3211 The command tree could legitimately contain commands like
3212 'step' and 'next', which call clear_proceed_status, which
3213 frees stop_bpstat's command tree. To make sure this doesn't
3214 free the tree we're executing out from under us, we need to
3215 take ownership of the tree ourselves. Since a given bpstat's
3216 commands are only executed once, we don't need to copy it; we
3217 can clear the pointer in the bpstat, and make sure we free
3218 the tree when we're done. */
3219 ccmd = bs->commands;
3220 bs->commands = NULL;
3222 = make_cleanup_decref_counted_command_line (&ccmd);
3223 cmd = bs->commands_left;
3224 bs->commands_left = NULL;
3228 execute_control_command (cmd);
3230 if (breakpoint_proceeded)
3236 /* We can free this command tree now. */
3237 do_cleanups (this_cmd_tree_chain);
3239 if (breakpoint_proceeded)
3241 if (target_can_async_p ())
3242 /* If we are in async mode, then the target might be still
3243 running, not stopped at any breakpoint, so nothing for
3244 us to do here -- just return to the event loop. */
3247 /* In sync mode, when execute_control_command returns
3248 we're already standing on the next breakpoint.
3249 Breakpoint commands for that stop were not run, since
3250 execute_command does not run breakpoint commands --
3251 only command_line_handler does, but that one is not
3252 involved in execution of breakpoint commands. So, we
3253 can now execute breakpoint commands. It should be
3254 noted that making execute_command do bpstat actions is
3255 not an option -- in this case we'll have recursive
3256 invocation of bpstat for each breakpoint with a
3257 command, and can easily blow up GDB stack. Instead, we
3258 return true, which will trigger the caller to recall us
3259 with the new stop_bpstat. */
3264 do_cleanups (old_chain);
3269 bpstat_do_actions (void)
3271 /* Do any commands attached to breakpoint we are stopped at. */
3272 while (!ptid_equal (inferior_ptid, null_ptid)
3273 && target_has_execution
3274 && !is_exited (inferior_ptid)
3275 && !is_executing (inferior_ptid))
3276 /* Since in sync mode, bpstat_do_actions may resume the inferior,
3277 and only return when it is stopped at the next breakpoint, we
3278 keep doing breakpoint actions until it returns false to
3279 indicate the inferior was not resumed. */
3280 if (!bpstat_do_actions_1 (&inferior_thread ()->control.stop_bpstat))
3284 /* Print out the (old or new) value associated with a watchpoint. */
3287 watchpoint_value_print (struct value *val, struct ui_file *stream)
3290 fprintf_unfiltered (stream, _("<unreadable>"));
3293 struct value_print_options opts;
3294 get_user_print_options (&opts);
3295 value_print (val, stream, &opts);
3299 /* This is the normal print function for a bpstat. In the future,
3300 much of this logic could (should?) be moved to bpstat_stop_status,
3301 by having it set different print_it values.
3303 Current scheme: When we stop, bpstat_print() is called. It loops
3304 through the bpstat list of things causing this stop, calling the
3305 print_bp_stop_message function on each one. The behavior of the
3306 print_bp_stop_message function depends on the print_it field of
3307 bpstat. If such field so indicates, call this function here.
3309 Return values from this routine (ultimately used by bpstat_print()
3310 and normal_stop() to decide what to do):
3311 PRINT_NOTHING: Means we already printed all we needed to print,
3312 don't print anything else.
3313 PRINT_SRC_ONLY: Means we printed something, and we do *not* desire
3314 that something to be followed by a location.
3315 PRINT_SCR_AND_LOC: Means we printed something, and we *do* desire
3316 that something to be followed by a location.
3317 PRINT_UNKNOWN: Means we printed nothing or we need to do some more
3320 static enum print_stop_action
3321 print_it_typical (bpstat bs)
3323 struct cleanup *old_chain;
3324 struct breakpoint *b;
3325 const struct bp_location *bl;
3326 struct ui_stream *stb;
3328 enum print_stop_action result;
3330 gdb_assert (bs->bp_location_at != NULL);
3332 bl = bs->bp_location_at;
3333 b = bs->breakpoint_at;
3335 stb = ui_out_stream_new (uiout);
3336 old_chain = make_cleanup_ui_out_stream_delete (stb);
3341 case bp_hardware_breakpoint:
3342 bp_temp = b->disposition == disp_del;
3343 if (bl->address != bl->requested_address)
3344 breakpoint_adjustment_warning (bl->requested_address,
3347 annotate_breakpoint (b->number);
3349 ui_out_text (uiout, "\nTemporary breakpoint ");
3351 ui_out_text (uiout, "\nBreakpoint ");
3352 if (ui_out_is_mi_like_p (uiout))
3354 ui_out_field_string (uiout, "reason",
3355 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
3356 ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
3358 ui_out_field_int (uiout, "bkptno", b->number);
3359 ui_out_text (uiout, ", ");
3360 result = PRINT_SRC_AND_LOC;
3363 case bp_shlib_event:
3364 /* Did we stop because the user set the stop_on_solib_events
3365 variable? (If so, we report this as a generic, "Stopped due
3366 to shlib event" message.) */
3367 printf_filtered (_("Stopped due to shared library event\n"));
3368 result = PRINT_NOTHING;
3371 case bp_thread_event:
3372 /* Not sure how we will get here.
3373 GDB should not stop for these breakpoints. */
3374 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
3375 result = PRINT_NOTHING;
3378 case bp_overlay_event:
3379 /* By analogy with the thread event, GDB should not stop for these. */
3380 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
3381 result = PRINT_NOTHING;
3384 case bp_longjmp_master:
3385 /* These should never be enabled. */
3386 printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
3387 result = PRINT_NOTHING;
3390 case bp_std_terminate_master:
3391 /* These should never be enabled. */
3392 printf_filtered (_("std::terminate Master Breakpoint: "
3393 "gdb should not stop!\n"));
3394 result = PRINT_NOTHING;
3397 case bp_exception_master:
3398 /* These should never be enabled. */
3399 printf_filtered (_("Exception Master Breakpoint: "
3400 "gdb should not stop!\n"));
3401 result = PRINT_NOTHING;
3405 case bp_hardware_watchpoint:
3406 annotate_watchpoint (b->number);
3407 if (ui_out_is_mi_like_p (uiout))
3410 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER));
3412 make_cleanup_ui_out_tuple_begin_end (uiout, "value");
3413 ui_out_text (uiout, "\nOld value = ");
3414 watchpoint_value_print (bs->old_val, stb->stream);
3415 ui_out_field_stream (uiout, "old", stb);
3416 ui_out_text (uiout, "\nNew value = ");
3417 watchpoint_value_print (b->val, stb->stream);
3418 ui_out_field_stream (uiout, "new", stb);
3419 ui_out_text (uiout, "\n");
3420 /* More than one watchpoint may have been triggered. */
3421 result = PRINT_UNKNOWN;
3424 case bp_read_watchpoint:
3425 if (ui_out_is_mi_like_p (uiout))
3428 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER));
3430 make_cleanup_ui_out_tuple_begin_end (uiout, "value");
3431 ui_out_text (uiout, "\nValue = ");
3432 watchpoint_value_print (b->val, stb->stream);
3433 ui_out_field_stream (uiout, "value", stb);
3434 ui_out_text (uiout, "\n");
3435 result = PRINT_UNKNOWN;
3438 case bp_access_watchpoint:
3439 if (bs->old_val != NULL)
3441 annotate_watchpoint (b->number);
3442 if (ui_out_is_mi_like_p (uiout))
3445 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
3447 make_cleanup_ui_out_tuple_begin_end (uiout, "value");
3448 ui_out_text (uiout, "\nOld value = ");
3449 watchpoint_value_print (bs->old_val, stb->stream);
3450 ui_out_field_stream (uiout, "old", stb);
3451 ui_out_text (uiout, "\nNew value = ");
3456 if (ui_out_is_mi_like_p (uiout))
3459 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
3460 make_cleanup_ui_out_tuple_begin_end (uiout, "value");
3461 ui_out_text (uiout, "\nValue = ");
3463 watchpoint_value_print (b->val, stb->stream);
3464 ui_out_field_stream (uiout, "new", stb);
3465 ui_out_text (uiout, "\n");
3466 result = PRINT_UNKNOWN;
3469 /* Fall through, we don't deal with these types of breakpoints
3473 if (ui_out_is_mi_like_p (uiout))
3476 async_reason_lookup (EXEC_ASYNC_FUNCTION_FINISHED));
3477 result = PRINT_UNKNOWN;
3481 if (ui_out_is_mi_like_p (uiout))
3484 async_reason_lookup (EXEC_ASYNC_LOCATION_REACHED));
3485 result = PRINT_UNKNOWN;
3490 case bp_longjmp_resume:
3492 case bp_exception_resume:
3493 case bp_step_resume:
3494 case bp_watchpoint_scope:
3496 case bp_std_terminate:
3498 case bp_fast_tracepoint:
3500 case bp_gnu_ifunc_resolver:
3501 case bp_gnu_ifunc_resolver_return:
3503 result = PRINT_UNKNOWN;
3507 do_cleanups (old_chain);
3511 /* Generic routine for printing messages indicating why we
3512 stopped. The behavior of this function depends on the value
3513 'print_it' in the bpstat structure. Under some circumstances we
3514 may decide not to print anything here and delegate the task to
3517 static enum print_stop_action
3518 print_bp_stop_message (bpstat bs)
3520 switch (bs->print_it)
3523 /* Nothing should be printed for this bpstat entry. */
3524 return PRINT_UNKNOWN;
3528 /* We still want to print the frame, but we already printed the
3529 relevant messages. */
3530 return PRINT_SRC_AND_LOC;
3533 case print_it_normal:
3535 struct breakpoint *b = bs->breakpoint_at;
3537 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
3538 which has since been deleted. */
3540 return PRINT_UNKNOWN;
3542 /* Normal case. Call the breakpoint's print_it method, or
3543 print_it_typical. */
3544 if (b->ops != NULL && b->ops->print_it != NULL)
3545 return b->ops->print_it (b);
3547 return print_it_typical (bs);
3552 internal_error (__FILE__, __LINE__,
3553 _("print_bp_stop_message: unrecognized enum value"));
3558 /* Print a message indicating what happened. This is called from
3559 normal_stop(). The input to this routine is the head of the bpstat
3560 list - a list of the eventpoints that caused this stop. This
3561 routine calls the generic print routine for printing a message
3562 about reasons for stopping. This will print (for example) the
3563 "Breakpoint n," part of the output. The return value of this
3566 PRINT_UNKNOWN: Means we printed nothing.
3567 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
3568 code to print the location. An example is
3569 "Breakpoint 1, " which should be followed by
3571 PRINT_SRC_ONLY: Means we printed something, but there is no need
3572 to also print the location part of the message.
3573 An example is the catch/throw messages, which
3574 don't require a location appended to the end.
3575 PRINT_NOTHING: We have done some printing and we don't need any
3576 further info to be printed. */
3578 enum print_stop_action
3579 bpstat_print (bpstat bs)
3583 /* Maybe another breakpoint in the chain caused us to stop.
3584 (Currently all watchpoints go on the bpstat whether hit or not.
3585 That probably could (should) be changed, provided care is taken
3586 with respect to bpstat_explains_signal). */
3587 for (; bs; bs = bs->next)
3589 val = print_bp_stop_message (bs);
3590 if (val == PRINT_SRC_ONLY
3591 || val == PRINT_SRC_AND_LOC
3592 || val == PRINT_NOTHING)
3596 /* We reached the end of the chain, or we got a null BS to start
3597 with and nothing was printed. */
3598 return PRINT_UNKNOWN;
3601 /* Evaluate the expression EXP and return 1 if value is zero. This is
3602 used inside a catch_errors to evaluate the breakpoint condition.
3603 The argument is a "struct expression *" that has been cast to a
3604 "char *" to make it pass through catch_errors. */
3607 breakpoint_cond_eval (void *exp)
3609 struct value *mark = value_mark ();
3610 int i = !value_true (evaluate_expression ((struct expression *) exp));
3612 value_free_to_mark (mark);
3616 /* Allocate a new bpstat. Link it to the FIFO list by BS_LINK_POINTER. */
3619 bpstat_alloc (struct bp_location *bl, bpstat **bs_link_pointer)
3623 bs = (bpstat) xmalloc (sizeof (*bs));
3625 **bs_link_pointer = bs;
3626 *bs_link_pointer = &bs->next;
3627 bs->breakpoint_at = bl->owner;
3628 bs->bp_location_at = bl;
3629 incref_bp_location (bl);
3630 /* If the condition is false, etc., don't do the commands. */
3631 bs->commands = NULL;
3632 bs->commands_left = NULL;
3634 bs->print_it = print_it_normal;
3638 /* The target has stopped with waitstatus WS. Check if any hardware
3639 watchpoints have triggered, according to the target. */
3642 watchpoints_triggered (struct target_waitstatus *ws)
3644 int stopped_by_watchpoint = target_stopped_by_watchpoint ();
3646 struct breakpoint *b;
3648 if (!stopped_by_watchpoint)
3650 /* We were not stopped by a watchpoint. Mark all watchpoints
3651 as not triggered. */
3653 if (is_hardware_watchpoint (b))
3654 b->watchpoint_triggered = watch_triggered_no;
3659 if (!target_stopped_data_address (¤t_target, &addr))
3661 /* We were stopped by a watchpoint, but we don't know where.
3662 Mark all watchpoints as unknown. */
3664 if (is_hardware_watchpoint (b))
3665 b->watchpoint_triggered = watch_triggered_unknown;
3667 return stopped_by_watchpoint;
3670 /* The target could report the data address. Mark watchpoints
3671 affected by this data address as triggered, and all others as not
3675 if (is_hardware_watchpoint (b))
3677 struct bp_location *loc;
3679 b->watchpoint_triggered = watch_triggered_no;
3680 for (loc = b->loc; loc; loc = loc->next)
3681 /* Exact match not required. Within range is
3683 if (target_watchpoint_addr_within_range (¤t_target,
3687 b->watchpoint_triggered = watch_triggered_yes;
3695 /* Possible return values for watchpoint_check (this can't be an enum
3696 because of check_errors). */
3697 /* The watchpoint has been deleted. */
3698 #define WP_DELETED 1
3699 /* The value has changed. */
3700 #define WP_VALUE_CHANGED 2
3701 /* The value has not changed. */
3702 #define WP_VALUE_NOT_CHANGED 3
3703 /* Ignore this watchpoint, no matter if the value changed or not. */
3706 #define BP_TEMPFLAG 1
3707 #define BP_HARDWAREFLAG 2
3709 /* Evaluate watchpoint condition expression and check if its value
3712 P should be a pointer to struct bpstat, but is defined as a void *
3713 in order for this function to be usable with catch_errors. */
3716 watchpoint_check (void *p)
3718 bpstat bs = (bpstat) p;
3719 struct breakpoint *b;
3720 struct frame_info *fr;
3721 int within_current_scope;
3723 /* BS is built from an existing struct breakpoint. */
3724 gdb_assert (bs->breakpoint_at != NULL);
3725 b = bs->breakpoint_at;
3727 gdb_assert (is_watchpoint (b));
3729 /* If this is a local watchpoint, we only want to check if the
3730 watchpoint frame is in scope if the current thread is the thread
3731 that was used to create the watchpoint. */
3732 if (!watchpoint_in_thread_scope (b))
3735 if (b->exp_valid_block == NULL)
3736 within_current_scope = 1;
3739 struct frame_info *frame = get_current_frame ();
3740 struct gdbarch *frame_arch = get_frame_arch (frame);
3741 CORE_ADDR frame_pc = get_frame_pc (frame);
3743 /* in_function_epilogue_p() returns a non-zero value if we're
3744 still in the function but the stack frame has already been
3745 invalidated. Since we can't rely on the values of local
3746 variables after the stack has been destroyed, we are treating
3747 the watchpoint in that state as `not changed' without further
3748 checking. Don't mark watchpoints as changed if the current
3749 frame is in an epilogue - even if they are in some other
3750 frame, our view of the stack is likely to be wrong and
3751 frame_find_by_id could error out. */
3752 if (gdbarch_in_function_epilogue_p (frame_arch, frame_pc))
3755 fr = frame_find_by_id (b->watchpoint_frame);
3756 within_current_scope = (fr != NULL);
3758 /* If we've gotten confused in the unwinder, we might have
3759 returned a frame that can't describe this variable. */
3760 if (within_current_scope)
3762 struct symbol *function;
3764 function = get_frame_function (fr);
3765 if (function == NULL
3766 || !contained_in (b->exp_valid_block,
3767 SYMBOL_BLOCK_VALUE (function)))
3768 within_current_scope = 0;
3771 if (within_current_scope)
3772 /* If we end up stopping, the current frame will get selected
3773 in normal_stop. So this call to select_frame won't affect
3778 if (within_current_scope)
3780 /* We use value_{,free_to_}mark because it could be a *long*
3781 time before we return to the command level and call
3782 free_all_values. We can't call free_all_values because we
3783 might be in the middle of evaluating a function call. */
3786 struct value *mark = value_mark ();
3787 struct value *new_val;
3789 fetch_subexp_value (b->exp, &pc, &new_val, NULL, NULL);
3791 /* We use value_equal_contents instead of value_equal because
3792 the latter coerces an array to a pointer, thus comparing just
3793 the address of the array instead of its contents. This is
3794 not what we want. */
3795 if ((b->val != NULL) != (new_val != NULL)
3796 || (b->val != NULL && !value_equal_contents (b->val, new_val)))
3798 if (new_val != NULL)
3800 release_value (new_val);
3801 value_free_to_mark (mark);
3803 bs->old_val = b->val;
3806 return WP_VALUE_CHANGED;
3810 /* Nothing changed. */
3811 value_free_to_mark (mark);
3812 return WP_VALUE_NOT_CHANGED;
3817 /* This seems like the only logical thing to do because
3818 if we temporarily ignored the watchpoint, then when
3819 we reenter the block in which it is valid it contains
3820 garbage (in the case of a function, it may have two
3821 garbage values, one before and one after the prologue).
3822 So we can't even detect the first assignment to it and
3823 watch after that (since the garbage may or may not equal
3824 the first value assigned). */
3825 /* We print all the stop information in print_it_typical(), but
3826 in this case, by the time we call print_it_typical() this bp
3827 will be deleted already. So we have no choice but print the
3828 information here. */
3829 if (ui_out_is_mi_like_p (uiout))
3831 (uiout, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE));
3832 ui_out_text (uiout, "\nWatchpoint ");
3833 ui_out_field_int (uiout, "wpnum", b->number);
3835 " deleted because the program has left the block in\n\
3836 which its expression is valid.\n");
3838 watchpoint_del_at_next_stop (b);
3844 /* Return true if it looks like target has stopped due to hitting
3845 breakpoint location BL. This function does not check if we
3846 should stop, only if BL explains the stop. */
3848 bpstat_check_location (const struct bp_location *bl,
3849 struct address_space *aspace, CORE_ADDR bp_addr)
3851 struct breakpoint *b = bl->owner;
3853 /* BL is from existing struct breakpoint. */
3854 gdb_assert (b != NULL);
3856 if (b->ops && b->ops->breakpoint_hit)
3857 return b->ops->breakpoint_hit (bl, aspace, bp_addr);
3859 /* By definition, the inferior does not report stops at
3861 if (is_tracepoint (b))
3864 if (!is_watchpoint (b)
3865 && b->type != bp_hardware_breakpoint
3866 && b->type != bp_catchpoint) /* a non-watchpoint bp */
3868 if (!breakpoint_address_match (bl->pspace->aspace, bl->address,
3871 if (overlay_debugging /* unmapped overlay section */
3872 && section_is_overlay (bl->section)
3873 && !section_is_mapped (bl->section))
3877 /* Continuable hardware watchpoints are treated as non-existent if the
3878 reason we stopped wasn't a hardware watchpoint (we didn't stop on
3879 some data address). Otherwise gdb won't stop on a break instruction
3880 in the code (not from a breakpoint) when a hardware watchpoint has
3881 been defined. Also skip watchpoints which we know did not trigger
3882 (did not match the data address). */
3884 if (is_hardware_watchpoint (b)
3885 && b->watchpoint_triggered == watch_triggered_no)
3888 if (b->type == bp_hardware_breakpoint)
3890 if (bl->address != bp_addr)
3892 if (overlay_debugging /* unmapped overlay section */
3893 && section_is_overlay (bl->section)
3894 && !section_is_mapped (bl->section))
3901 /* If BS refers to a watchpoint, determine if the watched values
3902 has actually changed, and we should stop. If not, set BS->stop
3905 bpstat_check_watchpoint (bpstat bs)
3907 const struct bp_location *bl;
3908 struct breakpoint *b;
3910 /* BS is built for existing struct breakpoint. */
3911 bl = bs->bp_location_at;
3912 gdb_assert (bl != NULL);
3913 b = bs->breakpoint_at;
3914 gdb_assert (b != NULL);
3916 if (is_watchpoint (b))
3918 int must_check_value = 0;
3920 if (b->type == bp_watchpoint)
3921 /* For a software watchpoint, we must always check the
3923 must_check_value = 1;
3924 else if (b->watchpoint_triggered == watch_triggered_yes)
3925 /* We have a hardware watchpoint (read, write, or access)
3926 and the target earlier reported an address watched by
3928 must_check_value = 1;
3929 else if (b->watchpoint_triggered == watch_triggered_unknown
3930 && b->type == bp_hardware_watchpoint)
3931 /* We were stopped by a hardware watchpoint, but the target could
3932 not report the data address. We must check the watchpoint's
3933 value. Access and read watchpoints are out of luck; without
3934 a data address, we can't figure it out. */
3935 must_check_value = 1;
3937 if (must_check_value)
3940 = xstrprintf ("Error evaluating expression for watchpoint %d\n",
3942 struct cleanup *cleanups = make_cleanup (xfree, message);
3943 int e = catch_errors (watchpoint_check, bs, message,
3945 do_cleanups (cleanups);
3949 /* We've already printed what needs to be printed. */
3950 bs->print_it = print_it_done;
3954 bs->print_it = print_it_noop;
3957 case WP_VALUE_CHANGED:
3958 if (b->type == bp_read_watchpoint)
3960 /* There are two cases to consider here:
3962 1. We're watching the triggered memory for reads.
3963 In that case, trust the target, and always report
3964 the watchpoint hit to the user. Even though
3965 reads don't cause value changes, the value may
3966 have changed since the last time it was read, and
3967 since we're not trapping writes, we will not see
3968 those, and as such we should ignore our notion of
3971 2. We're watching the triggered memory for both
3972 reads and writes. There are two ways this may
3975 2.1. This is a target that can't break on data
3976 reads only, but can break on accesses (reads or
3977 writes), such as e.g., x86. We detect this case
3978 at the time we try to insert read watchpoints.
3980 2.2. Otherwise, the target supports read
3981 watchpoints, but, the user set an access or write
3982 watchpoint watching the same memory as this read
3985 If we're watching memory writes as well as reads,
3986 ignore watchpoint hits when we find that the
3987 value hasn't changed, as reads don't cause
3988 changes. This still gives false positives when
3989 the program writes the same value to memory as
3990 what there was already in memory (we will confuse
3991 it for a read), but it's much better than
3994 int other_write_watchpoint = 0;
3996 if (bl->watchpoint_type == hw_read)
3998 struct breakpoint *other_b;
4000 ALL_BREAKPOINTS (other_b)
4001 if ((other_b->type == bp_hardware_watchpoint
4002 || other_b->type == bp_access_watchpoint)
4003 && (other_b->watchpoint_triggered
4004 == watch_triggered_yes))
4006 other_write_watchpoint = 1;
4011 if (other_write_watchpoint
4012 || bl->watchpoint_type == hw_access)
4014 /* We're watching the same memory for writes,
4015 and the value changed since the last time we
4016 updated it, so this trap must be for a write.
4018 bs->print_it = print_it_noop;
4023 case WP_VALUE_NOT_CHANGED:
4024 if (b->type == bp_hardware_watchpoint
4025 || b->type == bp_watchpoint)
4027 /* Don't stop: write watchpoints shouldn't fire if
4028 the value hasn't changed. */
4029 bs->print_it = print_it_noop;
4037 /* Error from catch_errors. */
4038 printf_filtered (_("Watchpoint %d deleted.\n"), b->number);
4039 watchpoint_del_at_next_stop (b);
4040 /* We've already printed what needs to be printed. */
4041 bs->print_it = print_it_done;
4045 else /* must_check_value == 0 */
4047 /* This is a case where some watchpoint(s) triggered, but
4048 not at the address of this watchpoint, or else no
4049 watchpoint triggered after all. So don't print
4050 anything for this watchpoint. */
4051 bs->print_it = print_it_noop;
4058 /* Check conditions (condition proper, frame, thread and ignore count)
4059 of breakpoint referred to by BS. If we should not stop for this
4060 breakpoint, set BS->stop to 0. */
4063 bpstat_check_breakpoint_conditions (bpstat bs, ptid_t ptid)
4065 int thread_id = pid_to_thread_id (ptid);
4066 const struct bp_location *bl;
4067 struct breakpoint *b;
4069 /* BS is built for existing struct breakpoint. */
4070 bl = bs->bp_location_at;
4071 gdb_assert (bl != NULL);
4072 b = bs->breakpoint_at;
4073 gdb_assert (b != NULL);
4075 if (frame_id_p (b->frame_id)
4076 && !frame_id_eq (b->frame_id, get_stack_frame_id (get_current_frame ())))
4080 int value_is_zero = 0;
4081 struct expression *cond;
4083 /* Evaluate Python breakpoints that have a "stop"
4084 method implemented. */
4085 if (b->py_bp_object)
4086 bs->stop = gdbpy_should_stop (b->py_bp_object);
4088 if (is_watchpoint (b))
4093 if (cond && b->disposition != disp_del_at_next_stop)
4095 int within_current_scope = 1;
4097 /* We use value_mark and value_free_to_mark because it could
4098 be a long time before we return to the command level and
4099 call free_all_values. We can't call free_all_values
4100 because we might be in the middle of evaluating a
4102 struct value *mark = value_mark ();
4104 /* Need to select the frame, with all that implies so that
4105 the conditions will have the right context. Because we
4106 use the frame, we will not see an inlined function's
4107 variables when we arrive at a breakpoint at the start
4108 of the inlined function; the current frame will be the
4110 if (!is_watchpoint (b) || b->cond_exp_valid_block == NULL)
4111 select_frame (get_current_frame ());
4114 struct frame_info *frame;
4116 /* For local watchpoint expressions, which particular
4117 instance of a local is being watched matters, so we
4118 keep track of the frame to evaluate the expression
4119 in. To evaluate the condition however, it doesn't
4120 really matter which instantiation of the function
4121 where the condition makes sense triggers the
4122 watchpoint. This allows an expression like "watch
4123 global if q > 10" set in `func', catch writes to
4124 global on all threads that call `func', or catch
4125 writes on all recursive calls of `func' by a single
4126 thread. We simply always evaluate the condition in
4127 the innermost frame that's executing where it makes
4128 sense to evaluate the condition. It seems
4130 frame = block_innermost_frame (b->cond_exp_valid_block);
4132 select_frame (frame);
4134 within_current_scope = 0;
4136 if (within_current_scope)
4138 = catch_errors (breakpoint_cond_eval, cond,
4139 "Error in testing breakpoint condition:\n",
4143 warning (_("Watchpoint condition cannot be tested "
4144 "in the current scope"));
4145 /* If we failed to set the right context for this
4146 watchpoint, unconditionally report it. */
4149 /* FIXME-someday, should give breakpoint #. */
4150 value_free_to_mark (mark);
4153 if (cond && value_is_zero)
4157 else if (b->thread != -1 && b->thread != thread_id)
4161 else if (b->ignore_count > 0)
4164 annotate_ignore_count_change ();
4166 /* Increase the hit count even though we don't stop. */
4168 observer_notify_breakpoint_modified (b);
4174 /* Get a bpstat associated with having just stopped at address
4175 BP_ADDR in thread PTID.
4177 Determine whether we stopped at a breakpoint, etc, or whether we
4178 don't understand this stop. Result is a chain of bpstat's such
4181 if we don't understand the stop, the result is a null pointer.
4183 if we understand why we stopped, the result is not null.
4185 Each element of the chain refers to a particular breakpoint or
4186 watchpoint at which we have stopped. (We may have stopped for
4187 several reasons concurrently.)
4189 Each element of the chain has valid next, breakpoint_at,
4190 commands, FIXME??? fields. */
4193 bpstat_stop_status (struct address_space *aspace,
4194 CORE_ADDR bp_addr, ptid_t ptid)
4196 struct breakpoint *b = NULL;
4197 struct bp_location *bl;
4198 struct bp_location *loc;
4199 /* First item of allocated bpstat's. */
4200 bpstat bs_head = NULL, *bs_link = &bs_head;
4201 /* Pointer to the last thing in the chain currently. */
4204 int need_remove_insert;
4207 /* First, build the bpstat chain with locations that explain a
4208 target stop, while being careful to not set the target running,
4209 as that may invalidate locations (in particular watchpoint
4210 locations are recreated). Resuming will happen here with
4211 breakpoint conditions or watchpoint expressions that include
4212 inferior function calls. */
4216 if (!breakpoint_enabled (b) && b->enable_state != bp_permanent)
4219 for (bl = b->loc; bl != NULL; bl = bl->next)
4221 /* For hardware watchpoints, we look only at the first
4222 location. The watchpoint_check function will work on the
4223 entire expression, not the individual locations. For
4224 read watchpoints, the watchpoints_triggered function has
4225 checked all locations already. */
4226 if (b->type == bp_hardware_watchpoint && bl != b->loc)
4229 if (bl->shlib_disabled)
4232 if (!bpstat_check_location (bl, aspace, bp_addr))
4235 /* Come here if it's a watchpoint, or if the break address
4238 bs = bpstat_alloc (bl, &bs_link); /* Alloc a bpstat to
4241 /* Assume we stop. Should we find a watchpoint that is not
4242 actually triggered, or if the condition of the breakpoint
4243 evaluates as false, we'll reset 'stop' to 0. */
4247 /* If this is a scope breakpoint, mark the associated
4248 watchpoint as triggered so that we will handle the
4249 out-of-scope event. We'll get to the watchpoint next
4251 if (b->type == bp_watchpoint_scope && b->related_breakpoint != b)
4252 b->related_breakpoint->watchpoint_triggered = watch_triggered_yes;
4256 for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
4258 if (breakpoint_location_address_match (loc, aspace, bp_addr))
4260 bs = bpstat_alloc (loc, &bs_link);
4261 /* For hits of moribund locations, we should just proceed. */
4264 bs->print_it = print_it_noop;
4268 /* Now go through the locations that caused the target to stop, and
4269 check whether we're interested in reporting this stop to higher
4270 layers, or whether we should resume the target transparently. */
4274 for (bs = bs_head; bs != NULL; bs = bs->next)
4279 bpstat_check_watchpoint (bs);
4283 b = bs->breakpoint_at;
4285 if (b->type == bp_thread_event || b->type == bp_overlay_event
4286 || b->type == bp_longjmp_master
4287 || b->type == bp_std_terminate_master
4288 || b->type == bp_exception_master)
4289 /* We do not stop for these. */
4292 bpstat_check_breakpoint_conditions (bs, ptid);
4297 observer_notify_breakpoint_modified (b);
4299 /* We will stop here. */
4300 if (b->disposition == disp_disable)
4302 if (b->enable_state != bp_permanent)
4303 b->enable_state = bp_disabled;
4308 bs->commands = b->commands;
4309 incref_counted_command_line (bs->commands);
4310 bs->commands_left = bs->commands ? bs->commands->commands : NULL;
4311 if (bs->commands_left
4312 && (strcmp ("silent", bs->commands_left->line) == 0
4315 bs->commands_left->line) == 0)))
4317 bs->commands_left = bs->commands_left->next;
4322 /* Print nothing for this entry if we dont stop or dont print. */
4323 if (bs->stop == 0 || bs->print == 0)
4324 bs->print_it = print_it_noop;
4327 /* If we aren't stopping, the value of some hardware watchpoint may
4328 not have changed, but the intermediate memory locations we are
4329 watching may have. Don't bother if we're stopping; this will get
4331 need_remove_insert = 0;
4332 if (! bpstat_causes_stop (bs_head))
4333 for (bs = bs_head; bs != NULL; bs = bs->next)
4335 && bs->breakpoint_at
4336 && is_hardware_watchpoint (bs->breakpoint_at))
4338 update_watchpoint (bs->breakpoint_at, 0 /* don't reparse. */);
4339 need_remove_insert = 1;
4342 if (need_remove_insert)
4343 update_global_location_list (1);
4344 else if (removed_any)
4345 update_global_location_list (0);
4351 handle_jit_event (void)
4353 struct frame_info *frame;
4354 struct gdbarch *gdbarch;
4356 /* Switch terminal for any messages produced by
4357 breakpoint_re_set. */
4358 target_terminal_ours_for_output ();
4360 frame = get_current_frame ();
4361 gdbarch = get_frame_arch (frame);
4363 jit_event_handler (gdbarch);
4365 target_terminal_inferior ();
4368 /* Prepare WHAT final decision for infrun. */
4370 /* Decide what infrun needs to do with this bpstat. */
4373 bpstat_what (bpstat bs_head)
4375 struct bpstat_what retval;
4376 /* We need to defer calling `solib_add', as adding new symbols
4377 resets breakpoints, which in turn deletes breakpoint locations,
4378 and hence may clear unprocessed entries in the BS chain. */
4379 int shlib_event = 0;
4383 retval.main_action = BPSTAT_WHAT_KEEP_CHECKING;
4384 retval.call_dummy = STOP_NONE;
4385 retval.is_longjmp = 0;
4387 for (bs = bs_head; bs != NULL; bs = bs->next)
4389 /* Extract this BS's action. After processing each BS, we check
4390 if its action overrides all we've seem so far. */
4391 enum bpstat_what_main_action this_action = BPSTAT_WHAT_KEEP_CHECKING;
4394 if (bs->breakpoint_at == NULL)
4396 /* I suspect this can happen if it was a momentary
4397 breakpoint which has since been deleted. */
4400 else if (bs->breakpoint_at == NULL)
4403 bptype = bs->breakpoint_at->type;
4410 case bp_hardware_breakpoint:
4416 this_action = BPSTAT_WHAT_STOP_NOISY;
4418 this_action = BPSTAT_WHAT_STOP_SILENT;
4421 this_action = BPSTAT_WHAT_SINGLE;
4424 case bp_hardware_watchpoint:
4425 case bp_read_watchpoint:
4426 case bp_access_watchpoint:
4430 this_action = BPSTAT_WHAT_STOP_NOISY;
4432 this_action = BPSTAT_WHAT_STOP_SILENT;
4436 /* There was a watchpoint, but we're not stopping.
4437 This requires no further action. */
4442 this_action = BPSTAT_WHAT_SET_LONGJMP_RESUME;
4443 retval.is_longjmp = bptype == bp_longjmp;
4445 case bp_longjmp_resume:
4446 case bp_exception_resume:
4447 this_action = BPSTAT_WHAT_CLEAR_LONGJMP_RESUME;
4448 retval.is_longjmp = bptype == bp_longjmp_resume;
4450 case bp_step_resume:
4452 this_action = BPSTAT_WHAT_STEP_RESUME;
4455 /* It is for the wrong frame. */
4456 this_action = BPSTAT_WHAT_SINGLE;
4459 case bp_watchpoint_scope:
4460 case bp_thread_event:
4461 case bp_overlay_event:
4462 case bp_longjmp_master:
4463 case bp_std_terminate_master:
4464 case bp_exception_master:
4465 this_action = BPSTAT_WHAT_SINGLE;
4471 this_action = BPSTAT_WHAT_STOP_NOISY;
4473 this_action = BPSTAT_WHAT_STOP_SILENT;
4477 /* There was a catchpoint, but we're not stopping.
4478 This requires no further action. */
4481 case bp_shlib_event:
4484 /* If requested, stop when the dynamic linker notifies GDB
4485 of events. This allows the user to get control and place
4486 breakpoints in initializer routines for dynamically
4487 loaded objects (among other things). */
4488 if (stop_on_solib_events)
4489 this_action = BPSTAT_WHAT_STOP_NOISY;
4491 this_action = BPSTAT_WHAT_SINGLE;
4495 this_action = BPSTAT_WHAT_SINGLE;
4498 /* Make sure the action is stop (silent or noisy),
4499 so infrun.c pops the dummy frame. */
4500 retval.call_dummy = STOP_STACK_DUMMY;
4501 this_action = BPSTAT_WHAT_STOP_SILENT;
4503 case bp_std_terminate:
4504 /* Make sure the action is stop (silent or noisy),
4505 so infrun.c pops the dummy frame. */
4506 retval.call_dummy = STOP_STD_TERMINATE;
4507 this_action = BPSTAT_WHAT_STOP_SILENT;
4510 case bp_fast_tracepoint:
4511 case bp_static_tracepoint:
4512 /* Tracepoint hits should not be reported back to GDB, and
4513 if one got through somehow, it should have been filtered
4515 internal_error (__FILE__, __LINE__,
4516 _("bpstat_what: tracepoint encountered"));
4518 case bp_gnu_ifunc_resolver:
4519 /* Step over it (and insert bp_gnu_ifunc_resolver_return). */
4520 this_action = BPSTAT_WHAT_SINGLE;
4522 case bp_gnu_ifunc_resolver_return:
4523 /* The breakpoint will be removed, execution will restart from the
4524 PC of the former breakpoint. */
4525 this_action = BPSTAT_WHAT_KEEP_CHECKING;
4528 internal_error (__FILE__, __LINE__,
4529 _("bpstat_what: unhandled bptype %d"), (int) bptype);
4532 retval.main_action = max (retval.main_action, this_action);
4535 /* These operations may affect the bs->breakpoint_at state so they are
4536 delayed after MAIN_ACTION is decided above. */
4541 fprintf_unfiltered (gdb_stdlog, "bpstat_what: bp_shlib_event\n");
4543 /* Check for any newly added shared libraries if we're supposed
4544 to be adding them automatically. */
4546 /* Switch terminal for any messages produced by
4547 breakpoint_re_set. */
4548 target_terminal_ours_for_output ();
4551 SOLIB_ADD (NULL, 0, ¤t_target, auto_solib_add);
4553 solib_add (NULL, 0, ¤t_target, auto_solib_add);
4556 target_terminal_inferior ();
4562 fprintf_unfiltered (gdb_stdlog, "bpstat_what: bp_jit_event\n");
4564 handle_jit_event ();
4567 for (bs = bs_head; bs != NULL; bs = bs->next)
4569 struct breakpoint *b = bs->breakpoint_at;
4575 case bp_gnu_ifunc_resolver:
4576 gnu_ifunc_resolver_stop (b);
4578 case bp_gnu_ifunc_resolver_return:
4579 gnu_ifunc_resolver_return_stop (b);
4587 /* Nonzero if we should step constantly (e.g. watchpoints on machines
4588 without hardware support). This isn't related to a specific bpstat,
4589 just to things like whether watchpoints are set. */
4592 bpstat_should_step (void)
4594 struct breakpoint *b;
4597 if (breakpoint_enabled (b) && b->type == bp_watchpoint && b->loc != NULL)
4603 bpstat_causes_stop (bpstat bs)
4605 for (; bs != NULL; bs = bs->next)
4614 /* Compute a string of spaces suitable to indent the next line
4615 so it starts at the position corresponding to the table column
4616 named COL_NAME in the currently active table of UIOUT. */
4619 wrap_indent_at_field (struct ui_out *uiout, const char *col_name)
4621 static char wrap_indent[80];
4622 int i, total_width, width, align;
4626 for (i = 1; ui_out_query_field (uiout, i, &width, &align, &text); i++)
4628 if (strcmp (text, col_name) == 0)
4630 gdb_assert (total_width < sizeof wrap_indent);
4631 memset (wrap_indent, ' ', total_width);
4632 wrap_indent[total_width] = 0;
4637 total_width += width + 1;
4643 /* Print the LOC location out of the list of B->LOC locations. */
4646 print_breakpoint_location (struct breakpoint *b,
4647 struct bp_location *loc)
4649 struct cleanup *old_chain = save_current_program_space ();
4651 if (loc != NULL && loc->shlib_disabled)
4655 set_current_program_space (loc->pspace);
4657 if (b->display_canonical)
4658 ui_out_field_string (uiout, "what", b->addr_string);
4659 else if (b->source_file && loc)
4662 = find_pc_sect_function (loc->address, loc->section);
4665 ui_out_text (uiout, "in ");
4666 ui_out_field_string (uiout, "func",
4667 SYMBOL_PRINT_NAME (sym));
4668 ui_out_text (uiout, " ");
4669 ui_out_wrap_hint (uiout, wrap_indent_at_field (uiout, "what"));
4670 ui_out_text (uiout, "at ");
4672 ui_out_field_string (uiout, "file", b->source_file);
4673 ui_out_text (uiout, ":");
4675 if (ui_out_is_mi_like_p (uiout))
4677 struct symtab_and_line sal = find_pc_line (loc->address, 0);
4678 char *fullname = symtab_to_fullname (sal.symtab);
4681 ui_out_field_string (uiout, "fullname", fullname);
4684 ui_out_field_int (uiout, "line", b->line_number);
4688 struct ui_stream *stb = ui_out_stream_new (uiout);
4689 struct cleanup *stb_chain = make_cleanup_ui_out_stream_delete (stb);
4691 print_address_symbolic (loc->gdbarch, loc->address, stb->stream,
4693 ui_out_field_stream (uiout, "at", stb);
4695 do_cleanups (stb_chain);
4698 ui_out_field_string (uiout, "pending", b->addr_string);
4700 do_cleanups (old_chain);
4704 bptype_string (enum bptype type)
4706 struct ep_type_description
4711 static struct ep_type_description bptypes[] =
4713 {bp_none, "?deleted?"},
4714 {bp_breakpoint, "breakpoint"},
4715 {bp_hardware_breakpoint, "hw breakpoint"},
4716 {bp_until, "until"},
4717 {bp_finish, "finish"},
4718 {bp_watchpoint, "watchpoint"},
4719 {bp_hardware_watchpoint, "hw watchpoint"},
4720 {bp_read_watchpoint, "read watchpoint"},
4721 {bp_access_watchpoint, "acc watchpoint"},
4722 {bp_longjmp, "longjmp"},
4723 {bp_longjmp_resume, "longjmp resume"},
4724 {bp_exception, "exception"},
4725 {bp_exception_resume, "exception resume"},
4726 {bp_step_resume, "step resume"},
4727 {bp_watchpoint_scope, "watchpoint scope"},
4728 {bp_call_dummy, "call dummy"},
4729 {bp_std_terminate, "std::terminate"},
4730 {bp_shlib_event, "shlib events"},
4731 {bp_thread_event, "thread events"},
4732 {bp_overlay_event, "overlay events"},
4733 {bp_longjmp_master, "longjmp master"},
4734 {bp_std_terminate_master, "std::terminate master"},
4735 {bp_exception_master, "exception master"},
4736 {bp_catchpoint, "catchpoint"},
4737 {bp_tracepoint, "tracepoint"},
4738 {bp_fast_tracepoint, "fast tracepoint"},
4739 {bp_static_tracepoint, "static tracepoint"},
4740 {bp_jit_event, "jit events"},
4741 {bp_gnu_ifunc_resolver, "STT_GNU_IFUNC resolver"},
4742 {bp_gnu_ifunc_resolver_return, "STT_GNU_IFUNC resolver return"},
4745 if (((int) type >= (sizeof (bptypes) / sizeof (bptypes[0])))
4746 || ((int) type != bptypes[(int) type].type))
4747 internal_error (__FILE__, __LINE__,
4748 _("bptypes table does not describe type #%d."),
4751 return bptypes[(int) type].description;
4754 /* Print B to gdb_stdout. */
4757 print_one_breakpoint_location (struct breakpoint *b,
4758 struct bp_location *loc,
4760 struct bp_location **last_loc,
4763 struct command_line *l;
4764 static char bpenables[] = "nynny";
4766 int header_of_multiple = 0;
4767 int part_of_multiple = (loc != NULL);
4768 struct value_print_options opts;
4770 get_user_print_options (&opts);
4772 gdb_assert (!loc || loc_number != 0);
4773 /* See comment in print_one_breakpoint concerning treatment of
4774 breakpoints with single disabled location. */
4777 && (b->loc->next != NULL || !b->loc->enabled)))
4778 header_of_multiple = 1;
4786 if (part_of_multiple)
4789 formatted = xstrprintf ("%d.%d", b->number, loc_number);
4790 ui_out_field_string (uiout, "number", formatted);
4795 ui_out_field_int (uiout, "number", b->number);
4800 if (part_of_multiple)
4801 ui_out_field_skip (uiout, "type");
4803 ui_out_field_string (uiout, "type", bptype_string (b->type));
4807 if (part_of_multiple)
4808 ui_out_field_skip (uiout, "disp");
4810 ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
4815 if (part_of_multiple)
4816 ui_out_field_string (uiout, "enabled", loc->enabled ? "y" : "n");
4818 ui_out_field_fmt (uiout, "enabled", "%c",
4819 bpenables[(int) b->enable_state]);
4820 ui_out_spaces (uiout, 2);
4824 if (b->ops != NULL && b->ops->print_one != NULL)
4826 /* Although the print_one can possibly print all locations,
4827 calling it here is not likely to get any nice result. So,
4828 make sure there's just one location. */
4829 gdb_assert (b->loc == NULL || b->loc->next == NULL);
4830 b->ops->print_one (b, last_loc);
4836 internal_error (__FILE__, __LINE__,
4837 _("print_one_breakpoint: bp_none encountered\n"));
4841 case bp_hardware_watchpoint:
4842 case bp_read_watchpoint:
4843 case bp_access_watchpoint:
4844 /* Field 4, the address, is omitted (which makes the columns
4845 not line up too nicely with the headers, but the effect
4846 is relatively readable). */
4847 if (opts.addressprint)
4848 ui_out_field_skip (uiout, "addr");
4850 ui_out_field_string (uiout, "what", b->exp_string);
4854 case bp_hardware_breakpoint:
4858 case bp_longjmp_resume:
4860 case bp_exception_resume:
4861 case bp_step_resume:
4862 case bp_watchpoint_scope:
4864 case bp_std_terminate:
4865 case bp_shlib_event:
4866 case bp_thread_event:
4867 case bp_overlay_event:
4868 case bp_longjmp_master:
4869 case bp_std_terminate_master:
4870 case bp_exception_master:
4872 case bp_fast_tracepoint:
4873 case bp_static_tracepoint:
4875 case bp_gnu_ifunc_resolver:
4876 case bp_gnu_ifunc_resolver_return:
4877 if (opts.addressprint)
4880 if (header_of_multiple)
4881 ui_out_field_string (uiout, "addr", "<MULTIPLE>");
4882 else if (b->loc == NULL || loc->shlib_disabled)
4883 ui_out_field_string (uiout, "addr", "<PENDING>");
4885 ui_out_field_core_addr (uiout, "addr",
4886 loc->gdbarch, loc->address);
4889 if (!header_of_multiple)
4890 print_breakpoint_location (b, loc);
4897 /* For backward compatibility, don't display inferiors unless there
4900 && !header_of_multiple
4902 || (!gdbarch_has_global_breakpoints (target_gdbarch)
4903 && (number_of_program_spaces () > 1
4904 || number_of_inferiors () > 1)
4905 /* LOC is for existing B, it cannot be in
4906 moribund_locations and thus having NULL OWNER. */
4907 && loc->owner->type != bp_catchpoint)))
4909 struct inferior *inf;
4912 for (inf = inferior_list; inf != NULL; inf = inf->next)
4914 if (inf->pspace == loc->pspace)
4919 ui_out_text (uiout, " inf ");
4922 ui_out_text (uiout, ", ");
4923 ui_out_text (uiout, plongest (inf->num));
4928 if (!part_of_multiple)
4930 if (b->thread != -1)
4932 /* FIXME: This seems to be redundant and lost here; see the
4933 "stop only in" line a little further down. */
4934 ui_out_text (uiout, " thread ");
4935 ui_out_field_int (uiout, "thread", b->thread);
4937 else if (b->task != 0)
4939 ui_out_text (uiout, " task ");
4940 ui_out_field_int (uiout, "task", b->task);
4944 ui_out_text (uiout, "\n");
4946 if (!part_of_multiple && b->ops && b->ops->print_one_detail)
4947 b->ops->print_one_detail (b, uiout);
4949 if (!part_of_multiple && b->static_trace_marker_id)
4951 gdb_assert (b->type == bp_static_tracepoint);
4953 ui_out_text (uiout, "\tmarker id is ");
4954 ui_out_field_string (uiout, "static-tracepoint-marker-string-id",
4955 b->static_trace_marker_id);
4956 ui_out_text (uiout, "\n");
4959 if (part_of_multiple && frame_id_p (b->frame_id))
4962 ui_out_text (uiout, "\tstop only in stack frame at ");
4963 /* FIXME: cagney/2002-12-01: Shouldn't be poeking around inside
4965 ui_out_field_core_addr (uiout, "frame",
4966 b->gdbarch, b->frame_id.stack_addr);
4967 ui_out_text (uiout, "\n");
4970 if (!part_of_multiple && b->cond_string && !ada_exception_catchpoint_p (b))
4972 /* We do not print the condition for Ada exception catchpoints
4973 because the condition is an internal implementation detail
4974 that we do not want to expose to the user. */
4976 if (is_tracepoint (b))
4977 ui_out_text (uiout, "\ttrace only if ");
4979 ui_out_text (uiout, "\tstop only if ");
4980 ui_out_field_string (uiout, "cond", b->cond_string);
4981 ui_out_text (uiout, "\n");
4984 if (!part_of_multiple && b->thread != -1)
4986 /* FIXME should make an annotation for this. */
4987 ui_out_text (uiout, "\tstop only in thread ");
4988 ui_out_field_int (uiout, "thread", b->thread);
4989 ui_out_text (uiout, "\n");
4992 if (!part_of_multiple && b->hit_count)
4994 /* FIXME should make an annotation for this. */
4995 if (ep_is_catchpoint (b))
4996 ui_out_text (uiout, "\tcatchpoint");
4998 ui_out_text (uiout, "\tbreakpoint");
4999 ui_out_text (uiout, " already hit ");
5000 ui_out_field_int (uiout, "times", b->hit_count);
5001 if (b->hit_count == 1)
5002 ui_out_text (uiout, " time\n");
5004 ui_out_text (uiout, " times\n");
5007 /* Output the count also if it is zero, but only if this is mi.
5008 FIXME: Should have a better test for this. */
5009 if (ui_out_is_mi_like_p (uiout))
5010 if (!part_of_multiple && b->hit_count == 0)
5011 ui_out_field_int (uiout, "times", b->hit_count);
5013 if (!part_of_multiple && b->ignore_count)
5016 ui_out_text (uiout, "\tignore next ");
5017 ui_out_field_int (uiout, "ignore", b->ignore_count);
5018 ui_out_text (uiout, " hits\n");
5021 l = b->commands ? b->commands->commands : NULL;
5022 if (!part_of_multiple && l)
5024 struct cleanup *script_chain;
5027 script_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "script");
5028 print_command_lines (uiout, l, 4);
5029 do_cleanups (script_chain);
5032 if (!part_of_multiple && b->pass_count)
5034 annotate_field (10);
5035 ui_out_text (uiout, "\tpass count ");
5036 ui_out_field_int (uiout, "pass", b->pass_count);
5037 ui_out_text (uiout, " \n");
5040 if (ui_out_is_mi_like_p (uiout) && !part_of_multiple)
5043 ui_out_field_string (uiout, "original-location", b->addr_string);
5044 else if (b->exp_string)
5045 ui_out_field_string (uiout, "original-location", b->exp_string);
5050 print_one_breakpoint (struct breakpoint *b,
5051 struct bp_location **last_loc,
5054 struct cleanup *bkpt_chain;
5056 bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "bkpt");
5058 print_one_breakpoint_location (b, NULL, 0, last_loc, allflag);
5059 do_cleanups (bkpt_chain);
5061 /* If this breakpoint has custom print function,
5062 it's already printed. Otherwise, print individual
5063 locations, if any. */
5064 if (b->ops == NULL || b->ops->print_one == NULL)
5066 /* If breakpoint has a single location that is disabled, we
5067 print it as if it had several locations, since otherwise it's
5068 hard to represent "breakpoint enabled, location disabled"
5071 Note that while hardware watchpoints have several locations
5072 internally, that's not a property exposed to user. */
5074 && !is_hardware_watchpoint (b)
5075 && (b->loc->next || !b->loc->enabled))
5077 struct bp_location *loc;
5080 for (loc = b->loc; loc; loc = loc->next, ++n)
5082 struct cleanup *inner2 =
5083 make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
5084 print_one_breakpoint_location (b, loc, n, last_loc, allflag);
5085 do_cleanups (inner2);
5092 breakpoint_address_bits (struct breakpoint *b)
5094 int print_address_bits = 0;
5095 struct bp_location *loc;
5097 for (loc = b->loc; loc; loc = loc->next)
5101 /* Software watchpoints that aren't watching memory don't have
5102 an address to print. */
5103 if (b->type == bp_watchpoint && loc->watchpoint_type == -1)
5106 addr_bit = gdbarch_addr_bit (loc->gdbarch);
5107 if (addr_bit > print_address_bits)
5108 print_address_bits = addr_bit;
5111 return print_address_bits;
5114 struct captured_breakpoint_query_args
5120 do_captured_breakpoint_query (struct ui_out *uiout, void *data)
5122 struct captured_breakpoint_query_args *args = data;
5123 struct breakpoint *b;
5124 struct bp_location *dummy_loc = NULL;
5128 if (args->bnum == b->number)
5130 print_one_breakpoint (b, &dummy_loc, 0);
5138 gdb_breakpoint_query (struct ui_out *uiout, int bnum,
5139 char **error_message)
5141 struct captured_breakpoint_query_args args;
5144 /* For the moment we don't trust print_one_breakpoint() to not throw
5146 if (catch_exceptions_with_msg (uiout, do_captured_breakpoint_query, &args,
5147 error_message, RETURN_MASK_ALL) < 0)
5153 /* Return true if this breakpoint was set by the user, false if it is
5154 internal or momentary. */
5157 user_breakpoint_p (struct breakpoint *b)
5159 return b->number > 0;
5162 /* Print information on user settable breakpoint (watchpoint, etc)
5163 number BNUM. If BNUM is -1 print all user-settable breakpoints.
5164 If ALLFLAG is non-zero, include non-user-settable breakpoints. If
5165 FILTER is non-NULL, call it on each breakpoint and only include the
5166 ones for which it returns non-zero. Return the total number of
5167 breakpoints listed. */
5170 breakpoint_1 (char *args, int allflag,
5171 int (*filter) (const struct breakpoint *))
5173 struct breakpoint *b;
5174 struct bp_location *last_loc = NULL;
5175 int nr_printable_breakpoints;
5176 struct cleanup *bkpttbl_chain;
5177 struct value_print_options opts;
5178 int print_address_bits = 0;
5179 int print_type_col_width = 14;
5181 get_user_print_options (&opts);
5183 /* Compute the number of rows in the table, as well as the size
5184 required for address fields. */
5185 nr_printable_breakpoints = 0;
5188 /* If we have a filter, only list the breakpoints it accepts. */
5189 if (filter && !filter (b))
5192 /* If we have an "args" string, it is a list of breakpoints to
5193 accept. Skip the others. */
5194 if (args != NULL && *args != '\0')
5196 if (allflag && parse_and_eval_long (args) != b->number)
5198 if (!allflag && !number_is_in_list (args, b->number))
5202 if (allflag || user_breakpoint_p (b))
5204 int addr_bit, type_len;
5206 addr_bit = breakpoint_address_bits (b);
5207 if (addr_bit > print_address_bits)
5208 print_address_bits = addr_bit;
5210 type_len = strlen (bptype_string (b->type));
5211 if (type_len > print_type_col_width)
5212 print_type_col_width = type_len;
5214 nr_printable_breakpoints++;
5218 if (opts.addressprint)
5220 = make_cleanup_ui_out_table_begin_end (uiout, 6,
5221 nr_printable_breakpoints,
5225 = make_cleanup_ui_out_table_begin_end (uiout, 5,
5226 nr_printable_breakpoints,
5229 if (nr_printable_breakpoints > 0)
5230 annotate_breakpoints_headers ();
5231 if (nr_printable_breakpoints > 0)
5233 ui_out_table_header (uiout, 7, ui_left, "number", "Num"); /* 1 */
5234 if (nr_printable_breakpoints > 0)
5236 ui_out_table_header (uiout, print_type_col_width, ui_left,
5237 "type", "Type"); /* 2 */
5238 if (nr_printable_breakpoints > 0)
5240 ui_out_table_header (uiout, 4, ui_left, "disp", "Disp"); /* 3 */
5241 if (nr_printable_breakpoints > 0)
5243 ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb"); /* 4 */
5244 if (opts.addressprint)
5246 if (nr_printable_breakpoints > 0)
5248 if (print_address_bits <= 32)
5249 ui_out_table_header (uiout, 10, ui_left,
5250 "addr", "Address"); /* 5 */
5252 ui_out_table_header (uiout, 18, ui_left,
5253 "addr", "Address"); /* 5 */
5255 if (nr_printable_breakpoints > 0)
5257 ui_out_table_header (uiout, 40, ui_noalign, "what", "What"); /* 6 */
5258 ui_out_table_body (uiout);
5259 if (nr_printable_breakpoints > 0)
5260 annotate_breakpoints_table ();
5265 /* If we have a filter, only list the breakpoints it accepts. */
5266 if (filter && !filter (b))
5269 /* If we have an "args" string, it is a list of breakpoints to
5270 accept. Skip the others. */
5272 if (args != NULL && *args != '\0')
5274 if (allflag) /* maintenance info breakpoint */
5276 if (parse_and_eval_long (args) != b->number)
5279 else /* all others */
5281 if (!number_is_in_list (args, b->number))
5285 /* We only print out user settable breakpoints unless the
5287 if (allflag || user_breakpoint_p (b))
5288 print_one_breakpoint (b, &last_loc, allflag);
5291 do_cleanups (bkpttbl_chain);
5293 if (nr_printable_breakpoints == 0)
5295 /* If there's a filter, let the caller decide how to report
5299 if (args == NULL || *args == '\0')
5300 ui_out_message (uiout, 0, "No breakpoints or watchpoints.\n");
5302 ui_out_message (uiout, 0,
5303 "No breakpoint or watchpoint matching '%s'.\n",
5309 if (last_loc && !server_command)
5310 set_next_address (last_loc->gdbarch, last_loc->address);
5313 /* FIXME? Should this be moved up so that it is only called when
5314 there have been breakpoints? */
5315 annotate_breakpoints_table_end ();
5317 return nr_printable_breakpoints;
5320 /* Display the value of default-collect in a way that is generally
5321 compatible with the breakpoint list. */
5324 default_collect_info (void)
5326 /* If it has no value (which is frequently the case), say nothing; a
5327 message like "No default-collect." gets in user's face when it's
5329 if (!*default_collect)
5332 /* The following phrase lines up nicely with per-tracepoint collect
5334 ui_out_text (uiout, "default collect ");
5335 ui_out_field_string (uiout, "default-collect", default_collect);
5336 ui_out_text (uiout, " \n");
5340 breakpoints_info (char *args, int from_tty)
5342 breakpoint_1 (args, 0, NULL);
5344 default_collect_info ();
5348 watchpoints_info (char *args, int from_tty)
5350 int num_printed = breakpoint_1 (args, 0, is_watchpoint);
5352 if (num_printed == 0)
5354 if (args == NULL || *args == '\0')
5355 ui_out_message (uiout, 0, "No watchpoints.\n");
5357 ui_out_message (uiout, 0, "No watchpoint matching '%s'.\n", args);
5362 maintenance_info_breakpoints (char *args, int from_tty)
5364 breakpoint_1 (args, 1, NULL);
5366 default_collect_info ();
5370 breakpoint_has_pc (struct breakpoint *b,
5371 struct program_space *pspace,
5372 CORE_ADDR pc, struct obj_section *section)
5374 struct bp_location *bl = b->loc;
5376 for (; bl; bl = bl->next)
5378 if (bl->pspace == pspace
5379 && bl->address == pc
5380 && (!overlay_debugging || bl->section == section))
5386 /* Print a message describing any breakpoints set at PC. This
5387 concerns with logical breakpoints, so we match program spaces, not
5391 describe_other_breakpoints (struct gdbarch *gdbarch,
5392 struct program_space *pspace, CORE_ADDR pc,
5393 struct obj_section *section, int thread)
5396 struct breakpoint *b;
5399 others += breakpoint_has_pc (b, pspace, pc, section);
5403 printf_filtered (_("Note: breakpoint "));
5404 else /* if (others == ???) */
5405 printf_filtered (_("Note: breakpoints "));
5407 if (breakpoint_has_pc (b, pspace, pc, section))
5410 printf_filtered ("%d", b->number);
5411 if (b->thread == -1 && thread != -1)
5412 printf_filtered (" (all threads)");
5413 else if (b->thread != -1)
5414 printf_filtered (" (thread %d)", b->thread);
5415 printf_filtered ("%s%s ",
5416 ((b->enable_state == bp_disabled
5417 || b->enable_state == bp_call_disabled
5418 || b->enable_state == bp_startup_disabled)
5420 : b->enable_state == bp_permanent
5424 : ((others == 1) ? " and" : ""));
5426 printf_filtered (_("also set at pc "));
5427 fputs_filtered (paddress (gdbarch, pc), gdb_stdout);
5428 printf_filtered (".\n");
5432 /* Set the default place to put a breakpoint
5433 for the `break' command with no arguments. */
5436 set_default_breakpoint (int valid, struct program_space *pspace,
5437 CORE_ADDR addr, struct symtab *symtab,
5440 default_breakpoint_valid = valid;
5441 default_breakpoint_pspace = pspace;
5442 default_breakpoint_address = addr;
5443 default_breakpoint_symtab = symtab;
5444 default_breakpoint_line = line;
5447 /* Return true iff it is meaningful to use the address member of
5448 BPT. For some breakpoint types, the address member is irrelevant
5449 and it makes no sense to attempt to compare it to other addresses
5450 (or use it for any other purpose either).
5452 More specifically, each of the following breakpoint types will
5453 always have a zero valued address and we don't want to mark
5454 breakpoints of any of these types to be a duplicate of an actual
5455 breakpoint at address zero:
5463 breakpoint_address_is_meaningful (struct breakpoint *bpt)
5465 enum bptype type = bpt->type;
5467 return (type != bp_watchpoint && type != bp_catchpoint);
5470 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
5471 true if LOC1 and LOC2 represent the same watchpoint location. */
5474 watchpoint_locations_match (struct bp_location *loc1,
5475 struct bp_location *loc2)
5477 /* Both of them must not be in moribund_locations. */
5478 gdb_assert (loc1->owner != NULL);
5479 gdb_assert (loc2->owner != NULL);
5481 /* If the target can evaluate the condition expression in hardware,
5482 then we we need to insert both watchpoints even if they are at
5483 the same place. Otherwise the watchpoint will only trigger when
5484 the condition of whichever watchpoint was inserted evaluates to
5485 true, not giving a chance for GDB to check the condition of the
5486 other watchpoint. */
5487 if ((loc1->owner->cond_exp
5488 && target_can_accel_watchpoint_condition (loc1->address,
5490 loc1->watchpoint_type,
5491 loc1->owner->cond_exp))
5492 || (loc2->owner->cond_exp
5493 && target_can_accel_watchpoint_condition (loc2->address,
5495 loc2->watchpoint_type,
5496 loc2->owner->cond_exp)))
5499 /* Note that this checks the owner's type, not the location's. In
5500 case the target does not support read watchpoints, but does
5501 support access watchpoints, we'll have bp_read_watchpoint
5502 watchpoints with hw_access locations. Those should be considered
5503 duplicates of hw_read locations. The hw_read locations will
5504 become hw_access locations later. */
5505 return (loc1->owner->type == loc2->owner->type
5506 && loc1->pspace->aspace == loc2->pspace->aspace
5507 && loc1->address == loc2->address
5508 && loc1->length == loc2->length);
5511 /* Returns true if {ASPACE1,ADDR1} and {ASPACE2,ADDR2} represent the
5512 same breakpoint location. In most targets, this can only be true
5513 if ASPACE1 matches ASPACE2. On targets that have global
5514 breakpoints, the address space doesn't really matter. */
5517 breakpoint_address_match (struct address_space *aspace1, CORE_ADDR addr1,
5518 struct address_space *aspace2, CORE_ADDR addr2)
5520 return ((gdbarch_has_global_breakpoints (target_gdbarch)
5521 || aspace1 == aspace2)
5525 /* Returns true if {ASPACE2,ADDR2} falls within the range determined by
5526 {ASPACE1,ADDR1,LEN1}. In most targets, this can only be true if ASPACE1
5527 matches ASPACE2. On targets that have global breakpoints, the address
5528 space doesn't really matter. */
5531 breakpoint_address_match_range (struct address_space *aspace1, CORE_ADDR addr1,
5532 int len1, struct address_space *aspace2,
5535 return ((gdbarch_has_global_breakpoints (target_gdbarch)
5536 || aspace1 == aspace2)
5537 && addr2 >= addr1 && addr2 < addr1 + len1);
5540 /* Returns true if {ASPACE,ADDR} matches the breakpoint BL. BL may be
5541 a ranged breakpoint. In most targets, a match happens only if ASPACE
5542 matches the breakpoint's address space. On targets that have global
5543 breakpoints, the address space doesn't really matter. */
5546 breakpoint_location_address_match (struct bp_location *bl,
5547 struct address_space *aspace,
5550 return (breakpoint_address_match (bl->pspace->aspace, bl->address,
5553 && breakpoint_address_match_range (bl->pspace->aspace,
5554 bl->address, bl->length,
5558 /* Assuming LOC1 and LOC2's types' have meaningful target addresses
5559 (breakpoint_address_is_meaningful), returns true if LOC1 and LOC2
5560 represent the same location. */
5563 breakpoint_locations_match (struct bp_location *loc1,
5564 struct bp_location *loc2)
5566 int hw_point1, hw_point2;
5568 /* Both of them must not be in moribund_locations. */
5569 gdb_assert (loc1->owner != NULL);
5570 gdb_assert (loc2->owner != NULL);
5572 hw_point1 = is_hardware_watchpoint (loc1->owner);
5573 hw_point2 = is_hardware_watchpoint (loc2->owner);
5575 if (hw_point1 != hw_point2)
5578 return watchpoint_locations_match (loc1, loc2);
5580 /* We compare bp_location.length in order to cover ranged breakpoints. */
5581 return (breakpoint_address_match (loc1->pspace->aspace, loc1->address,
5582 loc2->pspace->aspace, loc2->address)
5583 && loc1->length == loc2->length);
5587 breakpoint_adjustment_warning (CORE_ADDR from_addr, CORE_ADDR to_addr,
5588 int bnum, int have_bnum)
5590 /* The longest string possibly returned by hex_string_custom
5591 is 50 chars. These must be at least that big for safety. */
5595 strcpy (astr1, hex_string_custom ((unsigned long) from_addr, 8));
5596 strcpy (astr2, hex_string_custom ((unsigned long) to_addr, 8));
5598 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
5599 bnum, astr1, astr2);
5601 warning (_("Breakpoint address adjusted from %s to %s."), astr1, astr2);
5604 /* Adjust a breakpoint's address to account for architectural
5605 constraints on breakpoint placement. Return the adjusted address.
5606 Note: Very few targets require this kind of adjustment. For most
5607 targets, this function is simply the identity function. */
5610 adjust_breakpoint_address (struct gdbarch *gdbarch,
5611 CORE_ADDR bpaddr, enum bptype bptype)
5613 if (!gdbarch_adjust_breakpoint_address_p (gdbarch))
5615 /* Very few targets need any kind of breakpoint adjustment. */
5618 else if (bptype == bp_watchpoint
5619 || bptype == bp_hardware_watchpoint
5620 || bptype == bp_read_watchpoint
5621 || bptype == bp_access_watchpoint
5622 || bptype == bp_catchpoint)
5624 /* Watchpoints and the various bp_catch_* eventpoints should not
5625 have their addresses modified. */
5630 CORE_ADDR adjusted_bpaddr;
5632 /* Some targets have architectural constraints on the placement
5633 of breakpoint instructions. Obtain the adjusted address. */
5634 adjusted_bpaddr = gdbarch_adjust_breakpoint_address (gdbarch, bpaddr);
5636 /* An adjusted breakpoint address can significantly alter
5637 a user's expectations. Print a warning if an adjustment
5639 if (adjusted_bpaddr != bpaddr)
5640 breakpoint_adjustment_warning (bpaddr, adjusted_bpaddr, 0, 0);
5642 return adjusted_bpaddr;
5646 /* Allocate a struct bp_location. */
5648 static struct bp_location *
5649 allocate_bp_location (struct breakpoint *bpt)
5651 struct bp_location *loc;
5653 loc = xmalloc (sizeof (struct bp_location));
5654 memset (loc, 0, sizeof (*loc));
5658 loc->shlib_disabled = 0;
5667 case bp_longjmp_resume:
5669 case bp_exception_resume:
5670 case bp_step_resume:
5671 case bp_watchpoint_scope:
5673 case bp_std_terminate:
5674 case bp_shlib_event:
5675 case bp_thread_event:
5676 case bp_overlay_event:
5678 case bp_longjmp_master:
5679 case bp_std_terminate_master:
5680 case bp_exception_master:
5681 case bp_gnu_ifunc_resolver:
5682 case bp_gnu_ifunc_resolver_return:
5683 loc->loc_type = bp_loc_software_breakpoint;
5685 case bp_hardware_breakpoint:
5686 loc->loc_type = bp_loc_hardware_breakpoint;
5688 case bp_hardware_watchpoint:
5689 case bp_read_watchpoint:
5690 case bp_access_watchpoint:
5691 loc->loc_type = bp_loc_hardware_watchpoint;
5696 case bp_fast_tracepoint:
5697 case bp_static_tracepoint:
5698 loc->loc_type = bp_loc_other;
5701 internal_error (__FILE__, __LINE__, _("unknown breakpoint type"));
5709 free_bp_location (struct bp_location *loc)
5714 if (loc->function_name)
5715 xfree (loc->function_name);
5720 /* Increment reference count. */
5723 incref_bp_location (struct bp_location *bl)
5728 /* Decrement reference count. If the reference count reaches 0,
5729 destroy the bp_location. Sets *BLP to NULL. */
5732 decref_bp_location (struct bp_location **blp)
5734 gdb_assert ((*blp)->refc > 0);
5736 if (--(*blp)->refc == 0)
5737 free_bp_location (*blp);
5741 /* Helper to set_raw_breakpoint below. Creates a breakpoint that has
5742 type BPTYPE and has no locations as yet. */
5743 /* This function is used in gdbtk sources and thus can not be made
5746 static struct breakpoint *
5747 set_raw_breakpoint_without_location (struct gdbarch *gdbarch,
5750 struct breakpoint *b, *b1;
5752 b = (struct breakpoint *) xmalloc (sizeof (struct breakpoint));
5753 memset (b, 0, sizeof (*b));
5756 b->gdbarch = gdbarch;
5757 b->language = current_language->la_language;
5758 b->input_radix = input_radix;
5760 b->enable_state = bp_enabled;
5763 b->ignore_count = 0;
5765 b->frame_id = null_frame_id;
5766 b->forked_inferior_pid = null_ptid;
5767 b->exec_pathname = NULL;
5768 b->syscalls_to_be_caught = NULL;
5770 b->condition_not_parsed = 0;
5771 b->py_bp_object = NULL;
5772 b->related_breakpoint = b;
5774 /* Add this breakpoint to the end of the chain so that a list of
5775 breakpoints will come out in order of increasing numbers. */
5777 b1 = breakpoint_chain;
5779 breakpoint_chain = b;
5789 /* Initialize loc->function_name. EXPLICIT_LOC says no indirect function
5790 resolutions should be made as the user specified the location explicitly
5794 set_breakpoint_location_function (struct bp_location *loc, int explicit_loc)
5796 gdb_assert (loc->owner != NULL);
5798 if (loc->owner->type == bp_breakpoint
5799 || loc->owner->type == bp_hardware_breakpoint
5800 || is_tracepoint (loc->owner))
5804 find_pc_partial_function_gnu_ifunc (loc->address, &loc->function_name,
5805 NULL, NULL, &is_gnu_ifunc);
5807 if (is_gnu_ifunc && !explicit_loc)
5809 struct breakpoint *b = loc->owner;
5811 gdb_assert (loc->pspace == current_program_space);
5812 if (gnu_ifunc_resolve_name (loc->function_name,
5813 &loc->requested_address))
5815 /* Recalculate ADDRESS based on new REQUESTED_ADDRESS. */
5816 loc->address = adjust_breakpoint_address (loc->gdbarch,
5817 loc->requested_address,
5820 else if (b->type == bp_breakpoint && b->loc == loc
5821 && loc->next == NULL && b->related_breakpoint == b)
5823 /* Create only the whole new breakpoint of this type but do not
5824 mess more complicated breakpoints with multiple locations. */
5825 b->type = bp_gnu_ifunc_resolver;
5829 if (loc->function_name)
5830 loc->function_name = xstrdup (loc->function_name);
5834 /* Attempt to determine architecture of location identified by SAL. */
5835 static struct gdbarch *
5836 get_sal_arch (struct symtab_and_line sal)
5839 return get_objfile_arch (sal.section->objfile);
5841 return get_objfile_arch (sal.symtab->objfile);
5846 /* set_raw_breakpoint is a low level routine for allocating and
5847 partially initializing a breakpoint of type BPTYPE. The newly
5848 created breakpoint's address, section, source file name, and line
5849 number are provided by SAL. The newly created and partially
5850 initialized breakpoint is added to the breakpoint chain and
5851 is also returned as the value of this function.
5853 It is expected that the caller will complete the initialization of
5854 the newly created breakpoint struct as well as output any status
5855 information regarding the creation of a new breakpoint. In
5856 particular, set_raw_breakpoint does NOT set the breakpoint
5857 number! Care should be taken to not allow an error to occur
5858 prior to completing the initialization of the breakpoint. If this
5859 should happen, a bogus breakpoint will be left on the chain. */
5862 set_raw_breakpoint (struct gdbarch *gdbarch,
5863 struct symtab_and_line sal, enum bptype bptype)
5865 struct breakpoint *b = set_raw_breakpoint_without_location (gdbarch,
5867 CORE_ADDR adjusted_address;
5868 struct gdbarch *loc_gdbarch;
5870 loc_gdbarch = get_sal_arch (sal);
5872 loc_gdbarch = b->gdbarch;
5874 if (bptype != bp_catchpoint)
5875 gdb_assert (sal.pspace != NULL);
5877 /* Adjust the breakpoint's address prior to allocating a location.
5878 Once we call allocate_bp_location(), that mostly uninitialized
5879 location will be placed on the location chain. Adjustment of the
5880 breakpoint may cause target_read_memory() to be called and we do
5881 not want its scan of the location chain to find a breakpoint and
5882 location that's only been partially initialized. */
5883 adjusted_address = adjust_breakpoint_address (loc_gdbarch,
5886 b->loc = allocate_bp_location (b);
5887 b->loc->gdbarch = loc_gdbarch;
5888 b->loc->requested_address = sal.pc;
5889 b->loc->address = adjusted_address;
5890 b->loc->pspace = sal.pspace;
5892 /* Store the program space that was used to set the breakpoint, for
5893 breakpoint resetting. */
5894 b->pspace = sal.pspace;
5896 if (sal.symtab == NULL)
5897 b->source_file = NULL;
5899 b->source_file = xstrdup (sal.symtab->filename);
5900 b->loc->section = sal.section;
5901 b->line_number = sal.line;
5903 set_breakpoint_location_function (b->loc,
5904 sal.explicit_pc || sal.explicit_line);
5906 breakpoints_changed ();
5912 /* Note that the breakpoint object B describes a permanent breakpoint
5913 instruction, hard-wired into the inferior's code. */
5915 make_breakpoint_permanent (struct breakpoint *b)
5917 struct bp_location *bl;
5919 b->enable_state = bp_permanent;
5921 /* By definition, permanent breakpoints are already present in the
5922 code. Mark all locations as inserted. For now,
5923 make_breakpoint_permanent is called in just one place, so it's
5924 hard to say if it's reasonable to have permanent breakpoint with
5925 multiple locations or not, but it's easy to implmement. */
5926 for (bl = b->loc; bl; bl = bl->next)
5930 /* Call this routine when stepping and nexting to enable a breakpoint
5931 if we do a longjmp() or 'throw' in TP. FRAME is the frame which
5932 initiated the operation. */
5935 set_longjmp_breakpoint (struct thread_info *tp, struct frame_id frame)
5937 struct breakpoint *b, *b_tmp;
5938 int thread = tp->num;
5940 /* To avoid having to rescan all objfile symbols at every step,
5941 we maintain a list of continually-inserted but always disabled
5942 longjmp "master" breakpoints. Here, we simply create momentary
5943 clones of those and enable them for the requested thread. */
5944 ALL_BREAKPOINTS_SAFE (b, b_tmp)
5945 if (b->pspace == current_program_space
5946 && (b->type == bp_longjmp_master
5947 || b->type == bp_exception_master))
5949 struct breakpoint *clone = clone_momentary_breakpoint (b);
5951 clone->type = b->type == bp_longjmp_master ? bp_longjmp : bp_exception;
5952 clone->thread = thread;
5955 tp->initiating_frame = frame;
5958 /* Delete all longjmp breakpoints from THREAD. */
5960 delete_longjmp_breakpoint (int thread)
5962 struct breakpoint *b, *b_tmp;
5964 ALL_BREAKPOINTS_SAFE (b, b_tmp)
5965 if (b->type == bp_longjmp || b->type == bp_exception)
5967 if (b->thread == thread)
5968 delete_breakpoint (b);
5973 enable_overlay_breakpoints (void)
5975 struct breakpoint *b;
5978 if (b->type == bp_overlay_event)
5980 b->enable_state = bp_enabled;
5981 update_global_location_list (1);
5982 overlay_events_enabled = 1;
5987 disable_overlay_breakpoints (void)
5989 struct breakpoint *b;
5992 if (b->type == bp_overlay_event)
5994 b->enable_state = bp_disabled;
5995 update_global_location_list (0);
5996 overlay_events_enabled = 0;
6000 /* Set an active std::terminate breakpoint for each std::terminate
6001 master breakpoint. */
6003 set_std_terminate_breakpoint (void)
6005 struct breakpoint *b, *b_tmp;
6007 ALL_BREAKPOINTS_SAFE (b, b_tmp)
6008 if (b->pspace == current_program_space
6009 && b->type == bp_std_terminate_master)
6011 struct breakpoint *clone = clone_momentary_breakpoint (b);
6012 clone->type = bp_std_terminate;
6016 /* Delete all the std::terminate breakpoints. */
6018 delete_std_terminate_breakpoint (void)
6020 struct breakpoint *b, *b_tmp;
6022 ALL_BREAKPOINTS_SAFE (b, b_tmp)
6023 if (b->type == bp_std_terminate)
6024 delete_breakpoint (b);
6028 create_thread_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
6030 struct breakpoint *b;
6032 b = create_internal_breakpoint (gdbarch, address, bp_thread_event);
6034 b->enable_state = bp_enabled;
6035 /* addr_string has to be used or breakpoint_re_set will delete me. */
6037 = xstrprintf ("*%s", paddress (b->loc->gdbarch, b->loc->address));
6039 update_global_location_list_nothrow (1);
6045 remove_thread_event_breakpoints (void)
6047 struct breakpoint *b, *b_tmp;
6049 ALL_BREAKPOINTS_SAFE (b, b_tmp)
6050 if (b->type == bp_thread_event
6051 && b->loc->pspace == current_program_space)
6052 delete_breakpoint (b);
6055 struct lang_and_radix
6061 /* Create a breakpoint for JIT code registration and unregistration. */
6064 create_jit_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
6066 struct breakpoint *b;
6068 b = create_internal_breakpoint (gdbarch, address, bp_jit_event);
6069 update_global_location_list_nothrow (1);
6073 /* Remove JIT code registration and unregistration breakpoint(s). */
6076 remove_jit_event_breakpoints (void)
6078 struct breakpoint *b, *b_tmp;
6080 ALL_BREAKPOINTS_SAFE (b, b_tmp)
6081 if (b->type == bp_jit_event
6082 && b->loc->pspace == current_program_space)
6083 delete_breakpoint (b);
6087 remove_solib_event_breakpoints (void)
6089 struct breakpoint *b, *b_tmp;
6091 ALL_BREAKPOINTS_SAFE (b, b_tmp)
6092 if (b->type == bp_shlib_event
6093 && b->loc->pspace == current_program_space)
6094 delete_breakpoint (b);
6098 create_solib_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
6100 struct breakpoint *b;
6102 b = create_internal_breakpoint (gdbarch, address, bp_shlib_event);
6103 update_global_location_list_nothrow (1);
6107 /* Disable any breakpoints that are on code in shared libraries. Only
6108 apply to enabled breakpoints, disabled ones can just stay disabled. */
6111 disable_breakpoints_in_shlibs (void)
6113 struct bp_location *loc, **locp_tmp;
6115 ALL_BP_LOCATIONS (loc, locp_tmp)
6117 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
6118 struct breakpoint *b = loc->owner;
6120 /* We apply the check to all breakpoints, including disabled for
6121 those with loc->duplicate set. This is so that when breakpoint
6122 becomes enabled, or the duplicate is removed, gdb will try to
6123 insert all breakpoints. If we don't set shlib_disabled here,
6124 we'll try to insert those breakpoints and fail. */
6125 if (((b->type == bp_breakpoint)
6126 || (b->type == bp_jit_event)
6127 || (b->type == bp_hardware_breakpoint)
6128 || (is_tracepoint (b)))
6129 && loc->pspace == current_program_space
6130 && !loc->shlib_disabled
6132 && PC_SOLIB (loc->address)
6134 && solib_name_from_address (loc->pspace, loc->address)
6138 loc->shlib_disabled = 1;
6143 /* Disable any breakpoints that are in an unloaded shared library.
6144 Only apply to enabled breakpoints, disabled ones can just stay
6148 disable_breakpoints_in_unloaded_shlib (struct so_list *solib)
6150 struct bp_location *loc, **locp_tmp;
6151 int disabled_shlib_breaks = 0;
6153 /* SunOS a.out shared libraries are always mapped, so do not
6154 disable breakpoints; they will only be reported as unloaded
6155 through clear_solib when GDB discards its shared library
6156 list. See clear_solib for more information. */
6157 if (exec_bfd != NULL
6158 && bfd_get_flavour (exec_bfd) == bfd_target_aout_flavour)
6161 ALL_BP_LOCATIONS (loc, locp_tmp)
6163 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
6164 struct breakpoint *b = loc->owner;
6166 if ((loc->loc_type == bp_loc_hardware_breakpoint
6167 || loc->loc_type == bp_loc_software_breakpoint)
6168 && solib->pspace == loc->pspace
6169 && !loc->shlib_disabled
6170 && (b->type == bp_breakpoint
6171 || b->type == bp_jit_event
6172 || b->type == bp_hardware_breakpoint)
6173 && solib_contains_address_p (solib, loc->address))
6175 loc->shlib_disabled = 1;
6176 /* At this point, we cannot rely on remove_breakpoint
6177 succeeding so we must mark the breakpoint as not inserted
6178 to prevent future errors occurring in remove_breakpoints. */
6181 /* This may cause duplicate notifications for the same breakpoint. */
6182 observer_notify_breakpoint_modified (b);
6184 if (!disabled_shlib_breaks)
6186 target_terminal_ours_for_output ();
6187 warning (_("Temporarily disabling breakpoints "
6188 "for unloaded shared library \"%s\""),
6191 disabled_shlib_breaks = 1;
6196 /* FORK & VFORK catchpoints. */
6198 /* Implement the "insert" breakpoint_ops method for fork
6202 insert_catch_fork (struct bp_location *bl)
6204 return target_insert_fork_catchpoint (PIDGET (inferior_ptid));
6207 /* Implement the "remove" breakpoint_ops method for fork
6211 remove_catch_fork (struct bp_location *bl)
6213 return target_remove_fork_catchpoint (PIDGET (inferior_ptid));
6216 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
6220 breakpoint_hit_catch_fork (const struct bp_location *bl,
6221 struct address_space *aspace, CORE_ADDR bp_addr)
6223 return inferior_has_forked (inferior_ptid, &bl->owner->forked_inferior_pid);
6226 /* Implement the "print_it" breakpoint_ops method for fork
6229 static enum print_stop_action
6230 print_it_catch_fork (struct breakpoint *b)
6232 annotate_catchpoint (b->number);
6233 printf_filtered (_("\nCatchpoint %d (forked process %d), "),
6234 b->number, ptid_get_pid (b->forked_inferior_pid));
6235 return PRINT_SRC_AND_LOC;
6238 /* Implement the "print_one" breakpoint_ops method for fork
6242 print_one_catch_fork (struct breakpoint *b, struct bp_location **last_loc)
6244 struct value_print_options opts;
6246 get_user_print_options (&opts);
6248 /* Field 4, the address, is omitted (which makes the columns not
6249 line up too nicely with the headers, but the effect is relatively
6251 if (opts.addressprint)
6252 ui_out_field_skip (uiout, "addr");
6254 ui_out_text (uiout, "fork");
6255 if (!ptid_equal (b->forked_inferior_pid, null_ptid))
6257 ui_out_text (uiout, ", process ");
6258 ui_out_field_int (uiout, "what",
6259 ptid_get_pid (b->forked_inferior_pid));
6260 ui_out_spaces (uiout, 1);
6264 /* Implement the "print_mention" breakpoint_ops method for fork
6268 print_mention_catch_fork (struct breakpoint *b)
6270 printf_filtered (_("Catchpoint %d (fork)"), b->number);
6273 /* Implement the "print_recreate" breakpoint_ops method for fork
6277 print_recreate_catch_fork (struct breakpoint *b, struct ui_file *fp)
6279 fprintf_unfiltered (fp, "catch fork");
6282 /* The breakpoint_ops structure to be used in fork catchpoints. */
6284 static struct breakpoint_ops catch_fork_breakpoint_ops =
6288 breakpoint_hit_catch_fork,
6289 NULL, /* resources_needed */
6290 print_it_catch_fork,
6291 print_one_catch_fork,
6292 NULL, /* print_one_detail */
6293 print_mention_catch_fork,
6294 print_recreate_catch_fork
6297 /* Implement the "insert" breakpoint_ops method for vfork
6301 insert_catch_vfork (struct bp_location *bl)
6303 return target_insert_vfork_catchpoint (PIDGET (inferior_ptid));
6306 /* Implement the "remove" breakpoint_ops method for vfork
6310 remove_catch_vfork (struct bp_location *bl)
6312 return target_remove_vfork_catchpoint (PIDGET (inferior_ptid));
6315 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
6319 breakpoint_hit_catch_vfork (const struct bp_location *bl,
6320 struct address_space *aspace, CORE_ADDR bp_addr)
6322 return inferior_has_vforked (inferior_ptid, &bl->owner->forked_inferior_pid);
6325 /* Implement the "print_it" breakpoint_ops method for vfork
6328 static enum print_stop_action
6329 print_it_catch_vfork (struct breakpoint *b)
6331 annotate_catchpoint (b->number);
6332 printf_filtered (_("\nCatchpoint %d (vforked process %d), "),
6333 b->number, ptid_get_pid (b->forked_inferior_pid));
6334 return PRINT_SRC_AND_LOC;
6337 /* Implement the "print_one" breakpoint_ops method for vfork
6341 print_one_catch_vfork (struct breakpoint *b, struct bp_location **last_loc)
6343 struct value_print_options opts;
6345 get_user_print_options (&opts);
6346 /* Field 4, the address, is omitted (which makes the columns not
6347 line up too nicely with the headers, but the effect is relatively
6349 if (opts.addressprint)
6350 ui_out_field_skip (uiout, "addr");
6352 ui_out_text (uiout, "vfork");
6353 if (!ptid_equal (b->forked_inferior_pid, null_ptid))
6355 ui_out_text (uiout, ", process ");
6356 ui_out_field_int (uiout, "what",
6357 ptid_get_pid (b->forked_inferior_pid));
6358 ui_out_spaces (uiout, 1);
6362 /* Implement the "print_mention" breakpoint_ops method for vfork
6366 print_mention_catch_vfork (struct breakpoint *b)
6368 printf_filtered (_("Catchpoint %d (vfork)"), b->number);
6371 /* Implement the "print_recreate" breakpoint_ops method for vfork
6375 print_recreate_catch_vfork (struct breakpoint *b, struct ui_file *fp)
6377 fprintf_unfiltered (fp, "catch vfork");
6380 /* The breakpoint_ops structure to be used in vfork catchpoints. */
6382 static struct breakpoint_ops catch_vfork_breakpoint_ops =
6386 breakpoint_hit_catch_vfork,
6387 NULL, /* resources_needed */
6388 print_it_catch_vfork,
6389 print_one_catch_vfork,
6390 NULL, /* print_one_detail */
6391 print_mention_catch_vfork,
6392 print_recreate_catch_vfork
6395 /* Implement the "insert" breakpoint_ops method for syscall
6399 insert_catch_syscall (struct bp_location *bl)
6401 struct inferior *inf = current_inferior ();
6403 ++inf->total_syscalls_count;
6404 if (!bl->owner->syscalls_to_be_caught)
6405 ++inf->any_syscall_count;
6411 VEC_iterate (int, bl->owner->syscalls_to_be_caught, i, iter);
6416 if (iter >= VEC_length (int, inf->syscalls_counts))
6418 int old_size = VEC_length (int, inf->syscalls_counts);
6419 uintptr_t vec_addr_offset
6420 = old_size * ((uintptr_t) sizeof (int));
6422 VEC_safe_grow (int, inf->syscalls_counts, iter + 1);
6423 vec_addr = (uintptr_t) VEC_address (int, inf->syscalls_counts) +
6425 memset ((void *) vec_addr, 0,
6426 (iter + 1 - old_size) * sizeof (int));
6428 elem = VEC_index (int, inf->syscalls_counts, iter);
6429 VEC_replace (int, inf->syscalls_counts, iter, ++elem);
6433 return target_set_syscall_catchpoint (PIDGET (inferior_ptid),
6434 inf->total_syscalls_count != 0,
6435 inf->any_syscall_count,
6436 VEC_length (int, inf->syscalls_counts),
6437 VEC_address (int, inf->syscalls_counts));
6440 /* Implement the "remove" breakpoint_ops method for syscall
6444 remove_catch_syscall (struct bp_location *bl)
6446 struct inferior *inf = current_inferior ();
6448 --inf->total_syscalls_count;
6449 if (!bl->owner->syscalls_to_be_caught)
6450 --inf->any_syscall_count;
6456 VEC_iterate (int, bl->owner->syscalls_to_be_caught, i, iter);
6460 if (iter >= VEC_length (int, inf->syscalls_counts))
6461 /* Shouldn't happen. */
6463 elem = VEC_index (int, inf->syscalls_counts, iter);
6464 VEC_replace (int, inf->syscalls_counts, iter, --elem);
6468 return target_set_syscall_catchpoint (PIDGET (inferior_ptid),
6469 inf->total_syscalls_count != 0,
6470 inf->any_syscall_count,
6471 VEC_length (int, inf->syscalls_counts),
6473 inf->syscalls_counts));
6476 /* Implement the "breakpoint_hit" breakpoint_ops method for syscall
6480 breakpoint_hit_catch_syscall (const struct bp_location *bl,
6481 struct address_space *aspace, CORE_ADDR bp_addr)
6483 /* We must check if we are catching specific syscalls in this
6484 breakpoint. If we are, then we must guarantee that the called
6485 syscall is the same syscall we are catching. */
6486 int syscall_number = 0;
6487 const struct breakpoint *b = bl->owner;
6489 if (!inferior_has_called_syscall (inferior_ptid, &syscall_number))
6492 /* Now, checking if the syscall is the same. */
6493 if (b->syscalls_to_be_caught)
6498 VEC_iterate (int, b->syscalls_to_be_caught, i, iter);
6500 if (syscall_number == iter)
6510 /* Implement the "print_it" breakpoint_ops method for syscall
6513 static enum print_stop_action
6514 print_it_catch_syscall (struct breakpoint *b)
6516 /* These are needed because we want to know in which state a
6517 syscall is. It can be in the TARGET_WAITKIND_SYSCALL_ENTRY
6518 or TARGET_WAITKIND_SYSCALL_RETURN, and depending on it we
6519 must print "called syscall" or "returned from syscall". */
6521 struct target_waitstatus last;
6523 struct cleanup *old_chain;
6526 get_last_target_status (&ptid, &last);
6528 get_syscall_by_number (last.value.syscall_number, &s);
6530 annotate_catchpoint (b->number);
6533 syscall_id = xstrprintf ("%d", last.value.syscall_number);
6535 syscall_id = xstrprintf ("'%s'", s.name);
6537 old_chain = make_cleanup (xfree, syscall_id);
6539 if (last.kind == TARGET_WAITKIND_SYSCALL_ENTRY)
6540 printf_filtered (_("\nCatchpoint %d (call to syscall %s), "),
6541 b->number, syscall_id);
6542 else if (last.kind == TARGET_WAITKIND_SYSCALL_RETURN)
6543 printf_filtered (_("\nCatchpoint %d (returned from syscall %s), "),
6544 b->number, syscall_id);
6546 do_cleanups (old_chain);
6548 return PRINT_SRC_AND_LOC;
6551 /* Implement the "print_one" breakpoint_ops method for syscall
6555 print_one_catch_syscall (struct breakpoint *b,
6556 struct bp_location **last_loc)
6558 struct value_print_options opts;
6560 get_user_print_options (&opts);
6561 /* Field 4, the address, is omitted (which makes the columns not
6562 line up too nicely with the headers, but the effect is relatively
6564 if (opts.addressprint)
6565 ui_out_field_skip (uiout, "addr");
6568 if (b->syscalls_to_be_caught
6569 && VEC_length (int, b->syscalls_to_be_caught) > 1)
6570 ui_out_text (uiout, "syscalls \"");
6572 ui_out_text (uiout, "syscall \"");
6574 if (b->syscalls_to_be_caught)
6577 char *text = xstrprintf ("%s", "");
6580 VEC_iterate (int, b->syscalls_to_be_caught, i, iter);
6585 get_syscall_by_number (iter, &s);
6588 text = xstrprintf ("%s%s, ", text, s.name);
6590 text = xstrprintf ("%s%d, ", text, iter);
6592 /* We have to xfree the last 'text' (now stored at 'x')
6593 because xstrprintf dinamically allocates new space for it
6597 /* Remove the last comma. */
6598 text[strlen (text) - 2] = '\0';
6599 ui_out_field_string (uiout, "what", text);
6602 ui_out_field_string (uiout, "what", "<any syscall>");
6603 ui_out_text (uiout, "\" ");
6606 /* Implement the "print_mention" breakpoint_ops method for syscall
6610 print_mention_catch_syscall (struct breakpoint *b)
6612 if (b->syscalls_to_be_caught)
6616 if (VEC_length (int, b->syscalls_to_be_caught) > 1)
6617 printf_filtered (_("Catchpoint %d (syscalls"), b->number);
6619 printf_filtered (_("Catchpoint %d (syscall"), b->number);
6622 VEC_iterate (int, b->syscalls_to_be_caught, i, iter);
6626 get_syscall_by_number (iter, &s);
6629 printf_filtered (" '%s' [%d]", s.name, s.number);
6631 printf_filtered (" %d", s.number);
6633 printf_filtered (")");
6636 printf_filtered (_("Catchpoint %d (any syscall)"),
6640 /* Implement the "print_recreate" breakpoint_ops method for syscall
6644 print_recreate_catch_syscall (struct breakpoint *b, struct ui_file *fp)
6646 fprintf_unfiltered (fp, "catch syscall");
6648 if (b->syscalls_to_be_caught)
6653 VEC_iterate (int, b->syscalls_to_be_caught, i, iter);
6658 get_syscall_by_number (iter, &s);
6660 fprintf_unfiltered (fp, " %s", s.name);
6662 fprintf_unfiltered (fp, " %d", s.number);
6667 /* The breakpoint_ops structure to be used in syscall catchpoints. */
6669 static struct breakpoint_ops catch_syscall_breakpoint_ops =
6671 insert_catch_syscall,
6672 remove_catch_syscall,
6673 breakpoint_hit_catch_syscall,
6674 NULL, /* resources_needed */
6675 print_it_catch_syscall,
6676 print_one_catch_syscall,
6677 NULL, /* print_one_detail */
6678 print_mention_catch_syscall,
6679 print_recreate_catch_syscall
6682 /* Returns non-zero if 'b' is a syscall catchpoint. */
6685 syscall_catchpoint_p (struct breakpoint *b)
6687 return (b->ops == &catch_syscall_breakpoint_ops);
6690 /* Create a new breakpoint of the bp_catchpoint kind and return it,
6691 but does NOT mention it nor update the global location list.
6692 This is useful if you need to fill more fields in the
6693 struct breakpoint before calling mention.
6695 If TEMPFLAG is non-zero, then make the breakpoint temporary.
6696 If COND_STRING is not NULL, then store it in the breakpoint.
6697 OPS, if not NULL, is the breakpoint_ops structure associated
6698 to the catchpoint. */
6700 static struct breakpoint *
6701 create_catchpoint_without_mention (struct gdbarch *gdbarch, int tempflag,
6703 struct breakpoint_ops *ops)
6705 struct symtab_and_line sal;
6706 struct breakpoint *b;
6709 sal.pspace = current_program_space;
6711 b = set_raw_breakpoint (gdbarch, sal, bp_catchpoint);
6712 set_breakpoint_count (breakpoint_count + 1);
6713 b->number = breakpoint_count;
6715 b->cond_string = (cond_string == NULL) ? NULL : xstrdup (cond_string);
6717 b->addr_string = NULL;
6718 b->enable_state = bp_enabled;
6719 b->disposition = tempflag ? disp_del : disp_donttouch;
6725 /* Create a new breakpoint of the bp_catchpoint kind and return it.
6727 If TEMPFLAG is non-zero, then make the breakpoint temporary.
6728 If COND_STRING is not NULL, then store it in the breakpoint.
6729 OPS, if not NULL, is the breakpoint_ops structure associated
6730 to the catchpoint. */
6732 static struct breakpoint *
6733 create_catchpoint (struct gdbarch *gdbarch, int tempflag,
6734 char *cond_string, struct breakpoint_ops *ops)
6736 struct breakpoint *b =
6737 create_catchpoint_without_mention (gdbarch, tempflag, cond_string, ops);
6740 observer_notify_breakpoint_created (b);
6741 update_global_location_list (1);
6747 create_fork_vfork_event_catchpoint (struct gdbarch *gdbarch,
6748 int tempflag, char *cond_string,
6749 struct breakpoint_ops *ops)
6751 struct breakpoint *b
6752 = create_catchpoint (gdbarch, tempflag, cond_string, ops);
6754 /* FIXME: We should put this information in a breakpoint private data
6756 b->forked_inferior_pid = null_ptid;
6759 /* Exec catchpoints. */
6762 insert_catch_exec (struct bp_location *bl)
6764 return target_insert_exec_catchpoint (PIDGET (inferior_ptid));
6768 remove_catch_exec (struct bp_location *bl)
6770 return target_remove_exec_catchpoint (PIDGET (inferior_ptid));
6774 breakpoint_hit_catch_exec (const struct bp_location *bl,
6775 struct address_space *aspace, CORE_ADDR bp_addr)
6777 return inferior_has_execd (inferior_ptid, &bl->owner->exec_pathname);
6780 static enum print_stop_action
6781 print_it_catch_exec (struct breakpoint *b)
6783 annotate_catchpoint (b->number);
6784 printf_filtered (_("\nCatchpoint %d (exec'd %s), "), b->number,
6786 return PRINT_SRC_AND_LOC;
6790 print_one_catch_exec (struct breakpoint *b, struct bp_location **last_loc)
6792 struct value_print_options opts;
6794 get_user_print_options (&opts);
6796 /* Field 4, the address, is omitted (which makes the columns
6797 not line up too nicely with the headers, but the effect
6798 is relatively readable). */
6799 if (opts.addressprint)
6800 ui_out_field_skip (uiout, "addr");
6802 ui_out_text (uiout, "exec");
6803 if (b->exec_pathname != NULL)
6805 ui_out_text (uiout, ", program \"");
6806 ui_out_field_string (uiout, "what", b->exec_pathname);
6807 ui_out_text (uiout, "\" ");
6812 print_mention_catch_exec (struct breakpoint *b)
6814 printf_filtered (_("Catchpoint %d (exec)"), b->number);
6817 /* Implement the "print_recreate" breakpoint_ops method for exec
6821 print_recreate_catch_exec (struct breakpoint *b, struct ui_file *fp)
6823 fprintf_unfiltered (fp, "catch exec");
6826 static struct breakpoint_ops catch_exec_breakpoint_ops =
6830 breakpoint_hit_catch_exec,
6831 NULL, /* resources_needed */
6832 print_it_catch_exec,
6833 print_one_catch_exec,
6834 NULL, /* print_one_detail */
6835 print_mention_catch_exec,
6836 print_recreate_catch_exec
6840 create_syscall_event_catchpoint (int tempflag, VEC(int) *filter,
6841 struct breakpoint_ops *ops)
6843 struct gdbarch *gdbarch = get_current_arch ();
6844 struct breakpoint *b =
6845 create_catchpoint_without_mention (gdbarch, tempflag, NULL, ops);
6847 b->syscalls_to_be_caught = filter;
6849 /* Now, we have to mention the breakpoint and update the global
6852 observer_notify_breakpoint_created (b);
6853 update_global_location_list (1);
6857 hw_breakpoint_used_count (void)
6860 struct breakpoint *b;
6861 struct bp_location *bl;
6865 if (b->type == bp_hardware_breakpoint && breakpoint_enabled (b))
6866 for (bl = b->loc; bl; bl = bl->next)
6868 /* Special types of hardware breakpoints may use more than
6870 if (b->ops && b->ops->resources_needed)
6871 i += b->ops->resources_needed (bl);
6881 hw_watchpoint_used_count (enum bptype type, int *other_type_used)
6884 struct breakpoint *b;
6885 struct bp_location *bl;
6887 *other_type_used = 0;
6890 if (!breakpoint_enabled (b))
6893 if (b->type == type)
6894 for (bl = b->loc; bl; bl = bl->next)
6896 /* Special types of hardware watchpoints may use more than
6898 if (b->ops && b->ops->resources_needed)
6899 i += b->ops->resources_needed (bl);
6903 else if (is_hardware_watchpoint (b))
6904 *other_type_used = 1;
6911 disable_watchpoints_before_interactive_call_start (void)
6913 struct breakpoint *b;
6917 if (is_watchpoint (b) && breakpoint_enabled (b))
6919 b->enable_state = bp_call_disabled;
6920 update_global_location_list (0);
6926 enable_watchpoints_after_interactive_call_stop (void)
6928 struct breakpoint *b;
6932 if (is_watchpoint (b) && b->enable_state == bp_call_disabled)
6934 b->enable_state = bp_enabled;
6935 update_global_location_list (1);
6941 disable_breakpoints_before_startup (void)
6943 struct breakpoint *b;
6948 if (b->pspace != current_program_space)
6951 if ((b->type == bp_breakpoint
6952 || b->type == bp_hardware_breakpoint)
6953 && breakpoint_enabled (b))
6955 b->enable_state = bp_startup_disabled;
6961 update_global_location_list (0);
6963 current_program_space->executing_startup = 1;
6967 enable_breakpoints_after_startup (void)
6969 struct breakpoint *b;
6972 current_program_space->executing_startup = 0;
6976 if (b->pspace != current_program_space)
6979 if ((b->type == bp_breakpoint
6980 || b->type == bp_hardware_breakpoint)
6981 && b->enable_state == bp_startup_disabled)
6983 b->enable_state = bp_enabled;
6989 breakpoint_re_set ();
6993 /* Set a breakpoint that will evaporate an end of command
6994 at address specified by SAL.
6995 Restrict it to frame FRAME if FRAME is nonzero. */
6998 set_momentary_breakpoint (struct gdbarch *gdbarch, struct symtab_and_line sal,
6999 struct frame_id frame_id, enum bptype type)
7001 struct breakpoint *b;
7003 /* If FRAME_ID is valid, it should be a real frame, not an inlined
7005 gdb_assert (!frame_id_inlined_p (frame_id));
7007 b = set_raw_breakpoint (gdbarch, sal, type);
7008 b->enable_state = bp_enabled;
7009 b->disposition = disp_donttouch;
7010 b->frame_id = frame_id;
7012 /* If we're debugging a multi-threaded program, then we want
7013 momentary breakpoints to be active in only a single thread of
7015 if (in_thread_list (inferior_ptid))
7016 b->thread = pid_to_thread_id (inferior_ptid);
7018 update_global_location_list_nothrow (1);
7023 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
7027 clone_momentary_breakpoint (struct breakpoint *orig)
7029 struct breakpoint *copy;
7031 /* If there's nothing to clone, then return nothing. */
7035 copy = set_raw_breakpoint_without_location (orig->gdbarch, orig->type);
7036 copy->loc = allocate_bp_location (copy);
7037 set_breakpoint_location_function (copy->loc, 1);
7039 copy->loc->gdbarch = orig->loc->gdbarch;
7040 copy->loc->requested_address = orig->loc->requested_address;
7041 copy->loc->address = orig->loc->address;
7042 copy->loc->section = orig->loc->section;
7043 copy->loc->pspace = orig->loc->pspace;
7045 if (orig->source_file == NULL)
7046 copy->source_file = NULL;
7048 copy->source_file = xstrdup (orig->source_file);
7050 copy->line_number = orig->line_number;
7051 copy->frame_id = orig->frame_id;
7052 copy->thread = orig->thread;
7053 copy->pspace = orig->pspace;
7055 copy->enable_state = bp_enabled;
7056 copy->disposition = disp_donttouch;
7057 copy->number = internal_breakpoint_number--;
7059 update_global_location_list_nothrow (0);
7064 set_momentary_breakpoint_at_pc (struct gdbarch *gdbarch, CORE_ADDR pc,
7067 struct symtab_and_line sal;
7069 sal = find_pc_line (pc, 0);
7071 sal.section = find_pc_overlay (pc);
7072 sal.explicit_pc = 1;
7074 return set_momentary_breakpoint (gdbarch, sal, null_frame_id, type);
7078 /* Tell the user we have just set a breakpoint B. */
7081 mention (struct breakpoint *b)
7084 struct cleanup *ui_out_chain;
7085 struct value_print_options opts;
7087 get_user_print_options (&opts);
7089 if (b->ops != NULL && b->ops->print_mention != NULL)
7090 b->ops->print_mention (b);
7095 printf_filtered (_("(apparently deleted?) Eventpoint %d: "),
7099 ui_out_text (uiout, "Watchpoint ");
7100 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt");
7101 ui_out_field_int (uiout, "number", b->number);
7102 ui_out_text (uiout, ": ");
7103 ui_out_field_string (uiout, "exp", b->exp_string);
7104 do_cleanups (ui_out_chain);
7106 case bp_hardware_watchpoint:
7107 ui_out_text (uiout, "Hardware watchpoint ");
7108 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt");
7109 ui_out_field_int (uiout, "number", b->number);
7110 ui_out_text (uiout, ": ");
7111 ui_out_field_string (uiout, "exp", b->exp_string);
7112 do_cleanups (ui_out_chain);
7114 case bp_read_watchpoint:
7115 ui_out_text (uiout, "Hardware read watchpoint ");
7116 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-rwpt");
7117 ui_out_field_int (uiout, "number", b->number);
7118 ui_out_text (uiout, ": ");
7119 ui_out_field_string (uiout, "exp", b->exp_string);
7120 do_cleanups (ui_out_chain);
7122 case bp_access_watchpoint:
7123 ui_out_text (uiout, "Hardware access (read/write) watchpoint ");
7124 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-awpt");
7125 ui_out_field_int (uiout, "number", b->number);
7126 ui_out_text (uiout, ": ");
7127 ui_out_field_string (uiout, "exp", b->exp_string);
7128 do_cleanups (ui_out_chain);
7131 case bp_gnu_ifunc_resolver:
7132 if (ui_out_is_mi_like_p (uiout))
7137 if (b->disposition == disp_del)
7138 printf_filtered (_("Temporary breakpoint"));
7140 printf_filtered (_("Breakpoint"));
7141 printf_filtered (_(" %d"), b->number);
7142 if (b->type == bp_gnu_ifunc_resolver)
7143 printf_filtered (_(" at gnu-indirect-function resolver"));
7146 case bp_hardware_breakpoint:
7147 if (ui_out_is_mi_like_p (uiout))
7152 printf_filtered (_("Hardware assisted breakpoint %d"), b->number);
7156 if (ui_out_is_mi_like_p (uiout))
7161 printf_filtered (_("Tracepoint"));
7162 printf_filtered (_(" %d"), b->number);
7165 case bp_fast_tracepoint:
7166 if (ui_out_is_mi_like_p (uiout))
7171 printf_filtered (_("Fast tracepoint"));
7172 printf_filtered (_(" %d"), b->number);
7175 case bp_static_tracepoint:
7176 if (ui_out_is_mi_like_p (uiout))
7181 printf_filtered (_("Static tracepoint"));
7182 printf_filtered (_(" %d"), b->number);
7189 case bp_longjmp_resume:
7191 case bp_exception_resume:
7192 case bp_step_resume:
7194 case bp_std_terminate:
7195 case bp_watchpoint_scope:
7196 case bp_shlib_event:
7197 case bp_thread_event:
7198 case bp_overlay_event:
7200 case bp_longjmp_master:
7201 case bp_std_terminate_master:
7202 case bp_exception_master:
7203 case bp_gnu_ifunc_resolver_return:
7209 /* i18n: cagney/2005-02-11: Below needs to be merged into a
7213 printf_filtered (_(" (%s) pending."), b->addr_string);
7217 if (opts.addressprint || b->source_file == NULL)
7219 printf_filtered (" at ");
7220 fputs_filtered (paddress (b->loc->gdbarch, b->loc->address),
7224 printf_filtered (": file %s, line %d.",
7225 b->source_file, b->line_number);
7229 struct bp_location *loc = b->loc;
7231 for (; loc; loc = loc->next)
7233 printf_filtered (" (%d locations)", n);
7238 if (ui_out_is_mi_like_p (uiout))
7240 printf_filtered ("\n");
7244 static struct bp_location *
7245 add_location_to_breakpoint (struct breakpoint *b,
7246 const struct symtab_and_line *sal)
7248 struct bp_location *loc, **tmp;
7250 loc = allocate_bp_location (b);
7251 for (tmp = &(b->loc); *tmp != NULL; tmp = &((*tmp)->next))
7254 loc->gdbarch = get_sal_arch (*sal);
7256 loc->gdbarch = b->gdbarch;
7257 loc->requested_address = sal->pc;
7258 loc->address = adjust_breakpoint_address (loc->gdbarch,
7259 loc->requested_address, b->type);
7260 loc->pspace = sal->pspace;
7261 gdb_assert (loc->pspace != NULL);
7262 loc->section = sal->section;
7264 set_breakpoint_location_function (loc,
7265 sal->explicit_pc || sal->explicit_line);
7270 /* Return 1 if LOC is pointing to a permanent breakpoint,
7271 return 0 otherwise. */
7274 bp_loc_is_permanent (struct bp_location *loc)
7278 const gdb_byte *brk;
7279 gdb_byte *target_mem;
7280 struct cleanup *cleanup;
7283 gdb_assert (loc != NULL);
7285 addr = loc->address;
7286 brk = gdbarch_breakpoint_from_pc (loc->gdbarch, &addr, &len);
7288 /* Software breakpoints unsupported? */
7292 target_mem = alloca (len);
7294 /* Enable the automatic memory restoration from breakpoints while
7295 we read the memory. Otherwise we could say about our temporary
7296 breakpoints they are permanent. */
7297 cleanup = save_current_space_and_thread ();
7299 switch_to_program_space_and_thread (loc->pspace);
7300 make_show_memory_breakpoints_cleanup (0);
7302 if (target_read_memory (loc->address, target_mem, len) == 0
7303 && memcmp (target_mem, brk, len) == 0)
7306 do_cleanups (cleanup);
7313 /* Create a breakpoint with SAL as location. Use ADDR_STRING
7314 as textual description of the location, and COND_STRING
7315 as condition expression. */
7318 create_breakpoint_sal (struct gdbarch *gdbarch,
7319 struct symtabs_and_lines sals, char *addr_string,
7321 enum bptype type, enum bpdisp disposition,
7322 int thread, int task, int ignore_count,
7323 struct breakpoint_ops *ops, int from_tty,
7324 int enabled, int internal, int display_canonical)
7326 struct breakpoint *b = NULL;
7329 if (type == bp_hardware_breakpoint)
7331 int i = hw_breakpoint_used_count ();
7332 int target_resources_ok =
7333 target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
7335 if (target_resources_ok == 0)
7336 error (_("No hardware breakpoint support in the target."));
7337 else if (target_resources_ok < 0)
7338 error (_("Hardware breakpoints used exceeds limit."));
7341 gdb_assert (sals.nelts > 0);
7343 for (i = 0; i < sals.nelts; ++i)
7345 struct symtab_and_line sal = sals.sals[i];
7346 struct bp_location *loc;
7350 struct gdbarch *loc_gdbarch = get_sal_arch (sal);
7352 loc_gdbarch = gdbarch;
7354 describe_other_breakpoints (loc_gdbarch,
7355 sal.pspace, sal.pc, sal.section, thread);
7360 b = set_raw_breakpoint (gdbarch, sal, type);
7361 set_breakpoint_number (internal, b);
7365 b->cond_string = cond_string;
7366 b->ignore_count = ignore_count;
7367 b->enable_state = enabled ? bp_enabled : bp_disabled;
7368 b->disposition = disposition;
7369 b->pspace = sals.sals[0].pspace;
7371 if (type == bp_static_tracepoint)
7373 struct static_tracepoint_marker marker;
7375 if (is_marker_spec (addr_string))
7377 /* We already know the marker exists, otherwise, we
7378 wouldn't see a sal for it. */
7379 char *p = &addr_string[3];
7384 p = skip_spaces (p);
7386 endp = skip_to_space (p);
7388 marker_str = savestring (p, endp - p);
7389 b->static_trace_marker_id = marker_str;
7391 printf_filtered (_("Probed static tracepoint "
7393 b->static_trace_marker_id);
7395 else if (target_static_tracepoint_marker_at (sal.pc, &marker))
7397 b->static_trace_marker_id = xstrdup (marker.str_id);
7398 release_static_tracepoint_marker (&marker);
7400 printf_filtered (_("Probed static tracepoint "
7402 b->static_trace_marker_id);
7405 warning (_("Couldn't determine the static "
7406 "tracepoint marker to probe"));
7409 if (enabled && b->pspace->executing_startup
7410 && (b->type == bp_breakpoint
7411 || b->type == bp_hardware_breakpoint))
7412 b->enable_state = bp_startup_disabled;
7418 loc = add_location_to_breakpoint (b, &sal);
7421 if (bp_loc_is_permanent (loc))
7422 make_breakpoint_permanent (b);
7426 char *arg = b->cond_string;
7427 loc->cond = parse_exp_1 (&arg, block_for_pc (loc->address), 0);
7429 error (_("Garbage %s follows condition"), arg);
7433 b->display_canonical = display_canonical;
7435 b->addr_string = addr_string;
7437 /* addr_string has to be used or breakpoint_re_set will delete
7440 = xstrprintf ("*%s", paddress (b->loc->gdbarch, b->loc->address));
7443 /* Do not mention breakpoints with a negative number, but do
7444 notify observers. */
7447 observer_notify_breakpoint_created (b);
7450 /* Remove element at INDEX_TO_REMOVE from SAL, shifting other
7451 elements to fill the void space. */
7453 remove_sal (struct symtabs_and_lines *sal, int index_to_remove)
7455 int i = index_to_remove+1;
7456 int last_index = sal->nelts-1;
7458 for (;i <= last_index; ++i)
7459 sal->sals[i-1] = sal->sals[i];
7464 /* If appropriate, obtains all sals that correspond to the same file
7465 and line as SAL, in all program spaces. Users debugging with IDEs,
7466 will want to set a breakpoint at foo.c:line, and not really care
7467 about program spaces. This is done only if SAL does not have
7468 explicit PC and has line and file information. If we got just a
7469 single expanded sal, return the original.
7471 Otherwise, if SAL.explicit_line is not set, filter out all sals for
7472 which the name of enclosing function is different from SAL. This
7473 makes sure that if we have breakpoint originally set in template
7474 instantiation, say foo<int>(), we won't expand SAL to locations at
7475 the same line in all existing instantiations of 'foo'. */
7477 static struct symtabs_and_lines
7478 expand_line_sal_maybe (struct symtab_and_line sal)
7480 struct symtabs_and_lines expanded;
7481 CORE_ADDR original_pc = sal.pc;
7482 char *original_function = NULL;
7485 struct cleanup *old_chain;
7487 /* If we have explicit pc, don't expand.
7488 If we have no line number, we can't expand. */
7489 if (sal.explicit_pc || sal.line == 0 || sal.symtab == NULL)
7492 expanded.sals = xmalloc (sizeof (struct symtab_and_line));
7493 expanded.sals[0] = sal;
7499 old_chain = save_current_space_and_thread ();
7501 switch_to_program_space_and_thread (sal.pspace);
7503 find_pc_partial_function (original_pc, &original_function, NULL, NULL);
7505 /* Note that expand_line_sal visits *all* program spaces. */
7506 expanded = expand_line_sal (sal);
7508 if (expanded.nelts == 1)
7510 /* We had one sal, we got one sal. Return that sal, adjusting it
7511 past the function prologue if necessary. */
7512 xfree (expanded.sals);
7514 expanded.sals = xmalloc (sizeof (struct symtab_and_line));
7515 sal.pc = original_pc;
7516 expanded.sals[0] = sal;
7517 skip_prologue_sal (&expanded.sals[0]);
7518 do_cleanups (old_chain);
7522 if (!sal.explicit_line)
7524 CORE_ADDR func_addr, func_end;
7525 for (i = 0; i < expanded.nelts; ++i)
7527 CORE_ADDR pc = expanded.sals[i].pc;
7528 char *this_function;
7530 /* We need to switch threads as well since we're about to
7532 switch_to_program_space_and_thread (expanded.sals[i].pspace);
7534 if (find_pc_partial_function (pc, &this_function,
7535 &func_addr, &func_end))
7538 && strcmp (this_function, original_function) != 0)
7540 remove_sal (&expanded, i);
7547 /* Skip the function prologue if necessary. */
7548 for (i = 0; i < expanded.nelts; ++i)
7549 skip_prologue_sal (&expanded.sals[i]);
7551 do_cleanups (old_chain);
7553 if (expanded.nelts <= 1)
7555 /* This is un ugly workaround. If we get zero expanded sals
7556 then something is really wrong. Fix that by returning the
7559 xfree (expanded.sals);
7561 expanded.sals = xmalloc (sizeof (struct symtab_and_line));
7562 sal.pc = original_pc;
7563 expanded.sals[0] = sal;
7570 for (i = 0; i < expanded.nelts; ++i)
7571 if (expanded.sals[i].pc == original_pc)
7582 /* Add SALS.nelts breakpoints to the breakpoint table. For each
7583 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
7584 value. COND_STRING, if not NULL, specified the condition to be
7585 used for all breakpoints. Essentially the only case where
7586 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
7587 function. In that case, it's still not possible to specify
7588 separate conditions for different overloaded functions, so
7589 we take just a single condition string.
7591 NOTE: If the function succeeds, the caller is expected to cleanup
7592 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
7593 array contents). If the function fails (error() is called), the
7594 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
7595 COND and SALS arrays and each of those arrays contents. */
7598 create_breakpoints_sal (struct gdbarch *gdbarch,
7599 struct symtabs_and_lines sals,
7600 struct linespec_result *canonical,
7602 enum bptype type, enum bpdisp disposition,
7603 int thread, int task, int ignore_count,
7604 struct breakpoint_ops *ops, int from_tty,
7605 int enabled, int internal)
7609 for (i = 0; i < sals.nelts; ++i)
7611 struct symtabs_and_lines expanded =
7612 expand_line_sal_maybe (sals.sals[i]);
7614 create_breakpoint_sal (gdbarch, expanded, canonical->canonical[i],
7615 cond_string, type, disposition,
7616 thread, task, ignore_count, ops,
7617 from_tty, enabled, internal,
7618 canonical->special_display);
7622 /* Parse ADDRESS which is assumed to be a SAL specification possibly
7623 followed by conditionals. On return, SALS contains an array of SAL
7624 addresses found. ADDR_STRING contains a vector of (canonical)
7625 address strings. ADDRESS points to the end of the SAL.
7627 The array and the line spec strings are allocated on the heap, it is
7628 the caller's responsibility to free them. */
7631 parse_breakpoint_sals (char **address,
7632 struct symtabs_and_lines *sals,
7633 struct linespec_result *canonical)
7635 char *addr_start = *address;
7637 /* If no arg given, or if first arg is 'if ', use the default
7639 if ((*address) == NULL
7640 || (strncmp ((*address), "if", 2) == 0 && isspace ((*address)[2])))
7642 if (default_breakpoint_valid)
7644 struct symtab_and_line sal;
7646 init_sal (&sal); /* Initialize to zeroes. */
7647 sals->sals = (struct symtab_and_line *)
7648 xmalloc (sizeof (struct symtab_and_line));
7649 sal.pc = default_breakpoint_address;
7650 sal.line = default_breakpoint_line;
7651 sal.symtab = default_breakpoint_symtab;
7652 sal.pspace = default_breakpoint_pspace;
7653 sal.section = find_pc_overlay (sal.pc);
7655 /* "break" without arguments is equivalent to "break *PC"
7656 where PC is the default_breakpoint_address. So make sure
7657 to set sal.explicit_pc to prevent GDB from trying to
7658 expand the list of sals to include all other instances
7659 with the same symtab and line. */
7660 sal.explicit_pc = 1;
7662 sals->sals[0] = sal;
7666 error (_("No default breakpoint address now."));
7670 /* Force almost all breakpoints to be in terms of the
7671 current_source_symtab (which is decode_line_1's default).
7672 This should produce the results we want almost all of the
7673 time while leaving default_breakpoint_* alone.
7675 ObjC: However, don't match an Objective-C method name which
7676 may have a '+' or '-' succeeded by a '[' */
7678 struct symtab_and_line cursal = get_current_source_symtab_and_line ();
7680 if (default_breakpoint_valid
7682 || ((strchr ("+-", (*address)[0]) != NULL)
7683 && ((*address)[1] != '['))))
7684 *sals = decode_line_1 (address, 1, default_breakpoint_symtab,
7685 default_breakpoint_line, canonical);
7687 *sals = decode_line_1 (address, 1, (struct symtab *) NULL, 0,
7690 /* For any SAL that didn't have a canonical string, fill one in. */
7691 if (sals->nelts > 0 && canonical->canonical == NULL)
7692 canonical->canonical = xcalloc (sals->nelts, sizeof (char *));
7693 if (addr_start != (*address))
7697 for (i = 0; i < sals->nelts; i++)
7699 /* Add the string if not present. */
7700 if (canonical->canonical[i] == NULL)
7701 canonical->canonical[i] = savestring (addr_start,
7702 (*address) - addr_start);
7708 /* Convert each SAL into a real PC. Verify that the PC can be
7709 inserted as a breakpoint. If it can't throw an error. */
7712 breakpoint_sals_to_pc (struct symtabs_and_lines *sals)
7716 for (i = 0; i < sals->nelts; i++)
7717 resolve_sal_pc (&sals->sals[i]);
7720 /* Fast tracepoints may have restrictions on valid locations. For
7721 instance, a fast tracepoint using a jump instead of a trap will
7722 likely have to overwrite more bytes than a trap would, and so can
7723 only be placed where the instruction is longer than the jump, or a
7724 multi-instruction sequence does not have a jump into the middle of
7728 check_fast_tracepoint_sals (struct gdbarch *gdbarch,
7729 struct symtabs_and_lines *sals)
7732 struct symtab_and_line *sal;
7734 struct cleanup *old_chain;
7736 for (i = 0; i < sals->nelts; i++)
7738 sal = &sals->sals[i];
7740 rslt = gdbarch_fast_tracepoint_valid_at (gdbarch, sal->pc,
7742 old_chain = make_cleanup (xfree, msg);
7745 error (_("May not have a fast tracepoint at 0x%s%s"),
7746 paddress (gdbarch, sal->pc), (msg ? msg : ""));
7748 do_cleanups (old_chain);
7752 /* Given TOK, a string specification of condition and thread, as
7753 accepted by the 'break' command, extract the condition
7754 string and thread number and set *COND_STRING and *THREAD.
7755 PC identifies the context at which the condition should be parsed.
7756 If no condition is found, *COND_STRING is set to NULL.
7757 If no thread is found, *THREAD is set to -1. */
7759 find_condition_and_thread (char *tok, CORE_ADDR pc,
7760 char **cond_string, int *thread, int *task)
7762 *cond_string = NULL;
7768 char *cond_start = NULL;
7769 char *cond_end = NULL;
7771 tok = skip_spaces (tok);
7773 end_tok = skip_to_space (tok);
7775 toklen = end_tok - tok;
7777 if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
7779 struct expression *expr;
7781 tok = cond_start = end_tok + 1;
7782 expr = parse_exp_1 (&tok, block_for_pc (pc), 0);
7785 *cond_string = savestring (cond_start,
7786 cond_end - cond_start);
7788 else if (toklen >= 1 && strncmp (tok, "thread", toklen) == 0)
7794 *thread = strtol (tok, &tok, 0);
7796 error (_("Junk after thread keyword."));
7797 if (!valid_thread_id (*thread))
7798 error (_("Unknown thread %d."), *thread);
7800 else if (toklen >= 1 && strncmp (tok, "task", toklen) == 0)
7806 *task = strtol (tok, &tok, 0);
7808 error (_("Junk after task keyword."));
7809 if (!valid_task_id (*task))
7810 error (_("Unknown task %d."), *task);
7813 error (_("Junk at end of arguments."));
7817 /* Decode a static tracepoint marker spec. */
7819 static struct symtabs_and_lines
7820 decode_static_tracepoint_spec (char **arg_p)
7822 VEC(static_tracepoint_marker_p) *markers = NULL;
7823 struct symtabs_and_lines sals;
7824 struct symtab_and_line sal;
7826 struct cleanup *old_chain;
7827 char *p = &(*arg_p)[3];
7832 p = skip_spaces (p);
7834 endp = skip_to_space (p);
7836 marker_str = savestring (p, endp - p);
7837 old_chain = make_cleanup (xfree, marker_str);
7839 markers = target_static_tracepoint_markers_by_strid (marker_str);
7840 if (VEC_empty(static_tracepoint_marker_p, markers))
7841 error (_("No known static tracepoint marker named %s"), marker_str);
7843 sals.nelts = VEC_length(static_tracepoint_marker_p, markers);
7844 sals.sals = xmalloc (sizeof *sals.sals * sals.nelts);
7846 for (i = 0; i < sals.nelts; i++)
7848 struct static_tracepoint_marker *marker;
7850 marker = VEC_index (static_tracepoint_marker_p, markers, i);
7852 init_sal (&sals.sals[i]);
7854 sals.sals[i] = find_pc_line (marker->address, 0);
7855 sals.sals[i].pc = marker->address;
7857 release_static_tracepoint_marker (marker);
7860 do_cleanups (old_chain);
7866 /* Set a breakpoint. This function is shared between CLI and MI
7867 functions for setting a breakpoint. This function has two major
7868 modes of operations, selected by the PARSE_CONDITION_AND_THREAD
7869 parameter. If non-zero, the function will parse arg, extracting
7870 breakpoint location, address and thread. Otherwise, ARG is just
7871 the location of breakpoint, with condition and thread specified by
7872 the COND_STRING and THREAD parameters. If INTERNAL is non-zero,
7873 the breakpoint number will be allocated from the internal
7874 breakpoint count. Returns true if any breakpoint was created;
7878 create_breakpoint (struct gdbarch *gdbarch,
7879 char *arg, char *cond_string, int thread,
7880 int parse_condition_and_thread,
7881 int tempflag, enum bptype type_wanted,
7883 enum auto_boolean pending_break_support,
7884 struct breakpoint_ops *ops,
7885 int from_tty, int enabled, int internal)
7887 volatile struct gdb_exception e;
7888 struct symtabs_and_lines sals;
7889 struct symtab_and_line pending_sal;
7891 char *addr_start = arg;
7892 struct linespec_result canonical;
7893 struct cleanup *old_chain;
7894 struct cleanup *bkpt_chain = NULL;
7898 int prev_bkpt_count = breakpoint_count;
7902 init_linespec_result (&canonical);
7904 if (type_wanted == bp_static_tracepoint && is_marker_spec (arg))
7908 sals = decode_static_tracepoint_spec (&arg);
7910 copy_arg = savestring (addr_start, arg - addr_start);
7911 canonical.canonical = xcalloc (sals.nelts, sizeof (char *));
7912 for (i = 0; i < sals.nelts; i++)
7913 canonical.canonical[i] = xstrdup (copy_arg);
7917 TRY_CATCH (e, RETURN_MASK_ALL)
7919 parse_breakpoint_sals (&arg, &sals, &canonical);
7922 /* If caller is interested in rc value from parse, set value. */
7926 throw_exception (e);
7930 case NOT_FOUND_ERROR:
7932 /* If pending breakpoint support is turned off, throw
7935 if (pending_break_support == AUTO_BOOLEAN_FALSE)
7936 throw_exception (e);
7938 exception_print (gdb_stderr, e);
7940 /* If pending breakpoint support is auto query and the user
7941 selects no, then simply return the error code. */
7942 if (pending_break_support == AUTO_BOOLEAN_AUTO
7943 && !nquery (_("Make breakpoint pending on "
7944 "future shared library load? ")))
7947 /* At this point, either the user was queried about setting
7948 a pending breakpoint and selected yes, or pending
7949 breakpoint behavior is on and thus a pending breakpoint
7950 is defaulted on behalf of the user. */
7951 copy_arg = xstrdup (addr_start);
7952 canonical.canonical = ©_arg;
7954 sals.sals = &pending_sal;
7959 throw_exception (e);
7969 /* Create a chain of things that always need to be cleaned up. */
7970 old_chain = make_cleanup (null_cleanup, 0);
7974 /* Make sure that all storage allocated to SALS gets freed. */
7975 make_cleanup (xfree, sals.sals);
7977 /* Cleanup the canonical array but not its contents. */
7978 make_cleanup (xfree, canonical.canonical);
7981 /* ----------------------------- SNIP -----------------------------
7982 Anything added to the cleanup chain beyond this point is assumed
7983 to be part of a breakpoint. If the breakpoint create succeeds
7984 then the memory is not reclaimed. */
7985 bkpt_chain = make_cleanup (null_cleanup, 0);
7987 /* Mark the contents of the canonical for cleanup. These go on
7988 the bkpt_chain and only occur if the breakpoint create fails. */
7989 for (i = 0; i < sals.nelts; i++)
7991 if (canonical.canonical[i] != NULL)
7992 make_cleanup (xfree, canonical.canonical[i]);
7995 /* Resolve all line numbers to PC's and verify that the addresses
7996 are ok for the target. */
7998 breakpoint_sals_to_pc (&sals);
8000 /* Fast tracepoints may have additional restrictions on location. */
8001 if (type_wanted == bp_fast_tracepoint)
8002 check_fast_tracepoint_sals (gdbarch, &sals);
8004 /* Verify that condition can be parsed, before setting any
8005 breakpoints. Allocate a separate condition expression for each
8009 if (parse_condition_and_thread)
8011 /* Here we only parse 'arg' to separate condition
8012 from thread number, so parsing in context of first
8013 sal is OK. When setting the breakpoint we'll
8014 re-parse it in context of each sal. */
8017 find_condition_and_thread (arg, sals.sals[0].pc, &cond_string,
8020 make_cleanup (xfree, cond_string);
8024 /* Create a private copy of condition string. */
8027 cond_string = xstrdup (cond_string);
8028 make_cleanup (xfree, cond_string);
8032 /* If the user is creating a static tracepoint by marker id
8033 (strace -m MARKER_ID), then store the sals index, so that
8034 breakpoint_re_set can try to match up which of the newly
8035 found markers corresponds to this one, and, don't try to
8036 expand multiple locations for each sal, given than SALS
8037 already should contain all sals for MARKER_ID. */
8038 if (type_wanted == bp_static_tracepoint
8039 && is_marker_spec (canonical.canonical[0]))
8043 for (i = 0; i < sals.nelts; ++i)
8045 struct symtabs_and_lines expanded;
8046 struct breakpoint *tp;
8047 struct cleanup *old_chain;
8050 expanded.sals = xmalloc (sizeof (struct symtab_and_line));
8051 expanded.sals[0] = sals.sals[i];
8052 old_chain = make_cleanup (xfree, expanded.sals);
8054 create_breakpoint_sal (gdbarch, expanded, canonical.canonical[i],
8055 cond_string, type_wanted,
8056 tempflag ? disp_del : disp_donttouch,
8057 thread, task, ignore_count, ops,
8058 from_tty, enabled, internal,
8059 canonical.special_display);
8061 do_cleanups (old_chain);
8063 /* Get the tracepoint we just created. */
8065 tp = get_breakpoint (internal_breakpoint_number);
8067 tp = get_breakpoint (breakpoint_count);
8068 gdb_assert (tp != NULL);
8070 /* Given that its possible to have multiple markers with
8071 the same string id, if the user is creating a static
8072 tracepoint by marker id ("strace -m MARKER_ID"), then
8073 store the sals index, so that breakpoint_re_set can
8074 try to match up which of the newly found markers
8075 corresponds to this one */
8076 tp->static_trace_marker_id_idx = i;
8080 create_breakpoints_sal (gdbarch, sals, &canonical, cond_string,
8082 tempflag ? disp_del : disp_donttouch,
8083 thread, task, ignore_count, ops, from_tty,
8088 struct breakpoint *b;
8090 make_cleanup (xfree, copy_arg);
8092 b = set_raw_breakpoint_without_location (gdbarch, type_wanted);
8093 set_breakpoint_number (internal, b);
8095 b->addr_string = canonical.canonical[0];
8096 b->cond_string = NULL;
8097 b->ignore_count = ignore_count;
8098 b->disposition = tempflag ? disp_del : disp_donttouch;
8099 b->condition_not_parsed = 1;
8101 b->enable_state = enabled ? bp_enabled : bp_disabled;
8102 b->pspace = current_program_space;
8103 b->py_bp_object = NULL;
8105 if (enabled && b->pspace->executing_startup
8106 && (b->type == bp_breakpoint
8107 || b->type == bp_hardware_breakpoint))
8108 b->enable_state = bp_startup_disabled;
8111 /* Do not mention breakpoints with a negative number,
8112 but do notify observers. */
8114 observer_notify_breakpoint_created (b);
8119 warning (_("Multiple breakpoints were set.\nUse the "
8120 "\"delete\" command to delete unwanted breakpoints."));
8121 prev_breakpoint_count = prev_bkpt_count;
8124 /* That's it. Discard the cleanups for data inserted into the
8126 discard_cleanups (bkpt_chain);
8127 /* But cleanup everything else. */
8128 do_cleanups (old_chain);
8130 /* error call may happen here - have BKPT_CHAIN already discarded. */
8131 update_global_location_list (1);
8136 /* Set a breakpoint.
8137 ARG is a string describing breakpoint address,
8138 condition, and thread.
8139 FLAG specifies if a breakpoint is hardware on,
8140 and if breakpoint is temporary, using BP_HARDWARE_FLAG
8144 break_command_1 (char *arg, int flag, int from_tty)
8146 int tempflag = flag & BP_TEMPFLAG;
8147 enum bptype type_wanted = (flag & BP_HARDWAREFLAG
8148 ? bp_hardware_breakpoint
8151 create_breakpoint (get_current_arch (),
8153 NULL, 0, 1 /* parse arg */,
8154 tempflag, type_wanted,
8155 0 /* Ignore count */,
8156 pending_break_support,
8157 NULL /* breakpoint_ops */,
8164 /* Helper function for break_command_1 and disassemble_command. */
8167 resolve_sal_pc (struct symtab_and_line *sal)
8171 if (sal->pc == 0 && sal->symtab != NULL)
8173 if (!find_line_pc (sal->symtab, sal->line, &pc))
8174 error (_("No line %d in file \"%s\"."),
8175 sal->line, sal->symtab->filename);
8178 /* If this SAL corresponds to a breakpoint inserted using a line
8179 number, then skip the function prologue if necessary. */
8180 if (sal->explicit_line)
8181 skip_prologue_sal (sal);
8184 if (sal->section == 0 && sal->symtab != NULL)
8186 struct blockvector *bv;
8190 bv = blockvector_for_pc_sect (sal->pc, 0, &b, sal->symtab);
8193 sym = block_linkage_function (b);
8196 fixup_symbol_section (sym, sal->symtab->objfile);
8197 sal->section = SYMBOL_OBJ_SECTION (sym);
8201 /* It really is worthwhile to have the section, so we'll
8202 just have to look harder. This case can be executed
8203 if we have line numbers but no functions (as can
8204 happen in assembly source). */
8206 struct minimal_symbol *msym;
8207 struct cleanup *old_chain = save_current_space_and_thread ();
8209 switch_to_program_space_and_thread (sal->pspace);
8211 msym = lookup_minimal_symbol_by_pc (sal->pc);
8213 sal->section = SYMBOL_OBJ_SECTION (msym);
8215 do_cleanups (old_chain);
8222 break_command (char *arg, int from_tty)
8224 break_command_1 (arg, 0, from_tty);
8228 tbreak_command (char *arg, int from_tty)
8230 break_command_1 (arg, BP_TEMPFLAG, from_tty);
8234 hbreak_command (char *arg, int from_tty)
8236 break_command_1 (arg, BP_HARDWAREFLAG, from_tty);
8240 thbreak_command (char *arg, int from_tty)
8242 break_command_1 (arg, (BP_TEMPFLAG | BP_HARDWAREFLAG), from_tty);
8246 stop_command (char *arg, int from_tty)
8248 printf_filtered (_("Specify the type of breakpoint to set.\n\
8249 Usage: stop in <function | address>\n\
8250 stop at <line>\n"));
8254 stopin_command (char *arg, int from_tty)
8258 if (arg == (char *) NULL)
8260 else if (*arg != '*')
8265 /* Look for a ':'. If this is a line number specification, then
8266 say it is bad, otherwise, it should be an address or
8267 function/method name. */
8268 while (*argptr && !hasColon)
8270 hasColon = (*argptr == ':');
8275 badInput = (*argptr != ':'); /* Not a class::method */
8277 badInput = isdigit (*arg); /* a simple line number */
8281 printf_filtered (_("Usage: stop in <function | address>\n"));
8283 break_command_1 (arg, 0, from_tty);
8287 stopat_command (char *arg, int from_tty)
8291 if (arg == (char *) NULL || *arg == '*') /* no line number */
8298 /* Look for a ':'. If there is a '::' then get out, otherwise
8299 it is probably a line number. */
8300 while (*argptr && !hasColon)
8302 hasColon = (*argptr == ':');
8307 badInput = (*argptr == ':'); /* we have class::method */
8309 badInput = !isdigit (*arg); /* not a line number */
8313 printf_filtered (_("Usage: stop at <line>\n"));
8315 break_command_1 (arg, 0, from_tty);
8318 /* Implement the "breakpoint_hit" breakpoint_ops method for
8319 ranged breakpoints. */
8322 breakpoint_hit_ranged_breakpoint (const struct bp_location *bl,
8323 struct address_space *aspace,
8326 return breakpoint_address_match_range (bl->pspace->aspace, bl->address,
8327 bl->length, aspace, bp_addr);
8330 /* Implement the "resources_needed" breakpoint_ops method for
8331 ranged breakpoints. */
8334 resources_needed_ranged_breakpoint (const struct bp_location *bl)
8336 return target_ranged_break_num_registers ();
8339 /* Implement the "print_it" breakpoint_ops method for
8340 ranged breakpoints. */
8342 static enum print_stop_action
8343 print_it_ranged_breakpoint (struct breakpoint *b)
8345 struct bp_location *bl = b->loc;
8347 gdb_assert (b->type == bp_hardware_breakpoint);
8349 /* Ranged breakpoints have only one location. */
8350 gdb_assert (bl && bl->next == NULL);
8352 annotate_breakpoint (b->number);
8353 if (b->disposition == disp_del)
8354 ui_out_text (uiout, "\nTemporary ranged breakpoint ");
8356 ui_out_text (uiout, "\nRanged breakpoint ");
8357 if (ui_out_is_mi_like_p (uiout))
8359 ui_out_field_string (uiout, "reason",
8360 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
8361 ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
8363 ui_out_field_int (uiout, "bkptno", b->number);
8364 ui_out_text (uiout, ", ");
8366 return PRINT_SRC_AND_LOC;
8369 /* Implement the "print_one" breakpoint_ops method for
8370 ranged breakpoints. */
8373 print_one_ranged_breakpoint (struct breakpoint *b,
8374 struct bp_location **last_loc)
8376 struct bp_location *bl = b->loc;
8377 struct value_print_options opts;
8379 /* Ranged breakpoints have only one location. */
8380 gdb_assert (bl && bl->next == NULL);
8382 get_user_print_options (&opts);
8384 if (opts.addressprint)
8385 /* We don't print the address range here, it will be printed later
8386 by print_one_detail_ranged_breakpoint. */
8387 ui_out_field_skip (uiout, "addr");
8389 print_breakpoint_location (b, bl);
8393 /* Implement the "print_one_detail" breakpoint_ops method for
8394 ranged breakpoints. */
8397 print_one_detail_ranged_breakpoint (const struct breakpoint *b,
8398 struct ui_out *uiout)
8400 CORE_ADDR address_start, address_end;
8401 struct bp_location *bl = b->loc;
8402 struct ui_stream *stb = ui_out_stream_new (uiout);
8403 struct cleanup *cleanup = make_cleanup_ui_out_stream_delete (stb);
8407 address_start = bl->address;
8408 address_end = address_start + bl->length - 1;
8410 ui_out_text (uiout, "\taddress range: ");
8411 fprintf_unfiltered (stb->stream, "[%s, %s]",
8412 print_core_address (bl->gdbarch, address_start),
8413 print_core_address (bl->gdbarch, address_end));
8414 ui_out_field_stream (uiout, "addr", stb);
8415 ui_out_text (uiout, "\n");
8417 do_cleanups (cleanup);
8420 /* Implement the "print_mention" breakpoint_ops method for
8421 ranged breakpoints. */
8424 print_mention_ranged_breakpoint (struct breakpoint *b)
8426 struct bp_location *bl = b->loc;
8429 gdb_assert (b->type == bp_hardware_breakpoint);
8431 if (ui_out_is_mi_like_p (uiout))
8434 printf_filtered (_("Hardware assisted ranged breakpoint %d from %s to %s."),
8435 b->number, paddress (bl->gdbarch, bl->address),
8436 paddress (bl->gdbarch, bl->address + bl->length - 1));
8439 /* Implement the "print_recreate" breakpoint_ops method for
8440 ranged breakpoints. */
8443 print_recreate_ranged_breakpoint (struct breakpoint *b, struct ui_file *fp)
8445 fprintf_unfiltered (fp, "break-range %s, %s", b->addr_string,
8446 b->addr_string_range_end);
8449 /* The breakpoint_ops structure to be used in ranged breakpoints. */
8451 static struct breakpoint_ops ranged_breakpoint_ops =
8455 breakpoint_hit_ranged_breakpoint,
8456 resources_needed_ranged_breakpoint,
8457 print_it_ranged_breakpoint,
8458 print_one_ranged_breakpoint,
8459 print_one_detail_ranged_breakpoint,
8460 print_mention_ranged_breakpoint,
8461 print_recreate_ranged_breakpoint
8464 /* Find the address where the end of the breakpoint range should be
8465 placed, given the SAL of the end of the range. This is so that if
8466 the user provides a line number, the end of the range is set to the
8467 last instruction of the given line. */
8470 find_breakpoint_range_end (struct symtab_and_line sal)
8474 /* If the user provided a PC value, use it. Otherwise,
8475 find the address of the end of the given location. */
8476 if (sal.explicit_pc)
8483 ret = find_line_pc_range (sal, &start, &end);
8485 error (_("Could not find location of the end of the range."));
8487 /* find_line_pc_range returns the start of the next line. */
8494 /* Implement the "break-range" CLI command. */
8497 break_range_command (char *arg, int from_tty)
8499 char *arg_start, *addr_string_start, *addr_string_end;
8500 struct linespec_result canonical_start, canonical_end;
8501 int bp_count, can_use_bp, length;
8503 struct breakpoint *b;
8504 struct symtab_and_line sal_start, sal_end;
8505 struct symtabs_and_lines sals_start, sals_end;
8506 struct cleanup *cleanup_bkpt;
8508 /* We don't support software ranged breakpoints. */
8509 if (target_ranged_break_num_registers () < 0)
8510 error (_("This target does not support hardware ranged breakpoints."));
8512 bp_count = hw_breakpoint_used_count ();
8513 bp_count += target_ranged_break_num_registers ();
8514 can_use_bp = target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
8517 error (_("Hardware breakpoints used exceeds limit."));
8519 if (arg == NULL || arg[0] == '\0')
8520 error(_("No address range specified."));
8522 sals_start.sals = NULL;
8523 sals_start.nelts = 0;
8524 init_linespec_result (&canonical_start);
8526 while (*arg == ' ' || *arg == '\t')
8529 parse_breakpoint_sals (&arg, &sals_start, &canonical_start);
8531 sal_start = sals_start.sals[0];
8532 addr_string_start = canonical_start.canonical[0];
8533 cleanup_bkpt = make_cleanup (xfree, addr_string_start);
8534 xfree (sals_start.sals);
8535 xfree (canonical_start.canonical);
8538 error (_("Too few arguments."));
8539 else if (sals_start.nelts == 0)
8540 error (_("Could not find location of the beginning of the range."));
8541 else if (sals_start.nelts != 1)
8542 error (_("Cannot create a ranged breakpoint with multiple locations."));
8544 resolve_sal_pc (&sal_start);
8546 arg++; /* Skip the comma. */
8547 while (*arg == ' ' || *arg == '\t')
8550 /* Parse the end location. */
8552 sals_end.sals = NULL;
8554 init_linespec_result (&canonical_end);
8557 /* We call decode_line_1 directly here instead of using
8558 parse_breakpoint_sals because we need to specify the start location's
8559 symtab and line as the default symtab and line for the end of the
8560 range. This makes it possible to have ranges like "foo.c:27, +14",
8561 where +14 means 14 lines from the start location. */
8562 sals_end = decode_line_1 (&arg, 1, sal_start.symtab, sal_start.line,
8565 /* canonical_end can be NULL if it was of the form "*0xdeadbeef". */
8566 if (canonical_end.canonical == NULL)
8567 canonical_end.canonical = xcalloc (1, sizeof (char *));
8568 /* Add the string if not present. */
8569 if (arg_start != arg && canonical_end.canonical[0] == NULL)
8570 canonical_end.canonical[0] = savestring (arg_start, arg - arg_start);
8572 sal_end = sals_end.sals[0];
8573 addr_string_end = canonical_end.canonical[0];
8574 make_cleanup (xfree, addr_string_end);
8575 xfree (sals_end.sals);
8576 xfree (canonical_end.canonical);
8578 if (sals_end.nelts == 0)
8579 error (_("Could not find location of the end of the range."));
8580 else if (sals_end.nelts != 1)
8581 error (_("Cannot create a ranged breakpoint with multiple locations."));
8583 resolve_sal_pc (&sal_end);
8585 end = find_breakpoint_range_end (sal_end);
8586 if (sal_start.pc > end)
8587 error (_("Invalid address range, end preceeds start."));
8589 length = end - sal_start.pc + 1;
8591 /* Length overflowed. */
8592 error (_("Address range too large."));
8593 else if (length == 1)
8595 /* This range is simple enough to be handled by
8596 the `hbreak' command. */
8597 hbreak_command (addr_string_start, 1);
8599 do_cleanups (cleanup_bkpt);
8604 /* Now set up the breakpoint. */
8605 b = set_raw_breakpoint (get_current_arch (), sal_start,
8606 bp_hardware_breakpoint);
8607 set_breakpoint_count (breakpoint_count + 1);
8608 b->number = breakpoint_count;
8609 b->disposition = disp_donttouch;
8610 b->addr_string = addr_string_start;
8611 b->addr_string_range_end = addr_string_end;
8612 b->ops = &ranged_breakpoint_ops;
8613 b->loc->length = length;
8615 discard_cleanups (cleanup_bkpt);
8618 observer_notify_breakpoint_created (b);
8619 update_global_location_list (1);
8622 /* Return non-zero if EXP is verified as constant. Returned zero
8623 means EXP is variable. Also the constant detection may fail for
8624 some constant expressions and in such case still falsely return
8627 watchpoint_exp_is_const (const struct expression *exp)
8635 /* We are only interested in the descriptor of each element. */
8636 operator_length (exp, i, &oplenp, &argsp);
8639 switch (exp->elts[i].opcode)
8649 case BINOP_LOGICAL_AND:
8650 case BINOP_LOGICAL_OR:
8651 case BINOP_BITWISE_AND:
8652 case BINOP_BITWISE_IOR:
8653 case BINOP_BITWISE_XOR:
8655 case BINOP_NOTEQUAL:
8671 case TERNOP_SLICE_COUNT:
8683 case OP_OBJC_NSSTRING:
8686 case UNOP_LOGICAL_NOT:
8687 case UNOP_COMPLEMENT:
8690 /* Unary, binary and ternary operators: We have to check
8691 their operands. If they are constant, then so is the
8692 result of that operation. For instance, if A and B are
8693 determined to be constants, then so is "A + B".
8695 UNOP_IND is one exception to the rule above, because the
8696 value of *ADDR is not necessarily a constant, even when
8701 /* Check whether the associated symbol is a constant.
8703 We use SYMBOL_CLASS rather than TYPE_CONST because it's
8704 possible that a buggy compiler could mark a variable as
8705 constant even when it is not, and TYPE_CONST would return
8706 true in this case, while SYMBOL_CLASS wouldn't.
8708 We also have to check for function symbols because they
8709 are always constant. */
8711 struct symbol *s = exp->elts[i + 2].symbol;
8713 if (SYMBOL_CLASS (s) != LOC_BLOCK
8714 && SYMBOL_CLASS (s) != LOC_CONST
8715 && SYMBOL_CLASS (s) != LOC_CONST_BYTES)
8720 /* The default action is to return 0 because we are using
8721 the optimistic approach here: If we don't know something,
8722 then it is not a constant. */
8731 /* Implement the "insert" breakpoint_ops method for hardware watchpoints. */
8734 insert_watchpoint (struct bp_location *bl)
8736 int length = bl->owner->exact? 1 : bl->length;
8738 return target_insert_watchpoint (bl->address, length, bl->watchpoint_type,
8739 bl->owner->cond_exp);
8742 /* Implement the "remove" breakpoint_ops method for hardware watchpoints. */
8745 remove_watchpoint (struct bp_location *bl)
8747 int length = bl->owner->exact? 1 : bl->length;
8749 return target_remove_watchpoint (bl->address, length, bl->watchpoint_type,
8750 bl->owner->cond_exp);
8753 /* Implement the "resources_needed" breakpoint_ops method for
8754 hardware watchpoints. */
8757 resources_needed_watchpoint (const struct bp_location *bl)
8759 int length = bl->owner->exact? 1 : bl->length;
8761 return target_region_ok_for_hw_watchpoint (bl->address, length);
8764 /* The breakpoint_ops structure to be used in hardware watchpoints. */
8766 static struct breakpoint_ops watchpoint_breakpoint_ops =
8770 NULL, /* breakpoint_hit */
8771 resources_needed_watchpoint,
8772 NULL, /* print_it */
8773 NULL, /* print_one */
8774 NULL, /* print_one_detail */
8775 NULL, /* print_mention */
8776 NULL /* print_recreate */
8779 /* accessflag: hw_write: watch write,
8780 hw_read: watch read,
8781 hw_access: watch access (read or write) */
8783 watch_command_1 (char *arg, int accessflag, int from_tty,
8784 int just_location, int internal)
8786 struct breakpoint *b, *scope_breakpoint = NULL;
8787 struct expression *exp;
8788 struct block *exp_valid_block = NULL, *cond_exp_valid_block = NULL;
8789 struct value *val, *mark, *result;
8790 struct frame_info *frame;
8791 char *exp_start = NULL;
8792 char *exp_end = NULL;
8793 char *tok, *id_tok_start, *end_tok;
8795 char *cond_start = NULL;
8796 char *cond_end = NULL;
8797 int i, other_type_used, target_resources_ok = 0;
8798 enum bptype bp_type;
8803 /* Make sure that we actually have parameters to parse. */
8804 if (arg != NULL && arg[0] != '\0')
8806 toklen = strlen (arg); /* Size of argument list. */
8808 /* Points tok to the end of the argument list. */
8809 tok = arg + toklen - 1;
8811 /* Go backwards in the parameters list. Skip the last
8812 parameter. If we're expecting a 'thread <thread_num>'
8813 parameter, this should be the thread identifier. */
8814 while (tok > arg && (*tok == ' ' || *tok == '\t'))
8816 while (tok > arg && (*tok != ' ' && *tok != '\t'))
8819 /* Points end_tok to the beginning of the last token. */
8820 id_tok_start = tok + 1;
8822 /* Go backwards in the parameters list. Skip one more
8823 parameter. If we're expecting a 'thread <thread_num>'
8824 parameter, we should reach a "thread" token. */
8825 while (tok > arg && (*tok == ' ' || *tok == '\t'))
8830 while (tok > arg && (*tok != ' ' && *tok != '\t'))
8833 /* Move the pointer forward to skip the whitespace and
8834 calculate the length of the token. */
8836 toklen = end_tok - tok;
8838 if (toklen >= 1 && strncmp (tok, "thread", toklen) == 0)
8840 /* At this point we've found a "thread" token, which means
8841 the user is trying to set a watchpoint that triggers
8842 only in a specific thread. */
8845 /* Extract the thread ID from the next token. */
8846 thread = strtol (id_tok_start, &endp, 0);
8848 /* Check if the user provided a valid numeric value for the
8850 if (*endp != ' ' && *endp != '\t' && *endp != '\0')
8851 error (_("Invalid thread ID specification %s."), id_tok_start);
8853 /* Check if the thread actually exists. */
8854 if (!valid_thread_id (thread))
8855 error (_("Unknown thread %d."), thread);
8857 /* Truncate the string and get rid of the thread <thread_num>
8858 parameter before the parameter list is parsed by the
8859 evaluate_expression() function. */
8864 /* Parse the rest of the arguments. */
8865 innermost_block = NULL;
8867 exp = parse_exp_1 (&arg, 0, 0);
8869 /* Remove trailing whitespace from the expression before saving it.
8870 This makes the eventual display of the expression string a bit
8872 while (exp_end > exp_start && (exp_end[-1] == ' ' || exp_end[-1] == '\t'))
8875 /* Checking if the expression is not constant. */
8876 if (watchpoint_exp_is_const (exp))
8880 len = exp_end - exp_start;
8881 while (len > 0 && isspace (exp_start[len - 1]))
8883 error (_("Cannot watch constant value `%.*s'."), len, exp_start);
8886 exp_valid_block = innermost_block;
8887 mark = value_mark ();
8888 fetch_subexp_value (exp, &pc, &val, &result, NULL);
8892 exp_valid_block = NULL;
8893 val = value_addr (result);
8894 release_value (val);
8895 value_free_to_mark (mark);
8897 else if (val != NULL)
8898 release_value (val);
8900 tok = skip_spaces (arg);
8901 end_tok = skip_to_space (tok);
8903 toklen = end_tok - tok;
8904 if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
8906 struct expression *cond;
8908 innermost_block = NULL;
8909 tok = cond_start = end_tok + 1;
8910 cond = parse_exp_1 (&tok, 0, 0);
8912 /* The watchpoint expression may not be local, but the condition
8913 may still be. E.g.: `watch global if local > 0'. */
8914 cond_exp_valid_block = innermost_block;
8920 error (_("Junk at end of command."));
8922 if (accessflag == hw_read)
8923 bp_type = bp_read_watchpoint;
8924 else if (accessflag == hw_access)
8925 bp_type = bp_access_watchpoint;
8927 bp_type = bp_hardware_watchpoint;
8929 reg_cnt = can_use_hardware_watchpoint (val, target_exact_watchpoints);
8930 if (reg_cnt == 0 && bp_type != bp_hardware_watchpoint)
8931 error (_("Expression cannot be implemented with read/access watchpoint."));
8934 i = hw_watchpoint_used_count (bp_type, &other_type_used);
8935 target_resources_ok =
8936 target_can_use_hardware_watchpoint (bp_type, i + reg_cnt,
8938 if (target_resources_ok == 0 && bp_type != bp_hardware_watchpoint)
8939 error (_("Target does not support this type of hardware watchpoint."));
8941 if (target_resources_ok < 0 && bp_type != bp_hardware_watchpoint)
8942 error (_("Target can only support one kind "
8943 "of HW watchpoint at a time."));
8946 /* Change the type of breakpoint to an ordinary watchpoint if a
8947 hardware watchpoint could not be set. */
8948 if (!reg_cnt || target_resources_ok <= 0)
8949 bp_type = bp_watchpoint;
8951 frame = block_innermost_frame (exp_valid_block);
8953 /* If the expression is "local", then set up a "watchpoint scope"
8954 breakpoint at the point where we've left the scope of the watchpoint
8955 expression. Create the scope breakpoint before the watchpoint, so
8956 that we will encounter it first in bpstat_stop_status. */
8957 if (exp_valid_block && frame)
8959 if (frame_id_p (frame_unwind_caller_id (frame)))
8962 = create_internal_breakpoint (frame_unwind_caller_arch (frame),
8963 frame_unwind_caller_pc (frame),
8964 bp_watchpoint_scope);
8966 scope_breakpoint->enable_state = bp_enabled;
8968 /* Automatically delete the breakpoint when it hits. */
8969 scope_breakpoint->disposition = disp_del;
8971 /* Only break in the proper frame (help with recursion). */
8972 scope_breakpoint->frame_id = frame_unwind_caller_id (frame);
8974 /* Set the address at which we will stop. */
8975 scope_breakpoint->loc->gdbarch
8976 = frame_unwind_caller_arch (frame);
8977 scope_breakpoint->loc->requested_address
8978 = frame_unwind_caller_pc (frame);
8979 scope_breakpoint->loc->address
8980 = adjust_breakpoint_address (scope_breakpoint->loc->gdbarch,
8981 scope_breakpoint->loc->requested_address,
8982 scope_breakpoint->type);
8986 /* Now set up the breakpoint. */
8987 b = set_raw_breakpoint_without_location (NULL, bp_type);
8988 set_breakpoint_number (internal, b);
8990 b->disposition = disp_donttouch;
8992 b->exp_valid_block = exp_valid_block;
8993 b->cond_exp_valid_block = cond_exp_valid_block;
8996 struct type *t = value_type (val);
8997 CORE_ADDR addr = value_as_address (val);
9000 t = check_typedef (TYPE_TARGET_TYPE (check_typedef (t)));
9001 name = type_to_string (t);
9003 b->exp_string_reparse = xstrprintf ("* (%s *) %s", name,
9004 core_addr_to_string (addr));
9007 b->exp_string = xstrprintf ("-location %.*s",
9008 (int) (exp_end - exp_start), exp_start);
9010 /* The above expression is in C. */
9011 b->language = language_c;
9014 b->exp_string = savestring (exp_start, exp_end - exp_start);
9017 b->ops = &watchpoint_breakpoint_ops;
9019 /* Use an exact watchpoint when there's only one memory region to be
9020 watched, and only one debug register is needed to watch it. */
9021 b->exact = target_exact_watchpoints && reg_cnt == 1;
9024 b->cond_string = savestring (cond_start, cond_end - cond_start);
9030 b->watchpoint_frame = get_frame_id (frame);
9031 b->watchpoint_thread = inferior_ptid;
9035 b->watchpoint_frame = null_frame_id;
9036 b->watchpoint_thread = null_ptid;
9039 if (scope_breakpoint != NULL)
9041 /* The scope breakpoint is related to the watchpoint. We will
9042 need to act on them together. */
9043 b->related_breakpoint = scope_breakpoint;
9044 scope_breakpoint->related_breakpoint = b;
9048 value_free_to_mark (mark);
9050 /* Finally update the new watchpoint. This creates the locations
9051 that should be inserted. */
9052 update_watchpoint (b, 1);
9054 /* Do not mention breakpoints with a negative number, but do
9055 notify observers. */
9058 observer_notify_breakpoint_created (b);
9060 update_global_location_list (1);
9063 /* Return count of debug registers needed to watch the given expression.
9064 If EXACT_WATCHPOINTS is 1, then consider that only the address of
9065 the start of the watched region will be monitored (i.e., all accesses
9066 will be aligned). This uses less debug registers on some targets.
9068 If the watchpoint cannot be handled in hardware return zero. */
9071 can_use_hardware_watchpoint (struct value *v, int exact_watchpoints)
9073 int found_memory_cnt = 0;
9074 struct value *head = v;
9076 /* Did the user specifically forbid us to use hardware watchpoints? */
9077 if (!can_use_hw_watchpoints)
9080 /* Make sure that the value of the expression depends only upon
9081 memory contents, and values computed from them within GDB. If we
9082 find any register references or function calls, we can't use a
9083 hardware watchpoint.
9085 The idea here is that evaluating an expression generates a series
9086 of values, one holding the value of every subexpression. (The
9087 expression a*b+c has five subexpressions: a, b, a*b, c, and
9088 a*b+c.) GDB's values hold almost enough information to establish
9089 the criteria given above --- they identify memory lvalues,
9090 register lvalues, computed values, etcetera. So we can evaluate
9091 the expression, and then scan the chain of values that leaves
9092 behind to decide whether we can detect any possible change to the
9093 expression's final value using only hardware watchpoints.
9095 However, I don't think that the values returned by inferior
9096 function calls are special in any way. So this function may not
9097 notice that an expression involving an inferior function call
9098 can't be watched with hardware watchpoints. FIXME. */
9099 for (; v; v = value_next (v))
9101 if (VALUE_LVAL (v) == lval_memory)
9103 if (v != head && value_lazy (v))
9104 /* A lazy memory lvalue in the chain is one that GDB never
9105 needed to fetch; we either just used its address (e.g.,
9106 `a' in `a.b') or we never needed it at all (e.g., `a'
9107 in `a,b'). This doesn't apply to HEAD; if that is
9108 lazy then it was not readable, but watch it anyway. */
9112 /* Ahh, memory we actually used! Check if we can cover
9113 it with hardware watchpoints. */
9114 struct type *vtype = check_typedef (value_type (v));
9116 /* We only watch structs and arrays if user asked for it
9117 explicitly, never if they just happen to appear in a
9118 middle of some value chain. */
9120 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
9121 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
9123 CORE_ADDR vaddr = value_address (v);
9127 len = (exact_watchpoints
9128 && is_scalar_type_recursive (vtype))?
9129 1 : TYPE_LENGTH (value_type (v));
9131 num_regs = target_region_ok_for_hw_watchpoint (vaddr, len);
9135 found_memory_cnt += num_regs;
9139 else if (VALUE_LVAL (v) != not_lval
9140 && deprecated_value_modifiable (v) == 0)
9141 return 0; /* These are values from the history (e.g., $1). */
9142 else if (VALUE_LVAL (v) == lval_register)
9143 return 0; /* Cannot watch a register with a HW watchpoint. */
9146 /* The expression itself looks suitable for using a hardware
9147 watchpoint, but give the target machine a chance to reject it. */
9148 return found_memory_cnt;
9152 watch_command_wrapper (char *arg, int from_tty, int internal)
9154 watch_command_1 (arg, hw_write, from_tty, 0, internal);
9157 /* A helper function that looks for an argument at the start of a
9158 string. The argument must also either be at the end of the string,
9159 or be followed by whitespace. Returns 1 if it finds the argument,
9160 0 otherwise. If the argument is found, it updates *STR. */
9163 check_for_argument (char **str, char *arg, int arg_len)
9165 if (strncmp (*str, arg, arg_len) == 0
9166 && ((*str)[arg_len] == '\0' || isspace ((*str)[arg_len])))
9174 /* A helper function that looks for the "-location" argument and then
9175 calls watch_command_1. */
9178 watch_maybe_just_location (char *arg, int accessflag, int from_tty)
9180 int just_location = 0;
9183 && (check_for_argument (&arg, "-location", sizeof ("-location") - 1)
9184 || check_for_argument (&arg, "-l", sizeof ("-l") - 1)))
9186 arg = skip_spaces (arg);
9190 watch_command_1 (arg, accessflag, from_tty, just_location, 0);
9194 watch_command (char *arg, int from_tty)
9196 watch_maybe_just_location (arg, hw_write, from_tty);
9200 rwatch_command_wrapper (char *arg, int from_tty, int internal)
9202 watch_command_1 (arg, hw_read, from_tty, 0, internal);
9206 rwatch_command (char *arg, int from_tty)
9208 watch_maybe_just_location (arg, hw_read, from_tty);
9212 awatch_command_wrapper (char *arg, int from_tty, int internal)
9214 watch_command_1 (arg, hw_access, from_tty, 0, internal);
9218 awatch_command (char *arg, int from_tty)
9220 watch_maybe_just_location (arg, hw_access, from_tty);
9224 /* Helper routines for the until_command routine in infcmd.c. Here
9225 because it uses the mechanisms of breakpoints. */
9227 struct until_break_command_continuation_args
9229 struct breakpoint *breakpoint;
9230 struct breakpoint *breakpoint2;
9234 /* This function is called by fetch_inferior_event via the
9235 cmd_continuation pointer, to complete the until command. It takes
9236 care of cleaning up the temporary breakpoints set up by the until
9239 until_break_command_continuation (void *arg)
9241 struct until_break_command_continuation_args *a = arg;
9243 delete_breakpoint (a->breakpoint);
9245 delete_breakpoint (a->breakpoint2);
9246 delete_longjmp_breakpoint (a->thread_num);
9250 until_break_command (char *arg, int from_tty, int anywhere)
9252 struct symtabs_and_lines sals;
9253 struct symtab_and_line sal;
9254 struct frame_info *frame = get_selected_frame (NULL);
9255 struct breakpoint *breakpoint;
9256 struct breakpoint *breakpoint2 = NULL;
9257 struct cleanup *old_chain;
9259 struct thread_info *tp;
9261 clear_proceed_status ();
9263 /* Set a breakpoint where the user wants it and at return from
9266 if (default_breakpoint_valid)
9267 sals = decode_line_1 (&arg, 1, default_breakpoint_symtab,
9268 default_breakpoint_line, NULL);
9270 sals = decode_line_1 (&arg, 1, (struct symtab *) NULL, 0, NULL);
9272 if (sals.nelts != 1)
9273 error (_("Couldn't get information on specified line."));
9276 xfree (sals.sals); /* malloc'd, so freed. */
9279 error (_("Junk at end of arguments."));
9281 resolve_sal_pc (&sal);
9284 /* If the user told us to continue until a specified location,
9285 we don't specify a frame at which we need to stop. */
9286 breakpoint = set_momentary_breakpoint (get_frame_arch (frame), sal,
9287 null_frame_id, bp_until);
9289 /* Otherwise, specify the selected frame, because we want to stop
9290 only at the very same frame. */
9291 breakpoint = set_momentary_breakpoint (get_frame_arch (frame), sal,
9292 get_stack_frame_id (frame),
9295 old_chain = make_cleanup_delete_breakpoint (breakpoint);
9297 tp = inferior_thread ();
9300 /* Keep within the current frame, or in frames called by the current
9303 if (frame_id_p (frame_unwind_caller_id (frame)))
9305 sal = find_pc_line (frame_unwind_caller_pc (frame), 0);
9306 sal.pc = frame_unwind_caller_pc (frame);
9307 breakpoint2 = set_momentary_breakpoint (frame_unwind_caller_arch (frame),
9309 frame_unwind_caller_id (frame),
9311 make_cleanup_delete_breakpoint (breakpoint2);
9313 set_longjmp_breakpoint (tp, frame_unwind_caller_id (frame));
9314 make_cleanup (delete_longjmp_breakpoint_cleanup, &thread);
9317 proceed (-1, TARGET_SIGNAL_DEFAULT, 0);
9319 /* If we are running asynchronously, and proceed call above has
9320 actually managed to start the target, arrange for breakpoints to
9321 be deleted when the target stops. Otherwise, we're already
9322 stopped and delete breakpoints via cleanup chain. */
9324 if (target_can_async_p () && is_running (inferior_ptid))
9326 struct until_break_command_continuation_args *args;
9327 args = xmalloc (sizeof (*args));
9329 args->breakpoint = breakpoint;
9330 args->breakpoint2 = breakpoint2;
9331 args->thread_num = thread;
9333 discard_cleanups (old_chain);
9334 add_continuation (inferior_thread (),
9335 until_break_command_continuation, args,
9339 do_cleanups (old_chain);
9342 /* This function attempts to parse an optional "if <cond>" clause
9343 from the arg string. If one is not found, it returns NULL.
9345 Else, it returns a pointer to the condition string. (It does not
9346 attempt to evaluate the string against a particular block.) And,
9347 it updates arg to point to the first character following the parsed
9348 if clause in the arg string. */
9351 ep_parse_optional_if_clause (char **arg)
9355 if (((*arg)[0] != 'i') || ((*arg)[1] != 'f') || !isspace ((*arg)[2]))
9358 /* Skip the "if" keyword. */
9361 /* Skip any extra leading whitespace, and record the start of the
9362 condition string. */
9363 *arg = skip_spaces (*arg);
9366 /* Assume that the condition occupies the remainder of the arg
9368 (*arg) += strlen (cond_string);
9373 /* Commands to deal with catching events, such as signals, exceptions,
9374 process start/exit, etc. */
9378 catch_fork_temporary, catch_vfork_temporary,
9379 catch_fork_permanent, catch_vfork_permanent
9384 catch_fork_command_1 (char *arg, int from_tty,
9385 struct cmd_list_element *command)
9387 struct gdbarch *gdbarch = get_current_arch ();
9388 char *cond_string = NULL;
9389 catch_fork_kind fork_kind;
9392 fork_kind = (catch_fork_kind) (uintptr_t) get_cmd_context (command);
9393 tempflag = (fork_kind == catch_fork_temporary
9394 || fork_kind == catch_vfork_temporary);
9398 arg = skip_spaces (arg);
9400 /* The allowed syntax is:
9402 catch [v]fork if <cond>
9404 First, check if there's an if clause. */
9405 cond_string = ep_parse_optional_if_clause (&arg);
9407 if ((*arg != '\0') && !isspace (*arg))
9408 error (_("Junk at end of arguments."));
9410 /* If this target supports it, create a fork or vfork catchpoint
9411 and enable reporting of such events. */
9414 case catch_fork_temporary:
9415 case catch_fork_permanent:
9416 create_fork_vfork_event_catchpoint (gdbarch, tempflag, cond_string,
9417 &catch_fork_breakpoint_ops);
9419 case catch_vfork_temporary:
9420 case catch_vfork_permanent:
9421 create_fork_vfork_event_catchpoint (gdbarch, tempflag, cond_string,
9422 &catch_vfork_breakpoint_ops);
9425 error (_("unsupported or unknown fork kind; cannot catch it"));
9431 catch_exec_command_1 (char *arg, int from_tty,
9432 struct cmd_list_element *command)
9434 struct gdbarch *gdbarch = get_current_arch ();
9436 char *cond_string = NULL;
9438 tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
9442 arg = skip_spaces (arg);
9444 /* The allowed syntax is:
9446 catch exec if <cond>
9448 First, check if there's an if clause. */
9449 cond_string = ep_parse_optional_if_clause (&arg);
9451 if ((*arg != '\0') && !isspace (*arg))
9452 error (_("Junk at end of arguments."));
9454 /* If this target supports it, create an exec catchpoint
9455 and enable reporting of such events. */
9456 create_catchpoint (gdbarch, tempflag, cond_string,
9457 &catch_exec_breakpoint_ops);
9460 static enum print_stop_action
9461 print_it_exception_catchpoint (struct breakpoint *b)
9463 int bp_temp, bp_throw;
9465 annotate_catchpoint (b->number);
9467 bp_throw = strstr (b->addr_string, "throw") != NULL;
9468 if (b->loc->address != b->loc->requested_address)
9469 breakpoint_adjustment_warning (b->loc->requested_address,
9472 bp_temp = b->disposition == disp_del;
9474 bp_temp ? "Temporary catchpoint "
9476 if (!ui_out_is_mi_like_p (uiout))
9477 ui_out_field_int (uiout, "bkptno", b->number);
9479 bp_throw ? " (exception thrown), "
9480 : " (exception caught), ");
9481 if (ui_out_is_mi_like_p (uiout))
9483 ui_out_field_string (uiout, "reason",
9484 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
9485 ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
9486 ui_out_field_int (uiout, "bkptno", b->number);
9488 return PRINT_SRC_AND_LOC;
9492 print_one_exception_catchpoint (struct breakpoint *b,
9493 struct bp_location **last_loc)
9495 struct value_print_options opts;
9497 get_user_print_options (&opts);
9498 if (opts.addressprint)
9501 if (b->loc == NULL || b->loc->shlib_disabled)
9502 ui_out_field_string (uiout, "addr", "<PENDING>");
9504 ui_out_field_core_addr (uiout, "addr",
9505 b->loc->gdbarch, b->loc->address);
9510 if (strstr (b->addr_string, "throw") != NULL)
9511 ui_out_field_string (uiout, "what", "exception throw");
9513 ui_out_field_string (uiout, "what", "exception catch");
9517 print_mention_exception_catchpoint (struct breakpoint *b)
9522 bp_temp = b->disposition == disp_del;
9523 bp_throw = strstr (b->addr_string, "throw") != NULL;
9524 ui_out_text (uiout, bp_temp ? _("Temporary catchpoint ")
9525 : _("Catchpoint "));
9526 ui_out_field_int (uiout, "bkptno", b->number);
9527 ui_out_text (uiout, bp_throw ? _(" (throw)")
9531 /* Implement the "print_recreate" breakpoint_ops method for throw and
9532 catch catchpoints. */
9535 print_recreate_exception_catchpoint (struct breakpoint *b,
9541 bp_temp = b->disposition == disp_del;
9542 bp_throw = strstr (b->addr_string, "throw") != NULL;
9543 fprintf_unfiltered (fp, bp_temp ? "tcatch " : "catch ");
9544 fprintf_unfiltered (fp, bp_throw ? "throw" : "catch");
9547 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops = {
9550 NULL, /* breakpoint_hit */
9551 NULL, /* resources_needed */
9552 print_it_exception_catchpoint,
9553 print_one_exception_catchpoint,
9554 NULL, /* print_one_detail */
9555 print_mention_exception_catchpoint,
9556 print_recreate_exception_catchpoint
9560 handle_gnu_v3_exceptions (int tempflag, char *cond_string,
9561 enum exception_event_kind ex_event, int from_tty)
9563 char *trigger_func_name;
9565 if (ex_event == EX_EVENT_CATCH)
9566 trigger_func_name = "__cxa_begin_catch";
9568 trigger_func_name = "__cxa_throw";
9570 create_breakpoint (get_current_arch (),
9571 trigger_func_name, cond_string, -1,
9572 0 /* condition and thread are valid. */,
9573 tempflag, bp_breakpoint,
9575 AUTO_BOOLEAN_TRUE /* pending */,
9576 &gnu_v3_exception_catchpoint_ops, from_tty,
9583 /* Deal with "catch catch" and "catch throw" commands. */
9586 catch_exception_command_1 (enum exception_event_kind ex_event, char *arg,
9587 int tempflag, int from_tty)
9589 char *cond_string = NULL;
9593 arg = skip_spaces (arg);
9595 cond_string = ep_parse_optional_if_clause (&arg);
9597 if ((*arg != '\0') && !isspace (*arg))
9598 error (_("Junk at end of arguments."));
9600 if (ex_event != EX_EVENT_THROW
9601 && ex_event != EX_EVENT_CATCH)
9602 error (_("Unsupported or unknown exception event; cannot catch it"));
9604 if (handle_gnu_v3_exceptions (tempflag, cond_string, ex_event, from_tty))
9607 warning (_("Unsupported with this platform/compiler combination."));
9610 /* Implementation of "catch catch" command. */
9613 catch_catch_command (char *arg, int from_tty, struct cmd_list_element *command)
9615 int tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
9617 catch_exception_command_1 (EX_EVENT_CATCH, arg, tempflag, from_tty);
9620 /* Implementation of "catch throw" command. */
9623 catch_throw_command (char *arg, int from_tty, struct cmd_list_element *command)
9625 int tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
9627 catch_exception_command_1 (EX_EVENT_THROW, arg, tempflag, from_tty);
9630 /* Create a breakpoint struct for Ada exception catchpoints. */
9633 create_ada_exception_breakpoint (struct gdbarch *gdbarch,
9634 struct symtab_and_line sal,
9638 struct expression *cond,
9639 struct breakpoint_ops *ops,
9643 struct breakpoint *b;
9647 struct gdbarch *loc_gdbarch = get_sal_arch (sal);
9649 loc_gdbarch = gdbarch;
9651 describe_other_breakpoints (loc_gdbarch,
9652 sal.pspace, sal.pc, sal.section, -1);
9653 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
9654 version for exception catchpoints, because two catchpoints
9655 used for different exception names will use the same address.
9656 In this case, a "breakpoint ... also set at..." warning is
9657 unproductive. Besides, the warning phrasing is also a bit
9658 inapropriate, we should use the word catchpoint, and tell
9659 the user what type of catchpoint it is. The above is good
9660 enough for now, though. */
9663 b = set_raw_breakpoint (gdbarch, sal, bp_breakpoint);
9664 set_breakpoint_count (breakpoint_count + 1);
9666 b->enable_state = bp_enabled;
9667 b->disposition = tempflag ? disp_del : disp_donttouch;
9668 b->number = breakpoint_count;
9669 b->ignore_count = 0;
9670 b->loc->cond = cond;
9671 b->addr_string = addr_string;
9672 b->language = language_ada;
9673 b->cond_string = cond_string;
9674 b->exp_string = exp_string;
9679 observer_notify_breakpoint_created (b);
9680 update_global_location_list (1);
9683 /* Implement the "catch exception" command. */
9686 catch_ada_exception_command (char *arg, int from_tty,
9687 struct cmd_list_element *command)
9689 struct gdbarch *gdbarch = get_current_arch ();
9691 struct symtab_and_line sal;
9692 char *addr_string = NULL;
9693 char *exp_string = NULL;
9694 char *cond_string = NULL;
9695 struct expression *cond = NULL;
9696 struct breakpoint_ops *ops = NULL;
9698 tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
9702 sal = ada_decode_exception_location (arg, &addr_string, &exp_string,
9703 &cond_string, &cond, &ops);
9704 create_ada_exception_breakpoint (gdbarch, sal, addr_string, exp_string,
9705 cond_string, cond, ops, tempflag,
9709 /* Cleanup function for a syscall filter list. */
9711 clean_up_filters (void *arg)
9713 VEC(int) *iter = *(VEC(int) **) arg;
9714 VEC_free (int, iter);
9717 /* Splits the argument using space as delimiter. Returns an xmalloc'd
9718 filter list, or NULL if no filtering is required. */
9720 catch_syscall_split_args (char *arg)
9722 VEC(int) *result = NULL;
9723 struct cleanup *cleanup = make_cleanup (clean_up_filters, &result);
9725 while (*arg != '\0')
9727 int i, syscall_number;
9732 /* Skip whitespace. */
9733 while (isspace (*arg))
9736 for (i = 0; i < 127 && arg[i] && !isspace (arg[i]); ++i)
9737 cur_name[i] = arg[i];
9741 /* Check if the user provided a syscall name or a number. */
9742 syscall_number = (int) strtol (cur_name, &endptr, 0);
9743 if (*endptr == '\0')
9744 get_syscall_by_number (syscall_number, &s);
9747 /* We have a name. Let's check if it's valid and convert it
9749 get_syscall_by_name (cur_name, &s);
9751 if (s.number == UNKNOWN_SYSCALL)
9752 /* Here we have to issue an error instead of a warning,
9753 because GDB cannot do anything useful if there's no
9754 syscall number to be caught. */
9755 error (_("Unknown syscall name '%s'."), cur_name);
9758 /* Ok, it's valid. */
9759 VEC_safe_push (int, result, s.number);
9762 discard_cleanups (cleanup);
9766 /* Implement the "catch syscall" command. */
9769 catch_syscall_command_1 (char *arg, int from_tty,
9770 struct cmd_list_element *command)
9775 struct gdbarch *gdbarch = get_current_arch ();
9777 /* Checking if the feature if supported. */
9778 if (gdbarch_get_syscall_number_p (gdbarch) == 0)
9779 error (_("The feature 'catch syscall' is not supported on \
9780 this architecture yet."));
9782 tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
9784 arg = skip_spaces (arg);
9786 /* We need to do this first "dummy" translation in order
9787 to get the syscall XML file loaded or, most important,
9788 to display a warning to the user if there's no XML file
9789 for his/her architecture. */
9790 get_syscall_by_number (0, &s);
9792 /* The allowed syntax is:
9794 catch syscall <name | number> [<name | number> ... <name | number>]
9796 Let's check if there's a syscall name. */
9799 filter = catch_syscall_split_args (arg);
9803 create_syscall_event_catchpoint (tempflag, filter,
9804 &catch_syscall_breakpoint_ops);
9807 /* Implement the "catch assert" command. */
9810 catch_assert_command (char *arg, int from_tty,
9811 struct cmd_list_element *command)
9813 struct gdbarch *gdbarch = get_current_arch ();
9815 struct symtab_and_line sal;
9816 char *addr_string = NULL;
9817 struct breakpoint_ops *ops = NULL;
9819 tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
9823 sal = ada_decode_assert_location (arg, &addr_string, &ops);
9824 create_ada_exception_breakpoint (gdbarch, sal, addr_string, NULL, NULL, NULL,
9825 ops, tempflag, from_tty);
9829 catch_command (char *arg, int from_tty)
9831 error (_("Catch requires an event name."));
9836 tcatch_command (char *arg, int from_tty)
9838 error (_("Catch requires an event name."));
9841 /* Delete breakpoints by address or line. */
9844 clear_command (char *arg, int from_tty)
9846 struct breakpoint *b;
9847 VEC(breakpoint_p) *found = 0;
9850 struct symtabs_and_lines sals;
9851 struct symtab_and_line sal;
9856 sals = decode_line_spec (arg, 1);
9861 sals.sals = (struct symtab_and_line *)
9862 xmalloc (sizeof (struct symtab_and_line));
9863 make_cleanup (xfree, sals.sals);
9864 init_sal (&sal); /* Initialize to zeroes. */
9865 sal.line = default_breakpoint_line;
9866 sal.symtab = default_breakpoint_symtab;
9867 sal.pc = default_breakpoint_address;
9868 sal.pspace = default_breakpoint_pspace;
9869 if (sal.symtab == 0)
9870 error (_("No source file specified."));
9878 /* We don't call resolve_sal_pc here. That's not as bad as it
9879 seems, because all existing breakpoints typically have both
9880 file/line and pc set. So, if clear is given file/line, we can
9881 match this to existing breakpoint without obtaining pc at all.
9883 We only support clearing given the address explicitly
9884 present in breakpoint table. Say, we've set breakpoint
9885 at file:line. There were several PC values for that file:line,
9886 due to optimization, all in one block.
9888 We've picked one PC value. If "clear" is issued with another
9889 PC corresponding to the same file:line, the breakpoint won't
9890 be cleared. We probably can still clear the breakpoint, but
9891 since the other PC value is never presented to user, user
9892 can only find it by guessing, and it does not seem important
9895 /* For each line spec given, delete bps which correspond to it. Do
9896 it in two passes, solely to preserve the current behavior that
9897 from_tty is forced true if we delete more than one
9901 for (i = 0; i < sals.nelts; i++)
9903 /* If exact pc given, clear bpts at that pc.
9904 If line given (pc == 0), clear all bpts on specified line.
9905 If defaulting, clear all bpts on default line
9908 defaulting sal.pc != 0 tests to do
9913 1 0 <can't happen> */
9917 /* Find all matching breakpoints and add them to 'found'. */
9921 /* Are we going to delete b? */
9922 if (b->type != bp_none && !is_watchpoint (b))
9924 struct bp_location *loc = b->loc;
9925 for (; loc; loc = loc->next)
9927 int pc_match = sal.pc
9928 && (loc->pspace == sal.pspace)
9929 && (loc->address == sal.pc)
9930 && (!section_is_overlay (loc->section)
9931 || loc->section == sal.section);
9932 int line_match = ((default_match || (0 == sal.pc))
9933 && b->source_file != NULL
9934 && sal.symtab != NULL
9935 && sal.pspace == loc->pspace
9936 && filename_cmp (b->source_file,
9937 sal.symtab->filename) == 0
9938 && b->line_number == sal.line);
9939 if (pc_match || line_match)
9948 VEC_safe_push(breakpoint_p, found, b);
9951 /* Now go thru the 'found' chain and delete them. */
9952 if (VEC_empty(breakpoint_p, found))
9955 error (_("No breakpoint at %s."), arg);
9957 error (_("No breakpoint at this line."));
9960 if (VEC_length(breakpoint_p, found) > 1)
9961 from_tty = 1; /* Always report if deleted more than one. */
9964 if (VEC_length(breakpoint_p, found) == 1)
9965 printf_unfiltered (_("Deleted breakpoint "));
9967 printf_unfiltered (_("Deleted breakpoints "));
9969 breakpoints_changed ();
9971 for (ix = 0; VEC_iterate(breakpoint_p, found, ix, b); ix++)
9974 printf_unfiltered ("%d ", b->number);
9975 delete_breakpoint (b);
9978 putchar_unfiltered ('\n');
9981 /* Delete breakpoint in BS if they are `delete' breakpoints and
9982 all breakpoints that are marked for deletion, whether hit or not.
9983 This is called after any breakpoint is hit, or after errors. */
9986 breakpoint_auto_delete (bpstat bs)
9988 struct breakpoint *b, *b_tmp;
9990 for (; bs; bs = bs->next)
9991 if (bs->breakpoint_at
9992 && bs->breakpoint_at->disposition == disp_del
9994 delete_breakpoint (bs->breakpoint_at);
9996 ALL_BREAKPOINTS_SAFE (b, b_tmp)
9998 if (b->disposition == disp_del_at_next_stop)
9999 delete_breakpoint (b);
10003 /* A comparison function for bp_location AP and BP being interfaced to
10004 qsort. Sort elements primarily by their ADDRESS (no matter what
10005 does breakpoint_address_is_meaningful say for its OWNER),
10006 secondarily by ordering first bp_permanent OWNERed elements and
10007 terciarily just ensuring the array is sorted stable way despite
10008 qsort being an instable algorithm. */
10011 bp_location_compare (const void *ap, const void *bp)
10013 struct bp_location *a = *(void **) ap;
10014 struct bp_location *b = *(void **) bp;
10015 /* A and B come from existing breakpoints having non-NULL OWNER. */
10016 int a_perm = a->owner->enable_state == bp_permanent;
10017 int b_perm = b->owner->enable_state == bp_permanent;
10019 if (a->address != b->address)
10020 return (a->address > b->address) - (a->address < b->address);
10022 /* Sort permanent breakpoints first. */
10023 if (a_perm != b_perm)
10024 return (a_perm < b_perm) - (a_perm > b_perm);
10026 /* Make the user-visible order stable across GDB runs. Locations of
10027 the same breakpoint can be sorted in arbitrary order. */
10029 if (a->owner->number != b->owner->number)
10030 return (a->owner->number > b->owner->number)
10031 - (a->owner->number < b->owner->number);
10033 return (a > b) - (a < b);
10036 /* Set bp_location_placed_address_before_address_max and
10037 bp_location_shadow_len_after_address_max according to the current
10038 content of the bp_location array. */
10041 bp_location_target_extensions_update (void)
10043 struct bp_location *bl, **blp_tmp;
10045 bp_location_placed_address_before_address_max = 0;
10046 bp_location_shadow_len_after_address_max = 0;
10048 ALL_BP_LOCATIONS (bl, blp_tmp)
10050 CORE_ADDR start, end, addr;
10052 if (!bp_location_has_shadow (bl))
10055 start = bl->target_info.placed_address;
10056 end = start + bl->target_info.shadow_len;
10058 gdb_assert (bl->address >= start);
10059 addr = bl->address - start;
10060 if (addr > bp_location_placed_address_before_address_max)
10061 bp_location_placed_address_before_address_max = addr;
10063 /* Zero SHADOW_LEN would not pass bp_location_has_shadow. */
10065 gdb_assert (bl->address < end);
10066 addr = end - bl->address;
10067 if (addr > bp_location_shadow_len_after_address_max)
10068 bp_location_shadow_len_after_address_max = addr;
10072 /* If SHOULD_INSERT is false, do not insert any breakpoint locations
10073 into the inferior, only remove already-inserted locations that no
10074 longer should be inserted. Functions that delete a breakpoint or
10075 breakpoints should pass false, so that deleting a breakpoint
10076 doesn't have the side effect of inserting the locations of other
10077 breakpoints that are marked not-inserted, but should_be_inserted
10078 returns true on them.
10080 This behaviour is useful is situations close to tear-down -- e.g.,
10081 after an exec, while the target still has execution, but breakpoint
10082 shadows of the previous executable image should *NOT* be restored
10083 to the new image; or before detaching, where the target still has
10084 execution and wants to delete breakpoints from GDB's lists, and all
10085 breakpoints had already been removed from the inferior. */
10088 update_global_location_list (int should_insert)
10090 struct breakpoint *b;
10091 struct bp_location **locp, *loc;
10092 struct cleanup *cleanups;
10094 /* Used in the duplicates detection below. When iterating over all
10095 bp_locations, points to the first bp_location of a given address.
10096 Breakpoints and watchpoints of different types are never
10097 duplicates of each other. Keep one pointer for each type of
10098 breakpoint/watchpoint, so we only need to loop over all locations
10100 struct bp_location *bp_loc_first; /* breakpoint */
10101 struct bp_location *wp_loc_first; /* hardware watchpoint */
10102 struct bp_location *awp_loc_first; /* access watchpoint */
10103 struct bp_location *rwp_loc_first; /* read watchpoint */
10105 /* Saved former bp_location array which we compare against the newly
10106 built bp_location from the current state of ALL_BREAKPOINTS. */
10107 struct bp_location **old_location, **old_locp;
10108 unsigned old_location_count;
10110 old_location = bp_location;
10111 old_location_count = bp_location_count;
10112 bp_location = NULL;
10113 bp_location_count = 0;
10114 cleanups = make_cleanup (xfree, old_location);
10116 ALL_BREAKPOINTS (b)
10117 for (loc = b->loc; loc; loc = loc->next)
10118 bp_location_count++;
10120 bp_location = xmalloc (sizeof (*bp_location) * bp_location_count);
10121 locp = bp_location;
10122 ALL_BREAKPOINTS (b)
10123 for (loc = b->loc; loc; loc = loc->next)
10125 qsort (bp_location, bp_location_count, sizeof (*bp_location),
10126 bp_location_compare);
10128 bp_location_target_extensions_update ();
10130 /* Identify bp_location instances that are no longer present in the
10131 new list, and therefore should be freed. Note that it's not
10132 necessary that those locations should be removed from inferior --
10133 if there's another location at the same address (previously
10134 marked as duplicate), we don't need to remove/insert the
10137 LOCP is kept in sync with OLD_LOCP, each pointing to the current
10138 and former bp_location array state respectively. */
10140 locp = bp_location;
10141 for (old_locp = old_location; old_locp < old_location + old_location_count;
10144 struct bp_location *old_loc = *old_locp;
10145 struct bp_location **loc2p;
10147 /* Tells if 'old_loc' is found amoung the new locations. If
10148 not, we have to free it. */
10149 int found_object = 0;
10150 /* Tells if the location should remain inserted in the target. */
10151 int keep_in_target = 0;
10154 /* Skip LOCP entries which will definitely never be needed.
10155 Stop either at or being the one matching OLD_LOC. */
10156 while (locp < bp_location + bp_location_count
10157 && (*locp)->address < old_loc->address)
10161 (loc2p < bp_location + bp_location_count
10162 && (*loc2p)->address == old_loc->address);
10165 if (*loc2p == old_loc)
10172 /* If this location is no longer present, and inserted, look if
10173 there's maybe a new location at the same address. If so,
10174 mark that one inserted, and don't remove this one. This is
10175 needed so that we don't have a time window where a breakpoint
10176 at certain location is not inserted. */
10178 if (old_loc->inserted)
10180 /* If the location is inserted now, we might have to remove
10183 if (found_object && should_be_inserted (old_loc))
10185 /* The location is still present in the location list,
10186 and still should be inserted. Don't do anything. */
10187 keep_in_target = 1;
10191 /* The location is either no longer present, or got
10192 disabled. See if there's another location at the
10193 same address, in which case we don't need to remove
10194 this one from the target. */
10196 /* OLD_LOC comes from existing struct breakpoint. */
10197 if (breakpoint_address_is_meaningful (old_loc->owner))
10200 (loc2p < bp_location + bp_location_count
10201 && (*loc2p)->address == old_loc->address);
10204 struct bp_location *loc2 = *loc2p;
10206 if (breakpoint_locations_match (loc2, old_loc))
10208 /* For the sake of should_be_inserted.
10209 Duplicates check below will fix up this
10211 loc2->duplicate = 0;
10213 /* Read watchpoint locations are switched to
10214 access watchpoints, if the former are not
10215 supported, but the latter are. */
10216 if (is_hardware_watchpoint (old_loc->owner))
10218 gdb_assert (is_hardware_watchpoint (loc2->owner));
10219 loc2->watchpoint_type = old_loc->watchpoint_type;
10222 if (loc2 != old_loc && should_be_inserted (loc2))
10224 loc2->inserted = 1;
10225 loc2->target_info = old_loc->target_info;
10226 keep_in_target = 1;
10234 if (!keep_in_target)
10236 if (remove_breakpoint (old_loc, mark_uninserted))
10238 /* This is just about all we can do. We could keep
10239 this location on the global list, and try to
10240 remove it next time, but there's no particular
10241 reason why we will succeed next time.
10243 Note that at this point, old_loc->owner is still
10244 valid, as delete_breakpoint frees the breakpoint
10245 only after calling us. */
10246 printf_filtered (_("warning: Error removing "
10247 "breakpoint %d\n"),
10248 old_loc->owner->number);
10256 if (removed && non_stop
10257 && breakpoint_address_is_meaningful (old_loc->owner)
10258 && !is_hardware_watchpoint (old_loc->owner))
10260 /* This location was removed from the target. In
10261 non-stop mode, a race condition is possible where
10262 we've removed a breakpoint, but stop events for that
10263 breakpoint are already queued and will arrive later.
10264 We apply an heuristic to be able to distinguish such
10265 SIGTRAPs from other random SIGTRAPs: we keep this
10266 breakpoint location for a bit, and will retire it
10267 after we see some number of events. The theory here
10268 is that reporting of events should, "on the average",
10269 be fair, so after a while we'll see events from all
10270 threads that have anything of interest, and no longer
10271 need to keep this breakpoint location around. We
10272 don't hold locations forever so to reduce chances of
10273 mistaking a non-breakpoint SIGTRAP for a breakpoint
10276 The heuristic failing can be disastrous on
10277 decr_pc_after_break targets.
10279 On decr_pc_after_break targets, like e.g., x86-linux,
10280 if we fail to recognize a late breakpoint SIGTRAP,
10281 because events_till_retirement has reached 0 too
10282 soon, we'll fail to do the PC adjustment, and report
10283 a random SIGTRAP to the user. When the user resumes
10284 the inferior, it will most likely immediately crash
10285 with SIGILL/SIGBUS/SIGSEGV, or worse, get silently
10286 corrupted, because of being resumed e.g., in the
10287 middle of a multi-byte instruction, or skipped a
10288 one-byte instruction. This was actually seen happen
10289 on native x86-linux, and should be less rare on
10290 targets that do not support new thread events, like
10291 remote, due to the heuristic depending on
10294 Mistaking a random SIGTRAP for a breakpoint trap
10295 causes similar symptoms (PC adjustment applied when
10296 it shouldn't), but then again, playing with SIGTRAPs
10297 behind the debugger's back is asking for trouble.
10299 Since hardware watchpoint traps are always
10300 distinguishable from other traps, so we don't need to
10301 apply keep hardware watchpoint moribund locations
10302 around. We simply always ignore hardware watchpoint
10303 traps we can no longer explain. */
10305 old_loc->events_till_retirement = 3 * (thread_count () + 1);
10306 old_loc->owner = NULL;
10308 VEC_safe_push (bp_location_p, moribund_locations, old_loc);
10312 old_loc->owner = NULL;
10313 decref_bp_location (&old_loc);
10318 /* Rescan breakpoints at the same address and section, marking the
10319 first one as "first" and any others as "duplicates". This is so
10320 that the bpt instruction is only inserted once. If we have a
10321 permanent breakpoint at the same place as BPT, make that one the
10322 official one, and the rest as duplicates. Permanent breakpoints
10323 are sorted first for the same address.
10325 Do the same for hardware watchpoints, but also considering the
10326 watchpoint's type (regular/access/read) and length. */
10328 bp_loc_first = NULL;
10329 wp_loc_first = NULL;
10330 awp_loc_first = NULL;
10331 rwp_loc_first = NULL;
10332 ALL_BP_LOCATIONS (loc, locp)
10334 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always
10336 struct breakpoint *b = loc->owner;
10337 struct bp_location **loc_first_p;
10339 if (b->enable_state == bp_disabled
10340 || b->enable_state == bp_call_disabled
10341 || b->enable_state == bp_startup_disabled
10343 || loc->shlib_disabled
10344 || !breakpoint_address_is_meaningful (b)
10345 || is_tracepoint (b))
10348 /* Permanent breakpoint should always be inserted. */
10349 if (b->enable_state == bp_permanent && ! loc->inserted)
10350 internal_error (__FILE__, __LINE__,
10351 _("allegedly permanent breakpoint is not "
10352 "actually inserted"));
10354 if (b->type == bp_hardware_watchpoint)
10355 loc_first_p = &wp_loc_first;
10356 else if (b->type == bp_read_watchpoint)
10357 loc_first_p = &rwp_loc_first;
10358 else if (b->type == bp_access_watchpoint)
10359 loc_first_p = &awp_loc_first;
10361 loc_first_p = &bp_loc_first;
10363 if (*loc_first_p == NULL
10364 || (overlay_debugging && loc->section != (*loc_first_p)->section)
10365 || !breakpoint_locations_match (loc, *loc_first_p))
10367 *loc_first_p = loc;
10368 loc->duplicate = 0;
10372 loc->duplicate = 1;
10374 if ((*loc_first_p)->owner->enable_state == bp_permanent && loc->inserted
10375 && b->enable_state != bp_permanent)
10376 internal_error (__FILE__, __LINE__,
10377 _("another breakpoint was inserted on top of "
10378 "a permanent breakpoint"));
10381 if (breakpoints_always_inserted_mode () && should_insert
10382 && (have_live_inferiors ()
10383 || (gdbarch_has_global_breakpoints (target_gdbarch))))
10384 insert_breakpoint_locations ();
10386 do_cleanups (cleanups);
10390 breakpoint_retire_moribund (void)
10392 struct bp_location *loc;
10395 for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
10396 if (--(loc->events_till_retirement) == 0)
10398 decref_bp_location (&loc);
10399 VEC_unordered_remove (bp_location_p, moribund_locations, ix);
10405 update_global_location_list_nothrow (int inserting)
10407 struct gdb_exception e;
10409 TRY_CATCH (e, RETURN_MASK_ERROR)
10410 update_global_location_list (inserting);
10413 /* Clear BKP from a BPS. */
10416 bpstat_remove_bp_location (bpstat bps, struct breakpoint *bpt)
10420 for (bs = bps; bs; bs = bs->next)
10421 if (bs->breakpoint_at == bpt)
10423 bs->breakpoint_at = NULL;
10424 bs->old_val = NULL;
10425 /* bs->commands will be freed later. */
10429 /* Callback for iterate_over_threads. */
10431 bpstat_remove_breakpoint_callback (struct thread_info *th, void *data)
10433 struct breakpoint *bpt = data;
10435 bpstat_remove_bp_location (th->control.stop_bpstat, bpt);
10439 /* Delete a breakpoint and clean up all traces of it in the data
10443 delete_breakpoint (struct breakpoint *bpt)
10445 struct breakpoint *b;
10447 gdb_assert (bpt != NULL);
10449 /* Has this bp already been deleted? This can happen because
10450 multiple lists can hold pointers to bp's. bpstat lists are
10453 One example of this happening is a watchpoint's scope bp. When
10454 the scope bp triggers, we notice that the watchpoint is out of
10455 scope, and delete it. We also delete its scope bp. But the
10456 scope bp is marked "auto-deleting", and is already on a bpstat.
10457 That bpstat is then checked for auto-deleting bp's, which are
10460 A real solution to this problem might involve reference counts in
10461 bp's, and/or giving them pointers back to their referencing
10462 bpstat's, and teaching delete_breakpoint to only free a bp's
10463 storage when no more references were extent. A cheaper bandaid
10465 if (bpt->type == bp_none)
10468 /* At least avoid this stale reference until the reference counting
10469 of breakpoints gets resolved. */
10470 if (bpt->related_breakpoint != bpt)
10472 struct breakpoint *related;
10474 if (bpt->type == bp_watchpoint_scope)
10475 watchpoint_del_at_next_stop (bpt->related_breakpoint);
10476 else if (bpt->related_breakpoint->type == bp_watchpoint_scope)
10477 watchpoint_del_at_next_stop (bpt);
10479 /* Unlink bpt from the bpt->related_breakpoint ring. */
10480 for (related = bpt; related->related_breakpoint != bpt;
10481 related = related->related_breakpoint);
10482 related->related_breakpoint = bpt->related_breakpoint;
10483 bpt->related_breakpoint = bpt;
10486 observer_notify_breakpoint_deleted (bpt);
10488 if (breakpoint_chain == bpt)
10489 breakpoint_chain = bpt->next;
10491 ALL_BREAKPOINTS (b)
10492 if (b->next == bpt)
10494 b->next = bpt->next;
10498 decref_counted_command_line (&bpt->commands);
10499 xfree (bpt->cond_string);
10500 xfree (bpt->cond_exp);
10501 xfree (bpt->addr_string);
10502 xfree (bpt->addr_string_range_end);
10504 xfree (bpt->exp_string);
10505 xfree (bpt->exp_string_reparse);
10506 value_free (bpt->val);
10507 xfree (bpt->source_file);
10508 xfree (bpt->exec_pathname);
10509 clean_up_filters (&bpt->syscalls_to_be_caught);
10512 /* Be sure no bpstat's are pointing at the breakpoint after it's
10514 /* FIXME, how can we find all bpstat's? We just check stop_bpstat
10515 in all threeds for now. Note that we cannot just remove bpstats
10516 pointing at bpt from the stop_bpstat list entirely, as breakpoint
10517 commands are associated with the bpstat; if we remove it here,
10518 then the later call to bpstat_do_actions (&stop_bpstat); in
10519 event-top.c won't do anything, and temporary breakpoints with
10520 commands won't work. */
10522 iterate_over_threads (bpstat_remove_breakpoint_callback, bpt);
10524 /* Now that breakpoint is removed from breakpoint list, update the
10525 global location list. This will remove locations that used to
10526 belong to this breakpoint. Do this before freeing the breakpoint
10527 itself, since remove_breakpoint looks at location's owner. It
10528 might be better design to have location completely
10529 self-contained, but it's not the case now. */
10530 update_global_location_list (0);
10533 /* On the chance that someone will soon try again to delete this
10534 same bp, we mark it as deleted before freeing its storage. */
10535 bpt->type = bp_none;
10541 do_delete_breakpoint_cleanup (void *b)
10543 delete_breakpoint (b);
10547 make_cleanup_delete_breakpoint (struct breakpoint *b)
10549 return make_cleanup (do_delete_breakpoint_cleanup, b);
10552 /* A callback for map_breakpoint_numbers that calls
10553 delete_breakpoint. */
10556 do_delete_breakpoint (struct breakpoint *b, void *ignore)
10558 delete_breakpoint (b);
10562 delete_command (char *arg, int from_tty)
10564 struct breakpoint *b, *b_tmp;
10570 int breaks_to_delete = 0;
10572 /* Delete all breakpoints if no argument. Do not delete
10573 internal breakpoints, these have to be deleted with an
10574 explicit breakpoint number argument. */
10575 ALL_BREAKPOINTS (b)
10576 if (user_breakpoint_p (b))
10578 breaks_to_delete = 1;
10582 /* Ask user only if there are some breakpoints to delete. */
10584 || (breaks_to_delete && query (_("Delete all breakpoints? "))))
10586 ALL_BREAKPOINTS_SAFE (b, b_tmp)
10587 if (user_breakpoint_p (b))
10588 delete_breakpoint (b);
10592 map_breakpoint_numbers (arg, do_delete_breakpoint, NULL);
10596 all_locations_are_pending (struct bp_location *loc)
10598 for (; loc; loc = loc->next)
10599 if (!loc->shlib_disabled)
10604 /* Subroutine of update_breakpoint_locations to simplify it.
10605 Return non-zero if multiple fns in list LOC have the same name.
10606 Null names are ignored. */
10609 ambiguous_names_p (struct bp_location *loc)
10611 struct bp_location *l;
10612 htab_t htab = htab_create_alloc (13, htab_hash_string,
10613 (int (*) (const void *,
10614 const void *)) streq,
10615 NULL, xcalloc, xfree);
10617 for (l = loc; l != NULL; l = l->next)
10620 const char *name = l->function_name;
10622 /* Allow for some names to be NULL, ignore them. */
10626 slot = (const char **) htab_find_slot (htab, (const void *) name,
10628 /* NOTE: We can assume slot != NULL here because xcalloc never
10632 htab_delete (htab);
10638 htab_delete (htab);
10642 /* When symbols change, it probably means the sources changed as well,
10643 and it might mean the static tracepoint markers are no longer at
10644 the same address or line numbers they used to be at last we
10645 checked. Losing your static tracepoints whenever you rebuild is
10646 undesirable. This function tries to resync/rematch gdb static
10647 tracepoints with the markers on the target, for static tracepoints
10648 that have not been set by marker id. Static tracepoint that have
10649 been set by marker id are reset by marker id in breakpoint_re_set.
10652 1) For a tracepoint set at a specific address, look for a marker at
10653 the old PC. If one is found there, assume to be the same marker.
10654 If the name / string id of the marker found is different from the
10655 previous known name, assume that means the user renamed the marker
10656 in the sources, and output a warning.
10658 2) For a tracepoint set at a given line number, look for a marker
10659 at the new address of the old line number. If one is found there,
10660 assume to be the same marker. If the name / string id of the
10661 marker found is different from the previous known name, assume that
10662 means the user renamed the marker in the sources, and output a
10665 3) If a marker is no longer found at the same address or line, it
10666 may mean the marker no longer exists. But it may also just mean
10667 the code changed a bit. Maybe the user added a few lines of code
10668 that made the marker move up or down (in line number terms). Ask
10669 the target for info about the marker with the string id as we knew
10670 it. If found, update line number and address in the matching
10671 static tracepoint. This will get confused if there's more than one
10672 marker with the same ID (possible in UST, although unadvised
10673 precisely because it confuses tools). */
10675 static struct symtab_and_line
10676 update_static_tracepoint (struct breakpoint *b, struct symtab_and_line sal)
10678 struct static_tracepoint_marker marker;
10684 find_line_pc (sal.symtab, sal.line, &pc);
10686 if (target_static_tracepoint_marker_at (pc, &marker))
10688 if (strcmp (b->static_trace_marker_id, marker.str_id) != 0)
10689 warning (_("static tracepoint %d changed probed marker from %s to %s"),
10691 b->static_trace_marker_id, marker.str_id);
10693 xfree (b->static_trace_marker_id);
10694 b->static_trace_marker_id = xstrdup (marker.str_id);
10695 release_static_tracepoint_marker (&marker);
10700 /* Old marker wasn't found on target at lineno. Try looking it up
10702 if (!sal.explicit_pc
10704 && sal.symtab != NULL
10705 && b->static_trace_marker_id != NULL)
10707 VEC(static_tracepoint_marker_p) *markers;
10710 = target_static_tracepoint_markers_by_strid (b->static_trace_marker_id);
10712 if (!VEC_empty(static_tracepoint_marker_p, markers))
10714 struct symtab_and_line sal;
10715 struct symbol *sym;
10716 struct static_tracepoint_marker *marker;
10718 marker = VEC_index (static_tracepoint_marker_p, markers, 0);
10720 xfree (b->static_trace_marker_id);
10721 b->static_trace_marker_id = xstrdup (marker->str_id);
10723 warning (_("marker for static tracepoint %d (%s) not "
10724 "found at previous line number"),
10725 b->number, b->static_trace_marker_id);
10729 sal.pc = marker->address;
10731 sal = find_pc_line (marker->address, 0);
10732 sym = find_pc_sect_function (marker->address, NULL);
10733 ui_out_text (uiout, "Now in ");
10736 ui_out_field_string (uiout, "func",
10737 SYMBOL_PRINT_NAME (sym));
10738 ui_out_text (uiout, " at ");
10740 ui_out_field_string (uiout, "file", sal.symtab->filename);
10741 ui_out_text (uiout, ":");
10743 if (ui_out_is_mi_like_p (uiout))
10745 char *fullname = symtab_to_fullname (sal.symtab);
10748 ui_out_field_string (uiout, "fullname", fullname);
10751 ui_out_field_int (uiout, "line", sal.line);
10752 ui_out_text (uiout, "\n");
10754 b->line_number = sal.line;
10756 xfree (b->source_file);
10758 b->source_file = xstrdup (sal.symtab->filename);
10760 b->source_file = NULL;
10762 xfree (b->addr_string);
10763 b->addr_string = xstrprintf ("%s:%d",
10764 sal.symtab->filename, b->line_number);
10766 /* Might be nice to check if function changed, and warn if
10769 release_static_tracepoint_marker (marker);
10775 /* Returns 1 iff locations A and B are sufficiently same that
10776 we don't need to report breakpoint as changed. */
10779 locations_are_equal (struct bp_location *a, struct bp_location *b)
10783 if (a->address != b->address)
10786 if (a->shlib_disabled != b->shlib_disabled)
10789 if (a->enabled != b->enabled)
10796 if ((a == NULL) != (b == NULL))
10802 /* Create new breakpoint locations for B (a hardware or software breakpoint)
10803 based on SALS and SALS_END. If SALS_END.NELTS is not zero, then B is
10804 a ranged breakpoint. */
10807 update_breakpoint_locations (struct breakpoint *b,
10808 struct symtabs_and_lines sals,
10809 struct symtabs_and_lines sals_end)
10812 struct bp_location *existing_locations = b->loc;
10814 /* Ranged breakpoints have only one start location and one end location. */
10815 gdb_assert (sals_end.nelts == 0 || (sals.nelts == 1 && sals_end.nelts == 1));
10817 /* If there's no new locations, and all existing locations are
10818 pending, don't do anything. This optimizes the common case where
10819 all locations are in the same shared library, that was unloaded.
10820 We'd like to retain the location, so that when the library is
10821 loaded again, we don't loose the enabled/disabled status of the
10822 individual locations. */
10823 if (all_locations_are_pending (existing_locations) && sals.nelts == 0)
10828 for (i = 0; i < sals.nelts; ++i)
10830 struct bp_location *new_loc =
10831 add_location_to_breakpoint (b, &(sals.sals[i]));
10833 /* Reparse conditions, they might contain references to the
10835 if (b->cond_string != NULL)
10838 struct gdb_exception e;
10840 s = b->cond_string;
10841 TRY_CATCH (e, RETURN_MASK_ERROR)
10843 new_loc->cond = parse_exp_1 (&s, block_for_pc (sals.sals[i].pc),
10848 warning (_("failed to reevaluate condition "
10849 "for breakpoint %d: %s"),
10850 b->number, e.message);
10851 new_loc->enabled = 0;
10855 if (b->source_file != NULL)
10856 xfree (b->source_file);
10857 if (sals.sals[i].symtab == NULL)
10858 b->source_file = NULL;
10860 b->source_file = xstrdup (sals.sals[i].symtab->filename);
10862 if (b->line_number == 0)
10863 b->line_number = sals.sals[i].line;
10865 if (sals_end.nelts)
10867 CORE_ADDR end = find_breakpoint_range_end (sals_end.sals[0]);
10869 new_loc->length = end - sals.sals[0].pc + 1;
10873 /* Update locations of permanent breakpoints. */
10874 if (b->enable_state == bp_permanent)
10875 make_breakpoint_permanent (b);
10877 /* If possible, carry over 'disable' status from existing
10880 struct bp_location *e = existing_locations;
10881 /* If there are multiple breakpoints with the same function name,
10882 e.g. for inline functions, comparing function names won't work.
10883 Instead compare pc addresses; this is just a heuristic as things
10884 may have moved, but in practice it gives the correct answer
10885 often enough until a better solution is found. */
10886 int have_ambiguous_names = ambiguous_names_p (b->loc);
10888 for (; e; e = e->next)
10890 if (!e->enabled && e->function_name)
10892 struct bp_location *l = b->loc;
10893 if (have_ambiguous_names)
10895 for (; l; l = l->next)
10896 if (breakpoint_locations_match (e, l))
10904 for (; l; l = l->next)
10905 if (l->function_name
10906 && strcmp (e->function_name, l->function_name) == 0)
10916 if (!locations_are_equal (existing_locations, b->loc))
10917 observer_notify_breakpoint_modified (b);
10919 update_global_location_list (1);
10922 /* Find the SaL locations corresponding to the given ADDR_STRING.
10923 On return, FOUND will be 1 if any SaL was found, zero otherwise. */
10925 static struct symtabs_and_lines
10926 addr_string_to_sals (struct breakpoint *b, char *addr_string, int *found)
10930 struct symtabs_and_lines sals = {0};
10931 struct gdb_exception e;
10934 marker_spec = b->type == bp_static_tracepoint && is_marker_spec (s);
10936 TRY_CATCH (e, RETURN_MASK_ERROR)
10940 sals = decode_static_tracepoint_spec (&s);
10941 if (sals.nelts > b->static_trace_marker_id_idx)
10943 sals.sals[0] = sals.sals[b->static_trace_marker_id_idx];
10947 error (_("marker %s not found"), b->static_trace_marker_id);
10950 sals = decode_line_1 (&s, 1, (struct symtab *) NULL, 0, NULL);
10954 int not_found_and_ok = 0;
10955 /* For pending breakpoints, it's expected that parsing will
10956 fail until the right shared library is loaded. User has
10957 already told to create pending breakpoints and don't need
10958 extra messages. If breakpoint is in bp_shlib_disabled
10959 state, then user already saw the message about that
10960 breakpoint being disabled, and don't want to see more
10962 if (e.error == NOT_FOUND_ERROR
10963 && (b->condition_not_parsed
10964 || (b->loc && b->loc->shlib_disabled)
10965 || b->enable_state == bp_disabled))
10966 not_found_and_ok = 1;
10968 if (!not_found_and_ok)
10970 /* We surely don't want to warn about the same breakpoint
10971 10 times. One solution, implemented here, is disable
10972 the breakpoint on error. Another solution would be to
10973 have separate 'warning emitted' flag. Since this
10974 happens only when a binary has changed, I don't know
10975 which approach is better. */
10976 b->enable_state = bp_disabled;
10977 throw_exception (e);
10981 if (e.reason == 0 || e.error != NOT_FOUND_ERROR)
10983 gdb_assert (sals.nelts == 1);
10985 resolve_sal_pc (&sals.sals[0]);
10986 if (b->condition_not_parsed && s && s[0])
10988 char *cond_string = 0;
10992 find_condition_and_thread (s, sals.sals[0].pc,
10993 &cond_string, &thread, &task);
10995 b->cond_string = cond_string;
10996 b->thread = thread;
10998 b->condition_not_parsed = 0;
11001 if (b->type == bp_static_tracepoint && !marker_spec)
11002 sals.sals[0] = update_static_tracepoint (b, sals.sals[0]);
11012 /* Reevaluate a hardware or software breakpoint and recreate its locations.
11013 This is necessary after symbols are read (e.g., an executable or DSO
11014 was loaded, or the inferior just started). */
11017 re_set_breakpoint (struct breakpoint *b)
11020 struct symtabs_and_lines sals, sals_end;
11021 struct symtabs_and_lines expanded = {0};
11022 struct symtabs_and_lines expanded_end = {0};
11023 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
11025 input_radix = b->input_radix;
11026 save_current_space_and_thread ();
11027 switch_to_program_space_and_thread (b->pspace);
11028 set_language (b->language);
11030 sals = addr_string_to_sals (b, b->addr_string, &found);
11033 make_cleanup (xfree, sals.sals);
11034 expanded = expand_line_sal_maybe (sals.sals[0]);
11037 if (b->addr_string_range_end)
11039 sals_end = addr_string_to_sals (b, b->addr_string_range_end, &found);
11042 make_cleanup (xfree, sals_end.sals);
11043 expanded_end = expand_line_sal_maybe (sals_end.sals[0]);
11047 update_breakpoint_locations (b, expanded, expanded_end);
11048 do_cleanups (cleanups);
11051 /* Reset a breakpoint given it's struct breakpoint * BINT.
11052 The value we return ends up being the return value from catch_errors.
11053 Unused in this case. */
11056 breakpoint_re_set_one (void *bint)
11058 /* Get past catch_errs. */
11059 struct breakpoint *b = (struct breakpoint *) bint;
11064 warning (_("attempted to reset apparently deleted breakpoint #%d?"),
11067 case bp_breakpoint:
11068 case bp_hardware_breakpoint:
11069 case bp_tracepoint:
11070 case bp_fast_tracepoint:
11071 case bp_static_tracepoint:
11072 case bp_gnu_ifunc_resolver:
11073 /* Do not attempt to re-set breakpoints disabled during startup. */
11074 if (b->enable_state == bp_startup_disabled)
11077 if (b->addr_string == NULL)
11079 /* Anything without a string can't be re-set. */
11080 delete_breakpoint (b);
11084 re_set_breakpoint (b);
11087 case bp_watchpoint:
11088 case bp_hardware_watchpoint:
11089 case bp_read_watchpoint:
11090 case bp_access_watchpoint:
11091 /* Watchpoint can be either on expression using entirely global
11092 variables, or it can be on local variables.
11094 Watchpoints of the first kind are never auto-deleted, and
11095 even persist across program restarts. Since they can use
11096 variables from shared libraries, we need to reparse
11097 expression as libraries are loaded and unloaded.
11099 Watchpoints on local variables can also change meaning as
11100 result of solib event. For example, if a watchpoint uses
11101 both a local and a global variables in expression, it's a
11102 local watchpoint, but unloading of a shared library will make
11103 the expression invalid. This is not a very common use case,
11104 but we still re-evaluate expression, to avoid surprises to
11107 Note that for local watchpoints, we re-evaluate it only if
11108 watchpoints frame id is still valid. If it's not, it means
11109 the watchpoint is out of scope and will be deleted soon. In
11110 fact, I'm not sure we'll ever be called in this case.
11112 If a local watchpoint's frame id is still valid, then
11113 b->exp_valid_block is likewise valid, and we can safely use it.
11115 Don't do anything about disabled watchpoints, since they will
11116 be reevaluated again when enabled. */
11117 update_watchpoint (b, 1 /* reparse */);
11119 /* We needn't really do anything to reset these, since the mask
11120 that requests them is unaffected by e.g., new libraries being
11122 case bp_catchpoint:
11126 printf_filtered (_("Deleting unknown breakpoint type %d\n"), b->type);
11128 /* Delete overlay event and longjmp master breakpoints; they will be
11129 reset later by breakpoint_re_set. */
11130 case bp_overlay_event:
11131 case bp_longjmp_master:
11132 case bp_std_terminate_master:
11133 case bp_exception_master:
11134 delete_breakpoint (b);
11137 /* This breakpoint is special, it's set up when the inferior
11138 starts and we really don't want to touch it. */
11139 case bp_shlib_event:
11141 /* Like bp_shlib_event, this breakpoint type is special.
11142 Once it is set up, we do not want to touch it. */
11143 case bp_thread_event:
11145 /* Keep temporary breakpoints, which can be encountered when we
11146 step over a dlopen call and SOLIB_ADD is resetting the
11147 breakpoints. Otherwise these should have been blown away via
11148 the cleanup chain or by breakpoint_init_inferior when we
11149 rerun the executable. */
11152 case bp_watchpoint_scope:
11153 case bp_call_dummy:
11154 case bp_std_terminate:
11155 case bp_step_resume:
11157 case bp_longjmp_resume:
11159 case bp_exception_resume:
11161 case bp_gnu_ifunc_resolver_return:
11168 /* Re-set all breakpoints after symbols have been re-loaded. */
11170 breakpoint_re_set (void)
11172 struct breakpoint *b, *b_tmp;
11173 enum language save_language;
11174 int save_input_radix;
11175 struct cleanup *old_chain;
11177 save_language = current_language->la_language;
11178 save_input_radix = input_radix;
11179 old_chain = save_current_program_space ();
11181 ALL_BREAKPOINTS_SAFE (b, b_tmp)
11183 /* Format possible error msg. */
11184 char *message = xstrprintf ("Error in re-setting breakpoint %d: ",
11186 struct cleanup *cleanups = make_cleanup (xfree, message);
11187 catch_errors (breakpoint_re_set_one, b, message, RETURN_MASK_ALL);
11188 do_cleanups (cleanups);
11190 set_language (save_language);
11191 input_radix = save_input_radix;
11193 jit_breakpoint_re_set ();
11195 do_cleanups (old_chain);
11197 create_overlay_event_breakpoint ();
11198 create_longjmp_master_breakpoint ();
11199 create_std_terminate_master_breakpoint ();
11200 create_exception_master_breakpoint ();
11203 /* Reset the thread number of this breakpoint:
11205 - If the breakpoint is for all threads, leave it as-is.
11206 - Else, reset it to the current thread for inferior_ptid. */
11208 breakpoint_re_set_thread (struct breakpoint *b)
11210 if (b->thread != -1)
11212 if (in_thread_list (inferior_ptid))
11213 b->thread = pid_to_thread_id (inferior_ptid);
11215 /* We're being called after following a fork. The new fork is
11216 selected as current, and unless this was a vfork will have a
11217 different program space from the original thread. Reset that
11219 b->loc->pspace = current_program_space;
11223 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
11224 If from_tty is nonzero, it prints a message to that effect,
11225 which ends with a period (no newline). */
11228 set_ignore_count (int bptnum, int count, int from_tty)
11230 struct breakpoint *b;
11235 ALL_BREAKPOINTS (b)
11236 if (b->number == bptnum)
11238 if (is_tracepoint (b))
11240 if (from_tty && count != 0)
11241 printf_filtered (_("Ignore count ignored for tracepoint %d."),
11246 b->ignore_count = count;
11250 printf_filtered (_("Will stop next time "
11251 "breakpoint %d is reached."),
11253 else if (count == 1)
11254 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
11257 printf_filtered (_("Will ignore next %d "
11258 "crossings of breakpoint %d."),
11261 breakpoints_changed ();
11262 observer_notify_breakpoint_modified (b);
11266 error (_("No breakpoint number %d."), bptnum);
11269 /* Command to set ignore-count of breakpoint N to COUNT. */
11272 ignore_command (char *args, int from_tty)
11278 error_no_arg (_("a breakpoint number"));
11280 num = get_number (&p);
11282 error (_("bad breakpoint number: '%s'"), args);
11284 error (_("Second argument (specified ignore-count) is missing."));
11286 set_ignore_count (num,
11287 longest_to_int (value_as_long (parse_and_eval (p))),
11290 printf_filtered ("\n");
11293 /* Call FUNCTION on each of the breakpoints
11294 whose numbers are given in ARGS. */
11297 map_breakpoint_numbers (char *args, void (*function) (struct breakpoint *,
11302 struct breakpoint *b, *tmp;
11304 struct get_number_or_range_state state;
11307 error_no_arg (_("one or more breakpoint numbers"));
11309 init_number_or_range (&state, args);
11311 while (!state.finished)
11313 char *p = state.string;
11317 num = get_number_or_range (&state);
11320 warning (_("bad breakpoint number at or near '%s'"), p);
11324 ALL_BREAKPOINTS_SAFE (b, tmp)
11325 if (b->number == num)
11327 struct breakpoint *related_breakpoint;
11330 related_breakpoint = b;
11333 struct breakpoint *next_related_b;
11335 /* FUNCTION can be also delete_breakpoint. */
11336 next_related_b = related_breakpoint->related_breakpoint;
11337 function (related_breakpoint, data);
11339 /* For delete_breakpoint of the last entry of the ring we
11340 were traversing we would never get back to B. */
11341 if (next_related_b == related_breakpoint)
11343 related_breakpoint = next_related_b;
11345 while (related_breakpoint != b);
11349 printf_unfiltered (_("No breakpoint number %d.\n"), num);
11354 static struct bp_location *
11355 find_location_by_number (char *number)
11357 char *dot = strchr (number, '.');
11361 struct breakpoint *b;
11362 struct bp_location *loc;
11367 bp_num = get_number (&p1);
11369 error (_("Bad breakpoint number '%s'"), number);
11371 ALL_BREAKPOINTS (b)
11372 if (b->number == bp_num)
11377 if (!b || b->number != bp_num)
11378 error (_("Bad breakpoint number '%s'"), number);
11381 loc_num = get_number (&p1);
11383 error (_("Bad breakpoint location number '%s'"), number);
11387 for (;loc_num && loc; --loc_num, loc = loc->next)
11390 error (_("Bad breakpoint location number '%s'"), dot+1);
11396 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
11397 If from_tty is nonzero, it prints a message to that effect,
11398 which ends with a period (no newline). */
11401 disable_breakpoint (struct breakpoint *bpt)
11403 /* Never disable a watchpoint scope breakpoint; we want to
11404 hit them when we leave scope so we can delete both the
11405 watchpoint and its scope breakpoint at that time. */
11406 if (bpt->type == bp_watchpoint_scope)
11409 /* You can't disable permanent breakpoints. */
11410 if (bpt->enable_state == bp_permanent)
11413 bpt->enable_state = bp_disabled;
11415 update_global_location_list (0);
11417 observer_notify_breakpoint_modified (bpt);
11420 /* A callback for map_breakpoint_numbers that calls
11421 disable_breakpoint. */
11424 do_map_disable_breakpoint (struct breakpoint *b, void *ignore)
11426 disable_breakpoint (b);
11430 disable_command (char *args, int from_tty)
11434 struct breakpoint *bpt;
11436 ALL_BREAKPOINTS (bpt)
11437 if (user_breakpoint_p (bpt))
11438 disable_breakpoint (bpt);
11440 else if (strchr (args, '.'))
11442 struct bp_location *loc = find_location_by_number (args);
11445 update_global_location_list (0);
11448 map_breakpoint_numbers (args, do_map_disable_breakpoint, NULL);
11452 do_enable_breakpoint (struct breakpoint *bpt, enum bpdisp disposition)
11454 int target_resources_ok;
11456 if (bpt->type == bp_hardware_breakpoint)
11459 i = hw_breakpoint_used_count ();
11460 target_resources_ok =
11461 target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
11463 if (target_resources_ok == 0)
11464 error (_("No hardware breakpoint support in the target."));
11465 else if (target_resources_ok < 0)
11466 error (_("Hardware breakpoints used exceeds limit."));
11469 if (is_watchpoint (bpt))
11471 enum enable_state orig_enable_state;
11472 struct gdb_exception e;
11474 TRY_CATCH (e, RETURN_MASK_ALL)
11476 orig_enable_state = bpt->enable_state;
11477 bpt->enable_state = bp_enabled;
11478 update_watchpoint (bpt, 1 /* reparse */);
11482 bpt->enable_state = orig_enable_state;
11483 exception_fprintf (gdb_stderr, e, _("Cannot enable watchpoint %d: "),
11489 if (bpt->enable_state != bp_permanent)
11490 bpt->enable_state = bp_enabled;
11491 bpt->disposition = disposition;
11492 update_global_location_list (1);
11493 breakpoints_changed ();
11495 observer_notify_breakpoint_modified (bpt);
11500 enable_breakpoint (struct breakpoint *bpt)
11502 do_enable_breakpoint (bpt, bpt->disposition);
11505 /* A callback for map_breakpoint_numbers that calls
11506 enable_breakpoint. */
11509 do_map_enable_breakpoint (struct breakpoint *b, void *ignore)
11511 enable_breakpoint (b);
11514 /* The enable command enables the specified breakpoints (or all defined
11515 breakpoints) so they once again become (or continue to be) effective
11516 in stopping the inferior. */
11519 enable_command (char *args, int from_tty)
11523 struct breakpoint *bpt;
11525 ALL_BREAKPOINTS (bpt)
11526 if (user_breakpoint_p (bpt))
11527 enable_breakpoint (bpt);
11529 else if (strchr (args, '.'))
11531 struct bp_location *loc = find_location_by_number (args);
11534 update_global_location_list (1);
11537 map_breakpoint_numbers (args, do_map_enable_breakpoint, NULL);
11541 enable_once_breakpoint (struct breakpoint *bpt, void *ignore)
11543 do_enable_breakpoint (bpt, disp_disable);
11547 enable_once_command (char *args, int from_tty)
11549 map_breakpoint_numbers (args, enable_once_breakpoint, NULL);
11553 enable_delete_breakpoint (struct breakpoint *bpt, void *ignore)
11555 do_enable_breakpoint (bpt, disp_del);
11559 enable_delete_command (char *args, int from_tty)
11561 map_breakpoint_numbers (args, enable_delete_breakpoint, NULL);
11565 set_breakpoint_cmd (char *args, int from_tty)
11570 show_breakpoint_cmd (char *args, int from_tty)
11574 /* Invalidate last known value of any hardware watchpoint if
11575 the memory which that value represents has been written to by
11579 invalidate_bp_value_on_memory_change (CORE_ADDR addr, int len,
11580 const bfd_byte *data)
11582 struct breakpoint *bp;
11584 ALL_BREAKPOINTS (bp)
11585 if (bp->enable_state == bp_enabled
11586 && bp->type == bp_hardware_watchpoint
11587 && bp->val_valid && bp->val)
11589 struct bp_location *loc;
11591 for (loc = bp->loc; loc != NULL; loc = loc->next)
11592 if (loc->loc_type == bp_loc_hardware_watchpoint
11593 && loc->address + loc->length > addr
11594 && addr + len > loc->address)
11596 value_free (bp->val);
11603 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
11605 struct symtabs_and_lines
11606 decode_line_spec_1 (char *string, int funfirstline)
11608 struct symtabs_and_lines sals;
11611 error (_("Empty line specification."));
11612 if (default_breakpoint_valid)
11613 sals = decode_line_1 (&string, funfirstline,
11614 default_breakpoint_symtab,
11615 default_breakpoint_line,
11618 sals = decode_line_1 (&string, funfirstline,
11619 (struct symtab *) NULL, 0, NULL);
11621 error (_("Junk at end of line specification: %s"), string);
11625 /* Create and insert a raw software breakpoint at PC. Return an
11626 identifier, which should be used to remove the breakpoint later.
11627 In general, places which call this should be using something on the
11628 breakpoint chain instead; this function should be eliminated
11632 deprecated_insert_raw_breakpoint (struct gdbarch *gdbarch,
11633 struct address_space *aspace, CORE_ADDR pc)
11635 struct bp_target_info *bp_tgt;
11637 bp_tgt = XZALLOC (struct bp_target_info);
11639 bp_tgt->placed_address_space = aspace;
11640 bp_tgt->placed_address = pc;
11642 if (target_insert_breakpoint (gdbarch, bp_tgt) != 0)
11644 /* Could not insert the breakpoint. */
11652 /* Remove a breakpoint BP inserted by
11653 deprecated_insert_raw_breakpoint. */
11656 deprecated_remove_raw_breakpoint (struct gdbarch *gdbarch, void *bp)
11658 struct bp_target_info *bp_tgt = bp;
11661 ret = target_remove_breakpoint (gdbarch, bp_tgt);
11667 /* One (or perhaps two) breakpoints used for software single
11670 static void *single_step_breakpoints[2];
11671 static struct gdbarch *single_step_gdbarch[2];
11673 /* Create and insert a breakpoint for software single step. */
11676 insert_single_step_breakpoint (struct gdbarch *gdbarch,
11677 struct address_space *aspace,
11682 if (single_step_breakpoints[0] == NULL)
11684 bpt_p = &single_step_breakpoints[0];
11685 single_step_gdbarch[0] = gdbarch;
11689 gdb_assert (single_step_breakpoints[1] == NULL);
11690 bpt_p = &single_step_breakpoints[1];
11691 single_step_gdbarch[1] = gdbarch;
11694 /* NOTE drow/2006-04-11: A future improvement to this function would
11695 be to only create the breakpoints once, and actually put them on
11696 the breakpoint chain. That would let us use set_raw_breakpoint.
11697 We could adjust the addresses each time they were needed. Doing
11698 this requires corresponding changes elsewhere where single step
11699 breakpoints are handled, however. So, for now, we use this. */
11701 *bpt_p = deprecated_insert_raw_breakpoint (gdbarch, aspace, next_pc);
11702 if (*bpt_p == NULL)
11703 error (_("Could not insert single-step breakpoint at %s"),
11704 paddress (gdbarch, next_pc));
11707 /* Check if the breakpoints used for software single stepping
11708 were inserted or not. */
11711 single_step_breakpoints_inserted (void)
11713 return (single_step_breakpoints[0] != NULL
11714 || single_step_breakpoints[1] != NULL);
11717 /* Remove and delete any breakpoints used for software single step. */
11720 remove_single_step_breakpoints (void)
11722 gdb_assert (single_step_breakpoints[0] != NULL);
11724 /* See insert_single_step_breakpoint for more about this deprecated
11726 deprecated_remove_raw_breakpoint (single_step_gdbarch[0],
11727 single_step_breakpoints[0]);
11728 single_step_gdbarch[0] = NULL;
11729 single_step_breakpoints[0] = NULL;
11731 if (single_step_breakpoints[1] != NULL)
11733 deprecated_remove_raw_breakpoint (single_step_gdbarch[1],
11734 single_step_breakpoints[1]);
11735 single_step_gdbarch[1] = NULL;
11736 single_step_breakpoints[1] = NULL;
11740 /* Delete software single step breakpoints without removing them from
11741 the inferior. This is intended to be used if the inferior's address
11742 space where they were inserted is already gone, e.g. after exit or
11746 cancel_single_step_breakpoints (void)
11750 for (i = 0; i < 2; i++)
11751 if (single_step_breakpoints[i])
11753 xfree (single_step_breakpoints[i]);
11754 single_step_breakpoints[i] = NULL;
11755 single_step_gdbarch[i] = NULL;
11759 /* Detach software single-step breakpoints from INFERIOR_PTID without
11763 detach_single_step_breakpoints (void)
11767 for (i = 0; i < 2; i++)
11768 if (single_step_breakpoints[i])
11769 target_remove_breakpoint (single_step_gdbarch[i],
11770 single_step_breakpoints[i]);
11773 /* Check whether a software single-step breakpoint is inserted at
11777 single_step_breakpoint_inserted_here_p (struct address_space *aspace,
11782 for (i = 0; i < 2; i++)
11784 struct bp_target_info *bp_tgt = single_step_breakpoints[i];
11786 && breakpoint_address_match (bp_tgt->placed_address_space,
11787 bp_tgt->placed_address,
11795 /* Returns 0 if 'bp' is NOT a syscall catchpoint,
11796 non-zero otherwise. */
11798 is_syscall_catchpoint_enabled (struct breakpoint *bp)
11800 if (syscall_catchpoint_p (bp)
11801 && bp->enable_state != bp_disabled
11802 && bp->enable_state != bp_call_disabled)
11809 catch_syscall_enabled (void)
11811 struct inferior *inf = current_inferior ();
11813 return inf->total_syscalls_count != 0;
11817 catching_syscall_number (int syscall_number)
11819 struct breakpoint *bp;
11821 ALL_BREAKPOINTS (bp)
11822 if (is_syscall_catchpoint_enabled (bp))
11824 if (bp->syscalls_to_be_caught)
11828 VEC_iterate (int, bp->syscalls_to_be_caught, i, iter);
11830 if (syscall_number == iter)
11840 /* Complete syscall names. Used by "catch syscall". */
11842 catch_syscall_completer (struct cmd_list_element *cmd,
11843 char *text, char *word)
11845 const char **list = get_syscall_names ();
11847 = (list == NULL) ? NULL : complete_on_enum (list, text, word);
11853 /* Tracepoint-specific operations. */
11855 /* Set tracepoint count to NUM. */
11857 set_tracepoint_count (int num)
11859 tracepoint_count = num;
11860 set_internalvar_integer (lookup_internalvar ("tpnum"), num);
11864 trace_command (char *arg, int from_tty)
11866 if (create_breakpoint (get_current_arch (),
11868 NULL, 0, 1 /* parse arg */,
11870 bp_tracepoint /* type_wanted */,
11871 0 /* Ignore count */,
11872 pending_break_support,
11877 set_tracepoint_count (breakpoint_count);
11881 ftrace_command (char *arg, int from_tty)
11883 if (create_breakpoint (get_current_arch (),
11885 NULL, 0, 1 /* parse arg */,
11887 bp_fast_tracepoint /* type_wanted */,
11888 0 /* Ignore count */,
11889 pending_break_support,
11894 set_tracepoint_count (breakpoint_count);
11897 /* strace command implementation. Creates a static tracepoint. */
11900 strace_command (char *arg, int from_tty)
11902 if (create_breakpoint (get_current_arch (),
11904 NULL, 0, 1 /* parse arg */,
11906 bp_static_tracepoint /* type_wanted */,
11907 0 /* Ignore count */,
11908 pending_break_support,
11913 set_tracepoint_count (breakpoint_count);
11916 /* Set up a fake reader function that gets command lines from a linked
11917 list that was acquired during tracepoint uploading. */
11919 static struct uploaded_tp *this_utp;
11920 static int next_cmd;
11923 read_uploaded_action (void)
11927 VEC_iterate (char_ptr, this_utp->cmd_strings, next_cmd, rslt);
11934 /* Given information about a tracepoint as recorded on a target (which
11935 can be either a live system or a trace file), attempt to create an
11936 equivalent GDB tracepoint. This is not a reliable process, since
11937 the target does not necessarily have all the information used when
11938 the tracepoint was originally defined. */
11940 struct breakpoint *
11941 create_tracepoint_from_upload (struct uploaded_tp *utp)
11943 char *addr_str, small_buf[100];
11944 struct breakpoint *tp;
11946 if (utp->at_string)
11947 addr_str = utp->at_string;
11950 /* In the absence of a source location, fall back to raw
11951 address. Since there is no way to confirm that the address
11952 means the same thing as when the trace was started, warn the
11954 warning (_("Uploaded tracepoint %d has no "
11955 "source location, using raw address"),
11957 sprintf (small_buf, "*%s", hex_string (utp->addr));
11958 addr_str = small_buf;
11961 /* There's not much we can do with a sequence of bytecodes. */
11962 if (utp->cond && !utp->cond_string)
11963 warning (_("Uploaded tracepoint %d condition "
11964 "has no source form, ignoring it"),
11967 if (!create_breakpoint (get_current_arch (),
11969 utp->cond_string, -1, 0 /* parse cond/thread */,
11971 utp->type /* type_wanted */,
11972 0 /* Ignore count */,
11973 pending_break_support,
11976 utp->enabled /* enabled */,
11980 set_tracepoint_count (breakpoint_count);
11982 /* Get the tracepoint we just created. */
11983 tp = get_tracepoint (tracepoint_count);
11984 gdb_assert (tp != NULL);
11988 sprintf (small_buf, "%d %d", utp->pass, tp->number);
11990 trace_pass_command (small_buf, 0);
11993 /* If we have uploaded versions of the original commands, set up a
11994 special-purpose "reader" function and call the usual command line
11995 reader, then pass the result to the breakpoint command-setting
11997 if (!VEC_empty (char_ptr, utp->cmd_strings))
11999 struct command_line *cmd_list;
12004 cmd_list = read_command_lines_1 (read_uploaded_action, 1, NULL, NULL);
12006 breakpoint_set_commands (tp, cmd_list);
12008 else if (!VEC_empty (char_ptr, utp->actions)
12009 || !VEC_empty (char_ptr, utp->step_actions))
12010 warning (_("Uploaded tracepoint %d actions "
12011 "have no source form, ignoring them"),
12017 /* Print information on tracepoint number TPNUM_EXP, or all if
12021 tracepoints_info (char *args, int from_tty)
12025 num_printed = breakpoint_1 (args, 0, is_tracepoint);
12027 if (num_printed == 0)
12029 if (args == NULL || *args == '\0')
12030 ui_out_message (uiout, 0, "No tracepoints.\n");
12032 ui_out_message (uiout, 0, "No tracepoint matching '%s'.\n", args);
12035 default_collect_info ();
12038 /* The 'enable trace' command enables tracepoints.
12039 Not supported by all targets. */
12041 enable_trace_command (char *args, int from_tty)
12043 enable_command (args, from_tty);
12046 /* The 'disable trace' command disables tracepoints.
12047 Not supported by all targets. */
12049 disable_trace_command (char *args, int from_tty)
12051 disable_command (args, from_tty);
12054 /* Remove a tracepoint (or all if no argument). */
12056 delete_trace_command (char *arg, int from_tty)
12058 struct breakpoint *b, *b_tmp;
12064 int breaks_to_delete = 0;
12066 /* Delete all breakpoints if no argument.
12067 Do not delete internal or call-dummy breakpoints, these
12068 have to be deleted with an explicit breakpoint number
12070 ALL_TRACEPOINTS (b)
12071 if (is_tracepoint (b) && user_breakpoint_p (b))
12073 breaks_to_delete = 1;
12077 /* Ask user only if there are some breakpoints to delete. */
12079 || (breaks_to_delete && query (_("Delete all tracepoints? "))))
12081 ALL_BREAKPOINTS_SAFE (b, b_tmp)
12082 if (is_tracepoint (b) && user_breakpoint_p (b))
12083 delete_breakpoint (b);
12087 map_breakpoint_numbers (arg, do_delete_breakpoint, NULL);
12090 /* Helper function for trace_pass_command. */
12093 trace_pass_set_count (struct breakpoint *bp, int count, int from_tty)
12095 bp->pass_count = count;
12096 observer_notify_tracepoint_modified (bp->number);
12098 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
12099 bp->number, count);
12102 /* Set passcount for tracepoint.
12104 First command argument is passcount, second is tracepoint number.
12105 If tracepoint number omitted, apply to most recently defined.
12106 Also accepts special argument "all". */
12109 trace_pass_command (char *args, int from_tty)
12111 struct breakpoint *t1;
12112 unsigned int count;
12114 if (args == 0 || *args == 0)
12115 error (_("passcount command requires an "
12116 "argument (count + optional TP num)"));
12118 count = strtoul (args, &args, 10); /* Count comes first, then TP num. */
12120 while (*args && isspace ((int) *args))
12123 if (*args && strncasecmp (args, "all", 3) == 0)
12125 args += 3; /* Skip special argument "all". */
12127 error (_("Junk at end of arguments."));
12129 ALL_TRACEPOINTS (t1)
12131 trace_pass_set_count (t1, count, from_tty);
12134 else if (*args == '\0')
12136 t1 = get_tracepoint_by_number (&args, NULL, 1);
12138 trace_pass_set_count (t1, count, from_tty);
12142 struct get_number_or_range_state state;
12144 init_number_or_range (&state, args);
12145 while (!state.finished)
12147 t1 = get_tracepoint_by_number (&args, &state, 1);
12149 trace_pass_set_count (t1, count, from_tty);
12154 struct breakpoint *
12155 get_tracepoint (int num)
12157 struct breakpoint *t;
12159 ALL_TRACEPOINTS (t)
12160 if (t->number == num)
12166 /* Find the tracepoint with the given target-side number (which may be
12167 different from the tracepoint number after disconnecting and
12170 struct breakpoint *
12171 get_tracepoint_by_number_on_target (int num)
12173 struct breakpoint *t;
12175 ALL_TRACEPOINTS (t)
12176 if (t->number_on_target == num)
12182 /* Utility: parse a tracepoint number and look it up in the list.
12183 If STATE is not NULL, use, get_number_or_range_state and ignore ARG.
12184 If OPTIONAL_P is true, then if the argument is missing, the most
12185 recent tracepoint (tracepoint_count) is returned. */
12186 struct breakpoint *
12187 get_tracepoint_by_number (char **arg,
12188 struct get_number_or_range_state *state,
12191 extern int tracepoint_count;
12192 struct breakpoint *t;
12194 char *instring = arg == NULL ? NULL : *arg;
12198 gdb_assert (!state->finished);
12199 tpnum = get_number_or_range (state);
12201 else if (arg == NULL || *arg == NULL || ! **arg)
12204 tpnum = tracepoint_count;
12206 error_no_arg (_("tracepoint number"));
12209 tpnum = get_number (arg);
12213 if (instring && *instring)
12214 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
12217 printf_filtered (_("Tracepoint argument missing "
12218 "and no previous tracepoint\n"));
12222 ALL_TRACEPOINTS (t)
12223 if (t->number == tpnum)
12228 printf_unfiltered ("No tracepoint number %d.\n", tpnum);
12232 /* Save information on user settable breakpoints (watchpoints, etc) to
12233 a new script file named FILENAME. If FILTER is non-NULL, call it
12234 on each breakpoint and only include the ones for which it returns
12238 save_breakpoints (char *filename, int from_tty,
12239 int (*filter) (const struct breakpoint *))
12241 struct breakpoint *tp;
12244 struct cleanup *cleanup;
12245 struct ui_file *fp;
12246 int extra_trace_bits = 0;
12248 if (filename == 0 || *filename == 0)
12249 error (_("Argument required (file name in which to save)"));
12251 /* See if we have anything to save. */
12252 ALL_BREAKPOINTS (tp)
12254 /* Skip internal and momentary breakpoints. */
12255 if (!user_breakpoint_p (tp))
12258 /* If we have a filter, only save the breakpoints it accepts. */
12259 if (filter && !filter (tp))
12264 if (is_tracepoint (tp))
12266 extra_trace_bits = 1;
12268 /* We can stop searching. */
12275 warning (_("Nothing to save."));
12279 pathname = tilde_expand (filename);
12280 cleanup = make_cleanup (xfree, pathname);
12281 fp = gdb_fopen (pathname, "w");
12283 error (_("Unable to open file '%s' for saving (%s)"),
12284 filename, safe_strerror (errno));
12285 make_cleanup_ui_file_delete (fp);
12287 if (extra_trace_bits)
12288 save_trace_state_variables (fp);
12290 ALL_BREAKPOINTS (tp)
12292 /* Skip internal and momentary breakpoints. */
12293 if (!user_breakpoint_p (tp))
12296 /* If we have a filter, only save the breakpoints it accepts. */
12297 if (filter && !filter (tp))
12300 if (tp->ops != NULL && tp->ops->print_recreate != NULL)
12301 (tp->ops->print_recreate) (tp, fp);
12304 if (tp->type == bp_fast_tracepoint)
12305 fprintf_unfiltered (fp, "ftrace");
12306 if (tp->type == bp_static_tracepoint)
12307 fprintf_unfiltered (fp, "strace");
12308 else if (tp->type == bp_tracepoint)
12309 fprintf_unfiltered (fp, "trace");
12310 else if (tp->type == bp_breakpoint && tp->disposition == disp_del)
12311 fprintf_unfiltered (fp, "tbreak");
12312 else if (tp->type == bp_breakpoint)
12313 fprintf_unfiltered (fp, "break");
12314 else if (tp->type == bp_hardware_breakpoint
12315 && tp->disposition == disp_del)
12316 fprintf_unfiltered (fp, "thbreak");
12317 else if (tp->type == bp_hardware_breakpoint)
12318 fprintf_unfiltered (fp, "hbreak");
12319 else if (tp->type == bp_watchpoint)
12320 fprintf_unfiltered (fp, "watch");
12321 else if (tp->type == bp_hardware_watchpoint)
12322 fprintf_unfiltered (fp, "watch");
12323 else if (tp->type == bp_read_watchpoint)
12324 fprintf_unfiltered (fp, "rwatch");
12325 else if (tp->type == bp_access_watchpoint)
12326 fprintf_unfiltered (fp, "awatch");
12328 internal_error (__FILE__, __LINE__,
12329 _("unhandled breakpoint type %d"), (int) tp->type);
12331 if (tp->exp_string)
12332 fprintf_unfiltered (fp, " %s", tp->exp_string);
12333 else if (tp->addr_string)
12334 fprintf_unfiltered (fp, " %s", tp->addr_string);
12339 sprintf_vma (tmp, tp->loc->address);
12340 fprintf_unfiltered (fp, " *0x%s", tmp);
12344 if (tp->thread != -1)
12345 fprintf_unfiltered (fp, " thread %d", tp->thread);
12348 fprintf_unfiltered (fp, " task %d", tp->task);
12350 fprintf_unfiltered (fp, "\n");
12352 /* Note, we can't rely on tp->number for anything, as we can't
12353 assume the recreated breakpoint numbers will match. Use $bpnum
12356 if (tp->cond_string)
12357 fprintf_unfiltered (fp, " condition $bpnum %s\n", tp->cond_string);
12359 if (tp->ignore_count)
12360 fprintf_unfiltered (fp, " ignore $bpnum %d\n", tp->ignore_count);
12362 if (tp->pass_count)
12363 fprintf_unfiltered (fp, " passcount %d\n", tp->pass_count);
12367 volatile struct gdb_exception ex;
12369 fprintf_unfiltered (fp, " commands\n");
12371 ui_out_redirect (uiout, fp);
12372 TRY_CATCH (ex, RETURN_MASK_ALL)
12374 print_command_lines (uiout, tp->commands->commands, 2);
12376 ui_out_redirect (uiout, NULL);
12379 throw_exception (ex);
12381 fprintf_unfiltered (fp, " end\n");
12384 if (tp->enable_state == bp_disabled)
12385 fprintf_unfiltered (fp, "disable\n");
12387 /* If this is a multi-location breakpoint, check if the locations
12388 should be individually disabled. Watchpoint locations are
12389 special, and not user visible. */
12390 if (!is_watchpoint (tp) && tp->loc && tp->loc->next)
12392 struct bp_location *loc;
12395 for (loc = tp->loc; loc != NULL; loc = loc->next, n++)
12397 fprintf_unfiltered (fp, "disable $bpnum.%d\n", n);
12401 if (extra_trace_bits && *default_collect)
12402 fprintf_unfiltered (fp, "set default-collect %s\n", default_collect);
12404 do_cleanups (cleanup);
12406 printf_filtered (_("Saved to file '%s'.\n"), filename);
12409 /* The `save breakpoints' command. */
12412 save_breakpoints_command (char *args, int from_tty)
12414 save_breakpoints (args, from_tty, NULL);
12417 /* The `save tracepoints' command. */
12420 save_tracepoints_command (char *args, int from_tty)
12422 save_breakpoints (args, from_tty, is_tracepoint);
12425 /* Create a vector of all tracepoints. */
12427 VEC(breakpoint_p) *
12428 all_tracepoints (void)
12430 VEC(breakpoint_p) *tp_vec = 0;
12431 struct breakpoint *tp;
12433 ALL_TRACEPOINTS (tp)
12435 VEC_safe_push (breakpoint_p, tp_vec, tp);
12442 /* This help string is used for the break, hbreak, tbreak and thbreak
12443 commands. It is defined as a macro to prevent duplication.
12444 COMMAND should be a string constant containing the name of the
12446 #define BREAK_ARGS_HELP(command) \
12447 command" [LOCATION] [thread THREADNUM] [if CONDITION]\n\
12448 LOCATION may be a line number, function name, or \"*\" and an address.\n\
12449 If a line number is specified, break at start of code for that line.\n\
12450 If a function is specified, break at start of code for that function.\n\
12451 If an address is specified, break at that exact address.\n\
12452 With no LOCATION, uses current execution address of the selected\n\
12453 stack frame. This is useful for breaking on return to a stack frame.\n\
12455 THREADNUM is the number from \"info threads\".\n\
12456 CONDITION is a boolean expression.\n\
12458 Multiple breakpoints at one place are permitted, and useful if their\n\
12459 conditions are different.\n\
12461 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
12463 /* List of subcommands for "catch". */
12464 static struct cmd_list_element *catch_cmdlist;
12466 /* List of subcommands for "tcatch". */
12467 static struct cmd_list_element *tcatch_cmdlist;
12469 /* Like add_cmd, but add the command to both the "catch" and "tcatch"
12470 lists, and pass some additional user data to the command function. */
12472 add_catch_command (char *name, char *docstring,
12473 void (*sfunc) (char *args, int from_tty,
12474 struct cmd_list_element *command),
12475 char **(*completer) (struct cmd_list_element *cmd,
12476 char *text, char *word),
12477 void *user_data_catch,
12478 void *user_data_tcatch)
12480 struct cmd_list_element *command;
12482 command = add_cmd (name, class_breakpoint, NULL, docstring,
12484 set_cmd_sfunc (command, sfunc);
12485 set_cmd_context (command, user_data_catch);
12486 set_cmd_completer (command, completer);
12488 command = add_cmd (name, class_breakpoint, NULL, docstring,
12490 set_cmd_sfunc (command, sfunc);
12491 set_cmd_context (command, user_data_tcatch);
12492 set_cmd_completer (command, completer);
12496 clear_syscall_counts (struct inferior *inf)
12498 inf->total_syscalls_count = 0;
12499 inf->any_syscall_count = 0;
12500 VEC_free (int, inf->syscalls_counts);
12504 save_command (char *arg, int from_tty)
12506 printf_unfiltered (_("\"save\" must be followed by "
12507 "the name of a save subcommand.\n"));
12508 help_list (save_cmdlist, "save ", -1, gdb_stdout);
12511 struct breakpoint *
12512 iterate_over_breakpoints (int (*callback) (struct breakpoint *, void *),
12515 struct breakpoint *b, *b_tmp;
12517 ALL_BREAKPOINTS_SAFE (b, b_tmp)
12519 if ((*callback) (b, data))
12527 _initialize_breakpoint (void)
12529 struct cmd_list_element *c;
12531 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib);
12532 observer_attach_inferior_exit (clear_syscall_counts);
12533 observer_attach_memory_changed (invalidate_bp_value_on_memory_change);
12535 breakpoint_objfile_key = register_objfile_data ();
12537 breakpoint_chain = 0;
12538 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
12539 before a breakpoint is set. */
12540 breakpoint_count = 0;
12542 tracepoint_count = 0;
12544 add_com ("ignore", class_breakpoint, ignore_command, _("\
12545 Set ignore-count of breakpoint number N to COUNT.\n\
12546 Usage is `ignore N COUNT'."));
12548 add_com_alias ("bc", "ignore", class_breakpoint, 1);
12550 add_com ("commands", class_breakpoint, commands_command, _("\
12551 Set commands to be executed when a breakpoint is hit.\n\
12552 Give breakpoint number as argument after \"commands\".\n\
12553 With no argument, the targeted breakpoint is the last one set.\n\
12554 The commands themselves follow starting on the next line.\n\
12555 Type a line containing \"end\" to indicate the end of them.\n\
12556 Give \"silent\" as the first line to make the breakpoint silent;\n\
12557 then no output is printed when it is hit, except what the commands print."));
12559 add_com ("condition", class_breakpoint, condition_command, _("\
12560 Specify breakpoint number N to break only if COND is true.\n\
12561 Usage is `condition N COND', where N is an integer and COND is an\n\
12562 expression to be evaluated whenever breakpoint N is reached."));
12564 c = add_com ("tbreak", class_breakpoint, tbreak_command, _("\
12565 Set a temporary breakpoint.\n\
12566 Like \"break\" except the breakpoint is only temporary,\n\
12567 so it will be deleted when hit. Equivalent to \"break\" followed\n\
12568 by using \"enable delete\" on the breakpoint number.\n\
12570 BREAK_ARGS_HELP ("tbreak")));
12571 set_cmd_completer (c, location_completer);
12573 c = add_com ("hbreak", class_breakpoint, hbreak_command, _("\
12574 Set a hardware assisted breakpoint.\n\
12575 Like \"break\" except the breakpoint requires hardware support,\n\
12576 some target hardware may not have this support.\n\
12578 BREAK_ARGS_HELP ("hbreak")));
12579 set_cmd_completer (c, location_completer);
12581 c = add_com ("thbreak", class_breakpoint, thbreak_command, _("\
12582 Set a temporary hardware assisted breakpoint.\n\
12583 Like \"hbreak\" except the breakpoint is only temporary,\n\
12584 so it will be deleted when hit.\n\
12586 BREAK_ARGS_HELP ("thbreak")));
12587 set_cmd_completer (c, location_completer);
12589 add_prefix_cmd ("enable", class_breakpoint, enable_command, _("\
12590 Enable some breakpoints.\n\
12591 Give breakpoint numbers (separated by spaces) as arguments.\n\
12592 With no subcommand, breakpoints are enabled until you command otherwise.\n\
12593 This is used to cancel the effect of the \"disable\" command.\n\
12594 With a subcommand you can enable temporarily."),
12595 &enablelist, "enable ", 1, &cmdlist);
12597 add_com ("ab", class_breakpoint, enable_command, _("\
12598 Enable some breakpoints.\n\
12599 Give breakpoint numbers (separated by spaces) as arguments.\n\
12600 With no subcommand, breakpoints are enabled until you command otherwise.\n\
12601 This is used to cancel the effect of the \"disable\" command.\n\
12602 With a subcommand you can enable temporarily."));
12604 add_com_alias ("en", "enable", class_breakpoint, 1);
12606 add_prefix_cmd ("breakpoints", class_breakpoint, enable_command, _("\
12607 Enable some breakpoints.\n\
12608 Give breakpoint numbers (separated by spaces) as arguments.\n\
12609 This is used to cancel the effect of the \"disable\" command.\n\
12610 May be abbreviated to simply \"enable\".\n"),
12611 &enablebreaklist, "enable breakpoints ", 1, &enablelist);
12613 add_cmd ("once", no_class, enable_once_command, _("\
12614 Enable breakpoints for one hit. Give breakpoint numbers.\n\
12615 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
12618 add_cmd ("delete", no_class, enable_delete_command, _("\
12619 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
12620 If a breakpoint is hit while enabled in this fashion, it is deleted."),
12623 add_cmd ("delete", no_class, enable_delete_command, _("\
12624 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
12625 If a breakpoint is hit while enabled in this fashion, it is deleted."),
12628 add_cmd ("once", no_class, enable_once_command, _("\
12629 Enable breakpoints for one hit. Give breakpoint numbers.\n\
12630 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
12633 add_prefix_cmd ("disable", class_breakpoint, disable_command, _("\
12634 Disable some breakpoints.\n\
12635 Arguments are breakpoint numbers with spaces in between.\n\
12636 To disable all breakpoints, give no argument.\n\
12637 A disabled breakpoint is not forgotten, but has no effect until reenabled."),
12638 &disablelist, "disable ", 1, &cmdlist);
12639 add_com_alias ("dis", "disable", class_breakpoint, 1);
12640 add_com_alias ("disa", "disable", class_breakpoint, 1);
12642 add_com ("sb", class_breakpoint, disable_command, _("\
12643 Disable some breakpoints.\n\
12644 Arguments are breakpoint numbers with spaces in between.\n\
12645 To disable all breakpoints, give no argument.\n\
12646 A disabled breakpoint is not forgotten, but has no effect until reenabled."));
12648 add_cmd ("breakpoints", class_alias, disable_command, _("\
12649 Disable some breakpoints.\n\
12650 Arguments are breakpoint numbers with spaces in between.\n\
12651 To disable all breakpoints, give no argument.\n\
12652 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
12653 This command may be abbreviated \"disable\"."),
12656 add_prefix_cmd ("delete", class_breakpoint, delete_command, _("\
12657 Delete some breakpoints or auto-display expressions.\n\
12658 Arguments are breakpoint numbers with spaces in between.\n\
12659 To delete all breakpoints, give no argument.\n\
12661 Also a prefix command for deletion of other GDB objects.\n\
12662 The \"unset\" command is also an alias for \"delete\"."),
12663 &deletelist, "delete ", 1, &cmdlist);
12664 add_com_alias ("d", "delete", class_breakpoint, 1);
12665 add_com_alias ("del", "delete", class_breakpoint, 1);
12667 add_com ("db", class_breakpoint, delete_command, _("\
12668 Delete some breakpoints.\n\
12669 Arguments are breakpoint numbers with spaces in between.\n\
12670 To delete all breakpoints, give no argument.\n"));
12672 add_cmd ("breakpoints", class_alias, delete_command, _("\
12673 Delete some breakpoints or auto-display expressions.\n\
12674 Arguments are breakpoint numbers with spaces in between.\n\
12675 To delete all breakpoints, give no argument.\n\
12676 This command may be abbreviated \"delete\"."),
12679 add_com ("clear", class_breakpoint, clear_command, _("\
12680 Clear breakpoint at specified line or function.\n\
12681 Argument may be line number, function name, or \"*\" and an address.\n\
12682 If line number is specified, all breakpoints in that line are cleared.\n\
12683 If function is specified, breakpoints at beginning of function are cleared.\n\
12684 If an address is specified, breakpoints at that address are cleared.\n\
12686 With no argument, clears all breakpoints in the line that the selected frame\n\
12687 is executing in.\n\
12689 See also the \"delete\" command which clears breakpoints by number."));
12690 add_com_alias ("cl", "clear", class_breakpoint, 1);
12692 c = add_com ("break", class_breakpoint, break_command, _("\
12693 Set breakpoint at specified line or function.\n"
12694 BREAK_ARGS_HELP ("break")));
12695 set_cmd_completer (c, location_completer);
12697 add_com_alias ("b", "break", class_run, 1);
12698 add_com_alias ("br", "break", class_run, 1);
12699 add_com_alias ("bre", "break", class_run, 1);
12700 add_com_alias ("brea", "break", class_run, 1);
12703 add_com_alias ("ba", "break", class_breakpoint, 1);
12707 add_abbrev_prefix_cmd ("stop", class_breakpoint, stop_command, _("\
12708 Break in function/address or break at a line in the current file."),
12709 &stoplist, "stop ", 1, &cmdlist);
12710 add_cmd ("in", class_breakpoint, stopin_command,
12711 _("Break in function or address."), &stoplist);
12712 add_cmd ("at", class_breakpoint, stopat_command,
12713 _("Break at a line in the current file."), &stoplist);
12714 add_com ("status", class_info, breakpoints_info, _("\
12715 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
12716 The \"Type\" column indicates one of:\n\
12717 \tbreakpoint - normal breakpoint\n\
12718 \twatchpoint - watchpoint\n\
12719 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
12720 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
12721 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
12722 address and file/line number respectively.\n\
12724 Convenience variable \"$_\" and default examine address for \"x\"\n\
12725 are set to the address of the last breakpoint listed unless the command\n\
12726 is prefixed with \"server \".\n\n\
12727 Convenience variable \"$bpnum\" contains the number of the last\n\
12728 breakpoint set."));
12731 add_info ("breakpoints", breakpoints_info, _("\
12732 Status of specified breakpoints (all user-settable breakpoints if no argument).\n\
12733 The \"Type\" column indicates one of:\n\
12734 \tbreakpoint - normal breakpoint\n\
12735 \twatchpoint - watchpoint\n\
12736 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
12737 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
12738 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
12739 address and file/line number respectively.\n\
12741 Convenience variable \"$_\" and default examine address for \"x\"\n\
12742 are set to the address of the last breakpoint listed unless the command\n\
12743 is prefixed with \"server \".\n\n\
12744 Convenience variable \"$bpnum\" contains the number of the last\n\
12745 breakpoint set."));
12747 add_info_alias ("b", "breakpoints", 1);
12750 add_com ("lb", class_breakpoint, breakpoints_info, _("\
12751 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
12752 The \"Type\" column indicates one of:\n\
12753 \tbreakpoint - normal breakpoint\n\
12754 \twatchpoint - watchpoint\n\
12755 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
12756 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
12757 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
12758 address and file/line number respectively.\n\
12760 Convenience variable \"$_\" and default examine address for \"x\"\n\
12761 are set to the address of the last breakpoint listed unless the command\n\
12762 is prefixed with \"server \".\n\n\
12763 Convenience variable \"$bpnum\" contains the number of the last\n\
12764 breakpoint set."));
12766 add_cmd ("breakpoints", class_maintenance, maintenance_info_breakpoints, _("\
12767 Status of all breakpoints, or breakpoint number NUMBER.\n\
12768 The \"Type\" column indicates one of:\n\
12769 \tbreakpoint - normal breakpoint\n\
12770 \twatchpoint - watchpoint\n\
12771 \tlongjmp - internal breakpoint used to step through longjmp()\n\
12772 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
12773 \tuntil - internal breakpoint used by the \"until\" command\n\
12774 \tfinish - internal breakpoint used by the \"finish\" command\n\
12775 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
12776 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
12777 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
12778 address and file/line number respectively.\n\
12780 Convenience variable \"$_\" and default examine address for \"x\"\n\
12781 are set to the address of the last breakpoint listed unless the command\n\
12782 is prefixed with \"server \".\n\n\
12783 Convenience variable \"$bpnum\" contains the number of the last\n\
12785 &maintenanceinfolist);
12787 add_prefix_cmd ("catch", class_breakpoint, catch_command, _("\
12788 Set catchpoints to catch events."),
12789 &catch_cmdlist, "catch ",
12790 0/*allow-unknown*/, &cmdlist);
12792 add_prefix_cmd ("tcatch", class_breakpoint, tcatch_command, _("\
12793 Set temporary catchpoints to catch events."),
12794 &tcatch_cmdlist, "tcatch ",
12795 0/*allow-unknown*/, &cmdlist);
12797 /* Add catch and tcatch sub-commands. */
12798 add_catch_command ("catch", _("\
12799 Catch an exception, when caught.\n\
12800 With an argument, catch only exceptions with the given name."),
12801 catch_catch_command,
12805 add_catch_command ("throw", _("\
12806 Catch an exception, when thrown.\n\
12807 With an argument, catch only exceptions with the given name."),
12808 catch_throw_command,
12812 add_catch_command ("fork", _("Catch calls to fork."),
12813 catch_fork_command_1,
12815 (void *) (uintptr_t) catch_fork_permanent,
12816 (void *) (uintptr_t) catch_fork_temporary);
12817 add_catch_command ("vfork", _("Catch calls to vfork."),
12818 catch_fork_command_1,
12820 (void *) (uintptr_t) catch_vfork_permanent,
12821 (void *) (uintptr_t) catch_vfork_temporary);
12822 add_catch_command ("exec", _("Catch calls to exec."),
12823 catch_exec_command_1,
12827 add_catch_command ("syscall", _("\
12828 Catch system calls by their names and/or numbers.\n\
12829 Arguments say which system calls to catch. If no arguments\n\
12830 are given, every system call will be caught.\n\
12831 Arguments, if given, should be one or more system call names\n\
12832 (if your system supports that), or system call numbers."),
12833 catch_syscall_command_1,
12834 catch_syscall_completer,
12837 add_catch_command ("exception", _("\
12838 Catch Ada exceptions, when raised.\n\
12839 With an argument, catch only exceptions with the given name."),
12840 catch_ada_exception_command,
12844 add_catch_command ("assert", _("\
12845 Catch failed Ada assertions, when raised.\n\
12846 With an argument, catch only exceptions with the given name."),
12847 catch_assert_command,
12852 c = add_com ("watch", class_breakpoint, watch_command, _("\
12853 Set a watchpoint for an expression.\n\
12854 Usage: watch [-l|-location] EXPRESSION\n\
12855 A watchpoint stops execution of your program whenever the value of\n\
12856 an expression changes.\n\
12857 If -l or -location is given, this evaluates EXPRESSION and watches\n\
12858 the memory to which it refers."));
12859 set_cmd_completer (c, expression_completer);
12861 c = add_com ("rwatch", class_breakpoint, rwatch_command, _("\
12862 Set a read watchpoint for an expression.\n\
12863 Usage: rwatch [-l|-location] EXPRESSION\n\
12864 A watchpoint stops execution of your program whenever the value of\n\
12865 an expression is read.\n\
12866 If -l or -location is given, this evaluates EXPRESSION and watches\n\
12867 the memory to which it refers."));
12868 set_cmd_completer (c, expression_completer);
12870 c = add_com ("awatch", class_breakpoint, awatch_command, _("\
12871 Set a watchpoint for an expression.\n\
12872 Usage: awatch [-l|-location] EXPRESSION\n\
12873 A watchpoint stops execution of your program whenever the value of\n\
12874 an expression is either read or written.\n\
12875 If -l or -location is given, this evaluates EXPRESSION and watches\n\
12876 the memory to which it refers."));
12877 set_cmd_completer (c, expression_completer);
12879 add_info ("watchpoints", watchpoints_info, _("\
12880 Status of specified watchpoints (all watchpoints if no argument)."));
12882 /* XXX: cagney/2005-02-23: This should be a boolean, and should
12883 respond to changes - contrary to the description. */
12884 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support,
12885 &can_use_hw_watchpoints, _("\
12886 Set debugger's willingness to use watchpoint hardware."), _("\
12887 Show debugger's willingness to use watchpoint hardware."), _("\
12888 If zero, gdb will not use hardware for new watchpoints, even if\n\
12889 such is available. (However, any hardware watchpoints that were\n\
12890 created before setting this to nonzero, will continue to use watchpoint\n\
12893 show_can_use_hw_watchpoints,
12894 &setlist, &showlist);
12896 can_use_hw_watchpoints = 1;
12898 /* Tracepoint manipulation commands. */
12900 c = add_com ("trace", class_breakpoint, trace_command, _("\
12901 Set a tracepoint at specified line or function.\n\
12903 BREAK_ARGS_HELP ("trace") "\n\
12904 Do \"help tracepoints\" for info on other tracepoint commands."));
12905 set_cmd_completer (c, location_completer);
12907 add_com_alias ("tp", "trace", class_alias, 0);
12908 add_com_alias ("tr", "trace", class_alias, 1);
12909 add_com_alias ("tra", "trace", class_alias, 1);
12910 add_com_alias ("trac", "trace", class_alias, 1);
12912 c = add_com ("ftrace", class_breakpoint, ftrace_command, _("\
12913 Set a fast tracepoint at specified line or function.\n\
12915 BREAK_ARGS_HELP ("ftrace") "\n\
12916 Do \"help tracepoints\" for info on other tracepoint commands."));
12917 set_cmd_completer (c, location_completer);
12919 c = add_com ("strace", class_breakpoint, strace_command, _("\
12920 Set a static tracepoint at specified line, function or marker.\n\
12922 strace [LOCATION] [if CONDITION]\n\
12923 LOCATION may be a line number, function name, \"*\" and an address,\n\
12924 or -m MARKER_ID.\n\
12925 If a line number is specified, probe the marker at start of code\n\
12926 for that line. If a function is specified, probe the marker at start\n\
12927 of code for that function. If an address is specified, probe the marker\n\
12928 at that exact address. If a marker id is specified, probe the marker\n\
12929 with that name. With no LOCATION, uses current execution address of\n\
12930 the selected stack frame.\n\
12931 Static tracepoints accept an extra collect action -- ``collect $_sdata''.\n\
12932 This collects arbitrary user data passed in the probe point call to the\n\
12933 tracing library. You can inspect it when analyzing the trace buffer,\n\
12934 by printing the $_sdata variable like any other convenience variable.\n\
12936 CONDITION is a boolean expression.\n\
12938 Multiple tracepoints at one place are permitted, and useful if their\n\
12939 conditions are different.\n\
12941 Do \"help breakpoints\" for info on other commands dealing with breakpoints.\n\
12942 Do \"help tracepoints\" for info on other tracepoint commands."));
12943 set_cmd_completer (c, location_completer);
12945 add_info ("tracepoints", tracepoints_info, _("\
12946 Status of specified tracepoints (all tracepoints if no argument).\n\
12947 Convenience variable \"$tpnum\" contains the number of the\n\
12948 last tracepoint set."));
12950 add_info_alias ("tp", "tracepoints", 1);
12952 add_cmd ("tracepoints", class_trace, delete_trace_command, _("\
12953 Delete specified tracepoints.\n\
12954 Arguments are tracepoint numbers, separated by spaces.\n\
12955 No argument means delete all tracepoints."),
12958 c = add_cmd ("tracepoints", class_trace, disable_trace_command, _("\
12959 Disable specified tracepoints.\n\
12960 Arguments are tracepoint numbers, separated by spaces.\n\
12961 No argument means disable all tracepoints."),
12963 deprecate_cmd (c, "disable");
12965 c = add_cmd ("tracepoints", class_trace, enable_trace_command, _("\
12966 Enable specified tracepoints.\n\
12967 Arguments are tracepoint numbers, separated by spaces.\n\
12968 No argument means enable all tracepoints."),
12970 deprecate_cmd (c, "enable");
12972 add_com ("passcount", class_trace, trace_pass_command, _("\
12973 Set the passcount for a tracepoint.\n\
12974 The trace will end when the tracepoint has been passed 'count' times.\n\
12975 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
12976 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
12978 add_prefix_cmd ("save", class_breakpoint, save_command,
12979 _("Save breakpoint definitions as a script."),
12980 &save_cmdlist, "save ",
12981 0/*allow-unknown*/, &cmdlist);
12983 c = add_cmd ("breakpoints", class_breakpoint, save_breakpoints_command, _("\
12984 Save current breakpoint definitions as a script.\n\
12985 This includes all types of breakpoints (breakpoints, watchpoints,\n\
12986 catchpoints, tracepoints). Use the 'source' command in another debug\n\
12987 session to restore them."),
12989 set_cmd_completer (c, filename_completer);
12991 c = add_cmd ("tracepoints", class_trace, save_tracepoints_command, _("\
12992 Save current tracepoint definitions as a script.\n\
12993 Use the 'source' command in another debug session to restore them."),
12995 set_cmd_completer (c, filename_completer);
12997 c = add_com_alias ("save-tracepoints", "save tracepoints", class_trace, 0);
12998 deprecate_cmd (c, "save tracepoints");
13000 add_prefix_cmd ("breakpoint", class_maintenance, set_breakpoint_cmd, _("\
13001 Breakpoint specific settings\n\
13002 Configure various breakpoint-specific variables such as\n\
13003 pending breakpoint behavior"),
13004 &breakpoint_set_cmdlist, "set breakpoint ",
13005 0/*allow-unknown*/, &setlist);
13006 add_prefix_cmd ("breakpoint", class_maintenance, show_breakpoint_cmd, _("\
13007 Breakpoint specific settings\n\
13008 Configure various breakpoint-specific variables such as\n\
13009 pending breakpoint behavior"),
13010 &breakpoint_show_cmdlist, "show breakpoint ",
13011 0/*allow-unknown*/, &showlist);
13013 add_setshow_auto_boolean_cmd ("pending", no_class,
13014 &pending_break_support, _("\
13015 Set debugger's behavior regarding pending breakpoints."), _("\
13016 Show debugger's behavior regarding pending breakpoints."), _("\
13017 If on, an unrecognized breakpoint location will cause gdb to create a\n\
13018 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
13019 an error. If auto, an unrecognized breakpoint location results in a\n\
13020 user-query to see if a pending breakpoint should be created."),
13022 show_pending_break_support,
13023 &breakpoint_set_cmdlist,
13024 &breakpoint_show_cmdlist);
13026 pending_break_support = AUTO_BOOLEAN_AUTO;
13028 add_setshow_boolean_cmd ("auto-hw", no_class,
13029 &automatic_hardware_breakpoints, _("\
13030 Set automatic usage of hardware breakpoints."), _("\
13031 Show automatic usage of hardware breakpoints."), _("\
13032 If set, the debugger will automatically use hardware breakpoints for\n\
13033 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
13034 a warning will be emitted for such breakpoints."),
13036 show_automatic_hardware_breakpoints,
13037 &breakpoint_set_cmdlist,
13038 &breakpoint_show_cmdlist);
13040 add_setshow_enum_cmd ("always-inserted", class_support,
13041 always_inserted_enums, &always_inserted_mode, _("\
13042 Set mode for inserting breakpoints."), _("\
13043 Show mode for inserting breakpoints."), _("\
13044 When this mode is off, breakpoints are inserted in inferior when it is\n\
13045 resumed, and removed when execution stops. When this mode is on,\n\
13046 breakpoints are inserted immediately and removed only when the user\n\
13047 deletes the breakpoint. When this mode is auto (which is the default),\n\
13048 the behaviour depends on the non-stop setting (see help set non-stop).\n\
13049 In this case, if gdb is controlling the inferior in non-stop mode, gdb\n\
13050 behaves as if always-inserted mode is on; if gdb is controlling the\n\
13051 inferior in all-stop mode, gdb behaves as if always-inserted mode is off."),
13053 &show_always_inserted_mode,
13054 &breakpoint_set_cmdlist,
13055 &breakpoint_show_cmdlist);
13057 add_com ("break-range", class_breakpoint, break_range_command, _("\
13058 Set a breakpoint for an address range.\n\
13059 break-range START-LOCATION, END-LOCATION\n\
13060 where START-LOCATION and END-LOCATION can be one of the following:\n\
13061 LINENUM, for that line in the current file,\n\
13062 FILE:LINENUM, for that line in that file,\n\
13063 +OFFSET, for that number of lines after the current line\n\
13064 or the start of the range\n\
13065 FUNCTION, for the first line in that function,\n\
13066 FILE:FUNCTION, to distinguish among like-named static functions.\n\
13067 *ADDRESS, for the instruction at that address.\n\
13069 The breakpoint will stop execution of the inferior whenever it executes\n\
13070 an instruction at any address within the [START-LOCATION, END-LOCATION]\n\
13071 range (including START-LOCATION and END-LOCATION)."));
13073 automatic_hardware_breakpoints = 1;
13075 observer_attach_about_to_proceed (breakpoint_about_to_proceed);