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 *);
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
1410 enum bp_loc_type loc_type;
1411 struct bp_location *bl;
1413 reg_cnt = can_use_hardware_watchpoint (val_chain);
1417 int i, target_resources_ok, other_type_used;
1419 /* Use an exact watchpoint when there's only one memory region to be
1420 watched, and only one debug register is needed to watch it. */
1421 b->exact = target_exact_watchpoints && reg_cnt == 1;
1423 /* We need to determine how many resources are already
1424 used for all other hardware watchpoints plus this one
1425 to see if we still have enough resources to also fit
1426 this watchpoint in as well. To guarantee the
1427 hw_watchpoint_used_count call below counts this
1428 watchpoint, make sure that it is marked as a hardware
1430 if (b->type == bp_watchpoint)
1431 b->type = bp_hardware_watchpoint;
1433 i = hw_watchpoint_used_count (b->type, &other_type_used);
1434 target_resources_ok = target_can_use_hardware_watchpoint
1435 (b->type, i, other_type_used);
1436 if (target_resources_ok <= 0)
1438 if (target_resources_ok == 0
1439 && b->type != bp_hardware_watchpoint)
1440 error (_("Target does not support this type of "
1441 "hardware watchpoint."));
1442 else if (target_resources_ok < 0
1443 && b->type != bp_hardware_watchpoint)
1444 error (_("Target can only support one kind "
1445 "of HW watchpoint at a time."));
1447 b->type = bp_watchpoint;
1450 else if (b->type != bp_hardware_watchpoint)
1451 error (_("Expression cannot be implemented with "
1452 "read/access watchpoint."));
1454 b->type = bp_watchpoint;
1456 loc_type = (b->type == bp_watchpoint? bp_loc_other
1457 : bp_loc_hardware_watchpoint);
1458 for (bl = b->loc; bl; bl = bl->next)
1459 bl->loc_type = loc_type;
1462 for (v = val_chain; v; v = next)
1464 next = value_next (v);
1469 /* If a software watchpoint is not watching any memory, then the
1470 above left it without any location set up. But,
1471 bpstat_stop_status requires a location to be able to report
1472 stops, so make sure there's at least a dummy one. */
1473 if (b->type == bp_watchpoint && b->loc == NULL)
1475 b->loc = allocate_bp_location (b);
1476 b->loc->pspace = frame_pspace;
1477 b->loc->address = -1;
1478 b->loc->length = -1;
1479 b->loc->watchpoint_type = -1;
1482 else if (!within_current_scope)
1484 printf_filtered (_("\
1485 Watchpoint %d deleted because the program has left the block\n\
1486 in which its expression is valid.\n"),
1488 watchpoint_del_at_next_stop (b);
1491 /* Restore the selected frame. */
1493 select_frame (frame_find_by_id (saved_frame_id));
1497 /* Returns 1 iff breakpoint location should be
1498 inserted in the inferior. */
1500 should_be_inserted (struct bp_location *bl)
1502 if (bl->owner == NULL || !breakpoint_enabled (bl->owner))
1505 if (bl->owner->disposition == disp_del_at_next_stop)
1508 if (!bl->enabled || bl->shlib_disabled || bl->duplicate)
1511 /* This is set for example, when we're attached to the parent of a
1512 vfork, and have detached from the child. The child is running
1513 free, and we expect it to do an exec or exit, at which point the
1514 OS makes the parent schedulable again (and the target reports
1515 that the vfork is done). Until the child is done with the shared
1516 memory region, do not insert breakpoints in the parent, otherwise
1517 the child could still trip on the parent's breakpoints. Since
1518 the parent is blocked anyway, it won't miss any breakpoint. */
1519 if (bl->pspace->breakpoints_not_allowed)
1522 /* Tracepoints are inserted by the target at a time of its choosing,
1524 if (is_tracepoint (bl->owner))
1530 /* Insert a low-level "breakpoint" of some type. BL is the breakpoint
1531 location. Any error messages are printed to TMP_ERROR_STREAM; and
1532 DISABLED_BREAKS, and HW_BREAKPOINT_ERROR are used to report problems.
1534 NOTE drow/2003-09-09: This routine could be broken down to an
1535 object-style method for each breakpoint or catchpoint type. */
1537 insert_bp_location (struct bp_location *bl,
1538 struct ui_file *tmp_error_stream,
1539 int *disabled_breaks,
1540 int *hw_breakpoint_error)
1544 if (!should_be_inserted (bl) || bl->inserted)
1547 /* Initialize the target-specific information. */
1548 memset (&bl->target_info, 0, sizeof (bl->target_info));
1549 bl->target_info.placed_address = bl->address;
1550 bl->target_info.placed_address_space = bl->pspace->aspace;
1551 bl->target_info.length = bl->length;
1553 if (bl->loc_type == bp_loc_software_breakpoint
1554 || bl->loc_type == bp_loc_hardware_breakpoint)
1556 if (bl->owner->type != bp_hardware_breakpoint)
1558 /* If the explicitly specified breakpoint type
1559 is not hardware breakpoint, check the memory map to see
1560 if the breakpoint address is in read only memory or not.
1562 Two important cases are:
1563 - location type is not hardware breakpoint, memory
1564 is readonly. We change the type of the location to
1565 hardware breakpoint.
1566 - location type is hardware breakpoint, memory is
1567 read-write. This means we've previously made the
1568 location hardware one, but then the memory map changed,
1571 When breakpoints are removed, remove_breakpoints will use
1572 location types we've just set here, the only possible
1573 problem is that memory map has changed during running
1574 program, but it's not going to work anyway with current
1576 struct mem_region *mr
1577 = lookup_mem_region (bl->target_info.placed_address);
1581 if (automatic_hardware_breakpoints)
1583 enum bp_loc_type new_type;
1585 if (mr->attrib.mode != MEM_RW)
1586 new_type = bp_loc_hardware_breakpoint;
1588 new_type = bp_loc_software_breakpoint;
1590 if (new_type != bl->loc_type)
1592 static int said = 0;
1594 bl->loc_type = new_type;
1597 fprintf_filtered (gdb_stdout,
1598 _("Note: automatically using "
1599 "hardware breakpoints for "
1600 "read-only addresses.\n"));
1605 else if (bl->loc_type == bp_loc_software_breakpoint
1606 && mr->attrib.mode != MEM_RW)
1607 warning (_("cannot set software breakpoint "
1608 "at readonly address %s"),
1609 paddress (bl->gdbarch, bl->address));
1613 /* First check to see if we have to handle an overlay. */
1614 if (overlay_debugging == ovly_off
1615 || bl->section == NULL
1616 || !(section_is_overlay (bl->section)))
1618 /* No overlay handling: just set the breakpoint. */
1620 if (bl->loc_type == bp_loc_hardware_breakpoint)
1621 val = target_insert_hw_breakpoint (bl->gdbarch,
1624 val = target_insert_breakpoint (bl->gdbarch,
1629 /* This breakpoint is in an overlay section.
1630 Shall we set a breakpoint at the LMA? */
1631 if (!overlay_events_enabled)
1633 /* Yes -- overlay event support is not active,
1634 so we must try to set a breakpoint at the LMA.
1635 This will not work for a hardware breakpoint. */
1636 if (bl->loc_type == bp_loc_hardware_breakpoint)
1637 warning (_("hardware breakpoint %d not supported in overlay!"),
1641 CORE_ADDR addr = overlay_unmapped_address (bl->address,
1643 /* Set a software (trap) breakpoint at the LMA. */
1644 bl->overlay_target_info = bl->target_info;
1645 bl->overlay_target_info.placed_address = addr;
1646 val = target_insert_breakpoint (bl->gdbarch,
1647 &bl->overlay_target_info);
1649 fprintf_unfiltered (tmp_error_stream,
1650 "Overlay breakpoint %d "
1651 "failed: in ROM?\n",
1655 /* Shall we set a breakpoint at the VMA? */
1656 if (section_is_mapped (bl->section))
1658 /* Yes. This overlay section is mapped into memory. */
1659 if (bl->loc_type == bp_loc_hardware_breakpoint)
1660 val = target_insert_hw_breakpoint (bl->gdbarch,
1663 val = target_insert_breakpoint (bl->gdbarch,
1668 /* No. This breakpoint will not be inserted.
1669 No error, but do not mark the bp as 'inserted'. */
1676 /* Can't set the breakpoint. */
1677 if (solib_name_from_address (bl->pspace, bl->address))
1679 /* See also: disable_breakpoints_in_shlibs. */
1681 bl->shlib_disabled = 1;
1682 observer_notify_breakpoint_modified (bl->owner);
1683 if (!*disabled_breaks)
1685 fprintf_unfiltered (tmp_error_stream,
1686 "Cannot insert breakpoint %d.\n",
1688 fprintf_unfiltered (tmp_error_stream,
1689 "Temporarily disabling shared "
1690 "library breakpoints:\n");
1692 *disabled_breaks = 1;
1693 fprintf_unfiltered (tmp_error_stream,
1694 "breakpoint #%d\n", bl->owner->number);
1698 if (bl->loc_type == bp_loc_hardware_breakpoint)
1700 *hw_breakpoint_error = 1;
1701 fprintf_unfiltered (tmp_error_stream,
1702 "Cannot insert hardware "
1708 fprintf_unfiltered (tmp_error_stream,
1709 "Cannot insert breakpoint %d.\n",
1711 fprintf_filtered (tmp_error_stream,
1712 "Error accessing memory address ");
1713 fputs_filtered (paddress (bl->gdbarch, bl->address),
1715 fprintf_filtered (tmp_error_stream, ": %s.\n",
1716 safe_strerror (val));
1727 else if (bl->loc_type == bp_loc_hardware_watchpoint
1728 /* NOTE drow/2003-09-08: This state only exists for removing
1729 watchpoints. It's not clear that it's necessary... */
1730 && bl->owner->disposition != disp_del_at_next_stop)
1732 gdb_assert (bl->owner->ops != NULL
1733 && bl->owner->ops->insert_location != NULL);
1735 val = bl->owner->ops->insert_location (bl);
1737 /* If trying to set a read-watchpoint, and it turns out it's not
1738 supported, try emulating one with an access watchpoint. */
1739 if (val == 1 && bl->watchpoint_type == hw_read)
1741 struct bp_location *loc, **loc_temp;
1743 /* But don't try to insert it, if there's already another
1744 hw_access location that would be considered a duplicate
1746 ALL_BP_LOCATIONS (loc, loc_temp)
1748 && loc->watchpoint_type == hw_access
1749 && watchpoint_locations_match (bl, loc))
1753 bl->target_info = loc->target_info;
1754 bl->watchpoint_type = hw_access;
1761 bl->watchpoint_type = hw_access;
1762 val = bl->owner->ops->insert_location (bl);
1765 /* Back to the original value. */
1766 bl->watchpoint_type = hw_read;
1770 bl->inserted = (val == 0);
1773 else if (bl->owner->type == bp_catchpoint)
1775 gdb_assert (bl->owner->ops != NULL
1776 && bl->owner->ops->insert_location != NULL);
1778 val = bl->owner->ops->insert_location (bl);
1781 bl->owner->enable_state = bp_disabled;
1785 Error inserting catchpoint %d: Your system does not support this type\n\
1786 of catchpoint."), bl->owner->number);
1788 warning (_("Error inserting catchpoint %d."), bl->owner->number);
1791 bl->inserted = (val == 0);
1793 /* We've already printed an error message if there was a problem
1794 inserting this catchpoint, and we've disabled the catchpoint,
1795 so just return success. */
1802 /* This function is called when program space PSPACE is about to be
1803 deleted. It takes care of updating breakpoints to not reference
1807 breakpoint_program_space_exit (struct program_space *pspace)
1809 struct breakpoint *b, *b_temp;
1810 struct bp_location *loc, **loc_temp;
1812 /* Remove any breakpoint that was set through this program space. */
1813 ALL_BREAKPOINTS_SAFE (b, b_temp)
1815 if (b->pspace == pspace)
1816 delete_breakpoint (b);
1819 /* Breakpoints set through other program spaces could have locations
1820 bound to PSPACE as well. Remove those. */
1821 ALL_BP_LOCATIONS (loc, loc_temp)
1823 struct bp_location *tmp;
1825 if (loc->pspace == pspace)
1827 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
1828 if (loc->owner->loc == loc)
1829 loc->owner->loc = loc->next;
1831 for (tmp = loc->owner->loc; tmp->next != NULL; tmp = tmp->next)
1832 if (tmp->next == loc)
1834 tmp->next = loc->next;
1840 /* Now update the global location list to permanently delete the
1841 removed locations above. */
1842 update_global_location_list (0);
1845 /* Make sure all breakpoints are inserted in inferior.
1846 Throws exception on any error.
1847 A breakpoint that is already inserted won't be inserted
1848 again, so calling this function twice is safe. */
1850 insert_breakpoints (void)
1852 struct breakpoint *bpt;
1854 ALL_BREAKPOINTS (bpt)
1855 if (is_hardware_watchpoint (bpt))
1856 update_watchpoint (bpt, 0 /* don't reparse. */);
1858 update_global_location_list (1);
1860 /* update_global_location_list does not insert breakpoints when
1861 always_inserted_mode is not enabled. Explicitly insert them
1863 if (!breakpoints_always_inserted_mode ())
1864 insert_breakpoint_locations ();
1867 /* insert_breakpoints is used when starting or continuing the program.
1868 remove_breakpoints is used when the program stops.
1869 Both return zero if successful,
1870 or an `errno' value if could not write the inferior. */
1873 insert_breakpoint_locations (void)
1875 struct breakpoint *bpt;
1876 struct bp_location *bl, **blp_tmp;
1879 int disabled_breaks = 0;
1880 int hw_breakpoint_error = 0;
1882 struct ui_file *tmp_error_stream = mem_fileopen ();
1883 struct cleanup *cleanups = make_cleanup_ui_file_delete (tmp_error_stream);
1885 /* Explicitly mark the warning -- this will only be printed if
1886 there was an error. */
1887 fprintf_unfiltered (tmp_error_stream, "Warning:\n");
1889 save_current_space_and_thread ();
1891 ALL_BP_LOCATIONS (bl, blp_tmp)
1893 if (!should_be_inserted (bl) || bl->inserted)
1896 /* There is no point inserting thread-specific breakpoints if
1897 the thread no longer exists. ALL_BP_LOCATIONS bp_location
1898 has BL->OWNER always non-NULL. */
1899 if (bl->owner->thread != -1
1900 && !valid_thread_id (bl->owner->thread))
1903 switch_to_program_space_and_thread (bl->pspace);
1905 /* For targets that support global breakpoints, there's no need
1906 to select an inferior to insert breakpoint to. In fact, even
1907 if we aren't attached to any process yet, we should still
1908 insert breakpoints. */
1909 if (!gdbarch_has_global_breakpoints (target_gdbarch)
1910 && ptid_equal (inferior_ptid, null_ptid))
1913 val = insert_bp_location (bl, tmp_error_stream, &disabled_breaks,
1914 &hw_breakpoint_error);
1919 /* If we failed to insert all locations of a watchpoint, remove
1920 them, as half-inserted watchpoint is of limited use. */
1921 ALL_BREAKPOINTS (bpt)
1923 int some_failed = 0;
1924 struct bp_location *loc;
1926 if (!is_hardware_watchpoint (bpt))
1929 if (!breakpoint_enabled (bpt))
1932 if (bpt->disposition == disp_del_at_next_stop)
1935 for (loc = bpt->loc; loc; loc = loc->next)
1936 if (!loc->inserted && should_be_inserted (loc))
1943 for (loc = bpt->loc; loc; loc = loc->next)
1945 remove_breakpoint (loc, mark_uninserted);
1947 hw_breakpoint_error = 1;
1948 fprintf_unfiltered (tmp_error_stream,
1949 "Could not insert hardware watchpoint %d.\n",
1957 /* If a hardware breakpoint or watchpoint was inserted, add a
1958 message about possibly exhausted resources. */
1959 if (hw_breakpoint_error)
1961 fprintf_unfiltered (tmp_error_stream,
1962 "Could not insert hardware breakpoints:\n\
1963 You may have requested too many hardware breakpoints/watchpoints.\n");
1965 target_terminal_ours_for_output ();
1966 error_stream (tmp_error_stream);
1969 do_cleanups (cleanups);
1973 remove_breakpoints (void)
1975 struct bp_location *bl, **blp_tmp;
1978 ALL_BP_LOCATIONS (bl, blp_tmp)
1981 val |= remove_breakpoint (bl, mark_uninserted);
1986 /* Remove breakpoints of process PID. */
1989 remove_breakpoints_pid (int pid)
1991 struct bp_location *bl, **blp_tmp;
1993 struct inferior *inf = find_inferior_pid (pid);
1995 ALL_BP_LOCATIONS (bl, blp_tmp)
1997 if (bl->pspace != inf->pspace)
2002 val = remove_breakpoint (bl, mark_uninserted);
2011 remove_hw_watchpoints (void)
2013 struct bp_location *bl, **blp_tmp;
2016 ALL_BP_LOCATIONS (bl, blp_tmp)
2018 if (bl->inserted && bl->loc_type == bp_loc_hardware_watchpoint)
2019 val |= remove_breakpoint (bl, mark_uninserted);
2025 reattach_breakpoints (int pid)
2027 struct cleanup *old_chain;
2028 struct bp_location *bl, **blp_tmp;
2030 struct ui_file *tmp_error_stream;
2031 int dummy1 = 0, dummy2 = 0;
2032 struct inferior *inf;
2033 struct thread_info *tp;
2035 tp = any_live_thread_of_process (pid);
2039 inf = find_inferior_pid (pid);
2040 old_chain = save_inferior_ptid ();
2042 inferior_ptid = tp->ptid;
2044 tmp_error_stream = mem_fileopen ();
2045 make_cleanup_ui_file_delete (tmp_error_stream);
2047 ALL_BP_LOCATIONS (bl, blp_tmp)
2049 if (bl->pspace != inf->pspace)
2055 val = insert_bp_location (bl, tmp_error_stream, &dummy1, &dummy2);
2058 do_cleanups (old_chain);
2063 do_cleanups (old_chain);
2067 static int internal_breakpoint_number = -1;
2069 /* Set the breakpoint number of B, depending on the value of INTERNAL.
2070 If INTERNAL is non-zero, the breakpoint number will be populated
2071 from internal_breakpoint_number and that variable decremented.
2072 Otherwis the breakpoint number will be populated from
2073 breakpoint_count and that value incremented. Internal breakpoints
2074 do not set the internal var bpnum. */
2076 set_breakpoint_number (int internal, struct breakpoint *b)
2079 b->number = internal_breakpoint_number--;
2082 set_breakpoint_count (breakpoint_count + 1);
2083 b->number = breakpoint_count;
2087 static struct breakpoint *
2088 create_internal_breakpoint (struct gdbarch *gdbarch,
2089 CORE_ADDR address, enum bptype type)
2091 struct symtab_and_line sal;
2092 struct breakpoint *b;
2094 init_sal (&sal); /* Initialize to zeroes. */
2097 sal.section = find_pc_overlay (sal.pc);
2098 sal.pspace = current_program_space;
2100 b = set_raw_breakpoint (gdbarch, sal, type);
2101 b->number = internal_breakpoint_number--;
2102 b->disposition = disp_donttouch;
2107 static const char *const longjmp_names[] =
2109 "longjmp", "_longjmp", "siglongjmp", "_siglongjmp"
2111 #define NUM_LONGJMP_NAMES ARRAY_SIZE(longjmp_names)
2113 /* Per-objfile data private to breakpoint.c. */
2114 struct breakpoint_objfile_data
2116 /* Minimal symbol for "_ovly_debug_event" (if any). */
2117 struct minimal_symbol *overlay_msym;
2119 /* Minimal symbol(s) for "longjmp", "siglongjmp", etc. (if any). */
2120 struct minimal_symbol *longjmp_msym[NUM_LONGJMP_NAMES];
2122 /* Minimal symbol for "std::terminate()" (if any). */
2123 struct minimal_symbol *terminate_msym;
2125 /* Minimal symbol for "_Unwind_DebugHook" (if any). */
2126 struct minimal_symbol *exception_msym;
2129 static const struct objfile_data *breakpoint_objfile_key;
2131 /* Minimal symbol not found sentinel. */
2132 static struct minimal_symbol msym_not_found;
2134 /* Returns TRUE if MSYM point to the "not found" sentinel. */
2137 msym_not_found_p (const struct minimal_symbol *msym)
2139 return msym == &msym_not_found;
2142 /* Return per-objfile data needed by breakpoint.c.
2143 Allocate the data if necessary. */
2145 static struct breakpoint_objfile_data *
2146 get_breakpoint_objfile_data (struct objfile *objfile)
2148 struct breakpoint_objfile_data *bp_objfile_data;
2150 bp_objfile_data = objfile_data (objfile, breakpoint_objfile_key);
2151 if (bp_objfile_data == NULL)
2153 bp_objfile_data = obstack_alloc (&objfile->objfile_obstack,
2154 sizeof (*bp_objfile_data));
2156 memset (bp_objfile_data, 0, sizeof (*bp_objfile_data));
2157 set_objfile_data (objfile, breakpoint_objfile_key, bp_objfile_data);
2159 return bp_objfile_data;
2163 create_overlay_event_breakpoint (void)
2165 struct objfile *objfile;
2166 const char *const func_name = "_ovly_debug_event";
2168 ALL_OBJFILES (objfile)
2170 struct breakpoint *b;
2171 struct breakpoint_objfile_data *bp_objfile_data;
2174 bp_objfile_data = get_breakpoint_objfile_data (objfile);
2176 if (msym_not_found_p (bp_objfile_data->overlay_msym))
2179 if (bp_objfile_data->overlay_msym == NULL)
2181 struct minimal_symbol *m;
2183 m = lookup_minimal_symbol_text (func_name, objfile);
2186 /* Avoid future lookups in this objfile. */
2187 bp_objfile_data->overlay_msym = &msym_not_found;
2190 bp_objfile_data->overlay_msym = m;
2193 addr = SYMBOL_VALUE_ADDRESS (bp_objfile_data->overlay_msym);
2194 b = create_internal_breakpoint (get_objfile_arch (objfile), addr,
2196 b->addr_string = xstrdup (func_name);
2198 if (overlay_debugging == ovly_auto)
2200 b->enable_state = bp_enabled;
2201 overlay_events_enabled = 1;
2205 b->enable_state = bp_disabled;
2206 overlay_events_enabled = 0;
2209 update_global_location_list (1);
2213 create_longjmp_master_breakpoint (void)
2215 struct program_space *pspace;
2216 struct cleanup *old_chain;
2218 old_chain = save_current_program_space ();
2220 ALL_PSPACES (pspace)
2222 struct objfile *objfile;
2224 set_current_program_space (pspace);
2226 ALL_OBJFILES (objfile)
2229 struct gdbarch *gdbarch;
2230 struct breakpoint_objfile_data *bp_objfile_data;
2232 gdbarch = get_objfile_arch (objfile);
2233 if (!gdbarch_get_longjmp_target_p (gdbarch))
2236 bp_objfile_data = get_breakpoint_objfile_data (objfile);
2238 for (i = 0; i < NUM_LONGJMP_NAMES; i++)
2240 struct breakpoint *b;
2241 const char *func_name;
2244 if (msym_not_found_p (bp_objfile_data->longjmp_msym[i]))
2247 func_name = longjmp_names[i];
2248 if (bp_objfile_data->longjmp_msym[i] == NULL)
2250 struct minimal_symbol *m;
2252 m = lookup_minimal_symbol_text (func_name, objfile);
2255 /* Prevent future lookups in this objfile. */
2256 bp_objfile_data->longjmp_msym[i] = &msym_not_found;
2259 bp_objfile_data->longjmp_msym[i] = m;
2262 addr = SYMBOL_VALUE_ADDRESS (bp_objfile_data->longjmp_msym[i]);
2263 b = create_internal_breakpoint (gdbarch, addr, bp_longjmp_master);
2264 b->addr_string = xstrdup (func_name);
2265 b->enable_state = bp_disabled;
2269 update_global_location_list (1);
2271 do_cleanups (old_chain);
2274 /* Create a master std::terminate breakpoint. */
2276 create_std_terminate_master_breakpoint (void)
2278 struct program_space *pspace;
2279 struct cleanup *old_chain;
2280 const char *const func_name = "std::terminate()";
2282 old_chain = save_current_program_space ();
2284 ALL_PSPACES (pspace)
2286 struct objfile *objfile;
2289 set_current_program_space (pspace);
2291 ALL_OBJFILES (objfile)
2293 struct breakpoint *b;
2294 struct breakpoint_objfile_data *bp_objfile_data;
2296 bp_objfile_data = get_breakpoint_objfile_data (objfile);
2298 if (msym_not_found_p (bp_objfile_data->terminate_msym))
2301 if (bp_objfile_data->terminate_msym == NULL)
2303 struct minimal_symbol *m;
2305 m = lookup_minimal_symbol (func_name, NULL, objfile);
2306 if (m == NULL || (MSYMBOL_TYPE (m) != mst_text
2307 && MSYMBOL_TYPE (m) != mst_file_text))
2309 /* Prevent future lookups in this objfile. */
2310 bp_objfile_data->terminate_msym = &msym_not_found;
2313 bp_objfile_data->terminate_msym = m;
2316 addr = SYMBOL_VALUE_ADDRESS (bp_objfile_data->terminate_msym);
2317 b = create_internal_breakpoint (get_objfile_arch (objfile), addr,
2318 bp_std_terminate_master);
2319 b->addr_string = xstrdup (func_name);
2320 b->enable_state = bp_disabled;
2324 update_global_location_list (1);
2326 do_cleanups (old_chain);
2329 /* Install a master breakpoint on the unwinder's debug hook. */
2332 create_exception_master_breakpoint (void)
2334 struct objfile *objfile;
2335 const char *const func_name = "_Unwind_DebugHook";
2337 ALL_OBJFILES (objfile)
2339 struct breakpoint *b;
2340 struct gdbarch *gdbarch;
2341 struct breakpoint_objfile_data *bp_objfile_data;
2344 bp_objfile_data = get_breakpoint_objfile_data (objfile);
2346 if (msym_not_found_p (bp_objfile_data->exception_msym))
2349 gdbarch = get_objfile_arch (objfile);
2351 if (bp_objfile_data->exception_msym == NULL)
2353 struct minimal_symbol *debug_hook;
2355 debug_hook = lookup_minimal_symbol (func_name, NULL, objfile);
2356 if (debug_hook == NULL)
2358 bp_objfile_data->exception_msym = &msym_not_found;
2362 bp_objfile_data->exception_msym = debug_hook;
2365 addr = SYMBOL_VALUE_ADDRESS (bp_objfile_data->exception_msym);
2366 addr = gdbarch_convert_from_func_ptr_addr (gdbarch, addr,
2368 b = create_internal_breakpoint (gdbarch, addr, bp_exception_master);
2369 b->addr_string = xstrdup (func_name);
2370 b->enable_state = bp_disabled;
2373 update_global_location_list (1);
2377 update_breakpoints_after_exec (void)
2379 struct breakpoint *b, *b_tmp;
2380 struct bp_location *bploc, **bplocp_tmp;
2382 /* We're about to delete breakpoints from GDB's lists. If the
2383 INSERTED flag is true, GDB will try to lift the breakpoints by
2384 writing the breakpoints' "shadow contents" back into memory. The
2385 "shadow contents" are NOT valid after an exec, so GDB should not
2386 do that. Instead, the target is responsible from marking
2387 breakpoints out as soon as it detects an exec. We don't do that
2388 here instead, because there may be other attempts to delete
2389 breakpoints after detecting an exec and before reaching here. */
2390 ALL_BP_LOCATIONS (bploc, bplocp_tmp)
2391 if (bploc->pspace == current_program_space)
2392 gdb_assert (!bploc->inserted);
2394 ALL_BREAKPOINTS_SAFE (b, b_tmp)
2396 if (b->pspace != current_program_space)
2399 /* Solib breakpoints must be explicitly reset after an exec(). */
2400 if (b->type == bp_shlib_event)
2402 delete_breakpoint (b);
2406 /* JIT breakpoints must be explicitly reset after an exec(). */
2407 if (b->type == bp_jit_event)
2409 delete_breakpoint (b);
2413 /* Thread event breakpoints must be set anew after an exec(),
2414 as must overlay event and longjmp master breakpoints. */
2415 if (b->type == bp_thread_event || b->type == bp_overlay_event
2416 || b->type == bp_longjmp_master || b->type == bp_std_terminate_master
2417 || b->type == bp_exception_master)
2419 delete_breakpoint (b);
2423 /* Step-resume breakpoints are meaningless after an exec(). */
2424 if (b->type == bp_step_resume)
2426 delete_breakpoint (b);
2430 /* Longjmp and longjmp-resume breakpoints are also meaningless
2432 if (b->type == bp_longjmp || b->type == bp_longjmp_resume
2433 || b->type == bp_exception || b->type == bp_exception_resume)
2435 delete_breakpoint (b);
2439 if (b->type == bp_catchpoint)
2441 /* For now, none of the bp_catchpoint breakpoints need to
2442 do anything at this point. In the future, if some of
2443 the catchpoints need to something, we will need to add
2444 a new method, and call this method from here. */
2448 /* bp_finish is a special case. The only way we ought to be able
2449 to see one of these when an exec() has happened, is if the user
2450 caught a vfork, and then said "finish". Ordinarily a finish just
2451 carries them to the call-site of the current callee, by setting
2452 a temporary bp there and resuming. But in this case, the finish
2453 will carry them entirely through the vfork & exec.
2455 We don't want to allow a bp_finish to remain inserted now. But
2456 we can't safely delete it, 'cause finish_command has a handle to
2457 the bp on a bpstat, and will later want to delete it. There's a
2458 chance (and I've seen it happen) that if we delete the bp_finish
2459 here, that its storage will get reused by the time finish_command
2460 gets 'round to deleting the "use to be a bp_finish" breakpoint.
2461 We really must allow finish_command to delete a bp_finish.
2463 In the absense of a general solution for the "how do we know
2464 it's safe to delete something others may have handles to?"
2465 problem, what we'll do here is just uninsert the bp_finish, and
2466 let finish_command delete it.
2468 (We know the bp_finish is "doomed" in the sense that it's
2469 momentary, and will be deleted as soon as finish_command sees
2470 the inferior stopped. So it doesn't matter that the bp's
2471 address is probably bogus in the new a.out, unlike e.g., the
2472 solib breakpoints.) */
2474 if (b->type == bp_finish)
2479 /* Without a symbolic address, we have little hope of the
2480 pre-exec() address meaning the same thing in the post-exec()
2482 if (b->addr_string == NULL)
2484 delete_breakpoint (b);
2488 /* FIXME what about longjmp breakpoints? Re-create them here? */
2489 create_overlay_event_breakpoint ();
2490 create_longjmp_master_breakpoint ();
2491 create_std_terminate_master_breakpoint ();
2492 create_exception_master_breakpoint ();
2496 detach_breakpoints (int pid)
2498 struct bp_location *bl, **blp_tmp;
2500 struct cleanup *old_chain = save_inferior_ptid ();
2501 struct inferior *inf = current_inferior ();
2503 if (pid == PIDGET (inferior_ptid))
2504 error (_("Cannot detach breakpoints of inferior_ptid"));
2506 /* Set inferior_ptid; remove_breakpoint_1 uses this global. */
2507 inferior_ptid = pid_to_ptid (pid);
2508 ALL_BP_LOCATIONS (bl, blp_tmp)
2510 if (bl->pspace != inf->pspace)
2514 val |= remove_breakpoint_1 (bl, mark_inserted);
2517 /* Detach single-step breakpoints as well. */
2518 detach_single_step_breakpoints ();
2520 do_cleanups (old_chain);
2524 /* Remove the breakpoint location BL from the current address space.
2525 Note that this is used to detach breakpoints from a child fork.
2526 When we get here, the child isn't in the inferior list, and neither
2527 do we have objects to represent its address space --- we should
2528 *not* look at bl->pspace->aspace here. */
2531 remove_breakpoint_1 (struct bp_location *bl, insertion_state_t is)
2535 /* BL is never in moribund_locations by our callers. */
2536 gdb_assert (bl->owner != NULL);
2538 if (bl->owner->enable_state == bp_permanent)
2539 /* Permanent breakpoints cannot be inserted or removed. */
2542 /* The type of none suggests that owner is actually deleted.
2543 This should not ever happen. */
2544 gdb_assert (bl->owner->type != bp_none);
2546 if (bl->loc_type == bp_loc_software_breakpoint
2547 || bl->loc_type == bp_loc_hardware_breakpoint)
2549 /* "Normal" instruction breakpoint: either the standard
2550 trap-instruction bp (bp_breakpoint), or a
2551 bp_hardware_breakpoint. */
2553 /* First check to see if we have to handle an overlay. */
2554 if (overlay_debugging == ovly_off
2555 || bl->section == NULL
2556 || !(section_is_overlay (bl->section)))
2558 /* No overlay handling: just remove the breakpoint. */
2560 if (bl->loc_type == bp_loc_hardware_breakpoint)
2561 val = target_remove_hw_breakpoint (bl->gdbarch, &bl->target_info);
2563 val = target_remove_breakpoint (bl->gdbarch, &bl->target_info);
2567 /* This breakpoint is in an overlay section.
2568 Did we set a breakpoint at the LMA? */
2569 if (!overlay_events_enabled)
2571 /* Yes -- overlay event support is not active, so we
2572 should have set a breakpoint at the LMA. Remove it.
2574 /* Ignore any failures: if the LMA is in ROM, we will
2575 have already warned when we failed to insert it. */
2576 if (bl->loc_type == bp_loc_hardware_breakpoint)
2577 target_remove_hw_breakpoint (bl->gdbarch,
2578 &bl->overlay_target_info);
2580 target_remove_breakpoint (bl->gdbarch,
2581 &bl->overlay_target_info);
2583 /* Did we set a breakpoint at the VMA?
2584 If so, we will have marked the breakpoint 'inserted'. */
2587 /* Yes -- remove it. Previously we did not bother to
2588 remove the breakpoint if the section had been
2589 unmapped, but let's not rely on that being safe. We
2590 don't know what the overlay manager might do. */
2591 if (bl->loc_type == bp_loc_hardware_breakpoint)
2592 val = target_remove_hw_breakpoint (bl->gdbarch,
2595 /* However, we should remove *software* breakpoints only
2596 if the section is still mapped, or else we overwrite
2597 wrong code with the saved shadow contents. */
2598 else if (section_is_mapped (bl->section))
2599 val = target_remove_breakpoint (bl->gdbarch,
2606 /* No -- not inserted, so no need to remove. No error. */
2611 /* In some cases, we might not be able to remove a breakpoint
2612 in a shared library that has already been removed, but we
2613 have not yet processed the shlib unload event. */
2614 if (val && solib_name_from_address (bl->pspace, bl->address))
2619 bl->inserted = (is == mark_inserted);
2621 else if (bl->loc_type == bp_loc_hardware_watchpoint)
2623 gdb_assert (bl->owner->ops != NULL
2624 && bl->owner->ops->remove_location != NULL);
2626 bl->inserted = (is == mark_inserted);
2627 bl->owner->ops->remove_location (bl);
2629 /* Failure to remove any of the hardware watchpoints comes here. */
2630 if ((is == mark_uninserted) && (bl->inserted))
2631 warning (_("Could not remove hardware watchpoint %d."),
2634 else if (bl->owner->type == bp_catchpoint
2635 && breakpoint_enabled (bl->owner)
2638 gdb_assert (bl->owner->ops != NULL
2639 && bl->owner->ops->remove_location != NULL);
2641 val = bl->owner->ops->remove_location (bl);
2645 bl->inserted = (is == mark_inserted);
2652 remove_breakpoint (struct bp_location *bl, insertion_state_t is)
2655 struct cleanup *old_chain;
2657 /* BL is never in moribund_locations by our callers. */
2658 gdb_assert (bl->owner != NULL);
2660 if (bl->owner->enable_state == bp_permanent)
2661 /* Permanent breakpoints cannot be inserted or removed. */
2664 /* The type of none suggests that owner is actually deleted.
2665 This should not ever happen. */
2666 gdb_assert (bl->owner->type != bp_none);
2668 old_chain = save_current_space_and_thread ();
2670 switch_to_program_space_and_thread (bl->pspace);
2672 ret = remove_breakpoint_1 (bl, is);
2674 do_cleanups (old_chain);
2678 /* Clear the "inserted" flag in all breakpoints. */
2681 mark_breakpoints_out (void)
2683 struct bp_location *bl, **blp_tmp;
2685 ALL_BP_LOCATIONS (bl, blp_tmp)
2686 if (bl->pspace == current_program_space)
2690 /* Clear the "inserted" flag in all breakpoints and delete any
2691 breakpoints which should go away between runs of the program.
2693 Plus other such housekeeping that has to be done for breakpoints
2696 Note: this function gets called at the end of a run (by
2697 generic_mourn_inferior) and when a run begins (by
2698 init_wait_for_inferior). */
2703 breakpoint_init_inferior (enum inf_context context)
2705 struct breakpoint *b, *b_tmp;
2706 struct bp_location *bl, **blp_tmp;
2708 struct program_space *pspace = current_program_space;
2710 /* If breakpoint locations are shared across processes, then there's
2712 if (gdbarch_has_global_breakpoints (target_gdbarch))
2715 ALL_BP_LOCATIONS (bl, blp_tmp)
2717 /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
2718 if (bl->pspace == pspace
2719 && bl->owner->enable_state != bp_permanent)
2723 ALL_BREAKPOINTS_SAFE (b, b_tmp)
2725 if (b->loc && b->loc->pspace != pspace)
2732 /* If the call dummy breakpoint is at the entry point it will
2733 cause problems when the inferior is rerun, so we better get
2736 case bp_watchpoint_scope:
2738 /* Also get rid of scope breakpoints. */
2740 case bp_shlib_event:
2742 /* Also remove solib event breakpoints. Their addresses may
2743 have changed since the last time we ran the program.
2744 Actually we may now be debugging against different target;
2745 and so the solib backend that installed this breakpoint may
2746 not be used in by the target. E.g.,
2748 (gdb) file prog-linux
2749 (gdb) run # native linux target
2752 (gdb) file prog-win.exe
2753 (gdb) tar rem :9999 # remote Windows gdbserver.
2756 delete_breakpoint (b);
2760 case bp_hardware_watchpoint:
2761 case bp_read_watchpoint:
2762 case bp_access_watchpoint:
2764 /* Likewise for watchpoints on local expressions. */
2765 if (b->exp_valid_block != NULL)
2766 delete_breakpoint (b);
2767 else if (context == inf_starting)
2769 /* Reset val field to force reread of starting value in
2770 insert_breakpoints. */
2772 value_free (b->val);
2782 /* Get rid of the moribund locations. */
2783 for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, bl); ++ix)
2784 decref_bp_location (&bl);
2785 VEC_free (bp_location_p, moribund_locations);
2788 /* These functions concern about actual breakpoints inserted in the
2789 target --- to e.g. check if we need to do decr_pc adjustment or if
2790 we need to hop over the bkpt --- so we check for address space
2791 match, not program space. */
2793 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
2794 exists at PC. It returns ordinary_breakpoint_here if it's an
2795 ordinary breakpoint, or permanent_breakpoint_here if it's a
2796 permanent breakpoint.
2797 - When continuing from a location with an ordinary breakpoint, we
2798 actually single step once before calling insert_breakpoints.
2799 - When continuing from a localion with a permanent breakpoint, we
2800 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
2801 the target, to advance the PC past the breakpoint. */
2803 enum breakpoint_here
2804 breakpoint_here_p (struct address_space *aspace, CORE_ADDR pc)
2806 struct bp_location *bl, **blp_tmp;
2807 int any_breakpoint_here = 0;
2809 ALL_BP_LOCATIONS (bl, blp_tmp)
2811 if (bl->loc_type != bp_loc_software_breakpoint
2812 && bl->loc_type != bp_loc_hardware_breakpoint)
2815 /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
2816 if ((breakpoint_enabled (bl->owner)
2817 || bl->owner->enable_state == bp_permanent)
2818 && breakpoint_location_address_match (bl, aspace, pc))
2820 if (overlay_debugging
2821 && section_is_overlay (bl->section)
2822 && !section_is_mapped (bl->section))
2823 continue; /* unmapped overlay -- can't be a match */
2824 else if (bl->owner->enable_state == bp_permanent)
2825 return permanent_breakpoint_here;
2827 any_breakpoint_here = 1;
2831 return any_breakpoint_here ? ordinary_breakpoint_here : 0;
2834 /* Return true if there's a moribund breakpoint at PC. */
2837 moribund_breakpoint_here_p (struct address_space *aspace, CORE_ADDR pc)
2839 struct bp_location *loc;
2842 for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
2843 if (breakpoint_location_address_match (loc, aspace, pc))
2849 /* Returns non-zero if there's a breakpoint inserted at PC, which is
2850 inserted using regular breakpoint_chain / bp_location array
2851 mechanism. This does not check for single-step breakpoints, which
2852 are inserted and removed using direct target manipulation. */
2855 regular_breakpoint_inserted_here_p (struct address_space *aspace,
2858 struct bp_location *bl, **blp_tmp;
2860 ALL_BP_LOCATIONS (bl, blp_tmp)
2862 if (bl->loc_type != bp_loc_software_breakpoint
2863 && bl->loc_type != bp_loc_hardware_breakpoint)
2867 && breakpoint_location_address_match (bl, aspace, pc))
2869 if (overlay_debugging
2870 && section_is_overlay (bl->section)
2871 && !section_is_mapped (bl->section))
2872 continue; /* unmapped overlay -- can't be a match */
2880 /* Returns non-zero iff there's either regular breakpoint
2881 or a single step breakpoint inserted at PC. */
2884 breakpoint_inserted_here_p (struct address_space *aspace, CORE_ADDR pc)
2886 if (regular_breakpoint_inserted_here_p (aspace, pc))
2889 if (single_step_breakpoint_inserted_here_p (aspace, pc))
2895 /* This function returns non-zero iff there is a software breakpoint
2899 software_breakpoint_inserted_here_p (struct address_space *aspace,
2902 struct bp_location *bl, **blp_tmp;
2904 ALL_BP_LOCATIONS (bl, blp_tmp)
2906 if (bl->loc_type != bp_loc_software_breakpoint)
2910 && breakpoint_address_match (bl->pspace->aspace, bl->address,
2913 if (overlay_debugging
2914 && section_is_overlay (bl->section)
2915 && !section_is_mapped (bl->section))
2916 continue; /* unmapped overlay -- can't be a match */
2922 /* Also check for software single-step breakpoints. */
2923 if (single_step_breakpoint_inserted_here_p (aspace, pc))
2930 hardware_watchpoint_inserted_in_range (struct address_space *aspace,
2931 CORE_ADDR addr, ULONGEST len)
2933 struct breakpoint *bpt;
2935 ALL_BREAKPOINTS (bpt)
2937 struct bp_location *loc;
2939 if (bpt->type != bp_hardware_watchpoint
2940 && bpt->type != bp_access_watchpoint)
2943 if (!breakpoint_enabled (bpt))
2946 for (loc = bpt->loc; loc; loc = loc->next)
2947 if (loc->pspace->aspace == aspace && loc->inserted)
2951 /* Check for intersection. */
2952 l = max (loc->address, addr);
2953 h = min (loc->address + loc->length, addr + len);
2961 /* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
2962 PC is valid for process/thread PTID. */
2965 breakpoint_thread_match (struct address_space *aspace, CORE_ADDR pc,
2968 struct bp_location *bl, **blp_tmp;
2969 /* The thread and task IDs associated to PTID, computed lazily. */
2973 ALL_BP_LOCATIONS (bl, blp_tmp)
2975 if (bl->loc_type != bp_loc_software_breakpoint
2976 && bl->loc_type != bp_loc_hardware_breakpoint)
2979 /* ALL_BP_LOCATIONS bp_location has bl->OWNER always non-NULL. */
2980 if (!breakpoint_enabled (bl->owner)
2981 && bl->owner->enable_state != bp_permanent)
2984 if (!breakpoint_location_address_match (bl, aspace, pc))
2987 if (bl->owner->thread != -1)
2989 /* This is a thread-specific breakpoint. Check that ptid
2990 matches that thread. If thread hasn't been computed yet,
2991 it is now time to do so. */
2993 thread = pid_to_thread_id (ptid);
2994 if (bl->owner->thread != thread)
2998 if (bl->owner->task != 0)
3000 /* This is a task-specific breakpoint. Check that ptid
3001 matches that task. If task hasn't been computed yet,
3002 it is now time to do so. */
3004 task = ada_get_task_number (ptid);
3005 if (bl->owner->task != task)
3009 if (overlay_debugging
3010 && section_is_overlay (bl->section)
3011 && !section_is_mapped (bl->section))
3012 continue; /* unmapped overlay -- can't be a match */
3021 /* bpstat stuff. External routines' interfaces are documented
3025 ep_is_catchpoint (struct breakpoint *ep)
3027 return (ep->type == bp_catchpoint);
3030 /* Frees any storage that is part of a bpstat. Does not walk the
3034 bpstat_free (bpstat bs)
3036 if (bs->old_val != NULL)
3037 value_free (bs->old_val);
3038 decref_counted_command_line (&bs->commands);
3039 decref_bp_location (&bs->bp_location_at);
3043 /* Clear a bpstat so that it says we are not at any breakpoint.
3044 Also free any storage that is part of a bpstat. */
3047 bpstat_clear (bpstat *bsp)
3064 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
3065 is part of the bpstat is copied as well. */
3068 bpstat_copy (bpstat bs)
3072 bpstat retval = NULL;
3077 for (; bs != NULL; bs = bs->next)
3079 tmp = (bpstat) xmalloc (sizeof (*tmp));
3080 memcpy (tmp, bs, sizeof (*tmp));
3081 incref_counted_command_line (tmp->commands);
3082 incref_bp_location (tmp->bp_location_at);
3083 if (bs->old_val != NULL)
3085 tmp->old_val = value_copy (bs->old_val);
3086 release_value (tmp->old_val);
3090 /* This is the first thing in the chain. */
3100 /* Find the bpstat associated with this breakpoint. */
3103 bpstat_find_breakpoint (bpstat bsp, struct breakpoint *breakpoint)
3108 for (; bsp != NULL; bsp = bsp->next)
3110 if (bsp->breakpoint_at == breakpoint)
3116 /* Put in *NUM the breakpoint number of the first breakpoint we are
3117 stopped at. *BSP upon return is a bpstat which points to the
3118 remaining breakpoints stopped at (but which is not guaranteed to be
3119 good for anything but further calls to bpstat_num).
3121 Return 0 if passed a bpstat which does not indicate any breakpoints.
3122 Return -1 if stopped at a breakpoint that has been deleted since
3124 Return 1 otherwise. */
3127 bpstat_num (bpstat *bsp, int *num)
3129 struct breakpoint *b;
3132 return 0; /* No more breakpoint values */
3134 /* We assume we'll never have several bpstats that correspond to a
3135 single breakpoint -- otherwise, this function might return the
3136 same number more than once and this will look ugly. */
3137 b = (*bsp)->breakpoint_at;
3138 *bsp = (*bsp)->next;
3140 return -1; /* breakpoint that's been deleted since */
3142 *num = b->number; /* We have its number */
3146 /* Modify BS so that the actions will not be performed. */
3149 bpstat_clear_actions (bpstat bs)
3151 for (; bs != NULL; bs = bs->next)
3153 decref_counted_command_line (&bs->commands);
3154 bs->commands_left = NULL;
3155 if (bs->old_val != NULL)
3157 value_free (bs->old_val);
3163 /* Called when a command is about to proceed the inferior. */
3166 breakpoint_about_to_proceed (void)
3168 if (!ptid_equal (inferior_ptid, null_ptid))
3170 struct thread_info *tp = inferior_thread ();
3172 /* Allow inferior function calls in breakpoint commands to not
3173 interrupt the command list. When the call finishes
3174 successfully, the inferior will be standing at the same
3175 breakpoint as if nothing happened. */
3176 if (tp->control.in_infcall)
3180 breakpoint_proceeded = 1;
3183 /* Stub for cleaning up our state if we error-out of a breakpoint
3186 cleanup_executing_breakpoints (void *ignore)
3188 executing_breakpoint_commands = 0;
3191 /* Execute all the commands associated with all the breakpoints at
3192 this location. Any of these commands could cause the process to
3193 proceed beyond this point, etc. We look out for such changes by
3194 checking the global "breakpoint_proceeded" after each command.
3196 Returns true if a breakpoint command resumed the inferior. In that
3197 case, it is the caller's responsibility to recall it again with the
3198 bpstat of the current thread. */
3201 bpstat_do_actions_1 (bpstat *bsp)
3204 struct cleanup *old_chain;
3207 /* Avoid endless recursion if a `source' command is contained
3209 if (executing_breakpoint_commands)
3212 executing_breakpoint_commands = 1;
3213 old_chain = make_cleanup (cleanup_executing_breakpoints, 0);
3215 /* This pointer will iterate over the list of bpstat's. */
3218 breakpoint_proceeded = 0;
3219 for (; bs != NULL; bs = bs->next)
3221 struct counted_command_line *ccmd;
3222 struct command_line *cmd;
3223 struct cleanup *this_cmd_tree_chain;
3225 /* Take ownership of the BSP's command tree, if it has one.
3227 The command tree could legitimately contain commands like
3228 'step' and 'next', which call clear_proceed_status, which
3229 frees stop_bpstat's command tree. To make sure this doesn't
3230 free the tree we're executing out from under us, we need to
3231 take ownership of the tree ourselves. Since a given bpstat's
3232 commands are only executed once, we don't need to copy it; we
3233 can clear the pointer in the bpstat, and make sure we free
3234 the tree when we're done. */
3235 ccmd = bs->commands;
3236 bs->commands = NULL;
3238 = make_cleanup_decref_counted_command_line (&ccmd);
3239 cmd = bs->commands_left;
3240 bs->commands_left = NULL;
3244 execute_control_command (cmd);
3246 if (breakpoint_proceeded)
3252 /* We can free this command tree now. */
3253 do_cleanups (this_cmd_tree_chain);
3255 if (breakpoint_proceeded)
3257 if (target_can_async_p ())
3258 /* If we are in async mode, then the target might be still
3259 running, not stopped at any breakpoint, so nothing for
3260 us to do here -- just return to the event loop. */
3263 /* In sync mode, when execute_control_command returns
3264 we're already standing on the next breakpoint.
3265 Breakpoint commands for that stop were not run, since
3266 execute_command does not run breakpoint commands --
3267 only command_line_handler does, but that one is not
3268 involved in execution of breakpoint commands. So, we
3269 can now execute breakpoint commands. It should be
3270 noted that making execute_command do bpstat actions is
3271 not an option -- in this case we'll have recursive
3272 invocation of bpstat for each breakpoint with a
3273 command, and can easily blow up GDB stack. Instead, we
3274 return true, which will trigger the caller to recall us
3275 with the new stop_bpstat. */
3280 do_cleanups (old_chain);
3285 bpstat_do_actions (void)
3287 /* Do any commands attached to breakpoint we are stopped at. */
3288 while (!ptid_equal (inferior_ptid, null_ptid)
3289 && target_has_execution
3290 && !is_exited (inferior_ptid)
3291 && !is_executing (inferior_ptid))
3292 /* Since in sync mode, bpstat_do_actions may resume the inferior,
3293 and only return when it is stopped at the next breakpoint, we
3294 keep doing breakpoint actions until it returns false to
3295 indicate the inferior was not resumed. */
3296 if (!bpstat_do_actions_1 (&inferior_thread ()->control.stop_bpstat))
3300 /* Print out the (old or new) value associated with a watchpoint. */
3303 watchpoint_value_print (struct value *val, struct ui_file *stream)
3306 fprintf_unfiltered (stream, _("<unreadable>"));
3309 struct value_print_options opts;
3310 get_user_print_options (&opts);
3311 value_print (val, stream, &opts);
3315 /* This is the normal print function for a bpstat. In the future,
3316 much of this logic could (should?) be moved to bpstat_stop_status,
3317 by having it set different print_it values.
3319 Current scheme: When we stop, bpstat_print() is called. It loops
3320 through the bpstat list of things causing this stop, calling the
3321 print_bp_stop_message function on each one. The behavior of the
3322 print_bp_stop_message function depends on the print_it field of
3323 bpstat. If such field so indicates, call this function here.
3325 Return values from this routine (ultimately used by bpstat_print()
3326 and normal_stop() to decide what to do):
3327 PRINT_NOTHING: Means we already printed all we needed to print,
3328 don't print anything else.
3329 PRINT_SRC_ONLY: Means we printed something, and we do *not* desire
3330 that something to be followed by a location.
3331 PRINT_SCR_AND_LOC: Means we printed something, and we *do* desire
3332 that something to be followed by a location.
3333 PRINT_UNKNOWN: Means we printed nothing or we need to do some more
3336 static enum print_stop_action
3337 print_it_typical (bpstat bs)
3339 struct cleanup *old_chain;
3340 struct breakpoint *b;
3341 const struct bp_location *bl;
3342 struct ui_stream *stb;
3344 enum print_stop_action result;
3346 gdb_assert (bs->bp_location_at != NULL);
3348 bl = bs->bp_location_at;
3349 b = bs->breakpoint_at;
3351 stb = ui_out_stream_new (uiout);
3352 old_chain = make_cleanup_ui_out_stream_delete (stb);
3357 case bp_hardware_breakpoint:
3358 bp_temp = b->disposition == disp_del;
3359 if (bl->address != bl->requested_address)
3360 breakpoint_adjustment_warning (bl->requested_address,
3363 annotate_breakpoint (b->number);
3365 ui_out_text (uiout, "\nTemporary breakpoint ");
3367 ui_out_text (uiout, "\nBreakpoint ");
3368 if (ui_out_is_mi_like_p (uiout))
3370 ui_out_field_string (uiout, "reason",
3371 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
3372 ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
3374 ui_out_field_int (uiout, "bkptno", b->number);
3375 ui_out_text (uiout, ", ");
3376 result = PRINT_SRC_AND_LOC;
3379 case bp_shlib_event:
3380 /* Did we stop because the user set the stop_on_solib_events
3381 variable? (If so, we report this as a generic, "Stopped due
3382 to shlib event" message.) */
3383 printf_filtered (_("Stopped due to shared library event\n"));
3384 result = PRINT_NOTHING;
3387 case bp_thread_event:
3388 /* Not sure how we will get here.
3389 GDB should not stop for these breakpoints. */
3390 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
3391 result = PRINT_NOTHING;
3394 case bp_overlay_event:
3395 /* By analogy with the thread event, GDB should not stop for these. */
3396 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
3397 result = PRINT_NOTHING;
3400 case bp_longjmp_master:
3401 /* These should never be enabled. */
3402 printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
3403 result = PRINT_NOTHING;
3406 case bp_std_terminate_master:
3407 /* These should never be enabled. */
3408 printf_filtered (_("std::terminate Master Breakpoint: "
3409 "gdb should not stop!\n"));
3410 result = PRINT_NOTHING;
3413 case bp_exception_master:
3414 /* These should never be enabled. */
3415 printf_filtered (_("Exception Master Breakpoint: "
3416 "gdb should not stop!\n"));
3417 result = PRINT_NOTHING;
3421 case bp_hardware_watchpoint:
3422 annotate_watchpoint (b->number);
3423 if (ui_out_is_mi_like_p (uiout))
3426 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER));
3428 make_cleanup_ui_out_tuple_begin_end (uiout, "value");
3429 ui_out_text (uiout, "\nOld value = ");
3430 watchpoint_value_print (bs->old_val, stb->stream);
3431 ui_out_field_stream (uiout, "old", stb);
3432 ui_out_text (uiout, "\nNew value = ");
3433 watchpoint_value_print (b->val, stb->stream);
3434 ui_out_field_stream (uiout, "new", stb);
3435 ui_out_text (uiout, "\n");
3436 /* More than one watchpoint may have been triggered. */
3437 result = PRINT_UNKNOWN;
3440 case bp_read_watchpoint:
3441 if (ui_out_is_mi_like_p (uiout))
3444 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER));
3446 make_cleanup_ui_out_tuple_begin_end (uiout, "value");
3447 ui_out_text (uiout, "\nValue = ");
3448 watchpoint_value_print (b->val, stb->stream);
3449 ui_out_field_stream (uiout, "value", stb);
3450 ui_out_text (uiout, "\n");
3451 result = PRINT_UNKNOWN;
3454 case bp_access_watchpoint:
3455 if (bs->old_val != NULL)
3457 annotate_watchpoint (b->number);
3458 if (ui_out_is_mi_like_p (uiout))
3461 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
3463 make_cleanup_ui_out_tuple_begin_end (uiout, "value");
3464 ui_out_text (uiout, "\nOld value = ");
3465 watchpoint_value_print (bs->old_val, stb->stream);
3466 ui_out_field_stream (uiout, "old", stb);
3467 ui_out_text (uiout, "\nNew value = ");
3472 if (ui_out_is_mi_like_p (uiout))
3475 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
3476 make_cleanup_ui_out_tuple_begin_end (uiout, "value");
3477 ui_out_text (uiout, "\nValue = ");
3479 watchpoint_value_print (b->val, stb->stream);
3480 ui_out_field_stream (uiout, "new", stb);
3481 ui_out_text (uiout, "\n");
3482 result = PRINT_UNKNOWN;
3485 /* Fall through, we don't deal with these types of breakpoints
3489 if (ui_out_is_mi_like_p (uiout))
3492 async_reason_lookup (EXEC_ASYNC_FUNCTION_FINISHED));
3493 result = PRINT_UNKNOWN;
3497 if (ui_out_is_mi_like_p (uiout))
3500 async_reason_lookup (EXEC_ASYNC_LOCATION_REACHED));
3501 result = PRINT_UNKNOWN;
3506 case bp_longjmp_resume:
3508 case bp_exception_resume:
3509 case bp_step_resume:
3510 case bp_watchpoint_scope:
3512 case bp_std_terminate:
3514 case bp_fast_tracepoint:
3516 case bp_gnu_ifunc_resolver:
3517 case bp_gnu_ifunc_resolver_return:
3519 result = PRINT_UNKNOWN;
3523 do_cleanups (old_chain);
3527 /* Generic routine for printing messages indicating why we
3528 stopped. The behavior of this function depends on the value
3529 'print_it' in the bpstat structure. Under some circumstances we
3530 may decide not to print anything here and delegate the task to
3533 static enum print_stop_action
3534 print_bp_stop_message (bpstat bs)
3536 switch (bs->print_it)
3539 /* Nothing should be printed for this bpstat entry. */
3540 return PRINT_UNKNOWN;
3544 /* We still want to print the frame, but we already printed the
3545 relevant messages. */
3546 return PRINT_SRC_AND_LOC;
3549 case print_it_normal:
3551 struct breakpoint *b = bs->breakpoint_at;
3553 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
3554 which has since been deleted. */
3556 return PRINT_UNKNOWN;
3558 /* Normal case. Call the breakpoint's print_it method, or
3559 print_it_typical. */
3560 if (b->ops != NULL && b->ops->print_it != NULL)
3561 return b->ops->print_it (b);
3563 return print_it_typical (bs);
3568 internal_error (__FILE__, __LINE__,
3569 _("print_bp_stop_message: unrecognized enum value"));
3574 /* Print a message indicating what happened. This is called from
3575 normal_stop(). The input to this routine is the head of the bpstat
3576 list - a list of the eventpoints that caused this stop. This
3577 routine calls the generic print routine for printing a message
3578 about reasons for stopping. This will print (for example) the
3579 "Breakpoint n," part of the output. The return value of this
3582 PRINT_UNKNOWN: Means we printed nothing.
3583 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
3584 code to print the location. An example is
3585 "Breakpoint 1, " which should be followed by
3587 PRINT_SRC_ONLY: Means we printed something, but there is no need
3588 to also print the location part of the message.
3589 An example is the catch/throw messages, which
3590 don't require a location appended to the end.
3591 PRINT_NOTHING: We have done some printing and we don't need any
3592 further info to be printed. */
3594 enum print_stop_action
3595 bpstat_print (bpstat bs)
3599 /* Maybe another breakpoint in the chain caused us to stop.
3600 (Currently all watchpoints go on the bpstat whether hit or not.
3601 That probably could (should) be changed, provided care is taken
3602 with respect to bpstat_explains_signal). */
3603 for (; bs; bs = bs->next)
3605 val = print_bp_stop_message (bs);
3606 if (val == PRINT_SRC_ONLY
3607 || val == PRINT_SRC_AND_LOC
3608 || val == PRINT_NOTHING)
3612 /* We reached the end of the chain, or we got a null BS to start
3613 with and nothing was printed. */
3614 return PRINT_UNKNOWN;
3617 /* Evaluate the expression EXP and return 1 if value is zero. This is
3618 used inside a catch_errors to evaluate the breakpoint condition.
3619 The argument is a "struct expression *" that has been cast to a
3620 "char *" to make it pass through catch_errors. */
3623 breakpoint_cond_eval (void *exp)
3625 struct value *mark = value_mark ();
3626 int i = !value_true (evaluate_expression ((struct expression *) exp));
3628 value_free_to_mark (mark);
3632 /* Allocate a new bpstat. Link it to the FIFO list by BS_LINK_POINTER. */
3635 bpstat_alloc (struct bp_location *bl, bpstat **bs_link_pointer)
3639 bs = (bpstat) xmalloc (sizeof (*bs));
3641 **bs_link_pointer = bs;
3642 *bs_link_pointer = &bs->next;
3643 bs->breakpoint_at = bl->owner;
3644 bs->bp_location_at = bl;
3645 incref_bp_location (bl);
3646 /* If the condition is false, etc., don't do the commands. */
3647 bs->commands = NULL;
3648 bs->commands_left = NULL;
3650 bs->print_it = print_it_normal;
3654 /* The target has stopped with waitstatus WS. Check if any hardware
3655 watchpoints have triggered, according to the target. */
3658 watchpoints_triggered (struct target_waitstatus *ws)
3660 int stopped_by_watchpoint = target_stopped_by_watchpoint ();
3662 struct breakpoint *b;
3664 if (!stopped_by_watchpoint)
3666 /* We were not stopped by a watchpoint. Mark all watchpoints
3667 as not triggered. */
3669 if (is_hardware_watchpoint (b))
3670 b->watchpoint_triggered = watch_triggered_no;
3675 if (!target_stopped_data_address (¤t_target, &addr))
3677 /* We were stopped by a watchpoint, but we don't know where.
3678 Mark all watchpoints as unknown. */
3680 if (is_hardware_watchpoint (b))
3681 b->watchpoint_triggered = watch_triggered_unknown;
3683 return stopped_by_watchpoint;
3686 /* The target could report the data address. Mark watchpoints
3687 affected by this data address as triggered, and all others as not
3691 if (is_hardware_watchpoint (b))
3693 struct bp_location *loc;
3695 b->watchpoint_triggered = watch_triggered_no;
3696 for (loc = b->loc; loc; loc = loc->next)
3697 /* Exact match not required. Within range is
3699 if (target_watchpoint_addr_within_range (¤t_target,
3703 b->watchpoint_triggered = watch_triggered_yes;
3711 /* Possible return values for watchpoint_check (this can't be an enum
3712 because of check_errors). */
3713 /* The watchpoint has been deleted. */
3714 #define WP_DELETED 1
3715 /* The value has changed. */
3716 #define WP_VALUE_CHANGED 2
3717 /* The value has not changed. */
3718 #define WP_VALUE_NOT_CHANGED 3
3719 /* Ignore this watchpoint, no matter if the value changed or not. */
3722 #define BP_TEMPFLAG 1
3723 #define BP_HARDWAREFLAG 2
3725 /* Evaluate watchpoint condition expression and check if its value
3728 P should be a pointer to struct bpstat, but is defined as a void *
3729 in order for this function to be usable with catch_errors. */
3732 watchpoint_check (void *p)
3734 bpstat bs = (bpstat) p;
3735 struct breakpoint *b;
3736 struct frame_info *fr;
3737 int within_current_scope;
3739 /* BS is built from an existing struct breakpoint. */
3740 gdb_assert (bs->breakpoint_at != NULL);
3741 b = bs->breakpoint_at;
3743 gdb_assert (is_watchpoint (b));
3745 /* If this is a local watchpoint, we only want to check if the
3746 watchpoint frame is in scope if the current thread is the thread
3747 that was used to create the watchpoint. */
3748 if (!watchpoint_in_thread_scope (b))
3751 if (b->exp_valid_block == NULL)
3752 within_current_scope = 1;
3755 struct frame_info *frame = get_current_frame ();
3756 struct gdbarch *frame_arch = get_frame_arch (frame);
3757 CORE_ADDR frame_pc = get_frame_pc (frame);
3759 /* in_function_epilogue_p() returns a non-zero value if we're
3760 still in the function but the stack frame has already been
3761 invalidated. Since we can't rely on the values of local
3762 variables after the stack has been destroyed, we are treating
3763 the watchpoint in that state as `not changed' without further
3764 checking. Don't mark watchpoints as changed if the current
3765 frame is in an epilogue - even if they are in some other
3766 frame, our view of the stack is likely to be wrong and
3767 frame_find_by_id could error out. */
3768 if (gdbarch_in_function_epilogue_p (frame_arch, frame_pc))
3771 fr = frame_find_by_id (b->watchpoint_frame);
3772 within_current_scope = (fr != NULL);
3774 /* If we've gotten confused in the unwinder, we might have
3775 returned a frame that can't describe this variable. */
3776 if (within_current_scope)
3778 struct symbol *function;
3780 function = get_frame_function (fr);
3781 if (function == NULL
3782 || !contained_in (b->exp_valid_block,
3783 SYMBOL_BLOCK_VALUE (function)))
3784 within_current_scope = 0;
3787 if (within_current_scope)
3788 /* If we end up stopping, the current frame will get selected
3789 in normal_stop. So this call to select_frame won't affect
3794 if (within_current_scope)
3796 /* We use value_{,free_to_}mark because it could be a *long*
3797 time before we return to the command level and call
3798 free_all_values. We can't call free_all_values because we
3799 might be in the middle of evaluating a function call. */
3802 struct value *mark = value_mark ();
3803 struct value *new_val;
3805 fetch_subexp_value (b->exp, &pc, &new_val, NULL, NULL);
3807 /* We use value_equal_contents instead of value_equal because
3808 the latter coerces an array to a pointer, thus comparing just
3809 the address of the array instead of its contents. This is
3810 not what we want. */
3811 if ((b->val != NULL) != (new_val != NULL)
3812 || (b->val != NULL && !value_equal_contents (b->val, new_val)))
3814 if (new_val != NULL)
3816 release_value (new_val);
3817 value_free_to_mark (mark);
3819 bs->old_val = b->val;
3822 return WP_VALUE_CHANGED;
3826 /* Nothing changed. */
3827 value_free_to_mark (mark);
3828 return WP_VALUE_NOT_CHANGED;
3833 /* This seems like the only logical thing to do because
3834 if we temporarily ignored the watchpoint, then when
3835 we reenter the block in which it is valid it contains
3836 garbage (in the case of a function, it may have two
3837 garbage values, one before and one after the prologue).
3838 So we can't even detect the first assignment to it and
3839 watch after that (since the garbage may or may not equal
3840 the first value assigned). */
3841 /* We print all the stop information in print_it_typical(), but
3842 in this case, by the time we call print_it_typical() this bp
3843 will be deleted already. So we have no choice but print the
3844 information here. */
3845 if (ui_out_is_mi_like_p (uiout))
3847 (uiout, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE));
3848 ui_out_text (uiout, "\nWatchpoint ");
3849 ui_out_field_int (uiout, "wpnum", b->number);
3851 " deleted because the program has left the block in\n\
3852 which its expression is valid.\n");
3854 watchpoint_del_at_next_stop (b);
3860 /* Return true if it looks like target has stopped due to hitting
3861 breakpoint location BL. This function does not check if we
3862 should stop, only if BL explains the stop. */
3864 bpstat_check_location (const struct bp_location *bl,
3865 struct address_space *aspace, CORE_ADDR bp_addr)
3867 struct breakpoint *b = bl->owner;
3869 /* BL is from existing struct breakpoint. */
3870 gdb_assert (b != NULL);
3872 if (b->ops && b->ops->breakpoint_hit)
3873 return b->ops->breakpoint_hit (bl, aspace, bp_addr);
3875 /* By definition, the inferior does not report stops at
3877 if (is_tracepoint (b))
3880 if (!is_watchpoint (b)
3881 && b->type != bp_hardware_breakpoint
3882 && b->type != bp_catchpoint) /* a non-watchpoint bp */
3884 if (!breakpoint_address_match (bl->pspace->aspace, bl->address,
3887 if (overlay_debugging /* unmapped overlay section */
3888 && section_is_overlay (bl->section)
3889 && !section_is_mapped (bl->section))
3893 /* Continuable hardware watchpoints are treated as non-existent if the
3894 reason we stopped wasn't a hardware watchpoint (we didn't stop on
3895 some data address). Otherwise gdb won't stop on a break instruction
3896 in the code (not from a breakpoint) when a hardware watchpoint has
3897 been defined. Also skip watchpoints which we know did not trigger
3898 (did not match the data address). */
3900 if (is_hardware_watchpoint (b)
3901 && b->watchpoint_triggered == watch_triggered_no)
3904 if (b->type == bp_hardware_breakpoint)
3906 if (bl->address != bp_addr)
3908 if (overlay_debugging /* unmapped overlay section */
3909 && section_is_overlay (bl->section)
3910 && !section_is_mapped (bl->section))
3917 /* If BS refers to a watchpoint, determine if the watched values
3918 has actually changed, and we should stop. If not, set BS->stop
3921 bpstat_check_watchpoint (bpstat bs)
3923 const struct bp_location *bl;
3924 struct breakpoint *b;
3926 /* BS is built for existing struct breakpoint. */
3927 bl = bs->bp_location_at;
3928 gdb_assert (bl != NULL);
3929 b = bs->breakpoint_at;
3930 gdb_assert (b != NULL);
3932 if (is_watchpoint (b))
3934 int must_check_value = 0;
3936 if (b->type == bp_watchpoint)
3937 /* For a software watchpoint, we must always check the
3939 must_check_value = 1;
3940 else if (b->watchpoint_triggered == watch_triggered_yes)
3941 /* We have a hardware watchpoint (read, write, or access)
3942 and the target earlier reported an address watched by
3944 must_check_value = 1;
3945 else if (b->watchpoint_triggered == watch_triggered_unknown
3946 && b->type == bp_hardware_watchpoint)
3947 /* We were stopped by a hardware watchpoint, but the target could
3948 not report the data address. We must check the watchpoint's
3949 value. Access and read watchpoints are out of luck; without
3950 a data address, we can't figure it out. */
3951 must_check_value = 1;
3953 if (must_check_value)
3956 = xstrprintf ("Error evaluating expression for watchpoint %d\n",
3958 struct cleanup *cleanups = make_cleanup (xfree, message);
3959 int e = catch_errors (watchpoint_check, bs, message,
3961 do_cleanups (cleanups);
3965 /* We've already printed what needs to be printed. */
3966 bs->print_it = print_it_done;
3970 bs->print_it = print_it_noop;
3973 case WP_VALUE_CHANGED:
3974 if (b->type == bp_read_watchpoint)
3976 /* There are two cases to consider here:
3978 1. We're watching the triggered memory for reads.
3979 In that case, trust the target, and always report
3980 the watchpoint hit to the user. Even though
3981 reads don't cause value changes, the value may
3982 have changed since the last time it was read, and
3983 since we're not trapping writes, we will not see
3984 those, and as such we should ignore our notion of
3987 2. We're watching the triggered memory for both
3988 reads and writes. There are two ways this may
3991 2.1. This is a target that can't break on data
3992 reads only, but can break on accesses (reads or
3993 writes), such as e.g., x86. We detect this case
3994 at the time we try to insert read watchpoints.
3996 2.2. Otherwise, the target supports read
3997 watchpoints, but, the user set an access or write
3998 watchpoint watching the same memory as this read
4001 If we're watching memory writes as well as reads,
4002 ignore watchpoint hits when we find that the
4003 value hasn't changed, as reads don't cause
4004 changes. This still gives false positives when
4005 the program writes the same value to memory as
4006 what there was already in memory (we will confuse
4007 it for a read), but it's much better than
4010 int other_write_watchpoint = 0;
4012 if (bl->watchpoint_type == hw_read)
4014 struct breakpoint *other_b;
4016 ALL_BREAKPOINTS (other_b)
4017 if ((other_b->type == bp_hardware_watchpoint
4018 || other_b->type == bp_access_watchpoint)
4019 && (other_b->watchpoint_triggered
4020 == watch_triggered_yes))
4022 other_write_watchpoint = 1;
4027 if (other_write_watchpoint
4028 || bl->watchpoint_type == hw_access)
4030 /* We're watching the same memory for writes,
4031 and the value changed since the last time we
4032 updated it, so this trap must be for a write.
4034 bs->print_it = print_it_noop;
4039 case WP_VALUE_NOT_CHANGED:
4040 if (b->type == bp_hardware_watchpoint
4041 || b->type == bp_watchpoint)
4043 /* Don't stop: write watchpoints shouldn't fire if
4044 the value hasn't changed. */
4045 bs->print_it = print_it_noop;
4053 /* Error from catch_errors. */
4054 printf_filtered (_("Watchpoint %d deleted.\n"), b->number);
4055 watchpoint_del_at_next_stop (b);
4056 /* We've already printed what needs to be printed. */
4057 bs->print_it = print_it_done;
4061 else /* must_check_value == 0 */
4063 /* This is a case where some watchpoint(s) triggered, but
4064 not at the address of this watchpoint, or else no
4065 watchpoint triggered after all. So don't print
4066 anything for this watchpoint. */
4067 bs->print_it = print_it_noop;
4074 /* Check conditions (condition proper, frame, thread and ignore count)
4075 of breakpoint referred to by BS. If we should not stop for this
4076 breakpoint, set BS->stop to 0. */
4079 bpstat_check_breakpoint_conditions (bpstat bs, ptid_t ptid)
4081 int thread_id = pid_to_thread_id (ptid);
4082 const struct bp_location *bl;
4083 struct breakpoint *b;
4085 /* BS is built for existing struct breakpoint. */
4086 bl = bs->bp_location_at;
4087 gdb_assert (bl != NULL);
4088 b = bs->breakpoint_at;
4089 gdb_assert (b != NULL);
4091 if (frame_id_p (b->frame_id)
4092 && !frame_id_eq (b->frame_id, get_stack_frame_id (get_current_frame ())))
4096 int value_is_zero = 0;
4097 struct expression *cond;
4099 /* Evaluate Python breakpoints that have a "stop"
4100 method implemented. */
4101 if (b->py_bp_object)
4102 bs->stop = gdbpy_should_stop (b->py_bp_object);
4104 if (is_watchpoint (b))
4109 if (cond && b->disposition != disp_del_at_next_stop)
4111 int within_current_scope = 1;
4113 /* We use value_mark and value_free_to_mark because it could
4114 be a long time before we return to the command level and
4115 call free_all_values. We can't call free_all_values
4116 because we might be in the middle of evaluating a
4118 struct value *mark = value_mark ();
4120 /* Need to select the frame, with all that implies so that
4121 the conditions will have the right context. Because we
4122 use the frame, we will not see an inlined function's
4123 variables when we arrive at a breakpoint at the start
4124 of the inlined function; the current frame will be the
4126 if (!is_watchpoint (b) || b->cond_exp_valid_block == NULL)
4127 select_frame (get_current_frame ());
4130 struct frame_info *frame;
4132 /* For local watchpoint expressions, which particular
4133 instance of a local is being watched matters, so we
4134 keep track of the frame to evaluate the expression
4135 in. To evaluate the condition however, it doesn't
4136 really matter which instantiation of the function
4137 where the condition makes sense triggers the
4138 watchpoint. This allows an expression like "watch
4139 global if q > 10" set in `func', catch writes to
4140 global on all threads that call `func', or catch
4141 writes on all recursive calls of `func' by a single
4142 thread. We simply always evaluate the condition in
4143 the innermost frame that's executing where it makes
4144 sense to evaluate the condition. It seems
4146 frame = block_innermost_frame (b->cond_exp_valid_block);
4148 select_frame (frame);
4150 within_current_scope = 0;
4152 if (within_current_scope)
4154 = catch_errors (breakpoint_cond_eval, cond,
4155 "Error in testing breakpoint condition:\n",
4159 warning (_("Watchpoint condition cannot be tested "
4160 "in the current scope"));
4161 /* If we failed to set the right context for this
4162 watchpoint, unconditionally report it. */
4165 /* FIXME-someday, should give breakpoint #. */
4166 value_free_to_mark (mark);
4169 if (cond && value_is_zero)
4173 else if (b->thread != -1 && b->thread != thread_id)
4177 else if (b->ignore_count > 0)
4180 annotate_ignore_count_change ();
4182 /* Increase the hit count even though we don't stop. */
4184 observer_notify_breakpoint_modified (b);
4190 /* Get a bpstat associated with having just stopped at address
4191 BP_ADDR in thread PTID.
4193 Determine whether we stopped at a breakpoint, etc, or whether we
4194 don't understand this stop. Result is a chain of bpstat's such
4197 if we don't understand the stop, the result is a null pointer.
4199 if we understand why we stopped, the result is not null.
4201 Each element of the chain refers to a particular breakpoint or
4202 watchpoint at which we have stopped. (We may have stopped for
4203 several reasons concurrently.)
4205 Each element of the chain has valid next, breakpoint_at,
4206 commands, FIXME??? fields. */
4209 bpstat_stop_status (struct address_space *aspace,
4210 CORE_ADDR bp_addr, ptid_t ptid)
4212 struct breakpoint *b = NULL;
4213 struct bp_location *bl;
4214 struct bp_location *loc;
4215 /* First item of allocated bpstat's. */
4216 bpstat bs_head = NULL, *bs_link = &bs_head;
4217 /* Pointer to the last thing in the chain currently. */
4220 int need_remove_insert;
4223 /* First, build the bpstat chain with locations that explain a
4224 target stop, while being careful to not set the target running,
4225 as that may invalidate locations (in particular watchpoint
4226 locations are recreated). Resuming will happen here with
4227 breakpoint conditions or watchpoint expressions that include
4228 inferior function calls. */
4232 if (!breakpoint_enabled (b) && b->enable_state != bp_permanent)
4235 for (bl = b->loc; bl != NULL; bl = bl->next)
4237 /* For hardware watchpoints, we look only at the first
4238 location. The watchpoint_check function will work on the
4239 entire expression, not the individual locations. For
4240 read watchpoints, the watchpoints_triggered function has
4241 checked all locations already. */
4242 if (b->type == bp_hardware_watchpoint && bl != b->loc)
4245 if (bl->shlib_disabled)
4248 if (!bpstat_check_location (bl, aspace, bp_addr))
4251 /* Come here if it's a watchpoint, or if the break address
4254 bs = bpstat_alloc (bl, &bs_link); /* Alloc a bpstat to
4257 /* Assume we stop. Should we find a watchpoint that is not
4258 actually triggered, or if the condition of the breakpoint
4259 evaluates as false, we'll reset 'stop' to 0. */
4263 /* If this is a scope breakpoint, mark the associated
4264 watchpoint as triggered so that we will handle the
4265 out-of-scope event. We'll get to the watchpoint next
4267 if (b->type == bp_watchpoint_scope && b->related_breakpoint != b)
4268 b->related_breakpoint->watchpoint_triggered = watch_triggered_yes;
4272 for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
4274 if (breakpoint_location_address_match (loc, aspace, bp_addr))
4276 bs = bpstat_alloc (loc, &bs_link);
4277 /* For hits of moribund locations, we should just proceed. */
4280 bs->print_it = print_it_noop;
4284 /* Now go through the locations that caused the target to stop, and
4285 check whether we're interested in reporting this stop to higher
4286 layers, or whether we should resume the target transparently. */
4290 for (bs = bs_head; bs != NULL; bs = bs->next)
4295 bpstat_check_watchpoint (bs);
4299 b = bs->breakpoint_at;
4301 if (b->type == bp_thread_event || b->type == bp_overlay_event
4302 || b->type == bp_longjmp_master
4303 || b->type == bp_std_terminate_master
4304 || b->type == bp_exception_master)
4305 /* We do not stop for these. */
4308 bpstat_check_breakpoint_conditions (bs, ptid);
4313 observer_notify_breakpoint_modified (b);
4315 /* We will stop here. */
4316 if (b->disposition == disp_disable)
4318 if (b->enable_state != bp_permanent)
4319 b->enable_state = bp_disabled;
4324 bs->commands = b->commands;
4325 incref_counted_command_line (bs->commands);
4326 bs->commands_left = bs->commands ? bs->commands->commands : NULL;
4327 if (bs->commands_left
4328 && (strcmp ("silent", bs->commands_left->line) == 0
4331 bs->commands_left->line) == 0)))
4333 bs->commands_left = bs->commands_left->next;
4338 /* Print nothing for this entry if we dont stop or dont print. */
4339 if (bs->stop == 0 || bs->print == 0)
4340 bs->print_it = print_it_noop;
4343 /* If we aren't stopping, the value of some hardware watchpoint may
4344 not have changed, but the intermediate memory locations we are
4345 watching may have. Don't bother if we're stopping; this will get
4347 need_remove_insert = 0;
4348 if (! bpstat_causes_stop (bs_head))
4349 for (bs = bs_head; bs != NULL; bs = bs->next)
4351 && bs->breakpoint_at
4352 && is_hardware_watchpoint (bs->breakpoint_at))
4354 update_watchpoint (bs->breakpoint_at, 0 /* don't reparse. */);
4355 need_remove_insert = 1;
4358 if (need_remove_insert)
4359 update_global_location_list (1);
4360 else if (removed_any)
4361 update_global_location_list (0);
4367 handle_jit_event (void)
4369 struct frame_info *frame;
4370 struct gdbarch *gdbarch;
4372 /* Switch terminal for any messages produced by
4373 breakpoint_re_set. */
4374 target_terminal_ours_for_output ();
4376 frame = get_current_frame ();
4377 gdbarch = get_frame_arch (frame);
4379 jit_event_handler (gdbarch);
4381 target_terminal_inferior ();
4384 /* Prepare WHAT final decision for infrun. */
4386 /* Decide what infrun needs to do with this bpstat. */
4389 bpstat_what (bpstat bs_head)
4391 struct bpstat_what retval;
4392 /* We need to defer calling `solib_add', as adding new symbols
4393 resets breakpoints, which in turn deletes breakpoint locations,
4394 and hence may clear unprocessed entries in the BS chain. */
4395 int shlib_event = 0;
4399 retval.main_action = BPSTAT_WHAT_KEEP_CHECKING;
4400 retval.call_dummy = STOP_NONE;
4401 retval.is_longjmp = 0;
4403 for (bs = bs_head; bs != NULL; bs = bs->next)
4405 /* Extract this BS's action. After processing each BS, we check
4406 if its action overrides all we've seem so far. */
4407 enum bpstat_what_main_action this_action = BPSTAT_WHAT_KEEP_CHECKING;
4410 if (bs->breakpoint_at == NULL)
4412 /* I suspect this can happen if it was a momentary
4413 breakpoint which has since been deleted. */
4416 else if (bs->breakpoint_at == NULL)
4419 bptype = bs->breakpoint_at->type;
4426 case bp_hardware_breakpoint:
4432 this_action = BPSTAT_WHAT_STOP_NOISY;
4434 this_action = BPSTAT_WHAT_STOP_SILENT;
4437 this_action = BPSTAT_WHAT_SINGLE;
4440 case bp_hardware_watchpoint:
4441 case bp_read_watchpoint:
4442 case bp_access_watchpoint:
4446 this_action = BPSTAT_WHAT_STOP_NOISY;
4448 this_action = BPSTAT_WHAT_STOP_SILENT;
4452 /* There was a watchpoint, but we're not stopping.
4453 This requires no further action. */
4458 this_action = BPSTAT_WHAT_SET_LONGJMP_RESUME;
4459 retval.is_longjmp = bptype == bp_longjmp;
4461 case bp_longjmp_resume:
4462 case bp_exception_resume:
4463 this_action = BPSTAT_WHAT_CLEAR_LONGJMP_RESUME;
4464 retval.is_longjmp = bptype == bp_longjmp_resume;
4466 case bp_step_resume:
4468 this_action = BPSTAT_WHAT_STEP_RESUME;
4471 /* It is for the wrong frame. */
4472 this_action = BPSTAT_WHAT_SINGLE;
4475 case bp_watchpoint_scope:
4476 case bp_thread_event:
4477 case bp_overlay_event:
4478 case bp_longjmp_master:
4479 case bp_std_terminate_master:
4480 case bp_exception_master:
4481 this_action = BPSTAT_WHAT_SINGLE;
4487 this_action = BPSTAT_WHAT_STOP_NOISY;
4489 this_action = BPSTAT_WHAT_STOP_SILENT;
4493 /* There was a catchpoint, but we're not stopping.
4494 This requires no further action. */
4497 case bp_shlib_event:
4500 /* If requested, stop when the dynamic linker notifies GDB
4501 of events. This allows the user to get control and place
4502 breakpoints in initializer routines for dynamically
4503 loaded objects (among other things). */
4504 if (stop_on_solib_events)
4505 this_action = BPSTAT_WHAT_STOP_NOISY;
4507 this_action = BPSTAT_WHAT_SINGLE;
4511 this_action = BPSTAT_WHAT_SINGLE;
4514 /* Make sure the action is stop (silent or noisy),
4515 so infrun.c pops the dummy frame. */
4516 retval.call_dummy = STOP_STACK_DUMMY;
4517 this_action = BPSTAT_WHAT_STOP_SILENT;
4519 case bp_std_terminate:
4520 /* Make sure the action is stop (silent or noisy),
4521 so infrun.c pops the dummy frame. */
4522 retval.call_dummy = STOP_STD_TERMINATE;
4523 this_action = BPSTAT_WHAT_STOP_SILENT;
4526 case bp_fast_tracepoint:
4527 case bp_static_tracepoint:
4528 /* Tracepoint hits should not be reported back to GDB, and
4529 if one got through somehow, it should have been filtered
4531 internal_error (__FILE__, __LINE__,
4532 _("bpstat_what: tracepoint encountered"));
4534 case bp_gnu_ifunc_resolver:
4535 /* Step over it (and insert bp_gnu_ifunc_resolver_return). */
4536 this_action = BPSTAT_WHAT_SINGLE;
4538 case bp_gnu_ifunc_resolver_return:
4539 /* The breakpoint will be removed, execution will restart from the
4540 PC of the former breakpoint. */
4541 this_action = BPSTAT_WHAT_KEEP_CHECKING;
4544 internal_error (__FILE__, __LINE__,
4545 _("bpstat_what: unhandled bptype %d"), (int) bptype);
4548 retval.main_action = max (retval.main_action, this_action);
4551 /* These operations may affect the bs->breakpoint_at state so they are
4552 delayed after MAIN_ACTION is decided above. */
4557 fprintf_unfiltered (gdb_stdlog, "bpstat_what: bp_shlib_event\n");
4559 /* Check for any newly added shared libraries if we're supposed
4560 to be adding them automatically. */
4562 /* Switch terminal for any messages produced by
4563 breakpoint_re_set. */
4564 target_terminal_ours_for_output ();
4567 SOLIB_ADD (NULL, 0, ¤t_target, auto_solib_add);
4569 solib_add (NULL, 0, ¤t_target, auto_solib_add);
4572 target_terminal_inferior ();
4578 fprintf_unfiltered (gdb_stdlog, "bpstat_what: bp_jit_event\n");
4580 handle_jit_event ();
4583 for (bs = bs_head; bs != NULL; bs = bs->next)
4585 struct breakpoint *b = bs->breakpoint_at;
4591 case bp_gnu_ifunc_resolver:
4592 gnu_ifunc_resolver_stop (b);
4594 case bp_gnu_ifunc_resolver_return:
4595 gnu_ifunc_resolver_return_stop (b);
4603 /* Nonzero if we should step constantly (e.g. watchpoints on machines
4604 without hardware support). This isn't related to a specific bpstat,
4605 just to things like whether watchpoints are set. */
4608 bpstat_should_step (void)
4610 struct breakpoint *b;
4613 if (breakpoint_enabled (b) && b->type == bp_watchpoint && b->loc != NULL)
4619 bpstat_causes_stop (bpstat bs)
4621 for (; bs != NULL; bs = bs->next)
4630 /* Compute a string of spaces suitable to indent the next line
4631 so it starts at the position corresponding to the table column
4632 named COL_NAME in the currently active table of UIOUT. */
4635 wrap_indent_at_field (struct ui_out *uiout, const char *col_name)
4637 static char wrap_indent[80];
4638 int i, total_width, width, align;
4642 for (i = 1; ui_out_query_field (uiout, i, &width, &align, &text); i++)
4644 if (strcmp (text, col_name) == 0)
4646 gdb_assert (total_width < sizeof wrap_indent);
4647 memset (wrap_indent, ' ', total_width);
4648 wrap_indent[total_width] = 0;
4653 total_width += width + 1;
4659 /* Print the LOC location out of the list of B->LOC locations. */
4662 print_breakpoint_location (struct breakpoint *b,
4663 struct bp_location *loc)
4665 struct cleanup *old_chain = save_current_program_space ();
4667 if (loc != NULL && loc->shlib_disabled)
4671 set_current_program_space (loc->pspace);
4673 if (b->display_canonical)
4674 ui_out_field_string (uiout, "what", b->addr_string);
4675 else if (b->source_file && loc)
4678 = find_pc_sect_function (loc->address, loc->section);
4681 ui_out_text (uiout, "in ");
4682 ui_out_field_string (uiout, "func",
4683 SYMBOL_PRINT_NAME (sym));
4684 ui_out_text (uiout, " ");
4685 ui_out_wrap_hint (uiout, wrap_indent_at_field (uiout, "what"));
4686 ui_out_text (uiout, "at ");
4688 ui_out_field_string (uiout, "file", b->source_file);
4689 ui_out_text (uiout, ":");
4691 if (ui_out_is_mi_like_p (uiout))
4693 struct symtab_and_line sal = find_pc_line (loc->address, 0);
4694 char *fullname = symtab_to_fullname (sal.symtab);
4697 ui_out_field_string (uiout, "fullname", fullname);
4700 ui_out_field_int (uiout, "line", b->line_number);
4704 struct ui_stream *stb = ui_out_stream_new (uiout);
4705 struct cleanup *stb_chain = make_cleanup_ui_out_stream_delete (stb);
4707 print_address_symbolic (loc->gdbarch, loc->address, stb->stream,
4709 ui_out_field_stream (uiout, "at", stb);
4711 do_cleanups (stb_chain);
4714 ui_out_field_string (uiout, "pending", b->addr_string);
4716 do_cleanups (old_chain);
4720 bptype_string (enum bptype type)
4722 struct ep_type_description
4727 static struct ep_type_description bptypes[] =
4729 {bp_none, "?deleted?"},
4730 {bp_breakpoint, "breakpoint"},
4731 {bp_hardware_breakpoint, "hw breakpoint"},
4732 {bp_until, "until"},
4733 {bp_finish, "finish"},
4734 {bp_watchpoint, "watchpoint"},
4735 {bp_hardware_watchpoint, "hw watchpoint"},
4736 {bp_read_watchpoint, "read watchpoint"},
4737 {bp_access_watchpoint, "acc watchpoint"},
4738 {bp_longjmp, "longjmp"},
4739 {bp_longjmp_resume, "longjmp resume"},
4740 {bp_exception, "exception"},
4741 {bp_exception_resume, "exception resume"},
4742 {bp_step_resume, "step resume"},
4743 {bp_watchpoint_scope, "watchpoint scope"},
4744 {bp_call_dummy, "call dummy"},
4745 {bp_std_terminate, "std::terminate"},
4746 {bp_shlib_event, "shlib events"},
4747 {bp_thread_event, "thread events"},
4748 {bp_overlay_event, "overlay events"},
4749 {bp_longjmp_master, "longjmp master"},
4750 {bp_std_terminate_master, "std::terminate master"},
4751 {bp_exception_master, "exception master"},
4752 {bp_catchpoint, "catchpoint"},
4753 {bp_tracepoint, "tracepoint"},
4754 {bp_fast_tracepoint, "fast tracepoint"},
4755 {bp_static_tracepoint, "static tracepoint"},
4756 {bp_jit_event, "jit events"},
4757 {bp_gnu_ifunc_resolver, "STT_GNU_IFUNC resolver"},
4758 {bp_gnu_ifunc_resolver_return, "STT_GNU_IFUNC resolver return"},
4761 if (((int) type >= (sizeof (bptypes) / sizeof (bptypes[0])))
4762 || ((int) type != bptypes[(int) type].type))
4763 internal_error (__FILE__, __LINE__,
4764 _("bptypes table does not describe type #%d."),
4767 return bptypes[(int) type].description;
4770 /* Print B to gdb_stdout. */
4773 print_one_breakpoint_location (struct breakpoint *b,
4774 struct bp_location *loc,
4776 struct bp_location **last_loc,
4779 struct command_line *l;
4780 static char bpenables[] = "nynny";
4782 int header_of_multiple = 0;
4783 int part_of_multiple = (loc != NULL);
4784 struct value_print_options opts;
4786 get_user_print_options (&opts);
4788 gdb_assert (!loc || loc_number != 0);
4789 /* See comment in print_one_breakpoint concerning treatment of
4790 breakpoints with single disabled location. */
4793 && (b->loc->next != NULL || !b->loc->enabled)))
4794 header_of_multiple = 1;
4802 if (part_of_multiple)
4805 formatted = xstrprintf ("%d.%d", b->number, loc_number);
4806 ui_out_field_string (uiout, "number", formatted);
4811 ui_out_field_int (uiout, "number", b->number);
4816 if (part_of_multiple)
4817 ui_out_field_skip (uiout, "type");
4819 ui_out_field_string (uiout, "type", bptype_string (b->type));
4823 if (part_of_multiple)
4824 ui_out_field_skip (uiout, "disp");
4826 ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
4831 if (part_of_multiple)
4832 ui_out_field_string (uiout, "enabled", loc->enabled ? "y" : "n");
4834 ui_out_field_fmt (uiout, "enabled", "%c",
4835 bpenables[(int) b->enable_state]);
4836 ui_out_spaces (uiout, 2);
4840 if (b->ops != NULL && b->ops->print_one != NULL)
4842 /* Although the print_one can possibly print all locations,
4843 calling it here is not likely to get any nice result. So,
4844 make sure there's just one location. */
4845 gdb_assert (b->loc == NULL || b->loc->next == NULL);
4846 b->ops->print_one (b, last_loc);
4852 internal_error (__FILE__, __LINE__,
4853 _("print_one_breakpoint: bp_none encountered\n"));
4857 case bp_hardware_watchpoint:
4858 case bp_read_watchpoint:
4859 case bp_access_watchpoint:
4860 /* Field 4, the address, is omitted (which makes the columns
4861 not line up too nicely with the headers, but the effect
4862 is relatively readable). */
4863 if (opts.addressprint)
4864 ui_out_field_skip (uiout, "addr");
4866 ui_out_field_string (uiout, "what", b->exp_string);
4870 case bp_hardware_breakpoint:
4874 case bp_longjmp_resume:
4876 case bp_exception_resume:
4877 case bp_step_resume:
4878 case bp_watchpoint_scope:
4880 case bp_std_terminate:
4881 case bp_shlib_event:
4882 case bp_thread_event:
4883 case bp_overlay_event:
4884 case bp_longjmp_master:
4885 case bp_std_terminate_master:
4886 case bp_exception_master:
4888 case bp_fast_tracepoint:
4889 case bp_static_tracepoint:
4891 case bp_gnu_ifunc_resolver:
4892 case bp_gnu_ifunc_resolver_return:
4893 if (opts.addressprint)
4896 if (header_of_multiple)
4897 ui_out_field_string (uiout, "addr", "<MULTIPLE>");
4898 else if (b->loc == NULL || loc->shlib_disabled)
4899 ui_out_field_string (uiout, "addr", "<PENDING>");
4901 ui_out_field_core_addr (uiout, "addr",
4902 loc->gdbarch, loc->address);
4905 if (!header_of_multiple)
4906 print_breakpoint_location (b, loc);
4913 /* For backward compatibility, don't display inferiors unless there
4916 && !header_of_multiple
4918 || (!gdbarch_has_global_breakpoints (target_gdbarch)
4919 && (number_of_program_spaces () > 1
4920 || number_of_inferiors () > 1)
4921 /* LOC is for existing B, it cannot be in
4922 moribund_locations and thus having NULL OWNER. */
4923 && loc->owner->type != bp_catchpoint)))
4925 struct inferior *inf;
4928 for (inf = inferior_list; inf != NULL; inf = inf->next)
4930 if (inf->pspace == loc->pspace)
4935 ui_out_text (uiout, " inf ");
4938 ui_out_text (uiout, ", ");
4939 ui_out_text (uiout, plongest (inf->num));
4944 if (!part_of_multiple)
4946 if (b->thread != -1)
4948 /* FIXME: This seems to be redundant and lost here; see the
4949 "stop only in" line a little further down. */
4950 ui_out_text (uiout, " thread ");
4951 ui_out_field_int (uiout, "thread", b->thread);
4953 else if (b->task != 0)
4955 ui_out_text (uiout, " task ");
4956 ui_out_field_int (uiout, "task", b->task);
4960 ui_out_text (uiout, "\n");
4962 if (!part_of_multiple && b->ops && b->ops->print_one_detail)
4963 b->ops->print_one_detail (b, uiout);
4965 if (!part_of_multiple && b->static_trace_marker_id)
4967 gdb_assert (b->type == bp_static_tracepoint);
4969 ui_out_text (uiout, "\tmarker id is ");
4970 ui_out_field_string (uiout, "static-tracepoint-marker-string-id",
4971 b->static_trace_marker_id);
4972 ui_out_text (uiout, "\n");
4975 if (part_of_multiple && frame_id_p (b->frame_id))
4978 ui_out_text (uiout, "\tstop only in stack frame at ");
4979 /* FIXME: cagney/2002-12-01: Shouldn't be poeking around inside
4981 ui_out_field_core_addr (uiout, "frame",
4982 b->gdbarch, b->frame_id.stack_addr);
4983 ui_out_text (uiout, "\n");
4986 if (!part_of_multiple && b->cond_string && !ada_exception_catchpoint_p (b))
4988 /* We do not print the condition for Ada exception catchpoints
4989 because the condition is an internal implementation detail
4990 that we do not want to expose to the user. */
4992 if (is_tracepoint (b))
4993 ui_out_text (uiout, "\ttrace only if ");
4995 ui_out_text (uiout, "\tstop only if ");
4996 ui_out_field_string (uiout, "cond", b->cond_string);
4997 ui_out_text (uiout, "\n");
5000 if (!part_of_multiple && b->thread != -1)
5002 /* FIXME should make an annotation for this. */
5003 ui_out_text (uiout, "\tstop only in thread ");
5004 ui_out_field_int (uiout, "thread", b->thread);
5005 ui_out_text (uiout, "\n");
5008 if (!part_of_multiple && b->hit_count)
5010 /* FIXME should make an annotation for this. */
5011 if (ep_is_catchpoint (b))
5012 ui_out_text (uiout, "\tcatchpoint");
5014 ui_out_text (uiout, "\tbreakpoint");
5015 ui_out_text (uiout, " already hit ");
5016 ui_out_field_int (uiout, "times", b->hit_count);
5017 if (b->hit_count == 1)
5018 ui_out_text (uiout, " time\n");
5020 ui_out_text (uiout, " times\n");
5023 /* Output the count also if it is zero, but only if this is mi.
5024 FIXME: Should have a better test for this. */
5025 if (ui_out_is_mi_like_p (uiout))
5026 if (!part_of_multiple && b->hit_count == 0)
5027 ui_out_field_int (uiout, "times", b->hit_count);
5029 if (!part_of_multiple && b->ignore_count)
5032 ui_out_text (uiout, "\tignore next ");
5033 ui_out_field_int (uiout, "ignore", b->ignore_count);
5034 ui_out_text (uiout, " hits\n");
5037 l = b->commands ? b->commands->commands : NULL;
5038 if (!part_of_multiple && l)
5040 struct cleanup *script_chain;
5043 script_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "script");
5044 print_command_lines (uiout, l, 4);
5045 do_cleanups (script_chain);
5048 if (!part_of_multiple && b->pass_count)
5050 annotate_field (10);
5051 ui_out_text (uiout, "\tpass count ");
5052 ui_out_field_int (uiout, "pass", b->pass_count);
5053 ui_out_text (uiout, " \n");
5056 if (ui_out_is_mi_like_p (uiout) && !part_of_multiple)
5059 ui_out_field_string (uiout, "original-location", b->addr_string);
5060 else if (b->exp_string)
5061 ui_out_field_string (uiout, "original-location", b->exp_string);
5066 print_one_breakpoint (struct breakpoint *b,
5067 struct bp_location **last_loc,
5070 struct cleanup *bkpt_chain;
5072 bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "bkpt");
5074 print_one_breakpoint_location (b, NULL, 0, last_loc, allflag);
5075 do_cleanups (bkpt_chain);
5077 /* If this breakpoint has custom print function,
5078 it's already printed. Otherwise, print individual
5079 locations, if any. */
5080 if (b->ops == NULL || b->ops->print_one == NULL)
5082 /* If breakpoint has a single location that is disabled, we
5083 print it as if it had several locations, since otherwise it's
5084 hard to represent "breakpoint enabled, location disabled"
5087 Note that while hardware watchpoints have several locations
5088 internally, that's not a property exposed to user. */
5090 && !is_hardware_watchpoint (b)
5091 && (b->loc->next || !b->loc->enabled))
5093 struct bp_location *loc;
5096 for (loc = b->loc; loc; loc = loc->next, ++n)
5098 struct cleanup *inner2 =
5099 make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
5100 print_one_breakpoint_location (b, loc, n, last_loc, allflag);
5101 do_cleanups (inner2);
5108 breakpoint_address_bits (struct breakpoint *b)
5110 int print_address_bits = 0;
5111 struct bp_location *loc;
5113 for (loc = b->loc; loc; loc = loc->next)
5117 /* Software watchpoints that aren't watching memory don't have
5118 an address to print. */
5119 if (b->type == bp_watchpoint && loc->watchpoint_type == -1)
5122 addr_bit = gdbarch_addr_bit (loc->gdbarch);
5123 if (addr_bit > print_address_bits)
5124 print_address_bits = addr_bit;
5127 return print_address_bits;
5130 struct captured_breakpoint_query_args
5136 do_captured_breakpoint_query (struct ui_out *uiout, void *data)
5138 struct captured_breakpoint_query_args *args = data;
5139 struct breakpoint *b;
5140 struct bp_location *dummy_loc = NULL;
5144 if (args->bnum == b->number)
5146 print_one_breakpoint (b, &dummy_loc, 0);
5154 gdb_breakpoint_query (struct ui_out *uiout, int bnum,
5155 char **error_message)
5157 struct captured_breakpoint_query_args args;
5160 /* For the moment we don't trust print_one_breakpoint() to not throw
5162 if (catch_exceptions_with_msg (uiout, do_captured_breakpoint_query, &args,
5163 error_message, RETURN_MASK_ALL) < 0)
5169 /* Return true if this breakpoint was set by the user, false if it is
5170 internal or momentary. */
5173 user_breakpoint_p (struct breakpoint *b)
5175 return b->number > 0;
5178 /* Print information on user settable breakpoint (watchpoint, etc)
5179 number BNUM. If BNUM is -1 print all user-settable breakpoints.
5180 If ALLFLAG is non-zero, include non-user-settable breakpoints. If
5181 FILTER is non-NULL, call it on each breakpoint and only include the
5182 ones for which it returns non-zero. Return the total number of
5183 breakpoints listed. */
5186 breakpoint_1 (char *args, int allflag,
5187 int (*filter) (const struct breakpoint *))
5189 struct breakpoint *b;
5190 struct bp_location *last_loc = NULL;
5191 int nr_printable_breakpoints;
5192 struct cleanup *bkpttbl_chain;
5193 struct value_print_options opts;
5194 int print_address_bits = 0;
5195 int print_type_col_width = 14;
5197 get_user_print_options (&opts);
5199 /* Compute the number of rows in the table, as well as the size
5200 required for address fields. */
5201 nr_printable_breakpoints = 0;
5204 /* If we have a filter, only list the breakpoints it accepts. */
5205 if (filter && !filter (b))
5208 /* If we have an "args" string, it is a list of breakpoints to
5209 accept. Skip the others. */
5210 if (args != NULL && *args != '\0')
5212 if (allflag && parse_and_eval_long (args) != b->number)
5214 if (!allflag && !number_is_in_list (args, b->number))
5218 if (allflag || user_breakpoint_p (b))
5220 int addr_bit, type_len;
5222 addr_bit = breakpoint_address_bits (b);
5223 if (addr_bit > print_address_bits)
5224 print_address_bits = addr_bit;
5226 type_len = strlen (bptype_string (b->type));
5227 if (type_len > print_type_col_width)
5228 print_type_col_width = type_len;
5230 nr_printable_breakpoints++;
5234 if (opts.addressprint)
5236 = make_cleanup_ui_out_table_begin_end (uiout, 6,
5237 nr_printable_breakpoints,
5241 = make_cleanup_ui_out_table_begin_end (uiout, 5,
5242 nr_printable_breakpoints,
5245 if (nr_printable_breakpoints > 0)
5246 annotate_breakpoints_headers ();
5247 if (nr_printable_breakpoints > 0)
5249 ui_out_table_header (uiout, 7, ui_left, "number", "Num"); /* 1 */
5250 if (nr_printable_breakpoints > 0)
5252 ui_out_table_header (uiout, print_type_col_width, ui_left,
5253 "type", "Type"); /* 2 */
5254 if (nr_printable_breakpoints > 0)
5256 ui_out_table_header (uiout, 4, ui_left, "disp", "Disp"); /* 3 */
5257 if (nr_printable_breakpoints > 0)
5259 ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb"); /* 4 */
5260 if (opts.addressprint)
5262 if (nr_printable_breakpoints > 0)
5264 if (print_address_bits <= 32)
5265 ui_out_table_header (uiout, 10, ui_left,
5266 "addr", "Address"); /* 5 */
5268 ui_out_table_header (uiout, 18, ui_left,
5269 "addr", "Address"); /* 5 */
5271 if (nr_printable_breakpoints > 0)
5273 ui_out_table_header (uiout, 40, ui_noalign, "what", "What"); /* 6 */
5274 ui_out_table_body (uiout);
5275 if (nr_printable_breakpoints > 0)
5276 annotate_breakpoints_table ();
5281 /* If we have a filter, only list the breakpoints it accepts. */
5282 if (filter && !filter (b))
5285 /* If we have an "args" string, it is a list of breakpoints to
5286 accept. Skip the others. */
5288 if (args != NULL && *args != '\0')
5290 if (allflag) /* maintenance info breakpoint */
5292 if (parse_and_eval_long (args) != b->number)
5295 else /* all others */
5297 if (!number_is_in_list (args, b->number))
5301 /* We only print out user settable breakpoints unless the
5303 if (allflag || user_breakpoint_p (b))
5304 print_one_breakpoint (b, &last_loc, allflag);
5307 do_cleanups (bkpttbl_chain);
5309 if (nr_printable_breakpoints == 0)
5311 /* If there's a filter, let the caller decide how to report
5315 if (args == NULL || *args == '\0')
5316 ui_out_message (uiout, 0, "No breakpoints or watchpoints.\n");
5318 ui_out_message (uiout, 0,
5319 "No breakpoint or watchpoint matching '%s'.\n",
5325 if (last_loc && !server_command)
5326 set_next_address (last_loc->gdbarch, last_loc->address);
5329 /* FIXME? Should this be moved up so that it is only called when
5330 there have been breakpoints? */
5331 annotate_breakpoints_table_end ();
5333 return nr_printable_breakpoints;
5336 /* Display the value of default-collect in a way that is generally
5337 compatible with the breakpoint list. */
5340 default_collect_info (void)
5342 /* If it has no value (which is frequently the case), say nothing; a
5343 message like "No default-collect." gets in user's face when it's
5345 if (!*default_collect)
5348 /* The following phrase lines up nicely with per-tracepoint collect
5350 ui_out_text (uiout, "default collect ");
5351 ui_out_field_string (uiout, "default-collect", default_collect);
5352 ui_out_text (uiout, " \n");
5356 breakpoints_info (char *args, int from_tty)
5358 breakpoint_1 (args, 0, NULL);
5360 default_collect_info ();
5364 watchpoints_info (char *args, int from_tty)
5366 int num_printed = breakpoint_1 (args, 0, is_watchpoint);
5368 if (num_printed == 0)
5370 if (args == NULL || *args == '\0')
5371 ui_out_message (uiout, 0, "No watchpoints.\n");
5373 ui_out_message (uiout, 0, "No watchpoint matching '%s'.\n", args);
5378 maintenance_info_breakpoints (char *args, int from_tty)
5380 breakpoint_1 (args, 1, NULL);
5382 default_collect_info ();
5386 breakpoint_has_pc (struct breakpoint *b,
5387 struct program_space *pspace,
5388 CORE_ADDR pc, struct obj_section *section)
5390 struct bp_location *bl = b->loc;
5392 for (; bl; bl = bl->next)
5394 if (bl->pspace == pspace
5395 && bl->address == pc
5396 && (!overlay_debugging || bl->section == section))
5402 /* Print a message describing any breakpoints set at PC. This
5403 concerns with logical breakpoints, so we match program spaces, not
5407 describe_other_breakpoints (struct gdbarch *gdbarch,
5408 struct program_space *pspace, CORE_ADDR pc,
5409 struct obj_section *section, int thread)
5412 struct breakpoint *b;
5415 others += breakpoint_has_pc (b, pspace, pc, section);
5419 printf_filtered (_("Note: breakpoint "));
5420 else /* if (others == ???) */
5421 printf_filtered (_("Note: breakpoints "));
5423 if (breakpoint_has_pc (b, pspace, pc, section))
5426 printf_filtered ("%d", b->number);
5427 if (b->thread == -1 && thread != -1)
5428 printf_filtered (" (all threads)");
5429 else if (b->thread != -1)
5430 printf_filtered (" (thread %d)", b->thread);
5431 printf_filtered ("%s%s ",
5432 ((b->enable_state == bp_disabled
5433 || b->enable_state == bp_call_disabled
5434 || b->enable_state == bp_startup_disabled)
5436 : b->enable_state == bp_permanent
5440 : ((others == 1) ? " and" : ""));
5442 printf_filtered (_("also set at pc "));
5443 fputs_filtered (paddress (gdbarch, pc), gdb_stdout);
5444 printf_filtered (".\n");
5448 /* Set the default place to put a breakpoint
5449 for the `break' command with no arguments. */
5452 set_default_breakpoint (int valid, struct program_space *pspace,
5453 CORE_ADDR addr, struct symtab *symtab,
5456 default_breakpoint_valid = valid;
5457 default_breakpoint_pspace = pspace;
5458 default_breakpoint_address = addr;
5459 default_breakpoint_symtab = symtab;
5460 default_breakpoint_line = line;
5463 /* Return true iff it is meaningful to use the address member of
5464 BPT. For some breakpoint types, the address member is irrelevant
5465 and it makes no sense to attempt to compare it to other addresses
5466 (or use it for any other purpose either).
5468 More specifically, each of the following breakpoint types will
5469 always have a zero valued address and we don't want to mark
5470 breakpoints of any of these types to be a duplicate of an actual
5471 breakpoint at address zero:
5479 breakpoint_address_is_meaningful (struct breakpoint *bpt)
5481 enum bptype type = bpt->type;
5483 return (type != bp_watchpoint && type != bp_catchpoint);
5486 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
5487 true if LOC1 and LOC2 represent the same watchpoint location. */
5490 watchpoint_locations_match (struct bp_location *loc1,
5491 struct bp_location *loc2)
5493 /* Both of them must not be in moribund_locations. */
5494 gdb_assert (loc1->owner != NULL);
5495 gdb_assert (loc2->owner != NULL);
5497 /* If the target can evaluate the condition expression in hardware,
5498 then we we need to insert both watchpoints even if they are at
5499 the same place. Otherwise the watchpoint will only trigger when
5500 the condition of whichever watchpoint was inserted evaluates to
5501 true, not giving a chance for GDB to check the condition of the
5502 other watchpoint. */
5503 if ((loc1->owner->cond_exp
5504 && target_can_accel_watchpoint_condition (loc1->address,
5506 loc1->watchpoint_type,
5507 loc1->owner->cond_exp))
5508 || (loc2->owner->cond_exp
5509 && target_can_accel_watchpoint_condition (loc2->address,
5511 loc2->watchpoint_type,
5512 loc2->owner->cond_exp)))
5515 /* Note that this checks the owner's type, not the location's. In
5516 case the target does not support read watchpoints, but does
5517 support access watchpoints, we'll have bp_read_watchpoint
5518 watchpoints with hw_access locations. Those should be considered
5519 duplicates of hw_read locations. The hw_read locations will
5520 become hw_access locations later. */
5521 return (loc1->owner->type == loc2->owner->type
5522 && loc1->pspace->aspace == loc2->pspace->aspace
5523 && loc1->address == loc2->address
5524 && loc1->length == loc2->length);
5527 /* Returns true if {ASPACE1,ADDR1} and {ASPACE2,ADDR2} represent the
5528 same breakpoint location. In most targets, this can only be true
5529 if ASPACE1 matches ASPACE2. On targets that have global
5530 breakpoints, the address space doesn't really matter. */
5533 breakpoint_address_match (struct address_space *aspace1, CORE_ADDR addr1,
5534 struct address_space *aspace2, CORE_ADDR addr2)
5536 return ((gdbarch_has_global_breakpoints (target_gdbarch)
5537 || aspace1 == aspace2)
5541 /* Returns true if {ASPACE2,ADDR2} falls within the range determined by
5542 {ASPACE1,ADDR1,LEN1}. In most targets, this can only be true if ASPACE1
5543 matches ASPACE2. On targets that have global breakpoints, the address
5544 space doesn't really matter. */
5547 breakpoint_address_match_range (struct address_space *aspace1, CORE_ADDR addr1,
5548 int len1, struct address_space *aspace2,
5551 return ((gdbarch_has_global_breakpoints (target_gdbarch)
5552 || aspace1 == aspace2)
5553 && addr2 >= addr1 && addr2 < addr1 + len1);
5556 /* Returns true if {ASPACE,ADDR} matches the breakpoint BL. BL may be
5557 a ranged breakpoint. In most targets, a match happens only if ASPACE
5558 matches the breakpoint's address space. On targets that have global
5559 breakpoints, the address space doesn't really matter. */
5562 breakpoint_location_address_match (struct bp_location *bl,
5563 struct address_space *aspace,
5566 return (breakpoint_address_match (bl->pspace->aspace, bl->address,
5569 && breakpoint_address_match_range (bl->pspace->aspace,
5570 bl->address, bl->length,
5574 /* Assuming LOC1 and LOC2's types' have meaningful target addresses
5575 (breakpoint_address_is_meaningful), returns true if LOC1 and LOC2
5576 represent the same location. */
5579 breakpoint_locations_match (struct bp_location *loc1,
5580 struct bp_location *loc2)
5582 int hw_point1, hw_point2;
5584 /* Both of them must not be in moribund_locations. */
5585 gdb_assert (loc1->owner != NULL);
5586 gdb_assert (loc2->owner != NULL);
5588 hw_point1 = is_hardware_watchpoint (loc1->owner);
5589 hw_point2 = is_hardware_watchpoint (loc2->owner);
5591 if (hw_point1 != hw_point2)
5594 return watchpoint_locations_match (loc1, loc2);
5596 /* We compare bp_location.length in order to cover ranged breakpoints. */
5597 return (breakpoint_address_match (loc1->pspace->aspace, loc1->address,
5598 loc2->pspace->aspace, loc2->address)
5599 && loc1->length == loc2->length);
5603 breakpoint_adjustment_warning (CORE_ADDR from_addr, CORE_ADDR to_addr,
5604 int bnum, int have_bnum)
5606 /* The longest string possibly returned by hex_string_custom
5607 is 50 chars. These must be at least that big for safety. */
5611 strcpy (astr1, hex_string_custom ((unsigned long) from_addr, 8));
5612 strcpy (astr2, hex_string_custom ((unsigned long) to_addr, 8));
5614 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
5615 bnum, astr1, astr2);
5617 warning (_("Breakpoint address adjusted from %s to %s."), astr1, astr2);
5620 /* Adjust a breakpoint's address to account for architectural
5621 constraints on breakpoint placement. Return the adjusted address.
5622 Note: Very few targets require this kind of adjustment. For most
5623 targets, this function is simply the identity function. */
5626 adjust_breakpoint_address (struct gdbarch *gdbarch,
5627 CORE_ADDR bpaddr, enum bptype bptype)
5629 if (!gdbarch_adjust_breakpoint_address_p (gdbarch))
5631 /* Very few targets need any kind of breakpoint adjustment. */
5634 else if (bptype == bp_watchpoint
5635 || bptype == bp_hardware_watchpoint
5636 || bptype == bp_read_watchpoint
5637 || bptype == bp_access_watchpoint
5638 || bptype == bp_catchpoint)
5640 /* Watchpoints and the various bp_catch_* eventpoints should not
5641 have their addresses modified. */
5646 CORE_ADDR adjusted_bpaddr;
5648 /* Some targets have architectural constraints on the placement
5649 of breakpoint instructions. Obtain the adjusted address. */
5650 adjusted_bpaddr = gdbarch_adjust_breakpoint_address (gdbarch, bpaddr);
5652 /* An adjusted breakpoint address can significantly alter
5653 a user's expectations. Print a warning if an adjustment
5655 if (adjusted_bpaddr != bpaddr)
5656 breakpoint_adjustment_warning (bpaddr, adjusted_bpaddr, 0, 0);
5658 return adjusted_bpaddr;
5662 /* Allocate a struct bp_location. */
5664 static struct bp_location *
5665 allocate_bp_location (struct breakpoint *bpt)
5667 struct bp_location *loc;
5669 loc = xmalloc (sizeof (struct bp_location));
5670 memset (loc, 0, sizeof (*loc));
5674 loc->shlib_disabled = 0;
5683 case bp_longjmp_resume:
5685 case bp_exception_resume:
5686 case bp_step_resume:
5687 case bp_watchpoint_scope:
5689 case bp_std_terminate:
5690 case bp_shlib_event:
5691 case bp_thread_event:
5692 case bp_overlay_event:
5694 case bp_longjmp_master:
5695 case bp_std_terminate_master:
5696 case bp_exception_master:
5697 case bp_gnu_ifunc_resolver:
5698 case bp_gnu_ifunc_resolver_return:
5699 loc->loc_type = bp_loc_software_breakpoint;
5701 case bp_hardware_breakpoint:
5702 loc->loc_type = bp_loc_hardware_breakpoint;
5704 case bp_hardware_watchpoint:
5705 case bp_read_watchpoint:
5706 case bp_access_watchpoint:
5707 loc->loc_type = bp_loc_hardware_watchpoint;
5712 case bp_fast_tracepoint:
5713 case bp_static_tracepoint:
5714 loc->loc_type = bp_loc_other;
5717 internal_error (__FILE__, __LINE__, _("unknown breakpoint type"));
5725 free_bp_location (struct bp_location *loc)
5730 if (loc->function_name)
5731 xfree (loc->function_name);
5736 /* Increment reference count. */
5739 incref_bp_location (struct bp_location *bl)
5744 /* Decrement reference count. If the reference count reaches 0,
5745 destroy the bp_location. Sets *BLP to NULL. */
5748 decref_bp_location (struct bp_location **blp)
5750 gdb_assert ((*blp)->refc > 0);
5752 if (--(*blp)->refc == 0)
5753 free_bp_location (*blp);
5757 /* Helper to set_raw_breakpoint below. Creates a breakpoint that has
5758 type BPTYPE and has no locations as yet. */
5759 /* This function is used in gdbtk sources and thus can not be made
5762 static struct breakpoint *
5763 set_raw_breakpoint_without_location (struct gdbarch *gdbarch,
5766 struct breakpoint *b, *b1;
5768 b = (struct breakpoint *) xmalloc (sizeof (struct breakpoint));
5769 memset (b, 0, sizeof (*b));
5772 b->gdbarch = gdbarch;
5773 b->language = current_language->la_language;
5774 b->input_radix = input_radix;
5776 b->enable_state = bp_enabled;
5779 b->ignore_count = 0;
5781 b->frame_id = null_frame_id;
5782 b->forked_inferior_pid = null_ptid;
5783 b->exec_pathname = NULL;
5784 b->syscalls_to_be_caught = NULL;
5786 b->condition_not_parsed = 0;
5787 b->py_bp_object = NULL;
5788 b->related_breakpoint = b;
5790 /* Add this breakpoint to the end of the chain so that a list of
5791 breakpoints will come out in order of increasing numbers. */
5793 b1 = breakpoint_chain;
5795 breakpoint_chain = b;
5805 /* Initialize loc->function_name. EXPLICIT_LOC says no indirect function
5806 resolutions should be made as the user specified the location explicitly
5810 set_breakpoint_location_function (struct bp_location *loc, int explicit_loc)
5812 gdb_assert (loc->owner != NULL);
5814 if (loc->owner->type == bp_breakpoint
5815 || loc->owner->type == bp_hardware_breakpoint
5816 || is_tracepoint (loc->owner))
5820 find_pc_partial_function_gnu_ifunc (loc->address, &loc->function_name,
5821 NULL, NULL, &is_gnu_ifunc);
5823 if (is_gnu_ifunc && !explicit_loc)
5825 struct breakpoint *b = loc->owner;
5827 gdb_assert (loc->pspace == current_program_space);
5828 if (gnu_ifunc_resolve_name (loc->function_name,
5829 &loc->requested_address))
5831 /* Recalculate ADDRESS based on new REQUESTED_ADDRESS. */
5832 loc->address = adjust_breakpoint_address (loc->gdbarch,
5833 loc->requested_address,
5836 else if (b->type == bp_breakpoint && b->loc == loc
5837 && loc->next == NULL && b->related_breakpoint == b)
5839 /* Create only the whole new breakpoint of this type but do not
5840 mess more complicated breakpoints with multiple locations. */
5841 b->type = bp_gnu_ifunc_resolver;
5845 if (loc->function_name)
5846 loc->function_name = xstrdup (loc->function_name);
5850 /* Attempt to determine architecture of location identified by SAL. */
5851 static struct gdbarch *
5852 get_sal_arch (struct symtab_and_line sal)
5855 return get_objfile_arch (sal.section->objfile);
5857 return get_objfile_arch (sal.symtab->objfile);
5862 /* set_raw_breakpoint is a low level routine for allocating and
5863 partially initializing a breakpoint of type BPTYPE. The newly
5864 created breakpoint's address, section, source file name, and line
5865 number are provided by SAL. The newly created and partially
5866 initialized breakpoint is added to the breakpoint chain and
5867 is also returned as the value of this function.
5869 It is expected that the caller will complete the initialization of
5870 the newly created breakpoint struct as well as output any status
5871 information regarding the creation of a new breakpoint. In
5872 particular, set_raw_breakpoint does NOT set the breakpoint
5873 number! Care should be taken to not allow an error to occur
5874 prior to completing the initialization of the breakpoint. If this
5875 should happen, a bogus breakpoint will be left on the chain. */
5878 set_raw_breakpoint (struct gdbarch *gdbarch,
5879 struct symtab_and_line sal, enum bptype bptype)
5881 struct breakpoint *b = set_raw_breakpoint_without_location (gdbarch,
5883 CORE_ADDR adjusted_address;
5884 struct gdbarch *loc_gdbarch;
5886 loc_gdbarch = get_sal_arch (sal);
5888 loc_gdbarch = b->gdbarch;
5890 if (bptype != bp_catchpoint)
5891 gdb_assert (sal.pspace != NULL);
5893 /* Adjust the breakpoint's address prior to allocating a location.
5894 Once we call allocate_bp_location(), that mostly uninitialized
5895 location will be placed on the location chain. Adjustment of the
5896 breakpoint may cause target_read_memory() to be called and we do
5897 not want its scan of the location chain to find a breakpoint and
5898 location that's only been partially initialized. */
5899 adjusted_address = adjust_breakpoint_address (loc_gdbarch,
5902 b->loc = allocate_bp_location (b);
5903 b->loc->gdbarch = loc_gdbarch;
5904 b->loc->requested_address = sal.pc;
5905 b->loc->address = adjusted_address;
5906 b->loc->pspace = sal.pspace;
5908 /* Store the program space that was used to set the breakpoint, for
5909 breakpoint resetting. */
5910 b->pspace = sal.pspace;
5912 if (sal.symtab == NULL)
5913 b->source_file = NULL;
5915 b->source_file = xstrdup (sal.symtab->filename);
5916 b->loc->section = sal.section;
5917 b->line_number = sal.line;
5919 set_breakpoint_location_function (b->loc,
5920 sal.explicit_pc || sal.explicit_line);
5922 breakpoints_changed ();
5928 /* Note that the breakpoint object B describes a permanent breakpoint
5929 instruction, hard-wired into the inferior's code. */
5931 make_breakpoint_permanent (struct breakpoint *b)
5933 struct bp_location *bl;
5935 b->enable_state = bp_permanent;
5937 /* By definition, permanent breakpoints are already present in the
5938 code. Mark all locations as inserted. For now,
5939 make_breakpoint_permanent is called in just one place, so it's
5940 hard to say if it's reasonable to have permanent breakpoint with
5941 multiple locations or not, but it's easy to implmement. */
5942 for (bl = b->loc; bl; bl = bl->next)
5946 /* Call this routine when stepping and nexting to enable a breakpoint
5947 if we do a longjmp() or 'throw' in TP. FRAME is the frame which
5948 initiated the operation. */
5951 set_longjmp_breakpoint (struct thread_info *tp, struct frame_id frame)
5953 struct breakpoint *b, *b_tmp;
5954 int thread = tp->num;
5956 /* To avoid having to rescan all objfile symbols at every step,
5957 we maintain a list of continually-inserted but always disabled
5958 longjmp "master" breakpoints. Here, we simply create momentary
5959 clones of those and enable them for the requested thread. */
5960 ALL_BREAKPOINTS_SAFE (b, b_tmp)
5961 if (b->pspace == current_program_space
5962 && (b->type == bp_longjmp_master
5963 || b->type == bp_exception_master))
5965 struct breakpoint *clone = clone_momentary_breakpoint (b);
5967 clone->type = b->type == bp_longjmp_master ? bp_longjmp : bp_exception;
5968 clone->thread = thread;
5971 tp->initiating_frame = frame;
5974 /* Delete all longjmp breakpoints from THREAD. */
5976 delete_longjmp_breakpoint (int thread)
5978 struct breakpoint *b, *b_tmp;
5980 ALL_BREAKPOINTS_SAFE (b, b_tmp)
5981 if (b->type == bp_longjmp || b->type == bp_exception)
5983 if (b->thread == thread)
5984 delete_breakpoint (b);
5989 enable_overlay_breakpoints (void)
5991 struct breakpoint *b;
5994 if (b->type == bp_overlay_event)
5996 b->enable_state = bp_enabled;
5997 update_global_location_list (1);
5998 overlay_events_enabled = 1;
6003 disable_overlay_breakpoints (void)
6005 struct breakpoint *b;
6008 if (b->type == bp_overlay_event)
6010 b->enable_state = bp_disabled;
6011 update_global_location_list (0);
6012 overlay_events_enabled = 0;
6016 /* Set an active std::terminate breakpoint for each std::terminate
6017 master breakpoint. */
6019 set_std_terminate_breakpoint (void)
6021 struct breakpoint *b, *b_tmp;
6023 ALL_BREAKPOINTS_SAFE (b, b_tmp)
6024 if (b->pspace == current_program_space
6025 && b->type == bp_std_terminate_master)
6027 struct breakpoint *clone = clone_momentary_breakpoint (b);
6028 clone->type = bp_std_terminate;
6032 /* Delete all the std::terminate breakpoints. */
6034 delete_std_terminate_breakpoint (void)
6036 struct breakpoint *b, *b_tmp;
6038 ALL_BREAKPOINTS_SAFE (b, b_tmp)
6039 if (b->type == bp_std_terminate)
6040 delete_breakpoint (b);
6044 create_thread_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
6046 struct breakpoint *b;
6048 b = create_internal_breakpoint (gdbarch, address, bp_thread_event);
6050 b->enable_state = bp_enabled;
6051 /* addr_string has to be used or breakpoint_re_set will delete me. */
6053 = xstrprintf ("*%s", paddress (b->loc->gdbarch, b->loc->address));
6055 update_global_location_list_nothrow (1);
6061 remove_thread_event_breakpoints (void)
6063 struct breakpoint *b, *b_tmp;
6065 ALL_BREAKPOINTS_SAFE (b, b_tmp)
6066 if (b->type == bp_thread_event
6067 && b->loc->pspace == current_program_space)
6068 delete_breakpoint (b);
6071 struct lang_and_radix
6077 /* Create a breakpoint for JIT code registration and unregistration. */
6080 create_jit_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
6082 struct breakpoint *b;
6084 b = create_internal_breakpoint (gdbarch, address, bp_jit_event);
6085 update_global_location_list_nothrow (1);
6089 /* Remove JIT code registration and unregistration breakpoint(s). */
6092 remove_jit_event_breakpoints (void)
6094 struct breakpoint *b, *b_tmp;
6096 ALL_BREAKPOINTS_SAFE (b, b_tmp)
6097 if (b->type == bp_jit_event
6098 && b->loc->pspace == current_program_space)
6099 delete_breakpoint (b);
6103 remove_solib_event_breakpoints (void)
6105 struct breakpoint *b, *b_tmp;
6107 ALL_BREAKPOINTS_SAFE (b, b_tmp)
6108 if (b->type == bp_shlib_event
6109 && b->loc->pspace == current_program_space)
6110 delete_breakpoint (b);
6114 create_solib_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
6116 struct breakpoint *b;
6118 b = create_internal_breakpoint (gdbarch, address, bp_shlib_event);
6119 update_global_location_list_nothrow (1);
6123 /* Disable any breakpoints that are on code in shared libraries. Only
6124 apply to enabled breakpoints, disabled ones can just stay disabled. */
6127 disable_breakpoints_in_shlibs (void)
6129 struct bp_location *loc, **locp_tmp;
6131 ALL_BP_LOCATIONS (loc, locp_tmp)
6133 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
6134 struct breakpoint *b = loc->owner;
6136 /* We apply the check to all breakpoints, including disabled for
6137 those with loc->duplicate set. This is so that when breakpoint
6138 becomes enabled, or the duplicate is removed, gdb will try to
6139 insert all breakpoints. If we don't set shlib_disabled here,
6140 we'll try to insert those breakpoints and fail. */
6141 if (((b->type == bp_breakpoint)
6142 || (b->type == bp_jit_event)
6143 || (b->type == bp_hardware_breakpoint)
6144 || (is_tracepoint (b)))
6145 && loc->pspace == current_program_space
6146 && !loc->shlib_disabled
6148 && PC_SOLIB (loc->address)
6150 && solib_name_from_address (loc->pspace, loc->address)
6154 loc->shlib_disabled = 1;
6159 /* Disable any breakpoints that are in an unloaded shared library.
6160 Only apply to enabled breakpoints, disabled ones can just stay
6164 disable_breakpoints_in_unloaded_shlib (struct so_list *solib)
6166 struct bp_location *loc, **locp_tmp;
6167 int disabled_shlib_breaks = 0;
6169 /* SunOS a.out shared libraries are always mapped, so do not
6170 disable breakpoints; they will only be reported as unloaded
6171 through clear_solib when GDB discards its shared library
6172 list. See clear_solib for more information. */
6173 if (exec_bfd != NULL
6174 && bfd_get_flavour (exec_bfd) == bfd_target_aout_flavour)
6177 ALL_BP_LOCATIONS (loc, locp_tmp)
6179 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
6180 struct breakpoint *b = loc->owner;
6182 if ((loc->loc_type == bp_loc_hardware_breakpoint
6183 || loc->loc_type == bp_loc_software_breakpoint)
6184 && solib->pspace == loc->pspace
6185 && !loc->shlib_disabled
6186 && (b->type == bp_breakpoint
6187 || b->type == bp_jit_event
6188 || b->type == bp_hardware_breakpoint)
6189 && solib_contains_address_p (solib, loc->address))
6191 loc->shlib_disabled = 1;
6192 /* At this point, we cannot rely on remove_breakpoint
6193 succeeding so we must mark the breakpoint as not inserted
6194 to prevent future errors occurring in remove_breakpoints. */
6197 /* This may cause duplicate notifications for the same breakpoint. */
6198 observer_notify_breakpoint_modified (b);
6200 if (!disabled_shlib_breaks)
6202 target_terminal_ours_for_output ();
6203 warning (_("Temporarily disabling breakpoints "
6204 "for unloaded shared library \"%s\""),
6207 disabled_shlib_breaks = 1;
6212 /* FORK & VFORK catchpoints. */
6214 /* Implement the "insert" breakpoint_ops method for fork
6218 insert_catch_fork (struct bp_location *bl)
6220 return target_insert_fork_catchpoint (PIDGET (inferior_ptid));
6223 /* Implement the "remove" breakpoint_ops method for fork
6227 remove_catch_fork (struct bp_location *bl)
6229 return target_remove_fork_catchpoint (PIDGET (inferior_ptid));
6232 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
6236 breakpoint_hit_catch_fork (const struct bp_location *bl,
6237 struct address_space *aspace, CORE_ADDR bp_addr)
6239 return inferior_has_forked (inferior_ptid, &bl->owner->forked_inferior_pid);
6242 /* Implement the "print_it" breakpoint_ops method for fork
6245 static enum print_stop_action
6246 print_it_catch_fork (struct breakpoint *b)
6248 annotate_catchpoint (b->number);
6249 printf_filtered (_("\nCatchpoint %d (forked process %d), "),
6250 b->number, ptid_get_pid (b->forked_inferior_pid));
6251 return PRINT_SRC_AND_LOC;
6254 /* Implement the "print_one" breakpoint_ops method for fork
6258 print_one_catch_fork (struct breakpoint *b, struct bp_location **last_loc)
6260 struct value_print_options opts;
6262 get_user_print_options (&opts);
6264 /* Field 4, the address, is omitted (which makes the columns not
6265 line up too nicely with the headers, but the effect is relatively
6267 if (opts.addressprint)
6268 ui_out_field_skip (uiout, "addr");
6270 ui_out_text (uiout, "fork");
6271 if (!ptid_equal (b->forked_inferior_pid, null_ptid))
6273 ui_out_text (uiout, ", process ");
6274 ui_out_field_int (uiout, "what",
6275 ptid_get_pid (b->forked_inferior_pid));
6276 ui_out_spaces (uiout, 1);
6280 /* Implement the "print_mention" breakpoint_ops method for fork
6284 print_mention_catch_fork (struct breakpoint *b)
6286 printf_filtered (_("Catchpoint %d (fork)"), b->number);
6289 /* Implement the "print_recreate" breakpoint_ops method for fork
6293 print_recreate_catch_fork (struct breakpoint *b, struct ui_file *fp)
6295 fprintf_unfiltered (fp, "catch fork");
6298 /* The breakpoint_ops structure to be used in fork catchpoints. */
6300 static struct breakpoint_ops catch_fork_breakpoint_ops =
6304 breakpoint_hit_catch_fork,
6305 NULL, /* resources_needed */
6306 print_it_catch_fork,
6307 print_one_catch_fork,
6308 NULL, /* print_one_detail */
6309 print_mention_catch_fork,
6310 print_recreate_catch_fork
6313 /* Implement the "insert" breakpoint_ops method for vfork
6317 insert_catch_vfork (struct bp_location *bl)
6319 return target_insert_vfork_catchpoint (PIDGET (inferior_ptid));
6322 /* Implement the "remove" breakpoint_ops method for vfork
6326 remove_catch_vfork (struct bp_location *bl)
6328 return target_remove_vfork_catchpoint (PIDGET (inferior_ptid));
6331 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
6335 breakpoint_hit_catch_vfork (const struct bp_location *bl,
6336 struct address_space *aspace, CORE_ADDR bp_addr)
6338 return inferior_has_vforked (inferior_ptid, &bl->owner->forked_inferior_pid);
6341 /* Implement the "print_it" breakpoint_ops method for vfork
6344 static enum print_stop_action
6345 print_it_catch_vfork (struct breakpoint *b)
6347 annotate_catchpoint (b->number);
6348 printf_filtered (_("\nCatchpoint %d (vforked process %d), "),
6349 b->number, ptid_get_pid (b->forked_inferior_pid));
6350 return PRINT_SRC_AND_LOC;
6353 /* Implement the "print_one" breakpoint_ops method for vfork
6357 print_one_catch_vfork (struct breakpoint *b, struct bp_location **last_loc)
6359 struct value_print_options opts;
6361 get_user_print_options (&opts);
6362 /* Field 4, the address, is omitted (which makes the columns not
6363 line up too nicely with the headers, but the effect is relatively
6365 if (opts.addressprint)
6366 ui_out_field_skip (uiout, "addr");
6368 ui_out_text (uiout, "vfork");
6369 if (!ptid_equal (b->forked_inferior_pid, null_ptid))
6371 ui_out_text (uiout, ", process ");
6372 ui_out_field_int (uiout, "what",
6373 ptid_get_pid (b->forked_inferior_pid));
6374 ui_out_spaces (uiout, 1);
6378 /* Implement the "print_mention" breakpoint_ops method for vfork
6382 print_mention_catch_vfork (struct breakpoint *b)
6384 printf_filtered (_("Catchpoint %d (vfork)"), b->number);
6387 /* Implement the "print_recreate" breakpoint_ops method for vfork
6391 print_recreate_catch_vfork (struct breakpoint *b, struct ui_file *fp)
6393 fprintf_unfiltered (fp, "catch vfork");
6396 /* The breakpoint_ops structure to be used in vfork catchpoints. */
6398 static struct breakpoint_ops catch_vfork_breakpoint_ops =
6402 breakpoint_hit_catch_vfork,
6403 NULL, /* resources_needed */
6404 print_it_catch_vfork,
6405 print_one_catch_vfork,
6406 NULL, /* print_one_detail */
6407 print_mention_catch_vfork,
6408 print_recreate_catch_vfork
6411 /* Implement the "insert" breakpoint_ops method for syscall
6415 insert_catch_syscall (struct bp_location *bl)
6417 struct inferior *inf = current_inferior ();
6419 ++inf->total_syscalls_count;
6420 if (!bl->owner->syscalls_to_be_caught)
6421 ++inf->any_syscall_count;
6427 VEC_iterate (int, bl->owner->syscalls_to_be_caught, i, iter);
6432 if (iter >= VEC_length (int, inf->syscalls_counts))
6434 int old_size = VEC_length (int, inf->syscalls_counts);
6435 uintptr_t vec_addr_offset
6436 = old_size * ((uintptr_t) sizeof (int));
6438 VEC_safe_grow (int, inf->syscalls_counts, iter + 1);
6439 vec_addr = (uintptr_t) VEC_address (int, inf->syscalls_counts) +
6441 memset ((void *) vec_addr, 0,
6442 (iter + 1 - old_size) * sizeof (int));
6444 elem = VEC_index (int, inf->syscalls_counts, iter);
6445 VEC_replace (int, inf->syscalls_counts, iter, ++elem);
6449 return target_set_syscall_catchpoint (PIDGET (inferior_ptid),
6450 inf->total_syscalls_count != 0,
6451 inf->any_syscall_count,
6452 VEC_length (int, inf->syscalls_counts),
6453 VEC_address (int, inf->syscalls_counts));
6456 /* Implement the "remove" breakpoint_ops method for syscall
6460 remove_catch_syscall (struct bp_location *bl)
6462 struct inferior *inf = current_inferior ();
6464 --inf->total_syscalls_count;
6465 if (!bl->owner->syscalls_to_be_caught)
6466 --inf->any_syscall_count;
6472 VEC_iterate (int, bl->owner->syscalls_to_be_caught, i, iter);
6476 if (iter >= VEC_length (int, inf->syscalls_counts))
6477 /* Shouldn't happen. */
6479 elem = VEC_index (int, inf->syscalls_counts, iter);
6480 VEC_replace (int, inf->syscalls_counts, iter, --elem);
6484 return target_set_syscall_catchpoint (PIDGET (inferior_ptid),
6485 inf->total_syscalls_count != 0,
6486 inf->any_syscall_count,
6487 VEC_length (int, inf->syscalls_counts),
6489 inf->syscalls_counts));
6492 /* Implement the "breakpoint_hit" breakpoint_ops method for syscall
6496 breakpoint_hit_catch_syscall (const struct bp_location *bl,
6497 struct address_space *aspace, CORE_ADDR bp_addr)
6499 /* We must check if we are catching specific syscalls in this
6500 breakpoint. If we are, then we must guarantee that the called
6501 syscall is the same syscall we are catching. */
6502 int syscall_number = 0;
6503 const struct breakpoint *b = bl->owner;
6505 if (!inferior_has_called_syscall (inferior_ptid, &syscall_number))
6508 /* Now, checking if the syscall is the same. */
6509 if (b->syscalls_to_be_caught)
6514 VEC_iterate (int, b->syscalls_to_be_caught, i, iter);
6516 if (syscall_number == iter)
6526 /* Implement the "print_it" breakpoint_ops method for syscall
6529 static enum print_stop_action
6530 print_it_catch_syscall (struct breakpoint *b)
6532 /* These are needed because we want to know in which state a
6533 syscall is. It can be in the TARGET_WAITKIND_SYSCALL_ENTRY
6534 or TARGET_WAITKIND_SYSCALL_RETURN, and depending on it we
6535 must print "called syscall" or "returned from syscall". */
6537 struct target_waitstatus last;
6539 struct cleanup *old_chain;
6542 get_last_target_status (&ptid, &last);
6544 get_syscall_by_number (last.value.syscall_number, &s);
6546 annotate_catchpoint (b->number);
6549 syscall_id = xstrprintf ("%d", last.value.syscall_number);
6551 syscall_id = xstrprintf ("'%s'", s.name);
6553 old_chain = make_cleanup (xfree, syscall_id);
6555 if (last.kind == TARGET_WAITKIND_SYSCALL_ENTRY)
6556 printf_filtered (_("\nCatchpoint %d (call to syscall %s), "),
6557 b->number, syscall_id);
6558 else if (last.kind == TARGET_WAITKIND_SYSCALL_RETURN)
6559 printf_filtered (_("\nCatchpoint %d (returned from syscall %s), "),
6560 b->number, syscall_id);
6562 do_cleanups (old_chain);
6564 return PRINT_SRC_AND_LOC;
6567 /* Implement the "print_one" breakpoint_ops method for syscall
6571 print_one_catch_syscall (struct breakpoint *b,
6572 struct bp_location **last_loc)
6574 struct value_print_options opts;
6576 get_user_print_options (&opts);
6577 /* Field 4, the address, is omitted (which makes the columns not
6578 line up too nicely with the headers, but the effect is relatively
6580 if (opts.addressprint)
6581 ui_out_field_skip (uiout, "addr");
6584 if (b->syscalls_to_be_caught
6585 && VEC_length (int, b->syscalls_to_be_caught) > 1)
6586 ui_out_text (uiout, "syscalls \"");
6588 ui_out_text (uiout, "syscall \"");
6590 if (b->syscalls_to_be_caught)
6593 char *text = xstrprintf ("%s", "");
6596 VEC_iterate (int, b->syscalls_to_be_caught, i, iter);
6601 get_syscall_by_number (iter, &s);
6604 text = xstrprintf ("%s%s, ", text, s.name);
6606 text = xstrprintf ("%s%d, ", text, iter);
6608 /* We have to xfree the last 'text' (now stored at 'x')
6609 because xstrprintf dinamically allocates new space for it
6613 /* Remove the last comma. */
6614 text[strlen (text) - 2] = '\0';
6615 ui_out_field_string (uiout, "what", text);
6618 ui_out_field_string (uiout, "what", "<any syscall>");
6619 ui_out_text (uiout, "\" ");
6622 /* Implement the "print_mention" breakpoint_ops method for syscall
6626 print_mention_catch_syscall (struct breakpoint *b)
6628 if (b->syscalls_to_be_caught)
6632 if (VEC_length (int, b->syscalls_to_be_caught) > 1)
6633 printf_filtered (_("Catchpoint %d (syscalls"), b->number);
6635 printf_filtered (_("Catchpoint %d (syscall"), b->number);
6638 VEC_iterate (int, b->syscalls_to_be_caught, i, iter);
6642 get_syscall_by_number (iter, &s);
6645 printf_filtered (" '%s' [%d]", s.name, s.number);
6647 printf_filtered (" %d", s.number);
6649 printf_filtered (")");
6652 printf_filtered (_("Catchpoint %d (any syscall)"),
6656 /* Implement the "print_recreate" breakpoint_ops method for syscall
6660 print_recreate_catch_syscall (struct breakpoint *b, struct ui_file *fp)
6662 fprintf_unfiltered (fp, "catch syscall");
6664 if (b->syscalls_to_be_caught)
6669 VEC_iterate (int, b->syscalls_to_be_caught, i, iter);
6674 get_syscall_by_number (iter, &s);
6676 fprintf_unfiltered (fp, " %s", s.name);
6678 fprintf_unfiltered (fp, " %d", s.number);
6683 /* The breakpoint_ops structure to be used in syscall catchpoints. */
6685 static struct breakpoint_ops catch_syscall_breakpoint_ops =
6687 insert_catch_syscall,
6688 remove_catch_syscall,
6689 breakpoint_hit_catch_syscall,
6690 NULL, /* resources_needed */
6691 print_it_catch_syscall,
6692 print_one_catch_syscall,
6693 NULL, /* print_one_detail */
6694 print_mention_catch_syscall,
6695 print_recreate_catch_syscall
6698 /* Returns non-zero if 'b' is a syscall catchpoint. */
6701 syscall_catchpoint_p (struct breakpoint *b)
6703 return (b->ops == &catch_syscall_breakpoint_ops);
6706 /* Create a new breakpoint of the bp_catchpoint kind and return it,
6707 but does NOT mention it nor update the global location list.
6708 This is useful if you need to fill more fields in the
6709 struct breakpoint before calling mention.
6711 If TEMPFLAG is non-zero, then make the breakpoint temporary.
6712 If COND_STRING is not NULL, then store it in the breakpoint.
6713 OPS, if not NULL, is the breakpoint_ops structure associated
6714 to the catchpoint. */
6716 static struct breakpoint *
6717 create_catchpoint_without_mention (struct gdbarch *gdbarch, int tempflag,
6719 struct breakpoint_ops *ops)
6721 struct symtab_and_line sal;
6722 struct breakpoint *b;
6725 sal.pspace = current_program_space;
6727 b = set_raw_breakpoint (gdbarch, sal, bp_catchpoint);
6728 set_breakpoint_count (breakpoint_count + 1);
6729 b->number = breakpoint_count;
6731 b->cond_string = (cond_string == NULL) ? NULL : xstrdup (cond_string);
6733 b->addr_string = NULL;
6734 b->enable_state = bp_enabled;
6735 b->disposition = tempflag ? disp_del : disp_donttouch;
6741 /* Create a new breakpoint of the bp_catchpoint kind and return it.
6743 If TEMPFLAG is non-zero, then make the breakpoint temporary.
6744 If COND_STRING is not NULL, then store it in the breakpoint.
6745 OPS, if not NULL, is the breakpoint_ops structure associated
6746 to the catchpoint. */
6748 static struct breakpoint *
6749 create_catchpoint (struct gdbarch *gdbarch, int tempflag,
6750 char *cond_string, struct breakpoint_ops *ops)
6752 struct breakpoint *b =
6753 create_catchpoint_without_mention (gdbarch, tempflag, cond_string, ops);
6756 observer_notify_breakpoint_created (b);
6757 update_global_location_list (1);
6763 create_fork_vfork_event_catchpoint (struct gdbarch *gdbarch,
6764 int tempflag, char *cond_string,
6765 struct breakpoint_ops *ops)
6767 struct breakpoint *b
6768 = create_catchpoint (gdbarch, tempflag, cond_string, ops);
6770 /* FIXME: We should put this information in a breakpoint private data
6772 b->forked_inferior_pid = null_ptid;
6775 /* Exec catchpoints. */
6778 insert_catch_exec (struct bp_location *bl)
6780 return target_insert_exec_catchpoint (PIDGET (inferior_ptid));
6784 remove_catch_exec (struct bp_location *bl)
6786 return target_remove_exec_catchpoint (PIDGET (inferior_ptid));
6790 breakpoint_hit_catch_exec (const struct bp_location *bl,
6791 struct address_space *aspace, CORE_ADDR bp_addr)
6793 return inferior_has_execd (inferior_ptid, &bl->owner->exec_pathname);
6796 static enum print_stop_action
6797 print_it_catch_exec (struct breakpoint *b)
6799 annotate_catchpoint (b->number);
6800 printf_filtered (_("\nCatchpoint %d (exec'd %s), "), b->number,
6802 return PRINT_SRC_AND_LOC;
6806 print_one_catch_exec (struct breakpoint *b, struct bp_location **last_loc)
6808 struct value_print_options opts;
6810 get_user_print_options (&opts);
6812 /* Field 4, the address, is omitted (which makes the columns
6813 not line up too nicely with the headers, but the effect
6814 is relatively readable). */
6815 if (opts.addressprint)
6816 ui_out_field_skip (uiout, "addr");
6818 ui_out_text (uiout, "exec");
6819 if (b->exec_pathname != NULL)
6821 ui_out_text (uiout, ", program \"");
6822 ui_out_field_string (uiout, "what", b->exec_pathname);
6823 ui_out_text (uiout, "\" ");
6828 print_mention_catch_exec (struct breakpoint *b)
6830 printf_filtered (_("Catchpoint %d (exec)"), b->number);
6833 /* Implement the "print_recreate" breakpoint_ops method for exec
6837 print_recreate_catch_exec (struct breakpoint *b, struct ui_file *fp)
6839 fprintf_unfiltered (fp, "catch exec");
6842 static struct breakpoint_ops catch_exec_breakpoint_ops =
6846 breakpoint_hit_catch_exec,
6847 NULL, /* resources_needed */
6848 print_it_catch_exec,
6849 print_one_catch_exec,
6850 NULL, /* print_one_detail */
6851 print_mention_catch_exec,
6852 print_recreate_catch_exec
6856 create_syscall_event_catchpoint (int tempflag, VEC(int) *filter,
6857 struct breakpoint_ops *ops)
6859 struct gdbarch *gdbarch = get_current_arch ();
6860 struct breakpoint *b =
6861 create_catchpoint_without_mention (gdbarch, tempflag, NULL, ops);
6863 b->syscalls_to_be_caught = filter;
6865 /* Now, we have to mention the breakpoint and update the global
6868 observer_notify_breakpoint_created (b);
6869 update_global_location_list (1);
6873 hw_breakpoint_used_count (void)
6876 struct breakpoint *b;
6877 struct bp_location *bl;
6881 if (b->type == bp_hardware_breakpoint && breakpoint_enabled (b))
6882 for (bl = b->loc; bl; bl = bl->next)
6884 /* Special types of hardware breakpoints may use more than
6886 if (b->ops && b->ops->resources_needed)
6887 i += b->ops->resources_needed (bl);
6897 hw_watchpoint_used_count (enum bptype type, int *other_type_used)
6900 struct breakpoint *b;
6901 struct bp_location *bl;
6903 *other_type_used = 0;
6906 if (!breakpoint_enabled (b))
6909 if (b->type == type)
6910 for (bl = b->loc; bl; bl = bl->next)
6912 /* Special types of hardware watchpoints may use more than
6914 if (b->ops && b->ops->resources_needed)
6915 i += b->ops->resources_needed (bl);
6919 else if (is_hardware_watchpoint (b))
6920 *other_type_used = 1;
6927 disable_watchpoints_before_interactive_call_start (void)
6929 struct breakpoint *b;
6933 if (is_watchpoint (b) && breakpoint_enabled (b))
6935 b->enable_state = bp_call_disabled;
6936 update_global_location_list (0);
6942 enable_watchpoints_after_interactive_call_stop (void)
6944 struct breakpoint *b;
6948 if (is_watchpoint (b) && b->enable_state == bp_call_disabled)
6950 b->enable_state = bp_enabled;
6951 update_global_location_list (1);
6957 disable_breakpoints_before_startup (void)
6959 struct breakpoint *b;
6964 if (b->pspace != current_program_space)
6967 if ((b->type == bp_breakpoint
6968 || b->type == bp_hardware_breakpoint)
6969 && breakpoint_enabled (b))
6971 b->enable_state = bp_startup_disabled;
6977 update_global_location_list (0);
6979 current_program_space->executing_startup = 1;
6983 enable_breakpoints_after_startup (void)
6985 struct breakpoint *b;
6988 current_program_space->executing_startup = 0;
6992 if (b->pspace != current_program_space)
6995 if ((b->type == bp_breakpoint
6996 || b->type == bp_hardware_breakpoint)
6997 && b->enable_state == bp_startup_disabled)
6999 b->enable_state = bp_enabled;
7005 breakpoint_re_set ();
7009 /* Set a breakpoint that will evaporate an end of command
7010 at address specified by SAL.
7011 Restrict it to frame FRAME if FRAME is nonzero. */
7014 set_momentary_breakpoint (struct gdbarch *gdbarch, struct symtab_and_line sal,
7015 struct frame_id frame_id, enum bptype type)
7017 struct breakpoint *b;
7019 /* If FRAME_ID is valid, it should be a real frame, not an inlined
7021 gdb_assert (!frame_id_inlined_p (frame_id));
7023 b = set_raw_breakpoint (gdbarch, sal, type);
7024 b->enable_state = bp_enabled;
7025 b->disposition = disp_donttouch;
7026 b->frame_id = frame_id;
7028 /* If we're debugging a multi-threaded program, then we want
7029 momentary breakpoints to be active in only a single thread of
7031 if (in_thread_list (inferior_ptid))
7032 b->thread = pid_to_thread_id (inferior_ptid);
7034 update_global_location_list_nothrow (1);
7039 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
7043 clone_momentary_breakpoint (struct breakpoint *orig)
7045 struct breakpoint *copy;
7047 /* If there's nothing to clone, then return nothing. */
7051 copy = set_raw_breakpoint_without_location (orig->gdbarch, orig->type);
7052 copy->loc = allocate_bp_location (copy);
7053 set_breakpoint_location_function (copy->loc, 1);
7055 copy->loc->gdbarch = orig->loc->gdbarch;
7056 copy->loc->requested_address = orig->loc->requested_address;
7057 copy->loc->address = orig->loc->address;
7058 copy->loc->section = orig->loc->section;
7059 copy->loc->pspace = orig->loc->pspace;
7061 if (orig->source_file == NULL)
7062 copy->source_file = NULL;
7064 copy->source_file = xstrdup (orig->source_file);
7066 copy->line_number = orig->line_number;
7067 copy->frame_id = orig->frame_id;
7068 copy->thread = orig->thread;
7069 copy->pspace = orig->pspace;
7071 copy->enable_state = bp_enabled;
7072 copy->disposition = disp_donttouch;
7073 copy->number = internal_breakpoint_number--;
7075 update_global_location_list_nothrow (0);
7080 set_momentary_breakpoint_at_pc (struct gdbarch *gdbarch, CORE_ADDR pc,
7083 struct symtab_and_line sal;
7085 sal = find_pc_line (pc, 0);
7087 sal.section = find_pc_overlay (pc);
7088 sal.explicit_pc = 1;
7090 return set_momentary_breakpoint (gdbarch, sal, null_frame_id, type);
7094 /* Tell the user we have just set a breakpoint B. */
7097 mention (struct breakpoint *b)
7100 struct cleanup *ui_out_chain;
7101 struct value_print_options opts;
7103 get_user_print_options (&opts);
7105 if (b->ops != NULL && b->ops->print_mention != NULL)
7106 b->ops->print_mention (b);
7111 printf_filtered (_("(apparently deleted?) Eventpoint %d: "),
7115 ui_out_text (uiout, "Watchpoint ");
7116 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt");
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_hardware_watchpoint:
7123 ui_out_text (uiout, "Hardware watchpoint ");
7124 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt");
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);
7130 case bp_read_watchpoint:
7131 ui_out_text (uiout, "Hardware read watchpoint ");
7132 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-rwpt");
7133 ui_out_field_int (uiout, "number", b->number);
7134 ui_out_text (uiout, ": ");
7135 ui_out_field_string (uiout, "exp", b->exp_string);
7136 do_cleanups (ui_out_chain);
7138 case bp_access_watchpoint:
7139 ui_out_text (uiout, "Hardware access (read/write) watchpoint ");
7140 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-awpt");
7141 ui_out_field_int (uiout, "number", b->number);
7142 ui_out_text (uiout, ": ");
7143 ui_out_field_string (uiout, "exp", b->exp_string);
7144 do_cleanups (ui_out_chain);
7147 case bp_gnu_ifunc_resolver:
7148 if (ui_out_is_mi_like_p (uiout))
7153 if (b->disposition == disp_del)
7154 printf_filtered (_("Temporary breakpoint"));
7156 printf_filtered (_("Breakpoint"));
7157 printf_filtered (_(" %d"), b->number);
7158 if (b->type == bp_gnu_ifunc_resolver)
7159 printf_filtered (_(" at gnu-indirect-function resolver"));
7162 case bp_hardware_breakpoint:
7163 if (ui_out_is_mi_like_p (uiout))
7168 printf_filtered (_("Hardware assisted breakpoint %d"), b->number);
7172 if (ui_out_is_mi_like_p (uiout))
7177 printf_filtered (_("Tracepoint"));
7178 printf_filtered (_(" %d"), b->number);
7181 case bp_fast_tracepoint:
7182 if (ui_out_is_mi_like_p (uiout))
7187 printf_filtered (_("Fast tracepoint"));
7188 printf_filtered (_(" %d"), b->number);
7191 case bp_static_tracepoint:
7192 if (ui_out_is_mi_like_p (uiout))
7197 printf_filtered (_("Static tracepoint"));
7198 printf_filtered (_(" %d"), b->number);
7205 case bp_longjmp_resume:
7207 case bp_exception_resume:
7208 case bp_step_resume:
7210 case bp_std_terminate:
7211 case bp_watchpoint_scope:
7212 case bp_shlib_event:
7213 case bp_thread_event:
7214 case bp_overlay_event:
7216 case bp_longjmp_master:
7217 case bp_std_terminate_master:
7218 case bp_exception_master:
7219 case bp_gnu_ifunc_resolver_return:
7225 /* i18n: cagney/2005-02-11: Below needs to be merged into a
7229 printf_filtered (_(" (%s) pending."), b->addr_string);
7233 if (opts.addressprint || b->source_file == NULL)
7235 printf_filtered (" at ");
7236 fputs_filtered (paddress (b->loc->gdbarch, b->loc->address),
7240 printf_filtered (": file %s, line %d.",
7241 b->source_file, b->line_number);
7245 struct bp_location *loc = b->loc;
7247 for (; loc; loc = loc->next)
7249 printf_filtered (" (%d locations)", n);
7254 if (ui_out_is_mi_like_p (uiout))
7256 printf_filtered ("\n");
7260 static struct bp_location *
7261 add_location_to_breakpoint (struct breakpoint *b,
7262 const struct symtab_and_line *sal)
7264 struct bp_location *loc, **tmp;
7266 loc = allocate_bp_location (b);
7267 for (tmp = &(b->loc); *tmp != NULL; tmp = &((*tmp)->next))
7270 loc->gdbarch = get_sal_arch (*sal);
7272 loc->gdbarch = b->gdbarch;
7273 loc->requested_address = sal->pc;
7274 loc->address = adjust_breakpoint_address (loc->gdbarch,
7275 loc->requested_address, b->type);
7276 loc->pspace = sal->pspace;
7277 gdb_assert (loc->pspace != NULL);
7278 loc->section = sal->section;
7280 set_breakpoint_location_function (loc,
7281 sal->explicit_pc || sal->explicit_line);
7286 /* Return 1 if LOC is pointing to a permanent breakpoint,
7287 return 0 otherwise. */
7290 bp_loc_is_permanent (struct bp_location *loc)
7294 const gdb_byte *brk;
7295 gdb_byte *target_mem;
7296 struct cleanup *cleanup;
7299 gdb_assert (loc != NULL);
7301 addr = loc->address;
7302 brk = gdbarch_breakpoint_from_pc (loc->gdbarch, &addr, &len);
7304 /* Software breakpoints unsupported? */
7308 target_mem = alloca (len);
7310 /* Enable the automatic memory restoration from breakpoints while
7311 we read the memory. Otherwise we could say about our temporary
7312 breakpoints they are permanent. */
7313 cleanup = save_current_space_and_thread ();
7315 switch_to_program_space_and_thread (loc->pspace);
7316 make_show_memory_breakpoints_cleanup (0);
7318 if (target_read_memory (loc->address, target_mem, len) == 0
7319 && memcmp (target_mem, brk, len) == 0)
7322 do_cleanups (cleanup);
7329 /* Create a breakpoint with SAL as location. Use ADDR_STRING
7330 as textual description of the location, and COND_STRING
7331 as condition expression. */
7334 create_breakpoint_sal (struct gdbarch *gdbarch,
7335 struct symtabs_and_lines sals, char *addr_string,
7337 enum bptype type, enum bpdisp disposition,
7338 int thread, int task, int ignore_count,
7339 struct breakpoint_ops *ops, int from_tty,
7340 int enabled, int internal, int display_canonical)
7342 struct breakpoint *b = NULL;
7345 if (type == bp_hardware_breakpoint)
7347 int i = hw_breakpoint_used_count ();
7348 int target_resources_ok =
7349 target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
7351 if (target_resources_ok == 0)
7352 error (_("No hardware breakpoint support in the target."));
7353 else if (target_resources_ok < 0)
7354 error (_("Hardware breakpoints used exceeds limit."));
7357 gdb_assert (sals.nelts > 0);
7359 for (i = 0; i < sals.nelts; ++i)
7361 struct symtab_and_line sal = sals.sals[i];
7362 struct bp_location *loc;
7366 struct gdbarch *loc_gdbarch = get_sal_arch (sal);
7368 loc_gdbarch = gdbarch;
7370 describe_other_breakpoints (loc_gdbarch,
7371 sal.pspace, sal.pc, sal.section, thread);
7376 b = set_raw_breakpoint (gdbarch, sal, type);
7377 set_breakpoint_number (internal, b);
7381 b->cond_string = cond_string;
7382 b->ignore_count = ignore_count;
7383 b->enable_state = enabled ? bp_enabled : bp_disabled;
7384 b->disposition = disposition;
7385 b->pspace = sals.sals[0].pspace;
7387 if (type == bp_static_tracepoint)
7389 struct static_tracepoint_marker marker;
7391 if (is_marker_spec (addr_string))
7393 /* We already know the marker exists, otherwise, we
7394 wouldn't see a sal for it. */
7395 char *p = &addr_string[3];
7400 p = skip_spaces (p);
7402 endp = skip_to_space (p);
7404 marker_str = savestring (p, endp - p);
7405 b->static_trace_marker_id = marker_str;
7407 printf_filtered (_("Probed static tracepoint "
7409 b->static_trace_marker_id);
7411 else if (target_static_tracepoint_marker_at (sal.pc, &marker))
7413 b->static_trace_marker_id = xstrdup (marker.str_id);
7414 release_static_tracepoint_marker (&marker);
7416 printf_filtered (_("Probed static tracepoint "
7418 b->static_trace_marker_id);
7421 warning (_("Couldn't determine the static "
7422 "tracepoint marker to probe"));
7425 if (enabled && b->pspace->executing_startup
7426 && (b->type == bp_breakpoint
7427 || b->type == bp_hardware_breakpoint))
7428 b->enable_state = bp_startup_disabled;
7434 loc = add_location_to_breakpoint (b, &sal);
7437 if (bp_loc_is_permanent (loc))
7438 make_breakpoint_permanent (b);
7442 char *arg = b->cond_string;
7443 loc->cond = parse_exp_1 (&arg, block_for_pc (loc->address), 0);
7445 error (_("Garbage %s follows condition"), arg);
7449 b->display_canonical = display_canonical;
7451 b->addr_string = addr_string;
7453 /* addr_string has to be used or breakpoint_re_set will delete
7456 = xstrprintf ("*%s", paddress (b->loc->gdbarch, b->loc->address));
7459 /* Do not mention breakpoints with a negative number, but do
7460 notify observers. */
7463 observer_notify_breakpoint_created (b);
7466 /* Remove element at INDEX_TO_REMOVE from SAL, shifting other
7467 elements to fill the void space. */
7469 remove_sal (struct symtabs_and_lines *sal, int index_to_remove)
7471 int i = index_to_remove+1;
7472 int last_index = sal->nelts-1;
7474 for (;i <= last_index; ++i)
7475 sal->sals[i-1] = sal->sals[i];
7480 /* If appropriate, obtains all sals that correspond to the same file
7481 and line as SAL, in all program spaces. Users debugging with IDEs,
7482 will want to set a breakpoint at foo.c:line, and not really care
7483 about program spaces. This is done only if SAL does not have
7484 explicit PC and has line and file information. If we got just a
7485 single expanded sal, return the original.
7487 Otherwise, if SAL.explicit_line is not set, filter out all sals for
7488 which the name of enclosing function is different from SAL. This
7489 makes sure that if we have breakpoint originally set in template
7490 instantiation, say foo<int>(), we won't expand SAL to locations at
7491 the same line in all existing instantiations of 'foo'. */
7493 static struct symtabs_and_lines
7494 expand_line_sal_maybe (struct symtab_and_line sal)
7496 struct symtabs_and_lines expanded;
7497 CORE_ADDR original_pc = sal.pc;
7498 char *original_function = NULL;
7501 struct cleanup *old_chain;
7503 /* If we have explicit pc, don't expand.
7504 If we have no line number, we can't expand. */
7505 if (sal.explicit_pc || sal.line == 0 || sal.symtab == NULL)
7508 expanded.sals = xmalloc (sizeof (struct symtab_and_line));
7509 expanded.sals[0] = sal;
7515 old_chain = save_current_space_and_thread ();
7517 switch_to_program_space_and_thread (sal.pspace);
7519 find_pc_partial_function (original_pc, &original_function, NULL, NULL);
7521 /* Note that expand_line_sal visits *all* program spaces. */
7522 expanded = expand_line_sal (sal);
7524 if (expanded.nelts == 1)
7526 /* We had one sal, we got one sal. Return that sal, adjusting it
7527 past the function prologue if necessary. */
7528 xfree (expanded.sals);
7530 expanded.sals = xmalloc (sizeof (struct symtab_and_line));
7531 sal.pc = original_pc;
7532 expanded.sals[0] = sal;
7533 skip_prologue_sal (&expanded.sals[0]);
7534 do_cleanups (old_chain);
7538 if (!sal.explicit_line)
7540 CORE_ADDR func_addr, func_end;
7541 for (i = 0; i < expanded.nelts; ++i)
7543 CORE_ADDR pc = expanded.sals[i].pc;
7544 char *this_function;
7546 /* We need to switch threads as well since we're about to
7548 switch_to_program_space_and_thread (expanded.sals[i].pspace);
7550 if (find_pc_partial_function (pc, &this_function,
7551 &func_addr, &func_end))
7554 && strcmp (this_function, original_function) != 0)
7556 remove_sal (&expanded, i);
7563 /* Skip the function prologue if necessary. */
7564 for (i = 0; i < expanded.nelts; ++i)
7565 skip_prologue_sal (&expanded.sals[i]);
7567 do_cleanups (old_chain);
7569 if (expanded.nelts <= 1)
7571 /* This is un ugly workaround. If we get zero expanded sals
7572 then something is really wrong. Fix that by returning the
7575 xfree (expanded.sals);
7577 expanded.sals = xmalloc (sizeof (struct symtab_and_line));
7578 sal.pc = original_pc;
7579 expanded.sals[0] = sal;
7586 for (i = 0; i < expanded.nelts; ++i)
7587 if (expanded.sals[i].pc == original_pc)
7598 /* Add SALS.nelts breakpoints to the breakpoint table. For each
7599 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
7600 value. COND_STRING, if not NULL, specified the condition to be
7601 used for all breakpoints. Essentially the only case where
7602 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
7603 function. In that case, it's still not possible to specify
7604 separate conditions for different overloaded functions, so
7605 we take just a single condition string.
7607 NOTE: If the function succeeds, the caller is expected to cleanup
7608 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
7609 array contents). If the function fails (error() is called), the
7610 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
7611 COND and SALS arrays and each of those arrays contents. */
7614 create_breakpoints_sal (struct gdbarch *gdbarch,
7615 struct symtabs_and_lines sals,
7616 struct linespec_result *canonical,
7618 enum bptype type, enum bpdisp disposition,
7619 int thread, int task, int ignore_count,
7620 struct breakpoint_ops *ops, int from_tty,
7621 int enabled, int internal)
7625 for (i = 0; i < sals.nelts; ++i)
7627 struct symtabs_and_lines expanded =
7628 expand_line_sal_maybe (sals.sals[i]);
7630 create_breakpoint_sal (gdbarch, expanded, canonical->canonical[i],
7631 cond_string, type, disposition,
7632 thread, task, ignore_count, ops,
7633 from_tty, enabled, internal,
7634 canonical->special_display);
7638 /* Parse ADDRESS which is assumed to be a SAL specification possibly
7639 followed by conditionals. On return, SALS contains an array of SAL
7640 addresses found. ADDR_STRING contains a vector of (canonical)
7641 address strings. ADDRESS points to the end of the SAL.
7643 The array and the line spec strings are allocated on the heap, it is
7644 the caller's responsibility to free them. */
7647 parse_breakpoint_sals (char **address,
7648 struct symtabs_and_lines *sals,
7649 struct linespec_result *canonical)
7651 char *addr_start = *address;
7653 /* If no arg given, or if first arg is 'if ', use the default
7655 if ((*address) == NULL
7656 || (strncmp ((*address), "if", 2) == 0 && isspace ((*address)[2])))
7658 if (default_breakpoint_valid)
7660 struct symtab_and_line sal;
7662 init_sal (&sal); /* Initialize to zeroes. */
7663 sals->sals = (struct symtab_and_line *)
7664 xmalloc (sizeof (struct symtab_and_line));
7665 sal.pc = default_breakpoint_address;
7666 sal.line = default_breakpoint_line;
7667 sal.symtab = default_breakpoint_symtab;
7668 sal.pspace = default_breakpoint_pspace;
7669 sal.section = find_pc_overlay (sal.pc);
7671 /* "break" without arguments is equivalent to "break *PC"
7672 where PC is the default_breakpoint_address. So make sure
7673 to set sal.explicit_pc to prevent GDB from trying to
7674 expand the list of sals to include all other instances
7675 with the same symtab and line. */
7676 sal.explicit_pc = 1;
7678 sals->sals[0] = sal;
7682 error (_("No default breakpoint address now."));
7686 /* Force almost all breakpoints to be in terms of the
7687 current_source_symtab (which is decode_line_1's default).
7688 This should produce the results we want almost all of the
7689 time while leaving default_breakpoint_* alone.
7691 ObjC: However, don't match an Objective-C method name which
7692 may have a '+' or '-' succeeded by a '[' */
7694 struct symtab_and_line cursal = get_current_source_symtab_and_line ();
7696 if (default_breakpoint_valid
7698 || ((strchr ("+-", (*address)[0]) != NULL)
7699 && ((*address)[1] != '['))))
7700 *sals = decode_line_1 (address, 1, default_breakpoint_symtab,
7701 default_breakpoint_line, canonical);
7703 *sals = decode_line_1 (address, 1, (struct symtab *) NULL, 0,
7706 /* For any SAL that didn't have a canonical string, fill one in. */
7707 if (sals->nelts > 0 && canonical->canonical == NULL)
7708 canonical->canonical = xcalloc (sals->nelts, sizeof (char *));
7709 if (addr_start != (*address))
7713 for (i = 0; i < sals->nelts; i++)
7715 /* Add the string if not present. */
7716 if (canonical->canonical[i] == NULL)
7717 canonical->canonical[i] = savestring (addr_start,
7718 (*address) - addr_start);
7724 /* Convert each SAL into a real PC. Verify that the PC can be
7725 inserted as a breakpoint. If it can't throw an error. */
7728 breakpoint_sals_to_pc (struct symtabs_and_lines *sals)
7732 for (i = 0; i < sals->nelts; i++)
7733 resolve_sal_pc (&sals->sals[i]);
7736 /* Fast tracepoints may have restrictions on valid locations. For
7737 instance, a fast tracepoint using a jump instead of a trap will
7738 likely have to overwrite more bytes than a trap would, and so can
7739 only be placed where the instruction is longer than the jump, or a
7740 multi-instruction sequence does not have a jump into the middle of
7744 check_fast_tracepoint_sals (struct gdbarch *gdbarch,
7745 struct symtabs_and_lines *sals)
7748 struct symtab_and_line *sal;
7750 struct cleanup *old_chain;
7752 for (i = 0; i < sals->nelts; i++)
7754 sal = &sals->sals[i];
7756 rslt = gdbarch_fast_tracepoint_valid_at (gdbarch, sal->pc,
7758 old_chain = make_cleanup (xfree, msg);
7761 error (_("May not have a fast tracepoint at 0x%s%s"),
7762 paddress (gdbarch, sal->pc), (msg ? msg : ""));
7764 do_cleanups (old_chain);
7768 /* Given TOK, a string specification of condition and thread, as
7769 accepted by the 'break' command, extract the condition
7770 string and thread number and set *COND_STRING and *THREAD.
7771 PC identifies the context at which the condition should be parsed.
7772 If no condition is found, *COND_STRING is set to NULL.
7773 If no thread is found, *THREAD is set to -1. */
7775 find_condition_and_thread (char *tok, CORE_ADDR pc,
7776 char **cond_string, int *thread, int *task)
7778 *cond_string = NULL;
7784 char *cond_start = NULL;
7785 char *cond_end = NULL;
7787 tok = skip_spaces (tok);
7789 end_tok = skip_to_space (tok);
7791 toklen = end_tok - tok;
7793 if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
7795 struct expression *expr;
7797 tok = cond_start = end_tok + 1;
7798 expr = parse_exp_1 (&tok, block_for_pc (pc), 0);
7801 *cond_string = savestring (cond_start,
7802 cond_end - cond_start);
7804 else if (toklen >= 1 && strncmp (tok, "thread", toklen) == 0)
7810 *thread = strtol (tok, &tok, 0);
7812 error (_("Junk after thread keyword."));
7813 if (!valid_thread_id (*thread))
7814 error (_("Unknown thread %d."), *thread);
7816 else if (toklen >= 1 && strncmp (tok, "task", toklen) == 0)
7822 *task = strtol (tok, &tok, 0);
7824 error (_("Junk after task keyword."));
7825 if (!valid_task_id (*task))
7826 error (_("Unknown task %d."), *task);
7829 error (_("Junk at end of arguments."));
7833 /* Decode a static tracepoint marker spec. */
7835 static struct symtabs_and_lines
7836 decode_static_tracepoint_spec (char **arg_p)
7838 VEC(static_tracepoint_marker_p) *markers = NULL;
7839 struct symtabs_and_lines sals;
7840 struct symtab_and_line sal;
7842 struct cleanup *old_chain;
7843 char *p = &(*arg_p)[3];
7848 p = skip_spaces (p);
7850 endp = skip_to_space (p);
7852 marker_str = savestring (p, endp - p);
7853 old_chain = make_cleanup (xfree, marker_str);
7855 markers = target_static_tracepoint_markers_by_strid (marker_str);
7856 if (VEC_empty(static_tracepoint_marker_p, markers))
7857 error (_("No known static tracepoint marker named %s"), marker_str);
7859 sals.nelts = VEC_length(static_tracepoint_marker_p, markers);
7860 sals.sals = xmalloc (sizeof *sals.sals * sals.nelts);
7862 for (i = 0; i < sals.nelts; i++)
7864 struct static_tracepoint_marker *marker;
7866 marker = VEC_index (static_tracepoint_marker_p, markers, i);
7868 init_sal (&sals.sals[i]);
7870 sals.sals[i] = find_pc_line (marker->address, 0);
7871 sals.sals[i].pc = marker->address;
7873 release_static_tracepoint_marker (marker);
7876 do_cleanups (old_chain);
7882 /* Set a breakpoint. This function is shared between CLI and MI
7883 functions for setting a breakpoint. This function has two major
7884 modes of operations, selected by the PARSE_CONDITION_AND_THREAD
7885 parameter. If non-zero, the function will parse arg, extracting
7886 breakpoint location, address and thread. Otherwise, ARG is just
7887 the location of breakpoint, with condition and thread specified by
7888 the COND_STRING and THREAD parameters. If INTERNAL is non-zero,
7889 the breakpoint number will be allocated from the internal
7890 breakpoint count. Returns true if any breakpoint was created;
7894 create_breakpoint (struct gdbarch *gdbarch,
7895 char *arg, char *cond_string, int thread,
7896 int parse_condition_and_thread,
7897 int tempflag, enum bptype type_wanted,
7899 enum auto_boolean pending_break_support,
7900 struct breakpoint_ops *ops,
7901 int from_tty, int enabled, int internal)
7903 volatile struct gdb_exception e;
7904 struct symtabs_and_lines sals;
7905 struct symtab_and_line pending_sal;
7907 char *addr_start = arg;
7908 struct linespec_result canonical;
7909 struct cleanup *old_chain;
7910 struct cleanup *bkpt_chain = NULL;
7914 int prev_bkpt_count = breakpoint_count;
7918 init_linespec_result (&canonical);
7920 if (type_wanted == bp_static_tracepoint && is_marker_spec (arg))
7924 sals = decode_static_tracepoint_spec (&arg);
7926 copy_arg = savestring (addr_start, arg - addr_start);
7927 canonical.canonical = xcalloc (sals.nelts, sizeof (char *));
7928 for (i = 0; i < sals.nelts; i++)
7929 canonical.canonical[i] = xstrdup (copy_arg);
7933 TRY_CATCH (e, RETURN_MASK_ALL)
7935 parse_breakpoint_sals (&arg, &sals, &canonical);
7938 /* If caller is interested in rc value from parse, set value. */
7942 throw_exception (e);
7946 case NOT_FOUND_ERROR:
7948 /* If pending breakpoint support is turned off, throw
7951 if (pending_break_support == AUTO_BOOLEAN_FALSE)
7952 throw_exception (e);
7954 exception_print (gdb_stderr, e);
7956 /* If pending breakpoint support is auto query and the user
7957 selects no, then simply return the error code. */
7958 if (pending_break_support == AUTO_BOOLEAN_AUTO
7959 && !nquery (_("Make breakpoint pending on "
7960 "future shared library load? ")))
7963 /* At this point, either the user was queried about setting
7964 a pending breakpoint and selected yes, or pending
7965 breakpoint behavior is on and thus a pending breakpoint
7966 is defaulted on behalf of the user. */
7967 copy_arg = xstrdup (addr_start);
7968 canonical.canonical = ©_arg;
7970 sals.sals = &pending_sal;
7975 throw_exception (e);
7985 /* Create a chain of things that always need to be cleaned up. */
7986 old_chain = make_cleanup (null_cleanup, 0);
7990 /* Make sure that all storage allocated to SALS gets freed. */
7991 make_cleanup (xfree, sals.sals);
7993 /* Cleanup the canonical array but not its contents. */
7994 make_cleanup (xfree, canonical.canonical);
7997 /* ----------------------------- SNIP -----------------------------
7998 Anything added to the cleanup chain beyond this point is assumed
7999 to be part of a breakpoint. If the breakpoint create succeeds
8000 then the memory is not reclaimed. */
8001 bkpt_chain = make_cleanup (null_cleanup, 0);
8003 /* Mark the contents of the canonical for cleanup. These go on
8004 the bkpt_chain and only occur if the breakpoint create fails. */
8005 for (i = 0; i < sals.nelts; i++)
8007 if (canonical.canonical[i] != NULL)
8008 make_cleanup (xfree, canonical.canonical[i]);
8011 /* Resolve all line numbers to PC's and verify that the addresses
8012 are ok for the target. */
8014 breakpoint_sals_to_pc (&sals);
8016 /* Fast tracepoints may have additional restrictions on location. */
8017 if (type_wanted == bp_fast_tracepoint)
8018 check_fast_tracepoint_sals (gdbarch, &sals);
8020 /* Verify that condition can be parsed, before setting any
8021 breakpoints. Allocate a separate condition expression for each
8025 if (parse_condition_and_thread)
8027 /* Here we only parse 'arg' to separate condition
8028 from thread number, so parsing in context of first
8029 sal is OK. When setting the breakpoint we'll
8030 re-parse it in context of each sal. */
8033 find_condition_and_thread (arg, sals.sals[0].pc, &cond_string,
8036 make_cleanup (xfree, cond_string);
8040 /* Create a private copy of condition string. */
8043 cond_string = xstrdup (cond_string);
8044 make_cleanup (xfree, cond_string);
8048 /* If the user is creating a static tracepoint by marker id
8049 (strace -m MARKER_ID), then store the sals index, so that
8050 breakpoint_re_set can try to match up which of the newly
8051 found markers corresponds to this one, and, don't try to
8052 expand multiple locations for each sal, given than SALS
8053 already should contain all sals for MARKER_ID. */
8054 if (type_wanted == bp_static_tracepoint
8055 && is_marker_spec (canonical.canonical[0]))
8059 for (i = 0; i < sals.nelts; ++i)
8061 struct symtabs_and_lines expanded;
8062 struct breakpoint *tp;
8063 struct cleanup *old_chain;
8066 expanded.sals = xmalloc (sizeof (struct symtab_and_line));
8067 expanded.sals[0] = sals.sals[i];
8068 old_chain = make_cleanup (xfree, expanded.sals);
8070 create_breakpoint_sal (gdbarch, expanded, canonical.canonical[i],
8071 cond_string, type_wanted,
8072 tempflag ? disp_del : disp_donttouch,
8073 thread, task, ignore_count, ops,
8074 from_tty, enabled, internal,
8075 canonical.special_display);
8077 do_cleanups (old_chain);
8079 /* Get the tracepoint we just created. */
8081 tp = get_breakpoint (internal_breakpoint_number);
8083 tp = get_breakpoint (breakpoint_count);
8084 gdb_assert (tp != NULL);
8086 /* Given that its possible to have multiple markers with
8087 the same string id, if the user is creating a static
8088 tracepoint by marker id ("strace -m MARKER_ID"), then
8089 store the sals index, so that breakpoint_re_set can
8090 try to match up which of the newly found markers
8091 corresponds to this one */
8092 tp->static_trace_marker_id_idx = i;
8096 create_breakpoints_sal (gdbarch, sals, &canonical, cond_string,
8098 tempflag ? disp_del : disp_donttouch,
8099 thread, task, ignore_count, ops, from_tty,
8104 struct breakpoint *b;
8106 make_cleanup (xfree, copy_arg);
8108 b = set_raw_breakpoint_without_location (gdbarch, type_wanted);
8109 set_breakpoint_number (internal, b);
8111 b->addr_string = canonical.canonical[0];
8112 b->cond_string = NULL;
8113 b->ignore_count = ignore_count;
8114 b->disposition = tempflag ? disp_del : disp_donttouch;
8115 b->condition_not_parsed = 1;
8117 b->enable_state = enabled ? bp_enabled : bp_disabled;
8118 b->pspace = current_program_space;
8119 b->py_bp_object = NULL;
8121 if (enabled && b->pspace->executing_startup
8122 && (b->type == bp_breakpoint
8123 || b->type == bp_hardware_breakpoint))
8124 b->enable_state = bp_startup_disabled;
8127 /* Do not mention breakpoints with a negative number,
8128 but do notify observers. */
8130 observer_notify_breakpoint_created (b);
8135 warning (_("Multiple breakpoints were set.\nUse the "
8136 "\"delete\" command to delete unwanted breakpoints."));
8137 prev_breakpoint_count = prev_bkpt_count;
8140 /* That's it. Discard the cleanups for data inserted into the
8142 discard_cleanups (bkpt_chain);
8143 /* But cleanup everything else. */
8144 do_cleanups (old_chain);
8146 /* error call may happen here - have BKPT_CHAIN already discarded. */
8147 update_global_location_list (1);
8152 /* Set a breakpoint.
8153 ARG is a string describing breakpoint address,
8154 condition, and thread.
8155 FLAG specifies if a breakpoint is hardware on,
8156 and if breakpoint is temporary, using BP_HARDWARE_FLAG
8160 break_command_1 (char *arg, int flag, int from_tty)
8162 int tempflag = flag & BP_TEMPFLAG;
8163 enum bptype type_wanted = (flag & BP_HARDWAREFLAG
8164 ? bp_hardware_breakpoint
8167 create_breakpoint (get_current_arch (),
8169 NULL, 0, 1 /* parse arg */,
8170 tempflag, type_wanted,
8171 0 /* Ignore count */,
8172 pending_break_support,
8173 NULL /* breakpoint_ops */,
8180 /* Helper function for break_command_1 and disassemble_command. */
8183 resolve_sal_pc (struct symtab_and_line *sal)
8187 if (sal->pc == 0 && sal->symtab != NULL)
8189 if (!find_line_pc (sal->symtab, sal->line, &pc))
8190 error (_("No line %d in file \"%s\"."),
8191 sal->line, sal->symtab->filename);
8194 /* If this SAL corresponds to a breakpoint inserted using a line
8195 number, then skip the function prologue if necessary. */
8196 if (sal->explicit_line)
8197 skip_prologue_sal (sal);
8200 if (sal->section == 0 && sal->symtab != NULL)
8202 struct blockvector *bv;
8206 bv = blockvector_for_pc_sect (sal->pc, 0, &b, sal->symtab);
8209 sym = block_linkage_function (b);
8212 fixup_symbol_section (sym, sal->symtab->objfile);
8213 sal->section = SYMBOL_OBJ_SECTION (sym);
8217 /* It really is worthwhile to have the section, so we'll
8218 just have to look harder. This case can be executed
8219 if we have line numbers but no functions (as can
8220 happen in assembly source). */
8222 struct minimal_symbol *msym;
8223 struct cleanup *old_chain = save_current_space_and_thread ();
8225 switch_to_program_space_and_thread (sal->pspace);
8227 msym = lookup_minimal_symbol_by_pc (sal->pc);
8229 sal->section = SYMBOL_OBJ_SECTION (msym);
8231 do_cleanups (old_chain);
8238 break_command (char *arg, int from_tty)
8240 break_command_1 (arg, 0, from_tty);
8244 tbreak_command (char *arg, int from_tty)
8246 break_command_1 (arg, BP_TEMPFLAG, from_tty);
8250 hbreak_command (char *arg, int from_tty)
8252 break_command_1 (arg, BP_HARDWAREFLAG, from_tty);
8256 thbreak_command (char *arg, int from_tty)
8258 break_command_1 (arg, (BP_TEMPFLAG | BP_HARDWAREFLAG), from_tty);
8262 stop_command (char *arg, int from_tty)
8264 printf_filtered (_("Specify the type of breakpoint to set.\n\
8265 Usage: stop in <function | address>\n\
8266 stop at <line>\n"));
8270 stopin_command (char *arg, int from_tty)
8274 if (arg == (char *) NULL)
8276 else if (*arg != '*')
8281 /* Look for a ':'. If this is a line number specification, then
8282 say it is bad, otherwise, it should be an address or
8283 function/method name. */
8284 while (*argptr && !hasColon)
8286 hasColon = (*argptr == ':');
8291 badInput = (*argptr != ':'); /* Not a class::method */
8293 badInput = isdigit (*arg); /* a simple line number */
8297 printf_filtered (_("Usage: stop in <function | address>\n"));
8299 break_command_1 (arg, 0, from_tty);
8303 stopat_command (char *arg, int from_tty)
8307 if (arg == (char *) NULL || *arg == '*') /* no line number */
8314 /* Look for a ':'. If there is a '::' then get out, otherwise
8315 it is probably a line number. */
8316 while (*argptr && !hasColon)
8318 hasColon = (*argptr == ':');
8323 badInput = (*argptr == ':'); /* we have class::method */
8325 badInput = !isdigit (*arg); /* not a line number */
8329 printf_filtered (_("Usage: stop at <line>\n"));
8331 break_command_1 (arg, 0, from_tty);
8334 /* Implement the "breakpoint_hit" breakpoint_ops method for
8335 ranged breakpoints. */
8338 breakpoint_hit_ranged_breakpoint (const struct bp_location *bl,
8339 struct address_space *aspace,
8342 return breakpoint_address_match_range (bl->pspace->aspace, bl->address,
8343 bl->length, aspace, bp_addr);
8346 /* Implement the "resources_needed" breakpoint_ops method for
8347 ranged breakpoints. */
8350 resources_needed_ranged_breakpoint (const struct bp_location *bl)
8352 return target_ranged_break_num_registers ();
8355 /* Implement the "print_it" breakpoint_ops method for
8356 ranged breakpoints. */
8358 static enum print_stop_action
8359 print_it_ranged_breakpoint (struct breakpoint *b)
8361 struct bp_location *bl = b->loc;
8363 gdb_assert (b->type == bp_hardware_breakpoint);
8365 /* Ranged breakpoints have only one location. */
8366 gdb_assert (bl && bl->next == NULL);
8368 annotate_breakpoint (b->number);
8369 if (b->disposition == disp_del)
8370 ui_out_text (uiout, "\nTemporary ranged breakpoint ");
8372 ui_out_text (uiout, "\nRanged breakpoint ");
8373 if (ui_out_is_mi_like_p (uiout))
8375 ui_out_field_string (uiout, "reason",
8376 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
8377 ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
8379 ui_out_field_int (uiout, "bkptno", b->number);
8380 ui_out_text (uiout, ", ");
8382 return PRINT_SRC_AND_LOC;
8385 /* Implement the "print_one" breakpoint_ops method for
8386 ranged breakpoints. */
8389 print_one_ranged_breakpoint (struct breakpoint *b,
8390 struct bp_location **last_loc)
8392 struct bp_location *bl = b->loc;
8393 struct value_print_options opts;
8395 /* Ranged breakpoints have only one location. */
8396 gdb_assert (bl && bl->next == NULL);
8398 get_user_print_options (&opts);
8400 if (opts.addressprint)
8401 /* We don't print the address range here, it will be printed later
8402 by print_one_detail_ranged_breakpoint. */
8403 ui_out_field_skip (uiout, "addr");
8405 print_breakpoint_location (b, bl);
8409 /* Implement the "print_one_detail" breakpoint_ops method for
8410 ranged breakpoints. */
8413 print_one_detail_ranged_breakpoint (const struct breakpoint *b,
8414 struct ui_out *uiout)
8416 CORE_ADDR address_start, address_end;
8417 struct bp_location *bl = b->loc;
8418 struct ui_stream *stb = ui_out_stream_new (uiout);
8419 struct cleanup *cleanup = make_cleanup_ui_out_stream_delete (stb);
8423 address_start = bl->address;
8424 address_end = address_start + bl->length - 1;
8426 ui_out_text (uiout, "\taddress range: ");
8427 fprintf_unfiltered (stb->stream, "[%s, %s]",
8428 print_core_address (bl->gdbarch, address_start),
8429 print_core_address (bl->gdbarch, address_end));
8430 ui_out_field_stream (uiout, "addr", stb);
8431 ui_out_text (uiout, "\n");
8433 do_cleanups (cleanup);
8436 /* Implement the "print_mention" breakpoint_ops method for
8437 ranged breakpoints. */
8440 print_mention_ranged_breakpoint (struct breakpoint *b)
8442 struct bp_location *bl = b->loc;
8445 gdb_assert (b->type == bp_hardware_breakpoint);
8447 if (ui_out_is_mi_like_p (uiout))
8450 printf_filtered (_("Hardware assisted ranged breakpoint %d from %s to %s."),
8451 b->number, paddress (bl->gdbarch, bl->address),
8452 paddress (bl->gdbarch, bl->address + bl->length - 1));
8455 /* Implement the "print_recreate" breakpoint_ops method for
8456 ranged breakpoints. */
8459 print_recreate_ranged_breakpoint (struct breakpoint *b, struct ui_file *fp)
8461 fprintf_unfiltered (fp, "break-range %s, %s", b->addr_string,
8462 b->addr_string_range_end);
8465 /* The breakpoint_ops structure to be used in ranged breakpoints. */
8467 static struct breakpoint_ops ranged_breakpoint_ops =
8471 breakpoint_hit_ranged_breakpoint,
8472 resources_needed_ranged_breakpoint,
8473 print_it_ranged_breakpoint,
8474 print_one_ranged_breakpoint,
8475 print_one_detail_ranged_breakpoint,
8476 print_mention_ranged_breakpoint,
8477 print_recreate_ranged_breakpoint
8480 /* Find the address where the end of the breakpoint range should be
8481 placed, given the SAL of the end of the range. This is so that if
8482 the user provides a line number, the end of the range is set to the
8483 last instruction of the given line. */
8486 find_breakpoint_range_end (struct symtab_and_line sal)
8490 /* If the user provided a PC value, use it. Otherwise,
8491 find the address of the end of the given location. */
8492 if (sal.explicit_pc)
8499 ret = find_line_pc_range (sal, &start, &end);
8501 error (_("Could not find location of the end of the range."));
8503 /* find_line_pc_range returns the start of the next line. */
8510 /* Implement the "break-range" CLI command. */
8513 break_range_command (char *arg, int from_tty)
8515 char *arg_start, *addr_string_start, *addr_string_end;
8516 struct linespec_result canonical_start, canonical_end;
8517 int bp_count, can_use_bp, length;
8519 struct breakpoint *b;
8520 struct symtab_and_line sal_start, sal_end;
8521 struct symtabs_and_lines sals_start, sals_end;
8522 struct cleanup *cleanup_bkpt;
8524 /* We don't support software ranged breakpoints. */
8525 if (target_ranged_break_num_registers () < 0)
8526 error (_("This target does not support hardware ranged breakpoints."));
8528 bp_count = hw_breakpoint_used_count ();
8529 bp_count += target_ranged_break_num_registers ();
8530 can_use_bp = target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
8533 error (_("Hardware breakpoints used exceeds limit."));
8535 if (arg == NULL || arg[0] == '\0')
8536 error(_("No address range specified."));
8538 sals_start.sals = NULL;
8539 sals_start.nelts = 0;
8540 init_linespec_result (&canonical_start);
8542 while (*arg == ' ' || *arg == '\t')
8545 parse_breakpoint_sals (&arg, &sals_start, &canonical_start);
8547 sal_start = sals_start.sals[0];
8548 addr_string_start = canonical_start.canonical[0];
8549 cleanup_bkpt = make_cleanup (xfree, addr_string_start);
8550 xfree (sals_start.sals);
8551 xfree (canonical_start.canonical);
8554 error (_("Too few arguments."));
8555 else if (sals_start.nelts == 0)
8556 error (_("Could not find location of the beginning of the range."));
8557 else if (sals_start.nelts != 1)
8558 error (_("Cannot create a ranged breakpoint with multiple locations."));
8560 resolve_sal_pc (&sal_start);
8562 arg++; /* Skip the comma. */
8563 while (*arg == ' ' || *arg == '\t')
8566 /* Parse the end location. */
8568 sals_end.sals = NULL;
8570 init_linespec_result (&canonical_end);
8573 /* We call decode_line_1 directly here instead of using
8574 parse_breakpoint_sals because we need to specify the start location's
8575 symtab and line as the default symtab and line for the end of the
8576 range. This makes it possible to have ranges like "foo.c:27, +14",
8577 where +14 means 14 lines from the start location. */
8578 sals_end = decode_line_1 (&arg, 1, sal_start.symtab, sal_start.line,
8581 /* canonical_end can be NULL if it was of the form "*0xdeadbeef". */
8582 if (canonical_end.canonical == NULL)
8583 canonical_end.canonical = xcalloc (1, sizeof (char *));
8584 /* Add the string if not present. */
8585 if (arg_start != arg && canonical_end.canonical[0] == NULL)
8586 canonical_end.canonical[0] = savestring (arg_start, arg - arg_start);
8588 sal_end = sals_end.sals[0];
8589 addr_string_end = canonical_end.canonical[0];
8590 make_cleanup (xfree, addr_string_end);
8591 xfree (sals_end.sals);
8592 xfree (canonical_end.canonical);
8594 if (sals_end.nelts == 0)
8595 error (_("Could not find location of the end of the range."));
8596 else if (sals_end.nelts != 1)
8597 error (_("Cannot create a ranged breakpoint with multiple locations."));
8599 resolve_sal_pc (&sal_end);
8601 end = find_breakpoint_range_end (sal_end);
8602 if (sal_start.pc > end)
8603 error (_("Invalid address range, end preceeds start."));
8605 length = end - sal_start.pc + 1;
8607 /* Length overflowed. */
8608 error (_("Address range too large."));
8609 else if (length == 1)
8611 /* This range is simple enough to be handled by
8612 the `hbreak' command. */
8613 hbreak_command (addr_string_start, 1);
8615 do_cleanups (cleanup_bkpt);
8620 /* Now set up the breakpoint. */
8621 b = set_raw_breakpoint (get_current_arch (), sal_start,
8622 bp_hardware_breakpoint);
8623 set_breakpoint_count (breakpoint_count + 1);
8624 b->number = breakpoint_count;
8625 b->disposition = disp_donttouch;
8626 b->addr_string = addr_string_start;
8627 b->addr_string_range_end = addr_string_end;
8628 b->ops = &ranged_breakpoint_ops;
8629 b->loc->length = length;
8631 discard_cleanups (cleanup_bkpt);
8634 observer_notify_breakpoint_created (b);
8635 update_global_location_list (1);
8638 /* Return non-zero if EXP is verified as constant. Returned zero
8639 means EXP is variable. Also the constant detection may fail for
8640 some constant expressions and in such case still falsely return
8643 watchpoint_exp_is_const (const struct expression *exp)
8651 /* We are only interested in the descriptor of each element. */
8652 operator_length (exp, i, &oplenp, &argsp);
8655 switch (exp->elts[i].opcode)
8665 case BINOP_LOGICAL_AND:
8666 case BINOP_LOGICAL_OR:
8667 case BINOP_BITWISE_AND:
8668 case BINOP_BITWISE_IOR:
8669 case BINOP_BITWISE_XOR:
8671 case BINOP_NOTEQUAL:
8687 case TERNOP_SLICE_COUNT:
8699 case OP_OBJC_NSSTRING:
8702 case UNOP_LOGICAL_NOT:
8703 case UNOP_COMPLEMENT:
8706 /* Unary, binary and ternary operators: We have to check
8707 their operands. If they are constant, then so is the
8708 result of that operation. For instance, if A and B are
8709 determined to be constants, then so is "A + B".
8711 UNOP_IND is one exception to the rule above, because the
8712 value of *ADDR is not necessarily a constant, even when
8717 /* Check whether the associated symbol is a constant.
8719 We use SYMBOL_CLASS rather than TYPE_CONST because it's
8720 possible that a buggy compiler could mark a variable as
8721 constant even when it is not, and TYPE_CONST would return
8722 true in this case, while SYMBOL_CLASS wouldn't.
8724 We also have to check for function symbols because they
8725 are always constant. */
8727 struct symbol *s = exp->elts[i + 2].symbol;
8729 if (SYMBOL_CLASS (s) != LOC_BLOCK
8730 && SYMBOL_CLASS (s) != LOC_CONST
8731 && SYMBOL_CLASS (s) != LOC_CONST_BYTES)
8736 /* The default action is to return 0 because we are using
8737 the optimistic approach here: If we don't know something,
8738 then it is not a constant. */
8747 /* Implement the "insert" breakpoint_ops method for hardware watchpoints. */
8750 insert_watchpoint (struct bp_location *bl)
8752 int length = bl->owner->exact? 1 : bl->length;
8754 return target_insert_watchpoint (bl->address, length, bl->watchpoint_type,
8755 bl->owner->cond_exp);
8758 /* Implement the "remove" breakpoint_ops method for hardware watchpoints. */
8761 remove_watchpoint (struct bp_location *bl)
8763 int length = bl->owner->exact? 1 : bl->length;
8765 return target_remove_watchpoint (bl->address, length, bl->watchpoint_type,
8766 bl->owner->cond_exp);
8769 /* Implement the "resources_needed" breakpoint_ops method for
8770 hardware watchpoints. */
8773 resources_needed_watchpoint (const struct bp_location *bl)
8775 int length = bl->owner->exact? 1 : bl->length;
8777 return target_region_ok_for_hw_watchpoint (bl->address, length);
8780 /* The breakpoint_ops structure to be used in hardware watchpoints. */
8782 static struct breakpoint_ops watchpoint_breakpoint_ops =
8786 NULL, /* breakpoint_hit */
8787 resources_needed_watchpoint,
8788 NULL, /* print_it */
8789 NULL, /* print_one */
8790 NULL, /* print_one_detail */
8791 NULL, /* print_mention */
8792 NULL /* print_recreate */
8795 /* accessflag: hw_write: watch write,
8796 hw_read: watch read,
8797 hw_access: watch access (read or write) */
8799 watch_command_1 (char *arg, int accessflag, int from_tty,
8800 int just_location, int internal)
8802 volatile struct gdb_exception e;
8803 struct breakpoint *b, *scope_breakpoint = NULL;
8804 struct expression *exp;
8805 struct block *exp_valid_block = NULL, *cond_exp_valid_block = NULL;
8806 struct value *val, *mark, *result;
8807 struct frame_info *frame;
8808 char *exp_start = NULL;
8809 char *exp_end = NULL;
8810 char *tok, *id_tok_start, *end_tok;
8812 char *cond_start = NULL;
8813 char *cond_end = NULL;
8814 enum bptype bp_type;
8818 /* Make sure that we actually have parameters to parse. */
8819 if (arg != NULL && arg[0] != '\0')
8821 toklen = strlen (arg); /* Size of argument list. */
8823 /* Points tok to the end of the argument list. */
8824 tok = arg + toklen - 1;
8826 /* Go backwards in the parameters list. Skip the last
8827 parameter. If we're expecting a 'thread <thread_num>'
8828 parameter, this should be the thread identifier. */
8829 while (tok > arg && (*tok == ' ' || *tok == '\t'))
8831 while (tok > arg && (*tok != ' ' && *tok != '\t'))
8834 /* Points end_tok to the beginning of the last token. */
8835 id_tok_start = tok + 1;
8837 /* Go backwards in the parameters list. Skip one more
8838 parameter. If we're expecting a 'thread <thread_num>'
8839 parameter, we should reach a "thread" token. */
8840 while (tok > arg && (*tok == ' ' || *tok == '\t'))
8845 while (tok > arg && (*tok != ' ' && *tok != '\t'))
8848 /* Move the pointer forward to skip the whitespace and
8849 calculate the length of the token. */
8851 toklen = end_tok - tok;
8853 if (toklen >= 1 && strncmp (tok, "thread", toklen) == 0)
8855 /* At this point we've found a "thread" token, which means
8856 the user is trying to set a watchpoint that triggers
8857 only in a specific thread. */
8860 /* Extract the thread ID from the next token. */
8861 thread = strtol (id_tok_start, &endp, 0);
8863 /* Check if the user provided a valid numeric value for the
8865 if (*endp != ' ' && *endp != '\t' && *endp != '\0')
8866 error (_("Invalid thread ID specification %s."), id_tok_start);
8868 /* Check if the thread actually exists. */
8869 if (!valid_thread_id (thread))
8870 error (_("Unknown thread %d."), thread);
8872 /* Truncate the string and get rid of the thread <thread_num>
8873 parameter before the parameter list is parsed by the
8874 evaluate_expression() function. */
8879 /* Parse the rest of the arguments. */
8880 innermost_block = NULL;
8882 exp = parse_exp_1 (&arg, 0, 0);
8884 /* Remove trailing whitespace from the expression before saving it.
8885 This makes the eventual display of the expression string a bit
8887 while (exp_end > exp_start && (exp_end[-1] == ' ' || exp_end[-1] == '\t'))
8890 /* Checking if the expression is not constant. */
8891 if (watchpoint_exp_is_const (exp))
8895 len = exp_end - exp_start;
8896 while (len > 0 && isspace (exp_start[len - 1]))
8898 error (_("Cannot watch constant value `%.*s'."), len, exp_start);
8901 exp_valid_block = innermost_block;
8902 mark = value_mark ();
8903 fetch_subexp_value (exp, &pc, &val, &result, NULL);
8907 exp_valid_block = NULL;
8908 val = value_addr (result);
8909 release_value (val);
8910 value_free_to_mark (mark);
8912 else if (val != NULL)
8913 release_value (val);
8915 tok = skip_spaces (arg);
8916 end_tok = skip_to_space (tok);
8918 toklen = end_tok - tok;
8919 if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
8921 struct expression *cond;
8923 innermost_block = NULL;
8924 tok = cond_start = end_tok + 1;
8925 cond = parse_exp_1 (&tok, 0, 0);
8927 /* The watchpoint expression may not be local, but the condition
8928 may still be. E.g.: `watch global if local > 0'. */
8929 cond_exp_valid_block = innermost_block;
8935 error (_("Junk at end of command."));
8937 if (accessflag == hw_read)
8938 bp_type = bp_read_watchpoint;
8939 else if (accessflag == hw_access)
8940 bp_type = bp_access_watchpoint;
8942 bp_type = bp_hardware_watchpoint;
8944 frame = block_innermost_frame (exp_valid_block);
8946 /* If the expression is "local", then set up a "watchpoint scope"
8947 breakpoint at the point where we've left the scope of the watchpoint
8948 expression. Create the scope breakpoint before the watchpoint, so
8949 that we will encounter it first in bpstat_stop_status. */
8950 if (exp_valid_block && frame)
8952 if (frame_id_p (frame_unwind_caller_id (frame)))
8955 = create_internal_breakpoint (frame_unwind_caller_arch (frame),
8956 frame_unwind_caller_pc (frame),
8957 bp_watchpoint_scope);
8959 scope_breakpoint->enable_state = bp_enabled;
8961 /* Automatically delete the breakpoint when it hits. */
8962 scope_breakpoint->disposition = disp_del;
8964 /* Only break in the proper frame (help with recursion). */
8965 scope_breakpoint->frame_id = frame_unwind_caller_id (frame);
8967 /* Set the address at which we will stop. */
8968 scope_breakpoint->loc->gdbarch
8969 = frame_unwind_caller_arch (frame);
8970 scope_breakpoint->loc->requested_address
8971 = frame_unwind_caller_pc (frame);
8972 scope_breakpoint->loc->address
8973 = adjust_breakpoint_address (scope_breakpoint->loc->gdbarch,
8974 scope_breakpoint->loc->requested_address,
8975 scope_breakpoint->type);
8979 /* Now set up the breakpoint. */
8980 b = set_raw_breakpoint_without_location (NULL, bp_type);
8982 b->disposition = disp_donttouch;
8984 b->exp_valid_block = exp_valid_block;
8985 b->cond_exp_valid_block = cond_exp_valid_block;
8988 struct type *t = value_type (val);
8989 CORE_ADDR addr = value_as_address (val);
8992 t = check_typedef (TYPE_TARGET_TYPE (check_typedef (t)));
8993 name = type_to_string (t);
8995 b->exp_string_reparse = xstrprintf ("* (%s *) %s", name,
8996 core_addr_to_string (addr));
8999 b->exp_string = xstrprintf ("-location %.*s",
9000 (int) (exp_end - exp_start), exp_start);
9002 /* The above expression is in C. */
9003 b->language = language_c;
9006 b->exp_string = savestring (exp_start, exp_end - exp_start);
9009 b->ops = &watchpoint_breakpoint_ops;
9012 b->cond_string = savestring (cond_start, cond_end - cond_start);
9018 b->watchpoint_frame = get_frame_id (frame);
9019 b->watchpoint_thread = inferior_ptid;
9023 b->watchpoint_frame = null_frame_id;
9024 b->watchpoint_thread = null_ptid;
9027 if (scope_breakpoint != NULL)
9029 /* The scope breakpoint is related to the watchpoint. We will
9030 need to act on them together. */
9031 b->related_breakpoint = scope_breakpoint;
9032 scope_breakpoint->related_breakpoint = b;
9036 value_free_to_mark (mark);
9038 TRY_CATCH (e, RETURN_MASK_ALL)
9040 /* Finally update the new watchpoint. This creates the locations
9041 that should be inserted. */
9042 update_watchpoint (b, 1);
9046 delete_breakpoint (b);
9047 throw_exception (e);
9050 set_breakpoint_number (internal, b);
9052 /* Do not mention breakpoints with a negative number, but do
9053 notify observers. */
9056 observer_notify_breakpoint_created (b);
9058 update_global_location_list (1);
9061 /* Return count of debug registers needed to watch the given expression.
9062 If the watchpoint cannot be handled in hardware return zero. */
9065 can_use_hardware_watchpoint (struct value *v)
9067 int found_memory_cnt = 0;
9068 struct value *head = v;
9070 /* Did the user specifically forbid us to use hardware watchpoints? */
9071 if (!can_use_hw_watchpoints)
9074 /* Make sure that the value of the expression depends only upon
9075 memory contents, and values computed from them within GDB. If we
9076 find any register references or function calls, we can't use a
9077 hardware watchpoint.
9079 The idea here is that evaluating an expression generates a series
9080 of values, one holding the value of every subexpression. (The
9081 expression a*b+c has five subexpressions: a, b, a*b, c, and
9082 a*b+c.) GDB's values hold almost enough information to establish
9083 the criteria given above --- they identify memory lvalues,
9084 register lvalues, computed values, etcetera. So we can evaluate
9085 the expression, and then scan the chain of values that leaves
9086 behind to decide whether we can detect any possible change to the
9087 expression's final value using only hardware watchpoints.
9089 However, I don't think that the values returned by inferior
9090 function calls are special in any way. So this function may not
9091 notice that an expression involving an inferior function call
9092 can't be watched with hardware watchpoints. FIXME. */
9093 for (; v; v = value_next (v))
9095 if (VALUE_LVAL (v) == lval_memory)
9097 if (v != head && value_lazy (v))
9098 /* A lazy memory lvalue in the chain is one that GDB never
9099 needed to fetch; we either just used its address (e.g.,
9100 `a' in `a.b') or we never needed it at all (e.g., `a'
9101 in `a,b'). This doesn't apply to HEAD; if that is
9102 lazy then it was not readable, but watch it anyway. */
9106 /* Ahh, memory we actually used! Check if we can cover
9107 it with hardware watchpoints. */
9108 struct type *vtype = check_typedef (value_type (v));
9110 /* We only watch structs and arrays if user asked for it
9111 explicitly, never if they just happen to appear in a
9112 middle of some value chain. */
9114 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
9115 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
9117 CORE_ADDR vaddr = value_address (v);
9121 len = (target_exact_watchpoints
9122 && is_scalar_type_recursive (vtype))?
9123 1 : TYPE_LENGTH (value_type (v));
9125 num_regs = target_region_ok_for_hw_watchpoint (vaddr, len);
9129 found_memory_cnt += num_regs;
9133 else if (VALUE_LVAL (v) != not_lval
9134 && deprecated_value_modifiable (v) == 0)
9135 return 0; /* These are values from the history (e.g., $1). */
9136 else if (VALUE_LVAL (v) == lval_register)
9137 return 0; /* Cannot watch a register with a HW watchpoint. */
9140 /* The expression itself looks suitable for using a hardware
9141 watchpoint, but give the target machine a chance to reject it. */
9142 return found_memory_cnt;
9146 watch_command_wrapper (char *arg, int from_tty, int internal)
9148 watch_command_1 (arg, hw_write, from_tty, 0, internal);
9151 /* A helper function that looks for an argument at the start of a
9152 string. The argument must also either be at the end of the string,
9153 or be followed by whitespace. Returns 1 if it finds the argument,
9154 0 otherwise. If the argument is found, it updates *STR. */
9157 check_for_argument (char **str, char *arg, int arg_len)
9159 if (strncmp (*str, arg, arg_len) == 0
9160 && ((*str)[arg_len] == '\0' || isspace ((*str)[arg_len])))
9168 /* A helper function that looks for the "-location" argument and then
9169 calls watch_command_1. */
9172 watch_maybe_just_location (char *arg, int accessflag, int from_tty)
9174 int just_location = 0;
9177 && (check_for_argument (&arg, "-location", sizeof ("-location") - 1)
9178 || check_for_argument (&arg, "-l", sizeof ("-l") - 1)))
9180 arg = skip_spaces (arg);
9184 watch_command_1 (arg, accessflag, from_tty, just_location, 0);
9188 watch_command (char *arg, int from_tty)
9190 watch_maybe_just_location (arg, hw_write, from_tty);
9194 rwatch_command_wrapper (char *arg, int from_tty, int internal)
9196 watch_command_1 (arg, hw_read, from_tty, 0, internal);
9200 rwatch_command (char *arg, int from_tty)
9202 watch_maybe_just_location (arg, hw_read, from_tty);
9206 awatch_command_wrapper (char *arg, int from_tty, int internal)
9208 watch_command_1 (arg, hw_access, from_tty, 0, internal);
9212 awatch_command (char *arg, int from_tty)
9214 watch_maybe_just_location (arg, hw_access, from_tty);
9218 /* Helper routines for the until_command routine in infcmd.c. Here
9219 because it uses the mechanisms of breakpoints. */
9221 struct until_break_command_continuation_args
9223 struct breakpoint *breakpoint;
9224 struct breakpoint *breakpoint2;
9228 /* This function is called by fetch_inferior_event via the
9229 cmd_continuation pointer, to complete the until command. It takes
9230 care of cleaning up the temporary breakpoints set up by the until
9233 until_break_command_continuation (void *arg)
9235 struct until_break_command_continuation_args *a = arg;
9237 delete_breakpoint (a->breakpoint);
9239 delete_breakpoint (a->breakpoint2);
9240 delete_longjmp_breakpoint (a->thread_num);
9244 until_break_command (char *arg, int from_tty, int anywhere)
9246 struct symtabs_and_lines sals;
9247 struct symtab_and_line sal;
9248 struct frame_info *frame = get_selected_frame (NULL);
9249 struct breakpoint *breakpoint;
9250 struct breakpoint *breakpoint2 = NULL;
9251 struct cleanup *old_chain;
9253 struct thread_info *tp;
9255 clear_proceed_status ();
9257 /* Set a breakpoint where the user wants it and at return from
9260 if (default_breakpoint_valid)
9261 sals = decode_line_1 (&arg, 1, default_breakpoint_symtab,
9262 default_breakpoint_line, NULL);
9264 sals = decode_line_1 (&arg, 1, (struct symtab *) NULL, 0, NULL);
9266 if (sals.nelts != 1)
9267 error (_("Couldn't get information on specified line."));
9270 xfree (sals.sals); /* malloc'd, so freed. */
9273 error (_("Junk at end of arguments."));
9275 resolve_sal_pc (&sal);
9278 /* If the user told us to continue until a specified location,
9279 we don't specify a frame at which we need to stop. */
9280 breakpoint = set_momentary_breakpoint (get_frame_arch (frame), sal,
9281 null_frame_id, bp_until);
9283 /* Otherwise, specify the selected frame, because we want to stop
9284 only at the very same frame. */
9285 breakpoint = set_momentary_breakpoint (get_frame_arch (frame), sal,
9286 get_stack_frame_id (frame),
9289 old_chain = make_cleanup_delete_breakpoint (breakpoint);
9291 tp = inferior_thread ();
9294 /* Keep within the current frame, or in frames called by the current
9297 if (frame_id_p (frame_unwind_caller_id (frame)))
9299 sal = find_pc_line (frame_unwind_caller_pc (frame), 0);
9300 sal.pc = frame_unwind_caller_pc (frame);
9301 breakpoint2 = set_momentary_breakpoint (frame_unwind_caller_arch (frame),
9303 frame_unwind_caller_id (frame),
9305 make_cleanup_delete_breakpoint (breakpoint2);
9307 set_longjmp_breakpoint (tp, frame_unwind_caller_id (frame));
9308 make_cleanup (delete_longjmp_breakpoint_cleanup, &thread);
9311 proceed (-1, TARGET_SIGNAL_DEFAULT, 0);
9313 /* If we are running asynchronously, and proceed call above has
9314 actually managed to start the target, arrange for breakpoints to
9315 be deleted when the target stops. Otherwise, we're already
9316 stopped and delete breakpoints via cleanup chain. */
9318 if (target_can_async_p () && is_running (inferior_ptid))
9320 struct until_break_command_continuation_args *args;
9321 args = xmalloc (sizeof (*args));
9323 args->breakpoint = breakpoint;
9324 args->breakpoint2 = breakpoint2;
9325 args->thread_num = thread;
9327 discard_cleanups (old_chain);
9328 add_continuation (inferior_thread (),
9329 until_break_command_continuation, args,
9333 do_cleanups (old_chain);
9336 /* This function attempts to parse an optional "if <cond>" clause
9337 from the arg string. If one is not found, it returns NULL.
9339 Else, it returns a pointer to the condition string. (It does not
9340 attempt to evaluate the string against a particular block.) And,
9341 it updates arg to point to the first character following the parsed
9342 if clause in the arg string. */
9345 ep_parse_optional_if_clause (char **arg)
9349 if (((*arg)[0] != 'i') || ((*arg)[1] != 'f') || !isspace ((*arg)[2]))
9352 /* Skip the "if" keyword. */
9355 /* Skip any extra leading whitespace, and record the start of the
9356 condition string. */
9357 *arg = skip_spaces (*arg);
9360 /* Assume that the condition occupies the remainder of the arg
9362 (*arg) += strlen (cond_string);
9367 /* Commands to deal with catching events, such as signals, exceptions,
9368 process start/exit, etc. */
9372 catch_fork_temporary, catch_vfork_temporary,
9373 catch_fork_permanent, catch_vfork_permanent
9378 catch_fork_command_1 (char *arg, int from_tty,
9379 struct cmd_list_element *command)
9381 struct gdbarch *gdbarch = get_current_arch ();
9382 char *cond_string = NULL;
9383 catch_fork_kind fork_kind;
9386 fork_kind = (catch_fork_kind) (uintptr_t) get_cmd_context (command);
9387 tempflag = (fork_kind == catch_fork_temporary
9388 || fork_kind == catch_vfork_temporary);
9392 arg = skip_spaces (arg);
9394 /* The allowed syntax is:
9396 catch [v]fork if <cond>
9398 First, check if there's an if clause. */
9399 cond_string = ep_parse_optional_if_clause (&arg);
9401 if ((*arg != '\0') && !isspace (*arg))
9402 error (_("Junk at end of arguments."));
9404 /* If this target supports it, create a fork or vfork catchpoint
9405 and enable reporting of such events. */
9408 case catch_fork_temporary:
9409 case catch_fork_permanent:
9410 create_fork_vfork_event_catchpoint (gdbarch, tempflag, cond_string,
9411 &catch_fork_breakpoint_ops);
9413 case catch_vfork_temporary:
9414 case catch_vfork_permanent:
9415 create_fork_vfork_event_catchpoint (gdbarch, tempflag, cond_string,
9416 &catch_vfork_breakpoint_ops);
9419 error (_("unsupported or unknown fork kind; cannot catch it"));
9425 catch_exec_command_1 (char *arg, int from_tty,
9426 struct cmd_list_element *command)
9428 struct gdbarch *gdbarch = get_current_arch ();
9430 char *cond_string = NULL;
9432 tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
9436 arg = skip_spaces (arg);
9438 /* The allowed syntax is:
9440 catch exec if <cond>
9442 First, check if there's an if clause. */
9443 cond_string = ep_parse_optional_if_clause (&arg);
9445 if ((*arg != '\0') && !isspace (*arg))
9446 error (_("Junk at end of arguments."));
9448 /* If this target supports it, create an exec catchpoint
9449 and enable reporting of such events. */
9450 create_catchpoint (gdbarch, tempflag, cond_string,
9451 &catch_exec_breakpoint_ops);
9454 static enum print_stop_action
9455 print_it_exception_catchpoint (struct breakpoint *b)
9457 int bp_temp, bp_throw;
9459 annotate_catchpoint (b->number);
9461 bp_throw = strstr (b->addr_string, "throw") != NULL;
9462 if (b->loc->address != b->loc->requested_address)
9463 breakpoint_adjustment_warning (b->loc->requested_address,
9466 bp_temp = b->disposition == disp_del;
9468 bp_temp ? "Temporary catchpoint "
9470 if (!ui_out_is_mi_like_p (uiout))
9471 ui_out_field_int (uiout, "bkptno", b->number);
9473 bp_throw ? " (exception thrown), "
9474 : " (exception caught), ");
9475 if (ui_out_is_mi_like_p (uiout))
9477 ui_out_field_string (uiout, "reason",
9478 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
9479 ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
9480 ui_out_field_int (uiout, "bkptno", b->number);
9482 return PRINT_SRC_AND_LOC;
9486 print_one_exception_catchpoint (struct breakpoint *b,
9487 struct bp_location **last_loc)
9489 struct value_print_options opts;
9491 get_user_print_options (&opts);
9492 if (opts.addressprint)
9495 if (b->loc == NULL || b->loc->shlib_disabled)
9496 ui_out_field_string (uiout, "addr", "<PENDING>");
9498 ui_out_field_core_addr (uiout, "addr",
9499 b->loc->gdbarch, b->loc->address);
9504 if (strstr (b->addr_string, "throw") != NULL)
9505 ui_out_field_string (uiout, "what", "exception throw");
9507 ui_out_field_string (uiout, "what", "exception catch");
9511 print_mention_exception_catchpoint (struct breakpoint *b)
9516 bp_temp = b->disposition == disp_del;
9517 bp_throw = strstr (b->addr_string, "throw") != NULL;
9518 ui_out_text (uiout, bp_temp ? _("Temporary catchpoint ")
9519 : _("Catchpoint "));
9520 ui_out_field_int (uiout, "bkptno", b->number);
9521 ui_out_text (uiout, bp_throw ? _(" (throw)")
9525 /* Implement the "print_recreate" breakpoint_ops method for throw and
9526 catch catchpoints. */
9529 print_recreate_exception_catchpoint (struct breakpoint *b,
9535 bp_temp = b->disposition == disp_del;
9536 bp_throw = strstr (b->addr_string, "throw") != NULL;
9537 fprintf_unfiltered (fp, bp_temp ? "tcatch " : "catch ");
9538 fprintf_unfiltered (fp, bp_throw ? "throw" : "catch");
9541 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops = {
9544 NULL, /* breakpoint_hit */
9545 NULL, /* resources_needed */
9546 print_it_exception_catchpoint,
9547 print_one_exception_catchpoint,
9548 NULL, /* print_one_detail */
9549 print_mention_exception_catchpoint,
9550 print_recreate_exception_catchpoint
9554 handle_gnu_v3_exceptions (int tempflag, char *cond_string,
9555 enum exception_event_kind ex_event, int from_tty)
9557 char *trigger_func_name;
9559 if (ex_event == EX_EVENT_CATCH)
9560 trigger_func_name = "__cxa_begin_catch";
9562 trigger_func_name = "__cxa_throw";
9564 create_breakpoint (get_current_arch (),
9565 trigger_func_name, cond_string, -1,
9566 0 /* condition and thread are valid. */,
9567 tempflag, bp_breakpoint,
9569 AUTO_BOOLEAN_TRUE /* pending */,
9570 &gnu_v3_exception_catchpoint_ops, from_tty,
9577 /* Deal with "catch catch" and "catch throw" commands. */
9580 catch_exception_command_1 (enum exception_event_kind ex_event, char *arg,
9581 int tempflag, int from_tty)
9583 char *cond_string = NULL;
9587 arg = skip_spaces (arg);
9589 cond_string = ep_parse_optional_if_clause (&arg);
9591 if ((*arg != '\0') && !isspace (*arg))
9592 error (_("Junk at end of arguments."));
9594 if (ex_event != EX_EVENT_THROW
9595 && ex_event != EX_EVENT_CATCH)
9596 error (_("Unsupported or unknown exception event; cannot catch it"));
9598 if (handle_gnu_v3_exceptions (tempflag, cond_string, ex_event, from_tty))
9601 warning (_("Unsupported with this platform/compiler combination."));
9604 /* Implementation of "catch catch" command. */
9607 catch_catch_command (char *arg, int from_tty, struct cmd_list_element *command)
9609 int tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
9611 catch_exception_command_1 (EX_EVENT_CATCH, arg, tempflag, from_tty);
9614 /* Implementation of "catch throw" command. */
9617 catch_throw_command (char *arg, int from_tty, struct cmd_list_element *command)
9619 int tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
9621 catch_exception_command_1 (EX_EVENT_THROW, arg, tempflag, from_tty);
9624 /* Create a breakpoint struct for Ada exception catchpoints. */
9627 create_ada_exception_breakpoint (struct gdbarch *gdbarch,
9628 struct symtab_and_line sal,
9632 struct expression *cond,
9633 struct breakpoint_ops *ops,
9637 struct breakpoint *b;
9641 struct gdbarch *loc_gdbarch = get_sal_arch (sal);
9643 loc_gdbarch = gdbarch;
9645 describe_other_breakpoints (loc_gdbarch,
9646 sal.pspace, sal.pc, sal.section, -1);
9647 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
9648 version for exception catchpoints, because two catchpoints
9649 used for different exception names will use the same address.
9650 In this case, a "breakpoint ... also set at..." warning is
9651 unproductive. Besides, the warning phrasing is also a bit
9652 inapropriate, we should use the word catchpoint, and tell
9653 the user what type of catchpoint it is. The above is good
9654 enough for now, though. */
9657 b = set_raw_breakpoint (gdbarch, sal, bp_breakpoint);
9658 set_breakpoint_count (breakpoint_count + 1);
9660 b->enable_state = bp_enabled;
9661 b->disposition = tempflag ? disp_del : disp_donttouch;
9662 b->number = breakpoint_count;
9663 b->ignore_count = 0;
9664 b->loc->cond = cond;
9665 b->addr_string = addr_string;
9666 b->language = language_ada;
9667 b->cond_string = cond_string;
9668 b->exp_string = exp_string;
9673 observer_notify_breakpoint_created (b);
9674 update_global_location_list (1);
9677 /* Implement the "catch exception" command. */
9680 catch_ada_exception_command (char *arg, int from_tty,
9681 struct cmd_list_element *command)
9683 struct gdbarch *gdbarch = get_current_arch ();
9685 struct symtab_and_line sal;
9686 char *addr_string = NULL;
9687 char *exp_string = NULL;
9688 char *cond_string = NULL;
9689 struct expression *cond = NULL;
9690 struct breakpoint_ops *ops = NULL;
9692 tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
9696 sal = ada_decode_exception_location (arg, &addr_string, &exp_string,
9697 &cond_string, &cond, &ops);
9698 create_ada_exception_breakpoint (gdbarch, sal, addr_string, exp_string,
9699 cond_string, cond, ops, tempflag,
9703 /* Cleanup function for a syscall filter list. */
9705 clean_up_filters (void *arg)
9707 VEC(int) *iter = *(VEC(int) **) arg;
9708 VEC_free (int, iter);
9711 /* Splits the argument using space as delimiter. Returns an xmalloc'd
9712 filter list, or NULL if no filtering is required. */
9714 catch_syscall_split_args (char *arg)
9716 VEC(int) *result = NULL;
9717 struct cleanup *cleanup = make_cleanup (clean_up_filters, &result);
9719 while (*arg != '\0')
9721 int i, syscall_number;
9726 /* Skip whitespace. */
9727 while (isspace (*arg))
9730 for (i = 0; i < 127 && arg[i] && !isspace (arg[i]); ++i)
9731 cur_name[i] = arg[i];
9735 /* Check if the user provided a syscall name or a number. */
9736 syscall_number = (int) strtol (cur_name, &endptr, 0);
9737 if (*endptr == '\0')
9738 get_syscall_by_number (syscall_number, &s);
9741 /* We have a name. Let's check if it's valid and convert it
9743 get_syscall_by_name (cur_name, &s);
9745 if (s.number == UNKNOWN_SYSCALL)
9746 /* Here we have to issue an error instead of a warning,
9747 because GDB cannot do anything useful if there's no
9748 syscall number to be caught. */
9749 error (_("Unknown syscall name '%s'."), cur_name);
9752 /* Ok, it's valid. */
9753 VEC_safe_push (int, result, s.number);
9756 discard_cleanups (cleanup);
9760 /* Implement the "catch syscall" command. */
9763 catch_syscall_command_1 (char *arg, int from_tty,
9764 struct cmd_list_element *command)
9769 struct gdbarch *gdbarch = get_current_arch ();
9771 /* Checking if the feature if supported. */
9772 if (gdbarch_get_syscall_number_p (gdbarch) == 0)
9773 error (_("The feature 'catch syscall' is not supported on \
9774 this architecture yet."));
9776 tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
9778 arg = skip_spaces (arg);
9780 /* We need to do this first "dummy" translation in order
9781 to get the syscall XML file loaded or, most important,
9782 to display a warning to the user if there's no XML file
9783 for his/her architecture. */
9784 get_syscall_by_number (0, &s);
9786 /* The allowed syntax is:
9788 catch syscall <name | number> [<name | number> ... <name | number>]
9790 Let's check if there's a syscall name. */
9793 filter = catch_syscall_split_args (arg);
9797 create_syscall_event_catchpoint (tempflag, filter,
9798 &catch_syscall_breakpoint_ops);
9801 /* Implement the "catch assert" command. */
9804 catch_assert_command (char *arg, int from_tty,
9805 struct cmd_list_element *command)
9807 struct gdbarch *gdbarch = get_current_arch ();
9809 struct symtab_and_line sal;
9810 char *addr_string = NULL;
9811 struct breakpoint_ops *ops = NULL;
9813 tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
9817 sal = ada_decode_assert_location (arg, &addr_string, &ops);
9818 create_ada_exception_breakpoint (gdbarch, sal, addr_string, NULL, NULL, NULL,
9819 ops, tempflag, from_tty);
9823 catch_command (char *arg, int from_tty)
9825 error (_("Catch requires an event name."));
9830 tcatch_command (char *arg, int from_tty)
9832 error (_("Catch requires an event name."));
9835 /* Delete breakpoints by address or line. */
9838 clear_command (char *arg, int from_tty)
9840 struct breakpoint *b;
9841 VEC(breakpoint_p) *found = 0;
9844 struct symtabs_and_lines sals;
9845 struct symtab_and_line sal;
9850 sals = decode_line_spec (arg, 1);
9855 sals.sals = (struct symtab_and_line *)
9856 xmalloc (sizeof (struct symtab_and_line));
9857 make_cleanup (xfree, sals.sals);
9858 init_sal (&sal); /* Initialize to zeroes. */
9859 sal.line = default_breakpoint_line;
9860 sal.symtab = default_breakpoint_symtab;
9861 sal.pc = default_breakpoint_address;
9862 sal.pspace = default_breakpoint_pspace;
9863 if (sal.symtab == 0)
9864 error (_("No source file specified."));
9872 /* We don't call resolve_sal_pc here. That's not as bad as it
9873 seems, because all existing breakpoints typically have both
9874 file/line and pc set. So, if clear is given file/line, we can
9875 match this to existing breakpoint without obtaining pc at all.
9877 We only support clearing given the address explicitly
9878 present in breakpoint table. Say, we've set breakpoint
9879 at file:line. There were several PC values for that file:line,
9880 due to optimization, all in one block.
9882 We've picked one PC value. If "clear" is issued with another
9883 PC corresponding to the same file:line, the breakpoint won't
9884 be cleared. We probably can still clear the breakpoint, but
9885 since the other PC value is never presented to user, user
9886 can only find it by guessing, and it does not seem important
9889 /* For each line spec given, delete bps which correspond to it. Do
9890 it in two passes, solely to preserve the current behavior that
9891 from_tty is forced true if we delete more than one
9895 for (i = 0; i < sals.nelts; i++)
9897 /* If exact pc given, clear bpts at that pc.
9898 If line given (pc == 0), clear all bpts on specified line.
9899 If defaulting, clear all bpts on default line
9902 defaulting sal.pc != 0 tests to do
9907 1 0 <can't happen> */
9911 /* Find all matching breakpoints and add them to 'found'. */
9915 /* Are we going to delete b? */
9916 if (b->type != bp_none && !is_watchpoint (b))
9918 struct bp_location *loc = b->loc;
9919 for (; loc; loc = loc->next)
9921 int pc_match = sal.pc
9922 && (loc->pspace == sal.pspace)
9923 && (loc->address == sal.pc)
9924 && (!section_is_overlay (loc->section)
9925 || loc->section == sal.section);
9926 int line_match = ((default_match || (0 == sal.pc))
9927 && b->source_file != NULL
9928 && sal.symtab != NULL
9929 && sal.pspace == loc->pspace
9930 && filename_cmp (b->source_file,
9931 sal.symtab->filename) == 0
9932 && b->line_number == sal.line);
9933 if (pc_match || line_match)
9942 VEC_safe_push(breakpoint_p, found, b);
9945 /* Now go thru the 'found' chain and delete them. */
9946 if (VEC_empty(breakpoint_p, found))
9949 error (_("No breakpoint at %s."), arg);
9951 error (_("No breakpoint at this line."));
9954 if (VEC_length(breakpoint_p, found) > 1)
9955 from_tty = 1; /* Always report if deleted more than one. */
9958 if (VEC_length(breakpoint_p, found) == 1)
9959 printf_unfiltered (_("Deleted breakpoint "));
9961 printf_unfiltered (_("Deleted breakpoints "));
9963 breakpoints_changed ();
9965 for (ix = 0; VEC_iterate(breakpoint_p, found, ix, b); ix++)
9968 printf_unfiltered ("%d ", b->number);
9969 delete_breakpoint (b);
9972 putchar_unfiltered ('\n');
9975 /* Delete breakpoint in BS if they are `delete' breakpoints and
9976 all breakpoints that are marked for deletion, whether hit or not.
9977 This is called after any breakpoint is hit, or after errors. */
9980 breakpoint_auto_delete (bpstat bs)
9982 struct breakpoint *b, *b_tmp;
9984 for (; bs; bs = bs->next)
9985 if (bs->breakpoint_at
9986 && bs->breakpoint_at->disposition == disp_del
9988 delete_breakpoint (bs->breakpoint_at);
9990 ALL_BREAKPOINTS_SAFE (b, b_tmp)
9992 if (b->disposition == disp_del_at_next_stop)
9993 delete_breakpoint (b);
9997 /* A comparison function for bp_location AP and BP being interfaced to
9998 qsort. Sort elements primarily by their ADDRESS (no matter what
9999 does breakpoint_address_is_meaningful say for its OWNER),
10000 secondarily by ordering first bp_permanent OWNERed elements and
10001 terciarily just ensuring the array is sorted stable way despite
10002 qsort being an instable algorithm. */
10005 bp_location_compare (const void *ap, const void *bp)
10007 struct bp_location *a = *(void **) ap;
10008 struct bp_location *b = *(void **) bp;
10009 /* A and B come from existing breakpoints having non-NULL OWNER. */
10010 int a_perm = a->owner->enable_state == bp_permanent;
10011 int b_perm = b->owner->enable_state == bp_permanent;
10013 if (a->address != b->address)
10014 return (a->address > b->address) - (a->address < b->address);
10016 /* Sort permanent breakpoints first. */
10017 if (a_perm != b_perm)
10018 return (a_perm < b_perm) - (a_perm > b_perm);
10020 /* Make the user-visible order stable across GDB runs. Locations of
10021 the same breakpoint can be sorted in arbitrary order. */
10023 if (a->owner->number != b->owner->number)
10024 return (a->owner->number > b->owner->number)
10025 - (a->owner->number < b->owner->number);
10027 return (a > b) - (a < b);
10030 /* Set bp_location_placed_address_before_address_max and
10031 bp_location_shadow_len_after_address_max according to the current
10032 content of the bp_location array. */
10035 bp_location_target_extensions_update (void)
10037 struct bp_location *bl, **blp_tmp;
10039 bp_location_placed_address_before_address_max = 0;
10040 bp_location_shadow_len_after_address_max = 0;
10042 ALL_BP_LOCATIONS (bl, blp_tmp)
10044 CORE_ADDR start, end, addr;
10046 if (!bp_location_has_shadow (bl))
10049 start = bl->target_info.placed_address;
10050 end = start + bl->target_info.shadow_len;
10052 gdb_assert (bl->address >= start);
10053 addr = bl->address - start;
10054 if (addr > bp_location_placed_address_before_address_max)
10055 bp_location_placed_address_before_address_max = addr;
10057 /* Zero SHADOW_LEN would not pass bp_location_has_shadow. */
10059 gdb_assert (bl->address < end);
10060 addr = end - bl->address;
10061 if (addr > bp_location_shadow_len_after_address_max)
10062 bp_location_shadow_len_after_address_max = addr;
10066 /* If SHOULD_INSERT is false, do not insert any breakpoint locations
10067 into the inferior, only remove already-inserted locations that no
10068 longer should be inserted. Functions that delete a breakpoint or
10069 breakpoints should pass false, so that deleting a breakpoint
10070 doesn't have the side effect of inserting the locations of other
10071 breakpoints that are marked not-inserted, but should_be_inserted
10072 returns true on them.
10074 This behaviour is useful is situations close to tear-down -- e.g.,
10075 after an exec, while the target still has execution, but breakpoint
10076 shadows of the previous executable image should *NOT* be restored
10077 to the new image; or before detaching, where the target still has
10078 execution and wants to delete breakpoints from GDB's lists, and all
10079 breakpoints had already been removed from the inferior. */
10082 update_global_location_list (int should_insert)
10084 struct breakpoint *b;
10085 struct bp_location **locp, *loc;
10086 struct cleanup *cleanups;
10088 /* Used in the duplicates detection below. When iterating over all
10089 bp_locations, points to the first bp_location of a given address.
10090 Breakpoints and watchpoints of different types are never
10091 duplicates of each other. Keep one pointer for each type of
10092 breakpoint/watchpoint, so we only need to loop over all locations
10094 struct bp_location *bp_loc_first; /* breakpoint */
10095 struct bp_location *wp_loc_first; /* hardware watchpoint */
10096 struct bp_location *awp_loc_first; /* access watchpoint */
10097 struct bp_location *rwp_loc_first; /* read watchpoint */
10099 /* Saved former bp_location array which we compare against the newly
10100 built bp_location from the current state of ALL_BREAKPOINTS. */
10101 struct bp_location **old_location, **old_locp;
10102 unsigned old_location_count;
10104 old_location = bp_location;
10105 old_location_count = bp_location_count;
10106 bp_location = NULL;
10107 bp_location_count = 0;
10108 cleanups = make_cleanup (xfree, old_location);
10110 ALL_BREAKPOINTS (b)
10111 for (loc = b->loc; loc; loc = loc->next)
10112 bp_location_count++;
10114 bp_location = xmalloc (sizeof (*bp_location) * bp_location_count);
10115 locp = bp_location;
10116 ALL_BREAKPOINTS (b)
10117 for (loc = b->loc; loc; loc = loc->next)
10119 qsort (bp_location, bp_location_count, sizeof (*bp_location),
10120 bp_location_compare);
10122 bp_location_target_extensions_update ();
10124 /* Identify bp_location instances that are no longer present in the
10125 new list, and therefore should be freed. Note that it's not
10126 necessary that those locations should be removed from inferior --
10127 if there's another location at the same address (previously
10128 marked as duplicate), we don't need to remove/insert the
10131 LOCP is kept in sync with OLD_LOCP, each pointing to the current
10132 and former bp_location array state respectively. */
10134 locp = bp_location;
10135 for (old_locp = old_location; old_locp < old_location + old_location_count;
10138 struct bp_location *old_loc = *old_locp;
10139 struct bp_location **loc2p;
10141 /* Tells if 'old_loc' is found amoung the new locations. If
10142 not, we have to free it. */
10143 int found_object = 0;
10144 /* Tells if the location should remain inserted in the target. */
10145 int keep_in_target = 0;
10148 /* Skip LOCP entries which will definitely never be needed.
10149 Stop either at or being the one matching OLD_LOC. */
10150 while (locp < bp_location + bp_location_count
10151 && (*locp)->address < old_loc->address)
10155 (loc2p < bp_location + bp_location_count
10156 && (*loc2p)->address == old_loc->address);
10159 if (*loc2p == old_loc)
10166 /* If this location is no longer present, and inserted, look if
10167 there's maybe a new location at the same address. If so,
10168 mark that one inserted, and don't remove this one. This is
10169 needed so that we don't have a time window where a breakpoint
10170 at certain location is not inserted. */
10172 if (old_loc->inserted)
10174 /* If the location is inserted now, we might have to remove
10177 if (found_object && should_be_inserted (old_loc))
10179 /* The location is still present in the location list,
10180 and still should be inserted. Don't do anything. */
10181 keep_in_target = 1;
10185 /* The location is either no longer present, or got
10186 disabled. See if there's another location at the
10187 same address, in which case we don't need to remove
10188 this one from the target. */
10190 /* OLD_LOC comes from existing struct breakpoint. */
10191 if (breakpoint_address_is_meaningful (old_loc->owner))
10194 (loc2p < bp_location + bp_location_count
10195 && (*loc2p)->address == old_loc->address);
10198 struct bp_location *loc2 = *loc2p;
10200 if (breakpoint_locations_match (loc2, old_loc))
10202 /* For the sake of should_be_inserted.
10203 Duplicates check below will fix up this
10205 loc2->duplicate = 0;
10207 /* Read watchpoint locations are switched to
10208 access watchpoints, if the former are not
10209 supported, but the latter are. */
10210 if (is_hardware_watchpoint (old_loc->owner))
10212 gdb_assert (is_hardware_watchpoint (loc2->owner));
10213 loc2->watchpoint_type = old_loc->watchpoint_type;
10216 if (loc2 != old_loc && should_be_inserted (loc2))
10218 loc2->inserted = 1;
10219 loc2->target_info = old_loc->target_info;
10220 keep_in_target = 1;
10228 if (!keep_in_target)
10230 if (remove_breakpoint (old_loc, mark_uninserted))
10232 /* This is just about all we can do. We could keep
10233 this location on the global list, and try to
10234 remove it next time, but there's no particular
10235 reason why we will succeed next time.
10237 Note that at this point, old_loc->owner is still
10238 valid, as delete_breakpoint frees the breakpoint
10239 only after calling us. */
10240 printf_filtered (_("warning: Error removing "
10241 "breakpoint %d\n"),
10242 old_loc->owner->number);
10250 if (removed && non_stop
10251 && breakpoint_address_is_meaningful (old_loc->owner)
10252 && !is_hardware_watchpoint (old_loc->owner))
10254 /* This location was removed from the target. In
10255 non-stop mode, a race condition is possible where
10256 we've removed a breakpoint, but stop events for that
10257 breakpoint are already queued and will arrive later.
10258 We apply an heuristic to be able to distinguish such
10259 SIGTRAPs from other random SIGTRAPs: we keep this
10260 breakpoint location for a bit, and will retire it
10261 after we see some number of events. The theory here
10262 is that reporting of events should, "on the average",
10263 be fair, so after a while we'll see events from all
10264 threads that have anything of interest, and no longer
10265 need to keep this breakpoint location around. We
10266 don't hold locations forever so to reduce chances of
10267 mistaking a non-breakpoint SIGTRAP for a breakpoint
10270 The heuristic failing can be disastrous on
10271 decr_pc_after_break targets.
10273 On decr_pc_after_break targets, like e.g., x86-linux,
10274 if we fail to recognize a late breakpoint SIGTRAP,
10275 because events_till_retirement has reached 0 too
10276 soon, we'll fail to do the PC adjustment, and report
10277 a random SIGTRAP to the user. When the user resumes
10278 the inferior, it will most likely immediately crash
10279 with SIGILL/SIGBUS/SIGSEGV, or worse, get silently
10280 corrupted, because of being resumed e.g., in the
10281 middle of a multi-byte instruction, or skipped a
10282 one-byte instruction. This was actually seen happen
10283 on native x86-linux, and should be less rare on
10284 targets that do not support new thread events, like
10285 remote, due to the heuristic depending on
10288 Mistaking a random SIGTRAP for a breakpoint trap
10289 causes similar symptoms (PC adjustment applied when
10290 it shouldn't), but then again, playing with SIGTRAPs
10291 behind the debugger's back is asking for trouble.
10293 Since hardware watchpoint traps are always
10294 distinguishable from other traps, so we don't need to
10295 apply keep hardware watchpoint moribund locations
10296 around. We simply always ignore hardware watchpoint
10297 traps we can no longer explain. */
10299 old_loc->events_till_retirement = 3 * (thread_count () + 1);
10300 old_loc->owner = NULL;
10302 VEC_safe_push (bp_location_p, moribund_locations, old_loc);
10306 old_loc->owner = NULL;
10307 decref_bp_location (&old_loc);
10312 /* Rescan breakpoints at the same address and section, marking the
10313 first one as "first" and any others as "duplicates". This is so
10314 that the bpt instruction is only inserted once. If we have a
10315 permanent breakpoint at the same place as BPT, make that one the
10316 official one, and the rest as duplicates. Permanent breakpoints
10317 are sorted first for the same address.
10319 Do the same for hardware watchpoints, but also considering the
10320 watchpoint's type (regular/access/read) and length. */
10322 bp_loc_first = NULL;
10323 wp_loc_first = NULL;
10324 awp_loc_first = NULL;
10325 rwp_loc_first = NULL;
10326 ALL_BP_LOCATIONS (loc, locp)
10328 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always
10330 struct breakpoint *b = loc->owner;
10331 struct bp_location **loc_first_p;
10333 if (b->enable_state == bp_disabled
10334 || b->enable_state == bp_call_disabled
10335 || b->enable_state == bp_startup_disabled
10337 || loc->shlib_disabled
10338 || !breakpoint_address_is_meaningful (b)
10339 || is_tracepoint (b))
10342 /* Permanent breakpoint should always be inserted. */
10343 if (b->enable_state == bp_permanent && ! loc->inserted)
10344 internal_error (__FILE__, __LINE__,
10345 _("allegedly permanent breakpoint is not "
10346 "actually inserted"));
10348 if (b->type == bp_hardware_watchpoint)
10349 loc_first_p = &wp_loc_first;
10350 else if (b->type == bp_read_watchpoint)
10351 loc_first_p = &rwp_loc_first;
10352 else if (b->type == bp_access_watchpoint)
10353 loc_first_p = &awp_loc_first;
10355 loc_first_p = &bp_loc_first;
10357 if (*loc_first_p == NULL
10358 || (overlay_debugging && loc->section != (*loc_first_p)->section)
10359 || !breakpoint_locations_match (loc, *loc_first_p))
10361 *loc_first_p = loc;
10362 loc->duplicate = 0;
10366 loc->duplicate = 1;
10368 if ((*loc_first_p)->owner->enable_state == bp_permanent && loc->inserted
10369 && b->enable_state != bp_permanent)
10370 internal_error (__FILE__, __LINE__,
10371 _("another breakpoint was inserted on top of "
10372 "a permanent breakpoint"));
10375 if (breakpoints_always_inserted_mode () && should_insert
10376 && (have_live_inferiors ()
10377 || (gdbarch_has_global_breakpoints (target_gdbarch))))
10378 insert_breakpoint_locations ();
10380 do_cleanups (cleanups);
10384 breakpoint_retire_moribund (void)
10386 struct bp_location *loc;
10389 for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
10390 if (--(loc->events_till_retirement) == 0)
10392 decref_bp_location (&loc);
10393 VEC_unordered_remove (bp_location_p, moribund_locations, ix);
10399 update_global_location_list_nothrow (int inserting)
10401 struct gdb_exception e;
10403 TRY_CATCH (e, RETURN_MASK_ERROR)
10404 update_global_location_list (inserting);
10407 /* Clear BKP from a BPS. */
10410 bpstat_remove_bp_location (bpstat bps, struct breakpoint *bpt)
10414 for (bs = bps; bs; bs = bs->next)
10415 if (bs->breakpoint_at == bpt)
10417 bs->breakpoint_at = NULL;
10418 bs->old_val = NULL;
10419 /* bs->commands will be freed later. */
10423 /* Callback for iterate_over_threads. */
10425 bpstat_remove_breakpoint_callback (struct thread_info *th, void *data)
10427 struct breakpoint *bpt = data;
10429 bpstat_remove_bp_location (th->control.stop_bpstat, bpt);
10433 /* Delete a breakpoint and clean up all traces of it in the data
10437 delete_breakpoint (struct breakpoint *bpt)
10439 struct breakpoint *b;
10441 gdb_assert (bpt != NULL);
10443 /* Has this bp already been deleted? This can happen because
10444 multiple lists can hold pointers to bp's. bpstat lists are
10447 One example of this happening is a watchpoint's scope bp. When
10448 the scope bp triggers, we notice that the watchpoint is out of
10449 scope, and delete it. We also delete its scope bp. But the
10450 scope bp is marked "auto-deleting", and is already on a bpstat.
10451 That bpstat is then checked for auto-deleting bp's, which are
10454 A real solution to this problem might involve reference counts in
10455 bp's, and/or giving them pointers back to their referencing
10456 bpstat's, and teaching delete_breakpoint to only free a bp's
10457 storage when no more references were extent. A cheaper bandaid
10459 if (bpt->type == bp_none)
10462 /* At least avoid this stale reference until the reference counting
10463 of breakpoints gets resolved. */
10464 if (bpt->related_breakpoint != bpt)
10466 struct breakpoint *related;
10468 if (bpt->type == bp_watchpoint_scope)
10469 watchpoint_del_at_next_stop (bpt->related_breakpoint);
10470 else if (bpt->related_breakpoint->type == bp_watchpoint_scope)
10471 watchpoint_del_at_next_stop (bpt);
10473 /* Unlink bpt from the bpt->related_breakpoint ring. */
10474 for (related = bpt; related->related_breakpoint != bpt;
10475 related = related->related_breakpoint);
10476 related->related_breakpoint = bpt->related_breakpoint;
10477 bpt->related_breakpoint = bpt;
10480 /* watch_command_1 creates a watchpoint but only sets its number if
10481 update_watchpoint succeeds in creating its bp_locations. If there's
10482 a problem in that process, we'll be asked to delete the half-created
10483 watchpoint. In that case, don't announce the deletion. */
10485 observer_notify_breakpoint_deleted (bpt);
10487 if (breakpoint_chain == bpt)
10488 breakpoint_chain = bpt->next;
10490 ALL_BREAKPOINTS (b)
10491 if (b->next == bpt)
10493 b->next = bpt->next;
10497 decref_counted_command_line (&bpt->commands);
10498 xfree (bpt->cond_string);
10499 xfree (bpt->cond_exp);
10500 xfree (bpt->addr_string);
10501 xfree (bpt->addr_string_range_end);
10503 xfree (bpt->exp_string);
10504 xfree (bpt->exp_string_reparse);
10505 value_free (bpt->val);
10506 xfree (bpt->source_file);
10507 xfree (bpt->exec_pathname);
10508 clean_up_filters (&bpt->syscalls_to_be_caught);
10511 /* Be sure no bpstat's are pointing at the breakpoint after it's
10513 /* FIXME, how can we find all bpstat's? We just check stop_bpstat
10514 in all threeds for now. Note that we cannot just remove bpstats
10515 pointing at bpt from the stop_bpstat list entirely, as breakpoint
10516 commands are associated with the bpstat; if we remove it here,
10517 then the later call to bpstat_do_actions (&stop_bpstat); in
10518 event-top.c won't do anything, and temporary breakpoints with
10519 commands won't work. */
10521 iterate_over_threads (bpstat_remove_breakpoint_callback, bpt);
10523 /* Now that breakpoint is removed from breakpoint list, update the
10524 global location list. This will remove locations that used to
10525 belong to this breakpoint. Do this before freeing the breakpoint
10526 itself, since remove_breakpoint looks at location's owner. It
10527 might be better design to have location completely
10528 self-contained, but it's not the case now. */
10529 update_global_location_list (0);
10532 /* On the chance that someone will soon try again to delete this
10533 same bp, we mark it as deleted before freeing its storage. */
10534 bpt->type = bp_none;
10540 do_delete_breakpoint_cleanup (void *b)
10542 delete_breakpoint (b);
10546 make_cleanup_delete_breakpoint (struct breakpoint *b)
10548 return make_cleanup (do_delete_breakpoint_cleanup, b);
10551 /* A callback for map_breakpoint_numbers that calls
10552 delete_breakpoint. */
10555 do_delete_breakpoint (struct breakpoint *b, void *ignore)
10557 delete_breakpoint (b);
10561 delete_command (char *arg, int from_tty)
10563 struct breakpoint *b, *b_tmp;
10569 int breaks_to_delete = 0;
10571 /* Delete all breakpoints if no argument. Do not delete
10572 internal breakpoints, these have to be deleted with an
10573 explicit breakpoint number argument. */
10574 ALL_BREAKPOINTS (b)
10575 if (user_breakpoint_p (b))
10577 breaks_to_delete = 1;
10581 /* Ask user only if there are some breakpoints to delete. */
10583 || (breaks_to_delete && query (_("Delete all breakpoints? "))))
10585 ALL_BREAKPOINTS_SAFE (b, b_tmp)
10586 if (user_breakpoint_p (b))
10587 delete_breakpoint (b);
10591 map_breakpoint_numbers (arg, do_delete_breakpoint, NULL);
10595 all_locations_are_pending (struct bp_location *loc)
10597 for (; loc; loc = loc->next)
10598 if (!loc->shlib_disabled)
10603 /* Subroutine of update_breakpoint_locations to simplify it.
10604 Return non-zero if multiple fns in list LOC have the same name.
10605 Null names are ignored. */
10608 ambiguous_names_p (struct bp_location *loc)
10610 struct bp_location *l;
10611 htab_t htab = htab_create_alloc (13, htab_hash_string,
10612 (int (*) (const void *,
10613 const void *)) streq,
10614 NULL, xcalloc, xfree);
10616 for (l = loc; l != NULL; l = l->next)
10619 const char *name = l->function_name;
10621 /* Allow for some names to be NULL, ignore them. */
10625 slot = (const char **) htab_find_slot (htab, (const void *) name,
10627 /* NOTE: We can assume slot != NULL here because xcalloc never
10631 htab_delete (htab);
10637 htab_delete (htab);
10641 /* When symbols change, it probably means the sources changed as well,
10642 and it might mean the static tracepoint markers are no longer at
10643 the same address or line numbers they used to be at last we
10644 checked. Losing your static tracepoints whenever you rebuild is
10645 undesirable. This function tries to resync/rematch gdb static
10646 tracepoints with the markers on the target, for static tracepoints
10647 that have not been set by marker id. Static tracepoint that have
10648 been set by marker id are reset by marker id in breakpoint_re_set.
10651 1) For a tracepoint set at a specific address, look for a marker at
10652 the old PC. If one is found there, assume to be the same marker.
10653 If the name / string id of the marker found is different from the
10654 previous known name, assume that means the user renamed the marker
10655 in the sources, and output a warning.
10657 2) For a tracepoint set at a given line number, look for a marker
10658 at the new address of the old line number. If one is found there,
10659 assume to be the same marker. If the name / string id of the
10660 marker found is different from the previous known name, assume that
10661 means the user renamed the marker in the sources, and output a
10664 3) If a marker is no longer found at the same address or line, it
10665 may mean the marker no longer exists. But it may also just mean
10666 the code changed a bit. Maybe the user added a few lines of code
10667 that made the marker move up or down (in line number terms). Ask
10668 the target for info about the marker with the string id as we knew
10669 it. If found, update line number and address in the matching
10670 static tracepoint. This will get confused if there's more than one
10671 marker with the same ID (possible in UST, although unadvised
10672 precisely because it confuses tools). */
10674 static struct symtab_and_line
10675 update_static_tracepoint (struct breakpoint *b, struct symtab_and_line sal)
10677 struct static_tracepoint_marker marker;
10683 find_line_pc (sal.symtab, sal.line, &pc);
10685 if (target_static_tracepoint_marker_at (pc, &marker))
10687 if (strcmp (b->static_trace_marker_id, marker.str_id) != 0)
10688 warning (_("static tracepoint %d changed probed marker from %s to %s"),
10690 b->static_trace_marker_id, marker.str_id);
10692 xfree (b->static_trace_marker_id);
10693 b->static_trace_marker_id = xstrdup (marker.str_id);
10694 release_static_tracepoint_marker (&marker);
10699 /* Old marker wasn't found on target at lineno. Try looking it up
10701 if (!sal.explicit_pc
10703 && sal.symtab != NULL
10704 && b->static_trace_marker_id != NULL)
10706 VEC(static_tracepoint_marker_p) *markers;
10709 = target_static_tracepoint_markers_by_strid (b->static_trace_marker_id);
10711 if (!VEC_empty(static_tracepoint_marker_p, markers))
10713 struct symtab_and_line sal;
10714 struct symbol *sym;
10715 struct static_tracepoint_marker *marker;
10717 marker = VEC_index (static_tracepoint_marker_p, markers, 0);
10719 xfree (b->static_trace_marker_id);
10720 b->static_trace_marker_id = xstrdup (marker->str_id);
10722 warning (_("marker for static tracepoint %d (%s) not "
10723 "found at previous line number"),
10724 b->number, b->static_trace_marker_id);
10728 sal.pc = marker->address;
10730 sal = find_pc_line (marker->address, 0);
10731 sym = find_pc_sect_function (marker->address, NULL);
10732 ui_out_text (uiout, "Now in ");
10735 ui_out_field_string (uiout, "func",
10736 SYMBOL_PRINT_NAME (sym));
10737 ui_out_text (uiout, " at ");
10739 ui_out_field_string (uiout, "file", sal.symtab->filename);
10740 ui_out_text (uiout, ":");
10742 if (ui_out_is_mi_like_p (uiout))
10744 char *fullname = symtab_to_fullname (sal.symtab);
10747 ui_out_field_string (uiout, "fullname", fullname);
10750 ui_out_field_int (uiout, "line", sal.line);
10751 ui_out_text (uiout, "\n");
10753 b->line_number = sal.line;
10755 xfree (b->source_file);
10757 b->source_file = xstrdup (sal.symtab->filename);
10759 b->source_file = NULL;
10761 xfree (b->addr_string);
10762 b->addr_string = xstrprintf ("%s:%d",
10763 sal.symtab->filename, b->line_number);
10765 /* Might be nice to check if function changed, and warn if
10768 release_static_tracepoint_marker (marker);
10774 /* Returns 1 iff locations A and B are sufficiently same that
10775 we don't need to report breakpoint as changed. */
10778 locations_are_equal (struct bp_location *a, struct bp_location *b)
10782 if (a->address != b->address)
10785 if (a->shlib_disabled != b->shlib_disabled)
10788 if (a->enabled != b->enabled)
10795 if ((a == NULL) != (b == NULL))
10801 /* Create new breakpoint locations for B (a hardware or software breakpoint)
10802 based on SALS and SALS_END. If SALS_END.NELTS is not zero, then B is
10803 a ranged breakpoint. */
10806 update_breakpoint_locations (struct breakpoint *b,
10807 struct symtabs_and_lines sals,
10808 struct symtabs_and_lines sals_end)
10811 struct bp_location *existing_locations = b->loc;
10813 /* Ranged breakpoints have only one start location and one end location. */
10814 gdb_assert (sals_end.nelts == 0 || (sals.nelts == 1 && sals_end.nelts == 1));
10816 /* If there's no new locations, and all existing locations are
10817 pending, don't do anything. This optimizes the common case where
10818 all locations are in the same shared library, that was unloaded.
10819 We'd like to retain the location, so that when the library is
10820 loaded again, we don't loose the enabled/disabled status of the
10821 individual locations. */
10822 if (all_locations_are_pending (existing_locations) && sals.nelts == 0)
10827 for (i = 0; i < sals.nelts; ++i)
10829 struct bp_location *new_loc =
10830 add_location_to_breakpoint (b, &(sals.sals[i]));
10832 /* Reparse conditions, they might contain references to the
10834 if (b->cond_string != NULL)
10837 struct gdb_exception e;
10839 s = b->cond_string;
10840 TRY_CATCH (e, RETURN_MASK_ERROR)
10842 new_loc->cond = parse_exp_1 (&s, block_for_pc (sals.sals[i].pc),
10847 warning (_("failed to reevaluate condition "
10848 "for breakpoint %d: %s"),
10849 b->number, e.message);
10850 new_loc->enabled = 0;
10854 if (b->source_file != NULL)
10855 xfree (b->source_file);
10856 if (sals.sals[i].symtab == NULL)
10857 b->source_file = NULL;
10859 b->source_file = xstrdup (sals.sals[i].symtab->filename);
10861 if (b->line_number == 0)
10862 b->line_number = sals.sals[i].line;
10864 if (sals_end.nelts)
10866 CORE_ADDR end = find_breakpoint_range_end (sals_end.sals[0]);
10868 new_loc->length = end - sals.sals[0].pc + 1;
10872 /* Update locations of permanent breakpoints. */
10873 if (b->enable_state == bp_permanent)
10874 make_breakpoint_permanent (b);
10876 /* If possible, carry over 'disable' status from existing
10879 struct bp_location *e = existing_locations;
10880 /* If there are multiple breakpoints with the same function name,
10881 e.g. for inline functions, comparing function names won't work.
10882 Instead compare pc addresses; this is just a heuristic as things
10883 may have moved, but in practice it gives the correct answer
10884 often enough until a better solution is found. */
10885 int have_ambiguous_names = ambiguous_names_p (b->loc);
10887 for (; e; e = e->next)
10889 if (!e->enabled && e->function_name)
10891 struct bp_location *l = b->loc;
10892 if (have_ambiguous_names)
10894 for (; l; l = l->next)
10895 if (breakpoint_locations_match (e, l))
10903 for (; l; l = l->next)
10904 if (l->function_name
10905 && strcmp (e->function_name, l->function_name) == 0)
10915 if (!locations_are_equal (existing_locations, b->loc))
10916 observer_notify_breakpoint_modified (b);
10918 update_global_location_list (1);
10921 /* Find the SaL locations corresponding to the given ADDR_STRING.
10922 On return, FOUND will be 1 if any SaL was found, zero otherwise. */
10924 static struct symtabs_and_lines
10925 addr_string_to_sals (struct breakpoint *b, char *addr_string, int *found)
10929 struct symtabs_and_lines sals = {0};
10930 struct gdb_exception e;
10933 marker_spec = b->type == bp_static_tracepoint && is_marker_spec (s);
10935 TRY_CATCH (e, RETURN_MASK_ERROR)
10939 sals = decode_static_tracepoint_spec (&s);
10940 if (sals.nelts > b->static_trace_marker_id_idx)
10942 sals.sals[0] = sals.sals[b->static_trace_marker_id_idx];
10946 error (_("marker %s not found"), b->static_trace_marker_id);
10949 sals = decode_line_1 (&s, 1, (struct symtab *) NULL, 0, NULL);
10953 int not_found_and_ok = 0;
10954 /* For pending breakpoints, it's expected that parsing will
10955 fail until the right shared library is loaded. User has
10956 already told to create pending breakpoints and don't need
10957 extra messages. If breakpoint is in bp_shlib_disabled
10958 state, then user already saw the message about that
10959 breakpoint being disabled, and don't want to see more
10961 if (e.error == NOT_FOUND_ERROR
10962 && (b->condition_not_parsed
10963 || (b->loc && b->loc->shlib_disabled)
10964 || b->enable_state == bp_disabled))
10965 not_found_and_ok = 1;
10967 if (!not_found_and_ok)
10969 /* We surely don't want to warn about the same breakpoint
10970 10 times. One solution, implemented here, is disable
10971 the breakpoint on error. Another solution would be to
10972 have separate 'warning emitted' flag. Since this
10973 happens only when a binary has changed, I don't know
10974 which approach is better. */
10975 b->enable_state = bp_disabled;
10976 throw_exception (e);
10980 if (e.reason == 0 || e.error != NOT_FOUND_ERROR)
10982 gdb_assert (sals.nelts == 1);
10984 resolve_sal_pc (&sals.sals[0]);
10985 if (b->condition_not_parsed && s && s[0])
10987 char *cond_string = 0;
10991 find_condition_and_thread (s, sals.sals[0].pc,
10992 &cond_string, &thread, &task);
10994 b->cond_string = cond_string;
10995 b->thread = thread;
10997 b->condition_not_parsed = 0;
11000 if (b->type == bp_static_tracepoint && !marker_spec)
11001 sals.sals[0] = update_static_tracepoint (b, sals.sals[0]);
11011 /* Reevaluate a hardware or software breakpoint and recreate its locations.
11012 This is necessary after symbols are read (e.g., an executable or DSO
11013 was loaded, or the inferior just started). */
11016 re_set_breakpoint (struct breakpoint *b)
11019 struct symtabs_and_lines sals, sals_end;
11020 struct symtabs_and_lines expanded = {0};
11021 struct symtabs_and_lines expanded_end = {0};
11022 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
11024 input_radix = b->input_radix;
11025 save_current_space_and_thread ();
11026 switch_to_program_space_and_thread (b->pspace);
11027 set_language (b->language);
11029 sals = addr_string_to_sals (b, b->addr_string, &found);
11032 make_cleanup (xfree, sals.sals);
11033 expanded = expand_line_sal_maybe (sals.sals[0]);
11036 if (b->addr_string_range_end)
11038 sals_end = addr_string_to_sals (b, b->addr_string_range_end, &found);
11041 make_cleanup (xfree, sals_end.sals);
11042 expanded_end = expand_line_sal_maybe (sals_end.sals[0]);
11046 update_breakpoint_locations (b, expanded, expanded_end);
11047 do_cleanups (cleanups);
11050 /* Reset a breakpoint given it's struct breakpoint * BINT.
11051 The value we return ends up being the return value from catch_errors.
11052 Unused in this case. */
11055 breakpoint_re_set_one (void *bint)
11057 /* Get past catch_errs. */
11058 struct breakpoint *b = (struct breakpoint *) bint;
11063 warning (_("attempted to reset apparently deleted breakpoint #%d?"),
11066 case bp_breakpoint:
11067 case bp_hardware_breakpoint:
11068 case bp_tracepoint:
11069 case bp_fast_tracepoint:
11070 case bp_static_tracepoint:
11071 case bp_gnu_ifunc_resolver:
11072 /* Do not attempt to re-set breakpoints disabled during startup. */
11073 if (b->enable_state == bp_startup_disabled)
11076 if (b->addr_string == NULL)
11078 /* Anything without a string can't be re-set. */
11079 delete_breakpoint (b);
11083 re_set_breakpoint (b);
11086 case bp_watchpoint:
11087 case bp_hardware_watchpoint:
11088 case bp_read_watchpoint:
11089 case bp_access_watchpoint:
11090 /* Watchpoint can be either on expression using entirely global
11091 variables, or it can be on local variables.
11093 Watchpoints of the first kind are never auto-deleted, and
11094 even persist across program restarts. Since they can use
11095 variables from shared libraries, we need to reparse
11096 expression as libraries are loaded and unloaded.
11098 Watchpoints on local variables can also change meaning as
11099 result of solib event. For example, if a watchpoint uses
11100 both a local and a global variables in expression, it's a
11101 local watchpoint, but unloading of a shared library will make
11102 the expression invalid. This is not a very common use case,
11103 but we still re-evaluate expression, to avoid surprises to
11106 Note that for local watchpoints, we re-evaluate it only if
11107 watchpoints frame id is still valid. If it's not, it means
11108 the watchpoint is out of scope and will be deleted soon. In
11109 fact, I'm not sure we'll ever be called in this case.
11111 If a local watchpoint's frame id is still valid, then
11112 b->exp_valid_block is likewise valid, and we can safely use it.
11114 Don't do anything about disabled watchpoints, since they will
11115 be reevaluated again when enabled. */
11116 update_watchpoint (b, 1 /* reparse */);
11118 /* We needn't really do anything to reset these, since the mask
11119 that requests them is unaffected by e.g., new libraries being
11121 case bp_catchpoint:
11125 printf_filtered (_("Deleting unknown breakpoint type %d\n"), b->type);
11127 /* Delete overlay event and longjmp master breakpoints; they will be
11128 reset later by breakpoint_re_set. */
11129 case bp_overlay_event:
11130 case bp_longjmp_master:
11131 case bp_std_terminate_master:
11132 case bp_exception_master:
11133 delete_breakpoint (b);
11136 /* This breakpoint is special, it's set up when the inferior
11137 starts and we really don't want to touch it. */
11138 case bp_shlib_event:
11140 /* Like bp_shlib_event, this breakpoint type is special.
11141 Once it is set up, we do not want to touch it. */
11142 case bp_thread_event:
11144 /* Keep temporary breakpoints, which can be encountered when we
11145 step over a dlopen call and SOLIB_ADD is resetting the
11146 breakpoints. Otherwise these should have been blown away via
11147 the cleanup chain or by breakpoint_init_inferior when we
11148 rerun the executable. */
11151 case bp_watchpoint_scope:
11152 case bp_call_dummy:
11153 case bp_std_terminate:
11154 case bp_step_resume:
11156 case bp_longjmp_resume:
11158 case bp_exception_resume:
11160 case bp_gnu_ifunc_resolver_return:
11167 /* Re-set all breakpoints after symbols have been re-loaded. */
11169 breakpoint_re_set (void)
11171 struct breakpoint *b, *b_tmp;
11172 enum language save_language;
11173 int save_input_radix;
11174 struct cleanup *old_chain;
11176 save_language = current_language->la_language;
11177 save_input_radix = input_radix;
11178 old_chain = save_current_program_space ();
11180 ALL_BREAKPOINTS_SAFE (b, b_tmp)
11182 /* Format possible error msg. */
11183 char *message = xstrprintf ("Error in re-setting breakpoint %d: ",
11185 struct cleanup *cleanups = make_cleanup (xfree, message);
11186 catch_errors (breakpoint_re_set_one, b, message, RETURN_MASK_ALL);
11187 do_cleanups (cleanups);
11189 set_language (save_language);
11190 input_radix = save_input_radix;
11192 jit_breakpoint_re_set ();
11194 do_cleanups (old_chain);
11196 create_overlay_event_breakpoint ();
11197 create_longjmp_master_breakpoint ();
11198 create_std_terminate_master_breakpoint ();
11199 create_exception_master_breakpoint ();
11202 /* Reset the thread number of this breakpoint:
11204 - If the breakpoint is for all threads, leave it as-is.
11205 - Else, reset it to the current thread for inferior_ptid. */
11207 breakpoint_re_set_thread (struct breakpoint *b)
11209 if (b->thread != -1)
11211 if (in_thread_list (inferior_ptid))
11212 b->thread = pid_to_thread_id (inferior_ptid);
11214 /* We're being called after following a fork. The new fork is
11215 selected as current, and unless this was a vfork will have a
11216 different program space from the original thread. Reset that
11218 b->loc->pspace = current_program_space;
11222 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
11223 If from_tty is nonzero, it prints a message to that effect,
11224 which ends with a period (no newline). */
11227 set_ignore_count (int bptnum, int count, int from_tty)
11229 struct breakpoint *b;
11234 ALL_BREAKPOINTS (b)
11235 if (b->number == bptnum)
11237 if (is_tracepoint (b))
11239 if (from_tty && count != 0)
11240 printf_filtered (_("Ignore count ignored for tracepoint %d."),
11245 b->ignore_count = count;
11249 printf_filtered (_("Will stop next time "
11250 "breakpoint %d is reached."),
11252 else if (count == 1)
11253 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
11256 printf_filtered (_("Will ignore next %d "
11257 "crossings of breakpoint %d."),
11260 breakpoints_changed ();
11261 observer_notify_breakpoint_modified (b);
11265 error (_("No breakpoint number %d."), bptnum);
11268 /* Command to set ignore-count of breakpoint N to COUNT. */
11271 ignore_command (char *args, int from_tty)
11277 error_no_arg (_("a breakpoint number"));
11279 num = get_number (&p);
11281 error (_("bad breakpoint number: '%s'"), args);
11283 error (_("Second argument (specified ignore-count) is missing."));
11285 set_ignore_count (num,
11286 longest_to_int (value_as_long (parse_and_eval (p))),
11289 printf_filtered ("\n");
11292 /* Call FUNCTION on each of the breakpoints
11293 whose numbers are given in ARGS. */
11296 map_breakpoint_numbers (char *args, void (*function) (struct breakpoint *,
11301 struct breakpoint *b, *tmp;
11303 struct get_number_or_range_state state;
11306 error_no_arg (_("one or more breakpoint numbers"));
11308 init_number_or_range (&state, args);
11310 while (!state.finished)
11312 char *p = state.string;
11316 num = get_number_or_range (&state);
11319 warning (_("bad breakpoint number at or near '%s'"), p);
11323 ALL_BREAKPOINTS_SAFE (b, tmp)
11324 if (b->number == num)
11326 struct breakpoint *related_breakpoint;
11329 related_breakpoint = b;
11332 struct breakpoint *next_related_b;
11334 /* FUNCTION can be also delete_breakpoint. */
11335 next_related_b = related_breakpoint->related_breakpoint;
11336 function (related_breakpoint, data);
11338 /* For delete_breakpoint of the last entry of the ring we
11339 were traversing we would never get back to B. */
11340 if (next_related_b == related_breakpoint)
11342 related_breakpoint = next_related_b;
11344 while (related_breakpoint != b);
11348 printf_unfiltered (_("No breakpoint number %d.\n"), num);
11353 static struct bp_location *
11354 find_location_by_number (char *number)
11356 char *dot = strchr (number, '.');
11360 struct breakpoint *b;
11361 struct bp_location *loc;
11366 bp_num = get_number (&p1);
11368 error (_("Bad breakpoint number '%s'"), number);
11370 ALL_BREAKPOINTS (b)
11371 if (b->number == bp_num)
11376 if (!b || b->number != bp_num)
11377 error (_("Bad breakpoint number '%s'"), number);
11380 loc_num = get_number (&p1);
11382 error (_("Bad breakpoint location number '%s'"), number);
11386 for (;loc_num && loc; --loc_num, loc = loc->next)
11389 error (_("Bad breakpoint location number '%s'"), dot+1);
11395 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
11396 If from_tty is nonzero, it prints a message to that effect,
11397 which ends with a period (no newline). */
11400 disable_breakpoint (struct breakpoint *bpt)
11402 /* Never disable a watchpoint scope breakpoint; we want to
11403 hit them when we leave scope so we can delete both the
11404 watchpoint and its scope breakpoint at that time. */
11405 if (bpt->type == bp_watchpoint_scope)
11408 /* You can't disable permanent breakpoints. */
11409 if (bpt->enable_state == bp_permanent)
11412 bpt->enable_state = bp_disabled;
11414 update_global_location_list (0);
11416 observer_notify_breakpoint_modified (bpt);
11419 /* A callback for map_breakpoint_numbers that calls
11420 disable_breakpoint. */
11423 do_map_disable_breakpoint (struct breakpoint *b, void *ignore)
11425 disable_breakpoint (b);
11429 disable_command (char *args, int from_tty)
11433 struct breakpoint *bpt;
11435 ALL_BREAKPOINTS (bpt)
11436 if (user_breakpoint_p (bpt))
11437 disable_breakpoint (bpt);
11439 else if (strchr (args, '.'))
11441 struct bp_location *loc = find_location_by_number (args);
11444 update_global_location_list (0);
11447 map_breakpoint_numbers (args, do_map_disable_breakpoint, NULL);
11451 do_enable_breakpoint (struct breakpoint *bpt, enum bpdisp disposition)
11453 int target_resources_ok;
11455 if (bpt->type == bp_hardware_breakpoint)
11458 i = hw_breakpoint_used_count ();
11459 target_resources_ok =
11460 target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
11462 if (target_resources_ok == 0)
11463 error (_("No hardware breakpoint support in the target."));
11464 else if (target_resources_ok < 0)
11465 error (_("Hardware breakpoints used exceeds limit."));
11468 if (is_watchpoint (bpt))
11470 /* Initialize it just to avoid a GCC false warning. */
11471 enum enable_state orig_enable_state = 0;
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);